src/video/SDL_blit_N.c
author Sam Lantinga <slouken@libsdl.org>
Wed, 15 Aug 2007 08:21:10 +0000
changeset 2247 93994f65c74c
parent 1985 8055185ae4ed
child 2257 340942cfda48
permissions -rw-r--r--
Removed hermes since it's LGPL and not compatible with a commercial license.

Prepping for using MMX and SSE intrinsics instead of inline assembly.
.. except for memcpy equivalents which only get faster if they can
exploit the parallelism of loading into multiple SIMD registers. :)
slouken@0
     1
/*
slouken@0
     2
    SDL - Simple DirectMedia Layer
slouken@1312
     3
    Copyright (C) 1997-2006 Sam Lantinga
slouken@0
     4
slouken@0
     5
    This library is free software; you can redistribute it and/or
slouken@1312
     6
    modify it under the terms of the GNU Lesser General Public
slouken@0
     7
    License as published by the Free Software Foundation; either
slouken@1312
     8
    version 2.1 of the License, or (at your option) any later version.
slouken@0
     9
slouken@0
    10
    This library is distributed in the hope that it will be useful,
slouken@0
    11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
slouken@0
    12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
slouken@1312
    13
    Lesser General Public License for more details.
slouken@0
    14
slouken@1312
    15
    You should have received a copy of the GNU Lesser General Public
slouken@1312
    16
    License along with this library; if not, write to the Free Software
slouken@1312
    17
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
slouken@0
    18
slouken@0
    19
    Sam Lantinga
slouken@252
    20
    slouken@libsdl.org
slouken@0
    21
*/
slouken@1402
    22
#include "SDL_config.h"
slouken@0
    23
slouken@0
    24
#include "SDL_video.h"
slouken@1358
    25
#include "SDL_endian.h"
slouken@1358
    26
#include "SDL_cpuinfo.h"
slouken@0
    27
#include "SDL_blit.h"
slouken@0
    28
slouken@0
    29
/* Functions to blit from N-bit surfaces to other surfaces */
slouken@0
    30
slouken@1361
    31
#if SDL_ALTIVEC_BLITTERS
slouken@1795
    32
#if __MWERKS__
slouken@1795
    33
#pragma altivec_model on
slouken@1795
    34
#endif
icculus@1175
    35
#ifdef HAVE_ALTIVEC_H
icculus@1162
    36
#include <altivec.h>
icculus@1175
    37
#endif
slouken@1338
    38
#define assert(X)
slouken@1402
    39
#ifdef __MACOSX__
icculus@1047
    40
#include <sys/sysctl.h>
slouken@1895
    41
static size_t
slouken@1895
    42
GetL3CacheSize(void)
icculus@1047
    43
{
icculus@1047
    44
    const char key[] = "hw.l3cachesize";
icculus@1047
    45
    u_int64_t result = 0;
slouken@1895
    46
    size_t typeSize = sizeof(result);
icculus@1047
    47
icculus@1047
    48
slouken@1895
    49
    int err = sysctlbyname(key, &result, &typeSize, NULL, 0);
slouken@1895
    50
    if (0 != err)
slouken@1895
    51
        return 0;
icculus@1047
    52
icculus@1047
    53
    return result;
icculus@1047
    54
}
icculus@1047
    55
#else
slouken@1895
    56
static size_t
slouken@1895
    57
GetL3CacheSize(void)
icculus@1047
    58
{
icculus@1047
    59
    /* XXX: Just guess G4 */
icculus@1047
    60
    return 2097152;
icculus@1047
    61
}
slouken@1402
    62
#endif /* __MACOSX__ */
icculus@1047
    63
slouken@1402
    64
#if (defined(__MACOSX__) && (__GNUC__ < 4))
slouken@1895
    65
#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
icculus@1162
    66
        (vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )
slouken@1895
    67
#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
icculus@1162
    68
        (vector unsigned short) ( a,b,c,d,e,f,g,h )
icculus@1162
    69
#else
slouken@1895
    70
#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
icculus@1162
    71
        (vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p }
slouken@1895
    72
#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
icculus@1162
    73
        (vector unsigned short) { a,b,c,d,e,f,g,h }
icculus@1162
    74
#endif
icculus@1162
    75
icculus@1047
    76
#define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F)
icculus@1047
    77
#define VSWIZZLE32(a,b,c,d) (vector unsigned char) \
icculus@1047
    78
                               ( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \
icculus@1047
    79
                                 0x04+a, 0x04+b, 0x04+c, 0x04+d, \
icculus@1047
    80
                                 0x08+a, 0x08+b, 0x08+c, 0x08+d, \
icculus@1047
    81
                                 0x0C+a, 0x0C+b, 0x0C+c, 0x0C+d )
icculus@1047
    82
icculus@1047
    83
#define MAKE8888(dstfmt, r, g, b, a)  \
icculus@1047
    84
    ( ((r<<dstfmt->Rshift)&dstfmt->Rmask) | \
icculus@1047
    85
      ((g<<dstfmt->Gshift)&dstfmt->Gmask) | \
icculus@1047
    86
      ((b<<dstfmt->Bshift)&dstfmt->Bmask) | \
icculus@1047
    87
      ((a<<dstfmt->Ashift)&dstfmt->Amask) )
icculus@1047
    88
icculus@1047
    89
/*
icculus@1047
    90
 * Data Stream Touch...Altivec cache prefetching.
icculus@1047
    91
 *
icculus@1047
    92
 *  Don't use this on a G5...however, the speed boost is very significant
icculus@1047
    93
 *   on a G4.
icculus@1047
    94
 */
icculus@1047
    95
#define DST_CHAN_SRC 1
icculus@1047
    96
#define DST_CHAN_DEST 2
icculus@1047
    97
icculus@1047
    98
/* macro to set DST control word value... */
icculus@1047
    99
#define DST_CTRL(size, count, stride) \
icculus@1047
   100
    (((size) << 24) | ((count) << 16) | (stride))
icculus@1047
   101
icculus@1047
   102
#define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \
icculus@1047
   103
    ? vec_lvsl(0, src) \
icculus@1047
   104
    : vec_add(vec_lvsl(8, src), vec_splat_u8(8)))
icculus@1047
   105
icculus@1047
   106
/* Calculate the permute vector used for 32->32 swizzling */
slouken@1895
   107
static vector unsigned char
slouken@1895
   108
calc_swizzle32(const SDL_PixelFormat * srcfmt, const SDL_PixelFormat * dstfmt)
icculus@1047
   109
{
icculus@1047
   110
    /*
slouken@1895
   111
     * We have to assume that the bits that aren't used by other
icculus@1047
   112
     *  colors is alpha, and it's one complete byte, since some formats
icculus@1047
   113
     *  leave alpha with a zero mask, but we should still swizzle the bits.
icculus@1047
   114
     */
icculus@1047
   115
    /* ARGB */
icculus@1047
   116
    const static struct SDL_PixelFormat default_pixel_format = {
icculus@1047
   117
        NULL, 0, 0,
icculus@1047
   118
        0, 0, 0, 0,
icculus@1047
   119
        16, 8, 0, 24,
icculus@1047
   120
        0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
slouken@1895
   121
        0, 0
slouken@1895
   122
    };
icculus@1047
   123
    if (!srcfmt) {
icculus@1047
   124
        srcfmt = &default_pixel_format;
icculus@1047
   125
    }
icculus@1047
   126
    if (!dstfmt) {
icculus@1047
   127
        dstfmt = &default_pixel_format;
icculus@1047
   128
    }
slouken@1895
   129
    const vector unsigned char plus = VECUINT8_LITERAL(0x00, 0x00, 0x00, 0x00,
slouken@1895
   130
                                                       0x04, 0x04, 0x04, 0x04,
slouken@1895
   131
                                                       0x08, 0x08, 0x08, 0x08,
slouken@1895
   132
                                                       0x0C, 0x0C, 0x0C,
slouken@1895
   133
                                                       0x0C);
icculus@1047
   134
    vector unsigned char vswiz;
icculus@1047
   135
    vector unsigned int srcvec;
icculus@1047
   136
#define RESHIFT(X) (3 - ((X) >> 3))
icculus@1047
   137
    Uint32 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift);
icculus@1047
   138
    Uint32 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift);
icculus@1047
   139
    Uint32 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift);
icculus@1047
   140
    Uint32 amask;
icculus@1047
   141
    /* Use zero for alpha if either surface doesn't have alpha */
icculus@1047
   142
    if (dstfmt->Amask) {
slouken@1895
   143
        amask =
slouken@1895
   144
            ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->
slouken@1895
   145
                                                                   Ashift);
slouken@1895
   146
    } else {
slouken@1895
   147
        amask =
slouken@1895
   148
            0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^
slouken@1895
   149
                          0xFFFFFFFF);
slouken@1895
   150
    }
slouken@1895
   151
#undef RESHIFT
slouken@1895
   152
    ((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask);
slouken@1895
   153
    vswiz = vec_add(plus, (vector unsigned char) vec_splat(srcvec, 0));
slouken@1895
   154
    return (vswiz);
icculus@1047
   155
}
icculus@1047
   156
slouken@1895
   157
static void Blit_RGB888_RGB565(SDL_BlitInfo * info);
slouken@1895
   158
static void
slouken@1895
   159
Blit_RGB888_RGB565Altivec(SDL_BlitInfo * info)
slouken@1895
   160
{
icculus@1047
   161
    int height = info->d_height;
icculus@1047
   162
    Uint8 *src = (Uint8 *) info->s_pixels;
icculus@1047
   163
    int srcskip = info->s_skip;
icculus@1047
   164
    Uint8 *dst = (Uint8 *) info->d_pixels;
icculus@1047
   165
    int dstskip = info->d_skip;
icculus@1047
   166
    SDL_PixelFormat *srcfmt = info->src;
icculus@1047
   167
    vector unsigned char valpha = vec_splat_u8(0);
icculus@1047
   168
    vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);
slouken@1895
   169
    vector unsigned char vgmerge = VECUINT8_LITERAL(0x00, 0x02, 0x00, 0x06,
slouken@1895
   170
                                                    0x00, 0x0a, 0x00, 0x0e,
slouken@1895
   171
                                                    0x00, 0x12, 0x00, 0x16,
slouken@1895
   172
                                                    0x00, 0x1a, 0x00, 0x1e);
icculus@1047
   173
    vector unsigned short v1 = vec_splat_u16(1);
icculus@1047
   174
    vector unsigned short v3 = vec_splat_u16(3);
slouken@1895
   175
    vector unsigned short v3f =
slouken@1895
   176
        VECUINT16_LITERAL(0x003f, 0x003f, 0x003f, 0x003f,
slouken@1895
   177
                          0x003f, 0x003f, 0x003f, 0x003f);
slouken@1895
   178
    vector unsigned short vfc =
slouken@1895
   179
        VECUINT16_LITERAL(0x00fc, 0x00fc, 0x00fc, 0x00fc,
slouken@1895
   180
                          0x00fc, 0x00fc, 0x00fc, 0x00fc);
slouken@1895
   181
    vector unsigned short vf800 = (vector unsigned short) vec_splat_u8(-7);
icculus@1047
   182
    vf800 = vec_sl(vf800, vec_splat_u16(8));
icculus@1047
   183
icculus@1047
   184
    while (height--) {
icculus@1047
   185
        vector unsigned char valigner;
icculus@1047
   186
        vector unsigned char voverflow;
icculus@1047
   187
        vector unsigned char vsrc;
icculus@1047
   188
icculus@1047
   189
        int width = info->d_width;
icculus@1047
   190
        int extrawidth;
icculus@1047
   191
icculus@1047
   192
        /* do scalar until we can align... */
icculus@1047
   193
#define ONE_PIXEL_BLEND(condition, widthvar) \
icculus@1047
   194
        while (condition) { \
icculus@1162
   195
            Uint32 Pixel; \
icculus@1047
   196
            unsigned sR, sG, sB, sA; \
icculus@1162
   197
            DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \
icculus@1047
   198
                          sR, sG, sB, sA); \
icculus@1047
   199
            *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \
icculus@1047
   200
                                ((sG << 3) & 0x000007E0) | \
icculus@1047
   201
                                ((sB >> 3) & 0x0000001F)); \
icculus@1047
   202
            dst += 2; \
icculus@1047
   203
            src += 4; \
icculus@1047
   204
            widthvar--; \
icculus@1047
   205
        }
icculus@1047
   206
icculus@1047
   207
        ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
icculus@1047
   208
icculus@1047
   209
        /* After all that work, here's the vector part! */
slouken@1895
   210
        extrawidth = (width % 8);       /* trailing unaligned stores */
icculus@1047
   211
        width -= extrawidth;
icculus@1047
   212
        vsrc = vec_ld(0, src);
icculus@1047
   213
        valigner = VEC_ALIGNER(src);
icculus@1047
   214
icculus@1047
   215
        while (width) {
icculus@1047
   216
            vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;
icculus@1047
   217
            vector unsigned int vsrc1, vsrc2;
icculus@1047
   218
            vector unsigned char vdst;
icculus@1047
   219
icculus@1047
   220
            voverflow = vec_ld(15, src);
icculus@1047
   221
            vsrc = vec_perm(vsrc, voverflow, valigner);
slouken@1895
   222
            vsrc1 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);
icculus@1047
   223
            src += 16;
icculus@1047
   224
            vsrc = voverflow;
icculus@1047
   225
            voverflow = vec_ld(15, src);
icculus@1047
   226
            vsrc = vec_perm(vsrc, voverflow, valigner);
slouken@1895
   227
            vsrc2 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);
icculus@1047
   228
            /* 1555 */
slouken@1895
   229
            vpixel = (vector unsigned short) vec_packpx(vsrc1, vsrc2);
slouken@1895
   230
            vgpixel = (vector unsigned short) vec_perm(vsrc1, vsrc2, vgmerge);
icculus@1047
   231
            vgpixel = vec_and(vgpixel, vfc);
icculus@1047
   232
            vgpixel = vec_sl(vgpixel, v3);
icculus@1047
   233
            vrpixel = vec_sl(vpixel, v1);
icculus@1047
   234
            vrpixel = vec_and(vrpixel, vf800);
icculus@1047
   235
            vbpixel = vec_and(vpixel, v3f);
slouken@1895
   236
            vdst =
slouken@1895
   237
                vec_or((vector unsigned char) vrpixel,
slouken@1895
   238
                       (vector unsigned char) vgpixel);
icculus@1047
   239
            /* 565 */
slouken@1895
   240
            vdst = vec_or(vdst, (vector unsigned char) vbpixel);
icculus@1047
   241
            vec_st(vdst, 0, dst);
icculus@1047
   242
icculus@1047
   243
            width -= 8;
icculus@1047
   244
            src += 16;
icculus@1047
   245
            dst += 16;
icculus@1047
   246
            vsrc = voverflow;
icculus@1047
   247
        }
icculus@1047
   248
icculus@1047
   249
        assert(width == 0);
icculus@1047
   250
icculus@1047
   251
        /* do scalar until we can align... */
icculus@1047
   252
        ONE_PIXEL_BLEND((extrawidth), extrawidth);
icculus@1047
   253
#undef ONE_PIXEL_BLEND
icculus@1047
   254
slouken@1895
   255
        src += srcskip;         /* move to next row, accounting for pitch. */
icculus@1047
   256
        dst += dstskip;
icculus@1047
   257
    }
icculus@1047
   258
icculus@1047
   259
icculus@1047
   260
}
icculus@1047
   261
slouken@1895
   262
static void
slouken@1895
   263
Blit_RGB565_32Altivec(SDL_BlitInfo * info)
slouken@1895
   264
{
icculus@1047
   265
    int height = info->d_height;
icculus@1047
   266
    Uint8 *src = (Uint8 *) info->s_pixels;
icculus@1047
   267
    int srcskip = info->s_skip;
icculus@1047
   268
    Uint8 *dst = (Uint8 *) info->d_pixels;
icculus@1047
   269
    int dstskip = info->d_skip;
icculus@1047
   270
    SDL_PixelFormat *srcfmt = info->src;
icculus@1047
   271
    SDL_PixelFormat *dstfmt = info->dst;
icculus@1047
   272
    unsigned alpha;
icculus@1047
   273
    vector unsigned char valpha;
icculus@1047
   274
    vector unsigned char vpermute;
icculus@1047
   275
    vector unsigned short vf800;
icculus@1047
   276
    vector unsigned int v8 = vec_splat_u32(8);
icculus@1047
   277
    vector unsigned int v16 = vec_add(v8, v8);
icculus@1047
   278
    vector unsigned short v2 = vec_splat_u16(2);
icculus@1047
   279
    vector unsigned short v3 = vec_splat_u16(3);
icculus@1047
   280
    /* 
slouken@1895
   281
       0x10 - 0x1f is the alpha
slouken@1895
   282
       0x00 - 0x0e evens are the red
slouken@1895
   283
       0x01 - 0x0f odds are zero
slouken@1895
   284
     */
slouken@1895
   285
    vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,
slouken@1895
   286
                                                       0x10, 0x02, 0x01, 0x01,
slouken@1895
   287
                                                       0x10, 0x04, 0x01, 0x01,
slouken@1895
   288
                                                       0x10, 0x06, 0x01,
slouken@1895
   289
                                                       0x01);
