/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

#include "SDL_video.h"

#include "SDL_blit.h"

#if SDL_ASSEMBLY_ROUTINES

#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))

#define GCC_ASMBLIT 1

#elif defined(_MSC_VER) && (_MSC_VER >= 1200) && defined(_M_IX86)

#define MMX_ASMBLIT 1

#define MSVC_ASMBLIT 1

#elif MSVC_ASMBLIT

#include <mmintrin.h>

#include <mm3dnow.h>

#endif

/* Functions to perform alpha blended blitting */

/* N->1 blending with per-surface alpha */

static void BlitNto1SurfaceAlpha(SDL_BlitInfo *info)

{

int width = info->d_width;

int height = info->d_height;

Uint8 *src = info->s_pixels;

int srcskip = info->s_skip;

Uint8 *dst = info->d_pixels;

int dstskip = info->d_skip;

Uint8 *palmap = info->table;

SDL_PixelFormat *srcfmt = info->src;

SDL_PixelFormat *dstfmt = info->dst;

int srcbpp = srcfmt->BytesPerPixel;

const unsigned A = srcfmt->alpha;

while ( height-- ) {

DUFFS_LOOP4(

{

unsigned sR;

unsigned sG;

unsigned sB;

unsigned dR;

unsigned dG;

unsigned dB;

dR = dstfmt->palette->colors[*dst].r;

dG = dstfmt->palette->colors[*dst].g;

dB = dstfmt->palette->colors[*dst].b;

ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);

dR &= 0xff;

dG &= 0xff;

dB &= 0xff;

/* Pack RGB into 8bit pixel */

if ( palmap == NULL ) {

*dst =((dR>>5)<<(3+2))|

((dG>>5)<<(2))|

((dB>>6)<<(0));

} else {

*dst = palmap[((dR>>5)<<(3+2))|

((dG>>5)<<(2)) |

((dB>>6)<<(0))];

}

dst++;

src += srcbpp;

},

width);

src += srcskip;

dst += dstskip;

}

}

/* N->1 blending with pixel alpha */

static void BlitNto1PixelAlpha(SDL_BlitInfo *info)

{

int width = info->d_width;

int height = info->d_height;

Uint8 *src = info->s_pixels;

int srcskip = info->s_skip;

Uint8 *dst = info->d_pixels;

int dstskip = info->d_skip;

Uint8 *palmap = info->table;

SDL_PixelFormat *srcfmt = info->src;

SDL_PixelFormat *dstfmt = info->dst;

int srcbpp = srcfmt->BytesPerPixel;

/* FIXME: fix alpha bit field expansion here too? */

while ( height-- ) {

DUFFS_LOOP4(

{

unsigned sR;

unsigned sG;

unsigned sB;

unsigned sA;

unsigned dR;

unsigned dG;

unsigned dB;

dR = dstfmt->palette->colors[*dst].r;

dG = dstfmt->palette->colors[*dst].g;

dB = dstfmt->palette->colors[*dst].b;

ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB);

dR &= 0xff;

dG &= 0xff;

dB &= 0xff;

/* Pack RGB into 8bit pixel */

if ( palmap == NULL ) {

*dst =((dR>>5)<<(3+2))|

((dG>>5)<<(2))|

((dB>>6)<<(0));

} else {

*dst = palmap[((dR>>5)<<(3+2))|

((dG>>5)<<(2)) |

((dB>>6)<<(0)) ];

}

dst++;

src += srcbpp;

},

width);

src += srcskip;

dst += dstskip;

}

}

/* colorkeyed N->1 blending with per-surface alpha */

static void BlitNto1SurfaceAlphaKey(SDL_BlitInfo *info)

{

int width = info->d_width;

int height = info->d_height;

Uint8 *src = info->s_pixels;

int srcskip = info->s_skip;

Uint8 *dst = info->d_pixels;

int dstskip = info->d_skip;

Uint8 *palmap = info->table;

SDL_PixelFormat *srcfmt = info->src;

SDL_PixelFormat *dstfmt = info->dst;

int srcbpp = srcfmt->BytesPerPixel;

Uint32 ckey = srcfmt->colorkey;

const int A = srcfmt->alpha;

while ( height-- ) {

DUFFS_LOOP(

{

unsigned sR;

unsigned sG;

unsigned sB;

unsigned dR;

unsigned dG;

unsigned dB;

DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);

if ( Pixel != ckey ) {

dR = dstfmt->palette->colors[*dst].r;

dG = dstfmt->palette->colors[*dst].g;

dB = dstfmt->palette->colors[*dst].b;

ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);

dR &= 0xff;

dG &= 0xff;

dB &= 0xff;

/* Pack RGB into 8bit pixel */

if ( palmap == NULL ) {

*dst =((dR>>5)<<(3+2))|

((dG>>5)<<(2)) |

((dB>>6)<<(0));

} else {

*dst = palmap[((dR>>5)<<(3+2))|

((dG>>5)<<(2)) |

((dB>>6)<<(0)) ];

}

}

dst++;

src += srcbpp;

},

width);

