/* * /// <summary>Reset a codec for another deflation session.</summary> * /// <remarks>Call this to reset the deflation state. For example if a thread is deflatingnon-consecutive blocks, you can call Reset() after the Deflate(Sync) of the first block and before the nextDeflate(None) of the second block.</remarks> * public void ResetDeflate() * { * if (this.Dstate == null) * { * throw new ZlibException("No Deflate State!"); * } * * this.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 (this.Dstate == null) * { * throw new ZlibException("No Deflate State!"); * } * * return this.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 (this.Istate != null) * { * return this.Istate.SetDictionary(dictionary); * } * * if (this.Dstate != null) * { * return this.Dstate.SetDictionary(dictionary); * } * * throw new ZlibException("No Inflate or Deflate state!"); * } */ // 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()). /// <param name="buf"></param><param name="start"></param> <param name="size"></param><returns></returns> internal int ReadBuf(byte[] buf, int start, int size) { int len = this.AvailableBytesIn; if (len > size) { len = size; } if (len == 0) { return(0); } this.AvailableBytesIn -= len; if (this.Dstate.WantRfc1950HeaderBytes) { this.Adler32 = Adler.Adler32(this.Adler32, this.InputBuffer, this.NextIn, len); } Array.Copy(this.InputBuffer, this.NextIn, buf, start, len); this.NextIn += len; this.TotalBytesIn += len; return(len); }
/// <returns> /// </returns> internal uint Reset() { uint oldCheck = this.check; this.mode = InflateBlockMode.Type; this.Bitk = 0; this.Bitb = 0; this.ReadAt = this.WriteAt = 0; if (this.checkfn != null) { this.Codec.Adler32 = this.check = Adler.Adler32(0, null, 0, 0); } return(oldCheck); }
// 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); }
/// <param name="r"> /// </param><returns></returns> internal int Flush(int r) { for (int pass = 0; pass < 2; pass++) { int bytes; if (pass == 0) { // compute number of bytes to copy as far as end of window bytes = (this.ReadAt <= this.WriteAt ? this.WriteAt : this.End) - this.ReadAt; } else { // compute bytes to copy bytes = this.WriteAt - this.ReadAt; } // workitem 8870 if (bytes == 0) { if (r == ZlibConstants.ZBufError) { r = ZlibConstants.Zok; } return(r); } if (bytes > this.Codec.AvailableBytesOut) { bytes = this.Codec.AvailableBytesOut; } if (bytes != 0 && r == ZlibConstants.ZBufError) { r = ZlibConstants.Zok; } // update counters this.Codec.AvailableBytesOut -= bytes; this.Codec.TotalBytesOut += bytes; // update check information if (this.checkfn != null) { this.Codec.Adler32 = this.check = Adler.Adler32(this.check, this.Window, this.ReadAt, bytes); } // copy as far as end of window Array.Copy(this.Window, this.ReadAt, this.Codec.OutputBuffer, this.Codec.NextOut, bytes); this.Codec.NextOut += bytes; this.ReadAt += bytes; // see if more to copy at beginning of window if (this.ReadAt == this.End && pass == 0) { // wrap pointers this.ReadAt = 0; if (this.WriteAt == this.End) { this.WriteAt = 0; } } else { pass++; } } // done return(r); }