Changeset 6712 for trunk/src/msvfw32


Ignore:
Timestamp:
Sep 15, 2001, 11:47:44 AM (24 years ago)
Author:
sandervl
Message:

restored old version

Location:
trunk/src/msvfw32
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msvfw32/drawdib.c

    r6648 r6712  
    1 /* $Id: drawdib.c,v 1.2 2001-09-05 13:12:34 bird Exp $ */
    2 /*
     1/*
    32 * Copyright 2000 Bradley Baetz
    43 *
    … …  
    2221
    2322typedef struct {
    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 */
     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 */
    3837} WINE_HDD;
    3938
    … …  
    5958
    6059/***********************************************************************
    61  *      DrawDibOpen     [MSVFW32.@]
     60 *              DrawDibOpen             [MSVFW32.@]
    6261 */
    6362HDRAWDIB VFWAPI DrawDibOpen(void) {
    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]
     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]
    7473 */
    7574HDRAWDIB16 VFWAPI DrawDibOpen16(void) {
    76     return (HDRAWDIB16)DrawDibOpen();
    77 }
    78 
    79 /***********************************************************************
    80  *      DrawDibClose        [MSVFW32.@]
     75        return (HDRAWDIB16)DrawDibOpen();
     76}
     77
     78/***********************************************************************
     79 *              DrawDibClose            [MSVFW32.@]
    8180 */
    8281BOOL VFWAPI DrawDibClose(HDRAWDIB hdd) {
    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]
     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]
    10099 */
    101100BOOL16 VFWAPI DrawDibClose16(HDRAWDIB16 hdd) {
    102     return DrawDibClose(hdd);
    103 }
    104 
    105 /***********************************************************************
    106  *      DrawDibEnd      [MSVFW32.@]
     101        return DrawDibClose(hdd);
     102}
     103
     104/***********************************************************************
     105 *              DrawDibEnd              [MSVFW32.@]
    107106 */
    108107BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd) {
    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]
     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]
    151150 */
    152151BOOL16 VFWAPI DrawDibEnd16(HDRAWDIB16 hdd) {
    153     return DrawDibEnd(hdd);
     152        return DrawDibEnd(hdd);
    154153}
    155154
    … …  
    158157 */
    159158BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd,
    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;
     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;
    265264}
    266265
    267266/************************************************************************
    268  *      DrawDibBegin        [MSVIDEO.104]
     267 *              DrawDibBegin            [MSVIDEO.104]
    269268 */
    270269BOOL16 VFWAPI DrawDibBegin16(HDRAWDIB16 hdd,
    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);
     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);
    279278}
    280279
    281280/**********************************************************************
    282  *      DrawDibDraw     [MSVFW32.@]
     281 *              DrawDibDraw             [MSVFW32.@]
    283282 */
    284283BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc,
    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
     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
    290289) {
    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);
     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);
    308307
    309308#define CHANGED(x) (whdd->x != x)
    310309
    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     }
     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        }
    316315
    317316#undef CHANGED
    318317
    319318        if ((dxDst == -1) && (dyDst == -1)) {
    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;
     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;
    350349}
    351350
    352351/**********************************************************************
    353  *      DrawDibDraw     [MSVIDEO.106]
    354  */
    355 BOOL16 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);
     352 *              DrawDibDraw             [MSVIDEO.106]
     353 */
     354BOOL16 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);
    369368}
    370369
    371370/*************************************************************************
    372  *      DrawDibStart        [MSVFW32.@]
     371 *              DrawDibStart            [MSVFW32.@]
    373372 */
    374373BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate) {
    375     FIXME("(0x%08lx,%ld), stub\n",(DWORD)hdd,rate);
    376     return TRUE;
     374        FIXME("(0x%08lx,%ld), stub\n",(DWORD)hdd,rate);
     375        return TRUE;
    377376}
    378377
    379378/*************************************************************************
    380  *      DrawDibStart        [MSVIDEO.118]
     379 *              DrawDibStart            [MSVIDEO.118]
    381380 */
    382381BOOL16 VFWAPI DrawDibStart16(HDRAWDIB16 hdd, DWORD rate) {
    383     return DrawDibStart(hdd,rate);
     382        return DrawDibStart(hdd,rate);
    384383}
    385384
    386385/*************************************************************************
    387  *      DrawDibStop     [MSVFW32.@]
     386 *              DrawDibStop             [MSVFW32.@]
    388387 */
    389388BOOL VFWAPI DrawDibStop(HDRAWDIB hdd) {
    390     FIXME("(0x%08lx), stub\n",(DWORD)hdd);
    391     return TRUE;
     389        FIXME("(0x%08lx), stub\n",(DWORD)hdd);
     390        return TRUE;
    392391}
    393392
    394393/*************************************************************************
    395  *      DrawDibStop     [MSVIDEO.119]
     394 *              DrawDibStop             [MSVIDEO.119]
    396395 */
    397396BOOL16 DrawDibStop16(HDRAWDIB16 hdd) {
    398     return DrawDibStop(hdd);
     397        return DrawDibStop(hdd);
    399398}
    400399
    … …  
    403402 */
    404403BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal) {
    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;
     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;
    418417}
    419418
    … …  
    422421 */
    423422BOOL16 VFWAPI DrawDibSetPalette16(HDRAWDIB16 hdd, HPALETTE16 hpal) {
    424     return DrawDibSetPalette(hdd,hpal);
     423        return DrawDibSetPalette(hdd,hpal);
    425424}
    426425
    … …  
    429428 */
    430429HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd) {
    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;
     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;
    440439}
    441440
    … …  
    444443 */
    445444HPALETTE16 VFWAPI DrawDibGetPalette16(HDRAWDIB16 hdd) {
    446     return (HPALETTE16)DrawDibGetPalette(hdd);
     445        return (HPALETTE16)DrawDibGetPalette(hdd);
    447446}
    448447
    … …  
    451450 */
    452451UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground) {
    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 
     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       
    472471 out:
    473     GlobalUnlock16(hdd);
    474 
    475     TRACE("=> %u\n",ret);
    476     return ret;
     472        GlobalUnlock16(hdd);
     473
     474        TRACE("=> %u\n",ret);
     475        return ret;
    477476}
    478477
    … …  
    481480 */
    482481UINT16 VFWAPI DrawDibRealize16(HDRAWDIB16 hdd, HDC16 hdc, BOOL16 fBackground) {
    483     return (UINT16)DrawDibRealize(hdd,hdc,fBackground);
    484 }
     482        return (UINT16)DrawDibRealize(hdd,hdc,fBackground);
     483}

  • trunk/src/msvfw32/msvideo_main.c

    r6648 r6712  
    1 /* $Id: msvideo_main.c,v 1.2 2001-09-05 13:12:35 bird Exp $ */
    21/*
    32 * Copyright 1998 Marcus Meissner
    4  * Copyright 2000 Bradley Baetz
     3 * Copyright 2000 Bradley Baetz 
    54 *
    65 * FIXME: This all assumes 32 bit codecs
    7  *      Win95 appears to prefer 32 bit codecs, even from 16 bit code.
    8  *      There is the ICOpenFunction16 to worry about still, though.
     6 *              Win95 appears to prefer 32 bit codecs, even from 16 bit code.
     7 *              There is the ICOpenFunction16 to worry about still, though.
    98 */
    109
    … …  
    3534#define GlobalFree16 GlobalFree
    3635#undef SEGPTR_NEW
    37 #define SEGPTR_NEW(a)   malloc(sizeof(a))
     36#define SEGPTR_NEW(a)   malloc(sizeof(a))
    3837#define SEGPTR_FREE(a)  free(a)
    3938#define SEGPTR_GET(a)   a
    … …  
    6059
    6160/***********************************************************************
    62  *      VideoForWindowsVersion      [MSVFW32.2]
    63  *      VideoForWindowsVersion      [MSVIDEO.2]
     61 *              VideoForWindowsVersion          [MSVFW32.2]
     62 *              VideoForWindowsVersion          [MSVIDEO.2]
    6463 * Returns the version in major.minor form.
    6564 * In Windows95 this returns 0x040003b6 (4.950)
    6665 */
    6766DWORD WINAPI VideoForWindowsVersion(void) {
    68     return 0x040003B6; /* 4.950 */
    69 }
    70 
    71 /***********************************************************************
    72  *      VideoCapDriverDescAndVer    [MSVIDEO.22]
     67        return 0x040003B6; /* 4.950 */
     68}
     69
     70/***********************************************************************
     71 *              VideoCapDriverDescAndVer        [MSVIDEO.22]
    7372 */
    7473DWORD WINAPI VideoCapDriverDescAndVer(
    75     WORD nr,LPSTR buf1,WORD buf1len,LPSTR buf2,WORD buf2len
     74        WORD nr,LPSTR buf1,WORD buf1len,LPSTR buf2,WORD buf2len
    7675) {
    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;
     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;
    139138}
    140139
    … …  
    142141
    143142/***********************************************************************
    144  *      ICInfo              [MSVFW32.@]
     143 *              ICInfo                          [MSVFW32.@]
    145144 * Get information about an installable compressor. Return TRUE if there
    146145 * is one.
    147146 */
    148147BOOL VFWAPI ICInfo(
    149     DWORD fccType,      /* [in] type of compressor ('vidc') */
    150     DWORD fccHandler,   /* [in] <n>th compressor */
    151     ICINFO *lpicinfo)   /* [out] information about compressor */
     148        DWORD fccType,          /* [in] type of compressor ('vidc') */
     149        DWORD fccHandler,       /* [in] <n>th compressor */
     150        ICINFO *lpicinfo)       /* [out] information about compressor */
    152151{
    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;
     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;
    174173}
    175174#ifndef __WIN32OS2__
    176175/***********************************************************************
    177  *      ICInfo              [MSVIDEO.200]
     176 *              ICInfo                          [MSVIDEO.200]
    178177 */
    179178BOOL16 VFWAPI ICInfo16(
    180     DWORD     fccType,    /* [in] */
    181     DWORD     fccHandler, /* [in] */
    182     ICINFO16 *lpicinfo)   /* [in/out] NOTE: SEGPTR */
     179        DWORD     fccType,    /* [in] */
     180        DWORD     fccHandler, /* [in] */
     181        ICINFO16 *lpicinfo)   /* [in/out] NOTE: SEGPTR */
    183182{
    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.@]
     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.@]
    201200 * Opens an installable compressor. Return special handle.
    202201 */
    203202HIC VFWAPI ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
    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;
     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;
    239238#ifdef __WIN32OS2__
    240     whic->privatevfw    = 0;
     239        whic->privatevfw        = 0;
    241240#else
    242     whic->private   = 0;
    243 #endif
    244     GlobalUnlock16(hic);
    245     TRACE("=> 0x%08lx\n",(DWORD)hic);
    246     return hic;
     241        whic->private   = 0;
     242#endif
     243        GlobalUnlock16(hic);
     244        TRACE("=> 0x%08lx\n",(DWORD)hic);
     245        return hic;
    247246}
    248247
    249248HIC MSVIDEO_OpenFunc(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler, BOOL bFrom32) {
    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 
     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       
    272271#ifdef __WIN32OS2__
    273     whic->privatevfw    = bFrom32;
     272        whic->privatevfw        = bFrom32;
    274273#else
    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.@]
     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.@]
    303302 */
    304303HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler) {
    305     return MSVIDEO_OpenFunc(fccType,fccHandler,wMode,lpfnHandler,TRUE);
     304        return MSVIDEO_OpenFunc(fccType,fccHandler,wMode,lpfnHandler,TRUE);
    306305}
    307306
    308307#ifndef __WIN32OS2__
    309308/***********************************************************************
    310  *      ICOpen              [MSVIDEO.203]
     309 *              ICOpen                          [MSVIDEO.203]
    311310 */
    312311HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHandler, UINT16 wMode) {
    313     return (HIC16)ICOpen(fccType, fccHandler, wMode);
    314 }
    315 
    316 /***********************************************************************
    317  *      ICOpenFunction          [MSVIDEO.206]
     312        return (HIC16)ICOpen(fccType, fccHandler, wMode);
     313}
     314
     315/***********************************************************************
     316 *              ICOpenFunction                  [MSVIDEO.206]
    318317 */
    319318HIC16 VFWAPI ICOpenFunction16(DWORD fccType, DWORD fccHandler, UINT16 wMode, FARPROC16 lpfnHandler)
    320319{
    321     return MSVIDEO_OpenFunc(fccType, fccHandler, wMode, (FARPROC)lpfnHandler,FALSE);
    322 }
    323 #endif
    324 
    325 /***********************************************************************
    326  *      ICGetInfo           [MSVFW32.@]
     320        return MSVIDEO_OpenFunc(fccType, fccHandler, wMode, (FARPROC)lpfnHandler,FALSE);
     321}
     322#endif
     323
     324/***********************************************************************
     325 *              ICGetInfo                       [MSVFW32.@]
    327326 */
    328327LRESULT VFWAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
    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;
     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;
    335334}
    336335
    337336#ifndef __WIN32OS2__
    338337/***********************************************************************
    339  *      ICGetInfo           [MSVIDEO.212]
     338 *              ICGetInfo                       [MSVIDEO.212]
    340339 */
    341340LRESULT VFWAPI ICGetInfo16(HIC16 hic, ICINFO16 *picinfo,DWORD cb) {
    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.@]
     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.@]
    353352 */
    354353HIC VFWAPI ICLocate(
    355     DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
    356     LPBITMAPINFOHEADER lpbiOut, WORD wMode)
     354        DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
     355        LPBITMAPINFOHEADER lpbiOut, WORD wMode)
    357356{
    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;
     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;
    431430}
    432431
    433432#ifndef __WIN32OS2__
    434433/***********************************************************************
    435  *      ICLocate            [MSVIDEO.213]
     434 *              ICLocate                        [MSVIDEO.213]
    436435 */
    437436HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
    438                         LPBITMAPINFOHEADER lpbiOut, WORD wFlags) {
    439     return (HIC16)ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags);
    440 }
    441 #endif
    442 
    443 /***********************************************************************
    444  *      ICGetDisplayFormat          [MSVFW32.@]
     437                                                LPBITMAPINFOHEADER lpbiOut, WORD wFlags) {
     438        return (HIC16)ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags);
     439}
     440#endif
     441
     442/***********************************************************************
     443 *              ICGetDisplayFormat                      [MSVFW32.@]
    445444 */
    446445HIC VFWAPI ICGetDisplayFormat(
    447     HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
    448     INT depth,INT dx,INT dy)
     446        HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
     447        INT depth,INT dx,INT dy)
    449448{
    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;
     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;
    490489errout:
    491     if (hic!=tmphic)
    492         ICClose(tmphic);
    493 
    494     TRACE("=> 0\n");
    495     return 0;
     490        if (hic!=tmphic)
     491                ICClose(tmphic);
     492
     493        TRACE("=> 0\n");
     494        return 0;
    496495}
    497496
    498497#ifndef __WIN32OS2__
    499498/***********************************************************************
    500  *      ICGetDisplayFormat          [MSVIDEO.239]
     499 *              ICGetDisplayFormat                      [MSVIDEO.239]
    501500 */
    502501HIC16 VFWAPI ICGetDisplayFormat16(HIC16 hic, LPBITMAPINFOHEADER lpbiIn,
    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.@]
     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.@]
    510509 */
    511510DWORD VFWAPIV
    512511ICCompress(
    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)
     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)
    517516{
    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));
     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));
    537536}
    538537
    539538#ifndef __WIN32OS2__
    540539/***********************************************************************
    541  *      _ICCompress         [MSVIDEO.224]
     540 *              _ICCompress                     [MSVIDEO.224]
    542541 */
    543542DWORD VFWAPIV ICCompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
    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.@]
     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.@]
    575574 */
    576575DWORD VFWAPIV  ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,
    577                 LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits)
     576                                LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits)
    578577{
    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;
     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;
    600599}
    601600
    602601#ifndef __WIN32OS2__
    603602/***********************************************************************
    604  *      _ICDecompress           [MSVIDEO.230]
     603 *              _ICDecompress                   [MSVIDEO.230]
    605604 */
    606605DWORD VFWAPIV ICDecompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat,
    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;
     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;
    625624}
    626625
    … …  
    629628
    630629LPVOID MSVIDEO_MapICDEX16To32(LPDWORD lParam) {
    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;
     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;
    653652}
    654653
    655654LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2) {
    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);
     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);
    700699                        MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
    701700                        MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
    702701                        MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
    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;
     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;
    853852}
    854853
    … …  
    857856
    858857void MSVIDEO_UnmapMsg16To32(UINT msg, LPVOID data16, LPDWORD lParam1, LPDWORD lParam2) {
    859     TRACE("Unmapping %d\n",msg);
     858        TRACE("Unmapping %d\n",msg);
    860859
    861860#define UNCOPY(x,y) (x##16->y = x->y);
    862861
    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);
     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);
    874873                        WideCharToMultiByte( CP_ACP, 0, ici->szName, -1, ici16->szName,
    875874                                             sizeof(ici16->szName), NULL, NULL );
    … …  
    878877                                             sizeof(ici16->szDescription), NULL, NULL );
    879878                        ici16->szDescription[sizeof(ici16->szDescription)-1] = 0;
    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
     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           
    908907}
    909908#endif
    910909
    911910LRESULT MSVIDEO_SendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2, BOOL bFrom32) {
    912     LRESULT     ret;
    913     WINE_HIC    *whic = GlobalLock16(hic);
    914     LPVOID data16 = 0;
    915     BOOL bDrv32;
     911        LRESULT         ret;
     912        WINE_HIC        *whic = GlobalLock16(hic);
     913        LPVOID data16 = 0;
     914        BOOL bDrv32;
    916915
    917916#define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx,%d)\n",(DWORD)hic,lParam1,lParam2,bFrom32?32:16);break;
    918917
    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     }
     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        }
    980979
    981980#undef XX
    982981
    983     if (!whic) return ICERR_BADHANDLE;
    984 
    985     if (whic->driverproc) { /* IC is a function */
     982        if (!whic) return ICERR_BADHANDLE;
     983
     984        if (whic->driverproc) { /* IC is a function */
    986985#ifdef __WIN32OS2__
    987             bDrv32 = whic->privatevfw;
     986                bDrv32 = whic->privatevfw;
    988987#else
    989         bDrv32 = whic->private;
    990 #endif
    991     } else {
    992         bDrv32 = ((GetDriverFlags(whic->hdrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) == WINE_GDF_EXIST);
    993     }
     988                bDrv32 = whic->private;
     989#endif
     990        } else {
     991                bDrv32 = ((GetDriverFlags(whic->hdrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) == WINE_GDF_EXIST);
     992        }
    994993
    995994#ifndef __WIN32OS2__
    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) {
     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) {
    10091008#ifdef __WIN32OS2__
    1010             ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
     1009                ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
    10111010#else
    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     }
     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        }
    10211020
    10221021#ifndef __WIN32OS2__
    1023     if (data16)
    1024         MSVIDEO_UnmapMsg16To32(msg,data16,&lParam1,&lParam2);
    1025 #endif
    1026 
     1022        if (data16)
     1023                MSVIDEO_UnmapMsg16To32(msg,data16,&lParam1,&lParam2);
     1024#endif
     1025 
    10271026 out:
    1028     GlobalUnlock16(hic);
    1029 
    1030     TRACE(" -> 0x%08lx\n",ret);
    1031     return ret;
    1032 }
    1033 
    1034 /***********************************************************************
    1035  *      ICSendMessage           [MSVFW32.@]
     1027        GlobalUnlock16(hic);
     1028       
     1029        TRACE(" -> 0x%08lx\n",ret);
     1030        return ret;
     1031}
     1032
     1033/***********************************************************************
     1034 *              ICSendMessage                   [MSVFW32.@]
    10361035 */
    10371036LRESULT VFWAPI ICSendMessage(HIC hic, UINT msg, DWORD lParam1, DWORD lParam2) {
    1038     return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,TRUE);
     1037        return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,TRUE);
    10391038}
    10401039#ifndef __WIN32OS2__
    10411040/***********************************************************************
    1042  *      ICSendMessage           [MSVIDEO.205]
     1041 *              ICSendMessage                   [MSVIDEO.205]
    10431042 */
    10441043LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD lParam1, DWORD lParam2) {
    1045     return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,FALSE);
    1046 }
    1047 
    1048 /***********************************************************************
    1049  *      _ICMessage          [MSVIDEO.207]
     1044        return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,FALSE);
     1045}
     1046
     1047/***********************************************************************
     1048 *              _ICMessage                      [MSVIDEO.207]
    10501049 */
    10511050LRESULT VFWAPIV ICMessage16(void) {
    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.@]
     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.@]
    10831082 */
    10841083DWORD VFWAPIV ICDrawBegin(
    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] */
     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] */
    11011100{
    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));
     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));
    11251124}
    11261125
    11271126#ifndef __WIN32OS2__
    11281127/***********************************************************************
    1129  *      _ICDrawBegin        [MSVIDEO.232]
     1128 *              _ICDrawBegin            [MSVIDEO.232]
    11301129 */
    11311130DWORD VFWAPIV ICDrawBegin16(
    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] */
     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] */
    11481147{
    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.@]
     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.@]
    11801179 */
    11811180DWORD VFWAPIV ICDraw(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime) {
    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));
     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));
    11931192}
    11941193
    11951194#ifndef __WIN32OS2__
    11961195/***********************************************************************
    1197  *      _ICDraw         [MSVIDEO.234]
     1196 *              _ICDraw                 [MSVIDEO.234]
    11981197 */
    11991198DWORD VFWAPIV ICDraw16(
    1200     HIC16 hic,
    1201     DWORD dwFlags,
    1202     LPVOID lpFormat, /* [???] NOTE: SEGPTR */
    1203     LPVOID lpData,   /* [???] NOTE: SEGPTR */
    1204     DWORD cbData,
    1205     LONG lTime)
     1199        HIC16 hic,
     1200        DWORD dwFlags,
     1201        LPVOID lpFormat, /* [???] NOTE: SEGPTR */
     1202        LPVOID lpData,   /* [???] NOTE: SEGPTR */
     1203        DWORD cbData,
     1204        LONG lTime)
    12061205{
    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.@]
     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.@]
    12221221 */
    12231222LRESULT WINAPI ICClose(HIC hic) {
    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;
     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;
    12371236}
    12381237
    12391238#ifndef __WIN32OS2__
    12401239/***********************************************************************
    1241  *      ICClose         [MSVIDEO.204]
     1240 *              ICClose                 [MSVIDEO.204]
    12421241 */
    12431242LRESULT WINAPI ICClose16(HIC16 hic) {
    1244     return ICClose(hic);
    1245 }
    1246 #endif
    1247 
    1248 /***********************************************************************
    1249  *      MCIWndCreate        [MSVFW32.@]
    1250  *      MCIWndCreateA       [MSVFW32.@]
     1243        return ICClose(hic);
     1244}
     1245#endif
     1246
     1247/***********************************************************************
     1248 *              MCIWndCreate            [MSVFW32.@]
     1249 *              MCIWndCreateA           [MSVFW32.@]
    12511250 */
    12521251HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
    12531252                      DWORD dwStyle,LPCSTR szFile)
    12541253{
    1255     FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
    1256     return 0;
    1257 }
    1258 
    1259 /***********************************************************************
    1260  *      MCIWndCreateW       [MSVFW32.@]
     1254        FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
     1255        return 0;
     1256}
     1257
     1258/***********************************************************************
     1259 *              MCIWndCreateW           [MSVFW32.@]
    12611260 */
    12621261HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
    12631262                      DWORD dwStyle,LPCWSTR szFile)
    12641263{
    1265     FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
    1266     return 0;
    1267 }
     1264        FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
     1265        return 0;
     1266}
Note: See TracChangeset for help on using the changeset viewer.