public bool ReadETOC(EndianReader br, ulong startoffset)
{
br.BaseStream.Seek((long)startoffset, SeekOrigin.Begin);
if (tools.ReadCString(br, 4) != "ETOC")
{
br.Close();
return(false);
}
//br.BaseStream.Seek(0xC, SeekOrigin.Current); //skip header data
ReadUTFData(br);
ETOC_packet = utf_packet;
FileEntry etoc_entry = FileTable.Where(x => x.FileName.ToString() == "ETOC_HDR").Single();
etoc_entry.Encrypted = isUtfEncrypted;
etoc_entry.FileSize = ETOC_packet.Length;
MemoryStream ms = new MemoryStream(utf_packet);
EndianReader utfr = new EndianReader(ms, false);
files = new UTF(tools);
if (!files.ReadUTF(utfr))
{
br.Close();
return(false);
}
utfr.Close();
ms.Close();
List <FileEntry> fileEntries = FileTable.Where(x => x.FileType == "FILE").ToList();
for (int i = 0; i < fileEntries.Count; i++)
{
FileTable[i].LocalDir = GetColumnData(files, i, "LocalDir");
var tUpdateDateTime = GetColumnData(files, i, "UpdateDateTime");
if (tUpdateDateTime == null)
{
tUpdateDateTime = 0;
}
FileTable[i].UpdateDateTime = (ulong)tUpdateDateTime;
}
return(true);
}
public bool ReadGTOC(EndianReader br, ulong startoffset)
{
br.BaseStream.Seek((long)startoffset, SeekOrigin.Begin);
if (tools.ReadCString(br, 4) != "GTOC")
{
br.Close();
return(false);
}
//br.BaseStream.Seek(0xC, SeekOrigin.Current); //skip header data
ReadUTFData(br);
GTOC_packet = utf_packet;
FileEntry gtoc_entry = FileTable.Where(x => x.FileName.ToString() == "GTOC_HDR").Single();
gtoc_entry.Encrypted = isUtfEncrypted;
gtoc_entry.FileSize = GTOC_packet.Length;
return(true);
}
public byte[] DecompressLegacyCRI(byte[] input, int USize)
{
byte[] result;// = new byte[USize];
MemoryStream ms = new MemoryStream(input);
EndianReader br = new EndianReader(ms, true);
br.BaseStream.Seek(8, SeekOrigin.Begin); // Skip CRILAYLA
int uncompressed_size = br.ReadInt32();
int uncompressed_header_offset = br.ReadInt32();
result = new byte[uncompressed_size + 0x100];
// do some error checks here.........
// copy uncompressed 0x100 header to start of file
Array.Copy(input, uncompressed_header_offset + 0x10, result, 0, 0x100);
int input_end = input.Length - 0x100 - 1;
int input_offset = input_end;
int output_end = 0x100 + uncompressed_size - 1;
byte bit_pool = 0;
int bits_left = 0, bytes_output = 0;
int[] vle_lens = new int[4] {
2, 3, 5, 8
};
while (bytes_output < uncompressed_size)
{
if (get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 1) > 0)
{
int backreference_offset = output_end - bytes_output + get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 13) + 3;
int backreference_length = 3;
int vle_level;
for (vle_level = 0; vle_level < vle_lens.Length; vle_level++)
{
int this_level = get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, vle_lens[vle_level]);
backreference_length += this_level;
if (this_level != ((1 << vle_lens[vle_level]) - 1))
{
break;
}
}
if (vle_level == vle_lens.Length)
{
int this_level;
do
{
this_level = get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 8);
backreference_length += this_level;
} while (this_level == 255);
}
for (int i = 0; i < backreference_length; i++)
{
result[output_end - bytes_output] = result[backreference_offset--];
bytes_output++;
}
}
else
{
// verbatim byte
result[output_end - bytes_output] = (byte)get_next_bits(input, ref input_offset, ref bit_pool, ref bits_left, 8);
bytes_output++;
}
}
br.Close();
ms.Close();
return(result);
}
public bool ReadITOC(EndianReader br, ulong startoffset, ulong ContentOffset, ushort Align)
{
br.BaseStream.Seek((long)startoffset, SeekOrigin.Begin);
if (tools.ReadCString(br, 4) != "ITOC")
{
br.Close();
return(false);
}
ReadUTFData(br);
ITOC_packet = utf_packet;
FileEntry itoc_entry = FileTable.Where(x => x.FileName.ToString() == "ITOC_HDR").Single();
itoc_entry.Encrypted = isUtfEncrypted;
itoc_entry.FileSize = ITOC_packet.Length;
MemoryStream ms = new MemoryStream(utf_packet);
EndianReader utfr = new EndianReader(ms, false);
files = new UTF(tools);
if (!files.ReadUTF(utfr))
{
br.Close();
return(false);
}
utfr.Close();
ms.Close();
//uint FilesL = (uint)GetColumnData(files, 0, "FilesL");
//uint FilesH = (uint)GetColumnData(files, 0, "FilesH");
byte[] DataL = (byte[])GetColumnData(files, 0, "DataL");
long DataLPos = GetColumnPostion(files, 0, "DataL");
byte[] DataH = (byte[])GetColumnData(files, 0, "DataH");
long DataHPos = GetColumnPostion(files, 0, "DataH");
//MemoryStream ms;
//EndianReader ir;
UTF utfDataL, utfDataH;
Dictionary <int, uint> SizeTable, CSizeTable;
Dictionary <int, long> SizePosTable, CSizePosTable;
Dictionary <int, Type> SizeTypeTable, CSizeTypeTable;
List <int> IDs = new List <int>();
SizeTable = new Dictionary <int, uint>();
SizePosTable = new Dictionary <int, long>();
SizeTypeTable = new Dictionary <int, Type>();
CSizeTable = new Dictionary <int, uint>();
CSizePosTable = new Dictionary <int, long>();
CSizeTypeTable = new Dictionary <int, Type>();
ushort ID, size1;
uint size2;
long pos;
Type type;
if (DataL != null)
{
ms = new MemoryStream(DataL);
utfr = new EndianReader(ms, false);
utfDataL = new UTF(tools);
utfDataL.ReadUTF(utfr);
for (int i = 0; i < utfDataL.num_rows; i++)
{
ID = (ushort)GetColumnData(utfDataL, i, "ID");
size1 = (ushort)GetColumnData(utfDataL, i, "FileSize");
SizeTable.Add((int)ID, (uint)size1);
pos = GetColumnPostion(utfDataL, i, "FileSize");
SizePosTable.Add((int)ID, pos + DataLPos);
type = GetColumnType(utfDataL, i, "FileSize");
SizeTypeTable.Add((int)ID, type);
if ((GetColumnData(utfDataL, i, "ExtractSize")) != null)
{
size1 = (ushort)GetColumnData(utfDataL, i, "ExtractSize");
CSizeTable.Add((int)ID, (uint)size1);
pos = GetColumnPostion(utfDataL, i, "ExtractSize");
CSizePosTable.Add((int)ID, pos + DataLPos);
type = GetColumnType(utfDataL, i, "ExtractSize");
CSizeTypeTable.Add((int)ID, type);
}
IDs.Add(ID);
}
}
if (DataH != null)
{
ms = new MemoryStream(DataH);
utfr = new EndianReader(ms, false);
utfDataH = new UTF(tools);
utfDataH.ReadUTF(utfr);
for (int i = 0; i < utfDataH.num_rows; i++)
{
ID = (ushort)GetColumnData(utfDataH, i, "ID");
size2 = (uint)GetColumnData(utfDataH, i, "FileSize");
SizeTable.Add(ID, size2);
pos = GetColumnPostion(utfDataH, i, "FileSize");
SizePosTable.Add((int)ID, pos + DataHPos);
type = GetColumnType(utfDataH, i, "FileSize");
SizeTypeTable.Add((int)ID, type);
if ((GetColumnData(utfDataH, i, "ExtractSize")) != null)
{
size2 = (uint)GetColumnData(utfDataH, i, "ExtractSize");
CSizeTable.Add(ID, size2);
pos = GetColumnPostion(utfDataH, i, "ExtractSize");
CSizePosTable.Add((int)ID, pos + DataHPos);
type = GetColumnType(utfDataH, i, "ExtractSize");
CSizeTypeTable.Add((int)ID, type);
}
IDs.Add(ID);
}
}
FileEntry temp;
//int id = 0;
uint value = 0, value2 = 0;
ulong baseoffset = ContentOffset;
// Seems ITOC can mix up the IDs..... but they'll alwaysy be in order...
IDs = IDs.OrderBy(x => x).ToList();
for (int i = 0; i < IDs.Count; i++)
{
int id = IDs[i];
temp = new FileEntry();
SizeTable.TryGetValue(id, out value);
CSizeTable.TryGetValue(id, out value2);
temp.TOCName = "ITOC";
temp.DirName = null;
temp.FileName = id.ToString() + ".bin";
temp.FileSize = value;
temp.FileSizePos = SizePosTable[id];
temp.FileSizeType = SizeTypeTable[id];
if (CSizeTable.Count > 0 && CSizeTable.ContainsKey(id))
{
temp.ExtractSize = value2;
temp.ExtractSizePos = CSizePosTable[id];
temp.ExtractSizeType = CSizeTypeTable[id];
}
temp.FileType = "FILE";
temp.FileOffset = baseoffset;
temp.ID = id;
temp.UserString = null;
FileTable.Add(temp);
if ((value % Align) > 0)
{
baseoffset += value + (Align - (value % Align));
}
else
{
baseoffset += value;
}
//id++;
}
files = null;
utfDataL = null;
utfDataH = null;
ms.Close();
utfr.Close();
return(true);
}
public bool ReadCPK(string sPath, Encoding encoding = null)
{
if (File.Exists(sPath))
{
uint Files;
ushort Align;
EndianReader br = new EndianReader(File.OpenRead(sPath), true);
MemoryStream ms;
EndianReader utfr;
if (tools.ReadCString(br, 4) != "CPK ")
{
br.Close();
return(false);
}
ReadUTFData(br);
CPK_packet = utf_packet;
FileEntry CPAK_entry = new FileEntry
{
FileName = "CPK_HDR",
FileOffsetPos = br.BaseStream.Position + 0x10,
FileSize = CPK_packet.Length,
Encrypted = isUtfEncrypted,
FileType = "CPK"
};
FileTable.Add(CPAK_entry);
ms = new MemoryStream(utf_packet);
utfr = new EndianReader(ms, false);
utf = new UTF(tools);
if (!utf.ReadUTF(utfr, encoding))
{
br.Close();
return(false);
}
utfr.Close();
ms.Close();
cpkdata = new Dictionary <string, object>();
try
{
for (int i = 0; i < utf.columns.Count; i++)
{
cpkdata.Add(utf.columns[i].name, utf.rows[0].rows[i].GetValue());
}
}
catch (Exception ex)
{
//MessageBox.Show(ex.ToString());
Console.WriteLine(ex.ToString());
}
TocOffset = (ulong)GetColumsData2(utf, 0, "TocOffset", 3);
long TocOffsetPos = GetColumnPostion(utf, 0, "TocOffset");
EtocOffset = (ulong)GetColumsData2(utf, 0, "EtocOffset", 3);
long ETocOffsetPos = GetColumnPostion(utf, 0, "EtocOffset");
ItocOffset = (ulong)GetColumsData2(utf, 0, "ItocOffset", 3);
long ITocOffsetPos = GetColumnPostion(utf, 0, "ItocOffset");
GtocOffset = (ulong)GetColumsData2(utf, 0, "GtocOffset", 3);
long GTocOffsetPos = GetColumnPostion(utf, 0, "GtocOffset");
ContentOffset = (ulong)GetColumsData2(utf, 0, "ContentOffset", 3);
long ContentOffsetPos = GetColumnPostion(utf, 0, "ContentOffset");
FileTable.Add(CreateFileEntry("CONTENT_OFFSET", ContentOffset, typeof(ulong), ContentOffsetPos, "CPK", "CONTENT", false));
Files = (uint)GetColumsData2(utf, 0, "Files", 2);
Align = (ushort)GetColumsData2(utf, 0, "Align", 1);
if (TocOffset != 0xFFFFFFFFFFFFFFFF)
{
FileEntry entry = CreateFileEntry("TOC_HDR", TocOffset, typeof(ulong), TocOffsetPos, "CPK", "HDR", false);
FileTable.Add(entry);
if (!ReadTOC(br, TocOffset, ContentOffset, encoding))
{
return(false);
}
}
if (EtocOffset != 0xFFFFFFFFFFFFFFFF)
{
FileEntry entry = CreateFileEntry("ETOC_HDR", EtocOffset, typeof(ulong), ETocOffsetPos, "CPK", "HDR", false);
FileTable.Add(entry);
if (!ReadETOC(br, EtocOffset))
{
return(false);
}
}
if (ItocOffset != 0xFFFFFFFFFFFFFFFF)
{
//FileEntry ITOC_entry = new FileEntry {
// FileName = "ITOC_HDR",
// FileOffset = ItocOffset, FileOffsetType = typeof(ulong), FileOffsetPos = ITocOffsetPos,
// TOCName = "CPK",
// FileType = "FILE", Encrypted = true,
//};
FileEntry entry = CreateFileEntry("ITOC_HDR", ItocOffset, typeof(ulong), ITocOffsetPos, "CPK", "HDR", false);
FileTable.Add(entry);
if (!ReadITOC(br, ItocOffset, ContentOffset, Align))
{
return(false);
}
}
if (GtocOffset != 0xFFFFFFFFFFFFFFFF)
{
FileEntry entry = CreateFileEntry("GTOC_HDR", GtocOffset, typeof(ulong), GTocOffsetPos, "CPK", "HDR", false);
FileTable.Add(entry);
if (!ReadGTOC(br, GtocOffset))
{
return(false);
}
}
br.Close();
// at this point, we should have all needed file info
//utf = null;
files = null;
return(true);
}
return(false);
}
public bool ReadTOC(EndianReader br, ulong TocOffset, ulong ContentOffset, Encoding encoding = null)
{
ulong fTocOffset = TocOffset;
ulong add_offset = 0;
if (fTocOffset > (ulong)0x800)
{
fTocOffset = (ulong)0x800;
}
if (ContentOffset < 0)
{
add_offset = fTocOffset;
}
else
{
if (TocOffset < 0)
{
add_offset = ContentOffset;
}
else
{
if (ContentOffset < fTocOffset)
{
add_offset = ContentOffset;
}
else
{
add_offset = fTocOffset;
}
}
}
br.BaseStream.Seek((long)TocOffset, SeekOrigin.Begin);
if (tools.ReadCString(br, 4) != "TOC ")
{
br.Close();
return(false);
}
ReadUTFData(br);
// Store unencrypted TOC
TOC_packet = utf_packet;
FileEntry toc_entry = FileTable.Where(x => x.FileName.ToString() == "TOC_HDR").Single();
toc_entry.Encrypted = isUtfEncrypted;
toc_entry.FileSize = TOC_packet.Length;
MemoryStream ms = new MemoryStream(utf_packet);
EndianReader utfr = new EndianReader(ms, false);
files = new UTF(tools);
if (!files.ReadUTF(utfr, encoding))
{
br.Close();
return(false);
}
utfr.Close();
ms.Close();
FileEntry temp;
for (int i = 0; i < files.num_rows; i++)
{
temp = new FileEntry();
temp.TOCName = "TOC";
temp.DirName = GetColumnData(files, i, "DirName");
temp.FileName = GetColumnData(files, i, "FileName");
temp.FileSize = GetColumnData(files, i, "FileSize");
temp.FileSizePos = GetColumnPostion(files, i, "FileSize");
temp.FileSizeType = GetColumnType(files, i, "FileSize");
temp.ExtractSize = GetColumnData(files, i, "ExtractSize");
temp.ExtractSizePos = GetColumnPostion(files, i, "ExtractSize");
temp.ExtractSizeType = GetColumnType(files, i, "ExtractSize");
temp.FileOffset = ((ulong)GetColumnData(files, i, "FileOffset") + (ulong)add_offset);
temp.FileOffsetPos = GetColumnPostion(files, i, "FileOffset");
temp.FileOffsetType = GetColumnType(files, i, "FileOffset");
temp.FileType = "FILE";
temp.Offset = add_offset;
temp.ID = GetColumnData(files, i, "ID");
temp.UserString = GetColumnData(files, i, "UserString");
FileTable.Add(temp);
}
files = null;
return(true);
}