コード例 #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="stream"></param>
        public void SetStream(Stream stream)
        {
            Stream = stream;

            // Read the header.
            Header = Stream.ReadStruct <HeaderStruct>();
            if (Header.Magic != DaxfileSignature)
            {
                throw new InvalidDataException("Not a DAX File");
            }

            var totalBlocks = Header.TotalBlocks;

            //Header.TotalBlocks
            var offsets = Stream.ReadStructVector <uint>(totalBlocks);
            var sizes   = Stream.ReadStructVector <ushort>(totalBlocks);

            NcArea[] ncAreas = null;

            if (Header.Version >= Version.DaxformatVersion1)
            {
                ncAreas = Stream.ReadStructVector <NcArea>(Header.NcAreas);
            }

            Blocks = new BlockInfo[totalBlocks];
            for (var n = 0; n < totalBlocks; n++)
            {
                Blocks[n].Position     = offsets[n];
                Blocks[n].Length       = sizes[n];
                Blocks[n].IsCompressed = true;
            }
            if (Header.Version < Version.DaxformatVersion1)
            {
                return;
            }
            if (ncAreas == null)
            {
                return;
            }

            foreach (var ncArea in ncAreas)
            {
                //Console.WriteLine("{0}-{1}", NCArea.frame, NCArea.size);
                for (var n = 0; n < ncArea.Size; n++)
                {
                    Blocks[ncArea.Frame + n].IsCompressed = false;
                }
            }
        }
コード例 #2
0
ファイル: Psf.cs プロジェクト: rajeshwarn/cspspemu
        public Psf Load(Stream stream)
        {
            EntryDictionary = new Dictionary <string, object>();
            Header          = stream.ReadStruct <HeaderStruct>();
            Entries         = stream.ReadStructVector <EntryStruct>(Header.NumberOfPairs);
            KeysStream      = stream.SliceWithLength(Header.KeyTable);
            ValuesStream    = stream.SliceWithLength(Header.ValueTable);
            foreach (var entry in Entries)
            {
                var key         = KeysStream.ReadStringzAt(entry.KeyOffset);
                var valueStream = ValuesStream.SliceWithLength(entry.ValueOffset, entry.ValueSize);
                switch (entry.DataType)
                {
                case DataType.Binary:
                    EntryDictionary[key] = valueStream.ReadAll();
                    break;

                case DataType.Int:
                    EntryDictionary[key] = valueStream.ReadStruct <int>();
                    break;

                case DataType.Text:
                    EntryDictionary[key] = valueStream.ReadStringz(-1, Encoding.UTF8);
                    break;

                default: throw new NotImplementedException();
                }
            }
            return(this);
        }
コード例 #3
0
        public static T[] ReadStructVectorUntilTheEndOfStream <T>(this Stream Stream) where T : struct
        {
            var EntrySize      = Marshal.SizeOf(typeof(T));
            var BytesAvailable = Stream.Available();

            //Console.WriteLine("BytesAvailable={0}/EntrySize={1}", BytesAvailable, EntrySize);
            return(Stream.ReadStructVector <T>((uint)(BytesAvailable / EntrySize)));
        }
コード例 #4
0
 public static TType[] ReadStructVectorAt <TType>(this Stream Stream, long Offset, uint Count, int EntrySize = -1) where TType : struct
 {
     TType[] Value = null;
     Stream.PreservePositionAndLock(() =>
     {
         Stream.Position = Offset;
         Value           = Stream.ReadStructVector <TType>(Count, EntrySize);
     });
     return(Value);
 }
コード例 #5
0
 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TType"></typeparam>
 /// <param name="stream"></param>
 /// <param name="offset"></param>
 /// <param name="count"></param>
 /// <param name="entrySize"></param>
 /// <returns></returns>
 public static TType[] ReadStructVectorAt <TType>(this Stream stream, long offset, uint count, int entrySize = -1)
     where TType : struct
 {
     TType[] value = null;
     stream.PreservePositionAndLock(() =>
     {
         stream.Position = offset;
         value           = stream.ReadStructVector <TType>(count, entrySize);
     });
     return(value);
 }
