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