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