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);
        }
Beispiel #2
0
 public int deflate(int flush)
 {
     if (dstate == null)
     {
         return(Z_STREAM_ERROR);
     }
     return(dstate.deflate(this, flush));
 }
Beispiel #3
0
 /// <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));
 }
Beispiel #6
0
 public int deflate(int flush)
 {
     return(dstate == null ? Z_STREAM_ERROR : dstate.deflate(this, flush));
 }