dlls/msvideo/msvideo16.c

   1 /*
   2  * msvideo 16-bit functions
   3  *
   4  * Copyright 1998 Marcus Meissner
   5  * Copyright 2000 Bradley Baetz
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #define COM_NO_WINDOWS_H
  23 #include <stdio.h>
  24 #include <string.h>
  25
  26 #include "msvideo_private.h"
  27 #include "winver.h"
  28 #include "vfw16.h"
  29 #include "stackframe.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(msvideo);
  33
  34 /* ### start build ### */
  35 extern LONG CALLBACK MSVIDEO_CallTo16_long_lwwll(FARPROC16, LONG, WORD, WORD, LONG, LONG);
  36 /* ### stop build ### */
  37
  38 /***********************************************************************
  39  *              DrawDibOpen             [MSVIDEO.102]
  40  */
  41 HDRAWDIB16 VFWAPI DrawDibOpen16(void)
  42 {
  43     return HDRAWDIB_16(DrawDibOpen());
  44 }
  45
  46 /***********************************************************************
  47  *              DrawDibClose            [MSVIDEO.103]
  48  */
  49 BOOL16 VFWAPI DrawDibClose16(HDRAWDIB16 hdd)
  50 {
  51     return DrawDibClose(HDRAWDIB_32(hdd));
  52 }
  53
  54 /************************************************************************
  55  *              DrawDibBegin            [MSVIDEO.104]
  56  */
  57 BOOL16 VFWAPI DrawDibBegin16(HDRAWDIB16 hdd, HDC16 hdc, INT16 dxDst,
  58                              INT16 dyDst, LPBITMAPINFOHEADER lpbi, INT16 dxSrc,
  59                              INT16 dySrc, UINT16 wFlags)
  60 {
  61     return DrawDibBegin(HDRAWDIB_32(hdd), HDC_32(hdc), dxDst, dyDst, lpbi,
  62                         dxSrc, dySrc, wFlags);
  63 }
  64
  65 /***********************************************************************
  66  *              DrawDibEnd              [MSVIDEO.105]
  67  */
  68 BOOL16 VFWAPI DrawDibEnd16(HDRAWDIB16 hdd)
  69 {
  70     return DrawDibEnd(HDRAWDIB_32(hdd));
  71 }
  72
  73 /**********************************************************************
  74  *              DrawDibDraw             [MSVIDEO.106]
  75  */
  76 BOOL16 VFWAPI DrawDibDraw16(HDRAWDIB16 hdd, HDC16 hdc, INT16 xDst, INT16 yDst,
  77                             INT16 dxDst, INT16 dyDst, LPBITMAPINFOHEADER lpbi,
  78                             LPVOID lpBits, INT16 xSrc, INT16 ySrc, INT16 dxSrc,
  79                             INT16 dySrc, UINT16 wFlags)
  80 {
  81     return DrawDibDraw(HDRAWDIB_32(hdd), HDC_32(hdc), xDst, yDst, dxDst,
  82                        dyDst, lpbi, lpBits, xSrc, ySrc, dxSrc, dySrc, wFlags);
  83 }
  84
  85 /***********************************************************************
  86  *              DrawDibGetPalette       [MSVIDEO.108]
  87  */
  88 HPALETTE16 VFWAPI DrawDibGetPalette16(HDRAWDIB16 hdd)
  89 {
  90     return HPALETTE_16(DrawDibGetPalette(HDRAWDIB_32(hdd)));
  91 }
  92
  93 /***********************************************************************
  94  *              DrawDibSetPalette       [MSVIDEO.110]
  95  */
  96 BOOL16 VFWAPI DrawDibSetPalette16(HDRAWDIB16 hdd, HPALETTE16 hpal)
  97 {
  98     return DrawDibSetPalette(HDRAWDIB_32(hdd), HPALETTE_32(hpal));
  99 }
 100
 101 /***********************************************************************
 102  *              DrawDibRealize          [MSVIDEO.112]
 103  */
 104 UINT16 VFWAPI DrawDibRealize16(HDRAWDIB16 hdd, HDC16 hdc,
 105                                BOOL16 fBackground)
 106 {
 107     return (UINT16)DrawDibRealize(HDRAWDIB_32(hdd), HDC_32(hdc), fBackground);
 108 }
 109
 110 /*************************************************************************
 111  *              DrawDibStart            [MSVIDEO.118]
 112  */
 113 BOOL16 VFWAPI DrawDibStart16(HDRAWDIB16 hdd, DWORD rate)
 114 {
 115     return DrawDibStart(HDRAWDIB_32(hdd), rate);
 116 }
 117
 118 /*************************************************************************
 119  *              DrawDibStop             [MSVIDEO.119]
 120  */
 121 BOOL16 DrawDibStop16(HDRAWDIB16 hdd)
 122 {
 123     return DrawDibStop(HDRAWDIB_32(hdd));
 124 }
 125
 126 /***********************************************************************
 127  *              ICOpen                          [MSVIDEO.203]
 128  */
 129 HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHandler, UINT16 wMode)
 130 {
 131     return HIC_16(ICOpen(fccType, fccHandler, wMode));
 132 }
 133
 134 /***********************************************************************
 135  *              ICClose                 [MSVIDEO.204]
 136  */
 137 LRESULT WINAPI ICClose16(HIC16 hic)
 138 {
 139     return ICClose(HIC_32(hic));
 140 }
 141
 142 /***********************************************************************
 143  *              _ICMessage                      [MSVIDEO.207]
 144  */
 145 LRESULT VFWAPIV ICMessage16(void)
 146 {
 147     HIC16 hic;
 148     UINT16 msg;
 149     UINT16 cb;
 150     LPWORD lpData;
 151     SEGPTR segData;
 152     LRESULT ret;
 153     UINT16 i;
 154
 155     VA_LIST16 valist;
 156
 157     VA_START16(valist);
 158     hic = VA_ARG16(valist, HIC16);
 159     msg = VA_ARG16(valist, UINT16);
 160     cb = VA_ARG16(valist, UINT16);
 161
 162     lpData = HeapAlloc(GetProcessHeap(), 0, cb);
 163
 164     TRACE("0x%08lx, %u, %u, ...)\n", (DWORD) hic, msg, cb);
 165
 166     for (i = 0; i < cb / sizeof(WORD); i++)
 167     {
 168         lpData[i] = VA_ARG16(valist, WORD);
 169     }
 170
 171     VA_END16(valist);
 172     segData = MapLS(lpData);
 173     ret = ICSendMessage16(hic, msg, segData, (DWORD) cb);
 174     UnMapLS(segData);
 175     HeapFree(GetProcessHeap(), 0, lpData);
 176     return ret;
 177 }
 178
 179 /***********************************************************************
 180  *              ICGetInfo                       [MSVIDEO.212]
 181  */
 182 LRESULT VFWAPI ICGetInfo16(HIC16 hic, ICINFO16 * picinfo, DWORD cb)
 183 {
 184     LRESULT ret;
 185
 186     TRACE("(0x%08lx,%p,%ld)\n", (DWORD) hic, picinfo, cb);
 187     ret = ICSendMessage16(hic, ICM_GETINFO, (DWORD) picinfo, cb);
 188     TRACE("     -> 0x%08lx\n", ret);
 189     return ret;
 190 }
 191
 192 /***********************************************************************
 193  *              ICLocate                        [MSVIDEO.213]
 194  */
 195 HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler,
 196                         LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut,
 197                         WORD wFlags)
 198 {
 199     return HIC_16(ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags));
 200 }
 201
 202 /***********************************************************************
 203  *              _ICCompress                     [MSVIDEO.224]
 204  */
 205 DWORD VFWAPIV ICCompress16(HIC16 hic, DWORD dwFlags,
 206                            LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
 207                            LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits,
 208                            LPDWORD lpckid, LPDWORD lpdwFlags,
 209                            LONG lFrameNum, DWORD dwFrameSize,
 210                            DWORD dwQuality, LPBITMAPINFOHEADER lpbiPrev,
 211                            LPVOID lpPrev)
 212 {
 213     DWORD ret;
 214     ICCOMPRESS iccmp;
 215     SEGPTR seg_iccmp;
 216
 217     TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n", (DWORD) hic, dwFlags,
 218           lpbiOutput, lpData, lpbiInput, lpBits);
 219
 220     iccmp.dwFlags = dwFlags;
 221
 222     iccmp.lpbiOutput = lpbiOutput;
 223     iccmp.lpOutput = lpData;
 224     iccmp.lpbiInput = lpbiInput;
 225     iccmp.lpInput = lpBits;
 226
 227     iccmp.lpckid = lpckid;
 228     iccmp.lpdwFlags = lpdwFlags;
 229     iccmp.lFrameNum = lFrameNum;
 230     iccmp.dwFrameSize = dwFrameSize;
 231     iccmp.dwQuality = dwQuality;
 232     iccmp.lpbiPrev = lpbiPrev;
 233     iccmp.lpPrev = lpPrev;
 234     seg_iccmp = MapLS(&iccmp);
 235     ret = ICSendMessage16(hic, ICM_COMPRESS, seg_iccmp, sizeof(ICCOMPRESS));
 236     UnMapLS(seg_iccmp);
 237     return ret;
 238 }
 239
 240 /***********************************************************************
 241  *              _ICDecompress                   [MSVIDEO.230]
 242  */
 243 DWORD VFWAPIV ICDecompress16(HIC16 hic, DWORD dwFlags,
 244                              LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData,
 245                              LPBITMAPINFOHEADER lpbi, LPVOID lpBits)
 246 {
 247     ICDECOMPRESS icd;
 248     SEGPTR segptr;
 249     DWORD ret;
 250
 251     TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n", (DWORD) hic, dwFlags, lpbiFormat,
 252           lpData, lpbi, lpBits);
 253
 254     icd.dwFlags = dwFlags;
 255     icd.lpbiInput = lpbiFormat;
 256     icd.lpInput = lpData;
 257     icd.lpbiOutput = lpbi;
 258     icd.lpOutput = lpBits;
 259     icd.ckid = 0;
 260     segptr = MapLS(&icd);
 261     ret = ICSendMessage16(hic, ICM_DECOMPRESS, segptr, sizeof(ICDECOMPRESS));
 262     UnMapLS(segptr);
 263     return ret;
 264 }
 265
 266 /***********************************************************************
 267  *              _ICDrawBegin            [MSVIDEO.232]
 268  */
 269 DWORD VFWAPIV ICDrawBegin16(HIC16 hic,          /* [in] */
 270                             DWORD dwFlags,      /* [in] flags */
 271                             HPALETTE16 hpal,    /* [in] palette to draw with */
 272                             HWND16 hwnd,        /* [in] window to draw to */
 273                             HDC16 hdc,          /* [in] HDC to draw to */
 274                             INT16 xDst,         /* [in] destination rectangle */
 275                             INT16 yDst,         /* [in] */
 276                             INT16 dxDst,        /* [in] */
 277                             INT16 dyDst,        /* [in] */
 278                             LPBITMAPINFOHEADER lpbi,    /* [in] format of frame to draw NOTE: SEGPTR */
 279                             INT16 xSrc,         /* [in] source rectangle */
 280                             INT16 ySrc,         /* [in] */
 281                             INT16 dxSrc,        /* [in] */
 282                             INT16 dySrc,        /* [in] */
 283                             DWORD dwRate,       /* [in] frames/second = (dwRate/dwScale) */
 284                             DWORD dwScale)      /* [in] */
 285 {
 286     DWORD ret;
 287     ICDRAWBEGIN16 icdb;
 288     SEGPTR seg_icdb;
 289
 290     TRACE ("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
 291            (DWORD) hic, dwFlags, (DWORD) hpal, (DWORD) hwnd, (DWORD) hdc,
 292            xDst, yDst, dxDst, dyDst, lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate,
 293            dwScale);
 294
 295     icdb.dwFlags = dwFlags;
 296     icdb.hpal = hpal;
 297     icdb.hwnd = hwnd;
 298     icdb.hdc = hdc;
 299     icdb.xDst = xDst;
 300     icdb.yDst = yDst;
 301     icdb.dxDst = dxDst;
 302     icdb.dyDst = dyDst;
 303     icdb.lpbi = lpbi;           /* Keep this as SEGPTR for the mapping code to deal with */
 304     icdb.xSrc = xSrc;
 305     icdb.ySrc = ySrc;
 306     icdb.dxSrc = dxSrc;
 307     icdb.dySrc = dySrc;
 308     icdb.dwRate = dwRate;
 309     icdb.dwScale = dwScale;
 310     seg_icdb = MapLS(&icdb);
 311     ret = (DWORD) ICSendMessage16(hic, ICM_DRAW_BEGIN, seg_icdb,
 312                                   sizeof(ICDRAWBEGIN16));
 313     UnMapLS(seg_icdb);
 314     return ret;
 315 }
 316
 317 /***********************************************************************
 318  *              _ICDraw                 [MSVIDEO.234]
 319  */
 320 DWORD VFWAPIV ICDraw16(HIC16 hic, DWORD dwFlags,
 321                        LPVOID lpFormat, /* [???] NOTE: SEGPTR */
 322                        LPVOID lpData,   /* [???] NOTE: SEGPTR */
 323                        DWORD cbData, LONG lTime)
 324 {
 325     DWORD ret;
 326     ICDRAW icd;
 327     SEGPTR seg_icd;
 328
 329     TRACE("(0x%08lx,0x%08lx,%p,%p,%ld,%ld)\n", (DWORD) hic, dwFlags,
 330           lpFormat, lpData, cbData, lTime);
 331     icd.dwFlags = dwFlags;
 332     icd.lpFormat = lpFormat;
 333     icd.lpData = lpData;
 334     icd.cbData = cbData;
 335     icd.lTime = lTime;
 336     seg_icd = MapLS(&icd);
 337     ret = ICSendMessage16(hic, ICM_DRAW, seg_icd, sizeof(ICDRAW));
 338     UnMapLS(seg_icd);
 339     return ret;
 340 }
 341
 342 /***********************************************************************
 343  *              ICGetDisplayFormat                      [MSVIDEO.239]
 344  */
 345 HIC16 VFWAPI ICGetDisplayFormat16(HIC16 hic, LPBITMAPINFOHEADER lpbiIn,
 346                                   LPBITMAPINFOHEADER lpbiOut, INT16 depth,
 347                                   INT16 dx, INT16 dy)
 348 {
 349     return HIC_16(ICGetDisplayFormat(HIC_32(hic), lpbiIn, lpbiOut, depth,
 350                                      dx, dy));
 351 }
 352
 353 #define COPY(x,y) (x->y = x##16->y);
 354 #define COPYPTR(x,y) (x->y = MapSL((SEGPTR)x##16->y));
 355
 356 /******************************************************************
 357  *              MSVIDEO_MapICDEX16To32
 358  *
 359  *
 360  */
 361 static LPVOID MSVIDEO_MapICDEX16To32(LPDWORD lParam)
 362 {
 363     LPVOID ret;
 364
 365     ICDECOMPRESSEX *icdx = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDECOMPRESSEX));
 366     ICDECOMPRESSEX16 *icdx16 = MapSL(*lParam);
 367     ret = icdx16;
 368
 369     COPY(icdx, dwFlags);
 370     COPYPTR(icdx, lpbiSrc);
 371     COPYPTR(icdx, lpSrc);
 372     COPYPTR(icdx, lpbiDst);
 373     COPYPTR(icdx, lpDst);
 374     COPY(icdx, xDst);
 375     COPY(icdx, yDst);
 376     COPY(icdx, dxDst);
 377     COPY(icdx, dyDst);
 378     COPY(icdx, xSrc);
 379     COPY(icdx, ySrc);
 380     COPY(icdx, dxSrc);
 381     COPY(icdx, dySrc);
 382
 383     *lParam = (DWORD)(icdx);
 384     return ret;
 385 }
 386
 387 /******************************************************************
 388  *              MSVIDEO_MapMsg16To32
 389  *
 390  *
 391  */
 392 static LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2)
 393 {
 394     LPVOID ret = 0;
 395
 396     TRACE("Mapping %d\n", msg);
 397
 398     switch (msg)
 399     {
 400     case DRV_LOAD:
 401     case DRV_ENABLE:
 402     case DRV_CLOSE:
 403     case DRV_DISABLE:
 404     case DRV_FREE:
 405     case ICM_ABOUT:
 406     case ICM_CONFIGURE:
 407     case ICM_COMPRESS_END:
 408     case ICM_DECOMPRESS_END:
 409     case ICM_DECOMPRESSEX_END:
 410     case ICM_SETQUALITY:
 411     case ICM_DRAW_START_PLAY:
 412     case ICM_DRAW_STOP_PLAY:
 413     case ICM_DRAW_REALIZE:
 414     case ICM_DRAW_RENDERBUFFER:
 415     case ICM_DRAW_END:
 416         break;
 417     case DRV_OPEN:
 418     case ICM_GETDEFAULTQUALITY:
 419     case ICM_GETQUALITY:
 420     case ICM_SETSTATE:
 421     case ICM_DRAW_WINDOW:
 422     case ICM_GETBUFFERSWANTED:
 423         *lParam1 = (DWORD)MapSL(*lParam1);
 424         break;
 425     case ICM_GETINFO:
 426         {
 427             ICINFO *ici = HeapAlloc(GetProcessHeap(), 0, sizeof(ICINFO));
 428             ICINFO16 *ici16;
 429
 430             ici16 = MapSL(*lParam1);
 431             ret = ici16;
 432
 433             ici->dwSize = sizeof(ICINFO);
 434             COPY(ici, fccType);
 435             COPY(ici, fccHandler);
 436             COPY(ici, dwFlags);
 437             COPY(ici, dwVersion);
 438             COPY(ici, dwVersionICM);
 439             MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
 440             MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
 441             MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
 442             *lParam1 = (DWORD)(ici);
 443             *lParam2 = sizeof(ICINFO);
 444         }
 445         break;
 446     case ICM_COMPRESS:
 447         {
 448             ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(), 0, sizeof(ICCOMPRESS));
 449             ICCOMPRESS *icc16;
 450
 451             icc16 = MapSL(*lParam1);
 452             ret = icc16;
 453
 454             COPY(icc, dwFlags);
 455             COPYPTR(icc, lpbiOutput);
 456             COPYPTR(icc, lpOutput);
 457             COPYPTR(icc, lpbiInput);
 458             COPYPTR(icc, lpInput);
 459             COPYPTR(icc, lpckid);
 460             COPYPTR(icc, lpdwFlags);
 461             COPY(icc, lFrameNum);
 462             COPY(icc, dwFrameSize);
 463             COPY(icc, dwQuality);
 464             COPYPTR(icc, lpbiPrev);
 465             COPYPTR(icc, lpPrev);
 466
 467             *lParam1 = (DWORD)(icc);
 468             *lParam2 = sizeof(ICCOMPRESS);
 469         }
 470         break;
 471     case ICM_DECOMPRESS:
 472         {
 473             ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDECOMPRESS));
 474             ICDECOMPRESS *icd16; /* Same structure except for the pointers */
 475
 476             icd16 = MapSL(*lParam1);
 477             ret = icd16;
 478
 479             COPY(icd, dwFlags);
 480             COPYPTR(icd, lpbiInput);
 481             COPYPTR(icd, lpInput);
 482             COPYPTR(icd, lpbiOutput);
 483             COPYPTR(icd, lpOutput);
 484             COPY(icd, ckid);
 485
 486             *lParam1 = (DWORD)(icd);
 487             *lParam2 = sizeof(ICDECOMPRESS);
 488         }
 489         break;
 490     case ICM_COMPRESS_BEGIN:
 491     case ICM_COMPRESS_GET_FORMAT:
 492     case ICM_COMPRESS_GET_SIZE:
 493     case ICM_COMPRESS_QUERY:
 494     case ICM_DECOMPRESS_GET_FORMAT:
 495     case ICM_DECOMPRESS_QUERY:
 496     case ICM_DECOMPRESS_BEGIN:
 497     case ICM_DECOMPRESS_SET_PALETTE:
 498     case ICM_DECOMPRESS_GET_PALETTE:
 499         *lParam1 = (DWORD)MapSL(*lParam1);
 500         *lParam2 = (DWORD)MapSL(*lParam2);
 501         break;
 502     case ICM_DECOMPRESSEX_QUERY:
 503         if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
 504             WARN("*lParam2 has unknown value %p\n", (ICDECOMPRESSEX16*)*lParam2);
 505         /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
 506          * This is because of ICMessage(). Special case it?
 507          {
 508          LPVOID* addr = HeapAlloc(GetProcessHeap(), 0, 2*sizeof(LPVOID));
 509          addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
 510          if (*lParam2)
 511          addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
 512          else
 513          addr[1] = 0;
 514
 515          ret = addr;
 516          }
 517          break;*/
 518     case ICM_DECOMPRESSEX_BEGIN:
 519     case ICM_DECOMPRESSEX:
 520         ret = MSVIDEO_MapICDEX16To32(lParam1);
 521         *lParam2 = sizeof(ICDECOMPRESSEX);
 522         break;
 523     case ICM_DRAW_BEGIN:
 524         {
 525             ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWBEGIN));
 526             ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
 527             ret = icdb16;
 528
 529             COPY(icdb, dwFlags);
 530             icdb->hpal = HPALETTE_32(icdb16->hpal);
 531             icdb->hwnd = HWND_32(icdb16->hwnd);
 532             icdb->hdc = HDC_32(icdb16->hdc);
 533             COPY(icdb, xDst);
 534             COPY(icdb, yDst);
 535             COPY(icdb, dxDst);
 536             COPY(icdb, dyDst);
 537             COPYPTR(icdb, lpbi);
 538             COPY(icdb, xSrc);
 539             COPY(icdb, ySrc);
 540             COPY(icdb, dxSrc);
 541             COPY(icdb, dySrc);
 542             COPY(icdb, dwRate);
 543             COPY(icdb, dwScale);
 544
 545             *lParam1 = (DWORD)(icdb);
 546             *lParam2 = sizeof(ICDRAWBEGIN);
 547         }
 548         break;
 549     case ICM_DRAW_SUGGESTFORMAT:
 550         {
 551             ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWSUGGEST));
 552             ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
 553
 554             ret = icds16;
 555
 556             COPY(icds, dwFlags);
 557             COPYPTR(icds, lpbiIn);
 558             COPYPTR(icds, lpbiSuggest);
 559             COPY(icds, dxSrc);
 560             COPY(icds, dySrc);
 561             COPY(icds, dxDst);
 562             COPY(icds, dyDst);
 563             icds->hicDecompressor = HIC_32(icds16->hicDecompressor);
 564
 565             *lParam1 = (DWORD)(icds);
 566             *lParam2 = sizeof(ICDRAWSUGGEST);
 567         }
 568         break;
 569     case ICM_DRAW:
 570         {
 571             ICDRAW *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAW));
 572             ICDRAW *icd16 = MapSL(*lParam1);
 573             ret = icd16;
 574
 575             COPY(icd, dwFlags);
 576             COPYPTR(icd, lpFormat);
 577             COPYPTR(icd, lpData);
 578             COPY(icd, cbData);
 579             COPY(icd, lTime);
 580
 581             *lParam1 = (DWORD)(icd);
 582             *lParam2 = sizeof(ICDRAW);
 583         }
 584         break;
 585     case ICM_DRAW_START:
 586     case ICM_DRAW_STOP:
 587         break;
 588     default:
 589         FIXME("%d is not yet handled. Expect a crash.\n", msg);
 590     }
 591     return ret;
 592 }
 593
 594 #undef COPY
 595 #undef COPYPTR
 596
 597 /******************************************************************
 598  *              MSVIDEO_UnmapMsg16To32
 599  *
 600  *
 601  */
 602 static void MSVIDEO_UnmapMsg16To32(UINT msg, LPVOID data16, LPDWORD lParam1, LPDWORD lParam2)
 603 {
 604     TRACE("Unmapping %d\n", msg);
 605
 606 #define UNCOPY(x, y) (x##16->y = x->y);
 607
 608     switch (msg)
 609     {
 610     case ICM_GETINFO:
 611         {
 612             ICINFO *ici = (ICINFO*)(*lParam1);
 613             ICINFO16 *ici16 = (ICINFO16*)data16;
 614
 615             UNCOPY(ici, fccType);
 616             UNCOPY(ici, fccHandler);
 617             UNCOPY(ici, dwFlags);
 618             UNCOPY(ici, dwVersion);
 619             UNCOPY(ici, dwVersionICM);
 620             WideCharToMultiByte( CP_ACP, 0, ici->szName, -1, ici16->szName,
 621                                  sizeof(ici16->szName), NULL, NULL );
 622             ici16->szName[sizeof(ici16->szName)-1] = 0;
 623             WideCharToMultiByte( CP_ACP, 0, ici->szDescription, -1, ici16->szDescription,
 624                                  sizeof(ici16->szDescription), NULL, NULL );
 625             ici16->szDescription[sizeof(ici16->szDescription)-1] = 0;
 626             /* This just gives garbage for some reason - BB
 627                lstrcpynWtoA(ici16->szDriver, ici->szDriver, 128);*/
 628
 629             HeapFree(GetProcessHeap(), 0, ici);
 630         }
 631         break;
 632     case ICM_DECOMPRESS_QUERY:
 633         /*{
 634           LPVOID* x = data16;
 635           HeapFree(GetProcessHeap(), 0, x[0]);
 636           if (x[1])
 637           HeapFree(GetProcessHeap(), 0, x[1]);
 638           }
 639           break;*/
 640     case ICM_COMPRESS:
 641     case ICM_DECOMPRESS:
 642     case ICM_DECOMPRESSEX_QUERY:
 643     case ICM_DECOMPRESSEX_BEGIN:
 644     case ICM_DECOMPRESSEX:
 645     case ICM_DRAW_BEGIN:
 646     case ICM_DRAW_SUGGESTFORMAT:
 647     case ICM_DRAW:
 648         HeapFree(GetProcessHeap(), 0, data16);
 649         break;
 650     default:
 651         ERR("Unmapping unmapped msg %d\n", msg);
 652     }
 653 #undef UNCOPY
 654 }
 655
 656 /***********************************************************************
 657  *              ICInfo                          [MSVIDEO.200]
 658  */
 659 BOOL16 VFWAPI ICInfo16(DWORD fccType, DWORD fccHandler, ICINFO16 *lpicinfo)
 660 {
 661     BOOL16 ret;
 662     LPVOID lpv;
 663     DWORD lParam = (DWORD)lpicinfo;
 664     DWORD size = ((ICINFO*)(MapSL((SEGPTR)lpicinfo)))->dwSize;
 665
 666     /* Use the mapping functions to map the ICINFO structure */
 667     lpv = MSVIDEO_MapMsg16To32(ICM_GETINFO, &lParam, &size);
 668
 669     ret = ICInfo(fccType, fccHandler, (ICINFO*)lParam);
 670
 671     MSVIDEO_UnmapMsg16To32(ICM_GETINFO, lpv, &lParam, &size);
 672
 673     return ret;
 674 }
 675
 676 /******************************************************************
 677  *              IC_Callback3216
 678  *
 679  *
 680  */
 681 static  LRESULT CALLBACK  IC_Callback3216(HIC hic, HDRVR hdrv, UINT msg, DWORD lp1, DWORD lp2)
 682 {
 683     WINE_HIC*   whic;
 684     LRESULT     ret = 0;
 685
 686     whic = MSVIDEO_GetHicPtr(hic);
 687     if (whic)
 688     {
 689         switch (msg)
 690         {
 691         case DRV_OPEN:
 692             lp2 = (DWORD)MapLS((void*)lp2);
 693             break;
 694         }
 695
 696         ret = MSVIDEO_CallTo16_long_lwwll((FARPROC16)whic->driverproc16,
 697                                           HIC_16(hic), HDRVR_16(whic->hdrv), msg, lp1, lp2);
 698         switch (msg)
 699         {
 700         case DRV_OPEN:
 701             UnMapLS(lp2);
 702             break;
 703         }
 704     }
 705     else ret = ICERR_BADHANDLE;
 706     return ret;
 707 }
 708
 709 /***********************************************************************
 710  *              ICOpenFunction                  [MSVIDEO.206]
 711  */
 712 HIC16 VFWAPI ICOpenFunction16(DWORD fccType, DWORD fccHandler, UINT16 wMode, FARPROC16 lpfnHandler)
 713 {
 714     HIC         hic32;
 715
 716     hic32 = MSVIDEO_OpenFunction(fccType, fccHandler, wMode,
 717                                  (DRIVERPROC)IC_Callback3216, (DWORD)lpfnHandler);
 718     return HIC_16(hic32);
 719 }
 720
 721 /***********************************************************************
 722  *              ICSendMessage                   [MSVIDEO.205]
 723  */
 724 LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD lParam1, DWORD lParam2)
 725 {
 726     LRESULT     ret = ICERR_BADHANDLE;
 727     WINE_HIC*   whic;
 728
 729     whic = MSVIDEO_GetHicPtr(HIC_32(hic));
 730     if (whic)
 731     {
 732         /* we've got a 16 bit driver proc... call it directly */
 733         if (whic->driverproc16)
 734         {
 735             ret = MSVIDEO_CallTo16_long_lwwll((FARPROC16)whic->driverproc16,
 736                                               (LONG)whic->hdrv, HIC_16(hic), msg, lParam1, lParam2);
 737         }
 738         else
 739         {
 740             /* map the message for a 32 bit infrastructure, and pass it along */
 741             void*       data16 = MSVIDEO_MapMsg16To32(msg, &lParam1, &lParam2);
 742
 743             ret = MSVIDEO_SendMessage(HIC_32(hic), msg, lParam1, lParam2);
 744             if (data16)
 745                 MSVIDEO_UnmapMsg16To32(msg, data16, &lParam1, &lParam2);
 746         }
 747     }
 748     return ret;
 749 }
 750
 751 /***********************************************************************
 752  *              VideoCapDriverDescAndVer        [MSVIDEO.22]
 753  */
 754 DWORD WINAPI VideoCapDriverDescAndVer16(WORD nr, LPSTR buf1, WORD buf1len,
 755                                         LPSTR buf2, WORD buf2len)
 756 {
 757     DWORD       verhandle;
 758     WORD        xnr = nr;
 759     DWORD       infosize;
 760     UINT        subblocklen;
 761     char        *s,  buf[2000],  fn[260];
 762     LPBYTE      infobuf;
 763     LPVOID      subblock;
 764
 765     TRACE("(%d,%p,%d,%p,%d)\n", nr, buf1, buf1len, buf2, buf2len);
 766     if (GetPrivateProfileStringA("drivers32", NULL, NULL, buf, sizeof(buf), "system.ini"))
 767     {
 768         s = buf;
 769         while (*s)
 770         {
 771             if (!strncasecmp(s, "vid", 3))
 772             {
 773                 if (!xnr) break;
 774                 xnr--;
 775             }
 776             s = s + strlen(s) + 1; /* either next char or \0 */
 777         }
 778     }
 779     else
 780         return 20; /* hmm, out of entries even if we don't have any */
 781     if (xnr)
 782     {
 783         FIXME("No more VID* entries found\n");
 784         return 20;
 785     }
 786     GetPrivateProfileStringA("drivers32", s, NULL, fn, sizeof(fn), "system.ini");
 787     infosize = GetFileVersionInfoSizeA(fn, &verhandle);
 788     if (!infosize)
 789     {
 790         TRACE("%s has no fileversioninfo.\n", fn);
 791         return 18;
 792     }
 793     infobuf = HeapAlloc(GetProcessHeap(), 0, infosize);
 794     if (GetFileVersionInfoA(fn, verhandle, infosize, infobuf))
 795     {
 796         char    vbuf[200];
 797         /* Yes, two space behind : */
 798         /* FIXME: test for buflen */
 799         sprintf(vbuf, "Version:  %d.%d.%d.%d\n",
 800                 ((WORD*)infobuf)[0x0f],
 801                 ((WORD*)infobuf)[0x0e],
 802                 ((WORD*)infobuf)[0x11],
 803                 ((WORD*)infobuf)[0x10]
 804             );
 805         TRACE("version of %s is %s\n", fn, vbuf);
 806         strncpy(buf2, vbuf, buf2len);
 807     }
 808     else
 809     {
 810         TRACE("GetFileVersionInfoA failed for %s.\n", fn);
 811         strncpy(buf2, fn, buf2len); /* msvideo.dll appears to copy fn*/
 812     }
 813     /* FIXME: language problem? */
 814     if (VerQueryValueA( infobuf,
 815                         "\\StringFileInfo\\040904E4\\FileDescription",
 816                         &subblock,
 817                         &subblocklen
 818             ))
 819     {
 820         TRACE("VQA returned %s\n", (LPCSTR)subblock);
 821         strncpy(buf1, subblock, buf1len);
 822     }
 823     else
 824     {
 825         TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
 826         strncpy(buf1, fn, buf1len); /* msvideo.dll appears to copy fn*/
 827     }
 828     HeapFree(GetProcessHeap(), 0, infobuf);
 829     return 0;
 830 }
 831
 832 /******************************************************************
 833  *              IC_CallTo16
 834  *
 835  *
 836  */
 837 static  LRESULT CALLBACK IC_CallTo16(HDRVR hdrv, HIC hic, UINT msg, LPARAM lp1, LPARAM lp2)
 838 {
 839 #if 0
 840     WINE_HIC*   whic = IC_GetPtr(hic);
 841     LRESULT     ret = 0;
 842
 843
 844     if (whic->driverproc)
 845     {
 846         ret = whic->driverproc(hic, whic->hdrv, msg, lParam1, lParam2);
 847     }
 848     else
 849     {
 850         ret = SendDriverMessage(whic->hdrv, msg, lParam1, lParam2);
 851     }
 852 #else
 853     FIXME("No 32=>16 conversion yet\n");
 854 #endif
 855     return 0;
 856 }
 857
 858 /**************************************************************************
 859  *                      DllEntryPoint (MSVIDEO.300)
 860  *
 861  * MSVIDEO DLL entry point
 862  *
 863  */
 864 BOOL WINAPI VIDEO_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
 865                           WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
 866 {
 867     switch (fdwReason)
 868     {
 869     case DLL_PROCESS_ATTACH:
 870         /* hook in our 16 bit management functions */
 871         pFnCallTo16 = IC_CallTo16;
 872         break;
 873     case DLL_PROCESS_DETACH:
 874         /* remove our 16 bit management functions */
 875         pFnCallTo16 = NULL;
 876         break;
 877     case DLL_THREAD_ATTACH:
 878     case DLL_THREAD_DETACH:
 879         break;
 880     }
 881     return TRUE;
 882 }