int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = (const uint32_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
int y,
int width,
uint32_t * b,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = bits + x;
int y,
int width,
uint32_t * b,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
int y,
int width,
uint32_t * b,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = bits + x;
int y,
int width,
uint32_t * b,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint32_t *pixel = (uint32_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + 3 * x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + 3 * x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint16_t *pixel = (const uint16_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const pixman_indexed_t * indexed = image->bits.indexed;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const uint8_t *pixel = (const uint8_t *)bits + x;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
int i;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
int i;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
int i;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
uint32_t a, r, g, b;
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
int i;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const pixman_indexed_t * indexed = image->bits.indexed;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
int i;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + y * image->bits.rowstride;
const pixman_indexed_t * indexed = image->bits.indexed;
int line,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
const uint32_t *bits = image->bits.bits + image->bits.rowstride * line;
int i;
int line,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
YV12_SETUP (image);
uint8_t *y_line = YV12_Y (line);
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
/* Fetch the pixels into the first half of buffer and then expand them in
* place.
*/
- image->bits.fetch_scanline_raw_32 (image, x, y, width, buffer, NULL, 0);
+ image->bits.fetch_scanline_raw_32 (image, x, y, width, buffer, NULL);
pixman_expand ((uint64_t *)buffer, buffer, image->bits.format, width);
}
int line,
int width,
uint32_t * buffer,
- const uint32_t * mask,
- uint32_t mask_bits)
+ const uint32_t * mask)
{
bits_image_t *bits = &ima->bits;
pixman_fixed_t x_top, x_bottom, x;
*/
if (!mask)
{
+ uint32_t mask_bits = 1;
+
mask_inc = 0;
- mask_bits = 1;
mask = &mask_bits;
}
else
int line,
int width,
uint32_t * buffer,
- const uint32_t * mask,
- uint32_t mask_bits)
+ const uint32_t * mask)
{
pixman_fixed_t x, y, w;
pixman_fixed_t ux, uy, uw;
{
for (i = 0; i < width; ++i)
{
- if (!mask || (mask[i] & mask_bits))
+ if (!mask || mask[i])
{
buffer[i] =
bits_image_fetch_pixel_filtered (&image->bits, x, y);
{
pixman_fixed_t x0, y0;
- if (!mask || (mask[i] & mask_bits))
+ if (!mask || mask[i])
{
x0 = ((pixman_fixed_48_16_t)x << 16) / w;
y0 = ((pixman_fixed_48_16_t)y << 16) / w;
int y,
int width,
uint32_t * buffer,
- const uint32_t * mask,
- uint32_t mask_bits)
+ const uint32_t * mask)
{
uint32_t color;
uint32_t *end;
int y,
int width,
uint32_t * b,
- const uint32_t * unused,
- uint32_t unused2)
+ const uint32_t * unused)
{
uint64_t color;
uint64_t *buffer = (uint64_t *)b;
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_64 ((pixman_image_t *)image, x, y, w, buffer, NULL);
else
- image->fetch_scanline_raw_32 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);
width -= w;
buffer += w * (wide? 2 : 1);
w = MIN (width, image->width - x);
if (wide)
- image->fetch_scanline_raw_64 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_64 ((pixman_image_t *)image, x, y, w, buffer, NULL);
else
- image->fetch_scanline_raw_32 ((pixman_image_t *)image, x, y, w, buffer, NULL, 0);
+ image->fetch_scanline_raw_32 ((pixman_image_t *)image, x, y, w, buffer, NULL);
buffer += w * (wide? 2 : 1);
x += w;
int y,
int width,
uint32_t * buffer,
- const uint32_t * mask,
- uint32_t mask_bits)
+ const uint32_t * mask)
{
if (image->common.repeat == PIXMAN_REPEAT_NONE)
{
int y,
int width,
uint32_t * buffer,
- const uint32_t * unused,
- uint32_t unused2)
+ const uint32_t * unused)
{
if (image->common.repeat == PIXMAN_REPEAT_NONE)
{
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
source_image_t *source = (source_image_t *)image;
gradient_t *gradient = (gradient_t *)source;
{
double angle;
- if (!mask || *mask++ & mask_bits)
+ if (!mask || *mask++)
{
pixman_fixed_48_16_t t;
double x, y;
double angle;
- if (!mask || *mask++ & mask_bits)
+ if (!mask || *mask++)
{
pixman_fixed_48_16_t t;
/* fetch mask before source so that fetching of
source can be optimized */
fetch_mask (mask, mask_x, mask_y + i,
- width, (void *)mask_buffer, 0, 0);
+ width, (void *)mask_buffer, 0);
if (mask_class == SOURCE_IMAGE_CLASS_HORIZONTAL)
fetch_mask = NULL;
if (src_class == SOURCE_IMAGE_CLASS_HORIZONTAL)
{
fetch_src (src, src_x, src_y + i,
- width, (void *)src_buffer, 0, 0);
+ width, (void *)src_buffer, 0);
fetch_src = NULL;
}
else
{
fetch_src (src, src_x, src_y + i,
- width, (void *)src_buffer, (void *)mask_buffer,
- 0xffffffff);
+ width, (void *)src_buffer, (void *)mask_buffer);
}
}
else if (fetch_mask)
{
fetch_mask (mask, mask_x, mask_y + i,
- width, (void *)mask_buffer, 0, 0);
+ width, (void *)mask_buffer, 0);
}
if (store)
if (fetch_dest)
{
fetch_dest (dest, dest_x, dest_y + i,
- width, (void *)dest_buffer, 0, 0);
+ width, (void *)dest_buffer, 0);
}
/* blend */
int y,
int width,
uint32_t * buffer,
- const uint32_t * mask,
- uint32_t mask_bits)
+ const uint32_t * mask)
{
uint32_t *mask8 = NULL;
}
/* Fetch the source image into the first half of buffer. */
- _pixman_image_get_scanline_32 (image, x, y, width, (uint32_t*)buffer, mask8,
- mask_bits);
+ _pixman_image_get_scanline_32 (image, x, y, width, (uint32_t*)buffer, mask8);
/* Expand from 32bpp to 64bpp in place. */
pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, width);
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
- image->common.get_scanline_32 (image, x, y, width, buffer, mask, mask_bits);
+ image->common.get_scanline_32 (image, x, y, width, buffer, mask);
}
/* Even thought the type of buffer is uint32_t *, the function actually expects
int y,
int width,
uint32_t * buffer,
- const uint32_t *unused,
- uint32_t unused2)
+ const uint32_t *unused)
{
- image->common.get_scanline_64 (image, x, y, width, buffer, unused, unused2);
+ image->common.get_scanline_64 (image, x, y, width, buffer, unused);
}
static void
{
uint32_t result;
- _pixman_image_get_scanline_32 (image, 0, 0, 1, &result, NULL, 0);
+ _pixman_image_get_scanline_32 (image, 0, 0, 1, &result, NULL);
/* If necessary, convert RGB <--> BGR. */
if (PIXMAN_FORMAT_TYPE (format) != PIXMAN_TYPE_ARGB)
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
pixman_vector_t v, unit;
pixman_fixed_32_32_t l;
{
while (buffer < end)
{
- if (*mask++ & mask_bits)
+ if (*mask++)
*buffer = _pixman_gradient_walker_pixel (&walker, t);
buffer++;
{
while (buffer < end)
{
- if (!mask || *mask++ & mask_bits)
+ if (!mask || *mask++)
{
if (v.vector[2] == 0)
{
y = ((pixman_fixed_48_16_t)v.vector[1] << 16) / v.vector[2];
t = ((a * x + b * y) >> 16) + off;
}
-
+
*buffer = _pixman_gradient_walker_pixel (&walker, t);
}
-
+
++buffer;
-
+
v.vector[0] += unit.vector[0];
v.vector[1] += unit.vector[1];
v.vector[2] += unit.vector[2];
int y,
int width,
uint32_t *buffer,
- const uint32_t *mask,
- uint32_t mask_bits);
+ const uint32_t *mask);
typedef uint32_t (*fetch_pixel_32_t) (bits_image_t *image,
int x,
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits);
+ const uint32_t *mask);
source_image_class_t
_pixman_image_classify (pixman_image_t *image,
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits);
+ const uint32_t *mask);
/* Even thought the type of buffer is uint32_t *, the function actually expects
* a uint64_t *buffer.
int y,
int width,
uint32_t * buffer,
- const uint32_t *unused,
- uint32_t unused2);
+ const uint32_t *unused);
void
_pixman_image_store_scanline_32 (bits_image_t * image,
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
/*
* In the radial gradient problem we are given two circles (c₁,r₁) and
while (buffer < end)
{
- if (!mask || *mask++ & mask_bits)
+ if (!mask || *mask++)
{
pixman_fixed_48_16_t t;
double det = B * B + A4 * (pdx * pdx + pdy * pdy - r1sq);
/* projective */
while (buffer < end)
{
- if (!mask || *mask++ & mask_bits)
+ if (!mask || *mask++)
{
double pdx, pdy;
double B, C;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
uint32_t *end = buffer + width;
uint32_t color = image->solid.color_32;
int y,
int width,
uint32_t * buffer,
- const uint32_t *mask,
- uint32_t mask_bits)
+ const uint32_t *mask)
{
uint64_t *b = (uint64_t *)buffer;
uint64_t *e = b + width;