コード例 #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="stream"></param>
        public void SetStream(Stream stream)
        {
            //this.Stream = new BufferedStream(Stream, 0x20000);
            Stream = stream;

            // Read the header.
            Header = Stream.ReadStruct <HeaderStruct>();
            if (Header.Magic != 0x4F534943)
            {
                throw new InvalidDataException("Not a CISO File");
            }

            // Read the block list
            Blocks = Stream.ReadStructVector <BlockInfo>((uint)(NumberOfBlocks + 1));
        }
コード例 #7
0
ファイル: Psf.cs プロジェクト: e-COS/cspspemu
 public Psf Load(Stream Stream)
 {
     EntryDictionary = new Dictionary<string, object>();
     Header = Stream.ReadStruct<HeaderStruct>();
     Entries = Stream.ReadStructVector<EntryStruct>(Header.NumberOfPairs);
     KeysStream = Stream.SliceWithLength(Header.KeyTable);
     ValuesStream = Stream.SliceWithLength(Header.ValueTable);
     foreach (var Entry in Entries)
     {
         var Key = KeysStream.ReadStringzAt(Entry.KeyOffset);
         var ValueStream = ValuesStream.SliceWithLength(Entry.ValueOffset, Entry.ValueSize);;
         switch (Entry.DataType)
         {
             case DataType.Binary: EntryDictionary[Key] = ValueStream.ReadAll(); break;
             case DataType.Int: EntryDictionary[Key] = ValueStream.ReadStruct<int>(); break;
             case DataType.Text: EntryDictionary[Key] = ValueStream.ReadStringz(-1, Encoding.UTF8); break;
             default: throw(new NotImplementedException());
         }
     }
     return this;
 }
コード例 #8
0
        public Pgf Load(Stream fileStream)
        {
            Header = fileStream.ReadStruct <HeaderStruct>();

            if (Header.Revision >= 3)
            {
                HeaderExtraRevision3 = fileStream.ReadStruct <HeaderRevision3Struct>();
            }

            fileStream.ReadStructVector(out DimensionTable, Header.TableDimLength);
            fileStream.ReadStructVector(out XAdjustTable, Header.TableXAdjustLength);
            fileStream.ReadStructVector(out YAdjustTable, Header.TableYAdjustLength);
            fileStream.ReadStructVector(out AdvanceTable, Header.TableAdvanceLength);

            PackedShadowCharMap =
                fileStream.ReadBytes(BitsToBytesHighAligned(Header.TableShadowMapLength * Header.TableShadowMapBpe));

            if (Header.Revision == 3)
            {
                fileStream.ReadStructVector(out CharmapCompressionTable1, HeaderExtraRevision3.TableCompCharMapLength1);
                fileStream.ReadStructVector(out CharmapCompressionTable2, HeaderExtraRevision3.TableCompCharMapLength2);
            }

            PackedCharMap =
                fileStream.ReadBytes(BitsToBytesHighAligned(Header.TableCharMapLength * Header.TableCharMapBpe));
            PackedCharPointerTable =
                fileStream.ReadBytes(
                    BitsToBytesHighAligned(Header.TableCharPointerLength * Header.TableCharPointerBpe));

            /*
             * int BytesLeft = (int)(FileStream.Length - FileStream.Position);
             * charData = new byte[BytesLeft];
             * FileStream.Read(charData, 0, BytesLeft);
             */

            CharData = fileStream.ReadBytes((int)(fileStream.Length - fileStream.Position));

            var numberOfCharacters = Header.TableCharPointerLength;

            CharMap              = new int[Header.FirstGlyph + Header.LastGlyph + 1];
            CharPointer          = new int[numberOfCharacters];
            Glyphs               = new IGlyph[numberOfCharacters];
            ReverseCharMap       = new Dictionary <int, int>();
            ShadowCharMap        = new Dictionary <int, int>();
            ReverseShadowCharMap = new Dictionary <int, int>();

            foreach (var pair in BitReader.FixedBitReader(PackedShadowCharMap, Header.TableShadowMapBpe))
            {
                var unicodeIndex = (int)pair.Key + Header.FirstGlyph;
                var glyphIndex   = (int)pair.Value;
                ShadowCharMap[unicodeIndex]      = glyphIndex;
                ReverseShadowCharMap[glyphIndex] = unicodeIndex;
            }

            foreach (var pair in BitReader.FixedBitReader(PackedCharMap, Header.TableCharMapBpe))
            {
                var unicodeIndex = (int)pair.Key + Header.FirstGlyph;
                var glyphIndex   = (int)pair.Value;
                CharMap[unicodeIndex]      = glyphIndex;
                ReverseCharMap[glyphIndex] = unicodeIndex;
            }

            foreach (var pair in BitReader.FixedBitReader(PackedCharPointerTable, Header.TableCharPointerBpe))
            {
                CharPointer[pair.Key] = (int)pair.Value;
            }

            /*
             * for (int n = 0; n < NumberOfCharacters; n++)
             * {
             *  Glyphs[n] = new Glyph().Read(this, n);
             * }
             */

            Console.WriteLine(Header.FontName);

            /*
             * Console.WriteLine(this.header.fontName);
             * for (int n = 0; n < 300; n++)
             * {
             *  Console.WriteLine(GetGlyphId((char)n));
             * }
             */

            return(this);
        }
