?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Implement triangular gradients in the DIB engine.
[wine/multimedia.git] / dlls / gdi32 / dibdrv / primitives.c
blob47ba0e1a40bb5ed8cc3657006f46f36c92463600
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, const POINT *pt)
1280 {
1281 DWORD *ptr = get_pixel_ptr_32( dib, pt->x, pt->y );
1282 return *ptr;
1283 }
1284
1285 static DWORD get_pixel_24(const dib_info *dib, const POINT *pt)
1286 {
1287 BYTE *ptr = get_pixel_ptr_24( dib, pt->x, pt->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, const POINT *pt)
1292 {
1293 WORD *ptr = get_pixel_ptr_16( dib, pt->x, pt->y );
1294 return *ptr;
1295 }
1296
1297 static DWORD get_pixel_8(const dib_info *dib, const POINT *pt)
1298 {
1299 BYTE *ptr = get_pixel_ptr_8( dib, pt->x, pt->y );
1300 return *ptr;
1301 }
1302
1303 static DWORD get_pixel_4(const dib_info *dib, const POINT *pt)
1304 {
1305 BYTE *ptr = get_pixel_ptr_4( dib, pt->x, pt->y );
1306
1307 if (pt->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, const POINT *pt)
1314 {
1315 BYTE *ptr = get_pixel_ptr_1( dib, pt->x, pt->y );
1316 return (*ptr & pixel_masks_1[pt->x & 0x7]) ? 1 : 0;
1317 }
1318
1319 static DWORD get_pixel_null(const dib_info *dib, const POINT *pt)
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 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 inline RGBQUAD colortable_entry(const dib_info *dib, DWORD index)
1425 {
1426 static const RGBQUAD default_rgb;
1427 if (index < dib->color_table_size) return dib->color_table[index];
1428 return default_rgb;
1429 }
1430
1431 static COLORREF pixel_to_colorref_888(const dib_info *dib, DWORD pixel)
1432 {
1433 return ( ((pixel >> 16) & 0xff) | (pixel & 0xff00) | ((pixel << 16) & 0xff0000) );
1434 }
1435
1436 static COLORREF pixel_to_colorref_masks(const dib_info *dib, DWORD pixel)
1437 {
1438 return RGB( get_field( pixel, dib->red_shift, dib->red_len ),
1439 get_field( pixel, dib->green_shift, dib->green_len ),
1440 get_field( pixel, dib->blue_shift, dib->blue_len ) );
1441 }
1442
1443 static COLORREF pixel_to_colorref_555(const dib_info *dib, DWORD pixel)
1444 {
1445 return RGB( ((pixel >> 7) & 0xf8) | ((pixel >> 12) & 0x07),
1446 ((pixel >> 2) & 0xf8) | ((pixel >> 7) & 0x07),
1447 ((pixel << 3) & 0xf8) | ((pixel >> 2) & 0x07) );
1448 }
1449
1450 static COLORREF pixel_to_colorref_colortable(const dib_info *dib, DWORD pixel)
1451 {
1452 RGBQUAD quad = colortable_entry( dib, pixel );
1453
1454 return RGB( quad.rgbRed, quad.rgbGreen, quad.rgbBlue );
1455 }
1456
1457 static COLORREF pixel_to_colorref_null(const dib_info *dib, DWORD pixel)
1458 {
1459 return 0;
1460 }
1461
1462 static inline BOOL bit_fields_match(const dib_info *d1, const dib_info *d2)
1463 {
1464 assert( d1->bit_count > 8 && d1->bit_count == d2->bit_count );
1465
1466 return d1->red_mask == d2->red_mask &&
1467 d1->green_mask == d2->green_mask &&
1468 d1->blue_mask == d2->blue_mask;
1469 }
1470
1471 static void convert_to_8888(dib_info *dst, const dib_info *src, const RECT *src_rect)
1472 {
1473 DWORD *dst_start = get_pixel_ptr_32(dst, 0, 0), *dst_pixel, src_val;
1474 int x, y, pad_size = (dst->width - (src_rect->right - src_rect->left)) * 4;
1475
1476 switch(src->bit_count)
1477 {
1478 case 32:
1479 {
1480 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1481 if(src->funcs == &funcs_8888)
1482 {
1483 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
1484 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
1485 else
1486 {
1487 for(y = src_rect->top; y < src_rect->bottom; y++)
1488 {
1489 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 4);
1490 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
1491 dst_start += dst->stride / 4;
1492 src_start += src->stride / 4;
1493 }
1494 }
1495 }
1496 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
1497 {
1498 for(y = src_rect->top; y < src_rect->bottom; y++)
1499 {
1500 dst_pixel = dst_start;
1501 src_pixel = src_start;
1502 for(x = src_rect->left; x < src_rect->right; x++)
1503 {
1504 src_val = *src_pixel++;
1505 *dst_pixel++ = (((src_val >> src->red_shift) & 0xff) << 16) |
1506 (((src_val >> src->green_shift) & 0xff) << 8) |
1507 ((src_val >> src->blue_shift) & 0xff);
1508 }
1509 if(pad_size) memset(dst_pixel, 0, pad_size);
1510 dst_start += dst->stride / 4;
1511 src_start += src->stride / 4;
1512 }
1513 }
1514 else
1515 {
1516 for(y = src_rect->top; y < src_rect->bottom; y++)
1517 {
1518 dst_pixel = dst_start;
1519 src_pixel = src_start;
1520 for(x = src_rect->left; x < src_rect->right; x++)
1521 {
1522 src_val = *src_pixel++;
1523 *dst_pixel++ = (get_field( src_val, src->red_shift, src->red_len ) << 16 |
1524 get_field( src_val, src->green_shift, src->green_len ) << 8 |
1525 get_field( src_val, src->blue_shift, src->blue_len ));
1526 }
1527 if(pad_size) memset(dst_pixel, 0, pad_size);
1528 dst_start += dst->stride / 4;
1529 src_start += src->stride / 4;
1530 }
1531 }
1532 break;
1533 }
1534
1535 case 24:
1536 {
1537 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
1538
1539 for(y = src_rect->top; y < src_rect->bottom; y++)
1540 {
1541 dst_pixel = dst_start;
1542 src_pixel = src_start;
1543 for(x = src_rect->left; x < src_rect->right; x++)
1544 {
1545 RGBQUAD rgb;
1546 rgb.rgbBlue = *src_pixel++;
1547 rgb.rgbGreen = *src_pixel++;
1548 rgb.rgbRed = *src_pixel++;
1549
1550 *dst_pixel++ = ((rgb.rgbRed << 16) & 0xff0000) | ((rgb.rgbGreen << 8) & 0x00ff00) | (rgb.rgbBlue & 0x0000ff);
1551 }
1552 if(pad_size) memset(dst_pixel, 0, pad_size);
1553 dst_start += dst->stride / 4;
1554 src_start += src->stride;
1555 }
1556 break;
1557 }
1558
1559 case 16:
1560 {
1561 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
1562 if(src->funcs == &funcs_555)
1563 {
1564 for(y = src_rect->top; y < src_rect->bottom; y++)
1565 {
1566 dst_pixel = dst_start;
1567 src_pixel = src_start;
1568 for(x = src_rect->left; x < src_rect->right; x++)
1569 {
1570 src_val = *src_pixel++;
1571 *dst_pixel++ = ((src_val << 9) & 0xf80000) | ((src_val << 4) & 0x070000) |
1572 ((src_val << 6) & 0x00f800) | ((src_val << 1) & 0x000700) |
1573 ((src_val << 3) & 0x0000f8) | ((src_val >> 2) & 0x000007);
1574 }
1575 if(pad_size) memset(dst_pixel, 0, pad_size);
1576 dst_start += dst->stride / 4;
1577 src_start += src->stride / 2;
1578 }
1579 }
1580 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
1581 {
1582 for(y = src_rect->top; y < src_rect->bottom; y++)
1583 {
1584 dst_pixel = dst_start;
1585 src_pixel = src_start;
1586 for(x = src_rect->left; x < src_rect->right; x++)
1587 {
1588 src_val = *src_pixel++;
1589 *dst_pixel++ = (((src_val >> src->red_shift) << 19) & 0xf80000) |
1590 (((src_val >> src->red_shift) << 14) & 0x070000) |
1591 (((src_val >> src->green_shift) << 11) & 0x00f800) |
1592 (((src_val >> src->green_shift) << 6) & 0x000700) |
1593 (((src_val >> src->blue_shift) << 3) & 0x0000f8) |
1594 (((src_val >> src->blue_shift) >> 2) & 0x000007);
1595 }
1596 if(pad_size) memset(dst_pixel, 0, pad_size);
1597 dst_start += dst->stride / 4;
1598 src_start += src->stride / 2;
1599 }
1600 }
1601 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
1602 {
1603 for(y = src_rect->top; y < src_rect->bottom; y++)
1604 {
1605 dst_pixel = dst_start;
1606 src_pixel = src_start;
1607 for(x = src_rect->left; x < src_rect->right; x++)
1608 {
1609 src_val = *src_pixel++;
1610 *dst_pixel++ = (((src_val >> src->red_shift) << 19) & 0xf80000) |
1611 (((src_val >> src->red_shift) << 14) & 0x070000) |
1612 (((src_val >> src->green_shift) << 10) & 0x00fc00) |
1613 (((src_val >> src->green_shift) << 4) & 0x000300) |
1614 (((src_val >> src->blue_shift) << 3) & 0x0000f8) |
1615 (((src_val >> src->blue_shift) >> 2) & 0x000007);
1616 }
1617 if(pad_size) memset(dst_pixel, 0, pad_size);
1618 dst_start += dst->stride / 4;
1619 src_start += src->stride / 2;
1620 }
1621 }
1622 else
1623 {
1624 for(y = src_rect->top; y < src_rect->bottom; y++)
1625 {
1626 dst_pixel = dst_start;
1627 src_pixel = src_start;
1628 for(x = src_rect->left; x < src_rect->right; x++)
1629 {
1630 src_val = *src_pixel++;
1631 *dst_pixel++ = (get_field( src_val, src->red_shift, src->red_len ) << 16 |
1632 get_field( src_val, src->green_shift, src->green_len ) << 8 |
1633 get_field( src_val, src->blue_shift, src->blue_len ));
1634 }
1635 if(pad_size) memset(dst_pixel, 0, pad_size);
1636 dst_start += dst->stride / 4;
1637 src_start += src->stride / 2;
1638 }
1639 }
1640 break;
1641 }
1642
1643 case 8:
1644 {
1645 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
1646 for(y = src_rect->top; y < src_rect->bottom; y++)
1647 {
1648 dst_pixel = dst_start;
1649 src_pixel = src_start;
1650 for(x = src_rect->left; x < src_rect->right; x++)
1651 {
1652 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
1653 *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
1654 }
1655 if(pad_size) memset(dst_pixel, 0, pad_size);
1656 dst_start += dst->stride / 4;
1657 src_start += src->stride;
1658 }
1659 break;
1660 }
1661
1662 case 4:
1663 {
1664 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
1665 for(y = src_rect->top; y < src_rect->bottom; y++)
1666 {
1667 dst_pixel = dst_start;
1668 src_pixel = src_start;
1669 for(x = src_rect->left; x < src_rect->right; x++)
1670 {
1671 RGBQUAD rgb;
1672 if(x & 1)
1673 rgb = colortable_entry( src, *src_pixel++ & 0xf );
1674 else
1675 rgb = colortable_entry( src, *src_pixel >> 4 );
1676 *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
1677 }
1678 if(pad_size) memset(dst_pixel, 0, pad_size);
1679 dst_start += dst->stride / 4;
1680 src_start += src->stride;
1681 }
1682 break;
1683 }
1684
1685 case 1:
1686 {
1687 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
1688 for(y = src_rect->top; y < src_rect->bottom; y++)
1689 {
1690 dst_pixel = dst_start;
1691 src_pixel = src_start;
1692 for(x = src_rect->left; x < src_rect->right; x++)
1693 {
1694 RGBQUAD rgb;
1695 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
1696 if((x % 8) == 7) src_pixel++;
1697 rgb = src->color_table[src_val];
1698 *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
1699 }
1700 if(pad_size) memset(dst_pixel, 0, pad_size);
1701 dst_start += dst->stride / 4;
1702 src_start += src->stride;
1703 }
1704 break;
1705 }
1706 }
1707 }
1708
1709 static void convert_to_32(dib_info *dst, const dib_info *src, const RECT *src_rect)
1710 {
1711 DWORD *dst_start = get_pixel_ptr_32(dst, 0, 0), *dst_pixel, src_val;
1712 int x, y, pad_size = (dst->width - (src_rect->right - src_rect->left)) * 4;
1713
1714 switch(src->bit_count)
1715 {
1716 case 32:
1717 {
1718 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1719
1720 if(src->funcs == &funcs_8888)
1721 {
1722 for(y = src_rect->top; y < src_rect->bottom; y++)
1723 {
1724 dst_pixel = dst_start;
1725 src_pixel = src_start;
1726 for(x = src_rect->left; x < src_rect->right; x++)
1727 {
1728 src_val = *src_pixel++;
1729 *dst_pixel++ = put_field(src_val >> 16, dst->red_shift, dst->red_len) |
1730 put_field(src_val >> 8, dst->green_shift, dst->green_len) |
1731 put_field(src_val, dst->blue_shift, dst->blue_len);
1732 }
1733 if(pad_size) memset(dst_pixel, 0, pad_size);
1734 dst_start += dst->stride / 4;
1735 src_start += src->stride / 4;
1736 }
1737 }
1738 else if(bit_fields_match(src, dst))
1739 {
1740 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
1741 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
1742 else
1743 {
1744 for(y = src_rect->top; y < src_rect->bottom; y++)
1745 {
1746 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 4);
1747 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
1748 dst_start += dst->stride / 4;
1749 src_start += src->stride / 4;
1750 }
1751 }
1752 }
1753 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8 &&
1754 dst->red_len == 8 && dst->green_len == 8 && dst->blue_len == 8)
1755 {
1756 for(y = src_rect->top; y < src_rect->bottom; y++)
1757 {
1758 dst_pixel = dst_start;
1759 src_pixel = src_start;
1760 for(x = src_rect->left; x < src_rect->right; x++)
1761 {
1762 src_val = *src_pixel++;
1763 *dst_pixel++ = (((src_val >> src->red_shift) & 0xff) << dst->red_shift) |
1764 (((src_val >> src->green_shift) & 0xff) << dst->green_shift) |
1765 (((src_val >> src->blue_shift) & 0xff) << dst->blue_shift);
1766 }
1767 if(pad_size) memset(dst_pixel, 0, pad_size);
1768 dst_start += dst->stride / 4;
1769 src_start += src->stride / 4;
1770 }
1771 }
1772 else
1773 {
1774 for(y = src_rect->top; y < src_rect->bottom; y++)
1775 {
1776 dst_pixel = dst_start;
1777 src_pixel = src_start;
1778 for(x = src_rect->left; x < src_rect->right; x++)
1779 {
1780 src_val = *src_pixel++;
1781 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
1782 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
1783 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
1784 }
1785 if(pad_size) memset(dst_pixel, 0, pad_size);
1786 dst_start += dst->stride / 4;
1787 src_start += src->stride / 4;
1788 }
1789 }
1790 break;
1791 }
1792
1793 case 24:
1794 {
1795 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
1796
1797 for(y = src_rect->top; y < src_rect->bottom; y++)
1798 {
1799 dst_pixel = dst_start;
1800 src_pixel = src_start;
1801 for(x = src_rect->left; x < src_rect->right; x++)
1802 {
1803 RGBQUAD rgb;
1804 rgb.rgbBlue = *src_pixel++;
1805 rgb.rgbGreen = *src_pixel++;
1806 rgb.rgbRed = *src_pixel++;
1807
1808 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1809 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1810 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1811 }
1812 if(pad_size) memset(dst_pixel, 0, pad_size);
1813 dst_start += dst->stride / 4;
1814 src_start += src->stride;
1815 }
1816 break;
1817 }
1818
1819 case 16:
1820 {
1821 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
1822 if(src->funcs == &funcs_555)
1823 {
1824 for(y = src_rect->top; y < src_rect->bottom; y++)
1825 {
1826 dst_pixel = dst_start;
1827 src_pixel = src_start;
1828 for(x = src_rect->left; x < src_rect->right; x++)
1829 {
1830 src_val = *src_pixel++;
1831 *dst_pixel++ = put_field(((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07), dst->red_shift, dst->red_len) |
1832 put_field(((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07), dst->green_shift, dst->green_len) |
1833 put_field(((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07), dst->blue_shift, dst->blue_len);
1834 }
1835 if(pad_size) memset(dst_pixel, 0, pad_size);
1836 dst_start += dst->stride / 4;
1837 src_start += src->stride / 2;
1838 }
1839 }
1840 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
1841 {
1842 for(y = src_rect->top; y < src_rect->bottom; y++)
1843 {
1844 dst_pixel = dst_start;
1845 src_pixel = src_start;
1846 for(x = src_rect->left; x < src_rect->right; x++)
1847 {
1848 src_val = *src_pixel++;
1849 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
1850 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
1851 put_field( (((src_val >> src->green_shift) << 3) & 0xf8) |
1852 (((src_val >> src->green_shift) >> 2) & 0x07), dst->green_shift, dst->green_len ) |
1853 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
1854 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
1855 }
1856 if(pad_size) memset(dst_pixel, 0, pad_size);
1857 dst_start += dst->stride / 4;
1858 src_start += src->stride / 2;
1859 }
1860 }
1861 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
1862 {
1863 for(y = src_rect->top; y < src_rect->bottom; y++)
1864 {
1865 dst_pixel = dst_start;
1866 src_pixel = src_start;
1867 for(x = src_rect->left; x < src_rect->right; x++)
1868 {
1869 src_val = *src_pixel++;
1870 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
1871 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
1872 put_field( (((src_val >> src->green_shift) << 2) & 0xfc) |
1873 (((src_val >> src->green_shift) >> 4) & 0x03), dst->green_shift, dst->green_len ) |
1874 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
1875 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
1876 }
1877 if(pad_size) memset(dst_pixel, 0, pad_size);
1878 dst_start += dst->stride / 4;
1879 src_start += src->stride / 2;
1880 }
1881 }
1882 else
1883 {
1884 for(y = src_rect->top; y < src_rect->bottom; y++)
1885 {
1886 dst_pixel = dst_start;
1887 src_pixel = src_start;
1888 for(x = src_rect->left; x < src_rect->right; x++)
1889 {
1890 src_val = *src_pixel++;
1891 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
1892 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
1893 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
1894 }
1895 if(pad_size) memset(dst_pixel, 0, pad_size);
1896 dst_start += dst->stride / 4;
1897 src_start += src->stride / 2;
1898 }
1899 }
1900 break;
1901 }
1902
1903 case 8:
1904 {
1905 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
1906 for(y = src_rect->top; y < src_rect->bottom; y++)
1907 {
1908 dst_pixel = dst_start;
1909 src_pixel = src_start;
1910 for(x = src_rect->left; x < src_rect->right; x++)
1911 {
1912 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
1913 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1914 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1915 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1916 }
1917 if(pad_size) memset(dst_pixel, 0, pad_size);
1918 dst_start += dst->stride / 4;
1919 src_start += src->stride;
1920 }
1921 break;
1922 }
1923
1924 case 4:
1925 {
1926 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
1927 for(y = src_rect->top; y < src_rect->bottom; y++)
1928 {
1929 dst_pixel = dst_start;
1930 src_pixel = src_start;
1931 for(x = src_rect->left; x < src_rect->right; x++)
1932 {
1933 RGBQUAD rgb;
1934 if(x & 1)
1935 rgb = colortable_entry( src, *src_pixel++ & 0xf );
1936 else
1937 rgb = colortable_entry( src, *src_pixel >> 4 );
1938 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1939 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1940 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1941 }
1942 if(pad_size) memset(dst_pixel, 0, pad_size);
1943 dst_start += dst->stride / 4;
1944 src_start += src->stride;
1945 }
1946 break;
1947 }
1948
1949 case 1:
1950 {
1951 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
1952 for(y = src_rect->top; y < src_rect->bottom; y++)
1953 {
1954 dst_pixel = dst_start;
1955 src_pixel = src_start;
1956 for(x = src_rect->left; x < src_rect->right; x++)
1957 {
1958 RGBQUAD rgb;
1959 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
1960 if((x % 8) == 7) src_pixel++;
1961 rgb = src->color_table[src_val];
1962 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1963 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1964 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1965 }
1966 if(pad_size) memset(dst_pixel, 0, pad_size);
1967 dst_start += dst->stride / 4;
1968 src_start += src->stride;
1969 }
1970 break;
1971 }
1972 }
1973 }
1974
1975 static void convert_to_24(dib_info *dst, const dib_info *src, const RECT *src_rect)
1976 {
1977 BYTE *dst_start = get_pixel_ptr_24(dst, 0, 0), *dst_pixel;
1978 DWORD src_val;
1979 int x, y, pad_size = ((dst->width * 3 + 3) & ~3) - (src_rect->right - src_rect->left) * 3;
1980
1981 switch(src->bit_count)
1982 {
1983 case 32:
1984 {
1985 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1986 if(src->funcs == &funcs_8888)
1987 {
1988 for(y = src_rect->top; y < src_rect->bottom; y++)
1989 {
1990 dst_pixel = dst_start;
1991 src_pixel = src_start;
1992 for(x = src_rect->left; x < src_rect->right; x++)
1993 {
1994 src_val = *src_pixel++;
1995 *dst_pixel++ = src_val & 0xff;
1996 *dst_pixel++ = (src_val >> 8) & 0xff;
1997 *dst_pixel++ = (src_val >> 16) & 0xff;
1998 }
1999 if(pad_size) memset(dst_pixel, 0, pad_size);
2000 dst_start += dst->stride;
2001 src_start += src->stride / 4;
2002 }
2003 }
2004 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2005 {
2006 for(y = src_rect->top; y < src_rect->bottom; y++)
2007 {
2008 dst_pixel = dst_start;
2009 src_pixel = src_start;
2010 for(x = src_rect->left; x < src_rect->right; x++)
2011 {
2012 src_val = *src_pixel++;
2013 *dst_pixel++ = (src_val >> src->blue_shift) & 0xff;
2014 *dst_pixel++ = (src_val >> src->green_shift) & 0xff;
2015 *dst_pixel++ = (src_val >> src->red_shift) & 0xff;
2016 }
2017 if(pad_size) memset(dst_pixel, 0, pad_size);
2018 dst_start += dst->stride;
2019 src_start += src->stride / 4;
2020 }
2021 }
2022 else
2023 {
2024 for(y = src_rect->top; y < src_rect->bottom; y++)
2025 {
2026 dst_pixel = dst_start;
2027 src_pixel = src_start;
2028 for(x = src_rect->left; x < src_rect->right; x++)
2029 {
2030 src_val = *src_pixel++;
2031 *dst_pixel++ = get_field( src_val, src->blue_shift, src->blue_len );
2032 *dst_pixel++ = get_field( src_val, src->green_shift, src->green_len );
2033 *dst_pixel++ = get_field( src_val, src->red_shift, src->red_len );
2034 }
2035 if(pad_size) memset(dst_pixel, 0, pad_size);
2036 dst_start += dst->stride;
2037 src_start += src->stride / 4;
2038 }
2039 }
2040 break;
2041 }
2042
2043 case 24:
2044 {
2045 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top);
2046
2047 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
2048 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2049 else
2050 {
2051 for(y = src_rect->top; y < src_rect->bottom; y++)
2052 {
2053 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 3);
2054 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left) * 3, 0, pad_size);
2055 dst_start += dst->stride;
2056 src_start += src->stride;
2057 }
2058 }
2059 break;
2060 }
2061
2062 case 16:
2063 {
2064 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2065 if(src->funcs == &funcs_555)
2066 {
2067 for(y = src_rect->top; y < src_rect->bottom; y++)
2068 {
2069 dst_pixel = dst_start;
2070 src_pixel = src_start;
2071 for(x = src_rect->left; x < src_rect->right; x++)
2072 {
2073 src_val = *src_pixel++;
2074 *dst_pixel++ = ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07);
2075 *dst_pixel++ = ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07);
2076 *dst_pixel++ = ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07);
2077 }
2078 if(pad_size) memset(dst_pixel, 0, pad_size);
2079 dst_start += dst->stride;
2080 src_start += src->stride / 2;
2081 }
2082 }
2083 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2084 {
2085 for(y = src_rect->top; y < src_rect->bottom; y++)
2086 {
2087 dst_pixel = dst_start;
2088 src_pixel = src_start;
2089 for(x = src_rect->left; x < src_rect->right; x++)
2090 {
2091 src_val = *src_pixel++;
2092 *dst_pixel++ = (((src_val >> src->blue_shift) << 3) & 0xf8) |
2093 (((src_val >> src->blue_shift) >> 2) & 0x07);
2094 *dst_pixel++ = (((src_val >> src->green_shift) << 3) & 0xf8) |
2095 (((src_val >> src->green_shift) >> 2) & 0x07);
2096 *dst_pixel++ = (((src_val >> src->red_shift) << 3) & 0xf8) |
2097 (((src_val >> src->red_shift) >> 2) & 0x07);
2098 }
2099 if(pad_size) memset(dst_pixel, 0, pad_size);
2100 dst_start += dst->stride;
2101 src_start += src->stride / 2;
2102 }
2103 }
2104 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2105 {
2106 for(y = src_rect->top; y < src_rect->bottom; y++)
2107 {
2108 dst_pixel = dst_start;
2109 src_pixel = src_start;
2110 for(x = src_rect->left; x < src_rect->right; x++)
2111 {
2112 src_val = *src_pixel++;
2113 *dst_pixel++ = (((src_val >> src->blue_shift) << 3) & 0xf8) |
2114 (((src_val >> src->blue_shift) >> 2) & 0x07);
2115 *dst_pixel++ = (((src_val >> src->green_shift) << 2) & 0xfc) |
2116 (((src_val >> src->green_shift) >> 4) & 0x03);
2117 *dst_pixel++ = (((src_val >> src->red_shift) << 3) & 0xf8) |
2118 (((src_val >> src->red_shift) >> 2) & 0x07);
2119 }
2120 if(pad_size) memset(dst_pixel, 0, pad_size);
2121 dst_start += dst->stride;
2122 src_start += src->stride / 2;
2123 }
2124 }
2125 else
2126 {
2127 for(y = src_rect->top; y < src_rect->bottom; y++)
2128 {
2129 dst_pixel = dst_start;
2130 src_pixel = src_start;
2131 for(x = src_rect->left; x < src_rect->right; x++)
2132 {
2133 src_val = *src_pixel++;
2134 *dst_pixel++ = get_field(src_val, src->blue_shift, src->blue_len );
2135 *dst_pixel++ = get_field(src_val, src->green_shift, src->green_len );
2136 *dst_pixel++ = get_field(src_val, src->red_shift, src->red_len );
2137 }
2138 if(pad_size) memset(dst_pixel, 0, pad_size);
2139 dst_start += dst->stride;
2140 src_start += src->stride / 2;
2141 }
2142 }
2143 break;
2144 }
2145
2146 case 8:
2147 {
2148 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2149 for(y = src_rect->top; y < src_rect->bottom; y++)
2150 {
2151 dst_pixel = dst_start;
2152 src_pixel = src_start;
2153 for(x = src_rect->left; x < src_rect->right; x++)
2154 {
2155 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
2156 *dst_pixel++ = rgb.rgbBlue;
2157 *dst_pixel++ = rgb.rgbGreen;
2158 *dst_pixel++ = rgb.rgbRed;
2159 }
2160 if(pad_size) memset(dst_pixel, 0, pad_size);
2161 dst_start += dst->stride;
2162 src_start += src->stride;
2163 }
2164 break;
2165 }
2166
2167 case 4:
2168 {
2169 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2170 for(y = src_rect->top; y < src_rect->bottom; y++)
2171 {
2172 dst_pixel = dst_start;
2173 src_pixel = src_start;
2174 for(x = src_rect->left; x < src_rect->right; x++)
2175 {
2176 RGBQUAD rgb;
2177 if(x & 1)
2178 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2179 else
2180 rgb = colortable_entry( src, *src_pixel >> 4 );
2181 *dst_pixel++ = rgb.rgbBlue;
2182 *dst_pixel++ = rgb.rgbGreen;
2183 *dst_pixel++ = rgb.rgbRed;
2184 }
2185 if(pad_size) memset(dst_pixel, 0, pad_size);
2186 dst_start += dst->stride;
2187 src_start += src->stride;
2188 }
2189 break;
2190 }
2191
2192 case 1:
2193 {
2194 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
2195 for(y = src_rect->top; y < src_rect->bottom; y++)
2196 {
2197 dst_pixel = dst_start;
2198 src_pixel = src_start;
2199 for(x = src_rect->left; x < src_rect->right; x++)
2200 {
2201 RGBQUAD rgb;
2202 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
2203 if((x % 8) == 7) src_pixel++;
2204 rgb = src->color_table[src_val];
2205 *dst_pixel++ = rgb.rgbBlue;
2206 *dst_pixel++ = rgb.rgbGreen;
2207 *dst_pixel++ = rgb.rgbRed;
2208 }
2209 if(pad_size) memset(dst_pixel, 0, pad_size);
2210 dst_start += dst->stride;
2211 src_start += src->stride;
2212 }
2213 break;
2214 }
2215 }
2216 }
2217
2218 static void convert_to_555(dib_info *dst, const dib_info *src, const RECT *src_rect)
2219 {
2220 WORD *dst_start = get_pixel_ptr_16(dst, 0, 0), *dst_pixel;
2221 INT x, y, pad_size = ((dst->width + 1) & ~1) * 2 - (src_rect->right - src_rect->left) * 2;
2222 DWORD src_val;
2223
2224 switch(src->bit_count)
2225 {
2226 case 32:
2227 {
2228 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2229
2230 if(src->funcs == &funcs_8888)
2231 {
2232 for(y = src_rect->top; y < src_rect->bottom; y++)
2233 {
2234 dst_pixel = dst_start;
2235 src_pixel = src_start;
2236 for(x = src_rect->left; x < src_rect->right; x++)
2237 {
2238 src_val = *src_pixel++;
2239 *dst_pixel++ = ((src_val >> 9) & 0x7c00) |
2240 ((src_val >> 6) & 0x03e0) |
2241 ((src_val >> 3) & 0x001f);
2242 }
2243 if(pad_size) memset(dst_pixel, 0, pad_size);
2244 dst_start += dst->stride / 2;
2245 src_start += src->stride / 4;
2246 }
2247 }
2248 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2249 {
2250 for(y = src_rect->top; y < src_rect->bottom; y++)
2251 {
2252 dst_pixel = dst_start;
2253 src_pixel = src_start;
2254 for(x = src_rect->left; x < src_rect->right; x++)
2255 {
2256 src_val = *src_pixel++;
2257 *dst_pixel++ = (((src_val >> src->red_shift) << 7) & 0x7c00) |
2258 (((src_val >> src->green_shift) << 2) & 0x03e0) |
2259 (((src_val >> src->blue_shift) >> 3) & 0x001f);
2260 }
2261 if(pad_size) memset(dst_pixel, 0, pad_size);
2262 dst_start += dst->stride / 2;
2263 src_start += src->stride / 4;
2264 }
2265 }
2266 else
2267 {
2268 for(y = src_rect->top; y < src_rect->bottom; y++)
2269 {
2270 dst_pixel = dst_start;
2271 src_pixel = src_start;
2272 for(x = src_rect->left; x < src_rect->right; x++)
2273 {
2274 src_val = *src_pixel++;
2275 *dst_pixel++ = (((get_field(src_val, src->red_shift, src->red_len ) << 7) & 0x7c00) |
2276 ((get_field(src_val, src->green_shift, src->green_len ) << 2) & 0x03e0) |
2277 ( get_field(src_val, src->blue_shift, src->blue_len ) >> 3));
2278 }
2279 if(pad_size) memset(dst_pixel, 0, pad_size);
2280 dst_start += dst->stride / 2;
2281 src_start += src->stride / 4;
2282 }
2283 }
2284 break;
2285 }
2286
2287 case 24:
2288 {
2289 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2290
2291 for(y = src_rect->top; y < src_rect->bottom; y++)
2292 {
2293 dst_pixel = dst_start;
2294 src_pixel = src_start;
2295 for(x = src_rect->left; x < src_rect->right; x++)
2296 {
2297 RGBQUAD rgb;
2298 rgb.rgbBlue = *src_pixel++;
2299 rgb.rgbGreen = *src_pixel++;
2300 rgb.rgbRed = *src_pixel++;
2301
2302 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2303 ((rgb.rgbGreen << 2) & 0x03e0) |
2304 ((rgb.rgbBlue >> 3) & 0x001f);
2305 }
2306 if(pad_size) memset(dst_pixel, 0, pad_size);
2307 dst_start += dst->stride / 2;
2308 src_start += src->stride;
2309 }
2310 break;
2311 }
2312
2313 case 16:
2314 {
2315 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2316 if(src->funcs == &funcs_555)
2317 {
2318 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
2319 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2320 else
2321 {
2322 for(y = src_rect->top; y < src_rect->bottom; y++)
2323 {
2324 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 2);
2325 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2326 dst_start += dst->stride / 2;
2327 src_start += src->stride / 2;
2328 }
2329 }
2330 }
2331 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2332 {
2333 for(y = src_rect->top; y < src_rect->bottom; y++)
2334 {
2335 dst_pixel = dst_start;
2336 src_pixel = src_start;
2337 for(x = src_rect->left; x < src_rect->right; x++)
2338 {
2339 src_val = *src_pixel++;
2340 *dst_pixel++ = (((src_val >> src->red_shift) << 10) & 0x7c00) |
2341 (((src_val >> src->green_shift) << 5) & 0x03e0) |
2342 ( (src_val >> src->blue_shift) & 0x001f);
2343 }
2344 if(pad_size) memset(dst_pixel, 0, pad_size);
2345 dst_start += dst->stride / 2;
2346 src_start += src->stride / 2;
2347 }
2348 }
2349 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2350 {
2351 for(y = src_rect->top; y < src_rect->bottom; y++)
2352 {
2353 dst_pixel = dst_start;
2354 src_pixel = src_start;
2355 for(x = src_rect->left; x < src_rect->right; x++)
2356 {
2357 src_val = *src_pixel++;
2358 *dst_pixel++ = (((src_val >> src->red_shift) << 10) & 0x7c00) |
2359 (((src_val >> src->green_shift) << 4) & 0x03e0) |
2360 ( (src_val >> src->blue_shift) & 0x001f);
2361 }
2362 if(pad_size) memset(dst_pixel, 0, pad_size);
2363 dst_start += dst->stride / 2;
2364 src_start += src->stride / 2;
2365 }
2366 }
2367 else
2368 {
2369 for(y = src_rect->top; y < src_rect->bottom; y++)
2370 {
2371 dst_pixel = dst_start;
2372 src_pixel = src_start;
2373 for(x = src_rect->left; x < src_rect->right; x++)
2374 {
2375 src_val = *src_pixel++;
2376 *dst_pixel++ = (((get_field(src_val, src->red_shift, src->red_len) << 7) & 0x7c00) |
2377 ((get_field(src_val, src->green_shift, src->green_len) << 2) & 0x03e0) |
2378 ( get_field(src_val, src->blue_shift, src->blue_len) >> 3));
2379 }
2380 if(pad_size) memset(dst_pixel, 0, pad_size);
2381 dst_start += dst->stride / 2;
2382 src_start += src->stride / 2;
2383 }
2384 }
2385 break;
2386 }
2387
2388 case 8:
2389 {
2390 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2391 for(y = src_rect->top; y < src_rect->bottom; y++)
2392 {
2393 dst_pixel = dst_start;
2394 src_pixel = src_start;
2395 for(x = src_rect->left; x < src_rect->right; x++)
2396 {
2397 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
2398 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2399 ((rgb.rgbGreen << 2) & 0x03e0) |
2400 ((rgb.rgbBlue >> 3) & 0x001f);
2401 }
2402 if(pad_size) memset(dst_pixel, 0, pad_size);
2403 dst_start += dst->stride / 2;
2404 src_start += src->stride;
2405 }
2406 break;
2407 }
2408
2409 case 4:
2410 {
2411 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2412 for(y = src_rect->top; y < src_rect->bottom; y++)
2413 {
2414 dst_pixel = dst_start;
2415 src_pixel = src_start;
2416 for(x = src_rect->left; x < src_rect->right; x++)
2417 {
2418 RGBQUAD rgb;
2419 if(x & 1)
2420 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2421 else
2422 rgb = colortable_entry( src, *src_pixel >> 4 );
2423 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2424 ((rgb.rgbGreen << 2) & 0x03e0) |
2425 ((rgb.rgbBlue >> 3) & 0x001f);
2426 }
2427 if(pad_size) memset(dst_pixel, 0, pad_size);
2428 dst_start += dst->stride / 2;
2429 src_start += src->stride;
2430 }
2431 break;
2432 }
2433
2434 case 1:
2435 {
2436 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
2437 for(y = src_rect->top; y < src_rect->bottom; y++)
2438 {
2439 dst_pixel = dst_start;
2440 src_pixel = src_start;
2441 for(x = src_rect->left; x < src_rect->right; x++)
2442 {
2443 RGBQUAD rgb;
2444 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
2445 if((x % 8) == 7) src_pixel++;
2446 rgb = src->color_table[src_val];
2447 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2448 ((rgb.rgbGreen << 2) & 0x03e0) |
2449 ((rgb.rgbBlue >> 3) & 0x001f);
2450 }
2451 if(pad_size) memset(dst_pixel, 0, pad_size);
2452 dst_start += dst->stride / 2;
2453 src_start += src->stride;
2454 }
2455 break;
2456 }
2457 }
2458 }
2459
2460 static void convert_to_16(dib_info *dst, const dib_info *src, const RECT *src_rect)
2461 {
2462 WORD *dst_start = get_pixel_ptr_16(dst, 0, 0), *dst_pixel;
2463 INT x, y, pad_size = ((dst->width + 1) & ~1) * 2 - (src_rect->right - src_rect->left) * 2;
2464 DWORD src_val;
2465
2466 switch(src->bit_count)
2467 {
2468 case 32:
2469 {
2470 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2471
2472 if(src->funcs == &funcs_8888)
2473 {
2474 for(y = src_rect->top; y < src_rect->bottom; y++)
2475 {
2476 dst_pixel = dst_start;
2477 src_pixel = src_start;
2478 for(x = src_rect->left; x < src_rect->right; x++)
2479 {
2480 src_val = *src_pixel++;
2481 *dst_pixel++ = put_field(src_val >> 16, dst->red_shift, dst->red_len) |
2482 put_field(src_val >> 8, dst->green_shift, dst->green_len) |
2483 put_field(src_val, dst->blue_shift, dst->blue_len);
2484 }
2485 if(pad_size) memset(dst_pixel, 0, pad_size);
2486 dst_start += dst->stride / 2;
2487 src_start += src->stride / 4;
2488 }
2489 }
2490 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2491 {
2492 for(y = src_rect->top; y < src_rect->bottom; y++)
2493 {
2494 dst_pixel = dst_start;
2495 src_pixel = src_start;
2496 for(x = src_rect->left; x < src_rect->right; x++)
2497 {
2498 src_val = *src_pixel++;
2499 *dst_pixel++ = put_field(src_val >> src->red_shift, dst->red_shift, dst->red_len) |
2500 put_field(src_val >> src->green_shift, dst->green_shift, dst->green_len) |
2501 put_field(src_val >> src->blue_shift, dst->blue_shift, dst->blue_len);
2502 }
2503 if(pad_size) memset(dst_pixel, 0, pad_size);
2504 dst_start += dst->stride / 2;
2505 src_start += src->stride / 4;
2506 }
2507 }
2508 else
2509 {
2510 for(y = src_rect->top; y < src_rect->bottom; y++)
2511 {
2512 dst_pixel = dst_start;
2513 src_pixel = src_start;
2514 for(x = src_rect->left; x < src_rect->right; x++)
2515 {
2516 src_val = *src_pixel++;
2517 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2518 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2519 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2520 }
2521 if(pad_size) memset(dst_pixel, 0, pad_size);
2522 dst_start += dst->stride / 2;
2523 src_start += src->stride / 4;
2524 }
2525 }
2526 break;
2527 }
2528
2529 case 24:
2530 {
2531 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2532
2533 for(y = src_rect->top; y < src_rect->bottom; y++)
2534 {
2535 dst_pixel = dst_start;
2536 src_pixel = src_start;
2537 for(x = src_rect->left; x < src_rect->right; x++)
2538 {
2539 RGBQUAD rgb;
2540 rgb.rgbBlue = *src_pixel++;
2541 rgb.rgbGreen = *src_pixel++;
2542 rgb.rgbRed = *src_pixel++;
2543
2544 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2545 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2546 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2547 }
2548 if(pad_size) memset(dst_pixel, 0, pad_size);
2549 dst_start += dst->stride / 2;
2550 src_start += src->stride;
2551 }
2552 break;
2553 }
2554
2555 case 16:
2556 {
2557 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2558 if(src->funcs == &funcs_555)
2559 {
2560 for(y = src_rect->top; y < src_rect->bottom; y++)
2561 {
2562 dst_pixel = dst_start;
2563 src_pixel = src_start;
2564 for(x = src_rect->left; x < src_rect->right; x++)
2565 {
2566 src_val = *src_pixel++;
2567 *dst_pixel++ = put_field(((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07), dst->red_shift, dst->red_len) |
2568 put_field(((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07), dst->green_shift, dst->green_len) |
2569 put_field(((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2570 }
2571 if(pad_size) memset(dst_pixel, 0, pad_size);
2572 dst_start += dst->stride / 2;
2573 src_start += src->stride / 2;
2574 }
2575 }
2576 else if(bit_fields_match(src, dst))
2577 {
2578 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
2579 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2580 else
2581 {
2582 for(y = src_rect->top; y < src_rect->bottom; y++)
2583 {
2584 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 2);
2585 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2586 dst_start += dst->stride / 2;
2587 src_start += src->stride / 2;
2588 }
2589 }
2590 }
2591 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2592 {
2593 for(y = src_rect->top; y < src_rect->bottom; y++)
2594 {
2595 dst_pixel = dst_start;
2596 src_pixel = src_start;
2597 for(x = src_rect->left; x < src_rect->right; x++)
2598 {
2599 src_val = *src_pixel++;
2600 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2601 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2602 put_field( (((src_val >> src->green_shift) << 3) & 0xf8) |
2603 (((src_val >> src->green_shift) >> 2) & 0x07), dst->green_shift, dst->green_len ) |
2604 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2605 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2606 }
2607 if(pad_size) memset(dst_pixel, 0, pad_size);
2608 dst_start += dst->stride / 2;
2609 src_start += src->stride / 2;
2610 }
2611 }
2612 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2613 {
2614 for(y = src_rect->top; y < src_rect->bottom; y++)
2615 {
2616 dst_pixel = dst_start;
2617 src_pixel = src_start;
2618 for(x = src_rect->left; x < src_rect->right; x++)
2619 {
2620 src_val = *src_pixel++;
2621 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2622 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2623 put_field( (((src_val >> src->green_shift) << 2) & 0xfc) |
2624 (((src_val >> src->green_shift) >> 4) & 0x03), dst->green_shift, dst->green_len ) |
2625 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2626 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2627 }
2628 if(pad_size) memset(dst_pixel, 0, pad_size);
2629 dst_start += dst->stride / 2;
2630 src_start += src->stride / 2;
2631 }
2632 }
2633 else
2634 {
2635 for(y = src_rect->top; y < src_rect->bottom; y++)
2636 {
2637 dst_pixel = dst_start;
2638 src_pixel = src_start;
2639 for(x = src_rect->left; x < src_rect->right; x++)
2640 {
2641 src_val = *src_pixel++;
2642 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2643 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2644 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2645 }
2646 if(pad_size) memset(dst_pixel, 0, pad_size);
2647 dst_start += dst->stride / 2;
2648 src_start += src->stride / 2;
2649 }
2650 }
2651 break;
2652 }
2653
2654 case 8:
2655 {
2656 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2657 for(y = src_rect->top; y < src_rect->bottom; y++)
2658 {
2659 dst_pixel = dst_start;
2660 src_pixel = src_start;
2661 for(x = src_rect->left; x < src_rect->right; x++)
2662 {
2663 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
2664 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2665 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2666 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2667 }
2668 if(pad_size) memset(dst_pixel, 0, pad_size);
2669 dst_start += dst->stride / 2;
2670 src_start += src->stride;
2671 }
2672 break;
2673 }
2674
2675 case 4:
2676 {
2677 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2678 for(y = src_rect->top; y < src_rect->bottom; y++)
2679 {
2680 dst_pixel = dst_start;
2681 src_pixel = src_start;
2682 for(x = src_rect->left; x < src_rect->right; x++)
2683 {
2684 RGBQUAD rgb;
2685 if(x & 1)
2686 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2687 else
2688 rgb = colortable_entry( src, *src_pixel >> 4 );
2689 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2690 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2691 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2692 }
2693 if(pad_size) memset(dst_pixel, 0, pad_size);
2694 dst_start += dst->stride / 2;
2695 src_start += src->stride;
2696 }
2697 break;
2698 }
2699
2700 case 1:
2701 {
2702 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
2703 for(y = src_rect->top; y < src_rect->bottom; y++)
2704 {
2705 dst_pixel = dst_start;
2706 src_pixel = src_start;
2707 for(x = src_rect->left; x < src_rect->right; x++)
2708 {
2709 RGBQUAD rgb;
2710 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
2711 if((x % 8) == 7) src_pixel++;
2712 rgb = src->color_table[src_val];
2713 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2714 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2715 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2716 }
2717 if(pad_size) memset(dst_pixel, 0, pad_size);
2718 dst_start += dst->stride / 2;
2719 src_start += src->stride;
2720 }
2721 break;
2722 }
2723 }
2724 }
2725
2726 static inline BOOL color_tables_match(const dib_info *d1, const dib_info *d2)
2727 {
2728 assert(d1->color_table_size && d2->color_table_size);
2729
2730 if(d1->color_table_size != d2->color_table_size) return FALSE;
2731 return !memcmp(d1->color_table, d2->color_table, d1->color_table_size * sizeof(d1->color_table[0]));
2732 }
2733
2734 static inline DWORD rgb_lookup_colortable(const dib_info *dst, BYTE r, BYTE g, BYTE b)
2735 {
2736 /* Windows reduces precision to 5 bits, probably in order to build some sort of lookup cache */
2737 return rgb_to_pixel_colortable( dst, (r & ~7) + 4, (g & ~7) + 4, (b & ~7) + 4 );
2738 }
2739
2740 static void convert_to_8(dib_info *dst, const dib_info *src, const RECT *src_rect)
2741 {
2742 BYTE *dst_start = get_pixel_ptr_8(dst, 0, 0), *dst_pixel;
2743 INT x, y, pad_size = ((dst->width + 3) & ~3) - (src_rect->right - src_rect->left);
2744 DWORD src_val;
2745
2746 switch(src->bit_count)
2747 {
2748 case 32:
2749 {
2750 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2751
2752 if(src->funcs == &funcs_8888)
2753 {
2754 for(y = src_rect->top; y < src_rect->bottom; y++)
2755 {
2756 dst_pixel = dst_start;
2757 src_pixel = src_start;
2758 for(x = src_rect->left; x < src_rect->right; x++)
2759 {
2760 src_val = *src_pixel++;
2761 *dst_pixel++ = rgb_lookup_colortable(dst, src_val >> 16, src_val >> 8, src_val );
2762 }
2763 if(pad_size) memset(dst_pixel, 0, pad_size);
2764 dst_start += dst->stride;
2765 src_start += src->stride / 4;
2766 }
2767 }
2768 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2769 {
2770 for(y = src_rect->top; y < src_rect->bottom; y++)
2771 {
2772 dst_pixel = dst_start;
2773 src_pixel = src_start;
2774 for(x = src_rect->left; x < src_rect->right; x++)
2775 {
2776 src_val = *src_pixel++;
2777 *dst_pixel++ = rgb_lookup_colortable(dst,
2778 src_val >> src->red_shift,
2779 src_val >> src->green_shift,
2780 src_val >> src->blue_shift );
2781 }
2782 if(pad_size) memset(dst_pixel, 0, pad_size);
2783 dst_start += dst->stride;
2784 src_start += src->stride / 4;
2785 }
2786 }
2787 else
2788 {
2789 for(y = src_rect->top; y < src_rect->bottom; y++)
2790 {
2791 dst_pixel = dst_start;
2792 src_pixel = src_start;
2793 for(x = src_rect->left; x < src_rect->right; x++)
2794 {
2795 src_val = *src_pixel++;
2796 *dst_pixel++ = rgb_lookup_colortable(dst,
2797 get_field(src_val, src->red_shift, src->red_len),
2798 get_field(src_val, src->green_shift, src->green_len),
2799 get_field(src_val, src->blue_shift, src->blue_len));
2800 }
2801 if(pad_size) memset(dst_pixel, 0, pad_size);
2802 dst_start += dst->stride;
2803 src_start += src->stride / 4;
2804 }
2805 }
2806 break;
2807 }
2808
2809 case 24:
2810 {
2811 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2812
2813 for(y = src_rect->top; y < src_rect->bottom; y++)
2814 {
2815 dst_pixel = dst_start;
2816 src_pixel = src_start;
2817 for(x = src_rect->left; x < src_rect->right; x++, src_pixel += 3)
2818 {
2819 *dst_pixel++ = rgb_lookup_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0] );
2820 }
2821 if(pad_size) memset(dst_pixel, 0, pad_size);
2822 dst_start += dst->stride;
2823 src_start += src->stride;
2824 }
2825 break;
2826 }
2827
2828 case 16:
2829 {
2830 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2831 if(src->funcs == &funcs_555)
2832 {
2833 for(y = src_rect->top; y < src_rect->bottom; y++)
2834 {
2835 dst_pixel = dst_start;
2836 src_pixel = src_start;
2837 for(x = src_rect->left; x < src_rect->right; x++)
2838 {
2839 src_val = *src_pixel++;
2840 *dst_pixel++ = rgb_lookup_colortable(dst,
2841 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
2842 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
2843 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) );
2844 }
2845 if(pad_size) memset(dst_pixel, 0, pad_size);
2846 dst_start += dst->stride;
2847 src_start += src->stride / 2;
2848 }
2849 }
2850 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2851 {
2852 for(y = src_rect->top; y < src_rect->bottom; y++)
2853 {
2854 dst_pixel = dst_start;
2855 src_pixel = src_start;
2856 for(x = src_rect->left; x < src_rect->right; x++)
2857 {
2858 src_val = *src_pixel++;
2859 *dst_pixel++ = rgb_lookup_colortable(dst,
2860 (((src_val >> src->red_shift) << 3) & 0xf8) |
2861 (((src_val >> src->red_shift) >> 2) & 0x07),
2862 (((src_val >> src->green_shift) << 3) & 0xf8) |
2863 (((src_val >> src->green_shift) >> 2) & 0x07),
2864 (((src_val >> src->blue_shift) << 3) & 0xf8) |
2865 (((src_val >> src->blue_shift) >> 2) & 0x07) );
2866 }
2867 if(pad_size) memset(dst_pixel, 0, pad_size);
2868 dst_start += dst->stride;
2869 src_start += src->stride / 2;
2870 }
2871 }
2872 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2873 {
2874 for(y = src_rect->top; y < src_rect->bottom; y++)
2875 {
2876 dst_pixel = dst_start;
2877 src_pixel = src_start;
2878 for(x = src_rect->left; x < src_rect->right; x++)
2879 {
2880 src_val = *src_pixel++;
2881 *dst_pixel++ = rgb_lookup_colortable(dst,
2882 (((src_val >> src->red_shift) << 3) & 0xf8) |
2883 (((src_val >> src->red_shift) >> 2) & 0x07),
2884 (((src_val >> src->green_shift) << 2) & 0xfc) |
2885 (((src_val >> src->green_shift) >> 4) & 0x03),
2886 (((src_val >> src->blue_shift) << 3) & 0xf8) |
2887 (((src_val >> src->blue_shift) >> 2) & 0x07) );
2888 }
2889 if(pad_size) memset(dst_pixel, 0, pad_size);
2890 dst_start += dst->stride;
2891 src_start += src->stride / 2;
2892 }
2893 }
2894 else
2895 {
2896 for(y = src_rect->top; y < src_rect->bottom; y++)
2897 {
2898 dst_pixel = dst_start;
2899 src_pixel = src_start;
2900 for(x = src_rect->left; x < src_rect->right; x++)
2901 {
2902 src_val = *src_pixel++;
2903 *dst_pixel++ = rgb_lookup_colortable(dst,
2904 get_field(src_val, src->red_shift, src->red_len),
2905 get_field(src_val, src->green_shift, src->green_len),
2906 get_field(src_val, src->blue_shift, src->blue_len));
2907 }
2908 if(pad_size) memset(dst_pixel, 0, pad_size);
2909 dst_start += dst->stride;
2910 src_start += src->stride / 2;
2911 }
2912 }
2913 break;
2914 }
2915
2916 case 8:
2917 {
2918 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2919
2920 if(color_tables_match(dst, src))
2921 {
2922 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
2923 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2924 else
2925 {
2926 for(y = src_rect->top; y < src_rect->bottom; y++)
2927 {
2928 memcpy(dst_start, src_start, src_rect->right - src_rect->left);
2929 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2930 dst_start += dst->stride;
2931 src_start += src->stride;
2932 }
2933 }
2934 }
2935 else
2936 {
2937 for(y = src_rect->top; y < src_rect->bottom; y++)
2938 {
2939 dst_pixel = dst_start;
2940 src_pixel = src_start;
2941 for(x = src_rect->left; x < src_rect->right; x++)
2942 {
2943 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
2944 *dst_pixel++ = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2945 }
2946 if(pad_size) memset(dst_pixel, 0, pad_size);
2947 dst_start += dst->stride;
2948 src_start += src->stride;
2949 }
2950 }
2951 break;
2952 }
2953
2954 case 4:
2955 {
2956 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2957 for(y = src_rect->top; y < src_rect->bottom; y++)
2958 {
2959 dst_pixel = dst_start;
2960 src_pixel = src_start;
2961 for(x = src_rect->left; x < src_rect->right; x++)
2962 {
2963 RGBQUAD rgb;
2964 if(x & 1)
2965 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2966 else
2967 rgb = colortable_entry( src, *src_pixel >> 4 );
2968 *dst_pixel++ = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2969 }
2970 if(pad_size) memset(dst_pixel, 0, pad_size);
2971 dst_start += dst->stride;
2972 src_start += src->stride;
2973 }
2974 break;
2975 }
2976
2977 case 1:
2978 {
2979 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
2980 for(y = src_rect->top; y < src_rect->bottom; y++)
2981 {
2982 dst_pixel = dst_start;
2983 src_pixel = src_start;
2984 for(x = src_rect->left; x < src_rect->right; x++)
2985 {
2986 RGBQUAD rgb;
2987 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
2988 if((x % 8) == 7) src_pixel++;
2989 rgb = src->color_table[src_val];
2990 *dst_pixel++ = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2991 }
2992 if(pad_size) memset(dst_pixel, 0, pad_size);
2993 dst_start += dst->stride;
2994 src_start += src->stride;
2995 }
2996 break;
2997 }
2998 }
2999 }
3000
3001 static void convert_to_4(dib_info *dst, const dib_info *src, const RECT *src_rect)
3002 {
3003 BYTE *dst_start = get_pixel_ptr_4(dst, 0, 0), *dst_pixel, dst_val;
3004 INT x, y, pad_size = ((dst->width + 7) & ~7) / 2 - (src_rect->right - src_rect->left + 1) / 2;
3005 DWORD src_val;
3006
3007 switch(src->bit_count)
3008 {
3009 case 32:
3010 {
3011 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
3012
3013 if(src->funcs == &funcs_8888)
3014 {
3015 for(y = src_rect->top; y < src_rect->bottom; y++)
3016 {
3017 dst_pixel = dst_start;
3018 src_pixel = src_start;
3019 for(x = src_rect->left; x < src_rect->right; x++)
3020 {
3021 src_val = *src_pixel++;
3022 dst_val = rgb_to_pixel_colortable(dst, src_val >> 16, src_val >> 8, src_val);
3023 if((x - src_rect->left) & 1)
3024 {
3025 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3026 dst_pixel++;
3027 }
3028 else
3029 *dst_pixel = (dst_val << 4) & 0xf0;
3030 }
3031 if(pad_size)
3032 {
3033 if((x - src_rect->left) & 1) dst_pixel++;
3034 memset(dst_pixel, 0, pad_size);
3035 }
3036 dst_start += dst->stride;
3037 src_start += src->stride / 4;
3038 }
3039 }
3040 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
3041 {
3042 for(y = src_rect->top; y < src_rect->bottom; y++)
3043 {
3044 dst_pixel = dst_start;
3045 src_pixel = src_start;
3046 for(x = src_rect->left; x < src_rect->right; x++)
3047 {
3048 src_val = *src_pixel++;
3049 dst_val = rgb_to_pixel_colortable(dst,
3050 src_val >> src->red_shift,
3051 src_val >> src->green_shift,
3052 src_val >> src->blue_shift);
3053 if((x - src_rect->left) & 1)
3054 {
3055 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3056 dst_pixel++;
3057 }
3058 else
3059 *dst_pixel = (dst_val << 4) & 0xf0;
3060 }
3061 if(pad_size)
3062 {
3063 if((x - src_rect->left) & 1) dst_pixel++;
3064 memset(dst_pixel, 0, pad_size);
3065 }
3066 dst_start += dst->stride;
3067 src_start += src->stride / 4;
3068 }
3069 }
3070 else
3071 {
3072 for(y = src_rect->top; y < src_rect->bottom; y++)
3073 {
3074 dst_pixel = dst_start;
3075 src_pixel = src_start;
3076 for(x = src_rect->left; x < src_rect->right; x++)
3077 {
3078 src_val = *src_pixel++;
3079 dst_val = rgb_to_pixel_colortable(dst,
3080 get_field(src_val, src->red_shift, src->red_len),
3081 get_field(src_val, src->green_shift, src->green_len),
3082 get_field(src_val, src->blue_shift, src->blue_len));
3083 if((x - src_rect->left) & 1)
3084 {
3085 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3086 dst_pixel++;
3087 }
3088 else
3089 *dst_pixel = (dst_val << 4) & 0xf0;
3090 }
3091 if(pad_size)
3092 {
3093 if((x - src_rect->left) & 1) dst_pixel++;
3094 memset(dst_pixel, 0, pad_size);
3095 }
3096 dst_start += dst->stride;
3097 src_start += src->stride / 4;
3098 }
3099 }
3100 break;
3101 }
3102
3103 case 24:
3104 {
3105 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
3106
3107 for(y = src_rect->top; y < src_rect->bottom; y++)
3108 {
3109 dst_pixel = dst_start;
3110 src_pixel = src_start;
3111 for(x = src_rect->left; x < src_rect->right; x++, src_pixel += 3)
3112 {
3113 dst_val = rgb_to_pixel_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0]);
3114
3115 if((x - src_rect->left) & 1)
3116 {
3117 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3118 dst_pixel++;
3119 }
3120 else
3121 *dst_pixel = (dst_val << 4) & 0xf0;
3122 }
3123 if(pad_size)
3124 {
3125 if((x - src_rect->left) & 1) dst_pixel++;
3126 memset(dst_pixel, 0, pad_size);
3127 }
3128 dst_start += dst->stride;
3129 src_start += src->stride;
3130 }
3131 break;
3132 }
3133
3134 case 16:
3135 {
3136 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
3137 if(src->funcs == &funcs_555)
3138 {
3139 for(y = src_rect->top; y < src_rect->bottom; y++)
3140 {
3141 dst_pixel = dst_start;
3142 src_pixel = src_start;
3143 for(x = src_rect->left; x < src_rect->right; x++)
3144 {
3145 src_val = *src_pixel++;
3146 dst_val = rgb_to_pixel_colortable(dst,
3147 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
3148 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
3149 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) );
3150 if((x - src_rect->left) & 1)
3151 {
3152 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3153 dst_pixel++;
3154 }
3155 else
3156 *dst_pixel = (dst_val << 4) & 0xf0;
3157 }
3158 if(pad_size)
3159 {
3160 if((x - src_rect->left) & 1) dst_pixel++;
3161 memset(dst_pixel, 0, pad_size);
3162 }
3163 dst_start += dst->stride;
3164 src_start += src->stride / 2;
3165 }
3166 }
3167 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
3168 {
3169 for(y = src_rect->top; y < src_rect->bottom; y++)
3170 {
3171 dst_pixel = dst_start;
3172 src_pixel = src_start;
3173 for(x = src_rect->left; x < src_rect->right; x++)
3174 {
3175 src_val = *src_pixel++;
3176 dst_val = rgb_to_pixel_colortable(dst,
3177 (((src_val >> src->red_shift) << 3) & 0xf8) |
3178 (((src_val >> src->red_shift) >> 2) & 0x07),
3179 (((src_val >> src->green_shift) << 3) & 0xf8) |
3180 (((src_val >> src->green_shift) >> 2) & 0x07),
3181 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3182 (((src_val >> src->blue_shift) >> 2) & 0x07) );
3183 if((x - src_rect->left) & 1)
3184 {
3185 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3186 dst_pixel++;
3187 }
3188 else
3189 *dst_pixel = (dst_val << 4) & 0xf0;
3190 }
3191 if(pad_size)
3192 {
3193 if((x - src_rect->left) & 1) dst_pixel++;
3194 memset(dst_pixel, 0, pad_size);
3195 }
3196 dst_start += dst->stride;
3197 src_start += src->stride / 2;
3198 }
3199 }
3200 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
3201 {
3202 for(y = src_rect->top; y < src_rect->bottom; y++)
3203 {
3204 dst_pixel = dst_start;
3205 src_pixel = src_start;
3206 for(x = src_rect->left; x < src_rect->right; x++)
3207 {
3208 src_val = *src_pixel++;
3209 dst_val = rgb_to_pixel_colortable(dst,
3210 (((src_val >> src->red_shift) << 3) & 0xf8) |
3211 (((src_val >> src->red_shift) >> 2) & 0x07),
3212 (((src_val >> src->green_shift) << 2) & 0xfc) |
3213 (((src_val >> src->green_shift) >> 4) & 0x03),
3214 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3215 (((src_val >> src->blue_shift) >> 2) & 0x07) );
3216 if((x - src_rect->left) & 1)
3217 {
3218 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3219 dst_pixel++;
3220 }
3221 else
3222 *dst_pixel = (dst_val << 4) & 0xf0;
3223 }
3224 if(pad_size)
3225 {
3226 if((x - src_rect->left) & 1) dst_pixel++;
3227 memset(dst_pixel, 0, pad_size);
3228 }
3229 dst_start += dst->stride;
3230 src_start += src->stride / 2;
3231 }
3232 }
3233 else
3234 {
3235 for(y = src_rect->top; y < src_rect->bottom; y++)
3236 {
3237 dst_pixel = dst_start;
3238 src_pixel = src_start;
3239 for(x = src_rect->left; x < src_rect->right; x++)
3240 {
3241 src_val = *src_pixel++;
3242 dst_val = rgb_to_pixel_colortable(dst,
3243 get_field(src_val, src->red_shift, src->red_len),
3244 get_field(src_val, src->green_shift, src->green_len),
3245 get_field(src_val, src->blue_shift, src->blue_len));
3246 if((x - src_rect->left) & 1)
3247 {
3248 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3249 dst_pixel++;
3250 }
3251 else
3252 *dst_pixel = (dst_val << 4) & 0xf0;
3253 }
3254 if(pad_size)
3255 {
3256 if((x - src_rect->left) & 1) dst_pixel++;
3257 memset(dst_pixel, 0, pad_size);
3258 }
3259 dst_start += dst->stride;
3260 src_start += src->stride / 2;
3261 }
3262 }
3263 break;
3264 }
3265
3266 case 8:
3267 {
3268 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
3269
3270 for(y = src_rect->top; y < src_rect->bottom; y++)
3271 {
3272 dst_pixel = dst_start;
3273 src_pixel = src_start;
3274 for(x = src_rect->left; x < src_rect->right; x++)
3275 {
3276 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
3277 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3278 if((x - src_rect->left) & 1)
3279 {
3280 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3281 dst_pixel++;
3282 }
3283 else
3284 *dst_pixel = (dst_val << 4) & 0xf0;
3285 }
3286 if(pad_size)
3287 {
3288 if((x - src_rect->left) & 1) dst_pixel++;
3289 memset(dst_pixel, 0, pad_size);
3290 }
3291 dst_start += dst->stride;
3292 src_start += src->stride;
3293 }
3294 break;
3295 }
3296
3297 case 4:
3298 {
3299 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
3300
3301 if(color_tables_match(dst, src) && (src_rect->left & 1) == 0)
3302 {
3303 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
3304 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
3305 else
3306 {
3307 for(y = src_rect->top; y < src_rect->bottom; y++)
3308 {
3309 memcpy(dst_start, src_start, (src_rect->right - src_rect->left + 1) / 2);
3310 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left + 1) / 2, 0, pad_size);
3311 dst_start += dst->stride;
3312 src_start += src->stride;
3313 }
3314 }
3315 }
3316 else
3317 {
3318 for(y = src_rect->top; y < src_rect->bottom; y++)
3319 {
3320 dst_pixel = dst_start;
3321 src_pixel = src_start;
3322 for(x = src_rect->left; x < src_rect->right; x++)
3323 {
3324 RGBQUAD rgb;
3325 if(x & 1)
3326 rgb = colortable_entry( src, *src_pixel++ & 0xf );
3327 else
3328 rgb = colortable_entry( src, *src_pixel >> 4 );
3329 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3330 if((x - src_rect->left) & 1)
3331 {
3332 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3333 dst_pixel++;
3334 }
3335 else
3336 *dst_pixel = (dst_val << 4) & 0xf0;
3337 }
3338 if(pad_size)
3339 {
3340 if((x - src_rect->left) & 1) dst_pixel++;
3341 memset(dst_pixel, 0, pad_size);
3342 }
3343 dst_start += dst->stride;
3344 src_start += src->stride;
3345 }
3346 }
3347 break;
3348 }
3349
3350 case 1:
3351 {
3352 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
3353 for(y = src_rect->top; y < src_rect->bottom; y++)
3354 {
3355 dst_pixel = dst_start;
3356 src_pixel = src_start;
3357 for(x = src_rect->left; x < src_rect->right; x++)
3358 {
3359 RGBQUAD rgb;
3360 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
3361 if((x % 8) == 7) src_pixel++;
3362 rgb = src->color_table[src_val];
3363 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3364 if((x - src_rect->left) & 1)
3365 {
3366 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3367 dst_pixel++;
3368 }
3369 else
3370 *dst_pixel = (dst_val << 4) & 0xf0;
3371 }
3372 if(pad_size)
3373 {
3374 if((x - src_rect->left) & 1) dst_pixel++;
3375 memset(dst_pixel, 0, pad_size);
3376 }
3377 dst_start += dst->stride;
3378 src_start += src->stride;
3379 }
3380 break;
3381 }
3382 }
3383 }
3384
3385 static void convert_to_1(dib_info *dst, const dib_info *src, const RECT *src_rect)
3386 {
3387 BYTE *dst_start = get_pixel_ptr_1(dst, 0, 0), *dst_pixel, dst_val;
3388 INT x, y, pad_size = ((dst->width + 31) & ~31) / 8 - (src_rect->right - src_rect->left + 7) / 8;
3389 DWORD src_val;
3390 int bit_pos;
3391
3392 /* FIXME: Brushes should be dithered. */
3393
3394 switch(src->bit_count)
3395 {
3396 case 32:
3397 {
3398 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
3399
3400 if(src->funcs == &funcs_8888)
3401 {
3402 for(y = src_rect->top; y < src_rect->bottom; y++)
3403 {
3404 dst_pixel = dst_start;
3405 src_pixel = src_start;
3406 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3407 {
3408 src_val = *src_pixel++;
3409 dst_val = rgb_to_pixel_colortable(dst, src_val >> 16, src_val >> 8, src_val) ? 0xff : 0;
3410
3411 if(bit_pos == 0) *dst_pixel = 0;
3412 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3413
3414 if(++bit_pos == 8)
3415 {
3416 dst_pixel++;
3417 bit_pos = 0;
3418 }
3419 }
3420 if(pad_size)
3421 {
3422 if(bit_pos != 0) dst_pixel++;
3423 memset(dst_pixel, 0, pad_size);
3424 }
3425 dst_start += dst->stride;
3426 src_start += src->stride / 4;
3427 }
3428 }
3429 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
3430 {
3431 for(y = src_rect->top; y < src_rect->bottom; y++)
3432 {
3433 dst_pixel = dst_start;
3434 src_pixel = src_start;
3435 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3436 {
3437 src_val = *src_pixel++;
3438 dst_val = rgb_to_pixel_colortable(dst,
3439 src_val >> src->red_shift,
3440 src_val >> src->green_shift,
3441 src_val >> src->blue_shift) ? 0xff : 0;
3442
3443 if(bit_pos == 0) *dst_pixel = 0;
3444 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3445
3446 if(++bit_pos == 8)
3447 {
3448 dst_pixel++;
3449 bit_pos = 0;
3450 }
3451 }
3452 if(pad_size)
3453 {
3454 if(bit_pos != 0) dst_pixel++;
3455 memset(dst_pixel, 0, pad_size);
3456 }
3457 dst_start += dst->stride;
3458 src_start += src->stride / 4;
3459 }
3460 }
3461 else
3462 {
3463 for(y = src_rect->top; y < src_rect->bottom; y++)
3464 {
3465 dst_pixel = dst_start;
3466 src_pixel = src_start;
3467 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3468 {
3469 src_val = *src_pixel++;
3470 dst_val = rgb_to_pixel_colortable(dst,
3471 get_field(src_val, src->red_shift, src->red_len),
3472 get_field(src_val, src->green_shift, src->green_len),
3473 get_field(src_val, src->blue_shift, src->blue_len)) ? 0xff : 0;
3474
3475 if(bit_pos == 0) *dst_pixel = 0;
3476 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3477
3478 if(++bit_pos == 8)
3479 {
3480 dst_pixel++;
3481 bit_pos = 0;
3482 }
3483 }
3484 if(pad_size)
3485 {
3486 if(bit_pos != 0) dst_pixel++;
3487 memset(dst_pixel, 0, pad_size);
3488 }
3489 dst_start += dst->stride;
3490 src_start += src->stride / 4;
3491 }
3492 }
3493 break;
3494 }
3495
3496 case 24:
3497 {
3498 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
3499
3500 for(y = src_rect->top; y < src_rect->bottom; y++)
3501 {
3502 dst_pixel = dst_start;
3503 src_pixel = src_start;
3504 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++, src_pixel += 3)
3505 {
3506 dst_val = rgb_to_pixel_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0]) ? 0xff : 0;
3507
3508 if(bit_pos == 0) *dst_pixel = 0;
3509 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3510
3511 if(++bit_pos == 8)
3512 {
3513 dst_pixel++;
3514 bit_pos = 0;
3515 }
3516 }
3517 if(pad_size)
3518 {
3519 if(bit_pos != 0) dst_pixel++;
3520 memset(dst_pixel, 0, pad_size);
3521 }
3522 dst_start += dst->stride;
3523 src_start += src->stride;
3524 }
3525 break;
3526 }
3527
3528 case 16:
3529 {
3530 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
3531 if(src->funcs == &funcs_555)
3532 {
3533 for(y = src_rect->top; y < src_rect->bottom; y++)
3534 {
3535 dst_pixel = dst_start;
3536 src_pixel = src_start;
3537 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3538 {
3539 src_val = *src_pixel++;
3540 dst_val = rgb_to_pixel_colortable(dst,
3541 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
3542 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
3543 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) ) ? 0xff : 0;
3544
3545 if(bit_pos == 0) *dst_pixel = 0;
3546 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3547
3548 if(++bit_pos == 8)
3549 {
3550 dst_pixel++;
3551 bit_pos = 0;
3552 }
3553 }
3554 if(pad_size)
3555 {
3556 if(bit_pos != 0) dst_pixel++;
3557 memset(dst_pixel, 0, pad_size);
3558 }
3559 dst_start += dst->stride;
3560 src_start += src->stride / 2;
3561 }
3562 }
3563 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
3564 {
3565 for(y = src_rect->top; y < src_rect->bottom; y++)
3566 {
3567 dst_pixel = dst_start;
3568 src_pixel = src_start;
3569 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3570 {
3571 src_val = *src_pixel++;
3572 dst_val = rgb_to_pixel_colortable(dst,
3573 (((src_val >> src->red_shift) << 3) & 0xf8) |
3574 (((src_val >> src->red_shift) >> 2) & 0x07),
3575 (((src_val >> src->green_shift) << 3) & 0xf8) |
3576 (((src_val >> src->green_shift) >> 2) & 0x07),
3577 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3578 (((src_val >> src->blue_shift) >> 2) & 0x07) ) ? 0xff : 0;
3579 if(bit_pos == 0) *dst_pixel = 0;
3580 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3581
3582 if(++bit_pos == 8)
3583 {
3584 dst_pixel++;
3585 bit_pos = 0;
3586 }
3587 }
3588 if(pad_size)
3589 {
3590 if(bit_pos != 0) dst_pixel++;
3591 memset(dst_pixel, 0, pad_size);
3592 }
3593 dst_start += dst->stride;
3594 src_start += src->stride / 2;
3595 }
3596 }
3597 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
3598 {
3599 for(y = src_rect->top; y < src_rect->bottom; y++)
3600 {
3601 dst_pixel = dst_start;
3602 src_pixel = src_start;
3603 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3604 {
3605 src_val = *src_pixel++;
3606 dst_val = rgb_to_pixel_colortable(dst,
3607 (((src_val >> src->red_shift) << 3) & 0xf8) |
3608 (((src_val >> src->red_shift) >> 2) & 0x07),
3609 (((src_val >> src->green_shift) << 2) & 0xfc) |
3610 (((src_val >> src->green_shift) >> 4) & 0x03),
3611 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3612 (((src_val >> src->blue_shift) >> 2) & 0x07) ) ? 0xff : 0;
3613 if(bit_pos == 0) *dst_pixel = 0;
3614 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3615
3616 if(++bit_pos == 8)
3617 {
3618 dst_pixel++;
3619 bit_pos = 0;
3620 }
3621 }
3622 if(pad_size)
3623 {
3624 if(bit_pos != 0) dst_pixel++;
3625 memset(dst_pixel, 0, pad_size);
3626 }
3627 dst_start += dst->stride;
3628 src_start += src->stride / 2;
3629 }
3630 }
3631 else
3632 {
3633 for(y = src_rect->top; y < src_rect->bottom; y++)
3634 {
3635 dst_pixel = dst_start;
3636 src_pixel = src_start;
3637 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3638 {
3639 src_val = *src_pixel++;
3640 dst_val = rgb_to_pixel_colortable(dst,
3641 get_field(src_val, src->red_shift, src->red_len),
3642 get_field(src_val, src->green_shift, src->green_len),
3643 get_field(src_val, src->blue_shift, src->blue_len)) ? 0xff : 0;
3644 if(bit_pos == 0) *dst_pixel = 0;
3645 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3646
3647 if(++bit_pos == 8)
3648 {
3649 dst_pixel++;
3650 bit_pos = 0;
3651 }
3652 }
3653 if(pad_size)
3654 {
3655 if(bit_pos != 0) dst_pixel++;
3656 memset(dst_pixel, 0, pad_size);
3657 }
3658 dst_start += dst->stride;
3659 src_start += src->stride / 2;
3660 }
3661 }
3662 break;
3663 }
3664
3665 case 8:
3666 {
3667 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
3668
3669 for(y = src_rect->top; y < src_rect->bottom; y++)
3670 {
3671 dst_pixel = dst_start;
3672 src_pixel = src_start;
3673 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3674 {
3675 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
3676 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue) ? 0xff : 0;
3677
3678 if(bit_pos == 0) *dst_pixel = 0;
3679 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3680
3681 if(++bit_pos == 8)
3682 {
3683 dst_pixel++;
3684 bit_pos = 0;
3685 }
3686 }
3687 if(pad_size)
3688 {
3689 if(bit_pos != 0) dst_pixel++;
3690 memset(dst_pixel, 0, pad_size);
3691 }
3692 dst_start += dst->stride;
3693 src_start += src->stride;
3694 }
3695 break;
3696 }
3697
3698 case 4:
3699 {
3700 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
3701
3702 for(y = src_rect->top; y < src_rect->bottom; y++)
3703 {
3704 dst_pixel = dst_start;
3705 src_pixel = src_start;
3706 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3707 {
3708 RGBQUAD rgb;
3709 if(x & 1)
3710 rgb = colortable_entry( src, *src_pixel++ & 0xf );
3711 else
3712 rgb = colortable_entry( src, *src_pixel >> 4 );
3713 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue) ? 0xff : 0;
3714
3715 if(bit_pos == 0) *dst_pixel = 0;
3716 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3717
3718 if(++bit_pos == 8)
3719 {
3720 dst_pixel++;
3721 bit_pos = 0;
3722 }
3723 }
3724 if(pad_size)
3725 {
3726 if(bit_pos != 0) dst_pixel++;
3727 memset(dst_pixel, 0, pad_size);
3728 }
3729 dst_start += dst->stride;
3730 src_start += src->stride;
3731 }
3732 break;
3733 }
3734
3735 /* Note that while MSDN states that a 1 bpp dib brush -> mono dc
3736 uses text/bkgnd colours instead of the dib's colour table, this
3737 doesn't appear to be the case for a dc backed by a
3738 dibsection. */
3739
3740 case 1:
3741 {
3742 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
3743 for(y = src_rect->top; y < src_rect->bottom; y++)
3744 {
3745 dst_pixel = dst_start;
3746 src_pixel = src_start;
3747 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3748 {
3749 RGBQUAD rgb;
3750 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
3751 if((x % 8) == 7) src_pixel++;
3752 rgb = src->color_table[src_val];
3753 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue) ? 0xff : 0;
3754
3755 if(bit_pos == 0) *dst_pixel = 0;
3756 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3757
3758 if(++bit_pos == 8)
3759 {
3760 dst_pixel++;
3761 bit_pos = 0;
3762 }
3763 }
3764 if(pad_size)
3765 {
3766 if(bit_pos != 0) dst_pixel++;
3767 memset(dst_pixel, 0, pad_size);
3768 }
3769 dst_start += dst->stride;
3770 src_start += src->stride;
3771 }
3772 break;
3773 }
3774 }
3775 }
3776
3777 static void convert_to_null(dib_info *dst, const dib_info *src, const RECT *src_rect)
3778 {
3779 }
3780
3781 static inline BYTE blend_color(BYTE dst, BYTE src, DWORD alpha)
3782 {
3783 return (src * alpha + dst * (255 - alpha) + 127) / 255;
3784 }
3785
3786 static inline DWORD blend_argb( DWORD dst, DWORD src, DWORD alpha )
3787 {
3788 return (blend_color( dst, src, alpha ) |
3789 blend_color( dst >> 8, src >> 8, alpha ) << 8 |
3790 blend_color( dst >> 16, src >> 16, alpha ) << 16 |
3791 blend_color( dst >> 24, src >> 24, alpha ) << 24);
3792 }
3793
3794 static inline DWORD blend_argb_alpha( DWORD dst, DWORD src, DWORD alpha )
3795 {
3796 BYTE b = ((BYTE)src * alpha + 127) / 255;
3797 BYTE g = ((BYTE)(src >> 8) * alpha + 127) / 255;
3798 BYTE r = ((BYTE)(src >> 16) * alpha + 127) / 255;
3799 alpha = ((BYTE)(src >> 24) * alpha + 127) / 255;
3800 return ((b + ((BYTE)dst * (255 - alpha) + 127) / 255) |
3801 (g + ((BYTE)(dst >> 8) * (255 - alpha) + 127) / 255) << 8 |
3802 (r + ((BYTE)(dst >> 16) * (255 - alpha) + 127) / 255) << 16 |
3803 (alpha + ((BYTE)(dst >> 24) * (255 - alpha) + 127) / 255) << 24);
3804 }
3805
3806 static inline DWORD blend_rgb( BYTE dst_r, BYTE dst_g, BYTE dst_b, DWORD src, BLENDFUNCTION blend )
3807 {
3808 if (blend.AlphaFormat & AC_SRC_ALPHA)
3809 {
3810 DWORD alpha = blend.SourceConstantAlpha;
3811 BYTE src_b = ((BYTE)src * alpha + 127) / 255;
3812 BYTE src_g = ((BYTE)(src >> 8) * alpha + 127) / 255;
3813 BYTE src_r = ((BYTE)(src >> 16) * alpha + 127) / 255;
3814 alpha = ((BYTE)(src >> 24) * alpha + 127) / 255;
3815 return ((src_b + (dst_b * (255 - alpha) + 127) / 255) |
3816 (src_g + (dst_g * (255 - alpha) + 127) / 255) << 8 |
3817 (src_r + (dst_r * (255 - alpha) + 127) / 255) << 16);
3818 }
3819 return (blend_color( dst_b, src, blend.SourceConstantAlpha ) |
3820 blend_color( dst_g, src >> 8, blend.SourceConstantAlpha ) << 8 |
3821 blend_color( dst_r, src >> 16, blend.SourceConstantAlpha ) << 16);
3822 }
3823
3824 static void blend_rect_8888(const dib_info *dst, const RECT *rc,
3825 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3826 {
3827 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
3828 DWORD *dst_ptr = get_pixel_ptr_32( dst, rc->left, rc->top );
3829 int x, y;
3830
3831 if (blend.AlphaFormat & AC_SRC_ALPHA)
3832 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
3833 for (x = 0; x < rc->right - rc->left; x++)
3834 dst_ptr[x] = blend_argb_alpha( dst_ptr[x], src_ptr[x], blend.SourceConstantAlpha );
3835 else
3836 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
3837 for (x = 0; x < rc->right - rc->left; x++)
3838 dst_ptr[x] = blend_argb( dst_ptr[x], src_ptr[x], blend.SourceConstantAlpha );
3839 }
3840
3841 static void blend_rect_32(const dib_info *dst, const RECT *rc,
3842 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3843 {
3844 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
3845 DWORD *dst_ptr = get_pixel_ptr_32( dst, rc->left, rc->top );
3846 int x, y;
3847
3848 if (dst->red_len == 8 && dst->green_len == 8 && dst->blue_len == 8)
3849 {
3850 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
3851 {
3852 for (x = 0; x < rc->right - rc->left; x++)
3853 {
3854 DWORD val = blend_rgb( dst_ptr[x] >> dst->red_shift,
3855 dst_ptr[x] >> dst->green_shift,
3856 dst_ptr[x] >> dst->blue_shift,
3857 src_ptr[x], blend );
3858 dst_ptr[x] = ((( val & 0xff) << dst->blue_shift) |
3859 (((val >> 8) & 0xff) << dst->green_shift) |
3860 (((val >> 16) & 0xff) << dst->red_shift));
3861 }
3862 }
3863 }
3864 else
3865 {
3866 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 4, src_ptr += src->stride / 4)
3867 {
3868 for (x = 0; x < rc->right - rc->left; x++)
3869 {
3870 DWORD val = blend_rgb( get_field( dst_ptr[x], dst->red_shift, dst->red_len ),
3871 get_field( dst_ptr[x], dst->green_shift, dst->green_len ),
3872 get_field( dst_ptr[x], dst->blue_shift, dst->blue_len ),
3873 src_ptr[x], blend );
3874 dst_ptr[x] = (put_field( val >> 16, dst->red_shift, dst->red_len ) |
3875 put_field( val >> 8, dst->green_shift, dst->green_len ) |
3876 put_field( val, dst->blue_shift, dst->blue_len ));
3877 }
3878 }
3879 }
3880 }
3881
3882 static void blend_rect_24(const dib_info *dst, const RECT *rc,
3883 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3884 {
3885 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
3886 BYTE *dst_ptr = get_pixel_ptr_24( dst, rc->left, rc->top );
3887 int x, y;
3888
3889 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
3890 {
3891 for (x = 0; x < rc->right - rc->left; x++)
3892 {
3893 DWORD val = blend_rgb( dst_ptr[x * 3 + 2], dst_ptr[x * 3 + 1], dst_ptr[x * 3],
3894 src_ptr[x], blend );
3895 dst_ptr[x * 3] = val;
3896 dst_ptr[x * 3 + 1] = val >> 8;
3897 dst_ptr[x * 3 + 2] = val >> 16;
3898 }
3899 }
3900 }
3901
3902 static void blend_rect_555(const dib_info *dst, const RECT *rc,
3903 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3904 {
3905 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
3906 WORD *dst_ptr = get_pixel_ptr_16( dst, rc->left, rc->top );
3907 int x, y;
3908
3909 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 2, src_ptr += src->stride / 4)
3910 {
3911 for (x = 0; x < rc->right - rc->left; x++)
3912 {
3913 DWORD val = blend_rgb( ((dst_ptr[x] >> 7) & 0xf8) | ((dst_ptr[x] >> 12) & 0x07),
3914 ((dst_ptr[x] >> 2) & 0xf8) | ((dst_ptr[x] >> 7) & 0x07),
3915 ((dst_ptr[x] << 3) & 0xf8) | ((dst_ptr[x] >> 2) & 0x07),
3916 src_ptr[x], blend );
3917 dst_ptr[x] = ((val >> 9) & 0x7c00) | ((val >> 6) & 0x03e0) | ((val >> 3) & 0x001f);
3918 }
3919 }
3920 }
3921
3922 static void blend_rect_16(const dib_info *dst, const RECT *rc,
3923 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3924 {
3925 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
3926 WORD *dst_ptr = get_pixel_ptr_16( dst, rc->left, rc->top );
3927 int x, y;
3928
3929 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride / 2, src_ptr += src->stride / 4)
3930 {
3931 for (x = 0; x < rc->right - rc->left; x++)
3932 {
3933 DWORD val = blend_rgb( get_field( dst_ptr[x], dst->red_shift, dst->red_len ),
3934 get_field( dst_ptr[x], dst->green_shift, dst->green_len ),
3935 get_field( dst_ptr[x], dst->blue_shift, dst->blue_len ),
3936 src_ptr[x], blend );
3937 dst_ptr[x] = (put_field((val >> 16), dst->red_shift, dst->red_len) |
3938 put_field((val >> 8), dst->green_shift, dst->green_len) |
3939 put_field( val, dst->blue_shift, dst->blue_len));
3940 }
3941 }
3942 }
3943
3944 static void blend_rect_8(const dib_info *dst, const RECT *rc,
3945 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3946 {
3947 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x, origin->y );
3948 BYTE *dst_ptr = get_pixel_ptr_8( dst, rc->left, rc->top );
3949 int x, y;
3950
3951 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
3952 {
3953 for (x = 0; x < rc->right - rc->left; x++)
3954 {
3955 RGBQUAD rgb = colortable_entry( dst, dst_ptr[x] );
3956 DWORD val = blend_rgb( rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, src_ptr[x], blend );
3957 dst_ptr[x] = rgb_lookup_colortable( dst, val >> 16, val >> 8, val );
3958 }
3959 }
3960 }
3961
3962 static void blend_rect_4(const dib_info *dst, const RECT *rc,
3963 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3964 {
3965 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x - rc->left, origin->y );
3966 BYTE *dst_ptr = get_pixel_ptr_4( dst, 0, rc->top );
3967 int x, y;
3968
3969 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
3970 {
3971 for (x = rc->left; x < rc->right; x++)
3972 {
3973 DWORD val = ((x & 1) ? dst_ptr[x / 2] : (dst_ptr[x / 2] >> 4)) & 0x0f;
3974 RGBQUAD rgb = colortable_entry( dst, val );
3975 val = blend_rgb( rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, src_ptr[x], blend );
3976 val = rgb_lookup_colortable( dst, val >> 16, val >> 8, val );
3977 if (x & 1)
3978 dst_ptr[x / 2] = val | (dst_ptr[x / 2] & 0xf0);
3979 else
3980 dst_ptr[x / 2] = (val << 4) | (dst_ptr[x / 2] & 0x0f);
3981 }
3982 }
3983 }
3984
3985 static void blend_rect_1(const dib_info *dst, const RECT *rc,
3986 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
3987 {
3988 DWORD *src_ptr = get_pixel_ptr_32( src, origin->x - rc->left, origin->y );
3989 BYTE *dst_ptr = get_pixel_ptr_1( dst, 0, rc->top );
3990 int x, y;
3991
3992 for (y = rc->top; y < rc->bottom; y++, dst_ptr += dst->stride, src_ptr += src->stride / 4)
3993 {
3994 for (x = rc->left; x < rc->right; x++)
3995 {
3996 DWORD val = (dst_ptr[x / 8] & pixel_masks_1[x % 8]) ? 1 : 0;
3997 RGBQUAD rgb = dst->color_table[val];
3998 val = blend_rgb( rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue, src_ptr[x], blend );
3999 val = rgb_to_pixel_colortable(dst, val >> 16, val >> 8, val) ? 0xff : 0;
4000 dst_ptr[x / 8] = (dst_ptr[x / 8] & ~pixel_masks_1[x % 8]) | (val & pixel_masks_1[x % 8]);
4001 }
4002 }
4003 }
4004
4005 static void blend_rect_null(const dib_info *dst, const RECT *rc,
4006 const dib_info *src, const POINT *origin, BLENDFUNCTION blend)
4007 {
4008 }
4009
4010 static inline DWORD gradient_rgb_8888( const TRIVERTEX *v, unsigned int pos, unsigned int len )
4011 {
4012 BYTE r, g, b, a;
4013 r = (v[0].Red * (len - pos) + v[1].Red * pos) / len / 256;
4014 g = (v[0].Green * (len - pos) + v[1].Green * pos) / len / 256;
4015 b = (v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 256;
4016 a = (v[0].Alpha * (len - pos) + v[1].Alpha * pos) / len / 256;
4017 return a << 24 | r << 16 | g << 8 | b;
4018 }
4019
4020 static inline DWORD gradient_rgb_24( const TRIVERTEX *v, unsigned int pos, unsigned int len )
4021 {
4022 BYTE r, g, b;
4023 r = (v[0].Red * (len - pos) + v[1].Red * pos) / len / 256;
4024 g = (v[0].Green * (len - pos) + v[1].Green * pos) / len / 256;
4025 b = (v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 256;
4026 return r << 16 | g << 8 | b;
4027 }
4028
4029 static inline WORD gradient_rgb_555( const TRIVERTEX *v, unsigned int pos, unsigned int len,
4030 unsigned int x, unsigned int y )
4031 {
4032 int r = (v[0].Red * (len - pos) + v[1].Red * pos) / len / 128 + bayer_4x4[y % 4][x % 4];
4033 int g = (v[0].Green * (len - pos) + v[1].Green * pos) / len / 128 + bayer_4x4[y % 4][x % 4];
4034 int b = (v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 128 + bayer_4x4[y % 4][x % 4];
4035 r = min( 31, max( 0, r / 16 ));
4036 g = min( 31, max( 0, g / 16 ));
4037 b = min( 31, max( 0, b / 16 ));
4038 return (r << 10) | (g << 5) | b;
4039 }
4040
4041 static inline BYTE gradient_rgb_8( const dib_info *dib, const TRIVERTEX *v,
4042 unsigned int pos, unsigned int len, unsigned int x, unsigned int y )
4043 {
4044 BYTE r = ((v[0].Red * (len - pos) + v[1].Red * pos) / len / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4045 BYTE g = ((v[0].Green * (len - pos) + v[1].Green * pos) / len / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4046 BYTE b = ((v[0].Blue * (len - pos) + v[1].Blue * pos) / len / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4047 return rgb_to_pixel_colortable( dib, r * 127, g * 127, b * 127 );
4048 }
4049
4050 /* compute the left/right triangle limit for row y */
4051 static inline void triangle_coords( const TRIVERTEX *v, const RECT *rc, int y, int *left, int *right )
4052 {
4053 int x1, x2;
4054
4055 if (y < v[1].y) x1 = edge_coord( y, v[0].x, v[0].y, v[1].x, v[1].y );
4056 else x1 = edge_coord( y, v[1].x, v[1].y, v[2].x, v[2].y );
4057
4058 x2 = edge_coord( y, v[0].x, v[0].y, v[2].x, v[2].y );
4059
4060 *left = max( rc->left, min( x1, x2 ) );
4061 *right = min( rc->right, max( x1, x2 ) );
4062 }
4063
4064 /* compute the matrix determinant for triangular barycentric coordinates (constant across the triangle) */
4065 static inline int triangle_det( const TRIVERTEX *v )
4066 {
4067 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);
4068 }
4069
4070 /* compute the barycentric weights for a given point inside the triangle */
4071 static inline void triangle_weights( const TRIVERTEX *v, int x, int y, INT64 *l1, INT64 *l2 )
4072 {
4073 *l1 = (v[1].y - v[2].y) * (x - v[2].x) - (v[1].x - v[2].x) * (y - v[2].y);
4074 *l2 = (v[2].y - v[0].y) * (x - v[2].x) - (v[2].x - v[0].x) * (y - v[2].y);
4075 }
4076
4077 static inline DWORD gradient_triangle_8888( const TRIVERTEX *v, int x, int y, int det )
4078 {
4079 INT64 l1, l2;
4080 BYTE r, g, b, a;
4081
4082 triangle_weights( v, x, y, &l1, &l2 );
4083 r = (v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 256;
4084 g = (v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 256;
4085 b = (v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 256;
4086 a = (v[0].Alpha * l1 + v[1].Alpha * l2 + v[2].Alpha * (det - l1 - l2)) / det / 256;
4087 return a << 24 | r << 16 | g << 8 | b;
4088 }
4089
4090 static inline DWORD gradient_triangle_24( const TRIVERTEX *v, int x, int y, int det )
4091 {
4092 INT64 l1, l2;
4093 BYTE r, g, b;
4094
4095 triangle_weights( v, x, y, &l1, &l2 );
4096 r = (v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 256;
4097 g = (v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 256;
4098 b = (v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 256;
4099 return r << 16 | g << 8 | b;
4100 }
4101
4102 static inline DWORD gradient_triangle_555( const TRIVERTEX *v, int x, int y, int det )
4103 {
4104 INT64 l1, l2;
4105 int r, g, b;
4106
4107 triangle_weights( v, x, y, &l1, &l2 );
4108 r = (v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 128 + bayer_4x4[y % 4][x % 4];
4109 g = (v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 128 + bayer_4x4[y % 4][x % 4];
4110 b = (v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 128 + bayer_4x4[y % 4][x % 4];
4111 r = min( 31, max( 0, r / 16 ));
4112 g = min( 31, max( 0, g / 16 ));
4113 b = min( 31, max( 0, b / 16 ));
4114 return (r << 10) | (g << 5) | b;
4115 }
4116
4117 static inline DWORD gradient_triangle_8( const dib_info *dib, const TRIVERTEX *v, int x, int y, int det )
4118 {
4119 INT64 l1, l2;
4120 BYTE r, g, b;
4121
4122 triangle_weights( v, x, y, &l1, &l2 );
4123 r = ((v[0].Red * l1 + v[1].Red * l2 + v[2].Red * (det - l1 - l2)) / det / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4124 g = ((v[0].Green * l1 + v[1].Green * l2 + v[2].Green * (det - l1 - l2)) / det / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4125 b = ((v[0].Blue * l1 + v[1].Blue * l2 + v[2].Blue * (det - l1 - l2)) / det / 128 + bayer_16x16[y % 16][x % 16]) / 256;
4126 return rgb_to_pixel_colortable( dib, r * 127, g * 127, b * 127 );
4127 }
4128
4129 static BOOL gradient_rect_8888( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4130 {
4131 DWORD *ptr = get_pixel_ptr_32( dib, 0, rc->top );
4132 int x, y, left, right, det;
4133
4134 switch (mode)
4135 {
4136 case GRADIENT_FILL_RECT_H:
4137 for (x = rc->left; x < rc->right; x++)
4138 ptr[x] = gradient_rgb_8888( v, x - v[0].x, v[1].x - v[0].x );
4139
4140 for (y = rc->top + 1, ptr += rc->left; y < rc->bottom; y++, ptr += dib->stride / 4)
4141 memcpy( ptr + dib->stride / 4, ptr, (rc->right - rc->left) * 4 );
4142 break;
4143
4144 case GRADIENT_FILL_RECT_V:
4145 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 4)
4146 {
4147 DWORD val = gradient_rgb_8888( v, y - v[0].y, v[1].y - v[0].y );
4148 for (x = rc->left; x < rc->right; x++) ptr[x] = val;
4149 }
4150 break;
4151
4152 case GRADIENT_FILL_TRIANGLE:
4153 if (!(det = triangle_det( v ))) return FALSE;
4154 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 4)
4155 {
4156 triangle_coords( v, rc, y, &left, &right );
4157 for (x = left; x < right; x++) ptr[x] = gradient_triangle_8888( v, x, y, det );
4158 }
4159 break;
4160 }
4161 return TRUE;
4162 }
4163
4164 static BOOL gradient_rect_32( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4165 {
4166 DWORD *ptr = get_pixel_ptr_32( dib, 0, rc->top );
4167 int x, y, left, right, det;
4168
4169 switch (mode)
4170 {
4171 case GRADIENT_FILL_RECT_H:
4172 if (dib->red_len == 8 && dib->green_len == 8 && dib->blue_len == 8)
4173 {
4174 for (x = rc->left; x < rc->right; x++)
4175 {
4176 DWORD val = gradient_rgb_24( v, x - v[0].x, v[1].x - v[0].x );
4177 ptr[x] = ((( val & 0xff) << dib->blue_shift) |
4178 (((val >> 8) & 0xff) << dib->green_shift) |
4179 (((val >> 16) & 0xff) << dib->red_shift));
4180 }
4181 }
4182 else
4183 {
4184 for (x = rc->left; x < rc->right; x++)
4185 {
4186 DWORD val = gradient_rgb_24( v, x - v[0].x, v[1].x - v[0].x );
4187 ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4188 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4189 put_field( val, dib->blue_shift, dib->blue_len ));
4190 }
4191 }
4192
4193 for (y = rc->top + 1, ptr += rc->left; y < rc->bottom; y++, ptr += dib->stride / 4)
4194 memcpy( ptr + dib->stride / 4, ptr, (rc->right - rc->left) * 4 );
4195 break;
4196
4197 case GRADIENT_FILL_RECT_V:
4198 for (y = rc->top; y < rc->bottom; y++)
4199 {
4200 DWORD val = gradient_rgb_24( v, y - v[0].y, v[1].y - v[0].y );
4201 if (dib->red_len == 8 && dib->green_len == 8 && dib->blue_len == 8)
4202 val = ((( val & 0xff) << dib->blue_shift) |
4203 (((val >> 8) & 0xff) << dib->green_shift) |
4204 (((val >> 16) & 0xff) << dib->red_shift));
4205 else
4206 val = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4207 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4208 put_field( val, dib->blue_shift, dib->blue_len ));
4209
4210 for (x = rc->left; x < rc->right; x++) ptr[x] = val;
4211 ptr += dib->stride / 4;
4212 }
4213 break;
4214
4215 case GRADIENT_FILL_TRIANGLE:
4216 if (!(det = triangle_det( v ))) return FALSE;
4217 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 4)
4218 {
4219 triangle_coords( v, rc, y, &left, &right );
4220
4221 if (dib->red_len == 8 && dib->green_len == 8 && dib->blue_len == 8)
4222 for (x = left; x < right; x++)
4223 {
4224 DWORD val = gradient_triangle_24( v, x, y, det );
4225 ptr[x] = ((( val & 0xff) << dib->blue_shift) |
4226 (((val >> 8) & 0xff) << dib->green_shift) |
4227 (((val >> 16) & 0xff) << dib->red_shift));
4228 }
4229 else
4230 for (x = left; x < right; x++)
4231 {
4232 DWORD val = gradient_triangle_24( v, x, y, det );
4233 ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4234 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4235 put_field( val, dib->blue_shift, dib->blue_len ));
4236 }
4237 }
4238 break;
4239 }
4240 return TRUE;
4241 }
4242
4243 static BOOL gradient_rect_24( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4244 {
4245 BYTE *ptr = get_pixel_ptr_24( dib, 0, rc->top );
4246 int x, y, left, right, det;
4247
4248 switch (mode)
4249 {
4250 case GRADIENT_FILL_RECT_H:
4251 for (x = rc->left; x < rc->right; x++)
4252 {
4253 DWORD val = gradient_rgb_24( v, x - v[0].x, v[1].x - v[0].x );
4254 ptr[x * 3] = val;
4255 ptr[x * 3 + 1] = val >> 8;
4256 ptr[x * 3 + 2] = val >> 16;
4257 }
4258
4259 for (y = rc->top + 1, ptr += rc->left * 3; y < rc->bottom; y++, ptr += dib->stride)
4260 memcpy( ptr + dib->stride, ptr, (rc->right - rc->left) * 3 );
4261 break;
4262
4263 case GRADIENT_FILL_RECT_V:
4264 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4265 {
4266 DWORD val = gradient_rgb_24( v, y - v[0].y, v[1].y - v[0].y );
4267 for (x = rc->left; x < rc->right; x++)
4268 {
4269 ptr[x * 3] = val;
4270 ptr[x * 3 + 1] = val >> 8;
4271 ptr[x * 3 + 2] = val >> 16;
4272 }
4273 }
4274 break;
4275
4276 case GRADIENT_FILL_TRIANGLE:
4277 if (!(det = triangle_det( v ))) return FALSE;
4278 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4279 {
4280 triangle_coords( v, rc, y, &left, &right );
4281 for (x = left; x < right; x++)
4282 {
4283 DWORD val = gradient_triangle_24( v, x, y, det );
4284 ptr[x * 3] = val;
4285 ptr[x * 3 + 1] = val >> 8;
4286 ptr[x * 3 + 2] = val >> 16;
4287 }
4288 }
4289 break;
4290 }
4291 return TRUE;
4292 }
4293
4294 static BOOL gradient_rect_555( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4295 {
4296 WORD *ptr = get_pixel_ptr_16( dib, 0, rc->top );
4297 int x, y, left, right, det;
4298
4299 switch (mode)
4300 {
4301 case GRADIENT_FILL_RECT_H:
4302 for (y = rc->top; y < min( rc->top + 4, rc->bottom ); y++, ptr += dib->stride / 2)
4303 for (x = rc->left; x < rc->right; x++)
4304 ptr[x] = gradient_rgb_555( v, x - v[0].x, v[1].x - v[0].x, x, y );
4305 for (ptr += rc->left; y < rc->bottom; y++, ptr += dib->stride / 2)
4306 memcpy( ptr, ptr - dib->stride * 2, (rc->right - rc->left) * 2 );
4307 break;
4308
4309 case GRADIENT_FILL_RECT_V:
4310 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4311 {
4312 WORD values[4];
4313 for (x = 0; x < 4; x++) values[x] = gradient_rgb_555( v, y - v[0].y, v[1].y - v[0].y, x, y );
4314 for (x = rc->left; x < rc->right; x++) ptr[x] = values[x % 4];
4315 }
4316 break;
4317
4318 case GRADIENT_FILL_TRIANGLE:
4319 if (!(det = triangle_det( v ))) return FALSE;
4320 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4321 {
4322 triangle_coords( v, rc, y, &left, &right );
4323 for (x = left; x < right; x++) ptr[x] = gradient_triangle_555( v, x, y, det );
4324 }
4325 break;
4326 }
4327 return TRUE;
4328 }
4329
4330 static BOOL gradient_rect_16( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4331 {
4332 WORD *ptr = get_pixel_ptr_16( dib, 0, rc->top );
4333 int x, y, left, right, det;
4334
4335 switch (mode)
4336 {
4337 case GRADIENT_FILL_RECT_H:
4338 for (y = rc->top; y < min( rc->top + 4, rc->bottom ); y++, ptr += dib->stride / 2)
4339 for (x = rc->left; x < rc->right; x++)
4340 {
4341 WORD val = gradient_rgb_555( v, x - v[0].x, v[1].x - v[0].x, x, y );
4342 ptr[x] = (put_field(((val >> 7) & 0xf8) | ((val >> 12) & 0x07), dib->red_shift, dib->red_len) |
4343 put_field(((val >> 2) & 0xf8) | ((val >> 7) & 0x07), dib->green_shift, dib->green_len) |
4344 put_field(((val << 3) & 0xf8) | ((val >> 2) & 0x07), dib->blue_shift, dib->blue_len));
4345 }
4346 for (ptr += rc->left; y < rc->bottom; y++, ptr += dib->stride / 2)
4347 memcpy( ptr, ptr - dib->stride * 2, (rc->right - rc->left) * 2 );
4348 break;
4349
4350 case GRADIENT_FILL_RECT_V:
4351 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4352 {
4353 WORD values[4];
4354 for (x = 0; x < 4; x++)
4355 {
4356 WORD val = gradient_rgb_555( v, y - v[0].y, v[1].y - v[0].y, x, y );
4357 values[x] = (put_field(((val >> 7) & 0xf8) | ((val >> 12) & 0x07), dib->red_shift, dib->red_len) |
4358 put_field(((val >> 2) & 0xf8) | ((val >> 7) & 0x07), dib->green_shift, dib->green_len) |
4359 put_field(((val << 3) & 0xf8) | ((val >> 2) & 0x07), dib->blue_shift, dib->blue_len));
4360 }
4361 for (x = rc->left; x < rc->right; x++) ptr[x] = values[x % 4];
4362 }
4363 break;
4364
4365 case GRADIENT_FILL_TRIANGLE:
4366 if (!(det = triangle_det( v ))) return FALSE;
4367 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride / 2)
4368 {
4369 triangle_coords( v, rc, y, &left, &right );
4370 for (x = left; x < right; x++)
4371 {
4372 WORD val = gradient_triangle_555( v, x, y, det );
4373 ptr[x] = (put_field(((val >> 7) & 0xf8) | ((val >> 12) & 0x07), dib->red_shift, dib->red_len) |
4374 put_field(((val >> 2) & 0xf8) | ((val >> 7) & 0x07), dib->green_shift, dib->green_len) |
4375 put_field(((val << 3) & 0xf8) | ((val >> 2) & 0x07), dib->blue_shift, dib->blue_len));
4376 }
4377 }
4378 break;
4379 }
4380 return TRUE;
4381 }
4382
4383 static BOOL gradient_rect_8( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4384 {
4385 BYTE *ptr = get_pixel_ptr_8( dib, 0, rc->top );
4386 int x, y, left, right, det;
4387
4388 switch (mode)
4389 {
4390 case GRADIENT_FILL_RECT_H:
4391 for (y = rc->top; y < min( rc->top + 16, rc->bottom ); y++, ptr += dib->stride)
4392 for (x = rc->left; x < rc->right; x++)
4393 ptr[x] = gradient_rgb_8( dib, v, x - v[0].x, v[1].x - v[0].x, x, y );
4394 for (ptr += rc->left; y < rc->bottom; y++, ptr += dib->stride)
4395 memcpy( ptr, ptr - dib->stride * 16, rc->right - rc->left );
4396 break;
4397
4398 case GRADIENT_FILL_RECT_V:
4399 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4400 {
4401 BYTE values[16];
4402 for (x = 0; x < 16; x++)
4403 values[x] = gradient_rgb_8( dib, v, y - v[0].y, v[1].y - v[0].y, x, y );
4404 for (x = rc->left; x < rc->right; x++) ptr[x] = values[x % 16];
4405 }
4406 break;
4407
4408 case GRADIENT_FILL_TRIANGLE:
4409 if (!(det = triangle_det( v ))) return FALSE;
4410 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4411 {
4412 triangle_coords( v, rc, y, &left, &right );
4413 for (x = left; x < right; x++) ptr[x] = gradient_triangle_8( dib, v, x, y, det );
4414 }
4415 break;
4416 }
4417 return TRUE;
4418 }
4419
4420 static BOOL gradient_rect_4( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4421 {
4422 BYTE *ptr = get_pixel_ptr_4( dib, 0, rc->top );
4423 int x, y, left, right, det;
4424
4425 switch (mode)
4426 {
4427 case GRADIENT_FILL_RECT_H:
4428 for (y = rc->top; y < min( rc->top + 16, rc->bottom ); y++, ptr += dib->stride)
4429 {
4430 for (x = rc->left; x < rc->right; x++)
4431 {
4432 BYTE val = gradient_rgb_8( dib, v, x - v[0].x, v[1].x - v[0].x, x, y );
4433 if (x & 1)
4434 ptr[x / 2] = val | (ptr[x / 2] & 0xf0);
4435 else
4436 ptr[x / 2] = (val << 4) | (ptr[x / 2] & 0x0f);
4437 }
4438 }
4439 for ( ; y < rc->bottom; y++, ptr += dib->stride)
4440 {
4441 x = rc->left;
4442 if (x & 1)
4443 {
4444 ptr[x / 2] = (ptr[x / 2 - 16 * dib->stride] & 0x0f) | (ptr[x / 2] & 0xf0);
4445 x++;
4446 }
4447 for (; x < rc->right - 1; x += 2) ptr[x / 2] = ptr[x / 2 - 16 * dib->stride];
4448 if (x < rc->right)
4449 ptr[x / 2] = (ptr[x / 2] & 0x0f) | (ptr[x / 2 - 16 * dib->stride] & 0xf0);
4450 }
4451 break;
4452
4453 case GRADIENT_FILL_RECT_V:
4454 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4455 {
4456 BYTE values[16];
4457 for (x = 0; x < 16; x++)
4458 values[x] = gradient_rgb_8( dib, v, y - v[0].y, v[1].y - v[0].y, x, y );
4459 for (x = rc->left; x < rc->right; x++)
4460 if (x & 1)
4461 ptr[x / 2] = values[x % 16] | (ptr[x / 2] & 0xf0);
4462 else
4463 ptr[x / 2] = (values[x % 16] << 4) | (ptr[x / 2] & 0x0f);
4464 }
4465 break;
4466
4467 case GRADIENT_FILL_TRIANGLE:
4468 if (!(det = triangle_det( v ))) return FALSE;
4469 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4470 {
4471 triangle_coords( v, rc, y, &left, &right );
4472 for (x = left; x < right; x++)
4473 {
4474 BYTE val = gradient_triangle_8( dib, v, x, y, det );
4475 if (x & 1)
4476 ptr[x / 2] = val | (ptr[x / 2] & 0xf0);
4477 else
4478 ptr[x / 2] = (val << 4) | (ptr[x / 2] & 0x0f);
4479 }
4480 }
4481 break;
4482 }
4483 return TRUE;
4484 }
4485
4486 static BOOL gradient_rect_1( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4487 {
4488 BYTE *ptr = get_pixel_ptr_1( dib, 0, rc->top );
4489 int x, y, left, right, det;
4490
4491 switch (mode)
4492 {
4493 case GRADIENT_FILL_RECT_H:
4494 for (x = rc->left; x < rc->right; x++)
4495 {
4496 DWORD val = gradient_rgb_24( v, x - v[0].x, v[1].x - v[0].x );
4497 val = rgb_to_pixel_colortable( dib, val >> 16, val >> 8, val ) ? 0xff : 0;
4498 ptr[x / 8] = (ptr[x / 8] & ~pixel_masks_1[x % 8]) | (val & pixel_masks_1[x % 8]);
4499 }
4500
4501 for (y = rc->top + 1; y < rc->bottom; y++, ptr += dib->stride)
4502 for (x = rc->left; x < rc->right; x++)
4503 ptr[dib->stride + x / 8] = (ptr[dib->stride + x / 8] & ~pixel_masks_1[x % 8]) |
4504 (ptr[x / 8] & pixel_masks_1[x % 8]);
4505 break;
4506
4507 case GRADIENT_FILL_RECT_V:
4508 for (y = rc->top; y < rc->bottom; y++)
4509 {
4510 DWORD val = gradient_rgb_24( v, y - v[0].y, v[1].y - v[0].y );
4511 val = rgb_to_pixel_colortable( dib, val >> 16, val >> 8, val ) ? 0xff : 0;
4512 for (x = rc->left; x < rc->right; x++)
4513 ptr[x / 8] = (ptr[x / 8] & ~pixel_masks_1[x % 8]) | (val & pixel_masks_1[x % 8]);
4514 ptr += dib->stride;
4515 }
4516 break;
4517
4518 case GRADIENT_FILL_TRIANGLE:
4519 if (!(det = triangle_det( v ))) return FALSE;
4520 for (y = rc->top; y < rc->bottom; y++, ptr += dib->stride)
4521 {
4522 triangle_coords( v, rc, y, &left, &right );
4523 for (x = left; x < right; x++)
4524 {
4525 DWORD val = gradient_triangle_24( v, x, y, det );
4526 val = rgb_to_pixel_colortable( dib, val >> 16, val >> 8, val ) ? 0xff : 0;
4527 ptr[x / 8] = (ptr[x / 8] & ~pixel_masks_1[x % 8]) | (val & pixel_masks_1[x % 8]);
4528 }
4529 }
4530 break;
4531 }
4532 return TRUE;
4533 }
4534
4535 static BOOL gradient_rect_null( const dib_info *dib, const RECT *rc, const TRIVERTEX *v, int mode )
4536 {
4537 return TRUE;
4538 }
4539
4540 static inline BYTE aa_color( BYTE dst, BYTE text, BYTE min_comp, BYTE max_comp )
4541 {
4542 if (dst == text) return dst;
4543
4544 if (dst > text)
4545 {
4546 DWORD diff = dst - text;
4547 DWORD range = max_comp - text;
4548 dst = text + (diff * range ) / (0xff - text);
4549 return dst;
4550 }
4551 else
4552 {
4553 DWORD diff = text - dst;
4554 DWORD range = text - min_comp;
4555 dst = text - (diff * range) / text;
4556 return dst;
4557 }
4558 }
4559
4560 static inline DWORD aa_rgb( BYTE r_dst, BYTE g_dst, BYTE b_dst, DWORD text, const struct intensity_range *range )
4561 {
4562 return (aa_color( b_dst, text, range->b_min, range->b_max ) |
4563 aa_color( g_dst, text >> 8, range->g_min, range->g_max ) << 8 |
4564 aa_color( r_dst, text >> 16, range->r_min, range->r_max ) << 16);
4565 }
4566
4567 static void draw_glyph_8888( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4568 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4569 {
4570 DWORD *dst_ptr = get_pixel_ptr_32( dib, rect->left, rect->top );
4571 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4572 int x, y;
4573
4574 for (y = rect->top; y < rect->bottom; y++)
4575 {
4576 for (x = 0; x < rect->right - rect->left; x++)
4577 {
4578 if (glyph_ptr[x] <= 1) continue;
4579 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
4580 dst_ptr[x] = aa_rgb( dst_ptr[x] >> 16, dst_ptr[x] >> 8, dst_ptr[x], text_pixel, ranges + glyph_ptr[x] );
4581 }
4582 dst_ptr += dib->stride / 4;
4583 glyph_ptr += glyph->stride;
4584 }
4585 }
4586
4587 static void draw_glyph_32( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4588 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4589 {
4590 DWORD *dst_ptr = get_pixel_ptr_32( dib, rect->left, rect->top );
4591 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4592 int x, y;
4593 DWORD text, val;
4594
4595 text = get_field( text_pixel, dib->red_shift, dib->red_len ) << 16 |
4596 get_field( text_pixel, dib->green_shift, dib->green_len ) << 8 |
4597 get_field( text_pixel, dib->blue_shift, dib->blue_len );
4598
4599 for (y = rect->top; y < rect->bottom; y++)
4600 {
4601 for (x = 0; x < rect->right - rect->left; x++)
4602 {
4603 if (glyph_ptr[x] <= 1) continue;
4604 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
4605 val = aa_rgb( get_field(dst_ptr[x], dib->red_shift, dib->red_len),
4606 get_field(dst_ptr[x], dib->green_shift, dib->green_len),
4607 get_field(dst_ptr[x], dib->blue_shift, dib->blue_len),
4608 text, ranges + glyph_ptr[x] );
4609 dst_ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4610 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4611 put_field( val, dib->blue_shift, dib->blue_len ));
4612 }
4613 dst_ptr += dib->stride / 4;
4614 glyph_ptr += glyph->stride;
4615 }
4616 }
4617
4618 static void draw_glyph_24( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4619 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4620 {
4621 BYTE *dst_ptr = get_pixel_ptr_24( dib, rect->left, rect->top );
4622 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4623 int x, y;
4624 DWORD val;
4625
4626 for (y = rect->top; y < rect->bottom; y++)
4627 {
4628 for (x = 0; x < rect->right - rect->left; x++)
4629 {
4630 if (glyph_ptr[x] <= 1) continue;
4631 if (glyph_ptr[x] >= 16)
4632 val = text_pixel;
4633 else
4634 val = aa_rgb( dst_ptr[x * 3 + 2], dst_ptr[x * 3 + 1], dst_ptr[x * 3],
4635 text_pixel, ranges + glyph_ptr[x] );
4636 dst_ptr[x * 3] = val;
4637 dst_ptr[x * 3 + 1] = val >> 8;
4638 dst_ptr[x * 3 + 2] = val >> 16;
4639 }
4640 dst_ptr += dib->stride;
4641 glyph_ptr += glyph->stride;
4642 }
4643 }
4644
4645 static void draw_glyph_555( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4646 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4647 {
4648 WORD *dst_ptr = get_pixel_ptr_16( dib, rect->left, rect->top );
4649 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4650 int x, y;
4651 DWORD text, val;
4652
4653 text = ((text_pixel << 9) & 0xf80000) | ((text_pixel << 4) & 0x070000) |
4654 ((text_pixel << 6) & 0x00f800) | ((text_pixel << 1) & 0x000700) |
4655 ((text_pixel << 3) & 0x0000f8) | ((text_pixel >> 2) & 0x000007);
4656
4657 for (y = rect->top; y < rect->bottom; y++)
4658 {
4659 for (x = 0; x < rect->right - rect->left; x++)
4660 {
4661 if (glyph_ptr[x] <= 1) continue;
4662 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
4663 val = aa_rgb( ((dst_ptr[x] >> 7) & 0xf8) | ((dst_ptr[x] >> 12) & 0x07),
4664 ((dst_ptr[x] >> 2) & 0xf8) | ((dst_ptr[x] >> 7) & 0x07),
4665 ((dst_ptr[x] << 3) & 0xf8) | ((dst_ptr[x] >> 2) & 0x07),
4666 text, ranges + glyph_ptr[x] );
4667 dst_ptr[x] = ((val >> 9) & 0x7c00) | ((val >> 6) & 0x03e0) | ((val >> 3) & 0x001f);
4668 }
4669 dst_ptr += dib->stride / 2;
4670 glyph_ptr += glyph->stride;
4671 }
4672 }
4673
4674 static void draw_glyph_16( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4675 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4676 {
4677 WORD *dst_ptr = get_pixel_ptr_16( dib, rect->left, rect->top );
4678 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4679 int x, y;
4680 DWORD text, val;
4681
4682 text = get_field( text_pixel, dib->red_shift, dib->red_len ) << 16 |
4683 get_field( text_pixel, dib->green_shift, dib->green_len ) << 8 |
4684 get_field( text_pixel, dib->blue_shift, dib->blue_len );
4685
4686 for (y = rect->top; y < rect->bottom; y++)
4687 {
4688 for (x = 0; x < rect->right - rect->left; x++)
4689 {
4690 if (glyph_ptr[x] <= 1) continue;
4691 if (glyph_ptr[x] >= 16) { dst_ptr[x] = text_pixel; continue; }
4692 val = aa_rgb( get_field(dst_ptr[x], dib->red_shift, dib->red_len),
4693 get_field(dst_ptr[x], dib->green_shift, dib->green_len),
4694 get_field(dst_ptr[x], dib->blue_shift, dib->blue_len),
4695 text, ranges + glyph_ptr[x] );
4696 dst_ptr[x] = (put_field( val >> 16, dib->red_shift, dib->red_len ) |
4697 put_field( val >> 8, dib->green_shift, dib->green_len ) |
4698 put_field( val, dib->blue_shift, dib->blue_len ));
4699 }
4700 dst_ptr += dib->stride / 2;
4701 glyph_ptr += glyph->stride;
4702 }
4703 }
4704
4705 static void draw_glyph_8( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4706 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4707 {
4708 BYTE *dst_ptr = get_pixel_ptr_8( dib, rect->left, rect->top );
4709 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x, origin->y );
4710 int x, y;
4711
4712 for (y = rect->top; y < rect->bottom; y++)
4713 {
4714 for (x = 0; x < rect->right - rect->left; x++)
4715 {
4716 /* no antialiasing, glyph should only contain 0 or 16. */
4717 if (glyph_ptr[x] >= 16)
4718 dst_ptr[x] = text_pixel;
4719 }
4720 dst_ptr += dib->stride;
4721 glyph_ptr += glyph->stride;
4722 }
4723 }
4724
4725 static void draw_glyph_4( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4726 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4727 {
4728 BYTE *dst_ptr = get_pixel_ptr_4( dib, 0, rect->top );
4729 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x - rect->left, origin->y );
4730 int x, y;
4731
4732 for (y = rect->top; y < rect->bottom; y++)
4733 {
4734 for (x = rect->left; x < rect->right; x++)
4735 {
4736 /* no antialiasing, glyph should only contain 0 or 16. */
4737 if (glyph_ptr[x] >= 16)
4738 {
4739 if (x & 1)
4740 dst_ptr[x / 2] = text_pixel | (dst_ptr[x / 2] & 0xf0);
4741 else
4742 dst_ptr[x / 2] = (text_pixel << 4) | (dst_ptr[x / 2] & 0x0f);
4743 }
4744 }
4745 dst_ptr += dib->stride;
4746 glyph_ptr += glyph->stride;
4747 }
4748 }
4749
4750 static void draw_glyph_1( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4751 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4752 {
4753 BYTE *dst_ptr = get_pixel_ptr_1( dib, 0, rect->top );
4754 const BYTE *glyph_ptr = get_pixel_ptr_8( glyph, origin->x - rect->left, origin->y );
4755 int x, y;
4756 BYTE text = (text_pixel & 1) ? 0xff : 0;
4757
4758 for (y = rect->top; y < rect->bottom; y++)
4759 {
4760 for (x = rect->left; x < rect->right; x++)
4761 {
4762 /* no antialiasing, glyph should only contain 0 or 16. */
4763 if (glyph_ptr[x] >= 16)
4764 dst_ptr[x / 8] = (dst_ptr[x / 8] & ~pixel_masks_1[x % 8]) | (text & pixel_masks_1[x % 8]);
4765 }
4766 dst_ptr += dib->stride;
4767 glyph_ptr += glyph->stride;
4768 }
4769 }
4770
4771 static void draw_glyph_null( const dib_info *dib, const RECT *rect, const dib_info *glyph,
4772 const POINT *origin, DWORD text_pixel, const struct intensity_range *ranges )
4773 {
4774 return;
4775 }
4776
4777 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)
4778 {
4779 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
4780 DWORD mask_start = 0, mask_offset;
4781 DWORD *and_bits = bits->and, *xor_bits = bits->xor;
4782 int x, y;
4783
4784 for(y = 0; y < hatch->height; y++)
4785 {
4786 hatch_ptr = hatch_start;
4787 mask_offset = mask_start;
4788 for(x = 0; x < hatch->width; x++)
4789 {
4790 if(*hatch_ptr & pixel_masks_1[x % 8])
4791 {
4792 and_bits[mask_offset] = fg->and;
4793 xor_bits[mask_offset] = fg->xor;
4794 }
4795 else
4796 {
4797 and_bits[mask_offset] = bg->and;
4798 xor_bits[mask_offset] = bg->xor;
4799 }
4800 if(x % 8 == 7) hatch_ptr++;
4801 mask_offset++;
4802 }
4803 hatch_start += hatch->stride;
4804 mask_start += dib->stride / 4;
4805 }
4806
4807 return TRUE;
4808 }
4809
4810 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)
4811 {
4812 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
4813 DWORD mask_start = 0, mask_offset;
4814 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
4815 int x, y;
4816
4817 for(y = 0; y < hatch->height; y++)
4818 {
4819 hatch_ptr = hatch_start;
4820 mask_offset = mask_start;
4821 for(x = 0; x < hatch->width; x++)
4822 {
4823 if(*hatch_ptr & pixel_masks_1[x % 8])
4824 {
4825 and_bits[mask_offset] = fg->and & 0xff;
4826 xor_bits[mask_offset++] = fg->xor & 0xff;
4827 and_bits[mask_offset] = (fg->and >> 8) & 0xff;
4828 xor_bits[mask_offset++] = (fg->xor >> 8) & 0xff;
4829 and_bits[mask_offset] = (fg->and >> 16) & 0xff;
4830 xor_bits[mask_offset++] = (fg->xor >> 16) & 0xff;
4831 }
4832 else
4833 {
4834 and_bits[mask_offset] = bg->and & 0xff;
4835 xor_bits[mask_offset++] = bg->xor & 0xff;
4836 and_bits[mask_offset] = (bg->and >> 8) & 0xff;
4837 xor_bits[mask_offset++] = (bg->xor >> 8) & 0xff;
4838 and_bits[mask_offset] = (bg->and >> 16) & 0xff;
4839 xor_bits[mask_offset++] = (bg->xor >> 16) & 0xff;
4840 }
4841 if(x % 8 == 7) hatch_ptr++;
4842 }
4843 hatch_start += hatch->stride;
4844 mask_start += dib->stride;
4845 }
4846
4847 return TRUE;
4848 }
4849
4850 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)
4851 {
4852 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
4853 DWORD mask_start = 0, mask_offset;
4854 WORD *and_bits = bits->and, *xor_bits = bits->xor;
4855 int x, y;
4856
4857 for(y = 0; y < hatch->height; y++)
4858 {
4859 hatch_ptr = hatch_start;
4860 mask_offset = mask_start;
4861 for(x = 0; x < hatch->width; x++)
4862 {
4863 if(*hatch_ptr & pixel_masks_1[x % 8])
4864 {
4865 and_bits[mask_offset] = fg->and;
4866 xor_bits[mask_offset] = fg->xor;
4867 }
4868 else
4869 {
4870 and_bits[mask_offset] = bg->and;
4871 xor_bits[mask_offset] = bg->xor;
4872 }
4873 if(x % 8 == 7) hatch_ptr++;
4874 mask_offset++;
4875 }
4876 hatch_start += hatch->stride;
4877 mask_start += dib->stride / 2;
4878 }
4879
4880 return TRUE;
4881 }
4882
4883 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)
4884 {
4885 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
4886 DWORD mask_start = 0, mask_offset;
4887 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
4888 int x, y;
4889
4890 for(y = 0; y < hatch->height; y++)
4891 {
4892 hatch_ptr = hatch_start;
4893 mask_offset = mask_start;
4894 for(x = 0; x < hatch->width; x++)
4895 {
4896 if(*hatch_ptr & pixel_masks_1[x % 8])
4897 {
4898 and_bits[mask_offset] = fg->and;
4899 xor_bits[mask_offset] = fg->xor;
4900 }
4901 else
4902 {
4903 and_bits[mask_offset] = bg->and;
4904 xor_bits[mask_offset] = bg->xor;
4905 }
4906 if(x % 8 == 7) hatch_ptr++;
4907 mask_offset++;
4908 }
4909 hatch_start += hatch->stride;
4910 mask_start += dib->stride;
4911 }
4912
4913 return TRUE;
4914 }
4915
4916 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)
4917 {
4918 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
4919 DWORD mask_start = 0, mask_offset;
4920 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
4921 const rop_mask *rop_mask;
4922 int x, y;
4923
4924 for(y = 0; y < hatch->height; y++)
4925 {
4926 hatch_ptr = hatch_start;
4927 mask_offset = mask_start;
4928 for(x = 0; x < hatch->width; x++)
4929 {
4930 if(*hatch_ptr & pixel_masks_1[x % 8])
4931 rop_mask = fg;
4932 else
4933 rop_mask = bg;
4934
4935 if(x & 1)
4936 {
4937 and_bits[mask_offset] = (rop_mask->and & 0x0f) | (and_bits[mask_offset] & 0xf0);
4938 xor_bits[mask_offset] = (rop_mask->xor & 0x0f) | (xor_bits[mask_offset] & 0xf0);
4939 mask_offset++;
4940 }
4941 else
4942 {
4943 and_bits[mask_offset] = (rop_mask->and << 4) & 0xf0;
4944 xor_bits[mask_offset] = (rop_mask->xor << 4) & 0xf0;
4945 }
4946
4947 if(x % 8 == 7) hatch_ptr++;
4948 }
4949 hatch_start += hatch->stride;
4950 mask_start += dib->stride;
4951 }
4952
4953 return TRUE;
4954 }
4955
4956 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)
4957 {
4958 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
4959 DWORD mask_start = 0, mask_offset;
4960 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
4961 rop_mask rop_mask;
4962 int x, y, bit_pos;
4963
4964 for(y = 0; y < hatch->height; y++)
4965 {
4966 hatch_ptr = hatch_start;
4967 mask_offset = mask_start;
4968 for(x = 0, bit_pos = 0; x < hatch->width; x++)
4969 {
4970 if(*hatch_ptr & pixel_masks_1[x % 8])
4971 {
4972 rop_mask.and = (fg->and & 1) ? 0xff : 0;
4973 rop_mask.xor = (fg->xor & 1) ? 0xff : 0;
4974 }
4975 else
4976 {
4977 rop_mask.and = (bg->and & 1) ? 0xff : 0;
4978 rop_mask.xor = (bg->xor & 1) ? 0xff : 0;
4979 }
4980
4981 if(bit_pos == 0) and_bits[mask_offset] = xor_bits[mask_offset] = 0;
4982
4983 and_bits[mask_offset] = (rop_mask.and & pixel_masks_1[bit_pos]) | (and_bits[mask_offset] & ~pixel_masks_1[bit_pos]);
4984 xor_bits[mask_offset] = (rop_mask.xor & pixel_masks_1[bit_pos]) | (xor_bits[mask_offset] & ~pixel_masks_1[bit_pos]);
4985
4986 if(++bit_pos == 8)
4987 {
4988 mask_offset++;
4989 hatch_ptr++;
4990 bit_pos = 0;
4991 }
4992 }
4993 hatch_start += hatch->stride;
4994 mask_start += dib->stride;
4995 }
4996
4997 return TRUE;
4998 }
4999
5000 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)
5001 {
5002 return FALSE;
5003 }
5004
5005 static inline void rop_codes_from_stretch_mode( int mode, struct rop_codes *codes )
5006 {
5007 switch (mode)
5008 {
5009 default:
5010 case STRETCH_DELETESCANS:
5011 get_rop_codes( R2_COPYPEN, codes );
5012 break;
5013 case STRETCH_ORSCANS:
5014 get_rop_codes( R2_MERGEPEN, codes );
5015 break;
5016 case STRETCH_ANDSCANS:
5017 get_rop_codes( R2_MASKPEN, codes );
5018 break;
5019 }
5020 return;
5021 }
5022
5023 static void stretch_row_32(const dib_info *dst_dib, const POINT *dst_start,
5024 const dib_info *src_dib, const POINT *src_start,
5025 const struct stretch_params *params, int mode,
5026 BOOL keep_dst)
5027 {
5028 DWORD *dst_ptr = get_pixel_ptr_32( dst_dib, dst_start->x, dst_start->y );
5029 DWORD *src_ptr = get_pixel_ptr_32( src_dib, src_start->x, src_start->y );
5030 int err = params->err_start;
5031 int width;
5032 struct rop_codes codes;
5033
5034 rop_codes_from_stretch_mode( mode, &codes );
5035 for (width = params->length; width; width--)
5036 {
5037 do_rop_codes_32( dst_ptr, *src_ptr, &codes );
5038 dst_ptr += params->dst_inc;
5039 if (err > 0)
5040 {
5041 src_ptr += params->src_inc;
5042 err += params->err_add_1;
5043 }
5044 else err += params->err_add_2;
5045 }
5046 }
5047
5048 static void stretch_row_24(const dib_info *dst_dib, const POINT *dst_start,
5049 const dib_info *src_dib, const POINT *src_start,
5050 const struct stretch_params *params, int mode,
5051 BOOL keep_dst)
5052 {
5053 BYTE *dst_ptr = get_pixel_ptr_24( dst_dib, dst_start->x, dst_start->y );
5054 BYTE *src_ptr = get_pixel_ptr_24( src_dib, src_start->x, src_start->y );
5055 int err = params->err_start;
5056 int width;
5057 struct rop_codes codes;
5058
5059 rop_codes_from_stretch_mode( mode, &codes );
5060 for (width = params->length; width; width--)
5061 {
5062 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
5063 do_rop_codes_8( dst_ptr + 1, *(src_ptr + 1), &codes );
5064 do_rop_codes_8( dst_ptr + 2, *(src_ptr + 2), &codes );
5065 dst_ptr += 3 * params->dst_inc;
5066 if (err > 0)
5067 {
5068 src_ptr += 3 * params->src_inc;
5069 err += params->err_add_1;
5070 }
5071 else err += params->err_add_2;
5072 }
5073 }
5074
5075 static void stretch_row_16(const dib_info *dst_dib, const POINT *dst_start,
5076 const dib_info *src_dib, const POINT *src_start,
5077 const struct stretch_params *params, int mode,
5078 BOOL keep_dst)
5079 {
5080 WORD *dst_ptr = get_pixel_ptr_16( dst_dib, dst_start->x, dst_start->y );
5081 WORD *src_ptr = get_pixel_ptr_16( src_dib, src_start->x, src_start->y );
5082 int err = params->err_start;
5083 int width;
5084 struct rop_codes codes;
5085
5086 rop_codes_from_stretch_mode( mode, &codes );
5087 for (width = params->length; width; width--)
5088 {
5089 do_rop_codes_16( dst_ptr, *src_ptr, &codes );
5090 dst_ptr += params->dst_inc;
5091 if (err > 0)
5092 {
5093 src_ptr += params->src_inc;
5094 err += params->err_add_1;
5095 }
5096 else err += params->err_add_2;
5097 }
5098 }
5099
5100 static void stretch_row_8(const dib_info *dst_dib, const POINT *dst_start,
5101 const dib_info *src_dib, const POINT *src_start,
5102 const struct stretch_params *params, int mode,
5103 BOOL keep_dst)
5104 {
5105 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
5106 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
5107 int err = params->err_start;
5108 int width;
5109 struct rop_codes codes;
5110
5111 rop_codes_from_stretch_mode( mode, &codes );
5112 for (width = params->length; width; width--)
5113 {
5114 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
5115 dst_ptr += params->dst_inc;
5116 if (err > 0)
5117 {
5118 src_ptr += params->src_inc;
5119 err += params->err_add_1;
5120 }
5121 else err += params->err_add_2;
5122 }
5123 }
5124
5125 static void stretch_row_4(const dib_info *dst_dib, const POINT *dst_start,
5126 const dib_info *src_dib, const POINT *src_start,
5127 const struct stretch_params *params, int mode,
5128 BOOL keep_dst)
5129 {
5130 BYTE *dst_ptr = get_pixel_ptr_4( dst_dib, dst_start->x, dst_start->y );
5131 BYTE *src_ptr = get_pixel_ptr_4( src_dib, src_start->x, src_start->y );
5132 int err = params->err_start;
5133 int width, dst_x = dst_start->x, src_x = src_start->x;
5134 struct rop_codes codes;
5135 BYTE src_val;
5136
5137 rop_codes_from_stretch_mode( mode, &codes );
5138 for (width = params->length; width; width--)
5139 {
5140 if (src_x & 1) src_val = (*src_ptr & 0x0f) | (*src_ptr << 4);
5141 else src_val = (*src_ptr & 0xf0) | (*src_ptr >> 4);
5142
5143 do_rop_codes_mask_8( dst_ptr, src_val, &codes, (dst_x & 1) ? 0x0f : 0xf0 );
5144
5145 if ((dst_x & ~1) != ((dst_x + params->dst_inc) & ~1))
5146 dst_ptr += params->dst_inc;
5147 dst_x += params->dst_inc;
5148
5149 if (err > 0)
5150 {
5151 if ((src_x & ~1) != ((src_x + params->src_inc) & ~1))
5152 src_ptr += params->src_inc;
5153 src_x += params->src_inc;
5154 err += params->err_add_1;
5155 }
5156 else err += params->err_add_2;
5157 }
5158 }
5159
5160 static void stretch_row_1(const dib_info *dst_dib, const POINT *dst_start,
5161 const dib_info *src_dib, const POINT *src_start,
5162 const struct stretch_params *params, int mode,
5163 BOOL keep_dst)
5164 {
5165 BYTE *dst_ptr = get_pixel_ptr_1( dst_dib, dst_start->x, dst_start->y );
5166 BYTE *src_ptr = get_pixel_ptr_1( src_dib, src_start->x, src_start->y );
5167 int err = params->err_start;
5168 int width, dst_x = dst_start->x, src_x = src_start->x;
5169 struct rop_codes codes;
5170 BYTE src_val;
5171
5172 rop_codes_from_stretch_mode( mode, &codes );
5173 for (width = params->length; width; width--)
5174 {
5175 src_val = *src_ptr & pixel_masks_1[src_x % 8] ? 0xff : 0;
5176 do_rop_codes_mask_8( dst_ptr, src_val, &codes, pixel_masks_1[dst_x % 8] );
5177
5178 if ((dst_x & ~7) != ((dst_x + params->dst_inc) & ~7))
5179 dst_ptr += params->dst_inc;
5180 dst_x += params->dst_inc;
5181
5182 if (err > 0)
5183 {
5184 if ((src_x & ~7) != ((src_x + params->src_inc) & ~7))
5185 src_ptr += params->src_inc;
5186 src_x += params->src_inc;
5187 err += params->err_add_1;
5188 }
5189 else err += params->err_add_2;
5190 }
5191 }
5192
5193 static void stretch_row_null(const dib_info *dst_dib, const POINT *dst_start,
5194 const dib_info *src_dib, const POINT *src_start,
5195 const struct stretch_params *params, int mode,
5196 BOOL keep_dst)
5197 {
5198 FIXME("bit count %d\n", dst_dib->bit_count);
5199 return;
5200 }
5201
5202 static void shrink_row_32(const dib_info *dst_dib, const POINT *dst_start,
5203 const dib_info *src_dib, const POINT *src_start,
5204 const struct stretch_params *params, int mode,
5205 BOOL keep_dst)
5206 {
5207 DWORD *dst_ptr = get_pixel_ptr_32( dst_dib, dst_start->x, dst_start->y );
5208 DWORD *src_ptr = get_pixel_ptr_32( src_dib, src_start->x, src_start->y );
5209 int err = params->err_start;
5210 int width;
5211 struct rop_codes codes;
5212 DWORD init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
5213 BOOL new_pix = TRUE;
5214
5215 rop_codes_from_stretch_mode( mode, &codes );
5216 for (width = params->length; width; width--)
5217 {
5218 if (new_pix && !keep_dst) *dst_ptr = init_val;
5219 do_rop_codes_32( dst_ptr, *src_ptr, &codes );
5220 new_pix = FALSE;
5221 src_ptr += params->src_inc;
5222 if (err > 0)
5223 {
5224 dst_ptr += params->dst_inc;
5225 new_pix = TRUE;
5226 err += params->err_add_1;
5227 }
5228 else err += params->err_add_2;
5229 }
5230 }
5231
5232 static void shrink_row_24(const dib_info *dst_dib, const POINT *dst_start,
5233 const dib_info *src_dib, const POINT *src_start,
5234 const struct stretch_params *params, int mode,
5235 BOOL keep_dst)
5236 {
5237 BYTE *dst_ptr = get_pixel_ptr_24( dst_dib, dst_start->x, dst_start->y );
5238 BYTE *src_ptr = get_pixel_ptr_24( src_dib, src_start->x, src_start->y );
5239 int err = params->err_start;
5240 int width;
5241 struct rop_codes codes;
5242 BYTE init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
5243 BOOL new_pix = TRUE;
5244
5245 rop_codes_from_stretch_mode( mode, &codes );
5246 for (width = params->length; width; width--)
5247 {
5248 if (new_pix && !keep_dst) memset( dst_ptr, init_val, 3 );
5249 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
5250 do_rop_codes_8( dst_ptr + 1, *(src_ptr + 1), &codes );
5251 do_rop_codes_8( dst_ptr + 2, *(src_ptr + 2), &codes );
5252 new_pix = FALSE;
5253 src_ptr += 3 * params->src_inc;
5254 if (err > 0)
5255 {
5256 dst_ptr += 3 * params->dst_inc;
5257 new_pix = TRUE;
5258 err += params->err_add_1;
5259 }
5260 else err += params->err_add_2;
5261 }
5262 }
5263
5264 static void shrink_row_16(const dib_info *dst_dib, const POINT *dst_start,
5265 const dib_info *src_dib, const POINT *src_start,
5266 const struct stretch_params *params, int mode,
5267 BOOL keep_dst)
5268 {
5269 WORD *dst_ptr = get_pixel_ptr_16( dst_dib, dst_start->x, dst_start->y );
5270 WORD *src_ptr = get_pixel_ptr_16( src_dib, src_start->x, src_start->y );
5271 int err = params->err_start;
5272 int width;
5273 struct rop_codes codes;
5274 WORD init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
5275 BOOL new_pix = TRUE;
5276
5277 rop_codes_from_stretch_mode( mode, &codes );
5278 for (width = params->length; width; width--)
5279 {
5280 if (new_pix && !keep_dst) *dst_ptr = init_val;
5281 do_rop_codes_16( dst_ptr, *src_ptr, &codes );
5282 new_pix = FALSE;
5283 src_ptr += params->src_inc;
5284 if (err > 0)
5285 {
5286 dst_ptr += params->dst_inc;
5287 new_pix = TRUE;
5288 err += params->err_add_1;
5289 }
5290 else err += params->err_add_2;
5291 }
5292 }
5293
5294 static void shrink_row_8(const dib_info *dst_dib, const POINT *dst_start,
5295 const dib_info *src_dib, const POINT *src_start,
5296 const struct stretch_params *params, int mode,
5297 BOOL keep_dst)
5298 {
5299 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
5300 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
5301 int err = params->err_start;
5302 int width;
5303 struct rop_codes codes;
5304 BYTE init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
5305 BOOL new_pix = TRUE;
5306
5307 rop_codes_from_stretch_mode( mode, &codes );
5308 for (width = params->length; width; width--)
5309 {
5310 if (new_pix && !keep_dst) *dst_ptr = init_val;
5311 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
5312 new_pix = FALSE;
5313 src_ptr += params->src_inc;
5314 if (err > 0)
5315 {
5316 dst_ptr += params->dst_inc;
5317 new_pix = TRUE;
5318 err += params->err_add_1;
5319 }
5320 else err += params->err_add_2;
5321 }
5322 }
5323
5324 static void shrink_row_4(const dib_info *dst_dib, const POINT *dst_start,
5325 const dib_info *src_dib, const POINT *src_start,
5326 const struct stretch_params *params, int mode,
5327 BOOL keep_dst)
5328 {
5329 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
5330 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
5331 int err = params->err_start;
5332 int width, dst_x = dst_start->x, src_x = src_start->x;
5333 struct rop_codes codes;
5334 BYTE src_val, init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
5335 BOOL new_pix = TRUE;
5336
5337 rop_codes_from_stretch_mode( mode, &codes );
5338 for (width = params->length; width; width--)
5339 {
5340 if (new_pix && !keep_dst) do_rop_mask_8( dst_ptr, 0, init_val, (dst_x & 1) ? 0xf0 : 0x0f );
5341
5342 if (src_x & 1) src_val = (*src_ptr & 0x0f) | (*src_ptr << 4);
5343 else src_val = (*src_ptr & 0xf0) | (*src_ptr >> 4);
5344
5345 do_rop_codes_mask_8( dst_ptr, src_val, &codes, (dst_x & 1) ? 0xf0 : 0x0f );
5346 new_pix = FALSE;
5347
5348 if ((src_x & ~1) != ((src_x + params->src_inc) & ~1))
5349 src_ptr += params->src_inc;
5350 src_x += params->src_inc;
5351
5352 if (err > 0)
5353 {
5354 if ((dst_x & ~1) != ((dst_x + params->dst_inc) & ~1))
5355 dst_ptr += params->dst_inc;
5356 dst_x += params->dst_inc;
5357 new_pix = TRUE;
5358 err += params->err_add_1;
5359 }
5360 else err += params->err_add_2;
5361 }
5362 }
5363
5364 static void shrink_row_1(const dib_info *dst_dib, const POINT *dst_start,
5365 const dib_info *src_dib, const POINT *src_start,
5366 const struct stretch_params *params, int mode,
5367 BOOL keep_dst)
5368 {
5369 BYTE *dst_ptr = get_pixel_ptr_1( dst_dib, dst_start->x, dst_start->y );
5370 BYTE *src_ptr = get_pixel_ptr_1( src_dib, src_start->x, src_start->y );
5371 int err = params->err_start;
5372 int width, dst_x = dst_start->x, src_x = src_start->x;
5373 struct rop_codes codes;
5374 BYTE src_val, init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
5375 BOOL new_pix = TRUE;
5376
5377 rop_codes_from_stretch_mode( mode, &codes );
5378 for (width = params->length; width; width--)
5379 {
5380 if (new_pix && !keep_dst) do_rop_mask_8( dst_ptr, 0, init_val, pixel_masks_1[dst_x % 8] );
5381 src_val = *src_ptr & pixel_masks_1[src_x % 8] ? 0xff : 0;
5382 do_rop_codes_mask_8( dst_ptr, src_val, &codes, pixel_masks_1[dst_x % 8] );
5383 new_pix = FALSE;
5384
5385 if ((src_x & ~7) != ((src_x + params->src_inc) & ~7))
5386 src_ptr += params->src_inc;
5387 src_x += params->src_inc;
5388
5389 if (err > 0)
5390 {
5391 if ((dst_x & ~7) != ((dst_x + params->dst_inc) & ~7))
5392 dst_ptr += params->dst_inc;
5393 dst_x += params->dst_inc;
5394 new_pix = TRUE;
5395 err += params->err_add_1;
5396 }
5397 else err += params->err_add_2;
5398 }
5399 }
5400
5401 static void shrink_row_null(const dib_info *dst_dib, const POINT *dst_start,
5402 const dib_info *src_dib, const POINT *src_start,
5403 const struct stretch_params *params, int mode,
5404 BOOL keep_dst)
5405 {
5406 FIXME("bit count %d\n", dst_dib->bit_count);
5407 return;
5408 }
5409
5410 const primitive_funcs funcs_8888 =
5411 {
5412 solid_rects_32,
5413 solid_line_32,
5414 pattern_rects_32,
5415 copy_rect_32,
5416 blend_rect_8888,
5417 gradient_rect_8888,
5418 draw_glyph_8888,
5419 get_pixel_32,
5420 colorref_to_pixel_888,
5421 pixel_to_colorref_888,
5422 convert_to_8888,
5423 create_rop_masks_32,
5424 stretch_row_32,
5425 shrink_row_32
5426 };
5427
5428 const primitive_funcs funcs_32 =
5429 {
5430 solid_rects_32,
5431 solid_line_32,
5432 pattern_rects_32,
5433 copy_rect_32,
5434 blend_rect_32,
5435 gradient_rect_32,
5436 draw_glyph_32,
5437 get_pixel_32,
5438 colorref_to_pixel_masks,
5439 pixel_to_colorref_masks,
5440 convert_to_32,
5441 create_rop_masks_32,
5442 stretch_row_32,
5443 shrink_row_32
5444 };
5445
5446 const primitive_funcs funcs_24 =
5447 {
5448 solid_rects_24,
5449 solid_line_24,
5450 pattern_rects_24,
5451 copy_rect_24,
5452 blend_rect_24,
5453 gradient_rect_24,
5454 draw_glyph_24,
5455 get_pixel_24,
5456 colorref_to_pixel_888,
5457 pixel_to_colorref_888,
5458 convert_to_24,
5459 create_rop_masks_24,
5460 stretch_row_24,
5461 shrink_row_24
5462 };
5463
5464 const primitive_funcs funcs_555 =
5465 {
5466 solid_rects_16,
5467 solid_line_16,
5468 pattern_rects_16,
5469 copy_rect_16,
5470 blend_rect_555,
5471 gradient_rect_555,
5472 draw_glyph_555,
5473 get_pixel_16,
5474 colorref_to_pixel_555,
5475 pixel_to_colorref_555,
5476 convert_to_555,
5477 create_rop_masks_16,
5478 stretch_row_16,
5479 shrink_row_16
5480 };
5481
5482 const primitive_funcs funcs_16 =
5483 {
5484 solid_rects_16,
5485 solid_line_16,
5486 pattern_rects_16,
5487 copy_rect_16,
5488 blend_rect_16,
5489 gradient_rect_16,
5490 draw_glyph_16,
5491 get_pixel_16,
5492 colorref_to_pixel_masks,
5493 pixel_to_colorref_masks,
5494 convert_to_16,
5495 create_rop_masks_16,
5496 stretch_row_16,
5497 shrink_row_16
5498 };
5499
5500 const primitive_funcs funcs_8 =
5501 {
5502 solid_rects_8,
5503 solid_line_8,
5504 pattern_rects_8,
5505 copy_rect_8,
5506 blend_rect_8,
5507 gradient_rect_8,
5508 draw_glyph_8,
5509 get_pixel_8,
5510 colorref_to_pixel_colortable,
5511 pixel_to_colorref_colortable,
5512 convert_to_8,
5513 create_rop_masks_8,
5514 stretch_row_8,
5515 shrink_row_8
5516 };
5517
5518 const primitive_funcs funcs_4 =
5519 {
5520 solid_rects_4,
5521 solid_line_4,
5522 pattern_rects_4,
5523 copy_rect_4,
5524 blend_rect_4,
5525 gradient_rect_4,
5526 draw_glyph_4,
5527 get_pixel_4,
5528 colorref_to_pixel_colortable,
5529 pixel_to_colorref_colortable,
5530 convert_to_4,
5531 create_rop_masks_4,
5532 stretch_row_4,
5533 shrink_row_4
5534 };
5535
5536 const primitive_funcs funcs_1 =
5537 {
5538 solid_rects_1,
5539 solid_line_1,
5540 pattern_rects_1,
5541 copy_rect_1,
5542 blend_rect_1,
5543 gradient_rect_1,
5544 draw_glyph_1,
5545 get_pixel_1,
5546 colorref_to_pixel_colortable,
5547 pixel_to_colorref_colortable,
5548 convert_to_1,
5549 create_rop_masks_1,
5550 stretch_row_1,
5551 shrink_row_1
5552 };
5553
5554 const primitive_funcs funcs_null =
5555 {
5556 solid_rects_null,
5557 solid_line_null,
5558 pattern_rects_null,
5559 copy_rect_null,
5560 blend_rect_null,
5561 gradient_rect_null,
5562 draw_glyph_null,
5563 get_pixel_null,
5564 colorref_to_pixel_null,
5565 pixel_to_colorref_null,
5566 convert_to_null,
5567 create_rop_masks_null,
5568 stretch_row_null,
5569 shrink_row_null
5570 };
Maarten's multimedia branch