Esempio n. 1
0
        private Imgd(Stream stream)
        {
            stream
            .MustReadAndSeek()
            .MustHaveHeaderLengthOf(HeaderLength);

            var reader = new BinaryReader(stream);
            var header = BinaryMapping.ReadObject <Header>(stream);

            if (header.MagicCode != MagicCode)
            {
                throw InvalidHeaderException;
            }

            Size     = new Size(header.Width, header.Height);
            format   = header.Format;
            swizzled = header.Swizzled;

            stream.SetPosition(header.BitmapOffset);
            var data = reader.ReadBytes(header.BitmapLength);

            // Swap pixel order for only unswizzled 4-bpp IMGD.
            Data = (format == Format4bpp && (swizzled & 4) == 0)
                ? GetSwappedPixelData(data)
                : data;

            stream.SetPosition(header.ClutOffset);
            Clut = reader.ReadBytes(header.ClutLength);
        }
        public static Result Transfer <T>(
            object save, Stream srcSaveStream, Func <Stream, bool> isValid, Func <Stream, T> read,
            Dictionary <Type, Action <object, object, PropertyInfo> > mappings)
            where T : class
        {
            if (!(save is T))
            {
                return(Result.GameNotSupported);
            }

            if (!isValid(srcSaveStream.SetPosition(0)))
            {
                return(Result.SourceNotCompatible);
            }

            var srcSave = read(srcSaveStream.SetPosition(0));

            if (!(srcSave is T))
            {
                return(Result.InternalError);
            }

            TransferServiceLL.CopySave <T>(save, srcSave, mappings);
            return(Result.Success);
        }
Esempio n. 3
0
        public IReadOnlyCollection <String> ReadLines()
        {
            unsafe
            {
                Int32 headerOffset = Positive(_br.ReadInt32());
                Int32 headerCount  = Positive(_br.ReadInt32());
                Int32 headerSize   = checked (headerCount * sizeof(GVHeaderEntry));

                Int32 contentOffset = Positive(_br.ReadInt32());
                Int32 contentSize   = Positive(_br.ReadInt32());

                _stream.SetPosition(headerOffset);
                Byte[] header = _stream.ReadBytes(headerSize);

                _stream.SetPosition(contentOffset);
                Byte[] content = _stream.ReadBytes(contentSize);

                String[] result = new String[headerCount];

                fixed(Byte *headerBytes = header)
                fixed(Byte * contentBytes = content)
                {
                    GVHeaderEntry *entriesPtr = (GVHeaderEntry *)headerBytes;
                    SByte *        contentPtr = (SByte *)contentBytes;

                    for (Int32 i = 0; i < headerCount; i++)
                    {
                        if (IsEmpty(entriesPtr, i))
                        {
                            result[i] = $"{i:D4}|";
                            continue;
                        }

                        GVHeaderEntry entry = entriesPtr[i];

                        CheckEntry(i, ref entry, contentPtr);

                        Int32  offset = InRange(entry.Offset, minValue: 0, maxValue: contentSize - 1);
                        Int32  size   = InRange(entry.Size, minValue: 2, maxValue: contentSize - offset); // \0 terminated strings
                        UInt32 value  = entry.Value;
                        UInt32 mask   = entry.Mask;

                        String name = new String(contentPtr, offset, size - 1, Encoding.ASCII);

                        if ((value & mask) != value)
                        {
                            throw new InvalidDataException($"Value 0x[{value:X8}] of the variable [{i:D4}:{name}] is out of mask [{mask:X8}].");
                        }

                        FormatTypeAndValue(mask, value, out var formattedType, out var formattedValue);
                        result[i] = $"{i:D4}| {formattedType} {name} = {formattedValue}";
                    }
                }

                return(result);
            }
        }
