internal Entry(FPS4 FPS4, EntryStruct EntryStruct, String Name) { this.FPS4 = FPS4; this.EntryStruct = EntryStruct; this.Name = Name; this._Stream = SliceStream.CreateWithLength((EntryStruct.Offset == 0) ? FPS4.DavStream : FPS4.DatStream, EntryStruct.Offset, EntryStruct.LengthReal); }
public String ReadStringz(int TextOffset) { if (TextOffset < 0 || TextOffset >= TextStream.Length) { return(""); } return((SliceStream.CreateWithLength(TextStream, TextOffset)).ReadStringz(Encoding: Encoding.UTF8)); }
public Stream Open() { #if false if (MappedFileIndex > 0) { return(SliceStream.CreateWithLength(new ZeroStream(this.EntryStruct.LengthReal), 0, this.EntryStruct.LengthReal)); } #endif return(SliceStream.CreateWithLength(this._Stream, 0, this._Stream.Length)); }
static public Stream ReadStream(this Stream Stream, long ToRead = -1) { if (ToRead == -1) { ToRead = Stream.Available(); } var ReadedStream = SliceStream.CreateWithLength(Stream, Stream.Position, ToRead); Stream.Skip(ToRead); return(ReadedStream); }
static public Stream GetStreamByLBA(Stream Stream, long LBA, long Size = -1) { var Offset = LBA * (long)SECTOR_SIZE; if (Offset >= Stream.Length) { throw(new Exception("File too small for a Xbox360 Iso File")); } //Console.WriteLine("0x{0:X8}", Offset); return(SliceStream.CreateWithLength(Stream, Offset, Size)); }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <param name="toRead"></param> /// <returns></returns> public static SliceStream ReadStream(this Stream stream, long toRead = -1) { if (toRead == -1) { toRead = stream.Available(); } var readedStream = SliceStream.CreateWithLength(stream, stream.Position, toRead); stream.Skip(toRead); return(readedStream); }
protected void WriteChunk(string Name, Action Writer) { Stream.WriteStringz(Name, 4, Encoding.ASCII); BinaryWriter.Write((uint)0); var ChunkSizeStream = SliceStream.CreateWithLength(Stream, Stream.Position - 4, 4); var BackPosition = Stream.Position; { Writer(); } var ChunkLength = Stream.Position - BackPosition; new BinaryWriter(ChunkSizeStream).Write((uint)ChunkLength); }
public Stream OpenRead() { switch (LocalFileHeader.CompressionMethod) { case CompressionMethod.Stored: return(SliceStream.CreateWithLength(CompressedStream)); case CompressionMethod.Deflate: return(new DeflateStream(SliceStream.CreateWithLength(CompressedStream), CompressionMode.Decompress)); default: throw(new NotImplementedException("Not Implementeed : " + LocalFileHeader.CompressionMethod)); } }
override public void Load(Stream Stream) { this.Stream = Stream; var HeaderStruct = Stream.ReadStruct <HeaderStruct>(); Debug.Assert(HeaderStruct.Magic == "TO8CHTX"); Debug.Assert(HeaderStruct.FileSize <= Stream.Length); StreamEntries = SliceStream.CreateWithLength(Stream, HeaderStruct.OffsetEntries); StreamTexts = SliceStream.CreateWithLength(Stream, HeaderStruct.OffsetTexts); for (int n = 0; n < HeaderStruct.TextCount; n++) { var EntryStruct = StreamEntries.ReadStruct <EntryStruct>(); var Entry = new Entry(); Entry.Load(this, EntryStruct); Entries.Add(Entry); } }
public TSS Load(Stream Stream) { this.Stream = Stream; var BinaryReader = new BinaryReader(Stream); Header = Stream.ReadStruct <HeaderStruct>(); if (Header.Magic != "TSS") { throw(new Exception("Not a TSS file!")); } this.CodeStream = new MemoryStream(SliceStream.CreateWithBounds(Stream, Header.CodeStart, Header.TextStart).ReadAll()); var TextData = SliceStream.CreateWithLength(Stream, Header.TextStart, Header.TextLen).ReadAll(); this.TextStream = new MemoryStream(); this.TextStream.WriteBytes(TextData); this.TextStream.Position = 0; return(this); }
private IEnumerable <dynamic> GetElements(bool AsInt) { var ArrayStream = SliceStream.CreateWithLength(TSS.TextStream, ArrayPointer, ArrayNumberOfBytes); { switch (ValuesType) { case ValueType.String: if (!AsInt) { for (int n = 0; n < ArrayNumberOfElements; n++) { yield return(TSS.ReadStringz((int)(uint)ArrayStream.ReadStruct <uint_be>())); } } else { for (int n = 0; n < ArrayNumberOfElements; n++) { yield return((int)(uint)ArrayStream.ReadStruct <uint_be>()); } } break; case ValueType.Integer32Signed: for (int n = 0; n < ArrayNumberOfElements; n++) { yield return((int)(uint)ArrayStream.ReadStruct <uint_be>()); } break; case ValueType.Float32: if (!AsInt) { for (int n = 0; n < ArrayNumberOfElements; n++) { yield return((float)ArrayStream.ReadStruct <float_be>()); } } else { for (int n = 0; n < ArrayNumberOfElements; n++) { yield return((int)(uint)ArrayStream.ReadStruct <uint_be>()); } } break; default: { Console.Error.WriteLine("Unhandled " + ValuesType + "(" + ArrayPointer + "," + ArrayNumberOfBytes + ")[" + ArrayNumberOfElements + "]"); //if (ArrayNumberOfElements == 0) //{ // yield return "<TODO " + "Unhandled " + ValuesType + "(" + ArrayPointer + "," + ArrayNumberOfBytes + ")>"; //} //else { yield return("<TODO " + "Unhandled " + ValuesType + ">"); for (int n = 0; n < ArrayNumberOfBytes; n++) { yield return("" + ArrayStream.ReadStruct <byte>()); } } } break; //throw (new Exception("Unhandled " + ValuesType)); } } }
public int CountStringz(int TextOffset) { return((SliceStream.CreateWithLength(TextStream, TextOffset)).CountStringzBytes(AlignTo4: false, AlignPosition: (int)TextOffset)); }
static public SliceStream SliceWithLength(this Stream BaseStream, long ThisStart = 0, long ThisLength = -1, bool?CanWrite = null) { return(SliceStream.CreateWithLength(BaseStream, ThisStart, ThisLength, CanWrite)); }
static public SliceStream Slice(this Stream BaseStream) { return(SliceStream.CreateWithLength(BaseStream)); }
/// <summary> /// /// </summary> /// <param name="baseStream"></param> /// <param name="thisStart"></param> /// <param name="thisLength"></param> /// <param name="canWrite"></param> /// <returns></returns> public static SliceStream SliceWithLength(this Stream baseStream, long thisStart = 0, long thisLength = -1, bool?canWrite = null) { return(SliceStream.CreateWithLength(baseStream, thisStart, thisLength, canWrite)); }
public override void DecodeFile(Stream InputStream, Stream OutputStream) { byte[] CompressedBytes = new byte[0x10000]; byte[] UncompressedBytes = new byte[0x10000]; var BinaryWriter = new BinaryWriter(OutputStream); using (var LZXState = new LZXState(17)) { var BinaryReader = new BinaryReader(InputStream); HeaderStruct HeaderStruct = InputStream.ReadStruct <HeaderStruct>(); if (!HeaderStruct.Magic.SequenceEqual(Signature)) { throw (new Exception("File is not a TOV.LZX")); } if (HeaderStruct.Magic1 != 0x20000) { throw (new Exception("Invalid LZX")); } if (HeaderStruct.Magic2 != 0x80000) { throw (new Exception("Invalid LZX")); } if (HeaderStruct.Magic3 != 0x00000) { throw (new Exception("Invalid LZX")); } if (HeaderStruct.Magic4 != 0x00000) { throw (new Exception("Invalid LZX")); } if (HeaderStruct.UncompressedSize != HeaderStruct.UncompressedSize2) { throw (new Exception("Invalid LZX")); } if (HeaderStruct.CompressedSize != HeaderStruct.CompressedSize2) { throw (new Exception("Invalid LZX")); } if (HeaderStruct.CompressedSizePlus4 != HeaderStruct.CompressedSize + 4) { throw (new Exception("Invalid LZX")); } //if (InputStream.Position != 0x34); //Console.WriteLine(InputStream.Length); //Console.WriteLine(0x34 + HeaderStruct.CompressedSize); if (InputStream.Length < 0x34 + HeaderStruct.CompressedSize) { throw(new Exception("Invalid LZX")); } var DataInputStream = SliceStream.CreateWithLength(InputStream, 0x34, HeaderStruct.CompressedSize); var DataBinaryReader = new BinaryReader(DataInputStream); DataInputStream.Position = 0; while (DataInputStream.Position < DataInputStream.Length) { ushort UncompressedChunkLength, CompressedChunkLength; //Console.WriteLine(DataInputStream.Position + ":" + DataInputStream.Length); // Read Chunk's size. { byte Byte1, Byte2; Byte1 = DataBinaryReader.ReadByte(); if (Byte1 != 0xFF) { Byte2 = DataBinaryReader.ReadByte(); UncompressedChunkLength = 0x8000; CompressedChunkLength = (ushort)((Byte1 << 8) | Byte2); } else { UncompressedChunkLength = DataBinaryReader.ReadUint16Endian(Endianness.BigEndian); CompressedChunkLength = DataBinaryReader.ReadUint16Endian(Endianness.BigEndian); } if (CompressedChunkLength >= UncompressedChunkLength) { //Console.WriteLine("CompressedChunkLength >= UncompressedChunkLength"); //Console.WriteLine("{0} -> {1}", CompressedChunkLength, UncompressedChunkLength); } } //Console.WriteLine("CHUNK: {0,8:X}, {1,8:X}, {2,8:X}", DataInputStream.Position, CompressedChunkLength, UncompressedChunkLength); if (CompressedChunkLength == 0) { DataInputStream.Seek(-2, SeekOrigin.Current); Debug.WriteLine("WARNING: Block with length 0: end!"); break; } DataInputStream.Read(CompressedBytes, 0, CompressedChunkLength); //Debug.Assert(CompressedChunkLength < UncompressedChunkLength); { fixed(byte *CompressedBytesPtr = CompressedBytes) fixed(byte *UncompressedBytesPtr = UncompressedBytes) { //Console.WriteLine("{0} -> {1}", CompressedChunkLength, UncompressedChunkLength); LZXState.Decompress(CompressedBytesPtr, UncompressedBytesPtr, CompressedChunkLength, UncompressedChunkLength); } BinaryWriter.Write(UncompressedBytes, 0, UncompressedChunkLength); } } //Console.WriteLine("{0:X}", DataInputStream.Position); //Console.WriteLine("{0:X}", DataInputStream.Length); //Console.WriteLine("{0:X}", HeaderStruct.FileSizeMinusX30 + 0x30); if (DataInputStream.Position != DataInputStream.Length) { throw(new Exception("Not readed all the contents")); } if (!(SliceStream.CreateWithLength(InputStream, 0x34 + HeaderStruct.CompressedSize)).ReadAll().All(Byte => (Byte == 0))) { throw(new Exception("?")); } } }