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