/// <summary>把消息头写入到流中</summary>
/// <param name="stream"></param>
public void Write(Stream stream)
{
if (!UseHeader) return;
var writer = new BinaryWriterX(stream);
writer.Settings.EncodeInt = true;
writer.Write((Byte)Flag);
if (HasFlag(Flags.Channel)) writer.Write(Channel);
if (HasFlag(Flags.SessionID)) writer.Write(SessionID);
if (HasFlag(Flags.Length)) writer.Write(Length);
}
public void SwitchNibbleBitWriting()
{
var expect = new byte[] {
0x04, 0x00, 0xF8, 0x48
};
var ms = new MemoryStream();
using (var bw = new BinaryWriterX(ms, ByteOrder.LittleEndian, NibbleOrder.LowNibbleFirst, BitOrder.MostSignificantBitFirst, 2))
{
bw.WriteNibble(0x4);
bw.WriteBits(0x1F, 5);
bw.WriteNibble(0x08);
bw.WriteNibble(0x04);
Assert.IsTrue(ms.ToArray().SequenceEqual(expect));
}
}
public void RecordStreams(float deltaT)
{
foreach (RefID user_id in current_eye_tracking_users)
{
//Encode the streams
BinaryWriterX writer = output_writers[user_id];
//WRITE deltaT
writer.Write(deltaT); //float
EyeTrackingStreamManager eyeStreams = eye_streams[user_id];
//WRITE left eye streams
WriteStreams(eyeStreams.LeftEyeStreams, writer);
//WRITE right eye streams
WriteStreams(eyeStreams.RightEyeStreams, writer);
}
}
public static void Save(string filename, Bitmap bitmap)
{
int width = bitmap.Width;
int height = bitmap.Height;
while (width % 8 != 0)
{
width++;
}
while (height % 8 != 0)
{
height++;
}
byte[] pic = Common.Save(bitmap, new ImageSettings
{
Width = width,
Height = height,
Orientation = Orientation.TransposeTile,
Format = ImageSettings.ConvertFormat(header.imageFormat),
PadToPowerOf2 = false
});
using (BinaryWriterX bw = new BinaryWriterX(File.Create(filename)))
{
List <short> table;
byte[] importPic = Deflate(pic, out table, 32, width, height);
header.width = (short)bitmap.Width;
header.height = (short)bitmap.Height;
header.tableSize1 = table.Count * 2 + 4;
header.tableSize2 = (header.tableSize1 + 3) & ~3;
header.imgDataSize = importPic.Length + 4;
bw.WriteStruct(header);
bw.Write(header.tableSize1 << 3);
foreach (var tableEntry in table)
{
bw.Write(tableEntry);
}
bw.BaseStream.Position = 0x48 + header.tableSize2;
bw.Write(header.imgDataSize << 3);
bw.Write(importPic);
}
}
/// <inheritdoc cref="Load"/>
public byte[] Save(IEnumerable <Color> colors, EncodingSaveContext saveContext)
{
var ms = new MemoryStream();
using var bw = new BinaryWriterX(ms, _byteOrder, _bitOrder, 1);
var values = colors.AsParallel().AsOrdered()
.WithDegreeOfParallelism(saveContext.TaskCount)
.Select(_descriptor.GetValue);
foreach (var value in values)
{
_writeValueDelegate(bw, value);
}
return(ms.ToArray());
}
private Stream WriteArguments(IList <Argument> arguments)
{
var argumentStream = new MemoryStream();
using var bw = new BinaryWriterX(argumentStream, true);
foreach (var argument in arguments)
{
bw.WriteType(new XseqArgument
{
type = argument.Type,
value = (uint)argument.Value
});
}
argumentStream.Position = 0;
return(argumentStream);
}
public void Save(Stream output, IList <ArchiveFileInfo> files)
{
var darcTreeBuilder = new U8TreeBuilder(Encoding.ASCII);
darcTreeBuilder.Build(files.Select(x => ("/." + x.FilePath.FullName, x)).ToArray());
var entries = darcTreeBuilder.Entries;
var nameStream = darcTreeBuilder.NameStream;
var namePosition = _headerSize + entries.Count * _entrySize;
var dataOffset = (namePosition + (int)nameStream.Length + 0x1F) & ~0x1F;
using var bw = new BinaryWriterX(output, ByteOrder.BigEndian);
// Write names
bw.BaseStream.Position = namePosition;
nameStream.Position = 0;
nameStream.CopyTo(bw.BaseStream);
bw.WriteAlignment(0x20);
// Write files
foreach (var(qpEntry, afi) in entries.Where(x => x.Item2 != null))
{
bw.WriteAlignment(0x20);
var fileOffset = (int)bw.BaseStream.Position;
var writtenSize = afi.SaveFileData(bw.BaseStream, null);
qpEntry.offset = fileOffset;
qpEntry.size = (int)writtenSize;
}
// Write entries
bw.BaseStream.Position = _headerSize;
bw.WriteMultiple(entries.Select(x => x.Item1));
// Write header
bw.BaseStream.Position = 0;
bw.WriteType(new U8Header
{
entryDataOffset = _headerSize,
entryDataSize = entries.Count * _entrySize + (int)nameStream.Length,
dataOffset = dataOffset
});
bw.WritePadding(0x10, 0xCC);
}
public static void WriteFnt(BinaryWriterX bw, int fntOffset, IList <IArchiveFileInfo> files, int startFileId = 0)
{
var fileTree = files.ToTree();
var totalDirectories = CountTotalDirectories(fileTree);
var contentOffset = fntOffset + totalDirectories * Tools.MeasureType(typeof(MainFntEntry));
var baseOffset = fntOffset;
var fileId = startFileId;
var dirId = 0;
WriteFnt(bw, baseOffset, ref fntOffset, ref contentOffset, ref fileId, ref dirId, 0, fileTree);
// Write total directories
bw.BaseStream.Position = baseOffset + 6;
bw.Write((short)totalDirectories);
bw.BaseStream.Position = contentOffset;
}
public void Write(Stream input)
{
using (var bw = new BinaryWriterX(input, true))
{
if (State == ArchiveFileState.Archived || Entry.uncompSize == 0)
{
base.FileData.CopyTo(bw.BaseStream);
}
else
{
var compData = new MemoryStream(LZ11.Compress(base.FileData));
Entry.uncompSize = (uint)base.FileData.Length;
Entry.compSize = (uint)compData.Length;
compData.CopyTo(bw.BaseStream);
}
}
}
public void Save(string filename)
{
using (BinaryWriterX bw = new BinaryWriterX(File.Create(filename)))
{
//Update entries
uint relOffset = 0;
foreach (var label in Labels)
{
foreach (var point in label.Points)
{
entries[point.Y].data[point.X].value = relOffset;
}
uint byteCount = (uint)GetEncodedText(label.Text.Replace("\n", "\\n").Replace("\xa", "\\n"), encoding).Length + 1;
relOffset += byteCount;
}
//Header
header.stringSecSize = (int)(relOffset);
bw.WriteStruct(header);
//Entries
foreach (var entry in entries)
{
bw.Write(entry.entryTypeID);
bw.Write(entry.entryLength);
bw.Write(entry.typeMask);
foreach (var data in entry.data)
{
bw.Write(data.value);
}
}
bw.WriteAlignment(0x10, 0xff);
//Text
foreach (var label in Labels)
{
bw.Write(GetEncodedText(label.Text.Replace("\n", "\\n").Replace("\xa", "\\n"), encoding));
bw.Write((byte)0);
}
bw.WriteAlignment(0x10, 0xff);
//Signature
bw.Write(sig);
}
}
public void Save(Stream output, ImageInfo imageInfo)
{
using var bw = new BinaryWriterX(output);
var mipOffset = HeaderSize;
var dataOffset = 0x100;
// Write image and mip data
var mipOffsets = new List <int> {
dataOffset
};
var dataPosition = dataOffset;
output.Position = dataPosition;
bw.Write(imageInfo.ImageData);
dataPosition += imageInfo.ImageData.Length;
if (imageInfo.MipMapCount > 0)
{
foreach (var mipData in imageInfo.MipMapData)
{
mipOffsets.Add(dataPosition);
bw.Write(mipData);
dataPosition += mipData.Length;
}
}
// Write mip offsets
output.Position = mipOffset;
bw.WriteMultiple(mipOffsets.Select(x => x - dataOffset));
// Write unknown data
bw.Write(_unkData);
// Write header
_header.mipMapCount = imageInfo.MipMapCount;
_header.format = imageInfo.ImageFormat;
_header.width = imageInfo.ImageSize.Width;
_header.height = imageInfo.ImageSize.Height;
_header.textureDataSize = (int)(output.Length - dataOffset);
_header.textureDataSize2 = (int)(output.Length - dataOffset);
output.Position = 0;
bw.WriteType(_header);
}
public void Save(Stream output)
{
using (var bw = new BinaryWriterX(output))
{
uint dataOffset = (uint)(0x10 + 0xc + Files.Count * 0x8 + 0x8 + nameP.Length + 0x8);
//Files
uint offset = 0;
var data = new MemoryStream();
foreach (var file in Files)
{
file.FileData.CopyTo(data);
using (var dataB = new BinaryWriterX(data, true)) dataB.WriteAlignment(0x80, 0xff);
file.entry.startOffset = offset;
offset += (uint)file.FileSize;
file.entry.endOffset = offset;
offset = (uint)((offset + 0x7f) & ~0x7f);
}
bw.BaseStream.Position = dataOffset;
data.Position = 0;
data.CopyTo(bw.BaseStream);
//FAT
bw.BaseStream.Position = 0x10;
bw.WriteStruct(fatHeader);
foreach (var file in Files)
{
bw.WriteStruct(file.entry);
}
//FNT
bw.WriteStruct(fntHeader);
bw.Write(nameP);
//GMIF
gmifHeader.secSize = (uint)(bw.BaseStream.Length - dataOffset + 8);
bw.WriteStruct(gmifHeader);
//GenHeader
bw.BaseStream.Position = 0;
genHeader.secSize = (uint)(bw.BaseStream.Length);
bw.WriteStruct(genHeader);
}
}
public void Save(string filename)
{
//check original sizes
int bmpCount = 0;
foreach (var txobj in TxObs)
{
for (int j = 0; j < ((txobj.mipmapLvls == 0) ? 1 : txobj.mipmapLvls); j++)
{
if (bmps[bmpCount].Width != txobj.width / (1 << j) || bmps[bmpCount].Height != txobj.height / (1 << j))
{
throw new Exception($"Image {bmpCount:00} has to be {txobj.width / (1 << j)}x{txobj.height / (1 << j)}px!");
}
bmpCount++;
}
}
using (var bw = new BinaryWriterX(File.OpenWrite(filename)))
{
bw.Write(list);
bmpCount = 0;
for (int i = 0; i < TxObs.Count; i++)
{
bw.BaseStream.Position = TxObs[i].texDataOffset;
var width = TxObs[i].width;
var height = TxObs[i].height;
for (int j = 0; j < ((TxObs[i].mipmapLvls == 0) ? 1 : TxObs[i].mipmapLvls); j++)
{
var settings = new ImageSettings
{
Width = (int)width,
Height = (int)height,
Format = Support.CTRFormat[(byte)TxObs[i].format],
Swizzle = new CTRSwizzle((int)width, (int)height)
};
bw.Write(Common.Save(bmps[bmpCount++], settings));
width /= 2;
height /= 2;
}
}
}
}
public static void Save(string filename, Bitmap bitmap)
{
int width = (bitmap.Width + 0x7) & ~0x7;
int height = (bitmap.Height + 0x7) & ~0x7;
var settings = new ImageSettings
{
Width = width,
Height = height,
Orientation = Orientation.TransposeTile,
Format = ImageSettings.ConvertFormat(header.imageFormat),
PadToPowerOf2 = false
};
byte[] pic = Common.Save(bitmap, settings);
using (var bw = new BinaryWriterX(File.Create(filename)))
{
//Header
header.width = (short)bitmap.Width;
header.height = (short)bitmap.Height;
//tile table
var table = new MemoryStream();
byte[] importPic = Deflate(pic, ImageSettings.ConvertFormat(header.imageFormat), out table);
//Table
bw.BaseStream.Position = 0x48;
var comp = Level5.Compress(table, tableComp);
bw.Write(comp);
header.tableSize1 = comp.Length + 4;
header.tableSize2 = (header.tableSize1 + 3) & ~3;
//Image
bw.BaseStream.Position = 0x48 + header.tableSize2;
header.imageFormat = (editMode) ? Format.ETC1 : header.imageFormat;
comp = Level5.Compress(new MemoryStream(importPic), picComp);
bw.Write(comp);
header.imgDataSize = comp.Length;
//Header
bw.BaseStream.Position = 0;
bw.WriteStruct(header);
}
}
public void Save(string filename)
{
var sjis = Encoding.GetEncoding("Shift-JIS");
using (BinaryWriterX bw = new BinaryWriterX(File.Create(filename)))
{
//Table 0
bw.BaseStream.Position = 0x14;
bw.WriteMultipleCompressed(entries, table0Comp);
bw.WriteAlignment(4);
//Table 1
header.table1Offset = (int)bw.BaseStream.Position >> 2;
uint relOffset = 0;
var count = 1;
foreach (var label in Labels)
{
var byteCount = (uint)sjis.GetByteCount(label.Text) + 1;
var entryValue = subEntries[label.TextID].value;
foreach (var entry in subEntries)
{
if (entry.ident == 0x18 && entry.value == entryValue)
{
entry.value = relOffset;
}
}
relOffset += byteCount;
count++;
}
offsets = subEntries.Where(e => e.ident == 0x18).Select(e => e.value).Distinct().ToList();
bw.WriteMultipleCompressed(subEntries, table1Comp);
bw.WriteAlignment(4);
//Text
header.stringTableOffset = (int)bw.BaseStream.Position >> 2;
bw.WriteStringsCompressed(Labels.Select(l => l.Text), stringComp, sjis);
bw.WriteAlignment(4);
//Header
bw.BaseStream.Position = 0;
bw.WriteStruct(header);
}
}
public void Save(Stream output, IList <IArchiveFileInfo> files)
{
using var bw = new BinaryWriterX(output);
// Calculate offsets
var entryOffset = BlockSize;
var fileOffset = entryOffset + files.Count * BlockSize;
// Write files
// HINT: Files are ordered by name
var entries = new List <DpkEntry>();
var filePosition = fileOffset;
foreach (var file in files.OrderBy(x => x.FilePath.ToRelative().FullName).Cast <ArchiveFileInfo>())
{
output.Position = filePosition;
var writtenSize = file.SaveFileData(output);
var name = CapAndPadName(file.FilePath.ToRelative().FullName);
entries.Add(new DpkEntry
{
name = name,
nameSum = (short)NameSum(name),
offset = filePosition,
compSize = (int)writtenSize,
decompSize = (int)file.FileSize
});
filePosition += (int)((writtenSize + (BlockSize - 1)) & ~(BlockSize - 1));
}
// Write entries
// HINT: Entries are ordered by nameSum
output.Position = entryOffset;
bw.WriteMultiple(entries.OrderBy(x => x.nameSum));
// Write header
output.Position = 0;
bw.WriteType(new DpkHeader
{
fileCount = files.Count,
fileSize = (int)output.Length
});
}
public static void Decrypt(object sender, EventArgs e)
{
var tsi = sender as ToolStripMenuItem;
var name = (tsi.Tag.ToString() == "normal") ? "3DS" : tsi.Tag.ToString();
if (!PrepareFiles("Open an encrypted " + name + " file...", "Save your decrypted file...", ".dec", out FileStream openFile, out FileStream saveFile))
{
return;
}
try
{
using (var openBr = new BinaryReaderX(openFile))
using (var outFs = new BinaryWriterX(saveFile))
{
var engine = new AesEngine();
switch (tsi.Tag)
{
case Types.normal:
openBr.BaseStream.CopyTo(outFs.BaseStream);
openBr.BaseStream.Position = 0;
outFs.BaseStream.Position = 0;
engine.DecryptGameNCSD(openBr.BaseStream, outFs.BaseStream);
break;
case Types.CIA:
openBr.BaseStream.CopyTo(outFs.BaseStream);
openBr.BaseStream.Position = 0;
outFs.BaseStream.Position = 0;
engine.DecryptCIA(openBr.BaseStream, outFs.BaseStream);
break;
/*case Types.BOSS:
* outFs.Write(engine.DecryptBOSS(openBr.ReadBytes((int)openBr.BaseStream.Length)));
* break;*/
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), tsi?.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
MessageBox.Show($"Successfully decrypted {Path.GetFileName(openFile.Name)}.", tsi?.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public byte[] Deflate(byte[] pic, int bpp, out MemoryStream table)
{
table = new MemoryStream();
using (var tableB = new BinaryWriterX(table, true))
{
if (entryStart != null)
{
tableB.Write(entryStart);
}
List <byte[]> parts = new List <byte[]>();
using (var picB = new BinaryReaderX(new MemoryStream(pic)))
while (picB.BaseStream.Position < picB.BaseStream.Length)
{
byte[] part = picB.ReadBytes(64 * bpp / 8);
if (parts.Find(x => x.SequenceEqual(part)) != null)
{
if (entryStart != null)
{
tableB.Write(parts.FindIndex(x => x.SequenceEqual(part)));
}
else
{
tableB.Write((short)parts.FindIndex(x => x.SequenceEqual(part)));
}
}
else
{
if (entryStart != null)
{
tableB.Write(parts.Count);
}
else
{
tableB.Write((short)parts.Count);
}
parts.Add(part);
}
}
return(parts.SelectMany(x => x.SelectMany(b => new[] { b })).ToArray());
}
}
public void Save(Stream output, IList <IArchiveFileInfo> files)
{
using var bw = new BinaryWriterX(output);
// Calculate offsets
var dataAlignment = PkgSupport.DetermineAlignment((files[0] as PkgArchiveFileInfo).Type);
var entryOffset = HeaderSize;
var dataOffset = (entryOffset + files.Count * EntrySize + dataAlignment - 1) & ~(dataAlignment - 1);
// Write files
var entries = new List <PkgEntry>();
var dataPosition = dataOffset;
foreach (var file in files.Cast <PkgArchiveFileInfo>())
{
// Write file data
var alignment = PkgSupport.DetermineAlignment(file.Type);
var alignedDataPosition = (dataPosition + alignment - 1) & ~(alignment - 1);
output.Position = alignedDataPosition;
var writtenSize = file.SaveFileData(output);
// Create entry
entries.Add(new PkgEntry
{
startOffset = alignedDataPosition,
endOffset = (int)(alignedDataPosition + writtenSize),
hash = file.Hash
});
dataPosition = (int)(alignedDataPosition + writtenSize);
}
bw.WriteAlignment(4);
// Write entries
output.Position = entryOffset;
bw.WriteMultiple(entries);
// Write header
output.Position = 0;
bw.WriteType(new PkgHeader {
fileCount = files.Count, tableSize = dataOffset - 4, dataSize = (int)(output.Length - dataOffset)
});
}
public static void Save(string filename, Bitmap bitmap)
{
int width = (bitmap.Width + 0x7) & ~0x7;
int height = (bitmap.Height + 0x7) & ~0x7;
var settings = new ImageSettings
{
Width = width,
Height = height,
Format = ImageSettings.ConvertFormat(header.imageFormat),
PadToPowerOf2 = false,
ZOrder = false
};
byte[] pic = Common.Save(bitmap, settings);
using (var bw = new BinaryWriterX(File.Create(filename)))
{
//Header
header.bitDepth = 32;
header.width = (short)width;
header.height = (short)height;
//tile table
List <short> table;
byte[] importPic = Deflate(pic, out table);
header.width = (short)bitmap.Width;
header.height = (short)bitmap.Height;
header.tableSize1 = table.Count * 2 + 4;
header.tableSize2 = (header.tableSize1 + 3) & ~3;
header.imgDataSize = importPic.Length + 4;
bw.WriteStruct(header);
bw.Write(header.tableSize1 << 3);
foreach (var tableEntry in table)
{
bw.Write(tableEntry);
}
bw.BaseStream.Position = 0x48 + header.tableSize2;
bw.Write(header.imgDataSize << 3);
bw.Write(importPic);
}
}
public void Save(string filename)
{
using (BinaryWriterX bw = new BinaryWriterX(File.Create(filename)))
{
bw.BaseStream.Position = header.texDataOffset;
var count = 0;
for (int i = 0; i < header.chunkCount; i++)
{
for (int j = 0; j < chunks[i].texCount; j++)
{
settingsList[count] = new ImageSettings
{
Width = bmps[count].Width,
Height = bmps[count].Height,
Format = Support.Format[chunks[i].textures[j].imageFormat],
Swizzle = new CTRSwizzle(bmps[count].Width, bmps[count].Height)
};
var resBmp = Kontract.Image.Common.Save(bmps[count], settingsList[count]);
bw.Write(resBmp);
chunks[i].textures[j].dataLength = resBmp.Length;
chunks[i].textures[j].height = (ushort)bmps[count].Height;
chunks[i].textures[j].width = (ushort)bmps[count].Width;
count++;
}
}
//Ctxb Header
header.fileSize = (uint)bw.BaseStream.Length;
bw.BaseStream.Position = 0;
bw.WriteStruct(header);
//Chunks
for (int i = 0; i < header.chunkCount; i++)
{
chunks[i].Write(bw.BaseStream);
for (int j = 0; j < chunks[i].texCount; j++)
{
bw.WriteStruct(chunks[i].textures[j]);
}
}
}
}
public void WriteToHpb(Stream stream)
{
Entry.fileOffset = (int)stream.Position;
if (State == ArchiveFileState.Replaced && Entry.uncompressedSize != 0)
{
// Only here if we need to compress from a FileStream in the base.FileData
var uncompData = new byte[_fileData.Length];
base.FileData.Read(uncompData, 0, uncompData.Length);
var compData = RevLZ77.Compress(new MemoryStream(uncompData));
if (compData == null)
{
Entry.fileSize = uncompData.Length;
Entry.uncompressedSize = 0;
using (var bw = new BinaryWriterX(stream, true))
{
bw.Write(uncompData);
}
}
else
{
Entry.fileSize = compData.Length + 0x20;
Entry.uncompressedSize = uncompData.Length;
using (var bw = new BinaryWriterX(stream, true))
{
bw.WriteStruct(new AcmpHeader
{
compressedSize = Entry.fileSize,
uncompressedSize = Entry.uncompressedSize
});
bw.Write(compData);
}
}
}
else
{
Entry.fileSize = (int)_fileData.Length;
base.FileData.CopyTo(stream);
}
// padding
while (stream.Position % 4 != 0)
{
stream.WriteByte(0);
}
}
private void WriteTypeClass(BinaryWriterX bw, object writeValue, Type writeType, ValueStorage storage)
{
var typeAttributes = new MemberAttributeInfo(writeType);
var bitFieldInfoAttribute = typeAttributes.BitFieldInfoAttribute;
var alignmentAttribute = typeAttributes.AlignmentAttribute;
if (bitFieldInfoAttribute != null)
{
bw.Flush();
}
bw.BitOrder = (bitFieldInfoAttribute?.BitOrder != BitOrder.Default ? bitFieldInfoAttribute?.BitOrder : bw.BitOrder) ?? bw.BitOrder;
bw.BlockSize = bitFieldInfoAttribute?.BlockSize ?? bw.BlockSize;
if (bw.BlockSize != 8 && bw.BlockSize != 4 && bw.BlockSize != 2 && bw.BlockSize != 1)
{
throw new InvalidBitFieldInfoException(bw.BlockSize);
}
var fields = writeType.GetFields().OrderBy(fi => fi.MetadataToken);
foreach (var field in fields)
{
var fieldValue = field.GetValue(writeValue);
storage.Add(field.Name, fieldValue);
var bitInfo = field.GetCustomAttribute <BitFieldAttribute>();
if (bitInfo != null)
{
bw.WriteBits(Convert.ToInt64(fieldValue), bitInfo.BitLength);
}
else
{
WriteTypeInternal(bw, fieldValue, storage, field);
}
}
bw.Flush();
// Apply alignment
if (alignmentAttribute != null)
{
bw.WriteAlignment(alignmentAttribute.Alignment);
}
}
public void Save(Stream output)
{
var headerSize = 0x10;
var entrySize = 0x28;
using (var bw = new BinaryWriterX(output))
{
bw.WriteStruct(Header);
// Strings
bw.BaseStream.Position = headerSize + Header.EntryCount * entrySize;
var strEntries = Entries.Where(e => e.Offset > 0).ToList();
var offset = (int)bw.BaseStream.Position;
for (var i = 0; i < strEntries.Count; i++)
{
var entry = strEntries[i];
if (entry.Label == "<label>")
{
bw.WriteASCII(Strings[i].Text);
bw.Write((byte)0x0);
}
else
{
bw.Write(Encoding.Unicode.GetBytes(Strings[i].Text));
bw.Write((byte)0x0);
bw.Write((byte)0x0);
}
bw.WriteAlignment(4);
entry.Offset = offset;
offset = (int)bw.BaseStream.Position;
}
// Odd extra bytes
bw.Write(0);
bw.Write((byte)0x0);
// Entries
bw.BaseStream.Position = headerSize;
foreach (var entry in Entries)
{
bw.WriteStruct(entry);
}
}
}
public void Save(Stream incOutput, Stream datOutput)
{
using (var bwd = new BinaryWriterX(datOutput))
{
for (int i = 0; i < Files.Count; i++)
{
Files[i].Write(bwd.BaseStream);
bwd.WriteAlignment(4);
}
}
using (var bw = new BinaryWriterX(incOutput))
{
foreach (var file in Files)
{
bw.WriteStruct(file.Entry);
}
}
}
public void Write(Stream input)
{
using (var bw = new BinaryWriterX(input, true, ByteOrder.BigEndian))
{
bw.Write(sigType);
bw.Write(signature);
bw.WritePadding(Support.GetSignatureSizes(sigType).Item2);
bw.Write(GetFixedStringBA(issuer, 0x40));
bw.Write(keyType);
bw.Write(GetFixedStringBA(name, 0x40));
bw.Write(publicKey);
bw.Write(unk1);
bw.WritePadding(Support.GetPublicKeySizes(keyType).Item2);
}
}
public void Save(Stream output)
{
using (var bw = new BinaryWriterX(output))
{
var dataOffset = entries[0].offset;
foreach (var file in Files)
{
bw.Write(dataOffset);
file.Write(bw.BaseStream, dataOffset);
dataOffset = (uint)bw.BaseStream.Length;
}
bw.Write(dataOffset);
}
}
public int Write(Stream input, int absDataOffset, int baseDataOffset)
{
using (var bw = new BinaryWriterX(input, true))
{
bw.BaseStream.Position = absDataOffset;
FileData.CopyTo(bw.BaseStream);
if (bw.BaseStream.Position % 4 > 0) bw.WriteAlignment(4);
else bw.WritePadding(4);
var relOffset = absDataOffset - baseDataOffset;
Entry.tmp = (ushort)((relOffset >> 2) & 0xffff);
Entry.tmpZ = (byte)(((relOffset >> 2) & 0xff0000) >> 16);
Entry.tmp2 = (ushort)(FileSize & 0xffff);
Entry.tmp2Z = (byte)((FileSize & 0xff0000) >> 16);
return (bw.BaseStream.Position % 4 > 0) ? (int)(absDataOffset + FileSize + 0x3) & ~0x3 : (int)(absDataOffset + FileSize + 4);
}
}
public byte[] Save(IEnumerable <Color> colors, int taskCount)
{
var ms = new MemoryStream();
using var bw = new BinaryWriterX(ms, _byteOrder);
var blocks = colors.Batch(ColorsPerValue)
.AsParallel().AsOrdered()
.WithDegreeOfParallelism(taskCount)
.Select(c => EncodeNextBlock(c.ToArray()));
foreach (var block in blocks)
{
WriteNextBlock(bw, block);
}
return(ms.ToArray());
}
public void NibbleWriting()
{
var expect = new byte[] {
0x84, 0x08
};
var ms = new MemoryStream();
using (var bw = new BinaryWriterX(ms))
{
bw.WriteNibble(0x04);
bw.WriteNibble(0x08);
bw.WriteNibble(0x08);
bw.Flush();
Assert.IsTrue(ms.ToArray().SequenceEqual(expect));
}
}
public void Save(Stream file)
{
int width = (Image.Width + 0x7) & ~0x7;
int height = (Image.Height + 0x7) & ~0x7;
var settings = new ImageSettings
{
Width = width,
Height = height,
Format = Support.Format[header.imageFormat],
Swizzle = new ImgcSwizzle(width, height)
};
byte[] pic = L5XFEditor.Image.Common.Save(Image, settings);
using (var bw = new BinaryWriterX(file, true))
{
//Header
header.width = (short)Image.Width;
header.height = (short)Image.Height;
//tile table
var table = new MemoryStream();
byte[] importPic = Deflate(pic, Support.Format[header.imageFormat].BitDepth, out table);
//Table
bw.BaseStream.Position = 0x48;
var comp = Level5.Compress(table, tableComp);
bw.Write(comp);
header.tableSize1 = comp.Length;
header.tableSize2 = (header.tableSize1 + 3) & ~3;
//Image
bw.BaseStream.Position = 0x48 + header.tableSize2;
header.imageFormat = (editMode) ? (byte)28 : header.imageFormat;
comp = Level5.Compress(new MemoryStream(importPic), picComp);
bw.Write(comp);
bw.WriteAlignment(4);
header.imgDataSize = comp.Length;
//Header
bw.BaseStream.Position = 0;
bw.WriteStruct(header);
}
}
