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