?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Avoid TRUE:FALSE conditional expressions.
[wine.git] / dlls / gdi32 / dib.c
blobc35de33f91307ada41b9652c24211b13e6b1dc37
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
33
34 * The palettes are stored in different formats:
35
36 - BITMAPCOREINFO: Array of RGBTRIPLE
37 - BITMAPINFO: Array of RGBQUAD
38
39
40 * There are even more DIB headers, but they all extend BITMAPINFOHEADER:
41
42 - BITMAPV4HEADER: Introduced in Windows 95 / NT 4.0
43 - BITMAPV5HEADER: Introduced in Windows 98 / 2000
44
45 If biCompression is BI_BITFIELDS, the color masks are at the same position
46 in all the headers (they start at bmiColors of BITMAPINFOHEADER), because
47 the new headers have structure members for the masks.
48
49
50 * You should never access the color table using the bmiColors member,
51 because the passed structure may have one of the extended headers
52 mentioned above. Use this to calculate the location:
53
54 BITMAPINFO* info;
55 void* colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
56
57
58 * More information:
59 Search for "Bitmap Structures" in MSDN
60 */
61
62 #include <stdarg.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <assert.h>
66
67 #include "windef.h"
68 #include "winbase.h"
69 #include "gdi_private.h"
70 #include "wine/debug.h"
71
72 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
73
74
75 static HGDIOBJ DIB_SelectObject( HGDIOBJ handle, HDC hdc );
76 static INT DIB_GetObject( HGDIOBJ handle, INT count, LPVOID buffer );
77 static BOOL DIB_DeleteObject( HGDIOBJ handle );
78
79 static const struct gdi_obj_funcs dib_funcs =
80 {
81 DIB_SelectObject, /* pSelectObject */
82 DIB_GetObject, /* pGetObjectA */
83 DIB_GetObject, /* pGetObjectW */
84 NULL, /* pUnrealizeObject */
85 DIB_DeleteObject /* pDeleteObject */
86 };
87
88 /***********************************************************************
89 * bitmap_info_size
90 *
91 * Return the size of the bitmap info structure including color table.
92 */
93 int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
94 {
95 unsigned int colors, size, masks = 0;
96
97 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
98 {
99 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
100 colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
101 return sizeof(BITMAPCOREHEADER) + colors *
102 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
103 }
104 else /* assume BITMAPINFOHEADER */
105 {
106 if (info->bmiHeader.biClrUsed) colors = min( info->bmiHeader.biClrUsed, 256 );
107 else colors = info->bmiHeader.biBitCount > 8 ? 0 : 1 << info->bmiHeader.biBitCount;
108 if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
109 size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
110 return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
111 }
112 }
113
114 /*******************************************************************************************
115 * Verify that the DIB parameters are valid.
116 */
117 static BOOL is_valid_dib_format( const BITMAPINFOHEADER *info, BOOL allow_compression )
118 {
119 if (info->biWidth <= 0) return FALSE;
120 if (info->biHeight == 0) return FALSE;
121
122 if (allow_compression && (info->biCompression == BI_RLE4 || info->biCompression == BI_RLE8))
123 {
124 if (info->biHeight < 0) return FALSE;
125 if (!info->biSizeImage) return FALSE;
126 return info->biBitCount == (info->biCompression == BI_RLE4 ? 4 : 8);
127 }
128
129 if (!info->biPlanes) return FALSE;
130
131 switch (info->biBitCount)
132 {
133 case 1:
134 case 4:
135 case 8:
136 case 24:
137 return (info->biCompression == BI_RGB);
138 case 16:
139 case 32:
140 return (info->biCompression == BI_BITFIELDS || info->biCompression == BI_RGB);
141 default:
142 return FALSE;
143 }
144 }
145
146 /*******************************************************************************************
147 * Fill out a true BITMAPINFOHEADER from a variable sized BITMAPINFOHEADER / BITMAPCOREHEADER.
148 */
149 static BOOL bitmapinfoheader_from_user_bitmapinfo( BITMAPINFOHEADER *dst, const BITMAPINFOHEADER *info )
150 {
151 if (!info) return FALSE;
152
153 if (info->biSize == sizeof(BITMAPCOREHEADER))
154 {
155 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
156 dst->biWidth = core->bcWidth;
157 dst->biHeight = core->bcHeight;
158 dst->biPlanes = core->bcPlanes;
159 dst->biBitCount = core->bcBitCount;
160 dst->biCompression = BI_RGB;
161 dst->biXPelsPerMeter = 0;
162 dst->biYPelsPerMeter = 0;
163 dst->biClrUsed = 0;
164 dst->biClrImportant = 0;
165 }
166 else if (info->biSize >= sizeof(BITMAPINFOHEADER)) /* assume BITMAPINFOHEADER */
167 {
168 *dst = *info;
169 }
170 else
171 {
172 WARN( "(%u): unknown/wrong size for header\n", info->biSize );
173 return FALSE;
174 }
175
176 dst->biSize = sizeof(*dst);
177 if (dst->biCompression == BI_RGB || dst->biCompression == BI_BITFIELDS)
178 dst->biSizeImage = get_dib_image_size( (BITMAPINFO *)dst );
179 return TRUE;
180 }
181
182 /*******************************************************************************************
183 * Fill out a true BITMAPINFO from a variable sized BITMAPINFO / BITMAPCOREINFO.
184 *
185 * The resulting sanitized BITMAPINFO is guaranteed to have:
186 * - biSize set to sizeof(BITMAPINFOHEADER)
187 * - biSizeImage set to the actual image size even for non-compressed DIB
188 * - biClrUsed set to the size of the color table, and 0 only when there is no color table
189 * - color table present only for <= 8 bpp, always starts at info->bmiColors
190 */
191 static BOOL bitmapinfo_from_user_bitmapinfo( BITMAPINFO *dst, const BITMAPINFO *info,
192 UINT coloruse, BOOL allow_compression )
193 {
194 void *src_colors;
195
196 if (coloruse > DIB_PAL_COLORS + 1) return FALSE; /* FIXME: handle DIB_PAL_COLORS+1 format */
197 if (!bitmapinfoheader_from_user_bitmapinfo( &dst->bmiHeader, &info->bmiHeader )) return FALSE;
198 if (!is_valid_dib_format( &dst->bmiHeader, allow_compression )) return FALSE;
199
200 src_colors = (char *)info + info->bmiHeader.biSize;
201
202 if (dst->bmiHeader.biCompression == BI_BITFIELDS)
203 {
204 /* bitfields are always at bmiColors even in larger structures */
205 memcpy( dst->bmiColors, info->bmiColors, 3 * sizeof(DWORD) );
206 dst->bmiHeader.biClrUsed = 0;
207 }
208 else if (dst->bmiHeader.biBitCount <= 8)
209 {
210 unsigned int colors = dst->bmiHeader.biClrUsed;
211 unsigned int max_colors = 1 << dst->bmiHeader.biBitCount;
212
213 if (!colors) colors = max_colors;
214 else colors = min( colors, max_colors );
215
216 if (coloruse == DIB_PAL_COLORS)
217 {
218 memcpy( dst->bmiColors, src_colors, colors * sizeof(WORD) );
219 max_colors = colors;
220 }
221 else if (info->bmiHeader.biSize != sizeof(BITMAPCOREHEADER))
222 {
223 memcpy( dst->bmiColors, src_colors, colors * sizeof(RGBQUAD) );
224 }
225 else
226 {
227 unsigned int i;
228 RGBTRIPLE *triple = (RGBTRIPLE *)src_colors;
229 for (i = 0; i < colors; i++)
230 {
231 dst->bmiColors[i].rgbRed = triple[i].rgbtRed;
232 dst->bmiColors[i].rgbGreen = triple[i].rgbtGreen;
233 dst->bmiColors[i].rgbBlue = triple[i].rgbtBlue;
234 dst->bmiColors[i].rgbReserved = 0;
235 }
236 }
237 memset( dst->bmiColors + colors, 0, (max_colors - colors) * sizeof(RGBQUAD) );
238 dst->bmiHeader.biClrUsed = max_colors;
239 }
240 else dst->bmiHeader.biClrUsed = 0;
241
242 return TRUE;
243 }
244
245 static int fill_color_table_from_palette( BITMAPINFO *info, HDC hdc )
246 {
247 PALETTEENTRY palEntry[256];
248 HPALETTE palette = GetCurrentObject( hdc, OBJ_PAL );
249 int i, colors = 1 << info->bmiHeader.biBitCount;
250
251 info->bmiHeader.biClrUsed = colors;
252
253 if (!palette) return 0;
254
255 memset( palEntry, 0, sizeof(palEntry) );
256 if (!GetPaletteEntries( palette, 0, colors, palEntry ))
257 return 0;
258
259 for (i = 0; i < colors; i++)
260 {
261 info->bmiColors[i].rgbRed = palEntry[i].peRed;
262 info->bmiColors[i].rgbGreen = palEntry[i].peGreen;
263 info->bmiColors[i].rgbBlue = palEntry[i].peBlue;
264 info->bmiColors[i].rgbReserved = 0;
265 }
266
267 return colors;
268 }
269
270 BOOL fill_color_table_from_pal_colors( BITMAPINFO *info, HDC hdc )
271 {
272 PALETTEENTRY entries[256];
273 RGBQUAD table[256];
274 HPALETTE palette;
275 const WORD *index = (const WORD *)info->bmiColors;
276 int i, count, colors = info->bmiHeader.biClrUsed;
277
278 if (!colors) return TRUE;
279 if (!(palette = GetCurrentObject( hdc, OBJ_PAL ))) return FALSE;
280 if (!(count = GetPaletteEntries( palette, 0, colors, entries ))) return FALSE;
281
282 for (i = 0; i < colors; i++, index++)
283 {
284 table[i].rgbRed = entries[*index % count].peRed;
285 table[i].rgbGreen = entries[*index % count].peGreen;
286 table[i].rgbBlue = entries[*index % count].peBlue;
287 table[i].rgbReserved = 0;
288 }
289 info->bmiHeader.biClrUsed = 1 << info->bmiHeader.biBitCount;
290 memcpy( info->bmiColors, table, colors * sizeof(RGBQUAD) );
291 memset( info->bmiColors + colors, 0, (info->bmiHeader.biClrUsed - colors) * sizeof(RGBQUAD) );
292 return TRUE;
293 }
294
295 static void *get_pixel_ptr( const BITMAPINFO *info, void *bits, int x, int y )
296 {
297 const int width = info->bmiHeader.biWidth, height = info->bmiHeader.biHeight;
298 const int bpp = info->bmiHeader.biBitCount;
299
300 if (height > 0)
301 return (char *)bits + (height - y - 1) * get_dib_stride( width, bpp ) + x * bpp / 8;
302 else
303 return (char *)bits + y * get_dib_stride( width, bpp ) + x * bpp / 8;
304 }
305
306 static BOOL build_rle_bitmap( const BITMAPINFO *info, struct gdi_image_bits *bits, HRGN *clip )
307 {
308 int i = 0;
309 int left, right;
310 int x, y, width = info->bmiHeader.biWidth, height = info->bmiHeader.biHeight;
311 HRGN run = NULL;
312 BYTE skip, num, data;
313 BYTE *out_bits, *in_bits = bits->ptr;
314
315 if (clip) *clip = NULL;
316
317 assert( info->bmiHeader.biBitCount == 4 || info->bmiHeader.biBitCount == 8 );
318
319 out_bits = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, get_dib_image_size( info ) );
320 if (!out_bits) goto fail;
321
322 if (clip)
323 {
324 *clip = CreateRectRgn( 0, 0, 0, 0 );
325 run = CreateRectRgn( 0, 0, 0, 0 );
326 if (!*clip || !run) goto fail;
327 }
328
329 x = left = right = 0;
330 y = height - 1;
331
332 while (i < info->bmiHeader.biSizeImage - 1)
333 {
334 num = in_bits[i];
335 data = in_bits[i + 1];
336 i += 2;
337
338 if (num)
339 {
340 if (x + num > width) num = width - x;
341 if (num)
342 {
343 BYTE s = data, *out_ptr = get_pixel_ptr( info, out_bits, x, y );
344 if (info->bmiHeader.biBitCount == 8)
345 memset( out_ptr, s, num );
346 else
347 {
348 if(x & 1)
349 {
350 s = ((s >> 4) & 0x0f) | ((s << 4) & 0xf0);
351 *out_ptr = (*out_ptr & 0xf0) | (s & 0x0f);
352 out_ptr++;
353 x++;
354 num--;
355 }
356 /* this will write one too many if num is odd, but that doesn't matter */
357 if (num) memset( out_ptr, s, (num + 1) / 2 );
358 }
359 }
360 x += num;
361 right = x;
362 }
363 else
364 {
365 if (data < 3)
366 {
367 if(left != right && clip)
368 {
369 SetRectRgn( run, left, y, right, y + 1 );
370 CombineRgn( *clip, run, *clip, RGN_OR );
371 }
372 switch (data)
373 {
374 case 0: /* eol */
375 left = right = x = 0;
376 y--;
377 if(y < 0) goto done;
378 break;
379
380 case 1: /* eod */
381 goto done;
382
383 case 2: /* delta */
384 if (i >= info->bmiHeader.biSizeImage - 1) goto done;
385 x += in_bits[i];
386 if (x > width) x = width;
387 left = right = x;
388 y -= in_bits[i + 1];
389 if(y < 0) goto done;
390 i += 2;
391 }
392 }
393 else /* data bytes of data */
394 {
395 num = data;
396 skip = (num * info->bmiHeader.biBitCount + 7) / 8;
397 if (skip > info->bmiHeader.biSizeImage - i) goto done;
398 skip = (skip + 1) & ~1;
399 if (x + num > width) num = width - x;
400 if (num)
401 {
402 BYTE *out_ptr = get_pixel_ptr( info, out_bits, x, y );
403 if (info->bmiHeader.biBitCount == 8)
404 memcpy( out_ptr, in_bits + i, num );
405 else
406 {
407 if(x & 1)
408 {
409 const BYTE *in_ptr = in_bits + i;
410 for ( ; num; num--, x++)
411 {
412 if (x & 1)
413 {
414 *out_ptr = (*out_ptr & 0xf0) | ((*in_ptr >> 4) & 0x0f);
415 out_ptr++;
416 }
417 else
418 *out_ptr = (*in_ptr++ << 4) & 0xf0;
419 }
420 }
421 else
422 memcpy( out_ptr, in_bits + i, (num + 1) / 2);
423 }
424 }
425 x += num;
426 right = x;
427 i += skip;
428 }
429 }
430 }
431
432 done:
433 if (run) DeleteObject( run );
434 if (bits->free) bits->free( bits );
435
436 bits->ptr = out_bits;
437 bits->is_copy = TRUE;
438 bits->free = free_heap_bits;
439
440 return TRUE;
441
442 fail:
443 if (run) DeleteObject( run );
444 if (clip && *clip) DeleteObject( *clip );
445 HeapFree( GetProcessHeap(), 0, out_bits );
446 return FALSE;
447 }
448
449
450
451 INT nulldrv_StretchDIBits( PHYSDEV dev, INT xDst, INT yDst, INT widthDst, INT heightDst,
452 INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void *bits,
453 BITMAPINFO *src_info, UINT coloruse, DWORD rop )
454 {
455 DC *dc = get_nulldrv_dc( dev );
456 char dst_buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
457 BITMAPINFO *dst_info = (BITMAPINFO *)dst_buffer;
458 struct bitblt_coords src, dst;
459 struct gdi_image_bits src_bits;
460 DWORD err;
461 HRGN clip = NULL;
462 INT ret = 0;
463 INT height = abs( src_info->bmiHeader.biHeight );
464 BOOL top_down = src_info->bmiHeader.biHeight < 0, non_stretch_from_origin = FALSE;
465 RECT rect;
466
467 TRACE("%d %d %d %d <- %d %d %d %d rop %08x\n", xDst, yDst, widthDst, heightDst,
468 xSrc, ySrc, widthSrc, heightSrc, rop);
469
470 src_bits.ptr = (void*)bits;
471 src_bits.is_copy = FALSE;
472 src_bits.free = NULL;
473
474 if (coloruse == DIB_PAL_COLORS && !fill_color_table_from_pal_colors( src_info, dev->hdc )) return 0;
475
476 rect.left = xDst;
477 rect.top = yDst;
478 rect.right = xDst + widthDst;
479 rect.bottom = yDst + heightDst;
480 LPtoDP( dc->hSelf, (POINT *)&rect, 2 );
481 dst.x = rect.left;
482 dst.y = rect.top;
483 dst.width = rect.right - rect.left;
484 dst.height = rect.bottom - rect.top;
485
486 if (dc->layout & LAYOUT_RTL && rop & NOMIRRORBITMAP)
487 {
488 dst.x += dst.width;
489 dst.width = -dst.width;
490 }
491 rop &= ~NOMIRRORBITMAP;
492
493 src.x = xSrc;
494 src.width = widthSrc;
495 src.y = ySrc;
496 src.height = heightSrc;
497
498 if (src.x == 0 && src.y == 0 && src.width == dst.width && src.height == dst.height)
499 non_stretch_from_origin = TRUE;
500
501 if (src_info->bmiHeader.biCompression == BI_RLE4 || src_info->bmiHeader.biCompression == BI_RLE8)
502 {
503 BOOL want_clip = non_stretch_from_origin && (rop == SRCCOPY);
504 if (!build_rle_bitmap( src_info, &src_bits, want_clip ? &clip : NULL )) return 0;
505 }
506
507 if (rop != SRCCOPY || non_stretch_from_origin)
508 {
509 if (dst.width == 1 && src.width > 1) src.width--;
510 if (dst.height == 1 && src.height > 1) src.height--;
511 }
512
513 if (rop != SRCCOPY)
514 {
515 if (dst.width < 0 && dst.width == src.width)
516 {
517 /* This is off-by-one, but that's what Windows does */
518 dst.x += dst.width;
519 src.x += src.width;
520 dst.width = -dst.width;
521 src.width = -src.width;
522 }
523 if (dst.height < 0 && dst.height == src.height)
524 {
525 dst.y += dst.height;
526 src.y += src.height;
527 dst.height = -dst.height;
528 src.height = -src.height;
529 }
530 }
531
532 if (!top_down || (rop == SRCCOPY && !non_stretch_from_origin)) src.y = height - src.y - src.height;
533
534 if (src.y >= height && src.y + src.height + 1 < height)
535 src.y = height - 1;
536 else if (src.y > 0 && src.y + src.height + 1 < 0)
537 src.y = -src.height - 1;
538
539 get_bounding_rect( &rect, src.x, src.y, src.width, src.height );
540
541 src.visrect.left = 0;
542 src.visrect.right = src_info->bmiHeader.biWidth;
543 src.visrect.top = 0;
544 src.visrect.bottom = height;
545 if (!intersect_rect( &src.visrect, &src.visrect, &rect )) goto done;
546
547 if (rop == SRCCOPY) ret = height;
548 else ret = src_info->bmiHeader.biHeight;
549
550 get_bounding_rect( &rect, dst.x, dst.y, dst.width, dst.height );
551
552 if (!clip_visrect( dc, &dst.visrect, &rect )) goto done;
553
554 if (!intersect_vis_rectangles( &dst, &src )) goto done;
555
556 if (clip) OffsetRgn( clip, dst.x - src.x, dst.y - src.y );
557
558 dev = GET_DC_PHYSDEV( dc, pPutImage );
559 copy_bitmapinfo( dst_info, src_info );
560 err = dev->funcs->pPutImage( dev, clip, dst_info, &src_bits, &src, &dst, rop );
561 if (err == ERROR_BAD_FORMAT)
562 {
563 /* 1-bpp destination without a color table requires a fake 1-entry table
564 * that contains only the background color */
565 if (dst_info->bmiHeader.biBitCount == 1 && !dst_info->bmiHeader.biClrUsed)
566 {
567 COLORREF color = GetBkColor( dev->hdc );
568 dst_info->bmiColors[0].rgbRed = GetRValue( color );
569 dst_info->bmiColors[0].rgbGreen = GetGValue( color );
570 dst_info->bmiColors[0].rgbBlue = GetBValue( color );
571 dst_info->bmiColors[0].rgbReserved = 0;
572 dst_info->bmiHeader.biClrUsed = 1;
573 }
574
575 if (!(err = convert_bits( src_info, &src, dst_info, &src_bits, FALSE )))
576 {
577 /* get rid of the fake 1-bpp table */
578 if (dst_info->bmiHeader.biClrUsed == 1) dst_info->bmiHeader.biClrUsed = 0;
579 err = dev->funcs->pPutImage( dev, clip, dst_info, &src_bits, &src, &dst, rop );
580 }
581 }
582
583 if (err == ERROR_TRANSFORM_NOT_SUPPORTED)
584 {
585 copy_bitmapinfo( src_info, dst_info );
586 err = stretch_bits( src_info, &src, dst_info, &dst, &src_bits, GetStretchBltMode( dev->hdc ) );
587 if (!err) err = dev->funcs->pPutImage( dev, NULL, dst_info, &src_bits, &src, &dst, rop );
588 }
589 if (err) ret = 0;
590
591 done:
592 if (src_bits.free) src_bits.free( &src_bits );
593 if (clip) DeleteObject( clip );
594 return ret;
595 }
596
597 /***********************************************************************
598 * StretchDIBits (GDI32.@)
599 */
600 INT WINAPI StretchDIBits(HDC hdc, INT xDst, INT yDst, INT widthDst, INT heightDst,
601 INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void *bits,
602 const BITMAPINFO *bmi, UINT coloruse, DWORD rop )
603 {
604 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
605 BITMAPINFO *info = (BITMAPINFO *)buffer;
606 DC *dc;
607 INT ret = 0;
608
609 if (!bits) return 0;
610 if (!bitmapinfo_from_user_bitmapinfo( info, bmi, coloruse, TRUE ))
611 {
612 SetLastError( ERROR_INVALID_PARAMETER );
613 return 0;
614 }
615
616 if ((dc = get_dc_ptr( hdc )))
617 {
618 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pStretchDIBits );
619 update_dc( dc );
620 ret = physdev->funcs->pStretchDIBits( physdev, xDst, yDst, widthDst, heightDst,
621 xSrc, ySrc, widthSrc, heightSrc, bits, info, coloruse, rop );
622 release_dc_ptr( dc );
623 }
624 return ret;
625 }
626
627
628 /******************************************************************************
629 * SetDIBits [GDI32.@]
630 *
631 * Sets pixels in a bitmap using colors from DIB.
632 *
633 * PARAMS
634 * hdc [I] Handle to device context
635 * hbitmap [I] Handle to bitmap
636 * startscan [I] Starting scan line
637 * lines [I] Number of scan lines
638 * bits [I] Array of bitmap bits
639 * info [I] Address of structure with data
640 * coloruse [I] Type of color indexes to use
641 *
642 * RETURNS
643 * Success: Number of scan lines copied
644 * Failure: 0
645 */
646 INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan,
647 UINT lines, LPCVOID bits, const BITMAPINFO *info,
648 UINT coloruse )
649 {
650 BITMAPOBJ *bitmap;
651 char src_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
652 BITMAPINFO *src_info = (BITMAPINFO *)src_bmibuf;
653 char dst_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
654 BITMAPINFO *dst_info = (BITMAPINFO *)dst_bmibuf;
655 INT result = 0;
656 DWORD err;
657 struct gdi_image_bits src_bits;
658 struct bitblt_coords src, dst;
659 INT src_to_dst_offset;
660 HRGN clip = 0;
661
662 if (!bitmapinfo_from_user_bitmapinfo( src_info, info, coloruse, TRUE ) || coloruse > DIB_PAL_COLORS)
663 {
664 SetLastError( ERROR_INVALID_PARAMETER );
665 return 0;
666 }
667 if (src_info->bmiHeader.biCompression == BI_BITFIELDS)
668 {
669 DWORD *masks = (DWORD *)src_info->bmiColors;
670 if (!masks[0] || !masks[1] || !masks[2])
671 {
672 SetLastError( ERROR_INVALID_PARAMETER );
673 return 0;
674 }
675 }
676
677 src_bits.ptr = (void *)bits;
678 src_bits.is_copy = FALSE;
679 src_bits.free = NULL;
680 src_bits.param = NULL;
681
682 if (coloruse == DIB_PAL_COLORS && !fill_color_table_from_pal_colors( src_info, hdc )) return 0;
683
684 if (!(bitmap = GDI_GetObjPtr( hbitmap, OBJ_BITMAP ))) return 0;
685
686 if (src_info->bmiHeader.biCompression == BI_RLE4 || src_info->bmiHeader.biCompression == BI_RLE8)
687 {
688 if (lines == 0) goto done;
689 else lines = src_info->bmiHeader.biHeight;
690 startscan = 0;
691
692 if (!build_rle_bitmap( src_info, &src_bits, &clip )) goto done;
693 }
694
695 dst.visrect.left = 0;
696 dst.visrect.top = 0;
697 dst.visrect.right = bitmap->dib.dsBm.bmWidth;
698 dst.visrect.bottom = bitmap->dib.dsBm.bmHeight;
699
700 src.visrect.left = 0;
701 src.visrect.top = 0;
702 src.visrect.right = src_info->bmiHeader.biWidth;
703 src.visrect.bottom = abs( src_info->bmiHeader.biHeight );
704
705 if (src_info->bmiHeader.biHeight > 0)
706 {
707 src_to_dst_offset = -startscan;
708 lines = min( lines, src.visrect.bottom - startscan );
709 if (lines < src.visrect.bottom) src.visrect.top = src.visrect.bottom - lines;
710 }
711 else
712 {
713 src_to_dst_offset = src.visrect.bottom - lines - startscan;
714 /* Unlike the bottom-up case, Windows doesn't limit lines. */
715 if (lines < src.visrect.bottom) src.visrect.bottom = lines;
716 }
717
718 result = lines;
719
720 offset_rect( &src.visrect, 0, src_to_dst_offset );
721 if (!intersect_rect( &dst.visrect, &src.visrect, &dst.visrect )) goto done;
722 src.visrect = dst.visrect;
723 offset_rect( &src.visrect, 0, -src_to_dst_offset );
724
725 src.x = src.visrect.left;
726 src.y = src.visrect.top;
727 src.width = src.visrect.right - src.visrect.left;
728 src.height = src.visrect.bottom - src.visrect.top;
729
730 dst.x = dst.visrect.left;
731 dst.y = dst.visrect.top;
732 dst.width = dst.visrect.right - dst.visrect.left;
733 dst.height = dst.visrect.bottom - dst.visrect.top;
734
735 copy_bitmapinfo( dst_info, src_info );
736
737 err = put_image_into_bitmap( bitmap, clip, dst_info, &src_bits, &src, &dst );
738 if (err == ERROR_BAD_FORMAT)
739 {
740 err = convert_bits( src_info, &src, dst_info, &src_bits, FALSE );
741 if (!err) err = put_image_into_bitmap( bitmap, clip, dst_info, &src_bits, &src, &dst );
742 }
743 if(err) result = 0;
744
745 done:
746 if (src_bits.free) src_bits.free( &src_bits );
747 if (clip) DeleteObject( clip );
748 GDI_ReleaseObj( hbitmap );
749 return result;
750 }
751
752
753 INT nulldrv_SetDIBitsToDevice( PHYSDEV dev, INT x_dst, INT y_dst, DWORD cx, DWORD cy,
754 INT x_src, INT y_src, UINT startscan, UINT lines,
755 const void *bits, BITMAPINFO *src_info, UINT coloruse )
756 {
757 DC *dc = get_nulldrv_dc( dev );
758 char dst_buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
759 BITMAPINFO *dst_info = (BITMAPINFO *)dst_buffer;
760 struct bitblt_coords src, dst;
761 struct gdi_image_bits src_bits;
762 HRGN clip = 0;
763 DWORD err;
764 UINT height;
765 BOOL top_down;
766 POINT pt;
767 RECT rect;
768
769 top_down = (src_info->bmiHeader.biHeight < 0);
770 height = abs( src_info->bmiHeader.biHeight );
771
772 src_bits.ptr = (void *)bits;
773 src_bits.is_copy = FALSE;
774 src_bits.free = NULL;
775
776 if (!lines) return 0;
777 if (coloruse == DIB_PAL_COLORS && !fill_color_table_from_pal_colors( src_info, dev->hdc )) return 0;
778
779 if (src_info->bmiHeader.biCompression == BI_RLE4 || src_info->bmiHeader.biCompression == BI_RLE8)
780 {
781 startscan = 0;
782 lines = height;
783 src_info->bmiHeader.biWidth = x_src + cx;
784 src_info->bmiHeader.biHeight = y_src + cy;
785 if (src_info->bmiHeader.biWidth <= 0 || src_info->bmiHeader.biHeight <= 0) return 0;
786 src.x = x_src;
787 src.y = 0;
788 src.width = cx;
789 src.height = cy;
790 if (!build_rle_bitmap( src_info, &src_bits, &clip )) return 0;
791 }
792 else
793 {
794 if (startscan >= height) return 0;
795 if (!top_down && lines > height - startscan) lines = height - startscan;
796
797 /* map src to top-down coordinates with startscan as origin */
798 src.x = x_src;
799 src.y = startscan + lines - (y_src + cy);
800 src.width = cx;
801 src.height = cy;
802 if (src.y > 0)
803 {
804 if (!top_down)
805 {
806 /* get rid of unnecessary lines */
807 if (src.y >= lines) return 0;
808 lines -= src.y;
809 src.y = 0;
810 }
811 else if (src.y >= lines) return lines;
812 }
813 src_info->bmiHeader.biHeight = top_down ? -lines : lines;
814 }
815
816 src.visrect.left = src.x;
817 src.visrect.top = src.y;
818 src.visrect.right = src.x + cx;
819 src.visrect.bottom = src.y + cy;
820 rect.left = 0;
821 rect.top = 0;
822 rect.right = src_info->bmiHeader.biWidth;
823 rect.bottom = abs( src_info->bmiHeader.biHeight );
824 if (!intersect_rect( &src.visrect, &src.visrect, &rect ))
825 {
826 lines = 0;
827 goto done;
828 }
829
830 pt.x = x_dst;
831 pt.y = y_dst;
832 LPtoDP( dev->hdc, &pt, 1 );
833 dst.x = pt.x;
834 dst.y = pt.y;
835 dst.width = cx;
836 dst.height = cy;
837 if (GetLayout( dev->hdc ) & LAYOUT_RTL) dst.x -= cx - 1;
838
839 rect.left = dst.x;
840 rect.top = dst.y;
841 rect.right = dst.x + cx;
842 rect.bottom = dst.y + cy;
843 if (!clip_visrect( dc, &dst.visrect, &rect )) goto done;
844
845 offset_rect( &src.visrect, dst.x - src.x, dst.y - src.y );
846 intersect_rect( &rect, &src.visrect, &dst.visrect );
847 src.visrect = dst.visrect = rect;
848 offset_rect( &src.visrect, src.x - dst.x, src.y - dst.y );
849 if (is_rect_empty( &dst.visrect )) goto done;
850 if (clip) OffsetRgn( clip, dst.x - src.x, dst.y - src.y );
851
852 dev = GET_DC_PHYSDEV( dc, pPutImage );
853 copy_bitmapinfo( dst_info, src_info );
854 err = dev->funcs->pPutImage( dev, clip, dst_info, &src_bits, &src, &dst, SRCCOPY );
855 if (err == ERROR_BAD_FORMAT)
856 {
857 err = convert_bits( src_info, &src, dst_info, &src_bits, FALSE );
858 if (!err) err = dev->funcs->pPutImage( dev, clip, dst_info, &src_bits, &src, &dst, SRCCOPY );
859 }
860 if (err) lines = 0;
861
862 done:
863 if (src_bits.free) src_bits.free( &src_bits );
864 if (clip) DeleteObject( clip );
865 return lines;
866 }
867
868 /***********************************************************************
869 * SetDIBitsToDevice (GDI32.@)
870 */
871 INT WINAPI SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx,
872 DWORD cy, INT xSrc, INT ySrc, UINT startscan,
873 UINT lines, LPCVOID bits, const BITMAPINFO *bmi,
874 UINT coloruse )
875 {
876 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
877 BITMAPINFO *info = (BITMAPINFO *)buffer;
878 INT ret = 0;
879 DC *dc;
880
881 if (!bits) return 0;
882 if (!bitmapinfo_from_user_bitmapinfo( info, bmi, coloruse, TRUE ))
883 {
884 SetLastError( ERROR_INVALID_PARAMETER );
885 return 0;
886 }
887
888 if ((dc = get_dc_ptr( hdc )))
889 {
890 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDIBitsToDevice );
891 update_dc( dc );
892 ret = physdev->funcs->pSetDIBitsToDevice( physdev, xDest, yDest, cx, cy, xSrc,
893 ySrc, startscan, lines, bits, info, coloruse );
894 release_dc_ptr( dc );
895 }
896 return ret;
897 }
898
899 /***********************************************************************
900 * SetDIBColorTable (GDI32.@)
901 */
902 UINT WINAPI SetDIBColorTable( HDC hdc, UINT startpos, UINT entries, CONST RGBQUAD *colors )
903 {
904 DC * dc;
905 UINT result = 0;
906 BITMAPOBJ * bitmap;
907
908 if (!(dc = get_dc_ptr( hdc ))) return 0;
909
910 if ((bitmap = GDI_GetObjPtr( dc->hBitmap, OBJ_BITMAP )))
911 {
912 if (startpos < bitmap->dib.dsBmih.biClrUsed)
913 {
914 result = min( entries, bitmap->dib.dsBmih.biClrUsed - startpos );
915 memcpy(bitmap->color_table + startpos, colors, result * sizeof(RGBQUAD));
916 }
917 GDI_ReleaseObj( dc->hBitmap );
918
919 if (result) /* update colors of selected objects */
920 {
921 SetTextColor( hdc, dc->textColor );
922 SetBkColor( hdc, dc->backgroundColor );
923 SelectObject( hdc, dc->hPen );
924 SelectObject( hdc, dc->hBrush );
925 }
926 }
927 release_dc_ptr( dc );
928 return result;
929 }
930
931
932 /***********************************************************************
933 * GetDIBColorTable (GDI32.@)
934 */
935 UINT WINAPI GetDIBColorTable( HDC hdc, UINT startpos, UINT entries, RGBQUAD *colors )
936 {
937 DC * dc;
938 BITMAPOBJ *bitmap;
939 UINT result = 0;
940
941 if (!(dc = get_dc_ptr( hdc ))) return 0;
942
943 if ((bitmap = GDI_GetObjPtr( dc->hBitmap, OBJ_BITMAP )))
944 {
945 if (startpos < bitmap->dib.dsBmih.biClrUsed)
946 {
947 result = min( entries, bitmap->dib.dsBmih.biClrUsed - startpos );
948 memcpy(colors, bitmap->color_table + startpos, result * sizeof(RGBQUAD));
949 }
950 GDI_ReleaseObj( dc->hBitmap );
951 }
952 release_dc_ptr( dc );
953 return result;
954 }
955
956 static const DWORD bit_fields_888[3] = {0xff0000, 0x00ff00, 0x0000ff};
957 static const DWORD bit_fields_565[3] = {0xf800, 0x07e0, 0x001f};
958 static const DWORD bit_fields_555[3] = {0x7c00, 0x03e0, 0x001f};
959
960 static int fill_query_info( BITMAPINFO *info, BITMAPOBJ *bmp )
961 {
962 BITMAPINFOHEADER header;
963
964 header.biSize = info->bmiHeader.biSize; /* Ensure we don't overwrite the original size when we copy back */
965 header.biWidth = bmp->dib.dsBm.bmWidth;
966 header.biHeight = bmp->dib.dsBm.bmHeight;
967 header.biPlanes = 1;
968 header.biBitCount = bmp->dib.dsBm.bmBitsPixel;
969
970 switch (header.biBitCount)
971 {
972 case 16:
973 case 32:
974 header.biCompression = BI_BITFIELDS;
975 break;
976 default:
977 header.biCompression = BI_RGB;
978 break;
979 }
980
981 header.biSizeImage = get_dib_image_size( (BITMAPINFO *)&header );
982 header.biXPelsPerMeter = 0;
983 header.biYPelsPerMeter = 0;
984 header.biClrUsed = 0;
985 header.biClrImportant = 0;
986
987 if ( info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER) )
988 {
989 BITMAPCOREHEADER *coreheader = (BITMAPCOREHEADER *)info;
990
991 coreheader->bcWidth = header.biWidth;
992 coreheader->bcHeight = header.biHeight;
993 coreheader->bcPlanes = header.biPlanes;
994 coreheader->bcBitCount = header.biBitCount;
995 }
996 else
997 info->bmiHeader = header;
998
999 return bmp->dib.dsBm.bmHeight;
1000 }
1001
1002 /************************************************************************
1003 * copy_color_info
1004 *
1005 * Copy BITMAPINFO color information where dst may be a BITMAPCOREINFO.
1006 */
1007 static void copy_color_info(BITMAPINFO *dst, const BITMAPINFO *src, UINT coloruse)
1008 {
1009 assert( src->bmiHeader.biSize == sizeof(BITMAPINFOHEADER) );
1010
1011 if (dst->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
1012 {
1013 BITMAPCOREINFO *core = (BITMAPCOREINFO *)dst;
1014 if (coloruse == DIB_PAL_COLORS)
1015 memcpy( core->bmciColors, src->bmiColors, src->bmiHeader.biClrUsed * sizeof(WORD) );
1016 else
1017 {
1018 unsigned int i;
1019 for (i = 0; i < src->bmiHeader.biClrUsed; i++)
1020 {
1021 core->bmciColors[i].rgbtRed = src->bmiColors[i].rgbRed;
1022 core->bmciColors[i].rgbtGreen = src->bmiColors[i].rgbGreen;
1023 core->bmciColors[i].rgbtBlue = src->bmiColors[i].rgbBlue;
1024 }
1025 }
1026 }
1027 else
1028 {
1029 dst->bmiHeader.biClrUsed = src->bmiHeader.biClrUsed;
1030 dst->bmiHeader.biSizeImage = src->bmiHeader.biSizeImage;
1031
1032 if (src->bmiHeader.biCompression == BI_BITFIELDS)
1033 /* bitfields are always at bmiColors even in larger structures */
1034 memcpy( dst->bmiColors, src->bmiColors, 3 * sizeof(DWORD) );
1035 else if (src->bmiHeader.biClrUsed)
1036 {
1037 void *colorptr = (char *)dst + dst->bmiHeader.biSize;
1038 unsigned int size;
1039
1040 if (coloruse == DIB_PAL_COLORS)
1041 size = src->bmiHeader.biClrUsed * sizeof(WORD);
1042 else
1043 size = src->bmiHeader.biClrUsed * sizeof(RGBQUAD);
1044 memcpy( colorptr, src->bmiColors, size );
1045 }
1046 }
1047 }
1048
1049 const RGBQUAD *get_default_color_table( int bpp )
1050 {
1051 static const RGBQUAD table_1[2] =
1052 {
1053 { 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff }
1054 };
1055 static const RGBQUAD table_4[16] =
1056 {
1057 { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 },
1058 { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x80 },
1059 { 0xc0, 0xc0, 0xc0 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff },
1060 { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff },
1061 };
1062 static const RGBQUAD table_8[256] =
1063 {
1064 /* first and last 10 entries are the default system palette entries */
1065 { 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0x80 }, { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x80 },
1066 { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x80 }, { 0x80, 0x80, 0x00 }, { 0xc0, 0xc0, 0xc0 },
1067 { 0xc0, 0xdc, 0xc0 }, { 0xf0, 0xca, 0xa6 }, { 0x00, 0x20, 0x40 }, { 0x00, 0x20, 0x60 },
1068 { 0x00, 0x20, 0x80 }, { 0x00, 0x20, 0xa0 }, { 0x00, 0x20, 0xc0 }, { 0x00, 0x20, 0xe0 },
1069 { 0x00, 0x40, 0x00 }, { 0x00, 0x40, 0x20 }, { 0x00, 0x40, 0x40 }, { 0x00, 0x40, 0x60 },
1070 { 0x00, 0x40, 0x80 }, { 0x00, 0x40, 0xa0 }, { 0x00, 0x40, 0xc0 }, { 0x00, 0x40, 0xe0 },
1071 { 0x00, 0x60, 0x00 }, { 0x00, 0x60, 0x20 }, { 0x00, 0x60, 0x40 }, { 0x00, 0x60, 0x60 },
1072 { 0x00, 0x60, 0x80 }, { 0x00, 0x60, 0xa0 }, { 0x00, 0x60, 0xc0 }, { 0x00, 0x60, 0xe0 },
1073 { 0x00, 0x80, 0x00 }, { 0x00, 0x80, 0x20 }, { 0x00, 0x80, 0x40 }, { 0x00, 0x80, 0x60 },
1074 { 0x00, 0x80, 0x80 }, { 0x00, 0x80, 0xa0 }, { 0x00, 0x80, 0xc0 }, { 0x00, 0x80, 0xe0 },
1075 { 0x00, 0xa0, 0x00 }, { 0x00, 0xa0, 0x20 }, { 0x00, 0xa0, 0x40 }, { 0x00, 0xa0, 0x60 },
1076 { 0x00, 0xa0, 0x80 }, { 0x00, 0xa0, 0xa0 }, { 0x00, 0xa0, 0xc0 }, { 0x00, 0xa0, 0xe0 },
1077 { 0x00, 0xc0, 0x00 }, { 0x00, 0xc0, 0x20 }, { 0x00, 0xc0, 0x40 }, { 0x00, 0xc0, 0x60 },
1078 { 0x00, 0xc0, 0x80 }, { 0x00, 0xc0, 0xa0 }, { 0x00, 0xc0, 0xc0 }, { 0x00, 0xc0, 0xe0 },
1079 { 0x00, 0xe0, 0x00 }, { 0x00, 0xe0, 0x20 }, { 0x00, 0xe0, 0x40 }, { 0x00, 0xe0, 0x60 },
1080 { 0x00, 0xe0, 0x80 }, { 0x00, 0xe0, 0xa0 }, { 0x00, 0xe0, 0xc0 }, { 0x00, 0xe0, 0xe0 },
1081 { 0x40, 0x00, 0x00 }, { 0x40, 0x00, 0x20 }, { 0x40, 0x00, 0x40 }, { 0x40, 0x00, 0x60 },
1082 { 0x40, 0x00, 0x80 }, { 0x40, 0x00, 0xa0 }, { 0x40, 0x00, 0xc0 }, { 0x40, 0x00, 0xe0 },
1083 { 0x40, 0x20, 0x00 }, { 0x40, 0x20, 0x20 }, { 0x40, 0x20, 0x40 }, { 0x40, 0x20, 0x60 },
1084 { 0x40, 0x20, 0x80 }, { 0x40, 0x20, 0xa0 }, { 0x40, 0x20, 0xc0 }, { 0x40, 0x20, 0xe0 },
1085 { 0x40, 0x40, 0x00 }, { 0x40, 0x40, 0x20 }, { 0x40, 0x40, 0x40 }, { 0x40, 0x40, 0x60 },
1086 { 0x40, 0x40, 0x80 }, { 0x40, 0x40, 0xa0 }, { 0x40, 0x40, 0xc0 }, { 0x40, 0x40, 0xe0 },
1087 { 0x40, 0x60, 0x00 }, { 0x40, 0x60, 0x20 }, { 0x40, 0x60, 0x40 }, { 0x40, 0x60, 0x60 },
1088 { 0x40, 0x60, 0x80 }, { 0x40, 0x60, 0xa0 }, { 0x40, 0x60, 0xc0 }, { 0x40, 0x60, 0xe0 },
1089 { 0x40, 0x80, 0x00 }, { 0x40, 0x80, 0x20 }, { 0x40, 0x80, 0x40 }, { 0x40, 0x80, 0x60 },
1090 { 0x40, 0x80, 0x80 }, { 0x40, 0x80, 0xa0 }, { 0x40, 0x80, 0xc0 }, { 0x40, 0x80, 0xe0 },
1091 { 0x40, 0xa0, 0x00 }, { 0x40, 0xa0, 0x20 }, { 0x40, 0xa0, 0x40 }, { 0x40, 0xa0, 0x60 },
1092 { 0x40, 0xa0, 0x80 }, { 0x40, 0xa0, 0xa0 }, { 0x40, 0xa0, 0xc0 }, { 0x40, 0xa0, 0xe0 },
1093 { 0x40, 0xc0, 0x00 }, { 0x40, 0xc0, 0x20 }, { 0x40, 0xc0, 0x40 }, { 0x40, 0xc0, 0x60 },
1094 { 0x40, 0xc0, 0x80 }, { 0x40, 0xc0, 0xa0 }, { 0x40, 0xc0, 0xc0 }, { 0x40, 0xc0, 0xe0 },
1095 { 0x40, 0xe0, 0x00 }, { 0x40, 0xe0, 0x20 }, { 0x40, 0xe0, 0x40 }, { 0x40, 0xe0, 0x60 },
1096 { 0x40, 0xe0, 0x80 }, { 0x40, 0xe0, 0xa0 }, { 0x40, 0xe0, 0xc0 }, { 0x40, 0xe0, 0xe0 },
1097 { 0x80, 0x00, 0x00 }, { 0x80, 0x00, 0x20 }, { 0x80, 0x00, 0x40 }, { 0x80, 0x00, 0x60 },
1098 { 0x80, 0x00, 0x80 }, { 0x80, 0x00, 0xa0 }, { 0x80, 0x00, 0xc0 }, { 0x80, 0x00, 0xe0 },
1099 { 0x80, 0x20, 0x00 }, { 0x80, 0x20, 0x20 }, { 0x80, 0x20, 0x40 }, { 0x80, 0x20, 0x60 },
1100 { 0x80, 0x20, 0x80 }, { 0x80, 0x20, 0xa0 }, { 0x80, 0x20, 0xc0 }, { 0x80, 0x20, 0xe0 },
1101 { 0x80, 0x40, 0x00 }, { 0x80, 0x40, 0x20 }, { 0x80, 0x40, 0x40 }, { 0x80, 0x40, 0x60 },
1102 { 0x80, 0x40, 0x80 }, { 0x80, 0x40, 0xa0 }, { 0x80, 0x40, 0xc0 }, { 0x80, 0x40, 0xe0 },
1103 { 0x80, 0x60, 0x00 }, { 0x80, 0x60, 0x20 }, { 0x80, 0x60, 0x40 }, { 0x80, 0x60, 0x60 },
1104 { 0x80, 0x60, 0x80 }, { 0x80, 0x60, 0xa0 }, { 0x80, 0x60, 0xc0 }, { 0x80, 0x60, 0xe0 },
1105 { 0x80, 0x80, 0x00 }, { 0x80, 0x80, 0x20 }, { 0x80, 0x80, 0x40 }, { 0x80, 0x80, 0x60 },
1106 { 0x80, 0x80, 0x80 }, { 0x80, 0x80, 0xa0 }, { 0x80, 0x80, 0xc0 }, { 0x80, 0x80, 0xe0 },
1107 { 0x80, 0xa0, 0x00 }, { 0x80, 0xa0, 0x20 }, { 0x80, 0xa0, 0x40 }, { 0x80, 0xa0, 0x60 },
1108 { 0x80, 0xa0, 0x80 }, { 0x80, 0xa0, 0xa0 }, { 0x80, 0xa0, 0xc0 }, { 0x80, 0xa0, 0xe0 },
1109 { 0x80, 0xc0, 0x00 }, { 0x80, 0xc0, 0x20 }, { 0x80, 0xc0, 0x40 }, { 0x80, 0xc0, 0x60 },
1110 { 0x80, 0xc0, 0x80 }, { 0x80, 0xc0, 0xa0 }, { 0x80, 0xc0, 0xc0 }, { 0x80, 0xc0, 0xe0 },
1111 { 0x80, 0xe0, 0x00 }, { 0x80, 0xe0, 0x20 }, { 0x80, 0xe0, 0x40 }, { 0x80, 0xe0, 0x60 },
1112 { 0x80, 0xe0, 0x80 }, { 0x80, 0xe0, 0xa0 }, { 0x80, 0xe0, 0xc0 }, { 0x80, 0xe0, 0xe0 },
1113 { 0xc0, 0x00, 0x00 }, { 0xc0, 0x00, 0x20 }, { 0xc0, 0x00, 0x40 }, { 0xc0, 0x00, 0x60 },
1114 { 0xc0, 0x00, 0x80 }, { 0xc0, 0x00, 0xa0 }, { 0xc0, 0x00, 0xc0 }, { 0xc0, 0x00, 0xe0 },
1115 { 0xc0, 0x20, 0x00 }, { 0xc0, 0x20, 0x20 }, { 0xc0, 0x20, 0x40 }, { 0xc0, 0x20, 0x60 },
1116 { 0xc0, 0x20, 0x80 }, { 0xc0, 0x20, 0xa0 }, { 0xc0, 0x20, 0xc0 }, { 0xc0, 0x20, 0xe0 },
1117 { 0xc0, 0x40, 0x00 }, { 0xc0, 0x40, 0x20 }, { 0xc0, 0x40, 0x40 }, { 0xc0, 0x40, 0x60 },
1118 { 0xc0, 0x40, 0x80 }, { 0xc0, 0x40, 0xa0 }, { 0xc0, 0x40, 0xc0 }, { 0xc0, 0x40, 0xe0 },
1119 { 0xc0, 0x60, 0x00 }, { 0xc0, 0x60, 0x20 }, { 0xc0, 0x60, 0x40 }, { 0xc0, 0x60, 0x60 },
1120 { 0xc0, 0x60, 0x80 }, { 0xc0, 0x60, 0xa0 }, { 0xc0, 0x60, 0xc0 }, { 0xc0, 0x60, 0xe0 },
1121 { 0xc0, 0x80, 0x00 }, { 0xc0, 0x80, 0x20 }, { 0xc0, 0x80, 0x40 }, { 0xc0, 0x80, 0x60 },
1122 { 0xc0, 0x80, 0x80 }, { 0xc0, 0x80, 0xa0 }, { 0xc0, 0x80, 0xc0 }, { 0xc0, 0x80, 0xe0 },
1123 { 0xc0, 0xa0, 0x00 }, { 0xc0, 0xa0, 0x20 }, { 0xc0, 0xa0, 0x40 }, { 0xc0, 0xa0, 0x60 },
1124 { 0xc0, 0xa0, 0x80 }, { 0xc0, 0xa0, 0xa0 }, { 0xc0, 0xa0, 0xc0 }, { 0xc0, 0xa0, 0xe0 },
1125 { 0xc0, 0xc0, 0x00 }, { 0xc0, 0xc0, 0x20 }, { 0xc0, 0xc0, 0x40 }, { 0xc0, 0xc0, 0x60 },
1126 { 0xc0, 0xc0, 0x80 }, { 0xc0, 0xc0, 0xa0 }, { 0xf0, 0xfb, 0xff }, { 0xa4, 0xa0, 0xa0 },
1127 { 0x80, 0x80, 0x80 }, { 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00 }, { 0x00, 0xff, 0xff },
1128 { 0xff, 0x00, 0x00 }, { 0xff, 0x00, 0xff }, { 0xff, 0xff, 0x00 }, { 0xff, 0xff, 0xff },
1129 };
1130
1131 switch (bpp)
1132 {
1133 case 1: return table_1;
1134 case 4: return table_4;
1135 case 8: return table_8;
1136 default: return NULL;
1137 }
1138 }
1139
1140 void fill_default_color_table( BITMAPINFO *info )
1141 {
1142 info->bmiHeader.biClrUsed = 1 << info->bmiHeader.biBitCount;
1143 memcpy( info->bmiColors, get_default_color_table( info->bmiHeader.biBitCount ),
1144 info->bmiHeader.biClrUsed * sizeof(RGBQUAD) );
1145 }
1146
1147 void get_ddb_bitmapinfo( BITMAPOBJ *bmp, BITMAPINFO *info )
1148 {
1149 info->bmiHeader.biSize = sizeof(info->bmiHeader);
1150 info->bmiHeader.biWidth = bmp->dib.dsBm.bmWidth;
1151 info->bmiHeader.biHeight = -bmp->dib.dsBm.bmHeight;
1152 info->bmiHeader.biPlanes = 1;
1153 info->bmiHeader.biBitCount = bmp->dib.dsBm.bmBitsPixel;
1154 info->bmiHeader.biCompression = BI_RGB;
1155 info->bmiHeader.biXPelsPerMeter = 0;
1156 info->bmiHeader.biYPelsPerMeter = 0;
1157 info->bmiHeader.biClrUsed = 0;
1158 info->bmiHeader.biClrImportant = 0;
1159 }
1160
1161 BITMAPINFO *copy_packed_dib( const BITMAPINFO *src_info, UINT usage )
1162 {
1163 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1164 BITMAPINFO *ret, *info = (BITMAPINFO *)buffer;
1165 unsigned int info_size;
1166
1167 if (!bitmapinfo_from_user_bitmapinfo( info, src_info, usage, FALSE )) return NULL;
1168
1169 info_size = get_dib_info_size( info, usage );
1170 if ((ret = HeapAlloc( GetProcessHeap(), 0, info_size + info->bmiHeader.biSizeImage )))
1171 {
1172 memcpy( ret, info, info_size );
1173 memcpy( (char *)ret + info_size, (char *)src_info + bitmap_info_size( src_info, usage ),
1174 info->bmiHeader.biSizeImage );
1175 }
1176 return ret;
1177 }
1178
1179 /******************************************************************************
1180 * GetDIBits [GDI32.@]
1181 *
1182 * Retrieves bits of bitmap and copies to buffer.
1183 *
1184 * RETURNS
1185 * Success: Number of scan lines copied from bitmap
1186 * Failure: 0
1187 */
1188 INT WINAPI GetDIBits(
1189 HDC hdc, /* [in] Handle to device context */
1190 HBITMAP hbitmap, /* [in] Handle to bitmap */
1191 UINT startscan, /* [in] First scan line to set in dest bitmap */
1192 UINT lines, /* [in] Number of scan lines to copy */
1193 LPVOID bits, /* [out] Address of array for bitmap bits */
1194 BITMAPINFO * info, /* [out] Address of structure with bitmap data */
1195 UINT coloruse) /* [in] RGB or palette index */
1196 {
1197 DC * dc;
1198 BITMAPOBJ * bmp;
1199 int i, dst_to_src_offset, ret = 0;
1200 DWORD err;
1201 char dst_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1202 BITMAPINFO *dst_info = (BITMAPINFO *)dst_bmibuf;
1203 char src_bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1204 BITMAPINFO *src_info = (BITMAPINFO *)src_bmibuf;
1205 struct gdi_image_bits src_bits;
1206 struct bitblt_coords src, dst;
1207 BOOL empty_rect = FALSE;
1208
1209 /* Since info may be a BITMAPCOREINFO or any of the larger BITMAPINFO structures, we'll use our
1210 own copy and transfer the colour info back at the end */
1211 if (!bitmapinfoheader_from_user_bitmapinfo( &dst_info->bmiHeader, &info->bmiHeader )) return 0;
1212 if (coloruse > DIB_PAL_COLORS) return 0;
1213 if (bits &&
1214 (dst_info->bmiHeader.biCompression == BI_JPEG || dst_info->bmiHeader.biCompression == BI_PNG))
1215 return 0;
1216 dst_info->bmiHeader.biClrUsed = 0;
1217 dst_info->bmiHeader.biClrImportant = 0;
1218
1219 if (!(dc = get_dc_ptr( hdc )))
1220 {
1221 SetLastError( ERROR_INVALID_PARAMETER );
1222 return 0;
1223 }
1224 update_dc( dc );
1225 if (!(bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP )))
1226 {
1227 release_dc_ptr( dc );
1228 return 0;
1229 }
1230
1231 src.visrect.left = 0;
1232 src.visrect.top = 0;
1233 src.visrect.right = bmp->dib.dsBm.bmWidth;
1234 src.visrect.bottom = bmp->dib.dsBm.bmHeight;
1235
1236 dst.visrect.left = 0;
1237 dst.visrect.top = 0;
1238 dst.visrect.right = dst_info->bmiHeader.biWidth;
1239 dst.visrect.bottom = abs( dst_info->bmiHeader.biHeight );
1240
1241 if (lines == 0 || startscan >= dst.visrect.bottom)
1242 bits = NULL;
1243
1244 if (!bits && dst_info->bmiHeader.biBitCount == 0) /* query bitmap info only */
1245 {
1246 ret = fill_query_info( info, bmp );
1247 goto done;
1248 }
1249
1250 /* validate parameters */
1251
1252 if (dst_info->bmiHeader.biWidth <= 0) goto done;
1253 if (dst_info->bmiHeader.biHeight == 0) goto done;
1254
1255 switch (dst_info->bmiHeader.biCompression)
1256 {
1257 case BI_RLE4:
1258 if (dst_info->bmiHeader.biBitCount != 4) goto done;
1259 if (dst_info->bmiHeader.biHeight < 0) goto done;
1260 if (bits) goto done; /* can't retrieve compressed bits */
1261 break;
1262 case BI_RLE8:
1263 if (dst_info->bmiHeader.biBitCount != 8) goto done;
1264 if (dst_info->bmiHeader.biHeight < 0) goto done;
1265 if (bits) goto done; /* can't retrieve compressed bits */
1266 break;
1267 case BI_BITFIELDS:
1268 if (dst_info->bmiHeader.biBitCount != 16 && dst_info->bmiHeader.biBitCount != 32) goto done;
1269 /* fall through */
1270 case BI_RGB:
1271 if (lines && !dst_info->bmiHeader.biPlanes) goto done;
1272 if (dst_info->bmiHeader.biBitCount == 1) break;
1273 if (dst_info->bmiHeader.biBitCount == 4) break;
1274 if (dst_info->bmiHeader.biBitCount == 8) break;
1275 if (dst_info->bmiHeader.biBitCount == 16) break;
1276 if (dst_info->bmiHeader.biBitCount == 24) break;
1277 if (dst_info->bmiHeader.biBitCount == 32) break;
1278 /* fall through */
1279 default:
1280 goto done;
1281 }
1282
1283 if (bits)
1284 {
1285 if (dst_info->bmiHeader.biHeight > 0)
1286 {
1287 dst_to_src_offset = -startscan;
1288 lines = min( lines, dst.visrect.bottom - startscan );
1289 if (lines < dst.visrect.bottom) dst.visrect.top = dst.visrect.bottom - lines;
1290 }
1291 else
1292 {
1293 dst_to_src_offset = dst.visrect.bottom - lines - startscan;
1294 if (dst_to_src_offset < 0)
1295 {
1296 dst_to_src_offset = 0;
1297 lines = dst.visrect.bottom - startscan;
1298 }
1299 if (lines < dst.visrect.bottom) dst.visrect.bottom = lines;
1300 }
1301
1302 offset_rect( &dst.visrect, 0, dst_to_src_offset );
1303 empty_rect = !intersect_rect( &src.visrect, &src.visrect, &dst.visrect );
1304 dst.visrect = src.visrect;
1305 offset_rect( &dst.visrect, 0, -dst_to_src_offset );
1306
1307 if (dst_info->bmiHeader.biHeight > 0)
1308 {
1309 if (dst.visrect.bottom < dst_info->bmiHeader.biHeight)
1310 {
1311 int pad_lines = min( dst_info->bmiHeader.biHeight - dst.visrect.bottom, lines );
1312 int pad_bytes = pad_lines * get_dib_stride( dst_info->bmiHeader.biWidth, dst_info->bmiHeader.biBitCount );
1313 memset( bits, 0, pad_bytes );
1314 bits = (char *)bits + pad_bytes;
1315 }
1316 }
1317 else
1318 {
1319 if (dst.visrect.bottom < lines)
1320 {
1321 int pad_lines = lines - dst.visrect.bottom;
1322 int stride = get_dib_stride( dst_info->bmiHeader.biWidth, dst_info->bmiHeader.biBitCount );
1323 int pad_bytes = pad_lines * stride;
1324 memset( (char *)bits + dst.visrect.bottom * stride, 0, pad_bytes );
1325 }
1326 }
1327
1328 if (empty_rect) bits = NULL;
1329
1330 src.x = src.visrect.left;
1331 src.y = src.visrect.top;
1332 src.width = src.visrect.right - src.visrect.left;
1333 src.height = src.visrect.bottom - src.visrect.top;
1334
1335 lines = src.height;
1336 }
1337
1338 err = get_image_from_bitmap( bmp, src_info, bits ? &src_bits : NULL, bits ? &src : NULL );
1339
1340 if (err) goto done;
1341
1342 /* fill out the src colour table, if it needs one */
1343 if (src_info->bmiHeader.biBitCount <= 8 && src_info->bmiHeader.biClrUsed == 0)
1344 fill_default_color_table( src_info );
1345
1346 /* if the src and dst are the same depth, copy the colour info across */
1347 if (dst_info->bmiHeader.biBitCount == src_info->bmiHeader.biBitCount && coloruse == DIB_RGB_COLORS )
1348 {
1349 switch (src_info->bmiHeader.biBitCount)
1350 {
1351 case 16:
1352 if (src_info->bmiHeader.biCompression == BI_RGB)
1353 {
1354 src_info->bmiHeader.biCompression = BI_BITFIELDS;
1355 memcpy( src_info->bmiColors, bit_fields_555, sizeof(bit_fields_555) );
1356 }
1357 break;
1358 case 32:
1359 if (src_info->bmiHeader.biCompression == BI_RGB)
1360 {
1361 src_info->bmiHeader.biCompression = BI_BITFIELDS;
1362 memcpy( src_info->bmiColors, bit_fields_888, sizeof(bit_fields_888) );
1363 }
1364 break;
1365 }
1366 src_info->bmiHeader.biSizeImage = get_dib_image_size( dst_info );
1367 copy_color_info( dst_info, src_info, coloruse );
1368 }
1369 else if (dst_info->bmiHeader.biBitCount <= 8) /* otherwise construct a default colour table for the dst, if needed */
1370 {
1371 if( coloruse == DIB_PAL_COLORS )
1372 {
1373 if (!fill_color_table_from_palette( dst_info, hdc )) goto done;
1374 }
1375 else
1376 {
1377 fill_default_color_table( dst_info );
1378 }
1379 }
1380
1381 if (bits)
1382 {
1383 if(dst_info->bmiHeader.biHeight > 0)
1384 dst_info->bmiHeader.biHeight = src.height;
1385 else
1386 dst_info->bmiHeader.biHeight = -src.height;
1387
1388 convert_bitmapinfo( src_info, src_bits.ptr, &src, dst_info, bits, FALSE );
1389 if (src_bits.free) src_bits.free( &src_bits );
1390 ret = lines;
1391 }
1392 else
1393 ret = empty_rect ? FALSE : TRUE;
1394
1395 if (coloruse == DIB_PAL_COLORS)
1396 {
1397 WORD *index = (WORD *)dst_info->bmiColors;
1398 for (i = 0; i < dst_info->bmiHeader.biClrUsed; i++, index++)
1399 *index = i;
1400 }
1401
1402 copy_color_info( info, dst_info, coloruse );
1403 if (info->bmiHeader.biSize != sizeof(BITMAPCOREHEADER)) info->bmiHeader.biClrUsed = 0;
1404
1405 done:
1406 release_dc_ptr( dc );
1407 GDI_ReleaseObj( hbitmap );
1408 return ret;
1409 }
1410
1411
1412 /***********************************************************************
1413 * CreateDIBitmap (GDI32.@)
1414 *
1415 * Creates a DDB (device dependent bitmap) from a DIB.
1416 * The DDB will have the same color depth as the reference DC.
1417 */
1418 HBITMAP WINAPI CreateDIBitmap( HDC hdc, const BITMAPINFOHEADER *header,
1419 DWORD init, LPCVOID bits, const BITMAPINFO *data,
1420 UINT coloruse )
1421 {
1422 BITMAPINFOHEADER info;
1423 HBITMAP handle;
1424 LONG height;
1425
1426 if (!bitmapinfoheader_from_user_bitmapinfo( &info, header )) return 0;
1427 if (info.biCompression == BI_JPEG || info.biCompression == BI_PNG) return 0;
1428 if (coloruse > DIB_PAL_COLORS + 1) return 0;
1429 if (info.biWidth < 0) return 0;
1430
1431 /* Top-down DIBs have a negative height */
1432 height = abs( info.biHeight );
1433
1434 TRACE("hdc=%p, header=%p, init=%u, bits=%p, data=%p, coloruse=%u (bitmap: width=%d, height=%d, bpp=%u, compr=%u)\n",
1435 hdc, header, init, bits, data, coloruse, info.biWidth, info.biHeight,
1436 info.biBitCount, info.biCompression);
1437
1438 if (hdc == NULL)
1439 handle = CreateBitmap( info.biWidth, height, 1, 1, NULL );
1440 else
1441 handle = CreateCompatibleBitmap( hdc, info.biWidth, height );
1442
1443 if (handle)
1444 {
1445 if (init & CBM_INIT)
1446 {
1447 if (SetDIBits( hdc, handle, 0, height, bits, data, coloruse ) == 0)
1448 {
1449 DeleteObject( handle );
1450 handle = 0;
1451 }
1452 }
1453 }
1454
1455 return handle;
1456 }
1457
1458
1459 /***********************************************************************
1460 * CreateDIBSection (GDI32.@)
1461 */
1462 HBITMAP WINAPI CreateDIBSection(HDC hdc, CONST BITMAPINFO *bmi, UINT usage,
1463 VOID **bits, HANDLE section, DWORD offset)
1464 {
1465 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1466 BITMAPINFO *info = (BITMAPINFO *)buffer;
1467 HBITMAP ret = 0;
1468 BITMAPOBJ *bmp;
1469 void *mapBits = NULL;
1470
1471 if (bits) *bits = NULL;
1472 if (!bitmapinfo_from_user_bitmapinfo( info, bmi, usage, FALSE )) return 0;
1473 if (usage > DIB_PAL_COLORS) return 0;
1474 if (info->bmiHeader.biPlanes != 1)
1475 {
1476 if (info->bmiHeader.biPlanes * info->bmiHeader.biBitCount > 16) return 0;
1477 WARN( "%u planes not properly supported\n", info->bmiHeader.biPlanes );
1478 }
1479
1480 if (!(bmp = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*bmp) ))) return 0;
1481
1482 TRACE("format (%d,%d), planes %d, bpp %d, %s, size %d %s\n",
1483 info->bmiHeader.biWidth, info->bmiHeader.biHeight,
1484 info->bmiHeader.biPlanes, info->bmiHeader.biBitCount,
1485 info->bmiHeader.biCompression == BI_BITFIELDS? "BI_BITFIELDS" : "BI_RGB",
1486 info->bmiHeader.biSizeImage, usage == DIB_PAL_COLORS? "PAL" : "RGB");
1487
1488 bmp->dib.dsBm.bmType = 0;
1489 bmp->dib.dsBm.bmWidth = info->bmiHeader.biWidth;
1490 bmp->dib.dsBm.bmHeight = abs( info->bmiHeader.biHeight );
1491 bmp->dib.dsBm.bmWidthBytes = get_dib_stride( info->bmiHeader.biWidth, info->bmiHeader.biBitCount );
1492 bmp->dib.dsBm.bmPlanes = info->bmiHeader.biPlanes;
1493 bmp->dib.dsBm.bmBitsPixel = info->bmiHeader.biBitCount;
1494 bmp->dib.dsBmih = info->bmiHeader;
1495
1496 if (info->bmiHeader.biBitCount <= 8) /* build the color table */
1497 {
1498 if (usage == DIB_PAL_COLORS && !fill_color_table_from_pal_colors( info, hdc ))
1499 goto error;
1500 bmp->dib.dsBmih.biClrUsed = info->bmiHeader.biClrUsed;
1501 if (!(bmp->color_table = HeapAlloc( GetProcessHeap(), 0,
1502 bmp->dib.dsBmih.biClrUsed * sizeof(RGBQUAD) )))
1503 goto error;
1504 memcpy( bmp->color_table, info->bmiColors, bmp->dib.dsBmih.biClrUsed * sizeof(RGBQUAD) );
1505 }
1506
1507 /* set dsBitfields values */
1508 if (info->bmiHeader.biBitCount == 16 && info->bmiHeader.biCompression == BI_RGB)
1509 {
1510 bmp->dib.dsBmih.biCompression = BI_BITFIELDS;
1511 bmp->dib.dsBitfields[0] = 0x7c00;
1512 bmp->dib.dsBitfields[1] = 0x03e0;
1513 bmp->dib.dsBitfields[2] = 0x001f;
1514 }
1515 else if (info->bmiHeader.biCompression == BI_BITFIELDS)
1516 {
1517 if (usage == DIB_PAL_COLORS) goto error;
1518 bmp->dib.dsBitfields[0] = *(const DWORD *)info->bmiColors;
1519 bmp->dib.dsBitfields[1] = *((const DWORD *)info->bmiColors + 1);
1520 bmp->dib.dsBitfields[2] = *((const DWORD *)info->bmiColors + 2);
1521 if (!bmp->dib.dsBitfields[0] || !bmp->dib.dsBitfields[1] || !bmp->dib.dsBitfields[2]) goto error;
1522 }
1523 else bmp->dib.dsBitfields[0] = bmp->dib.dsBitfields[1] = bmp->dib.dsBitfields[2] = 0;
1524
1525 /* get storage location for DIB bits */
1526
1527 if (section)
1528 {
1529 SYSTEM_INFO SystemInfo;
1530 DWORD mapOffset;
1531 INT mapSize;
1532
1533 GetSystemInfo( &SystemInfo );
1534 mapOffset = offset - (offset % SystemInfo.dwAllocationGranularity);
1535 mapSize = bmp->dib.dsBmih.biSizeImage + (offset - mapOffset);
1536 mapBits = MapViewOfFile( section, FILE_MAP_ALL_ACCESS, 0, mapOffset, mapSize );
1537 if (mapBits) bmp->dib.dsBm.bmBits = (char *)mapBits + (offset - mapOffset);
1538 }
1539 else
1540 {
1541 offset = 0;
1542 bmp->dib.dsBm.bmBits = VirtualAlloc( NULL, bmp->dib.dsBmih.biSizeImage,
1543 MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE );
1544 }
1545 bmp->dib.dshSection = section;
1546 bmp->dib.dsOffset = offset;
1547
1548 if (!bmp->dib.dsBm.bmBits) goto error;
1549
1550 if (!(ret = alloc_gdi_handle( &bmp->header, OBJ_BITMAP, &dib_funcs ))) goto error;
1551
1552 if (bits) *bits = bmp->dib.dsBm.bmBits;
1553 return ret;
1554
1555 error:
1556 if (section) UnmapViewOfFile( mapBits );
1557 else VirtualFree( bmp->dib.dsBm.bmBits, 0, MEM_RELEASE );
1558 HeapFree( GetProcessHeap(), 0, bmp->color_table );
1559 HeapFree( GetProcessHeap(), 0, bmp );
1560 return 0;
1561 }
1562
1563
1564 /***********************************************************************
1565 * DIB_SelectObject
1566 */
1567 static HGDIOBJ DIB_SelectObject( HGDIOBJ handle, HDC hdc )
1568 {
1569 HGDIOBJ ret;
1570 BITMAPOBJ *bitmap;
1571 DC *dc;
1572 PHYSDEV physdev;
1573
1574 if (!(dc = get_dc_ptr( hdc ))) return 0;
1575
1576 if (GetObjectType( hdc ) != OBJ_MEMDC)
1577 {
1578 ret = 0;
1579 goto done;
1580 }
1581 ret = dc->hBitmap;
1582 if (handle == dc->hBitmap) goto done; /* nothing to do */
1583
1584 if (!(bitmap = GDI_GetObjPtr( handle, OBJ_BITMAP )))
1585 {
1586 ret = 0;
1587 goto done;
1588 }
1589
1590 if (bitmap->header.selcount)
1591 {
1592 WARN( "Bitmap already selected in another DC\n" );
1593 GDI_ReleaseObj( handle );
1594 ret = 0;
1595 goto done;
1596 }
1597
1598 physdev = GET_DC_PHYSDEV( dc, pSelectBitmap );
1599 if (!physdev->funcs->pSelectBitmap( physdev, handle ))
1600 {
1601 GDI_ReleaseObj( handle );
1602 ret = 0;
1603 }
1604 else
1605 {
1606 dc->hBitmap = handle;
1607 GDI_inc_ref_count( handle );
1608 dc->dirty = 0;
1609 dc->vis_rect.left = 0;
1610 dc->vis_rect.top = 0;
1611 dc->vis_rect.right = bitmap->dib.dsBm.bmWidth;
1612 dc->vis_rect.bottom = bitmap->dib.dsBm.bmHeight;
1613 dc->device_rect = dc->vis_rect;
1614 GDI_ReleaseObj( handle );
1615 DC_InitDC( dc );
1616 GDI_dec_ref_count( ret );
1617 }
1618
1619 done:
1620 release_dc_ptr( dc );
1621 return ret;
1622 }
1623
1624
1625 /***********************************************************************
1626 * DIB_GetObject
1627 */
1628 static INT DIB_GetObject( HGDIOBJ handle, INT count, LPVOID buffer )
1629 {
1630 INT ret = 0;
1631 BITMAPOBJ *bmp = GDI_GetObjPtr( handle, OBJ_BITMAP );
1632
1633 if (!bmp) return 0;
1634
1635 if (!buffer) ret = sizeof(BITMAP);
1636 else if (count >= sizeof(DIBSECTION))
1637 {
1638 DIBSECTION *dib = buffer;
1639 *dib = bmp->dib;
1640 dib->dsBmih.biHeight = abs( dib->dsBmih.biHeight );
1641 ret = sizeof(DIBSECTION);
1642 }
1643 else if (count >= sizeof(BITMAP))
1644 {
1645 BITMAP *bitmap = buffer;
1646 *bitmap = bmp->dib.dsBm;
1647 ret = sizeof(BITMAP);
1648 }
1649
1650 GDI_ReleaseObj( handle );
1651 return ret;
1652 }
1653
1654
1655 /***********************************************************************
1656 * DIB_DeleteObject
1657 */
1658 static BOOL DIB_DeleteObject( HGDIOBJ handle )
1659 {
1660 BITMAPOBJ *bmp;
1661
1662 if (!(bmp = free_gdi_handle( handle ))) return FALSE;
1663
1664 if (bmp->dib.dshSection)
1665 {
1666 SYSTEM_INFO SystemInfo;
1667 GetSystemInfo( &SystemInfo );
1668 UnmapViewOfFile( (char *)bmp->dib.dsBm.bmBits -
1669 (bmp->dib.dsOffset % SystemInfo.dwAllocationGranularity) );
1670 }
1671 else VirtualFree( bmp->dib.dsBm.bmBits, 0, MEM_RELEASE );
1672
1673 HeapFree(GetProcessHeap(), 0, bmp->color_table);
1674 return HeapFree( GetProcessHeap(), 0, bmp );
1675 }
Windows API implementation