?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Use the helper to retrieve the number of colours.
[wine.git] / dlls / gdi32 / dib.c
blob5adafcbcdffecbcce7d63af33c6eeb974af1c661
1 /*
2 * GDI device-independent bitmaps
3 *
4 * Copyright 1993,1994 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 /*
22 Important information:
23
24 * Current Windows versions support two different DIB structures:
25
26 - BITMAPCOREINFO / BITMAPCOREHEADER (legacy structures; used in OS/2)
27 - BITMAPINFO / BITMAPINFOHEADER
28
29 Most Windows API functions taking a BITMAPINFO* / BITMAPINFOHEADER* also
30 accept the old "core" structures, and so must WINE.
31 You can distinguish them by looking at the first member (bcSize/biSize),
32 or use the internal function DIB_GetBitmapInfo.
33
34
35 * The palettes are stored in different formats:
36
37 - BITMAPCOREINFO: Array of RGBTRIPLE
38 - BITMAPINFO: Array of RGBQUAD
39
40
41 * There are even more DIB headers, but they all extend BITMAPINFOHEADER:
42
43 - BITMAPV4HEADER: Introduced in Windows 95 / NT 4.0
44 - BITMAPV5HEADER: Introduced in Windows 98 / 2000
45
46 If biCompression is BI_BITFIELDS, the color masks are at the same position
47 in all the headers (they start at bmiColors of BITMAPINFOHEADER), because
48 the new headers have structure members for the masks.
49
50
51 * You should never access the color table using the bmiColors member,
52 because the passed structure may have one of the extended headers
53 mentioned above. Use this to calculate the location:
54
55 BITMAPINFO* info;
56 void* colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
57
58
59 * More information:
60 Search for "Bitmap Structures" in MSDN
61 */
62
63 #include <stdarg.h>
64 #include <stdlib.h>
65 #include <string.h>
66 #include <assert.h>
67
68 #include "windef.h"
69 #include "winbase.h"
70 #include "gdi_private.h"
71 #include "wine/debug.h"
72
73 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
74
75
76 /***********************************************************************
77 * bitmap_info_size
78 *
79 * Return the size of the bitmap info structure including color table.
80 */
81 int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
82 {
83 unsigned int colors, size, masks = 0;
84
85 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
86 {
87 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
88 colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
89 return sizeof(BITMAPCOREHEADER) + colors *
90 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
91 }
92 else /* assume BITMAPINFOHEADER */
93 {
94 colors = get_dib_num_of_colors( info );
95 if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
96 size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
97 return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
98 }
99 }
100
101
102 /***********************************************************************
103 * DIB_GetBitmapInfo
104 *
105 * Get the info from a bitmap header.
106 * Return 0 for COREHEADER, 1 for INFOHEADER, -1 for error.
107 */
108 int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, LONG *width,
109 LONG *height, WORD *planes, WORD *bpp, DWORD *compr, DWORD *size )
110 {
111 if (header->biSize == sizeof(BITMAPCOREHEADER))
112 {
113 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)header;
114 *width = core->bcWidth;
115 *height = core->bcHeight;
116 *planes = core->bcPlanes;
117 *bpp = core->bcBitCount;
118 *compr = 0;
119 *size = 0;
120 return 0;
121 }
122 if (header->biSize >= sizeof(BITMAPINFOHEADER)) /* assume BITMAPINFOHEADER */
123 {
124 *width = header->biWidth;
125 *height = header->biHeight;
126 *planes = header->biPlanes;
127 *bpp = header->biBitCount;
128 *compr = header->biCompression;
129 *size = header->biSizeImage;
130 return 1;
131 }
132 ERR("(%d): unknown/wrong size for header\n", header->biSize );
133 return -1;
134 }
135
136 /*******************************************************************************************
137 * Fill out a true BITMAPINFO from a variable sized BITMAPINFO / BITMAPCOREINFO.
138 */
139 static BOOL bitmapinfo_from_user_bitmapinfo( BITMAPINFO *dst, const BITMAPINFO *info, UINT coloruse )
140 {
141 LONG width, height;
142 WORD planes, bpp;
143 DWORD compr, size;
144 void *src_colors = (char *)info + info->bmiHeader.biSize;
145 unsigned int colors;
146 int bitmap_type = DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &planes, &bpp, &compr, &size );
147
148 if (bitmap_type == -1) return FALSE;
149
150 if (bitmap_type == 1)
151 {
152 dst->bmiHeader = info->bmiHeader;
153 dst->bmiHeader.biSize = sizeof(dst->bmiHeader);
154
155 colors = get_dib_num_of_colors( dst );
156
157 if (info->bmiHeader.biCompression == BI_BITFIELDS)
158 /* bitfields are always at bmiColors even in larger structures */
159 memcpy( dst->bmiColors, info->bmiColors, 3 * sizeof(DWORD) );
160 else if (colors)
161 {
162 unsigned int size;
163
164 if (coloruse == DIB_PAL_COLORS)
165 size = colors * sizeof(WORD);
166 else
167 size = colors * sizeof(RGBQUAD);
168 memcpy( dst->bmiColors, src_colors, size );
169 }
170 }
171 else
172 {
173 dst->bmiHeader.biSize = sizeof(dst->bmiHeader);
174 dst->bmiHeader.biWidth = width;
175 dst->bmiHeader.biHeight = height;
176 dst->bmiHeader.biPlanes = planes;
177 dst->bmiHeader.biBitCount = bpp;
178 dst->bmiHeader.biCompression = compr;
179 dst->bmiHeader.biSizeImage = size;
180 dst->bmiHeader.biXPelsPerMeter = 0;
181 dst->bmiHeader.biYPelsPerMeter = 0;
182 dst->bmiHeader.biClrUsed = 0;
183 dst->bmiHeader.biClrImportant = 0;
184
185 colors = get_dib_num_of_colors( dst );
186
187 if (colors)
188 {
189 if (coloruse == DIB_PAL_COLORS)
190 memcpy( dst->bmiColors, src_colors, colors * sizeof(WORD) );
191 else
192 {
193 unsigned int i;
194 RGBTRIPLE *triple = (RGBTRIPLE *)src_colors;
195 for (i = 0; i < colors; i++)
196 {
197 dst->bmiColors[i].rgbRed = triple[i].rgbtRed;
198 dst->bmiColors[i].rgbGreen = triple[i].rgbtGreen;
199 dst->bmiColors[i].rgbBlue = triple[i].rgbtBlue;
200 dst->bmiColors[i].rgbReserved = 0;
201 }
202 }
203 }
204 }
205
206 return TRUE;
207 }
208
209 static int fill_color_table_from_palette( BITMAPINFO *info, DC *dc )
210 {
211 PALETTEENTRY palEntry[256];
212 int i, colors = get_dib_num_of_colors( info );
213
214 if (!colors) return 0;
215
216 memset( palEntry, 0, sizeof(palEntry) );
217 if (!GetPaletteEntries( dc->hPalette, 0, colors, palEntry ))
218 return 0;
219
220 for (i = 0; i < colors; i++)
221 {
222 info->bmiColors[i].rgbRed = palEntry[i].peRed;
223 info->bmiColors[i].rgbGreen = palEntry[i].peGreen;
224 info->bmiColors[i].rgbBlue = palEntry[i].peBlue;
225 info->bmiColors[i].rgbReserved = 0;
226 }
227
228 return colors;
229 }
230
231 static void *get_pixel_ptr( const BITMAPINFO *info, void *bits, int x, int y )
232 {
233 const int width = info->bmiHeader.biWidth, height = info->bmiHeader.biHeight;
234 const int bpp = info->bmiHeader.biBitCount;
235
236 if (height > 0)
237 return (char *)bits + (height - y - 1) * get_dib_stride( width, bpp ) + x * bpp / 8;
238 else
239 return (char *)bits + y * get_dib_stride( width, bpp ) + x * bpp / 8;
240 }
241
242 static BOOL build_rle_bitmap( const BITMAPINFO *info, struct gdi_image_bits *bits, HRGN *clip )
243 {
244 int i = 0;
245 int left, right;
246 int x, y, width = info->bmiHeader.biWidth, height = info->bmiHeader.biHeight;
247 HRGN run = NULL;
248 BYTE skip, num, data;
249 BYTE *out_bits, *in_bits = bits->ptr;
250
251 *clip = NULL;
252
253 assert( info->bmiHeader.biBitCount == 4 || info->bmiHeader.biBitCount == 8 );
254
255 out_bits = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( info ) );
256 *clip = CreateRectRgn( 0, 0, 0, 0 );
257 run = CreateRectRgn( 0, 0, 0, 0 );
258 if (!out_bits || !*clip || !run) goto fail;
259
260 x = left = right = 0;
261 y = height - 1;
262
263 while (i < info->bmiHeader.biSizeImage - 1)
264 {
265 num = in_bits[i];
266 data = in_bits[i + 1];
267 i += 2;
268
269 if (num)
270 {
271 if (x + num > width) num = width - x;
272 if (num)
273 {
274 BYTE s = data, *out_ptr = get_pixel_ptr( info, out_bits, x, y );
275 if (info->bmiHeader.biBitCount == 8)
276 memset( out_ptr, s, num );
277 else
278 {
279 if(x & 1)
280 {
281 s = ((s >> 4) & 0x0f) | ((s << 4) & 0xf0);
282 *out_ptr = (*out_ptr & 0xf0) | (s & 0x0f);
283 out_ptr++;
284 x++;
285 num--;
286 }
287 /* this will write one too many if num is odd, but that doesn't matter */
288 if (num) memset( out_ptr, s, (num + 1) / 2 );
289 }
290 }
291 x += num;
292 right = x;
293 }
294 else
295 {
296 if (data < 3)
297 {
298 if(left != right)
299 {
300 SetRectRgn( run, left, y, right, y + 1 );
301 CombineRgn( *clip, run, *clip, RGN_OR );
302 }
303 switch (data)
304 {
305 case 0: /* eol */
306 left = right = x = 0;
307 y--;
308 if(y < 0) goto done;
309 break;
310
311 case 1: /* eod */
312 goto done;
313
314 case 2: /* delta */
315 if (i >= info->bmiHeader.biSizeImage - 1) goto done;
316 x += in_bits[i];
317 if (x > width) x = width;
318 left = right = x;
319 y -= in_bits[i + 1];
320 if(y < 0) goto done;
321 i += 2;
322 }
323 }
324 else /* data bytes of data */
325 {
326 num = data;
327 skip = (num * info->bmiHeader.biBitCount + 7) / 8;
328 if (skip > info->bmiHeader.biSizeImage - i) goto done;
329 skip = (skip + 1) & ~1;
330 if (x + num > width) num = width - x;
331 if (num)
332 {
333 BYTE *out_ptr = get_pixel_ptr( info, out_bits, x, y );
334 if (info->bmiHeader.biBitCount == 8)
335 memcpy( out_ptr, in_bits + i, num );
336 else
337 {
338 if(x & 1)
339 {
340 const BYTE *in_ptr = in_bits + i;
341 for ( ; num; num--, x++)
342 {
343 if (x & 1)
344 {
345 *out_ptr = (*out_ptr & 0xf0) | ((*in_ptr >> 4) & 0x0f);
346 out_ptr++;
347 }
348 else
349 *out_ptr = (*in_ptr++ << 4) & 0xf0;
350 }
351 }
352 else
353 memcpy( out_ptr, in_bits + i, (num + 1) / 2);
354 }
355 }
356 x += num;
357 right = x;
358 i += skip;
359 }
360 }
361 }
362
363 done:
364 DeleteObject( run );
365 if (bits->free) bits->free( bits );
366
367 bits->ptr = out_bits;
368 bits->is_copy = TRUE;
369 bits->free = free_heap_bits;
370
371 return TRUE;
372
373 fail:
374 if (run) DeleteObject( run );
375 if (*clip) DeleteObject( *clip );
376 HeapFree( GetProcessHeap(), 0, out_bits );
377 return FALSE;
378 }
379
380
381
382 /* nulldrv fallback implementation using SetDIBits/StretchBlt */
383 INT nulldrv_StretchDIBits( PHYSDEV dev, INT xDst, INT yDst, INT widthDst, INT heightDst,
384 INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void *bits,
385 const BITMAPINFO *info, UINT coloruse, DWORD rop )
386 {
387 DC *dc = get_nulldrv_dc( dev );
388 INT ret;
389 LONG width, height;
390 WORD planes, bpp;
391 DWORD compr, size;
392 HBITMAP hBitmap;
393 HDC hdcMem;
394
395 /* make sure we have a real implementation for StretchBlt and PutImage */
396 if (GET_DC_PHYSDEV( dc, pStretchBlt ) == dev || GET_DC_PHYSDEV( dc, pPutImage ) == dev)
397 return 0;
398
399 if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &planes, &bpp, &compr, &size ) == -1)
400 return 0;
401
402 if (width < 0) return 0;
403
404 if (xSrc == 0 && ySrc == 0 && widthDst == widthSrc && heightDst == heightSrc &&
405 info->bmiHeader.biCompression == BI_RGB)
406 {
407 /* Windows appears to have a fast case optimization
408 * that uses the wrong origin for top-down DIBs */
409 if (height < 0 && heightSrc < abs(height)) ySrc = abs(height) - heightSrc;
410
411 if (xDst == 0 && yDst == 0 && info->bmiHeader.biCompression == BI_RGB && rop == SRCCOPY)
412 {
413 BITMAP bm;
414 hBitmap = GetCurrentObject( dev->hdc, OBJ_BITMAP );
415 if (GetObjectW( hBitmap, sizeof(bm), &bm ) &&
416 bm.bmWidth == widthSrc && bm.bmHeight == heightSrc &&
417 bm.bmBitsPixel == bpp && bm.bmPlanes == planes)
418 {
419 /* fast path */
420 return SetDIBits( dev->hdc, hBitmap, 0, abs( height ), bits, info, coloruse );
421 }
422 }
423 }
424
425 hdcMem = CreateCompatibleDC( dev->hdc );
426 hBitmap = CreateCompatibleBitmap( dev->hdc, width, height );
427 SelectObject( hdcMem, hBitmap );
428 if (coloruse == DIB_PAL_COLORS)
429 SelectPalette( hdcMem, GetCurrentObject( dev->hdc, OBJ_PAL ), FALSE );
430
431 if (info->bmiHeader.biCompression == BI_RLE4 || info->bmiHeader.biCompression == BI_RLE8)
432 {
433 /* when RLE compression is used, there may be some gaps (ie the DIB doesn't
434 * contain all the rectangle described in bmiHeader, but only part of it.
435 * This mean that those undescribed pixels must be left untouched.
436 * So, we first copy on a memory bitmap the current content of the
437 * destination rectangle, blit the DIB bits on top of it - hence leaving
438 * the gaps untouched -, and blitting the rectangle back.
439 * This insure that gaps are untouched on the destination rectangle
440 */
441 StretchBlt( hdcMem, xSrc, abs(height) - heightSrc - ySrc, widthSrc, heightSrc,
442 dev->hdc, xDst, yDst, widthDst, heightDst, rop );
443 }
444 ret = SetDIBits( hdcMem, hBitmap, 0, abs( height ), bits, info, coloruse );
445 if (ret) StretchBlt( dev->hdc, xDst, yDst, widthDst, heightDst,
446 hdcMem, xSrc, abs(height) - heightSrc - ySrc, widthSrc, heightSrc, rop );
447 DeleteDC( hdcMem );
448 DeleteObject( hBitmap );
449 return ret;
450 }
451
452 /***********************************************************************
453 * StretchDIBits (GDI32.@)
454 */
455 INT WINAPI StretchDIBits(HDC hdc, INT xDst, INT yDst, INT widthDst, INT heightDst,
456 INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void *bits,
457 const BITMAPINFO *info, UINT coloruse, DWORD rop )
458 {
459 DC *dc;
460 INT ret = 0;
461
462 if (!bits || !info) return 0;
463
464 if ((dc = get_dc_ptr( hdc )))
465 {
466 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pStretchDIBits );
467 update_dc( dc );
468 ret = physdev->funcs->pStretchDIBits( physdev, xDst, yDst, widthDst, heightDst,
469 xSrc, ySrc, widthSrc, heightSrc, bits, info, coloruse, rop );
470 release_dc_ptr( dc );
471 }
472 return ret;
473 }
474
475
476 /******************************************************************************
477 * SetDIBits [GDI32.@]
478 *
479 * Sets pixels in a bitmap using colors from DIB.
480 *
481 * PARAMS
482 * hdc [I] Handle to device context
483 * hbitmap [I] Handle to bitmap
484 * startscan [I] Starting scan line
485 * lines [I] Number of scan lines
486 * bits [I] Array of bitmap bits
487 * info [I] Address of structure with data
488 * coloruse [I] Type of color indexes to use
489 *
490 * RETURNS
491 * Success: Number of scan lines copied
492 * Failure: 0
493 */
494 INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan,
495 UINT lines, LPCVOID bits, const BITMAPINFO *info,
496 UINT coloruse )
497 {
498 DC *dc = get_dc_ptr( hdc );
499 BOOL delete_hdc = FALSE;
500 PHYSDEV physdev;
501 BITMAPOBJ *bitmap;
502 char src_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
503 BITMAPINFO *src_info = (BITMAPINFO *)src_bmibuf;
504 char dst_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
505 BITMAPINFO *dst_info = (BITMAPINFO *)dst_bmibuf;
506 INT result = 0;
507 DWORD err;
508 struct gdi_image_bits src_bits;
509 struct bitblt_coords src, dst;
510 INT src_to_dst_offset;
511 HRGN clip = 0;
512
513 src_bits.ptr = (void *)bits;
514 src_bits.is_copy = FALSE;
515 src_bits.free = NULL;
516 src_bits.param = NULL;
517
518 if (coloruse == DIB_RGB_COLORS && !dc)
519 {
520 hdc = CreateCompatibleDC(0);
521 dc = get_dc_ptr( hdc );
522 delete_hdc = TRUE;
523 }
524
525 if (!dc) return 0;
526
527 update_dc( dc );
528
529 if (!(bitmap = GDI_GetObjPtr( hbitmap, OBJ_BITMAP )))
530 {
531 release_dc_ptr( dc );
532 if (delete_hdc) DeleteDC(hdc);
533 return 0;
534 }
535
536 if (!bitmapinfo_from_user_bitmapinfo( src_info, info, coloruse )) goto done;
537
538 if (coloruse == DIB_PAL_COLORS)
539 if (!fill_color_table_from_palette( src_info, dc )) goto done;
540
541 if (src_info->bmiHeader.biCompression == BI_RLE4 || src_info->bmiHeader.biCompression == BI_RLE8)
542 {
543 if ( src_info->bmiHeader.biHeight < 0 ||
544 (src_info->bmiHeader.biCompression == BI_RLE4 && src_info->bmiHeader.biBitCount != 4) ||
545 (src_info->bmiHeader.biCompression == BI_RLE8 && src_info->bmiHeader.biBitCount != 8) )
546 {
547 SetLastError( ERROR_INVALID_PARAMETER );
548 goto done;
549 }
550
551 if (lines == 0) goto done;
552 else lines = src_info->bmiHeader.biHeight;
553 startscan = 0;
554
555 if (!build_rle_bitmap( src_info, &src_bits, &clip )) goto done;
556 }
557
558 dst.visrect.left = 0;
559 dst.visrect.top = 0;
560 dst.visrect.right = bitmap->bitmap.bmWidth;
561 dst.visrect.bottom = bitmap->bitmap.bmHeight;
562
563 src.visrect.left = 0;
564 src.visrect.top = 0;
565 src.visrect.right = src_info->bmiHeader.biWidth;
566 src.visrect.bottom = abs( src_info->bmiHeader.biHeight );
567
568 if (src_info->bmiHeader.biHeight > 0)
569 {
570 src_to_dst_offset = -startscan;
571 lines = min( lines, src.visrect.bottom - startscan );
572 if (lines < src.visrect.bottom) src.visrect.top = src.visrect.bottom - lines;
573 }
574 else
575 {
576 src_to_dst_offset = src.visrect.bottom - lines - startscan;
577 /* Unlike the bottom-up case, Windows doesn't limit lines. */
578 if (lines < src.visrect.bottom) src.visrect.bottom = lines;
579 }
580
581 physdev = GET_DC_PHYSDEV( dc, pPutImage );
582 if (!BITMAP_SetOwnerDC( hbitmap, physdev )) goto done;
583
584 result = lines;
585
586 offset_rect( &src.visrect, 0, src_to_dst_offset );
587 if (!intersect_rect( &dst.visrect, &src.visrect, &dst.visrect )) goto done;
588 src.visrect = dst.visrect;
589 offset_rect( &src.visrect, 0, -src_to_dst_offset );
590
591 src.x = src.visrect.left;
592 src.y = src.visrect.top;
593 src.width = src.visrect.right - src.visrect.left;
594 src.height = src.visrect.bottom - src.visrect.top;
595
596 dst.x = dst.visrect.left;
597 dst.y = dst.visrect.top;
598 dst.width = dst.visrect.right - dst.visrect.left;
599 dst.height = dst.visrect.bottom - dst.visrect.top;
600
601 memcpy( dst_info, src_info, FIELD_OFFSET( BITMAPINFO, bmiColors[256] ));
602
603 err = physdev->funcs->pPutImage( physdev, hbitmap, clip, dst_info, &src_bits, &src, &dst, 0 );
604 if (err == ERROR_BAD_FORMAT)
605 {
606 void *ptr;
607
608 dst_info->bmiHeader.biWidth = dst.width;
609 ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( dst_info ));
610 if (ptr)
611 {
612 err = convert_bitmapinfo( src_info, src_bits.ptr, &src.visrect, dst_info, ptr );
613 {
614 if (src_bits.free) src_bits.free( &src_bits );
615 src_bits.ptr = ptr;
616 src_bits.is_copy = TRUE;
617 src_bits.free = free_heap_bits;
618 if (!err)
619 err = physdev->funcs->pPutImage( physdev, hbitmap, clip, dst_info, &src_bits, &src, &dst, 0 );
620 }
621 }
622 else err = ERROR_OUTOFMEMORY;
623 }
624 if(err) result = 0;
625
626 done:
627 if (src_bits.free) src_bits.free( &src_bits );
628 if (clip) DeleteObject( clip );
629 GDI_ReleaseObj( hbitmap );
630 release_dc_ptr( dc );
631 if (delete_hdc) DeleteDC(hdc);
632 return result;
633 }
634
635
636 /***********************************************************************
637 * SetDIBitsToDevice (GDI32.@)
638 */
639 INT WINAPI SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx,
640 DWORD cy, INT xSrc, INT ySrc, UINT startscan,
641 UINT lines, LPCVOID bits, const BITMAPINFO *info,
642 UINT coloruse )
643 {
644 INT ret = 0;
645 DC *dc;
646
647 if (!bits) return 0;
648
649 if ((dc = get_dc_ptr( hdc )))
650 {
651 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDIBitsToDevice );
652 update_dc( dc );
653 ret = physdev->funcs->pSetDIBitsToDevice( physdev, xDest, yDest, cx, cy, xSrc,
654 ySrc, startscan, lines, bits, info, coloruse );
655 release_dc_ptr( dc );
656 }
657 return ret;
658 }
659
660 /***********************************************************************
661 * SetDIBColorTable (GDI32.@)
662 */
663 UINT WINAPI SetDIBColorTable( HDC hdc, UINT startpos, UINT entries, CONST RGBQUAD *colors )
664 {
665 DC * dc;
666 UINT result = 0;
667 BITMAPOBJ * bitmap;
668
669 if (!(dc = get_dc_ptr( hdc ))) return 0;
670
671 if ((bitmap = GDI_GetObjPtr( dc->hBitmap, OBJ_BITMAP )))
672 {
673 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDIBColorTable );
674
675 /* Check if currently selected bitmap is a DIB */
676 if (bitmap->color_table)
677 {
678 if (startpos < bitmap->nb_colors)
679 {
680 if (startpos + entries > bitmap->nb_colors) entries = bitmap->nb_colors - startpos;
681 memcpy(bitmap->color_table + startpos, colors, entries * sizeof(RGBQUAD));
682 result = entries;
683 }
684 }
685 GDI_ReleaseObj( dc->hBitmap );
686 physdev->funcs->pSetDIBColorTable( physdev, startpos, entries, colors );
687 }
688 release_dc_ptr( dc );
689 return result;
690 }
691
692
693 /***********************************************************************
694 * GetDIBColorTable (GDI32.@)
695 */
696 UINT WINAPI GetDIBColorTable( HDC hdc, UINT startpos, UINT entries, RGBQUAD *colors )
697 {
698 DC * dc;
699 BITMAPOBJ *bitmap;
700 UINT result = 0;
701
702 if (!(dc = get_dc_ptr( hdc ))) return 0;
703
704 if ((bitmap = GDI_GetObjPtr( dc->hBitmap, OBJ_BITMAP )))
705 {
706 /* Check if currently selected bitmap is a DIB */
707 if (bitmap->color_table)
708 {
709 if (startpos < bitmap->nb_colors)
710 {
711 if (startpos + entries > bitmap->nb_colors) entries = bitmap->nb_colors - startpos;
712 memcpy(colors, bitmap->color_table + startpos, entries * sizeof(RGBQUAD));
713 result = entries;
714 }
715 }
716 GDI_ReleaseObj( dc->hBitmap );
717 }
718 release_dc_ptr( dc );
719 return result;
720 }
721
722 static const RGBQUAD DefLogPaletteQuads[20] = { /* Copy of Default Logical Palette */
723 /* rgbBlue, rgbGreen, rgbRed, rgbReserved */
724 { 0x00, 0x00, 0x00, 0x00 },
725 { 0x00, 0x00, 0x80, 0x00 },
726 { 0x00, 0x80, 0x00, 0x00 },
727 { 0x00, 0x80, 0x80, 0x00 },
728 { 0x80, 0x00, 0x00, 0x00 },
729 { 0x80, 0x00, 0x80, 0x00 },
730 { 0x80, 0x80, 0x00, 0x00 },
731 { 0xc0, 0xc0, 0xc0, 0x00 },
732 { 0xc0, 0xdc, 0xc0, 0x00 },
733 { 0xf0, 0xca, 0xa6, 0x00 },
734 { 0xf0, 0xfb, 0xff, 0x00 },
735 { 0xa4, 0xa0, 0xa0, 0x00 },
736 { 0x80, 0x80, 0x80, 0x00 },
737 { 0x00, 0x00, 0xff, 0x00 },
738 { 0x00, 0xff, 0x00, 0x00 },
739 { 0x00, 0xff, 0xff, 0x00 },
740 { 0xff, 0x00, 0x00, 0x00 },
741 { 0xff, 0x00, 0xff, 0x00 },
742 { 0xff, 0xff, 0x00, 0x00 },
743 { 0xff, 0xff, 0xff, 0x00 }
744 };
745
746 static const DWORD bit_fields_888[3] = {0xff0000, 0x00ff00, 0x0000ff};
747 static const DWORD bit_fields_565[3] = {0xf800, 0x07e0, 0x001f};
748 static const DWORD bit_fields_555[3] = {0x7c00, 0x03e0, 0x001f};
749
750 static int fill_query_info( BITMAPINFO *info, BITMAPOBJ *bmp )
751 {
752 BITMAPINFOHEADER header;
753
754 header.biSize = info->bmiHeader.biSize; /* Ensure we don't overwrite the original size when we copy back */
755 header.biWidth = bmp->bitmap.bmWidth;
756 header.biHeight = bmp->bitmap.bmHeight;
757 header.biPlanes = 1;
758
759 if (bmp->dib)
760 {
761 header.biBitCount = bmp->dib->dsBm.bmBitsPixel;
762 switch (bmp->dib->dsBm.bmBitsPixel)
763 {
764 case 16:
765 case 32:
766 header.biCompression = BI_BITFIELDS;
767 break;
768 default:
769 header.biCompression = BI_RGB;
770 break;
771 }
772 }
773 else
774 {
775 header.biCompression = (bmp->bitmap.bmBitsPixel > 8) ? BI_BITFIELDS : BI_RGB;
776 header.biBitCount = bmp->bitmap.bmBitsPixel;
777 }
778
779 header.biSizeImage = get_dib_image_size( (BITMAPINFO *)&header );
780 header.biXPelsPerMeter = 0;
781 header.biYPelsPerMeter = 0;
782 header.biClrUsed = 0;
783 header.biClrImportant = 0;
784
785 if ( info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER) )
786 {
787 BITMAPCOREHEADER *coreheader = (BITMAPCOREHEADER *)info;
788
789 coreheader->bcWidth = header.biWidth;
790 coreheader->bcHeight = header.biHeight;
791 coreheader->bcPlanes = header.biPlanes;
792 coreheader->bcBitCount = header.biBitCount;
793 }
794 else
795 info->bmiHeader = header;
796
797 return abs(bmp->bitmap.bmHeight);
798 }
799
800 /************************************************************************
801 * copy_color_info
802 *
803 * Copy BITMAPINFO color information where dst may be a BITMAPCOREINFO.
804 */
805 static void copy_color_info(BITMAPINFO *dst, const BITMAPINFO *src, UINT coloruse)
806 {
807 unsigned int colors = get_dib_num_of_colors( src );
808 RGBQUAD *src_colors = (RGBQUAD *)((char *)src + src->bmiHeader.biSize);
809
810 assert( src->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) );
811
812 if (dst->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
813 {
814 BITMAPCOREINFO *core = (BITMAPCOREINFO *)dst;
815 if (coloruse == DIB_PAL_COLORS)
816 memcpy( core->bmciColors, src_colors, colors * sizeof(WORD) );
817 else
818 {
819 unsigned int i;
820 for (i = 0; i < colors; i++)
821 {
822 core->bmciColors[i].rgbtRed = src_colors[i].rgbRed;
823 core->bmciColors[i].rgbtGreen = src_colors[i].rgbGreen;
824 core->bmciColors[i].rgbtBlue = src_colors[i].rgbBlue;
825 }
826 }
827 }
828 else
829 {
830 dst->bmiHeader.biClrUsed = src->bmiHeader.biClrUsed;
831 dst->bmiHeader.biSizeImage = src->bmiHeader.biSizeImage;
832
833 if (src->bmiHeader.biCompression == BI_BITFIELDS)
834 /* bitfields are always at bmiColors even in larger structures */
835 memcpy( dst->bmiColors, src->bmiColors, 3 * sizeof(DWORD) );
836 else if (colors)
837 {
838 void *colorptr = (char *)dst + dst->bmiHeader.biSize;
839 unsigned int size;
840
841 if (coloruse == DIB_PAL_COLORS)
842 size = colors * sizeof(WORD);
843 else
844 size = colors * sizeof(RGBQUAD);
845 memcpy( colorptr, src_colors, size );
846 }
847 }
848 }
849
850 static void fill_default_color_table( BITMAPINFO *info )
851 {
852 int i;
853
854 switch (info->bmiHeader.biBitCount)
855 {
856 case 1:
857 info->bmiColors[0].rgbRed = info->bmiColors[0].rgbGreen = info->bmiColors[0].rgbBlue = 0;
858 info->bmiColors[0].rgbReserved = 0;
859 info->bmiColors[1].rgbRed = info->bmiColors[1].rgbGreen = info->bmiColors[1].rgbBlue = 0xff;
860 info->bmiColors[1].rgbReserved = 0;
861 break;
862
863 case 4:
864 /* The EGA palette is the first and last 8 colours of the default palette
865 with the innermost pair swapped */
866 memcpy(info->bmiColors, DefLogPaletteQuads, 7 * sizeof(RGBQUAD));
867 memcpy(info->bmiColors + 7, DefLogPaletteQuads + 12, 1 * sizeof(RGBQUAD));
868 memcpy(info->bmiColors + 8, DefLogPaletteQuads + 7, 1 * sizeof(RGBQUAD));
869 memcpy(info->bmiColors + 9, DefLogPaletteQuads + 13, 7 * sizeof(RGBQUAD));
870 break;
871
872 case 8:
873 memcpy(info->bmiColors, DefLogPaletteQuads, 10 * sizeof(RGBQUAD));
874 memcpy(info->bmiColors + 246, DefLogPaletteQuads + 10, 10 * sizeof(RGBQUAD));
875 for (i = 10; i < 246; i++)
876 {
877 info->bmiColors[i].rgbRed = (i & 0x07) << 5;
878 info->bmiColors[i].rgbGreen = (i & 0x38) << 2;
879 info->bmiColors[i].rgbBlue = i & 0xc0;
880 info->bmiColors[i].rgbReserved = 0;
881 }
882 break;
883
884 default:
885 ERR("called with bitcount %d\n", info->bmiHeader.biBitCount);
886 }
887 }
888
889 /******************************************************************************
890 * GetDIBits [GDI32.@]
891 *
892 * Retrieves bits of bitmap and copies to buffer.
893 *
894 * RETURNS
895 * Success: Number of scan lines copied from bitmap
896 * Failure: 0
897 */
898 INT WINAPI GetDIBits(
899 HDC hdc, /* [in] Handle to device context */
900 HBITMAP hbitmap, /* [in] Handle to bitmap */
901 UINT startscan, /* [in] First scan line to set in dest bitmap */
902 UINT lines, /* [in] Number of scan lines to copy */
903 LPVOID bits, /* [out] Address of array for bitmap bits */
904 BITMAPINFO * info, /* [out] Address of structure with bitmap data */
905 UINT coloruse) /* [in] RGB or palette index */
906 {
907 DC * dc;
908 BITMAPOBJ * bmp;
909 int i;
910 int bitmap_type;
911 LONG width;
912 LONG height;
913 WORD planes, bpp;
914 DWORD compr, size;
915 char dst_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
916 BITMAPINFO *dst_info = (BITMAPINFO *)dst_bmibuf;
917 unsigned int colors = 0;
918
919 if (!info) return 0;
920
921 bitmap_type = DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &planes, &bpp, &compr, &size);
922 if (bitmap_type == -1)
923 {
924 ERR("Invalid bitmap format\n");
925 return 0;
926 }
927 if (!(dc = get_dc_ptr( hdc )))
928 {
929 SetLastError( ERROR_INVALID_PARAMETER );
930 return 0;
931 }
932 update_dc( dc );
933 if (!(bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP )))
934 {
935 release_dc_ptr( dc );
936 return 0;
937 }
938
939
940 if (bpp == 0) /* query bitmap info only */
941 {
942 lines = fill_query_info( info, bmp );
943 goto done;
944 }
945
946 /* Since info may be a BITMAPCOREINFO or any of the larger BITMAPINFO structures, we'll use our
947 own copy and transfer the colour info back at the end */
948
949 dst_info->bmiHeader.biSize = sizeof(dst_info->bmiHeader);
950 dst_info->bmiHeader.biWidth = width;
951 dst_info->bmiHeader.biHeight = height;
952 dst_info->bmiHeader.biPlanes = planes;
953 dst_info->bmiHeader.biBitCount = bpp;
954 dst_info->bmiHeader.biCompression = compr;
955 dst_info->bmiHeader.biSizeImage = get_dib_image_size( dst_info );
956 dst_info->bmiHeader.biXPelsPerMeter = 0;
957 dst_info->bmiHeader.biYPelsPerMeter = 0;
958 dst_info->bmiHeader.biClrUsed = 0;
959 dst_info->bmiHeader.biClrImportant = 0;
960
961 switch (bpp)
962 {
963 case 1:
964 case 4:
965 case 8:
966 {
967 colors = 1 << bpp;
968
969 /* If the bitmap object is a dib section at the
970 same color depth then get the color map from it */
971 if (bmp->dib && bpp == bmp->dib->dsBm.bmBitsPixel && coloruse == DIB_RGB_COLORS)
972 {
973 colors = min( colors, bmp->nb_colors );
974 if (colors != 1 << bpp) dst_info->bmiHeader.biClrUsed = colors;
975 memcpy( dst_info->bmiColors, bmp->color_table, colors * sizeof(RGBQUAD) );
976 }
977
978 /* For color DDBs in native depth (mono DDBs always have a black/white palette):
979 Generate the color map from the selected palette. In the DIB_PAL_COLORS
980 case we'll fix up the indices after the format conversion. */
981 else if ( (bpp > 1 && bpp == bmp->bitmap.bmBitsPixel) || coloruse == DIB_PAL_COLORS )
982 {
983 if (!fill_color_table_from_palette( dst_info, dc ))
984 {
985 lines = 0;
986 goto done;
987 }
988 }
989 else
990 fill_default_color_table( dst_info );
991 break;
992 }
993
994 case 15:
995 if (dst_info->bmiHeader.biCompression == BI_BITFIELDS)
996 memcpy( dst_info->bmiColors, bit_fields_555, sizeof(bit_fields_555) );
997 break;
998
999 case 16:
1000 if (dst_info->bmiHeader.biCompression == BI_BITFIELDS)
1001 {
1002 if (bmp->dib)
1003 {
1004 if (bmp->dib->dsBmih.biCompression == BI_BITFIELDS && bmp->dib->dsBmih.biBitCount == bpp)
1005 memcpy( dst_info->bmiColors, bmp->dib->dsBitfields, 3 * sizeof(DWORD) );
1006 else
1007 memcpy( dst_info->bmiColors, bit_fields_555, sizeof(bit_fields_555) );
1008 }
1009 else
1010 memcpy( dst_info->bmiColors, bit_fields_565, sizeof(bit_fields_565) );
1011 }
1012 break;
1013
1014 case 24:
1015 case 32:
1016 if (dst_info->bmiHeader.biCompression == BI_BITFIELDS)
1017 {
1018 if (bmp->dib && bmp->dib->dsBmih.biCompression == BI_BITFIELDS && bmp->dib->dsBmih.biBitCount == bpp)
1019 memcpy( dst_info->bmiColors, bmp->dib->dsBitfields, 3 * sizeof(DWORD) );
1020 else
1021 memcpy( dst_info->bmiColors, bit_fields_888, sizeof(bit_fields_888) );
1022 }
1023 break;
1024 }
1025
1026 if (bits && lines)
1027 {
1028 char src_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1029 BITMAPINFO *src_info = (BITMAPINFO *)src_bmibuf;
1030 struct gdi_image_bits src_bits;
1031 struct bitblt_coords src, dst;
1032 DWORD err;
1033 int dst_to_src_offset;
1034 BOOL empty_rect;
1035
1036 src.visrect.left = 0;
1037 src.visrect.top = 0;
1038 src.visrect.right = bmp->bitmap.bmWidth;
1039 src.visrect.bottom = bmp->bitmap.bmHeight;
1040
1041 dst.visrect.left = 0;
1042 dst.visrect.top = 0;
1043 dst.visrect.right = dst_info->bmiHeader.biWidth;
1044 dst.visrect.bottom = abs( dst_info->bmiHeader.biHeight );
1045
1046 if (startscan >= dst.visrect.bottom)
1047 {
1048 lines = 1; /* yes, this is strange */
1049 goto empty_image;
1050 }
1051
1052 if (dst_info->bmiHeader.biHeight > 0)
1053 {
1054 dst_to_src_offset = -startscan;
1055 lines = min( lines, dst.visrect.bottom - startscan );
1056 if (lines < dst.visrect.bottom) dst.visrect.top = dst.visrect.bottom - lines;
1057 }
1058 else
1059 {
1060 dst_to_src_offset = dst.visrect.bottom - lines - startscan;
1061 if (dst_to_src_offset < 0)
1062 {
1063 dst_to_src_offset = 0;
1064 lines = dst.visrect.bottom - startscan;
1065 }
1066 if (lines < dst.visrect.bottom) dst.visrect.bottom = lines;
1067 }
1068
1069 offset_rect( &dst.visrect, 0, dst_to_src_offset );
1070 empty_rect = !intersect_rect( &src.visrect, &src.visrect, &dst.visrect );
1071 dst.visrect = src.visrect;
1072 offset_rect( &dst.visrect, 0, -dst_to_src_offset );
1073
1074 if (dst_info->bmiHeader.biHeight > 0)
1075 {
1076 if (dst.visrect.bottom < dst_info->bmiHeader.biHeight)
1077 {
1078 int pad_lines = min( dst_info->bmiHeader.biHeight - dst.visrect.bottom, lines );
1079 int pad_bytes = pad_lines * get_dib_stride( width, bpp );
1080 memset( bits, 0, pad_bytes );
1081 bits = (char *)bits + pad_bytes;
1082 }
1083 }
1084 else
1085 {
1086 if (dst.visrect.bottom < lines)
1087 {
1088 int pad_lines = lines - dst.visrect.bottom, stride = get_dib_stride( width, bpp );
1089 int pad_bytes = pad_lines * stride;
1090 memset( (char *)bits + dst.visrect.bottom * stride, 0, pad_bytes );
1091 }
1092 }
1093
1094 if (empty_rect)
1095 {
1096 lines = 0;
1097 goto empty_image;
1098 }
1099
1100 src.x = src.visrect.left;
1101 src.y = src.visrect.top;
1102 src.width = src.visrect.right - src.visrect.left;
1103 src.height = src.visrect.bottom - src.visrect.top;
1104
1105 lines = src.height;
1106
1107 err = bmp->funcs->pGetImage( NULL, hbitmap, src_info, &src_bits, &src );
1108
1109 if(err)
1110 {
1111 lines = 0;
1112 goto done;
1113 }
1114
1115 if (src_info->bmiHeader.biBitCount <= 8 && src_info->bmiHeader.biClrUsed == 0)
1116 {
1117 if (bmp->dib)
1118 memcpy( src_info->bmiColors, bmp->color_table, bmp->nb_colors * sizeof(RGBQUAD) );
1119 else
1120 fill_default_color_table( src_info );
1121 }
1122
1123 if(dst_info->bmiHeader.biHeight > 0)
1124 dst_info->bmiHeader.biHeight = src.height;
1125 else
1126 dst_info->bmiHeader.biHeight = -src.height;
1127
1128 convert_bitmapinfo( src_info, src_bits.ptr, &src.visrect, dst_info, bits );
1129 if (src_bits.free) src_bits.free( &src_bits );
1130 }
1131 else lines = abs(height);
1132
1133 empty_image:
1134 if (coloruse == DIB_PAL_COLORS)
1135 {
1136 WORD *index = (WORD *)dst_info->bmiColors;
1137 for (i = 0; i < colors; i++, index++)
1138 *index = i;
1139 }
1140
1141 copy_color_info( info, dst_info, coloruse );
1142
1143 done:
1144 release_dc_ptr( dc );
1145 GDI_ReleaseObj( hbitmap );
1146 return lines;
1147 }
1148
1149
1150 /***********************************************************************
1151 * CreateDIBitmap (GDI32.@)
1152 *
1153 * Creates a DDB (device dependent bitmap) from a DIB.
1154 * The DDB will have the same color depth as the reference DC.
1155 */
1156 HBITMAP WINAPI CreateDIBitmap( HDC hdc, const BITMAPINFOHEADER *header,
1157 DWORD init, LPCVOID bits, const BITMAPINFO *data,
1158 UINT coloruse )
1159 {
1160 HBITMAP handle;
1161 LONG width;
1162 LONG height;
1163 WORD planes, bpp;
1164 DWORD compr, size;
1165
1166 if (!header) return 0;
1167
1168 if (DIB_GetBitmapInfo( header, &width, &height, &planes, &bpp, &compr, &size ) == -1) return 0;
1169
1170 if (width < 0)
1171 {
1172 TRACE("Bitmap has a negative width\n");
1173 return 0;
1174 }
1175
1176 /* Top-down DIBs have a negative height */
1177 if (height < 0) height = -height;
1178
1179 TRACE("hdc=%p, header=%p, init=%u, bits=%p, data=%p, coloruse=%u (bitmap: width=%d, height=%d, bpp=%u, compr=%u)\n",
1180 hdc, header, init, bits, data, coloruse, width, height, bpp, compr);
1181
1182 if (hdc == NULL)
1183 handle = CreateBitmap( width, height, 1, 1, NULL );
1184 else
1185 handle = CreateCompatibleBitmap( hdc, width, height );
1186
1187 if (handle)
1188 {
1189 if (init & CBM_INIT)
1190 {
1191 if (SetDIBits( hdc, handle, 0, height, bits, data, coloruse ) == 0)
1192 {
1193 DeleteObject( handle );
1194 handle = 0;
1195 }
1196 }
1197 }
1198
1199 return handle;
1200 }
1201
1202 /* Copy/synthesize RGB palette from BITMAPINFO. Ripped from dlls/winex11.drv/dib.c */
1203 static void DIB_CopyColorTable( DC *dc, BITMAPOBJ *bmp, WORD coloruse, const BITMAPINFO *info )
1204 {
1205 RGBQUAD *colorTable;
1206 unsigned int colors, i;
1207 BOOL core_info = info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER);
1208
1209 if (core_info)
1210 {
1211 colors = 1 << ((const BITMAPCOREINFO*) info)->bmciHeader.bcBitCount;
1212 }
1213 else
1214 {
1215 colors = get_dib_num_of_colors( info );
1216 }
1217
1218 if (colors > 256) {
1219 ERR("called with >256 colors!\n");
1220 return;
1221 }
1222
1223 if (!(colorTable = HeapAlloc(GetProcessHeap(), 0, colors * sizeof(RGBQUAD) ))) return;
1224
1225 if(coloruse == DIB_RGB_COLORS)
1226 {
1227 if (core_info)
1228 {
1229 /* Convert RGBTRIPLEs to RGBQUADs */
1230 for (i=0; i < colors; i++)
1231 {
1232 colorTable[i].rgbRed = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtRed;
1233 colorTable[i].rgbGreen = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtGreen;
1234 colorTable[i].rgbBlue = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtBlue;
1235 colorTable[i].rgbReserved = 0;
1236 }
1237 }
1238 else
1239 {
1240 memcpy(colorTable, (const BYTE*) info + (WORD) info->bmiHeader.biSize, colors * sizeof(RGBQUAD));
1241 }
1242 }
1243 else
1244 {
1245 PALETTEENTRY entries[256];
1246 const WORD *index = (const WORD*) ((const BYTE*) info + (WORD) info->bmiHeader.biSize);
1247 UINT count = GetPaletteEntries( dc->hPalette, 0, colors, entries );
1248
1249 for (i = 0; i < colors; i++, index++)
1250 {
1251 PALETTEENTRY *entry = &entries[*index % count];
1252 colorTable[i].rgbRed = entry->peRed;
1253 colorTable[i].rgbGreen = entry->peGreen;
1254 colorTable[i].rgbBlue = entry->peBlue;
1255 colorTable[i].rgbReserved = 0;
1256 }
1257 }
1258 bmp->color_table = colorTable;
1259 bmp->nb_colors = colors;
1260 }
1261
1262 /***********************************************************************
1263 * CreateDIBSection (GDI32.@)
1264 */
1265 HBITMAP WINAPI CreateDIBSection(HDC hdc, CONST BITMAPINFO *bmi, UINT usage,
1266 VOID **bits, HANDLE section, DWORD offset)
1267 {
1268 HBITMAP ret = 0;
1269 DC *dc;
1270 BOOL bDesktopDC = FALSE;
1271 DIBSECTION *dib;
1272 BITMAPOBJ *bmp;
1273 int bitmap_type;
1274 LONG width, height;
1275 WORD planes, bpp;
1276 DWORD compression, sizeImage;
1277 void *mapBits = NULL;
1278
1279 if(!bmi){
1280 if(bits) *bits = NULL;
1281 return NULL;
1282 }
1283
1284 if (((bitmap_type = DIB_GetBitmapInfo( &bmi->bmiHeader, &width, &height,
1285 &planes, &bpp, &compression, &sizeImage )) == -1))
1286 return 0;
1287
1288 switch (bpp)
1289 {
1290 case 16:
1291 case 32:
1292 if (compression == BI_BITFIELDS) break;
1293 /* fall through */
1294 case 1:
1295 case 4:
1296 case 8:
1297 case 24:
1298 if (compression == BI_RGB) break;
1299 /* fall through */
1300 default:
1301 WARN( "invalid %u bpp compression %u\n", bpp, compression );
1302 return 0;
1303 }
1304
1305 if (!(dib = HeapAlloc( GetProcessHeap(), 0, sizeof(*dib) ))) return 0;
1306
1307 TRACE("format (%d,%d), planes %d, bpp %d, %s, size %d %s\n",
1308 width, height, planes, bpp, compression == BI_BITFIELDS? "BI_BITFIELDS" : "BI_RGB",
1309 sizeImage, usage == DIB_PAL_COLORS? "PAL" : "RGB");
1310
1311 dib->dsBm.bmType = 0;
1312 dib->dsBm.bmWidth = width;
1313 dib->dsBm.bmHeight = height >= 0 ? height : -height;
1314 dib->dsBm.bmWidthBytes = get_dib_stride( width, bpp );
1315 dib->dsBm.bmPlanes = planes;
1316 dib->dsBm.bmBitsPixel = bpp;
1317 dib->dsBm.bmBits = NULL;
1318
1319 if (!bitmap_type) /* core header */
1320 {
1321 /* convert the BITMAPCOREHEADER to a BITMAPINFOHEADER */
1322 dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1323 dib->dsBmih.biWidth = width;
1324 dib->dsBmih.biHeight = height;
1325 dib->dsBmih.biPlanes = planes;
1326 dib->dsBmih.biBitCount = bpp;
1327 dib->dsBmih.biCompression = compression;
1328 dib->dsBmih.biXPelsPerMeter = 0;
1329 dib->dsBmih.biYPelsPerMeter = 0;
1330 dib->dsBmih.biClrUsed = 0;
1331 dib->dsBmih.biClrImportant = 0;
1332 }
1333 else
1334 {
1335 /* truncate extended bitmap headers (BITMAPV4HEADER etc.) */
1336 dib->dsBmih = bmi->bmiHeader;
1337 dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1338 }
1339
1340 /* set number of entries in bmi.bmiColors table */
1341 if( bpp <= 8 )
1342 dib->dsBmih.biClrUsed = 1 << bpp;
1343
1344 dib->dsBmih.biSizeImage = dib->dsBm.bmWidthBytes * dib->dsBm.bmHeight;
1345
1346 /* set dsBitfields values */
1347 dib->dsBitfields[0] = dib->dsBitfields[1] = dib->dsBitfields[2] = 0;
1348
1349 if((bpp == 15 || bpp == 16) && compression == BI_RGB)
1350 {
1351 /* In this case Windows changes biCompression to BI_BITFIELDS,
1352 however for now we won't do this, as there are a lot
1353 of places where BI_BITFIELDS is currently unsupported. */
1354
1355 /* dib->dsBmih.biCompression = compression = BI_BITFIELDS;*/
1356 dib->dsBitfields[0] = 0x7c00;
1357 dib->dsBitfields[1] = 0x03e0;
1358 dib->dsBitfields[2] = 0x001f;
1359 }
1360 else if(compression == BI_BITFIELDS)
1361 {
1362 dib->dsBitfields[0] = *(const DWORD *)bmi->bmiColors;
1363 dib->dsBitfields[1] = *((const DWORD *)bmi->bmiColors + 1);
1364 dib->dsBitfields[2] = *((const DWORD *)bmi->bmiColors + 2);
1365 }
1366
1367 /* get storage location for DIB bits */
1368
1369 if (section)
1370 {
1371 SYSTEM_INFO SystemInfo;
1372 DWORD mapOffset;
1373 INT mapSize;
1374
1375 GetSystemInfo( &SystemInfo );
1376 mapOffset = offset - (offset % SystemInfo.dwAllocationGranularity);
1377 mapSize = dib->dsBmih.biSizeImage + (offset - mapOffset);
1378 mapBits = MapViewOfFile( section, FILE_MAP_ALL_ACCESS, 0, mapOffset, mapSize );
1379 if (mapBits) dib->dsBm.bmBits = (char *)mapBits + (offset - mapOffset);
1380 }
1381 else
1382 {
1383 offset = 0;
1384 dib->dsBm.bmBits = VirtualAlloc( NULL, dib->dsBmih.biSizeImage,
1385 MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE );
1386 }
1387 dib->dshSection = section;
1388 dib->dsOffset = offset;
1389
1390 if (!dib->dsBm.bmBits)
1391 {
1392 HeapFree( GetProcessHeap(), 0, dib );
1393 return 0;
1394 }
1395
1396 /* If the reference hdc is null, take the desktop dc */
1397 if (hdc == 0)
1398 {
1399 hdc = CreateCompatibleDC(0);
1400 bDesktopDC = TRUE;
1401 }
1402
1403 if (!(dc = get_dc_ptr( hdc ))) goto error;
1404
1405 /* create Device Dependent Bitmap and add DIB pointer */
1406 ret = CreateBitmap( dib->dsBm.bmWidth, dib->dsBm.bmHeight, 1,
1407 (bpp == 1) ? 1 : GetDeviceCaps(hdc, BITSPIXEL), NULL );
1408
1409 if (ret && ((bmp = GDI_GetObjPtr(ret, OBJ_BITMAP))))
1410 {
1411 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pCreateDIBSection );
1412 bmp->dib = dib;
1413 bmp->funcs = physdev->funcs;
1414 /* create local copy of DIB palette */
1415 if (bpp <= 8) DIB_CopyColorTable( dc, bmp, usage, bmi );
1416 GDI_ReleaseObj( ret );
1417
1418 if (!physdev->funcs->pCreateDIBSection( physdev, ret, bmi, usage ))
1419 {
1420 DeleteObject( ret );
1421 ret = 0;
1422 }
1423 }
1424
1425 release_dc_ptr( dc );
1426 if (bDesktopDC) DeleteDC( hdc );
1427 if (ret && bits) *bits = dib->dsBm.bmBits;
1428 return ret;
1429
1430 error:
1431 if (bDesktopDC) DeleteDC( hdc );
1432 if (section) UnmapViewOfFile( mapBits );
1433 else if (!offset) VirtualFree( dib->dsBm.bmBits, 0, MEM_RELEASE );
1434 HeapFree( GetProcessHeap(), 0, dib );
1435 return 0;
1436 }
Windows API implementation