?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
TESTING -- override pthreads to fix gstreamer v5
[wine/multimedia.git] / dlls / gdi32 / dibdrv / primitives.c
blobc7b48ed25e99f895932794c975f875ef2f4e3ec2
1 /*
2 * DIB driver primitives.
3 *
4 * Copyright 2011 Huw Davies
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <assert.h>
22
23 #include "gdi_private.h"
24 #include "dibdrv.h"
25
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(dib);
29
30 /* Bayer matrices for dithering */
31
32 static const BYTE bayer_4x4[4][4] =
33 {
34 { 0, 8, 2, 10 },
35 { 12, 4, 14, 6 },
36 { 3, 11, 1, 9 },
37 { 15, 7, 13, 5 }
38 };
39
40 static const BYTE bayer_8x8[8][8] =
41 {
42 { 0, 32, 8, 40, 2, 34, 10, 42 },
43 { 48, 16, 56, 24, 50, 18, 58, 26 },
44 { 12, 44, 4, 36, 14, 46, 6, 38 },
45 { 60, 28, 52, 20, 62, 30, 54, 22 },
46 { 3, 35, 11, 43, 1, 33, 9, 41 },
47 { 51, 19, 59, 27, 49, 17, 57, 25 },
48 { 15, 47, 7, 39, 13, 45, 5, 37 },
49 { 63, 31, 55, 23, 61, 29, 53, 21 }
50 };
51
52 static const BYTE bayer_16x16[16][16] =
53 {
54 { 0, 128, 32, 160, 8, 136, 40, 168, 2, 130, 34, 162, 10, 138, 42, 170 },
55 { 192, 64, 224, 96, 200, 72, 232, 104, 194, 66, 226, 98, 202, 74, 234, 106 },
56 { 48, 176, 16, 144, 56, 184, 24, 152, 50, 178, 18, 146, 58, 186, 26, 154 },
57 { 240, 112, 208, 80, 248, 120, 216, 88, 242, 114, 210, 82, 250, 122, 218, 90 },
58 { 12, 140, 44, 172, 4, 132, 36, 164, 14, 142, 46, 174, 6, 134, 38, 166 },
59 { 204, 76, 236, 108, 196, 68, 228, 100, 206, 78, 238, 110, 198, 70, 230, 102 },
60 { 60, 188, 28, 156, 52, 180, 20, 148, 62, 190, 30, 158, 54, 182, 22, 150 },
61 { 252, 124, 220, 92, 244, 116, 212, 84, 254, 126, 222, 94, 246, 118, 214, 86 },
62 { 3, 131, 35, 163, 11, 139, 43, 171, 1, 129, 33, 161, 9, 137, 41, 169 },
63 { 195, 67, 227, 99, 203, 75, 235, 107, 193, 65, 225, 97, 201, 73, 233, 105 },
64 { 51, 179, 19, 147, 59, 187, 27, 155, 49, 177, 17, 145, 57, 185, 25, 153 },
65 { 243, 115, 211, 83, 251, 123, 219, 91, 241, 113, 209, 81, 249, 121, 217, 89 },
66 { 15, 143, 47, 175, 7, 135, 39, 167, 13, 141, 45, 173, 5, 133, 37, 165 },
67 { 207, 79, 239, 111, 199, 71, 231, 103, 205, 77, 237, 109, 197, 69, 229, 101 },
68 { 63, 191, 31, 159, 55, 183, 23, 151, 61, 189, 29, 157, 53, 181, 21, 149 },
69 { 255, 127, 223, 95, 247, 119, 215, 87, 253, 125, 221, 93, 245, 117, 213, 85 },
70 };
71
72 static inline DWORD *get_pixel_ptr_32(const dib_info *dib, int x, int y)
73 {
74 return (DWORD *)((BYTE*)dib->bits.ptr + (dib->rect.top + y) * dib->stride + (dib->rect.left + x) * 4);
75 }
76
77 static inline DWORD *get_pixel_ptr_24_dword(const dib_info *dib, int x, int y)
78 {
79 return (DWORD *)((BYTE*)dib->bits.ptr + (dib->rect.top + y) * dib->stride) + (dib->rect.left + x) * 3 / 4;
80 }
81
82 static inline BYTE *get_pixel_ptr_24(const dib_info *dib, int x, int y)
83 {
84 return (BYTE*)dib->bits.ptr + (dib->rect.top + y) * dib->stride + (dib->rect.left + x) * 3;
85 }
86
87 static inline WORD *get_pixel_ptr_16(const dib_info *dib, int x, int y)
88 {
89 return (WORD *)((BYTE*)dib->bits.ptr + (dib->rect.top + y) * dib->stride + (dib->rect.left + x) * 2);
90 }
91
92 static inline BYTE *get_pixel_ptr_8(const dib_info *dib, int x, int y)
93 {
94 return (BYTE*)dib->bits.ptr + (dib->rect.top + y) * dib->stride + dib->rect.left + x;
95 }
96
97 static inline BYTE *get_pixel_ptr_4(const dib_info *dib, int x, int y)
98 {
99 return (BYTE*)dib->bits.ptr + (dib->rect.top + y) * dib->stride + (dib->rect.left + x) / 2;
100 }
101
102 static inline BYTE *get_pixel_ptr_1(const dib_info *dib, int x, int y)
103 {
104 return (BYTE*)dib->bits.ptr + (dib->rect.top + y) * dib->stride + (dib->rect.left + x) / 8;
105 }
106
107 static const BYTE pixel_masks_4[2] = {0xf0, 0x0f};
108 static const BYTE pixel_masks_1[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
109
110 static inline void do_rop_32(DWORD *ptr, DWORD and, DWORD xor)
111 {
112 *ptr = (*ptr & and) ^ xor;
113 }
114
115 static inline void do_rop_16(WORD *ptr, WORD and, WORD xor)
116 {
117 *ptr = (*ptr & and) ^ xor;
118 }
119
120 static inline void do_rop_8(BYTE *ptr, BYTE and, BYTE xor)
121 {
122 *ptr = (*ptr & and) ^ xor;
123 }
124
125 static inline void do_rop_mask_8(BYTE *ptr, BYTE and, BYTE xor, BYTE mask)
126 {
127 *ptr = (*ptr & (and | ~mask)) ^ (xor & mask);
128 }
129
130 static inline void do_rop_codes_32(DWORD *dst, DWORD src, struct rop_codes *codes)
131 {
132 do_rop_32( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2 );
133 }
134
135 static inline void do_rop_codes_16(WORD *dst, WORD src, struct rop_codes *codes)
136 {
137 do_rop_16( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2 );
138 }
139
140 static inline void do_rop_codes_8(BYTE *dst, BYTE src, struct rop_codes *codes)
141 {
142 do_rop_8( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2 );
143 }
144
145 static inline void do_rop_codes_mask_8(BYTE *dst, BYTE src, struct rop_codes *codes, BYTE mask)
146 {
147 do_rop_mask_8( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2, mask );
148 }
149
150 static inline void do_rop_codes_line_32(DWORD *dst, const DWORD *src, struct rop_codes *codes, int len)
151 {
152 for (; len > 0; len--, src++, dst++) do_rop_codes_32( dst, *src, codes );
153 }
154
155 static inline void do_rop_codes_line_rev_32(DWORD *dst, const DWORD *src, struct rop_codes *codes, int len)
156 {
157 for (src += len - 1, dst += len - 1; len > 0; len--, src--, dst--)
158 do_rop_codes_32( dst, *src, codes );
159 }
160
161 static inline void do_rop_codes_line_16(WORD *dst, const WORD *src, struct rop_codes *codes, int len)
162 {
163 for (; len > 0; len--, src++, dst++) do_rop_codes_16( dst, *src, codes );
164 }
165
166 static inline void do_rop_codes_line_rev_16(WORD *dst, const WORD *src, struct rop_codes *codes, int len)
167 {
168 for (src += len - 1, dst += len - 1; len > 0; len--, src--, dst--)
169 do_rop_codes_16( dst, *src, codes );
170 }
171
172 static inline void do_rop_codes_line_8(BYTE *dst, const BYTE *src, struct rop_codes *codes, int len)
173 {
174 for (; len > 0; len--, src++, dst++) do_rop_codes_8( dst, *src, codes );
175 }
176
177 static inline void do_rop_codes_line_rev_8(BYTE *dst, const BYTE *src, struct rop_codes *codes, int len)
178 {
179 for (src += len - 1, dst += len - 1; len > 0; len--, src--, dst--)
180 do_rop_codes_8( dst, *src, codes );
181 }
182
183 static inline void do_rop_codes_line_4(BYTE *dst, int dst_x, const BYTE *src, int src_x,
184 struct rop_codes *codes, int len)
185 {
186 BYTE src_val;
187
188 for (src += src_x / 2, dst += dst_x / 2; len > 0; len--, dst_x++, src_x++)
189 {
190 if (dst_x & 1)
191 {
192 if (src_x & 1) src_val = *src++;
193 else src_val = *src >> 4;
194 do_rop_codes_mask_8( dst++, src_val, codes, 0x0f );
195 }
196 else
197 {
198 if (src_x & 1) src_val = *src++ << 4;
199 else src_val = *src;
200 do_rop_codes_mask_8( dst, src_val, codes, 0xf0 );
201 }
202 }
203 }
204
205 static inline void do_rop_codes_line_rev_4(BYTE *dst, int dst_x, const BYTE *src, int src_x,
206 struct rop_codes *codes, int len)
207 {
208 BYTE src_val;
209
210 src_x += len - 1;
211 dst_x += len - 1;
212 for (src += src_x / 2, dst += dst_x / 2; len > 0; len--, dst_x--, src_x--)
213 {
214 if (dst_x & 1)
215 {
216 if (src_x & 1) src_val = *src;
217 else src_val = *src-- >> 4;
218 do_rop_codes_mask_8( dst, src_val, codes, 0x0f );
219 }
220 else
221 {
222 if (src_x & 1) src_val = *src << 4;
223 else src_val = *src--;
224 do_rop_codes_mask_8( dst--, src_val, codes, 0xf0 );
225 }
226 }
227 }
228
229 static inline void do_rop_codes_line_1(BYTE *dst, int dst_x, const BYTE *src, int src_x,
230 struct rop_codes *codes, int len)
231 {
232 BYTE src_val;
233
234 for (src += src_x / 8, dst += dst_x / 8; len > 0; len--, dst_x++, src_x++)
235 {
236 src_val = *src & pixel_masks_1[src_x & 7] ? 0xff : 0;
237 do_rop_codes_mask_8( dst, src_val, codes, pixel_masks_1[dst_x & 7] );
238 if ((src_x & 7) == 7) src++;
239 if ((dst_x & 7) == 7) dst++;
240 }
241 }
242
243 static inline void do_rop_codes_line_rev_1(BYTE *dst, int dst_x, const BYTE *src, int src_x,
244 struct rop_codes *codes, int len)
245 {
246 BYTE src_val;
247
248 src_x += len - 1;
249 dst_x += len - 1;
250 for (src += src_x / 8, dst += dst_x / 8; len > 0; len--, dst_x--, src_x--)
251 {
252 src_val = *src & pixel_masks_1[src_x & 7] ? 0xff : 0;
253 do_rop_codes_mask_8( dst, src_val, codes, pixel_masks_1[dst_x & 7] );
254 if ((src_x & 7) == 0) src--;
255 if ((dst_x & 7) == 0) dst--;
256 }
257 }
258
259 static inline void memset_32( DWORD *start, DWORD val, DWORD size )
260 {
261 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
262 DWORD dummy;
263 __asm__ __volatile__( "cld; rep; stosl"
264 : "=c" (dummy), "=D" (dummy)
265 : "a" (val), "0" (size), "1" (start) );
266 #else
267 while (size--) *start++ = val;
268 #endif
269 }
270
271 static inline void memset_16( WORD *start, WORD val, DWORD size )
272 {
273 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
274 DWORD dummy;
275 __asm__ __volatile__( "cld; rep; stosw"
276 : "=c" (dummy), "=D" (dummy)
277 : "a" (val), "0" (size), "1" (start) );
278 #else
279 while (size--) *start++ = val;
280 #endif
281 }
282
283 static void solid_rects_32(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
284 {
285 DWORD *ptr, *start;
286 int x, y, i;
287
288 for(i = 0; i < num; i++, rc++)
289 {
290 assert( !is_rect_empty( rc ));
291
292 start = get_pixel_ptr_32(dib, rc->left, rc->top);
293 if (and)
294 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
295 for(x = rc->left, ptr = start; x < rc->right; x++)
296 do_rop_32(ptr++, and, xor);
297 else
298 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
299 memset_32( start, xor, rc->right - rc->left );
300 }
301 }
302
303 static void solid_rects_24(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
304 {
305 DWORD *ptr, *start;
306 BYTE *byte_ptr, *byte_start;
307 int x, y, i;
308 DWORD and_masks[3], xor_masks[3];
309
310 and_masks[0] = ( and & 0x00ffffff) | ((and << 24) & 0xff000000);
311 and_masks[1] = ((and >> 8) & 0x0000ffff) | ((and << 16) & 0xffff0000);
312 and_masks[2] = ((and >> 16) & 0x000000ff) | ((and << 8) & 0xffffff00);
313 xor_masks[0] = ( xor & 0x00ffffff) | ((xor << 24) & 0xff000000);
314 xor_masks[1] = ((xor >> 8) & 0x0000ffff) | ((xor << 16) & 0xffff0000);
315 xor_masks[2] = ((xor >> 16) & 0x000000ff) | ((xor << 8) & 0xffffff00);
316
317 for(i = 0; i < num; i++, rc++)
318 {
319 int left = dib->rect.left + rc->left;
320 int right = dib->rect.left + rc->right;
321
322 assert( !is_rect_empty( rc ));
323
324 if ((left & ~3) == (right & ~3)) /* Special case for lines that start and end in the same DWORD triplet */
325 {
326 byte_start = get_pixel_ptr_24(dib, rc->left, rc->top);
327 for(y = rc->top; y < rc->bottom; y++, byte_start += dib->stride)
328 {
329 for(x = left, byte_ptr = byte_start; x < right; x++)
330 {
331 do_rop_8(byte_ptr++, and_masks[0] & 0xff, xor_masks[0] & 0xff);
332 do_rop_8(byte_ptr++, and_masks[1] & 0xff, xor_masks[1] & 0xff);
333 do_rop_8(byte_ptr++, and_masks[2] & 0xff, xor_masks[2] & 0xff);
334 }
335 }
336 }
337 else if (and)
338 {
339 start = get_pixel_ptr_24_dword(dib, rc->left, rc->top);
340 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
341 {
342 ptr = start;
343
344 switch(left & 3)
345 {
346 case 1:
347 do_rop_32(ptr++, and_masks[0] | 0x00ffffff, xor_masks[0] & 0xff000000);
348 do_rop_32(ptr++, and_masks[1], xor_masks[1]);
349 do_rop_32(ptr++, and_masks[2], xor_masks[2]);
350 break;
351 case 2:
352 do_rop_32(ptr++, and_masks[1] | 0x0000ffff, xor_masks[1] & 0xffff0000);
353 do_rop_32(ptr++, and_masks[2], xor_masks[2]);
354 break;
355 case 3:
356 do_rop_32(ptr++, and_masks[2] | 0x000000ff, xor_masks[2] & 0xffffff00);
357 break;
358 }
359
360 for(x = (left + 3) & ~3; x < (right & ~3); x += 4)
361 {
362 do_rop_32(ptr++, and_masks[0], xor_masks[0]);
363 do_rop_32(ptr++, and_masks[1], xor_masks[1]);
364 do_rop_32(ptr++, and_masks[2], xor_masks[2]);
365 }
366
367 switch(right & 3)
368 {
369 case 1:
370 do_rop_32(ptr, and_masks[0] | 0xff000000, xor_masks[0] & 0x00ffffff);
371 break;
372 case 2:
373 do_rop_32(ptr++, and_masks[0], xor_masks[0]);
374 do_rop_32(ptr, and_masks[1] | 0xffff0000, xor_masks[1] & 0x0000ffff);
375 break;
376 case 3:
377 do_rop_32(ptr++, and_masks[0], xor_masks[0]);
378 do_rop_32(ptr++, and_masks[1], xor_masks[1]);
379 do_rop_32(ptr, and_masks[2] | 0xffffff00, xor_masks[2] & 0x000000ff);
380 break;
381 }
382 }
383 }
384 else
385 {
386 start = get_pixel_ptr_24_dword(dib, rc->left, rc->top);
387 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
388 {
389 ptr = start;
390
391 switch(left & 3)
392 {
393 case 1:
394 do_rop_32(ptr++, 0x00ffffff, xor_masks[0] & 0xff000000);
395 *ptr++ = xor_masks[1];
396 *ptr++ = xor_masks[2];
397 break;
398 case 2:
399 do_rop_32(ptr++, 0x0000ffff, xor_masks[1] & 0xffff0000);
400 *ptr++ = xor_masks[2];
401 break;
402 case 3:
403 do_rop_32(ptr++, 0x000000ff, xor_masks[2] & 0xffffff00);
404 break;
405 }
406
407 for(x = (left + 3) & ~3; x < (right & ~3); x += 4)
408 {
409 *ptr++ = xor_masks[0];
410 *ptr++ = xor_masks[1];
411 *ptr++ = xor_masks[2];
412 }
413
414 switch(right & 3)
415 {
416 case 1:
417 do_rop_32(ptr, 0xff000000, xor_masks[0] & 0x00ffffff);
418 break;
419 case 2:
420 *ptr++ = xor_masks[0];
421 do_rop_32(ptr, 0xffff0000, xor_masks[1] & 0x0000ffff);
422 break;
423 case 3:
424 *ptr++ = xor_masks[0];
425 *ptr++ = xor_masks[1];
426 do_rop_32(ptr, 0xffffff00, xor_masks[2] & 0x000000ff);
427 break;
428 }
429 }
430 }
431 }
432 }
433
434 static void solid_rects_16(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
435 {
436 WORD *ptr, *start;
437 int x, y, i;
438
439 for(i = 0; i < num; i++, rc++)
440 {
441 assert( !is_rect_empty( rc ));
442
443 start = get_pixel_ptr_16(dib, rc->left, rc->top);
444 if (and)
445 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
446 for(x = rc->left, ptr = start; x < rc->right; x++)
447 do_rop_16(ptr++, and, xor);
448 else
449 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
450 memset_16( start, xor, rc->right - rc->left );
451 }
452 }
453
454 static void solid_rects_8(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
455 {
456 BYTE *ptr, *start;
457 int x, y, i;
458
459 for(i = 0; i < num; i++, rc++)
460 {
461 assert( !is_rect_empty( rc ));
462
463 start = get_pixel_ptr_8(dib, rc->left, rc->top);
464 if (and)
465 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
466 for(x = rc->left, ptr = start; x < rc->right; x++)
467 do_rop_8(ptr++, and, xor);
468 else
469 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
470 memset( start, xor, rc->right - rc->left );
471 }
472 }
473
474 static void solid_rects_4(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
475 {
476 BYTE *ptr, *start;
477 int x, y, i;
478 BYTE byte_and = (and & 0xf) | ((and << 4) & 0xf0);
479 BYTE byte_xor = (xor & 0xf) | ((xor << 4) & 0xf0);
480
481 for(i = 0; i < num; i++, rc++)
482 {
483 int left = dib->rect.left + rc->left;
484 int right = dib->rect.left + rc->right;
485
486 assert( !is_rect_empty( rc ));
487
488 start = get_pixel_ptr_4(dib, rc->left, rc->top);
489 if (and)
490 {
491 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
492 {
493 ptr = start;
494 if(left & 1) /* upper nibble untouched */
495 do_rop_8(ptr++, byte_and | 0xf0, byte_xor & 0x0f);
496
497 for(x = (left + 1) & ~1; x < (right & ~1); x += 2)
498 do_rop_8(ptr++, byte_and, byte_xor);
499
500 if(right & 1) /* lower nibble untouched */
501 do_rop_8(ptr, byte_and | 0x0f, byte_xor & 0xf0);
502 }
503 }
504 else
505 {
506 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
507 {
508 unsigned int byte_len = (right - ((left + 1) & ~1)) / 2;
509
510 ptr = start;
511 if(left & 1) /* upper nibble untouched */
512 do_rop_8(ptr++, 0xf0, byte_xor & 0x0f);
513
514 memset( ptr, byte_xor, byte_len );
515
516 if(right & 1) /* lower nibble untouched */
517 do_rop_8(ptr + byte_len, 0x0f, byte_xor & 0xf0);
518 }
519 }
520 }
521 }
522
523 static void solid_rects_1(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
524 {
525 BYTE *ptr, *start;
526 int x, y, i;
527 BYTE byte_and = (and & 1) ? 0xff : 0;
528 BYTE byte_xor = (xor & 1) ? 0xff : 0;
529 static const BYTE masks[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};
530
531 for(i = 0; i < num; i++, rc++)
532 {
533 int left = dib->rect.left + rc->left;
534 int right = dib->rect.left + rc->right;
535
536 assert( !is_rect_empty( rc ));
537
538 start = get_pixel_ptr_1(dib, rc->left, rc->top);
539
540 if ((left & ~7) == (right & ~7)) /* Special case for lines that start and end in the same byte */
541 {
542 BYTE mask = masks[left & 7] & ~masks[right & 7];
543
544 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
545 {
546 do_rop_8(start, byte_and | ~mask, byte_xor & mask);
547 }
548 }
549 else if (and)
550 {
551 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
552 {
553 ptr = start;
554
555 if(left & 7)
556 do_rop_8(ptr++, byte_and | ~masks[left & 7], byte_xor & masks[left & 7]);
557
558 for(x = (left + 7) & ~7; x < (right & ~7); x += 8)
559 do_rop_8(ptr++, byte_and, byte_xor);
560
561 if(right & 7)
562 /* this is inverted wrt start mask */
563 do_rop_8(ptr, byte_and | masks[right & 7], byte_xor & ~masks[right & 7]);
564 }
565 }
566 else
567 {
568 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
569 {
570 unsigned int byte_len = (right - ((left + 7) & ~7)) / 8;
571
572 ptr = start;
573
574 if(left & 7)
575 do_rop_8(ptr++, ~masks[left & 7], byte_xor & masks[left & 7]);
576
577 memset( ptr, byte_xor, byte_len );
578
579 if(right & 7)
580 do_rop_8(ptr + byte_len, masks[right & 7], byte_xor & ~masks[right & 7]);
581 }
582 }
583 }
584 }
585
586 static void solid_rects_null(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
587 {
588 return;
589 }
590
591 static void solid_line_32(const dib_info *dib, const POINT *start, const struct line_params *params,
592 DWORD and, DWORD xor)
593 {
594 DWORD *ptr = get_pixel_ptr_32( dib, start->x, start->y );
595 int len = params->length, err = params->err_start;
596 int major_inc, minor_inc;
597
598 if (params->x_major)
599 {
600 major_inc = params->x_inc;
601 minor_inc = (dib->stride * params->y_inc) / 4;
602 }
603 else
604 {
605 major_inc = (dib->stride * params->y_inc) / 4;
606 minor_inc = params->x_inc;
607 }
608
609 while (len--)
610 {
611 do_rop_32( ptr, and, xor );
612 if (err + params->bias > 0)
613 {
614 ptr += minor_inc;
615 err += params->err_add_1;
616 }
617 else err += params->err_add_2;
618 ptr += major_inc;
619 }
620 }
621
622 static void solid_line_24(const dib_info *dib, const POINT *start, const struct line_params *params,
623 DWORD and, DWORD xor)
624 {
625 BYTE *ptr = get_pixel_ptr_24( dib, start->x, start->y );
626 int len = params->length, err = params->err_start;
627 int major_inc, minor_inc;
628
629 if (params->x_major)
630 {
631 major_inc = params->x_inc * 3;
632 minor_inc = dib->stride * params->y_inc;
633 }
634 else
635 {
636 major_inc = dib->stride * params->y_inc;
637 minor_inc = params->x_inc * 3;
638 }
639
640 while (len--)
641 {
642 do_rop_8( ptr, and, xor );
643 do_rop_8( ptr + 1, and >> 8, xor >> 8 );
644 do_rop_8( ptr + 2, and >> 16, xor >> 16 );
645 if (err + params->bias > 0)
646 {
647 ptr += minor_inc;
648 err += params->err_add_1;
649 }
650 else err += params->err_add_2;
651 ptr += major_inc;
652 }
653 }
654
655 static void solid_line_16(const dib_info *dib, const POINT *start, const struct line_params *params,
656 DWORD and, DWORD xor)
657 {
658 WORD *ptr = get_pixel_ptr_16( dib, start->x, start->y );
659 int len = params->length, err = params->err_start;
660 int major_inc, minor_inc;
661
662 if (params->x_major)
663 {
664 major_inc = params->x_inc;
665 minor_inc = (dib->stride * params->y_inc) / 2;
666 }
667 else
668 {
669 major_inc = (dib->stride * params->y_inc) / 2;
670 minor_inc = params->x_inc;
671 }
672
673 while (len--)
674 {
675 do_rop_16( ptr, and, xor );
676 if (err + params->bias > 0)
677 {
678 ptr += minor_inc;
679 err += params->err_add_1;
680 }
681 else err += params->err_add_2;
682 ptr += major_inc;
683 }
684 }
685
686 static void solid_line_8(const dib_info *dib, const POINT *start, const struct line_params *params,
687 DWORD and, DWORD xor)
688 {
689 BYTE *ptr = get_pixel_ptr_8( dib, start->x, start->y );
690 int len = params->length, err = params->err_start;
691 int major_inc, minor_inc;
692
693 if (params->x_major)
694 {
695 major_inc = params->x_inc;
696 minor_inc = dib->stride * params->y_inc;
697 }
698 else
699 {
700 major_inc = dib->stride * params->y_inc;
701 minor_inc = params->x_inc;
702 }
703
704 while (len--)
705 {
706 do_rop_8( ptr, and, xor );
707 if (err + params->bias > 0)
708 {
709 ptr += minor_inc;
710 err += params->err_add_1;
711 }
712 else err += params->err_add_2;
713 ptr += major_inc;
714 }
715 }
716
717 static void solid_line_4(const dib_info *dib, const POINT *start, const struct line_params *params,
718 DWORD and, DWORD xor)
719 {
720 BYTE *ptr = get_pixel_ptr_4( dib, start->x, start->y );
721 int len = params->length, err = params->err_start;
722 int x = dib->rect.left + start->x;
723
724 and = (and & 0x0f) | ((and << 4) & 0xf0);
725 xor = (xor & 0x0f) | ((xor << 4) & 0xf0);
726
727 if (params->x_major)
728 {
729 while (len--)
730 {
731 do_rop_mask_8( ptr, and, xor, pixel_masks_4[ x % 2 ] );
732 if (err + params->bias > 0)
733 {
734 ptr += dib->stride * params->y_inc;
735 err += params->err_add_1;
736 }
737 else err += params->err_add_2;
738 if ((x / 2) != ((x + params->x_inc) / 2))
739 ptr += params->x_inc;
740 x += params->x_inc;
741 }
742 }
743 else
744 {
745 while (len--)
746 {
747 do_rop_mask_8( ptr, and, xor, pixel_masks_4[ x % 2 ] );
748 if (err + params->bias > 0)
749 {
750 if ((x / 2) != ((x + params->x_inc) / 2))
751 ptr += params->x_inc;
752 x += params->x_inc;
753 err += params->err_add_1;
754 }
755 else err += params->err_add_2;
756 ptr += dib->stride * params->y_inc;
757 }
758 }
759 }
760
761 static void solid_line_1(const dib_info *dib, const POINT *start, const struct line_params *params,
762 DWORD and, DWORD xor)
763 {
764 BYTE *ptr = get_pixel_ptr_1( dib, start->x, start->y );
765 int len = params->length, err = params->err_start;
766 int x = dib->rect.left + start->x;
767
768 and = (and & 0x1) ? 0xff : 0;
769 xor = (xor & 0x1) ? 0xff : 0;
770
771 if (params->x_major)
772 {
773 while (len--)
774 {
775 do_rop_mask_8( ptr, and, xor, pixel_masks_1[ x % 8 ] );
776 if (err + params->bias > 0)
777 {
778 ptr += dib->stride * params->y_inc;
779 err += params->err_add_1;
780 }
781 else err += params->err_add_2;
782 if ((x / 8) != ((x + params->x_inc) / 8))
783 ptr += params->x_inc;
784 x += params->x_inc;
785 }
786 }
787 else
788 {
789 while (len--)
790 {
791 do_rop_mask_8( ptr, and, xor, pixel_masks_1[ x % 8 ] );
792 if (err + params->bias > 0)
793 {
794 if ((x / 8) != ((x + params->x_inc) / 8))
795 ptr += params->x_inc;
796 x += params->x_inc;
797 err += params->err_add_1;
798 }
799 else err += params->err_add_2;
800 ptr += dib->stride * params->y_inc;
801 }
802 }
803 }
804
805 static void solid_line_null(const dib_info *dib, const POINT *start, const struct line_params *params,
806 DWORD and, DWORD xor)
807 {
808 return;
809 }
810
811 static inline INT calc_offset(INT edge, INT size, INT origin)
812 {
813 INT offset;
814
815 if(edge - origin >= 0)
816 offset = (edge - origin) % size;
817 else
818 {
819 offset = (origin - edge) % size;
820 if(offset) offset = size - offset;
821 }
822 return offset;
823 }
824
825 static inline POINT calc_brush_offset(const RECT *rc, const dib_info *brush, const POINT *origin)
826 {
827 POINT offset;
828
829 offset.x = calc_offset(rc->left, brush->width, origin->x);
830 offset.y = calc_offset(rc->top, brush->height, origin->y);
831
832 return offset;
833 }
834
835 static void pattern_rects_32(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
836 const dib_info *brush, const rop_mask_bits *bits)
837 {
838 DWORD *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
839 int x, y, i, len, brush_x;
840 POINT offset;
841
842 for(i = 0; i < num; i++, rc++)
843 {
844 offset = calc_brush_offset(rc, brush, origin);
845 start = get_pixel_ptr_32(dib, rc->left, rc->top);
846 start_xor = (DWORD*)bits->xor + offset.y * brush->stride / 4;
847
848 if (bits->and)
849 {
850 start_and = (DWORD*)bits->and + offset.y * brush->stride / 4;
851
852 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
853 {
854 and_ptr = start_and + offset.x;
855 xor_ptr = start_xor + offset.x;
856
857 for(x = rc->left, ptr = start; x < rc->right; x++)
858 {
859 do_rop_32(ptr++, *and_ptr++, *xor_ptr++);
860 if(and_ptr == start_and + brush->width)
861 {
862 and_ptr = start_and;
863 xor_ptr = start_xor;
864 }
865 }
866
867 offset.y++;
868 if(offset.y == brush->height)
869 {
870 start_and = bits->and;
871 start_xor = bits->xor;
872 offset.y = 0;
873 }
874 else
875 {
876 start_and += brush->stride / 4;
877 start_xor += brush->stride / 4;
878 }
879 }
880 }
881 else
882 {
883 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
884 {
885 for (x = rc->left, brush_x = offset.x; x < rc->right; x += len)
886 {
887 len = min( rc->right - x, brush->width - brush_x );
888 memcpy( start + x - rc->left, start_xor + brush_x, len * 4 );
889 brush_x = 0;
890 }
891
892 start_xor += brush->stride / 4;
893 offset.y++;
894 if(offset.y == brush->height)
895 {
896 start_xor = bits->xor;
897 offset.y = 0;
898 }
899 }
900 }
901 }
902 }
903
904 static void pattern_rects_24(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
905 const dib_info *brush, const rop_mask_bits *bits)
906 {
907 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
908 int x, y, i, len, brush_x;
909 POINT offset;
910
911 for(i = 0; i < num; i++, rc++)
912 {
913 offset = calc_brush_offset(rc, brush, origin);
914
915 start = get_pixel_ptr_24(dib, rc->left, rc->top);
916 start_xor = (BYTE*)bits->xor + offset.y * brush->stride;
917
918 if (bits->and)
919 {
920 start_and = (BYTE*)bits->and + offset.y * brush->stride;
921 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
922 {
923 and_ptr = start_and + offset.x * 3;
924 xor_ptr = start_xor + offset.x * 3;
925
926 for(x = rc->left, ptr = start; x < rc->right; x++)
927 {
928 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
929 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
930 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
931 if(and_ptr == start_and + brush->width * 3)
932 {
933 and_ptr = start_and;
934 xor_ptr = start_xor;
935 }
936 }
937
938 offset.y++;
939 if(offset.y == brush->height)
940 {
941 start_and = bits->and;
942 start_xor = bits->xor;
943 offset.y = 0;
944 }
945 else
946 {
947 start_and += brush->stride;
948 start_xor += brush->stride;
949 }
950 }
951 }
952 else
953 {
954 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
955 {
956 for (x = rc->left, brush_x = offset.x; x < rc->right; x += len)
957 {
958 len = min( rc->right - x, brush->width - brush_x );
959 memcpy( start + (x - rc->left) * 3, start_xor + brush_x * 3, len * 3 );
960 brush_x = 0;
961 }
962
963 start_xor += brush->stride;
964 offset.y++;
965 if(offset.y == brush->height)
966 {
967 start_xor = bits->xor;
968 offset.y = 0;
969 }
970 }
971 }
972 }
973 }
974
975 static void pattern_rects_16(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
976 const dib_info *brush, const rop_mask_bits *bits)
977 {
978 WORD *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
979 int x, y, i, len, brush_x;
980 POINT offset;
981
982 for(i = 0; i < num; i++, rc++)
983 {
984 offset = calc_brush_offset(rc, brush, origin);
985
986 start = get_pixel_ptr_16(dib, rc->left, rc->top);
987 start_xor = (WORD*)bits->xor + offset.y * brush->stride / 2;
988
989 if (bits->and)
990 {
991 start_and = (WORD*)bits->and + offset.y * brush->stride / 2;
992 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
993 {
994 and_ptr = start_and + offset.x;
995 xor_ptr = start_xor + offset.x;
996
997 for(x = rc->left, ptr = start; x < rc->right; x++)
998 {
999 do_rop_16(ptr++, *and_ptr++, *xor_ptr++);
1000 if(and_ptr == start_and + brush->width)
1001 {
1002 and_ptr = start_and;
1003 xor_ptr = start_xor;
1004 }
1005 }
1006
1007 offset.y++;
1008 if(offset.y == brush->height)
1009 {
1010 start_and = bits->and;
1011 start_xor = bits->xor;
1012 offset.y = 0;
1013 }
1014 else
1015 {
1016 start_and += brush->stride / 2;
1017 start_xor += brush->stride / 2;
1018 }
1019 }
1020 }
1021 else
1022 {
1023 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
1024 {
1025 for (x = rc->left, brush_x = offset.x; x < rc->right; x += len)
1026 {
1027 len = min( rc->right - x, brush->width - brush_x );
1028 memcpy( start + x - rc->left, start_xor + brush_x, len * 2 );
1029 brush_x = 0;
1030 }
1031
1032 start_xor += brush->stride / 2;
1033 offset.y++;
1034 if(offset.y == brush->height)
1035 {
1036 start_xor = bits->xor;
1037 offset.y = 0;
1038 }
1039 }
1040 }
1041 }
1042 }
1043
1044 static void pattern_rects_8(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
1045 const dib_info *brush, const rop_mask_bits *bits)
1046 {
1047 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
1048 int x, y, i, len, brush_x;
1049 POINT offset;
1050
1051 for(i = 0; i < num; i++, rc++)
1052 {
1053 offset = calc_brush_offset(rc, brush, origin);
1054
1055 start = get_pixel_ptr_8(dib, rc->left, rc->top);
1056 start_xor = (BYTE*)bits->xor + offset.y * brush->stride;
1057
1058 if (bits->and)
1059 {
1060 start_and = (BYTE*)bits->and + offset.y * brush->stride;
1061 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
1062 {
1063 and_ptr = start_and + offset.x;
1064 xor_ptr = start_xor + offset.x;
1065
1066 for(x = rc->left, ptr = start; x < rc->right; x++)
1067 {
1068 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
1069 if(and_ptr == start_and + brush->width)
1070 {
1071 and_ptr = start_and;
1072 xor_ptr = start_xor;
1073 }
1074 }
1075
1076 offset.y++;
1077 if(offset.y == brush->height)
1078 {
1079 start_and = bits->and;
1080 start_xor = bits->xor;
1081 offset.y = 0;
1082 }
1083 else
1084 {
1085 start_and += brush->stride;
1086 start_xor += brush->stride;
1087 }
1088 }
1089 }
1090 else
1091 {
1092 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
1093 {
1094 for (x = rc->left, brush_x = offset.x; x < rc->right; x += len)
1095 {
1096 len = min( rc->right - x, brush->width - brush_x );
1097 memcpy( start + x - rc->left, start_xor + brush_x, len );
1098 brush_x = 0;
1099 }
1100
1101 start_xor += brush->stride;
1102 offset.y++;
1103 if(offset.y == brush->height)
1104 {
1105 start_xor = bits->xor;
1106 offset.y = 0;
1107 }
1108 }
1109 }
1110 }
1111 }
1112
1113 static void pattern_rects_4(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
1114 const dib_info *brush, const rop_mask_bits *bits)
1115 {
1116 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
1117 int x, y, i, left, right;
1118 POINT offset;
1119
1120 for(i = 0; i < num; i++, rc++)
1121 {
1122 offset = calc_brush_offset(rc, brush, origin);
1123 left = dib->rect.left + rc->left;
1124 right = dib->rect.left + rc->right;
1125
1126 start = get_pixel_ptr_4(dib, rc->left, rc->top);
1127 start_xor = (BYTE*)bits->xor + offset.y * brush->stride;
1128
1129 if (bits->and)
1130 {
1131 start_and = (BYTE*)bits->and + offset.y * brush->stride;
1132 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
1133 {
1134 INT brush_x = offset.x;
1135 BYTE byte_and, byte_xor;
1136
1137 and_ptr = start_and + brush_x / 2;
1138 xor_ptr = start_xor + brush_x / 2;
1139
1140 for(x = left, ptr = start; x < right; x++)
1141 {
1142 /* FIXME: Two pixels at a time */
1143 if(x & 1) /* lower dst nibble */
1144 {
1145 if(brush_x & 1) /* lower pat nibble */
1146 {
1147 byte_and = *and_ptr++ | 0xf0;
1148 byte_xor = *xor_ptr++ & 0x0f;
1149 }
1150 else /* upper pat nibble */
1151 {
1152 byte_and = (*and_ptr >> 4) | 0xf0;
1153 byte_xor = (*xor_ptr >> 4) & 0x0f;
1154 }
1155 }
1156 else /* upper dst nibble */
1157 {
1158 if(brush_x & 1) /* lower pat nibble */
1159 {
1160 byte_and = (*and_ptr++ << 4) | 0x0f;
1161 byte_xor = (*xor_ptr++ << 4) & 0xf0;
1162 }
1163 else /* upper pat nibble */
1164 {
1165 byte_and = *and_ptr | 0x0f;
1166 byte_xor = *xor_ptr & 0xf0;
1167 }
1168 }
1169 do_rop_8(ptr, byte_and, byte_xor);
1170
1171 if(x & 1) ptr++;
1172
1173 if(++brush_x == brush->width)
1174 {
1175 brush_x = 0;
1176 and_ptr = start_and;
1177 xor_ptr = start_xor;
1178 }
1179 }
1180
1181 offset.y++;
1182 if(offset.y == brush->height)
1183 {
1184 start_and = bits->and;
1185 start_xor = bits->xor;
1186 offset.y = 0;
1187 }
1188 else
1189 {
1190 start_and += brush->stride;
1191 start_xor += brush->stride;
1192 }
1193 }
1194 }
1195 else
1196 {
1197 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
1198 {
1199 INT brush_x = offset.x;
1200 BYTE byte_xor;
1201
1202 xor_ptr = start_xor + brush_x / 2;
1203
1204 for(x = left, ptr = start; x < right; x++)
1205 {
1206 /* FIXME: Two pixels at a time */
1207 if(x & 1) /* lower dst nibble */
1208 {
1209 if(brush_x & 1) /* lower pat nibble */
1210 byte_xor = *xor_ptr++ & 0x0f;
1211 else /* upper pat nibble */
1212 byte_xor = (*xor_ptr >> 4) & 0x0f;
1213 do_rop_8(ptr, 0xf0, byte_xor);
1214 }
1215 else /* upper dst nibble */
1216 {
1217 if(brush_x & 1) /* lower pat nibble */
1218 byte_xor = (*xor_ptr++ << 4) & 0xf0;
1219 else /* upper pat nibble */
1220 byte_xor = *xor_ptr & 0xf0;
1221 do_rop_8(ptr, 0x0f, byte_xor);
1222 }
1223
1224 if(x & 1) ptr++;
1225
1226 if(++brush_x == brush->width)
1227 {
1228 brush_x = 0;
1229 xor_ptr = start_xor;
1230 }
1231 }
1232
1233 start_xor += brush->stride;
1234 offset.y++;
1235 if(offset.y == brush->height)
1236 {
1237 start_xor = bits->xor;
1238 offset.y = 0;
1239 }
1240 }
1241 }
1242 }
1243 }
1244
1245 static void pattern_rects_1(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
1246 const dib_info *brush, const rop_mask_bits *bits)
1247 {
1248 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
1249 int x, y, i, left, right;
1250 POINT offset;
1251
1252 for(i = 0; i < num; i++, rc++)
1253 {
1254 offset = calc_brush_offset(rc, brush, origin);
1255 left = dib->rect.left + rc->left;
1256 right = dib->rect.left + rc->right;
1257
1258 start = get_pixel_ptr_1(dib, rc->left, rc->top);
1259 start_xor = (BYTE*)bits->xor + offset.y * brush->stride;
1260
1261 if (bits->and)
1262 {
1263 start_and = (BYTE*)bits->and + offset.y * brush->stride;
1264 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
1265 {
1266 INT brush_x = offset.x;
1267 BYTE byte_and, byte_xor;
1268
1269 and_ptr = start_and + brush_x / 8;
1270 xor_ptr = start_xor + brush_x / 8;
1271
1272 for(x = left, ptr = start; x < right; x++)
1273 {
1274 byte_and = (*and_ptr & pixel_masks_1[brush_x % 8]) ? 0xff : 0;
1275 byte_and |= ~pixel_masks_1[x % 8];
1276 byte_xor = (*xor_ptr & pixel_masks_1[brush_x % 8]) ? 0xff : 0;
1277 byte_xor &= pixel_masks_1[x % 8];
1278
1279 do_rop_8(ptr, byte_and, byte_xor);
1280
1281 if((x & 7) == 7) ptr++;
1282
1283 if((brush_x & 7) == 7)
1284 {
1285 and_ptr++;
1286 xor_ptr++;
1287 }
1288
1289 if(++brush_x == brush->width)
1290 {
1291 brush_x = 0;
1292 and_ptr = start_and;
1293 xor_ptr = start_xor;
1294 }
1295 }
1296
1297 offset.y++;
1298 if(offset.y == brush->height)
1299 {
1300 start_and = bits->and;
1301 start_xor = bits->xor;
1302 offset.y = 0;
1303 }
1304 else
1305 {
1306 start_and += brush->stride;
1307 start_xor += brush->stride;
1308 }
1309 }
1310 }
1311 else
1312 {
1313 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
1314 {
1315 INT brush_x = offset.x;
1316
1317 xor_ptr = start_xor + brush_x / 8;
1318
1319 for(x = left, ptr = start; x < right; x++)
1320 {
1321 BYTE byte_xor = (*xor_ptr & pixel_masks_1[brush_x % 8]) ? 0xff : 0;
1322 byte_xor &= pixel_masks_1[x % 8];
1323
1324 do_rop_8(ptr, ~pixel_masks_1[x % 8], byte_xor);
1325
1326 if((x & 7) == 7) ptr++;
1327 if((brush_x & 7) == 7) xor_ptr++;
1328
1329 if(++brush_x == brush->width)
1330 {
1331 brush_x = 0;
1332 xor_ptr = start_xor;
1333 }
1334 }
1335
1336 start_xor += brush->stride;
1337 offset.y++;
1338 if(offset.y == brush->height)
1339 {
1340 start_xor = bits->xor;
1341 offset.y = 0;
1342 }
1343 }
1344 }
1345 }
1346 }
1347
1348 static void pattern_rects_null(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
1349 const dib_info *brush, const rop_mask_bits *bits)
1350 {
1351 return;
1352 }
1353
1354 static void copy_rect_32(const dib_info *dst, const RECT *rc,
1355 const dib_info *src, const POINT *origin, int rop2, int overlap)
1356 {
1357 DWORD *dst_start, *src_start;
1358 struct rop_codes codes;
1359 int y, dst_stride, src_stride;
1360
1361 if (overlap & OVERLAP_BELOW)
1362 {
1363 dst_start = get_pixel_ptr_32(dst, rc->left, rc->bottom - 1);
1364 src_start = get_pixel_ptr_32(src, origin->x, origin->y + rc->bottom - rc->top - 1);
1365 dst_stride = -dst->stride / 4;
1366 src_stride = -src->stride / 4;
1367 }
1368 else
1369 {
1370 dst_start = get_pixel_ptr_32(dst, rc->left, rc->top);
1371 src_start = get_pixel_ptr_32(src, origin->x, origin->y);
1372 dst_stride = dst->stride / 4;
1373 src_stride = src->stride / 4;
1374 }
1375
1376 if (rop2 == R2_COPYPEN)
1377 {
1378 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1379 memmove( dst_start, src_start, (rc->right - rc->left) * 4 );
1380 return;
1381 }
1382
1383 get_rop_codes( rop2, &codes );
1384 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1385 {
1386 if (overlap & OVERLAP_RIGHT)
1387 do_rop_codes_line_rev_32( dst_start, src_start, &codes, rc->right - rc->left );
1388 else
1389 do_rop_codes_line_32( dst_start, src_start, &codes, rc->right - rc->left );
1390 }
1391 }
1392
1393 static void copy_rect_24(const dib_info *dst, const RECT *rc,
1394 const dib_info *src, const POINT *origin, int rop2, int overlap)
1395 {
1396 BYTE *dst_start, *src_start;
1397 int y, dst_stride, src_stride;
1398 struct rop_codes codes;
1399
1400 if (overlap & OVERLAP_BELOW)
1401 {
1402 dst_start = get_pixel_ptr_24(dst, rc->left, rc->bottom - 1);
1403 src_start = get_pixel_ptr_24(src, origin->x, origin->y + rc->bottom - rc->top - 1);
1404 dst_stride = -dst->stride;
1405 src_stride = -src->stride;
1406 }
1407 else
1408 {
1409 dst_start = get_pixel_ptr_24(dst, rc->left, rc->top);
1410 src_start = get_pixel_ptr_24(src, origin->x, origin->y);
1411 dst_stride = dst->stride;
1412 src_stride = src->stride;
1413 }
1414
1415 if (rop2 == R2_COPYPEN)
1416 {
1417 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1418 memmove( dst_start, src_start, (rc->right - rc->left) * 3 );
1419 return;
1420 }
1421
1422 get_rop_codes( rop2, &codes );
1423 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1424 {
1425 if (overlap & OVERLAP_RIGHT)
1426 do_rop_codes_line_rev_8( dst_start, src_start, &codes, (rc->right - rc->left) * 3 );
1427 else
1428 do_rop_codes_line_8( dst_start, src_start, &codes, (rc->right - rc->left) * 3 );
1429 }
1430 }
1431
1432 static void copy_rect_16(const dib_info *dst, const RECT *rc,
1433 const dib_info *src, const POINT *origin, int rop2, int overlap)
1434 {
1435 WORD *dst_start, *src_start;
1436 int y, dst_stride, src_stride;
1437 struct rop_codes codes;
1438
1439 if (overlap & OVERLAP_BELOW)
1440 {
1441 dst_start = get_pixel_ptr_16(dst, rc->left, rc->bottom - 1);
1442 src_start = get_pixel_ptr_16(src, origin->x, origin->y + rc->bottom - rc->top - 1);
1443 dst_stride = -dst->stride / 2;
1444 src_stride = -src->stride / 2;
1445 }
1446 else
1447 {
1448 dst_start = get_pixel_ptr_16(dst, rc->left, rc->top);
1449 src_start = get_pixel_ptr_16(src, origin->x, origin->y);
1450 dst_stride = dst->stride / 2;
1451 src_stride = src->stride / 2;
1452 }
1453
1454 if (rop2 == R2_COPYPEN)
1455 {
1456 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1457 memmove( dst_start, src_start, (rc->right - rc->left) * 2 );
1458 return;
1459 }
1460
1461 get_rop_codes( rop2, &codes );
1462 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1463 {
1464 if (overlap & OVERLAP_RIGHT)
1465 do_rop_codes_line_rev_16( dst_start, src_start, &codes, rc->right - rc->left );
1466 else
1467 do_rop_codes_line_16( dst_start, src_start, &codes, rc->right - rc->left );
1468 }
1469 }
1470
1471 static void copy_rect_8(const dib_info *dst, const RECT *rc,
1472 const dib_info *src, const POINT *origin, int rop2, int overlap)
1473 {
1474 BYTE *dst_start, *src_start;
1475 int y, dst_stride, src_stride;
1476 struct rop_codes codes;
1477
1478 if (overlap & OVERLAP_BELOW)
1479 {
1480 dst_start = get_pixel_ptr_8(dst, rc->left, rc->bottom - 1);
1481 src_start = get_pixel_ptr_8(src, origin->x, origin->y + rc->bottom - rc->top - 1);
1482 dst_stride = -dst->stride;
1483 src_stride = -src->stride;
1484 }
1485 else
1486 {
1487 dst_start = get_pixel_ptr_8(dst, rc->left, rc->top);
1488 src_start = get_pixel_ptr_8(src, origin->x, origin->y);
1489 dst_stride = dst->stride;
1490 src_stride = src->stride;
1491 }
1492
1493 if (rop2 == R2_COPYPEN)
1494 {
1495 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1496 memmove( dst_start, src_start, (rc->right - rc->left) );
1497 return;
1498 }
1499
1500 get_rop_codes( rop2, &codes );
1501 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1502 {
1503 if (overlap & OVERLAP_RIGHT)
1504 do_rop_codes_line_rev_8( dst_start, src_start, &codes, rc->right - rc->left );
1505 else
1506 do_rop_codes_line_8( dst_start, src_start, &codes, rc->right - rc->left );
1507 }
1508 }
1509
1510 static void copy_rect_4(const dib_info *dst, const RECT *rc,
1511 const dib_info *src, const POINT *origin, int rop2, int overlap)
1512 {
1513 BYTE *dst_start, *src_start;
1514 int y, dst_stride, src_stride;
1515 struct rop_codes codes;
1516 int left = dst->rect.left + rc->left;
1517 int right = dst->rect.left + rc->right;
1518 int org_x = src->rect.left + origin->x;
1519
1520 if (overlap & OVERLAP_BELOW)
1521 {
1522 dst_start = get_pixel_ptr_4(dst, rc->left, rc->bottom - 1);
1523 src_start = get_pixel_ptr_4(src, origin->x, origin->y + rc->bottom - rc->top - 1);
1524 dst_stride = -dst->stride;
1525 src_stride = -src->stride;
1526 }
1527 else
1528 {
1529 dst_start = get_pixel_ptr_4(dst, rc->left, rc->top);
1530 src_start = get_pixel_ptr_4(src, origin->x, origin->y);
1531 dst_stride = dst->stride;
1532 src_stride = src->stride;
1533 }
1534
1535 if (rop2 == R2_COPYPEN && (left & 1) == 0 && (org_x & 1) == 0 && (right & 1) == 0)
1536 {
1537 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1538 memmove( dst_start, src_start, (right - left) / 2 );
1539 return;
1540 }
1541
1542 get_rop_codes( rop2, &codes );
1543 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1544 {
1545 if (overlap & OVERLAP_RIGHT)
1546 do_rop_codes_line_rev_4( dst_start, left & 1, src_start, org_x & 1, &codes, right - left );
1547 else
1548 do_rop_codes_line_4( dst_start, left & 1, src_start, org_x & 1, &codes, right - left );
1549 }
1550 }
1551
1552 static void copy_rect_1(const dib_info *dst, const RECT *rc,
1553 const dib_info *src, const POINT *origin, int rop2, int overlap)
1554 {
1555 BYTE *dst_start, *src_start;
1556 int y, dst_stride, src_stride;
1557 struct rop_codes codes;
1558 int left = dst->rect.left + rc->left;
1559 int right = dst->rect.left + rc->right;
1560 int org_x = src->rect.left + origin->x;
1561
1562 if (overlap & OVERLAP_BELOW)
1563 {
1564 dst_start = get_pixel_ptr_1(dst, rc->left, rc->bottom - 1);
1565 src_start = get_pixel_ptr_1(src, origin->x, origin->y + rc->bottom - rc->top - 1);
1566 dst_stride = -dst->stride;
1567 src_stride = -src->stride;
1568 }
1569 else
1570 {
1571 dst_start = get_pixel_ptr_1(dst, rc->left, rc->top);
1572 src_start = get_pixel_ptr_1(src, origin->x, origin->y);
1573 dst_stride = dst->stride;
1574 src_stride = src->stride;
1575 }
1576
1577 if (rop2 == R2_COPYPEN && (left & 7) == 0 && (org_x & 7) == 0 && (right & 7) == 0)
1578 {
1579 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1580 memmove( dst_start, src_start, (right - left) / 8 );
1581 return;
1582 }
1583
1584 get_rop_codes( rop2, &codes );
1585 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1586 {
1587 if (overlap & OVERLAP_RIGHT)
1588 do_rop_codes_line_rev_1( dst_start, left & 7, src_start, org_x & 7, &codes, right - left );
1589 else
1590 do_rop_codes_line_1( dst_start, left & 7, src_start, org_x & 7, &codes, right - left );
1591 }
1592 }
1593
1594 static void copy_rect_null(const dib_info *dst, const RECT *rc,
1595 const dib_info *src, const POINT *origin, int rop2, int overlap)
1596 {
1597 return;
1598 }
1599
1600 static DWORD get_pixel_32(const dib_info *dib, int x, int y)
1601 {
1602 DWORD *ptr = get_pixel_ptr_32( dib, x, y );
1603 return *ptr;
1604 }
1605
1606 static DWORD get_pixel_24(const dib_info *dib, int x, int y)
1607 {
1608 BYTE *ptr = get_pixel_ptr_24( dib, x, y );
1609 return ptr[0] | ((DWORD)ptr[1] << 8) | ((DWORD)ptr[2] << 16);
1610 }
1611
1612 static DWORD get_pixel_16(const dib_info *dib, int x, int y)
1613 {
1614 WORD *ptr = get_pixel_ptr_16( dib, x, y );
1615 return *ptr;
1616 }
1617
1618 static DWORD get_pixel_8(const dib_info *dib, int x, int y)
1619 {
1620 BYTE *ptr = get_pixel_ptr_8( dib, x, y );
1621 return *ptr;
1622 }
1623
1624 static DWORD get_pixel_4(const dib_info *dib, int x, int y)
1625 {
1626 BYTE *ptr = get_pixel_ptr_4( dib, x, y );
1627
1628 if ((dib->rect.left + x) & 1)
1629 return *ptr & 0x0f;
1630 else
1631 return (*ptr >> 4) & 0x0f;
1632 }
1633
1634 static DWORD get_pixel_1(const dib_info *dib, int x, int y)
1635 {
1636 BYTE *ptr = get_pixel_ptr_1( dib, x, y );
1637 return (*ptr & pixel_masks_1[(dib->rect.left + x) & 7]) ? 1 : 0;
1638 }
1639
1640 static DWORD get_pixel_null(const dib_info *dib, int x, int y)
1641 {
1642 return 0;
1643 }
1644
1645 static DWORD colorref_to_pixel_888(const dib_info *dib, COLORREF color)
1646 {
1647 return ( ((color >> 16) & 0xff) | (color & 0xff00) | ((color << 16) & 0xff0000) );
1648 }
1649
1650 static const DWORD field_masks[33] =
1651 {
1652 0x00, /* should never happen */
1653 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff,
1654 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1655 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1656 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1657 };
1658
1659 static inline DWORD get_field(DWORD field, int shift, int len)
1660 {
1661 shift = shift - (8 - len);
1662 if (shift < 0)
1663 field <<= -shift;
1664 else
1665 field >>= shift;
1666 field &= field_masks[len];
1667 field |= field >> len;
1668 return field;
1669 }
1670
1671 static inline DWORD put_field(DWORD field, int shift, int len)
1672 {
1673 shift = shift - (8 - len);
1674 field &= field_masks[len];
1675 if (shift < 0)
1676 field >>= -shift;
1677 else
1678 field <<= shift;
1679 return field;
1680 }
1681
1682 static DWORD colorref_to_pixel_masks(const dib_info *dib, COLORREF colour)
1683 {
1684 DWORD r,g,b;
1685
1686 r = GetRValue(colour);
1687 g = GetGValue(colour);
1688 b = GetBValue(colour);
1689
1690 return put_field(r, dib->red_shift, dib->red_len) |
1691 put_field(g, dib->green_shift, dib->green_len) |
1692 put_field(b, dib->blue_shift, dib->blue_len);
1693 }
1694
1695 static DWORD colorref_to_pixel_555(const dib_info *dib, COLORREF color)
1696 {
1697 return ( ((color >> 19) & 0x1f) | ((color >> 6) & 0x03e0) | ((color << 7) & 0x7c00) );
1698 }
1699
1700 static DWORD rgb_to_pixel_colortable(const dib_info *dib, BYTE r, BYTE g, BYTE b)
1701 {
1702 const RGBQUAD *color_table = get_dib_color_table( dib );
1703 int size = dib->color_table ? dib->color_table_size : 1 << dib->bit_count;
1704 int i, best_index = 0;
1705 DWORD diff, best_diff = 0xffffffff;
1706
1707 /* special case for conversion to 1-bpp without a color table:
1708 * we get a 1-entry table containing the background color
1709 */
1710 if (dib->bit_count == 1 && size == 1)
1711 return (r == color_table[0].rgbRed &&
1712 g == color_table[0].rgbGreen &&
1713 b == color_table[0].rgbBlue);
1714
1715 for(i = 0; i < size; i++)
1716 {
1717 const RGBQUAD *cur = color_table + i;
1718 diff = (r - cur->rgbRed) * (r - cur->rgbRed)
1719 + (g - cur->rgbGreen) * (g - cur->rgbGreen)
1720 + (b - cur->rgbBlue) * (b - cur->rgbBlue);
1721
1722 if(diff == 0)
1723 {
1724 best_index = i;
1725 break;
1726 }
1727
1728 if(diff < best_diff)
1729 {
1730 best_diff = diff;
1731 best_index = i;
1732 }
1733 }
1734 return best_index;
1735 }
1736
1737 static DWORD rgb_to_pixel_mono(const dib_info *dib, BOOL dither, int x, int y, BYTE r, BYTE g, BYTE b)
1738 {
1739 DWORD ret;
1740
1741 if (!dither)
1742 ret = rgb_to_pixel_colortable( dib, r, g, b );
1743 else
1744 ret = ((30 * r + 59 * g + 11 * b) / 100 + bayer_16x16[y % 16][x % 16]) > 255;
1745
1746 return ret ? 0xff : 0;
1747 }
1748
1749 static DWORD colorref_to_pixel_colortable(const dib_info *dib, COLORREF color)
1750 {
1751 return rgb_to_pixel_colortable( dib, GetRValue(color), GetGValue(color), GetBValue(color) );
1752 }
1753
1754 static DWORD colorref_to_pixel_null(const dib_info *dib, COLORREF color)
1755 {
1756 return 0;
1757 }
1758
1759 static COLORREF pixel_to_colorref_888(const dib_info *dib, DWORD pixel)
1760 {
1761 return ( ((pixel >> 16) & 0xff) | (pixel & 0xff00) | ((pixel << 16) & 0xff0000) );
1762 }
1763
1764 static COLORREF pixel_to_colorref_masks(const dib_info *dib, DWORD pixel)
1765 {
1766 return RGB( get_field( pixel, dib->red_shift, dib->red_len ),
1767 get_field( pixel, dib->green_shift, dib->green_len ),
1768 get_field( pixel, dib->blue_shift, dib->blue_len ) );
1769 }
1770
1771 static COLORREF pixel_to_colorref_555(const dib_info *dib, DWORD pixel)
1772 {
1773 return RGB( ((pixel >> 7) & 0xf8) | ((pixel >> 12) & 0x07),
1774 ((pixel >> 2) & 0xf8) | ((pixel >> 7) & 0x07),
1775 ((pixel << 3) & 0xf8) | ((pixel >> 2) & 0x07) );
1776 }
1777
1778 static COLORREF pixel_to_colorref_colortable(const dib_info *dib, DWORD pixel)
1779 {
1780 const RGBQUAD *color_table = get_dib_color_table( dib );
1781
1782 if (!dib->color_table || pixel < dib->color_table_size)
1783 {
1784 RGBQUAD quad = color_table[pixel];
1785 return RGB( quad.rgbRed, quad.rgbGreen, quad.rgbBlue );
1786 }
1787 return 0;
1788 }
1789
1790 static COLORREF pixel_to_colorref_null(const dib_info *dib, DWORD pixel)
1791 {
1792 return 0;
1793 }
1794
1795 static inline BOOL bit_fields_match(const dib_info *d1, const dib_info *d2)
1796 {
1797 assert( d1->bit_count > 8 && d1->bit_count == d2->bit_count );
1798
1799 return d1->red_mask == d2->red_mask &&
1800 d1->green_mask == d2->green_mask &&
1801 d1->blue_mask == d2->blue_mask;
1802 }
1803
1804 static void convert_to_8888(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
1805 {
1806 DWORD *dst_start = get_pixel_ptr_32(dst, 0, 0), *dst_pixel, src_val;
1807 int x, y, pad_size = (dst->width - (src_rect->right - src_rect->left)) * 4;
1808
1809 switch(src->bit_count)
1810 {
1811 case 32:
1812 {
1813 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1814 if(src->funcs == &funcs_8888)
1815 {
1816 if (src->stride > 0 && src->stride == dst->stride && !pad_size)
1817 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
1818 else
1819 {
1820 for(y = src_rect->top; y < src_rect->bottom; y++)
1821 {
1822 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 4);
1823 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
1824 dst_start += dst->stride / 4;
1825 src_start += src->stride / 4;
1826 }
1827 }
1828 }
1829 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
1830 {
1831 for(y = src_rect->top; y < src_rect->bottom; y++)
1832 {
1833 dst_pixel = dst_start;
1834 src_pixel = src_start;
1835 for(x = src_rect->left; x < src_rect->right; x++)
1836 {
1837 src_val = *src_pixel++;
1838 *dst_pixel++ = (((src_val >> src->red_shift) & 0xff) << 16) |
1839 (((src_val >> src->green_shift) & 0xff) << 8) |
1840 ((src_val >> src->blue_shift) & 0xff);
1841 }
1842 if(pad_size) memset(dst_pixel, 0, pad_size);
1843 dst_start += dst->stride / 4;
1844 src_start += src->stride / 4;
1845 }
1846 }
1847 else
1848 {
1849 for(y = src_rect->top; y < src_rect->bottom; y++)
1850 {
1851 dst_pixel = dst_start;
1852 src_pixel = src_start;
1853 for(x = src_rect->left; x < src_rect->right; x++)
1854 {
1855 src_val = *src_pixel++;
1856 *dst_pixel++ = (get_field( src_val, src->red_shift, src->red_len ) << 16 |
1857 get_field( src_val, src->green_shift, src->green_len ) << 8 |
1858 get_field( src_val, src->blue_shift, src->blue_len ));
1859 }
1860 if(pad_size) memset(dst_pixel, 0, pad_size);
1861 dst_start += dst->stride / 4;
1862 src_start += src->stride / 4;
1863 }
1864 }
1865 break;
1866 }
1867
1868 case 24:
1869 {
1870 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
1871
1872 for(y = src_rect->top; y < src_rect->bottom; y++)
1873 {
1874 dst_pixel = dst_start;
1875 src_pixel = src_start;
1876 for(x = src_rect->left; x < src_rect->right; x++)
1877 {
1878 RGBQUAD rgb;
1879 rgb.rgbBlue = *src_pixel++;
1880 rgb.rgbGreen = *src_pixel++;
1881 rgb.rgbRed = *src_pixel++;
1882
1883 *dst_pixel++ = ((rgb.rgbRed << 16) & 0xff0000) | ((rgb.rgbGreen << 8) & 0x00ff00) | (rgb.rgbBlue & 0x0000ff);
1884 }
1885 if(pad_size) memset(dst_pixel, 0, pad_size);
1886 dst_start += dst->stride / 4;
1887 src_start += src->stride;
1888 }
1889 break;
1890 }
1891
1892 case 16:
1893 {
1894 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
1895 if(src->funcs == &funcs_555)
1896 {
1897 for(y = src_rect->top; y < src_rect->bottom; y++)
1898 {
1899 dst_pixel = dst_start;
1900 src_pixel = src_start;
1901 for(x = src_rect->left; x < src_rect->right; x++)
1902 {
1903 src_val = *src_pixel++;
1904 *dst_pixel++ = ((src_val << 9) & 0xf80000) | ((src_val << 4) & 0x070000) |
1905 ((src_val << 6) & 0x00f800) | ((src_val << 1) & 0x000700) |
1906 ((src_val << 3) & 0x0000f8) | ((src_val >> 2) & 0x000007);
1907 }
1908 if(pad_size) memset(dst_pixel, 0, pad_size);
1909 dst_start += dst->stride / 4;
1910 src_start += src->stride / 2;
1911 }
1912 }
1913 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
1914 {
1915 for(y = src_rect->top; y < src_rect->bottom; y++)
1916 {
1917 dst_pixel = dst_start;
1918 src_pixel = src_start;
1919 for(x = src_rect->left; x < src_rect->right; x++)
1920 {
1921 src_val = *src_pixel++;
1922 *dst_pixel++ = (((src_val >> src->red_shift) << 19) & 0xf80000) |
1923 (((src_val >> src->red_shift) << 14) & 0x070000) |
1924 (((src_val >> src->green_shift) << 11) & 0x00f800) |
1925 (((src_val >> src->green_shift) << 6) & 0x000700) |
1926 (((src_val >> src->blue_shift) << 3) & 0x0000f8) |
1927 (((src_val >> src->blue_shift) >> 2) & 0x000007);
1928 }
1929 if(pad_size) memset(dst_pixel, 0, pad_size);
1930 dst_start += dst->stride / 4;
1931 src_start += src->stride / 2;
1932 }
1933 }
1934 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
1935 {
1936 for(y = src_rect->top; y < src_rect->bottom; y++)
1937 {
1938 dst_pixel = dst_start;
1939 src_pixel = src_start;
1940 for(x = src_rect->left; x < src_rect->right; x++)
1941 {
1942 src_val = *src_pixel++;
1943 *dst_pixel++ = (((src_val >> src->red_shift) << 19) & 0xf80000) |
1944 (((src_val >> src->red_shift) << 14) & 0x070000) |
1945 (((src_val >> src->green_shift) << 10) & 0x00fc00) |
1946 (((src_val >> src->green_shift) << 4) & 0x000300) |
1947 (((src_val >> src->blue_shift) << 3) & 0x0000f8) |
1948 (((src_val >> src->blue_shift) >> 2) & 0x000007);
1949 }
1950 if(pad_size) memset(dst_pixel, 0, pad_size);
1951 dst_start += dst->stride / 4;
1952 src_start += src->stride / 2;
1953 }
1954 }
1955 else
1956 {
1957 for(y = src_rect->top; y < src_rect->bottom; y++)
1958 {
1959 dst_pixel = dst_start;
1960 src_pixel = src_start;
1961 for(x = src_rect->left; x < src_rect->right; x++)
1962 {
1963 src_val = *src_pixel++;
1964 *dst_pixel++ = (get_field( src_val, src->red_shift, src->red_len ) << 16 |
1965 get_field( src_val, src->green_shift, src->green_len ) << 8 |
1966 get_field( src_val, src->blue_shift, src->blue_len ));
1967 }
1968 if(pad_size) memset(dst_pixel, 0, pad_size);
1969 dst_start += dst->stride / 4;
1970 src_start += src->stride / 2;
1971 }
1972 }
1973 break;
1974 }
1975
1976 case 8:
1977 {
1978 const RGBQUAD *color_table = get_dib_color_table( src );
1979 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
1980 for(y = src_rect->top; y < src_rect->bottom; y++)
1981 {
1982 dst_pixel = dst_start;
1983 src_pixel = src_start;
1984 for(x = src_rect->left; x < src_rect->right; x++)
1985 {
1986 RGBQUAD rgb = color_table[*src_pixel++];
1987 *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
1988 }
1989 if(pad_size) memset(dst_pixel, 0, pad_size);
1990 dst_start += dst->stride / 4;
1991 src_start += src->stride;
1992 }
1993 break;
1994 }
1995
1996 case 4:
1997 {
1998 const RGBQUAD *color_table = get_dib_color_table( src );
1999 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2000 for(y = src_rect->top; y < src_rect->bottom; y++)
2001 {
2002 int pos = (src->rect.left + src_rect->left) & 1;
2003 src_pixel = src_start;
2004 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2005 {
2006 RGBQUAD rgb;
2007 if (pos & 1)
2008 rgb = color_table[*src_pixel++ & 0xf];
2009 else
2010 rgb = color_table[*src_pixel >> 4];
2011 dst_start[x] = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
2012 }
2013 if(pad_size) memset(dst_start + x, 0, pad_size);
2014 dst_start += dst->stride / 4;
2015 src_start += src->stride;
2016 }
2017 break;
2018 }
2019
2020 case 1:
2021 {
2022 const RGBQUAD *color_table = get_dib_color_table( src );
2023 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
2024 for(y = src_rect->top; y < src_rect->bottom; y++)
2025 {
2026 int pos = (src->rect.left + src_rect->left) & 7;
2027 for(x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2028 {
2029 RGBQUAD rgb;
2030 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
2031 rgb = color_table[src_val];
2032 dst_start[x] = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
2033 }
2034 if(pad_size) memset(dst_start + x, 0, pad_size);
2035 dst_start += dst->stride / 4;
2036 src_start += src->stride;
2037 }
2038 break;
2039 }
2040 }
2041 }
2042
2043 static void convert_to_32(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
2044 {
2045 DWORD *dst_start = get_pixel_ptr_32(dst, 0, 0), *dst_pixel, src_val;
2046 int x, y, pad_size = (dst->width - (src_rect->right - src_rect->left)) * 4;
2047
2048 switch(src->bit_count)
2049 {
2050 case 32:
2051 {
2052 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2053
2054 if(src->funcs == &funcs_8888)
2055 {
2056 for(y = src_rect->top; y < src_rect->bottom; y++)
2057 {
2058 dst_pixel = dst_start;
2059 src_pixel = src_start;
2060 for(x = src_rect->left; x < src_rect->right; x++)
2061 {
2062 src_val = *src_pixel++;
2063 *dst_pixel++ = put_field(src_val >> 16, dst->red_shift, dst->red_len) |
2064 put_field(src_val >> 8, dst->green_shift, dst->green_len) |
2065 put_field(src_val, dst->blue_shift, dst->blue_len);
2066 }
2067 if(pad_size) memset(dst_pixel, 0, pad_size);
2068 dst_start += dst->stride / 4;
2069 src_start += src->stride / 4;
2070 }
2071 }
2072 else if(bit_fields_match(src, dst))
2073 {
2074 if (src->stride > 0 && src->stride == dst->stride && !pad_size)
2075 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2076 else
2077 {
2078 for(y = src_rect->top; y < src_rect->bottom; y++)
2079 {
2080 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 4);
2081 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2082 dst_start += dst->stride / 4;
2083 src_start += src->stride / 4;
2084 }
2085 }
2086 }
2087 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8 &&
2088 dst->red_len == 8 && dst->green_len == 8 && dst->blue_len == 8)
2089 {
2090 for(y = src_rect->top; y < src_rect->bottom; y++)
2091 {
2092 dst_pixel = dst_start;
2093 src_pixel = src_start;
2094 for(x = src_rect->left; x < src_rect->right; x++)
2095 {
2096 src_val = *src_pixel++;
2097 *dst_pixel++ = (((src_val >> src->red_shift) & 0xff) << dst->red_shift) |
2098 (((src_val >> src->green_shift) & 0xff) << dst->green_shift) |
2099 (((src_val >> src->blue_shift) & 0xff) << dst->blue_shift);
2100 }
2101 if(pad_size) memset(dst_pixel, 0, pad_size);
2102 dst_start += dst->stride / 4;
2103 src_start += src->stride / 4;
2104 }
2105 }
2106 else
2107 {
2108 for(y = src_rect->top; y < src_rect->bottom; y++)
2109 {
2110 dst_pixel = dst_start;
2111 src_pixel = src_start;
2112 for(x = src_rect->left; x < src_rect->right; x++)
2113 {
2114 src_val = *src_pixel++;
2115 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2116 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2117 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2118 }
2119 if(pad_size) memset(dst_pixel, 0, pad_size);
2120 dst_start += dst->stride / 4;
2121 src_start += src->stride / 4;
2122 }
2123 }
2124 break;
2125 }
2126
2127 case 24:
2128 {
2129 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2130
2131 for(y = src_rect->top; y < src_rect->bottom; y++)
2132 {
2133 dst_pixel = dst_start;
2134 src_pixel = src_start;
2135 for(x = src_rect->left; x < src_rect->right; x++)
2136 {
2137 RGBQUAD rgb;
2138 rgb.rgbBlue = *src_pixel++;
2139 rgb.rgbGreen = *src_pixel++;
2140 rgb.rgbRed = *src_pixel++;
2141
2142 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2143 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2144 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2145 }
2146 if(pad_size) memset(dst_pixel, 0, pad_size);
2147 dst_start += dst->stride / 4;
2148 src_start += src->stride;
2149 }
2150 break;
2151 }
2152
2153 case 16:
2154 {
2155 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2156 if(src->funcs == &funcs_555)
2157 {
2158 for(y = src_rect->top; y < src_rect->bottom; y++)
2159 {
2160 dst_pixel = dst_start;
2161 src_pixel = src_start;
2162 for(x = src_rect->left; x < src_rect->right; x++)
2163 {
2164 src_val = *src_pixel++;
2165 *dst_pixel++ = put_field(((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07), dst->red_shift, dst->red_len) |
2166 put_field(((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07), dst->green_shift, dst->green_len) |
2167 put_field(((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2168 }
2169 if(pad_size) memset(dst_pixel, 0, pad_size);
2170 dst_start += dst->stride / 4;
2171 src_start += src->stride / 2;
2172 }
2173 }
2174 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2175 {
2176 for(y = src_rect->top; y < src_rect->bottom; y++)
2177 {
2178 dst_pixel = dst_start;
2179 src_pixel = src_start;
2180 for(x = src_rect->left; x < src_rect->right; x++)
2181 {
2182 src_val = *src_pixel++;
2183 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2184 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2185 put_field( (((src_val >> src->green_shift) << 3) & 0xf8) |
2186 (((src_val >> src->green_shift) >> 2) & 0x07), dst->green_shift, dst->green_len ) |
2187 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2188 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2189 }
2190 if(pad_size) memset(dst_pixel, 0, pad_size);
2191 dst_start += dst->stride / 4;
2192 src_start += src->stride / 2;
2193 }
2194 }
2195 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2196 {
2197 for(y = src_rect->top; y < src_rect->bottom; y++)
2198 {
2199 dst_pixel = dst_start;
2200 src_pixel = src_start;
2201 for(x = src_rect->left; x < src_rect->right; x++)
2202 {
2203 src_val = *src_pixel++;
2204 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2205 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2206 put_field( (((src_val >> src->green_shift) << 2) & 0xfc) |
2207 (((src_val >> src->green_shift) >> 4) & 0x03), dst->green_shift, dst->green_len ) |
2208 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2209 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2210 }
2211 if(pad_size) memset(dst_pixel, 0, pad_size);
2212 dst_start += dst->stride / 4;
2213 src_start += src->stride / 2;
2214 }
2215 }
2216 else
2217 {
2218 for(y = src_rect->top; y < src_rect->bottom; y++)
2219 {
2220 dst_pixel = dst_start;
2221 src_pixel = src_start;
2222 for(x = src_rect->left; x < src_rect->right; x++)
2223 {
2224 src_val = *src_pixel++;
2225 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2226 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2227 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2228 }
2229 if(pad_size) memset(dst_pixel, 0, pad_size);
2230 dst_start += dst->stride / 4;
2231 src_start += src->stride / 2;
2232 }
2233 }
2234 break;
2235 }
2236
2237 case 8:
2238 {
2239 const RGBQUAD *color_table = get_dib_color_table( src );
2240 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2241 for(y = src_rect->top; y < src_rect->bottom; y++)
2242 {
2243 dst_pixel = dst_start;
2244 src_pixel = src_start;
2245 for(x = src_rect->left; x < src_rect->right; x++)
2246 {
2247 RGBQUAD rgb = color_table[*src_pixel++];
2248 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2249 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2250 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2251 }
2252 if(pad_size) memset(dst_pixel, 0, pad_size);
2253 dst_start += dst->stride / 4;
2254 src_start += src->stride;
2255 }
2256 break;
2257 }
2258
2259 case 4:
2260 {
2261 const RGBQUAD *color_table = get_dib_color_table( src );
2262 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2263 for(y = src_rect->top; y < src_rect->bottom; y++)
2264 {
2265 int pos = (src->rect.left + src_rect->left) & 1;
2266 src_pixel = src_start;
2267 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2268 {
2269 RGBQUAD rgb;
2270 if (pos & 1)
2271 rgb = color_table[*src_pixel++ & 0xf];
2272 else
2273 rgb = color_table[*src_pixel >> 4];
2274 dst_start[x] = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2275 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2276 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2277 }
2278 if(pad_size) memset(dst_start + x, 0, pad_size);
2279 dst_start += dst->stride / 4;
2280 src_start += src->stride;
2281 }
2282 break;
2283 }
2284
2285 case 1:
2286 {
2287 const RGBQUAD *color_table = get_dib_color_table( src );
2288 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
2289 for(y = src_rect->top; y < src_rect->bottom; y++)
2290 {
2291 int pos = (src->rect.left + src_rect->left) & 7;
2292 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2293 {
2294 RGBQUAD rgb;
2295 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
2296 rgb = color_table[src_val];
2297 dst_start[x] = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2298 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2299 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2300 }
2301 if(pad_size) memset(dst_start + x, 0, pad_size);
2302 dst_start += dst->stride / 4;
2303 src_start += src->stride;
2304 }
2305 break;
2306 }
2307 }
2308 }
2309
2310 static void convert_to_24(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
2311 {
2312 BYTE *dst_start = get_pixel_ptr_24(dst, 0, 0), *dst_pixel;
2313 DWORD src_val;
2314 int x, y, pad_size = ((dst->width * 3 + 3) & ~3) - (src_rect->right - src_rect->left) * 3;
2315
2316 switch(src->bit_count)
2317 {
2318 case 32:
2319 {
2320 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2321 if(src->funcs == &funcs_8888)
2322 {
2323 for(y = src_rect->top; y < src_rect->bottom; y++)
2324 {
2325 dst_pixel = dst_start;
2326 src_pixel = src_start;
2327 for(x = src_rect->left; x < src_rect->right; x++)
2328 {
2329 src_val = *src_pixel++;
2330 *dst_pixel++ = src_val & 0xff;
2331 *dst_pixel++ = (src_val >> 8) & 0xff;
2332 *dst_pixel++ = (src_val >> 16) & 0xff;
2333 }
2334 if(pad_size) memset(dst_pixel, 0, pad_size);
2335 dst_start += dst->stride;
2336 src_start += src->stride / 4;
2337 }
2338 }
2339 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2340 {
2341 for(y = src_rect->top; y < src_rect->bottom; y++)
2342 {
2343 dst_pixel = dst_start;
2344 src_pixel = src_start;
2345 for(x = src_rect->left; x < src_rect->right; x++)
2346 {
2347 src_val = *src_pixel++;
2348 *dst_pixel++ = (src_val >> src->blue_shift) & 0xff;
2349 *dst_pixel++ = (src_val >> src->green_shift) & 0xff;
2350 *dst_pixel++ = (src_val >> src->red_shift) & 0xff;
2351 }
2352 if(pad_size) memset(dst_pixel, 0, pad_size);
2353 dst_start += dst->stride;
2354 src_start += src->stride / 4;
2355 }
2356 }
2357 else
2358 {
2359 for(y = src_rect->top; y < src_rect->bottom; y++)
2360 {
2361 dst_pixel = dst_start;
2362 src_pixel = src_start;
2363 for(x = src_rect->left; x < src_rect->right; x++)
2364 {
2365 src_val = *src_pixel++;
2366 *dst_pixel++ = get_field( src_val, src->blue_shift, src->blue_len );
2367 *dst_pixel++ = get_field( src_val, src->green_shift, src->green_len );
2368 *dst_pixel++ = get_field( src_val, src->red_shift, src->red_len );
2369 }
2370 if(pad_size) memset(dst_pixel, 0, pad_size);
2371 dst_start += dst->stride;
2372 src_start += src->stride / 4;
2373 }
2374 }
2375 break;
2376 }
2377
2378 case 24:
2379 {
2380 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top);
2381
2382 if (src->stride > 0 && src->stride == dst->stride && !pad_size)
2383 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2384 else
2385 {
2386 for(y = src_rect->top; y < src_rect->bottom; y++)
2387 {
2388 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 3);
2389 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left) * 3, 0, pad_size);
2390 dst_start += dst->stride;
2391 src_start += src->stride;
2392 }
2393 }
2394 break;
2395 }
2396
2397 case 16:
2398 {
2399 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2400 if(src->funcs == &funcs_555)
2401 {
2402 for(y = src_rect->top; y < src_rect->bottom; y++)
2403 {
2404 dst_pixel = dst_start;
2405 src_pixel = src_start;
2406 for(x = src_rect->left; x < src_rect->right; x++)
2407 {
2408 src_val = *src_pixel++;
2409 *dst_pixel++ = ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07);
2410 *dst_pixel++ = ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07);
2411 *dst_pixel++ = ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07);
2412 }
2413 if(pad_size) memset(dst_pixel, 0, pad_size);
2414 dst_start += dst->stride;
2415 src_start += src->stride / 2;
2416 }
2417 }
2418 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2419 {
2420 for(y = src_rect->top; y < src_rect->bottom; y++)
2421 {
2422 dst_pixel = dst_start;
2423 src_pixel = src_start;
2424 for(x = src_rect->left; x < src_rect->right; x++)
2425 {
2426 src_val = *src_pixel++;
2427 *dst_pixel++ = (((src_val >> src->blue_shift) << 3) & 0xf8) |
2428 (((src_val >> src->blue_shift) >> 2) & 0x07);
2429 *dst_pixel++ = (((src_val >> src->green_shift) << 3) & 0xf8) |
2430 (((src_val >> src->green_shift) >> 2) & 0x07);
2431 *dst_pixel++ = (((src_val >> src->red_shift) << 3) & 0xf8) |
2432 (((src_val >> src->red_shift) >> 2) & 0x07);
2433 }
2434 if(pad_size) memset(dst_pixel, 0, pad_size);
2435 dst_start += dst->stride;
2436 src_start += src->stride / 2;
2437 }
2438 }
2439 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2440 {
2441 for(y = src_rect->top; y < src_rect->bottom; y++)
2442 {
2443 dst_pixel = dst_start;
2444 src_pixel = src_start;
2445 for(x = src_rect->left; x < src_rect->right; x++)
2446 {
2447 src_val = *src_pixel++;
2448 *dst_pixel++ = (((src_val >> src->blue_shift) << 3) & 0xf8) |
2449 (((src_val >> src->blue_shift) >> 2) & 0x07);
2450 *dst_pixel++ = (((src_val >> src->green_shift) << 2) & 0xfc) |
2451 (((src_val >> src->green_shift) >> 4) & 0x03);
2452 *dst_pixel++ = (((src_val >> src->red_shift) << 3) & 0xf8) |
2453 (((src_val >> src->red_shift) >> 2) & 0x07);
2454 }
2455 if(pad_size) memset(dst_pixel, 0, pad_size);
2456 dst_start += dst->stride;
2457 src_start += src->stride / 2;
2458 }
2459 }
2460 else
2461 {
2462 for(y = src_rect->top; y < src_rect->bottom; y++)
2463 {
2464 dst_pixel = dst_start;
2465 src_pixel = src_start;
2466 for(x = src_rect->left; x < src_rect->right; x++)
2467 {
2468 src_val = *src_pixel++;
2469 *dst_pixel++ = get_field(src_val, src->blue_shift, src->blue_len );
2470 *dst_pixel++ = get_field(src_val, src->green_shift, src->green_len );
2471 *dst_pixel++ = get_field(src_val, src->red_shift, src->red_len );
2472 }
2473 if(pad_size) memset(dst_pixel, 0, pad_size);
2474 dst_start += dst->stride;
2475 src_start += src->stride / 2;
2476 }
2477 }
2478 break;
2479 }
2480
2481 case 8:
2482 {
2483 const RGBQUAD *color_table = get_dib_color_table( src );
2484 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2485 for(y = src_rect->top; y < src_rect->bottom; y++)
2486 {
2487 dst_pixel = dst_start;
2488 src_pixel = src_start;
2489 for(x = src_rect->left; x < src_rect->right; x++)
2490 {
2491 RGBQUAD rgb = color_table[*src_pixel++];
2492 *dst_pixel++ = rgb.rgbBlue;
2493 *dst_pixel++ = rgb.rgbGreen;
2494 *dst_pixel++ = rgb.rgbRed;
2495 }
2496 if(pad_size) memset(dst_pixel, 0, pad_size);
2497 dst_start += dst->stride;
2498 src_start += src->stride;
2499 }
2500 break;
2501 }
2502
2503 case 4:
2504 {
2505 const RGBQUAD *color_table = get_dib_color_table( src );
2506 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2507 for(y = src_rect->top; y < src_rect->bottom; y++)
2508 {
2509 int pos = (src->rect.left + src_rect->left) & 1;
2510 src_pixel = src_start;
2511 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2512 {
2513 RGBQUAD rgb;
2514 if (pos & 1)
2515 rgb = color_table[*src_pixel++ & 0xf];
2516 else
2517 rgb = color_table[*src_pixel >> 4];
2518 dst_start[x * 3] = rgb.rgbBlue;
2519 dst_start[x * 3 + 1] = rgb.rgbGreen;
2520 dst_start[x * 3 + 2] = rgb.rgbRed;
2521 }
2522 if(pad_size) memset(dst_start + x * 3, 0, pad_size);
2523 dst_start += dst->stride;
2524 src_start += src->stride;
2525 }
2526 break;
2527 }
2528
2529 case 1:
2530 {
2531 const RGBQUAD *color_table = get_dib_color_table( src );
2532 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
2533 for(y = src_rect->top; y < src_rect->bottom; y++)
2534 {
2535 int pos = (src->rect.left + src_rect->left) & 7;
2536 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2537 {
2538 RGBQUAD rgb;
2539 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
2540 rgb = color_table[src_val];
2541 dst_start[x * 3] = rgb.rgbBlue;
2542 dst_start[x * 3 + 1] = rgb.rgbGreen;
2543 dst_start[x * 3 + 2] = rgb.rgbRed;
2544 }
2545 if(pad_size) memset(dst_start + x * 3, 0, pad_size);
2546 dst_start += dst->stride;
2547 src_start += src->stride;
2548 }
2549 break;
2550 }
2551 }
2552 }
2553
2554 static void convert_to_555(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
2555 {
2556 WORD *dst_start = get_pixel_ptr_16(dst, 0, 0), *dst_pixel;
2557 INT x, y, pad_size = ((dst->width + 1) & ~1) * 2 - (src_rect->right - src_rect->left) * 2;
2558 DWORD src_val;
2559
2560 switch(src->bit_count)
2561 {
2562 case 32:
2563 {
2564 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2565
2566 if(src->funcs == &funcs_8888)
2567 {
2568 for(y = src_rect->top; y < src_rect->bottom; y++)
2569 {
2570 dst_pixel = dst_start;
2571 src_pixel = src_start;
2572 for(x = src_rect->left; x < src_rect->right; x++)
2573 {
2574 src_val = *src_pixel++;
2575 *dst_pixel++ = ((src_val >> 9) & 0x7c00) |
2576 ((src_val >> 6) & 0x03e0) |
2577 ((src_val >> 3) & 0x001f);
2578 }
2579 if(pad_size) memset(dst_pixel, 0, pad_size);
2580 dst_start += dst->stride / 2;
2581 src_start += src->stride / 4;
2582 }
2583 }
2584 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2585 {
2586 for(y = src_rect->top; y < src_rect->bottom; y++)
2587 {
2588 dst_pixel = dst_start;
2589 src_pixel = src_start;
2590 for(x = src_rect->left; x < src_rect->right; x++)
2591 {
2592 src_val = *src_pixel++;
2593 *dst_pixel++ = (((src_val >> src->red_shift) << 7) & 0x7c00) |
2594 (((src_val >> src->green_shift) << 2) & 0x03e0) |
2595 (((src_val >> src->blue_shift) >> 3) & 0x001f);
2596 }
2597 if(pad_size) memset(dst_pixel, 0, pad_size);
2598 dst_start += dst->stride / 2;
2599 src_start += src->stride / 4;
2600 }
2601 }
2602 else
2603 {
2604 for(y = src_rect->top; y < src_rect->bottom; y++)
2605 {
2606 dst_pixel = dst_start;
2607 src_pixel = src_start;
2608 for(x = src_rect->left; x < src_rect->right; x++)
2609 {
2610 src_val = *src_pixel++;
2611 *dst_pixel++ = (((get_field(src_val, src->red_shift, src->red_len ) << 7) & 0x7c00) |
2612 ((get_field(src_val, src->green_shift, src->green_len ) << 2) & 0x03e0) |
2613 ( get_field(src_val, src->blue_shift, src->blue_len ) >> 3));
2614 }
2615 if(pad_size) memset(dst_pixel, 0, pad_size);
2616 dst_start += dst->stride / 2;
2617 src_start += src->stride / 4;
2618 }
2619 }
2620 break;
2621 }
2622
2623 case 24:
2624 {
2625 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2626
2627 for(y = src_rect->top; y < src_rect->bottom; y++)
2628 {
2629 dst_pixel = dst_start;
2630 src_pixel = src_start;
2631 for(x = src_rect->left; x < src_rect->right; x++)
2632 {
2633 RGBQUAD rgb;
2634 rgb.rgbBlue = *src_pixel++;
2635 rgb.rgbGreen = *src_pixel++;
2636 rgb.rgbRed = *src_pixel++;
2637
2638 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2639 ((rgb.rgbGreen << 2) & 0x03e0) |
2640 ((rgb.rgbBlue >> 3) & 0x001f);
2641 }
2642 if(pad_size) memset(dst_pixel, 0, pad_size);
2643 dst_start += dst->stride / 2;
2644 src_start += src->stride;
2645 }
2646 break;
2647 }
2648
2649 case 16:
2650 {
2651 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2652 if(src->funcs == &funcs_555)
2653 {
2654 if (src->stride > 0 && src->stride == dst->stride && !pad_size)
2655 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2656 else
2657 {
2658 for(y = src_rect->top; y < src_rect->bottom; y++)
2659 {
2660 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 2);
2661 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2662 dst_start += dst->stride / 2;
2663 src_start += src->stride / 2;
2664 }
2665 }
2666 }
2667 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2668 {
2669 for(y = src_rect->top; y < src_rect->bottom; y++)
2670 {
2671 dst_pixel = dst_start;
2672 src_pixel = src_start;
2673 for(x = src_rect->left; x < src_rect->right; x++)
2674 {
2675 src_val = *src_pixel++;
2676 *dst_pixel++ = (((src_val >> src->red_shift) << 10) & 0x7c00) |
2677 (((src_val >> src->green_shift) << 5) & 0x03e0) |
2678 ( (src_val >> src->blue_shift) & 0x001f);
2679 }
2680 if(pad_size) memset(dst_pixel, 0, pad_size);
2681 dst_start += dst->stride / 2;
2682 src_start += src->stride / 2;
2683 }
2684 }
2685 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2686 {
2687 for(y = src_rect->top; y < src_rect->bottom; y++)
2688 {
2689 dst_pixel = dst_start;
2690 src_pixel = src_start;
2691 for(x = src_rect->left; x < src_rect->right; x++)
2692 {
2693 src_val = *src_pixel++;
2694 *dst_pixel++ = (((src_val >> src->red_shift) << 10) & 0x7c00) |
2695 (((src_val >> src->green_shift) << 4) & 0x03e0) |
2696 ( (src_val >> src->blue_shift) & 0x001f);
2697 }
2698 if(pad_size) memset(dst_pixel, 0, pad_size);
2699 dst_start += dst->stride / 2;
2700 src_start += src->stride / 2;
2701 }
2702 }
2703 else
2704 {
2705 for(y = src_rect->top; y < src_rect->bottom; y++)
2706 {
2707 dst_pixel = dst_start;
2708 src_pixel = src_start;
2709 for(x = src_rect->left; x < src_rect->right; x++)
2710 {
2711 src_val = *src_pixel++;
2712 *dst_pixel++ = (((get_field(src_val, src->red_shift, src->red_len) << 7) & 0x7c00) |
2713 ((get_field(src_val, src->green_shift, src->green_len) << 2) & 0x03e0) |
2714 ( get_field(src_val, src->blue_shift, src->blue_len) >> 3));
2715 }
2716 if(pad_size) memset(dst_pixel, 0, pad_size);
2717 dst_start += dst->stride / 2;
2718 src_start += src->stride / 2;
2719 }
2720 }
2721 break;
2722 }
2723
2724 case 8:
2725 {
2726 const RGBQUAD *color_table = get_dib_color_table( src );
2727 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2728 for(y = src_rect->top; y < src_rect->bottom; y++)
2729 {
2730 dst_pixel = dst_start;
2731 src_pixel = src_start;
2732 for(x = src_rect->left; x < src_rect->right; x++)
2733 {
2734 RGBQUAD rgb = color_table[*src_pixel++];
2735 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2736 ((rgb.rgbGreen << 2) & 0x03e0) |
2737 ((rgb.rgbBlue >> 3) & 0x001f);
2738 }
2739 if(pad_size) memset(dst_pixel, 0, pad_size);
2740 dst_start += dst->stride / 2;
2741 src_start += src->stride;
2742 }
2743 break;
2744 }
2745
2746 case 4:
2747 {
2748 const RGBQUAD *color_table = get_dib_color_table( src );
2749 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2750 for(y = src_rect->top; y < src_rect->bottom; y++)
2751 {
2752 int pos = (src->rect.left + src_rect->left) & 1;
2753 src_pixel = src_start;
2754 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2755 {
2756 RGBQUAD rgb;
2757 if (pos & 1)
2758 rgb = color_table[*src_pixel++ & 0xf];
2759 else
2760 rgb = color_table[*src_pixel >> 4];
2761 dst_start[x] = ((rgb.rgbRed << 7) & 0x7c00) |
2762 ((rgb.rgbGreen << 2) & 0x03e0) |
2763 ((rgb.rgbBlue >> 3) & 0x001f);
2764 }
2765 if(pad_size) memset(dst_start + x, 0, pad_size);
2766 dst_start += dst->stride / 2;
2767 src_start += src->stride;
2768 }
2769 break;
2770 }
2771
2772 case 1:
2773 {
2774 const RGBQUAD *color_table = get_dib_color_table( src );
2775 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
2776 for(y = src_rect->top; y < src_rect->bottom; y++)
2777 {
2778 int pos = (src->rect.left + src_rect->left) & 7;
2779 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
2780 {
2781 RGBQUAD rgb;
2782 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
2783 rgb = color_table[src_val];
2784 dst_start[x] = ((rgb.rgbRed << 7) & 0x7c00) |
2785 ((rgb.rgbGreen << 2) & 0x03e0) |
2786 ((rgb.rgbBlue >> 3) & 0x001f);
2787 }
2788 if(pad_size) memset(dst_start + x, 0, pad_size);
2789 dst_start += dst->stride / 2;
2790 src_start += src->stride;
2791 }
2792 break;
2793 }
2794 }
2795 }
2796
2797 static void convert_to_16(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
2798 {
2799 WORD *dst_start = get_pixel_ptr_16(dst, 0, 0), *dst_pixel;
2800 INT x, y, pad_size = ((dst->width + 1) & ~1) * 2 - (src_rect->right - src_rect->left) * 2;
2801 DWORD src_val;
2802
2803 switch(src->bit_count)
2804 {
2805 case 32:
2806 {
2807 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2808
2809 if(src->funcs == &funcs_8888)
2810 {
2811 for(y = src_rect->top; y < src_rect->bottom; y++)
2812 {
2813 dst_pixel = dst_start;
2814 src_pixel = src_start;
2815 for(x = src_rect->left; x < src_rect->right; x++)
2816 {
2817 src_val = *src_pixel++;
2818 *dst_pixel++ = put_field(src_val >> 16, dst->red_shift, dst->red_len) |
2819 put_field(src_val >> 8, dst->green_shift, dst->green_len) |
2820 put_field(src_val, dst->blue_shift, dst->blue_len);
2821 }
2822 if(pad_size) memset(dst_pixel, 0, pad_size);
2823 dst_start += dst->stride / 2;
2824 src_start += src->stride / 4;
2825 }
2826 }
2827 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2828 {
2829 for(y = src_rect->top; y < src_rect->bottom; y++)
2830 {
2831 dst_pixel = dst_start;
2832 src_pixel = src_start;
2833 for(x = src_rect->left; x < src_rect->right; x++)
2834 {
2835 src_val = *src_pixel++;
2836 *dst_pixel++ = put_field(src_val >> src->red_shift, dst->red_shift, dst->red_len) |
2837 put_field(src_val >> src->green_shift, dst->green_shift, dst->green_len) |
2838 put_field(src_val >> src->blue_shift, dst->blue_shift, dst->blue_len);
2839 }
2840 if(pad_size) memset(dst_pixel, 0, pad_size);
2841 dst_start += dst->stride / 2;
2842 src_start += src->stride / 4;
2843 }
2844 }
2845 else
2846 {
2847 for(y = src_rect->top; y < src_rect->bottom; y++)
2848 {
2849 dst_pixel = dst_start;
2850 src_pixel = src_start;
2851 for(x = src_rect->left; x < src_rect->right; x++)
2852 {
2853 src_val = *src_pixel++;
2854 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2855 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2856 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2857 }
2858 if(pad_size) memset(dst_pixel, 0, pad_size);
2859 dst_start += dst->stride / 2;
2860 src_start += src->stride / 4;
2861 }
2862 }
2863 break;
2864 }
2865
2866 case 24:
2867 {
2868 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2869
2870 for(y = src_rect->top; y < src_rect->bottom; y++)
2871 {
2872 dst_pixel = dst_start;
2873 src_pixel = src_start;
2874 for(x = src_rect->left; x < src_rect->right; x++)
2875 {
2876 RGBQUAD rgb;
2877 rgb.rgbBlue = *src_pixel++;
2878 rgb.rgbGreen = *src_pixel++;
2879 rgb.rgbRed = *src_pixel++;
2880
2881 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2882 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2883 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2884 }
2885 if(pad_size) memset(dst_pixel, 0, pad_size);
2886 dst_start += dst->stride / 2;
2887 src_start += src->stride;
2888 }
2889 break;
2890 }
2891
2892 case 16:
2893 {
2894 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2895 if(src->funcs == &funcs_555)
2896 {
2897 for(y = src_rect->top; y < src_rect->bottom; y++)
2898 {
2899 dst_pixel = dst_start;
2900 src_pixel = src_start;
2901 for(x = src_rect->left; x < src_rect->right; x++)
2902 {
2903 src_val = *src_pixel++;
2904 *dst_pixel++ = put_field(((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07), dst->red_shift, dst->red_len) |
2905 put_field(((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07), dst->green_shift, dst->green_len) |
2906 put_field(((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2907 }
2908 if(pad_size) memset(dst_pixel, 0, pad_size);
2909 dst_start += dst->stride / 2;
2910 src_start += src->stride / 2;
2911 }
2912 }
2913 else if(bit_fields_match(src, dst))
2914 {
2915 if (src->stride > 0 && src->stride == dst->stride && !pad_size)
2916 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2917 else
2918 {
2919 for(y = src_rect->top; y < src_rect->bottom; y++)
2920 {
2921 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 2);
2922 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2923 dst_start += dst->stride / 2;
2924 src_start += src->stride / 2;
2925 }
2926 }
2927 }
2928 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2929 {
2930 for(y = src_rect->top; y < src_rect->bottom; y++)
2931 {
2932 dst_pixel = dst_start;
2933 src_pixel = src_start;
2934 for(x = src_rect->left; x < src_rect->right; x++)
2935 {
2936 src_val = *src_pixel++;
2937 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2938 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2939 put_field( (((src_val >> src->green_shift) << 3) & 0xf8) |
2940 (((src_val >> src->green_shift) >> 2) & 0x07), dst->green_shift, dst->green_len ) |
2941 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2942 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2943 }
2944 if(pad_size) memset(dst_pixel, 0, pad_size);
2945 dst_start += dst->stride / 2;
2946 src_start += src->stride / 2;
2947 }
2948 }
2949 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2950 {
2951 for(y = src_rect->top; y < src_rect->bottom; y++)
2952 {
2953 dst_pixel = dst_start;
2954 src_pixel = src_start;
2955 for(x = src_rect->left; x < src_rect->right; x++)
2956 {
2957 src_val = *src_pixel++;
2958 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2959 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2960 put_field( (((src_val >> src->green_shift) << 2) & 0xfc) |
2961 (((src_val >> src->green_shift) >> 4) & 0x03), dst->green_shift, dst->green_len ) |
2962 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2963 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2964 }
2965 if(pad_size) memset(dst_pixel, 0, pad_size);
2966 dst_start += dst->stride / 2;
2967 src_start += src->stride / 2;
2968 }
2969 }
2970 else
2971 {
2972 for(y = src_rect->top; y < src_rect->bottom; y++)
2973 {
2974 dst_pixel = dst_start;
2975 src_pixel = src_start;
2976 for(x = src_rect->left; x < src_rect->right; x++)
2977 {
2978 src_val = *src_pixel++;
2979 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2980 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2981 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2982 }
2983 if(pad_size) memset(dst_pixel, 0, pad_size);
2984 dst_start += dst->stride / 2;
2985 src_start += src->stride / 2;
2986 }
2987 }
2988 break;
2989 }
2990
2991 case 8:
2992 {
2993 const RGBQUAD *color_table = get_dib_color_table( src );
2994 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2995 for(y = src_rect->top; y < src_rect->bottom; y++)
2996 {
2997 dst_pixel = dst_start;
2998 src_pixel = src_start;
2999 for(x = src_rect->left; x < src_rect->right; x++)
3000 {
3001 RGBQUAD rgb = color_table[*src_pixel++];
3002 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
3003 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
3004 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
3005 }
3006 if(pad_size) memset(dst_pixel, 0, pad_size);
3007 dst_start += dst->stride / 2;
3008 src_start += src->stride;
3009 }
3010 break;
3011 }
3012
3013 case 4:
3014 {
3015 const RGBQUAD *color_table = get_dib_color_table( src );
3016 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
3017 for(y = src_rect->top; y < src_rect->bottom; y++)
3018 {
3019 int pos = (src->rect.left + src_rect->left) & 1;
3020 src_pixel = src_start;
3021 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
3022 {
3023 RGBQUAD rgb;
3024 if (pos & 1)
3025 rgb = color_table[*src_pixel++ & 0xf];
3026 else
3027 rgb = color_table[*src_pixel >> 4];
3028 dst_start[x] = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
3029 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
3030 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
3031 }
3032 if(pad_size) memset(dst_start + x, 0, pad_size);
3033 dst_start += dst->stride / 2;
3034 src_start += src->stride;
3035 }
3036 break;
3037 }
3038
3039 case 1:
3040 {
3041 const RGBQUAD *color_table = get_dib_color_table( src );
3042 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
3043 for(y = src_rect->top; y < src_rect->bottom; y++)
3044 {
3045 int pos = (src->rect.left + src_rect->left) & 7;
3046 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
3047 {
3048 RGBQUAD rgb;
3049 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
3050 rgb = color_table[src_val];
3051 dst_start[x] = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
3052 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
3053 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
3054 }
3055 if(pad_size) memset(dst_start + x, 0, pad_size);
3056 dst_start += dst->stride / 2;
3057 src_start += src->stride;
3058 }
3059 break;
3060 }
3061 }
3062 }
3063
3064 static inline BOOL color_tables_match(const dib_info *d1, const dib_info *d2)
3065 {
3066 if (!d1->color_table || !d2->color_table) return (!d1->color_table && !d2->color_table);
3067 return !memcmp(d1->color_table, d2->color_table, (1 << d1->bit_count) * sizeof(d1->color_table[0]));
3068 }
3069
3070 static inline DWORD rgb_lookup_colortable(const dib_info *dst, BYTE r, BYTE g, BYTE b)
3071 {
3072 /* Windows reduces precision to 5 bits, probably in order to build some sort of lookup cache */
3073 return rgb_to_pixel_colortable( dst, (r & ~7) + 4, (g & ~7) + 4, (b & ~7) + 4 );
3074 }
3075
3076 static void convert_to_8(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
3077 {
3078 BYTE *dst_start = get_pixel_ptr_8(dst, 0, 0), *dst_pixel;
3079 INT x, y, pad_size = ((dst->width + 3) & ~3) - (src_rect->right - src_rect->left);
3080 DWORD src_val;
3081
3082 switch(src->bit_count)
3083 {
3084 case 32:
3085 {
3086 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
3087
3088 if(src->funcs == &funcs_8888)
3089 {
3090 for(y = src_rect->top; y < src_rect->bottom; y++)
3091 {
3092 dst_pixel = dst_start;
3093 src_pixel = src_start;
3094 for(x = src_rect->left; x < src_rect->right; x++)
3095 {
3096 src_val = *src_pixel++;
3097 *dst_pixel++ = rgb_lookup_colortable(dst, src_val >> 16, src_val >> 8, src_val );
3098 }
3099 if(pad_size) memset(dst_pixel, 0, pad_size);
3100 dst_start += dst->stride;
3101 src_start += src->stride / 4;
3102 }
3103 }
3104 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
3105 {
3106 for(y = src_rect->top; y < src_rect->bottom; y++)
3107 {
3108 dst_pixel = dst_start;
3109 src_pixel = src_start;
3110 for(x = src_rect->left; x < src_rect->right; x++)
3111 {
3112 src_val = *src_pixel++;
3113 *dst_pixel++ = rgb_lookup_colortable(dst,
3114 src_val >> src->red_shift,
3115 src_val >> src->green_shift,
3116 src_val >> src->blue_shift );
3117 }
3118 if(pad_size) memset(dst_pixel, 0, pad_size);
3119 dst_start += dst->stride;
3120 src_start += src->stride / 4;
3121 }
3122 }
3123 else
3124 {
3125 for(y = src_rect->top; y < src_rect->bottom; y++)
3126 {
3127 dst_pixel = dst_start;
3128 src_pixel = src_start;
3129 for(x = src_rect->left; x < src_rect->right; x++)
3130 {
3131 src_val = *src_pixel++;
3132 *dst_pixel++ = rgb_lookup_colortable(dst,
3133 get_field(src_val, src->red_shift, src->red_len),
3134 get_field(src_val, src->green_shift, src->green_len),
3135 get_field(src_val, src->blue_shift, src->blue_len));
3136 }
3137 if(pad_size) memset(dst_pixel, 0, pad_size);
3138 dst_start += dst->stride;
3139 src_start += src->stride / 4;
3140 }
3141 }
3142 break;
3143 }
3144
3145 case 24:
3146 {
3147 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
3148
3149 for(y = src_rect->top; y < src_rect->bottom; y++)
3150 {
3151 dst_pixel = dst_start;
3152 src_pixel = src_start;
3153 for(x = src_rect->left; x < src_rect->right; x++, src_pixel += 3)
3154 {
3155 *dst_pixel++ = rgb_lookup_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0] );
3156 }
3157 if(pad_size) memset(dst_pixel, 0, pad_size);
3158 dst_start += dst->stride;
3159 src_start += src->stride;
3160 }
3161 break;
3162 }
3163
3164 case 16:
3165 {
3166 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
3167 if(src->funcs == &funcs_555)
3168 {
3169 for(y = src_rect->top; y < src_rect->bottom; y++)
3170 {
3171 dst_pixel = dst_start;
3172 src_pixel = src_start;
3173 for(x = src_rect->left; x < src_rect->right; x++)
3174 {
3175 src_val = *src_pixel++;
3176 *dst_pixel++ = rgb_lookup_colortable(dst,
3177 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
3178 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
3179 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) );
3180 }
3181 if(pad_size) memset(dst_pixel, 0, pad_size);
3182 dst_start += dst->stride;
3183 src_start += src->stride / 2;
3184 }
3185 }
3186 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
3187 {
3188 for(y = src_rect->top; y < src_rect->bottom; y++)
3189 {
3190 dst_pixel = dst_start;
3191 src_pixel = src_start;
3192 for(x = src_rect->left; x < src_rect->right; x++)
3193 {
3194 src_val = *src_pixel++;
3195 *dst_pixel++ = rgb_lookup_colortable(dst,
3196 (((src_val >> src->red_shift) << 3) & 0xf8) |
3197 (((src_val >> src->red_shift) >> 2) & 0x07),
3198 (((src_val >> src->green_shift) << 3) & 0xf8) |
3199 (((src_val >> src->green_shift) >> 2) & 0x07),
3200 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3201 (((src_val >> src->blue_shift) >> 2) & 0x07) );
3202 }
3203 if(pad_size) memset(dst_pixel, 0, pad_size);
3204 dst_start += dst->stride;
3205 src_start += src->stride / 2;
3206 }
3207 }
3208 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
3209 {
3210 for(y = src_rect->top; y < src_rect->bottom; y++)
3211 {
3212 dst_pixel = dst_start;
3213 src_pixel = src_start;
3214 for(x = src_rect->left; x < src_rect->right; x++)
3215 {
3216 src_val = *src_pixel++;
3217 *dst_pixel++ = rgb_lookup_colortable(dst,
3218 (((src_val >> src->red_shift) << 3) & 0xf8) |
3219 (((src_val >> src->red_shift) >> 2) & 0x07),
3220 (((src_val >> src->green_shift) << 2) & 0xfc) |
3221 (((src_val >> src->green_shift) >> 4) & 0x03),
3222 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3223 (((src_val >> src->blue_shift) >> 2) & 0x07) );
3224 }
3225 if(pad_size) memset(dst_pixel, 0, pad_size);
3226 dst_start += dst->stride;
3227 src_start += src->stride / 2;
3228 }
3229 }
3230 else
3231 {
3232 for(y = src_rect->top; y < src_rect->bottom; y++)
3233 {
3234 dst_pixel = dst_start;
3235 src_pixel = src_start;
3236 for(x = src_rect->left; x < src_rect->right; x++)
3237 {
3238 src_val = *src_pixel++;
3239 *dst_pixel++ = rgb_lookup_colortable(dst,
3240 get_field(src_val, src->red_shift, src->red_len),
3241 get_field(src_val, src->green_shift, src->green_len),
3242 get_field(src_val, src->blue_shift, src->blue_len));
3243 }
3244 if(pad_size) memset(dst_pixel, 0, pad_size);
3245 dst_start += dst->stride;
3246 src_start += src->stride / 2;
3247 }
3248 }
3249 break;
3250 }
3251
3252 case 8:
3253 {
3254 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
3255
3256 if(color_tables_match(dst, src))
3257 {
3258 if (src->stride > 0 && src->stride == dst->stride && !pad_size)
3259 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
3260 else
3261 {
3262 for(y = src_rect->top; y < src_rect->bottom; y++)
3263 {
3264 memcpy(dst_start, src_start, src_rect->right - src_rect->left);
3265 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
3266 dst_start += dst->stride;
3267 src_start += src->stride;
3268 }
3269 }
3270 }
3271 else
3272 {
3273 const RGBQUAD *color_table = get_dib_color_table( src );
3274 for(y = src_rect->top; y < src_rect->bottom; y++)
3275 {
3276 dst_pixel = dst_start;
3277 src_pixel = src_start;
3278 for(x = src_rect->left; x < src_rect->right; x++)
3279 {
3280 RGBQUAD rgb = color_table[*src_pixel++];
3281 *dst_pixel++ = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3282 }
3283 if(pad_size) memset(dst_pixel, 0, pad_size);
3284 dst_start += dst->stride;
3285 src_start += src->stride;
3286 }
3287 }
3288 break;
3289 }
3290
3291 case 4:
3292 {
3293 const RGBQUAD *color_table = get_dib_color_table( src );
3294 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
3295 for(y = src_rect->top; y < src_rect->bottom; y++)
3296 {
3297 int pos = (src->rect.left + src_rect->left) & 1;
3298 src_pixel = src_start;
3299 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
3300 {
3301 RGBQUAD rgb;
3302 if (pos & 1)
3303 rgb = color_table[*src_pixel++ & 0xf];
3304 else
3305 rgb = color_table[*src_pixel >> 4];
3306 dst_start[x] = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3307 }
3308 if(pad_size) memset(dst_start + x, 0, pad_size);
3309 dst_start += dst->stride;
3310 src_start += src->stride;
3311 }
3312 break;
3313 }
3314
3315 case 1:
3316 {
3317 const RGBQUAD *color_table = get_dib_color_table( src );
3318 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
3319 for(y = src_rect->top; y < src_rect->bottom; y++)
3320 {
3321 int pos = (src->rect.left + src_rect->left) & 7;
3322 for (x = 0; x < src_rect->right - src_rect->left; x++, pos++)
3323 {
3324 RGBQUAD rgb;
3325 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
3326 rgb = color_table[src_val];
3327 dst_start[x] = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3328 }
3329 if(pad_size) memset(dst_start + x, 0, pad_size);
3330 dst_start += dst->stride;
3331 src_start += src->stride;
3332 }
3333 break;
3334 }
3335 }
3336 }
3337
3338 static void convert_to_4(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
3339 {
3340 BYTE *dst_start = get_pixel_ptr_4(dst, 0, 0), *dst_pixel, dst_val;
3341 INT x, y, pad_size = ((dst->width + 7) & ~7) / 2 - (src_rect->right - src_rect->left + 1) / 2;
3342 DWORD src_val;
3343
3344 switch(src->bit_count)
3345 {
3346 case 32:
3347 {
3348 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
3349
3350 if(src->funcs == &funcs_8888)
3351 {
3352 for(y = src_rect->top; y < src_rect->bottom; y++)
3353 {
3354 dst_pixel = dst_start;
3355 src_pixel = src_start;
3356 for(x = src_rect->left; x < src_rect->right; x++)
3357 {
3358 src_val = *src_pixel++;
3359 dst_val = rgb_to_pixel_colortable(dst, src_val >> 16, src_val >> 8, src_val);
3360 if((x - src_rect->left) & 1)
3361 {
3362 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3363 dst_pixel++;
3364 }
3365 else
3366 *dst_pixel = (dst_val << 4) & 0xf0;
3367 }
3368 if(pad_size)
3369 {
3370 if((x - src_rect->left) & 1) dst_pixel++;
3371 memset(dst_pixel, 0, pad_size);
3372 }
3373 dst_start += dst->stride;
3374 src_start += src->stride / 4;
3375 }
3376 }
3377 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
3378 {
3379 for(y = src_rect->top; y < src_rect->bottom; y++)
3380 {
3381 dst_pixel = dst_start;
3382 src_pixel = src_start;
3383 for(x = src_rect->left; x < src_rect->right; x++)
3384 {
3385 src_val = *src_pixel++;
3386 dst_val = rgb_to_pixel_colortable(dst,
3387 src_val >> src->red_shift,
3388 src_val >> src->green_shift,
3389 src_val >> src->blue_shift);
3390 if((x - src_rect->left) & 1)
3391 {
3392 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3393 dst_pixel++;
3394 }
3395 else
3396 *dst_pixel = (dst_val << 4) & 0xf0;
3397 }
3398 if(pad_size)
3399 {
3400 if((x - src_rect->left) & 1) dst_pixel++;
3401 memset(dst_pixel, 0, pad_size);
3402 }
3403 dst_start += dst->stride;
3404 src_start += src->stride / 4;
3405 }
3406 }
3407 else
3408 {
3409 for(y = src_rect->top; y < src_rect->bottom; y++)
3410 {
3411 dst_pixel = dst_start;
3412 src_pixel = src_start;
3413 for(x = src_rect->left; x < src_rect->right; x++)
3414 {
3415 src_val = *src_pixel++;
3416 dst_val = rgb_to_pixel_colortable(dst,
3417 get_field(src_val, src->red_shift, src->red_len),
3418 get_field(src_val, src->green_shift, src->green_len),
3419 get_field(src_val, src->blue_shift, src->blue_len));
3420 if((x - src_rect->left) & 1)
3421 {
3422 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3423 dst_pixel++;
3424 }
3425 else
3426 *dst_pixel = (dst_val << 4) & 0xf0;
3427 }
3428 if(pad_size)
3429 {
3430 if((x - src_rect->left) & 1) dst_pixel++;
3431 memset(dst_pixel, 0, pad_size);
3432 }
3433 dst_start += dst->stride;
3434 src_start += src->stride / 4;
3435 }
3436 }
3437 break;
3438 }
3439
3440 case 24:
3441 {
3442 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
3443
3444 for(y = src_rect->top; y < src_rect->bottom; y++)
3445 {
3446 dst_pixel = dst_start;
3447 src_pixel = src_start;
3448 for(x = src_rect->left; x < src_rect->right; x++, src_pixel += 3)
3449 {
3450 dst_val = rgb_to_pixel_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0]);
3451
3452 if((x - src_rect->left) & 1)
3453 {
3454 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3455 dst_pixel++;
3456 }
3457 else
3458 *dst_pixel = (dst_val << 4) & 0xf0;
3459 }
3460 if(pad_size)
3461 {
3462 if((x - src_rect->left) & 1) dst_pixel++;
3463 memset(dst_pixel, 0, pad_size);
3464 }
3465 dst_start += dst->stride;
3466 src_start += src->stride;
3467 }
3468 break;
3469 }
3470
3471 case 16:
3472 {
3473 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
3474 if(src->funcs == &funcs_555)
3475 {
3476 for(y = src_rect->top; y < src_rect->bottom; y++)
3477 {
3478 dst_pixel = dst_start;
3479 src_pixel = src_start;
3480 for(x = src_rect->left; x < src_rect->right; x++)
3481 {
3482 src_val = *src_pixel++;
3483 dst_val = rgb_to_pixel_colortable(dst,
3484 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
3485 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
3486 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) );
3487 if((x - src_rect->left) & 1)
3488 {
3489 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3490 dst_pixel++;
3491 }
3492 else
3493 *dst_pixel = (dst_val << 4) & 0xf0;
3494 }
3495 if(pad_size)
3496 {
3497 if((x - src_rect->left) & 1) dst_pixel++;
3498 memset(dst_pixel, 0, pad_size);
3499 }
3500 dst_start += dst->stride;
3501 src_start += src->stride / 2;
3502 }
3503 }
3504 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
3505 {
3506 for(y = src_rect->top; y < src_rect->bottom; y++)
3507 {
3508 dst_pixel = dst_start;
3509 src_pixel = src_start;
3510 for(x = src_rect->left; x < src_rect->right; x++)
3511 {
3512 src_val = *src_pixel++;
3513 dst_val = rgb_to_pixel_colortable(dst,
3514 (((src_val >> src->red_shift) << 3) & 0xf8) |
3515 (((src_val >> src->red_shift) >> 2) & 0x07),
3516 (((src_val >> src->green_shift) << 3) & 0xf8) |
3517 (((src_val >> src->green_shift) >> 2) & 0x07),
3518 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3519 (((src_val >> src->blue_shift) >> 2) & 0x07) );
3520 if((x - src_rect->left) & 1)
3521 {
3522 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3523 dst_pixel++;
3524 }
3525 else
3526 *dst_pixel = (dst_val << 4) & 0xf0;
3527 }
3528 if(pad_size)
3529 {
3530 if((x - src_rect->left) & 1) dst_pixel++;
3531 memset(dst_pixel, 0, pad_size);
3532 }
3533 dst_start += dst->stride;
3534 src_start += src->stride / 2;
3535 }
3536 }
3537 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
3538 {
3539 for(y = src_rect->top; y < src_rect->bottom; y++)
3540 {
3541 dst_pixel = dst_start;
3542 src_pixel = src_start;
3543 for(x = src_rect->left; x < src_rect->right; x++)
3544 {
3545 src_val = *src_pixel++;
3546 dst_val = rgb_to_pixel_colortable(dst,
3547 (((src_val >> src->red_shift) << 3) & 0xf8) |
3548 (((src_val >> src->red_shift) >> 2) & 0x07),
3549 (((src_val >> src->green_shift) << 2) & 0xfc) |
3550 (((src_val >> src->green_shift) >> 4) & 0x03),
3551 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3552 (((src_val >> src->blue_shift) >> 2) & 0x07) );
3553 if((x - src_rect->left) & 1)
3554 {
3555 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3556 dst_pixel++;
3557 }
3558 else
3559 *dst_pixel = (dst_val << 4) & 0xf0;
3560 }
3561 if(pad_size)
3562 {
3563 if((x - src_rect->left) & 1) dst_pixel++;
3564 memset(dst_pixel, 0, pad_size);
3565 }
3566 dst_start += dst->stride;
3567 src_start += src->stride / 2;
3568 }
3569 }
3570 else
3571 {
3572 for(y = src_rect->top; y < src_rect->bottom; y++)
3573 {
3574 dst_pixel = dst_start;
3575 src_pixel = src_start;
3576 for(x = src_rect->left; x < src_rect->right; x++)
3577 {
3578 src_val = *src_pixel++;
3579 dst_val = rgb_to_pixel_colortable(dst,
3580 get_field(src_val, src->red_shift, src->red_len),
3581 get_field(src_val, src->green_shift, src->green_len),
3582 get_field(src_val, src->blue_shift, src->blue_len));
3583 if((x - src_rect->left) & 1)
3584 {
3585 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3586 dst_pixel++;
3587 }
3588 else
3589 *dst_pixel = (dst_val << 4) & 0xf0;
3590 }
3591 if(pad_size)
3592 {
3593 if((x - src_rect->left) & 1) dst_pixel++;
3594 memset(dst_pixel, 0, pad_size);
3595 }
3596 dst_start += dst->stride;
3597 src_start += src->stride / 2;
3598 }
3599 }
3600 break;
3601 }
3602
3603 case 8:
3604 {
3605 const RGBQUAD *color_table = get_dib_color_table( src );
3606 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
3607
3608 for(y = src_rect->top; y < src_rect->bottom; y++)
3609 {
3610 dst_pixel = dst_start;
3611 src_pixel = src_start;
3612 for(x = src_rect->left; x < src_rect->right; x++)
3613 {
3614 RGBQUAD rgb = color_table[*src_pixel++];
3615 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3616 if((x - src_rect->left) & 1)
3617 {
3618 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3619 dst_pixel++;
3620 }
3621 else
3622 *dst_pixel = (dst_val << 4) & 0xf0;
3623 }
3624 if(pad_size)
3625 {
3626 if((x - src_rect->left) & 1) dst_pixel++;
3627 memset(dst_pixel, 0, pad_size);
3628 }
3629 dst_start += dst->stride;
3630 src_start += src->stride;
3631 }
3632 break;
3633 }
3634
3635 case 4:
3636 {
3637 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
3638
3639 if(color_tables_match(dst, src) && ((src->rect.left + src_rect->left) & 1) == 0)
3640 {
3641 if (src->stride > 0 && src->stride == dst->stride && !pad_size)
3642 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
3643 else
3644 {
3645 for(y = src_rect->top; y < src_rect->bottom; y++)
3646 {
3647 memcpy(dst_start, src_start, (src_rect->right - src_rect->left + 1) / 2);
3648 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left + 1) / 2, 0, pad_size);
3649 dst_start += dst->stride;
3650 src_start += src->stride;
3651 }
3652 }
3653 }
3654 else
3655 {
3656 const RGBQUAD *color_table = get_dib_color_table( src );
3657 for(y = src_rect->top; y < src_rect->bottom; y++)
3658 {
3659 int pos = (src->rect.left + src_rect->left) & 1;
3660 dst_pixel = dst_start;
3661 src_pixel = src_start;
3662 for(x = src_rect->left; x < src_rect->right; x++, pos++)
3663 {
3664 RGBQUAD rgb;
3665 if(pos & 1)
3666 rgb = color_table[*src_pixel++ & 0xf];
3667 else
3668 rgb = color_table[*src_pixel >> 4];
3669 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3670 if((x - src_rect->left) & 1)
3671 {
3672 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3673 dst_pixel++;
3674 }
3675 else
3676 *dst_pixel = (dst_val << 4) & 0xf0;
3677 }
3678 if(pad_size)
3679 {
3680 if((x - src_rect->left) & 1) dst_pixel++;
3681 memset(dst_pixel, 0, pad_size);
3682 }
3683 dst_start += dst->stride;
3684 src_start += src->stride;
3685 }
3686 }
3687 break;
3688 }
3689
3690 case 1:
3691 {
3692 const RGBQUAD *color_table = get_dib_color_table( src );
3693 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
3694 for(y = src_rect->top; y < src_rect->bottom; y++)
3695 {
3696 int pos = (src->rect.left + src_rect->left) & 7;
3697 dst_pixel = dst_start;
3698 for(x = src_rect->left; x < src_rect->right; x++, pos++)
3699 {
3700 RGBQUAD rgb;
3701 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
3702 rgb = color_table[src_val];
3703 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3704 if((x - src_rect->left) & 1)
3705 {
3706 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3707 dst_pixel++;
3708 }
3709 else
3710 *dst_pixel = (dst_val << 4) & 0xf0;
3711 }
3712 if(pad_size)
3713 {
3714 if((x - src_rect->left) & 1) dst_pixel++;
3715 memset(dst_pixel, 0, pad_size);
3716 }
3717 dst_start += dst->stride;
3718 src_start += src->stride;
3719 }
3720 break;
3721 }
3722 }
3723 }
3724
3725 static void convert_to_1(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
3726 {
3727 BYTE *dst_start = get_pixel_ptr_1(dst, 0, 0), *dst_pixel, dst_val;
3728 INT x, y, pad_size = ((dst->width + 31) & ~31) / 8 - (src_rect->right - src_rect->left + 7) / 8;
3729 DWORD src_val;
3730 int bit_pos;
3731
3732 switch(src->bit_count)
3733 {
3734 case 32:
3735 {
3736 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
3737
3738 if(src->funcs == &funcs_8888)
3739 {
3740 for(y = src_rect->top; y < src_rect->bottom; y++)
3741 {
3742 dst_pixel = dst_start;
3743 src_pixel = src_start;
3744 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3745 {
3746 src_val = *src_pixel++;
3747 dst_val = rgb_to_pixel_mono(dst, dither, x, y, src_val >> 16, src_val >> 8, src_val);
3748
3749 if(bit_pos == 0) *dst_pixel = 0;
3750 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3751
3752 if(++bit_pos == 8)
3753 {
3754 dst_pixel++;
3755 bit_pos = 0;
3756 }
3757 }
3758 if(pad_size)
3759 {
3760 if(bit_pos != 0) dst_pixel++;
3761 memset(dst_pixel, 0, pad_size);
3762 }
3763 dst_start += dst->stride;
3764 src_start += src->stride / 4;
3765 }
3766 }
3767 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
3768 {
3769 for(y = src_rect->top; y < src_rect->bottom; y++)
3770 {
3771 dst_pixel = dst_start;
3772 src_pixel = src_start;
3773 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3774 {
3775 src_val = *src_pixel++;
3776 dst_val = rgb_to_pixel_mono(dst, dither, x, y,
3777 src_val >> src->red_shift,
3778 src_val >> src->green_shift,
3779 src_val >> src->blue_shift);
3780
3781 if(bit_pos == 0) *dst_pixel = 0;
3782 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3783
3784 if(++bit_pos == 8)
3785 {
3786 dst_pixel++;
3787 bit_pos = 0;
3788 }
3789 }
3790 if(pad_size)
3791 {
3792 if(bit_pos != 0) dst_pixel++;
3793 memset(dst_pixel, 0, pad_size);
3794 }
3795 dst_start += dst->stride;
3796 src_start += src->stride / 4;
3797 }
3798 }
3799 else
3800 {
3801 for(y = src_rect->top; y < src_rect->bottom; y++)
3802 {
3803 dst_pixel = dst_start;
3804 src_pixel = src_start;
3805 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3806 {
3807 src_val = *src_pixel++;
3808 dst_val = rgb_to_pixel_mono(dst, dither, x, y,
3809 get_field(src_val, src->red_shift, src->red_len),
3810 get_field(src_val, src->green_shift, src->green_len),
3811 get_field(src_val, src->blue_shift, src->blue_len));
3812
3813 if(bit_pos == 0) *dst_pixel = 0;
3814 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3815
3816 if(++bit_pos == 8)
3817 {
3818 dst_pixel++;
3819 bit_pos = 0;
3820 }
3821 }
3822 if(pad_size)
3823 {
3824 if(bit_pos != 0) dst_pixel++;
3825 memset(dst_pixel, 0, pad_size);
3826 }
3827 dst_start += dst->stride;
3828 src_start += src->stride / 4;
3829 }
3830 }
3831 break;
3832 }
3833
3834 case 24:
3835 {
3836 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
3837
3838 for(y = src_rect->top; y < src_rect->bottom; y++)
3839 {
3840 dst_pixel = dst_start;
3841 src_pixel = src_start;
3842 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++, src_pixel += 3)
3843 {
3844 dst_val = rgb_to_pixel_mono(dst, dither, x, y, src_pixel[2], src_pixel[1], src_pixel[0]);
3845
3846 if(bit_pos == 0) *dst_pixel = 0;
3847 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3848
3849 if(++bit_pos == 8)
3850 {
3851 dst_pixel++;
3852 bit_pos = 0;
3853 }
3854 }
3855 if(pad_size)
3856 {
3857 if(bit_pos != 0) dst_pixel++;
3858 memset(dst_pixel, 0, pad_size);
3859 }
3860 dst_start += dst->stride;
3861 src_start += src->stride;
3862 }
3863 break;
3864 }
3865
3866 case 16:
3867 {
3868 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
3869 if(src->funcs == &funcs_555)
3870 {
3871 for(y = src_rect->top; y < src_rect->bottom; y++)
3872 {
3873 dst_pixel = dst_start;
3874 src_pixel = src_start;
3875 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3876 {
3877 src_val = *src_pixel++;
3878 dst_val = rgb_to_pixel_mono(dst, dither, x, y,
3879 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
3880 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
3881 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07));
3882
3883 if(bit_pos == 0) *dst_pixel = 0;
3884 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3885
3886 if(++bit_pos == 8)
3887 {
3888 dst_pixel++;
3889 bit_pos = 0;
3890 }
3891 }
3892 if(pad_size)
3893 {
3894 if(bit_pos != 0) dst_pixel++;
3895 memset(dst_pixel, 0, pad_size);
3896 }
3897 dst_start += dst->stride;
3898 src_start += src->stride / 2;
3899 }
3900 }
3901 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
3902 {
3903 for(y = src_rect->top; y < src_rect->bottom; y++)
3904 {
3905 dst_pixel = dst_start;
3906 src_pixel = src_start;
3907 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3908 {
3909 src_val = *src_pixel++;
3910 dst_val = rgb_to_pixel_mono(dst, dither, x, y,
3911 (((src_val >> src->red_shift) << 3) & 0xf8) |
3912 (((src_val >> src->red_shift) >> 2) & 0x07),
3913 (((src_val >> src->green_shift) << 3) & 0xf8) |
3914 (((src_val >> src->green_shift) >> 2) & 0x07),
3915 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3916 (((src_val >> src->blue_shift) >> 2) & 0x07));
3917 if(bit_pos == 0) *dst_pixel = 0;
3918 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3919
3920 if(++bit_pos == 8)
3921 {
3922 dst_pixel++;
3923 bit_pos = 0;
3924 }
3925 }
3926 if(pad_size)
3927 {
3928 if(bit_pos != 0) dst_pixel++;
3929 memset(dst_pixel, 0, pad_size);
3930 }
3931 dst_start += dst->stride;
3932 src_start += src->stride / 2;
3933 }
3934 }
3935 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
3936 {
3937 for(y = src_rect->top; y < src_rect->bottom; y++)
3938 {
3939 dst_pixel = dst_start;
3940 src_pixel = src_start;
3941 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3942 {
3943 src_val = *src_pixel++;
3944 dst_val = rgb_to_pixel_mono(dst, dither, x, y,
3945 (((src_val >> src->red_shift) << 3) & 0xf8) |
3946 (((src_val >> src->red_shift) >> 2) & 0x07),
3947 (((src_val >> src->green_shift) << 2) & 0xfc) |
3948 (((src_val >> src->green_shift) >> 4) & 0x03),
3949 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3950 (((src_val >> src->blue_shift) >> 2) & 0x07));
3951 if(bit_pos == 0) *dst_pixel = 0;
3952 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3953
3954 if(++bit_pos == 8)
3955 {
3956 dst_pixel++;
3957 bit_pos = 0;
3958 }
3959 }
3960 if(pad_size)
3961 {
3962 if(bit_pos != 0) dst_pixel++;
3963 memset(dst_pixel, 0, pad_size);
3964 }
3965 dst_start += dst->stride;
3966 src_start += src->stride / 2;
3967 }
3968 }
3969 else
3970 {
3971 for(y = src_rect->top; y < src_rect->bottom; y++)
3972 {
3973 dst_pixel = dst_start;
3974 src_pixel = src_start;
3975 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3976 {
3977 src_val = *src_pixel++;
3978 dst_val = rgb_to_pixel_mono(dst, dither, x, y,
3979 get_field(src_val, src->red_shift, src->red_len),
3980 get_field(src_val, src->green_shift, src->green_len),
3981 get_field(src_val, src->blue_shift, src->blue_len));
3982 if(bit_pos == 0) *dst_pixel = 0;
3983 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3984
3985 if(++bit_pos == 8)
3986 {
3987 dst_pixel++;
3988 bit_pos = 0;
3989 }
3990 }
3991 if(pad_size)
3992 {
3993 if(bit_pos != 0) dst_pixel++;
3994 memset(dst_pixel, 0, pad_size);
3995 }
3996 dst_start += dst->stride;
3997 src_start += src->stride / 2;
3998 }
3999 }
4000 break;
4001 }
4002
4003 case 8:
4004 {
4005 const RGBQUAD *color_table = get_dib_color_table( src );
4006 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
4007
4008 for(y = src_rect->top; y < src_rect->bottom; y++)
4009 {
4010 dst_pixel = dst_start;
4011 src_pixel = src_start;
4012 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
4013 {
4014 RGBQUAD rgb = color_table[*src_pixel++];
4015 dst_val = rgb_to_pixel_mono(dst, dither, x, y, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
4016
4017 if(bit_pos == 0) *dst_pixel = 0;
4018 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
4019
4020 if(++bit_pos == 8)
4021 {
4022 dst_pixel++;
4023 bit_pos = 0;
4024 }
4025 }
4026 if(pad_size)
4027 {
4028 if(bit_pos != 0) dst_pixel++;
4029 memset(dst_pixel, 0, pad_size);
4030 }
4031 dst_start += dst->stride;
4032 src_start += src->stride;
4033 }
4034 break;
4035 }
4036
4037 case 4:
4038 {
4039 const RGBQUAD *color_table = get_dib_color_table( src );
4040 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
4041
4042 for(y = src_rect->top; y < src_rect->bottom; y++)
4043 {
4044 int pos = (src->rect.left + src_rect->left) & 1;
4045 dst_pixel = dst_start;
4046 src_pixel = src_start;
4047 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++, pos++)
4048 {
4049 RGBQUAD rgb;
4050 if (pos & 1)
4051 rgb = color_table[*src_pixel++ & 0xf];
4052 else
4053 rgb = color_table[*src_pixel >> 4];
4054 dst_val = rgb_to_pixel_mono(dst, dither, x, y, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
4055
4056 if(bit_pos == 0) *dst_pixel = 0;
4057 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
4058
4059 if(++bit_pos == 8)
4060 {
4061 dst_pixel++;
4062 bit_pos = 0;
4063 }
4064 }
4065 if(pad_size)
4066 {
4067 if(bit_pos != 0) dst_pixel++;
4068 memset(dst_pixel, 0, pad_size);
4069 }
4070 dst_start += dst->stride;
4071 src_start += src->stride;
4072 }
4073 break;
4074 }
4075
4076 /* Note that while MSDN states that a 1 bpp dib brush -> mono dc
4077 uses text/bkgnd colours instead of the dib's colour table, this
4078 doesn't appear to be the case for a dc backed by a
4079 dibsection. */
4080
4081 case 1:
4082 {
4083 const RGBQUAD *color_table = get_dib_color_table( src );
4084 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top);
4085 for(y = src_rect->top; y < src_rect->bottom; y++)
4086 {
4087 int pos = (src->rect.left + src_rect->left) & 7;
4088 dst_pixel = dst_start;
4089 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++, pos++)
4090 {
4091 RGBQUAD rgb;
4092 src_val = (src_start[pos / 8] & pixel_masks_1[pos % 8]) ? 1 : 0;
4093 rgb = color_table[src_val];
4094 dst_val = rgb_to_pixel_mono(dst, dither, x, y, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
4095
4096 if(bit_pos == 0) *dst_pixel = 0;
4097 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
4098
4099 if(++bit_pos == 8)
4100 {
4101 dst_pixel++;
4102 bit_pos = 0;
4103 }
4104 }
4105 if(pad_size)
4106 {
4107 if(bit_pos != 0) dst_pixel++;
4108 memset(dst_pixel, 0, pad_size);
4109 }
4110 dst_start += dst->stride;
4111 src_start += src->stride;
4112 }
4113 break;
4114 }
4115 }
4116 }
4117
4118 static void convert_to_null(dib_info *dst, const dib_info *src, const RECT *src_rect, BOOL dither)
4119 {
4120 }
4121
4122 static inline BYTE blend_color(BYTE dst, BYTE src, DWORD alpha)
4123 {
4124 return (src * alpha + dst * (255 - alpha) + 127) / 255;
4125 }
4126
4127 static inline DWORD blend_argb_constant_alpha( DWORD dst, DWORD src, DWORD alpha )
4128 {
4129 return (blend_color( dst, src, alpha ) |
4130 blend_color( dst >> 8, src >> 8, alpha ) << 8 |
4131 blend_color( dst >> 16, src >> 16, alpha ) << 16 |
4132 blend_color( dst >> 24, src >> 24, alpha ) << 24);
4133 }
4134
4135 static inline DWORD blend_argb_no_src_alpha( DWORD dst, DWORD src, DWORD alpha )
4136 {
4137 return (blend_color( dst, src, alpha ) |
4138 blend_color( dst >> 8, src >> 8, alpha ) << 8 |
4139 blend_color( dst >> 16, src >> 16, alpha ) << 16 |
4140 blend_color( dst >> 24, 255, alpha ) << 24);
4141 }
4142
4143 static inline DWORD blend_argb( DWORD dst, DWORD src )
4144 {
4145 BYTE b = (BYTE)src;
4146 BYTE g = (BYTE)(src >> 8);
4147 BYTE r = (BYTE)(src >> 16);
4148 DWORD alpha = (BYTE)(src >> 24);
4149 return ((b + ((BYTE)dst * (255 - alpha) + 127) / 255) |
4150 (g + ((BYTE)(dst >> 8) * (255 - alpha) + 127) / 255) << 8 |
4151 (r + ((BYTE)(dst >> 16) * (255 - alpha) + 127) / 255) << 16 |
4152 (alpha + ((BYTE)(dst >> 24) * (255 - alpha) + 127) / 255) << 24);
4153 }
4154
4155 static inline DWORD blend_argb_alpha( DWORD dst, DWORD src, DWORD alpha )
4156 {
4157 BYTE b = ((BYTE)src * alpha + 127) / 255;
4158 BYTE g = ((BYTE)(src >> 8) * alpha + 127) / 255;
4159 BYTE r = ((BYTE)(src >> 16) * alpha + 127) / 255;
4160 alpha = ((BYTE)(src >> 24) * alpha + 127) / 255;
4161 return ((b + ((BYTE)dst * (255 - alpha) + 127) / 255) |
4162 (g + ((BYTE)(dst >> 8) * (255 - alpha) + 127) / 255) << 8 |
4163 (r + ((BYTE)(dst >> 16) * (255 - alpha) + 127) / 255) << 16 |
4164 (alpha + ((BYTE)(dst >> 24) * (255 - alpha) + 127) / 255) << 24);
4165 }
4166
4167 static inline DWORD blend_rgb( BYTE dst_r, BYTE dst_g, BYTE dst_b, DWORD src, BLENDFUNCTION blend )
4168 {
4169 if (blend.AlphaFormat & AC_SRC_ALPHA)
4170 {
4171 DWORD alpha = blend.SourceConstantAlpha;
4172 BYTE src_b = ((BYTE)src * alpha + 127) / 255;
4173 BYTE src_g = ((BYTE)(src >> 8) * alpha + 127) / 255;
4174 BYTE src_r = ((BYTE)(src >> 16) * alpha + 127) / 255;
4175 alpha = ((BYTE)(src >> 24) * alpha + 127) / 255;
4176 return ((src_b + (dst_b * (255 - alpha) + 127) / 255) |
4177 (src_g + (dst_g * (255 - alpha) + 127) / 255) << 8 |
4178 (src_r + (dst_r * (255 - alpha) + 127) / 255) << 16);
4179 }
4180 return (blend_color( dst_b, src, blend.SourceConstantAlpha ) |
4181 blend_color( dst_g, src >> 8, blend.SourceConstantAlpha ) << 8 |
4182 blend_color( dst_r, src >> 16, blend.SourceConstantAlpha ) << 16);
4183 }
4184
4185 static void blend_rect_8888(const dib_info *dst, const RECT *rc,
4186 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4187 {
4188 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4189 DWORD *dst_ptr = get_pixel_ptr_32( dst, rc->left, rc->top );
4190 int x, y;
4191
4192 if (blend.AlphaFormat & AC_SRC_ALPHA)
4193 {
4194 if (blend.SourceConstantAlpha == 255)
4195 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
4196 for (x = 0; x < rc->right - rc->left; x++)
4197 dst_ptr[x] = blend_argb( dst_ptr[x], src_ptr[x] );
4198 else
4199 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
4200 for (x = 0; x < rc->right - rc->left; x++)
4201 dst_ptr[x] = blend_argb_alpha( dst_ptr[x], src_ptr[x], blend.SourceConstantAlpha );
4202 }
4203 else if (src->compression == BI_RGB)
4204 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
4205 for (x = 0; x < rc->right - rc->left; x++)
4206 dst_ptr[x] = blend_argb_constant_alpha( dst_ptr[x], src_ptr[x], blend.SourceConstantAlpha );
4207 else
4208 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
4209 for (x = 0; x < rc->right - rc->left; x++)
4210 dst_ptr[x] = blend_argb_no_src_alpha( dst_ptr[x], src_ptr[x], blend.SourceConstantAlpha );
4211 }
4212
4213 static void blend_rect_32(const dib_info *dst, const RECT *rc,
4214 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4215 {
4216 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4217 DWORD *dst_ptr = get_pixel_ptr_32( dst, rc->left, rc->top );
4218 int x, y;
4219
4220 if (dst->red_len == 8 && dst->green_len == 8 && dst->blue_len == 8)
4221 {
4222 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
4223 {
4224 for (x = 0; x < rc->right - rc->left; x++)
4225 {
4226 DWORD val = blend_rgb( dst_ptr[x] >> dst->red_shift,
4227 dst_ptr[x] >> dst->green_shift,
4228 dst_ptr[x] >> dst->blue_shift,
4229 src_ptr[x], blend );
4230 dst_ptr[x] = ((( val & 0xff) << dst->blue_shift) |
4231 (((val >> 8) & 0xff) << dst->green_shift) |
4232 (((val >> 16) & 0xff) << dst->red_shift));
4233 }
4234 }
4235 }
4236 else
4237 {
4238 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
4239 {
4240 for (x = 0; x < rc->right - rc->left; x++)
4241 {
4242 DWORD val = blend_rgb( get_field( dst_ptr[x], dst->red_shift, dst->red_len ),
4243 get_field( dst_ptr[x], dst->green_shift, dst->green_len ),
4244 get_field( dst_ptr[x], dst->blue_shift, dst->blue_len ),
4245 src_ptr[x], blend );
4246 dst_ptr[x] = (put_field( val >> 16, dst->red_shift, dst->red_len ) |
4247 put_field( val >> 8, dst->green_shift, dst->green_len ) |
4248 put_field( val, dst->blue_shift, dst->blue_len ));
4249 }
4250 }
4251 }
4252 }
4253
4254 static void blend_rect_24(const dib_info *dst, const RECT *rc,
4255 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4256 {
4257 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4258 BYTE *dst_ptr = get_pixel_ptr_24( dst, rc->left, rc->top );
4259 int x, y;
4260
4261 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
4262 {
4263 for (x = 0; x < rc->right - rc->left; x++)
4264 {
4265 DWORD val = blend_rgb( dst_ptr[x * 3 + 2], dst_ptr[x * 3 + 1], dst_ptr[x * 3],
4266 src_ptr[x], blend );
4267 dst_ptr[x * 3] = val;
4268 dst_ptr[x * 3 + 1] = val >> 8;
4269 dst_ptr[x * 3 + 2] = val >> 16;
4270 }
4271 }
4272 }
4273
4274 static void blend_rect_555(const dib_info *dst, const RECT *rc,
4275 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4276 {
4277 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4278 WORD *dst_ptr = get_pixel_ptr_16( dst, rc->left, rc->top );
4279 int x, y;
4280
4281 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 2, src_ptr += src->stride / 4)
4282 {
4283 for (x = 0; x < rc->right - rc->left; x++)
4284 {
4285 DWORD val = blend_rgb( ((dst_ptr[x] >> 7) & 0xf8) | ((dst_ptr[x] >> 12) & 0x07),
4286 ((dst_ptr[x] >> 2) & 0xf8) | ((dst_ptr[x] >> 7) & 0x07),
4287 ((dst_ptr[x] << 3) & 0xf8) | ((dst_ptr[x] >> 2) & 0x07),
4288 src_ptr[x], blend );
4289 dst_ptr[x] = ((val >> 9) & 0x7c00) | ((val >> 6) & 0x03e0) | ((val >> 3) & 0x001f);
4290 }
4291 }
4292 }
4293
4294 static void blend_rect_16(const dib_info *dst, const RECT *rc,
4295 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4296 {
4297 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4298 WORD *dst_ptr = get_pixel_ptr_16( dst, rc->left, rc->top );
4299 int x, y;
4300
4301 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 2, src_ptr += src->stride / 4)
4302 {
4303 for (x = 0; x < rc->right - rc->left; x++)
4304 {
4305 DWORD val = blend_rgb( get_field( dst_ptr[x], dst->red_shift, dst->red_len ),
4306 get_field( dst_ptr[x], dst->green_shift, dst->green_len ),
4307 get_field( dst_ptr[x], dst->blue_shift, dst->blue_len ),
4308 src_ptr[x], blend );
4309 dst_ptr[x] = (put_field((val >> 16), dst->red_shift, dst->red_len) |
4310 put_field((val >> 8), dst->green_shift, dst->green_len) |
4311 put_field( val, dst->blue_shift, dst->blue_len));
4312 }
4313 }
4314 }
4315
4316 static void blend_rect_8(const dib_info *dst, const RECT *rc,
4317 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4318 {
4319 const RGBQUAD *color_table = get_dib_color_table( dst );
4320 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4321 BYTE *dst_ptr = get_pixel_ptr_8( dst, rc->left, rc->top );
4322 int x, y;
4323
4324 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
4325 {
4326 for (x = 0; x < rc->right - rc->left; x++)
4327 {
4328 RGBQUAD rgb = color_table[dst_ptr[x]];
4329 DWORD val = blend_rgb( rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, src_ptr[x], blend );
4330 dst_ptr[x] = rgb_lookup_colortable( dst, val >> 16, val >> 8, val );
4331 }
4332 }
4333 }
4334
4335 static void blend_rect_4(const dib_info *dst, const RECT *rc,
4336 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4337 {
4338 const RGBQUAD *color_table = get_dib_color_table( dst );
4339 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4340 BYTE *dst_ptr = get_pixel_ptr_4( dst, rc->left, rc->top );
4341 int i, x, y;
4342
4343 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
4344 {
4345 for (i = 0, x = (dst->rect.left + rc->left) & 1; i < rc->right - rc->left; i++, x++)
4346 {
4347 DWORD val = ((x & 1) ? dst_ptr[x / 2] : (dst_ptr[x / 2] >> 4)) & 0x0f;
4348 RGBQUAD rgb = color_table[val];
4349 val = blend_rgb( rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, src_ptr[i], blend );
4350 val = rgb_lookup_colortable( dst, val >> 16, val >> 8, val );
4351 if (x & 1)
4352 dst_ptr[x / 2] = val | (dst_ptr[x / 2] & 0xf0);
4353 else
4354 dst_ptr[x / 2] = (val << 4) | (dst_ptr[x / 2] & 0x0f);
4355 }
4356 }
4357 }
4358
4359 static void blend_rect_1(const dib_info *dst, const RECT *rc,
4360 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4361 {
4362 const RGBQUAD *color_table = get_dib_color_table( dst );
4363 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
4364 BYTE *dst_ptr = get_pixel_ptr_1( dst, rc->left, rc->top );
4365 int i, x, y;
4366
4367 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
4368 {
4369 for (i = 0, x = (dst->rect.left + rc->left) & 7; i < rc->right - rc->left; i++, x++)
4370 {
4371 DWORD val = (dst_ptr[x / 8] & pixel_masks_1[x % 8]) ? 1 : 0;
4372 RGBQUAD rgb = color_table[val];
4373 val = blend_rgb( rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, src_ptr[i], blend );
4374 val = rgb_to_pixel_colortable(dst, val >> 16, val >> 8, val) ? 0xff : 0;
4375 dst_ptr[x / 8] = (dst_ptr[x / 8] & ~pixel_masks_1[x % 8]) | (val & pixel_masks_1[x % 8]);
4376 }
4377 }
4378 }
4379
4380 static void blend_rect_null(const dib_info *dst, const RECT *rc,
4381 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4382 {
4383 }
4384
4385 static inline DWORD gradient_rgb_8888( const TRIVERTEX *v, unsigned int pos, unsigned int len )
4386 {
4387 BYTE r, g, b, a;
4388 r = (v[0].Red * (len - pos) + v[1].Red * pos) / len / 256;
4389 g = (v[0].Green * (len - pos) + v[1].Green * pos) / len / 256;
4390 b = (v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 256;
4391 a = (v[0].Alpha * (len - pos) + v[1].Alpha * pos) / len / 256;
4392 return a << 24 | r << 16 | g << 8 | b;
4393 }
4394
4395 static inline DWORD gradient_rgb_24( const TRIVERTEX *v, unsigned int pos, unsigned int len )
4396 {
4397 BYTE r, g, b;
4398 r = (v[0].Red * (len - pos) + v[1].Red * pos) / len / 256;
4399 g = (v[0].Green * (len - pos) + v[1].Green * pos) / len / 256;
4400 b = (v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 256;
4401 return r << 16 | g << 8 | b;
4402 }
4403
4404 static inline WORD gradient_rgb_555( const TRIVERTEX *v, unsigned int pos, unsigned int len,
4405 unsigned int x, unsigned int y )
4406 {
4407 int r = (v[0].Red * (len - pos) + v[1].Red * pos) / len / 128 + bayer_4x4[y % 4][x % 4];
4408 int g = (v[0].Green * (len - pos) + v[1].Green * pos) / len / 128 + bayer_4x4[y % 4][x % 4];
4409 int b = (v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 128 + bayer_4x4[y % 4][x % 4];
4410 r = min( 31, max( 0, r / 16 ));
4411 g = min( 31, max( 0, g / 16 ));
4412 b = min( 31, max( 0, b / 16 ));
4413 return (r << 10) | (g << 5) | b;
4414 }
4415
4416 static inline BYTE gradient_rgb_8( const dib_info *dib, const TRIVERTEX *v,
4417 unsigned int pos, unsigned int len, unsigned int x, unsigned int y )
4418 {
4419 BYTE r = ((v[0].Red * (len - pos) + v[1].Red * pos) / len / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4420 BYTE g = ((v[0].Green * (len - pos) + v[1].Green * pos) / len / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4421 BYTE b = ((v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4422 return rgb_to_pixel_colortable( dib, r * 127, g * 127, b * 127 );
4423 }
4424
4425 /* compute the left/right triangle limit for row y */
4426 static inline void triangle_coords( const TRIVERTEX *v, const RECT *rc, int y, int *left, int *right )
4427 {
4428 int x1, x2;
4429
4430 if (y < v[1].y) x1 = edge_coord( y, v[0].x, v[0].y, v[1].x, v[1].y );
4431 else x1 = edge_coord( y, v[1].x, v[1].y, v[2].x, v[2].y );
4432
4433 x2 = edge_coord( y, v[0].x, v[0].y, v[2].x, v[2].y );
4434
4435 *left = max( rc->left, min( x1, x2 ) );
4436 *right = min( rc->right, max( x1, x2 ) );
4437 }
4438
4439 /* compute the matrix determinant for triangular barycentric coordinates (constant across the triangle) */
4440 static inline int triangle_det( const TRIVERTEX *v )
4441 {
4442 return (v[2].y - v[1].y) * (v[2].x - v[0].x) - (v[2].x - v[1].x) * (v[2].y - v[0].y);
4443 }
4444
4445 /* compute the barycentric weights for a given point inside the triangle */
4446 static inline void triangle_weights( const TRIVERTEX *v, int x, int y, INT64 *l1, INT64 *l2 )
4447 {
4448 *l1 = (v[1].y - v[2].y) * (x - v[2].x) - (v[1].x - v[2].x) * (y - v[2].y);
4449 *l2 = (v[2].y - v[0].y) * (x - v[2].x) - (v[2].x - v[0].x) * (y - v[2].y);
4450 }
4451
4452 static inline DWORD gradient_triangle_8888( const TRIVERTEX *v, int x, int y, int det )
4453 {
4454 INT64 l1, l2;
4455 BYTE r, g, b, a;
4456
4457 triangle_weights( v, x, y, &l1, &l2 );
4458 r = (v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 256;
4459 g = (v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 256;
4460 b = (v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 256;
4461 a = (v[0].Alpha * l1 + v[1].Alpha * l2 + v[2].Alpha * (det - l1 - l2)) / det / 256;
4462 return a << 24 | r << 16 | g << 8 | b;
4463 }
4464
4465 static inline DWORD gradient_triangle_24( const TRIVERTEX *v, int x, int y, int det )
4466 {
4467 INT64 l1, l2;
4468 BYTE r, g, b;
4469
4470 triangle_weights( v, x, y, &l1, &l2 );
4471 r = (v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 256;
4472 g = (v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 256;
4473 b = (v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 256;
4474 return r << 16 | g << 8 | b;
4475 }
4476
4477 static inline DWORD gradient_triangle_555( const TRIVERTEX *v, int x, int y, int det )
4478 {
4479 INT64 l1, l2;
4480 int r, g, b;
4481
4482 triangle_weights( v, x, y, &l1, &l2 );
4483 r = (v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 128 + bayer_4x4[y % 4][x % 4];
4484 g = (v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 128 + bayer_4x4[y % 4][x % 4];
4485 b = (v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 128 + bayer_4x4[y % 4][x % 4];
4486 r = min( 31, max( 0, r / 16 ));
4487 g = min( 31, max( 0, g / 16 ));
4488 b = min( 31, max( 0, b / 16 ));
4489 return (r << 10) | (g << 5) | b;
4490 }
4491
4492 static inline DWORD gradient_triangle_8( const dib_info *dib, const TRIVERTEX *v, int x, int y, int det )
4493 {
4494 INT64 l1, l2;
4495 BYTE r, g, b;
4496
4497 triangle_weights( v, x, y, &l1, &l2 );
4498 r = ((v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4499 g = ((v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4500 b = ((v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4501 return rgb_to_pixel_colortable( dib, r * 127, g * 127, b * 127 );
4502 }
4503
4504 static BOOL gradient_rect_8888( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4505 {
4506 DWORD *ptr = get_pixel_ptr_32( dib, rc->left, rc->top );
4507 int x, y, left, right, det;
4508
4509 switch (mode)
4510 {
4511 case GRADIENT_FILL_RECT_H:
4512 for (x = 0; x < rc->right - rc->left; x++)
4513 ptr[x] = gradient_rgb_8888( v, rc->left + x - v[0].x, v[1].x - v[0].x );
4514
4515 for (y = rc->top + 1; y < rc->bottom; y++, ptr += dib->stride / 4)
4516 memcpy( ptr + dib->stride / 4, ptr, (rc->right - rc->left) * 4 );
4517 break;
4518
4519 case GRADIENT_FILL_RECT_V:
4520 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 4)
4521 {
4522 DWORD val = gradient_rgb_8888( v, y - v[0].y, v[1].y - v[0].y );
4523 memset_32( ptr, val, rc->right - rc->left );
4524 }
4525 break;
4526
4527 case GRADIENT_FILL_TRIANGLE:
4528 if (!(det = triangle_det( v ))) return FALSE;
4529 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 4)
4530 {
4531 triangle_coords( v, rc, y, &left, &right );
4532 for (x = left; x < right; x++) ptr[x - rc->left] = gradient_triangle_8888( v, x, y, det );
4533 }
4534 break;
4535 }
4536 return TRUE;
4537 }
4538
4539 static BOOL gradient_rect_32( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4540 {
4541 DWORD *ptr = get_pixel_ptr_32( dib, rc->left, rc->top );
4542 int x, y, left, right, det;
4543
4544 switch (mode)
4545 {
4546 case GRADIENT_FILL_RECT_H:
4547 if (dib->red_len == 8 && dib->green_len == 8 && dib->blue_len == 8)
4548 {
4549 for (x = 0; x < rc->right - rc->left; x++)
4550 {
4551 DWORD val = gradient_rgb_24( v, rc->left + x - v[0].x, v[1].x - v[0].x );
4552 ptr[x] = ((( val & 0xff) << dib->blue_shift) |
4553 (((val >> 8) & 0xff) << dib->green_shift) |
4554 (((val >> 16) & 0xff) << dib->red_shift));
4555 }
4556 }
4557 else
4558 {
4559 for (x = 0; x < rc->right - rc->left; x++)
4560 {
4561 DWORD val = gradient_rgb_24( v, rc->left + x - v[0].x, v[1].x - v[0].x );
4562 ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4563 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4564 put_field( val, dib->blue_shift, dib->blue_len ));
4565 }
4566 }
4567
4568 for (y = rc->top + 1; y < rc->bottom; y++, ptr += dib->stride / 4)
4569 memcpy( ptr + dib->stride / 4, ptr, (rc->right - rc->left) * 4 );
4570 break;
4571
4572 case GRADIENT_FILL_RECT_V:
4573 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 4)
4574 {
4575 DWORD val = gradient_rgb_24( v, y - v[0].y, v[1].y - v[0].y );
4576 if (dib->red_len == 8 && dib->green_len == 8 && dib->blue_len == 8)
4577 val = ((( val & 0xff) << dib->blue_shift) |
4578 (((val >> 8) & 0xff) << dib->green_shift) |
4579 (((val >> 16) & 0xff) << dib->red_shift));
4580 else
4581 val = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4582 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4583 put_field( val, dib->blue_shift, dib->blue_len ));
4584
4585 memset_32( ptr, val, rc->right - rc->left );
4586 }
4587 break;
4588
4589 case GRADIENT_FILL_TRIANGLE:
4590 if (!(det = triangle_det( v ))) return FALSE;
4591 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 4)
4592 {
4593 triangle_coords( v, rc, y, &left, &right );
4594
4595 if (dib->red_len == 8 && dib->green_len == 8 && dib->blue_len == 8)
4596 for (x = left; x < right; x++)
4597 {
4598 DWORD val = gradient_triangle_24( v, x, y, det );
4599 ptr[x - rc->left] = ((( val & 0xff) << dib->blue_shift) |
4600 (((val >> 8) & 0xff) << dib->green_shift) |
4601 (((val >> 16) & 0xff) << dib->red_shift));
4602 }
4603 else
4604 for (x = left; x < right; x++)
4605 {
4606 DWORD val = gradient_triangle_24( v, x, y, det );
4607 ptr[x - rc->left] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4608 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4609 put_field( val, dib->blue_shift, dib->blue_len ));
4610 }
4611 }
4612 break;
4613 }
4614 return TRUE;
4615 }
4616
4617 static BOOL gradient_rect_24( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4618 {
4619 BYTE *ptr = get_pixel_ptr_24( dib, rc->left, rc->top );
4620 int x, y, left, right, det;
4621
4622 switch (mode)
4623 {
4624 case GRADIENT_FILL_RECT_H:
4625 for (x = 0; x < rc->right - rc->left; x++)
4626 {
4627 DWORD val = gradient_rgb_24( v, rc->left + x - v[0].x, v[1].x - v[0].x );
4628 ptr[x * 3] = val;
4629 ptr[x * 3 + 1] = val >> 8;
4630 ptr[x * 3 + 2] = val >> 16;
4631 }
4632
4633 for (y = rc->top + 1; y < rc->bottom; y++, ptr += dib->stride)
4634 memcpy( ptr + dib->stride, ptr, (rc->right - rc->left) * 3 );
4635 break;
4636
4637 case GRADIENT_FILL_RECT_V:
4638 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4639 {
4640 DWORD val = gradient_rgb_24( v, y - v[0].y, v[1].y - v[0].y );
4641 for (x = 0; x < rc->right - rc->left; x++)
4642 {
4643 ptr[x * 3] = val;
4644 ptr[x * 3 + 1] = val >> 8;
4645 ptr[x * 3 + 2] = val >> 16;
4646 }
4647 }
4648 break;
4649
4650 case GRADIENT_FILL_TRIANGLE:
4651 if (!(det = triangle_det( v ))) return FALSE;
4652 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4653 {
4654 triangle_coords( v, rc, y, &left, &right );
4655 for (x = left; x < right; x++)
4656 {
4657 DWORD val = gradient_triangle_24( v, x, y, det );
4658 ptr[(x - rc->left) * 3] = val;
4659 ptr[(x - rc->left) * 3 + 1] = val >> 8;
4660 ptr[(x - rc->left) * 3 + 2] = val >> 16;
4661 }
4662 }
4663 break;
4664 }
4665 return TRUE;
4666 }
4667
4668 static BOOL gradient_rect_555( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4669 {
4670 WORD *ptr = get_pixel_ptr_16( dib, rc->left, rc->top );
4671 int x, y, left, right, det;
4672
4673 switch (mode)
4674 {
4675 case GRADIENT_FILL_RECT_H:
4676 for (y = rc->top; y < min( rc->top + 4, rc->bottom ); y++, ptr += dib->stride / 2)
4677 for (x = rc->left; x < rc->right; x++)
4678 ptr[x - rc->left] = gradient_rgb_555( v, x - v[0].x, v[1].x - v[0].x, x, y );
4679 for ( ; y < rc->bottom; y++, ptr += dib->stride / 2)
4680 memcpy( ptr, ptr - dib->stride * 2, (rc->right - rc->left) * 2 );
4681 break;
4682
4683 case GRADIENT_FILL_RECT_V:
4684 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4685 {
4686 WORD values[4];
4687 for (x = 0; x < 4; x++) values[x] = gradient_rgb_555( v, y - v[0].y, v[1].y - v[0].y, x, y );
4688 for (x = rc->left; x < rc->right; x++) ptr[x - rc->left] = values[x % 4];
4689 }
4690 break;
4691
4692 case GRADIENT_FILL_TRIANGLE:
4693 if (!(det = triangle_det( v ))) return FALSE;
4694 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4695 {
4696 triangle_coords( v, rc, y, &left, &right );
4697 for (x = left; x < right; x++) ptr[x - rc->left] = gradient_triangle_555( v, x, y, det );
4698 }
4699 break;
4700 }
4701 return TRUE;
4702 }
4703
4704 static BOOL gradient_rect_16( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4705 {
4706 WORD *ptr = get_pixel_ptr_16( dib, rc->left, rc->top );
4707 int x, y, left, right, det;
4708
4709 switch (mode)
4710 {
4711 case GRADIENT_FILL_RECT_H:
4712 for (y = rc->top; y < min( rc->top + 4, rc->bottom ); y++, ptr += dib->stride / 2)
4713 for (x = rc->left; x < rc->right; x++)
4714 {
4715 WORD val = gradient_rgb_555( v, x - v[0].x, v[1].x - v[0].x, x, y );
4716 ptr[x - rc->left] = (put_field(((val >> 7) & 0xf8) | ((val >> 12) & 0x07), dib->red_shift, dib->red_len) |
4717 put_field(((val >> 2) & 0xf8) | ((val >> 7) & 0x07), dib->green_shift, dib->green_len) |
4718 put_field(((val << 3) & 0xf8) | ((val >> 2) & 0x07), dib->blue_shift, dib->blue_len));
4719 }
4720 for ( ; y < rc->bottom; y++, ptr += dib->stride / 2)
4721 memcpy( ptr, ptr - dib->stride * 2, (rc->right - rc->left) * 2 );
4722 break;
4723
4724 case GRADIENT_FILL_RECT_V:
4725 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4726 {
4727 WORD values[4];
4728 for (x = 0; x < 4; x++)
4729 {
4730 WORD val = gradient_rgb_555( v, y - v[0].y, v[1].y - v[0].y, x, y );
4731 values[x] = (put_field(((val >> 7) & 0xf8) | ((val >> 12) & 0x07), dib->red_shift, dib->red_len) |
4732 put_field(((val >> 2) & 0xf8) | ((val >> 7) & 0x07), dib->green_shift, dib->green_len) |
4733 put_field(((val << 3) & 0xf8) | ((val >> 2) & 0x07), dib->blue_shift, dib->blue_len));
4734 }
4735 for (x = rc->left; x < rc->right; x++) ptr[x - rc->left] = values[x % 4];
4736 }
4737 break;
4738
4739 case GRADIENT_FILL_TRIANGLE:
4740 if (!(det = triangle_det( v ))) return FALSE;
4741 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4742 {
4743 triangle_coords( v, rc, y, &left, &right );
4744 for (x = left; x < right; x++)
4745 {
4746 WORD val = gradient_triangle_555( v, x, y, det );
4747 ptr[x - rc->left] = (put_field(((val >> 7) & 0xf8) | ((val >> 12) & 0x07), dib->red_shift, dib->red_len) |
4748 put_field(((val >> 2) & 0xf8) | ((val >> 7) & 0x07), dib->green_shift, dib->green_len) |
4749 put_field(((val << 3) & 0xf8) | ((val >> 2) & 0x07), dib->blue_shift, dib->blue_len));
4750 }
4751 }
4752 break;
4753 }
4754 return TRUE;
4755 }
4756
4757 static BOOL gradient_rect_8( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4758 {
4759 BYTE *ptr = get_pixel_ptr_8( dib, rc->left, rc->top );
4760 int x, y, left, right, det;
4761
4762 switch (mode)
4763 {
4764 case GRADIENT_FILL_RECT_H:
4765 for (y = rc->top; y < min( rc->top + 16, rc->bottom ); y++, ptr += dib->stride)
4766 for (x = rc->left; x < rc->right; x++)
4767 ptr[x - rc->left] = gradient_rgb_8( dib, v, x - v[0].x, v[1].x - v[0].x, x, y );
4768 for ( ; y < rc->bottom; y++, ptr += dib->stride)
4769 memcpy( ptr, ptr - dib->stride * 16, rc->right - rc->left );
4770 break;
4771
4772 case GRADIENT_FILL_RECT_V:
4773 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4774 {
4775 BYTE values[16];
4776 for (x = 0; x < 16; x++)
4777 values[x] = gradient_rgb_8( dib, v, y - v[0].y, v[1].y - v[0].y, x, y );
4778 for (x = rc->left; x < rc->right; x++) ptr[x - rc->left] = values[x % 16];
4779 }
4780 break;
4781
4782 case GRADIENT_FILL_TRIANGLE:
4783 if (!(det = triangle_det( v ))) return FALSE;
4784 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4785 {
4786 triangle_coords( v, rc, y, &left, &right );
4787 for (x = left; x < right; x++) ptr[x - rc->left] = gradient_triangle_8( dib, v, x, y, det );
4788 }
4789 break;
4790 }
4791 return TRUE;
4792 }
4793
4794 static BOOL gradient_rect_4( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4795 {
4796 BYTE *ptr = get_pixel_ptr_4( dib, rc->left, rc->top );
4797 int x, y, left, right, det, pos;
4798
4799 switch (mode)
4800 {
4801 case GRADIENT_FILL_RECT_H:
4802 for (y = rc->top; y < min( rc->top + 16, rc->bottom ); y++, ptr += dib->stride)
4803 {
4804 for (x = rc->left, pos = (dib->rect.left + rc->left) & 1; x < rc->right; x++, pos++)
4805 {
4806 BYTE val = gradient_rgb_8( dib, v, x - v[0].x, v[1].x - v[0].x, x, y );
4807 if (pos & 1)
4808 ptr[pos / 2] = val | (ptr[pos / 2] & 0xf0);
4809 else
4810 ptr[pos / 2] = (val << 4) | (ptr[pos / 2] & 0x0f);
4811 }
4812 }
4813 for ( ; y < rc->bottom; y++, ptr += dib->stride)
4814 {
4815 x = rc->left;
4816 pos = (dib->rect.left + rc->left) & 1;
4817 if (pos)
4818 {
4819 ptr[0] = (ptr[-16 * dib->stride] & 0x0f) | (ptr[0] & 0xf0);
4820 pos++;
4821 x++;
4822 }
4823 for (; x < rc->right - 1; x += 2, pos += 2) ptr[pos / 2] = ptr[pos / 2 - 16 * dib->stride];
4824 if (x < rc->right)
4825 ptr[pos / 2] = (ptr[pos / 2] & 0x0f) | (ptr[pos / 2 - 16 * dib->stride] & 0xf0);
4826 }
4827 break;
4828
4829 case GRADIENT_FILL_RECT_V:
4830 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4831 {
4832 BYTE values[16];
4833 for (x = 0; x < 16; x++)
4834 values[x] = gradient_rgb_8( dib, v, y - v[0].y, v[1].y - v[0].y, x, y );
4835 for (x = rc->left, pos = (dib->rect.left + rc->left) & 1; x < rc->right; x++, pos++)
4836 if (pos & 1)
4837 ptr[pos / 2] = values[x % 16] | (ptr[pos / 2] & 0xf0);
4838 else
4839 ptr[pos / 2] = (values[x % 16] << 4) | (ptr[pos / 2] & 0x0f);
4840 }
4841 break;
4842
4843 case GRADIENT_FILL_TRIANGLE:
4844 if (!(det = triangle_det( v ))) return FALSE;
4845 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4846 {
4847 triangle_coords( v, rc, y, &left, &right );
4848 for (x = left, pos = left - rc->left + ((dib->rect.left + rc->left) & 1); x < right; x++, pos++)
4849 {
4850 BYTE val = gradient_triangle_8( dib, v, x, y, det );
4851 if (pos & 1)
4852 ptr[pos / 2] = val | (ptr[pos / 2] & 0xf0);
4853 else
4854 ptr[pos / 2] = (val << 4) | (ptr[pos / 2] & 0x0f);
4855 }
4856 }
4857 break;
4858 }
4859 return TRUE;
4860 }
4861
4862 static BOOL gradient_rect_1( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4863 {
4864 BYTE *ptr = get_pixel_ptr_1( dib, rc->left, rc->top );
4865 int x, y, left, right, det, pos;
4866
4867 switch (mode)
4868 {
4869 case GRADIENT_FILL_RECT_H:
4870 for (y = rc->top; y < min( rc->top + 16, rc->bottom ); y++, ptr += dib->stride)
4871 {
4872 for (x = rc->left, pos = (dib->rect.left + rc->left) & 7; x < rc->right; x++, pos++)
4873 {
4874 BYTE val = gradient_rgb_8( dib, v, x - v[0].x, v[1].x - v[0].x, x, y ) ? 0xff : 0;
4875 ptr[pos / 8] = (ptr[pos / 8] & ~pixel_masks_1[pos % 8]) | (val & pixel_masks_1[pos % 8]);
4876 }
4877 }
4878 for ( ; y < rc->bottom; y++, ptr += dib->stride)
4879 for (x = rc->left, pos = (dib->rect.left + rc->left) & 7; x < rc->right; x++, pos++)
4880 ptr[pos / 8] = (ptr[pos / 8] & ~pixel_masks_1[pos % 8]) |
4881 (ptr[pos / 8 - 16 * dib->stride] & pixel_masks_1[pos % 8]);
4882 break;
4883
4884 case GRADIENT_FILL_RECT_V:
4885 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4886 {
4887 BYTE values[16];
4888 for (x = 0; x < 16; x++)
4889 values[x] = gradient_rgb_8( dib, v, y - v[0].y, v[1].y - v[0].y, x, y ) ? 0xff : 0;
4890 for (x = rc->left, pos = (dib->rect.left + rc->left) & 7; x < rc->right; x++, pos++)
4891 ptr[pos / 8] = (ptr[pos / 8] & ~pixel_masks_1[pos % 8]) |
4892 (values[x % 16] & pixel_masks_1[pos % 8]);
4893 }
4894 break;
4895
4896 case GRADIENT_FILL_TRIANGLE:
4897 if (!(det = triangle_det( v ))) return FALSE;
4898 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4899 {
4900 triangle_coords( v, rc, y, &left, &right );
4901 for (x = left, pos = left - rc->left + ((dib->rect.left + rc->left) & 7); x < right; x++, pos++)
4902 {
4903 BYTE val = gradient_triangle_8( dib, v, x, y, det ) ? 0xff : 0;
4904 ptr[pos / 8] = (ptr[pos / 8] & ~pixel_masks_1[pos % 8]) | (val & pixel_masks_1[pos % 8]);
4905 }
4906 }
4907 break;
4908 }
4909 return TRUE;
4910 }
4911
4912 static BOOL gradient_rect_null( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4913 {
4914 return TRUE;
4915 }
4916
4917 static inline BYTE aa_color( BYTE dst, BYTE text, BYTE min_comp, BYTE max_comp )
4918 {
4919 if (dst == text) return dst;
4920
4921 if (dst > text)
4922 {
4923 DWORD diff = dst - text;
4924 DWORD range = max_comp - text;
4925 dst = text + (diff * range ) / (0xff - text);
4926 return dst;
4927 }
4928 else
4929 {
4930 DWORD diff = text - dst;
4931 DWORD range = text - min_comp;
4932 dst = text - (diff * range) / text;
4933 return dst;
4934 }
4935 }
4936
4937 static inline DWORD aa_rgb( BYTE r_dst, BYTE g_dst, BYTE b_dst, DWORD text, const struct intensity_range *range )
4938 {
4939 return (aa_color( b_dst, text, range->b_min, range->b_max ) |
4940 aa_color( g_dst, text >> 8, range->g_min, range->g_max ) << 8 |
4941 aa_color( r_dst, text >> 16, range->r_min, range->r_max ) << 16);
4942 }
4943
4944 static void draw_glyph_8888( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4945 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4946 {
4947 DWORD *dst_ptr = get_pixel_ptr_32( dib, rect->left, rect->top );
4948 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4949 int x, y;
4950
4951 for (y = rect->top; y < rect->bottom; y++)
4952 {
4953 for (x = 0; x < rect->right - rect->left; x++)
4954 {
4955 if (glyph_ptr[x] <= 1) continue;
4956 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
4957 dst_ptr[x] = aa_rgb( dst_ptr[x] >> 16, dst_ptr[x] >> 8, dst_ptr[x], text_pixel, ranges + glyph_ptr[x] );
4958 }
4959 dst_ptr += dib->stride / 4;
4960 glyph_ptr += glyph->stride;
4961 }
4962 }
4963
4964 static void draw_glyph_32( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4965 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4966 {
4967 DWORD *dst_ptr = get_pixel_ptr_32( dib, rect->left, rect->top );
4968 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4969 int x, y;
4970 DWORD text, val;
4971
4972 text = get_field( text_pixel, dib->red_shift, dib->red_len ) << 16 |
4973 get_field( text_pixel, dib->green_shift, dib->green_len ) << 8 |
4974 get_field( text_pixel, dib->blue_shift, dib->blue_len );
4975
4976 for (y = rect->top; y < rect->bottom; y++)
4977 {
4978 for (x = 0; x < rect->right - rect->left; x++)
4979 {
4980 if (glyph_ptr[x] <= 1) continue;
4981 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
4982 val = aa_rgb( get_field(dst_ptr[x], dib->red_shift, dib->red_len),
4983 get_field(dst_ptr[x], dib->green_shift, dib->green_len),
4984 get_field(dst_ptr[x], dib->blue_shift, dib->blue_len),
4985 text, ranges + glyph_ptr[x] );
4986 dst_ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4987 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4988 put_field( val, dib->blue_shift, dib->blue_len ));
4989 }
4990 dst_ptr += dib->stride / 4;
4991 glyph_ptr += glyph->stride;
4992 }
4993 }
4994
4995 static void draw_glyph_24( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4996 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4997 {
4998 BYTE *dst_ptr = get_pixel_ptr_24( dib, rect->left, rect->top );
4999 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
5000 int x, y;
5001 DWORD val;
5002
5003 for (y = rect->top; y < rect->bottom; y++)
5004 {
5005 for (x = 0; x < rect->right - rect->left; x++)
5006 {
5007 if (glyph_ptr[x] <= 1) continue;
5008 if (glyph_ptr[x] >= 16)
5009 val = text_pixel;
5010 else
5011 val = aa_rgb( dst_ptr[x * 3 + 2], dst_ptr[x * 3 + 1], dst_ptr[x * 3],
5012 text_pixel, ranges + glyph_ptr[x] );
5013 dst_ptr[x * 3] = val;
5014 dst_ptr[x * 3 + 1] = val >> 8;
5015 dst_ptr[x * 3 + 2] = val >> 16;
5016 }
5017 dst_ptr += dib->stride;
5018 glyph_ptr += glyph->stride;
5019 }
5020 }
5021
5022 static void draw_glyph_555( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5023 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
5024 {
5025 WORD *dst_ptr = get_pixel_ptr_16( dib, rect->left, rect->top );
5026 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
5027 int x, y;
5028 DWORD text, val;
5029
5030 text = ((text_pixel << 9) & 0xf80000) | ((text_pixel << 4) & 0x070000) |
5031 ((text_pixel << 6) & 0x00f800) | ((text_pixel << 1) & 0x000700) |
5032 ((text_pixel << 3) & 0x0000f8) | ((text_pixel >> 2) & 0x000007);
5033
5034 for (y = rect->top; y < rect->bottom; y++)
5035 {
5036 for (x = 0; x < rect->right - rect->left; x++)
5037 {
5038 if (glyph_ptr[x] <= 1) continue;
5039 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
5040 val = aa_rgb( ((dst_ptr[x] >> 7) & 0xf8) | ((dst_ptr[x] >> 12) & 0x07),
5041 ((dst_ptr[x] >> 2) & 0xf8) | ((dst_ptr[x] >> 7) & 0x07),
5042 ((dst_ptr[x] << 3) & 0xf8) | ((dst_ptr[x] >> 2) & 0x07),
5043 text, ranges + glyph_ptr[x] );
5044 dst_ptr[x] = ((val >> 9) & 0x7c00) | ((val >> 6) & 0x03e0) | ((val >> 3) & 0x001f);
5045 }
5046 dst_ptr += dib->stride / 2;
5047 glyph_ptr += glyph->stride;
5048 }
5049 }
5050
5051 static void draw_glyph_16( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5052 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
5053 {
5054 WORD *dst_ptr = get_pixel_ptr_16( dib, rect->left, rect->top );
5055 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
5056 int x, y;
5057 DWORD text, val;
5058
5059 text = get_field( text_pixel, dib->red_shift, dib->red_len ) << 16 |
5060 get_field( text_pixel, dib->green_shift, dib->green_len ) << 8 |
5061 get_field( text_pixel, dib->blue_shift, dib->blue_len );
5062
5063 for (y = rect->top; y < rect->bottom; y++)
5064 {
5065 for (x = 0; x < rect->right - rect->left; x++)
5066 {
5067 if (glyph_ptr[x] <= 1) continue;
5068 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
5069 val = aa_rgb( get_field(dst_ptr[x], dib->red_shift, dib->red_len),
5070 get_field(dst_ptr[x], dib->green_shift, dib->green_len),
5071 get_field(dst_ptr[x], dib->blue_shift, dib->blue_len),
5072 text, ranges + glyph_ptr[x] );
5073 dst_ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
5074 put_field( val >> 8, dib->green_shift, dib->green_len ) |
5075 put_field( val, dib->blue_shift, dib->blue_len ));
5076 }
5077 dst_ptr += dib->stride / 2;
5078 glyph_ptr += glyph->stride;
5079 }
5080 }
5081
5082 static void draw_glyph_8( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5083 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
5084 {
5085 BYTE *dst_ptr = get_pixel_ptr_8( dib, rect->left, rect->top );
5086 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
5087 int x, y;
5088
5089 for (y = rect->top; y < rect->bottom; y++)
5090 {
5091 for (x = 0; x < rect->right - rect->left; x++)
5092 {
5093 /* no antialiasing, glyph should only contain 0 or 16. */
5094 if (glyph_ptr[x] >= 16)
5095 dst_ptr[x] = text_pixel;
5096 }
5097 dst_ptr += dib->stride;
5098 glyph_ptr += glyph->stride;
5099 }
5100 }
5101
5102 static void draw_glyph_4( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5103 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
5104 {
5105 BYTE *dst_ptr = get_pixel_ptr_4( dib, rect->left, rect->top );
5106 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
5107 int x, y, pos;
5108
5109 for (y = rect->top; y < rect->bottom; y++)
5110 {
5111 for (x = 0, pos = (dib->rect.left + rect->left) & 1; x < rect->right - rect->left; x++, pos++)
5112 {
5113 /* no antialiasing, glyph should only contain 0 or 16. */
5114 if (glyph_ptr[x] >= 16)
5115 {
5116 if (pos & 1)
5117 dst_ptr[pos / 2] = text_pixel | (dst_ptr[pos / 2] & 0xf0);
5118 else
5119 dst_ptr[pos / 2] = (text_pixel << 4) | (dst_ptr[pos / 2] & 0x0f);
5120 }
5121 }
5122 dst_ptr += dib->stride;
5123 glyph_ptr += glyph->stride;
5124 }
5125 }
5126
5127 static void draw_glyph_1( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5128 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
5129 {
5130 BYTE *dst_ptr = get_pixel_ptr_1( dib, rect->left, rect->top );
5131 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
5132 int x, y, pos;
5133 BYTE text = (text_pixel & 1) ? 0xff : 0;
5134
5135 for (y = rect->top; y < rect->bottom; y++)
5136 {
5137 for (x = 0, pos = (dib->rect.left + rect->left) & 7; x < rect->right - rect->left; x++, pos++)
5138 {
5139 /* no antialiasing, glyph should only contain 0 or 16. */
5140 if (glyph_ptr[x] >= 16)
5141 dst_ptr[pos / 8] = (dst_ptr[pos / 8] & ~pixel_masks_1[pos % 8]) |
5142 (text & pixel_masks_1[pos % 8]);
5143 }
5144 dst_ptr += dib->stride;
5145 glyph_ptr += glyph->stride;
5146 }
5147 }
5148
5149 static void draw_glyph_null( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5150 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
5151 {
5152 return;
5153 }
5154
5155 static inline DWORD blend_subpixel( BYTE r, BYTE g, BYTE b, DWORD text, DWORD alpha )
5156 {
5157 return blend_color( r, text >> 16, (BYTE)(alpha >> 16) ) << 16 |
5158 blend_color( g, text >> 8, (BYTE)(alpha >> 8) ) << 8 |
5159 blend_color( b, text, (BYTE) alpha );
5160 }
5161
5162 static void draw_subpixel_glyph_8888( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5163 const POINT *origin, DWORD text_pixel )
5164 {
5165 DWORD *dst_ptr = get_pixel_ptr_32( dib, rect->left, rect->top );
5166 const DWORD *glyph_ptr = get_pixel_ptr_32( glyph, origin->x, origin->y );
5167 int x, y;
5168
5169 for (y = rect->top; y < rect->bottom; y++)
5170 {
5171 for (x = 0; x < rect->right - rect->left; x++)
5172 {
5173 if (glyph_ptr[x] == 0) continue;
5174 dst_ptr[x] = blend_subpixel( dst_ptr[x] >> 16, dst_ptr[x] >> 8, dst_ptr[x], text_pixel, glyph_ptr[x] );
5175 }
5176 dst_ptr += dib->stride / 4;
5177 glyph_ptr += glyph->stride / 4;
5178 }
5179 }
5180
5181 static void draw_subpixel_glyph_32( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5182 const POINT *origin, DWORD text_pixel )
5183 {
5184 DWORD *dst_ptr = get_pixel_ptr_32( dib, rect->left, rect->top );
5185 const DWORD *glyph_ptr = get_pixel_ptr_32( glyph, origin->x, origin->y );
5186 int x, y;
5187 DWORD text, val;
5188
5189 text = get_field( text_pixel, dib->red_shift, dib->red_len ) << 16 |
5190 get_field( text_pixel, dib->green_shift, dib->green_len ) << 8 |
5191 get_field( text_pixel, dib->blue_shift, dib->blue_len );
5192
5193 for (y = rect->top; y < rect->bottom; y++)
5194 {
5195 for (x = 0; x < rect->right - rect->left; x++)
5196 {
5197 if (glyph_ptr[x] == 0) continue;
5198 val = blend_subpixel( get_field(dst_ptr[x], dib->red_shift, dib->red_len),
5199 get_field(dst_ptr[x], dib->green_shift, dib->green_len),
5200 get_field(dst_ptr[x], dib->blue_shift, dib->blue_len),
5201 text, glyph_ptr[x] );
5202 dst_ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
5203 put_field( val >> 8, dib->green_shift, dib->green_len ) |
5204 put_field( val, dib->blue_shift, dib->blue_len ));
5205 }
5206 dst_ptr += dib->stride / 4;
5207 glyph_ptr += glyph->stride / 4;
5208 }
5209 }
5210
5211 static void draw_subpixel_glyph_24( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5212 const POINT *origin, DWORD text_pixel )
5213 {
5214 BYTE *dst_ptr = get_pixel_ptr_24( dib, rect->left, rect->top );
5215 const DWORD *glyph_ptr = get_pixel_ptr_32( glyph, origin->x, origin->y );
5216 int x, y;
5217 DWORD val;
5218
5219 for (y = rect->top; y < rect->bottom; y++)
5220 {
5221 for (x = 0; x < rect->right - rect->left; x++)
5222 {
5223 if (glyph_ptr[x] == 0) continue;
5224 val = blend_subpixel( dst_ptr[x * 3 + 2], dst_ptr[x * 3 + 1], dst_ptr[x * 3],
5225 text_pixel, glyph_ptr[x] );
5226 dst_ptr[x * 3] = val;
5227 dst_ptr[x * 3 + 1] = val >> 8;
5228 dst_ptr[x * 3 + 2] = val >> 16;
5229 }
5230 dst_ptr += dib->stride;
5231 glyph_ptr += glyph->stride / 4;
5232 }
5233 }
5234
5235 static void draw_subpixel_glyph_555( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5236 const POINT *origin, DWORD text_pixel )
5237 {
5238 WORD *dst_ptr = get_pixel_ptr_16( dib, rect->left, rect->top );
5239 const DWORD *glyph_ptr = get_pixel_ptr_32( glyph, origin->x, origin->y );
5240 int x, y;
5241 DWORD text, val;
5242
5243 text = ((text_pixel << 9) & 0xf80000) | ((text_pixel << 4) & 0x070000) |
5244 ((text_pixel << 6) & 0x00f800) | ((text_pixel << 1) & 0x000700) |
5245 ((text_pixel << 3) & 0x0000f8) | ((text_pixel >> 2) & 0x000007);
5246
5247 for (y = rect->top; y < rect->bottom; y++)
5248 {
5249 for (x = 0; x < rect->right - rect->left; x++)
5250 {
5251 if (glyph_ptr[x] == 0) continue;
5252 val = blend_subpixel( ((dst_ptr[x] >> 7) & 0xf8) | ((dst_ptr[x] >> 12) & 0x07),
5253 ((dst_ptr[x] >> 2) & 0xf8) | ((dst_ptr[x] >> 7) & 0x07),
5254 ((dst_ptr[x] << 3) & 0xf8) | ((dst_ptr[x] >> 2) & 0x07),
5255 text, glyph_ptr[x] );
5256 dst_ptr[x] = ((val >> 9) & 0x7c00) | ((val >> 6) & 0x03e0) | ((val >> 3) & 0x001f);
5257 }
5258 dst_ptr += dib->stride / 2;
5259 glyph_ptr += glyph->stride / 4;
5260 }
5261 }
5262
5263 static void draw_subpixel_glyph_16( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5264 const POINT *origin, DWORD text_pixel )
5265 {
5266 WORD *dst_ptr = get_pixel_ptr_16( dib, rect->left, rect->top );
5267 const DWORD *glyph_ptr = get_pixel_ptr_32( glyph, origin->x, origin->y );
5268 int x, y;
5269 DWORD text, val;
5270
5271 text = get_field( text_pixel, dib->red_shift, dib->red_len ) << 16 |
5272 get_field( text_pixel, dib->green_shift, dib->green_len ) << 8 |
5273 get_field( text_pixel, dib->blue_shift, dib->blue_len );
5274
5275 for (y = rect->top; y < rect->bottom; y++)
5276 {
5277 for (x = 0; x < rect->right - rect->left; x++)
5278 {
5279 if (glyph_ptr[x] == 0) continue;
5280 val = blend_subpixel( get_field(dst_ptr[x], dib->red_shift, dib->red_len),
5281 get_field(dst_ptr[x], dib->green_shift, dib->green_len),
5282 get_field(dst_ptr[x], dib->blue_shift, dib->blue_len),
5283 text, glyph_ptr[x] );
5284 dst_ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
5285 put_field( val >> 8, dib->green_shift, dib->green_len ) |
5286 put_field( val, dib->blue_shift, dib->blue_len ));
5287 }
5288 dst_ptr += dib->stride / 2;
5289 glyph_ptr += glyph->stride / 4;
5290 }
5291 }
5292
5293 static void draw_subpixel_glyph_null( const dib_info *dib, const RECT *rect, const dib_info *glyph,
5294 const POINT *origin, DWORD text_pixel )
5295 {
5296 return;
5297 }
5298
5299 static void create_rop_masks_32(const dib_info *dib, const BYTE *hatch_ptr,
5300 const rop_mask *fg, const rop_mask *bg, rop_mask_bits *bits)
5301 {
5302 DWORD *and_bits = bits->and, *xor_bits = bits->xor;
5303 int x, y;
5304
5305 /* masks are always 8x8 */
5306 assert( dib->width == 8 );
5307 assert( dib->height == 8 );
5308
5309 for(y = 0; y < 8; y++, hatch_ptr++)
5310 {
5311 for(x = 0; x < 8; x++)
5312 {
5313 if(*hatch_ptr & pixel_masks_1[x])
5314 {
5315 and_bits[x] = fg->and;
5316 xor_bits[x] = fg->xor;
5317 }
5318 else
5319 {
5320 and_bits[x] = bg->and;
5321 xor_bits[x] = bg->xor;
5322 }
5323 }
5324 and_bits += dib->stride / 4;
5325 xor_bits += dib->stride / 4;
5326 }
5327 }
5328
5329 static void create_rop_masks_24(const dib_info *dib, const BYTE *hatch_ptr,
5330 const rop_mask *fg, const rop_mask *bg, rop_mask_bits *bits)
5331 {
5332 DWORD mask_start = 0, mask_offset;
5333 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
5334 int x, y;
5335
5336 /* masks are always 8x8 */
5337 assert( dib->width == 8 );
5338 assert( dib->height == 8 );
5339
5340 for(y = 0; y < 8; y++, hatch_ptr++)
5341 {
5342 mask_offset = mask_start;
5343 for(x = 0; x < 8; x++)
5344 {
5345 if(*hatch_ptr & pixel_masks_1[x])
5346 {
5347 and_bits[mask_offset] = fg->and & 0xff;
5348 xor_bits[mask_offset++] = fg->xor & 0xff;
5349 and_bits[mask_offset] = (fg->and >> 8) & 0xff;
5350 xor_bits[mask_offset++] = (fg->xor >> 8) & 0xff;
5351 and_bits[mask_offset] = (fg->and >> 16) & 0xff;
5352 xor_bits[mask_offset++] = (fg->xor >> 16) & 0xff;
5353 }
5354 else
5355 {
5356 and_bits[mask_offset] = bg->and & 0xff;
5357 xor_bits[mask_offset++] = bg->xor & 0xff;
5358 and_bits[mask_offset] = (bg->and >> 8) & 0xff;
5359 xor_bits[mask_offset++] = (bg->xor >> 8) & 0xff;
5360 and_bits[mask_offset] = (bg->and >> 16) & 0xff;
5361 xor_bits[mask_offset++] = (bg->xor >> 16) & 0xff;
5362 }
5363 }
5364 mask_start += dib->stride;
5365 }
5366 }
5367
5368 static void create_rop_masks_16(const dib_info *dib, const BYTE *hatch_ptr,
5369 const rop_mask *fg, const rop_mask *bg, rop_mask_bits *bits)
5370 {
5371 WORD *and_bits = bits->and, *xor_bits = bits->xor;
5372 int x, y;
5373
5374 /* masks are always 8x8 */
5375 assert( dib->width == 8 );
5376 assert( dib->height == 8 );
5377
5378 for(y = 0; y < 8; y++, hatch_ptr++)
5379 {
5380 for(x = 0; x < 8; x++)
5381 {
5382 if(*hatch_ptr & pixel_masks_1[x])
5383 {
5384 and_bits[x] = fg->and;
5385 xor_bits[x] = fg->xor;
5386 }
5387 else
5388 {
5389 and_bits[x] = bg->and;
5390 xor_bits[x] = bg->xor;
5391 }
5392 }
5393 and_bits += dib->stride / 2;
5394 xor_bits += dib->stride / 2;
5395 }
5396 }
5397
5398 static void create_rop_masks_8(const dib_info *dib, const BYTE *hatch_ptr,
5399 const rop_mask *fg, const rop_mask *bg, rop_mask_bits *bits)
5400 {
5401 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
5402 int x, y;
5403
5404 /* masks are always 8x8 */
5405 assert( dib->width == 8 );
5406 assert( dib->height == 8 );
5407
5408 for(y = 0; y < 8; y++, hatch_ptr++)
5409 {
5410 for(x = 0; x < 8; x++)
5411 {
5412 if(*hatch_ptr & pixel_masks_1[x])
5413 {
5414 and_bits[x] = fg->and;
5415 xor_bits[x] = fg->xor;
5416 }
5417 else
5418 {
5419 and_bits[x] = bg->and;
5420 xor_bits[x] = bg->xor;
5421 }
5422 }
5423 and_bits += dib->stride;
5424 xor_bits += dib->stride;
5425 }
5426 }
5427
5428 static void create_rop_masks_4(const dib_info *dib, const BYTE *hatch_ptr,
5429 const rop_mask *fg, const rop_mask *bg, rop_mask_bits *bits)
5430 {
5431 DWORD mask_offset;
5432 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
5433 const rop_mask *rop_mask;
5434 int x, y;
5435
5436 /* masks are always 8x8 */
5437 assert( dib->width == 8 );
5438 assert( dib->height == 8 );
5439
5440 for(y = 0; y < 8; y++, hatch_ptr++)
5441 {
5442 for(x = mask_offset = 0; x < 8; x++)
5443 {
5444 if(*hatch_ptr & pixel_masks_1[x])
5445 rop_mask = fg;
5446 else
5447 rop_mask = bg;
5448
5449 if(x & 1)
5450 {
5451 and_bits[mask_offset] |= (rop_mask->and & 0x0f);
5452 xor_bits[mask_offset] |= (rop_mask->xor & 0x0f);
5453 mask_offset++;
5454 }
5455 else
5456 {
5457 and_bits[mask_offset] = (rop_mask->and << 4) & 0xf0;
5458 xor_bits[mask_offset] = (rop_mask->xor << 4) & 0xf0;
5459 }
5460 }
5461 and_bits += dib->stride;
5462 xor_bits += dib->stride;
5463 }
5464 }
5465
5466 static void create_rop_masks_1(const dib_info *dib, const BYTE *hatch_ptr,
5467 const rop_mask *fg, const rop_mask *bg, rop_mask_bits *bits)
5468 {
5469 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
5470 rop_mask rop_mask;
5471 int x, y;
5472
5473 /* masks are always 8x8 */
5474 assert( dib->width == 8 );
5475 assert( dib->height == 8 );
5476
5477 for(y = 0; y < 8; y++, hatch_ptr++)
5478 {
5479 *and_bits = *xor_bits = 0;
5480 for(x = 0; x < 8; x++)
5481 {
5482 if(*hatch_ptr & pixel_masks_1[x])
5483 {
5484 rop_mask.and = (fg->and & 1) ? 0xff : 0;
5485 rop_mask.xor = (fg->xor & 1) ? 0xff : 0;
5486 }
5487 else
5488 {
5489 rop_mask.and = (bg->and & 1) ? 0xff : 0;
5490 rop_mask.xor = (bg->xor & 1) ? 0xff : 0;
5491 }
5492 *and_bits |= (rop_mask.and & pixel_masks_1[x]);
5493 *xor_bits |= (rop_mask.xor & pixel_masks_1[x]);
5494 }
5495 and_bits += dib->stride;
5496 xor_bits += dib->stride;
5497 }
5498 }
5499
5500 static void create_rop_masks_null(const dib_info *dib, const BYTE *hatch_ptr,
5501 const rop_mask *fg, const rop_mask *bg, rop_mask_bits *bits)
5502 {
5503 }
5504
5505 static void create_dither_masks_8(const dib_info *dib, int rop2, COLORREF color, rop_mask_bits *bits)
5506 {
5507 /* mapping between RGB triples and the default color table */
5508 static const BYTE mapping[27] =
5509 {
5510 0, /* 000000 -> 000000 */
5511 4, /* 00007f -> 000080 */
5512 252, /* 0000ff -> 0000ff */
5513 2, /* 007f00 -> 008000 */
5514 6, /* 007f7f -> 008080 */
5515 224, /* 007fff -> 0080c0 */
5516 250, /* 00ff00 -> 00ff00 */
5517 184, /* 00ff7f -> 00e080 */
5518 254, /* 00ffff -> 00ffff */
5519 1, /* 7f0000 -> 800000 */
5520 5, /* 7f007f -> 800080 */
5521 196, /* 7f00ff -> 8000c0 */
5522 3, /* 7f7f00 -> 808000 */
5523 248, /* 7f7f7f -> 808080 */
5524 228, /* 7f7fff -> 8080c0 */
5525 60, /* 7fff00 -> 80e000 */
5526 188, /* 7fff7f -> 80e080 */
5527 244, /* 7fffff -> 80c0c0 */
5528 249, /* ff0000 -> ff0000 */
5529 135, /* ff007f -> e00080 */
5530 253, /* ff00ff -> ff00ff */
5531 39, /* ff7f00 -> e08000 */
5532 167, /* ff7f7f -> e08080 */
5533 231, /* ff7fff -> e080c0 */
5534 251, /* ffff00 -> ffff00 */
5535 191, /* ffff7f -> e0e080 */
5536 255 /* ffffff -> ffffff */
5537 };
5538
5539 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
5540 struct rop_codes codes;
5541 int x, y;
5542
5543 /* masks are always 8x8 */
5544 assert( dib->width == 8 );
5545 assert( dib->height == 8 );
5546
5547 get_rop_codes( rop2, &codes );
5548
5549 for (y = 0; y < 8; y++)
5550 {
5551 for (x = 0; x < 8; x++)
5552 {
5553 DWORD r = ((GetRValue(color) + 1) / 2 + bayer_8x8[y][x]) / 64;
5554 DWORD g = ((GetGValue(color) + 1) / 2 + bayer_8x8[y][x]) / 64;
5555 DWORD b = ((GetBValue(color) + 1) / 2 + bayer_8x8[y][x]) / 64;
5556 DWORD pixel = mapping[r * 9 + g * 3 + b];
5557 and_bits[x] = (pixel & codes.a1) ^ codes.a2;
5558 xor_bits[x] = (pixel & codes.x1) ^ codes.x2;
5559 }
5560 and_bits += dib->stride;
5561 xor_bits += dib->stride;
5562 }
5563 }
5564
5565 static void create_dither_masks_4(const dib_info *dib, int rop2, COLORREF color, rop_mask_bits *bits)
5566 {
5567 /* mapping between RGB triples and the default color table */
5568 static const BYTE mapping[27] =
5569 {
5570 0, /* 000000 -> 000000 */
5571 4, /* 00007f -> 000080 */
5572 12, /* 0000ff -> 0000ff */
5573 2, /* 007f00 -> 008000 */
5574 6, /* 007f7f -> 008080 */
5575 6, /* 007fff -> 008080 */
5576 10, /* 00ff00 -> 00ff00 */
5577 6, /* 00ff7f -> 008080 */
5578 14, /* 00ffff -> 00ffff */
5579 1, /* 7f0000 -> 800000 */
5580 5, /* 7f007f -> 800080 */
5581 5, /* 7f00ff -> 800080 */
5582 3, /* 7f7f00 -> 808000 */
5583 7, /* 7f7f7f -> 808080 */
5584 8, /* 7f7fff -> c0c0c0 */
5585 3, /* 7fff00 -> 808000 */
5586 8, /* 7fff7f -> c0c0c0 */
5587 8, /* 7fffff -> c0c0c0 */
5588 9, /* ff0000 -> ff0000 */
5589 5, /* ff007f -> 800080 */
5590 13, /* ff00ff -> ff00ff */
5591 3, /* ff7f00 -> 808000 */
5592 8, /* ff7f7f -> c0c0c0 */
5593 8, /* ff7fff -> c0c0c0 */
5594 11, /* ffff00 -> ffff00 */
5595 8, /* ffff7f -> c0c0c0 */
5596 15 /* ffffff -> ffffff */
5597 };
5598
5599 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
5600 struct rop_codes codes;
5601 int x, y;
5602
5603 /* masks are always 8x8 */
5604 assert( dib->width == 8 );
5605 assert( dib->height == 8 );
5606
5607 get_rop_codes( rop2, &codes );
5608
5609 for (y = 0; y < 8; y++)
5610 {
5611 for (x = 0; x < 8; x++)
5612 {
5613 DWORD r = ((GetRValue(color) + 1) / 2 + bayer_8x8[y][x]) / 64;
5614 DWORD g = ((GetGValue(color) + 1) / 2 + bayer_8x8[y][x]) / 64;
5615 DWORD b = ((GetBValue(color) + 1) / 2 + bayer_8x8[y][x]) / 64;
5616 DWORD pixel = mapping[r * 9 + g * 3 + b];
5617 if (x & 1)
5618 {
5619 and_bits[x / 2] |= (pixel & codes.a1) ^ codes.a2;
5620 xor_bits[x / 2] |= (pixel & codes.x1) ^ codes.x2;
5621 }
5622 else
5623 {
5624 and_bits[x / 2] = ((pixel & codes.a1) ^ codes.a2) << 4;
5625 xor_bits[x / 2] = ((pixel & codes.x1) ^ codes.x2) << 4;
5626 }
5627 }
5628 and_bits += dib->stride;
5629 xor_bits += dib->stride;
5630 }
5631 }
5632
5633 static void create_dither_masks_1(const dib_info *dib, int rop2, COLORREF color, rop_mask_bits *bits)
5634 {
5635 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
5636 struct rop_codes codes;
5637 rop_mask rop_mask;
5638 int x, y, grey = (30 * GetRValue(color) + 59 * GetGValue(color) + 11 * GetBValue(color) + 200) / 400;
5639
5640 /* masks are always 8x8 */
5641 assert( dib->width == 8 );
5642 assert( dib->height == 8 );
5643
5644 get_rop_codes( rop2, &codes );
5645
5646 for (y = 0; y < 8; y++)
5647 {
5648 *and_bits = *xor_bits = 0;
5649 for (x = 0; x < 8; x++)
5650 {
5651 if (grey + bayer_8x8[y][x] > 63)
5652 {
5653 rop_mask.and = (0xff & codes.a1) ^ codes.a2;
5654 rop_mask.xor = (0xff & codes.x1) ^ codes.x2;
5655 }
5656 else
5657 {
5658 rop_mask.and = (0x00 & codes.a1) ^ codes.a2;
5659 rop_mask.xor = (0x00 & codes.x1) ^ codes.x2;
5660 }
5661 *and_bits |= (rop_mask.and & pixel_masks_1[x]);
5662 *xor_bits |= (rop_mask.xor & pixel_masks_1[x]);
5663 }
5664 and_bits += dib->stride;
5665 xor_bits += dib->stride;
5666 }
5667 }
5668
5669 static void create_dither_masks_null(const dib_info *dib, int rop2, COLORREF color, rop_mask_bits *bits)
5670 {
5671 }
5672
5673 static inline void rop_codes_from_stretch_mode( int mode, struct rop_codes *codes )
5674 {
5675 switch (mode)
5676 {
5677 default:
5678 case STRETCH_DELETESCANS:
5679 get_rop_codes( R2_COPYPEN, codes );
5680 break;
5681 case STRETCH_ORSCANS:
5682 get_rop_codes( R2_MERGEPEN, codes );
5683 break;
5684 case STRETCH_ANDSCANS:
5685 get_rop_codes( R2_MASKPEN, codes );
5686 break;
5687 }
5688 return;
5689 }
5690
5691 static void stretch_row_32(const dib_info *dst_dib, const POINT *dst_start,
5692 const dib_info *src_dib, const POINT *src_start,
5693 const struct stretch_params *params, int mode,
5694 BOOL keep_dst)
5695 {
5696 DWORD *dst_ptr = get_pixel_ptr_32( dst_dib, dst_start->x, dst_start->y );
5697 DWORD *src_ptr = get_pixel_ptr_32( src_dib, src_start->x, src_start->y );
5698 int err = params->err_start;
5699 int width;
5700
5701 if (mode == STRETCH_DELETESCANS || !keep_dst)
5702 {
5703 for (width = params->length; width; width--)
5704 {
5705 *dst_ptr = *src_ptr;
5706 dst_ptr += params->dst_inc;
5707 if (err > 0)
5708 {
5709 src_ptr += params->src_inc;
5710 err += params->err_add_1;
5711 }
5712 else err += params->err_add_2;
5713 }
5714 }
5715 else
5716 {
5717 struct rop_codes codes;
5718
5719 rop_codes_from_stretch_mode( mode, &codes );
5720 for (width = params->length; width; width--)
5721 {
5722 do_rop_codes_32( dst_ptr, *src_ptr, &codes );
5723 dst_ptr += params->dst_inc;
5724 if (err > 0)
5725 {
5726 src_ptr += params->src_inc;
5727 err += params->err_add_1;
5728 }
5729 else err += params->err_add_2;
5730 }
5731 }
5732 }
5733
5734 static void stretch_row_24(const dib_info *dst_dib, const POINT *dst_start,
5735 const dib_info *src_dib, const POINT *src_start,
5736 const struct stretch_params *params, int mode,
5737 BOOL keep_dst)
5738 {
5739 BYTE *dst_ptr = get_pixel_ptr_24( dst_dib, dst_start->x, dst_start->y );
5740 BYTE *src_ptr = get_pixel_ptr_24( src_dib, src_start->x, src_start->y );
5741 int err = params->err_start;
5742 int width;
5743
5744 if (mode == STRETCH_DELETESCANS || !keep_dst)
5745 {
5746 for (width = params->length; width; width--)
5747 {
5748 dst_ptr[0] = src_ptr[0];
5749 dst_ptr[1] = src_ptr[1];
5750 dst_ptr[2] = src_ptr[2];
5751 dst_ptr += 3 * params->dst_inc;
5752 if (err > 0)
5753 {
5754 src_ptr += 3 * params->src_inc;
5755 err += params->err_add_1;
5756 }
5757 else err += params->err_add_2;
5758 }
5759 }
5760 else
5761 {
5762 struct rop_codes codes;
5763
5764 rop_codes_from_stretch_mode( mode, &codes );
5765 for (width = params->length; width; width--)
5766 {
5767 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
5768 do_rop_codes_8( dst_ptr + 1, *(src_ptr + 1), &codes );
5769 do_rop_codes_8( dst_ptr + 2, *(src_ptr + 2), &codes );
5770 dst_ptr += 3 * params->dst_inc;
5771 if (err > 0)
5772 {
5773 src_ptr += 3 * params->src_inc;
5774 err += params->err_add_1;
5775 }
5776 else err += params->err_add_2;
5777 }
5778 }
5779 }
5780
5781 static void stretch_row_16(const dib_info *dst_dib, const POINT *dst_start,
5782 const dib_info *src_dib, const POINT *src_start,
5783 const struct stretch_params *params, int mode,
5784 BOOL keep_dst)
5785 {
5786 WORD *dst_ptr = get_pixel_ptr_16( dst_dib, dst_start->x, dst_start->y );
5787 WORD *src_ptr = get_pixel_ptr_16( src_dib, src_start->x, src_start->y );
5788 int err = params->err_start;
5789 int width;
5790
5791 if (mode == STRETCH_DELETESCANS || !keep_dst)
5792 {
5793 for (width = params->length; width; width--)
5794 {
5795 *dst_ptr = *src_ptr;
5796 dst_ptr += params->dst_inc;
5797 if (err > 0)
5798 {
5799 src_ptr += params->src_inc;
5800 err += params->err_add_1;
5801 }
5802 else err += params->err_add_2;
5803 }
5804 }
5805 else
5806 {
5807 struct rop_codes codes;
5808
5809 rop_codes_from_stretch_mode( mode, &codes );
5810 for (width = params->length; width; width--)
5811 {
5812 do_rop_codes_16( dst_ptr, *src_ptr, &codes );
5813 dst_ptr += params->dst_inc;
5814 if (err > 0)
5815 {
5816 src_ptr += params->src_inc;
5817 err += params->err_add_1;
5818 }
5819 else err += params->err_add_2;
5820 }
5821 }
5822 }
5823
5824 static void stretch_row_8(const dib_info *dst_dib, const POINT *dst_start,
5825 const dib_info *src_dib, const POINT *src_start,
5826 const struct stretch_params *params, int mode,
5827 BOOL keep_dst)
5828 {
5829 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
5830 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
5831 int err = params->err_start;
5832 int width;
5833
5834 if (mode == STRETCH_DELETESCANS || !keep_dst)
5835 {
5836 for (width = params->length; width; width--)
5837 {
5838 *dst_ptr = *src_ptr;
5839 dst_ptr += params->dst_inc;
5840 if (err > 0)
5841 {
5842 src_ptr += params->src_inc;
5843 err += params->err_add_1;
5844 }
5845 else err += params->err_add_2;
5846 }
5847 }
5848 else
5849 {
5850 struct rop_codes codes;
5851
5852 rop_codes_from_stretch_mode( mode, &codes );
5853 for (width = params->length; width; width--)
5854 {
5855 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
5856 dst_ptr += params->dst_inc;
5857 if (err > 0)
5858 {
5859 src_ptr += params->src_inc;
5860 err += params->err_add_1;
5861 }
5862 else err += params->err_add_2;
5863 }
5864 }
5865 }
5866
5867 static void stretch_row_4(const dib_info *dst_dib, const POINT *dst_start,
5868 const dib_info *src_dib, const POINT *src_start,
5869 const struct stretch_params *params, int mode,
5870 BOOL keep_dst)
5871 {
5872 BYTE *dst_ptr = get_pixel_ptr_4( dst_dib, dst_start->x, dst_start->y );
5873 BYTE *src_ptr = get_pixel_ptr_4( src_dib, src_start->x, src_start->y );
5874 int err = params->err_start;
5875 int width, dst_x = dst_dib->rect.left + dst_start->x, src_x = src_dib->rect.left + src_start->x;
5876 struct rop_codes codes;
5877 BYTE src_val;
5878
5879 if (!keep_dst) mode = STRETCH_DELETESCANS;
5880 rop_codes_from_stretch_mode( mode, &codes );
5881 for (width = params->length; width; width--)
5882 {
5883 if (src_x & 1) src_val = (*src_ptr & 0x0f) | (*src_ptr << 4);
5884 else src_val = (*src_ptr & 0xf0) | (*src_ptr >> 4);
5885
5886 do_rop_codes_mask_8( dst_ptr, src_val, &codes, (dst_x & 1) ? 0x0f : 0xf0 );
5887
5888 if ((dst_x & ~1) != ((dst_x + params->dst_inc) & ~1))
5889 dst_ptr += params->dst_inc;
5890 dst_x += params->dst_inc;
5891
5892 if (err > 0)
5893 {
5894 if ((src_x & ~1) != ((src_x + params->src_inc) & ~1))
5895 src_ptr += params->src_inc;
5896 src_x += params->src_inc;
5897 err += params->err_add_1;
5898 }
5899 else err += params->err_add_2;
5900 }
5901 }
5902
5903 static void stretch_row_1(const dib_info *dst_dib, const POINT *dst_start,
5904 const dib_info *src_dib, const POINT *src_start,
5905 const struct stretch_params *params, int mode,
5906 BOOL keep_dst)
5907 {
5908 BYTE *dst_ptr = get_pixel_ptr_1( dst_dib, dst_start->x, dst_start->y );
5909 BYTE *src_ptr = get_pixel_ptr_1( src_dib, src_start->x, src_start->y );
5910 int err = params->err_start;
5911 int width, dst_x = dst_dib->rect.left + dst_start->x, src_x = src_dib->rect.left + src_start->x;
5912 struct rop_codes codes;
5913 BYTE src_val;
5914
5915 if (!keep_dst) mode = STRETCH_DELETESCANS;
5916 rop_codes_from_stretch_mode( mode, &codes );
5917 for (width = params->length; width; width--)
5918 {
5919 src_val = *src_ptr & pixel_masks_1[src_x % 8] ? 0xff : 0;
5920 do_rop_codes_mask_8( dst_ptr, src_val, &codes, pixel_masks_1[dst_x % 8] );
5921
5922 if ((dst_x & ~7) != ((dst_x + params->dst_inc) & ~7))
5923 dst_ptr += params->dst_inc;
5924 dst_x += params->dst_inc;
5925
5926 if (err > 0)
5927 {
5928 if ((src_x & ~7) != ((src_x + params->src_inc) & ~7))
5929 src_ptr += params->src_inc;
5930 src_x += params->src_inc;
5931 err += params->err_add_1;
5932 }
5933 else err += params->err_add_2;
5934 }
5935 }
5936
5937 static void stretch_row_null(const dib_info *dst_dib, const POINT *dst_start,
5938 const dib_info *src_dib, const POINT *src_start,
5939 const struct stretch_params *params, int mode,
5940 BOOL keep_dst)
5941 {
5942 FIXME("bit count %d\n", dst_dib->bit_count);
5943 return;
5944 }
5945
5946 static void shrink_row_32(const dib_info *dst_dib, const POINT *dst_start,
5947 const dib_info *src_dib, const POINT *src_start,
5948 const struct stretch_params *params, int mode,
5949 BOOL keep_dst)
5950 {
5951 DWORD *dst_ptr = get_pixel_ptr_32( dst_dib, dst_start->x, dst_start->y );
5952 DWORD *src_ptr = get_pixel_ptr_32( src_dib, src_start->x, src_start->y );
5953 int err = params->err_start;
5954 int width;
5955
5956 if (mode == STRETCH_DELETESCANS)
5957 {
5958 for (width = params->length; width; width--)
5959 {
5960 *dst_ptr = *src_ptr;
5961 src_ptr += params->src_inc;
5962 if (err > 0)
5963 {
5964 dst_ptr += params->dst_inc;
5965 err += params->err_add_1;
5966 }
5967 else err += params->err_add_2;
5968 }
5969 }
5970 else
5971 {
5972 struct rop_codes codes;
5973 DWORD init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
5974 BOOL new_pix = TRUE;
5975
5976 rop_codes_from_stretch_mode( mode, &codes );
5977 for (width = params->length; width; width--)
5978 {
5979 if (new_pix && !keep_dst) *dst_ptr = init_val;
5980 do_rop_codes_32( dst_ptr, *src_ptr, &codes );
5981 new_pix = FALSE;
5982 src_ptr += params->src_inc;
5983 if (err > 0)
5984 {
5985 dst_ptr += params->dst_inc;
5986 new_pix = TRUE;
5987 err += params->err_add_1;
5988 }
5989 else err += params->err_add_2;
5990 }
5991 }
5992 }
5993
5994 static void shrink_row_24(const dib_info *dst_dib, const POINT *dst_start,
5995 const dib_info *src_dib, const POINT *src_start,
5996 const struct stretch_params *params, int mode,
5997 BOOL keep_dst)
5998 {
5999 BYTE *dst_ptr = get_pixel_ptr_24( dst_dib, dst_start->x, dst_start->y );
6000 BYTE *src_ptr = get_pixel_ptr_24( src_dib, src_start->x, src_start->y );
6001 int err = params->err_start;
6002 int width;
6003
6004 if (mode == STRETCH_DELETESCANS)
6005 {
6006 for (width = params->length; width; width--)
6007 {
6008 dst_ptr[0] = src_ptr[0];
6009 dst_ptr[1] = src_ptr[1];
6010 dst_ptr[2] = src_ptr[2];
6011 src_ptr += 3 * params->src_inc;
6012 if (err > 0)
6013 {
6014 dst_ptr += 3 * params->dst_inc;
6015 err += params->err_add_1;
6016 }
6017 else err += params->err_add_2;
6018 }
6019 }
6020 else
6021 {
6022 struct rop_codes codes;
6023 BYTE init_val = (mode == STRETCH_ANDSCANS) ? 0xff : 0;
6024 BOOL new_pix = TRUE;
6025
6026 rop_codes_from_stretch_mode( mode, &codes );
6027 for (width = params->length; width; width--)
6028 {
6029 if (new_pix && !keep_dst) memset( dst_ptr, init_val, 3 );
6030 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
6031 do_rop_codes_8( dst_ptr + 1, *(src_ptr + 1), &codes );
6032 do_rop_codes_8( dst_ptr + 2, *(src_ptr + 2), &codes );
6033 new_pix = FALSE;
6034 src_ptr += 3 * params->src_inc;
6035 if (err > 0)
6036 {
6037 dst_ptr += 3 * params->dst_inc;
6038 new_pix = TRUE;
6039 err += params->err_add_1;
6040 }
6041 else err += params->err_add_2;
6042 }
6043 }
6044 }
6045
6046 static void shrink_row_16(const dib_info *dst_dib, const POINT *dst_start,
6047 const dib_info *src_dib, const POINT *src_start,
6048 const struct stretch_params *params, int mode,
6049 BOOL keep_dst)
6050 {
6051 WORD *dst_ptr = get_pixel_ptr_16( dst_dib, dst_start->x, dst_start->y );
6052 WORD *src_ptr = get_pixel_ptr_16( src_dib, src_start->x, src_start->y );
6053 int err = params->err_start;
6054 int width;
6055
6056 if (mode == STRETCH_DELETESCANS)
6057 {
6058 for (width = params->length; width; width--)
6059 {
6060 *dst_ptr = *src_ptr;
6061 src_ptr += params->src_inc;
6062 if (err > 0)
6063 {
6064 dst_ptr += params->dst_inc;
6065 err += params->err_add_1;
6066 }
6067 else err += params->err_add_2;
6068 }
6069 }
6070 else
6071 {
6072 struct rop_codes codes;
6073 WORD init_val = (mode == STRETCH_ANDSCANS) ? 0xffff : 0;
6074 BOOL new_pix = TRUE;
6075
6076 rop_codes_from_stretch_mode( mode, &codes );
6077 for (width = params->length; width; width--)
6078 {
6079 if (new_pix && !keep_dst) *dst_ptr = init_val;
6080 do_rop_codes_16( dst_ptr, *src_ptr, &codes );
6081 new_pix = FALSE;
6082 src_ptr += params->src_inc;
6083 if (err > 0)
6084 {
6085 dst_ptr += params->dst_inc;
6086 new_pix = TRUE;
6087 err += params->err_add_1;
6088 }
6089 else err += params->err_add_2;
6090 }
6091 }
6092 }
6093
6094 static void shrink_row_8(const dib_info *dst_dib, const POINT *dst_start,
6095 const dib_info *src_dib, const POINT *src_start,
6096 const struct stretch_params *params, int mode,
6097 BOOL keep_dst)
6098 {
6099 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
6100 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
6101 int err = params->err_start;
6102 int width;
6103
6104 if (mode == STRETCH_DELETESCANS)
6105 {
6106 for (width = params->length; width; width--)
6107 {
6108 *dst_ptr = *src_ptr;
6109 src_ptr += params->src_inc;
6110 if (err > 0)
6111 {
6112 dst_ptr += params->dst_inc;
6113 err += params->err_add_1;
6114 }
6115 else err += params->err_add_2;
6116 }
6117 }
6118 else
6119 {
6120 struct rop_codes codes;
6121 BYTE init_val = (mode == STRETCH_ANDSCANS) ? 0xff : 0;
6122 BOOL new_pix = TRUE;
6123
6124 rop_codes_from_stretch_mode( mode, &codes );
6125 for (width = params->length; width; width--)
6126 {
6127 if (new_pix && !keep_dst) *dst_ptr = init_val;
6128 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
6129 new_pix = FALSE;
6130 src_ptr += params->src_inc;
6131 if (err > 0)
6132 {
6133 dst_ptr += params->dst_inc;
6134 new_pix = TRUE;
6135 err += params->err_add_1;
6136 }
6137 else err += params->err_add_2;
6138 }
6139 }
6140 }
6141
6142 static void shrink_row_4(const dib_info *dst_dib, const POINT *dst_start,
6143 const dib_info *src_dib, const POINT *src_start,
6144 const struct stretch_params *params, int mode,
6145 BOOL keep_dst)
6146 {
6147 BYTE *dst_ptr = get_pixel_ptr_4( dst_dib, dst_start->x, dst_start->y );
6148 BYTE *src_ptr = get_pixel_ptr_4( src_dib, src_start->x, src_start->y );
6149 int err = params->err_start;
6150 int width, dst_x = dst_dib->rect.left + dst_start->x, src_x = src_dib->rect.left + src_start->x;
6151 struct rop_codes codes;
6152 BYTE src_val, init_val = (mode == STRETCH_ANDSCANS) ? 0xff : 0;
6153 BOOL new_pix = TRUE;
6154
6155 rop_codes_from_stretch_mode( mode, &codes );
6156 for (width = params->length; width; width--)
6157 {
6158 if (new_pix && !keep_dst) do_rop_mask_8( dst_ptr, 0, init_val, (dst_x & 1) ? 0x0f : 0xf0 );
6159
6160 if (src_x & 1) src_val = (*src_ptr & 0x0f) | (*src_ptr << 4);
6161 else src_val = (*src_ptr & 0xf0) | (*src_ptr >> 4);
6162
6163 do_rop_codes_mask_8( dst_ptr, src_val, &codes, (dst_x & 1) ? 0x0f : 0xf0 );
6164 new_pix = FALSE;
6165
6166 if ((src_x & ~1) != ((src_x + params->src_inc) & ~1))
6167 src_ptr += params->src_inc;
6168 src_x += params->src_inc;
6169
6170 if (err > 0)
6171 {
6172 if ((dst_x & ~1) != ((dst_x + params->dst_inc) & ~1))
6173 dst_ptr += params->dst_inc;
6174 dst_x += params->dst_inc;
6175 new_pix = TRUE;
6176 err += params->err_add_1;
6177 }
6178 else err += params->err_add_2;
6179 }
6180 }
6181
6182 static void shrink_row_1(const dib_info *dst_dib, const POINT *dst_start,
6183 const dib_info *src_dib, const POINT *src_start,
6184 const struct stretch_params *params, int mode,
6185 BOOL keep_dst)
6186 {
6187 BYTE *dst_ptr = get_pixel_ptr_1( dst_dib, dst_start->x, dst_start->y );
6188 BYTE *src_ptr = get_pixel_ptr_1( src_dib, src_start->x, src_start->y );
6189 int err = params->err_start;
6190 int width, dst_x = dst_dib->rect.left + dst_start->x, src_x = src_dib->rect.left + src_start->x;
6191 struct rop_codes codes;
6192 BYTE src_val, init_val = (mode == STRETCH_ANDSCANS) ? 0xff : 0;
6193 BOOL new_pix = TRUE;
6194
6195 rop_codes_from_stretch_mode( mode, &codes );
6196 for (width = params->length; width; width--)
6197 {
6198 if (new_pix && !keep_dst) do_rop_mask_8( dst_ptr, 0, init_val, pixel_masks_1[dst_x % 8] );
6199 src_val = *src_ptr & pixel_masks_1[src_x % 8] ? 0xff : 0;
6200 do_rop_codes_mask_8( dst_ptr, src_val, &codes, pixel_masks_1[dst_x % 8] );
6201 new_pix = FALSE;
6202
6203 if ((src_x & ~7) != ((src_x + params->src_inc) & ~7))
6204 src_ptr += params->src_inc;
6205 src_x += params->src_inc;
6206
6207 if (err > 0)
6208 {
6209 if ((dst_x & ~7) != ((dst_x + params->dst_inc) & ~7))
6210 dst_ptr += params->dst_inc;
6211 dst_x += params->dst_inc;
6212 new_pix = TRUE;
6213 err += params->err_add_1;
6214 }
6215 else err += params->err_add_2;
6216 }
6217 }
6218
6219 static void shrink_row_null(const dib_info *dst_dib, const POINT *dst_start,
6220 const dib_info *src_dib, const POINT *src_start,
6221 const struct stretch_params *params, int mode,
6222 BOOL keep_dst)
6223 {
6224 FIXME("bit count %d\n", dst_dib->bit_count);
6225 return;
6226 }
6227
6228 const primitive_funcs funcs_8888 =
6229 {
6230 solid_rects_32,
6231 solid_line_32,
6232 pattern_rects_32,
6233 copy_rect_32,
6234 blend_rect_8888,
6235 gradient_rect_8888,
6236 draw_glyph_8888,
6237 draw_subpixel_glyph_8888,
6238 get_pixel_32,
6239 colorref_to_pixel_888,
6240 pixel_to_colorref_888,
6241 convert_to_8888,
6242 create_rop_masks_32,
6243 create_dither_masks_null,
6244 stretch_row_32,
6245 shrink_row_32
6246 };
6247
6248 const primitive_funcs funcs_32 =
6249 {
6250 solid_rects_32,
6251 solid_line_32,
6252 pattern_rects_32,
6253 copy_rect_32,
6254 blend_rect_32,
6255 gradient_rect_32,
6256 draw_glyph_32,
6257 draw_subpixel_glyph_32,
6258 get_pixel_32,
6259 colorref_to_pixel_masks,
6260 pixel_to_colorref_masks,
6261 convert_to_32,
6262 create_rop_masks_32,
6263 create_dither_masks_null,
6264 stretch_row_32,
6265 shrink_row_32
6266 };
6267
6268 const primitive_funcs funcs_24 =
6269 {
6270 solid_rects_24,
6271 solid_line_24,
6272 pattern_rects_24,
6273 copy_rect_24,
6274 blend_rect_24,
6275 gradient_rect_24,
6276 draw_glyph_24,
6277 draw_subpixel_glyph_24,
6278 get_pixel_24,
6279 colorref_to_pixel_888,
6280 pixel_to_colorref_888,
6281 convert_to_24,
6282 create_rop_masks_24,
6283 create_dither_masks_null,
6284 stretch_row_24,
6285 shrink_row_24
6286 };
6287
6288 const primitive_funcs funcs_555 =
6289 {
6290 solid_rects_16,
6291 solid_line_16,
6292 pattern_rects_16,
6293 copy_rect_16,
6294 blend_rect_555,
6295 gradient_rect_555,
6296 draw_glyph_555,
6297 draw_subpixel_glyph_555,
6298 get_pixel_16,
6299 colorref_to_pixel_555,
6300 pixel_to_colorref_555,
6301 convert_to_555,
6302 create_rop_masks_16,
6303 create_dither_masks_null,
6304 stretch_row_16,
6305 shrink_row_16
6306 };
6307
6308 const primitive_funcs funcs_16 =
6309 {
6310 solid_rects_16,
6311 solid_line_16,
6312 pattern_rects_16,
6313 copy_rect_16,
6314 blend_rect_16,
6315 gradient_rect_16,
6316 draw_glyph_16,
6317 draw_subpixel_glyph_16,
6318 get_pixel_16,
6319 colorref_to_pixel_masks,
6320 pixel_to_colorref_masks,
6321 convert_to_16,
6322 create_rop_masks_16,
6323 create_dither_masks_null,
6324 stretch_row_16,
6325 shrink_row_16
6326 };
6327
6328 const primitive_funcs funcs_8 =
6329 {
6330 solid_rects_8,
6331 solid_line_8,
6332 pattern_rects_8,
6333 copy_rect_8,
6334 blend_rect_8,
6335 gradient_rect_8,
6336 draw_glyph_8,
6337 draw_subpixel_glyph_null,
6338 get_pixel_8,
6339 colorref_to_pixel_colortable,
6340 pixel_to_colorref_colortable,
6341 convert_to_8,
6342 create_rop_masks_8,
6343 create_dither_masks_8,
6344 stretch_row_8,
6345 shrink_row_8
6346 };
6347
6348 const primitive_funcs funcs_4 =
6349 {
6350 solid_rects_4,
6351 solid_line_4,
6352 pattern_rects_4,
6353 copy_rect_4,
6354 blend_rect_4,
6355 gradient_rect_4,
6356 draw_glyph_4,
6357 draw_subpixel_glyph_null,
6358 get_pixel_4,
6359 colorref_to_pixel_colortable,
6360 pixel_to_colorref_colortable,
6361 convert_to_4,
6362 create_rop_masks_4,
6363 create_dither_masks_4,
6364 stretch_row_4,
6365 shrink_row_4
6366 };
6367
6368 const primitive_funcs funcs_1 =
6369 {
6370 solid_rects_1,
6371 solid_line_1,
6372 pattern_rects_1,
6373 copy_rect_1,
6374 blend_rect_1,
6375 gradient_rect_1,
6376 draw_glyph_1,
6377 draw_subpixel_glyph_null,
6378 get_pixel_1,
6379 colorref_to_pixel_colortable,
6380 pixel_to_colorref_colortable,
6381 convert_to_1,
6382 create_rop_masks_1,
6383 create_dither_masks_1,
6384 stretch_row_1,
6385 shrink_row_1
6386 };
6387
6388 const primitive_funcs funcs_null =
6389 {
6390 solid_rects_null,
6391 solid_line_null,
6392 pattern_rects_null,
6393 copy_rect_null,
6394 blend_rect_null,
6395 gradient_rect_null,
6396 draw_glyph_null,
6397 draw_subpixel_glyph_null,
6398 get_pixel_null,
6399 colorref_to_pixel_null,
6400 pixel_to_colorref_null,
6401 convert_to_null,
6402 create_rop_masks_null,
6403 create_dither_masks_null,
6404 stretch_row_null,
6405 shrink_row_null
6406 };
Maarten's multimedia branch