]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | uInt *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 | Byte *window; /* sliding window */ | |
59 | Byte *end; /* one byte after sliding window */ | |
60 | Byte *read; /* window read pointer */ | |
61 | Byte *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 ( | |
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 |