git.oblomov.eu Git - wine/blob - dlls/gdi32/dibdrv/primitives.c

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