public static void Pack(string inputDirectoryPath, string outputDirectoryPath, bool doList, bool doVerbose)
{
Log.Information("Packing directory {0} ...", inputDirectoryPath);
string libraryName = Path.GetFileNameWithoutExtension(inputDirectoryPath);
string outputFileName = libraryName + ".nicnt";
string outputFilePath = Path.Combine(outputDirectoryPath, outputFileName);
Log.Information("Packing into file {0} ...", outputFilePath);
// read the ContentVersion.txt file
string contentVersionPath = Path.Combine(inputDirectoryPath, "ContentVersion.txt");
string version = "1.0";
if (File.Exists(contentVersionPath))
{
version = IOUtils.ReadTextFromFile(contentVersionPath);
if (doVerbose)
{
Log.Debug("Read version: '" + version + "' from ContentVersion.txt");
}
}
else
{
Log.Information("No ContentVersion.txt file found - using default version: '" + version + "'");
}
// read the [LibraryName].xml file (should have the same name as the input directory)
string productHintsXmlFileName = libraryName + ".xml";
string productHintsXmlFilePath = Path.Combine(inputDirectoryPath, productHintsXmlFileName);
string productHintsXml = "";
ProductHints productHints = null;
if (File.Exists(productHintsXmlFilePath))
{
productHintsXml = IOUtils.ReadTextFromFile(productHintsXmlFilePath);
Log.Information(string.Format("Found ProductHints Xml with length {0} characters.", productHintsXml.Length));
if (doVerbose)
{
Log.Debug("ProductHints Xml:\n" + productHintsXml);
}
// get the product hints as an object
productHints = ProductHintsFactory.ReadFromString(productHintsXml);
// get the productHints as string
productHintsXml = ProductHintsFactory.ToString(productHints);
// test output
// var xmlBytesTest = Encoding.UTF8.GetBytes(productHintsXml);
// BinaryFile.ByteArrayToFile(Path.Combine(inputDirectoryPath, libraryName + "-test.xml"), xmlBytesTest);
// check that the directory name is the same as the Name and RegKey in the xml file
if (productHints.Product.Name != productHints.Product.RegKey || libraryName != productHints.Product.Name)
{
Log.Error(string.Format("Fixing '{0}' due to incorrect values! (Library-Name: '{1}', Xml-Name: '{2}', Xml-RegKey: '{3}')", productHintsXmlFileName, libraryName, productHints.Product.Name, productHints.Product.RegKey));
// change into the library name
productHints.Product.Name = libraryName;
productHints.Product.RegKey = libraryName;
// update the productHints as string
productHintsXml = ProductHintsFactory.ToString(productHints);
// and overwrite
var xmlBytes = Encoding.UTF8.GetBytes(productHintsXml);
BinaryFile.ByteArrayToFile(productHintsXmlFilePath, xmlBytes);
}
}
else
{
Log.Error("Mandatory ProductHints XML file not found at: " + productHintsXmlFilePath);
return;
}
// read the files in the resources directory
var resourceList = new List <NICNTResource>();
string resourcesDirectoryPath = Path.Combine(inputDirectoryPath, "Resources");
if (Directory.Exists(resourcesDirectoryPath))
{
var resourcesFilePaths = Directory.GetFiles(resourcesDirectoryPath, "*.*", SearchOption.AllDirectories);
int counter = 1;
foreach (var filePath in resourcesFilePaths)
{
var res = new NICNTResource();
string name = Path.GetFileName(filePath);
// remove the counter in front
string escapedFileNameWithNumber = Regex.Replace(name, @"^\d{3}(.*?)$", "$1", RegexOptions.IgnoreCase);
// convert the windows supported unix filename to the original unix filename
string unescapedFileName = ToUnixFileName(escapedFileNameWithNumber);
res.Name = unescapedFileName;
var bytes = File.ReadAllBytes(filePath);
res.Data = bytes;
res.Length = bytes.Length;
res.Count = counter;
resourceList.Add(res);
counter++;
}
if (resourceList.Count > 0)
{
if (doVerbose)
{
Log.Debug("Added " + resourceList.Count + " files found in the Resources directory.");
}
}
else
{
if (doVerbose)
{
Log.Information("No files in the Resource directory found!");
}
}
}
else
{
if (doVerbose)
{
Log.Information("No Resources directory found!");
}
}
// check for mandatory .db.cache
if (!resourceList.Any(m => m.Name.ToLower() == ".db.cache"))
{
XmlDocument xml = new XmlDocument();
// Adding the XmlDeclaration (version encoding and standalone) is not necessary as it is added using the XmlWriterSettings
// XmlNode docNode = xml.CreateXmlDeclaration("1.0", "UTF-8", "no");
// xml.AppendChild(docNode);
XmlElement root = xml.CreateElement("soundinfos");
root.SetAttribute("version", "110");
xml.AppendChild(root);
XmlElement all = xml.CreateElement("all");
root.AppendChild(all);
// format the xml string
string xmlString = BeautifyXml(xml);
var res = new NICNTResource();
res.Name = ".db.cache";
var bytes = Encoding.UTF8.GetBytes(xmlString);
res.Data = bytes;
res.Length = bytes.Length;
// res.EndIndex is calculated during the write resource operation later
res.Count = resourceList.Count + 1;
resourceList.Add(res);
if (doVerbose)
{
Log.Information("No .db.cache found - using default .db.cache:\n" + xml.OuterXml);
}
}
using (BinaryFile bf = new BinaryFile(outputFilePath, BinaryFile.ByteOrder.LittleEndian, true))
{
bf.Write(NKS_NICNT_MTD); // 2F 5C 20 4E 49 20 46 43 20 4D 54 44 20 20 2F 5C /\ NI FC MTD /\
bf.Write(new byte[50]); // 50 zero bytes
bf.WriteStringPadded(version, 66, Encoding.Unicode); // zero padded string
Int32 unknown1 = 1;
bf.Write(unknown1);
bf.Write(new byte[8]); // 8 zero bytes
Int32 startOffset = 512000;
bf.Write(startOffset);
Int32 unknown3 = startOffset;
bf.Write(unknown3);
bf.Write(new byte[104]); // 104 zero bytes
bf.Write(productHintsXml);
bf.Write(new byte[startOffset + 256 - bf.Position]); // 512000 + 256 zero bytes - current pos
bf.Write(NKS_NICNT_MTD); // 2F 5C 20 4E 49 20 46 43 20 4D 54 44 20 20 2F 5C /\ NI FC MTD /\
bf.Write(new byte[116]); // 116 zero bytes
Int64 unknown4 = 2;
bf.Write(unknown4);
bf.Write(new byte[4]); // 4 zero bytes
Int64 unknown5 = 1;
bf.Write(unknown5);
bf.Write(new byte[104]); // 104 zero bytes
Int64 unknown6 = 1;
bf.Write(unknown6);
// write delimiter
bf.Write(StringUtils.HexStringToByteArray("F0F0F0F0F0F0F0F0"));
Int64 totalResourceCount = resourceList.Count;
bf.Write(totalResourceCount);
Int64 totalResourceLength = resourceList.Sum(item => item.Length); // sum of bytes in the resourceList
bf.Write(totalResourceLength);
bf.Write(NKS_NICNT_TOC); // 2F 5C 20 4E 49 20 46 43 20 54 4F 43 20 20 2F 5C /\ NI FC TOC /\
bf.Write(new byte[600]); // 600 zero bytes
Int64 resCounter = 1;
Int64 lastEndIndex = 0;
foreach (var res in resourceList)
{
bf.Write(resCounter);
bf.Write(new byte[16]); // 16 zero bytes
bf.WriteStringPadded(res.Name, 600, Encoding.Unicode); // zero padded string
Int64 resUnknown = 0;
bf.Write(resUnknown);
Int64 resEndIndex = lastEndIndex + res.Length; // aggregated end index
bf.Write(resEndIndex);
lastEndIndex = resEndIndex;
resCounter++;
}
// write delimiter
bf.Write(StringUtils.HexStringToByteArray("F1F1F1F1F1F1F1F1"));
Int64 unknown13 = 0;
bf.Write(unknown13);
Int64 unknown14 = 0;
bf.Write(unknown14);
bf.Write(NKS_NICNT_TOC); // 2F 5C 20 4E 49 20 46 43 20 54 4F 43 20 20 2F 5C /\ NI FC TOC /\
bf.Write(new byte[592]); // 592 zero bytes
foreach (var res in resourceList)
{
Log.Information(String.Format("Resource '{0}' @ position {1} [{2} bytes]", res.Name, bf.Position, res.Length));
bf.Write(res.Data);
}
}
}
static readonly byte[] NKS_NICNT_TOC = new byte[] { 0x2F, 0x5C, 0x20, 0x4E, 0x49, 0x20, 0x46, 0x43, 0x20, 0x54, 0x4F, 0x43, 0x20, 0x20, 0x2F, 0x5C }; // /\ NI FC TOC /\
public static void Unpack(string inputFilePath, string outputDirectoryPath, bool doList, bool doVerbose)
{
using (BinaryFile bf = new BinaryFile(inputFilePath, BinaryFile.ByteOrder.LittleEndian, false))
{
var header = bf.ReadBytes(16);
if (header.SequenceEqual(NKS_NICNT_MTD)) // 2F 5C 20 4E 49 20 46 43 20 4D 54 44 20 20 2F 5C /\ NI FC MTD /\
{
bf.Seek(66, SeekOrigin.Begin);
string version = bf.ReadString(66, Encoding.Unicode).TrimEnd('\0');
Log.Information("Version: " + version);
string outputFileName = Path.GetFileNameWithoutExtension(inputFilePath);
if (!doList)
{
IOUtils.CreateDirectoryIfNotExist(Path.Combine(outputDirectoryPath, outputFileName));
}
// Save version in ContentVersion.txt
if (!doList)
{
IOUtils.WriteTextToFile(Path.Combine(outputDirectoryPath, outputFileName, "ContentVersion.txt"), version);
}
int unknown1 = bf.ReadInt32();
if (doVerbose)
{
Log.Debug("Unknown1: " + unknown1);
}
bf.Seek(144, SeekOrigin.Begin);
int startOffset = bf.ReadInt32();
Log.Information("Start Offset: " + startOffset);
int unknown3 = bf.ReadInt32();
if (doVerbose)
{
Log.Debug("Unknown3: " + unknown3);
}
bf.Seek(256, SeekOrigin.Begin);
string productHintsXml = bf.ReadStringNull();
Log.Information(string.Format("Read ProductHints Xml with length {0} characters.", productHintsXml.Length));
if (doVerbose)
{
Log.Debug("ProductHints Xml:\n" + productHintsXml);
}
// Save productHints as xml
if (!doList)
{
IOUtils.WriteTextToFile(Path.Combine(outputDirectoryPath, outputFileName, outputFileName + ".xml"), productHintsXml);
}
// get the product hints as an object
var productHints = ProductHintsFactory.ReadFromString(productHintsXml);
if (productHints != null && productHints.Product.Icon != null && productHints.Product.Icon.ImageBytes != null)
{
ProductHintsFactory.UpdateImageFromImageBytes(productHints);
var image = productHints.Product.Icon.Image;
var imageFormat = productHints.Product.Icon.ImageFormat;
if (image != null && imageFormat != null)
{
Log.Information(string.Format("Found Icon in ProductHints Xml in {0} format. (Dimensions: {1} x {2}, Width: {1} pixels, Height: {2} pixels, Bit depth: {3} bpp)", imageFormat.Name, image.Width, image.Height, image.PixelType.BitsPerPixel));
// save icon to file
if (!doList)
{
var iconFileName = outputFileName + " Icon." + imageFormat.Name.ToLower();
var iconFilePath = Path.Combine(outputDirectoryPath, outputFileName, iconFileName);
if (doVerbose)
{
Log.Debug("Saving Icon to: " + iconFilePath);
}
// save using ImageSharp
// var imageEncoder = image.GetConfiguration().ImageFormatsManager.FindEncoder(imageFormat);
// image.Save(iconFilePath, imageEncoder);
// save using image bytes
BinaryFile.ByteArrayToFile(iconFilePath, productHints.Product.Icon.ImageBytes);
}
}
}
bf.Seek(startOffset + 256, SeekOrigin.Begin);
var header2 = bf.ReadBytes(16);
if (header2.SequenceEqual(NKS_NICNT_MTD)) // 2F 5C 20 4E 49 20 46 43 20 4D 54 44 20 20 2F 5C /\ NI FC MTD /\
{
bf.ReadBytes(116);
long unknown4 = bf.ReadInt64();
if (doVerbose)
{
Log.Debug("Unknown4: " + unknown4);
}
bf.ReadBytes(4);
long unknown5 = bf.ReadInt64();
if (doVerbose)
{
Log.Debug("Unknown5: " + unknown5);
}
bf.ReadBytes(104);
long unknown6 = bf.ReadInt64();
if (doVerbose)
{
Log.Debug("Unknown6: " + unknown6);
}
var delimiter1 = bf.ReadBytes(8);
if (doVerbose)
{
Log.Debug("Delimiter1: " + StringUtils.ByteArrayToHexString(delimiter1)); // F0 F0 F0 F0 F0 F0 F0 F0
}
if (!delimiter1.SequenceEqual(new byte[] { 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0 }))
{
Log.Error("Delimiter1 not as expected 'F0 F0 F0 F0 F0 F0 F0 F0' but got " + StringUtils.ToHexAndAsciiString(delimiter1));
}
long totalResourceCount = bf.ReadInt64();
Log.Information("Total Resource Count: " + totalResourceCount);
long totalResourceLength = bf.ReadInt64();
Log.Information("Total Resource Byte Length: " + totalResourceLength);
var resourceList = new List <NICNTResource>();
var header3 = bf.ReadBytes(16);
if (header3.SequenceEqual(NKS_NICNT_TOC)) // 2F 5C 20 4E 49 20 46 43 20 54 4F 43 20 20 2F 5C /\ NI FC TOC /\
{
bf.ReadBytes(600);
long lastEndIndex = 0;
for (int i = 0; i < totalResourceCount; i++)
{
var resource = new NICNTResource();
Log.Information("-------- Index: " + bf.Position + " --------");
long resCounter = bf.ReadInt64();
Log.Information("Resource Counter: " + resCounter);
resource.Count = resCounter;
bf.ReadBytes(16);
string resName = bf.ReadString(600, Encoding.Unicode).TrimEnd('\0');
Log.Information("Resource Name: " + resName);
resource.Name = resName;
long resUnknown = bf.ReadInt64();
if (doVerbose)
{
Log.Debug("Resource Unknown: " + resUnknown);
}
long resEndIndex = bf.ReadInt64();
Log.Information("Resource End Index: " + resEndIndex);
resource.EndIndex = resEndIndex;
// store calculated length
if (lastEndIndex > 0)
{
resource.Length = resEndIndex - lastEndIndex;
}
else
{
// for the very first entry the end index is the same as the byte length
resource.Length = resEndIndex;
}
Log.Information("Calculated Resource Byte Length: " + resource.Length);
lastEndIndex = resEndIndex;
resourceList.Add(resource);
}
Log.Information("-------- Index: " + bf.Position + " --------");
var delimiter2 = bf.ReadBytes(8);
if (doVerbose)
{
Log.Debug("Delimiter2: " + StringUtils.ByteArrayToHexString(delimiter2)); // F1 F1 F1 F1 F1 F1 F1 F1
}
if (!delimiter2.SequenceEqual(new byte[] { 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1 }))
{
Log.Error("Delimiter2 not as expected 'F1 F1 F1 F1 F1 F1 F1 F1' but got " + StringUtils.ToHexAndAsciiString(delimiter2));
}
long unknown13 = bf.ReadInt64();
if (doVerbose)
{
Log.Debug("Unknown13: " + unknown13);
}
long unknown14 = bf.ReadInt64();
if (doVerbose)
{
Log.Debug("Unknown14: " + unknown14);
}
var header4 = bf.ReadBytes(16);
if (header4.SequenceEqual(NKS_NICNT_TOC)) // 2F 5C 20 4E 49 20 46 43 20 54 4F 43 20 20 2F 5C /\ NI FC TOC /\
{
bf.ReadBytes(592);
if (!doList)
{
IOUtils.CreateDirectoryIfNotExist(Path.Combine(outputDirectoryPath, outputFileName, "Resources"));
}
foreach (var res in resourceList)
{
// convert the unix filename to a windows supported filename
string escapedFileName = FromUnixFileNames(res.Name);
// and add the counter in front
string escapedFileNameWithNumber = string.Format("{0:D3}{1}", res.Count, escapedFileName);
Log.Information(String.Format("Resource '{0}' @ position {1} [{2} bytes]", escapedFileNameWithNumber, bf.Position, res.Length));
res.Data = bf.ReadBytes((int)res.Length);
// if not only listing, save files
if (!doList)
{
string outputFilePath = Path.Combine(outputDirectoryPath, outputFileName, "Resources", escapedFileNameWithNumber);
BinaryFile outBinaryFile = new BinaryFile(outputFilePath, BinaryFile.ByteOrder.LittleEndian, true);
outBinaryFile.Write(res.Data);
outBinaryFile.Close();
}
}
}
else
{
Log.Error(inputFilePath + ": Header4 not as expected '/\\ NI FC TOC /\\' but got " + StringUtils.ToHexAndAsciiString(header4));
}
}
else
{
Log.Error(inputFilePath + ": Header3 not as expected '/\\ NI FC TOC /\\' but got " + StringUtils.ToHexAndAsciiString(header3));
}
}
else
{
Log.Error(inputFilePath + ": Header2 not as expected '/\\ NI FC MTD /\\' but got " + StringUtils.ToHexAndAsciiString(header2));
}
}
else
{
Log.Error(inputFilePath + ": Header not as expected '/\\ NI FC MTD /\\' but got " + StringUtils.ToHexAndAsciiString(header));
}
}
}