/*

Simple DirectMedia Layer

Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "../SDL_internal.h"

#include "SDL_video.h"

#include "SDL_endian.h"

#include "SDL_cpuinfo.h"

#include "SDL_blit.h"

#include "SDL_assert.h"

/* General optimized routines that write char by char */

#define HAVE_FAST_WRITE_INT8 1

/* On some CPU, it's slower than combining and write a word */

#if defined(__MIPS__)

# undef HAVE_FAST_WRITE_INT8

# define HAVE_FAST_WRITE_INT8 0

#endif

/* Functions to blit from N-bit surfaces to other surfaces */

enum blit_features {

};

#if SDL_ALTIVEC_BLITTERS

#ifdef HAVE_ALTIVEC_H

#include <altivec.h>

#endif

#ifdef __MACOSX__

#include <sys/sysctl.h>

static size_t

GetL3CacheSize(void)

{

const char key[] = "hw.l3cachesize";

u_int64_t result = 0;

size_t typeSize = sizeof(result);

int err = sysctlbyname(key, &result, &typeSize, NULL, 0);

if (0 != err)

return 0;

return result;

}

#else

static size_t

GetL3CacheSize(void)

{

/* XXX: Just guess G4 */

return 2097152;

}

#endif /* __MACOSX__ */

#if (defined(__MACOSX__) && (__GNUC__ < 4))

#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \

(vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )

#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \

(vector unsigned short) ( a,b,c,d,e,f,g,h )

#else

#define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \

(vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p }

#define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \

(vector unsigned short) { a,b,c,d,e,f,g,h }

#endif

#define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F)

#define VSWIZZLE32(a,b,c,d) (vector unsigned char) \

( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \

0x04+a, 0x04+b, 0x04+c, 0x04+d, \

0x08+a, 0x08+b, 0x08+c, 0x08+d, \

0x0C+a, 0x0C+b, 0x0C+c, 0x0C+d )

#define MAKE8888(dstfmt, r, g, b, a) \

( ((r<<dstfmt->Rshift)&dstfmt->Rmask) | \

((g<<dstfmt->Gshift)&dstfmt->Gmask) | \

((b<<dstfmt->Bshift)&dstfmt->Bmask) | \

((a<<dstfmt->Ashift)&dstfmt->Amask) )

/*

* Data Stream Touch...Altivec cache prefetching.

*

* Don't use this on a G5...however, the speed boost is very significant

* on a G4.

*/

#define DST_CHAN_SRC 1

#define DST_CHAN_DEST 2

/* macro to set DST control word value... */

#define DST_CTRL(size, count, stride) \

(((size) << 24) | ((count) << 16) | (stride))

#define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \

? vec_lvsl(0, src) \

: vec_add(vec_lvsl(8, src), vec_splat_u8(8)))

/* Calculate the permute vector used for 32->32 swizzling */

static vector unsigned char

calc_swizzle32(const SDL_PixelFormat * srcfmt, const SDL_PixelFormat * dstfmt)

{

/*

* We have to assume that the bits that aren't used by other

* colors is alpha, and it's one complete byte, since some formats

* leave alpha with a zero mask, but we should still swizzle the bits.

*/

/* ARGB */

const static const struct SDL_PixelFormat default_pixel_format = {

0, NULL, 0, 0,

{0, 0},

0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,

0, 0, 0, 0,

16, 8, 0, 24,

0, NULL

};

const vector unsigned char plus = VECUINT8_LITERAL(0x00, 0x00, 0x00, 0x00,

0x04, 0x04, 0x04, 0x04,

0x08, 0x08, 0x08, 0x08,

0x0C, 0x0C, 0x0C,

0x0C);

vector unsigned char vswiz;

vector unsigned int srcvec;

Uint32 rmask, gmask, bmask, amask;

if (!srcfmt) {

srcfmt = &default_pixel_format;

}

if (!dstfmt) {

dstfmt = &default_pixel_format;

}

#define RESHIFT(X) (3 - ((X) >> 3))

rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift);

gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift);

bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift);

/* Use zero for alpha if either surface doesn't have alpha */

if (dstfmt->Amask) {

amask =

((srcfmt->Amask) ? RESHIFT(srcfmt->

Ashift) : 0x10) << (dstfmt->Ashift);

} else {

amask =

0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^

0xFFFFFFFF);

}

#undef RESHIFT

((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask);

vswiz = vec_add(plus, (vector unsigned char) vec_splat(srcvec, 0));

return (vswiz);

}

#if defined(__powerpc__) && (SDL_BYTEORDER == SDL_LIL_ENDIAN)

/* reorder bytes for PowerPC little endian */

static vector unsigned char reorder_ppc64le_vec(vector unsigned char vpermute)

{

/* The result vector of calc_swizzle32 reorder bytes using vec_perm.

The LE transformation for vec_perm has an implicit assumption

that the permutation is being used to reorder vector elements,

not to reorder bytes within those elements.

Unfortunatly the result order is not the expected one for powerpc

little endian when the two first vector parameters of vec_perm are

not of type 'vector char'. This is because the numbering from the

left for BE, and numbering from the right for LE, produces a

different interpretation of what the odd and even lanes are.

Refer to fedora bug 1392465

*/

const vector unsigned char ppc64le_reorder = VECUINT8_LITERAL(

0x01, 0x00, 0x03, 0x02,

0x05, 0x04, 0x07, 0x06,

0x09, 0x08, 0x0B, 0x0A,

0x0D, 0x0C, 0x0F, 0x0E );

vector unsigned char vswiz_ppc64le;

vswiz_ppc64le = vec_perm(vpermute, vpermute, ppc64le_reorder);

return(vswiz_ppc64le);

}

#endif

static void Blit_RGB888_RGB565(SDL_BlitInfo * info);

static void

Blit_RGB888_RGB565Altivec(SDL_BlitInfo * info)

{

int height = info->dst_h;

Uint8 *src = (Uint8 *) info->src;

int srcskip = info->src_skip;

Uint8 *dst = (Uint8 *) info->dst;

int dstskip = info->dst_skip;

SDL_PixelFormat *srcfmt = info->src_fmt;

vector unsigned char valpha = vec_splat_u8(0);

vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);

vector unsigned char vgmerge = VECUINT8_LITERAL(0x00, 0x02, 0x00, 0x06,

0x00, 0x0a, 0x00, 0x0e,

0x00, 0x12, 0x00, 0x16,

0x00, 0x1a, 0x00, 0x1e);

vector unsigned short v1 = vec_splat_u16(1);

vector unsigned short v3 = vec_splat_u16(3);

vector unsigned short v3f =

VECUINT16_LITERAL(0x003f, 0x003f, 0x003f, 0x003f,

0x003f, 0x003f, 0x003f, 0x003f);

vector unsigned short vfc =

VECUINT16_LITERAL(0x00fc, 0x00fc, 0x00fc, 0x00fc,

0x00fc, 0x00fc, 0x00fc, 0x00fc);

vector unsigned short vf800 = (vector unsigned short) vec_splat_u8(-7);

vf800 = vec_sl(vf800, vec_splat_u16(8));

while (height--) {

vector unsigned char valigner;

vector unsigned char voverflow;

vector unsigned char vsrc;

int width = info->dst_w;

int extrawidth;

/* do scalar until we can align... */

#define ONE_PIXEL_BLEND(condition, widthvar) \

while (condition) { \

Uint32 Pixel; \

unsigned sR, sG, sB, sA; \

DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \

sR, sG, sB, sA); \

*(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \

((sG << 3) & 0x000007E0) | \

((sB >> 3) & 0x0000001F)); \

dst += 2; \

src += 4; \

widthvar--; \

}

ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);

/* After all that work, here's the vector part! */

extrawidth = (width % 8); /* trailing unaligned stores */

width -= extrawidth;

vsrc = vec_ld(0, src);

valigner = VEC_ALIGNER(src);

