Changeset 6386 for trunk/src


Ignore:
Timestamp:
Jul 21, 2001, 7:39:44 PM (24 years ago)
Author:
sandervl
Message:

Resync with Wine (20010720)

Location:
trunk/src
Files:
14 added
1 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/avifil32/avifil32.def

    r4809 r6386  
    1 ; $Id: avifil32.def,v 1.4 2000-12-16 22:53:17 bird Exp $
     1; $Id: avifil32.def,v 1.5 2001-07-21 17:38:48 sandervl Exp $
    22
    33;
    … …  
    2727; AVIFileCreateStream        = _AVIFileCreateStream@?          @6
    2828  AVIFileCreateStreamA       = _AVIFileCreateStreamA@12        @7
    29 ; AVIFileCreateStreamW       = _AVIFileCreateStreamW@12        @8
     29  AVIFileCreateStreamW       = _AVIFileCreateStreamW@12        @8
    3030; AVIFileEndRecord           = _AVIFileEndRecord@?             @9
    3131  AVIFileExit                = _AVIFileExit@0                  @10
    32 ; AVIFileGetStream           = _AVIFileGetStream@?             @11
     32  AVIFileGetStream           = _AVIFileGetStream@16            @11
    3333  AVIFileInfo                = _AVIFileInfoA@12                @12
    3434  AVIFileInfoA               = _AVIFileInfoA@12                @13
    … …  
    7373  AVIStreamReadFormat        = _AVIStreamReadFormat@16         @52
    7474  AVIStreamRelease           = _AVIStreamRelease@4             @53
    75 ; AVIStreamSampleToTime      = _AVIStreamSampleToTime@?        @54
     75  AVIStreamSampleToTime      = _AVIStreamSampleToTime@8        @54
    7676  AVIStreamSetFormat         = _AVIStreamSetFormat@16          @55
    7777  AVIStreamStart             = _AVIStreamStart@4               @56
    78 ; AVIStreamTimeToSample      = _AVIStreamTimeToSample@?        @57
     78  AVIStreamTimeToSample      = _AVIStreamTimeToSample@8        @57
    7979  AVIStreamWrite             = _AVIStreamWrite@32              @58
    8080  AVIStreamWriteData         = _AVIStreamWriteData@16          @59

  • trunk/src/avifil32/makefile

    r4717 r6386  
    1 # $Id: makefile,v 1.11 2000-12-02 23:36:33 bird Exp $
     1# $Id: makefile,v 1.12 2001-07-21 17:38:50 sandervl Exp $
    22
    33#
    … …  
    1818#
    1919OBJS = \
    20 $(OBJDIR)\avifile.obj \
    21 $(OBJDIR)\avifil32.obj \
    22 $(DLLENTRY)
     20$(OBJDIR)\initterm.obj \
     21$(OBJDIR)\initavifil32.obj \
     22$(OBJDIR)\api.obj \
     23$(OBJDIR)\string.obj \
     24$(OBJDIR)\comentry.obj \
     25$(OBJDIR)\iafile.obj \
     26$(OBJDIR)\iastream.obj \
     27$(OBJDIR)\igframe.obj \
     28$(OBJDIR)\main.obj \
     29$(OBJDIR)\guid.obj \
     30$(OBJDIR)\avifil32.obj
    2331
    2432
    … …  
    2937$(ODIN32_LIB)/kernel32.lib \
    3038$(ODIN32_LIB)/$(ODINCRT).lib \
     39$(ODIN32_LIB)/ole32.lib \
     40$(ODIN32_LIB)/msvfw32.lib \
    3141OS2386.LIB \
    32 $(RTLLIB_O) \
    33 $(ODIN32_LIB)/ole32.lib \
    34 $(ODIN32_LIB)/msvfw32.lib
     42$(RTLLIB_O)
    3543
    3644

  • trunk/src/msvfw32/makefile

    r4717 r6386  
    1 # $Id: makefile,v 1.11 2000-12-02 23:40:22 bird Exp $
     1# $Id: makefile,v 1.12 2001-07-21 17:39:44 sandervl Exp $
    22
    33#
    … …  
    1919OBJS = \
    2020$(OBJDIR)\msvfw32.obj \
     21$(OBJDIR)\drawdib.obj \
     22$(OBJDIR)\msvideo_main.obj \
    2123$(OBJDIR)\msvfw32rsrc.obj \
    2224$(DLLENTRY)
    … …  
    2931$(ODIN32_LIB)/kernel32.lib \
    3032$(ODIN32_LIB)/user32.lib \
     33$(ODIN32_LIB)/version.lib \
    3134$(ODIN32_LIB)/gdi32.lib \
    3235$(ODIN32_LIB)/winmm.lib \

  • trunk/src/msvfw32/msvfw32.DEF

    r2223 r6386  
    1 ; $Id: msvfw32.DEF,v 1.3 1999-12-28 10:31:01 sandervl Exp $
     1; $Id: msvfw32.DEF,v 1.4 2001-07-21 17:39:44 sandervl Exp $
    22
    33;
    … …  
    2323    DrawDibStop                 = _DrawDibStop@4                        @15
    2424    DrawDibTime                 = _DrawDibTime@8                        @16
    25 ;    GetOpenFileNamePreview     = _GetOpenFileNamePreview               @17
     25    GetOpenFileNamePreview      = _GetOpenFileNamePreviewA@4            @17
    2626    GetOpenFileNamePreviewA     = _GetOpenFileNamePreviewA@4            @18
    2727    GetOpenFileNamePreviewW     = _GetOpenFileNamePreviewW@4            @19
    … …  
    4949    ICSeqCompressFrameEnd       = _ICSeqCompressFrameEnd@4              @42
    5050    ICSeqCompressFrameStart     = _ICSeqCompressFrameStart@8            @43
    51     MCIWndCreate                = _MCIWndCreate                         @44
     51    MCIWndCreate                = _MCIWndCreateA                        @44
    5252    MCIWndCreateA               = _MCIWndCreateA                        @45
    5353    MCIWndCreateW               = _MCIWndCreateW                        @46

  • trunk/src/msvfw32/msvfw32.cpp

    r5614 r6386  
    1 /* $Id: msvfw32.cpp,v 1.7 2001-04-28 09:11:36 hugh Exp $ */
     1/* $Id: msvfw32.cpp,v 1.8 2001-07-21 17:39:44 sandervl Exp $ */
    22/*
    33 * Copyright 1998 Marcus Meissner
    … …  
    3232DEFAULT_DEBUG_CHANNEL(msvideo)
    3333
    34 /****************************************************************************
    35  *    VideoForWindowsVersion    [MSVFW.2][MSVIDEO.2]
    36  * Returns the version in major.minor form.
    37  * In Windows95 this returns 0x040003b6 (4.950)
    38  */
    39 DWORD WINAPI
    40 VideoForWindowsVersion(void) {
    41   return 0x040003B6; /* 4.950 */
    42 }
    43 
    44 /* system.ini: [drivers] */
    45 
    46 /**************************************************************************
    47  *    ICInfo        [MSVFW.33]
    48  * Get information about an installable compressor. Return TRUE if there
    49  * is one.
    50  */
    51 BOOL WINAPI
    52 ICInfo(
    53   DWORD fccType,    /* [in] type of compressor ('vidc') */
    54   DWORD fccHandler, /* [in] <n>th compressor */
    55   ICINFO *lpicinfo  /* [out] information about compressor */
    56 ) {
    57   char  type[5],buf[2000];
    58 
    59   memcpy(type,&fccType,4);type[4]=0;
    60   TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
    61   /* does OpenDriver/CloseDriver */
    62   lpicinfo->dwSize = sizeof(ICINFO);
    63   lpicinfo->fccType = fccType;
    64   lpicinfo->dwFlags = 0;
    65   if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
    66     char *s = buf;
    67     while (*s) {
    68       if (!lstrncmpiA(type,s,4)) {
    69         if(!fccHandler--) {
    70           lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
    71           return TRUE;
    72         }
    73       }
    74       s=s+lstrlenA(s)+1; /* either next char or \0 */
    75     }
    76   }
    77   return FALSE;
    78 }
    79 
    80 /**************************************************************************
    81  *    ICOpen        [MSVFW.37]
    82  * Opens an installable compressor. Return special handle.
    83  */
    84 HIC WINAPI
    85 ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
    86   char    type[5],handler[5],codecname[20];
    87   ICOPEN    icopen;
    88   HDRVR   hdrv;
    89   WINE_HIC  *whic;
    90 
    91   memcpy(type,&fccType,4);type[4]=0;
    92   memcpy(handler,&fccHandler,4);handler[4]=0;
    93   TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
    94   sprintf(codecname,"%s.%s",type,handler);
    95 
    96   /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
    97    * same layout as ICOPEN
    98    */
    99   memset(&icopen,0,sizeof(ICOPEN));
    100   icopen.fccType    = fccType==0x43444956?0x63646976:fccType; //fccType use vidc if VIDC is passed in.
    101   icopen.fccHandler = fccHandler;
    102   icopen.dwSize     = sizeof(ICOPEN);
    103   icopen.dwVersion  = 0x03320000; // version 3,50,00 ???
    104   icopen.dwFlags    = wMode;
    105   TRACE("(0x%08lx,0x%08X=%d,%d)\n",icopen.fccType,icopen.fccHandler,icopen.fccHandler,icopen.dwSize);
    106 
    107   /* FIXME: do we need to fill out the rest too? */
    108   hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
    109   if (!hdrv)
    110   {
    111     TRACE("Driver returned Error %08x Version set to %08x\n",icopen.dwError,icopen.dwVersion);
    112     if (!strcasecmp(type,"vids"))
    113     {
    114       sprintf(codecname,"vidc.%s",handler);
    115       fccType = mmioFOURCC('v','i','d','c');
    116     }
    117     hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
    118     if (!hdrv)
    119     {
    120       TRACE("Driver returned Error %08x Version set to %08x\n",icopen.dwError,icopen.dwVersion);
    121       return 0;
    122     }
    123   }
    124   whic = (WINE_HIC *) HeapAlloc(GetProcessHeap(),0,sizeof(WINE_HIC));
    125   whic->hdrv  = hdrv;
    126   whic->driverproc= NULL;
    127   whic->privatevfw= ICSendMessage((HIC)whic,DRV_OPEN,0,(LPARAM)&icopen);
    128   return (HIC)whic;
    129 }
    130 HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode,
    131 FARPROC lpfnHandler) {
    132   char    type[5],handler[5];
    133   HIC   hic;
    134   WINE_HIC  *whic;
    135 
    136   memcpy(type,&fccType,4);type[4]=0;
    137   memcpy(handler,&fccHandler,4);handler[4]=0;
    138   dprintf(("(%s,%s,%d,%p), stub!\n",type,handler,wMode,lpfnHandler));
    139   hic = ICOpen(fccType,fccHandler,wMode);
    140   if (!hic)
    141     return hic;
    142   whic = (WINE_HIC*)hic;
    143   whic->driverproc = lpfnHandler;
    144   return hic;
    145 }
    146 
    147 
    148 LRESULT WINAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
    149   LRESULT   ret;
    150 
    151   TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
    152   ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
    153   TRACE(" -> 0x%08lx\n",ret);
    154   return ret;
    155 }
    156 
    157 HIC  VFWAPI
    158 ICLocate(
    159   DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
    160   LPBITMAPINFOHEADER lpbiOut, WORD wMode
    161 ) {
    162   char  type[5],handler[5];
    163   HIC hic;
    164   DWORD querymsg;
    165 
    166   switch (wMode) {
    167   case ICMODE_FASTCOMPRESS:
    168   case ICMODE_COMPRESS:
    169     querymsg = ICM_COMPRESS_QUERY;
    170     break;
    171   case ICMODE_DECOMPRESS:
    172   case ICMODE_FASTDECOMPRESS:
    173     querymsg = ICM_DECOMPRESS_QUERY;
    174     break;
    175   case ICMODE_DRAW:
    176     querymsg = ICM_DRAW_QUERY;
    177     break;
    178   default:
    179     dprintf(("Unknown mode (%d)\n",wMode));
     34
     35/* Stubs not included in Wine-Code*/
     36
     37
     38/****************************************************************************
     39 *    DrawDibChangePalette    [MSVFW.4]
     40 */
     41
     42BOOL VFWAPI DrawDibChangePalette(HANDLE /*HDRAWDIB*/ hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
     43{
     44    dprintf(("MSVFW32: DrawDibChangePalette not implemented\n"));
     45    return TRUE;
     46}
     47
     48
     49/****************************************************************************
     50 *    DrawDibProfileDisplay   [MSVFW.11]
     51 */
     52DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
     53{
     54       dprintf(("MSVFW32: DrawDibProfileDisplay not implemented\n"));
     55       return TRUE;
     56}
     57
     58/****************************************************************************
     59 *    DrawDibTime     [MSVFW.16]
     60 */
     61BOOL VFWAPI DrawDibTime(HANDLE /*HDRAWDIB*/ hdd, DWORD lpddtime)
     62{
     63    dprintf(("MSVFW32: DrawDibTime not implemented\n"));
     64    return TRUE;
     65}
     66
     67/****************************************************************************
     68 *    DrawDibGetBuffer    [MSVFW.8]
     69 */
     70LPVOID VFWAPI DrawDibGetBuffer(HANDLE /*HDRAWDIB*/ hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
     71{
     72    dprintf(("MSVFW32: DrawDibGetBuffer not implemented\n"));
    18073    return 0;
    181   }
    182 
    183   /* Easy case: handler/type match, we just fire a query and return */
    184   hic = ICOpen(fccType,fccHandler,wMode);
    185   if (hic) {
    186     if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
    187       return hic;
    188     ICClose(hic);
    189   }
    190   type[4]='\0';memcpy(type,&fccType,4);
    191   handler[4]='\0';memcpy(handler,&fccHandler,4);
    192   if (fccType==streamtypeVIDEO) {
    193     hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
    194     if (hic)
    195       return hic;
    196   }
    197   dprintf(("(%s,%s,%p,%p,0x%04x),unhandled!\n",type,handler,lpbiIn,lpbiOut,wMode));
    198   return 0;
    199 }
    200 
    201 HIC VFWAPI ICGetDisplayFormat(
    202   HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
    203   INT depth,INT dx,INT dy
    204 ) {
    205   HIC tmphic = hic;
    206   LRESULT lres;
    207 
    208   dprintf(("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy));
    209   if (!tmphic) {
    210     tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
    211     if (!tmphic)
    212       return tmphic;
    213   }
    214   if ((dy == lpbiIn->biHeight) || (dx == lpbiIn->biWidth))
    215     dy = dx = 0; /* no resize needed */
    216   /* Can we decompress it ? */
    217   lres = ICDecompressQuery(tmphic,lpbiIn,NULL);
    218   if (lres)
    219     goto errout; /* no, sorry */
    220   ICDecompressGetFormat(hic,lpbiIn,lpbiOut);
    221   *lpbiOut=*lpbiIn;
    222   lpbiOut->biCompression = 0;
    223   lpbiOut->biSize = sizeof(*lpbiOut);
    224   if (!depth) {
    225     HDC hdc;
    226 
    227     hdc = GetDC(0);
    228     depth = GetDeviceCaps(hdc,12)*GetDeviceCaps(hdc,14);
    229     ReleaseDC(0,hdc);
    230     if (depth==15)  depth = 16;
    231     if (depth<8)  depth =  8;
    232     /* more constraints and tests */
    233   }
    234   if (lpbiIn->biBitCount == 8)
    235     depth = 8;
    236 
    237   return hic;
    238 errout:
    239   if (hic!=tmphic)
    240     ICClose(tmphic);
    241   return 0;
    242 }
    243 
    244 DWORD VFWAPIV
    245 ICCompress(
    246   HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
    247   LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
    248   LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
    249   LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
    250 ) {
    251   ICCOMPRESS  iccmp;
    252 
    253   iccmp.dwFlags   = dwFlags;
    254 
    255   iccmp.lpbiOutput  = lpbiOutput;
    256   iccmp.lpOutput    = lpData;
    257   iccmp.lpbiInput   = lpbiInput;
    258   iccmp.lpInput   = lpBits;
    259 
    260   iccmp.lpckid    = lpckid;
    261   iccmp.lpdwFlags   = lpdwFlags;
    262   iccmp.lFrameNum   = lFrameNum;
    263   iccmp.dwFrameSize = dwFrameSize;
    264   iccmp.dwQuality   = dwQuality;
    265   iccmp.lpbiPrev    = lpbiPrev;
    266   iccmp.lpPrev    = lpPrev;
    267   return ICSendMessage(hic,ICM_COMPRESS,(LPARAM)&iccmp,sizeof(iccmp));
    268 }
    269 
    270 DWORD VFWAPIV
    271 ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER  lpbi,LPVOID lpBits) {
    272   ICDECOMPRESS  icd;
    273 
    274   icd.dwFlags = dwFlags;
    275   icd.lpbiInput = lpbiFormat;
    276   icd.lpInput = lpData;
    277 
    278   icd.lpbiOutput  = lpbi;
    279   icd.lpOutput  = lpBits;
    280   icd.ckid  = 0;
    281   return ICSendMessage(hic,ICM_DECOMPRESS,(LPARAM)&icd,sizeof(icd));
    282 }
    283 
    284 LRESULT VFWAPI
    285 ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2) {
    286   LRESULT   ret;
    287   WINE_HIC  *whic = (WINE_HIC*)hic;
    288 
    289 #define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx)\n",(DWORD)hic,lParam1,lParam2);break;
    290 
    291   switch (msg) {
    292   XX(ICM_ABOUT)
    293   XX(ICM_GETINFO)
    294   XX(ICM_COMPRESS_FRAMES_INFO)
    295   XX(ICM_COMPRESS_GET_FORMAT)
    296   XX(ICM_COMPRESS_GET_SIZE)
    297   XX(ICM_COMPRESS_QUERY)
    298   XX(ICM_COMPRESS_BEGIN)
    299   XX(ICM_COMPRESS)
    300   XX(ICM_COMPRESS_END)
    301   XX(ICM_DECOMPRESS_GET_FORMAT)
    302   XX(ICM_DECOMPRESS_QUERY)
    303   XX(ICM_DECOMPRESS_BEGIN)
    304   XX(ICM_DECOMPRESS)
    305   XX(ICM_DECOMPRESS_END)
    306   XX(ICM_DECOMPRESS_SET_PALETTE)
    307   XX(ICM_DECOMPRESS_GET_PALETTE)
    308   XX(ICM_DRAW_QUERY)
    309   XX(ICM_DRAW_BEGIN)
    310   XX(ICM_DRAW_GET_PALETTE)
    311   XX(ICM_DRAW_START)
    312   XX(ICM_DRAW_STOP)
    313   XX(ICM_DRAW_END)
    314   XX(ICM_DRAW_GETTIME)
    315   XX(ICM_DRAW)
    316   XX(ICM_DRAW_WINDOW)
    317   XX(ICM_DRAW_SETTIME)
    318   XX(ICM_DRAW_REALIZE)
    319   XX(ICM_DRAW_FLUSH)
    320   XX(ICM_DRAW_RENDERBUFFER)
    321   XX(ICM_DRAW_START_PLAY)
    322   XX(ICM_DRAW_STOP_PLAY)
    323   XX(ICM_DRAW_SUGGESTFORMAT)
    324   XX(ICM_DRAW_CHANGEPALETTE)
    325   XX(ICM_GETBUFFERSWANTED)
    326   XX(ICM_GETDEFAULTKEYFRAMERATE)
    327   XX(ICM_DECOMPRESSEX_BEGIN)
    328   XX(ICM_DECOMPRESSEX_QUERY)
    329   XX(ICM_DECOMPRESSEX)
    330   XX(ICM_DECOMPRESSEX_END)
    331   XX(ICM_SET_STATUS_PROC)
    332   default:
    333     dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx)\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2));
    334   }
    335 #if 0
    336   if (whic->driverproc) {
    337     dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx), calling %p\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,whic->driverproc));
    338     ret = whic->driverproc(whic->hdrv,1,msg,lParam1,lParam2);
    339   } else
    340 #endif
    341     ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
    342   TRACE(" -> 0x%08lx\n",ret);
    343   return ret;
    344 }
    345 
    346 DWORD VFWAPIV ICDrawBegin(
    347         HIC     hic,
    348         DWORD     dwFlags,/* flags */
    349         HPALETTE    hpal, /* palette to draw with */
    350         HWND      hwnd, /* window to draw to */
    351         HDC     hdc,  /* HDC to draw to */
    352         INT     xDst, /* destination rectangle */
    353         INT     yDst,
    354         INT     dxDst,
    355         INT     dyDst,
    356         LPBITMAPINFOHEADER  lpbi, /* format of frame to draw */
    357         INT     xSrc, /* source rectangle */
    358         INT     ySrc,
    359         INT     dxSrc,
    360         INT     dySrc,
    361         DWORD     dwRate, /* frames/second = (dwRate/dwScale) */
    362         DWORD     dwScale) {
    363   ICDRAWBEGIN icdb;
    364 
    365   icdb.dwFlags = dwFlags;
    366   icdb.hpal = hpal;
    367   icdb.hwnd = hwnd;
    368   icdb.hdc = hdc;
    369   icdb.xDst = xDst;
    370   icdb.yDst = yDst;
    371   icdb.dxDst = dxDst;
    372   icdb.dyDst = dyDst;
    373   icdb.lpbi = lpbi;
    374   icdb.xSrc = xSrc;
    375   icdb.ySrc = ySrc;
    376   icdb.dxSrc = dxSrc;
    377   icdb.dySrc = dySrc;
    378   icdb.dwRate = dwRate;
    379   icdb.dwScale = dwScale;
    380   return ICSendMessage(hic,ICM_DRAW_BEGIN,(LPARAM)&icdb,sizeof(icdb));
    381 }
    382 
    383 DWORD VFWAPIV ICDraw(
    384   HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,
    385   LONG lTime
    386 ) {
    387   ICDRAW  icd;
    388 
    389   icd.dwFlags = dwFlags;
    390   icd.lpFormat = lpFormat;
    391   icd.lpData = lpData;
    392   icd.cbData = cbData;
    393   icd.lTime = lTime;
    394   return ICSendMessage(hic,ICM_DRAW,(LPARAM)&icd,sizeof(icd));
    395 }
    396 
    397 LRESULT WINAPI ICClose(HIC hic) {
    398   WINE_HIC  *whic = (WINE_HIC*)hic;
    399   TRACE("(%d).\n",hic);
    400   /* FIXME: correct? */
    401   CloseDriver(whic->hdrv,0,0);
    402   HeapFree(GetProcessHeap(),0,whic);
    403   return 0;
    404 }
    405 
    406 HANDLE /* HDRAWDIB */ WINAPI
    407 DrawDibOpen( void ) {
    408   dprintf(("stub!\n"));
    409   return 0xdead;
    410 }
    411 
    412 BOOL WINAPI
    413 DrawDibClose( HANDLE /*HDRAWDIB*/ hDib ) {
    414        dprintf(("stub!\n"));
    415        return TRUE;
    416 }
    417 
    418 BOOL VFWAPI DrawDibBegin(HANDLE /*HDRAWDIB*/ hdd,
    419                                     HDC      hdc,
    420                                     INT      dxDst,
    421                                     INT      dyDst,
    422                                     LPBITMAPINFOHEADER lpbi,
    423                                     INT      dxSrc,
    424                                     INT      dySrc,
    425                                     UINT     wFlags) {
    426   dprintf(("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx), stub!\n",
    427     hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
    428   ));
    429   return TRUE;
    430 }
    431 
    432 
    433 BOOL VFWAPI
    434 DrawDibSetPalette(HANDLE /*HDRAWDIB*/ hdd, HPALETTE hpal) {
    435   dprintf(("(%d,%d),stub!\n",hdd,hpal));
    436   return TRUE;
    437 }
    438 
    439 UINT VFWAPI DrawDibRealize(HANDLE /*HDRAWDIB*/ hdd, HDC hdc, BOOL fBackground) {
    440   dprintf(("(0x%08lx,0x%08lx,%d),stub!\n",(DWORD)hdd,(DWORD)hdc,fBackground));
    441   return 0;
    442 }
    443 
    444 
    445 HWND VFWAPIV MCIWndCreate (HWND hwndParent, HINSTANCE hInstance,
    446                       DWORD dwStyle,LPVOID szFile)
    447 { dprintf(("%x %x %lx %p\n",hwndParent, hInstance, dwStyle, szFile));
    448   return 0;
    449 }
    450 HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
    451                       DWORD dwStyle,LPCSTR szFile)
    452 { dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile));
    453   return 0;
    454 }
    455 HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
    456                       DWORD dwStyle,LPCWSTR szFile)
    457 { dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile)));
    458   return 0;
    459 }
    460 
    461 /* Stubs not included in Wine-Code*/
    462 
    463 
    464 /****************************************************************************
    465  *    DrawDibChangePalette    [MSVFW.4]
    466  */
    467 
    468 BOOL VFWAPI DrawDibChangePalette(HANDLE /*HDRAWDIB*/ hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
    469 {
    470 #ifdef DEBUG
    471     dprintf(("MSVFW32: DrawDibChangePalette not implemented\n"));
    472 #endif
    473   return TRUE;
    474 }
    475 
    476 
    477 /****************************************************************************
    478  *    DrawDibDraw     [MSVFW.6]
    479  */
    480 BOOL VFWAPI DrawDibDraw(HANDLE /*HDRAWDIB*/ hdd,
    481                                    HDC      hdc,
    482                                    int      xDst,
    483                                    int      yDst,
    484                                    int      dxDst,
    485                                    int      dyDst,
    486                                    LPBITMAPINFOHEADER lpbi,
    487                                    LPVOID   lpBits,
    488                                    int      xSrc,
    489                                    int      ySrc,
    490                                    int      dxSrc,
    491                                    int      dySrc,
    492                                    UINT     wFlags)
    493 {
    494 #ifdef DEBUG
    495     dprintf(("MSVFW32: DrawDibDraw not implemented\n"));
    496 #endif
    497        return TRUE;
    498 }
    499 
    500 
    501 /****************************************************************************
    502  *    DrawDibEnd      [MSVFW.7]
    503  */
    504 BOOL VFWAPI DrawDibEnd(HANDLE /*HDRAWDIB*/ hdd)
    505 {
    506 #ifdef DEBUG
    507     dprintf(("MSVFW32: DrawDibEnd not implemented\n"));
    508 #endif
    509        return TRUE;
    510 }
    511 
    512 
    513 /****************************************************************************
    514  *    DrawDibGetBuffer    [MSVFW.8]
    515  */
    516 LPVOID VFWAPI DrawDibGetBuffer(HANDLE /*HDRAWDIB*/ hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
    517 {
    518 #ifdef DEBUG
    519     dprintf(("MSVFW32: DrawDibGetBuffer not implemented\n"));
    520 #endif
    521        return 0;
    522 }
    523 
    524 
    525 /****************************************************************************
    526  *    DrawDibGetPalette   [MSVFW.9]
    527  */
    528 HPALETTE VFWAPI DrawDibGetPalette(HANDLE /*HDRAWDIB*/ hdd)
    529 {
    530 #ifdef DEBUG
    531     dprintf(("MSVFW32: DrawDibGetPalette not implemented\n"));
    532 #endif
    533        return TRUE;
    534 }
    535 
    536 
    537 /****************************************************************************
    538  *    DrawDibProfileDisplay   [MSVFW.11]
    539  */
    540 DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
    541 {
    542 #ifdef DEBUG
    543     dprintf(("MSVFW32: DrawDibProfileDisplay not implemented\n"));
    544 #endif
    545        return TRUE;
    546 }
    547 
    548 
    549 /****************************************************************************
    550  *    DrawDibStart      [MSVFW.14]
    551  */
    552 BOOL VFWAPI DrawDibStart(HANDLE /*HDRAWDIB*/ hdd, DWORD rate)
    553 {
    554 #ifdef DEBUG
    555     dprintf(("MSVFW32: DrawDibStart not implemented\n"));
    556 #endif
    557   return TRUE;
    558 }
    559 
    560 
    561 /****************************************************************************
    562  *    DrawDibStop     [MSVFW.15]
    563  */
    564 BOOL VFWAPI DrawDibStop(HANDLE /*HDRAWDIB*/ hdd)
    565 {
    566 #ifdef DEBUG
    567     dprintf(("MSVFW32: DrawDibStop not implemented\n"));
    568 #endif
    569   return TRUE;
    570 }
    571 
    572 
    573 /****************************************************************************
    574  *    DrawDibTime     [MSVFW.16]
    575  */
    576 BOOL VFWAPI DrawDibTime(HANDLE /*HDRAWDIB*/ hdd, DWORD lpddtime)
    577 {
    578 #ifdef DEBUG
    579     dprintf(("MSVFW32: DrawDibTime not implemented\n"));
    580 #endif
    581   return TRUE;
    582 }
    583 
     74}
    58475
    58576/****************************************************************************
Note: See TracChangeset for help on using the changeset viewer.