slouken@1895
   290
    vector unsigned char vredalpha2 =
slouken@1895
   291
        (vector unsigned
slouken@1895
   292
         char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))
slouken@1895
   293
        );
icculus@1047
   294
    /*
slouken@1895
   295
       0x00 - 0x0f is ARxx ARxx ARxx ARxx
slouken@1895
   296
       0x11 - 0x0f odds are blue
slouken@1895
   297
     */
slouken@1895
   298
    vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,
slouken@1895
   299
                                                   0x04, 0x05, 0x06, 0x13,
slouken@1895
   300
                                                   0x08, 0x09, 0x0a, 0x15,
slouken@1895
   301
                                                   0x0c, 0x0d, 0x0e, 0x17);
slouken@1895
   302
    vector unsigned char vblue2 =
slouken@1895
   303
        (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)
slouken@1895
   304
        );
icculus@1047
   305
    /*
slouken@1895
   306
       0x00 - 0x0f is ARxB ARxB ARxB ARxB
slouken@1895
   307
       0x10 - 0x0e evens are green
slouken@1895
   308
     */
slouken@1895
   309
    vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,
slouken@1895
   310
                                                    0x04, 0x05, 0x12, 0x07,
slouken@1895
   311
                                                    0x08, 0x09, 0x14, 0x0b,
slouken@1895
   312
                                                    0x0c, 0x0d, 0x16, 0x0f);
slouken@1895
   313
    vector unsigned char vgreen2 =
slouken@1895
   314
        (vector unsigned
slouken@1895
   315
         char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))
slouken@1895
   316
        );
slouken@1895
   317
icculus@1047
   318
icculus@1047
   319
    assert(srcfmt->BytesPerPixel == 2);
icculus@1047
   320
    assert(dstfmt->BytesPerPixel == 4);
icculus@1047
   321
slouken@1895
   322
    vf800 = (vector unsigned short) vec_splat_u8(-7);
icculus@1047
   323
    vf800 = vec_sl(vf800, vec_splat_u16(8));
icculus@1047
   324
icculus@1047
   325
    if (dstfmt->Amask && srcfmt->alpha) {
slouken@1895
   326
        ((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha;
icculus@1047
   327
        valpha = vec_splat(valpha, 0);
icculus@1047
   328
    } else {
icculus@1047
   329
        alpha = 0;
icculus@1047
   330
        valpha = vec_splat_u8(0);
icculus@1047
   331
    }
icculus@1047
   332
icculus@1047
   333
    vpermute = calc_swizzle32(NULL, dstfmt);
icculus@1047
   334
    while (height--) {
icculus@1047
   335
        vector unsigned char valigner;
icculus@1047
   336
        vector unsigned char voverflow;
icculus@1047
   337
        vector unsigned char vsrc;
icculus@1047
   338
icculus@1047
   339
        int width = info->d_width;
icculus@1047
   340
        int extrawidth;
icculus@1047
   341
icculus@1047
   342
        /* do scalar until we can align... */
icculus@1047
   343
#define ONE_PIXEL_BLEND(condition, widthvar) \
icculus@1047
   344
        while (condition) { \
icculus@1047
   345
            unsigned sR, sG, sB; \
icculus@1162
   346
            unsigned short Pixel = *((unsigned short *)src); \
icculus@1162
   347
            sR = (Pixel >> 8) & 0xf8; \
icculus@1162
   348
            sG = (Pixel >> 3) & 0xfc; \
icculus@1162
   349
            sB = (Pixel << 3) & 0xf8; \
icculus@1047
   350
            ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
icculus@1047
   351
            src += 2; \
icculus@1047
   352
            dst += 4; \
icculus@1047
   353
            widthvar--; \
icculus@1047
   354
        }
icculus@1047
   355
        ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
icculus@1047
   356
icculus@1047
   357
        /* After all that work, here's the vector part! */
slouken@1895
   358
        extrawidth = (width % 8);       /* trailing unaligned stores */
icculus@1047
   359
        width -= extrawidth;
icculus@1047
   360
        vsrc = vec_ld(0, src);
icculus@1047
   361
        valigner = VEC_ALIGNER(src);
icculus@1047
   362
icculus@1047
   363
        while (width) {
icculus@1047
   364
            vector unsigned short vR, vG, vB;
icculus@1047
   365
            vector unsigned char vdst1, vdst2;
icculus@1047
   366
icculus@1047
   367
            voverflow = vec_ld(15, src);
icculus@1047
   368
            vsrc = vec_perm(vsrc, voverflow, valigner);
icculus@1047
   369
slouken@1895
   370
            vR = vec_and((vector unsigned short) vsrc, vf800);
slouken@1895
   371
            vB = vec_sl((vector unsigned short) vsrc, v3);
icculus@1047
   372
            vG = vec_sl(vB, v2);
icculus@1047
   373
slouken@1895
   374
            vdst1 =
slouken@1895
   375
                (vector unsigned char) vec_perm((vector unsigned char) vR,
slouken@1895
   376
                                                valpha, vredalpha1);
slouken@1895
   377
            vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);
slouken@1895
   378
            vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);
icculus@1047
   379
            vdst1 = vec_perm(vdst1, valpha, vpermute);
icculus@1047
   380
            vec_st(vdst1, 0, dst);
icculus@1047
   381
slouken@1895
   382
            vdst2 =
slouken@1895
   383
                (vector unsigned char) vec_perm((vector unsigned char) vR,
slouken@1895
   384
                                                valpha, vredalpha2);
slouken@1895
   385
            vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);
slouken@1895
   386
            vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);
icculus@1047
   387
            vdst2 = vec_perm(vdst2, valpha, vpermute);
icculus@1047
   388
            vec_st(vdst2, 16, dst);
slouken@1895
   389
icculus@1047
   390
            width -= 8;
icculus@1047
   391
            dst += 32;
icculus@1047
   392
            src += 16;
icculus@1047
   393
            vsrc = voverflow;
icculus@1047
   394
        }
icculus@1047
   395
icculus@1047
   396
        assert(width == 0);
icculus@1047
   397
icculus@1047
   398
icculus@1047
   399
        /* do scalar until we can align... */
icculus@1047
   400
        ONE_PIXEL_BLEND((extrawidth), extrawidth);
icculus@1047
   401
#undef ONE_PIXEL_BLEND
icculus@1047
   402
slouken@1895
   403
        src += srcskip;         /* move to next row, accounting for pitch. */
icculus@1047
   404
        dst += dstskip;
icculus@1047
   405
    }
icculus@1047
   406
icculus@1047
   407
}
icculus@1047
   408
icculus@1139
   409
slouken@1895
   410
static void
slouken@1895
   411
Blit_RGB555_32Altivec(SDL_BlitInfo * info)
slouken@1895
   412
{
icculus@1139
   413
    int height = info->d_height;
icculus@1139
   414
    Uint8 *src = (Uint8 *) info->s_pixels;
icculus@1139
   415
    int srcskip = info->s_skip;
icculus@1139
   416
    Uint8 *dst = (Uint8 *) info->d_pixels;
icculus@1139
   417
    int dstskip = info->d_skip;
icculus@1139
   418
    SDL_PixelFormat *srcfmt = info->src;
icculus@1139
   419
    SDL_PixelFormat *dstfmt = info->dst;
icculus@1139
   420
    unsigned alpha;
icculus@1139
   421
    vector unsigned char valpha;
icculus@1139
   422
    vector unsigned char vpermute;
icculus@1139
   423
    vector unsigned short vf800;
icculus@1139
   424
    vector unsigned int v8 = vec_splat_u32(8);
icculus@1139
   425
    vector unsigned int v16 = vec_add(v8, v8);
icculus@1139
   426
    vector unsigned short v1 = vec_splat_u16(1);
icculus@1139
   427
    vector unsigned short v3 = vec_splat_u16(3);
icculus@1139
   428
    /* 
slouken@1895
   429
       0x10 - 0x1f is the alpha
slouken@1895
   430
       0x00 - 0x0e evens are the red
slouken@1895
   431
       0x01 - 0x0f odds are zero
slouken@1895
   432
     */
slouken@1895
   433
    vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,
slouken@1895
   434
                                                       0x10, 0x02, 0x01, 0x01,
slouken@1895
   435
                                                       0x10, 0x04, 0x01, 0x01,
slouken@1895
   436
                                                       0x10, 0x06, 0x01,
slouken@1895
   437
                                                       0x01);
slouken@1895
   438
    vector unsigned char vredalpha2 =
slouken@1895
   439
        (vector unsigned
slouken@1895
   440
         char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))
slouken@1895
   441
        );
icculus@1139
   442
    /*
slouken@1895
   443
       0x00 - 0x0f is ARxx ARxx ARxx ARxx
slouken@1895
   444
       0x11 - 0x0f odds are blue
slouken@1895
   445
     */
slouken@1895
   446
    vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,
slouken@1895
   447
                                                   0x04, 0x05, 0x06, 0x13,
slouken@1895
   448
                                                   0x08, 0x09, 0x0a, 0x15,
slouken@1895
   449
                                                   0x0c, 0x0d, 0x0e, 0x17);
slouken@1895
   450
    vector unsigned char vblue2 =
slouken@1895
   451
        (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)
slouken@1895
   452
        );
icculus@1139
   453
    /*
slouken@1895
   454
       0x00 - 0x0f is ARxB ARxB ARxB ARxB
slouken@1895
   455
       0x10 - 0x0e evens are green
slouken@1895
   456
     */
slouken@1895
   457
    vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,
slouken@1895
   458
                                                    0x04, 0x05, 0x12, 0x07,
slouken@1895
   459
                                                    0x08, 0x09, 0x14, 0x0b,
slouken@1895
   460
                                                    0x0c, 0x0d, 0x16, 0x0f);
slouken@1895
   461
    vector unsigned char vgreen2 =
slouken@1895
   462
        (vector unsigned
slouken@1895
   463
         char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))
slouken@1895
   464
        );
slouken@1895
   465
icculus@1139
   466
icculus@1139
   467
    assert(srcfmt->BytesPerPixel == 2);
icculus@1139
   468
    assert(dstfmt->BytesPerPixel == 4);
icculus@1139
   469
slouken@1895
   470
    vf800 = (vector unsigned short) vec_splat_u8(-7);
icculus@1139
   471
    vf800 = vec_sl(vf800, vec_splat_u16(8));
icculus@1139
   472
icculus@1139
   473
    if (dstfmt->Amask && srcfmt->alpha) {
slouken@1895
   474
        ((unsigned char *) &valpha)[0] = alpha = srcfmt->alpha;
icculus@1139
   475
        valpha = vec_splat(valpha, 0);
icculus@1139
   476
    } else {
icculus@1139
   477
        alpha = 0;
icculus@1139
   478
        valpha = vec_splat_u8(0);
icculus@1139
   479
    }
icculus@1139
   480
icculus@1139
   481
    vpermute = calc_swizzle32(NULL, dstfmt);
icculus@1139
   482
    while (height--) {
icculus@1139
   483
        vector unsigned char valigner;
icculus@1139
   484
        vector unsigned char voverflow;
icculus@1139
   485
        vector unsigned char vsrc;
icculus@1139
   486
icculus@1139
   487
        int width = info->d_width;
icculus@1139
   488
        int extrawidth;
icculus@1139
   489
icculus@1139
   490
        /* do scalar until we can align... */
icculus@1139
   491
#define ONE_PIXEL_BLEND(condition, widthvar) \
icculus@1139
   492
        while (condition) { \
icculus@1139
   493
            unsigned sR, sG, sB; \
icculus@1162
   494
            unsigned short Pixel = *((unsigned short *)src); \
icculus@1162
   495
            sR = (Pixel >> 7) & 0xf8; \
icculus@1162
   496
            sG = (Pixel >> 2) & 0xf8; \
icculus@1162
   497
            sB = (Pixel << 3) & 0xf8; \
icculus@1139
   498
            ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
icculus@1139
   499
            src += 2; \
icculus@1139
   500
            dst += 4; \
icculus@1139
   501
            widthvar--; \
icculus@1139
   502
        }
icculus@1139
   503
        ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
icculus@1139
   504
icculus@1139
   505
        /* After all that work, here's the vector part! */
slouken@1895
   506
        extrawidth = (width % 8);       /* trailing unaligned stores */
icculus@1139
   507
        width -= extrawidth;
icculus@1139
   508
        vsrc = vec_ld(0, src);
icculus@1139
   509
        valigner = VEC_ALIGNER(src);
icculus@1139
   510
icculus@1139
   511
        while (width) {
icculus@1139
   512
            vector unsigned short vR, vG, vB;
icculus@1139
   513
            vector unsigned char vdst1, vdst2;
icculus@1139
   514
icculus@1139
   515
            voverflow = vec_ld(15, src);
icculus@1139
   516
            vsrc = vec_perm(vsrc, voverflow, valigner);
icculus@1139
   517
slouken@1895
   518
            vR = vec_and(vec_sl((vector unsigned short) vsrc, v1), vf800);
slouken@1895
   519
            vB = vec_sl((vector unsigned short) vsrc, v3);
icculus@1139
   520
            vG = vec_sl(vB, v3);
icculus@1139
   521
slouken@1895
   522
            vdst1 =
slouken@1895
   523
                (vector unsigned char) vec_perm((vector unsigned char) vR,
slouken@1895
   524
                                                valpha, vredalpha1);
slouken@1895
   525
            vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);
slouken@1895
   526
            vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);
icculus@1139
   527
            vdst1 = vec_perm(vdst1, valpha, vpermute);
icculus@1139
   528
            vec_st(vdst1, 0, dst);
icculus@1139
   529
slouken@1895
   530
            vdst2 =
slouken@1895
   531
                (vector unsigned char) vec_perm((vector unsigned char) vR,
slouken@1895
   532
                                                valpha, vredalpha2);
slouken@1895
   533
            vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);
slouken@1895
   534
            vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);
icculus@1139
   535
            vdst2 = vec_perm(vdst2, valpha, vpermute);
icculus@1139
   536
            vec_st(vdst2, 16, dst);
slouken@1895
   537
icculus@1139
   538
            width -= 8;
icculus@1139
   539
            dst += 32;
icculus@1139
   540
            src += 16;
icculus@1139
   541
            vsrc = voverflow;
icculus@1139
   542
        }
icculus@1139
   543
icculus@1139
   544
        assert(width == 0);
icculus@1139
   545
icculus@1139
   546
icculus@1139
   547
        /* do scalar until we can align... */
icculus@1139
   548
        ONE_PIXEL_BLEND((extrawidth), extrawidth);
icculus@1139
   549
#undef ONE_PIXEL_BLEND
icculus@1139
   550
slouken@1895
   551
        src += srcskip;         /* move to next row, accounting for pitch. */
icculus@1139
   552
        dst += dstskip;
icculus@1139
   553
    }
icculus@1139
   554
icculus@1139
   555
}
icculus@1139
   556
slouken@1895
   557
static void BlitNtoNKey(SDL_BlitInfo * info);
slouken@1895
   558
static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info);
slouken@1895
   559
static void
slouken@1895
   560
