/*

 * Copyright © 2007 Luca Barbato

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of Luca Barbato not be used in advertising or

 * publicity pertaining to distribution of the software without specific,

 * written prior permission.  Luca Barbato makes no representations about the

 * suitability of this software for any purpose.  It is provided "as is"

 * without express or implied warranty.

 *

 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS

 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN

 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

 * SOFTWARE.

 *

 * Author:  Luca Barbato (lu_zero@gentoo.org)

 *

 * Based on fbmmx.c by Owen Taylor, Søren Sandmann and Nicholas Miell

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "pixman-private.h"

#include "pixman-combine32.h"

#include "pixman-inlines.h"

#include <altivec.h>

#define AVV(x...) {x}

static vector unsigned int mask_ff000000;

static vector unsigned int mask_red;

static vector unsigned int mask_green;

static vector unsigned int mask_blue;

static vector unsigned int mask_565_fix_rb;

static vector unsigned int mask_565_fix_g;

static force_inline vector unsigned int

splat_alpha (vector unsigned int pix)

{

#ifdef WORDS_BIGENDIAN

    return vec_perm (pix, pix,

		     (vector unsigned char)AVV (

			 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04,

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

#else

    return vec_perm (pix, pix,

		     (vector unsigned char)AVV (

			 0x03, 0x03, 0x03, 0x03, 0x07, 0x07, 0x07, 0x07,

			 0x0B, 0x0B, 0x0B, 0x0B, 0x0F, 0x0F, 0x0F, 0x0F));

#endif

}

static force_inline vector unsigned int

splat_pixel (vector unsigned int pix)

{

    return vec_perm (pix, pix,

		     (vector unsigned char)AVV (

			 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,

			 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03));

}

static force_inline vector unsigned int

pix_multiply (vector unsigned int p, vector unsigned int a)

{

    vector unsigned short hi, lo, mod;

    /* unpack to short */

    hi = (vector unsigned short)

#ifdef WORDS_BIGENDIAN

	vec_mergeh ((vector unsigned char)AVV (0),

		    (vector unsigned char)p);

#else

	vec_mergeh ((vector unsigned char) p,

		    (vector unsigned char) AVV (0));

#endif

    mod = (vector unsigned short)

#ifdef WORDS_BIGENDIAN

	vec_mergeh ((vector unsigned char)AVV (0),

		    (vector unsigned char)a);

#else

	vec_mergeh ((vector unsigned char) a,

		    (vector unsigned char) AVV (0));

#endif

    hi = vec_mladd (hi, mod, (vector unsigned short)

                    AVV (0x0080, 0x0080, 0x0080, 0x0080,

                         0x0080, 0x0080, 0x0080, 0x0080));

    hi = vec_adds (hi, vec_sr (hi, vec_splat_u16 (8)));

    hi = vec_sr (hi, vec_splat_u16 (8));

    /* unpack to short */

    lo = (vector unsigned short)

#ifdef WORDS_BIGENDIAN

	vec_mergel ((vector unsigned char)AVV (0),

		    (vector unsigned char)p);

#else

	vec_mergel ((vector unsigned char) p,

		    (vector unsigned char) AVV (0));

#endif

    mod = (vector unsigned short)

#ifdef WORDS_BIGENDIAN

	vec_mergel ((vector unsigned char)AVV (0),

		    (vector unsigned char)a);

#else

	vec_mergel ((vector unsigned char) a,

		    (vector unsigned char) AVV (0));

#endif

    lo = vec_mladd (lo, mod, (vector unsigned short)

                    AVV (0x0080, 0x0080, 0x0080, 0x0080,

                         0x0080, 0x0080, 0x0080, 0x0080));

    lo = vec_adds (lo, vec_sr (lo, vec_splat_u16 (8)));

    lo = vec_sr (lo, vec_splat_u16 (8));

    return (vector unsigned int)vec_packsu (hi, lo);

}

static force_inline vector unsigned int

pix_add (vector unsigned int a, vector unsigned int b)

{

    return (vector unsigned int)vec_adds ((vector unsigned char)a,

                                          (vector unsigned char)b);

}

