mszipd.c File Reference

#include <system.h>
#include <mszip.h>
#include <readbits.h>
#include <readhuff.h>

Go to the source code of this file.

Macros
#define	BITS_TYPE   struct mszipd_stream
#define	BITS_VAR   zip
#define	BITS_ORDER_LSB
#define	BITS_LSB_TABLE
#define	READ_BYTES
#define	TABLEBITS(tbl)   MSZIP_##tbl##_TABLEBITS
#define	MAXSYMBOLS(tbl)   MSZIP_##tbl##_MAXSYMBOLS
#define	HUFF_TABLE(tbl, idx)   zip->tbl##_table[idx]
#define	HUFF_LEN(tbl, idx)   zip->tbl##_len[idx]
#define	HUFF_ERROR   return INF_ERR_HUFFSYM
#define	FLUSH_IF_NEEDED
#define	INF_ERR_BLOCKTYPE   (-1) /* unknown block type */
#define	INF_ERR_COMPLEMENT   (-2) /* block size complement mismatch */
#define	INF_ERR_FLUSH   (-3) /* error from flush_window() callback */
#define	INF_ERR_BITBUF   (-4) /* too many bits in bit buffer */
#define	INF_ERR_SYMLENS   (-5) /* too many symbols in blocktype 2 header */
#define	INF_ERR_BITLENTBL   (-6) /* failed to build bitlens huffman table */
#define	INF_ERR_LITERALTBL   (-7) /* failed to build literals huffman table */
#define	INF_ERR_DISTANCETBL   (-8) /* failed to build distance huffman table */
#define	INF_ERR_BITOVERRUN   (-9) /* bitlen RLE code goes over table size */
#define	INF_ERR_BADBITLEN   (-10) /* invalid bit-length code */
#define	INF_ERR_LITCODE   (-11) /* out-of-range literal code */
#define	INF_ERR_DISTCODE   (-12) /* out-of-range distance code */
#define	INF_ERR_DISTANCE   (-13) /* somehow, distance is beyond 32k */
#define	INF_ERR_HUFFSYM   (-14) /* out of bits decoding huffman symbol */

Functions
static int	zip_read_lens (struct mszipd_stream *zip)
static int	inflate (struct mszipd_stream *zip)
static int	mszipd_flush_window (struct mszipd_stream *zip, unsigned int data_flushed)
struct mszipd_stream *	mszipd_init (struct mspack_system *system, struct mspack_file *input, struct mspack_file *output, int input_buffer_size, int repair_mode)
int	mszipd_decompress (struct mszipd_stream *zip, off_t out_bytes)
int	mszipd_decompress_kwaj (struct mszipd_stream *zip)
void	mszipd_free (struct mszipd_stream *zip)

Variables
static const unsigned short	lit_lengths [29]
static const unsigned short	dist_offsets [30]
static const unsigned char	lit_extrabits [29]
static const unsigned char	dist_extrabits [30]
static const unsigned char	bitlen_order [19]

Macro Definition Documentation

BITS_LSB_TABLE

#define BITS_LSB_TABLE

Definition at line 22 of file mszipd.c.

BITS_ORDER_LSB

#define BITS_ORDER_LSB

Definition at line 21 of file mszipd.c.

BITS_TYPE

#define BITS_TYPE   struct mszipd_stream

Definition at line 19 of file mszipd.c.

BITS_VAR

#define BITS_VAR   zip

Definition at line 20 of file mszipd.c.

FLUSH_IF_NEEDED

#define FLUSH_IF_NEEDED

Value:

    do {                            \
    if (zip->window_posn == MSZIP_FRAME_SIZE) {         \
        if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) { \
            return INF_ERR_FLUSH;                       \
        }                                               \
        zip->window_posn = 0;                           \
    }                                                   \
} while (0)

Definition at line 37 of file mszipd.c.

HUFF_ERROR

#define HUFF_ERROR   return INF_ERR_HUFFSYM

Definition at line 34 of file mszipd.c.

HUFF_LEN

#define HUFF_LEN	(		tbl,
			idx
	)		zip->tbl##_len[idx]

Definition at line 33 of file mszipd.c.

HUFF_TABLE

#define HUFF_TABLE	(		tbl,
			idx
	)		zip->tbl##_table[idx]

Definition at line 32 of file mszipd.c.

