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