while (width) {

vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;

vector unsigned int vsrc1, vsrc2;

vector unsigned char vdst;

voverflow = vec_ld(15, src);

vsrc = vec_perm(vsrc, voverflow, valigner);

vsrc1 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);

src += 16;

vsrc = voverflow;

voverflow = vec_ld(15, src);

vsrc = vec_perm(vsrc, voverflow, valigner);

vsrc2 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);

/* 1555 */

vpixel = (vector unsigned short) vec_packpx(vsrc1, vsrc2);

vgpixel = (vector unsigned short) vec_perm(vsrc1, vsrc2, vgmerge);

vgpixel = vec_and(vgpixel, vfc);

vgpixel = vec_sl(vgpixel, v3);

vrpixel = vec_sl(vpixel, v1);

vrpixel = vec_and(vrpixel, vf800);

vbpixel = vec_and(vpixel, v3f);

vdst =

vec_or((vector unsigned char) vrpixel,

(vector unsigned char) vgpixel);

/* 565 */

vdst = vec_or(vdst, (vector unsigned char) vbpixel);

vec_st(vdst, 0, dst);

width -= 8;

src += 16;

dst += 16;

vsrc = voverflow;

}

SDL_assert(width == 0);

/* do scalar until we can align... */

ONE_PIXEL_BLEND((extrawidth), extrawidth);

#undef ONE_PIXEL_BLEND

src += srcskip; /* move to next row, accounting for pitch. */

dst += dstskip;

}

}

static void

Blit_RGB565_32Altivec(SDL_BlitInfo * info)

{

int height = info->dst_h;

Uint8 *src = (Uint8 *) info->src;

int srcskip = info->src_skip;

Uint8 *dst = (Uint8 *) info->dst;

int dstskip = info->dst_skip;

SDL_PixelFormat *srcfmt = info->src_fmt;

SDL_PixelFormat *dstfmt = info->dst_fmt;

unsigned alpha;

vector unsigned char valpha;

vector unsigned char vpermute;

vector unsigned short vf800;

vector unsigned int v8 = vec_splat_u32(8);

vector unsigned int v16 = vec_add(v8, v8);

vector unsigned short v2 = vec_splat_u16(2);

vector unsigned short v3 = vec_splat_u16(3);

/*

0x10 - 0x1f is the alpha

0x00 - 0x0e evens are the red

0x01 - 0x0f odds are zero

*/

vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,

0x10, 0x02, 0x01, 0x01,

0x10, 0x04, 0x01, 0x01,

0x10, 0x06, 0x01,

0x01);

vector unsigned char vredalpha2 =

(vector unsigned

char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))

);

/*

0x00 - 0x0f is ARxx ARxx ARxx ARxx

0x11 - 0x0f odds are blue

*/

vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,

0x04, 0x05, 0x06, 0x13,

0x08, 0x09, 0x0a, 0x15,

0x0c, 0x0d, 0x0e, 0x17);

vector unsigned char vblue2 =

(vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)

);

/*

0x00 - 0x0f is ARxB ARxB ARxB ARxB

0x10 - 0x0e evens are green

*/

vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,

0x04, 0x05, 0x12, 0x07,

0x08, 0x09, 0x14, 0x0b,

0x0c, 0x0d, 0x16, 0x0f);

vector unsigned char vgreen2 =

(vector unsigned

char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))

);

SDL_assert(srcfmt->BytesPerPixel == 2);

SDL_assert(dstfmt->BytesPerPixel == 4);

vf800 = (vector unsigned short) vec_splat_u8(-7);

vf800 = vec_sl(vf800, vec_splat_u16(8));

if (dstfmt->Amask && info->a) {

((unsigned char *) &valpha)[0] = alpha = info->a;

valpha = vec_splat(valpha, 0);

} else {

alpha = 0;

valpha = vec_splat_u8(0);

}

vpermute = calc_swizzle32(NULL, dstfmt);

