0
|
1 /* -*-mode:java; c-basic-offset:2; -*- */
|
|
2 /*
|
|
3 Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
|
|
4
|
|
5 Redistribution and use in source and binary forms, with or without
|
|
6 modification, are permitted provided that the following conditions are met:
|
|
7
|
|
8 1. Redistributions of source code must retain the above copyright notice,
|
|
9 this list of conditions and the following disclaimer.
|
|
10
|
357
|
11 2. Redistributions in binary form must reproduce the above copyright
|
|
12 notice, this list of conditions and the following disclaimer in
|
0
|
13 the documentation and/or other materials provided with the distribution.
|
|
14
|
|
15 3. The names of the authors may not be used to endorse or promote products
|
|
16 derived from this software without specific prior written permission.
|
|
17
|
|
18 THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
|
19 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
20 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
|
21 INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
22 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
23 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
24 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
25 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
26 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
27 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
28 */
|
|
29 /*
|
|
30 * This program is based on zlib-1.1.3, so all credit should go authors
|
|
31 * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
|
32 * and contributors of zlib.
|
|
33 */
|
|
34
|
|
35 package com.jcraft.jzlib;
|
|
36
|
357
|
37 final class InfCodes{
|
0
|
38
|
357
|
39 static final private int[] inflate_mask = {
|
|
40 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
|
|
41 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
|
|
42 0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
|
|
43 0x00007fff, 0x0000ffff
|
|
44 };
|
0
|
45
|
357
|
46 static final private int Z_OK=0;
|
|
47 static final private int Z_STREAM_END=1;
|
|
48 static final private int Z_NEED_DICT=2;
|
|
49 static final private int Z_ERRNO=-1;
|
|
50 static final private int Z_STREAM_ERROR=-2;
|
|
51 static final private int Z_DATA_ERROR=-3;
|
|
52 static final private int Z_MEM_ERROR=-4;
|
|
53 static final private int Z_BUF_ERROR=-5;
|
|
54 static final private int Z_VERSION_ERROR=-6;
|
0
|
55
|
357
|
56 // waiting for "i:"=input,
|
|
57 // "o:"=output,
|
|
58 // "x:"=nothing
|
|
59 static final private int START=0; // x: set up for LEN
|
|
60 static final private int LEN=1; // i: get length/literal/eob next
|
|
61 static final private int LENEXT=2; // i: getting length extra (have base)
|
|
62 static final private int DIST=3; // i: get distance next
|
|
63 static final private int DISTEXT=4;// i: getting distance extra
|
|
64 static final private int COPY=5; // o: copying bytes in window, waiting for space
|
|
65 static final private int LIT=6; // o: got literal, waiting for output space
|
|
66 static final private int WASH=7; // o: got eob, possibly still output waiting
|
|
67 static final private int END=8; // x: got eob and all data flushed
|
|
68 static final private int BADCODE=9;// x: got error
|
0
|
69
|
357
|
70 int mode; // current inflate_codes mode
|
0
|
71
|
357
|
72 // mode dependent information
|
|
73 int len;
|
0
|
74
|
357
|
75 int[] tree; // pointer into tree
|
|
76 int tree_index=0;
|
|
77 int need; // bits needed
|
|
78
|
|
79 int lit;
|
|
80
|
|
81 // if EXT or COPY, where and how much
|
|
82 int get; // bits to get for extra
|
|
83 int dist; // distance back to copy from
|
0
|
84
|
357
|
85 byte lbits; // ltree bits decoded per branch
|
|
86 byte dbits; // dtree bits decoder per branch
|
|
87 int[] ltree; // literal/length/eob tree
|
|
88 int ltree_index; // literal/length/eob tree
|
|
89 int[] dtree; // distance tree
|
|
90 int dtree_index; // distance tree
|
|
91
|
|
92 private final ZStream z;
|
|
93 private final InfBlocks s;
|
|
94 InfCodes(ZStream z, InfBlocks s){
|
|
95 this.z=z;
|
|
96 this.s=s;
|
|
97 }
|
0
|
98
|
357
|
99 void init(int bl, int bd,
|
|
100 int[] tl, int tl_index,
|
|
101 int[] td, int td_index){
|
|
102 mode=START;
|
|
103 lbits=(byte)bl;
|
|
104 dbits=(byte)bd;
|
|
105 ltree=tl;
|
|
106 ltree_index=tl_index;
|
|
107 dtree = td;
|
|
108 dtree_index=td_index;
|
|
109 tree=null;
|
|
110 }
|
0
|
111
|
357
|
112 int proc(int r){
|
|
113 int j; // temporary storage
|
|
114 int[] t; // temporary pointer
|
|
115 int tindex; // temporary pointer
|
|
116 int e; // extra bits or operation
|
|
117 int b=0; // bit buffer
|
|
118 int k=0; // bits in bit buffer
|
|
119 int p=0; // input data pointer
|
|
120 int n; // bytes available there
|
|
121 int q; // output window write pointer
|
|
122 int m; // bytes to end of window or read pointer
|
|
123 int f; // pointer to copy strings from
|
|
124
|
|
125 // copy input/output information to locals (UPDATE macro restores)
|
|
126 p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
|
|
127 q=s.write;m=q<s.read?s.read-q-1:s.end-q;
|
|
128
|
|
129 // process input and output based on current state
|
|
130 while (true){
|
|
131 switch (mode){
|
|
132 // waiting for "i:"=input, "o:"=output, "x:"=nothing
|
|
133 case START: // x: set up for LEN
|
|
134 if (m >= 258 && n >= 10){
|
0
|
135
|
357
|
136 s.bitb=b;s.bitk=k;
|
|
137 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
138 s.write=q;
|
|
139 r = inflate_fast(lbits, dbits,
|
|
140 ltree, ltree_index,
|
|
141 dtree, dtree_index,
|
|
142 s, z);
|
0
|
143
|
357
|
144 p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
|
|
145 q=s.write;m=q<s.read?s.read-q-1:s.end-q;
|
0
|
146
|
357
|
147 if (r != Z_OK){
|
|
148 mode = r == Z_STREAM_END ? WASH : BADCODE;
|
|
149 break;
|
|
150 }
|
|
151 }
|
|
152 need = lbits;
|
|
153 tree = ltree;
|
|
154 tree_index=ltree_index;
|
0
|
155
|
357
|
156 mode = LEN;
|
|
157 case LEN: // i: get length/literal/eob next
|
|
158 j = need;
|
|
159
|
|
160 while(k<(j)){
|
|
161 if(n!=0)r=Z_OK;
|
|
162 else{
|
0
|
163
|
357
|
164 s.bitb=b;s.bitk=k;
|
|
165 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
166 s.write=q;
|
|
167 return s.inflate_flush(r);
|
|
168 }
|
|
169 n--;
|
|
170 b|=(z.next_in[p++]&0xff)<<k;
|
|
171 k+=8;
|
|
172 }
|
0
|
173
|
357
|
174 tindex=(tree_index+(b&inflate_mask[j]))*3;
|
0
|
175
|
357
|
176 b>>>=(tree[tindex+1]);
|
|
177 k-=(tree[tindex+1]);
|
0
|
178
|
357
|
179 e=tree[tindex];
|
0
|
180
|
357
|
181 if(e == 0){ // literal
|
|
182 lit = tree[tindex+2];
|
|
183 mode = LIT;
|
|
184 break;
|
|
185 }
|
|
186 if((e & 16)!=0 ){ // length
|
|
187 get = e & 15;
|
|
188 len = tree[tindex+2];
|
|
189 mode = LENEXT;
|
|
190 break;
|
|
191 }
|
|
192 if ((e & 64) == 0){ // next table
|
|
193 need = e;
|
|
194 tree_index = tindex/3+tree[tindex+2];
|
|
195 break;
|
|
196 }
|
|
197 if ((e & 32)!=0){ // end of block
|
|
198 mode = WASH;
|
|
199 break;
|
|
200 }
|
|
201 mode = BADCODE; // invalid code
|
|
202 z.msg = "invalid literal/length code";
|
|
203 r = Z_DATA_ERROR;
|
0
|
204
|
357
|
205 s.bitb=b;s.bitk=k;
|
|
206 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
207 s.write=q;
|
|
208 return s.inflate_flush(r);
|
0
|
209
|
357
|
210 case LENEXT: // i: getting length extra (have base)
|
|
211 j = get;
|
0
|
212
|
357
|
213 while(k<(j)){
|
|
214 if(n!=0)r=Z_OK;
|
|
215 else{
|
0
|
216
|
357
|
217 s.bitb=b;s.bitk=k;
|
|
218 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
219 s.write=q;
|
|
220 return s.inflate_flush(r);
|
|
221 }
|
|
222 n--; b|=(z.next_in[p++]&0xff)<<k;
|
|
223 k+=8;
|
|
224 }
|
|
225
|
|
226 len += (b & inflate_mask[j]);
|
|
227
|
|
228 b>>=j;
|
|
229 k-=j;
|
0
|
230
|
357
|
231 need = dbits;
|
|
232 tree = dtree;
|
|
233 tree_index=dtree_index;
|
|
234 mode = DIST;
|
|
235 case DIST: // i: get distance next
|
|
236 j = need;
|
0
|
237
|
357
|
238 while(k<(j)){
|
|
239 if(n!=0)r=Z_OK;
|
|
240 else{
|
0
|
241
|
357
|
242 s.bitb=b;s.bitk=k;
|
|
243 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
244 s.write=q;
|
|
245 return s.inflate_flush(r);
|
|
246 }
|
|
247 n--; b|=(z.next_in[p++]&0xff)<<k;
|
|
248 k+=8;
|
|
249 }
|
0
|
250
|
357
|
251 tindex=(tree_index+(b & inflate_mask[j]))*3;
|
0
|
252
|
357
|
253 b>>=tree[tindex+1];
|
|
254 k-=tree[tindex+1];
|
0
|
255
|
357
|
256 e = (tree[tindex]);
|
|
257 if((e & 16)!=0){ // distance
|
|
258 get = e & 15;
|
|
259 dist = tree[tindex+2];
|
|
260 mode = DISTEXT;
|
|
261 break;
|
|
262 }
|
|
263 if ((e & 64) == 0){ // next table
|
|
264 need = e;
|
|
265 tree_index = tindex/3 + tree[tindex+2];
|
|
266 break;
|
|
267 }
|
|
268 mode = BADCODE; // invalid code
|
|
269 z.msg = "invalid distance code";
|
|
270 r = Z_DATA_ERROR;
|
0
|
271
|
357
|
272 s.bitb=b;s.bitk=k;
|
|
273 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
274 s.write=q;
|
|
275 return s.inflate_flush(r);
|
0
|
276
|
357
|
277 case DISTEXT: // i: getting distance extra
|
|
278 j = get;
|
|
279
|
|
280 while(k<(j)){
|
|
281 if(n!=0)r=Z_OK;
|
|
282 else{
|
0
|
283
|
357
|
284 s.bitb=b;s.bitk=k;
|
|
285 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
286 s.write=q;
|
|
287 return s.inflate_flush(r);
|
|
288 }
|
|
289 n--; b|=(z.next_in[p++]&0xff)<<k;
|
|
290 k+=8;
|
|
291 }
|
0
|
292
|
357
|
293 dist += (b & inflate_mask[j]);
|
0
|
294
|
357
|
295 b>>=j;
|
|
296 k-=j;
|
0
|
297
|
357
|
298 mode = COPY;
|
|
299 case COPY: // o: copying bytes in window, waiting for space
|
|
300 f = q - dist;
|
|
301 while(f < 0){ // modulo window size-"while" instead
|
|
302 f += s.end; // of "if" handles invalid distances
|
|
303 }
|
|
304 while (len!=0){
|
0
|
305
|
357
|
306 if(m==0){
|
|
307 if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
|
|
308 if(m==0){
|
|
309 s.write=q; r=s.inflate_flush(r);
|
|
310 q=s.write;m=q<s.read?s.read-q-1:s.end-q;
|
|
311
|
|
312 if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
|
0
|
313
|
357
|
314 if(m==0){
|
|
315 s.bitb=b;s.bitk=k;
|
|
316 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
317 s.write=q;
|
|
318 return s.inflate_flush(r);
|
|
319 }
|
|
320 }
|
|
321 }
|
0
|
322
|
357
|
323 s.window[q++]=s.window[f++]; m--;
|
0
|
324
|
357
|
325 if (f == s.end)
|
|
326 f = 0;
|
|
327 len--;
|
|
328 }
|
|
329 mode = START;
|
|
330 break;
|
|
331 case LIT: // o: got literal, waiting for output space
|
|
332 if(m==0){
|
|
333 if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
|
|
334 if(m==0){
|
|
335 s.write=q; r=s.inflate_flush(r);
|
|
336 q=s.write;m=q<s.read?s.read-q-1:s.end-q;
|
0
|
337
|
357
|
338 if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
|
|
339 if(m==0){
|
|
340 s.bitb=b;s.bitk=k;
|
|
341 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
342 s.write=q;
|
|
343 return s.inflate_flush(r);
|
|
344 }
|
|
345 }
|
|
346 }
|
|
347 r=Z_OK;
|
0
|
348
|
357
|
349 s.window[q++]=(byte)lit; m--;
|
0
|
350
|
357
|
351 mode = START;
|
|
352 break;
|
|
353 case WASH: // o: got eob, possibly more output
|
|
354 if (k > 7){ // return unused byte, if any
|
|
355 k -= 8;
|
|
356 n++;
|
|
357 p--; // can always return one
|
|
358 }
|
0
|
359
|
357
|
360 s.write=q; r=s.inflate_flush(r);
|
|
361 q=s.write;m=q<s.read?s.read-q-1:s.end-q;
|
0
|
362
|
357
|
363 if (s.read != s.write){
|
|
364 s.bitb=b;s.bitk=k;
|
|
365 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
366 s.write=q;
|
|
367 return s.inflate_flush(r);
|
|
368 }
|
|
369 mode = END;
|
|
370 case END:
|
|
371 r = Z_STREAM_END;
|
|
372 s.bitb=b;s.bitk=k;
|
|
373 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
374 s.write=q;
|
|
375 return s.inflate_flush(r);
|
0
|
376
|
357
|
377 case BADCODE: // x: got error
|
|
378
|
|
379 r = Z_DATA_ERROR;
|
0
|
380
|
357
|
381 s.bitb=b;s.bitk=k;
|
|
382 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
383 s.write=q;
|
|
384 return s.inflate_flush(r);
|
|
385
|
|
386 default:
|
|
387 r = Z_STREAM_ERROR;
|
0
|
388
|
357
|
389 s.bitb=b;s.bitk=k;
|
|
390 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
391 s.write=q;
|
|
392 return s.inflate_flush(r);
|
|
393 }
|
0
|
394 }
|
357
|
395 }
|
0
|
396
|
357
|
397 void free(ZStream z){
|
|
398 // ZFREE(z, c);
|
|
399 }
|
|
400
|
|
401 // Called with number of bytes left to write in window at least 258
|
|
402 // (the maximum string length) and number of input bytes available
|
|
403 // at least ten. The ten bytes are six bytes for the longest length/
|
|
404 // distance pair plus four bytes for overloading the bit buffer.
|
0
|
405
|
357
|
406 int inflate_fast(int bl, int bd,
|
|
407 int[] tl, int tl_index,
|
|
408 int[] td, int td_index,
|
|
409 InfBlocks s, ZStream z){
|
|
410 int t; // temporary pointer
|
|
411 int[] tp; // temporary pointer
|
|
412 int tp_index; // temporary pointer
|
|
413 int e; // extra bits or operation
|
|
414 int b; // bit buffer
|
|
415 int k; // bits in bit buffer
|
|
416 int p; // input data pointer
|
|
417 int n; // bytes available there
|
|
418 int q; // output window write pointer
|
|
419 int m; // bytes to end of window or read pointer
|
|
420 int ml; // mask for literal/length tree
|
|
421 int md; // mask for distance tree
|
|
422 int c; // bytes to copy
|
|
423 int d; // distance back to copy from
|
|
424 int r; // copy source pointer
|
0
|
425
|
357
|
426 int tp_index_t_3; // (tp_index+t)*3
|
|
427
|
|
428 // load input, output, bit values
|
|
429 p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
|
|
430 q=s.write;m=q<s.read?s.read-q-1:s.end-q;
|
|
431
|
|
432 // initialize masks
|
|
433 ml = inflate_mask[bl];
|
|
434 md = inflate_mask[bd];
|
|
435
|
|
436 // do until not enough input or output space for fast loop
|
|
437 do { // assume called with m >= 258 && n >= 10
|
|
438 // get literal/length code
|
|
439 while(k<(20)){ // max bits for literal/length code
|
|
440 n--;
|
|
441 b|=(z.next_in[p++]&0xff)<<k;k+=8;
|
|
442 }
|
0
|
443
|
357
|
444 t= b&ml;
|
|
445 tp=tl;
|
|
446 tp_index=tl_index;
|
|
447 tp_index_t_3=(tp_index+t)*3;
|
|
448 if ((e = tp[tp_index_t_3]) == 0){
|
|
449 b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
|
0
|
450
|
357
|
451 s.window[q++] = (byte)tp[tp_index_t_3+2];
|
|
452 m--;
|
|
453 continue;
|
|
454 }
|
|
455 do {
|
0
|
456
|
357
|
457 b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
|
0
|
458
|
357
|
459 if((e&16)!=0){
|
|
460 e &= 15;
|
|
461 c = tp[tp_index_t_3+2] + ((int)b & inflate_mask[e]);
|
|
462
|
|
463 b>>=e; k-=e;
|
0
|
464
|
357
|
465 // decode distance base of block to copy
|
|
466 while(k<(15)){ // max bits for distance code
|
|
467 n--;
|
|
468 b|=(z.next_in[p++]&0xff)<<k;k+=8;
|
|
469 }
|
0
|
470
|
357
|
471 t= b&md;
|
|
472 tp=td;
|
|
473 tp_index=td_index;
|
|
474 tp_index_t_3=(tp_index+t)*3;
|
|
475 e = tp[tp_index_t_3];
|
0
|
476
|
357
|
477 do {
|
0
|
478
|
357
|
479 b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
|
0
|
480
|
357
|
481 if((e&16)!=0){
|
|
482 // get extra bits to add to distance base
|
|
483 e &= 15;
|
|
484 while(k<(e)){ // get extra bits (up to 13)
|
|
485 n--;
|
|
486 b|=(z.next_in[p++]&0xff)<<k;k+=8;
|
|
487 }
|
0
|
488
|
357
|
489 d = tp[tp_index_t_3+2] + (b&inflate_mask[e]);
|
|
490
|
|
491 b>>=(e); k-=(e);
|
0
|
492
|
357
|
493 // do the copy
|
|
494 m -= c;
|
|
495 if (q >= d){ // offset before dest
|
|
496 // just copy
|
|
497 r=q-d;
|
|
498 if(q-r>0 && 2>(q-r)){
|
|
499 s.window[q++]=s.window[r++]; // minimum count is three,
|
|
500 s.window[q++]=s.window[r++]; // so unroll loop a little
|
|
501 c-=2;
|
|
502 }
|
|
503 else{
|
|
504 System.arraycopy(s.window, r, s.window, q, 2);
|
|
505 q+=2; r+=2; c-=2;
|
|
506 }
|
|
507 }
|
|
508 else{ // else offset after destination
|
|
509 r=q-d;
|
|
510 do{
|
|
511 r+=s.end; // force pointer in window
|
|
512 }while(r<0); // covers invalid distances
|
|
513 e=s.end-r;
|
|
514 if(c>e){ // if source crosses,
|
|
515 c-=e; // wrapped copy
|
|
516 if(q-r>0 && e>(q-r)){
|
|
517 do{s.window[q++] = s.window[r++];}
|
|
518 while(--e!=0);
|
|
519 }
|
|
520 else{
|
|
521 System.arraycopy(s.window, r, s.window, q, e);
|
|
522 q+=e; r+=e; e=0;
|
|
523 }
|
|
524 r = 0; // copy rest from start of window
|
|
525 }
|
0
|
526
|
357
|
527 }
|
0
|
528
|
357
|
529 // copy all or what's left
|
|
530 if(q-r>0 && c>(q-r)){
|
|
531 do{s.window[q++] = s.window[r++];}
|
|
532 while(--c!=0);
|
|
533 }
|
|
534 else{
|
|
535 System.arraycopy(s.window, r, s.window, q, c);
|
|
536 q+=c; r+=c; c=0;
|
|
537 }
|
|
538 break;
|
|
539 }
|
|
540 else if((e&64)==0){
|
|
541 t+=tp[tp_index_t_3+2];
|
|
542 t+=(b&inflate_mask[e]);
|
|
543 tp_index_t_3=(tp_index+t)*3;
|
|
544 e=tp[tp_index_t_3];
|
|
545 }
|
|
546 else{
|
|
547 z.msg = "invalid distance code";
|
0
|
548
|
357
|
549 c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
|
|
550
|
|
551 s.bitb=b;s.bitk=k;
|
|
552 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
553 s.write=q;
|
0
|
554
|
357
|
555 return Z_DATA_ERROR;
|
|
556 }
|
|
557 }
|
|
558 while(true);
|
|
559 break;
|
|
560 }
|
|
561
|
|
562 if((e&64)==0){
|
|
563 t+=tp[tp_index_t_3+2];
|
|
564 t+=(b&inflate_mask[e]);
|
|
565 tp_index_t_3=(tp_index+t)*3;
|
|
566 if((e=tp[tp_index_t_3])==0){
|
|
567
|
|
568 b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
|
0
|
569
|
357
|
570 s.window[q++]=(byte)tp[tp_index_t_3+2];
|
|
571 m--;
|
|
572 break;
|
|
573 }
|
|
574 }
|
|
575 else if((e&32)!=0){
|
|
576
|
|
577 c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
|
|
578
|
|
579 s.bitb=b;s.bitk=k;
|
|
580 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
581 s.write=q;
|
|
582
|
|
583 return Z_STREAM_END;
|
|
584 }
|
|
585 else{
|
|
586 z.msg="invalid literal/length code";
|
|
587
|
|
588 c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
|
0
|
589
|
357
|
590 s.bitb=b;s.bitk=k;
|
|
591 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
592 s.write=q;
|
|
593
|
|
594 return Z_DATA_ERROR;
|
|
595 }
|
|
596 }
|
|
597 while(true);
|
|
598 }
|
|
599 while(m>=258 && n>= 10);
|
0
|
600
|
357
|
601 // not enough input or output--restore pointers and return
|
|
602 c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
|
|
603
|
|
604 s.bitb=b;s.bitk=k;
|
|
605 z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
|
|
606 s.write=q;
|
|
607
|
|
608 return Z_OK;
|
|
609 }
|
0
|
610 }
|