public void Save(Stream output, IList <IArchiveFileInfo> files) { using var bw = new BinaryWriterX(output); // Calculate offsets var metaOffset = BlockSize; var blockOffset = metaOffset + _header.entryCount * MetaSize; var blockOffsetEnd = blockOffset + BlockOffsetHeaderSize + files.Count * BlockOffsetSize; var fileOffset = (blockOffsetEnd + (BlockSize - 1)) & ~(BlockSize - 1); // Write files var blockOffsets = new List <NlpBlockOffset>(); var metas = Enumerable.Repeat(new NlpMeta(), _header.entryCount).ToArray(); var filePosition = fileOffset; foreach (var file in files.Cast <NlpArchiveFileInfo>()) { // Write file output.Position = filePosition; var writtenSize = file.SaveFileData(output); bw.WriteAlignment(BlockSize); // Update meta entry AdjustMeta(file); metas[file.Id] = file.Meta; // Add block offset entry blockOffsets.Add(new NlpBlockOffset { metaId = file.Id, offset = (filePosition - BlockSize) / BlockSize }); filePosition += (int)((writtenSize + (BlockSize - 1)) & ~(BlockSize - 1)); } // Write metas output.Position = metaOffset; bw.WriteMultiple(metas); // Write block offsets output.Position = blockOffset; bw.WriteType(new NlpBlockOffsetHeader { entryCount = files.Count, offset = blockOffset + BlockOffsetHeaderSize - BlockSize }); bw.WriteMultiple(blockOffsets); bw.WriteAlignment(BlockSize); // Write header output.Position = 0; _header.fileBlockOffset = (fileOffset - BlockSize) / BlockSize; _header.entryCount = metas.Length; _header.blockEntriesOffset = blockOffset - BlockSize; _header.unkOffset = blockOffsetEnd - BlockSize; bw.WriteType(_header); }
public void Save(Stream output, IArchiveFileInfo file) { using var bw = new BinaryWriterX(output); // Calculate offsets var subHeaderOffset = _header.dataStart; var fileOffset = (subHeaderOffset + SubHeaderSize + 0x7F) & ~0x7F; // Write file output.Position = fileOffset; var writtenSize = (file as ArchiveFileInfo).SaveFileData(output); bw.WriteAlignment(0x80); // Write sub header output.Position = subHeaderOffset; _subHeader.size = (int)writtenSize; bw.WriteType(_subHeader); // Write header output.Position = 0; _header.size = (int)output.Length; bw.WriteType(_header); }
/// <summary> /// /// </summary> /// <param name="output"></param> /// <returns></returns> public bool Save(Stream output) { using (var bw = new BinaryWriterX(output, true)) { bw.WriteType(_header); bw.BaseStream.Position = 0x40; bw.WriteMultiple(_padding); var offsetTablePos = bw.BaseStream.Position; bw.BaseStream.Position += (0x14 * _header.FileCount); foreach (var b in Bitmaps) { bw.WriteString(b.Name, System.Text.Encoding.ASCII, false, true); } var newOffsets = new List <OffsetEntry>(); foreach (var b in Bitmaps) { var kbi = b as KsltBitmapInfo; newOffsets.Add(new OffsetEntry() { Offset = (int)bw.BaseStream.Position }); kbi.Header.Width = (short)kbi.Image.Width; kbi.Header.Height = (short)kbi.Image.Height; kbi.Header.DataSize = kbi.ImageData.Length; bw.WriteType(kbi.Header); bw.Write(kbi.ImageData); } bw.BaseStream.Position = offsetTablePos; bw.WriteMultiple(newOffsets); } return(true); }
public void Save(Stream xpck) { using (BinaryWriterX bw = new BinaryWriterX(xpck)) { int absDataOffset = header.dataOffset; //Files var files = Files.OrderBy(x => x.Entry.fileOffset).ToList(); var dataOffset = absDataOffset; foreach (var file in files) { dataOffset = file.Write(bw.BaseStream, dataOffset, absDataOffset); } //Entries bw.BaseStream.Position = 0x14; foreach (var file in Files) { bw.WriteType(file.Entry); } //Namelist bw.Write(compNameTable); //Header header.tmp6 = (uint)(bw.BaseStream.Length - absDataOffset) >> 2; bw.BaseStream.Position = 0; bw.WriteType(header); } }
public void Save(Stream output, IList <ArchiveFileInfo> files) { var castedFiles = files.Cast <ArcvArchiveFileInfo>().ToArray(); using var bw = new BinaryWriterX(output); bw.BaseStream.Position = (_headerSize + files.Count * _entrySize + 0x7F) & ~0x7F; // Write files foreach (var file in castedFiles) { file.Entry.offset = (int)bw.BaseStream.Position; file.Entry.size = (int)file.FileSize; file.SaveFileData(bw.BaseStream, null); } // Write header bw.BaseStream.Position = 0; bw.WriteType(new ArcvHeader { fileSize = (int)output.Length, fileCount = files.Count }); // Write file entries foreach (var file in castedFiles) { bw.WriteType(file.Entry); } // Pad with 0xAF to first file bw.WriteAlignment(0x80, 0xAC); }
public void Save(Stream output, ImageInfo imageInfo) { using var bw = new BinaryWriterX(output); // Calculate offsets var dataHeaderOffset = HeaderSize; var dataOffset = dataHeaderOffset + DataHeaderSize; // Compress image data output.Position = dataOffset; Compressions.ZLib.Build().Compress(new MemoryStream(imageInfo.ImageData), output); // Write data header output.Position = dataHeaderOffset; bw.WriteType(new RtexDataHeader { decompSize = imageInfo.ImageData.Length }); // Update header var paddedSize = imageInfo.PadSize.Build(imageInfo.ImageSize); _header.dataOffset = dataHeaderOffset; _header.dataSize = (int)output.Length - dataHeaderOffset; _header.format = (byte)imageInfo.ImageFormat; _header.width = (short)imageInfo.ImageSize.Width; _header.height = (short)imageInfo.ImageSize.Height; _header.paddedWidth = (short)paddedSize.Width; _header.paddedHeight = (short)paddedSize.Height; // Write header output.Position = 0; bw.WriteType(_header); }
/// <summary> /// Write an HTEX file to disk. /// </summary> /// <param name="output">A writable stream of an HTEX file.</param> public void Save(Stream output) { using (var bw = new BinaryWriterX(output)) { bw.BaseStream.Position = Common.PacketHeaderXSize * 3; ImageStream.Position = 0; ImageStream.CopyTo(bw.BaseStream); _htsfPacketHeader.DataSize = (int)bw.BaseStream.Position - Common.PacketHeaderXSize * 2; // Footers _htsfPacketHeader.PacketSize = (int)bw.BaseStream.Position - Common.PacketHeaderXSize * 2; bw.WriteType(_htsfFooter); _packetHeader.PacketSize = (int)bw.BaseStream.Position - Common.PacketHeaderXSize; bw.WriteType(_htexFooter); // Write Packet Header bw.BaseStream.Position = 0; bw.WriteType(_packetHeader); // Write HTSF Packet Header bw.WriteType(_htsfPacketHeader); // Write HTSF Header bw.WriteType(_htsfHeader); } }
public void Write(Stream input) { using var bw = new BinaryWriterX(input, _byteOrder); // Calculate offsets var texHeaderOffset = 0x14 + CommonHeader.sectionOffsets.Length * 4; // Write tex header input.Position = texHeaderOffset; bw.WriteType(Header); // Write image data input.Position = CommonHeader.sectionOffsets[0]; bw.Write(ImageData); foreach (var mipData in MipData) { bw.Write(mipData); } // Write common header CommonHeader.size = (int)input.Length; CommonHeader.bresOffset = 0; CommonHeader.nameOffset = 0; input.Position = 0; bw.WriteType(CommonHeader); }
public void Save(Stream output, TextEntry textEntry) { using (var bw = new BinaryWriterX(output, true)) { _content.CharacterCount = (short)textEntry.EditedText.Trim().Length; _content.CharacterDataSize = (short)Encoding.UTF8.GetByteCount(textEntry.EditedText); bw.WriteType(_content); bw.WriteType(_drawingFrames[0]); short newFrame = _drawingFrames[0].FrameCounter; string TextLength = textEntry.EditedText.Trim(); TextLength = TextLength.Replace("\r", "").Replace("\n", ""); for (var i = 1; i < TextLength.Length; i++) { bw.WriteType(_drawingFrames[0].Indicator); newFrame += 0x0C; bw.Write(newFrame); } for (var i = 0; i < TextLength.Length; i++) { bw.WriteType(_colorStructs[0]); } bw.WriteString(textEntry.EditedText, Encoding.UTF8, false); } }
public void Save(Stream output, ImageInfo imageInfo) { using var bw = new BinaryWriterX(output); // Write image data output.Position = _entry.dataOffset; bw.Write(imageInfo.ImageData); bw.WritePadding(0x10); // Write entry _entry.width = (short)imageInfo.ImageSize.Width; _entry.height = (short)imageInfo.ImageSize.Height; _entry.dataSize = imageInfo.ImageData.Length; output.Position = _header.entryOffset; bw.WriteType(_entry); bw.Write(1); // Write header _header.dataSize = imageInfo.ImageData.Length + 0x20; _header.fileSize = (int)output.Length; output.Position = 0; bw.WriteType(_header); }
public void Save(Stream output, ImageInfo imageInfo) { using var bw = new BinaryWriterX(output); // Calculate offsets var texOffset = HeaderSize + imageInfo.ImageData.Length; // Write image data bw.WriteType(new ImgHeader { magic = "IMG0", size = imageInfo.ImageData.Length }); bw.Write(imageInfo.ImageData); // Write tex header bw.WriteType(new ImgHeader { magic = "TEXR", size = 0x10 }); bw.WriteType(new ImgEntry { width = imageInfo.ImageSize.Width, height = imageInfo.ImageSize.Height }); // Write end header bw.WriteString("!END", Encoding.ASCII, false, false); bw.WritePadding(3); }
public static void WriteEntrySection(Stream input, DirectoryEntry rootEntry, IList <string> strings, IList <long> dataOffsets, bool writeFileData = true) { using var bw = new BinaryWriterX(input, true); var position = input.Position; // Write dir entry input.Position = position + 0x20; bw.WriteType(new ApkTocEntry { flags = 1, stringIndex = strings.IndexOf(""), offset = 1, count = rootEntry.Directories.Count + rootEntry.Files.Count }); // Write entries var entryCount = WriteEntries(input, rootEntry, strings, dataOffsets, writeFileData); var endPosition = input.Position; // Write entry header input.Position = position + 0x10; bw.WriteType(new ApkTocHeader { entryCount = entryCount }); // Write section header input.Position = position; bw.WriteType(new ApkSectionHeader { magic = ApkSection.PackToc, sectionSize = (int)((endPosition - position - 0x10 + 0xF) & ~0xF) }); }
public void Save(Stream output, IList <IArchiveFileInfo> files) { using var bw = new BinaryWriterX(output); var fileEntryStartOffset = _headerSize; var nameStartOffset = _headerSize + files.Count * _fileEntrySize; // Write names var fileOffset = 0; var nameOffset = 0; var fileEntries = new List <Lpc2FileEntry>(); foreach (var file in files) { fileEntries.Add(new Lpc2FileEntry { fileOffset = fileOffset, fileSize = (int)file.FileSize, nameOffset = nameOffset }); bw.BaseStream.Position = nameStartOffset + nameOffset; bw.WriteString(file.FilePath.FullName, Encoding.ASCII, false); nameOffset = (int)bw.BaseStream.Position - nameStartOffset; fileOffset += (int)file.FileSize; } // Write file data var dataOffset = (int)bw.BaseStream.Position; foreach (var file in files.Cast <ArchiveFileInfo>()) { file.SaveFileData(bw.BaseStream, null); } // Write file entries bw.BaseStream.Position = fileEntryStartOffset; foreach (var fileEntry in fileEntries) { bw.WriteType(fileEntry); } // Write header bw.BaseStream.Position = 0; bw.WriteType(new Lpc2Header { fileEntryOffset = fileEntryStartOffset, nameOffset = nameStartOffset, dataOffset = dataOffset, fileCount = files.Count, headerSize = _headerSize, fileSize = (int)bw.BaseStream.Length }); }
public void Save(Stream output, IList <IArchiveFileInfo> files) { using var bw = new BinaryWriterX(output, _header.byteOrder); // Calculate offsets var sizeOffset = HeaderSize; var unknownValueOffset = sizeOffset + files.Count * 4; var dataOffset = unknownValueOffset + files.Count * 8; // Write files var offsets = new List <int>(); foreach (var file in files.Cast <PackArchiveFileInfo>()) { offsets.Add(dataOffset); // Write file name output.Position = dataOffset + 8; bw.WriteString(file.FilePath.GetName(), Encoding.ASCII, false); // Pad to file start var alignment = PackSupport.GetAlignment(file.FilePath.GetExtensionWithDot()); output.Position = dataOffset + 0x28; bw.WriteAlignment(alignment); file.Entry.fileStart = (short)(output.Position - dataOffset); // Write file data output.Position = dataOffset + file.Entry.fileStart; var writtenSize = file.SaveFileData(output); var nextOffset = output.Position; // Write file entry file.Entry.fileSize = (uint)writtenSize; output.Position = dataOffset; bw.WriteType(file.Entry); dataOffset = (int)nextOffset; } // Write unknown values output.Position = unknownValueOffset; bw.WriteMultiple(_unknownValues); // Write offsets output.Position = sizeOffset; bw.WriteMultiple(offsets); // Write header _header.fileCount = (short)files.Count; _header.size = (int)output.Length; output.Position = 0; bw.WriteType(_header); }
public void Save(Stream output, IList <ImageInfo> imageInfos) { using var bw = new BinaryWriterX(output); // Calculate offsets var unkRegionOffset = HeaderSize; var offsetsOffset = unkRegionOffset + imageInfos.Count * 4; var dataOffset = offsetsOffset + imageInfos.Count * 4; // Write image data var offsets = new List <int>(); output.Position = dataOffset; foreach (var imageInfo in imageInfos.Cast <G1tImageInfo>()) { offsets.Add((int)(output.Position - offsetsOffset)); // Update entry imageInfo.Entry.Width = imageInfo.ImageSize.Width; imageInfo.Entry.Height = imageInfo.ImageSize.Height; imageInfo.Entry.format = (byte)imageInfo.ImageFormat; // Write entry bw.WriteType(imageInfo.Entry); // Write image data bw.Write(imageInfo.ImageData); // Write mips if (imageInfo.MipMapCount > 0) { foreach (var mip in imageInfo.MipMapData) { bw.Write(mip); } } } // Write offsets output.Position = offsetsOffset; bw.WriteMultiple(offsets); // Write unknown region output.Position = unkRegionOffset; bw.WriteMultiple(_unkRegion); // Write header _header.dataOffset = offsetsOffset; _header.texCount = imageInfos.Count; _header.fileSize = (int)output.Length; output.Position = 0; bw.WriteType(_header); }
public void Save(Stream output, ImageInfo image) { using var bw = new BinaryWriterX(output, _header.byteOrder); // Calculate offsets var nw4cOffset = ((image.ImageData.Length + 0xF) & ~0xF); var headerOffset = nw4cOffset + Nw4CHeaderSize; // Write image data output.Write(image.ImageData); // Write NW4C header _header.fileSize = headerOffset + 0x8 + (_bclimHeader == null ? BflimHeaderSize : BclimHeaderSize); output.Position = nw4cOffset; bw.WriteType(_header); // Write img header if (_bclimHeader != null) { _bclimHeader.format = (byte)image.ImageFormat; _bclimHeader.dataSize = image.ImageData.Length; _bclimHeader.width = (short)image.ImageSize.Width; _bclimHeader.height = (short)image.ImageSize.Height; var section = new NW4CSection <BclimHeader> { magic = "imag", sectionSize = 0x4 + BclimHeaderSize, sectionData = _bclimHeader }; output.Position = headerOffset; bw.WriteType(section); } else { _bflimHeader.format = (byte)image.ImageFormat; _bflimHeader.dataSize = image.ImageData.Length; _bflimHeader.width = (short)image.ImageSize.Width; _bflimHeader.height = (short)image.ImageSize.Height; var section = new NW4CSection <BclimHeader> { magic = "imag", sectionSize = 0x4 + BclimHeaderSize, sectionData = _bclimHeader }; output.Position = headerOffset; bw.WriteType(section); } }
public void GenericWriting() { var expect = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x04, 0xF8, 0x0F, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x34, 0x34, 0x34, 0x35, 0x36, 0x34, 0x05, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x04, 0xF8, 0x10, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x34, 0x34, 0x34, 0x35, 0x36, 0x34, 0x05, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x04, 0xF8, 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x34, 0x34, 0x34, 0x35, 0x36, 0x34, 0x05, 0x00, 0x00, 0x00, 0xFC }; var ms = new MemoryStream(); using (var bw = new BinaryWriterX(ms)) { var examp = new TestClass { exp0 = true, exp1 = 0x04, exp2 = new TestClass.TestClass2 { val1 = 0x0F, val2 = 0x00, val3 = 0x1F }, exp3 = new byte[] { 0x11, 0x11, 0x11 }, exp4 = new List <byte> { 0x22, 0x22, 0x22, 0x22 }, exp5 = "444564", exp6 = new TestClass.TestClass3 { val1 = 0x05 }, exp7 = 0xFF }; bw.WriteType(examp); examp.exp2.val1++; bw.WriteType(examp); examp.exp2.val1++; bw.WriteType(examp); Assert.IsTrue(ms.ToArray().SequenceEqual(expect)); } }
public void Save(Stream output, IList <IArchiveFileInfo> files) { var dataPosition = (_headerSize + (files.Count + 1) * 4 + 0x7F) & ~0x7F; using var bw = new BinaryWriterX(output); // Write files bw.BaseStream.Position = dataPosition; var offsets = new List <uint>(); foreach (var file in files.Cast <ArchiveFileInfo>()) { offsets.Add((uint)bw.BaseStream.Position); file.SaveFileData(bw.BaseStream, null); bw.WriteAlignment(0x80); } // Write offsets bw.BaseStream.Position = _headerSize; bw.WriteMultiple(offsets); bw.Write(bw.BaseStream.Length); // Write header bw.BaseStream.Position = 0; bw.WriteType(new PcHeader { entryCount = (short)files.Count }); }
private Stream WriteInstructions(IList <Instruction> instructions) { var instructionStream = new MemoryStream(); var argumentOffset = 0; using var bw = new BinaryWriterX(instructionStream, true); foreach (var instruction in instructions) { bw.WriteType(new Xq32Instruction { subType = (short)instruction.InstructionType, argOffset = (short)argumentOffset, argCount = (short)instruction.Arguments.Count, returnParameter = (short)instruction.ReturnParameter }); argumentOffset += instruction.Arguments.Count; } instructionStream.Position = 0; return(instructionStream); }
public void Save(Stream output, IArchiveFileInfo file) { using var bw = new BinaryWriterX(output); // Calculate offsets var sizeOffset = HeaderSize; var blockCount = file.ContentChanged ? (int)Math.Ceiling(file.FileSize / (float)_header.decompBlockSize) : _blockSizes.Count; var dataOffset = (sizeOffset + blockCount * 4 + 0x7F) & ~0x7F; // Chunk stream into blocks output.Position = dataOffset; var blockSizes = _blockSizes; if (file.ContentChanged) { blockSizes = GzStream.ChunkStream(file.GetFileData().Result, output, _header.decompBlockSize, 0x80); _header.decompSize = (int)file.FileSize; } else { _origStream.Position = 0; _origStream.CopyTo(output); } // Write header _header.blockCount = blockSizes.Count; output.Position = 0; bw.WriteType(_header); // Write block sizes bw.WriteMultiple(blockSizes); }
/// <summary> /// Saves the metadata and files into a PAC archive. /// </summary> /// <param name="output">An output stream for a PAC archive.</param> /// <param name="files">The files to save.</param> /// <returns>True if successful.</returns> public bool Save(Stream output, IList <ArchiveFileInfo> files) { using (var bw = new BinaryWriterX(output, true)) { // Header bw.WriteType(_header); var offsetPosition = bw.BaseStream.Position; // Skip Offsets bw.BaseStream.Position += _header.FileCount * sizeof(int); bw.WriteAlignment(EntryAlignment); // Entries bw.WriteMultiple(_entries); bw.WriteAlignment(FileAlignment); // Files var offsets = new List <int>(); foreach (var afi in files) { offsets.Add((int)bw.BaseStream.Position); bw.Write((int)afi.FileSize); bw.Write(FileAlignment); bw.WriteAlignment(FileAlignment); afi.SaveFileData(bw.BaseStream, null); bw.WriteAlignment(FileAlignment); } // Offsets bw.BaseStream.Position = offsetPosition; bw.WriteMultiple(offsets); } return(true); }
public void Save(Stream output, IList <IArchiveFileInfo> files) { using var bw = new BinaryWriterX(output); var castedFiles = files.Cast <BinArchiveFileInfo>(); // Write files foreach (var file in castedFiles) { var offset = (file.Entry.offSize >> _header.shiftFactor) * _header.padFactor; output.Position = offset; file.SaveFileData(output); } bw.WriteAlignment(_header.padFactor); // Write header output.Position = 0; bw.WriteType(_header); // Write entries foreach (var file in castedFiles) { bw.Write(file.Entry.offSize); } }
public void Save(Stream output, ImageInfo imageInfo) { using var bw = new BinaryWriterX(output); // Calculate offsets var texDataOffset = (HeaderSize + 0x7F) & ~0x7F; // Write image data output.Position = texDataOffset; output.Write(imageInfo.ImageData); // Write header var paddedSize = imageInfo.PadSize.Build(imageInfo.ImageSize); var header = new RawJtexHeader { dataOffset = (uint)texDataOffset, format = imageInfo.ImageFormat, width = imageInfo.ImageSize.Width, height = imageInfo.ImageSize.Height, paddedWidth = paddedSize.Width, paddedHeight = paddedSize.Height }; output.Position = 0; bw.WriteType(header); }
public void VariableLengthNestedFields() { var expect = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00 }; var ms = new MemoryStream(); using (var bw = new BinaryWriterX(ms)) { var tc2 = new TestClass2 { var0 = 1, var1 = new TestClass2.TestClass2_2 { var2 = 2 }, var3 = new byte[2], var4 = new TestClass2.TestClass2_3 { var0 = 3, var5 = new byte[1] } }; bw.WriteType(tc2); Assert.IsTrue(ms.ToArray().SequenceEqual(expect)); } }
public void Save(Stream output, IList <IArchiveFileInfo> files) { using var bw = new BinaryWriterX(output); // Calculate offsets var entryOffset = 4; var fileOffset = entryOffset + files.Count * EntrySize; // Write files var entries = new List <TD1Entry>(); var filePosition = fileOffset; foreach (var file in files.Cast <ArchiveFileInfo>()) { output.Position = filePosition; var writtenSize = file.SaveFileData(output); entries.Add(new TD1Entry { offset = filePosition >> 2, size = (int)writtenSize }); filePosition += (int)((writtenSize + 3) & ~3); } // Write entries output.Position = entryOffset; bw.WriteMultiple(entries); // Write file count output.Position = 0; bw.WriteType(files.Count); }
public void Save(Stream output, IList <IArchiveFileInfo> files) { output.Position = HeaderSize; // Write directory table _header.directoryOffset = HeaderSize; _header.directoryCount = files.Select(x => x.FilePath.GetDirectory()).Distinct().Count(); WriteDirectoryTable(output, files); // Write file entries _header.fileOffset = (int)output.Position; _header.fileCount = files.Count; WriteFileTable(output, files); // Write unknown table _header.unkOffset = (int)output.Position; output.Write(_unkTable); // Write strings _header.stringOffset = (int)output.Position; WriteStrings(output, files); // Write files _header.fileDataOffset = (int)output.Position; WriteFiles(output, files); // Write header _header.decompressedTableSize = _header.directoryCount * DirectoryEntrySize + _header.fileCount * FileEntrySize; output.Position = 0; using var bw = new BinaryWriterX(output); bw.WriteType(_header); }
/// <summary> /// Write the RomFs structure. /// </summary> /// <param name="output">The stream to write to.</param> /// <param name="metaData">The meta data for the RomFs.</param> /// <returns>The size of the RomFs partition and its header size.</returns> private static (long, long) WriteRomFs(Stream output, MetaData metaData) { var masterHashPosition = 0x60; var metaDataPosition = BlockSize_; // Write meta data output.Position = metaDataPosition; var metaDataSize = WriteMetaData(output, metaData); // Write IVFC levels var levelData = WriteIvfcLevels(output, metaDataPosition, metaDataSize, masterHashPosition, 3); // Write RomFs header using var bw = new BinaryWriterX(output, true); bw.BaseStream.Position = 0; bw.WriteType(new NcchRomFsHeader { masterHashSize = (int)levelData[2].Item2, lv1LogicalOffset = 0, lv1HashDataSize = levelData[1].Item2, lv2LogicalOffset = levelData[1].Item3, lv2HashDataSize = levelData[0].Item2, lv3LogicalOffset = levelData[1].Item3 + levelData[0].Item3, lv3HashDataSize = metaDataSize }); var romFsSize = levelData[0].Item1 + levelData[0].Item3; var romFsHeaderSize = 0x60 + levelData[2].Item2; return(romFsSize, romFsHeaderSize); }
public void Save(Stream output, IList <IArchiveFileInfo> files) { using var bw = new BinaryWriterX(output); // Calculate offsets var sizeOffset = HeaderSize; var fileOffset = (sizeOffset + files.Count * 4 + 0xF) & ~0xF; // Write files var sizes = new List <int>(); output.Position = fileOffset; foreach (var file in files.Cast <ArchiveFileInfo>()) { var writtenSize = file.SaveFileData(output); sizes.Add((int)writtenSize); } // Write sizes output.Position = sizeOffset; bw.WriteMultiple(sizes); // Write header output.Position = 0; bw.WriteType(new FbinHeader { fileCount = files.Count, dataOffset = fileOffset }); }
/// <summary> /// /// </summary> /// <param name="output"></param> public void Save(Stream output) { using (var bw = new BinaryWriterX(output, true)) { // Updates Header.Width = (short)Texture.Width; Header.Height = (short)Texture.Height; // Header bw.WriteType(Header); bw.WriteAlignment(); bw.WriteString(FileName, Encoding.ASCII, false); bw.WriteAlignment(); // Setup if (Header.Format == ImageFormat.Palette_8) { var settings = new PaletteImageSettings(Formats[ImageFormat.RGBA8888], PaletteFormats[ImageFormat.Palette_8], Header.Width, Header.Height); var data = Common.Save(Texture, Palette, settings); bw.Write(data.indexData); bw.Write(data.paletteData); } else { var settings = new ImageSettings(Formats[ImageFormat.RGBA8888], Header.Width, Header.Height); var data = Common.Save(Texture, settings); bw.Write(data); } } }
public void Save(Stream output, IFileManager fileManager) { var images = (_state.PluginState as IImageState).Images; using var bw = new BinaryWriterX(output); // Create header var header = new TotxHeader { width = (short)images[0].ImageSize.Width, height = (short)images[0].ImageSize.Height }; // Prepare image info images[0].ImageInfo.ImageSize = images[0].ImageInfo.PadSize.Build(images[0].ImageSize); // Write CTPK var ctpkStream = _state.StateChanged ? fileManager.SaveStream(_state).Result.SavedStream[0].Stream : _state.FileSystem.OpenFile(_state.FilePath); ctpkStream.Position = 0; output.Position = 0x80; ctpkStream.CopyTo(output); // Write header output.Position = 0; bw.WriteType(header); // Finalize file manager fileManager.Close(_state); _state = null; }