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