gdiplus: Always treat out of range string sizes as INT_MAX.
[wine] / dlls / iccvid / iccvid.c
1 /*
2  * Radius Cinepak Video Decoder
3  *
4  * Copyright 2001 Dr. Tim Ferguson (see below)
5  * Portions Copyright 2003 Mike McCormack for CodeWeavers
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 /* Copyright notice from original source:
23  * ------------------------------------------------------------------------
24  * Radius Cinepak Video Decoder
25  *
26  * Dr. Tim Ferguson, 2001.
27  * For more details on the algorithm:
28  *         http://www.csse.monash.edu.au/~timf/videocodec.html
29  *
30  * This is basically a vector quantiser with adaptive vector density.  The
31  * frame is segmented into 4x4 pixel blocks, and each block is coded using
32  * either 1 or 4 vectors.
33  *
34  * There are still some issues with this code yet to be resolved.  In
35  * particular with decoding in the strip boundaries.  However, I have not
36  * yet found a sequence it doesn't work on.  Ill keep trying :)
37  *
38  * You may freely use this source code.  I only ask that you reference its
39  * source in your projects documentation:
40  *       Tim Ferguson: http://www.csse.monash.edu.au/~timf/
41  * ------------------------------------------------------------------------ */
42
43 #include <stdarg.h>
44 #include "windef.h"
45 #include "winbase.h"
46 #include "wingdi.h"
47 #include "winuser.h"
48 #include "commdlg.h"
49 #include "vfw.h"
50 #include "mmsystem.h"
51 #include "iccvid_private.h"
52
53 #include "wine/debug.h"
54
55 WINE_DEFAULT_DEBUG_CHANNEL(iccvid);
56
57 static HINSTANCE ICCVID_hModule;
58
59 #define ICCVID_MAGIC mmioFOURCC('c', 'v', 'i', 'd')
60 #define compare_fourcc(fcc1, fcc2) (((fcc1)^(fcc2))&~0x20202020)
61
62 #define DBUG    0
63 #define MAX_STRIPS 32
64
65 /* ------------------------------------------------------------------------ */
66 typedef struct
67 {
68     unsigned char y0, y1, y2, y3;
69     char u, v;
70     unsigned char r[4], g[4], b[4];
71 } cvid_codebook;
72
73 typedef struct {
74     cvid_codebook *v4_codebook[MAX_STRIPS];
75     cvid_codebook *v1_codebook[MAX_STRIPS];
76     unsigned int strip_num;
77 } cinepak_info;
78
79 typedef struct _ICCVID_Info
80 {
81     DWORD         dwMagic;
82     int           bits_per_pixel;
83     cinepak_info *cvinfo;
84 } ICCVID_Info;
85
86 static inline LPVOID heap_alloc( size_t size )
87 {
88     return HeapAlloc( GetProcessHeap(), 0, size );
89 }
90
91 static inline BOOL heap_free( LPVOID ptr )
92 {
93     return HeapFree( GetProcessHeap(), 0, ptr );
94 }
95
96
97 /* ------------------------------------------------------------------------ */
98 static unsigned char *in_buffer, uiclip[1024], *uiclp = NULL;
99
100 #define get_byte() *(in_buffer++)
101 #define skip_byte() in_buffer++
102 #define get_word() ((unsigned short)(in_buffer += 2, \
103     (in_buffer[-2] << 8 | in_buffer[-1])))
104 #define get_long() ((unsigned long)(in_buffer += 4, \
105     (in_buffer[-4] << 24 | in_buffer[-3] << 16 | in_buffer[-2] << 8 | in_buffer[-1])))
106
107
108 /* ---------------------------------------------------------------------- */
109 static inline void read_codebook(cvid_codebook *c, int mode)
110 {
111 int uvr, uvg, uvb;
112
113     if(mode)        /* black and white */
114         {
115         c->y0 = get_byte();
116         c->y1 = get_byte();
117         c->y2 = get_byte();
118         c->y3 = get_byte();
119         c->u = c->v = 0;
120
121         c->r[0] = c->g[0] = c->b[0] = c->y0;
122         c->r[1] = c->g[1] = c->b[1] = c->y1;
123         c->r[2] = c->g[2] = c->b[2] = c->y2;
124         c->r[3] = c->g[3] = c->b[3] = c->y3;
125         }
126     else            /* colour */
127         {
128         c->y0 = get_byte();  /* luma */
129         c->y1 = get_byte();
130         c->y2 = get_byte();
131         c->y3 = get_byte();
132         c->u = get_byte(); /* chroma */
133         c->v = get_byte();
134
135         uvr = c->v << 1;
136         uvg = -((c->u+1) >> 1) - c->v;
137         uvb = c->u << 1;
138
139         c->r[0] = uiclp[c->y0 + uvr]; c->g[0] = uiclp[c->y0 + uvg]; c->b[0] = uiclp[c->y0 + uvb];
140         c->r[1] = uiclp[c->y1 + uvr]; c->g[1] = uiclp[c->y1 + uvg]; c->b[1] = uiclp[c->y1 + uvb];
141         c->r[2] = uiclp[c->y2 + uvr]; c->g[2] = uiclp[c->y2 + uvg]; c->b[2] = uiclp[c->y2 + uvb];
142         c->r[3] = uiclp[c->y3 + uvr]; c->g[3] = uiclp[c->y3 + uvg]; c->b[3] = uiclp[c->y3 + uvb];
143         }
144 }
145
146
147 #define MAKECOLOUR32(r,g,b) (((r) << 16) | ((g) << 8) | (b))
148 /*#define MAKECOLOUR24(r,g,b) (((r) << 16) | ((g) << 8) | (b))*/
149 #define MAKECOLOUR16(r,g,b) (((r) >> 3) << 11)| (((g) >> 2) << 5)| (((b) >> 3) << 0)
150 #define MAKECOLOUR15(r,g,b) (((r) >> 3) << 10)| (((g) >> 3) << 5)| (((b) >> 3) << 0)
151
152 /* ------------------------------------------------------------------------ */
153 static void cvid_v1_32(unsigned char *frm, unsigned char *limit, int stride, cvid_codebook *cb)
154 {
155 unsigned long *vptr = (unsigned long *)frm;
156 #ifndef ORIGINAL
157 int row_inc = -stride/4;
158 #else
159 int row_inc = stride/4;
160 #endif
161 int x, y;
162
163     /* fill 4x4 block of pixels with colour values from codebook */
164     for (y = 0; y < 4; y++)
165     {
166         if (&vptr[y*row_inc] < (unsigned long *)limit) return;
167         for (x = 0; x < 4; x++)
168             vptr[y*row_inc + x] = MAKECOLOUR32(cb->r[x/2+(y/2)*2], cb->g[x/2+(y/2)*2], cb->b[x/2+(y/2)*2]);
169     }
170 }
171
172
173 /* ------------------------------------------------------------------------ */
174 static void cvid_v4_32(unsigned char *frm, unsigned char *limit, int stride, cvid_codebook *cb0,
175     cvid_codebook *cb1, cvid_codebook *cb2, cvid_codebook *cb3)
176 {
177 unsigned long *vptr = (unsigned long *)frm;
178 #ifndef ORIGINAL
179 int row_inc = -stride/4;
180 #else
181 int row_inc = stride/4;
182 #endif
183 int x, y;
184 cvid_codebook * cb[] = {cb0,cb1,cb2,cb3};
185
186     /* fill 4x4 block of pixels with colour values from codebooks */
187     for (y = 0; y < 4; y++)
188     {
189         if (&vptr[y*row_inc] < (unsigned long *)limit) return;
190         for (x = 0; x < 4; x++)
191             vptr[y*row_inc + x] = MAKECOLOUR32(cb[x/2+(y/2)*2]->r[x%2+(y%2)*2], cb[x/2+(y/2)*2]->g[x%2+(y%2)*2], cb[x/2+(y/2)*2]->b[x%2+(y%2)*2]);
192     }
193 }
194
195
196 /* ------------------------------------------------------------------------ */
197 static void cvid_v1_24(unsigned char *vptr, unsigned char *limit, int stride, cvid_codebook *cb)
198 {
199 #ifndef ORIGINAL
200 int row_inc = -stride;
201 #else
202 int row_inc = stride;
203 #endif
204 int x, y;
205
206     /* fill 4x4 block of pixels with colour values from codebook */
207     for (y = 0; y < 4; y++)
208     {
209         if (&vptr[y*row_inc] < limit) return;
210         for (x = 0; x < 4; x++)
211         {
212             vptr[y*row_inc + x*3 + 0] = cb->b[x/2+(y/2)*2];
213             vptr[y*row_inc + x*3 + 1] = cb->g[x/2+(y/2)*2];
214             vptr[y*row_inc + x*3 + 2] = cb->r[x/2+(y/2)*2];
215         }
216     }
217 }
218
219
220 /* ------------------------------------------------------------------------ */
221 static void cvid_v4_24(unsigned char *vptr, unsigned char *limit, int stride, cvid_codebook *cb0,
222     cvid_codebook *cb1, cvid_codebook *cb2, cvid_codebook *cb3)
223 {
224 #ifndef ORIGINAL
225 int row_inc = -stride;
226 #else
227 int row_inc = stride;
228 #endif
229 cvid_codebook * cb[] = {cb0,cb1,cb2,cb3};
230 int x, y;
231
232     /* fill 4x4 block of pixels with colour values from codebooks */
233     for (y = 0; y < 4; y++)
234     {
235         if (&vptr[y*row_inc] < limit) return;
236         for (x = 0; x < 4; x++)
237         {
238             vptr[y*row_inc + x*3 + 0] = cb[x/2+(y/2)*2]->b[x%2+(y%2)*2];
239             vptr[y*row_inc + x*3 + 1] = cb[x/2+(y/2)*2]->g[x%2+(y%2)*2];
240             vptr[y*row_inc + x*3 + 2] = cb[x/2+(y/2)*2]->r[x%2+(y%2)*2];
241         }
242     }
243 }
244
245
246 /* ------------------------------------------------------------------------ */
247 static void cvid_v1_16(unsigned char *frm, unsigned char *limit, int stride, cvid_codebook *cb)
248 {
249 unsigned short *vptr = (unsigned short *)frm;
250 #ifndef ORIGINAL
251 int row_inc = -stride/2;
252 #else
253 int row_inc = stride/2;
254 #endif
255 int x, y;
256
257     /* fill 4x4 block of pixels with colour values from codebook */
258     for (y = 0; y < 4; y++)
259     {
260         if (&vptr[y*row_inc] < (unsigned short *)limit) return;
261         for (x = 0; x < 4; x++)
262             vptr[y*row_inc + x] = MAKECOLOUR16(cb->r[x/2+(y/2)*2], cb->g[x/2+(y/2)*2], cb->b[x/2+(y/2)*2]);
263     }
264 }
265
266
267 /* ------------------------------------------------------------------------ */
268 static void cvid_v4_16(unsigned char *frm, unsigned char *limit, int stride, cvid_codebook *cb0,
269     cvid_codebook *cb1, cvid_codebook *cb2, cvid_codebook *cb3)
270 {
271 unsigned short *vptr = (unsigned short *)frm;
272 #ifndef ORIGINAL
273 int row_inc = -stride/2;
274 #else
275 int row_inc = stride/2;
276 #endif
277 cvid_codebook * cb[] = {cb0,cb1,cb2,cb3};
278 int x, y;
279
280     /* fill 4x4 block of pixels with colour values from codebooks */
281     for (y = 0; y < 4; y++)
282     {
283         if (&vptr[y*row_inc] < (unsigned short *)limit) return;
284         for (x = 0; x < 4; x++)
285             vptr[y*row_inc + x] = MAKECOLOUR16(cb[x/2+(y/2)*2]->r[x%2+(y%2)*2], cb[x/2+(y/2)*2]->g[x%2+(y%2)*2], cb[x/2+(y/2)*2]->b[x%2+(y%2)*2]);
286     }
287 }
288
289 /* ------------------------------------------------------------------------ */
290 static void cvid_v1_15(unsigned char *frm, unsigned char *limit, int stride, cvid_codebook *cb)
291 {
292 unsigned short *vptr = (unsigned short *)frm;
293 #ifndef ORIGINAL
294 int row_inc = -stride/2;
295 #else
296 int row_inc = stride/2;
297 #endif
298 int x, y;
299
300     /* fill 4x4 block of pixels with colour values from codebook */
301     for (y = 0; y < 4; y++)
302     {
303         if (&vptr[y*row_inc] < (unsigned short *)limit) return;
304         for (x = 0; x < 4; x++)
305             vptr[y*row_inc + x] = MAKECOLOUR15(cb->r[x/2+(y/2)*2], cb->g[x/2+(y/2)*2], cb->b[x/2+(y/2)*2]);
306     }
307 }
308
309
310 /* ------------------------------------------------------------------------ */
311 static void cvid_v4_15(unsigned char *frm, unsigned char *limit, int stride, cvid_codebook *cb0,
312     cvid_codebook *cb1, cvid_codebook *cb2, cvid_codebook *cb3)
313 {
314 unsigned short *vptr = (unsigned short *)frm;
315 #ifndef ORIGINAL
316 int row_inc = -stride/2;
317 #else
318 int row_inc = stride/2;
319 #endif
320 cvid_codebook * cb[] = {cb0,cb1,cb2,cb3};
321 int x, y;
322
323     /* fill 4x4 block of pixels with colour values from codebooks */
324     for (y = 0; y < 4; y++)
325     {
326         if (&vptr[y*row_inc] < (unsigned short *)limit) return;
327         for (x = 0; x < 4; x++)
328             vptr[y*row_inc + x] = MAKECOLOUR15(cb[x/2+(y/2)*2]->r[x%2+(y%2)*2], cb[x/2+(y/2)*2]->g[x%2+(y%2)*2], cb[x/2+(y/2)*2]->b[x%2+(y%2)*2]);
329     }
330 }
331
332
333 /* ------------------------------------------------------------------------
334  * Call this function once at the start of the sequence and save the
335  * returned context for calls to decode_cinepak().
336  */
337 static cinepak_info *decode_cinepak_init(void)
338 {
339     cinepak_info *cvinfo;
340     int i;
341
342     cvinfo = heap_alloc( sizeof (cinepak_info) );
343     if( !cvinfo )
344         return NULL;
345     cvinfo->strip_num = 0;
346
347     if(uiclp == NULL)
348     {
349         uiclp = uiclip+512;
350         for(i = -512; i < 512; i++)
351             uiclp[i] = (i < 0 ? 0 : (i > 255 ? 255 : i));
352     }
353
354     return cvinfo;
355 }
356
357 static void free_cvinfo( cinepak_info *cvinfo )
358 {
359     unsigned int i;
360
361     for( i=0; i<cvinfo->strip_num; i++ )
362     {
363         heap_free(cvinfo->v4_codebook[i]);
364         heap_free(cvinfo->v1_codebook[i]);
365     }
366     heap_free( cvinfo );
367 }
368
369 typedef void (*fn_cvid_v1)(unsigned char *frm, unsigned char *limit,
370                            int stride, cvid_codebook *cb);
371 typedef void (*fn_cvid_v4)(unsigned char *frm, unsigned char *limit, int stride,
372                            cvid_codebook *cb0, cvid_codebook *cb1,
373                            cvid_codebook *cb2, cvid_codebook *cb3);
374
375 /* ------------------------------------------------------------------------
376  * This function decodes a buffer containing a Cinepak encoded frame.
377  *
378  * context - the context created by decode_cinepak_init().
379  * buf - the input buffer to be decoded
380  * size - the size of the input buffer
381  * frame - the output frame buffer (24 or 32 bit per pixel)
382  * width - the width of the output frame
383  * height - the height of the output frame
384  * bit_per_pixel - the number of bits per pixel allocated to the output
385  *   frame (only 24 or 32 bpp are supported)
386  */
387 static void decode_cinepak(cinepak_info *cvinfo, unsigned char *buf, int size,
388            unsigned char *frame, unsigned int width, unsigned int height, int bit_per_pixel)
389 {
390     cvid_codebook *v4_codebook, *v1_codebook, *codebook = NULL;
391     unsigned long x, y, y_bottom, frame_flags, strips, cv_width, cv_height,
392                   cnum, strip_id, chunk_id, x0, y0, x1, y1, ci, flag, mask;
393     long len, top_size, chunk_size;
394     unsigned char *frm_ptr;
395     unsigned int i, cur_strip;
396     int d0, d1, d2, d3, frm_stride, bpp = 3;
397     fn_cvid_v1 cvid_v1 = cvid_v1_24;
398     fn_cvid_v4 cvid_v4 = cvid_v4_24;
399
400     y = 0;
401     y_bottom = 0;
402     in_buffer = buf;
403
404     frame_flags = get_byte();
405     len = get_byte() << 16;
406     len |= get_byte() << 8;
407     len |= get_byte();
408
409     switch(bit_per_pixel)
410         {
411         case 15:
412             bpp = 2;
413             cvid_v1 = cvid_v1_15;
414             cvid_v4 = cvid_v4_15;
415             break;
416         case 16:
417             bpp = 2;
418             cvid_v1 = cvid_v1_16;
419             cvid_v4 = cvid_v4_16;
420             break;
421         case 24:
422             bpp = 3;
423             cvid_v1 = cvid_v1_24;
424             cvid_v4 = cvid_v4_24;
425             break;
426         case 32:
427             bpp = 4;
428             cvid_v1 = cvid_v1_32;
429             cvid_v4 = cvid_v4_32;
430             break;
431         }
432
433     frm_stride = width * bpp;
434     frm_ptr = frame;
435
436     if(len != size)
437         {
438         if(len & 0x01) len++; /* AVIs tend to have a size mismatch */
439         if(len != size)
440             {
441             ERR("CVID: corruption %d (QT/AVI) != %ld (CV)\n", size, len);
442             /* return; */
443             }
444         }
445
446     cv_width = get_word();
447     cv_height = get_word();
448     strips = get_word();
449
450     if(strips > cvinfo->strip_num)
451         {
452         if(strips >= MAX_STRIPS)
453             {
454             ERR("CVID: strip overflow (more than %d)\n", MAX_STRIPS);
455             return;
456             }
457
458         for(i = cvinfo->strip_num; i < strips; i++)
459             {
460             if((cvinfo->v4_codebook[i] = heap_alloc(sizeof(cvid_codebook) * 260)) == NULL)
461                 {
462                 ERR("CVID: codebook v4 alloc err\n");
463                 return;
464                 }
465
466             if((cvinfo->v1_codebook[i] = heap_alloc(sizeof(cvid_codebook) * 260)) == NULL)
467                 {
468                 ERR("CVID: codebook v1 alloc err\n");
469                 return;
470                 }
471             }
472         }
473     cvinfo->strip_num = strips;
474
475     TRACE("CVID: <%ld,%ld> strips %ld\n", cv_width, cv_height, strips);
476
477     for(cur_strip = 0; cur_strip < strips; cur_strip++)
478         {
479         v4_codebook = cvinfo->v4_codebook[cur_strip];
480         v1_codebook = cvinfo->v1_codebook[cur_strip];
481
482         if((cur_strip > 0) && (!(frame_flags & 0x01)))
483             {
484             memcpy(cvinfo->v4_codebook[cur_strip], cvinfo->v4_codebook[cur_strip-1], 260 * sizeof(cvid_codebook));
485             memcpy(cvinfo->v1_codebook[cur_strip], cvinfo->v1_codebook[cur_strip-1], 260 * sizeof(cvid_codebook));
486             }
487
488         strip_id = get_word();        /* 1000 = key strip, 1100 = iter strip */
489         top_size = get_word();
490         y0 = get_word();        /* FIXME: most of these are ignored at the moment */
491         x0 = get_word();
492         y1 = get_word();
493         x1 = get_word();
494
495         y_bottom += y1;
496         top_size -= 12;
497         x = 0;
498         if(x1 != width)
499             WARN("CVID: Warning x1 (%ld) != width (%d)\n", x1, width);
500
501         TRACE("   %d) %04lx %04ld <%ld,%ld> <%ld,%ld> yt %ld\n",
502               cur_strip, strip_id, top_size, x0, y0, x1, y1, y_bottom);
503
504         while(top_size > 0)
505             {
506             chunk_id  = get_word();
507             chunk_size = get_word();
508
509             TRACE("        %04lx %04ld\n", chunk_id, chunk_size);
510             top_size -= chunk_size;
511             chunk_size -= 4;
512
513             switch(chunk_id)
514                 {
515                     /* -------------------- Codebook Entries -------------------- */
516                 case 0x2000:
517                 case 0x2200:
518                     codebook = (chunk_id == 0x2200 ? v1_codebook : v4_codebook);
519                     cnum = chunk_size/6;
520                     for(i = 0; i < cnum; i++) read_codebook(codebook+i, 0);
521                     break;
522
523                 case 0x2400:
524                 case 0x2600:        /* 8 bit per pixel */
525                     codebook = (chunk_id == 0x2600 ? v1_codebook : v4_codebook);
526                     cnum = chunk_size/4;
527                     for(i = 0; i < cnum; i++) read_codebook(codebook+i, 1);
528                     break;
529
530                 case 0x2100:
531                 case 0x2300:
532                     codebook = (chunk_id == 0x2300 ? v1_codebook : v4_codebook);
533
534                     ci = 0;
535                     while(chunk_size > 0)
536                         {
537                         flag = get_long();
538                         chunk_size -= 4;
539
540                         for(i = 0; i < 32; i++)
541                             {
542                             if(flag & 0x80000000)
543                                 {
544                                 chunk_size -= 6;
545                                 read_codebook(codebook+ci, 0);
546                                 }
547
548                             ci++;
549                             flag <<= 1;
550                             }
551                         }
552                     while(chunk_size > 0) { skip_byte(); chunk_size--; }
553                     break;
554
555                 case 0x2500:
556                 case 0x2700:        /* 8 bit per pixel */
557                     codebook = (chunk_id == 0x2700 ? v1_codebook : v4_codebook);
558
559                     ci = 0;
560                     while(chunk_size > 0)
561                         {
562                         flag = get_long();
563                         chunk_size -= 4;
564
565                         for(i = 0; i < 32; i++)
566                             {
567                             if(flag & 0x80000000)
568                                 {
569                                 chunk_size -= 4;
570                                 read_codebook(codebook+ci, 1);
571                                 }
572
573                             ci++;
574                             flag <<= 1;
575                             }
576                         }
577                     while(chunk_size > 0) { skip_byte(); chunk_size--; }
578                     break;
579
580                     /* -------------------- Frame -------------------- */
581                 case 0x3000:
582                     while((chunk_size > 0) && (y < y_bottom))
583                         {
584                         flag = get_long();
585                         chunk_size -= 4;
586
587                         for(i = 0; i < 32; i++)
588                             {
589                             if(y >= y_bottom) break;
590                             if(flag & 0x80000000)    /* 4 bytes per block */
591                                 {
592                                 d0 = get_byte();
593                                 d1 = get_byte();
594                                 d2 = get_byte();
595                                 d3 = get_byte();
596                                 chunk_size -= 4;
597 #ifdef ORIGINAL
598                                 cvid_v4(frm_ptr + (y * frm_stride + x * bpp), frm_end, frm_stride, v4_codebook+d0, v4_codebook+d1, v4_codebook+d2, v4_codebook+d3);
599 #else
600                                 cvid_v4(frm_ptr + ((height - 1 - y) * frm_stride + x * bpp), frame, frm_stride, v4_codebook+d0, v4_codebook+d1, v4_codebook+d2, v4_codebook+d3);
601 #endif
602                                 }
603                             else        /* 1 byte per block */
604                                 {
605 #ifdef ORIGINAL
606                                 cvid_v1(frm_ptr + (y * frm_stride + x * bpp), frm_end, frm_stride, v1_codebook + get_byte());
607 #else
608                                 cvid_v1(frm_ptr + ((height - 1 - y) * frm_stride + x * bpp), frame, frm_stride, v1_codebook + get_byte());
609 #endif
610                                 chunk_size--;
611                                 }
612
613                             x += 4;
614                             if(x >= width)
615                                 {
616                                 x = 0;
617                                 y += 4;
618                                 }
619                             flag <<= 1;
620                             }
621                         }
622                     while(chunk_size > 0) { skip_byte(); chunk_size--; }
623                     break;
624
625                 case 0x3100:
626                     while((chunk_size > 0) && (y < y_bottom))
627                         {
628                             /* ---- flag bits: 0 = SKIP, 10 = V1, 11 = V4 ---- */
629                         flag = get_long();
630                         chunk_size -= 4;
631                         mask = 0x80000000;
632
633                         while((mask) && (y < y_bottom))
634                             {
635                             if(flag & mask)
636                                 {
637                                 if(mask == 1)
638                                     {
639                                     if(chunk_size < 0) break;
640                                     flag = get_long();
641                                     chunk_size -= 4;
642                                     mask = 0x80000000;
643                                     }
644                                 else mask >>= 1;
645
646                                 if(flag & mask)        /* V4 */
647                                     {
648                                     d0 = get_byte();
649                                     d1 = get_byte();
650                                     d2 = get_byte();
651                                     d3 = get_byte();
652                                     chunk_size -= 4;
653 #ifdef ORIGINAL
654                                     cvid_v4(frm_ptr + (y * frm_stride + x * bpp), frm_end, frm_stride, v4_codebook+d0, v4_codebook+d1, v4_codebook+d2, v4_codebook+d3);
655 #else
656                                     cvid_v4(frm_ptr + ((height - 1 - y) * frm_stride + x * bpp), frame, frm_stride, v4_codebook+d0, v4_codebook+d1, v4_codebook+d2, v4_codebook+d3);
657 #endif
658                                     }
659                                 else        /* V1 */
660                                     {
661                                     chunk_size--;
662 #ifdef ORIGINAL
663                                     cvid_v1(frm_ptr + (y * frm_stride + x * bpp), frm_end, frm_stride, v1_codebook + get_byte());
664 #else
665                                     cvid_v1(frm_ptr + ((height - 1 - y) * frm_stride + x * bpp), frame, frm_stride, v1_codebook + get_byte());
666 #endif
667                                     }
668                                 }        /* else SKIP */
669
670                             mask >>= 1;
671                             x += 4;
672                             if(x >= width)
673                                 {
674                                 x = 0;
675                                 y += 4;
676                                 }
677                             }
678                         }
679
680                     while(chunk_size > 0) { skip_byte(); chunk_size--; }
681                     break;
682
683                 case 0x3200:        /* each byte is a V1 codebook */
684                     while((chunk_size > 0) && (y < y_bottom))
685                         {
686 #ifdef ORIGINAL
687                         cvid_v1(frm_ptr + (y * frm_stride + x * bpp), frm_end, frm_stride, v1_codebook + get_byte());
688 #else
689                         cvid_v1(frm_ptr + ((height - 1 - y) * frm_stride + x * bpp), frame, frm_stride, v1_codebook + get_byte());
690 #endif
691                         chunk_size--;
692                         x += 4;
693                         if(x >= width)
694                             {
695                             x = 0;
696                             y += 4;
697                             }
698                         }
699                     while(chunk_size > 0) { skip_byte(); chunk_size--; }
700                     break;
701
702                 default:
703                     ERR("CVID: unknown chunk_id %08lx\n", chunk_id);
704                     while(chunk_size > 0) { skip_byte(); chunk_size--; }
705                     break;
706                 }
707             }
708         }
709
710     if(len != size)
711         {
712         if(len & 0x01) len++; /* AVIs tend to have a size mismatch */
713         if(len != size)
714             {
715             long xlen;
716             skip_byte();
717             xlen = get_byte() << 16;
718             xlen |= get_byte() << 8;
719             xlen |= get_byte(); /* Read Len */
720             WARN("CVID: END INFO chunk size %d cvid size1 %ld cvid size2 %ld\n",
721                   size, len, xlen);
722             }
723         }
724 }
725
726 static void ICCVID_dump_BITMAPINFO(const BITMAPINFO * bmi)
727 {
728     TRACE(
729         "planes = %d\n"
730         "bpp    = %d\n"
731         "height = %d\n"
732         "width  = %d\n"
733         "compr  = %s\n",
734         bmi->bmiHeader.biPlanes,
735         bmi->bmiHeader.biBitCount,
736         bmi->bmiHeader.biHeight,
737         bmi->bmiHeader.biWidth,
738         debugstr_an( (const char *)&bmi->bmiHeader.biCompression, 4 ) );
739 }
740
741 static inline int ICCVID_CheckMask(RGBQUAD bmiColors[3], COLORREF redMask, COLORREF blueMask, COLORREF greenMask)
742 {
743     COLORREF realRedMask = MAKECOLOUR32(bmiColors[0].rgbRed, bmiColors[0].rgbGreen, bmiColors[0].rgbBlue);
744     COLORREF realBlueMask = MAKECOLOUR32(bmiColors[1].rgbRed, bmiColors[1].rgbGreen, bmiColors[1].rgbBlue);
745     COLORREF realGreenMask = MAKECOLOUR32(bmiColors[2].rgbRed, bmiColors[2].rgbGreen, bmiColors[2].rgbBlue);
746
747     TRACE("\nbmiColors[0] = 0x%08x\nbmiColors[1] = 0x%08x\nbmiColors[2] = 0x%08x\n",
748         realRedMask, realBlueMask, realGreenMask);
749         
750     if ((realRedMask == redMask) &&
751         (realBlueMask == blueMask) &&
752         (realGreenMask == greenMask))
753         return TRUE;
754     return FALSE;
755 }
756
757 static LRESULT ICCVID_DecompressQuery( ICCVID_Info *info, LPBITMAPINFO in, LPBITMAPINFO out )
758 {
759     TRACE("ICM_DECOMPRESS_QUERY %p %p %p\n", info, in, out);
760
761     if( (info==NULL) || (info->dwMagic!=ICCVID_MAGIC) )
762         return ICERR_BADPARAM;
763
764     TRACE("in: ");
765     ICCVID_dump_BITMAPINFO(in);
766
767     if( in->bmiHeader.biCompression != ICCVID_MAGIC )
768         return ICERR_BADFORMAT;
769
770     if( out )
771     {
772         TRACE("out: ");
773         ICCVID_dump_BITMAPINFO(out);
774
775         if( in->bmiHeader.biPlanes != out->bmiHeader.biPlanes )
776             return ICERR_BADFORMAT;
777         if( in->bmiHeader.biHeight != out->bmiHeader.biHeight )
778             return ICERR_BADFORMAT;
779         if( in->bmiHeader.biWidth != out->bmiHeader.biWidth )
780             return ICERR_BADFORMAT;
781
782         switch( out->bmiHeader.biBitCount )
783         {
784         case 16:
785             if ( out->bmiHeader.biCompression == BI_BITFIELDS )
786             {
787                 if ( !ICCVID_CheckMask(out->bmiColors, 0x7C00, 0x03E0, 0x001F) &&
788                      !ICCVID_CheckMask(out->bmiColors, 0xF800, 0x07E0, 0x001F) )
789                 {
790                     TRACE("unsupported output bit field(s) for 16-bit colors\n");
791                     return ICERR_BADFORMAT;
792                 }
793             }
794             break;
795         case 24:
796         case 32:
797             break;
798         default:
799             TRACE("unsupported output bitcount = %d\n", out->bmiHeader.biBitCount );
800             return ICERR_BADFORMAT;
801         }
802     }
803
804     return ICERR_OK;
805 }
806
807 static LRESULT ICCVID_DecompressGetFormat( ICCVID_Info *info, LPBITMAPINFO in, LPBITMAPINFO out )
808 {
809     DWORD size;
810
811     TRACE("ICM_DECOMPRESS_GETFORMAT %p %p %p\n", info, in, out);
812
813     if( (info==NULL) || (info->dwMagic!=ICCVID_MAGIC) )
814         return ICERR_BADPARAM;
815
816     size = in->bmiHeader.biSize;
817     if (in->bmiHeader.biBitCount <= 8)
818         size += in->bmiHeader.biClrUsed * sizeof(RGBQUAD);
819
820     if( out )
821     {
822         memcpy( out, in, size );
823         out->bmiHeader.biCompression = BI_RGB;
824         out->bmiHeader.biSizeImage = in->bmiHeader.biHeight
825                                    * in->bmiHeader.biWidth *4;
826         return ICERR_OK;
827     }
828     return size;
829 }
830
831 static LRESULT ICCVID_DecompressBegin( ICCVID_Info *info, LPBITMAPINFO in, LPBITMAPINFO out )
832 {
833     TRACE("ICM_DECOMPRESS_BEGIN %p %p %p\n", info, in, out);
834
835     if( (info==NULL) || (info->dwMagic!=ICCVID_MAGIC) )
836         return ICERR_BADPARAM;
837
838     info->bits_per_pixel = out->bmiHeader.biBitCount;
839
840     if (info->bits_per_pixel == 16)
841     {
842         if ( out->bmiHeader.biCompression == BI_BITFIELDS )
843         {
844             if ( ICCVID_CheckMask(out->bmiColors, 0x7C00, 0x03E0, 0x001F) )
845                 info->bits_per_pixel = 15;
846             else if ( ICCVID_CheckMask(out->bmiColors, 0xF800, 0x07E0, 0x001F) )
847                 info->bits_per_pixel = 16;
848             else
849             {
850                 TRACE("unsupported output bit field(s) for 16-bit colors\n");
851                 return ICERR_UNSUPPORTED;
852             }
853         }
854         else
855             info->bits_per_pixel = 15;
856     }
857
858     TRACE("bit_per_pixel = %d\n", info->bits_per_pixel);
859
860     if( info->cvinfo )
861         free_cvinfo( info->cvinfo );
862     info->cvinfo = decode_cinepak_init();
863
864     return ICERR_OK;
865 }
866
867 static LRESULT ICCVID_Decompress( ICCVID_Info *info, ICDECOMPRESS *icd, DWORD size )
868 {
869     LONG width, height;
870
871     TRACE("ICM_DECOMPRESS %p %p %d\n", info, icd, size);
872
873     if( (info==NULL) || (info->dwMagic!=ICCVID_MAGIC) )
874         return ICERR_BADPARAM;
875     if (info->cvinfo==NULL)
876     {
877         ERR("ICM_DECOMPRESS sent after ICM_DECOMPRESS_END\n");
878         return ICERR_BADPARAM;
879     }
880
881     width  = icd->lpbiInput->biWidth;
882     height = icd->lpbiInput->biHeight;
883
884     decode_cinepak(info->cvinfo, icd->lpInput, icd->lpbiInput->biSizeImage,
885                    icd->lpOutput, width, height, info->bits_per_pixel);
886
887     return ICERR_OK;
888 }
889
890 static LRESULT ICCVID_DecompressEx( ICCVID_Info *info, ICDECOMPRESSEX *icd, DWORD size )
891 {
892     LONG width, height;
893
894     TRACE("ICM_DECOMPRESSEX %p %p %d\n", info, icd, size);
895
896     if( (info==NULL) || (info->dwMagic!=ICCVID_MAGIC) )
897         return ICERR_BADPARAM;
898     if (info->cvinfo==NULL)
899     {
900         ERR("ICM_DECOMPRESSEX sent after ICM_DECOMPRESS_END\n");
901         return ICERR_BADPARAM;
902     }
903
904     /* FIXME: flags are ignored */
905
906     width  = icd->lpbiSrc->biWidth;
907     height = icd->lpbiSrc->biHeight;
908
909     decode_cinepak(info->cvinfo, icd->lpSrc, icd->lpbiSrc->biSizeImage,
910                    icd->lpDst, width, height, info->bits_per_pixel);
911
912     return ICERR_OK;
913 }
914
915 static LRESULT ICCVID_Close( ICCVID_Info *info )
916 {
917     if( (info==NULL) || (info->dwMagic!=ICCVID_MAGIC) )
918         return 0;
919     if( info->cvinfo )
920         free_cvinfo( info->cvinfo );
921     heap_free( info );
922     return 1;
923 }
924
925 static LRESULT ICCVID_GetInfo( ICCVID_Info *info, ICINFO *icinfo, DWORD dwSize )
926 {
927     if (!icinfo) return sizeof(ICINFO);
928     if (dwSize < sizeof(ICINFO)) return 0;
929
930     icinfo->dwSize = sizeof(ICINFO);
931     icinfo->fccType = ICTYPE_VIDEO;
932     icinfo->fccHandler = info ? info->dwMagic : ICCVID_MAGIC;
933     icinfo->dwFlags = 0;
934     icinfo->dwVersion = ICVERSION;
935     icinfo->dwVersionICM = ICVERSION;
936
937     LoadStringW(ICCVID_hModule, IDS_NAME, icinfo->szName, sizeof(icinfo->szName)/sizeof(WCHAR));
938     LoadStringW(ICCVID_hModule, IDS_DESCRIPTION, icinfo->szDescription, sizeof(icinfo->szDescription)/sizeof(WCHAR));
939     /* msvfw32 will fill icinfo->szDriver for us */
940
941     return sizeof(ICINFO);
942 }
943
944 static LRESULT ICCVID_DecompressEnd( ICCVID_Info *info )
945 {
946     if( info->cvinfo )
947     {
948         free_cvinfo( info->cvinfo );
949         info->cvinfo = NULL;
950     }
951     return ICERR_OK;
952 }
953
954 LRESULT WINAPI ICCVID_DriverProc( DWORD_PTR dwDriverId, HDRVR hdrvr, UINT msg,
955                                   LPARAM lParam1, LPARAM lParam2)
956 {
957     ICCVID_Info *info = (ICCVID_Info *) dwDriverId;
958
959     TRACE("%ld %p %d %ld %ld\n", dwDriverId, hdrvr, msg, lParam1, lParam2);
960
961     switch( msg )
962     {
963     case DRV_LOAD:
964         TRACE("Loaded\n");
965         return 1;
966     case DRV_ENABLE:
967         return 0;
968     case DRV_DISABLE:
969         return 0;
970     case DRV_FREE:
971         return 0;
972
973     case DRV_OPEN:
974     {
975         ICINFO *icinfo = (ICINFO *)lParam2;
976
977         TRACE("Opened\n");
978
979         if (icinfo && compare_fourcc(icinfo->fccType, ICTYPE_VIDEO)) return 0;
980
981         info = heap_alloc( sizeof (ICCVID_Info) );
982         if( info )
983         {
984             info->dwMagic = ICCVID_MAGIC;
985             info->cvinfo = NULL;
986         }
987         return (LRESULT) info;
988     }
989
990     case DRV_CLOSE:
991         return ICCVID_Close( info );
992
993     case ICM_GETINFO:
994         return ICCVID_GetInfo( info, (ICINFO *)lParam1, (DWORD)lParam2 );
995
996     case ICM_DECOMPRESS_QUERY:
997         return ICCVID_DecompressQuery( info, (LPBITMAPINFO) lParam1,
998                                        (LPBITMAPINFO) lParam2 );
999     case ICM_DECOMPRESS_GET_FORMAT:
1000         return ICCVID_DecompressGetFormat( info, (LPBITMAPINFO) lParam1,
1001                                        (LPBITMAPINFO) lParam2 );
1002     case ICM_DECOMPRESS_BEGIN:
1003         return ICCVID_DecompressBegin( info, (LPBITMAPINFO) lParam1,
1004                                        (LPBITMAPINFO) lParam2 );
1005     case ICM_DECOMPRESS:
1006         return ICCVID_Decompress( info, (ICDECOMPRESS*) lParam1,
1007                                   (DWORD) lParam2 );
1008     case ICM_DECOMPRESSEX:
1009         return ICCVID_DecompressEx( info, (ICDECOMPRESSEX*) lParam1, 
1010                                   (DWORD) lParam2 );
1011
1012     case ICM_DECOMPRESS_END:
1013         return ICCVID_DecompressEnd( info );
1014
1015     case ICM_COMPRESS_QUERY:
1016         FIXME("compression not implemented\n");
1017         return ICERR_BADFORMAT;
1018
1019     case ICM_CONFIGURE:
1020         return ICERR_UNSUPPORTED;
1021
1022     default:
1023         FIXME("Unknown message: %04x %ld %ld\n", msg, lParam1, lParam2);
1024     }
1025     return ICERR_UNSUPPORTED;
1026 }
1027
1028 BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
1029 {
1030     TRACE("(%p,%d,%p)\n", hModule, dwReason, lpReserved);
1031
1032     switch (dwReason)
1033     {
1034     case DLL_PROCESS_ATTACH:
1035         DisableThreadLibraryCalls(hModule);
1036         ICCVID_hModule = hModule;
1037         break;
1038
1039     case DLL_PROCESS_DETACH:
1040         break;
1041     }
1042     return TRUE;
1043 }