ReactOS  0.4.14-dev-49-gfb4591c
mszip.c
Go to the documentation of this file.
1 /*
2  * MSZIP decompression (taken from fdi.c of cabinet dll)
3  *
4  * Copyright 2000-2002 Stuart Caie
5  * Copyright 2002 Patrik Stridvall
6  * Copyright 2003 Greg Turner
7  * Copyright 2010 Christian Costa
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23 
24 #include <stdarg.h>
25 
26 #include "windef.h"
27 #include "winbase.h"
28 
29 #include "wine/debug.h"
30 
31 #include "mszip.h"
32 
34 
36 
37 /********************************************************
38  * Ziphuft_free (internal)
39  */
40 static void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t)
41 {
42  register struct Ziphuft *p, *q;
43 
44  /* Go through linked list, freeing from the allocated (t[-1]) address. */
45  p = t;
46  while (p != NULL)
47  {
48  q = (--p)->v.t;
49  PFDI_FREE(hfdi, p);
50  p = q;
51  }
52 }
53 
54 /*********************************************************
55  * fdi_Ziphuft_build (internal)
56  */
58 struct Ziphuft **t, cab_LONG *m, fdi_decomp_state *decomp_state)
59 {
60  cab_ULONG a; /* counter for codes of length k */
61  cab_ULONG el; /* length of EOB code (value 256) */
62  cab_ULONG f; /* i repeats in table every f entries */
63  cab_LONG g; /* maximum code length */
64  cab_LONG h; /* table level */
65  register cab_ULONG i; /* counter, current code */
66  register cab_ULONG j; /* counter */
67  register cab_LONG k; /* number of bits in current code */
68  cab_LONG *l; /* stack of bits per table */
69  register cab_ULONG *p; /* pointer into ZIP(c)[],ZIP(b)[],ZIP(v)[] */
70  register struct Ziphuft *q; /* points to current table */
71  struct Ziphuft r; /* table entry for structure assignment */
72  register cab_LONG w; /* bits before this table == (l * h) */
73  cab_ULONG *xp; /* pointer into x */
74  cab_LONG y; /* number of dummy codes added */
75  cab_ULONG z; /* number of entries in current table */
76 
77  l = ZIP(lx)+1;
78 
79  /* Generate counts for each bit length */
80  el = n > 256 ? b[256] : ZIPBMAX; /* set length of EOB code, if any */
81 
82  for(i = 0; i < ZIPBMAX+1; ++i)
83  ZIP(c)[i] = 0;
84  p = b; i = n;
85  do
86  {
87  ZIP(c)[*p]++; p++; /* assume all entries <= ZIPBMAX */
88  } while (--i);
89  if (ZIP(c)[0] == n) /* null input--all zero length codes */
90  {
91  *t = NULL;
92  *m = 0;
93  return 0;
94  }
95 
96  /* Find minimum and maximum length, bound *m by those */
97  for (j = 1; j <= ZIPBMAX; j++)
98  if (ZIP(c)[j])
99  break;
100  k = j; /* minimum code length */
101  if ((cab_ULONG)*m < j)
102  *m = j;
103  for (i = ZIPBMAX; i; i--)
104  if (ZIP(c)[i])
105  break;
106  g = i; /* maximum code length */
107  if ((cab_ULONG)*m > i)
108  *m = i;
109 
110  /* Adjust last length count to fill out codes, if needed */
111  for (y = 1 << j; j < i; j++, y <<= 1)
112  if ((y -= ZIP(c)[j]) < 0)
113  return 2; /* bad input: more codes than bits */
114  if ((y -= ZIP(c)[i]) < 0)
115  return 2;
116  ZIP(c)[i] += y;
117 
118  /* Generate starting offsets LONGo the value table for each length */
119  ZIP(x)[1] = j = 0;
120  p = ZIP(c) + 1; xp = ZIP(x) + 2;
121  while (--i)
122  { /* note that i == g from above */
123  *xp++ = (j += *p++);
124  }
125 
126  /* Make a table of values in order of bit lengths */
127  p = b; i = 0;
128  do{
129  if ((j = *p++) != 0)
130  ZIP(v)[ZIP(x)[j]++] = i;
131  } while (++i < n);
132 
133 
134  /* Generate the Huffman codes and for each, make the table entries */
135  ZIP(x)[0] = i = 0; /* first Huffman code is zero */
136  p = ZIP(v); /* grab values in bit order */
137  h = -1; /* no tables yet--level -1 */
138  w = l[-1] = 0; /* no bits decoded yet */
139  ZIP(u)[0] = NULL; /* just to keep compilers happy */
140  q = NULL; /* ditto */
141  z = 0; /* ditto */
142 
143  /* go through the bit lengths (k already is bits in shortest code) */
144  for (; k <= g; k++)
145  {
146  a = ZIP(c)[k];
147  while (a--)
148  {
149  /* here i is the Huffman code of length k bits for value *p */
150  /* make tables up to required level */
151  while (k > w + l[h])
152  {
153  w += l[h++]; /* add bits already decoded */
154 
155  /* compute minimum size table less than or equal to *m bits */
156  if ((z = g - w) > (cab_ULONG)*m) /* upper limit */
157  z = *m;
158  if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
159  { /* too few codes for k-w bit table */
160  f -= a + 1; /* deduct codes from patterns left */
161  xp = ZIP(c) + k;
162  while (++j < z) /* try smaller tables up to z bits */
163  {
164  if ((f <<= 1) <= *++xp)
165  break; /* enough codes to use up j bits */
166  f -= *xp; /* else deduct codes from patterns */
167  }
168  }
169  if ((cab_ULONG)w + j > el && (cab_ULONG)w < el)
170  j = el - w; /* make EOB code end at table */
171  z = 1 << j; /* table entries for j-bit table */
172  l[h] = j; /* set table size in stack */
173 
174  /* allocate and link in new table */
175  if (!(q = PFDI_ALLOC(CAB(hfdi), (z + 1)*sizeof(struct Ziphuft))))
176  {
177  if(h)
178  fdi_Ziphuft_free(CAB(hfdi), ZIP(u)[0]);
179  return 3; /* not enough memory */
180  }
181  *t = q + 1; /* link to list for Ziphuft_free() */
182  *(t = &(q->v.t)) = NULL;
183  ZIP(u)[h] = ++q; /* table starts after link */
184 
185  /* connect to last table, if there is one */
186  if (h)
187  {
188  ZIP(x)[h] = i; /* save pattern for backing up */
189  r.b = (cab_UBYTE)l[h-1]; /* bits to dump before this table */
190  r.e = (cab_UBYTE)(16 + j); /* bits in this table */
191  r.v.t = q; /* pointer to this table */
192  j = (i & ((1 << w) - 1)) >> (w - l[h-1]);
193  ZIP(u)[h-1][j] = r; /* connect to last table */
194  }
195  }
196 
197  /* set up table entry in r */
198  r.b = (cab_UBYTE)(k - w);
199  if (p >= ZIP(v) + n)
200  r.e = 99; /* out of values--invalid code */
201  else if (*p < s)
202  {
203  r.e = (cab_UBYTE)(*p < 256 ? 16 : 15); /* 256 is end-of-block code */
204  r.v.n = *p++; /* simple code is just the value */
205  }
206  else
207  {
208  r.e = (cab_UBYTE)e[*p - s]; /* non-simple--look up in lists */
209  r.v.n = d[*p++ - s];
210  }
211 
212  /* fill code-like entries with r */
213  f = 1 << (k - w);
214  for (j = i >> w; j < z; j += f)
215  q[j] = r;
216 
217  /* backwards increment the k-bit code i */
218  for (j = 1 << (k - 1); i & j; j >>= 1)
219  i ^= j;
220  i ^= j;
221 
222  /* backup over finished tables */
223  while ((i & ((1 << w) - 1)) != ZIP(x)[h])
224  w -= l[--h]; /* don't need to update q */
225  }
226  }
227 
228  /* return actual size of base table */
229  *m = l[0];
230 
231  /* Return true (1) if we were given an incomplete table */
232  return y != 0 && g != 1;
233 }
234 
235 /*********************************************************
236  * fdi_Zipinflate_codes (internal)
237  */
238 static cab_LONG fdi_Zipinflate_codes(const struct Ziphuft *tl, const struct Ziphuft *td,
239  cab_LONG bl, cab_LONG bd, fdi_decomp_state *decomp_state)
240 {
241  register cab_ULONG e; /* table entry flag/number of extra bits */
242  cab_ULONG n, d; /* length and index for copy */
243  cab_ULONG w; /* current window position */
244  const struct Ziphuft *t; /* pointer to table entry */
245  cab_ULONG ml, md; /* masks for bl and bd bits */
246  register cab_ULONG b; /* bit buffer */
247  register cab_ULONG k; /* number of bits in bit buffer */
248 
249  /* make local copies of globals */
250  b = ZIP(bb); /* initialize bit buffer */
251  k = ZIP(bk);
252  w = ZIP(window_posn); /* initialize window position */
253 
254  /* inflate the coded data */
255  ml = Zipmask[bl]; /* precompute masks for speed */
256  md = Zipmask[bd];
257 
258  for(;;)
259  {
261  if((e = (t = tl + (b & ml))->e) > 16)
262  do
263  {
264  if (e == 99)
265  return 1;
266  ZIPDUMPBITS(t->b)
267  e -= 16;
268  ZIPNEEDBITS(e)
269  } while ((e = (t = t->v.t + (b & Zipmask[e]))->e) > 16);
270  ZIPDUMPBITS(t->b)
271  if (e == 16) /* then it's a literal */
272  CAB(outbuf)[w++] = (cab_UBYTE)t->v.n;
273  else /* it's an EOB or a length */
274  {
275  /* exit if end of block */
276  if(e == 15)
277  break;
278 
279  /* get length of block to copy */
280  ZIPNEEDBITS(e)
281  n = t->v.n + (b & Zipmask[e]);
282  ZIPDUMPBITS(e);
283 
284  /* decode distance of block to copy */
286  if ((e = (t = td + (b & md))->e) > 16)
287  do {
288  if (e == 99)
289  return 1;
290  ZIPDUMPBITS(t->b)
291  e -= 16;
292  ZIPNEEDBITS(e)
293  } while ((e = (t = t->v.t + (b & Zipmask[e]))->e) > 16);
294  ZIPDUMPBITS(t->b)
295  ZIPNEEDBITS(e)
296  d = w - t->v.n - (b & Zipmask[e]);
297  ZIPDUMPBITS(e)
298  do
299  {
300  d &= ZIPWSIZE - 1;
301  e = ZIPWSIZE - max(d, w);
302  e = min(e, n);
303  n -= e;
304  do
305  {
306  CAB(outbuf)[w++] = CAB(outbuf)[d++];
307  } while (--e);
308  } while (n);
309  }
310  }
311 
312  /* restore the globals from the locals */
313  ZIP(window_posn) = w; /* restore global window pointer */
314  ZIP(bb) = b; /* restore global bit buffer */
315  ZIP(bk) = k;
316 
317  /* done */
318  return 0;
319 }
320 
321 /***********************************************************
322  * Zipinflate_stored (internal)
323  */
325 /* "decompress" an inflated type 0 (stored) block. */
326 {
327  cab_ULONG n; /* number of bytes in block */
328  cab_ULONG w; /* current window position */
329  register cab_ULONG b; /* bit buffer */
330  register cab_ULONG k; /* number of bits in bit buffer */
331 
332  /* make local copies of globals */
333  b = ZIP(bb); /* initialize bit buffer */
334  k = ZIP(bk);
335  w = ZIP(window_posn); /* initialize window position */
336 
337  /* go to byte boundary */
338  n = k & 7;
339  ZIPDUMPBITS(n);
340 
341  /* get the length and its complement */
342  ZIPNEEDBITS(16)
343  n = (b & 0xffff);
344  ZIPDUMPBITS(16)
345  ZIPNEEDBITS(16)
346  if (n != ((~b) & 0xffff))
347  return 1; /* error in compressed data */
348  ZIPDUMPBITS(16)
349 
350  /* read and output the compressed data */
351  while(n--)
352  {
353  ZIPNEEDBITS(8)
354  CAB(outbuf)[w++] = (cab_UBYTE)b;
355  ZIPDUMPBITS(8)
356  }
357 
358  /* restore the globals from the locals */
359  ZIP(window_posn) = w; /* restore global window pointer */
360  ZIP(bb) = b; /* restore global bit buffer */
361  ZIP(bk) = k;
362  return 0;
363 }
364 
365 /******************************************************
366  * fdi_Zipinflate_fixed (internal)
367  */
369 {
370  struct Ziphuft *fixed_tl;
371  struct Ziphuft *fixed_td;
373  cab_LONG i; /* temporary variable */
374  cab_ULONG *l;
375 
376  l = ZIP(ll);
377 
378  /* literal table */
379  for(i = 0; i < 144; i++)
380  l[i] = 8;
381  for(; i < 256; i++)
382  l[i] = 9;
383  for(; i < 280; i++)
384  l[i] = 7;
385  for(; i < 288; i++) /* make a complete, but wrong code set */
386  l[i] = 8;
387  fixed_bl = 7;
388  if((i = fdi_Ziphuft_build(l, 288, 257, Zipcplens, Zipcplext, &fixed_tl, &fixed_bl, decomp_state)))
389  return i;
390 
391  /* distance table */
392  for(i = 0; i < 30; i++) /* make an incomplete code set */
393  l[i] = 5;
394  fixed_bd = 5;
395  if((i = fdi_Ziphuft_build(l, 30, 0, Zipcpdist, Zipcpdext, &fixed_td, &fixed_bd, decomp_state)) > 1)
396  {
397  fdi_Ziphuft_free(CAB(hfdi), fixed_tl);
398  return i;
399  }
400 
401  /* decompress until an end-of-block code */
403 
404  fdi_Ziphuft_free(CAB(hfdi), fixed_td);
405  fdi_Ziphuft_free(CAB(hfdi), fixed_tl);
406  return i;
407 }
408 
409 /**************************************************************
410  * fdi_Zipinflate_dynamic (internal)
411  */
413  /* decompress an inflated type 2 (dynamic Huffman codes) block. */
414 {
415  cab_LONG i; /* temporary variables */
416  cab_ULONG j;
417  cab_ULONG *ll;
418  cab_ULONG l; /* last length */
419  cab_ULONG m; /* mask for bit lengths table */
420  cab_ULONG n; /* number of lengths to get */
421  struct Ziphuft *tl; /* literal/length code table */
422  struct Ziphuft *td; /* distance code table */
423  cab_LONG bl; /* lookup bits for tl */
424  cab_LONG bd; /* lookup bits for td */
425  cab_ULONG nb; /* number of bit length codes */
426  cab_ULONG nl; /* number of literal/length codes */
427  cab_ULONG nd; /* number of distance codes */
428  register cab_ULONG b; /* bit buffer */
429  register cab_ULONG k; /* number of bits in bit buffer */
430 
431  /* make local bit buffer */
432  b = ZIP(bb);
433  k = ZIP(bk);
434  ll = ZIP(ll);
435 
436  /* read in table lengths */
437  ZIPNEEDBITS(5)
438  nl = 257 + (b & 0x1f); /* number of literal/length codes */
439  ZIPDUMPBITS(5)
440  ZIPNEEDBITS(5)
441  nd = 1 + (b & 0x1f); /* number of distance codes */
442  ZIPDUMPBITS(5)
443  ZIPNEEDBITS(4)
444  nb = 4 + (b & 0xf); /* number of bit length codes */
445  ZIPDUMPBITS(4)
446  if(nl > 288 || nd > 32)
447  return 1; /* bad lengths */
448 
449  /* read in bit-length-code lengths */
450  for(j = 0; j < nb; j++)
451  {
452  ZIPNEEDBITS(3)
453  ll[Zipborder[j]] = b & 7;
454  ZIPDUMPBITS(3)
455  }
456  for(; j < 19; j++)
457  ll[Zipborder[j]] = 0;
458 
459  /* build decoding table for trees--single level, 7 bit lookup */
460  bl = 7;
461  if((i = fdi_Ziphuft_build(ll, 19, 19, NULL, NULL, &tl, &bl, decomp_state)) != 0)
462  {
463  if(i == 1)
464  fdi_Ziphuft_free(CAB(hfdi), tl);
465  return i; /* incomplete code set */
466  }
467 
468  /* read in literal and distance code lengths */
469  n = nl + nd;
470  m = Zipmask[bl];
471  i = l = 0;
472  while((cab_ULONG)i < n)
473  {
475  j = (td = tl + (b & m))->b;
476  ZIPDUMPBITS(j)
477  j = td->v.n;
478  if (j < 16) /* length of code in bits (0..15) */
479  ll[i++] = l = j; /* save last length in l */
480  else if (j == 16) /* repeat last length 3 to 6 times */
481  {
482  ZIPNEEDBITS(2)
483  j = 3 + (b & 3);
484  ZIPDUMPBITS(2)
485  if((cab_ULONG)i + j > n)
486  return 1;
487  while (j--)
488  ll[i++] = l;
489  }
490  else if (j == 17) /* 3 to 10 zero length codes */
491  {
492  ZIPNEEDBITS(3)
493  j = 3 + (b & 7);
494  ZIPDUMPBITS(3)
495  if ((cab_ULONG)i + j > n)
496  return 1;
497  while (j--)
498  ll[i++] = 0;
499  l = 0;
500  }
501  else /* j == 18: 11 to 138 zero length codes */
502  {
503  ZIPNEEDBITS(7)
504  j = 11 + (b & 0x7f);
505  ZIPDUMPBITS(7)
506  if ((cab_ULONG)i + j > n)
507  return 1;
508  while (j--)
509  ll[i++] = 0;
510  l = 0;
511  }
512  }
513 
514  /* free decoding table for trees */
515  fdi_Ziphuft_free(CAB(hfdi), tl);
516 
517  /* restore the global bit buffer */
518  ZIP(bb) = b;
519  ZIP(bk) = k;
520 
521  /* build the decoding tables for literal/length and distance codes */
522  bl = ZIPLBITS;
523  if((i = fdi_Ziphuft_build(ll, nl, 257, Zipcplens, Zipcplext, &tl, &bl, decomp_state)) != 0)
524  {
525  if(i == 1)
526  fdi_Ziphuft_free(CAB(hfdi), tl);
527  return i; /* incomplete code set */
528  }
529  bd = ZIPDBITS;
530  fdi_Ziphuft_build(ll + nl, nd, 0, Zipcpdist, Zipcpdext, &td, &bd, decomp_state);
531 
532  /* decompress until an end-of-block code */
533  if(fdi_Zipinflate_codes(tl, td, bl, bd, decomp_state))
534  return 1;
535 
536  /* free the decoding tables, return */
537  fdi_Ziphuft_free(CAB(hfdi), tl);
538  fdi_Ziphuft_free(CAB(hfdi), td);
539  return 0;
540 }
541 
542 /*****************************************************
543  * fdi_Zipinflate_block (internal)
544  */
545 static cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state) /* e == last block flag */
546 { /* decompress an inflated block */
547  cab_ULONG t; /* block type */
548  register cab_ULONG b; /* bit buffer */
549  register cab_ULONG k; /* number of bits in bit buffer */
550 
551  /* make local bit buffer */
552  b = ZIP(bb);
553  k = ZIP(bk);
554 
555  /* read in last block bit */
556  ZIPNEEDBITS(1)
557  *e = (cab_LONG)b & 1;
558  ZIPDUMPBITS(1)
559 
560  /* read in block type */
561  ZIPNEEDBITS(2)
562  t = b & 3;
563  ZIPDUMPBITS(2)
564 
565  /* restore the global bit buffer */
566  ZIP(bb) = b;
567  ZIP(bk) = k;
568 
569  /* inflate that block type */
570  if(t == 2)
571  return fdi_Zipinflate_dynamic(decomp_state);
572  if(t == 0)
573  return fdi_Zipinflate_stored(decomp_state);
574  if(t == 1)
575  return fdi_Zipinflate_fixed(decomp_state);
576  /* bad block type */
577  return 2;
578 }
579 
580 /****************************************************
581  * ZIPfdi_decomp(internal)
582  */
583 static int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
584 {
585  cab_LONG e; /* last block flag */
586 
587  TRACE("(inlen == %d, outlen == %d)\n", inlen, outlen);
588 
589  ZIP(inpos) = CAB(inbuf);
590  ZIP(bb) = ZIP(bk) = ZIP(window_posn) = 0;
591 
592  if(outlen > ZIPWSIZE)
593  return DECR_DATAFORMAT;
594 
595  /* CK = Chris Kirmse, official Microsoft purloiner */
596  if(ZIP(inpos)[0] != 0x43 || ZIP(inpos)[1] != 0x4B)
597  return DECR_ILLEGALDATA;
598 
599  ZIP(inpos) += 2;
600 
601  do {
602  if(fdi_Zipinflate_block(&e, decomp_state))
603  return DECR_ILLEGALDATA;
604  } while(!e);
605 
606  /* return success */
607  return DECR_OK;
608 }
609 
610 static void * __cdecl fdi_alloc(ULONG cb)
611 {
612  return HeapAlloc(GetProcessHeap(), 0, cb);
613 }
614 
615 static void __cdecl fdi_free(void *pv)
616 {
617  HeapFree(GetProcessHeap(), 0, pv);
618 }
619 
620 int mszip_decompress(unsigned int inlen, unsigned int outlen, char* inbuffer, char* outbuffer)
621 {
622  int ret;
623  fdi_decomp_state decomp_state;
624  FDI_Int fdi;
625 
626  TRACE("(%u, %u, %p, %p)\n", inlen, outlen, inbuffer, outbuffer);
627 
628  if ((inlen > CAB_INPUTMAX) || (outlen > CAB_BLOCKMAX))
629  {
630  FIXME("Big file not supported yet (inlen = %u, outlen = %u)\n", inlen, outlen);
631  return DECR_DATAFORMAT;
632  }
633 
634  fdi.pfnalloc = fdi_alloc;
635  fdi.pfnfree = fdi_free;
636  decomp_state.hfdi = (void*)&fdi;
637 
638  memcpy(decomp_state.inbuf, inbuffer, inlen);
639 
640  ret = ZIPfdi_decomp(inlen, outlen, &decomp_state);
641 
642  memcpy(outbuffer, decomp_state.outbuf, outlen);
643 
644  return ret;
645 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define CAB(x)
Definition: mszip.h:77
#define ZIPWSIZE
Definition: mszip.h:49
const unsigned char * inbuffer
Definition: jpeglib.h:982
#define max(a, b)
Definition: svc.c:63
#define PFDI_ALLOC(hfdi, size)
Definition: mszip.h:45
static cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state)
Definition: mszip.c:545
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
WINE_DEFAULT_DEBUG_CHANNEL(d3dxof)
#define __cdecl
Definition: accygwin.h:79
static cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state)
Definition: mszip.c:368
int mszip_decompress(unsigned int inlen, unsigned int outlen, char *inbuffer, char *outbuffer)
Definition: mszip.c:620
cab_UBYTE inbuf[CAB_INPUTMAX+2]
Definition: mszip.h:102
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define DECR_ILLEGALDATA
Definition: mszip.h:81
GLdouble n
Definition: glext.h:7729
GLdouble GLdouble t
Definition: gl.h:2047
Definition: mszip.h:30
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
const uInt fixed_bl
Definition: inffixed.h:10
UINT16 cab_UWORD
Definition: mszip.h:26
const GLfloat * m
Definition: glext.h:10848
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
const inflate_huft fixed_td[]
Definition: inffixed.h:142
#define ZIP(x)
Definition: mszip.h:78
#define DECR_OK
Definition: mszip.h:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
INT32 cab_LONG
Definition: mszip.h:28
UINT32 cab_ULONG
Definition: mszip.h:27
#define a
Definition: ke_i.h:78
#define e
Definition: ke_i.h:82
#define PFDI_FREE(hfdi, ptr)
Definition: mszip.h:46
#define FIXME(fmt,...)
Definition: debug.h:110
THOSE_ZIP_CONSTS
Definition: mszip.c:35
#define ZIPDBITS
Definition: mszip.h:51
GLdouble GLdouble z
Definition: glext.h:5874
smooth NULL
Definition: ftsmooth.c:416
#define b
Definition: ke_i.h:79
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
r l[0]
Definition: byte_order.h:167
GLboolean GLboolean g
Definition: glext.h:6204
GLfloat f
Definition: glext.h:7540
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define TRACE(s)
Definition: solgame.cpp:4
PFNALLOC pfnalloc
Definition: mszip.h:32
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define d
Definition: ke_i.h:81
if(!(yy_init))
Definition: macro.lex.yy.c:714
Definition: mszip.h:55
const GLubyte * c
Definition: glext.h:8905
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
static DWORD cb
Definition: integrity.c:41
const uInt fixed_bd
Definition: inffixed.h:11
uchar inbuf[M_BLOCK]
Definition: unzcrash.c:40
PFNFREE pfnfree
Definition: mszip.h:33
unsigned char cab_UBYTE
Definition: mszip.h:25
int ret
cab_UBYTE outbuf[CAB_BLOCKMAX]
Definition: mszip.h:103
void * hfdi
Definition: mszip.h:101
static cab_LONG fdi_Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, const cab_UWORD *d, const cab_UWORD *e, struct Ziphuft **t, cab_LONG *m, fdi_decomp_state *decomp_state)
Definition: mszip.c:57
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLdouble s
Definition: gl.h:2039
#define ZIPLBITS
Definition: mszip.h:50
static void *__cdecl fdi_alloc(ULONG cb)
Definition: mszip.c:610
#define CAB_INPUTMAX
Definition: mszip.h:98
static cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state)
Definition: mszip.c:412
const GLdouble * v
Definition: gl.h:2040
union Ziphuft::@243 v
#define ZIPNEEDBITS(n)
Definition: mszip.h:88
#define f
Definition: ke_i.h:83
static int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
Definition: mszip.c:583
w ll
Definition: byte_order.h:166
#define min(a, b)
Definition: monoChain.cc:55
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define ZIPDUMPBITS(n)
Definition: mszip.h:90
static cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state)
Definition: mszip.c:324
unsigned int ULONG
Definition: retypes.h:1
#define DECR_DATAFORMAT
Definition: mszip.h:80
static void __cdecl fdi_free(void *pv)
Definition: mszip.c:615
static void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t)
Definition: mszip.c:40
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
#define ZIPBMAX
Definition: mszip.h:52
GLfloat GLfloat p
Definition: glext.h:8902
const inflate_huft fixed_tl[]
Definition: inffixed.h:12
#define md
Definition: compat-1.3.h:1989
int k
Definition: mpi.c:3369
#define HeapFree(x, y, z)
Definition: compat.h:394
#define CAB_BLOCKMAX
Definition: mszip.h:97
uchar outbuf[M_BLOCK_OUT]
Definition: unzcrash.c:41
cab_UWORD n
Definition: mszip.h:59
static cab_LONG fdi_Zipinflate_codes(const struct Ziphuft *tl, const struct Ziphuft *td, cab_LONG bl, cab_LONG bd, fdi_decomp_state *decomp_state)
Definition: mszip.c:238