INF_ERR_BADBITLEN

#define INF_ERR_BADBITLEN   (-10) /* invalid bit-length code */

Definition at line 85 of file mszipd.c.

INF_ERR_BITBUF

#define INF_ERR_BITBUF   (-4) /* too many bits in bit buffer */

Definition at line 79 of file mszipd.c.

INF_ERR_BITLENTBL

#define INF_ERR_BITLENTBL   (-6) /* failed to build bitlens huffman table */

Definition at line 81 of file mszipd.c.

INF_ERR_BITOVERRUN

#define INF_ERR_BITOVERRUN   (-9) /* bitlen RLE code goes over table size */

Definition at line 84 of file mszipd.c.

INF_ERR_BLOCKTYPE

#define INF_ERR_BLOCKTYPE   (-1) /* unknown block type */

Definition at line 76 of file mszipd.c.

INF_ERR_COMPLEMENT

#define INF_ERR_COMPLEMENT   (-2) /* block size complement mismatch */

Definition at line 77 of file mszipd.c.

INF_ERR_DISTANCE

#define INF_ERR_DISTANCE   (-13) /* somehow, distance is beyond 32k */

Definition at line 88 of file mszipd.c.

INF_ERR_DISTANCETBL

#define INF_ERR_DISTANCETBL   (-8) /* failed to build distance huffman table */

Definition at line 83 of file mszipd.c.

INF_ERR_DISTCODE

#define INF_ERR_DISTCODE   (-12) /* out-of-range distance code */

Definition at line 87 of file mszipd.c.

INF_ERR_FLUSH

#define INF_ERR_FLUSH   (-3) /* error from flush_window() callback */

Definition at line 78 of file mszipd.c.

INF_ERR_HUFFSYM

#define INF_ERR_HUFFSYM   (-14) /* out of bits decoding huffman symbol */

Definition at line 89 of file mszipd.c.

INF_ERR_LITCODE

#define INF_ERR_LITCODE   (-11) /* out-of-range literal code */

Definition at line 86 of file mszipd.c.

INF_ERR_LITERALTBL

#define INF_ERR_LITERALTBL   (-7) /* failed to build literals huffman table */

Definition at line 82 of file mszipd.c.

INF_ERR_SYMLENS

#define INF_ERR_SYMLENS   (-5) /* too many symbols in blocktype 2 header */

Definition at line 80 of file mszipd.c.

MAXSYMBOLS

#define MAXSYMBOLS

(

tbl

)

MSZIP_##tbl##_MAXSYMBOLS

Definition at line 31 of file mszipd.c.

READ_BYTES

#define READ_BYTES

Value:

    do {         \
    READ_IF_NEEDED;             \
    INJECT_BITS(*i_ptr++, 8);   \
} while (0)

Definition at line 23 of file mszipd.c.

TABLEBITS

#define TABLEBITS

(

tbl

)

MSZIP_##tbl##_TABLEBITS

Definition at line 30 of file mszipd.c.

Function Documentation

inflate()

static int inflate ( struct mszipd_stream *  zip )

static

