src/video/SDL_blit_auto.c

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