Reworked the NARC library (#464)

This commit is contained in:
JkKU 2022-07-15 03:30:04 +02:00 committed by GitHub
parent 963ffa1227
commit b21fc43b52
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23

View file

@ -1,226 +1,97 @@
using System;
using Syroot.BinaryData;
using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Toolbox.Library;
using Toolbox.Library.IO;
using Toolbox.Library.Forms;
using System.Windows.Forms;
namespace FirstPlugin
{
class NARC : IArchiveFile, IFileFormat
{
namespace FirstPlugin {
class NARC : IArchiveFile, IFileFormat {
public FileType FileType { get; set; } = FileType.Archive;
public bool CanSave { get; set; }
public bool CanSave { get; set; } = true;
public string[] Description { get; set; } = new string[] { "Nitro Archive (NARC)" };
public string[] Extension { get; set; } = new string[] { "*.narc" };
public string FileName { get; set; }
public string FilePath { get; set; }
public IFileInfo IFileInfo { get; set; }
public bool Identify(System.IO.Stream stream)
{
using (var reader = new Toolbox.Library.IO.FileReader(stream, true))
{
return reader.CheckSignature(4, "NARC");
}
}
public Type[] Types => new Type[0];
public Type[] Types
{
get
{
List<Type> types = new List<Type>();
return types.ToArray();
}
}
public bool CanAddFiles { get; set; } = true;
public bool CanRenameFiles { get; set; } = true;
public bool CanReplaceFiles { get; set; } = true;
public bool CanDeleteFiles { get; set; } = true;
public bool CanAddFiles { get; set; }
public bool CanRenameFiles { get; set; }
public bool CanReplaceFiles { get; set; }
public bool CanDeleteFiles { get; set; }
public List<FileEntry> files = new List<FileEntry>();
public IEnumerable<ArchiveFileInfo> Files => files;
public void ClearFiles() { files.Clear(); }
// private
private Header header;
private BTAF btaf;
private BTNF btnf;
private GMIF gmif;
public bool AddFile(ArchiveFileInfo archiveFileInfo)
{
return false;
private List<ArchiveFileInfo> files = new List<ArchiveFileInfo>();
public bool AddFile(ArchiveFileInfo archiveFileInfo) {
files.Add(archiveFileInfo);
return true;
}
public bool DeleteFile(ArchiveFileInfo archiveFileInfo)
{
return false;
public void ClearFiles() => files.Clear();
public bool DeleteFile(ArchiveFileInfo archiveFileInfo) {
return files.Remove(archiveFileInfo);
}
public class FileEntry : ArchiveFileInfo
{
public NARC.FileAllocationEntry entry;
public FileImageBlock fileImage;
public bool Identify(Stream stream) {
using(FileReader reader = new FileReader(stream, true))
return reader.CheckSignature(4, "NARC");
}
public override Dictionary<string, string> ExtensionImageKeyLookup
{
get
{
return new Dictionary<string, string>()
{
{".cbfmd", "bfres" },
{".cbfa", "bfres" },
{".cbfsa", "bfres" },
{".cbntx", "bntx" },
};
}
}
public void Load(Stream stream) {
using(FileReader reader = new FileReader(stream)) {
header = new Header(reader);
public NARC ArchiveFile;
for(uint i = 0; i < header.DataBlocks; i++) {
long PositionBuf = reader.Position;
string cSectionMagic = Encoding.ASCII.GetString(reader.ReadBytes(4)).ToUpperInvariant();
uint cSectionSize = reader.ReadUInt32();
public FileEntry(NARC narc, string Name)
{
ArchiveFile = narc;
FileName = Name.Replace(" ", string.Empty).RemoveIllegaleFolderNameCharacters();
}
public override byte[] FileData
{
get { return DecompressBlock(); }
set
{
}
}
private bool IsTexturesLoaded = false;
public override IFileFormat OpenFile()
{
var FileFormat = base.OpenFile();
bool IsModel = FileFormat is BFRES;
if (IsModel && !IsTexturesLoaded)
{
IsTexturesLoaded = true;
foreach (var file in ArchiveFile.Files)
{
if (Utils.GetExtension(file.FileName) == ".ctex")
{
file.FileFormat = file.OpenFile();
}
switch(cSectionMagic) {
case "BTAF":
btaf = new BTAF(reader);
break;
case "BTNF":
btnf = new BTNF(reader, (uint) btaf.FileDataArray.Length);
break;
case "GMIF":
gmif = new GMIF(reader, btaf);
break;
}
reader.Position = PositionBuf + cSectionSize;
}
return base.OpenFile();
}
private byte[] DecompressBlock()
{
byte[] data = GetBlock();
var reader = new FileReader(data);
reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
byte compType = reader.ReadByte();
if (compType == 0x50)
{
reader.Seek(4, System.IO.SeekOrigin.Begin);
uint decompSize = reader.ReadUInt32();
uint compSize = (uint)reader.BaseStream.Length - 8;
var comp = new STLibraryCompression.MTA_CUSTOM();
return comp.Decompress(data, decompSize);
}
else if (compType == 0x30 || compType == 0x20)
{
uint decompSize = reader.ReadUInt32();
uint compSize = (uint)reader.BaseStream.Length - 16;
reader.SeekBegin(16);
ushort signature = reader.ReadUInt16();
bool IsGZIP = signature == 0x1F8B;
bool IsZLIB = signature == 0x789C || signature == 0x78DA;
byte[] filedata = reader.getSection(16, (int)compSize);
reader.Close();
reader.Dispose();
if (IsGZIP)
data = STLibraryCompression.GZIP.Decompress(filedata);
else
data = STLibraryCompression.ZLIB.Decompress(filedata, false);
}
return data;
}
public byte[] GetBlock()
{
return Utils.SubArray(fileImage.dataBlock, entry.StartOffset, entry.EndOffset);
for(int i = 0; i < btnf.FileNames.Length; i++)
files.Add(new ArchiveFileInfo() {
FileName = btnf.FileNames[i],
FileData = gmif.FilesData[i]
});
}
}
Header header;
public void Unload() { }
public List<FileEntry> FileEntries = new List<FileEntry>();
public void Load(System.IO.Stream stream)
{
header = new Header(new FileReader(stream));
var names = GetNames(header.FNTB);
List<byte> Data = new List<byte>();
for (ushort i = 0; i < header.FATB.FileCount; i++)
{
string name = names.Count > i ? names[i] : $"File{i}";
FileEntries.Add(new FileEntry(this, name)
{
entry = header.FATB.FileEntries[i],
fileImage = header.FIMG,
});
files.Add(FileEntries[i]);
}
}
public List<string> GetNames(FileNameTable nameTable)
{
var names = new List<string>();
foreach (var tblEntry in nameTable.entryNameTable)
{
if (tblEntry is EntryNameTableFileEntry)
names.Add(((EntryNameTableFileEntry)tblEntry).entryName);
}
return names;
}
public void Unload()
{
}
public void Save(System.IO.Stream stream)
{
}
//EFE for REing format https://github.com/Gericom/EveryFileExplorer/blob/f9f00d193c9608d71c9a23d9f3ab7e752f4ada2a/NDS/NitroSystem/FND/NARC.cs
public class Header
{
public string Signature;
internal class Header {
public ushort ByteOrder;
public ushort Version;
public uint FileSize;
public uint Version;
public ushort HeaderSize;
public ushort DataBlocks;
public FileAllocationTableBlock FATB;
public FileNameTable FNTB;
public FileImageBlock FIMG;
public Header(FileReader reader)
{
public Header(FileReader reader) {
reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
reader.ReadSignature(4, "NARC");
@ -231,198 +102,147 @@ namespace FirstPlugin
FileSize = reader.ReadUInt32();
HeaderSize = reader.ReadUInt16();
DataBlocks = reader.ReadUInt16();
FATB = new FileAllocationTableBlock(reader);
FNTB = new FileNameTable(reader);
FIMG = new FileImageBlock(reader);
}
public void Write(FileWriter writer)
{
writer.WriteSignature(Signature);
writer.Write(ByteOrder);
writer.Write(Version);
writer.Write(FileSize);
writer.Write(HeaderSize);
writer.Write(DataBlocks);
}
}
public class FileAllocationTableBlock
{
public string Signature;
public uint Size;
public ushort FileCount;
public ushort Reserved;
public List<FileAllocationEntry> FileEntries = new List<FileAllocationEntry>();
// Mostly everything from this point was imported from:
// https://github.com/Jenrikku/NARCSharp
public void Save(Stream stream) {
using(BinaryDataWriter writer = new BinaryDataWriter(stream)) {
#region Header
writer.Write("NARC", BinaryStringFormat.NoPrefixOrTermination, Encoding.ASCII); // Magic.
public FileAllocationTableBlock(FileReader reader)
{
long startPos = reader.Position;
writer.ByteOrder = (ByteOrder) header.ByteOrder;
writer.Write((ushort) 0xFFFE); // ByteOrder.
reader.ReadSignature(4, "BTAF");
writer.Write(header.Version); // Version.
Size = reader.ReadUInt32();
FileCount = reader.ReadUInt16();
Reserved = reader.ReadUInt16();
for (int i = 0; i < FileCount; i++)
FileEntries.Add(new FileAllocationEntry(reader));
long headerLengthPorsition = writer.Position;
writer.Write(0x00000000); // Skips length writing.
reader.Seek(startPos + Size, System.IO.SeekOrigin.Begin);
}
}
public class FileAllocationEntry
{
public uint StartOffset;
public uint EndOffset;
writer.Write(header.HeaderSize); // Header length.
writer.Write(header.DataBlocks); // Section count.
#endregion
public FileAllocationEntry(FileReader reader)
{
StartOffset = reader.ReadUInt32();
EndOffset = reader.ReadUInt32();
}
public void Write(FileWriter writer)
{
writer.Write(StartOffset);
writer.Write(EndOffset);
}
}
public class FileImageBlock
{
public string Signature;
public uint Size;
public byte[] dataBlock;
#region BTAF preparation
long btafPosition = WriteSectionHeader("BTAF"); // Header.
writer.Write((uint) files.Count); // File count.
public FileImageBlock(FileReader reader)
{
reader.ReadSignature(4, "GMIF");
for(uint i = 0; i < files.Count; i++) // Reads unset bytes per file. (Reserved space for later)
writer.Write((long) 0x0000000000000000);
Size = reader.ReadUInt32();
dataBlock = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
}
}
public class FileNameTable
{
public string Signature;
public uint Size;
WriteSectionLength(btafPosition);
#endregion
public List<DirectoryTableEntry> directoryTable = new List<DirectoryTableEntry>();
public List<EntryNameTableEntry> entryNameTable = new List<EntryNameTableEntry>();
#region BTNF
long btnfPosition = WriteSectionHeader("BTNF"); // Header.
writer.Write(btnf.Unknown);
public FileNameTable(FileReader reader)
{
long startPos = reader.BaseStream.Position;
foreach(ArchiveFileInfo file in files)
writer.Write(file.FileName, BinaryStringFormat.ByteLengthPrefix);
writer.Write((byte) 0x00);
reader.ReadSignature(4, "BTNF");
Size = reader.ReadUInt32();
if (Size == 16)
{
reader.Seek(8);
return;
writer.Align(32);
writer.Position += 8;
WriteSectionLength(btnfPosition);
#endregion
#region GMIF
long gmifPosition = WriteSectionHeader("GMIF"); // Header.
long btafCurrentPosition = btafPosition + 12; // First offset-size position. (BTAF)
foreach(ArchiveFileInfo file in files) {
WriteBTAFEntry(); // BTAF offset
writer.Write(file.FileData);
WriteBTAFEntry(); // BTAF size.
writer.Align(16);
}
directoryTable.Add(new DirectoryTableEntry(reader));
WriteSectionLength(gmifPosition);
#endregion
for (int i = 0; i < directoryTable[0].dirParentID - 1; i++)
{
directoryTable.Add(new DirectoryTableEntry(reader));
writer.Position = headerLengthPorsition;
writer.Write((uint) writer.BaseStream.Length); // Total file length.
long WriteSectionHeader(string magic) {
long startPosition = writer.Position;
writer.Write(magic, BinaryStringFormat.NoPrefixOrTermination, Encoding.ASCII); // Magic.
writer.Write(0x00000000); // Skips length position.
return startPosition;
}
entryNameTable = new List<EntryNameTableEntry>();
int EndOfDirectory = 0;
while (EndOfDirectory < directoryTable[0].dirParentID)
{
byte entryNameLength = reader.ReadByte();
reader.BaseStream.Position--;
if (entryNameLength == 0)
{
entryNameTable.Add(new EntryNameTableEndOfDirectoryEntry(reader));
EndOfDirectory++;
void WriteSectionLength(long startPosition) {
using(writer.TemporarySeek()) {
long finalLength = (uint) writer.Position;
writer.Position = startPosition + 4;
writer.Write((uint) (finalLength - startPosition));
}
else if (entryNameLength < 0x80) entryNameTable.Add(new EntryNameTableFileEntry(reader));
else entryNameTable.Add(new EntryNameTableDirectoryEntry(reader));
}
reader.BaseStream.Position = startPos + Size;
void WriteBTAFEntry() {
uint value = (uint) (writer.Position - (gmifPosition + 8));
using(writer.TemporarySeek()) {
writer.Position = btafCurrentPosition;
writer.Write(value);
}
btafCurrentPosition += 4;
}
}
}
#region Sections
internal class BTAF {
public (uint offset, uint size)[] FileDataArray;
public BTAF() { }
public BTAF(BinaryDataReader reader) {
uint numberOfFiles = reader.ReadUInt32();
FileDataArray = new (uint, uint)[numberOfFiles];
for(ulong i = 0; i < numberOfFiles; i++) {
FileDataArray[i].offset = reader.ReadUInt32();
FileDataArray[i].size = reader.ReadUInt32();
}
}
}
public class EntryNameTableEndOfDirectoryEntry : EntryNameTableEntry
{
public EntryNameTableEndOfDirectoryEntry() { }
public EntryNameTableEndOfDirectoryEntry(FileReader reader)
: base(reader) { }
public override void Write(FileWriter writer)
{
base.Write(writer);
internal class BTNF {
public string[] FileNames;
public ulong Unknown;
public BTNF() { }
public BTNF(BinaryDataReader reader, uint numberOfFiles) {
Unknown = reader.ReadUInt64();
FileNames = new string[numberOfFiles];
for(int i = 0; i < numberOfFiles; i++) {
FileNames[i] = reader.ReadString(BinaryStringFormat.ByteLengthPrefix, Encoding.ASCII);
}
}
}
public class EntryNameTableDirectoryEntry : EntryNameTableEntry
{
public string entryName;
public ushort directoryID;
internal class GMIF {
public byte[][] FilesData;
public EntryNameTableDirectoryEntry(FileReader reader) : base(reader)
{
entryName = reader.ReadString(entryNameLength & 0x7F, Encoding.ASCII);
directoryID = reader.ReadUInt16();
}
public override void Write(FileWriter writer)
{
base.Write(writer);
writer.Write(entryName, Syroot.BinaryData.BinaryStringFormat.ZeroTerminated);
writer.Write(directoryID);
}
}
public class EntryNameTableFileEntry : EntryNameTableEntry
{
public string entryName;
public EntryNameTableFileEntry(FileReader reader) : base(reader)
{
entryName = reader.ReadString(entryNameLength, Encoding.ASCII);
}
public override void Write(FileWriter writer)
{
writer.Write(entryName, Syroot.BinaryData.BinaryStringFormat.ZeroTerminated);
}
}
public class EntryNameTableEntry
{
public byte entryNameLength;
protected EntryNameTableEntry() { }
public EntryNameTableEntry(FileReader reader)
{
entryNameLength = reader.ReadByte();
}
public virtual void Write(FileWriter writer)
{
writer.Write(entryNameLength);
}
}
public class DirectoryTableEntry
{
public uint dirEntryStart;
public ushort dirEntryFileID;
public ushort dirParentID;
public DirectoryTableEntry() { }
public DirectoryTableEntry(FileReader reader)
{
dirEntryStart = reader.ReadUInt32();
dirEntryFileID = reader.ReadUInt16();
dirParentID = reader.ReadUInt16();
}
public void Write(FileWriter writer)
{
writer.Write(dirEntryStart);
writer.Write(dirEntryFileID);
writer.Write(dirParentID);
public GMIF() { }
public GMIF(BinaryDataReader reader, BTAF btaf) {
FilesData = new byte[btaf.FileDataArray.Length][];
long PositionBuf = reader.Position;
for(int i = 0; i < btaf.FileDataArray.Length; i++) {
reader.Position = PositionBuf + btaf.FileDataArray[i].offset;
FilesData[i] = reader.ReadBytes(
(int) (btaf.FileDataArray[i].size - btaf.FileDataArray[i].offset));
}
}
}
#endregion
}
}