static force_inline vector unsigned int

pix_add_mul (vector unsigned int x,

             vector unsigned int a,

             vector unsigned int y,

             vector unsigned int b)

{

    vector unsigned int t1, t2;

    t1 = pix_multiply (x, a);

    t2 = pix_multiply (y, b);

    return pix_add (t1, t2);

}

static force_inline vector unsigned int

negate (vector unsigned int src)

{

    return vec_nor (src, src);

}

/* dest*~srca + src */

static force_inline vector unsigned int

over (vector unsigned int src,

      vector unsigned int srca,

      vector unsigned int dest)

{

    vector unsigned char tmp = (vector unsigned char)

	pix_multiply (dest, negate (srca));

    tmp = vec_adds ((vector unsigned char)src, tmp);

    return (vector unsigned int)tmp;

}

/* in == pix_multiply */

#define in_over(src, srca, mask, dest)					\

    over (pix_multiply (src, mask),					\

          pix_multiply (srca, mask), dest)

#ifdef WORDS_BIGENDIAN

#define COMPUTE_SHIFT_MASK(source)					\

    source ## _mask = vec_lvsl (0, source);

#define COMPUTE_SHIFT_MASKS(dest, source)				\

    source ## _mask = vec_lvsl (0, source);

#define COMPUTE_SHIFT_MASKC(dest, source, mask)				\

    mask ## _mask = vec_lvsl (0, mask);					\

    source ## _mask = vec_lvsl (0, source);

#define LOAD_VECTOR(source)				  \

do							  \

