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