src += srcskip;

dst += dstskip;

}

}

/* fast RGB888->(A)RGB888 blending with surface alpha=128 special case */

static void BlitRGBtoRGBSurfaceAlpha128MMX(SDL_BlitInfo *info)

{

int width = info->d_width;

int height = info->d_height;

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

int srcskip = info->s_skip >> 2;

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

int dstskip = info->d_skip >> 2;

Uint32 dalpha = info->dst->Amask;

Uint8 load[8];

*(Uint64 *)load = 0x00fefefe00fefefeULL;/* alpha128 mask */

movq_m2r(*load, mm4); /* alpha128 mask -> mm4 */

*(Uint64 *)load = 0x0001010100010101ULL;/* !alpha128 mask */

movq_m2r(*load, mm3); /* !alpha128 mask -> mm3 */

movd_m2r(dalpha, mm7); /* dst alpha mask */

punpckldq_r2r(mm7, mm7); /* dst alpha mask | dst alpha mask -> mm7 */

DUFFS_LOOP_DOUBLE2(

{

Uint32 s = *srcp++;

Uint32 d = *dstp;

*dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)

+ (s & d & 0x00010101)) | dalpha;

},{

movq_m2r((*dstp), mm2);/* 2 x dst -> mm2(ARGBARGB) */

movq_r2r(mm2, mm6); /* 2 x dst -> mm6(ARGBARGB) */

movq_m2r((*srcp), mm1);/* 2 x src -> mm1(ARGBARGB) */

movq_r2r(mm1, mm5); /* 2 x src -> mm5(ARGBARGB) */

pand_r2r(mm4, mm6); /* dst & mask -> mm6 */

pand_r2r(mm4, mm5); /* src & mask -> mm5 */

paddd_r2r(mm6, mm5); /* mm6 + mm5 -> mm5 */

pand_r2r(mm1, mm2); /* src & dst -> mm2 */

psrld_i2r(1, mm5); /* mm5 >> 1 -> mm5 */

pand_r2r(mm3, mm2); /* mm2 & !mask -> mm2 */

paddd_r2r(mm5, mm2); /* mm5 + mm2 -> mm2 */

por_r2r(mm7, mm2); /* mm7(full alpha) | mm2 -> mm2 */

movq_r2m(mm2, (*dstp));/* mm2 -> 2 x dst pixels */

dstp += 2;

srcp += 2;

}, width);

srcp += srcskip;

dstp += dstskip;

}

emms();

}

/* fast RGB888->(A)RGB888 blending with surface alpha */

static void BlitRGBtoRGBSurfaceAlphaMMX(SDL_BlitInfo *info)

