git.oblomov.eu Git - wine/blob - dlls/msvideo/msvideo_main.c

   1 /*
   2  * Copyright 1998 Marcus Meissner
   3  */
   4 #include <stdio.h>
   5 #include <string.h>
   6
   7 #include "winbase.h"
   8 #include "windef.h"
   9 #include "wingdi.h"
  10 #include "winuser.h"
  11 #include "vfw.h"
  12 #include "wine/winestring.h"
  13 #include "driver.h"
  14 #include "debugtools.h"
  15
  16 DEFAULT_DEBUG_CHANNEL(msvideo)
  17
  18 /****************************************************************************
  19  *              VideoForWindowsVersion          [MSVFW.2][MSVIDEO.2]
  20  * Returns the version in major.minor form.
  21  * In Windows95 this returns 0x040003b6 (4.950)
  22  */
  23 DWORD WINAPI
  24 VideoForWindowsVersion(void) {
  25         return 0x040003B6; /* 4.950 */
  26 }
  27
  28 /****************************************************************************
  29  *              VideoCapDriverDescAndVer        [MSVIDEO.22]
  30  */
  31 DWORD WINAPI
  32 VideoCapDriverDescAndVer(WORD nr,LPVOID buf1,WORD buf1len,LPVOID buf2,WORD buf2len) {
  33         FIXME("(%d,%p,%d,%p,%d), stub!\n",nr,buf1,buf1len,buf2,buf2len);
  34         return 0;
  35 }
  36
  37 /* system.ini: [drivers] */
  38
  39 /**************************************************************************
  40  *              ICInfo                          [MSVFW.33]
  41  * Get information about an installable compressor. Return TRUE if there
  42  * is one.
  43  */
  44 BOOL WINAPI
  45 ICInfo(
  46         DWORD fccType,          /* [in] type of compressor ('vidc') */
  47         DWORD fccHandler,       /* [in] <n>th compressor */
  48         ICINFO *lpicinfo        /* [out] information about compressor */
  49 ) {
  50         char    type[5],buf[2000];
  51
  52         memcpy(type,&fccType,4);type[4]=0;
  53         TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
  54         /* does OpenDriver/CloseDriver */
  55         lpicinfo->dwSize = sizeof(ICINFO);
  56         lpicinfo->fccType = fccType;
  57         lpicinfo->dwFlags = 0;
  58         if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
  59                 char *s = buf;
  60                 while (*s) {
  61                         if (!lstrncmpiA(type,s,4)) {
  62                                 if(!fccHandler--) {
  63                                         lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
  64                                         return TRUE;
  65                                 }
  66                         }
  67                         s=s+lstrlenA(s)+1; /* either next char or \0 */
  68                 }
  69         }
  70         return FALSE;
  71 }
  72
  73 /**************************************************************************
  74  *              ICOpen                          [MSVFW.37]
  75  * Opens an installable compressor. Return special handle.
  76  */
  77 HIC WINAPI
  78 ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
  79         char            type[5],handler[5],codecname[20];
  80         ICOPEN          icopen;
  81         HDRVR           hdrv;
  82         WINE_HIC        *whic;
  83
  84         memcpy(type,&fccType,4);type[4]=0;
  85         memcpy(handler,&fccHandler,4);handler[4]=0;
  86         TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
  87         sprintf(codecname,"%s.%s",type,handler);
  88
  89         /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
  90          * same layout as ICOPEN
  91          */
  92         icopen.fccType          = fccType;
  93         icopen.fccHandler       = fccHandler;
  94         icopen.dwSize           = sizeof(ICOPEN);
  95         icopen.dwFlags          = wMode;
  96         /* FIXME: do we need to fill out the rest too? */
  97         hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
  98         if (!hdrv) {
  99             if (!strcasecmp(type,"vids")) {
 100                 sprintf(codecname,"vidc.%s",handler);
 101                 fccType = mmioFOURCC('v','i','d','c');
 102             }
 103             hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
 104             if (!hdrv)
 105                     return 0;
 106         }
 107         whic = HeapAlloc(GetProcessHeap(),0,sizeof(WINE_HIC));
 108         whic->hdrv      = hdrv;
 109         whic->driverproc= NULL;
 110         whic->private   = ICSendMessage((HIC)whic,DRV_OPEN,0,(LPARAM)&icopen);
 111         return (HIC)whic;
 112 }
 113 HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode,
 114 FARPROC lpfnHandler) {
 115         char            type[5],handler[5];
 116         HIC             hic;
 117         WINE_HIC        *whic;
 118
 119         memcpy(type,&fccType,4);type[4]=0;
 120         memcpy(handler,&fccHandler,4);handler[4]=0;
 121         FIXME("(%s,%s,%d,%p), stub!\n",type,handler,wMode,lpfnHandler);
 122         hic = ICOpen(fccType,fccHandler,wMode);
 123         if (!hic)
 124                 return hic;
 125         whic = (WINE_HIC*)hic;
 126         whic->driverproc = lpfnHandler;
 127         return hic;
 128 }
 129
 130
 131 LRESULT WINAPI
 132 ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
 133         LRESULT         ret;
 134
 135         TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
 136         ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
 137         TRACE(" -> 0x%08lx\n",ret);
 138         return ret;
 139 }
 140
 141 HIC  VFWAPI
 142 ICLocate(
 143         DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
 144         LPBITMAPINFOHEADER lpbiOut, WORD wMode
 145 ) {
 146         char    type[5],handler[5];
 147         HIC     hic;
 148         DWORD   querymsg;
 149
 150         switch (wMode) {
 151         case ICMODE_FASTCOMPRESS:
 152         case ICMODE_COMPRESS:
 153                 querymsg = ICM_COMPRESS_QUERY;
 154                 break;
 155         case ICMODE_DECOMPRESS:
 156         case ICMODE_FASTDECOMPRESS:
 157                 querymsg = ICM_DECOMPRESS_QUERY;
 158                 break;
 159         case ICMODE_DRAW:
 160                 querymsg = ICM_DRAW_QUERY;
 161                 break;
 162         default:
 163                 FIXME("Unknown mode (%d)\n",wMode);
 164                 return 0;
 165         }
 166
 167         /* Easy case: handler/type match, we just fire a query and return */
 168         hic = ICOpen(fccType,fccHandler,wMode);
 169         if (hic) {
 170                 if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
 171                         return hic;
 172                 ICClose(hic);
 173         }
 174         type[4]='\0';memcpy(type,&fccType,4);
 175         handler[4]='\0';memcpy(handler,&fccHandler,4);
 176         if (fccType==streamtypeVIDEO) {
 177                 hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
 178                 if (hic)
 179                         return hic;
 180         }
 181         FIXME("(%s,%s,%p,%p,0x%04x),unhandled!\n",type,handler,lpbiIn,lpbiOut,wMode);
 182         return 0;
 183 }
 184
 185 HIC VFWAPI ICGetDisplayFormat(
 186         HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
 187         INT depth,INT dx,INT dy
 188 ) {
 189         HIC     tmphic = hic;
 190         LRESULT lres;
 191
 192         FIXME("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy);
 193         if (!tmphic) {
 194                 tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
 195                 if (!tmphic)
 196                         return tmphic;
 197         }
 198         if ((dy == lpbiIn->biHeight) || (dx == lpbiIn->biWidth))
 199                 dy = dx = 0; /* no resize needed */
 200         /* Can we decompress it ? */
 201         lres = ICDecompressQuery(tmphic,lpbiIn,NULL);
 202         if (lres)
 203                 goto errout; /* no, sorry */
 204         ICDecompressGetFormat(hic,lpbiIn,lpbiOut);
 205         *lpbiOut=*lpbiIn;
 206         lpbiOut->biCompression = 0;
 207         lpbiOut->biSize = sizeof(*lpbiOut);
 208         if (!depth) {
 209                 HDC     hdc;
 210
 211                 hdc = GetDC(0);
 212                 depth = GetDeviceCaps(hdc,12)*GetDeviceCaps(hdc,14);
 213                 ReleaseDC(0,hdc);
 214                 if (depth==15)  depth = 16;
 215                 if (depth<8)    depth =  8;
 216                 /* more constraints and tests */
 217         }
 218         if (lpbiIn->biBitCount == 8)
 219                 depth = 8;
 220
 221         return hic;
 222 errout:
 223         if (hic!=tmphic)
 224                 ICClose(tmphic);
 225         return 0;
 226 }
 227
 228 DWORD VFWAPIV
 229 ICCompress(
 230         HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
 231         LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
 232         LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
 233         LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
 234 ) {
 235         ICCOMPRESS      iccmp;
 236
 237         iccmp.dwFlags           = dwFlags;
 238
 239         iccmp.lpbiOutput        = lpbiOutput;
 240         iccmp.lpOutput          = lpData;
 241         iccmp.lpbiInput         = lpbiInput;
 242         iccmp.lpInput           = lpBits;
 243
 244         iccmp.lpckid            = lpckid;
 245         iccmp.lpdwFlags         = lpdwFlags;
 246         iccmp.lFrameNum         = lFrameNum;
 247         iccmp.dwFrameSize       = dwFrameSize;
 248         iccmp.dwQuality         = dwQuality;
 249         iccmp.lpbiPrev          = lpbiPrev;
 250         iccmp.lpPrev            = lpPrev;
 251         return ICSendMessage(hic,ICM_COMPRESS,(LPARAM)&iccmp,sizeof(iccmp));
 252 }
 253
 254 DWORD VFWAPIV
 255 ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER  lpbi,LPVOID lpBits) {
 256         ICDECOMPRESS    icd;
 257
 258         icd.dwFlags     = dwFlags;
 259         icd.lpbiInput   = lpbiFormat;
 260         icd.lpInput     = lpData;
 261
 262         icd.lpbiOutput  = lpbi;
 263         icd.lpOutput    = lpBits;
 264         icd.ckid        = 0;
 265         return ICSendMessage(hic,ICM_DECOMPRESS,(LPARAM)&icd,sizeof(icd));
 266 }
 267
 268 LRESULT VFWAPI
 269 ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2) {
 270         LRESULT         ret;
 271         WINE_HIC        *whic = (WINE_HIC*)hic;
 272
 273 #define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx)\n",(DWORD)hic,lParam1,lParam2);break;
 274
 275         switch (msg) {
 276         XX(ICM_ABOUT)
 277         XX(ICM_GETINFO)
 278         XX(ICM_COMPRESS_FRAMES_INFO)
 279         XX(ICM_COMPRESS_GET_FORMAT)
 280         XX(ICM_COMPRESS_GET_SIZE)
 281         XX(ICM_COMPRESS_QUERY)
 282         XX(ICM_COMPRESS_BEGIN)
 283         XX(ICM_COMPRESS)
 284         XX(ICM_COMPRESS_END)
 285         XX(ICM_DECOMPRESS_GET_FORMAT)
 286         XX(ICM_DECOMPRESS_QUERY)
 287         XX(ICM_DECOMPRESS_BEGIN)
 288         XX(ICM_DECOMPRESS)
 289         XX(ICM_DECOMPRESS_END)
 290         XX(ICM_DECOMPRESS_SET_PALETTE)
 291         XX(ICM_DECOMPRESS_GET_PALETTE)
 292         XX(ICM_DRAW_QUERY)
 293         XX(ICM_DRAW_BEGIN)
 294         XX(ICM_DRAW_GET_PALETTE)
 295         XX(ICM_DRAW_START)
 296         XX(ICM_DRAW_STOP)
 297         XX(ICM_DRAW_END)
 298         XX(ICM_DRAW_GETTIME)
 299         XX(ICM_DRAW)
 300         XX(ICM_DRAW_WINDOW)
 301         XX(ICM_DRAW_SETTIME)
 302         XX(ICM_DRAW_REALIZE)
 303         XX(ICM_DRAW_FLUSH)
 304         XX(ICM_DRAW_RENDERBUFFER)
 305         XX(ICM_DRAW_START_PLAY)
 306         XX(ICM_DRAW_STOP_PLAY)
 307         XX(ICM_DRAW_SUGGESTFORMAT)
 308         XX(ICM_DRAW_CHANGEPALETTE)
 309         XX(ICM_GETBUFFERSWANTED)
 310         XX(ICM_GETDEFAULTKEYFRAMERATE)
 311         XX(ICM_DECOMPRESSEX_BEGIN)
 312         XX(ICM_DECOMPRESSEX_QUERY)
 313         XX(ICM_DECOMPRESSEX)
 314         XX(ICM_DECOMPRESSEX_END)
 315         XX(ICM_SET_STATUS_PROC)
 316         default:
 317                 FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx)\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2);
 318         }
 319 #if 0
 320         if (whic->driverproc) {
 321                 FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx), calling %p\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,whic->driverproc);
 322                 ret = whic->driverproc(whic->hdrv,1,msg,lParam1,lParam2);
 323         } else
 324 #endif
 325                 ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
 326         TRACE(" -> 0x%08lx\n",ret);
 327         return ret;
 328 }
 329
 330 DWORD   VFWAPIV ICDrawBegin(
 331         HIC                     hic,
 332         DWORD                   dwFlags,/* flags */
 333         HPALETTE                hpal,   /* palette to draw with */
 334         HWND                    hwnd,   /* window to draw to */
 335         HDC                     hdc,    /* HDC to draw to */
 336         INT                     xDst,   /* destination rectangle */
 337         INT                     yDst,
 338         INT                     dxDst,
 339         INT                     dyDst,
 340         LPBITMAPINFOHEADER      lpbi,   /* format of frame to draw */
 341         INT                     xSrc,   /* source rectangle */
 342         INT                     ySrc,
 343         INT                     dxSrc,
 344         INT                     dySrc,
 345         DWORD                   dwRate, /* frames/second = (dwRate/dwScale) */
 346         DWORD                   dwScale) {
 347         ICDRAWBEGIN     icdb;
 348
 349         icdb.dwFlags = dwFlags;
 350         icdb.hpal = hpal;
 351         icdb.hwnd = hwnd;
 352         icdb.hdc = hdc;
 353         icdb.xDst = xDst;
 354         icdb.yDst = yDst;
 355         icdb.dxDst = dxDst;
 356         icdb.dyDst = dyDst;
 357         icdb.lpbi = lpbi;
 358         icdb.xSrc = xSrc;
 359         icdb.ySrc = ySrc;
 360         icdb.dxSrc = dxSrc;
 361         icdb.dySrc = dySrc;
 362         icdb.dwRate = dwRate;
 363         icdb.dwScale = dwScale;
 364         return ICSendMessage(hic,ICM_DRAW_BEGIN,(LPARAM)&icdb,sizeof(icdb));
 365 }
 366
 367 DWORD VFWAPIV ICDraw(
 368         HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,
 369         LONG lTime
 370 ) {
 371         ICDRAW  icd;
 372
 373         icd.dwFlags = dwFlags;
 374         icd.lpFormat = lpFormat;
 375         icd.lpData = lpData;
 376         icd.cbData = cbData;
 377         icd.lTime = lTime;
 378         return ICSendMessage(hic,ICM_DRAW,(LPARAM)&icd,sizeof(icd));
 379 }
 380
 381 LRESULT WINAPI ICClose(HIC hic) {
 382         WINE_HIC        *whic = (WINE_HIC*)hic;
 383         TRACE("(%d).\n",hic);
 384         /* FIXME: correct? */
 385         CloseDriver(whic->hdrv,0,0);
 386         HeapFree(GetProcessHeap(),0,whic);
 387         return 0;
 388 }
 389
 390 HANDLE /* HDRAWDIB */ WINAPI
 391 DrawDibOpen( void ) {
 392         FIXME("stub!\n");
 393         return 0xdead;
 394 }
 395
 396 BOOL WINAPI
 397 DrawDibClose( HANDLE /*HDRAWDIB*/ hDib ) {
 398        FIXME("stub!\n");
 399        return TRUE;
 400 }
 401
 402 BOOL VFWAPI DrawDibBegin(HANDLE /*HDRAWDIB*/ hdd,
 403                                     HDC      hdc,
 404                                     INT      dxDst,
 405                                     INT      dyDst,
 406                                     LPBITMAPINFOHEADER lpbi,
 407                                     INT      dxSrc,
 408                                     INT      dySrc,
 409                                     UINT     wFlags) {
 410         FIXME("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx), stub!\n",
 411                 hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
 412         );
 413         return TRUE;
 414 }
 415
 416
 417 BOOL VFWAPI
 418 DrawDibSetPalette(HANDLE /*HDRAWDIB*/ hdd, HPALETTE hpal) {
 419         FIXME("(%d,%d),stub!\n",hdd,hpal);
 420         return TRUE;
 421 }
 422
 423 UINT VFWAPI DrawDibRealize(HANDLE /*HDRAWDIB*/ hdd, HDC hdc, BOOL fBackground) {
 424         FIXME("(0x%08lx,0x%08lx,%d),stub!\n",(DWORD)hdd,(DWORD)hdc,fBackground);
 425         return 0;
 426 }
 427
 428
 429 HWND VFWAPIV MCIWndCreate (HWND hwndParent, HINSTANCE hInstance,
 430                       DWORD dwStyle,LPVOID szFile)
 431 {       FIXME("%x %x %lx %p\n",hwndParent, hInstance, dwStyle, szFile);
 432         return 0;
 433 }
 434 HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
 435                       DWORD dwStyle,LPCSTR szFile)
 436 {       FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
 437         return 0;
 438 }
 439 HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
 440                       DWORD dwStyle,LPCWSTR szFile)
 441 {       FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
 442         return 0;
 443 }