Esempio n. 4
0
        private static DmaChain ReadDmaChain(Stream stream, DmaChainHeader dmaChainHeader)
        {
            var dmaVifs = new List <DmaVif>();
            var count1a = stream.SetPosition(dmaChainHeader.Count1aOffset).ReadInt32();
            var alv1    = For(count1a, () => stream.ReadInt32()).ToList();

            var offsetDmaPackets = new List <int>();
            var alaxi            = new List <int[]>();
            var alaxref          = new List <int>();

            offsetDmaPackets.Add(dmaChainHeader.DmaOffset);

            var offsetDmaBase = dmaChainHeader.DmaOffset + 0x10;

            for (var i = 0; i < count1a; i++)
            {
                if (alv1[i] == -1)
                {
                    offsetDmaPackets.Add(offsetDmaBase + 0x10);
                    offsetDmaBase += 0x20;

                    alaxi.Add(alaxref.ToArray());
                    alaxref.Clear();
                }
                else
                {
                    offsetDmaBase += 0x10;
                    alaxref.Add(alv1[i]);
                }
            }

            alaxi.Add(alaxref.ToArray());
            alaxref.Clear();

            var dmaPackets = offsetDmaPackets
                             .Select(offset => ReadTags(stream.SetPosition(offset)).ToArray())
                             .ToArray();

            for (var i = 0; i < offsetDmaPackets.Count; i++)
            {
                var dmaTag      = dmaPackets[i][0].DmaTag;
                var baseAddress = dmaTag.Qwc != 0 ? dmaPackets[i][1].Parameter : 0;
                stream.Position = dmaTag.Address & 0x7FFFFFFF;
                var vifPacket = stream.ReadBytes(dmaTag.Qwc * 0x10);
                dmaVifs.Add(new DmaVif(dmaChainHeader.TextureIndex, alaxi[i], vifPacket, baseAddress));
            }

            return(new DmaChain
            {
                Unk00 = dmaChainHeader.Unk00,
                TextureIndex = dmaChainHeader.TextureIndex,
                Unk08 = dmaChainHeader.Unk08,
                DmaLength = dmaChainHeader.DmaLength,
                DmaVifs = dmaVifs,
            });
        }
Esempio n. 5
0
        private static bool IsKh2Font(Stream inputStream)
        {
            if (!Bar.IsValid(inputStream.SetPosition(0)))
            {
                return(false);
            }

            return(Bar.Read(inputStream.SetPosition(0))
                   .Any(x => x.Type == Bar.EntryType.RawBitmap));
        }
Esempio n. 6
0
        public static bool IsValid(Stream stream)
        {
            if (stream.Length == 0)
            {
                return(false);
            }

            var isValid = stream.SetPosition(stream.Length - 4).ReadInt32() == 0x0000FFFF;

            stream.SetPosition(0);
            return(isValid);
        }
        public static ISavePersona5 Read(Stream stream)
        {
            switch (GetGameIdentifier(stream.SetPosition(0)))
            {
            case Persona5Identifier:
                return(Mapper.ReadObject <Persona5Vanilla>(stream.SetPosition(0)));

            case Persona5RoyalIdentifier:
                return(Mapper.ReadObject <Persona5Royal>(stream.SetPosition(0)));

            default:
                throw new NotImplementedException("The version has been recognized but it is not supported.");
            }
        }
Esempio n. 8
0
        public static IEnumerable <Entry> Read(Stream stream)
        {
            var header = BinaryMapping.ReadObject <Header>(stream.SetPosition(0));

            return(Enumerable.Range(0, header.EntryCount)
                   .Select(x => BinaryMapping.ReadObject <MetaEntry>(stream))
                   .ToArray()
                   .Select(x => new Entry
            {
                DirectoryPointer = x.DirectoryPointer,
                Name = x.Name,
                Data = x.IsPointer ? null : stream.SetPosition(x.Offset).ReadBytes(x.Length)
            })
                   .ToArray());
        }
        private byte[] ReadData()
        {
            var dataLength = _header.CompressedLength >= 0 ? _header.CompressedLength : _header.DecompressedLength;
            var data       = _stream.SetPosition(_dataOffset).ReadBytes(dataLength);

            _originalRawData = data.ToArray();

            if (_header.CompressedLength > -2)
            {
                for (var i = 0; i < Math.Min(dataLength, 0x100); i += 0x10)
                {
                    EgsEncryption.DecryptChunk(_key, data, i, PASS_COUNT);
                }
            }

            if (_header.CompressedLength > -1)
            {
                using var compressedStream = new MemoryStream(data);
                using var deflate          = new DeflateStream(compressedStream.SetPosition(2), CompressionMode.Decompress);

                var decompressedData = new byte[_header.DecompressedLength];
                deflate.Read(decompressedData, 0, decompressedData.Length);

                data = decompressedData;
            }

            _originalData = data.ToArray();

            return(data);
        }