Definition at line 157 of file mszipd.c.

                                              {
  unsigned int last_block, block_type, distance, length, this_run, i;
 
  /* for the bit buffer and huffman decoding */
  register unsigned int bit_buffer;
  register int bits_left;
  register unsigned short sym;
  unsigned char *i_ptr, *i_end;
 
  RESTORE_BITS;
 
  do {
    /* read in last block bit */
    READ_BITS(last_block, 1);
 
    /* read in block type */
    READ_BITS(block_type, 2);
 
    if (block_type == 0) {
      /* uncompressed block */
      unsigned char lens_buf[4];
 
      /* go to byte boundary */
      i = bits_left & 7; REMOVE_BITS(i);
 
      /* read 4 bytes of data, emptying the bit-buffer if necessary */
      for (i = 0; (bits_left >= 8); i++) {
        if (i == 4) return INF_ERR_BITBUF;
        lens_buf[i] = PEEK_BITS(8);
        REMOVE_BITS(8);
      }
      if (bits_left != 0) return INF_ERR_BITBUF;
      while (i < 4) {
        READ_IF_NEEDED;
        lens_buf[i++] = *i_ptr++;
      }
 
      /* get the length and its complement */
      length = lens_buf[0] | (lens_buf[1] << 8);
      i      = lens_buf[2] | (lens_buf[3] << 8);
      if (length != (~i & 0xFFFF)) return INF_ERR_COMPLEMENT;
 
      /* read and copy the uncompressed data into the window */
      while (length > 0) {
        READ_IF_NEEDED;
 
        this_run = length;
        if (this_run > (unsigned int)(i_end - i_ptr)) this_run = i_end - i_ptr;
        if (this_run > (MSZIP_FRAME_SIZE - zip->window_posn))
          this_run = MSZIP_FRAME_SIZE - zip->window_posn;
 
        zip->sys->copy(i_ptr, &zip->window[zip->window_posn], this_run);
        zip->window_posn += this_run;
        i_ptr    += this_run;
        length   -= this_run;
        FLUSH_IF_NEEDED;
      }
    }
    else if ((block_type == 1) || (block_type == 2)) {
      /* Huffman-compressed LZ77 block */
      unsigned int match_posn, code;
 
      if (block_type == 1) {
        /* block with fixed Huffman codes */
        i = 0;
        while (i < 144) zip->LITERAL_len[i++] = 8;
        while (i < 256) zip->LITERAL_len[i++] = 9;
        while (i < 280) zip->LITERAL_len[i++] = 7;
        while (i < 288) zip->LITERAL_len[i++] = 8;
        for (i = 0; i < 32; i++) zip->DISTANCE_len[i] = 5;
      }
      else {
        /* block with dynamic Huffman codes */
        STORE_BITS;
        if ((i = zip_read_lens(zip))) return i;
        RESTORE_BITS;
      }
 
      /* now huffman lengths are read for either kind of block, 
       * create huffman decoding tables */
      if (make_decode_table(MSZIP_LITERAL_MAXSYMBOLS, MSZIP_LITERAL_TABLEBITS,
                            &zip->LITERAL_len[0], &zip->LITERAL_table[0]))
      {
        return INF_ERR_LITERALTBL;
      }
 
      if (make_decode_table(MSZIP_DISTANCE_MAXSYMBOLS,MSZIP_DISTANCE_TABLEBITS,
                            &zip->DISTANCE_len[0], &zip->DISTANCE_table[0]))
      {
        return INF_ERR_DISTANCETBL;
      }
 
      /* decode forever until end of block code */
      for (;;) {
        READ_HUFFSYM(LITERAL, code);
        if (code < 256) {
          zip->window[zip->window_posn++] = (unsigned char) code;
          FLUSH_IF_NEEDED;
        }
        else if (code == 256) {
          /* END OF BLOCK CODE: loop break point */
          break;
        }
        else {
          code -= 257; /* codes 257-285 are matches */
          if (code >= 29) return INF_ERR_LITCODE; /* codes 286-287 are illegal */
          READ_BITS_T(length, lit_extrabits[code]);
          length += lit_lengths[code];
 
          READ_HUFFSYM(DISTANCE, code);
          if (code >= 30) return INF_ERR_DISTCODE;
          READ_BITS_T(distance, dist_extrabits[code]);
          distance += dist_offsets[code];
 
          /* match position is window position minus distance. If distance
           * is more than window position numerically, it must 'wrap
           * around' the frame size. */ 
          match_posn = ((distance > zip->window_posn) ? MSZIP_FRAME_SIZE : 0)
            + zip->window_posn - distance;
 
          /* copy match */
          if (length < 12) {
            /* short match, use slower loop but no loop setup code */
            while (length--) {
              zip->window[zip->window_posn++] = zip->window[match_posn++];
              match_posn &= MSZIP_FRAME_SIZE - 1;
              FLUSH_IF_NEEDED;
            }
          }
          else {
            /* longer match, use faster loop but with setup expense */
            unsigned char *runsrc, *rundest;
            do {
              this_run = length;
              if ((match_posn + this_run) > MSZIP_FRAME_SIZE)
                this_run = MSZIP_FRAME_SIZE - match_posn;
              if ((zip->window_posn + this_run) > MSZIP_FRAME_SIZE)
                this_run = MSZIP_FRAME_SIZE - zip->window_posn;
 
              rundest = &zip->window[zip->window_posn]; zip->window_posn += this_run;
              runsrc  = &zip->window[match_posn];  match_posn  += this_run;
              length -= this_run;
              while (this_run--) *rundest++ = *runsrc++;
              if (match_posn == MSZIP_FRAME_SIZE) match_posn = 0;
              FLUSH_IF_NEEDED;
            } while (length > 0);
          }
 
        } /* else (code >= 257) */
 
      } /* for(;;) -- break point at 'code == 256' */
    }
    else {
      /* block_type == 3 -- bad block type */
      return INF_ERR_BLOCKTYPE;
    }
  } while (!last_block);
 
  /* flush the remaining data */
  if (zip->window_posn) {
    if (zip->flush_window(zip, zip->window_posn)) return INF_ERR_FLUSH;
  }
  STORE_BITS;
 
  /* return success */
  return 0;
}