Blit32to32KeyAltivec(SDL_BlitInfo * info)
icculus@1047
   561
{
icculus@1047
   562
    int height = info->d_height;
icculus@1047
   563
    Uint32 *srcp = (Uint32 *) info->s_pixels;
icculus@1047
   564
    int srcskip = info->s_skip;
icculus@1047
   565
    Uint32 *dstp = (Uint32 *) info->d_pixels;
icculus@1047
   566
    int dstskip = info->d_skip;
icculus@1047
   567
    SDL_PixelFormat *srcfmt = info->src;
icculus@1047
   568
    int srcbpp = srcfmt->BytesPerPixel;
icculus@1047
   569
    SDL_PixelFormat *dstfmt = info->dst;
icculus@1047
   570
    int dstbpp = dstfmt->BytesPerPixel;
icculus@1047
   571
    int copy_alpha = (srcfmt->Amask && dstfmt->Amask);
slouken@1895
   572
    unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
icculus@1047
   573
    Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
slouken@1895
   574
    Uint32 ckey = info->src->colorkey;
icculus@1047
   575
    vector unsigned int valpha;
icculus@1047
   576
    vector unsigned char vpermute;
icculus@1047
   577
    vector unsigned char vzero;
icculus@1047
   578
    vector unsigned int vckey;
icculus@1047
   579
    vector unsigned int vrgbmask;
icculus@1047
   580
    vpermute = calc_swizzle32(srcfmt, dstfmt);
icculus@1047
   581
    if (info->d_width < 16) {
slouken@1895
   582
        if (copy_alpha) {
slouken@1487
   583
            BlitNtoNKeyCopyAlpha(info);
icculus@1047
   584
        } else {
slouken@1487
   585
            BlitNtoNKey(info);
icculus@1047
   586
        }
slouken@1487
   587
        return;
icculus@1047
   588
    }
icculus@1047
   589
    vzero = vec_splat_u8(0);
icculus@1047
   590
    if (alpha) {
slouken@1895
   591
        ((unsigned char *) &valpha)[0] = (unsigned char) alpha;
slouken@1895
   592
        valpha =
slouken@1895
   593
            (vector unsigned int) vec_splat((vector unsigned char) valpha, 0);
icculus@1047
   594
    } else {
slouken@1895
   595
        valpha = (vector unsigned int) vzero;
icculus@1047
   596
    }
icculus@1047
   597
    ckey &= rgbmask;
slouken@1895
   598
    ((unsigned int *) (char *) &vckey)[0] = ckey;
icculus@1047
   599
    vckey = vec_splat(vckey, 0);
slouken@1895
   600
    ((unsigned int *) (char *) &vrgbmask)[0] = rgbmask;
icculus@1047
   601
    vrgbmask = vec_splat(vrgbmask, 0);
icculus@1047
   602
icculus@1047
   603
    while (height--) {
icculus@1047
   604
#define ONE_PIXEL_BLEND(condition, widthvar) \
icculus@1047
   605
        if (copy_alpha) { \
icculus@1047
   606
            while (condition) { \
icculus@1162
   607
                Uint32 Pixel; \
icculus@1047
   608
                unsigned sR, sG, sB, sA; \
icculus@1162
   609
                DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \
icculus@1047
   610
                          sR, sG, sB, sA); \
icculus@1162
   611
                if ( (Pixel & rgbmask) != ckey ) { \
icculus@1047
   612
                      ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
icculus@1047
   613
                            sR, sG, sB, sA); \
icculus@1047
   614
                } \
icculus@1162
   615
                dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \
icculus@1162
   616
                srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \
icculus@1047
   617
                widthvar--; \
icculus@1047
   618
            } \
icculus@1047
   619
        } else { \
icculus@1047
   620
            while (condition) { \
icculus@1162
   621
                Uint32 Pixel; \
icculus@1047
   622
                unsigned sR, sG, sB; \
icculus@1162
   623
                RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \
icculus@1162
   624
                if ( Pixel != ckey ) { \
icculus@1162
   625
                    RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \
icculus@1047
   626
                    ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
icculus@1047
   627
                              sR, sG, sB, alpha); \
icculus@1047
   628
                } \
icculus@1162
   629
                dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \
icculus@1162
   630
                srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \
icculus@1047
   631
                widthvar--; \
icculus@1047
   632
            } \
icculus@1047
   633
        }
icculus@1047
   634
        int width = info->d_width;
icculus@1047
   635
        ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width);
icculus@1047
   636
        assert(width > 0);
icculus@1047
   637
        if (width > 0) {
icculus@1047
   638
            int extrawidth = (width % 4);
icculus@1047
   639
            vector unsigned char valigner = VEC_ALIGNER(srcp);
icculus@1047
   640
            vector unsigned int vs = vec_ld(0, srcp);
icculus@1047
   641
            width -= extrawidth;
icculus@1047
   642
            assert(width >= 4);
icculus@1047
   643
            while (width) {
icculus@1047
   644
                vector unsigned char vsel;
icculus@1047
   645
                vector unsigned int vd;
icculus@1047
   646
                vector unsigned int voverflow = vec_ld(15, srcp);
icculus@1047
   647
                /* load the source vec */
icculus@1047
   648
                vs = vec_perm(vs, voverflow, valigner);
icculus@1047
   649
                /* vsel is set for items that match the key */
slouken@1895
   650
                vsel = (vector unsigned char) vec_and(vs, vrgbmask);
slouken@1895
   651
                vsel = (vector unsigned char) vec_cmpeq(vs, vckey);
icculus@1047
   652
                /* permute the src vec to the dest format */
icculus@1047
   653
                vs = vec_perm(vs, valpha, vpermute);
icculus@1047
   654
                /* load the destination vec */
icculus@1047
   655
                vd = vec_ld(0, dstp);
icculus@1047
   656
                /* select the source and dest into vs */
slouken@1895
   657
                vd = (vector unsigned int) vec_sel((vector unsigned char) vs,
slouken@1895
   658
                                                   (vector unsigned char) vd,
slouken@1895
   659
                                                   vsel);
slouken@1895
   660
icculus@1047
   661
                vec_st(vd, 0, dstp);
icculus@1047
   662
                srcp += 4;
icculus@1047
   663
                width -= 4;
icculus@1047
   664
                dstp += 4;
icculus@1047
   665
                vs = voverflow;
icculus@1047
   666
            }
icculus@1047
   667
            ONE_PIXEL_BLEND((extrawidth), extrawidth);
icculus@1047
   668
#undef ONE_PIXEL_BLEND
icculus@1047
   669
            srcp += srcskip >> 2;
icculus@1047
   670
            dstp += dstskip >> 2;
icculus@1047
   671
        }
icculus@1047
   672
    }
icculus@1047
   673
}
icculus@1047
   674
icculus@1047
   675
/* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
icculus@1047
   676
/* Use this on a G5 */
slouken@1895
   677
static void
slouken@1895
   678
ConvertAltivec32to32_noprefetch(SDL_BlitInfo * info)
icculus@1047
   679
{
icculus@1047
   680
    int height = info->d_height;
icculus@1047
   681
    Uint32 *src = (Uint32 *) info->s_pixels;
icculus@1047
   682
    int srcskip = info->s_skip;
icculus@1047
   683
    Uint32 *dst = (Uint32 *) info->d_pixels;
icculus@1047
   684
    int dstskip = info->d_skip;
icculus@1047
   685
    SDL_PixelFormat *srcfmt = info->src;
icculus@1047
   686
    SDL_PixelFormat *dstfmt = info->dst;
icculus@1047
   687
    vector unsigned int vzero = vec_splat_u32(0);
icculus@1047
   688
    vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
icculus@1047
   689
    if (dstfmt->Amask && !srcfmt->Amask) {
icculus@1047
   690
        if (srcfmt->alpha) {
icculus@1047
   691
            vector unsigned char valpha;
slouken@1895
   692
            ((unsigned char *) &valpha)[0] = srcfmt->alpha;
slouken@1895
   693
            vzero = (vector unsigned int) vec_splat(valpha, 0);
icculus@1047
   694
        }
icculus@1047
   695
    }
icculus@1047
   696
slouken@1339
   697
    assert(srcfmt->BytesPerPixel == 4);
slouken@1339
   698
    assert(dstfmt->BytesPerPixel == 4);
icculus@1047
   699
icculus@1047
   700
    while (height--) {
icculus@1047
   701
        vector unsigned char valigner;
icculus@1047
   702
        vector unsigned int vbits;
icculus@1047
   703
        vector unsigned int voverflow;
icculus@1047
   704
        Uint32 bits;
icculus@1047
   705
        Uint8 r, g, b, a;
icculus@1047
   706
icculus@1047
   707
        int width = info->d_width;
icculus@1047
   708
        int extrawidth;
icculus@1047
   709
icculus@1047
   710
        /* do scalar until we can align... */
icculus@1047
   711
        while ((UNALIGNED_PTR(dst)) && (width)) {
icculus@1047
   712
            bits = *(src++);
icculus@1047
   713
            RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
icculus@1047
   714
            *(dst++) = MAKE8888(dstfmt, r, g, b, a);
icculus@1047
   715
            width--;
icculus@1047
   716
        }
icculus@1047
   717
icculus@1047
   718
        /* After all that work, here's the vector part! */
icculus@1047
   719
        extrawidth = (width % 4);
icculus@1047
   720
        width -= extrawidth;
icculus@1047
   721
        valigner = VEC_ALIGNER(src);
icculus@1047
   722
        vbits = vec_ld(0, src);
icculus@1047
   723
slouken@1895
   724
        while (width) {
icculus@1047
   725
            voverflow = vec_ld(15, src);
icculus@1047
   726
            src += 4;
icculus@1047
   727
            width -= 4;
slouken@1895
   728
            vbits = vec_perm(vbits, voverflow, valigner);       /* src is ready. */
slouken@1895
   729
            vbits = vec_perm(vbits, vzero, vpermute);   /* swizzle it. */
slouken@1895
   730
            vec_st(vbits, 0, dst);      /* store it back out. */
icculus@1047
   731
            dst += 4;
icculus@1047
   732
            vbits = voverflow;
icculus@1047
   733
        }
icculus@1047
   734
icculus@1047
   735
        assert(width == 0);
icculus@1047
   736
icculus@1047
   737
        /* cover pixels at the end of the row that didn't fit in 16 bytes. */
icculus@1047
   738
        while (extrawidth) {
slouken@1895
   739
            bits = *(src++);    /* max 7 pixels, don't bother with prefetch. */
icculus@1047
   740
            RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
icculus@1047
   741
            *(dst++) = MAKE8888(dstfmt, r, g, b, a);
icculus@1047
   742
            extrawidth--;
icculus@1047
   743
        }
icculus@1047
   744
slouken@1895
   745
        src += srcskip >> 2;    /* move to next row, accounting for pitch. */
icculus@1047
   746
        dst += dstskip >> 2;
icculus@1047
   747
    }
icculus@1047
   748
icculus@1047
   749
}
icculus@1047
   750
icculus@1047
   751
/* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
icculus@1047
   752
/* Use this on a G4 */
slouken@1895
   753
static void
slouken@1895
   754
ConvertAltivec32to32_prefetch(SDL_BlitInfo * info)
icculus@1047
   755
{
slouken@1895
   756
    const int scalar_dst_lead = sizeof(Uint32) * 4;
slouken@1895
   757
    const int vector_dst_lead = sizeof(Uint32) * 16;
icculus@1047
   758
icculus@1047
   759
    int height = info->d_height;
icculus@1047
   760
    Uint32 *src = (Uint32 *) info->s_pixels;
icculus@1047
   761
    int srcskip = info->s_skip;
icculus@1047
   762
    Uint32 *dst = (Uint32 *) info->d_pixels;
icculus@1047
   763
    int dstskip = info->d_skip;
icculus@1047
   764
    SDL_PixelFormat *srcfmt = info->src;
icculus@1047
   765
    SDL_PixelFormat *dstfmt = info->dst;
icculus@1047
   766
    vector unsigned int vzero = vec_splat_u32(0);
icculus@1047
   767
    vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
icculus@1047
   768
    if (dstfmt->Amask && !srcfmt->Amask) {
icculus@1047
   769
        if (srcfmt->alpha) {
icculus@1047
   770
            vector unsigned char valpha;
slouken@1895
   771
            ((unsigned char *) &valpha)[0] = srcfmt->alpha;
slouken@1895
   772
            vzero = (vector unsigned int) vec_splat(valpha, 0);
icculus@1047
   773
        }
icculus@1047
   774
    }
icculus@1047
   775
slouken@1339
   776
    assert(srcfmt->BytesPerPixel == 4);
slouken@1339
   777
    assert(dstfmt->BytesPerPixel == 4);
icculus@1047
   778
icculus@1047
   779
    while (height--) {
icculus@1047
   780
        vector unsigned char valigner;
icculus@1047
   781
        vector unsigned int vbits;
icculus@1047
   782
        vector unsigned int voverflow;
icculus@1047
   783
        Uint32 bits;
icculus@1047
   784
        Uint8 r, g, b, a;
icculus@1047
   785
icculus@1047
   786
        int width = info->d_width;
icculus@1047
   787
        int extrawidth;
icculus@1047
   788
icculus@1047
   789
        /* do scalar until we can align... */
icculus@1047
   790
        while ((UNALIGNED_PTR(dst)) && (width)) {
slouken@1895
   791
            vec_dstt(src + scalar_dst_lead, DST_CTRL(2, 32, 1024),
slouken@1895
   792
                     DST_CHAN_SRC);
slouken@1895
   793
            vec_dstst(dst + scalar_dst_lead, DST_CTRL(2, 32, 1024),
slouken@1895
   794
                      DST_CHAN_DEST);
icculus@1047
   795
            bits = *(src++);
icculus@1047
   796
            RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
icculus@1047
   797
            *(dst++) = MAKE8888(dstfmt, r, g, b, a);
icculus@1047
   798
            width--;
icculus@1047
   799
        }
icculus@1047
   800
icculus@1047
   801
        /* After all that work, here's the vector part! */
icculus@1047
   802
        extrawidth = (width % 4);
icculus@1047
   803
        width -= extrawidth;
icculus@1047
   804
        valigner = VEC_ALIGNER(src);
icculus@1047
   805
        vbits = vec_ld(0, src);
icculus@1047
   806
icculus@1047
   807
        while (width) {
slouken@1895
   808
            vec_dstt(src + vector_dst_lead, DST_CTRL(2, 32, 1024),
slouken@1895
   809
                     DST_CHAN_SRC);
slouken@1895
   810
            vec_dstst(dst + vector_dst_lead, DST_CTRL(2, 32, 1024),
slouken@1895
   811
                      DST_CHAN_DEST);
icculus@1047
   812
            voverflow = vec_ld(15, src);
icculus@1047
   813
            src += 4;
icculus@1047
   814
            width -= 4;
slouken@1895
   815
            vbits = vec_perm(vbits, voverflow, valigner);       /* src is ready. */
slouken@1895
   816
            vbits = vec_perm(vbits, vzero, vpermute);   /* swizzle it. */
slouken@1895
   817
            vec_st(vbits, 0, dst);      /* store it back out. */
icculus@1047
   818
            dst += 4;
icculus@1047
   819
            vbits = voverflow;
icculus@1047
   820
        }
slouken@1895
   821
icculus@1047
   822
        assert(width == 0);
icculus@1047
   823
icculus@1047
   824
        /* cover pixels at the end of the row that didn't fit in 16 bytes. */
icculus@1047
   825
        while (extrawidth) {
slouken@1895
   826
            bits = *(src++);    /* max 7 pixels, don't bother with prefetch. */
icculus@1047
   827
            RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
icculus@1047
   828
            *(dst++) = MAKE8888(dstfmt, r, g, b, a);
icculus@1047
   829
            extrawidth--;
icculus@1047
   830
        }
icculus@1047
   831
slouken@1895
   832
        src += srcskip >> 2;    /* move to next row, accounting for pitch. */
icculus@1047
   833
        dst += dstskip >> 2;
icculus@1047
   834
    }
icculus@1047
   835
icculus@1047
   836
    vec_dss(DST_CHAN_SRC);
icculus@1047
   837
    vec_dss(DST_CHAN_DEST);
icculus@1047
   838
}
icculus@1047
   839
slouken@1895
   840
static Uint32
slouken@1895
   841
GetBlitFeatures(void)
icculus@1047
   842
{
icculus@1047
   843
    static Uint32 features = 0xffffffff;
icculus@1047
   844
    if (features == 0xffffffff) {
icculus@1047
   845
        /* Provide an override for testing .. */
slouken@1336
   846
        char *override = SDL_getenv("SDL_ALTIVEC_BLIT_FEATURES");
icculus@1047
   847
        if (override) {
icculus@1047
   848
            features = 0;
slouken@1336
   849
            SDL_sscanf(override, "%u", &features);
icculus@1047
   850
        } else {
slouken@1895
   851
            features = (0
slouken@1895
   852
                        /* Feature 1 is has-MMX */
slouken@1895
   853
                        | ((SDL_HasMMX())? 1 : 0)
slouken@1895
   854
                        /* Feature 2 is has-AltiVec */
slouken@1895
   855
                        | ((SDL_HasAltiVec())? 2 : 0)
slouken@1895
   856
                        /* Feature 4 is dont-use-prefetch */
slouken@1895
   857
                        /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */
slouken@1895
   858
                        | ((GetL3CacheSize() == 0) ? 4 : 0)
slouken@1895
   859
                );
icculus@1047
   860
        }
icculus@1047
   861
    }
icculus@1047
   862
    return features;
icculus@1047
   863
}
slouken@1895
   864
slouken@1795
   865
#if __MWERKS__
slouken@1795
   866
