Beispiel #1
0
		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;
			}
		}
Beispiel #2
0
        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);
        }
Beispiel #3
0
        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;
                }
            }
        }
Beispiel #4
0
        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);
        }
Beispiel #6
0
        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;
            }
        }
Beispiel #7
0
        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);
        }
Beispiel #8
0
        /// <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();
            }
        }
Beispiel #9
0
 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));
        }
Beispiel #11
0
        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);
        }
Beispiel #12
0
        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();
        }
Beispiel #13
0
 public void Read(Stream source)
 {
     this.ApiKey     = source.ReadInt16();
     this.MinVersion = source.ReadInt16();
     this.MaxVersion = source.ReadInt16();
 }
Beispiel #14
0
 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;
        }
Beispiel #16
0
 public override short Short() => Stream.ReadInt16();
Beispiel #17
0
 public static object Read(Stream stream)
 {
     return stream.ReadInt16();
 }
Beispiel #18
0
 public static object Read(Stream stream)
 {
     return(stream.ReadInt16());
 }
Beispiel #19
0
 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;
 }
Beispiel #20
0
        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);
            }
        }
Beispiel #21
0
        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;
        }
Beispiel #22
0
 public static Int32 ReadInt32(this Stream s)
 {
     return((Int32)(s.ReadInt16() | (s.ReadInt16() << 16)));
 }
Beispiel #23
0
 public static ErrorCode ReadErrorCode(this Stream source) => (ErrorCode)source.ReadInt16();
 public static ushort ReadUInt16(this Stream s)
 {
     return((ushort)s.ReadInt16());
 }
Beispiel #25
0
        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;
            }
        }
Beispiel #26
0
 public static UInt16 ReadUInt16(this Stream s)
 {
     return((UInt16)s.ReadInt16());
 }
Beispiel #27
0
        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;
            }
        }
Beispiel #28
0
        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);
        }
Beispiel #29
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);
            }
Beispiel #30
0
        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));
        }
Beispiel #31
0
		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;
			}
		}
Beispiel #32
0
        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;
                }
            }
        }
Beispiel #34
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);
            }
        }
Beispiel #35
0
        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;
                }
            }
        }
Beispiel #38
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 );
            }
        }
Beispiel #40
0
        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();
            }
        }
Beispiel #41
0
        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;
            }
        }
Beispiel #43
0
 internal override void Read(Stream reader)
 {
     _val = reader.ReadInt16();
 }
Beispiel #44
0
 public void Unpack(Stream stream)
 {
     Field6 = stream.ReadInt8();
     Field8 = stream.ReadInt16();
     Field8 = stream.ReadInt32();
     Field9 = stream.ReadBytes();
     Field10 = stream.ReadString();
 }