dlls/msvidc32/msvideo1.c

   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     BOOL mode_8bit;  /* if it's not 8-bit, it's 16-bit */
  71 } Msvideo1Context;
  72
  73 static void
  74 msvideo1_decode_8bit( int width, int height, const unsigned char *buf, int buf_size,
  75                       unsigned char *pixels, int stride)
  76 {
  77     int block_ptr, pixel_ptr;
  78     int total_blocks;
  79     int pixel_x, pixel_y;  /* pixel width and height iterators */
  80     int block_x, block_y;  /* block width and height iterators */
  81     int blocks_wide, blocks_high;  /* width and height in 4x4 blocks */
  82     int block_inc;
  83     int row_dec;
  84
  85     /* decoding parameters */
  86     int stream_ptr;
  87     unsigned char byte_a, byte_b;
  88     unsigned short flags;
  89     int skip_blocks;
  90     unsigned char colors[8];
  91
  92     stream_ptr = 0;
  93     skip_blocks = 0;
  94     blocks_wide = width / 4;
  95     blocks_high = height / 4;
  96     total_blocks = blocks_wide * blocks_high;
  97     block_inc = 4;
  98 #ifdef ORIGINAL
  99     row_dec = stride + 4;
 100 #else
 101     row_dec = - (stride - 4); /* such that -row_dec > 0 */
 102 #endif
 103
 104     for (block_y = blocks_high; block_y > 0; block_y--) {
 105 #ifdef ORIGINAL
 106         block_ptr = ((block_y * 4) - 1) * stride;
 107 #else
 108         block_ptr = ((blocks_high - block_y) * 4) * stride;
 109 #endif
 110         for (block_x = blocks_wide; block_x > 0; block_x--) {
 111             /* check if this block should be skipped */
 112             if (skip_blocks) {
 113                 block_ptr += block_inc;
 114                 skip_blocks--;
 115                 total_blocks--;
 116                 continue;
 117             }
 118
 119             pixel_ptr = block_ptr;
 120
 121             /* get the next two bytes in the encoded data stream */
 122             CHECK_STREAM_PTR(2);
 123             byte_a = buf[stream_ptr++];
 124             byte_b = buf[stream_ptr++];
 125
 126             /* check if the decode is finished */
 127             if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0))
 128                 return;
 129             else if ((byte_b & 0xFC) == 0x84) {
 130                 /* skip code, but don't count the current block */
 131                 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
 132             } else if (byte_b < 0x80) {
 133                 /* 2-color encoding */
 134                 flags = (byte_b << 8) | byte_a;
 135
 136                 CHECK_STREAM_PTR(2);
 137                 colors[0] = buf[stream_ptr++];
 138                 colors[1] = buf[stream_ptr++];
 139
 140                 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
 141                     for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
 142                         pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
 143                     pixel_ptr -= row_dec;
 144                 }
 145             } else if (byte_b >= 0x90) {
 146                 /* 8-color encoding */
 147                 flags = (byte_b << 8) | byte_a;
 148
 149                 CHECK_STREAM_PTR(8);
 150                 memcpy(colors, &buf[stream_ptr], 8);
 151                 stream_ptr += 8;
 152
 153                 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
 154                     for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
 155                         pixels[pixel_ptr++] =
 156                             colors[((pixel_y & 0x2) << 1) +
 157                                 (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
 158                     pixel_ptr -= row_dec;
 159                 }
 160             } else {
 161                 /* 1-color encoding */
 162                 colors[0] = byte_a;
 163
 164                 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
 165                     for (pixel_x = 0; pixel_x < 4; pixel_x++)
 166                         pixels[pixel_ptr++] = colors[0];
 167                     pixel_ptr -= row_dec;
 168                 }
 169             }
 170
 171             block_ptr += block_inc;
 172             total_blocks--;
 173         }
 174     }
 175 }
 176
 177 static void
 178 msvideo1_decode_16bit( int width, int height, const unsigned char *buf, int buf_size,
 179                        unsigned short *pixels, int stride)
 180 {
 181     int block_ptr, pixel_ptr;
 182     int total_blocks;
 183     int pixel_x, pixel_y;  /* pixel width and height iterators */
 184     int block_x, block_y;  /* block width and height iterators */
 185     int blocks_wide, blocks_high;  /* width and height in 4x4 blocks */
 186     int block_inc;
 187     int row_dec;
 188
 189     /* decoding parameters */
 190     int stream_ptr;
 191     unsigned char byte_a, byte_b;
 192     unsigned short flags;
 193     int skip_blocks;
 194     unsigned short colors[8];
 195
 196     stream_ptr = 0;
 197     skip_blocks = 0;
 198     blocks_wide = width / 4;
 199     blocks_high = height / 4;
 200     total_blocks = blocks_wide * blocks_high;
 201     block_inc = 4;
 202 #ifdef ORIGINAL
 203     row_dec = stride + 4;
 204 #else
 205     row_dec = - (stride - 4); /* such that -row_dec > 0 */
 206 #endif
 207
 208     for (block_y = blocks_high; block_y > 0; block_y--) {
 209 #ifdef ORIGINAL
 210         block_ptr = ((block_y * 4) - 1) * stride;
 211 #else
 212         block_ptr = ((blocks_high - block_y) * 4) * stride;
 213 #endif
 214         for (block_x = blocks_wide; block_x > 0; block_x--) {
 215             /* check if this block should be skipped */
 216             if (skip_blocks) {
 217                 block_ptr += block_inc;
 218                 skip_blocks--;
 219                 total_blocks--;
 220                 continue;
 221             }
 222
 223             pixel_ptr = block_ptr;
 224
 225             /* get the next two bytes in the encoded data stream */
 226             CHECK_STREAM_PTR(2);
 227             byte_a = buf[stream_ptr++];
 228             byte_b = buf[stream_ptr++];
 229
 230             /* check if the decode is finished */
 231             if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0)) {
 232                 return;
 233             } else if ((byte_b & 0xFC) == 0x84) {
 234                 /* skip code, but don't count the current block */
 235                 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
 236             } else if (byte_b < 0x80) {
 237                 /* 2- or 8-color encoding modes */
 238                 flags = (byte_b << 8) | byte_a;
 239
 240                 CHECK_STREAM_PTR(4);
 241                 colors[0] = LE_16(&buf[stream_ptr]);
 242                 stream_ptr += 2;
 243                 colors[1] = LE_16(&buf[stream_ptr]);
 244                 stream_ptr += 2;
 245
 246                 if (colors[0] & 0x8000) {
 247                     /* 8-color encoding */
 248                     CHECK_STREAM_PTR(12);
 249                     colors[2] = LE_16(&buf[stream_ptr]);
 250                     stream_ptr += 2;
 251                     colors[3] = LE_16(&buf[stream_ptr]);
 252                     stream_ptr += 2;
 253                     colors[4] = LE_16(&buf[stream_ptr]);
 254                     stream_ptr += 2;
 255                     colors[5] = LE_16(&buf[stream_ptr]);
 256                     stream_ptr += 2;
 257                     colors[6] = LE_16(&buf[stream_ptr]);
 258                     stream_ptr += 2;
 259                     colors[7] = LE_16(&buf[stream_ptr]);
 260                     stream_ptr += 2;
 261
 262                     for (pixel_y = 0; pixel_y < 4; pixel_y++) {
 263                         for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
 264                             pixels[pixel_ptr++] =
 265                                 colors[((pixel_y & 0x2) << 1) +
 266                                     (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
 267                         pixel_ptr -= row_dec;
 268                     }
 269                 } else {
 270                     /* 2-color encoding */
 271                     for (pixel_y = 0; pixel_y < 4; pixel_y++) {
 272                         for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
 273                             pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
 274                         pixel_ptr -= row_dec;
 275                     }
 276                 }
 277             } else {
 278                 /* otherwise, it's a 1-color block */
 279                 colors[0] = (byte_b << 8) | byte_a;
 280
 281                 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
 282                     for (pixel_x = 0; pixel_x < 4; pixel_x++)
 283                         pixels[pixel_ptr++] = colors[0];
 284                     pixel_ptr -= row_dec;
 285                 }
 286             }
 287
 288             block_ptr += block_inc;
 289             total_blocks--;
 290         }
 291     }
 292 }
 293
 294 static LRESULT
 295 CRAM_DecompressQuery( Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out )
 296 {
 297     TRACE("ICM_DECOMPRESS_QUERY %p %p %p\n", info, in, out);
 298
 299     if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
 300         return ICERR_BADPARAM;
 301
 302     TRACE("in->planes  = %d\n", in->bmiHeader.biPlanes );
 303     TRACE("in->bpp     = %d\n", in->bmiHeader.biBitCount );
 304     TRACE("in->height  = %d\n", in->bmiHeader.biHeight );
 305     TRACE("in->width   = %d\n", in->bmiHeader.biWidth );
 306     TRACE("in->compr   = 0x%x\n", in->bmiHeader.biCompression );
 307
 308     if( ( in->bmiHeader.biCompression != CRAM_MAGIC ) &&
 309         ( in->bmiHeader.biCompression != MSVC_MAGIC ) &&
 310         ( in->bmiHeader.biCompression != WHAM_MAGIC ) )
 311     {
 312         TRACE("can't do 0x%x compression\n", in->bmiHeader.biCompression);
 313         return ICERR_BADFORMAT;
 314     }
 315
 316     if( ( in->bmiHeader.biBitCount != 16 ) &&
 317         ( in->bmiHeader.biBitCount != 8 ) )
 318     {
 319         TRACE("can't do %d bpp\n", in->bmiHeader.biBitCount );
 320         return ICERR_BADFORMAT;
 321     }
 322
 323     /* output must be same dimensions as input */
 324     if( out )
 325     {
 326         TRACE("out->planes = %d\n", out->bmiHeader.biPlanes );
 327         TRACE("out->bpp    = %d\n", out->bmiHeader.biBitCount );
 328         TRACE("out->height = %d\n", out->bmiHeader.biHeight );
 329         TRACE("out->width  = %d\n", out->bmiHeader.biWidth );
 330         if(( in->bmiHeader.biBitCount != out->bmiHeader.biBitCount ) ||
 331           ( in->bmiHeader.biPlanes != out->bmiHeader.biPlanes ) ||
 332           ( in->bmiHeader.biHeight != out->bmiHeader.biHeight ) ||
 333           ( in->bmiHeader.biWidth != out->bmiHeader.biWidth ))
 334         {
 335             TRACE("incompatible output requested\n");
 336             return ICERR_BADFORMAT;
 337         }
 338     }
 339
 340     TRACE("OK!\n");
 341     return ICERR_OK;
 342 }
 343
 344 static LRESULT
 345 CRAM_DecompressGetFormat( Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out )
 346 {
 347     DWORD size;
 348
 349     TRACE("ICM_DECOMPRESS_GETFORMAT %p %p %p\n", info, in, out);
 350
 351     if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
 352         return ICERR_BADPARAM;
 353
 354     size = in->bmiHeader.biSize;
 355     if (in->bmiHeader.biBitCount <= 8)
 356         size += in->bmiHeader.biClrUsed * sizeof(RGBQUAD);
 357
 358     if( out )
 359     {
 360         memcpy( out, in, size );
 361         out->bmiHeader.biCompression = BI_RGB;
 362         out->bmiHeader.biSizeImage = in->bmiHeader.biHeight
 363                                    * in->bmiHeader.biWidth *4;
 364         return ICERR_OK;
 365     }
 366
 367     return size;
 368 }
 369
 370 static LRESULT CRAM_DecompressBegin( Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out )
 371 {
 372     TRACE("ICM_DECOMPRESS_BEGIN %p %p %p\n", info, in, out);
 373
 374     if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
 375         return ICERR_BADPARAM;
 376
 377     TRACE("bitmap is %d bpp\n", in->bmiHeader.biBitCount);
 378     if( in->bmiHeader.biBitCount == 8 )
 379         info->mode_8bit = TRUE;
 380     else if( in->bmiHeader.biBitCount == 16 )
 381         info->mode_8bit = FALSE;
 382     else
 383     {
 384         info->mode_8bit = FALSE;
 385         FIXME("Unsupported output format %i\n", in->bmiHeader.biBitCount);
 386     }
 387
 388     return ICERR_OK;
 389 }
 390
 391 static LRESULT CRAM_Decompress( Msvideo1Context *info, ICDECOMPRESS *icd, DWORD size )
 392 {
 393     LONG width, height, stride, sz;
 394
 395     TRACE("ICM_DECOMPRESS %p %p %d\n", info, icd, size);
 396
 397     if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
 398         return ICERR_BADPARAM;
 399
 400     /* FIXME: flags are ignored */
 401
 402     width  = icd->lpbiInput->biWidth;
 403     height = icd->lpbiInput->biHeight;
 404     stride = width; /* in bytes or 16bit words */
 405     sz = icd->lpbiInput->biSizeImage;
 406
 407     if (info->mode_8bit)
 408     {
 409         msvideo1_decode_8bit( width, height, icd->lpInput, sz,
 410                               icd->lpOutput, stride);
 411     }
 412     else
 413     {
 414         msvideo1_decode_16bit( width, height, icd->lpInput, sz,
 415                                icd->lpOutput, stride);
 416     }
 417
 418     return ICERR_OK;
 419 }
 420
 421 static LRESULT CRAM_DecompressEx( Msvideo1Context *info, ICDECOMPRESSEX *icd, DWORD size )
 422 {
 423     LONG width, height, stride, sz;
 424
 425     TRACE("ICM_DECOMPRESSEX %p %p %d\n", info, icd, size);
 426
 427     if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
 428         return ICERR_BADPARAM;
 429
 430     /* FIXME: flags are ignored */
 431
 432     width  = icd->lpbiSrc->biWidth;
 433     height = icd->lpbiSrc->biHeight;
 434     stride = width;
 435     sz = icd->lpbiSrc->biSizeImage;
 436
 437     if (info->mode_8bit)
 438     {
 439         msvideo1_decode_8bit( width, height, icd->lpSrc, sz,
 440                              icd->lpDst, stride);
 441     }
 442     else
 443     {
 444         msvideo1_decode_16bit( width, height, icd->lpSrc, sz,
 445                               icd->lpDst, stride);
 446     }
 447
 448     return ICERR_OK;
 449 }
 450
 451 static LRESULT CRAM_GetInfo( const Msvideo1Context *info, ICINFO *icinfo, DWORD dwSize )
 452 {
 453     if (!icinfo) return sizeof(ICINFO);
 454     if (dwSize < sizeof(ICINFO)) return 0;
 455
 456     icinfo->dwSize = sizeof(ICINFO);
 457     icinfo->fccType = ICTYPE_VIDEO;
 458     icinfo->fccHandler = info ? info->dwMagic : CRAM_MAGIC;
 459     icinfo->dwFlags = 0;
 460     icinfo->dwVersion = ICVERSION;
 461     icinfo->dwVersionICM = ICVERSION;
 462
 463     LoadStringW(MSVIDC32_hModule, IDS_NAME, icinfo->szName, sizeof(icinfo->szName)/sizeof(WCHAR));
 464     LoadStringW(MSVIDC32_hModule, IDS_DESCRIPTION, icinfo->szDescription, sizeof(icinfo->szDescription)/sizeof(WCHAR));
 465     /* msvfw32 will fill icinfo->szDriver for us */
 466
 467     return sizeof(ICINFO);
 468 }
 469
 470 /***********************************************************************
 471  *              DriverProc (MSVIDC32.@)
 472  */
 473 LRESULT WINAPI CRAM_DriverProc( DWORD_PTR dwDriverId, HDRVR hdrvr, UINT msg,
 474                                 LPARAM lParam1, LPARAM lParam2 )
 475 {
 476     Msvideo1Context *info = (Msvideo1Context *) dwDriverId;
 477     LRESULT r = ICERR_UNSUPPORTED;
 478
 479     TRACE("%ld %p %04x %08lx %08lx\n", dwDriverId, hdrvr, msg, lParam1, lParam2);
 480
 481     switch( msg )
 482     {
 483     case DRV_LOAD:
 484         TRACE("Loaded\n");
 485         r = 1;
 486         break;
 487
 488     case DRV_ENABLE:
 489         break;
 490
 491     case DRV_OPEN:
 492     {
 493         ICINFO *icinfo = (ICINFO *)lParam2;
 494
 495         TRACE("Opened\n");
 496
 497         if (icinfo && compare_fourcc(icinfo->fccType, ICTYPE_VIDEO)) return 0;
 498
 499         info = HeapAlloc( GetProcessHeap(), 0, sizeof (Msvideo1Context) );
 500         if( info )
 501         {
 502             memset( info, 0, sizeof *info );
 503             info->dwMagic = CRAM_MAGIC;
 504         }
 505         r = (LRESULT) info;
 506         break;
 507     }
 508
 509     case DRV_CLOSE:
 510         HeapFree( GetProcessHeap(), 0, info );
 511         break;
 512
 513     case DRV_DISABLE:
 514         break;
 515
 516     case DRV_FREE:
 517         break;
 518
 519     case ICM_GETINFO:
 520         r = CRAM_GetInfo( info, (ICINFO *)lParam1, (DWORD)lParam2 );
 521         break;
 522
 523     case ICM_DECOMPRESS_QUERY:
 524         r = CRAM_DecompressQuery( info, (LPBITMAPINFO) lParam1,
 525                                        (LPBITMAPINFO) lParam2 );
 526         break;
 527
 528     case ICM_DECOMPRESS_GET_FORMAT:
 529         r = CRAM_DecompressGetFormat( info, (LPBITMAPINFO) lParam1,
 530                                        (LPBITMAPINFO) lParam2 );
 531         break;
 532
 533     case ICM_DECOMPRESS_GET_PALETTE:
 534         FIXME("ICM_DECOMPRESS_GET_PALETTE\n");
 535         break;
 536
 537     case ICM_DECOMPRESSEX_QUERY:
 538         FIXME("ICM_DECOMPRESSEX_QUERY\n");
 539         break;
 540
 541     case ICM_DECOMPRESS:
 542         r = CRAM_Decompress( info, (ICDECOMPRESS*) lParam1,
 543                                   (DWORD) lParam2 );
 544         break;
 545
 546     case ICM_DECOMPRESS_BEGIN:
 547         r = CRAM_DecompressBegin( info, (LPBITMAPINFO) lParam1,
 548                                        (LPBITMAPINFO) lParam2 );
 549         break;
 550
 551     case ICM_DECOMPRESSEX:
 552         r = CRAM_DecompressEx( info, (ICDECOMPRESSEX*) lParam1,
 553                                   (DWORD) lParam2 );
 554         break;
 555
 556     case ICM_DECOMPRESS_END:
 557         r = ICERR_OK;
 558         break;
 559
 560     case ICM_COMPRESS_QUERY:
 561         r = ICERR_BADFORMAT;
 562         /* fall through */
 563     case ICM_COMPRESS_GET_FORMAT:
 564     case ICM_COMPRESS_END:
 565     case ICM_COMPRESS:
 566         FIXME("compression not implemented\n");
 567         break;
 568
 569     case ICM_CONFIGURE:
 570         break;
 571
 572     default:
 573         FIXME("Unknown message: %04x %ld %ld\n", msg, lParam1, lParam2);
 574     }
 575
 576     return r;
 577 }
 578
 579 /***********************************************************************
 580  *              DllMain
 581  */
 582 BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
 583 {
 584     TRACE("(%p,%d,%p)\n", hModule, dwReason, lpReserved);
 585
 586     switch (dwReason)
 587     {
 588     case DLL_PROCESS_ATTACH:
 589         DisableThreadLibraryCalls(hModule);
 590         MSVIDC32_hModule = hModule;
 591         break;
 592     }
 593     return TRUE;
 594 }