while (height--) {

vector unsigned char valigner;

vector unsigned char voverflow;

vector unsigned char vsrc;

int width = info->dst_w;

int extrawidth;

/* do scalar until we can align... */

#define ONE_PIXEL_BLEND(condition, widthvar) \

while (condition) { \

unsigned sR, sG, sB; \

unsigned short Pixel = *((unsigned short *)src); \

sR = (Pixel >> 8) & 0xf8; \

sG = (Pixel >> 3) & 0xfc; \

sB = (Pixel << 3) & 0xf8; \

ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \

src += 2; \

dst += 4; \

widthvar--; \

}

ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);

/* After all that work, here's the vector part! */

extrawidth = (width % 8); /* trailing unaligned stores */

width -= extrawidth;

vsrc = vec_ld(0, src);

valigner = VEC_ALIGNER(src);

while (width) {

vector unsigned short vR, vG, vB;

vector unsigned char vdst1, vdst2;

voverflow = vec_ld(15, src);

vsrc = vec_perm(vsrc, voverflow, valigner);

vR = vec_and((vector unsigned short) vsrc, vf800);

vB = vec_sl((vector unsigned short) vsrc, v3);

vG = vec_sl(vB, v2);

vdst1 =

(vector unsigned char) vec_perm((vector unsigned char) vR,

valpha, vredalpha1);

vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);

vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);

vdst1 = vec_perm(vdst1, valpha, vpermute);

vec_st(vdst1, 0, dst);

vdst2 =

(vector unsigned char) vec_perm((vector unsigned char) vR,

valpha, vredalpha2);

vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);

vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);

vdst2 = vec_perm(vdst2, valpha, vpermute);

vec_st(vdst2, 16, dst);

width -= 8;

dst += 32;

src += 16;

vsrc = voverflow;

}

SDL_assert(width == 0);

/* do scalar until we can align... */

ONE_PIXEL_BLEND((extrawidth), extrawidth);

#undef ONE_PIXEL_BLEND

src += srcskip; /* move to next row, accounting for pitch. */

dst += dstskip;

}

}

static void

Blit_RGB555_32Altivec(SDL_BlitInfo * info)

{

int height = info->dst_h;

Uint8 *src = (Uint8 *) info->src;

int srcskip = info->src_skip;

Uint8 *dst = (Uint8 *) info->dst;

int dstskip = info->dst_skip;

SDL_PixelFormat *srcfmt = info->src_fmt;

SDL_PixelFormat *dstfmt = info->dst_fmt;

unsigned alpha;

vector unsigned char valpha;

vector unsigned char vpermute;

vector unsigned short vf800;

vector unsigned int v8 = vec_splat_u32(8);

vector unsigned int v16 = vec_add(v8, v8);

vector unsigned short v1 = vec_splat_u16(1);

vector unsigned short v3 = vec_splat_u16(3);

/*

0x10 - 0x1f is the alpha

0x00 - 0x0e evens are the red

0x01 - 0x0f odds are zero

*/

vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,

0x10, 0x02, 0x01, 0x01,

0x10, 0x04, 0x01, 0x01,

0x10, 0x06, 0x01,

0x01);

vector unsigned char vredalpha2 =

(vector unsigned

char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))

);

/*

0x00 - 0x0f is ARxx ARxx ARxx ARxx

0x11 - 0x0f odds are blue

*/

vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,

0x04, 0x05, 0x06, 0x13,

0x08, 0x09, 0x0a, 0x15,

0x0c, 0x0d, 0x0e, 0x17);

vector unsigned char vblue2 =

(vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)

);

/*

0x00 - 0x0f is ARxB ARxB ARxB ARxB

0x10 - 0x0e evens are green

*/

vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,

0x04, 0x05, 0x12, 0x07,

0x08, 0x09, 0x14, 0x0b,

0x0c, 0x0d, 0x16, 0x0f);

vector unsigned char vgreen2 =

(vector unsigned

char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))

);

SDL_assert(srcfmt->BytesPerPixel == 2);

SDL_assert(dstfmt->BytesPerPixel == 4);