{

if (alpha == 128 && (df->Rmask | df->Gmask | df->Bmask) == 0x00FFFFFF) {

/* only call a128 version when R,G,B occupy lower bits */

BlitRGBtoRGBSurfaceAlpha128MMX(info);

} else {

int width = info->d_width;

int height = info->d_height;

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

int srcskip = info->s_skip >> 2;

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

int dstskip = info->d_skip >> 2;

pxor_r2r(mm5, mm5); /* 0 -> mm5 */

/* form the alpha mult */

movd_m2r(alpha, mm4); /* 0000000A -> mm4 */

punpcklwd_r2r(mm4, mm4); /* 00000A0A -> mm4 */

punpckldq_r2r(mm4, mm4); /* 0A0A0A0A -> mm4 */

alpha = (0xff << df->Rshift) | (0xff << df->Gshift) | (0xff << df->Bshift);

movd_m2r(alpha, mm0); /* 00000FFF -> mm0 */

punpcklbw_r2r(mm0, mm0); /* 00FFFFFF -> mm0 */

pand_r2r(mm0, mm4); /* 0A0A0A0A -> mm4, minus 1 chan */

/* at this point mm4 can be 000A0A0A or 0A0A0A00 or another combo */

movd_m2r(df->Amask, mm7); /* dst alpha mask */

punpckldq_r2r(mm7, mm7); /* dst alpha mask | dst alpha mask -> mm7 */

while(height--) {

DUFFS_LOOP_DOUBLE2({

/* One Pixel Blend */

movd_m2r((*srcp), mm1);/* src(ARGB) -> mm1 (0000ARGB)*/

movd_m2r((*dstp), mm2);/* dst(ARGB) -> mm2 (0000ARGB)*/

punpcklbw_r2r(mm5, mm1); /* 0A0R0G0B -> mm1(src) */

punpcklbw_r2r(mm5, mm2); /* 0A0R0G0B -> mm2(dst) */

psubw_r2r(mm2, mm1);/* src - dst -> mm1 */

pmullw_r2r(mm4, mm1); /* mm1 * alpha -> mm1 */

psrlw_i2r(8, mm1); /* mm1 >> 8 -> mm1 */

paddb_r2r(mm1, mm2); /* mm1 + mm2(dst) -> mm2 */

packuswb_r2r(mm5, mm2); /* ARGBARGB -> mm2 */

por_r2r(mm7, mm2); /* mm7(full alpha) | mm2 -> mm2 */

movd_r2m(mm2, *dstp);/* mm2 -> pixel */

++srcp;

++dstp;

},{

movq_m2r((*dstp), mm2);/* 2 x dst -> mm2(ARGBARGB) */

movq_r2r(mm0, mm1); /* 2 x src -> mm1(ARGBARGB) */

movq_r2r(mm2, mm6); /* 2 x dst -> mm6(ARGBARGB) */

punpcklbw_r2r(mm5, mm0); /* low - 0A0R0G0B -> mm0(src1) */

punpckhbw_r2r(mm5, mm1); /* high - 0A0R0G0B -> mm1(src2) */

punpcklbw_r2r(mm5, mm2); /* low - 0A0R0G0B -> mm2(dst1) */

punpckhbw_r2r(mm5, mm6); /* high - 0A0R0G0B -> mm6(dst2) */

psubw_r2r(mm2, mm0);/* src1 - dst1 -> mm0 */

pmullw_r2r(mm4, mm0); /* mm0 * alpha -> mm0 */

psrlw_i2r(8, mm0); /* mm0 >> 8 -> mm1 */

paddb_r2r(mm0, mm2); /* mm0 + mm2(dst1) -> mm2 */

psubw_r2r(mm6, mm1);/* src2 - dst2 -> mm1 */

pmullw_r2r(mm4, mm1); /* mm1 * alpha -> mm1 */

psrlw_i2r(8, mm1); /* mm1 >> 8 -> mm1 */

paddb_r2r(mm1, mm6); /* mm1 + mm6(dst2) -> mm6 */

packuswb_r2r(mm6, mm2); /* ARGBARGB -> mm2 */

por_r2r(mm7, mm2); /* mm7(dst alpha) | mm2 -> mm2 */

movq_r2m(mm2, *dstp);/* mm2 -> 2 x pixel */

srcp += 2;

dstp += 2;

}, width);

srcp += srcskip;

dstp += dstskip;

}

emms();

}

}

/* fast ARGB888->(A)RGB888 blending with pixel alpha */

static void BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo *info)