{							  \

    vector unsigned char tmp1, tmp2;			  \

    tmp1 = (typeof(tmp1))vec_ld (0, source);		  \

    tmp2 = (typeof(tmp2))vec_ld (15, source);		  \

    v ## source = (typeof(v ## source)) 		  \

	vec_perm (tmp1, tmp2, source ## _mask);		  \

} while (0)

#define LOAD_VECTORS(dest, source)			  \

do							  \

{							  \

    LOAD_VECTOR(source);				  \

    v ## dest = (typeof(v ## dest))vec_ld (0, dest);	  \

} while (0)

#define LOAD_VECTORSC(dest, source, mask)		  \

do							  \

{							  \

    LOAD_VECTORS(dest, source); 			  \

    LOAD_VECTOR(mask);					  \

} while (0)

#define DECLARE_SRC_MASK_VAR vector unsigned char src_mask

#define DECLARE_MASK_MASK_VAR vector unsigned char mask_mask

#else

/* Now the COMPUTE_SHIFT_{MASK, MASKS, MASKC} below are just no-op.

 * They are defined that way because little endian altivec can do unaligned

 * reads natively and have no need for constructing the permutation pattern

 * variables.

 */

#define COMPUTE_SHIFT_MASK(source)

#define COMPUTE_SHIFT_MASKS(dest, source)

#define COMPUTE_SHIFT_MASKC(dest, source, mask)

# define LOAD_VECTOR(source)				\

    v ## source = *((typeof(v ## source)*)source);

# define LOAD_VECTORS(dest, source)			\

    LOAD_VECTOR(source);				\

    LOAD_VECTOR(dest);					\

# define LOAD_VECTORSC(dest, source, mask)		\

    LOAD_VECTORS(dest, source); 			\

    LOAD_VECTOR(mask);					\

#define DECLARE_SRC_MASK_VAR

#define DECLARE_MASK_MASK_VAR

#endif /* WORDS_BIGENDIAN */

#define LOAD_VECTORSM(dest, source, mask)				\

    LOAD_VECTORSC (dest, source, mask); 				\

    v ## source = pix_multiply (v ## source,				\

                                splat_alpha (v ## mask));

#define STORE_VECTOR(dest)						\

    vec_st ((vector unsigned int) v ## dest, 0, dest);

/* load 4 pixels from a 16-byte boundary aligned address */

static force_inline vector unsigned int

load_128_aligned (const uint32_t* src)

{

    return *((vector unsigned int *) src);

}

/* load 4 pixels from a unaligned address */

static force_inline vector unsigned int

load_128_unaligned (const uint32_t* src)

{

    vector unsigned int vsrc;

    DECLARE_SRC_MASK_VAR;

    COMPUTE_SHIFT_MASK (src);

    LOAD_VECTOR (src);

    return vsrc;

}

/* save 4 pixels on a 16-byte boundary aligned address */

static force_inline void

save_128_aligned (uint32_t* data,

		  vector unsigned int vdata)

{

    STORE_VECTOR(data)

}

static force_inline vector unsigned int

create_mask_1x32_128 (const uint32_t *src)

{

    vector unsigned int vsrc;

    DECLARE_SRC_MASK_VAR;

    COMPUTE_SHIFT_MASK (src);

    LOAD_VECTOR (src);

    return vec_splat(vsrc, 0);

}

static force_inline vector unsigned int

create_mask_32_128 (uint32_t mask)

{

    return create_mask_1x32_128(&mask);

}

static force_inline vector unsigned int

unpacklo_128_16x8 (vector unsigned int data1, vector unsigned int data2)

{

    vector unsigned char lo;

    /* unpack to short */

    lo = (vector unsigned char)

#ifdef WORDS_BIGENDIAN

	vec_mergel ((vector unsigned char) data2,

		    (vector unsigned char) data1);

#else

	vec_mergel ((vector unsigned char) data1,

		    (vector unsigned char) data2);

#endif

    return (vector unsigned int) lo;

}

static force_inline vector unsigned int

unpackhi_128_16x8 (vector unsigned int data1, vector unsigned int data2)

{

    vector unsigned char hi;

    /* unpack to short */

    hi = (vector unsigned char)

#ifdef WORDS_BIGENDIAN

	vec_mergeh ((vector unsigned char) data2,

		    (vector unsigned char) data1);

#else

	vec_mergeh ((vector unsigned char) data1,

		    (vector unsigned char) data2);

#endif

    return (vector unsigned int) hi;

}

static force_inline vector unsigned int

unpacklo_128_8x16 (vector unsigned int data1, vector unsigned int data2)

{

    vector unsigned short lo;

    /* unpack to char */

    lo = (vector unsigned short)

#ifdef WORDS_BIGENDIAN

	vec_mergel ((vector unsigned short) data2,

		    (vector unsigned short) data1);

#else

	vec_mergel ((vector unsigned short) data1,

		    (vector unsigned short) data2);

#endif

    return (vector unsigned int) lo;

}

static force_inline vector unsigned int

unpackhi_128_8x16 (vector unsigned int data1, vector unsigned int data2)

{

    vector unsigned short hi;

    /* unpack to char */

    hi = (vector unsigned short)

#ifdef WORDS_BIGENDIAN

	vec_mergeh ((vector unsigned short) data2,

		    (vector unsigned short) data1);

#else

	vec_mergeh ((vector unsigned short) data1,

		    (vector unsigned short) data2);

#endif

    return (vector unsigned int) hi;

}

static force_inline void

unpack_128_2x128 (vector unsigned int data1, vector unsigned int data2,

		    vector unsigned int* data_lo, vector unsigned int* data_hi)

{

    *data_lo = unpacklo_128_16x8(data1, data2);

    *data_hi = unpackhi_128_16x8(data1, data2);

}

static force_inline void

unpack_128_2x128_16 (vector unsigned int data1, vector unsigned int data2,

		    vector unsigned int* data_lo, vector unsigned int* data_hi)

{

    *data_lo = unpacklo_128_8x16(data1, data2);

    *data_hi = unpackhi_128_8x16(data1, data2);

}

static force_inline vector unsigned int

unpack_565_to_8888 (vector unsigned int lo)

{

    vector unsigned int r, g, b, rb, t;

    r = vec_and (vec_sl(lo, create_mask_32_128(8)), mask_red);

    g = vec_and (vec_sl(lo, create_mask_32_128(5)), mask_green);

    b = vec_and (vec_sl(lo, create_mask_32_128(3)), mask_blue);

    rb = vec_or (r, b);

    t  = vec_and (rb, mask_565_fix_rb);

    t  = vec_sr (t, create_mask_32_128(5));

    rb = vec_or (rb, t);

    t  = vec_and (g, mask_565_fix_g);

    t  = vec_sr (t, create_mask_32_128(6));

    g  = vec_or (g, t);

    return vec_or (rb, g);

}

static force_inline int

is_opaque (vector unsigned int x)

{

    uint32_t cmp_result;

    vector bool int ffs = vec_cmpeq(x, x);

    cmp_result = vec_all_eq(x, ffs);

    return (cmp_result & 0x8888) == 0x8888;

}

static force_inline int

is_zero (vector unsigned int x)

{

    uint32_t cmp_result;

    cmp_result = vec_all_eq(x, (vector unsigned int) AVV(0));

    return cmp_result == 0xffff;

}

static force_inline int

is_transparent (vector unsigned int x)

{

    uint32_t cmp_result;

    cmp_result = vec_all_eq(x, (vector unsigned int) AVV(0));

    return (cmp_result & 0x8888) == 0x8888;

}

static force_inline uint32_t

core_combine_over_u_pixel_vmx (uint32_t src, uint32_t dst)

{

    uint32_t a;

    a = ALPHA_8(src);

    if (a == 0xff)

    {

	return src;

    }

    else if (src)

    {

	UN8x4_MUL_UN8_ADD_UN8x4(dst, (~a & MASK), src);

    }

    return dst;

}

static force_inline uint32_t

combine1 (const uint32_t *ps, const uint32_t *pm)

{

    uint32_t s = *ps;

    if (pm)

	UN8x4_MUL_UN8(s, ALPHA_8(*pm));

    return s;

}

static force_inline vector unsigned int

combine4 (const uint32_t* ps, const uint32_t* pm)

{

    vector unsigned int src, msk;

    if (pm)

    {

	msk = load_128_unaligned(pm);

	if (is_transparent(msk))

	    return (vector unsigned int) AVV(0);

    }

    src = load_128_unaligned(ps);

    if (pm)

	src = pix_multiply(src, msk);

    return src;

}

static void

vmx_combine_over_u_no_mask (uint32_t *      dest,

                            const uint32_t *src,

                            int             width)

{

    int i;

    vector unsigned int vdest, vsrc;

    DECLARE_SRC_MASK_VAR;

    while (width && ((uintptr_t)dest & 15))

    {

	uint32_t s = *src++;

	uint32_t d = *dest;

	uint32_t ia = ALPHA_8 (~s);

	UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);

	*dest++ = d;

	width--;

    }

    COMPUTE_SHIFT_MASKS (dest, src);

    /* printf ("%s\n",__PRETTY_FUNCTION__); */

    for (i = width / 4; i > 0; i--)

    {

	LOAD_VECTORS (dest, src);

	vdest = over (vsrc, splat_alpha (vsrc), vdest);

	STORE_VECTOR (dest);

	src += 4;

	dest += 4;

    }

    for (i = width % 4; --i >= 0;)

    {

	uint32_t s = src[i];

	uint32_t d = dest[i];

	uint32_t ia = ALPHA_8 (~s);

	UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);

	dest[i] = d;

    }

}

static void

vmx_combine_over_u_mask (uint32_t *      dest,

                         const uint32_t *src,

                         const uint32_t *mask,

                         int             width)

{

    int i;

    vector unsigned int vdest, vsrc, vmask;

    DECLARE_SRC_MASK_VAR;

    DECLARE_MASK_MASK_VAR;

    while (width && ((uintptr_t)dest & 15))

    {

	uint32_t m = ALPHA_8 (*mask++);

	uint32_t s = *src++;

	uint32_t d = *dest;

	uint32_t ia;

	UN8x4_MUL_UN8 (s, m);

	ia = ALPHA_8 (~s);

	UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);

	*dest++ = d;

	width--;

    }

    COMPUTE_SHIFT_MASKC (dest, src, mask);

    /* printf ("%s\n",__PRETTY_FUNCTION__); */

    for (i = width / 4; i > 0; i--)

    {

	LOAD_VECTORSM (dest, src, mask);

	vdest = over (vsrc, splat_alpha (vsrc), vdest);

	STORE_VECTOR (dest);

	src += 4;

	dest += 4;

	mask += 4;

    }

    for (i = width % 4; --i >= 0;)

    {

	uint32_t m = ALPHA_8 (mask[i]);

	uint32_t s = src[i];

	uint32_t d = dest[i];

	uint32_t ia;

	UN8x4_MUL_UN8 (s, m);

	ia = ALPHA_8 (~s);

	UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);

	dest[i] = d;

    }

}