コード例 #9
0
ファイル: PGF.cs プロジェクト: soywiz/cspspemu
        public PGF Load(Stream FileStream)
        {
            this.Header = FileStream.ReadStruct<HeaderStruct>();

            if (this.Header.Revision >= 3)
            {
                this.HeaderExtraRevision3 = FileStream.ReadStruct<HeaderRevision3Struct>();
            }

            FileStream.ReadStructVector(ref DimensionTable, Header.TableDimLength);
            FileStream.ReadStructVector(ref XAdjustTable, Header.TableXAdjustLength);
            FileStream.ReadStructVector(ref YAdjustTable, Header.TableYAdjustLength);
            FileStream.ReadStructVector(ref AdvanceTable, Header.TableAdvanceLength);

            PackedShadowCharMap = FileStream.ReadBytes(BitsToBytesHighAligned(Header.TableShadowMapLength * Header.TableShadowMapBpe));

            if (Header.Revision == 3)
            {
                FileStream.ReadStructVector(ref CharmapCompressionTable1, HeaderExtraRevision3.TableCompCharMapLength1);
                FileStream.ReadStructVector(ref CharmapCompressionTable2, HeaderExtraRevision3.TableCompCharMapLength2);
            }

            PackedCharMap = FileStream.ReadBytes(BitsToBytesHighAligned(Header.TableCharMapLength * Header.TableCharMapBpe));
            PackedCharPointerTable = FileStream.ReadBytes(BitsToBytesHighAligned(Header.TableCharPointerLength * Header.TableCharPointerBpe));

            /*
            int BytesLeft = (int)(FileStream.Length - FileStream.Position);
            charData = new byte[BytesLeft];
            FileStream.Read(charData, 0, BytesLeft);
            */

            CharData = FileStream.ReadBytes((int)(FileStream.Length - FileStream.Position));

            var NumberOfCharacters = Header.TableCharPointerLength;

            CharMap = new int[Header.FirstGlyph + Header.LastGlyph + 1];
            CharPointer = new int[NumberOfCharacters];
            Glyphs = new Glyph[NumberOfCharacters];
            ReverseCharMap = new Dictionary<int, int>();
            ShadowCharMap = new Dictionary<int, int>();
            ReverseShadowCharMap = new Dictionary<int, int>();

            foreach (var Pair in BitReader.FixedBitReader(PackedShadowCharMap, Header.TableShadowMapBpe))
            {
                var UnicodeIndex = (int)Pair.Key + Header.FirstGlyph;
                var GlyphIndex = (int)Pair.Value;
                ShadowCharMap[UnicodeIndex] = GlyphIndex;
                ReverseShadowCharMap[GlyphIndex] = UnicodeIndex;
            }

            foreach (var Pair in BitReader.FixedBitReader(PackedCharMap, Header.TableCharMapBpe))
            {
                var UnicodeIndex = (int)Pair.Key + Header.FirstGlyph;
                var GlyphIndex = (int)Pair.Value;
                CharMap[UnicodeIndex] = GlyphIndex;
                ReverseCharMap[GlyphIndex] = UnicodeIndex;
            }

            foreach (var Pair in BitReader.FixedBitReader(PackedCharPointerTable, Header.TableCharPointerBpe))
            {
                CharPointer[Pair.Key] = (int)Pair.Value;
            }

            /*
            for (int n = 0; n < NumberOfCharacters; n++)
            {
                Glyphs[n] = new Glyph().Read(this, n);
            }
            */

            Console.WriteLine(this.Header.FontName);

            /*
            Console.WriteLine(this.header.fontName);
            for (int n = 0; n < 300; n++)
            {
                Console.WriteLine(GetGlyphId((char)n));
            }
            */

            return this;
        }
