/// <summary>
/// Initializes a new instance of the <see cref="ZOutputStream"/> class.
/// </summary>
/// <param name="output">The output stream.</param>
/// <param name="level">The compression level for the data to compress.</param>
public ZOutputStream(Stream output, ZlibCompression level)
{
this.BaseStream = output;
this.InitBlock();
_ = this.Z.DeflateInit(level);
this.Compress = true;
}
public static List <Chunk> CompressIDATs(byte[] cipheredBytes)
{
byte[] compressedBytes = ZlibCompression.Compress(cipheredBytes);
List <Chunk> resultIdats = IDATConverter.SplitToIDATs(compressedBytes).Select(idat => (Chunk)idat).ToList();
return(resultIdats);
}
public static byte[] DecompressIDATs(List <Chunk> chunks)
{
List <IDAT> idats = chunks.Where(IsIDAT).Select(chunk => (IDAT)chunk).ToList();
byte[] bytes = IDATConverter.ConcatToBytes(idats);
byte[] decompressedBytes = ZlibCompression.Decompress(bytes);
return(decompressedBytes);
}
/// <summary>
/// Initializes a new instance of the <see cref="ZInputStream"/> class.
/// </summary>
/// <param name="input">The input stream.</param>
/// <param name="level">The compression level for the data to compress.</param>
public ZInputStream(Stream input, ZlibCompression level)
{
this.BaseStream = input;
this.InitBlock();
_ = this.Z.DeflateInit(level);
this.Compress = true;
this.Z.INextIn = this.pBuf;
this.Z.NextInIndex = 0;
this.Z.AvailIn = 0;
}
public CustomHousePlane(PacketReader reader)
{
byte[] data = reader.ReadBytes(4);
Index = data[0];
int uncompressedsize = data[1] + ((data[3] & 0xF0) << 4);
int compressedLength = data[2] + ((data[3] & 0xF) << 8);
ItemData = new byte[uncompressedsize];
ZlibCompression.Unpack(ItemData, ref uncompressedsize, reader.ReadBytes(compressedLength), compressedLength);
IsFloor = ((Index & 0x20) == 0x20);
Index &= 0x1F;
}
public CompressedGumpPacket(PacketReader reader)
: base(0xDD, "Compressed Gump")
{
GumpSerial = reader.ReadInt32();
GumpTypeID = reader.ReadInt32();
X = reader.ReadInt32();
Y = reader.ReadInt32();
int compressedLength = reader.ReadInt32() - 4;
int decompressedLength = reader.ReadInt32();
byte[] compressedData = reader.ReadBytes(compressedLength);
byte[] decompressedData = new byte[decompressedLength];
if (ZlibCompression.Unpack(decompressedData, ref decompressedLength, compressedData, compressedLength) != ZLibError.Okay)
{
// Problem decompressing, go ahead and quit.
return;
}
else
{
GumpData = Encoding.ASCII.GetString(decompressedData);
int numTextLines = reader.ReadInt32();
int compressedTextLength = reader.ReadInt32() - 4;
int decompressedTextLength = reader.ReadInt32();
byte[] decompressedText = new byte[decompressedTextLength];
if (numTextLines > 0 && decompressedTextLength > 0)
{
byte[] compressedTextData = reader.ReadBytes(compressedTextLength);
ZlibCompression.Unpack(decompressedText, ref decompressedTextLength, compressedTextData, compressedTextLength);
int index = 0;
List <string> lines = new List <string>();
for (int i = 0; i < numTextLines; i++)
{
int length = decompressedText[index] * 256 + decompressedText[index + 1];
index += 2;
byte[] b = new byte[length * 2];
Array.Copy(decompressedText, index, b, 0, length * 2);
index += length * 2;
lines.Add(Encoding.BigEndianUnicode.GetString(b));
}
TextLines = lines.ToArray();
}
else
{
TextLines = new string[0];
}
}
}
public void ShouldConcatDecompressCompressAndThenSplitImage()
{
string filePath = @"../../../Data/lena.png";
List <Chunk> chunks = PNGFile.Read(filePath);
List <Chunk> parsedChunks = ChunkParser.Parse(chunks);
int firstIdatIndex = parsedChunks.TakeWhile(chunk => !IsIDAT(chunk)).Count();
List <IDAT> idats = parsedChunks.Where(IsIDAT).Select(chunk => (IDAT)chunk).ToList();
byte[] bytes = IDATConverter.ConcatToBytes(idats);
byte[] decompressedBytes = ZlibCompression.Decompress(bytes);
byte[] compressedBytes = ZlibCompression.Compress(decompressedBytes);
List <Chunk> resultIdats = IDATConverter.SplitToIDATs(compressedBytes).Select(idat => (Chunk)idat).ToList();
List <Chunk> resultChunks = parsedChunks.Where(chunk => !IsIDAT(chunk)).ToList();
resultChunks.InsertRange(firstIdatIndex, resultIdats);
PNGFile.Write(@"../../../Data/lenaCompressed.png", resultChunks);
}
public CompiledMetafile(Metafile file)
{
Name = file.Name;
Source = file;
using (var metaFileStream = new MemoryStream())
{
using (var metaFileWriter = new BinaryWriter(metaFileStream, CodePagesEncodingProvider.Instance.GetEncoding(949), true))
{
metaFileWriter.Write((byte)(file.Nodes.Count / 256));
metaFileWriter.Write((byte)(file.Nodes.Count % 256));
foreach (var node in file.Nodes)
{
byte[] nodeBuffer = CodePagesEncodingProvider.Instance.GetEncoding(949).GetBytes(node.Text);
metaFileWriter.Write((byte)nodeBuffer.Length);
metaFileWriter.Write(nodeBuffer);
metaFileWriter.Write((byte)(node.Properties.Count / 256));
metaFileWriter.Write((byte)(node.Properties.Count % 256));
foreach (var property in node.Properties)
{
byte[] propertyBuffer = CodePagesEncodingProvider.Instance.GetEncoding(949).GetBytes(property);
metaFileWriter.Write((byte)(propertyBuffer.Length / 256));
metaFileWriter.Write((byte)(propertyBuffer.Length % 256));
metaFileWriter.Write(propertyBuffer);
}
}
}
Checksum = ~Crc32.Calculate(metaFileStream.ToArray());
metaFileStream.Seek(0, SeekOrigin.Begin);
using (var compressedMetaFileStream = new MemoryStream())
{
ZlibCompression.Compress(metaFileStream, compressedMetaFileStream);
Data = compressedMetaFileStream.ToArray();
}
}
}
/// <summary>
/// Compresses data using an specific compression level.
/// </summary>
/// <param name="inData">The original input data.</param>
/// <param name="outData">The compressed output data.</param>
/// <param name="level">The compression level to use.</param>
/// <param name="adler32">The output adler32 of the data.</param>
/// <exception cref="NotPackableException">
/// Thrown when the internal compression stream errors in any way.
/// </exception>
public static void Compress(byte[] inData, out byte[] outData, ZlibCompression level, out int adler32)
{
using (var outMemoryStream = new MemoryStream())
using (var outZStream = new ZOutputStream(outMemoryStream, level))
using (Stream inMemoryStream = new MemoryStream(inData))
{
try
{
inMemoryStream.CopyTo(outZStream);
}
catch (ZStreamException)
{
// the compression or decompression failed.
}
try
{
outZStream.Flush();
}
catch (StackOverflowException ex)
{
throw new NotPackableException("Compression Failed due to a stack overflow.", ex);
}
try
{
outZStream.Finish();
}
catch (ZStreamException ex)
{
throw new NotPackableException("Compression Failed.", ex);
}
outData = outMemoryStream.ToArray();
adler32 = (int)(outZStream.Z.Adler & 0xffff);
}
}
private static void CompressAndDecompress(byte[] bytes)
{
byte[] compressed = ZlibCompression.Compress(bytes);
byte[] decompressed = ZlibCompression.Decompress(compressed);
Assert.AreEqual(bytes, decompressed);
}
public static void CompressData(byte[] inData, out byte[] outData, ZlibCompression level, out int adler32) => Compress(inData, out outData, level, out adler32);
public static void CompressData(byte[] inData, out byte[] outData, ZlibCompression level) => Compress(inData, out outData, level);
/// <summary> /// Compresses a file using an specific compression level. /// </summary> /// <param name="path">The file to compress.</param> /// <param name="outData">The compressed output data.</param> /// <param name="level">The compression level to use.</param> /// <param name="adler32">The output adler32 of the data.</param> /// <exception cref="NotPackableException"> /// Thrown when the internal compression stream errors in any way. /// </exception> public static void Compress(string path, out byte[] outData, ZlibCompression level, out int adler32) => Compress(File.ReadAllBytes(path), out outData, level, out adler32);
/// <summary> /// Sets the compression paramiters. /// </summary> /// <param name="level">The compression level to use.</param> /// <param name="strategy">The strategy to use for compression.</param> /// <returns>The zlib status state.</returns> public ZlibCompressionState DeflateParams(ZlibCompression level, ZlibCompressionStrategy strategy) => this.Dstate == null ? ZlibCompressionState.ZSTREAMERROR : this.Dstate.DeflateParams(this, level, strategy);
/// <summary>
/// Initializes compression.
/// </summary>
/// <param name="level">The compression level to use.</param>
/// <param name="bits">The window bits to use.</param>
/// <returns>The zlib status state.</returns>
public ZlibCompressionState DeflateInit(ZlibCompression level, int bits)
{
this.Dstate = new Deflate();
return(this.Dstate.DeflateInit(this, level, bits));
}
/// <summary> /// Initializes compression. /// </summary> /// <param name="level">The compression level to use.</param> /// <returns>The zlib status state.</returns> public ZlibCompressionState DeflateInit(ZlibCompression level) => this.DeflateInit(level, MAXWBITS);
