public int Inflate(FlushType flush)
{
if (this.istate == null)
throw new ZlibException("No Inflate State!");
else
return this.istate.Inflate(flush);
}
private static byte[] ZlibCodecDecompress(byte[] data)
{
int buffer_size = 0x800;
byte[] buffer = new byte[buffer_size];
bool flag = false;
using (MemoryStream stream = new MemoryStream()) {
ZlibCodec codec = new ZlibCodec();
codec.InitializeInflate(flag);
codec.InputBuffer = data;
codec.AvailableBytesIn = data.Length;
codec.NextIn = 0;
codec.OutputBuffer = buffer;
FlushType[] typeArray1 = new FlushType[2];
typeArray1[1] = FlushType.Finish;
foreach (FlushType type in typeArray1)
{
int count = 0;
do
{
codec.AvailableBytesOut = buffer_size;
codec.NextOut = 0;
codec.Inflate(type);
count = buffer_size - codec.AvailableBytesOut;
if (count > 0)
{
stream.Write(buffer, 0, count);
}
}while (((type == FlushType.None) && ((codec.AvailableBytesIn != 0) || (codec.AvailableBytesOut == 0))) || ((type == FlushType.Finish) && (count != 0)));
}
codec.EndInflate();
return(stream.ToArray());
}
}
private static void addHeaders(string fileName, long fileLength, object response, FlushType flushType)
{
var addHeader = response.GetType().GetMethod("AddHeader");
addHeader.Invoke(response, new object[] { "Content-Length", fileLength.ToString(CultureInfo.InvariantCulture) });
var contentDisposition = flushType == FlushType.Inline ? "inline;filename=" : "attachment;filename=";
addHeader.Invoke(response, new object[] { "content-disposition", contentDisposition + fileName });
}
protected ZLibStatus inflate(FlushType f)
{
if (istate == null)
{
return(ZLibStatus.Z_STREAM_ERROR);
}
return(istate.inflate(this, f));
}
public ZLibStatus deflate(FlushType flush)
{
if (dstate == null)
{
return(ZLibStatus.Z_STREAM_ERROR);
}
return(dstate.deflate(this, flush));
}
public ZLibStatus deflate(FlushType flush)
{
if (dstate == null)
{
return ZLibStatus.Z_STREAM_ERROR;
}
return dstate.deflate(this, flush);
}
public ZOutputStream(Stream output, CompressionLevel level, bool nowrap)
: base()
{
this.FlushMode = FlushType.Z_PARTIAL_FLUSH;
this._output = output;
this.deflateInit(level, nowrap);
this.compress = true;
}
public ZOutputStream(Stream output)
: base()
{
this.FlushMode = FlushType.Z_PARTIAL_FLUSH;
this._output = output;
this.inflateInit();
this.compress = false;
}
internal BlockState method_24(FlushType A_0)
{
int num = 0xffff;
if (0xffff > (this.byte_0.Length - 5))
{
num = this.byte_0.Length - 5;
}
while (true)
{
if (this.int_44 <= 1)
{
this.method_27();
if ((this.int_44 == 0) && (A_0 == FlushType.None))
{
return(BlockState.NeedMore);
}
if (this.int_44 == 0)
{
this.method_23(A_0 == FlushType.Finish);
if (this.class1068_0.int_3 == 0)
{
if (A_0 != FlushType.Finish)
{
return(BlockState.NeedMore);
}
return(BlockState.FinishStarted);
}
if (A_0 != FlushType.Finish)
{
return(BlockState.BlockDone);
}
return(BlockState.FinishDone);
}
}
this.int_56 += this.int_44;
this.int_44 = 0;
int num2 = this.int_31 + num;
if ((this.int_56 == 0) || (this.int_56 >= num2))
{
this.int_44 = this.int_56 - num2;
this.int_56 = num2;
this.method_23(false);
if (this.class1068_0.int_3 == 0)
{
return(BlockState.NeedMore);
}
}
if ((this.int_56 - this.int_31) >= (this.int_59 - int_25))
{
this.method_23(false);
if (this.class1068_0.int_3 == 0)
{
return(BlockState.NeedMore);
}
}
}
}
/// <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>
internal int Deflate(FlushType flush)
{
if (this.Dstate == null)
{
throw new ZlibException("No Deflate State!");
}
return(this.Dstate.Deflate(flush));
}
public virtual void vmethod_1(FlushType A_0)
{
int num = 0x12;
if (this.bool_0)
{
throw new ObjectDisposedException(BookmarkStart.b("户嘹唻尽ጿ㙁㙃⍅⥇❉", num));
}
this.stream9_0.flushType_0 = A_0;
}
public virtual void vmethod_1(FlushType A_0)
{
int num = 1;
if (this.bool_0)
{
throw new ObjectDisposedException(BookmarkStart.b("挦䰨䴪䄬丮䔰嘲昴䌶䬸帺尼刾", num));
}
this.stream9_0.flushType_0 = A_0;
}
public int method_5(FlushType A_0)
{
int num = 15;
if (this.class609_0 == null)
{
throw new Exception0(BookmarkStart.b("笴堶ᤸ爺匼夾ⵀ≂ㅄ≆楈ᡊ㥌⹎═㙒瑔", num));
}
return(this.class609_0.method_5(A_0));
}
public int method_14(FlushType A_0)
{
int num = 5;
if (this.class935_0 == null)
{
throw new Exception0(BookmarkStart.b("攪䈬༮田嘲匴嬶堸伺堼Ἶቀ㝂⑄㍆ⱈ橊", num));
}
return(this.class935_0.method_39(A_0));
}
internal FileLogConfig()
{
this.Extension = "log";
this.LogMode = FileLogMode.SingleFile;
this.LogNameFormat = "yyyy-MM-dd hh-mm-ss";
this.Path = "SeeSharpLog.log";
this.MaxLogSize = 100000000L;
this.Encode = Encoding.Unicode;
this.Flush = FlushType.SyncFlush;
}
public ZlibBaseStream(Stream stream, ZlibStreamFlavor flavor, bool leaveOpen)
{
this._flushMode = FlushType.None;
this._stream = stream;
this._leaveOpen = leaveOpen;
this._flavor = flavor;
if (flavor != ZlibStreamFlavor.GZIP)
return;
this.crc = new Crc32();
}
public ZlibBaseStream( Stream stream,
CompressionMode compressionMode,
CompressionLevel level,
bool leaveOpen)
: base()
{
this.flushMode = FlushType.None;
this.stream = stream;
this.leaveOpen = leaveOpen;
this.compressionMode = compressionMode;
this.level = level;
}
/// <summary>
/// 使用指定的流, CompressionLevel 值和 CompressionMode 值以及一个指定是否将流保留为打开状态的值，初始化 <see cref="Py.Zip.Zlib.ZipBaseStream"/> 的新实例。
/// </summary>
/// <param name="stream">要解压或压缩缩的流。</param>
/// <param name="compressionMode">指示当前操作是解压或压缩。</param>
/// <param name="leaveOpen">true 将流保留为打开状态，否则为 false。</param>
/// <param name="level">使用的解压等级。</param>
/// <exception cref="ArgumentNullException"><paramref name="stream"/> 为 null。</exception>
/// <exception cref="InvalidOperationException"><paramref name="stream"/> 访问权限为 ReadOnly，mode 值为 Compress。</exception>
public ZipBaseStream(Stream stream, CompressionMode compressionMode, CompressionLevel level, bool leaveOpen)
: base()
{
Thrower.ThrowArgumentNullExceptionIf(stream, "stream");
Thrower.ThrowInvalidOperationExceptionIf(!stream.CanWrite && compressionMode == CompressionMode.Compress, "当前流不可写");
_flushMode = FlushType.None;
//_workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
_stream = stream;
_leaveOpen = leaveOpen;
_compressionMode = compressionMode;
_level = level;
_isGZip = this is GZipStream;
}
public Stream0(Stream stream, System.IO.Compression.Zlib.CompressionMode compressionMode, CompressionLevel level, Enum4 flavor, bool leaveOpen)
{
this.flushType_0 = FlushType.None;
this.stream_0 = stream;
this.bool_0 = leaveOpen;
this.compressionMode_0 = compressionMode;
this.enum4_0 = flavor;
this.compressionLevel_0 = level;
if (flavor == Enum4.const_2)
{
this.CRC32 = new CRC32();
}
}
internal BlockState DeflateNone(FlushType flush)
{
int num = 0xffff;
if (num > (this.pending.Length - 5))
{
num = this.pending.Length - 5;
}
Label_0021:
if (this.lookahead <= 1)
{
this._fillWindow();
if ((this.lookahead == 0) && (flush == FlushType.None))
{
return(BlockState.NeedMore);
}
if (this.lookahead == 0)
{
this.flush_block_only(flush == FlushType.Finish);
if (this._codec.AvailableBytesOut == 0)
{
return((flush != FlushType.Finish) ? BlockState.NeedMore : BlockState.FinishStarted);
}
return((flush != FlushType.Finish) ? BlockState.BlockDone : BlockState.FinishDone);
}
}
this.strstart += this.lookahead;
this.lookahead = 0;
int num2 = this.block_start + num;
if ((this.strstart == 0) || (this.strstart >= num2))
{
this.lookahead = this.strstart - num2;
this.strstart = num2;
this.flush_block_only(false);
if (this._codec.AvailableBytesOut == 0)
{
return(BlockState.NeedMore);
}
}
if ((this.strstart - this.block_start) < (this.w_size - MIN_LOOKAHEAD))
{
goto Label_0021;
}
this.flush_block_only(false);
if (this._codec.AvailableBytesOut != 0)
{
goto Label_0021;
}
return(BlockState.NeedMore);
}
public ZlibBaseStream(System.IO.Stream stream, ZlibStreamFlavor flavor, bool leaveOpen)
: base()
{
this._flushMode = FlushType.None;
//this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
this._stream = stream;
this._leaveOpen = leaveOpen;
this._flavor = flavor;
// workitem 7159
if (flavor == ZlibStreamFlavor.GZIP)
{
crc = new CRC32();
}
}
public ZlibBaseStream(System.IO.Stream stream, ZlibStreamFlavor flavor, bool leaveOpen)
: base()
{
this._flushMode = FlushType.None;
//this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
this._stream = stream;
this._leaveOpen = leaveOpen;
this._flavor = flavor;
// workitem 7159
if (flavor == ZlibStreamFlavor.GZIP)
{
crc = new CRC32();
}
}
public ZlibBaseStream(Stream stream, CompressionMode compressionMode, CompressionLevel level, ZlibStreamFlavor flavor, bool leaveOpen)
{
this._flushMode = FlushType.None;
this._stream = stream;
this._leaveOpen = leaveOpen;
this._compressionMode = compressionMode;
this._flavor = flavor;
this._level = level;
if (flavor != ZlibStreamFlavor.GZIP)
{
return;
}
this.crc = new CRC32();
}
/// <summary>
/// Flushes the fileData into the user's browser.
/// It's designed for the ASP.NET Applications.
/// </summary>
/// <param name="fileName">name of the file</param>
/// <param name="fileData">byte array containing the file's data</param>
/// <param name="flushType">How to flush an in memory PDF file</param>
public static void FlushInBrowser(string fileName, byte[] fileData, FlushType flushType = FlushType.Attachment)
{
var fileLength = fileData.Length;
var context = getCurrentHttpContext();
var response = getCurrentResponse(context);
setNoCache(response);
setContentType(response);
addHeaders(fileName, fileLength, response, flushType);
setBufferTrue(response);
clearResponse(response);
writeToOutputStream(fileData, fileLength, response);
responseEnd(response);
}
public ZlibBaseStream(System.IO.Stream stream,
CompressionMode compressionMode,
CompressionLevel level,
bool leaveOpen)
: base()
{
this._flushMode = FlushType.None;
//this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
this._stream = stream;
this._leaveOpen = leaveOpen;
this._compressionMode = compressionMode;
this._level = level;
// workitem 7159
}
public ZlibBaseStream(Stream stream, CompressionMode compressionMode, CompressionLevel level, ZlibStreamFlavor flavor, bool leaveOpen)
{
_flushMode = FlushType.None;
//this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
_stream = stream;
_leaveOpen = leaveOpen;
_compressionMode = compressionMode;
_flavor = flavor;
_level = level;
// workitem 7159
if (flavor == ZlibStreamFlavor.GZIP)
{
crc = new Crc.CRC32();
}
}
public ZlibBaseStream(Stream stream,
CompressionMode compressionMode,
CompressionLevel level,
ZlibStreamFlavor flavor,
bool leaveOpen)
{
this._flushMode = FlushType.None;
//this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
this._stream = stream;
this._leaveOpen = leaveOpen;
this._compressionMode = compressionMode;
this._flavor = flavor;
this._level = level;
// workitem 7159
if (flavor == ZlibStreamFlavor.GZIP) {
this.crc = new CRC32();
}
}
public ZlibBaseStream(System.IO.Stream stream,
CompressionMode compressionMode,
CompressionLevel level,
ZlibStreamFlavor flavor,
bool leaveOpen,
int windowBits)
: base()
{
this._flushMode = FlushType.None;
//this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
this._stream = stream;
this._leaveOpen = leaveOpen;
this._compressionMode = compressionMode;
this._flavor = flavor;
this._level = level;
this.windowBitsMax = windowBits;
// workitem 7159
if (flavor == ZlibStreamFlavor.GZIP)
{
this.crc = new BestHTTP.Decompression.Crc.CRC32();
}
}
public ZLibStatus inflate(FlushType ff)
{
ZLibStatus r;
int b;
if (base.next_in == null)
return ZLibStatus.Z_STREAM_ERROR;
var f = ff == FlushType.Z_FINISH ? ZLibStatus.Z_BUF_ERROR : ZLibStatus.Z_OK;
r = ZLibStatus.Z_BUF_ERROR;
while (true)
{
//System.out.println("mode: "+this.mode);
switch (this._mode)
{
case InflateMode.METHOD:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
if (((this.method = base.next_in[base.next_in_index++]) & 0xf) != Z_DEFLATED)
{
this._mode = InflateMode.BAD;
base.msg = "unknown compression method";
this._marker = 5; // can't try inflateSync
break;
}
if ((this.method >> 4) + 8 > this._wbits)
{
this._mode = InflateMode.BAD;
base.msg = "invalid window size";
this._marker = 5; // can't try inflateSync
break;
}
this._mode = InflateMode.FLAG;
goto case InflateMode.FLAG;
case InflateMode.FLAG:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
b = (base.next_in[base.next_in_index++]) & 0xff;
if ((((this.method << 8) + b) % 31) != 0)
{
this._mode = InflateMode.BAD;
base.msg = "incorrect header check";
this._marker = 5; // can't try inflateSync
break;
}
if ((b & PRESET_DICT) == 0)
{
this._mode = InflateMode.BLOCKS;
break;
}
this._mode = InflateMode.DICT4;
goto case InflateMode.DICT4;
case InflateMode.DICT4:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need = ((base.next_in[base.next_in_index++] & 0xff) << 24) & 0xff000000L;
this._mode = InflateMode.DICT3;
goto case InflateMode.DICT3;
case InflateMode.DICT3:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need += ((base.next_in[base.next_in_index++] & 0xff) << 16) & 0xff0000L;
this._mode = InflateMode.DICT2;
goto case InflateMode.DICT2;
case InflateMode.DICT2:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need += ((base.next_in[base.next_in_index++] & 0xff) << 8) & 0xff00L;
this._mode = InflateMode.DICT1;
goto case InflateMode.DICT1;
case InflateMode.DICT1:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need += (base.next_in[base.next_in_index++] & 0xffL);
base.adler = this._need;
this._mode = InflateMode.DICT0;
return ZLibStatus.Z_NEED_DICT;
case InflateMode.DICT0:
this._mode = InflateMode.BAD;
base.msg = "need dictionary";
this._marker = 0; // can try inflateSync
return ZLibStatus.Z_STREAM_ERROR;
case InflateMode.BLOCKS:
r = this._blocks.proc(this, r);
if (r == ZLibStatus.Z_DATA_ERROR)
{
this._mode = InflateMode.BAD;
this._marker = 0; // can try inflateSync
break;
}
if (r == ZLibStatus.Z_OK)
{
r = f;
}
if (r != ZLibStatus.Z_STREAM_END)
{
return r;
}
r = f;
this._blocks.reset(this, this._was);
if (this._nowrap != 0)
{
this._mode = InflateMode.DONE;
break;
}
this._mode = InflateMode.CHECK4;
goto case InflateMode.CHECK4;
case InflateMode.CHECK4:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need = ((base.next_in[base.next_in_index++] & 0xff) << 24) & 0xff000000L;
this._mode = InflateMode.CHECK3;
goto case InflateMode.CHECK3;
case InflateMode.CHECK3:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need += ((base.next_in[base.next_in_index++] & 0xff) << 16) & 0xff0000L;
this._mode = InflateMode.CHECK2;
goto case InflateMode.CHECK2;
case InflateMode.CHECK2:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need += ((base.next_in[base.next_in_index++] & 0xff) << 8) & 0xff00L;
this._mode = InflateMode.CHECK1;
goto case InflateMode.CHECK1;
case InflateMode.CHECK1:
if (base.avail_in == 0) return r; r = f;
base.avail_in--; base.total_in++;
this._need += (base.next_in[base.next_in_index++] & 0xffL);
if (((int)(this._was[0])) != ((int)(this._need)))
{
this._mode = InflateMode.BAD;
base.msg = "incorrect data check";
this._marker = 5; // can't try inflateSync
break;
}
this._mode = InflateMode.DONE;
goto case InflateMode.DONE;
case InflateMode.DONE:
return ZLibStatus.Z_STREAM_END;
case InflateMode.BAD:
return ZLibStatus.Z_DATA_ERROR;
default:
return ZLibStatus.Z_STREAM_ERROR;
}
}
}
public ZLibStatus inflate(byte[] inputBufer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset, int outputCount, FlushType flushType)
{
this.next_in = inputBufer;
this.next_in_index = inputOffset;
this.avail_in = inputCount;
this.next_out = outputBuffer;
this.next_out_index = outputOffset;
this.avail_out = outputCount;
return this.inflate(flushType);
}
public ZInputStream()
{
this.FlushMode = FlushType.Z_PARTIAL_FLUSH;
}
public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count)
{
// According to MS documentation, any implementation of the IO.Stream.Read function must:
// (a) throw an exception if offset & count reference an invalid part of the buffer,
// or if count < 0, or if buffer is null
// (b) return 0 only upon EOF, or if count = 0
// (c) if not EOF, then return at least 1 byte, up to <count> bytes
if (_streamMode == StreamMode.Undefined)
{
if (!this._stream.CanRead) throw new ZlibException("The stream is not readable.");
// for the first read, set up some controls.
_streamMode = StreamMode.Reader;
// (The first reference to _z goes through the private accessor which
// may initialize it.)
z.AvailableBytesIn = 0;
if (_flavor == ZlibStreamFlavor.GZIP)
{
_gzipHeaderByteCount = _ReadAndValidateGzipHeader();
// workitem 8501: handle edge case (decompress empty stream)
if (_gzipHeaderByteCount == 0)
return 0;
}
}
if (_streamMode != StreamMode.Reader)
throw new ZlibException("Cannot Read after Writing.");
if (count == 0) return 0;
// workitem 10562
// this quits too early if the input buffer has been consumed but
// there's still output which hasn't been created yet (e.g. block
// data for tables / tree, or the trailing adler32 data). we
// need to wait for a Z_STREAM_END from Deflate instead.
//if (nomoreinput && _wantCompress) return 0; // workitem 8557
if (buffer == null) throw new ArgumentNullException("buffer");
if (count < 0) throw new ArgumentOutOfRangeException("count");
if (offset < buffer.GetLowerBound(0)) throw new ArgumentOutOfRangeException("offset");
if ((offset + count) > buffer.GetLength(0)) throw new ArgumentOutOfRangeException("count");
int rc = 0;
// set up the output of the deflate/inflate codec:
_z.OutputBuffer = buffer;
_z.NextOut = offset;
_z.AvailableBytesOut = count;
// This is necessary in case _workingBuffer has been resized. (new byte[])
// (The first reference to _workingBuffer goes through the private accessor which
// may initialize it.)
_z.InputBuffer = workingBuffer;
do
{
// need data in _workingBuffer in order to deflate/inflate. Here, we check if we have any.
if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
{
// No data available, so try to Read data from the captive stream.
_z.NextIn = 0;
_z.AvailableBytesIn = _stream.Read(_workingBuffer, 0, _workingBuffer.Length);
if (_z.AvailableBytesIn == 0)
nomoreinput = true;
}
// workitem 10562
// if we've consumed all the input then we need to generate any
// remaining block data and checksums and put them in the pending array
if (nomoreinput) _flushMode = FlushType.Finish;
// we have data in InputBuffer; now compress or decompress as appropriate
rc = (_wantCompress)
? _z.Deflate(_flushMode)
: _z.Inflate(_flushMode);
if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
return 0;
if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
throw new ZlibException(String.Format("{0}flating: rc={1} msg={2}", (_wantCompress ? "de" : "in"), rc, _z.Message));
if ((nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
{
// workitem 10562
// we've genuinely reached the end of the output stream now,
// including any block data and adler32 which appears after
// the compressed input data. we don't have any more bytes
// to return so we can stop processing
return 0; // nothing more to read
};
}
//while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
//while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);
while (_z.AvailableBytesOut > 0 && rc == ZlibConstants.Z_OK);
// workitem 10562
// the following is no longer required as we now call _z.Deflate
// in the main loop above instead
//// workitem 8557
//// is there more room in output?
//if (_z.AvailableBytesOut > 0)
//{
// if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
// {
// // deferred
// }
//
// // are we completely done reading?
// if (nomoreinput)
// {
// // and in compression?
// if (_wantCompress)
// {
// // no more input data available; therefore we flush to
// // try to complete the read
// rc = _z.Deflate(FlushType.Finish);
//
// if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
// throw new ZlibException(String.Format("Deflating: rc={0} msg={1}", rc, _z.Message));
// }
// }
//}
rc = (count - _z.AvailableBytesOut);
// calculate CRC after reading
if (crc != null)
crc.SlurpBlock(buffer, offset, rc);
return rc;
}
public ZLibStatus deflate(byte[] bufer, int offset, int count, byte[] p1, int p2, int p3, FlushType flushType)
{
throw new NotImplementedException();
}
internal int Inflate(FlushType flush)
{
int r;
int b;
int f = (int)flush;
if (_codec.InputBuffer == null)
throw new ZlibException("InputBuffer is null. ");
f = (f == (int)FlushType.Finish)
? ZlibConstants.Z_BUF_ERROR
: ZlibConstants.Z_OK;
r = ZlibConstants.Z_BUF_ERROR;
while (true)
{
switch (mode)
{
case METHOD:
if (_codec.AvailableBytesIn == 0)
return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
if (((method = _codec.InputBuffer[_codec.NextIn++]) & 0xf) != Z_DEFLATED)
{
mode = BAD;
_codec.Message = String.Format("unknown compression method (0x{0:X2})", method);
marker = 5; // can't try inflateSync
break;
}
if ((method >> 4) + 8 > wbits)
{
mode = BAD;
_codec.Message = String.Format("invalid window size ({0})", (method >> 4) + 8);
marker = 5; // can't try inflateSync
break;
}
mode = FLAG;
goto case FLAG;
case FLAG:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
b = (_codec.InputBuffer[_codec.NextIn++]) & 0xff;
if ((((method << 8) + b) % 31) != 0)
{
mode = BAD;
_codec.Message = "incorrect header check";
marker = 5; // can't try inflateSync
break;
}
if ((b & PRESET_DICT) == 0)
{
mode = BLOCKS;
break;
}
mode = DICT4;
goto case DICT4;
case DICT4:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
need = ((_codec.InputBuffer[_codec.NextIn++] & 0xff) << 24) & unchecked((int)0xff000000L);
mode = DICT3;
goto case DICT3;
case DICT3:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
need += (((_codec.InputBuffer[_codec.NextIn++] & 0xff) << 16) & 0xff0000L);
mode = DICT2;
goto case DICT2;
case DICT2:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
need += (((_codec.InputBuffer[_codec.NextIn++] & 0xff) << 8) & 0xff00L);
mode = DICT1;
goto case DICT1;
case DICT1:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
need += (_codec.InputBuffer[_codec.NextIn++] & 0xffL);
_codec._Adler32 = need;
mode = DICT0;
return ZlibConstants.Z_NEED_DICT;
case DICT0:
mode = BAD;
_codec.Message = "need dictionary";
marker = 0; // can try inflateSync
return ZlibConstants.Z_STREAM_ERROR;
case BLOCKS:
r = blocks.Process(r);
if (r == ZlibConstants.Z_DATA_ERROR)
{
mode = BAD;
marker = 0; // can try inflateSync
break;
}
if (r == ZlibConstants.Z_OK) r = f;
if (r != ZlibConstants.Z_STREAM_END) return r;
r = f;
blocks.Reset(was);
if (!HandleRfc1950HeaderBytes)
{
mode = DONE;
break;
}
mode = CHECK4;
goto case CHECK4;
case CHECK4:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
need = ((_codec.InputBuffer[_codec.NextIn++] & 0xff) << 24) & unchecked((int)0xff000000L);
mode = CHECK3;
goto case CHECK3;
case CHECK3:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
need += (((_codec.InputBuffer[_codec.NextIn++] & 0xff) << 16) & 0xff0000L);
mode = CHECK2;
goto case CHECK2;
case CHECK2:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
need += (((_codec.InputBuffer[_codec.NextIn++] & 0xff) << 8) & 0xff00L);
mode = CHECK1;
goto case CHECK1;
case CHECK1:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
need += (_codec.InputBuffer[_codec.NextIn++] & 0xffL);
unchecked
{
if (((int)(was[0])) != ((int)(need)))
{
mode = BAD;
_codec.Message = "incorrect data check";
marker = 5; // can't try inflateSync
break;
}
}
mode = DONE;
goto case DONE;
case DONE:
return ZlibConstants.Z_STREAM_END;
case BAD:
throw new ZlibException(String.Format("Bad state ({0})", _codec.Message));
//return ZlibConstants.Z_DATA_ERROR;
default:
throw new ZlibException("Stream error.");
//return ZlibConstants.Z_STREAM_ERROR;
}
}
}
private ZLibStatus deflateReset()
{
base.total_in = base.total_out = 0;
base.msg = null; //
base.data_type = BlockType.Z_UNKNOWN;
pending = 0;
pending_out = 0;
if (noheader < 0)
{
noheader = 0; // was set to -1 by deflate(..., FlushType.Z_FINISH);
}
_status = (noheader != 0) ? BUSY_STATE : INIT_STATE;
base.adler = Adler32.adler32(0, null, 0, 0);
last_flush = FlushType.Z_NO_FLUSH;
tr_init();
lm_init();
return ZLibStatus.Z_OK;
}
/// <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>
internal int Inflate(FlushType flush)
{
if (istate == null)
throw new ZlibException("No Inflate State!");
return istate.Inflate(flush);
}
///<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);
}
internal int Deflate(FlushType flush)
{
int old_flush;
if (_codec.OutputBuffer == null ||
(_codec.InputBuffer == null && _codec.AvailableBytesIn != 0) ||
(status == FINISH_STATE && flush != FlushType.Finish))
{
_codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_STREAM_ERROR)];
throw new ZlibException(String.Format("Something is fishy. [{0}]", _codec.Message));
}
if (_codec.AvailableBytesOut == 0)
{
_codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
throw new ZlibException("OutputBuffer is full (AvailableBytesOut == 0)");
}
old_flush = last_flush;
last_flush = (int)flush;
// Write the zlib (rfc1950) header bytes
if (status == INIT_STATE)
{
int header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
int level_flags = (((int)compressionLevel - 1) & 0xff) >> 1;
if (level_flags > 3)
level_flags = 3;
header |= (level_flags << 6);
if (strstart != 0)
header |= PRESET_DICT;
header += 31 - (header % 31);
status = BUSY_STATE;
//putShortMSB(header);
unchecked
{
pending[pendingCount++] = (byte)(header >> 8);
pending[pendingCount++] = (byte)header;
}
// Save the adler32 of the preset dictionary:
if (strstart != 0)
{
pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
}
_codec._Adler32 = Adler.Adler32(0, null, 0, 0);
}
// Flush as much pending output as possible
if (pendingCount != 0)
{
_codec.flush_pending();
if (_codec.AvailableBytesOut == 0)
{
//System.out.println(" avail_out==0");
// Since avail_out is 0, deflate will be called again with
// more output space, but possibly with both pending and
// avail_in equal to zero. There won't be anything to do,
// but this is not an error situation so make sure we
// return OK instead of BUF_ERROR at next call of deflate:
last_flush = -1;
return ZlibConstants.Z_OK;
}
// Make sure there is something to do and avoid duplicate consecutive
// flushes. For repeated and useless calls with Z_FINISH, we keep
// returning Z_STREAM_END instead of Z_BUFF_ERROR.
}
else if (_codec.AvailableBytesIn == 0 &&
(int)flush <= old_flush &&
flush != FlushType.Finish)
{
// workitem 8557
//
// Not sure why this needs to be an error. pendingCount == 0, which
// means there's nothing to deflate. And the caller has not asked
// for a FlushType.Finish, but... that seems very non-fatal. We
// can just say "OK" and do nothing.
// _codec.Message = z_errmsg[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
// throw new ZlibException("AvailableBytesIn == 0 && flush<=old_flush && flush != FlushType.Finish");
return ZlibConstants.Z_OK;
}
// User must not provide more input after the first FINISH:
if (status == FINISH_STATE && _codec.AvailableBytesIn != 0)
{
_codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
throw new ZlibException("status == FINISH_STATE && _codec.AvailableBytesIn != 0");
}
// Start a new block or continue the current one.
if (_codec.AvailableBytesIn != 0 || lookahead != 0 || (flush != FlushType.None && status != FINISH_STATE))
{
BlockState bstate = DeflateFunction(flush);
if (bstate == BlockState.FinishStarted || bstate == BlockState.FinishDone)
{
status = FINISH_STATE;
}
if (bstate == BlockState.NeedMore || bstate == BlockState.FinishStarted)
{
if (_codec.AvailableBytesOut == 0)
{
last_flush = -1; // avoid BUF_ERROR next call, see above
}
return ZlibConstants.Z_OK;
// If flush != Z_NO_FLUSH && avail_out == 0, the next call
// of deflate should use the same flush parameter to make sure
// that the flush is complete. So we don't have to output an
// empty block here, this will be done at next call. This also
// ensures that for a very small output buffer, we emit at most
// one empty block.
}
if (bstate == BlockState.BlockDone)
{
if (flush == FlushType.Partial)
{
_tr_align();
}
else
{
// FlushType.Full or FlushType.Sync
_tr_stored_block(0, 0, false);
// For a full flush, this empty block will be recognized
// as a special marker by inflate_sync().
if (flush == FlushType.Full)
{
// clear hash (forget the history)
for (int i = 0; i < hash_size; i++)
head[i] = 0;
}
}
_codec.flush_pending();
if (_codec.AvailableBytesOut == 0)
{
last_flush = -1; // avoid BUF_ERROR at next call, see above
return ZlibConstants.Z_OK;
}
}
}
if (flush != FlushType.Finish)
return ZlibConstants.Z_OK;
if (!WantRfc1950HeaderBytes || Rfc1950BytesEmitted)
return ZlibConstants.Z_STREAM_END;
// Write the zlib trailer (adler32)
pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
//putShortMSB((int)(SharedUtils.URShift(_codec._Adler32, 16)));
//putShortMSB((int)(_codec._Adler32 & 0xffff));
_codec.flush_pending();
// If avail_out is zero, the application will call deflate again
// to flush the rest.
Rfc1950BytesEmitted = true; // write the trailer only once!
return pendingCount != 0 ? ZlibConstants.Z_OK : ZlibConstants.Z_STREAM_END;
}
// Compress as much as possible from the input stream, return the current
// block state.
// This function does not perform lazy evaluation of matches and inserts
// new strings in the dictionary only for unmatched strings or for short
// matches. It is used only for the fast compression options.
internal BlockState DeflateFast(FlushType flush)
{
// short hash_head = 0; // head of the hash chain
int hash_head = 0; // head of the hash chain
bool bflush; // set if current block must be flushed
while (true)
{
// Make sure that we always have enough lookahead, except
// at the end of the input file. We need MAX_MATCH bytes
// for the next match, plus MIN_MATCH bytes to insert the
// string following the next match.
if (lookahead < MIN_LOOKAHEAD)
{
_fillWindow();
if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
{
return BlockState.NeedMore;
}
if (lookahead == 0)
break; // flush the current block
}
// Insert the string window[strstart .. strstart+2] in the
// dictionary, and set hash_head to the head of the hash chain:
if (lookahead >= MIN_MATCH)
{
ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (head[ins_h] & 0xffff);
prev[strstart & w_mask] = head[ins_h];
head[ins_h] = unchecked((short)strstart);
}
// Find the longest match, discarding those <= prev_length.
// At this point we have always match_length < MIN_MATCH
if (hash_head != 0L && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
{
// To simplify the code, we prevent matches with the string
// of window index 0 (in particular we have to avoid a match
// of the string with itself at the start of the input file).
if (compressionStrategy != CompressionStrategy.HuffmanOnly)
{
match_length = longest_match(hash_head);
}
// longest_match() sets match_start
}
if (match_length >= MIN_MATCH)
{
// check_match(strstart, match_start, match_length);
bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH);
lookahead -= match_length;
// Insert new strings in the hash table only if the match length
// is not too large. This saves time but degrades compression.
if (match_length <= config.MaxLazy && lookahead >= MIN_MATCH)
{
match_length--; // string at strstart already in hash table
do
{
strstart++;
ins_h = ((ins_h << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (head[ins_h] & 0xffff);
prev[strstart & w_mask] = head[ins_h];
head[ins_h] = unchecked((short)strstart);
// strstart never exceeds WSIZE-MAX_MATCH, so there are
// always MIN_MATCH bytes ahead.
}
while (--match_length != 0);
strstart++;
}
else
{
strstart += match_length;
match_length = 0;
ins_h = window[strstart] & 0xff;
ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
// If lookahead < MIN_MATCH, ins_h is garbage, but it does not
// matter since it will be recomputed at next deflate call.
}
}
else
{
// No match, output a literal byte
bflush = _tr_tally(0, window[strstart] & 0xff);
lookahead--;
strstart++;
}
if (bflush)
{
flush_block_only(false);
if (_codec.AvailableBytesOut == 0)
return BlockState.NeedMore;
}
}
flush_block_only(flush == FlushType.Finish);
if (_codec.AvailableBytesOut == 0)
{
if (flush == FlushType.Finish)
return BlockState.FinishStarted;
else
return BlockState.NeedMore;
}
return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
}
public ZLibStatus deflate(FlushType flushType)
{
throw new NotImplementedException();
}
// Copy without compression as much as possible from the input stream, return
// the current block state.
// This function does not insert new strings in the dictionary since
// uncompressible data is probably not useful. This function is used
// only for the level=0 compression option.
// NOTE: this function should be optimized to avoid extra copying from
// window to pending_buf.
private int deflate_stored(FlushType flush)
{
// Stored blocks are limited to 0xffff bytes, pending_buf is limited
// to pending_buf_size, and each stored block has a 5 byte header:
int max_block_size = 0xffff;
int max_start;
if (max_block_size > _pendingBufferSize - 5)
{
max_block_size = _pendingBufferSize - 5;
}
// Copy as much as possible from input to output:
while (true)
{
// Fill the window as much as possible:
if (_validBytesAhead <= 1)
{
fill_window();
if (_validBytesAhead == 0 && flush == FlushType.Z_NO_FLUSH) return NeedMore;
if (_validBytesAhead == 0) break; // flush the current block
}
_startInsertString += _validBytesAhead;
_validBytesAhead = 0;
// Emit a stored block if pending_buf will be full:
max_start = _blockStart + max_block_size;
if (_startInsertString == 0 || _startInsertString >= max_start)
{
// strstart == 0 is possible when wraparound on 16-bit machine
_validBytesAhead = (int)(_startInsertString - max_start);
_startInsertString = (int)max_start;
flush_block_only(false);
if (base.avail_out == 0) return NeedMore;
}
// Flush if we may have to slide, otherwise block_start may become
// negative and the data will be gone:
if (_startInsertString - _blockStart >= _windowSize - MIN_LOOKAHEAD)
{
flush_block_only(false);
if (base.avail_out == 0) return NeedMore;
}
}
flush_block_only(flush == FlushType.Z_FINISH);
if (base.avail_out == 0)
return (flush == FlushType.Z_FINISH) ? FinishStarted : NeedMore;
return flush == FlushType.Z_FINISH ? FinishDone : BlockDone;
}
internal int Inflate(FlushType flush)
{
int b;
if (_codec.InputBuffer == null)
throw new ZlibException("InputBuffer is null. ");
// int f = (flush == FlushType.Finish)
// ? ZlibConstants.Z_BUF_ERROR
// : ZlibConstants.Z_OK;
// workitem 8870
int f = ZlibConstants.Z_OK;
int r = ZlibConstants.Z_BUF_ERROR;
while (true)
{
switch (mode)
{
case InflateManagerMode.METHOD:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
if (((method = _codec.InputBuffer[_codec.NextIn++]) & 0xf) != Z_DEFLATED)
{
mode = InflateManagerMode.BAD;
_codec.Message = String.Format("unknown compression method (0x{0:X2})", method);
marker = 5; // can't try inflateSync
break;
}
if ((method >> 4) + 8 > wbits)
{
mode = InflateManagerMode.BAD;
_codec.Message = String.Format("invalid window size ({0})", (method >> 4) + 8);
marker = 5; // can't try inflateSync
break;
}
mode = InflateManagerMode.FLAG;
break;
case InflateManagerMode.FLAG:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
b = (_codec.InputBuffer[_codec.NextIn++]) & 0xff;
if ((((method << 8) + b) % 31) != 0)
{
mode = InflateManagerMode.BAD;
_codec.Message = "incorrect header check";
marker = 5; // can't try inflateSync
break;
}
mode = ((b & PRESET_DICT) == 0)
? InflateManagerMode.BLOCKS
: InflateManagerMode.DICT4;
break;
case InflateManagerMode.DICT4:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
mode = InflateManagerMode.DICT3;
break;
case InflateManagerMode.DICT3:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
mode = InflateManagerMode.DICT2;
break;
case InflateManagerMode.DICT2:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
mode = InflateManagerMode.DICT1;
break;
case InflateManagerMode.DICT1:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
_codec._Adler32 = expectedCheck;
mode = InflateManagerMode.DICT0;
return ZlibConstants.Z_NEED_DICT;
case InflateManagerMode.DICT0:
mode = InflateManagerMode.BAD;
_codec.Message = "need dictionary";
marker = 0; // can try inflateSync
return ZlibConstants.Z_STREAM_ERROR;
case InflateManagerMode.BLOCKS:
r = blocks.Process(r);
if (r == ZlibConstants.Z_DATA_ERROR)
{
mode = InflateManagerMode.BAD;
marker = 0; // can try inflateSync
break;
}
if (r == ZlibConstants.Z_OK) r = f;
if (r != ZlibConstants.Z_STREAM_END)
return r;
r = f;
computedCheck = blocks.Reset();
if (!HandleRfc1950HeaderBytes)
{
mode = InflateManagerMode.DONE;
return ZlibConstants.Z_STREAM_END;
}
mode = InflateManagerMode.CHECK4;
break;
case InflateManagerMode.CHECK4:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
mode = InflateManagerMode.CHECK3;
break;
case InflateManagerMode.CHECK3:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
mode = InflateManagerMode.CHECK2;
break;
case InflateManagerMode.CHECK2:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--;
_codec.TotalBytesIn++;
expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
mode = InflateManagerMode.CHECK1;
break;
case InflateManagerMode.CHECK1:
if (_codec.AvailableBytesIn == 0) return r;
r = f;
_codec.AvailableBytesIn--; _codec.TotalBytesIn++;
expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
if (computedCheck != expectedCheck)
{
mode = InflateManagerMode.BAD;
_codec.Message = "incorrect data check";
marker = 5; // can't try inflateSync
break;
}
mode = InflateManagerMode.DONE;
return ZlibConstants.Z_STREAM_END;
case InflateManagerMode.DONE:
return ZlibConstants.Z_STREAM_END;
case InflateManagerMode.BAD:
throw new ZlibException(String.Format("Bad state ({0})", _codec.Message));
default:
throw new ZlibException("Stream error.");
}
}
}
// Compress as much as possible from the input stream, return the current
// block state.
// This function does not perform lazy evaluation of matches and inserts
// new strings in the dictionary only for unmatched strings or for short
// matches. It is used only for the fast compression options.
private int deflate_fast(FlushType flush)
{
// short hash_head = 0; // head of the hash chain
int hash_head = 0; // head of the hash chain
bool bflush; // set if current block must be flushed
while (true)
{
// Make sure that we always have enough lookahead, except
// at the end of the input file. We need MAX_MATCH bytes
// for the next match, plus MIN_MATCH bytes to insert the
// string following the next match.
if (_validBytesAhead < MIN_LOOKAHEAD)
{
fill_window();
if (_validBytesAhead < MIN_LOOKAHEAD && flush == FlushType.Z_NO_FLUSH)
{
return NeedMore;
}
if (_validBytesAhead == 0) break; // flush the current block
}
// Insert the string window[strstart .. strstart+2] in the
// dictionary, and set hash_head to the head of the hash chain:
if (_validBytesAhead >= MIN_MATCH)
{
_insertedHashIndex = (((_insertedHashIndex) << _hashShift) ^ (_window[(_startInsertString) + (MIN_MATCH - 1)] & 0xff)) & _hashMask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (_head[_insertedHashIndex] & 0xffff);
_previous[_startInsertString & _windowMask] = _head[_insertedHashIndex];
_head[_insertedHashIndex] = (short)_startInsertString;
}
// Find the longest match, discarding those <= prev_length.
// At this point we have always match_length < MIN_MATCH
if (hash_head != 0L &&
((_startInsertString - hash_head) & 0xffff) <= _windowSize - MIN_LOOKAHEAD
)
{
// To simplify the code, we prevent matches with the string
// of window index 0 (in particular we have to avoid a match
// of the string with itself at the start of the input file).
if (strategy != CompressionStrategy.Z_HUFFMAN_ONLY)
{
_matchLength = longest_match(hash_head);
}
// longest_match() sets match_start
}
if (_matchLength >= MIN_MATCH)
{
// check_match(strstart, match_start, match_length);
bflush = _tr_tally(_startInsertString - _startMatchString, _matchLength - MIN_MATCH);
_validBytesAhead -= _matchLength;
// Insert new strings in the hash table only if the match length
// is not too large. This saves time but degrades compression.
if (_matchLength <= _maxLazyMatch &&
_validBytesAhead >= MIN_MATCH)
{
_matchLength--; // string at strstart already in hash table
do
{
_startInsertString++;
_insertedHashIndex = ((_insertedHashIndex << _hashShift) ^ (_window[(_startInsertString) + (MIN_MATCH - 1)] & 0xff)) & _hashMask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (_head[_insertedHashIndex] & 0xffff);
_previous[_startInsertString & _windowMask] = _head[_insertedHashIndex];
_head[_insertedHashIndex] = (short)_startInsertString;
// strstart never exceeds WSIZE-MAX_MATCH, so there are
// always MIN_MATCH bytes ahead.
}
while (--_matchLength != 0);
_startInsertString++;
}
else
{
_startInsertString += _matchLength;
_matchLength = 0;
_insertedHashIndex = _window[_startInsertString] & 0xff;
_insertedHashIndex = (((_insertedHashIndex) << _hashShift) ^ (_window[_startInsertString + 1] & 0xff)) & _hashMask;
// If lookahead < MIN_MATCH, ins_h is garbage, but it does not
// matter since it will be recomputed at next deflate call.
}
}
else
{
// No match, output a literal byte
bflush = _tr_tally(0, _window[_startInsertString] & 0xff);
_validBytesAhead--;
_startInsertString++;
}
if (bflush)
{
flush_block_only(false);
if (base.avail_out == 0) return NeedMore;
}
}
flush_block_only(flush == FlushType.Z_FINISH);
if (base.avail_out == 0)
{
if (flush == FlushType.Z_FINISH) return FinishStarted;
else return NeedMore;
}
return flush == FlushType.Z_FINISH ? FinishDone : BlockDone;
}
// Same as above, but achieves better compression. We use a lazy
// evaluation for matches: a match is finally adopted only if there is
// no better match at the next window position.
internal BlockState DeflateSlow(FlushType flush)
{
// short hash_head = 0; // head of hash chain
int hash_head = 0; // head of hash chain
bool bflush; // set if current block must be flushed
// Process the input block.
while (true)
{
// Make sure that we always have enough lookahead, except
// at the end of the input file. We need MAX_MATCH bytes
// for the next match, plus MIN_MATCH bytes to insert the
// string following the next match.
if (lookahead < MIN_LOOKAHEAD)
{
_fillWindow();
if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
return BlockState.NeedMore;
if (lookahead == 0)
break; // flush the current block
}
// Insert the string window[strstart .. strstart+2] in the
// dictionary, and set hash_head to the head of the hash chain:
if (lookahead >= MIN_MATCH)
{
ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (head[ins_h] & 0xffff);
prev[strstart & w_mask] = head[ins_h];
head[ins_h] = unchecked((short)strstart);
}
// Find the longest match, discarding those <= prev_length.
prev_length = match_length;
prev_match = match_start;
match_length = MIN_MATCH - 1;
if (hash_head != 0 && prev_length < config.MaxLazy &&
((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
{
// To simplify the code, we prevent matches with the string
// of window index 0 (in particular we have to avoid a match
// of the string with itself at the start of the input file).
if (compressionStrategy != CompressionStrategy.HuffmanOnly)
{
match_length = longest_match(hash_head);
}
// longest_match() sets match_start
if (match_length <= 5 && (compressionStrategy == CompressionStrategy.Filtered ||
(match_length == MIN_MATCH && strstart - match_start > 4096)))
{
// If prev_match is also MIN_MATCH, match_start is garbage
// but we will ignore the current match anyway.
match_length = MIN_MATCH - 1;
}
}
// If there was a match at the previous step and the current
// match is not better, output the previous match:
if (prev_length >= MIN_MATCH && match_length <= prev_length)
{
int max_insert = strstart + lookahead - MIN_MATCH;
// Do not insert strings in hash table beyond this.
// check_match(strstart-1, prev_match, prev_length);
bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
// Insert in hash table all strings up to the end of the match.
// strstart-1 and strstart are already inserted. If there is not
// enough lookahead, the last two strings are not inserted in
// the hash table.
lookahead -= (prev_length - 1);
prev_length -= 2;
do
{
if (++strstart <= max_insert)
{
ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
//prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (head[ins_h] & 0xffff);
prev[strstart & w_mask] = head[ins_h];
head[ins_h] = unchecked((short)strstart);
}
}
while (--prev_length != 0);
match_available = 0;
match_length = MIN_MATCH - 1;
strstart++;
if (bflush)
{
flush_block_only(false);
if (_codec.AvailableBytesOut == 0)
return BlockState.NeedMore;
}
}
else if (match_available != 0)
{
// If there was no match at the previous position, output a
// single literal. If there was a match but the current match
// is longer, truncate the previous match to a single literal.
bflush = _tr_tally(0, window[strstart - 1] & 0xff);
if (bflush)
{
flush_block_only(false);
}
strstart++;
lookahead--;
if (_codec.AvailableBytesOut == 0)
return BlockState.NeedMore;
}
else
{
// There is no previous match to compare with, wait for
// the next step to decide.
match_available = 1;
strstart++;
lookahead--;
}
}
if (match_available != 0)
{
bflush = _tr_tally(0, window[strstart - 1] & 0xff);
match_available = 0;
}
flush_block_only(flush == FlushType.Finish);
if (_codec.AvailableBytesOut == 0)
{
if (flush == FlushType.Finish)
return BlockState.FinishStarted;
else
return BlockState.NeedMore;
}
return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
}
// Same as above, but achieves better compression. We use a lazy
// evaluation for matches: a match is finally adopted only if there is
// no better match at the next window position.
private int deflate_slow(FlushType flush)
{
// short hash_head = 0; // head of hash chain
int hash_head = 0; // head of hash chain
bool bflush; // set if current block must be flushed
// Process the input block.
while (true)
{
// Make sure that we always have enough lookahead, except
// at the end of the input file. We need MAX_MATCH bytes
// for the next match, plus MIN_MATCH bytes to insert the
// string following the next match.
if (_validBytesAhead < MIN_LOOKAHEAD)
{
fill_window();
if (_validBytesAhead < MIN_LOOKAHEAD && flush == FlushType.Z_NO_FLUSH)
{
return NeedMore;
}
if (_validBytesAhead == 0) break; // flush the current block
}
// Insert the string window[strstart .. strstart+2] in the
// dictionary, and set hash_head to the head of the hash chain:
if (_validBytesAhead >= MIN_MATCH)
{
_insertedHashIndex = (((_insertedHashIndex) << _hashShift) ^ (_window[(_startInsertString) + (MIN_MATCH - 1)] & 0xff)) & _hashMask;
// prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (_head[_insertedHashIndex] & 0xffff);
_previous[_startInsertString & _windowMask] = _head[_insertedHashIndex];
_head[_insertedHashIndex] = (short)_startInsertString;
}
// Find the longest match, discarding those <= prev_length.
_previousLength = _matchLength; _previousMatch = _startMatchString;
_matchLength = MIN_MATCH - 1;
if (hash_head != 0 && _previousLength < _maxLazyMatch &&
((_startInsertString - hash_head) & 0xffff) <= _windowSize - MIN_LOOKAHEAD
)
{
// To simplify the code, we prevent matches with the string
// of window index 0 (in particular we have to avoid a match
// of the string with itself at the start of the input file).
if (strategy != CompressionStrategy.Z_HUFFMAN_ONLY)
{
_matchLength = longest_match(hash_head);
}
// longest_match() sets match_start
if (_matchLength <= 5 && (strategy == CompressionStrategy.Z_FILTERED ||
(_matchLength == MIN_MATCH &&
_startInsertString - _startMatchString > 4096)))
{
// If prev_match is also MIN_MATCH, match_start is garbage
// but we will ignore the current match anyway.
_matchLength = MIN_MATCH - 1;
}
}
// If there was a match at the previous step and the current
// match is not better, output the previous match:
if (_previousLength >= MIN_MATCH && _matchLength <= _previousLength)
{
int max_insert = _startInsertString + _validBytesAhead - MIN_MATCH;
// Do not insert strings in hash table beyond this.
// check_match(strstart-1, prev_match, prev_length);
bflush = _tr_tally(_startInsertString - 1 - _previousMatch, _previousLength - MIN_MATCH);
// Insert in hash table all strings up to the end of the match.
// strstart-1 and strstart are already inserted. If there is not
// enough lookahead, the last two strings are not inserted in
// the hash table.
_validBytesAhead -= _previousLength - 1;
_previousLength -= 2;
do
{
if (++_startInsertString <= max_insert)
{
_insertedHashIndex = (((_insertedHashIndex) << _hashShift) ^ (_window[(_startInsertString) + (MIN_MATCH - 1)] & 0xff)) & _hashMask;
//prev[strstart&w_mask]=hash_head=head[ins_h];
hash_head = (_head[_insertedHashIndex] & 0xffff);
_previous[_startInsertString & _windowMask] = _head[_insertedHashIndex];
_head[_insertedHashIndex] = (short)_startInsertString;
}
}
while (--_previousLength != 0);
_matchAvailable = false;
_matchLength = MIN_MATCH - 1;
_startInsertString++;
if (bflush)
{
flush_block_only(false);
if (base.avail_out == 0) return NeedMore;
}
}
else if (_matchAvailable != false)
{
// If there was no match at the previous position, output a
// single literal. If there was a match but the current match
// is longer, truncate the previous match to a single literal.
bflush = _tr_tally(0, _window[_startInsertString - 1] & 0xff);
if (bflush)
{
flush_block_only(false);
}
_startInsertString++;
_validBytesAhead--;
if (base.avail_out == 0) return NeedMore;
}
else
{
// There is no previous match to compare with, wait for
// the next step to decide.
_matchAvailable = true;
_startInsertString++;
_validBytesAhead--;
}
}
if (_matchAvailable != false)
{
bflush = _tr_tally(0, _window[_startInsertString - 1] & 0xff);
_matchAvailable = false;
}
flush_block_only(flush == FlushType.Z_FINISH);
if (base.avail_out == 0)
{
if (flush == FlushType.Z_FINISH) return FinishStarted;
else return NeedMore;
}
return flush == FlushType.Z_FINISH ? FinishDone : BlockDone;
}
// Copy without compression as much as possible from the input stream, return
// the current block state.
// This function does not insert new strings in the dictionary since
// uncompressible data is probably not useful. This function is used
// only for the level=0 compression option.
// NOTE: this function should be optimized to avoid extra copying from
// window to pending_buf.
internal BlockState DeflateNone(FlushType flush)
{
// Stored blocks are limited to 0xffff bytes, pending is limited
// to pending_buf_size, and each stored block has a 5 byte header:
int max_block_size = 0xffff;
int max_start;
if (max_block_size > pending.Length - 5)
{
max_block_size = pending.Length - 5;
}
// Copy as much as possible from input to output:
while (true)
{
// Fill the window as much as possible:
if (lookahead <= 1)
{
_fillWindow();
if (lookahead == 0 && flush == FlushType.None)
return BlockState.NeedMore;
if (lookahead == 0)
break; // flush the current block
}
strstart += lookahead;
lookahead = 0;
// Emit a stored block if pending will be full:
max_start = block_start + max_block_size;
if (strstart == 0 || strstart >= max_start)
{
// strstart == 0 is possible when wraparound on 16-bit machine
lookahead = (int)(strstart - max_start);
strstart = (int)max_start;
flush_block_only(false);
if (_codec.AvailableBytesOut == 0)
return BlockState.NeedMore;
}
// Flush if we may have to slide, otherwise block_start may become
// negative and the data will be gone:
if (strstart - block_start >= w_size - MIN_LOOKAHEAD)
{
flush_block_only(false);
if (_codec.AvailableBytesOut == 0)
return BlockState.NeedMore;
}
}
flush_block_only(flush == FlushType.Finish);
if (_codec.AvailableBytesOut == 0)
return (flush == FlushType.Finish) ? BlockState.FinishStarted : BlockState.NeedMore;
return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
}
public ZLibStatus deflate(FlushType flush)
{
FlushType old_flush;
if (flush > FlushType.Z_FINISH || flush < 0)
{
return ZLibStatus.Z_STREAM_ERROR;
}
if (base.next_out == null ||
(base.next_in == null && base.avail_in != 0) ||
(_status == FINISH_STATE && flush != FlushType.Z_FINISH))
{
base.msg = z_errmsg[ZLibStatus.Z_NEED_DICT - (ZLibStatus.Z_STREAM_ERROR)];
return ZLibStatus.Z_STREAM_ERROR;
}
if (base.avail_out == 0)
{
base.msg = z_errmsg[ZLibStatus.Z_NEED_DICT - (ZLibStatus.Z_BUF_ERROR)];
return ZLibStatus.Z_BUF_ERROR;
}
old_flush = last_flush;
last_flush = flush;
// Write the zlib header
if (_status == INIT_STATE)
{
int header = (Z_DEFLATED + ((this._windowBits - 8) << 4)) << 8;
int level_flags = (((int)this.level - 1) & 0xff) >> 1;
if (level_flags > 3) level_flags = 3;
header |= (level_flags << 6);
if (this._startInsertString != 0) header |= PRESET_DICT;
header += 31 - (header % 31);
_status = BUSY_STATE;
putShortMSB(header);
// Save the adler32 of the preset dictionary:
if (this._startInsertString != 0)
{
putShortMSB((int)(base.adler >> 16));
putShortMSB((int)(base.adler & 0xffff));
}
base.adler = Adler32.adler32(0, null, 0, 0);
}
// Flush as much pending output as possible
if (pending != 0)
{
this.flush_pending();
if (base.avail_out == 0)
{
//System.out.println(" avail_out==0");
// Since avail_out is 0, deflate will be called again with
// more output space, but possibly with both pending and
// avail_in equal to zero. There won't be anything to do,
// but this is not an error situation so make sure we
// return OK instead of BUF_ERROR at next call of deflate:
last_flush = (FlushType)(-1);
return ZLibStatus.Z_OK;
}
// Make sure there is something to do and avoid duplicate consecutive
// flushes. For repeated and useless calls with Z_FINISH, we keep
// returning Z_STREAM_END instead of Z_BUFF_ERROR.
}
else if (base.avail_in == 0 && flush <= old_flush &&
flush != FlushType.Z_FINISH)
{
base.msg = z_errmsg[ZLibStatus.Z_NEED_DICT - (ZLibStatus.Z_BUF_ERROR)];
return ZLibStatus.Z_BUF_ERROR;
}
// User must not provide more input after the first FINISH:
if (_status == FINISH_STATE && base.avail_in != 0)
{
base.msg = z_errmsg[ZLibStatus.Z_NEED_DICT - (ZLibStatus.Z_BUF_ERROR)];
return ZLibStatus.Z_BUF_ERROR;
}
// Start a new block or continue the current one.
if (base.avail_in != 0 || this._validBytesAhead != 0 ||
(flush != FlushType.Z_NO_FLUSH && _status != FINISH_STATE))
{
int bstate = -1;
switch (config_table[level].Function)
{
case DefalteFlavor.STORED:
bstate = deflate_stored(flush);
break;
case DefalteFlavor.FAST:
bstate = deflate_fast(flush);
break;
case DefalteFlavor.SLOW:
bstate = deflate_slow(flush);
break;
default:
break;
}
if (bstate == FinishStarted || bstate == FinishDone)
{
_status = FINISH_STATE;
}
if (bstate == NeedMore || bstate == FinishStarted)
{
if (base.avail_out == 0)
{
last_flush = (FlushType)(-1); // avoid BUF_ERROR next call, see above
}
return ZLibStatus.Z_OK;
// If flush != Z_NO_FLUSH && avail_out == 0, the next call
// of deflate should use the same flush parameter to make sure
// that the flush is complete. So we don't have to output an
// empty block here, this will be done at next call. This also
// ensures that for a very small output buffer, we emit at most
// one empty block.
}
if (bstate == BlockDone)
{
if (flush == FlushType.Z_PARTIAL_FLUSH)
{
_tr_align();
}
else
{ // FULL_FLUSH or SYNC_FLUSH
_tr_stored_block(0, 0, false);
// For a full flush, this empty block will be recognized
// as a special marker by inflate_sync().
if (flush == FlushType.Z_FULL_FLUSH)
{
//state.head[s.hash_size-1]=0;
for (int i = 0; i < this._hashSize/*-1*/; i++) // forget history
this._head[i] = 0;
}
}
this.flush_pending();
if (base.avail_out == 0)
{
last_flush = (FlushType)(-1); // avoid BUF_ERROR at next call, see above
return ZLibStatus.Z_OK;
}
}
}
if (flush != FlushType.Z_FINISH) return ZLibStatus.Z_OK;
if (noheader != 0) return ZLibStatus.Z_STREAM_END;
// Write the zlib trailer (adler32)
putShortMSB((int)(base.adler >> 16));
putShortMSB((int)(base.adler & 0xffff));
this.flush_pending();
// If avail_out is zero, the application will call deflate again
// to flush the rest.
noheader = -1; // write the trailer only once!
return pending != 0 ? ZLibStatus.Z_OK : ZLibStatus.Z_STREAM_END;
}
/// <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);
}
public ZLibStatus inflate(byte[] outputBuffer, int outputOffset, int outputCount, FlushType flushType)
{
throw new NotImplementedException();
}