1997-08-19 14:10:50 +00:00
|
|
|
/*
|
1998-03-21 20:56:16 +00:00
|
|
|
* This file is derived from various .h and .c files from the zlib-1.0.4
|
1997-08-19 14:10:50 +00:00
|
|
|
* distribution by Jean-loup Gailly and Mark Adler, with some additions
|
|
|
|
* by Paul Mackerras to aid in implementing Deflate compression and
|
|
|
|
* decompression for PPP packets. See zlib.h for conditions of
|
|
|
|
* distribution and use.
|
|
|
|
*
|
|
|
|
* Changes that have been made include:
|
|
|
|
* - added Z_PACKET_FLUSH (see zlib.h for details)
|
1998-03-21 20:56:16 +00:00
|
|
|
* - added inflateIncomp and deflateOutputPending
|
|
|
|
* - allow strm->next_out to be NULL, meaning discard the output
|
1997-08-19 14:10:50 +00:00
|
|
|
*
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
1998-03-21 20:56:16 +00:00
|
|
|
* ==FILEVERSION 971210==
|
1997-08-19 14:10:50 +00:00
|
|
|
*
|
|
|
|
* This marker is used by the Linux installation script to determine
|
|
|
|
* whether an up-to-date version of this file is already installed.
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#define NO_DUMMY_DECL
|
|
|
|
#define NO_ZCFUNCS
|
|
|
|
#define MY_ZCALLOC
|
|
|
|
|
1999-12-29 04:46:21 +00:00
|
|
|
#if defined(__FreeBSD__) && defined(_KERNEL)
|
1998-03-21 20:56:16 +00:00
|
|
|
#define inflate inflate_ppp /* FreeBSD already has an inflate :-( */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/* +++ zutil.h */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* zutil.h -- internal interface and configuration of the compression library
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Jean-loup Gailly.
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* WARNING: this file should *not* be used by applications. It is
|
|
|
|
part of the implementation of the compression library and is
|
|
|
|
subject to change. Applications should only use zlib.h.
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* From: zutil.h,v 1.16 1996/07/24 13:41:13 me Exp $ */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifndef _Z_UTIL_H
|
1997-08-19 14:10:50 +00:00
|
|
|
#define _Z_UTIL_H
|
|
|
|
|
1999-12-29 04:46:21 +00:00
|
|
|
#ifdef _KERNEL
|
1997-08-19 14:10:50 +00:00
|
|
|
#include <net/zlib.h>
|
|
|
|
#else
|
|
|
|
#include "zlib.h"
|
|
|
|
#endif
|
|
|
|
|
1999-12-29 04:46:21 +00:00
|
|
|
#ifdef _KERNEL
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Assume this is a *BSD or SVR4 kernel */
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
# define HAVE_MEMCPY
|
|
|
|
# define memcpy(d, s, n) bcopy((s), (d), (n))
|
|
|
|
# define memset(d, v, n) bzero((d), (n))
|
|
|
|
# define memcmp bcmp
|
|
|
|
|
|
|
|
#else
|
|
|
|
#if defined(__KERNEL__)
|
|
|
|
/* Assume this is a Linux kernel */
|
|
|
|
#include <linux/string.h>
|
|
|
|
#define HAVE_MEMCPY
|
|
|
|
|
|
|
|
#else /* not kernel */
|
|
|
|
|
|
|
|
#if defined(MSDOS)||defined(VMS)||defined(CRAY)||defined(WIN32)||defined(RISCOS)
|
|
|
|
# include <stddef.h>
|
|
|
|
# include <errno.h>
|
|
|
|
#else
|
|
|
|
extern int errno;
|
|
|
|
#endif
|
|
|
|
#ifdef STDC
|
|
|
|
# include <string.h>
|
|
|
|
# include <stdlib.h>
|
|
|
|
#endif
|
|
|
|
#endif /* __KERNEL__ */
|
1999-12-29 04:46:21 +00:00
|
|
|
#endif /* _KERNEL */
|
1998-03-21 20:56:16 +00:00
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
#ifndef local
|
|
|
|
# define local static
|
|
|
|
#endif
|
|
|
|
/* compile with -Dlocal if your debugger can't find static symbols */
|
|
|
|
|
|
|
|
typedef unsigned char uch;
|
|
|
|
typedef uch FAR uchf;
|
|
|
|
typedef unsigned short ush;
|
|
|
|
typedef ush FAR ushf;
|
|
|
|
typedef unsigned long ulg;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */
|
|
|
|
/* (size given to avoid silly warnings with Visual C++) */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#define ERR_RETURN(strm,err) \
|
1999-01-27 22:42:27 +00:00
|
|
|
return (strm->msg = (const char*)ERR_MSG(err), (err))
|
1998-03-21 20:56:16 +00:00
|
|
|
/* To be used only when the state is known to be valid */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* common constants */
|
|
|
|
|
|
|
|
#ifndef DEF_WBITS
|
|
|
|
# define DEF_WBITS MAX_WBITS
|
|
|
|
#endif
|
|
|
|
/* default windowBits for decompression. MAX_WBITS is for compression only */
|
|
|
|
|
|
|
|
#if MAX_MEM_LEVEL >= 8
|
|
|
|
# define DEF_MEM_LEVEL 8
|
|
|
|
#else
|
|
|
|
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
|
|
|
#endif
|
|
|
|
/* default memLevel */
|
|
|
|
|
|
|
|
#define STORED_BLOCK 0
|
|
|
|
#define STATIC_TREES 1
|
|
|
|
#define DYN_TREES 2
|
|
|
|
/* The three kinds of block type */
|
|
|
|
|
|
|
|
#define MIN_MATCH 3
|
|
|
|
#define MAX_MATCH 258
|
|
|
|
/* The minimum and maximum match lengths */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* target dependencies */
|
|
|
|
|
|
|
|
#ifdef MSDOS
|
|
|
|
# define OS_CODE 0x00
|
|
|
|
# ifdef __TURBOC__
|
|
|
|
# include <alloc.h>
|
|
|
|
# else /* MSC or DJGPP */
|
|
|
|
# include <malloc.h>
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef OS2
|
|
|
|
# define OS_CODE 0x06
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef WIN32 /* Window 95 & Windows NT */
|
|
|
|
# define OS_CODE 0x0b
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(VAXC) || defined(VMS)
|
|
|
|
# define OS_CODE 0x02
|
|
|
|
# define FOPEN(name, mode) \
|
|
|
|
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef AMIGA
|
|
|
|
# define OS_CODE 0x01
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(ATARI) || defined(atarist)
|
|
|
|
# define OS_CODE 0x05
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef MACOS
|
|
|
|
# define OS_CODE 0x07
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __50SERIES /* Prime/PRIMOS */
|
|
|
|
# define OS_CODE 0x0F
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TOPS20
|
|
|
|
# define OS_CODE 0x0a
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(_BEOS_) || defined(RISCOS)
|
|
|
|
# define fdopen(fd,mode) NULL /* No fdopen() */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Common defaults */
|
|
|
|
|
|
|
|
#ifndef OS_CODE
|
|
|
|
# define OS_CODE 0x03 /* assume Unix */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef FOPEN
|
|
|
|
# define FOPEN(name, mode) fopen((name), (mode))
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* functions */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifdef HAVE_STRERROR
|
|
|
|
extern char *strerror OF((int));
|
|
|
|
# define zstrerror(errnum) strerror(errnum)
|
1997-08-19 14:10:50 +00:00
|
|
|
#else
|
1998-03-21 20:56:16 +00:00
|
|
|
# define zstrerror(errnum) ""
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#if defined(pyr)
|
|
|
|
# define NO_MEMCPY
|
|
|
|
#endif
|
|
|
|
#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(_MSC_VER)
|
|
|
|
/* Use our own functions for small and medium model with MSC <= 5.0.
|
|
|
|
* You may have to use the same strategy for Borland C (untested).
|
|
|
|
*/
|
|
|
|
# define NO_MEMCPY
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
|
|
|
|
# define HAVE_MEMCPY
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_MEMCPY
|
1998-03-21 20:56:16 +00:00
|
|
|
# ifdef SMALL_MEDIUM /* MSDOS small or medium model */
|
|
|
|
# define zmemcpy _fmemcpy
|
|
|
|
# define zmemcmp _fmemcmp
|
|
|
|
# define zmemzero(dest, len) _fmemset(dest, 0, len)
|
|
|
|
# else
|
1997-08-19 14:10:50 +00:00
|
|
|
# define zmemcpy memcpy
|
1998-03-21 20:56:16 +00:00
|
|
|
# define zmemcmp memcmp
|
1997-08-19 14:10:50 +00:00
|
|
|
# define zmemzero(dest, len) memset(dest, 0, len)
|
1998-03-21 20:56:16 +00:00
|
|
|
# endif
|
1997-08-19 14:10:50 +00:00
|
|
|
#else
|
|
|
|
extern void zmemcpy OF((Bytef* dest, Bytef* source, uInt len));
|
1998-03-21 20:56:16 +00:00
|
|
|
extern int zmemcmp OF((Bytef* s1, Bytef* s2, uInt len));
|
1997-08-19 14:10:50 +00:00
|
|
|
extern void zmemzero OF((Bytef* dest, uInt len));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Diagnostic functions */
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
# include <stdio.h>
|
|
|
|
# ifndef verbose
|
|
|
|
# define verbose 0
|
|
|
|
# endif
|
1998-03-21 20:56:16 +00:00
|
|
|
extern void z_error OF((char *m));
|
1997-08-19 14:10:50 +00:00
|
|
|
# define Assert(cond,msg) {if(!(cond)) z_error(msg);}
|
|
|
|
# define Trace(x) fprintf x
|
|
|
|
# define Tracev(x) {if (verbose) fprintf x ;}
|
|
|
|
# define Tracevv(x) {if (verbose>1) fprintf x ;}
|
|
|
|
# define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
|
|
|
|
# define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
|
|
|
|
#else
|
|
|
|
# define Assert(cond,msg)
|
|
|
|
# define Trace(x)
|
|
|
|
# define Tracev(x)
|
|
|
|
# define Tracevv(x)
|
|
|
|
# define Tracec(c,x)
|
|
|
|
# define Tracecv(c,x)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
typedef uLong (*check_func) OF((uLong check, const Bytef *buf, uInt len));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
|
|
|
|
void zcfree OF((voidpf opaque, voidpf ptr));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
#define ZALLOC(strm, items, size) \
|
|
|
|
(*((strm)->zalloc))((strm)->opaque, (items), (size))
|
1998-03-21 20:56:16 +00:00
|
|
|
#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
|
|
|
|
#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#endif /* _Z_UTIL_H */
|
|
|
|
/* --- zutil.h */
|
|
|
|
|
|
|
|
/* +++ deflate.h */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* deflate.h -- internal compression state
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Jean-loup Gailly
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* WARNING: this file should *not* be used by applications. It is
|
|
|
|
part of the implementation of the compression library and is
|
|
|
|
subject to change. Applications should only use zlib.h.
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* From: deflate.h,v 1.10 1996/07/02 12:41:00 me Exp $ */
|
|
|
|
|
|
|
|
#ifndef _DEFLATE_H
|
|
|
|
#define _DEFLATE_H
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* #include "zutil.h" */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Internal compression state.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define LENGTH_CODES 29
|
|
|
|
/* number of length codes, not counting the special END_BLOCK code */
|
|
|
|
|
|
|
|
#define LITERALS 256
|
|
|
|
/* number of literal bytes 0..255 */
|
|
|
|
|
|
|
|
#define L_CODES (LITERALS+1+LENGTH_CODES)
|
|
|
|
/* number of Literal or Length codes, including the END_BLOCK code */
|
|
|
|
|
|
|
|
#define D_CODES 30
|
|
|
|
/* number of distance codes */
|
|
|
|
|
|
|
|
#define BL_CODES 19
|
|
|
|
/* number of codes used to transfer the bit lengths */
|
|
|
|
|
|
|
|
#define HEAP_SIZE (2*L_CODES+1)
|
|
|
|
/* maximum heap size */
|
|
|
|
|
|
|
|
#define MAX_BITS 15
|
|
|
|
/* All codes must not exceed MAX_BITS bits */
|
|
|
|
|
|
|
|
#define INIT_STATE 42
|
|
|
|
#define BUSY_STATE 113
|
|
|
|
#define FINISH_STATE 666
|
|
|
|
/* Stream status */
|
|
|
|
|
|
|
|
|
|
|
|
/* Data structure describing a single value and its code string. */
|
|
|
|
typedef struct ct_data_s {
|
|
|
|
union {
|
|
|
|
ush freq; /* frequency count */
|
|
|
|
ush code; /* bit string */
|
|
|
|
} fc;
|
|
|
|
union {
|
|
|
|
ush dad; /* father node in Huffman tree */
|
|
|
|
ush len; /* length of bit string */
|
|
|
|
} dl;
|
|
|
|
} FAR ct_data;
|
|
|
|
|
|
|
|
#define Freq fc.freq
|
|
|
|
#define Code fc.code
|
|
|
|
#define Dad dl.dad
|
|
|
|
#define Len dl.len
|
|
|
|
|
|
|
|
typedef struct static_tree_desc_s static_tree_desc;
|
|
|
|
|
|
|
|
typedef struct tree_desc_s {
|
|
|
|
ct_data *dyn_tree; /* the dynamic tree */
|
|
|
|
int max_code; /* largest code with non zero frequency */
|
|
|
|
static_tree_desc *stat_desc; /* the corresponding static tree */
|
|
|
|
} FAR tree_desc;
|
|
|
|
|
|
|
|
typedef ush Pos;
|
|
|
|
typedef Pos FAR Posf;
|
|
|
|
typedef unsigned IPos;
|
|
|
|
|
|
|
|
/* A Pos is an index in the character window. We use short instead of int to
|
|
|
|
* save space in the various tables. IPos is used only for parameter passing.
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef struct deflate_state {
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp strm; /* pointer back to this zlib stream */
|
1997-08-19 14:10:50 +00:00
|
|
|
int status; /* as the name implies */
|
|
|
|
Bytef *pending_buf; /* output still pending */
|
1998-03-21 20:56:16 +00:00
|
|
|
ulg pending_buf_size; /* size of pending_buf */
|
1997-08-19 14:10:50 +00:00
|
|
|
Bytef *pending_out; /* next pending byte to output to the stream */
|
|
|
|
int pending; /* nb of bytes in the pending buffer */
|
|
|
|
int noheader; /* suppress zlib header and adler32 */
|
1998-03-21 20:56:16 +00:00
|
|
|
Byte data_type; /* UNKNOWN, BINARY or ASCII */
|
1997-08-19 14:10:50 +00:00
|
|
|
Byte method; /* STORED (for zip only) or DEFLATED */
|
1998-03-21 20:56:16 +00:00
|
|
|
int last_flush; /* value of flush param for previous deflate call */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* used by deflate.c: */
|
|
|
|
|
|
|
|
uInt w_size; /* LZ77 window size (32K by default) */
|
|
|
|
uInt w_bits; /* log2(w_size) (8..16) */
|
|
|
|
uInt w_mask; /* w_size - 1 */
|
|
|
|
|
|
|
|
Bytef *window;
|
|
|
|
/* Sliding window. Input bytes are read into the second half of the window,
|
|
|
|
* and move to the first half later to keep a dictionary of at least wSize
|
|
|
|
* bytes. With this organization, matches are limited to a distance of
|
|
|
|
* wSize-MAX_MATCH bytes, but this ensures that IO is always
|
|
|
|
* performed with a length multiple of the block size. Also, it limits
|
|
|
|
* the window size to 64K, which is quite useful on MSDOS.
|
|
|
|
* To do: use the user input buffer as sliding window.
|
|
|
|
*/
|
|
|
|
|
|
|
|
ulg window_size;
|
|
|
|
/* Actual size of window: 2*wSize, except when the user input buffer
|
|
|
|
* is directly used as sliding window.
|
|
|
|
*/
|
|
|
|
|
|
|
|
Posf *prev;
|
|
|
|
/* Link to older string with same hash index. To limit the size of this
|
|
|
|
* array to 64K, this link is maintained only for the last 32K strings.
|
|
|
|
* An index in this array is thus a window index modulo 32K.
|
|
|
|
*/
|
|
|
|
|
|
|
|
Posf *head; /* Heads of the hash chains or NIL. */
|
|
|
|
|
|
|
|
uInt ins_h; /* hash index of string to be inserted */
|
|
|
|
uInt hash_size; /* number of elements in hash table */
|
|
|
|
uInt hash_bits; /* log2(hash_size) */
|
|
|
|
uInt hash_mask; /* hash_size-1 */
|
|
|
|
|
|
|
|
uInt hash_shift;
|
|
|
|
/* Number of bits by which ins_h must be shifted at each input
|
|
|
|
* step. It must be such that after MIN_MATCH steps, the oldest
|
|
|
|
* byte no longer takes part in the hash key, that is:
|
|
|
|
* hash_shift * MIN_MATCH >= hash_bits
|
|
|
|
*/
|
|
|
|
|
|
|
|
long block_start;
|
|
|
|
/* Window position at the beginning of the current output block. Gets
|
|
|
|
* negative when the window is moved backwards.
|
|
|
|
*/
|
|
|
|
|
|
|
|
uInt match_length; /* length of best match */
|
|
|
|
IPos prev_match; /* previous match */
|
|
|
|
int match_available; /* set if previous match exists */
|
|
|
|
uInt strstart; /* start of string to insert */
|
|
|
|
uInt match_start; /* start of matching string */
|
|
|
|
uInt lookahead; /* number of valid bytes ahead in window */
|
|
|
|
|
|
|
|
uInt prev_length;
|
|
|
|
/* Length of the best match at previous step. Matches not greater than this
|
|
|
|
* are discarded. This is used in the lazy match evaluation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
uInt max_chain_length;
|
|
|
|
/* To speed up deflation, hash chains are never searched beyond this
|
|
|
|
* length. A higher limit improves compression ratio but degrades the
|
|
|
|
* speed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
uInt max_lazy_match;
|
|
|
|
/* Attempt to find a better match only when the current match is strictly
|
|
|
|
* smaller than this value. This mechanism is used only for compression
|
|
|
|
* levels >= 4.
|
|
|
|
*/
|
|
|
|
# define max_insert_length max_lazy_match
|
|
|
|
/* Insert new strings in the hash table only if the match length is not
|
|
|
|
* greater than this length. This saves time but degrades compression.
|
|
|
|
* max_insert_length is used only for compression levels <= 3.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int level; /* compression level (1..9) */
|
|
|
|
int strategy; /* favor or force Huffman coding*/
|
|
|
|
|
|
|
|
uInt good_match;
|
|
|
|
/* Use a faster search when the previous match is longer than this */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int nice_match; /* Stop searching when current match exceeds this */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* used by trees.c: */
|
|
|
|
/* Didn't use ct_data typedef below to supress compiler warning */
|
|
|
|
struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
|
|
|
|
struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
|
|
|
|
struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
|
|
|
|
|
|
|
|
struct tree_desc_s l_desc; /* desc. for literal tree */
|
|
|
|
struct tree_desc_s d_desc; /* desc. for distance tree */
|
|
|
|
struct tree_desc_s bl_desc; /* desc. for bit length tree */
|
|
|
|
|
|
|
|
ush bl_count[MAX_BITS+1];
|
|
|
|
/* number of codes at each bit length for an optimal tree */
|
|
|
|
|
|
|
|
int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
|
|
|
|
int heap_len; /* number of elements in the heap */
|
|
|
|
int heap_max; /* element of largest frequency */
|
|
|
|
/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
|
|
|
|
* The same heap array is used to build all trees.
|
|
|
|
*/
|
|
|
|
|
|
|
|
uch depth[2*L_CODES+1];
|
|
|
|
/* Depth of each subtree used as tie breaker for trees of equal frequency
|
|
|
|
*/
|
|
|
|
|
|
|
|
uchf *l_buf; /* buffer for literals or lengths */
|
|
|
|
|
|
|
|
uInt lit_bufsize;
|
|
|
|
/* Size of match buffer for literals/lengths. There are 4 reasons for
|
|
|
|
* limiting lit_bufsize to 64K:
|
|
|
|
* - frequencies can be kept in 16 bit counters
|
|
|
|
* - if compression is not successful for the first block, all input
|
|
|
|
* data is still in the window so we can still emit a stored block even
|
|
|
|
* when input comes from standard input. (This can also be done for
|
|
|
|
* all blocks if lit_bufsize is not greater than 32K.)
|
|
|
|
* - if compression is not successful for a file smaller than 64K, we can
|
|
|
|
* even emit a stored file instead of a stored block (saving 5 bytes).
|
|
|
|
* This is applicable only for zip (not gzip or zlib).
|
|
|
|
* - creating new Huffman trees less frequently may not provide fast
|
|
|
|
* adaptation to changes in the input data statistics. (Take for
|
|
|
|
* example a binary file with poorly compressible code followed by
|
|
|
|
* a highly compressible string table.) Smaller buffer sizes give
|
|
|
|
* fast adaptation but have of course the overhead of transmitting
|
|
|
|
* trees more frequently.
|
|
|
|
* - I can't count above 4
|
|
|
|
*/
|
|
|
|
|
|
|
|
uInt last_lit; /* running index in l_buf */
|
|
|
|
|
|
|
|
ushf *d_buf;
|
|
|
|
/* Buffer for distances. To simplify the code, d_buf and l_buf have
|
|
|
|
* the same number of elements. To use different lengths, an extra flag
|
|
|
|
* array would be necessary.
|
|
|
|
*/
|
|
|
|
|
|
|
|
ulg opt_len; /* bit length of current block with optimal trees */
|
|
|
|
ulg static_len; /* bit length of current block with static trees */
|
|
|
|
ulg compressed_len; /* total bit length of compressed file */
|
|
|
|
uInt matches; /* number of string matches in current block */
|
|
|
|
int last_eob_len; /* bit length of EOB code for last block */
|
|
|
|
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
ulg bits_sent; /* bit length of the compressed data */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
ush bi_buf;
|
|
|
|
/* Output buffer. bits are inserted starting at the bottom (least
|
|
|
|
* significant bits).
|
|
|
|
*/
|
|
|
|
int bi_valid;
|
|
|
|
/* Number of valid bits in bi_buf. All bits above the last valid bit
|
|
|
|
* are always zero.
|
|
|
|
*/
|
|
|
|
|
|
|
|
} FAR deflate_state;
|
|
|
|
|
|
|
|
/* Output a byte on the stream.
|
|
|
|
* IN assertion: there is enough room in pending_buf.
|
|
|
|
*/
|
|
|
|
#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
|
|
|
|
|
|
|
|
|
|
|
|
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
|
|
|
|
/* Minimum amount of lookahead, except at the end of the input file.
|
|
|
|
* See deflate.c for comments about the MIN_MATCH+1.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
|
|
|
|
/* In order to simplify the code, particularly on 16 bit machines, match
|
|
|
|
* distances are limited to MAX_DIST instead of WSIZE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* in trees.c */
|
1998-03-21 20:56:16 +00:00
|
|
|
void _tr_init OF((deflate_state *s));
|
|
|
|
int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
|
|
|
|
ulg _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len,
|
|
|
|
int eof));
|
|
|
|
void _tr_align OF((deflate_state *s));
|
|
|
|
void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
|
1997-08-19 14:10:50 +00:00
|
|
|
int eof));
|
1998-03-21 20:56:16 +00:00
|
|
|
void _tr_stored_type_only OF((deflate_state *));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#endif
|
|
|
|
/* --- deflate.h */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ deflate.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* deflate.c -- compress data using the deflation algorithm
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Jean-loup Gailly.
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ALGORITHM
|
|
|
|
*
|
|
|
|
* The "deflation" process depends on being able to identify portions
|
|
|
|
* of the input text which are identical to earlier input (within a
|
|
|
|
* sliding window trailing behind the input currently being processed).
|
|
|
|
*
|
|
|
|
* The most straightforward technique turns out to be the fastest for
|
|
|
|
* most input files: try all possible matches and select the longest.
|
|
|
|
* The key feature of this algorithm is that insertions into the string
|
|
|
|
* dictionary are very simple and thus fast, and deletions are avoided
|
|
|
|
* completely. Insertions are performed at each input character, whereas
|
|
|
|
* string matches are performed only when the previous match ends. So it
|
|
|
|
* is preferable to spend more time in matches to allow very fast string
|
|
|
|
* insertions and avoid deletions. The matching algorithm for small
|
|
|
|
* strings is inspired from that of Rabin & Karp. A brute force approach
|
|
|
|
* is used to find longer strings when a small match has been found.
|
|
|
|
* A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
|
|
|
|
* (by Leonid Broukhis).
|
|
|
|
* A previous version of this file used a more sophisticated algorithm
|
|
|
|
* (by Fiala and Greene) which is guaranteed to run in linear amortized
|
|
|
|
* time, but has a larger average cost, uses more memory and is patented.
|
|
|
|
* However the F&G algorithm may be faster for some highly redundant
|
|
|
|
* files if the parameter max_chain_length (described below) is too large.
|
|
|
|
*
|
|
|
|
* ACKNOWLEDGEMENTS
|
|
|
|
*
|
|
|
|
* The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
|
|
|
|
* I found it in 'freeze' written by Leonid Broukhis.
|
|
|
|
* Thanks to many people for bug reports and testing.
|
|
|
|
*
|
|
|
|
* REFERENCES
|
|
|
|
*
|
1998-03-21 20:56:16 +00:00
|
|
|
* Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
|
|
|
|
* Available in ftp://ds.internic.net/rfc/rfc1951.txt
|
1997-08-19 14:10:50 +00:00
|
|
|
*
|
|
|
|
* A description of the Rabin and Karp algorithm is given in the book
|
|
|
|
* "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
|
|
|
|
*
|
|
|
|
* Fiala,E.R., and Greene,D.H.
|
|
|
|
* Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* From: deflate.c,v 1.15 1996/07/24 13:40:58 me Exp $ */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* #include "deflate.h" */
|
|
|
|
|
|
|
|
char deflate_copyright[] = " deflate 1.0.4 Copyright 1995-1996 Jean-loup Gailly ";
|
1997-08-19 14:10:50 +00:00
|
|
|
/*
|
|
|
|
If you use the zlib library in a product, an acknowledgment is welcome
|
|
|
|
in the documentation of your product. If for some reason you cannot
|
|
|
|
include such an acknowledgment, I would appreciate that you keep this
|
|
|
|
copyright string in the executable of your product.
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* ===========================================================================
|
|
|
|
* Function prototypes.
|
|
|
|
*/
|
|
|
|
typedef enum {
|
|
|
|
need_more, /* block not completed, need more input or more output */
|
|
|
|
block_done, /* block flush performed */
|
|
|
|
finish_started, /* finish started, need only more output at next deflate */
|
|
|
|
finish_done /* finish done, accept no more input or output */
|
|
|
|
} block_state;
|
|
|
|
|
|
|
|
typedef block_state (*compress_func) OF((deflate_state *s, int flush));
|
|
|
|
/* Compression function. Returns the block state after the call. */
|
|
|
|
|
|
|
|
local void fill_window OF((deflate_state *s));
|
|
|
|
local block_state deflate_stored OF((deflate_state *s, int flush));
|
|
|
|
local block_state deflate_fast OF((deflate_state *s, int flush));
|
|
|
|
local block_state deflate_slow OF((deflate_state *s, int flush));
|
|
|
|
local void lm_init OF((deflate_state *s));
|
|
|
|
local void putShortMSB OF((deflate_state *s, uInt b));
|
|
|
|
local void flush_pending OF((z_streamp strm));
|
|
|
|
local int read_buf OF((z_streamp strm, charf *buf, unsigned size));
|
|
|
|
#ifdef ASMV
|
|
|
|
void match_init OF((void)); /* asm code initialization */
|
|
|
|
uInt longest_match OF((deflate_state *s, IPos cur_match));
|
|
|
|
#else
|
|
|
|
local uInt longest_match OF((deflate_state *s, IPos cur_match));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
local void check_match OF((deflate_state *s, IPos start, IPos match,
|
|
|
|
int length));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Local data
|
|
|
|
*/
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
#define NIL 0
|
|
|
|
/* Tail of hash chains */
|
|
|
|
|
|
|
|
#ifndef TOO_FAR
|
|
|
|
# define TOO_FAR 4096
|
|
|
|
#endif
|
|
|
|
/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
|
|
|
|
|
|
|
|
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
|
|
|
|
/* Minimum amount of lookahead, except at the end of the input file.
|
|
|
|
* See deflate.c for comments about the MIN_MATCH+1.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Values for max_lazy_match, good_match and max_chain_length, depending on
|
|
|
|
* the desired pack level (0..9). The values given below have been tuned to
|
|
|
|
* exclude worst case performance for pathological files. Better values may be
|
|
|
|
* found for specific files.
|
|
|
|
*/
|
|
|
|
typedef struct config_s {
|
|
|
|
ush good_length; /* reduce lazy search above this match length */
|
|
|
|
ush max_lazy; /* do not perform lazy search above this match length */
|
|
|
|
ush nice_length; /* quit search above this match length */
|
|
|
|
ush max_chain;
|
1998-03-21 20:56:16 +00:00
|
|
|
compress_func func;
|
1997-08-19 14:10:50 +00:00
|
|
|
} config;
|
|
|
|
|
|
|
|
local config configuration_table[10] = {
|
|
|
|
/* good lazy nice chain */
|
1998-03-21 20:56:16 +00:00
|
|
|
/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */
|
|
|
|
/* 1 */ {4, 4, 8, 4, deflate_fast}, /* maximum speed, no lazy matches */
|
|
|
|
/* 2 */ {4, 5, 16, 8, deflate_fast},
|
|
|
|
/* 3 */ {4, 6, 32, 32, deflate_fast},
|
|
|
|
|
|
|
|
/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */
|
|
|
|
/* 5 */ {8, 16, 32, 32, deflate_slow},
|
|
|
|
/* 6 */ {8, 16, 128, 128, deflate_slow},
|
|
|
|
/* 7 */ {8, 32, 128, 256, deflate_slow},
|
|
|
|
/* 8 */ {32, 128, 258, 1024, deflate_slow},
|
|
|
|
/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* maximum compression */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
|
|
|
|
* For deflate_fast() (levels <= 3) good is ignored and lazy has a different
|
|
|
|
* meaning.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define EQUAL 0
|
|
|
|
/* result of memcmp for equal strings */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
|
1997-08-19 14:10:50 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Update a hash value with the given input byte
|
|
|
|
* IN assertion: all calls to to UPDATE_HASH are made with consecutive
|
|
|
|
* input characters, so that a running hash key can be computed from the
|
|
|
|
* previous key instead of complete recalculation each time.
|
|
|
|
*/
|
|
|
|
#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
|
|
|
|
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Insert string str in the dictionary and set match_head to the previous head
|
|
|
|
* of the hash chain (the most recent string with same hash key). Return
|
|
|
|
* the previous length of the hash chain.
|
|
|
|
* IN assertion: all calls to to INSERT_STRING are made with consecutive
|
|
|
|
* input characters and the first MIN_MATCH bytes of str are valid
|
|
|
|
* (except for the last MIN_MATCH-1 bytes of the input file).
|
|
|
|
*/
|
|
|
|
#define INSERT_STRING(s, str, match_head) \
|
|
|
|
(UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
|
|
|
|
s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \
|
1998-03-21 20:56:16 +00:00
|
|
|
s->head[s->ins_h] = (Pos)(str))
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Initialize the hash table (avoiding 64K overflow for 16 bit systems).
|
|
|
|
* prev[] will be initialized on the fly.
|
|
|
|
*/
|
|
|
|
#define CLEAR_HASH(s) \
|
|
|
|
s->head[s->hash_size-1] = NIL; \
|
|
|
|
zmemzero((charf *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
|
|
|
|
|
|
|
|
/* ========================================================================= */
|
1998-03-21 20:56:16 +00:00
|
|
|
int deflateInit_(strm, level, version, stream_size)
|
|
|
|
z_streamp strm;
|
1997-08-19 14:10:50 +00:00
|
|
|
int level;
|
1998-03-21 20:56:16 +00:00
|
|
|
const char *version;
|
|
|
|
int stream_size;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
|
|
|
|
Z_DEFAULT_STRATEGY, version, stream_size);
|
1997-08-19 14:10:50 +00:00
|
|
|
/* To do: ignore strm->next_in if we use it as window */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ========================================================================= */
|
1998-03-21 20:56:16 +00:00
|
|
|
int deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
|
|
|
|
version, stream_size)
|
|
|
|
z_streamp strm;
|
1997-08-19 14:10:50 +00:00
|
|
|
int level;
|
|
|
|
int method;
|
|
|
|
int windowBits;
|
|
|
|
int memLevel;
|
|
|
|
int strategy;
|
1998-03-21 20:56:16 +00:00
|
|
|
const char *version;
|
|
|
|
int stream_size;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
deflate_state *s;
|
|
|
|
int noheader = 0;
|
1998-03-21 20:56:16 +00:00
|
|
|
static char* my_version = ZLIB_VERSION;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
ushf *overlay;
|
|
|
|
/* We overlay pending_buf and d_buf+l_buf. This works since the average
|
|
|
|
* output size for (length,distance) codes is <= 24 bits.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (version == Z_NULL || version[0] != my_version[0] ||
|
|
|
|
stream_size != sizeof(z_stream)) {
|
|
|
|
return Z_VERSION_ERROR;
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
if (strm == Z_NULL) return Z_STREAM_ERROR;
|
|
|
|
|
|
|
|
strm->msg = Z_NULL;
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifndef NO_ZCFUNCS
|
|
|
|
if (strm->zalloc == Z_NULL) {
|
|
|
|
strm->zalloc = zcalloc;
|
|
|
|
strm->opaque = (voidpf)0;
|
|
|
|
}
|
|
|
|
if (strm->zfree == Z_NULL) strm->zfree = zcfree;
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
if (level == Z_DEFAULT_COMPRESSION) level = 6;
|
|
|
|
|
|
|
|
if (windowBits < 0) { /* undocumented feature: suppress zlib header */
|
|
|
|
noheader = 1;
|
|
|
|
windowBits = -windowBits;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
|
|
|
|
windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
|
|
|
|
strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
|
1997-08-19 14:10:50 +00:00
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
|
1997-08-19 14:10:50 +00:00
|
|
|
if (s == Z_NULL) return Z_MEM_ERROR;
|
|
|
|
strm->state = (struct internal_state FAR *)s;
|
|
|
|
s->strm = strm;
|
|
|
|
|
|
|
|
s->noheader = noheader;
|
|
|
|
s->w_bits = windowBits;
|
|
|
|
s->w_size = 1 << s->w_bits;
|
|
|
|
s->w_mask = s->w_size - 1;
|
|
|
|
|
|
|
|
s->hash_bits = memLevel + 7;
|
|
|
|
s->hash_size = 1 << s->hash_bits;
|
|
|
|
s->hash_mask = s->hash_size - 1;
|
|
|
|
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
|
|
|
|
s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
|
|
|
|
s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
|
|
|
|
s->pending_buf = (uchf *) overlay;
|
|
|
|
s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
|
|
|
|
s->pending_buf == Z_NULL) {
|
1999-01-27 22:42:27 +00:00
|
|
|
strm->msg = (const char*)ERR_MSG(Z_MEM_ERROR);
|
1997-08-19 14:10:50 +00:00
|
|
|
deflateEnd (strm);
|
|
|
|
return Z_MEM_ERROR;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
|
|
|
|
s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
s->level = level;
|
|
|
|
s->strategy = strategy;
|
|
|
|
s->method = (Byte)method;
|
|
|
|
|
|
|
|
return deflateReset(strm);
|
|
|
|
}
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* ========================================================================= */
|
|
|
|
int deflateSetDictionary (strm, dictionary, dictLength)
|
|
|
|
z_streamp strm;
|
|
|
|
const Bytef *dictionary;
|
|
|
|
uInt dictLength;
|
|
|
|
{
|
|
|
|
deflate_state *s;
|
|
|
|
uInt length = dictLength;
|
|
|
|
uInt n;
|
|
|
|
IPos hash_head = 0;
|
|
|
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
|
|
|
|
s = (deflate_state *) strm->state;
|
|
|
|
if (s->status != INIT_STATE) return Z_STREAM_ERROR;
|
|
|
|
|
|
|
|
strm->adler = adler32(strm->adler, dictionary, dictLength);
|
|
|
|
|
|
|
|
if (length < MIN_MATCH) return Z_OK;
|
|
|
|
if (length > MAX_DIST(s)) {
|
|
|
|
length = MAX_DIST(s);
|
|
|
|
#ifndef USE_DICT_HEAD
|
|
|
|
dictionary += dictLength - length; /* use the tail of the dictionary */
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
zmemcpy((charf *)s->window, dictionary, length);
|
|
|
|
s->strstart = length;
|
|
|
|
s->block_start = (long)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.
|
|
|
|
*/
|
|
|
|
s->ins_h = s->window[0];
|
|
|
|
UPDATE_HASH(s, s->ins_h, s->window[1]);
|
|
|
|
for (n = 0; n <= length - MIN_MATCH; n++) {
|
|
|
|
INSERT_STRING(s, n, hash_head);
|
|
|
|
}
|
|
|
|
if (hash_head) hash_head = 0; /* to make compiler happy */
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* ========================================================================= */
|
|
|
|
int deflateReset (strm)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp strm;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
deflate_state *s;
|
|
|
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL ||
|
1998-03-21 20:56:16 +00:00
|
|
|
strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
strm->total_in = strm->total_out = 0;
|
|
|
|
strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
|
|
|
|
strm->data_type = Z_UNKNOWN;
|
|
|
|
|
|
|
|
s = (deflate_state *)strm->state;
|
|
|
|
s->pending = 0;
|
|
|
|
s->pending_out = s->pending_buf;
|
|
|
|
|
|
|
|
if (s->noheader < 0) {
|
|
|
|
s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */
|
|
|
|
}
|
|
|
|
s->status = s->noheader ? BUSY_STATE : INIT_STATE;
|
1998-03-21 20:56:16 +00:00
|
|
|
strm->adler = 1;
|
|
|
|
s->last_flush = Z_NO_FLUSH;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
_tr_init(s);
|
1997-08-19 14:10:50 +00:00
|
|
|
lm_init(s);
|
|
|
|
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* ========================================================================= */
|
|
|
|
int deflateParams(strm, level, strategy)
|
|
|
|
z_streamp strm;
|
|
|
|
int level;
|
|
|
|
int strategy;
|
|
|
|
{
|
|
|
|
deflate_state *s;
|
|
|
|
compress_func func;
|
|
|
|
int err = Z_OK;
|
|
|
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
|
|
|
s = (deflate_state *) strm->state;
|
|
|
|
|
|
|
|
if (level == Z_DEFAULT_COMPRESSION) {
|
|
|
|
level = 6;
|
|
|
|
}
|
|
|
|
if (level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
func = configuration_table[s->level].func;
|
|
|
|
|
|
|
|
if (func != configuration_table[level].func && strm->total_in != 0) {
|
|
|
|
/* Flush the last buffer: */
|
|
|
|
err = deflate(strm, Z_PARTIAL_FLUSH);
|
|
|
|
}
|
|
|
|
if (s->level != level) {
|
|
|
|
s->level = level;
|
|
|
|
s->max_lazy_match = configuration_table[level].max_lazy;
|
|
|
|
s->good_match = configuration_table[level].good_length;
|
|
|
|
s->nice_match = configuration_table[level].nice_length;
|
|
|
|
s->max_chain_length = configuration_table[level].max_chain;
|
|
|
|
}
|
|
|
|
s->strategy = strategy;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* =========================================================================
|
|
|
|
* Put a short in the pending buffer. The 16-bit value is put in MSB order.
|
|
|
|
* IN assertion: the stream state is correct and there is enough room in
|
|
|
|
* pending_buf.
|
|
|
|
*/
|
|
|
|
local void putShortMSB (s, b)
|
|
|
|
deflate_state *s;
|
|
|
|
uInt b;
|
|
|
|
{
|
|
|
|
put_byte(s, (Byte)(b >> 8));
|
|
|
|
put_byte(s, (Byte)(b & 0xff));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* =========================================================================
|
1998-03-21 20:56:16 +00:00
|
|
|
* Flush as much pending output as possible. All deflate() output goes
|
|
|
|
* through this function so some applications may wish to modify it
|
|
|
|
* to avoid allocating a large strm->next_out buffer and copying into it.
|
|
|
|
* (See also read_buf()).
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
|
|
|
local void flush_pending(strm)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp strm;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
deflate_state *s = (deflate_state *) strm->state;
|
|
|
|
unsigned len = s->pending;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
if (len > strm->avail_out) len = strm->avail_out;
|
|
|
|
if (len == 0) return;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (strm->next_out != Z_NULL) {
|
|
|
|
zmemcpy(strm->next_out, s->pending_out, len);
|
1997-08-19 14:10:50 +00:00
|
|
|
strm->next_out += len;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
s->pending_out += len;
|
1997-08-19 14:10:50 +00:00
|
|
|
strm->total_out += len;
|
1998-03-21 20:56:16 +00:00
|
|
|
strm->avail_out -= len;
|
|
|
|
s->pending -= len;
|
|
|
|
if (s->pending == 0) {
|
|
|
|
s->pending_out = s->pending_buf;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ========================================================================= */
|
|
|
|
int deflate (strm, flush)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp strm;
|
1997-08-19 14:10:50 +00:00
|
|
|
int flush;
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
int old_flush; /* value of flush param for previous deflate call */
|
|
|
|
deflate_state *s;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL ||
|
|
|
|
flush > Z_FINISH || flush < 0) {
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
s = (deflate_state *) strm->state;
|
|
|
|
|
|
|
|
if ((strm->next_in == Z_NULL && strm->avail_in != 0) ||
|
|
|
|
(s->status == FINISH_STATE && flush != Z_FINISH)) {
|
1997-08-19 14:10:50 +00:00
|
|
|
ERR_RETURN(strm, Z_STREAM_ERROR);
|
|
|
|
}
|
|
|
|
if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
s->strm = strm; /* just in case */
|
|
|
|
old_flush = s->last_flush;
|
|
|
|
s->last_flush = flush;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* Write the zlib header */
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->status == INIT_STATE) {
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
|
|
|
|
uInt level_flags = (s->level-1) >> 1;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
if (level_flags > 3) level_flags = 3;
|
|
|
|
header |= (level_flags << 6);
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->strstart != 0) header |= PRESET_DICT;
|
1997-08-19 14:10:50 +00:00
|
|
|
header += 31 - (header % 31);
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
s->status = BUSY_STATE;
|
|
|
|
putShortMSB(s, header);
|
|
|
|
|
|
|
|
/* Save the adler32 of the preset dictionary: */
|
|
|
|
if (s->strstart != 0) {
|
|
|
|
putShortMSB(s, (uInt)(strm->adler >> 16));
|
|
|
|
putShortMSB(s, (uInt)(strm->adler & 0xffff));
|
|
|
|
}
|
|
|
|
strm->adler = 1L;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Flush as much pending output as possible */
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->pending != 0) {
|
1997-08-19 14:10:50 +00:00
|
|
|
flush_pending(strm);
|
1998-03-21 20:56:16 +00:00
|
|
|
if (strm->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:
|
|
|
|
*/
|
|
|
|
s->last_flush = -1;
|
|
|
|
return Z_OK;
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* 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.
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
} else if (strm->avail_in == 0 && flush <= old_flush &&
|
|
|
|
flush != Z_FINISH) {
|
|
|
|
ERR_RETURN(strm, Z_BUF_ERROR);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* User must not provide more input after the first FINISH: */
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->status == FINISH_STATE && strm->avail_in != 0) {
|
1997-08-19 14:10:50 +00:00
|
|
|
ERR_RETURN(strm, Z_BUF_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Start a new block or continue the current one.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
if (strm->avail_in != 0 || s->lookahead != 0 ||
|
|
|
|
(flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
|
|
|
|
block_state bstate;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
bstate = (*(configuration_table[s->level].func))(s, flush);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (bstate == finish_started || bstate == finish_done) {
|
|
|
|
s->status = FINISH_STATE;
|
|
|
|
}
|
|
|
|
if (bstate == need_more || bstate == finish_started) {
|
|
|
|
if (strm->avail_out == 0) {
|
|
|
|
s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
return Z_OK;
|
1998-03-21 20:56:16 +00:00
|
|
|
/* 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.
|
|
|
|
*/
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
if (bstate == block_done) {
|
|
|
|
if (flush == Z_PARTIAL_FLUSH) {
|
|
|
|
_tr_align(s);
|
|
|
|
} else if (flush == Z_PACKET_FLUSH) {
|
|
|
|
/* Output just the 3-bit `stored' block type value,
|
|
|
|
but not a zero length. */
|
|
|
|
_tr_stored_type_only(s);
|
|
|
|
} else { /* FULL_FLUSH or SYNC_FLUSH */
|
|
|
|
_tr_stored_block(s, (char*)0, 0L, 0);
|
|
|
|
/* For a full flush, this empty block will be recognized
|
|
|
|
* as a special marker by inflate_sync().
|
|
|
|
*/
|
|
|
|
if (flush == Z_FULL_FLUSH) {
|
|
|
|
CLEAR_HASH(s); /* forget history */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
flush_pending(strm);
|
|
|
|
if (strm->avail_out == 0) {
|
|
|
|
s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
Assert(strm->avail_out > 0, "bug2");
|
|
|
|
|
|
|
|
if (flush != Z_FINISH) return Z_OK;
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->noheader) return Z_STREAM_END;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* Write the zlib trailer (adler32) */
|
1998-03-21 20:56:16 +00:00
|
|
|
putShortMSB(s, (uInt)(strm->adler >> 16));
|
|
|
|
putShortMSB(s, (uInt)(strm->adler & 0xffff));
|
1997-08-19 14:10:50 +00:00
|
|
|
flush_pending(strm);
|
|
|
|
/* If avail_out is zero, the application will call deflate again
|
|
|
|
* to flush the rest.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
s->noheader = -1; /* write the trailer only once! */
|
|
|
|
return s->pending != 0 ? Z_OK : Z_STREAM_END;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ========================================================================= */
|
|
|
|
int deflateEnd (strm)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp strm;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
int status;
|
|
|
|
deflate_state *s;
|
|
|
|
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
|
|
|
s = (deflate_state *) strm->state;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
status = s->status;
|
|
|
|
if (status != INIT_STATE && status != BUSY_STATE &&
|
|
|
|
status != FINISH_STATE) {
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Deallocate in reverse order of allocations: */
|
|
|
|
TRY_FREE(strm, s->pending_buf);
|
|
|
|
TRY_FREE(strm, s->head);
|
|
|
|
TRY_FREE(strm, s->prev);
|
|
|
|
TRY_FREE(strm, s->window);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
ZFREE(strm, s);
|
1997-08-19 14:10:50 +00:00
|
|
|
strm->state = Z_NULL;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* =========================================================================
|
|
|
|
* Copy the source state to the destination state.
|
|
|
|
*/
|
|
|
|
int deflateCopy (dest, source)
|
|
|
|
z_streamp dest;
|
|
|
|
z_streamp source;
|
|
|
|
{
|
|
|
|
deflate_state *ds;
|
|
|
|
deflate_state *ss;
|
|
|
|
ushf *overlay;
|
|
|
|
|
|
|
|
if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL)
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
ss = (deflate_state *) source->state;
|
|
|
|
|
1998-06-20 16:28:04 +00:00
|
|
|
zmemcpy(dest, source, sizeof(*dest));
|
1998-03-21 20:56:16 +00:00
|
|
|
|
|
|
|
ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
|
|
|
|
if (ds == Z_NULL) return Z_MEM_ERROR;
|
|
|
|
dest->state = (struct internal_state FAR *) ds;
|
1998-06-20 16:28:04 +00:00
|
|
|
zmemcpy(ds, ss, sizeof(*ds));
|
1998-03-21 20:56:16 +00:00
|
|
|
ds->strm = dest;
|
|
|
|
|
|
|
|
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
|
|
|
|
ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
|
|
|
|
ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
|
|
|
|
overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
|
|
|
|
ds->pending_buf = (uchf *) overlay;
|
|
|
|
|
|
|
|
if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
|
|
|
|
ds->pending_buf == Z_NULL) {
|
|
|
|
deflateEnd (dest);
|
|
|
|
return Z_MEM_ERROR;
|
|
|
|
}
|
|
|
|
/* ??? following zmemcpy doesn't work for 16-bit MSDOS */
|
|
|
|
zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
|
|
|
|
zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
|
|
|
|
zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
|
|
|
|
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
|
|
|
|
|
|
|
|
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
|
|
|
|
ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
|
|
|
|
ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
|
|
|
|
|
|
|
|
ds->l_desc.dyn_tree = ds->dyn_ltree;
|
|
|
|
ds->d_desc.dyn_tree = ds->dyn_dtree;
|
|
|
|
ds->bl_desc.dyn_tree = ds->bl_tree;
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* ===========================================================================
|
|
|
|
* Return the number of bytes of output which are immediately available
|
|
|
|
* for output from the decompressor.
|
|
|
|
*/
|
|
|
|
int deflateOutputPending (strm)
|
|
|
|
z_streamp strm;
|
|
|
|
{
|
|
|
|
if (strm == Z_NULL || strm->state == Z_NULL) return 0;
|
|
|
|
|
|
|
|
return ((deflate_state *)(strm->state))->pending;
|
|
|
|
}
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* ===========================================================================
|
|
|
|
* Read a new buffer from the current input stream, update the adler32
|
1998-03-21 20:56:16 +00:00
|
|
|
* and total number of bytes read. All deflate() input goes through
|
|
|
|
* this function so some applications may wish to modify it to avoid
|
|
|
|
* allocating a large strm->next_in buffer and copying from it.
|
|
|
|
* (See also flush_pending()).
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
|
|
|
local int read_buf(strm, buf, size)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp strm;
|
1997-08-19 14:10:50 +00:00
|
|
|
charf *buf;
|
|
|
|
unsigned size;
|
|
|
|
{
|
|
|
|
unsigned len = strm->avail_in;
|
|
|
|
|
|
|
|
if (len > size) len = size;
|
|
|
|
if (len == 0) return 0;
|
|
|
|
|
|
|
|
strm->avail_in -= len;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (!((deflate_state *)(strm->state))->noheader) {
|
|
|
|
strm->adler = adler32(strm->adler, strm->next_in, len);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
zmemcpy(buf, strm->next_in, len);
|
|
|
|
strm->next_in += len;
|
|
|
|
strm->total_in += len;
|
|
|
|
|
|
|
|
return (int)len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Initialize the "longest match" routines for a new zlib stream
|
|
|
|
*/
|
|
|
|
local void lm_init (s)
|
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
s->window_size = (ulg)2L*s->w_size;
|
|
|
|
|
|
|
|
CLEAR_HASH(s);
|
|
|
|
|
|
|
|
/* Set the default configuration parameters:
|
|
|
|
*/
|
|
|
|
s->max_lazy_match = configuration_table[s->level].max_lazy;
|
|
|
|
s->good_match = configuration_table[s->level].good_length;
|
|
|
|
s->nice_match = configuration_table[s->level].nice_length;
|
|
|
|
s->max_chain_length = configuration_table[s->level].max_chain;
|
|
|
|
|
|
|
|
s->strstart = 0;
|
|
|
|
s->block_start = 0L;
|
|
|
|
s->lookahead = 0;
|
1998-03-21 20:56:16 +00:00
|
|
|
s->match_length = s->prev_length = MIN_MATCH-1;
|
1997-08-19 14:10:50 +00:00
|
|
|
s->match_available = 0;
|
|
|
|
s->ins_h = 0;
|
|
|
|
#ifdef ASMV
|
|
|
|
match_init(); /* initialize the asm code */
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Set match_start to the longest match starting at the given string and
|
|
|
|
* return its length. Matches shorter or equal to prev_length are discarded,
|
|
|
|
* in which case the result is equal to prev_length and match_start is
|
|
|
|
* garbage.
|
|
|
|
* IN assertions: cur_match is the head of the hash chain for the current
|
|
|
|
* string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
|
1998-03-21 20:56:16 +00:00
|
|
|
* OUT assertion: the match length is not greater than s->lookahead.
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
|
|
|
#ifndef ASMV
|
|
|
|
/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
|
|
|
|
* match.S. The code will be functionally equivalent.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
local uInt longest_match(s, cur_match)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
IPos cur_match; /* current match */
|
|
|
|
{
|
|
|
|
unsigned chain_length = s->max_chain_length;/* max hash chain length */
|
|
|
|
register Bytef *scan = s->window + s->strstart; /* current string */
|
|
|
|
register Bytef *match; /* matched string */
|
|
|
|
register int len; /* length of current match */
|
|
|
|
int best_len = s->prev_length; /* best match length so far */
|
1998-03-21 20:56:16 +00:00
|
|
|
int nice_match = s->nice_match; /* stop if match long enough */
|
1997-08-19 14:10:50 +00:00
|
|
|
IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
|
|
|
s->strstart - (IPos)MAX_DIST(s) : NIL;
|
|
|
|
/* Stop when cur_match becomes <= limit. To simplify the code,
|
|
|
|
* we prevent matches with the string of window index 0.
|
|
|
|
*/
|
|
|
|
Posf *prev = s->prev;
|
|
|
|
uInt wmask = s->w_mask;
|
|
|
|
|
|
|
|
#ifdef UNALIGNED_OK
|
|
|
|
/* Compare two bytes at a time. Note: this is not always beneficial.
|
|
|
|
* Try with and without -DUNALIGNED_OK to check.
|
|
|
|
*/
|
|
|
|
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
|
|
|
|
register ush scan_start = *(ushf*)scan;
|
|
|
|
register ush scan_end = *(ushf*)(scan+best_len-1);
|
|
|
|
#else
|
|
|
|
register Bytef *strend = s->window + s->strstart + MAX_MATCH;
|
|
|
|
register Byte scan_end1 = scan[best_len-1];
|
|
|
|
register Byte scan_end = scan[best_len];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
|
|
|
|
* It is easy to get rid of this optimization if necessary.
|
|
|
|
*/
|
|
|
|
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
|
|
|
|
|
|
|
|
/* Do not waste too much time if we already have a good match: */
|
|
|
|
if (s->prev_length >= s->good_match) {
|
|
|
|
chain_length >>= 2;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Do not look for matches beyond the end of the input. This is necessary
|
|
|
|
* to make deflate deterministic.
|
|
|
|
*/
|
|
|
|
if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
|
|
|
|
|
|
|
|
do {
|
|
|
|
Assert(cur_match < s->strstart, "no future");
|
|
|
|
match = s->window + cur_match;
|
|
|
|
|
|
|
|
/* Skip to next match if the match length cannot increase
|
|
|
|
* or if the match length is less than 2:
|
|
|
|
*/
|
|
|
|
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
|
|
|
|
/* This code assumes sizeof(unsigned short) == 2. Do not use
|
|
|
|
* UNALIGNED_OK if your compiler uses a different size.
|
|
|
|
*/
|
|
|
|
if (*(ushf*)(match+best_len-1) != scan_end ||
|
|
|
|
*(ushf*)match != scan_start) continue;
|
|
|
|
|
|
|
|
/* It is not necessary to compare scan[2] and match[2] since they are
|
|
|
|
* always equal when the other bytes match, given that the hash keys
|
|
|
|
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
|
|
|
|
* strstart+3, +5, ... up to strstart+257. We check for insufficient
|
|
|
|
* lookahead only every 4th comparison; the 128th check will be made
|
|
|
|
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
|
|
|
|
* necessary to put more guard bytes at the end of the window, or
|
|
|
|
* to check more often for insufficient lookahead.
|
|
|
|
*/
|
|
|
|
Assert(scan[2] == match[2], "scan[2]?");
|
|
|
|
scan++, match++;
|
|
|
|
do {
|
|
|
|
} while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
|
|
|
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
|
|
|
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
|
|
|
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
|
|
|
scan < strend);
|
|
|
|
/* The funny "do {}" generates better code on most compilers */
|
|
|
|
|
|
|
|
/* Here, scan <= window+strstart+257 */
|
|
|
|
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
|
|
|
|
if (*scan == *match) scan++;
|
|
|
|
|
|
|
|
len = (MAX_MATCH - 1) - (int)(strend-scan);
|
|
|
|
scan = strend - (MAX_MATCH-1);
|
|
|
|
|
|
|
|
#else /* UNALIGNED_OK */
|
|
|
|
|
|
|
|
if (match[best_len] != scan_end ||
|
|
|
|
match[best_len-1] != scan_end1 ||
|
|
|
|
*match != *scan ||
|
|
|
|
*++match != scan[1]) continue;
|
|
|
|
|
|
|
|
/* The check at best_len-1 can be removed because it will be made
|
|
|
|
* again later. (This heuristic is not always a win.)
|
|
|
|
* It is not necessary to compare scan[2] and match[2] since they
|
|
|
|
* are always equal when the other bytes match, given that
|
|
|
|
* the hash keys are equal and that HASH_BITS >= 8.
|
|
|
|
*/
|
|
|
|
scan += 2, match++;
|
|
|
|
Assert(*scan == *match, "match[2]?");
|
|
|
|
|
|
|
|
/* We check for insufficient lookahead only every 8th comparison;
|
|
|
|
* the 256th check will be made at strstart+258.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
} while (*++scan == *++match && *++scan == *++match &&
|
|
|
|
*++scan == *++match && *++scan == *++match &&
|
|
|
|
*++scan == *++match && *++scan == *++match &&
|
|
|
|
*++scan == *++match && *++scan == *++match &&
|
|
|
|
scan < strend);
|
|
|
|
|
|
|
|
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
|
|
|
|
|
|
|
|
len = MAX_MATCH - (int)(strend - scan);
|
|
|
|
scan = strend - MAX_MATCH;
|
|
|
|
|
|
|
|
#endif /* UNALIGNED_OK */
|
|
|
|
|
|
|
|
if (len > best_len) {
|
|
|
|
s->match_start = cur_match;
|
|
|
|
best_len = len;
|
1998-03-21 20:56:16 +00:00
|
|
|
if (len >= nice_match) break;
|
1997-08-19 14:10:50 +00:00
|
|
|
#ifdef UNALIGNED_OK
|
|
|
|
scan_end = *(ushf*)(scan+best_len-1);
|
|
|
|
#else
|
|
|
|
scan_end1 = scan[best_len-1];
|
|
|
|
scan_end = scan[best_len];
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
} while ((cur_match = prev[cur_match & wmask]) > limit
|
|
|
|
&& --chain_length != 0);
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if ((uInt)best_len <= s->lookahead) return best_len;
|
|
|
|
return s->lookahead;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
#endif /* ASMV */
|
|
|
|
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
/* ===========================================================================
|
|
|
|
* Check that the match at match_start is indeed a match.
|
|
|
|
*/
|
|
|
|
local void check_match(s, start, match, length)
|
|
|
|
deflate_state *s;
|
|
|
|
IPos start, match;
|
|
|
|
int length;
|
|
|
|
{
|
|
|
|
/* check that the match is indeed a match */
|
1998-03-21 20:56:16 +00:00
|
|
|
if (zmemcmp((charf *)s->window + match,
|
1997-08-19 14:10:50 +00:00
|
|
|
(charf *)s->window + start, length) != EQUAL) {
|
1998-03-21 20:56:16 +00:00
|
|
|
fprintf(stderr, " start %u, match %u, length %d\n",
|
|
|
|
start, match, length);
|
|
|
|
do {
|
|
|
|
fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
|
|
|
|
} while (--length != 0);
|
1997-08-19 14:10:50 +00:00
|
|
|
z_error("invalid match");
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
if (z_verbose > 1) {
|
1997-08-19 14:10:50 +00:00
|
|
|
fprintf(stderr,"\\[%d,%d]", start-match, length);
|
|
|
|
do { putc(s->window[start++], stderr); } while (--length != 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define check_match(s, start, match, length)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Fill the window when the lookahead becomes insufficient.
|
|
|
|
* Updates strstart and lookahead.
|
|
|
|
*
|
|
|
|
* IN assertion: lookahead < MIN_LOOKAHEAD
|
|
|
|
* OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
|
|
|
|
* At least one byte has been read, or avail_in == 0; reads are
|
|
|
|
* performed for at least two bytes (required for the zip translate_eol
|
|
|
|
* option -- not supported here).
|
|
|
|
*/
|
|
|
|
local void fill_window(s)
|
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
register unsigned n, m;
|
|
|
|
register Posf *p;
|
|
|
|
unsigned more; /* Amount of free space at the end of the window. */
|
|
|
|
uInt wsize = s->w_size;
|
|
|
|
|
|
|
|
do {
|
|
|
|
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
|
|
|
|
|
|
|
|
/* Deal with !@#$% 64K limit: */
|
|
|
|
if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
|
|
|
|
more = wsize;
|
1998-03-21 20:56:16 +00:00
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
} else if (more == (unsigned)(-1)) {
|
|
|
|
/* Very unlikely, but possible on 16 bit machine if strstart == 0
|
|
|
|
* and lookahead == 1 (input done one byte at time)
|
|
|
|
*/
|
|
|
|
more--;
|
|
|
|
|
|
|
|
/* If the window is almost full and there is insufficient lookahead,
|
|
|
|
* move the upper half to the lower one to make room in the upper half.
|
|
|
|
*/
|
|
|
|
} else if (s->strstart >= wsize+MAX_DIST(s)) {
|
|
|
|
|
|
|
|
zmemcpy((charf *)s->window, (charf *)s->window+wsize,
|
|
|
|
(unsigned)wsize);
|
|
|
|
s->match_start -= wsize;
|
|
|
|
s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
|
|
|
|
s->block_start -= (long) wsize;
|
|
|
|
|
|
|
|
/* Slide the hash table (could be avoided with 32 bit values
|
1998-03-21 20:56:16 +00:00
|
|
|
at the expense of memory usage). We slide even when level == 0
|
|
|
|
to keep the hash table consistent if we switch back to level > 0
|
|
|
|
later. (Using level 0 permanently is not an optimal usage of
|
|
|
|
zlib, so we don't care about this pathological case.)
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
|
|
|
n = s->hash_size;
|
|
|
|
p = &s->head[n];
|
|
|
|
do {
|
|
|
|
m = *--p;
|
|
|
|
*p = (Pos)(m >= wsize ? m-wsize : NIL);
|
|
|
|
} while (--n);
|
|
|
|
|
|
|
|
n = wsize;
|
|
|
|
p = &s->prev[n];
|
|
|
|
do {
|
|
|
|
m = *--p;
|
|
|
|
*p = (Pos)(m >= wsize ? m-wsize : NIL);
|
|
|
|
/* If n is not on any hash chain, prev[n] is garbage but
|
|
|
|
* its value will never be used.
|
|
|
|
*/
|
|
|
|
} while (--n);
|
|
|
|
more += wsize;
|
|
|
|
}
|
|
|
|
if (s->strm->avail_in == 0) return;
|
|
|
|
|
|
|
|
/* If there was no sliding:
|
|
|
|
* strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
|
|
|
|
* more == window_size - lookahead - strstart
|
|
|
|
* => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
|
|
|
|
* => more >= window_size - 2*WSIZE + 2
|
|
|
|
* In the BIG_MEM or MMAP case (not yet supported),
|
|
|
|
* window_size == input_size + MIN_LOOKAHEAD &&
|
|
|
|
* strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
|
|
|
|
* Otherwise, window_size == 2*WSIZE so more >= 2.
|
|
|
|
* If there was sliding, more >= WSIZE. So in all cases, more >= 2.
|
|
|
|
*/
|
|
|
|
Assert(more >= 2, "more < 2");
|
|
|
|
|
|
|
|
n = read_buf(s->strm, (charf *)s->window + s->strstart + s->lookahead,
|
|
|
|
more);
|
|
|
|
s->lookahead += n;
|
|
|
|
|
|
|
|
/* Initialize the hash value now that we have some input: */
|
|
|
|
if (s->lookahead >= MIN_MATCH) {
|
|
|
|
s->ins_h = s->window[s->strstart];
|
|
|
|
UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
|
|
|
|
#if MIN_MATCH != 3
|
|
|
|
Call UPDATE_HASH() MIN_MATCH-3 more times
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
/* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
|
|
|
|
* but this is not important since only literal bytes will be emitted.
|
|
|
|
*/
|
|
|
|
|
|
|
|
} while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Flush the current block, with given end-of-file flag.
|
|
|
|
* IN assertion: strstart is set to the end of the current match.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
#define FLUSH_BLOCK_ONLY(s, eof) { \
|
|
|
|
_tr_flush_block(s, (s->block_start >= 0L ? \
|
|
|
|
(charf *)&s->window[(unsigned)s->block_start] : \
|
|
|
|
(charf *)Z_NULL), \
|
|
|
|
(ulg)((long)s->strstart - s->block_start), \
|
|
|
|
(eof)); \
|
1997-08-19 14:10:50 +00:00
|
|
|
s->block_start = s->strstart; \
|
|
|
|
flush_pending(s->strm); \
|
|
|
|
Tracev((stderr,"[FLUSH]")); \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Same but force premature exit if necessary. */
|
1998-03-21 20:56:16 +00:00
|
|
|
#define FLUSH_BLOCK(s, eof) { \
|
|
|
|
FLUSH_BLOCK_ONLY(s, eof); \
|
|
|
|
if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Copy without compression as much as possible from the input stream, return
|
|
|
|
* the current block state.
|
|
|
|
* This function does not insert new strings in the dictionary since
|
|
|
|
* uncompressible data is probably not useful. This function is used
|
|
|
|
* only for the level=0 compression option.
|
|
|
|
* NOTE: this function should be optimized to avoid extra copying from
|
|
|
|
* window to pending_buf.
|
|
|
|
*/
|
|
|
|
local block_state deflate_stored(s, flush)
|
|
|
|
deflate_state *s;
|
|
|
|
int flush;
|
|
|
|
{
|
|
|
|
/* Stored blocks are limited to 0xffff bytes, pending_buf is limited
|
|
|
|
* to pending_buf_size, and each stored block has a 5 byte header:
|
|
|
|
*/
|
|
|
|
ulg max_block_size = 0xffff;
|
|
|
|
ulg max_start;
|
|
|
|
|
|
|
|
if (max_block_size > s->pending_buf_size - 5) {
|
|
|
|
max_block_size = s->pending_buf_size - 5;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy as much as possible from input to output: */
|
|
|
|
for (;;) {
|
|
|
|
/* Fill the window as much as possible: */
|
|
|
|
if (s->lookahead <= 1) {
|
|
|
|
|
|
|
|
Assert(s->strstart < s->w_size+MAX_DIST(s) ||
|
|
|
|
s->block_start >= (long)s->w_size, "slide too late");
|
|
|
|
|
|
|
|
fill_window(s);
|
|
|
|
if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
|
|
|
|
|
|
|
|
if (s->lookahead == 0) break; /* flush the current block */
|
|
|
|
}
|
|
|
|
Assert(s->block_start >= 0L, "block gone");
|
|
|
|
|
|
|
|
s->strstart += s->lookahead;
|
|
|
|
s->lookahead = 0;
|
|
|
|
|
|
|
|
/* Emit a stored block if pending_buf will be full: */
|
|
|
|
max_start = s->block_start + max_block_size;
|
|
|
|
if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
|
|
|
|
/* strstart == 0 is possible when wraparound on 16-bit machine */
|
|
|
|
s->lookahead = (uInt)(s->strstart - max_start);
|
|
|
|
s->strstart = (uInt)max_start;
|
|
|
|
FLUSH_BLOCK(s, 0);
|
|
|
|
}
|
|
|
|
/* Flush if we may have to slide, otherwise block_start may become
|
|
|
|
* negative and the data will be gone:
|
|
|
|
*/
|
|
|
|
if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
|
|
|
|
FLUSH_BLOCK(s, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FLUSH_BLOCK(s, flush == Z_FINISH);
|
|
|
|
return flush == Z_FINISH ? finish_done : block_done;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
1998-03-21 20:56:16 +00:00
|
|
|
* Compress as much as possible from the input stream, return the current
|
|
|
|
* block state.
|
|
|
|
* This function does not perform lazy evaluation of matches and inserts
|
1997-08-19 14:10:50 +00:00
|
|
|
* new strings in the dictionary only for unmatched strings or for short
|
|
|
|
* matches. It is used only for the fast compression options.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
local block_state deflate_fast(s, flush)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
int flush;
|
|
|
|
{
|
|
|
|
IPos hash_head = NIL; /* head of the hash chain */
|
1998-03-21 20:56:16 +00:00
|
|
|
int bflush; /* set if current block must be flushed */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
/* Make sure that we always have enough lookahead, except
|
|
|
|
* at the end of the input file. We need MAX_MATCH bytes
|
|
|
|
* for the next match, plus MIN_MATCH bytes to insert the
|
|
|
|
* string following the next match.
|
|
|
|
*/
|
|
|
|
if (s->lookahead < MIN_LOOKAHEAD) {
|
|
|
|
fill_window(s);
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
|
|
|
|
return need_more;
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
if (s->lookahead == 0) break; /* flush the current block */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Insert the string window[strstart .. strstart+2] in the
|
|
|
|
* dictionary, and set hash_head to the head of the hash chain:
|
|
|
|
*/
|
|
|
|
if (s->lookahead >= MIN_MATCH) {
|
|
|
|
INSERT_STRING(s, s->strstart, hash_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the longest match, discarding those <= prev_length.
|
|
|
|
* At this point we have always match_length < MIN_MATCH
|
|
|
|
*/
|
|
|
|
if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
|
|
|
|
/* To simplify the code, we prevent matches with the string
|
|
|
|
* of window index 0 (in particular we have to avoid a match
|
|
|
|
* of the string with itself at the start of the input file).
|
|
|
|
*/
|
|
|
|
if (s->strategy != Z_HUFFMAN_ONLY) {
|
|
|
|
s->match_length = longest_match (s, hash_head);
|
|
|
|
}
|
|
|
|
/* longest_match() sets match_start */
|
|
|
|
}
|
|
|
|
if (s->match_length >= MIN_MATCH) {
|
|
|
|
check_match(s, s->strstart, s->match_start, s->match_length);
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
bflush = _tr_tally(s, s->strstart - s->match_start,
|
|
|
|
s->match_length - MIN_MATCH);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
s->lookahead -= s->match_length;
|
|
|
|
|
|
|
|
/* Insert new strings in the hash table only if the match length
|
|
|
|
* is not too large. This saves time but degrades compression.
|
|
|
|
*/
|
|
|
|
if (s->match_length <= s->max_insert_length &&
|
|
|
|
s->lookahead >= MIN_MATCH) {
|
|
|
|
s->match_length--; /* string at strstart already in hash table */
|
|
|
|
do {
|
|
|
|
s->strstart++;
|
|
|
|
INSERT_STRING(s, s->strstart, hash_head);
|
|
|
|
/* strstart never exceeds WSIZE-MAX_MATCH, so there are
|
|
|
|
* always MIN_MATCH bytes ahead.
|
|
|
|
*/
|
|
|
|
} while (--s->match_length != 0);
|
|
|
|
s->strstart++;
|
|
|
|
} else {
|
|
|
|
s->strstart += s->match_length;
|
|
|
|
s->match_length = 0;
|
|
|
|
s->ins_h = s->window[s->strstart];
|
|
|
|
UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
|
|
|
|
#if MIN_MATCH != 3
|
|
|
|
Call UPDATE_HASH() MIN_MATCH-3 more times
|
|
|
|
#endif
|
|
|
|
/* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
|
|
|
|
* matter since it will be recomputed at next deflate call.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* No match, output a literal byte */
|
|
|
|
Tracevv((stderr,"%c", s->window[s->strstart]));
|
1998-03-21 20:56:16 +00:00
|
|
|
bflush = _tr_tally (s, 0, s->window[s->strstart]);
|
1997-08-19 14:10:50 +00:00
|
|
|
s->lookahead--;
|
|
|
|
s->strstart++;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
if (bflush) FLUSH_BLOCK(s, 0);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
FLUSH_BLOCK(s, flush == Z_FINISH);
|
|
|
|
return flush == Z_FINISH ? finish_done : block_done;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Same as above, but achieves better compression. We use a lazy
|
|
|
|
* evaluation for matches: a match is finally adopted only if there is
|
|
|
|
* no better match at the next window position.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
local block_state deflate_slow(s, flush)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
int flush;
|
|
|
|
{
|
|
|
|
IPos hash_head = NIL; /* head of hash chain */
|
|
|
|
int bflush; /* set if current block must be flushed */
|
|
|
|
|
|
|
|
/* Process the input block. */
|
|
|
|
for (;;) {
|
|
|
|
/* Make sure that we always have enough lookahead, except
|
|
|
|
* at the end of the input file. We need MAX_MATCH bytes
|
|
|
|
* for the next match, plus MIN_MATCH bytes to insert the
|
|
|
|
* string following the next match.
|
|
|
|
*/
|
|
|
|
if (s->lookahead < MIN_LOOKAHEAD) {
|
|
|
|
fill_window(s);
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
|
|
|
|
return need_more;
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
if (s->lookahead == 0) break; /* flush the current block */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Insert the string window[strstart .. strstart+2] in the
|
|
|
|
* dictionary, and set hash_head to the head of the hash chain:
|
|
|
|
*/
|
|
|
|
if (s->lookahead >= MIN_MATCH) {
|
|
|
|
INSERT_STRING(s, s->strstart, hash_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the longest match, discarding those <= prev_length.
|
|
|
|
*/
|
|
|
|
s->prev_length = s->match_length, s->prev_match = s->match_start;
|
|
|
|
s->match_length = MIN_MATCH-1;
|
|
|
|
|
|
|
|
if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
|
|
|
|
s->strstart - hash_head <= MAX_DIST(s)) {
|
|
|
|
/* To simplify the code, we prevent matches with the string
|
|
|
|
* of window index 0 (in particular we have to avoid a match
|
|
|
|
* of the string with itself at the start of the input file).
|
|
|
|
*/
|
|
|
|
if (s->strategy != Z_HUFFMAN_ONLY) {
|
|
|
|
s->match_length = longest_match (s, hash_head);
|
|
|
|
}
|
|
|
|
/* longest_match() sets match_start */
|
|
|
|
|
|
|
|
if (s->match_length <= 5 && (s->strategy == Z_FILTERED ||
|
|
|
|
(s->match_length == MIN_MATCH &&
|
|
|
|
s->strstart - s->match_start > TOO_FAR))) {
|
|
|
|
|
|
|
|
/* If prev_match is also MIN_MATCH, match_start is garbage
|
|
|
|
* but we will ignore the current match anyway.
|
|
|
|
*/
|
|
|
|
s->match_length = MIN_MATCH-1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* If there was a match at the previous step and the current
|
|
|
|
* match is not better, output the previous match:
|
|
|
|
*/
|
|
|
|
if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
|
|
|
|
uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
|
|
|
|
/* Do not insert strings in hash table beyond this. */
|
|
|
|
|
|
|
|
check_match(s, s->strstart-1, s->prev_match, s->prev_length);
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
bflush = _tr_tally(s, s->strstart -1 - s->prev_match,
|
|
|
|
s->prev_length - MIN_MATCH);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* Insert in hash table all strings up to the end of the match.
|
|
|
|
* strstart-1 and strstart are already inserted. If there is not
|
|
|
|
* enough lookahead, the last two strings are not inserted in
|
|
|
|
* the hash table.
|
|
|
|
*/
|
|
|
|
s->lookahead -= s->prev_length-1;
|
|
|
|
s->prev_length -= 2;
|
|
|
|
do {
|
|
|
|
if (++s->strstart <= max_insert) {
|
|
|
|
INSERT_STRING(s, s->strstart, hash_head);
|
|
|
|
}
|
|
|
|
} while (--s->prev_length != 0);
|
|
|
|
s->match_available = 0;
|
|
|
|
s->match_length = MIN_MATCH-1;
|
|
|
|
s->strstart++;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (bflush) FLUSH_BLOCK(s, 0);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
} else if (s->match_available) {
|
|
|
|
/* If there was no match at the previous position, output a
|
|
|
|
* single literal. If there was a match but the current match
|
|
|
|
* is longer, truncate the previous match to a single literal.
|
|
|
|
*/
|
|
|
|
Tracevv((stderr,"%c", s->window[s->strstart-1]));
|
1998-03-21 20:56:16 +00:00
|
|
|
if (_tr_tally (s, 0, s->window[s->strstart-1])) {
|
|
|
|
FLUSH_BLOCK_ONLY(s, 0);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
s->strstart++;
|
|
|
|
s->lookahead--;
|
1998-03-21 20:56:16 +00:00
|
|
|
if (s->strm->avail_out == 0) return need_more;
|
1997-08-19 14:10:50 +00:00
|
|
|
} else {
|
|
|
|
/* There is no previous match to compare with, wait for
|
|
|
|
* the next step to decide.
|
|
|
|
*/
|
|
|
|
s->match_available = 1;
|
|
|
|
s->strstart++;
|
|
|
|
s->lookahead--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Assert (flush != Z_NO_FLUSH, "no flush?");
|
|
|
|
if (s->match_available) {
|
|
|
|
Tracevv((stderr,"%c", s->window[s->strstart-1]));
|
1998-03-21 20:56:16 +00:00
|
|
|
_tr_tally (s, 0, s->window[s->strstart-1]);
|
1997-08-19 14:10:50 +00:00
|
|
|
s->match_available = 0;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
FLUSH_BLOCK(s, flush == Z_FINISH);
|
|
|
|
return flush == Z_FINISH ? finish_done : block_done;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- deflate.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ trees.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* trees.c -- output deflated data using Huffman coding
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Jean-loup Gailly
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ALGORITHM
|
|
|
|
*
|
|
|
|
* The "deflation" process uses several Huffman trees. The more
|
|
|
|
* common source values are represented by shorter bit sequences.
|
|
|
|
*
|
|
|
|
* Each code tree is stored in a compressed form which is itself
|
|
|
|
* a Huffman encoding of the lengths of all the code strings (in
|
|
|
|
* ascending order by source values). The actual code strings are
|
|
|
|
* reconstructed from the lengths in the inflate process, as described
|
|
|
|
* in the deflate specification.
|
|
|
|
*
|
|
|
|
* REFERENCES
|
|
|
|
*
|
|
|
|
* Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
|
|
|
|
* Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
|
|
|
|
*
|
|
|
|
* Storer, James A.
|
|
|
|
* Data Compression: Methods and Theory, pp. 49-50.
|
|
|
|
* Computer Science Press, 1988. ISBN 0-7167-8156-5.
|
|
|
|
*
|
|
|
|
* Sedgewick, R.
|
|
|
|
* Algorithms, p290.
|
|
|
|
* Addison-Wesley, 1983. ISBN 0-201-06672-6.
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* From: trees.c,v 1.11 1996/07/24 13:41:06 me Exp $ */
|
|
|
|
|
|
|
|
/* #include "deflate.h" */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
# include <ctype.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Constants
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define MAX_BL_BITS 7
|
|
|
|
/* Bit length codes must not exceed MAX_BL_BITS bits */
|
|
|
|
|
|
|
|
#define END_BLOCK 256
|
|
|
|
/* end of block literal code */
|
|
|
|
|
|
|
|
#define REP_3_6 16
|
|
|
|
/* repeat previous bit length 3-6 times (2 bits of repeat count) */
|
|
|
|
|
|
|
|
#define REPZ_3_10 17
|
|
|
|
/* repeat a zero length 3-10 times (3 bits of repeat count) */
|
|
|
|
|
|
|
|
#define REPZ_11_138 18
|
|
|
|
/* repeat a zero length 11-138 times (7 bits of repeat count) */
|
|
|
|
|
|
|
|
local int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
|
|
|
|
= {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
|
|
|
|
|
|
|
|
local int extra_dbits[D_CODES] /* extra bits for each distance code */
|
|
|
|
= {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
|
|
|
|
|
|
|
|
local int extra_blbits[BL_CODES]/* extra bits for each bit length code */
|
|
|
|
= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
|
|
|
|
|
|
|
|
local uch bl_order[BL_CODES]
|
|
|
|
= {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
|
|
|
|
/* The lengths of the bit length codes are sent in order of decreasing
|
|
|
|
* probability, to avoid transmitting the lengths for unused bit length codes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define Buf_size (8 * 2*sizeof(char))
|
|
|
|
/* Number of bits used within bi_buf. (bi_buf might be implemented on
|
|
|
|
* more than 16 bits on some systems.)
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Local data. These are initialized only once.
|
|
|
|
*/
|
|
|
|
|
|
|
|
local ct_data static_ltree[L_CODES+2];
|
|
|
|
/* The static literal tree. Since the bit lengths are imposed, there is no
|
|
|
|
* need for the L_CODES extra codes used during heap construction. However
|
1998-03-21 20:56:16 +00:00
|
|
|
* The codes 286 and 287 are needed to build a canonical tree (see _tr_init
|
1997-08-19 14:10:50 +00:00
|
|
|
* below).
|
|
|
|
*/
|
|
|
|
|
|
|
|
local ct_data static_dtree[D_CODES];
|
|
|
|
/* The static distance tree. (Actually a trivial tree since all codes use
|
|
|
|
* 5 bits.)
|
|
|
|
*/
|
|
|
|
|
|
|
|
local uch dist_code[512];
|
|
|
|
/* distance codes. The first 256 values correspond to the distances
|
|
|
|
* 3 .. 258, the last 256 values correspond to the top 8 bits of
|
|
|
|
* the 15 bit distances.
|
|
|
|
*/
|
|
|
|
|
|
|
|
local uch length_code[MAX_MATCH-MIN_MATCH+1];
|
|
|
|
/* length code for each normalized match length (0 == MIN_MATCH) */
|
|
|
|
|
|
|
|
local int base_length[LENGTH_CODES];
|
|
|
|
/* First normalized length for each code (0 = MIN_MATCH) */
|
|
|
|
|
|
|
|
local int base_dist[D_CODES];
|
|
|
|
/* First normalized distance for each code (0 = distance of 1) */
|
|
|
|
|
|
|
|
struct static_tree_desc_s {
|
|
|
|
ct_data *static_tree; /* static tree or NULL */
|
|
|
|
intf *extra_bits; /* extra bits for each code or NULL */
|
|
|
|
int extra_base; /* base index for extra_bits */
|
|
|
|
int elems; /* max number of elements in the tree */
|
|
|
|
int max_length; /* max bit length for the codes */
|
|
|
|
};
|
|
|
|
|
|
|
|
local static_tree_desc static_l_desc =
|
|
|
|
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
|
|
|
|
|
|
|
|
local static_tree_desc static_d_desc =
|
|
|
|
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
|
|
|
|
|
|
|
|
local static_tree_desc static_bl_desc =
|
|
|
|
{(ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Local (static) routines in this file.
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
local void tr_static_init OF((void));
|
1997-08-19 14:10:50 +00:00
|
|
|
local void init_block OF((deflate_state *s));
|
|
|
|
local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
|
|
|
|
local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
|
|
|
|
local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count));
|
|
|
|
local void build_tree OF((deflate_state *s, tree_desc *desc));
|
|
|
|
local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
|
|
|
|
local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
|
|
|
|
local int build_bl_tree OF((deflate_state *s));
|
|
|
|
local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
|
|
|
|
int blcodes));
|
|
|
|
local void compress_block OF((deflate_state *s, ct_data *ltree,
|
|
|
|
ct_data *dtree));
|
|
|
|
local void set_data_type OF((deflate_state *s));
|
|
|
|
local unsigned bi_reverse OF((unsigned value, int length));
|
|
|
|
local void bi_windup OF((deflate_state *s));
|
|
|
|
local void bi_flush OF((deflate_state *s));
|
|
|
|
local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
|
|
|
|
int header));
|
|
|
|
|
|
|
|
#ifndef DEBUG_ZLIB
|
|
|
|
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
|
|
|
|
/* Send a code of the given tree. c and tree must not have side effects */
|
|
|
|
|
|
|
|
#else /* DEBUG_ZLIB */
|
|
|
|
# define send_code(s, c, tree) \
|
1998-03-21 20:56:16 +00:00
|
|
|
{ if (verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
|
1997-08-19 14:10:50 +00:00
|
|
|
send_bits(s, tree[c].Code, tree[c].Len); }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define d_code(dist) \
|
|
|
|
((dist) < 256 ? dist_code[dist] : dist_code[256+((dist)>>7)])
|
|
|
|
/* Mapping from a distance to a distance code. dist is the distance - 1 and
|
|
|
|
* must not have side effects. dist_code[256] and dist_code[257] are never
|
|
|
|
* used.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Output a short LSB first on the stream.
|
|
|
|
* IN assertion: there is enough room in pendingBuf.
|
|
|
|
*/
|
|
|
|
#define put_short(s, w) { \
|
|
|
|
put_byte(s, (uch)((w) & 0xff)); \
|
|
|
|
put_byte(s, (uch)((ush)(w) >> 8)); \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Send a value on a given number of bits.
|
|
|
|
* IN assertion: length <= 16 and value fits in length bits.
|
|
|
|
*/
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
local void send_bits OF((deflate_state *s, int value, int length));
|
|
|
|
|
|
|
|
local void send_bits(s, value, length)
|
|
|
|
deflate_state *s;
|
|
|
|
int value; /* value to send */
|
|
|
|
int length; /* number of bits */
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
Tracevv((stderr," l %2d v %4x ", length, value));
|
1997-08-19 14:10:50 +00:00
|
|
|
Assert(length > 0 && length <= 15, "invalid length");
|
|
|
|
s->bits_sent += (ulg)length;
|
|
|
|
|
|
|
|
/* If not enough room in bi_buf, use (valid) bits from bi_buf and
|
|
|
|
* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
|
|
|
|
* unused bits in value.
|
|
|
|
*/
|
|
|
|
if (s->bi_valid > (int)Buf_size - length) {
|
|
|
|
s->bi_buf |= (value << s->bi_valid);
|
|
|
|
put_short(s, s->bi_buf);
|
|
|
|
s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
|
|
|
|
s->bi_valid += length - Buf_size;
|
|
|
|
} else {
|
|
|
|
s->bi_buf |= value << s->bi_valid;
|
|
|
|
s->bi_valid += length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else /* !DEBUG_ZLIB */
|
|
|
|
|
|
|
|
#define send_bits(s, value, length) \
|
|
|
|
{ int len = length;\
|
|
|
|
if (s->bi_valid > (int)Buf_size - len) {\
|
|
|
|
int val = value;\
|
|
|
|
s->bi_buf |= (val << s->bi_valid);\
|
|
|
|
put_short(s, s->bi_buf);\
|
|
|
|
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
|
|
|
|
s->bi_valid += len - Buf_size;\
|
|
|
|
} else {\
|
|
|
|
s->bi_buf |= (value) << s->bi_valid;\
|
|
|
|
s->bi_valid += len;\
|
|
|
|
}\
|
|
|
|
}
|
|
|
|
#endif /* DEBUG_ZLIB */
|
|
|
|
|
|
|
|
|
|
|
|
#define MAX(a,b) (a >= b ? a : b)
|
|
|
|
/* the arguments must not have side effects */
|
|
|
|
|
|
|
|
/* ===========================================================================
|
1998-03-21 20:56:16 +00:00
|
|
|
* Initialize the various 'constant' tables. In a multi-threaded environment,
|
|
|
|
* this function may be called by two threads concurrently, but this is
|
|
|
|
* harmless since both invocations do exactly the same thing.
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
local void tr_static_init()
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
static int static_init_done = 0;
|
1997-08-19 14:10:50 +00:00
|
|
|
int n; /* iterates over tree elements */
|
|
|
|
int bits; /* bit counter */
|
|
|
|
int length; /* length value */
|
|
|
|
int code; /* code value */
|
|
|
|
int dist; /* distance index */
|
|
|
|
ush bl_count[MAX_BITS+1];
|
|
|
|
/* number of codes at each bit length for an optimal tree */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (static_init_done) return;
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* Initialize the mapping length (0..255) -> length code (0..28) */
|
|
|
|
length = 0;
|
|
|
|
for (code = 0; code < LENGTH_CODES-1; code++) {
|
|
|
|
base_length[code] = length;
|
|
|
|
for (n = 0; n < (1<<extra_lbits[code]); n++) {
|
|
|
|
length_code[length++] = (uch)code;
|
|
|
|
}
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
Assert (length == 256, "tr_static_init: length != 256");
|
1997-08-19 14:10:50 +00:00
|
|
|
/* Note that the length 255 (match length 258) can be represented
|
|
|
|
* in two different ways: code 284 + 5 bits or code 285, so we
|
|
|
|
* overwrite length_code[255] to use the best encoding:
|
|
|
|
*/
|
|
|
|
length_code[length-1] = (uch)code;
|
|
|
|
|
|
|
|
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */
|
|
|
|
dist = 0;
|
|
|
|
for (code = 0 ; code < 16; code++) {
|
|
|
|
base_dist[code] = dist;
|
|
|
|
for (n = 0; n < (1<<extra_dbits[code]); n++) {
|
|
|
|
dist_code[dist++] = (uch)code;
|
|
|
|
}
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
Assert (dist == 256, "tr_static_init: dist != 256");
|
1997-08-19 14:10:50 +00:00
|
|
|
dist >>= 7; /* from now on, all distances are divided by 128 */
|
|
|
|
for ( ; code < D_CODES; code++) {
|
|
|
|
base_dist[code] = dist << 7;
|
|
|
|
for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
|
|
|
|
dist_code[256 + dist++] = (uch)code;
|
|
|
|
}
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
Assert (dist == 256, "tr_static_init: 256+dist != 512");
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* Construct the codes of the static literal tree */
|
|
|
|
for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
|
|
|
|
n = 0;
|
|
|
|
while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
|
|
|
|
while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
|
|
|
|
while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
|
|
|
|
while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
|
|
|
|
/* Codes 286 and 287 do not exist, but we must include them in the
|
|
|
|
* tree construction to get a canonical Huffman tree (longest code
|
|
|
|
* all ones)
|
|
|
|
*/
|
|
|
|
gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
|
|
|
|
|
|
|
|
/* The static distance tree is trivial: */
|
|
|
|
for (n = 0; n < D_CODES; n++) {
|
|
|
|
static_dtree[n].Len = 5;
|
1998-03-21 20:56:16 +00:00
|
|
|
static_dtree[n].Code = bi_reverse((unsigned)n, 5);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
static_init_done = 1;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Initialize the tree data structures for a new zlib stream.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
void _tr_init(s)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
tr_static_init();
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
s->compressed_len = 0L;
|
|
|
|
|
|
|
|
s->l_desc.dyn_tree = s->dyn_ltree;
|
|
|
|
s->l_desc.stat_desc = &static_l_desc;
|
|
|
|
|
|
|
|
s->d_desc.dyn_tree = s->dyn_dtree;
|
|
|
|
s->d_desc.stat_desc = &static_d_desc;
|
|
|
|
|
|
|
|
s->bl_desc.dyn_tree = s->bl_tree;
|
|
|
|
s->bl_desc.stat_desc = &static_bl_desc;
|
|
|
|
|
|
|
|
s->bi_buf = 0;
|
|
|
|
s->bi_valid = 0;
|
|
|
|
s->last_eob_len = 8; /* enough lookahead for inflate */
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
s->bits_sent = 0L;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Initialize the first block of the first file: */
|
|
|
|
init_block(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Initialize a new block.
|
|
|
|
*/
|
|
|
|
local void init_block(s)
|
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
int n; /* iterates over tree elements */
|
|
|
|
|
|
|
|
/* Initialize the trees. */
|
|
|
|
for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
|
|
|
|
for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
|
|
|
|
for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
|
|
|
|
|
|
|
|
s->dyn_ltree[END_BLOCK].Freq = 1;
|
|
|
|
s->opt_len = s->static_len = 0L;
|
|
|
|
s->last_lit = s->matches = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SMALLEST 1
|
|
|
|
/* Index within the heap array of least frequent node in the Huffman tree */
|
|
|
|
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Remove the smallest element from the heap and recreate the heap with
|
|
|
|
* one less element. Updates heap and heap_len.
|
|
|
|
*/
|
|
|
|
#define pqremove(s, tree, top) \
|
|
|
|
{\
|
|
|
|
top = s->heap[SMALLEST]; \
|
|
|
|
s->heap[SMALLEST] = s->heap[s->heap_len--]; \
|
|
|
|
pqdownheap(s, tree, SMALLEST); \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Compares to subtrees, using the tree depth as tie breaker when
|
|
|
|
* the subtrees have equal frequency. This minimizes the worst case length.
|
|
|
|
*/
|
|
|
|
#define smaller(tree, n, m, depth) \
|
|
|
|
(tree[n].Freq < tree[m].Freq || \
|
|
|
|
(tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Restore the heap property by moving down the tree starting at node k,
|
|
|
|
* exchanging a node with the smallest of its two sons if necessary, stopping
|
|
|
|
* when the heap property is re-established (each father smaller than its
|
|
|
|
* two sons).
|
|
|
|
*/
|
|
|
|
local void pqdownheap(s, tree, k)
|
|
|
|
deflate_state *s;
|
|
|
|
ct_data *tree; /* the tree to restore */
|
|
|
|
int k; /* node to move down */
|
|
|
|
{
|
|
|
|
int v = s->heap[k];
|
|
|
|
int j = k << 1; /* left son of k */
|
|
|
|
while (j <= s->heap_len) {
|
|
|
|
/* Set j to the smallest of the two sons: */
|
|
|
|
if (j < s->heap_len &&
|
|
|
|
smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
/* Exit if v is smaller than both sons */
|
|
|
|
if (smaller(tree, v, s->heap[j], s->depth)) break;
|
|
|
|
|
|
|
|
/* Exchange v with the smallest son */
|
|
|
|
s->heap[k] = s->heap[j]; k = j;
|
|
|
|
|
|
|
|
/* And continue down the tree, setting j to the left son of k */
|
|
|
|
j <<= 1;
|
|
|
|
}
|
|
|
|
s->heap[k] = v;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Compute the optimal bit lengths for a tree and update the total bit length
|
|
|
|
* for the current block.
|
|
|
|
* IN assertion: the fields freq and dad are set, heap[heap_max] and
|
|
|
|
* above are the tree nodes sorted by increasing frequency.
|
|
|
|
* OUT assertions: the field len is set to the optimal bit length, the
|
|
|
|
* array bl_count contains the frequencies for each bit length.
|
|
|
|
* The length opt_len is updated; static_len is also updated if stree is
|
|
|
|
* not null.
|
|
|
|
*/
|
|
|
|
local void gen_bitlen(s, desc)
|
|
|
|
deflate_state *s;
|
|
|
|
tree_desc *desc; /* the tree descriptor */
|
|
|
|
{
|
|
|
|
ct_data *tree = desc->dyn_tree;
|
|
|
|
int max_code = desc->max_code;
|
|
|
|
ct_data *stree = desc->stat_desc->static_tree;
|
|
|
|
intf *extra = desc->stat_desc->extra_bits;
|
|
|
|
int base = desc->stat_desc->extra_base;
|
|
|
|
int max_length = desc->stat_desc->max_length;
|
|
|
|
int h; /* heap index */
|
|
|
|
int n, m; /* iterate over the tree elements */
|
|
|
|
int bits; /* bit length */
|
|
|
|
int xbits; /* extra bits */
|
|
|
|
ush f; /* frequency */
|
|
|
|
int overflow = 0; /* number of elements with bit length too large */
|
|
|
|
|
|
|
|
for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
|
|
|
|
|
|
|
|
/* In a first pass, compute the optimal bit lengths (which may
|
|
|
|
* overflow in the case of the bit length tree).
|
|
|
|
*/
|
|
|
|
tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
|
|
|
|
|
|
|
|
for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
|
|
|
|
n = s->heap[h];
|
|
|
|
bits = tree[tree[n].Dad].Len + 1;
|
|
|
|
if (bits > max_length) bits = max_length, overflow++;
|
|
|
|
tree[n].Len = (ush)bits;
|
|
|
|
/* We overwrite tree[n].Dad which is no longer needed */
|
|
|
|
|
|
|
|
if (n > max_code) continue; /* not a leaf node */
|
|
|
|
|
|
|
|
s->bl_count[bits]++;
|
|
|
|
xbits = 0;
|
|
|
|
if (n >= base) xbits = extra[n-base];
|
|
|
|
f = tree[n].Freq;
|
|
|
|
s->opt_len += (ulg)f * (bits + xbits);
|
|
|
|
if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
|
|
|
|
}
|
|
|
|
if (overflow == 0) return;
|
|
|
|
|
|
|
|
Trace((stderr,"\nbit length overflow\n"));
|
|
|
|
/* This happens for example on obj2 and pic of the Calgary corpus */
|
|
|
|
|
|
|
|
/* Find the first bit length which could increase: */
|
|
|
|
do {
|
|
|
|
bits = max_length-1;
|
|
|
|
while (s->bl_count[bits] == 0) bits--;
|
|
|
|
s->bl_count[bits]--; /* move one leaf down the tree */
|
|
|
|
s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
|
|
|
|
s->bl_count[max_length]--;
|
|
|
|
/* The brother of the overflow item also moves one step up,
|
|
|
|
* but this does not affect bl_count[max_length]
|
|
|
|
*/
|
|
|
|
overflow -= 2;
|
|
|
|
} while (overflow > 0);
|
|
|
|
|
|
|
|
/* Now recompute all bit lengths, scanning in increasing frequency.
|
|
|
|
* h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
|
|
|
|
* lengths instead of fixing only the wrong ones. This idea is taken
|
|
|
|
* from 'ar' written by Haruhiko Okumura.)
|
|
|
|
*/
|
|
|
|
for (bits = max_length; bits != 0; bits--) {
|
|
|
|
n = s->bl_count[bits];
|
|
|
|
while (n != 0) {
|
|
|
|
m = s->heap[--h];
|
|
|
|
if (m > max_code) continue;
|
|
|
|
if (tree[m].Len != (unsigned) bits) {
|
|
|
|
Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
|
|
|
|
s->opt_len += ((long)bits - (long)tree[m].Len)
|
|
|
|
*(long)tree[m].Freq;
|
|
|
|
tree[m].Len = (ush)bits;
|
|
|
|
}
|
|
|
|
n--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Generate the codes for a given tree and bit counts (which need not be
|
|
|
|
* optimal).
|
|
|
|
* IN assertion: the array bl_count contains the bit length statistics for
|
|
|
|
* the given tree and the field len is set for all tree elements.
|
|
|
|
* OUT assertion: the field code is set for all tree elements of non
|
|
|
|
* zero code length.
|
|
|
|
*/
|
|
|
|
local void gen_codes (tree, max_code, bl_count)
|
|
|
|
ct_data *tree; /* the tree to decorate */
|
|
|
|
int max_code; /* largest code with non zero frequency */
|
|
|
|
ushf *bl_count; /* number of codes at each bit length */
|
|
|
|
{
|
|
|
|
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
|
|
|
|
ush code = 0; /* running code value */
|
|
|
|
int bits; /* bit index */
|
|
|
|
int n; /* code index */
|
|
|
|
|
|
|
|
/* The distribution counts are first used to generate the code values
|
|
|
|
* without bit reversal.
|
|
|
|
*/
|
|
|
|
for (bits = 1; bits <= MAX_BITS; bits++) {
|
|
|
|
next_code[bits] = code = (code + bl_count[bits-1]) << 1;
|
|
|
|
}
|
|
|
|
/* Check that the bit counts in bl_count are consistent. The last code
|
|
|
|
* must be all ones.
|
|
|
|
*/
|
|
|
|
Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
|
|
|
|
"inconsistent bit counts");
|
|
|
|
Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
|
|
|
|
|
|
|
|
for (n = 0; n <= max_code; n++) {
|
|
|
|
int len = tree[n].Len;
|
|
|
|
if (len == 0) continue;
|
|
|
|
/* Now reverse the bits */
|
|
|
|
tree[n].Code = bi_reverse(next_code[len]++, len);
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
|
1997-08-19 14:10:50 +00:00
|
|
|
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Construct one Huffman tree and assigns the code bit strings and lengths.
|
|
|
|
* Update the total bit length for the current block.
|
|
|
|
* IN assertion: the field freq is set for all tree elements.
|
|
|
|
* OUT assertions: the fields len and code are set to the optimal bit length
|
|
|
|
* and corresponding code. The length opt_len is updated; static_len is
|
|
|
|
* also updated if stree is not null. The field max_code is set.
|
|
|
|
*/
|
|
|
|
local void build_tree(s, desc)
|
|
|
|
deflate_state *s;
|
|
|
|
tree_desc *desc; /* the tree descriptor */
|
|
|
|
{
|
|
|
|
ct_data *tree = desc->dyn_tree;
|
|
|
|
ct_data *stree = desc->stat_desc->static_tree;
|
|
|
|
int elems = desc->stat_desc->elems;
|
|
|
|
int n, m; /* iterate over heap elements */
|
|
|
|
int max_code = -1; /* largest code with non zero frequency */
|
|
|
|
int node; /* new node being created */
|
|
|
|
|
|
|
|
/* Construct the initial heap, with least frequent element in
|
|
|
|
* heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
|
|
|
|
* heap[0] is not used.
|
|
|
|
*/
|
|
|
|
s->heap_len = 0, s->heap_max = HEAP_SIZE;
|
|
|
|
|
|
|
|
for (n = 0; n < elems; n++) {
|
|
|
|
if (tree[n].Freq != 0) {
|
|
|
|
s->heap[++(s->heap_len)] = max_code = n;
|
|
|
|
s->depth[n] = 0;
|
|
|
|
} else {
|
|
|
|
tree[n].Len = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The pkzip format requires that at least one distance code exists,
|
|
|
|
* and that at least one bit should be sent even if there is only one
|
|
|
|
* possible code. So to avoid special checks later on we force at least
|
|
|
|
* two codes of non zero frequency.
|
|
|
|
*/
|
|
|
|
while (s->heap_len < 2) {
|
|
|
|
node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
|
|
|
|
tree[node].Freq = 1;
|
|
|
|
s->depth[node] = 0;
|
|
|
|
s->opt_len--; if (stree) s->static_len -= stree[node].Len;
|
|
|
|
/* node is 0 or 1 so it does not have extra bits */
|
|
|
|
}
|
|
|
|
desc->max_code = max_code;
|
|
|
|
|
|
|
|
/* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
|
|
|
|
* establish sub-heaps of increasing lengths:
|
|
|
|
*/
|
|
|
|
for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
|
|
|
|
|
|
|
|
/* Construct the Huffman tree by repeatedly combining the least two
|
|
|
|
* frequent nodes.
|
|
|
|
*/
|
|
|
|
node = elems; /* next internal node of the tree */
|
|
|
|
do {
|
|
|
|
pqremove(s, tree, n); /* n = node of least frequency */
|
|
|
|
m = s->heap[SMALLEST]; /* m = node of next least frequency */
|
|
|
|
|
|
|
|
s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
|
|
|
|
s->heap[--(s->heap_max)] = m;
|
|
|
|
|
|
|
|
/* Create a new node father of n and m */
|
|
|
|
tree[node].Freq = tree[n].Freq + tree[m].Freq;
|
|
|
|
s->depth[node] = (uch) (MAX(s->depth[n], s->depth[m]) + 1);
|
|
|
|
tree[n].Dad = tree[m].Dad = (ush)node;
|
|
|
|
#ifdef DUMP_BL_TREE
|
|
|
|
if (tree == s->bl_tree) {
|
|
|
|
fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
|
|
|
|
node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* and insert the new node in the heap */
|
|
|
|
s->heap[SMALLEST] = node++;
|
|
|
|
pqdownheap(s, tree, SMALLEST);
|
|
|
|
|
|
|
|
} while (s->heap_len >= 2);
|
|
|
|
|
|
|
|
s->heap[--(s->heap_max)] = s->heap[SMALLEST];
|
|
|
|
|
|
|
|
/* At this point, the fields freq and dad are set. We can now
|
|
|
|
* generate the bit lengths.
|
|
|
|
*/
|
|
|
|
gen_bitlen(s, (tree_desc *)desc);
|
|
|
|
|
|
|
|
/* The field len is now set, we can generate the bit codes */
|
|
|
|
gen_codes ((ct_data *)tree, max_code, s->bl_count);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Scan a literal or distance tree to determine the frequencies of the codes
|
|
|
|
* in the bit length tree.
|
|
|
|
*/
|
|
|
|
local void scan_tree (s, tree, max_code)
|
|
|
|
deflate_state *s;
|
|
|
|
ct_data *tree; /* the tree to be scanned */
|
|
|
|
int max_code; /* and its largest code of non zero frequency */
|
|
|
|
{
|
|
|
|
int n; /* iterates over all tree elements */
|
|
|
|
int prevlen = -1; /* last emitted length */
|
|
|
|
int curlen; /* length of current code */
|
|
|
|
int nextlen = tree[0].Len; /* length of next code */
|
|
|
|
int count = 0; /* repeat count of the current code */
|
|
|
|
int max_count = 7; /* max repeat count */
|
|
|
|
int min_count = 4; /* min repeat count */
|
|
|
|
|
|
|
|
if (nextlen == 0) max_count = 138, min_count = 3;
|
|
|
|
tree[max_code+1].Len = (ush)0xffff; /* guard */
|
|
|
|
|
|
|
|
for (n = 0; n <= max_code; n++) {
|
|
|
|
curlen = nextlen; nextlen = tree[n+1].Len;
|
|
|
|
if (++count < max_count && curlen == nextlen) {
|
|
|
|
continue;
|
|
|
|
} else if (count < min_count) {
|
|
|
|
s->bl_tree[curlen].Freq += count;
|
|
|
|
} else if (curlen != 0) {
|
|
|
|
if (curlen != prevlen) s->bl_tree[curlen].Freq++;
|
|
|
|
s->bl_tree[REP_3_6].Freq++;
|
|
|
|
} else if (count <= 10) {
|
|
|
|
s->bl_tree[REPZ_3_10].Freq++;
|
|
|
|
} else {
|
|
|
|
s->bl_tree[REPZ_11_138].Freq++;
|
|
|
|
}
|
|
|
|
count = 0; prevlen = curlen;
|
|
|
|
if (nextlen == 0) {
|
|
|
|
max_count = 138, min_count = 3;
|
|
|
|
} else if (curlen == nextlen) {
|
|
|
|
max_count = 6, min_count = 3;
|
|
|
|
} else {
|
|
|
|
max_count = 7, min_count = 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Send a literal or distance tree in compressed form, using the codes in
|
|
|
|
* bl_tree.
|
|
|
|
*/
|
|
|
|
local void send_tree (s, tree, max_code)
|
|
|
|
deflate_state *s;
|
|
|
|
ct_data *tree; /* the tree to be scanned */
|
|
|
|
int max_code; /* and its largest code of non zero frequency */
|
|
|
|
{
|
|
|
|
int n; /* iterates over all tree elements */
|
|
|
|
int prevlen = -1; /* last emitted length */
|
|
|
|
int curlen; /* length of current code */
|
|
|
|
int nextlen = tree[0].Len; /* length of next code */
|
|
|
|
int count = 0; /* repeat count of the current code */
|
|
|
|
int max_count = 7; /* max repeat count */
|
|
|
|
int min_count = 4; /* min repeat count */
|
|
|
|
|
|
|
|
/* tree[max_code+1].Len = -1; */ /* guard already set */
|
|
|
|
if (nextlen == 0) max_count = 138, min_count = 3;
|
|
|
|
|
|
|
|
for (n = 0; n <= max_code; n++) {
|
|
|
|
curlen = nextlen; nextlen = tree[n+1].Len;
|
|
|
|
if (++count < max_count && curlen == nextlen) {
|
|
|
|
continue;
|
|
|
|
} else if (count < min_count) {
|
|
|
|
do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
|
|
|
|
|
|
|
|
} else if (curlen != 0) {
|
|
|
|
if (curlen != prevlen) {
|
|
|
|
send_code(s, curlen, s->bl_tree); count--;
|
|
|
|
}
|
|
|
|
Assert(count >= 3 && count <= 6, " 3_6?");
|
|
|
|
send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
|
|
|
|
|
|
|
|
} else if (count <= 10) {
|
|
|
|
send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
|
|
|
|
}
|
|
|
|
count = 0; prevlen = curlen;
|
|
|
|
if (nextlen == 0) {
|
|
|
|
max_count = 138, min_count = 3;
|
|
|
|
} else if (curlen == nextlen) {
|
|
|
|
max_count = 6, min_count = 3;
|
|
|
|
} else {
|
|
|
|
max_count = 7, min_count = 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Construct the Huffman tree for the bit lengths and return the index in
|
|
|
|
* bl_order of the last bit length code to send.
|
|
|
|
*/
|
|
|
|
local int build_bl_tree(s)
|
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
int max_blindex; /* index of last bit length code of non zero freq */
|
|
|
|
|
|
|
|
/* Determine the bit length frequencies for literal and distance trees */
|
|
|
|
scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
|
|
|
|
scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
|
|
|
|
|
|
|
|
/* Build the bit length tree: */
|
|
|
|
build_tree(s, (tree_desc *)(&(s->bl_desc)));
|
|
|
|
/* opt_len now includes the length of the tree representations, except
|
|
|
|
* the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Determine the number of bit length codes to send. The pkzip format
|
|
|
|
* requires that at least 4 bit length codes be sent. (appnote.txt says
|
|
|
|
* 3 but the actual value used is 4.)
|
|
|
|
*/
|
|
|
|
for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
|
|
|
|
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
|
|
|
|
}
|
|
|
|
/* Update opt_len to include the bit length tree and counts */
|
|
|
|
s->opt_len += 3*(max_blindex+1) + 5+5+4;
|
|
|
|
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
|
|
|
|
s->opt_len, s->static_len));
|
|
|
|
|
|
|
|
return max_blindex;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Send the header for a block using dynamic Huffman trees: the counts, the
|
|
|
|
* lengths of the bit length codes, the literal tree and the distance tree.
|
|
|
|
* IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
|
|
|
|
*/
|
|
|
|
local void send_all_trees(s, lcodes, dcodes, blcodes)
|
|
|
|
deflate_state *s;
|
|
|
|
int lcodes, dcodes, blcodes; /* number of codes for each tree */
|
|
|
|
{
|
|
|
|
int rank; /* index in bl_order */
|
|
|
|
|
|
|
|
Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
|
|
|
|
Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
|
|
|
|
"too many codes");
|
|
|
|
Tracev((stderr, "\nbl counts: "));
|
|
|
|
send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
|
|
|
|
send_bits(s, dcodes-1, 5);
|
|
|
|
send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
|
|
|
|
for (rank = 0; rank < blcodes; rank++) {
|
|
|
|
Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
|
|
|
|
send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
|
|
|
|
}
|
|
|
|
Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
|
|
|
|
|
|
|
|
send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
|
|
|
|
Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
|
|
|
|
|
|
|
|
send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
|
|
|
|
Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Send a stored block
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
void _tr_stored_block(s, buf, stored_len, eof)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
charf *buf; /* input block */
|
|
|
|
ulg stored_len; /* length of input block */
|
|
|
|
int eof; /* true if this is the last block for a file */
|
|
|
|
{
|
|
|
|
send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */
|
1998-03-21 20:56:16 +00:00
|
|
|
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
|
1997-08-19 14:10:50 +00:00
|
|
|
s->compressed_len += (stored_len + 4) << 3;
|
|
|
|
|
|
|
|
copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send just the `stored block' type code without any length bytes or data.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
void _tr_stored_type_only(s)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
send_bits(s, (STORED_BLOCK << 1), 3);
|
|
|
|
bi_windup(s);
|
|
|
|
s->compressed_len = (s->compressed_len + 3) & ~7L;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Send one empty static block to give enough lookahead for inflate.
|
|
|
|
* This takes 10 bits, of which 7 may remain in the bit buffer.
|
1998-03-21 20:56:16 +00:00
|
|
|
* The current inflate code requires 9 bits of lookahead. If the
|
|
|
|
* last two codes for the previous block (real code plus EOB) were coded
|
|
|
|
* on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
|
|
|
|
* the last real code. In this case we send two empty static blocks instead
|
|
|
|
* of one. (There are no problems if the previous block is stored or fixed.)
|
|
|
|
* To simplify the code, we assume the worst case of last real code encoded
|
|
|
|
* on one bit only.
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
void _tr_align(s)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
send_bits(s, STATIC_TREES<<1, 3);
|
|
|
|
send_code(s, END_BLOCK, static_ltree);
|
|
|
|
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
|
|
|
|
bi_flush(s);
|
|
|
|
/* Of the 10 bits for the empty block, we have already sent
|
1998-03-21 20:56:16 +00:00
|
|
|
* (10 - bi_valid) bits. The lookahead for the last real code (before
|
|
|
|
* the EOB of the previous block) was thus at least one plus the length
|
|
|
|
* of the EOB plus what we have just sent of the empty static block.
|
1997-08-19 14:10:50 +00:00
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
|
1997-08-19 14:10:50 +00:00
|
|
|
send_bits(s, STATIC_TREES<<1, 3);
|
|
|
|
send_code(s, END_BLOCK, static_ltree);
|
|
|
|
s->compressed_len += 10L;
|
|
|
|
bi_flush(s);
|
|
|
|
}
|
|
|
|
s->last_eob_len = 7;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Determine the best encoding for the current block: dynamic trees, static
|
|
|
|
* trees or store, and output the encoded block to the zip file. This function
|
|
|
|
* returns the total compressed length for the file so far.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
ulg _tr_flush_block(s, buf, stored_len, eof)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
|
|
|
charf *buf; /* input block, or NULL if too old */
|
|
|
|
ulg stored_len; /* length of input block */
|
1998-03-21 20:56:16 +00:00
|
|
|
int eof; /* true if this is the last block for a file */
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
|
1998-03-21 20:56:16 +00:00
|
|
|
int max_blindex = 0; /* index of last bit length code of non zero freq */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Build the Huffman trees unless a stored block is forced */
|
|
|
|
if (s->level > 0) {
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Check if the file is ascii or binary */
|
|
|
|
if (s->data_type == Z_UNKNOWN) set_data_type(s);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Construct the literal and distance trees */
|
|
|
|
build_tree(s, (tree_desc *)(&(s->l_desc)));
|
|
|
|
Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
|
|
|
|
s->static_len));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
build_tree(s, (tree_desc *)(&(s->d_desc)));
|
|
|
|
Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
|
|
|
|
s->static_len));
|
|
|
|
/* At this point, opt_len and static_len are the total bit lengths of
|
|
|
|
* the compressed block data, excluding the tree representations.
|
|
|
|
*/
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Build the bit length tree for the above two trees, and get the index
|
|
|
|
* in bl_order of the last bit length code to send.
|
|
|
|
*/
|
|
|
|
max_blindex = build_bl_tree(s);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Determine the best encoding. Compute first the block length in bytes*/
|
|
|
|
opt_lenb = (s->opt_len+3+7)>>3;
|
|
|
|
static_lenb = (s->static_len+3+7)>>3;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
|
|
|
|
opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
|
|
|
|
s->last_lit));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
Assert(buf != (char*)0, "lost buf");
|
|
|
|
opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* If compression failed and this is the first and last block,
|
|
|
|
* and if the .zip file can be seeked (to rewrite the local header),
|
|
|
|
* the whole file is transformed into a stored file:
|
|
|
|
*/
|
|
|
|
#ifdef STORED_FILE_OK
|
|
|
|
# ifdef FORCE_STORED_FILE
|
1998-03-21 20:56:16 +00:00
|
|
|
if (eof && s->compressed_len == 0L) { /* force stored file */
|
1997-08-19 14:10:50 +00:00
|
|
|
# else
|
1998-03-21 20:56:16 +00:00
|
|
|
if (stored_len <= opt_lenb && eof && s->compressed_len==0L && seekable()) {
|
1997-08-19 14:10:50 +00:00
|
|
|
# endif
|
|
|
|
/* Since LIT_BUFSIZE <= 2*WSIZE, the input data must be there: */
|
|
|
|
if (buf == (charf*)0) error ("block vanished");
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
copy_block(s, buf, (unsigned)stored_len, 0); /* without header */
|
1997-08-19 14:10:50 +00:00
|
|
|
s->compressed_len = stored_len << 3;
|
|
|
|
s->method = STORED;
|
|
|
|
} else
|
|
|
|
#endif /* STORED_FILE_OK */
|
|
|
|
|
|
|
|
#ifdef FORCE_STORED
|
1998-03-21 20:56:16 +00:00
|
|
|
if (buf != (char*)0) { /* force stored block */
|
1997-08-19 14:10:50 +00:00
|
|
|
#else
|
1998-03-21 20:56:16 +00:00
|
|
|
if (stored_len+4 <= opt_lenb && buf != (char*)0) {
|
1997-08-19 14:10:50 +00:00
|
|
|
/* 4: two words for the lengths */
|
|
|
|
#endif
|
|
|
|
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
|
|
|
|
* Otherwise we can't have processed more than WSIZE input bytes since
|
|
|
|
* the last block flush, because compression would have been
|
|
|
|
* successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
|
|
|
|
* transform a block into a stored block.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
_tr_stored_block(s, buf, stored_len, eof);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
#ifdef FORCE_STATIC
|
1998-03-21 20:56:16 +00:00
|
|
|
} else if (static_lenb >= 0) { /* force static trees */
|
1997-08-19 14:10:50 +00:00
|
|
|
#else
|
1998-03-21 20:56:16 +00:00
|
|
|
} else if (static_lenb == opt_lenb) {
|
1997-08-19 14:10:50 +00:00
|
|
|
#endif
|
|
|
|
send_bits(s, (STATIC_TREES<<1)+eof, 3);
|
|
|
|
compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
|
|
|
|
s->compressed_len += 3 + s->static_len;
|
|
|
|
} else {
|
|
|
|
send_bits(s, (DYN_TREES<<1)+eof, 3);
|
|
|
|
send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
|
|
|
|
max_blindex+1);
|
|
|
|
compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
|
|
|
|
s->compressed_len += 3 + s->opt_len;
|
|
|
|
}
|
|
|
|
Assert (s->compressed_len == s->bits_sent, "bad compressed size");
|
|
|
|
init_block(s);
|
|
|
|
|
|
|
|
if (eof) {
|
|
|
|
bi_windup(s);
|
|
|
|
s->compressed_len += 7; /* align on byte boundary */
|
|
|
|
}
|
|
|
|
Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
|
|
|
|
s->compressed_len-7*eof));
|
|
|
|
|
|
|
|
return s->compressed_len >> 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Save the match info and tally the frequency counts. Return true if
|
|
|
|
* the current block must be flushed.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
int _tr_tally (s, dist, lc)
|
1997-08-19 14:10:50 +00:00
|
|
|
deflate_state *s;
|
1998-03-21 20:56:16 +00:00
|
|
|
unsigned dist; /* distance of matched string */
|
|
|
|
unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
s->d_buf[s->last_lit] = (ush)dist;
|
|
|
|
s->l_buf[s->last_lit++] = (uch)lc;
|
|
|
|
if (dist == 0) {
|
|
|
|
/* lc is the unmatched char */
|
|
|
|
s->dyn_ltree[lc].Freq++;
|
|
|
|
} else {
|
|
|
|
s->matches++;
|
|
|
|
/* Here, lc is the match length - MIN_MATCH */
|
|
|
|
dist--; /* dist = match distance - 1 */
|
|
|
|
Assert((ush)dist < (ush)MAX_DIST(s) &&
|
|
|
|
(ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
|
1998-03-21 20:56:16 +00:00
|
|
|
(ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
s->dyn_ltree[length_code[lc]+LITERALS+1].Freq++;
|
|
|
|
s->dyn_dtree[d_code(dist)].Freq++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try to guess if it is profitable to stop the current block here */
|
|
|
|
if (s->level > 2 && (s->last_lit & 0xfff) == 0) {
|
|
|
|
/* Compute an upper bound for the compressed length */
|
|
|
|
ulg out_length = (ulg)s->last_lit*8L;
|
1998-03-21 20:56:16 +00:00
|
|
|
ulg in_length = (ulg)((long)s->strstart - s->block_start);
|
1997-08-19 14:10:50 +00:00
|
|
|
int dcode;
|
|
|
|
for (dcode = 0; dcode < D_CODES; dcode++) {
|
|
|
|
out_length += (ulg)s->dyn_dtree[dcode].Freq *
|
|
|
|
(5L+extra_dbits[dcode]);
|
|
|
|
}
|
|
|
|
out_length >>= 3;
|
|
|
|
Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
|
|
|
|
s->last_lit, in_length, out_length,
|
|
|
|
100L - out_length*100L/in_length));
|
|
|
|
if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
|
|
|
|
}
|
|
|
|
return (s->last_lit == s->lit_bufsize-1);
|
|
|
|
/* We avoid equality with lit_bufsize because of wraparound at 64K
|
|
|
|
* on 16 bit machines and because stored blocks are restricted to
|
|
|
|
* 64K-1 bytes.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Send the block data compressed using the given Huffman trees
|
|
|
|
*/
|
|
|
|
local void compress_block(s, ltree, dtree)
|
|
|
|
deflate_state *s;
|
|
|
|
ct_data *ltree; /* literal tree */
|
|
|
|
ct_data *dtree; /* distance tree */
|
|
|
|
{
|
|
|
|
unsigned dist; /* distance of matched string */
|
|
|
|
int lc; /* match length or unmatched char (if dist == 0) */
|
|
|
|
unsigned lx = 0; /* running index in l_buf */
|
|
|
|
unsigned code; /* the code to send */
|
|
|
|
int extra; /* number of extra bits to send */
|
|
|
|
|
|
|
|
if (s->last_lit != 0) do {
|
|
|
|
dist = s->d_buf[lx];
|
|
|
|
lc = s->l_buf[lx++];
|
|
|
|
if (dist == 0) {
|
|
|
|
send_code(s, lc, ltree); /* send a literal byte */
|
|
|
|
Tracecv(isgraph(lc), (stderr," '%c' ", lc));
|
|
|
|
} else {
|
|
|
|
/* Here, lc is the match length - MIN_MATCH */
|
|
|
|
code = length_code[lc];
|
|
|
|
send_code(s, code+LITERALS+1, ltree); /* send the length code */
|
|
|
|
extra = extra_lbits[code];
|
|
|
|
if (extra != 0) {
|
|
|
|
lc -= base_length[code];
|
|
|
|
send_bits(s, lc, extra); /* send the extra length bits */
|
|
|
|
}
|
|
|
|
dist--; /* dist is now the match distance - 1 */
|
|
|
|
code = d_code(dist);
|
|
|
|
Assert (code < D_CODES, "bad d_code");
|
|
|
|
|
|
|
|
send_code(s, code, dtree); /* send the distance code */
|
|
|
|
extra = extra_dbits[code];
|
|
|
|
if (extra != 0) {
|
|
|
|
dist -= base_dist[code];
|
|
|
|
send_bits(s, dist, extra); /* send the extra distance bits */
|
|
|
|
}
|
|
|
|
} /* literal or match pair ? */
|
|
|
|
|
|
|
|
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
|
|
|
|
Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow");
|
|
|
|
|
|
|
|
} while (lx < s->last_lit);
|
|
|
|
|
|
|
|
send_code(s, END_BLOCK, ltree);
|
|
|
|
s->last_eob_len = ltree[END_BLOCK].Len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
1998-03-21 20:56:16 +00:00
|
|
|
* Set the data type to ASCII or BINARY, using a crude approximation:
|
1997-08-19 14:10:50 +00:00
|
|
|
* binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
|
|
|
|
* IN assertion: the fields freq of dyn_ltree are set and the total of all
|
|
|
|
* frequencies does not exceed 64K (to fit in an int on 16 bit machines).
|
|
|
|
*/
|
|
|
|
local void set_data_type(s)
|
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
int n = 0;
|
|
|
|
unsigned ascii_freq = 0;
|
|
|
|
unsigned bin_freq = 0;
|
|
|
|
while (n < 7) bin_freq += s->dyn_ltree[n++].Freq;
|
|
|
|
while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq;
|
|
|
|
while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq;
|
1998-03-21 20:56:16 +00:00
|
|
|
s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Reverse the first len bits of a code, using straightforward code (a faster
|
|
|
|
* method would use a table)
|
|
|
|
* IN assertion: 1 <= len <= 15
|
|
|
|
*/
|
|
|
|
local unsigned bi_reverse(code, len)
|
|
|
|
unsigned code; /* the value to invert */
|
|
|
|
int len; /* its bit length */
|
|
|
|
{
|
|
|
|
register unsigned res = 0;
|
|
|
|
do {
|
|
|
|
res |= code & 1;
|
|
|
|
code >>= 1, res <<= 1;
|
|
|
|
} while (--len > 0);
|
|
|
|
return res >> 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Flush the bit buffer, keeping at most 7 bits in it.
|
|
|
|
*/
|
|
|
|
local void bi_flush(s)
|
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
if (s->bi_valid == 16) {
|
|
|
|
put_short(s, s->bi_buf);
|
|
|
|
s->bi_buf = 0;
|
|
|
|
s->bi_valid = 0;
|
|
|
|
} else if (s->bi_valid >= 8) {
|
|
|
|
put_byte(s, (Byte)s->bi_buf);
|
|
|
|
s->bi_buf >>= 8;
|
|
|
|
s->bi_valid -= 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Flush the bit buffer and align the output on a byte boundary
|
|
|
|
*/
|
|
|
|
local void bi_windup(s)
|
|
|
|
deflate_state *s;
|
|
|
|
{
|
|
|
|
if (s->bi_valid > 8) {
|
|
|
|
put_short(s, s->bi_buf);
|
|
|
|
} else if (s->bi_valid > 0) {
|
|
|
|
put_byte(s, (Byte)s->bi_buf);
|
|
|
|
}
|
|
|
|
s->bi_buf = 0;
|
|
|
|
s->bi_valid = 0;
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
s->bits_sent = (s->bits_sent+7) & ~7;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ===========================================================================
|
|
|
|
* Copy a stored block, storing first the length and its
|
|
|
|
* one's complement if requested.
|
|
|
|
*/
|
|
|
|
local void copy_block(s, buf, len, header)
|
|
|
|
deflate_state *s;
|
|
|
|
charf *buf; /* the input data */
|
|
|
|
unsigned len; /* its length */
|
|
|
|
int header; /* true if block header must be written */
|
|
|
|
{
|
|
|
|
bi_windup(s); /* align on byte boundary */
|
|
|
|
s->last_eob_len = 8; /* enough lookahead for inflate */
|
|
|
|
|
|
|
|
if (header) {
|
|
|
|
put_short(s, (ush)len);
|
|
|
|
put_short(s, (ush)~len);
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
s->bits_sent += 2*16;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
s->bits_sent += (ulg)len<<3;
|
|
|
|
#endif
|
1998-03-21 20:56:16 +00:00
|
|
|
/* bundle up the put_byte(s, *buf++) calls */
|
|
|
|
zmemcpy(&s->pending_buf[s->pending], buf, len);
|
|
|
|
s->pending += len;
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- trees.c */
|
|
|
|
|
|
|
|
/* +++ inflate.c */
|
|
|
|
/* inflate.c -- zlib interface to inflate modules
|
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* #include "zutil.h" */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ infblock.h */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* infblock.h -- header to use infblock.c
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* WARNING: this file should *not* be used by applications. It is
|
|
|
|
part of the implementation of the compression library and is
|
|
|
|
subject to change. Applications should only use zlib.h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct inflate_blocks_state;
|
|
|
|
typedef struct inflate_blocks_state FAR inflate_blocks_statef;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
extern inflate_blocks_statef * inflate_blocks_new OF((
|
|
|
|
z_streamp z,
|
1997-08-19 14:10:50 +00:00
|
|
|
check_func c, /* check function */
|
|
|
|
uInt w)); /* window size */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
extern int inflate_blocks OF((
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *,
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp ,
|
1997-08-19 14:10:50 +00:00
|
|
|
int)); /* initial return code */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
extern void inflate_blocks_reset OF((
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *,
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp ,
|
1997-08-19 14:10:50 +00:00
|
|
|
uLongf *)); /* check value on output */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
extern int inflate_blocks_free OF((
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *,
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp ,
|
1997-08-19 14:10:50 +00:00
|
|
|
uLongf *)); /* check value on output */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
extern void inflate_set_dictionary OF((
|
|
|
|
inflate_blocks_statef *s,
|
|
|
|
const Bytef *d, /* dictionary */
|
|
|
|
uInt n)); /* dictionary length */
|
|
|
|
|
|
|
|
extern int inflate_addhistory OF((
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *,
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
extern int inflate_packet_flush OF((
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *));
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- infblock.h */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct inflate_blocks_state {int dummy;}; /* for buggy compilers */
|
1997-08-19 14:10:50 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* inflate private state */
|
|
|
|
struct internal_state {
|
|
|
|
|
|
|
|
/* mode */
|
|
|
|
enum {
|
|
|
|
METHOD, /* waiting for method byte */
|
|
|
|
FLAG, /* waiting for flag byte */
|
1998-03-21 20:56:16 +00:00
|
|
|
DICT4, /* four dictionary check bytes to go */
|
|
|
|
DICT3, /* three dictionary check bytes to go */
|
|
|
|
DICT2, /* two dictionary check bytes to go */
|
|
|
|
DICT1, /* one dictionary check byte to go */
|
|
|
|
DICT0, /* waiting for inflateSetDictionary */
|
1997-08-19 14:10:50 +00:00
|
|
|
BLOCKS, /* decompressing blocks */
|
|
|
|
CHECK4, /* four check bytes to go */
|
|
|
|
CHECK3, /* three check bytes to go */
|
|
|
|
CHECK2, /* two check bytes to go */
|
|
|
|
CHECK1, /* one check byte to go */
|
|
|
|
DONE, /* finished check, done */
|
|
|
|
BAD} /* got an error--stay here */
|
|
|
|
mode; /* current inflate mode */
|
|
|
|
|
|
|
|
/* mode dependent information */
|
|
|
|
union {
|
|
|
|
uInt method; /* if FLAGS, method byte */
|
|
|
|
struct {
|
|
|
|
uLong was; /* computed check value */
|
|
|
|
uLong need; /* stream check value */
|
|
|
|
} check; /* if CHECK, check values to compare */
|
|
|
|
uInt marker; /* if BAD, inflateSync's marker bytes count */
|
|
|
|
} sub; /* submode */
|
|
|
|
|
|
|
|
/* mode independent information */
|
|
|
|
int nowrap; /* flag for no wrapper */
|
|
|
|
uInt wbits; /* log2(window size) (8..15, defaults to 15) */
|
|
|
|
inflate_blocks_statef
|
|
|
|
*blocks; /* current inflate_blocks state */
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
int inflateReset(z)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
uLong c;
|
|
|
|
|
|
|
|
if (z == Z_NULL || z->state == Z_NULL)
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
z->total_in = z->total_out = 0;
|
|
|
|
z->msg = Z_NULL;
|
|
|
|
z->state->mode = z->state->nowrap ? BLOCKS : METHOD;
|
|
|
|
inflate_blocks_reset(z->state->blocks, z, &c);
|
|
|
|
Trace((stderr, "inflate: reset\n"));
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int inflateEnd(z)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
uLong c;
|
|
|
|
|
|
|
|
if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
if (z->state->blocks != Z_NULL)
|
|
|
|
inflate_blocks_free(z->state->blocks, z, &c);
|
1998-03-21 20:56:16 +00:00
|
|
|
ZFREE(z, z->state);
|
1997-08-19 14:10:50 +00:00
|
|
|
z->state = Z_NULL;
|
|
|
|
Trace((stderr, "inflate: end\n"));
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflateInit2_(z, w, version, stream_size)
|
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
int w;
|
1998-03-21 20:56:16 +00:00
|
|
|
const char *version;
|
|
|
|
int stream_size;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
|
|
|
stream_size != sizeof(z_stream))
|
|
|
|
return Z_VERSION_ERROR;
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* initialize state */
|
|
|
|
if (z == Z_NULL)
|
|
|
|
return Z_STREAM_ERROR;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = Z_NULL;
|
|
|
|
#ifndef NO_ZCFUNCS
|
|
|
|
if (z->zalloc == Z_NULL)
|
|
|
|
{
|
|
|
|
z->zalloc = zcalloc;
|
|
|
|
z->opaque = (voidpf)0;
|
|
|
|
}
|
|
|
|
if (z->zfree == Z_NULL) z->zfree = zcfree;
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
if ((z->state = (struct internal_state FAR *)
|
1998-03-21 20:56:16 +00:00
|
|
|
ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)
|
1997-08-19 14:10:50 +00:00
|
|
|
return Z_MEM_ERROR;
|
|
|
|
z->state->blocks = Z_NULL;
|
|
|
|
|
|
|
|
/* handle undocumented nowrap option (no zlib header or check) */
|
|
|
|
z->state->nowrap = 0;
|
|
|
|
if (w < 0)
|
|
|
|
{
|
|
|
|
w = - w;
|
|
|
|
z->state->nowrap = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set window size */
|
|
|
|
if (w < 8 || w > 15)
|
|
|
|
{
|
|
|
|
inflateEnd(z);
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
z->state->wbits = (uInt)w;
|
|
|
|
|
|
|
|
/* create inflate_blocks state */
|
|
|
|
if ((z->state->blocks =
|
1998-03-21 20:56:16 +00:00
|
|
|
inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w))
|
1997-08-19 14:10:50 +00:00
|
|
|
== Z_NULL)
|
|
|
|
{
|
|
|
|
inflateEnd(z);
|
|
|
|
return Z_MEM_ERROR;
|
|
|
|
}
|
|
|
|
Trace((stderr, "inflate: allocated\n"));
|
|
|
|
|
|
|
|
/* reset state */
|
|
|
|
inflateReset(z);
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflateInit_(z, version, stream_size)
|
|
|
|
z_streamp z;
|
|
|
|
const char *version;
|
|
|
|
int stream_size;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
return inflateInit2_(z, DEF_WBITS, version, stream_size);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define NEEDBYTE {if(z->avail_in==0)goto empty;r=Z_OK;}
|
|
|
|
#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)
|
|
|
|
|
|
|
|
int inflate(z, f)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
int f;
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
uInt b;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL || f < 0)
|
1997-08-19 14:10:50 +00:00
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
r = Z_BUF_ERROR;
|
|
|
|
while (1) switch (z->state->mode)
|
|
|
|
{
|
|
|
|
case METHOD:
|
|
|
|
NEEDBYTE
|
1998-03-21 20:56:16 +00:00
|
|
|
if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED)
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
z->state->mode = BAD;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"unknown compression method";
|
1997-08-19 14:10:50 +00:00
|
|
|
z->state->sub.marker = 5; /* can't try inflateSync */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
|
|
|
|
{
|
|
|
|
z->state->mode = BAD;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid window size";
|
1997-08-19 14:10:50 +00:00
|
|
|
z->state->sub.marker = 5; /* can't try inflateSync */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
z->state->mode = FLAG;
|
|
|
|
case FLAG:
|
|
|
|
NEEDBYTE
|
1998-03-21 20:56:16 +00:00
|
|
|
b = NEXTBYTE;
|
1997-08-19 14:10:50 +00:00
|
|
|
if (((z->state->sub.method << 8) + b) % 31)
|
|
|
|
{
|
|
|
|
z->state->mode = BAD;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"incorrect header check";
|
1997-08-19 14:10:50 +00:00
|
|
|
z->state->sub.marker = 5; /* can't try inflateSync */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
Trace((stderr, "inflate: zlib header ok\n"));
|
1998-03-21 20:56:16 +00:00
|
|
|
if (!(b & PRESET_DICT))
|
|
|
|
{
|
|
|
|
z->state->mode = BLOCKS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
z->state->mode = DICT4;
|
|
|
|
case DICT4:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need = (uLong)NEXTBYTE << 24;
|
|
|
|
z->state->mode = DICT3;
|
|
|
|
case DICT3:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need += (uLong)NEXTBYTE << 16;
|
|
|
|
z->state->mode = DICT2;
|
|
|
|
case DICT2:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need += (uLong)NEXTBYTE << 8;
|
|
|
|
z->state->mode = DICT1;
|
|
|
|
case DICT1:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need += (uLong)NEXTBYTE;
|
|
|
|
z->adler = z->state->sub.check.need;
|
|
|
|
z->state->mode = DICT0;
|
|
|
|
return Z_NEED_DICT;
|
|
|
|
case DICT0:
|
|
|
|
z->state->mode = BAD;
|
|
|
|
z->msg = (char*)"need dictionary";
|
|
|
|
z->state->sub.marker = 0; /* can try inflateSync */
|
|
|
|
return Z_STREAM_ERROR;
|
1997-08-19 14:10:50 +00:00
|
|
|
case BLOCKS:
|
|
|
|
r = inflate_blocks(z->state->blocks, z, r);
|
|
|
|
if (f == Z_PACKET_FLUSH && z->avail_in == 0 && z->avail_out != 0)
|
|
|
|
r = inflate_packet_flush(z->state->blocks);
|
|
|
|
if (r == Z_DATA_ERROR)
|
|
|
|
{
|
|
|
|
z->state->mode = BAD;
|
|
|
|
z->state->sub.marker = 0; /* can try inflateSync */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (r != Z_STREAM_END)
|
|
|
|
return r;
|
|
|
|
r = Z_OK;
|
|
|
|
inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
|
|
|
|
if (z->state->nowrap)
|
|
|
|
{
|
|
|
|
z->state->mode = DONE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
z->state->mode = CHECK4;
|
|
|
|
case CHECK4:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need = (uLong)NEXTBYTE << 24;
|
|
|
|
z->state->mode = CHECK3;
|
|
|
|
case CHECK3:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need += (uLong)NEXTBYTE << 16;
|
|
|
|
z->state->mode = CHECK2;
|
|
|
|
case CHECK2:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need += (uLong)NEXTBYTE << 8;
|
|
|
|
z->state->mode = CHECK1;
|
|
|
|
case CHECK1:
|
|
|
|
NEEDBYTE
|
|
|
|
z->state->sub.check.need += (uLong)NEXTBYTE;
|
|
|
|
|
|
|
|
if (z->state->sub.check.was != z->state->sub.check.need)
|
|
|
|
{
|
|
|
|
z->state->mode = BAD;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"incorrect data check";
|
1997-08-19 14:10:50 +00:00
|
|
|
z->state->sub.marker = 5; /* can't try inflateSync */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
Trace((stderr, "inflate: zlib check ok\n"));
|
|
|
|
z->state->mode = DONE;
|
|
|
|
case DONE:
|
|
|
|
return Z_STREAM_END;
|
|
|
|
case BAD:
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
default:
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
empty:
|
|
|
|
if (f != Z_PACKET_FLUSH)
|
|
|
|
return r;
|
|
|
|
z->state->mode = BAD;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char *)"need more for packet flush";
|
1997-08-19 14:10:50 +00:00
|
|
|
z->state->sub.marker = 0; /* can try inflateSync */
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
}
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
|
|
|
|
int inflateSetDictionary(z, dictionary, dictLength)
|
|
|
|
z_streamp z;
|
|
|
|
const Bytef *dictionary;
|
|
|
|
uInt dictLength;
|
|
|
|
{
|
|
|
|
uInt length = dictLength;
|
|
|
|
|
|
|
|
if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0)
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
|
|
|
|
if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR;
|
|
|
|
z->adler = 1L;
|
|
|
|
|
|
|
|
if (length >= ((uInt)1<<z->state->wbits))
|
|
|
|
{
|
|
|
|
length = (1<<z->state->wbits)-1;
|
|
|
|
dictionary += dictLength - length;
|
|
|
|
}
|
|
|
|
inflate_set_dictionary(z->state->blocks, dictionary, length);
|
|
|
|
z->state->mode = BLOCKS;
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/*
|
|
|
|
* This subroutine adds the data at next_in/avail_in to the output history
|
|
|
|
* without performing any output. The output buffer must be "caught up";
|
|
|
|
* i.e. no pending output (hence s->read equals s->write), and the state must
|
|
|
|
* be BLOCKS (i.e. we should be willing to see the start of a series of
|
|
|
|
* BLOCKS). On exit, the output will also be caught up, and the checksum
|
|
|
|
* will have been updated if need be.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int inflateIncomp(z)
|
|
|
|
z_stream *z;
|
|
|
|
{
|
|
|
|
if (z->state->mode != BLOCKS)
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
return inflate_addhistory(z->state->blocks, z);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int inflateSync(z)
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
uInt n; /* number of bytes to look at */
|
|
|
|
Bytef *p; /* pointer to bytes */
|
|
|
|
uInt m; /* number of marker bytes found in a row */
|
|
|
|
uLong r, w; /* temporaries to save total_in and total_out */
|
|
|
|
|
|
|
|
/* set up */
|
|
|
|
if (z == Z_NULL || z->state == Z_NULL)
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
if (z->state->mode != BAD)
|
|
|
|
{
|
|
|
|
z->state->mode = BAD;
|
|
|
|
z->state->sub.marker = 0;
|
|
|
|
}
|
|
|
|
if ((n = z->avail_in) == 0)
|
|
|
|
return Z_BUF_ERROR;
|
|
|
|
p = z->next_in;
|
|
|
|
m = z->state->sub.marker;
|
|
|
|
|
|
|
|
/* search */
|
|
|
|
while (n && m < 4)
|
|
|
|
{
|
|
|
|
if (*p == (Byte)(m < 2 ? 0 : 0xff))
|
|
|
|
m++;
|
|
|
|
else if (*p)
|
|
|
|
m = 0;
|
|
|
|
else
|
|
|
|
m = 4 - m;
|
|
|
|
p++, n--;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* restore */
|
|
|
|
z->total_in += p - z->next_in;
|
|
|
|
z->next_in = p;
|
|
|
|
z->avail_in = n;
|
|
|
|
z->state->sub.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->state->mode = BLOCKS;
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NEEDBYTE
|
|
|
|
#undef NEXTBYTE
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- inflate.c */
|
|
|
|
|
|
|
|
/* +++ infblock.c */
|
|
|
|
/* infblock.c -- interpret and process block types to last block
|
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* #include "zutil.h" */
|
|
|
|
/* #include "infblock.h" */
|
|
|
|
|
|
|
|
/* +++ inftrees.h */
|
|
|
|
/* inftrees.h -- header to use inftrees.c
|
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* WARNING: this file should *not* be used by applications. It is
|
|
|
|
part of the implementation of the compression library and is
|
|
|
|
subject to change. Applications should only use zlib.h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Huffman code lookup table entry--this entry is four bytes for machines
|
|
|
|
that have 16-bit pointers (e.g. PC's in the small or medium model). */
|
|
|
|
|
|
|
|
typedef struct inflate_huft_s FAR inflate_huft;
|
|
|
|
|
|
|
|
struct inflate_huft_s {
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
Byte Exop; /* number of extra bits or operation */
|
|
|
|
Byte Bits; /* number of bits in this code or subcode */
|
|
|
|
} what;
|
|
|
|
Bytef *pad; /* pad structure to a power of 2 (4 bytes for */
|
|
|
|
} word; /* 16-bit, 8 bytes for 32-bit machines) */
|
|
|
|
union {
|
|
|
|
uInt Base; /* literal, length base, or distance base */
|
|
|
|
inflate_huft *Next; /* pointer to next level of table */
|
|
|
|
} more;
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
extern uInt inflate_hufts;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern int inflate_trees_bits OF((
|
|
|
|
uIntf *, /* 19 code lengths */
|
|
|
|
uIntf *, /* bits tree desired/actual depth */
|
|
|
|
inflate_huft * FAR *, /* bits tree result */
|
|
|
|
z_streamp )); /* for zalloc, zfree functions */
|
|
|
|
|
|
|
|
extern int inflate_trees_dynamic OF((
|
|
|
|
uInt, /* number of literal/length codes */
|
|
|
|
uInt, /* number of distance codes */
|
|
|
|
uIntf *, /* that many (total) code lengths */
|
|
|
|
uIntf *, /* literal desired/actual bit depth */
|
|
|
|
uIntf *, /* distance desired/actual bit depth */
|
|
|
|
inflate_huft * FAR *, /* literal/length tree result */
|
|
|
|
inflate_huft * FAR *, /* distance tree result */
|
|
|
|
z_streamp )); /* for zalloc, zfree functions */
|
|
|
|
|
|
|
|
extern int inflate_trees_fixed OF((
|
|
|
|
uIntf *, /* literal desired/actual bit depth */
|
|
|
|
uIntf *, /* distance desired/actual bit depth */
|
|
|
|
inflate_huft * FAR *, /* literal/length tree result */
|
|
|
|
inflate_huft * FAR *)); /* distance tree result */
|
|
|
|
|
|
|
|
extern int inflate_trees_free OF((
|
|
|
|
inflate_huft *, /* tables to free */
|
|
|
|
z_streamp )); /* for zfree function */
|
|
|
|
|
|
|
|
/* --- inftrees.h */
|
|
|
|
|
|
|
|
/* +++ infcodes.h */
|
|
|
|
/* infcodes.h -- header to use infcodes.c
|
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* WARNING: this file should *not* be used by applications. It is
|
|
|
|
part of the implementation of the compression library and is
|
|
|
|
subject to change. Applications should only use zlib.h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct inflate_codes_state;
|
|
|
|
typedef struct inflate_codes_state FAR inflate_codes_statef;
|
|
|
|
|
|
|
|
extern inflate_codes_statef *inflate_codes_new OF((
|
|
|
|
uInt, uInt,
|
|
|
|
inflate_huft *, inflate_huft *,
|
|
|
|
z_streamp ));
|
|
|
|
|
|
|
|
extern int inflate_codes OF((
|
|
|
|
inflate_blocks_statef *,
|
|
|
|
z_streamp ,
|
|
|
|
int));
|
|
|
|
|
|
|
|
extern void inflate_codes_free OF((
|
|
|
|
inflate_codes_statef *,
|
|
|
|
z_streamp ));
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- infcodes.h */
|
|
|
|
|
|
|
|
/* +++ infutil.h */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* infutil.h -- types and macros common to blocks and codes
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* WARNING: this file should *not* be used by applications. It is
|
|
|
|
part of the implementation of the compression library and is
|
|
|
|
subject to change. Applications should only use zlib.h.
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifndef _INFUTIL_H
|
|
|
|
#define _INFUTIL_H
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
typedef enum {
|
1997-08-19 14:10:50 +00:00
|
|
|
TYPE, /* get type bits (3, including end bit) */
|
|
|
|
LENS, /* get lengths for stored */
|
|
|
|
STORED, /* processing stored block */
|
|
|
|
TABLE, /* get table lengths */
|
|
|
|
BTREE, /* get bit lengths tree for a dynamic block */
|
|
|
|
DTREE, /* get length, distance trees for a dynamic block */
|
|
|
|
CODES, /* processing fixed or dynamic block */
|
|
|
|
DRY, /* output remaining window bytes */
|
1998-03-21 20:56:16 +00:00
|
|
|
DONEB, /* finished last block, done */
|
|
|
|
BADB} /* got a data error--stuck here */
|
|
|
|
inflate_block_mode;
|
|
|
|
|
|
|
|
/* inflate blocks semi-private state */
|
|
|
|
struct inflate_blocks_state {
|
|
|
|
|
|
|
|
/* mode */
|
|
|
|
inflate_block_mode mode; /* current inflate_block mode */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* mode dependent information */
|
|
|
|
union {
|
|
|
|
uInt left; /* if STORED, bytes left to copy */
|
|
|
|
struct {
|
|
|
|
uInt table; /* table lengths (14 bits) */
|
|
|
|
uInt index; /* index into blens (or border) */
|
|
|
|
uIntf *blens; /* bit lengths of codes */
|
|
|
|
uInt bb; /* bit length tree depth */
|
|
|
|
inflate_huft *tb; /* bit length decoding tree */
|
|
|
|
} trees; /* if DTREE, decoding info for trees */
|
|
|
|
struct {
|
1998-03-21 20:56:16 +00:00
|
|
|
inflate_huft *tl;
|
|
|
|
inflate_huft *td; /* trees to free */
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_codes_statef
|
|
|
|
*codes;
|
|
|
|
} decode; /* if CODES, current state */
|
|
|
|
} sub; /* submode */
|
|
|
|
uInt last; /* true if this block is the last block */
|
|
|
|
|
|
|
|
/* mode independent information */
|
|
|
|
uInt bitk; /* bits in bit buffer */
|
|
|
|
uLong bitb; /* bit buffer */
|
|
|
|
Bytef *window; /* sliding window */
|
|
|
|
Bytef *end; /* one byte after sliding window */
|
|
|
|
Bytef *read; /* window read pointer */
|
|
|
|
Bytef *write; /* window write pointer */
|
|
|
|
check_func checkfn; /* check function */
|
|
|
|
uLong check; /* check on output */
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* defines for inflate input/output */
|
|
|
|
/* update pointers and return */
|
|
|
|
#define UPDBITS {s->bitb=b;s->bitk=k;}
|
|
|
|
#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;}
|
|
|
|
#define UPDOUT {s->write=q;}
|
|
|
|
#define UPDATE {UPDBITS UPDIN UPDOUT}
|
|
|
|
#define LEAVE {UPDATE return inflate_flush(s,z,r);}
|
|
|
|
/* get bytes and bits */
|
|
|
|
#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
|
|
|
|
#define NEEDBYTE {if(n)r=Z_OK;else LEAVE}
|
|
|
|
#define NEXTBYTE (n--,*p++)
|
|
|
|
#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
|
|
|
|
#define DUMPBITS(j) {b>>=(j);k-=(j);}
|
|
|
|
/* output bytes */
|
1998-03-21 20:56:16 +00:00
|
|
|
#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)
|
|
|
|
#define LOADOUT {q=s->write;m=(uInt)WAVAIL;}
|
|
|
|
#define WWRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}
|
1997-08-19 14:10:50 +00:00
|
|
|
#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
|
1998-03-21 20:56:16 +00:00
|
|
|
#define NEEDOUT {if(m==0){WWRAP if(m==0){FLUSH WWRAP if(m==0) LEAVE}}r=Z_OK;}
|
1997-08-19 14:10:50 +00:00
|
|
|
#define OUTBYTE(a) {*q++=(Byte)(a);m--;}
|
|
|
|
/* load local pointers */
|
|
|
|
#define LOAD {LOADIN LOADOUT}
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* masks for lower bits (size given to avoid silly warnings with Visual C++) */
|
|
|
|
extern uInt inflate_mask[17];
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* copy as much as possible from the sliding window to the output area */
|
1998-03-21 20:56:16 +00:00
|
|
|
extern int inflate_flush OF((
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *,
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp ,
|
1997-08-19 14:10:50 +00:00
|
|
|
int));
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct internal_state {int dummy;}; /* for buggy compilers */
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#endif
|
|
|
|
/* --- infutil.h */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct inflate_codes_state {int dummy;}; /* for buggy compilers */
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* Table for deflate from PKZIP's appnote.txt. */
|
1998-03-21 20:56:16 +00:00
|
|
|
local const uInt border[] = { /* Order of the bit length code lengths */
|
1997-08-19 14:10:50 +00:00
|
|
|
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
|
|
|
|
|
|
|
|
/*
|
|
|
|
Notes beyond the 1.93a appnote.txt:
|
|
|
|
|
|
|
|
1. Distance pointers never point before the beginning of the output
|
|
|
|
stream.
|
|
|
|
2. Distance pointers can point back across blocks, up to 32k away.
|
|
|
|
3. There is an implied maximum of 7 bits for the bit length table and
|
|
|
|
15 bits for the actual data.
|
|
|
|
4. If only one code exists, then it is encoded using one bit. (Zero
|
|
|
|
would be more efficient, but perhaps a little confusing.) If two
|
|
|
|
codes exist, they are coded using one bit each (0 and 1).
|
|
|
|
5. There is no way of sending zero distance codes--a dummy must be
|
|
|
|
sent if there are none. (History: a pre 2.0 version of PKZIP would
|
|
|
|
store blocks with no distance codes, but this was discovered to be
|
|
|
|
too harsh a criterion.) Valid only for 1.93a. 2.04c does allow
|
|
|
|
zero distance codes, which is sent as one code of zero bits in
|
|
|
|
length.
|
|
|
|
6. There are up to 286 literal/length codes. Code 256 represents the
|
|
|
|
end-of-block. Note however that the static length tree defines
|
|
|
|
288 codes just to fill out the Huffman codes. Codes 286 and 287
|
|
|
|
cannot be used though, since there is no length base or extra bits
|
|
|
|
defined for them. Similarily, there are up to 30 distance codes.
|
|
|
|
However, static trees define 32 codes (all 5 bits) to fill out the
|
|
|
|
Huffman codes, but the last two had better not show up in the data.
|
|
|
|
7. Unzip can check dynamic Huffman blocks for complete code sets.
|
|
|
|
The exception is that a single code would not be complete (see #4).
|
|
|
|
8. The five bits following the block type is really the number of
|
|
|
|
literal codes sent minus 257.
|
|
|
|
9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
|
|
|
|
(1+6+6). Therefore, to output three times the length, you output
|
|
|
|
three codes (1+1+1), whereas to output four times the same length,
|
|
|
|
you only need two codes (1+3). Hmm.
|
|
|
|
10. In the tree reconstruction algorithm, Code = Code + Increment
|
|
|
|
only if BitLength(i) is not zero. (Pretty obvious.)
|
|
|
|
11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19)
|
|
|
|
12. Note: length code 284 can represent 227-258, but length code 285
|
|
|
|
really is 258. The last length deserves its own, short code
|
|
|
|
since it gets used a lot in very redundant files. The length
|
|
|
|
258 is special since 258 - 3 (the min match length) is 255.
|
|
|
|
13. The literal/length and distance code bit lengths are read as a
|
|
|
|
single stream of lengths. It is possible (and advantageous) for
|
|
|
|
a repeat code (16, 17, or 18) to go across the boundary between
|
|
|
|
the two sets of lengths.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
void inflate_blocks_reset(s, z, c)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
uLongf *c;
|
|
|
|
{
|
|
|
|
if (s->checkfn != Z_NULL)
|
|
|
|
*c = s->check;
|
|
|
|
if (s->mode == BTREE || s->mode == DTREE)
|
1998-03-21 20:56:16 +00:00
|
|
|
ZFREE(z, s->sub.trees.blens);
|
1997-08-19 14:10:50 +00:00
|
|
|
if (s->mode == CODES)
|
|
|
|
{
|
|
|
|
inflate_codes_free(s->sub.decode.codes, z);
|
|
|
|
inflate_trees_free(s->sub.decode.td, z);
|
|
|
|
inflate_trees_free(s->sub.decode.tl, z);
|
|
|
|
}
|
|
|
|
s->mode = TYPE;
|
|
|
|
s->bitk = 0;
|
|
|
|
s->bitb = 0;
|
|
|
|
s->read = s->write = s->window;
|
|
|
|
if (s->checkfn != Z_NULL)
|
1998-03-21 20:56:16 +00:00
|
|
|
z->adler = s->check = (*s->checkfn)(0L, Z_NULL, 0);
|
1997-08-19 14:10:50 +00:00
|
|
|
Trace((stderr, "inflate: blocks reset\n"));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
inflate_blocks_statef *inflate_blocks_new(z, c, w)
|
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
check_func c;
|
|
|
|
uInt w;
|
|
|
|
{
|
|
|
|
inflate_blocks_statef *s;
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
if ((s = (inflate_blocks_statef *)ZALLOC
|
1997-08-19 14:10:50 +00:00
|
|
|
(z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
|
|
|
|
return s;
|
1998-03-21 20:56:16 +00:00
|
|
|
if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
ZFREE(z, s);
|
1997-08-19 14:10:50 +00:00
|
|
|
return Z_NULL;
|
|
|
|
}
|
|
|
|
s->end = s->window + w;
|
|
|
|
s->checkfn = c;
|
|
|
|
s->mode = TYPE;
|
|
|
|
Trace((stderr, "inflate: blocks allocated\n"));
|
|
|
|
inflate_blocks_reset(s, z, &s->check);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
extern uInt inflate_hufts;
|
|
|
|
#endif
|
|
|
|
int inflate_blocks(s, z, r)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
int r;
|
|
|
|
{
|
|
|
|
uInt t; /* temporary storage */
|
|
|
|
uLong b; /* bit buffer */
|
|
|
|
uInt k; /* bits in bit buffer */
|
|
|
|
Bytef *p; /* input data pointer */
|
|
|
|
uInt n; /* bytes available there */
|
|
|
|
Bytef *q; /* output window write pointer */
|
|
|
|
uInt m; /* bytes to end of window or read pointer */
|
|
|
|
|
|
|
|
/* copy input/output information to locals (UPDATE macro restores) */
|
|
|
|
LOAD
|
|
|
|
|
|
|
|
/* process input based on current state */
|
|
|
|
while (1) switch (s->mode)
|
|
|
|
{
|
|
|
|
case TYPE:
|
|
|
|
NEEDBITS(3)
|
|
|
|
t = (uInt)b & 7;
|
|
|
|
s->last = t & 1;
|
|
|
|
switch (t >> 1)
|
|
|
|
{
|
|
|
|
case 0: /* stored */
|
|
|
|
Trace((stderr, "inflate: stored block%s\n",
|
|
|
|
s->last ? " (last)" : ""));
|
|
|
|
DUMPBITS(3)
|
|
|
|
t = k & 7; /* go to byte boundary */
|
|
|
|
DUMPBITS(t)
|
|
|
|
s->mode = LENS; /* get length of stored block */
|
|
|
|
break;
|
|
|
|
case 1: /* fixed */
|
|
|
|
Trace((stderr, "inflate: fixed codes block%s\n",
|
|
|
|
s->last ? " (last)" : ""));
|
|
|
|
{
|
|
|
|
uInt bl, bd;
|
|
|
|
inflate_huft *tl, *td;
|
|
|
|
|
|
|
|
inflate_trees_fixed(&bl, &bd, &tl, &td);
|
|
|
|
s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
|
|
|
|
if (s->sub.decode.codes == Z_NULL)
|
|
|
|
{
|
|
|
|
r = Z_MEM_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
s->sub.decode.tl = Z_NULL; /* don't try to free these */
|
|
|
|
s->sub.decode.td = Z_NULL;
|
|
|
|
}
|
|
|
|
DUMPBITS(3)
|
|
|
|
s->mode = CODES;
|
|
|
|
break;
|
|
|
|
case 2: /* dynamic */
|
|
|
|
Trace((stderr, "inflate: dynamic codes block%s\n",
|
|
|
|
s->last ? " (last)" : ""));
|
|
|
|
DUMPBITS(3)
|
|
|
|
s->mode = TABLE;
|
|
|
|
break;
|
|
|
|
case 3: /* illegal */
|
|
|
|
DUMPBITS(3)
|
|
|
|
s->mode = BADB;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid block type";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LENS:
|
|
|
|
NEEDBITS(32)
|
1998-03-21 20:56:16 +00:00
|
|
|
if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
s->mode = BADB;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid stored block lengths";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
s->sub.left = (uInt)b & 0xffff;
|
|
|
|
b = k = 0; /* dump bits */
|
|
|
|
Tracev((stderr, "inflate: stored length %u\n", s->sub.left));
|
1998-03-21 20:56:16 +00:00
|
|
|
s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
|
1997-08-19 14:10:50 +00:00
|
|
|
break;
|
|
|
|
case STORED:
|
|
|
|
if (n == 0)
|
|
|
|
LEAVE
|
|
|
|
NEEDOUT
|
|
|
|
t = s->sub.left;
|
|
|
|
if (t > n) t = n;
|
|
|
|
if (t > m) t = m;
|
|
|
|
zmemcpy(q, p, t);
|
|
|
|
p += t; n -= t;
|
|
|
|
q += t; m -= t;
|
|
|
|
if ((s->sub.left -= t) != 0)
|
|
|
|
break;
|
|
|
|
Tracev((stderr, "inflate: stored end, %lu total out\n",
|
|
|
|
z->total_out + (q >= s->read ? q - s->read :
|
|
|
|
(s->end - s->read) + (q - s->window))));
|
|
|
|
s->mode = s->last ? DRY : TYPE;
|
|
|
|
break;
|
|
|
|
case TABLE:
|
|
|
|
NEEDBITS(14)
|
|
|
|
s->sub.trees.table = t = (uInt)b & 0x3fff;
|
|
|
|
#ifndef PKZIP_BUG_WORKAROUND
|
|
|
|
if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
|
|
|
|
{
|
|
|
|
s->mode = BADB;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"too many length or distance symbols";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
|
|
|
|
if (t < 19)
|
|
|
|
t = 19;
|
|
|
|
if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
|
|
|
|
{
|
|
|
|
r = Z_MEM_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
DUMPBITS(14)
|
|
|
|
s->sub.trees.index = 0;
|
|
|
|
Tracev((stderr, "inflate: table sizes ok\n"));
|
|
|
|
s->mode = BTREE;
|
|
|
|
case BTREE:
|
|
|
|
while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
|
|
|
|
{
|
|
|
|
NEEDBITS(3)
|
|
|
|
s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
|
|
|
|
DUMPBITS(3)
|
|
|
|
}
|
|
|
|
while (s->sub.trees.index < 19)
|
|
|
|
s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
|
|
|
|
s->sub.trees.bb = 7;
|
|
|
|
t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
|
|
|
|
&s->sub.trees.tb, z);
|
|
|
|
if (t != Z_OK)
|
|
|
|
{
|
|
|
|
r = t;
|
2002-02-17 17:35:18 +00:00
|
|
|
if (r == Z_DATA_ERROR) {
|
|
|
|
ZFREE(z, s->sub.trees.blens);
|
1997-08-19 14:10:50 +00:00
|
|
|
s->mode = BADB;
|
2002-02-17 17:35:18 +00:00
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
s->sub.trees.index = 0;
|
|
|
|
Tracev((stderr, "inflate: bits tree ok\n"));
|
|
|
|
s->mode = DTREE;
|
|
|
|
case DTREE:
|
|
|
|
while (t = s->sub.trees.table,
|
|
|
|
s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
|
|
|
|
{
|
|
|
|
inflate_huft *h;
|
|
|
|
uInt i, j, c;
|
|
|
|
|
|
|
|
t = s->sub.trees.bb;
|
|
|
|
NEEDBITS(t)
|
|
|
|
h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
|
|
|
|
t = h->word.what.Bits;
|
|
|
|
c = h->more.Base;
|
|
|
|
if (c < 16)
|
|
|
|
{
|
|
|
|
DUMPBITS(t)
|
|
|
|
s->sub.trees.blens[s->sub.trees.index++] = c;
|
|
|
|
}
|
|
|
|
else /* c == 16..18 */
|
|
|
|
{
|
|
|
|
i = c == 18 ? 7 : c - 14;
|
|
|
|
j = c == 18 ? 11 : 3;
|
|
|
|
NEEDBITS(t + i)
|
|
|
|
DUMPBITS(t)
|
|
|
|
j += (uInt)b & inflate_mask[i];
|
|
|
|
DUMPBITS(i)
|
|
|
|
i = s->sub.trees.index;
|
|
|
|
t = s->sub.trees.table;
|
|
|
|
if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
|
|
|
|
(c == 16 && i < 1))
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
inflate_trees_free(s->sub.trees.tb, z);
|
|
|
|
ZFREE(z, s->sub.trees.blens);
|
1997-08-19 14:10:50 +00:00
|
|
|
s->mode = BADB;
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid bit length repeat";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
|
|
|
|
do {
|
|
|
|
s->sub.trees.blens[i++] = c;
|
|
|
|
} while (--j);
|
|
|
|
s->sub.trees.index = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
inflate_trees_free(s->sub.trees.tb, z);
|
|
|
|
s->sub.trees.tb = Z_NULL;
|
|
|
|
{
|
|
|
|
uInt bl, bd;
|
|
|
|
inflate_huft *tl, *td;
|
|
|
|
inflate_codes_statef *c;
|
|
|
|
|
|
|
|
bl = 9; /* must be <= 9 for lookahead assumptions */
|
|
|
|
bd = 6; /* must be <= 9 for lookahead assumptions */
|
|
|
|
t = s->sub.trees.table;
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
inflate_hufts = 0;
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
|
|
|
|
s->sub.trees.blens, &bl, &bd, &tl, &td, z);
|
|
|
|
if (t != Z_OK)
|
|
|
|
{
|
2002-02-17 17:35:18 +00:00
|
|
|
if (t == (uInt)Z_DATA_ERROR) {
|
|
|
|
ZFREE(z, s->sub.trees.blens);
|
1997-08-19 14:10:50 +00:00
|
|
|
s->mode = BADB;
|
2002-02-17 17:35:18 +00:00
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
r = t;
|
|
|
|
LEAVE
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
Tracev((stderr, "inflate: trees ok, %d * %d bytes used\n",
|
|
|
|
inflate_hufts, sizeof(inflate_huft)));
|
1997-08-19 14:10:50 +00:00
|
|
|
if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
|
|
|
|
{
|
|
|
|
inflate_trees_free(td, z);
|
|
|
|
inflate_trees_free(tl, z);
|
|
|
|
r = Z_MEM_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
2002-03-20 04:05:26 +00:00
|
|
|
/*
|
|
|
|
* this ZFREE must occur *BEFORE* we mess with sub.decode, because
|
|
|
|
* sub.trees is union'd with sub.decode.
|
|
|
|
*/
|
|
|
|
ZFREE(z, s->sub.trees.blens);
|
1997-08-19 14:10:50 +00:00
|
|
|
s->sub.decode.codes = c;
|
|
|
|
s->sub.decode.tl = tl;
|
|
|
|
s->sub.decode.td = td;
|
|
|
|
}
|
|
|
|
s->mode = CODES;
|
|
|
|
case CODES:
|
|
|
|
UPDATE
|
|
|
|
if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
|
|
|
|
return inflate_flush(s, z, r);
|
|
|
|
r = Z_OK;
|
|
|
|
inflate_codes_free(s->sub.decode.codes, z);
|
|
|
|
inflate_trees_free(s->sub.decode.td, z);
|
|
|
|
inflate_trees_free(s->sub.decode.tl, z);
|
|
|
|
LOAD
|
|
|
|
Tracev((stderr, "inflate: codes end, %lu total out\n",
|
|
|
|
z->total_out + (q >= s->read ? q - s->read :
|
|
|
|
(s->end - s->read) + (q - s->window))));
|
|
|
|
if (!s->last)
|
|
|
|
{
|
|
|
|
s->mode = TYPE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (k > 7) /* return unused byte, if any */
|
|
|
|
{
|
|
|
|
Assert(k < 16, "inflate_codes grabbed too many bytes")
|
|
|
|
k -= 8;
|
|
|
|
n++;
|
|
|
|
p--; /* can always return one */
|
|
|
|
}
|
|
|
|
s->mode = DRY;
|
|
|
|
case DRY:
|
|
|
|
FLUSH
|
|
|
|
if (s->read != s->write)
|
|
|
|
LEAVE
|
|
|
|
s->mode = DONEB;
|
|
|
|
case DONEB:
|
|
|
|
r = Z_STREAM_END;
|
|
|
|
LEAVE
|
|
|
|
case BADB:
|
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
default:
|
|
|
|
r = Z_STREAM_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_blocks_free(s, z, c)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
uLongf *c;
|
|
|
|
{
|
|
|
|
inflate_blocks_reset(s, z, c);
|
1998-03-21 20:56:16 +00:00
|
|
|
ZFREE(z, s->window);
|
|
|
|
ZFREE(z, s);
|
1997-08-19 14:10:50 +00:00
|
|
|
Trace((stderr, "inflate: blocks freed\n"));
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
|
|
|
|
void inflate_set_dictionary(s, d, n)
|
|
|
|
inflate_blocks_statef *s;
|
|
|
|
const Bytef *d;
|
|
|
|
uInt n;
|
|
|
|
{
|
|
|
|
zmemcpy((charf *)s->window, d, n);
|
|
|
|
s->read = s->write = s->window + n;
|
|
|
|
}
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/*
|
|
|
|
* This subroutine adds the data at next_in/avail_in to the output history
|
|
|
|
* without performing any output. The output buffer must be "caught up";
|
|
|
|
* i.e. no pending output (hence s->read equals s->write), and the state must
|
|
|
|
* be BLOCKS (i.e. we should be willing to see the start of a series of
|
|
|
|
* BLOCKS). On exit, the output will also be caught up, and the checksum
|
|
|
|
* will have been updated if need be.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_addhistory(s, z)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
|
|
|
z_stream *z;
|
|
|
|
{
|
|
|
|
uLong b; /* bit buffer */ /* NOT USED HERE */
|
|
|
|
uInt k; /* bits in bit buffer */ /* NOT USED HERE */
|
|
|
|
uInt t; /* temporary storage */
|
|
|
|
Bytef *p; /* input data pointer */
|
|
|
|
uInt n; /* bytes available there */
|
|
|
|
Bytef *q; /* output window write pointer */
|
|
|
|
uInt m; /* bytes to end of window or read pointer */
|
|
|
|
|
|
|
|
if (s->read != s->write)
|
|
|
|
return Z_STREAM_ERROR;
|
|
|
|
if (s->mode != TYPE)
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
|
|
|
|
/* we're ready to rock */
|
|
|
|
LOAD
|
|
|
|
/* while there is input ready, copy to output buffer, moving
|
|
|
|
* pointers as needed.
|
|
|
|
*/
|
|
|
|
while (n) {
|
|
|
|
t = n; /* how many to do */
|
|
|
|
/* is there room until end of buffer? */
|
|
|
|
if (t > m) t = m;
|
|
|
|
/* update check information */
|
|
|
|
if (s->checkfn != Z_NULL)
|
|
|
|
s->check = (*s->checkfn)(s->check, q, t);
|
|
|
|
zmemcpy(q, p, t);
|
|
|
|
q += t;
|
|
|
|
p += t;
|
|
|
|
n -= t;
|
|
|
|
z->total_out += t;
|
|
|
|
s->read = q; /* drag read pointer forward */
|
1998-03-21 20:56:16 +00:00
|
|
|
/* WWRAP */ /* expand WWRAP macro by hand to handle s->read */
|
1997-08-19 14:10:50 +00:00
|
|
|
if (q == s->end) {
|
|
|
|
s->read = q = s->window;
|
|
|
|
m = WAVAIL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
UPDATE
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At the end of a Deflate-compressed PPP packet, we expect to have seen
|
|
|
|
* a `stored' block type value but not the (zero) length bytes.
|
|
|
|
*/
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_packet_flush(s)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
|
|
|
{
|
|
|
|
if (s->mode != LENS)
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
s->mode = TYPE;
|
|
|
|
return Z_OK;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- infblock.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ inftrees.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* inftrees.c -- generate Huffman trees for efficient decoding
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* #include "zutil.h" */
|
|
|
|
/* #include "inftrees.h" */
|
|
|
|
|
|
|
|
char inflate_copyright[] = " inflate 1.0.4 Copyright 1995-1996 Mark Adler ";
|
|
|
|
/*
|
|
|
|
If you use the zlib library in a product, an acknowledgment is welcome
|
|
|
|
in the documentation of your product. If for some reason you cannot
|
|
|
|
include such an acknowledgment, I would appreciate that you keep this
|
|
|
|
copyright string in the executable of your product.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct internal_state {int dummy;}; /* for buggy compilers */
|
|
|
|
#endif
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* simplify the use of the inflate_huft type with some defines */
|
|
|
|
#define base more.Base
|
|
|
|
#define next more.Next
|
|
|
|
#define exop word.what.Exop
|
|
|
|
#define bits word.what.Bits
|
|
|
|
|
|
|
|
|
|
|
|
local int huft_build OF((
|
|
|
|
uIntf *, /* code lengths in bits */
|
|
|
|
uInt, /* number of codes */
|
|
|
|
uInt, /* number of "simple" codes */
|
1998-03-21 20:56:16 +00:00
|
|
|
const uIntf *, /* list of base values for non-simple codes */
|
|
|
|
const uIntf *, /* list of extra bits for non-simple codes */
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_huft * FAR*,/* result: starting table */
|
|
|
|
uIntf *, /* maximum lookup bits (returns actual) */
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp )); /* for zalloc function */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
local voidpf falloc OF((
|
|
|
|
voidpf, /* opaque pointer (not used) */
|
|
|
|
uInt, /* number of items */
|
|
|
|
uInt)); /* size of item */
|
|
|
|
|
|
|
|
/* Tables for deflate from PKZIP's appnote.txt. */
|
1998-03-21 20:56:16 +00:00
|
|
|
local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
|
1997-08-19 14:10:50 +00:00
|
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
|
|
|
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
1998-03-21 20:56:16 +00:00
|
|
|
/* see note #13 above about 258 */
|
|
|
|
local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
|
1997-08-19 14:10:50 +00:00
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
|
1998-03-21 20:56:16 +00:00
|
|
|
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
|
|
|
|
local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
|
1997-08-19 14:10:50 +00:00
|
|
|
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
|
|
|
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
|
|
|
8193, 12289, 16385, 24577};
|
1998-03-21 20:56:16 +00:00
|
|
|
local const uInt cpdext[30] = { /* Extra bits for distance codes */
|
1997-08-19 14:10:50 +00:00
|
|
|
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
|
|
|
|
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
|
|
|
|
12, 12, 13, 13};
|
|
|
|
|
|
|
|
/*
|
|
|
|
Huffman code decoding is performed using a multi-level table lookup.
|
|
|
|
The fastest way to decode is to simply build a lookup table whose
|
|
|
|
size is determined by the longest code. However, the time it takes
|
|
|
|
to build this table can also be a factor if the data being decoded
|
|
|
|
is not very long. The most common codes are necessarily the
|
|
|
|
shortest codes, so those codes dominate the decoding time, and hence
|
|
|
|
the speed. The idea is you can have a shorter table that decodes the
|
|
|
|
shorter, more probable codes, and then point to subsidiary tables for
|
|
|
|
the longer codes. The time it costs to decode the longer codes is
|
|
|
|
then traded against the time it takes to make longer tables.
|
|
|
|
|
|
|
|
This results of this trade are in the variables lbits and dbits
|
|
|
|
below. lbits is the number of bits the first level table for literal/
|
|
|
|
length codes can decode in one step, and dbits is the same thing for
|
|
|
|
the distance codes. Subsequent tables are also less than or equal to
|
|
|
|
those sizes. These values may be adjusted either when all of the
|
|
|
|
codes are shorter than that, in which case the longest code length in
|
|
|
|
bits is used, or when the shortest code is *longer* than the requested
|
|
|
|
table size, in which case the length of the shortest code in bits is
|
|
|
|
used.
|
|
|
|
|
|
|
|
There are two different values for the two tables, since they code a
|
|
|
|
different number of possibilities each. The literal/length table
|
|
|
|
codes 286 possible values, or in a flat code, a little over eight
|
|
|
|
bits. The distance table codes 30 possible values, or a little less
|
|
|
|
than five bits, flat. The optimum values for speed end up being
|
|
|
|
about one bit more than those, so lbits is 8+1 and dbits is 5+1.
|
|
|
|
The optimum values may differ though from machine to machine, and
|
|
|
|
possibly even between compilers. Your mileage may vary.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
|
|
|
|
#define BMAX 15 /* maximum bit length of any code */
|
|
|
|
#define N_MAX 288 /* maximum number of codes in any set */
|
|
|
|
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
uInt inflate_hufts;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
local int huft_build(b, n, s, d, e, t, m, zs)
|
|
|
|
uIntf *b; /* code lengths in bits (all assumed <= BMAX) */
|
|
|
|
uInt n; /* number of codes (assumed <= N_MAX) */
|
|
|
|
uInt s; /* number of simple-valued codes (0..s-1) */
|
1998-03-21 20:56:16 +00:00
|
|
|
const uIntf *d; /* list of base values for non-simple codes */
|
|
|
|
const uIntf *e; /* list of extra bits for non-simple codes */
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_huft * FAR *t; /* result: starting table */
|
|
|
|
uIntf *m; /* maximum lookup bits, returns actual */
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp zs; /* for zalloc function */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* Given a list of code lengths and a maximum table size, make a set of
|
|
|
|
tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
|
|
|
|
if the given code set is incomplete (the tables are still built in this
|
1998-03-21 20:56:16 +00:00
|
|
|
case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
|
|
|
|
lengths), or Z_MEM_ERROR if not enough memory. */
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
uInt a; /* counter for codes of length k */
|
|
|
|
uInt c[BMAX+1]; /* bit length count table */
|
|
|
|
uInt f; /* i repeats in table every f entries */
|
|
|
|
int g; /* maximum code length */
|
|
|
|
int h; /* table level */
|
|
|
|
register uInt i; /* counter, current code */
|
|
|
|
register uInt j; /* counter */
|
|
|
|
register int k; /* number of bits in current code */
|
|
|
|
int l; /* bits per table (returned in m) */
|
|
|
|
register uIntf *p; /* pointer into c[], b[], or v[] */
|
|
|
|
inflate_huft *q; /* points to current table */
|
|
|
|
struct inflate_huft_s r; /* table entry for structure assignment */
|
|
|
|
inflate_huft *u[BMAX]; /* table stack */
|
|
|
|
uInt v[N_MAX]; /* values in order of bit length */
|
|
|
|
register int w; /* bits before this table == (l * h) */
|
|
|
|
uInt x[BMAX+1]; /* bit offsets, then code stack */
|
|
|
|
uIntf *xp; /* pointer into x */
|
|
|
|
int y; /* number of dummy codes added */
|
|
|
|
uInt z; /* number of entries in current table */
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate counts for each bit length */
|
|
|
|
p = c;
|
|
|
|
#define C0 *p++ = 0;
|
|
|
|
#define C2 C0 C0 C0 C0
|
|
|
|
#define C4 C2 C2 C2 C2
|
|
|
|
C4 /* clear c[]--assume BMAX+1 is 16 */
|
|
|
|
p = b; i = n;
|
|
|
|
do {
|
|
|
|
c[*p++]++; /* assume all entries <= BMAX */
|
|
|
|
} while (--i);
|
|
|
|
if (c[0] == n) /* null input--all zero length codes */
|
|
|
|
{
|
|
|
|
*t = (inflate_huft *)Z_NULL;
|
|
|
|
*m = 0;
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Find minimum and maximum length, bound *m by those */
|
|
|
|
l = *m;
|
|
|
|
for (j = 1; j <= BMAX; j++)
|
|
|
|
if (c[j])
|
|
|
|
break;
|
|
|
|
k = j; /* minimum code length */
|
|
|
|
if ((uInt)l < j)
|
|
|
|
l = j;
|
|
|
|
for (i = BMAX; i; i--)
|
|
|
|
if (c[i])
|
|
|
|
break;
|
|
|
|
g = i; /* maximum code length */
|
|
|
|
if ((uInt)l > i)
|
|
|
|
l = i;
|
|
|
|
*m = l;
|
|
|
|
|
|
|
|
|
|
|
|
/* Adjust last length count to fill out codes, if needed */
|
|
|
|
for (y = 1 << j; j < i; j++, y <<= 1)
|
|
|
|
if ((y -= c[j]) < 0)
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
if ((y -= c[i]) < 0)
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
c[i] += y;
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate starting offsets into the value table for each length */
|
|
|
|
x[1] = j = 0;
|
|
|
|
p = c + 1; xp = x + 2;
|
|
|
|
while (--i) { /* note that i == g from above */
|
|
|
|
*xp++ = (j += *p++);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Make a table of values in order of bit lengths */
|
|
|
|
p = b; i = 0;
|
|
|
|
do {
|
|
|
|
if ((j = *p++) != 0)
|
|
|
|
v[x[j]++] = i;
|
|
|
|
} while (++i < n);
|
1998-03-21 20:56:16 +00:00
|
|
|
n = x[g]; /* set n to length of v */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Generate the Huffman codes and for each, make the table entries */
|
|
|
|
x[0] = i = 0; /* first Huffman code is zero */
|
|
|
|
p = v; /* grab values in bit order */
|
|
|
|
h = -1; /* no tables yet--level -1 */
|
|
|
|
w = -l; /* bits decoded == (l * h) */
|
|
|
|
u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */
|
|
|
|
q = (inflate_huft *)Z_NULL; /* ditto */
|
|
|
|
z = 0; /* ditto */
|
|
|
|
|
|
|
|
/* go through the bit lengths (k already is bits in shortest code) */
|
|
|
|
for (; k <= g; k++)
|
|
|
|
{
|
|
|
|
a = c[k];
|
|
|
|
while (a--)
|
|
|
|
{
|
|
|
|
/* here i is the Huffman code of length k bits for value *p */
|
|
|
|
/* make tables up to required level */
|
|
|
|
while (k > w + l)
|
|
|
|
{
|
|
|
|
h++;
|
|
|
|
w += l; /* previous table always l bits */
|
|
|
|
|
|
|
|
/* compute minimum size table less than or equal to l bits */
|
1998-03-21 20:56:16 +00:00
|
|
|
z = g - w;
|
|
|
|
z = z > (uInt)l ? l : z; /* table size upper limit */
|
1997-08-19 14:10:50 +00:00
|
|
|
if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
|
|
|
|
{ /* too few codes for k-w bit table */
|
|
|
|
f -= a + 1; /* deduct codes from patterns left */
|
|
|
|
xp = c + k;
|
|
|
|
if (j < z)
|
|
|
|
while (++j < z) /* try smaller tables up to z bits */
|
|
|
|
{
|
|
|
|
if ((f <<= 1) <= *++xp)
|
|
|
|
break; /* enough codes to use up j bits */
|
|
|
|
f -= *xp; /* else deduct codes from patterns */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
z = 1 << j; /* table entries for j-bit table */
|
|
|
|
|
|
|
|
/* allocate and link in new table */
|
|
|
|
if ((q = (inflate_huft *)ZALLOC
|
|
|
|
(zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
|
|
|
|
{
|
|
|
|
if (h)
|
|
|
|
inflate_trees_free(u[0], zs);
|
|
|
|
return Z_MEM_ERROR; /* not enough memory */
|
|
|
|
}
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
inflate_hufts += z + 1;
|
|
|
|
#endif
|
|
|
|
*t = q + 1; /* link to list for huft_free() */
|
|
|
|
*(t = &(q->next)) = Z_NULL;
|
|
|
|
u[h] = ++q; /* table starts after link */
|
|
|
|
|
|
|
|
/* connect to last table, if there is one */
|
|
|
|
if (h)
|
|
|
|
{
|
|
|
|
x[h] = i; /* save pattern for backing up */
|
|
|
|
r.bits = (Byte)l; /* bits to dump before this table */
|
|
|
|
r.exop = (Byte)j; /* bits in this table */
|
|
|
|
r.next = q; /* pointer to this table */
|
|
|
|
j = i >> (w - l); /* (get around Turbo C bug) */
|
|
|
|
u[h-1][j] = r; /* connect to last table */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set up table entry in r */
|
|
|
|
r.bits = (Byte)(k - w);
|
|
|
|
if (p >= v + n)
|
|
|
|
r.exop = 128 + 64; /* out of values--invalid code */
|
|
|
|
else if (*p < s)
|
|
|
|
{
|
|
|
|
r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */
|
|
|
|
r.base = *p++; /* simple code is just the value */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
|
1997-08-19 14:10:50 +00:00
|
|
|
r.base = d[*p++ - s];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill code-like entries with r */
|
|
|
|
f = 1 << (k - w);
|
|
|
|
for (j = i >> w; j < z; j += f)
|
|
|
|
q[j] = r;
|
|
|
|
|
|
|
|
/* backwards increment the k-bit code i */
|
|
|
|
for (j = 1 << (k - 1); i & j; j >>= 1)
|
|
|
|
i ^= j;
|
|
|
|
i ^= j;
|
|
|
|
|
|
|
|
/* backup over finished tables */
|
|
|
|
while ((i & ((1 << w) - 1)) != x[h])
|
|
|
|
{
|
|
|
|
h--; /* don't need to update q */
|
|
|
|
w -= l;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Return Z_BUF_ERROR if we were given an incomplete table */
|
|
|
|
return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_trees_bits(c, bb, tb, z)
|
1997-08-19 14:10:50 +00:00
|
|
|
uIntf *c; /* 19 code lengths */
|
|
|
|
uIntf *bb; /* bits tree desired/actual depth */
|
|
|
|
inflate_huft * FAR *tb; /* bits tree result */
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z; /* for zfree function */
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, tb, bb, z);
|
|
|
|
if (r == Z_DATA_ERROR)
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"oversubscribed dynamic bit lengths tree";
|
|
|
|
else if (r == Z_BUF_ERROR || *bb == 0)
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
inflate_trees_free(*tb, z);
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"incomplete dynamic bit lengths tree";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, z)
|
1997-08-19 14:10:50 +00:00
|
|
|
uInt nl; /* number of literal/length codes */
|
|
|
|
uInt nd; /* number of distance codes */
|
|
|
|
uIntf *c; /* that many (total) code lengths */
|
|
|
|
uIntf *bl; /* literal desired/actual bit depth */
|
|
|
|
uIntf *bd; /* distance desired/actual bit depth */
|
|
|
|
inflate_huft * FAR *tl; /* literal/length tree result */
|
|
|
|
inflate_huft * FAR *td; /* distance tree result */
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z; /* for zfree function */
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
/* build literal/length tree */
|
1998-03-21 20:56:16 +00:00
|
|
|
r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z);
|
|
|
|
if (r != Z_OK || *bl == 0)
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
if (r == Z_DATA_ERROR)
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"oversubscribed literal/length tree";
|
|
|
|
else if (r != Z_MEM_ERROR)
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
inflate_trees_free(*tl, z);
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"incomplete literal/length tree";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* build distance tree */
|
1998-03-21 20:56:16 +00:00
|
|
|
r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z);
|
|
|
|
if (r != Z_OK || (*bd == 0 && nl > 257))
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
if (r == Z_DATA_ERROR)
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"oversubscribed distance tree";
|
1997-08-19 14:10:50 +00:00
|
|
|
else if (r == Z_BUF_ERROR) {
|
|
|
|
#ifdef PKZIP_BUG_WORKAROUND
|
|
|
|
r = Z_OK;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
inflate_trees_free(*td, z);
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"incomplete distance tree";
|
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
}
|
|
|
|
else if (r != Z_MEM_ERROR)
|
|
|
|
{
|
|
|
|
z->msg = (char*)"empty distance tree with lengths";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
}
|
|
|
|
inflate_trees_free(*tl, z);
|
|
|
|
return r;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/* done */
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* build fixed tables only once--keep them here */
|
|
|
|
local int fixed_built = 0;
|
|
|
|
#define FIXEDH 530 /* number of hufts used by fixed tables */
|
|
|
|
local inflate_huft fixed_mem[FIXEDH];
|
|
|
|
local uInt fixed_bl;
|
|
|
|
local uInt fixed_bd;
|
|
|
|
local inflate_huft *fixed_tl;
|
|
|
|
local inflate_huft *fixed_td;
|
|
|
|
|
|
|
|
|
|
|
|
local voidpf falloc(q, n, s)
|
1998-03-21 20:56:16 +00:00
|
|
|
voidpf q; /* opaque pointer */
|
1997-08-19 14:10:50 +00:00
|
|
|
uInt n; /* number of items */
|
|
|
|
uInt s; /* size of item */
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
Assert(s == sizeof(inflate_huft) && n <= *(intf *)q,
|
1997-08-19 14:10:50 +00:00
|
|
|
"inflate_trees falloc overflow");
|
1998-03-21 20:56:16 +00:00
|
|
|
*(intf *)q -= n+s-s; /* s-s to avoid warning */
|
|
|
|
return (voidpf)(fixed_mem + *(intf *)q);
|
1997-08-19 14:10:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_trees_fixed(bl, bd, tl, td)
|
1997-08-19 14:10:50 +00:00
|
|
|
uIntf *bl; /* literal desired/actual bit depth */
|
|
|
|
uIntf *bd; /* distance desired/actual bit depth */
|
|
|
|
inflate_huft * FAR *tl; /* literal/length tree result */
|
|
|
|
inflate_huft * FAR *td; /* distance tree result */
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
/* build fixed tables if not already (multiple overlapped executions ok) */
|
1997-08-19 14:10:50 +00:00
|
|
|
if (!fixed_built)
|
|
|
|
{
|
|
|
|
int k; /* temporary variable */
|
|
|
|
unsigned c[288]; /* length list for huft_build */
|
|
|
|
z_stream z; /* for falloc function */
|
1998-03-21 20:56:16 +00:00
|
|
|
int f = FIXEDH; /* number of hufts left in fixed_mem */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* set up fake z_stream for memory routines */
|
|
|
|
z.zalloc = falloc;
|
1998-03-21 20:56:16 +00:00
|
|
|
z.zfree = Z_NULL;
|
|
|
|
z.opaque = (voidpf)&f;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* literal table */
|
|
|
|
for (k = 0; k < 144; k++)
|
|
|
|
c[k] = 8;
|
|
|
|
for (; k < 256; k++)
|
|
|
|
c[k] = 9;
|
|
|
|
for (; k < 280; k++)
|
|
|
|
c[k] = 7;
|
|
|
|
for (; k < 288; k++)
|
|
|
|
c[k] = 8;
|
|
|
|
fixed_bl = 7;
|
|
|
|
huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z);
|
|
|
|
|
|
|
|
/* distance table */
|
|
|
|
for (k = 0; k < 30; k++)
|
|
|
|
c[k] = 5;
|
|
|
|
fixed_bd = 5;
|
|
|
|
huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z);
|
|
|
|
|
|
|
|
/* done */
|
1998-03-21 20:56:16 +00:00
|
|
|
Assert(f == 0, "invalid build of fixed tables");
|
1997-08-19 14:10:50 +00:00
|
|
|
fixed_built = 1;
|
|
|
|
}
|
|
|
|
*bl = fixed_bl;
|
|
|
|
*bd = fixed_bd;
|
|
|
|
*tl = fixed_tl;
|
|
|
|
*td = fixed_td;
|
|
|
|
return Z_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_trees_free(t, z)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_huft *t; /* table to free */
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z; /* for zfree function */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* Free the malloc'ed tables built by huft_build(), which makes a linked
|
|
|
|
list of the tables it made, with the links in a dummy first entry of
|
|
|
|
each table. */
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
register inflate_huft *p, *q, *r;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* Reverse linked list */
|
|
|
|
p = Z_NULL;
|
|
|
|
q = t;
|
|
|
|
while (q != Z_NULL)
|
|
|
|
{
|
|
|
|
r = (q - 1)->next;
|
|
|
|
(q - 1)->next = p;
|
|
|
|
p = q;
|
|
|
|
q = r;
|
|
|
|
}
|
1997-08-19 14:10:50 +00:00
|
|
|
/* Go through linked list, freeing from the malloced (t[-1]) address. */
|
|
|
|
while (p != Z_NULL)
|
|
|
|
{
|
|
|
|
q = (--p)->next;
|
1998-03-21 20:56:16 +00:00
|
|
|
ZFREE(z,p);
|
1997-08-19 14:10:50 +00:00
|
|
|
p = q;
|
|
|
|
}
|
|
|
|
return Z_OK;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- inftrees.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ infcodes.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* infcodes.c -- process literals and length/distance pairs
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* #include "zutil.h" */
|
|
|
|
/* #include "inftrees.h" */
|
|
|
|
/* #include "infblock.h" */
|
|
|
|
/* #include "infcodes.h" */
|
|
|
|
/* #include "infutil.h" */
|
|
|
|
|
|
|
|
/* +++ inffast.h */
|
|
|
|
/* inffast.h -- header to use inffast.c
|
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* WARNING: this file should *not* be used by applications. It is
|
|
|
|
part of the implementation of the compression library and is
|
|
|
|
subject to change. Applications should only use zlib.h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
extern int inflate_fast OF((
|
|
|
|
uInt,
|
|
|
|
uInt,
|
|
|
|
inflate_huft *,
|
|
|
|
inflate_huft *,
|
|
|
|
inflate_blocks_statef *,
|
|
|
|
z_streamp ));
|
|
|
|
/* --- inffast.h */
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* simplify the use of the inflate_huft type with some defines */
|
|
|
|
#define base more.Base
|
|
|
|
#define next more.Next
|
|
|
|
#define exop word.what.Exop
|
|
|
|
#define bits word.what.Bits
|
|
|
|
|
|
|
|
/* inflate codes private state */
|
|
|
|
struct inflate_codes_state {
|
|
|
|
|
|
|
|
/* mode */
|
|
|
|
enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
|
|
|
|
START, /* x: set up for LEN */
|
|
|
|
LEN, /* i: get length/literal/eob next */
|
|
|
|
LENEXT, /* i: getting length extra (have base) */
|
|
|
|
DIST, /* i: get distance next */
|
|
|
|
DISTEXT, /* i: getting distance extra */
|
|
|
|
COPY, /* o: copying bytes in window, waiting for space */
|
|
|
|
LIT, /* o: got literal, waiting for output space */
|
|
|
|
WASH, /* o: got eob, possibly still output waiting */
|
|
|
|
END, /* x: got eob and all data flushed */
|
|
|
|
BADCODE} /* x: got error */
|
|
|
|
mode; /* current inflate_codes mode */
|
|
|
|
|
|
|
|
/* mode dependent information */
|
|
|
|
uInt len;
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
inflate_huft *tree; /* pointer into tree */
|
|
|
|
uInt need; /* bits needed */
|
|
|
|
} code; /* if LEN or DIST, where in tree */
|
|
|
|
uInt lit; /* if LIT, literal */
|
|
|
|
struct {
|
|
|
|
uInt get; /* bits to get for extra */
|
|
|
|
uInt dist; /* distance back to copy from */
|
|
|
|
} copy; /* if EXT or COPY, where and how much */
|
|
|
|
} sub; /* submode */
|
|
|
|
|
|
|
|
/* mode independent information */
|
|
|
|
Byte lbits; /* ltree bits decoded per branch */
|
|
|
|
Byte dbits; /* dtree bits decoder per branch */
|
|
|
|
inflate_huft *ltree; /* literal/length/eob tree */
|
|
|
|
inflate_huft *dtree; /* distance tree */
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z)
|
1997-08-19 14:10:50 +00:00
|
|
|
uInt bl, bd;
|
1998-03-21 20:56:16 +00:00
|
|
|
inflate_huft *tl;
|
|
|
|
inflate_huft *td; /* need separate declaration for Borland C++ */
|
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
inflate_codes_statef *c;
|
|
|
|
|
|
|
|
if ((c = (inflate_codes_statef *)
|
|
|
|
ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)
|
|
|
|
{
|
|
|
|
c->mode = START;
|
|
|
|
c->lbits = (Byte)bl;
|
|
|
|
c->dbits = (Byte)bd;
|
|
|
|
c->ltree = tl;
|
|
|
|
c->dtree = td;
|
|
|
|
Tracev((stderr, "inflate: codes new\n"));
|
|
|
|
}
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_codes(s, z, r)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
int r;
|
|
|
|
{
|
|
|
|
uInt j; /* temporary storage */
|
|
|
|
inflate_huft *t; /* temporary pointer */
|
|
|
|
uInt e; /* extra bits or operation */
|
|
|
|
uLong b; /* bit buffer */
|
|
|
|
uInt k; /* bits in bit buffer */
|
|
|
|
Bytef *p; /* input data pointer */
|
|
|
|
uInt n; /* bytes available there */
|
|
|
|
Bytef *q; /* output window write pointer */
|
|
|
|
uInt m; /* bytes to end of window or read pointer */
|
|
|
|
Bytef *f; /* pointer to copy strings from */
|
|
|
|
inflate_codes_statef *c = s->sub.decode.codes; /* codes state */
|
|
|
|
|
|
|
|
/* copy input/output information to locals (UPDATE macro restores) */
|
|
|
|
LOAD
|
|
|
|
|
|
|
|
/* process input and output based on current state */
|
|
|
|
while (1) switch (c->mode)
|
|
|
|
{ /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
|
|
|
|
case START: /* x: set up for LEN */
|
|
|
|
#ifndef SLOW
|
|
|
|
if (m >= 258 && n >= 10)
|
|
|
|
{
|
|
|
|
UPDATE
|
|
|
|
r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
|
|
|
|
LOAD
|
|
|
|
if (r != Z_OK)
|
|
|
|
{
|
|
|
|
c->mode = r == Z_STREAM_END ? WASH : BADCODE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* !SLOW */
|
|
|
|
c->sub.code.need = c->lbits;
|
|
|
|
c->sub.code.tree = c->ltree;
|
|
|
|
c->mode = LEN;
|
|
|
|
case LEN: /* i: get length/literal/eob next */
|
|
|
|
j = c->sub.code.need;
|
|
|
|
NEEDBITS(j)
|
|
|
|
t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
|
|
|
|
DUMPBITS(t->bits)
|
|
|
|
e = (uInt)(t->exop);
|
|
|
|
if (e == 0) /* literal */
|
|
|
|
{
|
|
|
|
c->sub.lit = t->base;
|
|
|
|
Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
|
|
|
|
"inflate: literal '%c'\n" :
|
|
|
|
"inflate: literal 0x%02x\n", t->base));
|
|
|
|
c->mode = LIT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (e & 16) /* length */
|
|
|
|
{
|
|
|
|
c->sub.copy.get = e & 15;
|
|
|
|
c->len = t->base;
|
|
|
|
c->mode = LENEXT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((e & 64) == 0) /* next table */
|
|
|
|
{
|
|
|
|
c->sub.code.need = e;
|
|
|
|
c->sub.code.tree = t->next;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (e & 32) /* end of block */
|
|
|
|
{
|
|
|
|
Tracevv((stderr, "inflate: end of block\n"));
|
|
|
|
c->mode = WASH;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
c->mode = BADCODE; /* invalid code */
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid literal/length code";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
case LENEXT: /* i: getting length extra (have base) */
|
|
|
|
j = c->sub.copy.get;
|
|
|
|
NEEDBITS(j)
|
|
|
|
c->len += (uInt)b & inflate_mask[j];
|
|
|
|
DUMPBITS(j)
|
|
|
|
c->sub.code.need = c->dbits;
|
|
|
|
c->sub.code.tree = c->dtree;
|
|
|
|
Tracevv((stderr, "inflate: length %u\n", c->len));
|
|
|
|
c->mode = DIST;
|
|
|
|
case DIST: /* i: get distance next */
|
|
|
|
j = c->sub.code.need;
|
|
|
|
NEEDBITS(j)
|
|
|
|
t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
|
|
|
|
DUMPBITS(t->bits)
|
|
|
|
e = (uInt)(t->exop);
|
|
|
|
if (e & 16) /* distance */
|
|
|
|
{
|
|
|
|
c->sub.copy.get = e & 15;
|
|
|
|
c->sub.copy.dist = t->base;
|
|
|
|
c->mode = DISTEXT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((e & 64) == 0) /* next table */
|
|
|
|
{
|
|
|
|
c->sub.code.need = e;
|
|
|
|
c->sub.code.tree = t->next;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
c->mode = BADCODE; /* invalid code */
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid distance code";
|
1997-08-19 14:10:50 +00:00
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
case DISTEXT: /* i: getting distance extra */
|
|
|
|
j = c->sub.copy.get;
|
|
|
|
NEEDBITS(j)
|
|
|
|
c->sub.copy.dist += (uInt)b & inflate_mask[j];
|
|
|
|
DUMPBITS(j)
|
|
|
|
Tracevv((stderr, "inflate: distance %u\n", c->sub.copy.dist));
|
|
|
|
c->mode = COPY;
|
|
|
|
case COPY: /* o: copying bytes in window, waiting for space */
|
|
|
|
#ifndef __TURBOC__ /* Turbo C bug for following expression */
|
|
|
|
f = (uInt)(q - s->window) < c->sub.copy.dist ?
|
|
|
|
s->end - (c->sub.copy.dist - (q - s->window)) :
|
|
|
|
q - c->sub.copy.dist;
|
|
|
|
#else
|
|
|
|
f = q - c->sub.copy.dist;
|
|
|
|
if ((uInt)(q - s->window) < c->sub.copy.dist)
|
1998-03-21 20:56:16 +00:00
|
|
|
f = s->end - (c->sub.copy.dist - (uInt)(q - s->window));
|
1997-08-19 14:10:50 +00:00
|
|
|
#endif
|
|
|
|
while (c->len)
|
|
|
|
{
|
|
|
|
NEEDOUT
|
|
|
|
OUTBYTE(*f++)
|
|
|
|
if (f == s->end)
|
|
|
|
f = s->window;
|
|
|
|
c->len--;
|
|
|
|
}
|
|
|
|
c->mode = START;
|
|
|
|
break;
|
|
|
|
case LIT: /* o: got literal, waiting for output space */
|
|
|
|
NEEDOUT
|
|
|
|
OUTBYTE(c->sub.lit)
|
|
|
|
c->mode = START;
|
|
|
|
break;
|
|
|
|
case WASH: /* o: got eob, possibly more output */
|
|
|
|
FLUSH
|
|
|
|
if (s->read != s->write)
|
|
|
|
LEAVE
|
|
|
|
c->mode = END;
|
|
|
|
case END:
|
|
|
|
r = Z_STREAM_END;
|
|
|
|
LEAVE
|
|
|
|
case BADCODE: /* x: got error */
|
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
LEAVE
|
|
|
|
default:
|
|
|
|
r = Z_STREAM_ERROR;
|
|
|
|
LEAVE
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
void inflate_codes_free(c, z)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_codes_statef *c;
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
ZFREE(z, c);
|
1997-08-19 14:10:50 +00:00
|
|
|
Tracev((stderr, "inflate: codes free\n"));
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- infcodes.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ infutil.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* inflate_util.c -- data and routines common to blocks and codes
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* #include "zutil.h" */
|
|
|
|
/* #include "infblock.h" */
|
|
|
|
/* #include "inftrees.h" */
|
|
|
|
/* #include "infcodes.h" */
|
|
|
|
/* #include "infutil.h" */
|
|
|
|
|
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct inflate_codes_state {int dummy;}; /* for buggy compilers */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* And'ing with mask[n] masks the lower n bits */
|
|
|
|
uInt inflate_mask[17] = {
|
|
|
|
0x0000,
|
|
|
|
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
|
|
|
|
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
|
|
|
|
};
|
|
|
|
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* copy as much as possible from the sliding window to the output area */
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_flush(s, z, r)
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
int r;
|
|
|
|
{
|
|
|
|
uInt n;
|
1998-03-21 20:56:16 +00:00
|
|
|
Bytef *p;
|
|
|
|
Bytef *q;
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* local copies of source and destination pointers */
|
|
|
|
p = z->next_out;
|
|
|
|
q = s->read;
|
|
|
|
|
|
|
|
/* compute number of bytes to copy as far as end of window */
|
|
|
|
n = (uInt)((q <= s->write ? s->write : s->end) - q);
|
|
|
|
if (n > z->avail_out) n = z->avail_out;
|
|
|
|
if (n && r == Z_BUF_ERROR) r = Z_OK;
|
|
|
|
|
|
|
|
/* update counters */
|
|
|
|
z->avail_out -= n;
|
|
|
|
z->total_out += n;
|
|
|
|
|
|
|
|
/* update check information */
|
|
|
|
if (s->checkfn != Z_NULL)
|
1998-03-21 20:56:16 +00:00
|
|
|
z->adler = s->check = (*s->checkfn)(s->check, q, n);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* copy as far as end of window */
|
1998-03-21 20:56:16 +00:00
|
|
|
if (p != Z_NULL) {
|
1997-08-19 14:10:50 +00:00
|
|
|
zmemcpy(p, q, n);
|
|
|
|
p += n;
|
|
|
|
}
|
|
|
|
q += n;
|
|
|
|
|
|
|
|
/* see if more to copy at beginning of window */
|
|
|
|
if (q == s->end)
|
|
|
|
{
|
|
|
|
/* wrap pointers */
|
|
|
|
q = s->window;
|
|
|
|
if (s->write == s->end)
|
|
|
|
s->write = s->window;
|
|
|
|
|
|
|
|
/* compute bytes to copy */
|
|
|
|
n = (uInt)(s->write - q);
|
|
|
|
if (n > z->avail_out) n = z->avail_out;
|
|
|
|
if (n && r == Z_BUF_ERROR) r = Z_OK;
|
|
|
|
|
|
|
|
/* update counters */
|
|
|
|
z->avail_out -= n;
|
|
|
|
z->total_out += n;
|
|
|
|
|
|
|
|
/* update check information */
|
|
|
|
if (s->checkfn != Z_NULL)
|
1998-03-21 20:56:16 +00:00
|
|
|
z->adler = s->check = (*s->checkfn)(s->check, q, n);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* copy */
|
1998-03-21 20:56:16 +00:00
|
|
|
if (p != Z_NULL) {
|
1997-08-19 14:10:50 +00:00
|
|
|
zmemcpy(p, q, n);
|
|
|
|
p += n;
|
|
|
|
}
|
|
|
|
q += n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update pointers */
|
|
|
|
z->next_out = p;
|
|
|
|
s->read = q;
|
|
|
|
|
|
|
|
/* done */
|
|
|
|
return r;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- infutil.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ inffast.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* inffast.c -- process literals and length/distance pairs fast
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* #include "zutil.h" */
|
|
|
|
/* #include "inftrees.h" */
|
|
|
|
/* #include "infblock.h" */
|
|
|
|
/* #include "infcodes.h" */
|
|
|
|
/* #include "infutil.h" */
|
|
|
|
/* #include "inffast.h" */
|
|
|
|
|
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct inflate_codes_state {int dummy;}; /* for buggy compilers */
|
|
|
|
#endif
|
|
|
|
|
1997-08-19 14:10:50 +00:00
|
|
|
/* simplify the use of the inflate_huft type with some defines */
|
|
|
|
#define base more.Base
|
|
|
|
#define next more.Next
|
|
|
|
#define exop word.what.Exop
|
|
|
|
#define bits word.what.Bits
|
|
|
|
|
|
|
|
/* macros for bit input with no checking and for returning unused bytes */
|
|
|
|
#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}}
|
|
|
|
#define UNGRAB {n+=(c=k>>3);p-=c;k&=7;}
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
int inflate_fast(bl, bd, tl, td, s, z)
|
1997-08-19 14:10:50 +00:00
|
|
|
uInt bl, bd;
|
1998-03-21 20:56:16 +00:00
|
|
|
inflate_huft *tl;
|
|
|
|
inflate_huft *td; /* need separate declaration for Borland C++ */
|
1997-08-19 14:10:50 +00:00
|
|
|
inflate_blocks_statef *s;
|
1998-03-21 20:56:16 +00:00
|
|
|
z_streamp z;
|
1997-08-19 14:10:50 +00:00
|
|
|
{
|
|
|
|
inflate_huft *t; /* temporary pointer */
|
|
|
|
uInt e; /* extra bits or operation */
|
|
|
|
uLong b; /* bit buffer */
|
|
|
|
uInt k; /* bits in bit buffer */
|
|
|
|
Bytef *p; /* input data pointer */
|
|
|
|
uInt n; /* bytes available there */
|
|
|
|
Bytef *q; /* output window write pointer */
|
|
|
|
uInt m; /* bytes to end of window or read pointer */
|
|
|
|
uInt ml; /* mask for literal/length tree */
|
|
|
|
uInt md; /* mask for distance tree */
|
|
|
|
uInt c; /* bytes to copy */
|
|
|
|
uInt d; /* distance back to copy from */
|
|
|
|
Bytef *r; /* copy source pointer */
|
|
|
|
|
|
|
|
/* load input, output, bit values */
|
|
|
|
LOAD
|
|
|
|
|
|
|
|
/* 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 */
|
|
|
|
GRABBITS(20) /* max bits for literal/length code */
|
|
|
|
if ((e = (t = tl + ((uInt)b & ml))->exop) == 0)
|
|
|
|
{
|
|
|
|
DUMPBITS(t->bits)
|
|
|
|
Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
|
|
|
|
"inflate: * literal '%c'\n" :
|
|
|
|
"inflate: * literal 0x%02x\n", t->base));
|
|
|
|
*q++ = (Byte)t->base;
|
|
|
|
m--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
do {
|
|
|
|
DUMPBITS(t->bits)
|
|
|
|
if (e & 16)
|
|
|
|
{
|
|
|
|
/* get extra bits for length */
|
|
|
|
e &= 15;
|
|
|
|
c = t->base + ((uInt)b & inflate_mask[e]);
|
|
|
|
DUMPBITS(e)
|
|
|
|
Tracevv((stderr, "inflate: * length %u\n", c));
|
|
|
|
|
|
|
|
/* decode distance base of block to copy */
|
|
|
|
GRABBITS(15); /* max bits for distance code */
|
|
|
|
e = (t = td + ((uInt)b & md))->exop;
|
|
|
|
do {
|
|
|
|
DUMPBITS(t->bits)
|
|
|
|
if (e & 16)
|
|
|
|
{
|
|
|
|
/* get extra bits to add to distance base */
|
|
|
|
e &= 15;
|
|
|
|
GRABBITS(e) /* get extra bits (up to 13) */
|
|
|
|
d = t->base + ((uInt)b & inflate_mask[e]);
|
|
|
|
DUMPBITS(e)
|
|
|
|
Tracevv((stderr, "inflate: * distance %u\n", d));
|
|
|
|
|
|
|
|
/* do the copy */
|
|
|
|
m -= c;
|
|
|
|
if ((uInt)(q - s->window) >= d) /* offset before dest */
|
|
|
|
{ /* just copy */
|
|
|
|
r = q - d;
|
|
|
|
*q++ = *r++; c--; /* minimum count is three, */
|
|
|
|
*q++ = *r++; c--; /* so unroll loop a little */
|
|
|
|
}
|
|
|
|
else /* else offset after destination */
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
e = d - (uInt)(q - s->window); /* bytes from offset to end */
|
1997-08-19 14:10:50 +00:00
|
|
|
r = s->end - e; /* pointer to offset */
|
|
|
|
if (c > e) /* if source crosses, */
|
|
|
|
{
|
|
|
|
c -= e; /* copy to end of window */
|
|
|
|
do {
|
|
|
|
*q++ = *r++;
|
|
|
|
} while (--e);
|
|
|
|
r = s->window; /* copy rest from start of window */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
do { /* copy all or what's left */
|
|
|
|
*q++ = *r++;
|
|
|
|
} while (--c);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if ((e & 64) == 0)
|
|
|
|
e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop;
|
|
|
|
else
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid distance code";
|
1997-08-19 14:10:50 +00:00
|
|
|
UNGRAB
|
|
|
|
UPDATE
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
}
|
|
|
|
} while (1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((e & 64) == 0)
|
|
|
|
{
|
|
|
|
if ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) == 0)
|
|
|
|
{
|
|
|
|
DUMPBITS(t->bits)
|
|
|
|
Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
|
|
|
|
"inflate: * literal '%c'\n" :
|
|
|
|
"inflate: * literal 0x%02x\n", t->base));
|
|
|
|
*q++ = (Byte)t->base;
|
|
|
|
m--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (e & 32)
|
|
|
|
{
|
|
|
|
Tracevv((stderr, "inflate: * end of block\n"));
|
|
|
|
UNGRAB
|
|
|
|
UPDATE
|
|
|
|
return Z_STREAM_END;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1998-03-21 20:56:16 +00:00
|
|
|
z->msg = (char*)"invalid literal/length code";
|
1997-08-19 14:10:50 +00:00
|
|
|
UNGRAB
|
|
|
|
UPDATE
|
|
|
|
return Z_DATA_ERROR;
|
|
|
|
}
|
|
|
|
} while (1);
|
|
|
|
} while (m >= 258 && n >= 10);
|
|
|
|
|
|
|
|
/* not enough input or output--restore pointers and return */
|
|
|
|
UNGRAB
|
|
|
|
UPDATE
|
|
|
|
return Z_OK;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- inffast.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* +++ zutil.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* zutil.c -- target dependent utility functions for the compression library
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Jean-loup Gailly.
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* From: zutil.c,v 1.17 1996/07/24 13:41:12 me Exp $ */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
#include <stdio.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* #include "zutil.h" */
|
|
|
|
|
|
|
|
#ifndef NO_DUMMY_DECL
|
|
|
|
struct internal_state {int dummy;}; /* for buggy compilers */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef STDC
|
|
|
|
extern void exit OF((int));
|
|
|
|
#endif
|
1997-08-19 14:10:50 +00:00
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
static const char *z_errmsg[10] = {
|
|
|
|
"need dictionary", /* Z_NEED_DICT 2 */
|
|
|
|
"stream end", /* Z_STREAM_END 1 */
|
|
|
|
"", /* Z_OK 0 */
|
|
|
|
"file error", /* Z_ERRNO (-1) */
|
|
|
|
"stream error", /* Z_STREAM_ERROR (-2) */
|
|
|
|
"data error", /* Z_DATA_ERROR (-3) */
|
|
|
|
"insufficient memory", /* Z_MEM_ERROR (-4) */
|
|
|
|
"buffer error", /* Z_BUF_ERROR (-5) */
|
|
|
|
"incompatible version",/* Z_VERSION_ERROR (-6) */
|
1997-08-19 14:10:50 +00:00
|
|
|
""};
|
|
|
|
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
const char *zlibVersion()
|
|
|
|
{
|
|
|
|
return ZLIB_VERSION;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG_ZLIB
|
|
|
|
void z_error (m)
|
|
|
|
char *m;
|
|
|
|
{
|
|
|
|
fprintf(stderr, "%s\n", m);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef HAVE_MEMCPY
|
|
|
|
|
|
|
|
void zmemcpy(dest, source, len)
|
|
|
|
Bytef* dest;
|
|
|
|
Bytef* source;
|
|
|
|
uInt len;
|
|
|
|
{
|
|
|
|
if (len == 0) return;
|
|
|
|
do {
|
|
|
|
*dest++ = *source++; /* ??? to be unrolled */
|
|
|
|
} while (--len != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int zmemcmp(s1, s2, len)
|
|
|
|
Bytef* s1;
|
|
|
|
Bytef* s2;
|
|
|
|
uInt len;
|
|
|
|
{
|
|
|
|
uInt j;
|
|
|
|
|
|
|
|
for (j = 0; j < len; j++) {
|
|
|
|
if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void zmemzero(dest, len)
|
|
|
|
Bytef* dest;
|
|
|
|
uInt len;
|
|
|
|
{
|
|
|
|
if (len == 0) return;
|
|
|
|
do {
|
|
|
|
*dest++ = 0; /* ??? to be unrolled */
|
|
|
|
} while (--len != 0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef __TURBOC__
|
|
|
|
#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
|
|
|
|
/* Small and medium model in Turbo C are for now limited to near allocation
|
|
|
|
* with reduced MAX_WBITS and MAX_MEM_LEVEL
|
|
|
|
*/
|
|
|
|
# define MY_ZCALLOC
|
|
|
|
|
|
|
|
/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
|
|
|
|
* and farmalloc(64K) returns a pointer with an offset of 8, so we
|
|
|
|
* must fix the pointer. Warning: the pointer must be put back to its
|
|
|
|
* original form in order to free it, use zcfree().
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define MAX_PTR 10
|
|
|
|
/* 10*64K = 640K */
|
|
|
|
|
|
|
|
local int next_ptr = 0;
|
|
|
|
|
|
|
|
typedef struct ptr_table_s {
|
|
|
|
voidpf org_ptr;
|
|
|
|
voidpf new_ptr;
|
|
|
|
} ptr_table;
|
|
|
|
|
|
|
|
local ptr_table table[MAX_PTR];
|
|
|
|
/* This table is used to remember the original form of pointers
|
|
|
|
* to large buffers (64K). Such pointers are normalized with a zero offset.
|
|
|
|
* Since MSDOS is not a preemptive multitasking OS, this table is not
|
|
|
|
* protected from concurrent access. This hack doesn't work anyway on
|
|
|
|
* a protected system like OS/2. Use Microsoft C instead.
|
|
|
|
*/
|
|
|
|
|
|
|
|
voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
|
|
|
|
{
|
|
|
|
voidpf buf = opaque; /* just to make some compilers happy */
|
|
|
|
ulg bsize = (ulg)items*size;
|
|
|
|
|
|
|
|
/* If we allocate less than 65520 bytes, we assume that farmalloc
|
|
|
|
* will return a usable pointer which doesn't have to be normalized.
|
|
|
|
*/
|
|
|
|
if (bsize < 65520L) {
|
|
|
|
buf = farmalloc(bsize);
|
|
|
|
if (*(ush*)&buf != 0) return buf;
|
|
|
|
} else {
|
|
|
|
buf = farmalloc(bsize + 16L);
|
|
|
|
}
|
|
|
|
if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
|
|
|
|
table[next_ptr].org_ptr = buf;
|
|
|
|
|
|
|
|
/* Normalize the pointer to seg:0 */
|
|
|
|
*((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
|
|
|
|
*(ush*)&buf = 0;
|
|
|
|
table[next_ptr++].new_ptr = buf;
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
void zcfree (voidpf opaque, voidpf ptr)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
if (*(ush*)&ptr != 0) { /* object < 64K */
|
|
|
|
farfree(ptr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Find the original pointer */
|
|
|
|
for (n = 0; n < next_ptr; n++) {
|
|
|
|
if (ptr != table[n].new_ptr) continue;
|
|
|
|
|
|
|
|
farfree(table[n].org_ptr);
|
|
|
|
while (++n < next_ptr) {
|
|
|
|
table[n-1] = table[n];
|
|
|
|
}
|
|
|
|
next_ptr--;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ptr = opaque; /* just to make some compilers happy */
|
|
|
|
Assert(0, "zcfree: ptr not found");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* __TURBOC__ */
|
|
|
|
|
|
|
|
|
|
|
|
#if defined(M_I86) && !defined(__32BIT__)
|
|
|
|
/* Microsoft C in 16-bit mode */
|
|
|
|
|
|
|
|
# define MY_ZCALLOC
|
|
|
|
|
|
|
|
#if (!defined(_MSC_VER) || (_MSC_VER < 600))
|
|
|
|
# define _halloc halloc
|
|
|
|
# define _hfree hfree
|
|
|
|
#endif
|
|
|
|
|
|
|
|
voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
|
|
|
|
{
|
|
|
|
if (opaque) opaque = 0; /* to make compiler happy */
|
|
|
|
return _halloc((long)items, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void zcfree (voidpf opaque, voidpf ptr)
|
|
|
|
{
|
|
|
|
if (opaque) opaque = 0; /* to make compiler happy */
|
|
|
|
_hfree(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* MSC */
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef MY_ZCALLOC /* Any system without a special alloc function */
|
|
|
|
|
|
|
|
#ifndef STDC
|
|
|
|
extern voidp calloc OF((uInt items, uInt size));
|
|
|
|
extern void free OF((voidpf ptr));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
voidpf zcalloc (opaque, items, size)
|
|
|
|
voidpf opaque;
|
|
|
|
unsigned items;
|
|
|
|
unsigned size;
|
|
|
|
{
|
|
|
|
if (opaque) items += size - size; /* make compiler happy */
|
|
|
|
return (voidpf)calloc(items, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void zcfree (opaque, ptr)
|
|
|
|
voidpf opaque;
|
|
|
|
voidpf ptr;
|
|
|
|
{
|
|
|
|
free(ptr);
|
|
|
|
if (opaque) return; /* make compiler happy */
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* MY_ZCALLOC */
|
|
|
|
/* --- zutil.c */
|
|
|
|
|
|
|
|
/* +++ adler32.c */
|
1997-08-19 14:10:50 +00:00
|
|
|
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
1998-03-21 20:56:16 +00:00
|
|
|
* Copyright (C) 1995-1996 Mark Adler
|
1997-08-19 14:10:50 +00:00
|
|
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
|
|
*/
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
/* From: adler32.c,v 1.10 1996/05/22 11:52:18 me Exp $ */
|
|
|
|
|
|
|
|
/* #include "zlib.h" */
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
#define BASE 65521L /* largest prime smaller than 65536 */
|
|
|
|
#define NMAX 5552
|
|
|
|
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
|
|
|
|
|
1998-03-21 20:56:16 +00:00
|
|
|
#define DO1(buf,i) {s1 += buf[i]; s2 += s1;}
|
|
|
|
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
|
|
|
|
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
|
|
|
|
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
|
|
|
|
#define DO16(buf) DO8(buf,0); DO8(buf,8);
|
1997-08-19 14:10:50 +00:00
|
|
|
|
|
|
|
/* ========================================================================= */
|
|
|
|
uLong adler32(adler, buf, len)
|
|
|
|
uLong adler;
|
1998-03-21 20:56:16 +00:00
|
|
|
const Bytef *buf;
|
1997-08-19 14:10:50 +00:00
|
|
|
uInt len;
|
|
|
|
{
|
|
|
|
unsigned long s1 = adler & 0xffff;
|
|
|
|
unsigned long s2 = (adler >> 16) & 0xffff;
|
|
|
|
int k;
|
|
|
|
|
|
|
|
if (buf == Z_NULL) return 1L;
|
|
|
|
|
|
|
|
while (len > 0) {
|
|
|
|
k = len < NMAX ? len : NMAX;
|
|
|
|
len -= k;
|
|
|
|
while (k >= 16) {
|
|
|
|
DO16(buf);
|
1998-03-21 20:56:16 +00:00
|
|
|
buf += 16;
|
1997-08-19 14:10:50 +00:00
|
|
|
k -= 16;
|
|
|
|
}
|
|
|
|
if (k != 0) do {
|
1998-03-21 20:56:16 +00:00
|
|
|
s1 += *buf++;
|
|
|
|
s2 += s1;
|
1997-08-19 14:10:50 +00:00
|
|
|
} while (--k);
|
|
|
|
s1 %= BASE;
|
|
|
|
s2 %= BASE;
|
|
|
|
}
|
|
|
|
return (s2 << 16) | s1;
|
|
|
|
}
|
1998-03-21 20:56:16 +00:00
|
|
|
/* --- adler32.c */
|