public void Load(PrimitiveReader reader)
{
// checking magic
var magic = reader.ReadUInt32();
if (magic != Magic)
{
throw new InvalidOperationException("Memory: Cannot resume state from stream: Invalid magic.");
}
SegmentSize = reader.ReadInt32();
size = reader.ReadUInt32();
if (emptyCtorUsed)
{
Init();
}
var realSegmentsCount = 0;
for (var i = 0; i < segments.Length; i++)
{
var isTouched = reader.ReadBoolean();
if (!isTouched)
{
continue;
}
var compressedSegmentSize = reader.ReadInt32();
var compressedBuffer = reader.ReadBytes(compressedSegmentSize);
TouchSegment(i);
realSegmentsCount++;
LZ4Codec.Decode64(compressedBuffer, segments[i], SegmentSize);
}
this.NoisyLog(string.Format("{0} segments loaded from stream, of which {1} had content.", segments.Length, realSegmentsCount));
}
public static ResearchStat ReadFrom(PrimitiveReader reader)
{
ResearchStat s = new ResearchStat();
s.Status = reader.ReadInt16();
s.Unknown1 = reader.ReadUInt32();
s.Unknown2 = reader.ReadUInt32();
s.Unknown3 = reader.ReadUInt32();
return(s);
}
public static AiRuleData ReadFrom(PrimitiveReader reader)
{
AiRuleData data = new AiRuleData();
data.Type = reader.ReadUInt32();
data.Id = reader.ReadUInt16();
data.Unknown = reader.ReadUInt16();
data.Param1 = reader.ReadUInt32();
data.Param2 = reader.ReadUInt32();
data.Param2 = reader.ReadUInt32();
data.Param4 = reader.ReadUInt32();
return(data);
}
public async ValueTask Read(PrimitiveReader primitiveReader, CancellationToken cancellationToken)
{
BoolValue = await primitiveReader.ReadBool(cancellationToken);
ByteValue = await primitiveReader.ReadByte(cancellationToken);
SByteValue = await primitiveReader.ReadSByte(cancellationToken);
ShortValue = await primitiveReader.ReadInt16(cancellationToken);
UShortValue = await primitiveReader.ReadUInt16(cancellationToken);
IntValue = await primitiveReader.ReadInt32(cancellationToken);
UIntValue = await primitiveReader.ReadUInt32(cancellationToken);
LongValue = await primitiveReader.ReadInt64(cancellationToken);
ULongValue = await primitiveReader.ReadUInt64(cancellationToken);
FloatValue = await primitiveReader.ReadSingle(cancellationToken);
DoubleValue = await primitiveReader.ReadDouble(cancellationToken);
StringValue = await primitiveReader.ReadString(cancellationToken);
deserializationCounter++;
}
public static AiInfo ReadFrom(PrimitiveReader reader)
{
AiInfo info = new AiInfo();
info.Unknown = reader.ReadUInt16();
ushort stringsCount = reader.ReadUInt16();
System.Diagnostics.Debugger.Break();
info.Unknown2 = reader.ReadUInt32();
List <string> resources = new List <string>(stringsCount);
for (int i = 0; i < stringsCount; i++)
{
resources.Add(Utils.ReadUInt32LengthPrefixedString(reader));
}
info.Resources = resources;
info.Unknown3 = reader.ReadBytes(6);
AiData[] data = new AiData[8];
for (int i = 0; i < data.Length; i++)
{
data[i] = AiData.ReadFrom(reader);
}
info.Data = data;
info.Unknown4 = reader.ReadBytes(104);
AiTimer[] timers = new AiTimer[8];
for (int i = 0; i < timers.Length; i++)
{
timers[i] = AiTimer.ReadFrom(reader);
}
info.Timers = timers;
info.SharedGoals = reader.ReadUInt32Array(256);
info.Unknown5 = reader.ReadUInt32Array(1024);
return(info);
}
public void ShouldReadAndWriteLimits()
{
var stream = new MemoryStream();
using (var writer = new PrimitiveWriter(stream))
{
writer.Write(byte.MinValue);
writer.Write(byte.MaxValue);
writer.Write(sbyte.MinValue);
writer.Write(sbyte.MaxValue);
writer.Write(short.MinValue);
writer.Write(short.MaxValue);
writer.Write(ushort.MinValue);
writer.Write(ushort.MaxValue);
writer.Write(int.MinValue);
writer.Write(int.MaxValue);
writer.Write(uint.MinValue);
writer.Write(uint.MaxValue);
writer.Write(long.MinValue);
writer.Write(long.MaxValue);
writer.Write(ulong.MinValue);
writer.Write(ulong.MaxValue);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new PrimitiveReader(stream))
{
Assert.AreEqual(byte.MinValue, reader.ReadByte());
Assert.AreEqual(byte.MaxValue, reader.ReadByte());
Assert.AreEqual(sbyte.MinValue, reader.ReadSByte());
Assert.AreEqual(sbyte.MaxValue, reader.ReadSByte());
Assert.AreEqual(short.MinValue, reader.ReadInt16());
Assert.AreEqual(short.MaxValue, reader.ReadInt16());
Assert.AreEqual(ushort.MinValue, reader.ReadUInt16());
Assert.AreEqual(ushort.MaxValue, reader.ReadUInt16());
Assert.AreEqual(int.MinValue, reader.ReadInt32());
Assert.AreEqual(int.MaxValue, reader.ReadInt32());
Assert.AreEqual(uint.MinValue, reader.ReadUInt32());
Assert.AreEqual(uint.MaxValue, reader.ReadUInt32());
Assert.AreEqual(long.MinValue, reader.ReadInt64());
Assert.AreEqual(long.MaxValue, reader.ReadInt64());
Assert.AreEqual(ulong.MinValue, reader.ReadUInt64());
Assert.AreEqual(ulong.MaxValue, reader.ReadUInt64());
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
public static AiData ReadFrom(PrimitiveReader reader)
{
AiData data = new AiData();
data.Unknown = reader.ReadUInt32();
data.Unknown2 = reader.ReadUInt32();
data.MaximumRules = reader.ReadUInt16();
ushort rulesCount = reader.ReadUInt16();
data.Unknown3 = reader.ReadUInt32();
List <AiRule> rules = new List <AiRule>(rulesCount);
for (int i = 0; i < rulesCount; i++)
{
rules.Add(AiRule.ReadFrom(reader));
}
data.Rules = rules;
return(data);
}
public IEnumerable<AudioChunk> StreamData( Stream source )
{
infoBuffer.Length = 0;
chunk = new AudioChunk();
PrimitiveReader reader = new PrimitiveReader( source );
string signature = reader.ReadASCIIString( 4 );
if( signature != ".snd" ) {
throw new InvalidDataException( "Invalid initial signature." );
}
AppendInfoLine( 0, "-- Begin info --" );
reader.BigEndian = true;
uint dataOffset = reader.ReadUInt32();
AppendInfoLine( 0, "Data offset: {0}", dataOffset );
uint dataSize = reader.ReadUInt32();
if( dataSize == 0xFFFFFFFF ) {
dataLength = source.Length - dataOffset;
} else {
dataLength = dataSize;
}
AppendInfoLine( 0, "Data length: {0}", dataLength );
AuEncoding encoding = (AuEncoding)reader.ReadUInt32();
AppendInfoLine( 0, "Encoding: {0}", encoding );
uint sampleRate = reader.ReadUInt32();
AppendInfoLine( 0, "Sample rate: {0}", sampleRate );
uint channels = reader.ReadUInt32();
AppendInfoLine( 0, "Channels: {0}", channels );
if( dataOffset > 24 ) {
int infoLength = (int)( dataOffset - 24 );
string info = reader.ReadASCIIString( infoLength );
AppendInfoLine( 0, "Info: {0}", info );
}
int bitsPerSample = bitsPerSampleEncoding[(int)encoding];
int adjustedBitsPerSample = paddedBitsPerSampleEncoding[(int)encoding];
bufferSize = (int)( sampleRate * channels * adjustedBitsPerSample / 8 );
AppendInfoLine( 0, "-- End info --" );
fileinfo = infoBuffer.ToString();
return StreamDataCore( reader );
}
void ProcessFormatChunk( RiffChunkHeader chunk, PrimitiveReader reader )
{
byte[] chunkData = reader.ReadBytes( chunk.DataSize );
Stream source = reader.stream;
reader.stream = new MemoryStream( chunkData );
int audioFormat = reader.ReadUInt16();
Metadata["WAVE audio format"] = ((AudioFormat)audioFormat).ToString();
int channels = reader.ReadInt16();
Metadata[MetadataKeys.Channels] = channels.ToString();
int sampleRate = reader.ReadInt32();
Metadata[MetadataKeys.SampleRate] = sampleRate.ToString();
int byteRate = reader.ReadInt32();
int blockAlign = reader.ReadInt16();
int bitsPerSample = reader.ReadInt16();
Metadata[MetadataKeys.BitsPerSample] = bitsPerSample.ToString();
int extraInfoSize = 0;
#pragma warning disable 0618
// Usually, only very old wave files don't have this
// field included. (WaveFormat structure, not WaveFormatEx structure)
// Supress the warning because it's a MemoryStream.
if( reader.Position != reader.Length ) {
extraInfoSize = reader.ReadUInt16();
}
#pragma warning restore 0618
this.freq = sampleRate;
transformer = EmptyTransformer.Instance;
this.channels = channels;
this.bitsPerSample = bitsPerSample;
codecBitsPerSample = bitsPerSample;
switch( (AudioFormat)audioFormat ) {
case AudioFormat.Pcm: // No compression.
if( bitsPerSample == 16 && reader.BigEndian ) {
transformer = BigEndian16BitTo16BitTransformer.Instance;
}
break;
case AudioFormat.IeeeFloat:
if( bitsPerSample == 32 ) {
this.bitsPerSample = 16;
} else if( bitsPerSample == 64 ) {
this.bitsPerSample = 16;
}
throw new NotSupportedException();
break;
case AudioFormat.ALaw:
transformer = ALawTransformer.Instance;
this.bitsPerSample = 16;
break;
case AudioFormat.MuLaw:
transformer = MuLawTransformer.Instance;
this.bitsPerSample = 16;
break;
// TODO: Properly test this transformer, but I can't seem to find any wave files that use this format.
case AudioFormat.DialogicOkiAdpcm:
transformer = DialogicAdpcmTransformer.Instance;
this.bitsPerSample = 16;
break;
// TODO: Test this transformer too.
case AudioFormat.ImaAdpcm:
transformer = ImaAdpcmTransformer.Instance;
this.bitsPerSample = 16;
break;
case AudioFormat.Extensible:
ushort validBitsPerSample = reader.ReadUInt16();
uint channelMask = reader.ReadUInt32();
Guid subFormat = reader.ReadGuid();
Metadata["extensible guid"] = subFormat.ToString();
if( subFormat == PcmGuid ) {
} else if( subFormat == IeeeFloatGuid ) {
throw new NotSupportedException( "Ieee float sub format not supported." );
} else if( subFormat == DrmGuid ) {
throw new NotSupportedException( "Drm sub format not supported." );
} else if( subFormat == AlawGuid ) {
transformer = ALawTransformer.Instance;
this.bitsPerSample = 16;
} else if( subFormat == MulawGuid ) {
transformer = MuLawTransformer.Instance;
this.bitsPerSample = 16;
} else if( subFormat == AdpcmGuid ) {
throw new NotSupportedException( "Adpcm sub format not supported." );
} else if( subFormat == MpegGuid ) {
throw new NotSupportedException( "Mpeg sub format not supported." );
} else {
throw new NotSupportedException( "Unsupported sub format: " + subFormat );
}
break;
default:
throw new NotSupportedException( "Unsupported audio format: " + (AudioFormat)audioFormat );
}
reader.stream = source;
}
void ProcessFormatVersionChunk( AiffChunkHeader chunk, PrimitiveReader reader )
{
uint timeStamp = reader.ReadUInt32();
AppendInfoLine( 2, "Format timestamp: {0} (hex {1})", timeStamp, timeStamp.ToString( "X8" ) );
}
void ProcessCommonChunk( AiffChunkHeader chunk, PrimitiveReader reader )
{
byte[] chunkData = reader.ReadBytes( chunk.DataSize );
Stream source = reader.stream;
reader.stream = new MemoryStream( chunkData );
int channelsCount = reader.ReadInt16();
uint frameCount = reader.ReadUInt32();
int bitsPerSample = reader.ReadInt16();
byte[] sampleRateBytes = reader.ReadBytes( 10 );
double sampleRate = ConvertFromIeeeExtended( sampleRateBytes );
Console.WriteLine( sampleRate );
AppendInfoLine( 2, "Channels Count: {0}", channelsCount );
AppendInfoLine( 2, "Sample rate (frames/sec): {0}", sampleRate );
AppendInfoLine( 2, "Bits per sample: {0}", bitsPerSample );
AppendInfoLine( 2, "Frame count: {0}", frameCount );
int byteRate = (int)Math.Ceiling( sampleRate ) * channelsCount * bitsPerSample / 8;
info.Frequency = (int)sampleRate;
Console.WriteLine( "BPS:" + bitsPerSample + ", SR:" + info.Frequency );
transformer = EmptyTransformer.Instance;
if( bitsPerSample > 8 && bitsPerSample <= 16 ) {
transformer = BigEndian16BitTo16BitTransformer.Instance;
}
if( bitsPerSample > 16 && bitsPerSample <= 24 ) {
transformer = BigEndian24BitTo16BitTransformer.Instance;
}
// Number of bytes that make up a second's worth of audio data.
bufferSize = byteRate;
info.Channels = channelsCount;
actualBitsPerSample = bitsPerSample;
// TODO: Remove this hackery.
if( bitsPerSample > 16 )
bitsPerSample = 16;
info.BitsPerSample = bitsPerSample;
if( aifcFormat ) {
string compressionType = reader.ReadASCIIString( 4 );
string compressionName = reader.ReadASCIIString( reader.ReadByte() );
AppendInfoLine( 2, "Compression type: {0}", compressionType );
AppendInfoLine( 2, "Compression name: {0}", compressionName );
switch( compressionType ) {
case "NONE":
case "sowt":
break;
case "alaw":
case "ALAW":
info.BitsPerSample = 16;
transformer = ALawTransformer.Instance;
break;
case "ulaw":
case "ULAW":
info.BitsPerSample = 16;
transformer = MuLawTransformer.Instance;
break;
}
}
reader.stream = source;
}
void ProcessMetadataPicture( int len, PrimitiveReader reader )
{
uint type = reader.ReadUInt32();
PictureType pictureType = (PictureType)type;
int mimeTypeLength = reader.ReadInt32();
string mimeType = reader.ReadASCIIString( mimeTypeLength );
int descriptionLength = reader.ReadInt32();
string description = reader.ReadUTF8String( descriptionLength );
int width = reader.ReadInt32();
int height = reader.ReadInt32();
int colourDepth = reader.ReadInt32(); // Bits per pixel.
int indexedColoursUsed = reader.ReadInt32();
int picturelength = reader.ReadInt32();
byte[] data = reader.ReadBytes( picturelength );
}
void ReadV3ExtendedHeader( PrimitiveReader reader, ref int len )
{
int extendedDataSize = reader.ReadInt32(); len -= ( 4 + extendedDataSize );
ushort extendedFlags = reader.ReadUInt16();
int paddingSize = reader.ReadInt32();
extendedDataSize -= 6;
if( ( extendedFlags & 0x8000 ) != 0 ) {
uint crc32 = reader.ReadUInt32();
extendedDataSize -= 4;
}
reader.SkipData( extendedDataSize );
}
public void ReadData(string path)
{
PrimitiveReader reader = new PrimitiveReader(path);
SaveGameFile file = new SaveGameFile();
file.Version = reader.ReadASCIIString(8);
file.Unknown1 = reader.ReadFloat32();
bool aiDataIncluded = reader.ReadUInt32() != 0;
if (aiDataIncluded)
{
file.AiInfo2 = AiInfo.ReadFrom(reader);
}
file.Unknown2 = reader.ReadUInt32();
file.GameSpeed1 = reader.ReadUInt32();
file.Unknown3 = reader.ReadUInt32();
file.GameSpeed2 = reader.ReadUInt32();
file.Unknown4 = reader.ReadFloat32();
file.Unknown5 = reader.ReadUInt32();
file.Unknown6 = reader.ReadBytes(17);
file.RecordedGamePlayerNumber = reader.ReadUInt16();
//System.Diagnostics.Debugger.Break();
file.PlayersCount = reader.ReadUInt8();
file.Unknown7 = reader.ReadUInt32();
file.Unknown8 = reader.ReadBytes(12);
file.Unknown9 = reader.ReadBytes(14);
file.Unknown10 = reader.ReadUInt32Array(8);
//System.Diagnostics.Debugger.Break();
reader.SeekAbsolute(126);
int mapWidth = reader.ReadInt32();
int mapLength = reader.ReadInt32();
uint unknownDataCount = reader.ReadUInt32();
ushort unknown2 = reader.ReadUInt16();
SaveGameMap map = SaveGameMap.ReadFrom(reader, mapWidth, mapLength);
/*int unknownIntsArrayCount = reader.ReadInt32();
* uint[][] unknowns = new uint[unknownIntsArrayCount][];
* for( int i = 0; i < unknowns.Length; i++ ) {
* int intsCount = reader.ReadInt32() - 1;
* if( intsCount < 0 ) throw new Exception();
* unknowns[i] = reader.ReadUInt32Array( intsCount );
* }*/
reader.SeekAbsolute(29132);
int mapWidth2 = reader.ReadInt32();
int mapLength2 = reader.ReadInt32();
uint[] unknownMap2 = reader.ReadUInt32Array(mapWidth2 * mapLength2);
//byte unknownIntsCount1 = reader.ReadUInt8();
//uint[] unknownInts = reader.ReadUInt32Array( unknownIntsCount1 );
reader.SeekAbsolute(88779);
SavePlayerInfo f = SavePlayerInfo.ReadFrom(reader, 2);
System.Diagnostics.Debugger.Break();
}
public static SavePlayerInfo ReadFrom(PrimitiveReader reader, int pCount)
{
SavePlayerInfo p = new SavePlayerInfo();
byte[] diplomacyFrom = reader.ReadBytes(pCount);
uint[] diplomacyTo = reader.ReadUInt32Array(9);
uint unknown1 = reader.ReadUInt32();
byte unknown2 = reader.ReadUInt8();
string name = Utils.ReadUInt16LengthPrefixedString(reader);
byte unknown3 = reader.ReadUInt8();
int floatsCount = reader.ReadInt32();
byte unknown4 = reader.ReadUInt8();
float[] civHeader = reader.ReadFloat32Array(floatsCount);
FloatTest t = new FloatTest(civHeader);
byte unknown5 = reader.ReadUInt8();
float[] unknown6 = reader.ReadFloat32Array(2);
byte[] unknown7 = reader.ReadBytes(9);
byte civilization = reader.ReadUInt8();
byte[] unknown8 = reader.ReadBytes(3);
byte colour = reader.ReadUInt8();
byte[] unknown9 = reader.ReadBytes(4183);
float unknown10 = reader.ReadFloat32();
int researchCount = reader.ReadInt32();
ushort unknown11 = reader.ReadUInt16();
ResearchStat[] stats = new ResearchStat[researchCount];
for (int i = 0; i < stats.Length; i++)
{
stats[i] = ResearchStat.ReadFrom(reader);
}
Console.WriteLine("LAST KNOWN POS:" + reader.Position);
reader.SeekAbsolute(128358);
int masterObjectsCount = reader.ReadInt32();
bool[] objectExistsFlags = new bool[masterObjectsCount];
for (int i = 0; i < objectExistsFlags.Length; i++)
{
objectExistsFlags[i] = reader.ReadUInt32() != 0;
}
//System.Diagnostics.Debugger.Break();
ushort unknownObjects = reader.ReadUInt16();
Console.WriteLine("BEGIN READ OBJECTS.." + reader.Position);
MasterObject[] masterObjects = new MasterObject[masterObjectsCount];
for (int i = 0; i < masterObjects.Length; i++)
{
if (objectExistsFlags[i])
{
masterObjects[i] = MasterObject.ReadFrom(reader, i);
}
}
System.Diagnostics.Debugger.Break();
return(p);
}
public override void ReadMetadata()
{
reader = new PrimitiveReader( stream );
string signature = reader.ReadASCIIString( 4 );
if( signature != ".snd" ) {
throw new InvalidDataException( "Invalid initial signature." );
}
reader.BigEndian = true;
uint dataOffset = reader.ReadUInt32();
dataLength = reader.ReadUInt32();
if( dataLength == 0xFFFFFFFF ) {
dataLength = (uint)( reader.Length - dataOffset );
}
AuEncoding encoding = (AuEncoding)reader.ReadUInt32();
Metadata["AU encoding"] = encoding.ToString();
freq = reader.ReadInt32();
Metadata[MetadataKeys.SampleRate] = freq.ToString();
channels = reader.ReadInt32();
Metadata[MetadataKeys.Channels] = channels.ToString();
if( dataOffset > 24 ) {
int infoLength = (int)( dataOffset - 24 );
string info = reader.ReadASCIIString( infoLength );
Metadata["File comment"] = info;
}
transformer = EmptyTransformer.Instance;
switch( encoding ) {
case AuEncoding.Int8G711uLaw:
transformer = MuLawTransformer.Instance;
bitsPerSample = 16; codecBitsPerSample = 8;
break;
case AuEncoding.Int8LinearPcm:
bitsPerSample = codecBitsPerSample = 8;
break;
case AuEncoding.Int16LinearPcm:
bitsPerSample = codecBitsPerSample = 16;
transformer = BigEndian16BitTo16BitTransformer.Instance;
break;
case AuEncoding.Int24LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 24;
transformer = BigEndian24BitTo16BitTransformer.Instance;
break;
case AuEncoding.Int32LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 32;
transformer = BigEndian32BitTo16BitTransformer.Instance;
break;
case AuEncoding.Float32LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 32;
transformer = BigEndianFloat32To16BitTransformer.Instance;
break;
case AuEncoding.Float64LinearPcm:
bitsPerSample = 16; codecBitsPerSample = 64;
transformer = BigEndianFloat64To16BitTransformer.Instance;
break;
case AuEncoding.Int8G711ALaw:
transformer = ALawTransformer.Instance;
bitsPerSample = 16; codecBitsPerSample = 8;
break;
default:
throw new NotSupportedException( "Unsupported audio format: " + encoding );
}
Metadata[MetadataKeys.BitsPerSample] = bitsPerSample.ToString();
}
public void ShouldReadAndWriteLimits()
{
var stream = new MemoryStream();
using(var writer = new PrimitiveWriter(stream))
{
writer.Write(byte.MinValue);
writer.Write(byte.MaxValue);
writer.Write(sbyte.MinValue);
writer.Write(sbyte.MaxValue);
writer.Write(short.MinValue);
writer.Write(short.MaxValue);
writer.Write(ushort.MinValue);
writer.Write(ushort.MaxValue);
writer.Write(int.MinValue);
writer.Write(int.MaxValue);
writer.Write(uint.MinValue);
writer.Write(uint.MaxValue);
writer.Write(long.MinValue);
writer.Write(long.MaxValue);
writer.Write(ulong.MinValue);
writer.Write(ulong.MaxValue);
}
var position = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using(var reader = new PrimitiveReader(stream))
{
Assert.AreEqual(byte.MinValue, reader.ReadByte());
Assert.AreEqual(byte.MaxValue, reader.ReadByte());
Assert.AreEqual(sbyte.MinValue, reader.ReadSByte());
Assert.AreEqual(sbyte.MaxValue, reader.ReadSByte());
Assert.AreEqual(short.MinValue, reader.ReadInt16());
Assert.AreEqual(short.MaxValue, reader.ReadInt16());
Assert.AreEqual(ushort.MinValue, reader.ReadUInt16());
Assert.AreEqual(ushort.MaxValue, reader.ReadUInt16());
Assert.AreEqual(int.MinValue, reader.ReadInt32());
Assert.AreEqual(int.MaxValue, reader.ReadInt32());
Assert.AreEqual(uint.MinValue, reader.ReadUInt32());
Assert.AreEqual(uint.MaxValue, reader.ReadUInt32());
Assert.AreEqual(long.MinValue, reader.ReadInt64());
Assert.AreEqual(long.MaxValue, reader.ReadInt64());
Assert.AreEqual(ulong.MinValue, reader.ReadUInt64());
Assert.AreEqual(ulong.MaxValue, reader.ReadUInt64());
}
Assert.AreEqual(position, stream.Position, StreamCorruptedMessage);
}
void ProcessMetadataVorbisComment( int len, PrimitiveReader reader )
{
int bytesRead = 0;
reader.BigEndian = false;
while( bytesRead < len ) {
int vendorLength = reader.ReadInt32();
string vendor = reader.ReadUTF8String( vendorLength );
bytesRead += 4 + vendorLength;
uint commentsCount = reader.ReadUInt32();
bytesRead += 4;
for( uint i = 0; i < commentsCount; i++ ) {
int commentLength = reader.ReadInt32();
string comment = reader.ReadUTF8String( commentLength );
bytesRead += 4 + commentLength;
}
}
reader.BigEndian = true;
}