vf800 = (vector unsigned short) vec_splat_u8(-7);

vf800 = vec_sl(vf800, vec_splat_u16(8));

if (dstfmt->Amask && info->a) {

((unsigned char *) &valpha)[0] = alpha = info->a;

valpha = vec_splat(valpha, 0);

} else {

alpha = 0;

valpha = vec_splat_u8(0);

}

vpermute = calc_swizzle32(NULL, dstfmt);

while (height--) {

vector unsigned char valigner;

vector unsigned char voverflow;

vector unsigned char vsrc;

int width = info->dst_w;

int extrawidth;

/* do scalar until we can align... */

#define ONE_PIXEL_BLEND(condition, widthvar) \

while (condition) { \

unsigned sR, sG, sB; \

unsigned short Pixel = *((unsigned short *)src); \

sR = (Pixel >> 7) & 0xf8; \

sG = (Pixel >> 2) & 0xf8; \

sB = (Pixel << 3) & 0xf8; \

ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \

src += 2; \

dst += 4; \

widthvar--; \

}

ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);

/* After all that work, here's the vector part! */

extrawidth = (width % 8); /* trailing unaligned stores */

width -= extrawidth;

vsrc = vec_ld(0, src);

valigner = VEC_ALIGNER(src);

while (width) {

vector unsigned short vR, vG, vB;

vector unsigned char vdst1, vdst2;

voverflow = vec_ld(15, src);

vsrc = vec_perm(vsrc, voverflow, valigner);

vR = vec_and(vec_sl((vector unsigned short) vsrc, v1), vf800);

vB = vec_sl((vector unsigned short) vsrc, v3);

vG = vec_sl(vB, v3);

vdst1 =

(vector unsigned char) vec_perm((vector unsigned char) vR,

valpha, vredalpha1);

vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);

vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);

vdst1 = vec_perm(vdst1, valpha, vpermute);

vec_st(vdst1, 0, dst);

vdst2 =

(vector unsigned char) vec_perm((vector unsigned char) vR,

valpha, vredalpha2);

vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);

vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);

vdst2 = vec_perm(vdst2, valpha, vpermute);

vec_st(vdst2, 16, dst);

width -= 8;

dst += 32;

src += 16;

vsrc = voverflow;

}

SDL_assert(width == 0);

/* do scalar until we can align... */

ONE_PIXEL_BLEND((extrawidth), extrawidth);

#undef ONE_PIXEL_BLEND

src += srcskip; /* move to next row, accounting for pitch. */

dst += dstskip;

}

}

static void BlitNtoNKey(SDL_BlitInfo * info);

static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info);

static void

Blit32to32KeyAltivec(SDL_BlitInfo * info)

{

int height = info->dst_h;

Uint32 *srcp = (Uint32 *) info->src;

int srcskip = info->src_skip / 4;

Uint32 *dstp = (Uint32 *) info->dst;

int dstskip = info->dst_skip / 4;

SDL_PixelFormat *srcfmt = info->src_fmt;

int srcbpp = srcfmt->BytesPerPixel;

SDL_PixelFormat *dstfmt = info->dst_fmt;

int dstbpp = dstfmt->BytesPerPixel;

int copy_alpha = (srcfmt->Amask && dstfmt->Amask);

unsigned alpha = dstfmt->Amask ? info->a : 0;

Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;

Uint32 ckey = info->colorkey;

vector unsigned int valpha;

vector unsigned char vpermute;

vector unsigned char vzero;

vector unsigned int vckey;

vector unsigned int vrgbmask;

vpermute = calc_swizzle32(srcfmt, dstfmt);

if (info->dst_w < 16) {

if (copy_alpha) {

BlitNtoNKeyCopyAlpha(info);

} else {

BlitNtoNKey(info);

}

return;

}

vzero = vec_splat_u8(0);

if (alpha) {

((unsigned char *) &valpha)[0] = (unsigned char) alpha;

valpha =

(vector unsigned int) vec_splat((vector unsigned char) valpha, 0);

} else {

valpha = (vector unsigned int) vzero;

}

ckey &= rgbmask;

((unsigned int *) (char *) &vckey)[0] = ckey;

vckey = vec_splat(vckey, 0);

((unsigned int *) (char *) &vrgbmask)[0] = rgbmask;

vrgbmask = vec_splat(vrgbmask, 0);

while (height--) {

#define ONE_PIXEL_BLEND(condition, widthvar) \

if (copy_alpha) { \

while (condition) { \

Uint32 Pixel; \

unsigned sR, sG, sB, sA; \

DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \

sR, sG, sB, sA); \

if ( (Pixel & rgbmask) != ckey ) { \

ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \

sR, sG, sB, sA); \

} \

dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \

srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \

widthvar--; \

} \

} else { \

while (condition) { \

Uint32 Pixel; \

unsigned sR, sG, sB; \

RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \

if ( Pixel != ckey ) { \

RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \

ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \

sR, sG, sB, alpha); \

} \

dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \

srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \

widthvar--; \

} \

}

