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