?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Add a helper for RGB to color index mapping to avoid redundant shifts.
[wine/multimedia.git] / dlls / gdi32 / dibdrv / primitives.c
blobda009a2c4b199365b53c3d3ecf42f61b734779e4
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 static inline DWORD *get_pixel_ptr_32(const dib_info *dib, int x, int y)
31 {
32 return (DWORD *)((BYTE*)dib->bits.ptr + y * dib->stride + x * 4);
33 }
34
35 static inline DWORD *get_pixel_ptr_24_dword(const dib_info *dib, int x, int y)
36 {
37 return (DWORD *)((BYTE*)dib->bits.ptr + y * dib->stride) + x * 3 / 4;
38 }
39
40 static inline BYTE *get_pixel_ptr_24(const dib_info *dib, int x, int y)
41 {
42 return (BYTE*)dib->bits.ptr + y * dib->stride + x * 3;
43 }
44
45 static inline WORD *get_pixel_ptr_16(const dib_info *dib, int x, int y)
46 {
47 return (WORD *)((BYTE*)dib->bits.ptr + y * dib->stride + x * 2);
48 }
49
50 static inline BYTE *get_pixel_ptr_8(const dib_info *dib, int x, int y)
51 {
52 return (BYTE*)dib->bits.ptr + y * dib->stride + x;
53 }
54
55 static inline BYTE *get_pixel_ptr_4(const dib_info *dib, int x, int y)
56 {
57 return (BYTE*)dib->bits.ptr + y * dib->stride + x / 2;
58 }
59
60 static inline BYTE *get_pixel_ptr_1(const dib_info *dib, int x, int y)
61 {
62 return (BYTE*)dib->bits.ptr + y * dib->stride + x / 8;
63 }
64
65 static const BYTE pixel_masks_1[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
66
67 static inline void do_rop_32(DWORD *ptr, DWORD and, DWORD xor)
68 {
69 *ptr = (*ptr & and) ^ xor;
70 }
71
72 static inline void do_rop_16(WORD *ptr, WORD and, WORD xor)
73 {
74 *ptr = (*ptr & and) ^ xor;
75 }
76
77 static inline void do_rop_8(BYTE *ptr, BYTE and, BYTE xor)
78 {
79 *ptr = (*ptr & and) ^ xor;
80 }
81
82 static inline void do_rop_mask_8(BYTE *ptr, BYTE and, BYTE xor, BYTE mask)
83 {
84 *ptr = (*ptr & (and | ~mask)) ^ (xor & mask);
85 }
86
87 static inline void do_rop_codes_32(DWORD *dst, DWORD src, struct rop_codes *codes)
88 {
89 do_rop_32( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2 );
90 }
91
92 static inline void do_rop_codes_16(WORD *dst, WORD src, struct rop_codes *codes)
93 {
94 do_rop_16( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2 );
95 }
96
97 static inline void do_rop_codes_8(BYTE *dst, BYTE src, struct rop_codes *codes)
98 {
99 do_rop_8( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2 );
100 }
101
102 static inline void do_rop_codes_mask_8(BYTE *dst, BYTE src, struct rop_codes *codes, BYTE mask)
103 {
104 do_rop_mask_8( dst, (src & codes->a1) ^ codes->a2, (src & codes->x1) ^ codes->x2, mask );
105 }
106
107 static inline void do_rop_codes_line_32(DWORD *dst, const DWORD *src, struct rop_codes *codes, int len)
108 {
109 for (; len > 0; len--, src++, dst++) do_rop_codes_32( dst, *src, codes );
110 }
111
112 static inline void do_rop_codes_line_rev_32(DWORD *dst, const DWORD *src, struct rop_codes *codes, int len)
113 {
114 for (src += len - 1, dst += len - 1; len > 0; len--, src--, dst--)
115 do_rop_codes_32( dst, *src, codes );
116 }
117
118 static inline void do_rop_codes_line_16(WORD *dst, const WORD *src, struct rop_codes *codes, int len)
119 {
120 for (; len > 0; len--, src++, dst++) do_rop_codes_16( dst, *src, codes );
121 }
122
123 static inline void do_rop_codes_line_rev_16(WORD *dst, const WORD *src, struct rop_codes *codes, int len)
124 {
125 for (src += len - 1, dst += len - 1; len > 0; len--, src--, dst--)
126 do_rop_codes_16( dst, *src, codes );
127 }
128
129 static inline void do_rop_codes_line_8(BYTE *dst, const BYTE *src, struct rop_codes *codes, int len)
130 {
131 for (; len > 0; len--, src++, dst++) do_rop_codes_8( dst, *src, codes );
132 }
133
134 static inline void do_rop_codes_line_rev_8(BYTE *dst, const BYTE *src, struct rop_codes *codes, int len)
135 {
136 for (src += len - 1, dst += len - 1; len > 0; len--, src--, dst--)
137 do_rop_codes_8( dst, *src, codes );
138 }
139
140 static inline void do_rop_codes_line_4(BYTE *dst, int dst_x, const BYTE *src, int src_x,
141 struct rop_codes *codes, int len)
142 {
143 BYTE src_val;
144
145 for (src += src_x / 2, dst += dst_x / 2; len > 0; len--, dst_x++, src_x++)
146 {
147 if (dst_x & 1)
148 {
149 if (src_x & 1) src_val = *src++;
150 else src_val = *src >> 4;
151 do_rop_codes_mask_8( dst++, src_val, codes, 0x0f );
152 }
153 else
154 {
155 if (src_x & 1) src_val = *src++ << 4;
156 else src_val = *src;
157 do_rop_codes_mask_8( dst, src_val, codes, 0xf0 );
158 }
159 }
160 }
161
162 static inline void do_rop_codes_line_rev_4(BYTE *dst, int dst_x, const BYTE *src, int src_x,
163 struct rop_codes *codes, int len)
164 {
165 BYTE src_val;
166
167 src_x += len - 1;
168 dst_x += len - 1;
169 for (src += src_x / 2, dst += dst_x / 2; len > 0; len--, dst_x--, src_x--)
170 {
171 if (dst_x & 1)
172 {
173 if (src_x & 1) src_val = *src;
174 else src_val = *src-- >> 4;
175 do_rop_codes_mask_8( dst, src_val, codes, 0x0f );
176 }
177 else
178 {
179 if (src_x & 1) src_val = *src << 4;
180 else src_val = *src--;
181 do_rop_codes_mask_8( dst--, src_val, codes, 0xf0 );
182 }
183 }
184 }
185
186 static inline void do_rop_codes_line_1(BYTE *dst, int dst_x, const BYTE *src, int src_x,
187 struct rop_codes *codes, int len)
188 {
189 BYTE src_val;
190
191 for (src += src_x / 8, dst += dst_x / 8; len > 0; len--, dst_x++, src_x++)
192 {
193 src_val = *src & pixel_masks_1[src_x & 7] ? 0xff : 0;
194 do_rop_codes_mask_8( dst, src_val, codes, pixel_masks_1[dst_x & 7] );
195 if ((src_x & 7) == 7) src++;
196 if ((dst_x & 7) == 7) dst++;
197 }
198 }
199
200 static inline void do_rop_codes_line_rev_1(BYTE *dst, int dst_x, const BYTE *src, int src_x,
201 struct rop_codes *codes, int len)
202 {
203 BYTE src_val;
204
205 src_x += len - 1;
206 dst_x += len - 1;
207 for (src += src_x / 8, dst += dst_x / 8; len > 0; len--, dst_x--, src_x--)
208 {
209 src_val = *src & pixel_masks_1[src_x & 7] ? 0xff : 0;
210 do_rop_codes_mask_8( dst, src_val, codes, pixel_masks_1[dst_x & 7] );
211 if ((src_x & 7) == 0) src--;
212 if ((dst_x & 7) == 0) dst--;
213 }
214 }
215
216 static void solid_rects_32(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
217 {
218 DWORD *ptr, *start;
219 int x, y, i;
220
221 for(i = 0; i < num; i++, rc++)
222 {
223 start = get_pixel_ptr_32(dib, rc->left, rc->top);
224 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
225 for(x = rc->left, ptr = start; x < rc->right; x++)
226 do_rop_32(ptr++, and, xor);
227 }
228 }
229
230 static void solid_rects_24(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
231 {
232 DWORD *ptr, *start;
233 BYTE *byte_ptr, *byte_start;
234 int x, y, i;
235 DWORD and_masks[3], xor_masks[3];
236
237 and_masks[0] = ( and & 0x00ffffff) | ((and << 24) & 0xff000000);
238 and_masks[1] = ((and >> 8) & 0x0000ffff) | ((and << 16) & 0xffff0000);
239 and_masks[2] = ((and >> 16) & 0x000000ff) | ((and << 8) & 0xffffff00);
240 xor_masks[0] = ( xor & 0x00ffffff) | ((xor << 24) & 0xff000000);
241 xor_masks[1] = ((xor >> 8) & 0x0000ffff) | ((xor << 16) & 0xffff0000);
242 xor_masks[2] = ((xor >> 16) & 0x000000ff) | ((xor << 8) & 0xffffff00);
243
244 for(i = 0; i < num; i++, rc++)
245 {
246 if(rc->left >= rc->right) continue;
247
248 if((rc->left & ~3) == (rc->right & ~3)) /* Special case for lines that start and end in the same DWORD triplet */
249 {
250 byte_start = get_pixel_ptr_24(dib, rc->left, rc->top);
251 for(y = rc->top; y < rc->bottom; y++, byte_start += dib->stride)
252 {
253 for(x = rc->left, byte_ptr = byte_start; x < rc->right; x++)
254 {
255 do_rop_8(byte_ptr++, and_masks[0] & 0xff, xor_masks[0] & 0xff);
256 do_rop_8(byte_ptr++, and_masks[1] & 0xff, xor_masks[1] & 0xff);
257 do_rop_8(byte_ptr++, and_masks[2] & 0xff, xor_masks[2] & 0xff);
258 }
259 }
260 }
261 else
262 {
263 start = get_pixel_ptr_24_dword(dib, rc->left, rc->top);
264 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
265 {
266 ptr = start;
267
268 switch(rc->left & 3)
269 {
270 case 1:
271 do_rop_32(ptr++, and_masks[0] | 0x00ffffff, xor_masks[0] & 0xff000000);
272 do_rop_32(ptr++, and_masks[1], xor_masks[1]);
273 do_rop_32(ptr++, and_masks[2], xor_masks[2]);
274 break;
275 case 2:
276 do_rop_32(ptr++, and_masks[1] | 0x0000ffff, xor_masks[1] & 0xffff0000);
277 do_rop_32(ptr++, and_masks[2], xor_masks[2]);
278 break;
279 case 3:
280 do_rop_32(ptr++, and_masks[2] | 0x000000ff, xor_masks[2] & 0xffffff00);
281 break;
282 }
283
284 for(x = (rc->left + 3) & ~3; x < (rc->right & ~3); x += 4)
285 {
286 do_rop_32(ptr++, and_masks[0], xor_masks[0]);
287 do_rop_32(ptr++, and_masks[1], xor_masks[1]);
288 do_rop_32(ptr++, and_masks[2], xor_masks[2]);
289 }
290
291 switch(rc->right & 3)
292 {
293 case 1:
294 do_rop_32(ptr, and_masks[0] | 0xff000000, xor_masks[0] & 0x00ffffff);
295 break;
296 case 2:
297 do_rop_32(ptr++, and_masks[0], xor_masks[0]);
298 do_rop_32(ptr, and_masks[1] | 0xffff0000, xor_masks[1] & 0x0000ffff);
299 break;
300 case 3:
301 do_rop_32(ptr++, and_masks[0], xor_masks[0]);
302 do_rop_32(ptr++, and_masks[1], xor_masks[1]);
303 do_rop_32(ptr, and_masks[2] | 0xffffff00, xor_masks[2] & 0x000000ff);
304 break;
305 }
306 }
307 }
308 }
309 }
310
311 static void solid_rects_16(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
312 {
313 WORD *ptr, *start;
314 int x, y, i;
315
316 for(i = 0; i < num; i++, rc++)
317 {
318 start = get_pixel_ptr_16(dib, rc->left, rc->top);
319 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
320 for(x = rc->left, ptr = start; x < rc->right; x++)
321 do_rop_16(ptr++, and, xor);
322 }
323 }
324
325 static void solid_rects_8(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
326 {
327 BYTE *ptr, *start;
328 int x, y, i;
329
330 for(i = 0; i < num; i++, rc++)
331 {
332 start = get_pixel_ptr_8(dib, rc->left, rc->top);
333 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
334 for(x = rc->left, ptr = start; x < rc->right; x++)
335 do_rop_8(ptr++, and, xor);
336 }
337 }
338
339 static void solid_rects_4(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
340 {
341 BYTE *ptr, *start;
342 int x, y, i;
343 BYTE byte_and = (and & 0xf) | ((and << 4) & 0xf0);
344 BYTE byte_xor = (xor & 0xf) | ((xor << 4) & 0xf0);
345
346 for(i = 0; i < num; i++, rc++)
347 {
348 if(rc->left >= rc->right) continue;
349 start = get_pixel_ptr_4(dib, rc->left, rc->top);
350 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
351 {
352 ptr = start;
353 if(rc->left & 1) /* upper nibble untouched */
354 do_rop_8(ptr++, byte_and | 0xf0, byte_xor & 0x0f);
355
356 for(x = (rc->left + 1) & ~1; x < (rc->right & ~1); x += 2)
357 do_rop_8(ptr++, byte_and, byte_xor);
358
359 if(rc->right & 1) /* lower nibble untouched */
360 do_rop_8(ptr, byte_and | 0x0f, byte_xor & 0xf0);
361 }
362 }
363 }
364
365 static void solid_rects_1(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
366 {
367 BYTE *ptr, *start;
368 int x, y, i;
369 BYTE byte_and = (and & 1) ? 0xff : 0;
370 BYTE byte_xor = (xor & 1) ? 0xff : 0;
371 BYTE start_and, start_xor, end_and, end_xor, mask;
372 static const BYTE masks[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};
373
374 for(i = 0; i < num; i++, rc++)
375 {
376 if(rc->left >= rc->right) continue;
377
378 start = get_pixel_ptr_1(dib, rc->left, rc->top);
379
380 if((rc->left & ~7) == (rc->right & ~7)) /* Special case for lines that start and end in the same byte */
381 {
382 mask = masks[rc->left & 7] & ~masks[rc->right & 7];
383
384 start_and = byte_and | ~mask;
385 start_xor = byte_xor & mask;
386 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
387 {
388 do_rop_8(start, start_and, start_xor);
389 }
390 }
391 else
392 {
393 mask = masks[rc->left & 7];
394 start_and = byte_and | ~mask;
395 start_xor = byte_xor & mask;
396
397 mask = masks[rc->right & 7];
398 /* This is inverted wrt to start mask, so end_and/xor assignments reflect this */
399 end_and = byte_and | mask;
400 end_xor = byte_xor & ~mask;
401
402 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
403 {
404 ptr = start;
405
406 if(rc->left & 7)
407 do_rop_8(ptr++, start_and, start_xor);
408
409 for(x = (rc->left + 7) & ~7; x < (rc->right & ~7); x += 8)
410 do_rop_8(ptr++, byte_and, byte_xor);
411
412 if(rc->right & 7)
413 do_rop_8(ptr, end_and, end_xor);
414 }
415 }
416 }
417 }
418
419 static void solid_rects_null(const dib_info *dib, int num, const RECT *rc, DWORD and, DWORD xor)
420 {
421 return;
422 }
423
424 static inline INT calc_offset(INT edge, INT size, INT origin)
425 {
426 INT offset;
427
428 if(edge - origin >= 0)
429 offset = (edge - origin) % size;
430 else
431 {
432 offset = (origin - edge) % size;
433 if(offset) offset = size - offset;
434 }
435 return offset;
436 }
437
438 static inline POINT calc_brush_offset(const RECT *rc, const dib_info *brush, const POINT *origin)
439 {
440 POINT offset;
441
442 offset.x = calc_offset(rc->left, brush->width, origin->x);
443 offset.y = calc_offset(rc->top, brush->height, origin->y);
444
445 return offset;
446 }
447
448 static void pattern_rects_32(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
449 const dib_info *brush, void *and_bits, void *xor_bits)
450 {
451 DWORD *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
452 int x, y, i;
453 POINT offset;
454
455 for(i = 0; i < num; i++, rc++)
456 {
457 offset = calc_brush_offset(rc, brush, origin);
458
459 start = get_pixel_ptr_32(dib, rc->left, rc->top);
460 start_and = (DWORD*)and_bits + offset.y * brush->stride / 4;
461 start_xor = (DWORD*)xor_bits + offset.y * brush->stride / 4;
462
463 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 4)
464 {
465 and_ptr = start_and + offset.x;
466 xor_ptr = start_xor + offset.x;
467
468 for(x = rc->left, ptr = start; x < rc->right; x++)
469 {
470 do_rop_32(ptr++, *and_ptr++, *xor_ptr++);
471 if(and_ptr == start_and + brush->width)
472 {
473 and_ptr = start_and;
474 xor_ptr = start_xor;
475 }
476 }
477
478 offset.y++;
479 if(offset.y == brush->height)
480 {
481 start_and = and_bits;
482 start_xor = xor_bits;
483 offset.y = 0;
484 }
485 else
486 {
487 start_and += brush->stride / 4;
488 start_xor += brush->stride / 4;
489 }
490 }
491 }
492 }
493
494 static void pattern_rects_24(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
495 const dib_info *brush, void *and_bits, void *xor_bits)
496 {
497 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
498 int x, y, i;
499 POINT offset;
500
501 for(i = 0; i < num; i++, rc++)
502 {
503 offset = calc_brush_offset(rc, brush, origin);
504
505 start = get_pixel_ptr_24(dib, rc->left, rc->top);
506 start_and = (BYTE*)and_bits + offset.y * brush->stride;
507 start_xor = (BYTE*)xor_bits + offset.y * brush->stride;
508
509 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
510 {
511 and_ptr = start_and + offset.x * 3;
512 xor_ptr = start_xor + offset.x * 3;
513
514 for(x = rc->left, ptr = start; x < rc->right; x++)
515 {
516 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
517 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
518 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
519 if(and_ptr == start_and + brush->width * 3)
520 {
521 and_ptr = start_and;
522 xor_ptr = start_xor;
523 }
524 }
525
526 offset.y++;
527 if(offset.y == brush->height)
528 {
529 start_and = and_bits;
530 start_xor = xor_bits;
531 offset.y = 0;
532 }
533 else
534 {
535 start_and += brush->stride;
536 start_xor += brush->stride;
537 }
538 }
539 }
540 }
541
542 static void pattern_rects_16(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
543 const dib_info *brush, void *and_bits, void *xor_bits)
544 {
545 WORD *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
546 int x, y, i;
547 POINT offset;
548
549 for(i = 0; i < num; i++, rc++)
550 {
551 offset = calc_brush_offset(rc, brush, origin);
552
553 start = get_pixel_ptr_16(dib, rc->left, rc->top);
554 start_and = (WORD*)and_bits + offset.y * brush->stride / 2;
555 start_xor = (WORD*)xor_bits + offset.y * brush->stride / 2;
556
557 for(y = rc->top; y < rc->bottom; y++, start += dib->stride / 2)
558 {
559 and_ptr = start_and + offset.x;
560 xor_ptr = start_xor + offset.x;
561
562 for(x = rc->left, ptr = start; x < rc->right; x++)
563 {
564 do_rop_16(ptr++, *and_ptr++, *xor_ptr++);
565 if(and_ptr == start_and + brush->width)
566 {
567 and_ptr = start_and;
568 xor_ptr = start_xor;
569 }
570 }
571
572 offset.y++;
573 if(offset.y == brush->height)
574 {
575 start_and = and_bits;
576 start_xor = xor_bits;
577 offset.y = 0;
578 }
579 else
580 {
581 start_and += brush->stride / 2;
582 start_xor += brush->stride / 2;
583 }
584 }
585 }
586 }
587
588 static void pattern_rects_8(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
589 const dib_info *brush, void *and_bits, void *xor_bits)
590 {
591 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
592 int x, y, i;
593 POINT offset;
594
595 for(i = 0; i < num; i++, rc++)
596 {
597 offset = calc_brush_offset(rc, brush, origin);
598
599 start = get_pixel_ptr_8(dib, rc->left, rc->top);
600 start_and = (BYTE*)and_bits + offset.y * brush->stride;
601 start_xor = (BYTE*)xor_bits + offset.y * brush->stride;
602
603 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
604 {
605 and_ptr = start_and + offset.x;
606 xor_ptr = start_xor + offset.x;
607
608 for(x = rc->left, ptr = start; x < rc->right; x++)
609 {
610 do_rop_8(ptr++, *and_ptr++, *xor_ptr++);
611 if(and_ptr == start_and + brush->width)
612 {
613 and_ptr = start_and;
614 xor_ptr = start_xor;
615 }
616 }
617
618 offset.y++;
619 if(offset.y == brush->height)
620 {
621 start_and = and_bits;
622 start_xor = xor_bits;
623 offset.y = 0;
624 }
625 else
626 {
627 start_and += brush->stride;
628 start_xor += brush->stride;
629 }
630 }
631 }
632 }
633
634 static void pattern_rects_4(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
635 const dib_info *brush, void *and_bits, void *xor_bits)
636 {
637 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
638 int x, y, i;
639 POINT offset;
640
641 for(i = 0; i < num; i++, rc++)
642 {
643 offset = calc_brush_offset(rc, brush, origin);
644
645 start = get_pixel_ptr_4(dib, rc->left, rc->top);
646 start_and = (BYTE*)and_bits + offset.y * brush->stride;
647 start_xor = (BYTE*)xor_bits + offset.y * brush->stride;
648
649 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
650 {
651 INT brush_x = offset.x;
652 BYTE byte_and, byte_xor;
653
654 and_ptr = start_and + brush_x / 2;
655 xor_ptr = start_xor + brush_x / 2;
656
657 for(x = rc->left, ptr = start; x < rc->right; x++)
658 {
659 /* FIXME: Two pixels at a time */
660 if(x & 1) /* lower dst nibble */
661 {
662 if(brush_x & 1) /* lower pat nibble */
663 {
664 byte_and = *and_ptr++ | 0xf0;
665 byte_xor = *xor_ptr++ & 0x0f;
666 }
667 else /* upper pat nibble */
668 {
669 byte_and = (*and_ptr >> 4) | 0xf0;
670 byte_xor = (*xor_ptr >> 4) & 0x0f;
671 }
672 }
673 else /* upper dst nibble */
674 {
675 if(brush_x & 1) /* lower pat nibble */
676 {
677 byte_and = (*and_ptr++ << 4) | 0x0f;
678 byte_xor = (*xor_ptr++ << 4) & 0xf0;
679 }
680 else /* upper pat nibble */
681 {
682 byte_and = *and_ptr | 0x0f;
683 byte_xor = *xor_ptr & 0xf0;
684 }
685 }
686 do_rop_8(ptr, byte_and, byte_xor);
687
688 if(x & 1) ptr++;
689
690 if(++brush_x == brush->width)
691 {
692 brush_x = 0;
693 and_ptr = start_and;
694 xor_ptr = start_xor;
695 }
696 }
697
698 offset.y++;
699 if(offset.y == brush->height)
700 {
701 start_and = and_bits;
702 start_xor = xor_bits;
703 offset.y = 0;
704 }
705 else
706 {
707 start_and += brush->stride;
708 start_xor += brush->stride;
709 }
710 }
711 }
712 }
713
714 static void pattern_rects_1(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
715 const dib_info *brush, void *and_bits, void *xor_bits)
716 {
717 BYTE *ptr, *start, *start_and, *and_ptr, *start_xor, *xor_ptr;
718 int x, y, i;
719 POINT offset;
720
721 for(i = 0; i < num; i++, rc++)
722 {
723 offset = calc_brush_offset(rc, brush, origin);
724
725 start = get_pixel_ptr_1(dib, rc->left, rc->top);
726 start_and = (BYTE*)and_bits + offset.y * brush->stride;
727 start_xor = (BYTE*)xor_bits + offset.y * brush->stride;
728
729 for(y = rc->top; y < rc->bottom; y++, start += dib->stride)
730 {
731 INT brush_x = offset.x;
732 BYTE byte_and, byte_xor;
733
734 and_ptr = start_and + brush_x / 8;
735 xor_ptr = start_xor + brush_x / 8;
736
737 for(x = rc->left, ptr = start; x < rc->right; x++)
738 {
739 byte_and = (*and_ptr & pixel_masks_1[brush_x % 8]) ? 0xff : 0;
740 byte_and |= ~pixel_masks_1[x % 8];
741 byte_xor = (*xor_ptr & pixel_masks_1[brush_x % 8]) ? 0xff : 0;
742 byte_xor &= pixel_masks_1[x % 8];
743
744 do_rop_8(ptr, byte_and, byte_xor);
745
746 if((x & 7) == 7) ptr++;
747
748 if((brush_x & 7) == 7)
749 {
750 and_ptr++;
751 xor_ptr++;
752 }
753
754 if(++brush_x == brush->width)
755 {
756 brush_x = 0;
757 and_ptr = start_and;
758 xor_ptr = start_xor;
759 }
760 }
761
762 offset.y++;
763 if(offset.y == brush->height)
764 {
765 start_and = and_bits;
766 start_xor = xor_bits;
767 offset.y = 0;
768 }
769 else
770 {
771 start_and += brush->stride;
772 start_xor += brush->stride;
773 }
774 }
775 }
776 }
777
778 static void pattern_rects_null(const dib_info *dib, int num, const RECT *rc, const POINT *origin,
779 const dib_info *brush, void *and_bits, void *xor_bits)
780 {
781 return;
782 }
783
784 static void copy_rect_32(const dib_info *dst, const RECT *rc,
785 const dib_info *src, const POINT *origin, int rop2, int overlap)
786 {
787 DWORD *dst_start, *src_start;
788 struct rop_codes codes;
789 int y, dst_stride, src_stride;
790
791 if (overlap & OVERLAP_BELOW)
792 {
793 dst_start = get_pixel_ptr_32(dst, rc->left, rc->bottom - 1);
794 src_start = get_pixel_ptr_32(src, origin->x, origin->y + rc->bottom - rc->top - 1);
795 dst_stride = -dst->stride / 4;
796 src_stride = -src->stride / 4;
797 }
798 else
799 {
800 dst_start = get_pixel_ptr_32(dst, rc->left, rc->top);
801 src_start = get_pixel_ptr_32(src, origin->x, origin->y);
802 dst_stride = dst->stride / 4;
803 src_stride = src->stride / 4;
804 }
805
806 if (rop2 == R2_COPYPEN)
807 {
808 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
809 memmove( dst_start, src_start, (rc->right - rc->left) * 4 );
810 return;
811 }
812
813 get_rop_codes( rop2, &codes );
814 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
815 {
816 if (overlap & OVERLAP_RIGHT)
817 do_rop_codes_line_rev_32( dst_start, src_start, &codes, rc->right - rc->left );
818 else
819 do_rop_codes_line_32( dst_start, src_start, &codes, rc->right - rc->left );
820 }
821 }
822
823 static void copy_rect_24(const dib_info *dst, const RECT *rc,
824 const dib_info *src, const POINT *origin, int rop2, int overlap)
825 {
826 BYTE *dst_start, *src_start;
827 int y, dst_stride, src_stride;
828 struct rop_codes codes;
829
830 if (overlap & OVERLAP_BELOW)
831 {
832 dst_start = get_pixel_ptr_24(dst, rc->left, rc->bottom - 1);
833 src_start = get_pixel_ptr_24(src, origin->x, origin->y + rc->bottom - rc->top - 1);
834 dst_stride = -dst->stride;
835 src_stride = -src->stride;
836 }
837 else
838 {
839 dst_start = get_pixel_ptr_24(dst, rc->left, rc->top);
840 src_start = get_pixel_ptr_24(src, origin->x, origin->y);
841 dst_stride = dst->stride;
842 src_stride = src->stride;
843 }
844
845 if (rop2 == R2_COPYPEN)
846 {
847 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
848 memmove( dst_start, src_start, (rc->right - rc->left) * 3 );
849 return;
850 }
851
852 get_rop_codes( rop2, &codes );
853 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
854 {
855 if (overlap & OVERLAP_RIGHT)
856 do_rop_codes_line_rev_8( dst_start, src_start, &codes, (rc->right - rc->left) * 3 );
857 else
858 do_rop_codes_line_8( dst_start, src_start, &codes, (rc->right - rc->left) * 3 );
859 }
860 }
861
862 static void copy_rect_16(const dib_info *dst, const RECT *rc,
863 const dib_info *src, const POINT *origin, int rop2, int overlap)
864 {
865 WORD *dst_start, *src_start;
866 int y, dst_stride, src_stride;
867 struct rop_codes codes;
868
869 if (overlap & OVERLAP_BELOW)
870 {
871 dst_start = get_pixel_ptr_16(dst, rc->left, rc->bottom - 1);
872 src_start = get_pixel_ptr_16(src, origin->x, origin->y + rc->bottom - rc->top - 1);
873 dst_stride = -dst->stride / 2;
874 src_stride = -src->stride / 2;
875 }
876 else
877 {
878 dst_start = get_pixel_ptr_16(dst, rc->left, rc->top);
879 src_start = get_pixel_ptr_16(src, origin->x, origin->y);
880 dst_stride = dst->stride / 2;
881 src_stride = src->stride / 2;
882 }
883
884 if (rop2 == R2_COPYPEN)
885 {
886 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
887 memmove( dst_start, src_start, (rc->right - rc->left) * 2 );
888 return;
889 }
890
891 get_rop_codes( rop2, &codes );
892 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
893 {
894 if (overlap & OVERLAP_RIGHT)
895 do_rop_codes_line_rev_16( dst_start, src_start, &codes, rc->right - rc->left );
896 else
897 do_rop_codes_line_16( dst_start, src_start, &codes, rc->right - rc->left );
898 }
899 }
900
901 static void copy_rect_8(const dib_info *dst, const RECT *rc,
902 const dib_info *src, const POINT *origin, int rop2, int overlap)
903 {
904 BYTE *dst_start, *src_start;
905 int y, dst_stride, src_stride;
906 struct rop_codes codes;
907
908 if (overlap & OVERLAP_BELOW)
909 {
910 dst_start = get_pixel_ptr_8(dst, rc->left, rc->bottom - 1);
911 src_start = get_pixel_ptr_8(src, origin->x, origin->y + rc->bottom - rc->top - 1);
912 dst_stride = -dst->stride;
913 src_stride = -src->stride;
914 }
915 else
916 {
917 dst_start = get_pixel_ptr_8(dst, rc->left, rc->top);
918 src_start = get_pixel_ptr_8(src, origin->x, origin->y);
919 dst_stride = dst->stride;
920 src_stride = src->stride;
921 }
922
923 if (rop2 == R2_COPYPEN)
924 {
925 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
926 memmove( dst_start, src_start, (rc->right - rc->left) );
927 return;
928 }
929
930 get_rop_codes( rop2, &codes );
931 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
932 {
933 if (overlap & OVERLAP_RIGHT)
934 do_rop_codes_line_rev_8( dst_start, src_start, &codes, rc->right - rc->left );
935 else
936 do_rop_codes_line_8( dst_start, src_start, &codes, rc->right - rc->left );
937 }
938 }
939
940 static void copy_rect_4(const dib_info *dst, const RECT *rc,
941 const dib_info *src, const POINT *origin, int rop2, int overlap)
942 {
943 BYTE *dst_start, *src_start;
944 int y, dst_stride, src_stride;
945 struct rop_codes codes;
946
947 if (overlap & OVERLAP_BELOW)
948 {
949 dst_start = get_pixel_ptr_4(dst, 0, rc->bottom - 1);
950 src_start = get_pixel_ptr_4(src, 0, origin->y + rc->bottom - rc->top - 1);
951 dst_stride = -dst->stride;
952 src_stride = -src->stride;
953 }
954 else
955 {
956 dst_start = get_pixel_ptr_4(dst, 0, rc->top);
957 src_start = get_pixel_ptr_4(src, 0, origin->y);
958 dst_stride = dst->stride;
959 src_stride = src->stride;
960 }
961
962 if (rop2 == R2_COPYPEN && (rc->left & 1) == 0 && (origin->x & 1) == 0 && (rc->right & 1) == 0)
963 {
964 dst_start += rc->left / 2;
965 src_start += origin->x / 2;
966 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
967 memmove( dst_start, src_start, (rc->right - rc->left) / 2 );
968 return;
969 }
970
971 get_rop_codes( rop2, &codes );
972 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
973 {
974 if (overlap & OVERLAP_RIGHT)
975 do_rop_codes_line_rev_4( dst_start, rc->left, src_start, origin->x, &codes, rc->right - rc->left );
976 else
977 do_rop_codes_line_4( dst_start, rc->left, src_start, origin->x, &codes, rc->right - rc->left );
978 }
979 }
980
981 static void copy_rect_1(const dib_info *dst, const RECT *rc,
982 const dib_info *src, const POINT *origin, int rop2, int overlap)
983 {
984 BYTE *dst_start, *src_start;
985 int y, dst_stride, src_stride;
986 struct rop_codes codes;
987
988 if (overlap & OVERLAP_BELOW)
989 {
990 dst_start = get_pixel_ptr_1(dst, 0, rc->bottom - 1);
991 src_start = get_pixel_ptr_1(src, 0, origin->y + rc->bottom - rc->top - 1);
992 dst_stride = -dst->stride;
993 src_stride = -src->stride;
994 }
995 else
996 {
997 dst_start = get_pixel_ptr_1(dst, 0, rc->top);
998 src_start = get_pixel_ptr_1(src, 0, origin->y);
999 dst_stride = dst->stride;
1000 src_stride = src->stride;
1001 }
1002
1003 if (rop2 == R2_COPYPEN && (rc->left & 7) == 0 && (origin->x & 7) == 0 && (rc->right & 7) == 0)
1004 {
1005 dst_start += rc->left / 8;
1006 src_start += origin->x / 8;
1007 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1008 memmove( dst_start, src_start, (rc->right - rc->left) / 8 );
1009 return;
1010 }
1011
1012 get_rop_codes( rop2, &codes );
1013 for (y = rc->top; y < rc->bottom; y++, dst_start += dst_stride, src_start += src_stride)
1014 {
1015 if (overlap & OVERLAP_RIGHT)
1016 do_rop_codes_line_rev_1( dst_start, rc->left, src_start, origin->x, &codes, rc->right - rc->left );
1017 else
1018 do_rop_codes_line_1( dst_start, rc->left, src_start, origin->x, &codes, rc->right - rc->left );
1019 }
1020 }
1021
1022 static void copy_rect_null(const dib_info *dst, const RECT *rc,
1023 const dib_info *src, const POINT *origin, int rop2, int overlap)
1024 {
1025 return;
1026 }
1027
1028 static DWORD colorref_to_pixel_888(const dib_info *dib, COLORREF color)
1029 {
1030 return ( ((color >> 16) & 0xff) | (color & 0xff00) | ((color << 16) & 0xff0000) );
1031 }
1032
1033 static const DWORD field_masks[33] =
1034 {
1035 0x00, /* should never happen */
1036 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff,
1037 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1038 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1039 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
1040 };
1041
1042 static inline DWORD get_field(DWORD field, int shift, int len)
1043 {
1044 shift = shift - (8 - len);
1045 if (shift < 0)
1046 field <<= -shift;
1047 else
1048 field >>= shift;
1049 field &= field_masks[len];
1050 field |= field >> len;
1051 return field;
1052 }
1053
1054 static inline DWORD put_field(DWORD field, int shift, int len)
1055 {
1056 shift = shift - (8 - len);
1057 field &= field_masks[len];
1058 if (shift < 0)
1059 field >>= -shift;
1060 else
1061 field <<= shift;
1062 return field;
1063 }
1064
1065 static DWORD colorref_to_pixel_masks(const dib_info *dib, COLORREF colour)
1066 {
1067 DWORD r,g,b;
1068
1069 r = GetRValue(colour);
1070 g = GetGValue(colour);
1071 b = GetBValue(colour);
1072
1073 return put_field(r, dib->red_shift, dib->red_len) |
1074 put_field(g, dib->green_shift, dib->green_len) |
1075 put_field(b, dib->blue_shift, dib->blue_len);
1076 }
1077
1078 static DWORD colorref_to_pixel_555(const dib_info *dib, COLORREF color)
1079 {
1080 return ( ((color >> 19) & 0x1f) | ((color >> 6) & 0x03e0) | ((color << 7) & 0x7c00) );
1081 }
1082
1083 static DWORD rgb_to_pixel_colortable(const dib_info *dib, BYTE r, BYTE g, BYTE b)
1084 {
1085 int i, best_index = 0;
1086 DWORD diff, best_diff = 0xffffffff;
1087
1088 /* special case for conversion to 1-bpp without a color table:
1089 * we get a 1-entry table containing the background color
1090 */
1091 if (dib->bit_count == 1 && dib->color_table_size == 1)
1092 return (r == dib->color_table[0].rgbRed &&
1093 g == dib->color_table[0].rgbGreen &&
1094 b == dib->color_table[0].rgbBlue);
1095
1096 for(i = 0; i < dib->color_table_size; i++)
1097 {
1098 RGBQUAD *cur = dib->color_table + i;
1099 diff = (r - cur->rgbRed) * (r - cur->rgbRed)
1100 + (g - cur->rgbGreen) * (g - cur->rgbGreen)
1101 + (b - cur->rgbBlue) * (b - cur->rgbBlue);
1102
1103 if(diff == 0)
1104 {
1105 best_index = i;
1106 break;
1107 }
1108
1109 if(diff < best_diff)
1110 {
1111 best_diff = diff;
1112 best_index = i;
1113 }
1114 }
1115 return best_index;
1116 }
1117
1118 static DWORD colorref_to_pixel_colortable(const dib_info *dib, COLORREF color)
1119 {
1120 return rgb_to_pixel_colortable( dib, GetRValue(color), GetGValue(color), GetBValue(color) );
1121 }
1122
1123 static DWORD colorref_to_pixel_null(const dib_info *dib, COLORREF color)
1124 {
1125 return 0;
1126 }
1127
1128 static inline RGBQUAD colortable_entry(const dib_info *dib, DWORD index)
1129 {
1130 static const RGBQUAD default_rgb;
1131 if (index < dib->color_table_size) return dib->color_table[index];
1132 return default_rgb;
1133 }
1134
1135 static inline BOOL bit_fields_match(const dib_info *d1, const dib_info *d2)
1136 {
1137 assert( d1->bit_count > 8 && d1->bit_count == d2->bit_count );
1138
1139 return d1->red_mask == d2->red_mask &&
1140 d1->green_mask == d2->green_mask &&
1141 d1->blue_mask == d2->blue_mask;
1142 }
1143
1144 static void convert_to_8888(dib_info *dst, const dib_info *src, const RECT *src_rect)
1145 {
1146 DWORD *dst_start = get_pixel_ptr_32(dst, 0, 0), *dst_pixel, src_val;
1147 int x, y, pad_size = (dst->width - (src_rect->right - src_rect->left)) * 4;
1148
1149 switch(src->bit_count)
1150 {
1151 case 32:
1152 {
1153 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1154 if(src->funcs == &funcs_8888)
1155 {
1156 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
1157 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
1158 else
1159 {
1160 for(y = src_rect->top; y < src_rect->bottom; y++)
1161 {
1162 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 4);
1163 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
1164 dst_start += dst->stride / 4;
1165 src_start += src->stride / 4;
1166 }
1167 }
1168 }
1169 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
1170 {
1171 for(y = src_rect->top; y < src_rect->bottom; y++)
1172 {
1173 dst_pixel = dst_start;
1174 src_pixel = src_start;
1175 for(x = src_rect->left; x < src_rect->right; x++)
1176 {
1177 src_val = *src_pixel++;
1178 *dst_pixel++ = (((src_val >> src->red_shift) & 0xff) << 16) |
1179 (((src_val >> src->green_shift) & 0xff) << 8) |
1180 ((src_val >> src->blue_shift) & 0xff);
1181 }
1182 if(pad_size) memset(dst_pixel, 0, pad_size);
1183 dst_start += dst->stride / 4;
1184 src_start += src->stride / 4;
1185 }
1186 }
1187 else
1188 {
1189 for(y = src_rect->top; y < src_rect->bottom; y++)
1190 {
1191 dst_pixel = dst_start;
1192 src_pixel = src_start;
1193 for(x = src_rect->left; x < src_rect->right; x++)
1194 {
1195 src_val = *src_pixel++;
1196 *dst_pixel++ = (get_field( src_val, src->red_shift, src->red_len ) << 16 |
1197 get_field( src_val, src->green_shift, src->green_len ) << 8 |
1198 get_field( src_val, src->blue_shift, src->blue_len ));
1199 }
1200 if(pad_size) memset(dst_pixel, 0, pad_size);
1201 dst_start += dst->stride / 4;
1202 src_start += src->stride / 4;
1203 }
1204 }
1205 break;
1206 }
1207
1208 case 24:
1209 {
1210 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
1211
1212 for(y = src_rect->top; y < src_rect->bottom; y++)
1213 {
1214 dst_pixel = dst_start;
1215 src_pixel = src_start;
1216 for(x = src_rect->left; x < src_rect->right; x++)
1217 {
1218 RGBQUAD rgb;
1219 rgb.rgbBlue = *src_pixel++;
1220 rgb.rgbGreen = *src_pixel++;
1221 rgb.rgbRed = *src_pixel++;
1222
1223 *dst_pixel++ = ((rgb.rgbRed << 16) & 0xff0000) | ((rgb.rgbGreen << 8) & 0x00ff00) | (rgb.rgbBlue & 0x0000ff);
1224 }
1225 if(pad_size) memset(dst_pixel, 0, pad_size);
1226 dst_start += dst->stride / 4;
1227 src_start += src->stride;
1228 }
1229 break;
1230 }
1231
1232 case 16:
1233 {
1234 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
1235 if(src->funcs == &funcs_555)
1236 {
1237 for(y = src_rect->top; y < src_rect->bottom; y++)
1238 {
1239 dst_pixel = dst_start;
1240 src_pixel = src_start;
1241 for(x = src_rect->left; x < src_rect->right; x++)
1242 {
1243 src_val = *src_pixel++;
1244 *dst_pixel++ = ((src_val << 9) & 0xf80000) | ((src_val << 4) & 0x070000) |
1245 ((src_val << 6) & 0x00f800) | ((src_val << 1) & 0x000700) |
1246 ((src_val << 3) & 0x0000f8) | ((src_val >> 2) & 0x000007);
1247 }
1248 if(pad_size) memset(dst_pixel, 0, pad_size);
1249 dst_start += dst->stride / 4;
1250 src_start += src->stride / 2;
1251 }
1252 }
1253 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
1254 {
1255 for(y = src_rect->top; y < src_rect->bottom; y++)
1256 {
1257 dst_pixel = dst_start;
1258 src_pixel = src_start;
1259 for(x = src_rect->left; x < src_rect->right; x++)
1260 {
1261 src_val = *src_pixel++;
1262 *dst_pixel++ = (((src_val >> src->red_shift) << 19) & 0xf80000) |
1263 (((src_val >> src->red_shift) << 14) & 0x070000) |
1264 (((src_val >> src->green_shift) << 11) & 0x00f800) |
1265 (((src_val >> src->green_shift) << 6) & 0x000700) |
1266 (((src_val >> src->blue_shift) << 3) & 0x0000f8) |
1267 (((src_val >> src->blue_shift) >> 2) & 0x000007);
1268 }
1269 if(pad_size) memset(dst_pixel, 0, pad_size);
1270 dst_start += dst->stride / 4;
1271 src_start += src->stride / 2;
1272 }
1273 }
1274 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
1275 {
1276 for(y = src_rect->top; y < src_rect->bottom; y++)
1277 {
1278 dst_pixel = dst_start;
1279 src_pixel = src_start;
1280 for(x = src_rect->left; x < src_rect->right; x++)
1281 {
1282 src_val = *src_pixel++;
1283 *dst_pixel++ = (((src_val >> src->red_shift) << 19) & 0xf80000) |
1284 (((src_val >> src->red_shift) << 14) & 0x070000) |
1285 (((src_val >> src->green_shift) << 10) & 0x00fc00) |
1286 (((src_val >> src->green_shift) << 4) & 0x000300) |
1287 (((src_val >> src->blue_shift) << 3) & 0x0000f8) |
1288 (((src_val >> src->blue_shift) >> 2) & 0x000007);
1289 }
1290 if(pad_size) memset(dst_pixel, 0, pad_size);
1291 dst_start += dst->stride / 4;
1292 src_start += src->stride / 2;
1293 }
1294 }
1295 else
1296 {
1297 for(y = src_rect->top; y < src_rect->bottom; y++)
1298 {
1299 dst_pixel = dst_start;
1300 src_pixel = src_start;
1301 for(x = src_rect->left; x < src_rect->right; x++)
1302 {
1303 src_val = *src_pixel++;
1304 *dst_pixel++ = (get_field( src_val, src->red_shift, src->red_len ) << 16 |
1305 get_field( src_val, src->green_shift, src->green_len ) << 8 |
1306 get_field( src_val, src->blue_shift, src->blue_len ));
1307 }
1308 if(pad_size) memset(dst_pixel, 0, pad_size);
1309 dst_start += dst->stride / 4;
1310 src_start += src->stride / 2;
1311 }
1312 }
1313 break;
1314 }
1315
1316 case 8:
1317 {
1318 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
1319 for(y = src_rect->top; y < src_rect->bottom; y++)
1320 {
1321 dst_pixel = dst_start;
1322 src_pixel = src_start;
1323 for(x = src_rect->left; x < src_rect->right; x++)
1324 {
1325 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
1326 *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
1327 }
1328 if(pad_size) memset(dst_pixel, 0, pad_size);
1329 dst_start += dst->stride / 4;
1330 src_start += src->stride;
1331 }
1332 break;
1333 }
1334
1335 case 4:
1336 {
1337 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
1338 for(y = src_rect->top; y < src_rect->bottom; y++)
1339 {
1340 dst_pixel = dst_start;
1341 src_pixel = src_start;
1342 for(x = src_rect->left; x < src_rect->right; x++)
1343 {
1344 RGBQUAD rgb;
1345 if(x & 1)
1346 rgb = colortable_entry( src, *src_pixel++ & 0xf );
1347 else
1348 rgb = colortable_entry( src, *src_pixel >> 4 );
1349 *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
1350 }
1351 if(pad_size) memset(dst_pixel, 0, pad_size);
1352 dst_start += dst->stride / 4;
1353 src_start += src->stride;
1354 }
1355 break;
1356 }
1357
1358 case 1:
1359 {
1360 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
1361 for(y = src_rect->top; y < src_rect->bottom; y++)
1362 {
1363 dst_pixel = dst_start;
1364 src_pixel = src_start;
1365 for(x = src_rect->left; x < src_rect->right; x++)
1366 {
1367 RGBQUAD rgb;
1368 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
1369 if((x % 8) == 7) src_pixel++;
1370 rgb = src->color_table[src_val];
1371 *dst_pixel++ = rgb.rgbRed << 16 | rgb.rgbGreen << 8 | rgb.rgbBlue;
1372 }
1373 if(pad_size) memset(dst_pixel, 0, pad_size);
1374 dst_start += dst->stride / 4;
1375 src_start += src->stride;
1376 }
1377 break;
1378 }
1379 }
1380 }
1381
1382 static void convert_to_32(dib_info *dst, const dib_info *src, const RECT *src_rect)
1383 {
1384 DWORD *dst_start = get_pixel_ptr_32(dst, 0, 0), *dst_pixel, src_val;
1385 int x, y, pad_size = (dst->width - (src_rect->right - src_rect->left)) * 4;
1386
1387 switch(src->bit_count)
1388 {
1389 case 32:
1390 {
1391 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1392
1393 if(src->funcs == &funcs_8888)
1394 {
1395 for(y = src_rect->top; y < src_rect->bottom; y++)
1396 {
1397 dst_pixel = dst_start;
1398 src_pixel = src_start;
1399 for(x = src_rect->left; x < src_rect->right; x++)
1400 {
1401 src_val = *src_pixel++;
1402 *dst_pixel++ = put_field(src_val >> 16, dst->red_shift, dst->red_len) |
1403 put_field(src_val >> 8, dst->green_shift, dst->green_len) |
1404 put_field(src_val, dst->blue_shift, dst->blue_len);
1405 }
1406 if(pad_size) memset(dst_pixel, 0, pad_size);
1407 dst_start += dst->stride / 4;
1408 src_start += src->stride / 4;
1409 }
1410 }
1411 else if(bit_fields_match(src, dst))
1412 {
1413 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
1414 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
1415 else
1416 {
1417 for(y = src_rect->top; y < src_rect->bottom; y++)
1418 {
1419 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 4);
1420 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
1421 dst_start += dst->stride / 4;
1422 src_start += src->stride / 4;
1423 }
1424 }
1425 }
1426 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8 &&
1427 dst->red_len == 8 && dst->green_len == 8 && dst->blue_len == 8)
1428 {
1429 for(y = src_rect->top; y < src_rect->bottom; y++)
1430 {
1431 dst_pixel = dst_start;
1432 src_pixel = src_start;
1433 for(x = src_rect->left; x < src_rect->right; x++)
1434 {
1435 src_val = *src_pixel++;
1436 *dst_pixel++ = (((src_val >> src->red_shift) & 0xff) << dst->red_shift) |
1437 (((src_val >> src->green_shift) & 0xff) << dst->green_shift) |
1438 (((src_val >> src->blue_shift) & 0xff) << dst->blue_shift);
1439 }
1440 if(pad_size) memset(dst_pixel, 0, pad_size);
1441 dst_start += dst->stride / 4;
1442 src_start += src->stride / 4;
1443 }
1444 }
1445 else
1446 {
1447 for(y = src_rect->top; y < src_rect->bottom; y++)
1448 {
1449 dst_pixel = dst_start;
1450 src_pixel = src_start;
1451 for(x = src_rect->left; x < src_rect->right; x++)
1452 {
1453 src_val = *src_pixel++;
1454 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
1455 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
1456 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
1457 }
1458 if(pad_size) memset(dst_pixel, 0, pad_size);
1459 dst_start += dst->stride / 4;
1460 src_start += src->stride / 4;
1461 }
1462 }
1463 break;
1464 }
1465
1466 case 24:
1467 {
1468 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
1469
1470 for(y = src_rect->top; y < src_rect->bottom; y++)
1471 {
1472 dst_pixel = dst_start;
1473 src_pixel = src_start;
1474 for(x = src_rect->left; x < src_rect->right; x++)
1475 {
1476 RGBQUAD rgb;
1477 rgb.rgbBlue = *src_pixel++;
1478 rgb.rgbGreen = *src_pixel++;
1479 rgb.rgbRed = *src_pixel++;
1480
1481 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1482 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1483 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1484 }
1485 if(pad_size) memset(dst_pixel, 0, pad_size);
1486 dst_start += dst->stride / 4;
1487 src_start += src->stride;
1488 }
1489 break;
1490 }
1491
1492 case 16:
1493 {
1494 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
1495 if(src->funcs == &funcs_555)
1496 {
1497 for(y = src_rect->top; y < src_rect->bottom; y++)
1498 {
1499 dst_pixel = dst_start;
1500 src_pixel = src_start;
1501 for(x = src_rect->left; x < src_rect->right; x++)
1502 {
1503 src_val = *src_pixel++;
1504 *dst_pixel++ = put_field(((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07), dst->red_shift, dst->red_len) |
1505 put_field(((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07), dst->green_shift, dst->green_len) |
1506 put_field(((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07), dst->blue_shift, dst->blue_len);
1507 }
1508 if(pad_size) memset(dst_pixel, 0, pad_size);
1509 dst_start += dst->stride / 4;
1510 src_start += src->stride / 2;
1511 }
1512 }
1513 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
1514 {
1515 for(y = src_rect->top; y < src_rect->bottom; y++)
1516 {
1517 dst_pixel = dst_start;
1518 src_pixel = src_start;
1519 for(x = src_rect->left; x < src_rect->right; x++)
1520 {
1521 src_val = *src_pixel++;
1522 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
1523 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
1524 put_field( (((src_val >> src->green_shift) << 3) & 0xf8) |
1525 (((src_val >> src->green_shift) >> 2) & 0x07), dst->green_shift, dst->green_len ) |
1526 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
1527 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
1528 }
1529 if(pad_size) memset(dst_pixel, 0, pad_size);
1530 dst_start += dst->stride / 4;
1531 src_start += src->stride / 2;
1532 }
1533 }
1534 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
1535 {
1536 for(y = src_rect->top; y < src_rect->bottom; y++)
1537 {
1538 dst_pixel = dst_start;
1539 src_pixel = src_start;
1540 for(x = src_rect->left; x < src_rect->right; x++)
1541 {
1542 src_val = *src_pixel++;
1543 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
1544 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
1545 put_field( (((src_val >> src->green_shift) << 2) & 0xfc) |
1546 (((src_val >> src->green_shift) >> 4) & 0x03), dst->green_shift, dst->green_len ) |
1547 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
1548 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
1549 }
1550 if(pad_size) memset(dst_pixel, 0, pad_size);
1551 dst_start += dst->stride / 4;
1552 src_start += src->stride / 2;
1553 }
1554 }
1555 else
1556 {
1557 for(y = src_rect->top; y < src_rect->bottom; y++)
1558 {
1559 dst_pixel = dst_start;
1560 src_pixel = src_start;
1561 for(x = src_rect->left; x < src_rect->right; x++)
1562 {
1563 src_val = *src_pixel++;
1564 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
1565 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
1566 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
1567 }
1568 if(pad_size) memset(dst_pixel, 0, pad_size);
1569 dst_start += dst->stride / 4;
1570 src_start += src->stride / 2;
1571 }
1572 }
1573 break;
1574 }
1575
1576 case 8:
1577 {
1578 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
1579 for(y = src_rect->top; y < src_rect->bottom; y++)
1580 {
1581 dst_pixel = dst_start;
1582 src_pixel = src_start;
1583 for(x = src_rect->left; x < src_rect->right; x++)
1584 {
1585 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
1586 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1587 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1588 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1589 }
1590 if(pad_size) memset(dst_pixel, 0, pad_size);
1591 dst_start += dst->stride / 4;
1592 src_start += src->stride;
1593 }
1594 break;
1595 }
1596
1597 case 4:
1598 {
1599 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
1600 for(y = src_rect->top; y < src_rect->bottom; y++)
1601 {
1602 dst_pixel = dst_start;
1603 src_pixel = src_start;
1604 for(x = src_rect->left; x < src_rect->right; x++)
1605 {
1606 RGBQUAD rgb;
1607 if(x & 1)
1608 rgb = colortable_entry( src, *src_pixel++ & 0xf );
1609 else
1610 rgb = colortable_entry( src, *src_pixel >> 4 );
1611 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1612 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1613 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1614 }
1615 if(pad_size) memset(dst_pixel, 0, pad_size);
1616 dst_start += dst->stride / 4;
1617 src_start += src->stride;
1618 }
1619 break;
1620 }
1621
1622 case 1:
1623 {
1624 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
1625 for(y = src_rect->top; y < src_rect->bottom; y++)
1626 {
1627 dst_pixel = dst_start;
1628 src_pixel = src_start;
1629 for(x = src_rect->left; x < src_rect->right; x++)
1630 {
1631 RGBQUAD rgb;
1632 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
1633 if((x % 8) == 7) src_pixel++;
1634 rgb = src->color_table[src_val];
1635 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
1636 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
1637 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
1638 }
1639 if(pad_size) memset(dst_pixel, 0, pad_size);
1640 dst_start += dst->stride / 4;
1641 src_start += src->stride;
1642 }
1643 break;
1644 }
1645 }
1646 }
1647
1648 static void convert_to_24(dib_info *dst, const dib_info *src, const RECT *src_rect)
1649 {
1650 BYTE *dst_start = get_pixel_ptr_24(dst, 0, 0), *dst_pixel;
1651 DWORD src_val;
1652 int x, y, pad_size = ((dst->width * 3 + 3) & ~3) - (src_rect->right - src_rect->left) * 3;
1653
1654 switch(src->bit_count)
1655 {
1656 case 32:
1657 {
1658 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1659 if(src->funcs == &funcs_8888)
1660 {
1661 for(y = src_rect->top; y < src_rect->bottom; y++)
1662 {
1663 dst_pixel = dst_start;
1664 src_pixel = src_start;
1665 for(x = src_rect->left; x < src_rect->right; x++)
1666 {
1667 src_val = *src_pixel++;
1668 *dst_pixel++ = src_val & 0xff;
1669 *dst_pixel++ = (src_val >> 8) & 0xff;
1670 *dst_pixel++ = (src_val >> 16) & 0xff;
1671 }
1672 if(pad_size) memset(dst_pixel, 0, pad_size);
1673 dst_start += dst->stride;
1674 src_start += src->stride / 4;
1675 }
1676 }
1677 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
1678 {
1679 for(y = src_rect->top; y < src_rect->bottom; y++)
1680 {
1681 dst_pixel = dst_start;
1682 src_pixel = src_start;
1683 for(x = src_rect->left; x < src_rect->right; x++)
1684 {
1685 src_val = *src_pixel++;
1686 *dst_pixel++ = (src_val >> src->blue_shift) & 0xff;
1687 *dst_pixel++ = (src_val >> src->green_shift) & 0xff;
1688 *dst_pixel++ = (src_val >> src->red_shift) & 0xff;
1689 }
1690 if(pad_size) memset(dst_pixel, 0, pad_size);
1691 dst_start += dst->stride;
1692 src_start += src->stride / 4;
1693 }
1694 }
1695 else
1696 {
1697 for(y = src_rect->top; y < src_rect->bottom; y++)
1698 {
1699 dst_pixel = dst_start;
1700 src_pixel = src_start;
1701 for(x = src_rect->left; x < src_rect->right; x++)
1702 {
1703 src_val = *src_pixel++;
1704 *dst_pixel++ = get_field( src_val, src->blue_shift, src->blue_len );
1705 *dst_pixel++ = get_field( src_val, src->green_shift, src->green_len );
1706 *dst_pixel++ = get_field( src_val, src->red_shift, src->red_len );
1707 }
1708 if(pad_size) memset(dst_pixel, 0, pad_size);
1709 dst_start += dst->stride;
1710 src_start += src->stride / 4;
1711 }
1712 }
1713 break;
1714 }
1715
1716 case 24:
1717 {
1718 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top);
1719
1720 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
1721 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
1722 else
1723 {
1724 for(y = src_rect->top; y < src_rect->bottom; y++)
1725 {
1726 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 3);
1727 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left) * 3, 0, pad_size);
1728 dst_start += dst->stride;
1729 src_start += src->stride;
1730 }
1731 }
1732 break;
1733 }
1734
1735 case 16:
1736 {
1737 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
1738 if(src->funcs == &funcs_555)
1739 {
1740 for(y = src_rect->top; y < src_rect->bottom; y++)
1741 {
1742 dst_pixel = dst_start;
1743 src_pixel = src_start;
1744 for(x = src_rect->left; x < src_rect->right; x++)
1745 {
1746 src_val = *src_pixel++;
1747 *dst_pixel++ = ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07);
1748 *dst_pixel++ = ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07);
1749 *dst_pixel++ = ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07);
1750 }
1751 if(pad_size) memset(dst_pixel, 0, pad_size);
1752 dst_start += dst->stride;
1753 src_start += src->stride / 2;
1754 }
1755 }
1756 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
1757 {
1758 for(y = src_rect->top; y < src_rect->bottom; y++)
1759 {
1760 dst_pixel = dst_start;
1761 src_pixel = src_start;
1762 for(x = src_rect->left; x < src_rect->right; x++)
1763 {
1764 src_val = *src_pixel++;
1765 *dst_pixel++ = (((src_val >> src->blue_shift) << 3) & 0xf8) |
1766 (((src_val >> src->blue_shift) >> 2) & 0x07);
1767 *dst_pixel++ = (((src_val >> src->green_shift) << 3) & 0xf8) |
1768 (((src_val >> src->green_shift) >> 2) & 0x07);
1769 *dst_pixel++ = (((src_val >> src->red_shift) << 3) & 0xf8) |
1770 (((src_val >> src->red_shift) >> 2) & 0x07);
1771 }
1772 if(pad_size) memset(dst_pixel, 0, pad_size);
1773 dst_start += dst->stride;
1774 src_start += src->stride / 2;
1775 }
1776 }
1777 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
1778 {
1779 for(y = src_rect->top; y < src_rect->bottom; y++)
1780 {
1781 dst_pixel = dst_start;
1782 src_pixel = src_start;
1783 for(x = src_rect->left; x < src_rect->right; x++)
1784 {
1785 src_val = *src_pixel++;
1786 *dst_pixel++ = (((src_val >> src->blue_shift) << 3) & 0xf8) |
1787 (((src_val >> src->blue_shift) >> 2) & 0x07);
1788 *dst_pixel++ = (((src_val >> src->green_shift) << 2) & 0xfc) |
1789 (((src_val >> src->green_shift) >> 4) & 0x03);
1790 *dst_pixel++ = (((src_val >> src->red_shift) << 3) & 0xf8) |
1791 (((src_val >> src->red_shift) >> 2) & 0x07);
1792 }
1793 if(pad_size) memset(dst_pixel, 0, pad_size);
1794 dst_start += dst->stride;
1795 src_start += src->stride / 2;
1796 }
1797 }
1798 else
1799 {
1800 for(y = src_rect->top; y < src_rect->bottom; y++)
1801 {
1802 dst_pixel = dst_start;
1803 src_pixel = src_start;
1804 for(x = src_rect->left; x < src_rect->right; x++)
1805 {
1806 src_val = *src_pixel++;
1807 *dst_pixel++ = get_field(src_val, src->blue_shift, src->blue_len );
1808 *dst_pixel++ = get_field(src_val, src->green_shift, src->green_len );
1809 *dst_pixel++ = get_field(src_val, src->red_shift, src->red_len );
1810 }
1811 if(pad_size) memset(dst_pixel, 0, pad_size);
1812 dst_start += dst->stride;
1813 src_start += src->stride / 2;
1814 }
1815 }
1816 break;
1817 }
1818
1819 case 8:
1820 {
1821 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
1822 for(y = src_rect->top; y < src_rect->bottom; y++)
1823 {
1824 dst_pixel = dst_start;
1825 src_pixel = src_start;
1826 for(x = src_rect->left; x < src_rect->right; x++)
1827 {
1828 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
1829 *dst_pixel++ = rgb.rgbBlue;
1830 *dst_pixel++ = rgb.rgbGreen;
1831 *dst_pixel++ = rgb.rgbRed;
1832 }
1833 if(pad_size) memset(dst_pixel, 0, pad_size);
1834 dst_start += dst->stride;
1835 src_start += src->stride;
1836 }
1837 break;
1838 }
1839
1840 case 4:
1841 {
1842 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
1843 for(y = src_rect->top; y < src_rect->bottom; y++)
1844 {
1845 dst_pixel = dst_start;
1846 src_pixel = src_start;
1847 for(x = src_rect->left; x < src_rect->right; x++)
1848 {
1849 RGBQUAD rgb;
1850 if(x & 1)
1851 rgb = colortable_entry( src, *src_pixel++ & 0xf );
1852 else
1853 rgb = colortable_entry( src, *src_pixel >> 4 );
1854 *dst_pixel++ = rgb.rgbBlue;
1855 *dst_pixel++ = rgb.rgbGreen;
1856 *dst_pixel++ = rgb.rgbRed;
1857 }
1858 if(pad_size) memset(dst_pixel, 0, pad_size);
1859 dst_start += dst->stride;
1860 src_start += src->stride;
1861 }
1862 break;
1863 }
1864
1865 case 1:
1866 {
1867 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
1868 for(y = src_rect->top; y < src_rect->bottom; y++)
1869 {
1870 dst_pixel = dst_start;
1871 src_pixel = src_start;
1872 for(x = src_rect->left; x < src_rect->right; x++)
1873 {
1874 RGBQUAD rgb;
1875 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
1876 if((x % 8) == 7) src_pixel++;
1877 rgb = src->color_table[src_val];
1878 *dst_pixel++ = rgb.rgbBlue;
1879 *dst_pixel++ = rgb.rgbGreen;
1880 *dst_pixel++ = rgb.rgbRed;
1881 }
1882 if(pad_size) memset(dst_pixel, 0, pad_size);
1883 dst_start += dst->stride;
1884 src_start += src->stride;
1885 }
1886 break;
1887 }
1888 }
1889 }
1890
1891 static void convert_to_555(dib_info *dst, const dib_info *src, const RECT *src_rect)
1892 {
1893 WORD *dst_start = get_pixel_ptr_16(dst, 0, 0), *dst_pixel;
1894 INT x, y, pad_size = ((dst->width + 1) & ~1) * 2 - (src_rect->right - src_rect->left) * 2;
1895 DWORD src_val;
1896
1897 switch(src->bit_count)
1898 {
1899 case 32:
1900 {
1901 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
1902
1903 if(src->funcs == &funcs_8888)
1904 {
1905 for(y = src_rect->top; y < src_rect->bottom; y++)
1906 {
1907 dst_pixel = dst_start;
1908 src_pixel = src_start;
1909 for(x = src_rect->left; x < src_rect->right; x++)
1910 {
1911 src_val = *src_pixel++;
1912 *dst_pixel++ = ((src_val >> 9) & 0x7c00) |
1913 ((src_val >> 6) & 0x03e0) |
1914 ((src_val >> 3) & 0x001f);
1915 }
1916 if(pad_size) memset(dst_pixel, 0, pad_size);
1917 dst_start += dst->stride / 2;
1918 src_start += src->stride / 4;
1919 }
1920 }
1921 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
1922 {
1923 for(y = src_rect->top; y < src_rect->bottom; y++)
1924 {
1925 dst_pixel = dst_start;
1926 src_pixel = src_start;
1927 for(x = src_rect->left; x < src_rect->right; x++)
1928 {
1929 src_val = *src_pixel++;
1930 *dst_pixel++ = (((src_val >> src->red_shift) << 7) & 0x7c00) |
1931 (((src_val >> src->green_shift) << 2) & 0x03e0) |
1932 (((src_val >> src->blue_shift) >> 3) & 0x001f);
1933 }
1934 if(pad_size) memset(dst_pixel, 0, pad_size);
1935 dst_start += dst->stride / 2;
1936 src_start += src->stride / 4;
1937 }
1938 }
1939 else
1940 {
1941 for(y = src_rect->top; y < src_rect->bottom; y++)
1942 {
1943 dst_pixel = dst_start;
1944 src_pixel = src_start;
1945 for(x = src_rect->left; x < src_rect->right; x++)
1946 {
1947 src_val = *src_pixel++;
1948 *dst_pixel++ = (((get_field(src_val, src->red_shift, src->red_len ) << 7) & 0x7c00) |
1949 ((get_field(src_val, src->green_shift, src->green_len ) << 2) & 0x03e0) |
1950 ( get_field(src_val, src->blue_shift, src->blue_len ) >> 3));
1951 }
1952 if(pad_size) memset(dst_pixel, 0, pad_size);
1953 dst_start += dst->stride / 2;
1954 src_start += src->stride / 4;
1955 }
1956 }
1957 break;
1958 }
1959
1960 case 24:
1961 {
1962 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
1963
1964 for(y = src_rect->top; y < src_rect->bottom; y++)
1965 {
1966 dst_pixel = dst_start;
1967 src_pixel = src_start;
1968 for(x = src_rect->left; x < src_rect->right; x++)
1969 {
1970 RGBQUAD rgb;
1971 rgb.rgbBlue = *src_pixel++;
1972 rgb.rgbGreen = *src_pixel++;
1973 rgb.rgbRed = *src_pixel++;
1974
1975 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
1976 ((rgb.rgbGreen << 2) & 0x03e0) |
1977 ((rgb.rgbBlue >> 3) & 0x001f);
1978 }
1979 if(pad_size) memset(dst_pixel, 0, pad_size);
1980 dst_start += dst->stride / 2;
1981 src_start += src->stride;
1982 }
1983 break;
1984 }
1985
1986 case 16:
1987 {
1988 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
1989 if(src->funcs == &funcs_555)
1990 {
1991 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
1992 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
1993 else
1994 {
1995 for(y = src_rect->top; y < src_rect->bottom; y++)
1996 {
1997 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 2);
1998 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
1999 dst_start += dst->stride / 2;
2000 src_start += src->stride / 2;
2001 }
2002 }
2003 }
2004 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
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->red_shift) << 10) & 0x7c00) |
2014 (((src_val >> src->green_shift) << 5) & 0x03e0) |
2015 ( (src_val >> src->blue_shift) & 0x001f);
2016 }
2017 if(pad_size) memset(dst_pixel, 0, pad_size);
2018 dst_start += dst->stride / 2;
2019 src_start += src->stride / 2;
2020 }
2021 }
2022 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
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++ = (((src_val >> src->red_shift) << 10) & 0x7c00) |
2032 (((src_val >> src->green_shift) << 4) & 0x03e0) |
2033 ( (src_val >> src->blue_shift) & 0x001f);
2034 }
2035 if(pad_size) memset(dst_pixel, 0, pad_size);
2036 dst_start += dst->stride / 2;
2037 src_start += src->stride / 2;
2038 }
2039 }
2040 else
2041 {
2042 for(y = src_rect->top; y < src_rect->bottom; y++)
2043 {
2044 dst_pixel = dst_start;
2045 src_pixel = src_start;
2046 for(x = src_rect->left; x < src_rect->right; x++)
2047 {
2048 src_val = *src_pixel++;
2049 *dst_pixel++ = (((get_field(src_val, src->red_shift, src->red_len) << 7) & 0x7c00) |
2050 ((get_field(src_val, src->green_shift, src->green_len) << 2) & 0x03e0) |
2051 ( get_field(src_val, src->blue_shift, src->blue_len) >> 3));
2052 }
2053 if(pad_size) memset(dst_pixel, 0, pad_size);
2054 dst_start += dst->stride / 2;
2055 src_start += src->stride / 2;
2056 }
2057 }
2058 break;
2059 }
2060
2061 case 8:
2062 {
2063 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2064 for(y = src_rect->top; y < src_rect->bottom; y++)
2065 {
2066 dst_pixel = dst_start;
2067 src_pixel = src_start;
2068 for(x = src_rect->left; x < src_rect->right; x++)
2069 {
2070 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
2071 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2072 ((rgb.rgbGreen << 2) & 0x03e0) |
2073 ((rgb.rgbBlue >> 3) & 0x001f);
2074 }
2075 if(pad_size) memset(dst_pixel, 0, pad_size);
2076 dst_start += dst->stride / 2;
2077 src_start += src->stride;
2078 }
2079 break;
2080 }
2081
2082 case 4:
2083 {
2084 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
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 RGBQUAD rgb;
2092 if(x & 1)
2093 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2094 else
2095 rgb = colortable_entry( src, *src_pixel >> 4 );
2096 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2097 ((rgb.rgbGreen << 2) & 0x03e0) |
2098 ((rgb.rgbBlue >> 3) & 0x001f);
2099 }
2100 if(pad_size) memset(dst_pixel, 0, pad_size);
2101 dst_start += dst->stride / 2;
2102 src_start += src->stride;
2103 }
2104 break;
2105 }
2106
2107 case 1:
2108 {
2109 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
2110 for(y = src_rect->top; y < src_rect->bottom; y++)
2111 {
2112 dst_pixel = dst_start;
2113 src_pixel = src_start;
2114 for(x = src_rect->left; x < src_rect->right; x++)
2115 {
2116 RGBQUAD rgb;
2117 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
2118 if((x % 8) == 7) src_pixel++;
2119 rgb = src->color_table[src_val];
2120 *dst_pixel++ = ((rgb.rgbRed << 7) & 0x7c00) |
2121 ((rgb.rgbGreen << 2) & 0x03e0) |
2122 ((rgb.rgbBlue >> 3) & 0x001f);
2123 }
2124 if(pad_size) memset(dst_pixel, 0, pad_size);
2125 dst_start += dst->stride / 2;
2126 src_start += src->stride;
2127 }
2128 break;
2129 }
2130 }
2131 }
2132
2133 static void convert_to_16(dib_info *dst, const dib_info *src, const RECT *src_rect)
2134 {
2135 WORD *dst_start = get_pixel_ptr_16(dst, 0, 0), *dst_pixel;
2136 INT x, y, pad_size = ((dst->width + 1) & ~1) * 2 - (src_rect->right - src_rect->left) * 2;
2137 DWORD src_val;
2138
2139 switch(src->bit_count)
2140 {
2141 case 32:
2142 {
2143 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2144
2145 if(src->funcs == &funcs_8888)
2146 {
2147 for(y = src_rect->top; y < src_rect->bottom; y++)
2148 {
2149 dst_pixel = dst_start;
2150 src_pixel = src_start;
2151 for(x = src_rect->left; x < src_rect->right; x++)
2152 {
2153 src_val = *src_pixel++;
2154 *dst_pixel++ = put_field(src_val >> 16, dst->red_shift, dst->red_len) |
2155 put_field(src_val >> 8, dst->green_shift, dst->green_len) |
2156 put_field(src_val, dst->blue_shift, dst->blue_len);
2157 }
2158 if(pad_size) memset(dst_pixel, 0, pad_size);
2159 dst_start += dst->stride / 2;
2160 src_start += src->stride / 4;
2161 }
2162 }
2163 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2164 {
2165 for(y = src_rect->top; y < src_rect->bottom; y++)
2166 {
2167 dst_pixel = dst_start;
2168 src_pixel = src_start;
2169 for(x = src_rect->left; x < src_rect->right; x++)
2170 {
2171 src_val = *src_pixel++;
2172 *dst_pixel++ = put_field(src_val >> src->red_shift, dst->red_shift, dst->red_len) |
2173 put_field(src_val >> src->green_shift, dst->green_shift, dst->green_len) |
2174 put_field(src_val >> src->blue_shift, dst->blue_shift, dst->blue_len);
2175 }
2176 if(pad_size) memset(dst_pixel, 0, pad_size);
2177 dst_start += dst->stride / 2;
2178 src_start += src->stride / 4;
2179 }
2180 }
2181 else
2182 {
2183 for(y = src_rect->top; y < src_rect->bottom; y++)
2184 {
2185 dst_pixel = dst_start;
2186 src_pixel = src_start;
2187 for(x = src_rect->left; x < src_rect->right; x++)
2188 {
2189 src_val = *src_pixel++;
2190 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2191 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2192 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2193 }
2194 if(pad_size) memset(dst_pixel, 0, pad_size);
2195 dst_start += dst->stride / 2;
2196 src_start += src->stride / 4;
2197 }
2198 }
2199 break;
2200 }
2201
2202 case 24:
2203 {
2204 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2205
2206 for(y = src_rect->top; y < src_rect->bottom; y++)
2207 {
2208 dst_pixel = dst_start;
2209 src_pixel = src_start;
2210 for(x = src_rect->left; x < src_rect->right; x++)
2211 {
2212 RGBQUAD rgb;
2213 rgb.rgbBlue = *src_pixel++;
2214 rgb.rgbGreen = *src_pixel++;
2215 rgb.rgbRed = *src_pixel++;
2216
2217 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2218 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2219 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2220 }
2221 if(pad_size) memset(dst_pixel, 0, pad_size);
2222 dst_start += dst->stride / 2;
2223 src_start += src->stride;
2224 }
2225 break;
2226 }
2227
2228 case 16:
2229 {
2230 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2231 if(src->funcs == &funcs_555)
2232 {
2233 for(y = src_rect->top; y < src_rect->bottom; y++)
2234 {
2235 dst_pixel = dst_start;
2236 src_pixel = src_start;
2237 for(x = src_rect->left; x < src_rect->right; x++)
2238 {
2239 src_val = *src_pixel++;
2240 *dst_pixel++ = put_field(((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07), dst->red_shift, dst->red_len) |
2241 put_field(((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07), dst->green_shift, dst->green_len) |
2242 put_field(((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2243 }
2244 if(pad_size) memset(dst_pixel, 0, pad_size);
2245 dst_start += dst->stride / 2;
2246 src_start += src->stride / 2;
2247 }
2248 }
2249 else if(bit_fields_match(src, dst))
2250 {
2251 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
2252 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2253 else
2254 {
2255 for(y = src_rect->top; y < src_rect->bottom; y++)
2256 {
2257 memcpy(dst_start, src_start, (src_rect->right - src_rect->left) * 2);
2258 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2259 dst_start += dst->stride / 2;
2260 src_start += src->stride / 2;
2261 }
2262 }
2263 }
2264 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2265 {
2266 for(y = src_rect->top; y < src_rect->bottom; y++)
2267 {
2268 dst_pixel = dst_start;
2269 src_pixel = src_start;
2270 for(x = src_rect->left; x < src_rect->right; x++)
2271 {
2272 src_val = *src_pixel++;
2273 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2274 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2275 put_field( (((src_val >> src->green_shift) << 3) & 0xf8) |
2276 (((src_val >> src->green_shift) >> 2) & 0x07), dst->green_shift, dst->green_len ) |
2277 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2278 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2279 }
2280 if(pad_size) memset(dst_pixel, 0, pad_size);
2281 dst_start += dst->stride / 2;
2282 src_start += src->stride / 2;
2283 }
2284 }
2285 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2286 {
2287 for(y = src_rect->top; y < src_rect->bottom; y++)
2288 {
2289 dst_pixel = dst_start;
2290 src_pixel = src_start;
2291 for(x = src_rect->left; x < src_rect->right; x++)
2292 {
2293 src_val = *src_pixel++;
2294 *dst_pixel++ = put_field( (((src_val >> src->red_shift) << 3) & 0xf8) |
2295 (((src_val >> src->red_shift) >> 2) & 0x07), dst->red_shift, dst->red_len ) |
2296 put_field( (((src_val >> src->green_shift) << 2) & 0xfc) |
2297 (((src_val >> src->green_shift) >> 4) & 0x03), dst->green_shift, dst->green_len ) |
2298 put_field( (((src_val >> src->blue_shift) << 3) & 0xf8) |
2299 (((src_val >> src->blue_shift) >> 2) & 0x07), dst->blue_shift, dst->blue_len);
2300 }
2301 if(pad_size) memset(dst_pixel, 0, pad_size);
2302 dst_start += dst->stride / 2;
2303 src_start += src->stride / 2;
2304 }
2305 }
2306 else
2307 {
2308 for(y = src_rect->top; y < src_rect->bottom; y++)
2309 {
2310 dst_pixel = dst_start;
2311 src_pixel = src_start;
2312 for(x = src_rect->left; x < src_rect->right; x++)
2313 {
2314 src_val = *src_pixel++;
2315 *dst_pixel++ = put_field(get_field(src_val, src->red_shift, src->red_len ), dst->red_shift, dst->red_len) |
2316 put_field(get_field(src_val, src->green_shift, src->green_len ), dst->green_shift, dst->green_len) |
2317 put_field(get_field(src_val, src->blue_shift, src->blue_len ), dst->blue_shift, dst->blue_len);
2318 }
2319 if(pad_size) memset(dst_pixel, 0, pad_size);
2320 dst_start += dst->stride / 2;
2321 src_start += src->stride / 2;
2322 }
2323 }
2324 break;
2325 }
2326
2327 case 8:
2328 {
2329 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2330 for(y = src_rect->top; y < src_rect->bottom; y++)
2331 {
2332 dst_pixel = dst_start;
2333 src_pixel = src_start;
2334 for(x = src_rect->left; x < src_rect->right; x++)
2335 {
2336 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
2337 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2338 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2339 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2340 }
2341 if(pad_size) memset(dst_pixel, 0, pad_size);
2342 dst_start += dst->stride / 2;
2343 src_start += src->stride;
2344 }
2345 break;
2346 }
2347
2348 case 4:
2349 {
2350 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
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 RGBQUAD rgb;
2358 if(x & 1)
2359 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2360 else
2361 rgb = colortable_entry( src, *src_pixel >> 4 );
2362 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2363 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2364 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2365 }
2366 if(pad_size) memset(dst_pixel, 0, pad_size);
2367 dst_start += dst->stride / 2;
2368 src_start += src->stride;
2369 }
2370 break;
2371 }
2372
2373 case 1:
2374 {
2375 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
2376 for(y = src_rect->top; y < src_rect->bottom; y++)
2377 {
2378 dst_pixel = dst_start;
2379 src_pixel = src_start;
2380 for(x = src_rect->left; x < src_rect->right; x++)
2381 {
2382 RGBQUAD rgb;
2383 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
2384 if((x % 8) == 7) src_pixel++;
2385 rgb = src->color_table[src_val];
2386 *dst_pixel++ = put_field(rgb.rgbRed, dst->red_shift, dst->red_len) |
2387 put_field(rgb.rgbGreen, dst->green_shift, dst->green_len) |
2388 put_field(rgb.rgbBlue, dst->blue_shift, dst->blue_len);
2389 }
2390 if(pad_size) memset(dst_pixel, 0, pad_size);
2391 dst_start += dst->stride / 2;
2392 src_start += src->stride;
2393 }
2394 break;
2395 }
2396 }
2397 }
2398
2399 static inline BOOL color_tables_match(const dib_info *d1, const dib_info *d2)
2400 {
2401 assert(d1->color_table_size && d2->color_table_size);
2402
2403 if(d1->color_table_size != d2->color_table_size) return FALSE;
2404 return !memcmp(d1->color_table, d2->color_table, d1->color_table_size * sizeof(d1->color_table[0]));
2405 }
2406
2407 static void convert_to_8(dib_info *dst, const dib_info *src, const RECT *src_rect)
2408 {
2409 BYTE *dst_start = get_pixel_ptr_8(dst, 0, 0), *dst_pixel;
2410 INT x, y, pad_size = ((dst->width + 3) & ~3) - (src_rect->right - src_rect->left);
2411 DWORD src_val;
2412
2413 switch(src->bit_count)
2414 {
2415 case 32:
2416 {
2417 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2418
2419 if(src->funcs == &funcs_8888)
2420 {
2421 for(y = src_rect->top; y < src_rect->bottom; y++)
2422 {
2423 dst_pixel = dst_start;
2424 src_pixel = src_start;
2425 for(x = src_rect->left; x < src_rect->right; x++)
2426 {
2427 src_val = *src_pixel++;
2428 *dst_pixel++ = rgb_to_pixel_colortable(dst, src_val >> 16, src_val >> 8, src_val );
2429 }
2430 if(pad_size) memset(dst_pixel, 0, pad_size);
2431 dst_start += dst->stride;
2432 src_start += src->stride / 4;
2433 }
2434 }
2435 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2436 {
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 src_val = *src_pixel++;
2444 *dst_pixel++ = rgb_to_pixel_colortable(dst,
2445 src_val >> src->red_shift,
2446 src_val >> src->green_shift,
2447 src_val >> src->blue_shift );
2448 }
2449 if(pad_size) memset(dst_pixel, 0, pad_size);
2450 dst_start += dst->stride;
2451 src_start += src->stride / 4;
2452 }
2453 }
2454 else
2455 {
2456 for(y = src_rect->top; y < src_rect->bottom; y++)
2457 {
2458 dst_pixel = dst_start;
2459 src_pixel = src_start;
2460 for(x = src_rect->left; x < src_rect->right; x++)
2461 {
2462 src_val = *src_pixel++;
2463 *dst_pixel++ = rgb_to_pixel_colortable(dst,
2464 get_field(src_val, src->red_shift, src->red_len),
2465 get_field(src_val, src->green_shift, src->green_len),
2466 get_field(src_val, src->blue_shift, src->blue_len));
2467 }
2468 if(pad_size) memset(dst_pixel, 0, pad_size);
2469 dst_start += dst->stride;
2470 src_start += src->stride / 4;
2471 }
2472 }
2473 break;
2474 }
2475
2476 case 24:
2477 {
2478 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2479
2480 for(y = src_rect->top; y < src_rect->bottom; y++)
2481 {
2482 dst_pixel = dst_start;
2483 src_pixel = src_start;
2484 for(x = src_rect->left; x < src_rect->right; x++, src_pixel += 3)
2485 {
2486 *dst_pixel++ = rgb_to_pixel_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0] );
2487 }
2488 if(pad_size) memset(dst_pixel, 0, pad_size);
2489 dst_start += dst->stride;
2490 src_start += src->stride;
2491 }
2492 break;
2493 }
2494
2495 case 16:
2496 {
2497 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2498 if(src->funcs == &funcs_555)
2499 {
2500 for(y = src_rect->top; y < src_rect->bottom; y++)
2501 {
2502 dst_pixel = dst_start;
2503 src_pixel = src_start;
2504 for(x = src_rect->left; x < src_rect->right; x++)
2505 {
2506 src_val = *src_pixel++;
2507 *dst_pixel++ = rgb_to_pixel_colortable(dst,
2508 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
2509 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
2510 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) );
2511 }
2512 if(pad_size) memset(dst_pixel, 0, pad_size);
2513 dst_start += dst->stride;
2514 src_start += src->stride / 2;
2515 }
2516 }
2517 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2518 {
2519 for(y = src_rect->top; y < src_rect->bottom; y++)
2520 {
2521 dst_pixel = dst_start;
2522 src_pixel = src_start;
2523 for(x = src_rect->left; x < src_rect->right; x++)
2524 {
2525 src_val = *src_pixel++;
2526 *dst_pixel++ = rgb_to_pixel_colortable(dst,
2527 (((src_val >> src->red_shift) << 3) & 0xf8) |
2528 (((src_val >> src->red_shift) >> 2) & 0x07),
2529 (((src_val >> src->green_shift) << 3) & 0xf8) |
2530 (((src_val >> src->green_shift) >> 2) & 0x07),
2531 (((src_val >> src->blue_shift) << 3) & 0xf8) |
2532 (((src_val >> src->blue_shift) >> 2) & 0x07) );
2533 }
2534 if(pad_size) memset(dst_pixel, 0, pad_size);
2535 dst_start += dst->stride;
2536 src_start += src->stride / 2;
2537 }
2538 }
2539 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2540 {
2541 for(y = src_rect->top; y < src_rect->bottom; y++)
2542 {
2543 dst_pixel = dst_start;
2544 src_pixel = src_start;
2545 for(x = src_rect->left; x < src_rect->right; x++)
2546 {
2547 src_val = *src_pixel++;
2548 *dst_pixel++ = rgb_to_pixel_colortable(dst,
2549 (((src_val >> src->red_shift) << 3) & 0xf8) |
2550 (((src_val >> src->red_shift) >> 2) & 0x07),
2551 (((src_val >> src->green_shift) << 2) & 0xfc) |
2552 (((src_val >> src->green_shift) >> 4) & 0x03),
2553 (((src_val >> src->blue_shift) << 3) & 0xf8) |
2554 (((src_val >> src->blue_shift) >> 2) & 0x07) );
2555 }
2556 if(pad_size) memset(dst_pixel, 0, pad_size);
2557 dst_start += dst->stride;
2558 src_start += src->stride / 2;
2559 }
2560 }
2561 else
2562 {
2563 for(y = src_rect->top; y < src_rect->bottom; y++)
2564 {
2565 dst_pixel = dst_start;
2566 src_pixel = src_start;
2567 for(x = src_rect->left; x < src_rect->right; x++)
2568 {
2569 src_val = *src_pixel++;
2570 *dst_pixel++ = rgb_to_pixel_colortable(dst,
2571 get_field(src_val, src->red_shift, src->red_len),
2572 get_field(src_val, src->green_shift, src->green_len),
2573 get_field(src_val, src->blue_shift, src->blue_len));
2574 }
2575 if(pad_size) memset(dst_pixel, 0, pad_size);
2576 dst_start += dst->stride;
2577 src_start += src->stride / 2;
2578 }
2579 }
2580 break;
2581 }
2582
2583 case 8:
2584 {
2585 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
2586
2587 if(color_tables_match(dst, src))
2588 {
2589 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
2590 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2591 else
2592 {
2593 for(y = src_rect->top; y < src_rect->bottom; y++)
2594 {
2595 memcpy(dst_start, src_start, src_rect->right - src_rect->left);
2596 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left), 0, pad_size);
2597 dst_start += dst->stride;
2598 src_start += src->stride;
2599 }
2600 }
2601 }
2602 else
2603 {
2604 for(y = src_rect->top; y < src_rect->bottom; y++)
2605 {
2606 dst_pixel = dst_start;
2607 src_pixel = src_start;
2608 for(x = src_rect->left; x < src_rect->right; x++)
2609 {
2610 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
2611 *dst_pixel++ = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2612 }
2613 if(pad_size) memset(dst_pixel, 0, pad_size);
2614 dst_start += dst->stride;
2615 src_start += src->stride;
2616 }
2617 }
2618 break;
2619 }
2620
2621 case 4:
2622 {
2623 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2624 for(y = src_rect->top; y < src_rect->bottom; y++)
2625 {
2626 dst_pixel = dst_start;
2627 src_pixel = src_start;
2628 for(x = src_rect->left; x < src_rect->right; x++)
2629 {
2630 RGBQUAD rgb;
2631 if(x & 1)
2632 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2633 else
2634 rgb = colortable_entry( src, *src_pixel >> 4 );
2635 *dst_pixel++ = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2636 }
2637 if(pad_size) memset(dst_pixel, 0, pad_size);
2638 dst_start += dst->stride;
2639 src_start += src->stride;
2640 }
2641 break;
2642 }
2643
2644 case 1:
2645 {
2646 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
2647 for(y = src_rect->top; y < src_rect->bottom; y++)
2648 {
2649 dst_pixel = dst_start;
2650 src_pixel = src_start;
2651 for(x = src_rect->left; x < src_rect->right; x++)
2652 {
2653 RGBQUAD rgb;
2654 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
2655 if((x % 8) == 7) src_pixel++;
2656 rgb = src->color_table[src_val];
2657 *dst_pixel++ = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2658 }
2659 if(pad_size) memset(dst_pixel, 0, pad_size);
2660 dst_start += dst->stride;
2661 src_start += src->stride;
2662 }
2663 break;
2664 }
2665 }
2666 }
2667
2668 static void convert_to_4(dib_info *dst, const dib_info *src, const RECT *src_rect)
2669 {
2670 BYTE *dst_start = get_pixel_ptr_4(dst, 0, 0), *dst_pixel, dst_val;
2671 INT x, y, pad_size = ((dst->width + 7) & ~7) / 2 - (src_rect->right - src_rect->left + 1) / 2;
2672 DWORD src_val;
2673
2674 switch(src->bit_count)
2675 {
2676 case 32:
2677 {
2678 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
2679
2680 if(src->funcs == &funcs_8888)
2681 {
2682 for(y = src_rect->top; y < src_rect->bottom; y++)
2683 {
2684 dst_pixel = dst_start;
2685 src_pixel = src_start;
2686 for(x = src_rect->left; x < src_rect->right; x++)
2687 {
2688 src_val = *src_pixel++;
2689 dst_val = rgb_to_pixel_colortable(dst, src_val >> 16, src_val >> 8, src_val);
2690 if((x - src_rect->left) & 1)
2691 {
2692 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2693 dst_pixel++;
2694 }
2695 else
2696 *dst_pixel = (dst_val << 4) & 0xf0;
2697 }
2698 if(pad_size)
2699 {
2700 if((x - src_rect->left) & 1) dst_pixel++;
2701 memset(dst_pixel, 0, pad_size);
2702 }
2703 dst_start += dst->stride;
2704 src_start += src->stride / 4;
2705 }
2706 }
2707 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
2708 {
2709 for(y = src_rect->top; y < src_rect->bottom; y++)
2710 {
2711 dst_pixel = dst_start;
2712 src_pixel = src_start;
2713 for(x = src_rect->left; x < src_rect->right; x++)
2714 {
2715 src_val = *src_pixel++;
2716 dst_val = rgb_to_pixel_colortable(dst,
2717 src_val >> src->red_shift,
2718 src_val >> src->green_shift,
2719 src_val >> src->blue_shift);
2720 if((x - src_rect->left) & 1)
2721 {
2722 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2723 dst_pixel++;
2724 }
2725 else
2726 *dst_pixel = (dst_val << 4) & 0xf0;
2727 }
2728 if(pad_size)
2729 {
2730 if((x - src_rect->left) & 1) dst_pixel++;
2731 memset(dst_pixel, 0, pad_size);
2732 }
2733 dst_start += dst->stride;
2734 src_start += src->stride / 4;
2735 }
2736 }
2737 else
2738 {
2739 for(y = src_rect->top; y < src_rect->bottom; y++)
2740 {
2741 dst_pixel = dst_start;
2742 src_pixel = src_start;
2743 for(x = src_rect->left; x < src_rect->right; x++)
2744 {
2745 src_val = *src_pixel++;
2746 dst_val = rgb_to_pixel_colortable(dst,
2747 get_field(src_val, src->red_shift, src->red_len),
2748 get_field(src_val, src->green_shift, src->green_len),
2749 get_field(src_val, src->blue_shift, src->blue_len));
2750 if((x - src_rect->left) & 1)
2751 {
2752 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2753 dst_pixel++;
2754 }
2755 else
2756 *dst_pixel = (dst_val << 4) & 0xf0;
2757 }
2758 if(pad_size)
2759 {
2760 if((x - src_rect->left) & 1) dst_pixel++;
2761 memset(dst_pixel, 0, pad_size);
2762 }
2763 dst_start += dst->stride;
2764 src_start += src->stride / 4;
2765 }
2766 }
2767 break;
2768 }
2769
2770 case 24:
2771 {
2772 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
2773
2774 for(y = src_rect->top; y < src_rect->bottom; y++)
2775 {
2776 dst_pixel = dst_start;
2777 src_pixel = src_start;
2778 for(x = src_rect->left; x < src_rect->right; x++, src_pixel += 3)
2779 {
2780 dst_val = rgb_to_pixel_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0]);
2781
2782 if((x - src_rect->left) & 1)
2783 {
2784 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2785 dst_pixel++;
2786 }
2787 else
2788 *dst_pixel = (dst_val << 4) & 0xf0;
2789 }
2790 if(pad_size)
2791 {
2792 if((x - src_rect->left) & 1) dst_pixel++;
2793 memset(dst_pixel, 0, pad_size);
2794 }
2795 dst_start += dst->stride;
2796 src_start += src->stride;
2797 }
2798 break;
2799 }
2800
2801 case 16:
2802 {
2803 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
2804 if(src->funcs == &funcs_555)
2805 {
2806 for(y = src_rect->top; y < src_rect->bottom; y++)
2807 {
2808 dst_pixel = dst_start;
2809 src_pixel = src_start;
2810 for(x = src_rect->left; x < src_rect->right; x++)
2811 {
2812 src_val = *src_pixel++;
2813 dst_val = rgb_to_pixel_colortable(dst,
2814 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
2815 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
2816 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) );
2817 if((x - src_rect->left) & 1)
2818 {
2819 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2820 dst_pixel++;
2821 }
2822 else
2823 *dst_pixel = (dst_val << 4) & 0xf0;
2824 }
2825 if(pad_size)
2826 {
2827 if((x - src_rect->left) & 1) dst_pixel++;
2828 memset(dst_pixel, 0, pad_size);
2829 }
2830 dst_start += dst->stride;
2831 src_start += src->stride / 2;
2832 }
2833 }
2834 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
2835 {
2836 for(y = src_rect->top; y < src_rect->bottom; y++)
2837 {
2838 dst_pixel = dst_start;
2839 src_pixel = src_start;
2840 for(x = src_rect->left; x < src_rect->right; x++)
2841 {
2842 src_val = *src_pixel++;
2843 dst_val = rgb_to_pixel_colortable(dst,
2844 (((src_val >> src->red_shift) << 3) & 0xf8) |
2845 (((src_val >> src->red_shift) >> 2) & 0x07),
2846 (((src_val >> src->green_shift) << 3) & 0xf8) |
2847 (((src_val >> src->green_shift) >> 2) & 0x07),
2848 (((src_val >> src->blue_shift) << 3) & 0xf8) |
2849 (((src_val >> src->blue_shift) >> 2) & 0x07) );
2850 if((x - src_rect->left) & 1)
2851 {
2852 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2853 dst_pixel++;
2854 }
2855 else
2856 *dst_pixel = (dst_val << 4) & 0xf0;
2857 }
2858 if(pad_size)
2859 {
2860 if((x - src_rect->left) & 1) dst_pixel++;
2861 memset(dst_pixel, 0, pad_size);
2862 }
2863 dst_start += dst->stride;
2864 src_start += src->stride / 2;
2865 }
2866 }
2867 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
2868 {
2869 for(y = src_rect->top; y < src_rect->bottom; y++)
2870 {
2871 dst_pixel = dst_start;
2872 src_pixel = src_start;
2873 for(x = src_rect->left; x < src_rect->right; x++)
2874 {
2875 src_val = *src_pixel++;
2876 dst_val = rgb_to_pixel_colortable(dst,
2877 (((src_val >> src->red_shift) << 3) & 0xf8) |
2878 (((src_val >> src->red_shift) >> 2) & 0x07),
2879 (((src_val >> src->green_shift) << 2) & 0xfc) |
2880 (((src_val >> src->green_shift) >> 4) & 0x03),
2881 (((src_val >> src->blue_shift) << 3) & 0xf8) |
2882 (((src_val >> src->blue_shift) >> 2) & 0x07) );
2883 if((x - src_rect->left) & 1)
2884 {
2885 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2886 dst_pixel++;
2887 }
2888 else
2889 *dst_pixel = (dst_val << 4) & 0xf0;
2890 }
2891 if(pad_size)
2892 {
2893 if((x - src_rect->left) & 1) dst_pixel++;
2894 memset(dst_pixel, 0, pad_size);
2895 }
2896 dst_start += dst->stride;
2897 src_start += src->stride / 2;
2898 }
2899 }
2900 else
2901 {
2902 for(y = src_rect->top; y < src_rect->bottom; y++)
2903 {
2904 dst_pixel = dst_start;
2905 src_pixel = src_start;
2906 for(x = src_rect->left; x < src_rect->right; x++)
2907 {
2908 src_val = *src_pixel++;
2909 dst_val = rgb_to_pixel_colortable(dst,
2910 get_field(src_val, src->red_shift, src->red_len),
2911 get_field(src_val, src->green_shift, src->green_len),
2912 get_field(src_val, src->blue_shift, src->blue_len));
2913 if((x - src_rect->left) & 1)
2914 {
2915 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2916 dst_pixel++;
2917 }
2918 else
2919 *dst_pixel = (dst_val << 4) & 0xf0;
2920 }
2921 if(pad_size)
2922 {
2923 if((x - src_rect->left) & 1) dst_pixel++;
2924 memset(dst_pixel, 0, pad_size);
2925 }
2926 dst_start += dst->stride;
2927 src_start += src->stride / 2;
2928 }
2929 }
2930 break;
2931 }
2932
2933 case 8:
2934 {
2935 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
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_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2945 if((x - src_rect->left) & 1)
2946 {
2947 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
2948 dst_pixel++;
2949 }
2950 else
2951 *dst_pixel = (dst_val << 4) & 0xf0;
2952 }
2953 if(pad_size)
2954 {
2955 if((x - src_rect->left) & 1) dst_pixel++;
2956 memset(dst_pixel, 0, pad_size);
2957 }
2958 dst_start += dst->stride;
2959 src_start += src->stride;
2960 }
2961 break;
2962 }
2963
2964 case 4:
2965 {
2966 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
2967
2968 if(color_tables_match(dst, src) && (src_rect->left & 1) == 0)
2969 {
2970 if(src->stride > 0 && dst->stride > 0 && src_rect->left == 0 && src_rect->right == src->width)
2971 memcpy(dst_start, src_start, (src_rect->bottom - src_rect->top) * src->stride);
2972 else
2973 {
2974 for(y = src_rect->top; y < src_rect->bottom; y++)
2975 {
2976 memcpy(dst_start, src_start, (src_rect->right - src_rect->left + 1) / 2);
2977 if(pad_size) memset(dst_start + (src_rect->right - src_rect->left + 1) / 2, 0, pad_size);
2978 dst_start += dst->stride;
2979 src_start += src->stride;
2980 }
2981 }
2982 }
2983 else
2984 {
2985 for(y = src_rect->top; y < src_rect->bottom; y++)
2986 {
2987 dst_pixel = dst_start;
2988 src_pixel = src_start;
2989 for(x = src_rect->left; x < src_rect->right; x++)
2990 {
2991 RGBQUAD rgb;
2992 if(x & 1)
2993 rgb = colortable_entry( src, *src_pixel++ & 0xf );
2994 else
2995 rgb = colortable_entry( src, *src_pixel >> 4 );
2996 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
2997 if((x - src_rect->left) & 1)
2998 {
2999 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3000 dst_pixel++;
3001 }
3002 else
3003 *dst_pixel = (dst_val << 4) & 0xf0;
3004 }
3005 if(pad_size)
3006 {
3007 if((x - src_rect->left) & 1) dst_pixel++;
3008 memset(dst_pixel, 0, pad_size);
3009 }
3010 dst_start += dst->stride;
3011 src_start += src->stride;
3012 }
3013 }
3014 break;
3015 }
3016
3017 case 1:
3018 {
3019 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
3020 for(y = src_rect->top; y < src_rect->bottom; y++)
3021 {
3022 dst_pixel = dst_start;
3023 src_pixel = src_start;
3024 for(x = src_rect->left; x < src_rect->right; x++)
3025 {
3026 RGBQUAD rgb;
3027 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
3028 if((x % 8) == 7) src_pixel++;
3029 rgb = src->color_table[src_val];
3030 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
3031 if((x - src_rect->left) & 1)
3032 {
3033 *dst_pixel = (dst_val & 0x0f) | (*dst_pixel & 0xf0);
3034 dst_pixel++;
3035 }
3036 else
3037 *dst_pixel = (dst_val << 4) & 0xf0;
3038 }
3039 if(pad_size)
3040 {
3041 if((x - src_rect->left) & 1) dst_pixel++;
3042 memset(dst_pixel, 0, pad_size);
3043 }
3044 dst_start += dst->stride;
3045 src_start += src->stride;
3046 }
3047 break;
3048 }
3049 }
3050 }
3051
3052 static void convert_to_1(dib_info *dst, const dib_info *src, const RECT *src_rect)
3053 {
3054 BYTE *dst_start = get_pixel_ptr_1(dst, 0, 0), *dst_pixel, dst_val;
3055 INT x, y, pad_size = ((dst->width + 31) & ~31) / 8 - (src_rect->right - src_rect->left + 7) / 8;
3056 DWORD src_val;
3057 int bit_pos;
3058
3059 /* FIXME: Brushes should be dithered. */
3060
3061 switch(src->bit_count)
3062 {
3063 case 32:
3064 {
3065 DWORD *src_start = get_pixel_ptr_32(src, src_rect->left, src_rect->top), *src_pixel;
3066
3067 if(src->funcs == &funcs_8888)
3068 {
3069 for(y = src_rect->top; y < src_rect->bottom; y++)
3070 {
3071 dst_pixel = dst_start;
3072 src_pixel = src_start;
3073 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3074 {
3075 src_val = *src_pixel++;
3076 dst_val = rgb_to_pixel_colortable(dst, src_val >> 16, src_val >> 8, src_val) ? 0xff : 0;
3077
3078 if(bit_pos == 0) *dst_pixel = 0;
3079 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3080
3081 if(++bit_pos == 8)
3082 {
3083 dst_pixel++;
3084 bit_pos = 0;
3085 }
3086 }
3087 if(pad_size)
3088 {
3089 if(bit_pos != 0) dst_pixel++;
3090 memset(dst_pixel, 0, pad_size);
3091 }
3092 dst_start += dst->stride;
3093 src_start += src->stride / 4;
3094 }
3095 }
3096 else if(src->red_len == 8 && src->green_len == 8 && src->blue_len == 8)
3097 {
3098 for(y = src_rect->top; y < src_rect->bottom; y++)
3099 {
3100 dst_pixel = dst_start;
3101 src_pixel = src_start;
3102 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3103 {
3104 src_val = *src_pixel++;
3105 dst_val = rgb_to_pixel_colortable(dst,
3106 src_val >> src->red_shift,
3107 src_val >> src->green_shift,
3108 src_val >> src->blue_shift) ? 0xff : 0;
3109
3110 if(bit_pos == 0) *dst_pixel = 0;
3111 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3112
3113 if(++bit_pos == 8)
3114 {
3115 dst_pixel++;
3116 bit_pos = 0;
3117 }
3118 }
3119 if(pad_size)
3120 {
3121 if(bit_pos != 0) dst_pixel++;
3122 memset(dst_pixel, 0, pad_size);
3123 }
3124 dst_start += dst->stride;
3125 src_start += src->stride / 4;
3126 }
3127 }
3128 else
3129 {
3130 for(y = src_rect->top; y < src_rect->bottom; y++)
3131 {
3132 dst_pixel = dst_start;
3133 src_pixel = src_start;
3134 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3135 {
3136 src_val = *src_pixel++;
3137 dst_val = rgb_to_pixel_colortable(dst,
3138 get_field(src_val, src->red_shift, src->red_len),
3139 get_field(src_val, src->green_shift, src->green_len),
3140 get_field(src_val, src->blue_shift, src->blue_len)) ? 0xff : 0;
3141
3142 if(bit_pos == 0) *dst_pixel = 0;
3143 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3144
3145 if(++bit_pos == 8)
3146 {
3147 dst_pixel++;
3148 bit_pos = 0;
3149 }
3150 }
3151 if(pad_size)
3152 {
3153 if(bit_pos != 0) dst_pixel++;
3154 memset(dst_pixel, 0, pad_size);
3155 }
3156 dst_start += dst->stride;
3157 src_start += src->stride / 4;
3158 }
3159 }
3160 break;
3161 }
3162
3163 case 24:
3164 {
3165 BYTE *src_start = get_pixel_ptr_24(src, src_rect->left, src_rect->top), *src_pixel;
3166
3167 for(y = src_rect->top; y < src_rect->bottom; y++)
3168 {
3169 dst_pixel = dst_start;
3170 src_pixel = src_start;
3171 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++, src_pixel += 3)
3172 {
3173 dst_val = rgb_to_pixel_colortable(dst, src_pixel[2], src_pixel[1], src_pixel[0]) ? 0xff : 0;
3174
3175 if(bit_pos == 0) *dst_pixel = 0;
3176 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3177
3178 if(++bit_pos == 8)
3179 {
3180 dst_pixel++;
3181 bit_pos = 0;
3182 }
3183 }
3184 if(pad_size)
3185 {
3186 if(bit_pos != 0) dst_pixel++;
3187 memset(dst_pixel, 0, pad_size);
3188 }
3189 dst_start += dst->stride;
3190 src_start += src->stride;
3191 }
3192 break;
3193 }
3194
3195 case 16:
3196 {
3197 WORD *src_start = get_pixel_ptr_16(src, src_rect->left, src_rect->top), *src_pixel;
3198 if(src->funcs == &funcs_555)
3199 {
3200 for(y = src_rect->top; y < src_rect->bottom; y++)
3201 {
3202 dst_pixel = dst_start;
3203 src_pixel = src_start;
3204 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3205 {
3206 src_val = *src_pixel++;
3207 dst_val = rgb_to_pixel_colortable(dst,
3208 ((src_val >> 7) & 0xf8) | ((src_val >> 12) & 0x07),
3209 ((src_val >> 2) & 0xf8) | ((src_val >> 7) & 0x07),
3210 ((src_val << 3) & 0xf8) | ((src_val >> 2) & 0x07) ) ? 0xff : 0;
3211
3212 if(bit_pos == 0) *dst_pixel = 0;
3213 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3214
3215 if(++bit_pos == 8)
3216 {
3217 dst_pixel++;
3218 bit_pos = 0;
3219 }
3220 }
3221 if(pad_size)
3222 {
3223 if(bit_pos != 0) dst_pixel++;
3224 memset(dst_pixel, 0, pad_size);
3225 }
3226 dst_start += dst->stride;
3227 src_start += src->stride / 2;
3228 }
3229 }
3230 else if(src->red_len == 5 && src->green_len == 5 && src->blue_len == 5)
3231 {
3232 for(y = src_rect->top; y < src_rect->bottom; y++)
3233 {
3234 dst_pixel = dst_start;
3235 src_pixel = src_start;
3236 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3237 {
3238 src_val = *src_pixel++;
3239 dst_val = rgb_to_pixel_colortable(dst,
3240 (((src_val >> src->red_shift) << 3) & 0xf8) |
3241 (((src_val >> src->red_shift) >> 2) & 0x07),
3242 (((src_val >> src->green_shift) << 3) & 0xf8) |
3243 (((src_val >> src->green_shift) >> 2) & 0x07),
3244 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3245 (((src_val >> src->blue_shift) >> 2) & 0x07) ) ? 0xff : 0;
3246 if(bit_pos == 0) *dst_pixel = 0;
3247 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3248
3249 if(++bit_pos == 8)
3250 {
3251 dst_pixel++;
3252 bit_pos = 0;
3253 }
3254 }
3255 if(pad_size)
3256 {
3257 if(bit_pos != 0) dst_pixel++;
3258 memset(dst_pixel, 0, pad_size);
3259 }
3260 dst_start += dst->stride;
3261 src_start += src->stride / 2;
3262 }
3263 }
3264 else if(src->red_len == 5 && src->green_len == 6 && src->blue_len == 5)
3265 {
3266 for(y = src_rect->top; y < src_rect->bottom; y++)
3267 {
3268 dst_pixel = dst_start;
3269 src_pixel = src_start;
3270 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3271 {
3272 src_val = *src_pixel++;
3273 dst_val = rgb_to_pixel_colortable(dst,
3274 (((src_val >> src->red_shift) << 3) & 0xf8) |
3275 (((src_val >> src->red_shift) >> 2) & 0x07),
3276 (((src_val >> src->green_shift) << 2) & 0xfc) |
3277 (((src_val >> src->green_shift) >> 4) & 0x03),
3278 (((src_val >> src->blue_shift) << 3) & 0xf8) |
3279 (((src_val >> src->blue_shift) >> 2) & 0x07) ) ? 0xff : 0;
3280 if(bit_pos == 0) *dst_pixel = 0;
3281 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3282
3283 if(++bit_pos == 8)
3284 {
3285 dst_pixel++;
3286 bit_pos = 0;
3287 }
3288 }
3289 if(pad_size)
3290 {
3291 if(bit_pos != 0) dst_pixel++;
3292 memset(dst_pixel, 0, pad_size);
3293 }
3294 dst_start += dst->stride;
3295 src_start += src->stride / 2;
3296 }
3297 }
3298 else
3299 {
3300 for(y = src_rect->top; y < src_rect->bottom; y++)
3301 {
3302 dst_pixel = dst_start;
3303 src_pixel = src_start;
3304 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3305 {
3306 src_val = *src_pixel++;
3307 dst_val = rgb_to_pixel_colortable(dst,
3308 get_field(src_val, src->red_shift, src->red_len),
3309 get_field(src_val, src->green_shift, src->green_len),
3310 get_field(src_val, src->blue_shift, src->blue_len)) ? 0xff : 0;
3311 if(bit_pos == 0) *dst_pixel = 0;
3312 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3313
3314 if(++bit_pos == 8)
3315 {
3316 dst_pixel++;
3317 bit_pos = 0;
3318 }
3319 }
3320 if(pad_size)
3321 {
3322 if(bit_pos != 0) dst_pixel++;
3323 memset(dst_pixel, 0, pad_size);
3324 }
3325 dst_start += dst->stride;
3326 src_start += src->stride / 2;
3327 }
3328 }
3329 break;
3330 }
3331
3332 case 8:
3333 {
3334 BYTE *src_start = get_pixel_ptr_8(src, src_rect->left, src_rect->top), *src_pixel;
3335
3336 for(y = src_rect->top; y < src_rect->bottom; y++)
3337 {
3338 dst_pixel = dst_start;
3339 src_pixel = src_start;
3340 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3341 {
3342 RGBQUAD rgb = colortable_entry( src, *src_pixel++ );
3343 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue) ? 0xff : 0;
3344
3345 if(bit_pos == 0) *dst_pixel = 0;
3346 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3347
3348 if(++bit_pos == 8)
3349 {
3350 dst_pixel++;
3351 bit_pos = 0;
3352 }
3353 }
3354 if(pad_size)
3355 {
3356 if(bit_pos != 0) dst_pixel++;
3357 memset(dst_pixel, 0, pad_size);
3358 }
3359 dst_start += dst->stride;
3360 src_start += src->stride;
3361 }
3362 break;
3363 }
3364
3365 case 4:
3366 {
3367 BYTE *src_start = get_pixel_ptr_4(src, src_rect->left, src_rect->top), *src_pixel;
3368
3369 for(y = src_rect->top; y < src_rect->bottom; y++)
3370 {
3371 dst_pixel = dst_start;
3372 src_pixel = src_start;
3373 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3374 {
3375 RGBQUAD rgb;
3376 if(x & 1)
3377 rgb = colortable_entry( src, *src_pixel++ & 0xf );
3378 else
3379 rgb = colortable_entry( src, *src_pixel >> 4 );
3380 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue) ? 0xff : 0;
3381
3382 if(bit_pos == 0) *dst_pixel = 0;
3383 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3384
3385 if(++bit_pos == 8)
3386 {
3387 dst_pixel++;
3388 bit_pos = 0;
3389 }
3390 }
3391 if(pad_size)
3392 {
3393 if(bit_pos != 0) dst_pixel++;
3394 memset(dst_pixel, 0, pad_size);
3395 }
3396 dst_start += dst->stride;
3397 src_start += src->stride;
3398 }
3399 break;
3400 }
3401
3402 /* Note that while MSDN states that a 1 bpp dib brush -> mono dc
3403 uses text/bkgnd colours instead of the dib's colour table, this
3404 doesn't appear to be the case for a dc backed by a
3405 dibsection. */
3406
3407 case 1:
3408 {
3409 BYTE *src_start = get_pixel_ptr_1(src, src_rect->left, src_rect->top), *src_pixel;
3410 for(y = src_rect->top; y < src_rect->bottom; y++)
3411 {
3412 dst_pixel = dst_start;
3413 src_pixel = src_start;
3414 for(x = src_rect->left, bit_pos = 0; x < src_rect->right; x++)
3415 {
3416 RGBQUAD rgb;
3417 src_val = (*src_pixel & pixel_masks_1[x % 8]) ? 1 : 0;
3418 if((x % 8) == 7) src_pixel++;
3419 rgb = src->color_table[src_val];
3420 dst_val = rgb_to_pixel_colortable(dst, rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue) ? 0xff : 0;
3421
3422 if(bit_pos == 0) *dst_pixel = 0;
3423 *dst_pixel = (*dst_pixel & ~pixel_masks_1[bit_pos]) | (dst_val & pixel_masks_1[bit_pos]);
3424
3425 if(++bit_pos == 8)
3426 {
3427 dst_pixel++;
3428 bit_pos = 0;
3429 }
3430 }
3431 if(pad_size)
3432 {
3433 if(bit_pos != 0) dst_pixel++;
3434 memset(dst_pixel, 0, pad_size);
3435 }
3436 dst_start += dst->stride;
3437 src_start += src->stride;
3438 }
3439 break;
3440 }
3441 }
3442 }
3443
3444 static void convert_to_null(dib_info *dst, const dib_info *src, const RECT *src_rect)
3445 {
3446 }
3447
3448 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)
3449 {
3450 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
3451 DWORD mask_start = 0, mask_offset;
3452 DWORD *and_bits = bits->and, *xor_bits = bits->xor;
3453 int x, y;
3454
3455 for(y = 0; y < hatch->height; y++)
3456 {
3457 hatch_ptr = hatch_start;
3458 mask_offset = mask_start;
3459 for(x = 0; x < hatch->width; x++)
3460 {
3461 if(*hatch_ptr & pixel_masks_1[x % 8])
3462 {
3463 and_bits[mask_offset] = fg->and;
3464 xor_bits[mask_offset] = fg->xor;
3465 }
3466 else
3467 {
3468 and_bits[mask_offset] = bg->and;
3469 xor_bits[mask_offset] = bg->xor;
3470 }
3471 if(x % 8 == 7) hatch_ptr++;
3472 mask_offset++;
3473 }
3474 hatch_start += hatch->stride;
3475 mask_start += dib->stride / 4;
3476 }
3477
3478 return TRUE;
3479 }
3480
3481 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)
3482 {
3483 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
3484 DWORD mask_start = 0, mask_offset;
3485 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
3486 int x, y;
3487
3488 for(y = 0; y < hatch->height; y++)
3489 {
3490 hatch_ptr = hatch_start;
3491 mask_offset = mask_start;
3492 for(x = 0; x < hatch->width; x++)
3493 {
3494 if(*hatch_ptr & pixel_masks_1[x % 8])
3495 {
3496 and_bits[mask_offset] = fg->and & 0xff;
3497 xor_bits[mask_offset++] = fg->xor & 0xff;
3498 and_bits[mask_offset] = (fg->and >> 8) & 0xff;
3499 xor_bits[mask_offset++] = (fg->xor >> 8) & 0xff;
3500 and_bits[mask_offset] = (fg->and >> 16) & 0xff;
3501 xor_bits[mask_offset++] = (fg->xor >> 16) & 0xff;
3502 }
3503 else
3504 {
3505 and_bits[mask_offset] = bg->and & 0xff;
3506 xor_bits[mask_offset++] = bg->xor & 0xff;
3507 and_bits[mask_offset] = (bg->and >> 8) & 0xff;
3508 xor_bits[mask_offset++] = (bg->xor >> 8) & 0xff;
3509 and_bits[mask_offset] = (bg->and >> 16) & 0xff;
3510 xor_bits[mask_offset++] = (bg->xor >> 16) & 0xff;
3511 }
3512 if(x % 8 == 7) hatch_ptr++;
3513 }
3514 hatch_start += hatch->stride;
3515 mask_start += dib->stride;
3516 }
3517
3518 return TRUE;
3519 }
3520
3521 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)
3522 {
3523 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
3524 DWORD mask_start = 0, mask_offset;
3525 WORD *and_bits = bits->and, *xor_bits = bits->xor;
3526 int x, y;
3527
3528 for(y = 0; y < hatch->height; y++)
3529 {
3530 hatch_ptr = hatch_start;
3531 mask_offset = mask_start;
3532 for(x = 0; x < hatch->width; x++)
3533 {
3534 if(*hatch_ptr & pixel_masks_1[x % 8])
3535 {
3536 and_bits[mask_offset] = fg->and;
3537 xor_bits[mask_offset] = fg->xor;
3538 }
3539 else
3540 {
3541 and_bits[mask_offset] = bg->and;
3542 xor_bits[mask_offset] = bg->xor;
3543 }
3544 if(x % 8 == 7) hatch_ptr++;
3545 mask_offset++;
3546 }
3547 hatch_start += hatch->stride;
3548 mask_start += dib->stride / 2;
3549 }
3550
3551 return TRUE;
3552 }
3553
3554 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)
3555 {
3556 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
3557 DWORD mask_start = 0, mask_offset;
3558 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
3559 int x, y;
3560
3561 for(y = 0; y < hatch->height; y++)
3562 {
3563 hatch_ptr = hatch_start;
3564 mask_offset = mask_start;
3565 for(x = 0; x < hatch->width; x++)
3566 {
3567 if(*hatch_ptr & pixel_masks_1[x % 8])
3568 {
3569 and_bits[mask_offset] = fg->and;
3570 xor_bits[mask_offset] = fg->xor;
3571 }
3572 else
3573 {
3574 and_bits[mask_offset] = bg->and;
3575 xor_bits[mask_offset] = bg->xor;
3576 }
3577 if(x % 8 == 7) hatch_ptr++;
3578 mask_offset++;
3579 }
3580 hatch_start += hatch->stride;
3581 mask_start += dib->stride;
3582 }
3583
3584 return TRUE;
3585 }
3586
3587 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)
3588 {
3589 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
3590 DWORD mask_start = 0, mask_offset;
3591 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
3592 const rop_mask *rop_mask;
3593 int x, y;
3594
3595 for(y = 0; y < hatch->height; y++)
3596 {
3597 hatch_ptr = hatch_start;
3598 mask_offset = mask_start;
3599 for(x = 0; x < hatch->width; x++)
3600 {
3601 if(*hatch_ptr & pixel_masks_1[x % 8])
3602 rop_mask = fg;
3603 else
3604 rop_mask = bg;
3605
3606 if(x & 1)
3607 {
3608 and_bits[mask_offset] = (rop_mask->and & 0x0f) | (and_bits[mask_offset] & 0xf0);
3609 xor_bits[mask_offset] = (rop_mask->xor & 0x0f) | (xor_bits[mask_offset] & 0xf0);
3610 mask_offset++;
3611 }
3612 else
3613 {
3614 and_bits[mask_offset] = (rop_mask->and << 4) & 0xf0;
3615 xor_bits[mask_offset] = (rop_mask->xor << 4) & 0xf0;
3616 }
3617
3618 if(x % 8 == 7) hatch_ptr++;
3619 }
3620 hatch_start += hatch->stride;
3621 mask_start += dib->stride;
3622 }
3623
3624 return TRUE;
3625 }
3626
3627 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)
3628 {
3629 BYTE *hatch_start = get_pixel_ptr_1(hatch, 0, 0), *hatch_ptr;
3630 DWORD mask_start = 0, mask_offset;
3631 BYTE *and_bits = bits->and, *xor_bits = bits->xor;
3632 rop_mask rop_mask;
3633 int x, y, bit_pos;
3634
3635 for(y = 0; y < hatch->height; y++)
3636 {
3637 hatch_ptr = hatch_start;
3638 mask_offset = mask_start;
3639 for(x = 0, bit_pos = 0; x < hatch->width; x++)
3640 {
3641 if(*hatch_ptr & pixel_masks_1[x % 8])
3642 {
3643 rop_mask.and = (fg->and & 1) ? 0xff : 0;
3644 rop_mask.xor = (fg->xor & 1) ? 0xff : 0;
3645 }
3646 else
3647 {
3648 rop_mask.and = (bg->and & 1) ? 0xff : 0;
3649 rop_mask.xor = (bg->xor & 1) ? 0xff : 0;
3650 }
3651
3652 if(bit_pos == 0) and_bits[mask_offset] = xor_bits[mask_offset] = 0;
3653
3654 and_bits[mask_offset] = (rop_mask.and & pixel_masks_1[bit_pos]) | (and_bits[mask_offset] & ~pixel_masks_1[bit_pos]);
3655 xor_bits[mask_offset] = (rop_mask.xor & pixel_masks_1[bit_pos]) | (xor_bits[mask_offset] & ~pixel_masks_1[bit_pos]);
3656
3657 if(++bit_pos == 8)
3658 {
3659 mask_offset++;
3660 hatch_ptr++;
3661 bit_pos = 0;
3662 }
3663 }
3664 hatch_start += hatch->stride;
3665 mask_start += dib->stride;
3666 }
3667
3668 return TRUE;
3669 }
3670
3671 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)
3672 {
3673 return FALSE;
3674 }
3675
3676 static inline void rop_codes_from_stretch_mode( int mode, struct rop_codes *codes )
3677 {
3678 switch (mode)
3679 {
3680 default:
3681 case STRETCH_DELETESCANS:
3682 get_rop_codes( R2_COPYPEN, codes );
3683 break;
3684 case STRETCH_ORSCANS:
3685 get_rop_codes( R2_MERGEPEN, codes );
3686 break;
3687 case STRETCH_ANDSCANS:
3688 get_rop_codes( R2_MASKPEN, codes );
3689 break;
3690 }
3691 return;
3692 }
3693
3694 static void stretch_row_32(const dib_info *dst_dib, const POINT *dst_start,
3695 const dib_info *src_dib, const POINT *src_start,
3696 const struct stretch_params *params, int mode,
3697 BOOL keep_dst)
3698 {
3699 DWORD *dst_ptr = get_pixel_ptr_32( dst_dib, dst_start->x, dst_start->y );
3700 DWORD *src_ptr = get_pixel_ptr_32( src_dib, src_start->x, src_start->y );
3701 int err = params->err_start;
3702 int width;
3703 struct rop_codes codes;
3704
3705 rop_codes_from_stretch_mode( mode, &codes );
3706 for (width = params->length; width; width--)
3707 {
3708 do_rop_codes_32( dst_ptr, *src_ptr, &codes );
3709 dst_ptr += params->dst_inc;
3710 if (err > 0)
3711 {
3712 src_ptr += params->src_inc;
3713 err += params->err_add_1;
3714 }
3715 else err += params->err_add_2;
3716 }
3717 }
3718
3719 static void stretch_row_24(const dib_info *dst_dib, const POINT *dst_start,
3720 const dib_info *src_dib, const POINT *src_start,
3721 const struct stretch_params *params, int mode,
3722 BOOL keep_dst)
3723 {
3724 BYTE *dst_ptr = get_pixel_ptr_24( dst_dib, dst_start->x, dst_start->y );
3725 BYTE *src_ptr = get_pixel_ptr_24( src_dib, src_start->x, src_start->y );
3726 int err = params->err_start;
3727 int width;
3728 struct rop_codes codes;
3729
3730 rop_codes_from_stretch_mode( mode, &codes );
3731 for (width = params->length; width; width--)
3732 {
3733 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
3734 do_rop_codes_8( dst_ptr + 1, *(src_ptr + 1), &codes );
3735 do_rop_codes_8( dst_ptr + 2, *(src_ptr + 2), &codes );
3736 dst_ptr += 3 * params->dst_inc;
3737 if (err > 0)
3738 {
3739 src_ptr += 3 * params->src_inc;
3740 err += params->err_add_1;
3741 }
3742 else err += params->err_add_2;
3743 }
3744 }
3745
3746 static void stretch_row_16(const dib_info *dst_dib, const POINT *dst_start,
3747 const dib_info *src_dib, const POINT *src_start,
3748 const struct stretch_params *params, int mode,
3749 BOOL keep_dst)
3750 {
3751 WORD *dst_ptr = get_pixel_ptr_16( dst_dib, dst_start->x, dst_start->y );
3752 WORD *src_ptr = get_pixel_ptr_16( src_dib, src_start->x, src_start->y );
3753 int err = params->err_start;
3754 int width;
3755 struct rop_codes codes;
3756
3757 rop_codes_from_stretch_mode( mode, &codes );
3758 for (width = params->length; width; width--)
3759 {
3760 do_rop_codes_16( dst_ptr, *src_ptr, &codes );
3761 dst_ptr += params->dst_inc;
3762 if (err > 0)
3763 {
3764 src_ptr += params->src_inc;
3765 err += params->err_add_1;
3766 }
3767 else err += params->err_add_2;
3768 }
3769 }
3770
3771 static void stretch_row_8(const dib_info *dst_dib, const POINT *dst_start,
3772 const dib_info *src_dib, const POINT *src_start,
3773 const struct stretch_params *params, int mode,
3774 BOOL keep_dst)
3775 {
3776 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
3777 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
3778 int err = params->err_start;
3779 int width;
3780 struct rop_codes codes;
3781
3782 rop_codes_from_stretch_mode( mode, &codes );
3783 for (width = params->length; width; width--)
3784 {
3785 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
3786 dst_ptr += params->dst_inc;
3787 if (err > 0)
3788 {
3789 src_ptr += params->src_inc;
3790 err += params->err_add_1;
3791 }
3792 else err += params->err_add_2;
3793 }
3794 }
3795
3796 static void stretch_row_4(const dib_info *dst_dib, const POINT *dst_start,
3797 const dib_info *src_dib, const POINT *src_start,
3798 const struct stretch_params *params, int mode,
3799 BOOL keep_dst)
3800 {
3801 BYTE *dst_ptr = get_pixel_ptr_4( dst_dib, dst_start->x, dst_start->y );
3802 BYTE *src_ptr = get_pixel_ptr_4( src_dib, src_start->x, src_start->y );
3803 int err = params->err_start;
3804 int width, dst_x = dst_start->x, src_x = src_start->x;
3805 struct rop_codes codes;
3806 BYTE src_val;
3807
3808 rop_codes_from_stretch_mode( mode, &codes );
3809 for (width = params->length; width; width--)
3810 {
3811 if (src_x & 1) src_val = (*src_ptr & 0x0f) | (*src_ptr << 4);
3812 else src_val = (*src_ptr & 0xf0) | (*src_ptr >> 4);
3813
3814 do_rop_codes_mask_8( dst_ptr, src_val, &codes, (dst_x & 1) ? 0x0f : 0xf0 );
3815
3816 if ((dst_x & ~1) != ((dst_x + params->dst_inc) & ~1))
3817 dst_ptr += params->dst_inc;
3818 dst_x += params->dst_inc;
3819
3820 if (err > 0)
3821 {
3822 if ((src_x & ~1) != ((src_x + params->src_inc) & ~1))
3823 src_ptr += params->src_inc;
3824 src_x += params->src_inc;
3825 err += params->err_add_1;
3826 }
3827 else err += params->err_add_2;
3828 }
3829 }
3830
3831 static void stretch_row_1(const dib_info *dst_dib, const POINT *dst_start,
3832 const dib_info *src_dib, const POINT *src_start,
3833 const struct stretch_params *params, int mode,
3834 BOOL keep_dst)
3835 {
3836 BYTE *dst_ptr = get_pixel_ptr_1( dst_dib, dst_start->x, dst_start->y );
3837 BYTE *src_ptr = get_pixel_ptr_1( src_dib, src_start->x, src_start->y );
3838 int err = params->err_start;
3839 int width, dst_x = dst_start->x, src_x = src_start->x;
3840 struct rop_codes codes;
3841 BYTE src_val;
3842
3843 rop_codes_from_stretch_mode( mode, &codes );
3844 for (width = params->length; width; width--)
3845 {
3846 src_val = *src_ptr & pixel_masks_1[src_x % 8] ? 0xff : 0;
3847 do_rop_codes_mask_8( dst_ptr, src_val, &codes, pixel_masks_1[dst_x % 8] );
3848
3849 if ((dst_x & ~7) != ((dst_x + params->dst_inc) & ~7))
3850 dst_ptr += params->dst_inc;
3851 dst_x += params->dst_inc;
3852
3853 if (err > 0)
3854 {
3855 if ((src_x & ~7) != ((src_x + params->src_inc) & ~7))
3856 src_ptr += params->src_inc;
3857 src_x += params->src_inc;
3858 err += params->err_add_1;
3859 }
3860 else err += params->err_add_2;
3861 }
3862 }
3863
3864 static void stretch_row_null(const dib_info *dst_dib, const POINT *dst_start,
3865 const dib_info *src_dib, const POINT *src_start,
3866 const struct stretch_params *params, int mode,
3867 BOOL keep_dst)
3868 {
3869 FIXME("bit count %d\n", dst_dib->bit_count);
3870 return;
3871 }
3872
3873 static void shrink_row_32(const dib_info *dst_dib, const POINT *dst_start,
3874 const dib_info *src_dib, const POINT *src_start,
3875 const struct stretch_params *params, int mode,
3876 BOOL keep_dst)
3877 {
3878 DWORD *dst_ptr = get_pixel_ptr_32( dst_dib, dst_start->x, dst_start->y );
3879 DWORD *src_ptr = get_pixel_ptr_32( src_dib, src_start->x, src_start->y );
3880 int err = params->err_start;
3881 int width;
3882 struct rop_codes codes;
3883 DWORD init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
3884 BOOL new_pix = TRUE;
3885
3886 rop_codes_from_stretch_mode( mode, &codes );
3887 for (width = params->length; width; width--)
3888 {
3889 if (new_pix && !keep_dst) *dst_ptr = init_val;
3890 do_rop_codes_32( dst_ptr, *src_ptr, &codes );
3891 new_pix = FALSE;
3892 src_ptr += params->src_inc;
3893 if (err > 0)
3894 {
3895 dst_ptr += params->dst_inc;
3896 new_pix = TRUE;
3897 err += params->err_add_1;
3898 }
3899 else err += params->err_add_2;
3900 }
3901 }
3902
3903 static void shrink_row_24(const dib_info *dst_dib, const POINT *dst_start,
3904 const dib_info *src_dib, const POINT *src_start,
3905 const struct stretch_params *params, int mode,
3906 BOOL keep_dst)
3907 {
3908 BYTE *dst_ptr = get_pixel_ptr_24( dst_dib, dst_start->x, dst_start->y );
3909 BYTE *src_ptr = get_pixel_ptr_24( src_dib, src_start->x, src_start->y );
3910 int err = params->err_start;
3911 int width;
3912 struct rop_codes codes;
3913 BYTE init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
3914 BOOL new_pix = TRUE;
3915
3916 rop_codes_from_stretch_mode( mode, &codes );
3917 for (width = params->length; width; width--)
3918 {
3919 if (new_pix && !keep_dst) memset( dst_ptr, init_val, 3 );
3920 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
3921 do_rop_codes_8( dst_ptr + 1, *(src_ptr + 1), &codes );
3922 do_rop_codes_8( dst_ptr + 2, *(src_ptr + 2), &codes );
3923 new_pix = FALSE;
3924 src_ptr += 3 * params->src_inc;
3925 if (err > 0)
3926 {
3927 dst_ptr += 3 * params->dst_inc;
3928 new_pix = TRUE;
3929 err += params->err_add_1;
3930 }
3931 else err += params->err_add_2;
3932 }
3933 }
3934
3935 static void shrink_row_16(const dib_info *dst_dib, const POINT *dst_start,
3936 const dib_info *src_dib, const POINT *src_start,
3937 const struct stretch_params *params, int mode,
3938 BOOL keep_dst)
3939 {
3940 WORD *dst_ptr = get_pixel_ptr_16( dst_dib, dst_start->x, dst_start->y );
3941 WORD *src_ptr = get_pixel_ptr_16( src_dib, src_start->x, src_start->y );
3942 int err = params->err_start;
3943 int width;
3944 struct rop_codes codes;
3945 WORD init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
3946 BOOL new_pix = TRUE;
3947
3948 rop_codes_from_stretch_mode( mode, &codes );
3949 for (width = params->length; width; width--)
3950 {
3951 if (new_pix && !keep_dst) *dst_ptr = init_val;
3952 do_rop_codes_16( dst_ptr, *src_ptr, &codes );
3953 new_pix = FALSE;
3954 src_ptr += params->src_inc;
3955 if (err > 0)
3956 {
3957 dst_ptr += params->dst_inc;
3958 new_pix = TRUE;
3959 err += params->err_add_1;
3960 }
3961 else err += params->err_add_2;
3962 }
3963 }
3964
3965 static void shrink_row_8(const dib_info *dst_dib, const POINT *dst_start,
3966 const dib_info *src_dib, const POINT *src_start,
3967 const struct stretch_params *params, int mode,
3968 BOOL keep_dst)
3969 {
3970 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
3971 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
3972 int err = params->err_start;
3973 int width;
3974 struct rop_codes codes;
3975 BYTE init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
3976 BOOL new_pix = TRUE;
3977
3978 rop_codes_from_stretch_mode( mode, &codes );
3979 for (width = params->length; width; width--)
3980 {
3981 if (new_pix && !keep_dst) *dst_ptr = init_val;
3982 do_rop_codes_8( dst_ptr, *src_ptr, &codes );
3983 new_pix = FALSE;
3984 src_ptr += params->src_inc;
3985 if (err > 0)
3986 {
3987 dst_ptr += params->dst_inc;
3988 new_pix = TRUE;
3989 err += params->err_add_1;
3990 }
3991 else err += params->err_add_2;
3992 }
3993 }
3994
3995 static void shrink_row_4(const dib_info *dst_dib, const POINT *dst_start,
3996 const dib_info *src_dib, const POINT *src_start,
3997 const struct stretch_params *params, int mode,
3998 BOOL keep_dst)
3999 {
4000 BYTE *dst_ptr = get_pixel_ptr_8( dst_dib, dst_start->x, dst_start->y );
4001 BYTE *src_ptr = get_pixel_ptr_8( src_dib, src_start->x, src_start->y );
4002 int err = params->err_start;
4003 int width, dst_x = dst_start->x, src_x = src_start->x;
4004 struct rop_codes codes;
4005 BYTE src_val, init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
4006 BOOL new_pix = TRUE;
4007
4008 rop_codes_from_stretch_mode( mode, &codes );
4009 for (width = params->length; width; width--)
4010 {
4011 if (new_pix && !keep_dst) do_rop_mask_8( dst_ptr, 0, init_val, (dst_x & 1) ? 0xf0 : 0x0f );
4012
4013 if (src_x & 1) src_val = (*src_ptr & 0x0f) | (*src_ptr << 4);
4014 else src_val = (*src_ptr & 0xf0) | (*src_ptr >> 4);
4015
4016 do_rop_codes_mask_8( dst_ptr, src_val, &codes, (dst_x & 1) ? 0xf0 : 0x0f );
4017 new_pix = FALSE;
4018
4019 if ((src_x & ~1) != ((src_x + params->src_inc) & ~1))
4020 src_ptr += params->src_inc;
4021 src_x += params->src_inc;
4022
4023 if (err > 0)
4024 {
4025 if ((dst_x & ~1) != ((dst_x + params->dst_inc) & ~1))
4026 dst_ptr += params->dst_inc;
4027 dst_x += params->dst_inc;
4028 new_pix = TRUE;
4029 err += params->err_add_1;
4030 }
4031 else err += params->err_add_2;
4032 }
4033 }
4034
4035 static void shrink_row_1(const dib_info *dst_dib, const POINT *dst_start,
4036 const dib_info *src_dib, const POINT *src_start,
4037 const struct stretch_params *params, int mode,
4038 BOOL keep_dst)
4039 {
4040 BYTE *dst_ptr = get_pixel_ptr_1( dst_dib, dst_start->x, dst_start->y );
4041 BYTE *src_ptr = get_pixel_ptr_1( src_dib, src_start->x, src_start->y );
4042 int err = params->err_start;
4043 int width, dst_x = dst_start->x, src_x = src_start->x;
4044 struct rop_codes codes;
4045 BYTE src_val, init_val = (mode == STRETCH_ANDSCANS) ? ~0u : 0u;
4046 BOOL new_pix = TRUE;
4047
4048 rop_codes_from_stretch_mode( mode, &codes );
4049 for (width = params->length; width; width--)
4050 {
4051 if (new_pix && !keep_dst) do_rop_mask_8( dst_ptr, 0, init_val, pixel_masks_1[dst_x % 8] );
4052 src_val = *src_ptr & pixel_masks_1[src_x % 8] ? 0xff : 0;
4053 do_rop_codes_mask_8( dst_ptr, src_val, &codes, pixel_masks_1[dst_x % 8] );
4054 new_pix = FALSE;
4055
4056 if ((src_x & ~7) != ((src_x + params->src_inc) & ~7))
4057 src_ptr += params->src_inc;
4058 src_x += params->src_inc;
4059
4060 if (err > 0)
4061 {
4062 if ((dst_x & ~7) != ((dst_x + params->dst_inc) & ~7))
4063 dst_ptr += params->dst_inc;
4064 dst_x += params->dst_inc;
4065 new_pix = TRUE;
4066 err += params->err_add_1;
4067 }
4068 else err += params->err_add_2;
4069 }
4070 }
4071
4072 static void shrink_row_null(const dib_info *dst_dib, const POINT *dst_start,
4073 const dib_info *src_dib, const POINT *src_start,
4074 const struct stretch_params *params, int mode,
4075 BOOL keep_dst)
4076 {
4077 FIXME("bit count %d\n", dst_dib->bit_count);
4078 return;
4079 }
4080
4081 const primitive_funcs funcs_8888 =
4082 {
4083 solid_rects_32,
4084 pattern_rects_32,
4085 copy_rect_32,
4086 colorref_to_pixel_888,
4087 convert_to_8888,
4088 create_rop_masks_32,
4089 stretch_row_32,
4090 shrink_row_32
4091 };
4092
4093 const primitive_funcs funcs_32 =
4094 {
4095 solid_rects_32,
4096 pattern_rects_32,
4097 copy_rect_32,
4098 colorref_to_pixel_masks,
4099 convert_to_32,
4100 create_rop_masks_32,
4101 stretch_row_32,
4102 shrink_row_32
4103 };
4104
4105 const primitive_funcs funcs_24 =
4106 {
4107 solid_rects_24,
4108 pattern_rects_24,
4109 copy_rect_24,
4110 colorref_to_pixel_888,
4111 convert_to_24,
4112 create_rop_masks_24,
4113 stretch_row_24,
4114 shrink_row_24
4115 };
4116
4117 const primitive_funcs funcs_555 =
4118 {
4119 solid_rects_16,
4120 pattern_rects_16,
4121 copy_rect_16,
4122 colorref_to_pixel_555,
4123 convert_to_555,
4124 create_rop_masks_16,
4125 stretch_row_16,
4126 shrink_row_16
4127 };
4128
4129 const primitive_funcs funcs_16 =
4130 {
4131 solid_rects_16,
4132 pattern_rects_16,
4133 copy_rect_16,
4134 colorref_to_pixel_masks,
4135 convert_to_16,
4136 create_rop_masks_16,
4137 stretch_row_16,
4138 shrink_row_16
4139 };
4140
4141 const primitive_funcs funcs_8 =
4142 {
4143 solid_rects_8,
4144 pattern_rects_8,
4145 copy_rect_8,
4146 colorref_to_pixel_colortable,
4147 convert_to_8,
4148 create_rop_masks_8,
4149 stretch_row_8,
4150 shrink_row_8
4151 };
4152
4153 const primitive_funcs funcs_4 =
4154 {
4155 solid_rects_4,
4156 pattern_rects_4,
4157 copy_rect_4,
4158 colorref_to_pixel_colortable,
4159 convert_to_4,
4160 create_rop_masks_4,
4161 stretch_row_4,
4162 shrink_row_4
4163 };
4164
4165 const primitive_funcs funcs_1 =
4166 {
4167 solid_rects_1,
4168 pattern_rects_1,
4169 copy_rect_1,
4170 colorref_to_pixel_colortable,
4171 convert_to_1,
4172 create_rop_masks_1,
4173 stretch_row_1,
4174 shrink_row_1
4175 };
4176
4177 const primitive_funcs funcs_null =
4178 {
4179 solid_rects_null,
4180 pattern_rects_null,
4181 copy_rect_null,
4182 colorref_to_pixel_null,
4183 convert_to_null,
4184 create_rop_masks_null,
4185 stretch_row_null,
4186 shrink_row_null
4187 };
Maarten's multimedia branch