static void

vmx_combine_over_u (pixman_implementation_t *imp,

                    pixman_op_t              op,

                    uint32_t *               dest,

                    const uint32_t *         src,

                    const uint32_t *         mask,

                    int                      width)

{

    if (mask)

	vmx_combine_over_u_mask (dest, src, mask, width);

    else

	vmx_combine_over_u_no_mask (dest, src, width);

}

static void

vmx_combine_over_reverse_u_no_mask (uint32_t *      dest,

                                    const uint32_t *src,

                                    int             width)

{

    int i;

    vector unsigned int vdest, vsrc;

    DECLARE_SRC_MASK_VAR;

    while (width && ((uintptr_t)dest & 15))

    {

	uint32_t s = *src++;

	uint32_t d = *dest;

	uint32_t ia = ALPHA_8 (~d);

	UN8x4_MUL_UN8_ADD_UN8x4 (s, ia, d);

	*dest++ = s;

	width--;

    }

    COMPUTE_SHIFT_MASKS (dest, src);

    /* printf ("%s\n",__PRETTY_FUNCTION__); */

    for (i = width / 4; i > 0; i--)

    {

	LOAD_VECTORS (dest, src);

	vdest = over (vdest, splat_alpha (vdest), vsrc);

	STORE_VECTOR (dest);

	src += 4;

	dest += 4;

    }

    for (i = width % 4; --i >= 0;)

    {

	uint32_t s = src[i];

	uint32_t d = dest[i];

	uint32_t ia = ALPHA_8 (~dest[i]);

	UN8x4_MUL_UN8_ADD_UN8x4 (s, ia, d);

	dest[i] = s;

    }

}