References code, dist_extrabits, dist_offsets, FLUSH_IF_NEEDED, i, INF_ERR_BITBUF, INF_ERR_BLOCKTYPE, INF_ERR_COMPLEMENT, INF_ERR_DISTANCETBL, INF_ERR_DISTCODE, INF_ERR_FLUSH, INF_ERR_LITCODE, INF_ERR_LITERALTBL, length, lit_extrabits, lit_lengths, make_decode_table(), MSZIP_DISTANCE_MAXSYMBOLS, MSZIP_DISTANCE_TABLEBITS, MSZIP_FRAME_SIZE, MSZIP_LITERAL_MAXSYMBOLS, MSZIP_LITERAL_TABLEBITS, PEEK_BITS, READ_BITS, READ_HUFFSYM, READ_IF_NEEDED, REMOVE_BITS, RESTORE_BITS, STORE_BITS, while(), and zip_read_lens().

Referenced by mszipd_decompress(), and mszipd_decompress_kwaj().

mszipd_decompress()

int mszipd_decompress	(	struct mszipd_stream *	zip,
		off_t	out_bytes
	)

Definition at line 384 of file mszipd.c.

                                                                  {
  /* for the bit buffer */
  register unsigned int bit_buffer;
  register int bits_left;
  unsigned char *i_ptr, *i_end;
 
  int i, state, error;
 
  /* easy answers */
  if (!zip || (out_bytes < 0)) return MSPACK_ERR_ARGS;
  if (zip->error) return zip->error;
 
  /* flush out any stored-up bytes before we begin */
  i = zip->o_end - zip->o_ptr;
  if ((off_t) i > out_bytes) i = (int) out_bytes;
  if (i) {
    if (zip->sys->write(zip->output, zip->o_ptr, i) != i) {
      return zip->error = MSPACK_ERR_WRITE;
    }
    zip->o_ptr  += i;
    out_bytes   -= i;
  }
  if (out_bytes == 0) return MSPACK_ERR_OK;
 
 
  while (out_bytes > 0) {
    /* unpack another block */
    RESTORE_BITS;
 
    /* skip to next read 'CK' header */
    i = bits_left & 7; REMOVE_BITS(i); /* align to bytestream */
    state = 0;
    do {
      READ_BITS(i, 8);
      if (i == 'C') state = 1;
      else if ((state == 1) && (i == 'K')) state = 2;
      else state = 0;
    } while (state != 2);
 
    /* inflate a block, repair and realign if necessary */
    zip->window_posn = 0;
    zip->bytes_output = 0;
    STORE_BITS;
    if ((error = inflate(zip))) {
      D(("inflate error %d", error))
      if (zip->repair_mode) {
        /* recover partially-inflated buffers */
        if (zip->bytes_output == 0 && zip->window_posn > 0) {
          zip->flush_window(zip, zip->window_posn);
        }
        zip->sys->message(NULL, "MSZIP error, %u bytes of data lost.",
                          MSZIP_FRAME_SIZE - zip->bytes_output);
        for (i = zip->bytes_output; i < MSZIP_FRAME_SIZE; i++) {
          zip->window[i] = '\0';
        }
        zip->bytes_output = MSZIP_FRAME_SIZE;
      }
      else {
        return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
      }
    }
    zip->o_ptr = &zip->window[0];
    zip->o_end = &zip->o_ptr[zip->bytes_output];
 
    /* write a frame */
    i = (out_bytes < (off_t)zip->bytes_output) ?
      (int)out_bytes : zip->bytes_output;
    if (zip->sys->write(zip->output, zip->o_ptr, i) != i) {
      return zip->error = MSPACK_ERR_WRITE;
    }
 
    /* mspack errors (i.e. read errors) are fatal and can't be recovered */
    if ((error > 0) && zip->repair_mode) return error;
 
    zip->o_ptr  += i;
    out_bytes   -= i;
  }
 
  if (out_bytes) {
    D(("bytes left to output"))
    return zip->error = MSPACK_ERR_DECRUNCH;
  }
  return MSPACK_ERR_OK;
}