コード例 #10
0
 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TType"></typeparam>
 /// <param name="Stream"></param>
 /// <param name="Vector"></param>
 /// <param name="Count"></param>
 /// <param name="EntrySize"></param>
 /// <returns></returns>
 public static TType[] ReadStructVector <TType>(this Stream Stream, ref TType[] Vector, uint Count, int EntrySize = -1) where TType : struct
 {
     Vector = Stream.ReadStructVector <TType>(Count, EntrySize);
     return(Vector);
 }
コード例 #11
0
ファイル: Xex.cs プロジェクト: soywiz-emulation/cs360emu
        public Xex LoadHeader(Stream XexStream)
        {
            Header = XexStream.ReadStruct<HeaderStruct>();
            var OptionalHeaders = XexStream.ReadStructVector<OptionalHeader>(Header.OptionalHeaderCount);
            Console.WriteLine("{0:X}", XexStream.Position);
            InfoList = new Dictionary<OptionalHeader.Ids, ulong>();
            foreach (var OptionalHeader in OptionalHeaders)
            {
                //Console.WriteLine("{0}: 0x{1:X}", OptionalHeader.Id, (uint)OptionalHeader.Data);
                //InfoList[OptionalHeader.Id] = OptionalHeader.Data;
                InfoList.Add(OptionalHeader.Id, OptionalHeader.Data);

                switch (OptionalHeader.Id)
                {
                    case Xex.OptionalHeader.Ids.OriginalPEName:
                        this.OriginalPeName = LoadChunk(XexStream, OptionalHeader.Data).ReadStringz(Encoding: Encoding.UTF8);
                        break;
                    case Xex.OptionalHeader.Ids.LANKey:
                        this.LanKey = XexStream.SliceWithLength(OptionalHeader.Data, 0x10).ReadAll();
                        break;
                    case Xex.OptionalHeader.Ids.DefaultStackSize:
                        this.DefaultStackSize = OptionalHeader.Data;
                        break;
                    case Xex.OptionalHeader.Ids.ChecksumTimestamp:
                        this.ChecksumTimestamp = XexStream.SliceWithLength(OptionalHeader.Data).ReadStruct<ChecksumTimestampStruct>();
                        break;
                    case Xex.OptionalHeader.Ids.ImageBaseAddress:
                        this.ImageBaseAddress = OptionalHeader.Data;
                        break;
                    case Xex.OptionalHeader.Ids.EntryPoint:
                        this.EntryPoint = OptionalHeader.Data;
                        break;
                    case Xex.OptionalHeader.Ids.StaticLibraries:
                        this.StaticLibs = LoadChunk(XexStream, OptionalHeader.Data).ReadStructVectorUntilTheEndOfStream<StaticLib>();
                        foreach (var StaticLib in StaticLibs)
                        {
                            Console.WriteLine("StaticLib: {0}", StaticLib.ToStringDefault());
                        }
                        break;
                    case Xex.OptionalHeader.Ids.ImportLibraries:
                        {
                            var ImportLibrariesStream = LoadChunk(XexStream, OptionalHeader.Data);
                            var TextLength = (uint)ImportLibrariesStream.ReadStruct<uint_be>();
                            var LibraryCount = (uint)ImportLibrariesStream.ReadStruct<uint_be>();
                            var TextStream = ImportLibrariesStream.ReadStream(TextLength);

                            var LibraryNames = new String[LibraryCount];
                            for (int n = 0; n < LibraryCount; n++)
                            {
                                LibraryNames[n] = TextStream.ReadStringz(AllowEndOfStream: false);
                                Console.WriteLine("ImportLib: {0}", LibraryNames[n]);
                            }

                            var ChunkUnk1 = ReadChunkIncludingTheSize(ImportLibrariesStream);
                            var ImportAddressList = ReadChunkIncludingTheSize(ImportLibrariesStream);
                            Console.Error.WriteLine("@TODO: Xex.OptionalHeader.Ids.ImportLibraries");
                        }
                        break;
                    case Xex.OptionalHeader.Ids.TLSInfo:
                        {
                            this.TLSInfo = XexStream.SliceWithLength(OptionalHeader.Data).ReadStruct<TLSInfoStruct>();
                        }
                        break;
                    default:
                        Console.WriteLine("{0}: 0x{1:X}", OptionalHeader.Id, (uint)OptionalHeader.Data);
                        break;
                }
            }
            PeStream = XexStream.SliceWithLength(Header.PeDataOffset);
            Pe = new Pe().LoadHeader(PeStream);

            Console.WriteLine("SecurityInfoOffset: {0:X}", (uint)Header.SecurityInfoOffset);
            var SecurityStream = LoadChunk(XexStream, Header.SecurityInfoOffset);
            var NumberOfSections = (ushort)SecurityStream.ReadStruct<ushort_be>();
            Console.WriteLine("NumberOfSections: {0:X}", NumberOfSections);

            return this;
        }
