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); }
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); } }
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, }); }
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)); }
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."); } }
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); }
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); }
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; }
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)); } }
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); }
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); }
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); }
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>(); } }
public static byte[] ReadAllBytes(this Stream stream) { var data = stream.SetPosition(0).ReadBytes(); stream.Position = 0; return(data); }
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)); } }
public byte[] ReadRawData() { var data = new byte[_header.CompressedLength >= 0 ? _header.CompressedLength : _header.DecompressedLength]; data = _stream.SetPosition(_dataOffset).ReadBytes(data.Length); return(data); }
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); } }
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); }
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)); }
private void OnPlaybackStopped(object sender, StoppedEventArgs e) { if (e.Exception == null) { _stream.SetPosition(0); } _waveOutDevice.Play(); }
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); }
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)); }
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); }
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); }
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); }
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); }
public static bool IsValid(Stream stream) { if (stream.SetPosition(0).ReadInt32() != MagicCode || stream.ReadInt32() != 1 || stream.Length < 0x50) { return(false); } return(true); }
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(); }
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; } } }
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); }