dlls/ir50_32/ir50.c

   1 /*
   2  * Intel Indeo 5 Video Decoder
   3  * Copyright 2023 Shaun Ren for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdlib.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "winuser.h"
  27 #include "commdlg.h"
  28 #include "vfw.h"
  29 #include "initguid.h"
  30 #include "ir50_private.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(ir50_32);
  35
  36 static HINSTANCE IR50_32_hModule;
  37
  38 #define IV50_MAGIC mmioFOURCC('I','V','5','0')
  39 #define compare_fourcc(fcc1, fcc2) (((fcc1)^(fcc2))&~0x20202020)
  40
  41 DEFINE_MEDIATYPE_GUID(MFVideoFormat_IV50, MAKEFOURCC('I','V','5','0'));
  42
  43 static inline UINT64
  44 make_uint64( UINT32 high, UINT32 low )
  45 {
  46     return ((UINT64)high << 32) | low;
  47 }
  48
  49
  50 static LRESULT
  51 IV50_Open( const ICINFO *icinfo )
  52 {
  53     IMFTransform *decoder = NULL;
  54
  55     TRACE("DRV_OPEN %p\n", icinfo);
  56
  57     if ( icinfo && compare_fourcc( icinfo->fccType, ICTYPE_VIDEO ) )
  58         return 0;
  59
  60     if ( FAILED(winegstreamer_create_video_decoder( &decoder )) )
  61         return 0;
  62
  63     return (LRESULT)decoder;
  64 }
  65
  66 static LRESULT
  67 IV50_DecompressQuery( LPBITMAPINFO in, LPBITMAPINFO out )
  68 {
  69     TRACE("ICM_DECOMPRESS_QUERY %p %p\n", in, out);
  70
  71     TRACE("in->planes  = %d\n", in->bmiHeader.biPlanes);
  72     TRACE("in->bpp     = %d\n", in->bmiHeader.biBitCount);
  73     TRACE("in->height  = %ld\n", in->bmiHeader.biHeight);
  74     TRACE("in->width   = %ld\n", in->bmiHeader.biWidth);
  75     TRACE("in->compr   = %#lx\n", in->bmiHeader.biCompression);
  76
  77     if ( in->bmiHeader.biCompression != IV50_MAGIC )
  78     {
  79         TRACE("can't do %#lx compression\n", in->bmiHeader.biCompression);
  80         return ICERR_BADFORMAT;
  81     }
  82
  83     /* output must be same dimensions as input */
  84     if ( out )
  85     {
  86         TRACE("out->planes = %d\n", out->bmiHeader.biPlanes);
  87         TRACE("out->bpp    = %d\n", out->bmiHeader.biBitCount);
  88         TRACE("out->height = %ld\n", out->bmiHeader.biHeight);
  89         TRACE("out->width  = %ld\n", out->bmiHeader.biWidth);
  90         TRACE("out->compr  = %#lx\n", out->bmiHeader.biCompression);
  91
  92         if ( out->bmiHeader.biCompression != BI_RGB )
  93         {
  94             TRACE("incompatible compression requested\n");
  95             return ICERR_BADFORMAT;
  96         }
  97
  98         if ( out->bmiHeader.biBitCount != 32 && out->bmiHeader.biBitCount != 24 && out->bmiHeader.biBitCount != 16 )
  99         {
 100             TRACE("incompatible depth requested\n");
 101             return ICERR_BADFORMAT;
 102         }
 103
 104         if ( in->bmiHeader.biPlanes != out->bmiHeader.biPlanes ||
 105              in->bmiHeader.biHeight != abs(out->bmiHeader.biHeight) ||
 106              in->bmiHeader.biWidth  != out->bmiHeader.biWidth )
 107         {
 108             TRACE("incompatible output dimensions requested\n");
 109             return ICERR_BADFORMAT;
 110         }
 111     }
 112
 113     return ICERR_OK;
 114 }
 115
 116 static LRESULT
 117 IV50_DecompressGetFormat( LPBITMAPINFO in, LPBITMAPINFO out )
 118 {
 119     DWORD size;
 120
 121     TRACE("ICM_DECOMPRESS_GETFORMAT %p %p\n", in, out);
 122
 123     if ( !in )
 124         return ICERR_BADPARAM;
 125
 126     if ( in->bmiHeader.biCompression != IV50_MAGIC )
 127         return ICERR_BADFORMAT;
 128
 129     size = in->bmiHeader.biSize;
 130     if ( out )
 131     {
 132         memcpy( out, in, size );
 133         out->bmiHeader.biHeight = abs(in->bmiHeader.biHeight);
 134         out->bmiHeader.biCompression = BI_RGB;
 135         out->bmiHeader.biBitCount = 32;
 136         out->bmiHeader.biSizeImage = out->bmiHeader.biWidth * out->bmiHeader.biHeight * 4;
 137         return ICERR_OK;
 138     }
 139
 140     return size;
 141 }
 142
 143 static LRESULT IV50_DecompressBegin( IMFTransform *decoder, LPBITMAPINFO in, LPBITMAPINFO out )
 144 {
 145     IMFMediaType *input_type, *output_type;
 146     const GUID *output_subtype;
 147     LRESULT r = ICERR_INTERNAL;
 148     unsigned int stride;
 149
 150     TRACE("ICM_DECOMPRESS_BEGIN %p %p %p\n", decoder, in, out);
 151
 152     if ( !decoder )
 153         return ICERR_BADPARAM;
 154
 155     if ( out->bmiHeader.biBitCount == 32 )
 156         output_subtype = &MFVideoFormat_RGB32;
 157     else if ( out->bmiHeader.biBitCount == 24 )
 158         output_subtype = &MFVideoFormat_RGB24;
 159     else if ( out->bmiHeader.biBitCount == 16 )
 160         output_subtype = &MFVideoFormat_RGB555;
 161     else
 162         return ICERR_BADFORMAT;
 163
 164     stride = (out->bmiHeader.biWidth + 3) & ~3;
 165     if (out->bmiHeader.biHeight >= 0)
 166         stride = -stride;
 167
 168     if ( FAILED(MFCreateMediaType( &input_type )) )
 169         return ICERR_INTERNAL;
 170
 171     if ( FAILED(MFCreateMediaType( &output_type )) )
 172     {
 173         IMFMediaType_Release( input_type );
 174         return ICERR_INTERNAL;
 175     }
 176
 177     if ( FAILED(IMFMediaType_SetGUID( input_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video )) ||
 178          FAILED(IMFMediaType_SetGUID( input_type, &MF_MT_SUBTYPE, &MFVideoFormat_IV50 )) )
 179         goto done;
 180     if ( FAILED(IMFMediaType_SetUINT64(
 181                     input_type, &MF_MT_FRAME_SIZE,
 182                     make_uint64( in->bmiHeader.biWidth, in->bmiHeader.biHeight ) )) )
 183         goto done;
 184
 185     if ( FAILED(IMFMediaType_SetGUID( output_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video )) ||
 186          FAILED(IMFMediaType_SetGUID( output_type, &MF_MT_SUBTYPE, output_subtype )) )
 187         goto done;
 188     if ( FAILED(IMFMediaType_SetUINT64(
 189                     output_type, &MF_MT_FRAME_SIZE,
 190                     make_uint64( out->bmiHeader.biWidth, abs(out->bmiHeader.biHeight) ) )) )
 191         goto done;
 192     if ( FAILED(IMFMediaType_SetUINT32( output_type, &MF_MT_DEFAULT_STRIDE, stride)) )
 193         goto done;
 194
 195     if ( FAILED(IMFTransform_SetInputType( decoder, 0, input_type, 0 )) ||
 196          FAILED(IMFTransform_SetOutputType( decoder, 0, output_type, 0 )) )
 197         goto done;
 198
 199     r = ICERR_OK;
 200
 201 done:
 202     IMFMediaType_Release( input_type );
 203     IMFMediaType_Release( output_type );
 204     return r;
 205 }
 206
 207 static LRESULT IV50_Decompress( IMFTransform *decoder, ICDECOMPRESS *icd, DWORD size )
 208 {
 209     IMFSample *in_sample = NULL, *out_sample = NULL;
 210     IMFMediaBuffer *in_buf = NULL, *out_buf = NULL;
 211     MFT_OUTPUT_DATA_BUFFER mft_buf;
 212     DWORD mft_status;
 213     BYTE *data;
 214     HRESULT hr;
 215     LRESULT r = ICERR_INTERNAL;
 216
 217     TRACE("ICM_DECOMPRESS %p %p %lu\n", decoder, icd, size);
 218
 219     if ( FAILED(MFCreateSample( &in_sample )) )
 220         return ICERR_INTERNAL;
 221
 222     if ( FAILED(MFCreateMemoryBuffer( icd->lpbiInput->biSizeImage, &in_buf )) )
 223         goto done;
 224
 225     if ( FAILED(IMFSample_AddBuffer( in_sample, in_buf )) )
 226         goto done;
 227
 228     if ( FAILED(MFCreateSample( &out_sample )) )
 229         goto done;
 230
 231     if ( FAILED(MFCreateMemoryBuffer( icd->lpbiOutput->biSizeImage, &out_buf )) )
 232         goto done;
 233
 234     if ( FAILED(IMFSample_AddBuffer( out_sample, out_buf )) )
 235         goto done;
 236
 237     if ( FAILED(IMFMediaBuffer_Lock( in_buf, &data, NULL, NULL )))
 238         goto done;
 239
 240     memcpy( data, icd->lpInput, icd->lpbiInput->biSizeImage );
 241
 242     if ( FAILED(IMFMediaBuffer_Unlock( in_buf )) )
 243         goto done;
 244
 245     if ( FAILED(IMFMediaBuffer_SetCurrentLength( in_buf, icd->lpbiInput->biSizeImage )) )
 246         goto done;
 247
 248     if ( FAILED(IMFTransform_ProcessInput( decoder, 0, in_sample, 0 )) )
 249         goto done;
 250
 251     memset( &mft_buf, 0, sizeof(mft_buf) );
 252     mft_buf.pSample = out_sample;
 253
 254     hr = IMFTransform_ProcessOutput( decoder, 0, 1, &mft_buf, &mft_status );
 255     if ( SUCCEEDED(hr) && (mft_status & MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE) )
 256         hr = IMFTransform_ProcessOutput( decoder, 0, 1, &mft_buf, &mft_status );
 257
 258     if ( SUCCEEDED(hr) )
 259     {
 260         LONG width = icd->lpbiOutput->biWidth * (icd->lpbiOutput->biBitCount / 8);
 261         LONG height = abs( icd->lpbiOutput->biHeight );
 262         LONG stride = (width + 3) & ~3;
 263         BYTE *output = (BYTE *)icd->lpOutput;
 264
 265         if ( FAILED(IMFMediaBuffer_Lock( out_buf, &data, NULL, NULL )))
 266             goto done;
 267
 268         MFCopyImage( output, stride, data, stride, width, height );
 269
 270         IMFMediaBuffer_Unlock( out_buf );
 271         r = ICERR_OK;
 272     }
 273     else if ( hr == MF_E_TRANSFORM_NEED_MORE_INPUT )
 274     {
 275         TRACE("no output received.\n");
 276         r = ICERR_OK;
 277     }
 278
 279 done:
 280     if ( in_buf )
 281         IMFMediaBuffer_Release( in_buf );
 282     if ( in_sample )
 283         IMFSample_Release( in_sample );
 284     if ( out_buf )
 285         IMFMediaBuffer_Release( out_buf );
 286     if ( out_sample )
 287         IMFSample_Release( out_sample );
 288
 289     return r;
 290 }
 291
 292 static LRESULT IV50_GetInfo( ICINFO *icinfo, DWORD dwSize )
 293 {
 294     TRACE("ICM_GETINFO %p %lu\n", icinfo, dwSize);
 295
 296     if ( !icinfo ) return sizeof(ICINFO);
 297     if ( dwSize < sizeof(ICINFO) ) return 0;
 298
 299     icinfo->dwSize       = sizeof(ICINFO);
 300     icinfo->fccType      = ICTYPE_VIDEO;
 301     icinfo->fccHandler   = IV50_MAGIC;
 302     icinfo->dwFlags      = 0;
 303     icinfo->dwVersion    = ICVERSION;
 304     icinfo->dwVersionICM = ICVERSION;
 305
 306     LoadStringW( IR50_32_hModule, IDS_NAME, icinfo->szName, ARRAY_SIZE(icinfo->szName) );
 307     LoadStringW( IR50_32_hModule, IDS_DESCRIPTION, icinfo->szDescription, ARRAY_SIZE(icinfo->szDescription) );
 308     /* msvfw32 will fill icinfo->szDriver for us */
 309
 310     return sizeof(ICINFO);
 311 }
 312
 313 /***********************************************************************
 314  *              DriverProc (IR50_32.@)
 315  */
 316 LRESULT WINAPI IV50_DriverProc( DWORD_PTR dwDriverId, HDRVR hdrvr, UINT msg,
 317                                 LPARAM lParam1, LPARAM lParam2 )
 318 {
 319     IMFTransform *decoder = (IMFTransform *) dwDriverId;
 320     LRESULT r = ICERR_UNSUPPORTED;
 321
 322     TRACE("%Id %p %04x %08Ix %08Ix\n", dwDriverId, hdrvr, msg, lParam1, lParam2);
 323
 324     switch( msg )
 325     {
 326     case DRV_LOAD:
 327         TRACE("DRV_LOAD\n");
 328         r = 1;
 329         break;
 330
 331     case DRV_OPEN:
 332         r = IV50_Open((ICINFO *)lParam2);
 333         break;
 334
 335     case DRV_CLOSE:
 336         TRACE("DRV_CLOSE\n");
 337         if ( decoder )
 338             IMFTransform_Release( decoder );
 339         r = 1;
 340         break;
 341
 342     case DRV_ENABLE:
 343     case DRV_DISABLE:
 344     case DRV_FREE:
 345         break;
 346
 347     case ICM_GETINFO:
 348         r = IV50_GetInfo( (ICINFO *) lParam1, (DWORD) lParam2 );
 349         break;
 350
 351     case ICM_DECOMPRESS_QUERY:
 352         r = IV50_DecompressQuery( (LPBITMAPINFO) lParam1, (LPBITMAPINFO) lParam2 );
 353         break;
 354
 355     case ICM_DECOMPRESS_GET_FORMAT:
 356         r = IV50_DecompressGetFormat( (LPBITMAPINFO) lParam1, (LPBITMAPINFO) lParam2 );
 357         break;
 358
 359     case ICM_DECOMPRESS_GET_PALETTE:
 360         FIXME("ICM_DECOMPRESS_GET_PALETTE\n");
 361         break;
 362
 363     case ICM_DECOMPRESS:
 364         r = IV50_Decompress( decoder, (ICDECOMPRESS *) lParam1, (DWORD) lParam2 );
 365         break;
 366
 367     case ICM_DECOMPRESS_BEGIN:
 368         r = IV50_DecompressBegin( decoder, (LPBITMAPINFO) lParam1, (LPBITMAPINFO) lParam2 );
 369         break;
 370
 371     case ICM_DECOMPRESS_END:
 372         r = ICERR_UNSUPPORTED;
 373         break;
 374
 375     case ICM_DECOMPRESSEX_QUERY:
 376         FIXME("ICM_DECOMPRESSEX_QUERY\n");
 377         break;
 378
 379     case ICM_DECOMPRESSEX:
 380         FIXME("ICM_DECOMPRESSEX\n");
 381         break;
 382
 383     case ICM_COMPRESS_QUERY:
 384         r = ICERR_BADFORMAT;
 385         /* fall through */
 386     case ICM_COMPRESS_GET_FORMAT:
 387     case ICM_COMPRESS_END:
 388     case ICM_COMPRESS:
 389         FIXME("compression not implemented\n");
 390         break;
 391
 392     case ICM_CONFIGURE:
 393         break;
 394
 395     default:
 396         FIXME("Unknown message: %04x %Id %Id\n", msg, lParam1, lParam2);
 397     }
 398
 399     return r;
 400 }
 401
 402 /***********************************************************************
 403  *              DllMain
 404  */
 405 BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
 406 {
 407     TRACE("(%p,%lu,%p)\n", hModule, dwReason, lpReserved);
 408
 409     switch (dwReason)
 410     {
 411     case DLL_PROCESS_ATTACH:
 412         DisableThreadLibraryCalls(hModule);
 413         IR50_32_hModule = hModule;
 414         break;
 415     }
 416     return TRUE;
 417 }