src/video/SDL_blit_auto.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 02 Apr 2020 12:27:29 -0700
changeset 13686 42ef99a1bde2
parent 13440 ac297b67f6d9
permissions -rw-r--r--
Fixed setting the "playandrecord" audio hint on Apple TV

The Apple TV doesn't have record capability by default, so activating the audio session with AVAudioSessionCategoryPlayAndRecord fails.
     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