public WavLoader(Stream s)
{
while (s.Position < s.Length)
{
if ((s.Position & 1) == 1)
s.ReadByte(); // Alignment
var type = s.ReadASCII(4);
switch (type)
{
case "RIFF":
FileSize = s.ReadInt32();
Format = s.ReadASCII(4);
if (Format != "WAVE")
throw new NotSupportedException("Not a canonical WAVE file.");
break;
case "fmt ":
FmtChunkSize = s.ReadInt32();
AudioFormat = s.ReadInt16();
Type = (WaveType)AudioFormat;
if (Type != WaveType.Pcm && Type != WaveType.ImaAdpcm)
throw new NotSupportedException("Compression type is not supported.");
Channels = s.ReadInt16();
SampleRate = s.ReadInt32();
ByteRate = s.ReadInt32();
BlockAlign = s.ReadInt16();
BitsPerSample = s.ReadInt16();
s.ReadBytes(FmtChunkSize - 16);
break;
case "fact":
{
var chunkSize = s.ReadInt32();
UncompressedSize = s.ReadInt32();
s.ReadBytes(chunkSize - 4);
}
break;
case "data":
DataSize = s.ReadInt32();
RawOutput = s.ReadBytes(DataSize);
break;
default:
// Ignore unknown chunks
{
var chunkSize = s.ReadInt32();
s.ReadBytes(chunkSize);
}
break;
}
}
if (Type == WaveType.ImaAdpcm)
{
RawOutput = DecodeImaAdpcmData();
BitsPerSample = 16;
}
}
public static float WaveLength(Stream s)
{
s.Position = 12;
var fmt = s.ReadASCII(4);
if (fmt != "fmt ")
return 0;
s.Position = 22;
var channels = s.ReadInt16();
var sampleRate = s.ReadInt32();
s.Position = 34;
var bitsPerSample = s.ReadInt16();
var length = s.Length * 8;
return length / (channels * sampleRate * bitsPerSample);
}
public WavLoader(Stream s)
{
while (s.Position < s.Length)
{
if ((s.Position & 1) == 1)
s.ReadByte(); // Alignment
var type = s.ReadASCII(4);
switch (type)
{
case "RIFF":
FileSize = s.ReadInt32();
Format = s.ReadASCII(4);
if (Format != "WAVE")
throw new NotSupportedException("Not a canonical WAVE file.");
break;
case "fmt ":
FmtChunkSize = s.ReadInt32();
if (FmtChunkSize != 16)
throw new NotSupportedException("{0} fmt chunk size is not a supported encoding scheme.".F(FmtChunkSize));
AudioFormat = s.ReadInt16();
if (AudioFormat != 1)
throw new NotSupportedException("Non-PCM compression is not supported.");
Channels = s.ReadInt16();
SampleRate = s.ReadInt32();
ByteRate = s.ReadInt32();
BlockAlign = s.ReadInt16();
BitsPerSample = s.ReadInt16();
break;
case "data":
DataSize = s.ReadInt32();
RawOutput = s.ReadBytes(DataSize);
break;
default:
// Ignore unknown chunks
var chunkSize = s.ReadInt32();
s.ReadBytes(chunkSize);
break;
}
}
}
public static bool LoadSound(Stream s, out Func <Stream> result, out short channels, out int sampleBits, out int sampleRate)
{
result = null;
channels = -1;
sampleBits = -1;
sampleRate = -1;
var type = s.ReadASCII(4);
if (type != "RIFF")
{
return(false);
}
s.ReadInt32(); // File-size
var format = s.ReadASCII(4);
if (format != "WAVE")
{
return(false);
}
WaveType audioType = 0;
var dataOffset = -1L;
var dataSize = -1;
short blockAlign = -1;
int uncompressedSize = -1;
while (s.Position < s.Length)
{
if ((s.Position & 1) == 1)
{
s.ReadByte(); // Alignment
}
if (s.Position == s.Length)
{
break; // Break if we aligned with end of stream
}
var blockType = s.ReadASCII(4);
switch (blockType)
{
case "fmt ":
var fmtChunkSize = s.ReadInt32();
var audioFormat = s.ReadInt16();
audioType = (WaveType)audioFormat;
if (!Enum.IsDefined(typeof(WaveType), audioType))
{
throw new NotSupportedException("Compression type {0} is not supported.".F(audioFormat));
}
channels = s.ReadInt16();
sampleRate = s.ReadInt32();
s.ReadInt32(); // Byte Rate
blockAlign = s.ReadInt16();
sampleBits = s.ReadInt16();
s.ReadBytes(fmtChunkSize - 16);
break;
case "fact":
var chunkSize = s.ReadInt32();
uncompressedSize = s.ReadInt32();
s.ReadBytes(chunkSize - 4);
break;
case "data":
dataSize = s.ReadInt32();
dataOffset = s.Position;
s.Position += dataSize;
break;
case "LIST":
case "cue ":
var listCueChunkSize = s.ReadInt32();
s.ReadBytes(listCueChunkSize);
break;
default:
s.Position = s.Length; // Skip to end of stream
break;
}
}
if (audioType == WaveType.ImaAdpcm)
{
sampleBits = 16;
}
var chan = channels;
result = () =>
{
var audioStream = SegmentStream.CreateWithoutOwningStream(s, dataOffset, dataSize);
if (audioType == WaveType.ImaAdpcm)
{
return(new WavStream(audioStream, dataSize, blockAlign, chan, uncompressedSize));
}
return(audioStream); // Data is already PCM format.
};
return(true);
}
// TODO: Still probably needs some more work to read the pixel array properly in case of non 4-byte aligned rows
private unsafe static void GetBmpDataFromStream(Stream dataStream, byte* dataPointer, uint imageSizeInBytes)
{
// Start reading from the position of the pixel array offset information in the bitmap header
const int startOffset = 10;
dataStream.Seek(startOffset, SeekOrigin.Begin);
int pixelArrayOffset = dataStream.ReadInt32();
// Read in some data from the dib header
int dibHeaderSize = dataStream.ReadInt32();
int bitmapWidth = dataStream.ReadInt32();
int bitmapHeight = dataStream.ReadInt32();
int colorPlaneCount = dataStream.ReadInt16();
int bitsPerPixel = dataStream.ReadInt16();
Debug.Assert(colorPlaneCount == 1);
Debug.Assert(imageSizeInBytes == bitmapWidth*bitmapHeight*(bitsPerPixel>>3));
// Everything ok, time to read the actual pixel data
dataStream.Seek(pixelArrayOffset, SeekOrigin.Begin);
//dataStream.Read(dataPointer, 0, (int)imageSizeInBytes);
dataStream.ReadNoAlloc(dataPointer, 0, (int)imageSizeInBytes);
}
public TextureFooterData(Stream stream)
{
var shouldEmitDMYAtFirst = false;
var index = -1;
while (stream.Position < stream.Length)
{
++index;
var tag = Encoding.ASCII.GetString(stream.ReadBytes(4));
if (tag == "_KN5")
{
ShouldEmitDMYAtFirst = (index == 1) && shouldEmitDMYAtFirst;
ShouldEmitKN5 = true;
UnkFooter = stream.ReadBytes();
break;
}
var length = stream.ReadInt32();
var nextTag = stream.Position + length;
var subStreamPos = Convert.ToInt32(stream.Position);
if (tag == "UVSC")
{
UvscList.Add(BinaryMapping.ReadObject <UvScroll>(stream));
}
else if (tag == "TEXA")
{
var header = BinaryMapping.ReadObject <TextureAnimation>(stream);
stream.Position = subStreamPos + header.OffsetSlotTable;
header.SlotTable = Enumerable.Range(0, 1 + header.MaximumSlotIndex - header.BaseSlotIndex)
.Select(_ => stream.ReadInt16())
.ToArray();
stream.Position = subStreamPos + header.OffsetAnimationTable;
var frameGroupOffsetList = Enumerable.Range(0, header.NumAnimations)
.Select(index => stream.ReadUInt32())
.ToArray();
header.FrameGroupList = frameGroupOffsetList
.Select(
firstPosition =>
{
stream.Position = subStreamPos + firstPosition;
var indexedFrameList = new Dictionary <int, TextureFrame>();
var index = 0;
while (true)
{
if (indexedFrameList.ContainsKey(index))
{
break;
}
var frame = BinaryMapping.ReadObject <TextureFrame>(stream);
indexedFrameList[index] = frame;
if (frame.FrameControl == TextureFrameControl.Jump || frame.FrameControl == TextureFrameControl.Stop)
{
index += frame.FrameIndexDelta;
stream.Seek(TextureFrame.SizeInBytes * (-1 + frame.FrameIndexDelta), SeekOrigin.Current);
}
else
{
index++;
}
}
return(new TextureFrameGroup
{
IndexedFrameList = indexedFrameList,
});
}
)
.ToArray();
header.SpriteImage = stream
.SetPosition(subStreamPos + header.OffsetSpriteImage)
.ReadBytes(header.SpriteStride * header.SpriteHeight * header.NumSpritesInImageData);
TextureAnimationList.Add(header);
}
else if (tag == "_DMY")
{
shouldEmitDMYAtFirst |= (index == 0) ? true : false;
}
stream.Position = nextTag;
}
}
public bool LoadSound(Stream s)
{
var type = s.ReadASCII(4);
if (type != "RIFF")
{
return(false);
}
FileSize = s.ReadInt32();
Format = s.ReadASCII(4);
if (Format != "WAVE")
{
return(false);
}
while (s.Position < s.Length)
{
if ((s.Position & 1) == 1)
{
s.ReadByte(); // Alignment
}
type = s.ReadASCII(4);
switch (type)
{
case "fmt ":
FmtChunkSize = s.ReadInt32();
AudioFormat = s.ReadInt16();
Type = (WaveType)AudioFormat;
if (!Enum.IsDefined(typeof(WaveType), Type))
{
throw new NotSupportedException("Compression type {0} is not supported.".F(AudioFormat));
}
Channels = s.ReadInt16();
SampleRate = s.ReadInt32();
ByteRate = s.ReadInt32();
BlockAlign = s.ReadInt16();
BitsPerSample = s.ReadInt16();
s.ReadBytes(FmtChunkSize - 16);
break;
case "fact":
var chunkSize = s.ReadInt32();
UncompressedSize = s.ReadInt32();
s.ReadBytes(chunkSize - 4);
break;
case "data":
DataSize = s.ReadInt32();
RawOutput = s.ReadBytes(DataSize);
break;
default:
var unknownChunkSize = s.ReadInt32();
s.ReadBytes(unknownChunkSize);
break;
}
}
if (Type == WaveType.ImaAdpcm)
{
RawOutput = DecodeImaAdpcmData();
BitsPerSample = 16;
}
return(true);
}
/// <summary>
/// Reads an object from a stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <returns>Decoded object.</returns>
public static object ReadObject(this Stream stream)
{
ObjectType type = (ObjectType)stream.ReadNextByte();
switch (type)
{
case ObjectType.Null:
return(null);
case ObjectType.DBNull:
return(DBNull.Value);
case ObjectType.BooleanTrue:
return(true);
case ObjectType.BooleanFalse:
return(false);
case ObjectType.Char:
return(stream.ReadChar());
case ObjectType.SByte:
return(stream.ReadSByte());
case ObjectType.Byte:
return(stream.ReadNextByte());
case ObjectType.Int16:
return(stream.ReadInt16());
case ObjectType.UInt16:
return(stream.ReadUInt16());
case ObjectType.Int32:
return(stream.ReadInt32());
case ObjectType.UInt32:
return(stream.ReadUInt32());
case ObjectType.Int64:
return(stream.ReadInt64());
case ObjectType.UInt64:
return(stream.ReadUInt64());
case ObjectType.Single:
return(stream.ReadSingle());
case ObjectType.Double:
return(stream.ReadDouble());
case ObjectType.Decimal:
return(stream.ReadDecimal());
case ObjectType.DateTime:
return(stream.ReadDateTime());
case ObjectType.String:
return(stream.ReadString());
case ObjectType.ByteArray:
return(stream.ReadBytes());
case ObjectType.CharArray:
return(stream.ReadString().ToCharArray());
case ObjectType.Guid:
return(stream.ReadGuid());
default:
throw new ArgumentOutOfRangeException();
}
}
public static string?ReadNullableString(this Stream source)
{
return(source.ReadNullableString(source.ReadInt16()));
}
private bool ResumeTicket(IDigest hash, Stream stream, byte[] additionalChallenge)
{
// Successful Resume Session (If mode = 1)
// C => S
// byte ChallengeLength
// byte[] A = Challenge
// int16 TicketLength
// byte[] Ticket
// C <= S
// bool IsSuccess = true
// byte HashMethod
// byte ChallengeLength
// byte[] B = Challenge
// C => S
// byte[] M1 = H(A | B | SessionKey)
// Bool Success (if false, done)
// C <= S
// byte[] M2 = H(B | A | SessionKey)
// Failed Resume Session
// C => S
// byte ChallengeLength
// byte[] A = Challenge
// int16 TicketLength
// byte[] Ticket
// C <= S
// bool IsSuccess = false
// Goto Authenticate Code
byte[] a = stream.ReadBytes(stream.ReadNextByte());
int ticketLength = stream.ReadInt16();
if (ticketLength < 0 || ticketLength > 10000)
{
return(false);
}
byte[] ticket = stream.ReadBytes(ticketLength);
if (TryLoadTicket(ticket, m_user, out SessionSecret))
{
stream.Write(true);
stream.WriteByte((byte)SrpHashMethod);
byte[] b = SaltGenerator.Create(16);
stream.WriteByte(16);
stream.Write(b);
stream.Flush();
byte[] clientProofCheck = hash.ComputeHash(a, b, SessionSecret, additionalChallenge);
byte[] serverProof = hash.ComputeHash(b, a, SessionSecret, additionalChallenge);
byte[] clientProof = stream.ReadBytes(hash.GetDigestSize());
if (clientProof.SecureEquals(clientProofCheck))
{
stream.Write(true);
stream.Write(serverProof);
stream.Flush();
return(true);
}
stream.Write(false);
return(false);
}
stream.Write(false);
return(StandardAuthentication(hash, stream, additionalChallenge));
}
public static WAV.Header ReadWAVHeader(this Stream IO)
{
WAV.Header Header = new WAV.Header();
if (IO.ReadString(4) != "RIFF")
{
return(Header);
}
IO.ReadUInt32();
if (IO.ReadString(4) != "WAVE")
{
return(Header);
}
if (IO.ReadString(4) != "fmt ")
{
return(Header);
}
int Offset = IO.ReadInt32();
Header.Format = IO.ReadUInt16();
if (Header.Format == 0x01 || Header.Format == 0x03 || Header.Format == 0xFFFE)
{
Header.Channels = IO.ReadUInt16();
Header.SampleRate = IO.ReadUInt32();
IO.ReadInt32(); IO.ReadInt16();
Header.Bytes = IO.ReadUInt16();
if (Header.Bytes % 8 != 0)
{
return(Header);
}
Header.Bytes >>= 3;
if (Header.Bytes == 0)
{
return(Header);
}
if (Header.Format == 0xFFFE)
{
IO.ReadInt32();
Header.ChannelMask = IO.ReadUInt32();
Header.Format = IO.ReadUInt16();
}
if (Header.Bytes < 1 || (Header.Bytes > 4 && Header.Bytes != 8))
{
return(Header);
}
if (Header.Bytes > 0 && Header.Bytes < 4 && Header.Format == 3)
{
return(Header);
}
if (Header.Bytes == 8 && Header.Format == 1)
{
return(Header);
}
IO.Seek(Offset + 0x14, 0);
if (IO.ReadString(4) != "data")
{
return(Header);
}
Header.Size = IO.ReadUInt32();
Header.HeaderSize = IO.UIntPosition;
Header.IsSupported = true;
return(Header);
}
return(Header);
}
public void BINReader(string file)
{
/*Stream IO0 = File.OpenReader(file + "0.bin");
* Stream IO1 = File.OpenReader(file + "1.bin");
*
* List<int> _0 = new List<int>();
* List<int> _1 = new List<int>();
* IO0.Position = 0x20;
* for (i = 0; i < 124; i++)
* { _0.Add(IO0.ReadInt32()); IO0.LongPosition += 8; }
* IO1.Position = 0x20;
* for (i = 0; i < 124; i++)
* { _1.Add(IO1.ReadInt32()); IO1.LongPosition += 8; }
* IO0.Close();
* IO1.Close();
*
* IO = File.OpenWriter(@"F:\Source\MikuMikuModel\DatabaseConverter\msgpack-json-tools\aet_gam_pv643.bin");
* IO.Position = 0x10;
* for (i = 0; i < 108; i++)
* { IO.ReadInt32(); i1 = _1[_0.IndexOf(IO.ReadInt32())]; IO.Position -= 4; IO.Write(i1); }
* IO.Close();*/
IO = File.OpenReader(file + ".bin");
int spriteSetsLength = IO.ReadInt32();
int spriteSetsOffset = IO.ReadInt32();
int spritesLength = IO.ReadInt32();
int spritesOffset = IO.ReadInt32();
IO.Position = spriteSetsOffset;
SpriteSets = new SpriteSet[spriteSetsLength];
for (i = 0; i < spriteSetsLength; i++)
{
SpriteSets[i].Id = IO.ReadInt32();
SpriteSets[i].Name = IO.ReadStringAtOffset();
SpriteSets[i].FileName = IO.ReadStringAtOffset();
IO.ReadInt32();
}
int setIndex;
bool IsTexture;
SpriteTexture st = new SpriteTexture();
int[] SprCount = new int[spriteSetsLength];
int[] TexCount = new int[spriteSetsLength];
IO.Position = spritesOffset;
for (i = 0; i < spritesLength; i++)
{
IO.LongPosition += 10;
setIndex = IO.ReadInt16();
IsTexture = (setIndex & 0x1000) == 0x1000;
setIndex &= 0xFFF;
if (IsTexture)
{
TexCount[setIndex]++;
}
else
{
SprCount[setIndex]++;
}
}
for (int i = 0; i < spriteSetsLength; i++)
{
SpriteSets[i].Sprites = new SpriteTexture[SprCount[i]];
SpriteSets[i].Textures = new SpriteTexture[TexCount[i]];
SprCount[i] = 0;
TexCount[i] = 0;
}
IO.Position = spritesOffset;
for (i = 0; i < spritesLength; i++)
{
st.Id = IO.ReadInt32();
st.Name = IO.ReadStringAtOffset();
IO.ReadInt16();
setIndex = IO.ReadInt16();
IsTexture = (setIndex & 0x1000) == 0x1000;
setIndex &= 0xFFF;
if (IsTexture)
{
SpriteSets[setIndex].Textures[TexCount[setIndex]] = st; TexCount[setIndex]++;
}
else
{
SpriteSets[setIndex].Sprites[SprCount[setIndex]] = st; SprCount[setIndex]++;
}
}
IO.Close();
}
public void Read(Stream source)
{
this.ApiKey = source.ReadInt16();
this.MinVersion = source.ReadInt16();
this.MaxVersion = source.ReadInt16();
}
private static object ReadObject(Stream stream, object instance, BinaryMemberAttribute attribute,
Type type, ByteConverter converter)
{
if (attribute.Converter == null)
{
if (type == typeof(String))
{
if (attribute.StringFormat == StringCoding.Raw)
{
return(stream.ReadString(attribute.Length));
}
else
{
return(stream.ReadString(attribute.StringFormat, converter: converter));
}
}
else if (type.IsEnumerable())
{
throw new InvalidOperationException("Multidimensional arrays cannot be read directly.");
}
else if (type == typeof(Boolean))
{
return(stream.ReadBoolean(attribute.BooleanFormat));
}
else if (type == typeof(Byte))
{
return(stream.Read1Byte());
}
else if (type == typeof(DateTime))
{
return(stream.ReadDateTime(attribute.DateTimeFormat, converter));
}
else if (type == typeof(Decimal))
{
return(stream.ReadDecimal());
}
else if (type == typeof(Double))
{
return(stream.ReadDouble(converter));
}
else if (type == typeof(Int16))
{
return(stream.ReadInt16(converter));
}
else if (type == typeof(Int32))
{
return(stream.ReadInt32(converter));
}
else if (type == typeof(Int64))
{
return(stream.ReadInt64(converter));
}
else if (type == typeof(SByte))
{
return(stream.ReadSByte());
}
else if (type == typeof(Single))
{
return(stream.ReadSingle(converter));
}
else if (type == typeof(UInt16))
{
return(stream.ReadUInt16(converter));
}
else if (type == typeof(UInt32))
{
return(stream.ReadUInt32(converter));
}
else if (type == typeof(UInt64))
{
return(stream.ReadUInt64(converter));
}
else if (type.IsEnum)
{
return(ReadEnum(stream, type, attribute.Strict, converter));
}
else
{
if (stream.CanSeek)
{
return(ReadCustomObject(stream, type, null, stream.Position, converter));
}
else
{
return(ReadCustomObject(stream, type, null, -1, converter));
}
}
}
else
{
// Let a binary converter do all the work.
IBinaryConverter binaryConverter = BinaryConverterCache.GetConverter(attribute.Converter);
return(binaryConverter.Read(stream, instance, attribute, converter));
}
}
private bool Authenticate(Stream stream, byte[] additionalChallenge)
{
HashMethod passwordHashMethod = (HashMethod)stream.ReadNextByte();
byte[] salt = stream.ReadBytes(stream.ReadNextByte());
int iterations = stream.ReadInt32();
SetHashMethod((HashMethod)stream.ReadNextByte());
SetSrpStrength((SrpStrength)stream.ReadInt32());
m_credentials.TryUpdate(passwordHashMethod, salt, iterations);
BigInteger pubA = m_client.GenerateClientCredentials(m_hash, salt, m_credentials.UsernameBytes, m_credentials.SaltedPassword);
byte[] pubABytes = pubA.ToPaddedArray(m_srpByteLength);
stream.Write(pubABytes);
stream.Flush();
//Read from Server: B
byte[] pubBBytes = stream.ReadBytes(m_srpByteLength);
BigInteger pubB = new BigInteger(1, pubBBytes);
//Calculate Session Key
BigInteger S = m_client.CalculateSecret(m_hash, pubB);
byte[] SBytes = S.ToPaddedArray(m_srpByteLength);
byte[] clientProof = m_hash.ComputeHash(pubABytes, pubBBytes, SBytes, additionalChallenge);
stream.Write(clientProof);
stream.Flush();
byte[] serverProof = m_hash.ComputeHash(pubBBytes, pubABytes, SBytes, additionalChallenge);
if (stream.ReadBoolean())
{
byte[] serverProofCheck = stream.ReadBytes(m_hash.GetDigestSize());
int ticketLength = stream.ReadInt16();
if (ticketLength < 0 || ticketLength > 10000)
return false;
if (serverProofCheck.SecureEquals(serverProof))
{
m_resumeTicket = stream.ReadBytes(ticketLength);
m_sessionSecret = m_hash.ComputeHash(pubABytes, SBytes, pubBBytes).Combine(m_hash.ComputeHash(pubBBytes, SBytes, pubABytes));
return true;
}
return false;
}
return false;
}
public override short Short() => Stream.ReadInt16();
public static object Read(Stream stream)
{
return stream.ReadInt16();
}
public static object Read(Stream stream)
{
return(stream.ReadInt16());
}
private static MidHeader ReadHeader(Stream s)
{
if (!s.Read(4).SequenceEqual(new byte[] { 0x4D, 0x54, 0x68, 0x64 }))
{
throw new InvalidDataException("不是有效的mid文件");
}
s.ReadInt32();
var header = new MidHeader();
header.FormatType = s.ReadInt16();
header.TrackCount = s.ReadInt16();
header.TicksPerBeat = s.ReadInt16();
if ((header.TicksPerBeat & 0x8000) != 0)
{
throw new InvalidDataException("不支持SMTPE时间格式");
}
return header;
}
public static void ReadMeshData(Stream stream, Pmo pmo, int MeshNumber = 0)
{
// Go to mesh position.
if (MeshNumber == 0)
{
stream.Seek(pmo.PMO_StartPosition + pmo.header.MeshOffset0, SeekOrigin.Begin);
}
else
{
stream.Seek(pmo.PMO_StartPosition + pmo.header.MeshOffset1, SeekOrigin.Begin);
}
UInt16 VertCnt = 0xFFFF;
while (VertCnt > 0)
{
MeshChunks meshChunk = new MeshChunks();
meshChunk.MeshNumber = MeshNumber;
meshChunk.SectionInfo = Mapping.ReadObject <MeshSection>(stream);
// Exit if Vertex Count is zero.
if (meshChunk.SectionInfo.VertexCount <= 0)
{
break;
}
meshChunk.TextureID = meshChunk.SectionInfo.TextureID;
VertexFlags flags = GetFlags(meshChunk.SectionInfo);
bool isColorFlagRisen = flags.UniformDiffuseFlag;
if (pmo.header.SkeletonOffset != 0)
{
meshChunk.SectionInfo_opt1 = Mapping.ReadObject <MeshSectionOptional1>(stream);
}
if (isColorFlagRisen)
{
meshChunk.SectionInfo_opt2 = Mapping.ReadObject <MeshSectionOptional2>(stream);
}
if (meshChunk.SectionInfo.TriangleStripCount > 0)
{
meshChunk.TriangleStripValues = new UInt16[meshChunk.SectionInfo.TriangleStripCount];
for (int i = 0; i < meshChunk.SectionInfo.TriangleStripCount; i++)
{
meshChunk.TriangleStripValues[i] = stream.ReadUInt16();
}
}
// Get Formats.
CoordinateFormat TexCoordFormat = flags.TextureCoordinateFormat;
CoordinateFormat VertexPositionFormat = flags.PositionFormat;
CoordinateFormat WeightFormat = flags.WeightFormat;
ColorFormat ColorFormat = flags.ColorFormat;
UInt32 SkinningWeightsCount = flags.SkinningWeightsCount;
BinaryReader r = new BinaryReader(stream);
long positionAfterHeader = stream.Position;
if (meshChunk.SectionInfo.TriangleStripCount > 0)
{
int vertInd = 0;
for (int p = 0; p < meshChunk.SectionInfo.TriangleStripCount; p++)
{
for (int s = 0; s < (meshChunk.TriangleStripValues[p] - 2); s++)
{
if (s % 2 == 0)
{
meshChunk.Indices.Add(vertInd + s + 0);
meshChunk.Indices.Add(vertInd + s + 1);
meshChunk.Indices.Add(vertInd + s + 2);
}
else
{
meshChunk.Indices.Add(vertInd + s + 0);
meshChunk.Indices.Add(vertInd + s + 2);
meshChunk.Indices.Add(vertInd + s + 1);
}
}
vertInd += meshChunk.TriangleStripValues[p];
}
}
else
{
if (flags.Primitive == PrimitiveType.PRIMITIVE_TRIANGLE_STRIP)
{
for (int s = 0; s < (meshChunk.SectionInfo.VertexCount - 2); s++)
{
if (s % 2 == 0)
{
meshChunk.Indices.Add(s + 0);
meshChunk.Indices.Add(s + 1);
meshChunk.Indices.Add(s + 2);
}
else
{
meshChunk.Indices.Add(s + 1);
meshChunk.Indices.Add(s + 0);
meshChunk.Indices.Add(s + 2);
}
}
}
}
for (int v = 0; v < meshChunk.SectionInfo.VertexCount; v++)
{
long vertexStartPos = stream.Position;
int vertexIncreaseAmount = 0;
// Vertex Weights.
if (pmo.header.SkeletonOffset != 0 && WeightFormat != CoordinateFormat.NO_VERTEX)
{
WeightData WeightList = new WeightData();
WeightList.weights = new List <float>();
WeightList.coordFormart = WeightFormat;
for (int i = 0; i < (SkinningWeightsCount + 1); i++)
{
switch (WeightFormat)
{
case CoordinateFormat.NORMALIZED_8_BITS:
WeightList.weights.Add(stream.ReadByte() / 128.0f);
break;
case CoordinateFormat.NORMALIZED_16_BITS:
WeightList.weights.Add(stream.ReadUInt16() / 32768.0f);
break;
case CoordinateFormat.FLOAT_32_BITS:
WeightList.weights.Add(stream.ReadFloat());
break;
case CoordinateFormat.NO_VERTEX:
break;
}
}
meshChunk.jointWeights.Add(WeightList);
}
Vector2 currentTexCoord = new Vector2(0, 0);
switch (TexCoordFormat)
{
case CoordinateFormat.NORMALIZED_8_BITS:
currentTexCoord.X = stream.ReadByte() / 128.0f;
currentTexCoord.Y = stream.ReadByte() / 128.0f;
meshChunk.textureCoordinates.Add(currentTexCoord);
break;
case CoordinateFormat.NORMALIZED_16_BITS:
vertexIncreaseAmount = ((0x2 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x1)) & 0x1);
stream.Seek(vertexIncreaseAmount, SeekOrigin.Current);
currentTexCoord.X = stream.ReadUInt16() / 32768.0f;
currentTexCoord.Y = stream.ReadUInt16() / 32768.0f;
meshChunk.textureCoordinates.Add(currentTexCoord);
break;
case CoordinateFormat.FLOAT_32_BITS:
vertexIncreaseAmount = ((0x4 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x3)) & 0x3);
stream.Seek(vertexIncreaseAmount, SeekOrigin.Current);
currentTexCoord.X = stream.ReadFloat();
currentTexCoord.Y = stream.ReadFloat();
meshChunk.textureCoordinates.Add(currentTexCoord);
break;
case CoordinateFormat.NO_VERTEX:
meshChunk.textureCoordinates.Add(currentTexCoord);
break;
}
Vector4 col;
if (isColorFlagRisen)
{
uint c = meshChunk.SectionInfo_opt2.DiffuseColor;
col.X = c % 0x100;
col.Y = (c >> 8) % 0x100;
col.Z = (c >> 16) % 0x100;
col.W = (c >> 24) % 0x100;
meshChunk.colors.Add(col);
}
else
{
switch (ColorFormat)
{
case Pmo.ColorFormat.NO_COLOR:
meshChunk.colors.Add(new Vector4(0xFF, 0xFF, 0xFF, 0xFF));
break;
case Pmo.ColorFormat.BGR_5650_16BITS:
stream.ReadUInt16();
break;
case Pmo.ColorFormat.ABGR_5551_16BITS:
stream.ReadUInt16();
break;
case Pmo.ColorFormat.ABGR_4444_16BITS:
stream.ReadUInt16();
break;
case Pmo.ColorFormat.ABGR_8888_32BITS:
vertexIncreaseAmount = ((0x4 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x3)) & 0x3);
stream.Seek(vertexIncreaseAmount, SeekOrigin.Current);
col.X = stream.ReadByte();
col.Y = stream.ReadByte();
col.Z = stream.ReadByte();
col.W = stream.ReadByte();
meshChunk.colors.Add(col);
break;
}
}
Vector3 currentVertex;
// Handle triangles and triangle strips.
switch (VertexPositionFormat)
{
case CoordinateFormat.NORMALIZED_8_BITS:
currentVertex.X = r.ReadSByte() / 128.0f;
currentVertex.Y = r.ReadSByte() / 128.0f;
currentVertex.Z = r.ReadSByte() / 128.0f;
meshChunk.vertices.Add(currentVertex);
break;
case CoordinateFormat.NORMALIZED_16_BITS:
vertexIncreaseAmount = ((0x2 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x1)) & 0x1);
stream.Seek(vertexIncreaseAmount, SeekOrigin.Current);
currentVertex.X = (float)stream.ReadInt16() / 32768.0f;
currentVertex.Y = (float)stream.ReadInt16() / 32768.0f;
currentVertex.Z = (float)stream.ReadInt16() / 32768.0f;
meshChunk.vertices.Add(currentVertex);
break;
case CoordinateFormat.FLOAT_32_BITS:
vertexIncreaseAmount = ((0x4 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x3)) & 0x3);
stream.Seek(vertexIncreaseAmount, SeekOrigin.Current);
currentVertex.X = stream.ReadFloat();
currentVertex.Y = stream.ReadFloat();
currentVertex.Z = stream.ReadFloat();
meshChunk.vertices.Add(currentVertex);
break;
}
stream.Seek(vertexStartPos + meshChunk.SectionInfo.VertexSize, SeekOrigin.Begin);
if (flags.Primitive == PrimitiveType.PRIMITIVE_TRIANGLE)
{
meshChunk.Indices.Add(v);
}
}
VertCnt = meshChunk.SectionInfo.VertexCount;
pmo.Meshes.Add(meshChunk);
// Find position of next data chunk.
stream.Seek(positionAfterHeader + (meshChunk.SectionInfo.VertexCount * meshChunk.SectionInfo.VertexSize), SeekOrigin.Begin);
stream.Seek(stream.Position % 4, SeekOrigin.Current);
}
}
public bool LoadSound(Stream s)
{
var type = s.ReadASCII(4);
if (type != "RIFF")
return false;
FileSize = s.ReadInt32();
Format = s.ReadASCII(4);
if (Format != "WAVE")
return false;
while (s.Position < s.Length)
{
if ((s.Position & 1) == 1)
s.ReadByte(); // Alignment
type = s.ReadASCII(4);
switch (type)
{
case "fmt ":
FmtChunkSize = s.ReadInt32();
AudioFormat = s.ReadInt16();
Type = (WaveType)AudioFormat;
if (!Enum.IsDefined(typeof(WaveType), Type))
throw new NotSupportedException("Compression type {0} is not supported.".F(AudioFormat));
Channels = s.ReadInt16();
SampleRate = s.ReadInt32();
ByteRate = s.ReadInt32();
BlockAlign = s.ReadInt16();
BitsPerSample = s.ReadInt16();
s.ReadBytes(FmtChunkSize - 16);
break;
case "fact":
var chunkSize = s.ReadInt32();
UncompressedSize = s.ReadInt32();
s.ReadBytes(chunkSize - 4);
break;
case "data":
DataSize = s.ReadInt32();
RawOutput = s.ReadBytes(DataSize);
break;
default:
var unknownChunkSize = s.ReadInt32();
s.ReadBytes(unknownChunkSize);
break;
}
}
if (Type == WaveType.ImaAdpcm)
{
RawOutput = DecodeImaAdpcmData();
BitsPerSample = 16;
}
return true;
}
public static Int32 ReadInt32(this Stream s)
{
return((Int32)(s.ReadInt16() | (s.ReadInt16() << 16)));
}
public static ErrorCode ReadErrorCode(this Stream source) => (ErrorCode)source.ReadInt16();
public static ushort ReadUInt16(this Stream s)
{
return((ushort)s.ReadInt16());
}
public void Unpack(Stream stream)
{
var flags = (BitsByte)stream.ReadInt8();
var flags2 = (BitsByte)stream.ReadInt8();
Wire2 = flags2[0];
Wire3 = flags2[1];
Slope = flags2[4];
Slope2 = flags2[5];
Slope3 = flags2[6];
if (flags2[2])
{
TileColor = stream.ReadInt8();
}
if (flags2[3])
{
WallColor = stream.ReadInt8();
}
Active = flags[0];
if (Active)
{
Type = stream.ReadUInt16();
if (FrameImportant)
{
FrameX = stream.ReadInt16();
FrameY = stream.ReadInt16();
}
}
if (flags[2])
{
Wall = stream.ReadInt8();
}
if (flags[3])
{
Liquid = stream.ReadInt8();
LiquidType = stream.ReadInt8();
}
if (flags[4])
{
Wire = true;
}
if (flags[5])
{
IsHalf = true;
}
if (flags[6])
{
IsActuator = true;
}
if (flags[7])
{
Inactive = true;
Active = false;
}
}
public static UInt16 ReadUInt16(this Stream s)
{
return((UInt16)s.ReadInt16());
}
public BitmapFont(Canvas canvas, string path)
{
this.canvas = canvas;
#if UNCOMPRESSED_CONTENT
string png = PathOp.Combine(DualityApp.DataDirectory, "Animations", path + ".png");
#else
string png = PathOp.Combine(DualityApp.DataDirectory, "Main.dz", "Animations", path + ".png");
#endif
string pathFont = png + ".font";
int textureHeight;
using (Stream s = FileOp.Open(png, FileAccessMode.Read)) {
PixelData pixelData = new Png(s).GetPixelData();
textureHeight = pixelData.Height;
ColorRgba[] palette = ContentResolver.Current.Palette.Res.BasePixmap.Res.MainLayer.Data;
ColorRgba[] data = pixelData.Data;
#if !DISABLE_ASYNC
Parallel.ForEach(Partitioner.Create(0, data.Length), range => {
for (int i = range.Item1; i < range.Item2; i++) {
#else
for (int i = 0; i < data.Length; i++) {
#endif
int colorIdx = data[i].R;
data[i] = palette[colorIdx].WithAlpha(palette[colorIdx].A * data[i].A / (255f * 255f));
}
#if !DISABLE_ASYNC
});
#endif
Texture texture = new Texture(new Pixmap(pixelData), TextureSizeMode.NonPowerOfTwo, TextureMagFilter.Linear, TextureMinFilter.Linear);
materialPlain = new Material(DrawTechnique.Alpha, texture);
materialColor = new Material(ContentResolver.Current.RequestShader("Colorize"), texture);
}
using (Stream s = FileOp.Open(pathFont, FileAccessMode.Read)) {
byte[] internalBuffer = new byte[128];
byte flags = s.ReadUInt8(ref internalBuffer);
ushort width = s.ReadUInt16(ref internalBuffer);
ushort height = s.ReadUInt16(ref internalBuffer);
byte cols = s.ReadUInt8(ref internalBuffer);
int rows = textureHeight / height;
short spacing = s.ReadInt16(ref internalBuffer);
int asciiFirst = s.ReadUInt8(ref internalBuffer);
int asciiCount = s.ReadUInt8(ref internalBuffer);
s.Read(internalBuffer, 0, asciiCount);
int i = 0;
for (; i < asciiCount; i++) {
asciiChars[i + asciiFirst] = new Rect(
(float)(i % cols) / cols,
(float)(i / cols) / rows,
internalBuffer[i],
height);
}
UTF8Encoding enc = new UTF8Encoding(false, true);
int unicodeCharCount = asciiCount + s.ReadInt32(ref internalBuffer);
for (; i < unicodeCharCount; i++) {
s.Read(internalBuffer, 0, 1);
int remainingBytes =
((internalBuffer[0] & 240) == 240) ? 3 : (
((internalBuffer[0] & 224) == 224) ? 2 : (
((internalBuffer[0] & 192) == 192) ? 1 : -1
));
if (remainingBytes == -1) {
throw new InvalidDataException("Char \"" + (char)internalBuffer[0] + "\" is not UTF-8");
}
s.Read(internalBuffer, 1, remainingBytes);
char c = enc.GetChars(internalBuffer, 0, remainingBytes + 1)[0];
byte charWidth = s.ReadUInt8(ref internalBuffer);
unicodeChars[c] = new Rect(
(float)(i % cols) / cols,
(float)(i / cols) / rows,
charWidth,
height);
}
this.charHeight = height;
this.baseSpacing = spacing;
}
}
public int WAVReaderStraight(string file, bool ExtendedFlagging = false)
{
Success = false;
VAGData = new VAGFile();
Stream reader = File.OpenReader(file + ".wav");
WAV.Header Header = reader.ReadWAVHeader();
if (!Header.IsSupported)
{
reader.Close(); return(1);
}
ch = Header.Channels;
VBS = BS * ch;
VAGData.Size = Header.Size / Header.Bytes;
VAGData.Data = new int[VAGData.Size.Align(VBS)];
VAGData.DataPtr = VAGData.Data.GetPtr();
VAGData.OriginDataPtr = VAGData.DataPtr;
if (Header.Bytes == 1 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = (reader.ReadByte() - 0x80) << 16;
}
}
else if (Header.Bytes == 2 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = reader.ReadInt16() << 8;
}
}
else if (Header.Bytes == 3 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = reader.ReadByte() | (reader.ReadInt16() << 8);
}
}
else if (Header.Bytes == 4 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = reader.ReadInt32() >> 8;
}
}
else if (Header.Bytes == 4 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = (int)(reader.ReadSingle() * 8388608.0);
}
}
else if (Header.Bytes == 8 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = (int)(reader.ReadDouble() * 8388608.0);
}
}
VAGData.Size = VAGData.Size.Align(VBS, VBS);
VAGData.DataPtr = VAGData.OriginDataPtr;
VAGData.Channels = ch;
VAGData.SampleRate = Header.SampleRate;
VAGData.Flags = new byte[VAGData.Size];
if (ExtendedFlagging)
{
VAGData.Flags[0] = 0x4;
}
VAGData.Flags[VAGData.Size - 1] = 0x1;
reader.Close();
Success = true;
return(0);
}
protected override bool BufferData(Stream baseStream, Queue <byte> data)
{
// Decode each block of IMA ADPCM data
// Each block starts with a initial state per-channel
for (var c = 0; c < channels; c++)
{
predictor[c] = baseStream.ReadInt16();
index[c] = baseStream.ReadUInt8();
baseStream.ReadUInt8(); // Unknown/Reserved
// Output first sample from input
data.Enqueue((byte)predictor[c]);
data.Enqueue((byte)(predictor[c] >> 8));
outOffset += 2;
if (outOffset >= outputSize)
{
return(true);
}
}
// Decode and output remaining data in this block
var blockOffset = 0;
while (blockOffset < blockDataSize)
{
for (var c = 0; c < channels; c++)
{
// Decode 4 bytes (to 16 bytes of output) per channel
var chunk = baseStream.ReadBytes(4);
var decoded = ImaAdpcmReader.LoadImaAdpcmSound(chunk, ref index[c], ref predictor[c]);
// Interleave output, one sample per channel
var interleaveChannelOffset = 2 * c;
for (var i = 0; i < decoded.Length; i += 2)
{
var interleaveSampleOffset = interleaveChannelOffset + i;
interleaveBuffer[interleaveSampleOffset] = decoded[i];
interleaveBuffer[interleaveSampleOffset + 1] = decoded[i + 1];
interleaveChannelOffset += 2 * (channels - 1);
}
blockOffset += 4;
}
var outputRemaining = outputSize - outOffset;
var toCopy = Math.Min(outputRemaining, interleaveBuffer.Length);
for (var i = 0; i < toCopy; i++)
{
data.Enqueue(interleaveBuffer[i]);
}
outOffset += 16 * channels;
if (outOffset >= outputSize)
{
return(true);
}
}
return(++currentBlock >= numBlocks);
}
public static T ReadValueEnum <T>(this Stream stream, Endian endian)
{
var type = typeof(T);
object value;
switch (EnumTypeCache.Get(type))
{
case TypeCode.SByte:
{
value = (sbyte)stream.ReadByte();
break;
}
case TypeCode.Byte:
{
value = stream.ReadByte();
break;
}
case TypeCode.Int16:
{
value = stream.ReadInt16();
break;
}
case TypeCode.UInt16:
{
value = stream.ReadUInt16();
break;
}
case TypeCode.Int32:
{
value = stream.ReadInt32();
break;
}
case TypeCode.UInt32:
{
value = stream.ReadUInt32();
break;
}
case TypeCode.Int64:
{
value = stream.ReadInt64();
break;
}
case TypeCode.UInt64:
{
value = stream.ReadUInt64();
break;
}
default:
{
throw new NotSupportedException();
}
}
return((T)Enum.ToObject(type, value));
}
public void Unpack(Stream stream)
{
var flags = (BitsByte) stream.ReadInt8();
var flags2 = (BitsByte)stream.ReadInt8();
Wire2 = flags2[0];
Wire3 = flags2[1];
Slope = flags2[4];
Slope2 = flags2[5];
Slope3 = flags2[6];
if (flags2[2])
{
TileColor = stream.ReadInt8();
}
if (flags2[3])
{
WallColor = stream.ReadInt8();
}
Active = flags[0];
if (Active)
{
Type = stream.ReadUInt16();
if (FrameImportant)
{
FrameX = stream.ReadInt16();
FrameY = stream.ReadInt16();
}
}
if (flags[2])
{
Wall = stream.ReadInt8();
}
if (flags[3])
{
Liquid = stream.ReadInt8();
LiquidType = stream.ReadInt8();
}
if (flags[4])
Wire = true;
if (flags[5])
IsHalf = true;
if (flags[6])
IsActuator = true;
if (flags[7])
{
Inactive = true;
Active = false;
}
}
public static float ReadHalf(this Stream stream)
{
var aShort = stream.ReadInt16();
return((float)(((aShort & 0x8000) << 16) + ((aShort & 0x7FFF) << 13) + ((127 - 15) << 23)));
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
// RVAD/RVA2
/*Double original = -65534;
Double newVal = Math.Log10(1 + original/65535.0)*20.0*512.0;
Double original2 = Math.Pow(10, newVal/(20.0*512.0));
original2 = original2 - 1;
original2 *= 65535.0;*/
/*Double original = 10000;
Double newVal = Math.Log10(1 + original / 65535.0);
Double original2 = Math.Pow(10, newVal);
original2 = original2 - 1;
original2 *= 65535.0;*/
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
// todo: there needs to be some kind of a test to see if this is RVAD/RVA2 format, too
// much varying implementation in 2.3 and 2.4
bool isRVA2 = (_frameHeader.TagVersion == ID3v2TagVersion.ID3v24);
if (isRVA2)
{
// sometimes "identification" is completely ommitted... grr
Identification = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
while (bytesLeft >= 3)
{
// TODO: Implementation not complete
byte channelType = stream.Read1(ref bytesLeft);
//if (channelType == 16) break; // Invalid, probably stored as an ID3v2.3 RVAD frame
// TODO: some kind of switch.. maybe a new internal enum
short volumeAdjustment = stream.ReadInt16(ref bytesLeft);
if (bytesLeft > 0)
{
// sometimes represented as BITS representing peak.. seriously.
byte bytesRepresentingPeak = stream.Read1(ref bytesLeft);
if (bytesRepresentingPeak == 0) break;
if (bytesLeft >= bytesRepresentingPeak)
{
// TODO: Finish implementation
byte[] peakVolume = stream.Read(bytesRepresentingPeak);
bytesLeft -= peakVolume.Length;
}
else
{
break;
}
}
}
if (bytesLeft > 0)
{
//Trace.WriteLine("Invalid RVA2 frame");
//stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
// Try to read it like an ID3v2.3 RVAD frame
stream.Seek(bytesLeft - _frameHeader.FrameSizeExcludingAdditions, SeekOrigin.Current);
bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
isRVA2 = false;
}
else
{
// TODO
//MessageBox.Show("valid RVA2 frame, omg!");
}
}
// ID3v2.2, ID3v2.3, or mal-formed ID3v2.4
if (isRVA2 == false)
{
byte incrementDecrement = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
byte bitsUsedForVolumeDescription = stream.Read1(ref bytesLeft);
int bytesUsedForVolumeDescription = bitsUsedForVolumeDescription / 8;
// TODO: (may be useful for testing which implementation)
// if bits used for volume description is > 64, don't bother
// Relative volume change, right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 0) ? 1 : -1);
}
// Relative volume change, left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 1) ? 1 : -1);
}
// Peak volume right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 2) ? 1 : -1);
}
// Relative volume change, left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 3) ? 1 : -1);
}
// Peak volume right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 4) ? 1 : -1);
}
// Peak volume center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 5) ? 1 : -1);
}
// Peak volume bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferPeak = ByteUtils.ConvertToInt64(byteArray);
}
}
}
// Skip past the rest of the frame
if (bytesLeft > 0)
{
Trace.WriteLine("Invalid RVA2/RVAD/RVA frame");
stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
}
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
OwnerIdentifier = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft >= 4)
{
PreviewStart = stream.ReadInt16(ref bytesLeft);
PreviewLength = stream.ReadInt16(ref bytesLeft);
if (bytesLeft > 0)
{
EncryptionInfo = stream.Read(bytesLeft);
bytesLeft = 0;
}
else
{
// Incomplete frame
EncryptionInfo = null;
}
}
else
{
// Incomplete frame
PreviewStart = 0;
PreviewLength = 0;
EncryptionInfo = null;
}
}
else
{
// Incomplete frame
OwnerIdentifier = null;
PreviewStart = 0;
PreviewLength = 0;
EncryptionInfo = null;
}
// Seek to end of frame
if (bytesLeft != 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public void Unpack(Stream stream)
{
var flags = (TileFlags) stream.ReadInt8();
var flags2 = (TileFlags2)stream.ReadInt8();
Wire2 = flags2.HasFlag(TileFlags2.Wire2);
Wire3 = flags2.HasFlag(TileFlags2.Wire3);
Slope = flags2.HasFlag(TileFlags2.Slope);
Slope2 = flags2.HasFlag(TileFlags2.Slope2);
if (flags2.HasFlag(TileFlags2.Color))
{
TileColor = stream.ReadInt8();
}
if (flags2.HasFlag(TileFlags2.WallColor))
{
WallColor = stream.ReadInt8();
}
Active = flags.HasFlag(TileFlags.Active);
if (Active)
{
Type = stream.ReadInt8();
if (FrameImportant)
{
FrameX = stream.ReadInt16();
FrameY = stream.ReadInt16();
}
}
if (flags.HasFlag(TileFlags.Lighted))
{
Lighted = true;
}
if (flags.HasFlag(TileFlags.Wall))
{
Wall = stream.ReadInt8();
}
if (flags.HasFlag(TileFlags.Liquid))
{
Liquid = stream.ReadInt8();
LiquidType = stream.ReadInt8();
}
if (flags.HasFlag(TileFlags.Wire))
Wire = true;
if (flags.HasFlag(TileFlags.HalfBrick))
IsHalf = true;
if (flags.HasFlag(TileFlags.Actuator))
IsActuator = true;
if (flags.HasFlag(TileFlags.Inactive))
{
Inactive = true;
Active = false;
}
}
private bool ResumeTicket(IDigest hash, Stream stream, byte[] additionalChallenge)
{
// Successful Resume Session (If mode = 1)
// C => S
// byte ChallengeLength
// byte[] A = Challenge
// int16 TicketLength
// byte[] Ticket
// C <= S
// bool IsSuccess = true
// byte HashMethod
// byte ChallengeLength
// byte[] B = Challenge
// C => S
// byte[] M1 = H(A | B | SessionKey)
// Bool Success (if false, done)
// C <= S
// byte[] M2 = H(B | A | SessionKey)
// Failed Resume Session
// C => S
// byte ChallengeLength
// byte[] A = Challenge
// int16 TicketLength
// byte[] Ticket
// C <= S
// bool IsSuccess = false
// Goto Authenticate Code
byte[] a = stream.ReadBytes(stream.ReadNextByte());
int ticketLength = stream.ReadInt16();
if (ticketLength < 0 || ticketLength > 10000)
return false;
byte[] ticket = stream.ReadBytes(ticketLength);
if (TryLoadTicket(ticket, m_user, out SessionSecret))
{
stream.Write(true);
stream.WriteByte((byte)SrpHashMethod);
byte[] b = SaltGenerator.Create(16);
stream.WriteByte(16);
stream.Write(b);
stream.Flush();
byte[] clientProofCheck = hash.ComputeHash(a, b, SessionSecret, additionalChallenge);
byte[] serverProof = hash.ComputeHash(b, a, SessionSecret, additionalChallenge);
byte[] clientProof = stream.ReadBytes(hash.GetDigestSize());
if (clientProof.SecureEquals(clientProofCheck))
{
stream.Write(true);
stream.Write(serverProof);
stream.Flush();
return true;
}
stream.Write(false);
return false;
}
stream.Write(false);
return StandardAuthentication(hash, stream, additionalChallenge);
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
// RVAD/RVA2
/*Double original = -65534;
* Double newVal = Math.Log10(1 + original/65535.0)*20.0*512.0;
* Double original2 = Math.Pow(10, newVal/(20.0*512.0));
* original2 = original2 - 1;
* original2 *= 65535.0;*/
/*Double original = 10000;
* Double newVal = Math.Log10(1 + original / 65535.0);
* Double original2 = Math.Pow(10, newVal);
* original2 = original2 - 1;
* original2 *= 65535.0;*/
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
// todo: there needs to be some kind of a test to see if this is RVAD/RVA2 format, too
// much varying implementation in 2.3 and 2.4
bool isRVA2 = (_frameHeader.TagVersion == ID3v2TagVersion.ID3v24);
if (isRVA2)
{
// sometimes "identification" is completely ommitted... grr
Identification = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
while (bytesLeft >= 3)
{
// TODO: Implementation not complete
byte channelType = stream.Read1(ref bytesLeft);
//if (channelType == 16) break; // Invalid, probably stored as an ID3v2.3 RVAD frame
// TODO: some kind of switch.. maybe a new internal enum
short volumeAdjustment = stream.ReadInt16(ref bytesLeft);
if (bytesLeft > 0)
{
// sometimes represented as BITS representing peak.. seriously.
byte bytesRepresentingPeak = stream.Read1(ref bytesLeft);
if (bytesRepresentingPeak == 0)
{
break;
}
if (bytesLeft >= bytesRepresentingPeak)
{
// TODO: Finish implementation
byte[] peakVolume = stream.Read(bytesRepresentingPeak);
bytesLeft -= peakVolume.Length;
}
else
{
break;
}
}
}
if (bytesLeft > 0)
{
//Trace.WriteLine("Invalid RVA2 frame");
//stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
// Try to read it like an ID3v2.3 RVAD frame
stream.Seek(bytesLeft - _frameHeader.FrameSizeExcludingAdditions, SeekOrigin.Current);
bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
isRVA2 = false;
}
else
{
// TODO
//MessageBox.Show("valid RVA2 frame, omg!");
}
}
// ID3v2.2, ID3v2.3, or mal-formed ID3v2.4
if (isRVA2 == false)
{
byte incrementDecrement = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
byte bitsUsedForVolumeDescription = stream.Read1(ref bytesLeft);
int bytesUsedForVolumeDescription = bitsUsedForVolumeDescription / 8;
// TODO: (may be useful for testing which implementation)
// if bits used for volume description is > 64, don't bother
// Relative volume change, right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 0) ? 1 : -1);
}
// Relative volume change, left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 1) ? 1 : -1);
}
// Peak volume right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 2) ? 1 : -1);
}
// Relative volume change, left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 3) ? 1 : -1);
}
// Peak volume right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 4) ? 1 : -1);
}
// Peak volume center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 5) ? 1 : -1);
}
// Peak volume bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferPeak = ByteUtils.ConvertToInt64(byteArray);
}
}
}
// Skip past the rest of the frame
if (bytesLeft > 0)
{
Trace.WriteLine("Invalid RVA2/RVAD/RVA frame");
stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
}
}
}
/// <summary>
/// Reads the value from the stream in little endian format.
/// </summary>
/// <param name="stream">the stream to read from.</param>
/// <returns>The value read</returns>
public static char ReadChar(this Stream stream)
{
return((char)stream.ReadInt16());
}
/// <summary>
/// ストリームからタグ情報を読み込みます。
/// オブジェクトのデータ構造は以下のようになります。
///
/// 1.タグのサイズ ( 2byte ) x タグ数
/// 2.タグの内容 ( サイズ分 ) x タグ数
///
/// よって、はじめにサイズを読み、次にその分だけ値を取得してゆきます。
/// </summary>
/// <param name="src">オブジェクト情報を読み取るストリーム。位置はオブジェクトのボディ先頭 ( サイズ情報の直後 ) に設定します。</param>
private void Load( Stream src )
{
var length = new int[ RequiredTagCount ] { src.ReadInt16(), src.ReadInt16(), src.ReadInt16(), src.ReadInt16(), src.ReadInt16() };
var names = RequiredTagNames;
for( var i = 0; i < ContentDescriptionObject.RequiredTagCount; ++i )
{
this._tags.Add( names[ i ], new ObjectTagValue( ObjectTagValueType.String, src.Position, length[ i ] ) );
src.Seek( length[ i ], SeekOrigin.Current );
}
}
public override void LoadFromBinaryReader(Stream binaryReader)
{
base.LoadFromBinaryReader(binaryReader);
if (_gameInfo.ScummVersion == 6)
{
Size = binaryReader.ReadUint32(); //size: 32le can be 0 (see num anim) or the size (sometimes with an offset of one ??)
Header = binaryReader.ReadUTF8Sring(2); //header: 2*8 always contain "CO"
if (Header != "CO")
{
throw new InvalidFileFormatException(string.Format("Unknown costume Header. Expected 'CO' but was '{0}'", Header));
}
}
NumAnim = binaryReader.ReadByte1(); //num anim: 8 if(size) num_anim++
//lets assign to a new variable to keep the read value intact
byte totalAnimations = NumAnim;
if (Size > 0 || _gameInfo.ScummVersion == 5)
{
totalAnimations++;
}
Format = binaryReader.ReadByte1(); //format: 8 bit 7 set means that west anims must NOT be mirrored, bit 0 is the palette size (0: 16 colors, 1: 32 colors)
//discover the palette size to continue reading
PaletteSize = 16;
if (BinaryHelper.CheckBitState(Format, 0))
{
PaletteSize = 32;
}
//palette : 8*num colors coded in format
Palette = new List <byte>();
for (int i = 0; i < PaletteSize; i++)
{
byte paletteEntry = binaryReader.ReadByte1();
Palette.Add(paletteEntry);
}
AnimCommandsOffset = binaryReader.ReadUint16(); //anim cmds offset : 16le access the anim cmds array
LimbsOffsets = new List <ushort>();
for (int i = 0; i < 16; i++)
{
ushort limbOffSet = binaryReader.ReadUint16();
LimbsOffsets.Add(limbOffSet);//limbs offset : 16*16le access limb picture table
}
//anim offsets : 16le*num anim access anim definitions
AnimOffsets = new List <ushort>();
for (int i = 0; i < totalAnimations; i++)
{
ushort currentOffset = binaryReader.ReadUint16();
AnimOffsets.Add(currentOffset);
}
/*
* anim
* limb mask : 16le
* anim definitions : variable length, one definition for each bit set to 1 in the limb mask.
* 0xFFFF : 16le disabled limb code
* OR
* start : 16le
* noloop : 1
* end offset : 7 offset of the last frame, or len-1 (Pelo que entendi, esse não é a posição final, e sim o comprimento do offset.
*/
Animations = new List <Animation>();
for (int i = 0; i < AnimOffsets.Count; i++)
{
//Por alguma razão, o NumAnimations não é o numero real de animações. Parece que tem um array "reservando" posições para animações
//não utilizadas.
//O que eu quero dizer é que tem o indice de animações, mas esse indice as vezes aponta para um offset de animação 0, ou seja,
//o indice existe e diz que não aponta para nenhuma animação, pelo que entendi. Então só vou continuar lendo do binary stream
//quando for o indice apontara para a próxima animação.
if (AnimOffsets[i] > 0)
{
Animation existingAnimation = Animations.SingleOrDefault(x => x.Offset == AnimOffsets[i]);
if (existingAnimation == null)
{
//Pra isso aqui funciona, a posição do binaryReader deve ser a mesma informada no offset.
//Se não for, então para no debug, porque tem alguma coisa errada com o meu código e
//preciso verificar o que é.
if (AnimOffsets[i] != DebugGetCurrentRelativePosition(binaryReader))
{
Debugger.Break();
}
var currentAnimation = new Animation();
currentAnimation.Offset = AnimOffsets[i];
currentAnimation.LimbMask = binaryReader.ReadUint16();
for (int j = 0; j < currentAnimation.NumLimbs; j++)
{
var currentDefinition = new AnimationDefinition();
currentDefinition.Start = binaryReader.ReadUint16();
if (!currentDefinition.Disabled)
{
currentDefinition.NoLoopAndEndOffset = binaryReader.ReadByte1();
}
currentAnimation.AnimDefinitions.Add(currentDefinition);
}
Animations.Add(currentAnimation);
}
}
}
//Segundo o site do SCUMMC, achar o tamanho do CMDArray e outro itens é somente olhando os indices, pois uma coisa começa onde a
//outra termina. Segue o texto original abaixo:
//
//It seems the data is always properly ordered. That is, the first picture of the first limb comes right after the last limb table.
//The first limb table start right after the cmd array, and so on. Currently this seems to be the only way to determine how long the
//cmd array is, or how long the last limb table is. Clumsy but it works, however a simple decoder doesn’t need to compute these lengths :)
// anim cmds
// cmd: 8
//Essa conta ta ficando 1 byte atrasado. Não sei se a sessão anterior termina com 00 e eu não estou pulando
//ou se tem algum erro mesmo. Verificar se nos próximos costumes é sempre 00 ou 00 00...
//por hora, vou comentar o código de start+length e calcular igual o site fala.
//Tamanhos do CMD Array
if (AnimCommandsOffset != (DebugGetCurrentRelativePosition(binaryReader)))
{
Debugger.Break();
}
int cmdArraySize = (int)(LimbsOffsets.First() - (DebugGetCurrentRelativePosition(binaryReader)));
//cmdArraySize = 0;
//foreach (Animation animation in Animations)
//{
// foreach (AnimationDefinition animationDefinition in animation.AnimDefinitions)
// {
// if (!animationDefinition.Disabled)
// {
// int cmdArrayFinalPosition = animationDefinition.Start + animationDefinition.Length;
// if (cmdArrayFinalPosition > cmdArraySize)
// {
// cmdArraySize = cmdArrayFinalPosition;
// }
// }
// }
//}
Commands = new List <byte>();
for (int i = 0; i < cmdArraySize; i++)
{
Commands.Add(binaryReader.ReadByte1());
}
Limbs = new List <Limb>();
//Pega uma lista apenas com os limbs distintos, sem as repetições:
//, e ignora o ultimo valor, sei lá porque, mas o ultimo valor parece apontar para o final da lista!
List <ushort> differentLimbsOnly = LimbsOffsets.Distinct().ToList();
for (int i = 0; i < differentLimbsOnly.Count - 1; i++)
{
Limb currentLimb = new Limb();
currentLimb.OffSet = differentLimbsOnly[i];
currentLimb.Size = (ushort)(differentLimbsOnly[i + 1] - differentLimbsOnly[i]);
Limbs.Add(currentLimb);
}
//Para determinar o tamanho do ultimo limb, é preciso saber onde começa a primeira imagem do primeiro limb,
//pois ela vem, segundo o texto do scummc, logo apos a ultima tabela de limb. Então eu pego o offset da
//primeira imagem do primeiro limb (dando peek no ushort, que será o primeiro valor lido)
//e subtraio o offset de inicio do ultimo limb, com isso eu descubro o tamanho.
Limb lastLimb = new Limb();
lastLimb.OffSet = differentLimbsOnly[differentLimbsOnly.Count - 1];
//TESTE para tentar descobrir que porra ta acontecendo aqui
ushort nextValue = binaryReader.PeekUint16();
if (nextValue == 0)
{
//Debugger.Break();
}
else
{
lastLimb.Size = (ushort)(nextValue - lastLimb.OffSet);
}
//Eu to achando que se o size for 0, então na verdade esse limb não existe.
//O negócio é que eu acho que pra determinar o tamanho do limb, o engine do scumm
//desconta o offset do limb seguinte do limb atual, então o ultimo limb, se não
//tiver tamanho, era porque seu offset só serviria para determinar o tamanho do limb
//anterior.
//ACHO que talvez por isso, em algumas vezes o nextValue logo acima é 0,
//porque por alguma razão o valor não era o do inicio da próxima imagem e dai foi nulado. Mas isso tudo pode ser besteira tb.
if (lastLimb.Size > 0)
{
Limbs.Add(lastLimb);
}
foreach (Limb limb in Limbs)
{
if ((limb.Size % 2) != 0)
{
Debugger.Break();
}
if (limb.OffSet != (DebugGetCurrentRelativePosition(binaryReader)))
{
Debugger.Break();
}
//Como cada indice tem 2 bytes (ushort), então o total de entradas é o tamanho do limb dividido por 2
for (int i = 0; i < (limb.Size / 2); i++)
{
ushort currentImageOffset = binaryReader.ReadUint16();
limb.ImageOffsets.Add(currentImageOffset);
}
}
Pictures = new List <CostumeImageData>();
int picturesHeaderSize = 12;
if ((Format & 0x7E) == 0x60)
{
//soh vai ter redir_limb e redir_pic se os bits 6 e 7 do format estiver ligados.
picturesHeaderSize = 14;
}
//Primeiro vamos calcular o tamanho que tera os dados de cada imagem.
//Para isso, precisamos pegar a imagem atual + 1, e descontar do offset dela
//o offset da imagem atual. Com isso teremos o tamanho total da imagem.
//Desse total, descontamos 14 (ou 12), que é o número de bytes do cabeçalho da imagem.
CostumeImageData lastImageData = null;
foreach (Limb limb in Limbs)
{
if (limb.ImageOffsets.Count > 0)
{
if (lastImageData != null)
{
ushort firstWithImageOffSet = limb.ImageOffsets.Where(x => x > 0).First();
lastImageData.ImageDataSize = (ushort)((firstWithImageOffSet - lastImageData.ImageStartOffSet) - picturesHeaderSize);
Pictures.Add(lastImageData);
}
for (int i = 0; i < limb.ImageOffsets.Count - 1; i++)
{
if (limb.ImageOffsets[i] > 0)
{
//if (limb.ImageOffsets[i] != (DebugGetCurrentRelativePosition(binaryReader))) Debugger.Break();
ushort nextWithImageOffset = limb.ImageOffsets.Skip(i + 1).Where(x => x > 0).First();
CostumeImageData currentCostumeImageData = new CostumeImageData();
currentCostumeImageData.ImageStartOffSet = limb.ImageOffsets[i];
currentCostumeImageData.ImageDataSize = (ushort)((nextWithImageOffset - currentCostumeImageData.ImageStartOffSet) - picturesHeaderSize);
Pictures.Add(currentCostumeImageData);
}
}
lastImageData = new CostumeImageData();
ushort lastWithImageOffset = limb.ImageOffsets.Where(x => x > 0).Last();
lastImageData.ImageStartOffSet = lastWithImageOffset; //limb.ImageOffsets[limb.ImageOffsets.Count - 1];
}
}
if (lastImageData != null)
{
uint sizeVerify = 0;
switch (_gameInfo.ScummVersion)
{
case 5:
sizeVerify = BlockSize - 2;
break;
case 6:
//pra determinar o tamanho da ultima imagem, vamos usar o parametro size(??) que foi o primeiro valor lido pelo costume.
//Talvez eu deva utilizar o blocksize, não sei... é que esse size não faz muito sentido, visto que o blocksize
//é justamente pra isso. Sei lá, tem alguma pegadinha aqui. Mas em alguns casos o SIZE é 0, dai tem que usar o blocksize mesmo (?)
sizeVerify = Size == 0 ? BlockSize - 8 : Size;
break;
default:
Debugger.Break(); //Não era pra cair aqui.
break;
}
lastImageData.ImageDataSize = (ushort)((sizeVerify - lastImageData.ImageStartOffSet) - picturesHeaderSize);
Pictures.Add(lastImageData);
}
//Agora sim, finalmente, depois dessa volta MEDONHA, parece que conseguimos chegar de fato aos dados dos frames das
//animações... espero que sim pelo menos.
foreach (CostumeImageData picture in Pictures)
{
/*
* width : 16le
* height : 16le
* rel_x : s16le
* rel_y : s16le
* move_x : s16le
* move_y : s16le
* redir_limb : 8 only present if((format & 0x7E) == 0x60)
* redir_pict : 8 only present if((format & 0x7E) == 0x60)
* rle data
*/
picture.Width = binaryReader.ReadUint16();
picture.Height = binaryReader.ReadUint16();
picture.RelX = binaryReader.ReadInt16();
picture.RelY = binaryReader.ReadInt16();
picture.MoveX = binaryReader.ReadInt16();
picture.MoveY = binaryReader.ReadInt16();
if (picturesHeaderSize == 14)
{
//Mexendo, a impressão que parece é que só tem informações de REDIR_LIMB e REDIR_PICT quando
//o size == 0. Não sei porque, mas é isso que ta parecendo.
//Vou fazer mais uns testes.
picture.HasRedirInfo = true;
picture.RedirLimb = binaryReader.ReadByte1();
picture.RedirPict = binaryReader.ReadByte1();
}
picture.ImageData = binaryReader.ReadBytes(picture.ImageDataSize);
}
if (_gameInfo.ScummVersion == 6)
{
uint blockSizeWithoutHeader = (BlockSize - 8);
if (blockSizeWithoutHeader == Size)
{
//não faz nada
}
else if (blockSizeWithoutHeader == Size + 1)
{
HasCloseByte = true;
CloseByte = binaryReader.ReadByte1();
}
}
//TEM GATO NA TUBA!?!?
if (binaryReader.Position - BlockOffSet != BlockSize)
{
Debugger.Break();
}
}
public void Unpack(Stream stream)
{
var flags = (TileFlags) stream.ReadInt8();
Active = flags.HasFlag(TileFlags.Active);
if (Active)
{
Type = stream.ReadInt8();
if (FrameImportant)
{
FrameX = stream.ReadInt16();
FrameY = stream.ReadInt16();
}
}
if (flags.HasFlag(TileFlags.Wall))
{
Wall = stream.ReadInt8();
}
if (flags.HasFlag(TileFlags.Liquid))
{
Liquid = stream.ReadInt8();
Lava = stream.ReadBoolean();
}
if (flags.HasFlag(TileFlags.Wire))
Wire = true;
}
public IEnumerable<Record> Read(Stream s)
{
if (Encoding.ASCII.GetString(s.ReadBytes(7)) != "ARCH000")
throw new NotSupportedException("Not a boir file");
var compressed = s.ReadByte();
var recordStart = s.ReadInt32();
var recordCount = s.ReadInt16();
s.Position = recordStart;
for (int i = 0; i < recordCount; i++)
{
Record rec = null;
switch ((FileType)compressed)
{
case FileType.Compressed:
rec = (Record)new CompressedRecord();
break;
case FileType.Encrypted:
rec = new EncryptedRecord();
break;
case FileType.Encrypted2:
rec = new MiniZCompressedRecord();
break;
}
rec.Read(s);
yield return rec;
}
}
internal override void Read(Stream reader)
{
_val = reader.ReadInt16();
}
public void Unpack(Stream stream)
{
Field6 = stream.ReadInt8();
Field8 = stream.ReadInt16();
Field8 = stream.ReadInt32();
Field9 = stream.ReadBytes();
Field10 = stream.ReadString();
}
