1809 lines
46 KiB
C
1809 lines
46 KiB
C
/*
|
|
* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
|
|
* 2005 Lars Knoll & Zack Rusin, Trolltech
|
|
* 2008 Aaron Plattner, NVIDIA Corporation
|
|
* Copyright © 2000 SuSE, Inc.
|
|
* Copyright © 2007, 2009 Red Hat, Inc.
|
|
* Copyright © 2008 André Tupinambá <andrelrt@gmail.com>
|
|
*
|
|
* 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 Keith Packard not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Keith Packard 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.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "pixman-private.h"
|
|
#include "pixman-combine32.h"
|
|
#include "pixman-inlines.h"
|
|
|
|
static uint32_t *
|
|
_pixman_image_get_scanline_generic_float (pixman_iter_t * iter,
|
|
const uint32_t *mask)
|
|
{
|
|
pixman_iter_get_scanline_t fetch_32 = iter->data;
|
|
uint32_t *buffer = iter->buffer;
|
|
|
|
fetch_32 (iter, NULL);
|
|
|
|
pixman_expand_to_float ((argb_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
|
|
|
|
return iter->buffer;
|
|
}
|
|
|
|
/* Fetch functions */
|
|
|
|
static force_inline uint32_t
|
|
fetch_pixel_no_alpha (bits_image_t *image,
|
|
int x, int y, pixman_bool_t check_bounds)
|
|
{
|
|
if (check_bounds &&
|
|
(x < 0 || x >= image->width || y < 0 || y >= image->height))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return image->fetch_pixel_32 (image, x, y);
|
|
}
|
|
|
|
typedef uint32_t (* get_pixel_t) (bits_image_t *image,
|
|
int x, int y, pixman_bool_t check_bounds);
|
|
|
|
static force_inline uint32_t
|
|
bits_image_fetch_pixel_nearest (bits_image_t *image,
|
|
pixman_fixed_t x,
|
|
pixman_fixed_t y,
|
|
get_pixel_t get_pixel)
|
|
{
|
|
int x0 = pixman_fixed_to_int (x - pixman_fixed_e);
|
|
int y0 = pixman_fixed_to_int (y - pixman_fixed_e);
|
|
|
|
if (image->common.repeat != PIXMAN_REPEAT_NONE)
|
|
{
|
|
repeat (image->common.repeat, &x0, image->width);
|
|
repeat (image->common.repeat, &y0, image->height);
|
|
|
|
return get_pixel (image, x0, y0, FALSE);
|
|
}
|
|
else
|
|
{
|
|
return get_pixel (image, x0, y0, TRUE);
|
|
}
|
|
}
|
|
|
|
static force_inline uint32_t
|
|
bits_image_fetch_pixel_bilinear (bits_image_t *image,
|
|
pixman_fixed_t x,
|
|
pixman_fixed_t y,
|
|
get_pixel_t get_pixel)
|
|
{
|
|
pixman_repeat_t repeat_mode = image->common.repeat;
|
|
int width = image->width;
|
|
int height = image->height;
|
|
int x1, y1, x2, y2;
|
|
uint32_t tl, tr, bl, br;
|
|
int32_t distx, disty;
|
|
|
|
x1 = x - pixman_fixed_1 / 2;
|
|
y1 = y - pixman_fixed_1 / 2;
|
|
|
|
distx = pixman_fixed_to_bilinear_weight (x1);
|
|
disty = pixman_fixed_to_bilinear_weight (y1);
|
|
|
|
x1 = pixman_fixed_to_int (x1);
|
|
y1 = pixman_fixed_to_int (y1);
|
|
x2 = x1 + 1;
|
|
y2 = y1 + 1;
|
|
|
|
if (repeat_mode != PIXMAN_REPEAT_NONE)
|
|
{
|
|
repeat (repeat_mode, &x1, width);
|
|
repeat (repeat_mode, &y1, height);
|
|
repeat (repeat_mode, &x2, width);
|
|
repeat (repeat_mode, &y2, height);
|
|
|
|
tl = get_pixel (image, x1, y1, FALSE);
|
|
bl = get_pixel (image, x1, y2, FALSE);
|
|
tr = get_pixel (image, x2, y1, FALSE);
|
|
br = get_pixel (image, x2, y2, FALSE);
|
|
}
|
|
else
|
|
{
|
|
tl = get_pixel (image, x1, y1, TRUE);
|
|
tr = get_pixel (image, x2, y1, TRUE);
|
|
bl = get_pixel (image, x1, y2, TRUE);
|
|
br = get_pixel (image, x2, y2, TRUE);
|
|
}
|
|
|
|
return bilinear_interpolation (tl, tr, bl, br, distx, disty);
|
|
}
|
|
|
|
static uint32_t *
|
|
bits_image_fetch_bilinear_no_repeat_8888 (pixman_iter_t *iter,
|
|
const uint32_t *mask)
|
|
{
|
|
|
|
pixman_image_t * ima = iter->image;
|
|
int offset = iter->x;
|
|
int line = iter->y++;
|
|
int width = iter->width;
|
|
uint32_t * buffer = iter->buffer;
|
|
|
|
bits_image_t *bits = &ima->bits;
|
|
pixman_fixed_t x_top, x_bottom, x;
|
|
pixman_fixed_t ux_top, ux_bottom, ux;
|
|
pixman_vector_t v;
|
|
uint32_t top_mask, bottom_mask;
|
|
uint32_t *top_row;
|
|
uint32_t *bottom_row;
|
|
uint32_t *end;
|
|
uint32_t zero[2] = { 0, 0 };
|
|
uint32_t one = 1;
|
|
int y, y1, y2;
|
|
int disty;
|
|
int mask_inc;
|
|
int w;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
|
|
v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
|
|
v.vector[2] = pixman_fixed_1;
|
|
|
|
if (!pixman_transform_point_3d (bits->common.transform, &v))
|
|
return iter->buffer;
|
|
|
|
ux = ux_top = ux_bottom = bits->common.transform->matrix[0][0];
|
|
x = x_top = x_bottom = v.vector[0] - pixman_fixed_1/2;
|
|
|
|
y = v.vector[1] - pixman_fixed_1/2;
|
|
disty = pixman_fixed_to_bilinear_weight (y);
|
|
|
|
/* Load the pointers to the first and second lines from the source
|
|
* image that bilinear code must read.
|
|
*
|
|
* The main trick in this code is about the check if any line are
|
|
* outside of the image;
|
|
*
|
|
* When I realize that a line (any one) is outside, I change
|
|
* the pointer to a dummy area with zeros. Once I change this, I
|
|
* must be sure the pointer will not change, so I set the
|
|
* variables to each pointer increments inside the loop.
|
|
*/
|
|
y1 = pixman_fixed_to_int (y);
|
|
y2 = y1 + 1;
|
|
|
|
if (y1 < 0 || y1 >= bits->height)
|
|
{
|
|
top_row = zero;
|
|
x_top = 0;
|
|
ux_top = 0;
|
|
}
|
|
else
|
|
{
|
|
top_row = bits->bits + y1 * bits->rowstride;
|
|
x_top = x;
|
|
ux_top = ux;
|
|
}
|
|
|
|
if (y2 < 0 || y2 >= bits->height)
|
|
{
|
|
bottom_row = zero;
|
|
x_bottom = 0;
|
|
ux_bottom = 0;
|
|
}
|
|
else
|
|
{
|
|
bottom_row = bits->bits + y2 * bits->rowstride;
|
|
x_bottom = x;
|
|
ux_bottom = ux;
|
|
}
|
|
|
|
/* Instead of checking whether the operation uses the mast in
|
|
* each loop iteration, verify this only once and prepare the
|
|
* variables to make the code smaller inside the loop.
|
|
*/
|
|
if (!mask)
|
|
{
|
|
mask_inc = 0;
|
|
mask = &one;
|
|
}
|
|
else
|
|
{
|
|
/* If have a mask, prepare the variables to check it */
|
|
mask_inc = 1;
|
|
}
|
|
|
|
/* If both are zero, then the whole thing is zero */
|
|
if (top_row == zero && bottom_row == zero)
|
|
{
|
|
memset (buffer, 0, width * sizeof (uint32_t));
|
|
return iter->buffer;
|
|
}
|
|
else if (bits->format == PIXMAN_x8r8g8b8)
|
|
{
|
|
if (top_row == zero)
|
|
{
|
|
top_mask = 0;
|
|
bottom_mask = 0xff000000;
|
|
}
|
|
else if (bottom_row == zero)
|
|
{
|
|
top_mask = 0xff000000;
|
|
bottom_mask = 0;
|
|
}
|
|
else
|
|
{
|
|
top_mask = 0xff000000;
|
|
bottom_mask = 0xff000000;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
top_mask = 0;
|
|
bottom_mask = 0;
|
|
}
|
|
|
|
end = buffer + width;
|
|
|
|
/* Zero fill to the left of the image */
|
|
while (buffer < end && x < pixman_fixed_minus_1)
|
|
{
|
|
*buffer++ = 0;
|
|
x += ux;
|
|
x_top += ux_top;
|
|
x_bottom += ux_bottom;
|
|
mask += mask_inc;
|
|
}
|
|
|
|
/* Left edge
|
|
*/
|
|
while (buffer < end && x < 0)
|
|
{
|
|
uint32_t tr, br;
|
|
int32_t distx;
|
|
|
|
tr = top_row[pixman_fixed_to_int (x_top) + 1] | top_mask;
|
|
br = bottom_row[pixman_fixed_to_int (x_bottom) + 1] | bottom_mask;
|
|
|
|
distx = pixman_fixed_to_bilinear_weight (x);
|
|
|
|
*buffer++ = bilinear_interpolation (0, tr, 0, br, distx, disty);
|
|
|
|
x += ux;
|
|
x_top += ux_top;
|
|
x_bottom += ux_bottom;
|
|
mask += mask_inc;
|
|
}
|
|
|
|
/* Main part */
|
|
w = pixman_int_to_fixed (bits->width - 1);
|
|
|
|
while (buffer < end && x < w)
|
|
{
|
|
if (*mask)
|
|
{
|
|
uint32_t tl, tr, bl, br;
|
|
int32_t distx;
|
|
|
|
tl = top_row [pixman_fixed_to_int (x_top)] | top_mask;
|
|
tr = top_row [pixman_fixed_to_int (x_top) + 1] | top_mask;
|
|
bl = bottom_row [pixman_fixed_to_int (x_bottom)] | bottom_mask;
|
|
br = bottom_row [pixman_fixed_to_int (x_bottom) + 1] | bottom_mask;
|
|
|
|
distx = pixman_fixed_to_bilinear_weight (x);
|
|
|
|
*buffer = bilinear_interpolation (tl, tr, bl, br, distx, disty);
|
|
}
|
|
|
|
buffer++;
|
|
x += ux;
|
|
x_top += ux_top;
|
|
x_bottom += ux_bottom;
|
|
mask += mask_inc;
|
|
}
|
|
|
|
/* Right Edge */
|
|
w = pixman_int_to_fixed (bits->width);
|
|
while (buffer < end && x < w)
|
|
{
|
|
if (*mask)
|
|
{
|
|
uint32_t tl, bl;
|
|
int32_t distx;
|
|
|
|
tl = top_row [pixman_fixed_to_int (x_top)] | top_mask;
|
|
bl = bottom_row [pixman_fixed_to_int (x_bottom)] | bottom_mask;
|
|
|
|
distx = pixman_fixed_to_bilinear_weight (x);
|
|
|
|
*buffer = bilinear_interpolation (tl, 0, bl, 0, distx, disty);
|
|
}
|
|
|
|
buffer++;
|
|
x += ux;
|
|
x_top += ux_top;
|
|
x_bottom += ux_bottom;
|
|
mask += mask_inc;
|
|
}
|
|
|
|
/* Zero fill to the left of the image */
|
|
while (buffer < end)
|
|
*buffer++ = 0;
|
|
|
|
return iter->buffer;
|
|
}
|
|
|
|
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 = (satot + 0x8000) >> 16;
|
|
srtot = (srtot + 0x8000) >> 16;
|
|
sgtot = (sgtot + 0x8000) >> 16;
|
|
sbtot = (sbtot + 0x8000) >> 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));
|
|
}
|
|
|
|
static uint32_t
|
|
bits_image_fetch_pixel_separable_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;
|
|
pixman_repeat_t repeat_mode = image->common.repeat;
|
|
int width = image->width;
|
|
int height = image->height;
|
|
int cwidth = pixman_fixed_to_int (params[0]);
|
|
int cheight = pixman_fixed_to_int (params[1]);
|
|
int x_phase_bits = pixman_fixed_to_int (params[2]);
|
|
int y_phase_bits = pixman_fixed_to_int (params[3]);
|
|
int x_phase_shift = 16 - x_phase_bits;
|
|
int y_phase_shift = 16 - y_phase_bits;
|
|
int x_off = ((cwidth << 16) - pixman_fixed_1) >> 1;
|
|
int y_off = ((cheight << 16) - pixman_fixed_1) >> 1;
|
|
pixman_fixed_t *y_params;
|
|
int srtot, sgtot, sbtot, satot;
|
|
int32_t x1, x2, y1, y2;
|
|
int32_t px, py;
|
|
int i, j;
|
|
|
|
/* Round x and y to the middle of the closest phase before continuing. This
|
|
* ensures that the convolution matrix is aligned right, since it was
|
|
* positioned relative to a particular phase (and not relative to whatever
|
|
* exact fraction we happen to get here).
|
|
*/
|
|
x = ((x >> x_phase_shift) << x_phase_shift) + ((1 << x_phase_shift) >> 1);
|
|
y = ((y >> y_phase_shift) << y_phase_shift) + ((1 << y_phase_shift) >> 1);
|
|
|
|
px = (x & 0xffff) >> x_phase_shift;
|
|
py = (y & 0xffff) >> y_phase_shift;
|
|
|
|
y_params = params + 4 + (1 << x_phase_bits) * cwidth + py * cheight;
|
|
|
|
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)
|
|
{
|
|
pixman_fixed_48_16_t fy = *y_params++;
|
|
pixman_fixed_t *x_params = params + 4 + px * cwidth;
|
|
|
|
if (fy)
|
|
{
|
|
for (j = x1; j < x2; ++j)
|
|
{
|
|
pixman_fixed_t fx = *x_params++;
|
|
int rx = j;
|
|
int ry = i;
|
|
|
|
if (fx)
|
|
{
|
|
pixman_fixed_t 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);
|
|
}
|
|
|
|
f = (fy * fx + 0x8000) >> 16;
|
|
|
|
srtot += (int)RED_8 (pixel) * f;
|
|
sgtot += (int)GREEN_8 (pixel) * f;
|
|
sbtot += (int)BLUE_8 (pixel) * f;
|
|
satot += (int)ALPHA_8 (pixel) * f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
satot = (satot + 0x8000) >> 16;
|
|
srtot = (srtot + 0x8000) >> 16;
|
|
sgtot = (sgtot + 0x8000) >> 16;
|
|
sbtot = (sbtot + 0x8000) >> 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));
|
|
}
|
|
|
|
static force_inline uint32_t
|
|
bits_image_fetch_pixel_filtered (bits_image_t *image,
|
|
pixman_fixed_t x,
|
|
pixman_fixed_t y,
|
|
get_pixel_t get_pixel)
|
|
{
|
|
switch (image->common.filter)
|
|
{
|
|
case PIXMAN_FILTER_NEAREST:
|
|
case PIXMAN_FILTER_FAST:
|
|
return bits_image_fetch_pixel_nearest (image, x, y, get_pixel);
|
|
break;
|
|
|
|
case PIXMAN_FILTER_BILINEAR:
|
|
case PIXMAN_FILTER_GOOD:
|
|
case PIXMAN_FILTER_BEST:
|
|
return bits_image_fetch_pixel_bilinear (image, x, y, get_pixel);
|
|
break;
|
|
|
|
case PIXMAN_FILTER_CONVOLUTION:
|
|
return bits_image_fetch_pixel_convolution (image, x, y, get_pixel);
|
|
break;
|
|
|
|
case PIXMAN_FILTER_SEPARABLE_CONVOLUTION:
|
|
return bits_image_fetch_pixel_separable_convolution (image, x, y, get_pixel);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static uint32_t *
|
|
bits_image_fetch_affine_no_alpha (pixman_iter_t * iter,
|
|
const uint32_t * mask)
|
|
{
|
|
pixman_image_t *image = iter->image;
|
|
int offset = iter->x;
|
|
int line = iter->y++;
|
|
int width = iter->width;
|
|
uint32_t * buffer = iter->buffer;
|
|
|
|
pixman_fixed_t x, y;
|
|
pixman_fixed_t ux, uy;
|
|
pixman_vector_t v;
|
|
int i;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
|
|
v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
|
|
v.vector[2] = pixman_fixed_1;
|
|
|
|
if (image->common.transform)
|
|
{
|
|
if (!pixman_transform_point_3d (image->common.transform, &v))
|
|
return iter->buffer;
|
|
|
|
ux = image->common.transform->matrix[0][0];
|
|
uy = image->common.transform->matrix[1][0];
|
|
}
|
|
else
|
|
{
|
|
ux = pixman_fixed_1;
|
|
uy = 0;
|
|
}
|
|
|
|
x = v.vector[0];
|
|
y = v.vector[1];
|
|
|
|
for (i = 0; i < width; ++i)
|
|
{
|
|
if (!mask || mask[i])
|
|
{
|
|
buffer[i] = bits_image_fetch_pixel_filtered (
|
|
&image->bits, x, y, fetch_pixel_no_alpha);
|
|
}
|
|
|
|
x += ux;
|
|
y += uy;
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/* 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 uint32_t *
|
|
bits_image_fetch_general (pixman_iter_t *iter,
|
|
const uint32_t *mask)
|
|
{
|
|
pixman_image_t *image = iter->image;
|
|
int offset = iter->x;
|
|
int line = iter->y++;
|
|
int width = iter->width;
|
|
uint32_t * buffer = iter->buffer;
|
|
|
|
pixman_fixed_t x, y, w;
|
|
pixman_fixed_t ux, uy, uw;
|
|
pixman_vector_t v;
|
|
int i;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
|
|
v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
|
|
v.vector[2] = pixman_fixed_1;
|
|
|
|
if (image->common.transform)
|
|
{
|
|
if (!pixman_transform_point_3d (image->common.transform, &v))
|
|
return buffer;
|
|
|
|
ux = image->common.transform->matrix[0][0];
|
|
uy = image->common.transform->matrix[1][0];
|
|
uw = image->common.transform->matrix[2][0];
|
|
}
|
|
else
|
|
{
|
|
ux = pixman_fixed_1;
|
|
uy = 0;
|
|
uw = 0;
|
|
}
|
|
|
|
x = v.vector[0];
|
|
y = v.vector[1];
|
|
w = v.vector[2];
|
|
|
|
for (i = 0; i < width; ++i)
|
|
{
|
|
pixman_fixed_t x0, y0;
|
|
|
|
if (!mask || mask[i])
|
|
{
|
|
if (w != 0)
|
|
{
|
|
x0 = ((pixman_fixed_48_16_t)x << 16) / w;
|
|
y0 = ((pixman_fixed_48_16_t)y << 16) / w;
|
|
}
|
|
else
|
|
{
|
|
x0 = 0;
|
|
y0 = 0;
|
|
}
|
|
|
|
buffer[i] = bits_image_fetch_pixel_filtered (
|
|
&image->bits, x0, y0, fetch_pixel_general);
|
|
}
|
|
|
|
x += ux;
|
|
y += uy;
|
|
w += uw;
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
typedef uint32_t (* convert_pixel_t) (const uint8_t *row, int x);
|
|
|
|
static force_inline void
|
|
bits_image_fetch_separable_convolution_affine (pixman_image_t * image,
|
|
int offset,
|
|
int line,
|
|
int width,
|
|
uint32_t * buffer,
|
|
const uint32_t * mask,
|
|
|
|
convert_pixel_t convert_pixel,
|
|
pixman_format_code_t format,
|
|
pixman_repeat_t repeat_mode)
|
|
{
|
|
bits_image_t *bits = &image->bits;
|
|
pixman_fixed_t *params = image->common.filter_params;
|
|
int cwidth = pixman_fixed_to_int (params[0]);
|
|
int cheight = pixman_fixed_to_int (params[1]);
|
|
int x_off = ((cwidth << 16) - pixman_fixed_1) >> 1;
|
|
int y_off = ((cheight << 16) - pixman_fixed_1) >> 1;
|
|
int x_phase_bits = pixman_fixed_to_int (params[2]);
|
|
int y_phase_bits = pixman_fixed_to_int (params[3]);
|
|
int x_phase_shift = 16 - x_phase_bits;
|
|
int y_phase_shift = 16 - y_phase_bits;
|
|
pixman_fixed_t vx, vy;
|
|
pixman_fixed_t ux, uy;
|
|
pixman_vector_t v;
|
|
int k;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
|
|
v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
|
|
v.vector[2] = pixman_fixed_1;
|
|
|
|
if (!pixman_transform_point_3d (image->common.transform, &v))
|
|
return;
|
|
|
|
ux = image->common.transform->matrix[0][0];
|
|
uy = image->common.transform->matrix[1][0];
|
|
|
|
vx = v.vector[0];
|
|
vy = v.vector[1];
|
|
|
|
for (k = 0; k < width; ++k)
|
|
{
|
|
pixman_fixed_t *y_params;
|
|
int satot, srtot, sgtot, sbtot;
|
|
pixman_fixed_t x, y;
|
|
int32_t x1, x2, y1, y2;
|
|
int32_t px, py;
|
|
int i, j;
|
|
|
|
if (mask && !mask[k])
|
|
goto next;
|
|
|
|
/* Round x and y to the middle of the closest phase before continuing. This
|
|
* ensures that the convolution matrix is aligned right, since it was
|
|
* positioned relative to a particular phase (and not relative to whatever
|
|
* exact fraction we happen to get here).
|
|
*/
|
|
x = ((vx >> x_phase_shift) << x_phase_shift) + ((1 << x_phase_shift) >> 1);
|
|
y = ((vy >> y_phase_shift) << y_phase_shift) + ((1 << y_phase_shift) >> 1);
|
|
|
|
px = (x & 0xffff) >> x_phase_shift;
|
|
py = (y & 0xffff) >> y_phase_shift;
|
|
|
|
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;
|
|
|
|
satot = srtot = sgtot = sbtot = 0;
|
|
|
|
y_params = params + 4 + (1 << x_phase_bits) * cwidth + py * cheight;
|
|
|
|
for (i = y1; i < y2; ++i)
|
|
{
|
|
pixman_fixed_t fy = *y_params++;
|
|
|
|
if (fy)
|
|
{
|
|
pixman_fixed_t *x_params = params + 4 + px * cwidth;
|
|
|
|
for (j = x1; j < x2; ++j)
|
|
{
|
|
pixman_fixed_t fx = *x_params++;
|
|
int rx = j;
|
|
int ry = i;
|
|
|
|
if (fx)
|
|
{
|
|
pixman_fixed_t f;
|
|
uint32_t pixel, mask;
|
|
uint8_t *row;
|
|
|
|
mask = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
|
|
|
|
if (repeat_mode != PIXMAN_REPEAT_NONE)
|
|
{
|
|
repeat (repeat_mode, &rx, bits->width);
|
|
repeat (repeat_mode, &ry, bits->height);
|
|
|
|
row = (uint8_t *)bits->bits + bits->rowstride * 4 * ry;
|
|
pixel = convert_pixel (row, rx) | mask;
|
|
}
|
|
else
|
|
{
|
|
if (rx < 0 || ry < 0 || rx >= bits->width || ry >= bits->height)
|
|
{
|
|
pixel = 0;
|
|
}
|
|
else
|
|
{
|
|
row = (uint8_t *)bits->bits + bits->rowstride * 4 * ry;
|
|
pixel = convert_pixel (row, rx) | mask;
|
|
}
|
|
}
|
|
|
|
f = ((pixman_fixed_32_32_t)fx * fy + 0x8000) >> 16;
|
|
srtot += (int)RED_8 (pixel) * f;
|
|
sgtot += (int)GREEN_8 (pixel) * f;
|
|
sbtot += (int)BLUE_8 (pixel) * f;
|
|
satot += (int)ALPHA_8 (pixel) * f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
satot = (satot + 0x8000) >> 16;
|
|
srtot = (srtot + 0x8000) >> 16;
|
|
sgtot = (sgtot + 0x8000) >> 16;
|
|
sbtot = (sbtot + 0x8000) >> 16;
|
|
|
|
satot = CLIP (satot, 0, 0xff);
|
|
srtot = CLIP (srtot, 0, 0xff);
|
|
sgtot = CLIP (sgtot, 0, 0xff);
|
|
sbtot = CLIP (sbtot, 0, 0xff);
|
|
|
|
buffer[k] = (satot << 24) | (srtot << 16) | (sgtot << 8) | (sbtot << 0);
|
|
|
|
next:
|
|
vx += ux;
|
|
vy += uy;
|
|
}
|
|
}
|
|
|
|
static const uint8_t zero[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
|
|
static force_inline void
|
|
bits_image_fetch_bilinear_affine (pixman_image_t * image,
|
|
int offset,
|
|
int line,
|
|
int width,
|
|
uint32_t * buffer,
|
|
const uint32_t * mask,
|
|
|
|
convert_pixel_t convert_pixel,
|
|
pixman_format_code_t format,
|
|
pixman_repeat_t repeat_mode)
|
|
{
|
|
pixman_fixed_t x, y;
|
|
pixman_fixed_t ux, uy;
|
|
pixman_vector_t v;
|
|
bits_image_t *bits = &image->bits;
|
|
int i;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
|
|
v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
|
|
v.vector[2] = pixman_fixed_1;
|
|
|
|
if (!pixman_transform_point_3d (image->common.transform, &v))
|
|
return;
|
|
|
|
ux = image->common.transform->matrix[0][0];
|
|
uy = image->common.transform->matrix[1][0];
|
|
|
|
x = v.vector[0];
|
|
y = v.vector[1];
|
|
|
|
for (i = 0; i < width; ++i)
|
|
{
|
|
int x1, y1, x2, y2;
|
|
uint32_t tl, tr, bl, br;
|
|
int32_t distx, disty;
|
|
int width = image->bits.width;
|
|
int height = image->bits.height;
|
|
const uint8_t *row1;
|
|
const uint8_t *row2;
|
|
|
|
if (mask && !mask[i])
|
|
goto next;
|
|
|
|
x1 = x - pixman_fixed_1 / 2;
|
|
y1 = y - pixman_fixed_1 / 2;
|
|
|
|
distx = pixman_fixed_to_bilinear_weight (x1);
|
|
disty = pixman_fixed_to_bilinear_weight (y1);
|
|
|
|
y1 = pixman_fixed_to_int (y1);
|
|
y2 = y1 + 1;
|
|
x1 = pixman_fixed_to_int (x1);
|
|
x2 = x1 + 1;
|
|
|
|
if (repeat_mode != PIXMAN_REPEAT_NONE)
|
|
{
|
|
uint32_t mask;
|
|
|
|
mask = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
|
|
|
|
repeat (repeat_mode, &x1, width);
|
|
repeat (repeat_mode, &y1, height);
|
|
repeat (repeat_mode, &x2, width);
|
|
repeat (repeat_mode, &y2, height);
|
|
|
|
row1 = (uint8_t *)bits->bits + bits->rowstride * 4 * y1;
|
|
row2 = (uint8_t *)bits->bits + bits->rowstride * 4 * y2;
|
|
|
|
tl = convert_pixel (row1, x1) | mask;
|
|
tr = convert_pixel (row1, x2) | mask;
|
|
bl = convert_pixel (row2, x1) | mask;
|
|
br = convert_pixel (row2, x2) | mask;
|
|
}
|
|
else
|
|
{
|
|
uint32_t mask1, mask2;
|
|
int bpp;
|
|
|
|
/* Note: PIXMAN_FORMAT_BPP() returns an unsigned value,
|
|
* which means if you use it in expressions, those
|
|
* expressions become unsigned themselves. Since
|
|
* the variables below can be negative in some cases,
|
|
* that will lead to crashes on 64 bit architectures.
|
|
*
|
|
* So this line makes sure bpp is signed
|
|
*/
|
|
bpp = PIXMAN_FORMAT_BPP (format);
|
|
|
|
if (x1 >= width || x2 < 0 || y1 >= height || y2 < 0)
|
|
{
|
|
buffer[i] = 0;
|
|
goto next;
|
|
}
|
|
|
|
if (y2 == 0)
|
|
{
|
|
row1 = zero;
|
|
mask1 = 0;
|
|
}
|
|
else
|
|
{
|
|
row1 = (uint8_t *)bits->bits + bits->rowstride * 4 * y1;
|
|
row1 += bpp / 8 * x1;
|
|
|
|
mask1 = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
|
|
}
|
|
|
|
if (y1 == height - 1)
|
|
{
|
|
row2 = zero;
|
|
mask2 = 0;
|
|
}
|
|
else
|
|
{
|
|
row2 = (uint8_t *)bits->bits + bits->rowstride * 4 * y2;
|
|
row2 += bpp / 8 * x1;
|
|
|
|
mask2 = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
|
|
}
|
|
|
|
if (x2 == 0)
|
|
{
|
|
tl = 0;
|
|
bl = 0;
|
|
}
|
|
else
|
|
{
|
|
tl = convert_pixel (row1, 0) | mask1;
|
|
bl = convert_pixel (row2, 0) | mask2;
|
|
}
|
|
|
|
if (x1 == width - 1)
|
|
{
|
|
tr = 0;
|
|
br = 0;
|
|
}
|
|
else
|
|
{
|
|
tr = convert_pixel (row1, 1) | mask1;
|
|
br = convert_pixel (row2, 1) | mask2;
|
|
}
|
|
}
|
|
|
|
buffer[i] = bilinear_interpolation (
|
|
tl, tr, bl, br, distx, disty);
|
|
|
|
next:
|
|
x += ux;
|
|
y += uy;
|
|
}
|
|
}
|
|
|
|
static force_inline void
|
|
bits_image_fetch_nearest_affine (pixman_image_t * image,
|
|
int offset,
|
|
int line,
|
|
int width,
|
|
uint32_t * buffer,
|
|
const uint32_t * mask,
|
|
|
|
convert_pixel_t convert_pixel,
|
|
pixman_format_code_t format,
|
|
pixman_repeat_t repeat_mode)
|
|
{
|
|
pixman_fixed_t x, y;
|
|
pixman_fixed_t ux, uy;
|
|
pixman_vector_t v;
|
|
bits_image_t *bits = &image->bits;
|
|
int i;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
|
|
v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
|
|
v.vector[2] = pixman_fixed_1;
|
|
|
|
if (!pixman_transform_point_3d (image->common.transform, &v))
|
|
return;
|
|
|
|
ux = image->common.transform->matrix[0][0];
|
|
uy = image->common.transform->matrix[1][0];
|
|
|
|
x = v.vector[0];
|
|
y = v.vector[1];
|
|
|
|
for (i = 0; i < width; ++i)
|
|
{
|
|
int width, height, x0, y0;
|
|
const uint8_t *row;
|
|
|
|
if (mask && !mask[i])
|
|
goto next;
|
|
|
|
width = image->bits.width;
|
|
height = image->bits.height;
|
|
x0 = pixman_fixed_to_int (x - pixman_fixed_e);
|
|
y0 = pixman_fixed_to_int (y - pixman_fixed_e);
|
|
|
|
if (repeat_mode == PIXMAN_REPEAT_NONE &&
|
|
(y0 < 0 || y0 >= height || x0 < 0 || x0 >= width))
|
|
{
|
|
buffer[i] = 0;
|
|
}
|
|
else
|
|
{
|
|
uint32_t mask = PIXMAN_FORMAT_A (format)? 0 : 0xff000000;
|
|
|
|
if (repeat_mode != PIXMAN_REPEAT_NONE)
|
|
{
|
|
repeat (repeat_mode, &x0, width);
|
|
repeat (repeat_mode, &y0, height);
|
|
}
|
|
|
|
row = (uint8_t *)bits->bits + bits->rowstride * 4 * y0;
|
|
|
|
buffer[i] = convert_pixel (row, x0) | mask;
|
|
}
|
|
|
|
next:
|
|
x += ux;
|
|
y += uy;
|
|
}
|
|
}
|
|
|
|
static force_inline uint32_t
|
|
convert_a8r8g8b8 (const uint8_t *row, int x)
|
|
{
|
|
return *(((uint32_t *)row) + x);
|
|
}
|
|
|
|
static force_inline uint32_t
|
|
convert_x8r8g8b8 (const uint8_t *row, int x)
|
|
{
|
|
return *(((uint32_t *)row) + x);
|
|
}
|
|
|
|
static force_inline uint32_t
|
|
convert_a8 (const uint8_t *row, int x)
|
|
{
|
|
return *(row + x) << 24;
|
|
}
|
|
|
|
static force_inline uint32_t
|
|
convert_r5g6b5 (const uint8_t *row, int x)
|
|
{
|
|
return convert_0565_to_0888 (*((uint16_t *)row + x));
|
|
}
|
|
|
|
#define MAKE_SEPARABLE_CONVOLUTION_FETCHER(name, format, repeat_mode) \
|
|
static uint32_t * \
|
|
bits_image_fetch_separable_convolution_affine_ ## name (pixman_iter_t *iter, \
|
|
const uint32_t * mask) \
|
|
{ \
|
|
bits_image_fetch_separable_convolution_affine ( \
|
|
iter->image, \
|
|
iter->x, iter->y++, \
|
|
iter->width, \
|
|
iter->buffer, mask, \
|
|
convert_ ## format, \
|
|
PIXMAN_ ## format, \
|
|
repeat_mode); \
|
|
\
|
|
return iter->buffer; \
|
|
}
|
|
|
|
#define MAKE_BILINEAR_FETCHER(name, format, repeat_mode) \
|
|
static uint32_t * \
|
|
bits_image_fetch_bilinear_affine_ ## name (pixman_iter_t *iter, \
|
|
const uint32_t * mask) \
|
|
{ \
|
|
bits_image_fetch_bilinear_affine (iter->image, \
|
|
iter->x, iter->y++, \
|
|
iter->width, \
|
|
iter->buffer, mask, \
|
|
convert_ ## format, \
|
|
PIXMAN_ ## format, \
|
|
repeat_mode); \
|
|
return iter->buffer; \
|
|
}
|
|
|
|
#define MAKE_NEAREST_FETCHER(name, format, repeat_mode) \
|
|
static uint32_t * \
|
|
bits_image_fetch_nearest_affine_ ## name (pixman_iter_t *iter, \
|
|
const uint32_t * mask) \
|
|
{ \
|
|
bits_image_fetch_nearest_affine (iter->image, \
|
|
iter->x, iter->y++, \
|
|
iter->width, \
|
|
iter->buffer, mask, \
|
|
convert_ ## format, \
|
|
PIXMAN_ ## format, \
|
|
repeat_mode); \
|
|
return iter->buffer; \
|
|
}
|
|
|
|
#define MAKE_FETCHERS(name, format, repeat_mode) \
|
|
MAKE_NEAREST_FETCHER (name, format, repeat_mode) \
|
|
MAKE_BILINEAR_FETCHER (name, format, repeat_mode) \
|
|
MAKE_SEPARABLE_CONVOLUTION_FETCHER (name, format, repeat_mode)
|
|
|
|
MAKE_FETCHERS (pad_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_PAD)
|
|
MAKE_FETCHERS (none_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_NONE)
|
|
MAKE_FETCHERS (reflect_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_REFLECT)
|
|
MAKE_FETCHERS (normal_a8r8g8b8, a8r8g8b8, PIXMAN_REPEAT_NORMAL)
|
|
MAKE_FETCHERS (pad_x8r8g8b8, x8r8g8b8, PIXMAN_REPEAT_PAD)
|
|
MAKE_FETCHERS (none_x8r8g8b8, x8r8g8b8, PIXMAN_REPEAT_NONE)
|
|
MAKE_FETCHERS (reflect_x8r8g8b8, x8r8g8b8, PIXMAN_REPEAT_REFLECT)
|
|
MAKE_FETCHERS (normal_x8r8g8b8, x8r8g8b8, PIXMAN_REPEAT_NORMAL)
|
|
MAKE_FETCHERS (pad_a8, a8, PIXMAN_REPEAT_PAD)
|
|
MAKE_FETCHERS (none_a8, a8, PIXMAN_REPEAT_NONE)
|
|
MAKE_FETCHERS (reflect_a8, a8, PIXMAN_REPEAT_REFLECT)
|
|
MAKE_FETCHERS (normal_a8, a8, PIXMAN_REPEAT_NORMAL)
|
|
MAKE_FETCHERS (pad_r5g6b5, r5g6b5, PIXMAN_REPEAT_PAD)
|
|
MAKE_FETCHERS (none_r5g6b5, r5g6b5, PIXMAN_REPEAT_NONE)
|
|
MAKE_FETCHERS (reflect_r5g6b5, r5g6b5, PIXMAN_REPEAT_REFLECT)
|
|
MAKE_FETCHERS (normal_r5g6b5, r5g6b5, PIXMAN_REPEAT_NORMAL)
|
|
|
|
static void
|
|
replicate_pixel_32 (bits_image_t * bits,
|
|
int x,
|
|
int y,
|
|
int width,
|
|
uint32_t * buffer)
|
|
{
|
|
uint32_t color;
|
|
uint32_t *end;
|
|
|
|
color = bits->fetch_pixel_32 (bits, x, y);
|
|
|
|
end = buffer + width;
|
|
while (buffer < end)
|
|
*(buffer++) = color;
|
|
}
|
|
|
|
static void
|
|
replicate_pixel_float (bits_image_t * bits,
|
|
int x,
|
|
int y,
|
|
int width,
|
|
uint32_t * b)
|
|
{
|
|
argb_t color;
|
|
argb_t *buffer = (argb_t *)b;
|
|
argb_t *end;
|
|
|
|
color = bits->fetch_pixel_float (bits, x, y);
|
|
|
|
end = buffer + width;
|
|
while (buffer < end)
|
|
*(buffer++) = color;
|
|
}
|
|
|
|
static void
|
|
bits_image_fetch_untransformed_repeat_none (bits_image_t *image,
|
|
pixman_bool_t wide,
|
|
int x,
|
|
int y,
|
|
int width,
|
|
uint32_t * buffer)
|
|
{
|
|
uint32_t w;
|
|
|
|
if (y < 0 || y >= image->height)
|
|
{
|
|
memset (buffer, 0, width * (wide? sizeof (argb_t) : 4));
|
|
return;
|
|
}
|
|
|
|
if (x < 0)
|
|
{
|
|
w = MIN (width, -x);
|
|
|
|
memset (buffer, 0, w * (wide ? sizeof (argb_t) : 4));
|
|
|
|
width -= w;
|
|
buffer += w * (wide? 4 : 1);
|
|
x += w;
|
|
}
|
|
|
|
if (x < image->width)
|
|
{
|
|
w = MIN (width, image->width - x);
|
|
|
|
if (wide)
|
|
image->fetch_scanline_float ((pixman_image_t *)image, x, y, w, buffer, NULL);
|
|
else
|
|
image->fetch_scanline_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);
|
|
|
|
width -= w;
|
|
buffer += w * (wide? 4 : 1);
|
|
x += w;
|
|
}
|
|
|
|
memset (buffer, 0, width * (wide ? sizeof (argb_t) : 4));
|
|
}
|
|
|
|
static void
|
|
bits_image_fetch_untransformed_repeat_normal (bits_image_t *image,
|
|
pixman_bool_t wide,
|
|
int x,
|
|
int y,
|
|
int width,
|
|
uint32_t * buffer)
|
|
{
|
|
uint32_t w;
|
|
|
|
while (y < 0)
|
|
y += image->height;
|
|
|
|
while (y >= image->height)
|
|
y -= image->height;
|
|
|
|
if (image->width == 1)
|
|
{
|
|
if (wide)
|
|
replicate_pixel_float (image, 0, y, width, buffer);
|
|
else
|
|
replicate_pixel_32 (image, 0, y, width, buffer);
|
|
|
|
return;
|
|
}
|
|
|
|
while (width)
|
|
{
|
|
while (x < 0)
|
|
x += image->width;
|
|
while (x >= image->width)
|
|
x -= image->width;
|
|
|
|
w = MIN (width, image->width - x);
|
|
|
|
if (wide)
|
|
image->fetch_scanline_float ((pixman_image_t *)image, x, y, w, buffer, NULL);
|
|
else
|
|
image->fetch_scanline_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);
|
|
|
|
buffer += w * (wide? 4 : 1);
|
|
x += w;
|
|
width -= w;
|
|
}
|
|
}
|
|
|
|
static uint32_t *
|
|
bits_image_fetch_untransformed_32 (pixman_iter_t * iter,
|
|
const uint32_t *mask)
|
|
{
|
|
pixman_image_t *image = iter->image;
|
|
int x = iter->x;
|
|
int y = iter->y;
|
|
int width = iter->width;
|
|
uint32_t * buffer = iter->buffer;
|
|
|
|
if (image->common.repeat == PIXMAN_REPEAT_NONE)
|
|
{
|
|
bits_image_fetch_untransformed_repeat_none (
|
|
&image->bits, FALSE, x, y, width, buffer);
|
|
}
|
|
else
|
|
{
|
|
bits_image_fetch_untransformed_repeat_normal (
|
|
&image->bits, FALSE, x, y, width, buffer);
|
|
}
|
|
|
|
iter->y++;
|
|
return buffer;
|
|
}
|
|
|
|
static uint32_t *
|
|
bits_image_fetch_untransformed_float (pixman_iter_t * iter,
|
|
const uint32_t *mask)
|
|
{
|
|
pixman_image_t *image = iter->image;
|
|
int x = iter->x;
|
|
int y = iter->y;
|
|
int width = iter->width;
|
|
uint32_t * buffer = iter->buffer;
|
|
|
|
if (image->common.repeat == PIXMAN_REPEAT_NONE)
|
|
{
|
|
bits_image_fetch_untransformed_repeat_none (
|
|
&image->bits, TRUE, x, y, width, buffer);
|
|
}
|
|
else
|
|
{
|
|
bits_image_fetch_untransformed_repeat_normal (
|
|
&image->bits, TRUE, x, y, width, buffer);
|
|
}
|
|
|
|
iter->y++;
|
|
return buffer;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
pixman_format_code_t format;
|
|
uint32_t flags;
|
|
pixman_iter_get_scanline_t get_scanline_32;
|
|
pixman_iter_get_scanline_t get_scanline_float;
|
|
} fetcher_info_t;
|
|
|
|
static const fetcher_info_t fetcher_info[] =
|
|
{
|
|
{ PIXMAN_any,
|
|
(FAST_PATH_NO_ALPHA_MAP |
|
|
FAST_PATH_ID_TRANSFORM |
|
|
FAST_PATH_NO_CONVOLUTION_FILTER |
|
|
FAST_PATH_NO_PAD_REPEAT |
|
|
FAST_PATH_NO_REFLECT_REPEAT),
|
|
bits_image_fetch_untransformed_32,
|
|
bits_image_fetch_untransformed_float
|
|
},
|
|
|
|
#define FAST_BILINEAR_FLAGS \
|
|
(FAST_PATH_NO_ALPHA_MAP | \
|
|
FAST_PATH_NO_ACCESSORS | \
|
|
FAST_PATH_HAS_TRANSFORM | \
|
|
FAST_PATH_AFFINE_TRANSFORM | \
|
|
FAST_PATH_X_UNIT_POSITIVE | \
|
|
FAST_PATH_Y_UNIT_ZERO | \
|
|
FAST_PATH_NONE_REPEAT | \
|
|
FAST_PATH_BILINEAR_FILTER)
|
|
|
|
{ PIXMAN_a8r8g8b8,
|
|
FAST_BILINEAR_FLAGS,
|
|
bits_image_fetch_bilinear_no_repeat_8888,
|
|
_pixman_image_get_scanline_generic_float
|
|
},
|
|
|
|
{ PIXMAN_x8r8g8b8,
|
|
FAST_BILINEAR_FLAGS,
|
|
bits_image_fetch_bilinear_no_repeat_8888,
|
|
_pixman_image_get_scanline_generic_float
|
|
},
|
|
|
|
#define GENERAL_BILINEAR_FLAGS \
|
|
(FAST_PATH_NO_ALPHA_MAP | \
|
|
FAST_PATH_NO_ACCESSORS | \
|
|
FAST_PATH_HAS_TRANSFORM | \
|
|
FAST_PATH_AFFINE_TRANSFORM | \
|
|
FAST_PATH_BILINEAR_FILTER)
|
|
|
|
#define GENERAL_NEAREST_FLAGS \
|
|
(FAST_PATH_NO_ALPHA_MAP | \
|
|
FAST_PATH_NO_ACCESSORS | \
|
|
FAST_PATH_HAS_TRANSFORM | \
|
|
FAST_PATH_AFFINE_TRANSFORM | \
|
|
FAST_PATH_NEAREST_FILTER)
|
|
|
|
#define GENERAL_SEPARABLE_CONVOLUTION_FLAGS \
|
|
(FAST_PATH_NO_ALPHA_MAP | \
|
|
FAST_PATH_NO_ACCESSORS | \
|
|
FAST_PATH_HAS_TRANSFORM | \
|
|
FAST_PATH_AFFINE_TRANSFORM | \
|
|
FAST_PATH_SEPARABLE_CONVOLUTION_FILTER)
|
|
|
|
#define SEPARABLE_CONVOLUTION_AFFINE_FAST_PATH(name, format, repeat) \
|
|
{ PIXMAN_ ## format, \
|
|
GENERAL_SEPARABLE_CONVOLUTION_FLAGS | FAST_PATH_ ## repeat ## _REPEAT, \
|
|
bits_image_fetch_separable_convolution_affine_ ## name, \
|
|
_pixman_image_get_scanline_generic_float \
|
|
},
|
|
|
|
#define BILINEAR_AFFINE_FAST_PATH(name, format, repeat) \
|
|
{ PIXMAN_ ## format, \
|
|
GENERAL_BILINEAR_FLAGS | FAST_PATH_ ## repeat ## _REPEAT, \
|
|
bits_image_fetch_bilinear_affine_ ## name, \
|
|
_pixman_image_get_scanline_generic_float \
|
|
},
|
|
|
|
#define NEAREST_AFFINE_FAST_PATH(name, format, repeat) \
|
|
{ PIXMAN_ ## format, \
|
|
GENERAL_NEAREST_FLAGS | FAST_PATH_ ## repeat ## _REPEAT, \
|
|
bits_image_fetch_nearest_affine_ ## name, \
|
|
_pixman_image_get_scanline_generic_float \
|
|
},
|
|
|
|
#define AFFINE_FAST_PATHS(name, format, repeat) \
|
|
SEPARABLE_CONVOLUTION_AFFINE_FAST_PATH(name, format, repeat) \
|
|
BILINEAR_AFFINE_FAST_PATH(name, format, repeat) \
|
|
NEAREST_AFFINE_FAST_PATH(name, format, repeat)
|
|
|
|
AFFINE_FAST_PATHS (pad_a8r8g8b8, a8r8g8b8, PAD)
|
|
AFFINE_FAST_PATHS (none_a8r8g8b8, a8r8g8b8, NONE)
|
|
AFFINE_FAST_PATHS (reflect_a8r8g8b8, a8r8g8b8, REFLECT)
|
|
AFFINE_FAST_PATHS (normal_a8r8g8b8, a8r8g8b8, NORMAL)
|
|
AFFINE_FAST_PATHS (pad_x8r8g8b8, x8r8g8b8, PAD)
|
|
AFFINE_FAST_PATHS (none_x8r8g8b8, x8r8g8b8, NONE)
|
|
AFFINE_FAST_PATHS (reflect_x8r8g8b8, x8r8g8b8, REFLECT)
|
|
AFFINE_FAST_PATHS (normal_x8r8g8b8, x8r8g8b8, NORMAL)
|
|
AFFINE_FAST_PATHS (pad_a8, a8, PAD)
|
|
AFFINE_FAST_PATHS (none_a8, a8, NONE)
|
|
AFFINE_FAST_PATHS (reflect_a8, a8, REFLECT)
|
|
AFFINE_FAST_PATHS (normal_a8, a8, NORMAL)
|
|
AFFINE_FAST_PATHS (pad_r5g6b5, r5g6b5, PAD)
|
|
AFFINE_FAST_PATHS (none_r5g6b5, r5g6b5, NONE)
|
|
AFFINE_FAST_PATHS (reflect_r5g6b5, r5g6b5, REFLECT)
|
|
AFFINE_FAST_PATHS (normal_r5g6b5, r5g6b5, NORMAL)
|
|
|
|
/* Affine, no alpha */
|
|
{ PIXMAN_any,
|
|
(FAST_PATH_NO_ALPHA_MAP | FAST_PATH_HAS_TRANSFORM | FAST_PATH_AFFINE_TRANSFORM),
|
|
bits_image_fetch_affine_no_alpha,
|
|
_pixman_image_get_scanline_generic_float
|
|
},
|
|
|
|
/* General */
|
|
{ PIXMAN_any,
|
|
0,
|
|
bits_image_fetch_general,
|
|
_pixman_image_get_scanline_generic_float
|
|
},
|
|
|
|
{ PIXMAN_null },
|
|
};
|
|
|
|
static void
|
|
bits_image_property_changed (pixman_image_t *image)
|
|
{
|
|
_pixman_bits_image_setup_accessors (&image->bits);
|
|
}
|
|
|
|
void
|
|
_pixman_bits_image_src_iter_init (pixman_image_t *image, pixman_iter_t *iter)
|
|
{
|
|
pixman_format_code_t format = image->common.extended_format_code;
|
|
uint32_t flags = image->common.flags;
|
|
const fetcher_info_t *info;
|
|
|
|
for (info = fetcher_info; info->format != PIXMAN_null; ++info)
|
|
{
|
|
if ((info->format == format || info->format == PIXMAN_any) &&
|
|
(info->flags & flags) == info->flags)
|
|
{
|
|
if (iter->iter_flags & ITER_NARROW)
|
|
{
|
|
iter->get_scanline = info->get_scanline_32;
|
|
}
|
|
else
|
|
{
|
|
iter->data = info->get_scanline_32;
|
|
iter->get_scanline = info->get_scanline_float;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Just in case we somehow didn't find a scanline function */
|
|
iter->get_scanline = _pixman_iter_get_scanline_noop;
|
|
}
|
|
|
|
static uint32_t *
|
|
dest_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)
|
|
{
|
|
pixman_image_t *image = iter->image;
|
|
int x = iter->x;
|
|
int y = iter->y;
|
|
int width = iter->width;
|
|
uint32_t * buffer = iter->buffer;
|
|
|
|
image->bits.fetch_scanline_32 (image, x, y, width, buffer, mask);
|
|
if (image->common.alpha_map)
|
|
{
|
|
uint32_t *alpha;
|
|
|
|
if ((alpha = malloc (width * sizeof (uint32_t))))
|
|
{
|
|
int i;
|
|
|
|
x -= image->common.alpha_origin_x;
|
|
y -= image->common.alpha_origin_y;
|
|
|
|
image->common.alpha_map->fetch_scanline_32 (
|
|
(pixman_image_t *)image->common.alpha_map,
|
|
x, y, width, alpha, mask);
|
|
|
|
for (i = 0; i < width; ++i)
|
|
{
|
|
buffer[i] &= ~0xff000000;
|
|
buffer[i] |= (alpha[i] & 0xff000000);
|
|
}
|
|
|
|
free (alpha);
|
|
}
|
|
}
|
|
|
|
return iter->buffer;
|
|
}
|
|
|
|
static uint32_t *
|
|
dest_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
|
|
{
|
|
bits_image_t * image = &iter->image->bits;
|
|
int x = iter->x;
|
|
int y = iter->y;
|
|
int width = iter->width;
|
|
argb_t * buffer = (argb_t *)iter->buffer;
|
|
|
|
image->fetch_scanline_float (
|
|
(pixman_image_t *)image, x, y, width, (uint32_t *)buffer, mask);
|
|
if (image->common.alpha_map)
|
|
{
|
|
argb_t *alpha;
|
|
|
|
if ((alpha = malloc (width * sizeof (argb_t))))
|
|
{
|
|
int i;
|
|
|
|
x -= image->common.alpha_origin_x;
|
|
y -= image->common.alpha_origin_y;
|
|
|
|
image->common.alpha_map->fetch_scanline_float (
|
|
(pixman_image_t *)image->common.alpha_map,
|
|
x, y, width, (uint32_t *)alpha, mask);
|
|
|
|
for (i = 0; i < width; ++i)
|
|
buffer[i].a = alpha[i].a;
|
|
|
|
free (alpha);
|
|
}
|
|
}
|
|
|
|
return iter->buffer;
|
|
}
|
|
|
|
static void
|
|
dest_write_back_narrow (pixman_iter_t *iter)
|
|
{
|
|
bits_image_t * image = &iter->image->bits;
|
|
int x = iter->x;
|
|
int y = iter->y;
|
|
int width = iter->width;
|
|
const uint32_t *buffer = iter->buffer;
|
|
|
|
image->store_scanline_32 (image, x, y, width, buffer);
|
|
|
|
if (image->common.alpha_map)
|
|
{
|
|
x -= image->common.alpha_origin_x;
|
|
y -= image->common.alpha_origin_y;
|
|
|
|
image->common.alpha_map->store_scanline_32 (
|
|
image->common.alpha_map, x, y, width, buffer);
|
|
}
|
|
|
|
iter->y++;
|
|
}
|
|
|
|
static void
|
|
dest_write_back_wide (pixman_iter_t *iter)
|
|
{
|
|
bits_image_t * image = &iter->image->bits;
|
|
int x = iter->x;
|
|
int y = iter->y;
|
|
int width = iter->width;
|
|
const uint32_t *buffer = iter->buffer;
|
|
|
|
image->store_scanline_float (image, x, y, width, buffer);
|
|
|
|
if (image->common.alpha_map)
|
|
{
|
|
x -= image->common.alpha_origin_x;
|
|
y -= image->common.alpha_origin_y;
|
|
|
|
image->common.alpha_map->store_scanline_float (
|
|
image->common.alpha_map, x, y, width, buffer);
|
|
}
|
|
|
|
iter->y++;
|
|
}
|
|
|
|
void
|
|
_pixman_bits_image_dest_iter_init (pixman_image_t *image, pixman_iter_t *iter)
|
|
{
|
|
if (iter->iter_flags & ITER_NARROW)
|
|
{
|
|
if ((iter->iter_flags & (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA)) ==
|
|
(ITER_IGNORE_RGB | ITER_IGNORE_ALPHA))
|
|
{
|
|
iter->get_scanline = _pixman_iter_get_scanline_noop;
|
|
}
|
|
else
|
|
{
|
|
iter->get_scanline = dest_get_scanline_narrow;
|
|
}
|
|
|
|
iter->write_back = dest_write_back_narrow;
|
|
}
|
|
else
|
|
{
|
|
iter->get_scanline = dest_get_scanline_wide;
|
|
iter->write_back = dest_write_back_wide;
|
|
}
|
|
}
|
|
|
|
static uint32_t *
|
|
create_bits (pixman_format_code_t format,
|
|
int width,
|
|
int height,
|
|
int * rowstride_bytes,
|
|
pixman_bool_t clear)
|
|
{
|
|
int stride;
|
|
size_t buf_size;
|
|
int bpp;
|
|
|
|
/* what follows is a long-winded way, avoiding any possibility of integer
|
|
* overflows, of saying:
|
|
* stride = ((width * bpp + 0x1f) >> 5) * sizeof (uint32_t);
|
|
*/
|
|
|
|
bpp = PIXMAN_FORMAT_BPP (format);
|
|
if (_pixman_multiply_overflows_int (width, bpp))
|
|
return NULL;
|
|
|
|
stride = width * bpp;
|
|
if (_pixman_addition_overflows_int (stride, 0x1f))
|
|
return NULL;
|
|
|
|
stride += 0x1f;
|
|
stride >>= 5;
|
|
|
|
stride *= sizeof (uint32_t);
|
|
|
|
if (_pixman_multiply_overflows_size (height, stride))
|
|
return NULL;
|
|
|
|
buf_size = height * stride;
|
|
|
|
if (rowstride_bytes)
|
|
*rowstride_bytes = stride;
|
|
|
|
if (clear)
|
|
return calloc (buf_size, 1);
|
|
else
|
|
return malloc (buf_size);
|
|
}
|
|
|
|
pixman_bool_t
|
|
_pixman_bits_image_init (pixman_image_t * image,
|
|
pixman_format_code_t format,
|
|
int width,
|
|
int height,
|
|
uint32_t * bits,
|
|
int rowstride,
|
|
pixman_bool_t clear)
|
|
{
|
|
uint32_t *free_me = NULL;
|
|
|
|
if (!bits && width && height)
|
|
{
|
|
int rowstride_bytes;
|
|
|
|
free_me = bits = create_bits (format, width, height, &rowstride_bytes, clear);
|
|
|
|
if (!bits)
|
|
return FALSE;
|
|
|
|
rowstride = rowstride_bytes / (int) sizeof (uint32_t);
|
|
}
|
|
|
|
_pixman_image_init (image);
|
|
|
|
image->type = BITS;
|
|
image->bits.format = format;
|
|
image->bits.width = width;
|
|
image->bits.height = height;
|
|
image->bits.bits = bits;
|
|
image->bits.free_me = free_me;
|
|
image->bits.read_func = NULL;
|
|
image->bits.write_func = NULL;
|
|
image->bits.rowstride = rowstride;
|
|
image->bits.indexed = NULL;
|
|
|
|
image->common.property_changed = bits_image_property_changed;
|
|
|
|
_pixman_image_reset_clip_region (image);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static pixman_image_t *
|
|
create_bits_image_internal (pixman_format_code_t format,
|
|
int width,
|
|
int height,
|
|
uint32_t * bits,
|
|
int rowstride_bytes,
|
|
pixman_bool_t clear)
|
|
{
|
|
pixman_image_t *image;
|
|
|
|
/* must be a whole number of uint32_t's
|
|
*/
|
|
return_val_if_fail (
|
|
bits == NULL || (rowstride_bytes % sizeof (uint32_t)) == 0, NULL);
|
|
|
|
return_val_if_fail (PIXMAN_FORMAT_BPP (format) >= PIXMAN_FORMAT_DEPTH (format), NULL);
|
|
|
|
image = _pixman_image_allocate ();
|
|
|
|
if (!image)
|
|
return NULL;
|
|
|
|
if (!_pixman_bits_image_init (image, format, width, height, bits,
|
|
rowstride_bytes / (int) sizeof (uint32_t),
|
|
clear))
|
|
{
|
|
free (image);
|
|
return NULL;
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
/* If bits is NULL, a buffer will be allocated and initialized to 0 */
|
|
PIXMAN_EXPORT pixman_image_t *
|
|
pixman_image_create_bits (pixman_format_code_t format,
|
|
int width,
|
|
int height,
|
|
uint32_t * bits,
|
|
int rowstride_bytes)
|
|
{
|
|
return create_bits_image_internal (
|
|
format, width, height, bits, rowstride_bytes, TRUE);
|
|
}
|
|
|
|
|
|
/* If bits is NULL, a buffer will be allocated and _not_ initialized */
|
|
PIXMAN_EXPORT pixman_image_t *
|
|
pixman_image_create_bits_no_clear (pixman_format_code_t format,
|
|
int width,
|
|
int height,
|
|
uint32_t * bits,
|
|
int rowstride_bytes)
|
|
{
|
|
return create_bits_image_internal (
|
|
format, width, height, bits, rowstride_bytes, FALSE);
|
|
}
|