static void

vmx_combine_over_reverse_u_mask (uint32_t *      dest,

                                 const uint32_t *src,

                                 const uint32_t *mask,

                                 int             width)

{

    int i;

    vector unsigned int vdest, vsrc, vmask;

    DECLARE_SRC_MASK_VAR;

    DECLARE_MASK_MASK_VAR;

    while (width && ((uintptr_t)dest & 15))

    {

	uint32_t m = ALPHA_8 (*mask++);

	uint32_t s = *src++;

	uint32_t d = *dest;

	uint32_t ia = ALPHA_8 (~d);

	UN8x4_MUL_UN8 (s, m);

	UN8x4_MUL_UN8_ADD_UN8x4 (s, ia, d);

	*dest++ = s;

	width--;

    }

    COMPUTE_SHIFT_MASKC (dest, src, mask);

    /* printf ("%s\n",__PRETTY_FUNCTION__); */

    for (i = width / 4; i > 0; i--)

    {

	LOAD_VECTORSM (dest, src, mask);

	vdest = over (vdest, splat_alpha (vdest), vsrc);

	STORE_VECTOR (dest);

	src += 4;

	dest += 4;

	mask += 4;

    }

    for (i = width % 4; --i >= 0;)

    {

	uint32_t m = ALPHA_8 (mask[i]);

	uint32_t s = src[i];

	uint32_t d = dest[i];

	uint32_t ia = ALPHA_8 (~dest[i]);

	UN8x4_MUL_UN8 (s, m);

	UN8x4_MUL_UN8_ADD_UN8x4 (s, ia, d);

	dest[i] = s;

    }

}

static void

vmx_combine_over_reverse_u (pixman_implementation_t *imp,

                            pixman_op_t              op,

                            uint32_t *               dest,

                            const uint32_t *         src,

                            const uint32_t *         mask,

                            int                      width)

{

    if (mask)

	vmx_combine_over_reverse_u_mask (dest, src, mask, width);

    else

	vmx_combine_over_reverse_u_no_mask (dest, src, width);

}

