?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix a sign bug where memcpy was called with negative length.
[wine.git] / graphics / x11drv / dib.c
blob5db9589dd8145908a964c80b7aafc3f2e326efa9
1 /*
2 * X11DRV device-independent bitmaps
3 *
4 * Copyright 1993,1994 Alexandre Julliard
5 */
6
7 #include "config.h"
8
9 #ifndef X_DISPLAY_MISSING
10
11 #include "ts_xlib.h"
12 #include "ts_xutil.h"
13
14 #ifdef HAVE_LIBXXSHM
15 # include "ts_xshm.h"
16 # ifdef HAVE_SYS_SHM_H
17 # include <sys/shm.h>
18 # endif
19 # ifdef HAVE_SYS_IPC_H
20 # include <sys/ipc.h>
21 # endif
22 #endif /* defined(HAVE_LIBXXSHM) */
23
24 #include "windef.h"
25 #include "bitmap.h"
26 #include "x11drv.h"
27 #include "debugtools.h"
28 #include "dc.h"
29 #include "color.h"
30 #include "callback.h"
31 #include "selectors.h"
32 #include "global.h"
33 #include "xmalloc.h" /* for XCREATEIMAGE macro */
34
35 DEFAULT_DEBUG_CHANNEL(bitmap)
36 DECLARE_DEBUG_CHANNEL(x11drv)
37
38 static int bitmapDepthTable[] = { 8, 1, 32, 16, 24, 15, 4, 0 };
39 static int ximageDepthTable[] = { 0, 0, 0, 0, 0, 0, 0 };
40
41 static int XShmErrorFlag = 0;
42
43 /***********************************************************************
44 * X11DRV_DIB_Init
45 */
46 BOOL X11DRV_DIB_Init(void)
47 {
48 int i;
49 XImage* testimage;
50
51 for( i = 0; bitmapDepthTable[i]; i++ )
52 {
53 testimage = TSXCreateImage(display, DefaultVisualOfScreen(X11DRV_GetXScreen()),
54 bitmapDepthTable[i], ZPixmap, 0, NULL, 1, 1, 32, 20 );
55 if( testimage ) ximageDepthTable[i] = testimage->bits_per_pixel;
56 else return FALSE;
57 TSXDestroyImage(testimage);
58 }
59 return TRUE;
60 }
61
62
63 /***********************************************************************
64 * X11DRV_DIB_GetXImageWidthBytes
65 *
66 * Return the width of an X image in bytes
67 */
68 int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
69 {
70 int i;
71
72 if (!ximageDepthTable[0]) {
73 X11DRV_DIB_Init();
74 }
75 for( i = 0; bitmapDepthTable[i] ; i++ )
76 if( bitmapDepthTable[i] == depth )
77 return (4 * ((width * ximageDepthTable[i] + 31)/32));
78
79 WARN("(%d): Unsupported depth\n", depth );
80 return (4 * width);
81 }
82
83 /***********************************************************************
84 * X11DRV_DIB_BuildColorMap
85 *
86 * Build the color map from the bitmap palette. Should not be called
87 * for a >8-bit deep bitmap.
88 */
89 int *X11DRV_DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth,
90 const BITMAPINFO *info, int *nColors )
91 {
92 int i, colors;
93 BOOL isInfo;
94 WORD *colorPtr;
95 int *colorMapping;
96
97 if ((isInfo = (info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))))
98 {
99 colors = info->bmiHeader.biClrUsed;
100 if (!colors) colors = 1 << info->bmiHeader.biBitCount;
101 colorPtr = (WORD *)info->bmiColors;
102 }
103 else /* assume BITMAPCOREINFO */
104 {
105 colors = 1 << ((BITMAPCOREHEADER *)&info->bmiHeader)->bcBitCount;
106 colorPtr = (WORD *)((BITMAPCOREINFO *)info)->bmciColors;
107 }
108
109 if (colors > 256)
110 {
111 ERR("called with >256 colors!\n");
112 return NULL;
113 }
114
115 if (!(colorMapping = (int *)HeapAlloc(GetProcessHeap(), 0,
116 colors * sizeof(int) )))
117 return NULL;
118
119 if (coloruse == DIB_RGB_COLORS)
120 {
121 if (isInfo)
122 {
123 RGBQUAD * rgb = (RGBQUAD *)colorPtr;
124
125 if (depth == 1) /* Monochrome */
126 for (i = 0; i < colors; i++, rgb++)
127 colorMapping[i] = (rgb->rgbRed + rgb->rgbGreen +
128 rgb->rgbBlue > 255*3/2);
129 else
130 for (i = 0; i < colors; i++, rgb++)
131 colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, RGB(rgb->rgbRed,
132 rgb->rgbGreen,
133 rgb->rgbBlue));
134 }
135 else
136 {
137 RGBTRIPLE * rgb = (RGBTRIPLE *)colorPtr;
138
139 if (depth == 1) /* Monochrome */
140 for (i = 0; i < colors; i++, rgb++)
141 colorMapping[i] = (rgb->rgbtRed + rgb->rgbtGreen +
142 rgb->rgbtBlue > 255*3/2);
143 else
144 for (i = 0; i < colors; i++, rgb++)
145 colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, RGB(rgb->rgbtRed,
146 rgb->rgbtGreen,
147 rgb->rgbtBlue));
148 }
149 }
150 else /* DIB_PAL_COLORS */
151 {
152 for (i = 0; i < colors; i++, colorPtr++)
153 colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, PALETTEINDEX(*colorPtr) );
154 }
155
156 *nColors = colors;
157 return colorMapping;
158 }
159
160
161 /***********************************************************************
162 * X11DRV_DIB_MapColor
163 */
164 int X11DRV_DIB_MapColor( int *physMap, int nPhysMap, int phys )
165 {
166 int color;
167
168 for (color = 0; color < nPhysMap; color++)
169 if (physMap[color] == phys)
170 return color;
171
172 WARN("Strange color %08x\n", phys);
173 return 0;
174 }
175
176
177 /*********************************************************************
178 * X11DRV_DIB_GetNearestIndex
179 *
180 * Helper for X11DRV_DIB_GetDIBits.
181 * Returns the nearest colour table index for a given RGB.
182 * Nearest is defined by minimizing the sum of the squares.
183 */
184 static INT X11DRV_DIB_GetNearestIndex(RGBQUAD *colormap, int numColors, BYTE r, BYTE g, BYTE b)
185 {
186 INT i, best = -1, diff, bestdiff = -1;
187 RGBQUAD *color;
188
189 for(color = colormap, i = 0; i < numColors; color++, i++) {
190 diff = (r - color->rgbRed) * (r - color->rgbRed) +
191 (g - color->rgbGreen) * (g - color->rgbGreen) +
192 (b - color->rgbBlue) * (b - color->rgbBlue);
193 if(diff == 0)
194 return i;
195 if(best == -1 || diff < bestdiff) {
196 best = i;
197 bestdiff = diff;
198 }
199 }
200 return best;
201 }
202
203 /***********************************************************************
204 * X11DRV_DIB_SetImageBits_1_Line
205 *
206 * Handles a single line of 1 bit data.
207 */
208 static void X11DRV_DIB_SetImageBits_1_Line(DWORD dstwidth, int left, int *colors,
209 XImage *bmpImage, int h, const BYTE *bits)
210 {
211 BYTE pix, extra;
212 DWORD i, x;
213
214 if((extra = (left & 7)) != 0) {
215 left &= ~7;
216 dstwidth += extra;
217 }
218
219 bits += left >> 3;
220
221 /* FIXME: should avoid putting x<left pixels (minor speed issue) */
222 for (i = dstwidth/8, x = left; i > 0; i--)
223 {
224 pix = *bits++;
225 XPutPixel( bmpImage, x++, h, colors[pix >> 7] );
226 XPutPixel( bmpImage, x++, h, colors[(pix >> 6) & 1] );
227 XPutPixel( bmpImage, x++, h, colors[(pix >> 5) & 1] );
228 XPutPixel( bmpImage, x++, h, colors[(pix >> 4) & 1] );
229 XPutPixel( bmpImage, x++, h, colors[(pix >> 3) & 1] );
230 XPutPixel( bmpImage, x++, h, colors[(pix >> 2) & 1] );
231 XPutPixel( bmpImage, x++, h, colors[(pix >> 1) & 1] );
232 XPutPixel( bmpImage, x++, h, colors[pix & 1] );
233 }
234 pix = *bits;
235 switch(dstwidth & 7)
236 {
237 case 7: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
238 case 6: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
239 case 5: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
240 case 4: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
241 case 3: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
242 case 2: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
243 case 1: XPutPixel( bmpImage, x++, h, colors[pix >> 7] );
244 }
245 }
246
247 /***********************************************************************
248 * X11DRV_DIB_SetImageBits_1
249 *
250 * SetDIBits for a 1-bit deep DIB.
251 */
252 static void X11DRV_DIB_SetImageBits_1( int lines, const BYTE *srcbits,
253 DWORD srcwidth, DWORD dstwidth, int left,
254 int *colors, XImage *bmpImage )
255 {
256 int h;
257
258 /* 32 bit aligned */
259 DWORD linebytes = ((srcwidth + 31) & ~31) / 8;
260
261 if (lines > 0) {
262 for (h = lines-1; h >=0; h--) {
263 X11DRV_DIB_SetImageBits_1_Line(dstwidth, left, colors, bmpImage, h,
264 srcbits);
265 srcbits += linebytes;
266 }
267 } else {
268 lines = -lines;
269 for (h = 0; h < lines; h++) {
270 X11DRV_DIB_SetImageBits_1_Line(dstwidth, left, colors, bmpImage, h,
271 srcbits);
272 srcbits += linebytes;
273 }
274 }
275 }
276
277 /***********************************************************************
278 * X11DRV_DIB_GetImageBits_1
279 *
280 * GetDIBits for a 1-bit deep DIB.
281 */
282 static void X11DRV_DIB_GetImageBits_1( int lines, BYTE *dstbits,
283 DWORD dstwidth, DWORD srcwidth,
284 RGBQUAD *colors, PALETTEENTRY *srccolors,
285 XImage *bmpImage )
286 {
287 DWORD x;
288 int h;
289 BYTE *bits;
290
291 /* 32 bit aligned */
292 DWORD linebytes = ((dstwidth + 31) & ~31) / 8;
293
294 if (lines < 0 ) {
295 lines = -lines;
296 dstbits = dstbits + linebytes * (lines - 1);
297 linebytes = -linebytes;
298 }
299
300 bits = dstbits;
301
302 switch(bmpImage->depth) {
303
304 case 1:
305 /* ==== monochrome bitmap to monochrome dib ==== */
306 case 4:
307 /* ==== 4 colormap bitmap to monochrome dib ==== */
308 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
309 {
310 PALETTEENTRY val;
311
312 for (h = lines - 1; h >= 0; h--) {
313 for (x = 0; x < dstwidth; x++) {
314 val = srccolors[XGetPixel(bmpImage, x, h)];
315 if (!(x&7)) *bits = 0;
316 *bits |= (X11DRV_DIB_GetNearestIndex(colors, 2,
317 val.peRed,
318 val.peGreen,
319 val.peBlue) << (7 - (x & 7)));
320 if ((x&7)==7) bits++;
321 }
322 bits = (dstbits += linebytes);
323 }
324 }
325 else goto notsupported;
326
327 break;
328
329 case 8:
330 /* ==== 8 colormap bitmap to monochrome dib ==== */
331 if ( bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
332 {
333 BYTE *srcpixel;
334 PALETTEENTRY val;
335
336 for( h = lines- 1; h >= 0; h-- ) {
337 srcpixel = bmpImage->data + (h*bmpImage->bytes_per_line);
338 for( x = 0; x < dstwidth; x++ ) {
339 if (!(x&7)) *bits = 0;
340 val = srccolors[(int)*srcpixel++];
341 *bits |= ( X11DRV_DIB_GetNearestIndex(colors, 2,
342 val.peRed,
343 val.peGreen,
344 val.peBlue) << (7-(x&7)) );
345 if ((x&7)==7) bits++;
346 }
347 bits = (dstbits += linebytes);
348 }
349 }
350 else goto notsupported;
351
352 break;
353
354 case 15:
355 {
356 LPWORD srcpixel;
357 WORD val;
358
359 /* ==== 555 BGR bitmap to monochrome dib ==== */
360 if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x1f)
361 {
362 for( h = lines - 1; h >= 0; h--) {
363 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
364 for( x = 0; x < dstwidth; x++) {
365 if (!(x&7)) *bits = 0;
366 val = *srcpixel++;
367 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
368 ((val >> 7) & 0xf8) |
369 ((val >> 12) & 0x7),
370 ((val >> 2) & 0xf8) |
371 ((val >> 7) & 0x3),
372 ((val << 3) & 0xf8) |
373 ((val >> 2) & 0x7) ) << (7-(x&7)) );
374 if ((x&7)==7) bits++;
375 }
376 bits = (dstbits += linebytes);
377 }
378 }
379 /* ==== 555 RGB bitmap to monochrome dib ==== */
380 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
381 {
382 for( h = lines - 1; h >= 0; h--)
383 {
384 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
385 for( x = 0; x < dstwidth; x++) {
386 if (!(x&1)) *bits = 0;
387 val = *srcpixel++;
388 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
389 ((val << 3) & 0xf8) |
390 ((val >> 2) & 0x7),
391 ((val >> 2) & 0xf8) |
392 ((val >> 7) & 0x3),
393 ((val >> 7) & 0xf8) |
394 ((val >> 12) & 0x7) ) << (7-(x&7)) );
395 if ((x&7)==7) bits++;
396 }
397 bits = (dstbits += linebytes);
398 }
399 }
400 else goto notsupported;
401 }
402 break;
403
404 case 16:
405 {
406 LPWORD srcpixel;
407 WORD val;
408
409 /* ==== 565 BGR bitmap to monochrome dib ==== */
410 if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
411 {
412 for( h = lines - 1; h >= 0; h--)
413 {
414 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
415 for( x = 0; x < dstwidth; x++) {
416 if (!(x&7)) *bits = 0;
417 val = *srcpixel++;
418 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
419 ((val >> 8) & 0xf8) |
420 ((val >> 13) & 0x7),
421 ((val >> 3) & 0xfc) |
422 ((val >> 9) & 0x3),
423 ((val << 3) & 0xf8) |
424 ((val >> 2) & 0x7) ) << (7-(x&7)) );
425 if ((x&7)==7) bits++;
426 }
427 bits = (dstbits += linebytes);
428 }
429 }
430 /* ==== 565 RGB bitmap to monochrome dib ==== */
431 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
432 {
433 for( h = lines - 1; h >= 0; h--)
434 {
435 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
436 for( x = 0; x < dstwidth; x++) {
437 if (!(x&7)) *bits = 0;
438 val = *srcpixel++;
439 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
440 ((val << 3) & 0xf8) |
441 ((val >> 2) & 0x7),
442 ((val >> 3) & 0xfc) |
443 ((val >> 9) & 0x3),
444 ((val >> 8) & 0xf8) |
445 ((val >> 13) & 0x7) ) << (7-(x&7)) );
446 if ((x&7)==7) bits++;
447 }
448 bits = (dstbits += linebytes);
449 }
450 }
451 else goto notsupported;
452 }
453 break;
454
455 case 24:
456 case 32:
457 {
458 BYTE *srcpixel;
459
460 /* ==== 24/32 BGR bitmap to monochrome dib ==== */
461 if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
462 {
463 for (h = lines - 1; h >= 0; h--)
464 {
465 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
466 for (x = 0; x < dstwidth; x++, srcpixel+=4) {
467 if (!(x&7)) *bits = 0;
468 *bits |= (X11DRV_DIB_GetNearestIndex(colors, 2, srcpixel[2] , srcpixel[1], srcpixel[0]) << (7-(x&7)) );
469 if ((x&7)==7) bits++;
470 }
471 bits = (dstbits += linebytes);
472 }
473 }
474 /* ==== 24/32 RGB bitmap to monochrome dib ==== */
475 else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
476 {
477 for (h = lines - 1; h >= 0; h--)
478 {
479 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
480 for (x = 0; x < dstwidth; x++, srcpixel+=4) {
481 if (!(x & 7)) *bits = 0;
482 *bits |= (X11DRV_DIB_GetNearestIndex(colors, 2, srcpixel[0] , srcpixel[1], srcpixel[2]) << (7-(x&7)) );
483 if ((x & 7) == 7) bits++;
484 }
485 bits = (dstbits += linebytes);
486 }
487 }
488 else goto notsupported;
489 }
490 break;
491
492 default: /* ? bit bmp -> monochrome DIB */
493 notsupported:
494 {
495 unsigned long white = (1 << bmpImage->bits_per_pixel) - 1;
496
497 FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 1 bit DIB\n",
498 bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
499 (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
500
501 for( h = lines - 1; h >= 0; h-- ) {
502 for( x = 0; x < dstwidth; x++ ) {
503 if (!(x&7)) *bits = 0;
504 *bits |= (XGetPixel( bmpImage, x, h) >= white)
505 << (7 - (x&7));
506 if ((x&7)==7) bits++;
507 }
508 bits = (dstbits += linebytes);
509 }
510 }
511 break;
512 }
513 }
514
515 /***********************************************************************
516 * X11DRV_DIB_SetImageBits_4
517 *
518 * SetDIBits for a 4-bit deep DIB.
519 */
520 static void X11DRV_DIB_SetImageBits_4( int lines, const BYTE *srcbits,
521 DWORD srcwidth, DWORD dstwidth, int left,
522 int *colors, XImage *bmpImage )
523 {
524 DWORD i, x;
525 int h;
526 const BYTE *bits = srcbits + (left >> 1);
527
528 /* 32 bit aligned */
529 DWORD linebytes = ((srcwidth+7)&~7)/2;
530
531 if(left & 1) {
532 left--;
533 dstwidth++;
534 }
535
536 if (lines > 0) {
537 for (h = lines-1; h >= 0; h--) {
538 for (i = dstwidth/2, x = left; i > 0; i--) {
539 BYTE pix = *bits++;
540 XPutPixel( bmpImage, x++, h, colors[pix >> 4] );
541 XPutPixel( bmpImage, x++, h, colors[pix & 0x0f] );
542 }
543 if (dstwidth & 1) XPutPixel( bmpImage, x, h, colors[*bits >> 4] );
544 srcbits += linebytes;
545 bits = srcbits + (left >> 1);
546 }
547 } else {
548 lines = -lines;
549 for (h = 0; h < lines; h++) {
550 for (i = dstwidth/2, x = left; i > 0; i--) {
551 BYTE pix = *bits++;
552 XPutPixel( bmpImage, x++, h, colors[pix >> 4] );
553 XPutPixel( bmpImage, x++, h, colors[pix & 0x0f] );
554 }
555 if (dstwidth & 1) XPutPixel( bmpImage, x, h, colors[*bits >> 4] );
556 srcbits += linebytes;
557 bits = srcbits + (left >> 1);
558 }
559 }
560 }
561
562
563
564 /***********************************************************************
565 * X11DRV_DIB_GetImageBits_4
566 *
567 * GetDIBits for a 4-bit deep DIB.
568 */
569 static void X11DRV_DIB_GetImageBits_4( int lines, BYTE *dstbits,
570 DWORD srcwidth, DWORD dstwidth,
571 RGBQUAD *colors, PALETTEENTRY *srccolors,
572 XImage *bmpImage )
573 {
574 DWORD x;
575 int h;
576 BYTE *bits;
577 LPBYTE srcpixel;
578
579 /* 32 bit aligned */
580 DWORD linebytes = ((srcwidth+7)&~7)/2;
581
582 if (lines < 0 )
583 {
584 lines = -lines;
585 dstbits = dstbits + ( linebytes * (lines-1) );
586 linebytes = -linebytes;
587 }
588
589 bits = dstbits;
590
591 switch(bmpImage->depth) {
592
593 case 1:
594 /* ==== monochrome bitmap to 4 colormap dib ==== */
595 case 4:
596 /* ==== 4 colormap bitmap to 4 colormap dib ==== */
597 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
598 {
599 PALETTEENTRY val;
600
601 for (h = lines-1; h >= 0; h--) {
602 for (x = 0; x < dstwidth; x++) {
603 if (!(x&1)) *bits = 0;
604 val = srccolors[XGetPixel(bmpImage, x, h)];
605 *bits |= (X11DRV_DIB_GetNearestIndex(colors, 16,
606 val.peRed,
607 val.peGreen,
608 val.peBlue) << (4-((x&1)<<2)));
609 if ((x&1)==1) bits++;
610 }
611 bits = (dstbits += linebytes);
612 }
613 }
614 else goto notsupported;
615
616 break;
617
618 case 8:
619 /* ==== 8 colormap bitmap to 4 colormap dib ==== */
620 if ( bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
621 {
622 PALETTEENTRY val;
623
624 for( h = lines - 1; h >= 0; h-- ) {
625 srcpixel = bmpImage->data + (h*bmpImage->bytes_per_line);
626 for( x = 0; x < dstwidth; x++ ) {
627 if (!(x&1)) *bits = 0;
628 val = srccolors[(int)*srcpixel++];
629 *bits |= ( X11DRV_DIB_GetNearestIndex(colors, 16,
630 val.peRed,
631 val.peGreen,
632 val.peBlue) << (4*(1-(x&1))) );
633 if ((x&1)==1) bits++;
634 }
635 bits = (dstbits += linebytes);
636 }
637 }
638 else goto notsupported;
639
640 break;
641
642 case 15:
643 {
644 LPWORD srcpixel;
645 WORD val;
646
647 /* ==== 555 BGR bitmap to 4 colormap dib ==== */
648 if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x1f)
649 {
650 for( h = lines - 1; h >= 0; h--) {
651 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
652 for( x = 0; x < dstwidth; x++) {
653 if (!(x&1)) *bits = 0;
654 val = *srcpixel++;
655 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
656 ((val >> 7) & 0xf8) |
657 ((val >> 12) & 0x7),
658 ((val >> 2) & 0xf8) |
659 ((val >> 7) & 0x3),
660 ((val << 3) & 0xf8) |
661 ((val >> 2) & 0x7) ) << ((1-(x&1))<<2) );
662 if ((x&1)==1) bits++;
663 }
664 bits = (dstbits += linebytes);
665 }
666 }
667 /* ==== 555 RGB bitmap to 4 colormap dib ==== */
668 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
669 {
670 for( h = lines - 1; h >= 0; h--)
671 {
672 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
673 for( x = 0; x < dstwidth; x++) {
674 if (!(x&1)) *bits = 0;
675 val = *srcpixel++;
676 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
677 ((val << 3) & 0xf8) |
678 ((val >> 2) & 0x7),
679 ((val >> 2) & 0xfc) |
680 ((val >> 7) & 0x3),
681 ((val >> 7) & 0xf8) |
682 ((val >> 12) & 0x7) ) << ((1-(x&1))<<2) );
683 if ((x&1)==1) bits++;
684 }
685 bits = (dstbits += linebytes);
686 }
687 }
688 else goto notsupported;
689 }
690 break;
691
692 case 16:
693 {
694 LPWORD srcpixel;
695 WORD val;
696
697 /* ==== 565 BGR bitmap to 4 colormap dib ==== */
698 if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
699 {
700 for( h = lines - 1; h >= 0; h--)
701 {
702 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
703 for( x = 0; x < dstwidth; x++) {
704 if (!(x&1)) *bits = 0;
705 val = *srcpixel++;
706 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
707 ((val >> 8) & 0xf8) |
708 ((val >> 13) & 0x7),
709 ((val >> 3) & 0xfc) |
710 ((val >> 9) & 0x3),
711 ((val << 3) & 0xf8) |
712 ((val >> 2) & 0x7) ) << ((1-(x&1))<<2) );
713 if ((x&1)==1) bits++;
714 }
715 bits = (dstbits += linebytes);
716 }
717 }
718 /* ==== 565 RGB bitmap to 4 colormap dib ==== */
719 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
720 {
721 for( h = lines - 1; h >= 0; h--)
722 {
723 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
724 for( x = 0; x < dstwidth; x++) {
725 if (!(x&1)) *bits = 0;
726 val = *srcpixel++;
727 *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
728 ((val << 3) & 0xf8) |
729 ((val >> 2) & 0x7),
730 ((val >> 3) & 0xfc) |
731 ((val >> 9) & 0x3),
732 ((val >> 8) & 0xf8) |
733 ((val >> 13) & 0x7) ) << ((1-(x&1))<<2) );
734 if ((x&1)==1) bits++;
735 }
736 bits = (dstbits += linebytes);
737 }
738 }
739 else goto notsupported;
740 }
741 break;
742
743 case 24:
744 case 32:
745 {
746 BYTE *srcpixel;
747
748 /* ==== 24/32 BGR bitmap to 4 colormap dib ==== */
749 if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
750 {
751 for (h = lines - 1; h >= 0; h--)
752 {
753 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
754 for (x = 0; x < dstwidth; x+=2, srcpixel+=8) /* 2 pixels at a time */
755 *bits++ = (X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[2] , srcpixel[1], srcpixel[0]) << 4) |
756 X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[6] , srcpixel[5], srcpixel[4]);
757 bits = (dstbits += linebytes);
758 }
759 }
760 /* ==== 24/32 RGB bitmap to 4 colormap dib ==== */
761 else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
762 {
763 for (h = lines - 1; h >= 0; h--)
764 {
765 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
766 for (x = 0; x < dstwidth; x+=2, srcpixel+=8) /* 2 pixels at a time */
767 *bits++ = (X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[0] , srcpixel[1], srcpixel[2]) << 4) |
768 X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[4] , srcpixel[5], srcpixel[6]);
769 bits = (dstbits += linebytes);
770 }
771 }
772 else goto notsupported;
773 }
774 break;
775
776 default: /* ? bit bmp -> 4 bit DIB */
777 notsupported:
778 FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 4 bit DIB\n",
779 bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
780 (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
781 for (h = lines-1; h >= 0; h--) {
782 for (x = 0; x < dstwidth/2; x++) {
783 *bits++ = (X11DRV_DIB_MapColor((int *)colors, 16,
784 XGetPixel( bmpImage, x++, h )) << 4)
785 | (X11DRV_DIB_MapColor((int *)colors, 16,
786 XGetPixel( bmpImage, x++, h )) & 0x0f);
787 }
788 if (dstwidth & 1)
789 *bits = (X11DRV_DIB_MapColor((int *)colors, 16,
790 XGetPixel( bmpImage, x++, h )) << 4);
791 bits = (dstbits += linebytes);
792 }
793 break;
794 }
795 }
796
797 /***********************************************************************
798 * X11DRV_DIB_SetImageBits_RLE4
799 *
800 * SetDIBits for a 4-bit deep compressed DIB.
801 */
802 static void X11DRV_DIB_SetImageBits_RLE4( int lines, const BYTE *bits,
803 DWORD width, DWORD dstwidth,
804 int left, int *colors,
805 XImage *bmpImage )
806 {
807 int x = 0, c, length;
808 const BYTE *begin = bits;
809
810 lines--;
811
812 while ((int)lines >= 0) {
813 length = *bits++;
814 if (length) { /* encoded */
815 c = *bits++;
816 while (length--) {
817 if(x >= width) {
818 x = 0;
819 if(--lines < 0)
820 return;
821 }
822 XPutPixel(bmpImage, x++, lines, colors[c >>4]);
823 if (length) {
824 length--;
825 if(x >= width) {
826 x = 0;
827 if(--lines < 0)
828 return;
829 }
830 XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
831 }
832 }
833 } else {
834 length = *bits++;
835 switch (length) {
836 case 0: /* eol */
837 x = 0;
838 lines--;
839 continue;
840
841 case 1: /* eopicture */
842 return;
843
844 case 2: /* delta */
845 x += *bits++;
846 if(x >= width) {
847 FIXME_(x11drv)("x-delta is too large?\n");
848 return;
849 }
850 lines -= *bits++;
851 continue;
852
853 default: /* absolute */
854 while (length--) {
855 c = *bits++;
856 if(x >= width) {
857 x = 0;
858 if(--lines < 0)
859 return;
860 }
861 XPutPixel(bmpImage, x++, lines, colors[c >> 4]);
862 if (length) {
863 length--;
864 if(x >= width) {
865 x = 0;
866 if(--lines < 0)
867 return;
868 }
869 XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
870 }
871 }
872 if ((bits - begin) & 1)
873 bits++;
874 }
875 }
876 }
877 }
878
879
880
881 /***********************************************************************
882 * X11DRV_DIB_SetImageBits_8
883 *
884 * SetDIBits for an 8-bit deep DIB.
885 */
886 static void X11DRV_DIB_SetImageBits_8( int lines, const BYTE *srcbits,
887 DWORD srcwidth, DWORD dstwidth, int left,
888 int *colors, XImage *bmpImage )
889 {
890 DWORD x;
891 int h, color;
892 const BYTE *bits;
893
894 /* align to 32 bit */
895 DWORD linebytes = (srcwidth + 3) & ~3;
896
897 dstwidth += left;
898
899 if (lines < 0 )
900 {
901 lines = -lines;
902 srcbits = srcbits + ( linebytes * (lines-1) );
903 linebytes = -linebytes;
904 }
905
906 bits = srcbits + left;
907
908 for (h = lines - 1; h >= 0; h--) {
909 for (x = left; x < dstwidth; x++, bits++) {
910 color = colors[*bits];
911 XPutPixel( bmpImage, x, h, colors[*bits] );
912 }
913 bits = (srcbits += linebytes) + left;
914 }
915 }
916
917 /***********************************************************************
918 * X11DRV_DIB_GetImageBits_8
919 *
920 * GetDIBits for an 8-bit deep DIB.
921 */
922 static void X11DRV_DIB_GetImageBits_8( int lines, BYTE *dstbits,
923 DWORD srcwidth, DWORD dstwidth,
924 RGBQUAD *colors, PALETTEENTRY *srccolors,
925 XImage *bmpImage )
926 {
927 DWORD x;
928 int h;
929 BYTE *bits;
930
931 /* align to 32 bit */
932 DWORD linebytes = (srcwidth + 3) & ~3;
933
934 if (lines < 0 )
935 {
936 lines = -lines;
937 dstbits = dstbits + ( linebytes * (lines-1) );
938 linebytes = -linebytes;
939 }
940
941 bits = dstbits;
942
943 /*
944 Hack for now
945 This condition is true when GetImageBits has been called by UpdateDIBSection.
946 For now, GetNearestIndex is too slow to support 256 colormaps, so we'll just use for
947 for GetDIBits calls. (In somes cases, in a updateDIBSection, the returned colors are bad too)
948 */
949 if (!srccolors) goto updatesection;
950
951 switch(bmpImage->depth) {
952
953 case 1:
954 /* ==== monochrome bitmap to 8 colormap dib ==== */
955 case 4:
956 /* ==== 4 colormap bitmap to 8 colormap dib ==== */
957 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
958 {
959 PALETTEENTRY val;
960
961 for (h = lines - 1; h >= 0; h--) {
962 for (x = 0; x < dstwidth; x++) {
963 val = srccolors[XGetPixel(bmpImage, x, h)];
964 *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256, val.peRed,
965 val.peGreen, val.peBlue);
966 }
967 bits = (dstbits += linebytes);
968 }
969 }
970 else goto notsupported;
971
972 break;
973
974 case 8:
975 /* ==== 8 colormap bitmap to 8 colormap dib ==== */
976 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
977 {
978 BYTE *srcpixel;
979 PALETTEENTRY val;
980
981 for (h = lines - 1; h >= 0; h--) {
982 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
983 for (x = 0; x < dstwidth; x++) {
984 val = srccolors[(int)*srcpixel++];
985 *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256, val.peRed,
986 val.peGreen, val.peBlue);
987 }
988 bits = (dstbits += linebytes);
989 }
990 }
991 else goto notsupported;
992
993 break;
994
995 case 15:
996 {
997 LPWORD srcpixel;
998 WORD val;
999
1000 /* ==== 555 BGR bitmap to 8 colormap dib ==== */
1001 if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
1002 {
1003 for( h = lines - 1; h >= 0; h--)
1004 {
1005 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1006 for( x = 0; x < dstwidth; x++ )
1007 {
1008 val = *srcpixel++;
1009 *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1010 ((val >> 7) & 0xf8) |
1011 ((val >> 12) & 0x7),
1012 ((val >> 2) & 0xf8) |
1013 ((val >> 7) & 0x3),
1014 ((val << 3) & 0xf8) |
1015 ((val >> 2) & 0x7) );
1016 }
1017 bits = (dstbits += linebytes);
1018 }
1019 }
1020 /* ==== 555 RGB bitmap to 8 colormap dib ==== */
1021 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
1022 {
1023 for( h = lines - 1; h >= 0; h--)
1024 {
1025 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1026 for( x = 0; x < dstwidth; x++ )
1027 {
1028 val = *srcpixel++;
1029 *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1030 ((val << 3) & 0xf8) |
1031 ((val >> 2) & 0x7),
1032 ((val >> 2) & 0xf8) |
1033 ((val >> 7) & 0x3),
1034 ((val >> 7) & 0xf8) |
1035 ((val >> 12) & 0x7) );
1036 }
1037 bits = (dstbits += linebytes);
1038 }
1039 }
1040 else goto notsupported;
1041 }
1042 break;
1043
1044 case 16:
1045 {
1046 LPWORD srcpixel;
1047 WORD val;
1048
1049 /* ==== 565 BGR bitmap to 8 colormap dib ==== */
1050 if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
1051 {
1052 for( h = lines - 1; h >= 0; h--)
1053 {
1054 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1055 for( x = 0; x < dstwidth; x++ )
1056 {
1057 val = *srcpixel++;
1058 *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1059 ((val >> 8) & 0xf8) |
1060 ((val >> 13) & 0x7),
1061 ((val >> 3) & 0xfc) |
1062 ((val >> 9) & 0x3),
1063 ((val << 3) & 0xf8) |
1064 ((val >> 2) & 0x7) );
1065 }
1066 bits = (dstbits += linebytes);
1067 }
1068 }
1069 /* ==== 565 RGB bitmap to 8 colormap dib ==== */
1070 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
1071 {
1072 for( h = lines - 1; h >= 0; h--)
1073 {
1074 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1075 for( x = 0; x < dstwidth; x++ )
1076 {
1077 val = *srcpixel++;
1078 *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1079 ((val << 3) & 0xf8) |
1080 ((val >> 2) & 0x7),
1081 ((val >> 3) & 0x00fc) |
1082 ((val >> 9) & 0x3),
1083 ((val >> 8) & 0x00f8) |
1084 ((val >> 13) & 0x7) );
1085 }
1086 bits = (dstbits += linebytes);
1087 }
1088 }
1089 else goto notsupported;
1090 }
1091 break;
1092
1093 case 24:
1094 case 32:
1095 {
1096 BYTE *srcpixel;
1097
1098 /* ==== 24/32 BGR bitmap to 8 colormap dib ==== */
1099 if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
1100 {
1101 for (h = lines - 1; h >= 0; h--)
1102 {
1103 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
1104 for (x = 0; x < dstwidth; x++, srcpixel+=4)
1105 *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256,
1106 srcpixel[2] , srcpixel[1], *srcpixel);
1107 bits = (dstbits += linebytes);
1108 }
1109 }
1110 /* ==== 24/32 RGB bitmap to 8 colormap dib ==== */
1111 else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
1112 {
1113 for (h = lines - 1; h >= 0; h--)
1114 {
1115 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
1116 for (x = 0; x < dstwidth; x++, srcpixel+=4)
1117 *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256,
1118 *srcpixel, srcpixel[1], srcpixel[2]);
1119 bits = (dstbits += linebytes);
1120 }
1121
1122 }
1123 else goto notsupported;
1124 }
1125 break;
1126
1127 default: /* ? bit bmp -> 8 bit DIB */
1128 notsupported:
1129 FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 8 bit DIB\n",
1130 bmpImage->depth, (int)bmpImage->red_mask,
1131 (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
1132 updatesection:
1133 for (h = lines - 1; h >= 0; h--) {
1134 for (x = 0; x < dstwidth; x++, bits++) {
1135 *bits = X11DRV_DIB_MapColor((int *)colors, 256,
1136 XGetPixel( bmpImage, x, h ) );
1137 }
1138 bits = (dstbits += linebytes);
1139 }
1140 break;
1141 }
1142 }
1143
1144 /***********************************************************************
1145 * X11DRV_DIB_SetImageBits_RLE8
1146 *
1147 * SetDIBits for an 8-bit deep compressed DIB.
1148 *
1149 * This function rewritten 941113 by James Youngman. WINE blew out when I
1150 * first ran it because my desktop wallpaper is a (large) RLE8 bitmap.
1151 *
1152 * This was because the algorithm assumed that all RLE8 bitmaps end with the
1153 * 'End of bitmap' escape code. This code is very much laxer in what it
1154 * allows to end the expansion. Possibly too lax. See the note by
1155 * case RleDelta. BTW, MS's documentation implies that a correct RLE8
1156 * bitmap should end with RleEnd, but on the other hand, software exists
1157 * that produces ones that don't and Windows 3.1 doesn't complain a bit
1158 * about it.
1159 *
1160 * (No) apologies for my English spelling. [Emacs users: c-indent-level=4].
1161 * James A. Youngman <mbcstjy@afs.man.ac.uk>
1162 * [JAY]
1163 */
1164
1165 enum Rle8_EscapeCodes
1166 {
1167 /*
1168 * Apologies for polluting your file's namespace...
1169 */
1170 RleEol = 0, /* End of line */
1171 RleEnd = 1, /* End of bitmap */
1172 RleDelta = 2 /* Delta */
1173 };
1174
1175 static void X11DRV_DIB_SetImageBits_RLE8( int lines, const BYTE *bits,
1176 DWORD width, DWORD dstwidth,
1177 int left, int *colors,
1178 XImage *bmpImage )
1179 {
1180 int x; /* X-positon on each line. Increases. */
1181 int line; /* Line #. Starts at lines-1, decreases */
1182 const BYTE *pIn = bits; /* Pointer to current position in bits */
1183 BYTE length; /* The length pf a run */
1184 BYTE color_index; /* index into colors[] as read from bits */
1185 BYTE escape_code; /* See enum Rle8_EscapeCodes.*/
1186 int color; /* value of colour[color_index] */
1187
1188 if (lines == 0) /* Let's hope this doesn't happen. */
1189 return;
1190
1191 /*
1192 * Note that the bitmap data is stored by Windows starting at the
1193 * bottom line of the bitmap and going upwards. Within each line,
1194 * the data is stored left-to-right. That's the reason why line
1195 * goes from lines-1 to 0. [JAY]
1196 */
1197
1198 x = 0;
1199 line = lines-1;
1200 do
1201 {
1202 length = *pIn++;
1203
1204 /*
1205 * If the length byte is not zero (which is the escape value),
1206 * We have a run of length pixels all the same colour. The colour
1207 * index is stored next.
1208 *
1209 * If the length byte is zero, we need to read the next byte to
1210 * know what to do. [JAY]
1211 */
1212 if (length != 0)
1213 {
1214 /*
1215 * [Run-Length] Encoded mode
1216 */
1217 color_index = (*pIn++); /* Get the colour index. */
1218 color = colors[color_index];
1219
1220 while(length--)
1221 XPutPixel(bmpImage, x++, line, color);
1222 }
1223 else
1224 {
1225 /*
1226 * Escape codes (may be an absolute sequence though)
1227 */
1228 escape_code = (*pIn++);
1229 switch(escape_code)
1230 {
1231 case RleEol: /* =0, end of line */
1232 {
1233 x = 0;
1234 line--;
1235 break;
1236 }
1237
1238 case RleEnd: /* =1, end of bitmap */
1239 {
1240 /*
1241 * Not all RLE8 bitmaps end with this
1242 * code. For example, Paint Shop Pro
1243 * produces some that don't. That's (I think)
1244 * what caused the previous implementation to
1245 * fail. [JAY]
1246 */
1247 line=-1; /* Cause exit from do loop. */
1248 break;
1249 }
1250
1251 case RleDelta: /* =2, a delta */
1252 {
1253 /*
1254 * Note that deltaing to line 0
1255 * will cause an exit from the loop,
1256 * which may not be what is intended.
1257 * The fact that there is a delta in the bits
1258 * almost certainly implies that there is data
1259 * to follow. You may feel that we should
1260 * jump to the top of the loop to avoid exiting
1261 * in this case.
1262 *
1263 * TODO: Decide what to do here in that case. [JAY]
1264 */
1265 x += (*pIn++);
1266 line -= (*pIn++);
1267 if (line == 0)
1268 {
1269 TRACE("Delta to last line of bitmap "
1270 "(wrongly?) causes loop exit\n");
1271 }
1272 break;
1273 }
1274
1275 default: /* >2, switch to absolute mode */
1276 {
1277 /*
1278 * Absolute Mode
1279 */
1280 length = escape_code;
1281 while(length--)
1282 {
1283 color_index = (*pIn++);
1284 XPutPixel(bmpImage, x++, line,
1285 colors[color_index]);
1286 }
1287
1288 /*
1289 * If you think for a moment you'll realise that the
1290 * only time we could ever possibly read an odd
1291 * number of bytes is when there is a 0x00 (escape),
1292 * a value >0x02 (absolute mode) and then an odd-
1293 * length run. Therefore this is the only place we
1294 * need to worry about it. Everywhere else the
1295 * bytes are always read in pairs. [JAY]
1296 */
1297 if (escape_code & 1)
1298 pIn++; /* Throw away the pad byte. */
1299 break;
1300 }
1301 } /* switch (escape_code) : Escape sequence */
1302 } /* process either an encoded sequence or an escape sequence */
1303
1304 /* We expect to come here more than once per line. */
1305 } while (line >= 0); /* Do this until the bitmap is filled */
1306
1307 /*
1308 * Everybody comes here at the end.
1309 * Check how we exited the loop and print a message if it's a bit odd.
1310 * [JAY]
1311 */
1312 if ( (*(pIn-2) != 0/*escape*/) || (*(pIn-1)!= RleEnd) )
1313 {
1314 TRACE("End-of-bitmap without (strictly) proper escape code. Last two "
1315 "bytes were: %02X %02X.\n", (int)*(pIn-2),(int)*(pIn-1));
1316 }
1317 }
1318
1319
1320 /***********************************************************************
1321 * X11DRV_DIB_SetImageBits_16
1322 *
1323 * SetDIBits for a 16-bit deep DIB.
1324 */
1325 static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits,
1326 DWORD srcwidth, DWORD dstwidth, int left,
1327 DC *dc, DWORD rSrc, DWORD gSrc, DWORD bSrc,
1328 XImage *bmpImage )
1329 {
1330 DWORD x;
1331 int h;
1332
1333 /* align to 32 bit */
1334 DWORD linebytes = (srcwidth * 2 + 3) & ~3;
1335
1336 if (lines < 0 )
1337 {
1338 lines = -lines;
1339 srcbits = srcbits + ( linebytes * (lines-1));
1340 linebytes = -linebytes;
1341 }
1342
1343 switch ( bmpImage->depth )
1344 {
1345 case 15:
1346 /* using same format as XImage */
1347 if (rSrc == bmpImage->red_mask && gSrc == bmpImage->green_mask && bSrc == bmpImage->blue_mask)
1348 for (h = lines - 1; h >= 0; h--, srcbits += linebytes)
1349 memcpy ( bmpImage->data + h * bmpImage->bytes_per_line + left*2, srcbits + left*2, dstwidth*2 );
1350 else /* We need to do a conversion from a 565 dib */
1351 {
1352 LPDWORD dstpixel, ptr = (LPDWORD)(srcbits + left*2);
1353 DWORD val;
1354 int div = dstwidth % 2;
1355
1356 for (h = lines - 1; h >= 0; h--) {
1357 dstpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1358 for (x = 0; x < dstwidth/2; x++) { /* Do 2 pixels at a time */
1359 val = *ptr++;
1360 *dstpixel++ = ((val >> 1) & 0x7fe07fe0) | (val & 0x001f001f); /* Red & Green & Blue */
1361 }
1362 if (div != 0) /* Odd width? */
1363 *dstpixel = ((*(WORD *)ptr >> 1) & 0x7fe0) | (*(WORD *)ptr & 0x001f);
1364 ptr = (LPDWORD) ((srcbits += linebytes) + left*2);
1365 }
1366 }
1367 break;
1368
1369 case 16:
1370 /* using same format as XImage */
1371 if (rSrc == bmpImage->red_mask && gSrc == bmpImage->green_mask && bSrc == bmpImage->blue_mask)
1372 for (h = lines - 1; h >= 0; h--, srcbits += linebytes)
1373 memcpy ( bmpImage->data + h * bmpImage->bytes_per_line + left*2, srcbits + left*2, dstwidth*2 );
1374 else /* We need to do a conversion from a 555 dib */
1375 {
1376 LPDWORD dstpixel, ptr = (LPDWORD)(srcbits + left*2);
1377 DWORD val;
1378 int div = dstwidth % 2;
1379
1380 for (h = lines - 1; h >= 0; h--) {
1381 dstpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1382 for (x = 0; x < dstwidth/2; x++) { /* Do 2 pixels at a time */
1383 val = *ptr++;
1384 *dstpixel++ = ((val << 1) & 0xffc0ffc0) | ((val >> 4) & 0x00200020) | /* Red & Green */
1385 (val & 0x001f001f); /* Blue */
1386 }
1387 if (div != 0) /* Odd width? */
1388 *dstpixel = ((*(WORD *)ptr << 1) & 0xffc0) | ((*(WORD *)ptr >> 4) & 0x0020)
1389 | (*(WORD *)ptr & 0x001f);
1390 ptr = (LPDWORD) ((srcbits += linebytes) + left*2);
1391 }
1392 }
1393 break;
1394
1395 case 24:
1396 case 32:
1397 {
1398 DWORD *dstpixel;
1399 LPWORD ptr = (LPWORD)srcbits + left;
1400 DWORD val;
1401
1402 /* ==== 555 BGR dib to 24/32 BGR bitmap ==== */
1403 if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
1404 {
1405 for (h = lines - 1; h >= 0; h--) {
1406 dstpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line + left*4);
1407 for (x = 0; x < dstwidth; x++) {
1408
1409 val = *ptr++;
1410 *dstpixel++ = ((val << 9) & 0xf80000) | ((val << 4) & 0x070000) | /* Red */
1411 ((val << 6) & 0x00f800) | ((val << 1) & 0x000700) | /* Green */
1412 ((val << 3) & 0x0000f8) | ((val >> 2) & 0x000007); /* Blue */
1413 }
1414 ptr = (LPWORD)(srcbits += linebytes) + left;
1415 }
1416 }
1417 /* ==== 555 BGR dib to 24/32 RGB bitmap ==== */
1418 else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
1419 {
1420 for (h = lines - 1; h >= 0; h--) {
1421 dstpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line + left*4);
1422 for (x = 0; x < dstwidth; x++) {
1423
1424 val = *ptr++;
1425 *dstpixel++ = ((val >> 7) & 0x0000f8) | ((val >> 12) & 0x000007) | /* Red */
1426 ((val << 6) & 0x00f800) | ((val << 1) & 0x000700) | /* Green */
1427 ((val << 19) & 0xf80000) | ((val >> 14) & 0x070000); /* Blue */
1428 }
1429 ptr = (LPWORD)(srcbits += linebytes) + left;
1430 }
1431 }
1432
1433 }
1434 break;
1435
1436 case 1:
1437 case 4:
1438 case 8:
1439 {
1440 LPWORD ptr = (LPWORD)srcbits + left;
1441 WORD val;
1442 int sc1, sc2;
1443
1444 /* Set color scaling values */
1445 if ( rSrc == 0x7c00 ) { sc1 = 7; sc2 = 2; } /* 555 dib */
1446 else { sc1 = 8; sc2 = 3; } /* 565 dib */
1447
1448 for (h = lines - 1; h >= 0; h--) {
1449 for (x = left; x < dstwidth+left; x++) {
1450 val = *ptr++;
1451 XPutPixel( bmpImage, x, h,
1452 X11DRV_PALETTE_ToPhysical(dc, RGB(((val & rSrc) >> sc1), /* Red */
1453 ((val & gSrc) >> sc2), /* Green */
1454 ((val & bSrc) << 3)))); /* Blue */
1455 }
1456 ptr = (LPWORD) (srcbits += linebytes) + left;
1457 }
1458 }
1459 break;
1460
1461 default:
1462 FIXME("16 bit DIB %d bit bitmap\n", bmpImage->bits_per_pixel);
1463 break;
1464
1465 }
1466 }
1467
1468
1469 /***********************************************************************
1470 * X11DRV_DIB_GetImageBits_16
1471 *
1472 * GetDIBits for an 16-bit deep DIB.
1473 */
1474 static void X11DRV_DIB_GetImageBits_16( int lines, BYTE *dstbits,
1475 DWORD dstwidth, DWORD srcwidth,
1476 PALETTEENTRY *srccolors, XImage *bmpImage )
1477 {
1478 DWORD x;
1479 int h;
1480
1481 /* align to 32 bit */
1482 DWORD linebytes = (dstwidth * 2 + 3) & ~3;
1483
1484 if (lines < 0 )
1485 {
1486 lines = -lines;
1487 dstbits = dstbits + ( linebytes * (lines-1));
1488 linebytes = -linebytes;
1489 }
1490
1491 switch ( bmpImage->depth )
1492 {
1493 case 15:
1494 /* ==== 555 BGR bitmap to 555 BGR dib ==== */
1495 if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
1496 for (h = lines - 1; h >= 0; h--, dstbits += linebytes)
1497 memcpy( dstbits, bmpImage->data + h*bmpImage->bytes_per_line, srcwidth*2 );
1498
1499 /* ==== 555 RGB bitmap to 555 BGR dib ==== */
1500 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
1501 {
1502 LPDWORD srcpixel, ptr = (LPDWORD)dstbits;
1503 DWORD val;
1504 int div = srcwidth % 2;
1505
1506 for (h = lines - 1; h >= 0; h--) {
1507 srcpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
1508 for (x = 0; x < srcwidth/2; x++) { /* Do 2 pixels at a time */
1509 val = *srcpixel++;
1510 *ptr++ = ((val << 10) & 0xf800f800) | (val & 0x03e003e0) | /* Red & Green */
1511 ((val >> 10) & 0x001f001f); /* Blue */
1512 }
1513 if (div != 0) /* Odd width? */
1514 *ptr = ((*(WORD *)srcpixel << 1) & 0xffc0) | ((*(WORD *)srcpixel >> 4) & 0x0020) |
1515 (*(WORD *)srcpixel & 0x001f);
1516 ptr = (LPDWORD)(dstbits += linebytes);
1517 }
1518 }
1519 else goto notsupported;
1520
1521 break;
1522
1523 case 16:
1524 {
1525 LPDWORD srcpixel, ptr = (LPDWORD)dstbits;
1526 DWORD val;
1527 int div = srcwidth % 2;
1528
1529 /* ==== 565 BGR bitmap to 555 BGR dib ==== */
1530 if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f )
1531 {
1532 for (h = lines - 1; h >= 0; h--) {
1533 srcpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
1534 for (x = 0; x < srcwidth/2; x++) { /* Do 2 pixels at a time */
1535 val = *srcpixel++;
1536 *ptr++ = ((val >> 1) & 0x7fe07fe0) | /* Red & Green */
1537 (val & 0x001f001f); /* Blue */
1538 }
1539 if (div != 0) /* Odd width? */
1540 *ptr = ((*(WORD *)srcpixel >> 1) & 0x7fe0) | (*(WORD *)srcpixel & 0x001f);
1541 ptr = (LPDWORD) (dstbits += linebytes);
1542 }
1543 }
1544 /* ==== 565 RGB bitmap to 555 BGR dib ==== */
1545 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
1546 {
1547 for (h = lines - 1; h >= 0; h--) {
1548 srcpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
1549 for (x = 0; x < srcwidth/2; x++) { /* Do 2 pixels at a time */
1550 val = *srcpixel++;
1551 *ptr++ = ((val << 10) & 0x7c007c00) | ((val >> 1) & 0x03e003e0) | /* Red & Green */
1552 ((val >> 11) & 0x001f001f); /* Blue */
1553 }
1554 if (div != 0) /* Odd width? */
1555 *ptr = ((*(WORD *)srcpixel >> 1) & 0x7fe0) | (*(WORD *)srcpixel & 0x001f);
1556 ptr = (LPDWORD) (dstbits += linebytes);
1557 }
1558 }
1559 else goto notsupported;
1560 }
1561 break;
1562
1563 case 24:
1564 case 32:
1565 {
1566 DWORD *srcpixel;
1567 LPWORD ptr = (LPWORD)dstbits;
1568 DWORD val;
1569
1570 /* ==== 24/32 BGR bitmap to 555 BGR dib ==== */
1571 if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
1572 {
1573 for (h = lines - 1; h >= 0; h--) {
1574 srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
1575 for (x = 0; x < srcwidth; x++, ptr++) {
1576 val = *srcpixel++;
1577 *ptr = ((val >> 9) & 0x7c00) | /* Red */
1578 ((val >> 6) & 0x03e0) | /* Green */
1579 ((val >> 3) & 0x001f); /* Blue */
1580 }
1581 ptr = (LPWORD)(dstbits += linebytes);
1582 }
1583 }
1584 /* ==== 24/32 RGB bitmap to 555 BGR dib ==== */
1585 else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
1586 {
1587 for (h = lines - 1; h >= 0; h--) {
1588 srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
1589 for (x = 0; x < srcwidth; x++, ptr++) {
1590 val = *srcpixel++;
1591 *ptr = ((val << 7) & 0x7c00) | /* Red */
1592 ((val >> 6) & 0x03e0) | /* Green */
1593 ((val >> 19) & 0x001f); /* Blue */
1594 }
1595 ptr = (LPWORD) (dstbits += linebytes);
1596 }
1597 }
1598 else goto notsupported;
1599 }
1600 break;
1601
1602 case 1:
1603 /* ==== monochrome bitmap to 16 BGR dib ==== */
1604 case 4:
1605 /* ==== 4 colormap bitmap to 16 BGR dib ==== */
1606 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
1607 {
1608 LPWORD ptr = (LPWORD)dstbits;
1609 PALETTEENTRY val;
1610
1611 for (h = lines - 1; h >= 0; h--) {
1612 for (x = 0; x < dstwidth; x++) {
1613 val = srccolors[XGetPixel(bmpImage, x, h)];
1614 *ptr++ = ((val.peRed << 7) & 0x7c00) |
1615 ((val.peGreen << 2) & 0x03e0) |
1616 ((val.peBlue >> 3) & 0x001f);
1617 }
1618 ptr = (LPWORD)(dstbits += linebytes);
1619 }
1620 }
1621 else goto notsupported;
1622
1623 break;
1624
1625 case 8:
1626 /* ==== 8 colormap bitmap to 16 BGR dib ==== */
1627 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
1628 {
1629 LPWORD ptr = (LPWORD)dstbits;
1630 BYTE *srcpixel;
1631 PALETTEENTRY val;
1632
1633 for (h = lines - 1; h >= 0; h--) {
1634 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
1635 for (x = 0; x < dstwidth; x++) {
1636 val = srccolors[(int)*srcpixel++];
1637 *ptr++ = ((val.peRed << 7) & 0x7c00) |
1638 ((val.peGreen << 2) & 0x03e0) |
1639 ((val.peBlue >> 3) & 0x001f);
1640 }
1641 ptr = (LPWORD)(dstbits += linebytes);
1642 }
1643 }
1644 else goto notsupported;
1645
1646 break;
1647
1648 default:
1649 notsupported:
1650 {
1651 BYTE r,g, b;
1652 LPWORD ptr = (LPWORD)dstbits;
1653
1654 FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 16 bit DIB\n",
1655 bmpImage->depth, (int)bmpImage->red_mask,
1656 (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
1657 for (h = lines - 1; h >= 0; h--)
1658 {
1659 for (x = 0; x < dstwidth; x++, ptr++)
1660 {
1661 COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) );
1662 r = (BYTE) GetRValue(pixel);
1663 g = (BYTE) GetGValue(pixel);
1664 b = (BYTE) GetBValue(pixel);
1665 *ptr = ( ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001f) );
1666 }
1667 ptr = (LPWORD) (dstbits += linebytes);
1668 }
1669 }
1670 break;
1671 }
1672 }
1673
1674
1675 /***********************************************************************
1676 * X11DRV_DIB_SetImageBits_24
1677 *
1678 * SetDIBits for a 24-bit deep DIB.
1679 */
1680 static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits,
1681 DWORD srcwidth, DWORD dstwidth, int left,
1682 DC *dc, XImage *bmpImage )
1683 {
1684 DWORD x;
1685 int h;
1686
1687 /* align to 32 bit */
1688 DWORD linebytes = (srcwidth * 3 + 3) & ~3;
1689
1690 if (lines < 0 )
1691 {
1692 lines = -lines;
1693 srcbits = srcbits + linebytes * (lines - 1);
1694 linebytes = -linebytes;
1695 }
1696
1697 switch ( bmpImage->depth )
1698 {
1699 case 24:
1700 case 32:
1701 {
1702 if( bmpImage->blue_mask == 0xff && bmpImage->red_mask == 0xff0000 ) /* packed BGR to unpacked BGR */
1703 {
1704 DWORD *dstpixel, val, buf;
1705 DWORD *ptr = (DWORD *)(srcbits + left*3);
1706 BYTE *bits;
1707 int div = dstwidth % 4;
1708 int divk;
1709
1710 for(h = lines - 1; h >= 0; h--)
1711 {
1712 dstpixel = (DWORD *) (bmpImage->data + h*bmpImage->bytes_per_line + left*4);
1713
1714 for (x = 0; x < dstwidth/4; x++) { /* do 3 dwords source, 4 dwords dest at a time */
1715 buf = *ptr++;
1716 *dstpixel++ = buf&0x00ffffff; /* b1, g1, r1 */
1717 val = (buf >> 24); /* b2 */
1718 buf = *ptr++;
1719 *dstpixel++ = (val | (buf<<8)) &0x00ffffff; /* g2, r2 */
1720 val = (buf >> 16); /* b3, g3 */
1721 buf = *ptr++;
1722 *dstpixel++ = (val | (buf<<16)) &0x00ffffff; /* r3 */
1723 *dstpixel++ = (buf >> 8); /* b4, g4, r4 */
1724 }
1725 for ( divk=div, bits=(BYTE*)ptr; divk>0; divk--, bits+=3 ) /* do remainder */
1726 {
1727 *dstpixel++ = *(DWORD*)bits & 0x00ffffff; /* b, g, r */
1728 }
1729 ptr = (DWORD*)((srcbits+=linebytes)+left*3);
1730 }
1731 }
1732 else if( bmpImage->blue_mask == 0xff0000 && bmpImage->red_mask == 0xff ) /* packed BGR to unpacked RGB */
1733 {
1734 DWORD *dstpixel, val, buf;
1735 DWORD *ptr = (DWORD *)(srcbits + left*3);
1736 BYTE *bits;
1737 int div = dstwidth % 4;
1738 int divk;
1739
1740 for(h = lines - 1; h >= 0; h--)
1741 {
1742 dstpixel = (DWORD *) (bmpImage->data + h*bmpImage->bytes_per_line + left*4);
1743
1744 for (x = 0; x < dstwidth/4; x++) { /* do 3 dwords source, 4 dwords dest at a time */
1745 buf = *ptr++;
1746 *dstpixel++ = ((buf&0xff)<<16) | (buf&0xff00) | ((buf&0xff0000)>>16); /* b1, g1, r1 */
1747 val = ((buf&0xff000000)>>8); /* b2 */
1748 buf = *ptr++;
1749 *dstpixel++ = val | ((buf&0xff)<<8) | ((buf&0xff00)>>8); /* g2, r2 */
1750 val = (buf&0xff0000) | ((buf&0xff000000)>>16); /* b3, g3 */
1751 buf = *ptr++;
1752 *dstpixel++ = val | (buf&0xff); /* r3 */
1753 *dstpixel++ = ((buf&0xff00)<<8) | ((buf&0xff0000)>>8) | (buf>>24); /* b4, g4, r4 */
1754 }
1755 for ( divk=div, bits=(BYTE*)ptr; divk>0; divk--, bits+=3 ) /* do remainder */
1756 {
1757 buf = *(DWORD*)bits;
1758 *dstpixel++ = ((buf&0xff)<<16) | (buf&0xff00) | ((buf&0xff0000)>>16); /* b, g, r */
1759 }
1760 ptr = (DWORD*)((srcbits+=linebytes)+left*3);
1761 }
1762 }
1763 else
1764 goto notsupported;
1765 }
1766 break;
1767
1768 case 15:
1769 {
1770 if( bmpImage->blue_mask == 0x7c00 && bmpImage->red_mask == 0x1f ) /* BGR888 to RGB555 */
1771 {
1772 DWORD *ptr = (DWORD *)(srcbits + left*3), val;
1773 LPBYTE bits;
1774 LPWORD dstpixel;
1775 int div = dstwidth % 4;
1776 int divk;
1777
1778 for (h = lines - 1; h >= 0; h--) { /* Do 4 pixels at a time */
1779 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1780 for (x = 0; x < dstwidth/4; x++) {
1781 *dstpixel++ = (WORD)((((val = *ptr++) << 7) & 0x7c00) | ((val >> 6) & 0x03e0) | ((val >> 19) & 0x1f));
1782 *dstpixel++ = (WORD)(((val >> 17) & 0x7c00) | (((val = *ptr++) << 2) & 0x03e0) | ((val >> 11) & 0x1f));
1783 *dstpixel++ = (WORD)(((val >> 9) & 0x07c00) | ((val >> 22) & 0x03e0) | (((val = *ptr++) >> 3) & 0x1f));
1784 *dstpixel++ = (WORD)(((val >> 1) & 0x07c00) | ((val >> 14) & 0x03e0) | ((val >> 27) & 0x1f));
1785 }
1786 for (bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3) /* dstwidth not divisible by 4? */
1787 *dstpixel++ = (((WORD)bits[0] << 7) & 0x07c00) |
1788 (((WORD)bits[1] << 2) & 0x03e0) |
1789 (((WORD)bits[2] >> 3) & 0x001f);
1790 ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1791 }
1792 }
1793 else if( bmpImage->blue_mask == 0x1f && bmpImage->red_mask == 0x7c00 ) /* BGR888 to BGR555 */
1794 {
1795 DWORD *ptr = (DWORD *)(srcbits + left*3), val;
1796 LPBYTE bits;
1797 LPWORD dstpixel;
1798 int div = dstwidth % 4;
1799 int divk;
1800
1801 for (h = lines - 1; h >= 0; h--) { /* Do 4 pixels at a time */
1802 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1803 for (x = 0; x < dstwidth/4; x++) {
1804 *dstpixel++ = (WORD)((((val = *ptr++) >> 3) & 0x1f) | ((val >> 6) & 0x03e0) | ((val >> 9) & 0x7c00));
1805 *dstpixel++ = (WORD)(((val >> 27) & 0x1f) | (((val = *ptr++) << 2) & 0x03e0) | ((val >> 1) & 0x7c00));
1806 *dstpixel++ = (WORD)(((val >> 19) & 0x1f) | ((val >> 22) & 0x03e0) | (((val = *ptr++) << 7) & 0x7c00));
1807 *dstpixel++ = (WORD)(((val >> 11) & 0x1f) | ((val >> 14) & 0x03e0) | ((val >> 17) & 0x7c00));
1808 }
1809 for (bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3) /* dstwidth not divisible by 4? */
1810 *dstpixel++ = (((WORD)bits[2] << 7) & 0x07c00) |
1811 (((WORD)bits[1] << 2) & 0x03e0) |
1812 (((WORD)bits[0] >> 3) & 0x001f);
1813 ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1814 }
1815 }
1816 else
1817 goto notsupported;
1818 }
1819 break;
1820
1821 case 16:
1822 {
1823 DWORD *ptr = (DWORD *)(srcbits + left*3), val;
1824 LPBYTE bits;
1825 LPWORD dstpixel;
1826 int div = dstwidth % 4;
1827 int divk;
1828
1829 if( bmpImage->blue_mask == 0x001f && bmpImage->red_mask == 0xf800 ) /* BGR888 to BGR565 */
1830 {
1831 for (h = lines - 1; h >= 0; h--) { /* Do 4 pixels at a time */
1832 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1833 for (x = 0; x < dstwidth/4; x++) {
1834 *dstpixel++ = (WORD)((((val = *ptr++) >> 3) & 0x1f) | ((val >> 5) & 0x07e0) | ((val >> 8) & 0xf800));
1835 *dstpixel++ = (WORD)(((val >> 27) & 0x1f) | (((val = *ptr++) << 3) & 0x07e0) | ((val) & 0xf800));
1836 *dstpixel++ = (WORD)(((val >> 19) & 0x1f) | ((val >> 21) & 0x07e0) | (((val = *ptr++) << 8) & 0xf800));
1837 *dstpixel++ = (WORD)(((val >> 11) & 0x1f) | ((val >> 13) & 0x07e0) | ((val >> 16) & 0xf800));
1838 }
1839 for ( bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3) /* dstwidth is not divisible by 4? */
1840 *dstpixel++ = (((WORD)bits[2] << 8) & 0xf800) |
1841 (((WORD)bits[1] << 3) & 0x07e0) |
1842 (((WORD)bits[0] >> 3) & 0x001f);
1843 ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1844 }
1845 }
1846 else if( bmpImage->blue_mask == 0xf800 && bmpImage->red_mask == 0x001f ) /* BGR888 to RGB565 */
1847 {
1848 for (h = lines - 1; h >= 0; h--) { /* Do 4 pixels at a time */
1849 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1850 for (x = 0; x < dstwidth/4; x++) {
1851 *dstpixel++ = (WORD)((((val = *ptr++) << 8) & 0xf800) | ((val >> 5) & 0x07e0) | ((val >> 19) & 0x1f));
1852 *dstpixel++ = (WORD)(((val >> 16) & 0xf800) | (((val = *ptr++) << 3) & 0x07e0) | ((val >> 11) & 0x1f));
1853 *dstpixel++ = (WORD)(((val >> 8) & 0xf800) | ((val >> 21) & 0x07e0) | (((val = *ptr++) >> 3) & 0x1f));
1854 *dstpixel++ = (WORD)((val & 0xf800) | ((val >> 13) & 0x07e0) | ((val >> 27) & 0x1f));
1855 }
1856 for ( bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3) /* dstwidth is not divisible by 4? */
1857 *dstpixel++ = (((WORD)bits[0] << 8) & 0xf800) |
1858 (((WORD)bits[1] << 3) & 0x07e0) |
1859 (((WORD)bits[2] >> 3) & 0x001f);
1860 ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1861 }
1862 }
1863 else
1864 goto notsupported;
1865 }
1866 break;
1867
1868 case 1:
1869 case 4:
1870 case 8:
1871 {
1872 LPBYTE bits = (LPBYTE)srcbits + left*3;
1873
1874 for (h = lines - 1; h >= 0; h--) {
1875 for (x = left; x < dstwidth+left; x++, bits+=3)
1876 XPutPixel( bmpImage, x, h,
1877 X11DRV_PALETTE_ToPhysical(dc, RGB(bits[2], bits[1], bits[0])));
1878 bits = (LPBYTE)(srcbits += linebytes) + left * 3;
1879 }
1880 }
1881 break;
1882
1883 default:
1884 notsupported:
1885 FIXME("from 24 bit DIB to %d bit bitmap with mask R,G,B %x,%x,%x\n",
1886 bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
1887 (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
1888 break;
1889 }
1890 }
1891
1892
1893 /***********************************************************************
1894 * X11DRV_DIB_GetImageBits_24
1895 *
1896 * GetDIBits for an 24-bit deep DIB.
1897 */
1898 static void X11DRV_DIB_GetImageBits_24( int lines, BYTE *dstbits,
1899 DWORD dstwidth, DWORD srcwidth,
1900 PALETTEENTRY *srccolors, XImage *bmpImage )
1901 {
1902 DWORD x, val;
1903 int h;
1904
1905 /* align to 32 bit */
1906 DWORD linebytes = (dstwidth * 3 + 3) & ~3;
1907
1908 if (lines < 0 )
1909 {
1910 lines = -lines;
1911 dstbits = dstbits + ( linebytes * (lines-1) );
1912 linebytes = -linebytes;
1913 }
1914
1915 switch ( bmpImage->depth )
1916 {
1917 case 24:
1918 case 32:
1919 {
1920 DWORD *srcpixel, buf;
1921 LPBYTE bits;
1922 DWORD *ptr=(DWORD *)dstbits;
1923 int quotient = dstwidth / 4;
1924 int remainder = dstwidth % 4;
1925 int remk;
1926
1927 /* ==== 24/32 BGR bitmap to 24 BGR dib==== */
1928 if( bmpImage->blue_mask == 0xff && bmpImage->red_mask == 0xff0000 )
1929 {
1930 for(h = lines - 1; h >= 0; h--)
1931 {
1932 srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
1933
1934 for (x = 0; x < quotient; x++) { /* do 4 dwords source, 3 dwords dest at a time*/
1935 buf = ((*srcpixel++)&0x00ffffff); /* b1, g1, r1*/
1936 *ptr++ = buf | ((*srcpixel)<<24); /* b2 */
1937 buf = ((*srcpixel++>>8)&0x0000ffff); /* g2, r2 */
1938 *ptr++ = buf | ((*srcpixel)<<16); /* b3, g3 */
1939 buf = ((*srcpixel++>>16)&0x000000ff); /* r3 */
1940 *ptr++ = buf | ((*srcpixel++)<<8); /* b4, g4, r4 */
1941 }
1942 for ( remk=remainder, bits=(BYTE*)ptr; remk>0; remk--, bits+=3 ) /* do remainder */
1943 {
1944 buf=*srcpixel++;
1945 *(WORD*)bits = buf; /* b, g */
1946 *(bits+2) = buf>>16; /* r */
1947 }
1948 ptr = (DWORD*)(dstbits+=linebytes);
1949 }
1950
1951 }
1952 /* ==== 24/32 RGB bitmap to 24 BGR dib ==== */
1953 else if( bmpImage->blue_mask == 0xff0000 && bmpImage->red_mask == 0xff )
1954 {
1955 for(h = lines - 1; h >= 0; h--)
1956 {
1957 srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
1958
1959 for (x = 0; x < quotient; x++) { /* do 4 dwords source, 3 dwords dest at a time */
1960 buf = *srcpixel++;
1961 val = ((buf&0xff0000)>>16) | (buf&0xff00) | ((buf&0xff)<<16); /* b1, g1, r1 */
1962 buf = *srcpixel++;
1963 *ptr++ = val | ((buf&0xff0000)<<8); /* b2 */
1964 val = ((buf&0xff00)>>8) | ((buf&0xff)<<8); /* g2, r2 */
1965 buf = *srcpixel++;
1966 *ptr++ = val | (buf&0xff0000) | ((buf&0xff00)<<16); /* b3, g3 */
1967 val = (buf&0xff); /* r3 */
1968 buf = *srcpixel++;
1969 *ptr++ = val | ((buf&0xff0000)>>8) | ((buf&0xff00)<<8) | (buf<<24); /* b4, g4, r4 */
1970 }
1971 for ( remk=remainder, bits=(BYTE*)ptr; remk>0; remk--, bits+=3 ) /* do remainder */
1972 {
1973 buf=*srcpixel++;
1974 *(WORD*)bits = (buf&0xff00) | ((buf&0xff0000)>>16) ; /* b, g */
1975 *(bits+2) = buf; /* r */
1976 }
1977 ptr = (DWORD*)(dstbits+=linebytes);
1978 }
1979 }
1980 else goto notsupported;
1981 }
1982 break;
1983
1984 case 15:
1985 {
1986 LPWORD srcpixel;
1987 LPBYTE bits = dstbits;
1988 WORD val;
1989
1990 /* ==== 555 BGR bitmap to 24 BGR dib ==== */
1991 if( bmpImage->blue_mask == 0x1f && bmpImage->red_mask == 0x7c00 )
1992 {
1993 for (h = lines - 1; h >= 0; h--) {
1994 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
1995 for (x = 0; x < srcwidth; x++, bits += 3) {
1996 val = *srcpixel++;
1997 bits[2] = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07)); /*Red*/
1998 bits[1] = (BYTE)(((val >> 2) & 0xf8) | ((val >> 7) & 0x07)); /*Green*/
1999 bits[0] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07)); /*Blue*/
2000 }
2001 bits = (dstbits += linebytes);
2002 }
2003 }
2004 /* ==== 555 RGB bitmap to 24 RGB dib==== */
2005 else if( bmpImage->blue_mask == 0x7c00 && bmpImage->red_mask == 0x1f )
2006 {
2007 for (h = lines - 1; h >= 0; h--) {
2008 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2009 for (x = 0; x < srcwidth; x++, bits += 3) {
2010 val = *srcpixel++;
2011 bits[0] = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07)); /*Red*/
2012 bits[1] = (BYTE)(((val >> 2) & 0xf8) | ((val >> 7) & 0x07)); /*Green*/
2013 bits[2] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07)); /*Blue*/
2014 }
2015 bits = (dstbits += linebytes);
2016 }
2017 }
2018 else goto notsupported;
2019 }
2020 break;
2021
2022 case 16:
2023 {
2024 LPWORD srcpixel;
2025 LPBYTE bits = dstbits;
2026 WORD val;
2027
2028 /* ==== 565 BGR bitmap to 24 BGR dib ==== */
2029 if( bmpImage->blue_mask == 0x1f && bmpImage->red_mask == 0xf800 )
2030 {
2031 for (h = lines - 1; h >= 0; h--) {
2032 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2033 for (x = 0; x < srcwidth; x++, bits += 3) {
2034 val = *srcpixel++;
2035 bits[2] = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07)); /*Red*/
2036 bits[1] = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03)); /*Green*/
2037 bits[0] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07)); /*Blue*/
2038 }
2039 bits = (dstbits += linebytes);
2040 }
2041 }
2042 /* ==== 565 RGB bitmap to 24 BGR dib ==== */
2043 else if( bmpImage->blue_mask == 0xf800 && bmpImage->red_mask == 0x1f )
2044 {
2045 for (h = lines - 1; h >= 0; h--) {
2046 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2047 for (x = 0; x < srcwidth; x++, bits += 3) {
2048 val = *srcpixel++;
2049 bits[0] = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07)); /*Red*/
2050 bits[1] = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03)); /*Green*/
2051 bits[2] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07)); /*Blue*/
2052 }
2053 bits = (dstbits += linebytes);
2054 }
2055 }
2056 else goto notsupported;
2057 }
2058 break;
2059
2060 case 1:
2061 /* ==== monochrome bitmap to 24 BGR dib ==== */
2062 case 4:
2063 /* ==== 4 colormap bitmap to 24 BGR dib ==== */
2064 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
2065 {
2066 LPBYTE bits = dstbits;
2067 PALETTEENTRY val;
2068
2069 for (h = lines - 1; h >= 0; h--) {
2070 for (x = 0; x < dstwidth; x++) {
2071 val = srccolors[XGetPixel(bmpImage, x, h)];
2072 *bits++ = val.peBlue;
2073 *bits++ = val.peGreen;
2074 *bits++ = val.peRed;
2075 }
2076 bits = (dstbits += linebytes);
2077 }
2078 }
2079 else goto notsupported;
2080
2081 break;
2082
2083 case 8:
2084 /* ==== 8 colormap bitmap to 24 BGR dib ==== */
2085 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask == 0 && srccolors)
2086 {
2087 BYTE *srcpixel;
2088 LPBYTE bits = dstbits;
2089 PALETTEENTRY val;
2090
2091 for (h = lines - 1; h >= 0; h--) {
2092 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
2093 for (x = 0; x < dstwidth; x++ ) {
2094 val = srccolors[(int)*srcpixel++];
2095 *bits++ = val.peBlue; /*Blue*/
2096 *bits++ = val.peGreen; /*Green*/
2097 *bits++ = val.peRed; /*Red*/
2098 }
2099 bits = (dstbits += linebytes);
2100 }
2101 }
2102 else goto notsupported;
2103
2104 break;
2105
2106 default:
2107 notsupported:
2108 {
2109 LPBYTE bits = dstbits;
2110
2111 FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 24 bit DIB\n",
2112 bmpImage->depth, (int)bmpImage->red_mask,
2113 (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
2114 for (h = lines - 1; h >= 0; h--)
2115 {
2116 for (x = 0; x < dstwidth; x++, bits += 3)
2117 {
2118 COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) );
2119 bits[0] = GetBValue(pixel);
2120 bits[1] = GetGValue(pixel);
2121 bits[2] = GetRValue(pixel);
2122 }
2123 bits = (dstbits += linebytes);
2124 }
2125 }
2126 break;
2127 }
2128 }
2129
2130
2131 /***********************************************************************
2132 * X11DRV_DIB_SetImageBits_32
2133 *
2134 * SetDIBits for a 32-bit deep DIB.
2135 */
2136 static void X11DRV_DIB_SetImageBits_32( int lines, const BYTE *srcbits,
2137 DWORD srcwidth, DWORD dstwidth, int left,
2138 DC *dc, XImage *bmpImage )
2139 {
2140 DWORD x, *ptr;
2141 int h;
2142
2143 DWORD linebytes = (srcwidth * 4);
2144
2145 if (lines < 0 )
2146 {
2147 lines = -lines;
2148 srcbits = srcbits + ( linebytes * (lines-1) );
2149 linebytes = -linebytes;
2150 }
2151
2152 ptr = (DWORD *) srcbits + left;
2153
2154 switch ( bmpImage->depth )
2155 {
2156 case 24:
2157 case 32:
2158 /* ==== 32 BGR dib to 24/32 BGR bitmap ==== */
2159 if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff) {
2160 for (h = lines - 1; h >= 0; h--, srcbits+=linebytes) {
2161 memcpy( bmpImage->data + h * bmpImage->bytes_per_line, srcbits + left*4, dstwidth*4 );
2162 }
2163 }
2164
2165 /* ==== 32 BGR dib to 24/32 RGB bitmap ==== */
2166 else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
2167 {
2168 DWORD *dstpixel;
2169
2170 for (h = lines - 1; h >= 0; h--) {
2171 dstpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
2172 for (x = 0; x < dstwidth; x++, ptr++) {
2173 *dstpixel++ = ((*ptr << 16) & 0xff0000) | (*ptr & 0xff00) | ((*ptr >> 16) & 0xff);
2174 }
2175 ptr = (DWORD *) (srcbits += linebytes) + left;
2176 }
2177 }
2178 else goto notsupported;
2179
2180 break;
2181
2182 case 15:
2183 /* ==== 32 BGR dib to 555 BGR bitmap ==== */
2184 if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
2185 {
2186 LPWORD dstpixel;
2187
2188 for (h = lines - 1; h >= 0; h--) {
2189 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2190 for (x = 0; x < dstwidth; x++, ptr++) {
2191 *dstpixel++ = (WORD) (((*ptr >> 9) & 0x7c00) | ((*ptr >> 6) & 0x03e0) | ((*ptr >> 3) & 0x001f));
2192 }
2193 ptr = (DWORD *) (srcbits += linebytes) + left;
2194 }
2195 }
2196 /* ==== 32 BGR dib to 555 RGB bitmap ==== */
2197 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
2198 {
2199 LPWORD dstpixel;
2200
2201 for (h = lines - 1; h >= 0; h--) {
2202 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2203 for (x = 0; x < dstwidth; x++, ptr++) {
2204 *dstpixel++ = (WORD) (((*ptr << 7) & 0x7c00) | ((*ptr >> 6) & 0x03e0) | ((*ptr >> 19) & 0x001f));
2205 }
2206 ptr = (DWORD *) (srcbits += linebytes) + left;
2207 }
2208 }
2209 else goto notsupported;
2210
2211 break;
2212
2213 case 16:
2214 /* ==== 32 BGR dib to 565 BGR bitmap ==== */
2215 if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
2216 {
2217 LPWORD dstpixel;
2218
2219 for (h = lines - 1; h >= 0; h--) {
2220 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2221 for (x = 0; x < dstwidth; x++, ptr++) {
2222 *dstpixel++ = (WORD) (((*ptr >> 8) & 0xf800) | ((*ptr >> 5) & 0x07e0) | ((*ptr >> 3) & 0x001f));
2223 }
2224 ptr = (DWORD *) (srcbits += linebytes) + left;
2225 }
2226 }
2227 /* ==== 32 BGR dib to 565 RGB bitmap ==== */
2228 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
2229 {
2230 LPWORD dstpixel;
2231
2232 for (h = lines - 1; h >= 0; h--) {
2233 dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2234 for (x = 0; x < dstwidth; x++, ptr++) {
2235 *dstpixel++ = (WORD) (((*ptr << 8) & 0xf800) | ((*ptr >> 5) & 0x07e0) | ((*ptr >> 19) & 0x001f));
2236 }
2237 ptr = (DWORD *) (srcbits += linebytes) + left;
2238 }
2239 }
2240 else goto notsupported;
2241
2242 break;
2243
2244 case 1:
2245 case 4:
2246 case 8:
2247 {
2248 LPBYTE bits = (LPBYTE)srcbits + left*4;
2249
2250 for (h = lines - 1; h >= 0; h--) {
2251 for (x = left; x < dstwidth+left; x++, bits += 4)
2252 XPutPixel( bmpImage, x, h,
2253 X11DRV_PALETTE_ToPhysical(dc, RGB( bits[2], bits[1], *bits )));
2254 bits = (LPBYTE)(srcbits += linebytes) + left * 4;
2255 }
2256 }
2257 break;
2258
2259 default:
2260 notsupported:
2261 FIXME("32 bit DIB %d bit bitmap\n", bmpImage->bits_per_pixel);
2262 break;
2263 }
2264
2265 }
2266
2267 /***********************************************************************
2268 * X11DRV_DIB_GetImageBits_32
2269 *
2270 * GetDIBits for an 32-bit deep DIB.
2271 */
2272 static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *dstbits,
2273 DWORD dstwidth, DWORD srcwidth,
2274 PALETTEENTRY *srccolors, XImage *bmpImage )
2275 {
2276 DWORD x;
2277 int h;
2278 BYTE *bits;
2279
2280 /* align to 32 bit */
2281 DWORD linebytes = (srcwidth * 4);
2282 DWORD copybytes = linebytes;
2283
2284 if (lines < 0 )
2285 {
2286 lines = -lines;
2287 dstbits = dstbits + ( linebytes * (lines-1) );
2288 linebytes = -linebytes;
2289 }
2290
2291 bits = dstbits;
2292
2293 switch ( bmpImage->depth )
2294 {
2295 case 24:
2296 case 32:
2297 /* ==== 24/32 BGR bitmap to 32 BGR dib ==== */
2298 if ( bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff )
2299 for (h = lines - 1; h >= 0; h--, dstbits+=linebytes)
2300 memcpy( dstbits, bmpImage->data + h*bmpImage->bytes_per_line, copybytes );
2301
2302 /* ==== 24/32 RGB bitmap to 32 BGR dib ==== */
2303 else if ( bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000 )
2304 {
2305 LPBYTE srcbits;
2306
2307 for (h = lines - 1; h >= 0; h--) {
2308 srcbits = bmpImage->data + h * bmpImage->bytes_per_line;
2309 for (x = 0; x < dstwidth; x++, bits+=4, srcbits+=2) {
2310 *(bits + 2) = *srcbits++;
2311 *(bits + 1) = *srcbits++;
2312 *bits = *srcbits;
2313 }
2314 bits = (dstbits += linebytes);
2315 }
2316 }
2317 else goto notsupported;
2318 break;
2319
2320 case 15:
2321 {
2322 LPWORD srcpixel;
2323 WORD val;
2324
2325 /* ==== 555 BGR bitmap to 32 BGR dib ==== */
2326 if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
2327 {
2328 for (h = lines - 1; h >= 0; h--) {
2329 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2330 for (x = 0; x < dstwidth; x++, bits+=2) {
2331 val = *srcpixel++;
2332 *bits++ = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03)); /*Blue*/
2333 *bits++ = (BYTE)(((val >> 2) & 0xfc) | ((val >> 8) & 0x03)); /*Green*/
2334 *bits = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07)); /*Red*/
2335 }
2336 bits = (dstbits += linebytes);
2337 }
2338 }
2339 /* ==== 555 RGB bitmap to 32 BGR dib ==== */
2340 else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
2341 {
2342 for (h = lines - 1; h >= 0; h--) {
2343 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2344 for (x = 0; x < dstwidth; x++, bits+=2) {
2345 val = *srcpixel++;
2346 *bits++ = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));/*Blue*/
2347 *bits++ = (BYTE)(((val >> 2) & 0xfc) | ((val >> 8) & 0x03)); /*Green*/
2348 *bits = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03)); /*Red*/
2349 }
2350 bits = (dstbits += linebytes);
2351 }
2352 }
2353 else goto notsupported;
2354 }
2355 break;
2356
2357 case 16:
2358 {
2359 LPWORD srcpixel;
2360 WORD val;
2361
2362 /* ==== 565 BGR bitmap to 32 BGR dib ==== */
2363 if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
2364 {
2365 for (h = lines - 1; h >= 0; h--) {
2366 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2367 for (x = 0; x < srcwidth; x++, bits+=2) {
2368 val = *srcpixel++;
2369 *bits++ = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03)); /*Blue*/
2370 *bits++ = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03)); /*Green*/
2371 *bits = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07)); /*Red*/
2372 }
2373 bits = (dstbits += linebytes);
2374 }
2375 }
2376 /* ==== 565 RGB bitmap to 32 BGR dib ==== */
2377 else if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
2378 {
2379 for (h = lines - 1; h >= 0; h--) {
2380 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2381 for (x = 0; x < srcwidth; x++, bits+=2) {
2382 val = *srcpixel++;
2383 *bits++ = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07));/*Blue*/
2384 *bits++ = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03)); /*Green*/
2385 *bits = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03)); /*Red*/
2386 }
2387 bits = (dstbits += linebytes);
2388 }
2389 }
2390 else goto notsupported;
2391 }
2392 break;
2393
2394 case 1:
2395 /* ==== monochrome bitmap to 32 BGR dib ==== */
2396 case 4:
2397 /* ==== 4 colormap bitmap to 32 BGR dib ==== */
2398 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
2399 {
2400 PALETTEENTRY val;
2401
2402 for (h = lines - 1; h >= 0; h--) {
2403 for (x = 0; x < dstwidth; x++) {
2404 val = srccolors[XGetPixel(bmpImage, x, h)];
2405 *bits++ = val.peBlue;
2406 *bits++ = val.peGreen;
2407 *bits++ = val.peRed;
2408 *bits++ = 0;
2409 }
2410 bits = (dstbits += linebytes);
2411 }
2412 }
2413 else goto notsupported;
2414
2415 break;
2416
2417 case 8:
2418 /* ==== 8 colormap bitmap to 32 BGR dib ==== */
2419 if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
2420 {
2421 BYTE *srcpixel;
2422 PALETTEENTRY val;
2423
2424 for (h = lines - 1; h >= 0; h--) {
2425 srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
2426 for (x = 0; x < dstwidth; x++) {
2427 val = srccolors[(int)*srcpixel++];
2428 *bits++ = val.peBlue; /*Blue*/
2429 *bits++ = val.peGreen; /*Green*/
2430 *bits++ = val.peRed; /*Red*/
2431 *bits++ = 0;
2432 }
2433 bits = (dstbits += linebytes);
2434 }
2435 }
2436 else goto notsupported;
2437 break;
2438
2439 default:
2440 notsupported:
2441 FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 32 bit DIB\n",
2442 bmpImage->depth, (int)bmpImage->red_mask,
2443 (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
2444 for (h = lines - 1; h >= 0; h--)
2445 {
2446 for (x = 0; x < dstwidth; x++, bits += 4)
2447 {
2448 COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) );
2449 bits[0] = GetBValue(pixel);
2450 bits[1] = GetGValue(pixel);
2451 bits[2] = GetRValue(pixel);
2452 }
2453 bits = (dstbits += linebytes);
2454 }
2455 break;
2456 }
2457 }
2458
2459 /***********************************************************************
2460 * X11DRV_DIB_SetImageBits
2461 *
2462 * Transfer the bits to an X image.
2463 * Helper function for SetDIBits() and SetDIBitsToDevice().
2464 * The Xlib critical section must be entered before calling this function.
2465 */
2466 int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
2467 {
2468 int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
2469 XImage *bmpImage;
2470
2471 if ( descr->dc && descr->dc->w.flags & DC_DIRTY )
2472 CLIPPING_UpdateGCRegion( descr->dc );
2473
2474 if (descr->image)
2475 bmpImage = descr->image;
2476 else {
2477 bmpImage = XCreateImage( display,
2478 DefaultVisualOfScreen(X11DRV_GetXScreen()),
2479 descr->depth, ZPixmap, 0, NULL,
2480 descr->infoWidth, lines, 32, 0 );
2481 bmpImage->data = xcalloc( bmpImage->bytes_per_line * lines );
2482 }
2483
2484 /* Transfer the pixels */
2485 switch(descr->infoBpp)
2486 {
2487 case 1:
2488 X11DRV_DIB_SetImageBits_1( descr->lines, descr->bits, descr->infoWidth,
2489 descr->width, descr->xSrc, (int *)(descr->colorMap),
2490 bmpImage );
2491 break;
2492 case 4:
2493 if (descr->compression) {
2494 XGetSubImage( display, descr->drawable, descr->xDest, descr->yDest,
2495 descr->width, descr->height, AllPlanes, ZPixmap,
2496 bmpImage, descr->xSrc, descr->ySrc );
2497
2498 X11DRV_DIB_SetImageBits_RLE4( descr->lines, descr->bits,
2499 descr->infoWidth, descr->width,
2500 descr->xSrc, (int *)(descr->colorMap),
2501 bmpImage );
2502 } else
2503 X11DRV_DIB_SetImageBits_4( descr->lines, descr->bits,
2504 descr->infoWidth, descr->width,
2505 descr->xSrc, (int*)(descr->colorMap),
2506 bmpImage );
2507 break;
2508 case 8:
2509 if (descr->compression) {
2510 XGetSubImage( display, descr->drawable, descr->xDest, descr->yDest,
2511 descr->width, descr->height, AllPlanes, ZPixmap,
2512 bmpImage, descr->xSrc, descr->ySrc );
2513 X11DRV_DIB_SetImageBits_RLE8( descr->lines, descr->bits,
2514 descr->infoWidth, descr->width,
2515 descr->xSrc, (int *)(descr->colorMap),
2516 bmpImage );
2517 } else
2518 X11DRV_DIB_SetImageBits_8( descr->lines, descr->bits,
2519 descr->infoWidth, descr->width,
2520 descr->xSrc, (int *)(descr->colorMap),
2521 bmpImage );
2522 break;
2523 case 15:
2524 case 16:
2525 X11DRV_DIB_SetImageBits_16( descr->lines, descr->bits,
2526 descr->infoWidth, descr->width,
2527 descr->xSrc, descr->dc,
2528 descr->rMask, descr->gMask, descr->bMask,
2529 bmpImage);
2530 break;
2531 case 24:
2532 X11DRV_DIB_SetImageBits_24( descr->lines, descr->bits,
2533 descr->infoWidth, descr->width,
2534 descr->xSrc, descr->dc, bmpImage );
2535 break;
2536 case 32:
2537 X11DRV_DIB_SetImageBits_32( descr->lines, descr->bits,
2538 descr->infoWidth, descr->width,
2539 descr->xSrc, descr->dc,
2540 bmpImage);
2541 break;
2542 default:
2543 WARN("(%d): Invalid depth\n", descr->infoBpp );
2544 break;
2545 }
2546
2547 if (descr->useShm)
2548 {
2549 XShmPutImage( display, descr->drawable, descr->gc, bmpImage,
2550 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
2551 descr->width, descr->height, FALSE );
2552 XSync( display, 0 );
2553 }
2554 else
2555 XPutImage( display, descr->drawable, descr->gc, bmpImage,
2556 descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
2557 descr->width, descr->height );
2558
2559 if (!descr->image) XDestroyImage( bmpImage );
2560 return lines;
2561 }
2562
2563 /***********************************************************************
2564 * X11DRV_DIB_GetImageBits
2565 *
2566 * Transfer the bits from an X image.
2567 * The Xlib critical section must be entered before calling this function.
2568 */
2569 int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
2570 {
2571 int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
2572 XImage *bmpImage;
2573
2574 if (descr->image)
2575 bmpImage = descr->image;
2576 else {
2577 bmpImage = XCreateImage( display,
2578 DefaultVisualOfScreen(X11DRV_GetXScreen()),
2579 descr->depth, ZPixmap, 0, NULL,
2580 descr->infoWidth, lines, 32, 0 );
2581 bmpImage->data = xcalloc( bmpImage->bytes_per_line * lines );
2582 }
2583
2584 XGetSubImage( display, descr->drawable, descr->xDest, descr->yDest,
2585 descr->width, descr->height, AllPlanes, ZPixmap,
2586 bmpImage, descr->xSrc, descr->ySrc );
2587
2588 /* Transfer the pixels */
2589 switch(descr->infoBpp)
2590 {
2591 case 1:
2592 X11DRV_DIB_GetImageBits_1( descr->lines,(LPVOID)descr->bits,
2593 descr->infoWidth, descr->width,
2594 descr->colorMap, descr->palentry,
2595 bmpImage );
2596 break;
2597
2598 case 4:
2599 if (descr->compression)
2600 FIXME("Compression not yet supported!\n");
2601 else
2602 X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
2603 descr->infoWidth, descr->width,
2604 descr->colorMap, descr->palentry,
2605 bmpImage );
2606 break;
2607
2608 case 8:
2609 if (descr->compression)
2610 FIXME("Compression not yet supported!\n");
2611 else
2612 X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
2613 descr->infoWidth, descr->width,
2614 descr->colorMap, descr->palentry,
2615 bmpImage );
2616 break;
2617 case 15:
2618 case 16:
2619 X11DRV_DIB_GetImageBits_16( descr->lines, (LPVOID)descr->bits,
2620 descr->infoWidth,descr->width,
2621 descr->palentry, bmpImage );
2622 break;
2623
2624 case 24:
2625 X11DRV_DIB_GetImageBits_24( descr->lines, (LPVOID)descr->bits,
2626 descr->infoWidth,descr->width,
2627 descr->palentry, bmpImage );
2628 break;
2629
2630 case 32:
2631 X11DRV_DIB_GetImageBits_32( descr->lines, (LPVOID)descr->bits,
2632 descr->infoWidth, descr->width,
2633 descr->palentry, bmpImage );
2634 break;
2635
2636 default:
2637 WARN("(%d): Invalid depth\n", descr->infoBpp );
2638 break;
2639 }
2640
2641 if (!descr->image) XDestroyImage( bmpImage );
2642 return lines;
2643 }
2644
2645 /*************************************************************************
2646 * X11DRV_SetDIBitsToDevice
2647 *
2648 */
2649 INT X11DRV_SetDIBitsToDevice( DC *dc, INT xDest, INT yDest, DWORD cx,
2650 DWORD cy, INT xSrc, INT ySrc,
2651 UINT startscan, UINT lines, LPCVOID bits,
2652 const BITMAPINFO *info, UINT coloruse )
2653 {
2654 X11DRV_DIB_IMAGEBITS_DESCR descr;
2655 DWORD width, oldcy = cy;
2656 INT result;
2657 int height, tmpheight;
2658 X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
2659
2660
2661 if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
2662 &descr.infoBpp, &descr.compression ) == -1)
2663 return 0;
2664 tmpheight = height;
2665 if (height < 0) height = -height;
2666 if (!lines || (startscan >= height)) return 0;
2667 if (startscan + lines > height) lines = height - startscan;
2668 if (ySrc < startscan) ySrc = startscan;
2669 else if (ySrc >= startscan + lines) return 0;
2670 if (xSrc >= width) return 0;
2671 if (ySrc + cy >= startscan + lines) cy = startscan + lines - ySrc;
2672 if (xSrc + cx >= width) cx = width - xSrc;
2673 if (!cx || !cy) return 0;
2674
2675 X11DRV_SetupGCForText( dc ); /* To have the correct colors */
2676 TSXSetFunction(display, physDev->gc, X11DRV_XROPfunction[dc->w.ROPmode-1]);
2677
2678 switch (descr.infoBpp)
2679 {
2680 case 1:
2681 case 4:
2682 case 8:
2683 descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
2684 coloruse == DIB_PAL_COLORS ? dc : NULL, coloruse,
2685 dc->w.bitsPerPixel, info, &descr.nColorMap );
2686 if (!descr.colorMap) return 0;
2687 descr.rMask = descr.gMask = descr.bMask = 0;
2688 break;
2689 case 15:
2690 case 16:
2691 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
2692 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0x03e0;
2693 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0x001f;
2694 descr.colorMap = 0;
2695 break;
2696
2697 case 24:
2698 descr.rMask = descr.gMask = descr.bMask = 0;
2699 descr.colorMap = 0;
2700 break;
2701
2702 case 32:
2703 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0xff0000;
2704 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0xff00;
2705 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0xff;
2706 descr.colorMap = 0;
2707 break;
2708 }
2709
2710 descr.dc = dc;
2711 descr.bits = bits;
2712 descr.image = NULL;
2713 descr.palentry = NULL;
2714 descr.lines = tmpheight >= 0 ? lines : -lines;
2715 descr.infoWidth = width;
2716 descr.depth = dc->w.bitsPerPixel;
2717 descr.drawable = physDev->drawable;
2718 descr.gc = physDev->gc;
2719 descr.xSrc = xSrc;
2720 descr.ySrc = tmpheight >= 0 ? lines-(ySrc-startscan)-cy+(oldcy-cy)
2721 : ySrc - startscan;
2722 descr.xDest = dc->w.DCOrgX + XLPTODP( dc, xDest );
2723 descr.yDest = dc->w.DCOrgY + YLPTODP( dc, yDest ) +
2724 (tmpheight >= 0 ? oldcy-cy : 0);
2725 descr.width = cx;
2726 descr.height = cy;
2727 descr.useShm = FALSE;
2728
2729 EnterCriticalSection( &X11DRV_CritSection );
2730 result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
2731 LeaveCriticalSection( &X11DRV_CritSection );
2732
2733 if (descr.infoBpp <= 8)
2734 HeapFree(GetProcessHeap(), 0, descr.colorMap);
2735 return result;
2736 }
2737
2738 /***********************************************************************
2739 * X11DRV_DIB_SetDIBits
2740 */
2741 INT X11DRV_DIB_SetDIBits(
2742 BITMAPOBJ *bmp, DC *dc, UINT startscan,
2743 UINT lines, LPCVOID bits, const BITMAPINFO *info,
2744 UINT coloruse, HBITMAP hbitmap)
2745 {
2746 X11DRV_DIB_IMAGEBITS_DESCR descr;
2747 X11DRV_PHYSBITMAP *pbitmap;
2748 int height, tmpheight;
2749 INT result;
2750
2751 descr.dc = dc;
2752
2753 if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &height,
2754 &descr.infoBpp, &descr.compression ) == -1)
2755 return 0;
2756
2757 tmpheight = height;
2758 if (height < 0) height = -height;
2759 if (!lines || (startscan >= height))
2760 return 0;
2761
2762 if (startscan + lines > height) lines = height - startscan;
2763
2764 switch (descr.infoBpp)
2765 {
2766 case 1:
2767 case 4:
2768 case 8:
2769 descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
2770 coloruse == DIB_PAL_COLORS ? descr.dc : NULL, coloruse,
2771 bmp->bitmap.bmBitsPixel,
2772 info, &descr.nColorMap );
2773 if (!descr.colorMap) return 0;
2774 descr.rMask = descr.gMask = descr.bMask = 0;
2775 break;
2776 case 15:
2777 case 16:
2778 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
2779 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0x03e0;
2780 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0x001f;
2781 descr.colorMap = 0;
2782 break;
2783
2784 case 24:
2785 descr.rMask = descr.gMask = descr.bMask = 0;
2786 descr.colorMap = 0;
2787 break;
2788
2789 case 32:
2790 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0xff0000;
2791 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0xff00;
2792 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0xff;
2793 descr.colorMap = 0;
2794 break;
2795
2796 default: break;
2797 }
2798
2799 /* HACK for now */
2800 if(!bmp->DDBitmap)
2801 X11DRV_CreateBitmap(hbitmap);
2802
2803 pbitmap = bmp->DDBitmap->physBitmap;
2804
2805 descr.bits = bits;
2806 descr.image = NULL;
2807 descr.palentry = NULL;
2808 descr.lines = tmpheight >= 0 ? lines : -lines;
2809 descr.depth = bmp->bitmap.bmBitsPixel;
2810 descr.drawable = pbitmap->pixmap;
2811 descr.gc = BITMAP_GC(bmp);
2812 descr.xSrc = 0;
2813 descr.ySrc = 0;
2814 descr.xDest = 0;
2815 descr.yDest = height - startscan - lines;
2816 descr.width = bmp->bitmap.bmWidth;
2817 descr.height = lines;
2818 descr.useShm = FALSE;
2819
2820 EnterCriticalSection( &X11DRV_CritSection );
2821 result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
2822 LeaveCriticalSection( &X11DRV_CritSection );
2823
2824 if (descr.colorMap) HeapFree(GetProcessHeap(), 0, descr.colorMap);
2825
2826 return result;
2827 }
2828
2829 /***********************************************************************
2830 * X11DRV_DIB_GetDIBits
2831 */
2832 INT X11DRV_DIB_GetDIBits(
2833 BITMAPOBJ *bmp, DC *dc, UINT startscan,
2834 UINT lines, LPVOID bits, BITMAPINFO *info,
2835 UINT coloruse, HBITMAP hbitmap)
2836 {
2837 X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
2838 X11DRV_DIB_IMAGEBITS_DESCR descr;
2839 X11DRV_PHYSBITMAP *pbitmap;
2840 PALETTEOBJ * palette;
2841
2842 TRACE("%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
2843 lines, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
2844 (int)info->bmiHeader.biWidth, (int)info->bmiHeader.biHeight,
2845 startscan );
2846
2847 if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
2848 return 0;
2849
2850 if( lines > info->bmiHeader.biHeight ) lines = info->bmiHeader.biHeight;
2851 if( startscan >= bmp->bitmap.bmHeight ) return FALSE;
2852
2853 if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &descr.lines,
2854 &descr.infoBpp, &descr.compression ) == -1)
2855 return FALSE;
2856
2857 switch (descr.infoBpp)
2858 {
2859 case 1:
2860 case 4:
2861 case 8:
2862 case 24:
2863 descr.rMask = descr.gMask = descr.bMask = 0;
2864 break;
2865 case 15:
2866 case 16:
2867 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
2868 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0x03e0;
2869 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0x001f;
2870 break;
2871
2872 case 32:
2873 descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0xff0000;
2874 descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0xff00;
2875 descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0xff;
2876 break;
2877 }
2878
2879 /* Hack for now */
2880 if(!bmp->DDBitmap)
2881 X11DRV_CreateBitmap(hbitmap);
2882
2883 pbitmap = bmp->DDBitmap->physBitmap;
2884
2885 descr.dc = dc;
2886 descr.palentry = palette->logpalette.palPalEntry;
2887 descr.bits = bits;
2888 descr.lines = lines;
2889 descr.depth = bmp->bitmap.bmBitsPixel;
2890 descr.drawable = pbitmap->pixmap;
2891 descr.gc = BITMAP_GC(bmp);
2892 descr.xSrc = 0;
2893 descr.ySrc = startscan;
2894 descr.xDest = 0;
2895 descr.yDest = 0;
2896 descr.width = bmp->bitmap.bmWidth;
2897 descr.height = bmp->bitmap.bmHeight;
2898 descr.colorMap = info->bmiColors;
2899
2900 if (dib)
2901 descr.useShm = (dib->shminfo.shmid != -1);
2902 else
2903 descr.useShm = FALSE;
2904
2905 EnterCriticalSection( &X11DRV_CritSection );
2906
2907 descr.image = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp );
2908 CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr );
2909
2910 LeaveCriticalSection( &X11DRV_CritSection );
2911
2912 if(info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */
2913 info->bmiHeader.biSizeImage = DIB_GetDIBImageBytes(
2914 info->bmiHeader.biWidth,
2915 info->bmiHeader.biHeight,
2916 info->bmiHeader.biBitCount );
2917
2918 info->bmiHeader.biCompression = 0;
2919
2920 GDI_HEAP_UNLOCK( dc->w.hPalette );
2921
2922 return lines;
2923 }
2924
2925 /***********************************************************************
2926 * DIB_DoProtectDIBSection
2927 */
2928 static void X11DRV_DIB_DoProtectDIBSection( BITMAPOBJ *bmp, DWORD new_prot )
2929 {
2930 DIBSECTION *dib = bmp->dib;
2931 INT effHeight = dib->dsBm.bmHeight >= 0? dib->dsBm.bmHeight
2932 : -dib->dsBm.bmHeight;
2933 INT totalSize = dib->dsBmih.biSizeImage? dib->dsBmih.biSizeImage
2934 : dib->dsBm.bmWidthBytes * effHeight;
2935 DWORD old_prot;
2936
2937 VirtualProtect(dib->dsBm.bmBits, totalSize, new_prot, &old_prot);
2938 TRACE("Changed protection from %ld to %ld\n", old_prot, new_prot);
2939 }
2940
2941 /***********************************************************************
2942 * X11DRV_DIB_DoUpdateDIBSection
2943 */
2944 static void X11DRV_DIB_DoUpdateDIBSection(BITMAPOBJ *bmp, BOOL toDIB)
2945 {
2946 X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
2947 X11DRV_DIB_IMAGEBITS_DESCR descr;
2948
2949 if (DIB_GetBitmapInfo( &dib->dibSection.dsBmih, &descr.infoWidth, &descr.lines,
2950 &descr.infoBpp, &descr.compression ) == -1)
2951 return;
2952
2953 descr.dc = NULL;
2954 descr.palentry = NULL;
2955 descr.image = dib->image;
2956 descr.colorMap = (RGBQUAD *)dib->colorMap;
2957 descr.nColorMap = dib->nColorMap;
2958 descr.bits = dib->dibSection.dsBm.bmBits;
2959 descr.depth = bmp->bitmap.bmBitsPixel;
2960
2961 switch (descr.infoBpp)
2962 {
2963 case 1:
2964 case 4:
2965 case 8:
2966 case 24:
2967 descr.rMask = descr.gMask = descr.bMask = 0;
2968 break;
2969 case 15:
2970 case 16:
2971 descr.rMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[0] : 0x7c00;
2972 descr.gMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[1] : 0x03e0;
2973 descr.bMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[2] : 0x001f;
2974 break;
2975
2976 case 32:
2977 descr.rMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[0] : 0xff;
2978 descr.gMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[1] : 0xff00;
2979 descr.bMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[2] : 0xff0000;
2980 break;
2981 }
2982
2983 /* Hack for now */
2984 descr.drawable = ((X11DRV_PHYSBITMAP *)bmp->DDBitmap->physBitmap)->pixmap;
2985 descr.gc = BITMAP_GC(bmp);
2986 descr.xSrc = 0;
2987 descr.ySrc = 0;
2988 descr.xDest = 0;
2989 descr.yDest = 0;
2990 descr.width = bmp->bitmap.bmWidth;
2991 descr.height = bmp->bitmap.bmHeight;
2992 descr.useShm = (dib->shminfo.shmid != -1);
2993
2994 if (toDIB)
2995 {
2996 TRACE("Copying from Pixmap to DIB bits\n");
2997 EnterCriticalSection( &X11DRV_CritSection );
2998 CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr );
2999 LeaveCriticalSection( &X11DRV_CritSection );
3000 }
3001 else
3002 {
3003 TRACE("Copying from DIB bits to Pixmap\n");
3004 EnterCriticalSection( &X11DRV_CritSection );
3005 CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
3006 LeaveCriticalSection( &X11DRV_CritSection );
3007 }
3008 }
3009
3010 /***********************************************************************
3011 * X11DRV_DIB_FaultHandler
3012 */
3013 static BOOL X11DRV_DIB_FaultHandler( LPVOID res, LPCVOID addr )
3014 {
3015 BOOL handled = FALSE;
3016 BITMAPOBJ *bmp;
3017
3018 bmp = (BITMAPOBJ *)GDI_GetObjPtr( (HBITMAP)res, BITMAP_MAGIC );
3019 if (!bmp) return FALSE;
3020
3021 if (bmp->dib)
3022 switch (((X11DRV_DIBSECTION *) bmp->dib)->status)
3023 {
3024 case X11DRV_DIB_GdiMod:
3025 TRACE("called in status DIB_GdiMod\n" );
3026 X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
3027 X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
3028 X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
3029 ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_InSync;
3030 handled = TRUE;
3031 break;
3032
3033 case X11DRV_DIB_InSync:
3034 TRACE("called in status X11DRV_DIB_InSync\n" );
3035 X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
3036 ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_AppMod;
3037 handled = TRUE;
3038 break;
3039
3040 case X11DRV_DIB_AppMod:
3041 FIXME("called in status X11DRV_DIB_AppMod: this can't happen!\n" );
3042 break;
3043
3044 case X11DRV_DIB_NoHandler:
3045 FIXME("called in status DIB_NoHandler: this can't happen!\n" );
3046 break;
3047 }
3048
3049 GDI_HEAP_UNLOCK( (HBITMAP)res );
3050 return handled;
3051 }
3052
3053 /***********************************************************************
3054 * X11DRV_DIB_UpdateDIBSection
3055 */
3056 void X11DRV_DIB_UpdateDIBSection(DC *dc, BOOL toDIB)
3057 {
3058 BITMAPOBJ *bmp;
3059
3060 /* Ensure this is a Compatible DC that has a DIB section selected */
3061
3062 if (!dc) return;
3063 if (!(dc->w.flags & DC_MEMORY)) return;
3064
3065 bmp = (BITMAPOBJ *)GDI_GetObjPtr( dc->w.hBitmap, BITMAP_MAGIC );
3066 if (!bmp) return;
3067
3068 if (!bmp->dib)
3069 {
3070 GDI_HEAP_UNLOCK(dc->w.hBitmap);
3071 return;
3072 }
3073
3074 if (!toDIB)
3075 {
3076 /* Prepare for access to the DIB by GDI functions */
3077
3078 switch (((X11DRV_DIBSECTION *) bmp->dib)->status)
3079 {
3080 default:
3081 case X11DRV_DIB_NoHandler:
3082 X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE );
3083 break;
3084
3085 case X11DRV_DIB_GdiMod:
3086 TRACE("fromDIB called in status X11DRV_DIB_GdiMod\n" );
3087 /* nothing to do */
3088 break;
3089
3090 case X11DRV_DIB_InSync:
3091 TRACE("fromDIB called in status X11DRV_DIB_InSync\n" );
3092 /* nothing to do */
3093 break;
3094
3095 case X11DRV_DIB_AppMod:
3096 TRACE("fromDIB called in status X11DRV_DIB_AppMod\n" );
3097 X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE );
3098 X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
3099 ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_InSync;
3100 break;
3101 }
3102 }
3103 else
3104 {
3105 /* Acknowledge write access to the DIB by GDI functions */
3106
3107 switch (((X11DRV_DIBSECTION *) bmp->dib)->status)
3108 {
3109 default:
3110 case X11DRV_DIB_NoHandler:
3111 X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
3112 break;
3113
3114 case X11DRV_DIB_GdiMod:
3115 TRACE(" toDIB called in status X11DRV_DIB_GdiMod\n" );
3116 /* nothing to do */
3117 break;
3118
3119 case X11DRV_DIB_InSync:
3120 TRACE(" toDIB called in status X11DRV_DIB_InSync\n" );
3121 X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS );
3122 ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_GdiMod;
3123 break;
3124
3125 case X11DRV_DIB_AppMod:
3126 FIXME(" toDIB called in status X11DRV_DIB_AppMod: "
3127 "this can't happen!\n" );
3128 break;
3129 }
3130 }
3131
3132 GDI_HEAP_UNLOCK(dc->w.hBitmap);
3133 }
3134
3135 /***********************************************************************
3136 * X11DRV_DIB_CreateDIBSection16
3137 */
3138 HBITMAP16 X11DRV_DIB_CreateDIBSection16(
3139 DC *dc, BITMAPINFO *bmi, UINT16 usage,
3140 SEGPTR *bits, HANDLE section,
3141 DWORD offset)
3142 {
3143 HBITMAP res = X11DRV_DIB_CreateDIBSection(dc, bmi, usage, NULL,
3144 section, offset);
3145 if ( res )
3146 {
3147 BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC);
3148 if ( bmp && bmp->dib )
3149 {
3150 DIBSECTION *dib = bmp->dib;
3151 INT height = dib->dsBm.bmHeight >= 0 ?
3152 dib->dsBm.bmHeight : -dib->dsBm.bmHeight;
3153 INT size = dib->dsBmih.biSizeImage ?
3154 dib->dsBmih.biSizeImage : dib->dsBm.bmWidthBytes * height;
3155 if ( dib->dsBm.bmBits )
3156 {
3157 ((X11DRV_DIBSECTION *) bmp->dib)->selector =
3158 SELECTOR_AllocBlock( dib->dsBm.bmBits, size,
3159 SEGMENT_DATA, FALSE, FALSE );
3160 }
3161 TRACE("ptr = %p, size =%d, selector = %04x, segptr = %ld\n",
3162 dib->dsBm.bmBits, size, ((X11DRV_DIBSECTION *) bmp->dib)->selector,
3163 PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0));
3164 }
3165 GDI_HEAP_UNLOCK( res );
3166
3167 if ( bits )
3168 *bits = PTR_SEG_OFF_TO_SEGPTR( ((X11DRV_DIBSECTION *) bmp->dib)->selector, 0 );
3169 }
3170
3171 return res;
3172 }
3173
3174 /***********************************************************************
3175 * X11DRV_XShmErrorHandler
3176 *
3177 */
3178 static int XShmErrorHandler(Display *dpy, XErrorEvent *event)
3179 {
3180 XShmErrorFlag = 1;
3181 return 0;
3182 }
3183
3184 /***********************************************************************
3185 * X11DRV_XShmCreateImage
3186 *
3187 */
3188
3189 extern BOOL X11DRV_XShmCreateImage(XImage** image, int width, int height, int bpp,
3190 XShmSegmentInfo* shminfo)
3191 {
3192 int (*WineXHandler)(Display *, XErrorEvent *);
3193
3194 *image = TSXShmCreateImage(display, DefaultVisualOfScreen(X11DRV_GetXScreen()),
3195 bpp, ZPixmap, NULL, shminfo, width, height);
3196 if( *image != NULL )
3197 {
3198 EnterCriticalSection( &X11DRV_CritSection );
3199 shminfo->shmid = shmget(IPC_PRIVATE, (*image)->bytes_per_line * height,
3200 IPC_CREAT|0700);
3201 if( shminfo->shmid != -1 )
3202 {
3203 shminfo->shmaddr = (*image)->data = shmat(shminfo->shmid, 0, 0);
3204 if( shminfo->shmaddr != (char*)-1 )
3205 {
3206 shminfo->readOnly = FALSE;
3207 if( TSXShmAttach( display, shminfo ) != 0)
3208 {
3209 /* Reset the error flag */
3210 XShmErrorFlag = 0;
3211 WineXHandler = XSetErrorHandler(XShmErrorHandler);
3212 XSync( display, 0 );
3213
3214 if (!XShmErrorFlag)
3215 {
3216 XSetErrorHandler(WineXHandler);
3217 LeaveCriticalSection( &X11DRV_CritSection );
3218
3219 return TRUE; /* Success! */
3220 }
3221 /* An error occured */
3222 XShmErrorFlag = 0;
3223 XSetErrorHandler(WineXHandler);
3224 }
3225 shmdt(shminfo->shmaddr);
3226 }
3227 shmctl(shminfo->shmid, IPC_RMID, 0);
3228 }
3229 XFlush(display);
3230 XDestroyImage(*image);
3231 LeaveCriticalSection( &X11DRV_CritSection );
3232 }
3233 return FALSE;
3234 }
3235
3236
3237
3238
3239 /***********************************************************************
3240 * X11DRV_DIB_CreateDIBSection
3241 */
3242 HBITMAP X11DRV_DIB_CreateDIBSection(
3243 DC *dc, BITMAPINFO *bmi, UINT usage,
3244 LPVOID *bits, HANDLE section,
3245 DWORD offset)
3246 {
3247 HBITMAP res = 0;
3248 BITMAPOBJ *bmp = NULL;
3249 X11DRV_DIBSECTION *dib = NULL;
3250 int *colorMap = NULL;
3251 int nColorMap;
3252
3253 /* Fill BITMAP32 structure with DIB data */
3254 BITMAPINFOHEADER *bi = &bmi->bmiHeader;
3255 INT effHeight, totalSize;
3256 BITMAP bm;
3257
3258 TRACE("format (%ld,%ld), planes %d, bpp %d, size %ld, colors %ld (%s)\n",
3259 bi->biWidth, bi->biHeight, bi->biPlanes, bi->biBitCount,
3260 bi->biSizeImage, bi->biClrUsed, usage == DIB_PAL_COLORS? "PAL" : "RGB");
3261
3262 effHeight = bi->biHeight >= 0 ? bi->biHeight : -bi->biHeight;
3263 bm.bmType = 0;
3264 bm.bmWidth = bi->biWidth;
3265 bm.bmHeight = effHeight;
3266 bm.bmWidthBytes = DIB_GetDIBWidthBytes(bm.bmWidth, bi->biBitCount);
3267 bm.bmPlanes = bi->biPlanes;
3268 bm.bmBitsPixel = bi->biBitCount;
3269 bm.bmBits = NULL;
3270
3271 /* Get storage location for DIB bits */
3272 totalSize = bi->biSizeImage? bi->biSizeImage : bm.bmWidthBytes * effHeight;
3273
3274 if (section)
3275 bm.bmBits = MapViewOfFile(section, FILE_MAP_ALL_ACCESS,
3276 0L, offset, totalSize);
3277 else
3278 bm.bmBits = VirtualAlloc(NULL, totalSize,
3279 MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
3280
3281 /* Create Color Map */
3282 if (bm.bmBits && bm.bmBitsPixel <= 8)
3283 colorMap = X11DRV_DIB_BuildColorMap( usage == DIB_PAL_COLORS? dc : NULL,
3284 usage, bm.bmBitsPixel, bmi, &nColorMap );
3285
3286 /* Allocate Memory for DIB and fill structure */
3287 if (bm.bmBits)
3288 dib = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(X11DRV_DIBSECTION));
3289 if (dib)
3290 {
3291 dib->dibSection.dsBm = bm;
3292 dib->dibSection.dsBmih = *bi;
3293
3294 /* Set dsBitfields values */
3295 if ( usage == DIB_PAL_COLORS || bi->biBitCount <= 8)
3296 {
3297 dib->dibSection.dsBitfields[0] = dib->dibSection.dsBitfields[1] = dib->dibSection.dsBitfields[2] = 0;
3298 }
3299 else switch( bi->biBitCount )
3300 {
3301 case 16:
3302 dib->dibSection.dsBitfields[0] = (bi->biCompression == BI_BITFIELDS) ? *(DWORD *)bmi->bmiColors : 0x7c00;
3303 dib->dibSection.dsBitfields[1] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 1) : 0x03e0;
3304 dib->dibSection.dsBitfields[2] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 2) : 0x001f;
3305 break;
3306
3307 case 24:
3308 dib->dibSection.dsBitfields[0] = 0xff;
3309 dib->dibSection.dsBitfields[1] = 0xff00;
3310 dib->dibSection.dsBitfields[2] = 0xff0000;
3311 break;
3312
3313 case 32:
3314 dib->dibSection.dsBitfields[0] = (bi->biCompression == BI_BITFIELDS) ? *(DWORD *)bmi->bmiColors : 0xff;
3315 dib->dibSection.dsBitfields[1] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 1) : 0xff00;
3316 dib->dibSection.dsBitfields[2] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 2) : 0xff0000;
3317 break;
3318 }
3319 dib->dibSection.dshSection = section;
3320 dib->dibSection.dsOffset = offset;
3321
3322 dib->status = X11DRV_DIB_NoHandler;
3323 dib->selector = 0;
3324
3325 dib->nColorMap = nColorMap;
3326 dib->colorMap = colorMap;
3327 }
3328
3329 /* Create Device Dependent Bitmap and add DIB pointer */
3330 if (dib)
3331 {
3332 res = CreateDIBitmap(dc->hSelf, bi, 0, NULL, bmi, usage);
3333 if (res)
3334 {
3335 bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC);
3336 if (bmp)
3337 {
3338 bmp->dib = (DIBSECTION *) dib;
3339 /* HACK for now */
3340 if(!bmp->DDBitmap)
3341 X11DRV_CreateBitmap(res);
3342 }
3343 }
3344 }
3345
3346 /* Create XImage */
3347 if (dib && bmp)
3348 {
3349 if (TSXShmQueryExtension(display) &&
3350 X11DRV_XShmCreateImage( &dib->image, bm.bmWidth, effHeight,
3351 bmp->bitmap.bmBitsPixel, &dib->shminfo ) )
3352 {
3353 ; /* Created Image */
3354 } else {
3355 XCREATEIMAGE( dib->image, bm.bmWidth, effHeight, bmp->bitmap.bmBitsPixel );
3356 dib->shminfo.shmid = -1;
3357 }
3358 }
3359
3360 /* Clean up in case of errors */
3361 if (!res || !bmp || !dib || !bm.bmBits || (bm.bmBitsPixel <= 8 && !colorMap))
3362 {
3363 TRACE("got an error res=%08x, bmp=%p, dib=%p, bm.bmBits=%p\n",
3364 res, bmp, dib, bm.bmBits);
3365 if (bm.bmBits)
3366 {
3367 if (section)
3368 UnmapViewOfFile(bm.bmBits), bm.bmBits = NULL;
3369 else
3370 VirtualFree(bm.bmBits, 0L, MEM_RELEASE), bm.bmBits = NULL;
3371 }
3372
3373 if (dib && dib->image) { XDestroyImage(dib->image); dib->image = NULL; }
3374 if (colorMap) { HeapFree(GetProcessHeap(), 0, colorMap); colorMap = NULL; }
3375 if (dib) { HeapFree(GetProcessHeap(), 0, dib); dib = NULL; }
3376 if (res) { DeleteObject(res); res = 0; }
3377 }
3378
3379 /* Install fault handler, if possible */
3380 if (bm.bmBits)
3381 {
3382 if (VIRTUAL_SetFaultHandler(bm.bmBits, X11DRV_DIB_FaultHandler, (LPVOID)res))
3383 {
3384 X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
3385 if (dib) dib->status = X11DRV_DIB_InSync;
3386 }
3387 }
3388
3389 /* Return BITMAP handle and storage location */
3390 if (res) GDI_HEAP_UNLOCK(res);
3391 if (bm.bmBits && bits) *bits = bm.bmBits;
3392 return res;
3393 }
3394
3395 /***********************************************************************
3396 * X11DRV_DIB_DeleteDIBSection
3397 */
3398 void X11DRV_DIB_DeleteDIBSection(BITMAPOBJ *bmp)
3399 {
3400 X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
3401
3402 if (dib->image)
3403 {
3404 if (dib->shminfo.shmid != -1)
3405 {
3406 TSXShmDetach (display, &(dib->shminfo));
3407 XDestroyImage (dib->image);
3408 shmdt (dib->shminfo.shmaddr);
3409 shmctl (dib->shminfo.shmid, IPC_RMID, 0);
3410 dib->shminfo.shmid = -1;
3411 }
3412 else
3413 XDestroyImage( dib->image );
3414 }
3415
3416 if (dib->colorMap)
3417 HeapFree(GetProcessHeap(), 0, dib->colorMap);
3418
3419 if (dib->selector)
3420 {
3421 WORD count = (GET_SEL_LIMIT( dib->selector ) >> 16) + 1;
3422 SELECTOR_FreeBlock( dib->selector, count );
3423 }
3424 }
3425
3426
3427 /**************************************************************************
3428 * X11DRV_DIB_CreateDIBFromPixmap
3429 *
3430 * Allocates a packed DIB and copies the Pixmap data into it.
3431 * If bDeletePixmap is TRUE, the Pixmap passed in is deleted after the conversion.
3432 */
3433 HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc, BOOL bDeletePixmap)
3434 {
3435 HBITMAP hBmp = 0;
3436 BITMAPOBJ *pBmp = NULL;
3437 HGLOBAL hPackedDIB = 0;
3438
3439 /* Allocates an HBITMAP which references the Pixmap passed to us */
3440 hBmp = X11DRV_BITMAP_CreateBitmapHeaderFromPixmap(pixmap);
3441 if (!hBmp)
3442 {
3443 TRACE("\tCould not create bitmap header for Pixmap\n");
3444 goto END;
3445 }
3446
3447 /*
3448 * Create a packed DIB from the Pixmap wrapper bitmap created above.
3449 * A packed DIB contains a BITMAPINFO structure followed immediately by
3450 * an optional color palette and the pixel data.
3451 */
3452 hPackedDIB = DIB_CreateDIBFromBitmap(hdc, hBmp);
3453
3454 /* Get a pointer to the BITMAPOBJ structure */
3455 pBmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
3456
3457 /* We can now get rid of the HBITMAP wrapper we created earlier.
3458 * Note: Simply calling DeleteObject will free the embedded Pixmap as well.
3459 */
3460 if (!bDeletePixmap)
3461 {
3462 /* Manually free the DDBitmap internals to prevent the Pixmap
3463 * from being deleted by DeleteObject.
3464 */
3465 HeapFree( GetProcessHeap(), 0, pBmp->DDBitmap->physBitmap );
3466 HeapFree( GetProcessHeap(), 0, pBmp->DDBitmap );
3467 pBmp->DDBitmap = NULL;
3468 }
3469 DeleteObject(hBmp);
3470
3471 END:
3472 TRACE("\tReturning packed DIB %x\n", hPackedDIB);
3473 return hPackedDIB;
3474 }
3475
3476
3477 /**************************************************************************
3478 * X11DRV_DIB_CreatePixmapFromDIB
3479 *
3480 * Creates a Pixmap from a packed DIB
3481 */
3482 Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
3483 {
3484 Pixmap pixmap = None;
3485 HBITMAP hBmp = 0;
3486 BITMAPOBJ *pBmp = NULL;
3487 LPBYTE pPackedDIB = NULL;
3488 LPBITMAPINFO pbmi = NULL;
3489 LPBITMAPINFOHEADER pbmiHeader = NULL;
3490 LPBYTE pbits = NULL;
3491
3492 /* Get a pointer to the packed DIB's data */
3493 pPackedDIB = (LPBYTE)GlobalLock(hPackedDIB);
3494 pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
3495 pbmi = (LPBITMAPINFO)pPackedDIB;
3496 pbits = (LPBYTE)(pPackedDIB
3497 + DIB_BitmapInfoSize( (LPBITMAPINFO)pbmiHeader, DIB_RGB_COLORS ));
3498
3499 /* Create a DDB from the DIB */
3500
3501 hBmp = CreateDIBitmap(hdc,
3502 pbmiHeader,
3503 CBM_INIT,
3504 (LPVOID)pbits,
3505 pbmi,
3506 DIB_RGB_COLORS);
3507
3508 GlobalUnlock(hPackedDIB);
3509
3510 TRACE("CreateDIBitmap returned %x\n", hBmp);
3511
3512 /* Retrieve the internal Pixmap from the DDB */
3513
3514 pBmp = (BITMAPOBJ *) GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
3515
3516 if (pBmp->DDBitmap && pBmp->DDBitmap->physBitmap)
3517 {
3518 pixmap = ((X11DRV_PHYSBITMAP *)(pBmp->DDBitmap->physBitmap))->pixmap;
3519 if (!pixmap)
3520 TRACE("NULL Pixmap in DDBitmap->physBitmap!\n");
3521
3522 /* Manually free the BITMAPOBJ internals so that we can steal its pixmap */
3523 HeapFree( GetProcessHeap(), 0, pBmp->DDBitmap->physBitmap );
3524 HeapFree( GetProcessHeap(), 0, pBmp->DDBitmap );
3525 pBmp->DDBitmap = NULL; /* Its not a DDB anymore */
3526 }
3527
3528 /* Delete the DDB we created earlier now that we have stolen its pixmap */
3529 DeleteObject(hBmp);
3530
3531 TRACE("\tReturning Pixmap %ld\n", pixmap);
3532 return pixmap;
3533 }
3534
3535 #endif /* !defined(X_DISPLAY_MISSING) */
3536
3537
3538
Windows API implementation