widl: Use the output buffer functions to write typelibs.
[wine] / dlls / d3dxof / mszip.c
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
33 WINE_DEFAULT_DEBUG_CHANNEL(d3dxof);
34
35 THOSE_ZIP_CONSTS;
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  */
57 static cab_LONG fdi_Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, const cab_UWORD *d, const cab_UWORD *e,
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   {
260     ZIPNEEDBITS((cab_ULONG)bl)
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 */
285       ZIPNEEDBITS((cab_ULONG)bd)
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  */
324 static cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state)
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  */
368 static cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state)
369 {
370   struct Ziphuft *fixed_tl;
371   struct Ziphuft *fixed_td;
372   cab_LONG fixed_bl, fixed_bd;
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 */
402   i = fdi_Zipinflate_codes(fixed_tl, fixed_td, fixed_bl, fixed_bd, decomp_state);
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  */
412 static cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state)
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   {
474     ZIPNEEDBITS((cab_ULONG)bl)
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 }