// ZlibCodec.cs
|
// ------------------------------------------------------------------
|
//
|
// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
|
// All rights reserved.
|
//
|
// This code module is part of DotNetZip, a zipfile class library.
|
//
|
// ------------------------------------------------------------------
|
//
|
// This code is licensed under the Microsoft Public License.
|
// See the file License.txt for the license details.
|
// More info on: http://dotnetzip.codeplex.com
|
//
|
// ------------------------------------------------------------------
|
//
|
// last saved (in emacs):
|
// Time-stamp: <2009-November-03 15:40:51>
|
//
|
// ------------------------------------------------------------------
|
//
|
// This module defines a Codec for ZLIB compression and
|
// decompression. This code extends code that was based the jzlib
|
// implementation of zlib, but this code is completely novel. The codec
|
// class is new, and encapsulates some behaviors that are new, and some
|
// that were present in other classes in the jzlib code base. In
|
// keeping with the license for jzlib, the copyright to the jzlib code
|
// is included below.
|
//
|
// ------------------------------------------------------------------
|
//
|
// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
//
|
// Redistribution and use in source and binary forms, with or without
|
// modification, are permitted provided that the following conditions are met:
|
//
|
// 1. Redistributions of source code must retain the above copyright notice,
|
// this list of conditions and the following disclaimer.
|
//
|
// 2. Redistributions in binary form must reproduce the above copyright
|
// notice, this list of conditions and the following disclaimer in
|
// the documentation and/or other materials provided with the distribution.
|
//
|
// 3. The names of the authors may not be used to endorse or promote products
|
// derived from this software without specific prior written permission.
|
//
|
// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
//
|
// -----------------------------------------------------------------------
|
//
|
// This program is based on zlib-1.1.3; credit to authors
|
// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
// and contributors of zlib.
|
//
|
// -----------------------------------------------------------------------
|
|
|
using System;
|
using Interop=System.Runtime.InteropServices;
|
|
namespace HH.WMS.Utils.Ionic.Zlib
|
{
|
/// <summary>
|
/// Encoder and Decoder for ZLIB and DEFLATE (IETF RFC1950 and RFC1951).
|
/// </summary>
|
///
|
/// <remarks>
|
/// This class compresses and decompresses data according to the Deflate algorithm
|
/// and optionally, the ZLIB format, as documented in <see
|
/// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950 - ZLIB</see> and <see
|
/// href="http://www.ietf.org/rfc/rfc1951.txt">RFC 1951 - DEFLATE</see>.
|
/// </remarks>
|
[Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000D")]
|
[Interop.ComVisible(true)]
|
#if !NETCF
|
[Interop.ClassInterface(Interop.ClassInterfaceType.AutoDispatch)]
|
#endif
|
sealed public class ZlibCodec
|
{
|
/// <summary>
|
/// The buffer from which data is taken.
|
/// </summary>
|
public byte[] InputBuffer;
|
|
/// <summary>
|
/// An index into the InputBuffer array, indicating where to start reading.
|
/// </summary>
|
public int NextIn;
|
|
/// <summary>
|
/// The number of bytes available in the InputBuffer, starting at NextIn.
|
/// </summary>
|
/// <remarks>
|
/// Generally you should set this to InputBuffer.Length before the first Inflate() or Deflate() call.
|
/// The class will update this number as calls to Inflate/Deflate are made.
|
/// </remarks>
|
public int AvailableBytesIn;
|
|
/// <summary>
|
/// Total number of bytes read so far, through all calls to Inflate()/Deflate().
|
/// </summary>
|
public long TotalBytesIn;
|
|
/// <summary>
|
/// Buffer to store output data.
|
/// </summary>
|
public byte[] OutputBuffer;
|
|
/// <summary>
|
/// An index into the OutputBuffer array, indicating where to start writing.
|
/// </summary>
|
public int NextOut;
|
|
/// <summary>
|
/// The number of bytes available in the OutputBuffer, starting at NextOut.
|
/// </summary>
|
/// <remarks>
|
/// Generally you should set this to OutputBuffer.Length before the first Inflate() or Deflate() call.
|
/// The class will update this number as calls to Inflate/Deflate are made.
|
/// </remarks>
|
public int AvailableBytesOut;
|
|
/// <summary>
|
/// Total number of bytes written to the output so far, through all calls to Inflate()/Deflate().
|
/// </summary>
|
public long TotalBytesOut;
|
|
/// <summary>
|
/// used for diagnostics, when something goes wrong!
|
/// </summary>
|
public System.String Message;
|
|
internal DeflateManager dstate;
|
internal InflateManager istate;
|
|
internal uint _Adler32;
|
|
/// <summary>
|
/// The compression level to use in this codec. Useful only in compression mode.
|
/// </summary>
|
public CompressionLevel CompressLevel = CompressionLevel.Default;
|
|
/// <summary>
|
/// The number of Window Bits to use.
|
/// </summary>
|
/// <remarks>
|
/// This gauges the size of the sliding window, and hence the
|
/// compression effectiveness as well as memory consumption. It's best to just leave this
|
/// setting alone if you don't know what it is. The maximum value is 15 bits, which implies
|
/// a 32k window.
|
/// </remarks>
|
public int WindowBits = ZlibConstants.WindowBitsDefault;
|
|
/// <summary>
|
/// The compression strategy to use.
|
/// </summary>
|
/// <remarks>
|
/// This is only effective in compression. The theory offered by ZLIB is that different
|
/// strategies could potentially produce significant differences in compression behavior
|
/// for different data sets. Unfortunately I don't have any good recommendations for how
|
/// to set it differently. When I tested changing the strategy I got minimally different
|
/// compression performance. It's best to leave this property alone if you don't have a
|
/// good feel for it. Or, you may want to produce a test harness that runs through the
|
/// different strategy options and evaluates them on different file types. If you do that,
|
/// let me know your results.
|
/// </remarks>
|
public CompressionStrategy Strategy = CompressionStrategy.Default;
|
|
|
/// <summary>
|
/// The Adler32 checksum on the data transferred through the codec so far. You probably don't need to look at this.
|
/// </summary>
|
public int Adler32 { get { return (int)_Adler32; } }
|
|
|
/// <summary>
|
/// Create a ZlibCodec.
|
/// </summary>
|
/// <remarks>
|
/// If you use this default constructor, you will later have to explicitly call
|
/// InitializeInflate() or InitializeDeflate() before using the ZlibCodec to compress
|
/// or decompress.
|
/// </remarks>
|
public ZlibCodec() { }
|
|
/// <summary>
|
/// Create a ZlibCodec that either compresses or decompresses.
|
/// </summary>
|
/// <param name="mode">
|
/// Indicates whether the codec should compress (deflate) or decompress (inflate).
|
/// </param>
|
public ZlibCodec(CompressionMode mode)
|
{
|
if (mode == CompressionMode.Compress)
|
{
|
int rc = InitializeDeflate();
|
if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for deflate.");
|
}
|
else if (mode == CompressionMode.Decompress)
|
{
|
int rc = InitializeInflate();
|
if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for inflate.");
|
}
|
else throw new ZlibException("Invalid ZlibStreamFlavor.");
|
}
|
|
/// <summary>
|
/// Initialize the inflation state.
|
/// </summary>
|
/// <remarks>
|
/// It is not necessary to call this before using the ZlibCodec to inflate data;
|
/// It is implicitly called when you call the constructor.
|
/// </remarks>
|
/// <returns>Z_OK if everything goes well.</returns>
|
public int InitializeInflate()
|
{
|
return InitializeInflate(this.WindowBits);
|
}
|
|
/// <summary>
|
/// Initialize the inflation state with an explicit flag to
|
/// govern the handling of RFC1950 header bytes.
|
/// </summary>
|
///
|
/// <remarks>
|
/// By default, the ZLIB header defined in <see
|
/// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</see> is expected. If
|
/// you want to read a zlib stream you should specify true for
|
/// expectRfc1950Header. If you have a deflate stream, you will want to specify
|
/// false. It is only necessary to invoke this initializer explicitly if you
|
/// want to specify false.
|
/// </remarks>
|
///
|
/// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte
|
/// pair when reading the stream of data to be inflated.</param>
|
///
|
/// <returns>Z_OK if everything goes well.</returns>
|
public int InitializeInflate(bool expectRfc1950Header)
|
{
|
return InitializeInflate(this.WindowBits, expectRfc1950Header);
|
}
|
|
/// <summary>
|
/// Initialize the ZlibCodec for inflation, with the specified number of window bits.
|
/// </summary>
|
/// <param name="windowBits">The number of window bits to use. If you need to ask what that is,
|
/// then you shouldn't be calling this initializer.</param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int InitializeInflate(int windowBits)
|
{
|
this.WindowBits = windowBits;
|
return InitializeInflate(windowBits, true);
|
}
|
|
/// <summary>
|
/// Initialize the inflation state with an explicit flag to govern the handling of
|
/// RFC1950 header bytes.
|
/// </summary>
|
///
|
/// <remarks>
|
/// If you want to read a zlib stream you should specify true for
|
/// expectRfc1950Header. In this case, the library will expect to find a ZLIB
|
/// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
|
/// 1950</see>, in the compressed stream. If you will be reading a DEFLATE or
|
/// GZIP stream, which does not have such a header, you will want to specify
|
/// false.
|
/// </remarks>
|
///
|
/// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading
|
/// the stream of data to be inflated.</param>
|
/// <param name="windowBits">The number of window bits to use. If you need to ask what that is,
|
/// then you shouldn't be calling this initializer.</param>
|
/// <returns>Z_OK if everything goes well.</returns>
|
public int InitializeInflate(int windowBits, bool expectRfc1950Header)
|
{
|
this.WindowBits = windowBits;
|
if (dstate != null) throw new ZlibException("You may not call InitializeInflate() after calling InitializeDeflate().");
|
istate = new InflateManager(expectRfc1950Header);
|
return istate.Initialize(this, windowBits);
|
}
|
|
/// <summary>
|
/// Inflate the data in the InputBuffer, placing the result in the OutputBuffer.
|
/// </summary>
|
/// <remarks>
|
/// You must have set InputBuffer and OutputBuffer, NextIn and NextOut, and AvailableBytesIn and
|
/// AvailableBytesOut before calling this method.
|
/// </remarks>
|
/// <example>
|
/// <code>
|
/// private void InflateBuffer()
|
/// {
|
/// int bufferSize = 1024;
|
/// byte[] buffer = new byte[bufferSize];
|
/// ZlibCodec decompressor = new ZlibCodec();
|
///
|
/// Console.WriteLine("\n============================================");
|
/// Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);
|
/// MemoryStream ms = new MemoryStream(DecompressedBytes);
|
///
|
/// int rc = decompressor.InitializeInflate();
|
///
|
/// decompressor.InputBuffer = CompressedBytes;
|
/// decompressor.NextIn = 0;
|
/// decompressor.AvailableBytesIn = CompressedBytes.Length;
|
///
|
/// decompressor.OutputBuffer = buffer;
|
///
|
/// // pass 1: inflate
|
/// do
|
/// {
|
/// decompressor.NextOut = 0;
|
/// decompressor.AvailableBytesOut = buffer.Length;
|
/// rc = decompressor.Inflate(FlushType.None);
|
///
|
/// if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
|
/// throw new Exception("inflating: " + decompressor.Message);
|
///
|
/// ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
|
/// }
|
/// while (decompressor.AvailableBytesIn > 0 || decompressor.AvailableBytesOut == 0);
|
///
|
/// // pass 2: finish and flush
|
/// do
|
/// {
|
/// decompressor.NextOut = 0;
|
/// decompressor.AvailableBytesOut = buffer.Length;
|
/// rc = decompressor.Inflate(FlushType.Finish);
|
///
|
/// if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
|
/// throw new Exception("inflating: " + decompressor.Message);
|
///
|
/// if (buffer.Length - decompressor.AvailableBytesOut > 0)
|
/// ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);
|
/// }
|
/// while (decompressor.AvailableBytesIn > 0 || decompressor.AvailableBytesOut == 0);
|
///
|
/// decompressor.EndInflate();
|
/// }
|
///
|
/// </code>
|
/// </example>
|
/// <param name="flush">The flush to use when inflating.</param>
|
/// <returns>Z_OK if everything goes well.</returns>
|
public int Inflate(FlushType flush)
|
{
|
if (istate == null)
|
throw new ZlibException("No Inflate State!");
|
return istate.Inflate(flush);
|
}
|
|
|
/// <summary>
|
/// Ends an inflation session.
|
/// </summary>
|
/// <remarks>
|
/// Call this after successively calling Inflate(). This will cause all buffers to be flushed.
|
/// After calling this you cannot call Inflate() without a intervening call to one of the
|
/// InitializeInflate() overloads.
|
/// </remarks>
|
/// <returns>Z_OK if everything goes well.</returns>
|
public int EndInflate()
|
{
|
if (istate == null)
|
throw new ZlibException("No Inflate State!");
|
int ret = istate.End();
|
istate = null;
|
return ret;
|
}
|
|
/// <summary>
|
/// I don't know what this does!
|
/// </summary>
|
/// <returns>Z_OK if everything goes well.</returns>
|
public int SyncInflate()
|
{
|
if (istate == null)
|
throw new ZlibException("No Inflate State!");
|
return istate.Sync();
|
}
|
|
/// <summary>
|
/// Initialize the ZlibCodec for deflation operation.
|
/// </summary>
|
/// <remarks>
|
/// The codec will use the MAX window bits and the default level of compression.
|
/// </remarks>
|
/// <example>
|
/// <code>
|
/// int bufferSize = 40000;
|
/// byte[] CompressedBytes = new byte[bufferSize];
|
/// byte[] DecompressedBytes = new byte[bufferSize];
|
///
|
/// ZlibCodec compressor = new ZlibCodec();
|
///
|
/// compressor.InitializeDeflate(CompressionLevel.Default);
|
///
|
/// compressor.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
|
/// compressor.NextIn = 0;
|
/// compressor.AvailableBytesIn = compressor.InputBuffer.Length;
|
///
|
/// compressor.OutputBuffer = CompressedBytes;
|
/// compressor.NextOut = 0;
|
/// compressor.AvailableBytesOut = CompressedBytes.Length;
|
///
|
/// while (compressor.TotalBytesIn != TextToCompress.Length && compressor.TotalBytesOut < bufferSize)
|
/// {
|
/// compressor.Deflate(FlushType.None);
|
/// }
|
///
|
/// while (true)
|
/// {
|
/// int rc= compressor.Deflate(FlushType.Finish);
|
/// if (rc == ZlibConstants.Z_STREAM_END) break;
|
/// }
|
///
|
/// compressor.EndDeflate();
|
///
|
/// </code>
|
/// </example>
|
/// <returns>Z_OK if all goes well. You generally don't need to check the return code.</returns>
|
public int InitializeDeflate()
|
{
|
return _InternalInitializeDeflate(true);
|
}
|
|
/// <summary>
|
/// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel.
|
/// </summary>
|
/// <remarks>
|
/// The codec will use the maximum window bits (15) and the specified
|
/// CompressionLevel. It will emit a ZLIB stream as it compresses.
|
/// </remarks>
|
/// <param name="level">The compression level for the codec.</param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int InitializeDeflate(CompressionLevel level)
|
{
|
this.CompressLevel = level;
|
return _InternalInitializeDeflate(true);
|
}
|
|
|
/// <summary>
|
/// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel,
|
/// and the explicit flag governing whether to emit an RFC1950 header byte pair.
|
/// </summary>
|
/// <remarks>
|
/// The codec will use the maximum window bits (15) and the specified CompressionLevel.
|
/// If you want to generate a zlib stream, you should specify true for
|
/// wantRfc1950Header. In this case, the library will emit a ZLIB
|
/// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
|
/// 1950</see>, in the compressed stream.
|
/// </remarks>
|
/// <param name="level">The compression level for the codec.</param>
|
/// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int InitializeDeflate(CompressionLevel level, bool wantRfc1950Header)
|
{
|
this.CompressLevel = level;
|
return _InternalInitializeDeflate(wantRfc1950Header);
|
}
|
|
|
/// <summary>
|
/// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel,
|
/// and the specified number of window bits.
|
/// </summary>
|
/// <remarks>
|
/// The codec will use the specified number of window bits and the specified CompressionLevel.
|
/// </remarks>
|
/// <param name="level">The compression level for the codec.</param>
|
/// <param name="bits">the number of window bits to use. If you don't know what this means, don't use this method.</param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int InitializeDeflate(CompressionLevel level, int bits)
|
{
|
this.CompressLevel = level;
|
this.WindowBits = bits;
|
return _InternalInitializeDeflate(true);
|
}
|
|
/// <summary>
|
/// Initialize the ZlibCodec for deflation operation, using the specified
|
/// CompressionLevel, the specified number of window bits, and the explicit flag
|
/// governing whether to emit an RFC1950 header byte pair.
|
/// </summary>
|
///
|
/// <param name="level">The compression level for the codec.</param>
|
/// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
|
/// <param name="bits">the number of window bits to use. If you don't know what this means, don't use this method.</param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int InitializeDeflate(CompressionLevel level, int bits, bool wantRfc1950Header)
|
{
|
this.CompressLevel = level;
|
this.WindowBits = bits;
|
return _InternalInitializeDeflate(wantRfc1950Header);
|
}
|
|
private int _InternalInitializeDeflate(bool wantRfc1950Header)
|
{
|
if (istate != null) throw new ZlibException("You may not call InitializeDeflate() after calling InitializeInflate().");
|
dstate = new DeflateManager();
|
dstate.WantRfc1950HeaderBytes = wantRfc1950Header;
|
|
return dstate.Initialize(this, this.CompressLevel, this.WindowBits, this.Strategy);
|
}
|
|
/// <summary>
|
/// Deflate one batch of data.
|
/// </summary>
|
/// <remarks>
|
/// You must have set InputBuffer and OutputBuffer before calling this method.
|
/// </remarks>
|
/// <example>
|
/// <code>
|
/// private void DeflateBuffer(CompressionLevel level)
|
/// {
|
/// int bufferSize = 1024;
|
/// byte[] buffer = new byte[bufferSize];
|
/// ZlibCodec compressor = new ZlibCodec();
|
///
|
/// Console.WriteLine("\n============================================");
|
/// Console.WriteLine("Size of Buffer to Deflate: {0} bytes.", UncompressedBytes.Length);
|
/// MemoryStream ms = new MemoryStream();
|
///
|
/// int rc = compressor.InitializeDeflate(level);
|
///
|
/// compressor.InputBuffer = UncompressedBytes;
|
/// compressor.NextIn = 0;
|
/// compressor.AvailableBytesIn = UncompressedBytes.Length;
|
///
|
/// compressor.OutputBuffer = buffer;
|
///
|
/// // pass 1: deflate
|
/// do
|
/// {
|
/// compressor.NextOut = 0;
|
/// compressor.AvailableBytesOut = buffer.Length;
|
/// rc = compressor.Deflate(FlushType.None);
|
///
|
/// if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
|
/// throw new Exception("deflating: " + compressor.Message);
|
///
|
/// ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);
|
/// }
|
/// while (compressor.AvailableBytesIn > 0 || compressor.AvailableBytesOut == 0);
|
///
|
/// // pass 2: finish and flush
|
/// do
|
/// {
|
/// compressor.NextOut = 0;
|
/// compressor.AvailableBytesOut = buffer.Length;
|
/// rc = compressor.Deflate(FlushType.Finish);
|
///
|
/// if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
|
/// throw new Exception("deflating: " + compressor.Message);
|
///
|
/// if (buffer.Length - compressor.AvailableBytesOut > 0)
|
/// ms.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
|
/// }
|
/// while (compressor.AvailableBytesIn > 0 || compressor.AvailableBytesOut == 0);
|
///
|
/// compressor.EndDeflate();
|
///
|
/// ms.Seek(0, SeekOrigin.Begin);
|
/// CompressedBytes = new byte[compressor.TotalBytesOut];
|
/// ms.Read(CompressedBytes, 0, CompressedBytes.Length);
|
/// }
|
/// </code>
|
/// </example>
|
/// <param name="flush">whether to flush all data as you deflate. Generally you will want to
|
/// use Z_NO_FLUSH here, in a series of calls to Deflate(), and then call EndDeflate() to
|
/// flush everything.
|
/// </param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int Deflate(FlushType flush)
|
{
|
if (dstate == null)
|
throw new ZlibException("No Deflate State!");
|
return dstate.Deflate(flush);
|
}
|
|
/// <summary>
|
/// End a deflation session.
|
/// </summary>
|
/// <remarks>
|
/// Call this after making a series of one or more calls to Deflate(). All buffers are flushed.
|
/// </remarks>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int EndDeflate()
|
{
|
if (dstate == null)
|
throw new ZlibException("No Deflate State!");
|
// TODO: dinoch Tue, 03 Nov 2009 15:39 (test this)
|
//int ret = dstate.End();
|
dstate = null;
|
return ZlibConstants.Z_OK; //ret;
|
}
|
|
/// <summary>
|
/// Reset a codec for another deflation session.
|
/// </summary>
|
/// <remarks>
|
/// Call this to reset the deflation state. For example if a thread is deflating
|
/// non-consecutive blocks, you can call Reset() after the Deflate(Sync) of the first
|
/// block and before the next Deflate(None) of the second block.
|
/// </remarks>
|
/// <returns>Z_OK if all goes well.</returns>
|
public void ResetDeflate()
|
{
|
if (dstate == null)
|
throw new ZlibException("No Deflate State!");
|
dstate.Reset();
|
}
|
|
|
/// <summary>
|
/// Set the CompressionStrategy and CompressionLevel for a deflation session.
|
/// </summary>
|
/// <param name="level">the level of compression to use.</param>
|
/// <param name="strategy">the strategy to use for compression.</param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int SetDeflateParams(CompressionLevel level, CompressionStrategy strategy)
|
{
|
if (dstate == null)
|
throw new ZlibException("No Deflate State!");
|
return dstate.SetParams(level, strategy);
|
}
|
|
|
/// <summary>
|
/// Set the dictionary to be used for either Inflation or Deflation.
|
/// </summary>
|
/// <param name="dictionary">The dictionary bytes to use.</param>
|
/// <returns>Z_OK if all goes well.</returns>
|
public int SetDictionary(byte[] dictionary)
|
{
|
if (istate != null)
|
return istate.SetDictionary(dictionary);
|
|
if (dstate != null)
|
return dstate.SetDictionary(dictionary);
|
|
throw new ZlibException("No Inflate or Deflate state!");
|
}
|
|
// Flush as much pending output as possible. All deflate() output goes
|
// through this function so some applications may wish to modify it
|
// to avoid allocating a large strm->next_out buffer and copying into it.
|
// (See also read_buf()).
|
internal void flush_pending()
|
{
|
int len = dstate.pendingCount;
|
|
if (len > AvailableBytesOut)
|
len = AvailableBytesOut;
|
if (len == 0)
|
return;
|
|
if (dstate.pending.Length <= dstate.nextPending ||
|
OutputBuffer.Length <= NextOut ||
|
dstate.pending.Length < (dstate.nextPending + len) ||
|
OutputBuffer.Length < (NextOut + len))
|
{
|
throw new ZlibException(String.Format("Invalid State. (pending.Length={0}, pendingCount={1})",
|
dstate.pending.Length, dstate.pendingCount));
|
}
|
|
Array.Copy(dstate.pending, dstate.nextPending, OutputBuffer, NextOut, len);
|
|
NextOut += len;
|
dstate.nextPending += len;
|
TotalBytesOut += len;
|
AvailableBytesOut -= len;
|
dstate.pendingCount -= len;
|
if (dstate.pendingCount == 0)
|
{
|
dstate.nextPending = 0;
|
}
|
}
|
|
// Read a new buffer from the current input stream, update the adler32
|
// and total number of bytes read. All deflate() input goes through
|
// this function so some applications may wish to modify it to avoid
|
// allocating a large strm->next_in buffer and copying from it.
|
// (See also flush_pending()).
|
internal int read_buf(byte[] buf, int start, int size)
|
{
|
int len = AvailableBytesIn;
|
|
if (len > size)
|
len = size;
|
if (len == 0)
|
return 0;
|
|
AvailableBytesIn -= len;
|
|
if (dstate.WantRfc1950HeaderBytes)
|
{
|
_Adler32 = Adler.Adler32(_Adler32, InputBuffer, NextIn, len);
|
}
|
Array.Copy(InputBuffer, NextIn, buf, start, len);
|
NextIn += len;
|
TotalBytesIn += len;
|
return len;
|
}
|
|
}
|
}
|
