Exemplo n.º 1
0
        internal override bool Parse(WZBinaryReader r, bool initial, out byte[] result)
        {
            r.Skip(1);
            int blockLen = r.ReadWZInt(); // sound data length

            Duration = r.ReadWZInt();     // sound duration
            r.Skip(1 + 16 + 16 + 2);      // Byte, Major type GUID, Sub type GUID, byte, byte

            Guid fmt = new Guid(r.ReadBytes(16));

            if (fmt == WaveFormatExGuid)
            {
                if (initial)
                {
                    r.Skip(r.ReadWZInt());
                }
                else
                {
                    _header = r.ReadBytes(r.ReadWZInt());
                    if (_header.Length != 18 + GetCbSize(_header))
                    {
                        _header = null; // TODO FIXME figure out what those gibberish headers are
                    }
                    // But in any case they don't affect our uses

                    //    File._aes.DecryptBytesAsciiKey(_header);
                    //if (_header.Length != 18 + GetCbSize(_header))
                    //    Debug.WriteLine("Failed to parse WAVEFORMATEX header at node {0}", Path);
                    //throw new WZException($"Failed to parse WAVEFORMATEX header at node {Path}");
                }
            }
            else if (fmt != NoHeaderGuid)
            {
                Debug.WriteLine("New format guid {0} @ {1}", fmt, Path);
            }

            if (!initial || (File._flag & WZReadSelection.EagerParseAudio) == WZReadSelection.EagerParseAudio)
            {
                result = r.ReadBytes(blockLen);
                return(true);
            }
            else
            {
                r.Skip(blockLen);
                result = null;
                return(false);
            }
        }
Exemplo n.º 2
0
        internal override bool Parse(WZBinaryReader br, bool initial, out Bitmap result)
        {
            bool skip  = (File._flag & WZReadSelection.NeverParseCanvas) == WZReadSelection.NeverParseCanvas,
                 eager = (File._flag & WZReadSelection.EagerParseCanvas) == WZReadSelection.EagerParseCanvas;

            if (initial)
            {
                if (skip && eager)
                {
                    result = null;
                    return(WZUtil.Die <bool>("Both NeverParseCanvas and EagerParseCanvas are set."));
                }
                br.Skip(1);
                if (br.ReadByte() == 1)
                {
                    br.Skip(2);
                    List <WZObject> l = WZExtendedParser.ParsePropertyList(br, this, Image, Image._encrypted);
                    if (ChildCount == 0)
                    {
                        l.ForEach(Add);
                    }
                }
                _afterChildren = br.Position;
            }
            else
            {
                br.Position = _afterChildren;
            }
            int width   = br.ReadWZInt(); // width
            int height  = br.ReadWZInt(); // height
            int format1 = br.ReadWZInt(); // format 1
            int scale   = br.ReadByte();  // format 2

            br.Skip(4);
            int blockLen = br.ReadInt32();

            if ((initial || skip) && !eager)
            {
                br.Skip(blockLen); // block Len & png data
                result = null;
                return(skip);
            }
            else
            {
                br.Skip(1);
                byte[] header = br.ReadBytes(2);
                // FLG bit 5 indicates the presence of a preset dictionary
                // seems like MS doesn't use that?
                if ((header[1] & 0x20) != 0)
                {
                    Debug.WriteLine("Warning; zlib with preset dictionary");
                    result = null;
                    br.Skip(blockLen - 3);
                    return(true);
                }
                // zlib header: CMF (byte), FLG (byte)
                byte[] pngData = br.ReadBytes(blockLen - 3);
                result = ParsePNG(width, height, format1, scale,
                                  // CMF least significant bits 0 to 3 are compression method. only 8 is valid
                                  (header[0] & 0xF) != 8 ||
                                  // CMF << 8 | FLG i.e. header read as a big-endian short is a multiple of 31
                                  (header[0] << 8 | header[1]) % 31 != 0
                        ? DecryptPNG(pngData)
                        : pngData);
                return(true);
            }
        }