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         if (lpbi->biCompression)
 359         {
 360             DWORD flags = 0;
 361
 362             TRACE("Compression == 0x%08x\n", lpbi->biCompression);
 363
 364             if (wFlags & DDF_NOTKEYFRAME)
 365                 flags |= ICDECOMPRESS_NOTKEYFRAME;
 366
 367             ICDecompress(whdd->hic, flags, lpbi, lpBits, whdd->lpbiOut, whdd->lpvbits);
 368         }
 369         else
 370         {
 371             /* BI_RGB: lpbi->biSizeImage isn't reliable */
 372             DWORD biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
 373             memcpy(whdd->lpvbits, lpBits, biSizeImage);
 374         }
 375     }
 376     if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
 377     {
 378         if ((wFlags & DDF_BACKGROUNDPAL) && ! (wFlags & DDF_SAME_HDC))
 379          SelectPalette(hdc, whdd->hpal, TRUE);
 380         else
 381          SelectPalette(hdc, whdd->hpal, FALSE);
 382     }
 383
 384     if (!(StretchBlt(whdd->hdc, xDst, yDst, dxDst, dyDst, whdd->hMemDC, xSrc, ySrc, dxSrc, dySrc, SRCCOPY)))
 385         ret = FALSE;
 386
 387     return ret;
 388 }
 389
 390 /*************************************************************************
 391  *              DrawDibStart            [MSVFW32.@]
 392  */
 393 BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate) {
 394         FIXME("(%p, %d), stub\n", hdd, rate);
 395         return TRUE;
 396 }
 397
 398 /*************************************************************************
 399  *              DrawDibStop             [MSVFW32.@]
 400  */
 401 BOOL VFWAPI DrawDibStop(HDRAWDIB hdd) {
 402         FIXME("(%p), stub\n", hdd);
 403         return TRUE;
 404 }
 405
 406 /***********************************************************************
 407  *              DrawDibChangePalette       [MSVFW32.@]
 408  */
 409 BOOL VFWAPI DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
 410 {
 411     FIXME("(%p, 0x%08x, 0x%08x, %p), stub\n", hdd, iStart, iLen, lppe);
 412     return TRUE;
 413 }
 414
 415 /***********************************************************************
 416  *              DrawDibSetPalette       [MSVFW32.@]
 417  */
 418 BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal)
 419 {
 420     WINE_HDD *whdd;
 421
 422     TRACE("(%p, %p)\n", hdd, hpal);
 423
 424     whdd = MSVIDEO_GetHddPtr(hdd);
 425     if (!whdd) return FALSE;
 426
 427     whdd->hpal = hpal;
 428
 429     if (whdd->begun)
 430     {
 431         SelectPalette(whdd->hdc, hpal, 0);
 432         RealizePalette(whdd->hdc);
 433     }
 434
 435     return TRUE;
 436 }
 437
 438 /***********************************************************************
 439  *              DrawDibGetBuffer       [MSVFW32.@]
 440  */
 441 LPVOID VFWAPI DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
 442 {
 443     FIXME("(%p, %p, 0x%08x, 0x%08x), stub\n", hdd, lpbi, dwSize, dwFlags);
 444     return NULL;
 445 }
 446
 447 /***********************************************************************
 448  *              DrawDibGetPalette       [MSVFW32.@]
 449  */
 450 HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd)
 451 {
 452     WINE_HDD *whdd;
 453
 454     TRACE("(%p)\n", hdd);
 455
 456     whdd = MSVIDEO_GetHddPtr(hdd);
 457     if (!whdd) return FALSE;
 458
 459     return whdd->hpal;
 460 }
 461
 462 /***********************************************************************
 463  *              DrawDibRealize          [MSVFW32.@]
 464  */
 465 UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground)
 466 {
 467     WINE_HDD *whdd;
 468     UINT ret = 0;
 469
 470     FIXME("(%p, %p, %d), stub\n", hdd, hdc, fBackground);
 471
 472     whdd = MSVIDEO_GetHddPtr(hdd);
 473     if (!whdd) return FALSE;
 474
 475     if (!whdd->begun)
 476     {
 477         ret = 0;
 478         goto out;
 479     }
 480
 481     if (!whdd->hpal)
 482         whdd->hpal = CreateHalftonePalette(hdc);
 483
 484     SelectPalette(hdc, whdd->hpal, fBackground);
 485     ret = RealizePalette(hdc);
 486
 487  out:
 488     TRACE("=> %u\n", ret);
 489     return ret;
 490 }
 491
 492 /***********************************************************************
 493  *              DrawDibTime          [MSVFW32.@]
 494  */
 495 BOOL VFWAPI DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime)
 496 {
 497     FIXME("(%p, %p) stub\n", hdd, lpddtime);
 498     return FALSE;
 499 }
 500
 501 /***********************************************************************
 502  *              DrawDibProfileDisplay          [MSVFW32.@]
 503  */
 504 DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
 505 {
 506     FIXME("(%p) stub\n", lpbi);
 507
 508     return PD_CAN_DRAW_DIB;
 509 }