static void

vmx_combine_in_u_no_mask (uint32_t *      dest,

                          const uint32_t *src,

                          int             width)

{

    int i;

    vector unsigned int vdest, vsrc;

    DECLARE_SRC_MASK_VAR;

    while (width && ((uintptr_t)dest & 15))

    {

	uint32_t s = *src++;

	uint32_t a = ALPHA_8 (*dest);

	UN8x4_MUL_UN8 (s, a);

	*dest++ = s;

	width--;

    }

    COMPUTE_SHIFT_MASKS (dest, src);

    /* printf ("%s\n",__PRETTY_FUNCTION__); */

    for (i = width / 4; i > 0; i--)

    {

	LOAD_VECTORS (dest, src);

	vdest = pix_multiply (vsrc, splat_alpha (vdest));

	STORE_VECTOR (dest);

	src += 4;

	dest += 4;

    }

    for (i = width % 4; --i >= 0;)

    {

	uint32_t s = src[i];

	uint32_t a = ALPHA_8 (dest[i]);

	UN8x4_MUL_UN8 (s, a);

	dest[i] = s;

    }

}

static void

vmx_combine_in_u_mask (uint32_t *      dest,

                       const uint32_t *src,

                       const uint32_t *mask,

                       int             width)

{

    int i;

    vector unsigned int vdest, vsrc, vmask;

    DECLARE_SRC_MASK_VAR;

    DECLARE_MASK_MASK_VAR;

    while (width && ((uintptr_t)dest & 15))

    {

	uint32_t m = ALPHA_8 (*mask++);

	uint32_t s = *src++;

	uint32_t a = ALPHA_8 (*dest);

	UN8x4_MUL_UN8 (s, m);

	UN8x4_MUL_UN8 (s, a);

	*dest++ = s;

	width--;

    }

    COMPUTE_SHIFT_MASKC (dest, src, mask);

    /* printf ("%s\n",__PRETTY_FUNCTION__); */

    for (i = width / 4; i > 0; i--)

    {

	LOAD_VECTORSM (dest, src, mask);

	vdest = pix_multiply (vsrc, splat_alpha (vdest));

	STORE_VECTOR (dest);

	src += 4;

	dest += 4;

	mask += 4;

    }

    for (i = width % 4; --i >= 0;)

    {

	uint32_t m = ALPHA_8 (mask[i]);

	uint32_t s = src[i];

	uint32_t a = ALPHA_8 (dest[i]);

	UN8x4_MUL_UN8 (s, m);

	UN8x4_MUL_UN8 (s, a);

	dest[i] = s;

    }

}

static void

vmx_combine_in_u (pixman_implementation_t *imp,

                  pixman_op_t              op,

                  uint32_t *               dest,

                  const uint32_t *         src,

                  const uint32_t *         mask,

                  int                      width)

{

    if (mask)

	vmx_combine_in_u_mask (dest, src, mask, width);

    else

	vmx_combine_in_u_no_mask (dest, src, width);

}

static void

vmx_combine_in_reverse_u_no_mask (uint32_t *      dest,

                                  const uint32_t *src,

                                  int             width)

{

    int i;

    vector unsigned int vdest, vsrc;

    DECLARE_SRC_MASK_VAR;

    while (width && ((uintptr_t)dest & 15))

    {

	uint32_t d = *dest;

	uint32_t a = ALPHA_8 (*src++);

	UN8x4_MUL_UN8 (d, a);

	*dest++ = d;

	width--;

    }

    COMPUTE_SHIFT_MASKS (dest, src);

    /* printf ("%s\n",__PRETTY_FUNCTION__); */

    for (i = width / 4; i > 0; i--)

    {

	LOAD_VECTORS (dest, src);

	vdest = pix_multiply (vdest, splat_alpha (vsrc));

	STORE_VECTOR (dest);

	src += 4;

	dest += 4;

    }

    for (i = width % 4; --i >= 0;)

    {

	uint32_t d = dest[i];

	uint32_t a = ALPHA_8 (src[i]);

	UN8x4_MUL_UN8 (d, a);

	dest[i] = d;