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; }