/*

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"

/* Functions to perform alpha blended blitting */

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

static void

BlitNto1SurfaceAlpha(SDL_BlitInfo * info)

int width = info->dst_w;

int height = info->dst_h;

Uint8 *src = info->src;

SDL_PixelFormat *srcfmt = info->src_fmt;

SDL_PixelFormat *dstfmt = info->dst_fmt;

int srcbpp = srcfmt->BytesPerPixel;

while (height--) {

/* *INDENT-OFF* */

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

/* *INDENT-ON* */

src += srcskip;

dst += dstskip;

}

}

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

static void

BlitNto1PixelAlpha(SDL_BlitInfo * info)

int width = info->dst_w;

int height = info->dst_h;

Uint8 *src = info->src;

SDL_PixelFormat *srcfmt = info->src_fmt;

SDL_PixelFormat *dstfmt = info->dst_fmt;

int srcbpp = srcfmt->BytesPerPixel;

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

while (height--) {

/* *INDENT-OFF* */

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

/* *INDENT-ON* */

src += srcskip;

dst += dstskip;

}

}

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

static void

BlitNto1SurfaceAlphaKey(SDL_BlitInfo * info)

int width = info->dst_w;

int height = info->dst_h;

Uint8 *src = info->src;

SDL_PixelFormat *srcfmt = info->src_fmt;

SDL_PixelFormat *dstfmt = info->dst_fmt;

while (height--) {

/* *INDENT-OFF* */

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

/* *INDENT-ON* */

src += srcskip;

dst += dstskip;

}

}

static void

BlitRGBtoRGBSurfaceAlpha128MMX(SDL_BlitInfo * info)

int width = info->dst_w;

int height = info->dst_h;

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

int dstskip = info->dst_skip >> 2;

Uint32 dalpha = info->dst_fmt->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)

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->dst_w;

int height = info->dst_h;

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

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->dst_w;

int height = info->dst_h;

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

int dstskip = info->dst_skip >> 2;

SDL_PixelFormat *sf = info->src_fmt;

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 <<= (ashift * 2);

multmask = ~multmask;

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

while (height--) {

/* *INDENT-OFF* */

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

/* *INDENT-ON* */

srcp += srcskip;

dstp += dstskip;

}

_mm_empty();

static void

BlitRGBtoRGBSurfaceAlpha128(SDL_BlitInfo * info)

int width = info->dst_w;

int height = info->dst_h;

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

while (height--) {

/* *INDENT-OFF* */

Uint32 s = *srcp++;

Uint32 d = *dstp;

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

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

/* *INDENT-ON* */

srcp += srcskip;

dstp += dstskip;

}

}

static void

BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo * info)

if (alpha == 128) {

BlitRGBtoRGBSurfaceAlpha128(info);

} else {

int width = info->dst_w;

int height = info->dst_h;

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

Uint32 s;

Uint32 d;

Uint32 s1;

Uint32 d1;

while (height--) {

/* *INDENT-OFF* */

s = *srcp;

d = *dstp;

s1 = s & 0xff00ff;

d1 = d & 0xff00ff;

d1 = (d1 + ((s1 - d1) * alpha >> 8))

& 0xff00ff;

s &= 0xff00;

d &= 0xff00;

d = (d + ((s - d) * alpha >> 8)) & 0xff00;

*dstp = d1 | d | 0xff000000;

++srcp;

++dstp;

}, width);

/* *INDENT-ON* */

srcp += srcskip;

dstp += dstskip;

}

}

}

static void

BlitRGBtoRGBPixelAlpha(SDL_BlitInfo * info)

int width = info->dst_w;

int height = info->dst_h;

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

while (height--) {

/* *INDENT-OFF* */

DUFFS_LOOP4({

Uint32 dalpha;

Uint32 d;

Uint32 s1;

Uint32 d1;

Uint32 s = *srcp;

Uint32 alpha = s >> 24;

/* FIXME: Here we special-case opaque alpha since the

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

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

Benchmark this! */

if(alpha) {

if(alpha == SDL_ALPHA_OPAQUE) {

/*

* take out the middle component (green), and process

* the other two in parallel. One multiply less.

*/

d = *dstp;

dalpha = d & 0xff000000;

s1 = s & 0xff00ff;

d1 = d & 0xff00ff;

d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff;

s &= 0xff00;

d &= 0xff00;

d = (d + ((s - d) * alpha >> 8)) & 0xff00;

*dstp = d1 | d | dalpha;

}

++srcp;

++dstp;

}, width);

/* *INDENT-ON* */

srcp += srcskip;

dstp += dstskip;

}

}

/* 16bpp special case for per-surface alpha=50%: blend 2 pixels in parallel */

/* blend a single 16 bit pixel at 50% */

#define BLEND16_50(d, s, mask) \

