static void
vmx_combine_over_ca (pixman_implementation_t *imp,
pixman_op_t op,
uint32_t * dest,
const uint32_t * src,
const uint32_t * mask,
int width)
{
int i;
vector unsigned int vdest, vsrc, vmask;
vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
dest_mask, mask_mask, src_mask, store_mask;
COMPUTE_SHIFT_MASKC (dest, src, mask);
/* printf ("%s\n",__PRETTY_FUNCTION__); */
for (i = width / 4; i > 0; i--)
{
LOAD_VECTORSC (dest, src, mask);
vdest = in_over (vsrc, splat_alpha (vsrc), vmask, vdest);
STORE_VECTOR (dest);
mask += 4;
src += 4;
dest += 4;
}
for (i = width % 4; --i >= 0;)
{
uint32_t a = mask[i];
uint32_t s = src[i];
uint32_t d = dest[i];
uint32_t sa = ALPHA_8 (s);
UN8x4_MUL_UN8x4 (s, a);
UN8x4_MUL_UN8 (a, sa);
UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ~a, s);
dest[i] = d;
}
}
static void
vmx128_combine_in_reverse_ca (pixman_implementation_t *imp,
pixman_op_t op,
uint32_t * dest,
const uint32_t * src,
const uint32_t * mask,
int width)
{
int i;
__vector4 vdest, vsrc, vmask;
__vector4 tmp1, tmp2, tmp3, tmp4, edges,
dest_mask, mask_mask, src_mask, store_mask;
COMPUTE_SHIFT_MASKC (dest, src, mask);
/* printf ("%s\n",__PRETTY_FUNCTION__); */
for (i = width / 4; i > 0; i--)
{
LOAD_VECTORSC (dest, src, mask);
vdest = pix_multiply (vdest, pix_multiply (vmask, splat_alpha (vsrc)));
STORE_VECTOR (dest);
src += 4;
dest += 4;
mask += 4;
}
for (i = width % 4; --i >= 0;)
{
uint32_t a = mask[i];
uint32_t d = dest[i];
uint32_t sa = ALPHA_8 (src[i]);
UN8x4_MUL_UN8 (a, sa);
UN8x4_MUL_UN8x4 (d, a);
dest[i] = d;
}
}
static void
vmx128_combine_add_u_mask (uint32_t * dest,
const uint32_t *src,
const uint32_t *mask,
int width)
{
int i;
__vector4 vdest, vsrc, vmask;
__vector4 tmp1, tmp2, tmp3, tmp4, edges,
dest_mask, src_mask, mask_mask, store_mask;
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_add (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];
UN8x4_MUL_UN8 (s, m);
UN8x4_ADD_UN8x4 (d, s);
dest[i] = d;
}
}
/* General fetcher */
static force_inline uint32_t
fetch_pixel_general (bits_image_t *image, int x, int y, pixman_bool_t check_bounds)
{
uint32_t pixel;
if (check_bounds &&
(x < 0 || x >= image->width || y < 0 || y >= image->height))
{
return 0;
}
pixel = image->fetch_pixel_32 (image, x, y);
if (image->common.alpha_map)
{
uint32_t pixel_a;
x -= image->common.alpha_origin_x;
y -= image->common.alpha_origin_y;
if (x < 0 || x >= image->common.alpha_map->width ||
y < 0 || y >= image->common.alpha_map->height)
{
pixel_a = 0;
}
else
{
pixel_a = image->common.alpha_map->fetch_pixel_32 (
image->common.alpha_map, x, y);
pixel_a = ALPHA_8 (pixel_a);
}
pixel &= 0x00ffffff;
pixel |= (pixel_a << 24);
}
return pixel;
}
static void
vmx128_combine_over_u_no_mask (uint32_t * dest,
const uint32_t *src,
int width)
{
int i;
__vector4 vdest, vsrc;
__vector4 tmp1, tmp2, tmp3, tmp4, edges,
dest_mask, src_mask, store_mask;
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
vmx128_combine_out_reverse_u_no_mask (uint32_t * dest,
const uint32_t *src,
int width)
{
int i;
__vector4 vdest, vsrc;
__vector4 tmp1, tmp2, tmp3, tmp4, edges,
dest_mask, src_mask, store_mask;
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 (negate (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;
}
}
static force_inline uint32_t
bits_image_fetch_pixel_convolution (bits_image_t *image,
pixman_fixed_t x,
pixman_fixed_t y,
get_pixel_t get_pixel)
{
pixman_fixed_t *params = image->common.filter_params;
int x_off = (params[0] - pixman_fixed_1) >> 1;
int y_off = (params[1] - pixman_fixed_1) >> 1;
int32_t cwidth = pixman_fixed_to_int (params[0]);
int32_t cheight = pixman_fixed_to_int (params[1]);
int32_t i, j, x1, x2, y1, y2;
pixman_repeat_t repeat_mode = image->common.repeat;
int width = image->width;
int height = image->height;
int srtot, sgtot, sbtot, satot;
params += 2;
x1 = pixman_fixed_to_int (x - pixman_fixed_e - x_off);
y1 = pixman_fixed_to_int (y - pixman_fixed_e - y_off);
x2 = x1 + cwidth;
y2 = y1 + cheight;
srtot = sgtot = sbtot = satot = 0;
for (i = y1; i < y2; ++i)
{
for (j = x1; j < x2; ++j)
{
int rx = j;
int ry = i;
pixman_fixed_t f = *params;
if (f)
{
uint32_t pixel;
if (repeat_mode != PIXMAN_REPEAT_NONE)
{
repeat (repeat_mode, &rx, width);
repeat (repeat_mode, &ry, height);
pixel = get_pixel (image, rx, ry, FALSE);
}
else
{
pixel = get_pixel (image, rx, ry, TRUE);
}
srtot += (int)RED_8 (pixel) * f;
sgtot += (int)GREEN_8 (pixel) * f;
sbtot += (int)BLUE_8 (pixel) * f;
satot += (int)ALPHA_8 (pixel) * f;
}
params++;
}
}
satot >>= 16;
srtot >>= 16;
sgtot >>= 16;
sbtot >>= 16;
satot = CLIP (satot, 0, 0xff);
srtot = CLIP (srtot, 0, 0xff);
sgtot = CLIP (sgtot, 0, 0xff);
sbtot = CLIP (sbtot, 0, 0xff);
return ((satot << 24) | (srtot << 16) | (sgtot << 8) | (sbtot));
}