mszipd_decompress_kwaj()

int mszipd_decompress_kwaj

(

struct mszipd_stream *

zip

)

Definition at line 469 of file mszipd.c.

                                                      {
    /* for the bit buffer */
    register unsigned int bit_buffer;
    register int bits_left;
    unsigned char *i_ptr, *i_end;
 
    int i, error, block_len;
 
    /* unpack blocks until block_len == 0 */
    for (;;) {
        RESTORE_BITS;
 
        /* align to bytestream, read block_len */
        i = bits_left & 7; REMOVE_BITS(i);
        READ_BITS(block_len, 8);
        READ_BITS(i, 8); block_len |= i << 8;
 
        if (block_len == 0) break;
 
        /* read "CK" header */
        READ_BITS(i, 8); if (i != 'C') return MSPACK_ERR_DATAFORMAT;
        READ_BITS(i, 8); if (i != 'K') return MSPACK_ERR_DATAFORMAT;
 
        /* inflate block */
        zip->window_posn = 0;
        zip->bytes_output = 0;
        STORE_BITS;
        if ((error = inflate(zip))) {
            D(("inflate error %d", error))
            return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
        }
 
        /* write inflated block */
        if (zip->sys->write(zip->output, &zip->window[0], zip->bytes_output)
            != zip->bytes_output) return zip->error = MSPACK_ERR_WRITE;
    }
    return MSPACK_ERR_OK;
}

mszipd_flush_window()

static int mszipd_flush_window ( struct mszipd_stream *  zip, unsigned int  data_flushed  )

static

Definition at line 330 of file mszipd.c.

{
  zip->bytes_output += data_flushed;
  if (zip->bytes_output > MSZIP_FRAME_SIZE) {
    D(("overflow: %u bytes flushed, total is now %u",
       data_flushed, zip->bytes_output))
    return 1;
  }
  return 0;
}

References D, and MSZIP_FRAME_SIZE.

Referenced by mszipd_init().

mszipd_free()

void mszipd_free

(

struct mszipd_stream *

zip

)

Definition at line 508 of file mszipd.c.

                                            {
  struct mspack_system *sys;
  if (zip) {
    sys = zip->sys;
    sys->free(zip->inbuf);
    sys->free(zip);
  }
}

mszipd_init()

struct mszipd_stream* mszipd_init	(	struct mspack_system *	system,
		struct mspack_file *	input,
		struct mspack_file *	output,
		int	input_buffer_size,
		int	repair_mode
	)

Definition at line 342 of file mszipd.c.

{
  struct mszipd_stream *zip;
 
  if (!system) return NULL;
 
  /* round up input buffer size to multiple of two */
  input_buffer_size = (input_buffer_size + 1) & -2;
  if (input_buffer_size < 2) return NULL;
 
  /* allocate decompression state */
  if (!(zip = (struct mszipd_stream *) system->alloc(system, sizeof(struct mszipd_stream)))) {
    return NULL;
  }
 
  /* allocate input buffer */
  zip->inbuf  = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
  if (!zip->inbuf) {
    system->free(zip);
    return NULL;
  }
 
  /* initialise decompression state */
  zip->sys             = system;
  zip->input           = input;
  zip->output          = output;
  zip->inbuf_size      = input_buffer_size;
  zip->input_end       = 0;
  zip->error           = MSPACK_ERR_OK;
  zip->repair_mode     = repair_mode;
  zip->flush_window    = &mszipd_flush_window;
 
  zip->i_ptr = zip->i_end = &zip->inbuf[0];
  zip->o_ptr = zip->o_end = NULL;
  zip->bit_buffer = 0; zip->bits_left = 0;
  return zip;
}

zip_read_lens()

static int zip_read_lens ( struct mszipd_stream *  zip )

static

