?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Don't hide GL function pointer typedefs behind extension defines.
[wine.git] / dlls / winex11.drv / dib.c
blob609e5c2d686af177b42b2b8ef4530b322b3e902c
1 /*
2 * X11DRV 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 #include "config.h"
22 #include "wine/port.h"
23
24 #include <X11/Xlib.h>
25 #ifdef HAVE_LIBXXSHM
26 #include <X11/extensions/XShm.h>
27 # ifdef HAVE_SYS_SHM_H
28 # include <sys/shm.h>
29 # endif
30 # ifdef HAVE_SYS_IPC_H
31 # include <sys/ipc.h>
32 # endif
33 #endif /* defined(HAVE_LIBXXSHM) */
34
35 #include <stdarg.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include "windef.h"
39 #include "winbase.h"
40 #include "wingdi.h"
41 #include "x11drv.h"
42 #include "wine/exception.h"
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
46
47 static struct list dibs_list = LIST_INIT(dibs_list);
48
49 static CRITICAL_SECTION dibs_cs;
50 static CRITICAL_SECTION_DEBUG dibs_cs_debug =
51 {
52 0, 0, &dibs_cs,
53 { &dibs_cs_debug.ProcessLocksList, &dibs_cs_debug.ProcessLocksList },
54 0, 0, { (DWORD_PTR)(__FILE__ ": dibs_cs") }
55 };
56 static CRITICAL_SECTION dibs_cs = { &dibs_cs_debug, -1, 0, 0, 0, 0 };
57
58 static PVOID dibs_handler;
59
60 static int ximageDepthTable[32];
61
62 /* This structure holds the arguments for DIB_SetImageBits() */
63 typedef struct
64 {
65 X11DRV_PDEVICE *physDev;
66 LPCVOID bits;
67 XImage *image;
68 PALETTEENTRY *palentry;
69 int lines;
70 DWORD infoWidth;
71 WORD depth;
72 WORD infoBpp;
73 WORD compression;
74 ColorShifts *shifts;
75 RGBQUAD *colorMap;
76 int nColorMap;
77 Drawable drawable;
78 GC gc;
79 int xSrc;
80 int ySrc;
81 int xDest;
82 int yDest;
83 int width;
84 int height;
85 DWORD rMask;
86 DWORD gMask;
87 DWORD bMask;
88 enum x11drv_shm_mode shm_mode;
89 int dibpitch;
90 DWORD sizeImage;
91 X_PHYSBITMAP *physBitmap;
92 } X11DRV_DIB_IMAGEBITS_DESCR;
93
94
95 enum Rle_EscapeCodes
96 {
97 RLE_EOL = 0, /* End of line */
98 RLE_END = 1, /* End of bitmap */
99 RLE_DELTA = 2 /* Delta */
100 };
101
102
103 static INT X11DRV_DIB_Coerce(X_PHYSBITMAP *,INT);
104
105 /*
106 Some of the following helper functions are duplicated in
107 dlls/gdi/dib.c
108 */
109
110 /***********************************************************************
111 * DIB_DoProtectDIBSection
112 */
113 static void X11DRV_DIB_DoProtectDIBSection( X_PHYSBITMAP *physBitmap, DWORD new_prot )
114 {
115 DWORD old_prot;
116
117 VirtualProtect(physBitmap->base, physBitmap->size, new_prot, &old_prot);
118 TRACE("Changed protection from %d to %d\n", old_prot, new_prot);
119 }
120
121 /***********************************************************************
122 * X11DRV_DIB_GetXImageWidthBytes
123 *
124 * Return the width of an X image in bytes
125 */
126 static inline int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
127 {
128 if (!depth || depth > 32) goto error;
129
130 if (!ximageDepthTable[depth-1])
131 {
132 XImage *testimage = XCreateImage( gdi_display, visual, depth,
133 ZPixmap, 0, NULL, 1, 1, 32, 20 );
134 if (testimage)
135 {
136 ximageDepthTable[depth-1] = testimage->bits_per_pixel;
137 XDestroyImage( testimage );
138 }
139 else ximageDepthTable[depth-1] = -1;
140 }
141 if (ximageDepthTable[depth-1] != -1)
142 return (4 * ((width * ximageDepthTable[depth-1] + 31) / 32));
143
144 error:
145 WARN( "(%d): Unsupported depth\n", depth );
146 return 4 * width;
147 }
148
149
150 /***********************************************************************
151 * X11DRV_DIB_GetDIBWidthBytes
152 *
153 * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned.
154 */
155 static int X11DRV_DIB_GetDIBWidthBytes( int width, int depth )
156 {
157 int words;
158
159 switch(depth)
160 {
161 case 1: words = (width + 31) / 32; break;
162 case 4: words = (width + 7) / 8; break;
163 case 8: words = (width + 3) / 4; break;
164 case 15:
165 case 16: words = (width + 1) / 2; break;
166 case 24: words = (width * 3 + 3) / 4; break;
167 default:
168 WARN("(%d): Unsupported depth\n", depth );
169 /* fall through */
170 case 32:
171 words = width;
172 }
173 return 4 * words;
174 }
175
176
177 /***********************************************************************
178 * bitmap_info_size
179 *
180 * Return the size of the bitmap info structure including color table.
181 */
182 int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
183 {
184 unsigned int colors, size, masks = 0;
185
186 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
187 {
188 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
189 colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
190 return sizeof(BITMAPCOREHEADER) + colors *
191 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
192 }
193 else /* assume BITMAPINFOHEADER */
194 {
195 colors = info->bmiHeader.biClrUsed;
196 if (!colors && (info->bmiHeader.biBitCount <= 8))
197 colors = 1 << info->bmiHeader.biBitCount;
198 if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
199 size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
200 return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
201 }
202 }
203
204
205 /***********************************************************************
206 * X11DRV_DIB_CreateXImage
207 *
208 * Create an X image.
209 */
210 XImage *X11DRV_DIB_CreateXImage( int width, int height, int depth )
211 {
212 int width_bytes;
213 XImage *image = NULL;
214 void *data;
215
216 wine_tsx11_lock();
217 width_bytes = X11DRV_DIB_GetXImageWidthBytes( width, depth );
218 data = HeapAlloc( GetProcessHeap(), 0, height * width_bytes );
219 if (data) image = XCreateImage( gdi_display, visual, depth, ZPixmap, 0,
220 data, width, height, 32, width_bytes );
221 if (!image) HeapFree( GetProcessHeap(), 0, data );
222 wine_tsx11_unlock();
223 return image;
224 }
225
226
227 /***********************************************************************
228 * X11DRV_DIB_DestroyXImage
229 *
230 * Destroy an X image created with X11DRV_DIB_CreateXImage.
231 */
232 void X11DRV_DIB_DestroyXImage( XImage *image )
233 {
234 HeapFree( GetProcessHeap(), 0, image->data );
235 image->data = NULL;
236 wine_tsx11_lock();
237 XDestroyImage( image );
238 wine_tsx11_unlock();
239 }
240
241
242 /***********************************************************************
243 * DIB_GetBitmapInfoEx
244 *
245 * Get the info from a bitmap header.
246 * Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
247 */
248 static int DIB_GetBitmapInfoEx( const BITMAPINFOHEADER *header, LONG *width,
249 LONG *height, WORD *planes, WORD *bpp,
250 WORD *compr, DWORD *size )
251 {
252 if (header->biSize == sizeof(BITMAPCOREHEADER))
253 {
254 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)header;
255 *width = core->bcWidth;
256 *height = core->bcHeight;
257 *planes = core->bcPlanes;
258 *bpp = core->bcBitCount;
259 *compr = 0;
260 *size = 0;
261 return 0;
262 }
263 if (header->biSize >= sizeof(BITMAPINFOHEADER))
264 {
265 *width = header->biWidth;
266 *height = header->biHeight;
267 *planes = header->biPlanes;
268 *bpp = header->biBitCount;
269 *compr = header->biCompression;
270 *size = header->biSizeImage;
271 return 1;
272 }
273 ERR("(%d): unknown/wrong size for header\n", header->biSize );
274 return -1;
275 }
276
277
278 /***********************************************************************
279 * X11DRV_DIB_GetColorCount
280 *
281 * Computes the number of colors for the bitmap palette.
282 * Should not be called for a >8-bit deep bitmap.
283 */
284 static unsigned int X11DRV_DIB_GetColorCount(const BITMAPINFO *info)
285 {
286 unsigned int colors;
287 BOOL core_info = info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER);
288
289 if (core_info)
290 {
291 colors = 1 << ((const BITMAPCOREINFO*)info)->bmciHeader.bcBitCount;
292 }
293 else
294 {
295 colors = info->bmiHeader.biClrUsed;
296 if (!colors) colors = 1 << info->bmiHeader.biBitCount;
297 }
298 if (colors > 256)
299 {
300 ERR("called with >256 colors!\n");
301 colors = 0;
302 }
303 return colors;
304 }
305
306 /***********************************************************************
307 * DIB_GetBitmapInfo
308 *
309 * Get the info from a bitmap header.
310 * Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
311 */
312 static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, LONG *width,
313 LONG *height, WORD *bpp, WORD *compr )
314 {
315 WORD planes;
316 DWORD size;
317
318 return DIB_GetBitmapInfoEx( header, width, height, &planes, bpp, compr, &size);
319 }
320
321
322 static inline BOOL colour_is_brighter(RGBQUAD c1, RGBQUAD c2)
323 {
324 return (c1.rgbRed * c1.rgbRed + c1.rgbGreen * c1.rgbGreen + c1.rgbBlue * c1.rgbBlue) >
325 (c2.rgbRed * c2.rgbRed + c2.rgbGreen * c2.rgbGreen + c2.rgbBlue * c2.rgbBlue);
326 }
327
328 /***********************************************************************
329 * X11DRV_DIB_GenColorMap
330 *
331 * Fills the color map of a bitmap palette. Should not be called
332 * for a >8-bit deep bitmap.
333 */
334 static int *X11DRV_DIB_GenColorMap( X11DRV_PDEVICE *physDev, int *colorMapping,
335 WORD coloruse, WORD depth, BOOL quads,
336 const void *colorPtr, int start, int end )
337 {
338 int i;
339
340 if (coloruse == DIB_RGB_COLORS)
341 {
342 if (quads)
343 {
344 const RGBQUAD * rgb = colorPtr;
345
346 if (depth == 1) /* Monochrome */
347 {
348 BOOL invert = FALSE;
349 RGBQUAD table[2];
350
351 if (GetDIBColorTable( physDev->dev.hdc, 0, 2, table ) == 2)
352 invert = !colour_is_brighter(table[1], table[0]);
353
354 for (i = start; i < end; i++, rgb++)
355 colorMapping[i] = ((rgb->rgbRed + rgb->rgbGreen +
356 rgb->rgbBlue > 255*3/2 && !invert) ||
357 (rgb->rgbRed + rgb->rgbGreen +
358 rgb->rgbBlue <= 255*3/2 && invert));
359 }
360 else
361 for (i = start; i < end; i++, rgb++)
362 colorMapping[i] = X11DRV_PALETTE_LookupPixel(physDev->color_shifts, RGB(rgb->rgbRed,
363 rgb->rgbGreen,
364 rgb->rgbBlue));
365 }
366 else
367 {
368 const RGBTRIPLE * rgb = colorPtr;
369
370 if (depth == 1) /* Monochrome */
371 {
372 BOOL invert = FALSE;
373 RGBQUAD table[2];
374
375 if (GetDIBColorTable( physDev->dev.hdc, 0, 2, table ) == 2)
376 invert = !colour_is_brighter(table[1], table[0]);
377
378 for (i = start; i < end; i++, rgb++)
379 colorMapping[i] = ((rgb->rgbtRed + rgb->rgbtGreen +
380 rgb->rgbtBlue > 255*3/2 && !invert) ||
381 (rgb->rgbtRed + rgb->rgbtGreen +
382 rgb->rgbtBlue <= 255*3/2 && invert));
383 }
384 else
385 for (i = start; i < end; i++, rgb++)
386 colorMapping[i] = X11DRV_PALETTE_LookupPixel(physDev->color_shifts, RGB(rgb->rgbtRed,
387 rgb->rgbtGreen,
388 rgb->rgbtBlue));
389 }
390 }
391 else /* DIB_PAL_COLORS */
392 {
393 const WORD * index = colorPtr;
394
395 for (i = start; i < end; i++, index++)
396 colorMapping[i] = X11DRV_PALETTE_ToPhysical( physDev, PALETTEINDEX(*index) );
397 }
398
399 return colorMapping;
400 }
401
402 /***********************************************************************
403 * X11DRV_DIB_BuildColorMap
404 *
405 * Build the color map from the bitmap palette. Should not be called
406 * for a >8-bit deep bitmap.
407 */
408 static int *X11DRV_DIB_BuildColorMap( X11DRV_PDEVICE *physDev, WORD coloruse, WORD depth,
409 const BITMAPINFO *info, int *nColors )
410 {
411 BOOL isInfo;
412 const void *colorPtr;
413 int *colorMapping;
414
415
416 *nColors = X11DRV_DIB_GetColorCount(info);
417 if (!*nColors) return NULL;
418
419 isInfo = info->bmiHeader.biSize != sizeof(BITMAPCOREHEADER);
420 colorPtr = (const BYTE*)info + (WORD)info->bmiHeader.biSize;
421 if (!(colorMapping = HeapAlloc(GetProcessHeap(), 0, *nColors * sizeof(int) )))
422 return NULL;
423
424 return X11DRV_DIB_GenColorMap( physDev, colorMapping, coloruse, depth,
425 isInfo, colorPtr, 0, *nColors);
426 }
427
428 /***********************************************************************
429 * X11DRV_DIB_MapColor
430 */
431 static int X11DRV_DIB_MapColor( int *physMap, int nPhysMap, int phys, int oldcol )
432 {
433 int color;
434
435 if ((oldcol < nPhysMap) && (physMap[oldcol] == phys))
436 return oldcol;
437
438 for (color = 0; color < nPhysMap; color++)
439 if (physMap[color] == phys)
440 return color;
441
442 WARN("Strange color %08x\n", phys);
443 return 0;
444 }
445
446
447 /*********************************************************************
448 * X11DRV_DIB_GetNearestIndex
449 *
450 * Helper for X11DRV_DIB_GetDIBits.
451 * Returns the nearest colour table index for a given RGB.
452 * Nearest is defined by minimizing the sum of the squares.
453 */
454 static INT X11DRV_DIB_GetNearestIndex(RGBQUAD *colormap, int numColors, BYTE r, BYTE g, BYTE b)
455 {
456 INT i, best = -1, diff, bestdiff = -1;
457 RGBQUAD *color;
458
459 for(color = colormap, i = 0; i < numColors; color++, i++) {
460 diff = (r - color->rgbRed) * (r - color->rgbRed) +
461 (g - color->rgbGreen) * (g - color->rgbGreen) +
462 (b - color->rgbBlue) * (b - color->rgbBlue);
463 if(diff == 0)
464 return i;
465 if(best == -1 || diff < bestdiff) {
466 best = i;
467 bestdiff = diff;
468 }
469 }
470 return best;
471 }
472 /*********************************************************************
473 * X11DRV_DIB_MaskToShift
474 *
475 * Helper for X11DRV_DIB_GetDIBits.
476 * Returns the by how many bits to shift a given color so that it is
477 * in the proper position.
478 */
479 INT X11DRV_DIB_MaskToShift(DWORD mask)
480 {
481 int shift;
482
483 if (mask==0)
484 return 0;
485
486 shift=0;
487 while ((mask&1)==0) {
488 mask>>=1;
489 shift++;
490 }
491 return shift;
492 }
493
494 /***********************************************************************
495 * X11DRV_DIB_CheckMask
496 *
497 * Check RGB mask if it is either 0 or matches visual's mask.
498 */
499 static inline int X11DRV_DIB_CheckMask(int red_mask, int green_mask, int blue_mask)
500 {
501 return ( red_mask == 0 && green_mask == 0 && blue_mask == 0 ) ||
502 ( red_mask == visual->red_mask && green_mask == visual->green_mask &&
503 blue_mask == visual->blue_mask );
504 }
505
506 /***********************************************************************
507 * X11DRV_DIB_SetImageBits_1
508 *
509 * SetDIBits for a 1-bit deep DIB.
510 */
511 static void X11DRV_DIB_SetImageBits_1( int lines, const BYTE *srcbits,
512 DWORD srcwidth, DWORD dstwidth, int left,
513 int *colors, XImage *bmpImage, int linebytes)
514 {
515 int h, width;
516 const BYTE* srcbyte;
517 BYTE srcval, extra;
518 DWORD i, x;
519
520 if (lines < 0 ) {
521 lines = -lines;
522 srcbits = srcbits + linebytes * (lines - 1);
523 linebytes = -linebytes;
524 }
525
526 if ((extra = (left & 7)) != 0) {
527 left &= ~7;
528 dstwidth += extra;
529 }
530 srcbits += left >> 3;
531 width = min(srcwidth, dstwidth);
532
533 /* ==== pal 1 dib -> any bmp format ==== */
534 for (h = lines-1; h >=0; h--) {
535 srcbyte=srcbits;
536 for (i = width/8, x = left; i > 0; i--) {
537 srcval=*srcbyte++;
538 XPutPixel( bmpImage, x++, h, colors[ srcval >> 7] );
539 XPutPixel( bmpImage, x++, h, colors[(srcval >> 6) & 1] );
540 XPutPixel( bmpImage, x++, h, colors[(srcval >> 5) & 1] );
541 XPutPixel( bmpImage, x++, h, colors[(srcval >> 4) & 1] );
542 XPutPixel( bmpImage, x++, h, colors[(srcval >> 3) & 1] );
543 XPutPixel( bmpImage, x++, h, colors[(srcval >> 2) & 1] );
544 XPutPixel( bmpImage, x++, h, colors[(srcval >> 1) & 1] );
545 XPutPixel( bmpImage, x++, h, colors[ srcval & 1] );
546 }
547 if (width % 8){
548 srcval=*srcbyte;
549 switch (width & 7)
550 {
551 case 7: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
552 case 6: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
553 case 5: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
554 case 4: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
555 case 3: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
556 case 2: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
557 case 1: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]);
558 }
559 }
560 srcbits += linebytes;
561 }
562 }
563
564 /***********************************************************************
565 * X11DRV_DIB_GetImageBits_1
566 *
567 * GetDIBits for a 1-bit deep DIB.
568 */
569 static void X11DRV_DIB_GetImageBits_1( int lines, BYTE *dstbits,
570 DWORD dstwidth, DWORD srcwidth,
571 RGBQUAD *colors, PALETTEENTRY *srccolors,
572 XImage *bmpImage, int linebytes )
573 {
574 DWORD x;
575 int h, width = min(dstwidth, srcwidth);
576
577 if (lines < 0 ) {
578 lines = -lines;
579 dstbits = dstbits + linebytes * (lines - 1);
580 linebytes = -linebytes;
581 }
582
583 switch (bmpImage->depth)
584 {
585 case 1:
586 case 4:
587 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
588 && srccolors) {
589 /* ==== pal 1 or 4 bmp -> pal 1 dib ==== */
590 BYTE* dstbyte;
591
592 for (h=lines-1; h>=0; h--) {
593 BYTE dstval;
594 dstbyte=dstbits;
595 dstval=0;
596 for (x=0; x<width; x++) {
597 PALETTEENTRY srcval;
598 srcval=srccolors[XGetPixel(bmpImage, x, h)];
599 dstval|=(X11DRV_DIB_GetNearestIndex
600 (colors, 2,
601 srcval.peRed,
602 srcval.peGreen,
603 srcval.peBlue) << (7 - (x & 7)));
604 if ((x&7)==7) {
605 *dstbyte++=dstval;
606 dstval=0;
607 }
608 }
609 if ((width&7)!=0) {
610 *dstbyte++=dstval;
611 }
612 /* pad with 0 to DWORD alignment */
613 for (x = (x+7)&~7; x < ((width + 31) & ~31); x+=8)
614 *dstbyte++ = 0;
615 dstbits += linebytes;
616 }
617 } else {
618 goto notsupported;
619 }
620 break;
621
622 case 8:
623 if (X11DRV_DIB_CheckMask(bmpImage->red_mask, bmpImage->green_mask, bmpImage->blue_mask)
624 && srccolors) {
625 /* ==== pal 8 bmp -> pal 1 dib ==== */
626 const void* srcbits;
627 const BYTE* srcpixel;
628 BYTE* dstbyte;
629
630 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
631
632 for (h=0; h<lines; h++) {
633 BYTE dstval;
634 srcpixel=srcbits;
635 dstbyte=dstbits;
636 dstval=0;
637 for (x=0; x<width; x++) {
638 PALETTEENTRY srcval;
639 srcval=srccolors[*srcpixel++];
640 dstval|=(X11DRV_DIB_GetNearestIndex
641 (colors, 2,
642 srcval.peRed,
643 srcval.peGreen,
644 srcval.peBlue) << (7-(x&7)) );
645 if ((x&7)==7) {
646 *dstbyte++=dstval;
647 dstval=0;
648 }
649 }
650 if ((width&7)!=0) {
651 *dstbyte=dstval;
652 }
653 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
654 dstbits += linebytes;
655 }
656 } else {
657 goto notsupported;
658 }
659 break;
660
661 case 15:
662 case 16:
663 {
664 const void* srcbits;
665 const WORD* srcpixel;
666 BYTE* dstbyte;
667
668 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
669
670 if (bmpImage->green_mask==0x03e0) {
671 if (bmpImage->red_mask==0x7c00) {
672 /* ==== rgb 555 bmp -> pal 1 dib ==== */
673 for (h=0; h<lines; h++) {
674 BYTE dstval;
675 srcpixel=srcbits;
676 dstbyte=dstbits;
677 dstval=0;
678 for (x=0; x<width; x++) {
679 WORD srcval;
680 srcval=*srcpixel++;
681 dstval|=(X11DRV_DIB_GetNearestIndex
682 (colors, 2,
683 ((srcval >> 7) & 0xf8) | /* r */
684 ((srcval >> 12) & 0x07),
685 ((srcval >> 2) & 0xf8) | /* g */
686 ((srcval >> 7) & 0x07),
687 ((srcval << 3) & 0xf8) | /* b */
688 ((srcval >> 2) & 0x07) ) << (7-(x&7)) );
689 if ((x&7)==7) {
690 *dstbyte++=dstval;
691 dstval=0;
692 }
693 }
694 if ((width&7)!=0) {
695 *dstbyte=dstval;
696 }
697 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
698 dstbits += linebytes;
699 }
700 } else if (bmpImage->blue_mask==0x7c00) {
701 /* ==== bgr 555 bmp -> pal 1 dib ==== */
702 for (h=0; h<lines; h++) {
703 WORD dstval;
704 srcpixel=srcbits;
705 dstbyte=dstbits;
706 dstval=0;
707 for (x=0; x<width; x++) {
708 BYTE srcval;
709 srcval=*srcpixel++;
710 dstval|=(X11DRV_DIB_GetNearestIndex
711 (colors, 2,
712 ((srcval << 3) & 0xf8) | /* r */
713 ((srcval >> 2) & 0x07),
714 ((srcval >> 2) & 0xf8) | /* g */
715 ((srcval >> 7) & 0x07),
716 ((srcval >> 7) & 0xf8) | /* b */
717 ((srcval >> 12) & 0x07) ) << (7-(x&7)) );
718 if ((x&7)==7) {
719 *dstbyte++=dstval;
720 dstval=0;
721 }
722 }
723 if ((width&7)!=0) {
724 *dstbyte=dstval;
725 }
726 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
727 dstbits += linebytes;
728 }
729 } else {
730 goto notsupported;
731 }
732 } else if (bmpImage->green_mask==0x07e0) {
733 if (bmpImage->red_mask==0xf800) {
734 /* ==== rgb 565 bmp -> pal 1 dib ==== */
735 for (h=0; h<lines; h++) {
736 BYTE dstval;
737 srcpixel=srcbits;
738 dstbyte=dstbits;
739 dstval=0;
740 for (x=0; x<width; x++) {
741 WORD srcval;
742 srcval=*srcpixel++;
743 dstval|=(X11DRV_DIB_GetNearestIndex
744 (colors, 2,
745 ((srcval >> 8) & 0xf8) | /* r */
746 ((srcval >> 13) & 0x07),
747 ((srcval >> 3) & 0xfc) | /* g */
748 ((srcval >> 9) & 0x03),
749 ((srcval << 3) & 0xf8) | /* b */
750 ((srcval >> 2) & 0x07) ) << (7-(x&7)) );
751 if ((x&7)==7) {
752 *dstbyte++=dstval;
753 dstval=0;
754 }
755 }
756 if ((width&7)!=0) {
757 *dstbyte=dstval;
758 }
759 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
760 dstbits += linebytes;
761 }
762 } else if (bmpImage->blue_mask==0xf800) {
763 /* ==== bgr 565 bmp -> pal 1 dib ==== */
764 for (h=0; h<lines; h++) {
765 BYTE dstval;
766 srcpixel=srcbits;
767 dstbyte=dstbits;
768 dstval=0;
769 for (x=0; x<width; x++) {
770 WORD srcval;
771 srcval=*srcpixel++;
772 dstval|=(X11DRV_DIB_GetNearestIndex
773 (colors, 2,
774 ((srcval << 3) & 0xf8) | /* r */
775 ((srcval >> 2) & 0x07),
776 ((srcval >> 3) & 0xfc) | /* g */
777 ((srcval >> 9) & 0x03),
778 ((srcval >> 8) & 0xf8) | /* b */
779 ((srcval >> 13) & 0x07) ) << (7-(x&7)) );
780 if ((x&7)==7) {
781 *dstbyte++=dstval;
782 dstval=0;
783 }
784 }
785 if ((width&7)!=0) {
786 *dstbyte=dstval;
787 }
788 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
789 dstbits += linebytes;
790 }
791 } else {
792 goto notsupported;
793 }
794 } else {
795 goto notsupported;
796 }
797 }
798 break;
799
800 case 24:
801 case 32:
802 {
803 const void* srcbits;
804 const BYTE *srcbyte;
805 BYTE* dstbyte;
806 int bytes_per_pixel;
807
808 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
809 bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
810
811 if (bmpImage->green_mask!=0x00ff00 ||
812 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
813 goto notsupported;
814 } else if (bmpImage->blue_mask==0xff) {
815 /* ==== rgb 888 or 0888 bmp -> pal 1 dib ==== */
816 for (h=0; h<lines; h++) {
817 BYTE dstval;
818 srcbyte=srcbits;
819 dstbyte=dstbits;
820 dstval=0;
821 for (x=0; x<width; x++) {
822 dstval|=(X11DRV_DIB_GetNearestIndex
823 (colors, 2,
824 srcbyte[2],
825 srcbyte[1],
826 srcbyte[0]) << (7-(x&7)) );
827 srcbyte+=bytes_per_pixel;
828 if ((x&7)==7) {
829 *dstbyte++=dstval;
830 dstval=0;
831 }
832 }
833 if ((width&7)!=0) {
834 *dstbyte=dstval;
835 }
836 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
837 dstbits += linebytes;
838 }
839 } else {
840 /* ==== bgr 888 or 0888 bmp -> pal 1 dib ==== */
841 for (h=0; h<lines; h++) {
842 BYTE dstval;
843 srcbyte=srcbits;
844 dstbyte=dstbits;
845 dstval=0;
846 for (x=0; x<width; x++) {
847 dstval|=(X11DRV_DIB_GetNearestIndex
848 (colors, 2,
849 srcbyte[0],
850 srcbyte[1],
851 srcbyte[2]) << (7-(x&7)) );
852 srcbyte+=bytes_per_pixel;
853 if ((x&7)==7) {
854 *dstbyte++=dstval;
855 dstval=0;
856 }
857 }
858 if ((width&7)!=0) {
859 *dstbyte=dstval;
860 }
861 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
862 dstbits += linebytes;
863 }
864 }
865 }
866 break;
867
868 default:
869 notsupported:
870 {
871 BYTE* dstbyte;
872 BYTE neg = 0;
873 unsigned long white = (1 << bmpImage->bits_per_pixel) - 1;
874
875 /* ==== any bmp format -> pal 1 dib ==== */
876 if ((unsigned)colors[0].rgbRed+colors[0].rgbGreen+colors[0].rgbBlue >=
877 (unsigned)colors[1].rgbRed+colors[1].rgbGreen+colors[1].rgbBlue )
878 neg = 1;
879
880 WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 1 bit DIB, "
881 "%s color mapping\n",
882 bmpImage->bits_per_pixel, bmpImage->red_mask,
883 bmpImage->green_mask, bmpImage->blue_mask,
884 neg?"negative":"direct" );
885
886 for (h=lines-1; h>=0; h--) {
887 BYTE dstval;
888 dstbyte=dstbits;
889 dstval=0;
890 for (x=0; x<width; x++) {
891 dstval|=((XGetPixel( bmpImage, x, h) >= white) ^ neg) << (7 - (x&7));
892 if ((x&7)==7) {
893 *dstbyte++=dstval;
894 dstval=0;
895 }
896 }
897 if ((width&7)!=0) {
898 *dstbyte=dstval;
899 }
900 dstbits += linebytes;
901 }
902 }
903 break;
904 }
905 }
906
907 /***********************************************************************
908 * X11DRV_DIB_SetImageBits_4
909 *
910 * SetDIBits for a 4-bit deep DIB.
911 */
912 static void X11DRV_DIB_SetImageBits_4( int lines, const BYTE *srcbits,
913 DWORD srcwidth, DWORD dstwidth, int left,
914 int *colors, XImage *bmpImage, int linebytes)
915 {
916 int h, width;
917 const BYTE* srcbyte;
918 DWORD i, x;
919
920 if (lines < 0 ) {
921 lines = -lines;
922 srcbits = srcbits + linebytes * (lines - 1);
923 linebytes = -linebytes;
924 }
925
926 if (left & 1) {
927 left--;
928 dstwidth++;
929 }
930 srcbits += left >> 1;
931 width = min(srcwidth, dstwidth);
932
933 /* ==== pal 4 dib -> any bmp format ==== */
934 for (h = lines-1; h >= 0; h--) {
935 srcbyte=srcbits;
936 for (i = width/2, x = left; i > 0; i--) {
937 BYTE srcval=*srcbyte++;
938 XPutPixel( bmpImage, x++, h, colors[srcval >> 4] );
939 XPutPixel( bmpImage, x++, h, colors[srcval & 0x0f] );
940 }
941 if (width & 1)
942 XPutPixel( bmpImage, x, h, colors[*srcbyte >> 4] );
943 srcbits += linebytes;
944 }
945 }
946
947
948
949 /***********************************************************************
950 * X11DRV_DIB_GetImageBits_4
951 *
952 * GetDIBits for a 4-bit deep DIB.
953 */
954 static void X11DRV_DIB_GetImageBits_4( int lines, BYTE *dstbits,
955 DWORD srcwidth, DWORD dstwidth,
956 RGBQUAD *colors, PALETTEENTRY *srccolors,
957 XImage *bmpImage, int linebytes )
958 {
959 DWORD x;
960 int h, width = min(srcwidth, dstwidth);
961
962 if (lines < 0 )
963 {
964 lines = -lines;
965 dstbits = dstbits + ( linebytes * (lines-1) );
966 linebytes = -linebytes;
967 }
968
969 switch (bmpImage->depth) {
970 case 1:
971 case 4:
972 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
973 && srccolors) {
974 /* ==== pal 1 or 4 bmp -> pal 4 dib ==== */
975 BYTE* dstbyte;
976
977 for (h = lines-1; h >= 0; h--) {
978 BYTE dstval;
979 dstbyte=dstbits;
980 dstval=0;
981 for (x = 0; x < width; x++) {
982 PALETTEENTRY srcval;
983 srcval=srccolors[XGetPixel(bmpImage, x, h)];
984 dstval|=(X11DRV_DIB_GetNearestIndex
985 (colors, 16,
986 srcval.peRed,
987 srcval.peGreen,
988 srcval.peBlue) << (4-((x&1)<<2)));
989 if ((x&1)==1) {
990 *dstbyte++=dstval;
991 dstval=0;
992 }
993 }
994 if ((width&1)!=0) {
995 *dstbyte=dstval;
996 }
997 dstbits += linebytes;
998 }
999 } else {
1000 goto notsupported;
1001 }
1002 break;
1003
1004 case 8:
1005 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1006 && srccolors) {
1007 /* ==== pal 8 bmp -> pal 4 dib ==== */
1008 const void* srcbits;
1009 const BYTE *srcpixel;
1010 BYTE* dstbyte;
1011
1012 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1013 for (h=0; h<lines; h++) {
1014 BYTE dstval;
1015 srcpixel=srcbits;
1016 dstbyte=dstbits;
1017 dstval=0;
1018 for (x=0; x<width; x++) {
1019 PALETTEENTRY srcval;
1020 srcval = srccolors[*srcpixel++];
1021 dstval|=(X11DRV_DIB_GetNearestIndex
1022 (colors, 16,
1023 srcval.peRed,
1024 srcval.peGreen,
1025 srcval.peBlue) << (4*(1-(x&1))) );
1026 if ((x&1)==1) {
1027 *dstbyte++=dstval;
1028 dstval=0;
1029 }
1030 }
1031 if ((width&1)!=0) {
1032 *dstbyte=dstval;
1033 }
1034 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1035 dstbits += linebytes;
1036 }
1037 } else {
1038 goto notsupported;
1039 }
1040 break;
1041
1042 case 15:
1043 case 16:
1044 {
1045 const void* srcbits;
1046 const WORD* srcpixel;
1047 BYTE* dstbyte;
1048
1049 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1050
1051 if (bmpImage->green_mask==0x03e0) {
1052 if (bmpImage->red_mask==0x7c00) {
1053 /* ==== rgb 555 bmp -> pal 4 dib ==== */
1054 for (h=0; h<lines; h++) {
1055 BYTE dstval;
1056 srcpixel=srcbits;
1057 dstbyte=dstbits;
1058 dstval=0;
1059 for (x=0; x<width; x++) {
1060 WORD srcval;
1061 srcval=*srcpixel++;
1062 dstval|=(X11DRV_DIB_GetNearestIndex
1063 (colors, 16,
1064 ((srcval >> 7) & 0xf8) | /* r */
1065 ((srcval >> 12) & 0x07),
1066 ((srcval >> 2) & 0xf8) | /* g */
1067 ((srcval >> 7) & 0x07),
1068 ((srcval << 3) & 0xf8) | /* b */
1069 ((srcval >> 2) & 0x07) ) << ((1-(x&1))<<2) );
1070 if ((x&1)==1) {
1071 *dstbyte++=dstval;
1072 dstval=0;
1073 }
1074 }
1075 if ((width&1)!=0) {
1076 *dstbyte=dstval;
1077 }
1078 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1079 dstbits += linebytes;
1080 }
1081 } else if (bmpImage->blue_mask==0x7c00) {
1082 /* ==== bgr 555 bmp -> pal 4 dib ==== */
1083 for (h=0; h<lines; h++) {
1084 WORD dstval;
1085 srcpixel=srcbits;
1086 dstbyte=dstbits;
1087 dstval=0;
1088 for (x=0; x<width; x++) {
1089 WORD srcval;
1090 srcval=*srcpixel++;
1091 dstval|=(X11DRV_DIB_GetNearestIndex
1092 (colors, 16,
1093 ((srcval << 3) & 0xf8) | /* r */
1094 ((srcval >> 2) & 0x07),
1095 ((srcval >> 2) & 0xf8) | /* g */
1096 ((srcval >> 7) & 0x07),
1097 ((srcval >> 7) & 0xf8) | /* b */
1098 ((srcval >> 12) & 0x07) ) << ((1-(x&1))<<2) );
1099 if ((x&1)==1) {
1100 *dstbyte++=dstval;
1101 dstval=0;
1102 }
1103 }
1104 if ((width&1)!=0) {
1105 *dstbyte=dstval;
1106 }
1107 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1108 dstbits += linebytes;
1109 }
1110 } else {
1111 goto notsupported;
1112 }
1113 } else if (bmpImage->green_mask==0x07e0) {
1114 if (bmpImage->red_mask==0xf800) {
1115 /* ==== rgb 565 bmp -> pal 4 dib ==== */
1116 for (h=0; h<lines; h++) {
1117 BYTE dstval;
1118 srcpixel=srcbits;
1119 dstbyte=dstbits;
1120 dstval=0;
1121 for (x=0; x<width; x++) {
1122 WORD srcval;
1123 srcval=*srcpixel++;
1124 dstval|=(X11DRV_DIB_GetNearestIndex
1125 (colors, 16,
1126 ((srcval >> 8) & 0xf8) | /* r */
1127 ((srcval >> 13) & 0x07),
1128 ((srcval >> 3) & 0xfc) | /* g */
1129 ((srcval >> 9) & 0x03),
1130 ((srcval << 3) & 0xf8) | /* b */
1131 ((srcval >> 2) & 0x07) ) << ((1-(x&1))<<2) );
1132 if ((x&1)==1) {
1133 *dstbyte++=dstval;
1134 dstval=0;
1135 }
1136 }
1137 if ((width&1)!=0) {
1138 *dstbyte=dstval;
1139 }
1140 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1141 dstbits += linebytes;
1142 }
1143 } else if (bmpImage->blue_mask==0xf800) {
1144 /* ==== bgr 565 bmp -> pal 4 dib ==== */
1145 for (h=0; h<lines; h++) {
1146 WORD dstval;
1147 srcpixel=srcbits;
1148 dstbyte=dstbits;
1149 dstval=0;
1150 for (x=0; x<width; x++) {
1151 WORD srcval;
1152 srcval=*srcpixel++;
1153 dstval|=(X11DRV_DIB_GetNearestIndex
1154 (colors, 16,
1155 ((srcval << 3) & 0xf8) | /* r */
1156 ((srcval >> 2) & 0x07),
1157 ((srcval >> 3) & 0xfc) | /* g */
1158 ((srcval >> 9) & 0x03),
1159 ((srcval >> 8) & 0xf8) | /* b */
1160 ((srcval >> 13) & 0x07) ) << ((1-(x&1))<<2) );
1161 if ((x&1)==1) {
1162 *dstbyte++=dstval;
1163 dstval=0;
1164 }
1165 }
1166 if ((width&1)!=0) {
1167 *dstbyte=dstval;
1168 }
1169 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1170 dstbits += linebytes;
1171 }
1172 } else {
1173 goto notsupported;
1174 }
1175 } else {
1176 goto notsupported;
1177 }
1178 }
1179 break;
1180
1181 case 24:
1182 if (bmpImage->bits_per_pixel==24) {
1183 const void* srcbits;
1184 const BYTE *srcbyte;
1185 BYTE* dstbyte;
1186
1187 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1188
1189 if (bmpImage->green_mask!=0x00ff00 ||
1190 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1191 goto notsupported;
1192 } else if (bmpImage->blue_mask==0xff) {
1193 /* ==== rgb 888 bmp -> pal 4 dib ==== */
1194 for (h=0; h<lines; h++) {
1195 srcbyte=srcbits;
1196 dstbyte=dstbits;
1197 for (x=0; x<width/2; x++) {
1198 /* Do 2 pixels at a time */
1199 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1200 (colors, 16,
1201 srcbyte[2],
1202 srcbyte[1],
1203 srcbyte[0]) << 4) |
1204 X11DRV_DIB_GetNearestIndex
1205 (colors, 16,
1206 srcbyte[5],
1207 srcbyte[4],
1208 srcbyte[3]);
1209 srcbyte+=6;
1210 }
1211 if (width&1) {
1212 /* And then the odd pixel */
1213 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1214 (colors, 16,
1215 srcbyte[2],
1216 srcbyte[1],
1217 srcbyte[0]) << 4);
1218 }
1219 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1220 dstbits += linebytes;
1221 }
1222 } else {
1223 /* ==== bgr 888 bmp -> pal 4 dib ==== */
1224 for (h=0; h<lines; h++) {
1225 srcbyte=srcbits;
1226 dstbyte=dstbits;
1227 for (x=0; x<width/2; x++) {
1228 /* Do 2 pixels at a time */
1229 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1230 (colors, 16,
1231 srcbyte[0],
1232 srcbyte[1],
1233 srcbyte[2]) << 4) |
1234 X11DRV_DIB_GetNearestIndex
1235 (colors, 16,
1236 srcbyte[3],
1237 srcbyte[4],
1238 srcbyte[5]);
1239 srcbyte+=6;
1240 }
1241 if (width&1) {
1242 /* And then the odd pixel */
1243 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1244 (colors, 16,
1245 srcbyte[0],
1246 srcbyte[1],
1247 srcbyte[2]) << 4);
1248 }
1249 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1250 dstbits += linebytes;
1251 }
1252 }
1253 break;
1254 }
1255 /* Fall through */
1256
1257 case 32:
1258 {
1259 const void* srcbits;
1260 const BYTE *srcbyte;
1261 BYTE* dstbyte;
1262
1263 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1264
1265 if (bmpImage->green_mask!=0x00ff00 ||
1266 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1267 goto notsupported;
1268 } else if (bmpImage->blue_mask==0xff) {
1269 /* ==== rgb 0888 bmp -> pal 4 dib ==== */
1270 for (h=0; h<lines; h++) {
1271 srcbyte=srcbits;
1272 dstbyte=dstbits;
1273 for (x=0; x<width/2; x++) {
1274 /* Do 2 pixels at a time */
1275 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1276 (colors, 16,
1277 srcbyte[2],
1278 srcbyte[1],
1279 srcbyte[0]) << 4) |
1280 X11DRV_DIB_GetNearestIndex
1281 (colors, 16,
1282 srcbyte[6],
1283 srcbyte[5],
1284 srcbyte[4]);
1285 srcbyte+=8;
1286 }
1287 if (width&1) {
1288 /* And then the odd pixel */
1289 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1290 (colors, 16,
1291 srcbyte[2],
1292 srcbyte[1],
1293 srcbyte[0]) << 4);
1294 }
1295 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1296 dstbits += linebytes;
1297 }
1298 } else {
1299 /* ==== bgr 0888 bmp -> pal 4 dib ==== */
1300 for (h=0; h<lines; h++) {
1301 srcbyte=srcbits;
1302 dstbyte=dstbits;
1303 for (x=0; x<width/2; x++) {
1304 /* Do 2 pixels at a time */
1305 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1306 (colors, 16,
1307 srcbyte[0],
1308 srcbyte[1],
1309 srcbyte[2]) << 4) |
1310 X11DRV_DIB_GetNearestIndex
1311 (colors, 16,
1312 srcbyte[4],
1313 srcbyte[5],
1314 srcbyte[6]);
1315 srcbyte+=8;
1316 }
1317 if (width&1) {
1318 /* And then the odd pixel */
1319 *dstbyte++=(X11DRV_DIB_GetNearestIndex
1320 (colors, 16,
1321 srcbyte[0],
1322 srcbyte[1],
1323 srcbyte[2]) << 4);
1324 }
1325 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1326 dstbits += linebytes;
1327 }
1328 }
1329 }
1330 break;
1331
1332 default:
1333 notsupported:
1334 {
1335 BYTE* dstbyte;
1336
1337 /* ==== any bmp format -> pal 4 dib ==== */
1338 WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 4 bit DIB\n",
1339 bmpImage->bits_per_pixel, bmpImage->red_mask,
1340 bmpImage->green_mask, bmpImage->blue_mask );
1341 for (h=lines-1; h>=0; h--) {
1342 dstbyte=dstbits;
1343 for (x=0; x<(width & ~1); x+=2) {
1344 *dstbyte++=(X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4) |
1345 X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x+1, h), 0);
1346 }
1347 if (width & 1) {
1348 *dstbyte=(X11DRV_DIB_MapColor((int *)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4);
1349 }
1350 dstbits += linebytes;
1351 }
1352 }
1353 break;
1354 }
1355 }
1356
1357 /***********************************************************************
1358 * X11DRV_DIB_SetImageBits_RLE4
1359 *
1360 * SetDIBits for a 4-bit deep compressed DIB.
1361 */
1362 static void X11DRV_DIB_SetImageBits_RLE4( int lines, const BYTE *bits,
1363 DWORD srcwidth, DWORD dstwidth,
1364 int left, int *colors,
1365 XImage *bmpImage )
1366 {
1367 unsigned int x = 0, width = min(srcwidth, dstwidth);
1368 int y = lines - 1, c, length;
1369 const BYTE *begin = bits;
1370
1371 while (y >= 0)
1372 {
1373 length = *bits++;
1374 if (length) { /* encoded */
1375 c = *bits++;
1376 while (length--) {
1377 if (x >= (left + width)) break;
1378 if( x >= left) XPutPixel(bmpImage, x, y, colors[c >> 4]);
1379 x++;
1380 if (!length--) break;
1381 if (x >= (left + width)) break;
1382 if( x >= left) XPutPixel(bmpImage, x, y, colors[c & 0xf]);
1383 x++;
1384 }
1385 } else {
1386 length = *bits++;
1387 switch (length)
1388 {
1389 case RLE_EOL:
1390 x = 0;
1391 y--;
1392 break;
1393
1394 case RLE_END:
1395 return;
1396
1397 case RLE_DELTA:
1398 x += *bits++;
1399 y -= *bits++;
1400 break;
1401
1402 default: /* absolute */
1403 while (length--) {
1404 c = *bits++;
1405 if (x >= left && x < (left + width))
1406 XPutPixel(bmpImage, x, y, colors[c >> 4]);
1407 x++;
1408 if (!length--) break;
1409 if (x >= left && x < (left + width))
1410 XPutPixel(bmpImage, x, y, colors[c & 0xf]);
1411 x++;
1412 }
1413 if ((bits - begin) & 1)
1414 bits++;
1415 }
1416 }
1417 }
1418 }
1419
1420
1421
1422 /***********************************************************************
1423 * X11DRV_DIB_SetImageBits_8
1424 *
1425 * SetDIBits for an 8-bit deep DIB.
1426 */
1427 static void X11DRV_DIB_SetImageBits_8( int lines, const BYTE *srcbits,
1428 DWORD srcwidth, DWORD dstwidth, int left,
1429 const int *colors, XImage *bmpImage,
1430 int linebytes )
1431 {
1432 DWORD x;
1433 int h, width = min(srcwidth, dstwidth);
1434 const BYTE* srcbyte;
1435 BYTE* dstbits;
1436
1437 if (lines < 0 )
1438 {
1439 lines = -lines;
1440 srcbits = srcbits + linebytes * (lines-1);
1441 linebytes = -linebytes;
1442 }
1443 srcbits += left;
1444 srcbyte = srcbits;
1445
1446 switch (bmpImage->depth) {
1447 case 15:
1448 case 16:
1449 /* Some X servers might have 32 bit/ 16bit deep pixel */
1450 if (lines && width && (bmpImage->bits_per_pixel == 16) &&
1451 (ImageByteOrder(gdi_display)==LSBFirst) )
1452 {
1453 /* ==== pal 8 dib -> rgb or bgr 555 or 565 bmp ==== */
1454 dstbits=(BYTE*)bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
1455 for (h = lines ; h--; ) {
1456 #if defined(__i386__) && defined(__GNUC__)
1457 int _cl1,_cl2; /* temp outputs for asm below */
1458 /* Borrowed from DirectDraw */
1459 __asm__ __volatile__(
1460 "xor %%eax,%%eax\n"
1461 "cld\n"
1462 "1:\n"
1463 " lodsb\n"
1464 " movw (%%edx,%%eax,4),%%ax\n"
1465 " stosw\n"
1466 " xor %%eax,%%eax\n"
1467 " loop 1b\n"
1468 :"=S" (srcbyte), "=D" (_cl1), "=c" (_cl2)
1469 :"S" (srcbyte),
1470 "D" (dstbits),
1471 "c" (width),
1472 "d" (colors)
1473 :"eax", "cc", "memory"
1474 );
1475 #else
1476 DWORD* dstpixel=(DWORD*)dstbits;
1477 for (x=0; x<width/2; x++) {
1478 /* Do 2 pixels at a time */
1479 *dstpixel++=(colors[srcbyte[1]] << 16) | colors[srcbyte[0]];
1480 srcbyte+=2;
1481 }
1482 if (width&1) {
1483 /* And then the odd pixel */
1484 *((WORD*)dstpixel)=colors[srcbyte[0]];
1485 }
1486 #endif
1487 srcbyte = (srcbits += linebytes);
1488 dstbits -= bmpImage->bytes_per_line;
1489 }
1490 return;
1491 }
1492 break;
1493 case 24:
1494 case 32:
1495 if (lines && width && (bmpImage->bits_per_pixel == 32) &&
1496 (ImageByteOrder(gdi_display)==LSBFirst) )
1497 {
1498 dstbits=(BYTE*)bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
1499 /* ==== pal 8 dib -> rgb or bgr 0888 bmp ==== */
1500 for (h = lines ; h--; ) {
1501 #if defined(__i386__) && defined(__GNUC__)
1502 int _cl1,_cl2; /* temp outputs for asm below */
1503 /* Borrowed from DirectDraw */
1504 __asm__ __volatile__(
1505 "xor %%eax,%%eax\n"
1506 "cld\n"
1507 "1:\n"
1508 " lodsb\n"
1509 " movl (%%edx,%%eax,4),%%eax\n"
1510 " stosl\n"
1511 " xor %%eax,%%eax\n"
1512 " loop 1b\n"
1513 :"=S" (srcbyte), "=D" (_cl1), "=c" (_cl2)
1514 :"S" (srcbyte),
1515 "D" (dstbits),
1516 "c" (width),
1517 "d" (colors)
1518 :"eax", "cc", "memory"
1519 );
1520 #else
1521 DWORD* dstpixel=(DWORD*)dstbits;
1522 for (x=0; x<width; x++) {
1523 *dstpixel++=colors[*srcbyte++];
1524 }
1525 #endif
1526 srcbyte = (srcbits += linebytes);
1527 dstbits -= bmpImage->bytes_per_line;
1528 }
1529 return;
1530 }
1531 break;
1532 default:
1533 break; /* use slow generic case below */
1534 }
1535
1536 /* ==== pal 8 dib -> any bmp format ==== */
1537 for (h=lines-1; h>=0; h--) {
1538 for (x=left; x<width+left; x++) {
1539 XPutPixel(bmpImage, x, h, colors[*srcbyte++]);
1540 }
1541 srcbyte = (srcbits += linebytes);
1542 }
1543 }
1544
1545 /***********************************************************************
1546 * X11DRV_DIB_GetImageBits_8
1547 *
1548 * GetDIBits for an 8-bit deep DIB.
1549 */
1550 static void X11DRV_DIB_GetImageBits_8( int lines, BYTE *dstbits,
1551 DWORD srcwidth, DWORD dstwidth,
1552 RGBQUAD *colors, PALETTEENTRY *srccolors,
1553 XImage *bmpImage, int linebytes )
1554 {
1555 DWORD x;
1556 int h, width = min(srcwidth, dstwidth);
1557 BYTE* dstbyte;
1558
1559 if (lines < 0 )
1560 {
1561 lines = -lines;
1562 dstbits = dstbits + ( linebytes * (lines-1) );
1563 linebytes = -linebytes;
1564 }
1565
1566 /*
1567 * Hack for now
1568 * This condition is true when GetImageBits has been called by
1569 * UpdateDIBSection. For now, GetNearestIndex is too slow to support
1570 * 256 colormaps, so we'll just use it for GetDIBits calls.
1571 * (In some cases, in an updateDIBSection, the returned colors are bad too)
1572 */
1573 if (!srccolors) goto updatesection;
1574
1575 switch (bmpImage->depth) {
1576 case 1:
1577 case 4:
1578 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1579 && srccolors) {
1580
1581 /* ==== pal 1 bmp -> pal 8 dib ==== */
1582 /* ==== pal 4 bmp -> pal 8 dib ==== */
1583 for (h=lines-1; h>=0; h--) {
1584 dstbyte=dstbits;
1585 for (x=0; x<width; x++) {
1586 PALETTEENTRY srcval;
1587 srcval=srccolors[XGetPixel(bmpImage, x, h)];
1588 *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
1589 srcval.peRed,
1590 srcval.peGreen,
1591 srcval.peBlue);
1592 }
1593 dstbits += linebytes;
1594 }
1595 } else {
1596 goto notsupported;
1597 }
1598 break;
1599
1600 case 8:
1601 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1602 && srccolors) {
1603 /* ==== pal 8 bmp -> pal 8 dib ==== */
1604 const void* srcbits;
1605 const BYTE* srcpixel;
1606
1607 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1608 for (h=0; h<lines; h++) {
1609 srcpixel=srcbits;
1610 dstbyte=dstbits;
1611 for (x = 0; x < width; x++) {
1612 PALETTEENTRY srcval;
1613 srcval=srccolors[*srcpixel++];
1614 *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
1615 srcval.peRed,
1616 srcval.peGreen,
1617 srcval.peBlue);
1618 }
1619 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1620 dstbits += linebytes;
1621 }
1622 } else {
1623 goto notsupported;
1624 }
1625 break;
1626
1627 case 15:
1628 case 16:
1629 {
1630 const void* srcbits;
1631 const WORD* srcpixel;
1632 BYTE* dstbyte;
1633
1634 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1635
1636 if (bmpImage->green_mask==0x03e0) {
1637 if (bmpImage->red_mask==0x7c00) {
1638 /* ==== rgb 555 bmp -> pal 8 dib ==== */
1639 for (h=0; h<lines; h++) {
1640 srcpixel=srcbits;
1641 dstbyte=dstbits;
1642 for (x=0; x<width; x++) {
1643 WORD srcval;
1644 srcval=*srcpixel++;
1645 *dstbyte++=X11DRV_DIB_GetNearestIndex
1646 (colors, 256,
1647 ((srcval >> 7) & 0xf8) | /* r */
1648 ((srcval >> 12) & 0x07),
1649 ((srcval >> 2) & 0xf8) | /* g */
1650 ((srcval >> 7) & 0x07),
1651 ((srcval << 3) & 0xf8) | /* b */
1652 ((srcval >> 2) & 0x07) );
1653 }
1654 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1655 dstbits += linebytes;
1656 }
1657 } else if (bmpImage->blue_mask==0x7c00) {
1658 /* ==== bgr 555 bmp -> pal 8 dib ==== */
1659 for (h=0; h<lines; h++) {
1660 srcpixel=srcbits;
1661 dstbyte=dstbits;
1662 for (x=0; x<width; x++) {
1663 WORD srcval;
1664 srcval=*srcpixel++;
1665 *dstbyte++=X11DRV_DIB_GetNearestIndex
1666 (colors, 256,
1667 ((srcval << 3) & 0xf8) | /* r */
1668 ((srcval >> 2) & 0x07),
1669 ((srcval >> 2) & 0xf8) | /* g */
1670 ((srcval >> 7) & 0x07),
1671 ((srcval >> 7) & 0xf8) | /* b */
1672 ((srcval >> 12) & 0x07) );
1673 }
1674 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1675 dstbits += linebytes;
1676 }
1677 } else {
1678 goto notsupported;
1679 }
1680 } else if (bmpImage->green_mask==0x07e0) {
1681 if (bmpImage->red_mask==0xf800) {
1682 /* ==== rgb 565 bmp -> pal 8 dib ==== */
1683 for (h=0; h<lines; h++) {
1684 srcpixel=srcbits;
1685 dstbyte=dstbits;
1686 for (x=0; x<width; x++) {
1687 WORD srcval;
1688 srcval=*srcpixel++;
1689 *dstbyte++=X11DRV_DIB_GetNearestIndex
1690 (colors, 256,
1691 ((srcval >> 8) & 0xf8) | /* r */
1692 ((srcval >> 13) & 0x07),
1693 ((srcval >> 3) & 0xfc) | /* g */
1694 ((srcval >> 9) & 0x03),
1695 ((srcval << 3) & 0xf8) | /* b */
1696 ((srcval >> 2) & 0x07) );
1697 }
1698 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1699 dstbits += linebytes;
1700 }
1701 } else if (bmpImage->blue_mask==0xf800) {
1702 /* ==== bgr 565 bmp -> pal 8 dib ==== */
1703 for (h=0; h<lines; h++) {
1704 srcpixel=srcbits;
1705 dstbyte=dstbits;
1706 for (x=0; x<width; x++) {
1707 WORD srcval;
1708 srcval=*srcpixel++;
1709 *dstbyte++=X11DRV_DIB_GetNearestIndex
1710 (colors, 256,
1711 ((srcval << 3) & 0xf8) | /* r */
1712 ((srcval >> 2) & 0x07),
1713 ((srcval >> 3) & 0xfc) | /* g */
1714 ((srcval >> 9) & 0x03),
1715 ((srcval >> 8) & 0xf8) | /* b */
1716 ((srcval >> 13) & 0x07) );
1717 }
1718 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1719 dstbits += linebytes;
1720 }
1721 } else {
1722 goto notsupported;
1723 }
1724 } else {
1725 goto notsupported;
1726 }
1727 }
1728 break;
1729
1730 case 24:
1731 case 32:
1732 {
1733 const void* srcbits;
1734 const BYTE *srcbyte;
1735 BYTE* dstbyte;
1736 int bytes_per_pixel;
1737
1738 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1739 bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
1740
1741 if (bmpImage->green_mask!=0x00ff00 ||
1742 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1743 goto notsupported;
1744 } else if (bmpImage->blue_mask==0xff) {
1745 /* ==== rgb 888 or 0888 bmp -> pal 8 dib ==== */
1746 for (h=0; h<lines; h++) {
1747 srcbyte=srcbits;
1748 dstbyte=dstbits;
1749 for (x=0; x<width; x++) {
1750 *dstbyte++=X11DRV_DIB_GetNearestIndex
1751 (colors, 256,
1752 srcbyte[2],
1753 srcbyte[1],
1754 srcbyte[0]);
1755 srcbyte+=bytes_per_pixel;
1756 }
1757 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1758 dstbits += linebytes;
1759 }
1760 } else {
1761 /* ==== bgr 888 or 0888 bmp -> pal 8 dib ==== */
1762 for (h=0; h<lines; h++) {
1763 srcbyte=srcbits;
1764 dstbyte=dstbits;
1765 for (x=0; x<width; x++) {
1766 *dstbyte++=X11DRV_DIB_GetNearestIndex
1767 (colors, 256,
1768 srcbyte[0],
1769 srcbyte[1],
1770 srcbyte[2]);
1771 srcbyte+=bytes_per_pixel;
1772 }
1773 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1774 dstbits += linebytes;
1775 }
1776 }
1777 }
1778 break;
1779
1780 default:
1781 notsupported:
1782 WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 8 bit DIB\n",
1783 bmpImage->depth, bmpImage->red_mask,
1784 bmpImage->green_mask, bmpImage->blue_mask );
1785 updatesection:
1786 /* ==== any bmp format -> pal 8 dib ==== */
1787 for (h=lines-1; h>=0; h--) {
1788 dstbyte=dstbits;
1789 for (x=0; x<width; x++) {
1790 *dstbyte=X11DRV_DIB_MapColor
1791 ((int*)colors, 256,
1792 XGetPixel(bmpImage, x, h), *dstbyte);
1793 dstbyte++;
1794 }
1795 dstbits += linebytes;
1796 }
1797 break;
1798 }
1799 }
1800
1801 /***********************************************************************
1802 * X11DRV_DIB_SetImageBits_RLE8
1803 *
1804 * SetDIBits for an 8-bit deep compressed DIB.
1805 *
1806 * This function rewritten 941113 by James Youngman. WINE blew out when I
1807 * first ran it because my desktop wallpaper is a (large) RLE8 bitmap.
1808 *
1809 * This was because the algorithm assumed that all RLE8 bitmaps end with the
1810 * 'End of bitmap' escape code. This code is very much laxer in what it
1811 * allows to end the expansion. Possibly too lax. See the note by
1812 * case RleDelta. BTW, MS's documentation implies that a correct RLE8
1813 * bitmap should end with RleEnd, but on the other hand, software exists
1814 * that produces ones that don't and Windows 3.1 doesn't complain a bit
1815 * about it.
1816 *
1817 * (No) apologies for my English spelling. [Emacs users: c-indent-level=4].
1818 * James A. Youngman <mbcstjy@afs.man.ac.uk>
1819 * [JAY]
1820 */
1821 static void X11DRV_DIB_SetImageBits_RLE8( int lines, const BYTE *bits,
1822 DWORD srcwidth, DWORD dstwidth,
1823 int left, int *colors,
1824 XImage *bmpImage )
1825 {
1826 unsigned int x; /* X-position on each line. Increases. */
1827 int y; /* Line #. Starts at lines-1, decreases */
1828 const BYTE *pIn = bits; /* Pointer to current position in bits */
1829 BYTE length; /* The length pf a run */
1830 BYTE escape_code; /* See enum Rle8_EscapeCodes.*/
1831
1832 /*
1833 * Note that the bitmap data is stored by Windows starting at the
1834 * bottom line of the bitmap and going upwards. Within each line,
1835 * the data is stored left-to-right. That's the reason why line
1836 * goes from lines-1 to 0. [JAY]
1837 */
1838
1839 x = 0;
1840 y = lines - 1;
1841 while (y >= 0)
1842 {
1843 length = *pIn++;
1844
1845 /*
1846 * If the length byte is not zero (which is the escape value),
1847 * We have a run of length pixels all the same colour. The colour
1848 * index is stored next.
1849 *
1850 * If the length byte is zero, we need to read the next byte to
1851 * know what to do. [JAY]
1852 */
1853 if (length != 0)
1854 {
1855 /*
1856 * [Run-Length] Encoded mode
1857 */
1858 int color = colors[*pIn++];
1859 while (length-- && x < (left + dstwidth)) {
1860 if( x >= left) XPutPixel(bmpImage, x, y, color);
1861 x++;
1862 }
1863 }
1864 else
1865 {
1866 /*
1867 * Escape codes (may be an absolute sequence though)
1868 */
1869 escape_code = (*pIn++);
1870 switch(escape_code)
1871 {
1872 case RLE_EOL:
1873 x = 0;
1874 y--;
1875 break;
1876
1877 case RLE_END:
1878 /* Not all RLE8 bitmaps end with this code. For
1879 * example, Paint Shop Pro produces some that don't.
1880 * That's (I think) what caused the previous
1881 * implementation to fail. [JAY]
1882 */
1883 return;
1884
1885 case RLE_DELTA:
1886 x += (*pIn++);
1887 y -= (*pIn++);
1888 break;
1889
1890 default: /* switch to absolute mode */
1891 length = escape_code;
1892 while (length--)
1893 {
1894 int color = colors[*pIn++];
1895 if (x >= (left + dstwidth))
1896 {
1897 pIn += length;
1898 break;
1899 }
1900 if( x >= left) XPutPixel(bmpImage, x, y, color);
1901 x++;
1902 }
1903 /*
1904 * If you think for a moment you'll realise that the
1905 * only time we could ever possibly read an odd
1906 * number of bytes is when there is a 0x00 (escape),
1907 * a value >0x02 (absolute mode) and then an odd-
1908 * length run. Therefore this is the only place we
1909 * need to worry about it. Everywhere else the
1910 * bytes are always read in pairs. [JAY]
1911 */
1912 if (escape_code & 1) pIn++; /* Throw away the pad byte. */
1913 break;
1914 } /* switch (escape_code) : Escape sequence */
1915 }
1916 }
1917 }
1918
1919
1920 /***********************************************************************
1921 * X11DRV_DIB_SetImageBits_16
1922 *
1923 * SetDIBits for a 16-bit deep DIB.
1924 */
1925 static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits,
1926 DWORD srcwidth, DWORD dstwidth, int left,
1927 X11DRV_PDEVICE *physDev, DWORD rSrc, DWORD gSrc, DWORD bSrc,
1928 XImage *bmpImage, int linebytes )
1929 {
1930 DWORD x;
1931 int h, width = min(srcwidth, dstwidth);
1932 const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
1933
1934 if (lines < 0 )
1935 {
1936 lines = -lines;
1937 srcbits = srcbits + ( linebytes * (lines-1));
1938 linebytes = -linebytes;
1939 }
1940
1941 switch (bmpImage->depth)
1942 {
1943 case 15:
1944 case 16:
1945 {
1946 char* dstbits;
1947
1948 srcbits=srcbits+left*2;
1949 dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
1950
1951 if (bmpImage->green_mask==0x03e0) {
1952 if (gSrc==bmpImage->green_mask) {
1953 if (rSrc==bmpImage->red_mask) {
1954 /* ==== rgb 555 dib -> rgb 555 bmp ==== */
1955 /* ==== bgr 555 dib -> bgr 555 bmp ==== */
1956 convs->Convert_5x5_asis
1957 (width,lines,
1958 srcbits,linebytes,
1959 dstbits,-bmpImage->bytes_per_line);
1960 } else if (rSrc==bmpImage->blue_mask) {
1961 /* ==== rgb 555 dib -> bgr 555 bmp ==== */
1962 /* ==== bgr 555 dib -> rgb 555 bmp ==== */
1963 convs->Convert_555_reverse
1964 (width,lines,
1965 srcbits,linebytes,
1966 dstbits,-bmpImage->bytes_per_line);
1967 }
1968 } else {
1969 if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
1970 /* ==== rgb 565 dib -> rgb 555 bmp ==== */
1971 /* ==== bgr 565 dib -> bgr 555 bmp ==== */
1972 convs->Convert_565_to_555_asis
1973 (width,lines,
1974 srcbits,linebytes,
1975 dstbits,-bmpImage->bytes_per_line);
1976 } else {
1977 /* ==== rgb 565 dib -> bgr 555 bmp ==== */
1978 /* ==== bgr 565 dib -> rgb 555 bmp ==== */
1979 convs->Convert_565_to_555_reverse
1980 (width,lines,
1981 srcbits,linebytes,
1982 dstbits,-bmpImage->bytes_per_line);
1983 }
1984 }
1985 } else if (bmpImage->green_mask==0x07e0) {
1986 if (gSrc==bmpImage->green_mask) {
1987 if (rSrc==bmpImage->red_mask) {
1988 /* ==== rgb 565 dib -> rgb 565 bmp ==== */
1989 /* ==== bgr 565 dib -> bgr 565 bmp ==== */
1990 convs->Convert_5x5_asis
1991 (width,lines,
1992 srcbits,linebytes,
1993 dstbits,-bmpImage->bytes_per_line);
1994 } else {
1995 /* ==== rgb 565 dib -> bgr 565 bmp ==== */
1996 /* ==== bgr 565 dib -> rgb 565 bmp ==== */
1997 convs->Convert_565_reverse
1998 (width,lines,
1999 srcbits,linebytes,
2000 dstbits,-bmpImage->bytes_per_line);
2001 }
2002 } else {
2003 if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
2004 /* ==== rgb 555 dib -> rgb 565 bmp ==== */
2005 /* ==== bgr 555 dib -> bgr 565 bmp ==== */
2006 convs->Convert_555_to_565_asis
2007 (width,lines,
2008 srcbits,linebytes,
2009 dstbits,-bmpImage->bytes_per_line);
2010 } else {
2011 /* ==== rgb 555 dib -> bgr 565 bmp ==== */
2012 /* ==== bgr 555 dib -> rgb 565 bmp ==== */
2013 convs->Convert_555_to_565_reverse
2014 (width,lines,
2015 srcbits,linebytes,
2016 dstbits,-bmpImage->bytes_per_line);
2017 }
2018 }
2019 } else {
2020 goto notsupported;
2021 }
2022 }
2023 break;
2024
2025 case 24:
2026 if (bmpImage->bits_per_pixel==24) {
2027 char* dstbits;
2028
2029 srcbits=srcbits+left*2;
2030 dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2031
2032 if (bmpImage->green_mask!=0x00ff00 ||
2033 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2034 goto notsupported;
2035 } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
2036 (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
2037 if (gSrc==0x03e0) {
2038 /* ==== rgb 555 dib -> rgb 888 bmp ==== */
2039 /* ==== bgr 555 dib -> bgr 888 bmp ==== */
2040 convs->Convert_555_to_888_asis
2041 (width,lines,
2042 srcbits,linebytes,
2043 dstbits,-bmpImage->bytes_per_line);
2044 } else {
2045 /* ==== rgb 565 dib -> rgb 888 bmp ==== */
2046 /* ==== bgr 565 dib -> bgr 888 bmp ==== */
2047 convs->Convert_565_to_888_asis
2048 (width,lines,
2049 srcbits,linebytes,
2050 dstbits,-bmpImage->bytes_per_line);
2051 }
2052 } else {
2053 if (gSrc==0x03e0) {
2054 /* ==== rgb 555 dib -> bgr 888 bmp ==== */
2055 /* ==== bgr 555 dib -> rgb 888 bmp ==== */
2056 convs->Convert_555_to_888_reverse
2057 (width,lines,
2058 srcbits,linebytes,
2059 dstbits,-bmpImage->bytes_per_line);
2060 } else {
2061 /* ==== rgb 565 dib -> bgr 888 bmp ==== */
2062 /* ==== bgr 565 dib -> rgb 888 bmp ==== */
2063 convs->Convert_565_to_888_reverse
2064 (width,lines,
2065 srcbits,linebytes,
2066 dstbits,-bmpImage->bytes_per_line);
2067 }
2068 }
2069 break;
2070 }
2071 /* Fall through */
2072
2073 case 32:
2074 {
2075 char* dstbits;
2076
2077 srcbits=srcbits+left*2;
2078 dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2079
2080 if (bmpImage->green_mask!=0x00ff00 ||
2081 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2082 goto notsupported;
2083 } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
2084 (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
2085 if (gSrc==0x03e0) {
2086 /* ==== rgb 555 dib -> rgb 0888 bmp ==== */
2087 /* ==== bgr 555 dib -> bgr 0888 bmp ==== */
2088 convs->Convert_555_to_0888_asis
2089 (width,lines,
2090 srcbits,linebytes,
2091 dstbits,-bmpImage->bytes_per_line);
2092 } else {
2093 /* ==== rgb 565 dib -> rgb 0888 bmp ==== */
2094 /* ==== bgr 565 dib -> bgr 0888 bmp ==== */
2095 convs->Convert_565_to_0888_asis
2096 (width,lines,
2097 srcbits,linebytes,
2098 dstbits,-bmpImage->bytes_per_line);
2099 }
2100 } else {
2101 if (gSrc==0x03e0) {
2102 /* ==== rgb 555 dib -> bgr 0888 bmp ==== */
2103 /* ==== bgr 555 dib -> rgb 0888 bmp ==== */
2104 convs->Convert_555_to_0888_reverse
2105 (width,lines,
2106 srcbits,linebytes,
2107 dstbits,-bmpImage->bytes_per_line);
2108 } else {
2109 /* ==== rgb 565 dib -> bgr 0888 bmp ==== */
2110 /* ==== bgr 565 dib -> rgb 0888 bmp ==== */
2111 convs->Convert_565_to_0888_reverse
2112 (width,lines,
2113 srcbits,linebytes,
2114 dstbits,-bmpImage->bytes_per_line);
2115 }
2116 }
2117 }
2118 break;
2119
2120 default:
2121 notsupported:
2122 WARN("from 16 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
2123 rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
2124 bmpImage->green_mask, bmpImage->blue_mask );
2125 /* fall through */
2126 case 1:
2127 case 4:
2128 case 8:
2129 {
2130 /* ==== rgb or bgr 555 or 565 dib -> pal 1, 4 or 8 ==== */
2131 const WORD* srcpixel;
2132 int rShift1,gShift1,bShift1;
2133 int rShift2,gShift2,bShift2;
2134 BYTE gMask1,gMask2;
2135
2136 /* Set color scaling values */
2137 rShift1=16+X11DRV_DIB_MaskToShift(rSrc)-3;
2138 gShift1=16+X11DRV_DIB_MaskToShift(gSrc)-3;
2139 bShift1=16+X11DRV_DIB_MaskToShift(bSrc)-3;
2140 rShift2=rShift1+5;
2141 gShift2=gShift1+5;
2142 bShift2=bShift1+5;
2143 if (gSrc==0x03e0) {
2144 /* Green has 5 bits, like the others */
2145 gMask1=0xf8;
2146 gMask2=0x07;
2147 } else {
2148 /* Green has 6 bits, not 5. Compensate. */
2149 gShift1++;
2150 gShift2+=2;
2151 gMask1=0xfc;
2152 gMask2=0x03;
2153 }
2154
2155 srcbits+=2*left;
2156
2157 /* We could split it into four separate cases to optimize
2158 * but it is probably not worth it.
2159 */
2160 for (h=lines-1; h>=0; h--) {
2161 srcpixel=(const WORD*)srcbits;
2162 for (x=left; x<width+left; x++) {
2163 DWORD srcval;
2164 BYTE red,green,blue;
2165 srcval=*srcpixel++ << 16;
2166 red= ((srcval >> rShift1) & 0xf8) |
2167 ((srcval >> rShift2) & 0x07);
2168 green=((srcval >> gShift1) & gMask1) |
2169 ((srcval >> gShift2) & gMask2);
2170 blue= ((srcval >> bShift1) & 0xf8) |
2171 ((srcval >> bShift2) & 0x07);
2172 XPutPixel(bmpImage, x, h,
2173 X11DRV_PALETTE_ToPhysical
2174 (physDev, RGB(red,green,blue)));
2175 }
2176 srcbits += linebytes;
2177 }
2178 }
2179 break;
2180 }
2181 }
2182
2183
2184 /***********************************************************************
2185 * X11DRV_DIB_GetImageBits_16
2186 *
2187 * GetDIBits for an 16-bit deep DIB.
2188 */
2189 static void X11DRV_DIB_GetImageBits_16( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
2190 DWORD dstwidth, DWORD srcwidth,
2191 PALETTEENTRY *srccolors,
2192 DWORD rDst, DWORD gDst, DWORD bDst,
2193 XImage *bmpImage, int linebytes )
2194 {
2195 DWORD x;
2196 int h, width = min(srcwidth, dstwidth);
2197 const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
2198
2199 if (lines < 0 )
2200 {
2201 lines = -lines;
2202 dstbits = dstbits + ( linebytes * (lines-1));
2203 linebytes = -linebytes;
2204 }
2205
2206 switch (bmpImage->depth)
2207 {
2208 case 15:
2209 case 16:
2210 {
2211 const char* srcbits;
2212
2213 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2214
2215 if (bmpImage->green_mask==0x03e0) {
2216 if (gDst==bmpImage->green_mask) {
2217 if (rDst==bmpImage->red_mask) {
2218 /* ==== rgb 555 bmp -> rgb 555 dib ==== */
2219 /* ==== bgr 555 bmp -> bgr 555 dib ==== */
2220 convs->Convert_5x5_asis
2221 (width,lines,
2222 srcbits,-bmpImage->bytes_per_line,
2223 dstbits,linebytes);
2224 } else {
2225 /* ==== rgb 555 bmp -> bgr 555 dib ==== */
2226 /* ==== bgr 555 bmp -> rgb 555 dib ==== */
2227 convs->Convert_555_reverse
2228 (width,lines,
2229 srcbits,-bmpImage->bytes_per_line,
2230 dstbits,linebytes);
2231 }
2232 } else {
2233 if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
2234 /* ==== rgb 555 bmp -> rgb 565 dib ==== */
2235 /* ==== bgr 555 bmp -> bgr 565 dib ==== */
2236 convs->Convert_555_to_565_asis
2237 (width,lines,
2238 srcbits,-bmpImage->bytes_per_line,
2239 dstbits,linebytes);
2240 } else {
2241 /* ==== rgb 555 bmp -> bgr 565 dib ==== */
2242 /* ==== bgr 555 bmp -> rgb 565 dib ==== */
2243 convs->Convert_555_to_565_reverse
2244 (width,lines,
2245 srcbits,-bmpImage->bytes_per_line,
2246 dstbits,linebytes);
2247 }
2248 }
2249 } else if (bmpImage->green_mask==0x07e0) {
2250 if (gDst==bmpImage->green_mask) {
2251 if (rDst == bmpImage->red_mask) {
2252 /* ==== rgb 565 bmp -> rgb 565 dib ==== */
2253 /* ==== bgr 565 bmp -> bgr 565 dib ==== */
2254 convs->Convert_5x5_asis
2255 (width,lines,
2256 srcbits,-bmpImage->bytes_per_line,
2257 dstbits,linebytes);
2258 } else {
2259 /* ==== rgb 565 bmp -> bgr 565 dib ==== */
2260 /* ==== bgr 565 bmp -> rgb 565 dib ==== */
2261 convs->Convert_565_reverse
2262 (width,lines,
2263 srcbits,-bmpImage->bytes_per_line,
2264 dstbits,linebytes);
2265 }
2266 } else {
2267 if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
2268 /* ==== rgb 565 bmp -> rgb 555 dib ==== */
2269 /* ==== bgr 565 bmp -> bgr 555 dib ==== */
2270 convs->Convert_565_to_555_asis
2271 (width,lines,
2272 srcbits,-bmpImage->bytes_per_line,
2273 dstbits,linebytes);
2274 } else {
2275 /* ==== rgb 565 bmp -> bgr 555 dib ==== */
2276 /* ==== bgr 565 bmp -> rgb 555 dib ==== */
2277 convs->Convert_565_to_555_reverse
2278 (width,lines,
2279 srcbits,-bmpImage->bytes_per_line,
2280 dstbits,linebytes);
2281 }
2282 }
2283 } else {
2284 goto notsupported;
2285 }
2286 }
2287 break;
2288
2289 case 24:
2290 if (bmpImage->bits_per_pixel == 24) {
2291 const char* srcbits;
2292
2293 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2294
2295 if (bmpImage->green_mask!=0x00ff00 ||
2296 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2297 goto notsupported;
2298 } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
2299 (bDst==0x1f && bmpImage->blue_mask==0xff)) {
2300 if (gDst==0x03e0) {
2301 /* ==== rgb 888 bmp -> rgb 555 dib ==== */
2302 /* ==== bgr 888 bmp -> bgr 555 dib ==== */
2303 convs->Convert_888_to_555_asis
2304 (width,lines,
2305 srcbits,-bmpImage->bytes_per_line,
2306 dstbits,linebytes);
2307 } else {
2308 /* ==== rgb 888 bmp -> rgb 565 dib ==== */
2309 /* ==== rgb 888 bmp -> rgb 565 dib ==== */
2310 convs->Convert_888_to_565_asis
2311 (width,lines,
2312 srcbits,-bmpImage->bytes_per_line,
2313 dstbits,linebytes);
2314 }
2315 } else {
2316 if (gDst==0x03e0) {
2317 /* ==== rgb 888 bmp -> bgr 555 dib ==== */
2318 /* ==== bgr 888 bmp -> rgb 555 dib ==== */
2319 convs->Convert_888_to_555_reverse
2320 (width,lines,
2321 srcbits,-bmpImage->bytes_per_line,
2322 dstbits,linebytes);
2323 } else {
2324 /* ==== rgb 888 bmp -> bgr 565 dib ==== */
2325 /* ==== bgr 888 bmp -> rgb 565 dib ==== */
2326 convs->Convert_888_to_565_reverse
2327 (width,lines,
2328 srcbits,-bmpImage->bytes_per_line,
2329 dstbits,linebytes);
2330 }
2331 }
2332 break;
2333 }
2334 /* Fall through */
2335
2336 case 32:
2337 {
2338 const char* srcbits;
2339
2340 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2341
2342 if (bmpImage->green_mask!=0x00ff00 ||
2343 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2344 goto notsupported;
2345 } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
2346 (bDst==0x1f && bmpImage->blue_mask==0xff)) {
2347 if (gDst==0x03e0) {
2348 /* ==== rgb 0888 bmp -> rgb 555 dib ==== */
2349 /* ==== bgr 0888 bmp -> bgr 555 dib ==== */
2350 convs->Convert_0888_to_555_asis
2351 (width,lines,
2352 srcbits,-bmpImage->bytes_per_line,
2353 dstbits,linebytes);
2354 } else {
2355 /* ==== rgb 0888 bmp -> rgb 565 dib ==== */
2356 /* ==== bgr 0888 bmp -> bgr 565 dib ==== */
2357 convs->Convert_0888_to_565_asis
2358 (width,lines,
2359 srcbits,-bmpImage->bytes_per_line,
2360 dstbits,linebytes);
2361 }
2362 } else {
2363 if (gDst==0x03e0) {
2364 /* ==== rgb 0888 bmp -> bgr 555 dib ==== */
2365 /* ==== bgr 0888 bmp -> rgb 555 dib ==== */
2366 convs->Convert_0888_to_555_reverse
2367 (width,lines,
2368 srcbits,-bmpImage->bytes_per_line,
2369 dstbits,linebytes);
2370 } else {
2371 /* ==== rgb 0888 bmp -> bgr 565 dib ==== */
2372 /* ==== bgr 0888 bmp -> rgb 565 dib ==== */
2373 convs->Convert_0888_to_565_reverse
2374 (width,lines,
2375 srcbits,-bmpImage->bytes_per_line,
2376 dstbits,linebytes);
2377 }
2378 }
2379 }
2380 break;
2381
2382 case 1:
2383 case 4:
2384 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2385 && srccolors) {
2386 /* ==== pal 1 or 4 bmp -> rgb or bgr 555 or 565 dib ==== */
2387 int rShift,gShift,bShift;
2388 WORD* dstpixel;
2389
2390 /* Shift everything 16 bits left so that all shifts are >0,
2391 * even for BGR DIBs. Then a single >> 16 will bring everything
2392 * back into place.
2393 */
2394 rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2395 gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2396 bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2397 if (gDst==0x07e0) {
2398 /* 6 bits for the green */
2399 gShift++;
2400 }
2401 rDst=rDst << 16;
2402 gDst=gDst << 16;
2403 bDst=bDst << 16;
2404 for (h = lines - 1; h >= 0; h--) {
2405 dstpixel=(LPWORD)dstbits;
2406 for (x = 0; x < width; x++) {
2407 PALETTEENTRY srcval;
2408 DWORD dstval;
2409 srcval=srccolors[XGetPixel(bmpImage, x, h)];
2410 dstval=((srcval.peRed << rShift) & rDst) |
2411 ((srcval.peGreen << gShift) & gDst) |
2412 ((srcval.peBlue << bShift) & bDst);
2413 *dstpixel++=dstval >> 16;
2414 }
2415 dstbits += linebytes;
2416 }
2417 } else {
2418 goto notsupported;
2419 }
2420 break;
2421
2422 case 8:
2423 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2424 && srccolors) {
2425 /* ==== pal 8 bmp -> rgb or bgr 555 or 565 dib ==== */
2426 int rShift,gShift,bShift;
2427 const BYTE* srcbits;
2428 const BYTE* srcpixel;
2429 WORD* dstpixel;
2430
2431 /* Shift everything 16 bits left so that all shifts are >0,
2432 * even for BGR DIBs. Then a single >> 16 will bring everything
2433 * back into place.
2434 */
2435 rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2436 gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2437 bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2438 if (gDst==0x07e0) {
2439 /* 6 bits for the green */
2440 gShift++;
2441 }
2442 rDst=rDst << 16;
2443 gDst=gDst << 16;
2444 bDst=bDst << 16;
2445 srcbits=(BYTE*)bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2446 for (h=0; h<lines; h++) {
2447 srcpixel=srcbits;
2448 dstpixel=(LPWORD)dstbits;
2449 for (x = 0; x < width; x++) {
2450 PALETTEENTRY srcval;
2451 DWORD dstval;
2452 srcval=srccolors[*srcpixel++];
2453 dstval=((srcval.peRed << rShift) & rDst) |
2454 ((srcval.peGreen << gShift) & gDst) |
2455 ((srcval.peBlue << bShift) & bDst);
2456 *dstpixel++=dstval >> 16;
2457 }
2458 srcbits -= bmpImage->bytes_per_line;
2459 dstbits += linebytes;
2460 }
2461 } else {
2462 goto notsupported;
2463 }
2464 break;
2465
2466 default:
2467 notsupported:
2468 {
2469 /* ==== any bmp format -> rgb or bgr 555 or 565 dib ==== */
2470 int rShift,gShift,bShift;
2471 WORD* dstpixel;
2472
2473 WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 16 bit DIB (%x,%x,%x)\n",
2474 bmpImage->depth, bmpImage->red_mask,
2475 bmpImage->green_mask, bmpImage->blue_mask,
2476 rDst, gDst, bDst);
2477
2478 /* Shift everything 16 bits left so that all shifts are >0,
2479 * even for BGR DIBs. Then a single >> 16 will bring everything
2480 * back into place.
2481 */
2482 rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2483 gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2484 bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2485 if (gDst==0x07e0) {
2486 /* 6 bits for the green */
2487 gShift++;
2488 }
2489 rDst=rDst << 16;
2490 gDst=gDst << 16;
2491 bDst=bDst << 16;
2492 for (h = lines - 1; h >= 0; h--) {
2493 dstpixel=(LPWORD)dstbits;
2494 for (x = 0; x < width; x++) {
2495 COLORREF srcval;
2496 DWORD dstval;
2497 srcval=X11DRV_PALETTE_ToLogical(physDev, XGetPixel(bmpImage, x, h));
2498 dstval=((GetRValue(srcval) << rShift) & rDst) |
2499 ((GetGValue(srcval) << gShift) & gDst) |
2500 ((GetBValue(srcval) << bShift) & bDst);
2501 *dstpixel++=dstval >> 16;
2502 }
2503 dstbits += linebytes;
2504 }
2505 }
2506 break;
2507 }
2508 }
2509
2510
2511 /***********************************************************************
2512 * X11DRV_DIB_SetImageBits_24
2513 *
2514 * SetDIBits for a 24-bit deep DIB.
2515 */
2516 static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits,
2517 DWORD srcwidth, DWORD dstwidth, int left,
2518 X11DRV_PDEVICE *physDev,
2519 DWORD rSrc, DWORD gSrc, DWORD bSrc,
2520 XImage *bmpImage, DWORD linebytes )
2521 {
2522 DWORD x;
2523 int h, width = min(srcwidth, dstwidth);
2524 const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
2525
2526 if (lines < 0 )
2527 {
2528 lines = -lines;
2529 srcbits = srcbits + linebytes * (lines - 1);
2530 linebytes = -linebytes;
2531 }
2532
2533 switch (bmpImage->depth)
2534 {
2535 case 24:
2536 if (bmpImage->bits_per_pixel==24) {
2537 char* dstbits;
2538
2539 srcbits=srcbits+left*3;
2540 dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2541
2542 if (bmpImage->green_mask!=0x00ff00 ||
2543 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2544 goto notsupported;
2545 } else if (rSrc==bmpImage->red_mask) {
2546 /* ==== rgb 888 dib -> rgb 888 bmp ==== */
2547 /* ==== bgr 888 dib -> bgr 888 bmp ==== */
2548 convs->Convert_888_asis
2549 (width,lines,
2550 srcbits,linebytes,
2551 dstbits,-bmpImage->bytes_per_line);
2552 } else {
2553 /* ==== rgb 888 dib -> bgr 888 bmp ==== */
2554 /* ==== bgr 888 dib -> rgb 888 bmp ==== */
2555 convs->Convert_888_reverse
2556 (width,lines,
2557 srcbits,linebytes,
2558 dstbits,-bmpImage->bytes_per_line);
2559 }
2560 break;
2561 }
2562 /* fall through */
2563
2564 case 32:
2565 {
2566 char* dstbits;
2567
2568 srcbits=srcbits+left*3;
2569 dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2570
2571 if (bmpImage->green_mask!=0x00ff00 ||
2572 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2573 goto notsupported;
2574 } else if (rSrc==bmpImage->red_mask) {
2575 /* ==== rgb 888 dib -> rgb 0888 bmp ==== */
2576 /* ==== bgr 888 dib -> bgr 0888 bmp ==== */
2577 convs->Convert_888_to_0888_asis
2578 (width,lines,
2579 srcbits,linebytes,
2580 dstbits,-bmpImage->bytes_per_line);
2581 } else {
2582 /* ==== rgb 888 dib -> bgr 0888 bmp ==== */
2583 /* ==== bgr 888 dib -> rgb 0888 bmp ==== */
2584 convs->Convert_888_to_0888_reverse
2585 (width,lines,
2586 srcbits,linebytes,
2587 dstbits,-bmpImage->bytes_per_line);
2588 }
2589 break;
2590 }
2591
2592 case 15:
2593 case 16:
2594 {
2595 char* dstbits;
2596
2597 srcbits=srcbits+left*3;
2598 dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
2599
2600 if (bmpImage->green_mask==0x03e0) {
2601 if ((rSrc==0xff0000 && bmpImage->red_mask==0x7f00) ||
2602 (bSrc==0xff0000 && bmpImage->blue_mask==0x7f00)) {
2603 /* ==== rgb 888 dib -> rgb 555 bmp ==== */
2604 /* ==== bgr 888 dib -> bgr 555 bmp ==== */
2605 convs->Convert_888_to_555_asis
2606 (width,lines,
2607 srcbits,linebytes,
2608 dstbits,-bmpImage->bytes_per_line);
2609 } else if ((rSrc==0xff && bmpImage->red_mask==0x7f00) ||
2610 (bSrc==0xff && bmpImage->blue_mask==0x7f00)) {
2611 /* ==== rgb 888 dib -> bgr 555 bmp ==== */
2612 /* ==== bgr 888 dib -> rgb 555 bmp ==== */
2613 convs->Convert_888_to_555_reverse
2614 (width,lines,
2615 srcbits,linebytes,
2616 dstbits,-bmpImage->bytes_per_line);
2617 } else {
2618 goto notsupported;
2619 }
2620 } else if (bmpImage->green_mask==0x07e0) {
2621 if ((rSrc==0xff0000 && bmpImage->red_mask==0xf800) ||
2622 (bSrc==0xff0000 && bmpImage->blue_mask==0xf800)) {
2623 /* ==== rgb 888 dib -> rgb 565 bmp ==== */
2624 /* ==== bgr 888 dib -> bgr 565 bmp ==== */
2625 convs->Convert_888_to_565_asis
2626 (width,lines,
2627 srcbits,linebytes,
2628 dstbits,-bmpImage->bytes_per_line);
2629 } else if ((rSrc==0xff && bmpImage->red_mask==0xf800) ||
2630 (bSrc==0xff && bmpImage->blue_mask==0xf800)) {
2631 /* ==== rgb 888 dib -> bgr 565 bmp ==== */
2632 /* ==== bgr 888 dib -> rgb 565 bmp ==== */
2633 convs->Convert_888_to_565_reverse
2634 (width,lines,
2635 srcbits,linebytes,
2636 dstbits,-bmpImage->bytes_per_line);
2637 } else {
2638 goto notsupported;
2639 }
2640 } else {
2641 goto notsupported;
2642 }
2643 }
2644 break;
2645
2646 default:
2647 notsupported:
2648 WARN("from 24 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
2649 rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
2650 bmpImage->green_mask, bmpImage->blue_mask );
2651 /* fall through */
2652 case 1:
2653 case 4:
2654 case 8:
2655 {
2656 /* ==== rgb 888 dib -> any bmp format ==== */
2657 const BYTE* srcbyte;
2658
2659 /* Windows only supports one 24bpp DIB format: RGB888 */
2660 srcbits+=left*3;
2661 for (h = lines - 1; h >= 0; h--) {
2662 srcbyte = srcbits;
2663 for (x = left; x < width+left; x++) {
2664 XPutPixel(bmpImage, x, h,
2665 X11DRV_PALETTE_ToPhysical
2666 (physDev, RGB(srcbyte[2], srcbyte[1], srcbyte[0])));
2667 srcbyte+=3;
2668 }
2669 srcbits += linebytes;
2670 }
2671 }
2672 break;
2673 }
2674 }
2675
2676
2677 /***********************************************************************
2678 * X11DRV_DIB_GetImageBits_24
2679 *
2680 * GetDIBits for an 24-bit deep DIB.
2681 */
2682 static void X11DRV_DIB_GetImageBits_24( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
2683 DWORD dstwidth, DWORD srcwidth,
2684 PALETTEENTRY *srccolors,
2685 DWORD rDst, DWORD gDst, DWORD bDst,
2686 XImage *bmpImage, DWORD linebytes )
2687 {
2688 DWORD x;
2689 int h, width = min(srcwidth, dstwidth);
2690 const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
2691
2692 if (lines < 0 )
2693 {
2694 lines = -lines;
2695 dstbits = dstbits + ( linebytes * (lines-1) );
2696 linebytes = -linebytes;
2697 }
2698
2699 switch (bmpImage->depth)
2700 {
2701 case 24:
2702 if (bmpImage->bits_per_pixel==24) {
2703 const char* srcbits;
2704
2705 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2706
2707 if (bmpImage->green_mask!=0x00ff00 ||
2708 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2709 goto notsupported;
2710 } else if (rDst==bmpImage->red_mask) {
2711 /* ==== rgb 888 bmp -> rgb 888 dib ==== */
2712 /* ==== bgr 888 bmp -> bgr 888 dib ==== */
2713 convs->Convert_888_asis
2714 (width,lines,
2715 srcbits,-bmpImage->bytes_per_line,
2716 dstbits,linebytes);
2717 } else {
2718 /* ==== rgb 888 bmp -> bgr 888 dib ==== */
2719 /* ==== bgr 888 bmp -> rgb 888 dib ==== */
2720 convs->Convert_888_reverse
2721 (width,lines,
2722 srcbits,-bmpImage->bytes_per_line,
2723 dstbits,linebytes);
2724 }
2725 break;
2726 }
2727 /* fall through */
2728
2729 case 32:
2730 {
2731 const char* srcbits;
2732
2733 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2734
2735 if (bmpImage->green_mask!=0x00ff00 ||
2736 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2737 goto notsupported;
2738 } else if (rDst==bmpImage->red_mask) {
2739 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
2740 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
2741 convs->Convert_0888_to_888_asis
2742 (width,lines,
2743 srcbits,-bmpImage->bytes_per_line,
2744 dstbits,linebytes);
2745 } else {
2746 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
2747 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
2748 convs->Convert_0888_to_888_reverse
2749 (width,lines,
2750 srcbits,-bmpImage->bytes_per_line,
2751 dstbits,linebytes);
2752 }
2753 break;
2754 }
2755
2756 case 15:
2757 case 16:
2758 {
2759 const char* srcbits;
2760
2761 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2762
2763 if (bmpImage->green_mask==0x03e0) {
2764 if ((rDst==0xff0000 && bmpImage->red_mask==0x7f00) ||
2765 (bDst==0xff0000 && bmpImage->blue_mask==0x7f00)) {
2766 /* ==== rgb 555 bmp -> rgb 888 dib ==== */
2767 /* ==== bgr 555 bmp -> bgr 888 dib ==== */
2768 convs->Convert_555_to_888_asis
2769 (width,lines,
2770 srcbits,-bmpImage->bytes_per_line,
2771 dstbits,linebytes);
2772 } else if ((rDst==0xff && bmpImage->red_mask==0x7f00) ||
2773 (bDst==0xff && bmpImage->blue_mask==0x7f00)) {
2774 /* ==== rgb 555 bmp -> bgr 888 dib ==== */
2775 /* ==== bgr 555 bmp -> rgb 888 dib ==== */
2776 convs->Convert_555_to_888_reverse
2777 (width,lines,
2778 srcbits,-bmpImage->bytes_per_line,
2779 dstbits,linebytes);
2780 } else {
2781 goto notsupported;
2782 }
2783 } else if (bmpImage->green_mask==0x07e0) {
2784 if ((rDst==0xff0000 && bmpImage->red_mask==0xf800) ||
2785 (bDst==0xff0000 && bmpImage->blue_mask==0xf800)) {
2786 /* ==== rgb 565 bmp -> rgb 888 dib ==== */
2787 /* ==== bgr 565 bmp -> bgr 888 dib ==== */
2788 convs->Convert_565_to_888_asis
2789 (width,lines,
2790 srcbits,-bmpImage->bytes_per_line,
2791 dstbits,linebytes);
2792 } else if ((rDst==0xff && bmpImage->red_mask==0xf800) ||
2793 (bDst==0xff && bmpImage->blue_mask==0xf800)) {
2794 /* ==== rgb 565 bmp -> bgr 888 dib ==== */
2795 /* ==== bgr 565 bmp -> rgb 888 dib ==== */
2796 convs->Convert_565_to_888_reverse
2797 (width,lines,
2798 srcbits,-bmpImage->bytes_per_line,
2799 dstbits,linebytes);
2800 } else {
2801 goto notsupported;
2802 }
2803 } else {
2804 goto notsupported;
2805 }
2806 }
2807 break;
2808
2809 case 1:
2810 case 4:
2811 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2812 && srccolors) {
2813 /* ==== pal 1 or 4 bmp -> rgb 888 dib ==== */
2814 BYTE* dstbyte;
2815
2816 /* Windows only supports one 24bpp DIB format: rgb 888 */
2817 for (h = lines - 1; h >= 0; h--) {
2818 dstbyte=dstbits;
2819 for (x = 0; x < width; x++) {
2820 PALETTEENTRY srcval;
2821 srcval=srccolors[XGetPixel(bmpImage, x, h)];
2822 dstbyte[0]=srcval.peBlue;
2823 dstbyte[1]=srcval.peGreen;
2824 dstbyte[2]=srcval.peRed;
2825 dstbyte+=3;
2826 }
2827 dstbits += linebytes;
2828 }
2829 } else {
2830 goto notsupported;
2831 }
2832 break;
2833
2834 case 8:
2835 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2836 && srccolors) {
2837 /* ==== pal 8 bmp -> rgb 888 dib ==== */
2838 const void* srcbits;
2839 const BYTE* srcpixel;
2840 BYTE* dstbyte;
2841
2842 /* Windows only supports one 24bpp DIB format: rgb 888 */
2843 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2844 for (h = lines - 1; h >= 0; h--) {
2845 srcpixel=srcbits;
2846 dstbyte=dstbits;
2847 for (x = 0; x < width; x++ ) {
2848 PALETTEENTRY srcval;
2849 srcval=srccolors[*srcpixel++];
2850 dstbyte[0]=srcval.peBlue;
2851 dstbyte[1]=srcval.peGreen;
2852 dstbyte[2]=srcval.peRed;
2853 dstbyte+=3;
2854 }
2855 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
2856 dstbits += linebytes;
2857 }
2858 } else {
2859 goto notsupported;
2860 }
2861 break;
2862
2863 default:
2864 notsupported:
2865 {
2866 /* ==== any bmp format -> 888 dib ==== */
2867 BYTE* dstbyte;
2868
2869 WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 24 bit DIB (%x,%x,%x)\n",
2870 bmpImage->depth, bmpImage->red_mask,
2871 bmpImage->green_mask, bmpImage->blue_mask,
2872 rDst, gDst, bDst );
2873
2874 /* Windows only supports one 24bpp DIB format: rgb 888 */
2875 for (h = lines - 1; h >= 0; h--) {
2876 dstbyte=dstbits;
2877 for (x = 0; x < width; x++) {
2878 COLORREF srcval=X11DRV_PALETTE_ToLogical
2879 (physDev, XGetPixel( bmpImage, x, h ));
2880 dstbyte[0]=GetBValue(srcval);
2881 dstbyte[1]=GetGValue(srcval);
2882 dstbyte[2]=GetRValue(srcval);
2883 dstbyte+=3;
2884 }
2885 dstbits += linebytes;
2886 }
2887 }
2888 break;
2889 }
2890 }
2891
2892
2893 /***********************************************************************
2894 * X11DRV_DIB_SetImageBits_32
2895 *
2896 * SetDIBits for a 32-bit deep DIB.
2897 */
2898 static void X11DRV_DIB_SetImageBits_32(int lines, const BYTE *srcbits,
2899 DWORD srcwidth, DWORD dstwidth, int left,
2900 X11DRV_PDEVICE *physDev,
2901 DWORD rSrc, DWORD gSrc, DWORD bSrc,
2902 XImage *bmpImage,
2903 DWORD linebytes)
2904 {
2905 DWORD x;
2906 int h, width = min(srcwidth, dstwidth);
2907 const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
2908
2909 if (lines < 0 )
2910 {
2911 lines = -lines;
2912 srcbits = srcbits + ( linebytes * (lines-1) );
2913 linebytes = -linebytes;
2914 }
2915
2916 switch (bmpImage->depth)
2917 {
2918 case 24:
2919 if (bmpImage->bits_per_pixel==24) {
2920 char* dstbits;
2921
2922 srcbits=srcbits+left*4;
2923 dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2924
2925 if (rSrc==bmpImage->red_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->blue_mask) {
2926 /* ==== rgb 0888 dib -> rgb 888 bmp ==== */
2927 /* ==== bgr 0888 dib -> bgr 888 bmp ==== */
2928 convs->Convert_0888_to_888_asis
2929 (width,lines,
2930 srcbits,linebytes,
2931 dstbits,-bmpImage->bytes_per_line);
2932 } else if (bmpImage->green_mask!=0x00ff00 ||
2933 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2934 goto notsupported;
2935 /* the tests below assume sane bmpImage masks */
2936 } else if (rSrc==bmpImage->blue_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->red_mask) {
2937 /* ==== rgb 0888 dib -> bgr 888 bmp ==== */
2938 /* ==== bgr 0888 dib -> rgb 888 bmp ==== */
2939 convs->Convert_0888_to_888_reverse
2940 (width,lines,
2941 srcbits,linebytes,
2942 dstbits,-bmpImage->bytes_per_line);
2943 } else if (bmpImage->blue_mask==0xff) {
2944 /* ==== any 0888 dib -> rgb 888 bmp ==== */
2945 convs->Convert_any0888_to_rgb888
2946 (width,lines,
2947 srcbits,linebytes,
2948 rSrc,gSrc,bSrc,
2949 dstbits,-bmpImage->bytes_per_line);
2950 } else {
2951 /* ==== any 0888 dib -> bgr 888 bmp ==== */
2952 convs->Convert_any0888_to_bgr888
2953 (width,lines,
2954 srcbits,linebytes,
2955 rSrc,gSrc,bSrc,
2956 dstbits,-bmpImage->bytes_per_line);
2957 }
2958 break;
2959 }
2960 /* fall through */
2961
2962 case 32:
2963 {
2964 char* dstbits;
2965
2966 srcbits=srcbits+left*4;
2967 dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2968
2969 if (gSrc==bmpImage->green_mask) {
2970 if (rSrc==bmpImage->red_mask && bSrc==bmpImage->blue_mask) {
2971 /* ==== rgb 0888 dib -> rgb 0888 bmp ==== */
2972 /* ==== bgr 0888 dib -> bgr 0888 bmp ==== */
2973 convs->Convert_0888_asis
2974 (width,lines,
2975 srcbits,linebytes,
2976 dstbits,-bmpImage->bytes_per_line);
2977 } else if (bmpImage->green_mask!=0x00ff00 ||
2978 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2979 goto notsupported;
2980 /* the tests below assume sane bmpImage masks */
2981 } else if (rSrc==bmpImage->blue_mask && bSrc==bmpImage->red_mask) {
2982 /* ==== rgb 0888 dib -> bgr 0888 bmp ==== */
2983 /* ==== bgr 0888 dib -> rgb 0888 bmp ==== */
2984 convs->Convert_0888_reverse
2985 (width,lines,
2986 srcbits,linebytes,
2987 dstbits,-bmpImage->bytes_per_line);
2988 } else {
2989 /* ==== any 0888 dib -> any 0888 bmp ==== */
2990 convs->Convert_0888_any
2991 (width,lines,
2992 srcbits,linebytes,
2993 rSrc,gSrc,bSrc,
2994 dstbits,-bmpImage->bytes_per_line,
2995 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
2996 }
2997 } else if (bmpImage->green_mask!=0x00ff00 ||
2998 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2999 goto notsupported;
3000 /* the tests below assume sane bmpImage masks */
3001 } else {
3002 /* ==== any 0888 dib -> any 0888 bmp ==== */
3003 convs->Convert_0888_any
3004 (width,lines,
3005 srcbits,linebytes,
3006 rSrc,gSrc,bSrc,
3007 dstbits,-bmpImage->bytes_per_line,
3008 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3009 }
3010 }
3011 break;
3012
3013 case 15:
3014 case 16:
3015 {
3016 char* dstbits;
3017
3018 srcbits=srcbits+left*4;
3019 dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
3020
3021 if (rSrc==0xff0000 && gSrc==0x00ff00 && bSrc==0x0000ff) {
3022 if (bmpImage->green_mask==0x03e0) {
3023 if (bmpImage->red_mask==0x7f00) {
3024 /* ==== rgb 0888 dib -> rgb 555 bmp ==== */
3025 convs->Convert_0888_to_555_asis
3026 (width,lines,
3027 srcbits,linebytes,
3028 dstbits,-bmpImage->bytes_per_line);
3029 } else if (bmpImage->blue_mask==0x7f00) {
3030 /* ==== rgb 0888 dib -> bgr 555 bmp ==== */
3031 convs->Convert_0888_to_555_reverse
3032 (width,lines,
3033 srcbits,linebytes,
3034 dstbits,-bmpImage->bytes_per_line);
3035 } else {
3036 goto notsupported;
3037 }
3038 } else if (bmpImage->green_mask==0x07e0) {
3039 if (bmpImage->red_mask==0xf800) {
3040 /* ==== rgb 0888 dib -> rgb 565 bmp ==== */
3041 convs->Convert_0888_to_565_asis
3042 (width,lines,
3043 srcbits,linebytes,
3044 dstbits,-bmpImage->bytes_per_line);
3045 } else if (bmpImage->blue_mask==0xf800) {
3046 /* ==== rgb 0888 dib -> bgr 565 bmp ==== */
3047 convs->Convert_0888_to_565_reverse
3048 (width,lines,
3049 srcbits,linebytes,
3050 dstbits,-bmpImage->bytes_per_line);
3051 } else {
3052 goto notsupported;
3053 }
3054 } else {
3055 goto notsupported;
3056 }
3057 } else if (rSrc==0x0000ff && gSrc==0x00ff00 && bSrc==0xff0000) {
3058 if (bmpImage->green_mask==0x03e0) {
3059 if (bmpImage->blue_mask==0x7f00) {
3060 /* ==== bgr 0888 dib -> bgr 555 bmp ==== */
3061 convs->Convert_0888_to_555_asis
3062 (width,lines,
3063 srcbits,linebytes,
3064 dstbits,-bmpImage->bytes_per_line);
3065 } else if (bmpImage->red_mask==0x7f00) {
3066 /* ==== bgr 0888 dib -> rgb 555 bmp ==== */
3067 convs->Convert_0888_to_555_reverse
3068 (width,lines,
3069 srcbits,linebytes,
3070 dstbits,-bmpImage->bytes_per_line);
3071 } else {
3072 goto notsupported;
3073 }
3074 } else if (bmpImage->green_mask==0x07e0) {
3075 if (bmpImage->blue_mask==0xf800) {
3076 /* ==== bgr 0888 dib -> bgr 565 bmp ==== */
3077 convs->Convert_0888_to_565_asis
3078 (width,lines,
3079 srcbits,linebytes,
3080 dstbits,-bmpImage->bytes_per_line);
3081 } else if (bmpImage->red_mask==0xf800) {
3082 /* ==== bgr 0888 dib -> rgb 565 bmp ==== */
3083 convs->Convert_0888_to_565_reverse
3084 (width,lines,
3085 srcbits,linebytes,
3086 dstbits,-bmpImage->bytes_per_line);
3087 } else {
3088 goto notsupported;
3089 }
3090 } else {
3091 goto notsupported;
3092 }
3093 } else {
3094 if (bmpImage->green_mask==0x03e0 &&
3095 (bmpImage->red_mask==0x7f00 ||
3096 bmpImage->blue_mask==0x7f00)) {
3097 /* ==== any 0888 dib -> rgb or bgr 555 bmp ==== */
3098 convs->Convert_any0888_to_5x5
3099 (width,lines,
3100 srcbits,linebytes,
3101 rSrc,gSrc,bSrc,
3102 dstbits,-bmpImage->bytes_per_line,
3103 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3104 } else if (bmpImage->green_mask==0x07e0 &&
3105 (bmpImage->red_mask==0xf800 ||
3106 bmpImage->blue_mask==0xf800)) {
3107 /* ==== any 0888 dib -> rgb or bgr 565 bmp ==== */
3108 convs->Convert_any0888_to_5x5
3109 (width,lines,
3110 srcbits,linebytes,
3111 rSrc,gSrc,bSrc,
3112 dstbits,-bmpImage->bytes_per_line,
3113 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3114 } else {
3115 goto notsupported;
3116 }
3117 }
3118 }
3119 break;
3120
3121 default:
3122 notsupported:
3123 WARN("from 32 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
3124 rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
3125 bmpImage->green_mask, bmpImage->blue_mask );
3126 /* fall through */
3127 case 1:
3128 case 4:
3129 case 8:
3130 {
3131 /* ==== any 0888 dib -> pal 1, 4 or 8 bmp ==== */
3132 const DWORD* srcpixel;
3133 int rShift,gShift,bShift;
3134
3135 rShift=X11DRV_DIB_MaskToShift(rSrc);
3136 gShift=X11DRV_DIB_MaskToShift(gSrc);
3137 bShift=X11DRV_DIB_MaskToShift(bSrc);
3138 srcbits+=left*4;
3139 for (h = lines - 1; h >= 0; h--) {
3140 srcpixel=(const DWORD*)srcbits;
3141 for (x = left; x < width+left; x++) {
3142 DWORD srcvalue;
3143 BYTE red,green,blue;
3144 srcvalue=*srcpixel++;
3145 red= (srcvalue >> rShift) & 0xff;
3146 green=(srcvalue >> gShift) & 0xff;
3147 blue= (srcvalue >> bShift) & 0xff;
3148 XPutPixel(bmpImage, x, h, X11DRV_PALETTE_ToPhysical
3149 (physDev, RGB(red,green,blue)));
3150 }
3151 srcbits += linebytes;
3152 }
3153 }
3154 break;
3155 }
3156
3157 }
3158
3159 /***********************************************************************
3160 * X11DRV_DIB_GetImageBits_32
3161 *
3162 * GetDIBits for an 32-bit deep DIB.
3163 */
3164 static void X11DRV_DIB_GetImageBits_32( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
3165 DWORD dstwidth, DWORD srcwidth,
3166 PALETTEENTRY *srccolors,
3167 DWORD rDst, DWORD gDst, DWORD bDst,
3168 XImage *bmpImage, int linebytes )
3169 {
3170 DWORD x;
3171 int h, width = min(srcwidth, dstwidth);
3172 const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
3173
3174 if (lines < 0 )
3175 {
3176 lines = -lines;
3177 dstbits = dstbits + ( linebytes * (lines-1) );
3178 linebytes = -linebytes;
3179 }
3180
3181 switch (bmpImage->depth)
3182 {
3183 case 24:
3184 if (bmpImage->bits_per_pixel==24) {
3185 const void* srcbits;
3186
3187 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3188
3189 if (rDst==bmpImage->red_mask && gDst==bmpImage->green_mask && bDst==bmpImage->blue_mask) {
3190 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
3191 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
3192 convs->Convert_888_to_0888_asis
3193 (width,lines,
3194 srcbits,-bmpImage->bytes_per_line,
3195 dstbits,linebytes);
3196 } else if (bmpImage->green_mask!=0x00ff00 ||
3197 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3198 goto notsupported;
3199 /* the tests below assume sane bmpImage masks */
3200 } else if (rDst==bmpImage->blue_mask && gDst==bmpImage->green_mask && bDst==bmpImage->red_mask) {
3201 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
3202 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
3203 convs->Convert_888_to_0888_reverse
3204 (width,lines,
3205 srcbits,-bmpImage->bytes_per_line,
3206 dstbits,linebytes);
3207 } else if (bmpImage->blue_mask==0xff) {
3208 /* ==== rgb 888 bmp -> any 0888 dib ==== */
3209 convs->Convert_rgb888_to_any0888
3210 (width,lines,
3211 srcbits,-bmpImage->bytes_per_line,
3212 dstbits,linebytes,
3213 rDst,gDst,bDst);
3214 } else {
3215 /* ==== bgr 888 bmp -> any 0888 dib ==== */
3216 convs->Convert_bgr888_to_any0888
3217 (width,lines,
3218 srcbits,-bmpImage->bytes_per_line,
3219 dstbits,linebytes,
3220 rDst,gDst,bDst);
3221 }
3222 break;
3223 }
3224 /* fall through */
3225
3226 case 32:
3227 {
3228 const char* srcbits;
3229
3230 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3231
3232 if (gDst==bmpImage->green_mask) {
3233 if (rDst==bmpImage->red_mask && bDst==bmpImage->blue_mask) {
3234 /* ==== rgb 0888 bmp -> rgb 0888 dib ==== */
3235 /* ==== bgr 0888 bmp -> bgr 0888 dib ==== */
3236 convs->Convert_0888_asis
3237 (width,lines,
3238 srcbits,-bmpImage->bytes_per_line,
3239 dstbits,linebytes);
3240 } else if (bmpImage->green_mask!=0x00ff00 ||
3241 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3242 goto notsupported;
3243 /* the tests below assume sane bmpImage masks */
3244 } else if (rDst==bmpImage->blue_mask && bDst==bmpImage->red_mask) {
3245 /* ==== rgb 0888 bmp -> bgr 0888 dib ==== */
3246 /* ==== bgr 0888 bmp -> rgb 0888 dib ==== */
3247 convs->Convert_0888_reverse
3248 (width,lines,
3249 srcbits,-bmpImage->bytes_per_line,
3250 dstbits,linebytes);
3251 } else {
3252 /* ==== any 0888 bmp -> any 0888 dib ==== */
3253 convs->Convert_0888_any
3254 (width,lines,
3255 srcbits,-bmpImage->bytes_per_line,
3256 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3257 dstbits,linebytes,
3258 rDst,gDst,bDst);
3259 }
3260 } else if (bmpImage->green_mask!=0x00ff00 ||
3261 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3262 goto notsupported;
3263 /* the tests below assume sane bmpImage masks */
3264 } else {
3265 /* ==== any 0888 bmp -> any 0888 dib ==== */
3266 convs->Convert_0888_any
3267 (width,lines,
3268 srcbits,-bmpImage->bytes_per_line,
3269 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3270 dstbits,linebytes,
3271 rDst,gDst,bDst);
3272 }
3273 }
3274 break;
3275
3276 case 15:
3277 case 16:
3278 {
3279 const char* srcbits;
3280
3281 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3282
3283 if (rDst==0xff0000 && gDst==0x00ff00 && bDst==0x0000ff) {
3284 if (bmpImage->green_mask==0x03e0) {
3285 if (bmpImage->red_mask==0x7f00) {
3286 /* ==== rgb 555 bmp -> rgb 0888 dib ==== */
3287 convs->Convert_555_to_0888_asis
3288 (width,lines,
3289 srcbits,-bmpImage->bytes_per_line,
3290 dstbits,linebytes);
3291 } else if (bmpImage->blue_mask==0x7f00) {
3292 /* ==== bgr 555 bmp -> rgb 0888 dib ==== */
3293 convs->Convert_555_to_0888_reverse
3294 (width,lines,
3295 srcbits,-bmpImage->bytes_per_line,
3296 dstbits,linebytes);
3297 } else {
3298 goto notsupported;
3299 }
3300 } else if (bmpImage->green_mask==0x07e0) {
3301 if (bmpImage->red_mask==0xf800) {
3302 /* ==== rgb 565 bmp -> rgb 0888 dib ==== */
3303 convs->Convert_565_to_0888_asis
3304 (width,lines,
3305 srcbits,-bmpImage->bytes_per_line,
3306 dstbits,linebytes);
3307 } else if (bmpImage->blue_mask==0xf800) {
3308 /* ==== bgr 565 bmp -> rgb 0888 dib ==== */
3309 convs->Convert_565_to_0888_reverse
3310 (width,lines,
3311 srcbits,-bmpImage->bytes_per_line,
3312 dstbits,linebytes);
3313 } else {
3314 goto notsupported;
3315 }
3316 } else {
3317 goto notsupported;
3318 }
3319 } else if (rDst==0x0000ff && gDst==0x00ff00 && bDst==0xff0000) {
3320 if (bmpImage->green_mask==0x03e0) {
3321 if (bmpImage->blue_mask==0x7f00) {
3322 /* ==== bgr 555 bmp -> bgr 0888 dib ==== */
3323 convs->Convert_555_to_0888_asis
3324 (width,lines,
3325 srcbits,-bmpImage->bytes_per_line,
3326 dstbits,linebytes);
3327 } else if (bmpImage->red_mask==0x7f00) {
3328 /* ==== rgb 555 bmp -> bgr 0888 dib ==== */
3329 convs->Convert_555_to_0888_reverse
3330 (width,lines,
3331 srcbits,-bmpImage->bytes_per_line,
3332 dstbits,linebytes);
3333 } else {
3334 goto notsupported;
3335 }
3336 } else if (bmpImage->green_mask==0x07e0) {
3337 if (bmpImage->blue_mask==0xf800) {
3338 /* ==== bgr 565 bmp -> bgr 0888 dib ==== */
3339 convs->Convert_565_to_0888_asis
3340 (width,lines,
3341 srcbits,-bmpImage->bytes_per_line,
3342 dstbits,linebytes);
3343 } else if (bmpImage->red_mask==0xf800) {
3344 /* ==== rgb 565 bmp -> bgr 0888 dib ==== */
3345 convs->Convert_565_to_0888_reverse
3346 (width,lines,
3347 srcbits,-bmpImage->bytes_per_line,
3348 dstbits,linebytes);
3349 } else {
3350 goto notsupported;
3351 }
3352 } else {
3353 goto notsupported;
3354 }
3355 } else {
3356 if (bmpImage->green_mask==0x03e0 &&
3357 (bmpImage->red_mask==0x7f00 ||
3358 bmpImage->blue_mask==0x7f00)) {
3359 /* ==== rgb or bgr 555 bmp -> any 0888 dib ==== */
3360 convs->Convert_5x5_to_any0888
3361 (width,lines,
3362 srcbits,-bmpImage->bytes_per_line,
3363 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3364 dstbits,linebytes,
3365 rDst,gDst,bDst);
3366 } else if (bmpImage->green_mask==0x07e0 &&
3367 (bmpImage->red_mask==0xf800 ||
3368 bmpImage->blue_mask==0xf800)) {
3369 /* ==== rgb or bgr 565 bmp -> any 0888 dib ==== */
3370 convs->Convert_5x5_to_any0888
3371 (width,lines,
3372 srcbits,-bmpImage->bytes_per_line,
3373 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3374 dstbits,linebytes,
3375 rDst,gDst,bDst);
3376 } else {
3377 goto notsupported;
3378 }
3379 }
3380 }
3381 break;
3382
3383 case 1:
3384 case 4:
3385 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
3386 && srccolors) {
3387 /* ==== pal 1 or 4 bmp -> any 0888 dib ==== */
3388 int rShift,gShift,bShift;
3389 DWORD* dstpixel;
3390
3391 rShift=X11DRV_DIB_MaskToShift(rDst);
3392 gShift=X11DRV_DIB_MaskToShift(gDst);
3393 bShift=X11DRV_DIB_MaskToShift(bDst);
3394 for (h = lines - 1; h >= 0; h--) {
3395 dstpixel=(DWORD*)dstbits;
3396 for (x = 0; x < width; x++) {
3397 PALETTEENTRY srcval;
3398 srcval = srccolors[XGetPixel(bmpImage, x, h)];
3399 *dstpixel++=(srcval.peRed << rShift) |
3400 (srcval.peGreen << gShift) |
3401 (srcval.peBlue << bShift);
3402 }
3403 dstbits += linebytes;
3404 }
3405 } else {
3406 goto notsupported;
3407 }
3408 break;
3409
3410 case 8:
3411 if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
3412 && srccolors) {
3413 /* ==== pal 8 bmp -> any 0888 dib ==== */
3414 int rShift,gShift,bShift;
3415 const void* srcbits;
3416 const BYTE* srcpixel;
3417 DWORD* dstpixel;
3418
3419 rShift=X11DRV_DIB_MaskToShift(rDst);
3420 gShift=X11DRV_DIB_MaskToShift(gDst);
3421 bShift=X11DRV_DIB_MaskToShift(bDst);
3422 srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3423 for (h = lines - 1; h >= 0; h--) {
3424 srcpixel=srcbits;
3425 dstpixel=(DWORD*)dstbits;
3426 for (x = 0; x < width; x++) {
3427 PALETTEENTRY srcval;
3428 srcval=srccolors[*srcpixel++];
3429 *dstpixel++=(srcval.peRed << rShift) |
3430 (srcval.peGreen << gShift) |
3431 (srcval.peBlue << bShift);
3432 }
3433 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
3434 dstbits += linebytes;
3435 }
3436 } else {
3437 goto notsupported;
3438 }
3439 break;
3440
3441 default:
3442 notsupported:
3443 {
3444 /* ==== any bmp format -> any 0888 dib ==== */
3445 int rShift,gShift,bShift;
3446 DWORD* dstpixel;
3447
3448 WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 32 bit DIB (%x,%x,%x)\n",
3449 bmpImage->depth, bmpImage->red_mask,
3450 bmpImage->green_mask, bmpImage->blue_mask,
3451 rDst,gDst,bDst);
3452
3453 rShift=X11DRV_DIB_MaskToShift(rDst);
3454 gShift=X11DRV_DIB_MaskToShift(gDst);
3455 bShift=X11DRV_DIB_MaskToShift(bDst);
3456 for (h = lines - 1; h >= 0; h--) {
3457 dstpixel=(DWORD*)dstbits;
3458 for (x = 0; x < width; x++) {
3459 COLORREF srcval;
3460 srcval=X11DRV_PALETTE_ToLogical(physDev, XGetPixel(bmpImage, x, h));
3461 *dstpixel++=(GetRValue(srcval) << rShift) |
3462 (GetGValue(srcval) << gShift) |
3463 (GetBValue(srcval) << bShift);
3464 }
3465 dstbits += linebytes;
3466 }
3467 }
3468 break;
3469 }
3470 }
3471
3472 static int XGetSubImageErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
3473 {
3474 return (event->request_code == X_GetImage && event->error_code == BadMatch);
3475 }
3476
3477 /***********************************************************************
3478 * X11DRV_DIB_SetImageBits_GetSubImage
3479 *
3480 * Helper for X11DRV_DIB_SetImageBits
3481 */
3482 static void X11DRV_DIB_SetImageBits_GetSubImage(
3483 const X11DRV_DIB_IMAGEBITS_DESCR *descr, XImage *bmpImage)
3484 {
3485 /* compressed bitmaps may contain gaps in them. So make a copy
3486 * of the existing pixels first */
3487 RECT bmprc, rc;
3488
3489 SetRect( &bmprc, descr->xDest, descr->yDest,
3490 descr->xDest + descr->width , descr->yDest + descr->height );
3491 GetRgnBox( descr->physDev->region, &rc );
3492 /* convert from dc to drawable origin */
3493 OffsetRect( &rc, descr->physDev->dc_rect.left, descr->physDev->dc_rect.top);
3494 /* clip visible rect with bitmap */
3495 if( IntersectRect( &rc, &rc, &bmprc))
3496 {
3497 X11DRV_expect_error( gdi_display, XGetSubImageErrorHandler, NULL );
3498 XGetSubImage( gdi_display, descr->drawable, rc.left, rc.top,
3499 rc.right - rc.left, rc.bottom - rc.top, AllPlanes,
3500 ZPixmap, bmpImage,
3501 descr->xSrc + rc.left - bmprc.left,
3502 descr->ySrc + rc.top - bmprc.top);
3503 X11DRV_check_error();
3504 }
3505 }
3506
3507 /***********************************************************************
3508 * X11DRV_DIB_SetImageBits
3509 *
3510 * Transfer the bits to an X image.
3511 * Helper function for SetDIBits() and SetDIBitsToDevice().
3512 */
3513 static int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
3514 {
3515 int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
3516 void *old_data = NULL;
3517 XImage *bmpImage;
3518
3519 wine_tsx11_lock();
3520 if (descr->image)
3521 bmpImage = descr->image;
3522 else {
3523 bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
3524 descr->infoWidth, lines, 32, 0 );
3525 bmpImage->data = HeapAlloc( GetProcessHeap(), 0, lines * bmpImage->bytes_per_line );
3526 if(bmpImage->data == NULL) {
3527 ERR("Out of memory!\n");
3528 XDestroyImage( bmpImage );
3529 wine_tsx11_unlock();
3530 return 0;
3531 }
3532 if (descr->shifts)
3533 {
3534 bmpImage->red_mask = descr->shifts->physicalRed.max << descr->shifts->physicalRed.shift;
3535 bmpImage->green_mask = descr->shifts->physicalGreen.max << descr->shifts->physicalGreen.shift;
3536 bmpImage->blue_mask = descr->shifts->physicalBlue.max << descr->shifts->physicalBlue.shift;
3537 }
3538 }
3539 wine_tsx11_unlock();
3540
3541 TRACE("Dib: depth=%d r=%x g=%x b=%x\n",
3542 descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
3543 TRACE("Bmp: depth=%d/%d r=%lx g=%lx b=%lx\n",
3544 bmpImage->depth,bmpImage->bits_per_pixel,
3545 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3546
3547 #ifdef HAVE_LIBXXSHM
3548 if (descr->shm_mode == X11DRV_SHM_PIXMAP
3549 && descr->xSrc == 0 && descr->ySrc == 0
3550 && descr->xDest == 0 && descr->yDest == 0)
3551 {
3552 TRACE("Using the shared pixmap data.\n");
3553
3554 wine_tsx11_lock();
3555 XSync( gdi_display, False );
3556 wine_tsx11_unlock();
3557
3558 old_data = descr->image->data;
3559 descr->image->data = descr->physBitmap->shminfo.shmaddr;
3560 }
3561 #endif
3562
3563 /* Transfer the pixels */
3564 __TRY
3565 {
3566 switch(descr->infoBpp)
3567 {
3568 case 1:
3569 X11DRV_DIB_SetImageBits_1( descr->lines, descr->bits, descr->infoWidth,
3570 descr->width, descr->xSrc, (int *)(descr->colorMap),
3571 bmpImage, descr->dibpitch );
3572 break;
3573 case 4:
3574 if (descr->compression) {
3575 X11DRV_DIB_SetImageBits_GetSubImage( descr, bmpImage);
3576 X11DRV_DIB_SetImageBits_RLE4( descr->lines, descr->bits,
3577 descr->infoWidth, descr->width,
3578 descr->xSrc, (int *)(descr->colorMap),
3579 bmpImage );
3580 } else
3581 X11DRV_DIB_SetImageBits_4( descr->lines, descr->bits,
3582 descr->infoWidth, descr->width,
3583 descr->xSrc, (int*)(descr->colorMap),
3584 bmpImage, descr->dibpitch );
3585 break;
3586 case 8:
3587 if (descr->compression) {
3588 X11DRV_DIB_SetImageBits_GetSubImage( descr, bmpImage);
3589 X11DRV_DIB_SetImageBits_RLE8( descr->lines, descr->bits,
3590 descr->infoWidth, descr->width,
3591 descr->xSrc, (int *)(descr->colorMap),
3592 bmpImage );
3593 } else
3594 X11DRV_DIB_SetImageBits_8( descr->lines, descr->bits,
3595 descr->infoWidth, descr->width,
3596 descr->xSrc, (int *)(descr->colorMap),
3597 bmpImage, descr->dibpitch );
3598 break;
3599 case 15:
3600 case 16:
3601 X11DRV_DIB_SetImageBits_16( descr->lines, descr->bits,
3602 descr->infoWidth, descr->width,
3603 descr->xSrc, descr->physDev,
3604 descr->rMask, descr->gMask, descr->bMask,
3605 bmpImage, descr->dibpitch);
3606 break;
3607 case 24:
3608 X11DRV_DIB_SetImageBits_24( descr->lines, descr->bits,
3609 descr->infoWidth, descr->width,
3610 descr->xSrc, descr->physDev,
3611 descr->rMask, descr->gMask, descr->bMask,
3612 bmpImage, descr->dibpitch);
3613 break;
3614 case 32:
3615 X11DRV_DIB_SetImageBits_32( descr->lines, descr->bits,
3616 descr->infoWidth, descr->width,
3617 descr->xSrc, descr->physDev,
3618 descr->rMask, descr->gMask, descr->bMask,
3619 bmpImage, descr->dibpitch);
3620 break;
3621 default:
3622 WARN("(%d): Invalid depth\n", descr->infoBpp );
3623 break;
3624 }
3625 }
3626 __EXCEPT_PAGE_FAULT
3627 {
3628 WARN( "invalid bits pointer %p\n", descr->bits );
3629 lines = 0;
3630 }
3631 __ENDTRY
3632
3633 TRACE("XPutImage(%ld,%p,%p,%d,%d,%d,%d,%d,%d)\n",
3634 descr->drawable, descr->gc, bmpImage,
3635 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3636 descr->width, descr->height);
3637
3638 wine_tsx11_lock();
3639 if (lines)
3640 {
3641 #ifdef HAVE_LIBXXSHM
3642 if (descr->shm_mode == X11DRV_SHM_PIXMAP
3643 && descr->xSrc == 0 && descr->ySrc == 0
3644 && descr->xDest == 0 && descr->yDest == 0)
3645 {
3646 XSync( gdi_display, False );
3647 }
3648 else if (descr->shm_mode == X11DRV_SHM_IMAGE && descr->image)
3649 {
3650 XShmPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3651 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3652 descr->width, descr->height, FALSE );
3653 XSync( gdi_display, 0 );
3654 }
3655 else
3656 #endif
3657 {
3658 XPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3659 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3660 descr->width, descr->height );
3661 }
3662 }
3663
3664 if (old_data) descr->image->data = old_data;
3665
3666 if (!descr->image) X11DRV_DIB_DestroyXImage( bmpImage );
3667 wine_tsx11_unlock();
3668 return lines;
3669 }
3670
3671 /***********************************************************************
3672 * X11DRV_DIB_GetImageBits
3673 *
3674 * Transfer the bits from an X image.
3675 */
3676 static int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
3677 {
3678 int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
3679 void *old_data = NULL;
3680 XImage *bmpImage;
3681
3682 wine_tsx11_lock();
3683 if (descr->image)
3684 bmpImage = descr->image;
3685 else {
3686 bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
3687 descr->infoWidth, lines, 32, 0 );
3688 bmpImage->data = HeapAlloc( GetProcessHeap(), 0, lines * bmpImage->bytes_per_line );
3689 if(bmpImage->data == NULL) {
3690 ERR("Out of memory!\n");
3691 XDestroyImage( bmpImage );
3692 wine_tsx11_unlock();
3693 return 0;
3694 }
3695 if (descr->shifts)
3696 {
3697 bmpImage->red_mask = descr->shifts->physicalRed.max << descr->shifts->physicalRed.shift;
3698 bmpImage->green_mask = descr->shifts->physicalGreen.max << descr->shifts->physicalGreen.shift;
3699 bmpImage->blue_mask = descr->shifts->physicalBlue.max << descr->shifts->physicalBlue.shift;
3700 }
3701 }
3702
3703 #ifdef HAVE_LIBXXSHM
3704
3705 /* We must not call XShmGetImage() with a bitmap which is bigger than the available area.
3706 If we do, XShmGetImage() will fail (X exception), as it checks for this internally. */
3707 if (descr->shm_mode == X11DRV_SHM_PIXMAP && descr->image
3708 && descr->xSrc == 0 && descr->ySrc == 0
3709 && descr->xDest == 0 && descr->yDest == 0
3710 && bmpImage->width <= (descr->width - descr->xSrc)
3711 && bmpImage->height <= (descr->height - descr->ySrc))
3712 {
3713 XSync( gdi_display, False );
3714 old_data = bmpImage->data;
3715 bmpImage->data = descr->physBitmap->shminfo.shmaddr;
3716 TRACE("Using shared pixmap data.\n");
3717 }
3718 else if (descr->shm_mode == X11DRV_SHM_IMAGE && descr->image
3719 && bmpImage->width <= (descr->width - descr->xSrc)
3720 && bmpImage->height <= (descr->height - descr->ySrc))
3721 {
3722 int saveRed, saveGreen, saveBlue;
3723
3724 TRACE("XShmGetImage(%p, %ld, %p, %d, %d, %ld)\n",
3725 gdi_display, descr->drawable, bmpImage,
3726 descr->xSrc, descr->ySrc, AllPlanes);
3727
3728 /* We must save and restore the bmpImage's masks in order
3729 * to preserve them across the call to XShmGetImage, which
3730 * decides to eliminate them since it doesn't happen to know
3731 * what the format of the image is supposed to be, even though
3732 * we do. */
3733 saveRed = bmpImage->red_mask;
3734 saveBlue= bmpImage->blue_mask;
3735 saveGreen = bmpImage->green_mask;
3736
3737 XShmGetImage( gdi_display, descr->drawable, bmpImage,
3738 descr->xSrc, descr->ySrc, AllPlanes);
3739
3740 bmpImage->red_mask = saveRed;
3741 bmpImage->blue_mask = saveBlue;
3742 bmpImage->green_mask = saveGreen;
3743 }
3744 else
3745 #endif /* HAVE_LIBXXSHM */
3746 {
3747 TRACE("XGetSubImage(%p,%ld,%d,%d,%d,%d,%ld,%d,%p,%d,%d)\n",
3748 gdi_display, descr->drawable, descr->xSrc, descr->ySrc, descr->width,
3749 lines, AllPlanes, ZPixmap, bmpImage, descr->xDest, descr->yDest);
3750 XGetSubImage( gdi_display, descr->drawable, descr->xSrc, descr->ySrc,
3751 descr->width, lines, AllPlanes, ZPixmap,
3752 bmpImage, descr->xDest, descr->yDest );
3753 }
3754 wine_tsx11_unlock();
3755
3756 TRACE("Dib: depth=%2d r=%x g=%x b=%x\n",
3757 descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
3758 TRACE("Bmp: depth=%2d/%2d r=%lx g=%lx b=%lx\n",
3759 bmpImage->depth,bmpImage->bits_per_pixel,
3760 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3761 /* Transfer the pixels */
3762 switch(descr->infoBpp)
3763 {
3764 case 1:
3765 X11DRV_DIB_GetImageBits_1( descr->lines,(LPVOID)descr->bits,
3766 descr->infoWidth, descr->width,
3767 descr->colorMap, descr->palentry,
3768 bmpImage, descr->dibpitch );
3769 break;
3770
3771 case 4:
3772 if (descr->compression) {
3773 FIXME("Compression not yet supported!\n");
3774 if(descr->sizeImage < X11DRV_DIB_GetDIBWidthBytes( descr->infoWidth, 4 ) * abs(descr->lines))
3775 break;
3776 }
3777 X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
3778 descr->infoWidth, descr->width,
3779 descr->colorMap, descr->palentry,
3780 bmpImage, descr->dibpitch );
3781 break;
3782 case 8:
3783 if (descr->compression) {
3784 FIXME("Compression not yet supported!\n");
3785 if(descr->sizeImage < X11DRV_DIB_GetDIBWidthBytes( descr->infoWidth, 8 ) * abs(descr->lines))
3786 break;
3787 }
3788 X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
3789 descr->infoWidth, descr->width,
3790 descr->colorMap, descr->palentry,
3791 bmpImage, descr->dibpitch );
3792 break;
3793 case 15:
3794 case 16:
3795 X11DRV_DIB_GetImageBits_16( descr->physDev, descr->lines, (LPVOID)descr->bits,
3796 descr->infoWidth,descr->width,
3797 descr->palentry,
3798 descr->rMask, descr->gMask, descr->bMask,
3799 bmpImage, descr->dibpitch );
3800 break;
3801
3802 case 24:
3803 X11DRV_DIB_GetImageBits_24( descr->physDev, descr->lines, (LPVOID)descr->bits,
3804 descr->infoWidth,descr->width,
3805 descr->palentry,
3806 descr->rMask, descr->gMask, descr->bMask,
3807 bmpImage, descr->dibpitch);
3808 break;
3809
3810 case 32:
3811 X11DRV_DIB_GetImageBits_32( descr->physDev, descr->lines, (LPVOID)descr->bits,
3812 descr->infoWidth, descr->width,
3813 descr->palentry,
3814 descr->rMask, descr->gMask, descr->bMask,
3815 bmpImage, descr->dibpitch);
3816 break;
3817
3818 default:
3819 WARN("(%d): Invalid depth\n", descr->infoBpp );
3820 break;
3821 }
3822
3823 if (old_data) bmpImage->data = old_data;
3824 if (!descr->image) X11DRV_DIB_DestroyXImage( bmpImage );
3825 return lines;
3826 }
3827
3828 /*************************************************************************
3829 * X11DRV_SetDIBitsToDevice
3830 *
3831 */
3832 INT X11DRV_SetDIBitsToDevice( PHYSDEV dev, INT xDest, INT yDest, DWORD cx, DWORD cy,
3833 INT xSrc, INT ySrc, UINT startscan, UINT lines, LPCVOID bits,
3834 const BITMAPINFO *info, UINT coloruse )
3835 {
3836 X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
3837 X11DRV_DIB_IMAGEBITS_DESCR descr;
3838 INT result;
3839 LONG width, height;
3840 BOOL top_down;
3841 POINT pt;
3842 int rop = X11DRV_XROPfunction[GetROP2(dev->hdc) - 1];
3843
3844 if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
3845 &descr.infoBpp, &descr.compression ) == -1)
3846 return 0;
3847
3848 top_down = (height < 0);
3849 if (top_down) height = -height;
3850
3851 pt.x = xDest;
3852 pt.y = yDest;
3853 LPtoDP(dev->hdc, &pt, 1);
3854
3855 if (!lines || (startscan >= height)) return 0;
3856 if (!top_down && startscan + lines > height) lines = height - startscan;
3857
3858 /* make xSrc,ySrc point to the upper-left corner, not the lower-left one,
3859 * and clamp all values to fit inside [startscan,startscan+lines]
3860 */
3861 if (ySrc + cy <= startscan + lines)
3862 {
3863 UINT y = startscan + lines - (ySrc + cy);
3864 if (ySrc < startscan) cy -= (startscan - ySrc);
3865 if (!top_down)
3866 {
3867 /* avoid getting unnecessary lines */
3868 ySrc = 0;
3869 if (y >= lines) return 0;
3870 lines -= y;
3871 }
3872 else
3873 {
3874 if (y >= lines) return lines;
3875 ySrc = y; /* need to get all lines in top down mode */
3876 }
3877 }
3878 else
3879 {
3880 if (ySrc >= startscan + lines) return lines;
3881 pt.y += ySrc + cy - (startscan + lines);
3882 cy = startscan + lines - ySrc;
3883 ySrc = 0;
3884 if (cy > lines) cy = lines;
3885 }
3886 if (xSrc >= width) return lines;
3887 if (xSrc + cx >= width) cx = width - xSrc;
3888 if (!cx || !cy) return lines;
3889
3890 /* Update the pixmap from the DIB section */
3891 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
3892
3893 X11DRV_SetupGCForText( physDev ); /* To have the correct colors */
3894 wine_tsx11_lock();
3895 XSetFunction(gdi_display, physDev->gc, rop);
3896 wine_tsx11_unlock();
3897
3898 switch (descr.infoBpp)
3899 {
3900 case 1:
3901 case 4:
3902 case 8:
3903 descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
3904 physDev, coloruse,
3905 physDev->depth, info, &descr.nColorMap );
3906 if (!descr.colorMap) return 0;
3907 descr.rMask = descr.gMask = descr.bMask = 0;
3908 break;
3909 case 15:
3910 case 16:
3911 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0x7c00;
3912 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x03e0;
3913 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x001f;
3914 descr.colorMap = 0;
3915 break;
3916
3917 case 24:
3918 case 32:
3919 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0xff0000;
3920 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x00ff00;
3921 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x0000ff;
3922 descr.colorMap = 0;
3923 break;
3924 }
3925
3926 descr.physDev = physDev;
3927 descr.bits = bits;
3928 descr.image = NULL;
3929 descr.palentry = NULL;
3930 descr.lines = top_down ? -lines : lines;
3931 descr.infoWidth = width;
3932 descr.depth = physDev->depth;
3933 descr.shifts = physDev->color_shifts;
3934 descr.drawable = physDev->drawable;
3935 descr.gc = physDev->gc;
3936 descr.xSrc = xSrc;
3937 descr.ySrc = ySrc;
3938 descr.xDest = physDev->dc_rect.left + pt.x;
3939 descr.yDest = physDev->dc_rect.top + pt.y;
3940 descr.width = cx;
3941 descr.height = cy;
3942 descr.shm_mode = X11DRV_SHM_NONE;
3943 descr.dibpitch = ((width * descr.infoBpp + 31) &~31) / 8;
3944 descr.physBitmap = NULL;
3945
3946 result = X11DRV_DIB_SetImageBits( &descr );
3947
3948 if (descr.infoBpp <= 8)
3949 HeapFree(GetProcessHeap(), 0, descr.colorMap);
3950
3951 /* Update the DIBSection of the pixmap */
3952 X11DRV_UnlockDIBSection(physDev, TRUE);
3953
3954 return result;
3955 }
3956
3957 /***********************************************************************
3958 * X11DRV_DIB_DoCopyDIBSection
3959 */
3960 static void X11DRV_DIB_DoCopyDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB,
3961 void *colorMap, int nColorMap,
3962 Drawable dest, GC gc,
3963 DWORD xSrc, DWORD ySrc,
3964 DWORD xDest, DWORD yDest,
3965 DWORD width, DWORD height)
3966 {
3967 DIBSECTION dibSection;
3968 X11DRV_DIB_IMAGEBITS_DESCR descr;
3969 int identity[2] = {0,1};
3970
3971 if (!GetObjectW( physBitmap->hbitmap, sizeof(dibSection), &dibSection )) return;
3972
3973 descr.physDev = NULL;
3974 descr.palentry = NULL;
3975 descr.infoWidth = dibSection.dsBmih.biWidth;
3976 descr.infoBpp = dibSection.dsBmih.biBitCount;
3977 descr.lines = physBitmap->topdown ? -dibSection.dsBmih.biHeight : dibSection.dsBmih.biHeight;
3978 descr.image = physBitmap->image;
3979 descr.colorMap = colorMap;
3980 descr.nColorMap = nColorMap;
3981 descr.bits = dibSection.dsBm.bmBits;
3982 descr.depth = physBitmap->pixmap_depth;
3983 descr.shifts = physBitmap->trueColor ? &physBitmap->pixmap_color_shifts : NULL;
3984 descr.compression = dibSection.dsBmih.biCompression;
3985 descr.physBitmap = physBitmap;
3986
3987 if(descr.infoBpp == 1)
3988 descr.colorMap = (void*)identity;
3989
3990 switch (descr.infoBpp)
3991 {
3992 case 1:
3993 case 4:
3994 case 8:
3995 descr.rMask = descr.gMask = descr.bMask = 0;
3996 break;
3997 case 15:
3998 case 16:
3999 descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0x7c00;
4000 descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x03e0;
4001 descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x001f;
4002 break;
4003
4004 case 24:
4005 case 32:
4006 descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0xff0000;
4007 descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x00ff00;
4008 descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x0000ff;
4009 break;
4010 }
4011
4012 /* Hack for now */
4013 descr.drawable = dest;
4014 descr.gc = gc;
4015 descr.xSrc = xSrc;
4016 descr.ySrc = ySrc;
4017 descr.xDest = xDest;
4018 descr.yDest = yDest;
4019 descr.width = width;
4020 descr.height = height;
4021 descr.sizeImage = 0;
4022
4023 descr.shm_mode = physBitmap->shm_mode;
4024 #ifdef HAVE_LIBXXSHM
4025 if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP && physBitmap->pixmap != dest)
4026 {
4027 descr.shm_mode = X11DRV_SHM_NONE;
4028 }
4029 #endif
4030 descr.dibpitch = dibSection.dsBm.bmWidthBytes;
4031
4032 if (toDIB)
4033 {
4034 TRACE("Copying from Pixmap to DIB bits\n");
4035 X11DRV_DIB_GetImageBits( &descr );
4036 }
4037 else
4038 {
4039 TRACE("Copying from DIB bits to Pixmap\n");
4040 X11DRV_DIB_SetImageBits( &descr );
4041 }
4042 }
4043
4044 /***********************************************************************
4045 * X11DRV_DIB_CopyDIBSection
4046 */
4047 void X11DRV_DIB_CopyDIBSection(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
4048 DWORD xSrc, DWORD ySrc, DWORD xDest, DWORD yDest,
4049 DWORD width, DWORD height)
4050 {
4051 DIBSECTION dib;
4052 X_PHYSBITMAP *physBitmap;
4053 unsigned int nColorMap;
4054 int* x11ColorMap;
4055 int freeColorMap;
4056
4057 TRACE("(%p,%p,%d,%d,%d,%d,%d,%d)\n", physDevSrc->dev.hdc, physDevDst->dev.hdc,
4058 xSrc, ySrc, xDest, yDest, width, height);
4059 /* this function is meant as an optimization for BitBlt,
4060 * not to be called otherwise */
4061 physBitmap = physDevSrc->bitmap;
4062 if (!physBitmap || GetObjectW( physBitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
4063 {
4064 ERR("called for non-DIBSection!?\n");
4065 return;
4066 }
4067 /* while BitBlt should already have made sure we only get
4068 * positive values, we should check for oversize values */
4069 if ((xSrc < dib.dsBm.bmWidth) &&
4070 (ySrc < dib.dsBm.bmHeight)) {
4071 if (xSrc + width > dib.dsBm.bmWidth)
4072 width = dib.dsBm.bmWidth - xSrc;
4073 if (ySrc + height > dib.dsBm.bmHeight)
4074 height = dib.dsBm.bmHeight - ySrc;
4075 /* if the source bitmap is 8bpp or less, we're supposed to use the
4076 * DC's palette for color conversion (not the DIB color table) */
4077 if (dib.dsBm.bmBitsPixel <= 8) {
4078 HPALETTE hPalette = GetCurrentObject( physDevSrc->dev.hdc, OBJ_PAL );
4079 if (!hPalette || (hPalette == GetStockObject(DEFAULT_PALETTE))) {
4080 /* HACK: no palette has been set in the source DC,
4081 * use the DIB colormap instead - this is necessary in some
4082 * cases since we need to do depth conversion in some places
4083 * where real Windows can just copy data straight over */
4084 x11ColorMap = physBitmap->colorMap;
4085 nColorMap = physBitmap->nColorMap;
4086 freeColorMap = FALSE;
4087 } else {
4088 const BITMAPINFO* info = (BITMAPINFO*)&dib.dsBmih;
4089 unsigned int i;
4090
4091 nColorMap = X11DRV_DIB_GetColorCount(info);
4092 x11ColorMap = HeapAlloc(GetProcessHeap(), 0, nColorMap * sizeof(int));
4093 for (i = 0; i < nColorMap; i++)
4094 x11ColorMap[i] = X11DRV_PALETTE_ToPhysical(physDevSrc, PALETTEINDEX(i));
4095 freeColorMap = TRUE;
4096 }
4097 }
4098 else
4099 {
4100 nColorMap = 0;
4101 x11ColorMap = NULL;
4102 freeColorMap = FALSE;
4103 }
4104 /* perform the copy */
4105 X11DRV_DIB_DoCopyDIBSection(physBitmap, FALSE, x11ColorMap, nColorMap,
4106 physDevDst->drawable, physDevDst->gc, xSrc, ySrc,
4107 physDevDst->dc_rect.left + xDest, physDevDst->dc_rect.top + yDest,
4108 width, height);
4109 /* free color mapping */
4110 if (freeColorMap)
4111 HeapFree(GetProcessHeap(), 0, x11ColorMap);
4112 }
4113 }
4114
4115 /***********************************************************************
4116 * X11DRV_DIB_DoUpdateDIBSection
4117 */
4118 static void X11DRV_DIB_DoUpdateDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB)
4119 {
4120 BITMAP bitmap;
4121
4122 GetObjectW( physBitmap->hbitmap, sizeof(bitmap), &bitmap );
4123 X11DRV_DIB_DoCopyDIBSection(physBitmap, toDIB,
4124 physBitmap->colorMap, physBitmap->nColorMap,
4125 physBitmap->pixmap, get_bitmap_gc(physBitmap->pixmap_depth),
4126 0, 0, 0, 0, bitmap.bmWidth, bitmap.bmHeight);
4127 }
4128
4129 /***********************************************************************
4130 * X11DRV_DIB_FaultHandler
4131 */
4132 static LONG CALLBACK X11DRV_DIB_FaultHandler( PEXCEPTION_POINTERS ep )
4133 {
4134 X_PHYSBITMAP *physBitmap = NULL;
4135 BOOL found = FALSE;
4136 BYTE *addr;
4137 struct list *ptr;
4138 const size_t pagemask = getpagesize() - 1;
4139
4140 if (ep->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION)
4141 return EXCEPTION_CONTINUE_SEARCH;
4142
4143 addr = (BYTE *)ep->ExceptionRecord->ExceptionInformation[1];
4144
4145 EnterCriticalSection(&dibs_cs);
4146 LIST_FOR_EACH( ptr, &dibs_list )
4147 {
4148 physBitmap = LIST_ENTRY( ptr, X_PHYSBITMAP, entry );
4149 if ((physBitmap->base <= addr) &&
4150 (addr < physBitmap->base + ((physBitmap->size + pagemask) & ~pagemask)))
4151 {
4152 found = TRUE;
4153 break;
4154 }
4155 }
4156 LeaveCriticalSection(&dibs_cs);
4157
4158 if (!found) return EXCEPTION_CONTINUE_SEARCH;
4159
4160 if (addr >= physBitmap->base + physBitmap->size)
4161 WARN( "%p: access to %p beyond the end of the DIB\n", physBitmap->hbitmap, addr );
4162
4163 X11DRV_DIB_Lock( physBitmap, DIB_Status_None );
4164 if (ep->ExceptionRecord->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT) {
4165 /* the app tried to write the DIB bits */
4166 X11DRV_DIB_Coerce( physBitmap, DIB_Status_AppMod);
4167 } else {
4168 /* the app tried to read the DIB bits */
4169 X11DRV_DIB_Coerce( physBitmap, DIB_Status_InSync);
4170 }
4171 X11DRV_DIB_Unlock( physBitmap, TRUE );
4172
4173 return EXCEPTION_CONTINUE_EXECUTION;
4174 }
4175
4176 /***********************************************************************
4177 * X11DRV_DIB_Coerce
4178 */
4179 static INT X11DRV_DIB_Coerce(X_PHYSBITMAP *physBitmap, INT req)
4180 {
4181 INT ret = DIB_Status_None;
4182
4183 if (!physBitmap->image) return ret; /* not a DIB section */
4184 EnterCriticalSection(&physBitmap->lock);
4185 ret = physBitmap->status;
4186 switch (req) {
4187 case DIB_Status_GdiMod:
4188 /* GDI access - request to draw on pixmap */
4189 switch (physBitmap->status)
4190 {
4191 default:
4192 case DIB_Status_None:
4193 physBitmap->p_status = DIB_Status_GdiMod;
4194 X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
4195 break;
4196
4197 case DIB_Status_GdiMod:
4198 TRACE("GdiMod requested in status GdiMod\n" );
4199 physBitmap->p_status = DIB_Status_GdiMod;
4200 break;
4201
4202 case DIB_Status_InSync:
4203 TRACE("GdiMod requested in status InSync\n" );
4204 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
4205 physBitmap->status = DIB_Status_GdiMod;
4206 physBitmap->p_status = DIB_Status_InSync;
4207 break;
4208
4209 case DIB_Status_AppMod:
4210 TRACE("GdiMod requested in status AppMod\n" );
4211 /* make it readonly to avoid app changing data while we copy */
4212 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4213 X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
4214 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
4215 physBitmap->p_status = DIB_Status_AppMod;
4216 physBitmap->status = DIB_Status_GdiMod;
4217 break;
4218 }
4219 break;
4220
4221 case DIB_Status_InSync:
4222 /* App access - request access to read DIB surface */
4223 /* (typically called from signal handler) */
4224 switch (physBitmap->status)
4225 {
4226 default:
4227 case DIB_Status_None:
4228 /* shouldn't happen from signal handler */
4229 break;
4230
4231 case DIB_Status_GdiMod:
4232 TRACE("InSync requested in status GdiMod\n" );
4233 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4234 X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4235 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4236 physBitmap->status = DIB_Status_InSync;
4237 break;
4238
4239 case DIB_Status_InSync:
4240 TRACE("InSync requested in status InSync\n" );
4241 /* shouldn't happen from signal handler */
4242 break;
4243
4244 case DIB_Status_AppMod:
4245 TRACE("InSync requested in status AppMod\n" );
4246 /* no reason to do anything here, and this
4247 * shouldn't happen from signal handler */
4248 break;
4249 }
4250 break;
4251
4252 case DIB_Status_AppMod:
4253 /* App access - request access to write DIB surface */
4254 /* (typically called from signal handler) */
4255 switch (physBitmap->status)
4256 {
4257 default:
4258 case DIB_Status_None:
4259 /* shouldn't happen from signal handler */
4260 break;
4261
4262 case DIB_Status_GdiMod:
4263 TRACE("AppMod requested in status GdiMod\n" );
4264 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4265 X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4266 physBitmap->status = DIB_Status_AppMod;
4267 break;
4268
4269 case DIB_Status_InSync:
4270 TRACE("AppMod requested in status InSync\n" );
4271 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4272 physBitmap->status = DIB_Status_AppMod;
4273 break;
4274
4275 case DIB_Status_AppMod:
4276 TRACE("AppMod requested in status AppMod\n" );
4277 /* shouldn't happen from signal handler */
4278 break;
4279 }
4280 break;
4281
4282 /* it is up to the caller to do the copy/conversion, probably
4283 * using the return value to decide where to copy from */
4284 }
4285 LeaveCriticalSection(&physBitmap->lock);
4286 return ret;
4287 }
4288
4289 /***********************************************************************
4290 * X11DRV_DIB_Lock
4291 */
4292 INT X11DRV_DIB_Lock(X_PHYSBITMAP *physBitmap, INT req)
4293 {
4294 INT ret = DIB_Status_None;
4295
4296 if (!physBitmap->image) return ret; /* not a DIB section */
4297 TRACE("Locking %p from thread %04x\n", physBitmap->hbitmap, GetCurrentThreadId());
4298 EnterCriticalSection(&physBitmap->lock);
4299 ret = physBitmap->status;
4300 if (req != DIB_Status_None)
4301 X11DRV_DIB_Coerce(physBitmap, req);
4302 return ret;
4303 }
4304
4305 /***********************************************************************
4306 * X11DRV_DIB_Unlock
4307 */
4308 void X11DRV_DIB_Unlock(X_PHYSBITMAP *physBitmap, BOOL commit)
4309 {
4310 if (!physBitmap->image) return; /* not a DIB section */
4311 switch (physBitmap->status)
4312 {
4313 default:
4314 case DIB_Status_None:
4315 /* in case anyone is wondering, this is the "signal handler doesn't
4316 * work" case, where we always have to be ready for app access */
4317 if (commit) {
4318 switch (physBitmap->p_status)
4319 {
4320 case DIB_Status_GdiMod:
4321 TRACE("Unlocking and syncing from GdiMod\n" );
4322 X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4323 break;
4324
4325 default:
4326 TRACE("Unlocking without needing to sync\n" );
4327 break;
4328 }
4329 }
4330 else TRACE("Unlocking with no changes\n");
4331 physBitmap->p_status = DIB_Status_None;
4332 break;
4333
4334 case DIB_Status_GdiMod:
4335 TRACE("Unlocking in status GdiMod\n" );
4336 /* DIB was protected in Coerce */
4337 if (!commit) {
4338 /* no commit, revert to InSync if applicable */
4339 if ((physBitmap->p_status == DIB_Status_InSync) ||
4340 (physBitmap->p_status == DIB_Status_AppMod)) {
4341 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4342 physBitmap->status = DIB_Status_InSync;
4343 }
4344 }
4345 break;
4346
4347 case DIB_Status_InSync:
4348 TRACE("Unlocking in status InSync\n" );
4349 /* DIB was already protected in Coerce */
4350 break;
4351
4352 case DIB_Status_AppMod:
4353 TRACE("Unlocking in status AppMod\n" );
4354 /* DIB was already protected in Coerce */
4355 /* this case is ordinary only called from the signal handler,
4356 * so we don't bother to check for !commit */
4357 break;
4358 }
4359 LeaveCriticalSection(&physBitmap->lock);
4360 TRACE("Unlocked %p\n", physBitmap->hbitmap);
4361 }
4362
4363 /***********************************************************************
4364 * X11DRV_CoerceDIBSection
4365 */
4366 INT X11DRV_CoerceDIBSection(X11DRV_PDEVICE *physDev, INT req)
4367 {
4368 if (!physDev || !physDev->bitmap) return DIB_Status_None;
4369 return X11DRV_DIB_Coerce(physDev->bitmap, req);
4370 }
4371
4372 /***********************************************************************
4373 * X11DRV_LockDIBSection
4374 */
4375 INT X11DRV_LockDIBSection(X11DRV_PDEVICE *physDev, INT req)
4376 {
4377 if (!physDev || !physDev->bitmap) return DIB_Status_None;
4378 return X11DRV_DIB_Lock(physDev->bitmap, req);
4379 }
4380
4381 /***********************************************************************
4382 * X11DRV_UnlockDIBSection
4383 */
4384 void X11DRV_UnlockDIBSection(X11DRV_PDEVICE *physDev, BOOL commit)
4385 {
4386 if (!physDev || !physDev->bitmap) return;
4387 X11DRV_DIB_Unlock(physDev->bitmap, commit);
4388 }
4389
4390
4391 #ifdef HAVE_LIBXXSHM
4392 /***********************************************************************
4393 * X11DRV_XShmErrorHandler
4394 *
4395 */
4396 static int XShmErrorHandler( Display *dpy, XErrorEvent *event, void *arg )
4397 {
4398 return 1; /* FIXME: should check event contents */
4399 }
4400
4401 /***********************************************************************
4402 * X11DRV_XShmCreateImage
4403 *
4404 */
4405 static XImage *X11DRV_XShmCreateImage( int width, int height, int bpp,
4406 XShmSegmentInfo* shminfo)
4407 {
4408 XImage *image;
4409
4410 image = XShmCreateImage(gdi_display, visual, bpp, ZPixmap, NULL, shminfo, width, height);
4411 if (image)
4412 {
4413 shminfo->shmid = shmget(IPC_PRIVATE, image->bytes_per_line * height,
4414 IPC_CREAT|0700);
4415 if( shminfo->shmid != -1 )
4416 {
4417 shminfo->shmaddr = shmat( shminfo->shmid, 0, 0 );
4418 if( shminfo->shmaddr != (char*)-1 )
4419 {
4420 BOOL ok;
4421
4422 shminfo->readOnly = FALSE;
4423 X11DRV_expect_error( gdi_display, XShmErrorHandler, NULL );
4424 ok = (XShmAttach( gdi_display, shminfo ) != 0);
4425 XSync( gdi_display, False );
4426 if (X11DRV_check_error()) ok = FALSE;
4427 if (ok)
4428 {
4429 shmctl(shminfo->shmid, IPC_RMID, 0);
4430 return image; /* Success! */
4431 }
4432 /* An error occurred */
4433 shmdt(shminfo->shmaddr);
4434 }
4435 shmctl(shminfo->shmid, IPC_RMID, 0);
4436 shminfo->shmid = -1;
4437 }
4438 XFlush(gdi_display);
4439 XDestroyImage(image);
4440 image = NULL;
4441 }
4442 return image;
4443 }
4444 #endif /* HAVE_LIBXXSHM */
4445
4446 static Bool X11DRV_DIB_QueryXShm( Bool *pixmaps )
4447 {
4448 static Bool have_xshm, have_xshm_pixmaps;
4449 static BOOL initialized;
4450
4451 if (!initialized)
4452 {
4453 #ifdef HAVE_LIBXXSHM
4454 int major, minor;
4455
4456 have_xshm = XShmQueryVersion( gdi_display, &major, &minor, &have_xshm_pixmaps );
4457 #endif
4458 initialized = TRUE;
4459 }
4460
4461 *pixmaps = have_xshm_pixmaps;
4462 return have_xshm;
4463 }
4464
4465 /***********************************************************************
4466 * X11DRV_CreateDIBSection (X11DRV.@)
4467 */
4468 HBITMAP X11DRV_CreateDIBSection( PHYSDEV dev, HBITMAP hbitmap, const BITMAPINFO *bmi, UINT usage )
4469 {
4470 X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
4471 X_PHYSBITMAP *physBitmap;
4472 DIBSECTION dib;
4473 WORD bpp, compr;
4474 LONG w, h;
4475 #ifdef HAVE_LIBXXSHM
4476 Bool pixmaps;
4477 #endif
4478
4479 if (DIB_GetBitmapInfo( &bmi->bmiHeader, &w, &h, &bpp, &compr ) == -1) return 0;
4480
4481 if (!(physBitmap = X11DRV_init_phys_bitmap( hbitmap ))) return 0;
4482 if (h < 0) physBitmap->topdown = TRUE;
4483 physBitmap->status = DIB_Status_None;
4484
4485 GetObjectW( hbitmap, sizeof(dib), &dib );
4486
4487 /* create color map */
4488 if (dib.dsBm.bmBitsPixel <= 8)
4489 {
4490 physBitmap->colorMap = X11DRV_DIB_BuildColorMap( physDev,
4491 usage, dib.dsBm.bmBitsPixel, bmi,
4492 &physBitmap->nColorMap );
4493 }
4494
4495 if (!X11DRV_XRender_SetPhysBitmapDepth( physBitmap, dib.dsBm.bmBitsPixel, &dib ))
4496 {
4497 if (dib.dsBm.bmBitsPixel == 1)
4498 {
4499 physBitmap->pixmap_depth = 1;
4500 physBitmap->trueColor = FALSE;
4501 }
4502 else
4503 {
4504 physBitmap->pixmap_depth = screen_depth;
4505 physBitmap->pixmap_color_shifts = X11DRV_PALETTE_default_shifts;
4506 physBitmap->trueColor = (visual->class == TrueColor || visual->class == DirectColor);
4507 }
4508 }
4509
4510 /* create pixmap and X image */
4511 wine_tsx11_lock();
4512 #ifdef HAVE_LIBXXSHM
4513 physBitmap->shminfo.shmid = -1;
4514
4515 if (X11DRV_DIB_QueryXShm( &pixmaps )
4516 && (physBitmap->image = X11DRV_XShmCreateImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4517 physBitmap->pixmap_depth, &physBitmap->shminfo )))
4518 {
4519 if (pixmaps)
4520 {
4521 physBitmap->shm_mode = X11DRV_SHM_PIXMAP;
4522 physBitmap->image->data = HeapAlloc( GetProcessHeap(), 0,
4523 dib.dsBm.bmHeight * physBitmap->image->bytes_per_line );
4524 }
4525 else
4526 {
4527 physBitmap->shm_mode = X11DRV_SHM_IMAGE;
4528 physBitmap->image->data = physBitmap->shminfo.shmaddr;
4529 }
4530 }
4531 else
4532 #endif
4533 {
4534 physBitmap->shm_mode = X11DRV_SHM_NONE;
4535 physBitmap->image = X11DRV_DIB_CreateXImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4536 physBitmap->pixmap_depth );
4537 }
4538
4539 #ifdef HAVE_LIBXXSHM
4540 if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP)
4541 {
4542 TRACE("Creating shared pixmap for bmp %p.\n", physBitmap->hbitmap);
4543 physBitmap->pixmap = XShmCreatePixmap( gdi_display, root_window,
4544 physBitmap->shminfo.shmaddr, &physBitmap->shminfo,
4545 dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4546 physBitmap->pixmap_depth );
4547 }
4548 else
4549 #endif
4550 {
4551 physBitmap->pixmap = XCreatePixmap( gdi_display, root_window, dib.dsBm.bmWidth,
4552 dib.dsBm.bmHeight, physBitmap->pixmap_depth );
4553 }
4554
4555 wine_tsx11_unlock();
4556 if (!physBitmap->pixmap || !physBitmap->image) return 0;
4557
4558 if (physBitmap->trueColor)
4559 {
4560 ColorShifts *shifts = &physBitmap->pixmap_color_shifts;
4561
4562 /* When XRender is around and used, we also support dibsections in other formats like 16-bit. In these
4563 * cases we need to override the mask of XImages. The reason is that during XImage creation the masks are
4564 * derived from a 24-bit visual (no 16-bit ones are around when X runs at 24-bit). SetImageBits and other
4565 * functions rely on the color masks for proper color conversion, so we need to override the masks here. */
4566 physBitmap->image->red_mask = shifts->physicalRed.max << shifts->physicalRed.shift;
4567 physBitmap->image->green_mask = shifts->physicalGreen.max << shifts->physicalGreen.shift;
4568 physBitmap->image->blue_mask = shifts->physicalBlue.max << shifts->physicalBlue.shift;
4569 }
4570
4571 /* install fault handler */
4572 InitializeCriticalSection( &physBitmap->lock );
4573 physBitmap->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": X_PHYSBITMAP.lock");
4574
4575 physBitmap->base = dib.dsBm.bmBits;
4576 physBitmap->size = dib.dsBmih.biSizeImage;
4577 physBitmap->status = DIB_Status_AppMod;
4578
4579 if (!dibs_handler)
4580 dibs_handler = AddVectoredExceptionHandler( TRUE, X11DRV_DIB_FaultHandler );
4581 EnterCriticalSection( &dibs_cs );
4582 list_add_head( &dibs_list, &physBitmap->entry );
4583 LeaveCriticalSection( &dibs_cs );
4584
4585 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4586
4587 return hbitmap;
4588 }
4589
4590 /***********************************************************************
4591 * X11DRV_DIB_DeleteDIBSection
4592 */
4593 void X11DRV_DIB_DeleteDIBSection(X_PHYSBITMAP *physBitmap, DIBSECTION *dib)
4594 {
4595 BOOL last;
4596
4597 EnterCriticalSection( &dibs_cs );
4598 list_remove( &physBitmap->entry );
4599 last = list_empty( &dibs_list );
4600 LeaveCriticalSection( &dibs_cs );
4601
4602 if (last)
4603 {
4604 RemoveVectoredExceptionHandler( dibs_handler );
4605 dibs_handler = NULL;
4606 }
4607
4608 if (dib->dshSection)
4609 X11DRV_DIB_Coerce(physBitmap, DIB_Status_InSync);
4610
4611 if (physBitmap->image)
4612 {
4613 wine_tsx11_lock();
4614 #ifdef HAVE_LIBXXSHM
4615 if (physBitmap->shminfo.shmid != -1)
4616 {
4617 XShmDetach( gdi_display, &(physBitmap->shminfo) );
4618 if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP) X11DRV_DIB_DestroyXImage( physBitmap->image );
4619 else XDestroyImage( physBitmap->image );
4620 shmdt( physBitmap->shminfo.shmaddr );
4621 physBitmap->shminfo.shmid = -1;
4622 physBitmap->shm_mode = X11DRV_SHM_NONE;
4623 }
4624 else
4625 #endif
4626 X11DRV_DIB_DestroyXImage( physBitmap->image );
4627 wine_tsx11_unlock();
4628 }
4629
4630 HeapFree(GetProcessHeap(), 0, physBitmap->colorMap);
4631 physBitmap->lock.DebugInfo->Spare[0] = 0;
4632 DeleteCriticalSection(&physBitmap->lock);
4633 }
4634
4635 /***********************************************************************
4636 * SetDIBColorTable (X11DRV.@)
4637 */
4638 UINT X11DRV_SetDIBColorTable( PHYSDEV dev, UINT start, UINT count, const RGBQUAD *colors )
4639 {
4640 X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
4641 DIBSECTION dib;
4642 UINT ret = 0;
4643 X_PHYSBITMAP *physBitmap = physDev->bitmap;
4644
4645 if (!physBitmap) return 0;
4646 GetObjectW( physBitmap->hbitmap, sizeof(dib), &dib );
4647
4648 if (physBitmap->colorMap && start < physBitmap->nColorMap) {
4649 UINT end = count + start;
4650 if (end > physBitmap->nColorMap) end = physBitmap->nColorMap;
4651 /*
4652 * Changing color table might change the mapping between
4653 * DIB colors and X11 colors and thus alter the visible state
4654 * of the bitmap object.
4655 */
4656 /*
4657 * FIXME we need to recalculate the pen, brush, text and bkgnd pixels here,
4658 * at least for a 1 bpp dibsection
4659 */
4660 X11DRV_DIB_Lock( physBitmap, DIB_Status_AppMod );
4661 X11DRV_DIB_GenColorMap( physDev, physBitmap->colorMap, DIB_RGB_COLORS,
4662 dib.dsBm.bmBitsPixel,
4663 TRUE, colors, start, end );
4664 X11DRV_DIB_Unlock( physBitmap, TRUE );
4665 ret = end - start;
4666 }
4667 return ret;
4668 }
4669
4670
4671 /***********************************************************************
4672 * X11DRV_DIB_CreateDIBFromBitmap
4673 *
4674 * Allocates a packed DIB and copies the bitmap data into it.
4675 */
4676 HGLOBAL X11DRV_DIB_CreateDIBFromBitmap(HDC hdc, HBITMAP hBmp)
4677 {
4678 BITMAP bmp;
4679 HGLOBAL hPackedDIB;
4680 LPBYTE pPackedDIB;
4681 LPBITMAPINFOHEADER pbmiHeader;
4682 unsigned int cDataSize, cPackedSize, OffsetBits;
4683 int nLinesCopied;
4684
4685 if (!GetObjectW( hBmp, sizeof(bmp), &bmp )) return 0;
4686
4687 /*
4688 * A packed DIB contains a BITMAPINFO structure followed immediately by
4689 * an optional color palette and the pixel data.
4690 */
4691
4692 /* Calculate the size of the packed DIB */
4693 cDataSize = X11DRV_DIB_GetDIBWidthBytes( bmp.bmWidth, bmp.bmBitsPixel ) * abs( bmp.bmHeight );
4694 cPackedSize = sizeof(BITMAPINFOHEADER)
4695 + ( (bmp.bmBitsPixel <= 8) ? (sizeof(RGBQUAD) * (1 << bmp.bmBitsPixel)) : 0 )
4696 + cDataSize;
4697 /* Get the offset to the bits */
4698 OffsetBits = cPackedSize - cDataSize;
4699
4700 /* Allocate the packed DIB */
4701 TRACE("\tAllocating packed DIB of size %d\n", cPackedSize);
4702 hPackedDIB = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE /*| GMEM_ZEROINIT*/,
4703 cPackedSize );
4704 if ( !hPackedDIB )
4705 {
4706 WARN("Could not allocate packed DIB!\n");
4707 return 0;
4708 }
4709
4710 /* A packed DIB starts with a BITMAPINFOHEADER */
4711 pPackedDIB = GlobalLock(hPackedDIB);
4712 pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
4713
4714 /* Init the BITMAPINFOHEADER */
4715 pbmiHeader->biSize = sizeof(BITMAPINFOHEADER);
4716 pbmiHeader->biWidth = bmp.bmWidth;
4717 pbmiHeader->biHeight = bmp.bmHeight;
4718 pbmiHeader->biPlanes = 1;
4719 pbmiHeader->biBitCount = bmp.bmBitsPixel;
4720 pbmiHeader->biCompression = BI_RGB;
4721 pbmiHeader->biSizeImage = 0;
4722 pbmiHeader->biXPelsPerMeter = pbmiHeader->biYPelsPerMeter = 0;
4723 pbmiHeader->biClrUsed = 0;
4724 pbmiHeader->biClrImportant = 0;
4725
4726 /* Retrieve the DIB bits from the bitmap and fill in the
4727 * DIB color table if present */
4728
4729 nLinesCopied = GetDIBits(hdc, /* Handle to device context */
4730 hBmp, /* Handle to bitmap */
4731 0, /* First scan line to set in dest bitmap */
4732 bmp.bmHeight, /* Number of scan lines to copy */
4733 pPackedDIB + OffsetBits, /* [out] Address of array for bitmap bits */
4734 (LPBITMAPINFO) pbmiHeader, /* [out] Address of BITMAPINFO structure */
4735 0); /* RGB or palette index */
4736 GlobalUnlock(hPackedDIB);
4737
4738 /* Cleanup if GetDIBits failed */
4739 if (nLinesCopied != bmp.bmHeight)
4740 {
4741 TRACE("\tGetDIBits returned %d. Actual lines=%d\n", nLinesCopied, bmp.bmHeight);
4742 GlobalFree(hPackedDIB);
4743 hPackedDIB = 0;
4744 }
4745 return hPackedDIB;
4746 }
4747
4748
4749 /**************************************************************************
4750 * X11DRV_DIB_CreateDIBFromPixmap
4751 *
4752 * Allocates a packed DIB and copies the Pixmap data into it.
4753 * The Pixmap passed in is deleted after the conversion.
4754 */
4755 HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc)
4756 {
4757 HDC hdcMem;
4758 X_PHYSBITMAP *physBitmap;
4759 Pixmap orig_pixmap;
4760 HBITMAP hBmp = 0;
4761 HGLOBAL hPackedDIB = 0;
4762 Window root;
4763 int x,y; /* Unused */
4764 unsigned border_width; /* Unused */
4765 unsigned int depth, width, height;
4766
4767 /* Get the Pixmap dimensions and bit depth */
4768 wine_tsx11_lock();
4769 if (!XGetGeometry(gdi_display, pixmap, &root, &x, &y, &width, &height,
4770 &border_width, &depth)) depth = 0;
4771 wine_tsx11_unlock();
4772 if (!pixmap_formats[depth]) return 0;
4773
4774 TRACE("\tPixmap properties: width=%d, height=%d, depth=%d\n",
4775 width, height, depth);
4776
4777 /*
4778 * Create an HBITMAP with the same dimensions and BPP as the pixmap,
4779 * and make it a container for the pixmap passed.
4780 */
4781 if (!(hBmp = CreateBitmap( width, height, 1, pixmap_formats[depth]->bits_per_pixel, NULL ))) return 0;
4782
4783 /* force bitmap to be owned by a screen DC */
4784 hdcMem = CreateCompatibleDC( hdc );
4785 SelectObject( hdcMem, SelectObject( hdcMem, hBmp ));
4786 DeleteDC( hdcMem );
4787
4788 physBitmap = X11DRV_get_phys_bitmap( hBmp );
4789
4790 /* swap the new pixmap in */
4791 orig_pixmap = physBitmap->pixmap;
4792 physBitmap->pixmap = pixmap;
4793
4794 /*
4795 * Create a packed DIB from the Pixmap wrapper bitmap created above.
4796 * A packed DIB contains a BITMAPINFO structure followed immediately by
4797 * an optional color palette and the pixel data.
4798 */
4799 hPackedDIB = X11DRV_DIB_CreateDIBFromBitmap(hdc, hBmp);
4800
4801 /* we can now get rid of the HBITMAP and its original pixmap */
4802 physBitmap->pixmap = orig_pixmap;
4803 DeleteObject(hBmp);
4804
4805 TRACE("\tReturning packed DIB %p\n", hPackedDIB);
4806 return hPackedDIB;
4807 }
4808
4809
4810 /**************************************************************************
4811 * X11DRV_DIB_CreatePixmapFromDIB
4812 *
4813 * Creates a Pixmap from a packed DIB
4814 */
4815 Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
4816 {
4817 Pixmap pixmap;
4818 X_PHYSBITMAP *physBitmap;
4819 HBITMAP hBmp;
4820 LPBITMAPINFO pbmi;
4821
4822 /* Create a DDB from the DIB */
4823
4824 pbmi = GlobalLock(hPackedDIB);
4825 hBmp = CreateDIBitmap(hdc, &pbmi->bmiHeader, CBM_INIT,
4826 (LPBYTE)pbmi + bitmap_info_size( pbmi, DIB_RGB_COLORS ),
4827 pbmi, DIB_RGB_COLORS);
4828 GlobalUnlock(hPackedDIB);
4829
4830 /* clear the physBitmap so that we can steal its pixmap */
4831 physBitmap = X11DRV_get_phys_bitmap( hBmp );
4832 pixmap = physBitmap->pixmap;
4833 physBitmap->pixmap = 0;
4834
4835 /* Delete the DDB we created earlier now that we have stolen its pixmap */
4836 DeleteObject(hBmp);
4837
4838 TRACE("Returning Pixmap %lx\n", pixmap);
4839 return pixmap;
4840 }
Windows API implementation