ReactOS  0.4.12-dev-918-g6c6e7b8
drawdib.c
Go to the documentation of this file.
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 
36 
37 typedef struct tagWINE_HDD {
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 */
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 
68 {
69  WINE_HDD* hdd;
70 
71  for (hdd = HDD_FirstHdd; hdd != NULL && hdd->hSelf != hd; hdd = hdd->next);
72  return hdd;
73 }
74 
76 
77 /***********************************************************************
78  * DrawDibOpen [MSVFW32.@]
79  */
81 {
82  WINE_HDD* whdd;
83 
84  TRACE("(void)\n");
85 
87  TRACE("=> %p\n", whdd);
88 
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  */
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  */
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  */
176  HDC hdc,
177  INT dxDst,
178  INT dyDst,
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",
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 
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  {
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  */
309  INT xDst, INT yDst, INT dxDst, INT dyDst,
311  LPVOID lpBits,
312  INT xSrc, INT ySrc, INT dxSrc, INT dySrc,
313  UINT wFlags)
314 {
315  WINE_HDD *whdd;
316  BOOL ret;
317  int reopen = 0;
318 
319  TRACE("(%p,%p,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08x)\n",
320  hdd, hdc, xDst, yDst, dxDst, dyDst, lpbi, lpBits, xSrc, ySrc, dxSrc, dySrc, wFlags);
321 
322  whdd = MSVIDEO_GetHddPtr(hdd);
323  if (!whdd) return FALSE;
324 
325  TRACE("whdd=%p\n", whdd);
326 
328  FIXME("wFlags == 0x%08x not handled\n", wFlags);
329 
330  if (!lpBits)
331  {
332  /* Undocumented? */
333  lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(num_colours(lpbi)*sizeof(RGBQUAD));
334  }
335 
336 
337 #define CHANGED(x) (whdd->x != x)
338 
339  /* Check if anything changed from the parameters passed and our struct.
340  * If anything changed we need to run DrawDibBegin again to ensure we
341  * can support the changes.
342  */
343  if (!whdd->begun)
344  reopen = 1;
345  else if (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc))
346  reopen = 2;
347  else if (!(wFlags & DDF_SAME_DRAW))
348  {
349  if (CHANGED(lpbi) && memcmp(lpbi, whdd->lpbi, sizeof(*lpbi))) reopen = 3;
350  else if (CHANGED(dxSrc)) reopen = 4;
351  else if (CHANGED(dySrc)) reopen = 5;
352  else if (CHANGED(dxDst)) reopen = 6;
353  else if (CHANGED(dyDst)) reopen = 7;
354  }
355  if (reopen)
356  {
357  TRACE("Something changed (reason %d)!\n", reopen);
358  ret = DrawDibBegin(hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, 0);
359  if (!ret)
360  return ret;
361  }
362 
363 #undef CHANGED
364 
365  /* If source dimensions are not specified derive them from bitmap header */
366  if (dxSrc == -1 && dySrc == -1)
367  {
368  dxSrc = lpbi->biWidth;
369  dySrc = lpbi->biHeight;
370  }
371  /* If destination dimensions are not specified derive them from source */
372  if (dxDst == -1 && dyDst == -1)
373  {
374  dxDst = dxSrc;
375  dyDst = dySrc;
376  }
377 
378  if (!(wFlags & DDF_UPDATE))
379  {
380  if (lpbi->biCompression)
381  {
382  DWORD flags = 0;
383 
384  TRACE("Compression == 0x%08x\n", lpbi->biCompression);
385 
386  if (wFlags & DDF_NOTKEYFRAME)
388 
389  ICDecompress(whdd->hic, flags, lpbi, lpBits, whdd->lpbiOut, whdd->lpvbits);
390  }
391  else
392  {
393  /* BI_RGB: lpbi->biSizeImage isn't reliable */
394  DWORD biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
395  memcpy(whdd->lpvbits, lpBits, biSizeImage);
396  }
397  }
398  if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
399  {
400  if ((wFlags & DDF_BACKGROUNDPAL) && ! (wFlags & DDF_SAME_HDC))
401  SelectPalette(hdc, whdd->hpal, TRUE);
402  else
403  SelectPalette(hdc, whdd->hpal, FALSE);
404  }
405 
406  ret = StretchBlt(whdd->hdc, xDst, yDst, dxDst, dyDst, whdd->hMemDC, xSrc, ySrc, dxSrc, dySrc, SRCCOPY);
407  TRACE("Painting %dx%d at %d,%d from %dx%d at %d,%d -> %d\n",
408  dxDst, dyDst, xDst, yDst, dxSrc, dySrc, xSrc, ySrc, ret);
409 
410  return ret;
411 }
412 
413 /*************************************************************************
414  * DrawDibStart [MSVFW32.@]
415  */
417  FIXME("(%p, %d), stub\n", hdd, rate);
418  return TRUE;
419 }
420 
421 /*************************************************************************
422  * DrawDibStop [MSVFW32.@]
423  */
425  FIXME("(%p), stub\n", hdd);
426  return TRUE;
427 }
428 
429 /***********************************************************************
430  * DrawDibChangePalette [MSVFW32.@]
431  */
433 {
434  FIXME("(%p, 0x%08x, 0x%08x, %p), stub\n", hdd, iStart, iLen, lppe);
435  return TRUE;
436 }
437 
438 /***********************************************************************
439  * DrawDibSetPalette [MSVFW32.@]
440  */
442 {
443  WINE_HDD *whdd;
444 
445  TRACE("(%p, %p)\n", hdd, hpal);
446 
447  whdd = MSVIDEO_GetHddPtr(hdd);
448  if (!whdd) return FALSE;
449 
450  whdd->hpal = hpal;
451 
452  if (whdd->begun)
453  {
454  SelectPalette(whdd->hdc, hpal, 0);
455  RealizePalette(whdd->hdc);
456  }
457 
458  return TRUE;
459 }
460 
461 /***********************************************************************
462  * DrawDibGetBuffer [MSVFW32.@]
463  */
465 {
466  FIXME("(%p, %p, 0x%08x, 0x%08x), stub\n", hdd, lpbi, dwSize, dwFlags);
467  return NULL;
468 }
469 
470 /***********************************************************************
471  * DrawDibGetPalette [MSVFW32.@]
472  */
474 {
475  WINE_HDD *whdd;
476 
477  TRACE("(%p)\n", hdd);
478 
479  whdd = MSVIDEO_GetHddPtr(hdd);
480  if (!whdd) return FALSE;
481 
482  return whdd->hpal;
483 }
484 
485 /***********************************************************************
486  * DrawDibRealize [MSVFW32.@]
487  */
489 {
490  WINE_HDD *whdd;
491  UINT ret = 0;
492 
493  FIXME("(%p, %p, %d), stub\n", hdd, hdc, fBackground);
494 
495  whdd = MSVIDEO_GetHddPtr(hdd);
496  if (!whdd) return FALSE;
497 
498  if (!whdd->begun)
499  {
500  ret = 0;
501  goto out;
502  }
503 
504  if (!whdd->hpal)
505  whdd->hpal = CreateHalftonePalette(hdc);
506 
507  SelectPalette(hdc, whdd->hpal, fBackground);
509 
510  out:
511  TRACE("=> %u\n", ret);
512  return ret;
513 }
514 
515 /***********************************************************************
516  * DrawDibTime [MSVFW32.@]
517  */
519 {
520  FIXME("(%p, %p) stub\n", hdd, lpddtime);
521  return FALSE;
522 }
523 
524 /***********************************************************************
525  * DrawDibProfileDisplay [MSVFW32.@]
526  */
528 {
529  FIXME("(%p) stub\n", lpbi);
530 
531  return PD_CAN_DRAW_DIB;
532 }
#define DDF_SAME_DRAW
Definition: vfw.h:2059
#define ICDecompressEnd(hic)
Definition: vfw.h:404
#define TRUE
Definition: types.h:120
HIC VFWAPI ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode)
Definition: msvideo_main.c:437
DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
Definition: drawdib.c:527
LPBITMAPINFOHEADER lpbiOut
Definition: drawdib.c:46
HDRAWDIB VFWAPI DrawDibOpen(void)
Definition: drawdib.c:80
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate)
Definition: drawdib.c:416
DWORD biClrImportant
Definition: amvideo.idl:40
BOOL VFWAPI DrawDibStop(HDRAWDIB hdd)
Definition: drawdib.c:424
LPVOID VFWAPI DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
Definition: drawdib.c:464
#define DDF_BUFFER
Definition: vfw.h:2062
LONG biXPelsPerMeter
Definition: amvideo.idl:37
#define WARN(fmt,...)
Definition: debug.h:111
static HDC
Definition: imagelist.c:92
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1497
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
struct tagWINE_HDD * next
Definition: drawdib.c:53
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
static WINE_HDD * MSVIDEO_GetHddPtr(HDRAWDIB hd)
Definition: drawdib.c:67
_In_ UINT iStart
Definition: wingdi.h:3598
BOOL VFWAPI DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
Definition: drawdib.c:432
HBITMAP hDib
Definition: drawdib.c:50
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define ICERR_OK
Definition: vfw.h:50
int rate
Definition: pcmconverter.c:98
#define ICDecompressGetFormat(hic, lpbiInput, lpbiOutput)
Definition: vfw.h:383
char * LPSTR
Definition: xmlstorage.h:182
LONG biYPelsPerMeter
Definition: amvideo.idl:38
int32_t INT
Definition: typedefs.h:56
BOOL WINAPI StretchBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_opt_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ DWORD)
HPALETTE hpal
Definition: drawdib.c:44
#define DDF_DONTDRAW
Definition: vfw.h:2060
HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd)
Definition: drawdib.c:473
INT dyDst
Definition: drawdib.c:40
DWORD VFWAPIV ICDecompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits)
Definition: msvideo_main.c:854
unsigned int BOOL
Definition: ntddk_ex.h:94
LRESULT WINAPI ICClose(HIC hic)
#define FIXME(fmt,...)
Definition: debug.h:110
DWORD biCompression
Definition: amvideo.idl:35
struct tagWINE_HDD WINE_HDD
BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd, HDC hdc, INT dxDst, INT dyDst, LPBITMAPINFOHEADER lpbi, INT dxSrc, INT dySrc, UINT wFlags)
Definition: drawdib.c:175
BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc, INT xDst, INT yDst, INT dxDst, INT dyDst, LPBITMAPINFOHEADER lpbi, LPVOID lpBits, INT xSrc, INT ySrc, INT dxSrc, INT dySrc, UINT wFlags)
Definition: drawdib.c:308
HPALETTE WINAPI SelectPalette(_In_ HDC, _In_ HPALETTE, _In_ BOOL)
smooth NULL
Definition: ftsmooth.c:416
HDC hMemDC
Definition: drawdib.c:48
INT dxDst
Definition: drawdib.c:39
HANDLE HDRAWDIB
Definition: vfw.h:33
HDC hdc
Definition: drawdib.c:38
#define DDF_NOTKEYFRAME
Definition: vfw.h:2066
HBITMAP hOldDib
Definition: drawdib.c:49
#define PD_CAN_DRAW_DIB
Definition: vfw.h:2104
struct tagRGBQUAD RGBQUAD
static UINT_PTR HDD_HandleRef
Definition: drawdib.c:75
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
static WINE_HDD * HDD_FirstHdd
Definition: drawdib.c:65
WINE_DEFAULT_DEBUG_CHANNEL(msvideo)
#define ICMODE_DECOMPRESS
Definition: vfw.h:269
#define ICTYPE_VIDEO
Definition: mmreg.h:531
BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal)
Definition: drawdib.c:441
unsigned short WORD
Definition: ntddk_ex.h:93
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD biSizeImage
Definition: amvideo.idl:36
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
#define ICDECOMPRESS_NOTKEYFRAME
Definition: vfw.h:331
GLbitfield flags
Definition: glext.h:7161
INT dxSrc
Definition: drawdib.c:42
int ret
BOOL begun
Definition: drawdib.c:45
UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground)
Definition: drawdib.c:488
#define ICERR_UNSUPPORTED
Definition: vfw.h:56
#define CHANGED(x)
#define DDF_UPDATE
Definition: vfw.h:2057
HDC hdc
Definition: main.c:9
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
HIC hic
Definition: drawdib.c:47
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define DDF_SAME_HDC
Definition: vfw.h:2058
#define DDF_BACKGROUNDPAL
Definition: vfw.h:2065
INT dySrc
Definition: drawdib.c:43
#define ICDecompressBegin(hic, lpbiInput, lpbiOutput)
Definition: vfw.h:371
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:519
#define VFWAPI
Definition: vfw.h:26
LPBITMAPINFOHEADER lpbi
Definition: drawdib.c:41
BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd)
Definition: drawdib.c:129
BOOL WINAPI DeleteDC(_In_ HDC)
HBITMAP WINAPI CreateDIBSection(HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
Definition: bitmap.c:197
unsigned int UINT
Definition: ndis.h:50
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
HDRAWDIB hSelf
Definition: drawdib.c:52
BOOL VFWAPI DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime)
Definition: drawdib.c:518
static HBITMAP
Definition: button.c:44
GLfloat GLfloat p
Definition: glext.h:8902
#define DIB_RGB_COLORS
Definition: wingdi.h:366
#define HeapFree(x, y, z)
Definition: compat.h:394
LPVOID lpvbits
Definition: drawdib.c:51
UINT WINAPI RealizePalette(_In_ HDC)
Definition: palette.c:138
#define SRCCOPY
Definition: wingdi.h:332
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54
static int num_colours(const BITMAPINFOHEADER *lpbi)
Definition: drawdib.c:56
HPALETTE WINAPI CreateHalftonePalette(_In_opt_ HDC)
BOOL VFWAPI DrawDibClose(HDRAWDIB hdd)
Definition: drawdib.c:101