((((s & mask) + (d & mask)) >> 1) + (s & d & (~mask & 0xffff)))

/* blend two 16 bit pixels at 50% */

#define BLEND2x16_50(d, s, mask) \

(((s & (mask | mask << 16)) >> 1) + ((d & (mask | mask << 16)) >> 1) \

+ (s & d & (~(mask | mask << 16))))

static void

Blit16to16SurfaceAlpha128(SDL_BlitInfo * info, Uint16 mask)

int width = info->dst_w;

int height = info->dst_h;

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

while (height--) {

if (((uintptr_t) srcp ^ (uintptr_t) dstp) & 2) {

/*

* Source and destination not aligned, pipeline it.

* This is mostly a win for big blits but no loss for

* small ones

*/

Uint32 prev_sw;

int w = width;

/* handle odd destination */

if ((uintptr_t) dstp & 2) {

Uint16 d = *dstp, s = *srcp;

*dstp = BLEND16_50(d, s, mask);

dstp++;

srcp++;

w--;

}

srcp++; /* srcp is now 32-bit aligned */

/* bootstrap pipeline with first halfword */

prev_sw = ((Uint32 *) srcp)[-1];

while (w > 1) {

Uint32 sw, dw, s;

sw = *(Uint32 *) srcp;

dw = *(Uint32 *) dstp;

prev_sw = sw;

*(Uint32 *) dstp = BLEND2x16_50(dw, s, mask);

dstp += 2;

srcp += 2;

w -= 2;

}

/* final pixel if any */

if (w) {

Uint16 d = *dstp, s;

*dstp = BLEND16_50(d, s, mask);

srcp++;

dstp++;

}

srcp += srcskip - 1;

dstp += dstskip;

} else {

/* source and destination are aligned */

int w = width;

/* first odd pixel? */

if ((uintptr_t) srcp & 2) {

Uint16 d = *dstp, s = *srcp;

*dstp = BLEND16_50(d, s, mask);

srcp++;

dstp++;

w--;

}

/* srcp and dstp are now 32-bit aligned */

while (w > 1) {

Uint32 sw = *(Uint32 *) srcp;

Uint32 dw = *(Uint32 *) dstp;

*(Uint32 *) dstp = BLEND2x16_50(dw, sw, mask);

srcp += 2;

dstp += 2;

w -= 2;

}

/* last odd pixel? */

if (w) {

Uint16 d = *dstp, s = *srcp;

*dstp = BLEND16_50(d, s, mask);

srcp++;

dstp++;

}

srcp += srcskip;

dstp += dstskip;

}

}

}

static void

Blit565to565SurfaceAlphaMMX(SDL_BlitInfo * info)

if (alpha == 128) {

Blit16to16SurfaceAlpha128(info, 0xf7de);

} else {

int width = info->dst_w;

int height = info->dst_h;

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

Uint32 s, d;

__m64 src1, dst1, src2, dst2, gmask, bmask, mm_res, mm_alpha;

alpha &= ~(1 + 2 + 4); /* cut alpha to get the exact same behaviour */

mm_alpha = _mm_set_pi32(0, alpha); /* 0000000A -> mm_alpha */

alpha >>= 3; /* downscale alpha to 5 bits */

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

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

/* position alpha to allow for mullo and mulhi on diff channels

to reduce the number of operations */

mm_alpha = _mm_slli_si64(mm_alpha, 3);

/* Setup the 565 color channel masks */

gmask = _mm_set_pi32(0x07E007E0, 0x07E007E0); /* MASKGREEN -> gmask */

bmask = _mm_set_pi32(0x001F001F, 0x001F001F); /* MASKBLUE -> bmask */

while (height--) {

/* *INDENT-OFF* */

{

s = *srcp++;

d = *dstp;

/*

* shift out the middle component (green) to

* the high 16 bits, and process all three RGB

* components at the same time.

*/

s = (s | s << 16) & 0x07e0f81f;

d = (d | d << 16) & 0x07e0f81f;

d += (s - d) * alpha >> 5;

d &= 0x07e0f81f;

},{

s = *srcp++;

d = *dstp;

/*

* shift out the middle component (green) to

* the high 16 bits, and process all three RGB

* components at the same time.

*/

s = (s | s << 16) & 0x07e0f81f;

d = (d | d << 16) & 0x07e0f81f;

d += (s - d) * alpha >> 5;

d &= 0x07e0f81f;

s = *srcp++;

d = *dstp;

/*

* shift out the middle component (green) to

* the high 16 bits, and process all three RGB

* components at the same time.

*/

s = (s | s << 16) & 0x07e0f81f;

d = (d | d << 16) & 0x07e0f81f;

d += (s - d) * alpha >> 5;

d &= 0x07e0f81f;

},{

src1 = *(__m64*)srcp; /* 4 src pixels -> src1 */

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

/* red */