Esempio n. 10
0
        public static bool IsFac(Stream stream)
        {
            if (stream.Length < HeaderLength)
            {
                return(false);
            }

            stream.MustReadAndSeek().SetPosition(0);
            var header = BinaryMapping.ReadObject <Header>(stream);

            if (header.MagicCode != MagicCode)
            {
                return(false);
            }

            stream
            .SetPosition(header.ClutOffset + header.ClutLength)
            .AlignPosition(FacAlignment);

            if (stream.Position + HeaderLength >= stream.Length)
            {
                return(false);
            }

            header = BinaryMapping.ReadObject <Header>(stream);
            if (header.MagicCode != MagicCode)
            {
                return(false);
            }

            return(true);
        }
Esempio n. 11
0
            public void Deserialize()
            {
                if (_header.Entries == null)
                {
                    return;
                }

                int entryCount = Math.Max(0, _header.Entries.Length - SpecialEntriesCount);

                WdbMovieEntry[] entries = new WdbMovieEntry[entryCount];

                for (int i = 0; i < entryCount; i++)
                {
                    WpdEntry entry = _header.Entries[i + SpecialEntriesCount];
                    _input.SetPosition(entry.Offset);

                    if (entry.Length != WdbMovieEntry.StructSize)
                    {
                        throw new InvalidDataException($"[WdbMovieHeader.Deserialize] Entry: {entry.Name}, Length: {entry.Length}, Expected length: {WdbMovieEntry.StructSize}");
                    }

                    WdbMovieEntry movieEntry = _input.ReadContent <WdbMovieEntry>();
                    movieEntry.Entry       = entry;
                    movieEntry.PackageName = _header.GetString(movieEntry.PackageNameOffset);
                    entries[i]             = movieEntry;
                }

                _header.Movies = entries;
            }
Esempio n. 12
0
        private static DxTexture ReadTextureCubeFromStream(GtexData gtex, Stream input)
        {
            Texture2DDescription descriptor = GetTextureCubeDescription(gtex);

            using (SafeUnmanagedArray array = new SafeUnmanagedArray(gtex.MipMapData.Sum(d => d.Length)))
            {
                DataRectangle[] rects = new DataRectangle[gtex.MipMapData.Length];
                using (UnmanagedMemoryStream io = array.OpenStream(FileAccess.Write))
                {
                    byte[] buff = new byte[32 * 1024];
                    for (int index = 0; index < gtex.MipMapData.Length; index++)
                    {
                        GtexMipMapLocation mimMap = gtex.MipMapData[index];
                        Int32 pitch = GetPitch(descriptor, index);
                        rects[index] = CreateDataRectangle(array, io, pitch);
                        input.SetPosition(mimMap.Offset);
                        input.CopyToStream(io, mimMap.Length, buff);
                    }
                }

                Texture2D texture = new Texture2D(_device.Device, descriptor, rects);

                // Workaround
                _textureCreatingWorkaround(_device.Device.ImmediateContext, texture, ImageFileFormat.Dds);

                return(new DxTexture(texture, descriptor));
            }
        }
Esempio n. 13
0
        public EgsHdAsset(Stream stream)
        {
            _stream     = stream;
            _baseOffset = stream.Position;

            _seed = stream.ReadBytes(0x10);
            _key  = EgsEncryption.GenerateKey(_seed, PASS_COUNT);

            _header = BinaryMapping.ReadObject <Header>(new MemoryStream(_seed));

            var entries = Enumerable
                          .Range(0, _header.RemasteredAssetCount)
                          .Select(_ => BinaryMapping.ReadObject <RemasteredEntry>(stream))
                          .ToList();

            _entries    = entries.ToDictionary(x => x.Name, x => x);
            _dataOffset = stream.Position;

            Assets = entries.Select(x => x.Name).ToArray();

            ReadData();

            foreach (var remasteredAssetName in Assets)
            {
                ReadRemasteredAsset(remasteredAssetName);
            }

            stream.SetPosition(_dataOffset);
        }
Esempio n. 14
0
        private static void PatchImageImz(Context context, AssetFile assetFile, Stream stream)
        {
            var index  = 0;
            var images = Imgz.IsValid(stream) ? Imgz.Read(stream).ToList() : new List <Imgd>();

            foreach (var source in assetFile.Source)
            {
                if (source.Index > 0)
                {
                    index = source.Index;
                }

                var imd = CreateImageImd(context, source);
                if (images.Count <= index)
                {
                    images.Add(imd);
                }
                else
                {
                    images[index] = imd;
                }

                index++;
            }

            Imgz.Write(stream.SetPosition(0), images);
        }
