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