msvfw32: Remove unneeded casts.
[wine] / 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 DWORD 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     whdd->hpal = 0; /* Do not free this */
137     whdd->hdc = 0;
138     HeapFree(GetProcessHeap(), 0, whdd->lpbi);
139     whdd->lpbi = NULL;
140     HeapFree(GetProcessHeap(), 0, whdd->lpbiOut);
141     whdd->lpbiOut = NULL;
142
143     whdd->begun = FALSE;
144
145     /*if (whdd->lpvbits)
146       HeapFree(GetProcessHeap(), 0, whdd->lpvbuf);*/
147
148     if (whdd->hMemDC) 
149     {
150         SelectObject(whdd->hMemDC, whdd->hOldDib);
151         DeleteDC(whdd->hMemDC);
152         whdd->hMemDC = 0;
153     }
154
155     if (whdd->hDib) DeleteObject(whdd->hDib);
156     whdd->hDib = 0;
157
158     if (whdd->hic) 
159     {
160         ICDecompressEnd(whdd->hic);
161         ICClose(whdd->hic);
162         whdd->hic = 0;
163     }
164
165     whdd->lpvbits = NULL;
166
167     return ret;
168 }
169
170 /***********************************************************************
171  *              DrawDibBegin            [MSVFW32.@]
172  */
173 BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd,
174                          HDC      hdc,
175                          INT      dxDst,
176                          INT      dyDst,
177                          LPBITMAPINFOHEADER lpbi,
178                          INT      dxSrc,
179                          INT      dySrc,
180                          UINT     wFlags) 
181 {
182     BOOL ret = TRUE;
183     WINE_HDD *whdd;
184
185     TRACE("(%p,%p,%d,%d,%p,%d,%d,0x%08x)\n",
186           hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, wFlags);
187
188     TRACE("lpbi: %d,%d/%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
189           lpbi->biSize, lpbi->biWidth, lpbi->biHeight, lpbi->biPlanes,
190           lpbi->biBitCount, lpbi->biCompression, lpbi->biSizeImage,
191           lpbi->biXPelsPerMeter, lpbi->biYPelsPerMeter, lpbi->biClrUsed,
192           lpbi->biClrImportant);
193
194     if (wFlags & ~(DDF_BUFFER))
195         FIXME("wFlags == 0x%08x not handled\n", wFlags & ~(DDF_BUFFER));
196
197     whdd = MSVIDEO_GetHddPtr(hdd);
198     if (!whdd) return FALSE;
199
200     if (whdd->begun) DrawDibEnd(hdd);
201
202     if (lpbi->biCompression) 
203     {
204         DWORD size = 0;
205
206         whdd->hic = ICOpen(ICTYPE_VIDEO, lpbi->biCompression, ICMODE_DECOMPRESS);
207         if (!whdd->hic) 
208         {
209             WARN("Could not open IC. biCompression == 0x%08x\n", lpbi->biCompression);
210             ret = FALSE;
211         }
212
213         if (ret) 
214         {
215             size = ICDecompressGetFormat(whdd->hic, lpbi, NULL);
216             if (size == ICERR_UNSUPPORTED) 
217             {
218                 WARN("Codec doesn't support GetFormat, giving up.\n");
219                 ret = FALSE;
220             }
221         }
222
223         if (ret) 
224         {
225             whdd->lpbiOut = HeapAlloc(GetProcessHeap(), 0, size);
226
227             if (ICDecompressGetFormat(whdd->hic, lpbi, whdd->lpbiOut) != ICERR_OK)
228                 ret = FALSE;
229         }
230
231         if (ret) 
232         {
233             /* FIXME: Use Ex functions if available? */
234             if (ICDecompressBegin(whdd->hic, lpbi, whdd->lpbiOut) != ICERR_OK)
235                 ret = FALSE;
236             
237             TRACE("biSizeImage == %d\n", whdd->lpbiOut->biSizeImage);
238             TRACE("biCompression == %d\n", whdd->lpbiOut->biCompression);
239             TRACE("biBitCount == %d\n", whdd->lpbiOut->biBitCount);
240         }
241     }
242     else 
243     {
244         DWORD dwSize;
245         /* No compression */
246         TRACE("Not compressed!\n");
247         dwSize = lpbi->biSize + num_colours(lpbi)*sizeof(RGBQUAD);
248         whdd->lpbiOut = HeapAlloc(GetProcessHeap(), 0, dwSize);
249         memcpy(whdd->lpbiOut, lpbi, dwSize);
250     }
251
252     if (ret) 
253     {
254         /*whdd->lpvbuf = HeapAlloc(GetProcessHeap(), 0, whdd->lpbiOut->biSizeImage);*/
255
256         whdd->hMemDC = CreateCompatibleDC(hdc);
257         TRACE("Creating: %d, %p\n", whdd->lpbiOut->biSize, whdd->lpvbits);
258         whdd->hDib = CreateDIBSection(whdd->hMemDC, (BITMAPINFO *)whdd->lpbiOut, DIB_RGB_COLORS, &(whdd->lpvbits), 0, 0);
259         if (whdd->hDib) 
260         {
261             TRACE("Created: %p,%p\n", whdd->hDib, whdd->lpvbits);
262         }
263         else
264         {
265             ret = FALSE;
266             TRACE("Error: %d\n", GetLastError());
267         }
268         whdd->hOldDib = SelectObject(whdd->hMemDC, whdd->hDib);
269     }
270
271     if (ret) 
272     {
273         whdd->hdc = hdc;
274         whdd->dxDst = dxDst;
275         whdd->dyDst = dyDst;
276         whdd->lpbi = HeapAlloc(GetProcessHeap(), 0, lpbi->biSize);
277         memcpy(whdd->lpbi, lpbi, lpbi->biSize);
278         whdd->dxSrc = dxSrc;
279         whdd->dySrc = dySrc;
280         whdd->begun = TRUE;
281         whdd->hpal = 0;
282     } 
283     else 
284     {
285         if (whdd->hic)
286             ICClose(whdd->hic);
287         HeapFree(GetProcessHeap(), 0, whdd->lpbiOut);
288         whdd->lpbiOut = NULL;
289     }
290
291     return ret;
292 }
293
294 /**********************************************************************
295  *              DrawDibDraw             [MSVFW32.@]
296  */
297 BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc,
298                         INT xDst, INT yDst, INT dxDst, INT dyDst,
299                         LPBITMAPINFOHEADER lpbi,
300                         LPVOID lpBits,
301                         INT xSrc, INT ySrc, INT dxSrc, INT dySrc,
302                         UINT wFlags)
303 {
304     WINE_HDD *whdd;
305     BOOL ret = TRUE;
306
307     TRACE("(%p,%p,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08x)\n",
308           hdd, hdc, xDst, yDst, dxDst, dyDst, lpbi, lpBits, xSrc, ySrc, dxSrc, dySrc, wFlags);
309
310     whdd = MSVIDEO_GetHddPtr(hdd);
311     if (!whdd) return FALSE;
312
313     TRACE("whdd=%p\n", whdd);
314
315     if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME | DDF_UPDATE | DDF_DONTDRAW | DDF_BACKGROUNDPAL))
316         FIXME("wFlags == 0x%08x not handled\n", wFlags);
317
318     if (!lpBits) 
319     {
320         /* Undocumented? */
321         lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(num_colours(lpbi)*sizeof(RGBQUAD));
322     }
323
324
325 #define CHANGED(x) (whdd->x != x)
326
327     if ((!whdd->begun) || 
328         (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc)) || 
329         (!(wFlags & DDF_SAME_DRAW) && (CHANGED(lpbi) || CHANGED(dxSrc) || CHANGED(dySrc) || CHANGED(dxDst) || CHANGED(dyDst)))) 
330     {
331         TRACE("Something changed!\n");
332         ret = DrawDibBegin(hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, 0);
333     }
334
335 #undef CHANGED
336
337     if ((dxDst == -1) && (dyDst == -1)) 
338     {
339         dxDst = dxSrc;
340         dyDst = dySrc;
341     }
342
343     if (!(wFlags & DDF_UPDATE)) 
344     {
345         DWORD biSizeImage = lpbi->biSizeImage;
346
347         /* biSizeImage may be set to 0 for BI_RGB (uncompressed) bitmaps */
348         if ((lpbi->biCompression == BI_RGB) && (biSizeImage == 0))
349             biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
350
351         if (lpbi->biCompression) 
352         {
353             DWORD flags = 0;
354
355             TRACE("Compression == 0x%08x\n", lpbi->biCompression);
356
357             if (wFlags & DDF_NOTKEYFRAME)
358                 flags |= ICDECOMPRESS_NOTKEYFRAME;
359
360             ICDecompress(whdd->hic, flags, lpbi, lpBits, whdd->lpbiOut, whdd->lpvbits);
361         }
362         else
363         {
364             memcpy(whdd->lpvbits, lpBits, biSizeImage);
365         }
366     }
367     if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
368     {
369         if ((wFlags & DDF_BACKGROUNDPAL) && ! (wFlags & DDF_SAME_HDC))
370          SelectPalette(hdc, whdd->hpal, TRUE);
371         else
372          SelectPalette(hdc, whdd->hpal, FALSE);
373     }
374
375     if (!(StretchBlt(whdd->hdc, xDst, yDst, dxDst, dyDst, whdd->hMemDC, xSrc, ySrc, dxSrc, dySrc, SRCCOPY)))
376         ret = FALSE;
377     
378     return ret;
379 }
380
381 /*************************************************************************
382  *              DrawDibStart            [MSVFW32.@]
383  */
384 BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate) {
385         FIXME("(%p, %d), stub\n", hdd, rate);
386         return TRUE;
387 }
388
389 /*************************************************************************
390  *              DrawDibStop             [MSVFW32.@]
391  */
392 BOOL VFWAPI DrawDibStop(HDRAWDIB hdd) {
393         FIXME("(%p), stub\n", hdd);
394         return TRUE;
395 }
396
397 /***********************************************************************
398  *              DrawDibChangePalette       [MSVFW32.@]
399  */
400 BOOL VFWAPI DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe)
401 {
402     FIXME("(%p, 0x%08x, 0x%08x, %p), stub\n", hdd, iStart, iLen, lppe);
403     return TRUE;
404 }
405
406 /***********************************************************************
407  *              DrawDibSetPalette       [MSVFW32.@]
408  */
409 BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal) 
410 {
411     WINE_HDD *whdd;
412
413     TRACE("(%p, %p)\n", hdd, hpal);
414
415     whdd = MSVIDEO_GetHddPtr(hdd);
416     if (!whdd) return FALSE;
417
418     whdd->hpal = hpal;
419
420     if (whdd->begun) 
421     {
422         SelectPalette(whdd->hdc, hpal, 0);
423         RealizePalette(whdd->hdc);
424     }
425
426     return TRUE;
427 }
428
429 /***********************************************************************
430  *              DrawDibGetBuffer       [MSVFW32.@]
431  */
432 LPVOID VFWAPI DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags)
433 {
434     FIXME("(%p, %p, 0x%08x, 0x%08x), stub\n", hdd, lpbi, dwSize, dwFlags);
435     return NULL;
436 }
437
438 /***********************************************************************
439  *              DrawDibGetPalette       [MSVFW32.@]
440  */
441 HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd) 
442 {
443     WINE_HDD *whdd;
444
445     TRACE("(%p)\n", hdd);
446
447     whdd = MSVIDEO_GetHddPtr(hdd);
448     if (!whdd) return FALSE;
449
450     return whdd->hpal;
451 }
452
453 /***********************************************************************
454  *              DrawDibRealize          [MSVFW32.@]
455  */
456 UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground) 
457 {
458     WINE_HDD *whdd;
459     HPALETTE oldPal;
460     UINT ret = 0;
461
462     FIXME("(%p, %p, %d), stub\n", hdd, hdc, fBackground);
463
464     whdd = MSVIDEO_GetHddPtr(hdd);
465     if (!whdd) return FALSE;
466
467     if (!whdd || !(whdd->begun)) 
468     {
469         ret = 0;
470         goto out;
471     }
472
473     if (!whdd->hpal)
474         whdd->hpal = CreateHalftonePalette(hdc);
475
476     oldPal = SelectPalette(hdc, whdd->hpal, fBackground);
477     ret = RealizePalette(hdc);
478
479  out:
480     TRACE("=> %u\n", ret);
481     return ret;
482 }
483
484 /***********************************************************************
485  *              DrawDibTime          [MSVFW32.@]
486  */
487 BOOL VFWAPI DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime)
488 {
489     FIXME("(%p, %p) stub\n", hdd, lpddtime);
490     return FALSE;
491 }
492
493 /***********************************************************************
494  *              DrawDibProfileDisplay          [MSVFW32.@]
495  */
496 DWORD VFWAPI DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi)
497 {
498     FIXME("(%p) stub\n", lpbi);
499
500     return PD_CAN_DRAW_DIB;
501 }