public DeflateOutputStream(Stream output, ZStream z, bool compress) : base(output) { this.z = z; this.compress = compress; this.FlushMode = JZlib.Z_PARTIAL_FLUSH; }
public TlsDeflateCompression(int level) { this.zIn = new ZStream(); this.zIn.inflateInit(); this.zOut = new ZStream(); this.zOut.deflateInit(level); }
public DeflateOutputStream(Stream output, ZStream z, bool compress) : base(output) { this.z = z; this.compress = compress; // TODO http://www.bolet.org/~pornin/deflate-flush.html says we should use Z_SYNC_FLUSH this.FlushMode = JZlib.Z_PARTIAL_FLUSH; }
public TlsDeflateCompression() { this.zIn = new ZStream(); this.zIn.inflateInit(); this.zOut = new ZStream(); // TODO Allow custom setting this.zOut.deflateInit(JZlib.Z_DEFAULT_COMPRESSION); }
public DeflateOutputStream(Stream output, ZStream z, bool compress) : base(output, z) { this.compress = compress; /* * See discussion at http://www.bolet.org/~pornin/deflate-flush.html . */ this.FlushMode = JZlib.Z_SYNC_FLUSH; }
public CompressedStream (Stream baseStream) { BaseStream = baseStream; zOut = new ZStream (); zOut.deflateInit (5, true); zOut.next_out = new byte[4096]; zIn = new ZStream (); zIn.inflateInit (true); zIn.next_in = new byte[4096]; }
public ZOutputStream(Stream output, ZStream z) : base() { Debug.Assert(output.CanWrite); if (z == null) { z = new ZStream(); z.inflateInit(); } this.output = output; this.z = z; this.compress = false; }
public ZOutputStream(Stream output, ZStream z) : base() { Debug.Assert(output.CanWrite); if (z == null) { z = new ZStream(); } if (z.istate == null && z.dstate == null) { z.inflateInit(); } this.output = output; this.compress = (z.istate == null); this.z = z; }
public ZInputStream(Stream input, ZStream z) : base() { Debug.Assert(input.CanRead); if (z == null) { z = new ZStream(); } if (z.istate == null && z.dstate == null) { z.inflateInit(); } this.input = input; this.compress = (z.istate == null); this.z = z; this.z.next_in = buf; this.z.next_in_index = 0; this.z.avail_in = 0; }
internal int deflate(ZStream strm, int flush) { if (flush > 4 || flush < 0) { return(-2); } if (strm.next_out == null || (strm.next_in == null && strm.avail_in != 0) || (status == 666 && flush != 4)) { strm.msg = z_errmsg[4]; return(-2); } if (strm.avail_out == 0) { strm.msg = z_errmsg[7]; return(-5); } this.strm = strm; int num = last_flush; last_flush = flush; if (status == 42) { int num2 = 8 + (w_bits - 8 << 4) << 8; int num3 = ((level - 1) & 0xFF) >> 1; if (num3 > 3) { num3 = 3; } num2 |= num3 << 6; if (strstart != 0) { num2 |= 0x20; } num2 += 31 - num2 % 31; status = 113; putShortMSB(num2); if (strstart != 0) { putShortMSB((int)(strm.adler >> 16)); putShortMSB((int)(strm.adler & 0xFFFF)); } strm.adler = strm._adler.adler32(0L, null, 0, 0); } if (pending != 0) { strm.flush_pending(); if (strm.avail_out == 0) { last_flush = -1; return(0); } } else if (strm.avail_in == 0 && flush <= num && flush != 4) { strm.msg = z_errmsg[7]; return(-5); } if (status == 666 && strm.avail_in != 0) { strm.msg = z_errmsg[7]; return(-5); } if (strm.avail_in != 0 || lookahead != 0 || (flush != 0 && status != 666)) { int num4 = -1; switch (config_table[level].func) { case 0: num4 = deflate_stored(flush); break; case 1: num4 = deflate_fast(flush); break; case 2: num4 = deflate_slow(flush); break; } if (num4 == 2 || num4 == 3) { status = 666; } switch (num4) { case 0: case 2: if (strm.avail_out == 0) { last_flush = -1; } return(0); case 1: if (flush == 1) { _tr_align(); } else { _tr_stored_block(0, 0, eof: false); if (flush == 3) { for (int i = 0; i < hash_size; i++) { head[i] = 0; } } } strm.flush_pending(); if (strm.avail_out == 0) { last_flush = -1; return(0); } break; } } if (flush != 4) { return(0); } if (noheader != 0) { return(1); } putShortMSB((int)(strm.adler >> 16)); putShortMSB((int)(strm.adler & 0xFFFF)); strm.flush_pending(); noheader = -1; if (pending == 0) { return(1); } return(0); }
internal int inflateReset(ZStream z) { if(z == null || z.istate == null) return Z_STREAM_ERROR; z.total_in = z.total_out = 0; z.msg = null; z.istate.mode = z.istate.nowrap!=0 ? BLOCKS : METHOD; z.istate.blocks.reset(z, null); return Z_OK; }
internal int inflateEnd(ZStream z) { if(blocks != null) blocks.free(z); blocks=null; // ZFREE(z, z->state); return Z_OK; }
public ZLibStatus InflateSync(ZStream z) { int n; // number of bytes to look at int p; // pointer to bytes int m; // number of marker bytes found in a row long r, w; // temporaries to save total_in and total_out // set up if (this._mode != InflateMode.BAD) { this._mode = InflateMode.BAD; this._marker = 0; } if ((n = base.avail_in) == 0) return ZLibStatus.Z_BUF_ERROR; p = base.next_in_index; m = this._marker; // search while (n != 0 && m < 4) { if (base.next_in[p] == mark[m]) { m++; } else if (base.next_in[p] != 0) { m = 0; } else { m = 4 - m; } p++; n--; } // restore base.total_in += p - base.next_in_index; base.next_in_index = p; base.avail_in = n; this._marker = m; // return no joy or set up to restart on a new block if (m != 4) { return ZLibStatus.Z_DATA_ERROR; } r = base.total_in; w = base.total_out; InflateReset(); base.total_in = r; base.total_out = w; this._mode = InflateMode.BLOCKS; return ZLibStatus.Z_OK; }
public ZLibStatus InflateEnd(ZStream z) { if (_blocks != null) _blocks.free(z); _blocks = null; // ZFREE(z, z->state); return ZLibStatus.Z_OK; }
internal int deflateSetDictionary (ZStream strm, byte[] dictionary, int dictLength){ int length = dictLength; int index=0; if(dictionary == null || status != INIT_STATE) return Z_STREAM_ERROR; strm.adler=strm._adler.adler32(strm.adler, dictionary, 0, dictLength); if(length < MIN_MATCH) return Z_OK; if(length > w_size-MIN_LOOKAHEAD){ length = w_size-MIN_LOOKAHEAD; index=dictLength-length; // use the tail of the dictionary } System.Array.Copy(dictionary, index, window, 0, length); strstart = length; block_start = length; // Insert all strings in the hash table (except for the last two bytes). // s->lookahead stays null, so s->ins_h will be recomputed at the next // call of fill_window. ins_h = window[0]&0xff; ins_h=(((ins_h)<<hash_shift)^(window[1]&0xff))&hash_mask; for(int n=0; n<=length-MIN_MATCH; n++){ ins_h=(((ins_h)<<hash_shift)^(window[(n)+(MIN_MATCH-1)]&0xff))&hash_mask; prev[n&w_mask]=head[ins_h]; head[ins_h]=(short)n; } return Z_OK; }
internal int deflateInit(ZStream strm, int level, int bits) { return(deflateInit2(strm, level, 8, bits, 8, 0)); }
internal int proc(InfBlocks s, ZStream z, int r) { int j; // temporary storage int tindex; // temporary pointer int e; // extra bits or operation int b = 0; // bit buffer int k = 0; // bits in bit buffer int p = 0; // input data pointer int n; // bytes available there int q; // output window write pointer int m; // bytes to end of window or read pointer int f; // pointer to copy strings from // copy input/output information to locals (UPDATE macro restores) p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk; q = s.write; m = q < s.read?s.read - q - 1:s.end - q; // process input and output based on current state while (true) { switch (mode) { // waiting for "i:"=input, "o:"=output, "x:"=nothing case START: // x: set up for LEN if (m >= 258 && n >= 10) { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; r = inflate_fast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, s, z); p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk; q = s.write; m = q < s.read?s.read - q - 1:s.end - q; if (r != Z_OK) { mode = r == Z_STREAM_END ? WASH : BADCODE; break; } } need = lbits; tree = ltree; tree_index = ltree_index; mode = LEN; goto case LEN; case LEN: // i: get length/literal/eob next j = need; while (k < (j)) { if (n != 0) { r = Z_OK; } else { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } tindex = (tree_index + (b & inflate_mask[j])) * 3; b >>= (tree[tindex + 1]); k -= (tree[tindex + 1]); e = tree[tindex]; if (e == 0) // literal { lit = tree[tindex + 2]; mode = LIT; break; } if ((e & 16) != 0) // length { get = e & 15; len = tree[tindex + 2]; mode = LENEXT; break; } if ((e & 64) == 0) // next table { need = e; tree_index = tindex / 3 + tree[tindex + 2]; break; } if ((e & 32) != 0) // end of block { mode = WASH; break; } mode = BADCODE; // invalid code z.msg = "invalid literal/length code"; r = Z_DATA_ERROR; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); case LENEXT: // i: getting length extra (have base) j = get; while (k < (j)) { if (n != 0) { r = Z_OK; } else { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } len += (b & inflate_mask[j]); b >>= j; k -= j; need = dbits; tree = dtree; tree_index = dtree_index; mode = DIST; goto case DIST; case DIST: // i: get distance next j = need; while (k < (j)) { if (n != 0) { r = Z_OK; } else { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } tindex = (tree_index + (b & inflate_mask[j])) * 3; b >>= tree[tindex + 1]; k -= tree[tindex + 1]; e = (tree[tindex]); if ((e & 16) != 0) // distance { get = e & 15; dist = tree[tindex + 2]; mode = DISTEXT; break; } if ((e & 64) == 0) // next table { need = e; tree_index = tindex / 3 + tree[tindex + 2]; break; } mode = BADCODE; // invalid code z.msg = "invalid distance code"; r = Z_DATA_ERROR; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); case DISTEXT: // i: getting distance extra j = get; while (k < (j)) { if (n != 0) { r = Z_OK; } else { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } dist += (b & inflate_mask[j]); b >>= j; k -= j; mode = COPY; goto case COPY; case COPY: // o: copying bytes in window, waiting for space f = q - dist; while (f < 0) // modulo window size-"while" instead { f += s.end; // of "if" handles invalid distances } while (len != 0) { if (m == 0) { if (q == s.end && s.read != 0) { q = 0; m = q < s.read?s.read - q - 1:s.end - q; } if (m == 0) { s.write = q; r = s.inflate_flush(z, r); q = s.write; m = q < s.read?s.read - q - 1:s.end - q; if (q == s.end && s.read != 0) { q = 0; m = q < s.read?s.read - q - 1:s.end - q; } if (m == 0) { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } } } s.window[q++] = s.window[f++]; m--; if (f == s.end) { f = 0; } len--; } mode = START; break; case LIT: // o: got literal, waiting for output space if (m == 0) { if (q == s.end && s.read != 0) { q = 0; m = q < s.read?s.read - q - 1:s.end - q; } if (m == 0) { s.write = q; r = s.inflate_flush(z, r); q = s.write; m = q < s.read?s.read - q - 1:s.end - q; if (q == s.end && s.read != 0) { q = 0; m = q < s.read?s.read - q - 1:s.end - q; } if (m == 0) { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } } } r = Z_OK; s.window[q++] = (byte)lit; m--; mode = START; break; case WASH: // o: got eob, possibly more output if (k > 7) // return unused byte, if any { k -= 8; n++; p--; // can always return one } s.write = q; r = s.inflate_flush(z, r); q = s.write; m = q < s.read?s.read - q - 1:s.end - q; if (s.read != s.write) { s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } mode = END; goto case END; case END: r = Z_STREAM_END; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); case BADCODE: // x: got error r = Z_DATA_ERROR; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); default: r = Z_STREAM_ERROR; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(s.inflate_flush(z, r)); } } }
internal int inflate_fast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InfBlocks s, ZStream z) { int num12; int num6 = z.next_in_index; int num7 = z.avail_in; int bitb = s.bitb; int bitk = s.bitk; int write = s.write; int num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); int num10 = inflate_mask[bl]; int num11 = inflate_mask[bd]; Label_009B: while (bitk < 20) { num7--; bitb |= (z.next_in[num6++] & 0xff) << bitk; bitk += 8; } int num = bitb & num10; int[] numArray = tl; int num2 = tl_index; int index = (num2 + num) * 3; int num3 = numArray[index]; if (num3 == 0) { bitb = bitb >> numArray[index + 1]; bitk -= numArray[index + 1]; s.window[write++] = (byte)numArray[index + 2]; num9--; goto Label_062B; } Label_00FB: bitb = bitb >> numArray[index + 1]; bitk -= numArray[index + 1]; if ((num3 & 0x10) == 0) { if ((num3 & 0x40) == 0) { num += numArray[index + 2]; num += bitb & inflate_mask[num3]; index = (num2 + num) * 3; num3 = numArray[index]; if (num3 != 0) { goto Label_00FB; } bitb = bitb >> numArray[index + 1]; bitk -= numArray[index + 1]; s.window[write++] = (byte)numArray[index + 2]; num9--; } else { if ((num3 & 0x20) != 0) { num12 = z.avail_in - num7; num12 = ((bitk >> 3) >= num12) ? num12 : (bitk >> 3); num7 += num12; num6 -= num12; bitk -= num12 << 3; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(1); } z.msg = "invalid literal/length code"; num12 = z.avail_in - num7; num12 = ((bitk >> 3) >= num12) ? num12 : (bitk >> 3); num7 += num12; num6 -= num12; bitk -= num12 << 3; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(-3); } goto Label_062B; } num3 &= 15; num12 = numArray[index + 2] + (bitb & inflate_mask[num3]); bitb = bitb >> num3; bitk -= num3; while (bitk < 15) { num7--; bitb |= (z.next_in[num6++] & 0xff) << bitk; bitk += 8; } num = bitb & num11; numArray = td; num2 = td_index; index = (num2 + num) * 3; num3 = numArray[index]; Label_0196: bitb = bitb >> numArray[index + 1]; bitk -= numArray[index + 1]; if ((num3 & 0x10) != 0) { int num14; num3 &= 15; while (bitk < num3) { num7--; bitb |= (z.next_in[num6++] & 0xff) << bitk; bitk += 8; } int num13 = numArray[index + 2] + (bitb & inflate_mask[num3]); bitb = bitb >> num3; bitk -= num3; num9 -= num12; if (write >= num13) { num14 = write - num13; if (((write - num14) > 0) && (2 > (write - num14))) { s.window[write++] = s.window[num14++]; s.window[write++] = s.window[num14++]; num12 -= 2; } else { Array.Copy(s.window, num14, s.window, write, 2); write += 2; num14 += 2; num12 -= 2; } } else { num14 = write - num13; do { num14 += s.end; }while (num14 < 0); num3 = s.end - num14; if (num12 > num3) { num12 -= num3; if (((write - num14) > 0) && (num3 > (write - num14))) { do { s.window[write++] = s.window[num14++]; }while (--num3 != 0); } else { Array.Copy(s.window, num14, s.window, write, num3); write += num3; num14 += num3; num3 = 0; } num14 = 0; } } if (((write - num14) > 0) && (num12 > (write - num14))) { do { s.window[write++] = s.window[num14++]; }while (--num12 != 0); } else { Array.Copy(s.window, num14, s.window, write, num12); write += num12; num14 += num12; num12 = 0; } } else { if ((num3 & 0x40) == 0) { num += numArray[index + 2]; num += bitb & inflate_mask[num3]; index = (num2 + num) * 3; num3 = numArray[index]; goto Label_0196; } z.msg = "invalid distance code"; num12 = z.avail_in - num7; num12 = ((bitk >> 3) >= num12) ? num12 : (bitk >> 3); num7 += num12; num6 -= num12; bitk -= num12 << 3; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(-3); } Label_062B: if ((num9 >= 0x102) && (num7 >= 10)) { goto Label_009B; } num12 = z.avail_in - num7; num12 = ((bitk >> 3) >= num12) ? num12 : (bitk >> 3); num7 += num12; num6 -= num12; bitk -= num12 << 3; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(0); }
internal void free(ZStream z) { }
internal int proc(InfBlocks s, ZStream z, int r) { int get; int num10; int bitb = 0; int bitk = 0; int num6 = 0; num6 = z.next_in_index; int num7 = z.avail_in; bitb = s.bitb; bitk = s.bitk; int write = s.write; int num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); Label_0057: switch (this.mode) { case 0: if ((num9 < 0x102) || (num7 < 10)) { break; } s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; r = this.inflate_fast(this.lbits, this.dbits, this.ltree, this.ltree_index, this.dtree, this.dtree_index, s, z); num6 = z.next_in_index; num7 = z.avail_in; bitb = s.bitb; bitk = s.bitk; write = s.write; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); if (r == 0) { break; } this.mode = (r != 1) ? 9 : 7; goto Label_0057; case 1: goto Label_01B3; case 2: get = this.get; while (bitk < get) { if (num7 != 0) { r = 0; } else { s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } num7--; bitb |= (z.next_in[num6++] & 0xff) << bitk; bitk += 8; } this.len += bitb & inflate_mask[get]; bitb = bitb >> get; bitk -= get; this.need = this.dbits; this.tree = this.dtree; this.tree_index = this.dtree_index; this.mode = 3; goto Label_0454; case 3: goto Label_0454; case 4: get = this.get; while (bitk < get) { if (num7 != 0) { r = 0; } else { s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } num7--; bitb |= (z.next_in[num6++] & 0xff) << bitk; bitk += 8; } this.dist += bitb & inflate_mask[get]; bitb = bitb >> get; bitk -= get; this.mode = 5; goto Label_069A; case 5: goto Label_069A; case 6: if (num9 == 0) { if ((write == s.end) && (s.read != 0)) { write = 0; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); } if (num9 == 0) { s.write = write; r = s.inflate_flush(z, r); write = s.write; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); if ((write == s.end) && (s.read != 0)) { write = 0; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); } if (num9 == 0) { s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } } } r = 0; s.window[write++] = (byte)this.lit; num9--; this.mode = 0; goto Label_0057; case 7: if (bitk > 7) { bitk -= 8; num7++; num6--; } s.write = write; r = s.inflate_flush(z, r); write = s.write; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); if (s.read != s.write) { s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } this.mode = 8; goto Label_0A4B; case 8: goto Label_0A4B; case 9: r = -3; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); default: r = -2; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } this.need = this.lbits; this.tree = this.ltree; this.tree_index = this.ltree_index; this.mode = 1; Label_01B3: get = this.need; while (bitk < get) { if (num7 != 0) { r = 0; } else { s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } num7--; bitb |= (z.next_in[num6++] & 0xff) << bitk; bitk += 8; } int index = (this.tree_index + (bitb & inflate_mask[get])) * 3; bitb = bitb >> this.tree[index + 1]; bitk -= this.tree[index + 1]; int num3 = this.tree[index]; if (num3 == 0) { this.lit = this.tree[index + 2]; this.mode = 6; goto Label_0057; } if ((num3 & 0x10) != 0) { this.get = num3 & 15; this.len = this.tree[index + 2]; this.mode = 2; goto Label_0057; } if ((num3 & 0x40) == 0) { this.need = num3; this.tree_index = (index / 3) + this.tree[index + 2]; goto Label_0057; } if ((num3 & 0x20) != 0) { this.mode = 7; goto Label_0057; } this.mode = 9; z.msg = "invalid literal/length code"; r = -3; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); Label_0454: get = this.need; while (bitk < get) { if (num7 != 0) { r = 0; } else { s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } num7--; bitb |= (z.next_in[num6++] & 0xff) << bitk; bitk += 8; } index = (this.tree_index + (bitb & inflate_mask[get])) * 3; bitb = bitb >> this.tree[index + 1]; bitk -= this.tree[index + 1]; num3 = this.tree[index]; if ((num3 & 0x10) != 0) { this.get = num3 & 15; this.dist = this.tree[index + 2]; this.mode = 4; goto Label_0057; } if ((num3 & 0x40) == 0) { this.need = num3; this.tree_index = (index / 3) + this.tree[index + 2]; goto Label_0057; } this.mode = 9; z.msg = "invalid distance code"; r = -3; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); Label_069A: num10 = write - this.dist; while (num10 < 0) { num10 += s.end; } while (this.len != 0) { if (num9 == 0) { if ((write == s.end) && (s.read != 0)) { write = 0; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); } if (num9 == 0) { s.write = write; r = s.inflate_flush(z, r); write = s.write; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); if ((write == s.end) && (s.read != 0)) { write = 0; num9 = (write >= s.read) ? (s.end - write) : ((s.read - write) - 1); } if (num9 == 0) { s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); } } } s.window[write++] = s.window[num10++]; num9--; if (num10 == s.end) { num10 = 0; } this.len--; } this.mode = 0; goto Label_0057; Label_0A4B: r = 1; s.bitb = bitb; s.bitk = bitk; z.avail_in = num7; z.total_in += num6 - z.next_in_index; z.next_in_index = num6; s.write = write; return(s.inflate_flush(z, r)); }
internal void init(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, ZStream z) { this.mode = 0; this.lbits = (byte)bl; this.dbits = (byte)bd; this.ltree = tl; this.ltree_index = tl_index; this.dtree = td; this.dtree_index = td_index; this.tree = null; }
internal int inflate(ZStream z, int f) { int r; int b; if (z == null || z.istate == null || z.next_in == null) { return(Z_STREAM_ERROR); } f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; r = Z_BUF_ERROR; while (true) { //System.out.println("mode: "+z.istate.mode); switch (z.istate.mode) { case METHOD: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; if (((z.istate.method = z.next_in[z.next_in_index++]) & 0xf) != Z_DEFLATED) { z.istate.mode = BAD; z.msg = "unknown compression method"; z.istate.marker = 5; // can't try inflateSync break; } if ((z.istate.method >> 4) + 8 > z.istate.wbits) { z.istate.mode = BAD; z.msg = "invalid window size"; z.istate.marker = 5; // can't try inflateSync break; } z.istate.mode = FLAG; goto case FLAG; case FLAG: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; b = (z.next_in[z.next_in_index++]) & 0xff; if ((((z.istate.method << 8) + b) % 31) != 0) { z.istate.mode = BAD; z.msg = "incorrect header check"; z.istate.marker = 5; // can't try inflateSync break; } if ((b & PRESET_DICT) == 0) { z.istate.mode = BLOCKS; break; } z.istate.mode = DICT4; goto case DICT4; case DICT4: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need = ((z.next_in[z.next_in_index++] & 0xff) << 24) & 0xff000000L; z.istate.mode = DICT3; goto case DICT3; case DICT3: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need += ((z.next_in[z.next_in_index++] & 0xff) << 16) & 0xff0000L; z.istate.mode = DICT2; goto case DICT2; case DICT2: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need += ((z.next_in[z.next_in_index++] & 0xff) << 8) & 0xff00L; z.istate.mode = DICT1; goto case DICT1; case DICT1: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need += (z.next_in[z.next_in_index++] & 0xffL); z.adler = z.istate.need; z.istate.mode = DICT0; return(Z_NEED_DICT); case DICT0: z.istate.mode = BAD; z.msg = "need dictionary"; z.istate.marker = 0; // can try inflateSync return(Z_STREAM_ERROR); case BLOCKS: r = z.istate.blocks.proc(z, r); if (r == Z_DATA_ERROR) { z.istate.mode = BAD; z.istate.marker = 0; // can try inflateSync break; } if (r == Z_OK) { r = f; } if (r != Z_STREAM_END) { return(r); } r = f; z.istate.blocks.reset(z, z.istate.was); if (z.istate.nowrap != 0) { z.istate.mode = DONE; break; } z.istate.mode = CHECK4; goto case CHECK4; case CHECK4: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need = ((z.next_in[z.next_in_index++] & 0xff) << 24) & 0xff000000L; z.istate.mode = CHECK3; goto case CHECK3; case CHECK3: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need += ((z.next_in[z.next_in_index++] & 0xff) << 16) & 0xff0000L; z.istate.mode = CHECK2; goto case CHECK2; case CHECK2: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need += ((z.next_in[z.next_in_index++] & 0xff) << 8) & 0xff00L; z.istate.mode = CHECK1; goto case CHECK1; case CHECK1: if (z.avail_in == 0) { return(r); } r = f; z.avail_in--; z.total_in++; z.istate.need += (z.next_in[z.next_in_index++] & 0xffL); if (((int)(z.istate.was[0])) != ((int)(z.istate.need))) { z.istate.mode = BAD; z.msg = "incorrect data check"; z.istate.marker = 5; // can't try inflateSync break; } z.istate.mode = DONE; goto case DONE; case DONE: return(Z_STREAM_END); case BAD: return(Z_DATA_ERROR); default: return(Z_STREAM_ERROR); } } }
internal void reset(ZStream z, long[] c){ if(c!=null) c[0]=check; if(mode==BTREE || mode==DTREE){ } if(mode==CODES){ codes.free(z); } mode=TYPE; bitk=0; bitb=0; read=write=0; if(checkfn != null) z.adler=check=z._adler.adler32(0L, null, 0, 0); }
internal int proc(InfBlocks s, ZStream z, int r) { int num = z.next_in_index; int num2 = z.avail_in; int num3 = s.bitb; int i = s.bitk; int num4 = s.write; int num5 = (num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4); while (true) { int num6; switch (this.mode) { case 0: if (num5 >= 258 && num2 >= 10) { s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; r = this.inflate_fast((int)this.lbits, (int)this.dbits, this.ltree, this.ltree_index, this.dtree, this.dtree_index, s, z); num = z.next_in_index; num2 = z.avail_in; num3 = s.bitb; i = s.bitk; num4 = s.write; num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); if (r != 0) { this.mode = ((r == 1) ? 7 : 9); continue; } } this.need = (int)this.lbits; this.tree = this.ltree; this.tree_index = this.ltree_index; this.mode = 1; goto IL_199; case 1: goto IL_199; case 2: num6 = this.get; while (i < num6) { if (num2 == 0) { goto IL_34E; } r = 0; num2--; num3 |= (int)(z.next_in[num++] & 255) << i; i += 8; } this.len += (num3 & InfCodes.inflate_mask[num6]); num3 >>= num6; i -= num6; this.need = (int)this.dbits; this.tree = this.dtree; this.tree_index = this.dtree_index; this.mode = 3; goto IL_411; case 3: goto IL_411; case 4: num6 = this.get; while (i < num6) { if (num2 == 0) { goto IL_595; } r = 0; num2--; num3 |= (int)(z.next_in[num++] & 255) << i; i += 8; } this.dist += (num3 & InfCodes.inflate_mask[num6]); num3 >>= num6; i -= num6; this.mode = 5; goto IL_634; case 5: goto IL_634; case 6: if (num5 == 0) { if (num4 == s.end && s.read != 0) { num4 = 0; num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); } if (num5 == 0) { s.write = num4; r = s.inflate_flush(z, r); num4 = s.write; num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); if (num4 == s.end && s.read != 0) { num4 = 0; num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); } if (num5 == 0) { goto Block_44; } } } r = 0; s.window[num4++] = (byte)this.lit; num5--; this.mode = 0; continue; case 7: goto IL_8DA; case 8: goto IL_989; case 9: goto IL_9D3; } break; IL_199: num6 = this.need; while (i < num6) { if (num2 == 0) { goto IL_1AB; } r = 0; num2--; num3 |= (int)(z.next_in[num++] & 255) << i; i += 8; } int num7 = (this.tree_index + (num3 & InfCodes.inflate_mask[num6])) * 3; num3 >>= this.tree[num7 + 1]; i -= this.tree[num7 + 1]; int num8 = this.tree[num7]; if (num8 == 0) { this.lit = this.tree[num7 + 2]; this.mode = 6; continue; } if ((num8 & 16) != 0) { this.get = (num8 & 15); this.len = this.tree[num7 + 2]; this.mode = 2; continue; } if ((num8 & 64) == 0) { this.need = num8; this.tree_index = num7 / 3 + this.tree[num7 + 2]; continue; } if ((num8 & 32) != 0) { this.mode = 7; continue; } goto IL_2DE; IL_411: num6 = this.need; while (i < num6) { if (num2 == 0) { goto IL_423; } r = 0; num2--; num3 |= (int)(z.next_in[num++] & 255) << i; i += 8; } num7 = (this.tree_index + (num3 & InfCodes.inflate_mask[num6])) * 3; num3 >>= this.tree[num7 + 1]; i -= this.tree[num7 + 1]; num8 = this.tree[num7]; if ((num8 & 16) != 0) { this.get = (num8 & 15); this.dist = this.tree[num7 + 2]; this.mode = 4; continue; } if ((num8 & 64) == 0) { this.need = num8; this.tree_index = num7 / 3 + this.tree[num7 + 2]; continue; } goto IL_525; IL_634: int j; for (j = num4 - this.dist; j < 0; j += s.end) { } while (this.len != 0) { if (num5 == 0) { if (num4 == s.end && s.read != 0) { num4 = 0; num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); } if (num5 == 0) { s.write = num4; r = s.inflate_flush(z, r); num4 = s.write; num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); if (num4 == s.end && s.read != 0) { num4 = 0; num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); } if (num5 == 0) { goto Block_32; } } } s.window[num4++] = s.window[j++]; num5--; if (j == s.end) { j = 0; } this.len--; } this.mode = 0; } r = -2; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_1AB: s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_2DE: this.mode = 9; z.msg = "invalid literal/length code"; r = -3; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_34E: s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_423: s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_525: this.mode = 9; z.msg = "invalid distance code"; r = -3; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_595: s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); Block_32: s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); Block_44: s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_8DA: if (i > 7) { i -= 8; num2++; num--; } s.write = num4; r = s.inflate_flush(z, r); num4 = s.write; int arg_92B_0 = (num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4); if (s.read != s.write) { s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); } this.mode = 8; IL_989: r = 1; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); IL_9D3: r = -3; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(s.inflate_flush(z, r)); }
internal void free(ZStream z) { // ZFREE(z, c); }
internal int inflate(ZStream z, int f) { if (z == null || z.istate == null || z.next_in == null) { return(-2); } f = ((f == 4) ? -5 : 0); int num = -5; while (true) { switch (z.istate.mode) { case 0: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; if (((z.istate.method = (int)z.next_in[z.next_in_index++]) & 15) != 8) { z.istate.mode = 13; z.msg = "unknown compression method"; z.istate.marker = 5; continue; } if ((z.istate.method >> 4) + 8 > z.istate.wbits) { z.istate.mode = 13; z.msg = "invalid window size"; z.istate.marker = 5; continue; } z.istate.mode = 1; goto IL_144; case 1: goto IL_144; case 2: goto IL_1EE; case 3: goto IL_259; case 4: goto IL_2CB; case 5: goto IL_33C; case 6: goto IL_3B8; case 7: num = z.istate.blocks.proc(z, num); if (num == -3) { z.istate.mode = 13; z.istate.marker = 0; continue; } if (num == 0) { num = f; } if (num != 1) { return(num); } num = f; z.istate.blocks.reset(z, z.istate.was); if (z.istate.nowrap != 0) { z.istate.mode = 12; continue; } z.istate.mode = 8; goto IL_469; case 8: goto IL_469; case 9: goto IL_4D5; case 10: goto IL_548; case 11: goto IL_5BA; case 12: return(1); case 13: return(-3); } break; IL_144: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; int num2 = (int)(z.next_in[z.next_in_index++] & 255); if (((z.istate.method << 8) + num2) % 31 != 0) { z.istate.mode = 13; z.msg = "incorrect header check"; z.istate.marker = 5; continue; } if ((num2 & 32) == 0) { z.istate.mode = 7; continue; } goto IL_1E2; IL_5BA: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; z.istate.need += (long)((ulong)z.next_in[z.next_in_index++] & 255uL); if ((int)z.istate.was[0] != (int)z.istate.need) { z.istate.mode = 13; z.msg = "incorrect data check"; z.istate.marker = 5; continue; } goto IL_65C; IL_548: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; z.istate.need += ((long)((long)(z.next_in[z.next_in_index++] & 255) << 8) & 65280L); z.istate.mode = 11; goto IL_5BA; IL_4D5: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; z.istate.need += ((long)((long)(z.next_in[z.next_in_index++] & 255) << 16) & 16711680L); z.istate.mode = 10; goto IL_548; IL_469: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; z.istate.need = ((long)((long)(z.next_in[z.next_in_index++] & 255) << 24) & (long)((ulong)-16777216)); z.istate.mode = 9; goto IL_4D5; } return(-2); IL_1E2: z.istate.mode = 2; IL_1EE: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; z.istate.need = ((long)((long)(z.next_in[z.next_in_index++] & 255) << 24) & (long)((ulong)-16777216)); z.istate.mode = 3; IL_259: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; z.istate.need += ((long)((long)(z.next_in[z.next_in_index++] & 255) << 16) & 16711680L); z.istate.mode = 4; IL_2CB: if (z.avail_in == 0) { return(num); } num = f; z.avail_in--; z.total_in += 1L; z.istate.need += ((long)((long)(z.next_in[z.next_in_index++] & 255) << 8) & 65280L); z.istate.mode = 5; IL_33C: if (z.avail_in == 0) { return(num); } z.avail_in--; z.total_in += 1L; z.istate.need += (long)((ulong)z.next_in[z.next_in_index++] & 255uL); z.adler = z.istate.need; z.istate.mode = 6; return(2); IL_3B8: z.istate.mode = 13; z.msg = "need dictionary"; z.istate.marker = 0; return(-2); IL_65C: z.istate.mode = 12; return(1); }
// Called with number of bytes left to write in window at least 258 // (the maximum string length) and number of input bytes available // at least ten. The ten bytes are six bytes for the longest length/ // distance pair plus four bytes for overloading the bit buffer. internal int inflate_fast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InfBlocks s, ZStream z) { int t; // temporary pointer int[] tp; // temporary pointer int tp_index; // temporary pointer int e; // extra bits or operation int b; // bit buffer int k; // bits in bit buffer int p; // input data pointer int n; // bytes available there int q; // output window write pointer int m; // bytes to end of window or read pointer int ml; // mask for literal/length tree int md; // mask for distance tree int c; // bytes to copy int d; // distance back to copy from int r; // copy source pointer int tp_index_t_3; // (tp_index+t)*3 // load input, output, bit values p = z.next_in_index; n = z.avail_in; b = s.bitb; k = s.bitk; q = s.write; m = q < s.read?s.read - q - 1:s.end - q; // initialize masks ml = inflate_mask[bl]; md = inflate_mask[bd]; // do until not enough input or output space for fast loop do // assume called with m >= 258 && n >= 10 // get literal/length code { while (k < (20)) // max bits for literal/length code { n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } t = b & ml; tp = tl; tp_index = tl_index; tp_index_t_3 = (tp_index + t) * 3; if ((e = tp[tp_index_t_3]) == 0) { b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]); s.window[q++] = (byte)tp[tp_index_t_3 + 2]; m--; continue; } do { b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]); if ((e & 16) != 0) { e &= 15; c = tp[tp_index_t_3 + 2] + ((int)b & inflate_mask[e]); b >>= e; k -= e; // decode distance base of block to copy while (k < (15)) // max bits for distance code { n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } t = b & md; tp = td; tp_index = td_index; tp_index_t_3 = (tp_index + t) * 3; e = tp[tp_index_t_3]; do { b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]); if ((e & 16) != 0) { // get extra bits to add to distance base e &= 15; while (k < (e)) // get extra bits (up to 13) { n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } d = tp[tp_index_t_3 + 2] + (b & inflate_mask[e]); b >>= (e); k -= (e); // do the copy m -= c; if (q >= d) // offset before dest // just copy { r = q - d; if (q - r > 0 && 2 > (q - r)) { s.window[q++] = s.window[r++]; // minimum count is three, s.window[q++] = s.window[r++]; // so unroll loop a little c -= 2; } else { System.Array.Copy(s.window, r, s.window, q, 2); q += 2; r += 2; c -= 2; } } else // else offset after destination { r = q - d; do { r += s.end; // force pointer in window }while(r < 0); // covers invalid distances e = s.end - r; if (c > e) // if source crosses, { c -= e; // wrapped copy if (q - r > 0 && e > (q - r)) { do { s.window[q++] = s.window[r++]; }while(--e != 0); } else { System.Array.Copy(s.window, r, s.window, q, e); q += e; r += e; e = 0; } r = 0; // copy rest from start of window } } // copy all or what's left if (q - r > 0 && c > (q - r)) { do { s.window[q++] = s.window[r++]; }while(--c != 0); } else { System.Array.Copy(s.window, r, s.window, q, c); q += c; r += c; c = 0; } break; } else if ((e & 64) == 0) { t += tp[tp_index_t_3 + 2]; t += (b & inflate_mask[e]); tp_index_t_3 = (tp_index + t) * 3; e = tp[tp_index_t_3]; } else { z.msg = "invalid distance code"; c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= c << 3; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(Z_DATA_ERROR); } }while(true); break; } if ((e & 64) == 0) { t += tp[tp_index_t_3 + 2]; t += (b & inflate_mask[e]); tp_index_t_3 = (tp_index + t) * 3; if ((e = tp[tp_index_t_3]) == 0) { b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]); s.window[q++] = (byte)tp[tp_index_t_3 + 2]; m--; break; } } else if ((e & 32) != 0) { c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= c << 3; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(Z_STREAM_END); } else { z.msg = "invalid literal/length code"; c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= c << 3; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(Z_DATA_ERROR); } }while(true); }while(m >= 258 && n >= 10); // not enough input or output--restore pointers and return c = z.avail_in - n; c = (k >> 3) < c?k >> 3:c; n += c; p -= c; k -= c << 3; s.bitb = b; s.bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; s.write = q; return(Z_OK); }
internal int deflate(ZStream strm, int flush){ int old_flush; if(flush>Z_FINISH || flush<0){ return Z_STREAM_ERROR; } if(strm.next_out == null || (strm.next_in == null && strm.avail_in != 0) || (status == FINISH_STATE && flush != Z_FINISH)) { strm.msg=z_errmsg[Z_NEED_DICT-(Z_STREAM_ERROR)]; return Z_STREAM_ERROR; } if(strm.avail_out == 0){ strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)]; return Z_BUF_ERROR; } this.strm = strm; // just in case old_flush = last_flush; last_flush = flush; // Write the zlib header if(status == INIT_STATE) { int header = (Z_DEFLATED+((w_bits-8)<<4))<<8; int level_flags=((level-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); // Save the adler32 of the preset dictionary: if(strstart!=0){ putShortMSB((int)(strm.adler>>16)); putShortMSB((int)(strm.adler&0xffff)); } strm.adler=strm._adler.adler32(0, null, 0, 0); } // Flush as much pending output as possible if(pending != 0) { strm.flush_pending(); if(strm.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 = -1; return 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(strm.avail_in==0 && flush <= old_flush && flush != Z_FINISH) { strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)]; return Z_BUF_ERROR; } // User must not provide more input after the first FINISH: if(status == FINISH_STATE && strm.avail_in != 0) { strm.msg=z_errmsg[Z_NEED_DICT-(Z_BUF_ERROR)]; return Z_BUF_ERROR; } // Start a new block or continue the current one. if(strm.avail_in!=0 || lookahead!=0 || (flush != Z_NO_FLUSH && status != FINISH_STATE)) { int bstate=-1; switch(config_table[level].func){ case STORED: bstate = deflate_stored(flush); break; case FAST: bstate = deflate_fast(flush); break; case SLOW: bstate = deflate_slow(flush); break; default: break; } if (bstate==FinishStarted || bstate==FinishDone) { status = FINISH_STATE; } if (bstate==NeedMore || bstate==FinishStarted) { if(strm.avail_out == 0) { last_flush = -1; // avoid BUF_ERROR next call, see above } return 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 == 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 == Z_FULL_FLUSH) { //state.head[s.hash_size-1]=0; for(int i=0; i<hash_size/*-1*/; i++) // forget history head[i]=0; } } strm.flush_pending(); if(strm.avail_out == 0) { last_flush = -1; // avoid BUF_ERROR at next call, see above return Z_OK; } } } if(flush!=Z_FINISH) return Z_OK; if(noheader!=0) return Z_STREAM_END; // Write the zlib trailer (adler32) putShortMSB((int)(strm.adler>>16)); putShortMSB((int)(strm.adler&0xffff)); strm.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 ? Z_OK : Z_STREAM_END; }
internal int proc(ZStream z, int r) { int t; // temporary storage int b; // bit buffer int k; // bits in bit buffer int p; // input data pointer int n; // bytes available there int q; // output window write pointer int m; { // bytes to end of window or read pointer // copy input/output information to locals (UPDATE macro restores) p = z.next_in_index; n = z.avail_in; b = bitb; k = bitk; } { q = write; m = (int)(q < read?read - q - 1:end - q); } // process input based on current state while (true) { switch (mode) { case TYPE: while (k < (3)) { if (n != 0) { r = Z_OK; } else { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); }; n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } t = (int)(b & 7); last = t & 1; switch (t >> 1) { case 0: { // stored b >>= (3); k -= (3); } t = k & 7; { // go to byte boundary b >>= (t); k -= (t); } mode = LENS; // get length of stored block break; case 1: { // fixed int[] bl = new int[1]; int[] bd = new int[1]; int[][] tl = new int[1][]; int[][] td = new int[1][]; InfTree.inflate_trees_fixed(bl, bd, tl, td, z); codes.init(bl[0], bd[0], tl[0], 0, td[0], 0, z); } { b >>= (3); k -= (3); } mode = CODES; break; case 2: { // dynamic b >>= (3); k -= (3); } mode = TABLE; break; case 3: { // illegal b >>= (3); k -= (3); } mode = BAD; z.msg = "invalid block type"; r = Z_DATA_ERROR; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } break; case LENS: while (k < (32)) { if (n != 0) { r = Z_OK; } else { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); }; n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } if ((((~b) >> 16) & 0xffff) != (b & 0xffff)) { mode = BAD; z.msg = "invalid stored block lengths"; r = Z_DATA_ERROR; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } left = (b & 0xffff); b = k = 0; // dump bits mode = left != 0 ? STORED : (last != 0 ? DRY : TYPE); break; case STORED: if (n == 0) { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } if (m == 0) { if (q == end && read != 0) { q = 0; m = (int)(q < read?read - q - 1:end - q); } if (m == 0) { write = q; r = inflate_flush(z, r); q = write; m = (int)(q < read?read - q - 1:end - q); if (q == end && read != 0) { q = 0; m = (int)(q < read?read - q - 1:end - q); } if (m == 0) { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } } } r = Z_OK; t = left; if (t > n) { t = n; } if (t > m) { t = m; } System.Array.Copy(z.next_in, p, window, q, t); p += t; n -= t; q += t; m -= t; if ((left -= t) != 0) { break; } mode = last != 0 ? DRY : TYPE; break; case TABLE: while (k < (14)) { if (n != 0) { r = Z_OK; } else { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); }; n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } table = t = (b & 0x3fff); if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) { mode = BAD; z.msg = "too many length or distance symbols"; r = Z_DATA_ERROR; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); if (blens == null || blens.Length < t) { blens = new int[t]; } else { for (int i = 0; i < t; i++) { blens[i] = 0; } } { b >>= (14); k -= (14); } index = 0; mode = BTREE; goto case BTREE; case BTREE: while (index < 4 + (table >> 10)) { while (k < (3)) { if (n != 0) { r = Z_OK; } else { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); }; n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } blens[border[index++]] = b & 7; { b >>= (3); k -= (3); } } while (index < 19) { blens[border[index++]] = 0; } bb[0] = 7; t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z); if (t != Z_OK) { r = t; if (r == Z_DATA_ERROR) { blens = null; mode = BAD; } bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } index = 0; mode = DTREE; goto case DTREE; case DTREE: while (true) { t = table; if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))) { break; } int i, j, c; t = bb[0]; while (k < (t)) { if (n != 0) { r = Z_OK; } else { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); }; n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } if (tb[0] == -1) { //System.err.println("null..."); } t = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 1]; c = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 2]; if (c < 16) { b >>= (t); k -= (t); blens[index++] = c; } else // c == 16..18 { i = c == 18 ? 7 : c - 14; j = c == 18 ? 11 : 3; while (k < (t + i)) { if (n != 0) { r = Z_OK; } else { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); }; n--; b |= (z.next_in[p++] & 0xff) << k; k += 8; } b >>= (t); k -= (t); j += (b & inflate_mask[i]); b >>= (i); k -= (i); i = index; t = table; if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1)) { blens = null; mode = BAD; z.msg = "invalid bit length repeat"; r = Z_DATA_ERROR; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } c = c == 16 ? blens[i - 1] : 0; do { blens[i++] = c; }while (--j != 0); index = i; } } tb[0] = -1; { int[] bl = new int[1]; int[] bd = new int[1]; int[] tl = new int[1]; int[] td = new int[1]; bl[0] = 9; // must be <= 9 for lookahead assumptions bd[0] = 6; // must be <= 9 for lookahead assumptions t = table; t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl, bd, tl, td, hufts, z); if (t != Z_OK) { if (t == Z_DATA_ERROR) { blens = null; mode = BAD; } r = t; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } codes.init(bl[0], bd[0], hufts, tl[0], hufts, td[0], z); } mode = CODES; goto case CODES; case CODES: bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; if ((r = codes.proc(this, z, r)) != Z_STREAM_END) { return(inflate_flush(z, r)); } r = Z_OK; codes.free(z); p = z.next_in_index; n = z.avail_in; b = bitb; k = bitk; q = write; m = (int)(q < read?read - q - 1:end - q); if (last == 0) { mode = TYPE; break; } mode = DRY; goto case DRY; case DRY: write = q; r = inflate_flush(z, r); q = write; m = (int)(q < read?read - q - 1:end - q); if (read != write) { bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } mode = DONE; goto case DONE; case DONE: r = Z_STREAM_END; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); case BAD: r = Z_DATA_ERROR; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); default: r = Z_STREAM_ERROR; bitb = b; bitk = k; z.avail_in = n; z.total_in += p - z.next_in_index; z.next_in_index = p; write = q; return(inflate_flush(z, r)); } } }
public ZLibStatus InflateInit(ZStream z, int w) { base.msg = null; _blocks = null; // handle undocumented nowrap option (no zlib header or check) _nowrap = 0; if (w < 0) { w = -w; _nowrap = 1; } // set window size if (w < 8 || w > 15) { InflateEnd(z); return ZLibStatus.Z_STREAM_ERROR; } _wbits = w; this._blocks = new InflateBlocks(z, this._nowrap != 0 ? null : this, 1 << w); // reset state InflateReset(); return ZLibStatus.Z_OK; }
// copy as much as possible from the sliding window to the output area internal int inflate_flush(ZStream z, int r) { int n; int p; int q; // local copies of source and destination pointers p = z.next_out_index; q = read; // compute number of bytes to copy as far as end of window n = (int)((q <= write ? write : end) - q); if (n > z.avail_out) { n = z.avail_out; } if (n != 0 && r == Z_BUF_ERROR) { r = Z_OK; } // update counters z.avail_out -= n; z.total_out += n; // update check information if (checkfn != null) { z.adler = check = z._adler.adler32(check, window, q, n); } // copy as far as end of window System.Array.Copy(window, q, z.next_out, p, n); p += n; q += n; // see if more to copy at beginning of window if (q == end) { // wrap pointers q = 0; if (write == end) { write = 0; } // compute bytes to copy n = write - q; if (n > z.avail_out) { n = z.avail_out; } if (n != 0 && r == Z_BUF_ERROR) { r = Z_OK; } // update counters z.avail_out -= n; z.total_out += n; // update check information if (checkfn != null) { z.adler = check = z._adler.adler32(check, window, q, n); } // copy System.Array.Copy(window, q, z.next_out, p, n); p += n; q += n; } // update pointers z.next_out_index = p; read = q; // done return(r); }
internal int inflate(ZStream z, int f) { int r; int b; if(z == null || z.istate == null || z.next_in == null) return Z_STREAM_ERROR; f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; r = Z_BUF_ERROR; while (true){ //System.out.println("mode: "+z.istate.mode); switch (z.istate.mode){ case METHOD: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; if(((z.istate.method = z.next_in[z.next_in_index++])&0xf)!=Z_DEFLATED){ z.istate.mode = BAD; z.msg="unknown compression method"; z.istate.marker = 5; // can't try inflateSync break; } if((z.istate.method>>4)+8>z.istate.wbits){ z.istate.mode = BAD; z.msg="invalid window size"; z.istate.marker = 5; // can't try inflateSync break; } z.istate.mode=FLAG; goto case FLAG; case FLAG: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; b = (z.next_in[z.next_in_index++])&0xff; if((((z.istate.method << 8)+b) % 31)!=0){ z.istate.mode = BAD; z.msg = "incorrect header check"; z.istate.marker = 5; // can't try inflateSync break; } if((b&PRESET_DICT)==0){ z.istate.mode = BLOCKS; break; } z.istate.mode = DICT4; goto case DICT4; case DICT4: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L; z.istate.mode=DICT3; goto case DICT3; case DICT3: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L; z.istate.mode=DICT2; goto case DICT2; case DICT2: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L; z.istate.mode=DICT1; goto case DICT1; case DICT1: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need += (z.next_in[z.next_in_index++]&0xffL); z.adler = z.istate.need; z.istate.mode = DICT0; return Z_NEED_DICT; case DICT0: z.istate.mode = BAD; z.msg = "need dictionary"; z.istate.marker = 0; // can try inflateSync return Z_STREAM_ERROR; case BLOCKS: r = z.istate.blocks.proc(z, r); if(r == Z_DATA_ERROR){ z.istate.mode = BAD; z.istate.marker = 0; // can try inflateSync break; } if(r == Z_OK){ r = f; } if(r != Z_STREAM_END){ return r; } r = f; z.istate.blocks.reset(z, z.istate.was); if(z.istate.nowrap!=0){ z.istate.mode=DONE; break; } z.istate.mode=CHECK4; goto case CHECK4; case CHECK4: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L; z.istate.mode=CHECK3; goto case CHECK3; case CHECK3: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L; z.istate.mode = CHECK2; goto case CHECK2; case CHECK2: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L; z.istate.mode = CHECK1; goto case CHECK1; case CHECK1: if(z.avail_in==0)return r;r=f; z.avail_in--; z.total_in++; z.istate.need+=(z.next_in[z.next_in_index++]&0xffL); if(((int)(z.istate.was[0])) != ((int)(z.istate.need))){ z.istate.mode = BAD; z.msg = "incorrect data check"; z.istate.marker = 5; // can't try inflateSync break; } z.istate.mode = DONE; goto case DONE; case DONE: return Z_STREAM_END; case BAD: return Z_DATA_ERROR; default: return Z_STREAM_ERROR; } } }
internal int inflateSync(ZStream z) { int n; // number of bytes to look at int p; // pointer to bytes int m; // number of marker bytes found in a row long r, w; // temporaries to save total_in and total_out // set up if(z == null || z.istate == null) return Z_STREAM_ERROR; if(z.istate.mode != BAD){ z.istate.mode = BAD; z.istate.marker = 0; } if((n=z.avail_in)==0) return Z_BUF_ERROR; p=z.next_in_index; m=z.istate.marker; // search while (n!=0 && m < 4){ if(z.next_in[p] == mark[m]){ m++; } else if(z.next_in[p]!=0){ m = 0; } else{ m = 4 - m; } p++; n--; } // restore z.total_in += p-z.next_in_index; z.next_in_index = p; z.avail_in = n; z.istate.marker = m; // return no joy or set up to restart on a new block if(m != 4){ return Z_DATA_ERROR; } r=z.total_in; w=z.total_out; inflateReset(z); z.total_in=r; z.total_out = w; z.istate.mode = BLOCKS; return Z_OK; }
internal int inflateInit(ZStream z, int w) { z.msg = null; blocks = null; // handle undocumented nowrap option (no zlib header or check) nowrap = 0; if(w < 0){ w = - w; nowrap = 1; } // set window size if(w<8 ||w>15){ inflateEnd(z); return Z_STREAM_ERROR; } wbits=w; z.istate.blocks=new InfBlocks(z, z.istate.nowrap!=0 ? null : this, 1<<w); // reset state inflateReset(z); return Z_OK; }
public virtual void End() { if (z == null) return; if (compress) z.deflateEnd(); else z.inflateEnd(); z.free(); z = null; }
internal int inflateSetDictionary(ZStream z, byte[] dictionary, int dictLength) { int index=0; int length = dictLength; if(z==null || z.istate == null|| z.istate.mode != DICT0) return Z_STREAM_ERROR; if(z._adler.adler32(1L, dictionary, 0, dictLength)!=z.adler){ return Z_DATA_ERROR; } z.adler = z._adler.adler32(0, null, 0, 0); if(length >= (1<<z.istate.wbits)){ length = (1<<z.istate.wbits)-1; index=dictLength - length; } z.istate.blocks.set_dictionary(dictionary, index, length); z.istate.mode = BLOCKS; return Z_OK; }
internal int deflateInit(ZStream strm, int level) { return(deflateInit(strm, level, 15)); }
// Returns true if inflate is currently at the end of a block generated // by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP // implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH // but removes the length bytes of the resulting empty stored block. When // decompressing, PPP checks that at the end of input packet, inflate is // waiting for these length bytes. internal int inflateSyncPoint(ZStream z) { if(z == null || z.istate == null || z.istate.blocks == null) return Z_STREAM_ERROR; return z.istate.blocks.sync_point(); }
public void End() { if(z==null) return; z.deflateEnd(); z.free(); z=null; }
private static ZStream GetDefaultZStream(bool nowrap) { ZStream z = new ZStream(); z.inflateInit(nowrap); return z; }
internal int inflate_fast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InfBlocks s, ZStream z) { int num = z.next_in_index; int num2 = z.avail_in; int num3 = s.bitb; int i = s.bitk; int num4 = s.write; int num5 = (num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4); int num6 = InfCodes.inflate_mask[bl]; int num7 = InfCodes.inflate_mask[bd]; int num10; int num11; while (true) { if (i >= 20) { int num8 = num3 & num6; int num9 = (tl_index + num8) * 3; if ((num10 = tl[num9]) == 0) { num3 >>= tl[num9 + 1]; i -= tl[num9 + 1]; s.window[num4++] = (byte)tl[num9 + 2]; num5--; } else { while (true) { num3 >>= tl[num9 + 1]; i -= tl[num9 + 1]; if ((num10 & 16) != 0) { break; } if ((num10 & 64) != 0) { goto IL_4B3; } num8 += tl[num9 + 2]; num8 += (num3 & InfCodes.inflate_mask[num10]); num9 = (tl_index + num8) * 3; if ((num10 = tl[num9]) == 0) { goto Block_20; } } num10 &= 15; num11 = tl[num9 + 2] + (num3 & InfCodes.inflate_mask[num10]); num3 >>= num10; for (i -= num10; i < 15; i += 8) { num2--; num3 |= (int)(z.next_in[num++] & 255) << i; } num8 = (num3 & num7); num9 = (td_index + num8) * 3; num10 = td[num9]; while (true) { num3 >>= td[num9 + 1]; i -= td[num9 + 1]; if ((num10 & 16) != 0) { break; } if ((num10 & 64) != 0) { goto IL_3C1; } num8 += td[num9 + 2]; num8 += (num3 & InfCodes.inflate_mask[num10]); num9 = (td_index + num8) * 3; num10 = td[num9]; } num10 &= 15; while (i < num10) { num2--; num3 |= (int)(z.next_in[num++] & 255) << i; i += 8; } int num12 = td[num9 + 2] + (num3 & InfCodes.inflate_mask[num10]); num3 >>= num10; i -= num10; num5 -= num11; int num13; if (num4 >= num12) { num13 = num4 - num12; if (num4 - num13 > 0 && 2 > num4 - num13) { s.window[num4++] = s.window[num13++]; s.window[num4++] = s.window[num13++]; num11 -= 2; } else { Array.Copy(s.window, num13, s.window, num4, 2); num4 += 2; num13 += 2; num11 -= 2; } } else { num13 = num4 - num12; do { num13 += s.end; }while (num13 < 0); num10 = s.end - num13; if (num11 > num10) { num11 -= num10; if (num4 - num13 > 0 && num10 > num4 - num13) { do { s.window[num4++] = s.window[num13++]; }while (--num10 != 0); } else { Array.Copy(s.window, num13, s.window, num4, num10); num4 += num10; num13 += num10; } num13 = 0; } } if (num4 - num13 > 0 && num11 > num4 - num13) { do { s.window[num4++] = s.window[num13++]; }while (--num11 != 0); goto IL_5C0; } Array.Copy(s.window, num13, s.window, num4, num11); num4 += num11; num13 += num11; goto IL_5C0; Block_20: num3 >>= tl[num9 + 1]; i -= tl[num9 + 1]; s.window[num4++] = (byte)tl[num9 + 2]; num5--; } IL_5C0: if (num5 < 258 || num2 < 10) { goto IL_5D2; } } else { num2--; num3 |= (int)(z.next_in[num++] & 255) << i; i += 8; } } IL_3C1: z.msg = "invalid distance code"; num11 = z.avail_in - num2; num11 = ((i >> 3 < num11) ? (i >> 3) : num11); num2 += num11; num -= num11; i -= num11 << 3; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(-3); IL_4B3: if ((num10 & 32) != 0) { num11 = z.avail_in - num2; num11 = ((i >> 3 < num11) ? (i >> 3) : num11); num2 += num11; num -= num11; i -= num11 << 3; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(1); } z.msg = "invalid literal/length code"; num11 = z.avail_in - num2; num11 = ((i >> 3 < num11) ? (i >> 3) : num11); num2 += num11; num -= num11; i -= num11 << 3; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(-3); IL_5D2: num11 = z.avail_in - num2; num11 = ((i >> 3 < num11) ? (i >> 3) : num11); num2 += num11; num -= num11; i -= num11 << 3; s.bitb = num3; s.bitk = i; z.avail_in = num2; z.total_in += (long)(num - z.next_in_index); z.next_in_index = num; s.write = num4; return(0); }
public ZOutputStream(Stream output, int level, bool nowrap) : base() { Debug.Assert(output.CanWrite); this.output = output; this.compress = true; this.z = new ZStream(); this.z.deflateInit(level, nowrap); }
internal void free(ZStream z){ reset(z, null); window=null; hufts=null; //ZFREE(z, s); }
internal InfBlocks(ZStream z, Object checkfn, int w){ hufts=new int[MANY*3]; window=new byte[w]; end=w; this.checkfn = checkfn; mode = TYPE; reset(z, null); }
internal void init(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, ZStream z) { mode = 0; lbits = (byte)bl; dbits = (byte)bd; ltree = tl; ltree_index = tl_index; dtree = td; dtree_index = td_index; tree = null; }
internal int proc(ZStream z, int r){ int t; // temporary storage int b; // bit buffer int k; // bits in bit buffer int p; // input data pointer int n; // bytes available there int q; // output window write pointer int m; { // bytes to end of window or read pointer // copy input/output information to locals (UPDATE macro restores) p=z.next_in_index;n=z.avail_in;b=bitb;k=bitk;} { q=write;m=(int)(q<read?read-q-1:end-q);} // process input based on current state while(true){ switch (mode){ case TYPE: while(k<(3)){ if(n!=0){ r=Z_OK; } else{ bitb=b; bitk=k; z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); }; n--; b|=(z.next_in[p++]&0xff)<<k; k+=8; } t = (int)(b & 7); last = t & 1; switch (t >> 1){ case 0: { // stored b>>=(3);k-=(3);} t = k & 7; { // go to byte boundary b>>=(t);k-=(t);} mode = LENS; // get length of stored block break; case 1: { // fixed int[] bl=new int[1]; int[] bd=new int[1]; int[][] tl=new int[1][]; int[][] td=new int[1][]; InfTree.inflate_trees_fixed(bl, bd, tl, td, z); codes.init(bl[0], bd[0], tl[0], 0, td[0], 0, z); } { b>>=(3);k-=(3);} mode = CODES; break; case 2: { // dynamic b>>=(3);k-=(3);} mode = TABLE; break; case 3: { // illegal b>>=(3);k-=(3);} mode = BAD; z.msg = "invalid block type"; r = Z_DATA_ERROR; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } break; case LENS: while(k<(32)){ if(n!=0){ r=Z_OK; } else{ bitb=b; bitk=k; z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); }; n--; b|=(z.next_in[p++]&0xff)<<k; k+=8; } if ((((~b) >> 16) & 0xffff) != (b & 0xffff)){ mode = BAD; z.msg = "invalid stored block lengths"; r = Z_DATA_ERROR; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } left = (b & 0xffff); b = k = 0; // dump bits mode = left!=0 ? STORED : (last!=0 ? DRY : TYPE); break; case STORED: if (n == 0){ bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } if(m==0){ if(q==end&&read!=0){ q=0; m=(int)(q<read?read-q-1:end-q); } if(m==0){ write=q; r=inflate_flush(z,r); q=write;m=(int)(q<read?read-q-1:end-q); if(q==end&&read!=0){ q=0; m=(int)(q<read?read-q-1:end-q); } if(m==0){ bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } } } r=Z_OK; t = left; if(t>n) t = n; if(t>m) t = m; System.Array.Copy(z.next_in, p, window, q, t); p += t; n -= t; q += t; m -= t; if ((left -= t) != 0) break; mode = last!=0 ? DRY : TYPE; break; case TABLE: while(k<(14)){ if(n!=0){ r=Z_OK; } else{ bitb=b; bitk=k; z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); }; n--; b|=(z.next_in[p++]&0xff)<<k; k+=8; } table = t = (b & 0x3fff); if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) { mode = BAD; z.msg = "too many length or distance symbols"; r = Z_DATA_ERROR; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); if(blens==null || blens.Length<t){ blens=new int[t]; } else{ for(int i=0; i<t; i++){blens[i]=0;} } { b>>=(14);k-=(14);} index = 0; mode = BTREE; goto case BTREE; case BTREE: while (index < 4 + (table >> 10)){ while(k<(3)){ if(n!=0){ r=Z_OK; } else{ bitb=b; bitk=k; z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); }; n--; b|=(z.next_in[p++]&0xff)<<k; k+=8; } blens[border[index++]] = b&7; { b>>=(3);k-=(3);} } while(index < 19){ blens[border[index++]] = 0; } bb[0] = 7; t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z); if (t != Z_OK){ r = t; if (r == Z_DATA_ERROR){ blens=null; mode = BAD; } bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } index = 0; mode = DTREE; goto case DTREE; case DTREE: while (true){ t = table; if(!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))){ break; } int i, j, c; t = bb[0]; while(k<(t)){ if(n!=0){ r=Z_OK; } else{ bitb=b; bitk=k; z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); }; n--; b|=(z.next_in[p++]&0xff)<<k; k+=8; } if(tb[0]==-1){ //System.err.println("null..."); } t=hufts[(tb[0]+(b&inflate_mask[t]))*3+1]; c=hufts[(tb[0]+(b&inflate_mask[t]))*3+2]; if (c < 16){ b>>=(t);k-=(t); blens[index++] = c; } else { // c == 16..18 i = c == 18 ? 7 : c - 14; j = c == 18 ? 11 : 3; while(k<(t+i)){ if(n!=0){ r=Z_OK; } else{ bitb=b; bitk=k; z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); }; n--; b|=(z.next_in[p++]&0xff)<<k; k+=8; } b>>=(t);k-=(t); j += (b & inflate_mask[i]); b>>=(i);k-=(i); i = index; t = table; if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1)){ blens=null; mode = BAD; z.msg = "invalid bit length repeat"; r = Z_DATA_ERROR; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } c = c == 16 ? blens[i-1] : 0; do{ blens[i++] = c; } while (--j!=0); index = i; } } tb[0]=-1; { int[] bl=new int[1]; int[] bd=new int[1]; int[] tl=new int[1]; int[] td=new int[1]; bl[0] = 9; // must be <= 9 for lookahead assumptions bd[0] = 6; // must be <= 9 for lookahead assumptions t = table; t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl, bd, tl, td, hufts, z); if (t != Z_OK){ if (t == Z_DATA_ERROR){ blens=null; mode = BAD; } r = t; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z,r); } codes.init(bl[0], bd[0], hufts, tl[0], hufts, td[0], z); } mode = CODES; goto case CODES; case CODES: bitb=b; bitk=k; z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; if ((r = codes.proc(this, z, r)) != Z_STREAM_END){ return inflate_flush(z, r); } r = Z_OK; codes.free(z); p=z.next_in_index; n=z.avail_in;b=bitb;k=bitk; q=write;m=(int)(q<read?read-q-1:end-q); if (last==0){ mode = TYPE; break; } mode = DRY; goto case DRY; case DRY: write=q; r=inflate_flush(z, r); q=write; m=(int)(q<read?read-q-1:end-q); if (read != write){ bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z, r); } mode = DONE; goto case DONE; case DONE: r = Z_STREAM_END; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z, r); case BAD: r = Z_DATA_ERROR; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z, r); default: r = Z_STREAM_ERROR; bitb=b; bitk=k; z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p; write=q; return inflate_flush(z, r); } } }
internal int proc(InfBlocks s, ZStream z, int r) { int num = 0; int num2 = 0; int num3 = 0; num3 = z.next_in_index; int num4 = z.avail_in; num = s.bitb; num2 = s.bitk; int num5 = s.write; int num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); while (true) { switch (mode) { case 0: if (num6 >= 258 && num4 >= 10) { s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; r = inflate_fast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, s, z); num3 = z.next_in_index; num4 = z.avail_in; num = s.bitb; num2 = s.bitk; num5 = s.write; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); if (r != 0) { mode = ((r == 1) ? 7 : 9); break; } } need = lbits; tree = ltree; tree_index = ltree_index; mode = 1; goto case 1; case 1: { int num7; for (num7 = need; num2 < num7; num2 += 8) { if (num4 != 0) { r = 0; num4--; num |= (z.next_in[num3++] & 0xFF) << num2; continue; } s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } int num8 = (tree_index + (num & inflate_mask[num7])) * 3; num >>= tree[num8 + 1]; num2 -= tree[num8 + 1]; int num9 = tree[num8]; if (num9 == 0) { lit = tree[num8 + 2]; mode = 6; break; } if (((uint)num9 & 0x10u) != 0) { get = num9 & 0xF; len = tree[num8 + 2]; mode = 2; break; } if ((num9 & 0x40) == 0) { need = num9; tree_index = num8 / 3 + tree[num8 + 2]; break; } if (((uint)num9 & 0x20u) != 0) { mode = 7; break; } mode = 9; z.msg = "invalid literal/length code"; r = -3; s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } case 2: { int num7; for (num7 = get; num2 < num7; num2 += 8) { if (num4 != 0) { r = 0; num4--; num |= (z.next_in[num3++] & 0xFF) << num2; continue; } s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } len += num & inflate_mask[num7]; num >>= num7; num2 -= num7; need = dbits; tree = dtree; tree_index = dtree_index; mode = 3; goto case 3; } case 3: { int num7; for (num7 = need; num2 < num7; num2 += 8) { if (num4 != 0) { r = 0; num4--; num |= (z.next_in[num3++] & 0xFF) << num2; continue; } s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } int num8 = (tree_index + (num & inflate_mask[num7])) * 3; num >>= tree[num8 + 1]; num2 -= tree[num8 + 1]; int num9 = tree[num8]; if (((uint)num9 & 0x10u) != 0) { get = num9 & 0xF; dist = tree[num8 + 2]; mode = 4; break; } if ((num9 & 0x40) == 0) { need = num9; tree_index = num8 / 3 + tree[num8 + 2]; break; } mode = 9; z.msg = "invalid distance code"; r = -3; s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } case 4: { int num7; for (num7 = get; num2 < num7; num2 += 8) { if (num4 != 0) { r = 0; num4--; num |= (z.next_in[num3++] & 0xFF) << num2; continue; } s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } dist += num & inflate_mask[num7]; num >>= num7; num2 -= num7; mode = 5; goto case 5; } case 5: { int i; for (i = num5 - dist; i < 0; i += s.end) { } while (len != 0) { if (num6 == 0) { if (num5 == s.end && s.read != 0) { num5 = 0; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); } if (num6 == 0) { s.write = num5; r = s.inflate_flush(z, r); num5 = s.write; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); if (num5 == s.end && s.read != 0) { num5 = 0; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); } if (num6 == 0) { s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } } } s.window[num5++] = s.window[i++]; num6--; if (i == s.end) { i = 0; } len--; } mode = 0; break; } case 6: if (num6 == 0) { if (num5 == s.end && s.read != 0) { num5 = 0; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); } if (num6 == 0) { s.write = num5; r = s.inflate_flush(z, r); num5 = s.write; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); if (num5 == s.end && s.read != 0) { num5 = 0; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); } if (num6 == 0) { s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } } } r = 0; s.window[num5++] = (byte)lit; num6--; mode = 0; break; case 7: if (num2 > 7) { num2 -= 8; num4++; num3--; } s.write = num5; r = s.inflate_flush(z, r); num5 = s.write; num6 = ((num5 < s.read) ? (s.read - num5 - 1) : (s.end - num5)); if (s.read != s.write) { s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } mode = 8; goto case 8; case 8: r = 1; s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); case 9: r = -3; s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); default: r = -2; s.bitb = num; s.bitk = num2; z.avail_in = num4; z.total_in += num3 - z.next_in_index; z.next_in_index = num3; s.write = num5; return(s.inflate_flush(z, r)); } } }
// copy as much as possible from the sliding window to the output area internal int inflate_flush(ZStream z, int r){ int n; int p; int q; // local copies of source and destination pointers p = z.next_out_index; q = read; // compute number of bytes to copy as far as end of window n = (int)((q <= write ? write : end) - q); if (n > z.avail_out) n = z.avail_out; if (n!=0 && r == Z_BUF_ERROR) r = Z_OK; // update counters z.avail_out -= n; z.total_out += n; // update check information if(checkfn != null) z.adler=check=z._adler.adler32(check, window, q, n); // copy as far as end of window System.Array.Copy(window, q, z.next_out, p, n); p += n; q += n; // see if more to copy at beginning of window if (q == end){ // wrap pointers q = 0; if (write == end) write = 0; // compute bytes to copy n = write - q; if (n > z.avail_out) n = z.avail_out; if (n!=0 && r == Z_BUF_ERROR) r = Z_OK; // update counters z.avail_out -= n; z.total_out += n; // update check information if(checkfn != null) z.adler=check=z._adler.adler32(check, window, q, n); // copy System.Array.Copy(window, q, z.next_out, p, n); p += n; q += n; } // update pointers z.next_out_index = p; read = q; // done return r; }
internal int inflate_fast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InfBlocks s, ZStream z) { int next_in_index = z.next_in_index; int num = z.avail_in; int num2 = s.bitb; int num3 = s.bitk; int num4 = s.write; int num5 = ((num4 < s.read) ? (s.read - num4 - 1) : (s.end - num4)); int num6 = inflate_mask[bl]; int num7 = inflate_mask[bd]; int num12; while (true) { if (num3 < 20) { num--; num2 |= (z.next_in[next_in_index++] & 0xFF) << num3; num3 += 8; continue; } int num8 = num2 & num6; int[] array = tl; int num9 = tl_index; int num10 = (num9 + num8) * 3; int num11; if ((num11 = array[num10]) == 0) { num2 >>= array[num10 + 1]; num3 -= array[num10 + 1]; s.window[num4++] = (byte)array[num10 + 2]; num5--; } else { while (true) { num2 >>= array[num10 + 1]; num3 -= array[num10 + 1]; if (((uint)num11 & 0x10u) != 0) { num11 &= 0xF; num12 = array[num10 + 2] + (num2 & inflate_mask[num11]); num2 >>= num11; for (num3 -= num11; num3 < 15; num3 += 8) { num--; num2 |= (z.next_in[next_in_index++] & 0xFF) << num3; } num8 = num2 & num7; array = td; num9 = td_index; num10 = (num9 + num8) * 3; num11 = array[num10]; while (true) { num2 >>= array[num10 + 1]; num3 -= array[num10 + 1]; if (((uint)num11 & 0x10u) != 0) { break; } if ((num11 & 0x40) == 0) { num8 += array[num10 + 2]; num8 += num2 & inflate_mask[num11]; num10 = (num9 + num8) * 3; num11 = array[num10]; continue; } z.msg = "invalid distance code"; num12 = z.avail_in - num; num12 = ((num3 >> 3 < num12) ? (num3 >> 3) : num12); num += num12; next_in_index -= num12; num3 -= num12 << 3; s.bitb = num2; s.bitk = num3; z.avail_in = num; z.total_in += next_in_index - z.next_in_index; z.next_in_index = next_in_index; s.write = num4; return(-3); } for (num11 &= 0xF; num3 < num11; num3 += 8) { num--; num2 |= (z.next_in[next_in_index++] & 0xFF) << num3; } int num13 = array[num10 + 2] + (num2 & inflate_mask[num11]); num2 >>= num11; num3 -= num11; num5 -= num12; int num14; if (num4 >= num13) { num14 = num4 - num13; if (num4 - num14 > 0 && 2 > num4 - num14) { s.window[num4++] = s.window[num14++]; s.window[num4++] = s.window[num14++]; num12 -= 2; } else { global::System.Array.Copy((global::System.Array)s.window, num14, (global::System.Array)s.window, num4, 2); num4 += 2; num14 += 2; num12 -= 2; } } else { num14 = num4 - num13; do { num14 += s.end; }while (num14 < 0); num11 = s.end - num14; if (num12 > num11) { num12 -= num11; if (num4 - num14 > 0 && num11 > num4 - num14) { do { s.window[num4++] = s.window[num14++]; }while (--num11 != 0); } else { global::System.Array.Copy((global::System.Array)s.window, num14, (global::System.Array)s.window, num4, num11); num4 += num11; num14 += num11; num11 = 0; } num14 = 0; } } if (num4 - num14 > 0 && num12 > num4 - num14) { do { s.window[num4++] = s.window[num14++]; }while (--num12 != 0); break; } global::System.Array.Copy((global::System.Array)s.window, num14, (global::System.Array)s.window, num4, num12); num4 += num12; num14 += num12; num12 = 0; break; } if ((num11 & 0x40) == 0) { num8 += array[num10 + 2]; num8 += num2 & inflate_mask[num11]; num10 = (num9 + num8) * 3; if ((num11 = array[num10]) == 0) { num2 >>= array[num10 + 1]; num3 -= array[num10 + 1]; s.window[num4++] = (byte)array[num10 + 2]; num5--; break; } continue; } if (((uint)num11 & 0x20u) != 0) { num12 = z.avail_in - num; num12 = ((num3 >> 3 < num12) ? (num3 >> 3) : num12); num += num12; next_in_index -= num12; num3 -= num12 << 3; s.bitb = num2; s.bitk = num3; z.avail_in = num; z.total_in += next_in_index - z.next_in_index; z.next_in_index = next_in_index; s.write = num4; return(1); } z.msg = "invalid literal/length code"; num12 = z.avail_in - num; num12 = ((num3 >> 3 < num12) ? (num3 >> 3) : num12); num += num12; next_in_index -= num12; num3 -= num12 << 3; s.bitb = num2; s.bitk = num3; z.avail_in = num; z.total_in += next_in_index - z.next_in_index; z.next_in_index = next_in_index; s.write = num4; return(-3); } } if (num5 < 258 || num < 10) { break; } } num12 = z.avail_in - num; num12 = ((num3 >> 3 < num12) ? (num3 >> 3) : num12); num += num12; next_in_index -= num12; num3 -= num12 << 3; s.bitb = num2; s.bitk = num3; z.avail_in = num; z.total_in += next_in_index - z.next_in_index; z.next_in_index = next_in_index; s.write = num4; return(0); }