Esempio n. 15
0
        public static bool IsValid(Stream stream)
        {
            if (stream.Length < HeaderLength)
            {
                return(false);
            }

            var header = BinaryMapping.ReadObject <Header>(stream.SetPosition(0));

            if (header.MagicCode != MagicCode)
            {
                return(false);
            }

            var streamLength = stream.Length;

            if (header.Offset1 > streamLength ||
                header.Texinf1off > streamLength ||
                header.Texinf2off > streamLength ||
                header.PictureOffset > streamLength ||
                header.PaletteOffset > streamLength ||
                header.TextureInfoCount <= 0 ||
                header.GsInfoCount <= 0)
            {
                return(false);
            }

            return(true);
        }
Esempio n. 16
0
        public void ReadFromStream(Stream stream)
        {
            BinaryReader br = new BinaryReader(stream);

            Unknown1 = br.ReadInt32();
            Unknown2 = br.ReadInt32();
            int count = br.ReadInt32();

            Unknown3 = br.ReadInt32();

            int[] offsets = new int[count];
            for (int i = 0; i < count; i++)
            {
                offsets[i] = br.ReadInt32();
            }

            int alignment = ((4 - (count % 4)) % 4);

            for (int i = 0; i < alignment; i++)
            {
                br.Check(r => r.ReadInt32(), 0);
            }

            Frames = new YkdFrame[count];
            for (int i = 0; i < count; i++)
            {
                stream.SetPosition(offsets[i]);
                Frames[i] = stream.ReadContent <YkdFrame>();
            }
        }
Esempio n. 17
0
        public static byte[] ReadAllBytes(this Stream stream)
        {
            var data = stream.SetPosition(0).ReadBytes();

            stream.Position = 0;
            return(data);
        }
Esempio n. 18
0
        public static DxTexture ReadFromWpd(WpdArchiveListing listing, WpdEntry entry)
        {
            using (Stream headers = listing.Accessor.ExtractHeaders())
                using (Stream content = listing.Accessor.ExtractContent())
                {
                    headers.SetPosition(entry.Offset);

                    GtexData      gtex;
                    SectionHeader sectionHeader = headers.ReadContent <SectionHeader>();
                    switch (sectionHeader.Type)
                    {
                    case SectionType.Txb:
                        gtex = ReadGtexFromTxb(headers);
                        break;

                    case SectionType.Vtex:
                        gtex = ReadGtexFromVtex(headers);
                        break;

                    default:
                        throw new NotImplementedException();
                    }

                    return(LoadFromStream(gtex, content));
                }
        }
Esempio n. 19
0
        public byte[] ReadRawData()
        {
            var data = new byte[_header.CompressedLength >= 0 ? _header.CompressedLength : _header.DecompressedLength];

            data = _stream.SetPosition(_dataOffset).ReadBytes(data.Length);
            return(data);
        }
Esempio n. 20
0
    public String[][] ReadLines()
    {
        unsafe
        {
            Int32 headerOffset = Asserts.Positive(_br.ReadInt32());
            Int32 headerCount  = Asserts.Positive(_br.ReadInt32());
            Int32 headerSize   = checked (headerCount * sizeof(ILHeaderEntry));

            Int32 contentOffset = Asserts.Positive(_br.ReadInt32());
            Int32 contentCount  = Asserts.Positive(_br.ReadInt32());
            Int32 contentSize   = checked (contentCount * sizeof(ILValueEntry));

            _stream.SetPosition(headerOffset);
            Byte[] header = _stream.ReadBytes(headerSize);

            _stream.SetPosition(contentOffset);
            Byte[] content = _stream.ReadBytes(contentSize);

            String[][] result = new String[headerCount][];

            fixed(Byte *headerBytes = header)
            fixed(Byte * contentBytes = content)
            {
                ILHeaderEntry *entriesPtr = (ILHeaderEntry *)headerBytes;
                ILValueEntry * contentPtr = (ILValueEntry *)contentBytes;

                for (Int32 i = 0; i < headerCount; i++)
                {
                    ILHeaderEntry entry = entriesPtr[i];

                    Int32 index = Asserts.InRange(entry.Index, minValue: 0, maxValue: contentCount - 1);
                    Int32 count = Asserts.InRange(entry.Count, minValue: 0, maxValue: contentCount - index);

                    String[] entryContent = new String[count];
                    result[i] = entryContent;

                    for (Int32 k = 0; k < count; k++)
                    {
                        ILValueEntry value = contentPtr[index + k];
                        entryContent[k] = FormatValue(in value);
                    }
                }
            }

            return(result);
        }
    }
