public override void Write(System.Byte[] buffer, int offset, int length) { if (_streamMode == StreamMode.Undefined) { _streamMode = StreamMode.Writer; } if (_streamMode != StreamMode.Writer) { throw new ZlibException("Cannot Write after Reading."); } if (length == 0) { return; } _z.InputBuffer = buffer; _z.NextIn = offset; _z.AvailableBytesIn = length; do { _z.OutputBuffer = _workingBuffer; _z.NextOut = 0; _z.AvailableBytesOut = _workingBuffer.Length; int rc = (_wantCompress) ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode); if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END) { throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message); } _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut); }while (_z.AvailableBytesIn > 0 || _z.AvailableBytesOut == 0); }
private void finish() { if (_streamMode == StreamMode.Writer) { do { _z.OutputBuffer = _workingBuffer; _z.NextOut = 0; _z.AvailableBytesOut = _workingBuffer.Length; int rc = //(_wantCompress) //? _z.Deflate(ZlibConstants.Z_FINISH): _z.Inflate(ZlibConstants.Z_FINISH); if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK) { throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message); } if (_workingBuffer.Length - _z.AvailableBytesOut > 0) { _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut); } }while (_z.AvailableBytesIn > 0 || _z.AvailableBytesOut == 0); Flush(); } }
public override void Write(System.Byte[] buffer, int offset, int count) { #if !NETFX_CORE // workitem 7159 // calculate the CRC on the unccompressed data (before writing) if (crc != null) { crc.SlurpBlock(buffer, offset, count); } #endif if (_streamMode == StreamMode.Undefined) { _streamMode = StreamMode.Writer; } else if (_streamMode != StreamMode.Writer) { throw new ZlibException("Cannot Write after Reading."); } if (count == 0) { return; } // first reference of z property will initialize the private var _z z.InputBuffer = buffer; _z.NextIn = offset; _z.AvailableBytesIn = count; bool done = false; do { _z.OutputBuffer = workingBuffer; _z.NextOut = 0; _z.AvailableBytesOut = _workingBuffer.Length; int rc = (_wantCompress) ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode); if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END) { throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message); } //if (_workingBuffer.Length - _z.AvailableBytesOut > 0) _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut); done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0; // If GZIP and de-compress, we're done when 8 bytes remain. if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress) { done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0); } }while (!done); }
public override void Write(byte[] buffer, int offset, int count) { if (crc != null) { crc.SlurpBlock(buffer, offset, count); } if (_streamMode == StreamMode.Undefined) { _streamMode = StreamMode.Writer; } else if (_streamMode != 0) { throw new ZlibException("Cannot Write after Reading."); } if (count == 0) { return; } z.InputBuffer = buffer; _z.NextIn = offset; _z.AvailableBytesIn = count; bool flag = false; while (true) { _z.OutputBuffer = workingBuffer; _z.NextOut = 0; _z.AvailableBytesOut = _workingBuffer.Length; int num = _wantCompress ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode); if (num != 0 && num != 1) { break; } _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut); flag = (_z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0); if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress) { flag = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0); } if (flag) { return; } } throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message); }
public int Read(byte[] buffer, int offset, int count) { // According to MS documentation, any implementation of the IO.Stream.Read function must: // (a) throw an exception if offset & count reference an invalid part of the buffer, // or if count < 0, or if buffer is null // (b) return 0 only upon EOF, or if count = 0 // (c) if not EOF, then return at least 1 byte, up to <count> bytes if (count == 0) { return(0); } int rc = 0; // set up the output of the deflate/inflate codec: z.OutputBuffer = buffer; z.NextOut = offset; z.AvailableBytesOut = count; z.InputBuffer = workBuffer; bool endOfInput = false; do { // need data in _workingBuffer in order to deflate/inflate. Here, we check if we have any. if (z.AvailableBytesIn == 0 && !endOfInput) { // No data available, so try to Read data from the captive stream. z.NextIn = 0; z.AvailableBytesIn = _stream.Read(workBuffer, 0, workBuffer.Length); if (z.AvailableBytesIn == 0) { endOfInput = true; } } rc = z.Inflate(); if (endOfInput && rc == RCode.BufferError) { return(0); } if (rc != RCode.Okay && rc != RCode.StreamEnd) { throw new InvalidDataException("inflating: rc=" + rc); } if ((endOfInput || rc == RCode.StreamEnd) && z.AvailableBytesOut == count) { break; // nothing more to read } } while(z.AvailableBytesOut > 0 && !endOfInput && rc == RCode.Okay); return(count - z.AvailableBytesOut); }
public override void Write(byte[] buffer, int offset, int count) { if (_streamMode == StreamMode.Undefined) { _streamMode = StreamMode.Writer; } else if (_streamMode != StreamMode.Writer) { throw new ZlibException("Cannot Write after Reading."); } if (count == 0) { return; } // first reference of z property will initialize the private var _z z.InputBuffer = buffer; _z.NextIn = offset; _z.AvailableBytesIn = count; var done = false; do { _z.OutputBuffer = workingBuffer; _z.NextOut = 0; _z.AvailableBytesOut = _workingBuffer.Length; var rc = _wantCompress ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode); if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END) { throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message); } //if (_workingBuffer.Length - _z.AvailableBytesOut > 0) _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut); done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0; } while (!done); }
/// <summary> /// Decompress the specified inputData. /// </summary> /// <param name="inputData">Input data.</param> /// <returns>decompressed byte array</returns> public static byte[] Decompress(byte[] inputData) { var zlib = new ZlibCodec(Ionic.Zlib.CompressionMode.Decompress); zlib.InputBuffer = inputData; zlib.OutputBuffer = new byte[MAX_PACKET_SIZE]; zlib.NextIn = 0; zlib.AvailableBytesIn = inputData.Length; zlib.NextOut = 0; zlib.AvailableBytesOut = MAX_PACKET_SIZE; zlib.Inflate(FlushType.Finish); var output = new byte[zlib.TotalBytesOut]; Array.Copy(zlib.OutputBuffer, output, (int)zlib.TotalBytesOut); return output; }
public static byte[] ZLibDecompress(byte[] compressed, bool mode, int outputSize) { byte[] output = new Byte[outputSize]; bool expectRfc1950Header = mode; using (MemoryStream ms = new MemoryStream()) { ZlibCodec compressor = new ZlibCodec(); compressor.InitializeInflate(expectRfc1950Header); compressor.InputBuffer = compressed; compressor.AvailableBytesIn = compressed.Length; compressor.NextIn = 0; compressor.OutputBuffer = output; foreach (var f in new FlushType[] { FlushType.None, FlushType.Finish }) { int bytesToWrite = 0; do { compressor.AvailableBytesOut = outputSize; compressor.NextOut = 0; compressor.Inflate(f); bytesToWrite = outputSize - compressor.AvailableBytesOut; if (bytesToWrite > 0) ms.Write(output, 0, bytesToWrite); } while ((f == FlushType.None && (compressor.AvailableBytesIn != 0 || compressor.AvailableBytesOut == 0)) || (f == FlushType.Finish && bytesToWrite != 0)); } compressor.EndInflate(); return (ms.ToArray()); } }
int HandleDecompression(byte[] buffer, int count) { _decompressor.InputBuffer = buffer; _decompressor.NextOut = 0; _decompressor.NextIn = 0; _decompressor.AvailableBytesIn = count; while (true) { _decompressor.OutputBuffer = _compressionBuffer; _decompressor.AvailableBytesOut = _compressionBuffer.Length - _decompressor.NextOut; var rc = _decompressor.Inflate(Ionic.Zlib.FlushType.None); if (rc != Ionic.Zlib.ZlibConstants.Z_OK) { throw new IOException($"Error '{rc}' while decompressing the data."); } if (_decompressor.AvailableBytesIn > 0 || _decompressor.AvailableBytesOut == 0) { ResizeBuffer(ref _compressionBuffer); continue; } break; } return(_decompressor.NextOut); }
private string ZlibCodecDecompress(byte[] compressed) { int outputSize = 2048; byte[] output = new Byte[ outputSize ]; // If you have a ZLIB stream, set this to true. If you have // a bare DEFLATE stream, set this to false. bool expectRfc1950Header = false; using ( MemoryStream ms = new MemoryStream()) { ZlibCodec compressor = new ZlibCodec(); compressor.InitializeInflate(expectRfc1950Header); compressor.InputBuffer = compressed; compressor.AvailableBytesIn = compressed.Length; compressor.NextIn = 0; compressor.OutputBuffer = output; foreach (var f in new FlushType[] { FlushType.None, FlushType.Finish } ) { int bytesToWrite = 0; do { compressor.AvailableBytesOut = outputSize; compressor.NextOut = 0; compressor.Inflate(f); bytesToWrite = outputSize - compressor.AvailableBytesOut ; if (bytesToWrite > 0) ms.Write(output, 0, bytesToWrite); } while (( f == FlushType.None && (compressor.AvailableBytesIn != 0 || compressor.AvailableBytesOut == 0)) || ( f == FlushType.Finish && bytesToWrite != 0)); } compressor.EndInflate(); return UTF8Encoding.UTF8.GetString( ms.ToArray() ); } }
private byte[] InflateBuffer(byte[] b, int length) { int bufferSize = 1024; byte[] buffer = new byte[bufferSize]; ZlibCodec decompressor = new ZlibCodec(); byte[] DecompressedBytes = new byte[length]; TestContext.WriteLine("\n============================================"); TestContext.WriteLine("Size of Buffer to Inflate: {0} bytes.", b.Length); MemoryStream ms = new MemoryStream(DecompressedBytes); int rc = decompressor.InitializeInflate(); decompressor.InputBuffer = b; decompressor.NextIn = 0; decompressor.AvailableBytesIn = b.Length; decompressor.OutputBuffer = buffer; for (int pass = 0; pass < 2; pass++) { FlushType flush = (pass==0) ? FlushType.None : FlushType.Finish; do { decompressor.NextOut = 0; decompressor.AvailableBytesOut = buffer.Length; rc = decompressor.Inflate(flush); if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END) throw new Exception("inflating: " + decompressor.Message); if (buffer.Length - decompressor.AvailableBytesOut > 0) ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut); } while (decompressor.AvailableBytesIn > 0 || decompressor.AvailableBytesOut == 0); } decompressor.EndInflate(); TestContext.WriteLine("TBO({0}).", decompressor.TotalBytesOut); return DecompressedBytes; }
public void Zlib_Codec_TestLargeDeflateInflate() { int rc; int j; int bufferSize = 80000; byte[] compressedBytes = new byte[bufferSize]; byte[] workBuffer = new byte[bufferSize / 4]; ZlibCodec compressingStream = new ZlibCodec(); rc = compressingStream.InitializeDeflate(CompressionLevel.Level1); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressingStream.Message)); compressingStream.OutputBuffer = compressedBytes; compressingStream.AvailableBytesOut = compressedBytes.Length; compressingStream.NextOut = 0; System.Random rnd = new Random(); for (int k = 0; k < 4; k++) { switch (k) { case 0: // At this point, workBuffer is all zeroes, so it should compress very well. break; case 1: // switch to no compression, keep same workBuffer (all zeroes): compressingStream.SetDeflateParams(CompressionLevel.None, CompressionStrategy.Default); break; case 2: // Insert data into workBuffer, and switch back to compressing mode. // we'll use lengths of the same random byte: for (int i = 0; i < workBuffer.Length / 1000; i++) { byte b = (byte)rnd.Next(); int n = 500 + rnd.Next(500); for (j = 0; j < n; j++) workBuffer[j + i] = b; i += j - 1; } compressingStream.SetDeflateParams(CompressionLevel.BestCompression, CompressionStrategy.Filtered); break; case 3: // insert totally random data into the workBuffer rnd.NextBytes(workBuffer); break; } compressingStream.InputBuffer = workBuffer; compressingStream.NextIn = 0; compressingStream.AvailableBytesIn = workBuffer.Length; rc = compressingStream.Deflate(FlushType.None); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate({0}) [{1}]", k, compressingStream.Message)); if (k == 0) Assert.AreEqual<int>(0, compressingStream.AvailableBytesIn, "Deflate should be greedy."); TestContext.WriteLine("Stage {0}: uncompressed/compresssed bytes so far: ({1,6}/{2,6})", k, compressingStream.TotalBytesIn, compressingStream.TotalBytesOut); } rc = compressingStream.Deflate(FlushType.Finish); Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressingStream.Message)); rc = compressingStream.EndDeflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressingStream.Message)); TestContext.WriteLine("Final: uncompressed/compressed bytes: ({0,6},{1,6})", compressingStream.TotalBytesIn, compressingStream.TotalBytesOut); ZlibCodec decompressingStream = new ZlibCodec(CompressionMode.Decompress); decompressingStream.InputBuffer = compressedBytes; decompressingStream.NextIn = 0; decompressingStream.AvailableBytesIn = bufferSize; // upon inflating, we overwrite the decompressedBytes buffer repeatedly int nCycles = 0; while (true) { decompressingStream.OutputBuffer = workBuffer; decompressingStream.NextOut = 0; decompressingStream.AvailableBytesOut = workBuffer.Length; rc = decompressingStream.Inflate(FlushType.None); nCycles++; if (rc == ZlibConstants.Z_STREAM_END) break; Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate() [{0}] TotalBytesOut={1}", decompressingStream.Message, decompressingStream.TotalBytesOut)); } rc = decompressingStream.EndInflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressingStream.Message)); Assert.AreEqual<int>(4 * workBuffer.Length, (int)decompressingStream.TotalBytesOut); TestContext.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut); TestContext.WriteLine("decompressed length (expected): {0}", 4 * workBuffer.Length); TestContext.WriteLine("decompressed length (actual) : {0}", decompressingStream.TotalBytesOut); TestContext.WriteLine("decompression cycles: {0}", nCycles); }
public void Zlib_TestFlushSync() { int rc; int bufferSize = 40000; byte[] CompressedBytes = new byte[bufferSize]; byte[] DecompressedBytes = new byte[bufferSize]; string TextToCompress = "This is the text that will be compressed."; byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress); ZlibCodec compressor = new ZlibCodec(CompressionMode.Compress); compressor.InputBuffer = BytesToCompress; compressor.NextIn = 0; compressor.AvailableBytesIn = 3; compressor.OutputBuffer = CompressedBytes; compressor.NextOut = 0; compressor.AvailableBytesOut = CompressedBytes.Length; rc = compressor.Deflate(FlushType.Full); CompressedBytes[3]++; // force an error in first compressed block // dinoch - ?? compressor.AvailableBytesIn = TextToCompress.Length - 3; rc = compressor.Deflate(FlushType.Finish); Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressor.Message)); rc = compressor.EndDeflate(); bufferSize = (int)(compressor.TotalBytesOut); ZlibCodec decompressor = new ZlibCodec(CompressionMode.Decompress); decompressor.InputBuffer = CompressedBytes; decompressor.NextIn = 0; decompressor.AvailableBytesIn = 2; decompressor.OutputBuffer = DecompressedBytes; decompressor.NextOut = 0; decompressor.AvailableBytesOut = DecompressedBytes.Length; rc = decompressor.Inflate(FlushType.None); decompressor.AvailableBytesIn = bufferSize - 2; rc = decompressor.SyncInflate(); bool gotException = false; try { rc = decompressor.Inflate(FlushType.Finish); } catch (ZlibException ex1) { TestContext.WriteLine("Got Expected Exception: " + ex1); gotException = true; } Assert.IsTrue(gotException, "inflate should report DATA_ERROR"); rc = decompressor.EndInflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressor.Message)); int j = 0; for (; j < DecompressedBytes.Length; j++) if (DecompressedBytes[j] == 0) break; var result = System.Text.ASCIIEncoding.ASCII.GetString(DecompressedBytes, 0, j); Assert.AreEqual<int>(TextToCompress.Length, result.Length + 3, "Strings are unequal lengths"); Console.WriteLine("orig length: {0}", TextToCompress.Length); Console.WriteLine("compressed length: {0}", compressor.TotalBytesOut); Console.WriteLine("uncompressed length: {0}", decompressor.TotalBytesOut); Console.WriteLine("result length: {0}", result.Length); Console.WriteLine("result of inflate:\n(Thi){0}", result); }
public void ExtractFile(MAS2File f, string target) { BinaryReader reader = new BinaryReader(System.IO.File.OpenRead(this.mas2_file)); reader.BaseStream.Seek(f.FileOffset, SeekOrigin.Begin); byte[] RawData = reader.ReadBytes((int)f.CompressedSize); if (f.IsCompressed) { byte[] OutputData = new byte[f.UncompressedSize]; // MAS2 compression consists of a simple inflate/deflate process. ZlibCodec codec = new ZlibCodec(CompressionMode.Decompress); codec.InitializeInflate(); codec.InputBuffer = RawData; codec.NextIn = 0; codec.AvailableBytesIn = RawData.Length; codec.OutputBuffer = OutputData; codec.NextOut = 0; codec.AvailableBytesOut = OutputData.Length; codec.Inflate(FlushType.None); codec.EndInflate(); System.IO.File.WriteAllBytes(target, OutputData); } else { System.IO.File.WriteAllBytes(target, RawData); } }
public byte[] ExtractBytes(MAS2File f) { var reader = new BinaryReader(System.IO.File.OpenRead(this._File)); reader.BaseStream.Seek(f.FileOffset, SeekOrigin.Begin); var rawData = reader.ReadBytes((int)f.CompressedSize); reader.Close(); if (f.IsCompressed) { var outputData = new byte[f.UncompressedSize]; // MAS2 compression consists of a simple inflate/deflate action. var codec = new ZlibCodec(CompressionMode.Decompress); codec.InitializeInflate(); codec.InputBuffer = rawData; codec.NextIn = 0; codec.AvailableBytesIn = rawData.Length; codec.OutputBuffer = outputData; codec.NextOut = 0; codec.AvailableBytesOut = outputData.Length; codec.Inflate(FlushType.None); codec.EndInflate(); return outputData; } else { return rawData; } }
public Packet Inflate(int inflatedSize, bool keepStream = true) { var arr = ReadToEnd(); var newarr = new byte[inflatedSize]; if (ClientVersion.RemovedInVersion(ClientVersionBuild.V4_3_0_15005)) keepStream = false; if (keepStream) { int idx = ConnectionIndex; while (!TryInflate(inflatedSize, idx, arr, ref newarr)) idx += 1; } else { /*try { var inflater = new Inflater(true); inflater.SetInput(arr, 0, arr.Length); inflater.Inflate(newarr, 0, inflatedSize); } catch (ICSharpCode.SharpZipLib.SharpZipBaseException) { var inflater = new Inflater(true); inflater.SetInput(arr, 0, arr.Length); inflater.Inflate(newarr, 0, inflatedSize); }*/ var stream = new ZlibCodec(CompressionMode.Decompress) { InputBuffer = arr, NextIn = 0, AvailableBytesIn = arr.Length, OutputBuffer = newarr, NextOut = 0, AvailableBytesOut = inflatedSize }; stream.Inflate(FlushType.None); stream.Inflate(FlushType.Finish); stream.EndInflate(); } // Cannot use "using" here var pkt = new Packet(newarr, Opcode, Time, Direction, Number, Writer, FileName); pkt.ConnectionIndex = ConnectionIndex; return pkt; }
private void Run() { int rc; int comprLen = 40000; int uncomprLen = comprLen; byte[] CompressedBytes = new byte[comprLen]; byte[] DecompressedBytes = new byte[uncomprLen]; string TextToCompress = "This is the text that will be compressed."; byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress); ZlibCodec compressor = new ZlibCodec(CompressionMode.Compress); compressor.InputBuffer = BytesToCompress; compressor.NextIn = 0; compressor.OutputBuffer = CompressedBytes; compressor.NextOut = 0; compressor.AvailableBytesIn = 3; compressor.AvailableBytesOut = CompressedBytes.Length; rc = compressor.Deflate(ZlibConstants.Z_FULL_FLUSH); CheckForError(compressor, rc, "Deflate"); CompressedBytes[3]++; // force an error in first compressed block // dinoch compressor.AvailableBytesIn = TextToCompress.Length - 3; rc = compressor.Deflate(ZlibConstants.Z_FINISH); if (rc != ZlibConstants.Z_STREAM_END) { CheckForError(compressor, rc, "Deflate"); } rc = compressor.EndDeflate(); CheckForError(compressor, rc, "EndDeflate"); comprLen = (int) (compressor.TotalBytesOut); ZlibCodec decompressor = new ZlibCodec(CompressionMode.Decompress); decompressor.InputBuffer = CompressedBytes; decompressor.NextIn = 0; decompressor.AvailableBytesIn = 2; decompressor.OutputBuffer = DecompressedBytes; decompressor.NextOut = 0; decompressor.AvailableBytesOut = DecompressedBytes.Length; rc = decompressor.Inflate(ZlibConstants.Z_NO_FLUSH); CheckForError(decompressor, rc, "Inflate"); decompressor.AvailableBytesIn = CompressedBytes.Length - 2; rc = decompressor.SyncInflate(); CheckForError(decompressor, rc, "SyncInflate"); bool gotException = false; try { rc = decompressor.Inflate(ZlibConstants.Z_FINISH); } catch (ZlibException ex1) { Console.WriteLine("Got Expected Exception: " + ex1); gotException = true; } if (!gotException) { System.Console.Out.WriteLine("inflate should report DATA_ERROR"); /* Because of incorrect adler32 */ System.Environment.Exit(1); } rc = decompressor.EndInflate(); CheckForError(decompressor, rc, "EndInflate"); int j = 0; for (; j < DecompressedBytes.Length; j++) if (DecompressedBytes[j] == 0) break; var result = System.Text.ASCIIEncoding.ASCII.GetString(DecompressedBytes, 0, j); Console.WriteLine("orig length: {0}", TextToCompress.Length); Console.WriteLine("compressed length: {0}", compressor.TotalBytesOut); Console.WriteLine("uncompressed length: {0}", decompressor.TotalBytesOut); Console.WriteLine("result length: {0}", result.Length); Console.WriteLine("result of inflate:\n(Thi){0}", result); }
public void Zlib_BasicDeflateAndInflate() { string TextToCompress = LoremIpsum; int rc; int bufferSize = 40000; byte[] compressedBytes = new byte[bufferSize]; byte[] decompressedBytes = new byte[bufferSize]; ZlibCodec compressingStream = new ZlibCodec(); rc = compressingStream.InitializeDeflate(CompressionLevel.Default); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressingStream.Message)); compressingStream.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress); compressingStream.NextIn = 0; compressingStream.OutputBuffer = compressedBytes; compressingStream.NextOut = 0; while (compressingStream.TotalBytesIn != TextToCompress.Length && compressingStream.TotalBytesOut < bufferSize) { compressingStream.AvailableBytesIn = compressingStream.AvailableBytesOut = 1; // force small buffers rc = compressingStream.Deflate(FlushType.None); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate(1) [{0}]", compressingStream.Message)); } while (true) { compressingStream.AvailableBytesOut = 1; rc = compressingStream.Deflate(FlushType.Finish); if (rc == ZlibConstants.Z_STREAM_END) break; Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate(2) [{0}]", compressingStream.Message)); } rc = compressingStream.EndDeflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressingStream.Message)); ZlibCodec decompressingStream = new ZlibCodec(); decompressingStream.InputBuffer = compressedBytes; decompressingStream.NextIn = 0; decompressingStream.OutputBuffer = decompressedBytes; decompressingStream.NextOut = 0; rc = decompressingStream.InitializeInflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeInflate() [{0}]", decompressingStream.Message)); //CheckForError(decompressingStream, rc, "inflateInit"); while (decompressingStream.TotalBytesOut < decompressedBytes.Length && decompressingStream.TotalBytesIn < bufferSize) { decompressingStream.AvailableBytesIn = decompressingStream.AvailableBytesOut = 1; /* force small buffers */ rc = decompressingStream.Inflate(FlushType.None); if (rc == ZlibConstants.Z_STREAM_END) break; Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate() [{0}]", decompressingStream.Message)); //CheckForError(decompressingStream, rc, "inflate"); } rc = decompressingStream.EndInflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressingStream.Message)); //CheckForError(decompressingStream, rc, "inflateEnd"); int j = 0; for (; j < decompressedBytes.Length; j++) if (decompressedBytes[j] == 0) break; Assert.AreEqual<int>(TextToCompress.Length, j, String.Format("Unequal lengths")); int i = 0; for (i = 0; i < j; i++) if (TextToCompress[i] != decompressedBytes[i]) break; Assert.AreEqual<int>(j, i, String.Format("Non-identical content")); var result = System.Text.ASCIIEncoding.ASCII.GetString(decompressedBytes, 0, j); TestContext.WriteLine("orig length: {0}", TextToCompress.Length); TestContext.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut); TestContext.WriteLine("decompressed length: {0}", decompressingStream.TotalBytesOut); TestContext.WriteLine("result length: {0}", result.Length); TestContext.WriteLine("result of inflate:\n{0}", result); return; }
private void Run() { int rc; int j; int bufferSize = 40000; byte[] compressedBytes = new byte[bufferSize]; byte[] bufferToCompress= new byte[bufferSize]; byte[] decompressedBytes = new byte[bufferSize]; ZlibCodec compressingStream= new ZlibCodec(); rc = compressingStream.InitializeDeflate(CompressionLevel.BestSpeed); CheckForError(compressingStream, rc, "InitializeDeflate"); compressingStream.OutputBuffer = compressedBytes; compressingStream.NextOut = 0; compressingStream.AvailableBytesOut = compressedBytes.Length; // At this point, bufferToCompress is all zeroes, so it should compress // very well: compressingStream.InputBuffer = bufferToCompress; compressingStream.AvailableBytesIn = bufferToCompress.Length; rc = compressingStream.Deflate(FlushType.None); CheckForError(compressingStream, rc, "deflate"); if (compressingStream.AvailableBytesIn != 0) { System.Console.Out.WriteLine("deflate not greedy"); System.Environment.Exit(1); } Console.WriteLine("Stage 1: uncompressed bytes in so far: {0,6}", compressingStream.TotalBytesIn); Console.WriteLine(" compressed bytes out so far: {0,6}", compressingStream.TotalBytesOut); // Feed in already compressed data and switch to no compression: compressingStream.SetDeflateParams(CompressionLevel.None, CompressionStrategy.Default); compressingStream.InputBuffer = compressedBytes; compressingStream.NextIn = 0; compressingStream.AvailableBytesIn = bufferSize / 2; // why? - for fun rc = compressingStream.Deflate(FlushType.None); CheckForError(compressingStream, rc, "Deflate"); Console.WriteLine("Stage 2: uncompressed bytes in so far: {0,6}", compressingStream.TotalBytesIn); Console.WriteLine(" compressed bytes out so far: {0,6}", compressingStream.TotalBytesOut); // Insert data into bufferToCompress, and Switch back to compressing mode: System.Random rnd = new Random(); for (int i = 0; i < bufferToCompress.Length / 1000; i++) { byte b = (byte) rnd.Next(); int n = 500 + rnd.Next(500); for (j = 0; j < n; j++) bufferToCompress[j + i] = b; i += j-1; } compressingStream.SetDeflateParams(CompressionLevel.BestCompression, CompressionStrategy.Filtered); compressingStream.InputBuffer = bufferToCompress; compressingStream.NextIn = 0; compressingStream.AvailableBytesIn = bufferToCompress.Length; rc = compressingStream.Deflate(FlushType.None); CheckForError(compressingStream, rc, "Deflate"); Console.WriteLine("Stage 3: uncompressed bytes in so far: {0,6}", compressingStream.TotalBytesIn); Console.WriteLine(" compressed bytes out so far: {0,6}", compressingStream.TotalBytesOut); rc = compressingStream.Deflate(FlushType.Finish); if (rc != ZlibConstants.Z_STREAM_END) { Console.WriteLine("deflate reported {0}, should report Z_STREAM_END", rc); Environment.Exit(1); } rc = compressingStream.EndDeflate(); CheckForError(compressingStream, rc, "EndDeflate"); Console.WriteLine("Stage 4: uncompressed bytes in (final): {0,6}", compressingStream.TotalBytesIn); Console.WriteLine(" compressed bytes out (final): {0,6}", compressingStream.TotalBytesOut); ZlibCodec decompressingStream = new ZlibCodec(CompressionMode.Decompress); decompressingStream.InputBuffer = compressedBytes; decompressingStream.NextIn = 0; decompressingStream.AvailableBytesIn = bufferSize; // upon inflating, we overwrite the decompressedBytes buffer repeatedly while (true) { decompressingStream.OutputBuffer = decompressedBytes; decompressingStream.NextOut = 0; decompressingStream.AvailableBytesOut = decompressedBytes.Length; rc = decompressingStream.Inflate(FlushType.None); if (rc == ZlibConstants.Z_STREAM_END) break; CheckForError(decompressingStream, rc, "inflate large"); } rc = decompressingStream.EndInflate(); CheckForError(decompressingStream, rc, "EndInflate"); if (decompressingStream.TotalBytesOut != 2 * decompressedBytes.Length + bufferSize / 2) { System.Console.WriteLine("bad large inflate: " + decompressingStream.TotalBytesOut); System.Environment.Exit(1); } for (j = 0; j < decompressedBytes.Length; j++) if (decompressedBytes[j] == 0) break; Console.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut); Console.WriteLine("decompressed length (expected): {0}", 2 * decompressedBytes.Length + bufferSize / 2); Console.WriteLine("decompressed length (actual) : {0}", decompressingStream.TotalBytesOut); }
public void Zlib_BasicDictionaryDeflateInflate() { int rc; int comprLen = 40000; int uncomprLen = comprLen; byte[] uncompr = new byte[uncomprLen]; byte[] compr = new byte[comprLen]; //long dictId; ZlibCodec compressor = new ZlibCodec(); rc = compressor.InitializeDeflate(CompressionLevel.BestCompression); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressor.Message)); string dictionaryWord = "hello "; byte[] dictionary = System.Text.ASCIIEncoding.ASCII.GetBytes(dictionaryWord); string TextToCompress = "hello, hello! How are you, Joe? I said hello. "; byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress); rc = compressor.SetDictionary(dictionary); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at SetDeflateDictionary() [{0}]", compressor.Message)); int dictId = compressor.Adler32; compressor.OutputBuffer = compr; compressor.NextOut = 0; compressor.AvailableBytesOut = comprLen; compressor.InputBuffer = BytesToCompress; compressor.NextIn = 0; compressor.AvailableBytesIn = BytesToCompress.Length; rc = compressor.Deflate(FlushType.Finish); Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressor.Message)); rc = compressor.EndDeflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressor.Message)); ZlibCodec decompressor = new ZlibCodec(); decompressor.InputBuffer = compr; decompressor.NextIn = 0; decompressor.AvailableBytesIn = comprLen; rc = decompressor.InitializeInflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeInflate() [{0}]", decompressor.Message)); decompressor.OutputBuffer = uncompr; decompressor.NextOut = 0; decompressor.AvailableBytesOut = uncomprLen; while (true) { rc = decompressor.Inflate(FlushType.None); if (rc == ZlibConstants.Z_STREAM_END) { break; } if (rc == ZlibConstants.Z_NEED_DICT) { Assert.AreEqual<long>(dictId, decompressor.Adler32, "Unexpected Dictionary"); rc = decompressor.SetDictionary(dictionary); } Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate/SetInflateDictionary() [{0}]", decompressor.Message)); } rc = decompressor.EndInflate(); Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressor.Message)); int j = 0; for (; j < uncompr.Length; j++) if (uncompr[j] == 0) break; Assert.AreEqual<int>(TextToCompress.Length, j, String.Format("Unequal lengths")); int i = 0; for (i = 0; i < j; i++) if (TextToCompress[i] != uncompr[i]) break; Assert.AreEqual<int>(j, i, String.Format("Non-identical content")); var result = System.Text.ASCIIEncoding.ASCII.GetString(uncompr, 0, j); TestContext.WriteLine("orig length: {0}", TextToCompress.Length); TestContext.WriteLine("compressed length: {0}", compressor.TotalBytesOut); TestContext.WriteLine("uncompressed length: {0}", decompressor.TotalBytesOut); TestContext.WriteLine("result length: {0}", result.Length); TestContext.WriteLine("result of inflate:\n{0}", result); }
public Packet Inflate(int inflatedSize, bool keepStream = true) { var arr = ReadToEnd(); var newarr = new byte[inflatedSize]; if (ClientVersion.RemovedInVersion(ClientVersionBuild.V4_3_0_15005)) keepStream = false; if (keepStream) { if (!SessionHandler.z_streams.ContainsKey(ConnectionIndex)) SessionHandler.z_streams[ConnectionIndex] = new ZlibCodec(CompressionMode.Decompress); SessionHandler.z_streams[ConnectionIndex].InputBuffer = arr; SessionHandler.z_streams[ConnectionIndex].NextIn = 0; SessionHandler.z_streams[ConnectionIndex].AvailableBytesIn = arr.Length; SessionHandler.z_streams[ConnectionIndex].OutputBuffer = newarr; SessionHandler.z_streams[ConnectionIndex].NextOut = 0; SessionHandler.z_streams[ConnectionIndex].AvailableBytesOut = inflatedSize; SessionHandler.z_streams[ConnectionIndex].Inflate(FlushType.Sync); } else { /*try { var inflater = new Inflater(true); inflater.SetInput(arr, 0, arr.Length); inflater.Inflate(newarr, 0, inflatedSize); } catch (ICSharpCode.SharpZipLib.SharpZipBaseException) { var inflater = new Inflater(true); inflater.SetInput(arr, 0, arr.Length); inflater.Inflate(newarr, 0, inflatedSize); }*/ ZlibCodec stream = new ZlibCodec(CompressionMode.Decompress); stream.InputBuffer = arr; stream.NextIn = 0; stream.AvailableBytesIn = arr.Length; stream.OutputBuffer = newarr; stream.NextOut = 0; stream.AvailableBytesOut = inflatedSize; stream.Inflate(FlushType.None); stream.Inflate(FlushType.Finish); stream.EndInflate(); } // Cannot use "using" here var pkt = new Packet(newarr, Opcode, Time, Direction, Number, Writer, FileName); pkt.ConnectionIndex = ConnectionIndex; return pkt; }
private void Run() { int rc; int bufferSize = 40000; byte[] compressedBytes = new byte[bufferSize]; byte[] decompressedBytes = new byte[bufferSize]; ZlibCodec compressingStream = new ZlibCodec(); rc = compressingStream.InitializeDeflate(CompressionLevel.LEVEL9_BEST_COMPRESSION); CheckForError(compressingStream, rc, "InitializeDeflate"); string dictionaryWord = "hello "; byte[] dictionary = System.Text.ASCIIEncoding.ASCII.GetBytes(dictionaryWord); string TextToCompress = "hello, hello! How are you, Joe? "; byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress); rc = compressingStream.SetDictionary(dictionary); CheckForError(compressingStream, rc, "SetDeflateDictionary"); long dictId = compressingStream.Adler32; compressingStream.OutputBuffer = compressedBytes; compressingStream.NextOut = 0; compressingStream.AvailableBytesOut = bufferSize; compressingStream.InputBuffer = BytesToCompress; compressingStream.NextIn = 0; compressingStream.AvailableBytesIn = BytesToCompress.Length; rc = compressingStream.Deflate(ZlibConstants.Z_FINISH); if (rc != ZlibConstants.Z_STREAM_END) { System.Console.Out.WriteLine("deflate should report Z_STREAM_END"); System.Environment.Exit(1); } rc = compressingStream.EndDeflate(); CheckForError(compressingStream, rc, "deflateEnd"); ZlibCodec decompressingStream = new ZlibCodec(); decompressingStream.InputBuffer = compressedBytes; decompressingStream.NextIn = 0; decompressingStream.AvailableBytesIn = bufferSize; rc = decompressingStream.InitializeInflate(); CheckForError(decompressingStream, rc, "inflateInit"); decompressingStream.OutputBuffer = decompressedBytes; decompressingStream.NextOut = 0; decompressingStream.AvailableBytesOut = decompressedBytes.Length; while (true) { rc = decompressingStream.Inflate(ZlibConstants.Z_NO_FLUSH); if (rc == ZlibConstants.Z_STREAM_END) { break; } if (rc == ZlibConstants.Z_NEED_DICT) { if ((int)decompressingStream.Adler32 != (int)dictId) { System.Console.Out.WriteLine("unexpected dictionary"); System.Environment.Exit(1); } rc = decompressingStream.SetDictionary(dictionary); } CheckForError(decompressingStream, rc, "inflate with dict"); } rc = decompressingStream.EndInflate(); CheckForError(decompressingStream, rc, "EndInflate"); int j = 0; for (; j < decompressedBytes.Length; j++) if (decompressedBytes[j] == 0) break; var result = System.Text.ASCIIEncoding.ASCII.GetString(decompressedBytes, 0, j); Console.WriteLine("orig length: {0}", TextToCompress.Length); Console.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut); Console.WriteLine("decompressed length: {0}", decompressingStream.TotalBytesOut); Console.WriteLine("result length: {0}", result.Length); Console.WriteLine("result of inflate:\n{0}", result); }