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