Fix build.
[reactos.git] / dll / win32 / gdi32 / objects / bitmap.c
1 #include "precomp.h"
2
3 #define NDEBUG
4 #include <debug.h>
5
6 /*
7 * Return the full scan size for a bitmap.
8 *
9 * Based on Wine, Utils.c and Windows Graphics Prog pg 595, SDK amvideo.h.
10 */
11 UINT
12 FASTCALL
13 DIB_BitmapMaxBitsSize( PBITMAPINFO Info, UINT ScanLines )
14 {
15 UINT MaxBits = 0;
16
17 if (!Info) return 0;
18
19 if (Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
20 {
21 PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info;
22 MaxBits = Core->bcBitCount * Core->bcPlanes * Core->bcWidth;
23 }
24 else /* assume BITMAPINFOHEADER */
25 {
26 if ((Info->bmiHeader.biCompression) && (Info->bmiHeader.biCompression != BI_BITFIELDS))
27 return Info->bmiHeader.biSizeImage;
28 // Planes are over looked by Yuan. I guess assumed always 1.
29 MaxBits = Info->bmiHeader.biBitCount * Info->bmiHeader.biPlanes * Info->bmiHeader.biWidth;
30 }
31 MaxBits = ((MaxBits + 31) & ~31 ) / 8; // From Yuan, ScanLineSize = (Width * bitcount + 31)/32
32 return (MaxBits * ScanLines); // ret the full Size.
33 }
34
35 UINT
36 FASTCALL
37 DIB_BitmapBitsSize( PBITMAPINFO Info )
38 {
39 UINT Ret;
40
41 if (!Info) return 0;
42
43 if ( Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
44 {
45 PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info;
46 Ret = Core->bcHeight *
47 ((Core->bcWidth * Core->bcPlanes * Core->bcBitCount + 31) & ~31 ) / 8;
48 }
49 else /* assume BITMAPINFOHEADER */
50 {
51 if ((Info->bmiHeader.biCompression) &&
52 (Info->bmiHeader.biCompression != BI_BITFIELDS))
53 return Info->bmiHeader.biSizeImage;
54 // Make Height positive always....
55 Ret = abs(Info->bmiHeader.biHeight) *
56 ((Info->bmiHeader.biWidth * Info->bmiHeader.biPlanes * Info->bmiHeader.biBitCount + 31) & ~31 ) / 8;
57 }
58 return Ret;
59 }
60
61
62 /*
63 * DIB_GetBitmapInfo is complete copy of wine cvs 2/9-2006
64 * from file dib.c from gdi32.dll or orginal version
65 * did not calc the info right for some headers.
66 */
67 INT
68 WINAPI
69 DIB_GetBitmapInfo(const BITMAPINFOHEADER *header,
70 PLONG width,
71 PLONG height,
72 PWORD planes,
73 PWORD bpp,
74 PLONG compr,
75 PLONG size )
76 {
77 if (header->biSize == sizeof(BITMAPCOREHEADER))
78 {
79 BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header;
80 *width = core->bcWidth;
81 *height = core->bcHeight;
82 *planes = core->bcPlanes;
83 *bpp = core->bcBitCount;
84 *compr = 0;
85 *size = 0;
86 return 0;
87 }
88
89 if (header->biSize == sizeof(BITMAPINFOHEADER))
90 {
91 *width = header->biWidth;
92 *height = header->biHeight;
93 *planes = header->biPlanes;
94 *bpp = header->biBitCount;
95 *compr = header->biCompression;
96 *size = header->biSizeImage;
97 return 1;
98 }
99
100 if (header->biSize == sizeof(BITMAPV4HEADER))
101 {
102 BITMAPV4HEADER *v4hdr = (BITMAPV4HEADER *)header;
103 *width = v4hdr->bV4Width;
104 *height = v4hdr->bV4Height;
105 *planes = v4hdr->bV4Planes;
106 *bpp = v4hdr->bV4BitCount;
107 *compr = v4hdr->bV4V4Compression;
108 *size = v4hdr->bV4SizeImage;
109 return 4;
110 }
111
112 if (header->biSize == sizeof(BITMAPV5HEADER))
113 {
114 BITMAPV5HEADER *v5hdr = (BITMAPV5HEADER *)header;
115 *width = v5hdr->bV5Width;
116 *height = v5hdr->bV5Height;
117 *planes = v5hdr->bV5Planes;
118 *bpp = v5hdr->bV5BitCount;
119 *compr = v5hdr->bV5Compression;
120 *size = v5hdr->bV5SizeImage;
121 return 5;
122 }
123 DPRINT("(%ld): wrong size for header\n", header->biSize );
124 return -1;
125 }
126
127 /*
128 * @implemented
129 */
130 int
131 WINAPI
132 GdiGetBitmapBitsSize(BITMAPINFO *lpbmi)
133 {
134 int retSize;
135
136 if (lpbmi->bmiHeader.biSize == FIELD_OFFSET(BITMAPINFOHEADER, biPlanes))
137 {
138 /* Calc the bits Size and align it*/
139 retSize = HIWORD(lpbmi->bmiHeader.biWidth) * ((LOWORD(lpbmi->bmiHeader.biWidth) *
140 LOWORD(lpbmi->bmiHeader.biHeight) * HIWORD(lpbmi->bmiHeader.biHeight) + 31)
141 & -32) / 8;
142 }
143 else
144 {
145 if ( (lpbmi->bmiHeader.biCompression == BI_BITFIELDS) ||
146 (lpbmi->bmiHeader.biCompression == BI_RGB))
147 {
148 if (lpbmi->bmiHeader.biHeight >=0 )
149 {
150 /* Calc the bits Size and align it*/
151 retSize = lpbmi->bmiHeader.biHeight * ((lpbmi->bmiHeader.biWidth *
152 lpbmi->bmiHeader.biPlanes * lpbmi->bmiHeader.biBitCount + 31) & -32) / 8;
153 }
154 else
155 {
156 /* Make height postiive if it negitve then calc the bits Size and align it*/
157 retSize = (-lpbmi->bmiHeader.biHeight) * ((lpbmi->bmiHeader.biWidth *
158 lpbmi->bmiHeader.biPlanes * lpbmi->bmiHeader.biBitCount + 31) & -32) / 8;
159 }
160 }
161 else
162 {
163 retSize = lpbmi->bmiHeader.biSizeImage;
164 }
165 }
166 return retSize;
167 }
168
169 /*
170 * @implemented
171 */
172 HBITMAP WINAPI
173 CreateDIBSection(
174 HDC hDC,
175 CONST BITMAPINFO *BitmapInfo,
176 UINT Usage,
177 VOID **Bits,
178 HANDLE hSection,
179 DWORD dwOffset)
180 {
181 PBITMAPINFO pConvertedInfo;
182 UINT ConvertedInfoSize;
183 HBITMAP hBitmap = NULL;
184 PVOID bmBits = NULL;
185
186 pConvertedInfo = ConvertBitmapInfo(BitmapInfo, Usage,
187 &ConvertedInfoSize, FALSE);
188 if (pConvertedInfo)
189 { // Verify header due to converted may == info.
190 if ( pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
191 {
192 if ( pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
193 pConvertedInfo->bmiHeader.biCompression == BI_PNG )
194 {
195 SetLastError(ERROR_INVALID_PARAMETER);
196 return NULL;
197 }
198 }
199 bmBits = Bits;
200 hBitmap = NtGdiCreateDIBSection( hDC,
201 hSection,
202 dwOffset,
203 pConvertedInfo,
204 Usage,
205 0,
206 0,
207 0,
208 &bmBits);
209 if (BitmapInfo != pConvertedInfo)
210 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
211
212 if (!hBitmap)
213 {
214 bmBits = NULL;
215 }
216 }
217
218 if (Bits) *Bits = bmBits;
219
220 return hBitmap;
221 }
222
223
224 /*
225 * @implemented
226 */
227 BOOL
228 WINAPI
229 BitBlt(HDC hdcDest, /* handle to destination DC */
230 int nXOriginDest, /* x-coord of destination upper-left corner */
231 int nYOriginDest, /* y-coord of destination upper-left corner */
232 int nWidthDest, /* width of destination rectangle */
233 int nHeightDest, /* height of destination rectangle */
234 HDC hdcSrc, /* handle to source DC */
235 int nXSrc, /* x-coordinate of source upper-left corner */
236 int nYSrc, /* y-coordinate of source upper-left corner */
237 DWORD dwRop) /* raster operation code */
238 {
239 /* use patBlt for no source blt Like windows does */
240 if (!ROP_USES_SOURCE(dwRop))
241 {
242 return PatBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, dwRop);
243 }
244
245 return NtGdiBitBlt(hdcDest,
246 nXOriginDest,
247 nYOriginDest,
248 nWidthDest,
249 nHeightDest,
250 hdcSrc,
251 nXSrc,
252 nYSrc,
253 dwRop,
254 0,
255 0);
256 }
257
258 /*
259 * @implemented
260 */
261 BOOL WINAPI
262 StretchBlt(
263 HDC hdcDest, /* handle to destination DC */
264 int nXOriginDest, /* x-coord of destination upper-left corner */
265 int nYOriginDest, /* y-coord of destination upper-left corner */
266 int nWidthDest, /* width of destination rectangle */
267 int nHeightDest, /* height of destination rectangle */
268 HDC hdcSrc, /* handle to source DC */
269 int nXOriginSrc, /* x-coord of source upper-left corner */
270 int nYOriginSrc, /* y-coord of source upper-left corner */
271 int nWidthSrc, /* width of source rectangle */
272 int nHeightSrc, /* height of source rectangle */
273 DWORD dwRop) /* raster operation code */
274
275 {
276 if ((nWidthDest != nWidthSrc) || (nHeightDest != nHeightSrc))
277 {
278 return NtGdiStretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest,
279 nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc,
280 nWidthSrc, nHeightSrc, dwRop, 0);
281 }
282
283 return NtGdiBitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest,
284 nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, dwRop, 0, 0);
285 }
286
287 /*
288 * @unimplemented
289 */
290 HBITMAP WINAPI
291 CreateBitmap(INT Width,
292 INT Height,
293 UINT Planes,
294 UINT BitsPixel,
295 CONST VOID* pUnsafeBits)
296 {
297 /* FIXME some part should be done in user mode */
298 if (Width && Height)
299 {
300 return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
301 }
302 else
303 {
304 /* Return 1x1 bitmap */
305 return GetStockObject(DEFAULT_BITMAP);
306 }
307 }
308
309 /*
310 * @implemented
311 */
312 HBITMAP WINAPI
313 CreateBitmapIndirect(const BITMAP *pbm)
314 {
315 HBITMAP bitmap = NULL;
316
317 /* Note windows xp/2003 does not check if pbm is NULL or not */
318 if ( (pbm->bmWidthBytes != 0) &&
319 (!(pbm->bmWidthBytes & 1)) )
320
321 {
322
323 bitmap = CreateBitmap(pbm->bmWidth,
324 pbm->bmHeight,
325 pbm->bmPlanes,
326 pbm->bmBitsPixel,
327 pbm->bmBits);
328 }
329 else
330 {
331 SetLastError(ERROR_INVALID_PARAMETER);
332 }
333
334 return bitmap;
335 }
336
337 HBITMAP WINAPI
338 CreateDiscardableBitmap(
339 HDC hDC,
340 INT Width,
341 INT Height)
342 {
343 return CreateCompatibleBitmap(hDC, Width, Height);
344 }
345
346
347 HBITMAP WINAPI
348 CreateCompatibleBitmap(
349 HDC hDC,
350 INT Width,
351 INT Height)
352 {
353 PDC_ATTR pDc_Attr;
354 HBITMAP hBmp = NULL;
355 DIBSECTION dibs;
356
357 if (!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
358 return NULL;
359
360 if ( !Width || !Height )
361 return GetStockObject(DEFAULT_BITMAP);
362
363 if (!(pDc_Attr->ulDirty_ & DC_DIBSECTION))
364 {
365 return NtGdiCreateCompatibleBitmap(hDC, Width, Height);
366 }
367
368 hBmp = NtGdiGetDCObject(hDC, GDI_OBJECT_TYPE_BITMAP);
369
370 if ( GetObjectA(hBmp, sizeof(DIBSECTION), &dibs) != sizeof(DIBSECTION) )
371 return NULL;
372
373 if ( dibs.dsBm.bmBitsPixel <= 8 )
374 GetDIBColorTable(hDC, 0, 256, (RGBQUAD *)&dibs.dsBitfields);
375
376 dibs.dsBmih.biWidth = Width;
377 dibs.dsBmih.biHeight = Height;
378
379 return CreateDIBSection(hDC, (CONST BITMAPINFO *)&dibs.dsBmih, 0, NULL, NULL, 0);
380 }
381
382
383 INT
384 WINAPI
385 GetDIBits(
386 HDC hDC,
387 HBITMAP hbmp,
388 UINT uStartScan,
389 UINT cScanLines,
390 LPVOID lpvBits,
391 LPBITMAPINFO lpbmi,
392 UINT uUsage)
393 {
394 INT Ret = 0;
395 UINT cjBmpScanSize;
396 PVOID pvSafeBits = lpvBits;
397
398 if (!hDC || !GdiIsHandleValid((HGDIOBJ)hDC))
399 {
400 GdiSetLastError(ERROR_INVALID_PARAMETER);
401 return Ret;
402 }
403
404 cjBmpScanSize = DIB_BitmapMaxBitsSize(lpbmi, cScanLines);
405
406 if ( lpvBits )
407 {
408 if ( lpbmi )
409 {
410 if ( lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
411 {
412 if ( lpbmi->bmiHeader.biCompression == BI_JPEG ||
413 lpbmi->bmiHeader.biCompression == BI_PNG )
414 {
415 SetLastError(ERROR_INVALID_PARAMETER);
416 return Ret;
417 }
418 }
419 }
420
421 if ((ULONG)lpvBits & (sizeof(DWORD) - 1))
422 {
423 pvSafeBits = RtlAllocateHeap(RtlGetProcessHeap(), 0, cjBmpScanSize);
424 if (!pvSafeBits)
425 return Ret;
426 }
427 }
428
429 Ret = NtGdiGetDIBitsInternal(hDC,
430 hbmp,
431 uStartScan,
432 cScanLines,
433 pvSafeBits,
434 lpbmi,
435 uUsage,
436 cjBmpScanSize,
437 0);
438 if (lpvBits != pvSafeBits)
439 {
440 if (Ret)
441 {
442 RtlCopyMemory(lpvBits, pvSafeBits, cjBmpScanSize);
443 }
444 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
445 }
446 return Ret;
447 }
448
449 /*
450 * @implemented
451 */
452 HBITMAP
453 WINAPI
454 CreateDIBitmap( HDC hDC,
455 const BITMAPINFOHEADER *Header,
456 DWORD Init,
457 LPCVOID Bits,
458 const BITMAPINFO *Data,
459 UINT ColorUse)
460 {
461 LONG width, height, compr, dibsize;
462 WORD planes, bpp;
463 // PDC_ATTR pDc_Attr;
464 PBITMAPINFO pConvertedInfo;
465 UINT ConvertedInfoSize;
466 UINT cjBmpScanSize;
467 PVOID pvSafeBits = NULL;
468 HBITMAP hBmp;
469
470 if (!Header) return 0;
471
472 pConvertedInfo = ConvertBitmapInfo(Data, ColorUse,
473 &ConvertedInfoSize, FALSE);
474
475 if (DIB_GetBitmapInfo(Header, &width, &height, &planes, &bpp, &compr, &dibsize) == -1)
476 {
477 GdiSetLastError(ERROR_INVALID_PARAMETER);
478 return NULL;
479 }
480
481 if ( pConvertedInfo )
482 {
483 if ( pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
484 {
485 if ( pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
486 pConvertedInfo->bmiHeader.biCompression == BI_PNG )
487 {
488 hBmp = NULL;
489 goto Exit;
490 }
491 }
492 }
493
494 // For Icm support.
495 // GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
496
497 cjBmpScanSize = DIB_BitmapBitsSize((LPBITMAPINFO)pConvertedInfo);
498 DPRINT("pBMI %x, Size bpp %d, dibsize %d, Conv %d, BSS %d\n", pConvertedInfo,bpp,dibsize,ConvertedInfoSize,cjBmpScanSize);
499
500 if ( !width || !height )
501 hBmp = GetStockObject(DEFAULT_BITMAP);
502 else
503 {
504 if ( Bits && Init == CBM_INIT )
505 {
506 pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
507 if (pvSafeBits == NULL)
508 {
509 hBmp = NULL;
510 goto Exit;
511 }
512 else
513 {
514 RtlCopyMemory( pvSafeBits, Bits, cjBmpScanSize);
515 }
516 }
517
518 hBmp = NtGdiCreateDIBitmapInternal(hDC,
519 width,
520 height,
521 Init,
522 (LPBYTE)pvSafeBits,
523 (PBITMAPINFO)pConvertedInfo,
524 ColorUse,
525 ConvertedInfoSize,
526 cjBmpScanSize,
527 0,
528 0);
529
530 if ( Bits && Init == CBM_INIT )
531 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
532 }
533 Exit:
534 if (Data != pConvertedInfo)
535 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
536 return hBmp;
537 }
538
539 #if 0 // FIXME!!! This is a victim of the Win32k Initialization BUG!!!!!
540 /*
541 * @implemented
542 */
543 INT
544 WINAPI
545 SetDIBits(HDC hDC,
546 HBITMAP hBitmap,
547 UINT uStartScan,
548 UINT cScanLines,
549 CONST VOID *lpvBits,
550 CONST BITMAPINFO *lpbmi,
551 UINT fuColorUse)
552 {
553 HDC hDCc, SavehDC, nhDC;
554 DWORD dwWidth, dwHeight;
555 HGDIOBJ hOldBitmap;
556 HPALETTE hPal = NULL;
557 INT LinesCopied = 0;
558 BOOL newDC = FALSE;
559
560 if ( !lpvBits || (GDI_HANDLE_GET_TYPE(hBitmap) != GDI_OBJECT_TYPE_BITMAP) )
561 return 0;
562
563 if ( lpbmi )
564 {
565 if ( lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
566 {
567 if ( lpbmi->bmiHeader.biCompression == BI_JPEG || lpbmi->bmiHeader.biCompression == BI_PNG )
568 {
569 SetLastError(ERROR_INVALID_PARAMETER);
570 return 0;
571 }
572 }
573 }
574
575 hDCc = NtGdiGetDCforBitmap(hBitmap);
576 SavehDC = hDCc;
577 if ( !hDCc )
578 {
579 nhDC = CreateCompatibleDC(hDC);
580 if ( !nhDC ) return 0;
581 newDC = TRUE;
582 SavehDC = nhDC;
583 }
584 else if ( !SaveDC(hDCc) )
585 return 0;
586
587 hOldBitmap = SelectObject(SavehDC, hBitmap);
588
589 if ( hOldBitmap )
590 {
591 if ( hDC )
592 hPal = SelectPalette(SavehDC, (HPALETTE)GetDCObject(hDC, GDI_OBJECT_TYPE_PALETTE), FALSE);
593
594 if ( lpbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER))
595 {
596 PBITMAPCOREINFO pbci = (PBITMAPCOREINFO) lpbmi;
597 dwWidth = pbci->bmciHeader.bcWidth;
598 dwHeight = pbci->bmciHeader.bcHeight;
599 }
600 else
601 {
602 dwWidth = lpbmi->bmiHeader.biWidth;
603 dwHeight = abs(lpbmi->bmiHeader.biHeight);
604 }
605
606 LinesCopied = SetDIBitsToDevice(SavehDC,
607 0,
608 0,
609 dwWidth,
610 dwHeight,
611 0,
612 0,
613 uStartScan,
614 cScanLines,
615 (void *)lpvBits,
616 (LPBITMAPINFO)lpbmi,
617 fuColorUse);
618
619 if ( hDC ) SelectPalette(SavehDC, hPal, FALSE);
620
621 SelectObject(SavehDC, hOldBitmap);
622 }
623
624 if ( newDC )
625 DeleteDC(SavehDC);
626 else
627 RestoreDC(SavehDC, -1);
628
629 return LinesCopied;
630 }
631 #endif
632
633 INT
634 WINAPI
635 SetDIBits(HDC hdc,
636 HBITMAP hbmp,
637 UINT uStartScan,
638 UINT cScanLines,
639 CONST VOID *lpvBits,
640 CONST BITMAPINFO *lpbmi,
641 UINT fuColorUse)
642 {
643 PBITMAPINFO pConvertedInfo;
644 UINT ConvertedInfoSize;
645 INT LinesCopied = 0;
646 UINT cjBmpScanSize = 0;
647 PVOID pvSafeBits = (PVOID)lpvBits;
648
649 // This needs to be almost the sames as SetDIBitsToDevice
650
651 if ( !cScanLines || !lpbmi || !lpvBits || (GDI_HANDLE_GET_TYPE(hbmp) != GDI_OBJECT_TYPE_BITMAP))
652 return 0;
653
654 if ( fuColorUse && fuColorUse != DIB_PAL_COLORS && fuColorUse != DIB_PAL_COLORS+1 )
655 return 0;
656
657 pConvertedInfo = ConvertBitmapInfo(lpbmi, fuColorUse,
658 &ConvertedInfoSize, FALSE);
659 if (!pConvertedInfo)
660 return 0;
661
662 cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO)lpbmi, cScanLines);
663
664 if ( lpvBits )
665 {
666 pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
667 if (pvSafeBits)
668 RtlCopyMemory( pvSafeBits, lpvBits, cjBmpScanSize);
669 }
670
671 LinesCopied = NtGdiSetDIBits( hdc,
672 hbmp,
673 uStartScan,
674 cScanLines,
675 pvSafeBits,
676 pConvertedInfo,
677 fuColorUse);
678
679 if ( lpvBits != pvSafeBits)
680 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
681 if (lpbmi != pConvertedInfo)
682 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
683 return LinesCopied;
684 }
685
686 /*
687 * @implemented
688 *
689 */
690 INT
691 WINAPI
692 SetDIBitsToDevice(
693 HDC hdc,
694 int XDest,
695 int YDest,
696 DWORD Width,
697 DWORD Height,
698 int XSrc,
699 int YSrc,
700 UINT StartScan,
701 UINT ScanLines,
702 CONST VOID *Bits,
703 CONST BITMAPINFO *lpbmi,
704 UINT ColorUse)
705 {
706 PDC_ATTR pDc_Attr;
707 PBITMAPINFO pConvertedInfo;
708 UINT ConvertedInfoSize;
709 INT LinesCopied = 0;
710 UINT cjBmpScanSize = 0;
711 PVOID pvSafeBits = (PVOID)Bits;
712
713 if ( !ScanLines || !lpbmi || !Bits )
714 return 0;
715
716 if ( ColorUse && ColorUse != DIB_PAL_COLORS && ColorUse != DIB_PAL_COLORS+1 )
717 return 0;
718
719 pConvertedInfo = ConvertBitmapInfo(lpbmi, ColorUse,
720 &ConvertedInfoSize, FALSE);
721 if (!pConvertedInfo)
722 return 0;
723
724 #if 0
725 // Handle something other than a normal dc object.
726 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
727 {
728 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
729 return MFDRV_SetDIBitsToDevice( hdc,
730 XDest,
731 YDest,
732 Width,
733 Height,
734 XSrc,
735 YSrc,
736 StartScan,
737 ScanLines,
738 Bits,
739 lpbmi,
740 ColorUse);
741 else
742 {
743 PLDC pLDC = GdiGetLDC(hdc);
744 if ( !pLDC )
745 {
746 SetLastError(ERROR_INVALID_HANDLE);
747 return 0;
748 }
749 if (pLDC->iType == LDC_EMFLDC)
750 {
751 return EMFDRV_SetDIBitsToDevice(hdc,
752 XDest,
753 YDest,
754 Width,
755 Height,
756 XSrc,
757 YSrc,
758 StartScan,
759 ScanLines,
760 Bits,
761 lpbmi,
762 ColorUse);
763 }
764 return 0;
765 }
766 }
767 #endif
768 cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO)lpbmi, ScanLines);
769
770 if ( Bits )
771 {
772 pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
773 if (pvSafeBits)
774 RtlCopyMemory( pvSafeBits, Bits, cjBmpScanSize);
775 }
776
777 if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
778 {
779 SetLastError(ERROR_INVALID_PARAMETER);
780 return 0;
781 }
782 /*
783 if ( !pDc_Attr ||
784 ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
785 (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
786 pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/
787 {
788 LinesCopied = NtGdiSetDIBitsToDeviceInternal( hdc,
789 XDest,
790 YDest,
791 Width,
792 Height,
793 XSrc,
794 YSrc,
795 StartScan,
796 ScanLines,
797 (LPBYTE)pvSafeBits,
798 (LPBITMAPINFO)pConvertedInfo,
799 ColorUse,
800 cjBmpScanSize,
801 ConvertedInfoSize,
802 TRUE,
803 NULL);
804 }
805 if ( Bits != pvSafeBits)
806 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
807 if (lpbmi != pConvertedInfo)
808 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
809
810 return LinesCopied;
811 }
812
813
814 /*
815 * @unimplemented
816 */
817 int
818 WINAPI
819 StretchDIBits(HDC hdc,
820 int XDest,
821 int YDest,
822 int nDestWidth,
823 int nDestHeight,
824 int XSrc,
825 int YSrc,
826 int nSrcWidth,
827 int nSrcHeight,
828 CONST VOID *lpBits,
829 CONST BITMAPINFO *lpBitsInfo,
830 UINT iUsage,
831 DWORD dwRop)
832
833 {
834 PDC_ATTR pDc_Attr;
835 PBITMAPINFO pConvertedInfo = NULL;
836 UINT ConvertedInfoSize = 0;
837 INT LinesCopied = 0;
838 UINT cjBmpScanSize = 0;
839 PVOID pvSafeBits = NULL;
840 BOOL Hit = FALSE;
841
842 DPRINT("StretchDIBits %x : %x : %d\n", lpBits, lpBitsInfo, iUsage);
843 #if 0
844 // Handle something other than a normal dc object.
845 if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
846 {
847 if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
848 return MFDRV_StretchBlt( hdc,
849 XDest,
850 YDest,
851 nDestWidth,
852 nDestHeight,
853 XSrc,
854 YSrc,
855 nSrcWidth,
856 nSrcHeight,
857 lpBits,
858 lpBitsInfo,
859 iUsage,
860 dwRop);
861 else
862 {
863 PLDC pLDC = GdiGetLDC(hdc);
864 if ( !pLDC )
865 {
866 SetLastError(ERROR_INVALID_HANDLE);
867 return 0;
868 }
869 if (pLDC->iType == LDC_EMFLDC)
870 {
871 return EMFDRV_StretchBlt(hdc,
872 XDest,
873 YDest,
874 nDestWidth,
875 nDestHeight,
876 XSrc,
877 YSrc,
878 nSrcWidth,
879 nSrcHeight,
880 lpBits,
881 lpBitsInfo,
882 iUsage,
883 dwRop);
884 }
885 return 0;
886 }
887 }
888 #endif
889 if ( iUsage ) // Save time, we only look at non RGB.
890 {
891 pConvertedInfo = ConvertBitmapInfo(lpBitsInfo, iUsage,
892 &ConvertedInfoSize, FALSE);
893 if (!pConvertedInfo)
894 {
895 return 0;
896 }
897 }
898 else
899 pConvertedInfo = (PBITMAPINFO)lpBitsInfo;
900
901 cjBmpScanSize = DIB_BitmapBitsSize((LPBITMAPINFO)pConvertedInfo);
902
903 if ( lpBits )
904 {
905 pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
906 if (pvSafeBits)
907 {
908 _SEH2_TRY
909 {
910 RtlCopyMemory( pvSafeBits, lpBits, cjBmpScanSize );
911 }
912 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
913 {
914 Hit = TRUE;
915 }
916 _SEH2_END
917
918 if (Hit)
919 {
920 // We don't die, we continue on with a allocated safe pointer to kernel
921 // space.....
922 DPRINT1("StretchDIBits fail to read BitMapInfo: %x or Bits: %x & Size: %d\n",pConvertedInfo,lpBits,cjBmpScanSize);
923 }
924 DPRINT("StretchDIBits Allocate Bits %d!!!\n", cjBmpScanSize);
925 }
926 }
927
928 if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
929 {
930 SetLastError(ERROR_INVALID_PARAMETER);
931 return 0;
932 }
933 /*
934 if ( !pDc_Attr ||
935 ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
936 (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
937 pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/
938 {
939 LinesCopied = NtGdiStretchDIBitsInternal( hdc,
940 XDest,
941 YDest,
942 nDestWidth,
943 nDestHeight,
944 XSrc,
945 YSrc,
946 nSrcWidth,
947 nSrcHeight,
948 pvSafeBits,
949 pConvertedInfo,
950 (DWORD)iUsage,
951 dwRop,
952 ConvertedInfoSize,
953 cjBmpScanSize,
954 NULL);
955 }
956 if ( pvSafeBits )
957 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
958 if (lpBitsInfo != pConvertedInfo)
959 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
960
961 return LinesCopied;
962 }
963