#pragma altivec_model off
slouken@1795
   867
#endif
icculus@1047
   868
#else
icculus@1047
   869
/* Feature 1 is has-MMX */
icculus@1047
   870
#define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0))
icculus@1047
   871
#endif
icculus@1047
   872
icculus@1053
   873
/* This is now endian dependent */
slouken@1443
   874
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
icculus@1053
   875
#define HI	1
icculus@1053
   876
#define LO	0
slouken@1443
   877
#else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */
icculus@1053
   878
#define HI	0
icculus@1053
   879
#define LO	1
icculus@1053
   880
#endif
icculus@1053
   881
slouken@0
   882
/* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
slouken@0
   883
#define RGB888_RGB332(dst, src) { \
slouken@1428
   884
	dst = (Uint8)((((src)&0x00E00000)>>16)| \
slouken@1428
   885
	              (((src)&0x0000E000)>>11)| \
slouken@1428
   886
	              (((src)&0x000000C0)>>6)); \
slouken@0
   887
}
slouken@1895
   888
static void
slouken@1895
   889
Blit_RGB888_index8(SDL_BlitInfo * info)
slouken@0
   890
{
slouken@0
   891
#ifndef USE_DUFFS_LOOP
slouken@1895
   892
    int c;
slouken@0
   893
#endif
slouken@1895
   894
    int width, height;
slouken@1895
   895
    Uint32 *src;
slouken@1895
   896
    const Uint8 *map;
slouken@1895
   897
    Uint8 *dst;
slouken@1895
   898
    int srcskip, dstskip;
slouken@0
   899
slouken@1895
   900
    /* Set up some basic variables */
slouken@1895
   901
    width = info->d_width;
slouken@1895
   902
    height = info->d_height;
slouken@1895
   903
    src = (Uint32 *) info->s_pixels;
slouken@1895
   904
    srcskip = info->s_skip / 4;
slouken@1895
   905
    dst = info->d_pixels;
slouken@1895
   906
    dstskip = info->d_skip;
slouken@1895
   907
    map = info->table;
slouken@0
   908
slouken@1895
   909
    if (map == NULL) {
slouken@1895
   910
        while (height--) {
slouken@0
   911
#ifdef USE_DUFFS_LOOP
slouken@1895
   912
			/* *INDENT-OFF* */
slouken@0
   913
			DUFFS_LOOP(
slouken@0
   914
				RGB888_RGB332(*dst++, *src);
slouken@0
   915
			, width);
slouken@1895
   916
			/* *INDENT-ON* */
slouken@0
   917
#else
slouken@1895
   918
            for (c = width / 4; c; --c) {
slouken@1895
   919
                /* Pack RGB into 8bit pixel */
slouken@1895
   920
                ++src;
slouken@1895
   921
                RGB888_RGB332(*dst++, *src);
slouken@1895
   922
                ++src;
slouken@1895
   923
                RGB888_RGB332(*dst++, *src);
slouken@1895
   924
                ++src;
slouken@1895
   925
                RGB888_RGB332(*dst++, *src);
slouken@1895
   926
                ++src;
slouken@1895
   927
            }
slouken@1895
   928
            switch (width & 3) {
slouken@1895
   929
            case 3:
slouken@1895
   930
                RGB888_RGB332(*dst++, *src);
slouken@1895
   931
                ++src;
slouken@1895
   932
            case 2:
slouken@1895
   933
                RGB888_RGB332(*dst++, *src);
slouken@1895
   934
                ++src;
slouken@1895
   935
            case 1:
slouken@1895
   936
                RGB888_RGB332(*dst++, *src);
slouken@1895
   937
                ++src;
slouken@1895
   938
            }
slouken@0
   939
#endif /* USE_DUFFS_LOOP */
slouken@1895
   940
            src += srcskip;
slouken@1895
   941
            dst += dstskip;
slouken@1895
   942
        }
slouken@1895
   943
    } else {
slouken@1895
   944
        int Pixel;
slouken@0
   945
slouken@1895
   946
        while (height--) {
slouken@0
   947
#ifdef USE_DUFFS_LOOP
slouken@1895
   948
			/* *INDENT-OFF* */
slouken@0
   949
			DUFFS_LOOP(
icculus@1162
   950
				RGB888_RGB332(Pixel, *src);
icculus@1162
   951
				*dst++ = map[Pixel];
slouken@0
   952
				++src;
slouken@0
   953
			, width);
slouken@1895
   954
			/* *INDENT-ON* */
slouken@0
   955
#else
slouken@1895
   956
            for (c = width / 4; c; --c) {
slouken@1895
   957
                /* Pack RGB into 8bit pixel */
slouken@1895
   958
                RGB888_RGB332(Pixel, *src);
slouken@1895
   959
                *dst++ = map[Pixel];
slouken@1895
   960
                ++src;
slouken@1895
   961
                RGB888_RGB332(Pixel, *src);
slouken@1895
   962
                *dst++ = map[Pixel];
slouken@1895
   963
                ++src;
slouken@1895
   964
                RGB888_RGB332(Pixel, *src);
slouken@1895
   965
                *dst++ = map[Pixel];
slouken@1895
   966
                ++src;
slouken@1895
   967
                RGB888_RGB332(Pixel, *src);
slouken@1895
   968
                *dst++ = map[Pixel];
slouken@1895
   969
                ++src;
slouken@1895
   970
            }
slouken@1895
   971
            switch (width & 3) {
slouken@1895
   972
            case 3:
slouken@1895
   973
                RGB888_RGB332(Pixel, *src);
slouken@1895
   974
                *dst++ = map[Pixel];
slouken@1895
   975
                ++src;
slouken@1895
   976
            case 2:
slouken@1895
   977
                RGB888_RGB332(Pixel, *src);
slouken@1895
   978
                *dst++ = map[Pixel];
slouken@1895
   979
                ++src;
slouken@1895
   980
            case 1:
slouken@1895
   981
                RGB888_RGB332(Pixel, *src);
slouken@1895
   982
                *dst++ = map[Pixel];
slouken@1895
   983
                ++src;
slouken@1895
   984
            }
slouken@0
   985
#endif /* USE_DUFFS_LOOP */
slouken@1895
   986
            src += srcskip;
slouken@1895
   987
            dst += dstskip;
slouken@1895
   988
        }
slouken@1895
   989
    }
slouken@0
   990
}
slouken@1895
   991
slouken@0
   992
/* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
slouken@0
   993
#define RGB888_RGB555(dst, src) { \
slouken@1428
   994
	*(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>9)| \
slouken@1428
   995
	                            (((*src)&0x0000F800)>>6)| \
slouken@1428
   996
	                            (((*src)&0x000000F8)>>3)); \
slouken@0
   997
}
slouken@0
   998
#define RGB888_RGB555_TWO(dst, src) { \
slouken@0
   999
	*(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
slouken@0
  1000
	                     (((src[HI])&0x0000F800)>>6)| \
slouken@0
  1001
	                     (((src[HI])&0x000000F8)>>3))<<16)| \
slouken@0
  1002
	                     (((src[LO])&0x00F80000)>>9)| \
slouken@0
  1003
	                     (((src[LO])&0x0000F800)>>6)| \
slouken@0
  1004
	                     (((src[LO])&0x000000F8)>>3); \
slouken@0
  1005
}
slouken@1895
  1006
static void
slouken@1895
  1007
Blit_RGB888_RGB555(SDL_BlitInfo * info)
slouken@0
  1008
{
slouken@0
  1009
#ifndef USE_DUFFS_LOOP
slouken@1895
  1010
    int c;
slouken@0
  1011
#endif
slouken@1895
  1012
    int width, height;
slouken@1895
  1013
    Uint32 *src;
slouken@1895
  1014
    Uint16 *dst;
slouken@1895
  1015
    int srcskip, dstskip;
slouken@0
  1016
slouken@1895
  1017
    /* Set up some basic variables */
slouken@1895
  1018
    width = info->d_width;
slouken@1895
  1019
    height = info->d_height;
slouken@1895
  1020
    src = (Uint32 *) info->s_pixels;
slouken@1895
  1021
    srcskip = info->s_skip / 4;
slouken@1895
  1022
    dst = (Uint16 *) info->d_pixels;
slouken@1895
  1023
    dstskip = info->d_skip / 2;
slouken@0
  1024
slouken@0
  1025
#ifdef USE_DUFFS_LOOP
slouken@1895
  1026
    while (height--) {
slouken@1895
  1027
		/* *INDENT-OFF* */
slouken@0
  1028
		DUFFS_LOOP(
slouken@0
  1029
			RGB888_RGB555(dst, src);
slouken@0
  1030
			++src;
slouken@0
  1031
			++dst;
slouken@0
  1032
		, width);
slouken@1895
  1033
		/* *INDENT-ON* */
slouken@1895
  1034
        src += srcskip;
slouken@1895
  1035
        dst += dstskip;
slouken@1895
  1036
    }
slouken@0
  1037
#else
slouken@1895
  1038
    /* Memory align at 4-byte boundary, if necessary */
slouken@1895
  1039
    if ((long) dst & 0x03) {
slouken@1895
  1040
        /* Don't do anything if width is 0 */
slouken@1895
  1041
        if (width == 0) {
slouken@1895
  1042
            return;
slouken@1895
  1043
        }
slouken@1895
  1044
        --width;
slouken@0
  1045
slouken@1895
  1046
        while (height--) {
slouken@1895
  1047
            /* Perform copy alignment */
slouken@1895
  1048
            RGB888_RGB555(dst, src);
slouken@1895
  1049
            ++src;
slouken@1895
  1050
            ++dst;
slouken@0
  1051
slouken@1895
  1052
            /* Copy in 4 pixel chunks */
slouken@1895
  1053
            for (c = width / 4; c; --c) {
slouken@1895
  1054
                RGB888_RGB555_TWO(dst, src);
slouken@1895
  1055
                src += 2;
slouken@1895
  1056
                dst += 2;
slouken@1895
  1057
                RGB888_RGB555_TWO(dst, src);
slouken@1895
  1058
                src += 2;
slouken@1895
  1059
                dst += 2;
slouken@1895
  1060
            }
slouken@1895
  1061
            /* Get any leftovers */
slouken@1895
  1062
            switch (width & 3) {
slouken@1895
  1063
            case 3:
slouken@1895
  1064
                RGB888_RGB555(dst, src);
slouken@1895
  1065
                ++src;
slouken@1895
  1066
                ++dst;
slouken@1895
  1067
            case 2:
slouken@1895
  1068
                RGB888_RGB555_TWO(dst, src);
slouken@1895
  1069
                src += 2;
slouken@1895
  1070
                dst += 2;
slouken@1895
  1071
                break;
slouken@1895
  1072
            case 1:
slouken@1895
  1073
                RGB888_RGB555(dst, src);
slouken@1895
  1074
                ++src;
slouken@1895
  1075
                ++dst;
slouken@1895
  1076
                break;
slouken@1895
  1077
            }
slouken@1895
  1078
            src += srcskip;
slouken@1895
  1079
            dst += dstskip;
slouken@1895
  1080
        }
slouken@1895
  1081
    } else {
slouken@1895
  1082
        while (height--) {
slouken@1895
  1083
            /* Copy in 4 pixel chunks */
slouken@1895
  1084
            for (c = width / 4; c; --c) {
slouken@1895
  1085
                RGB888_RGB555_TWO(dst, src);
slouken@1895
  1086
                src += 2;
slouken@1895
  1087
                dst += 2;
slouken@1895
  1088
                RGB888_RGB555_TWO(dst, src);
slouken@1895
  1089
                src += 2;
slouken@1895
  1090
                dst += 2;
slouken@1895
  1091
            }
slouken@1895
  1092
            /* Get any leftovers */
slouken@1895
  1093
            switch (width & 3) {
slouken@1895
  1094
            case 3:
slouken@1895
  1095
                RGB888_RGB555(dst, src);
slouken@1895
  1096
                ++src;
slouken@1895
  1097
                ++dst;
slouken@1895
  1098
            case 2:
slouken@1895
  1099
                RGB888_RGB555_TWO(dst, src);
slouken@1895
  1100
                src += 2;
slouken@1895
  1101
                dst += 2;
slouken@1895
  1102
                break;
slouken@1895
  1103
            case 1:
slouken@1895
  1104
                RGB888_RGB555(dst, src);
slouken@1895
  1105
                ++src;
slouken@1895
  1106
                ++dst;
slouken@1895
  1107
                break;
slouken@1895
  1108
            }
slouken@1895
  1109
            src += srcskip;
slouken@1895
  1110
            dst += dstskip;
slouken@1895
  1111
        }
slouken@1895
  1112
    }
slouken@0
  1113
#endif /* USE_DUFFS_LOOP */
slouken@0
  1114
}
slouken@1895
  1115
slouken@0
  1116
/* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
slouken@0
  1117
#define RGB888_RGB565(dst, src) { \
slouken@1428
  1118
	*(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>8)| \
slouken@1428
  1119
	                            (((*src)&0x0000FC00)>>5)| \
slouken@1428
  1120
	                            (((*src)&0x000000F8)>>3)); \
slouken@0
  1121
}
slouken@0
  1122
#define RGB888_RGB565_TWO(dst, src) { \
slouken@0
  1123
	*(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
slouken@0
  1124
	                     (((src[HI])&0x0000FC00)>>5)| \
slouken@0
  1125
	                     (((src[HI])&0x000000F8)>>3))<<16)| \
slouken@0
  1126
	                     (((src[LO])&0x00F80000)>>8)| \
slouken@0
  1127
	                     (((src[LO])&0x0000FC00)>>5)| \
slouken@0
  1128
	                     (((src[LO])&0x000000F8)>>3); \
slouken@0
  1129
}
slouken@1895
  1130
static void
slouken@1895
  1131
Blit_RGB888_RGB565(SDL_BlitInfo * info)
slouken@0
  1132
{
slouken@0
  1133
#ifndef USE_DUFFS_LOOP
slouken@1895
  1134
    int c;
slouken@0
  1135
#endif
slouken@1895
  1136
    int width, height;
slouken@1895
  1137
    Uint32 *src;
slouken@1895
  1138
    Uint16 *dst;
slouken@1895
  1139
    int srcskip, dstskip;
slouken@0
  1140
slouken@1895
  1141
    /* Set up some basic variables */
slouken@1895
  1142
    width = info->d_width;
slouken@1895
  1143
    height = info->d_height;
slouken@1895
  1144
    src = (Uint32 *) info->s_pixels;
slouken@1895
  1145
    srcskip = info->s_skip / 4;
slouken@1895
  1146
    dst = (Uint16 *) info->d_pixels;
slouken@1895
  1147
    dstskip = info->d_skip / 2;
slouken@0
  1148
slouken@0
  1149
#ifdef USE_DUFFS_LOOP
slouken@1895
  1150
    while (height--) {
slouken@1895
  1151
		/* *INDENT-OFF* */
slouken@0
  1152
		DUFFS_LOOP(
slouken@0
  1153
			RGB888_RGB565(dst, src);
slouken@0
  1154
			++src;
slouken@0
  1155
			++dst;
slouken@0
  1156
		, width);
slouken@1895
  1157
		/* *INDENT-ON* */
slouken@1895
  1158
        src += srcskip;
slouken@1895
  1159
        dst += dstskip;
slouken@1895
  1160
    }
slouken@0
  1161
#else
slouken@1895
  1162
    /* Memory align at 4-byte boundary, if necessary */