int width = info->dst_w;

ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width);

SDL_assert(width > 0);

if (width > 0) {

int extrawidth = (width % 4);

vector unsigned char valigner = VEC_ALIGNER(srcp);

vector unsigned int vs = vec_ld(0, srcp);

width -= extrawidth;

SDL_assert(width >= 4);

while (width) {

vector unsigned char vsel;

vector unsigned int vd;

vector unsigned int voverflow = vec_ld(15, srcp);

/* load the source vec */

vs = vec_perm(vs, voverflow, valigner);

/* vsel is set for items that match the key */

vsel = (vector unsigned char) vec_and(vs, vrgbmask);

vsel = (vector unsigned char) vec_cmpeq(vs, vckey);

#if defined(__powerpc__) && (SDL_BYTEORDER == SDL_LIL_ENDIAN)

/* reorder bytes for PowerPC little endian */

vpermute = reorder_ppc64le_vec(vpermute);

#endif

/* permute the src vec to the dest format */

vs = vec_perm(vs, valpha, vpermute);

/* load the destination vec */

vd = vec_ld(0, dstp);

/* select the source and dest into vs */

vd = (vector unsigned int) vec_sel((vector unsigned char) vs,

(vector unsigned char) vd,

vsel);

vec_st(vd, 0, dstp);

srcp += 4;

width -= 4;

dstp += 4;

vs = voverflow;

}

ONE_PIXEL_BLEND((extrawidth), extrawidth);

#undef ONE_PIXEL_BLEND

srcp += srcskip;

dstp += dstskip;

}

}

}

/* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */

/* Use this on a G5 */

static void

ConvertAltivec32to32_noprefetch(SDL_BlitInfo * info)

{

int height = info->dst_h;

Uint32 *src = (Uint32 *) info->src;

int srcskip = info->src_skip / 4;

Uint32 *dst = (Uint32 *) info->dst;

int dstskip = info->dst_skip / 4;

SDL_PixelFormat *srcfmt = info->src_fmt;

SDL_PixelFormat *dstfmt = info->dst_fmt;

vector unsigned int vzero = vec_splat_u32(0);

vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);

if (dstfmt->Amask && !srcfmt->Amask) {

if (info->a) {

vector unsigned char valpha;

((unsigned char *) &valpha)[0] = info->a;

vzero = (vector unsigned int) vec_splat(valpha, 0);

}

}

SDL_assert(srcfmt->BytesPerPixel == 4);

SDL_assert(dstfmt->BytesPerPixel == 4);