コード例 #12
0
 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="TType"></typeparam>
 /// <param name="stream"></param>
 /// <param name="vector"></param>
 /// <param name="count"></param>
 /// <param name="entrySize"></param>
 /// <returns></returns>
 public static TType[] ReadStructVector <TType>(this Stream stream, out TType[] vector, uint count,
                                                int entrySize = -1) where TType : struct
 {
     vector = stream.ReadStructVector <TType>(count, entrySize);
     return(vector);
 }
コード例 #13
0
ファイル: DXT.cs プロジェクト: talestra/tov
        /// <summary>
        ///
        /// </summary>
        /// <param name="File"></param>
        /// <param name="Width"></param>
        /// <param name="Height"></param>
        /// <param name="_Depth"></param>
        /// <param name="Swizzled"></param>
        /// <returns></returns>
        private BitmapList _LoadSwizzled(Stream File, int Width, int Height, int?_Depth, bool Swizzled = true)
        {
            if ((Width % 4) != 0 || (Height % 4) != 0)
            {
                throw (new InvalidDataException(String.Format("Invalid size {0}x{1} must be multiple of 4", Width, Height)));
            }

            int  Depth              = _Depth ?? 1;
            bool Is3D               = _Depth.HasValue;
            var  BitmapList         = new BitmapList(Depth);
            var  BitmapListData     = new BitmapData[Depth];
            var  BitmapListPointers = new ARGB_Rev *[Depth];

            for (int n = 0; n < Depth; n++)
            {
                BitmapList.Bitmaps[n] = new Bitmap(Width, Height);
            }

            for (int n = 0; n < Depth; n++)
            {
                var Bitmap = BitmapList.Bitmaps[n];
                BitmapListData[n]     = Bitmap.LockBits(Bitmap.GetFullRectangle(), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
                BitmapListPointers[n] = (ARGB_Rev *)BitmapListData[n].Scan0.ToPointer();
            }

            int BlockWidth           = Width / 4;
            int BlockHeight          = Height / 4;
            var CurrentDecodedColors = new ARGB_Rev[4 * 4];

            var ExpectedBlockCount = BlockWidth * BlockHeight * Depth;
            int RealUsedBlockCount;

            if (Is3D)
            {
                RealUsedBlockCount = Swizzling.XGAddress3DTiledExtent(Width / 4, Height / 4, Depth, BlockSize);
            }
            else
            {
                RealUsedBlockCount = Swizzling.XGAddress2DTiledExtent(Width / 4, Height / 4, BlockSize);
            }
            //Console.WriteLine("{0} - {1}", ExpectedBlockCount, UsedBlockCount);

            var BlockCount = RealUsedBlockCount;

            //var BlockCount = ExpectedBlockCount;

            if (BlockCount * Marshal.SizeOf(typeof(TBlock)) > File.Length)
            {
                Console.Error.WriteLine("File too small");
                //throw(new Exception("File too small"));
                return(new BitmapList(0));
            }

            var Blocks = File.ReadStructVector <TBlock>((uint)BlockCount, -1);

            //Console.WriteLine(Blocks.Length);

            for (int BlockN = 0; BlockN < BlockCount; BlockN++)
            {
                int TileX, TileY, TileZ;

                if (Swizzled)
                {
                    if (Is3D)
                    {
                        Swizzling.XGAddress3DTiledXYZ(BlockN, BlockWidth, BlockHeight, BlockSize, out TileX, out TileY, out TileZ);
                    }
                    else
                    {
                        Swizzling.XGAddress2DTiledXY(BlockN, BlockWidth, BlockSize, out TileX, out TileY);
                        TileZ = 0;
                    }
                }
                else
                {
                    TileX = BlockN % BlockWidth;
                    TileY = BlockN / BlockWidth;
                    TileZ = 0;
                    Console.Error.Write("(Not implemented!)");
                }

                // Skip blocks.
                if (TileX >= BlockWidth || TileY >= BlockHeight)
                {
                    continue;
                }

                DecodeBlock(ref Blocks[BlockN], ref CurrentDecodedColors);

                //Console.WriteLine("{0}", CurrentDecodedColors[0]);

                int PositionX = TileX * 4;
                int PositionY = TileY * 4;

                var BlockBitmap = BitmapList.Bitmaps[TileZ];

                if ((PositionX + 3 >= BlockBitmap.Width) || (PositionY + 3 >= BlockBitmap.Height))
                {
                    Console.Error.WriteLine(
                        "(Warning! [Read] Position outside ({0}, {1}) - ({2}x{3}) ;; ({4}, {5})) - ({6}x{7}) ;; {8}",
                        PositionX, PositionY,
                        Width, Height,
                        TileX, TileY,
                        BlockWidth, BlockHeight,
                        BlockN
                        );
                    continue;
                }

                int n             = 0;
                var BitmapPointer = BitmapListPointers[TileZ];
                for (int y = 0; y < 4; y++)
                {
                    int BaseOffset = (PositionY + y) * Width + (PositionX);
                    for (int x = 0; x < 4; x++)
                    {
                        BitmapPointer[BaseOffset + x] = CurrentDecodedColors[n];
                        n++;
                    }
                }
            }

            for (int n = 0; n < Depth; n++)
            {
                BitmapList.Bitmaps[n].UnlockBits(BitmapListData[n]);
            }

            return(BitmapList);
        }