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