Esempio n. 21
0
        public static T Peek <T>(this Stream stream, Func <Stream, T> func)
        {
            var currentPosition = stream.Position;
            var result          = func(stream);

            stream.SetPosition(currentPosition);
            return(result);
        }
Esempio n. 22
0
 private static int GetPsmfLength(Stream stream, int offset)
 {
     stream.SetPosition(offset + 12);
     return((stream.ReadByte() << 24) |
            (stream.ReadByte() << 16) |
            (stream.ReadByte() << 8) |
            (stream.ReadByte() << 0));
 }
Esempio n. 23
0
        private void OnPlaybackStopped(object sender, StoppedEventArgs e)
        {
            if (e.Exception == null)
            {
                _stream.SetPosition(0);
            }

            _waveOutDevice.Play();
        }
Esempio n. 24
0
        public void Write(Stream stream)
        {
            using (var tempStream = new MemoryStream())
            {
                BinaryMapping.WriteObject(tempStream, this);
                Checksum = SaveKh3.CalculateChecksum(tempStream);
            }

            SaveKh3.Mapper.WriteObject(stream.SetPosition(0), this);
        }
Esempio n. 25
0
        private T[] ReadSegment <T>(CHSegmentHeader segmentHeader) where T : unmanaged
        {
            if (segmentHeader.Count == 0)
            {
                return(new T[0]);
            }

            _stream.SetPosition(segmentHeader.Offset);
            return(_stream.ReadStructs <T>(segmentHeader.Count));
        }
Esempio n. 26
0
        public WaveStream[] Read()
        {
            SectionHeader sectionHeader = _input.ReadContent <SectionHeader>();
            SscfHeader    sscfHeader    = _input.ReadContent <SscfHeader>();

            BinaryReader br = new BinaryReader(_input);

            _input.SetPosition(sscfHeader.WavesOffset);
            int[] offsets = new int[sscfHeader.NumWaves];
            for (int i = 0; i < offsets.Length; i++)
            {
                offsets[i] = br.ReadInt32();
            }

            WaveStream[] result = new WaveStream[sscfHeader.NumWaves];
            for (int i = 0; i < offsets.Length; i++)
            {
                _input.SetPosition(offsets[i]);
                SscfWaveHeader waveHeader = _input.ReadContent <SscfWaveHeader>();
                if (waveHeader.Format == SscfWaveFormat.Vorbis)
                {
                    _input.SetPosition(waveHeader.DataOffset);
                    byte[]       vorbisData = _input.EnsureRead(waveHeader.DataLength);
                    MemoryStream vorbisMs   = new MemoryStream(vorbisData, 0, vorbisData.Length, false);
                    result[i] = new VorbisWaveReader(vorbisMs);
                    continue;
                }

                WaveFormat format = ReadWaveFormat(waveHeader);
                if (format == null)
                {
                    continue;
                }


                _input.SetPosition(waveHeader.DataOffset);
                byte[]       data = _input.EnsureRead(waveHeader.DataLength);
                MemoryStream ms   = new MemoryStream(data, 0, data.Length, false);
                result[i] = new RawSourceWaveStream(ms, format);
            }
            return(result);
        }
Esempio n. 27
0
        public static int GetFileOffset(Stream isoStream, string fileName)
        {
            const uint basePosition = 0x105 * BlockLength; // un-needly hardcoded?

            var fileNameData = Encoding.UTF8.GetBytes(fileName);

            isoStream.SetPosition(basePosition);
            for (int i = 0; i < 0x500; i++)
            {
                if (isoStream.ReadByte() != 1)
                {
                    continue;
                }

                var stringLength = isoStream.ReadByte();
                if (stringLength != fileNameData.Length)
                {
                    continue;
                }

                var currentPosition = isoStream.Position;
                if (isoStream.ReadBytes(stringLength).SequenceEqual(fileNameData))
                {
                    isoStream.SetPosition(currentPosition - 0x1B);

                    var blockStack         = isoStream.ReadBytes(0x04);
                    var blockCorrectEndian = new byte[0x04]
                    {
                        blockStack[3],
                        blockStack[2],
                        blockStack[1],
                        blockStack[0]
                    };

                    return(BitConverter.ToInt32(blockCorrectEndian, 0));
                }

                isoStream.Position = currentPosition + 1;
            }

            return(-1);
        }
