public void DeleteEntry(int Index)
{
try
{
FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Read);
int tocIndex = findTOCIndex();
if (tocIndex == -1)
{
return;
}
MemoryStream m = DecompressEntry(tocIndex, fs);
fs.Close();
FileEntryStruct e = Files[Index];
string toc = Encoding.UTF8.GetString(m.ToArray(), 0, (int)m.Length);
string file = e.FileName + "\r\n";
toc = toc.Replace(file, "");
ReplaceEntry(Encoding.ASCII.GetBytes(toc), tocIndex);
List <FileEntryStruct> l = new List <FileEntryStruct>();
l.AddRange(Files);
l.RemoveAt(Index);
Files = l.ToArray();
Header.FileCount--;
ReBuild();
}
catch (Exception ex)
{
Debug.WriteLine("ERROR DELETING ENTRY FROM SFAR TOC\n" + ex.Message);
}
}
public void DeleteEntries(List <int> Index)
{
Index.Sort();
Index.Reverse();
FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Read);
int f = FindTOC();
if (f == -1)
{
return;
}
MemoryStream m = DecompressEntry(f, fs);
string toc = Encoding.UTF8.GetString(m.ToArray(), 0, (int)m.Length);
fs.Close();
for (int i = 0; i < Index.Count; i++)
{
FileEntryStruct e = Files[Index[i]];
string file = e.FileName + "\r\n";
toc = toc.Replace(file, "");
}
ReplaceEntry(Encoding.ASCII.GetBytes(toc), f);
List <FileEntryStruct> l = new List <FileEntryStruct>();
l.AddRange(Files);
for (int i = 0; i < Index.Count; i++)
{
l.RemoveAt(Index[i]);
Header.FileCount--;
}
Files = l.ToArray();
ReBuild();
}
public void Serialize(SerializingFile con)
{
if (con.isLoading)
{
Header = new HeaderStruct();
}
Header.Serialize(con);
con.Seek((int)Header.EntryOffset, SeekOrigin.Begin);
for (int i = 0; i < Header.FileCount; i++)
{
//Debug.WriteLine($"Serialize sfar file {i} at 0x{con.Memory.Position:X8}");
var feStruct = new FileEntryStruct();
feStruct.Serialize(con, Header);
Files.Add(feStruct);
//Debug.WriteLine($"Data offset for {i}: 0x{Files[i].DataOffset:X8} (0x{Files[i].RealDataOffset:X8}), header at 0x{pos:X8}");
}
//var ordered = Files.OrderBy(x => x.DataOffset).ToList();
//foreach (var f in ordered)
//{
// Debug.WriteLine($"0x{f.DataOffset:X8} (0x{f.RealDataOffset:X8}), header at {f.MyOffset:X8}");
//}
//var firstfile = Files.MinBy(x => x.RealDataOffset);
if (con.isLoading)
{
ReadFileNames();
}
}
public void DeleteEntry(int Index)
{
try
{
FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Read);
Debug.WriteLine("Searching TOC...");
int f = FindTOC();
if (f == -1)
{
return;
}
Debug.WriteLine("Found TOC, deleting line...");
MemoryStream m = DecompressEntry(f, fs);
fs.Close();
FileEntryStruct e = Files[Index];
string toc = Encoding.UTF8.GetString(m.ToArray(), 0, (int)m.Length);
string file = e.FileName + "\r\n";
toc = toc.Replace(file, "");
Debug.WriteLine("Replacing TOC...");
ReplaceEntry(Encoding.ASCII.GetBytes(toc), f);
Debug.WriteLine("Deleting Entry from Filelist...");
List <FileEntryStruct> l = new List <FileEntryStruct>();
l.AddRange(Files);
l.RemoveAt(Index);
Files.ReplaceAll(l);
Header.FileCount--;
Debug.WriteLine("Rebuilding...");
ReBuild();
Debug.WriteLine("Done.");
}
catch (Exception ex)
{
Debug.WriteLine("ERROR\n" + ex.Message);
}
}
public MemoryStream DecompressEntry(int Index)
{
MemoryStream result = new MemoryStream();
FileEntryStruct e = Files[Index];
uint count = 0;
byte[] inputBlock;
byte[] outputBlock = new byte[Header.MaxBlockSize];
long left = e.RealUncompressedSize;
FileStream fs = new FileStream(MyFileName, FileMode.Open, FileAccess.Read);
fs.Seek(e.BlockOffsets[0], SeekOrigin.Begin);
byte[] buff;
if (e.BlockSizeIndex == 0xFFFFFFFF)
{
buff = new byte[e.RealUncompressedSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
}
else
{
while (left > 0)
{
uint compressedBlockSize = (uint)e.BlockSizes[count];
if (compressedBlockSize == 0)
{
compressedBlockSize = Header.MaxBlockSize;
}
if (compressedBlockSize == Header.MaxBlockSize || compressedBlockSize == left)
{
buff = new byte[compressedBlockSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
left -= compressedBlockSize;
}
else
{
var uncompressedBlockSize = (uint)Math.Min(left, Header.MaxBlockSize);
if (compressedBlockSize < 5)
{
throw new Exception("compressed block size smaller than 5");
}
inputBlock = new byte[compressedBlockSize];
fs.Read(inputBlock, 0, (int)compressedBlockSize);
uint actualUncompressedBlockSize = uncompressedBlockSize;
uint actualCompressedBlockSize = compressedBlockSize;
outputBlock = SevenZipHelper.Decompress(inputBlock, (int)actualUncompressedBlockSize);
if (outputBlock.Length != actualUncompressedBlockSize)
{
throw new Exception("Decompression Error");
}
result.Write(outputBlock, 0, (int)actualUncompressedBlockSize);
left -= uncompressedBlockSize;
}
count++;
}
}
fs.Close();
return(result);
}
public void ReplaceEntry(byte[] FileIN, int Index)
{
string DLCPath = MyFileName;
FileStream fs = new FileStream(DLCPath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
fs.Seek(0, SeekOrigin.End);
uint offset = (uint)fs.Length;
fs.Write(FileIN, 0, FileIN.Length);
FileEntryStruct e = Files[Index];
e.BlockSizes = new ushort[0];
e.BlockOffsets = new long[1];
e.BlockOffsets[0] = offset;
e.BlockSizeIndex = 0xFFFFFFFF;
e.DataOffset = offset;
e.UncompressedSize = (uint)FileIN.Length;
fs.Seek(e.MyOffset, 0);
fs.Write(e.Hash, 0, 16);
fs.Write(BitConverter.GetBytes(0xFFFFFFFF), 0, 4);
fs.Write(BitConverter.GetBytes(FileIN.Length), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(offset), 0, 4);
fs.WriteByte(0);
Files[Index] = e;
fs.Close();
}
public List <byte[]> GetBlocks(int Index)
{
List <byte[]> res = new List <byte[]>();
FileEntryStruct e = Files[Index];
uint count = 0;
byte[] inputBlock;
byte[] outputBlock = new byte[Header.MaxBlockSize];
long left = e.RealUncompressedSize;
FileStream fs = new FileStream(MyFileName, FileMode.Open, FileAccess.Read);
fs.Seek(e.BlockOffsets[0], SeekOrigin.Begin);
byte[] buff;
if (e.BlockSizeIndex == 0xFFFFFFFF)
{
buff = new byte[e.RealUncompressedSize];
fs.Read(buff, 0, buff.Length);
res.Add(buff);
fs.Close();
return(res);
}
else
{
while (left > 0)
{
uint compressedBlockSize = (uint)e.BlockSizes[count];
if (compressedBlockSize == 0)
{
compressedBlockSize = Header.MaxBlockSize;
}
if (compressedBlockSize == Header.MaxBlockSize || compressedBlockSize == left)
{
buff = new byte[compressedBlockSize];
fs.Read(buff, 0, buff.Length);
res.Add(buff);
left -= compressedBlockSize;
}
else
{
var uncompressedBlockSize = (uint)Math.Min(left, Header.MaxBlockSize);
if (compressedBlockSize < 5)
{
DebugLog.PrintLn("DLCPACKAGE::GETBLOCKS ERROR: compressed block size smaller than 5");
break;
}
inputBlock = new byte[compressedBlockSize];
fs.Read(inputBlock, 0, (int)compressedBlockSize);
res.Add(inputBlock);
left -= uncompressedBlockSize;
}
count++;
}
}
fs.Close();
return(res);
}
public void DeleteEntry(List <int> Index)
{
try
{
Index.Sort();
Index.Reverse();
FileStream fs = new FileStream(MyFileName, FileMode.Open, FileAccess.Read);
//DebugLog.PrintLn("Searching TOC...");
int f = FindTOC();
if (f == -1)
{
return;
}
//DebugLog.PrintLn("Found TOC, deleting lines...");
MemoryStream m = DecompressEntry(f, fs);
string toc = Encoding.UTF8.GetString(m.ToArray(), 0, (int)m.Length);
fs.Close();
for (int i = 0; i < Index.Count; i++)
{
FileEntryStruct e = Files[Index[i]];
string file = e.FileName + "\r\n";
toc = toc.Replace(file, "");
}
//DebugLog.PrintLn("Replacing TOC...");
ReplaceEntry(Encoding.ASCII.GetBytes(toc), f);
//DebugLog.PrintLn("Deleting Entry from Filelist...");
List <FileEntryStruct> l = new List <FileEntryStruct>();
l.AddRange(Files);
for (int i = 0; i < Index.Count; i++)
{
l.RemoveAt(Index[i]);
Header.FileCount--;
}
Files = l.ToArray();
//DebugLog.PrintLn("Rebuilding...");
ReBuild();
//DebugLog.PrintLn("Done.");
}
catch (Exception ex)
{
//DebugLog.PrintLn("ERROR\n" + ex.Message);
}
}
/// <summary>
/// Appends a file to the index and accompanying data file.
/// </summary>
/// <param name="directory">The directory that will be stored in the index.</param>
/// <param name="fileName">The filename that will be stored in the index.</param>
/// <param name="bytesToWrite">Byte array of the file to add.</param>
/// <param name="fileTime">File time to set to the file.</param>
/// <returns>Returns true if the operation was successful.</returns>
public override bool AddFile(String directory, String fileName, byte[] bytesToWrite, DateTime?fileTime = null)
{
if (bytesToWrite == null || bytesToWrite.Length == 0)
{
throw new ArgumentNullException("bytesToWrite", "Bytes to write cannot be empty!");
}
bool doCompress = NoCompressionExt.All(extentsion => !fileName.EndsWith(extentsion));
if (fileTime == null)
{
fileTime = DateTime.Now;
}
FileEntryStruct fileStruct = new FileEntryStruct
{
StartToken = Token.Info,
SizeUncompressed = bytesToWrite.Length,
SizeCompressed = doCompress ? 1 : 0,
FileTime = fileTime.Value.ToFileTime(),
NameHash = Crypt.GetStringSHA1UInt32(fileName),
DirectoryHash = Crypt.GetStringSHA1UInt32(directory),
First4BytesOfFile = FileTools.ByteArrayToInt32(bytesToWrite, 0),
Second4BytesOfFile = FileTools.ByteArrayToInt32(bytesToWrite, 4),
EndToken = Token.Info,
};
PackFileEntry fileEntry = new FileEntry(fileStruct);
fileEntry.Directory = directory;
fileEntry.Name = fileName;
Files.Add(fileEntry);
_AddFileToDat(bytesToWrite, fileEntry);
// todo: create new applicable file entry object as well?
// todo: remove existing file bytes if applicable...
return(true);
}
public void ReplaceEntry(byte[] newData, int entryIndex)
{
FileStream fs = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
FileEntryStruct e = Files[entryIndex];
if (e.BlockSizeTableIndex == 0xFFFFFFFF && e.RealUncompressedSize == newData.Length)
{
//overwrite existing data, but only if already uncompressed!
fs.Seek(e.RealDataOffset, SeekOrigin.Begin);
}
else
{
// It won't fit. Append it to the end instead
fs.Seek(0, SeekOrigin.End);
}
uint offset = (uint)fs.Position;
//append data
fs.Write(newData, 0, newData.Length);
//uncompressed entry
e.BlockSizes = new ushort[0];
e.BlockOffsets = new long[1];
e.BlockOffsets[0] = offset;
e.BlockSizeTableIndex = 0xFFFFFFFF;
e.DataOffset = offset;
e.UncompressedSize = (uint)newData.Length;
fs.Seek(e.MyOffset, 0);
fs.Write(e.Hash, 0, 16);
fs.Write(BitConverter.GetBytes(0xFFFFFFFF), 0, 4);
fs.Write(BitConverter.GetBytes(newData.Length), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(offset), 0, 4);
fs.WriteByte(0);
Files[entryIndex] = e;
fs.Close();
}
/// <summary>
/// Appends a file to the index and accompanying data file.
/// </summary>
/// <param name="directory">The directory that will be stored in the index.</param>
/// <param name="fileName">The filename that will be stored in the index.</param>
/// <param name="bytesToWrite">Byte array of the file to add.</param>
/// <param name="fileTime">File time to set to the file.</param>
/// <returns>Returns true if the operation was successful.</returns>
public override bool AddFile(String directory, String fileName, byte[] bytesToWrite, DateTime ?fileTime = null)
{
if (bytesToWrite == null || bytesToWrite.Length == 0) throw new ArgumentNullException("bytesToWrite", "Bytes to write cannot be empty!");
bool doCompress = NoCompressionExt.All(extentsion => !fileName.EndsWith(extentsion));
if (fileTime == null) fileTime = DateTime.Now;
FileEntryStruct fileStruct = new FileEntryStruct
{
StartToken = Token.Info,
SizeUncompressed = bytesToWrite.Length,
SizeCompressed = doCompress ? 1 : 0,
FileTime = fileTime.Value.ToFileTime(),
NameHash = Crypt.GetStringSHA1UInt32(fileName),
DirectoryHash = Crypt.GetStringSHA1UInt32(directory),
First4BytesOfFile = FileTools.ByteArrayToInt32(bytesToWrite, 0),
Second4BytesOfFile = FileTools.ByteArrayToInt32(bytesToWrite, 4),
EndToken = Token.Info,
};
PackFileEntry fileEntry = new FileEntry(fileStruct);
fileEntry.Directory = directory;
fileEntry.Name = fileName;
Files.Add(fileEntry);
_AddFileToDat(bytesToWrite, fileEntry);
// todo: create new applicable file entry object as well?
// todo: remove existing file bytes if applicable...
return true;
}
public void AddFileQuick(string filein, string path)
{
BitConverter.IsLittleEndian = true;
string DLCPath = MyFileName;
FileStream fs = new FileStream(DLCPath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
byte[] FileIN = File.ReadAllBytes(filein);
//Create Entry
List<FileEntryStruct> tmp = new List<FileEntryStruct>(Files);
FileEntryStruct e = new FileEntryStruct();
e.FileName = path;
e.BlockOffsets = new long[0];
e.Hash = ComputeHash(path);
e.BlockSizeIndex = 0xFFFFFFFF;
e.UncompressedSize = (uint)FileIN.Length;
e.UncompressedSizeAdder = 0;
tmp.Add(e);
e = new FileEntryStruct();
Files = tmp.ToArray();
//
//Find TOC
DebugOutput.PrintLn("Searching TOC...");
int f = FindTOC();
if (f == -1)
return;
DebugOutput.PrintLn("Found TOC, adding line...");
MemoryStream m = DecompressEntry(f, fs);
//
//Update TOC
WriteString(m, path);
m.WriteByte(0xD);
m.WriteByte(0xA);
//
//Append new FileTable
int count = (int)Header.FileCount +1;
long oldsize = fs.Length;
long offset = oldsize;
DebugOutput.PrintLn("File End Offset : 0x" + offset.ToString("X10"));
fs.Seek(oldsize, 0);
Header.EntryOffset = (uint)offset;
for (int i = 0; i < count; i++)
{
e = Files[i];
fs.Write(e.Hash, 0, 16);
fs.Write(BitConverter.GetBytes(e.BlockSizeIndex), 0, 4);
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
fs.WriteByte(e.DataOffsetAdder);
}
offset += count * 0x1E;
DebugOutput.PrintLn("Table End Offset : 0x" + offset.ToString("X10"));
Header.BlockTableOffset = (uint)offset;
//
//Append blocktable
for (int i = 0; i < count; i++)
{
e = Files[i];
if (e.BlockSizeIndex != 0xFFFFFFFF && i != f)
foreach(ushort u in e.BlockSizes)
fs.Write(BitConverter.GetBytes(u), 0, 2);
}
offset = fs.Length;
DebugOutput.PrintLn("Block Table End Offset : 0x" + offset.ToString("X10"));
long dataoffset = offset;
fs.Write(FileIN, 0, FileIN.Length);
offset += FileIN.Length;
DebugOutput.PrintLn("New Data End Offset : 0x" + offset.ToString("X10"));
//
//Append TOC
long tocoffset = offset;
fs.Write(m.ToArray(), 0, (int)m.Length);
offset = fs.Length;
DebugOutput.PrintLn("New TOC Data End Offset : 0x" + offset.ToString("X10"));
//update filetable
fs.Seek(oldsize, 0);
uint blocksizeindex = 0;
for (int i = 0; i < count; i++)
{
e = Files[i];
fs.Write(e.Hash, 0, 16);
if (e.BlockSizeIndex == 0xFFFFFFFF || i==f)
fs.Write(BitConverter.GetBytes((int)-1), 0, 4);
else
{
fs.Write(BitConverter.GetBytes(blocksizeindex), 0, 4);
e.BlockSizeIndex = (uint)blocksizeindex;
blocksizeindex += (uint)e.BlockSizes.Length;
Files[i] = e;
}
if (i == f)
{
fs.Write(BitConverter.GetBytes(m.Length), 0, 4);
fs.WriteByte(0);
fs.Write(BitConverter.GetBytes(tocoffset), 0, 4);
byte b = (byte)((tocoffset & 0xFF00000000) >> 32);
fs.WriteByte(b);
}
else if (i == count - 1)
{
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(0);
fs.Write(BitConverter.GetBytes(dataoffset), 0, 4);
byte b = (byte)((dataoffset & 0xFF00000000) >> 32);
fs.WriteByte(b);
}
else
{
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
fs.WriteByte(e.DataOffsetAdder);
}
}
//Update Header
fs.Seek(0xC, 0);
fs.Write(BitConverter.GetBytes(Header.EntryOffset), 0, 4);
fs.Write(BitConverter.GetBytes(count), 0, 4);
fs.Write(BitConverter.GetBytes(Header.BlockTableOffset), 0, 4);
//
fs.Close();
}
public void AddFileQuick(string filein, string path)
{
string DLCPath = FileName;
FileStream fs = new FileStream(DLCPath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
byte[] FileIN = File.ReadAllBytes(filein);
//Create Entry
List <FileEntryStruct> tmp = new List <FileEntryStruct>(Files);
FileEntryStruct e = new FileEntryStruct();
e.FileName = path;
e.BlockOffsets = new long[0];
e.Hash = ComputeHash(path);
e.BlockSizeTableIndex = 0xFFFFFFFF;
e.UncompressedSize = (uint)FileIN.Length;
e.UncompressedSizeAdder = 0;
tmp.Add(e);
e = new FileEntryStruct();
Files.ReplaceAll(tmp);
//
//Find TOC
Debug.WriteLine("Searching TOC...");
int f = FindTOC();
if (f == -1)
{
return;
}
Debug.WriteLine("Found TOC, adding line...");
MemoryStream m = DecompressEntry(f, fs);
//
//Update TOC
WriteString(m, path);
m.WriteByte(0xD);
m.WriteByte(0xA);
//
//Append new FileTable
int count = (int)Header.FileCount + 1;
long oldsize = fs.Length;
long offset = oldsize;
Debug.WriteLine("File End Offset : 0x" + offset.ToString("X10"));
fs.Seek(oldsize, 0);
Header.EntryOffset = (uint)offset;
for (int i = 0; i < count; i++)
{
e = Files[i];
fs.Write(e.Hash, 0, 16);
fs.Write(BitConverter.GetBytes(e.BlockSizeTableIndex), 0, 4);
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
fs.WriteByte(e.DataOffsetAdder);
}
offset += count * 0x1E;
Debug.WriteLine("Table End Offset : 0x" + offset.ToString("X10"));
Header.BlockTableOffset = (uint)offset;
//
//Append blocktable
for (int i = 0; i < count; i++)
{
e = Files[i];
if (e.BlockSizeTableIndex != 0xFFFFFFFF && i != f)
{
foreach (ushort u in e.BlockSizes)
{
fs.Write(BitConverter.GetBytes(u), 0, 2);
}
}
}
offset = fs.Length;
Debug.WriteLine("Block Table End Offset : 0x" + offset.ToString("X10"));
long dataoffset = offset;
fs.Write(FileIN, 0, FileIN.Length);
offset += FileIN.Length;
Debug.WriteLine("New Data End Offset : 0x" + offset.ToString("X10"));
//
//Append TOC
long tocoffset = offset;
fs.Write(m.ToArray(), 0, (int)m.Length);
offset = fs.Length;
Debug.WriteLine("New TOC Data End Offset : 0x" + offset.ToString("X10"));
//update filetable
fs.Seek(oldsize, 0);
uint blocksizeindex = 0;
for (int i = 0; i < count; i++)
{
e = Files[i];
fs.Write(e.Hash, 0, 16);
if (e.BlockSizeTableIndex == 0xFFFFFFFF || i == f)
{
fs.Write(BitConverter.GetBytes(-1), 0, 4);
}
else
{
fs.Write(BitConverter.GetBytes(blocksizeindex), 0, 4);
e.BlockSizeTableIndex = blocksizeindex;
blocksizeindex += (uint)e.BlockSizes.Length;
Files[i] = e;
}
if (i == f)
{
fs.Write(BitConverter.GetBytes(m.Length), 0, 4);
fs.WriteByte(0);
fs.Write(BitConverter.GetBytes(tocoffset), 0, 4);
byte b = (byte)((tocoffset & 0xFF00000000) >> 32);
fs.WriteByte(b);
}
else if (i == count - 1)
{
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(0);
fs.Write(BitConverter.GetBytes(dataoffset), 0, 4);
byte b = (byte)((dataoffset & 0xFF00000000) >> 32);
fs.WriteByte(b);
}
else
{
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
fs.WriteByte(e.DataOffsetAdder);
}
}
//Update Header
fs.Seek(0xC, 0);
fs.Write(BitConverter.GetBytes(Header.EntryOffset), 0, 4);
fs.Write(BitConverter.GetBytes(count), 0, 4);
fs.Write(BitConverter.GetBytes(Header.BlockTableOffset), 0, 4);
//
fs.Close();
}
public MemoryStream DecompressEntry(FileEntryStruct e)
{
//Debug.WriteLine("Decompressing " + e.FileName);
MemoryStream result = new MemoryStream();
uint count = 0;
byte[] inputBlock;
long left = e.RealUncompressedSize;
FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Read);
fs.Seek(e.BlockOffsets[0], SeekOrigin.Begin);
byte[] buff;
if (e.BlockSizeTableIndex == 0xFFFFFFFF)
{
buff = new byte[e.RealUncompressedSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
}
else
{
while (left > 0)
{
uint compressedBlockSize = e.BlockSizes[count];
if (compressedBlockSize == 0)
{
compressedBlockSize = Header.MaxBlockSize;
}
if (compressedBlockSize == Header.MaxBlockSize || compressedBlockSize == left)
{
//uncompressed?
buff = new byte[compressedBlockSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
left -= compressedBlockSize;
}
else
{
var uncompressedBlockSize = (uint)Math.Min(left, Header.MaxBlockSize);
if (compressedBlockSize < 5)
{
throw new Exception("compressed block size smaller than 5");
}
inputBlock = new byte[compressedBlockSize];
//Debug.WriteLine($"Decompressing at 0x{fs.Position:X8}");
fs.Read(inputBlock, 0, (int)compressedBlockSize);
uint actualUncompressedBlockSize = uncompressedBlockSize;
if (Header.CompressionScheme == "amzl" /* PC */ || Header.CompressionScheme == "lzma" /* PS3 (it doesn't appear to actually be LZMA!), WiiU */)
{
//if (Header.CompressionScheme == "lzma")
//{
//PS3 - This doesn't work. I'm not sure what kind of LZMA this uses but it has seemingly no header
//var attachedHeader = new byte[inputBlock.Length + 5];
//attachedHeader[0] = 0x5D;
////attachedHeader[1] = (byte) (Header.Version >> 24);
////attachedHeader[2] = (byte)(Header.Version >> 16);
////attachedHeader[3] = (byte)(Header.Version >> 8);
////attachedHeader[4] = (byte) Header.Version;
//attachedHeader[1] = (byte)Header.Version;
//attachedHeader[2] = (byte)(Header.Version >> 8);
//attachedHeader[3] = (byte)(Header.Version >> 16);
//attachedHeader[4] = (byte)(Header.Version >> 24);
//Buffer.BlockCopy(inputBlock,0,attachedHeader,5, inputBlock.Length);
//inputBlock = attachedHeader;
//}
var outputBlock = LZMA.Decompress(inputBlock, actualUncompressedBlockSize);
if (outputBlock.Length != actualUncompressedBlockSize)
{
throw new Exception("SFAR LZMA Decompression Error");
}
result.Write(outputBlock, 0, (int)actualUncompressedBlockSize);
left -= uncompressedBlockSize;
//continue;
}
if (Header.CompressionScheme == "lzx") //Xbox
{
var outputBlock = new byte[actualUncompressedBlockSize];
var decompResult = LZX.Decompress(inputBlock, (uint)inputBlock.Length, outputBlock);
if (decompResult != 0)
{
throw new Exception("SFAR LZX Decompression Error");
}
result.Write(outputBlock, 0, (int)actualUncompressedBlockSize);
left -= uncompressedBlockSize;
}
}
count++;
}
}
fs.Close();
result.Position = 0;
return(result);
}
public void ReBuild()
{
string path = Path.Combine(Path.GetDirectoryName(FileName), Path.GetFileNameWithoutExtension(FileName) + ".tmp");
FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write);
Debug.WriteLine("Creating Header Dummy...");
for (int i = 0; i < 8; i++)
{
fs.Write(BitConverter.GetBytes(0), 0, 4);
}
Header.EntryOffset = 0x20;
Debug.WriteLine("Creating File Table...");
for (int i = 0; i < Header.FileCount; i++)
{
FileEntryStruct e = Files[i];
fs.Write(e.Hash, 0, 16);
fs.Write(BitConverter.GetBytes(e.BlockSizeTableIndex), 0, 4);
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
fs.WriteByte(e.DataOffsetAdder);
}
Header.BlockTableOffset = (uint)fs.Position;
Debug.WriteLine("Creating Block Table...");
for (int i = 0; i < Header.FileCount; i++)
{
if (Files[i].BlockSizeTableIndex != 0xFFFFFFFF)
{
foreach (ushort u in Files[i].BlockSizes)
{
fs.Write(BitConverter.GetBytes(u), 0, 2);
}
}
}
Header.DataOffset = (uint)fs.Position;
Debug.WriteLine("Appending Files...");
uint pos = (uint)fs.Position;
for (int i = 0; i < Header.FileCount; i++)
{
List <byte[]> blocks = GetBlocks(i);
FileEntryStruct e = Files[i];
Debug.WriteLine("Rebuilding \"" + e.FileName + "\" (" + (i + 1) + "/" + Header.FileCount + ") " + BytesToString(e.UncompressedSize) + " ...");
e.DataOffset = pos;
e.DataOffsetAdder = 0;
for (int j = 0; j < blocks.Count; j++)
{
MemoryStream m = new MemoryStream(blocks[j]);
fs.Write(m.ToArray(), 0, (int)m.Length);
pos += (uint)m.Length;
}
Files[i] = e;
}
Debug.WriteLine("Updating FileTable...");
fs.Seek(0x20, 0);
pos = (uint)fs.Position;
uint blocksizeindex = 0;
for (int i = 0; i < Header.FileCount; i++)
{
FileEntryStruct e = Files[i];
fs.Write(e.Hash, 0, 16);
if (e.BlockSizeTableIndex != 0xFFFFFFFF)
{
fs.Write(BitConverter.GetBytes(blocksizeindex), 0, 4);
e.BlockSizeTableIndex = blocksizeindex;
blocksizeindex += (uint)e.BlockSizes.Length;
}
else
{
fs.Write(BitConverter.GetBytes(0xFFFFFFFF), 0, 4);
}
fs.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
fs.WriteByte(e.UncompressedSizeAdder);
fs.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
fs.WriteByte(e.DataOffsetAdder);
e.MyOffset = pos;
Files[i] = e;
pos += 0x1E;
}
fs.Seek(0, 0);
Debug.WriteLine("Rebuilding Header...");
//magic
fs.Write(BitConverter.GetBytes(0x53464152), 0, 4);
fs.Write(BitConverter.GetBytes(Header.Version), 0, 4);
fs.Write(BitConverter.GetBytes(Header.DataOffset), 0, 4);
fs.Write(BitConverter.GetBytes(Header.EntryOffset), 0, 4);
fs.Write(BitConverter.GetBytes(Header.FileCount), 0, 4);
fs.Write(BitConverter.GetBytes(Header.BlockTableOffset), 0, 4);
fs.Write(BitConverter.GetBytes(Header.MaxBlockSize), 0, 4);
foreach (char c in Header.CompressionScheme)
{
fs.WriteByte((byte)c);
}
fs.Close();
File.Delete(FileName);
File.Move(path, FileName);
}
public MemoryStream DecompressEntry(int index, FileStream fs)
{
FileEntryStruct e = Files[index];
//MemoryStream result = new MemoryStream((int)e.RealUncompressedSize);
MemoryStream result = MixinHandler.MixinMemoryStreamManager.GetStream();
uint count = 0;
byte[] inputBlock;
byte[] outputBlock = new byte[Header.MaxBlockSize];
long left = e.RealUncompressedSize;
fs.Seek(e.BlockOffsets[0], SeekOrigin.Begin);
byte[] buff;
if (e.BlockSizeIndex == 0xFFFFFFFF)
{
buff = new byte[e.RealUncompressedSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
}
else
{
//Compressed
while (left > 0)
{
uint compressedBlockSize = e.BlockSizes[count];
if (compressedBlockSize == 0)
{
compressedBlockSize = Header.MaxBlockSize;
}
if (compressedBlockSize == Header.MaxBlockSize || compressedBlockSize == left)
{
buff = new byte[compressedBlockSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
left -= compressedBlockSize;
}
else
{
var uncompressedBlockSize = (uint)Math.Min(left, Header.MaxBlockSize);
if (compressedBlockSize < 5)
{
throw new Exception("compressed block size smaller than 5");
}
inputBlock = new byte[compressedBlockSize];
fs.Read(inputBlock, 0, (int)compressedBlockSize);
uint actualUncompressedBlockSize = uncompressedBlockSize;
uint actualCompressedBlockSize = compressedBlockSize;
outputBlock = SevenZipHelper.LZMA.Decompress(inputBlock, actualUncompressedBlockSize);
if (outputBlock.Length != actualUncompressedBlockSize)
{
throw new Exception("Decompression Error");
}
result.Write(outputBlock, 0, (int)actualUncompressedBlockSize);
left -= uncompressedBlockSize;
}
count++;
}
}
return(result);
}
public FileEntry(FileEntryStruct fileEntryStruct)
{
_fileEntryStruct = fileEntryStruct;
}
public MemoryStream DecompressEntry(int Index, FileStream fs)
{
MemoryStream result = new MemoryStream();
FileEntryStruct e = Files[Index];
uint count = 0;
byte[] inputBlock;
byte[] outputBlock = new byte[Header.MaxBlockSize];
long left = e.RealUncompressedSize;
fs.Seek(e.BlockOffsets[0], SeekOrigin.Begin);
byte[] buff;
if (e.BlockSizeIndex == 0xFFFFFFFF)
{
buff = new byte[e.RealUncompressedSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
}
else
{
while (left > 0)
{
uint compressedBlockSize = (uint)e.BlockSizes[count];
if (compressedBlockSize == 0)
{
compressedBlockSize = Header.MaxBlockSize;
}
if (compressedBlockSize == Header.MaxBlockSize || compressedBlockSize == left)
{
buff = new byte[compressedBlockSize];
fs.Read(buff, 0, buff.Length);
result.Write(buff, 0, buff.Length);
left -= compressedBlockSize;
}
else
{
var uncompressedBlockSize = (uint)Math.Min(left, Header.MaxBlockSize);
if (compressedBlockSize < 5)
{
DebugLog.PrintLn("DLCPACKAGE::DECOMPRESSENTRY ERROR:compressed block size smaller than 5");
break;
}
inputBlock = new byte[compressedBlockSize];
fs.Read(inputBlock, 0, (int)compressedBlockSize);
uint actualUncompressedBlockSize = uncompressedBlockSize;
uint actualCompressedBlockSize = compressedBlockSize;
outputBlock = SevenZipHelper.Decompress(inputBlock, (int)actualUncompressedBlockSize);
if (outputBlock.Length != actualUncompressedBlockSize)
{
DebugLog.PrintLn("DLCPACKAGE::DECOMPRESSENTRY ERROR:Decompression Error");
break;
}
result.Write(outputBlock, 0, (int)actualUncompressedBlockSize);
left -= uncompressedBlockSize;
}
count++;
}
}
fs.Close();
return(result);
}
public void AddFileQuick(string onDiskNewFile, string inArchivePath)
{
byte[] newFileBytes;
if (Path.GetExtension(onDiskNewFile).ToLower() == @".pcc" && FileName.EndsWith(@"Patch_001.sfar", StringComparison.InvariantCultureIgnoreCase))
{
//Use the decompressed bytes - SFARs can't store compressed packages apparently!
var package = MEPackageHandler.OpenMEPackage(onDiskNewFile);
newFileBytes = package.saveToStream().ToArray();
}
else
{
newFileBytes = File.ReadAllBytes(onDiskNewFile);
}
FileStream sfarStream = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
//Create Entry
List <FileEntryStruct> tmp = new List <FileEntryStruct>(Files);
FileEntryStruct e = new FileEntryStruct();
e.FileName = inArchivePath;
e.BlockOffsets = new long[0];
e.Hash = ComputeHash(inArchivePath);
e.BlockSizeIndex = 0xFFFFFFFF;
e.UncompressedSize = (uint)newFileBytes.Length;
e.UncompressedSizeAdder = 0;
tmp.Add(e);
Files = tmp.ToArray();
//
//Find TOC
int f = findTOCIndex();
if (f == -1)
{
return;
}
MemoryStream tocMemory = DecompressEntry(f, sfarStream);
//
//No idea what most of the rest of this stuff is so i probably shouldn't change it
//Update TOC
tocMemory.WriteStringASCII(inArchivePath);
tocMemory.WriteByte(0xD);
tocMemory.WriteByte(0xA);
//
//Append new FileTable
int count = (int)Header.FileCount + 1;
long oldsize = sfarStream.Length;
long offset = oldsize;
//Debug.WriteLine("File End Offset : 0x" + offset.ToString("X10"));
sfarStream.Seek(oldsize, 0);
Header.EntryOffset = (uint)offset;
for (int i = 0; i < count; i++)
{
e = Files[i];
sfarStream.Write(e.Hash, 0, 16);
sfarStream.Write(BitConverter.GetBytes(e.BlockSizeIndex), 0, 4);
sfarStream.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
sfarStream.WriteByte(e.UncompressedSizeAdder);
sfarStream.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
sfarStream.WriteByte(e.DataOffsetAdder);
}
offset += count * 0x1E;
//Debug.WriteLine("Table End Offset : 0x" + offset.ToString("X10"));
Header.BlockTableOffset = (uint)offset;
//
//Append blocktable
for (int i = 0; i < count; i++)
{
e = Files[i];
if (e.BlockSizeIndex != 0xFFFFFFFF && i != f)
{
foreach (ushort u in e.BlockSizes)
{
sfarStream.Write(BitConverter.GetBytes(u), 0, 2);
}
}
}
offset = sfarStream.Length;
//Debug.WriteLine("Block Table End Offset : 0x" + offset.ToString("X10"));
long dataoffset = offset;
sfarStream.Write(newFileBytes, 0, newFileBytes.Length);
offset += newFileBytes.Length;
//Debug.WriteLine("New Data End Offset : 0x" + offset.ToString("X10"));
//
//Append TOC
long tocoffset = offset;
sfarStream.Write(tocMemory.ToArray(), 0, (int)tocMemory.Length);
offset = sfarStream.Length;
//Debug.WriteLine("New TOC Data End Offset : 0x" + offset.ToString("X10"));
//update filetable
sfarStream.Seek(oldsize, 0);
uint blocksizeindex = 0;
for (int i = 0; i < count; i++)
{
e = Files[i];
sfarStream.Write(e.Hash, 0, 16);
if (e.BlockSizeIndex == 0xFFFFFFFF || i == f)
{
sfarStream.Write(BitConverter.GetBytes(-1), 0, 4);
}
else
{
sfarStream.Write(BitConverter.GetBytes(blocksizeindex), 0, 4);
e.BlockSizeIndex = blocksizeindex;
blocksizeindex += (uint)e.BlockSizes.Length;
Files[i] = e;
}
if (i == f)
{
sfarStream.Write(BitConverter.GetBytes(tocMemory.Length), 0, 4);
sfarStream.WriteByte(0);
sfarStream.Write(BitConverter.GetBytes(tocoffset), 0, 4);
byte b = (byte)((tocoffset & 0xFF00000000) >> 32);
sfarStream.WriteByte(b);
}
else if (i == count - 1)
{
sfarStream.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
sfarStream.WriteByte(0);
sfarStream.Write(BitConverter.GetBytes(dataoffset), 0, 4);
byte b = (byte)((dataoffset & 0xFF00000000) >> 32);
sfarStream.WriteByte(b);
}
else
{
sfarStream.Write(BitConverter.GetBytes(e.UncompressedSize), 0, 4);
sfarStream.WriteByte(e.UncompressedSizeAdder);
sfarStream.Write(BitConverter.GetBytes(e.DataOffset), 0, 4);
sfarStream.WriteByte(e.DataOffsetAdder);
}
}
//Update Header
sfarStream.Seek(0xC, 0);
sfarStream.Write(BitConverter.GetBytes(Header.EntryOffset), 0, 4);
sfarStream.Write(BitConverter.GetBytes(count), 0, 4);
sfarStream.Write(BitConverter.GetBytes(Header.BlockTableOffset), 0, 4);
//
sfarStream.Close();
}
public FileEntry(FileEntryStruct fileEntryStruct)
{
_fileEntryStruct = fileEntryStruct;
}
