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