?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Added nsIURI::Equals implementation on URIs without necko interface associated.
[wine.git] / dlls / winex11.drv / dib.c
blob91aab9976d2cba7e3b366afc4fb684af4f325ee4
1 /*
2 * X11DRV device-independent bitmaps
3 *
4 * Copyright 1993,1994 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <X11/Xlib.h>
25 #ifdef HAVE_LIBXXSHM
26 #include <X11/extensions/XShm.h>
27 # ifdef HAVE_SYS_SHM_H
28 # include <sys/shm.h>
29 # endif
30 # ifdef HAVE_SYS_IPC_H
31 # include <sys/ipc.h>
32 # endif
33 #endif /* defined(HAVE_LIBXXSHM) */
34
35 #include <stdarg.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include "windef.h"
39 #include "winbase.h"
40 #include "wingdi.h"
41 #include "x11drv.h"
42 #include "excpt.h"
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
46
47 static struct list dibs_list = LIST_INIT(dibs_list);
48
49 static CRITICAL_SECTION dibs_cs;
50 static CRITICAL_SECTION_DEBUG dibs_cs_debug =
51 {
52 0, 0, &dibs_cs,
53 { &dibs_cs_debug.ProcessLocksList, &dibs_cs_debug.ProcessLocksList },
54 0, 0, { (DWORD_PTR)(__FILE__ ": dibs_cs") }
55 };
56 static CRITICAL_SECTION dibs_cs = { &dibs_cs_debug, -1, 0, 0, 0, 0 };
57
58 static PVOID dibs_handler;
59
60 static int ximageDepthTable[32];
61
62 /* This structure holds the arguments for DIB_SetImageBits() */
63 typedef struct
64 {
65 X11DRV_PDEVICE *physDev;
66 LPCVOID bits;
67 XImage *image;
68 PALETTEENTRY *palentry;
69 int lines;
70 DWORD infoWidth;
71 WORD depth;
72 WORD infoBpp;
73 WORD compression;
74 RGBQUAD *colorMap;
75 int nColorMap;
76 Drawable drawable;
77 GC gc;
78 int xSrc;
79 int ySrc;
80 int xDest;
81 int yDest;
82 int width;
83 int height;
84 DWORD rMask;
85 DWORD gMask;
86 DWORD bMask;
87 BOOL useShm;
88 int dibpitch;
89 DWORD sizeImage;
90 } X11DRV_DIB_IMAGEBITS_DESCR;
91
92
93 enum Rle_EscapeCodes
94 {
95 RLE_EOL = 0, /* End of line */
96 RLE_END = 1, /* End of bitmap */
97 RLE_DELTA = 2 /* Delta */
98 };
99
100
101 static INT X11DRV_DIB_Coerce(X_PHYSBITMAP *,INT);
102 static INT X11DRV_DIB_Lock(X_PHYSBITMAP *,INT);
103 static void X11DRV_DIB_Unlock(X_PHYSBITMAP *,BOOL);
104
105 /*
106 Some of the following helper functions are duplicated in
107 dlls/gdi/dib.c
108 */
109
110 /***********************************************************************
111 * 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 switch(descr->infoBpp)
3543 {
3544 case 1:
3545 X11DRV_DIB_SetImageBits_1( descr->lines, descr->bits, descr->infoWidth,
3546 descr->width, descr->xSrc, (int *)(descr->colorMap),
3547 bmpImage, descr->dibpitch );
3548 break;
3549 case 4:
3550 if (descr->compression) {
3551 X11DRV_DIB_SetImageBits_GetSubImage( descr, bmpImage);
3552 X11DRV_DIB_SetImageBits_RLE4( descr->lines, descr->bits,
3553 descr->infoWidth, descr->width,
3554 descr->xSrc, (int *)(descr->colorMap),
3555 bmpImage );
3556 } else
3557 X11DRV_DIB_SetImageBits_4( descr->lines, descr->bits,
3558 descr->infoWidth, descr->width,
3559 descr->xSrc, (int*)(descr->colorMap),
3560 bmpImage, descr->dibpitch );
3561 break;
3562 case 8:
3563 if (descr->compression) {
3564 X11DRV_DIB_SetImageBits_GetSubImage( descr, bmpImage);
3565 X11DRV_DIB_SetImageBits_RLE8( descr->lines, descr->bits,
3566 descr->infoWidth, descr->width,
3567 descr->xSrc, (int *)(descr->colorMap),
3568 bmpImage );
3569 } else
3570 X11DRV_DIB_SetImageBits_8( descr->lines, descr->bits,
3571 descr->infoWidth, descr->width,
3572 descr->xSrc, (int *)(descr->colorMap),
3573 bmpImage, descr->dibpitch );
3574 break;
3575 case 15:
3576 case 16:
3577 X11DRV_DIB_SetImageBits_16( descr->lines, descr->bits,
3578 descr->infoWidth, descr->width,
3579 descr->xSrc, descr->physDev,
3580 descr->rMask, descr->gMask, descr->bMask,
3581 bmpImage, descr->dibpitch);
3582 break;
3583 case 24:
3584 X11DRV_DIB_SetImageBits_24( descr->lines, descr->bits,
3585 descr->infoWidth, descr->width,
3586 descr->xSrc, descr->physDev,
3587 descr->rMask, descr->gMask, descr->bMask,
3588 bmpImage, descr->dibpitch);
3589 break;
3590 case 32:
3591 X11DRV_DIB_SetImageBits_32( descr->lines, descr->bits,
3592 descr->infoWidth, descr->width,
3593 descr->xSrc, descr->physDev,
3594 descr->rMask, descr->gMask, descr->bMask,
3595 bmpImage, descr->dibpitch);
3596 break;
3597 default:
3598 WARN("(%d): Invalid depth\n", descr->infoBpp );
3599 break;
3600 }
3601
3602 TRACE("XPutImage(%ld,%p,%p,%d,%d,%d,%d,%d,%d)\n",
3603 descr->drawable, descr->gc, bmpImage,
3604 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3605 descr->width, descr->height);
3606
3607 wine_tsx11_lock();
3608 #ifdef HAVE_LIBXXSHM
3609 if (descr->image && descr->useShm)
3610 {
3611 XShmPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3612 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3613 descr->width, descr->height, FALSE );
3614 XSync( gdi_display, 0 );
3615 }
3616 else
3617 #endif
3618 XPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3619 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3620 descr->width, descr->height );
3621
3622 if (!descr->image) XDestroyImage( bmpImage );
3623 wine_tsx11_unlock();
3624 return lines;
3625 }
3626
3627 /***********************************************************************
3628 * X11DRV_DIB_GetImageBits
3629 *
3630 * Transfer the bits from an X image.
3631 */
3632 static int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
3633 {
3634 int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
3635 XImage *bmpImage;
3636
3637 wine_tsx11_lock();
3638 if (descr->image)
3639 bmpImage = descr->image;
3640 else {
3641 bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
3642 descr->infoWidth, lines, 32, 0 );
3643 bmpImage->data = calloc( lines, bmpImage->bytes_per_line );
3644 if(bmpImage->data == NULL) {
3645 ERR("Out of memory!\n");
3646 XDestroyImage( bmpImage );
3647 wine_tsx11_unlock();
3648 return lines;
3649 }
3650 }
3651
3652 #ifdef HAVE_LIBXXSHM
3653
3654 /* We must not call XShmGetImage() with a bitmap which is bigger than the available area.
3655 If we do, XShmGetImage() will fail (X exception), as it checks for this internally. */
3656 if((descr->image && descr->useShm) && (bmpImage->width <= (descr->width - descr->xSrc))
3657 && (bmpImage->height <= (descr->height - descr->ySrc)))
3658 {
3659 int saveRed, saveGreen, saveBlue;
3660
3661 TRACE("XShmGetImage(%p, %ld, %p, %d, %d, %ld)\n",
3662 gdi_display, descr->drawable, bmpImage,
3663 descr->xSrc, descr->ySrc, AllPlanes);
3664
3665 /* We must save and restore the bmpImage's masks in order
3666 * to preserve them across the call to XShmGetImage, which
3667 * decides to eliminate them since it doesn't happen to know
3668 * what the format of the image is supposed to be, even though
3669 * we do. */
3670 saveRed = bmpImage->red_mask;
3671 saveBlue= bmpImage->blue_mask;
3672 saveGreen = bmpImage->green_mask;
3673
3674 XShmGetImage( gdi_display, descr->drawable, bmpImage,
3675 descr->xSrc, descr->ySrc, AllPlanes);
3676
3677 bmpImage->red_mask = saveRed;
3678 bmpImage->blue_mask = saveBlue;
3679 bmpImage->green_mask = saveGreen;
3680 }
3681 else
3682 #endif /* HAVE_LIBXXSHM */
3683 {
3684 TRACE("XGetSubImage(%p,%ld,%d,%d,%d,%d,%ld,%d,%p,%d,%d)\n",
3685 gdi_display, descr->drawable, descr->xSrc, descr->ySrc, descr->width,
3686 lines, AllPlanes, ZPixmap, bmpImage, descr->xDest, descr->yDest);
3687 XGetSubImage( gdi_display, descr->drawable, descr->xSrc, descr->ySrc,
3688 descr->width, lines, AllPlanes, ZPixmap,
3689 bmpImage, descr->xDest, descr->yDest );
3690 }
3691 wine_tsx11_unlock();
3692
3693 TRACE("Dib: depth=%2d r=%x g=%x b=%x\n",
3694 descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
3695 TRACE("Bmp: depth=%2d/%2d r=%lx g=%lx b=%lx\n",
3696 bmpImage->depth,bmpImage->bits_per_pixel,
3697 bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3698 /* Transfer the pixels */
3699 switch(descr->infoBpp)
3700 {
3701 case 1:
3702 X11DRV_DIB_GetImageBits_1( descr->lines,(LPVOID)descr->bits,
3703 descr->infoWidth, descr->width,
3704 descr->colorMap, descr->palentry,
3705 bmpImage, descr->dibpitch );
3706 break;
3707
3708 case 4:
3709 if (descr->compression) {
3710 FIXME("Compression not yet supported!\n");
3711 if(descr->sizeImage < X11DRV_DIB_GetDIBWidthBytes( descr->infoWidth, 4 ) * abs(descr->lines))
3712 break;
3713 }
3714 X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
3715 descr->infoWidth, descr->width,
3716 descr->colorMap, descr->palentry,
3717 bmpImage, descr->dibpitch );
3718 break;
3719 case 8:
3720 if (descr->compression) {
3721 FIXME("Compression not yet supported!\n");
3722 if(descr->sizeImage < X11DRV_DIB_GetDIBWidthBytes( descr->infoWidth, 8 ) * abs(descr->lines))
3723 break;
3724 }
3725 X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
3726 descr->infoWidth, descr->width,
3727 descr->colorMap, descr->palentry,
3728 bmpImage, descr->dibpitch );
3729 break;
3730 case 15:
3731 case 16:
3732 X11DRV_DIB_GetImageBits_16( descr->lines, (LPVOID)descr->bits,
3733 descr->infoWidth,descr->width,
3734 descr->palentry,
3735 descr->rMask, descr->gMask, descr->bMask,
3736 bmpImage, descr->dibpitch );
3737 break;
3738
3739 case 24:
3740 X11DRV_DIB_GetImageBits_24( descr->lines, (LPVOID)descr->bits,
3741 descr->infoWidth,descr->width,
3742 descr->palentry,
3743 descr->rMask, descr->gMask, descr->bMask,
3744 bmpImage, descr->dibpitch);
3745 break;
3746
3747 case 32:
3748 X11DRV_DIB_GetImageBits_32( descr->lines, (LPVOID)descr->bits,
3749 descr->infoWidth, descr->width,
3750 descr->palentry,
3751 descr->rMask, descr->gMask, descr->bMask,
3752 bmpImage, descr->dibpitch);
3753 break;
3754
3755 default:
3756 WARN("(%d): Invalid depth\n", descr->infoBpp );
3757 break;
3758 }
3759
3760 if (!descr->image)
3761 {
3762 wine_tsx11_lock();
3763 XDestroyImage( bmpImage );
3764 wine_tsx11_unlock();
3765 }
3766 return lines;
3767 }
3768
3769 /*************************************************************************
3770 * X11DRV_SetDIBitsToDevice
3771 *
3772 */
3773 INT X11DRV_SetDIBitsToDevice( X11DRV_PDEVICE *physDev, INT xDest, INT yDest, DWORD cx,
3774 DWORD cy, INT xSrc, INT ySrc,
3775 UINT startscan, UINT lines, LPCVOID bits,
3776 const BITMAPINFO *info, UINT coloruse )
3777 {
3778 X11DRV_DIB_IMAGEBITS_DESCR descr;
3779 INT result;
3780 LONG width, height;
3781 BOOL top_down;
3782 POINT pt;
3783 int rop = X11DRV_XROPfunction[GetROP2(physDev->hdc) - 1];
3784
3785 if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
3786 &descr.infoBpp, &descr.compression ) == -1)
3787 return 0;
3788
3789 top_down = (height < 0);
3790 if (top_down) height = -height;
3791
3792 pt.x = xDest;
3793 pt.y = yDest;
3794 LPtoDP(physDev->hdc, &pt, 1);
3795
3796 if (!lines || (startscan >= height)) return 0;
3797 if (!top_down && startscan + lines > height) lines = height - startscan;
3798
3799 /* make xSrc,ySrc point to the upper-left corner, not the lower-left one,
3800 * and clamp all values to fit inside [startscan,startscan+lines]
3801 */
3802 if (ySrc + cy <= startscan + lines)
3803 {
3804 UINT y = startscan + lines - (ySrc + cy);
3805 if (ySrc < startscan) cy -= (startscan - ySrc);
3806 if (!top_down)
3807 {
3808 /* avoid getting unnecessary lines */
3809 ySrc = 0;
3810 if (y >= lines) return 0;
3811 lines -= y;
3812 }
3813 else
3814 {
3815 if (y >= lines) return lines;
3816 ySrc = y; /* need to get all lines in top down mode */
3817 }
3818 }
3819 else
3820 {
3821 if (ySrc >= startscan + lines) return lines;
3822 pt.y += ySrc + cy - (startscan + lines);
3823 cy = startscan + lines - ySrc;
3824 ySrc = 0;
3825 if (cy > lines) cy = lines;
3826 }
3827 if (xSrc >= width) return lines;
3828 if (xSrc + cx >= width) cx = width - xSrc;
3829 if (!cx || !cy) return lines;
3830
3831 /* Update the pixmap from the DIB section */
3832 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
3833
3834 X11DRV_SetupGCForText( physDev ); /* To have the correct colors */
3835 wine_tsx11_lock();
3836 XSetFunction(gdi_display, physDev->gc, rop);
3837 wine_tsx11_unlock();
3838
3839 switch (descr.infoBpp)
3840 {
3841 case 1:
3842 case 4:
3843 case 8:
3844 descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
3845 physDev, coloruse,
3846 physDev->depth, info, &descr.nColorMap );
3847 if (!descr.colorMap) return 0;
3848 descr.rMask = descr.gMask = descr.bMask = 0;
3849 break;
3850 case 15:
3851 case 16:
3852 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0x7c00;
3853 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x03e0;
3854 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x001f;
3855 descr.colorMap = 0;
3856 break;
3857
3858 case 24:
3859 case 32:
3860 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0xff0000;
3861 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x00ff00;
3862 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x0000ff;
3863 descr.colorMap = 0;
3864 break;
3865 }
3866
3867 descr.physDev = physDev;
3868 descr.bits = bits;
3869 descr.image = NULL;
3870 descr.palentry = NULL;
3871 descr.lines = top_down ? -lines : lines;
3872 descr.infoWidth = width;
3873 descr.depth = physDev->depth;
3874 descr.drawable = physDev->drawable;
3875 descr.gc = physDev->gc;
3876 descr.xSrc = xSrc;
3877 descr.ySrc = ySrc;
3878 descr.xDest = physDev->dc_rect.left + pt.x;
3879 descr.yDest = physDev->dc_rect.top + pt.y;
3880 descr.width = cx;
3881 descr.height = cy;
3882 descr.useShm = FALSE;
3883 descr.dibpitch = ((width * descr.infoBpp + 31) &~31) / 8;
3884
3885 result = X11DRV_DIB_SetImageBits( &descr );
3886
3887 if (descr.infoBpp <= 8)
3888 HeapFree(GetProcessHeap(), 0, descr.colorMap);
3889
3890 /* Update the DIBSection of the pixmap */
3891 X11DRV_UnlockDIBSection(physDev, TRUE);
3892
3893 return result;
3894 }
3895
3896 /***********************************************************************
3897 * SetDIBits (X11DRV.@)
3898 */
3899 INT X11DRV_SetDIBits( X11DRV_PDEVICE *physDev, HBITMAP hbitmap, UINT startscan,
3900 UINT lines, LPCVOID bits, const BITMAPINFO *info, UINT coloruse )
3901 {
3902 X_PHYSBITMAP *physBitmap = X11DRV_get_phys_bitmap( hbitmap );
3903 X11DRV_DIB_IMAGEBITS_DESCR descr;
3904 BITMAP bitmap;
3905 LONG width, height, tmpheight;
3906 INT result;
3907
3908 descr.physDev = physDev;
3909
3910 if (!physBitmap) return 0;
3911
3912 if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
3913 &descr.infoBpp, &descr.compression ) == -1)
3914 return 0;
3915
3916 tmpheight = height;
3917 if (height < 0) height = -height;
3918 if (!lines || (startscan >= height))
3919 return 0;
3920
3921 if (!GetObjectW( hbitmap, sizeof(bitmap), &bitmap )) return 0;
3922
3923 if (startscan + lines > height) lines = height - startscan;
3924
3925 switch (descr.infoBpp)
3926 {
3927 case 1:
3928 case 4:
3929 case 8:
3930 descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
3931 descr.physDev, coloruse,
3932 physBitmap->pixmap_depth,
3933 info, &descr.nColorMap );
3934 if (!descr.colorMap) return 0;
3935 descr.rMask = descr.gMask = descr.bMask = 0;
3936 break;
3937 case 15:
3938 case 16:
3939 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0x7c00;
3940 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x03e0;
3941 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x001f;
3942 descr.colorMap = 0;
3943 break;
3944
3945 case 24:
3946 case 32:
3947 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0xff0000;
3948 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x00ff00;
3949 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x0000ff;
3950 descr.colorMap = 0;
3951 break;
3952
3953 default: break;
3954 }
3955
3956 descr.bits = bits;
3957 descr.image = NULL;
3958 descr.palentry = NULL;
3959 descr.infoWidth = width;
3960 descr.lines = tmpheight >= 0 ? lines : -lines;
3961 descr.depth = physBitmap->pixmap_depth;
3962 descr.drawable = physBitmap->pixmap;
3963 descr.gc = BITMAP_GC(physBitmap);
3964 descr.xSrc = 0;
3965 descr.ySrc = 0;
3966 descr.xDest = 0;
3967 descr.yDest = height - startscan - lines;
3968 descr.width = bitmap.bmWidth;
3969 descr.height = lines;
3970 descr.useShm = FALSE;
3971 descr.dibpitch = ((descr.infoWidth * descr.infoBpp + 31) &~31) / 8;
3972 X11DRV_DIB_Lock( physBitmap, DIB_Status_GdiMod );
3973 result = X11DRV_DIB_SetImageBits( &descr );
3974
3975 /* optimisation for the case where the input bits are in exactly the same
3976 * format as the internal representation and copying to the app bits is
3977 * cheap - saves a round trip to the X server */
3978 if (descr.compression == BI_RGB &&
3979 coloruse == DIB_RGB_COLORS &&
3980 descr.infoBpp == bitmap.bmBitsPixel &&
3981 physBitmap->base && physBitmap->size < 65536)
3982 {
3983 unsigned int srcwidthb = bitmap.bmWidthBytes;
3984 int dstwidthb = X11DRV_DIB_GetDIBWidthBytes( width, descr.infoBpp );
3985 LPBYTE dbits = physBitmap->base, sbits = (LPBYTE)bits + (startscan * srcwidthb);
3986 int widthb;
3987 UINT y;
3988
3989 TRACE("syncing compatible set bits to app bits\n");
3990 if ((tmpheight < 0) ^ (bitmap.bmHeight < 0))
3991 {
3992 dbits = (LPBYTE)bits + (dstwidthb * (lines-1));
3993 dstwidthb = -dstwidthb;
3994 }
3995 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
3996 widthb = min(srcwidthb, abs(dstwidthb));
3997 for (y = 0; y < lines; y++, dbits += dstwidthb, sbits += srcwidthb)
3998 memcpy(dbits, sbits, widthb);
3999 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4000 physBitmap->status = DIB_Status_InSync;
4001 }
4002 X11DRV_DIB_Unlock( physBitmap, TRUE );
4003
4004 HeapFree(GetProcessHeap(), 0, descr.colorMap);
4005
4006 return result;
4007 }
4008
4009 /***********************************************************************
4010 * GetDIBits (X11DRV.@)
4011 */
4012 INT X11DRV_GetDIBits( X11DRV_PDEVICE *physDev, HBITMAP hbitmap, UINT startscan, UINT lines,
4013 LPVOID bits, BITMAPINFO *info, UINT coloruse )
4014 {
4015 X_PHYSBITMAP *physBitmap = X11DRV_get_phys_bitmap( hbitmap );
4016 DIBSECTION dib;
4017 X11DRV_DIB_IMAGEBITS_DESCR descr;
4018 PALETTEENTRY palette[256];
4019 size_t obj_size;
4020 int height;
4021 LONG width, tempHeight;
4022 int bitmap_type;
4023 BOOL core_header;
4024 void* colorPtr;
4025
4026 GetPaletteEntries( GetCurrentObject( physDev->hdc, OBJ_PAL ), 0, 256, palette );
4027
4028 if (!physBitmap) return 0;
4029 if (!(obj_size = GetObjectW( hbitmap, sizeof(dib), &dib ))) return 0;
4030
4031 bitmap_type = DIB_GetBitmapInfo( (BITMAPINFOHEADER*)info, &width, &tempHeight, &descr.infoBpp, &descr.compression);
4032 descr.lines = tempHeight;
4033 if (bitmap_type == -1)
4034 {
4035 ERR("Invalid bitmap\n");
4036 return 0;
4037 }
4038 core_header = (bitmap_type == 0);
4039 colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
4040
4041 TRACE("%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
4042 lines, dib.dsBm.bmWidth, dib.dsBm.bmHeight, width, descr.lines, startscan);
4043
4044 if( lines > dib.dsBm.bmHeight ) lines = dib.dsBm.bmHeight;
4045
4046 height = descr.lines;
4047 if (height < 0) height = -height;
4048 if( lines > height ) lines = height;
4049 /* Top-down images have a negative biHeight, the scanlines of these images
4050 * were inverted in X11DRV_DIB_GetImageBits_xx
4051 * To prevent this we simply change the sign of lines
4052 * (the number of scan lines to copy).
4053 * Negative lines are correctly handled by X11DRV_DIB_GetImageBits_xx.
4054 */
4055 if( descr.lines < 0 && lines > 0) lines = -lines;
4056
4057 if( startscan >= dib.dsBm.bmHeight ) return 0;
4058
4059 descr.colorMap = NULL;
4060
4061 switch (descr.infoBpp)
4062 {
4063 case 1:
4064 case 4:
4065 case 8:
4066 descr.rMask= descr.gMask = descr.bMask = 0;
4067 if(coloruse == DIB_RGB_COLORS)
4068 descr.colorMap = colorPtr;
4069 else {
4070 int num_colors = 1 << descr.infoBpp, i;
4071 RGBQUAD *rgb;
4072 COLORREF colref;
4073 WORD *index = (WORD*)colorPtr;
4074 descr.colorMap = rgb = HeapAlloc(GetProcessHeap(), 0, num_colors * sizeof(RGBQUAD));
4075 for(i = 0; i < num_colors; i++, rgb++, index++) {
4076 colref = X11DRV_PALETTE_ToLogical(X11DRV_PALETTE_ToPhysical(physDev, PALETTEINDEX(*index)));
4077 rgb->rgbRed = GetRValue(colref);
4078 rgb->rgbGreen = GetGValue(colref);
4079 rgb->rgbBlue = GetBValue(colref);
4080 rgb->rgbReserved = 0;
4081 }
4082 }
4083 break;
4084 case 15:
4085 case 16:
4086 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0x7c00;
4087 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x03e0;
4088 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x001f;
4089 break;
4090 case 24:
4091 case 32:
4092 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors : 0xff0000;
4093 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x00ff00;
4094 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x0000ff;
4095 break;
4096 }
4097
4098 descr.physDev = physDev;
4099 descr.palentry = palette;
4100 descr.bits = bits;
4101 descr.image = physBitmap->image;
4102 descr.infoWidth = width;
4103 descr.lines = lines;
4104 descr.depth = physBitmap->pixmap_depth;
4105 descr.drawable = physBitmap->pixmap;
4106 descr.gc = BITMAP_GC(physBitmap);
4107 descr.width = dib.dsBm.bmWidth;
4108 descr.height = dib.dsBm.bmHeight;
4109 descr.xDest = 0;
4110 descr.yDest = 0;
4111 descr.xSrc = 0;
4112 descr.sizeImage = core_header ? 0 : info->bmiHeader.biSizeImage;
4113
4114 if (descr.lines > 0)
4115 {
4116 descr.ySrc = (descr.height-1) - (startscan + (lines-1));
4117 }
4118 else
4119 {
4120 descr.ySrc = startscan;
4121 }
4122 #ifdef HAVE_LIBXXSHM
4123 descr.useShm = (obj_size == sizeof(DIBSECTION)) && (physBitmap->shminfo.shmid != -1);
4124 #else
4125 descr.useShm = FALSE;
4126 #endif
4127 descr.dibpitch = (obj_size == sizeof(DIBSECTION)) ? dib.dsBm.bmWidthBytes
4128 : (((descr.infoWidth * descr.infoBpp + 31) &~31) / 8);
4129
4130 X11DRV_DIB_Lock( physBitmap, DIB_Status_GdiMod );
4131 X11DRV_DIB_GetImageBits( &descr );
4132 X11DRV_DIB_Unlock( physBitmap, TRUE );
4133
4134 if(!core_header && info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */
4135 info->bmiHeader.biSizeImage = X11DRV_DIB_GetDIBImageBytes( descr.infoWidth,
4136 descr.lines,
4137 descr.infoBpp);
4138
4139 if (descr.compression == BI_BITFIELDS)
4140 {
4141 *(DWORD *)info->bmiColors = descr.rMask;
4142 *((DWORD *)info->bmiColors + 1) = descr.gMask;
4143 *((DWORD *)info->bmiColors + 2) = descr.bMask;
4144 }
4145 else if (!core_header)
4146 {
4147 /* if RLE or JPEG compression were supported,
4148 * this line would be invalid. */
4149 info->bmiHeader.biCompression = 0;
4150 }
4151
4152 if(descr.colorMap != colorPtr)
4153 HeapFree(GetProcessHeap(), 0, descr.colorMap);
4154 return lines;
4155 }
4156
4157 /***********************************************************************
4158 * X11DRV_DIB_DoCopyDIBSection
4159 */
4160 static void X11DRV_DIB_DoCopyDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB,
4161 void *colorMap, int nColorMap,
4162 Drawable dest, GC gc,
4163 DWORD xSrc, DWORD ySrc,
4164 DWORD xDest, DWORD yDest,
4165 DWORD width, DWORD height)
4166 {
4167 DIBSECTION dibSection;
4168 X11DRV_DIB_IMAGEBITS_DESCR descr;
4169 int identity[2] = {0,1};
4170
4171 if (!GetObjectW( physBitmap->hbitmap, sizeof(dibSection), &dibSection )) return;
4172
4173 descr.physDev = NULL;
4174 descr.palentry = NULL;
4175 descr.infoWidth = dibSection.dsBmih.biWidth;
4176 descr.infoBpp = dibSection.dsBmih.biBitCount;
4177 descr.lines = dibSection.dsBmih.biHeight;
4178 descr.image = physBitmap->image;
4179 descr.colorMap = colorMap;
4180 descr.nColorMap = nColorMap;
4181 descr.bits = dibSection.dsBm.bmBits;
4182 descr.depth = physBitmap->pixmap_depth;
4183 descr.compression = dibSection.dsBmih.biCompression;
4184
4185 if(descr.infoBpp == 1)
4186 descr.colorMap = (void*)identity;
4187
4188 switch (descr.infoBpp)
4189 {
4190 case 1:
4191 case 4:
4192 case 8:
4193 descr.rMask = descr.gMask = descr.bMask = 0;
4194 break;
4195 case 15:
4196 case 16:
4197 descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0x7c00;
4198 descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x03e0;
4199 descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x001f;
4200 break;
4201
4202 case 24:
4203 case 32:
4204 descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0xff0000;
4205 descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x00ff00;
4206 descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x0000ff;
4207 break;
4208 }
4209
4210 /* Hack for now */
4211 descr.drawable = dest;
4212 descr.gc = gc;
4213 descr.xSrc = xSrc;
4214 descr.ySrc = ySrc;
4215 descr.xDest = xDest;
4216 descr.yDest = yDest;
4217 descr.width = width;
4218 descr.height = height;
4219 descr.sizeImage = 0;
4220
4221 #ifdef HAVE_LIBXXSHM
4222 descr.useShm = (physBitmap->shminfo.shmid != -1);
4223 #else
4224 descr.useShm = FALSE;
4225 #endif
4226 descr.dibpitch = dibSection.dsBm.bmWidthBytes;
4227
4228 if (toDIB)
4229 {
4230 TRACE("Copying from Pixmap to DIB bits\n");
4231 X11DRV_DIB_GetImageBits( &descr );
4232 }
4233 else
4234 {
4235 TRACE("Copying from DIB bits to Pixmap\n");
4236 X11DRV_DIB_SetImageBits( &descr );
4237 }
4238 }
4239
4240 /***********************************************************************
4241 * X11DRV_DIB_CopyDIBSection
4242 */
4243 void X11DRV_DIB_CopyDIBSection(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
4244 DWORD xSrc, DWORD ySrc, DWORD xDest, DWORD yDest,
4245 DWORD width, DWORD height)
4246 {
4247 DIBSECTION dib;
4248 X_PHYSBITMAP *physBitmap;
4249 unsigned int nColorMap;
4250 int* x11ColorMap;
4251 int freeColorMap;
4252
4253 TRACE("(%p,%p,%d,%d,%d,%d,%d,%d)\n", physDevSrc->hdc, physDevDst->hdc,
4254 xSrc, ySrc, xDest, yDest, width, height);
4255 /* this function is meant as an optimization for BitBlt,
4256 * not to be called otherwise */
4257 physBitmap = physDevSrc->bitmap;
4258 if (!physBitmap || GetObjectW( physBitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
4259 {
4260 ERR("called for non-DIBSection!?\n");
4261 return;
4262 }
4263 /* while BitBlt should already have made sure we only get
4264 * positive values, we should check for oversize values */
4265 if ((xSrc < dib.dsBm.bmWidth) &&
4266 (ySrc < dib.dsBm.bmHeight)) {
4267 if (xSrc + width > dib.dsBm.bmWidth)
4268 width = dib.dsBm.bmWidth - xSrc;
4269 if (ySrc + height > dib.dsBm.bmHeight)
4270 height = dib.dsBm.bmHeight - ySrc;
4271 /* if the source bitmap is 8bpp or less, we're supposed to use the
4272 * DC's palette for color conversion (not the DIB color table) */
4273 if (dib.dsBm.bmBitsPixel <= 8) {
4274 HPALETTE hPalette = GetCurrentObject( physDevSrc->hdc, OBJ_PAL );
4275 if (!hPalette || (hPalette == GetStockObject(DEFAULT_PALETTE))) {
4276 /* HACK: no palette has been set in the source DC,
4277 * use the DIB colormap instead - this is necessary in some
4278 * cases since we need to do depth conversion in some places
4279 * where real Windows can just copy data straight over */
4280 x11ColorMap = physBitmap->colorMap;
4281 nColorMap = physBitmap->nColorMap;
4282 freeColorMap = FALSE;
4283 } else {
4284 const BITMAPINFO* info = (BITMAPINFO*)&dib.dsBmih;
4285 int i;
4286
4287 nColorMap = X11DRV_DIB_GetColorCount(info);
4288 x11ColorMap = HeapAlloc(GetProcessHeap(), 0, nColorMap * sizeof(int));
4289 for (i = 0; i < nColorMap; i++)
4290 x11ColorMap[i] = X11DRV_PALETTE_ToPhysical(physDevSrc, PALETTEINDEX(i));
4291 freeColorMap = TRUE;
4292 }
4293 }
4294 else
4295 {
4296 nColorMap = 0;
4297 x11ColorMap = NULL;
4298 freeColorMap = FALSE;
4299 }
4300 /* perform the copy */
4301 X11DRV_DIB_DoCopyDIBSection(physBitmap, FALSE, x11ColorMap, nColorMap,
4302 physDevDst->drawable, physDevDst->gc, xSrc, ySrc,
4303 physDevDst->dc_rect.left + xDest, physDevDst->dc_rect.top + yDest,
4304 width, height);
4305 /* free color mapping */
4306 if (freeColorMap)
4307 HeapFree(GetProcessHeap(), 0, x11ColorMap);
4308 }
4309 }
4310
4311 /***********************************************************************
4312 * X11DRV_DIB_DoUpdateDIBSection
4313 */
4314 static void X11DRV_DIB_DoUpdateDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB)
4315 {
4316 BITMAP bitmap;
4317
4318 GetObjectW( physBitmap->hbitmap, sizeof(bitmap), &bitmap );
4319 X11DRV_DIB_DoCopyDIBSection(physBitmap, toDIB,
4320 physBitmap->colorMap, physBitmap->nColorMap,
4321 physBitmap->pixmap, BITMAP_GC(physBitmap),
4322 0, 0, 0, 0, bitmap.bmWidth, bitmap.bmHeight);
4323 }
4324
4325 /***********************************************************************
4326 * X11DRV_DIB_FaultHandler
4327 */
4328 static LONG CALLBACK X11DRV_DIB_FaultHandler( PEXCEPTION_POINTERS ep )
4329 {
4330 X_PHYSBITMAP *physBitmap = NULL;
4331 BOOL found = FALSE;
4332 BYTE *addr;
4333 struct list *ptr;
4334 const size_t pagemask = getpagesize() - 1;
4335
4336 if (ep->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION)
4337 return EXCEPTION_CONTINUE_SEARCH;
4338
4339 addr = (BYTE *)ep->ExceptionRecord->ExceptionInformation[1];
4340
4341 EnterCriticalSection(&dibs_cs);
4342 LIST_FOR_EACH( ptr, &dibs_list )
4343 {
4344 physBitmap = LIST_ENTRY( ptr, X_PHYSBITMAP, entry );
4345 if ((physBitmap->base <= addr) &&
4346 (addr < physBitmap->base + ((physBitmap->size + pagemask) & ~pagemask)))
4347 {
4348 found = TRUE;
4349 break;
4350 }
4351 }
4352 LeaveCriticalSection(&dibs_cs);
4353
4354 if (!found) return EXCEPTION_CONTINUE_SEARCH;
4355
4356 if (addr >= physBitmap->base + physBitmap->size)
4357 WARN( "%p: access to %p beyond the end of the DIB\n", physBitmap->hbitmap, addr );
4358
4359 X11DRV_DIB_Lock( physBitmap, DIB_Status_None );
4360 if (ep->ExceptionRecord->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT) {
4361 /* the app tried to write the DIB bits */
4362 X11DRV_DIB_Coerce( physBitmap, DIB_Status_AppMod);
4363 } else {
4364 /* the app tried to read the DIB bits */
4365 X11DRV_DIB_Coerce( physBitmap, DIB_Status_InSync);
4366 }
4367 X11DRV_DIB_Unlock( physBitmap, TRUE );
4368
4369 return EXCEPTION_CONTINUE_EXECUTION;
4370 }
4371
4372 /***********************************************************************
4373 * X11DRV_DIB_Coerce
4374 */
4375 static INT X11DRV_DIB_Coerce(X_PHYSBITMAP *physBitmap, INT req)
4376 {
4377 INT ret = DIB_Status_None;
4378
4379 if (!physBitmap->image) return ret; /* not a DIB section */
4380 EnterCriticalSection(&physBitmap->lock);
4381 ret = physBitmap->status;
4382 switch (req) {
4383 case DIB_Status_GdiMod:
4384 /* GDI access - request to draw on pixmap */
4385 switch (physBitmap->status)
4386 {
4387 default:
4388 case DIB_Status_None:
4389 physBitmap->p_status = DIB_Status_GdiMod;
4390 X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
4391 break;
4392
4393 case DIB_Status_GdiMod:
4394 TRACE("GdiMod requested in status GdiMod\n" );
4395 physBitmap->p_status = DIB_Status_GdiMod;
4396 break;
4397
4398 case DIB_Status_InSync:
4399 TRACE("GdiMod requested in status InSync\n" );
4400 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
4401 physBitmap->status = DIB_Status_GdiMod;
4402 physBitmap->p_status = DIB_Status_InSync;
4403 break;
4404
4405 case DIB_Status_AppMod:
4406 TRACE("GdiMod requested in status AppMod\n" );
4407 /* make it readonly to avoid app changing data while we copy */
4408 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4409 X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
4410 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
4411 physBitmap->p_status = DIB_Status_AppMod;
4412 physBitmap->status = DIB_Status_GdiMod;
4413 break;
4414 }
4415 break;
4416
4417 case DIB_Status_InSync:
4418 /* App access - request access to read DIB surface */
4419 /* (typically called from signal handler) */
4420 switch (physBitmap->status)
4421 {
4422 default:
4423 case DIB_Status_None:
4424 /* shouldn't happen from signal handler */
4425 break;
4426
4427 case DIB_Status_GdiMod:
4428 TRACE("InSync requested in status GdiMod\n" );
4429 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4430 X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4431 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4432 physBitmap->status = DIB_Status_InSync;
4433 break;
4434
4435 case DIB_Status_InSync:
4436 TRACE("InSync requested in status InSync\n" );
4437 /* shouldn't happen from signal handler */
4438 break;
4439
4440 case DIB_Status_AppMod:
4441 TRACE("InSync requested in status AppMod\n" );
4442 /* no reason to do anything here, and this
4443 * shouldn't happen from signal handler */
4444 break;
4445 }
4446 break;
4447
4448 case DIB_Status_AppMod:
4449 /* App access - request access to write DIB surface */
4450 /* (typically called from signal handler) */
4451 switch (physBitmap->status)
4452 {
4453 default:
4454 case DIB_Status_None:
4455 /* shouldn't happen from signal handler */
4456 break;
4457
4458 case DIB_Status_GdiMod:
4459 TRACE("AppMod requested in status GdiMod\n" );
4460 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4461 X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4462 physBitmap->status = DIB_Status_AppMod;
4463 break;
4464
4465 case DIB_Status_InSync:
4466 TRACE("AppMod requested in status InSync\n" );
4467 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4468 physBitmap->status = DIB_Status_AppMod;
4469 break;
4470
4471 case DIB_Status_AppMod:
4472 TRACE("AppMod requested in status AppMod\n" );
4473 /* shouldn't happen from signal handler */
4474 break;
4475 }
4476 break;
4477
4478 /* it is up to the caller to do the copy/conversion, probably
4479 * using the return value to decide where to copy from */
4480 }
4481 LeaveCriticalSection(&physBitmap->lock);
4482 return ret;
4483 }
4484
4485 /***********************************************************************
4486 * X11DRV_DIB_Lock
4487 */
4488 static INT X11DRV_DIB_Lock(X_PHYSBITMAP *physBitmap, INT req)
4489 {
4490 INT ret = DIB_Status_None;
4491
4492 if (!physBitmap->image) return ret; /* not a DIB section */
4493 TRACE("Locking %p from thread %04x\n", physBitmap->hbitmap, GetCurrentThreadId());
4494 EnterCriticalSection(&physBitmap->lock);
4495 ret = physBitmap->status;
4496 if (req != DIB_Status_None)
4497 X11DRV_DIB_Coerce(physBitmap, req);
4498 return ret;
4499 }
4500
4501 /***********************************************************************
4502 * X11DRV_DIB_Unlock
4503 */
4504 static void X11DRV_DIB_Unlock(X_PHYSBITMAP *physBitmap, BOOL commit)
4505 {
4506 if (!physBitmap->image) return; /* not a DIB section */
4507 switch (physBitmap->status)
4508 {
4509 default:
4510 case DIB_Status_None:
4511 /* in case anyone is wondering, this is the "signal handler doesn't
4512 * work" case, where we always have to be ready for app access */
4513 if (commit) {
4514 switch (physBitmap->p_status)
4515 {
4516 case DIB_Status_GdiMod:
4517 TRACE("Unlocking and syncing from GdiMod\n" );
4518 X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4519 break;
4520
4521 default:
4522 TRACE("Unlocking without needing to sync\n" );
4523 break;
4524 }
4525 }
4526 else TRACE("Unlocking with no changes\n");
4527 physBitmap->p_status = DIB_Status_None;
4528 break;
4529
4530 case DIB_Status_GdiMod:
4531 TRACE("Unlocking in status GdiMod\n" );
4532 /* DIB was protected in Coerce */
4533 if (!commit) {
4534 /* no commit, revert to InSync if applicable */
4535 if ((physBitmap->p_status == DIB_Status_InSync) ||
4536 (physBitmap->p_status == DIB_Status_AppMod)) {
4537 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4538 physBitmap->status = DIB_Status_InSync;
4539 }
4540 }
4541 break;
4542
4543 case DIB_Status_InSync:
4544 TRACE("Unlocking in status InSync\n" );
4545 /* DIB was already protected in Coerce */
4546 break;
4547
4548 case DIB_Status_AppMod:
4549 TRACE("Unlocking in status AppMod\n" );
4550 /* DIB was already protected in Coerce */
4551 /* this case is ordinary only called from the signal handler,
4552 * so we don't bother to check for !commit */
4553 break;
4554 }
4555 LeaveCriticalSection(&physBitmap->lock);
4556 TRACE("Unlocked %p\n", physBitmap->hbitmap);
4557 }
4558
4559 /***********************************************************************
4560 * X11DRV_CoerceDIBSection
4561 */
4562 INT X11DRV_CoerceDIBSection(X11DRV_PDEVICE *physDev, INT req)
4563 {
4564 if (!physDev || !physDev->bitmap) return DIB_Status_None;
4565 return X11DRV_DIB_Coerce(physDev->bitmap, req);
4566 }
4567
4568 /***********************************************************************
4569 * X11DRV_LockDIBSection
4570 */
4571 INT X11DRV_LockDIBSection(X11DRV_PDEVICE *physDev, INT req)
4572 {
4573 if (!physDev || !physDev->bitmap) return DIB_Status_None;
4574 return X11DRV_DIB_Lock(physDev->bitmap, req);
4575 }
4576
4577 /***********************************************************************
4578 * X11DRV_UnlockDIBSection
4579 */
4580 void X11DRV_UnlockDIBSection(X11DRV_PDEVICE *physDev, BOOL commit)
4581 {
4582 if (!physDev || !physDev->bitmap) return;
4583 X11DRV_DIB_Unlock(physDev->bitmap, commit);
4584 }
4585
4586
4587 #ifdef HAVE_LIBXXSHM
4588 /***********************************************************************
4589 * X11DRV_XShmErrorHandler
4590 *
4591 */
4592 static int XShmErrorHandler( Display *dpy, XErrorEvent *event, void *arg )
4593 {
4594 return 1; /* FIXME: should check event contents */
4595 }
4596
4597 /***********************************************************************
4598 * X11DRV_XShmCreateImage
4599 *
4600 */
4601 static XImage *X11DRV_XShmCreateImage( int width, int height, int bpp,
4602 XShmSegmentInfo* shminfo)
4603 {
4604 XImage *image;
4605
4606 image = XShmCreateImage(gdi_display, visual, bpp, ZPixmap, NULL, shminfo, width, height);
4607 if (image)
4608 {
4609 shminfo->shmid = shmget(IPC_PRIVATE, image->bytes_per_line * height,
4610 IPC_CREAT|0700);
4611 if( shminfo->shmid != -1 )
4612 {
4613 shminfo->shmaddr = image->data = shmat(shminfo->shmid, 0, 0);
4614 if( shminfo->shmaddr != (char*)-1 )
4615 {
4616 BOOL ok;
4617
4618 shminfo->readOnly = FALSE;
4619 X11DRV_expect_error( gdi_display, XShmErrorHandler, NULL );
4620 ok = (XShmAttach( gdi_display, shminfo ) != 0);
4621 XSync( gdi_display, False );
4622 if (X11DRV_check_error()) ok = FALSE;
4623 if (ok)
4624 {
4625 shmctl(shminfo->shmid, IPC_RMID, 0);
4626 return image; /* Success! */
4627 }
4628 /* An error occurred */
4629 shmdt(shminfo->shmaddr);
4630 }
4631 shmctl(shminfo->shmid, IPC_RMID, 0);
4632 shminfo->shmid = -1;
4633 }
4634 XFlush(gdi_display);
4635 XDestroyImage(image);
4636 image = NULL;
4637 }
4638 return image;
4639 }
4640 #endif /* HAVE_LIBXXSHM */
4641
4642
4643 /***********************************************************************
4644 * X11DRV_CreateDIBSection (X11DRV.@)
4645 */
4646 HBITMAP X11DRV_CreateDIBSection( X11DRV_PDEVICE *physDev, HBITMAP hbitmap,
4647 const BITMAPINFO *bmi, UINT usage )
4648 {
4649 X_PHYSBITMAP *physBitmap;
4650 DIBSECTION dib;
4651
4652 if (!(physBitmap = X11DRV_init_phys_bitmap( hbitmap ))) return 0;
4653 physBitmap->status = DIB_Status_None;
4654
4655 GetObjectW( hbitmap, sizeof(dib), &dib );
4656
4657 /* create color map */
4658 if (dib.dsBm.bmBitsPixel <= 8)
4659 {
4660 physBitmap->colorMap = X11DRV_DIB_BuildColorMap( physDev,
4661 usage, dib.dsBm.bmBitsPixel, bmi,
4662 &physBitmap->nColorMap );
4663 }
4664
4665 /* create pixmap and X image */
4666 wine_tsx11_lock();
4667 physBitmap->pixmap_depth = (dib.dsBm.bmBitsPixel == 1) ? 1 : screen_depth;
4668 physBitmap->pixmap = XCreatePixmap( gdi_display, root_window, dib.dsBm.bmWidth,
4669 dib.dsBm.bmHeight, physBitmap->pixmap_depth );
4670 #ifdef HAVE_LIBXXSHM
4671 physBitmap->shminfo.shmid = -1;
4672 if (!XShmQueryExtension(gdi_display) ||
4673 !(physBitmap->image = X11DRV_XShmCreateImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4674 physBitmap->pixmap_depth, &physBitmap->shminfo )) )
4675 #endif
4676 physBitmap->image = X11DRV_DIB_CreateXImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4677 physBitmap->pixmap_depth );
4678 wine_tsx11_unlock();
4679 if (!physBitmap->pixmap || !physBitmap->image) return 0;
4680
4681 /* install fault handler */
4682 InitializeCriticalSection( &physBitmap->lock );
4683 physBitmap->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": X_PHYSBITMAP.lock");
4684
4685 physBitmap->base = dib.dsBm.bmBits;
4686 physBitmap->size = dib.dsBmih.biSizeImage;
4687 physBitmap->status = DIB_Status_AppMod;
4688
4689 if (!dibs_handler)
4690 dibs_handler = AddVectoredExceptionHandler( TRUE, X11DRV_DIB_FaultHandler );
4691 EnterCriticalSection( &dibs_cs );
4692 list_add_head( &dibs_list, &physBitmap->entry );
4693 LeaveCriticalSection( &dibs_cs );
4694
4695 X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4696
4697 return hbitmap;
4698 }
4699
4700 /***********************************************************************
4701 * X11DRV_DIB_DeleteDIBSection
4702 */
4703 void X11DRV_DIB_DeleteDIBSection(X_PHYSBITMAP *physBitmap, DIBSECTION *dib)
4704 {
4705 BOOL last;
4706
4707 EnterCriticalSection( &dibs_cs );
4708 list_remove( &physBitmap->entry );
4709 last = list_empty( &dibs_list );
4710 LeaveCriticalSection( &dibs_cs );
4711
4712 if (last)
4713 {
4714 RemoveVectoredExceptionHandler( dibs_handler );
4715 dibs_handler = NULL;
4716 }
4717
4718 if (dib->dshSection)
4719 X11DRV_DIB_Coerce(physBitmap, DIB_Status_InSync);
4720
4721 if (physBitmap->image)
4722 {
4723 wine_tsx11_lock();
4724 #ifdef HAVE_LIBXXSHM
4725 if (physBitmap->shminfo.shmid != -1)
4726 {
4727 XShmDetach( gdi_display, &(physBitmap->shminfo) );
4728 XDestroyImage( physBitmap->image );
4729 shmdt( physBitmap->shminfo.shmaddr );
4730 physBitmap->shminfo.shmid = -1;
4731 }
4732 else
4733 #endif
4734 XDestroyImage( physBitmap->image );
4735 wine_tsx11_unlock();
4736 }
4737
4738 HeapFree(GetProcessHeap(), 0, physBitmap->colorMap);
4739 physBitmap->lock.DebugInfo->Spare[0] = 0;
4740 DeleteCriticalSection(&physBitmap->lock);
4741 }
4742
4743 /***********************************************************************
4744 * SetDIBColorTable (X11DRV.@)
4745 */
4746 UINT X11DRV_SetDIBColorTable( X11DRV_PDEVICE *physDev, UINT start, UINT count, const RGBQUAD *colors )
4747 {
4748 DIBSECTION dib;
4749 UINT ret = 0;
4750 X_PHYSBITMAP *physBitmap = physDev->bitmap;
4751
4752 if (!physBitmap) return 0;
4753 GetObjectW( physBitmap->hbitmap, sizeof(dib), &dib );
4754
4755 if (physBitmap->colorMap && start < physBitmap->nColorMap) {
4756 UINT end = count + start;
4757 if (end > physBitmap->nColorMap) end = physBitmap->nColorMap;
4758 /*
4759 * Changing color table might change the mapping between
4760 * DIB colors and X11 colors and thus alter the visible state
4761 * of the bitmap object.
4762 */
4763 /*
4764 * FIXME we need to recalculate the pen, brush, text and bkgnd pixels here,
4765 * at least for a 1 bpp dibsection
4766 */
4767 X11DRV_DIB_Lock( physBitmap, DIB_Status_AppMod );
4768 X11DRV_DIB_GenColorMap( physDev, physBitmap->colorMap, DIB_RGB_COLORS,
4769 dib.dsBm.bmBitsPixel,
4770 TRUE, colors, start, end );
4771 X11DRV_DIB_Unlock( physBitmap, TRUE );
4772 ret = end - start;
4773 }
4774 return ret;
4775 }
4776
4777
4778 /***********************************************************************
4779 * X11DRV_DIB_CreateDIBFromBitmap
4780 *
4781 * Allocates a packed DIB and copies the bitmap data into it.
4782 */
4783 HGLOBAL X11DRV_DIB_CreateDIBFromBitmap(HDC hdc, HBITMAP hBmp)
4784 {
4785 BITMAP bmp;
4786 HGLOBAL hPackedDIB;
4787 LPBYTE pPackedDIB;
4788 LPBITMAPINFOHEADER pbmiHeader;
4789 unsigned int cDataSize, cPackedSize, OffsetBits;
4790 int nLinesCopied;
4791
4792 if (!GetObjectW( hBmp, sizeof(bmp), &bmp )) return 0;
4793
4794 /*
4795 * A packed DIB contains a BITMAPINFO structure followed immediately by
4796 * an optional color palette and the pixel data.
4797 */
4798
4799 /* Calculate the size of the packed DIB */
4800 cDataSize = X11DRV_DIB_GetDIBWidthBytes( bmp.bmWidth, bmp.bmBitsPixel ) * abs( bmp.bmHeight );
4801 cPackedSize = sizeof(BITMAPINFOHEADER)
4802 + ( (bmp.bmBitsPixel <= 8) ? (sizeof(RGBQUAD) * (1 << bmp.bmBitsPixel)) : 0 )
4803 + cDataSize;
4804 /* Get the offset to the bits */
4805 OffsetBits = cPackedSize - cDataSize;
4806
4807 /* Allocate the packed DIB */
4808 TRACE("\tAllocating packed DIB of size %d\n", cPackedSize);
4809 hPackedDIB = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE /*| GMEM_ZEROINIT*/,
4810 cPackedSize );
4811 if ( !hPackedDIB )
4812 {
4813 WARN("Could not allocate packed DIB!\n");
4814 return 0;
4815 }
4816
4817 /* A packed DIB starts with a BITMAPINFOHEADER */
4818 pPackedDIB = GlobalLock(hPackedDIB);
4819 pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
4820
4821 /* Init the BITMAPINFOHEADER */
4822 pbmiHeader->biSize = sizeof(BITMAPINFOHEADER);
4823 pbmiHeader->biWidth = bmp.bmWidth;
4824 pbmiHeader->biHeight = bmp.bmHeight;
4825 pbmiHeader->biPlanes = 1;
4826 pbmiHeader->biBitCount = bmp.bmBitsPixel;
4827 pbmiHeader->biCompression = BI_RGB;
4828 pbmiHeader->biSizeImage = 0;
4829 pbmiHeader->biXPelsPerMeter = pbmiHeader->biYPelsPerMeter = 0;
4830 pbmiHeader->biClrUsed = 0;
4831 pbmiHeader->biClrImportant = 0;
4832
4833 /* Retrieve the DIB bits from the bitmap and fill in the
4834 * DIB color table if present */
4835
4836 nLinesCopied = GetDIBits(hdc, /* Handle to device context */
4837 hBmp, /* Handle to bitmap */
4838 0, /* First scan line to set in dest bitmap */
4839 bmp.bmHeight, /* Number of scan lines to copy */
4840 pPackedDIB + OffsetBits, /* [out] Address of array for bitmap bits */
4841 (LPBITMAPINFO) pbmiHeader, /* [out] Address of BITMAPINFO structure */
4842 0); /* RGB or palette index */
4843 GlobalUnlock(hPackedDIB);
4844
4845 /* Cleanup if GetDIBits failed */
4846 if (nLinesCopied != bmp.bmHeight)
4847 {
4848 TRACE("\tGetDIBits returned %d. Actual lines=%d\n", nLinesCopied, bmp.bmHeight);
4849 GlobalFree(hPackedDIB);
4850 hPackedDIB = 0;
4851 }
4852 return hPackedDIB;
4853 }
4854
4855
4856 /**************************************************************************
4857 * X11DRV_DIB_CreateDIBFromPixmap
4858 *
4859 * Allocates a packed DIB and copies the Pixmap data into it.
4860 * The Pixmap passed in is deleted after the conversion.
4861 */
4862 HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc)
4863 {
4864 HDC hdcMem;
4865 X_PHYSBITMAP *physBitmap;
4866 HBITMAP hBmp = 0, old;
4867 HGLOBAL hPackedDIB = 0;
4868 Window root;
4869 int x,y; /* Unused */
4870 unsigned border_width; /* Unused */
4871 unsigned int depth, width, height;
4872
4873 /* Get the Pixmap dimensions and bit depth */
4874 wine_tsx11_lock();
4875 if (!XGetGeometry(gdi_display, pixmap, &root, &x, &y, &width, &height,
4876 &border_width, &depth)) depth = 0;
4877 wine_tsx11_unlock();
4878 if (!depth) return 0;
4879
4880 TRACE("\tPixmap properties: width=%d, height=%d, depth=%d\n",
4881 width, height, depth);
4882
4883 /*
4884 * Create an HBITMAP with the same dimensions and BPP as the pixmap,
4885 * and make it a container for the pixmap passed.
4886 */
4887 if (!(hBmp = CreateBitmap( width, height, 1, depth_to_bpp(depth), NULL ))) return 0;
4888
4889 /* force bitmap to be owned by a screen DC */
4890 hdcMem = CreateCompatibleDC( hdc );
4891 old = SelectObject( hdcMem, hBmp );
4892
4893 physBitmap = X11DRV_get_phys_bitmap( hBmp );
4894
4895 wine_tsx11_lock();
4896 if (physBitmap->pixmap) XFreePixmap( gdi_display, physBitmap->pixmap );
4897 physBitmap->pixmap = pixmap;
4898 wine_tsx11_unlock();
4899
4900 SelectObject( hdcMem, old );
4901 DeleteDC( hdcMem );
4902
4903 /*
4904 * Create a packed DIB from the Pixmap wrapper bitmap created above.
4905 * A packed DIB contains a BITMAPINFO structure followed immediately by
4906 * an optional color palette and the pixel data.
4907 */
4908 hPackedDIB = X11DRV_DIB_CreateDIBFromBitmap(hdc, hBmp);
4909
4910 /* We can now get rid of the HBITMAP wrapper we created earlier.
4911 * Note: Simply calling DeleteObject will free the embedded Pixmap as well.
4912 */
4913 DeleteObject(hBmp);
4914
4915 TRACE("\tReturning packed DIB %p\n", hPackedDIB);
4916 return hPackedDIB;
4917 }
4918
4919
4920 /**************************************************************************
4921 * X11DRV_DIB_CreatePixmapFromDIB
4922 *
4923 * Creates a Pixmap from a packed DIB
4924 */
4925 Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
4926 {
4927 Pixmap pixmap;
4928 X_PHYSBITMAP *physBitmap;
4929 HBITMAP hBmp;
4930 LPBITMAPINFO pbmi;
4931
4932 /* Create a DDB from the DIB */
4933
4934 pbmi = GlobalLock(hPackedDIB);
4935 hBmp = CreateDIBitmap(hdc, &pbmi->bmiHeader, CBM_INIT,
4936 (LPBYTE)pbmi + X11DRV_DIB_BitmapInfoSize( pbmi, DIB_RGB_COLORS ),
4937 pbmi, DIB_RGB_COLORS);
4938 GlobalUnlock(hPackedDIB);
4939
4940 /* clear the physBitmap so that we can steal its pixmap */
4941 physBitmap = X11DRV_get_phys_bitmap( hBmp );
4942 pixmap = physBitmap->pixmap;
4943 physBitmap->pixmap = 0;
4944
4945 /* Delete the DDB we created earlier now that we have stolen its pixmap */
4946 DeleteObject(hBmp);
4947
4948 TRACE("Returning Pixmap %ld\n", pixmap);
4949 return pixmap;
4950 }
Windows API implementation