Changeset 6648 for trunk/src/msvfw32


Ignore:
Timestamp:
Sep 5, 2001, 3:19:02 PM (24 years ago)
Author:
bird
Message:

Added $Id:$ keyword.

Location:
trunk/src/msvfw32
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msvfw32/drawdib.c

    r6386 r6648  
    1 /*
     1/* $Id: drawdib.c,v 1.2 2001-09-05 13:12:34 bird Exp $ */
     2/*
    23 * Copyright 2000 Bradley Baetz
    34 *
    … …  
    2122
    2223typedef struct {
    23         HDC hdc;
    24         INT dxDst;
    25         INT dyDst;
    26         LPBITMAPINFOHEADER lpbi;
    27         INT dxSrc;
    28         INT dySrc;
    29         HPALETTE hpal;                          /* Palette to use for the DIB */
    30         BOOL begun;                                     /* DrawDibBegin has been called */
    31         LPBITMAPINFOHEADER lpbiOut;     /* Output format */
    32         HIC hic;                                        /* HIC for decompression */
    33         HDC hMemDC;                                     /* DC for buffering */
    34         HBITMAP hOldDib;                        /* Original Dib */
    35         HBITMAP hDib;                           /* DibSection */
    36         LPVOID lpvbits;                         /* Buffer for holding decompressed dib */
     24    HDC hdc;
     25    INT dxDst;
     26    INT dyDst;
     27    LPBITMAPINFOHEADER lpbi;
     28    INT dxSrc;
     29    INT dySrc;
     30    HPALETTE hpal;              /* Palette to use for the DIB */
     31    BOOL begun;                 /* DrawDibBegin has been called */
     32    LPBITMAPINFOHEADER lpbiOut; /* Output format */
     33    HIC hic;                    /* HIC for decompression */
     34    HDC hMemDC;                 /* DC for buffering */
     35    HBITMAP hOldDib;            /* Original Dib */
     36    HBITMAP hDib;               /* DibSection */
     37    LPVOID lpvbits;             /* Buffer for holding decompressed dib */
    3738} WINE_HDD;
    3839
    … …  
    5859
    5960/***********************************************************************
    60  *              DrawDibOpen             [MSVFW32.@]
     61 *      DrawDibOpen     [MSVFW32.@]
    6162 */
    6263HDRAWDIB VFWAPI DrawDibOpen(void) {
    63         HDRAWDIB hdd;
    64 
    65         TRACE("(void)\n");
    66         hdd = GlobalAlloc16(GHND,sizeof(WINE_HDD));
    67         TRACE("=> %d\n",hdd);
    68         return hdd;
    69 }
    70 
    71 /***********************************************************************
    72  *              DrawDibOpen             [MSVIDEO.102]
     64    HDRAWDIB hdd;
     65
     66    TRACE("(void)\n");
     67    hdd = GlobalAlloc16(GHND,sizeof(WINE_HDD));
     68    TRACE("=> %d\n",hdd);
     69    return hdd;
     70}
     71
     72/***********************************************************************
     73 *      DrawDibOpen     [MSVIDEO.102]
    7374 */
    7475HDRAWDIB16 VFWAPI DrawDibOpen16(void) {
    75         return (HDRAWDIB16)DrawDibOpen();
    76 }
    77 
    78 /***********************************************************************
    79  *              DrawDibClose            [MSVFW32.@]
     76    return (HDRAWDIB16)DrawDibOpen();
     77}
     78
     79/***********************************************************************
     80 *      DrawDibClose        [MSVFW32.@]
    8081 */
    8182BOOL VFWAPI DrawDibClose(HDRAWDIB hdd) {
    82         WINE_HDD *whdd = GlobalLock16(hdd);
    83 
    84         TRACE("(0x%08lx)\n",(DWORD)hdd);
    85 
    86         if (!whdd)
    87                 return FALSE;
    88 
    89         if (whdd->begun)
    90                 DrawDibEnd(hdd);
    91 
    92         GlobalUnlock16(hdd);
    93         GlobalFree16(hdd);
    94         return TRUE;
    95 }
    96 
    97 /***********************************************************************
    98  *              DrawDibClose            [MSVIDEO.103]
     83    WINE_HDD *whdd = GlobalLock16(hdd);
     84
     85    TRACE("(0x%08lx)\n",(DWORD)hdd);
     86
     87    if (!whdd)
     88        return FALSE;
     89
     90    if (whdd->begun)
     91        DrawDibEnd(hdd);
     92
     93    GlobalUnlock16(hdd);
     94    GlobalFree16(hdd);
     95    return TRUE;
     96}
     97
     98/***********************************************************************
     99 *      DrawDibClose        [MSVIDEO.103]
    99100 */
    100101BOOL16 VFWAPI DrawDibClose16(HDRAWDIB16 hdd) {
    101         return DrawDibClose(hdd);
    102 }
    103 
    104 /***********************************************************************
    105  *              DrawDibEnd              [MSVFW32.@]
     102    return DrawDibClose(hdd);
     103}
     104
     105/***********************************************************************
     106 *      DrawDibEnd      [MSVFW32.@]
    106107 */
    107108BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd) {
    108         BOOL ret = TRUE;
    109         WINE_HDD *whdd = GlobalLock16(hdd);
    110        
    111         TRACE("(0x%08lx)\n",(DWORD)hdd);
    112 
    113         whdd->hpal = 0; /* Do not free this */
    114         whdd->hdc = 0;
    115         if (whdd->lpbi) {
    116                 HeapFree(GetProcessHeap(),0,whdd->lpbi);
    117                 whdd->lpbi = NULL;
    118         }
    119         if (whdd->lpbiOut) {
    120                 HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
    121                 whdd->lpbiOut = NULL;
    122         }
    123 
    124         whdd->begun = FALSE;
    125 
    126         /*if (whdd->lpvbits)
    127           HeapFree(GetProcessHeap(),0,whdd->lpvbuf);*/
    128 
    129         if (whdd->hMemDC) {
    130                 SelectObject(whdd->hMemDC,whdd->hOldDib);
    131                 DeleteDC(whdd->hMemDC);
    132         }
    133 
    134         if (whdd->hDib)
    135                 DeleteObject(whdd->hDib);
    136        
    137         if (whdd->hic) {
    138                 ICDecompressEnd(whdd->hic);
    139                 ICClose(whdd->hic);
    140         }
    141 
    142         whdd->lpvbits = NULL;
    143 
    144         GlobalUnlock16(hdd);
    145         return ret;
    146 }
    147 
    148 /***********************************************************************
    149  *              DrawDibEnd              [MSVIDEO.105]
     109    BOOL ret = TRUE;
     110    WINE_HDD *whdd = GlobalLock16(hdd);
     111
     112    TRACE("(0x%08lx)\n",(DWORD)hdd);
     113
     114    whdd->hpal = 0; /* Do not free this */
     115    whdd->hdc = 0;
     116    if (whdd->lpbi) {
     117        HeapFree(GetProcessHeap(),0,whdd->lpbi);
     118        whdd->lpbi = NULL;
     119    }
     120    if (whdd->lpbiOut) {
     121        HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
     122        whdd->lpbiOut = NULL;
     123    }
     124
     125    whdd->begun = FALSE;
     126
     127    /*if (whdd->lpvbits)
     128      HeapFree(GetProcessHeap(),0,whdd->lpvbuf);*/
     129
     130    if (whdd->hMemDC) {
     131        SelectObject(whdd->hMemDC,whdd->hOldDib);
     132        DeleteDC(whdd->hMemDC);
     133    }
     134
     135    if (whdd->hDib)
     136        DeleteObject(whdd->hDib);
     137
     138    if (whdd->hic) {
     139        ICDecompressEnd(whdd->hic);
     140        ICClose(whdd->hic);
     141    }
     142
     143    whdd->lpvbits = NULL;
     144
     145    GlobalUnlock16(hdd);
     146    return ret;
     147}
     148
     149/***********************************************************************
     150 *      DrawDibEnd      [MSVIDEO.105]
    150151 */
    151152BOOL16 VFWAPI DrawDibEnd16(HDRAWDIB16 hdd) {
    152         return DrawDibEnd(hdd);
     153    return DrawDibEnd(hdd);
    153154}
    154155
    … …  
    157158 */
    158159BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd,
    159                                                 HDC      hdc,
    160                                                 INT      dxDst,
    161                                                 INT      dyDst,
    162                                                 LPBITMAPINFOHEADER lpbi,
    163                                                 INT      dxSrc,
    164                                                 INT      dySrc,
    165                                                 UINT     wFlags) {
    166         BOOL ret = TRUE;
    167         WINE_HDD *whdd;
    168 
    169         TRACE("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx)\n",
    170                 hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
    171         );
    172         TRACE("lpbi: %ld,%ld/%ld,%d,%d,%ld,%ld,%ld,%ld,%ld,%ld\n",
    173                   lpbi->biSize, lpbi->biWidth, lpbi->biHeight, lpbi->biPlanes,
    174                   lpbi->biBitCount, lpbi->biCompression, lpbi->biSizeImage,
    175                   lpbi->biXPelsPerMeter, lpbi->biYPelsPerMeter, lpbi->biClrUsed,
    176                   lpbi->biClrImportant);
    177 
    178         if (wFlags & ~(DDF_BUFFER))
    179                 FIXME("wFlags == 0x%08x not handled\n", wFlags & ~(DDF_BUFFER));
    180 
    181         whdd = (WINE_HDD*)GlobalLock16(hdd);
    182         if (!whdd) return FALSE;
    183 
    184         if (whdd->begun)
    185                 DrawDibEnd(hdd);
    186 
    187         if (lpbi->biCompression) {
    188                 DWORD size = 0;
    189 
    190                 whdd->hic = ICOpen(ICTYPE_VIDEO,lpbi->biCompression,ICMODE_DECOMPRESS);
    191                 if (!whdd->hic) {
    192                         WARN("Could not open IC. biCompression == 0x%08lx\n",lpbi->biCompression);
    193                         ret = FALSE;
    194                 }
    195 
    196                 if (ret) {
    197                         size = ICDecompressGetFormat(whdd->hic,lpbi,NULL);
    198                         if (size == ICERR_UNSUPPORTED) {
    199                                 WARN("Codec doesn't support GetFormat, giving up.\n");
    200                                 ret = FALSE;
    201                         }
    202                 }
    203 
    204                 if (ret) {
    205                         whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,size);
    206 
    207                         if (ICDecompressGetFormat(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
    208                                 ret = FALSE;
    209                 }
    210 
    211                 if (ret) {
    212                         /* FIXME: Use Ex functions if available? */
    213                         if (ICDecompressBegin(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
    214                                 ret = FALSE;
    215 
    216                         TRACE("biSizeImage == %ld\n",whdd->lpbiOut->biSizeImage);
    217                         TRACE("biCompression == %ld\n",whdd->lpbiOut->biCompression);
    218                         TRACE("biBitCount == %d\n",whdd->lpbiOut->biBitCount);
    219                 }
    220         } else {
    221                 DWORD dwSize;
    222                 /* No compression */
    223                 TRACE("Not compressed!\n");
    224                 dwSize = lpbi->biSize + lpbi->biClrUsed*sizeof(RGBQUAD);
    225                 whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,dwSize);
    226                 memcpy(whdd->lpbiOut,lpbi,dwSize);
    227         }
    228 
    229         if (ret) {
    230                 /*whdd->lpvbuf = HeapAlloc(GetProcessHeap(),0,whdd->lpbiOut->biSizeImage);*/
    231                
    232                 whdd->hMemDC = CreateCompatibleDC(hdc);
    233                 TRACE("Creating: %ld,%p\n",whdd->lpbiOut->biSize,whdd->lpvbits);
    234                 whdd->hDib = CreateDIBSection(whdd->hMemDC,(BITMAPINFO *)whdd->lpbiOut,DIB_RGB_COLORS,&(whdd->lpvbits),0,0);
    235                 if (!whdd->hDib) {
    236                         TRACE("Error: %ld\n",GetLastError());
    237                 }
    238                 TRACE("Created: %d,%p\n",whdd->hDib,whdd->lpvbits);
    239                 whdd->hOldDib = SelectObject(whdd->hMemDC,whdd->hDib);
    240         }
    241 
    242         if (ret) {
    243                 whdd->hdc = hdc;
    244                 whdd->dxDst = dxDst;
    245                 whdd->dyDst = dyDst;
    246                 whdd->lpbi = HeapAlloc(GetProcessHeap(),0,lpbi->biSize);
    247                 memcpy(whdd->lpbi,lpbi,lpbi->biSize);
    248                 whdd->dxSrc = dxSrc;
    249                 whdd->dySrc = dySrc;
    250                 whdd->begun = TRUE;
    251                 whdd->hpal = 0;
    252         } else {
    253                 if (whdd->hic)
    254                         ICClose(whdd->hic);
    255                 if (whdd->lpbiOut) {
    256                         HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
    257                         whdd->lpbiOut = NULL;
    258                 }
    259         }
    260 
    261         GlobalUnlock16(hdd);
    262 
    263         return ret;
     160                        HDC      hdc,
     161                        INT      dxDst,
     162                        INT      dyDst,
     163                        LPBITMAPINFOHEADER lpbi,
     164                        INT      dxSrc,
     165                        INT      dySrc,
     166                        UINT     wFlags) {
     167    BOOL ret = TRUE;
     168    WINE_HDD *whdd;
     169
     170    TRACE("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx)\n",
     171        hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
     172    );
     173    TRACE("lpbi: %ld,%ld/%ld,%d,%d,%ld,%ld,%ld,%ld,%ld,%ld\n",
     174          lpbi->biSize, lpbi->biWidth, lpbi->biHeight, lpbi->biPlanes,
     175          lpbi->biBitCount, lpbi->biCompression, lpbi->biSizeImage,
     176          lpbi->biXPelsPerMeter, lpbi->biYPelsPerMeter, lpbi->biClrUsed,
     177          lpbi->biClrImportant);
     178
     179    if (wFlags & ~(DDF_BUFFER))
     180        FIXME("wFlags == 0x%08x not handled\n", wFlags & ~(DDF_BUFFER));
     181
     182    whdd = (WINE_HDD*)GlobalLock16(hdd);
     183    if (!whdd) return FALSE;
     184
     185    if (whdd->begun)
     186        DrawDibEnd(hdd);
     187
     188    if (lpbi->biCompression) {
     189        DWORD size = 0;
     190
     191        whdd->hic = ICOpen(ICTYPE_VIDEO,lpbi->biCompression,ICMODE_DECOMPRESS);
     192        if (!whdd->hic) {
     193            WARN("Could not open IC. biCompression == 0x%08lx\n",lpbi->biCompression);
     194            ret = FALSE;
     195        }
     196
     197        if (ret) {
     198            size = ICDecompressGetFormat(whdd->hic,lpbi,NULL);
     199            if (size == ICERR_UNSUPPORTED) {
     200                WARN("Codec doesn't support GetFormat, giving up.\n");
     201                ret = FALSE;
     202            }
     203        }
     204
     205        if (ret) {
     206            whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,size);
     207
     208            if (ICDecompressGetFormat(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
     209                ret = FALSE;
     210        }
     211
     212        if (ret) {
     213            /* FIXME: Use Ex functions if available? */
     214            if (ICDecompressBegin(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
     215                ret = FALSE;
     216
     217            TRACE("biSizeImage == %ld\n",whdd->lpbiOut->biSizeImage);
     218            TRACE("biCompression == %ld\n",whdd->lpbiOut->biCompression);
     219            TRACE("biBitCount == %d\n",whdd->lpbiOut->biBitCount);
     220        }
     221    } else {
     222        DWORD dwSize;
     223        /* No compression */
     224        TRACE("Not compressed!\n");
     225        dwSize = lpbi->biSize + lpbi->biClrUsed*sizeof(RGBQUAD);
     226        whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,dwSize);
     227        memcpy(whdd->lpbiOut,lpbi,dwSize);
     228    }
     229
     230    if (ret) {
     231        /*whdd->lpvbuf = HeapAlloc(GetProcessHeap(),0,whdd->lpbiOut->biSizeImage);*/
     232
     233        whdd->hMemDC = CreateCompatibleDC(hdc);
     234        TRACE("Creating: %ld,%p\n",whdd->lpbiOut->biSize,whdd->lpvbits);
     235        whdd->hDib = CreateDIBSection(whdd->hMemDC,(BITMAPINFO *)whdd->lpbiOut,DIB_RGB_COLORS,&(whdd->lpvbits),0,0);
     236        if (!whdd->hDib) {
     237            TRACE("Error: %ld\n",GetLastError());
     238        }
     239        TRACE("Created: %d,%p\n",whdd->hDib,whdd->lpvbits);
     240        whdd->hOldDib = SelectObject(whdd->hMemDC,whdd->hDib);
     241    }
     242
     243    if (ret) {
     244        whdd->hdc = hdc;
     245        whdd->dxDst = dxDst;
     246        whdd->dyDst = dyDst;
     247        whdd->lpbi = HeapAlloc(GetProcessHeap(),0,lpbi->biSize);
     248        memcpy(whdd->lpbi,lpbi,lpbi->biSize);
     249        whdd->dxSrc = dxSrc;
     250        whdd->dySrc = dySrc;
     251        whdd->begun = TRUE;
     252        whdd->hpal = 0;
     253    } else {
     254        if (whdd->hic)
     255            ICClose(whdd->hic);
     256        if (whdd->lpbiOut) {
     257            HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
     258            whdd->lpbiOut = NULL;
     259        }
     260    }
     261
     262    GlobalUnlock16(hdd);
     263
     264    return ret;
    264265}
    265266
    266267/************************************************************************
    267  *              DrawDibBegin            [MSVIDEO.104]
     268 *      DrawDibBegin        [MSVIDEO.104]
    268269 */
    269270BOOL16 VFWAPI DrawDibBegin16(HDRAWDIB16 hdd,
    270                                                    HDC16      hdc,
    271                                                    INT16      dxDst,
    272                                                    INT16      dyDst,
    273                                                    LPBITMAPINFOHEADER lpbi,
    274                                                    INT16      dxSrc,
    275                                                    INT16      dySrc,
    276                                                    UINT16     wFlags) {
    277         return DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,wFlags);
     271                           HDC16      hdc,
     272                           INT16      dxDst,
     273                           INT16      dyDst,
     274                           LPBITMAPINFOHEADER lpbi,
     275                           INT16      dxSrc,
     276                           INT16      dySrc,
     277                           UINT16     wFlags) {
     278    return DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,wFlags);
    278279}
    279280
    280281/**********************************************************************
    281  *              DrawDibDraw             [MSVFW32.@]
     282 *      DrawDibDraw     [MSVFW32.@]
    282283 */
    283284BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc,
    284         INT xDst, INT yDst, INT dxDst, INT dyDst,
    285         LPBITMAPINFOHEADER lpbi,
    286         LPVOID lpBits,
    287         INT xSrc, INT ySrc, INT dxSrc, INT dySrc,
    288         UINT wFlags
     285    INT xDst, INT yDst, INT dxDst, INT dyDst,
     286    LPBITMAPINFOHEADER lpbi,
     287    LPVOID lpBits,
     288    INT xSrc, INT ySrc, INT dxSrc, INT dySrc,
     289    UINT wFlags
    289290) {
    290         WINE_HDD *whdd;
    291         BOOL ret = TRUE;
    292 
    293         TRACE("(%d,0x%lx,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08lx)\n",
    294                   hdd,(DWORD)hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,(DWORD)wFlags
    295         );
    296 
    297         if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME |
    298                                    DDF_UPDATE | DDF_DONTDRAW))
    299                 FIXME("wFlags == 0x%08lx not handled\n",(DWORD)wFlags);
    300 
    301         if (!lpBits) {
    302                 /* Undocumented? */
    303                 lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(lpbi->biClrUsed*sizeof(RGBQUAD));
    304         }
    305 
    306         whdd = GlobalLock16(hdd);
     291    WINE_HDD *whdd;
     292    BOOL ret = TRUE;
     293
     294    TRACE("(%d,0x%lx,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08lx)\n",
     295          hdd,(DWORD)hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,(DWORD)wFlags
     296    );
     297
     298    if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME |
     299                   DDF_UPDATE | DDF_DONTDRAW))
     300        FIXME("wFlags == 0x%08lx not handled\n",(DWORD)wFlags);
     301
     302    if (!lpBits) {
     303        /* Undocumented? */
     304        lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(lpbi->biClrUsed*sizeof(RGBQUAD));
     305    }
     306
     307    whdd = GlobalLock16(hdd);
    307308
    308309#define CHANGED(x) (whdd->x != x)
    309310
    310         if ((!whdd->begun) || (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc)) || (!(wFlags & DDF_SAME_DRAW) &&
    311                 (CHANGED(lpbi) || CHANGED(dxSrc) || CHANGED(dySrc) || CHANGED(dxDst) || CHANGED(dyDst)))) {
    312                 TRACE("Something changed!\n");
    313                 ret = DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,0);
    314         }
     311    if ((!whdd->begun) || (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc)) || (!(wFlags & DDF_SAME_DRAW) &&
     312        (CHANGED(lpbi) || CHANGED(dxSrc) || CHANGED(dySrc) || CHANGED(dxDst) || CHANGED(dyDst)))) {
     313        TRACE("Something changed!\n");
     314        ret = DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,0);
     315    }
    315316
    316317#undef CHANGED
    317318
    318319        if ((dxDst == -1) && (dyDst == -1)) {
    319                 dxDst = dxSrc;
    320                 dyDst = dySrc;
    321         }
    322 
    323         if (!(wFlags & DDF_UPDATE)) {
    324             /* biSizeImage may be set to 0 for BI_RGB (uncompressed) bitmaps */
    325             if ((lpbi->biCompression == BI_RGB) && (lpbi->biSizeImage == 0))
    326                     lpbi->biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
    327 
    328                 if (lpbi->biCompression) {
    329                     DWORD flags = 0;
    330                
    331                         TRACE("Compression == 0x%08lx\n",lpbi->biCompression);
    332                
    333                         if (wFlags & DDF_NOTKEYFRAME)
    334                             flags |= ICDECOMPRESS_NOTKEYFRAME;
    335                
    336                         ICDecompress(whdd->hic,flags,lpbi,lpBits,whdd->lpbiOut,whdd->lpvbits);
    337                 } else {
    338                     memcpy(whdd->lpvbits,lpBits,lpbi->biSizeImage);
    339                 }       
    340         }
    341         if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
    342             SelectPalette(hdc,whdd->hpal,FALSE);
    343 
    344         if (!(StretchBlt(whdd->hdc,xDst,yDst,dxDst,dyDst,whdd->hMemDC,xSrc,ySrc,dxSrc,dySrc,SRCCOPY)))
    345             ret = FALSE;
    346 
    347         GlobalUnlock16(hdd);
    348         return ret;
     320        dxDst = dxSrc;
     321        dyDst = dySrc;
     322    }
     323
     324    if (!(wFlags & DDF_UPDATE)) {
     325        /* biSizeImage may be set to 0 for BI_RGB (uncompressed) bitmaps */
     326        if ((lpbi->biCompression == BI_RGB) && (lpbi->biSizeImage == 0))
     327            lpbi->biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
     328
     329        if (lpbi->biCompression) {
     330            DWORD flags = 0;
     331
     332            TRACE("Compression == 0x%08lx\n",lpbi->biCompression);
     333
     334            if (wFlags & DDF_NOTKEYFRAME)
     335                flags |= ICDECOMPRESS_NOTKEYFRAME;
     336
     337            ICDecompress(whdd->hic,flags,lpbi,lpBits,whdd->lpbiOut,whdd->lpvbits);
     338        } else {
     339            memcpy(whdd->lpvbits,lpBits,lpbi->biSizeImage);
     340        }
     341    }
     342    if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
     343        SelectPalette(hdc,whdd->hpal,FALSE);
     344
     345    if (!(StretchBlt(whdd->hdc,xDst,yDst,dxDst,dyDst,whdd->hMemDC,xSrc,ySrc,dxSrc,dySrc,SRCCOPY)))
     346        ret = FALSE;
     347
     348    GlobalUnlock16(hdd);
     349    return ret;
    349350}
    350351
    351352/**********************************************************************
    352  *              DrawDibDraw             [MSVIDEO.106]
    353  */
    354 BOOL16 VFWAPI DrawDibDraw16(HDRAWDIB16 hdd,             
    355                                                   HDC16 hdc,
    356                                                   INT16 xDst,
    357                                                   INT16 yDst,
    358                                                   INT16 dxDst,
    359                                                   INT16 dyDst,
    360                                                   LPBITMAPINFOHEADER lpbi,
    361                                                   LPVOID lpBits,
    362                                                   INT16 xSrc,
    363                                                   INT16 ySrc,
    364                                                   INT16 dxSrc,
    365                                                   INT16 dySrc,
    366                                                   UINT16 wFlags) {
    367         return DrawDibDraw(hdd,hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,wFlags);
     353 *      DrawDibDraw     [MSVIDEO.106]
     354 */
     355BOOL16 VFWAPI DrawDibDraw16(HDRAWDIB16 hdd,
     356                          HDC16 hdc,
     357                          INT16 xDst,
     358                          INT16 yDst,
     359                          INT16 dxDst,
     360                          INT16 dyDst,
     361                          LPBITMAPINFOHEADER lpbi,
     362                          LPVOID lpBits,
     363                          INT16 xSrc,
     364                          INT16 ySrc,
     365                          INT16 dxSrc,
     366                          INT16 dySrc,
     367                          UINT16 wFlags) {
     368    return DrawDibDraw(hdd,hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,wFlags);
    368369}
    369370
    370371/*************************************************************************
    371  *              DrawDibStart            [MSVFW32.@]
     372 *      DrawDibStart        [MSVFW32.@]
    372373 */
    373374BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate) {
    374         FIXME("(0x%08lx,%ld), stub\n",(DWORD)hdd,rate);
    375         return TRUE;
     375    FIXME("(0x%08lx,%ld), stub\n",(DWORD)hdd,rate);
     376    return TRUE;
    376377}
    377378
    378379/*************************************************************************
    379  *              DrawDibStart            [MSVIDEO.118]
     380 *      DrawDibStart        [MSVIDEO.118]
    380381 */
    381382BOOL16 VFWAPI DrawDibStart16(HDRAWDIB16 hdd, DWORD rate) {
    382         return DrawDibStart(hdd,rate);
     383    return DrawDibStart(hdd,rate);
    383384}
    384385
    385386/*************************************************************************
    386  *              DrawDibStop             [MSVFW32.@]
     387 *      DrawDibStop     [MSVFW32.@]
    387388 */
    388389BOOL VFWAPI DrawDibStop(HDRAWDIB hdd) {
    389         FIXME("(0x%08lx), stub\n",(DWORD)hdd);
    390         return TRUE;
     390    FIXME("(0x%08lx), stub\n",(DWORD)hdd);
     391    return TRUE;
    391392}
    392393
    393394/*************************************************************************
    394  *              DrawDibStop             [MSVIDEO.119]
     395 *      DrawDibStop     [MSVIDEO.119]
    395396 */
    396397BOOL16 DrawDibStop16(HDRAWDIB16 hdd) {
    397         return DrawDibStop(hdd);
     398    return DrawDibStop(hdd);
    398399}
    399400
    … …  
    402403 */
    403404BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal) {
    404         WINE_HDD *whdd;
    405 
    406         TRACE("(0x%08lx,0x%08lx)\n",(DWORD)hdd,(DWORD)hpal);
    407 
    408         whdd = GlobalLock16(hdd);
    409         whdd->hpal = hpal;
    410        
    411         if (whdd->begun) {
    412                 SelectPalette(whdd->hdc,hpal,0);
    413                 RealizePalette(whdd->hdc);
    414         }
    415         GlobalUnlock16(hdd);
    416         return TRUE;
     405    WINE_HDD *whdd;
     406
     407    TRACE("(0x%08lx,0x%08lx)\n",(DWORD)hdd,(DWORD)hpal);
     408
     409    whdd = GlobalLock16(hdd);
     410    whdd->hpal = hpal;
     411
     412    if (whdd->begun) {
     413        SelectPalette(whdd->hdc,hpal,0);
     414        RealizePalette(whdd->hdc);
     415    }
     416    GlobalUnlock16(hdd);
     417    return TRUE;
    417418}
    418419
    … …  
    421422 */
    422423BOOL16 VFWAPI DrawDibSetPalette16(HDRAWDIB16 hdd, HPALETTE16 hpal) {
    423         return DrawDibSetPalette(hdd,hpal);
     424    return DrawDibSetPalette(hdd,hpal);
    424425}
    425426
    … …  
    428429 */
    429430HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd) {
    430         WINE_HDD *whdd;
    431         HPALETTE ret;
    432 
    433         TRACE("(0x%08lx)\n",(DWORD)hdd);
    434 
    435         whdd = GlobalLock16(hdd);
    436         ret = whdd->hpal;
    437         GlobalUnlock16(hdd);
    438         return ret;
     431    WINE_HDD *whdd;
     432    HPALETTE ret;
     433
     434    TRACE("(0x%08lx)\n",(DWORD)hdd);
     435
     436    whdd = GlobalLock16(hdd);
     437    ret = whdd->hpal;
     438    GlobalUnlock16(hdd);
     439    return ret;
    439440}
    440441
    … …  
    443444 */
    444445HPALETTE16 VFWAPI DrawDibGetPalette16(HDRAWDIB16 hdd) {
    445         return (HPALETTE16)DrawDibGetPalette(hdd);
     446    return (HPALETTE16)DrawDibGetPalette(hdd);
    446447}
    447448
    … …  
    450451 */
    451452UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground) {
    452         WINE_HDD *whdd;
    453         HPALETTE oldPal;
    454         UINT ret = 0;
    455 
    456         FIXME("(%d,0x%08lx,%d), stub\n",hdd,(DWORD)hdc,fBackground);
    457        
    458         whdd = GlobalLock16(hdd);
    459 
    460         if (!whdd || !(whdd->begun)) {
    461                 ret = 0;
    462                 goto out;
    463         }
    464        
    465         if (!whdd->hpal)
    466                 whdd->hpal = CreateHalftonePalette(hdc);
    467 
    468         oldPal = SelectPalette(hdc,whdd->hpal,fBackground);
    469         ret = RealizePalette(hdc);
    470        
     453    WINE_HDD *whdd;
     454    HPALETTE oldPal;
     455    UINT ret = 0;
     456
     457    FIXME("(%d,0x%08lx,%d), stub\n",hdd,(DWORD)hdc,fBackground);
     458
     459    whdd = GlobalLock16(hdd);
     460
     461    if (!whdd || !(whdd->begun)) {
     462        ret = 0;
     463        goto out;
     464    }
     465
     466    if (!whdd->hpal)
     467        whdd->hpal = CreateHalftonePalette(hdc);
     468
     469    oldPal = SelectPalette(hdc,whdd->hpal,fBackground);
     470    ret = RealizePalette(hdc);
     471
    471472 out:
    472         GlobalUnlock16(hdd);
    473 
    474         TRACE("=> %u\n",ret);
    475         return ret;
     473    GlobalUnlock16(hdd);
     474
     475    TRACE("=> %u\n",ret);
     476    return ret;
    476477}
    477478
    … …  
    480481 */
    481482UINT16 VFWAPI DrawDibRealize16(HDRAWDIB16 hdd, HDC16 hdc, BOOL16 fBackground) {
    482         return (UINT16)DrawDibRealize(hdd,hdc,fBackground);
    483 }
     483    return (UINT16)DrawDibRealize(hdd,hdc,fBackground);
     484}

  • trunk/src/msvfw32/msvideo_main.c

    r6386 r6648  
     1/* $Id: msvideo_main.c,v 1.2 2001-09-05 13:12:35 bird Exp $ */
    12/*
    23 * Copyright 1998 Marcus Meissner
    3  * Copyright 2000 Bradley Baetz 
     4 * Copyright 2000 Bradley Baetz
    45 *
    56 * FIXME: This all assumes 32 bit codecs
    6  *              Win95 appears to prefer 32 bit codecs, even from 16 bit code.
    7  *              There is the ICOpenFunction16 to worry about still, though.
     7 *      Win95 appears to prefer 32 bit codecs, even from 16 bit code.
     8 *      There is the ICOpenFunction16 to worry about still, though.
    89 */
    910
    … …  
    3435#define GlobalFree16 GlobalFree
    3536#undef SEGPTR_NEW
    36 #define SEGPTR_NEW(a)   malloc(sizeof(a))
     37#define SEGPTR_NEW(a)   malloc(sizeof(a))
    3738#define SEGPTR_FREE(a)  free(a)
    3839#define SEGPTR_GET(a)   a
    … …  
    5960
    6061/***********************************************************************
    61  *              VideoForWindowsVersion          [MSVFW32.2]
    62  *              VideoForWindowsVersion          [MSVIDEO.2]
     62 *      VideoForWindowsVersion      [MSVFW32.2]
     63 *      VideoForWindowsVersion      [MSVIDEO.2]
    6364 * Returns the version in major.minor form.
    6465 * In Windows95 this returns 0x040003b6 (4.950)
    6566 */
    6667DWORD WINAPI VideoForWindowsVersion(void) {
    67         return 0x040003B6; /* 4.950 */
    68 }
    69 
    70 /***********************************************************************
    71  *              VideoCapDriverDescAndVer        [MSVIDEO.22]
     68    return 0x040003B6; /* 4.950 */
     69}
     70
     71/***********************************************************************
     72 *      VideoCapDriverDescAndVer    [MSVIDEO.22]
    7273 */
    7374DWORD WINAPI VideoCapDriverDescAndVer(
    74         WORD nr,LPSTR buf1,WORD buf1len,LPSTR buf2,WORD buf2len
     75    WORD nr,LPSTR buf1,WORD buf1len,LPSTR buf2,WORD buf2len
    7576) {
    76         DWORD   verhandle;
    77         WORD    xnr = nr;
    78         DWORD   infosize;
    79         UINT    subblocklen;
    80         char    *s,buf[2000],fn[260];
    81         LPBYTE  infobuf;
    82         LPVOID  subblock;
    83 
    84         TRACE("(%d,%p,%d,%p,%d)\n",nr,buf1,buf1len,buf2,buf2len);
    85         if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,sizeof(buf),"system.ini")) {
    86                 s = buf;
    87                 while (*s) {
    88                         if (!strncasecmp(s,"vid",3)) {
    89                             if (!xnr)
    90                                 break;
    91                             xnr--;
    92                         }
    93                         s=s+strlen(s)+1; /* either next char or \0 */
    94                 }
    95         } else
    96             return 20; /* hmm, out of entries even if we don't have any */
    97         if (xnr) {
    98                 FIXME("No more VID* entries found\n");
    99                 return 20;
    100         }
    101         GetPrivateProfileStringA("drivers32",s,NULL,fn,sizeof(fn),"system.ini");
    102         infosize = GetFileVersionInfoSizeA(fn,&verhandle);
    103         if (!infosize) {
    104             TRACE("%s has no fileversioninfo.\n",fn);
    105             return 18;
    106         }
    107         infobuf = HeapAlloc(GetProcessHeap(),0,infosize);
    108         if (GetFileVersionInfoA(fn,verhandle,infosize,infobuf)) {
    109             char        vbuf[200];
    110             /* Yes, two space behind : */
    111             /* FIXME: test for buflen */
    112             sprintf(vbuf,"Version:  %d.%d.%d.%d\n",
    113                     ((WORD*)infobuf)[0x0f],
    114                     ((WORD*)infobuf)[0x0e],
    115                     ((WORD*)infobuf)[0x11],
    116                     ((WORD*)infobuf)[0x10]
    117             );
    118             TRACE("version of %s is %s\n",fn,vbuf);
    119             strncpy(buf2,vbuf,buf2len);
    120         } else {
    121             TRACE("GetFileVersionInfoA failed for %s.\n",fn);
    122             strncpy(buf2,fn,buf2len); /* msvideo.dll appears to copy fn*/
    123         }
    124         /* FIXME: language problem? */
    125         if (VerQueryValueA(     infobuf,
    126                                 "\\StringFileInfo\\040904E4\\FileDescription",
    127                                 &subblock,
    128                                 &subblocklen
    129         )) {
    130             TRACE("VQA returned %s\n",(LPCSTR)subblock);
    131             strncpy(buf1,subblock,buf1len);
    132         } else {
    133             TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
    134             strncpy(buf1,fn,buf1len); /* msvideo.dll appears to copy fn*/
    135         }
    136         HeapFree(GetProcessHeap(),0,infobuf);
    137         return 0;
     77    DWORD   verhandle;
     78    WORD    xnr = nr;
     79    DWORD   infosize;
     80    UINT    subblocklen;
     81    char    *s,buf[2000],fn[260];
     82    LPBYTE  infobuf;
     83    LPVOID  subblock;
     84
     85    TRACE("(%d,%p,%d,%p,%d)\n",nr,buf1,buf1len,buf2,buf2len);
     86    if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,sizeof(buf),"system.ini")) {
     87        s = buf;
     88        while (*s) {
     89                if (!strncasecmp(s,"vid",3)) {
     90                if (!xnr)
     91                break;
     92                xnr--;
     93            }
     94            s=s+strlen(s)+1; /* either next char or \0 */
     95        }
     96    } else
     97        return 20; /* hmm, out of entries even if we don't have any */
     98    if (xnr) {
     99        FIXME("No more VID* entries found\n");
     100        return 20;
     101    }
     102    GetPrivateProfileStringA("drivers32",s,NULL,fn,sizeof(fn),"system.ini");
     103    infosize = GetFileVersionInfoSizeA(fn,&verhandle);
     104    if (!infosize) {
     105        TRACE("%s has no fileversioninfo.\n",fn);
     106        return 18;
     107    }
     108    infobuf = HeapAlloc(GetProcessHeap(),0,infosize);
     109    if (GetFileVersionInfoA(fn,verhandle,infosize,infobuf)) {
     110        char    vbuf[200];
     111        /* Yes, two space behind : */
     112        /* FIXME: test for buflen */
     113        sprintf(vbuf,"Version:  %d.%d.%d.%d\n",
     114            ((WORD*)infobuf)[0x0f],
     115            ((WORD*)infobuf)[0x0e],
     116            ((WORD*)infobuf)[0x11],
     117            ((WORD*)infobuf)[0x10]
     118        );
     119        TRACE("version of %s is %s\n",fn,vbuf);
     120        strncpy(buf2,vbuf,buf2len);
     121    } else {
     122        TRACE("GetFileVersionInfoA failed for %s.\n",fn);
     123        strncpy(buf2,fn,buf2len); /* msvideo.dll appears to copy fn*/
     124    }
     125    /* FIXME: language problem? */
     126    if (VerQueryValueA( infobuf,
     127                "\\StringFileInfo\\040904E4\\FileDescription",
     128                &subblock,
     129                &subblocklen
     130    )) {
     131        TRACE("VQA returned %s\n",(LPCSTR)subblock);
     132        strncpy(buf1,subblock,buf1len);
     133    } else {
     134        TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
     135        strncpy(buf1,fn,buf1len); /* msvideo.dll appears to copy fn*/
     136    }
     137    HeapFree(GetProcessHeap(),0,infobuf);
     138    return 0;
    138139}
    139140
    … …  
    141142
    142143/***********************************************************************
    143  *              ICInfo                          [MSVFW32.@]
     144 *      ICInfo              [MSVFW32.@]
    144145 * Get information about an installable compressor. Return TRUE if there
    145146 * is one.
    146147 */
    147148BOOL VFWAPI ICInfo(
    148         DWORD fccType,          /* [in] type of compressor ('vidc') */
    149         DWORD fccHandler,       /* [in] <n>th compressor */
    150         ICINFO *lpicinfo)       /* [out] information about compressor */
     149    DWORD fccType,      /* [in] type of compressor ('vidc') */
     150    DWORD fccHandler,   /* [in] <n>th compressor */
     151    ICINFO *lpicinfo)   /* [out] information about compressor */
    151152{
    152         char    type[5],buf[2000];
    153 
    154         memcpy(type,&fccType,4);type[4]=0;
    155         TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
    156         /* does OpenDriver/CloseDriver */
    157         lpicinfo->dwSize = sizeof(ICINFO);
    158         lpicinfo->fccType = fccType;
    159         lpicinfo->dwFlags = 0;
    160         if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
    161                 char *s = buf;
    162                 while (*s) {
    163                         if (!strncasecmp(type,s,4)) {
    164                                 if(!fccHandler--) {
    165                                         lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
    166                                         return TRUE;
    167                                 }
    168                         }
    169                         s=s+strlen(s)+1; /* either next char or \0 */
    170                 }
    171         }
    172         return FALSE;
     153    char    type[5],buf[2000];
     154
     155    memcpy(type,&fccType,4);type[4]=0;
     156    TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
     157    /* does OpenDriver/CloseDriver */
     158    lpicinfo->dwSize = sizeof(ICINFO);
     159    lpicinfo->fccType = fccType;
     160    lpicinfo->dwFlags = 0;
     161    if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
     162        char *s = buf;
     163        while (*s) {
     164            if (!strncasecmp(type,s,4)) {
     165                if(!fccHandler--) {
     166                    lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
     167                    return TRUE;
     168                }
     169            }
     170            s=s+strlen(s)+1; /* either next char or \0 */
     171        }
     172    }
     173    return FALSE;
    173174}
    174175#ifndef __WIN32OS2__
    175176/***********************************************************************
    176  *              ICInfo                          [MSVIDEO.200]
     177 *      ICInfo              [MSVIDEO.200]
    177178 */
    178179BOOL16 VFWAPI ICInfo16(
    179         DWORD     fccType,    /* [in] */
    180         DWORD     fccHandler, /* [in] */
    181         ICINFO16 *lpicinfo)   /* [in/out] NOTE: SEGPTR */
     180    DWORD     fccType,    /* [in] */
     181    DWORD     fccHandler, /* [in] */
     182    ICINFO16 *lpicinfo)   /* [in/out] NOTE: SEGPTR */
    182183{
    183         BOOL16 ret;
    184         LPVOID lpv;
    185         DWORD lParam = (DWORD)lpicinfo;
    186         DWORD size = ((ICINFO*)(MapSL((SEGPTR)lpicinfo)))->dwSize;
    187 
    188         /* Use the mapping functions to map the ICINFO structure */
    189         lpv = MSVIDEO_MapMsg16To32(ICM_GETINFO,&lParam,&size);
    190 
    191         ret = ICInfo(fccType,fccHandler,(ICINFO*)lParam);
    192 
    193         MSVIDEO_UnmapMsg16To32(ICM_GETINFO,lpv,&lParam,&size);
    194        
    195         return ret;
    196 }
    197 #endif
    198 /***********************************************************************
    199  *              ICOpen                          [MSVFW32.@]
     184    BOOL16 ret;
     185    LPVOID lpv;
     186    DWORD lParam = (DWORD)lpicinfo;
     187    DWORD size = ((ICINFO*)(MapSL((SEGPTR)lpicinfo)))->dwSize;
     188
     189    /* Use the mapping functions to map the ICINFO structure */
     190    lpv = MSVIDEO_MapMsg16To32(ICM_GETINFO,&lParam,&size);
     191
     192    ret = ICInfo(fccType,fccHandler,(ICINFO*)lParam);
     193
     194    MSVIDEO_UnmapMsg16To32(ICM_GETINFO,lpv,&lParam,&size);
     195
     196    return ret;
     197}
     198#endif
     199/***********************************************************************
     200 *      ICOpen              [MSVFW32.@]
    200201 * Opens an installable compressor. Return special handle.
    201202 */
    202203HIC VFWAPI ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
    203         char            type[5],handler[5],codecname[20];
    204         ICOPEN          icopen;
    205         HDRVR           hdrv;
    206         HIC16           hic;
    207         WINE_HIC        *whic;
    208 
    209         memcpy(type,&fccType,4);type[4]=0;
    210         memcpy(handler,&fccHandler,4);handler[4]=0;
    211         TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
    212 
    213         sprintf(codecname,"%s.%s",type,handler);
    214 
    215         /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
    216         * same layout as ICOPEN
    217         */
    218         icopen.fccType          = fccType;
    219         icopen.fccHandler       = fccHandler;
    220         icopen.dwSize           = sizeof(ICOPEN);
    221         icopen.dwFlags          = wMode;
    222         /* FIXME: do we need to fill out the rest too? */
    223         hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
    224         if (!hdrv) {
    225             if (!strcasecmp(type,"vids")) {
    226                 sprintf(codecname,"vidc.%s",handler);
    227                 fccType = mmioFOURCC('v','i','d','c');
    228             }
    229             hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
    230             if (!hdrv)
    231                     return 0;
    232         }
    233         /* The handle should be a valid 16-bit handle as well */
    234         hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
    235         whic = (WINE_HIC*)GlobalLock16(hic);
    236         whic->hdrv      = hdrv;
    237         whic->driverproc= NULL;
     204    char        type[5],handler[5],codecname[20];
     205    ICOPEN      icopen;
     206    HDRVR       hdrv;
     207    HIC16       hic;
     208    WINE_HIC    *whic;
     209
     210    memcpy(type,&fccType,4);type[4]=0;
     211    memcpy(handler,&fccHandler,4);handler[4]=0;
     212    TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
     213
     214    sprintf(codecname,"%s.%s",type,handler);
     215
     216    /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
     217    * same layout as ICOPEN
     218    */
     219    icopen.fccType      = fccType;
     220    icopen.fccHandler   = fccHandler;
     221    icopen.dwSize       = sizeof(ICOPEN);
     222    icopen.dwFlags      = wMode;
     223    /* FIXME: do we need to fill out the rest too? */
     224    hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
     225    if (!hdrv) {
     226        if (!strcasecmp(type,"vids")) {
     227        sprintf(codecname,"vidc.%s",handler);
     228        fccType = mmioFOURCC('v','i','d','c');
     229        }
     230        hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
     231        if (!hdrv)
     232            return 0;
     233    }
     234    /* The handle should be a valid 16-bit handle as well */
     235    hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
     236    whic = (WINE_HIC*)GlobalLock16(hic);
     237    whic->hdrv  = hdrv;
     238    whic->driverproc= NULL;
    238239#ifdef __WIN32OS2__
    239         whic->privatevfw        = 0;
     240    whic->privatevfw    = 0;
    240241#else
    241         whic->private   = 0;
    242 #endif
    243         GlobalUnlock16(hic);
    244         TRACE("=> 0x%08lx\n",(DWORD)hic);
    245         return hic;
     242    whic->private   = 0;
     243#endif
     244    GlobalUnlock16(hic);
     245    TRACE("=> 0x%08lx\n",(DWORD)hic);
     246    return hic;
    246247}
    247248
    248249HIC MSVIDEO_OpenFunc(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler, BOOL bFrom32) {
    249         char    type[5],handler[5],codecname[20];
    250         HIC16   hic;
    251         ICOPEN*  icopen = SEGPTR_NEW(ICOPEN);
    252         WINE_HIC        *whic;
    253 
    254         memcpy(type,&fccType,4);type[4]=0;
    255         memcpy(handler,&fccHandler,4);handler[4]=0;
    256         TRACE("(%s,%s,%d,%p,%d)\n",type,handler,wMode,lpfnHandler,bFrom32?32:16);
    257        
    258         icopen->fccType         = fccType;
    259         icopen->fccHandler      = fccHandler;
    260         icopen->dwSize          = sizeof(ICOPEN);
    261         icopen->dwFlags         = wMode;
    262        
    263         sprintf(codecname,"%s.%s",type,handler);
    264 
    265         hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
    266         if (!hic)
    267                 return 0;
    268         whic = GlobalLock16(hic);
    269         whic->driverproc = lpfnHandler;
    270        
     250    char    type[5],handler[5],codecname[20];
     251    HIC16   hic;
     252    ICOPEN*  icopen = SEGPTR_NEW(ICOPEN);
     253    WINE_HIC    *whic;
     254
     255    memcpy(type,&fccType,4);type[4]=0;
     256    memcpy(handler,&fccHandler,4);handler[4]=0;
     257    TRACE("(%s,%s,%d,%p,%d)\n",type,handler,wMode,lpfnHandler,bFrom32?32:16);
     258
     259    icopen->fccType     = fccType;
     260    icopen->fccHandler  = fccHandler;
     261    icopen->dwSize      = sizeof(ICOPEN);
     262    icopen->dwFlags     = wMode;
     263
     264    sprintf(codecname,"%s.%s",type,handler);
     265
     266    hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
     267    if (!hic)
     268        return 0;
     269    whic = GlobalLock16(hic);
     270    whic->driverproc = lpfnHandler;
     271
    271272#ifdef __WIN32OS2__
    272         whic->privatevfw        = bFrom32;
     273    whic->privatevfw    = bFrom32;
    273274#else
    274         whic->private = bFrom32;
    275 #endif
    276        
    277         /* Now try opening/loading the driver. Taken from DRIVER_AddToList */
    278         /* What if the function is used more than once? */
    279        
    280         if (MSVIDEO_SendMessage(hic,DRV_LOAD,0L,0L,bFrom32) != DRV_SUCCESS) {
    281                 WARN("DRV_LOAD failed for hic 0x%08lx\n",(DWORD)hic);
    282                 GlobalFree16(hic);
    283                 return 0;
    284         }
    285         /* return value is not checked */
    286         MSVIDEO_SendMessage(hic,DRV_ENABLE,0L,0L,bFrom32);
    287 
    288         whic->hdrv = MSVIDEO_SendMessage(hic,DRV_OPEN,0,(LPARAM)(SEGPTR_GET(icopen)),FALSE);
    289         if (whic->hdrv == 0) {
    290                 WARN("DRV_OPEN failed for hic 0x%08lx\n",(DWORD)hic);
    291                 GlobalFree16(hic);
    292                 return 0;
    293         }
    294 
    295         GlobalUnlock16(hic);
    296         TRACE("=> 0x%08lx\n",(DWORD)hic);
    297         return hic;
    298 }
    299 
    300 /***********************************************************************
    301  *              ICOpenFunction                  [MSVFW32.@]
     275    whic->private = bFrom32;
     276#endif
     277
     278    /* Now try opening/loading the driver. Taken from DRIVER_AddToList */
     279    /* What if the function is used more than once? */
     280
     281    if (MSVIDEO_SendMessage(hic,DRV_LOAD,0L,0L,bFrom32) != DRV_SUCCESS) {
     282        WARN("DRV_LOAD failed for hic 0x%08lx\n",(DWORD)hic);
     283        GlobalFree16(hic);
     284        return 0;
     285    }
     286    /* return value is not checked */
     287    MSVIDEO_SendMessage(hic,DRV_ENABLE,0L,0L,bFrom32);
     288
     289    whic->hdrv = MSVIDEO_SendMessage(hic,DRV_OPEN,0,(LPARAM)(SEGPTR_GET(icopen)),FALSE);
     290    if (whic->hdrv == 0) {
     291        WARN("DRV_OPEN failed for hic 0x%08lx\n",(DWORD)hic);
     292        GlobalFree16(hic);
     293        return 0;
     294    }
     295
     296    GlobalUnlock16(hic);
     297    TRACE("=> 0x%08lx\n",(DWORD)hic);
     298    return hic;
     299}
     300
     301/***********************************************************************
     302 *      ICOpenFunction          [MSVFW32.@]
    302303 */
    303304HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler) {
    304         return MSVIDEO_OpenFunc(fccType,fccHandler,wMode,lpfnHandler,TRUE);
     305    return MSVIDEO_OpenFunc(fccType,fccHandler,wMode,lpfnHandler,TRUE);
    305306}
    306307
    307308#ifndef __WIN32OS2__
    308309/***********************************************************************
    309  *              ICOpen                          [MSVIDEO.203]
     310 *      ICOpen              [MSVIDEO.203]
    310311 */
    311312HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHandler, UINT16 wMode) {
    312         return (HIC16)ICOpen(fccType, fccHandler, wMode);
    313 }
    314 
    315 /***********************************************************************
    316  *              ICOpenFunction                  [MSVIDEO.206]
     313    return (HIC16)ICOpen(fccType, fccHandler, wMode);
     314}
     315
     316/***********************************************************************
     317 *      ICOpenFunction          [MSVIDEO.206]
    317318 */
    318319HIC16 VFWAPI ICOpenFunction16(DWORD fccType, DWORD fccHandler, UINT16 wMode, FARPROC16 lpfnHandler)
    319320{
    320         return MSVIDEO_OpenFunc(fccType, fccHandler, wMode, (FARPROC)lpfnHandler,FALSE);
    321 }
    322 #endif
    323 
    324 /***********************************************************************
    325  *              ICGetInfo                       [MSVFW32.@]
     321    return MSVIDEO_OpenFunc(fccType, fccHandler, wMode, (FARPROC)lpfnHandler,FALSE);
     322}
     323#endif
     324
     325/***********************************************************************
     326 *      ICGetInfo           [MSVFW32.@]
    326327 */
    327328LRESULT VFWAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
    328         LRESULT         ret;
    329 
    330         TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
    331         ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
    332         TRACE(" -> 0x%08lx\n",ret);
    333         return ret;
     329    LRESULT     ret;
     330
     331    TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
     332    ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
     333    TRACE(" -> 0x%08lx\n",ret);
     334    return ret;
    334335}
    335336
    336337#ifndef __WIN32OS2__
    337338/***********************************************************************
    338  *              ICGetInfo                       [MSVIDEO.212]
     339 *      ICGetInfo           [MSVIDEO.212]
    339340 */
    340341LRESULT VFWAPI ICGetInfo16(HIC16 hic, ICINFO16 *picinfo,DWORD cb) {
    341         LRESULT         ret;
    342 
    343         TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
    344         ret = ICSendMessage16(hic,ICM_GETINFO,(DWORD)picinfo,cb);
    345         TRACE(" -> 0x%08lx\n",ret);
    346         return ret;
    347 }
    348 #endif
    349 
    350 /***********************************************************************
    351  *              ICLocate                        [MSVFW32.@]
     342    LRESULT     ret;
     343
     344    TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
     345    ret = ICSendMessage16(hic,ICM_GETINFO,(DWORD)picinfo,cb);
     346    TRACE(" -> 0x%08lx\n",ret);
     347    return ret;
     348}
     349#endif
     350
     351/***********************************************************************
     352 *      ICLocate            [MSVFW32.@]
    352353 */
    353354HIC VFWAPI ICLocate(
    354         DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
    355         LPBITMAPINFOHEADER lpbiOut, WORD wMode)
     355    DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
     356    LPBITMAPINFOHEADER lpbiOut, WORD wMode)
    356357{
    357         char    type[5],handler[5];
    358         HIC     hic;
    359         DWORD   querymsg;
    360         LPSTR pszBuffer;
    361 
    362         type[4]=0;memcpy(type,&fccType,4);
    363         handler[4]=0;memcpy(handler,&fccHandler,4);
    364 
    365         TRACE("(%s,%s,%p,%p,0x%04x)\n", type, handler, lpbiIn, lpbiOut, wMode);
    366 
    367         switch (wMode) {
    368         case ICMODE_FASTCOMPRESS:
    369         case ICMODE_COMPRESS:
    370                 querymsg = ICM_COMPRESS_QUERY;
    371                 break;
    372         case ICMODE_FASTDECOMPRESS:
    373         case ICMODE_DECOMPRESS:
    374                 querymsg = ICM_DECOMPRESS_QUERY;
    375                 break;
    376         case ICMODE_DRAW:
    377                 querymsg = ICM_DRAW_QUERY;
    378                 break;
    379         default:
    380                 WARN("Unknown mode (%d)\n",wMode);
    381                 return 0;
    382         }
    383 
    384         /* Easy case: handler/type match, we just fire a query and return */
    385         hic = ICOpen(fccType,fccHandler,wMode);
    386         if (hic) {
    387                 if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
    388                         return hic;
    389                 ICClose(hic);
    390         }
    391 
    392         type[4]='.';memcpy(type,&fccType,4);
    393         handler[4]='.';memcpy(handler,&fccHandler,4);
    394 
    395         /* Now try each driver in turn. 32 bit codecs only. */
    396         /* FIXME: Move this to an init routine? */
    397        
    398         pszBuffer = (LPSTR)HeapAlloc(GetProcessHeap(),0,1024);
    399         if (GetPrivateProfileSectionA("drivers32",pszBuffer,1024,"system.ini")) {
    400                 char* s = pszBuffer;
    401                 while (*s) {
    402                         if (!strncasecmp(type,s,5)) {
    403                                 char *s2 = s;
    404                                 while (*s2 != '\0' && *s2 != '.') s2++;
    405                                 if (*s2++) {
    406                                         HIC h;
    407 
    408                                         h = ICOpen(fccType,*(DWORD*)s2,wMode);
    409                                         if (h) {
    410                                                 if (!ICSendMessage(h,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
    411                                                         return h;
    412                                                 ICClose(h);
    413                                         }
    414                                 }
    415                         }
    416                         s += strlen(s) + 1;
    417                 }
    418         }
    419         HeapFree(GetProcessHeap(),0,pszBuffer);
    420        
    421         if (fccType==streamtypeVIDEO) {
    422                 hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
    423                 if (hic)
    424                         return hic;
    425         }
    426 
    427         type[4] = handler[4] = '\0';
    428         WARN("(%.4s,%.4s,%p,%p,0x%04x) not found!\n",type,handler,lpbiIn,lpbiOut,wMode);
    429         return 0;
     358    char    type[5],handler[5];
     359    HIC hic;
     360    DWORD   querymsg;
     361    LPSTR pszBuffer;
     362
     363    type[4]=0;memcpy(type,&fccType,4);
     364    handler[4]=0;memcpy(handler,&fccHandler,4);
     365
     366    TRACE("(%s,%s,%p,%p,0x%04x)\n", type, handler, lpbiIn, lpbiOut, wMode);
     367
     368    switch (wMode) {
     369    case ICMODE_FASTCOMPRESS:
     370    case ICMODE_COMPRESS:
     371        querymsg = ICM_COMPRESS_QUERY;
     372        break;
     373    case ICMODE_FASTDECOMPRESS:
     374    case ICMODE_DECOMPRESS:
     375        querymsg = ICM_DECOMPRESS_QUERY;
     376        break;
     377    case ICMODE_DRAW:
     378        querymsg = ICM_DRAW_QUERY;
     379        break;
     380    default:
     381        WARN("Unknown mode (%d)\n",wMode);
     382        return 0;
     383    }
     384
     385    /* Easy case: handler/type match, we just fire a query and return */
     386    hic = ICOpen(fccType,fccHandler,wMode);
     387    if (hic) {
     388        if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
     389            return hic;
     390        ICClose(hic);
     391    }
     392
     393    type[4]='.';memcpy(type,&fccType,4);
     394    handler[4]='.';memcpy(handler,&fccHandler,4);
     395
     396    /* Now try each driver in turn. 32 bit codecs only. */
     397    /* FIXME: Move this to an init routine? */
     398
     399    pszBuffer = (LPSTR)HeapAlloc(GetProcessHeap(),0,1024);
     400    if (GetPrivateProfileSectionA("drivers32",pszBuffer,1024,"system.ini")) {
     401        char* s = pszBuffer;
     402        while (*s) {
     403            if (!strncasecmp(type,s,5)) {
     404                char *s2 = s;
     405                while (*s2 != '\0' && *s2 != '.') s2++;
     406                if (*s2++) {
     407                    HIC h;
     408
     409                    h = ICOpen(fccType,*(DWORD*)s2,wMode);
     410                    if (h) {
     411                        if (!ICSendMessage(h,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
     412                            return h;
     413                        ICClose(h);
     414                    }
     415                }
     416            }
     417            s += strlen(s) + 1;
     418        }
     419    }
     420    HeapFree(GetProcessHeap(),0,pszBuffer);
     421
     422    if (fccType==streamtypeVIDEO) {
     423        hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
     424        if (hic)
     425            return hic;
     426    }
     427
     428    type[4] = handler[4] = '\0';
     429    WARN("(%.4s,%.4s,%p,%p,0x%04x) not found!\n",type,handler,lpbiIn,lpbiOut,wMode);
     430    return 0;
    430431}
    431432
    432433#ifndef __WIN32OS2__
    433434/***********************************************************************
    434  *              ICLocate                        [MSVIDEO.213]
     435 *      ICLocate            [MSVIDEO.213]
    435436 */
    436437HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
    437                                                 LPBITMAPINFOHEADER lpbiOut, WORD wFlags) {
    438         return (HIC16)ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags);
    439 }
    440 #endif
    441 
    442 /***********************************************************************
    443  *              ICGetDisplayFormat                      [MSVFW32.@]
     438                        LPBITMAPINFOHEADER lpbiOut, WORD wFlags) {
     439    return (HIC16)ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags);
     440}
     441#endif
     442
     443/***********************************************************************
     444 *      ICGetDisplayFormat          [MSVFW32.@]
    444445 */
    445446HIC VFWAPI ICGetDisplayFormat(
    446         HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
    447         INT depth,INT dx,INT dy)
     447    HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
     448    INT depth,INT dx,INT dy)
    448449{
    449         HIC     tmphic = hic;
    450 
    451         FIXME("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy);
    452         if (!tmphic) {
    453                 tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
    454                 if (!tmphic)
    455                         return tmphic;
    456         }
    457         if ((dy == lpbiIn->biHeight) && (dx == lpbiIn->biWidth))
    458                 dy = dx = 0; /* no resize needed */
    459 
    460         /* Can we decompress it ? */
    461         if (ICDecompressQuery(tmphic,lpbiIn,NULL) != 0)
    462                 goto errout; /* no, sorry */
    463 
    464         ICDecompressGetFormat(tmphic,lpbiIn,lpbiOut);
    465 
    466         if (lpbiOut->biCompression != 0) {
    467            FIXME("Ooch, how come decompressor outputs compressed data (%ld)??\n",
    468                         lpbiOut->biCompression);
    469         }
    470         if (lpbiOut->biSize < sizeof(*lpbiOut)) {
    471            FIXME("Ooch, size of output BIH is too small (%ld)\n",
    472                         lpbiOut->biSize);
    473            lpbiOut->biSize = sizeof(*lpbiOut);
    474         }
    475         if (!depth) {
    476                 HDC     hdc;
    477 
    478                 hdc = GetDC(0);
    479                 depth = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES);
    480                 ReleaseDC(0,hdc);
    481                 if (depth==15)  depth = 16;
    482                 if (depth<8)    depth =  8;
    483         }
    484         if (lpbiIn->biBitCount == 8)
    485                 depth = 8;
    486        
    487         TRACE("=> 0x%08lx\n",(DWORD)tmphic);
    488         return tmphic;
     450    HIC tmphic = hic;
     451
     452    FIXME("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy);
     453    if (!tmphic) {
     454        tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
     455        if (!tmphic)
     456            return tmphic;
     457    }
     458    if ((dy == lpbiIn->biHeight) && (dx == lpbiIn->biWidth))
     459        dy = dx = 0; /* no resize needed */
     460
     461    /* Can we decompress it ? */
     462    if (ICDecompressQuery(tmphic,lpbiIn,NULL) != 0)
     463        goto errout; /* no, sorry */
     464
     465    ICDecompressGetFormat(tmphic,lpbiIn,lpbiOut);
     466
     467    if (lpbiOut->biCompression != 0) {
     468       FIXME("Ooch, how come decompressor outputs compressed data (%ld)??\n",
     469            lpbiOut->biCompression);
     470    }
     471    if (lpbiOut->biSize < sizeof(*lpbiOut)) {
     472       FIXME("Ooch, size of output BIH is too small (%ld)\n",
     473            lpbiOut->biSize);
     474       lpbiOut->biSize = sizeof(*lpbiOut);
     475    }
     476    if (!depth) {
     477        HDC hdc;
     478
     479        hdc = GetDC(0);
     480        depth = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES);
     481        ReleaseDC(0,hdc);
     482        if (depth==15)  depth = 16;
     483        if (depth<8)    depth =  8;
     484    }
     485    if (lpbiIn->biBitCount == 8)
     486        depth = 8;
     487
     488    TRACE("=> 0x%08lx\n",(DWORD)tmphic);
     489    return tmphic;
    489490errout:
    490         if (hic!=tmphic)
    491                 ICClose(tmphic);
    492 
    493         TRACE("=> 0\n");
    494         return 0;
     491    if (hic!=tmphic)
     492        ICClose(tmphic);
     493
     494    TRACE("=> 0\n");
     495    return 0;
    495496}
    496497
    497498#ifndef __WIN32OS2__
    498499/***********************************************************************
    499  *              ICGetDisplayFormat                      [MSVIDEO.239]
     500 *      ICGetDisplayFormat          [MSVIDEO.239]
    500501 */
    501502HIC16 VFWAPI ICGetDisplayFormat16(HIC16 hic, LPBITMAPINFOHEADER lpbiIn,
    502                                                                   LPBITMAPINFOHEADER lpbiOut, INT16 depth, INT16 dx, INT16 dy) {
    503         return (HIC16)ICGetDisplayFormat(hic,lpbiIn,lpbiOut,depth,dx,dy);
    504 }
    505 #endif
    506 
    507 /***********************************************************************
    508  *              ICCompress                      [MSVFW32.@]
     503                                  LPBITMAPINFOHEADER lpbiOut, INT16 depth, INT16 dx, INT16 dy) {
     504    return (HIC16)ICGetDisplayFormat(hic,lpbiIn,lpbiOut,depth,dx,dy);
     505}
     506#endif
     507
     508/***********************************************************************
     509 *      ICCompress          [MSVFW32.@]
    509510 */
    510511DWORD VFWAPIV
    511512ICCompress(
    512         HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
    513         LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
    514         LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
    515         LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev)
     513    HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
     514    LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
     515    LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
     516    LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev)
    516517{
    517         ICCOMPRESS      iccmp;
    518 
    519         TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
    520 
    521         iccmp.dwFlags           = dwFlags;
    522 
    523         iccmp.lpbiOutput        = lpbiOutput;
    524         iccmp.lpOutput          = lpData;
    525         iccmp.lpbiInput         = lpbiInput;
    526         iccmp.lpInput           = lpBits;
    527 
    528         iccmp.lpckid            = lpckid;
    529         iccmp.lpdwFlags         = lpdwFlags;
    530         iccmp.lFrameNum         = lFrameNum;
    531         iccmp.dwFrameSize       = dwFrameSize;
    532         iccmp.dwQuality         = dwQuality;
    533         iccmp.lpbiPrev          = lpbiPrev;
    534         iccmp.lpPrev            = lpPrev;
    535         return ICSendMessage(hic,ICM_COMPRESS,(DWORD)&iccmp,sizeof(iccmp));
     518    ICCOMPRESS  iccmp;
     519
     520    TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
     521
     522    iccmp.dwFlags       = dwFlags;
     523
     524    iccmp.lpbiOutput    = lpbiOutput;
     525    iccmp.lpOutput      = lpData;
     526    iccmp.lpbiInput     = lpbiInput;
     527    iccmp.lpInput       = lpBits;
     528
     529    iccmp.lpckid        = lpckid;
     530    iccmp.lpdwFlags     = lpdwFlags;
     531    iccmp.lFrameNum     = lFrameNum;
     532    iccmp.dwFrameSize   = dwFrameSize;
     533    iccmp.dwQuality     = dwQuality;
     534    iccmp.lpbiPrev      = lpbiPrev;
     535    iccmp.lpPrev        = lpPrev;
     536    return ICSendMessage(hic,ICM_COMPRESS,(DWORD)&iccmp,sizeof(iccmp));
    536537}
    537538
    538539#ifndef __WIN32OS2__
    539540/***********************************************************************
    540  *              _ICCompress                     [MSVIDEO.224]
     541 *      _ICCompress         [MSVIDEO.224]
    541542 */
    542543DWORD VFWAPIV ICCompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
    543                                                    LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid,
    544                                                    LPDWORD lpdwFlags, LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality,
    545                                                    LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev) {
    546 
    547         DWORD ret;
    548         ICCOMPRESS *iccmp = SEGPTR_NEW(ICCOMPRESS);
    549 
    550         TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
    551 
    552         iccmp->dwFlags          = dwFlags;
    553 
    554         iccmp->lpbiOutput       = lpbiOutput;
    555         iccmp->lpOutput         = lpData;
    556         iccmp->lpbiInput                = lpbiInput;
    557         iccmp->lpInput          = lpBits;
    558 
    559         iccmp->lpckid           = lpckid;
    560         iccmp->lpdwFlags                = lpdwFlags;
    561         iccmp->lFrameNum                = lFrameNum;
    562         iccmp->dwFrameSize      = dwFrameSize;
    563         iccmp->dwQuality                = dwQuality;
    564         iccmp->lpbiPrev         = lpbiPrev;
    565         iccmp->lpPrev           = lpPrev;
    566         ret = ICSendMessage16(hic,ICM_COMPRESS,(DWORD)SEGPTR_GET(iccmp),sizeof(ICCOMPRESS));
    567         SEGPTR_FREE(iccmp);
    568         return ret;
    569 }
    570 #endif
    571 
    572 /***********************************************************************
    573  *              ICDecompress                    [MSVFW32.@]
     544                           LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid,
     545                           LPDWORD lpdwFlags, LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality,
     546                           LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev) {
     547
     548    DWORD ret;
     549    ICCOMPRESS *iccmp = SEGPTR_NEW(ICCOMPRESS);
     550
     551    TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
     552
     553    iccmp->dwFlags      = dwFlags;
     554
     555    iccmp->lpbiOutput   = lpbiOutput;
     556    iccmp->lpOutput     = lpData;
     557    iccmp->lpbiInput        = lpbiInput;
     558    iccmp->lpInput      = lpBits;
     559
     560    iccmp->lpckid       = lpckid;
     561    iccmp->lpdwFlags        = lpdwFlags;
     562    iccmp->lFrameNum        = lFrameNum;
     563    iccmp->dwFrameSize  = dwFrameSize;
     564    iccmp->dwQuality        = dwQuality;
     565    iccmp->lpbiPrev     = lpbiPrev;
     566    iccmp->lpPrev       = lpPrev;
     567    ret = ICSendMessage16(hic,ICM_COMPRESS,(DWORD)SEGPTR_GET(iccmp),sizeof(ICCOMPRESS));
     568    SEGPTR_FREE(iccmp);
     569    return ret;
     570}
     571#endif
     572
     573/***********************************************************************
     574 *      ICDecompress            [MSVFW32.@]
    574575 */
    575576DWORD VFWAPIV  ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,
    576                                 LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits)
     577                LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits)
    577578{
    578         ICDECOMPRESS    icd;
    579         DWORD ret;
    580 
    581         TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
    582 
    583         TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
    584 
    585         icd.dwFlags     = dwFlags;
    586         icd.lpbiInput   = lpbiFormat;
    587         icd.lpInput     = lpData;
    588 
    589         icd.lpbiOutput  = lpbi;
    590         icd.lpOutput    = lpBits;
    591         icd.ckid        = 0;
    592         ret = ICSendMessage(hic,ICM_DECOMPRESS,(DWORD)&icd,sizeof(ICDECOMPRESS));
    593 
    594         TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
    595 
    596         TRACE("-> %ld\n",ret);
    597 
    598         return ret;
     579    ICDECOMPRESS    icd;
     580    DWORD ret;
     581
     582    TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
     583
     584    TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
     585
     586    icd.dwFlags = dwFlags;
     587    icd.lpbiInput   = lpbiFormat;
     588    icd.lpInput = lpData;
     589
     590    icd.lpbiOutput  = lpbi;
     591    icd.lpOutput    = lpBits;
     592    icd.ckid    = 0;
     593    ret = ICSendMessage(hic,ICM_DECOMPRESS,(DWORD)&icd,sizeof(ICDECOMPRESS));
     594
     595    TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
     596
     597    TRACE("-> %ld\n",ret);
     598
     599    return ret;
    599600}
    600601
    601602#ifndef __WIN32OS2__
    602603/***********************************************************************
    603  *              _ICDecompress                   [MSVIDEO.230]
     604 *      _ICDecompress           [MSVIDEO.230]
    604605 */
    605606DWORD VFWAPIV ICDecompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat,
    606                                                         LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits) {
    607 
    608         ICDECOMPRESS *icd = SEGPTR_NEW(ICDECOMPRESS);
    609         DWORD ret;
    610        
    611         TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
    612 
    613         icd->dwFlags = dwFlags;
    614         icd->lpbiInput = lpbiFormat;
    615         icd->lpInput = lpData;
    616         icd->lpbiOutput = lpbi;
    617         icd->lpOutput = lpBits;
    618         icd->ckid = 0;
    619 
    620         ret = ICSendMessage16(hic,ICM_DECOMPRESS,(DWORD)SEGPTR_GET(icd),sizeof(ICDECOMPRESS));
    621 
    622         SEGPTR_FREE(icd);
    623         return ret;
     607                            LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits) {
     608
     609    ICDECOMPRESS *icd = SEGPTR_NEW(ICDECOMPRESS);
     610    DWORD ret;
     611
     612    TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
     613
     614    icd->dwFlags = dwFlags;
     615    icd->lpbiInput = lpbiFormat;
     616    icd->lpInput = lpData;
     617    icd->lpbiOutput = lpbi;
     618    icd->lpOutput = lpBits;
     619    icd->ckid = 0;
     620
     621    ret = ICSendMessage16(hic,ICM_DECOMPRESS,(DWORD)SEGPTR_GET(icd),sizeof(ICDECOMPRESS));
     622
     623    SEGPTR_FREE(icd);
     624    return ret;
    624625}
    625626
    … …  
    628629
    629630LPVOID MSVIDEO_MapICDEX16To32(LPDWORD lParam) {
    630         LPVOID ret;
    631 
    632         ICDECOMPRESSEX *icdx = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESSEX));
    633         ICDECOMPRESSEX16 *icdx16 = MapSL(*lParam);
    634         ret = icdx16;
    635        
    636         COPY(icdx,dwFlags);
    637         COPYPTR(icdx,lpbiSrc);
    638         COPYPTR(icdx,lpSrc);
    639         COPYPTR(icdx,lpbiDst);
    640         COPYPTR(icdx,lpDst);
    641         COPY(icdx,xDst);
    642         COPY(icdx,yDst);
    643         COPY(icdx,dxDst);
    644         COPY(icdx,dyDst);
    645         COPY(icdx,xSrc);
    646         COPY(icdx,ySrc);
    647         COPY(icdx,dxSrc);
    648         COPY(icdx,dySrc);
    649        
    650         *lParam = (DWORD)(icdx);
    651         return ret;
     631    LPVOID ret;
     632
     633    ICDECOMPRESSEX *icdx = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESSEX));
     634    ICDECOMPRESSEX16 *icdx16 = MapSL(*lParam);
     635    ret = icdx16;
     636
     637    COPY(icdx,dwFlags);
     638    COPYPTR(icdx,lpbiSrc);
     639    COPYPTR(icdx,lpSrc);
     640    COPYPTR(icdx,lpbiDst);
     641    COPYPTR(icdx,lpDst);
     642    COPY(icdx,xDst);
     643    COPY(icdx,yDst);
     644    COPY(icdx,dxDst);
     645    COPY(icdx,dyDst);
     646    COPY(icdx,xSrc);
     647    COPY(icdx,ySrc);
     648    COPY(icdx,dxSrc);
     649    COPY(icdx,dySrc);
     650
     651    *lParam = (DWORD)(icdx);
     652    return ret;
    652653}
    653654
    654655LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2) {
    655         LPVOID ret = 0;
    656        
    657         TRACE("Mapping %d\n",msg);
    658 
    659         switch (msg) {
    660         case DRV_LOAD:
    661         case DRV_ENABLE:
    662         case DRV_CLOSE:
    663         case DRV_DISABLE:
    664         case DRV_FREE:
    665         case ICM_ABOUT:
    666         case ICM_CONFIGURE:
    667         case ICM_COMPRESS_END:
    668         case ICM_DECOMPRESS_END:
    669         case ICM_DECOMPRESSEX_END:
    670         case ICM_SETQUALITY:
    671         case ICM_DRAW_START_PLAY:
    672         case ICM_DRAW_STOP_PLAY:
    673         case ICM_DRAW_REALIZE:
    674         case ICM_DRAW_RENDERBUFFER:
    675         case ICM_DRAW_END:
    676                 break;
    677         case DRV_OPEN:
    678         case ICM_GETDEFAULTQUALITY:
    679         case ICM_GETQUALITY:
    680         case ICM_SETSTATE:
    681         case ICM_DRAW_WINDOW:
    682         case ICM_GETBUFFERSWANTED:
    683                 *lParam1 = (DWORD)MapSL(*lParam1);
    684                 break;
    685         case ICM_GETINFO:
    686                 {
    687                         ICINFO *ici = HeapAlloc(GetProcessHeap(),0,sizeof(ICINFO));
    688                         ICINFO16 *ici16;
    689 
    690                         ici16 = MapSL(*lParam1);
    691                         ret = ici16;
    692 
    693                         ici->dwSize = sizeof(ICINFO);
    694                         COPY(ici,fccType);
    695                         COPY(ici,fccHandler);
    696                         COPY(ici,dwFlags);
    697                         COPY(ici,dwVersion);
    698                         COPY(ici,dwVersionICM);
     656    LPVOID ret = 0;
     657
     658    TRACE("Mapping %d\n",msg);
     659
     660    switch (msg) {
     661    case DRV_LOAD:
     662    case DRV_ENABLE:
     663    case DRV_CLOSE:
     664    case DRV_DISABLE:
     665    case DRV_FREE:
     666    case ICM_ABOUT:
     667    case ICM_CONFIGURE:
     668    case ICM_COMPRESS_END:
     669    case ICM_DECOMPRESS_END:
     670    case ICM_DECOMPRESSEX_END:
     671    case ICM_SETQUALITY:
     672    case ICM_DRAW_START_PLAY:
     673    case ICM_DRAW_STOP_PLAY:
     674    case ICM_DRAW_REALIZE:
     675    case ICM_DRAW_RENDERBUFFER:
     676    case ICM_DRAW_END:
     677        break;
     678    case DRV_OPEN:
     679    case ICM_GETDEFAULTQUALITY:
     680    case ICM_GETQUALITY:
     681    case ICM_SETSTATE:
     682    case ICM_DRAW_WINDOW:
     683    case ICM_GETBUFFERSWANTED:
     684        *lParam1 = (DWORD)MapSL(*lParam1);
     685        break;
     686    case ICM_GETINFO:
     687        {
     688            ICINFO *ici = HeapAlloc(GetProcessHeap(),0,sizeof(ICINFO));
     689            ICINFO16 *ici16;
     690
     691            ici16 = MapSL(*lParam1);
     692            ret = ici16;
     693
     694            ici->dwSize = sizeof(ICINFO);
     695            COPY(ici,fccType);
     696            COPY(ici,fccHandler);
     697            COPY(ici,dwFlags);
     698            COPY(ici,dwVersion);
     699            COPY(ici,dwVersionICM);
    699700                        MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
    700701                        MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
    701702                        MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
    702                         *lParam1 = (DWORD)(ici);
    703                         *lParam2 = sizeof(ICINFO);
    704                 }
    705                 break;
    706         case ICM_COMPRESS:
    707                 {
    708                         ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(),0,sizeof(ICCOMPRESS));
    709                         ICCOMPRESS *icc16;
    710 
    711                         icc16 = MapSL(*lParam1);
    712                         ret = icc16;
    713 
    714                         COPY(icc,dwFlags);
    715                         COPYPTR(icc,lpbiOutput);
    716                         COPYPTR(icc,lpOutput);
    717                         COPYPTR(icc,lpbiInput);
    718                         COPYPTR(icc,lpInput);
    719                         COPYPTR(icc,lpckid);
    720                         COPYPTR(icc,lpdwFlags);
    721                         COPY(icc,lFrameNum);
    722                         COPY(icc,dwFrameSize);
    723                         COPY(icc,dwQuality);
    724                         COPYPTR(icc,lpbiPrev);
    725                         COPYPTR(icc,lpPrev);
    726                        
    727                         *lParam1 = (DWORD)(icc);
    728                         *lParam2 = sizeof(ICCOMPRESS);
    729                 }
    730                 break;
    731         case ICM_DECOMPRESS:
    732                 {
    733                         ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESS));
    734                         ICDECOMPRESS *icd16; /* Same structure except for the pointers */
    735                        
    736                         icd16 = MapSL(*lParam1);
    737                         ret = icd16;
    738                        
    739                         COPY(icd,dwFlags);
    740                         COPYPTR(icd,lpbiInput);
    741                         COPYPTR(icd,lpInput);
    742                         COPYPTR(icd,lpbiOutput);
    743                         COPYPTR(icd,lpOutput);
    744                         COPY(icd,ckid);
    745                        
    746                         *lParam1 = (DWORD)(icd);
    747                         *lParam2 = sizeof(ICDECOMPRESS);
    748                 }
    749                 break;
    750         case ICM_COMPRESS_BEGIN:
    751         case ICM_COMPRESS_GET_FORMAT:
    752         case ICM_COMPRESS_GET_SIZE:
    753         case ICM_COMPRESS_QUERY:
    754         case ICM_DECOMPRESS_GET_FORMAT:
    755         case ICM_DECOMPRESS_QUERY:
    756         case ICM_DECOMPRESS_BEGIN:
    757         case ICM_DECOMPRESS_SET_PALETTE:
    758         case ICM_DECOMPRESS_GET_PALETTE:
    759                 *lParam1 = (DWORD)MapSL(*lParam1);
    760                 *lParam2 = (DWORD)MapSL(*lParam2);
    761                 break;
    762         case ICM_DECOMPRESSEX_QUERY:
    763                 if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
    764                         WARN("*lParam2 has unknown value %p\n",(ICDECOMPRESSEX16*)*lParam2);
    765                 /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
    766                 * This is because of ICMessage(). Special case it?
    767                 {
    768                 LPVOID* addr = HeapAlloc(GetProcessHeap(),0,2*sizeof(LPVOID));
    769                 addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
    770                 if (*lParam2)
    771                 addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
    772                 else
    773                 addr[1] = 0;
    774                  
    775                 ret = addr;
    776                 }
    777                 break;*/
    778         case ICM_DECOMPRESSEX_BEGIN:
    779         case ICM_DECOMPRESSEX:
    780                 ret = MSVIDEO_MapICDEX16To32(lParam1);
    781                 *lParam2 = sizeof(ICDECOMPRESSEX);
    782                 break;
    783         case ICM_DRAW_BEGIN:
    784                 {
    785                         ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWBEGIN));
    786                         ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
    787                         ret = icdb16;
    788 
    789                         COPY(icdb,dwFlags);
    790                         COPY(icdb,hpal);
    791                         COPY(icdb,hwnd);
    792                         COPY(icdb,hdc);
    793                         COPY(icdb,xDst);
    794                         COPY(icdb,yDst);
    795                         COPY(icdb,dxDst);
    796                         COPY(icdb,dyDst);
    797                         COPYPTR(icdb,lpbi);
    798                         COPY(icdb,xSrc);
    799                         COPY(icdb,ySrc);
    800                         COPY(icdb,dxSrc);
    801                         COPY(icdb,dySrc);
    802                         COPY(icdb,dwRate);
    803                         COPY(icdb,dwScale);
    804 
    805                         *lParam1 = (DWORD)(icdb);
    806                         *lParam2 = sizeof(ICDRAWBEGIN);
    807                 }
    808                 break;
    809         case ICM_DRAW_SUGGESTFORMAT:
    810                 {
    811                         ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWSUGGEST));
    812                         ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
    813                        
    814                         ret = icds16;
    815 
    816                         COPY(icds,dwFlags);
    817                         COPYPTR(icds,lpbiIn);
    818                         COPYPTR(icds,lpbiSuggest);
    819                         COPY(icds,dxSrc);
    820                         COPY(icds,dySrc);
    821                         COPY(icds,dxDst);
    822                         COPY(icds,dyDst);
    823                         COPY(icds,hicDecompressor);
    824 
    825                         *lParam1 = (DWORD)(icds);
    826                         *lParam2 = sizeof(ICDRAWSUGGEST);
    827                 }
    828                 break;
    829         case ICM_DRAW:
    830                 {
    831                         ICDRAW *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAW));
    832                         ICDRAW *icd16 = MapSL(*lParam1);
    833                         ret = icd16;
    834 
    835                         COPY(icd,dwFlags);
    836                         COPYPTR(icd,lpFormat);
    837                         COPYPTR(icd,lpData);
    838                         COPY(icd,cbData);
    839                         COPY(icd,lTime);
    840 
    841                         *lParam1 = (DWORD)(icd);
    842                         *lParam2 = sizeof(ICDRAW);
    843                 }
    844                 break;
    845         case ICM_DRAW_START:
    846         case ICM_DRAW_STOP:
    847                 break;
    848         default:
    849                 FIXME("%d is not yet handled. Expect a crash.\n",msg);
    850         }
    851         return ret;
     703            *lParam1 = (DWORD)(ici);
     704            *lParam2 = sizeof(ICINFO);
     705        }
     706        break;
     707    case ICM_COMPRESS:
     708        {
     709            ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(),0,sizeof(ICCOMPRESS));
     710            ICCOMPRESS *icc16;
     711
     712            icc16 = MapSL(*lParam1);
     713            ret = icc16;
     714
     715            COPY(icc,dwFlags);
     716            COPYPTR(icc,lpbiOutput);
     717            COPYPTR(icc,lpOutput);
     718            COPYPTR(icc,lpbiInput);
     719            COPYPTR(icc,lpInput);
     720            COPYPTR(icc,lpckid);
     721            COPYPTR(icc,lpdwFlags);
     722            COPY(icc,lFrameNum);
     723            COPY(icc,dwFrameSize);
     724            COPY(icc,dwQuality);
     725            COPYPTR(icc,lpbiPrev);
     726            COPYPTR(icc,lpPrev);
     727
     728            *lParam1 = (DWORD)(icc);
     729            *lParam2 = sizeof(ICCOMPRESS);
     730        }
     731        break;
     732    case ICM_DECOMPRESS:
     733        {
     734            ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESS));
     735            ICDECOMPRESS *icd16; /* Same structure except for the pointers */
     736
     737            icd16 = MapSL(*lParam1);
     738            ret = icd16;
     739
     740            COPY(icd,dwFlags);
     741            COPYPTR(icd,lpbiInput);
     742            COPYPTR(icd,lpInput);
     743            COPYPTR(icd,lpbiOutput);
     744            COPYPTR(icd,lpOutput);
     745            COPY(icd,ckid);
     746
     747            *lParam1 = (DWORD)(icd);
     748            *lParam2 = sizeof(ICDECOMPRESS);
     749        }
     750        break;
     751    case ICM_COMPRESS_BEGIN:
     752    case ICM_COMPRESS_GET_FORMAT:
     753    case ICM_COMPRESS_GET_SIZE:
     754    case ICM_COMPRESS_QUERY:
     755    case ICM_DECOMPRESS_GET_FORMAT:
     756    case ICM_DECOMPRESS_QUERY:
     757    case ICM_DECOMPRESS_BEGIN:
     758    case ICM_DECOMPRESS_SET_PALETTE:
     759    case ICM_DECOMPRESS_GET_PALETTE:
     760        *lParam1 = (DWORD)MapSL(*lParam1);
     761        *lParam2 = (DWORD)MapSL(*lParam2);
     762        break;
     763    case ICM_DECOMPRESSEX_QUERY:
     764        if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
     765            WARN("*lParam2 has unknown value %p\n",(ICDECOMPRESSEX16*)*lParam2);
     766        /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
     767        * This is because of ICMessage(). Special case it?
     768        {
     769        LPVOID* addr = HeapAlloc(GetProcessHeap(),0,2*sizeof(LPVOID));
     770        addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
     771        if (*lParam2)
     772        addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
     773        else
     774        addr[1] = 0;
     775
     776        ret = addr;
     777        }
     778        break;*/
     779    case ICM_DECOMPRESSEX_BEGIN:
     780    case ICM_DECOMPRESSEX:
     781        ret = MSVIDEO_MapICDEX16To32(lParam1);
     782        *lParam2 = sizeof(ICDECOMPRESSEX);
     783        break;
     784    case ICM_DRAW_BEGIN:
     785        {
     786            ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWBEGIN));
     787            ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
     788            ret = icdb16;
     789
     790            COPY(icdb,dwFlags);
     791            COPY(icdb,hpal);
     792            COPY(icdb,hwnd);
     793            COPY(icdb,hdc);
     794            COPY(icdb,xDst);
     795            COPY(icdb,yDst);
     796            COPY(icdb,dxDst);
     797            COPY(icdb,dyDst);
     798            COPYPTR(icdb,lpbi);
     799            COPY(icdb,xSrc);
     800            COPY(icdb,ySrc);
     801            COPY(icdb,dxSrc);
     802            COPY(icdb,dySrc);
     803            COPY(icdb,dwRate);
     804            COPY(icdb,dwScale);
     805
     806            *lParam1 = (DWORD)(icdb);
     807            *lParam2 = sizeof(ICDRAWBEGIN);
     808        }
     809        break;
     810    case ICM_DRAW_SUGGESTFORMAT:
     811        {
     812            ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWSUGGEST));
     813            ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
     814
     815            ret = icds16;
     816
     817            COPY(icds,dwFlags);
     818            COPYPTR(icds,lpbiIn);
     819            COPYPTR(icds,lpbiSuggest);
     820            COPY(icds,dxSrc);
     821            COPY(icds,dySrc);
     822            COPY(icds,dxDst);
     823            COPY(icds,dyDst);
     824            COPY(icds,hicDecompressor);
     825
     826            *lParam1 = (DWORD)(icds);
     827            *lParam2 = sizeof(ICDRAWSUGGEST);
     828        }
     829        break;
     830    case ICM_DRAW:
     831        {
     832            ICDRAW *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAW));
     833            ICDRAW *icd16 = MapSL(*lParam1);
     834            ret = icd16;
     835
     836            COPY(icd,dwFlags);
     837            COPYPTR(icd,lpFormat);
     838            COPYPTR(icd,lpData);
     839            COPY(icd,cbData);
     840            COPY(icd,lTime);
     841
     842            *lParam1 = (DWORD)(icd);
     843            *lParam2 = sizeof(ICDRAW);
     844        }
     845        break;
     846    case ICM_DRAW_START:
     847    case ICM_DRAW_STOP:
     848        break;
     849    default:
     850        FIXME("%d is not yet handled. Expect a crash.\n",msg);
     851    }
     852    return ret;
    852853}
    853854
    … …  
    856857
    857858void MSVIDEO_UnmapMsg16To32(UINT msg, LPVOID data16, LPDWORD lParam1, LPDWORD lParam2) {
    858         TRACE("Unmapping %d\n",msg);
     859    TRACE("Unmapping %d\n",msg);
    859860
    860861#define UNCOPY(x,y) (x##16->y = x->y);
    861862
    862         switch (msg) {
    863         case ICM_GETINFO:
    864                 {
    865                         ICINFO *ici = (ICINFO*)(*lParam1);
    866                         ICINFO16 *ici16 = (ICINFO16*)data16;
    867 
    868                         UNCOPY(ici,fccType);
    869                         UNCOPY(ici,fccHandler);
    870                         UNCOPY(ici,dwFlags);
    871                         UNCOPY(ici,dwVersion);
    872                         UNCOPY(ici,dwVersionICM);
     863    switch (msg) {
     864    case ICM_GETINFO:
     865        {
     866            ICINFO *ici = (ICINFO*)(*lParam1);
     867            ICINFO16 *ici16 = (ICINFO16*)data16;
     868
     869            UNCOPY(ici,fccType);
     870            UNCOPY(ici,fccHandler);
     871            UNCOPY(ici,dwFlags);
     872            UNCOPY(ici,dwVersion);
     873            UNCOPY(ici,dwVersionICM);
    873874                        WideCharToMultiByte( CP_ACP, 0, ici->szName, -1, ici16->szName,
    874875                                             sizeof(ici16->szName), NULL, NULL );
    … …  
    877878                                             sizeof(ici16->szDescription), NULL, NULL );
    878879                        ici16->szDescription[sizeof(ici16->szDescription)-1] = 0;
    879                         /* This just gives garbage for some reason - BB
    880                            lstrcpynWtoA(ici16->szDriver,ici->szDriver,128);*/
    881 
    882                         HeapFree(GetProcessHeap(),0,ici);
    883                 }
    884                 break;
    885         case ICM_DECOMPRESS_QUERY:
    886                 /*{
    887                   LPVOID* x = data16;
    888                   HeapFree(GetProcessHeap(),0,x[0]);
    889                   if (x[1])
    890                   HeapFree(GetProcessHeap(),0,x[1]);
    891                   }
    892                   break;*/
    893         case ICM_COMPRESS:
    894         case ICM_DECOMPRESS:
    895         case ICM_DECOMPRESSEX_QUERY:
    896         case ICM_DECOMPRESSEX_BEGIN:
    897         case ICM_DECOMPRESSEX:
    898         case ICM_DRAW_BEGIN:
    899         case ICM_DRAW_SUGGESTFORMAT:
    900         case ICM_DRAW:
    901                 HeapFree(GetProcessHeap(),0,data16);
    902                 break;
    903         default:
    904                 ERR("Unmapping unmapped msg %d\n",msg);
    905         }
    906 #undef UNCOPY           
     880            /* This just gives garbage for some reason - BB
     881               lstrcpynWtoA(ici16->szDriver,ici->szDriver,128);*/
     882
     883            HeapFree(GetProcessHeap(),0,ici);
     884        }
     885        break;
     886    case ICM_DECOMPRESS_QUERY:
     887        /*{
     888          LPVOID* x = data16;
     889          HeapFree(GetProcessHeap(),0,x[0]);
     890          if (x[1])
     891          HeapFree(GetProcessHeap(),0,x[1]);
     892          }
     893          break;*/
     894    case ICM_COMPRESS:
     895    case ICM_DECOMPRESS:
     896    case ICM_DECOMPRESSEX_QUERY:
     897    case ICM_DECOMPRESSEX_BEGIN:
     898    case ICM_DECOMPRESSEX:
     899    case ICM_DRAW_BEGIN:
     900    case ICM_DRAW_SUGGESTFORMAT:
     901    case ICM_DRAW:
     902        HeapFree(GetProcessHeap(),0,data16);
     903        break;
     904    default:
     905        ERR("Unmapping unmapped msg %d\n",msg);
     906    }
     907#undef UNCOPY
    907908}
    908909#endif
    909910
    910911LRESULT MSVIDEO_SendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2, BOOL bFrom32) {
    911         LRESULT         ret;
    912         WINE_HIC        *whic = GlobalLock16(hic);
    913         LPVOID data16 = 0;
    914         BOOL bDrv32;
     912    LRESULT     ret;
     913    WINE_HIC    *whic = GlobalLock16(hic);
     914    LPVOID data16 = 0;
     915    BOOL bDrv32;
    915916
    916917#define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx,%d)\n",(DWORD)hic,lParam1,lParam2,bFrom32?32:16);break;
    917918
    918         switch (msg) {
    919                 /* DRV_* */
    920                 XX(DRV_LOAD);
    921                 XX(DRV_ENABLE);
    922                 XX(DRV_OPEN);
    923                 XX(DRV_CLOSE);
    924                 XX(DRV_DISABLE);
    925                 XX(DRV_FREE);
    926                 /* ICM_RESERVED+X */
    927                 XX(ICM_ABOUT);
    928                 XX(ICM_CONFIGURE);
    929                 XX(ICM_GET);
    930                 XX(ICM_GETINFO);
    931                 XX(ICM_GETDEFAULTQUALITY);
    932                 XX(ICM_GETQUALITY);
    933                 XX(ICM_GETSTATE);
    934                 XX(ICM_SETQUALITY);
    935                 XX(ICM_SET);
    936                 XX(ICM_SETSTATE);
    937                 /* ICM_USER+X */
    938                 XX(ICM_COMPRESS_FRAMES_INFO);
    939                 XX(ICM_COMPRESS_GET_FORMAT);
    940                 XX(ICM_COMPRESS_GET_SIZE);
    941                 XX(ICM_COMPRESS_QUERY);
    942                 XX(ICM_COMPRESS_BEGIN);
    943                 XX(ICM_COMPRESS);
    944                 XX(ICM_COMPRESS_END);
    945                 XX(ICM_DECOMPRESS_GET_FORMAT);
    946                 XX(ICM_DECOMPRESS_QUERY);
    947                 XX(ICM_DECOMPRESS_BEGIN);
    948                 XX(ICM_DECOMPRESS);
    949                 XX(ICM_DECOMPRESS_END);
    950                 XX(ICM_DECOMPRESS_SET_PALETTE);
    951                 XX(ICM_DECOMPRESS_GET_PALETTE);
    952                 XX(ICM_DRAW_QUERY);
    953                 XX(ICM_DRAW_BEGIN);
    954                 XX(ICM_DRAW_GET_PALETTE);
    955                 XX(ICM_DRAW_START);
    956                 XX(ICM_DRAW_STOP);
    957                 XX(ICM_DRAW_END);
    958                 XX(ICM_DRAW_GETTIME);
    959                 XX(ICM_DRAW);
    960                 XX(ICM_DRAW_WINDOW);
    961                 XX(ICM_DRAW_SETTIME);
    962                 XX(ICM_DRAW_REALIZE);
    963                 XX(ICM_DRAW_FLUSH);
    964                 XX(ICM_DRAW_RENDERBUFFER);
    965                 XX(ICM_DRAW_START_PLAY);
    966                 XX(ICM_DRAW_STOP_PLAY);
    967                 XX(ICM_DRAW_SUGGESTFORMAT);
    968                 XX(ICM_DRAW_CHANGEPALETTE);
    969                 XX(ICM_GETBUFFERSWANTED);
    970                 XX(ICM_GETDEFAULTKEYFRAMERATE);
    971                 XX(ICM_DECOMPRESSEX_BEGIN);
    972                 XX(ICM_DECOMPRESSEX_QUERY);
    973                 XX(ICM_DECOMPRESSEX);
    974                 XX(ICM_DECOMPRESSEX_END);
    975                 XX(ICM_SET_STATUS_PROC);
    976         default:
    977                 FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,%i) unknown message\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,bFrom32?32:16);
    978         }
     919    switch (msg) {
     920        /* DRV_* */
     921        XX(DRV_LOAD);
     922        XX(DRV_ENABLE);
     923        XX(DRV_OPEN);
     924        XX(DRV_CLOSE);
     925        XX(DRV_DISABLE);
     926        XX(DRV_FREE);
     927        /* ICM_RESERVED+X */
     928        XX(ICM_ABOUT);
     929        XX(ICM_CONFIGURE);
     930        XX(ICM_GET);
     931        XX(ICM_GETINFO);
     932        XX(ICM_GETDEFAULTQUALITY);
     933        XX(ICM_GETQUALITY);
     934        XX(ICM_GETSTATE);
     935        XX(ICM_SETQUALITY);
     936        XX(ICM_SET);
     937        XX(ICM_SETSTATE);
     938        /* ICM_USER+X */
     939        XX(ICM_COMPRESS_FRAMES_INFO);
     940        XX(ICM_COMPRESS_GET_FORMAT);
     941        XX(ICM_COMPRESS_GET_SIZE);
     942        XX(ICM_COMPRESS_QUERY);
     943        XX(ICM_COMPRESS_BEGIN);
     944        XX(ICM_COMPRESS);
     945        XX(ICM_COMPRESS_END);
     946        XX(ICM_DECOMPRESS_GET_FORMAT);
     947        XX(ICM_DECOMPRESS_QUERY);
     948        XX(ICM_DECOMPRESS_BEGIN);
     949        XX(ICM_DECOMPRESS);
     950        XX(ICM_DECOMPRESS_END);
     951        XX(ICM_DECOMPRESS_SET_PALETTE);
     952        XX(ICM_DECOMPRESS_GET_PALETTE);
     953        XX(ICM_DRAW_QUERY);
     954        XX(ICM_DRAW_BEGIN);
     955        XX(ICM_DRAW_GET_PALETTE);
     956        XX(ICM_DRAW_START);
     957        XX(ICM_DRAW_STOP);
     958        XX(ICM_DRAW_END);
     959        XX(ICM_DRAW_GETTIME);
     960        XX(ICM_DRAW);
     961        XX(ICM_DRAW_WINDOW);
     962        XX(ICM_DRAW_SETTIME);
     963        XX(ICM_DRAW_REALIZE);
     964        XX(ICM_DRAW_FLUSH);
     965        XX(ICM_DRAW_RENDERBUFFER);
     966        XX(ICM_DRAW_START_PLAY);
     967        XX(ICM_DRAW_STOP_PLAY);
     968        XX(ICM_DRAW_SUGGESTFORMAT);
     969        XX(ICM_DRAW_CHANGEPALETTE);
     970        XX(ICM_GETBUFFERSWANTED);
     971        XX(ICM_GETDEFAULTKEYFRAMERATE);
     972        XX(ICM_DECOMPRESSEX_BEGIN);
     973        XX(ICM_DECOMPRESSEX_QUERY);
     974        XX(ICM_DECOMPRESSEX);
     975        XX(ICM_DECOMPRESSEX_END);
     976        XX(ICM_SET_STATUS_PROC);
     977    default:
     978        FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,%i) unknown message\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,bFrom32?32:16);
     979    }
    979980
    980981#undef XX
    981982
    982         if (!whic) return ICERR_BADHANDLE;
    983 
    984         if (whic->driverproc) { /* IC is a function */
     983    if (!whic) return ICERR_BADHANDLE;
     984
     985    if (whic->driverproc) { /* IC is a function */
    985986#ifdef __WIN32OS2__
    986                 bDrv32 = whic->privatevfw;
     987            bDrv32 = whic->privatevfw;
    987988#else
    988                 bDrv32 = whic->private;
    989 #endif
    990         } else {
    991                 bDrv32 = ((GetDriverFlags(whic->hdrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) == WINE_GDF_EXIST);
    992         }
     989        bDrv32 = whic->private;
     990#endif
     991    } else {
     992        bDrv32 = ((GetDriverFlags(whic->hdrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) == WINE_GDF_EXIST);
     993    }
    993994
    994995#ifndef __WIN32OS2__
    995         if (!bFrom32) {
    996                 if (bDrv32)
    997                         data16 = MSVIDEO_MapMsg16To32(msg,&lParam1,&lParam2);
    998         } else {
    999                 if (!bDrv32) {
    1000                         ERR("Can't do 32->16 mappings\n");
    1001                         ret = -1;
    1002                         goto out;
    1003                 }
    1004         }
    1005 #endif
    1006        
    1007         if (whic->driverproc) {
     996    if (!bFrom32) {
     997        if (bDrv32)
     998            data16 = MSVIDEO_MapMsg16To32(msg,&lParam1,&lParam2);
     999    } else {
     1000        if (!bDrv32) {
     1001            ERR("Can't do 32->16 mappings\n");
     1002            ret = -1;
     1003            goto out;
     1004        }
     1005    }
     1006#endif
     1007
     1008    if (whic->driverproc) {
    10081009#ifdef __WIN32OS2__
    1009                 ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
     1010            ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
    10101011#else
    1011                 if (bDrv32) {
    1012                         ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
    1013                 } else {
    1014                         ret = MSVIDEO_CallTo16_long_lwwll((FARPROC16)whic->driverproc,whic->hdrv,hic,msg,lParam1,lParam2);
    1015                 }
    1016 #endif
    1017         } else {
    1018                 ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
    1019         }
     1012        if (bDrv32) {
     1013            ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
     1014        } else {
     1015            ret = MSVIDEO_CallTo16_long_lwwll((FARPROC16)whic->driverproc,whic->hdrv,hic,msg,lParam1,lParam2);
     1016        }
     1017#endif
     1018    } else {
     1019        ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
     1020    }
    10201021
    10211022#ifndef __WIN32OS2__
    1022         if (data16)
    1023                 MSVIDEO_UnmapMsg16To32(msg,data16,&lParam1,&lParam2);
    1024 #endif
    1025  
     1023    if (data16)
     1024        MSVIDEO_UnmapMsg16To32(msg,data16,&lParam1,&lParam2);
     1025#endif
     1026
    10261027 out:
    1027         GlobalUnlock16(hic);
    1028        
    1029         TRACE(" -> 0x%08lx\n",ret);
    1030         return ret;
    1031 }
    1032 
    1033 /***********************************************************************
    1034  *              ICSendMessage                   [MSVFW32.@]
     1028    GlobalUnlock16(hic);
     1029
     1030    TRACE(" -> 0x%08lx\n",ret);
     1031    return ret;
     1032}
     1033
     1034/***********************************************************************
     1035 *      ICSendMessage           [MSVFW32.@]
    10351036 */
    10361037LRESULT VFWAPI ICSendMessage(HIC hic, UINT msg, DWORD lParam1, DWORD lParam2) {
    1037         return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,TRUE);
     1038    return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,TRUE);
    10381039}
    10391040#ifndef __WIN32OS2__
    10401041/***********************************************************************
    1041  *              ICSendMessage                   [MSVIDEO.205]
     1042 *      ICSendMessage           [MSVIDEO.205]
    10421043 */
    10431044LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD lParam1, DWORD lParam2) {
    1044         return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,FALSE);
    1045 }
    1046 
    1047 /***********************************************************************
    1048  *              _ICMessage                      [MSVIDEO.207]
     1045    return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,FALSE);
     1046}
     1047
     1048/***********************************************************************
     1049 *      _ICMessage          [MSVIDEO.207]
    10491050 */
    10501051LRESULT VFWAPIV ICMessage16(void) {
    1051         HIC16 hic;
    1052         UINT16 msg;
    1053         UINT16 cb;
    1054         LPWORD lpData;
    1055         LRESULT ret;
    1056         UINT16 i;
    1057 
    1058         VA_LIST16 valist;
    1059        
    1060         VA_START16(valist);
    1061         hic = VA_ARG16(valist, HIC16);
    1062         msg = VA_ARG16(valist, UINT16);
    1063         cb  = VA_ARG16(valist, UINT16);
    1064 
    1065         lpData = SEGPTR_ALLOC(cb);
    1066 
    1067         TRACE("0x%08lx, %u, %u, ...)\n",(DWORD)hic,msg,cb);
    1068 
    1069         for(i=0;i<cb/sizeof(WORD);i++) {
    1070                 lpData[i] = VA_ARG16(valist, WORD);
    1071         }
    1072                
    1073         VA_END16(valist);
    1074         ret = ICSendMessage16(hic, msg, (DWORD)(SEGPTR_GET(lpData)), (DWORD)cb);
    1075 
    1076         SEGPTR_FREE(lpData);
    1077         return ret;
    1078 }
    1079 #endif
    1080 /***********************************************************************
    1081  *              ICDrawBegin             [MSVFW32.@]
     1052    HIC16 hic;
     1053    UINT16 msg;
     1054    UINT16 cb;
     1055    LPWORD lpData;
     1056    LRESULT ret;
     1057    UINT16 i;
     1058
     1059    VA_LIST16 valist;
     1060
     1061    VA_START16(valist);
     1062    hic = VA_ARG16(valist, HIC16);
     1063    msg = VA_ARG16(valist, UINT16);
     1064    cb  = VA_ARG16(valist, UINT16);
     1065
     1066    lpData = SEGPTR_ALLOC(cb);
     1067
     1068    TRACE("0x%08lx, %u, %u, ...)\n",(DWORD)hic,msg,cb);
     1069
     1070    for(i=0;i<cb/sizeof(WORD);i++) {
     1071        lpData[i] = VA_ARG16(valist, WORD);
     1072    }
     1073
     1074    VA_END16(valist);
     1075    ret = ICSendMessage16(hic, msg, (DWORD)(SEGPTR_GET(lpData)), (DWORD)cb);
     1076
     1077    SEGPTR_FREE(lpData);
     1078    return ret;
     1079}
     1080#endif
     1081/***********************************************************************
     1082 *      ICDrawBegin     [MSVFW32.@]
    10821083 */
    10831084DWORD VFWAPIV ICDrawBegin(
    1084         HIC                hic,     /* [in] */
    1085         DWORD              dwFlags, /* [in] flags */
    1086         HPALETTE           hpal,    /* [in] palette to draw with */
    1087         HWND               hwnd,    /* [in] window to draw to */
    1088         HDC                hdc,     /* [in] HDC to draw to */
    1089         INT                xDst,    /* [in] destination rectangle */
    1090         INT                yDst,    /* [in] */
    1091         INT                dxDst,   /* [in] */
    1092         INT                dyDst,   /* [in] */
    1093         LPBITMAPINFOHEADER lpbi,    /* [in] format of frame to draw */
    1094         INT                xSrc,    /* [in] source rectangle */
    1095         INT                ySrc,    /* [in] */
    1096         INT                dxSrc,   /* [in] */
    1097         INT                dySrc,   /* [in] */
    1098         DWORD              dwRate,  /* [in] frames/second = (dwRate/dwScale) */
    1099         DWORD              dwScale) /* [in] */
     1085    HIC                hic,     /* [in] */
     1086    DWORD              dwFlags, /* [in] flags */
     1087    HPALETTE           hpal,    /* [in] palette to draw with */
     1088    HWND               hwnd,    /* [in] window to draw to */
     1089    HDC                hdc,     /* [in] HDC to draw to */
     1090    INT                xDst,    /* [in] destination rectangle */
     1091    INT                yDst,    /* [in] */
     1092    INT                dxDst,   /* [in] */
     1093    INT                dyDst,   /* [in] */
     1094    LPBITMAPINFOHEADER lpbi,    /* [in] format of frame to draw */
     1095    INT                xSrc,    /* [in] source rectangle */
     1096    INT                ySrc,    /* [in] */
     1097    INT                dxSrc,   /* [in] */
     1098    INT                dySrc,   /* [in] */
     1099    DWORD              dwRate,  /* [in] frames/second = (dwRate/dwScale) */
     1100    DWORD              dwScale) /* [in] */
    11001101{
    1101        
    1102         ICDRAWBEGIN     icdb;
    1103 
    1104         TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
    1105                   (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
    1106                   lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
    1107 
    1108         icdb.dwFlags = dwFlags;
    1109         icdb.hpal = hpal;
    1110         icdb.hwnd = hwnd;
    1111         icdb.hdc = hdc;
    1112         icdb.xDst = xDst;
    1113         icdb.yDst = yDst;
    1114         icdb.dxDst = dxDst;
    1115         icdb.dyDst = dyDst;
    1116         icdb.lpbi = lpbi;
    1117         icdb.xSrc = xSrc;
    1118         icdb.ySrc = ySrc;
    1119         icdb.dxSrc = dxSrc;
    1120         icdb.dySrc = dySrc;
    1121         icdb.dwRate = dwRate;
    1122         icdb.dwScale = dwScale;
    1123         return ICSendMessage(hic,ICM_DRAW_BEGIN,(DWORD)&icdb,sizeof(icdb));
     1102
     1103    ICDRAWBEGIN icdb;
     1104
     1105    TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
     1106          (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
     1107          lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
     1108
     1109    icdb.dwFlags = dwFlags;
     1110    icdb.hpal = hpal;
     1111    icdb.hwnd = hwnd;
     1112    icdb.hdc = hdc;
     1113    icdb.xDst = xDst;
     1114    icdb.yDst = yDst;
     1115    icdb.dxDst = dxDst;
     1116    icdb.dyDst = dyDst;
     1117    icdb.lpbi = lpbi;
     1118    icdb.xSrc = xSrc;
     1119    icdb.ySrc = ySrc;
     1120    icdb.dxSrc = dxSrc;
     1121    icdb.dySrc = dySrc;
     1122    icdb.dwRate = dwRate;
     1123    icdb.dwScale = dwScale;
     1124    return ICSendMessage(hic,ICM_DRAW_BEGIN,(DWORD)&icdb,sizeof(icdb));
    11241125}
    11251126
    11261127#ifndef __WIN32OS2__
    11271128/***********************************************************************
    1128  *              _ICDrawBegin            [MSVIDEO.232]
     1129 *      _ICDrawBegin        [MSVIDEO.232]
    11291130 */
    11301131DWORD VFWAPIV ICDrawBegin16(
    1131         HIC16               hic,     /* [in] */
    1132         DWORD               dwFlags, /* [in] flags */
    1133         HPALETTE16          hpal,    /* [in] palette to draw with */
    1134         HWND16              hwnd,    /* [in] window to draw to */
    1135         HDC16               hdc,     /* [in] HDC to draw to */
    1136         INT16               xDst,    /* [in] destination rectangle */
    1137         INT16               yDst,    /* [in] */
    1138         INT16               dxDst,   /* [in] */
    1139         INT16               dyDst,   /* [in] */
    1140         LPBITMAPINFOHEADER  lpbi,    /* [in] format of frame to draw NOTE: SEGPTR */
    1141         INT16               xSrc,    /* [in] source rectangle */
    1142         INT16               ySrc,    /* [in] */
    1143         INT16               dxSrc,   /* [in] */
    1144         INT16               dySrc,   /* [in] */
    1145         DWORD               dwRate,  /* [in] frames/second = (dwRate/dwScale) */
    1146         DWORD               dwScale) /* [in] */
     1132    HIC16               hic,     /* [in] */
     1133    DWORD               dwFlags, /* [in] flags */
     1134    HPALETTE16          hpal,    /* [in] palette to draw with */
     1135    HWND16              hwnd,    /* [in] window to draw to */
     1136    HDC16               hdc,     /* [in] HDC to draw to */
     1137    INT16               xDst,    /* [in] destination rectangle */
     1138    INT16               yDst,    /* [in] */
     1139    INT16               dxDst,   /* [in] */
     1140    INT16               dyDst,   /* [in] */
     1141    LPBITMAPINFOHEADER  lpbi,    /* [in] format of frame to draw NOTE: SEGPTR */
     1142    INT16           xSrc,    /* [in] source rectangle */
     1143    INT16           ySrc,    /* [in] */
     1144    INT16           dxSrc,   /* [in] */
     1145    INT16           dySrc,   /* [in] */
     1146    DWORD           dwRate,  /* [in] frames/second = (dwRate/dwScale) */
     1147    DWORD           dwScale) /* [in] */
    11471148{
    1148         DWORD ret;
    1149         ICDRAWBEGIN16* icdb = SEGPTR_NEW(ICDRAWBEGIN16); /* SEGPTR for mapper to deal with */
    1150 
    1151         TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
    1152                   (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
    1153                   lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
    1154 
    1155         icdb->dwFlags = dwFlags;
    1156         icdb->hpal = hpal;
    1157         icdb->hwnd = hwnd;
    1158         icdb->hdc = hdc;
    1159         icdb->xDst = xDst;
    1160         icdb->yDst = yDst;
    1161         icdb->dxDst = dxDst;
    1162         icdb->dyDst = dyDst;
    1163         icdb->lpbi = lpbi; /* Keep this as SEGPTR for the mapping code to deal with */
    1164         icdb->xSrc = xSrc;
    1165         icdb->ySrc = ySrc;
    1166         icdb->dxSrc = dxSrc;
    1167         icdb->dySrc = dySrc;
    1168         icdb->dwRate = dwRate;
    1169         icdb->dwScale = dwScale;
    1170        
    1171         ret = (DWORD)ICSendMessage16(hic,ICM_DRAW_BEGIN,(DWORD)SEGPTR_GET(icdb),sizeof(ICDRAWBEGIN16));
    1172         SEGPTR_FREE(icdb);
    1173         return ret;
    1174 }
    1175 #endif
    1176 
    1177 /***********************************************************************
    1178  *              ICDraw                  [MSVFW32.@]
     1149    DWORD ret;
     1150    ICDRAWBEGIN16* icdb = SEGPTR_NEW(ICDRAWBEGIN16); /* SEGPTR for mapper to deal with */
     1151
     1152    TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
     1153          (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
     1154          lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
     1155
     1156    icdb->dwFlags = dwFlags;
     1157    icdb->hpal = hpal;
     1158    icdb->hwnd = hwnd;
     1159    icdb->hdc = hdc;
     1160    icdb->xDst = xDst;
     1161    icdb->yDst = yDst;
     1162    icdb->dxDst = dxDst;
     1163    icdb->dyDst = dyDst;
     1164    icdb->lpbi = lpbi; /* Keep this as SEGPTR for the mapping code to deal with */
     1165    icdb->xSrc = xSrc;
     1166    icdb->ySrc = ySrc;
     1167    icdb->dxSrc = dxSrc;
     1168    icdb->dySrc = dySrc;
     1169    icdb->dwRate = dwRate;
     1170    icdb->dwScale = dwScale;
     1171
     1172    ret = (DWORD)ICSendMessage16(hic,ICM_DRAW_BEGIN,(DWORD)SEGPTR_GET(icdb),sizeof(ICDRAWBEGIN16));
     1173    SEGPTR_FREE(icdb);
     1174    return ret;
     1175}
     1176#endif
     1177
     1178/***********************************************************************
     1179 *      ICDraw          [MSVFW32.@]
    11791180 */
    11801181DWORD VFWAPIV ICDraw(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime) {
    1181         ICDRAW  icd;
    1182 
    1183         TRACE("(0x%09lx,%ld,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
    1184 
    1185         icd.dwFlags = dwFlags;
    1186         icd.lpFormat = lpFormat;
    1187         icd.lpData = lpData;
    1188         icd.cbData = cbData;
    1189         icd.lTime = lTime;
    1190 
    1191         return ICSendMessage(hic,ICM_DRAW,(DWORD)&icd,sizeof(icd));
     1182    ICDRAW  icd;
     1183
     1184    TRACE("(0x%09lx,%ld,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
     1185
     1186    icd.dwFlags = dwFlags;
     1187    icd.lpFormat = lpFormat;
     1188    icd.lpData = lpData;
     1189    icd.cbData = cbData;
     1190    icd.lTime = lTime;
     1191
     1192    return ICSendMessage(hic,ICM_DRAW,(DWORD)&icd,sizeof(icd));
    11921193}
    11931194
    11941195#ifndef __WIN32OS2__
    11951196/***********************************************************************
    1196  *              _ICDraw                 [MSVIDEO.234]
     1197 *      _ICDraw         [MSVIDEO.234]
    11971198 */
    11981199DWORD VFWAPIV ICDraw16(
    1199         HIC16 hic,
    1200         DWORD dwFlags,
    1201         LPVOID lpFormat, /* [???] NOTE: SEGPTR */
    1202         LPVOID lpData,   /* [???] NOTE: SEGPTR */
    1203         DWORD cbData,
    1204         LONG lTime)
     1200    HIC16 hic,
     1201    DWORD dwFlags,
     1202    LPVOID lpFormat, /* [???] NOTE: SEGPTR */
     1203    LPVOID lpData,   /* [???] NOTE: SEGPTR */
     1204    DWORD cbData,
     1205    LONG lTime)
    12051206{
    1206         ICDRAW* icd = SEGPTR_NEW(ICDRAW); /* SEGPTR for mapper to deal with */
    1207 
    1208         TRACE("(0x%08lx,0x%08lx,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
    1209         icd->dwFlags = dwFlags;
    1210         icd->lpFormat = lpFormat;
    1211         icd->lpData = lpData;
    1212         icd->cbData = cbData;
    1213         icd->lTime = lTime;
    1214 
    1215         return ICSendMessage16(hic,ICM_DRAW,(DWORD)SEGPTR_GET(icd),sizeof(ICDRAW));
    1216 }
    1217 #endif
    1218 
    1219 /***********************************************************************
    1220  *              ICClose                 [MSVFW32.@]
     1207    ICDRAW* icd = SEGPTR_NEW(ICDRAW); /* SEGPTR for mapper to deal with */
     1208
     1209    TRACE("(0x%08lx,0x%08lx,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
     1210    icd->dwFlags = dwFlags;
     1211    icd->lpFormat = lpFormat;
     1212    icd->lpData = lpData;
     1213    icd->cbData = cbData;
     1214    icd->lTime = lTime;
     1215
     1216    return ICSendMessage16(hic,ICM_DRAW,(DWORD)SEGPTR_GET(icd),sizeof(ICDRAW));
     1217}
     1218#endif
     1219
     1220/***********************************************************************
     1221 *      ICClose         [MSVFW32.@]
    12211222 */
    12221223LRESULT WINAPI ICClose(HIC hic) {
    1223         WINE_HIC *whic = GlobalLock16(hic);
    1224         TRACE("(0x%08lx)\n",(DWORD)hic);
    1225         if (whic->driverproc) {
    1226                 ICSendMessage(hic,DRV_CLOSE,0,0);
    1227                 ICSendMessage(hic,DRV_DISABLE,0,0);
    1228                 ICSendMessage(hic,DRV_FREE,0,0);
    1229         } else {
    1230                 CloseDriver(whic->hdrv,0,0);
    1231         }
    1232 
    1233         GlobalUnlock16(hic);
    1234         GlobalFree16(hic);
    1235         return 0;
     1224    WINE_HIC *whic = GlobalLock16(hic);
     1225    TRACE("(0x%08lx)\n",(DWORD)hic);
     1226    if (whic->driverproc) {
     1227        ICSendMessage(hic,DRV_CLOSE,0,0);
     1228        ICSendMessage(hic,DRV_DISABLE,0,0);
     1229        ICSendMessage(hic,DRV_FREE,0,0);
     1230    } else {
     1231        CloseDriver(whic->hdrv,0,0);
     1232    }
     1233
     1234    GlobalUnlock16(hic);
     1235    GlobalFree16(hic);
     1236    return 0;
    12361237}
    12371238
    12381239#ifndef __WIN32OS2__
    12391240/***********************************************************************
    1240  *              ICClose                 [MSVIDEO.204]
     1241 *      ICClose         [MSVIDEO.204]
    12411242 */
    12421243LRESULT WINAPI ICClose16(HIC16 hic) {
    1243         return ICClose(hic);
    1244 }
    1245 #endif
    1246 
    1247 /***********************************************************************
    1248  *              MCIWndCreate            [MSVFW32.@]
    1249  *              MCIWndCreateA           [MSVFW32.@]
     1244    return ICClose(hic);
     1245}
     1246#endif
     1247
     1248/***********************************************************************
     1249 *      MCIWndCreate        [MSVFW32.@]
     1250 *      MCIWndCreateA       [MSVFW32.@]
    12501251 */
    12511252HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
    12521253                      DWORD dwStyle,LPCSTR szFile)
    12531254{
    1254         FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
    1255         return 0;
    1256 }
    1257 
    1258 /***********************************************************************
    1259  *              MCIWndCreateW           [MSVFW32.@]
     1255    FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
     1256    return 0;
     1257}
     1258
     1259/***********************************************************************
     1260 *      MCIWndCreateW       [MSVFW32.@]
    12601261 */
    12611262HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
    12621263                      DWORD dwStyle,LPCWSTR szFile)
    12631264{
    1264         FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
    1265         return 0;
    1266 }
     1265    FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
     1266    return 0;
     1267}
Note: See TracChangeset for help on using the changeset viewer.