public static IEnumerable <SysCpkEntry> EnumerateSysFiles(Cpk cpk, int index)
{
if (cpk.ItocEntries.Count != 16)
{
throw new InvalidDataException($"{cpk.ItocEntries.Count} != 16");
}
byte[] data;
using (var ms = new MemoryStream()) {
cpk.ExtractItoc(ms, cpk.ItocEntries[index]);
if (index != 1) // lzss
{
Span <byte> span = stackalloc byte[4];
ms.Position = 0;
ms.Read(span);
var size = BitConverter.ToInt32(span);
data = LZSS.Decode(ms.StreamAsIEnumerable()).ToArray();
if (data.Length != size)
{
throw new InvalidDataException($"itoc {index} decoded size {data.Length} != {size}");
}
}
else
{
data = new byte[ms.Length];
ms.Position = 0;
ms.Read(data);
}
}
return(HandleNested("", data));
}
private void tabMain_DragDrop(object sender, string path)
{
if (sender == PB_Unpack)
{
openARC(path, pBar1);
}
else if (sender == PB_BCLIM)
{
openIMG(path);
}
else if (sender == PB_Repack)
{
saveARC(path);
}
else
{
try {
LZSS.Decompress(path, Path.Combine(Path.GetDirectoryName(path), "dec_" + Path.GetFileName(path)));
File.Delete(path);
System.Media.SystemSounds.Asterisk.Play();
} catch { try { if (threads < 1)
{
new Thread(() => { threads++; new BLZCoder(new[] { "-d", path }, pBar1); threads--; WinFormsUtil.Alert("Decompressed!"); }).Start();
}
} catch { WinFormsUtil.Error("Unable to process file."); threads = 0; } }
}
}
private static void ExtractFiles(FileList fileList, IFileWriter writer)
{
Console.WriteLine($"Extracting {fileList.Name}");
writer.CreateDirectory(fileList.Name);
foreach (FileData file in fileList.GetFiles())
{
if (file.Compressed)
{
using (var compressed = new MemoryStream(file.Contents))
{
using (var decompressed = new MemoryStream())
{
LZSS.Decompress(compressed, decompressed);
file.Contents = decompressed.ToArray();
}
}
}
if (file.IsArchive())
{
ExtractFiles(new ArchiveFileList(Path.Combine(fileList.Name, file.Name), file.Contents), writer);
}
else
{
writer.Write(Path.Combine(fileList.Name, $"{file.Name}.{file.GetExtension()}"), file.Contents);
}
}
}
// Token: 0x06000026 RID: 38 RVA: 0x000024C4 File Offset: 0x000006C4
public byte[] ReadLZSS(uint expectedSize, bool inPAA = false)
{
if (expectedSize < 1024u && !inPAA)
{
return(this.ReadBytes((int)expectedSize));
}
byte[] result = new byte[expectedSize];
LZSS.readLZSS(this.BaseStream, out result, expectedSize, inPAA);
return(result);
}
byte[] GetType1FileData(int indexOffset)
{
DataStream.Seek(indexOffset, SeekOrigin.Begin);
UInt16 uncmpSize = ReadUInt16LE(DataStream);
UInt16 cmpSize = ReadUInt16LE(DataStream);
DataStream.Seek(indexOffset + 4, SeekOrigin.Begin);
return(LZSS.Decode(DataStream, cmpSize, uncmpSize));
}
public void Save(System.IO.Stream stream)
{
using (var writer = new FileWriter(stream))
{
writer.SetByteOrder(true);
writer.Write(files.Count);
writer.Write(new uint[files.Count]); //reserve space for offsets
for (int i = 0; i < files.Count; i++)
{
uint uncomp_size = (uint)files[i].FileData.Length;
writer.WriteUint32Offset(4 + (i * 4));
writer.Write(uncomp_size);
writer.Write((uint)files[i].CompressionType);
byte[] savedBytes = files[i].AsBytes();
switch (files[i].CompressionType)
{
case CompressionType.LZSS:
savedBytes = LZSS.Encode(savedBytes);
break;
case CompressionType.INFLATE:
{
var compressed = STLibraryCompression.ZLIB.Compress(savedBytes);
List <byte> output = new List <byte>();
output.AddRange(WriteBigEndian(uncomp_size));
output.AddRange(WriteBigEndian((uint)compressed.Length));
output.AddRange(compressed);
savedBytes = output.ToArray();
output.Clear();
}
break;
case CompressionType.SLIDE:
case CompressionType.FSLIDE_Alt:
case CompressionType.FLIDE:
{
List <byte> output = new List <byte>();
output.AddRange(WriteBigEndian(uncomp_size));
output.AddRange(CompressSlide(savedBytes, uncomp_size));
savedBytes = output.ToArray();
output.Clear();
}
break;
default:
throw new Exception($"Compression not supported! {files[i].CompressionType}");
}
writer.Write(savedBytes);
}
}
}
private static void Compress(string filename, Stream file)
{
using (var output = new FileStream($"{filename}{Extension}", FileMode.Create, FileAccess.Write))
{
output.WriteCharacters(Header);
output.WriteUInt(Version);
output.Position += 4;
output.WriteUInt((uint)file.Length);
LZSS.Compress(file, output);
output.Position = 8;
output.WriteUInt((uint)(output.Length - 16));
}
}
public byte[] ReadLZSS(uint expectedSize, bool inPAA = false)
{
if (expectedSize < 1024 && !inPAA) //data is always compressed in PAAs
{
return(ReadBytes((int)expectedSize));
}
else
{
var dst = new byte[expectedSize];
LZSS.ReadLZSS(BaseStream, out dst, expectedSize, inPAA); //PAAs calculate checksums with signed byte values
return(dst);
}
}
public void DecompressSimpleText()
{
var inputPath = TestContext.CurrentContext.TestDirectory + "../../../res/compressedTestFile";
var expectedPath = TestContext.CurrentContext.TestDirectory + "../../../res/testfile2";
var expectedFile = new DataFile(expectedPath);
var inputFile = new DataFile(inputPath);
var comp = new LZSS();
var actualFile = comp.Decompress(inputFile);
Assert.AreEqual(expectedFile.GetBytes(0, expectedFile.Length),
actualFile.GetBytes(0, actualFile.Length));
;
}
public void CompressSimpleTextNoPointersByteArraysOnly()
{
byte[] inputBytes = { 97, 98, 99 };
var inputFile = new DataFile();
inputFile.LoadBytes(inputBytes);
byte[] expected = { 48, 152, 140, 96 };
var comp = new LZSS();
var output = comp.Compress(inputFile);
var actual = output.GetBytes(0, output.Length);
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
if (args.Length != 1)
{
return;
}
using (FileStream input = new FileStream(args[0], FileMode.Open))
{
using (FileStream output = new FileStream(args[0] + "_decompressed", FileMode.Create))
{
LZSS.Decompress(input, output);
}
}
}
public void CompressSimpleTextPointers()
{
var inputPath = TestContext.CurrentContext.TestDirectory + "../../../res/testfile3";
var inputFile = new DataFile(inputPath);
byte[] expectedData = { 48, 152, 140, 102, 72, 1, 152 };
var expected = new DataFile();
expected.LoadBytes(expectedData);
var comp = new LZSS();
var actual = comp.Compress(inputFile);
Assert.AreEqual(expected.GetBytes(0, expected.Length), actual.GetBytes(0, actual.Length));
}
public void CompressSimpleTextNoPointersDataFile()
{
var inputPath = TestContext.CurrentContext.TestDirectory + "../../../res/testfile1";
var inputFile = new DataFile(inputPath);
byte[] expectedData = { 48, 152, 140, 96 };
var expected = new DataFile();
expected.LoadBytes(expectedData);
var comp = new LZSS();
var actual = comp.Compress(inputFile);
Assert.IsTrue(DataFile.Compare(expected, actual));
}
// private methods
byte[] GetType2FileData(int indexOffset, int part)
{
DataRunStream.Seek(indexOffset, SeekOrigin.Begin);
int data001Offset = DataRunStream.ReadByte() + (DataRunStream.ReadByte() << 8) + (DataRunStream.ReadByte() << 16);
for (int i = 0; i < part; i++)
{
int size = ReadUInt16LE(DataRunStream);
data001Offset += size;
}
DataStream.Seek(data001Offset, SeekOrigin.Begin);
UInt16 uncmpSize = ReadUInt16LE(DataStream);
UInt16 cmpSize = ReadUInt16LE(DataStream);
return(LZSS.Decode(DataStream, cmpSize, uncmpSize));
}
public /*bool*/ byte[] TryDecompress()
{
string s;
using (OpenFileDialog ofd = new OpenFileDialog())
if (ofd.ShowDialog() == DialogResult.OK)
{
s = ofd.FileName;
}
else
{
return(null /*false*/);
}
fileSave = Path.GetFileName(s);
byte[] buffer = System.IO.File.ReadAllBytes(s);
//return LZSS.DecompressAll(buffer, (uint)buffer.Length).Length > 0 ? false:g
return(LZSS.DecompressAll(buffer, (uint)buffer.Length));
}
private void button_decompDbg_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "binary dump|*.*";
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
byte[] dump = File.ReadAllBytes(openFileDialog.FileName);
byte[] decompDump = LZSS.Decompress(dump);
var outputFolderPath = Path.GetDirectoryName(openFileDialog.FileName);
//Decompressed file
using (FileStream fs = File.Create(outputFolderPath + "//" + "decompressed_blob.bin"))
{
fs.Write(decompDump, 0, decompDump.Length);
}
}
}
private void DecompressLZSS_BLZ(string path)
{
try
{
LZSS.Decompress(path, Path.Combine(Path.GetDirectoryName(path), "dec_" + Path.GetFileName(path)));
File.Delete(path);
}
catch
{
try
{
if (threads < 1)
{
new Thread(() => { Interlocked.Increment(ref threads); new BLZCoder(new[] { "-d", path }, pBar1); Interlocked.Decrement(ref threads); WinFormsUtil.Alert("Decompressed!"); }).Start();
}
}
catch { WinFormsUtil.Error("Unable to process file."); threads = 0; }
}
}
private static void Decompress(string filename, Stream file)
{
if (file.ReadUInt() != Version)
{
Console.WriteLine("Unknown GTZ version");
return;
}
uint compressedSize = file.ReadUInt();
if (file.Length != compressedSize + 16)
{
Console.WriteLine("Incorrect file size");
return;
}
uint uncompressedSize = file.ReadUInt();
using (var compressed = new MemoryStream())
{
file.CopyTo(compressed);
compressed.Position = 0;
using (var decompressed = new MemoryStream())
{
LZSS.Decompress(compressed, decompressed);
if (decompressed.Length < uncompressedSize)
{
Console.WriteLine("Decompressed data too short");
return;
}
decompressed.Position = 0;
decompressed.SetLength(uncompressedSize);
filename = filename.EndsWith(Extension) ? filename.Replace(Extension, "") : $"decompressed_{filename}";
using (var output = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
decompressed.CopyTo(output);
}
}
}
}
public byte[] ReadLZSS(uint expectedSize, bool inPAA = false)
{
if (expectedSize < 1024 && !inPAA) //data is always compressed in PAAs
{
return(ReadBytes((int)expectedSize));
}
else
{
// XXX: Needs testing
//var buffer = new byte[expectedSize];
//using (var lzss = new LzssStream(BaseStream, CompressionMode.Decompress, true))
//{
// lzss.Read(buffer, 0, (int)expectedSize);
//}
//Chesksum(inPAA, buffer); //PAAs calculate checksums with signed byte values
byte[] buffer;
LZSS.ReadLZSS(BaseStream, out buffer, expectedSize, inPAA);
return(buffer);
}
}
private void button_NetworkControl_Disconnect_Click(object sender, EventArgs e)
{
FileStream fs = new FileStream("far.exe", FileMode.Open);
byte[] uncomp = new byte[fs.Length];
fs.Read(uncomp, 0, uncomp.Length);
ICompression iCompressionArray_obj = new LZSS(8, true, true, false, 131072);
DateTime dt1 = DateTime.Now;
byte [] compress = iCompressionArray_obj.Compress(uncomp, false);
DateTime dt2 = DateTime.Now;
TimeSpan ts1 = dt2 - dt1;
MessageBox.Show(ts1.Minutes.ToString() + ":" + ts1.Seconds.ToString() + ":" + ts1.Milliseconds.ToString());
}
public static LPack FromData(byte[] Data)
{
if (Data.Length < 0x10)
{
return(null);
}
LPack Output = new LPack();
using (MemoryStream Input = new MemoryStream(Data))
{
BinaryReader Reader = new BinaryReader(Input);
uint FilesCount = Reader.ReadUInt32();
uint FileDecLength = Reader.ReadUInt32();
//Simple validity check
uint FirstAddr = 8 + FilesCount * 8;
Input.Seek(4, SeekOrigin.Current);
if (Reader.ReadUInt32() != FirstAddr)
{
return(null);
}
Output.Files = new PackFile[FilesCount];
for (int i = 0; i < FilesCount; i++)
{
Input.Seek(8 + i * 8, SeekOrigin.Begin);
uint DecLength = Utils.ReadUInt24(Reader);
byte FileId = Reader.ReadByte();
uint Address = Reader.ReadUInt32();
Output.Files[i].FileId = FileId;
Output.Files[i].Data = LZSS.Decompress(Data, Address, DecLength);
}
}
return(Output);
}
public static byte[] ToData(LPack Pack)
{
using (MemoryStream Output = new MemoryStream())
{
BinaryWriter Writer = new BinaryWriter(Output);
Writer.Write(Pack.Files.Length);
Writer.Write(0u); //Total decompressed length Place Holder
uint DataAddress = (uint)(8 + Pack.Files.Length * 8);
uint FileDecLength = 0;
for (int i = 0; i < Pack.Files.Length; i++)
{
Output.Seek(8 + i * 8, SeekOrigin.Begin);
Utils.WriteUInt24(Writer, (uint)Pack.Files[i].Data.Length);
Writer.Write(Pack.Files[i].FileId);
Writer.Write(DataAddress);
Output.Seek(DataAddress, SeekOrigin.Begin);
byte[] Comp = LZSS.Compress(Pack.Files[i].Data);
Writer.Write(Comp);
DataAddress += (uint)Comp.Length;
FileDecLength += (uint)Pack.Files[i].Data.Length;
}
Output.Seek(4, SeekOrigin.Begin);
Writer.Write(FileDecLength);
return(Output.ToArray());
}
}
static void Main(string[] args)
{
Console.Title = "MBuild - A Marvelous Translation and Hacking Tool";
Console.WriteLine("MBuild - " + Application.ProductVersion.ToString().Split('.')[0] + "." + Application.ProductVersion.ToString().Split('.')[1]);
Console.WriteLine("A Marvelous Translation and Hacking Tool");
Console.WriteLine("Written by DackR aka Daniel Martin Burgess\r\n");
if (args.Length == 0)
{
Console.WriteLine("No Arguments specified.");
UseXML("MBuild.MBXML", !Settings.Default.AutoBuild);
}
else
{
string mArg = args[0].Trim().ToLower();
switch (mArg)
{
case "build":
BuildXML(args);
break;
case "dump-script":
DumpScript(args);
break;
case "bin-script":
BuildScript(args);
break;
case "comp":
CompressFile(args);
break;
case "decomp":
DeCompressFile(args);
break;
case "bpp-convert":
//BuildScript(args);
break;
case "dmpptr":
DumpPointers();
break;
case "fixsum":
FixCheckSum(args);
break;
case "mbxml-shell":
string[] makeArg = new string[] { "-f", "-t", ".mbxml", "-si", Application.ExecutablePath, "-a", Application.ExecutablePath, "-sn", "MBXML File", "-sc", "MBuild_XML_File" };
//string[] assocArg = new string[] { "-f", "-t", ".txt", "-associate", Application.ExecutablePath };
CTypes.Main(makeArg);
//CTypes.Main(assocArg);
//FileAssociation.SetAssociation(".mbxml", "MBuild_XML_File", Application.ExecutablePath, "MBXML File", args);
break;
case "ips":
MakeIPS(args);
break;
case "xdelta":
MakexDelta(args);
break;
case "extract": //used to extract RAW binary data from a file
ExtractBin(args);
break;
case "dmpdata":
//Dump data located at the various pointers
DumpData(args);
break;
case "bm5dump":
SBM5.DumpDataFromPointerTab(@"F:\GoogleDrive\SBM5\Base\Base.sfc", @"F:\GoogleDrive\SBM5\Dump\");
break;
case "test":
string romfile = @"D:\GoogleDrive\SuperFamicomWars\base.sfc";
byte[] data = File.ReadAllBytes(romfile);
MemoryStream ms = LZSS.Decompress(data);
byte[] dcdata = ms.ToArray();
break;
default:
if (mArg.ToLower().Contains(".mbxml") && File.Exists(mArg))
{ //detected xml file specified... Try to build.
UseXML(mArg, false);
//Console.WriteLine(mArg);
//Console.ReadKey(true);
}
break;
}
}
LCompress.LunarCompressCleanup();
xDelta.xDeltaCleanup();
bool wait = false;
Console.Write("Press any key to exit (\"q\" to stop count-down)");
DateTime beginWait = DateTime.Now;
while (!Console.KeyAvailable && DateTime.Now.Subtract(beginWait).TotalSeconds < 3)
{
Console.Write(".");
Thread.Sleep(250);
}
if (Console.KeyAvailable && (Console.ReadKey(true).Key == ConsoleKey.Q))
{
wait = true;
}
if (wait)
{
Console.CursorLeft = 0;
Console.Write(("").PadLeft(79, ' '));
Console.CursorLeft = 0;
Console.Write("Press any key to exit...");
Console.ReadKey(true);
}
}
public static file load(Stream data)
{
//Too small
if (data.Length < 0x10)
{
data.Close();
return(new file {
type = formatType.unsupported
});
}
BinaryReader input = new BinaryReader(data);
uint magic, length;
switch (peek(input))
{
case 0x00010000: return(new file {
data = GfModel.load(data), type = formatType.model
});
case 0x00060000: return(new file {
data = GfMotion.loadAnim(input), type = formatType.anims
});
case 0x15041213: return(new file {
data = GfTexture.load(data), type = formatType.image
});
case 0x15122117:
RenderBase.OModelGroup mdls = new RenderBase.OModelGroup();
mdls.model.Add(GfModel.loadModel(data));
return(new file {
data = mdls, type = formatType.model
});
}
switch (getMagic(input, 5))
{
case "MODEL": return(new file {
data = DQVIIPack.load(data), type = formatType.container
});
}
switch (getMagic(input, 4))
{
case "CGFX": return(new file {
data = CGFX.load(data), type = formatType.model
});
case "CRAG": return(new file {
data = GARC.load(data), type = formatType.container
});
case "darc": return(new file {
data = DARC.load(data), type = formatType.container
});
case "FPT0": return(new file {
data = FPT0.load(data), type = formatType.container
});
case "IECP":
magic = input.ReadUInt32();
length = input.ReadUInt32();
return(load(new MemoryStream(LZSS.decompress(data, length))));
case "NLK2":
data.Seek(0x80, SeekOrigin.Begin);
return(new file
{
data = CGFX.load(data),
type = formatType.model
});
case "SARC": return(new file {
data = SARC.load(data), type = formatType.container
});
case "SMES": return(new file {
data = NLP.loadMesh(data), type = formatType.model
});
case "Yaz0":
magic = input.ReadUInt32();
length = IOUtils.endianSwap(input.ReadUInt32());
data.Seek(8, SeekOrigin.Current);
return(load(new MemoryStream(Yaz0.decompress(data, length))));
case "zmdl": return(new file {
data = ZMDL.load(data), type = formatType.model
});
case "ztex": return(new file {
data = ZTEX.load(data), type = formatType.texture
});
}
//Check if is a BCLIM or BFLIM file (header on the end)
if (data.Length > 0x28)
{
data.Seek(-0x28, SeekOrigin.End);
string clim = IOUtils.readStringWithLength(input, 4);
if (clim == "CLIM" || clim == "FLIM")
{
return new file {
data = BCLIM.load(data), type = formatType.image
}
}
;
}
switch (getMagic(input, 3))
{
case "BCH":
byte[] buffer = new byte[data.Length];
input.Read(buffer, 0, buffer.Length);
data.Close();
return(new file
{
data = BCH.load(new MemoryStream(buffer)),
type = formatType.model
});
case "DMP": return(new file {
data = DMP.load(data), type = formatType.image
});
}
string magic2b = getMagic(input, 2);
switch (magic2b)
{
case "AD": return(new file {
data = AD.load(data), type = formatType.model
});
case "BM": return(new file {
data = MM.load(data), type = formatType.model
});
case "BS": return(new file {
data = BS.load(data), type = formatType.anims
});
case "CM": return(new file {
data = CM.load(data), type = formatType.model
});
case "CP": return(new file {
data = CP.load(data), type = formatType.model
});
case "GR": return(new file {
data = GR.load(data), type = formatType.model
});
case "MM": return(new file {
data = MM.load(data), type = formatType.model
});
case "PC": return(new file {
data = PC.load(data), type = formatType.model
});
case "PT": return(new file {
data = PT.load(data), type = formatType.texture
});
}
if (magic2b.Length == 2)
{
if ((magic2b[0] >= 'A' && magic2b[0] <= 'Z') &&
(magic2b[1] >= 'A' && magic2b[1] <= 'Z'))
{
return(new file {
data = PkmnContainer.load(data), type = formatType.container
});
}
}
//Compressions
data.Seek(0, SeekOrigin.Begin);
uint cmp = input.ReadUInt32();
if ((cmp & 0xff) == 0x13)
{
cmp = input.ReadUInt32();
}
switch (cmp & 0xff)
{
case 0x11: return(load(new MemoryStream(LZSS_Ninty.decompress(data, cmp >> 8))));
case 0x90:
byte[] buffer = BLZ.decompress(data);
byte[] newData = new byte[buffer.Length - 1];
Buffer.BlockCopy(buffer, 1, newData, 0, newData.Length);
return(load(new MemoryStream(newData)));
}
data.Close();
return(new file {
type = formatType.unsupported
});
}
public static void Decompress(object sender, EventArgs e)
{
var tsi = sender as ToolStripMenuItem;
if (!PrepareFiles("Open a " + tsi.Tag.ToString() + " compressed file...", "Save your decompressed file...", ".decomp", out FileStream openFile, out FileStream saveFile))
{
return;
}
try
{
using (openFile)
using (var outFs = new BinaryWriterX(saveFile))
switch (tsi.Tag)
{
case Compression.Level5:
outFs.Write(Level5.Decompress(openFile));
break;
case Compression.GZip:
outFs.Write(GZip.Decompress(openFile));
break;
case Compression.Huff4:
outFs.Write(Huffman.Decompress(openFile, 4));
break;
case Compression.Huff8:
outFs.Write(Huffman.Decompress(openFile, 8));
break;
case Compression.LZ10:
outFs.Write(LZ10.Decompress(openFile));
break;
case Compression.LZ11:
outFs.Write(LZ11.Decompress(openFile));
break;
case Compression.LZ77:
outFs.Write(LZ77.Decompress(openFile));
break;
case Compression.LZSS:
outFs.Write(LZSS.Decompress(openFile, LZSS.GetDecompressedSize(openFile)));
break;
case Compression.LZSSVLE:
outFs.Write(LZSSVLE.Decompress(openFile));
break;
case Compression.RevLZ77:
outFs.Write(RevLZ77.Decompress(openFile));
break;
case Compression.LZECD:
outFs.Write(LZECD.Decompress(openFile));
break;
case Compression.RLE:
outFs.Write(RLE.Decompress(openFile));
break;
case Compression.ZLib:
outFs.Write(ZLib.Decompress(openFile));
break;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), tsi?.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
MessageBox.Show($"Successfully decompressed {Path.GetFileName(openFile.Name)}.", tsi?.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public static List <LZSS> SetLZSS(string text)
{
var lzss = new List <LZSS>();
int i = 0;
while (i < text.Count())
{
var lz = new LZSS();
if (lzss.Count == 0)
{
lz.Dictionary = "";
lz.FutureDictionary = text[0].ToString();
lz.Buffer = text.Substring(0, 8);
lz.Code = $"0, {text[0]} ";
lz.LengthCode = 9;
lzss.Add(lz);
}
else
{
int vh = -1;
bool flag = false;
lz.Dictionary = lzss.LastOrDefault().FutureDictionary;
int length = 0;
if (text.Length - (i + 1) >= 8)
{
length = 8;
lz.Buffer = text.Substring(i, length);
}
else
{
length = text.Length - (i + 1);
lz.Buffer = text.Substring(i, length);
}
for (int j = lz.Buffer.Length - 1; j >= 0; j--)
{
vh = lz.Dictionary.IndexOf(lz.Buffer.Substring(0, j + 1));
if (vh != -1)
{
flag = true;
int lengthSub = 0;
if (j == 0 && vh != 0)
{
if (lz.Buffer.Count() != 1)
{
lengthSub = j + 2;
}
else
{
lengthSub = j + 1;
}
}
else if (j == 0 && vh == 0)
{
lengthSub = j + 1;
}
else if (j != 0)
{
lengthSub = j + 1;
}
if (lz.Dictionary.Length >= 16 || (lz.Dictionary + lz.Buffer.Substring(0, lengthSub)).Length >= 16)
{
int dict = lz.Dictionary.Length + lz.Buffer.Substring(0, lengthSub).Length - lz.Dictionary.Length;
lz.FutureDictionary = lz.Dictionary.Remove(0, dict) + lz.Buffer.Substring(0, lengthSub);
lz.Code = $"1, ({vh}, {lengthSub})";
lz.LengthCode = 7;
i = i + dict - 1;
break;
}
else
{
int dict = lz.Dictionary.Length + lz.Buffer.Substring(0, lengthSub).Length - lz.Dictionary.Length;
lz.FutureDictionary = lz.Dictionary + lz.Buffer.Substring(0, lengthSub);
lz.Code = $"1, ({vh}, {lengthSub})";
lz.LengthCode = 7;
i = i + dict - 1;
break;
}
}
}
if (flag == false)
{
if (lz.Dictionary.Length >= 16)
{
lz.FutureDictionary = lz.Dictionary.Remove(0, 1) + text[i];
lz.Code = $"0, {text[i]} ";
lz.LengthCode = 9;
}
else
{
lz.FutureDictionary = lz.Dictionary + text[i];
lz.Code = $"0, {text[i]} ";
lz.LengthCode = 9;
}
}
lzss.Add(lz);
}
i++;
}
return(lzss);
}
private void button_Decompress_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "LoGH Containers|*.mvx;*.arc";
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
string outputFolderPath = openFileDialog.FileName + "_";
GenericInfo tmpGeneric = new GenericInfo
{
ContainerName = openFileDialog.FileName,
ContainerType = Path.GetExtension(openFileDialog.FileName)
};
ARCHeader tmpHeader = new ARCHeader();
List <ARCToc> tmpToc = new List <ARCToc>();
using (BinaryReader reader = new BinaryReader(new FileStream(openFileDialog.FileName, FileMode.Open)))
{
//Parse Header
reader.BaseStream.Seek(0, SeekOrigin.Begin);
tmpHeader.HeaderIdentifier = reader.ReadBytes(4);
tmpHeader.FileReaderBufferSize = reader.ReadByte();
tmpHeader.UnknownType = reader.ReadByte();
reader.BaseStream.Seek(3, SeekOrigin.Current); //0x00 three times
tmpHeader.UnknownValue1 = reader.ReadByte();
tmpHeader.TocPointer2 = reader.ReadByte();
tmpHeader.UnknownValue2 = reader.ReadByte();
tmpHeader.UnknownType2 = reader.ReadByte();
tmpHeader.FileCount = reader.ReadByte();
tmpHeader.UnknownValue3 = reader.ReadByte();
tmpHeader.CompressionType = reader.ReadByte();
tmpHeader.HeaderLeftover = reader.ReadBytes(112);
//Begin of TOC
reader.BaseStream.Seek(2, SeekOrigin.Current); //skip two 0x00
for (int i = 1; i <= tmpHeader.FileCount; i++)
{
long entryOffset = reader.BaseStream.Position;
ARCToc localToc = new ARCToc();
for (int j = 1; j <= 5; j++)
{
var VAL1 = reader.ReadByte();
reader.BaseStream.Seek(6, SeekOrigin.Current);
var VAL2 = reader.ReadByte();
reader.BaseStream.Seek(6, SeekOrigin.Current);
var VAL3 = reader.ReadByte();
reader.BaseStream.Seek(6, SeekOrigin.Current);
var VAL4 = reader.ReadByte();
reader.BaseStream.Seek(6, SeekOrigin.Current);
var tmpVal = (VAL1 | (VAL2 << 8) | (VAL3 << 16) | (VAL4 << 24));
switch (j)
{
case 1:
localToc.NameOffset = tmpVal;
break;
case 2:
localToc.NameLength = tmpVal;
break;
case 3:
localToc.Offset = tmpVal;
break;
case 4:
localToc.Zsize = tmpVal;
break;
case 5:
localToc.Size = tmpVal;
break;
default:
throw new Exception("NOPE!");
}
entryOffset += 1;
reader.BaseStream.Seek(entryOffset, SeekOrigin.Begin);
}
//Readout name string
long preOffset = reader.BaseStream.Position;
reader.BaseStream.Seek(localToc.NameOffset, SeekOrigin.Begin);
localToc.NameBytes = reader.ReadBytes(localToc.NameLength);
localToc.Name = new ASCIIEncoding().GetString(localToc.NameBytes, 0, localToc.NameLength - 1); //-1 because we dont want the null terminator
//Read DATA (offset since file begin)
reader.BaseStream.Seek(localToc.Offset, SeekOrigin.Begin);
localToc.Data = reader.ReadBytes(localToc.Zsize);
localToc.OffsetEnd = (int)reader.BaseStream.Position;
//Reset Seek for next header file
reader.BaseStream.Seek(preOffset, SeekOrigin.Begin);
//Add toc to list
tmpToc.Add(localToc);
//Everything is ready to readout compressed data
if (localToc.Zsize == localToc.Size)
{
//Content is unencrypted... passtrough directly to filewriter
localToc.DataDecompressed = localToc.Data;
}
else
{
//decompress with lzss
localToc.DataDecompressed = LZSS.Decompress(localToc.Data);
}
reader.BaseStream.Seek(27, SeekOrigin.Current);
}
}
//PHASE 2: Export data from memory to Filesystem
DirectoryInfo di = Directory.CreateDirectory(outputFolderPath);
foreach (var toc in tmpToc)
{
//Check name for sub-folders - when there are some - create
Directory.CreateDirectory(Path.GetDirectoryName(outputFolderPath + "//" + toc.Name));
//Decompressed file
using (FileStream fs = File.Create(outputFolderPath + "//" + toc.Name))
{
fs.Write(toc.DataDecompressed, 0, toc.DataDecompressed.Length);
}
//Compressed file
using (FileStream fs = File.Create(outputFolderPath + "//" + toc.Name + "_COMP"))
{
fs.Write(toc.Data, 0, toc.Data.Length);
}
}
SerializeCollection tmpSer = new SerializeCollection
{
generic = tmpGeneric,
arcHeader = tmpHeader,
arcToc = tmpToc
};
//Serialize header & toc
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream(outputFolderPath + "//_header.bin", FileMode.Create, FileAccess.Write, FileShare.None);
//GZipStream gzip = new GZipStream(stream, CompressionLevel.Fastest);
formatter.Serialize(stream, tmpSer);
stream.Close();
}
}
public static void Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("Usage: <input path> [-o <output path>] [-A <algorithm (lz, ppm, huffman)>]");
return;
}
DataFile input;
string outputPath;
Stopwatch watch = new Stopwatch();
ICompressor compressor = new LZSS();
var fileExtension = "lz";
try {
var inputPath = args[0];
input = new DataFile(inputPath);
if (args.Contains("-A"))
{
var i = Array.IndexOf(args, "-A") + 1;
Console.WriteLine($"{args[i]}");
switch (args[i])
{
case "lz":
compressor = new LZSS();
fileExtension = "lz";
break;
case "ppm":
compressor = new PredictionByPartialMatching();
fileExtension = "ppm";
break;
case "huffman":
compressor = new HuffmanCompressor();
fileExtension = "huffman";
break;
default:
throw new InvalidCompressorException();
}
}
var compress = !args.Contains("-D");
if (!compress)
{
outputPath = Path.GetFullPath(inputPath);
outputPath = Path.ChangeExtension(outputPath, null);
}
else
{
outputPath = Path.GetFullPath(inputPath) + "." + fileExtension;
}
if (args.Contains("-o"))
{
var i = Array.IndexOf(args, "-o") + 1;
outputPath = args[i];
}
Console.WriteLine("{0}ompressing file with algorithm {1}.", compress ? "C" : "Dec", fileExtension);
DataFile output;
Thread t = new Thread(PrintStatus);
t.Start(compressor);
watch.Start();
if (compress)
{
output = compressor.Compress(input);
}
else
{
output = compressor.Decompress(input);
}
output.WriteToFile(outputPath);
Console.WriteLine("\rPercent: 100.0%");
Console.WriteLine($"Elapsed time: {watch.Elapsed} Ratio: {(double)output.Length / input.Length}");
Console.WriteLine("Compression speed: " + (double)input.Length / watch.ElapsedMilliseconds + " kb/s");
Console.WriteLine("File written to {0}", outputPath);
t.Abort();
}
catch (FileNotFoundException e) {
Console.WriteLine("File was not found: {0}", e.Message);
}
catch (InvalidCompressorException) {
Console.WriteLine("The compression algorithm specified does not exist");
}
catch (DirectoryNotFoundException e) {
Console.WriteLine("Directory or file does not exist: {0}", e.Message);
}
}
public TitleScreenEditor6()
{
InitializeComponent();
AllowDrop = true;
DragEnter += TC_Main_DragEnter;
DragDrop += TC_Main_DragDrop;
PB_Image.AllowDrop = true;
PB_Image.DragEnter += TC_Main_DragEnter;
PB_Image.DragDrop += TC_Main_DragDrop;
// Add tooltip to image
new ToolTip().SetToolTip(PB_Image, "Click to toggle Green Screen\nRightClick for I/O\nCTRL+Click for Copy->Clipboard.");
// Add context menus
ContextMenuStrip mnu = new ContextMenuStrip();
ToolStripMenuItem mnuR = new ToolStripMenuItem("Replace with...");
ToolStripMenuItem mnuS = new ToolStripMenuItem("Save as...");
// Assign event handlers
mnuR.Click += ClickOpen;
mnuS.Click += ClickSave;
// Add to main context menu
mnu.Items.AddRange(new ToolStripItem[] { mnuR, mnuS, });
// Assign
PB_Image.ContextMenuStrip = mnu;
// Set up languages
string[] languages = (Main.Config.ORAS ? new[] { "JP1" } : Array.Empty <string>()).Concat(new[] { "DE", "ES", "FR", "IT", "JP", "KO", "EN" }).ToArray();
string[] games = Main.Config.ORAS ? new[] { "OR", "AS" } : new[] { "X", "Y" };
for (int i = 0; i < darcs.Length / 2; i++)
{
CB_DARC.Items.Add($"{games[0]} - {languages[i]}");
}
for (int i = darcs.Length / 2; i < darcs.Length; i++)
{
CB_DARC.Items.Add($"{games[1]} - {languages[i - (darcs.Length/2)]}");
}
// Load darcs
for (int i = 0; i < darcs.Length; i++)
{
// Get DARC name and assign the decompressed name
usedFiles[i] = "titlescreen\\" + (compressed ? "dec_" : "") + Path.GetFileName(files[darcFiles[i]]);
if (compressed) // Decompress file (XY does not compress)
{
LZSS.Decompress(files[darcFiles[i]], usedFiles[i]);
}
// Read decompressed file
var data = File.ReadAllBytes(usedFiles[i]);
// Find darc data offset (ignore header)
int pos = 0;
while (BitConverter.ToUInt32(data, pos) != 0x63726164)
{
pos += 4;
if (pos >= data.Length)
{
throw new Exception("Invalid DARC?\n\n" + usedFiles[i]);
}
}
var darcData = data.Skip(pos).ToArray();
darcs[i] = new DARC(darcData);
}
CB_DARC.SelectedIndex = CB_DARC.Items.Count - 1; // last (english game2)
}
public static int Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("No options specified.");
return(1);
}
switch (args[0])
{
// Pack a directory of files into DATA.001, DATA.DIR, DATA.RUN.
case "--packfiles": {
var cmpArchive = new Archive(args[1]);
var uncmpArchive = new Archive(args[2]);
PackedFileWriter writer = new PackedFileWriter(cmpArchive, uncmpArchive);
writer.Save(args[3]);
break;
}
// Decompress a file
case "--compressfile": {
byte[] data = File.ReadAllBytes(args[1]);
byte[] cmpData = LZSS.Encode(data);
FileStream output = File.Open(args[2], FileMode.Create);
output.WriteByte((byte)(data.Length & 0xff));
output.WriteByte((byte)(data.Length >> 8));
output.Write(cmpData, 0, cmpData.Length);
output.Close();
break;
}
// Decompress a given file
case "--decompressfile": {
FileStream stream = File.OpenRead(args[1]);
byte[] cmpData = new byte[stream.Length - 2];
UInt16 uncmpSize = (UInt16)(stream.ReadByte() + (stream.ReadByte() << 8));
stream.Read(cmpData, 0, cmpData.Length);
byte[] data = LZSS.Decode(cmpData, cmpData.Length, uncmpSize);
FileStream output = File.Open(args[2], FileMode.Create);
output.Write(data, 0, data.Length);
output.Close();
break;
}
// Dump uncompressed versions of all files
case "--dumpallfiles": {
var archive = new Archive(args[1]);
var fileMgr = new PackedFileReader(archive);
DumpAllFiles(fileMgr, args[2]);
break;
}
// Dump compressed versions of all files
case "--dumpallfilescmp": {
var archive = new Archive(args[1]);
var fileMgr = new PackedFileReader(archive);
DumpAllCompressedFiles(fileMgr, args[2]);
break;
}
// Dump text from an RDF file
case "--dumprdftext": {
byte[] data = File.ReadAllBytes(args[1]);
int textPos = Int32.Parse(args[2]);
Console.Write("\"");
while (data[textPos] != '\0')
{
char c = (char)(data[textPos++]);
if (c == '\\' || c == '"')
{
Console.Write("\\");
}
Console.Write(c);
}
Console.Write("\",\n");
break;
}
// Dump table of text from an RDF file
case "--dumprdftexttable": {
byte[] data = File.ReadAllBytes(args[1]);
int pos = Int32.Parse(args[2]);
Console.WriteLine("const char *text[] = {");
do
{
int textPos = Helper.ReadUInt16(data, pos);
Console.Write("\t\"");
while (data[textPos] != '\0')
{
char c = (char)(data[textPos++]);
if (c == '\\' || c == '"')
{
Console.Write("\\");
}
Console.Write(c);
}
Console.Write("\",\n");
pos += 2;
}while (Helper.ReadUInt16(data, pos) != 0);
Console.WriteLine("\t\"\"\n};");
break;
}
case "--dumpscript": {
if (args.Length >= 3)
{
DumpScript(args[1], args[2]);
}
else
{
DumpScript(args[1], null);
}
break;
}
// Dump "scripts" (x86 code) from RDF files into txt files (uses objdump to disassemble)
case "--dumpallscripts": {
var directory = args[1];
var outputDir = args[2];
string sfxDir = (args.Length >= 3 ? args[2] : null);
foreach (String s in Directory.GetFiles(directory))
{
if (s.EndsWith(".RDF"))
{
DumpScript(s, sfxDir, outputDir);
}
}
break;
}
default:
Console.WriteLine("Unrecognized option \"" + args[0] + "\".");
return(1);
}
return(0);
}