while (height--) {

vector unsigned char valigner;

vector unsigned int vbits;

vector unsigned int voverflow;

Uint32 bits;

Uint8 r, g, b, a;

int width = info->dst_w;

int extrawidth;

/* do scalar until we can align... */

while ((UNALIGNED_PTR(dst)) && (width)) {

bits = *(src++);

RGBA_FROM_8888(bits, srcfmt, r, g, b, a);

if(!srcfmt->Amask)

a = info->a;

*(dst++) = MAKE8888(dstfmt, r, g, b, a);

width--;

}

/* After all that work, here's the vector part! */

extrawidth = (width % 4);

width -= extrawidth;

valigner = VEC_ALIGNER(src);

vbits = vec_ld(0, src);

while (width) {

voverflow = vec_ld(15, src);

src += 4;

width -= 4;

vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */

#if defined(__powerpc__) && (SDL_BYTEORDER == SDL_LIL_ENDIAN)

/* reorder bytes for PowerPC little endian */

vpermute = reorder_ppc64le_vec(vpermute);

#endif

vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */

vec_st(vbits, 0, dst); /* store it back out. */

dst += 4;

vbits = voverflow;

}

SDL_assert(width == 0);

/* cover pixels at the end of the row that didn't fit in 16 bytes. */

while (extrawidth) {

bits = *(src++); /* max 7 pixels, don't bother with prefetch. */

RGBA_FROM_8888(bits, srcfmt, r, g, b, a);

if(!srcfmt->Amask)

a = info->a;

*(dst++) = MAKE8888(dstfmt, r, g, b, a);

extrawidth--;

}

src += srcskip;

dst += dstskip;

}

}

/* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */

/* Use this on a G4 */

static void

ConvertAltivec32to32_prefetch(SDL_BlitInfo * info)

{

const int scalar_dst_lead = sizeof(Uint32) * 4;

const int vector_dst_lead = sizeof(Uint32) * 16;

int height = info->dst_h;

Uint32 *src = (Uint32 *) info->src;

int srcskip = info->src_skip / 4;

Uint32 *dst = (Uint32 *) info->dst;

int dstskip = info->dst_skip / 4;

SDL_PixelFormat *srcfmt = info->src_fmt;

SDL_PixelFormat *dstfmt = info->dst_fmt;

vector unsigned int vzero = vec_splat_u32(0);

vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);

if (dstfmt->Amask && !srcfmt->Amask) {

if (info->a) {

vector unsigned char valpha;

((unsigned char *) &valpha)[0] = info->a;

vzero = (vector unsigned int) vec_splat(valpha, 0);

}

}

SDL_assert(srcfmt->BytesPerPixel == 4);

SDL_assert(dstfmt->BytesPerPixel == 4);

while (height--) {

vector unsigned char valigner;

vector unsigned int vbits;

vector unsigned int voverflow;

Uint32 bits;

Uint8 r, g, b, a;

int width = info->dst_w;

int extrawidth;

/* do scalar until we can align... */

while ((UNALIGNED_PTR(dst)) && (width)) {

vec_dstt(src + scalar_dst_lead, DST_CTRL(2, 32, 1024),

DST_CHAN_SRC);

vec_dstst(dst + scalar_dst_lead, DST_CTRL(2, 32, 1024),

DST_CHAN_DEST);

bits = *(src++);

RGBA_FROM_8888(bits, srcfmt, r, g, b, a);

if(!srcfmt->Amask)

a = info->a;

*(dst++) = MAKE8888(dstfmt, r, g, b, a);

width--;

}

/* After all that work, here's the vector part! */

extrawidth = (width % 4);

width -= extrawidth;

valigner = VEC_ALIGNER(src);

vbits = vec_ld(0, src);

while (width) {

vec_dstt(src + vector_dst_lead, DST_CTRL(2, 32, 1024),

DST_CHAN_SRC);

vec_dstst(dst + vector_dst_lead, DST_CTRL(2, 32, 1024),

DST_CHAN_DEST);

voverflow = vec_ld(15, src);

src += 4;

width -= 4;

vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */

#if defined(__powerpc__) && (SDL_BYTEORDER == SDL_LIL_ENDIAN)

/* reorder bytes for PowerPC little endian */

vpermute = reorder_ppc64le_vec(vpermute);

#endif

vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */

vec_st(vbits, 0, dst); /* store it back out. */

dst += 4;

vbits = voverflow;

}

SDL_assert(width == 0);

/* cover pixels at the end of the row that didn't fit in 16 bytes. */

while (extrawidth) {

bits = *(src++); /* max 7 pixels, don't bother with prefetch. */

RGBA_FROM_8888(bits, srcfmt, r, g, b, a);

if(!srcfmt->Amask)

a = info->a;

*(dst++) = MAKE8888(dstfmt, r, g, b, a);

extrawidth--;

}

src += srcskip;

dst += dstskip;

}

