Lines Matching refs:strm
97 extern void ZLIB_INTERNAL copy_with_crc(z_streamp strm, Bytef *dst, long size);
209 * allocating a large strm->next_in buffer and copying from it.
212 local unsigned read_buf(z_streamp strm, Bytef *buf, unsigned size) {
213 unsigned len = strm->avail_in;
218 strm->avail_in -= len;
224 if (strm->state->wrap == 2)
225 copy_with_crc(strm, buf, len);
229 zmemcpy(buf, strm->next_in, len);
230 if (strm->state->wrap == 1)
231 strm->adler = adler32(strm->adler, buf, len);
233 strm->next_in += len;
234 strm->total_in += len;
286 if (s->strm->avail_in == 0) break;
301 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
342 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
383 int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version,
385 return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
387 /* To do: ignore strm->next_in if we use it as window */
391 int ZEXPORT deflateInit2_(z_streamp strm, int level, int method,
411 if (strm == Z_NULL) return Z_STREAM_ERROR;
413 strm->msg = Z_NULL;
414 if (strm->zalloc == (alloc_func)0) {
418 strm->zalloc = zcalloc;
419 strm->opaque = (voidpf)0;
422 if (strm->zfree == (free_func)0)
426 strm->zfree = zcfree;
453 s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
455 strm->state = (struct internal_state FAR *)s;
456 s->strm = strm;
479 s->window = (Bytef *) ZALLOC(strm,
485 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
490 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
535 s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 5);
537 s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 4);
544 strm->msg = ERR_MSG(Z_MEM_ERROR);
545 deflateEnd (strm);
565 return deflateReset(strm);
571 local int deflateStateCheck(z_streamp strm) {
573 if (strm == Z_NULL ||
574 strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
576 s = strm->state;
577 if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
592 int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef *dictionary,
600 if (deflateStateCheck(strm) || dictionary == Z_NULL)
602 s = strm->state;
609 strm->adler = adler32(strm->adler, dictionary, dictLength);
625 avail = strm->avail_in;
626 next = strm->next_in;
627 strm->avail_in = dictLength;
628 strm->next_in = (z_const Bytef *)dictionary;
647 strm->next_in = next;
648 strm->avail_in = avail;
654 int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef *dictionary,
659 if (deflateStateCheck(strm))
661 s = strm->state;
673 int ZEXPORT deflateResetKeep(z_streamp strm) {
676 if (deflateStateCheck(strm)) {
680 strm->total_in = strm->total_out = 0;
681 strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
682 strm->data_type = Z_UNKNOWN;
684 s = (deflate_state *)strm->state;
696 strm->adler =
733 int ZEXPORT deflateReset(z_streamp strm) {
736 ret = deflateResetKeep(strm);
738 lm_init(strm->state);
743 int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head) {
744 if (deflateStateCheck(strm) || strm->state->wrap != 2)
746 strm->state->gzhead = head;
751 int ZEXPORT deflatePending(z_streamp strm, unsigned *pending, int *bits) {
752 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
754 *pending = strm->state->pending;
756 *bits = strm->state->bi_valid;
761 int ZEXPORT deflatePrime(z_streamp strm, int bits, int value) {
765 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
766 s = strm->state;
790 int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) {
794 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
795 s = strm->state;
810 int err = deflate(strm, Z_BLOCK);
813 if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
835 int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy,
839 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
840 s = strm->state;
872 uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen) {
888 if (deflateStateCheck(strm))
892 s = strm->state;
951 * strm->next_out buffer and copying into it. (See also read_buf()).
953 local void flush_pending(z_streamp strm) {
955 deflate_state *s = strm->state;
959 if (len > strm->avail_out) len = strm->avail_out;
962 zmemcpy(strm->next_out, s->pending_out, len);
963 strm->next_out += len;
965 strm->total_out += len;
966 strm->avail_out -= len;
979 strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
984 int ZEXPORT deflate(z_streamp strm, int flush) {
988 if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
991 s = strm->state;
993 if (strm->next_out == Z_NULL ||
994 (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
996 ERR_RETURN(strm, Z_STREAM_ERROR);
998 if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
1005 flush_pending(strm);
1006 if (strm->avail_out == 0) {
1021 } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
1023 ERR_RETURN(strm, Z_BUF_ERROR);
1027 if (s->status == FINISH_STATE && strm->avail_in != 0) {
1028 ERR_RETURN(strm, Z_BUF_ERROR);
1055 putShortMSB(s, (uInt)(strm->adler >> 16));
1056 putShortMSB(s, (uInt)(strm->adler & 0xffff));
1058 strm->adler = adler32(0L, Z_NULL, 0);
1062 flush_pending(strm);
1088 flush_pending(strm);
1114 strm->adler = crc32(strm->adler, s->pending_buf,
1131 flush_pending(strm);
1154 flush_pending(strm);
1176 flush_pending(strm);
1193 flush_pending(strm);
1199 put_byte(s, (Byte)(strm->adler & 0xff));
1200 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
1201 strm->adler = crc32(0L, Z_NULL, 0);
1206 flush_pending(strm);
1216 if (strm->avail_in != 0 || s->lookahead != 0 ||
1229 if (strm->avail_out == 0) {
1258 flush_pending(strm);
1259 if (strm->avail_out == 0) {
1273 put_byte(s, (Byte)(strm->adler & 0xff));
1274 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
1275 put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
1276 put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
1277 put_byte(s, (Byte)(strm->total_in & 0xff));
1278 put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
1279 put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
1280 put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
1285 putShortMSB(s, (uInt)(strm->adler >> 16));
1286 putShortMSB(s, (uInt)(strm->adler & 0xffff));
1288 flush_pending(strm);
1297 int ZEXPORT deflateEnd(z_streamp strm) {
1300 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
1302 status = strm->state->status;
1305 TRY_FREE(strm, strm->state->pending_buf);
1306 TRY_FREE(strm, strm->state->head);
1307 TRY_FREE(strm, strm->state->prev);
1308 TRY_FREE(strm, strm->state->window);
1310 ZFREE(strm, strm->state);
1311 strm->state = Z_NULL;
1343 ds->strm = dest;
1653 flush_pending(s->strm); \
1660 if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
1696 unsigned used = s->strm->avail_in;
1704 if (s->strm->avail_out < have) /* need room for header */
1707 have = s->strm->avail_out - have;
1709 if (len > (ulg)left + s->strm->avail_in)
1710 len = left + s->strm->avail_in; /* limit len to the input */
1721 len != left + s->strm->avail_in))
1727 last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
1737 flush_pending(s->strm);
1749 zmemcpy(s->strm->next_out, s->window + s->block_start, left);
1750 s->strm->next_out += left;
1751 s->strm->avail_out -= left;
1752 s->strm->total_out += left;
1761 read_buf(s->strm, s->strm->next_out, len);
1762 s->strm->next_out += len;
1763 s->strm->avail_out -= len;
1764 s->strm->total_out += len;
1774 used -= s->strm->avail_in; /* number of input bytes directly copied */
1781 zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
1795 zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
1810 s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
1815 if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
1826 if (have > s->strm->avail_in)
1827 have = s->strm->avail_in;
1829 read_buf(s->strm, s->window + s->strstart, have);
1848 s->strm->avail_in == 0 && left <= have)) {
1850 last = flush == Z_FINISH && s->strm->avail_in == 0 &&
1854 flush_pending(s->strm);
2072 if (s->strm->avail_out == 0) return need_more;