[WIN32SS] Don't trigger ProbeForWrite when retrieving caret size from co_IntDrawCaret...
[reactos.git] / reactos / win32ss / gdi / ntgdi / bitmaps.c
1 /*
2 * COPYRIGHT: GNU GPL, See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Bitmap functions
5 * FILE: win32ss/gdi/ntgdi/bitmaps.c
6 * PROGRAMER: Timo Kreuzer <timo.kreuzer@reactos.org>
7 */
8
9 #include <win32k.h>
10
11 #define NDEBUG
12 #include <debug.h>
13
14 BOOL
15 NTAPI
16 GreSetBitmapOwner(
17 _In_ HBITMAP hbmp,
18 _In_ ULONG ulOwner)
19 {
20 /* Check if we have the correct object type */
21 if (GDI_HANDLE_GET_TYPE(hbmp) != GDILoObjType_LO_BITMAP_TYPE)
22 {
23 DPRINT1("Incorrect type for hbmp: %p\n", hbmp);
24 return FALSE;
25 }
26
27 /// FIXME: this is a hack and doesn't handle a race condition properly.
28 /// It needs to be done in GDIOBJ_vSetObjectOwner atomically.
29
30 /* Check if we set public or none */
31 if ((ulOwner == GDI_OBJ_HMGR_PUBLIC) ||
32 (ulOwner == GDI_OBJ_HMGR_NONE))
33 {
34 /* Only allow this for owned objects */
35 if (GreGetObjectOwner(hbmp) != GDI_OBJ_HMGR_POWNED)
36 {
37 DPRINT1("Cannot change owner for non-powned hbmp\n");
38 return FALSE;
39 }
40 }
41
42 return GreSetObjectOwner(hbmp, ulOwner);
43 }
44
45 BOOL
46 NTAPI
47 UnsafeSetBitmapBits(
48 _Inout_ PSURFACE psurf,
49 _In_ ULONG cjBits,
50 _In_ const VOID *pvBits)
51 {
52 PUCHAR pjDst;
53 const UCHAR *pjSrc;
54 LONG lDeltaDst, lDeltaSrc;
55 ULONG nWidth, nHeight, cBitsPixel;
56 NT_ASSERT(psurf->flags & API_BITMAP);
57 NT_ASSERT(psurf->SurfObj.iBitmapFormat <= BMF_32BPP);
58
59 nWidth = psurf->SurfObj.sizlBitmap.cx;
60 nHeight = psurf->SurfObj.sizlBitmap.cy;
61 cBitsPixel = BitsPerFormat(psurf->SurfObj.iBitmapFormat);
62
63 /* Get pointers */
64 pjDst = psurf->SurfObj.pvScan0;
65 pjSrc = pvBits;
66 lDeltaDst = psurf->SurfObj.lDelta;
67 lDeltaSrc = WIDTH_BYTES_ALIGN16(nWidth, cBitsPixel);
68 NT_ASSERT(lDeltaSrc <= abs(lDeltaDst));
69
70 /* Make sure the buffer is large enough*/
71 if (cjBits < (lDeltaSrc * nHeight))
72 return FALSE;
73
74 while (nHeight--)
75 {
76 /* Copy one line */
77 memcpy(pjDst, pjSrc, lDeltaSrc);
78 pjSrc += lDeltaSrc;
79 pjDst += lDeltaDst;
80 }
81
82 return TRUE;
83 }
84
85 HBITMAP
86 NTAPI
87 GreCreateBitmapEx(
88 _In_ ULONG nWidth,
89 _In_ ULONG nHeight,
90 _In_ ULONG cjWidthBytes,
91 _In_ ULONG iFormat,
92 _In_ USHORT fjBitmap,
93 _In_ ULONG cjSizeImage,
94 _In_opt_ PVOID pvBits,
95 _In_ FLONG flags)
96 {
97 PSURFACE psurf;
98 HBITMAP hbmp;
99 PVOID pvCompressedBits = NULL;
100
101 /* Verify format */
102 if (iFormat < BMF_1BPP || iFormat > BMF_PNG) return NULL;
103
104 /* The infamous RLE hack */
105 if ((iFormat == BMF_4RLE) || (iFormat == BMF_8RLE))
106 {
107 pvCompressedBits = pvBits;
108 pvBits = NULL;
109 iFormat = (iFormat == BMF_4RLE) ? BMF_4BPP : BMF_8BPP;
110 }
111
112 /* Allocate a surface */
113 psurf = SURFACE_AllocSurface(STYPE_BITMAP,
114 nWidth,
115 nHeight,
116 iFormat,
117 fjBitmap,
118 cjWidthBytes,
119 pvCompressedBits ? 0 : cjSizeImage,
120 pvBits);
121 if (!psurf)
122 {
123 DPRINT1("SURFACE_AllocSurface failed.\n");
124 return NULL;
125 }
126
127 /* The infamous RLE hack */
128 if (pvCompressedBits)
129 {
130 SIZEL sizl;
131 LONG lDelta;
132
133 sizl.cx = nWidth;
134 sizl.cy = nHeight;
135 lDelta = WIDTH_BYTES_ALIGN32(nWidth, gajBitsPerFormat[iFormat]);
136
137 pvBits = psurf->SurfObj.pvBits;
138 DecompressBitmap(sizl, pvCompressedBits, pvBits, lDelta, iFormat, cjSizeImage);
139 }
140
141 /* Get the handle for the bitmap */
142 hbmp = (HBITMAP)psurf->SurfObj.hsurf;
143
144 /* Mark as API bitmap */
145 psurf->flags |= (flags | API_BITMAP);
146
147 /* Unlock the surface and return */
148 SURFACE_UnlockSurface(psurf);
149 return hbmp;
150 }
151
152 /* Creates a DDB surface,
153 * as in CreateCompatibleBitmap or CreateBitmap.
154 * Note that each scanline must be 32bit aligned!
155 */
156 HBITMAP
157 NTAPI
158 GreCreateBitmap(
159 _In_ ULONG nWidth,
160 _In_ ULONG nHeight,
161 _In_ ULONG cPlanes,
162 _In_ ULONG cBitsPixel,
163 _In_opt_ PVOID pvBits)
164 {
165 /* Call the extended function */
166 return GreCreateBitmapEx(nWidth,
167 nHeight,
168 0, /* Auto width */
169 BitmapFormat(cBitsPixel * cPlanes, BI_RGB),
170 0, /* No bitmap flags */
171 0, /* Auto size */
172 pvBits,
173 DDB_SURFACE /* DDB */);
174 }
175
176 HBITMAP
177 APIENTRY
178 NtGdiCreateBitmap(
179 IN INT nWidth,
180 IN INT nHeight,
181 IN UINT cPlanes,
182 IN UINT cBitsPixel,
183 IN OPTIONAL LPBYTE pUnsafeBits)
184 {
185 HBITMAP hbmp;
186 ULONG cRealBpp, cjWidthBytes, iFormat;
187 ULONGLONG cjSize;
188 PSURFACE psurf;
189
190 /* Calculate bitmap format and real bits per pixel. */
191 iFormat = BitmapFormat(cBitsPixel * cPlanes, BI_RGB);
192 cRealBpp = gajBitsPerFormat[iFormat];
193
194 /* Calculate width and image size in bytes */
195 cjWidthBytes = WIDTH_BYTES_ALIGN16(nWidth, cRealBpp);
196 cjSize = (ULONGLONG)cjWidthBytes * nHeight;
197
198 /* Check parameters (possible overflow of cjSize!) */
199 if ((iFormat == 0) || (nWidth <= 0) || (nWidth >= 0x8000000) || (nHeight <= 0) ||
200 (cBitsPixel > 32) || (cPlanes > 32) || (cjSize >= 0x100000000ULL))
201 {
202 DPRINT1("Invalid bitmap format! Width=%d, Height=%d, Bpp=%u, Planes=%u\n",
203 nWidth, nHeight, cBitsPixel, cPlanes);
204 EngSetLastError(ERROR_INVALID_PARAMETER);
205 return NULL;
206 }
207
208 /* Allocate the surface (but don't set the bits) */
209 psurf = SURFACE_AllocSurface(STYPE_BITMAP,
210 nWidth,
211 nHeight,
212 iFormat,
213 0,
214 0,
215 0,
216 NULL);
217 if (!psurf)
218 {
219 DPRINT1("SURFACE_AllocSurface failed.\n");
220 return NULL;
221 }
222
223 /* Mark as API and DDB bitmap */
224 psurf->flags |= (API_BITMAP | DDB_SURFACE);
225
226 /* Check if we have bits to set */
227 if (pUnsafeBits)
228 {
229 /* Protect with SEH and copy the bits */
230 _SEH2_TRY
231 {
232 ProbeForRead(pUnsafeBits, (SIZE_T)cjSize, 1);
233 UnsafeSetBitmapBits(psurf, cjSize, pUnsafeBits);
234 }
235 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
236 {
237 GDIOBJ_vDeleteObject(&psurf->BaseObject);
238 _SEH2_YIELD(return NULL;)
239 }
240 _SEH2_END
241 }
242 else
243 {
244 /* Zero the bits */
245 RtlZeroMemory(psurf->SurfObj.pvBits, psurf->SurfObj.cjBits);
246 }
247
248 /* Get the handle for the bitmap */
249 hbmp = (HBITMAP)psurf->SurfObj.hsurf;
250
251 /* Unlock the surface */
252 SURFACE_UnlockSurface(psurf);
253
254 return hbmp;
255 }
256
257
258 HBITMAP FASTCALL
259 IntCreateCompatibleBitmap(
260 PDC Dc,
261 INT Width,
262 INT Height,
263 UINT Planes,
264 UINT Bpp)
265 {
266 HBITMAP Bmp = NULL;
267 PPALETTE ppal;
268
269 /* MS doc says if width or height is 0, return 1-by-1 pixel, monochrome bitmap */
270 if (0 == Width || 0 == Height)
271 {
272 return NtGdiGetStockObject(DEFAULT_BITMAP);
273 }
274
275 if (Dc->dctype != DC_TYPE_MEMORY)
276 {
277 PSURFACE psurf;
278
279 Bmp = GreCreateBitmap(abs(Width),
280 abs(Height),
281 Planes ? Planes : 1,
282 Bpp ? Bpp : Dc->ppdev->gdiinfo.cBitsPixel,
283 NULL);
284 if (Bmp == NULL)
285 {
286 DPRINT1("Failed to allocate a bitmap!\n");
287 return NULL;
288 }
289
290 psurf = SURFACE_ShareLockSurface(Bmp);
291 ASSERT(psurf);
292
293 /* Dereference old palette and set new palette */
294 ppal = PALETTE_ShareLockPalette(Dc->ppdev->devinfo.hpalDefault);
295 ASSERT(ppal);
296 SURFACE_vSetPalette(psurf, ppal);
297 PALETTE_ShareUnlockPalette(ppal);
298
299 /* Set flags */
300 psurf->flags = API_BITMAP;
301 psurf->hdc = NULL; // FIXME:
302 psurf->SurfObj.hdev = (HDEV)Dc->ppdev;
303 SURFACE_ShareUnlockSurface(psurf);
304 }
305 else
306 {
307 DIBSECTION dibs;
308 INT Count;
309 PSURFACE psurf = Dc->dclevel.pSurface;
310 if(!psurf) psurf = psurfDefaultBitmap;
311 Count = BITMAP_GetObject(psurf, sizeof(dibs), &dibs);
312
313 if (Count == sizeof(BITMAP))
314 {
315 PSURFACE psurfBmp;
316
317 Bmp = GreCreateBitmap(abs(Width),
318 abs(Height),
319 Planes ? Planes : 1,
320 Bpp ? Bpp : dibs.dsBm.bmBitsPixel,
321 NULL);
322 psurfBmp = SURFACE_ShareLockSurface(Bmp);
323 ASSERT(psurfBmp);
324
325 /* Dereference old palette and set new palette */
326 SURFACE_vSetPalette(psurfBmp, psurf->ppal);
327
328 /* Set flags */
329 psurfBmp->flags = API_BITMAP;
330 psurfBmp->hdc = NULL; // FIXME:
331 psurf->SurfObj.hdev = (HDEV)Dc->ppdev;
332 SURFACE_ShareUnlockSurface(psurfBmp);
333 }
334 else if (Count == sizeof(DIBSECTION))
335 {
336 /* A DIB section is selected in the DC */
337 BYTE buf[sizeof(BITMAPINFOHEADER) + 256*sizeof(RGBQUAD)] = {0};
338 PVOID Bits;
339 BITMAPINFO* bi = (BITMAPINFO*)buf;
340
341 bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
342 bi->bmiHeader.biWidth = Width;
343 bi->bmiHeader.biHeight = Height;
344 bi->bmiHeader.biPlanes = Planes ? Planes : dibs.dsBmih.biPlanes;
345 bi->bmiHeader.biBitCount = Bpp ? Bpp : dibs.dsBmih.biBitCount;
346 bi->bmiHeader.biCompression = dibs.dsBmih.biCompression;
347 bi->bmiHeader.biSizeImage = 0;
348 bi->bmiHeader.biXPelsPerMeter = dibs.dsBmih.biXPelsPerMeter;
349 bi->bmiHeader.biYPelsPerMeter = dibs.dsBmih.biYPelsPerMeter;
350 bi->bmiHeader.biClrUsed = dibs.dsBmih.biClrUsed;
351 bi->bmiHeader.biClrImportant = dibs.dsBmih.biClrImportant;
352
353 if (bi->bmiHeader.biCompression == BI_BITFIELDS)
354 {
355 /* Copy the color masks */
356 RtlCopyMemory(bi->bmiColors, dibs.dsBitfields, 3*sizeof(RGBQUAD));
357 }
358 else if (bi->bmiHeader.biBitCount <= 8)
359 {
360 /* Copy the color table */
361 UINT Index;
362 PPALETTE PalGDI;
363
364 if (!psurf->ppal)
365 {
366 EngSetLastError(ERROR_INVALID_HANDLE);
367 return 0;
368 }
369
370 PalGDI = psurf->ppal;
371
372 for (Index = 0;
373 Index < 256 && Index < PalGDI->NumColors;
374 Index++)
375 {
376 bi->bmiColors[Index].rgbRed = PalGDI->IndexedColors[Index].peRed;
377 bi->bmiColors[Index].rgbGreen = PalGDI->IndexedColors[Index].peGreen;
378 bi->bmiColors[Index].rgbBlue = PalGDI->IndexedColors[Index].peBlue;
379 bi->bmiColors[Index].rgbReserved = 0;
380 }
381 }
382
383 Bmp = DIB_CreateDIBSection(Dc,
384 bi,
385 DIB_RGB_COLORS,
386 &Bits,
387 NULL,
388 0,
389 0);
390 return Bmp;
391 }
392 }
393 return Bmp;
394 }
395
396 HBITMAP APIENTRY
397 NtGdiCreateCompatibleBitmap(
398 HDC hDC,
399 INT Width,
400 INT Height)
401 {
402 HBITMAP Bmp;
403 PDC Dc;
404
405 /* Check parameters */
406 if ((Width <= 0) || (Height <= 0) || ((Width * Height) > 0x3FFFFFFF))
407 {
408 EngSetLastError(ERROR_INVALID_PARAMETER);
409 return NULL;
410 }
411
412 if (!hDC)
413 return GreCreateBitmap(Width, Height, 1, 1, 0);
414
415 Dc = DC_LockDc(hDC);
416
417 DPRINT("NtGdiCreateCompatibleBitmap(%p,%d,%d, bpp:%u) = \n",
418 hDC, Width, Height, Dc->ppdev->gdiinfo.cBitsPixel);
419
420 if (NULL == Dc)
421 {
422 EngSetLastError(ERROR_INVALID_HANDLE);
423 return NULL;
424 }
425
426 Bmp = IntCreateCompatibleBitmap(Dc, Width, Height, 0, 0);
427
428 DC_UnlockDc(Dc);
429 return Bmp;
430 }
431
432 BOOL
433 NTAPI
434 GreGetBitmapDimension(
435 _In_ HBITMAP hBitmap,
436 _Out_ LPSIZE psizDim)
437 {
438 PSURFACE psurfBmp;
439
440 if (hBitmap == NULL)
441 return FALSE;
442
443 /* Lock the bitmap */
444 psurfBmp = SURFACE_ShareLockSurface(hBitmap);
445 if (psurfBmp == NULL)
446 {
447 EngSetLastError(ERROR_INVALID_HANDLE);
448 return FALSE;
449 }
450
451 *psizDim = psurfBmp->sizlDim;
452
453 /* Unlock the bitmap */
454 SURFACE_ShareUnlockSurface(psurfBmp);
455
456 return TRUE;
457 }
458
459 BOOL
460 APIENTRY
461 NtGdiGetBitmapDimension(
462 HBITMAP hBitmap,
463 LPSIZE psizDim)
464 {
465 SIZE dim;
466
467 if (!GreGetBitmapDimension(hBitmap, &dim))
468 return FALSE;
469
470 /* Use SEH to copy the data to the caller */
471 _SEH2_TRY
472 {
473 ProbeForWrite(psizDim, sizeof(*psizDim), 1);
474 *psizDim = dim;
475 }
476 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
477 {
478 _SEH2_YIELD(return FALSE);
479 }
480 _SEH2_END
481
482 return TRUE;
483 }
484
485
486 VOID
487 FASTCALL
488 UnsafeGetBitmapBits(
489 PSURFACE psurf,
490 DWORD Bytes,
491 OUT PBYTE pvBits)
492 {
493 PUCHAR pjDst, pjSrc;
494 LONG lDeltaDst, lDeltaSrc;
495 ULONG nWidth, nHeight, cBitsPixel;
496
497 nWidth = psurf->SurfObj.sizlBitmap.cx;
498 nHeight = psurf->SurfObj.sizlBitmap.cy;
499 cBitsPixel = BitsPerFormat(psurf->SurfObj.iBitmapFormat);
500
501 /* Get pointers */
502 pjSrc = psurf->SurfObj.pvScan0;
503 pjDst = pvBits;
504 lDeltaSrc = psurf->SurfObj.lDelta;
505 lDeltaDst = WIDTH_BYTES_ALIGN16(nWidth, cBitsPixel);
506
507 while (nHeight--)
508 {
509 /* Copy one line */
510 RtlCopyMemory(pjDst, pjSrc, lDeltaDst);
511 pjSrc += lDeltaSrc;
512 pjDst += lDeltaDst;
513 }
514 }
515
516 LONG
517 APIENTRY
518 NtGdiGetBitmapBits(
519 HBITMAP hBitmap,
520 ULONG cjBuffer,
521 OUT OPTIONAL PBYTE pUnsafeBits)
522 {
523 PSURFACE psurf;
524 ULONG cjSize;
525 LONG ret;
526
527 /* Check parameters */
528 if (pUnsafeBits != NULL && cjBuffer == 0)
529 {
530 return 0;
531 }
532
533 /* Lock the bitmap */
534 psurf = SURFACE_ShareLockSurface(hBitmap);
535 if (!psurf)
536 {
537 EngSetLastError(ERROR_INVALID_HANDLE);
538 return 0;
539 }
540
541 /* Calculate the size of the bitmap in bytes */
542 cjSize = WIDTH_BYTES_ALIGN16(psurf->SurfObj.sizlBitmap.cx,
543 BitsPerFormat(psurf->SurfObj.iBitmapFormat)) *
544 abs(psurf->SurfObj.sizlBitmap.cy);
545
546 /* If the bits vector is null, the function should return the read size */
547 if (pUnsafeBits == NULL)
548 {
549 SURFACE_ShareUnlockSurface(psurf);
550 return cjSize;
551 }
552
553 /* Don't copy more bytes than the buffer has */
554 cjBuffer = min(cjBuffer, cjSize);
555
556 // FIXME: Use MmSecureVirtualMemory
557 _SEH2_TRY
558 {
559 ProbeForWrite(pUnsafeBits, cjBuffer, 1);
560 UnsafeGetBitmapBits(psurf, cjBuffer, pUnsafeBits);
561 ret = cjBuffer;
562 }
563 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
564 {
565 ret = 0;
566 }
567 _SEH2_END
568
569 SURFACE_ShareUnlockSurface(psurf);
570
571 return ret;
572 }
573
574
575 LONG APIENTRY
576 NtGdiSetBitmapBits(
577 HBITMAP hBitmap,
578 DWORD Bytes,
579 IN PBYTE pUnsafeBits)
580 {
581 LONG ret;
582 PSURFACE psurf;
583
584 if (pUnsafeBits == NULL || Bytes == 0)
585 {
586 return 0;
587 }
588
589 if (GDI_HANDLE_IS_STOCKOBJ(hBitmap))
590 {
591 return 0;
592 }
593
594 psurf = SURFACE_ShareLockSurface(hBitmap);
595 if (psurf == NULL)
596 {
597 EngSetLastError(ERROR_INVALID_HANDLE);
598 return 0;
599 }
600
601 if (((psurf->flags & API_BITMAP) == 0) ||
602 (psurf->SurfObj.iBitmapFormat > BMF_32BPP))
603 {
604 DPRINT1("Invalid bitmap: iBitmapFormat = %lu, flags = 0x%lx\n",
605 psurf->SurfObj.iBitmapFormat,
606 psurf->flags);
607 EngSetLastError(ERROR_INVALID_HANDLE);
608 SURFACE_ShareUnlockSurface(psurf);
609 return 0;
610 }
611
612 _SEH2_TRY
613 {
614 ProbeForRead(pUnsafeBits, Bytes, sizeof(WORD));
615 ret = UnsafeSetBitmapBits(psurf, Bytes, pUnsafeBits);
616 }
617 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
618 {
619 ret = 0;
620 }
621 _SEH2_END
622
623 SURFACE_ShareUnlockSurface(psurf);
624
625 return ret;
626 }
627
628 BOOL APIENTRY
629 NtGdiSetBitmapDimension(
630 HBITMAP hBitmap,
631 INT Width,
632 INT Height,
633 LPSIZE Size)
634 {
635 PSURFACE psurf;
636 BOOL Ret = TRUE;
637
638 if (hBitmap == NULL)
639 return FALSE;
640
641 psurf = SURFACE_ShareLockSurface(hBitmap);
642 if (psurf == NULL)
643 {
644 EngSetLastError(ERROR_INVALID_HANDLE);
645 return FALSE;
646 }
647
648 if (Size)
649 {
650 _SEH2_TRY
651 {
652 ProbeForWrite(Size, sizeof(SIZE), 1);
653 *Size = psurf->sizlDim;
654 }
655 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
656 {
657 Ret = FALSE;
658 }
659 _SEH2_END
660 }
661
662 /* The dimension is changed even if writing the old value failed */
663 psurf->sizlDim.cx = Width;
664 psurf->sizlDim.cy = Height;
665
666 SURFACE_ShareUnlockSurface(psurf);
667
668 return Ret;
669 }
670
671 /* Internal Functions */
672
673 HBITMAP
674 FASTCALL
675 BITMAP_CopyBitmap(HBITMAP hBitmap)
676 {
677 HBITMAP hbmNew;
678 SURFACE *psurfSrc, *psurfNew;
679
680 /* Fail, if no source bitmap is given */
681 if (hBitmap == NULL) return 0;
682
683 /* Lock the source bitmap */
684 psurfSrc = SURFACE_ShareLockSurface(hBitmap);
685 if (psurfSrc == NULL)
686 {
687 return 0;
688 }
689
690 /* Allocate a new bitmap with the same dimensions as the source bmp */
691 hbmNew = GreCreateBitmapEx(psurfSrc->SurfObj.sizlBitmap.cx,
692 psurfSrc->SurfObj.sizlBitmap.cy,
693 abs(psurfSrc->SurfObj.lDelta),
694 psurfSrc->SurfObj.iBitmapFormat,
695 psurfSrc->SurfObj.fjBitmap & BMF_TOPDOWN,
696 psurfSrc->SurfObj.cjBits,
697 NULL,
698 psurfSrc->flags);
699
700 if (hbmNew)
701 {
702 /* Lock the new bitmap */
703 psurfNew = SURFACE_ShareLockSurface(hbmNew);
704 if (psurfNew)
705 {
706 /* Copy the bitmap bits to the new bitmap buffer */
707 RtlCopyMemory(psurfNew->SurfObj.pvBits,
708 psurfSrc->SurfObj.pvBits,
709 psurfNew->SurfObj.cjBits);
710
711
712 /* Reference the palette of the source bitmap and use it */
713 SURFACE_vSetPalette(psurfNew, psurfSrc->ppal);
714
715 /* Unlock the new surface */
716 SURFACE_ShareUnlockSurface(psurfNew);
717 }
718 else
719 {
720 /* Failed to lock the bitmap, shouldn't happen */
721 GreDeleteObject(hbmNew);
722 hbmNew = NULL;
723 }
724 }
725
726 /* Unlock the source bitmap and return the handle of the new bitmap */
727 SURFACE_ShareUnlockSurface(psurfSrc);
728 return hbmNew;
729 }
730
731 INT APIENTRY
732 BITMAP_GetObject(SURFACE *psurf, INT Count, LPVOID buffer)
733 {
734 PBITMAP pBitmap;
735
736 if (!buffer) return sizeof(BITMAP);
737 if ((UINT)Count < sizeof(BITMAP)) return 0;
738
739 /* Always fill a basic BITMAP structure */
740 pBitmap = buffer;
741 pBitmap->bmType = 0;
742 pBitmap->bmWidth = psurf->SurfObj.sizlBitmap.cx;
743 pBitmap->bmHeight = psurf->SurfObj.sizlBitmap.cy;
744 pBitmap->bmPlanes = 1;
745 pBitmap->bmBitsPixel = BitsPerFormat(psurf->SurfObj.iBitmapFormat);
746 pBitmap->bmWidthBytes = WIDTH_BYTES_ALIGN16(pBitmap->bmWidth, pBitmap->bmBitsPixel);
747
748 /* Check for DIB section */
749 if (psurf->hSecure)
750 {
751 /* Set bmBits in this case */
752 pBitmap->bmBits = psurf->SurfObj.pvBits;
753 /* DIBs data are 32 bits aligned */
754 pBitmap->bmWidthBytes = WIDTH_BYTES_ALIGN32(pBitmap->bmWidth, pBitmap->bmBitsPixel);
755
756 if (Count >= sizeof(DIBSECTION))
757 {
758 /* Fill rest of DIBSECTION */
759 PDIBSECTION pds = buffer;
760
761 pds->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
762 pds->dsBmih.biWidth = pds->dsBm.bmWidth;
763 pds->dsBmih.biHeight = pds->dsBm.bmHeight;
764 pds->dsBmih.biPlanes = pds->dsBm.bmPlanes;
765 pds->dsBmih.biBitCount = pds->dsBm.bmBitsPixel;
766
767 switch (psurf->SurfObj.iBitmapFormat)
768 {
769 case BMF_1BPP:
770 case BMF_4BPP:
771 case BMF_8BPP:
772 pds->dsBmih.biCompression = BI_RGB;
773 break;
774
775 case BMF_16BPP:
776 if (psurf->ppal->flFlags & PAL_RGB16_555)
777 pds->dsBmih.biCompression = BI_RGB;
778 else
779 pds->dsBmih.biCompression = BI_BITFIELDS;
780 break;
781
782 case BMF_24BPP:
783 case BMF_32BPP:
784 /* 24/32bpp BI_RGB is actually BGR format */
785 if (psurf->ppal->flFlags & PAL_BGR)
786 pds->dsBmih.biCompression = BI_RGB;
787 else
788 pds->dsBmih.biCompression = BI_BITFIELDS;
789 break;
790
791 case BMF_4RLE:
792 pds->dsBmih.biCompression = BI_RLE4;
793 break;
794 case BMF_8RLE:
795 pds->dsBmih.biCompression = BI_RLE8;
796 break;
797 case BMF_JPEG:
798 pds->dsBmih.biCompression = BI_JPEG;
799 break;
800 case BMF_PNG:
801 pds->dsBmih.biCompression = BI_PNG;
802 break;
803 default:
804 ASSERT(FALSE); /* This shouldn't happen */
805 }
806
807 pds->dsBmih.biSizeImage = psurf->SurfObj.cjBits;
808 pds->dsBmih.biXPelsPerMeter = 0;
809 pds->dsBmih.biYPelsPerMeter = 0;
810 pds->dsBmih.biClrUsed = psurf->ppal->NumColors;
811 pds->dsBmih.biClrImportant = psurf->biClrImportant;
812 pds->dsBitfields[0] = psurf->ppal->RedMask;
813 pds->dsBitfields[1] = psurf->ppal->GreenMask;
814 pds->dsBitfields[2] = psurf->ppal->BlueMask;
815 pds->dshSection = psurf->hDIBSection;
816 pds->dsOffset = psurf->dwOffset;
817
818 return sizeof(DIBSECTION);
819 }
820 }
821 else
822 {
823 /* Not set according to wine test, confirmed in win2k */
824 pBitmap->bmBits = NULL;
825 }
826
827 return sizeof(BITMAP);
828 }
829
830 /*
831 * @implemented
832 */
833 HDC
834 APIENTRY
835 NtGdiGetDCforBitmap(
836 IN HBITMAP hsurf)
837 {
838 HDC hdc = NULL;
839 PSURFACE psurf = SURFACE_ShareLockSurface(hsurf);
840 if (psurf)
841 {
842 hdc = psurf->hdc;
843 SURFACE_ShareUnlockSurface(psurf);
844 }
845 return hdc;
846 }
847
848
849 /* EOF */