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