{

int width = info->d_width;

int height = info->d_height;

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

int srcskip = info->s_skip >> 2;

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

int dstskip = info->d_skip >> 2;

SDL_PixelFormat* sf = info->src;

Uint32 amask = sf->Amask;

pxor_r2r(mm6, mm6); /* 0 -> mm6 */

/* form multiplication mask */

movd_m2r(sf->Amask, mm7); /* 0000F000 -> mm7 */

punpcklbw_r2r(mm7, mm7); /* FF000000 -> mm7 */

pcmpeqb_r2r(mm0, mm0); /* FFFFFFFF -> mm0 */

movq_r2r(mm0, mm3); /* FFFFFFFF -> mm3 (for later) */

pxor_r2r(mm0, mm7); /* 00FFFFFF -> mm7 (mult mask) */

/* form channel masks */

movq_r2r(mm7, mm0); /* 00FFFFFF -> mm0 */

packsswb_r2r(mm6, mm0); /* 00000FFF -> mm0 (channel mask) */

packsswb_r2r(mm6, mm3); /* 0000FFFF -> mm3 */

pxor_r2r(mm0, mm3); /* 0000F000 -> mm3 (~channel mask) */

/* get alpha channel shift */

movd_m2r(sf->Ashift, mm5); /* Ashift -> mm5 */

while(height--) {

DUFFS_LOOP4({

compositioning used (>>8 instead of /255) doesn't handle

it correctly. Also special-case alpha=0 for speed?

Benchmark this! */

if(alpha == 0) {

/* do nothing */

} else if(alpha == amask) {

/* opaque alpha -- copy RGB, keep dst alpha */

/* using MMX here to free up regular registers for other things */

movd_m2r((*srcp), mm1);/* src(ARGB) -> mm1 (0000ARGB)*/

movd_m2r((*dstp), mm2);/* dst(ARGB) -> mm2 (0000ARGB)*/

pand_r2r(mm0, mm1); /* src & chanmask -> mm1 */

pand_r2r(mm3, mm2); /* dst & ~chanmask -> mm2 */

por_r2r(mm1, mm2); /* src | dst -> mm2 */

movd_r2m(mm2, (*dstp)); /* mm2 -> dst */

} else {

movd_m2r((*srcp), mm1);/* src(ARGB) -> mm1 (0000ARGB)*/

punpcklbw_r2r(mm6, mm1); /* 0A0R0G0B -> mm1 */

movd_m2r((*dstp), mm2);/* dst(ARGB) -> mm2 (0000ARGB)*/

punpcklbw_r2r(mm6, mm2); /* 0A0R0G0B -> mm2 */

__asm__ __volatile__ (

"movd %0, %%mm4"

: : "r" (alpha) ); /* 0000A000 -> mm4 */

psrld_r2r(mm5, mm4); /* mm4 >> mm5 -> mm4 (0000000A) */

punpcklwd_r2r(mm4, mm4); /* 00000A0A -> mm4 */

punpcklwd_r2r(mm4, mm4); /* 0A0A0A0A -> mm4 */

pand_r2r(mm7, mm4); /* 000A0A0A -> mm4, preserve dst alpha on add */

/* blend */

psubw_r2r(mm2, mm1);/* src - dst -> mm1 */

pmullw_r2r(mm4, mm1); /* mm1 * alpha -> mm1 */

psrlw_i2r(8, mm1); /* mm1 >> 8 -> mm1(000R0G0B) */

paddb_r2r(mm1, mm2); /* mm1 + mm2(dst) -> mm2 */

packuswb_r2r(mm6, mm2); /* 0000ARGB -> mm2 */

movd_r2m(mm2, *dstp);/* mm2 -> dst */

}

++srcp;

++dstp;

}, width);

srcp += srcskip;

dstp += dstskip;

}

emms();

}

/* End GCC_ASMBLIT */

#elif MSVC_ASMBLIT

/* fast RGB888->(A)RGB888 blending with surface alpha=128 special case */

static void BlitRGBtoRGBSurfaceAlpha128MMX(SDL_BlitInfo *info)

{

int width = info->d_width;

int height = info->d_height;

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

int srcskip = info->s_skip >> 2;

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

int dstskip = info->d_skip >> 2;

Uint32 dalpha = info->dst->Amask;

__m64 src1, src2, dst1, dst2, lmask, hmask, dsta;

hmask = _mm_set_pi32(0x00fefefe, 0x00fefefe); /* alpha128 mask -> hmask */

lmask = _mm_set_pi32(0x00010101, 0x00010101); /* !alpha128 mask -> lmask */

dsta = _mm_set_pi32(dalpha, dalpha); /* dst alpha mask -> dsta */

while (height--) {

int n = width;

if ( n & 1 ) {

Uint32 s = *srcp++;

Uint32 d = *dstp;

*dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)

+ (s & d & 0x00010101)) | dalpha;

n--;

}

for (n >>= 1; n > 0; --n) {

dst1 = *(__m64*)dstp; /* 2 x dst -> dst1(ARGBARGB) */

dst2 = dst1; /* 2 x dst -> dst2(ARGBARGB) */

src1 = *(__m64*)srcp; /* 2 x src -> src1(ARGBARGB) */

src2 = src1; /* 2 x src -> src2(ARGBARGB) */

dst2 = _mm_and_si64(dst2, hmask); /* dst & mask -> dst2 */

src2 = _mm_and_si64(src2, hmask); /* src & mask -> src2 */

src2 = _mm_add_pi32(src2, dst2); /* dst2 + src2 -> src2 */

src2 = _mm_srli_pi32(src2, 1); /* src2 >> 1 -> src2 */

dst1 = _mm_and_si64(dst1, src1); /* src & dst -> dst1 */

dst1 = _mm_and_si64(dst1, lmask); /* dst1 & !mask -> dst1 */

dst1 = _mm_add_pi32(dst1, src2); /* src2 + dst1 -> dst1 */

dst1 = _mm_or_si64(dst1, dsta); /* dsta(full alpha) | dst1 -> dst1 */

*(__m64*)dstp = dst1; /* dst1 -> 2 x dst pixels */

dstp += 2;

srcp += 2;

}

srcp += srcskip;

dstp += dstskip;

}

_mm_empty();

}

