1 /* 2 * Microsoft Video-1 Decoder 3 * Copyright (C) 2003 the ffmpeg project 4 * 5 * Portions Copyright (C) 2004 Mike McCormack for CodeWeavers 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 20 * 21 */ 22 23 /** 24 * @file msvideo1.c 25 * Microsoft Video-1 Decoder by Mike Melanson (melanson@pcisys.net) 26 * For more information about the MS Video-1 format, visit: 27 * http://www.pcisys.net/~melanson/codecs/ 28 * 29 * This decoder outputs either PAL8 or RGB555 data, depending on the 30 * whether a RGB palette was passed through palctrl; 31 * if it's present, then the data is PAL8; RGB555 otherwise. 32 */ 33 34 #include <stdarg.h> 35 #include "windef.h" 36 #include "winbase.h" 37 #include "wingdi.h" 38 #include "winuser.h" 39 #include "commdlg.h" 40 #include "vfw.h" 41 #include "mmsystem.h" 42 #include "msvidc32_private.h" 43 44 #include "wine/debug.h" 45 46 WINE_DEFAULT_DEBUG_CHANNEL(msvidc32); 47 48 static HINSTANCE MSVIDC32_hModule; 49 50 #define CRAM_MAGIC mmioFOURCC('C', 'R', 'A', 'M') 51 #define MSVC_MAGIC mmioFOURCC('M', 'S', 'V', 'C') 52 #define WHAM_MAGIC mmioFOURCC('W', 'H', 'A', 'M') 53 #define compare_fourcc(fcc1, fcc2) (((fcc1)^(fcc2))&~0x20202020) 54 55 #define PALETTE_COUNT 256 56 #define LE_16(x) ((((const uint8_t *)(x))[1] << 8) | ((const uint8_t *)(x))[0]) 57 58 /* FIXME - check the stream size */ 59 #define CHECK_STREAM_PTR(n) \ 60 if ((stream_ptr + n) > buf_size ) { \ 61 WARN("stream_ptr out of bounds (%d >= %d)\n", \ 62 stream_ptr + n, buf_size); \ 63 return; \ 64 } 65 66 typedef BYTE uint8_t; 67 68 typedef struct Msvideo1Context { 69 DWORD dwMagic; 70 int depth; 71 } Msvideo1Context; 72 73 static inline int get_stride(int width, int depth) 74 { 75 return ((depth * width + 31) >> 3) & ~3; 76 } 77 78 static void 79 msvideo1_decode_8bit( int width, int height, const unsigned char *buf, int buf_size, 80 unsigned char *pixels, int stride) 81 { 82 int block_ptr, pixel_ptr; 83 int total_blocks; 84 int pixel_x, pixel_y; /* pixel width and height iterators */ 85 int block_x, block_y; /* block width and height iterators */ 86 int blocks_wide, blocks_high; /* width and height in 4x4 blocks */ 87 int block_inc; 88 int row_dec; 89 90 /* decoding parameters */ 91 int stream_ptr; 92 unsigned char byte_a, byte_b; 93 unsigned short flags; 94 int skip_blocks; 95 unsigned char colors[8]; 96 97 stream_ptr = 0; 98 skip_blocks = 0; 99 blocks_wide = width / 4; 100 blocks_high = height / 4; 101 total_blocks = blocks_wide * blocks_high; 102 block_inc = 4; 103 #ifdef ORIGINAL 104 row_dec = stride + 4; 105 #else 106 row_dec = - (stride - 4); /* such that -row_dec > 0 */ 107 #endif 108 109 for (block_y = blocks_high; block_y > 0; block_y--) { 110 #ifdef ORIGINAL 111 block_ptr = ((block_y * 4) - 1) * stride; 112 #else 113 block_ptr = ((blocks_high - block_y) * 4) * stride; 114 #endif 115 for (block_x = blocks_wide; block_x > 0; block_x--) { 116 /* check if this block should be skipped */ 117 if (skip_blocks) { 118 block_ptr += block_inc; 119 skip_blocks--; 120 total_blocks--; 121 continue; 122 } 123 124 pixel_ptr = block_ptr; 125 126 /* get the next two bytes in the encoded data stream */ 127 CHECK_STREAM_PTR(2); 128 byte_a = buf[stream_ptr++]; 129 byte_b = buf[stream_ptr++]; 130 131 /* check if the decode is finished */ 132 if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0)) 133 return; 134 else if ((byte_b & 0xFC) == 0x84) { 135 /* skip code, but don't count the current block */ 136 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1; 137 } else if (byte_b < 0x80) { 138 /* 2-color encoding */ 139 flags = (byte_b << 8) | byte_a; 140 141 CHECK_STREAM_PTR(2); 142 colors[0] = buf[stream_ptr++]; 143 colors[1] = buf[stream_ptr++]; 144 145 for (pixel_y = 0; pixel_y < 4; pixel_y++) { 146 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1) 147 pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1]; 148 pixel_ptr -= row_dec; 149 } 150 } else if (byte_b >= 0x90) { 151 /* 8-color encoding */ 152 flags = (byte_b << 8) | byte_a; 153 154 CHECK_STREAM_PTR(8); 155 memcpy(colors, &buf[stream_ptr], 8); 156 stream_ptr += 8; 157 158 for (pixel_y = 0; pixel_y < 4; pixel_y++) { 159 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1) 160 pixels[pixel_ptr++] = 161 colors[((pixel_y & 0x2) << 1) + 162 (pixel_x & 0x2) + ((flags & 0x1) ^ 1)]; 163 pixel_ptr -= row_dec; 164 } 165 } else { 166 /* 1-color encoding */ 167 colors[0] = byte_a; 168 169 for (pixel_y = 0; pixel_y < 4; pixel_y++) { 170 for (pixel_x = 0; pixel_x < 4; pixel_x++) 171 pixels[pixel_ptr++] = colors[0]; 172 pixel_ptr -= row_dec; 173 } 174 } 175 176 block_ptr += block_inc; 177 total_blocks--; 178 } 179 } 180 } 181 182 static void 183 msvideo1_decode_16bit( int width, int height, const unsigned char *buf, int buf_size, 184 unsigned short *pixels, int stride) 185 { 186 int block_ptr, pixel_ptr; 187 int total_blocks; 188 int pixel_x, pixel_y; /* pixel width and height iterators */ 189 int block_x, block_y; /* block width and height iterators */ 190 int blocks_wide, blocks_high; /* width and height in 4x4 blocks */ 191 int block_inc; 192 int row_dec; 193 194 /* decoding parameters */ 195 int stream_ptr; 196 unsigned char byte_a, byte_b; 197 unsigned short flags; 198 int skip_blocks; 199 unsigned short colors[8]; 200 201 stream_ptr = 0; 202 skip_blocks = 0; 203 blocks_wide = width / 4; 204 blocks_high = height / 4; 205 total_blocks = blocks_wide * blocks_high; 206 block_inc = 4; 207 #ifdef ORIGINAL 208 row_dec = stride + 4; 209 #else 210 row_dec = - (stride - 4); /* such that -row_dec > 0 */ 211 #endif 212 213 for (block_y = blocks_high; block_y > 0; block_y--) { 214 #ifdef ORIGINAL 215 block_ptr = ((block_y * 4) - 1) * stride; 216 #else 217 block_ptr = ((blocks_high - block_y) * 4) * stride; 218 #endif 219 for (block_x = blocks_wide; block_x > 0; block_x--) { 220 /* check if this block should be skipped */ 221 if (skip_blocks) { 222 block_ptr += block_inc; 223 skip_blocks--; 224 total_blocks--; 225 continue; 226 } 227 228 pixel_ptr = block_ptr; 229 230 /* get the next two bytes in the encoded data stream */ 231 CHECK_STREAM_PTR(2); 232 byte_a = buf[stream_ptr++]; 233 byte_b = buf[stream_ptr++]; 234 235 /* check if the decode is finished */ 236 if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0)) { 237 return; 238 } else if ((byte_b & 0xFC) == 0x84) { 239 /* skip code, but don't count the current block */ 240 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1; 241 } else if (byte_b < 0x80) { 242 /* 2- or 8-color encoding modes */ 243 flags = (byte_b << 8) | byte_a; 244 245 CHECK_STREAM_PTR(4); 246 colors[0] = LE_16(&buf[stream_ptr]); 247 stream_ptr += 2; 248 colors[1] = LE_16(&buf[stream_ptr]); 249 stream_ptr += 2; 250 251 if (colors[0] & 0x8000) { 252 /* 8-color encoding */ 253 CHECK_STREAM_PTR(12); 254 colors[2] = LE_16(&buf[stream_ptr]); 255 stream_ptr += 2; 256 colors[3] = LE_16(&buf[stream_ptr]); 257 stream_ptr += 2; 258 colors[4] = LE_16(&buf[stream_ptr]); 259 stream_ptr += 2; 260 colors[5] = LE_16(&buf[stream_ptr]); 261 stream_ptr += 2; 262 colors[6] = LE_16(&buf[stream_ptr]); 263 stream_ptr += 2; 264 colors[7] = LE_16(&buf[stream_ptr]); 265 stream_ptr += 2; 266 267 for (pixel_y = 0; pixel_y < 4; pixel_y++) { 268 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1) 269 pixels[pixel_ptr++] = 270 colors[((pixel_y & 0x2) << 1) + 271 (pixel_x & 0x2) + ((flags & 0x1) ^ 1)]; 272 pixel_ptr -= row_dec; 273 } 274 } else { 275 /* 2-color encoding */ 276 for (pixel_y = 0; pixel_y < 4; pixel_y++) { 277 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1) 278 pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1]; 279 pixel_ptr -= row_dec; 280 } 281 } 282 } else { 283 /* otherwise, it's a 1-color block */ 284 colors[0] = (byte_b << 8) | byte_a; 285 286 for (pixel_y = 0; pixel_y < 4; pixel_y++) { 287 for (pixel_x = 0; pixel_x < 4; pixel_x++) 288 pixels[pixel_ptr++] = colors[0]; 289 pixel_ptr -= row_dec; 290 } 291 } 292 293 block_ptr += block_inc; 294 total_blocks--; 295 } 296 } 297 } 298 299 static LRESULT 300 CRAM_DecompressQuery( Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out ) 301 { 302 TRACE("ICM_DECOMPRESS_QUERY %p %p %p\n", info, in, out); 303 304 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) ) 305 return ICERR_BADPARAM; 306 307 TRACE("in->planes = %d\n", in->bmiHeader.biPlanes ); 308 TRACE("in->bpp = %d\n", in->bmiHeader.biBitCount ); 309 TRACE("in->height = %d\n", in->bmiHeader.biHeight ); 310 TRACE("in->width = %d\n", in->bmiHeader.biWidth ); 311 TRACE("in->compr = 0x%x\n", in->bmiHeader.biCompression ); 312 313 if( ( in->bmiHeader.biCompression != CRAM_MAGIC ) && 314 ( in->bmiHeader.biCompression != MSVC_MAGIC ) && 315 ( in->bmiHeader.biCompression != WHAM_MAGIC ) ) 316 { 317 TRACE("can't do 0x%x compression\n", in->bmiHeader.biCompression); 318 return ICERR_BADFORMAT; 319 } 320 321 if( ( in->bmiHeader.biBitCount != 16 ) && 322 ( in->bmiHeader.biBitCount != 8 ) ) 323 { 324 TRACE("can't do %d bpp\n", in->bmiHeader.biBitCount ); 325 return ICERR_BADFORMAT; 326 } 327 328 /* output must be same dimensions as input */ 329 if( out ) 330 { 331 TRACE("out->planes = %d\n", out->bmiHeader.biPlanes ); 332 TRACE("out->bpp = %d\n", out->bmiHeader.biBitCount ); 333 TRACE("out->height = %d\n", out->bmiHeader.biHeight ); 334 TRACE("out->width = %d\n", out->bmiHeader.biWidth ); 335 336 if ((in->bmiHeader.biBitCount != out->bmiHeader.biBitCount) && 337 (in->bmiHeader.biBitCount != 16 || out->bmiHeader.biBitCount != 24)) 338 { 339 TRACE("incompatible depth requested\n"); 340 return ICERR_BADFORMAT; 341 } 342 343 if(( in->bmiHeader.biPlanes != out->bmiHeader.biPlanes ) || 344 ( in->bmiHeader.biHeight != out->bmiHeader.biHeight ) || 345 ( in->bmiHeader.biWidth != out->bmiHeader.biWidth )) 346 { 347 TRACE("incompatible output requested\n"); 348 return ICERR_BADFORMAT; 349 } 350 } 351 352 TRACE("OK!\n"); 353 return ICERR_OK; 354 } 355 356 static LRESULT 357 CRAM_DecompressGetFormat( Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out ) 358 { 359 DWORD size; 360 361 TRACE("ICM_DECOMPRESS_GETFORMAT %p %p %p\n", info, in, out); 362 363 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) ) 364 return ICERR_BADPARAM; 365 366 size = in->bmiHeader.biSize; 367 if (in->bmiHeader.biBitCount <= 8) 368 size += in->bmiHeader.biClrUsed * sizeof(RGBQUAD); 369 370 if (in->bmiHeader.biBitCount != 8 && in->bmiHeader.biBitCount != 16) 371 return ICERR_BADFORMAT; 372 373 if( out ) 374 { 375 memcpy( out, in, size ); 376 out->bmiHeader.biWidth = in->bmiHeader.biWidth & ~1; 377 out->bmiHeader.biHeight = in->bmiHeader.biHeight & ~1; 378 out->bmiHeader.biCompression = BI_RGB; 379 out->bmiHeader.biSizeImage = in->bmiHeader.biHeight * 380 get_stride(out->bmiHeader.biWidth, out->bmiHeader.biBitCount); 381 return ICERR_OK; 382 } 383 384 return size; 385 } 386 387 static LRESULT CRAM_DecompressBegin( Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out ) 388 { 389 TRACE("ICM_DECOMPRESS_BEGIN %p %p %p\n", info, in, out); 390 391 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) ) 392 return ICERR_BADPARAM; 393 394 TRACE("bitmap is %d bpp\n", in->bmiHeader.biBitCount); 395 if( in->bmiHeader.biBitCount == 8 ) 396 info->depth = 8; 397 else if( in->bmiHeader.biBitCount == 16 ) 398 info->depth = 16; 399 else 400 { 401 info->depth = 0; 402 FIXME("Unsupported output format %i\n", in->bmiHeader.biBitCount); 403 } 404 405 return ICERR_OK; 406 } 407 408 static void convert_depth(char *input, int depth_in, char *output, BITMAPINFOHEADER *out_hdr) 409 { 410 int x, y; 411 int stride_in = get_stride(out_hdr->biWidth, depth_in); 412 int stride_out = get_stride(out_hdr->biWidth, out_hdr->biBitCount); 413 414 if (depth_in == 16 && out_hdr->biBitCount == 24) 415 { 416 static const unsigned char convert_5to8[] = 417 { 418 0x00, 0x08, 0x10, 0x19, 0x21, 0x29, 0x31, 0x3a, 419 0x42, 0x4a, 0x52, 0x5a, 0x63, 0x6b, 0x73, 0x7b, 420 0x84, 0x8c, 0x94, 0x9c, 0xa5, 0xad, 0xb5, 0xbd, 421 0xc5, 0xce, 0xd6, 0xde, 0xe6, 0xef, 0xf7, 0xff, 422 }; 423 424 for (y = 0; y < out_hdr->biHeight; y++) 425 { 426 WORD *src_row = (WORD *)(input + y * stride_in); 427 char *out_row = output + y * stride_out; 428 429 for (x = 0; x < out_hdr->biWidth; x++) 430 { 431 WORD pixel = *src_row++; 432 *out_row++ = convert_5to8[(pixel & 0x7c00u) >> 10]; 433 *out_row++ = convert_5to8[(pixel & 0x03e0u) >> 5]; 434 *out_row++ = convert_5to8[(pixel & 0x001fu)]; 435 } 436 } 437 } 438 else 439 FIXME("Conversion from %d to %d bit unimplemented\n", depth_in, out_hdr->biBitCount); 440 } 441 442 static LRESULT CRAM_Decompress( Msvideo1Context *info, ICDECOMPRESS *icd, DWORD size ) 443 { 444 LONG width, height, stride, sz; 445 void *output; 446 447 TRACE("ICM_DECOMPRESS %p %p %d\n", info, icd, size); 448 449 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) ) 450 return ICERR_BADPARAM; 451 452 /* FIXME: flags are ignored */ 453 454 width = icd->lpbiInput->biWidth; 455 height = icd->lpbiInput->biHeight; 456 sz = icd->lpbiInput->biSizeImage; 457 458 output = icd->lpOutput; 459 460 if (icd->lpbiOutput->biBitCount != info->depth) 461 { 462 output = HeapAlloc(GetProcessHeap(), 0, icd->lpbiOutput->biWidth * icd->lpbiOutput->biHeight * info->depth / 8); 463 if (!output) return ICERR_MEMORY; 464 } 465 466 if (info->depth == 8) 467 { 468 stride = get_stride(width, 8); 469 msvideo1_decode_8bit( width, height, icd->lpInput, sz, 470 output, stride ); 471 } 472 else 473 { 474 stride = get_stride(width, 16) / 2; 475 msvideo1_decode_16bit( width, height, icd->lpInput, sz, 476 output, stride ); 477 } 478 479 if (icd->lpbiOutput->biBitCount != info->depth) 480 { 481 convert_depth(output, info->depth, icd->lpOutput, icd->lpbiOutput); 482 HeapFree(GetProcessHeap(), 0, output); 483 } 484 485 return ICERR_OK; 486 } 487 488 static LRESULT CRAM_DecompressEx( Msvideo1Context *info, ICDECOMPRESSEX *icd, DWORD size ) 489 { 490 LONG width, height, stride, sz; 491 void *output; 492 493 TRACE("ICM_DECOMPRESSEX %p %p %d\n", info, icd, size); 494 495 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) ) 496 return ICERR_BADPARAM; 497 498 /* FIXME: flags are ignored */ 499 500 width = icd->lpbiSrc->biWidth; 501 height = icd->lpbiSrc->biHeight; 502 sz = icd->lpbiSrc->biSizeImage; 503 504 output = icd->lpDst; 505 506 if (icd->lpbiDst->biBitCount != info->depth) 507 { 508 output = HeapAlloc(GetProcessHeap(), 0, icd->lpbiDst->biWidth * icd->lpbiDst->biHeight * info->depth / 8); 509 if (!output) return ICERR_MEMORY; 510 } 511 512 if (info->depth == 8) 513 { 514 stride = get_stride(width, 8); 515 msvideo1_decode_8bit( width, height, icd->lpSrc, sz, 516 output, stride ); 517 } 518 else 519 { 520 stride = get_stride(width, 16) / 2; 521 msvideo1_decode_16bit( width, height, icd->lpSrc, sz, 522 output, stride ); 523 } 524 525 if (icd->lpbiDst->biBitCount != info->depth) 526 { 527 convert_depth(output, info->depth, icd->lpDst, icd->lpbiDst); 528 HeapFree(GetProcessHeap(), 0, output); 529 } 530 531 return ICERR_OK; 532 } 533 534 static LRESULT CRAM_GetInfo( const Msvideo1Context *info, ICINFO *icinfo, DWORD dwSize ) 535 { 536 if (!icinfo) return sizeof(ICINFO); 537 if (dwSize < sizeof(ICINFO)) return 0; 538 539 icinfo->dwSize = sizeof(ICINFO); 540 icinfo->fccType = ICTYPE_VIDEO; 541 icinfo->fccHandler = info ? info->dwMagic : CRAM_MAGIC; 542 icinfo->dwFlags = 0; 543 icinfo->dwVersion = ICVERSION; 544 icinfo->dwVersionICM = ICVERSION; 545 546 LoadStringW(MSVIDC32_hModule, IDS_NAME, icinfo->szName, ARRAY_SIZE(icinfo->szName)); 547 LoadStringW(MSVIDC32_hModule, IDS_DESCRIPTION, icinfo->szDescription, ARRAY_SIZE(icinfo->szDescription)); 548 /* msvfw32 will fill icinfo->szDriver for us */ 549 550 return sizeof(ICINFO); 551 } 552 553 /*********************************************************************** 554 * DriverProc (MSVIDC32.@) 555 */ 556 LRESULT WINAPI CRAM_DriverProc( DWORD_PTR dwDriverId, HDRVR hdrvr, UINT msg, 557 LPARAM lParam1, LPARAM lParam2 ) 558 { 559 Msvideo1Context *info = (Msvideo1Context *) dwDriverId; 560 LRESULT r = ICERR_UNSUPPORTED; 561 562 TRACE("%ld %p %04x %08lx %08lx\n", dwDriverId, hdrvr, msg, lParam1, lParam2); 563 564 switch( msg ) 565 { 566 case DRV_LOAD: 567 TRACE("Loaded\n"); 568 r = 1; 569 break; 570 571 case DRV_ENABLE: 572 break; 573 574 case DRV_OPEN: 575 { 576 ICINFO *icinfo = (ICINFO *)lParam2; 577 578 TRACE("Opened\n"); 579 580 if (icinfo && compare_fourcc(icinfo->fccType, ICTYPE_VIDEO)) return 0; 581 582 info = HeapAlloc( GetProcessHeap(), 0, sizeof (Msvideo1Context) ); 583 if( info ) 584 { 585 memset( info, 0, sizeof *info ); 586 info->dwMagic = CRAM_MAGIC; 587 } 588 r = (LRESULT) info; 589 break; 590 } 591 592 case DRV_CLOSE: 593 HeapFree( GetProcessHeap(), 0, info ); 594 break; 595 596 case DRV_DISABLE: 597 break; 598 599 case DRV_FREE: 600 break; 601 602 case ICM_GETINFO: 603 r = CRAM_GetInfo( info, (ICINFO *)lParam1, (DWORD)lParam2 ); 604 break; 605 606 case ICM_DECOMPRESS_QUERY: 607 r = CRAM_DecompressQuery( info, (LPBITMAPINFO) lParam1, 608 (LPBITMAPINFO) lParam2 ); 609 break; 610 611 case ICM_DECOMPRESS_GET_FORMAT: 612 r = CRAM_DecompressGetFormat( info, (LPBITMAPINFO) lParam1, 613 (LPBITMAPINFO) lParam2 ); 614 break; 615 616 case ICM_DECOMPRESS_GET_PALETTE: 617 FIXME("ICM_DECOMPRESS_GET_PALETTE\n"); 618 break; 619 620 case ICM_DECOMPRESSEX_QUERY: 621 FIXME("ICM_DECOMPRESSEX_QUERY\n"); 622 break; 623 624 case ICM_DECOMPRESS: 625 r = CRAM_Decompress( info, (ICDECOMPRESS*) lParam1, 626 (DWORD) lParam2 ); 627 break; 628 629 case ICM_DECOMPRESS_BEGIN: 630 r = CRAM_DecompressBegin( info, (LPBITMAPINFO) lParam1, 631 (LPBITMAPINFO) lParam2 ); 632 break; 633 634 case ICM_DECOMPRESSEX: 635 r = CRAM_DecompressEx( info, (ICDECOMPRESSEX*) lParam1, 636 (DWORD) lParam2 ); 637 break; 638 639 case ICM_DECOMPRESS_END: 640 r = ICERR_OK; 641 break; 642 643 case ICM_COMPRESS_QUERY: 644 r = ICERR_BADFORMAT; 645 /* fall through */ 646 case ICM_COMPRESS_GET_FORMAT: 647 case ICM_COMPRESS_END: 648 case ICM_COMPRESS: 649 FIXME("compression not implemented\n"); 650 break; 651 652 case ICM_CONFIGURE: 653 break; 654 655 default: 656 FIXME("Unknown message: %04x %ld %ld\n", msg, lParam1, lParam2); 657 } 658 659 return r; 660 } 661 662 /*********************************************************************** 663 * DllMain 664 */ 665 BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved) 666 { 667 TRACE("(%p,%d,%p)\n", hModule, dwReason, lpReserved); 668 669 switch (dwReason) 670 { 671 case DLL_PROCESS_ATTACH: 672 DisableThreadLibraryCalls(hModule); 673 MSVIDC32_hModule = hModule; 674 break; 675 } 676 return TRUE; 677 } 678