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