Ignore:
Timestamp:
Nov 5, 1999, 10:19:27 AM (26 years ago)
Author:
sandervl
Message:

Jens Weissner's update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msvfw32/msvfw32.cpp

    r1012 r1607  
    1 /* $Id: msvfw32.cpp,v 1.3 1999-09-23 09:38:05 sandervl Exp $ */
    21/*
    32 * Copyright 1998 Marcus Meissner
    … …  
    2423#include "vfw.h"
    2524#include "driver.h"
    26 #include "msvfw32.h"
     25// #include "msvfw32.h"
    2726
    2827#include "debugtools.h"
    2928#include <debugstr.h>
    30 
     29#include <heapstring.h>
    3130
    3231DEFAULT_DEBUG_CHANNEL(msvideo)
    3332
    34 
    35 /****************************************************************************
    36  *              VideoForWindowsVersion          [MSVFW.2]
     33/****************************************************************************
     34 *              VideoForWindowsVersion          [MSVFW.2][MSVIDEO.2]
    3735 * Returns the version in major.minor form.
    3836 * In Windows95 this returns 0x040003b6 (4.950)
    3937 */
    40 DWORD WINAPI VideoForWindowsVersion(void)
    41 {
    42 #ifdef DEBUG
    43     dprintf(("MSVFW32: VideoForWindowsVersion\n"));
    44 #endif
     38DWORD WINAPI
     39VideoForWindowsVersion(void) {
    4540        return 0x040003B6; /* 4.950 */
    4641}
    4742
    48 
    49 /****************************************************************************
    50  *              DrawDibBegin                    [MSVFW.3]
    51  */
    52 BOOL VFWAPI DrawDibBegin(HANDLE /*HDRAWDIB*/ hdd,
    53                                     HDC      hdc,
    54                                     INT      dxDst,
    55                                     INT      dyDst,
    56                                     LPBITMAPINFOHEADER lpbi,
    57                                     INT      dxSrc,
    58                                     INT      dySrc,
    59                                     UINT     wFlags)
    60 {
    61 #ifdef DEBUG
    62     dprintf(("MSVFW32: DrawDibBegin not implemented\n"));
    63 #endif
    64         return TRUE;
    65 }
    66 
    67 
    68 /****************************************************************************
    69  *              DrawDibChangePalette            [MSVFW.4]
    70  */
    71 
    72 BOOL VFWAPI DrawDibChangePalette(HANDLE /*HDRAWDIB*/ hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
    73 {
    74 #ifdef DEBUG
    75     dprintf(("MSVFW32: DrawDibChangePalette not implemented\n"));
    76 #endif
    77         return TRUE;
    78 }
    79 
    80 
    81 /****************************************************************************
    82  *              DrawDibClose                    [MSVFW.5]
    83  */
    84 BOOL WINAPI DrawDibClose( HANDLE /*HDRAWDIB*/ hDib )
    85 {
    86 #ifdef DEBUG
    87     dprintf(("MSVFW32: DrawDibClose not implemented\n"));
    88 #endif
    89        return TRUE;
    90 }
    91 
    92 
    93 /****************************************************************************
    94  *              DrawDibDraw                     [MSVFW.6]
    95  */
    96 BOOL VFWAPI DrawDibDraw(HANDLE /*HDRAWDIB*/ hdd,
    97                                    HDC      hdc,
    98                                    int      xDst,
    99                                    int      yDst,
    100                                    int      dxDst,
    101                                    int      dyDst,
    102                                    LPBITMAPINFOHEADER lpbi,
    103                                    LPVOID   lpBits,
    104                                    int      xSrc,
    105                                    int      ySrc,
    106                                    int      dxSrc,
    107                                    int      dySrc,
    108                                    UINT     wFlags)
    109 {
    110 #ifdef DEBUG
    111     dprintf(("MSVFW32: DrawDibDraw not implemented\n"));
    112 #endif
    113        return TRUE;
    114 }
    115 
    116 
    117 /****************************************************************************
    118  *              DrawDibEnd                      [MSVFW.7]
    119  */
    120 BOOL VFWAPI DrawDibEnd(HANDLE /*HDRAWDIB*/ hdd)
    121 {
    122 #ifdef DEBUG
    123     dprintf(("MSVFW32: DrawDibEnd not implemented\n"));
    124 #endif
    125        return TRUE;
    126 }
    127 
    128 
    129 /****************************************************************************
    130  *              DrawDibGetBuffer                [MSVFW.8]
    131  */
    132 LPVOID VFWAPI DrawDibGetBuffer(HANDLE /*HDRAWDIB*/ hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
    133 {
    134 #ifdef DEBUG
    135     dprintf(("MSVFW32: DrawDibGetBuffer not implemented\n"));
    136 #endif
    137        return 0;
    138 }
    139 
    140 
    141 /****************************************************************************
    142  *              DrawDibGetPalette               [MSVFW.9]
    143  */
    144 HPALETTE VFWAPI DrawDibGetPalette(HANDLE /*HDRAWDIB*/ hdd)
    145 {
    146 #ifdef DEBUG
    147     dprintf(("MSVFW32: DrawDibGetPalette not implemented\n"));
    148 #endif
    149        return TRUE;
    150 }
    151 
    152 
    153 /****************************************************************************
    154  *              DrawDibOpen                     [MSVFW.10]
    155  */
    156 HANDLE /* HDRAWDIB */ WINAPI DrawDibOpen( void )
    157 {
    158 #ifdef DEBUG
    159     dprintf(("MSVFW32: DrawDibOpen not implemented\n"));
    160 #endif
    161         return 0xdead;
    162 }
    163 
    164 
    165 /****************************************************************************
    166  *              DrawDibProfileDisplay           [MSVFW.11]
    167  */
    168 DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
    169 {
    170 #ifdef DEBUG
    171     dprintf(("MSVFW32: DrawDibProfileDisplay not implemented\n"));
    172 #endif
    173        return TRUE;
    174 }
    175 
    176 
    177 /****************************************************************************
    178  *              DrawDibRealize                  [MSVFW.12]
    179  */
    180 UINT VFWAPI DrawDibRealize(HANDLE /*HDRAWDIB*/ hdd, HDC hdc, BOOL fBackground)
    181 {
    182 #ifdef DEBUG
    183     dprintf(("MSVFW32: DrawDibRealize not implemented\n"));
    184 #endif
    185         return 0;
    186 }
    187 
    188 
    189 /****************************************************************************
    190  *              DrawDibSetPalette               [MSVFW.13]
    191  */
    192 BOOL VFWAPI DrawDibSetPalette(HANDLE /*HDRAWDIB*/ hdd, HPALETTE hpal)
    193 {
    194 #ifdef DEBUG
    195     dprintf(("MSVFW32: DrawDibSetPalette not implemented\n"));
    196 #endif
    197         return TRUE;
    198 }
    199 
    200 
    201 /****************************************************************************
    202  *              DrawDibStart                    [MSVFW.14]
    203  */
    204 BOOL VFWAPI DrawDibStart(HANDLE /*HDRAWDIB*/ hdd, DWORD rate)
    205 {
    206 #ifdef DEBUG
    207     dprintf(("MSVFW32: DrawDibStart not implemented\n"));
    208 #endif
    209         return TRUE;
    210 }
    211 
    212 
    213 /****************************************************************************
    214  *              DrawDibStop                     [MSVFW.15]
    215  */
    216 BOOL VFWAPI DrawDibStop(HANDLE /*HDRAWDIB*/ hdd)
    217 {
    218 #ifdef DEBUG
    219     dprintf(("MSVFW32: DrawDibStop not implemented\n"));
    220 #endif
    221         return TRUE;
    222 }
    223 
    224 
    225 /****************************************************************************
    226  *              DrawDibTime                     [MSVFW.16]
    227  */
    228 BOOL VFWAPI DrawDibTime(HANDLE /*HDRAWDIB*/ hdd, LPDRAWDIBTIME lpddtime)
    229 {
    230 #ifdef DEBUG
    231     dprintf(("MSVFW32: DrawDibTime not implemented\n"));
    232 #endif
    233         return TRUE;
    234 }
    235 
    236 
    237 /****************************************************************************
    238  *              GetOpenFileNamePreview          [MSVFW.17]
    239  */
    240 
    241 /* NO */
    242 
    243 
    244 /****************************************************************************
    245  *              GetOpenFileNamePreviewA         [MSVFW.18]
    246  */
    247 BOOL VFWAPI GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn)
    248 {
    249 #ifdef DEBUG
    250     dprintf(("MSVFW32: GetOpenFileNamePreviewA not implemented\n"));
    251 #endif
    252         return TRUE;
    253 }
    254 
    255 
    256 /****************************************************************************
    257  *              GetOpenFileNamePreviewW         [MSVFW.19]
    258  */
    259 BOOL VFWAPI GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn)
    260 {
    261 #ifdef DEBUG
    262     dprintf(("MSVFW32: GetOpenFileNamePreviewW not implemented\n"));
    263 #endif
    264         return TRUE;
    265 }
    266 
    267 
    268 /****************************************************************************
    269  *              GetSaveFileNamePreviewA         [MSVFW.20]
    270  */
    271 BOOL VFWAPI GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn)
    272 {
    273 #ifdef DEBUG
    274     dprintf(("MSVFW32: GetSaveFileNamePreviewA not implemented\n"));
    275 #endif
    276         return TRUE;
    277 }
    278 
    279 
    280 /****************************************************************************
    281  *              GetSaveFileNamePreviewW         [MSVFW.21]
    282  */
    283 BOOL VFWAPI GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn)
    284 {
    285 #ifdef DEBUG
    286     dprintf(("MSVFW32: GetSaveFileNamePreviewW not implemented\n"));
    287 #endif
    288         return TRUE;
    289 }
    290 
    291 
    292 /****************************************************************************
    293  *              ICClose                         [MSVFW.22]
    294  */
    295 LRESULT WINAPI ICClose(HIC hic)
    296 {
    297 #ifdef DEBUG
    298     dprintf(("MSVFW32: ICClose\n"));
    299 #endif
    300         WINE_HIC        *whic = (WINE_HIC*)hic;
    301         /* FIXME: correct? */
    302         CloseDriver(whic->hdrv,0,0);
    303         HeapFree(GetProcessHeap(),0,whic);
    304         return 0;
    305 }
    306 
    307 
    308 /****************************************************************************
    309  *              ICCompress                      [MSVFW.23]
    310  */
    311 DWORD VFWAPIV ICCompress(
    312         HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
    313         LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
    314         LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
    315         LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev)
    316 {
    317 #ifdef DEBUG
    318     dprintf(("MSVFW32: ICCompress\n"));
    319 #endif
    320         ICCOMPRESS      iccmp;
    321 
    322         iccmp.dwFlags           = dwFlags;
    323 
    324         iccmp.lpbiOutput        = lpbiOutput;
    325         iccmp.lpOutput          = lpData;
    326         iccmp.lpbiInput         = lpbiInput;
    327         iccmp.lpInput           = lpBits;
    328 
    329         iccmp.lpckid            = lpckid;
    330         iccmp.lpdwFlags         = lpdwFlags;
    331         iccmp.lFrameNum         = lFrameNum;
    332         iccmp.dwFrameSize       = dwFrameSize;
    333         iccmp.dwQuality         = dwQuality;
    334         iccmp.lpbiPrev          = lpbiPrev;
    335         iccmp.lpPrev            = lpPrev;
    336         return ICSendMessage(hic,ICM_COMPRESS,(LPARAM)&iccmp,sizeof(iccmp));
    337 }
    338 
    339 
    340 /****************************************************************************
    341  *              ICCompressorChoose              [MSVFW.24]
    342  */
    343 BOOL VFWAPI ICCompressorChoose(
    344         HWND        hwnd,               // parent window for dialog
    345         UINT        uiFlags,            // flags
    346         LPVOID      pvIn,               // input format (optional)
    347         LPVOID      lpData,             // input data (optional)
    348         PCOMPVARS   pc,                 // data about the compressor/dlg
    349         LPSTR       lpszTitle)          // dialog title (optional)
    350 {
    351 #ifdef DEBUG
    352     dprintf(("MSVFW32: ICCompressorChoose not implemented\n"));
    353 #endif
    354         return TRUE;
    355 }
    356 
    357 
    358 /****************************************************************************
    359  *              ICCompressorFree                [MSVFW.25]
    360  */
    361 void VFWAPI ICCompressorFree(PCOMPVARS pc)
    362 {
    363 #ifdef DEBUG
    364     dprintf(("MSVFW32: ICCompressorFree not implemented\n"));
    365 #endif
    366         return;
    367 }
    368 
    369 
    370 /****************************************************************************
    371  *              ICDecompress                    [MSVFW.26]
    372  */
    373 DWORD VFWAPIV ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,
    374                 LPVOID lpData,LPBITMAPINFOHEADER  lpbi,LPVOID lpBits)
    375 {
    376 #ifdef DEBUG
    377     dprintf(("MSVFW32: ICDecompress\n"));
    378 #endif
    379         ICDECOMPRESS    icd;
    380 
    381         icd.dwFlags     = dwFlags;
    382         icd.lpbiInput   = lpbiFormat;
    383         icd.lpInput     = lpData;
    384 
    385         icd.lpbiOutput  = lpbi;
    386         icd.lpOutput    = lpBits;
    387         icd.ckid        = 0;
    388         return ICSendMessage(hic,ICM_DECOMPRESS,(LPARAM)&icd,sizeof(icd));
    389 }
    390 
    391 
    392 /****************************************************************************
    393  *              ICDraw                          [MSVFW.27]
    394  */
    395 DWORD VFWAPIV ICDraw(HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,
    396         DWORD cbData, LONG lTime)
    397 {
    398 #ifdef DEBUG
    399     dprintf(("MSVFW32: ICDraw\n"));
    400 #endif
    401         ICDRAW  icd;
    402 
    403         icd.dwFlags = dwFlags;
    404         icd.lpFormat = lpFormat;
    405         icd.lpData = lpData;
    406         icd.cbData = cbData;
    407         icd.lTime = lTime;
    408         return ICSendMessage(hic,ICM_DRAW,(LPARAM)&icd,sizeof(icd));
    409 }
    410 
    411 
    412 /****************************************************************************
    413  *              ICDrawBegin                     [MSVFW.28]
    414  */
    415 DWORD   VFWAPIV ICDrawBegin(
    416         HIC                     hic,
    417         DWORD                   dwFlags,/* flags */
    418         HPALETTE                hpal,   /* palette to draw with */
    419         HWND                    hwnd,   /* window to draw to */
    420         HDC                     hdc,    /* HDC to draw to */
    421         INT                     xDst,   /* destination rectangle */
    422         INT                     yDst,
    423         INT                     dxDst,
    424         INT                     dyDst,
    425         LPBITMAPINFOHEADER      lpbi,   /* format of frame to draw */
    426         INT                     xSrc,   /* source rectangle */
    427         INT                     ySrc,
    428         INT                     dxSrc,
    429         INT                     dySrc,
    430         DWORD                   dwRate, /* frames/second = (dwRate/dwScale) */
    431         DWORD                   dwScale)
    432 {
    433 #ifdef DEBUG
    434     dprintf(("MSVFW32: ICDrawBegin\n"));
    435 #endif
    436         ICDRAWBEGIN     icdb;
    437 
    438         icdb.dwFlags = dwFlags;
    439         icdb.hpal = hpal;
    440         icdb.hwnd = hwnd;
    441         icdb.hdc = hdc;
    442         icdb.xDst = xDst;
    443         icdb.yDst = yDst;
    444         icdb.dxDst = dxDst;
    445         icdb.dyDst = dyDst;
    446         icdb.lpbi = lpbi;
    447         icdb.xSrc = xSrc;
    448         icdb.ySrc = ySrc;
    449         icdb.dxSrc = dxSrc;
    450         icdb.dySrc = dySrc;
    451         icdb.dwRate = dwRate;
    452         icdb.dwScale = dwScale;
    453         return ICSendMessage(hic,ICM_DRAW_BEGIN,(LPARAM)&icdb,sizeof(icdb));
    454 }
    455 
    456 
    457 /****************************************************************************
    458  *              ICGetDisplayFormat              [MSVFW.29]
    459  */
    460 HIC VFWAPI ICGetDisplayFormat(HIC hic,LPBITMAPINFOHEADER lpbiIn,
    461         LPBITMAPINFOHEADER lpbiOut, INT depth,INT dx,INT dy)
    462 {
    463 #ifdef DEBUG
    464     dprintf(("MSVFW32: ICGetDisplayFormat\n"));
    465 #endif
    466         HIC     tmphic = hic;
    467         LRESULT lres;
    468 
    469         if (!tmphic) {
    470                 tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
    471                 if (!tmphic)
    472                         return tmphic;
    473         }
    474         if ((dy == lpbiIn->biHeight) || (dx == lpbiIn->biWidth))
    475                 dy = dx = 0; /* no resize needed */
    476         /* Can we decompress it ? */
    477         lres = ICDecompressQuery(tmphic,lpbiIn,NULL);
    478         if (lres)
    479                 goto errout; /* no, sorry */
    480         ICDecompressGetFormat(hic,lpbiIn,lpbiOut);
    481         *lpbiOut=*lpbiIn;
    482         lpbiOut->biCompression = 0;
    483         lpbiOut->biSize = sizeof(*lpbiOut);
    484         if (!depth) {
    485                 HDC     hdc;
    486 
    487                 hdc = GetDC(0);
    488                 depth = GetDeviceCaps(hdc,12)*GetDeviceCaps(hdc,14);
    489                 ReleaseDC(0,hdc);
    490                 if (depth==15)  depth = 16;
    491                 if (depth<8)    depth =  8;
    492                 /* more constraints and tests */
    493         }
    494         if (lpbiIn->biBitCount == 8)
    495                 depth = 8;
    496        
    497         return hic;
    498 errout:
    499         if (hic!=tmphic)
    500                 ICClose(tmphic);
    501         return 0;
    502 }
    503 
    504 
    505 /****************************************************************************
    506  *              ICGetInfo                       [MSVFW.30]
    507  */
    508 LRESULT WINAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb)
    509 {
    510 #ifdef DEBUG
    511     dprintf(("MSVFW32: ICGetInfo\n"));
    512 #endif
    513         LRESULT         ret;
    514 
    515         ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
    516         return ret;
    517 }
    518 
    519 
    520 /****************************************************************************
    521  *              ICImageCompress                 [MSVFW.31]
    522  */
    523 HANDLE VFWAPI ICImageCompress(
    524         HIC                 hic,        // compressor to use
    525         UINT                uiFlags,    // flags (none yet)
    526         LPBITMAPINFO        lpbiIn,     // format to compress from
    527         LPVOID              lpBits,     // data to compress
    528         LPBITMAPINFO        lpbiOut,    // compress to this (NULL ==> default)
    529         LONG                lQuality,   // quality to use
    530         LONG                plSize)     // compress to this size (0=whatever)
    531 {       
    532 #ifdef DEBUG
    533     dprintf(("MSVFW32: ICImageCompress not implemented\n"));
    534 #endif
    535         return 0;
    536 }
    537 
    538 
    539 /****************************************************************************
    540  *              ICImageDecompress               [MSVFW.32]
    541  */
    542 HANDLE VFWAPI ICImageDecompress(
    543         HIC                 hic,        // compressor to use
    544         UINT                uiFlags,    // flags (none yet)
    545         LPBITMAPINFO        lpbiIn,     // format to decompress from
    546         LPVOID              lpBits,     // data to decompress
    547         LPBITMAPINFO        lpbiOut)    // decompress to this (NULL ==> default)
    548 {       
    549 #ifdef DEBUG
    550     dprintf(("MSVFW32: ICImageDecompress not implemented\n"));
    551 #endif
    552         return 0;
    553 }
    554 
     43/* system.ini: [drivers] */
    55544
    55645/**************************************************************************
    … …  
    55948 * is one.
    56049 */
    561 BOOL WINAPI ICInfo(DWORD fccType,DWORD fccHandler,ICINFO *lpicinfo)
    562 {
    563 #ifdef DEBUG
    564     dprintf(("MSVFW32: ICInfo\n"));
    565 #endif
    566 
     50BOOL WINAPI
     51ICInfo(
     52        DWORD fccType,          /* [in] type of compressor ('vidc') */
     53        DWORD fccHandler,       /* [in] <n>th compressor */
     54        ICINFO *lpicinfo        /* [out] information about compressor */
     55) {
    56756        char    type[5],buf[2000];
    56857
    56958        memcpy(type,&fccType,4);type[4]=0;
     59        TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
    57060        /* does OpenDriver/CloseDriver */
    57161        lpicinfo->dwSize = sizeof(ICINFO);
    … …  
    58777}
    58878
    589 
    590 /****************************************************************************
    591  *              ICInstall                       [MSVFW.34]
    592  */
    593 BOOL    VFWAPI ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags)
    594 {       
    595 #ifdef DEBUG
    596     dprintf(("MSVFW32: ICInstall not implemented\n"));
    597 #endif
    598         return TRUE;
    599 }
    600 
    601 
    602 /****************************************************************************
    603  *              ICLocate                        [MSVFW.35]
    604  */
    605 HIC  VFWAPI ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
    606         LPBITMAPINFOHEADER lpbiOut, WORD wMode)
    607 {
    608 #ifdef DEBUG
    609     dprintf(("MSVFW32: ICLocate\n"));
    610 #endif
    611         char    type[5],handler[5];
    612         HIC     hic;
    613         DWORD   querymsg;
    614 
    615         switch (wMode) {
    616         case ICMODE_FASTCOMPRESS:
    617         case ICMODE_COMPRESS:
    618                 querymsg = ICM_COMPRESS_QUERY;
    619                 break;
    620         case ICMODE_DECOMPRESS:
    621         case ICMODE_FASTDECOMPRESS:
    622                 querymsg = ICM_DECOMPRESS_QUERY;
    623                 break;
    624         case ICMODE_DRAW:
    625                 querymsg = ICM_DRAW_QUERY;
    626                 break;
    627         default:
    628                 return 0;
    629         }
    630 
    631         /* Easy case: handler/type match, we just fire a query and return */
    632         hic = ICOpen(fccType,fccHandler,wMode);
    633         if (hic) {
    634                 if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
    635                         return hic;
    636                 ICClose(hic);
    637         }
    638         type[4]='\0';memcpy(type,&fccType,4);
    639         handler[4]='\0';memcpy(handler,&fccHandler,4);
    640         if (fccType==streamtypeVIDEO) {
    641                 hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
    642                 if (hic)
    643                         return hic;
    644         }
    645         return 0;
    646 }
    647 
    648 
    64979/**************************************************************************
    65080 *              ICOpen                          [MSVFW.37]
    65181 * Opens an installable compressor. Return special handle.
    65282 */
    653 HIC WINAPI ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode)
    654 {
    655 #ifdef DEBUG
    656     dprintf(("MSVFW32: ICOpen\n"));
    657 #endif
     83HIC WINAPI
     84ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
    65885        char            type[5],handler[5],codecname[20];
    65986        ICOPEN          icopen;
    … …  
    66390        memcpy(type,&fccType,4);type[4]=0;
    66491        memcpy(handler,&fccHandler,4);handler[4]=0;
     92        TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
    66593        sprintf(codecname,"%s.%s",type,handler);
    66694
    … …  
    683111                    return 0;
    684112        }
    685         whic = (PWINE_HIC)HeapAlloc(GetProcessHeap(),0,sizeof(WINE_HIC));
     113        whic = PWINE_HIC(HeapAlloc(GetProcessHeap(),0,sizeof(WINE_HIC)));
    686114        whic->hdrv      = hdrv;
    687115        whic->driverproc= NULL;
    … …  
    689117        return (HIC)whic;
    690118}
    691 
    692 
    693 /**************************************************************************
    694  *              ICOpenFunction                  [MSVFW.38]
    695  */
    696119HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode,
    697 FARPROC lpfnHandler)
    698 {
    699 #ifdef DEBUG
    700     dprintf(("MSVFW32: ICOpenFunction\n"));
    701 #endif
     120FARPROC lpfnHandler) {
    702121        char            type[5],handler[5];
    703122        HIC             hic;
    … …  
    706125        memcpy(type,&fccType,4);type[4]=0;
    707126        memcpy(handler,&fccHandler,4);handler[4]=0;
     127        dprintf(("(%s,%s,%d,%p), stub!\n",type,handler,wMode,lpfnHandler));
    708128        hic = ICOpen(fccType,fccHandler,wMode);
    709129        if (!hic)
    … …  
    715135
    716136
    717 /**************************************************************************
    718  *              ICRemove                        [MSVFW.39]
    719  */
    720 BOOL    VFWAPI ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags)
    721 {       
    722 #ifdef DEBUG
    723     dprintf(("MSVFW32: ICRemove not implemented\n"));
    724 #endif
    725         return TRUE;
    726 }
    727 
    728 
    729 /**************************************************************************
    730  *              ICSendMessage                   [MSVFW.40]
    731  */
    732 LRESULT VFWAPI ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2)
    733 
    734 {
    735 #ifdef DEBUG
    736     dprintf(("MSVFW32: ICSendMessage\n"));
    737 #endif
     137LRESULT WINAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
     138        LRESULT         ret;
     139
     140        TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
     141        ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
     142        TRACE(" -> 0x%08lx\n",ret);
     143        return ret;
     144}
     145
     146HIC  VFWAPI
     147ICLocate(
     148        DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
     149        LPBITMAPINFOHEADER lpbiOut, WORD wMode
     150) {
     151        char    type[5],handler[5];
     152        HIC     hic;
     153        DWORD   querymsg;
     154
     155        switch (wMode) {
     156        case ICMODE_FASTCOMPRESS:
     157        case ICMODE_COMPRESS:
     158                querymsg = ICM_COMPRESS_QUERY;
     159                break;
     160        case ICMODE_DECOMPRESS:
     161        case ICMODE_FASTDECOMPRESS:
     162                querymsg = ICM_DECOMPRESS_QUERY;
     163                break;
     164        case ICMODE_DRAW:
     165                querymsg = ICM_DRAW_QUERY;
     166                break;
     167        default:
     168                dprintf(("Unknown mode (%d)\n",wMode));
     169                return 0;
     170        }
     171
     172        /* Easy case: handler/type match, we just fire a query and return */
     173        hic = ICOpen(fccType,fccHandler,wMode);
     174        if (hic) {
     175                if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
     176                        return hic;
     177                ICClose(hic);
     178        }
     179        type[4]='\0';memcpy(type,&fccType,4);
     180        handler[4]='\0';memcpy(handler,&fccHandler,4);
     181        if (fccType==streamtypeVIDEO) {
     182                hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
     183                if (hic)
     184                        return hic;
     185        }
     186        dprintf(("(%s,%s,%p,%p,0x%04x),unhandled!\n",type,handler,lpbiIn,lpbiOut,wMode));
     187        return 0;
     188}
     189
     190HIC VFWAPI ICGetDisplayFormat(
     191        HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
     192        INT depth,INT dx,INT dy
     193) {
     194        HIC     tmphic = hic;
     195        LRESULT lres;
     196
     197        dprintf(("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy));
     198        if (!tmphic) {
     199                tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
     200                if (!tmphic)
     201                        return tmphic;
     202        }
     203        if ((dy == lpbiIn->biHeight) || (dx == lpbiIn->biWidth))
     204                dy = dx = 0; /* no resize needed */
     205        /* Can we decompress it ? */
     206        lres = ICDecompressQuery(tmphic,lpbiIn,NULL);
     207        if (lres)
     208                goto errout; /* no, sorry */
     209        ICDecompressGetFormat(hic,lpbiIn,lpbiOut);
     210        *lpbiOut=*lpbiIn;
     211        lpbiOut->biCompression = 0;
     212        lpbiOut->biSize = sizeof(*lpbiOut);
     213        if (!depth) {
     214                HDC     hdc;
     215
     216                hdc = GetDC(0);
     217                depth = GetDeviceCaps(hdc,12)*GetDeviceCaps(hdc,14);
     218                ReleaseDC(0,hdc);
     219                if (depth==15)  depth = 16;
     220                if (depth<8)    depth =  8;
     221                /* more constraints and tests */
     222        }
     223        if (lpbiIn->biBitCount == 8)
     224                depth = 8;
     225       
     226        return hic;
     227errout:
     228        if (hic!=tmphic)
     229                ICClose(tmphic);
     230        return 0;
     231}
     232
     233DWORD VFWAPIV
     234ICCompress(
     235        HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
     236        LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
     237        LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
     238        LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
     239) {
     240        ICCOMPRESS      iccmp;
     241
     242        iccmp.dwFlags           = dwFlags;
     243
     244        iccmp.lpbiOutput        = lpbiOutput;
     245        iccmp.lpOutput          = lpData;
     246        iccmp.lpbiInput         = lpbiInput;
     247        iccmp.lpInput           = lpBits;
     248
     249        iccmp.lpckid            = lpckid;
     250        iccmp.lpdwFlags         = lpdwFlags;
     251        iccmp.lFrameNum         = lFrameNum;
     252        iccmp.dwFrameSize       = dwFrameSize;
     253        iccmp.dwQuality         = dwQuality;
     254        iccmp.lpbiPrev          = lpbiPrev;
     255        iccmp.lpPrev            = lpPrev;
     256        return ICSendMessage(hic,ICM_COMPRESS,(LPARAM)&iccmp,sizeof(iccmp));
     257}
     258
     259DWORD VFWAPIV
     260ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER  lpbi,LPVOID lpBits) {
     261        ICDECOMPRESS    icd;
     262
     263        icd.dwFlags     = dwFlags;
     264        icd.lpbiInput   = lpbiFormat;
     265        icd.lpInput     = lpData;
     266
     267        icd.lpbiOutput  = lpbi;
     268        icd.lpOutput    = lpBits;
     269        icd.ckid        = 0;
     270        return ICSendMessage(hic,ICM_DECOMPRESS,(LPARAM)&icd,sizeof(icd));
     271}
     272
     273LRESULT VFWAPI
     274ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2) {
    738275        LRESULT         ret;
    739276        WINE_HIC        *whic = (WINE_HIC*)hic;
    740         INT             tvfw;
    741 
    742 #define XX(x) case x:
    743 
    744         switch (msg)
    745         {
    746 
     277
     278#define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx)\n",(DWORD)hic,lParam1,lParam2);break;
     279
     280        switch (msg) {
    747281        XX(ICM_ABOUT)
    748282        XX(ICM_GETINFO)
    … …  
    786320        XX(ICM_SET_STATUS_PROC)
    787321        default:
    788           tvfw = 0;
     322                dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx)\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2));
    789323        }
    790324#if 0
    791325        if (whic->driverproc) {
     326                dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx), calling %p\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,whic->driverproc));
    792327                ret = whic->driverproc(whic->hdrv,1,msg,lParam1,lParam2);
    793328        } else
    794329#endif
    795         ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
     330                ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
     331        TRACE(" -> 0x%08lx\n",ret);
    796332        return ret;
     333}
     334
     335DWORD   VFWAPIV ICDrawBegin(
     336        HIC                     hic,
     337        DWORD                   dwFlags,/* flags */
     338        HPALETTE                hpal,   /* palette to draw with */
     339        HWND                    hwnd,   /* window to draw to */
     340        HDC                     hdc,    /* HDC to draw to */
     341        INT                     xDst,   /* destination rectangle */
     342        INT                     yDst,
     343        INT                     dxDst,
     344        INT                     dyDst,
     345        LPBITMAPINFOHEADER      lpbi,   /* format of frame to draw */
     346        INT                     xSrc,   /* source rectangle */
     347        INT                     ySrc,
     348        INT                     dxSrc,
     349        INT                     dySrc,
     350        DWORD                   dwRate, /* frames/second = (dwRate/dwScale) */
     351        DWORD                   dwScale) {
     352        ICDRAWBEGIN     icdb;
     353
     354        icdb.dwFlags = dwFlags;
     355        icdb.hpal = hpal;
     356        icdb.hwnd = hwnd;
     357        icdb.hdc = hdc;
     358        icdb.xDst = xDst;
     359        icdb.yDst = yDst;
     360        icdb.dxDst = dxDst;
     361        icdb.dyDst = dyDst;
     362        icdb.lpbi = lpbi;
     363        icdb.xSrc = xSrc;
     364        icdb.ySrc = ySrc;
     365        icdb.dxSrc = dxSrc;
     366        icdb.dySrc = dySrc;
     367        icdb.dwRate = dwRate;
     368        icdb.dwScale = dwScale;
     369        return ICSendMessage(hic,ICM_DRAW_BEGIN,(LPARAM)&icdb,sizeof(icdb));
     370}
     371
     372DWORD VFWAPIV ICDraw(
     373        HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,
     374        LONG lTime
     375) {
     376        ICDRAW  icd;
     377
     378        icd.dwFlags = dwFlags;
     379        icd.lpFormat = lpFormat;
     380        icd.lpData = lpData;
     381        icd.cbData = cbData;
     382        icd.lTime = lTime;
     383        return ICSendMessage(hic,ICM_DRAW,(LPARAM)&icd,sizeof(icd));
     384}
     385
     386LRESULT WINAPI ICClose(HIC hic) {
     387        WINE_HIC        *whic = (WINE_HIC*)hic;
     388        TRACE("(%d).\n",hic);
     389        /* FIXME: correct? */
     390        CloseDriver(whic->hdrv,0,0);
     391        HeapFree(GetProcessHeap(),0,whic);
     392        return 0;
     393}
     394
     395HANDLE /* HDRAWDIB */ WINAPI
     396DrawDibOpen( void ) {
     397        dprintf(("stub!\n"));
     398        return 0xdead;
     399}
     400
     401BOOL WINAPI
     402DrawDibClose( HANDLE /*HDRAWDIB*/ hDib ) {
     403       dprintf(("stub!\n"));
     404       return TRUE;
     405}
     406
     407BOOL VFWAPI DrawDibBegin(HANDLE /*HDRAWDIB*/ hdd,
     408                                    HDC      hdc,
     409                                    INT      dxDst,
     410                                    INT      dyDst,
     411                                    LPBITMAPINFOHEADER lpbi,
     412                                    INT      dxSrc,
     413                                    INT      dySrc,
     414                                    UINT     wFlags) {
     415        dprintf(("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx), stub!\n",
     416                hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
     417        ));
     418        return TRUE;
     419}
     420
     421
     422BOOL VFWAPI
     423DrawDibSetPalette(HANDLE /*HDRAWDIB*/ hdd, HPALETTE hpal) {
     424        dprintf(("(%d,%d),stub!\n",hdd,hpal));
     425        return TRUE;
     426}
     427
     428UINT VFWAPI DrawDibRealize(HANDLE /*HDRAWDIB*/ hdd, HDC hdc, BOOL fBackground) {
     429        dprintf(("(0x%08lx,0x%08lx,%d),stub!\n",(DWORD)hdd,(DWORD)hdc,fBackground));
     430        return 0;
     431}
     432
     433
     434HWND VFWAPIV MCIWndCreate (HWND hwndParent, HINSTANCE hInstance,
     435                      DWORD dwStyle,LPVOID szFile)
     436{       dprintf(("%x %x %lx %p\n",hwndParent, hInstance, dwStyle, szFile));
     437        return 0;
     438}
     439HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
     440                      DWORD dwStyle,LPCSTR szFile)
     441{       dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile));
     442        return 0;
     443}
     444HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
     445                      DWORD dwStyle,LPCWSTR szFile)
     446{       dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile)));
     447        return 0;
     448}
     449
     450/* Stubs not included in Wine-Code*/
     451
     452
     453/****************************************************************************
     454 *              DrawDibChangePalette            [MSVFW.4]
     455 */
     456
     457BOOL VFWAPI DrawDibChangePalette(HANDLE /*HDRAWDIB*/ hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
     458{
     459#ifdef DEBUG
     460    dprintf(("MSVFW32: DrawDibChangePalette not implemented\n"));
     461#endif
     462        return TRUE;
     463}
     464
     465
     466/****************************************************************************
     467 *              DrawDibDraw                     [MSVFW.6]
     468 */
     469BOOL VFWAPI DrawDibDraw(HANDLE /*HDRAWDIB*/ hdd,
     470                                   HDC      hdc,
     471                                   int      xDst,
     472                                   int      yDst,
     473                                   int      dxDst,
     474                                   int      dyDst,
     475                                   LPBITMAPINFOHEADER lpbi,
     476                                   LPVOID   lpBits,
     477                                   int      xSrc,
     478                                   int      ySrc,
     479                                   int      dxSrc,
     480                                   int      dySrc,
     481                                   UINT     wFlags)
     482{
     483#ifdef DEBUG
     484    dprintf(("MSVFW32: DrawDibDraw not implemented\n"));
     485#endif
     486       return TRUE;
     487}
     488
     489
     490/****************************************************************************
     491 *              DrawDibEnd                      [MSVFW.7]
     492 */
     493BOOL VFWAPI DrawDibEnd(HANDLE /*HDRAWDIB*/ hdd)
     494{
     495#ifdef DEBUG
     496    dprintf(("MSVFW32: DrawDibEnd not implemented\n"));
     497#endif
     498       return TRUE;
     499}
     500
     501
     502/****************************************************************************
     503 *              DrawDibGetBuffer                [MSVFW.8]
     504 */
     505LPVOID VFWAPI DrawDibGetBuffer(HANDLE /*HDRAWDIB*/ hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
     506{
     507#ifdef DEBUG
     508    dprintf(("MSVFW32: DrawDibGetBuffer not implemented\n"));
     509#endif
     510       return 0;
     511}
     512
     513
     514/****************************************************************************
     515 *              DrawDibGetPalette               [MSVFW.9]
     516 */
     517HPALETTE VFWAPI DrawDibGetPalette(HANDLE /*HDRAWDIB*/ hdd)
     518{
     519#ifdef DEBUG
     520    dprintf(("MSVFW32: DrawDibGetPalette not implemented\n"));
     521#endif
     522       return TRUE;
     523}
     524
     525
     526/****************************************************************************
     527 *              DrawDibProfileDisplay           [MSVFW.11]
     528 */
     529DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
     530{
     531#ifdef DEBUG
     532    dprintf(("MSVFW32: DrawDibProfileDisplay not implemented\n"));
     533#endif
     534       return TRUE;
     535}
     536
     537
     538/****************************************************************************
     539 *              DrawDibStart                    [MSVFW.14]
     540 */
     541BOOL VFWAPI DrawDibStart(HANDLE /*HDRAWDIB*/ hdd, DWORD rate)
     542{
     543#ifdef DEBUG
     544    dprintf(("MSVFW32: DrawDibStart not implemented\n"));
     545#endif
     546        return TRUE;
     547}
     548
     549
     550/****************************************************************************
     551 *              DrawDibStop                     [MSVFW.15]
     552 */
     553BOOL VFWAPI DrawDibStop(HANDLE /*HDRAWDIB*/ hdd)
     554{
     555#ifdef DEBUG
     556    dprintf(("MSVFW32: DrawDibStop not implemented\n"));
     557#endif
     558        return TRUE;
     559}
     560
     561
     562/****************************************************************************
     563 *              DrawDibTime                     [MSVFW.16]
     564 */
     565BOOL VFWAPI DrawDibTime(HANDLE /*HDRAWDIB*/ hdd, DWORD lpddtime)
     566{
     567#ifdef DEBUG
     568    dprintf(("MSVFW32: DrawDibTime not implemented\n"));
     569#endif
     570        return TRUE;
     571}
     572
     573
     574/****************************************************************************
     575 *              GetOpenFileNamePreview          [MSVFW.17]
     576 */
     577
     578/* NO */
     579
     580
     581/****************************************************************************
     582 *              GetOpenFileNamePreviewA         [MSVFW.18]
     583 */
     584BOOL VFWAPI GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn)
     585{
     586#ifdef DEBUG
     587    dprintf(("MSVFW32: GetOpenFileNamePreviewA not implemented\n"));
     588#endif
     589        return TRUE;
     590}
     591
     592
     593/****************************************************************************
     594 *              GetOpenFileNamePreviewW         [MSVFW.19]
     595 */
     596BOOL VFWAPI GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn)
     597{
     598#ifdef DEBUG
     599    dprintf(("MSVFW32: GetOpenFileNamePreviewW not implemented\n"));
     600#endif
     601        return TRUE;
     602}
     603
     604
     605/****************************************************************************
     606 *              GetSaveFileNamePreviewA         [MSVFW.20]
     607 */
     608BOOL VFWAPI GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn)
     609{
     610#ifdef DEBUG
     611    dprintf(("MSVFW32: GetSaveFileNamePreviewA not implemented\n"));
     612#endif
     613        return TRUE;
     614}
     615
     616
     617/****************************************************************************
     618 *              GetSaveFileNamePreviewW         [MSVFW.21]
     619 */
     620BOOL VFWAPI GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn)
     621{
     622#ifdef DEBUG
     623    dprintf(("MSVFW32: GetSaveFileNamePreviewW not implemented\n"));
     624#endif
     625        return TRUE;
     626}
     627
     628
     629/****************************************************************************
     630 *              ICCompressorChoose              [MSVFW.24]
     631 */
     632BOOL VFWAPI ICCompressorChoose(
     633        HWND        hwnd,               // parent window for dialog
     634        UINT        uiFlags,            // flags
     635        LPVOID      pvIn,               // input format (optional)
     636        LPVOID      lpData,             // input data (optional)
     637        PCOMPVARS   pc,                 // data about the compressor/dlg
     638        LPSTR       lpszTitle)          // dialog title (optional)
     639{
     640#ifdef DEBUG
     641    dprintf(("MSVFW32: ICCompressorChoose not implemented\n"));
     642#endif
     643        return TRUE;
     644}
     645
     646
     647/****************************************************************************
     648 *              ICCompressorFree                [MSVFW.25]
     649 */
     650void VFWAPI ICCompressorFree(PCOMPVARS pc)
     651{
     652#ifdef DEBUG
     653    dprintf(("MSVFW32: ICCompressorFree not implemented\n"));
     654#endif
     655        return;
     656}
     657
     658
     659/****************************************************************************
     660 *              ICImageCompress                 [MSVFW.31]
     661 */
     662HANDLE VFWAPI ICImageCompress(
     663        HIC                 hic,        // compressor to use
     664        UINT                uiFlags,    // flags (none yet)
     665        LPBITMAPINFO        lpbiIn,     // format to compress from
     666        LPVOID              lpBits,     // data to compress
     667        LPBITMAPINFO        lpbiOut,    // compress to this (NULL ==> default)
     668        LONG                lQuality,   // quality to use
     669        LONG                plSize)     // compress to this size (0=whatever)
     670{       
     671#ifdef DEBUG
     672    dprintf(("MSVFW32: ICImageCompress not implemented\n"));
     673#endif
     674        return 0;
     675}
     676
     677
     678/****************************************************************************
     679 *              ICImageDecompress               [MSVFW.32]
     680 */
     681HANDLE VFWAPI ICImageDecompress(
     682        HIC                 hic,        // compressor to use
     683        UINT                uiFlags,    // flags (none yet)
     684        LPBITMAPINFO        lpbiIn,     // format to decompress from
     685        LPVOID              lpBits,     // data to decompress
     686        LPBITMAPINFO        lpbiOut)    // decompress to this (NULL ==> default)
     687{       
     688#ifdef DEBUG
     689    dprintf(("MSVFW32: ICImageDecompress not implemented\n"));
     690#endif
     691        return 0;
     692}
     693
     694
     695/****************************************************************************
     696 *              ICInstall                       [MSVFW.34]
     697 */
     698BOOL    VFWAPI ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags)
     699{       
     700#ifdef DEBUG
     701    dprintf(("MSVFW32: ICInstall not implemented\n"));
     702#endif
     703        return TRUE;
     704}
     705
     706
     707/**************************************************************************
     708 *              ICRemove                        [MSVFW.39]
     709 */
     710BOOL    VFWAPI ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags)
     711{       
     712#ifdef DEBUG
     713    dprintf(("MSVFW32: ICRemove not implemented\n"));
     714#endif
     715        return TRUE;
    797716}
    798717
    … …  
    840759
    841760/**************************************************************************
    842  *              MCIWndCreate                    [MSVFW.44]
    843  */
    844 HWND VFWAPIV MCIWndCreate (HWND hwndParent, HINSTANCE hInstance,
    845                       DWORD dwStyle,LPVOID szFile)
    846 {       
    847 #ifdef DEBUG
    848     dprintf(("MSVFW32: MCIWndCreate not implemented\n"));
    849 #endif
    850         return 0;
    851 }
    852 
    853 
    854 /**************************************************************************
    855  *              MCIWndCreateA                   [MSVFW.45]
    856  */
    857 HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
    858                       DWORD dwStyle,LPCSTR szFile)
    859 {       
    860 #ifdef DEBUG
    861     dprintf(("MSVFW32: MCIWndCreateA not implemented\n"));
    862 #endif
    863         return 0;
    864 }
    865 
    866 
    867 /**************************************************************************
    868  *              MCIWndCreateW                   [MSVFW.46]
    869  */
    870 HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
    871                       DWORD dwStyle,LPCWSTR szFile)
    872 {       
    873 #ifdef DEBUG
    874     dprintf(("MSVFW32: MCIWndCreateW not implemented\n"));
    875 #endif
    876         return 0;
    877 }
    878 
    879 
    880 /**************************************************************************
    881761 *              MCIWndRegisterClass             [MSVFW.47]
    882762 */
    … …  
    888768        return TRUE;
    889769}
    890 
    891 
    892 /**************************************************************************
    893  *              StretchDIB                      [MSVFW.48]
    894  */
    895 
    896 /* NO */
Note: See TracChangeset for help on using the changeset viewer.