slouken@1895
  1163
    if ((long) dst & 0x03) {
slouken@1895
  1164
        /* Don't do anything if width is 0 */
slouken@1895
  1165
        if (width == 0) {
slouken@1895
  1166
            return;
slouken@1895
  1167
        }
slouken@1895
  1168
        --width;
slouken@0
  1169
slouken@1895
  1170
        while (height--) {
slouken@1895
  1171
            /* Perform copy alignment */
slouken@1895
  1172
            RGB888_RGB565(dst, src);
slouken@1895
  1173
            ++src;
slouken@1895
  1174
            ++dst;
slouken@0
  1175
slouken@1895
  1176
            /* Copy in 4 pixel chunks */
slouken@1895
  1177
            for (c = width / 4; c; --c) {
slouken@1895
  1178
                RGB888_RGB565_TWO(dst, src);
slouken@1895
  1179
                src += 2;
slouken@1895
  1180
                dst += 2;
slouken@1895
  1181
                RGB888_RGB565_TWO(dst, src);
slouken@1895
  1182
                src += 2;
slouken@1895
  1183
                dst += 2;
slouken@1895
  1184
            }
slouken@1895
  1185
            /* Get any leftovers */
slouken@1895
  1186
            switch (width & 3) {
slouken@1895
  1187
            case 3:
slouken@1895
  1188
                RGB888_RGB565(dst, src);
slouken@1895
  1189
                ++src;
slouken@1895
  1190
                ++dst;
slouken@1895
  1191
            case 2:
slouken@1895
  1192
                RGB888_RGB565_TWO(dst, src);
slouken@1895
  1193
                src += 2;
slouken@1895
  1194
                dst += 2;
slouken@1895
  1195
                break;
slouken@1895
  1196
            case 1:
slouken@1895
  1197
                RGB888_RGB565(dst, src);
slouken@1895
  1198
                ++src;
slouken@1895
  1199
                ++dst;
slouken@1895
  1200
                break;
slouken@1895
  1201
            }
slouken@1895
  1202
            src += srcskip;
slouken@1895
  1203
            dst += dstskip;
slouken@1895
  1204
        }
slouken@1895
  1205
    } else {
slouken@1895
  1206
        while (height--) {
slouken@1895
  1207
            /* Copy in 4 pixel chunks */
slouken@1895
  1208
            for (c = width / 4; c; --c) {
slouken@1895
  1209
                RGB888_RGB565_TWO(dst, src);
slouken@1895
  1210
                src += 2;
slouken@1895
  1211
                dst += 2;
slouken@1895
  1212
                RGB888_RGB565_TWO(dst, src);
slouken@1895
  1213
                src += 2;
slouken@1895
  1214
                dst += 2;
slouken@1895
  1215
            }
slouken@1895
  1216
            /* Get any leftovers */
slouken@1895
  1217
            switch (width & 3) {
slouken@1895
  1218
            case 3:
slouken@1895
  1219
                RGB888_RGB565(dst, src);
slouken@1895
  1220
                ++src;
slouken@1895
  1221
                ++dst;
slouken@1895
  1222
            case 2:
slouken@1895
  1223
                RGB888_RGB565_TWO(dst, src);
slouken@1895
  1224
                src += 2;
slouken@1895
  1225
                dst += 2;
slouken@1895
  1226
                break;
slouken@1895
  1227
            case 1:
slouken@1895
  1228
                RGB888_RGB565(dst, src);
slouken@1895
  1229
                ++src;
slouken@1895
  1230
                ++dst;
slouken@1895
  1231
                break;
slouken@1895
  1232
            }
slouken@1895
  1233
            src += srcskip;
slouken@1895
  1234
            dst += dstskip;
slouken@1895
  1235
        }
slouken@1895
  1236
    }
slouken@0
  1237
#endif /* USE_DUFFS_LOOP */
slouken@0
  1238
}
slouken@0
  1239
slouken@0
  1240
slouken@0
  1241
/* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
icculus@1047
  1242
#define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1])
slouken@1895
  1243
static void
slouken@1895
  1244
Blit_RGB565_32(SDL_BlitInfo * info, const Uint32 * map)
slouken@0
  1245
{
slouken@0
  1246
#ifndef USE_DUFFS_LOOP
slouken@1895
  1247
    int c;
slouken@0
  1248
#endif
slouken@1895
  1249
    int width, height;
slouken@1895
  1250
    Uint8 *src;
slouken@1895
  1251
    Uint32 *dst;
slouken@1895
  1252
    int srcskip, dstskip;
slouken@0
  1253
slouken@1895
  1254
    /* Set up some basic variables */
slouken@1895
  1255
    width = info->d_width;
slouken@1895
  1256
    height = info->d_height;
slouken@1895
  1257
    src = (Uint8 *) info->s_pixels;
slouken@1895
  1258
    srcskip = info->s_skip;
slouken@1895
  1259
    dst = (Uint32 *) info->d_pixels;
slouken@1895
  1260
    dstskip = info->d_skip / 4;
slouken@0
  1261
slouken@0
  1262
#ifdef USE_DUFFS_LOOP
slouken@1895
  1263
    while (height--) {
slouken@1895
  1264
		/* *INDENT-OFF* */
slouken@0
  1265
		DUFFS_LOOP(
slouken@0
  1266
		{
slouken@0
  1267
			*dst++ = RGB565_32(dst, src, map);
slouken@0
  1268
			src += 2;
slouken@0
  1269
		},
slouken@0
  1270
		width);
slouken@1895
  1271
		/* *INDENT-ON* */
slouken@1895
  1272
        src += srcskip;
slouken@1895
  1273
        dst += dstskip;
slouken@1895
  1274
    }
slouken@0
  1275
#else
slouken@1895
  1276
    while (height--) {
slouken@1895
  1277
        /* Copy in 4 pixel chunks */
slouken@1895
  1278
        for (c = width / 4; c; --c) {
slouken@1895
  1279
            *dst++ = RGB565_32(dst, src, map);
slouken@1895
  1280
            src += 2;
slouken@1895
  1281
            *dst++ = RGB565_32(dst, src, map);
slouken@1895
  1282
            src += 2;
slouken@1895
  1283
            *dst++ = RGB565_32(dst, src, map);
slouken@1895
  1284
            src += 2;
slouken@1895
  1285
            *dst++ = RGB565_32(dst, src, map);
slouken@1895
  1286
            src += 2;
slouken@1895
  1287
        }
slouken@1895
  1288
        /* Get any leftovers */
slouken@1895
  1289
        switch (width & 3) {
slouken@1895
  1290
        case 3:
slouken@1895
  1291
            *dst++ = RGB565_32(dst, src, map);
slouken@1895
  1292
            src += 2;
slouken@1895
  1293
        case 2:
slouken@1895
  1294
            *dst++ = RGB565_32(dst, src, map);
slouken@1895
  1295
            src += 2;
slouken@1895
  1296
        case 1:
slouken@1895
  1297
            *dst++ = RGB565_32(dst, src, map);
slouken@1895
  1298
            src += 2;
slouken@1895
  1299
            break;
slouken@1895
  1300
        }
slouken@1895
  1301
        src += srcskip;
slouken@1895
  1302
        dst += dstskip;
slouken@1895
  1303
    }
slouken@0
  1304
#endif /* USE_DUFFS_LOOP */
slouken@0
  1305
}
slouken@0
  1306
slouken@0
  1307
/* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
slouken@91
  1308
static const Uint32 RGB565_ARGB8888_LUT[512] = {
slouken@1895
  1309
    0x00000000, 0xff000000, 0x00000008, 0xff002000,
slouken@1895
  1310
    0x00000010, 0xff004000, 0x00000018, 0xff006100,
slouken@1895
  1311
    0x00000020, 0xff008100, 0x00000029, 0xff00a100,
slouken@1895
  1312
    0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
slouken@1895
  1313
    0x00000041, 0xff080000, 0x0000004a, 0xff082000,
slouken@1895
  1314
    0x00000052, 0xff084000, 0x0000005a, 0xff086100,
slouken@1895
  1315
    0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
slouken@1895
  1316
    0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
slouken@1895
  1317
    0x00000083, 0xff100000, 0x0000008b, 0xff102000,
slouken@1895
  1318
    0x00000094, 0xff104000, 0x0000009c, 0xff106100,
slouken@1895
  1319
    0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
slouken@1895
  1320
    0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
slouken@1895
  1321
    0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
slouken@1895
  1322
    0x000000d5, 0xff184000, 0x000000de, 0xff186100,
slouken@1895
  1323
    0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
slouken@1895
  1324
    0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
slouken@1895
  1325
    0x00000400, 0xff200000, 0x00000408, 0xff202000,
slouken@1895
  1326
    0x00000410, 0xff204000, 0x00000418, 0xff206100,
slouken@1895
  1327
    0x00000420, 0xff208100, 0x00000429, 0xff20a100,
slouken@1895
  1328
    0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
slouken@1895
  1329
    0x00000441, 0xff290000, 0x0000044a, 0xff292000,
slouken@1895
  1330
    0x00000452, 0xff294000, 0x0000045a, 0xff296100,
slouken@1895
  1331
    0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
slouken@1895
  1332
    0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
slouken@1895
  1333
    0x00000483, 0xff310000, 0x0000048b, 0xff312000,
slouken@1895
  1334
    0x00000494, 0xff314000, 0x0000049c, 0xff316100,
slouken@1895
  1335
    0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
slouken@1895
  1336
    0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
slouken@1895
  1337
    0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
slouken@1895
  1338
    0x000004d5, 0xff394000, 0x000004de, 0xff396100,
slouken@1895
  1339
    0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
slouken@1895
  1340
    0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
slouken@1895
  1341
    0x00000800, 0xff410000, 0x00000808, 0xff412000,
slouken@1895
  1342
    0x00000810, 0xff414000, 0x00000818, 0xff416100,
slouken@1895
  1343
    0x00000820, 0xff418100, 0x00000829, 0xff41a100,
slouken@1895
  1344
    0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
slouken@1895
  1345
    0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
slouken@1895
  1346
    0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
slouken@1895
  1347
    0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
slouken@1895
  1348
    0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
slouken@1895
  1349
    0x00000883, 0xff520000, 0x0000088b, 0xff522000,
slouken@1895
  1350
    0x00000894, 0xff524000, 0x0000089c, 0xff526100,
slouken@1895
  1351
    0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
slouken@1895
  1352
    0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
slouken@1895
  1353
    0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
slouken@1895
  1354
    0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
slouken@1895
  1355
    0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
slouken@1895
  1356
    0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
slouken@1895
  1357
    0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
slouken@1895
  1358
    0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
slouken@1895
  1359
    0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
slouken@1895
  1360
    0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
slouken@1895
  1361
    0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
slouken@1895
  1362
    0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
slouken@1895
  1363
    0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
slouken@1895
  1364
    0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
slouken@1895
  1365
    0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
slouken@1895
  1366
    0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
slouken@1895
  1367
    0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
slouken@1895
  1368
    0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
slouken@1895
  1369
    0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
slouken@1895
  1370
    0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
slouken@1895
  1371
    0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
slouken@1895
  1372
    0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
slouken@1895
  1373
    0x00001000, 0xff830000, 0x00001008, 0xff832000,
slouken@1895
  1374
    0x00001010, 0xff834000, 0x00001018, 0xff836100,
slouken@1895
  1375
    0x00001020, 0xff838100, 0x00001029, 0xff83a100,
slouken@1895
  1376
    0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
slouken@1895
  1377
    0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
slouken@1895
  1378
    0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
slouken@1895
  1379
    0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
slouken@1895
  1380
    0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
slouken@1895
  1381
    0x00001083, 0xff940000, 0x0000108b, 0xff942000,
slouken@1895
  1382
    0x00001094, 0xff944000, 0x0000109c, 0xff946100,
slouken@1895
  1383
    0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
slouken@1895
  1384
    0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
slouken@1895
  1385
    0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
slouken@1895
  1386
    0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
slouken@1895
  1387
    0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
slouken@1895
  1388
    0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
slouken@1895
  1389
    0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
slouken@1895
  1390
    0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
slouken@1895
  1391
    0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
slouken@1895
  1392
    0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
slouken@1895
  1393
    0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
slouken@1895
  1394
    0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
slouken@1895
  1395
    0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
slouken@1895
  1396
    0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
slouken@1895
  1397
    0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
slouken@1895
  1398
    0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
slouken@1895
  1399
    0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
slouken@1895
  1400
    0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
slouken@1895
  1401
    0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
slouken@1895
  1402
    0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
slouken@1895
  1403
    0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
slouken@1895
  1404
    0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
slouken@1895
  1405
    0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
slouken@1895
  1406
    0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
slouken@1895
  1407
    0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
slouken@1895
  1408
    0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
slouken@1895
  1409
    0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
slouken@1895
  1410
    0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
slouken@1895
  1411
    0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
slouken@1895
  1412
    0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
slouken@1895
  1413
    0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
slouken@1895
  1414
    0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
slouken@1895
  1415
    0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
slouken@1895
  1416
    0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
slouken@1895
  1417
    0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
slouken@1895
  1418
    0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
slouken@1895
  1419
    0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
slouken@1895
  1420
    0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
slouken@1895
  1421
    0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
slouken@1895
  1422
    0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
slouken@1895
  1423
    0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
slouken@1895
  1424
    0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
slouken@1895
  1425
    0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
slouken@1895
  1426
    0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
slouken@1895
  1427
    0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
slouken@1895
  1428
    0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
slouken@1895
  1429
    0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
slouken@1895
  1430
    0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
slouken@1895
  1431
    0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
slouken@1895
  1432
    0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
slouken@1895
  1433
    0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
slouken@1895
  1434
    0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
slouken@1895
  1435
    0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
slouken@1895
  1436
    0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
slouken@0
  1437
};
slouken@1895
  1438
static void
slouken@1895
  1439
Blit_RGB565_ARGB8888(SDL_BlitInfo * info)
slouken@0
  1440
{
slouken@0
  1441
    Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
slouken@0
  1442
}
slouken@0
  1443
slouken@0
  1444
/* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
slouken@91
  1445
static const Uint32 RGB565_ABGR8888_LUT[512] = {
slouken@1895
  1446
    0xff000000, 0x00000000, 0xff080000, 0x00002000,
slouken@1895
  1447
    0xff100000, 0x00004000, 0xff180000, 0x00006100,
slouken@1895
  1448
    0xff200000, 0x00008100, 0xff290000, 0x0000a100,
slouken@1895
  1449
    0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
slouken@1895
  1450
    0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
slouken@1895
  1451
    0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
slouken@1895
  1452
    0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
slouken@1895
  1453
    0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
slouken@1895
  1454
    0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
slouken@1895
  1455
    0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
slouken@1895
  1456
    0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
slouken@1895
  1457
    0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
slouken@1895
  1458
    0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
slouken@1895
  1459
    0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
slouken@1895
  1460
    0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
slouken@1895
  1461
    0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
slouken@1895
  1462
    0xff000400, 0x00000020, 0xff080400, 0x00002020,
slouken@1895
  1463
    0xff100400, 0x00004020, 0xff180400, 0x00006120,
slouken@1895
  1464
    0xff200400, 0x00008120, 0xff290400, 0x0000a120,
slouken@1895
  1465
    0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
slouken@1895
  1466
    0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
slouken@1895
  1467
    0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
slouken@1895
  1468
    0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
slouken@1895
  1469
    0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
slouken@1895
  1470
    0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
slouken@1895
  1471
    0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
slouken@1895
  1472
    0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
slouken@1895
  1473
    0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
slouken@1895
  1474
    0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
slouken@1895
  1475
    0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
slouken@1895
  1476
    0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
slouken@1895
  1477
    0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
slouken@1895
  1478
    0xff000800, 0x00000041, 0xff080800, 0x00002041,
slouken@1895
  1479
    0xff100800, 0x00004041, 0xff180800, 0x00006141,
slouken@1895
  1480
    0xff200800, 0x00008141, 0xff290800, 0x0000a141,
slouken@1895
  1481
    0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
slouken@1895
  1482
    0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
slouken@1895
  1483
    0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
slouken@1895
  1484
    0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
slouken@1895
  1485
    0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
slouken@1895
  1486
    0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
slouken@1895
  1487
    0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
slouken@1895
  1488
    0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
slouken@1895
  1489
    0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
slouken@1895
  1490
    0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
slouken@1895
  1491
    0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
slouken@1895
  1492
    0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
slouken@1895
  1493
    0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
slouken@1895
  1494
    0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
slouken@1895
  1495
    0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
slouken@1895
  1496
    0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
slouken@1895
  1497
    0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
slouken@1895
  1498
    0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
slouken@1895
  1499
    0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
slouken@1895
  1500
    0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
slouken@1895
  1501
    0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
slouken@1895
  1502
    0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
slouken@1895
  1503
    0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
slouken@1895
  1504
    0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
slouken@1895
  1505
    0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
slouken@1895
  1506
    0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
slouken@1895
  1507
    0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
slouken@1895
  1508
    0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
slouken@1895
  1509
    0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
slouken@1895
  1510
    0xff001000, 0x00000083, 0xff081000, 0x00002083,
slouken@1895
  1511
    0xff101000, 0x00004083, 0xff181000, 0x00006183,
slouken@1895
  1512
    0xff201000, 0x00008183, 0xff291000, 0x0000a183,
slouken@1895
  1513
    0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
slouken@1895
  1514
    0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
slouken@1895
  1515
    0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
slouken@1895
  1516
    0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
slouken@1895
  1517
    0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
slouken@1895
  1518
    0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
slouken@1895
  1519
    0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
slouken@1895
  1520
    0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
slouken@1895
  1521
    0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
slouken@1895
  1522
    0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
slouken@1895
  1523
    0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
slouken@1895
  1524
    0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
slouken@1895
  1525
    0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
slouken@1895
  1526
    0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
slouken@1895
  1527
    0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
slouken@1895
  1528
    0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
slouken@1895
  1529
    0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
slouken@1895
  1530
    0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
slouken@1895
  1531
    0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
slouken@1895
  1532
    0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
slouken@1895
  1533
    0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
slouken@1895
  1534
    0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
slouken@1895
  1535
    0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
slouken@1895
  1536
    0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
slouken@1895
  1537
    0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
slouken@1895
  1538
    0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
slouken@1895
  1539
    0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
slouken@1895
  1540
    0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
slouken@1895
  1541
    0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
slouken@1895
  1542
    0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
slouken@1895
  1543
    0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
slouken@1895
  1544
    0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
slouken@1895
  1545
    0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
slouken@1895
  1546
    0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
slouken@1895
  1547
    0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
slouken@1895
  1548
    0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
slouken@1895
  1549
    0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
slouken@1895
  1550
    0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
slouken@1895
  1551
    0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
slouken@1895
  1552
    0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
slouken@1895
  1553
    0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
slouken@1895
  1554
    0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
slouken@1895
  1555
    0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
slouken@1895
  1556
    0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
slouken@1895
  1557
    0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
slouken@1895
  1558
    0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
slouken@1895
  1559
    0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
slouken@1895
  1560
    0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
slouken@1895
  1561
    0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
slouken@1895
  1562
    0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
slouken@1895
  1563
    0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
slouken@1895
  1564
    0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
slouken@1895
  1565
    0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
slouken@1895
  1566
    0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
slouken@1895
  1567
    0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
slouken@1895
  1568
    0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
slouken@1895
  1569
    0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
slouken@1895
  1570
    0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
slouken@1895
  1571
    0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
slouken@1895
  1572
    0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
slouken@1895
  1573
    0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
slouken@0
  1574
};
slouken@1895
  1575
static void
slouken@1895
  1576
Blit_RGB565_ABGR8888(SDL_BlitInfo * info)
slouken@0
  1577
{
slouken@0
  1578
    Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
slouken@0
  1579
}
slouken@0
  1580
slouken@0
  1581
/* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
slouken@91
  1582
static const Uint32 RGB565_RGBA8888_LUT[512] = {
slouken@1895
  1583
    0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
slouken@1895
  1584
    0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
slouken@1895
  1585
    0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
slouken@1895
  1586
    0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
slouken@1895
  1587
    0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
slouken@1895
  1588
    0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
slouken@1895
  1589
    0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
slouken@1895
  1590
    0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
slouken@1895
  1591
    0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
slouken@1895
  1592
    0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
slouken@1895
  1593
    0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
slouken@1895
  1594
    0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
slouken@1895
  1595
    0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
slouken@1895
  1596
    0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
slouken@1895
  1597
    0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
slouken@1895
  1598
    0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
slouken@1895
  1599
    0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
slouken@1895
  1600
    0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
slouken@1895
  1601
    0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
slouken@1895
  1602
    0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
slouken@1895
  1603
    0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
slouken@1895
  1604
    0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
slouken@1895
  1605
    0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
slouken@1895
  1606
    0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
slouken@1895
  1607
    0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
slouken@1895
  1608
    0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
slouken@1895
  1609
    0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
slouken@1895
  1610
    0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
slouken@1895
  1611
    0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
slouken@1895
  1612
    0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
slouken@1895
  1613
    0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
slouken@1895
  1614
    0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
slouken@1895
  1615
    0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
slouken@1895
  1616
    0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
slouken@1895
  1617
    0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
slouken@1895
  1618
    0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
slouken@1895
  1619
    0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
slouken@1895
  1620
    0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
slouken@1895
  1621
    0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
slouken@1895
  1622
    0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
slouken@1895
  1623
    0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
slouken@1895
  1624
    0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
slouken@1895
  1625
    0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
slouken@1895
  1626
    0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
slouken@1895
  1627
    0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
slouken@1895
  1628
    0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
slouken@1895
  1629
    0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
slouken@1895
  1630
    0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
slouken@1895
  1631
    0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
slouken@1895
  1632
    0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
slouken@1895
  1633
    0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
slouken@1895
  1634
    0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
slouken@1895
  1635
    0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
slouken@1895
  1636
    0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
slouken@1895
  1637
    0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
slouken@1895
  1638
    0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
slouken@1895
  1639
    0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
slouken@1895
  1640
    0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
slouken@1895
  1641
    0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
slouken@1895
  1642
    0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
slouken@1895
  1643
    0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
slouken@1895
  1644
    0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
slouken@1895
  1645
    0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
slouken@1895
  1646
    0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
slouken@1895
  1647
    0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
slouken@1895
  1648
    0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
slouken@1895
  1649
    0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
slouken@1895
  1650
    0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
slouken@1895
  1651
    0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
slouken@1895
  1652
    0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
slouken@1895
  1653
    0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
slouken@1895
  1654
    0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
slouken@1895
  1655
    0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
slouken@1895
  1656
    0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
slouken@1895
  1657
    0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
slouken@1895
  1658
    0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
slouken@1895
  1659
    0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
slouken@1895
  1660
    0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
slouken@1895
  1661
    0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
slouken@1895
  1662
    0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
slouken@1895
  1663
    0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
slouken@1895
  1664
    0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
slouken@1895
  1665
    0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
slouken@1895
  1666
    0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
slouken@1895
  1667
    0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
slouken@1895
  1668
    0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
slouken@1895
  1669
    0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
slouken@1895
  1670
    0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
slouken@1895
  1671
    0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
slouken@1895
  1672
    0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
slouken@1895
  1673
    0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
slouken@1895
  1674
    0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
slouken@1895
  1675
    0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
slouken@1895
  1676
    0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
slouken@1895
  1677
    0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
slouken@1895
  1678
    0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
slouken@1895
  1679
    0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
slouken@1895
  1680
    0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
slouken@1895
  1681
    0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
slouken@1895
  1682
    0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
slouken@1895
  1683
    0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
slouken@1895
  1684
    0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
slouken@1895
  1685
    0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
slouken@1895
  1686
    0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
slouken@1895
  1687
    0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
slouken@1895
  1688
    0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
slouken@1895
  1689
    0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
slouken@1895
  1690
    0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
slouken@1895
  1691
    0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
slouken@1895
  1692
    0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
slouken@1895
  1693
    0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
slouken@1895
  1694
    0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
slouken@1895
  1695
    0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
slouken@1895
  1696
    0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
slouken@1895
  1697
    0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
slouken@1895
  1698
    0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
slouken@1895
  1699
    0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
slouken@1895
  1700
    0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
slouken@1895
  1701
    0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
slouken@1895
  1702
    0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
slouken@1895
  1703
    0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
slouken@1895
  1704
    0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
slouken@1895
  1705
    0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
slouken@1895
  1706
    0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
slouken@1895
  1707
    0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
slouken@1895
  1708
    0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
slouken@1895
  1709
    0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
slouken@1895
  1710
    0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
slouken@0
  1711
};
slouken@1895
  1712
static void
slouken@1895
  1713
Blit_RGB565_RGBA8888(SDL_BlitInfo * info)
slouken@0
  1714
{
slouken@0
  1715
    Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
slouken@0
  1716
}
slouken@0
  1717
slouken@0
  1718
/* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
slouken@91
  1719
static const Uint32 RGB565_BGRA8888_LUT[512] = {
slouken@1895
  1720
    0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
slouken@1895
  1721
    0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
slouken@1895
  1722
    0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
slouken@1895
  1723
    0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
slouken@1895
  1724
    0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
slouken@1895
  1725
    0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
slouken@1895
  1726
    0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
slouken@1895
  1727
    0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
slouken@1895
  1728
    0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
slouken@1895
  1729
    0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
slouken@1895
  1730
    0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
slouken@1895
  1731
    0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
slouken@1895
  1732
    0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
slouken@1895
  1733
    0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
slouken@1895
  1734
    0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
slouken@1895
  1735
    0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
slouken@1895
  1736
    0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
slouken@1895
  1737
    0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
slouken@1895
  1738
    0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
slouken@1895
  1739
    0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
slouken@1895
  1740
    0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
slouken@1895
  1741
    0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
slouken@1895
  1742
    0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
slouken@1895
  1743
    0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
slouken@1895
  1744
    0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
slouken@1895
  1745
    0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
slouken@1895
  1746
    0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
slouken@1895
  1747
    0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
slouken@1895
  1748
    0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
slouken@1895
  1749
    0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
slouken@1895
  1750
    0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
slouken@1895
  1751
    0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
slouken@1895
  1752
    0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
slouken@1895
  1753
    0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
slouken@1895
  1754
    0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
slouken@1895
  1755
    0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
slouken@1895
  1756
    0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
slouken@1895
  1757
    0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
slouken@1895
  1758
    0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
slouken@1895
  1759
    0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
slouken@1895
  1760
    0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
slouken@1895
  1761
    0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
slouken@1895
  1762
    0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
slouken@1895
  1763
    0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
slouken@1895
  1764
    0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
slouken@1895
  1765
    0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
slouken@1895
  1766
    0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
slouken@1895
  1767
    0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
slouken@1895
  1768
    0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
slouken@1895
  1769
    0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
slouken@1895
  1770
    0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
slouken@1895
  1771
    0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
slouken@1895
  1772
    0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
slouken@1895
  1773
    0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
slouken@1895
  1774
    0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
slouken@1895
  1775
    0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
slouken@1895
  1776
    0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
slouken@1895
  1777
    0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
slouken@1895
  1778
    0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
slouken@1895
  1779
    0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
slouken@1895
  1780
    0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
slouken@1895
  1781
    0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
slouken@1895
  1782
    0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
slouken@1895
  1783
    0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
slouken@1895
  1784
    0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
slouken@1895
  1785
    0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
slouken@1895
  1786
    0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
slouken@1895
  1787
    0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
slouken@1895
  1788
    0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
slouken@1895
  1789
    0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
slouken@1895
  1790
    0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
slouken@1895
  1791
    0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
slouken@1895
  1792
    0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
slouken@1895
  1793
    0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
slouken@1895
  1794
    0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
slouken@1895
  1795
    0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
slouken@1895
  1796
    0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
slouken@1895
  1797
    0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
slouken@1895
  1798
    0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
slouken@1895
  1799
    0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
slouken@1895
  1800
    0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
slouken@1895
  1801
    0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
slouken@1895
  1802
    0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
slouken@1895
  1803
    0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
slouken@1895
  1804
    0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
slouken@1895
  1805
    0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
slouken@1895
  1806
    0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
slouken@1895
  1807
    0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
slouken@1895
  1808
    0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
slouken@1895
  1809
    0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
slouken@1895
  1810
    0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
slouken@1895
  1811
    0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
slouken@1895
  1812
    0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
slouken@1895
  1813
    0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
slouken@1895
  1814
    0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
slouken@1895
  1815
    0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
slouken@1895
  1816
    0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
slouken@1895
  1817
    0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
slouken@1895
  1818
    0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
slouken@1895
  1819
    0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
slouken@1895
  1820
    0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
slouken@1895
  1821
    0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
slouken@1895
  1822
    0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
slouken@1895
  1823
    0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
slouken@1895
  1824
    0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
slouken@1895
  1825
    0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
slouken@1895
  1826
    0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
slouken@1895
  1827
    0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
slouken@1895
  1828
    0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
slouken@1895
  1829
    0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
slouken@1895
  1830
    0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
slouken@1895
  1831
    0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
slouken@1895
  1832
    0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
slouken@1895
  1833
    0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
slouken@1895
  1834
    0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
slouken@1895
  1835
    0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
slouken@1895
  1836
    0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
slouken@1895
  1837
    0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
slouken@1895
  1838
    0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
slouken@1895
  1839
    0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
slouken@1895
  1840
    0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
slouken@1895
  1841
    0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
slouken@1895
  1842
    0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
slouken@1895
  1843
    0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
slouken@1895
  1844
    0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
slouken@1895
  1845
    0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
slouken@1895
  1846
    0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
slouken@1895
  1847
    0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
slouken@0
  1848
};
slouken@1895
  1849
static void
slouken@1895
  1850
Blit_RGB565_BGRA8888(SDL_BlitInfo * info)
slouken@0
  1851
{
slouken@0
  1852
    Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
slouken@0
  1853
}
slouken@0
  1854
slouken@0
  1855
/* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
slouken@0
  1856
#ifndef RGB888_RGB332
slouken@0
  1857
#define RGB888_RGB332(dst, src) { \
slouken@0
  1858
	dst = (((src)&0x00E00000)>>16)| \
slouken@0
  1859
	      (((src)&0x0000E000)>>11)| \
slouken@0
  1860
	      (((src)&0x000000C0)>>6); \
slouken@0
  1861
}
slouken@0
  1862
#endif
slouken@1895
  1863
static void
slouken@1895
  1864
Blit_RGB888_index8_map(SDL_BlitInfo * info)
slouken@0
  1865
{
slouken@0
  1866
#ifndef USE_DUFFS_LOOP
slouken@1895
  1867
    int c;
slouken@0
  1868
#endif
slouken@1895
  1869
    int Pixel;
slouken@1895
  1870
    int width, height;
slouken@1895
  1871
    Uint32 *src;
slouken@1895
  1872
    const Uint8 *map;
slouken@1895
  1873
    Uint8 *dst;
slouken@1895
  1874
    int srcskip, dstskip;
slouken@0
  1875
slouken@1895
  1876
    /* Set up some basic variables */
slouken@1895
  1877
    width = info->d_width;
slouken@1895
  1878
    height = info->d_height;
slouken@1895
  1879
    src = (Uint32 *) info->s_pixels;
slouken@1895
  1880
    srcskip = info->s_skip / 4;
slouken@1895
  1881
    dst = info->d_pixels;
slouken@1895
  1882
    dstskip = info->d_skip;
slouken@1895
  1883
    map = info->table;
slouken@0
  1884
slouken@0
  1885
#ifdef USE_DUFFS_LOOP
slouken@1895
  1886
    while (height--) {
slouken@1895
  1887
		/* *INDENT-OFF* */
slouken@0
  1888
		DUFFS_LOOP(
icculus@1162
  1889
			RGB888_RGB332(Pixel, *src);
icculus@1162
  1890
			*dst++ = map[Pixel];
slouken@0
  1891
			++src;
slouken@0
  1892
		, width);
slouken@1895
  1893
		/* *INDENT-ON* */
slouken@1895
  1894
        src += srcskip;
slouken@1895
  1895
        dst += dstskip;
slouken@1895
  1896
    }
slouken@0
  1897
#else
slouken@1895
  1898
    while (height--) {
slouken@1895
  1899
        for (c = width / 4; c; --c) {
slouken@1895
  1900
            /* Pack RGB into 8bit pixel */
slouken@1895
  1901
            RGB888_RGB332(Pixel, *src);
slouken@1895
  1902
            *dst++ = map[Pixel];
slouken@1895
  1903
            ++src;
slouken@1895
  1904
            RGB888_RGB332(Pixel, *src);
slouken@1895
  1905
            *dst++ = map[Pixel];
slouken@1895
  1906
            ++src;
slouken@1895
  1907
            RGB888_RGB332(Pixel, *src);
slouken@1895
  1908
            *dst++ = map[Pixel];
slouken@1895
  1909
            ++src;
slouken@1895
  1910
            RGB888_RGB332(Pixel, *src);
slouken@1895
  1911
            *dst++ = map[Pixel];
slouken@1895
  1912
            ++src;
slouken@1895
  1913
        }
slouken@1895
  1914
        switch (width & 3) {
slouken@1895
  1915
        case 3:
slouken@1895
  1916
            RGB888_RGB332(Pixel, *src);
slouken@1895
  1917
            *dst++ = map[Pixel];
slouken@1895
  1918
            ++src;
slouken@1895
  1919
        case 2:
slouken@1895
  1920
            RGB888_RGB332(Pixel, *src);
slouken@1895
  1921
            *dst++ = map[Pixel];
slouken@1895
  1922
            ++src;
slouken@1895
  1923
        case 1:
slouken@1895
  1924
            RGB888_RGB332(Pixel, *src);
slouken@1895
  1925
            *dst++ = map[Pixel];
slouken@1895
  1926
            ++src;
slouken@1895
  1927
        }
slouken@1895
  1928
        src += srcskip;
slouken@1895
  1929
        dst += dstskip;
slouken@1895
  1930
    }
slouken@0
  1931
#endif /* USE_DUFFS_LOOP */
slouken@0
  1932
}
slouken@1895
  1933
static void
slouken@1895
  1934