/* fast RGB888->(A)RGB888 blending with surface alpha */

static void BlitRGBtoRGBSurfaceAlphaMMX(SDL_BlitInfo *info)

{

SDL_PixelFormat* df = info->dst;

Uint32 chanmask = df->Rmask | df->Gmask | df->Bmask;

unsigned alpha = info->src->alpha;

if (alpha == 128 && (df->Rmask | df->Gmask | df->Bmask) == 0x00FFFFFF) {

/* only call a128 version when R,G,B occupy lower bits */

BlitRGBtoRGBSurfaceAlpha128MMX(info);

} else {

int width = info->d_width;

int height = info->d_height;

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

int srcskip = info->s_skip >> 2;

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

int dstskip = info->d_skip >> 2;

Uint32 dalpha = df->Amask;

Uint32 amult;

__m64 src1, src2, dst1, dst2, mm_alpha, mm_zero, dsta;

mm_zero = _mm_setzero_si64(); /* 0 -> mm_zero */

/* form the alpha mult */

amult = alpha | (alpha << 8);

amult = amult | (amult << 16);

chanmask = (0xff << df->Rshift) | (0xff << df->Gshift) | (0xff << df->Bshift);

mm_alpha = _mm_set_pi32(0, amult & chanmask); /* 0000AAAA -> mm_alpha, minus 1 chan */

mm_alpha = _mm_unpacklo_pi8(mm_alpha, mm_zero); /* 0A0A0A0A -> mm_alpha, minus 1 chan */

/* at this point mm_alpha can be 000A0A0A or 0A0A0A00 or another combo */

dsta = _mm_set_pi32(dalpha, dalpha); /* dst alpha mask -> dsta */

while (height--) {

int n = width;

if (n & 1) {

/* One Pixel Blend */

src2 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src2 (0000ARGB)*/

src2 = _mm_unpacklo_pi8(src2, mm_zero); /* 0A0R0G0B -> src2 */

dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB)*/

dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */

src2 = _mm_sub_pi16(src2, dst1); /* src2 - dst2 -> src2 */

src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */

src2 = _mm_srli_pi16(src2, 8); /* src2 >> 8 -> src2 */

dst1 = _mm_add_pi8(src2, dst1); /* src2 + dst1 -> dst1 */

dst1 = _mm_packs_pu16(dst1, mm_zero); /* 0000ARGB -> dst1 */

dst1 = _mm_or_si64(dst1, dsta); /* dsta | dst1 -> dst1 */

*dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */

++srcp;

++dstp;

n--;

}

for (n >>= 1; n > 0; --n) {

/* Two Pixels Blend */

src1 = *(__m64*)srcp; /* 2 x src -> src1(ARGBARGB)*/

src2 = src1; /* 2 x src -> src2(ARGBARGB) */

src1 = _mm_unpacklo_pi8(src1, mm_zero); /* low - 0A0R0G0B -> src1 */

src2 = _mm_unpackhi_pi8(src2, mm_zero); /* high - 0A0R0G0B -> src2 */

dst1 = *(__m64*)dstp;/* 2 x dst -> dst1(ARGBARGB) */

dst2 = dst1; /* 2 x dst -> dst2(ARGBARGB) */

dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* low - 0A0R0G0B -> dst1 */

dst2 = _mm_unpackhi_pi8(dst2, mm_zero); /* high - 0A0R0G0B -> dst2 */

src1 = _mm_sub_pi16(src1, dst1);/* src1 - dst1 -> src1 */

src1 = _mm_mullo_pi16(src1, mm_alpha); /* src1 * alpha -> src1 */

src1 = _mm_srli_pi16(src1, 8); /* src1 >> 8 -> src1 */

dst1 = _mm_add_pi8(src1, dst1); /* src1 + dst1(dst1) -> dst1 */

src2 = _mm_sub_pi16(src2, dst2);/* src2 - dst2 -> src2 */

src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */

src2 = _mm_srli_pi16(src2, 8); /* src2 >> 8 -> src2 */

dst2 = _mm_add_pi8(src2, dst2); /* src2 + dst2(dst2) -> dst2 */

dst1 = _mm_packs_pu16(dst1, dst2); /* 0A0R0G0B(res1), 0A0R0G0B(res2) -> dst1(ARGBARGB) */

dst1 = _mm_or_si64(dst1, dsta); /* dsta | dst1 -> dst1 */

*(__m64*)dstp = dst1; /* dst1 -> 2 x pixel */

srcp += 2;

dstp += 2;

}

srcp += srcskip;

dstp += dstskip;

}

_mm_empty();

}

}