Definition at line 91 of file mszipd.c.

                                                    {
  /* for the bit buffer and huffman decoding */
  register unsigned int bit_buffer;
  register int bits_left;
  unsigned char *i_ptr, *i_end;
 
  /* bitlen Huffman codes -- immediate lookup, 7 bit max code length */
  unsigned short bl_table[(1 << 7)];
  unsigned char bl_len[19];
 
  unsigned char lens[MSZIP_LITERAL_MAXSYMBOLS + MSZIP_DISTANCE_MAXSYMBOLS];
  unsigned int lit_codes, dist_codes, code, last_code=0, bitlen_codes, i, run;
 
  RESTORE_BITS;
 
  /* read the number of codes */
  READ_BITS(lit_codes,    5); lit_codes    += 257;
  READ_BITS(dist_codes,   5); dist_codes   += 1;
  READ_BITS(bitlen_codes, 4); bitlen_codes += 4;
  if (lit_codes  > MSZIP_LITERAL_MAXSYMBOLS)  return INF_ERR_SYMLENS;
  if (dist_codes > MSZIP_DISTANCE_MAXSYMBOLS) return INF_ERR_SYMLENS;
 
  /* read in the bit lengths in their unusual order */
  for (i = 0; i < bitlen_codes; i++) READ_BITS(bl_len[bitlen_order[i]], 3);
  while (i < 19) bl_len[bitlen_order[i++]] = 0;
 
  /* create decoding table with an immediate lookup */
  if (make_decode_table(19, 7, &bl_len[0], &bl_table[0])) {
    return INF_ERR_BITLENTBL;
  }
 
  /* read literal / distance code lengths */
  for (i = 0; i < (lit_codes + dist_codes); i++) {
    /* single-level huffman lookup */
    ENSURE_BITS(7);
    code = bl_table[PEEK_BITS(7)];
    REMOVE_BITS(bl_len[code]);
 
    if (code < 16) lens[i] = last_code = code;
    else {
      switch (code) {
      case 16: READ_BITS(run, 2); run += 3;  code = last_code; break;
      case 17: READ_BITS(run, 3); run += 3;  code = 0;         break;
      case 18: READ_BITS(run, 7); run += 11; code = 0;         break;
      default: D(("bad code!: %u", code)) return INF_ERR_BADBITLEN;
      }
      if ((i + run) > (lit_codes + dist_codes)) return INF_ERR_BITOVERRUN;
      while (run--) lens[i++] = code;
      i--;
    }
  }
 
  /* copy LITERAL code lengths and clear any remaining */
  i = lit_codes;
  zip->sys->copy(&lens[0], &zip->LITERAL_len[0], i);
  while (i < MSZIP_LITERAL_MAXSYMBOLS) zip->LITERAL_len[i++] = 0;
 
  i = dist_codes;
  zip->sys->copy(&lens[lit_codes], &zip->DISTANCE_len[0], i);
  while (i < MSZIP_DISTANCE_MAXSYMBOLS) zip->DISTANCE_len[i++] = 0;
 
  STORE_BITS;
  return 0;
}

References bitlen_order, code, D, ENSURE_BITS, i, INF_ERR_BADBITLEN, INF_ERR_BITLENTBL, INF_ERR_BITOVERRUN, INF_ERR_SYMLENS, make_decode_table(), MSZIP_DISTANCE_MAXSYMBOLS, MSZIP_LITERAL_MAXSYMBOLS, PEEK_BITS, READ_BITS, REMOVE_BITS, RESTORE_BITS, run(), and STORE_BITS.

Referenced by inflate().

Variable Documentation

bitlen_order

const unsigned char bitlen_order[19]

static

Initial value:

= {
  16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
}

Definition at line 71 of file mszipd.c.

Referenced by zip_read_lens().

dist_extrabits

const unsigned char dist_extrabits[30]

static

Initial value:

= {
  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
}

Definition at line 65 of file mszipd.c.

Referenced by inflate().

dist_offsets

const unsigned short dist_offsets[30]

static

Initial value:

= {
  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
}

Definition at line 53 of file mszipd.c.

Referenced by inflate().

lit_extrabits

const unsigned char lit_extrabits[29]

static

Initial value:

= {
  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
}

Definition at line 59 of file mszipd.c.

Referenced by inflate().

lit_lengths

const unsigned short lit_lengths[29]

static

Initial value:

= {
  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
}

Definition at line 47 of file mszipd.c.

Referenced by inflate().