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