libkern/zlib/deflate.c

111 local void flush_pending  OF((z_streamp strm));
112 local int read_buf        OF((z_streamp strm, Bytef *buf, unsigned size));
231 int ZEXPORT deflateInit_(strm, level, version, stream_size)
232     z_streamp strm;
237     return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
239     /* To do: ignore strm->next_in if we use it as window */
243 int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
245     z_streamp strm;
267     if (strm == Z_NULL) return Z_STREAM_ERROR;
269     strm->msg = Z_NULL;
271     if (strm->zalloc == (alloc_func)0) {
272         strm->zalloc = zcalloc;
273         strm->opaque = (voidpf)0;
275     if (strm->zfree == (free_func)0) strm->zfree = zcfree;
300     s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
302     strm->state = (struct internal_state FAR *)s;
303     s->strm = strm;
316     s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
317     s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
318     s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
322     overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
329         strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
330         deflateEnd (strm);
340     return deflateReset(strm);
344 int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
345     z_streamp strm;
354     if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
355         strm->state->wrap == 2 ||
356         (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
359     s = strm->state;
361         strm->adler = adler32(strm->adler, dictionary, dictLength);
386 int ZEXPORT deflateReset (strm)
387     z_streamp strm;
391     if (strm == Z_NULL || strm->state == Z_NULL ||
392         strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
396     strm->total_in = strm->total_out = 0;
397     strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
398     strm->data_type = Z_UNKNOWN;
400     s = (deflate_state *)strm->state;
408     strm->adler =
422 int ZEXPORT deflateSetHeader (strm, head)
423     z_streamp strm;
426     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
427     if (strm->state->wrap != 2) return Z_STREAM_ERROR;
428     strm->state->gzhead = head;
433 int ZEXPORT deflatePrime (strm, bits, value)
434     z_streamp strm;
438     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
439     strm->state->bi_valid = bits;
440     strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
445 int ZEXPORT deflateParams(strm, level, strategy)
446     z_streamp strm;
454     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
455     s = strm->state;
467     if (func != configuration_table[level].func && strm->total_in != 0) {
469         err = deflate(strm, Z_PARTIAL_FLUSH);
483 int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
484     z_streamp strm;
492     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
493     s = strm->state;
518 uLong ZEXPORT deflateBound(strm, sourceLen)
519     z_streamp strm;
530     if (strm == Z_NULL || strm->state == Z_NULL)
534     s = strm->state;
558  * to avoid allocating a large strm->next_out buffer and copying into it.
561 local void flush_pending(strm)
562     z_streamp strm;
564     unsigned len = strm->state->pending;
566     if (len > strm->avail_out) len = strm->avail_out;
569     zmemcpy(strm->next_out, strm->state->pending_out, len);
570     strm->next_out  += len;
571     strm->state->pending_out  += len;
572     strm->total_out += len;
573     strm->avail_out  -= len;
574     strm->state->pending -= len;
575     if (strm->state->pending == 0) {
576         strm->state->pending_out = strm->state->pending_buf;
581 int ZEXPORT deflate (strm, flush)
582     z_streamp strm;
588     if (strm == Z_NULL || strm->state == Z_NULL ||
592     s = strm->state;
594     if (strm->next_out == Z_NULL ||
595         (strm->next_in == Z_NULL && strm->avail_in != 0) ||
597         ERR_RETURN(strm, Z_STREAM_ERROR);
599     if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
601     s->strm = strm; /* just in case */
609             strm->adler = z_crc32(0L, Z_NULL, 0);
645                     strm->adler = z_crc32(strm->adler, s->pending_buf,
674                 putShortMSB(s, (uInt)(strm->adler >> 16));
675                 putShortMSB(s, (uInt)(strm->adler & 0xffff));
677             strm->adler = adler32(0L, Z_NULL, 0);
688                         strm->adler = z_crc32(strm->adler, s->pending_buf + beg,
690                     flush_pending(strm);
699                 strm->adler = z_crc32(strm->adler, s->pending_buf + beg,
717                         strm->adler = z_crc32(strm->adler, s->pending_buf + beg,
719                     flush_pending(strm);
730                 strm->adler = z_crc32(strm->adler, s->pending_buf + beg,
748                         strm->adler = z_crc32(strm->adler, s->pending_buf + beg,
750                     flush_pending(strm);
761                 strm->adler = z_crc32(strm->adler, s->pending_buf + beg,
772                 flush_pending(strm);
774                 put_byte(s, (Byte)(strm->adler & 0xff));
775                 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
776                 strm->adler = z_crc32(0L, Z_NULL, 0);
787         flush_pending(strm);
788         if (strm->avail_out == 0) {
803     } else if (strm->avail_in == 0 && flush <= old_flush &&
805         ERR_RETURN(strm, Z_BUF_ERROR);
809     if (s->status == FINISH_STATE && strm->avail_in != 0) {
810         ERR_RETURN(strm, Z_BUF_ERROR);
815     if (strm->avail_in != 0 || s->lookahead != 0 ||
825             if (strm->avail_out == 0) {
849             flush_pending(strm);
850             if (strm->avail_out == 0) {
856     Assert(strm->avail_out > 0, "bug2");
864         put_byte(s, (Byte)(strm->adler & 0xff));
865         put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
866         put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
867         put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
868         put_byte(s, (Byte)(strm->total_in & 0xff));
869         put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
870         put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
871         put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
876         putShortMSB(s, (uInt)(strm->adler >> 16));
877         putShortMSB(s, (uInt)(strm->adler & 0xffff));
879     flush_pending(strm);
888 int ZEXPORT deflateEnd (strm)
889     z_streamp strm;
893     if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
895     status = strm->state->status;
907     TRY_FREE(strm, strm->state->pending_buf);
908     TRY_FREE(strm, strm->state->head);
909     TRY_FREE(strm, strm->state->prev);
910     TRY_FREE(strm, strm->state->window);
912     ZFREE(strm, strm->state);
913     strm->state = Z_NULL;
947     ds->strm = dest;
982  * allocating a large strm->next_in buffer and copying from it.
985 local int read_buf(strm, buf, size)
986     z_streamp strm;
990     unsigned len = strm->avail_in;
995     strm->avail_in  -= len;
997     if (strm->state->wrap == 1) {
998         strm->adler = adler32(strm->adler, strm->next_in, len);
1001     else if (strm->state->wrap == 2) {
1002         strm->adler = z_crc32(strm->adler, strm->next_in, len);
1005     zmemcpy(buf, strm->next_in, len);
1006     strm->next_in  += len;
1007     strm->total_in += len;
1356         if (s->strm->avail_in == 0) return;
1371         n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
1386     } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
1400    flush_pending(s->strm); \
1407    if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
1685             if (s->strm->avail_out == 0) return need_more;