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