Lines Matching defs:strm
211 * allocating a large strm->next_in buffer and copying from it.
214 local unsigned read_buf(z_streamp strm, Bytef *buf, unsigned size) {
215 unsigned len = strm->avail_in;
220 strm->avail_in -= len;
222 zmemcpy(buf, strm->next_in, len);
223 if (strm->state->wrap == 1) {
224 strm->adler = adler32(strm->adler, buf, len);
227 else if (strm->state->wrap == 2) {
228 strm->adler = crc32(strm->adler, buf, len);
231 strm->next_in += len;
232 strm->total_in += len;
284 if (s->strm->avail_in == 0) break;
299 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
326 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
367 int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version,
369 return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
371 /* To do: ignore strm->next_in if we use it as window */
375 int ZEXPORT deflateInit2_(z_streamp strm, int level, int method,
386 if (strm == Z_NULL) return Z_STREAM_ERROR;
388 strm->msg = Z_NULL;
389 if (strm->zalloc == (alloc_func)0) {
393 strm->zalloc = zcalloc;
394 strm->opaque = (voidpf)0;
397 if (strm->zfree == (free_func)0)
401 strm->zfree = zcfree;
428 s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
430 strm->state = (struct internal_state FAR *)s;
431 s->strm = strm;
445 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
446 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
447 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
492 s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, LIT_BUFS);
498 strm->msg = ERR_MSG(Z_MEM_ERROR);
499 deflateEnd (strm);
519 return deflateReset(strm);
525 local int deflateStateCheck(z_streamp strm) {
527 if (strm == Z_NULL ||
528 strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
530 s = strm->state;
531 if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
546 int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef *dictionary,
554 if (deflateStateCheck(strm) || dictionary == Z_NULL)
556 s = strm->state;
563 strm->adler = adler32(strm->adler, dictionary, dictLength);
579 avail = strm->avail_in;
580 next = strm->next_in;
581 strm->avail_in = dictLength;
582 strm->next_in = (z_const Bytef *)dictionary;
605 strm->next_in = next;
606 strm->avail_in = avail;
612 int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef *dictionary,
617 if (deflateStateCheck(strm))
619 s = strm->state;
631 int ZEXPORT deflateResetKeep(z_streamp strm) {
634 if (deflateStateCheck(strm)) {
638 strm->total_in = strm->total_out = 0;
639 strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
640 strm->data_type = Z_UNKNOWN;
642 s = (deflate_state *)strm->state;
654 strm->adler =
691 int ZEXPORT deflateReset(z_streamp strm) {
694 ret = deflateResetKeep(strm);
696 lm_init(strm->state);
701 int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head) {
702 if (deflateStateCheck(strm) || strm->state->wrap != 2)
704 strm->state->gzhead = head;
709 int ZEXPORT deflatePending(z_streamp strm, unsigned *pending, int *bits) {
710 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
712 *pending = strm->state->pending;
714 *bits = strm->state->bi_valid;
719 int ZEXPORT deflateUsed(z_streamp strm, int *bits) {
720 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
722 *bits = strm->state->bi_used;
727 int ZEXPORT deflatePrime(z_streamp strm, int bits, int value) {
731 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
732 s = strm->state;
756 int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) {
760 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
761 s = strm->state;
776 int err = deflate(strm, Z_BLOCK);
779 if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
801 int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy,
805 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
806 s = strm->state;
838 uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen) {
854 if (deflateStateCheck(strm))
858 s = strm->state;
917 * strm->next_out buffer and copying into it. (See also read_buf()).
919 local void flush_pending(z_streamp strm) {
921 deflate_state *s = strm->state;
925 if (len > strm->avail_out) len = strm->avail_out;
928 zmemcpy(strm->next_out, s->pending_out, len);
929 strm->next_out += len;
931 strm->total_out += len;
932 strm->avail_out -= len;
945 strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
950 int ZEXPORT deflate(z_streamp strm, int flush) {
954 if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
957 s = strm->state;
959 if (strm->next_out == Z_NULL ||
960 (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
962 ERR_RETURN(strm, Z_STREAM_ERROR);
964 if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
971 flush_pending(strm);
972 if (strm->avail_out == 0) {
987 } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
989 ERR_RETURN(strm, Z_BUF_ERROR);
993 if (s->status == FINISH_STATE && strm->avail_in != 0) {
994 ERR_RETURN(strm, Z_BUF_ERROR);
1021 putShortMSB(s, (uInt)(strm->adler >> 16));
1022 putShortMSB(s, (uInt)(strm->adler & 0xffff));
1024 strm->adler = adler32(0L, Z_NULL, 0);
1028 flush_pending(strm);
1037 strm->adler = crc32(0L, Z_NULL, 0);
1054 flush_pending(strm);
1080 strm->adler = crc32(strm->adler, s->pending_buf,
1097 flush_pending(strm);
1120 flush_pending(strm);
1142 flush_pending(strm);
1159 flush_pending(strm);
1165 put_byte(s, (Byte)(strm->adler & 0xff));
1166 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
1167 strm->adler = crc32(0L, Z_NULL, 0);
1172 flush_pending(strm);
1182 if (strm->avail_in != 0 || s->lookahead != 0 ||
1195 if (strm->avail_out == 0) {
1224 flush_pending(strm);
1225 if (strm->avail_out == 0) {
1238 put_byte(s, (Byte)(strm->adler & 0xff));
1239 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
1240 put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
1241 put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
1242 put_byte(s, (Byte)(strm->total_in & 0xff));
1243 put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
1244 put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
1245 put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
1250 putShortMSB(s, (uInt)(strm->adler >> 16));
1251 putShortMSB(s, (uInt)(strm->adler & 0xffff));
1253 flush_pending(strm);
1262 int ZEXPORT deflateEnd(z_streamp strm) {
1265 if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
1267 status = strm->state->status;
1270 TRY_FREE(strm, strm->state->pending_buf, strm->state->pending_buf_size);
1271 TRY_FREE(strm, strm->state->head, strm->state->hash_size * sizeof(Pos));
1272 TRY_FREE(strm, strm->state->prev, strm->state->w_size * sizeof(Pos));
1273 TRY_FREE(strm, strm->state->window, strm->state->w_size * 2 * sizeof(Byte));
1275 ZFREE(strm, strm->state, sizeof(deflate_state));
1276 strm->state = Z_NULL;
1308 ds->strm = dest;
1600 flush_pending(s->strm); \
1607 if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
1646 unsigned used = s->strm->avail_in;
1654 if (s->strm->avail_out < have) /* need room for header */
1657 have = s->strm->avail_out - have;
1659 if (len > (ulg)left + s->strm->avail_in)
1660 len = left + s->strm->avail_in; /* limit len to the input */
1671 len != left + s->strm->avail_in))
1677 last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
1687 flush_pending(s->strm);
1699 zmemcpy(s->strm->next_out, s->window + s->block_start, left);
1700 s->strm->next_out += left;
1701 s->strm->avail_out -= left;
1702 s->strm->total_out += left;
1711 read_buf(s->strm, s->strm->next_out, len);
1712 s->strm->next_out += len;
1713 s->strm->avail_out -= len;
1714 s->strm->total_out += len;
1724 used -= s->strm->avail_in; /* number of input bytes directly copied */
1731 zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
1745 zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
1762 s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
1767 if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
1778 if (have > s->strm->avail_in)
1779 have = s->strm->avail_in;
1781 read_buf(s->strm, s->window + s->strstart, have);
1800 s->strm->avail_in == 0 && left <= have)) {
1802 last = flush == Z_FINISH && s->strm->avail_in == 0 &&
1806 flush_pending(s->strm);
2017 if (s->strm->avail_out == 0) return need_more;