BlitNto1(SDL_BlitInfo * info)
slouken@0
  1935
{
slouken@0
  1936
#ifndef USE_DUFFS_LOOP
slouken@1895
  1937
    int c;
slouken@0
  1938
#endif
slouken@1895
  1939
    int width, height;
slouken@1895
  1940
    Uint8 *src;
slouken@1895
  1941
    const Uint8 *map;
slouken@1895
  1942
    Uint8 *dst;
slouken@1895
  1943
    int srcskip, dstskip;
slouken@1895
  1944
    int srcbpp;
slouken@1895
  1945
    Uint32 Pixel;
slouken@1895
  1946
    int sR, sG, sB;
slouken@1895
  1947
    SDL_PixelFormat *srcfmt;
slouken@0
  1948
slouken@1895
  1949
    /* Set up some basic variables */
slouken@1895
  1950
    width = info->d_width;
slouken@1895
  1951
    height = info->d_height;
slouken@1895
  1952
    src = info->s_pixels;
slouken@1895
  1953
    srcskip = info->s_skip;
slouken@1895
  1954
    dst = info->d_pixels;
slouken@1895
  1955
    dstskip = info->d_skip;
slouken@1895
  1956
    map = info->table;
slouken@1895
  1957
    srcfmt = info->src;
slouken@1895
  1958
    srcbpp = srcfmt->BytesPerPixel;
slouken@0
  1959
slouken@1895
  1960
    if (map == NULL) {
slouken@1895
  1961
        while (height--) {
slouken@0
  1962
#ifdef USE_DUFFS_LOOP
slouken@1895
  1963
			/* *INDENT-OFF* */
slouken@0
  1964
			DUFFS_LOOP(
icculus@1162
  1965
				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
slouken@0
  1966
								sR, sG, sB);
slouken@0
  1967
				if ( 1 ) {
slouken@0
  1968
				  	/* Pack RGB into 8bit pixel */
slouken@0
  1969
				  	*dst = ((sR>>5)<<(3+2))|
slouken@0
  1970
					        ((sG>>5)<<(2)) |
slouken@0
  1971
					        ((sB>>6)<<(0)) ;
slouken@0
  1972
				}
slouken@0
  1973
				dst++;
slouken@0
  1974
				src += srcbpp;
slouken@0
  1975
			, width);
slouken@1895
  1976
			/* *INDENT-ON* */
slouken@0
  1977
#else
slouken@1895
  1978
            for (c = width; c; --c) {
slouken@1895
  1979
                DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
slouken@1895
  1980
                if (1) {
slouken@1895
  1981
                    /* Pack RGB into 8bit pixel */
slouken@1895
  1982
                    *dst = ((sR >> 5) << (3 + 2)) |
slouken@1895
  1983
                        ((sG >> 5) << (2)) | ((sB >> 6) << (0));
slouken@1895
  1984
                }
slouken@1895
  1985
                dst++;
slouken@1895
  1986
                src += srcbpp;
slouken@1895
  1987
            }
slouken@0
  1988
#endif
slouken@1895
  1989
            src += srcskip;
slouken@1895
  1990
            dst += dstskip;
slouken@1895
  1991
        }
slouken@1895
  1992
    } else {
slouken@1895
  1993
        while (height--) {
slouken@0
  1994
#ifdef USE_DUFFS_LOOP
slouken@1895
  1995
			/* *INDENT-OFF* */
slouken@0
  1996
			DUFFS_LOOP(
icculus@1162
  1997
				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
slouken@0
  1998
								sR, sG, sB);
slouken@0
  1999
				if ( 1 ) {
slouken@0
  2000
				  	/* Pack RGB into 8bit pixel */
slouken@0
  2001
				  	*dst = map[((sR>>5)<<(3+2))|
slouken@0
  2002
						   ((sG>>5)<<(2))  |
slouken@0
  2003
						   ((sB>>6)<<(0))  ];
slouken@0
  2004
				}
slouken@0
  2005
				dst++;
slouken@0
  2006
				src += srcbpp;
slouken@0
  2007
			, width);
slouken@1895
  2008
			/* *INDENT-ON* */
slouken@0
  2009
#else
slouken@1895
  2010
            for (c = width; c; --c) {
slouken@1895
  2011
                DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
slouken@1895
  2012
                if (1) {
slouken@1895
  2013
                    /* Pack RGB into 8bit pixel */
slouken@1895
  2014
                    *dst = map[((sR >> 5) << (3 + 2)) |
slouken@1895
  2015
                               ((sG >> 5) << (2)) | ((sB >> 6) << (0))];
slouken@1895
  2016
                }
slouken@1895
  2017
                dst++;
slouken@1895
  2018
                src += srcbpp;
slouken@1895
  2019
            }
slouken@0
  2020
#endif /* USE_DUFFS_LOOP */
slouken@1895
  2021
            src += srcskip;
slouken@1895
  2022
            dst += dstskip;
slouken@1895
  2023
        }
slouken@1895
  2024
    }
slouken@0
  2025
}
icculus@1232
  2026
icculus@1232
  2027
/* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */
slouken@1895
  2028
static void
slouken@1895
  2029
Blit4to4MaskAlpha(SDL_BlitInfo * info)
icculus@1232
  2030
{
slouken@1895
  2031
    int width = info->d_width;
slouken@1895
  2032
    int height = info->d_height;
slouken@1895
  2033
    Uint32 *src = (Uint32 *) info->s_pixels;
slouken@1895
  2034
    int srcskip = info->s_skip;
slouken@1895
  2035
    Uint32 *dst = (Uint32 *) info->d_pixels;
slouken@1895
  2036
    int dstskip = info->d_skip;
slouken@1895
  2037
    SDL_PixelFormat *srcfmt = info->src;
slouken@1895
  2038
    SDL_PixelFormat *dstfmt = info->dst;
icculus@1232
  2039
slouken@1895
  2040
    if (dstfmt->Amask) {
slouken@1895
  2041
        /* RGB->RGBA, SET_ALPHA */
slouken@1895
  2042
        Uint32 mask = (srcfmt->alpha >> dstfmt->Aloss) << dstfmt->Ashift;
icculus@1232
  2043
slouken@1895
  2044
        while (height--) {
slouken@1895
  2045
			/* *INDENT-OFF* */
icculus@1232
  2046
			DUFFS_LOOP(
icculus@1232
  2047
			{
icculus@1232
  2048
				*dst = *src | mask;
icculus@1232
  2049
				++dst;
icculus@1232
  2050
				++src;
icculus@1232
  2051
			},
icculus@1232
  2052
			width);
slouken@1895
  2053
			/* *INDENT-ON* */
slouken@1895
  2054
            src = (Uint32 *) ((Uint8 *) src + srcskip);
slouken@1895
  2055
            dst = (Uint32 *) ((Uint8 *) dst + dstskip);
slouken@1895
  2056
        }
slouken@1895
  2057
    } else {
slouken@1895
  2058
        /* RGBA->RGB, NO_ALPHA */
slouken@1895
  2059
        Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
icculus@1232
  2060
slouken@1895
  2061
        while (height--) {
slouken@1895
  2062
			/* *INDENT-OFF* */
icculus@1232
  2063
			DUFFS_LOOP(
icculus@1232
  2064
			{
icculus@1232
  2065
				*dst = *src & mask;
icculus@1232
  2066
				++dst;
icculus@1232
  2067
				++src;
icculus@1232
  2068
			},
icculus@1232
  2069
			width);
slouken@1895
  2070
			/* *INDENT-ON* */
slouken@1895
  2071
            src = (Uint32 *) ((Uint8 *) src + srcskip);
slouken@1895
  2072
            dst = (Uint32 *) ((Uint8 *) dst + dstskip);
slouken@1895
  2073
        }
slouken@1895
  2074
    }
icculus@1232
  2075
}
icculus@1232
  2076
slouken@1895
  2077
static void
slouken@1895
  2078
BlitNtoN(SDL_BlitInfo * info)
slouken@0
  2079
{
slouken@1895
  2080
    int width = info->d_width;
slouken@1895
  2081
    int height = info->d_height;
slouken@1895
  2082
    Uint8 *src = info->s_pixels;
slouken@1895
  2083
    int srcskip = info->s_skip;
slouken@1895
  2084
    Uint8 *dst = info->d_pixels;
slouken@1895
  2085
    int dstskip = info->d_skip;
slouken@1895
  2086
    SDL_PixelFormat *srcfmt = info->src;
slouken@1895
  2087
    int srcbpp = srcfmt->BytesPerPixel;
slouken@1895
  2088
    SDL_PixelFormat *dstfmt = info->dst;
slouken@1895
  2089
    int dstbpp = dstfmt->BytesPerPixel;
slouken@1895
  2090
    unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
slouken@0
  2091
slouken@1895
  2092
    while (height--) {
slouken@1895
  2093
		/* *INDENT-OFF* */
slouken@0
  2094
		DUFFS_LOOP(
slouken@0
  2095
		{
slouken@1985
  2096
            Uint32 Pixel;
slouken@0
  2097
			unsigned sR;
slouken@0
  2098
			unsigned sG;
slouken@0
  2099
			unsigned sB;
icculus@1162
  2100
			DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
slouken@0
  2101
			ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
slouken@0
  2102
			dst += dstbpp;
slouken@0
  2103
			src += srcbpp;
slouken@0
  2104
		},
slouken@0
  2105
		width);
slouken@1895
  2106
		/* *INDENT-ON* */
slouken@1895
  2107
        src += srcskip;
slouken@1895
  2108
        dst += dstskip;
slouken@1895
  2109
    }
slouken@0
  2110
}
slouken@0
  2111
slouken@1895
  2112
static void
slouken@1895
  2113
BlitNtoNCopyAlpha(SDL_BlitInfo * info)
slouken@0
  2114
{
slouken@1895
  2115
    int width = info->d_width;
slouken@1895
  2116
    int height = info->d_height;
slouken@1895
  2117
    Uint8 *src = info->s_pixels;
slouken@1895
  2118
    int srcskip = info->s_skip;
slouken@1895
  2119
    Uint8 *dst = info->d_pixels;
slouken@1895
  2120
    int dstskip = info->d_skip;
slouken@1895
  2121
    SDL_PixelFormat *srcfmt = info->src;
slouken@1895
  2122
    int srcbpp = srcfmt->BytesPerPixel;
slouken@1895
  2123
    SDL_PixelFormat *dstfmt = info->dst;
slouken@1895
  2124
    int dstbpp = dstfmt->BytesPerPixel;
slouken@1895
  2125
    int c;
slouken@0
  2126
slouken@1895
  2127
    /* FIXME: should map alpha to [0..255] correctly! */
slouken@1895
  2128
    while (height--) {
slouken@1895
  2129
        for (c = width; c; --c) {
slouken@1895
  2130
            Uint32 Pixel;
slouken@1895
  2131
            unsigned sR, sG, sB, sA;
slouken@1895
  2132
            DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
slouken@1895
  2133
            ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
slouken@1895
  2134
            dst += dstbpp;
slouken@1895
  2135
            src += srcbpp;
slouken@1895
  2136
        }
slouken@1895
  2137
        src += srcskip;
slouken@1895
  2138
        dst += dstskip;
slouken@1895
  2139
    }
slouken@0
  2140
}
slouken@0
  2141
slouken@1895
  2142
static void
slouken@1895
  2143
BlitNto1Key(SDL_BlitInfo * info)
slouken@0
  2144
{
slouken@1895
  2145
    int width = info->d_width;
slouken@1895
  2146
    int height = info->d_height;
slouken@1895
  2147
    Uint8 *src = info->s_pixels;
slouken@1895
  2148
    int srcskip = info->s_skip;
slouken@1895
  2149
    Uint8 *dst = info->d_pixels;
slouken@1895
  2150
    int dstskip = info->d_skip;
slouken@1895
  2151
    SDL_PixelFormat *srcfmt = info->src;
slouken@1895
  2152
    const Uint8 *palmap = info->table;
slouken@1895
  2153
    Uint32 ckey = srcfmt->colorkey;
slouken@1895
  2154
    Uint32 rgbmask = ~srcfmt->Amask;
slouken@1895
  2155
    int srcbpp;
slouken@1895
  2156
    Uint32 Pixel;
slouken@1895
  2157
    unsigned sR, sG, sB;
slouken@0
  2158
slouken@1895
  2159
    /* Set up some basic variables */
slouken@1895
  2160
    srcbpp = srcfmt->BytesPerPixel;
slouken@1895
  2161
    ckey &= rgbmask;
slouken@0
  2162
slouken@1895
  2163
    if (palmap == NULL) {
slouken@1895
  2164
        while (height--) {
slouken@1895
  2165
			/* *INDENT-OFF* */
slouken@0
  2166
			DUFFS_LOOP(
slouken@0
  2167
			{
icculus@1162
  2168
				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
slouken@0
  2169
								sR, sG, sB);
icculus@1162
  2170
				if ( (Pixel & rgbmask) != ckey ) {
slouken@0
  2171
				  	/* Pack RGB into 8bit pixel */
slouken@1428
  2172
				  	*dst = (Uint8)(((sR>>5)<<(3+2))|
slouken@1428
  2173
						           ((sG>>5)<<(2)) |
slouken@1428
  2174
						           ((sB>>6)<<(0)));
slouken@0
  2175
				}
slouken@0
  2176
				dst++;
slouken@0
  2177
				src += srcbpp;
slouken@0
  2178
			},
slouken@0
  2179
			width);
slouken@1895
  2180
			/* *INDENT-ON* */
slouken@1895
  2181
            src += srcskip;
slouken@1895
  2182
            dst += dstskip;
slouken@1895
  2183
        }
slouken@1895
  2184
    } else {
slouken@1895
  2185
        while (height--) {
slouken@1895
  2186
			/* *INDENT-OFF* */
slouken@0
  2187
			DUFFS_LOOP(
slouken@0
  2188
			{
icculus@1162
  2189
				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
slouken@0
  2190
								sR, sG, sB);
icculus@1162
  2191
				if ( (Pixel & rgbmask) != ckey ) {
slouken@0
  2192
				  	/* Pack RGB into 8bit pixel */
slouken@1428
  2193
				  	*dst = (Uint8)palmap[((sR>>5)<<(3+2))|
slouken@1428
  2194
							             ((sG>>5)<<(2))  |
slouken@1428
  2195
							             ((sB>>6)<<(0))  ];
slouken@0
  2196
				}
slouken@0
  2197
				dst++;
slouken@0
  2198
				src += srcbpp;
slouken@0
  2199
			},
slouken@0
  2200
			width);
slouken@1895
  2201
			/* *INDENT-ON* */
slouken@1895
  2202
            src += srcskip;
slouken@1895
  2203
            dst += dstskip;
slouken@1895
  2204
        }
slouken@1895
  2205
    }
slouken@0
  2206
}
slouken@0
  2207
slouken@1895
  2208
static void
slouken@1895
  2209
Blit2to2Key(SDL_BlitInfo * info)
slouken@0
  2210
{
slouken@1895
  2211
    int width = info->d_width;
slouken@1895
  2212
    int height = info->d_height;
slouken@1895
  2213
    Uint16 *srcp = (Uint16 *) info->s_pixels;
slouken@1895
  2214
    int srcskip = info->s_skip;
slouken@1895
  2215
    Uint16 *dstp = (Uint16 *) info->d_pixels;
slouken@1895
  2216
    int dstskip = info->d_skip;
slouken@1895
  2217
    Uint32 ckey = info->src->colorkey;
slouken@1895
  2218
    Uint32 rgbmask = ~info->src->Amask;
slouken@0
  2219
slouken@1895
  2220
    /* Set up some basic variables */
slouken@1895
  2221
    srcskip /= 2;
slouken@1895
  2222
    dstskip /= 2;
slouken@1895
  2223
    ckey &= rgbmask;
slouken@0
  2224
slouken@1895
  2225
    while (height--) {
slouken@1895
  2226
		/* *INDENT-OFF* */
slouken@0
  2227
		DUFFS_LOOP(
slouken@0
  2228
		{
slouken@0
  2229
			if ( (*srcp & rgbmask) != ckey ) {
slouken@0
  2230
				*dstp = *srcp;
slouken@0
  2231
			}
slouken@0
  2232
			dstp++;
slouken@0
  2233
			srcp++;
slouken@0
  2234
		},
slouken@0
  2235
		width);
slouken@1895
  2236
		/* *INDENT-ON* */
slouken@1895
  2237
        srcp += srcskip;
slouken@1895
  2238
        dstp += dstskip;
slouken@1895
  2239
    }
slouken@0
  2240
}
slouken@0
  2241
slouken@1895
  2242
static void
slouken@1895
  2243