Esempio n. 28
0
        internal static bool IsValidInternal(Stream stream)
        {
            var prevPosition = stream.Position;
            var reader       = new BinaryReader(stream.SetPosition(0));
            var magicCode    = reader.ReadInt32();
            var length       = reader.ReadInt32();

            stream.Position = prevPosition;

            return(magicCode == 0x45764053 && length == 0x94F2F8);
        }
Esempio n. 29
0
        public bool IsValid(Stream stream)
        {
            var currentPosition = stream.Position;

            stream.Position = 0;

            var result = BitConverter.ToUInt32(stream.ReadBytes(4));

            stream.SetPosition((int)currentPosition);
            return(result == 0x00554643);
        }
Esempio n. 30
0
        public static bool IsValid(Stream stream)
        {
            if (stream.SetPosition(0).ReadInt32() != MagicCode ||
                stream.ReadInt32() != 1 ||
                stream.Length < 0x50)
            {
                return(false);
            }

            return(true);
        }
Esempio n. 31
0
        public void ReadFromStream(Stream stream)
        {
            Offsets = stream.ReadContent<YkdOffsets>();

            Resources = new YkdResource[Offsets.Count];
            for (int i = 0; i < Resources.Length; i++)
            {
                YkdResource resource = Resources[i] = new YkdResource();

                stream.SetPosition(Offsets[i]);
                resource.ReadFromStream(stream);
            }

            if (!stream.IsEndOfStream())
                throw new InvalidDataException();
        }
Esempio n. 32
0
        public void ReadFromStream(Stream stream)
        {
            BinaryReader br = new BinaryReader(stream);

            IsFirstBlock = stream.Position == YkdHeader.Size;

            Type = br.ReadUInt32();
            Index = br.ReadUInt32();
            AssociatedIndex = br.ReadUInt32();
            Unknown = br.ReadUInt32();

            for (int i = 0; i < TransformationMatrix.Length; i++)
                TransformationMatrix[i] = br.ReadBigInt32();

            Offsets = stream.ReadContent<YkdOffsets>();
            Entries = new YkdBlockEntry[Offsets.Count];
            for (int i = 0; i < Offsets.Count; i++)
            {
                stream.SetPosition(Offsets[i]);
                Entries[i] = stream.ReadContent<YkdBlockEntry>();
            }

            if (!IsFirstBlock)
            {
                switch (Type)
                {
                    case 0:
                        ZeroTail = stream.ReadContent<YkdBlockOptionalTail>();
                        break;
                    case 4:
                        Tails4 = stream.ReadContent<YkdBlockOptionalTails>();
                        break;
                    case 5:
                    case 6:
                        Tail56 = new int[12];
                        for (int i = 0; i < Tail56.Length; i++)
                            Tail56[i] = br.ReadInt32();
                        break;
                }
            }
        }
Esempio n. 33
0
        private static DxTexture ReadTextureCubeFromStream(GtexData gtex, Stream input)
        {
            Texture2DDescription descriptor = GetTextureCubeDescription(gtex);

            using (SafeUnmanagedArray array = new SafeUnmanagedArray(gtex.MipMapData.Sum(d => d.Length)))
            {
                DataRectangle[] rects = new DataRectangle[gtex.MipMapData.Length];
                using (UnmanagedMemoryStream io = array.OpenStream(FileAccess.Write))
                {
                    byte[] buff = new byte[32 * 1024];
                    for (int index = 0; index < gtex.MipMapData.Length; index++)
                    {
                        GtexMipMapLocation mimMap = gtex.MipMapData[index];
                        Int32 pitch = GetPitch(descriptor, index);
                        rects[index] = CreateDataRectangle(array, io, pitch);
                        input.SetPosition(mimMap.Offset);
                        input.CopyToStream(io, mimMap.Length, buff);
                    }
                }

                Texture2D texture = new Texture2D(_device, descriptor, rects);

                // Workaround
                _textureCreatingWorkaround(_device.ImmediateContext, texture, ImageFileFormat.Dds);

                return new DxTexture(texture, descriptor);
            }
        }
 public void Extract(WdbMovieEntry entry, Stream output, Stream content, Byte[] buff)
 {
     content.SetPosition(entry.Offset);
     content.CopyToStream(output, entry.Length, buff);
 }