internal void flush_block_only(bool eof) { _tr_flush_block((block_start < 0) ? (-1) : block_start, strstart - block_start, eof); block_start = strstart; strm.flush_pending(); }
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) (SupportClass.URShift(strm.adler, 16))); putShortMSB((int) (strm.adler & 0xffff)); } strm.adler = Adler32.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; 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) (SupportClass.URShift(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 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)SupportClass.URShift(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)SupportClass.URShift(strm.adler, 16)); putShortMSB((int)(strm.adler & 0xFFFF)); strm.flush_pending(); noheader = -1; return((pending == 0) ? 1 : 0); }