BlitNtoNKey(SDL_BlitInfo * info)
slouken@0
  2244
{
slouken@1895
  2245
    int width = info->d_width;
slouken@1895
  2246
    int height = info->d_height;
slouken@1895
  2247
    Uint8 *src = info->s_pixels;
slouken@1895
  2248
    int srcskip = info->s_skip;
slouken@1895
  2249
    Uint8 *dst = info->d_pixels;
slouken@1895
  2250
    int dstskip = info->d_skip;
slouken@1895
  2251
    Uint32 ckey = info->src->colorkey;
slouken@1895
  2252
    SDL_PixelFormat *srcfmt = info->src;
slouken@1895
  2253
    SDL_PixelFormat *dstfmt = info->dst;
slouken@1895
  2254
    int srcbpp = srcfmt->BytesPerPixel;
slouken@1895
  2255
    int dstbpp = dstfmt->BytesPerPixel;
slouken@1895
  2256
    unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
slouken@1895
  2257
    Uint32 rgbmask = ~srcfmt->Amask;
slouken@1543
  2258
slouken@1895
  2259
    /* Set up some basic variables */
slouken@1895
  2260
    ckey &= rgbmask;
slouken@0
  2261
slouken@1895
  2262
    while (height--) {
slouken@1895
  2263
		/* *INDENT-OFF* */
slouken@0
  2264
		DUFFS_LOOP(
slouken@0
  2265
		{
slouken@1985
  2266
            Uint32 Pixel;
slouken@0
  2267
			unsigned sR;
slouken@0
  2268
			unsigned sG;
slouken@0
  2269
			unsigned sB;
icculus@1162
  2270
			RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
slouken@1543
  2271
			if ( (Pixel & rgbmask) != ckey ) {
slouken@1985
  2272
                RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
slouken@1985
  2273
				ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
slouken@0
  2274
			}
slouken@0
  2275
			dst += dstbpp;
slouken@0
  2276
			src += srcbpp;
slouken@0
  2277
		},
slouken@0
  2278
		width);
slouken@1895
  2279
		/* *INDENT-ON* */
slouken@1895
  2280
        src += srcskip;
slouken@1895
  2281
        dst += dstskip;
slouken@1895
  2282
    }
slouken@0
  2283
}
slouken@0
  2284
slouken@1895
  2285
static void
slouken@1895
  2286
BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
slouken@0
  2287
{
slouken@1895
  2288
    int width = info->d_width;
slouken@1895
  2289
    int height = info->d_height;
slouken@1895
  2290
    Uint8 *src = info->s_pixels;
slouken@1895
  2291
    int srcskip = info->s_skip;
slouken@1895
  2292
    Uint8 *dst = info->d_pixels;
slouken@1895
  2293
    int dstskip = info->d_skip;
slouken@1895
  2294
    Uint32 ckey = info->src->colorkey;
slouken@1895
  2295
    SDL_PixelFormat *srcfmt = info->src;
slouken@1895
  2296
    SDL_PixelFormat *dstfmt = info->dst;
slouken@1895
  2297
    Uint32 rgbmask = ~srcfmt->Amask;
slouken@0
  2298
slouken@1895
  2299
    Uint8 srcbpp;
slouken@1895
  2300
    Uint8 dstbpp;
slouken@1895
  2301
    Uint32 Pixel;
slouken@1895
  2302
    unsigned sR, sG, sB, sA;
slouken@0
  2303
slouken@1895
  2304
    /* Set up some basic variables */
slouken@1895
  2305
    srcbpp = srcfmt->BytesPerPixel;
slouken@1895
  2306
    dstbpp = dstfmt->BytesPerPixel;
slouken@1895
  2307
    ckey &= rgbmask;
slouken@0
  2308
slouken@1895
  2309
    /* FIXME: should map alpha to [0..255] correctly! */
slouken@1895
  2310
    while (height--) {
slouken@1895
  2311
		/* *INDENT-OFF* */
slouken@0
  2312
		DUFFS_LOOP(
slouken@0
  2313
		{
slouken@1985
  2314
			DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
icculus@1162
  2315
			if ( (Pixel & rgbmask) != ckey ) {
slouken@1985
  2316
				  ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
slouken@0
  2317
			}
slouken@0
  2318
			dst += dstbpp;
slouken@0
  2319
			src += srcbpp;
slouken@0
  2320
		},
slouken@0
  2321
		width);
slouken@1895
  2322
		/* *INDENT-ON* */
slouken@1895
  2323
        src += srcskip;
slouken@1895
  2324
        dst += dstskip;
slouken@1895
  2325
    }
slouken@0
  2326
}
slouken@0
  2327
slouken@0
  2328
/* Normal N to N optimized blitters */
slouken@1895
  2329
struct blit_table
slouken@1895
  2330
{
slouken@1895
  2331
    Uint32 srcR, srcG, srcB;
slouken@1895
  2332
    int dstbpp;
slouken@1895
  2333
    Uint32 dstR, dstG, dstB;
slouken@1895
  2334
    Uint32 blit_features;
slouken@1895
  2335
    void *aux_data;
slouken@1895
  2336
    SDL_loblit blitfunc;
slouken@1895
  2337
    enum
slouken@1895
  2338
    { NO_ALPHA = 1, SET_ALPHA = 2, COPY_ALPHA = 4 } alpha;
slouken@0
  2339
};
slouken@91
  2340
static const struct blit_table normal_blit_1[] = {
slouken@1895
  2341
    /* Default for 8-bit RGB source, an invalid combination */
slouken@1895
  2342
    {0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL},
slouken@0
  2343
};
slouken@91
  2344
static const struct blit_table normal_blit_2[] = {
slouken@2247
  2345
#if SDL_ALTIVEC_BLITTERS
icculus@1047
  2346
    /* has-altivec */
slouken@1895
  2347
    {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x00000000, 0x00000000,
slouken@1895
  2348
     0x00000000,
slouken@1895
  2349
     2, NULL, Blit_RGB565_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
slouken@1895
  2350
    {0x00007C00, 0x000003E0, 0x0000001F, 4, 0x00000000, 0x00000000,
slouken@1895
  2351
     0x00000000,
slouken@1895
  2352
     2, NULL, Blit_RGB555_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
icculus@1047
  2353
#endif
slouken@1895
  2354
    {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x00FF0000, 0x0000FF00,
slouken@1895
  2355
     0x000000FF,
slouken@1895
  2356
     0, NULL, Blit_RGB565_ARGB8888, SET_ALPHA},
slouken@1895
  2357
    {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x000000FF, 0x0000FF00,
slouken@1895
  2358
     0x00FF0000,
slouken@1895
  2359
     0, NULL, Blit_RGB565_ABGR8888, SET_ALPHA},
slouken@1895
  2360
    {0x0000F800, 0x000007E0, 0x0000001F, 4, 0xFF000000, 0x00FF0000,
slouken@1895
  2361
     0x0000FF00,
slouken@1895
  2362
     0, NULL, Blit_RGB565_RGBA8888, SET_ALPHA},
slouken@1895
  2363
    {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x0000FF00, 0x00FF0000,
slouken@1895
  2364
     0xFF000000,
slouken@1895
  2365
     0, NULL, Blit_RGB565_BGRA8888, SET_ALPHA},
slouken@0
  2366
slouken@0
  2367
    /* Default for 16-bit RGB source, used if no other blitter matches */
slouken@1895
  2368
    {0, 0, 0, 0, 0, 0, 0, 0, NULL, BlitNtoN, 0}
slouken@0
  2369
};
slouken@91
  2370
static const struct blit_table normal_blit_3[] = {
slouken@1895
  2371
    /* Default for 24-bit RGB source, never optimized */
slouken@1895
  2372
    {0, 0, 0, 0, 0, 0, 0, 0, NULL, BlitNtoN, 0}
slouken@0
  2373
};
slouken@91
  2374
static const struct blit_table normal_blit_4[] = {
slouken@1361
  2375
#if SDL_ALTIVEC_BLITTERS
icculus@1047
  2376
    /* has-altivec | dont-use-prefetch */
slouken@1895
  2377
    {0x00000000, 0x00000000, 0x00000000, 4, 0x00000000, 0x00000000,
slouken@1895
  2378
     0x00000000,
slouken@1895
  2379
     6, NULL, ConvertAltivec32to32_noprefetch,
slouken@1895
  2380
     NO_ALPHA | COPY_ALPHA | SET_ALPHA},
icculus@1047
  2381
    /* has-altivec */
slouken@1895
  2382
    {0x00000000, 0x00000000, 0x00000000, 4, 0x00000000, 0x00000000,
slouken@1895
  2383
     0x00000000,
slouken@1895
  2384
     2, NULL, ConvertAltivec32to32_prefetch,
slouken@1895
  2385
     NO_ALPHA | COPY_ALPHA | SET_ALPHA},
icculus@1047
  2386
    /* has-altivec */
slouken@1895
  2387
    {0x00000000, 0x00000000, 0x00000000, 2, 0x0000F800, 0x000007E0,
slouken@1895
  2388
     0x0000001F,
slouken@1895
  2389
     2, NULL, Blit_RGB888_RGB565Altivec, NO_ALPHA},
icculus@1047
  2390
#endif
slouken@1895
  2391
    {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x0000F800, 0x000007E0,
slouken@1895
  2392
     0x0000001F,
slouken@1895
  2393
     0, NULL, Blit_RGB888_RGB565, NO_ALPHA},
slouken@1895
  2394
    {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x00007C00, 0x000003E0,
slouken@1895
  2395
     0x0000001F,
slouken@1895
  2396
     0, NULL, Blit_RGB888_RGB555, NO_ALPHA},
slouken@1895
  2397
    /* Default for 32-bit RGB source, used if no other blitter matches */
slouken@1895
  2398
    {0, 0, 0, 0, 0, 0, 0, 0, NULL, BlitNtoN, 0}
slouken@0
  2399
};
slouken@91
  2400
static const struct blit_table *normal_blit[] = {
slouken@1895
  2401
    normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
slouken@0
  2402
};
slouken@0
  2403
icculus@1047
  2404
/* Mask matches table, or table entry is zero */
icculus@1047
  2405
#define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000))
icculus@1047
  2406
slouken@1895
  2407
SDL_loblit
slouken@1895
  2408
SDL_CalculateBlitN(SDL_Surface * surface, int blit_index)
slouken@0
  2409
{
slouken@1895
  2410
    struct private_swaccel *sdata;
slouken@1895
  2411
    SDL_PixelFormat *srcfmt;
slouken@1895
  2412
    SDL_PixelFormat *dstfmt;
slouken@1895
  2413
    const struct blit_table *table;
slouken@1895
  2414
    int which;
slouken@1895
  2415
    SDL_loblit blitfun;
slouken@0
  2416
slouken@1895
  2417
    /* Set up data for choosing the blit */
slouken@1895
  2418
    sdata = surface->map->sw_data;
slouken@1895
  2419
    srcfmt = surface->format;
slouken@1895
  2420
    dstfmt = surface->map->dst->format;
slouken@0
  2421
slouken@1895
  2422
    if (blit_index & 2) {
slouken@1895
  2423
        /* alpha or alpha+colorkey */
slouken@1895
  2424
        return SDL_CalculateAlphaBlit(surface, blit_index);
slouken@1895
  2425
    }
slouken@0
  2426
slouken@1895
  2427
    /* We don't support destinations less than 8-bits */
slouken@1895
  2428
    if (dstfmt->BitsPerPixel < 8) {
slouken@1895
  2429
        return (NULL);
slouken@1895
  2430
    }
slouken@0
  2431
slouken@1895
  2432
    if (blit_index == 1) {
slouken@1895
  2433
        /* colorkey blit: Here we don't have too many options, mostly
slouken@1895
  2434
           because RLE is the preferred fast way to deal with this.
slouken@1895
  2435
           If a particular case turns out to be useful we'll add it. */
slouken@1895
  2436
slouken@1895
  2437
        if (srcfmt->BytesPerPixel == 2 && surface->map->identity)
slouken@1895
  2438
            return Blit2to2Key;
slouken@1895
  2439
        else if (dstfmt->BytesPerPixel == 1)
slouken@1895
  2440
            return BlitNto1Key;
slouken@1895
  2441
        else {
slouken@1361
  2442
#if SDL_ALTIVEC_BLITTERS
slouken@1895
  2443
            if ((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4)
slouken@1895
  2444
                && SDL_HasAltiVec()) {
slouken@1895
  2445
                return Blit32to32KeyAltivec;
slouken@1895
  2446
            } else
icculus@1047
  2447
#endif
icculus@1047
  2448
slouken@1895
  2449
            if (srcfmt->Amask && dstfmt->Amask)
slouken@1895
  2450
                return BlitNtoNKeyCopyAlpha;
slouken@1895
  2451
            else
slouken@1895
  2452
                return BlitNtoNKey;
slouken@1895
  2453
        }
slouken@1895
  2454
    }
slouken@0
  2455
slouken@1895
  2456
    blitfun = NULL;
slouken@1895
  2457
    if (dstfmt->BitsPerPixel == 8) {
slouken@1895
  2458
        /* We assume 8-bit destinations are palettized */
slouken@1895
  2459
        if ((srcfmt->BytesPerPixel == 4) &&
slouken@1895
  2460
            (srcfmt->Rmask == 0x00FF0000) &&
slouken@1895
  2461
            (srcfmt->Gmask == 0x0000FF00) && (srcfmt->Bmask == 0x000000FF)) {
slouken@1895
  2462
            if (surface->map->table) {
slouken@1895
  2463
                blitfun = Blit_RGB888_index8_map;
slouken@1895
  2464
            } else {
slouken@1895
  2465
                blitfun = Blit_RGB888_index8;
slouken@1895
  2466
            }
slouken@1895
  2467
        } else {
slouken@1895
  2468
            blitfun = BlitNto1;
slouken@1895
  2469
        }
slouken@1895
  2470
    } else {
slouken@1895
  2471
        /* Now the meat, choose the blitter we want */
slouken@1895
  2472
        int a_need = NO_ALPHA;
slouken@1895
  2473
        if (dstfmt->Amask)
slouken@1895
  2474
            a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
slouken@1895
  2475
        table = normal_blit[srcfmt->BytesPerPixel - 1];
slouken@1895
  2476
        for (which = 0; table[which].dstbpp; ++which) {
slouken@1895
  2477
            if (MASKOK(srcfmt->Rmask, table[which].srcR) &&
slouken@1895
  2478
                MASKOK(srcfmt->Gmask, table[which].srcG) &&
slouken@1895
  2479
                MASKOK(srcfmt->Bmask, table[which].srcB) &&
slouken@1895
  2480
                MASKOK(dstfmt->Rmask, table[which].dstR) &&
slouken@1895
  2481
                MASKOK(dstfmt->Gmask, table[which].dstG) &&
slouken@1895
  2482
                MASKOK(dstfmt->Bmask, table[which].dstB) &&
slouken@1895
  2483
                dstfmt->BytesPerPixel == table[which].dstbpp &&
slouken@1895
  2484
                (a_need & table[which].alpha) == a_need &&
slouken@1895
  2485
                ((table[which].blit_features & GetBlitFeatures()) ==
slouken@1895
  2486
                 table[which].blit_features))
slouken@1895
  2487
                break;
slouken@1895
  2488
        }
slouken@1895
  2489
        sdata->aux_data = table[which].aux_data;
slouken@1895
  2490
        blitfun = table[which].blitfunc;
icculus@1232
  2491
slouken@1895
  2492
        if (blitfun == BlitNtoN) {      /* default C fallback catch-all. Slow! */
slouken@1895
  2493
            /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */
slouken@1895
  2494
            if (srcfmt->BytesPerPixel == 4 && dstfmt->BytesPerPixel == 4 &&
slouken@1895
  2495
                srcfmt->Rmask == dstfmt->Rmask &&
slouken@1895
  2496
                srcfmt->Gmask == dstfmt->Gmask &&
slouken@1895
  2497
                srcfmt->Bmask == dstfmt->Bmask) {
slouken@1895
  2498
                blitfun = Blit4to4MaskAlpha;
slouken@1895
  2499
            } else if (a_need == COPY_ALPHA) {
slouken@1895
  2500
                blitfun = BlitNtoNCopyAlpha;
slouken@1895
  2501
            }
slouken@1895
  2502
        }
slouken@1895
  2503
    }
slouken@0
  2504
slouken@0
  2505
#ifdef DEBUG_ASM
slouken@1895
  2506
    if ((blitfun == BlitNtoN) || (blitfun == BlitNto1))
slouken@1895
  2507
        fprintf(stderr, "Using C blit\n");
slouken@1895
  2508
    else
slouken@1895
  2509
        fprintf(stderr, "Using optimized C blit\n");
slouken@0
  2510
#endif /* DEBUG_ASM */
slouken@0
  2511
slouken@1895
  2512
    return (blitfun);
slouken@0
  2513
}
slouken@1895
  2514
slouken@1895
  2515
/* vi: set ts=4 sw=4 expandtab: */