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