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