Changeset 5614 for trunk/src


Ignore:
Timestamp:
Apr 28, 2001, 11:11:36 AM (25 years ago)
Author:
hugh
Message:

fixed ICOpen to correct VIDC to vidc in fccType

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msvfw32/msvfw32.cpp

    r4631 r5614  
    1 /* $Id: msvfw32.cpp,v 1.6 2000-11-19 13:04:28 sandervl Exp $ */
     1/* $Id: msvfw32.cpp,v 1.7 2001-04-28 09:11:36 hugh Exp $ */
    22/*
    33 * Copyright 1998 Marcus Meissner
    … …  
    3333
    3434/****************************************************************************
    35  *              VideoForWindowsVersion          [MSVFW.2][MSVIDEO.2]
     35 *    VideoForWindowsVersion    [MSVFW.2][MSVIDEO.2]
    3636 * Returns the version in major.minor form.
    3737 * In Windows95 this returns 0x040003b6 (4.950)
    … …  
    3939DWORD WINAPI
    4040VideoForWindowsVersion(void) {
    41         return 0x040003B6; /* 4.950 */
     41  return 0x040003B6; /* 4.950 */
    4242}
    4343
    … …  
    4545
    4646/**************************************************************************
    47  *              ICInfo                          [MSVFW.33]
     47 *    ICInfo        [MSVFW.33]
    4848 * Get information about an installable compressor. Return TRUE if there
    4949 * is one.
    … …  
    5151BOOL WINAPI
    5252ICInfo(
    53         DWORD fccType,          /* [in] type of compressor ('vidc') */
    54         DWORD fccHandler,       /* [in] <n>th compressor */
    55         ICINFO *lpicinfo        /* [out] information about compressor */
     53  DWORD fccType,    /* [in] type of compressor ('vidc') */
     54  DWORD fccHandler, /* [in] <n>th compressor */
     55  ICINFO *lpicinfo  /* [out] information about compressor */
    5656) {
    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;
     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;
    7878}
    7979
    8080/**************************************************************************
    81  *              ICOpen                          [MSVFW.37]
     81 *    ICOpen        [MSVFW.37]
    8282 * Opens an installable compressor. Return special handle.
    8383 */
    8484HIC WINAPI
    8585ICOpen(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         icopen.fccType          = fccType;
    100         icopen.fccHandler       = fccHandler;
    101         icopen.dwSize           = sizeof(ICOPEN);
    102         icopen.dwFlags          = wMode;
    103         /* FIXME: do we need to fill out the rest too? */
    104         hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
    105         if (!hdrv) {
    106             if (!strcasecmp(type,"vids")) {
    107                 sprintf(codecname,"vidc.%s",handler);
    108                 fccType = mmioFOURCC('v','i','d','c');
    109             }
    110             hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
    111             if (!hdrv)
    112                     return 0;
    113         }
    114         whic = (WINE_HIC *) HeapAlloc(GetProcessHeap(),0,sizeof(WINE_HIC));
    115         whic->hdrv      = hdrv;
    116         whic->driverproc= NULL;
    117         whic->privatevfw= ICSendMessage((HIC)whic,DRV_OPEN,0,(LPARAM)&icopen);
    118         return (HIC)whic;
     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;
    119129}
    120130HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode,
    121131FARPROC lpfnHandler) {
    122         char            type[5],handler[5];
    123         HIC             hic;
    124         WINE_HIC        *whic;
    125 
    126         memcpy(type,&fccType,4);type[4]=0;
    127         memcpy(handler,&fccHandler,4);handler[4]=0;
    128         dprintf(("(%s,%s,%d,%p), stub!\n",type,handler,wMode,lpfnHandler));
    129         hic = ICOpen(fccType,fccHandler,wMode);
    130         if (!hic)
    131                 return hic;
    132         whic = (WINE_HIC*)hic;
    133         whic->driverproc = lpfnHandler;
    134         return hic;
     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;
    135145}
    136146
    137147
    138148LRESULT WINAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
    139         LRESULT         ret;
    140 
    141         TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
    142         ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
    143         TRACE(" -> 0x%08lx\n",ret);
    144         return ret;
     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;
    145155}
    146156
    147157HIC  VFWAPI
    148158ICLocate(
    149         DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
    150         LPBITMAPINFOHEADER lpbiOut, WORD wMode
     159  DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
     160  LPBITMAPINFOHEADER lpbiOut, WORD wMode
    151161) {
    152         char    type[5],handler[5];
    153         HIC     hic;
    154         DWORD   querymsg;
    155 
    156         switch (wMode) {
    157         case ICMODE_FASTCOMPRESS:
    158         case ICMODE_COMPRESS:
    159                 querymsg = ICM_COMPRESS_QUERY;
    160                 break;
    161         case ICMODE_DECOMPRESS:
    162         case ICMODE_FASTDECOMPRESS:
    163                 querymsg = ICM_DECOMPRESS_QUERY;
    164                 break;
    165         case ICMODE_DRAW:
    166                 querymsg = ICM_DRAW_QUERY;
    167                 break;
    168         default:
    169                 dprintf(("Unknown mode (%d)\n",wMode));
    170                 return 0;
    171         }
    172 
    173         /* Easy case: handler/type match, we just fire a query and return */
    174         hic = ICOpen(fccType,fccHandler,wMode);
    175         if (hic) {
    176                 if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
    177                         return hic;
    178                 ICClose(hic);
    179         }
    180         type[4]='\0';memcpy(type,&fccType,4);
    181         handler[4]='\0';memcpy(handler,&fccHandler,4);
    182         if (fccType==streamtypeVIDEO) {
    183                 hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
    184                 if (hic)
    185                         return hic;
    186         }
    187         dprintf(("(%s,%s,%p,%p,0x%04x),unhandled!\n",type,handler,lpbiIn,lpbiOut,wMode));
    188         return 0;
     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));
     180    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;
    189199}
    190200
    191201HIC VFWAPI ICGetDisplayFormat(
    192         HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
    193         INT depth,INT dx,INT dy
     202  HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
     203  INT depth,INT dx,INT dy
    194204) {
    195         HIC     tmphic = hic;
    196         LRESULT lres;
    197 
    198         dprintf(("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy));
    199         if (!tmphic) {
    200                 tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
    201                 if (!tmphic)
    202                         return tmphic;
    203         }
    204         if ((dy == lpbiIn->biHeight) || (dx == lpbiIn->biWidth))
    205                 dy = dx = 0; /* no resize needed */
    206         /* Can we decompress it ? */
    207         lres = ICDecompressQuery(tmphic,lpbiIn,NULL);
    208         if (lres)
    209                 goto errout; /* no, sorry */
    210         ICDecompressGetFormat(hic,lpbiIn,lpbiOut);
    211         *lpbiOut=*lpbiIn;
    212         lpbiOut->biCompression = 0;
    213         lpbiOut->biSize = sizeof(*lpbiOut);
    214         if (!depth) {
    215                 HDC     hdc;
    216 
    217                 hdc = GetDC(0);
    218                 depth = GetDeviceCaps(hdc,12)*GetDeviceCaps(hdc,14);
    219                 ReleaseDC(0,hdc);
    220                 if (depth==15)  depth = 16;
    221                 if (depth<8)    depth =  8;
    222                 /* more constraints and tests */
    223         }
    224         if (lpbiIn->biBitCount == 8)
    225                 depth = 8;
    226 
    227         return hic;
     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;
    228238errout:
    229         if (hic!=tmphic)
    230                 ICClose(tmphic);
    231         return 0;
     239  if (hic!=tmphic)
     240    ICClose(tmphic);
     241  return 0;
    232242}
    233243
    234244DWORD VFWAPIV
    235245ICCompress(
    236         HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
    237         LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
    238         LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
    239         LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev
     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
    240250) {
    241         ICCOMPRESS      iccmp;
    242 
    243         iccmp.dwFlags           = dwFlags;
    244 
    245         iccmp.lpbiOutput        = lpbiOutput;
    246         iccmp.lpOutput          = lpData;
    247         iccmp.lpbiInput         = lpbiInput;
    248         iccmp.lpInput           = lpBits;
    249 
    250         iccmp.lpckid            = lpckid;
    251         iccmp.lpdwFlags         = lpdwFlags;
    252         iccmp.lFrameNum         = lFrameNum;
    253         iccmp.dwFrameSize       = dwFrameSize;
    254         iccmp.dwQuality         = dwQuality;
    255         iccmp.lpbiPrev          = lpbiPrev;
    256         iccmp.lpPrev            = lpPrev;
    257         return ICSendMessage(hic,ICM_COMPRESS,(LPARAM)&iccmp,sizeof(iccmp));
     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));
    258268}
    259269
    260270DWORD VFWAPIV
    261271ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER  lpbi,LPVOID lpBits) {
    262         ICDECOMPRESS    icd;
    263 
    264         icd.dwFlags     = dwFlags;
    265         icd.lpbiInput   = lpbiFormat;
    266         icd.lpInput     = lpData;
    267 
    268         icd.lpbiOutput  = lpbi;
    269         icd.lpOutput    = lpBits;
    270         icd.ckid        = 0;
    271         return ICSendMessage(hic,ICM_DECOMPRESS,(LPARAM)&icd,sizeof(icd));
     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));
    272282}
    273283
    274284LRESULT VFWAPI
    275285ICSendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2) {
    276         LRESULT         ret;
    277         WINE_HIC        *whic = (WINE_HIC*)hic;
     286  LRESULT   ret;
     287  WINE_HIC  *whic = (WINE_HIC*)hic;
    278288
    279289#define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx)\n",(DWORD)hic,lParam1,lParam2);break;
    280290
    281         switch (msg) {
    282         XX(ICM_ABOUT)
    283         XX(ICM_GETINFO)
    284         XX(ICM_COMPRESS_FRAMES_INFO)
    285         XX(ICM_COMPRESS_GET_FORMAT)
    286         XX(ICM_COMPRESS_GET_SIZE)
    287         XX(ICM_COMPRESS_QUERY)
    288         XX(ICM_COMPRESS_BEGIN)
    289         XX(ICM_COMPRESS)
    290         XX(ICM_COMPRESS_END)
    291         XX(ICM_DECOMPRESS_GET_FORMAT)
    292         XX(ICM_DECOMPRESS_QUERY)
    293         XX(ICM_DECOMPRESS_BEGIN)
    294         XX(ICM_DECOMPRESS)
    295         XX(ICM_DECOMPRESS_END)
    296         XX(ICM_DECOMPRESS_SET_PALETTE)
    297         XX(ICM_DECOMPRESS_GET_PALETTE)
    298         XX(ICM_DRAW_QUERY)
    299         XX(ICM_DRAW_BEGIN)
    300         XX(ICM_DRAW_GET_PALETTE)
    301         XX(ICM_DRAW_START)
    302         XX(ICM_DRAW_STOP)
    303         XX(ICM_DRAW_END)
    304         XX(ICM_DRAW_GETTIME)
    305         XX(ICM_DRAW)
    306         XX(ICM_DRAW_WINDOW)
    307         XX(ICM_DRAW_SETTIME)
    308         XX(ICM_DRAW_REALIZE)
    309         XX(ICM_DRAW_FLUSH)
    310         XX(ICM_DRAW_RENDERBUFFER)
    311         XX(ICM_DRAW_START_PLAY)
    312         XX(ICM_DRAW_STOP_PLAY)
    313         XX(ICM_DRAW_SUGGESTFORMAT)
    314         XX(ICM_DRAW_CHANGEPALETTE)
    315         XX(ICM_GETBUFFERSWANTED)
    316         XX(ICM_GETDEFAULTKEYFRAMERATE)
    317         XX(ICM_DECOMPRESSEX_BEGIN)
    318         XX(ICM_DECOMPRESSEX_QUERY)
    319         XX(ICM_DECOMPRESSEX)
    320         XX(ICM_DECOMPRESSEX_END)
    321         XX(ICM_SET_STATUS_PROC)
    322         default:
    323                 dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx)\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2));
    324         }
     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  }
    325335#if 0
    326         if (whic->driverproc) {
    327                 dprintf(("(0x%08lx,0x%08lx,0x%08lx,0x%08lx), calling %p\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,whic->driverproc));
    328                 ret = whic->driverproc(whic->hdrv,1,msg,lParam1,lParam2);
    329         } else
    330 #endif
    331                 ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
    332         TRACE(" -> 0x%08lx\n",ret);
    333         return ret;
    334 }
    335 
    336 DWORD   VFWAPIV ICDrawBegin(
    337         HIC                     hic,
    338         DWORD                   dwFlags,/* flags */
    339         HPALETTE                hpal,   /* palette to draw with */
    340         HWND                    hwnd,   /* window to draw to */
    341         HDC                     hdc,    /* HDC to draw to */
    342         INT                     xDst,   /* destination rectangle */
    343         INT                     yDst,
    344         INT                     dxDst,
    345         INT                     dyDst,
    346         LPBITMAPINFOHEADER      lpbi,   /* format of frame to draw */
    347         INT                     xSrc,   /* source rectangle */
    348         INT                     ySrc,
    349         INT                     dxSrc,
    350         INT                     dySrc,
    351         DWORD                   dwRate, /* frames/second = (dwRate/dwScale) */
    352         DWORD                   dwScale) {
    353         ICDRAWBEGIN     icdb;
    354 
    355         icdb.dwFlags = dwFlags;
    356         icdb.hpal = hpal;
    357         icdb.hwnd = hwnd;
    358         icdb.hdc = hdc;
    359         icdb.xDst = xDst;
    360         icdb.yDst = yDst;
    361         icdb.dxDst = dxDst;
    362         icdb.dyDst = dyDst;
    363         icdb.lpbi = lpbi;
    364         icdb.xSrc = xSrc;
    365         icdb.ySrc = ySrc;
    366         icdb.dxSrc = dxSrc;
    367         icdb.dySrc = dySrc;
    368         icdb.dwRate = dwRate;
    369         icdb.dwScale = dwScale;
    370         return ICSendMessage(hic,ICM_DRAW_BEGIN,(LPARAM)&icdb,sizeof(icdb));
     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
     346DWORD 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));
    371381}
    372382
    373383DWORD VFWAPIV ICDraw(
    374         HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,
    375         LONG lTime
     384  HIC hic,DWORD dwFlags,LPVOID lpFormat,LPVOID lpData,DWORD cbData,
     385  LONG lTime
    376386) {
    377         ICDRAW  icd;
    378 
    379         icd.dwFlags = dwFlags;
    380         icd.lpFormat = lpFormat;
    381         icd.lpData = lpData;
    382         icd.cbData = cbData;
    383         icd.lTime = lTime;
    384         return ICSendMessage(hic,ICM_DRAW,(LPARAM)&icd,sizeof(icd));
     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));
    385395}
    386396
    387397LRESULT WINAPI ICClose(HIC hic) {
    388         WINE_HIC        *whic = (WINE_HIC*)hic;
    389         TRACE("(%d).\n",hic);
    390         /* FIXME: correct? */
    391         CloseDriver(whic->hdrv,0,0);
    392         HeapFree(GetProcessHeap(),0,whic);
    393         return 0;
     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;
    394404}
    395405
    396406HANDLE /* HDRAWDIB */ WINAPI
    397407DrawDibOpen( void ) {
    398         dprintf(("stub!\n"));
    399         return 0xdead;
     408  dprintf(("stub!\n"));
     409  return 0xdead;
    400410}
    401411
    … …  
    414424                                    INT      dySrc,
    415425                                    UINT     wFlags) {
    416         dprintf(("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx), stub!\n",
    417                 hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
    418         ));
    419         return TRUE;
     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;
    420430}
    421431
    … …  
    423433BOOL VFWAPI
    424434DrawDibSetPalette(HANDLE /*HDRAWDIB*/ hdd, HPALETTE hpal) {
    425         dprintf(("(%d,%d),stub!\n",hdd,hpal));
    426         return TRUE;
     435  dprintf(("(%d,%d),stub!\n",hdd,hpal));
     436  return TRUE;
    427437}
    428438
    429439UINT VFWAPI DrawDibRealize(HANDLE /*HDRAWDIB*/ hdd, HDC hdc, BOOL fBackground) {
    430         dprintf(("(0x%08lx,0x%08lx,%d),stub!\n",(DWORD)hdd,(DWORD)hdc,fBackground));
    431         return 0;
     440  dprintf(("(0x%08lx,0x%08lx,%d),stub!\n",(DWORD)hdd,(DWORD)hdc,fBackground));
     441  return 0;
    432442}
    433443
    … …  
    435445HWND VFWAPIV MCIWndCreate (HWND hwndParent, HINSTANCE hInstance,
    436446                      DWORD dwStyle,LPVOID szFile)
    437 {       dprintf(("%x %x %lx %p\n",hwndParent, hInstance, dwStyle, szFile));
    438         return 0;
     447{ dprintf(("%x %x %lx %p\n",hwndParent, hInstance, dwStyle, szFile));
     448  return 0;
    439449}
    440450HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
    441451                      DWORD dwStyle,LPCSTR szFile)
    442 {       dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile));
    443         return 0;
     452{ dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile));
     453  return 0;
    444454}
    445455HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
    446456                      DWORD dwStyle,LPCWSTR szFile)
    447 {       dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile)));
    448         return 0;
     457{ dprintf(("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile)));
     458  return 0;
    449459}
    450460
    … …  
    453463
    454464/****************************************************************************
    455  *              DrawDibChangePalette            [MSVFW.4]
     465 *    DrawDibChangePalette    [MSVFW.4]
    456466 */
    457467
    … …  
    461471    dprintf(("MSVFW32: DrawDibChangePalette not implemented\n"));
    462472#endif
    463         return TRUE;
    464 }
    465 
    466 
    467 /****************************************************************************
    468  *              DrawDibDraw                     [MSVFW.6]
     473  return TRUE;
     474}
     475
     476
     477/****************************************************************************
     478 *    DrawDibDraw     [MSVFW.6]
    469479 */
    470480BOOL VFWAPI DrawDibDraw(HANDLE /*HDRAWDIB*/ hdd,
    … …  
    490500
    491501/****************************************************************************
    492  *              DrawDibEnd                      [MSVFW.7]
     502 *    DrawDibEnd      [MSVFW.7]
    493503 */
    494504BOOL VFWAPI DrawDibEnd(HANDLE /*HDRAWDIB*/ hdd)
    … …  
    502512
    503513/****************************************************************************
    504  *              DrawDibGetBuffer                [MSVFW.8]
     514 *    DrawDibGetBuffer    [MSVFW.8]
    505515 */
    506516LPVOID VFWAPI DrawDibGetBuffer(HANDLE /*HDRAWDIB*/ hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
    … …  
    514524
    515525/****************************************************************************
    516  *              DrawDibGetPalette               [MSVFW.9]
     526 *    DrawDibGetPalette   [MSVFW.9]
    517527 */
    518528HPALETTE VFWAPI DrawDibGetPalette(HANDLE /*HDRAWDIB*/ hdd)
    … …  
    526536
    527537/****************************************************************************
    528  *              DrawDibProfileDisplay           [MSVFW.11]
     538 *    DrawDibProfileDisplay   [MSVFW.11]
    529539 */
    530540DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
    … …  
    538548
    539549/****************************************************************************
    540  *              DrawDibStart                    [MSVFW.14]
     550 *    DrawDibStart      [MSVFW.14]
    541551 */
    542552BOOL VFWAPI DrawDibStart(HANDLE /*HDRAWDIB*/ hdd, DWORD rate)
    … …  
    545555    dprintf(("MSVFW32: DrawDibStart not implemented\n"));
    546556#endif
    547         return TRUE;
    548 }
    549 
    550 
    551 /****************************************************************************
    552  *              DrawDibStop                     [MSVFW.15]
     557  return TRUE;
     558}
     559
     560
     561/****************************************************************************
     562 *    DrawDibStop     [MSVFW.15]
    553563 */
    554564BOOL VFWAPI DrawDibStop(HANDLE /*HDRAWDIB*/ hdd)
    … …  
    557567    dprintf(("MSVFW32: DrawDibStop not implemented\n"));
    558568#endif
    559         return TRUE;
    560 }
    561 
    562 
    563 /****************************************************************************
    564  *              DrawDibTime                     [MSVFW.16]
     569  return TRUE;
     570}
     571
     572
     573/****************************************************************************
     574 *    DrawDibTime     [MSVFW.16]
    565575 */
    566576BOOL VFWAPI DrawDibTime(HANDLE /*HDRAWDIB*/ hdd, DWORD lpddtime)
    … …  
    569579    dprintf(("MSVFW32: DrawDibTime not implemented\n"));
    570580#endif
    571         return TRUE;
    572 }
    573 
    574 
    575 /****************************************************************************
    576  *              GetOpenFileNamePreview          [MSVFW.17]
     581  return TRUE;
     582}
     583
     584
     585/****************************************************************************
     586 *    GetOpenFileNamePreview    [MSVFW.17]
    577587 */
    578588
    … …  
    581591
    582592/****************************************************************************
    583  *              GetOpenFileNamePreviewA         [MSVFW.18]
     593 *    GetOpenFileNamePreviewA   [MSVFW.18]
    584594 */
    585595BOOL VFWAPI GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn)
    … …  
    588598    dprintf(("MSVFW32: GetOpenFileNamePreviewA not implemented\n"));
    589599#endif
    590         return TRUE;
    591 }
    592 
    593 
    594 /****************************************************************************
    595  *              GetOpenFileNamePreviewW         [MSVFW.19]
     600  return TRUE;
     601}
     602
     603
     604/****************************************************************************
     605 *    GetOpenFileNamePreviewW   [MSVFW.19]
    596606 */
    597607BOOL VFWAPI GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn)
    … …  
    600610    dprintf(("MSVFW32: GetOpenFileNamePreviewW not implemented\n"));
    601611#endif
    602         return TRUE;
    603 }
    604 
    605 
    606 /****************************************************************************
    607  *              GetSaveFileNamePreviewA         [MSVFW.20]
     612  return TRUE;
     613}
     614
     615
     616/****************************************************************************
     617 *    GetSaveFileNamePreviewA   [MSVFW.20]
    608618 */
    609619BOOL VFWAPI GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn)
    … …  
    612622    dprintf(("MSVFW32: GetSaveFileNamePreviewA not implemented\n"));
    613623#endif
    614         return TRUE;
    615 }
    616 
    617 
    618 /****************************************************************************
    619  *              GetSaveFileNamePreviewW         [MSVFW.21]
     624  return TRUE;
     625}
     626
     627
     628/****************************************************************************
     629 *    GetSaveFileNamePreviewW   [MSVFW.21]
    620630 */
    621631BOOL VFWAPI GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn)
    … …  
    624634    dprintf(("MSVFW32: GetSaveFileNamePreviewW not implemented\n"));
    625635#endif
    626         return TRUE;
    627 }
    628 
    629 
    630 /****************************************************************************
    631  *              ICCompressorChoose              [MSVFW.24]
     636  return TRUE;
     637}
     638
     639
     640/****************************************************************************
     641 *    ICCompressorChoose    [MSVFW.24]
    632642 */
    633643BOOL VFWAPI ICCompressorChoose(
    … …  
    642652    dprintf(("MSVFW32: ICCompressorChoose not implemented\n"));
    643653#endif
    644         return TRUE;
    645 }
    646 
    647 
    648 /****************************************************************************
    649  *              ICCompressorFree                [MSVFW.25]
     654  return TRUE;
     655}
     656
     657
     658/****************************************************************************
     659 *    ICCompressorFree    [MSVFW.25]
    650660 */
    651661void VFWAPI ICCompressorFree(PCOMPVARS pc)
    … …  
    654664    dprintf(("MSVFW32: ICCompressorFree not implemented\n"));
    655665#endif
    656         return;
    657 }
    658 
    659 
    660 /****************************************************************************
    661  *              ICImageCompress                 [MSVFW.31]
     666  return;
     667}
     668
     669
     670/****************************************************************************
     671 *    ICImageCompress     [MSVFW.31]
    662672 */
    663673HANDLE VFWAPI ICImageCompress(
    664674        HIC                 hic,        // compressor to use
    665675        UINT                uiFlags,    // flags (none yet)
    666         LPBITMAPINFO        lpbiIn,     // format to compress from
     676        LPBITMAPINFO      lpbiIn,     // format to compress from
    667677        LPVOID              lpBits,     // data to compress
    668678        LPBITMAPINFO        lpbiOut,    // compress to this (NULL ==> default)
    … …  
    673683    dprintf(("MSVFW32: ICImageCompress not implemented\n"));
    674684#endif
    675         return 0;
    676 }
    677 
    678 
    679 /****************************************************************************
    680  *              ICImageDecompress               [MSVFW.32]
     685  return 0;
     686}
     687
     688
     689/****************************************************************************
     690 *    ICImageDecompress   [MSVFW.32]
    681691 */
    682692HANDLE VFWAPI ICImageDecompress(
    … …  
    690700    dprintf(("MSVFW32: ICImageDecompress not implemented\n"));
    691701#endif
    692         return 0;
    693 }
    694 
    695 
    696 /****************************************************************************
    697  *              ICInstall                       [MSVFW.34]
     702  return 0;
     703}
     704
     705
     706/****************************************************************************
     707 *    ICInstall     [MSVFW.34]
    698708 */
    699709BOOL    VFWAPI ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags)
    … …  
    702712    dprintf(("MSVFW32: ICInstall not implemented\n"));
    703713#endif
    704         return TRUE;
     714  return TRUE;
    705715}
    706716
    707717
    708718/**************************************************************************
    709  *              ICRemove                        [MSVFW.39]
     719 *    ICRemove      [MSVFW.39]
    710720 */
    711721BOOL    VFWAPI ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags)
    … …  
    714724    dprintf(("MSVFW32: ICRemove not implemented\n"));
    715725#endif
    716         return TRUE;
     726  return TRUE;
    717727}
    718728
    719729
    720730/**************************************************************************
    721  *              ICSeqCompressFrame              [MSVFW.41]
     731 *    ICSeqCompressFrame    [MSVFW.41]
    722732 */
    723733LPVOID VFWAPI ICSeqCompressFrame(
    … …  
    725735    UINT                    uiFlags,    // flags
    726736    LPVOID                  lpBits,     // input DIB bits
    727     BOOL                    *pfKey,     // did it end up being a key frame?
    728     LONG                    *plSize)    // size to compress to/of returned image
     737    BOOL        *pfKey, // did it end up being a key frame?
     738    LONG        *plSize)  // size to compress to/of returned image
    729739{
    730740#ifdef DEBUG
    731741    dprintf(("MSVFW32: ICSeqCompressFrame not implemented\n"));
    732742#endif
    733         return 0;
     743  return 0;
    734744}
    735745
    736746
    737747/**************************************************************************
    738  *              ICSeqCompressFrameEnd           [MSVFW.42]
     748 *    ICSeqCompressFrameEnd   [MSVFW.42]
    739749 */
    740750BOOL VFWAPI ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn)
    … …  
    743753    dprintf(("MSVFW32: ICSeqCompressFrameEnd not implemented\n"));
    744754#endif
    745         return TRUE;
     755  return TRUE;
    746756}
    747757
    748758
    749759/**************************************************************************
    750  *              ICSeqCompressFrameStart         [MSVFW.43]
     760 *    ICSeqCompressFrameStart   [MSVFW.43]
    751761 */
    752762void VFWAPI ICSeqCompressFrameEnd(PCOMPVARS pc)
    … …  
    755765    dprintf(("MSVFW32: ICSeqCompressFrameStart not implemented\n"));
    756766#endif
    757         return;
     767  return;
    758768}
    759769
    760770
    761771/**************************************************************************
    762  *              MCIWndRegisterClass             [MSVFW.47]
     772 *    MCIWndRegisterClass   [MSVFW.47]
    763773 */
    764774BOOL VFWAPIV MCIWndRegisterClass()
    … …  
    767777    dprintf(("MSVFW32: MCIWndRegisterClass not implemented\n"));
    768778#endif
    769         return TRUE;
    770 }
     779  return TRUE;
     780}
Note: See TracChangeset for help on using the changeset viewer.