dlls/msvideo/drawdib.c

   1 /*
   2  * Copyright 2000 Bradley Baetz
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  * FIXME: Some flags are ignored
  19  *
  20  * Handle palettes
  21  */
  22
  23 #include <string.h>
  24 #include "msvideo_private.h"
  25
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(msvideo);
  32
  33 typedef struct tagWINE_HDD {
  34     HDC                 hdc;
  35     INT                 dxDst;
  36     INT                 dyDst;
  37     LPBITMAPINFOHEADER  lpbi;
  38     INT                 dxSrc;
  39     INT                 dySrc;
  40     HPALETTE            hpal;           /* Palette to use for the DIB */
  41     BOOL                begun;          /* DrawDibBegin has been called */
  42     LPBITMAPINFOHEADER  lpbiOut;        /* Output format */
  43     HIC                 hic;            /* HIC for decompression */
  44     HDC                 hMemDC;         /* DC for buffering */
  45     HBITMAP             hOldDib;        /* Original Dib */
  46     HBITMAP             hDib;           /* DibSection */
  47     LPVOID              lpvbits;        /* Buffer for holding decompressed dib */
  48     HDRAWDIB            hSelf;
  49     struct tagWINE_HDD* next;
  50 } WINE_HDD;
  51
  52 static int num_colours(const LPBITMAPINFOHEADER lpbi)
  53 {
  54         if(lpbi->biClrUsed)
  55                 return lpbi->biClrUsed;
  56         if(lpbi->biBitCount<=8)
  57                 return 1<<lpbi->biBitCount;
  58         return 0;
  59 }
  60
  61 static WINE_HDD*        HDD_FirstHdd /* = NULL */;
  62
  63 static WINE_HDD*       MSVIDEO_GetHddPtr(HDRAWDIB hd)
  64 {
  65     WINE_HDD*   hdd;
  66
  67     for (hdd = HDD_FirstHdd; hdd != NULL && hdd->hSelf != hd; hdd = hdd->next);
  68     return hdd;
  69 }
  70
  71 static DWORD HDD_HandleRef = 1;
  72
  73 /***********************************************************************
  74  *              DrawDibOpen             [MSVFW32.@]
  75  */
  76 HDRAWDIB VFWAPI DrawDibOpen(void)
  77 {
  78     WINE_HDD*   whdd;
  79
  80     TRACE("(void)\n");
  81
  82     whdd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_HDD));
  83     TRACE("=> %p\n", whdd);
  84
  85     while (MSVIDEO_GetHddPtr((HDRAWDIB)HDD_HandleRef) != NULL) HDD_HandleRef++;
  86     whdd->hSelf = (HDRAWDIB)HDD_HandleRef++;
  87
  88     whdd->next = HDD_FirstHdd;
  89     HDD_FirstHdd = whdd;
  90
  91     return whdd->hSelf;
  92 }
  93
  94 /***********************************************************************
  95  *              DrawDibClose            [MSVFW32.@]
  96  */
  97 BOOL VFWAPI DrawDibClose(HDRAWDIB hdd)
  98 {
  99     WINE_HDD* whdd = MSVIDEO_GetHddPtr(hdd);
 100     WINE_HDD** p;
 101
 102     TRACE("(%p)\n", hdd);
 103
 104     if (!whdd) return FALSE;
 105
 106     if (whdd->begun) DrawDibEnd(hdd);
 107
 108     for (p = &HDD_FirstHdd; *p != NULL; p = &((*p)->next))
 109     {
 110         if (*p == whdd)
 111         {
 112             *p = whdd->next;
 113             break;
 114         }
 115     }
 116
 117     HeapFree(GetProcessHeap(), 0, whdd);
 118
 119     return TRUE;
 120 }
 121
 122 /***********************************************************************
 123  *              DrawDibEnd              [MSVFW32.@]
 124  */
 125 BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd)
 126 {
 127     BOOL ret = TRUE;
 128     WINE_HDD *whdd = MSVIDEO_GetHddPtr(hdd);
 129
 130     TRACE("(%p)\n", hdd);
 131
 132     whdd->hpal = 0; /* Do not free this */
 133     whdd->hdc = 0;
 134     HeapFree(GetProcessHeap(), 0, whdd->lpbi);
 135     whdd->lpbi = NULL;
 136     HeapFree(GetProcessHeap(), 0, whdd->lpbiOut);
 137     whdd->lpbiOut = NULL;
 138
 139     whdd->begun = FALSE;
 140
 141     /*if (whdd->lpvbits)
 142       HeapFree(GetProcessHeap(), 0, whdd->lpvbuf);*/
 143
 144     if (whdd->hMemDC)
 145     {
 146         SelectObject(whdd->hMemDC, whdd->hOldDib);
 147         DeleteDC(whdd->hMemDC);
 148         whdd->hMemDC = 0;
 149     }
 150
 151     if (whdd->hDib) DeleteObject(whdd->hDib);
 152     whdd->hDib = 0;
 153
 154     if (whdd->hic)
 155     {
 156         ICDecompressEnd(whdd->hic);
 157         ICClose(whdd->hic);
 158         whdd->hic = 0;
 159     }
 160
 161     whdd->lpvbits = NULL;
 162
 163     return ret;
 164 }
 165
 166 /***********************************************************************
 167  *              DrawDibBegin            [MSVFW32.@]
 168  */
 169 BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd,
 170                          HDC      hdc,
 171                          INT      dxDst,
 172                          INT      dyDst,
 173                          LPBITMAPINFOHEADER lpbi,
 174                          INT      dxSrc,
 175                          INT      dySrc,
 176                          UINT     wFlags)
 177 {
 178     BOOL ret = TRUE;
 179     WINE_HDD *whdd;
 180
 181     TRACE("(%p,%p,%d,%d,%p,%d,%d,0x%08lx)\n",
 182           hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, (DWORD)wFlags);
 183
 184     TRACE("lpbi: %ld,%ld/%ld,%d,%d,%ld,%ld,%ld,%ld,%ld,%ld\n",
 185           lpbi->biSize, lpbi->biWidth, lpbi->biHeight, lpbi->biPlanes,
 186           lpbi->biBitCount, lpbi->biCompression, lpbi->biSizeImage,
 187           lpbi->biXPelsPerMeter, lpbi->biYPelsPerMeter, lpbi->biClrUsed,
 188           lpbi->biClrImportant);
 189
 190     if (wFlags & ~(DDF_BUFFER))
 191         FIXME("wFlags == 0x%08x not handled\n", wFlags & ~(DDF_BUFFER));
 192
 193     whdd = MSVIDEO_GetHddPtr(hdd);
 194     if (!whdd) return FALSE;
 195
 196     if (whdd->begun) DrawDibEnd(hdd);
 197
 198     if (lpbi->biCompression)
 199     {
 200         DWORD size = 0;
 201
 202         whdd->hic = ICOpen(ICTYPE_VIDEO, lpbi->biCompression, ICMODE_DECOMPRESS);
 203         if (!whdd->hic)
 204         {
 205             WARN("Could not open IC. biCompression == 0x%08lx\n", lpbi->biCompression);
 206             ret = FALSE;
 207         }
 208
 209         if (ret)
 210         {
 211             size = ICDecompressGetFormat(whdd->hic, lpbi, NULL);
 212             if (size == ICERR_UNSUPPORTED)
 213             {
 214                 WARN("Codec doesn't support GetFormat, giving up.\n");
 215                 ret = FALSE;
 216             }
 217         }
 218
 219         if (ret)
 220         {
 221             whdd->lpbiOut = HeapAlloc(GetProcessHeap(), 0, size);
 222
 223             if (ICDecompressGetFormat(whdd->hic, lpbi, whdd->lpbiOut) != ICERR_OK)
 224                 ret = FALSE;
 225         }
 226
 227         if (ret)
 228         {
 229             /* FIXME: Use Ex functions if available? */
 230             if (ICDecompressBegin(whdd->hic, lpbi, whdd->lpbiOut) != ICERR_OK)
 231                 ret = FALSE;
 232
 233             TRACE("biSizeImage == %ld\n", whdd->lpbiOut->biSizeImage);
 234             TRACE("biCompression == %ld\n", whdd->lpbiOut->biCompression);
 235             TRACE("biBitCount == %d\n", whdd->lpbiOut->biBitCount);
 236         }
 237     }
 238     else
 239     {
 240         DWORD dwSize;
 241         /* No compression */
 242         TRACE("Not compressed!\n");
 243         dwSize = lpbi->biSize + num_colours(lpbi)*sizeof(RGBQUAD);
 244         whdd->lpbiOut = HeapAlloc(GetProcessHeap(), 0, dwSize);
 245         memcpy(whdd->lpbiOut, lpbi, dwSize);
 246     }
 247
 248     if (ret)
 249     {
 250         /*whdd->lpvbuf = HeapAlloc(GetProcessHeap(), 0, whdd->lpbiOut->biSizeImage);*/
 251
 252         whdd->hMemDC = CreateCompatibleDC(hdc);
 253         TRACE("Creating: %ld, %p\n", whdd->lpbiOut->biSize, whdd->lpvbits);
 254         whdd->hDib = CreateDIBSection(whdd->hMemDC, (BITMAPINFO *)whdd->lpbiOut, DIB_RGB_COLORS, &(whdd->lpvbits), 0, 0);
 255         if (whdd->hDib)
 256         {
 257             TRACE("Created: %p,%p\n", whdd->hDib, whdd->lpvbits);
 258         }
 259         else
 260         {
 261             ret = FALSE;
 262             TRACE("Error: %ld\n", GetLastError());
 263         }
 264         whdd->hOldDib = SelectObject(whdd->hMemDC, whdd->hDib);
 265     }
 266
 267     if (ret)
 268     {
 269         whdd->hdc = hdc;
 270         whdd->dxDst = dxDst;
 271         whdd->dyDst = dyDst;
 272         whdd->lpbi = HeapAlloc(GetProcessHeap(), 0, lpbi->biSize);
 273         memcpy(whdd->lpbi, lpbi, lpbi->biSize);
 274         whdd->dxSrc = dxSrc;
 275         whdd->dySrc = dySrc;
 276         whdd->begun = TRUE;
 277         whdd->hpal = 0;
 278     }
 279     else
 280     {
 281         if (whdd->hic)
 282             ICClose(whdd->hic);
 283         HeapFree(GetProcessHeap(), 0, whdd->lpbiOut);
 284         whdd->lpbiOut = NULL;
 285     }
 286
 287     return ret;
 288 }
 289
 290 /**********************************************************************
 291  *              DrawDibDraw             [MSVFW32.@]
 292  */
 293 BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc,
 294                         INT xDst, INT yDst, INT dxDst, INT dyDst,
 295                         LPBITMAPINFOHEADER lpbi,
 296                         LPVOID lpBits,
 297                         INT xSrc, INT ySrc, INT dxSrc, INT dySrc,
 298                         UINT wFlags)
 299 {
 300     WINE_HDD *whdd;
 301     BOOL ret = TRUE;
 302
 303     TRACE("(%p,%p,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08lx)\n",
 304           hdd, hdc, xDst, yDst, dxDst, dyDst, lpbi, lpBits, xSrc, ySrc, dxSrc, dySrc, (DWORD)wFlags);
 305
 306     whdd = MSVIDEO_GetHddPtr(hdd);
 307     if (!whdd) return FALSE;
 308
 309     TRACE("whdd=%p\n", whdd);
 310
 311     if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME | DDF_UPDATE | DDF_DONTDRAW | DDF_BACKGROUNDPAL))
 312         FIXME("wFlags == 0x%08lx not handled\n", (DWORD)wFlags);
 313
 314     if (!lpBits)
 315     {
 316         /* Undocumented? */
 317         lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(num_colours(lpbi)*sizeof(RGBQUAD));
 318     }
 319
 320
 321 #define CHANGED(x) (whdd->x != x)
 322
 323     if ((!whdd->begun) ||
 324         (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc)) ||
 325         (!(wFlags & DDF_SAME_DRAW) && (CHANGED(lpbi) || CHANGED(dxSrc) || CHANGED(dySrc) || CHANGED(dxDst) || CHANGED(dyDst))))
 326     {
 327         TRACE("Something changed!\n");
 328         ret = DrawDibBegin(hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, 0);
 329     }
 330
 331 #undef CHANGED
 332
 333     if ((dxDst == -1) && (dyDst == -1))
 334     {
 335         dxDst = dxSrc;
 336         dyDst = dySrc;
 337     }
 338
 339     if (!(wFlags & DDF_UPDATE))
 340     {
 341         DWORD biSizeImage = lpbi->biSizeImage;
 342
 343         /* biSizeImage may be set to 0 for BI_RGB (uncompressed) bitmaps */
 344         if ((lpbi->biCompression == BI_RGB) && (biSizeImage == 0))
 345             biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
 346
 347         if (lpbi->biCompression)
 348         {
 349             DWORD flags = 0;
 350
 351             TRACE("Compression == 0x%08lx\n", lpbi->biCompression);
 352
 353             if (wFlags & DDF_NOTKEYFRAME)
 354                 flags |= ICDECOMPRESS_NOTKEYFRAME;
 355
 356             ICDecompress(whdd->hic, flags, lpbi, lpBits, whdd->lpbiOut, whdd->lpvbits);
 357         }
 358         else
 359         {
 360             memcpy(whdd->lpvbits, lpBits, biSizeImage);
 361         }
 362     }
 363     if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
 364     {
 365         if ((wFlags & DDF_BACKGROUNDPAL) && ! (wFlags & DDF_SAME_HDC))
 366          SelectPalette(hdc, whdd->hpal, TRUE);
 367         else
 368          SelectPalette(hdc, whdd->hpal, FALSE);
 369     }
 370
 371     if (!(StretchBlt(whdd->hdc, xDst, yDst, dxDst, dyDst, whdd->hMemDC, xSrc, ySrc, dxSrc, dySrc, SRCCOPY)))
 372         ret = FALSE;
 373
 374     return ret;
 375 }
 376
 377 /*************************************************************************
 378  *              DrawDibStart            [MSVFW32.@]
 379  */
 380 BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate) {
 381         FIXME("(%p, %ld), stub\n", hdd, rate);
 382         return TRUE;
 383 }
 384
 385 /*************************************************************************
 386  *              DrawDibStop             [MSVFW32.@]
 387  */
 388 BOOL VFWAPI DrawDibStop(HDRAWDIB hdd) {
 389         FIXME("(%p), stub\n", hdd);
 390         return TRUE;
 391 }
 392
 393 /***********************************************************************
 394  *              DrawDibChangePalette       [MSVFW32.@]
 395  */
 396 BOOL VFWAPI DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
 397 {
 398     FIXME("(%p, 0x%08x, 0x%08x, %p), stub\n", hdd, iStart, iLen, lppe);
 399     return TRUE;
 400 }
 401
 402 /***********************************************************************
 403  *              DrawDibSetPalette       [MSVFW32.@]
 404  */
 405 BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal)
 406 {
 407     WINE_HDD *whdd;
 408
 409     TRACE("(%p, %p)\n", hdd, hpal);
 410
 411     whdd = MSVIDEO_GetHddPtr(hdd);
 412     if (!whdd) return FALSE;
 413
 414     whdd->hpal = hpal;
 415
 416     if (whdd->begun)
 417     {
 418         SelectPalette(whdd->hdc, hpal, 0);
 419         RealizePalette(whdd->hdc);
 420     }
 421
 422     return TRUE;
 423 }
 424
 425 /***********************************************************************
 426  *              DrawDibGetBuffer       [MSVFW32.@]
 427  */
 428 LPVOID VFWAPI DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
 429 {
 430     FIXME("(%p, %p, 0x%08lx, 0x%08lx), stub\n", hdd, lpbi, dwSize, dwFlags);
 431     return NULL;
 432 }
 433
 434 /***********************************************************************
 435  *              DrawDibGetPalette       [MSVFW32.@]
 436  */
 437 HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd)
 438 {
 439     WINE_HDD *whdd;
 440
 441     TRACE("(%p)\n", hdd);
 442
 443     whdd = MSVIDEO_GetHddPtr(hdd);
 444     if (!whdd) return FALSE;
 445
 446     return whdd->hpal;
 447 }
 448
 449 /***********************************************************************
 450  *              DrawDibRealize          [MSVFW32.@]
 451  */
 452 UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground)
 453 {
 454     WINE_HDD *whdd;
 455     HPALETTE oldPal;
 456     UINT ret = 0;
 457
 458     FIXME("(%p, %p, %d), stub\n", hdd, hdc, fBackground);
 459
 460     whdd = MSVIDEO_GetHddPtr(hdd);
 461     if (!whdd) return FALSE;
 462
 463     if (!whdd || !(whdd->begun))
 464     {
 465         ret = 0;
 466         goto out;
 467     }
 468
 469     if (!whdd->hpal)
 470         whdd->hpal = CreateHalftonePalette(hdc);
 471
 472     oldPal = SelectPalette(hdc, whdd->hpal, fBackground);
 473     ret = RealizePalette(hdc);
 474
 475  out:
 476     TRACE("=> %u\n", ret);
 477     return ret;
 478 }
 479
 480 /***********************************************************************
 481  *              DrawDibTime          [MSVFW32.@]
 482  */
 483 BOOL VFWAPI DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime)
 484 {
 485     FIXME("(%p, %p) stub\n", hdd, lpddtime);
 486     return FALSE;
 487 }
 488
 489 /***********************************************************************
 490  *              DrawDibProfileDisplay          [MSVFW32.@]
 491  */
 492 DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
 493 {
 494     FIXME("(%p) stub\n", lpbi);
 495
 496     return PD_CAN_DRAW_DIB;
 497 }