/* fast ARGB888->(A)RGB888 blending with pixel alpha */

static void BlitRGBtoRGBPixelAlphaMMX(SDL_BlitInfo *info)

{

int width = info->d_width;

int height = info->d_height;

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

int srcskip = info->s_skip >> 2;

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

int dstskip = info->d_skip >> 2;

SDL_PixelFormat* sf = info->src;

Uint32 chanmask = sf->Rmask | sf->Gmask | sf->Bmask;

Uint32 amask = sf->Amask;

Uint32 ashift = sf->Ashift;

Uint64 multmask;

__m64 src1, dst1, mm_alpha, mm_zero, dmask;

mm_zero = _mm_setzero_si64(); /* 0 -> mm_zero */

multmask = ~(0xFFFFi64 << (ashift * 2));

dmask = *(__m64*) &multmask; /* dst alpha mask -> dmask */

while(height--) {

DUFFS_LOOP4({

Uint32 alpha = *srcp & amask;

if (alpha == 0) {

/* do nothing */

} else if (alpha == amask) {

/* opaque alpha -- copy RGB, keep dst alpha */

*dstp = (*srcp & chanmask) | (*dstp & ~chanmask);

} else {

src1 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src1 (0000ARGB)*/

src1 = _mm_unpacklo_pi8(src1, mm_zero); /* 0A0R0G0B -> src1 */

dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB)*/

dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */

mm_alpha = _mm_cvtsi32_si64(alpha); /* alpha -> mm_alpha (0000000A) */

mm_alpha = _mm_srli_si64(mm_alpha, ashift); /* mm_alpha >> ashift -> mm_alpha(0000000A) */

mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha); /* 00000A0A -> mm_alpha */

mm_alpha = _mm_unpacklo_pi32(mm_alpha, mm_alpha); /* 0A0A0A0A -> mm_alpha */

mm_alpha = _mm_and_si64(mm_alpha, dmask); /* 000A0A0A -> mm_alpha, preserve dst alpha on add */

/* blend */

src1 = _mm_sub_pi16(src1, dst1);/* src1 - dst1 -> src1 */

src1 = _mm_mullo_pi16(src1, mm_alpha); /* (src1 - dst1) * alpha -> src1 */

src1 = _mm_srli_pi16(src1, 8); /* src1 >> 8 -> src1(000R0G0B) */

dst1 = _mm_add_pi8(src1, dst1); /* src1 + dst1 -> dst1(0A0R0G0B) */

dst1 = _mm_packs_pu16(dst1, mm_zero); /* 0000ARGB -> dst1 */

*dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */

}

++srcp;

++dstp;

}, width);

srcp += srcskip;

dstp += dstskip;

}

_mm_empty();

}

/* End MSVC_ASMBLIT */

#endif /* GCC_ASMBLIT, MSVC_ASMBLIT */

#if SDL_ALTIVEC_BLITTERS

#if HAVE_ALTIVEC_H

#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 VECPRINT(msg, v) do { \

vector unsigned int tmpvec = (vector unsigned int)(v); \

unsigned int *vp = (unsigned int *)&tmpvec; \

printf("%s = %08X %08X %08X %08X\n", msg, vp[0], vp[1], vp[2], vp[3]); \

} while (0)

/* the permuation vector that takes the high bytes out of all the appropriate shorts

(vector unsigned char)(

0x00, 0x10, 0x02, 0x12,

0x04, 0x14, 0x06, 0x16,

0x08, 0x18, 0x0A, 0x1A,

0x0C, 0x1C, 0x0E, 0x1E );

*/

#define VEC_MERGE_PERMUTE() (vec_add(vec_lvsl(0, (int*)NULL), (vector unsigned char)vec_splat_u16(0x0F)))

#define VEC_U32_24() (vec_add(vec_splat_u32(12), vec_splat_u32(12)))

#define VEC_ALPHA_MASK() ((vector unsigned char)vec_sl((vector unsigned int)vec_splat_s8(-1), VEC_U32_24()))

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

? vec_lvsl(0, src) \

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

#define VEC_MULTIPLY_ALPHA(vs, vd, valpha, mergePermute, v1_16, v8_16) do { \

/* vtemp1 contains source AAGGAAGGAAGGAAGG */ \

vector unsigned short vtemp1 = vec_mule(vs, valpha); \

/* vtemp2 contains source RRBBRRBBRRBBRRBB */ \

vector unsigned short vtemp2 = vec_mulo(vs, valpha); \

/* valpha2 is 255-alpha */ \

vector unsigned char valpha2 = vec_nor(valpha, valpha); \

/* vtemp3 contains dest AAGGAAGGAAGGAAGG */ \