vec_dss(DST_CHAN_SRC);

vec_dss(DST_CHAN_DEST);

}

static enum blit_features

GetBlitFeatures(void)

{

static enum blit_features features = -1;

if (features == (enum blit_features) -1) {

/* Provide an override for testing .. */

char *override = SDL_getenv("SDL_ALTIVEC_BLIT_FEATURES");

if (override) {

unsigned int features_as_uint = 0;

SDL_sscanf(override, "%u", &features_as_uint);

features = (enum blit_features) features_as_uint;

} else {

features = (0

/* Feature 1 is has-MMX */

| ((SDL_HasMMX())? BLIT_FEATURE_HAS_MMX : 0)

/* Feature 2 is has-AltiVec */

| ((SDL_HasAltiVec())? BLIT_FEATURE_HAS_ALTIVEC : 0)

/* Feature 4 is dont-use-prefetch */

/* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */

| ((GetL3CacheSize() == 0) ? BLIT_FEATURE_ALTIVEC_DONT_USE_PREFETCH : 0)

);

}

}

return features;

}

#if __MWERKS__

#pragma altivec_model off

#endif

#else

/* Feature 1 is has-MMX */

#define GetBlitFeatures() ((SDL_HasMMX() ? BLIT_FEATURE_HAS_MMX : 0) | (SDL_HasARMSIMD() ? BLIT_FEATURE_HAS_ARM_SIMD : 0))

#endif

#if SDL_ARM_SIMD_BLITTERS

void Blit_BGR888_RGB888ARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint32_t *src, int32_t src_stride);

static void

Blit_BGR888_RGB888ARMSIMD(SDL_BlitInfo * info)

{

int32_t width = info->dst_w;

int32_t height = info->dst_h;

uint32_t *dstp = (uint32_t *)info->dst;

int32_t dststride = width + (info->dst_skip >> 2);

uint32_t *srcp = (uint32_t *)info->src;

int32_t srcstride = width + (info->src_skip >> 2);

Blit_BGR888_RGB888ARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);

}

void Blit_RGB444_RGB888ARMSIMDAsm(int32_t w, int32_t h, uint32_t *dst, int32_t dst_stride, uint16_t *src, int32_t src_stride);

static void

Blit_RGB444_RGB888ARMSIMD(SDL_BlitInfo * info)

{

int32_t width = info->dst_w;

int32_t height = info->dst_h;

uint32_t *dstp = (uint32_t *)info->dst;

int32_t dststride = width + (info->dst_skip >> 2);

uint16_t *srcp = (uint16_t *)info->src;

int32_t srcstride = width + (info->src_skip >> 1);

Blit_RGB444_RGB888ARMSIMDAsm(width, height, dstp, dststride, srcp, srcstride);

}

#endif

/* This is now endian dependent */

#if SDL_BYTEORDER == SDL_LIL_ENDIAN

#define HI 1

#define LO 0

#else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */

#define HI 0

#define LO 1

#endif

/* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */

#define RGB888_RGB332(dst, src) { \

dst = (Uint8)((((src)&0x00E00000)>>16)| \

(((src)&0x0000E000)>>11)| \

(((src)&0x000000C0)>>6)); \

}

static void

Blit_RGB888_index8(SDL_BlitInfo * info)

{

#ifndef USE_DUFFS_LOOP

int c;

#endif

int width, height;

Uint32 *src;

const Uint8 *map;

Uint8 *dst;

int srcskip, dstskip;

/* Set up some basic variables */

width = info->dst_w;

height = info->dst_h;