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 #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 }