vector unsigned short vtemp3 = vec_mule(vd, valpha2); \

/* vtemp4 contains dest RRBBRRBBRRBBRRBB */ \

vector unsigned short vtemp4 = vec_mulo(vd, valpha2); \

/* add source and dest */ \

vtemp1 = vec_add(vtemp1, vtemp3); \

vtemp2 = vec_add(vtemp2, vtemp4); \

/* vtemp1 = (vtemp1 + 1) + ((vtemp1 + 1) >> 8) */ \

vtemp1 = vec_add(vtemp1, v1_16); \

vtemp3 = vec_sr(vtemp1, v8_16); \

vtemp1 = vec_add(vtemp1, vtemp3); \

/* vtemp2 = (vtemp2 + 1) + ((vtemp2 + 1) >> 8) */ \

vtemp2 = vec_add(vtemp2, v1_16); \

vtemp4 = vec_sr(vtemp2, v8_16); \

vtemp2 = vec_add(vtemp2, vtemp4); \

/* (>>8) and get ARGBARGBARGBARGB */ \

vd = (vector unsigned char)vec_perm(vtemp1, vtemp2, mergePermute); \

} while (0)

/* 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 struct SDL_PixelFormat default_pixel_format = {

NULL, 0, 0,

0, 0, 0, 0,

16, 8, 0, 24,

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

0, 0};

if (!srcfmt) {

srcfmt = &default_pixel_format;

}

if (!dstfmt) {

dstfmt = &default_pixel_format;

}

( 0x00, 0x00, 0x00, 0x00,

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

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

0x0C, 0x0C, 0x0C, 0x0C );

vector unsigned char vswiz;

vector unsigned int srcvec;

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

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

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

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

Uint32 amask;

/* 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

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

return(vswiz);

}

static void Blit32to565PixelAlphaAltivec(SDL_BlitInfo *info)

{

int height = info->d_height;

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

int srcskip = info->s_skip;

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

int dstskip = info->d_skip;

SDL_PixelFormat *srcfmt = info->src;

vector unsigned char v0 = vec_splat_u8(0);

vector unsigned short v8_16 = vec_splat_u16(8);

vector unsigned short v1_16 = vec_splat_u16(1);

vector unsigned short v2_16 = vec_splat_u16(2);

vector unsigned short v3_16 = vec_splat_u16(3);

vector unsigned int v8_32 = vec_splat_u32(8);

vector unsigned int v16_32 = vec_add(v8_32, v8_32);

0x003f, 0x003f, 0x003f, 0x003f,

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

0x00fc, 0x00fc, 0x00fc, 0x00fc,

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

/*

0x10 - 0x1f is the alpha

0x00 - 0x0e evens are the red

0x01 - 0x0f odds are zero

*/

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_32, v16_32))

);

/*

0x00 - 0x0f is ARxx ARxx ARxx ARxx

0x11 - 0x0f odds are blue

*/

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_32)

);

/*

0x00 - 0x0f is ARxB ARxB ARxB ARxB

0x10 - 0x0e evens are green

*/

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_32, v8_32))

);

0x00, 0x02, 0x00, 0x06,

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

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

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

vector unsigned char mergePermute = VEC_MERGE_PERMUTE();

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

vector unsigned char valphaPermute = vec_and(vec_lvsl(0, (int *)NULL), vec_splat_u8(0xC));

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

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

while(height--) {

int extrawidth;

vector unsigned char valigner;

vector unsigned char vsrc;

vector unsigned char voverflow;

int width = info->d_width;

#define ONE_PIXEL_BLEND(condition, widthvar) \

while (condition) { \

if(sA) { \

unsigned short dstpixel = *((unsigned short *)dst); \

dR = (dstpixel >> 8) & 0xf8; \

dG = (dstpixel >> 3) & 0xfc; \

dB = (dstpixel << 3) & 0xf8; \

ACCURATE_ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB); \

*((unsigned short *)dst) = ( \

((dR & 0xf8) << 8) | ((dG & 0xfc) << 3) | (dB >> 3) \

); \

} \

src += 4; \

dst += 2; \

widthvar--; \

}

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

extrawidth = (width % 8);

valigner = VEC_ALIGNER(src);

vsrc = (vector unsigned char)vec_ld(0, src);

width -= extrawidth;

