// Do we really need these? SWGEmu doesn't seem to compress... public void Compress() { byte[] numArray = new byte[this.data.Count]; this.data.CopyTo(0, numArray, 0, this.data.Count); byte[] numArray1 = new byte[800]; ZStream zStream = new ZStream() { avail_in = 0 }; zStream.deflateInit(6); zStream.next_in = numArray; zStream.next_in_index = 2; zStream.avail_in = (int)numArray.Length - 4; zStream.next_out = numArray1; zStream.avail_out = 800; if (zStream.deflate(4) != -3) { long totalOut = zStream.total_out; zStream.deflateEnd(); zStream = null; this.data.Clear(); this.data.Add(numArray[0]); this.data.Add(numArray[1]); for (int i = 0; (long)i < totalOut; i++) { this.data.Add(numArray1[i]); } this.data.Add(numArray[(int)numArray.Length - 3]); this.data.Add(numArray[(int)numArray.Length - 2]); this.data.Add(numArray[(int)numArray.Length - 1]); } }
public ZOutputStream(System.IO.Stream out_Renamed, int level) : base() { InitBlock(); this.out_Renamed = out_Renamed; z.deflateInit(level); compress = true; }
public ZInputStream(Stream in_Renamed, int level) : base(in_Renamed) { InitBlock(); this.in_Renamed = in_Renamed; z.deflateInit(level); compress = true; z.next_in = buf; z.next_in_index = 0; z.avail_in = 0; }
protected override int InitZlibOperation(ZStream zs) { // -MAX_WBITS stands for absense of Zlib header and trailer (needed for GZIP compression and decompression) return zs.deflateInit(_level, -Zlib.MAX_WBITS); }
private void init(Stream innerStream) { m_stream = innerStream; if (m_stream.CanRead) { m_in = new ZStream(); int ret = m_in.inflateInit(); if (ret != zlibConst.Z_OK) throw new CompressionFailedException("Unable to initialize zlib for deflate: " + ret); m_inbuf = new byte[bufsize]; m_in.avail_in = 0; m_in.next_in = m_inbuf; m_in.next_in_index = 0; } if (m_stream.CanWrite) { m_out = new ZStream(); int ret = m_out.deflateInit(zlibConst.Z_DEFAULT_COMPRESSION); if (ret != zlibConst.Z_OK) throw new CompressionFailedException("Unable to initialize zlib for inflate: " + ret); m_outbuf = new byte[bufsize]; m_out.next_out = m_outbuf; } }
public static PhpBytes GzEncode(PhpBytes data, int level, int encoding_mode) { if ((level < -1) || (level > 9)) { PhpException.Throw(PhpError.Warning, String.Format("compression level ({0}) must be within -1..9", level)); return null; } ZStream zs = new ZStream(); int status = zlibConst.Z_OK; zs.next_in = data.ReadonlyData; zs.avail_in = data.Length; // heuristic for max data length zs.avail_out = data.Length + data.Length / Zlib.PHP_ZLIB_MODIFIER + 15 + 1; zs.next_out = new byte[zs.avail_out]; switch (encoding_mode) { case (int)ForceConstants.FORCE_GZIP: if ((status = zs.deflateInit(level, -MAX_WBITS)) != zlibConst.Z_OK) { PhpException.Throw(PhpError.Warning, zError(status)); return null; } break; case (int)ForceConstants.FORCE_DEFLATE: if ((status = zs.deflateInit(level)) != zlibConst.Z_OK) { PhpException.Throw(PhpError.Warning, zError(status)); return null; } break; } status = zs.deflate(zlibConst.Z_FINISH); if (status != zlibConst.Z_STREAM_END) { zs.deflateEnd(); if (status == zlibConst.Z_OK) { status = zlibConst.Z_STREAM_ERROR; } } else { status = zs.deflateEnd(); } if (status == zlibConst.Z_OK) { long output_length = zs.total_out + (encoding_mode == (int)ForceConstants.FORCE_GZIP ? GZIP_HEADER_LENGTH + GZIP_FOOTER_LENGTH : GZIP_HEADER_LENGTH); long output_offset = GZIP_HEADER_LENGTH; byte[] output = new byte[output_length]; Buffer.BlockCopy(zs.next_out, 0, output, (int)output_offset, (int)zs.total_out); // fill the header output[0] = GZIP_HEADER[0]; output[1] = GZIP_HEADER[1]; output[2] = Z_DEFLATED; // zlib constant (private in ZLIB.NET) output[3] = 0; // reserved flag bits (this function puts invalid flags in here) // 4-8 represent time and are set to zero output[9] = OS_CODE; // php constant if (encoding_mode == (int)ForceConstants.FORCE_GZIP) { var crc_algo = new PHP.Library.CRC32(); byte[] crc = crc_algo.ComputeHash(data.ReadonlyData, 0, data.Length); crc_algo.Dispose(); output[output_length - 8] = crc[0]; output[output_length - 7] = crc[1]; output[output_length - 6] = crc[2]; output[output_length - 5] = crc[3]; output[output_length - 4] = (byte)(zs.total_in & 0xFF); output[output_length - 3] = (byte)((zs.total_in >> 8) & 0xFF); output[output_length - 2] = (byte)((zs.total_in >> 16) & 0xFF); output[output_length - 1] = (byte)((zs.total_in >> 24) & 0xFF); } return new PhpBytes(output); } else { PhpException.Throw(PhpError.Warning, zError(status)); return null; } }
public static PhpBytes GzDeflate(PhpBytes data, int level) { if ((level < -1) || (level > 9)) { PhpException.Throw(PhpError.Warning, String.Format("compression level ({0}) must be within -1..9", level)); return null; } ZStream zs = new ZStream(); zs.next_in = data.ReadonlyData; zs.avail_in = data.Length; // heuristic for max data length zs.avail_out = data.Length + data.Length / PHP_ZLIB_MODIFIER + 15 + 1; zs.next_out = new byte[zs.avail_out]; // -15 omits the header (undocumented feature of zlib) int status = zs.deflateInit(level, -MAX_WBITS); if (status == zlibConst.Z_OK) { status = zs.deflate(zlibConst.Z_FINISH); if (status != zlibConst.Z_STREAM_END) { zs.deflateEnd(); if (status == zlibConst.Z_OK) { status = zlibConst.Z_BUF_ERROR; } } else { status = zs.deflateEnd(); } } if (status == zlibConst.Z_OK) { byte[] result = new byte[zs.total_out]; Buffer.BlockCopy(zs.next_out, 0, result, 0, (int)zs.total_out); return new PhpBytes(result); } else { PhpException.Throw(PhpError.Warning, zError(status)); return null; } }
/// <summary> /// Reimplements function from zlib (compress2) that is not present in ZLIB.NET. /// </summary> /// <param name="dest">Destination array of bytes. May be trimmed if necessary.</param> /// <param name="source">Source array of bytes.</param> /// <param name="level">Level of compression.</param> /// <returns>Zlib status code.</returns> private static int ZlibCompress(ref byte[] dest, byte[] source, int level) { ZStream stream = new ZStream(); int err; stream.next_in = source; stream.avail_in = source.Length; stream.next_out = dest; stream.avail_out = dest.Length; err = stream.deflateInit(level); if (err != zlibConst.Z_OK) return err; err = stream.deflate(zlibConst.Z_FINISH); if (err != zlibConst.Z_STREAM_END) { stream.deflateEnd(); return err == zlibConst.Z_OK ? zlibConst.Z_BUF_ERROR : err; } if (stream.total_out != dest.Length) { byte[] output = new byte[stream.total_out]; Buffer.BlockCopy(stream.next_out, 0, output, 0, (int)stream.total_out); dest = output; } return stream.deflateEnd(); }