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