1 /* infutil.h -- types and macros common to blocks and codes 2 * Copyright (C) 1995-1998 Mark Adler 3 * For conditions of distribution and use, see copyright notice in zlib.h 4 */ 5 6 /* WARNING: this file should *not* be used by applications. It is 7 part of the implementation of the compression library and is 8 subject to change. Applications should only use zlib.h. 9 */ 10 11 #ifndef _INFUTIL_H 12 #define _INFUTIL_H 13 14 #include <linux/zconf.h> 15 #include "inftrees.h" 16 #include "infcodes.h" 17 18 typedef enum { 19 TYPE, /* get type bits (3, including end bit) */ 20 LENS, /* get lengths for stored */ 21 STORED, /* processing stored block */ 22 TABLE, /* get table lengths */ 23 BTREE, /* get bit lengths tree for a dynamic block */ 24 DTREE, /* get length, distance trees for a dynamic block */ 25 CODES, /* processing fixed or dynamic block */ 26 DRY, /* output remaining window bytes */ 27 B_DONE, /* finished last block, done */ 28 B_BAD} /* got a data error--stuck here */ 29 inflate_block_mode; 30 31 /* inflate blocks semi-private state */ 32 struct inflate_blocks_state { 33 34 /* mode */ 35 inflate_block_mode mode; /* current inflate_block mode */ 36 37 /* mode dependent information */ 38 union { 39 uInt left; /* if STORED, bytes left to copy */ 40 struct { 41 uInt table; /* table lengths (14 bits) */ 42 uInt index; /* index into blens (or border) */ 43 uIntf *blens; /* bit lengths of codes */ 44 uInt bb; /* bit length tree depth */ 45 inflate_huft *tb; /* bit length decoding tree */ 46 } trees; /* if DTREE, decoding info for trees */ 47 struct { 48 inflate_codes_statef 49 *codes; 50 } decode; /* if CODES, current state */ 51 } sub; /* submode */ 52 uInt last; /* true if this block is the last block */ 53 54 /* mode independent information */ 55 uInt bitk; /* bits in bit buffer */ 56 uLong bitb; /* bit buffer */ 57 inflate_huft *hufts; /* single malloc for tree space */ 58 Bytef *window; /* sliding window */ 59 Bytef *end; /* one byte after sliding window */ 60 Bytef *read; /* window read pointer */ 61 Bytef *write; /* window write pointer */ 62 check_func checkfn; /* check function */ 63 uLong check; /* check on output */ 64 65 }; 66 67 68 /* defines for inflate input/output */ 69 /* update pointers and return */ 70 #define UPDBITS {s->bitb=b;s->bitk=k;} 71 #define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;} 72 #define UPDOUT {s->write=q;} 73 #define UPDATE {UPDBITS UPDIN UPDOUT} 74 #define LEAVE {UPDATE return zlib_inflate_flush(s,z,r);} 75 /* get bytes and bits */ 76 #define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;} 77 #define NEEDBYTE {if(n)r=Z_OK;else LEAVE} 78 #define NEXTBYTE (n--,*p++) 79 #define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}} 80 #define DUMPBITS(j) {b>>=(j);k-=(j);} 81 /* output bytes */ 82 #define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q) 83 #define LOADOUT {q=s->write;m=(uInt)WAVAIL;} 84 #define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}} 85 #define FLUSH {UPDOUT r=zlib_inflate_flush(s,z,r); LOADOUT} 86 #define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} 87 #define OUTBYTE(a) {*q++=(Byte)(a);m--;} 88 /* load local pointers */ 89 #define LOAD {LOADIN LOADOUT} 90 91 /* masks for lower bits (size given to avoid silly warnings with Visual C++) */ 92 extern uInt zlib_inflate_mask[17]; 93 94 /* copy as much as possible from the sliding window to the output area */ 95 extern int zlib_inflate_flush OF(( 96 inflate_blocks_statef *, 97 z_streamp , 98 int)); 99 100 /* inflate private state */ 101 typedef enum { 102 METHOD, /* waiting for method byte */ 103 FLAG, /* waiting for flag byte */ 104 DICT4, /* four dictionary check bytes to go */ 105 DICT3, /* three dictionary check bytes to go */ 106 DICT2, /* two dictionary check bytes to go */ 107 DICT1, /* one dictionary check byte to go */ 108 DICT0, /* waiting for inflateSetDictionary */ 109 BLOCKS, /* decompressing blocks */ 110 CHECK4, /* four check bytes to go */ 111 CHECK3, /* three check bytes to go */ 112 CHECK2, /* two check bytes to go */ 113 CHECK1, /* one check byte to go */ 114 I_DONE, /* finished check, done */ 115 I_BAD} /* got an error--stay here */ 116 inflate_mode; 117 118 struct internal_state { 119 120 /* mode */ 121 inflate_mode mode; /* current inflate mode */ 122 123 /* mode dependent information */ 124 union { 125 uInt method; /* if FLAGS, method byte */ 126 struct { 127 uLong was; /* computed check value */ 128 uLong need; /* stream check value */ 129 } check; /* if CHECK, check values to compare */ 130 uInt marker; /* if BAD, inflateSync's marker bytes count */ 131 } sub; /* submode */ 132 133 /* mode independent information */ 134 int nowrap; /* flag for no wrapper */ 135 uInt wbits; /* log2(window size) (8..15, defaults to 15) */ 136 inflate_blocks_statef 137 *blocks; /* current inflate_blocks state */ 138 139 }; 140 141 /* inflate codes private state */ 142 typedef enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ 143 START, /* x: set up for LEN */ 144 LEN, /* i: get length/literal/eob next */ 145 LENEXT, /* i: getting length extra (have base) */ 146 DIST, /* i: get distance next */ 147 DISTEXT, /* i: getting distance extra */ 148 COPY, /* o: copying bytes in window, waiting for space */ 149 LIT, /* o: got literal, waiting for output space */ 150 WASH, /* o: got eob, possibly still output waiting */ 151 END, /* x: got eob and all data flushed */ 152 BADCODE} /* x: got error */ 153 inflate_codes_mode; 154 155 struct inflate_codes_state { 156 157 /* mode */ 158 inflate_codes_mode mode; /* current inflate_codes mode */ 159 160 /* mode dependent information */ 161 uInt len; 162 union { 163 struct { 164 inflate_huft *tree; /* pointer into tree */ 165 uInt need; /* bits needed */ 166 } code; /* if LEN or DIST, where in tree */ 167 uInt lit; /* if LIT, literal */ 168 struct { 169 uInt get; /* bits to get for extra */ 170 uInt dist; /* distance back to copy from */ 171 } copy; /* if EXT or COPY, where and how much */ 172 } sub; /* submode */ 173 174 /* mode independent information */ 175 Byte lbits; /* ltree bits decoded per branch */ 176 Byte dbits; /* dtree bits decoder per branch */ 177 inflate_huft *ltree; /* literal/length/eob tree */ 178 inflate_huft *dtree; /* distance tree */ 179 180 }; 181 182 /* memory allocation for inflation */ 183 184 struct inflate_workspace { 185 inflate_codes_statef working_state; 186 struct inflate_blocks_state working_blocks_state; 187 struct internal_state internal_state; 188 unsigned int tree_work_area_1[19]; 189 unsigned int tree_work_area_2[288]; 190 unsigned working_blens[258 + 0x1f + 0x1f]; 191 inflate_huft working_hufts[MANY]; 192 unsigned char working_window[1 << MAX_WBITS]; 193 }; 194 195 #define WS(z) ((struct inflate_workspace *)(z->workspace)) 196 197 #endif 198