public static int compress2(byte[] dest, ref int destLen, byte[] source, int sourceLen, int level)
{
z_stream_s stream = new z_stream_s();
int err = 0;
int max = int.MaxValue;
int left = destLen;
err = (int)Deflate.deflateInit_(stream, level, "1.2.11");
if (err != 0)
{
return(err);
}
stream.next_out = dest;
stream.avail_out = 0;
stream.next_in = source;
stream.avail_in = 0;
do
{
if (stream.avail_out == 0)
{
stream.avail_out = left > ((int)max) ? max : left;
left -= (int)stream.avail_out;
}
if (stream.avail_in == 0)
{
stream.avail_in = sourceLen > ((int)max) ? max : sourceLen;
sourceLen -= (int)stream.avail_in;
}
err = (int)Deflate.deflate(stream, sourceLen != 0 ? 0 : 4);
}while (err == 0);
destLen = stream.total_out;
Deflate.deflateEnd(stream);
return(err == 1 ? 0 : err);
}
public int deflate(int flush)
{
if (dstate == null)
{
return(Z_STREAM_ERROR);
}
return(dstate.deflate(this, flush));
}
/// <summary>
/// <para>Deflate compresses as much data as possible, and stops when the <see cref="next_in">input buffer</see> becomes empty or the
/// <see cref="next_out">output buffer</see> becomes full. It may introduce some output latency (reading input without producing any output)
/// except when forced to flush.</para>
/// <para>The detailed semantics are as follows. deflate performs one or both of the following actions:
/// <list type="bullet">
/// <item>Compress more input starting at <see cref="next_in" /> and update <see cref="next_in" /> and <see cref="avail_in" /> accordingly.
/// If not all input can be processed (because there is not enough room in the output buffer), <see cref="next_in" /> and <see cref="avail_in" />
/// are updated and processing will resume at this point for the next call of <see cref="deflate" />. </item>
/// <item>Provide more output starting at <see cref="next_out" /> and update <see cref="next_out" /> and <see cref="avail_out" /> accordingly.
/// This action is forced if the parameter flush is non zero. Forcing flush frequently degrades the compression ratio, so this parameter should
/// be set only when necessary (in interactive applications). Some output may be provided even if flush is not set.</item>
/// </list>
/// </para>
/// </summary>
/// <param name="flush">The <see cref="FlushStrategy">flush strategy</see> to use.</param>
/// <remarks>
/// <para>
/// Before the call of <seec ref="deflate" />, the application should ensure that at least one of the actions is possible, by providing
/// more input and/or consuming more output, and updating <see cref="avail_in" /> or <see cref="avail_out" /> accordingly ; <see cref="avail_out" />
/// should never be zero before the call. The application can consume the compressed output when it wants, for example when the output buffer is full
/// (<c>avail_out == 0</c>), or after each call of <see cref="deflate" />. If <see cref="deflate" /> returns <see cref="ZLibResultCode.Z_OK" />
/// and with zero <see cref="avail_out" />, it must be called again after making room in the output buffer because there might be more output pending.
/// </para>
/// <para>
/// If the parameter <paramref name="flush"/> is set to <see cref="FlushStrategy.Z_SYNC_FLUSH" />, all pending output is flushed to the
/// <see cref="next_out">output buffer</see> and the output is aligned on a byte boundary, so that the decompressor can get all input
/// data available so far. (In particular <see cref="avail_in" /> is zero after the call if enough output space has been provided before the call.)
/// Flushing may degrade compression for some compression algorithms and so it should be used only when necessary.
/// </para>
/// <para>
/// If flush is set to <see cref="FlushStrategy.Z_FULL_FLUSH" />, all output is flushed as with <see cref="FlushStrategy.Z_SYNC_FLUSH" />,
/// and the compression state is reset so that decompression can restart from this point if previous compressed data has been damaged or if
/// random access is desired. Using <see cref="FlushStrategy.Z_FULL_FLUSH" /> too often can seriously degrade the compression.
/// </para>
/// </remarks>
/// <returns>
/// <para>
/// If deflate returns with <c><see cref="avail_out" /> == 0</c>, this function must be called again with the same value of the flush
/// parameter and more output space (updated <see cref="avail_out" />), until the flush is complete (<see cref="deflate" /> returns with
/// non-zero <see cref="avail_out" />).
/// </para>
/// <para>
/// If the parameter <paramref name="flush"/> is set to <see cref="FlushStrategy.Z_FINISH" />, pending input is processed, pending
/// output is flushed and deflate returns with <see cref="ZLibResultCode.Z_STREAM_END" /> if there was enough output space ;
/// if deflate returns with <see cref="ZLibResultCode.Z_OK" />, this function must be called again with <see cref="FlushStrategy.Z_FINISH" />
/// and more output space (updated <see cref="avail_out" />) but no more input data, until it returns with <see cref="ZLibResultCode.Z_STREAM_END" />
/// or an error. After deflate has returned <see cref="ZLibResultCode.Z_STREAM_END" />, the only possible operation on the stream is
/// <see cref="deflateEnd" />. </para>
/// <para>
/// <see cref="FlushStrategy.Z_FINISH" /> can be used immediately after <see cref="DeflateInit(int)" /> if all the compression is to be
/// done in a single step. In this case, avail_out must be at least 0.1% larger than avail_in plus 12 bytes. If deflate does not return
/// Z_STREAM_END, then it must be called again as described above.
/// </para>
/// <para>
/// <see cref="deflate" /> sets strm-> adler to the adler32 checksum of all input read so far (that is, <see cref="total_in" /> bytes).
/// </para>
/// <para>
/// <see cref="deflate" /> may update data_type if it can make a good guess about the input data type (<see cref="BlockType">Z_ASCII or Z_BINARY</see>).
/// In doubt, the data is considered binary. This field is only for information purposes and does not affect the compression algorithm in any manner.
/// </para>
/// <para>
/// <see cref="deflate" /> returns <see cref="ZLibResultCode.Z_OK" /> if some progress has been made (more input processed or more output produced),
/// <see cref="ZLibResultCode.Z_STREAM_END" /> if all input has been consumed and all output has been produced (only when flush is set to
/// <see cref="FlushStrategy.Z_FINISH" />), <see cref="ZLibResultCode.Z_STREAM_ERROR" /> if the stream state was inconsistent (for example if
/// <see cref="next_in" /> or <see cref="next_out" /> was <c>null</c>), <see cref="ZLibResultCode.Z_BUF_ERROR" /> if no progress is possible
/// (for example <see cref="avail_in" /> or <see cref="avail_out" /> was zero).
/// </para>
/// </returns>
public int deflate(FlushStrategy flush)
{
if (_dstate == null)
{
return((int)ZLibResultCode.Z_STREAM_ERROR);
}
return(_dstate.deflate(this, flush));
}
public int deflate(int flush)
{
if (dstate == null)
{
return(-2);
}
return(dstate.deflate(this, flush));
}
public int Deflate(int flush)
{
if (Dstate == null)
{
return(ZStreamError);
}
return(Dstate.deflate(this, flush));
}
public int deflate(int flush)
{
return(dstate == null ? Z_STREAM_ERROR : dstate.deflate(this, flush));
}