?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Avoid null pointer dereference in CreateDIBSection.
[wine/gsoc_dplay.git] / dlls / gdi32 / dib.c
blobffd6f3131f7fccaed700c0a05a2e7468689eb79d
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 static 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 = (BITMAPOBJ *)GDI_GetObjPtr( hBitmap, BITMAP_MAGIC )))
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 (!(dc = get_dc_ptr( hdc )))
340 {
341 if (coloruse == DIB_RGB_COLORS) FIXME( "shouldn't require a DC for DIB_RGB_COLORS\n" );
342 return 0;
343 }
344
345 update_dc( dc );
346
347 if (!(bitmap = GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
348 {
349 release_dc_ptr( dc );
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 return result;
369 }
370
371
372 /***********************************************************************
373 * SetDIBitsToDevice (GDI32.@)
374 */
375 INT WINAPI SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx,
376 DWORD cy, INT xSrc, INT ySrc, UINT startscan,
377 UINT lines, LPCVOID bits, const BITMAPINFO *info,
378 UINT coloruse )
379 {
380 INT ret;
381 DC *dc;
382
383 if (!bits) return 0;
384
385 if (!(dc = get_dc_ptr( hdc ))) return 0;
386
387 if(dc->funcs->pSetDIBitsToDevice)
388 {
389 update_dc( dc );
390 ret = dc->funcs->pSetDIBitsToDevice( dc->physDev, xDest, yDest, cx, cy, xSrc,
391 ySrc, startscan, lines, bits,
392 info, coloruse );
393 }
394 else {
395 FIXME("unimplemented on hdc %p\n", hdc);
396 ret = 0;
397 }
398
399 release_dc_ptr( dc );
400 return ret;
401 }
402
403 /***********************************************************************
404 * SetDIBColorTable (GDI32.@)
405 */
406 UINT WINAPI SetDIBColorTable( HDC hdc, UINT startpos, UINT entries, CONST RGBQUAD *colors )
407 {
408 DC * dc;
409 UINT result = 0;
410 BITMAPOBJ * bitmap;
411
412 if (!(dc = get_dc_ptr( hdc ))) return 0;
413
414 if ((bitmap = GDI_GetObjPtr( dc->hBitmap, BITMAP_MAGIC )))
415 {
416 /* Check if currently selected bitmap is a DIB */
417 if (bitmap->color_table)
418 {
419 if (startpos < bitmap->nb_colors)
420 {
421 if (startpos + entries > bitmap->nb_colors) entries = bitmap->nb_colors - startpos;
422 memcpy(bitmap->color_table + startpos, colors, entries * sizeof(RGBQUAD));
423 result = entries;
424 }
425 }
426 GDI_ReleaseObj( dc->hBitmap );
427 }
428
429 if (dc->funcs->pSetDIBColorTable)
430 dc->funcs->pSetDIBColorTable(dc->physDev, startpos, entries, colors);
431
432 release_dc_ptr( dc );
433 return result;
434 }
435
436
437 /***********************************************************************
438 * GetDIBColorTable (GDI32.@)
439 */
440 UINT WINAPI GetDIBColorTable( HDC hdc, UINT startpos, UINT entries, RGBQUAD *colors )
441 {
442 DC * dc;
443 UINT result = 0;
444
445 if (!(dc = get_dc_ptr( hdc ))) return 0;
446
447 if (dc->funcs->pGetDIBColorTable)
448 result = dc->funcs->pGetDIBColorTable(dc->physDev, startpos, entries, colors);
449 else
450 {
451 BITMAPOBJ *bitmap = GDI_GetObjPtr( dc->hBitmap, BITMAP_MAGIC );
452 if (bitmap)
453 {
454 /* Check if currently selected bitmap is a DIB */
455 if (bitmap->color_table)
456 {
457 if (startpos < bitmap->nb_colors)
458 {
459 if (startpos + entries > bitmap->nb_colors) entries = bitmap->nb_colors - startpos;
460 memcpy(colors, bitmap->color_table + startpos, entries * sizeof(RGBQUAD));
461 result = entries;
462 }
463 }
464 GDI_ReleaseObj( dc->hBitmap );
465 }
466 }
467 release_dc_ptr( dc );
468 return result;
469 }
470
471 /* FIXME the following two structs should be combined with __sysPalTemplate in
472 objects/color.c - this should happen after de-X11-ing both of these
473 files.
474 NB. RGBQUAD and PALETTEENTRY have different orderings of red, green
475 and blue - sigh */
476
477 static const RGBQUAD EGAColorsQuads[16] = {
478 /* rgbBlue, rgbGreen, rgbRed, rgbReserved */
479 { 0x00, 0x00, 0x00, 0x00 },
480 { 0x00, 0x00, 0x80, 0x00 },
481 { 0x00, 0x80, 0x00, 0x00 },
482 { 0x00, 0x80, 0x80, 0x00 },
483 { 0x80, 0x00, 0x00, 0x00 },
484 { 0x80, 0x00, 0x80, 0x00 },
485 { 0x80, 0x80, 0x00, 0x00 },
486 { 0x80, 0x80, 0x80, 0x00 },
487 { 0xc0, 0xc0, 0xc0, 0x00 },
488 { 0x00, 0x00, 0xff, 0x00 },
489 { 0x00, 0xff, 0x00, 0x00 },
490 { 0x00, 0xff, 0xff, 0x00 },
491 { 0xff, 0x00, 0x00, 0x00 },
492 { 0xff, 0x00, 0xff, 0x00 },
493 { 0xff, 0xff, 0x00, 0x00 },
494 { 0xff, 0xff, 0xff, 0x00 }
495 };
496
497 static const RGBTRIPLE EGAColorsTriples[16] = {
498 /* rgbBlue, rgbGreen, rgbRed */
499 { 0x00, 0x00, 0x00 },
500 { 0x00, 0x00, 0x80 },
501 { 0x00, 0x80, 0x00 },
502 { 0x00, 0x80, 0x80 },
503 { 0x80, 0x00, 0x00 },
504 { 0x80, 0x00, 0x80 },
505 { 0x80, 0x80, 0x00 },
506 { 0x80, 0x80, 0x80 },
507 { 0xc0, 0xc0, 0xc0 },
508 { 0x00, 0x00, 0xff },
509 { 0x00, 0xff, 0x00 },
510 { 0x00, 0xff, 0xff },
511 { 0xff, 0x00, 0x00 } ,
512 { 0xff, 0x00, 0xff },
513 { 0xff, 0xff, 0x00 },
514 { 0xff, 0xff, 0xff }
515 };
516
517 static const RGBQUAD DefLogPaletteQuads[20] = { /* Copy of Default Logical Palette */
518 /* rgbBlue, rgbGreen, rgbRed, rgbReserved */
519 { 0x00, 0x00, 0x00, 0x00 },
520 { 0x00, 0x00, 0x80, 0x00 },
521 { 0x00, 0x80, 0x00, 0x00 },
522 { 0x00, 0x80, 0x80, 0x00 },
523 { 0x80, 0x00, 0x00, 0x00 },
524 { 0x80, 0x00, 0x80, 0x00 },
525 { 0x80, 0x80, 0x00, 0x00 },
526 { 0xc0, 0xc0, 0xc0, 0x00 },
527 { 0xc0, 0xdc, 0xc0, 0x00 },
528 { 0xf0, 0xca, 0xa6, 0x00 },
529 { 0xf0, 0xfb, 0xff, 0x00 },
530 { 0xa4, 0xa0, 0xa0, 0x00 },
531 { 0x80, 0x80, 0x80, 0x00 },
532 { 0x00, 0x00, 0xf0, 0x00 },
533 { 0x00, 0xff, 0x00, 0x00 },
534 { 0x00, 0xff, 0xff, 0x00 },
535 { 0xff, 0x00, 0x00, 0x00 },
536 { 0xff, 0x00, 0xff, 0x00 },
537 { 0xff, 0xff, 0x00, 0x00 },
538 { 0xff, 0xff, 0xff, 0x00 }
539 };
540
541 static const RGBTRIPLE DefLogPaletteTriples[20] = { /* Copy of Default Logical Palette */
542 /* rgbBlue, rgbGreen, rgbRed */
543 { 0x00, 0x00, 0x00 },
544 { 0x00, 0x00, 0x80 },
545 { 0x00, 0x80, 0x00 },
546 { 0x00, 0x80, 0x80 },
547 { 0x80, 0x00, 0x00 },
548 { 0x80, 0x00, 0x80 },
549 { 0x80, 0x80, 0x00 },
550 { 0xc0, 0xc0, 0xc0 },
551 { 0xc0, 0xdc, 0xc0 },
552 { 0xf0, 0xca, 0xa6 },
553 { 0xf0, 0xfb, 0xff },
554 { 0xa4, 0xa0, 0xa0 },
555 { 0x80, 0x80, 0x80 },
556 { 0x00, 0x00, 0xf0 },
557 { 0x00, 0xff, 0x00 },
558 { 0x00, 0xff, 0xff },
559 { 0xff, 0x00, 0x00 },
560 { 0xff, 0x00, 0xff },
561 { 0xff, 0xff, 0x00 },
562 { 0xff, 0xff, 0xff}
563 };
564
565
566 /******************************************************************************
567 * GetDIBits [GDI32.@]
568 *
569 * Retrieves bits of bitmap and copies to buffer.
570 *
571 * RETURNS
572 * Success: Number of scan lines copied from bitmap
573 * Failure: 0
574 */
575 INT WINAPI GetDIBits(
576 HDC hdc, /* [in] Handle to device context */
577 HBITMAP hbitmap, /* [in] Handle to bitmap */
578 UINT startscan, /* [in] First scan line to set in dest bitmap */
579 UINT lines, /* [in] Number of scan lines to copy */
580 LPVOID bits, /* [out] Address of array for bitmap bits */
581 BITMAPINFO * info, /* [out] Address of structure with bitmap data */
582 UINT coloruse) /* [in] RGB or palette index */
583 {
584 DC * dc;
585 BITMAPOBJ * bmp;
586 int i;
587 int bitmap_type;
588 BOOL core_header;
589 LONG width;
590 LONG height;
591 WORD planes, bpp;
592 DWORD compr, size;
593 void* colorPtr;
594 RGBTRIPLE* rgbTriples;
595 RGBQUAD* rgbQuads;
596
597 if (!info) return 0;
598
599 bitmap_type = DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &planes, &bpp, &compr, &size);
600 if (bitmap_type == -1)
601 {
602 ERR("Invalid bitmap format\n");
603 return 0;
604 }
605 core_header = (bitmap_type == 0);
606 if (!(dc = get_dc_ptr( hdc )))
607 {
608 SetLastError( ERROR_INVALID_PARAMETER );
609 return 0;
610 }
611 update_dc( dc );
612 if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
613 {
614 release_dc_ptr( dc );
615 return 0;
616 }
617
618 colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
619 rgbTriples = (RGBTRIPLE *) colorPtr;
620 rgbQuads = (RGBQUAD *) colorPtr;
621
622 /* Transfer color info */
623
624 switch (bpp)
625 {
626 case 0: /* query bitmap info only */
627 if (core_header)
628 {
629 BITMAPCOREHEADER* coreheader = (BITMAPCOREHEADER*) info;
630 coreheader->bcWidth = bmp->bitmap.bmWidth;
631 coreheader->bcHeight = bmp->bitmap.bmHeight;
632 coreheader->bcPlanes = 1;
633 coreheader->bcBitCount = bmp->bitmap.bmBitsPixel;
634 }
635 else
636 {
637 info->bmiHeader.biWidth = bmp->bitmap.bmWidth;
638 info->bmiHeader.biHeight = bmp->bitmap.bmHeight;
639 info->bmiHeader.biPlanes = 1;
640 info->bmiHeader.biSizeImage =
641 DIB_GetDIBImageBytes( bmp->bitmap.bmWidth,
642 bmp->bitmap.bmHeight,
643 bmp->bitmap.bmBitsPixel );
644 info->bmiHeader.biCompression = (bmp->bitmap.bmBitsPixel > 8) ? BI_BITFIELDS : BI_RGB;
645 switch(bmp->bitmap.bmBitsPixel)
646 {
647 case 15:
648 info->bmiHeader.biBitCount = 16;
649 break;
650 case 24:
651 info->bmiHeader.biBitCount = 32;
652 break;
653 default:
654 info->bmiHeader.biBitCount = bmp->bitmap.bmBitsPixel;
655 break;
656 }
657 info->bmiHeader.biXPelsPerMeter = 0;
658 info->bmiHeader.biYPelsPerMeter = 0;
659 info->bmiHeader.biClrUsed = 0;
660 info->bmiHeader.biClrImportant = 0;
661
662 /* Windows 2000 doesn't touch the additional struct members if
663 it's a BITMAPV4HEADER or a BITMAPV5HEADER */
664 }
665 lines = abs(bmp->bitmap.bmHeight);
666 goto done;
667
668 case 1:
669 case 4:
670 case 8:
671 if (!core_header) info->bmiHeader.biClrUsed = 0;
672
673 /* If the bitmap object already has a dib section at the
674 same color depth then get the color map from it */
675 if (bmp->dib && bmp->dib->dsBm.bmBitsPixel == bpp) {
676 if(coloruse == DIB_RGB_COLORS) {
677 unsigned int colors = min( bmp->nb_colors, 1 << bpp );
678
679 if (core_header)
680 {
681 /* Convert the color table (RGBQUAD to RGBTRIPLE) */
682 RGBTRIPLE* index = rgbTriples;
683
684 for (i=0; i < colors; i++, index++)
685 {
686 index->rgbtRed = bmp->color_table[i].rgbRed;
687 index->rgbtGreen = bmp->color_table[i].rgbGreen;
688 index->rgbtBlue = bmp->color_table[i].rgbBlue;
689 }
690 }
691 else
692 {
693 if (colors != 1 << bpp) info->bmiHeader.biClrUsed = colors;
694 memcpy(colorPtr, bmp->color_table, colors * sizeof(RGBQUAD));
695 }
696 }
697 else {
698 WORD *index = colorPtr;
699 for(i = 0; i < 1 << info->bmiHeader.biBitCount; i++, index++)
700 *index = i;
701 }
702 }
703 else {
704 if(bpp >= bmp->bitmap.bmBitsPixel) {
705 /* Generate the color map from the selected palette */
706 PALETTEENTRY palEntry[256];
707
708 memset( palEntry, 0, sizeof(palEntry) );
709 if (!GetPaletteEntries( dc->hPalette, 0, 1 << bmp->bitmap.bmBitsPixel, palEntry ))
710 {
711 release_dc_ptr( dc );
712 GDI_ReleaseObj( hbitmap );
713 return 0;
714 }
715 for (i = 0; i < (1 << bmp->bitmap.bmBitsPixel); i++) {
716 if (coloruse == DIB_RGB_COLORS) {
717 if (core_header)
718 {
719 rgbTriples[i].rgbtRed = palEntry[i].peRed;
720 rgbTriples[i].rgbtGreen = palEntry[i].peGreen;
721 rgbTriples[i].rgbtBlue = palEntry[i].peBlue;
722 }
723 else
724 {
725 rgbQuads[i].rgbRed = palEntry[i].peRed;
726 rgbQuads[i].rgbGreen = palEntry[i].peGreen;
727 rgbQuads[i].rgbBlue = palEntry[i].peBlue;
728 rgbQuads[i].rgbReserved = 0;
729 }
730 }
731 else ((WORD *)colorPtr)[i] = (WORD)i;
732 }
733 } else {
734 switch (bpp) {
735 case 1:
736 if (core_header)
737 {
738 rgbTriples[0].rgbtRed = rgbTriples[0].rgbtGreen =
739 rgbTriples[0].rgbtBlue = 0;
740 rgbTriples[1].rgbtRed = rgbTriples[1].rgbtGreen =
741 rgbTriples[1].rgbtBlue = 0xff;
742 }
743 else
744 {
745 rgbQuads[0].rgbRed = rgbQuads[0].rgbGreen =
746 rgbQuads[0].rgbBlue = 0;
747 rgbQuads[0].rgbReserved = 0;
748 rgbQuads[1].rgbRed = rgbQuads[1].rgbGreen =
749 rgbQuads[1].rgbBlue = 0xff;
750 rgbQuads[1].rgbReserved = 0;
751 }
752 break;
753
754 case 4:
755 if (core_header)
756 memcpy(colorPtr, EGAColorsTriples, sizeof(EGAColorsTriples));
757 else
758 memcpy(colorPtr, EGAColorsQuads, sizeof(EGAColorsQuads));
759
760 break;
761
762 case 8:
763 {
764 if (core_header)
765 {
766 INT r, g, b;
767 RGBTRIPLE *color;
768
769 memcpy(rgbTriples, DefLogPaletteTriples,
770 10 * sizeof(RGBTRIPLE));
771 memcpy(rgbTriples + 246, DefLogPaletteTriples + 10,
772 10 * sizeof(RGBTRIPLE));
773 color = rgbTriples + 10;
774 for(r = 0; r <= 5; r++) /* FIXME */
775 for(g = 0; g <= 5; g++)
776 for(b = 0; b <= 5; b++) {
777 color->rgbtRed = (r * 0xff) / 5;
778 color->rgbtGreen = (g * 0xff) / 5;
779 color->rgbtBlue = (b * 0xff) / 5;
780 color++;
781 }
782 }
783 else
784 {
785 INT r, g, b;
786 RGBQUAD *color;
787
788 memcpy(rgbQuads, DefLogPaletteQuads,
789 10 * sizeof(RGBQUAD));
790 memcpy(rgbQuads + 246, DefLogPaletteQuads + 10,
791 10 * sizeof(RGBQUAD));
792 color = rgbQuads + 10;
793 for(r = 0; r <= 5; r++) /* FIXME */
794 for(g = 0; g <= 5; g++)
795 for(b = 0; b <= 5; b++) {
796 color->rgbRed = (r * 0xff) / 5;
797 color->rgbGreen = (g * 0xff) / 5;
798 color->rgbBlue = (b * 0xff) / 5;
799 color->rgbReserved = 0;
800 color++;
801 }
802 }
803 }
804 }
805 }
806 }
807 break;
808
809 case 15:
810 if (info->bmiHeader.biCompression == BI_BITFIELDS)
811 {
812 ((PDWORD)info->bmiColors)[0] = 0x7c00;
813 ((PDWORD)info->bmiColors)[1] = 0x03e0;
814 ((PDWORD)info->bmiColors)[2] = 0x001f;
815 }
816 break;
817
818 case 16:
819 if (info->bmiHeader.biCompression == BI_BITFIELDS)
820 {
821 ((PDWORD)info->bmiColors)[0] = 0xf800;
822 ((PDWORD)info->bmiColors)[1] = 0x07e0;
823 ((PDWORD)info->bmiColors)[2] = 0x001f;
824 }
825 break;
826
827 case 24:
828 case 32:
829 if (info->bmiHeader.biCompression == BI_BITFIELDS)
830 {
831 ((PDWORD)info->bmiColors)[0] = 0xff0000;
832 ((PDWORD)info->bmiColors)[1] = 0x00ff00;
833 ((PDWORD)info->bmiColors)[2] = 0x0000ff;
834 }
835 break;
836 }
837
838 if (bits && lines)
839 {
840 /* If the bitmap object already have a dib section that contains image data, get the bits from it */
841 if(bmp->dib && bmp->dib->dsBm.bmBitsPixel >= 15 && bpp >= 15)
842 {
843 /*FIXME: Only RGB dibs supported for now */
844 unsigned int srcwidth = bmp->dib->dsBm.bmWidth, srcwidthb = bmp->dib->dsBm.bmWidthBytes;
845 unsigned int dstwidth = width;
846 int dstwidthb = DIB_GetDIBWidthBytes( width, bpp );
847 LPBYTE dbits = bits, sbits = (LPBYTE) bmp->dib->dsBm.bmBits + (startscan * srcwidthb);
848 unsigned int x, y, width, widthb;
849
850 if ((height < 0) ^ (bmp->dib->dsBmih.biHeight < 0))
851 {
852 dbits = (LPBYTE)bits + (dstwidthb * (lines-1));
853 dstwidthb = -dstwidthb;
854 }
855
856 switch( bpp ) {
857
858 case 15:
859 case 16: /* 16 bpp dstDIB */
860 {
861 LPWORD dstbits = (LPWORD)dbits;
862 WORD rmask = 0x7c00, gmask= 0x03e0, bmask = 0x001f;
863
864 /* FIXME: BI_BITFIELDS not supported yet */
865
866 switch(bmp->dib->dsBm.bmBitsPixel) {
867
868 case 16: /* 16 bpp srcDIB -> 16 bpp dstDIB */
869 {
870 widthb = min(srcwidthb, abs(dstwidthb));
871 /* FIXME: BI_BITFIELDS not supported yet */
872 for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb)
873 memcpy(dbits, sbits, widthb);
874 }
875 break;
876
877 case 24: /* 24 bpp srcDIB -> 16 bpp dstDIB */
878 {
879 LPBYTE srcbits = sbits;
880
881 width = min(srcwidth, dstwidth);
882 for( y = 0; y < lines; y++) {
883 for( x = 0; x < width; x++, srcbits += 3)
884 *dstbits++ = ((srcbits[0] >> 3) & bmask) |
885 (((WORD)srcbits[1] << 2) & gmask) |
886 (((WORD)srcbits[2] << 7) & rmask);
887
888 dstbits = (LPWORD)(dbits+=dstwidthb);
889 srcbits = (sbits += srcwidthb);
890 }
891 }
892 break;
893
894 case 32: /* 32 bpp srcDIB -> 16 bpp dstDIB */
895 {
896 LPDWORD srcbits = (LPDWORD)sbits;
897 DWORD val;
898
899 width = min(srcwidth, dstwidth);
900 for( y = 0; y < lines; y++) {
901 for( x = 0; x < width; x++ ) {
902 val = *srcbits++;
903 *dstbits++ = (WORD)(((val >> 3) & bmask) | ((val >> 6) & gmask) |
904 ((val >> 9) & rmask));
905 }
906 dstbits = (LPWORD)(dbits+=dstwidthb);
907 srcbits = (LPDWORD)(sbits+=srcwidthb);
908 }
909 }
910 break;
911
912 default: /* ? bit bmp -> 16 bit DIB */
913 FIXME("15/16 bit DIB %d bit bitmap\n",
914 bmp->bitmap.bmBitsPixel);
915 break;
916 }
917 }
918 break;
919
920 case 24: /* 24 bpp dstDIB */
921 {
922 LPBYTE dstbits = dbits;
923
924 switch(bmp->dib->dsBm.bmBitsPixel) {
925
926 case 16: /* 16 bpp srcDIB -> 24 bpp dstDIB */
927 {
928 LPWORD srcbits = (LPWORD)sbits;
929 WORD val;
930
931 width = min(srcwidth, dstwidth);
932 /* FIXME: BI_BITFIELDS not supported yet */
933 for( y = 0; y < lines; y++) {
934 for( x = 0; x < width; x++ ) {
935 val = *srcbits++;
936 *dstbits++ = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07));
937 *dstbits++ = (BYTE)(((val >> 2) & 0xf8) | ((val >> 7) & 0x07));
938 *dstbits++ = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));
939 }
940 dstbits = dbits+=dstwidthb;
941 srcbits = (LPWORD)(sbits+=srcwidthb);
942 }
943 }
944 break;
945
946 case 24: /* 24 bpp srcDIB -> 24 bpp dstDIB */
947 {
948 widthb = min(srcwidthb, abs(dstwidthb));
949 for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb)
950 memcpy(dbits, sbits, widthb);
951 }
952 break;
953
954 case 32: /* 32 bpp srcDIB -> 24 bpp dstDIB */
955 {
956 LPBYTE srcbits = sbits;
957
958 width = min(srcwidth, dstwidth);
959 for( y = 0; y < lines; y++) {
960 for( x = 0; x < width; x++, srcbits++ ) {
961 *dstbits++ = *srcbits++;
962 *dstbits++ = *srcbits++;
963 *dstbits++ = *srcbits++;
964 }
965 dstbits = dbits+=dstwidthb;
966 srcbits = sbits+=srcwidthb;
967 }
968 }
969 break;
970
971 default: /* ? bit bmp -> 24 bit DIB */
972 FIXME("24 bit DIB %d bit bitmap\n",
973 bmp->bitmap.bmBitsPixel);
974 break;
975 }
976 }
977 break;
978
979 case 32: /* 32 bpp dstDIB */
980 {
981 LPDWORD dstbits = (LPDWORD)dbits;
982
983 /* FIXME: BI_BITFIELDS not supported yet */
984
985 switch(bmp->dib->dsBm.bmBitsPixel) {
986 case 16: /* 16 bpp srcDIB -> 32 bpp dstDIB */
987 {
988 LPWORD srcbits = (LPWORD)sbits;
989 DWORD val;
990
991 width = min(srcwidth, dstwidth);
992 /* FIXME: BI_BITFIELDS not supported yet */
993 for( y = 0; y < lines; y++) {
994 for( x = 0; x < width; x++ ) {
995 val = (DWORD)*srcbits++;
996 *dstbits++ = ((val << 3) & 0xf8) | ((val >> 2) & 0x07) |
997 ((val << 6) & 0xf800) | ((val << 1) & 0x0700) |
998 ((val << 9) & 0xf80000) | ((val << 4) & 0x070000);
999 }
1000 dstbits=(LPDWORD)(dbits+=dstwidthb);
1001 srcbits=(LPWORD)(sbits+=srcwidthb);
1002 }
1003 }
1004 break;
1005
1006 case 24: /* 24 bpp srcDIB -> 32 bpp dstDIB */
1007 {
1008 LPBYTE srcbits = sbits;
1009
1010 width = min(srcwidth, dstwidth);
1011 for( y = 0; y < lines; y++) {
1012 for( x = 0; x < width; x++, srcbits+=3 )
1013 *dstbits++ = srcbits[0] |
1014 (srcbits[1] << 8) |
1015 (srcbits[2] << 16);
1016 dstbits=(LPDWORD)(dbits+=dstwidthb);
1017 srcbits=(sbits+=srcwidthb);
1018 }
1019 }
1020 break;
1021
1022 case 32: /* 32 bpp srcDIB -> 32 bpp dstDIB */
1023 {
1024 widthb = min(srcwidthb, abs(dstwidthb));
1025 /* FIXME: BI_BITFIELDS not supported yet */
1026 for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb) {
1027 memcpy(dbits, sbits, widthb);
1028 }
1029 }
1030 break;
1031
1032 default: /* ? bit bmp -> 32 bit DIB */
1033 FIXME("32 bit DIB %d bit bitmap\n",
1034 bmp->bitmap.bmBitsPixel);
1035 break;
1036 }
1037 }
1038 break;
1039
1040 default: /* ? bit DIB */
1041 FIXME("Unsupported DIB depth %d\n", info->bmiHeader.biBitCount);
1042 break;
1043 }
1044 }
1045 /* Otherwise, get bits from the XImage */
1046 else
1047 {
1048 if (!bmp->funcs && !BITMAP_SetOwnerDC( hbitmap, dc )) lines = 0;
1049 else
1050 {
1051 if (bmp->funcs && bmp->funcs->pGetDIBits)
1052 lines = bmp->funcs->pGetDIBits( dc->physDev, hbitmap, startscan,
1053 lines, bits, info, coloruse );
1054 else
1055 lines = 0; /* FIXME: should copy from bmp->bitmap.bmBits */
1056 }
1057 }
1058 }
1059 else lines = abs(height);
1060
1061 /* The knowledge base article Q81498 ("DIBs and Their Uses") states that
1062 if bits == NULL and bpp != 0, only biSizeImage and the color table are
1063 filled in. */
1064 if (!core_header)
1065 {
1066 /* FIXME: biSizeImage should be calculated according to the selected
1067 compression algorithm if biCompression != BI_RGB */
1068 info->bmiHeader.biSizeImage = DIB_GetDIBImageBytes( width, height, bpp );
1069 TRACE("biSizeImage = %d, ", info->bmiHeader.biSizeImage);
1070 }
1071 TRACE("biWidth = %d, biHeight = %d\n", width, height);
1072
1073 done:
1074 release_dc_ptr( dc );
1075 GDI_ReleaseObj( hbitmap );
1076 return lines;
1077 }
1078
1079
1080 /***********************************************************************
1081 * CreateDIBitmap (GDI32.@)
1082 *
1083 * Creates a DDB (device dependent bitmap) from a DIB.
1084 * The DDB will have the same color depth as the reference DC.
1085 */
1086 HBITMAP WINAPI CreateDIBitmap( HDC hdc, const BITMAPINFOHEADER *header,
1087 DWORD init, LPCVOID bits, const BITMAPINFO *data,
1088 UINT coloruse )
1089 {
1090 HBITMAP handle;
1091 LONG width;
1092 LONG height;
1093 WORD planes, bpp;
1094 DWORD compr, size;
1095 DC *dc;
1096
1097 if (DIB_GetBitmapInfo( header, &width, &height, &planes, &bpp, &compr, &size ) == -1) return 0;
1098
1099 if (width < 0)
1100 {
1101 TRACE("Bitmap has a negative width\n");
1102 return 0;
1103 }
1104
1105 /* Top-down DIBs have a negative height */
1106 if (height < 0) height = -height;
1107
1108 TRACE("hdc=%p, header=%p, init=%u, bits=%p, data=%p, coloruse=%u (bitmap: width=%d, height=%d, bpp=%u, compr=%u)\n",
1109 hdc, header, init, bits, data, coloruse, width, height, bpp, compr);
1110
1111 if (hdc == NULL)
1112 handle = CreateBitmap( width, height, 1, 1, NULL );
1113 else
1114 handle = CreateCompatibleBitmap( hdc, width, height );
1115
1116 if (handle)
1117 {
1118 if (init == CBM_INIT) SetDIBits( hdc, handle, 0, height, bits, data, coloruse );
1119
1120 else if (hdc && ((dc = get_dc_ptr( hdc )) != NULL) )
1121 {
1122 if (!BITMAP_SetOwnerDC( handle, dc ))
1123 {
1124 DeleteObject( handle );
1125 handle = 0;
1126 }
1127 release_dc_ptr( dc );
1128 }
1129 }
1130
1131 return handle;
1132 }
1133
1134 /***********************************************************************
1135 * CreateDIBSection (GDI.489)
1136 */
1137 HBITMAP16 WINAPI CreateDIBSection16 (HDC16 hdc, const BITMAPINFO *bmi, UINT16 usage,
1138 SEGPTR *bits16, HANDLE section, DWORD offset)
1139 {
1140 LPVOID bits32;
1141 HBITMAP hbitmap;
1142
1143 hbitmap = CreateDIBSection( HDC_32(hdc), bmi, usage, &bits32, section, offset );
1144 if (hbitmap)
1145 {
1146 BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(hbitmap, BITMAP_MAGIC);
1147 if (bmp && bmp->dib && bits32)
1148 {
1149 const BITMAPINFOHEADER *bi = &bmi->bmiHeader;
1150 LONG width, height;
1151 WORD planes, bpp;
1152 DWORD compr, size;
1153 INT width_bytes;
1154 WORD count, sel;
1155 int i;
1156
1157 DIB_GetBitmapInfo(bi, &width, &height, &planes, &bpp, &compr, &size);
1158
1159 height = height >= 0 ? height : -height;
1160 width_bytes = DIB_GetDIBWidthBytes(width, bpp);
1161
1162 if (!size || (compr != BI_RLE4 && compr != BI_RLE8)) size = width_bytes * height;
1163
1164 /* calculate number of sel's needed for size with 64K steps */
1165 count = (size + 0xffff) / 0x10000;
1166 sel = AllocSelectorArray16(count);
1167
1168 for (i = 0; i < count; i++)
1169 {
1170 SetSelectorBase(sel + (i << __AHSHIFT), (DWORD)bits32 + i * 0x10000);
1171 SetSelectorLimit16(sel + (i << __AHSHIFT), size - 1); /* yep, limit is correct */
1172 size -= 0x10000;
1173 }
1174 bmp->segptr_bits = MAKESEGPTR( sel, 0 );
1175 if (bits16) *bits16 = bmp->segptr_bits;
1176 }
1177 if (bmp) GDI_ReleaseObj( hbitmap );
1178 }
1179 return HBITMAP_16(hbitmap);
1180 }
1181
1182 /* Copy/synthesize RGB palette from BITMAPINFO. Ripped from dlls/winex11.drv/dib.c */
1183 static void DIB_CopyColorTable( DC *dc, BITMAPOBJ *bmp, WORD coloruse, const BITMAPINFO *info )
1184 {
1185 RGBQUAD *colorTable;
1186 unsigned int colors;
1187 int i;
1188 BOOL core_info = info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER);
1189
1190 if (core_info)
1191 {
1192 colors = 1 << ((const BITMAPCOREINFO*) info)->bmciHeader.bcBitCount;
1193 }
1194 else
1195 {
1196 colors = info->bmiHeader.biClrUsed;
1197 if (!colors) colors = 1 << info->bmiHeader.biBitCount;
1198 }
1199
1200 if (colors > 256) {
1201 ERR("called with >256 colors!\n");
1202 return;
1203 }
1204
1205 if (!(colorTable = HeapAlloc(GetProcessHeap(), 0, colors * sizeof(RGBQUAD) ))) return;
1206
1207 if(coloruse == DIB_RGB_COLORS)
1208 {
1209 if (core_info)
1210 {
1211 /* Convert RGBTRIPLEs to RGBQUADs */
1212 for (i=0; i < colors; i++)
1213 {
1214 colorTable[i].rgbRed = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtRed;
1215 colorTable[i].rgbGreen = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtGreen;
1216 colorTable[i].rgbBlue = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtBlue;
1217 colorTable[i].rgbReserved = 0;
1218 }
1219 }
1220 else
1221 {
1222 memcpy(colorTable, (const BYTE*) info + (WORD) info->bmiHeader.biSize, colors * sizeof(RGBQUAD));
1223 }
1224 }
1225 else
1226 {
1227 PALETTEENTRY entries[256];
1228 const WORD *index = (const WORD*) ((const BYTE*) info + (WORD) info->bmiHeader.biSize);
1229 UINT count = GetPaletteEntries( dc->hPalette, 0, colors, entries );
1230
1231 for (i = 0; i < colors; i++, index++)
1232 {
1233 PALETTEENTRY *entry = &entries[*index % count];
1234 colorTable[i].rgbRed = entry->peRed;
1235 colorTable[i].rgbGreen = entry->peGreen;
1236 colorTable[i].rgbBlue = entry->peBlue;
1237 colorTable[i].rgbReserved = 0;
1238 }
1239 }
1240 bmp->color_table = colorTable;
1241 bmp->nb_colors = colors;
1242 }
1243
1244 /***********************************************************************
1245 * CreateDIBSection (GDI32.@)
1246 */
1247 HBITMAP WINAPI CreateDIBSection(HDC hdc, CONST BITMAPINFO *bmi, UINT usage,
1248 VOID **bits, HANDLE section, DWORD offset)
1249 {
1250 HBITMAP ret = 0;
1251 DC *dc;
1252 BOOL bDesktopDC = FALSE;
1253 DIBSECTION *dib;
1254 BITMAPOBJ *bmp;
1255 int bitmap_type;
1256 LONG width, height;
1257 WORD planes, bpp;
1258 DWORD compression, sizeImage;
1259 void *mapBits = NULL;
1260
1261 if(!bmi){
1262 if(bits) *bits = NULL;
1263 return NULL;
1264 }
1265
1266 if (((bitmap_type = DIB_GetBitmapInfo( &bmi->bmiHeader, &width, &height,
1267 &planes, &bpp, &compression, &sizeImage )) == -1))
1268 return 0;
1269
1270 if (compression != BI_RGB && compression != BI_BITFIELDS)
1271 {
1272 TRACE("can't create a compressed (%u) dibsection\n", compression);
1273 return 0;
1274 }
1275
1276 if (!(dib = HeapAlloc( GetProcessHeap(), 0, sizeof(*dib) ))) return 0;
1277
1278 TRACE("format (%d,%d), planes %d, bpp %d, size %d, %s\n",
1279 width, height, planes, bpp, sizeImage, usage == DIB_PAL_COLORS? "PAL" : "RGB");
1280
1281 dib->dsBm.bmType = 0;
1282 dib->dsBm.bmWidth = width;
1283 dib->dsBm.bmHeight = height >= 0 ? height : -height;
1284 dib->dsBm.bmWidthBytes = DIB_GetDIBWidthBytes(width, bpp);
1285 dib->dsBm.bmPlanes = planes;
1286 dib->dsBm.bmBitsPixel = bpp;
1287 dib->dsBm.bmBits = NULL;
1288
1289 if (!bitmap_type) /* core header */
1290 {
1291 /* convert the BITMAPCOREHEADER to a BITMAPINFOHEADER */
1292 dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1293 dib->dsBmih.biWidth = width;
1294 dib->dsBmih.biHeight = height;
1295 dib->dsBmih.biPlanes = planes;
1296 dib->dsBmih.biBitCount = bpp;
1297 dib->dsBmih.biCompression = compression;
1298 dib->dsBmih.biXPelsPerMeter = 0;
1299 dib->dsBmih.biYPelsPerMeter = 0;
1300 dib->dsBmih.biClrUsed = 0;
1301 dib->dsBmih.biClrImportant = 0;
1302 }
1303 else
1304 {
1305 /* truncate extended bitmap headers (BITMAPV4HEADER etc.) */
1306 dib->dsBmih = bmi->bmiHeader;
1307 dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1308 }
1309
1310 /* set number of entries in bmi.bmiColors table */
1311 if( bpp <= 8 )
1312 dib->dsBmih.biClrUsed = 1 << bpp;
1313
1314 dib->dsBmih.biSizeImage = dib->dsBm.bmWidthBytes * dib->dsBm.bmHeight;
1315
1316 /* set dsBitfields values */
1317 if (usage == DIB_PAL_COLORS || bpp <= 8)
1318 {
1319 dib->dsBitfields[0] = dib->dsBitfields[1] = dib->dsBitfields[2] = 0;
1320 }
1321 else switch( bpp )
1322 {
1323 case 15:
1324 case 16:
1325 dib->dsBitfields[0] = (compression == BI_BITFIELDS) ? *(const DWORD *)bmi->bmiColors : 0x7c00;
1326 dib->dsBitfields[1] = (compression == BI_BITFIELDS) ? *((const DWORD *)bmi->bmiColors + 1) : 0x03e0;
1327 dib->dsBitfields[2] = (compression == BI_BITFIELDS) ? *((const DWORD *)bmi->bmiColors + 2) : 0x001f;
1328 break;
1329 case 24:
1330 case 32:
1331 dib->dsBitfields[0] = (compression == BI_BITFIELDS) ? *(const DWORD *)bmi->bmiColors : 0xff0000;
1332 dib->dsBitfields[1] = (compression == BI_BITFIELDS) ? *((const DWORD *)bmi->bmiColors + 1) : 0x00ff00;
1333 dib->dsBitfields[2] = (compression == BI_BITFIELDS) ? *((const DWORD *)bmi->bmiColors + 2) : 0x0000ff;
1334 break;
1335 }
1336
1337 /* get storage location for DIB bits */
1338
1339 if (section)
1340 {
1341 SYSTEM_INFO SystemInfo;
1342 DWORD mapOffset;
1343 INT mapSize;
1344
1345 GetSystemInfo( &SystemInfo );
1346 mapOffset = offset - (offset % SystemInfo.dwAllocationGranularity);
1347 mapSize = dib->dsBmih.biSizeImage + (offset - mapOffset);
1348 mapBits = MapViewOfFile( section, FILE_MAP_ALL_ACCESS, 0, mapOffset, mapSize );
1349 if (mapBits) dib->dsBm.bmBits = (char *)mapBits + (offset - mapOffset);
1350 }
1351 else
1352 {
1353 offset = 0;
1354 dib->dsBm.bmBits = VirtualAlloc( NULL, dib->dsBmih.biSizeImage,
1355 MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE );
1356 }
1357 dib->dshSection = section;
1358 dib->dsOffset = offset;
1359
1360 if (!dib->dsBm.bmBits)
1361 {
1362 HeapFree( GetProcessHeap(), 0, dib );
1363 return 0;
1364 }
1365
1366 /* If the reference hdc is null, take the desktop dc */
1367 if (hdc == 0)
1368 {
1369 hdc = CreateCompatibleDC(0);
1370 bDesktopDC = TRUE;
1371 }
1372
1373 if (!(dc = get_dc_ptr( hdc ))) goto error;
1374
1375 /* create Device Dependent Bitmap and add DIB pointer */
1376 ret = CreateBitmap( dib->dsBm.bmWidth, dib->dsBm.bmHeight, 1,
1377 (bpp == 1) ? 1 : GetDeviceCaps(hdc, BITSPIXEL), NULL );
1378
1379 if (ret && ((bmp = GDI_GetObjPtr(ret, BITMAP_MAGIC))))
1380 {
1381 bmp->dib = dib;
1382 bmp->funcs = dc->funcs;
1383 /* create local copy of DIB palette */
1384 if (bpp <= 8) DIB_CopyColorTable( dc, bmp, usage, bmi );
1385 GDI_ReleaseObj( ret );
1386
1387 if (dc->funcs->pCreateDIBSection)
1388 {
1389 if (!dc->funcs->pCreateDIBSection(dc->physDev, ret, bmi, usage))
1390 {
1391 DeleteObject( ret );
1392 ret = 0;
1393 }
1394 }
1395 }
1396
1397 release_dc_ptr( dc );
1398 if (bDesktopDC) DeleteDC( hdc );
1399 if (ret && bits) *bits = dib->dsBm.bmBits;
1400 return ret;
1401
1402 error:
1403 if (bDesktopDC) DeleteDC( hdc );
1404 if (section) UnmapViewOfFile( mapBits );
1405 else if (!offset) VirtualFree( dib->dsBm.bmBits, 0, MEM_RELEASE );
1406 HeapFree( GetProcessHeap(), 0, dib );
1407 return 0;
1408 }
DirectPlay implementation for GSoC