internal static ZlibCompressionState InflateSetDictionary(ZStream z, byte[] dictionary, int dictLength)
{
var index = 0;
var length = dictLength;
if (z == null || z.Istate == null || z.Istate.Mode != DICT0)
{
return(ZlibCompressionState.ZSTREAMERROR);
}
if (Adler32.Calculate(1L, dictionary, 0, dictLength) != z.Adler)
{
return(ZlibCompressionState.ZDATAERROR);
}
z.Adler = Adler32.Calculate(0, null, 0, 0);
if (length >= (1 << z.Istate.Wbits))
{
length = (1 << z.Istate.Wbits) - 1;
index = dictLength - length;
}
z.Istate.Blocks.Set_dictionary(dictionary, index, length);
z.Istate.Mode = BLOCKS;
return(ZlibCompressionState.ZOK);
}
// Used for protobuf json strings.
public static byte[] Compress <T>(T data, string prefix)
{
var jsonData = Encoding.UTF8.GetBytes($"{prefix}:{CreateString(data)}\0");
var jsonDataLength = BitConverter.GetBytes(jsonData.Length);
var uncompressedAdler = BitConverter.GetBytes(Adler32.Calculate(jsonData)).Reverse().ToArray();
return(jsonDataLength.Combine(ZLib.Compress(jsonData), uncompressedAdler));
}
// Used for protobuf json strings.
public static byte[] Deflate <T>(string name, T data)
{
var jsonData = Encoding.UTF8.GetBytes(name + ":" + CreateString(data) + "\0");
var jsonDataLength = BitConverter.GetBytes(jsonData.Length);
var zlibHeader = new byte[] { 0x78, 0x9C };
var compressedData = Zlib.Deflate(jsonData);
var uncompressedAdler = BitConverter.GetBytes(Adler32.Calculate(jsonData)).Reverse().ToArray();
return(jsonDataLength.Concat(zlibHeader).Concat(compressedData).Concat(uncompressedAdler).ToArray());
}
public void MatchesReference(int length)
{
var data = GetBuffer(length);
var adler = new SharpAdler32();
adler.Update(data);
long expected = adler.Value;
long actual = Adler32.Calculate(data);
Assert.Equal(expected, actual);
}
// TODO (Dragon): see if theres a good way to minimize memory consumption
private static void CompressFirstGenCEXbox(string file, StructureValueCollection headerValues)
{
using (MemoryStream msOutput = new MemoryStream())
{
using (FileStream fsInput = new FileStream(file, FileMode.Open))
{
using (BinaryReader brInput = new BinaryReader(fsInput))
{
int headerSize = (int)headerValues.GetInteger("_header_length_");
//header is uncompressed
msOutput.Write(brInput.ReadBytes(headerSize), 0, headerSize);
int realsize = (int)fsInput.Length - headerSize;
byte[] chunkData = new byte[realsize];
fsInput.Seek(0x800, SeekOrigin.Begin);
fsInput.Read(chunkData, 0, realsize);
msOutput.WriteByte((byte)0x78);
msOutput.WriteByte((byte)0x9C);
using (DeflateStream ds = new DeflateStream(msOutput, CompressionMode.Compress, true))
{
realsize = fsInput.Read(chunkData, 0, chunkData.Length);
ds.Write(chunkData, 0, chunkData.Length);
}
// NOTE: actual zlib has an adler-32 checksum trailer on the end
uint adler = Adler32.Calculate(chunkData);
// write the bytes
msOutput.WriteByte((byte)((adler & 0xFF000000) >> 24));
msOutput.WriteByte((byte)((adler & 0xFF0000) >> 16));
msOutput.WriteByte((byte)((adler & 0xFF00) >> 8));
msOutput.WriteByte((byte)(adler & 0xFF));
// CE xbox has some padding on the end to a 0x800 alignment
int pad_size = 0x800 - ((int)msOutput.Length % 0x800);
byte[] padding = new byte[pad_size];
msOutput.Write(padding, 0, pad_size);
}
}
File.WriteAllBytes(file, msOutput.ToArray());
}
}
public long SixLaborsUpdate()
{
return(Adler32.Calculate(1, this.data));
}
public void ReturnsCorrectWhenEmpty(uint input)
{
Assert.Equal(input, Adler32.Calculate(input, default));
}
public uint SixLaborsCalculate()
{
return(Adler32.Calculate(this.data));
}