git.oblomov.eu Git - wine/blob - dlls/msrle32/msrle32.c

   1 /*
   2  * Copyright 2002-2003 Michael Günnewig
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 /* TODO:
  20  *   - some improvements possible
  21  *   - implement DecompressSetPalette? -- do we need it for anything?
  22  */
  23
  24 #include <assert.h>
  25
  26 #include "msrle_private.h"
  27
  28 #include "winnls.h"
  29 #include "winuser.h"
  30
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msrle32);
  34
  35 static HINSTANCE MSRLE32_hModule = 0;
  36
  37 #define compare_fourcc(fcc1, fcc2) (((fcc1)^(fcc2))&~0x20202020)
  38
  39 #define ABS(a)                ((a) < 0 ? -(a) : (a))
  40 #define SQR(a)                ((a) * (a))
  41
  42 #define QUALITY_to_DIST(q)    (ICQUALITY_HIGH - q)
  43 static inline WORD ColorCmp(WORD clr1, WORD clr2)
  44 {
  45   register UINT a = (clr1-clr2);
  46   return SQR(a);
  47 }
  48 static inline WORD Intensity(RGBQUAD clr)
  49 {
  50   return (30 * clr.rgbRed + 59 * clr.rgbGreen + 11 * clr.rgbBlue)/4;
  51 }
  52
  53 #define GetRawPixel(lpbi,lp,x) \
  54   ((lpbi)->biBitCount == 1 ? ((lp)[(x)/8] >> (8 - (x)%8)) & 1 : \
  55    ((lpbi)->biBitCount == 4 ? ((lp)[(x)/2] >> (4 * (1 - (x)%2))) & 15 : lp[x]))
  56
  57 /*****************************************************************************/
  58
  59 /* utility functions */
  60 static BOOL    isSupportedDIB(LPCBITMAPINFOHEADER lpbi);
  61 static BOOL    isSupportedMRLE(LPCBITMAPINFOHEADER lpbi);
  62 static BYTE    MSRLE32_GetNearestPaletteIndex(UINT count, const RGBQUAD *clrs, RGBQUAD clr);
  63
  64 /* compression functions */
  65 static void    computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, const BYTE *lpIn);
  66 static LONG    MSRLE32_GetMaxCompressedSize(LPCBITMAPINFOHEADER lpbi);
  67 static LRESULT MSRLE32_CompressRLE4(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  68                                     const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
  69                                     LPBYTE lpOut, BOOL isKey);
  70 static LRESULT MSRLE32_CompressRLE8(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  71                                     const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
  72                                     LPBYTE lpOut, BOOL isKey);
  73
  74 /* decompression functions */
  75 static LRESULT MSRLE32_DecompressRLE4(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
  76                                       const BYTE *lpIn, LPBYTE lpOut);
  77 static LRESULT MSRLE32_DecompressRLE8(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
  78                                       const BYTE *lpIn, LPBYTE lpOut);
  79
  80 /* API functions */
  81 static LRESULT CompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  82                                  LPBITMAPINFOHEADER lpbiOut);
  83 static LRESULT CompressGetSize(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  84                                LPCBITMAPINFOHEADER lpbiOut);
  85 static LRESULT CompressQuery(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  86                              LPCBITMAPINFOHEADER lpbiOut);
  87 static LRESULT CompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  88                              LPCBITMAPINFOHEADER lpbiOut);
  89 static LRESULT Compress(CodecInfo *pi, ICCOMPRESS* lpic, DWORD dwSize);
  90 static LRESULT CompressEnd(CodecInfo *pi);
  91
  92 static LRESULT DecompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  93                                    LPBITMAPINFOHEADER lpbiOut);
  94 static LRESULT DecompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  95                                LPCBITMAPINFOHEADER lpbiOut);
  96 static LRESULT DecompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
  97                                LPCBITMAPINFOHEADER lpbiOut);
  98 static LRESULT Decompress(CodecInfo *pi, ICDECOMPRESS *pic, DWORD dwSize);
  99 static LRESULT DecompressEnd(CodecInfo *pi);
 100 static LRESULT DecompressGetPalette(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
 101                                     LPBITMAPINFOHEADER lpbiOut);
 102
 103 /*****************************************************************************/
 104
 105 static BOOL isSupportedMRLE(LPCBITMAPINFOHEADER lpbi)
 106 {
 107   /* pre-conditions */
 108   assert(lpbi != NULL);
 109
 110   if (lpbi->biSize < sizeof(BITMAPINFOHEADER) ||
 111       lpbi->biPlanes != 1)
 112     return FALSE;
 113
 114   if (lpbi->biCompression == BI_RLE4) {
 115     if (lpbi->biBitCount != 4 ||
 116         (lpbi->biWidth % 2) != 0)
 117       return FALSE;
 118   } else if (lpbi->biCompression == BI_RLE8) {
 119     if (lpbi->biBitCount != 8)
 120       return FALSE;
 121   } else
 122     return FALSE;
 123
 124   return TRUE;
 125 }
 126
 127 static BOOL  isSupportedDIB(LPCBITMAPINFOHEADER lpbi)
 128 {
 129   /* pre-conditions */
 130   assert(lpbi != NULL);
 131
 132   /* check structure version/planes/compression */
 133   if (lpbi->biSize < sizeof(BITMAPINFOHEADER) ||
 134       lpbi->biPlanes != 1)
 135     return FALSE;
 136   if (lpbi->biCompression != BI_RGB &&
 137       lpbi->biCompression != BI_BITFIELDS)
 138     return FALSE;
 139
 140   /* check bit-depth */
 141   if (lpbi->biBitCount != 1 &&
 142       lpbi->biBitCount != 4 &&
 143       lpbi->biBitCount != 8 &&
 144       lpbi->biBitCount != 15 &&
 145       lpbi->biBitCount != 16 &&
 146       lpbi->biBitCount != 24 &&
 147       lpbi->biBitCount != 32)
 148     return FALSE;
 149
 150   /* check for size(s) */
 151   if (!lpbi->biWidth || !lpbi->biHeight)
 152     return FALSE; /* image with zero size, makes no sense so error ! */
 153   if (DIBWIDTHBYTES(*lpbi) * (DWORD)lpbi->biHeight >= (1UL << 31) - 1)
 154     return FALSE; /* image too big ! */
 155
 156   /* check for nonexistent colortable for hi- and true-color DIB's */
 157   if (lpbi->biBitCount >= 15 && lpbi->biClrUsed > 0)
 158     return FALSE;
 159
 160   return TRUE;
 161 }
 162
 163 static BYTE MSRLE32_GetNearestPaletteIndex(UINT count, const RGBQUAD *clrs, RGBQUAD clr)
 164 {
 165   INT  diff = 0x00FFFFFF;
 166   UINT i;
 167   UINT idx = 0;
 168
 169   /* pre-conditions */
 170   assert(clrs != NULL);
 171
 172   for (i = 0; i < count; i++) {
 173     int r = ((int)clrs[i].rgbRed   - (int)clr.rgbRed);
 174     int g = ((int)clrs[i].rgbGreen - (int)clr.rgbGreen);
 175     int b = ((int)clrs[i].rgbBlue  - (int)clr.rgbBlue);
 176
 177     r = r*r + g*g + b*b;
 178
 179     if (r < diff) {
 180       idx  = i;
 181       diff = r;
 182       if (diff == 0)
 183         break;
 184     }
 185   }
 186
 187   return idx;
 188 }
 189
 190 /*****************************************************************************/
 191
 192 void computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, const BYTE *lpIn)
 193 {
 194   WORD   wIntensityTbl[256];
 195   DWORD  lInLine, lOutLine;
 196   LPWORD lpOut;
 197   UINT   i;
 198   LONG   y;
 199
 200   /* pre-conditions */
 201   assert(pi != NULL && lpbiIn != NULL && lpIn != NULL);
 202   assert(pi->pCurFrame != NULL);
 203
 204   lInLine  = DIBWIDTHBYTES(*lpbiIn);
 205   lOutLine = WIDTHBYTES((WORD)lpbiIn->biWidth * 8u * sizeof(WORD)) / 2u;
 206   lpOut    = pi->pCurFrame;
 207
 208   assert(lpbiIn->biClrUsed != 0);
 209
 210   {
 211     const RGBQUAD *lp =
 212       (const RGBQUAD *)((const BYTE*)lpbiIn + lpbiIn->biSize);
 213
 214     for (i = 0; i < lpbiIn->biClrUsed; i++)
 215       wIntensityTbl[i] = Intensity(lp[i]);
 216   }
 217
 218   for (y = 0; y < lpbiIn->biHeight; y++) {
 219     LONG x;
 220
 221     switch (lpbiIn->biBitCount) {
 222     case 1:
 223       for (x = 0; x < lpbiIn->biWidth / 8; x++) {
 224         for (i = 0; i < 7; i++)
 225           lpOut[8 * x + i] = wIntensityTbl[(lpIn[x] >> (7 - i)) & 1];
 226       }
 227       break;
 228     case 4:
 229       for (x = 0; x < lpbiIn->biWidth / 2; x++) {
 230         lpOut[2 * x + 0] = wIntensityTbl[(lpIn[x] >> 4)];
 231         lpOut[2 * x + 1] = wIntensityTbl[(lpIn[x] & 0x0F)];
 232       }
 233       break;
 234     case 8:
 235       for (x = 0; x < lpbiIn->biWidth; x++)
 236         lpOut[x] = wIntensityTbl[lpIn[x]];
 237       break;
 238     }
 239
 240     lpIn  += lInLine;
 241     lpOut += lOutLine;
 242   }
 243 }
 244
 245 static LONG MSRLE32_GetMaxCompressedSize(LPCBITMAPINFOHEADER lpbi)
 246 {
 247   LONG a, b, size;
 248
 249   /* pre-condition */
 250   assert(lpbi != NULL);
 251
 252   a = lpbi->biWidth / 255;
 253   b = lpbi->biWidth % 255;
 254   if (lpbi->biBitCount <= 4) {
 255     a /= 2;
 256     b /= 2;
 257   }
 258
 259   size = (2 + a * (2 + ((a + 2) & ~2)) + b * (2 + ((b + 2) & ~2)));
 260   return size * lpbi->biHeight;
 261 }
 262
 263 /* lpP => current  pos in previous frame
 264  * lpA => previous pos in current  frame
 265  * lpB => current  pos in current  frame
 266  */
 267 static INT countDiffRLE4(const WORD *lpP, const WORD *lpA, const WORD *lpB, INT pos, LONG lDist, LONG width)
 268 {
 269   INT  count;
 270   WORD clr1, clr2;
 271
 272   /* pre-conditions */
 273   assert(lpA && lpB && lDist >= 0 && width > 0);
 274
 275   if (pos >= width)
 276     return 0;
 277   if (pos+1 == width)
 278     return 1;
 279
 280   clr1 = lpB[pos++];
 281   clr2 = lpB[pos];
 282
 283   count = 2;
 284   while (pos + 1 < width) {
 285     WORD clr3, clr4;
 286
 287     clr3 = lpB[++pos];
 288     if (pos + 1 >= width)
 289       return count + 1;
 290
 291     clr4 = lpB[++pos];
 292     if (ColorCmp(clr1, clr3) <= lDist &&
 293         ColorCmp(clr2, clr4) <= lDist) {
 294       /* diff at end? -- look-ahead for at least ?? more encodable pixels */
 295       if (pos + 2 < width && ColorCmp(clr1,lpB[pos+1]) <= lDist &&
 296           ColorCmp(clr2,lpB[pos+2]) <= lDist) {
 297         if (pos + 4 < width && ColorCmp(lpB[pos+1],lpB[pos+3]) <= lDist &&
 298             ColorCmp(lpB[pos+2],lpB[pos+4]) <= lDist)
 299           return count - 3; /* followed by at least 4 encodable pixels */
 300         return count - 2;
 301       }
 302     } else if (lpP != NULL && ColorCmp(lpP[pos], lpB[pos]) <= lDist) {
 303       /* 'compare' with previous frame for end of diff */
 304       INT count2 = 0;
 305
 306       /* FIXME */
 307
 308       if (count2 >= 8)
 309         return count;
 310
 311       pos -= count2;
 312     }
 313
 314     count += 2;
 315     clr1 = clr3;
 316     clr2 = clr4;
 317   }
 318
 319   return count;
 320 }
 321
 322 /* lpP => current  pos in previous frame
 323  * lpA => previous pos in current  frame
 324  * lpB => current  pos in current  frame
 325  */
 326 static INT countDiffRLE8(const WORD *lpP, const WORD *lpA, const WORD *lpB, INT pos, LONG lDist, LONG width)
 327 {
 328   INT count;
 329
 330   for (count = 0; pos < width; pos++, count++) {
 331     if (ColorCmp(lpA[pos], lpB[pos]) <= lDist) {
 332       /* diff at end? -- look-ahead for some more encodable pixel */
 333       if (pos + 1 < width && ColorCmp(lpB[pos], lpB[pos+1]) <= lDist)
 334         return count - 1;
 335       if (pos + 2 < width && ColorCmp(lpB[pos+1], lpB[pos+2]) <= lDist)
 336         return count - 1;
 337     } else if (lpP != NULL && ColorCmp(lpP[pos], lpB[pos]) <= lDist) {
 338       /* 'compare' with previous frame for end of diff */
 339       INT count2 = 0;
 340
 341       for (count2 = 0, pos++; pos < width && count2 <= 5; pos++, count2++) {
 342         if (ColorCmp(lpP[pos], lpB[pos]) > lDist)
 343           break;
 344       }
 345       if (count2 > 4)
 346         return count;
 347
 348       pos -= count2;
 349     }
 350   }
 351
 352   return count;
 353 }
 354
 355 static INT MSRLE32_CompressRLE4Line(const CodecInfo *pi, const WORD *lpP,
 356                                     const WORD *lpC, LPCBITMAPINFOHEADER lpbi,
 357                                     const BYTE *lpIn, LONG lDist,
 358                                     INT x, LPBYTE *ppOut,
 359                                     DWORD *lpSizeImage)
 360 {
 361   LPBYTE lpOut = *ppOut;
 362   INT    count, pos;
 363   WORD   clr1, clr2;
 364
 365   /* try to encode as many pixel as possible */
 366   count = 1;
 367   pos   = x;
 368   clr1  = lpC[pos++];
 369   if (pos < lpbi->biWidth) {
 370     clr2 = lpC[pos];
 371     for (++count; pos + 1 < lpbi->biWidth; ) {
 372       ++pos;
 373       if (ColorCmp(clr1, lpC[pos]) > lDist)
 374         break;
 375       count++;
 376       if (pos + 1 >= lpbi->biWidth)
 377         break;
 378       ++pos;
 379       if (ColorCmp(clr2, lpC[pos]) > lDist)
 380         break;
 381       count++;
 382     }
 383   }
 384
 385   if (count < 4) {
 386     /* add some pixel for absoluting if possible */
 387     count += countDiffRLE4(lpP, lpC - 1, lpC, pos-1, lDist, lpbi->biWidth);
 388
 389     assert(count > 0);
 390
 391     /* check for near end of line */
 392     if (x + count > lpbi->biWidth)
 393       count = lpbi->biWidth - x;
 394
 395     /* absolute pixel(s) in groups of at least 3 and at most 254 pixels */
 396     while (count > 2) {
 397       INT  i;
 398       INT  size       = min(count, 254);
 399       int  bytes      = ((size + 1) & (~1)) / 2;
 400       int  extra_byte = bytes & 0x01;
 401
 402       *lpSizeImage += 2 + bytes + extra_byte;
 403       assert(((*lpSizeImage) % 2) == 0);
 404       count -= size;
 405       *lpOut++ = 0;
 406       *lpOut++ = size;
 407       for (i = 0; i < size; i += 2) {
 408         clr1 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 409         x++;
 410         if (i + 1 < size) {
 411           clr2 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 412           x++;
 413         } else
 414           clr2 = 0;
 415
 416         *lpOut++ = (clr1 << 4) | clr2;
 417       }
 418       if (extra_byte)
 419         *lpOut++ = 0;
 420     }
 421
 422     if (count > 0) {
 423       /* too little for absoluting so we must encode them */
 424       assert(count <= 2);
 425
 426       *lpSizeImage += 2;
 427       clr1 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 428       x++;
 429       if (count == 2) {
 430         clr2 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 431         x++;
 432       } else
 433         clr2 = 0;
 434       *lpOut++ = count;
 435       *lpOut++ = (clr1 << 4) | clr2;
 436     }
 437   } else {
 438     /* encode count pixel(s) */
 439     clr1 = ((pi->palette_map[GetRawPixel(lpbi,lpIn,x)] << 4) |
 440             pi->palette_map[GetRawPixel(lpbi,lpIn,x + 1)]);
 441
 442     x += count;
 443     while (count > 0) {
 444       INT size = min(count, 254);
 445
 446       *lpSizeImage += 2;
 447       count    -= size;
 448       *lpOut++  = size;
 449       *lpOut++  = clr1;
 450     }
 451   }
 452
 453   *ppOut = lpOut;
 454
 455   return x;
 456 }
 457
 458 static INT MSRLE32_CompressRLE8Line(const CodecInfo *pi, const WORD *lpP,
 459                                     const WORD *lpC, LPCBITMAPINFOHEADER lpbi,
 460                                     const BYTE *lpIn, LONG lDist,
 461                                     INT x, LPBYTE *ppOut,
 462                                     DWORD *lpSizeImage)
 463 {
 464   LPBYTE lpOut = *ppOut;
 465   INT    count, pos;
 466   WORD   clr;
 467
 468   assert(lpbi->biBitCount <= 8);
 469   assert(lpbi->biCompression == BI_RGB);
 470
 471   /* try to encode as much as possible */
 472   pos = x;
 473   clr = lpC[pos++];
 474   for (count = 1; pos < lpbi->biWidth; count++) {
 475     if (ColorCmp(clr, lpC[pos++]) > lDist)
 476       break;
 477   }
 478
 479   if (count < 2) {
 480     /* add some more pixels for absoluting if possible */
 481     count += countDiffRLE8(lpP, lpC - 1, lpC, pos-1, lDist, lpbi->biWidth);
 482
 483     assert(count > 0);
 484
 485     /* check for over end of line */
 486     if (x + count > lpbi->biWidth)
 487       count = lpbi->biWidth - x;
 488
 489     /* absolute pixel(s) in groups of at least 3 and at most 255 pixels */
 490     while (count > 2) {
 491       INT  i;
 492       INT  size       = min(count, 255);
 493       int  extra_byte = size % 2;
 494
 495       *lpSizeImage += 2 + size + extra_byte;
 496       count -= size;
 497       *lpOut++ = 0;
 498       *lpOut++ = size;
 499       for (i = 0; i < size; i++) {
 500         *lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 501         x++;
 502       }
 503       if (extra_byte)
 504         *lpOut++ = 0;
 505     }
 506     if (count > 0) {
 507       /* too little for absoluting so we must encode them even if it's expensive! */
 508       assert(count <= 2);
 509
 510       *lpSizeImage += 2 * count;
 511       *lpOut++ = 1;
 512       *lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 513       x++;
 514
 515       if (count == 2) {
 516         *lpOut++ = 1;
 517         *lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 518         x++;
 519       }
 520     }
 521   } else {
 522     /* encode count pixel(s) */
 523     clr = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
 524
 525     /* optimize end of line */
 526     if (x + count + 1 == lpbi->biWidth)
 527       count++;
 528
 529     x += count;
 530     while (count > 0) {
 531       INT size = min(count, 255);
 532
 533       *lpSizeImage += 2;
 534       count    -= size;
 535       *lpOut++  = size;
 536       *lpOut++  = clr;
 537     }
 538   }
 539
 540   *ppOut = lpOut;
 541
 542   return x;
 543 }
 544
 545 LRESULT MSRLE32_CompressRLE4(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
 546                              const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
 547                              LPBYTE lpOut, BOOL isKey)
 548 {
 549   LPWORD lpC;
 550   LONG   lLine, lInLine, lDist;
 551   LPBYTE lpOutStart = lpOut;
 552
 553   /* pre-conditions */
 554   assert(pi != NULL && lpbiOut != NULL);
 555   assert(lpIn != NULL && lpOut != NULL);
 556   assert(pi->pCurFrame != NULL);
 557
 558   lpC      = pi->pCurFrame;
 559   lDist    = QUALITY_to_DIST(pi->dwQuality);
 560   lInLine  = DIBWIDTHBYTES(*lpbiIn);
 561   lLine    = WIDTHBYTES(lpbiOut->biWidth * 16) / 2;
 562
 563   lpbiOut->biSizeImage = 0;
 564   if (isKey) {
 565     /* keyframe -- convert internal frame to output format */
 566     INT x, y;
 567
 568     for (y = 0; y < lpbiOut->biHeight; y++) {
 569       x = 0;
 570
 571       do {
 572         x = MSRLE32_CompressRLE4Line(pi, NULL, lpC, lpbiIn, lpIn, lDist, x,
 573                                      &lpOut, &lpbiOut->biSizeImage);
 574       } while (x < lpbiOut->biWidth);
 575
 576       lpC   += lLine;
 577       lpIn  += lInLine;
 578
 579       /* add EOL -- end of line */
 580       lpbiOut->biSizeImage += 2;
 581       *(LPWORD)lpOut = 0;
 582       lpOut += sizeof(WORD);
 583       assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 584     }
 585   } else {
 586     /* delta-frame -- compute delta between last and this internal frame */
 587     LPWORD lpP;
 588     INT    x, y;
 589     INT    jumpx, jumpy;
 590
 591     assert(pi->pPrevFrame != NULL);
 592
 593     lpP   = pi->pPrevFrame;
 594     jumpy = 0;
 595     jumpx = -1;
 596
 597     for (y = 0; y < lpbiOut->biHeight; y++) {
 598       x = 0;
 599
 600       do {
 601         INT count, pos;
 602
 603         if (jumpx == -1)
 604           jumpx = x;
 605         for (count = 0, pos = x; pos < lpbiOut->biWidth; pos++, count++) {
 606           if (ColorCmp(lpP[pos], lpC[pos]) > lDist)
 607             break;
 608         }
 609
 610         if (pos == lpbiOut->biWidth && count > 8) {
 611           /* (count > 8) secures that we will save space */
 612           jumpy++;
 613           break;
 614         } else if (jumpy || jumpx != pos) {
 615           /* time to jump */
 616           assert(jumpx != -1);
 617
 618           if (pos < jumpx) {
 619             /* can only jump in positive direction -- jump until EOL, EOL */
 620             INT w = lpbiOut->biWidth - jumpx;
 621
 622             assert(jumpy > 0);
 623             assert(w >= 4);
 624
 625             jumpx = 0;
 626             jumpy--;
 627             /* if (w % 255 == 2) then equal costs
 628              * else if (w % 255 < 4 && we could encode all) then 2 bytes too expensive
 629              * else it will be cheaper
 630              */
 631             while (w > 0) {
 632               lpbiOut->biSizeImage += 4;
 633               *lpOut++ = 0;
 634               *lpOut++ = 2;
 635               *lpOut   = min(w, 255);
 636               w       -= *lpOut++;
 637               *lpOut++ = 0;
 638             }
 639             /* add EOL -- end of line */
 640             lpbiOut->biSizeImage += 2;
 641             *((LPWORD)lpOut) = 0;
 642             lpOut += sizeof(WORD);
 643           }
 644
 645           /* FIXME: if (jumpy == 0 && could encode all) then jump too expensive */
 646
 647           /* write out real jump(s) */
 648           while (jumpy || pos != jumpx) {
 649             lpbiOut->biSizeImage += 4;
 650             *lpOut++ = 0;
 651             *lpOut++ = 2;
 652             *lpOut   = min(pos - jumpx, 255);
 653             x       += *lpOut;
 654             jumpx   += *lpOut++;
 655             *lpOut   = min(jumpy, 255);
 656             jumpy   -= *lpOut++;
 657           }
 658
 659           jumpy = 0;
 660         }
 661
 662         jumpx = -1;
 663
 664         if (x < lpbiOut->biWidth) {
 665           /* skipped the 'same' things corresponding to previous frame */
 666           x = MSRLE32_CompressRLE4Line(pi, lpP, lpC, lpbiIn, lpIn, lDist, x,
 667                                &lpOut, &lpbiOut->biSizeImage);
 668         }
 669       } while (x < lpbiOut->biWidth);
 670
 671       lpP   += lLine;
 672       lpC   += lLine;
 673       lpIn  += lInLine;
 674
 675       if (jumpy == 0) {
 676         assert(jumpx == -1);
 677
 678         /* add EOL -- end of line */
 679         lpbiOut->biSizeImage += 2;
 680         *((LPWORD)lpOut) = 0;
 681         lpOut += sizeof(WORD);
 682         assert(lpOut == lpOutStart + lpbiOut->biSizeImage);
 683       }
 684     }
 685
 686     /* add EOL -- will be changed to EOI */
 687     lpbiOut->biSizeImage += 2;
 688     *((LPWORD)lpOut) = 0;
 689     lpOut += sizeof(WORD);
 690   }
 691
 692   /* change EOL to EOI -- end of image */
 693   lpOut[-1] = 1;
 694   assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 695
 696   return ICERR_OK;
 697 }
 698
 699 LRESULT MSRLE32_CompressRLE8(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
 700                              const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
 701                              LPBYTE lpOut, BOOL isKey)
 702 {
 703   LPWORD lpC;
 704   LONG   lDist, lInLine, lLine;
 705   LPBYTE lpOutStart = lpOut;
 706
 707   assert(pi != NULL && lpbiOut != NULL);
 708   assert(lpIn != NULL && lpOut != NULL);
 709   assert(pi->pCurFrame != NULL);
 710
 711   lpC     = pi->pCurFrame;
 712   lDist   = QUALITY_to_DIST(pi->dwQuality);
 713   lInLine = DIBWIDTHBYTES(*lpbiIn);
 714   lLine   = WIDTHBYTES(lpbiOut->biWidth * 16) / 2;
 715
 716   lpbiOut->biSizeImage = 0;
 717   if (isKey) {
 718     /* keyframe -- convert internal frame to output format */
 719     INT x, y;
 720
 721     for (y = 0; y < lpbiOut->biHeight; y++) {
 722       x = 0;
 723
 724       do {
 725         x = MSRLE32_CompressRLE8Line(pi, NULL, lpC, lpbiIn, lpIn, lDist, x,
 726                              &lpOut, &lpbiOut->biSizeImage);
 727         assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 728       } while (x < lpbiOut->biWidth);
 729
 730       lpC  += lLine;
 731       lpIn += lInLine;
 732
 733       /* add EOL -- end of line */
 734       lpbiOut->biSizeImage += 2;
 735       *((LPWORD)lpOut) = 0;
 736       lpOut += sizeof(WORD);
 737       assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 738     }
 739   } else {
 740     /* delta-frame -- compute delta between last and this internal frame */
 741     LPWORD lpP;
 742     INT    x, y;
 743     INT    jumpx, jumpy;
 744
 745     assert(pi->pPrevFrame != NULL);
 746
 747     lpP   = pi->pPrevFrame;
 748     jumpx = -1;
 749     jumpy = 0;
 750
 751     for (y = 0; y < lpbiOut->biHeight; y++) {
 752       x = 0;
 753
 754       do {
 755         INT count, pos;
 756
 757         if (jumpx == -1)
 758           jumpx = x;
 759         for (count = 0, pos = x; pos < lpbiOut->biWidth; pos++, count++) {
 760           if (ColorCmp(lpP[pos], lpC[pos]) > lDist)
 761             break;
 762         }
 763
 764         if (pos == lpbiOut->biWidth && count > 4) {
 765           /* (count > 4) secures that we will save space */
 766           jumpy++;
 767           break;
 768         } else if (jumpy || jumpx != pos) {
 769           /* time to jump */
 770           assert(jumpx != -1);
 771
 772           if (pos < jumpx) {
 773             /* can only jump in positive direction -- do an EOL then jump */
 774             assert(jumpy > 0);
 775
 776             jumpx = 0;
 777             jumpy--;
 778
 779             /* add EOL -- end of line */
 780             lpbiOut->biSizeImage += 2;
 781             *((LPWORD)lpOut) = 0;
 782             lpOut += sizeof(WORD);
 783             assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 784           }
 785
 786           /* FIXME: if (jumpy == 0 && could encode all) then jump too expensive */
 787
 788           /* write out real jump(s) */
 789           while (jumpy || pos != jumpx) {
 790             lpbiOut->biSizeImage += 4;
 791             *lpOut++ = 0;
 792             *lpOut++ = 2;
 793             *lpOut   = min(pos - jumpx, 255);
 794             jumpx   += *lpOut++;
 795             *lpOut   = min(jumpy, 255);
 796             jumpy   -= *lpOut++;
 797           }
 798           x = pos;
 799
 800           jumpy = 0;
 801         }
 802
 803         jumpx = -1;
 804
 805         if (x < lpbiOut->biWidth) {
 806           /* skip the 'same' things corresponding to previous frame */
 807           x = MSRLE32_CompressRLE8Line(pi, lpP, lpC, lpbiIn, lpIn, lDist, x,
 808                                &lpOut, &lpbiOut->biSizeImage);
 809           assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 810         }
 811       } while (x < lpbiOut->biWidth);
 812
 813       lpP  += lLine;
 814       lpC  += lLine;
 815       lpIn += lInLine;
 816
 817       if (jumpy == 0) {
 818         /* add EOL -- end of line */
 819         lpbiOut->biSizeImage += 2;
 820         *((LPWORD)lpOut) = 0;
 821         lpOut += sizeof(WORD);
 822         assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 823       }
 824     }
 825
 826     /* add EOL -- will be changed to EOI */
 827     lpbiOut->biSizeImage += 2;
 828     *((LPWORD)lpOut) = 0;
 829     lpOut += sizeof(WORD);
 830   }
 831
 832   /* change EOL to EOI -- end of image */
 833   lpOut[-1] = 1;
 834   assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
 835
 836   return ICERR_OK;
 837 }
 838
 839 /*****************************************************************************/
 840
 841 static LRESULT MSRLE32_DecompressRLE4(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
 842                                       const BYTE *lpIn, LPBYTE lpOut)
 843 {
 844   int  bytes_per_pixel;
 845   int  line_size;
 846   int  pixel_ptr  = 0;
 847   int  i;
 848   BOOL bEndFlag   = FALSE;
 849
 850   assert(pi != NULL);
 851   assert(lpbi != NULL && lpbi->biCompression == BI_RGB);
 852   assert(lpIn != NULL && lpOut != NULL);
 853
 854   bytes_per_pixel = (lpbi->biBitCount + 1) / 8;
 855   line_size       = DIBWIDTHBYTES(*lpbi);
 856
 857   do {
 858     BYTE code0, code1;
 859
 860     code0 = *lpIn++;
 861     code1 = *lpIn++;
 862
 863     if (code0 == 0) {
 864       int  extra_byte;
 865
 866       switch (code1) {
 867       case  0: /* EOL - end of line  */
 868         pixel_ptr = 0;
 869         lpOut += line_size;
 870         break;
 871       case  1: /* EOI - end of image */
 872         bEndFlag = TRUE;
 873         break;
 874       case  2: /* skip */
 875         pixel_ptr += *lpIn++ * bytes_per_pixel;
 876         lpOut     += *lpIn++ * line_size;
 877         if (pixel_ptr >= lpbi->biWidth * bytes_per_pixel) {
 878           pixel_ptr = 0;
 879           lpOut    += line_size;
 880         }
 881         break;
 882       default: /* absolute mode */
 883         extra_byte = (((code1 + 1) & (~1)) / 2) & 0x01;
 884
 885         if (pixel_ptr/bytes_per_pixel + code1 > lpbi->biWidth)
 886           return ICERR_ERROR;
 887
 888         code0 = code1;
 889         for (i = 0; i < code0 / 2; i++) {
 890           if (bytes_per_pixel == 1) {
 891             code1 = lpIn[i];
 892             lpOut[pixel_ptr++] = pi->palette_map[(code1 >> 4)];
 893             if (2 * i + 1 <= code0)
 894               lpOut[pixel_ptr++] = pi->palette_map[(code1 & 0x0F)];
 895           } else if (bytes_per_pixel == 2) {
 896             code1 = lpIn[i] >> 4;
 897             lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
 898             lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
 899
 900             if (2 * i + 1 <= code0) {
 901               code1 = lpIn[i] & 0x0F;
 902               lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
 903               lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
 904             }
 905           } else {
 906             code1 = lpIn[i] >> 4;
 907             lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
 908             lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
 909             lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
 910             pixel_ptr += bytes_per_pixel;
 911
 912             if (2 * i + 1 <= code0) {
 913               code1 = lpIn[i] & 0x0F;
 914               lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
 915               lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
 916               lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
 917               pixel_ptr += bytes_per_pixel;
 918             }
 919           }
 920         }
 921         if (code0 & 0x01) {
 922           if (bytes_per_pixel == 1) {
 923             code1 = lpIn[i];
 924             lpOut[pixel_ptr++] = pi->palette_map[(code1 >> 4)];
 925           } else if (bytes_per_pixel == 2) {
 926             code1 = lpIn[i] >> 4;
 927             lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
 928             lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
 929           } else {
 930             code1 = lpIn[i] >> 4;
 931             lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
 932             lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
 933             lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
 934             pixel_ptr += bytes_per_pixel;
 935           }
 936           lpIn++;
 937         }
 938         lpIn += code0 / 2;
 939
 940         /* if the RLE code is odd, skip a byte in the stream */
 941         if (extra_byte)
 942           lpIn++;
 943       };
 944     } else {
 945       /* coded mode */
 946       if (pixel_ptr/bytes_per_pixel + code0 > lpbi->biWidth)
 947         return ICERR_ERROR;
 948
 949       if (bytes_per_pixel == 1) {
 950         BYTE c1 = pi->palette_map[(code1 >> 4)];
 951         BYTE c2 = pi->palette_map[(code1 & 0x0F)];
 952
 953         for (i = 0; i < code0; i++) {
 954           if ((i & 1) == 0)
 955             lpOut[pixel_ptr++] = c1;
 956           else
 957             lpOut[pixel_ptr++] = c2;
 958         }
 959       } else if (bytes_per_pixel == 2) {
 960         BYTE hi1 = pi->palette_map[(code1 >> 4) * 2 + 0];
 961         BYTE lo1 = pi->palette_map[(code1 >> 4) * 2 + 1];
 962
 963         BYTE hi2 = pi->palette_map[(code1 & 0x0F) * 2 + 0];
 964         BYTE lo2 = pi->palette_map[(code1 & 0x0F) * 2 + 1];
 965
 966         for (i = 0; i < code0; i++) {
 967           if ((i & 1) == 0) {
 968             lpOut[pixel_ptr++] = hi1;
 969             lpOut[pixel_ptr++] = lo1;
 970           } else {
 971             lpOut[pixel_ptr++] = hi2;
 972             lpOut[pixel_ptr++] = lo2;
 973           }
 974         }
 975       } else {
 976         BYTE b1 = pi->palette_map[(code1 >> 4) * 4 + 0];
 977         BYTE g1 = pi->palette_map[(code1 >> 4) * 4 + 1];
 978         BYTE r1 = pi->palette_map[(code1 >> 4) * 4 + 2];
 979
 980         BYTE b2 = pi->palette_map[(code1 & 0x0F) * 4 + 0];
 981         BYTE g2 = pi->palette_map[(code1 & 0x0F) * 4 + 1];
 982         BYTE r2 = pi->palette_map[(code1 & 0x0F) * 4 + 2];
 983
 984         for (i = 0; i < code0; i++) {
 985           if ((i & 1) == 0) {
 986             lpOut[pixel_ptr + 0] = b1;
 987             lpOut[pixel_ptr + 1] = g1;
 988             lpOut[pixel_ptr + 2] = r1;
 989           } else {
 990             lpOut[pixel_ptr + 0] = b2;
 991             lpOut[pixel_ptr + 1] = g2;
 992             lpOut[pixel_ptr + 2] = r2;
 993           }
 994           pixel_ptr += bytes_per_pixel;
 995         }
 996       }
 997     }
 998   } while (! bEndFlag);
 999
1000   return ICERR_OK;
1001 }
1002
1003 static LRESULT MSRLE32_DecompressRLE8(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
1004                                       const BYTE *lpIn, LPBYTE lpOut)
1005 {
1006   int  bytes_per_pixel;
1007   int  line_size;
1008   int  pixel_ptr  = 0;
1009   BOOL bEndFlag   = FALSE;
1010
1011   assert(pi != NULL);
1012   assert(lpbi != NULL && lpbi->biCompression == BI_RGB);
1013   assert(lpIn != NULL && lpOut != NULL);
1014
1015   bytes_per_pixel = (lpbi->biBitCount + 1) / 8;
1016   line_size       = DIBWIDTHBYTES(*lpbi);
1017
1018   do {
1019     BYTE code0, code1;
1020
1021     code0 = *lpIn++;
1022     code1 = *lpIn++;
1023
1024     if (code0 == 0) {
1025       int  extra_byte;
1026
1027       switch (code1) {
1028       case  0: /* EOL - end of line  */
1029         pixel_ptr = 0;
1030         lpOut += line_size;
1031         break;
1032       case  1: /* EOI - end of image */
1033         bEndFlag = TRUE;
1034         break;
1035       case  2: /* skip */
1036         pixel_ptr += *lpIn++ * bytes_per_pixel;
1037         lpOut     += *lpIn++ * line_size;
1038         if (pixel_ptr >= lpbi->biWidth * bytes_per_pixel) {
1039           pixel_ptr = 0;
1040           lpOut    += line_size;
1041         }
1042         break;
1043       default: /* absolute mode */
1044         if (pixel_ptr/bytes_per_pixel + code1 > lpbi->biWidth) {
1045           WARN("aborted absolute: (%d=%d/%d+%d) > %d\n",pixel_ptr/bytes_per_pixel + code1,pixel_ptr,bytes_per_pixel,code1,lpbi->biWidth);
1046           return ICERR_ERROR;
1047         }
1048         extra_byte = code1 & 0x01;
1049
1050         code0 = code1;
1051         while (code0--) {
1052           code1 = *lpIn++;
1053           if (bytes_per_pixel == 1) {
1054             lpOut[pixel_ptr] = pi->palette_map[code1];
1055           } else if (bytes_per_pixel == 2) {
1056             lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 2 + 0];
1057             lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 2 + 1];
1058           } else {
1059             lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
1060             lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
1061             lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
1062           }
1063           pixel_ptr += bytes_per_pixel;
1064         }
1065
1066         /* if the RLE code is odd, skip a byte in the stream */
1067         if (extra_byte)
1068           lpIn++;
1069       };
1070     } else {
1071       /* coded mode */
1072       if (pixel_ptr/bytes_per_pixel + code0 > lpbi->biWidth) {
1073         WARN("aborted coded: (%d=%d/%d+%d) > %d\n",pixel_ptr/bytes_per_pixel + code1,pixel_ptr,bytes_per_pixel,code1,lpbi->biWidth);
1074         return ICERR_ERROR;
1075       }
1076
1077       if (bytes_per_pixel == 1) {
1078         code1 = pi->palette_map[code1];
1079         while (code0--)
1080           lpOut[pixel_ptr++] = code1;
1081       } else if (bytes_per_pixel == 2) {
1082         BYTE hi = pi->palette_map[code1 * 2 + 0];
1083         BYTE lo = pi->palette_map[code1 * 2 + 1];
1084
1085         while (code0--) {
1086           lpOut[pixel_ptr + 0] = hi;
1087           lpOut[pixel_ptr + 1] = lo;
1088           pixel_ptr += bytes_per_pixel;
1089         }
1090       } else {
1091         BYTE r = pi->palette_map[code1 * 4 + 2];
1092         BYTE g = pi->palette_map[code1 * 4 + 1];
1093         BYTE b = pi->palette_map[code1 * 4 + 0];
1094
1095         while (code0--) {
1096           lpOut[pixel_ptr + 0] = b;
1097           lpOut[pixel_ptr + 1] = g;
1098           lpOut[pixel_ptr + 2] = r;
1099           pixel_ptr += bytes_per_pixel;
1100         }
1101       }
1102     }
1103   } while (! bEndFlag);
1104
1105   return ICERR_OK;
1106 }
1107
1108 /*****************************************************************************/
1109
1110 static CodecInfo* Open(LPICOPEN icinfo)
1111 {
1112   CodecInfo* pi = NULL;
1113
1114   if (icinfo == NULL) {
1115     TRACE("(NULL)\n");
1116     return (LPVOID)0xFFFF0000;
1117   }
1118
1119   if (compare_fourcc(icinfo->fccType, ICTYPE_VIDEO)) return NULL;
1120
1121   TRACE("(%p = {%u,0x%08X(%4.4s),0x%08X(%4.4s),0x%X,0x%X,...})\n", icinfo,
1122         icinfo->dwSize, icinfo->fccType, (char*)&icinfo->fccType,
1123         icinfo->fccHandler, (char*)&icinfo->fccHandler,
1124         icinfo->dwVersion,icinfo->dwFlags);
1125
1126   switch (icinfo->fccHandler) {
1127   case FOURCC_RLE:
1128   case FOURCC_RLE4:
1129   case FOURCC_RLE8:
1130   case FOURCC_MRLE:
1131     break;
1132   case mmioFOURCC('m','r','l','e'):
1133     icinfo->fccHandler = FOURCC_MRLE;
1134     break;
1135   default:
1136     WARN("unknown FOURCC = 0x%08X(%4.4s) !\n",
1137          icinfo->fccHandler,(char*)&icinfo->fccHandler);
1138     return NULL;
1139   }
1140
1141   pi = LocalAlloc(LPTR, sizeof(CodecInfo));
1142
1143   if (pi != NULL) {
1144     pi->fccHandler  = icinfo->fccHandler;
1145
1146     pi->bCompress   = FALSE;
1147     pi->dwQuality   = MSRLE32_DEFAULTQUALITY;
1148     pi->nPrevFrame  = -1;
1149     pi->pPrevFrame  = pi->pCurFrame = NULL;
1150
1151     pi->bDecompress = FALSE;
1152     pi->palette_map = NULL;
1153   }
1154
1155   icinfo->dwError = (pi != NULL ? ICERR_OK : ICERR_MEMORY);
1156
1157   return pi;
1158 }
1159
1160 static LRESULT Close(CodecInfo *pi)
1161 {
1162   TRACE("(%p)\n", pi);
1163
1164   /* pre-condition */
1165   assert(pi != NULL);
1166
1167   if (pi->pPrevFrame != NULL || pi->pCurFrame != NULL)
1168     CompressEnd(pi);
1169
1170   LocalFree(pi);
1171   return 1;
1172 }
1173
1174 static LRESULT GetInfo(const CodecInfo *pi, ICINFO *icinfo, DWORD dwSize)
1175 {
1176   /* pre-condition */
1177   assert(pi != NULL);
1178
1179   /* check parameters */
1180   if (icinfo == NULL)
1181     return sizeof(ICINFO);
1182   if (dwSize < sizeof(ICINFO))
1183     return 0;
1184
1185   icinfo->dwSize       = sizeof(ICINFO);
1186   icinfo->fccType      = ICTYPE_VIDEO;
1187   icinfo->fccHandler   = (pi != NULL ? pi->fccHandler : FOURCC_MRLE);
1188   icinfo->dwFlags      = VIDCF_QUALITY | VIDCF_TEMPORAL | VIDCF_CRUNCH | VIDCF_FASTTEMPORALC;
1189   icinfo->dwVersion    = ICVERSION;
1190   icinfo->dwVersionICM = ICVERSION;
1191
1192   LoadStringW(MSRLE32_hModule, IDS_NAME, icinfo->szName, sizeof(icinfo->szName)/sizeof(WCHAR));
1193   LoadStringW(MSRLE32_hModule, IDS_DESCRIPTION, icinfo->szDescription, sizeof(icinfo->szDescription)/sizeof(WCHAR));
1194
1195   return sizeof(ICINFO);
1196 }
1197
1198 static LRESULT SetQuality(CodecInfo *pi, LONG lQuality)
1199 {
1200   /* pre-condition */
1201   assert(pi != NULL);
1202
1203   if (lQuality == -1)
1204     lQuality = MSRLE32_DEFAULTQUALITY;
1205   else if (ICQUALITY_LOW > lQuality || lQuality > ICQUALITY_HIGH)
1206     return ICERR_BADPARAM;
1207
1208   pi->dwQuality = (DWORD)lQuality;
1209
1210   return ICERR_OK;
1211 }
1212
1213 static LRESULT Configure(const CodecInfo *pi, HWND hWnd)
1214 {
1215   /* pre-condition */
1216   assert(pi != NULL);
1217
1218   /* FIXME */
1219   return ICERR_OK;
1220 }
1221
1222 static LRESULT About(CodecInfo *pi, HWND hWnd)
1223 {
1224   WCHAR szTitle[20];
1225   WCHAR szAbout[128];
1226
1227   /* pre-condition */
1228   assert(MSRLE32_hModule != 0);
1229
1230   LoadStringW(MSRLE32_hModule, IDS_NAME, szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
1231   LoadStringW(MSRLE32_hModule, IDS_ABOUT, szAbout, sizeof(szAbout)/sizeof(szAbout[0]));
1232
1233   MessageBoxW(hWnd, szAbout, szTitle, MB_OK|MB_ICONINFORMATION);
1234
1235   return ICERR_OK;
1236 }
1237
1238 static LRESULT CompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1239                                  LPBITMAPINFOHEADER lpbiOut)
1240 {
1241   LRESULT size;
1242
1243   TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1244
1245   /* pre-condition */
1246   assert(pi != NULL);
1247
1248   /* check parameters -- need at least input format */
1249   if (lpbiIn == NULL) {
1250     if (lpbiOut != NULL)
1251       return ICERR_BADPARAM;
1252     return 0;
1253   }
1254
1255   /* handle unsupported input format */
1256   if (CompressQuery(pi, lpbiIn, NULL) != ICERR_OK)
1257     return (lpbiOut == NULL ? ICERR_BADFORMAT : 0);
1258
1259   assert(0 < lpbiIn->biBitCount && lpbiIn->biBitCount <= 8);
1260
1261   switch (pi->fccHandler) {
1262   case FOURCC_RLE4:
1263     size = 1 << 4;
1264     break;
1265   case FOURCC_RLE8:
1266     size = 1 << 8;
1267     break;
1268   case FOURCC_RLE:
1269   case FOURCC_MRLE:
1270     size = (lpbiIn->biBitCount <= 4 ? 1 << 4 : 1 << 8);
1271     break;
1272   default:
1273     return ICERR_ERROR;
1274   }
1275
1276   if (lpbiIn->biClrUsed != 0)
1277     size = lpbiIn->biClrUsed;
1278
1279   size = sizeof(BITMAPINFOHEADER) + size * sizeof(RGBQUAD);
1280
1281   if (lpbiOut != NULL) {
1282     lpbiOut->biSize          = sizeof(BITMAPINFOHEADER);
1283     lpbiOut->biWidth         = lpbiIn->biWidth;
1284     lpbiOut->biHeight        = lpbiIn->biHeight;
1285     lpbiOut->biPlanes        = 1;
1286     if (pi->fccHandler == FOURCC_RLE4 ||
1287         lpbiIn->biBitCount <= 4) {
1288       lpbiOut->biCompression = BI_RLE4;
1289       lpbiOut->biBitCount    = 4;
1290     } else {
1291       lpbiOut->biCompression = BI_RLE8;
1292       lpbiOut->biBitCount    = 8;
1293     }
1294     lpbiOut->biSizeImage     = MSRLE32_GetMaxCompressedSize(lpbiOut);
1295     lpbiOut->biXPelsPerMeter = lpbiIn->biXPelsPerMeter;
1296     lpbiOut->biYPelsPerMeter = lpbiIn->biYPelsPerMeter;
1297     if (lpbiIn->biClrUsed == 0)
1298       size = 1<<lpbiIn->biBitCount;
1299     else
1300       size = lpbiIn->biClrUsed;
1301     lpbiOut->biClrUsed       = min(size, 1 << lpbiOut->biBitCount);
1302     lpbiOut->biClrImportant  = 0;
1303
1304     memcpy((LPBYTE)lpbiOut + lpbiOut->biSize,
1305            (const BYTE*)lpbiIn + lpbiIn->biSize, lpbiOut->biClrUsed * sizeof(RGBQUAD));
1306
1307     return ICERR_OK;
1308   } else
1309     return size;
1310 }
1311
1312 static LRESULT CompressGetSize(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1313                                LPCBITMAPINFOHEADER lpbiOut)
1314 {
1315   /* pre-condition */
1316   assert(pi != NULL);
1317
1318   TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1319
1320   /* check parameter -- need at least one format */
1321   if (lpbiIn == NULL && lpbiOut == NULL)
1322     return 0;
1323   /* check if the given format is supported */
1324   if (CompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1325     return 0;
1326
1327   /* the worst case is coding the complete image in absolute mode. */
1328   if (lpbiIn)
1329     return MSRLE32_GetMaxCompressedSize(lpbiIn);
1330   else
1331     return MSRLE32_GetMaxCompressedSize(lpbiOut);
1332 }
1333
1334 static LRESULT CompressQuery(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1335                              LPCBITMAPINFOHEADER lpbiOut)
1336 {
1337   /* pre-condition */
1338   assert(pi != NULL);
1339
1340   /* need at least one format */
1341   if (lpbiIn == NULL && lpbiOut == NULL)
1342     return ICERR_BADPARAM;
1343
1344   /* check input format if given */
1345   if (lpbiIn != NULL) {
1346     if (!isSupportedDIB(lpbiIn))
1347       return ICERR_BADFORMAT;
1348
1349     /* for 4-bit need an even width */
1350     if (lpbiIn->biBitCount <= 4 && (lpbiIn->biWidth % 2))
1351       return ICERR_BADFORMAT;
1352
1353     if (pi->fccHandler == FOURCC_RLE4 && lpbiIn->biBitCount > 4)
1354       return ICERR_UNSUPPORTED;
1355     else if (lpbiIn->biBitCount > 8)
1356       return ICERR_UNSUPPORTED;
1357   }
1358
1359   /* check output format if given */
1360   if (lpbiOut != NULL) {
1361     if (!isSupportedMRLE(lpbiOut))
1362       return ICERR_BADFORMAT;
1363
1364     if (lpbiIn != NULL) {
1365       if (lpbiIn->biWidth  != lpbiOut->biWidth)
1366         return ICERR_UNSUPPORTED;
1367       if (lpbiIn->biHeight != lpbiOut->biHeight)
1368         return ICERR_UNSUPPORTED;
1369       if (lpbiIn->biBitCount > lpbiOut->biBitCount)
1370         return ICERR_UNSUPPORTED;
1371     }
1372   }
1373
1374   return ICERR_OK;
1375 }
1376
1377 static LRESULT CompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1378                              LPCBITMAPINFOHEADER lpbiOut)
1379 {
1380   const RGBQUAD *rgbIn;
1381   const RGBQUAD *rgbOut;
1382   UINT   i;
1383   size_t size;
1384
1385   TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1386
1387   /* pre-condition */
1388   assert(pi != NULL);
1389
1390   /* check parameters -- need both formats */
1391   if (lpbiIn == NULL || lpbiOut == NULL)
1392     return ICERR_BADPARAM;
1393   /* And both must be supported */
1394   if (CompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1395     return ICERR_BADFORMAT;
1396
1397   /* FIXME: cannot compress and decompress at same time! */
1398   if (pi->bDecompress) {
1399     FIXME("cannot compress and decompress at same time!\n");
1400     return ICERR_ERROR;
1401   }
1402
1403   if (pi->bCompress)
1404     CompressEnd(pi);
1405
1406   size = WIDTHBYTES(lpbiOut->biWidth * 16) / 2 * lpbiOut->biHeight;
1407   pi->pPrevFrame = GlobalLock(GlobalAlloc(GPTR, size * sizeof(WORD)));
1408   if (pi->pPrevFrame == NULL)
1409     return ICERR_MEMORY;
1410   pi->pCurFrame = GlobalLock(GlobalAlloc(GPTR, size * sizeof(WORD)));
1411   if (pi->pCurFrame == NULL) {
1412     CompressEnd(pi);
1413     return ICERR_MEMORY;
1414   }
1415   pi->nPrevFrame = -1;
1416   pi->bCompress  = TRUE;
1417
1418   rgbIn  = (const RGBQUAD*)((const BYTE*)lpbiIn  + lpbiIn->biSize);
1419   rgbOut = (const RGBQUAD*)((const BYTE*)lpbiOut + lpbiOut->biSize);
1420
1421   switch (lpbiOut->biBitCount) {
1422   case 4:
1423   case 8:
1424     pi->palette_map = LocalAlloc(LPTR, lpbiIn->biClrUsed);
1425     if (pi->palette_map == NULL) {
1426       CompressEnd(pi);
1427       return ICERR_MEMORY;
1428     }
1429
1430     for (i = 0; i < lpbiIn->biClrUsed; i++) {
1431       pi->palette_map[i] = MSRLE32_GetNearestPaletteIndex(lpbiOut->biClrUsed, rgbOut, rgbIn[i]);
1432     }
1433     break;
1434   };
1435
1436   return ICERR_OK;
1437 }
1438
1439 static LRESULT Compress(CodecInfo *pi, ICCOMPRESS* lpic, DWORD dwSize)
1440 {
1441   int i;
1442
1443   TRACE("(%p,%p,%u)\n",pi,lpic,dwSize);
1444
1445   /* pre-condition */
1446   assert(pi != NULL);
1447
1448   /* check parameters */
1449   if (lpic == NULL || dwSize < sizeof(ICCOMPRESS))
1450     return ICERR_BADPARAM;
1451   if (!lpic->lpbiOutput || !lpic->lpOutput ||
1452       !lpic->lpbiInput  || !lpic->lpInput)
1453     return ICERR_BADPARAM;
1454
1455   TRACE("lpic={0x%X,%p,%p,%p,%p,%p,%p,%d,%u,%u,%p,%p}\n",lpic->dwFlags,lpic->lpbiOutput,lpic->lpOutput,lpic->lpbiInput,lpic->lpInput,lpic->lpckid,lpic->lpdwFlags,lpic->lFrameNum,lpic->dwFrameSize,lpic->dwQuality,lpic->lpbiPrev,lpic->lpPrev);
1456
1457   if (! pi->bCompress) {
1458     LRESULT hr = CompressBegin(pi, lpic->lpbiInput, lpic->lpbiOutput);
1459     if (hr != ICERR_OK)
1460       return hr;
1461   } else if (CompressQuery(pi, lpic->lpbiInput, lpic->lpbiOutput) != ICERR_OK)
1462     return ICERR_BADFORMAT;
1463
1464   if (lpic->lFrameNum >= pi->nPrevFrame + 1) {
1465     /* we continue in the sequence so we need to initialize
1466      * our internal framedata */
1467
1468     computeInternalFrame(pi, lpic->lpbiInput, lpic->lpInput);
1469   } else if (lpic->lFrameNum == pi->nPrevFrame) {
1470     /* Oops, compress same frame again ? Okay, as you wish.
1471      * No need to recompute internal framedata, because we only swapped buffers */
1472     LPWORD pTmp = pi->pPrevFrame;
1473
1474     pi->pPrevFrame = pi->pCurFrame;
1475     pi->pCurFrame  = pTmp;
1476   } else if ((lpic->dwFlags & ICCOMPRESS_KEYFRAME) == 0) {
1477     LPWORD pTmp;
1478
1479     WARN(": prev=%d cur=%d gone back? -- untested\n",pi->nPrevFrame,lpic->lFrameNum);
1480     if (lpic->lpbiPrev == NULL || lpic->lpPrev == NULL)
1481       return ICERR_GOTOKEYFRAME; /* Need a keyframe if you go back */
1482     if (CompressQuery(pi, lpic->lpbiPrev, lpic->lpbiOutput) != ICERR_OK)
1483       return ICERR_BADFORMAT;
1484
1485     WARN(": prev=%d cur=%d compute swapped -- untested\n",pi->nPrevFrame,lpic->lFrameNum);
1486     computeInternalFrame(pi, lpic->lpbiPrev, lpic->lpPrev);
1487
1488     /* swap buffers for current and previous frame */
1489     /* Don't free and alloc new -- costs to much time and they are of equal size ! */
1490     pTmp = pi->pPrevFrame;
1491     pi->pPrevFrame = pi->pCurFrame;
1492     pi->pCurFrame  = pTmp;
1493     pi->nPrevFrame = lpic->lFrameNum;
1494   }
1495
1496   for (i = 0; i < 3; i++) {
1497     SetQuality(pi, lpic->dwQuality);
1498
1499     lpic->lpbiOutput->biSizeImage = 0;
1500
1501     if (lpic->lpbiOutput->biBitCount == 4)
1502       MSRLE32_CompressRLE4(pi, lpic->lpbiInput, lpic->lpInput,
1503                    lpic->lpbiOutput, lpic->lpOutput, (lpic->dwFlags & ICCOMPRESS_KEYFRAME) != 0);
1504     else
1505       MSRLE32_CompressRLE8(pi, lpic->lpbiInput, lpic->lpInput,
1506                    lpic->lpbiOutput, lpic->lpOutput, (lpic->dwFlags & ICCOMPRESS_KEYFRAME) != 0);
1507
1508     if (lpic->dwFrameSize == 0 ||
1509         lpic->lpbiOutput->biSizeImage < lpic->dwFrameSize)
1510       break;
1511
1512     if ((*lpic->lpdwFlags & ICCOMPRESS_KEYFRAME) == 0) {
1513       if (lpic->lpbiOutput->biBitCount == 4)
1514         MSRLE32_CompressRLE4(pi, lpic->lpbiInput, lpic->lpInput,
1515                              lpic->lpbiOutput, lpic->lpOutput, TRUE);
1516       else
1517         MSRLE32_CompressRLE8(pi, lpic->lpbiInput, lpic->lpInput,
1518                              lpic->lpbiOutput, lpic->lpOutput, TRUE);
1519
1520       if (lpic->dwFrameSize == 0 ||
1521           lpic->lpbiOutput->biSizeImage < lpic->dwFrameSize) {
1522         WARN("switched to keyframe, was small enough!\n");
1523         *lpic->lpdwFlags |= ICCOMPRESS_KEYFRAME;
1524         *lpic->lpckid    = MAKEAVICKID(cktypeDIBbits,
1525                                        StreamFromFOURCC(*lpic->lpckid));
1526         break;
1527       }
1528     }
1529
1530     if (lpic->dwQuality < 1000)
1531       break;
1532
1533     lpic->dwQuality -= 1000; /* reduce quality by 10% */
1534   }
1535
1536   { /* swap buffer for current and previous frame */
1537     /* Don't free and alloc new -- costs to much time and they are of equal size ! */
1538     register LPWORD pTmp = pi->pPrevFrame;
1539
1540     pi->pPrevFrame = pi->pCurFrame;
1541     pi->pCurFrame  = pTmp;
1542     pi->nPrevFrame = lpic->lFrameNum;
1543   }
1544
1545   return ICERR_OK;
1546 }
1547
1548 static LRESULT CompressEnd(CodecInfo *pi)
1549 {
1550   TRACE("(%p)\n",pi);
1551
1552   if (pi != NULL) {
1553     if (pi->pPrevFrame != NULL)
1554     {
1555       GlobalUnlock(GlobalHandle(pi->pPrevFrame));
1556       GlobalFree(GlobalHandle(pi->pPrevFrame));
1557     }
1558     if (pi->pCurFrame != NULL)
1559     {
1560       GlobalUnlock(GlobalHandle(pi->pCurFrame));
1561       GlobalFree(GlobalHandle(pi->pCurFrame));
1562     }
1563     pi->pPrevFrame = NULL;
1564     pi->pCurFrame  = NULL;
1565     pi->nPrevFrame = -1;
1566     pi->bCompress  = FALSE;
1567   }
1568
1569   return ICERR_OK;
1570 }
1571
1572 static LRESULT DecompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1573                                    LPBITMAPINFOHEADER lpbiOut)
1574 {
1575   DWORD size;
1576
1577   TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1578
1579   /* pre-condition */
1580   assert(pi != NULL);
1581
1582   if (lpbiIn == NULL)
1583     return (lpbiOut != NULL ? ICERR_BADPARAM : 0);
1584
1585   if (DecompressQuery(pi, lpbiIn, NULL) != ICERR_OK)
1586     return (lpbiOut != NULL ? ICERR_BADFORMAT : 0);
1587
1588   size = lpbiIn->biSize;
1589
1590   if (lpbiIn->biBitCount <= 8)
1591     size += lpbiIn->biClrUsed * sizeof(RGBQUAD);
1592
1593   if (lpbiOut != NULL) {
1594     memcpy(lpbiOut, lpbiIn, size);
1595     lpbiOut->biCompression  = BI_RGB;
1596     lpbiOut->biSizeImage    = DIBWIDTHBYTES(*lpbiOut) * lpbiOut->biHeight;
1597
1598     return ICERR_OK;
1599   } else
1600     return size;
1601 }
1602
1603 static LRESULT DecompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1604                                LPCBITMAPINFOHEADER lpbiOut)
1605 {
1606   LRESULT hr = ICERR_OK;
1607
1608   TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1609
1610   /* pre-condition */
1611   assert(pi != NULL);
1612
1613   /* need at least one format */
1614   if (lpbiIn == NULL && lpbiOut == NULL)
1615     return ICERR_BADPARAM;
1616
1617   /* check input format if given */
1618   if (lpbiIn != NULL) {
1619     if (!isSupportedMRLE(lpbiIn))
1620       return ICERR_BADFORMAT;
1621   }
1622
1623   /* check output format if given */
1624   if (lpbiOut != NULL) {
1625     if (!isSupportedDIB(lpbiOut))
1626       hr = ICERR_BADFORMAT;
1627
1628     if (lpbiIn != NULL) {
1629       if (lpbiIn->biWidth  != lpbiOut->biWidth)
1630         hr = ICERR_UNSUPPORTED;
1631       if (lpbiIn->biHeight != lpbiOut->biHeight)
1632         hr = ICERR_UNSUPPORTED;
1633       if (lpbiIn->biBitCount > lpbiOut->biBitCount)
1634         hr = ICERR_UNSUPPORTED;
1635     }
1636   }
1637
1638   return hr;
1639 }
1640
1641 static LRESULT DecompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1642                                LPCBITMAPINFOHEADER lpbiOut)
1643 {
1644   const RGBQUAD *rgbIn;
1645   const RGBQUAD *rgbOut;
1646   UINT  i;
1647
1648   TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1649
1650   /* pre-condition */
1651   assert(pi != NULL);
1652
1653   /* check parameters */
1654   if (lpbiIn == NULL || lpbiOut == NULL)
1655     return ICERR_BADPARAM;
1656   if (DecompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1657     return ICERR_BADFORMAT;
1658
1659   /* FIXME: cannot compress and decompress at a time! */
1660   if (pi->bCompress) {
1661     FIXME("cannot compress and decompress at same time!\n");
1662     return ICERR_ERROR;
1663   }
1664
1665   if (pi->bDecompress)
1666     DecompressEnd(pi);
1667
1668   rgbIn  = (const RGBQUAD*)((const BYTE*)lpbiIn  + lpbiIn->biSize);
1669   rgbOut = (const RGBQUAD*)((const BYTE*)lpbiOut + lpbiOut->biSize);
1670
1671   switch (lpbiOut->biBitCount) {
1672   case 4:
1673   case 8:
1674     pi->palette_map = LocalAlloc(LPTR, lpbiIn->biClrUsed);
1675     if (pi->palette_map == NULL)
1676       return ICERR_MEMORY;
1677
1678     for (i = 0; i < lpbiIn->biClrUsed; i++) {
1679       pi->palette_map[i] = MSRLE32_GetNearestPaletteIndex(lpbiOut->biClrUsed, rgbOut, rgbIn[i]);
1680     }
1681     break;
1682   case 15:
1683   case 16:
1684     pi->palette_map = LocalAlloc(LPTR, lpbiIn->biClrUsed * 2);
1685     if (pi->palette_map == NULL)
1686       return ICERR_MEMORY;
1687
1688     for (i = 0; i < lpbiIn->biClrUsed; i++) {
1689       WORD color;
1690
1691       if (lpbiOut->biBitCount == 15)
1692         color = ((rgbIn[i].rgbRed >> 3) << 10)
1693           | ((rgbIn[i].rgbGreen >> 3) << 5) | (rgbIn[i].rgbBlue >> 3);
1694       else
1695         color = ((rgbIn[i].rgbRed >> 3) << 11)
1696           | ((rgbIn[i].rgbGreen >> 3) << 5) | (rgbIn[i].rgbBlue >> 3);
1697
1698       pi->palette_map[i * 2 + 1] = color >> 8;
1699       pi->palette_map[i * 2 + 0] = color & 0xFF;
1700     };
1701     break;
1702   case 24:
1703   case 32:
1704     pi->palette_map = LocalAlloc(LPTR, lpbiIn->biClrUsed * sizeof(RGBQUAD));
1705     if (pi->palette_map == NULL)
1706       return ICERR_MEMORY;
1707     memcpy(pi->palette_map, rgbIn, lpbiIn->biClrUsed * sizeof(RGBQUAD));
1708     break;
1709   };
1710
1711   pi->bDecompress = TRUE;
1712
1713   return ICERR_OK;
1714 }
1715
1716 static LRESULT Decompress(CodecInfo *pi, ICDECOMPRESS *pic, DWORD dwSize)
1717 {
1718   TRACE("(%p,%p,%u)\n",pi,pic,dwSize);
1719
1720   /* pre-condition */
1721   assert(pi != NULL);
1722
1723   /* check parameters */
1724   if (pic == NULL)
1725     return ICERR_BADPARAM;
1726   if (pic->lpbiInput == NULL || pic->lpInput == NULL ||
1727       pic->lpbiOutput == NULL || pic->lpOutput == NULL)
1728     return ICERR_BADPARAM;
1729
1730   /* check formats */
1731   if (! pi->bDecompress) {
1732     LRESULT hr = DecompressBegin(pi, pic->lpbiInput, pic->lpbiOutput);
1733     if (hr != ICERR_OK)
1734       return hr;
1735   } else if (DecompressQuery(pi, pic->lpbiInput, pic->lpbiOutput) != ICERR_OK)
1736     return ICERR_BADFORMAT;
1737
1738   assert(pic->lpbiInput->biWidth  == pic->lpbiOutput->biWidth);
1739   assert(pic->lpbiInput->biHeight == pic->lpbiOutput->biHeight);
1740
1741   pic->lpbiOutput->biSizeImage = DIBWIDTHBYTES(*pic->lpbiOutput) * pic->lpbiOutput->biHeight;
1742   if (pic->lpbiInput->biBitCount == 4)
1743     return MSRLE32_DecompressRLE4(pi, pic->lpbiOutput, pic->lpInput, pic->lpOutput);
1744   else
1745     return MSRLE32_DecompressRLE8(pi, pic->lpbiOutput, pic->lpInput, pic->lpOutput);
1746 }
1747
1748 static LRESULT DecompressEnd(CodecInfo *pi)
1749 {
1750   TRACE("(%p)\n",pi);
1751
1752   /* pre-condition */
1753   assert(pi != NULL);
1754
1755   pi->bDecompress = FALSE;
1756
1757   if (pi->palette_map != NULL) {
1758     LocalFree(pi->palette_map);
1759     pi->palette_map = NULL;
1760   }
1761
1762   return ICERR_OK;
1763 }
1764
1765 static LRESULT DecompressGetPalette(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1766                                     LPBITMAPINFOHEADER lpbiOut)
1767 {
1768   int size;
1769
1770   TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1771
1772   /* pre-condition */
1773   assert(pi != NULL);
1774
1775   /* check parameters */
1776   if (lpbiIn == NULL || lpbiOut == NULL)
1777     return ICERR_BADPARAM;
1778
1779   if (DecompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1780     return ICERR_BADFORMAT;
1781
1782   if (lpbiOut->biBitCount > 8)
1783     return ICERR_ERROR;
1784
1785   if (lpbiIn->biBitCount <= 8) {
1786     if (lpbiIn->biClrUsed > 0)
1787       size = lpbiIn->biClrUsed;
1788     else
1789       size = (1 << lpbiIn->biBitCount);
1790
1791     lpbiOut->biClrUsed = size;
1792
1793     memcpy((LPBYTE)lpbiOut + lpbiOut->biSize, (const BYTE*)lpbiIn + lpbiIn->biSize, size * sizeof(RGBQUAD));
1794   } /* else could never occur ! */
1795
1796   return ICERR_OK;
1797 }
1798
1799 /* DriverProc - entry point for an installable driver */
1800 LRESULT CALLBACK MSRLE32_DriverProc(DWORD_PTR dwDrvID, HDRVR hDrv, UINT uMsg,
1801                                     LPARAM lParam1, LPARAM lParam2)
1802 {
1803   CodecInfo *pi = (CodecInfo*)dwDrvID;
1804
1805   TRACE("(%lx,%p,0x%04X,0x%08lX,0x%08lX)\n", dwDrvID, hDrv, uMsg, lParam1, lParam2);
1806
1807   switch (uMsg) {
1808     /* standard driver messages */
1809   case DRV_LOAD:
1810     return DRVCNF_OK;
1811   case DRV_OPEN:
1812       return (LRESULT)Open((ICOPEN*)lParam2);
1813   case DRV_CLOSE:
1814     if (dwDrvID != 0xFFFF0000 && (LPVOID)dwDrvID != NULL)
1815       Close(pi);
1816     return DRVCNF_OK;
1817   case DRV_ENABLE:
1818   case DRV_DISABLE:
1819     return DRVCNF_OK;
1820   case DRV_FREE:
1821     return DRVCNF_OK;
1822   case DRV_QUERYCONFIGURE:
1823     return DRVCNF_CANCEL; /* FIXME */
1824   case DRV_CONFIGURE:
1825     return DRVCNF_OK;     /* FIXME */
1826   case DRV_INSTALL:
1827   case DRV_REMOVE:
1828     return DRVCNF_OK;
1829
1830     /* installable compression manager messages */
1831   case ICM_CONFIGURE:
1832     FIXME("ICM_CONFIGURE (%ld)\n",lParam1);
1833     if (lParam1 == -1)
1834       return ICERR_UNSUPPORTED; /* FIXME */
1835     else
1836       return Configure(pi, (HWND)lParam1);
1837   case ICM_ABOUT:
1838     if (lParam1 == -1)
1839       return ICERR_OK;
1840     else
1841       return About(pi, (HWND)lParam1);
1842   case ICM_GETSTATE:
1843   case ICM_SETSTATE:
1844     return 0; /* no state */
1845   case ICM_GETINFO:
1846     return GetInfo(pi, (ICINFO*)lParam1, (DWORD)lParam2);
1847   case ICM_GETDEFAULTQUALITY:
1848     if ((LPVOID)lParam1 != NULL) {
1849       *((LPDWORD)lParam1) = MSRLE32_DEFAULTQUALITY;
1850       return ICERR_OK;
1851     }
1852     break;
1853   case ICM_GETQUALITY:
1854     if ((LPVOID)lParam1 != NULL) {
1855       *((LPDWORD)lParam1) = pi->dwQuality;
1856       return ICERR_OK;
1857     }
1858     break;
1859   case ICM_SETQUALITY:
1860     return SetQuality(pi, *(LPLONG)lParam1);
1861   case ICM_COMPRESS_GET_FORMAT:
1862     return CompressGetFormat(pi, (LPCBITMAPINFOHEADER)lParam1,
1863                              (LPBITMAPINFOHEADER)lParam2);
1864   case ICM_COMPRESS_GET_SIZE:
1865     return CompressGetSize(pi, (LPCBITMAPINFOHEADER)lParam1,
1866                            (LPCBITMAPINFOHEADER)lParam2);
1867   case ICM_COMPRESS_QUERY:
1868     return CompressQuery(pi, (LPCBITMAPINFOHEADER)lParam1,
1869                          (LPCBITMAPINFOHEADER)lParam2);
1870   case ICM_COMPRESS_BEGIN:
1871     return CompressBegin(pi, (LPCBITMAPINFOHEADER)lParam1,
1872                          (LPCBITMAPINFOHEADER)lParam2);
1873   case ICM_COMPRESS:
1874     return Compress(pi, (ICCOMPRESS*)lParam1, (DWORD)lParam2);
1875   case ICM_COMPRESS_END:
1876     return CompressEnd(pi);
1877   case ICM_DECOMPRESS_GET_FORMAT:
1878     return DecompressGetFormat(pi, (LPCBITMAPINFOHEADER)lParam1,
1879                                (LPBITMAPINFOHEADER)lParam2);
1880   case ICM_DECOMPRESS_QUERY:
1881     return DecompressQuery(pi, (LPCBITMAPINFOHEADER)lParam1,
1882                            (LPCBITMAPINFOHEADER)lParam2);
1883   case ICM_DECOMPRESS_BEGIN:
1884     return DecompressBegin(pi, (LPCBITMAPINFOHEADER)lParam1,
1885                            (LPCBITMAPINFOHEADER)lParam2);
1886   case ICM_DECOMPRESS:
1887     return Decompress(pi, (ICDECOMPRESS*)lParam1, (DWORD)lParam2);
1888   case ICM_DECOMPRESS_END:
1889     return DecompressEnd(pi);
1890   case ICM_DECOMPRESS_SET_PALETTE:
1891     FIXME("(...) -> SetPalette(%p,%p,%p): stub!\n", pi, (LPVOID)lParam1, (LPVOID)lParam2);
1892     return ICERR_UNSUPPORTED;
1893   case ICM_DECOMPRESS_GET_PALETTE:
1894     return DecompressGetPalette(pi, (LPBITMAPINFOHEADER)lParam1,
1895                                 (LPBITMAPINFOHEADER)lParam2);
1896   case ICM_GETDEFAULTKEYFRAMERATE:
1897     if ((LPVOID)lParam1 != NULL)
1898       *(LPDWORD)lParam1 = 15;
1899     return ICERR_OK;
1900   default:
1901     if (uMsg < DRV_USER)
1902       return DefDriverProc(dwDrvID, hDrv, uMsg, lParam1, lParam2);
1903     else
1904       FIXME("Unknown message uMsg=0x%08X lParam1=0x%08lX lParam2=0x%08lX\n",uMsg,lParam1,lParam2);
1905   };
1906
1907   return ICERR_UNSUPPORTED;
1908 }
1909
1910 /* DllMain - library initialization code */
1911 BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
1912 {
1913   TRACE("(%p,%d,%p)\n",hModule,dwReason,lpReserved);
1914
1915   switch (dwReason) {
1916   case DLL_PROCESS_ATTACH:
1917     DisableThreadLibraryCalls(hModule);
1918     MSRLE32_hModule = hModule;
1919     break;
1920
1921   case DLL_PROCESS_DETACH:
1922     break;
1923   }
1924
1925   return TRUE;
1926 }