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