9 * Return the size of the bitmap info structure including color table.
10 * 11/16/1999 (RJJ) lifted from wine
13 INT FASTCALL
DIB_BitmapInfoSize(const BITMAPINFO
* info
, WORD coloruse
)
15 unsigned int colors
, size
, masks
= 0;
17 if (info
->bmiHeader
.biSize
== sizeof(BITMAPCOREHEADER
))
19 const BITMAPCOREHEADER
*core
= (const BITMAPCOREHEADER
*)info
;
20 colors
= (core
->bcBitCount
<= 8) ? 1 << core
->bcBitCount
: 0;
21 return sizeof(BITMAPCOREHEADER
) + colors
*
22 ((coloruse
== DIB_RGB_COLORS
) ? sizeof(RGBTRIPLE
) : sizeof(WORD
));
24 else /* assume BITMAPINFOHEADER */
26 colors
= info
->bmiHeader
.biClrUsed
;
27 if (colors
> 256) colors
= 256;
28 if (!colors
&& (info
->bmiHeader
.biBitCount
<= 8))
29 colors
= 1 << info
->bmiHeader
.biBitCount
;
30 if (info
->bmiHeader
.biCompression
== BI_BITFIELDS
) masks
= 3;
31 size
= max( info
->bmiHeader
.biSize
, sizeof(BITMAPINFOHEADER
) + masks
* sizeof(DWORD
) );
32 return size
+ colors
* ((coloruse
== DIB_RGB_COLORS
) ? sizeof(RGBQUAD
) : sizeof(WORD
));
37 * Return the full scan size for a bitmap.
39 * Based on Wine, Utils.c and Windows Graphics Prog pg 595, SDK amvideo.h.
43 DIB_BitmapMaxBitsSize( PBITMAPINFO Info
, UINT ScanLines
)
49 if (Info
->bmiHeader
.biSize
== sizeof(BITMAPCOREHEADER
))
51 PBITMAPCOREHEADER Core
= (PBITMAPCOREHEADER
)Info
;
52 MaxBits
= Core
->bcBitCount
* Core
->bcPlanes
* Core
->bcWidth
;
54 else /* assume BITMAPINFOHEADER */
56 if ((Info
->bmiHeader
.biCompression
) && (Info
->bmiHeader
.biCompression
!= BI_BITFIELDS
))
57 return Info
->bmiHeader
.biSizeImage
;
58 // Planes are over looked by Yuan. I guess assumed always 1.
59 MaxBits
= Info
->bmiHeader
.biBitCount
* Info
->bmiHeader
.biPlanes
* Info
->bmiHeader
.biWidth
;
61 MaxBits
= ((MaxBits
+ 31) & ~31 ) / 8; // From Yuan, ScanLineSize = (Width * bitcount + 31)/32
62 return (MaxBits
* ScanLines
); // ret the full Size.
67 DIB_BitmapBitsSize( CONST BITMAPINFO
* Info
)
73 if ( Info
->bmiHeader
.biSize
== sizeof(BITMAPCOREHEADER
))
75 PBITMAPCOREHEADER Core
= (PBITMAPCOREHEADER
)Info
;
76 Ret
= Core
->bcHeight
*
77 ((Core
->bcWidth
* Core
->bcPlanes
* Core
->bcBitCount
+ 31) & ~31 ) / 8;
79 else /* assume BITMAPINFOHEADER */
81 if ((Info
->bmiHeader
.biCompression
) &&
82 (Info
->bmiHeader
.biCompression
!= BI_BITFIELDS
))
83 return Info
->bmiHeader
.biSizeImage
;
84 // Make Height positive always....
85 Ret
= abs(Info
->bmiHeader
.biHeight
) *
86 ((Info
->bmiHeader
.biWidth
* Info
->bmiHeader
.biPlanes
* Info
->bmiHeader
.biBitCount
+ 31) & ~31 ) / 8;
93 * DIB_GetBitmapInfo is complete copy of wine cvs 2/9-2006
94 * from file dib.c from gdi32.dll or orginal version
95 * did not calc the info right for some headers.
99 DIB_GetBitmapInfo(const BITMAPINFOHEADER
*header
,
107 if (header
->biSize
== sizeof(BITMAPCOREHEADER
))
109 BITMAPCOREHEADER
*core
= (BITMAPCOREHEADER
*)header
;
110 *width
= core
->bcWidth
;
111 *height
= core
->bcHeight
;
112 *planes
= core
->bcPlanes
;
113 *bpp
= core
->bcBitCount
;
119 if (header
->biSize
== sizeof(BITMAPINFOHEADER
))
121 *width
= header
->biWidth
;
122 *height
= header
->biHeight
;
123 *planes
= header
->biPlanes
;
124 *bpp
= header
->biBitCount
;
125 *compr
= header
->biCompression
;
126 *size
= header
->biSizeImage
;
130 if (header
->biSize
== sizeof(BITMAPV4HEADER
))
132 BITMAPV4HEADER
*v4hdr
= (BITMAPV4HEADER
*)header
;
133 *width
= v4hdr
->bV4Width
;
134 *height
= v4hdr
->bV4Height
;
135 *planes
= v4hdr
->bV4Planes
;
136 *bpp
= v4hdr
->bV4BitCount
;
137 *compr
= v4hdr
->bV4V4Compression
;
138 *size
= v4hdr
->bV4SizeImage
;
142 if (header
->biSize
== sizeof(BITMAPV5HEADER
))
144 BITMAPV5HEADER
*v5hdr
= (BITMAPV5HEADER
*)header
;
145 *width
= v5hdr
->bV5Width
;
146 *height
= v5hdr
->bV5Height
;
147 *planes
= v5hdr
->bV5Planes
;
148 *bpp
= v5hdr
->bV5BitCount
;
149 *compr
= v5hdr
->bV5Compression
;
150 *size
= v5hdr
->bV5SizeImage
;
153 DPRINT("(%ld): wrong size for header\n", header
->biSize
);
162 GdiGetBitmapBitsSize(BITMAPINFO
*lpbmi
)
166 if (lpbmi
->bmiHeader
.biSize
== FIELD_OFFSET(BITMAPINFOHEADER
, biPlanes
))
168 /* Calc the bits Size and align it*/
169 retSize
= HIWORD(lpbmi
->bmiHeader
.biWidth
) * ((LOWORD(lpbmi
->bmiHeader
.biWidth
) *
170 LOWORD(lpbmi
->bmiHeader
.biHeight
) * HIWORD(lpbmi
->bmiHeader
.biHeight
) + 31)
175 if ( (lpbmi
->bmiHeader
.biCompression
== BI_BITFIELDS
) ||
176 (lpbmi
->bmiHeader
.biCompression
== BI_RGB
))
178 if (lpbmi
->bmiHeader
.biHeight
>=0 )
180 /* Calc the bits Size and align it*/
181 retSize
= lpbmi
->bmiHeader
.biHeight
* ((lpbmi
->bmiHeader
.biWidth
*
182 lpbmi
->bmiHeader
.biPlanes
* lpbmi
->bmiHeader
.biBitCount
+ 31) & -32) / 8;
186 /* Make height postiive if it negitve then calc the bits Size and align it*/
187 retSize
= (-lpbmi
->bmiHeader
.biHeight
) * ((lpbmi
->bmiHeader
.biWidth
*
188 lpbmi
->bmiHeader
.biPlanes
* lpbmi
->bmiHeader
.biBitCount
+ 31) & -32) / 8;
193 retSize
= lpbmi
->bmiHeader
.biSizeImage
;
205 CONST BITMAPINFO
*BitmapInfo
,
211 PBITMAPINFO pConvertedInfo
;
212 UINT ConvertedInfoSize
;
213 HBITMAP hBitmap
= NULL
;
216 pConvertedInfo
= ConvertBitmapInfo(BitmapInfo
, Usage
,
217 &ConvertedInfoSize
, FALSE
);
220 // Verify header due to converted may == info.
221 if ( pConvertedInfo
->bmiHeader
.biSize
>= sizeof(BITMAPINFOHEADER
) )
223 if ( pConvertedInfo
->bmiHeader
.biCompression
== BI_JPEG
||
224 pConvertedInfo
->bmiHeader
.biCompression
== BI_PNG
)
226 SetLastError(ERROR_INVALID_PARAMETER
);
231 hBitmap
= NtGdiCreateDIBSection( hDC
,
240 if (BitmapInfo
!= pConvertedInfo
)
241 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo
);
249 if (Bits
) *Bits
= bmBits
;
260 BitBlt(HDC hdcDest
, /* handle to destination DC */
261 int nXOriginDest
, /* x-coord of destination upper-left corner */
262 int nYOriginDest
, /* y-coord of destination upper-left corner */
263 int nWidthDest
, /* width of destination rectangle */
264 int nHeightDest
, /* height of destination rectangle */
265 HDC hdcSrc
, /* handle to source DC */
266 int nXSrc
, /* x-coordinate of source upper-left corner */
267 int nYSrc
, /* y-coordinate of source upper-left corner */
268 DWORD dwRop
) /* raster operation code */
270 /* use patBlt for no source blt Like windows does */
271 if (!ROP_USES_SOURCE(dwRop
))
273 return PatBlt(hdcDest
, nXOriginDest
, nYOriginDest
, nWidthDest
, nHeightDest
, dwRop
);
276 return NtGdiBitBlt(hdcDest
,
294 HDC hdcDest
, /* handle to destination DC */
295 int nXOriginDest
, /* x-coord of destination upper-left corner */
296 int nYOriginDest
, /* y-coord of destination upper-left corner */
297 int nWidthDest
, /* width of destination rectangle */
298 int nHeightDest
, /* height of destination rectangle */
299 HDC hdcSrc
, /* handle to source DC */
300 int nXOriginSrc
, /* x-coord of source upper-left corner */
301 int nYOriginSrc
, /* y-coord of source upper-left corner */
302 int nWidthSrc
, /* width of source rectangle */
303 int nHeightSrc
, /* height of source rectangle */
304 DWORD dwRop
) /* raster operation code */
307 if ((nWidthDest
!= nWidthSrc
) || (nHeightDest
!= nHeightSrc
))
309 return NtGdiStretchBlt(hdcDest
, nXOriginDest
, nYOriginDest
, nWidthDest
,
310 nHeightDest
, hdcSrc
, nXOriginSrc
, nYOriginSrc
,
311 nWidthSrc
, nHeightSrc
, dwRop
, 0);
314 return NtGdiBitBlt(hdcDest
, nXOriginDest
, nYOriginDest
, nWidthDest
,
315 nHeightDest
, hdcSrc
, nXOriginSrc
, nYOriginSrc
, dwRop
, 0, 0);
322 CreateBitmap(INT Width
,
326 CONST VOID
* pUnsafeBits
)
328 /* FIXME some part should be done in user mode */
331 return NtGdiCreateBitmap(Width
, Height
, Planes
, BitsPixel
, (LPBYTE
) pUnsafeBits
);
335 /* Return 1x1 bitmap */
336 return GetStockObject(DEFAULT_BITMAP
);
344 CreateBitmapIndirect(const BITMAP
*pbm
)
346 HBITMAP bitmap
= NULL
;
348 /* Note windows xp/2003 does not check if pbm is NULL or not */
349 if ( (pbm
->bmWidthBytes
!= 0) &&
350 (!(pbm
->bmWidthBytes
& 1)) )
354 bitmap
= CreateBitmap(pbm
->bmWidth
,
362 SetLastError(ERROR_INVALID_PARAMETER
);
369 CreateDiscardableBitmap(
374 return CreateCompatibleBitmap(hDC
, Width
, Height
);
379 CreateCompatibleBitmap(
388 if (!GdiGetHandleUserData(hDC
, GDI_OBJECT_TYPE_DC
, (PVOID
)&pDc_Attr
))
391 if ( !Width
|| !Height
)
392 return GetStockObject(DEFAULT_BITMAP
);
394 if (!(pDc_Attr
->ulDirty_
& DC_DIBSECTION
))
396 return NtGdiCreateCompatibleBitmap(hDC
, Width
, Height
);
399 hBmp
= NtGdiGetDCObject(hDC
, GDI_OBJECT_TYPE_BITMAP
);
401 if ( GetObjectA(hBmp
, sizeof(DIBSECTION
), &dibs
) != sizeof(DIBSECTION
) )
404 if ( dibs
.dsBm
.bmBitsPixel
<= 8 )
405 GetDIBColorTable(hDC
, 0, 256, (RGBQUAD
*)&dibs
.dsBitfields
);
407 dibs
.dsBmih
.biWidth
= Width
;
408 dibs
.dsBmih
.biHeight
= Height
;
410 return CreateDIBSection(hDC
, (CONST BITMAPINFO
*)&dibs
.dsBmih
, 0, NULL
, NULL
, 0);
414 ConvertBackBitmapInfo(PBITMAPINFO pbmi
, PBITMAPINFO pbmiConverted
)
418 /* Check if we converted from PBITMAPCOREINFO */
419 if (pbmiConverted
!= pbmi
)
421 PBITMAPCOREINFO pbci
= (PBITMAPCOREINFO
)pbmi
;
423 /* Convert back header */
424 pbci
->bmciHeader
.bcSize
= sizeof(BITMAPCOREHEADER
);
425 pbci
->bmciHeader
.bcWidth
= pbmiConverted
->bmiHeader
.biWidth
;
426 pbci
->bmciHeader
.bcHeight
= pbmiConverted
->bmiHeader
.biHeight
;
427 pbci
->bmciHeader
.bcPlanes
= 1;
428 pbci
->bmciHeader
.bcBitCount
= pbmiConverted
->bmiHeader
.biBitCount
;
430 /* Convert back colors */
431 for (i
= 0; i
< pbmiConverted
->bmiHeader
.biClrUsed
; i
++)
433 pbci
->bmciColors
[i
].rgbtRed
= pbmiConverted
->bmiColors
[i
].rgbRed
;
434 pbci
->bmciColors
[i
].rgbtGreen
= pbmiConverted
->bmiColors
[i
].rgbGreen
;
435 pbci
->bmciColors
[i
].rgbtBlue
= pbmiConverted
->bmiColors
[i
].rgbBlue
;
439 RtlFreeHeap(RtlGetProcessHeap(), 0, pbmiConverted
);
454 PBITMAPINFO pbmiConverted
;
455 UINT cjBmpScanSize
, cjInfoSize
;
458 if (!hDC
|| !GdiIsHandleValid((HGDIOBJ
)hDC
) || !lpbmi
)
460 GdiSetLastError(ERROR_INVALID_PARAMETER
);
464 /* Convert BITMAPINFO to a proper format */
465 pbmiConverted
= ConvertBitmapInfo(lpbmi
, uUsage
, &cjInfoSize
, FALSE
);
468 GdiSetLastError(ERROR_INVALID_PARAMETER
);
472 cjBmpScanSize
= DIB_BitmapMaxBitsSize(lpbmi
, cScanLines
);
476 if (lpbmi
->bmiHeader
.biSize
>= sizeof(BITMAPINFOHEADER
))
478 if (lpbmi
->bmiHeader
.biCompression
== BI_JPEG
||
479 lpbmi
->bmiHeader
.biCompression
== BI_PNG
)
481 SetLastError(ERROR_INVALID_PARAMETER
);
487 iResult
= NtGdiGetDIBitsInternal(hDC
,
497 ConvertBackBitmapInfo(lpbmi
, pbmiConverted
);
508 CreateDIBitmap( HDC hDC
,
509 const BITMAPINFOHEADER
*Header
,
512 const BITMAPINFO
*Data
,
515 LONG width
, height
, compr
, dibsize
;
517 // PDC_ATTR pDc_Attr;
519 UINT cjBmpScanSize
= 0;
521 NTSTATUS Status
= STATUS_SUCCESS
;
523 if (!Header
) return 0;
525 if (DIB_GetBitmapInfo(Header
, &width
, &height
, &planes
, &bpp
, &compr
, &dibsize
) == -1)
527 GdiSetLastError(ERROR_INVALID_PARAMETER
);
532 // GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
538 cjBmpScanSize
= DIB_BitmapBitsSize(Data
);
539 CalculateColorTableSize(&Data
->bmiHeader
, &ColorUse
, &InfoSize
);
540 InfoSize
+= Data
->bmiHeader
.biSize
;
542 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
544 Status
= _SEH2_GetExceptionCode();
549 if(!NT_SUCCESS(Status
))
551 GdiSetLastError(ERROR_INVALID_PARAMETER
);
555 DPRINT("pBMI %x, Size bpp %d, dibsize %d, Conv %d, BSS %d\n", Data
,bpp
,dibsize
,InfoSize
,cjBmpScanSize
);
557 if ( !width
|| !height
)
558 hBmp
= GetStockObject(DEFAULT_BITMAP
);
561 hBmp
= NtGdiCreateDIBitmapInternal(hDC
,
576 #if 0 // FIXME!!! This is a victim of the Win32k Initialization BUG!!!!!
587 CONST BITMAPINFO
*lpbmi
,
590 HDC hDCc
, SavehDC
, nhDC
;
591 DWORD dwWidth
, dwHeight
;
593 HPALETTE hPal
= NULL
;
597 if ( !lpvBits
|| (GDI_HANDLE_GET_TYPE(hBitmap
) != GDI_OBJECT_TYPE_BITMAP
) )
602 if ( lpbmi
->bmiHeader
.biSize
>= sizeof(BITMAPINFOHEADER
) )
604 if ( lpbmi
->bmiHeader
.biCompression
== BI_JPEG
|| lpbmi
->bmiHeader
.biCompression
== BI_PNG
)
606 SetLastError(ERROR_INVALID_PARAMETER
);
612 hDCc
= NtGdiGetDCforBitmap(hBitmap
);
616 nhDC
= CreateCompatibleDC(hDC
);
617 if ( !nhDC
) return 0;
621 else if ( !SaveDC(hDCc
) )
624 hOldBitmap
= SelectObject(SavehDC
, hBitmap
);
629 hPal
= SelectPalette(SavehDC
, (HPALETTE
)GetDCObject(hDC
, GDI_OBJECT_TYPE_PALETTE
), FALSE
);
631 if ( lpbmi
->bmiHeader
.biSize
< sizeof(BITMAPINFOHEADER
))
633 PBITMAPCOREINFO pbci
= (PBITMAPCOREINFO
) lpbmi
;
634 dwWidth
= pbci
->bmciHeader
.bcWidth
;
635 dwHeight
= pbci
->bmciHeader
.bcHeight
;
639 dwWidth
= lpbmi
->bmiHeader
.biWidth
;
640 dwHeight
= abs(lpbmi
->bmiHeader
.biHeight
);
643 LinesCopied
= SetDIBitsToDevice(SavehDC
,
656 if ( hDC
) SelectPalette(SavehDC
, hPal
, FALSE
);
658 SelectObject(SavehDC
, hOldBitmap
);
664 RestoreDC(SavehDC
, -1);
677 CONST BITMAPINFO
*lpbmi
,
680 PBITMAPINFO pConvertedInfo
;
681 UINT ConvertedInfoSize
;
683 UINT cjBmpScanSize
= 0;
684 PVOID pvSafeBits
= (PVOID
)lpvBits
;
686 // This needs to be almost the sames as SetDIBitsToDevice
688 if ( !cScanLines
|| !lpbmi
|| !lpvBits
|| (GDI_HANDLE_GET_TYPE(hbmp
) != GDI_OBJECT_TYPE_BITMAP
))
691 if ( fuColorUse
&& fuColorUse
!= DIB_PAL_COLORS
&& fuColorUse
!= DIB_PAL_COLORS
+1 )
694 pConvertedInfo
= ConvertBitmapInfo(lpbmi
, fuColorUse
,
695 &ConvertedInfoSize
, FALSE
);
699 cjBmpScanSize
= DIB_BitmapMaxBitsSize((LPBITMAPINFO
)lpbmi
, cScanLines
);
703 pvSafeBits
= RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize
);
705 RtlCopyMemory( pvSafeBits
, lpvBits
, cjBmpScanSize
);
708 LinesCopied
= NtGdiSetDIBits( hdc
,
716 if ( lpvBits
!= pvSafeBits
)
717 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits
);
718 if (lpbmi
!= pConvertedInfo
)
719 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo
);
740 CONST BITMAPINFO
*lpbmi
,
744 PBITMAPINFO pConvertedInfo
;
745 UINT ConvertedInfoSize
;
747 UINT cjBmpScanSize
= 0;
748 PVOID pvSafeBits
= (PVOID
)Bits
;
750 if ( !ScanLines
|| !lpbmi
|| !Bits
)
753 if ( ColorUse
&& ColorUse
!= DIB_PAL_COLORS
&& ColorUse
!= DIB_PAL_COLORS
+1 )
756 pConvertedInfo
= ConvertBitmapInfo(lpbmi
, ColorUse
,
757 &ConvertedInfoSize
, FALSE
);
762 // Handle something other than a normal dc object.
763 if (GDI_HANDLE_GET_TYPE(hdc
) != GDI_OBJECT_TYPE_DC
)
765 if (GDI_HANDLE_GET_TYPE(hdc
) == GDI_OBJECT_TYPE_METADC
)
766 return MFDRV_SetDIBitsToDevice( hdc
,
780 PLDC pLDC
= GdiGetLDC(hdc
);
783 SetLastError(ERROR_INVALID_HANDLE
);
786 if (pLDC
->iType
== LDC_EMFLDC
)
788 return EMFDRV_SetDIBitsToDevice(hdc
,
805 cjBmpScanSize
= DIB_BitmapMaxBitsSize((LPBITMAPINFO
)lpbmi
, ScanLines
);
809 pvSafeBits
= RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize
);
811 RtlCopyMemory( pvSafeBits
, Bits
, cjBmpScanSize
);
814 if (!GdiGetHandleUserData(hdc
, GDI_OBJECT_TYPE_DC
, (PVOID
)&pDc_Attr
))
816 SetLastError(ERROR_INVALID_PARAMETER
);
821 ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
822 (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
823 pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/
825 LinesCopied
= NtGdiSetDIBitsToDeviceInternal( hdc
,
835 (LPBITMAPINFO
)pConvertedInfo
,
842 if ( Bits
!= pvSafeBits
)
843 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits
);
844 if (lpbmi
!= pConvertedInfo
)
845 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo
);
856 StretchDIBits(HDC hdc
,
866 CONST BITMAPINFO
*lpBitsInfo
,
872 PBITMAPINFO pConvertedInfo
= NULL
;
873 UINT ConvertedInfoSize
= 0;
875 UINT cjBmpScanSize
= 0;
876 PVOID pvSafeBits
= NULL
;
879 DPRINT("StretchDIBits %x : %x : %d\n", lpBits
, lpBitsInfo
, iUsage
);
881 // Handle something other than a normal dc object.
882 if (GDI_HANDLE_GET_TYPE(hdc
) != GDI_OBJECT_TYPE_DC
)
884 if (GDI_HANDLE_GET_TYPE(hdc
) == GDI_OBJECT_TYPE_METADC
)
885 return MFDRV_StretchBlt( hdc
,
900 PLDC pLDC
= GdiGetLDC(hdc
);
903 SetLastError(ERROR_INVALID_HANDLE
);
906 if (pLDC
->iType
== LDC_EMFLDC
)
908 return EMFDRV_StretchBlt(hdc
,
926 pConvertedInfo
= ConvertBitmapInfo(lpBitsInfo
, iUsage
,
927 &ConvertedInfoSize
, FALSE
);
933 cjBmpScanSize
= DIB_BitmapBitsSize((LPBITMAPINFO
)pConvertedInfo
);
937 pvSafeBits
= RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize
);
942 RtlCopyMemory( pvSafeBits
, lpBits
, cjBmpScanSize
);
944 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER
)
952 // We don't die, we continue on with a allocated safe pointer to kernel
954 DPRINT1("StretchDIBits fail to read BitMapInfo: %x or Bits: %x & Size: %d\n",pConvertedInfo
,lpBits
,cjBmpScanSize
);
956 DPRINT("StretchDIBits Allocate Bits %d!!!\n", cjBmpScanSize
);
960 if (!GdiGetHandleUserData(hdc
, GDI_OBJECT_TYPE_DC
, (PVOID
)&pDc_Attr
))
962 SetLastError(ERROR_INVALID_PARAMETER
);
967 ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
968 (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
969 pConvertedInfo->bmiHeader.biCompression == BI_PNG )) )*/
971 LinesCopied
= NtGdiStretchDIBitsInternal( hdc
,
989 RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits
);
990 if (lpBitsInfo
!= pConvertedInfo
)
991 RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo
);