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