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