while (width) {

vector unsigned char valpha;

vector unsigned char vsrc1, vsrc2;

vector unsigned char vdst1, vdst2;

vector unsigned short vR, vG, vB;

vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;

/* Load 8 pixels from src as ARGB */

voverflow = (vector unsigned char)vec_ld(15, src);

vsrc = vec_perm(vsrc, voverflow, valigner);

vsrc1 = vec_perm(vsrc, vsrc, vpermute);

src += 16;

vsrc = (vector unsigned char)vec_ld(15, src);

voverflow = vec_perm(voverflow, vsrc, valigner);

vsrc2 = vec_perm(voverflow, voverflow, vpermute);

src += 16;

/* Load 8 pixels from dst as XRGB */

voverflow = vec_ld(0, dst);

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

vB = vec_sl((vector unsigned short)voverflow, v3_16);

vG = vec_sl(vB, v2_16);

vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, (vector unsigned char)vR, vredalpha1);

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

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

vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, (vector unsigned char)vR, vredalpha2);

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

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

/* Alpha blend 8 pixels as ARGB */

valpha = vec_perm(vsrc1, v0, valphaPermute);

VEC_MULTIPLY_ALPHA(vsrc1, vdst1, valpha, mergePermute, v1_16, v8_16);

valpha = vec_perm(vsrc2, v0, valphaPermute);

VEC_MULTIPLY_ALPHA(vsrc2, vdst2, valpha, mergePermute, v1_16, v8_16);

/* Convert 8 pixels to 565 */

vpixel = (vector unsigned short)vec_packpx((vector unsigned int)vdst1, (vector unsigned int)vdst2);

vgpixel = (vector unsigned short)vec_perm(vdst1, vdst2, vgmerge);

vgpixel = vec_and(vgpixel, vfc);

vgpixel = vec_sl(vgpixel, v3_16);

vrpixel = vec_sl(vpixel, v1_16);

vrpixel = vec_and(vrpixel, vf800);

vbpixel = vec_and(vpixel, v3f);

vdst1 = vec_or((vector unsigned char)vrpixel, (vector unsigned char)vgpixel);

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

/* Store 8 pixels */

vec_st(vdst1, 0, dst);

width -= 8;

dst += 16;

}

ONE_PIXEL_BLEND((extrawidth), extrawidth);

#undef ONE_PIXEL_BLEND

src += srcskip;

dst += dstskip;

}

}

static void Blit32to32SurfaceAlphaKeyAltivec(SDL_BlitInfo *info)

{

unsigned alpha = info->src->alpha;

int height = info->d_height;

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

int srcskip = info->s_skip >> 2;

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

int dstskip = info->d_skip >> 2;

SDL_PixelFormat *srcfmt = info->src;

SDL_PixelFormat *dstfmt = info->dst;

unsigned sA = srcfmt->alpha;

unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;

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

Uint32 ckey = info->src->colorkey;

vector unsigned char mergePermute;

vector unsigned char vsrcPermute;

vector unsigned char vdstPermute;

vector unsigned char vsdstPermute;

vector unsigned char valpha;

vector unsigned char valphamask;

vector unsigned char vbits;

vector unsigned char v0;

vector unsigned short v1;

vector unsigned short v8;

vector unsigned int vckey;

vector unsigned int vrgbmask;

mergePermute = VEC_MERGE_PERMUTE();

v0 = vec_splat_u8(0);

v1 = vec_splat_u16(1);

v8 = vec_splat_u16(8);

/* set the alpha to 255 on the destination surf */

valphamask = VEC_ALPHA_MASK();

vsrcPermute = calc_swizzle32(srcfmt, NULL);

vdstPermute = calc_swizzle32(NULL, dstfmt);

vsdstPermute = calc_swizzle32(dstfmt, NULL);

/* set a vector full of alpha and 255-alpha */

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

valpha = vec_splat(valpha, 0);

vbits = (vector unsigned char)vec_splat_s8(-1);

ckey &= rgbmask;

vrgbmask = vec_splat(vrgbmask, 0);

while(height--) {

int width = info->d_width;

#define ONE_PIXEL_BLEND(condition, widthvar) \

while (condition) { \

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

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

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

DISEMBLE_RGB(((Uint8 *)dstp), 4, dstfmt, Pixel, dR, dG, dB); \

ACCURATE_ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB); \

ASSEMBLE_RGBA(((Uint8 *)dstp), 4, dstfmt, dR, dG, dB, dA); \

} \

dstp++; \

srcp++; \

widthvar--; \

}

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

if (width > 0) {

int extrawidth = (width % 4);

vector unsigned char valigner = VEC_ALIGNER(srcp);

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

width -= extrawidth;

while (width) {

vector unsigned char vsel;

vector unsigned char voverflow;

vector unsigned char vd;

vector unsigned char vd_orig;

/* s = *srcp */

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

vs = vec_perm(vs, voverflow, valigner);

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

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