зеркало из https://github.com/mozilla/gecko-dev.git
Bug 484076 - Update pixman and cairo to newer upstream versions. r=vlad
Pixman revision is 072d848f592530973f1f0a0066a320ec5965625c Cairo revision is 3ec94f9b5917b8f71304c982bd153e5a810f3b12
This commit is contained in:
Jeff Muizelaar
Родитель
ef4d1781b6
Коммит
9524f81b71
|
|
@ -108,6 +108,7 @@ CSRCS = \
|
|||
pixman-edge.c \
|
||||
pixman-edge-accessors.c \
|
||||
pixman-image.c \
|
||||
pixman-matrix.c \
|
||||
pixman-pict.c \
|
||||
pixman-region16.c \
|
||||
pixman-region32.c \
|
||||
|
|
|
|||
|
|
@ -60,7 +60,9 @@ fbCompositeSrcAdd_8000x8000arm (pixman_op_t op,
|
|||
srcLine += srcStride;
|
||||
w = width;
|
||||
|
||||
while (w && (unsigned long)dst & 3)
|
||||
/* ensure both src and dst are properly aligned before doing 32 bit reads
|
||||
* we'll stay in this loop if src and dst have differing alignments */
|
||||
while (w && (((unsigned long)dst & 3) || ((unsigned long)src & 3)))
|
||||
{
|
||||
s = *src;
|
||||
d = *dst;
|
||||
|
|
@ -164,7 +166,7 @@ fbCompositeSrc_8888x8888arm (pixman_op_t op,
|
|||
"uxtab16 r7, r7, r7, ror #8\n\t"
|
||||
|
||||
/* recombine the 0xff00ff00 bytes of r6 and r7 */
|
||||
"and r7, %[upper_component_mask]\n\t"
|
||||
"and r7, r7, %[upper_component_mask]\n\t"
|
||||
"uxtab16 r6, r7, r6, ror #8\n\t"
|
||||
|
||||
"uqadd8 r5, r6, r5\n\t"
|
||||
|
|
|
|||
|
|
@ -543,12 +543,12 @@ PIXMAN_COMPOSITE_RECT_GENERAL (const FbComposeData *data,
|
|||
|
||||
#ifndef PIXMAN_FB_ACCESSORS
|
||||
|
||||
#define SCANLINE_BUFFER_LENGTH 2048
|
||||
#define SCANLINE_BUFFER_LENGTH 8192
|
||||
|
||||
void
|
||||
pixman_composite_rect_general (const FbComposeData *data)
|
||||
{
|
||||
uint32_t _scanline_buffer[SCANLINE_BUFFER_LENGTH * 3];
|
||||
uint8_t stack_scanline_buffer[SCANLINE_BUFFER_LENGTH * 3];
|
||||
const pixman_format_code_t srcFormat = data->src->type == BITS ? data->src->bits.format : 0;
|
||||
const pixman_format_code_t maskFormat = data->mask && data->mask->type == BITS ? data->mask->bits.format : 0;
|
||||
const pixman_format_code_t destFormat = data->dest->type == BITS ? data->dest->bits.format : 0;
|
||||
|
|
@ -557,10 +557,10 @@ pixman_composite_rect_general (const FbComposeData *data)
|
|||
const int destWide = PIXMAN_FORMAT_16BPC(destFormat);
|
||||
const int wide = srcWide || maskWide || destWide;
|
||||
const int Bpp = wide ? 8 : 4;
|
||||
uint8_t *scanline_buffer = (uint8_t*)_scanline_buffer;
|
||||
uint8_t *scanline_buffer = stack_scanline_buffer;
|
||||
uint8_t *src_buffer, *mask_buffer, *dest_buffer;
|
||||
|
||||
if (data->width * Bpp > SCANLINE_BUFFER_LENGTH * sizeof(uint32_t))
|
||||
if (data->width * Bpp > SCANLINE_BUFFER_LENGTH)
|
||||
{
|
||||
scanline_buffer = pixman_malloc_abc (data->width, 3, Bpp);
|
||||
|
||||
|
|
@ -589,7 +589,7 @@ pixman_composite_rect_general (const FbComposeData *data)
|
|||
wide);
|
||||
}
|
||||
|
||||
if ((void*)scanline_buffer != (void*)_scanline_buffer)
|
||||
if (scanline_buffer != stack_scanline_buffer)
|
||||
free (scanline_buffer);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,626 @@
|
|||
/*
|
||||
* Copyright © 2008 Keith Packard
|
||||
*
|
||||
* 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 the copyright holders not be used in advertising or
|
||||
* publicity pertaining to distribution of the software without specific,
|
||||
* written prior permission. The copyright holders make 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Matrix interfaces
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include "pixman-private.h"
|
||||
|
||||
#define F(x) pixman_int_to_fixed(x)
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_transform_init_identity(struct pixman_transform *matrix)
|
||||
{
|
||||
int i;
|
||||
|
||||
memset(matrix, '\0', sizeof (struct pixman_transform));
|
||||
for (i = 0; i < 3; i++)
|
||||
matrix->matrix[i][i] = F(1);
|
||||
}
|
||||
|
||||
typedef pixman_fixed_32_32_t pixman_fixed_34_30_t;
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_point_3d(const struct pixman_transform *transform,
|
||||
struct pixman_vector *vector)
|
||||
{
|
||||
struct pixman_vector result;
|
||||
pixman_fixed_32_32_t partial;
|
||||
pixman_fixed_48_16_t v;
|
||||
int i, j;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
v = 0;
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
partial = ((pixman_fixed_48_16_t) transform->matrix[j][i] *
|
||||
(pixman_fixed_48_16_t) vector->vector[i]);
|
||||
v += partial >> 16;
|
||||
}
|
||||
if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)
|
||||
return FALSE;
|
||||
result.vector[j] = (pixman_fixed_t) v;
|
||||
}
|
||||
*vector = result;
|
||||
if (!result.vector[2])
|
||||
return FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_point(const struct pixman_transform *transform,
|
||||
struct pixman_vector *vector)
|
||||
{
|
||||
pixman_fixed_32_32_t partial;
|
||||
pixman_fixed_34_30_t v[3];
|
||||
pixman_fixed_48_16_t quo;
|
||||
int i, j;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
v[j] = 0;
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
partial = ((pixman_fixed_32_32_t) transform->matrix[j][i] *
|
||||
(pixman_fixed_32_32_t) vector->vector[i]);
|
||||
v[j] += partial >> 2;
|
||||
}
|
||||
}
|
||||
if (!v[2])
|
||||
return FALSE;
|
||||
for (j = 0; j < 2; j++)
|
||||
{
|
||||
quo = v[j] / (v[2] >> 16);
|
||||
if (quo > pixman_max_fixed_48_16 || quo < pixman_min_fixed_48_16)
|
||||
return FALSE;
|
||||
vector->vector[j] = (pixman_fixed_t) quo;
|
||||
}
|
||||
vector->vector[2] = pixman_fixed_1;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_multiply (struct pixman_transform *dst,
|
||||
const struct pixman_transform *l,
|
||||
const struct pixman_transform *r)
|
||||
{
|
||||
struct pixman_transform d;
|
||||
int dx, dy;
|
||||
int o;
|
||||
|
||||
for (dy = 0; dy < 3; dy++)
|
||||
for (dx = 0; dx < 3; dx++) {
|
||||
pixman_fixed_48_16_t v;
|
||||
pixman_fixed_32_32_t partial;
|
||||
v = 0;
|
||||
for (o = 0; o < 3; o++) {
|
||||
partial = (pixman_fixed_32_32_t) l->matrix[dy][o] * (pixman_fixed_32_32_t) r->matrix[o][dx];
|
||||
v += partial >> 16;
|
||||
}
|
||||
if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)
|
||||
return FALSE;
|
||||
d.matrix[dy][dx] = (pixman_fixed_t) v;
|
||||
}
|
||||
*dst = d;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_transform_init_scale (struct pixman_transform *t,
|
||||
pixman_fixed_t sx,
|
||||
pixman_fixed_t sy)
|
||||
{
|
||||
memset (t, '\0', sizeof (struct pixman_transform));
|
||||
t->matrix[0][0] = sx;
|
||||
t->matrix[1][1] = sy;
|
||||
t->matrix[2][2] = F (1);
|
||||
}
|
||||
|
||||
static pixman_fixed_t
|
||||
fixed_inverse(pixman_fixed_t x)
|
||||
{
|
||||
return (pixman_fixed_t) ((((pixman_fixed_48_16_t) F(1)) * F(1)) / x);
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_scale(struct pixman_transform *forward,
|
||||
struct pixman_transform *reverse,
|
||||
pixman_fixed_t sx, pixman_fixed_t sy)
|
||||
{
|
||||
struct pixman_transform t;
|
||||
|
||||
if (sx == 0 || sy == 0)
|
||||
return FALSE;
|
||||
|
||||
if (forward) {
|
||||
pixman_transform_init_scale (&t, sx, sy);
|
||||
if (!pixman_transform_multiply (forward, &t, forward))
|
||||
return FALSE;
|
||||
}
|
||||
if (reverse) {
|
||||
pixman_transform_init_scale (&t, fixed_inverse (sx),
|
||||
fixed_inverse (sy));
|
||||
if (!pixman_transform_multiply (reverse, reverse, &t))
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_transform_init_rotate(struct pixman_transform *t,
|
||||
pixman_fixed_t c,
|
||||
pixman_fixed_t s)
|
||||
{
|
||||
memset(t, '\0', sizeof (struct pixman_transform));
|
||||
t->matrix[0][0] = c;
|
||||
t->matrix[0][1] = -s;
|
||||
t->matrix[1][0] = s;
|
||||
t->matrix[1][1] = c;
|
||||
t->matrix[2][2] = F (1);
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_rotate(struct pixman_transform *forward,
|
||||
struct pixman_transform *reverse,
|
||||
pixman_fixed_t c, pixman_fixed_t s)
|
||||
{
|
||||
struct pixman_transform t;
|
||||
|
||||
if (forward) {
|
||||
pixman_transform_init_rotate(&t, c, s);
|
||||
if (!pixman_transform_multiply(forward, &t, forward))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (reverse) {
|
||||
pixman_transform_init_rotate(&t, c, -s);
|
||||
if (!pixman_transform_multiply (reverse, reverse, &t))
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_transform_init_translate(struct pixman_transform *t,
|
||||
pixman_fixed_t tx, pixman_fixed_t ty)
|
||||
{
|
||||
memset(t, '\0', sizeof (struct pixman_transform));
|
||||
t->matrix[0][0] = F (1);
|
||||
t->matrix[0][2] = tx;
|
||||
t->matrix[1][1] = F (1);
|
||||
t->matrix[1][2] = ty;
|
||||
t->matrix[2][2] = F (1);
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_translate(struct pixman_transform *forward,
|
||||
struct pixman_transform *reverse,
|
||||
pixman_fixed_t tx, pixman_fixed_t ty)
|
||||
{
|
||||
struct pixman_transform t;
|
||||
|
||||
if (forward) {
|
||||
pixman_transform_init_translate(&t, tx, ty);
|
||||
if (!pixman_transform_multiply(forward, &t, forward))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (reverse) {
|
||||
pixman_transform_init_translate(&t, -tx, -ty);
|
||||
if (!pixman_transform_multiply(reverse, reverse, &t))
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_bounds(const struct pixman_transform *matrix,
|
||||
struct pixman_box16 *b)
|
||||
|
||||
{
|
||||
struct pixman_vector v[4];
|
||||
int i;
|
||||
int x1, y1, x2, y2;
|
||||
|
||||
v[0].vector[0] = F (b->x1); v[0].vector[1] = F (b->y1); v[0].vector[2] = F(1);
|
||||
v[1].vector[0] = F (b->x2); v[1].vector[1] = F (b->y1); v[1].vector[2] = F(1);
|
||||
v[2].vector[0] = F (b->x2); v[2].vector[1] = F (b->y2); v[2].vector[2] = F(1);
|
||||
v[3].vector[0] = F (b->x1); v[3].vector[1] = F (b->y2); v[3].vector[2] = F(1);
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
if (!pixman_transform_point(matrix, &v[i]))
|
||||
return FALSE;
|
||||
x1 = pixman_fixed_to_int(v[i].vector[0]);
|
||||
y1 = pixman_fixed_to_int(v[i].vector[1]);
|
||||
x2 = pixman_fixed_to_int(pixman_fixed_ceil (v[i].vector[0]));
|
||||
y2 = pixman_fixed_to_int(pixman_fixed_ceil (v[i].vector[1]));
|
||||
if (i == 0)
|
||||
{
|
||||
b->x1 = x1; b->y1 = y1;
|
||||
b->x2 = x2; b->y2 = y2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (x1 < b->x1) b->x1 = x1;
|
||||
if (y1 < b->y1) b->y1 = y1;
|
||||
if (x2 > b->x2) b->x2 = x2;
|
||||
if (y2 > b->y2) b->y2 = y2;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_invert (struct pixman_transform *dst,
|
||||
const struct pixman_transform *src)
|
||||
{
|
||||
struct pixman_f_transform m, r;
|
||||
|
||||
pixman_f_transform_from_pixman_transform (&m, src);
|
||||
if (!pixman_f_transform_invert (&r, &m))
|
||||
return FALSE;
|
||||
if (!pixman_transform_from_pixman_f_transform (dst, &r))
|
||||
return FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static pixman_bool_t
|
||||
within_epsilon(pixman_fixed_t a, pixman_fixed_t b, pixman_fixed_t epsilon)
|
||||
{
|
||||
pixman_fixed_t t = a - b;
|
||||
if (t < 0) t = -t;
|
||||
return t <= epsilon;
|
||||
}
|
||||
|
||||
#define epsilon (pixman_fixed_t) (2)
|
||||
|
||||
#define is_same(a,b) (within_epsilon(a, b, epsilon))
|
||||
#define is_zero(a) (within_epsilon(a, 0, epsilon))
|
||||
#define is_one(a) (within_epsilon(a, F(1), epsilon))
|
||||
#define is_unit(a) (within_epsilon(a, F( 1), epsilon) || \
|
||||
within_epsilon(a, F(-1), epsilon) || \
|
||||
is_zero(a))
|
||||
#define is_int(a) (is_zero(pixman_fixed_frac(a)))
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_is_identity(const struct pixman_transform *t)
|
||||
{
|
||||
return ( is_same(t->matrix[0][0], t->matrix[1][1]) &&
|
||||
is_same(t->matrix[0][0], t->matrix[2][2]) &&
|
||||
!is_zero(t->matrix[0][0]) &&
|
||||
is_zero(t->matrix[0][1]) &&
|
||||
is_zero(t->matrix[0][2]) &&
|
||||
is_zero(t->matrix[1][0]) &&
|
||||
is_zero(t->matrix[1][2]) &&
|
||||
is_zero(t->matrix[2][0]) &&
|
||||
is_zero(t->matrix[2][1]));
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_is_scale(const struct pixman_transform *t)
|
||||
{
|
||||
return (!is_zero(t->matrix[0][0]) &&
|
||||
is_zero(t->matrix[0][1]) &&
|
||||
is_zero(t->matrix[0][2]) &&
|
||||
|
||||
is_zero(t->matrix[1][0]) &&
|
||||
!is_zero(t->matrix[1][1]) &&
|
||||
is_zero(t->matrix[1][2]) &&
|
||||
|
||||
is_zero(t->matrix[2][0]) &&
|
||||
is_zero(t->matrix[2][1]) &&
|
||||
!is_zero(t->matrix[2][2]));
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_is_int_translate(const struct pixman_transform *t)
|
||||
{
|
||||
return (is_one (t->matrix[0][0]) &&
|
||||
is_zero(t->matrix[0][1]) &&
|
||||
is_int (t->matrix[0][2]) &&
|
||||
|
||||
is_zero(t->matrix[1][0]) &&
|
||||
is_one (t->matrix[1][1]) &&
|
||||
is_int (t->matrix[1][2]) &&
|
||||
|
||||
is_zero(t->matrix[2][0]) &&
|
||||
is_zero(t->matrix[2][1]) &&
|
||||
is_one (t->matrix[2][2]));
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_is_inverse(const struct pixman_transform *a,
|
||||
const struct pixman_transform *b)
|
||||
{
|
||||
struct pixman_transform t;
|
||||
|
||||
pixman_transform_multiply(&t, a, b);
|
||||
return pixman_transform_is_identity(&t);
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_f_transform_from_pixman_transform (struct pixman_f_transform *ft,
|
||||
const struct pixman_transform *t)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 3; i++)
|
||||
ft->m[j][i] = pixman_fixed_to_double (t->matrix[j][i]);
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
|
||||
const struct pixman_f_transform *ft)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
double d = ft->m[j][i];
|
||||
if (d < -32767.0 || d > 32767.0)
|
||||
return FALSE;
|
||||
d = d * 65536.0 + 0.5;
|
||||
t->matrix[j][i] = (pixman_fixed_t) floor (d);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static const int a[3] = { 3, 3, 2 };
|
||||
static const int b[3] = { 2, 1, 1 };
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_f_transform_invert(struct pixman_f_transform *dst,
|
||||
const struct pixman_f_transform *src)
|
||||
{
|
||||
double det;
|
||||
int i, j;
|
||||
static int a[3] = { 2, 2, 1 };
|
||||
static int b[3] = { 1, 0, 0 };
|
||||
|
||||
det = 0;
|
||||
for (i = 0; i < 3; i++) {
|
||||
double p;
|
||||
int ai = a[i];
|
||||
int bi = b[i];
|
||||
p = src->m[i][0] * (src->m[ai][2] * src->m[bi][1] -
|
||||
src->m[ai][1] * src->m[bi][2]);
|
||||
if (i == 1)
|
||||
p = -p;
|
||||
det += p;
|
||||
}
|
||||
if (det == 0)
|
||||
return FALSE;
|
||||
det = 1/det;
|
||||
for (j = 0; j < 3; j++) {
|
||||
for (i = 0; i < 3; i++) {
|
||||
double p;
|
||||
int ai = a[i];
|
||||
int aj = a[j];
|
||||
int bi = b[i];
|
||||
int bj = b[j];
|
||||
|
||||
p = (src->m[ai][aj] * src->m[bi][bj] -
|
||||
src->m[ai][bj] * src->m[bi][aj]);
|
||||
if (((i + j) & 1) != 0)
|
||||
p = -p;
|
||||
dst->m[j][i] = det * p;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_f_transform_point(const struct pixman_f_transform *t,
|
||||
struct pixman_f_vector *v)
|
||||
{
|
||||
struct pixman_f_vector result;
|
||||
int i, j;
|
||||
double a;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
a = 0;
|
||||
for (i = 0; i < 3; i++)
|
||||
a += t->m[j][i] * v->v[i];
|
||||
result.v[j] = a;
|
||||
}
|
||||
if (!result.v[2])
|
||||
return FALSE;
|
||||
for (j = 0; j < 2; j++)
|
||||
v->v[j] = result.v[j] / result.v[2];
|
||||
v->v[2] = 1;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_f_transform_point_3d(const struct pixman_f_transform *t,
|
||||
struct pixman_f_vector *v)
|
||||
{
|
||||
struct pixman_f_vector result;
|
||||
int i, j;
|
||||
double a;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
a = 0;
|
||||
for (i = 0; i < 3; i++)
|
||||
a += t->m[j][i] * v->v[i];
|
||||
result.v[j] = a;
|
||||
}
|
||||
*v = result;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_f_transform_multiply(struct pixman_f_transform *dst,
|
||||
const struct pixman_f_transform *l,
|
||||
const struct pixman_f_transform *r)
|
||||
{
|
||||
struct pixman_f_transform d;
|
||||
int dx, dy;
|
||||
int o;
|
||||
|
||||
for (dy = 0; dy < 3; dy++)
|
||||
for (dx = 0; dx < 3; dx++)
|
||||
{
|
||||
double v = 0;
|
||||
for (o = 0; o < 3; o++)
|
||||
v += l->m[dy][o] * r->m[o][dx];
|
||||
d.m[dy][dx] = v;
|
||||
}
|
||||
*dst = d;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_f_transform_init_scale (struct pixman_f_transform *t, double sx, double sy)
|
||||
{
|
||||
t->m[0][0] = sx; t->m[0][1] = 0; t->m[0][2] = 0;
|
||||
t->m[1][0] = 0; t->m[1][1] = sy; t->m[1][2] = 0;
|
||||
t->m[2][0] = 0; t->m[2][1] = 0; t->m[2][2] = 1;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_f_transform_scale (struct pixman_f_transform *forward,
|
||||
struct pixman_f_transform *reverse,
|
||||
double sx, double sy)
|
||||
{
|
||||
struct pixman_f_transform t;
|
||||
|
||||
if (sx == 0 || sy == 0)
|
||||
return FALSE;
|
||||
|
||||
if (forward) {
|
||||
pixman_f_transform_init_scale (&t, sx, sy);
|
||||
pixman_f_transform_multiply (forward, &t, forward);
|
||||
}
|
||||
if (reverse) {
|
||||
pixman_f_transform_init_scale (&t, 1/sx, 1/sy);
|
||||
pixman_f_transform_multiply (reverse, reverse, &t);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_f_transform_init_rotate (struct pixman_f_transform *t, double c, double s)
|
||||
{
|
||||
t->m[0][0] = c; t->m[0][1] = -s; t->m[0][2] = 0;
|
||||
t->m[1][0] = s; t->m[1][1] = c; t->m[1][2] = 0;
|
||||
t->m[2][0] = 0; t->m[2][1] = 0; t->m[2][2] = 1;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_f_transform_rotate (struct pixman_f_transform *forward,
|
||||
struct pixman_f_transform *reverse,
|
||||
double c, double s)
|
||||
{
|
||||
struct pixman_f_transform t;
|
||||
|
||||
if (forward) {
|
||||
pixman_f_transform_init_rotate (&t, c, s);
|
||||
pixman_f_transform_multiply (forward, &t, forward);
|
||||
}
|
||||
if (reverse) {
|
||||
pixman_f_transform_init_rotate (&t, c, -s);
|
||||
pixman_f_transform_multiply (reverse, reverse, &t);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_f_transform_init_translate (struct pixman_f_transform *t, double tx, double ty)
|
||||
{
|
||||
t->m[0][0] = 1; t->m[0][1] = 0; t->m[0][2] = tx;
|
||||
t->m[1][0] = 0; t->m[1][1] = 1; t->m[1][2] = ty;
|
||||
t->m[2][0] = 0; t->m[2][1] = 0; t->m[2][2] = 1;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_f_transform_translate (struct pixman_f_transform *forward,
|
||||
struct pixman_f_transform *reverse,
|
||||
double tx, double ty)
|
||||
{
|
||||
struct pixman_f_transform t;
|
||||
|
||||
if (forward) {
|
||||
pixman_f_transform_init_translate (&t, tx, ty);
|
||||
pixman_f_transform_multiply (forward, &t, forward);
|
||||
}
|
||||
if (reverse) {
|
||||
pixman_f_transform_init_translate (&t, -tx, -ty);
|
||||
pixman_f_transform_multiply (reverse, reverse, &t);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_f_transform_bounds(const struct pixman_f_transform *t, struct pixman_box16 *b)
|
||||
{
|
||||
struct pixman_f_vector v[4];
|
||||
int i;
|
||||
int x1, y1, x2, y2;
|
||||
|
||||
v[0].v[0] = b->x1; v[0].v[1] = b->y1; v[0].v[2] = 1;
|
||||
v[1].v[0] = b->x2; v[1].v[1] = b->y1; v[1].v[2] = 1;
|
||||
v[2].v[0] = b->x2; v[2].v[1] = b->y2; v[2].v[2] = 1;
|
||||
v[3].v[0] = b->x1; v[3].v[1] = b->y2; v[3].v[2] = 1;
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
if (!pixman_f_transform_point (t, &v[i]))
|
||||
return FALSE;
|
||||
x1 = floor (v[i].v[0]);
|
||||
y1 = floor (v[i].v[1]);
|
||||
x2 = ceil (v[i].v[0]);
|
||||
y2 = ceil (v[i].v[1]);
|
||||
if (i == 0)
|
||||
{
|
||||
b->x1 = x1; b->y1 = y1;
|
||||
b->x2 = x2; b->y2 = y2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (x1 < b->x1) b->x1 = x1;
|
||||
if (y1 < b->y1) b->y1 = y1;
|
||||
if (x2 > b->x2) b->x2 = x2;
|
||||
if (y2 > b->y2) b->y2 = y2;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PIXMAN_EXPORT void
|
||||
pixman_f_transform_init_identity (struct pixman_f_transform *t)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 3; i++)
|
||||
t->m[j][i] = i == j ? 1 : 0;
|
||||
}
|
||||
|
|
@ -1212,6 +1212,93 @@ fbCompositeSrc_8888xx888 (pixman_op_t op,
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fbCompositeSrcScaleNearest (pixman_op_t op,
|
||||
pixman_image_t * pSrc,
|
||||
pixman_image_t * pMask,
|
||||
pixman_image_t * pDst,
|
||||
int16_t xSrc,
|
||||
int16_t ySrc,
|
||||
int16_t xMask,
|
||||
int16_t yMask,
|
||||
int16_t xDst,
|
||||
int16_t yDst,
|
||||
uint16_t width,
|
||||
uint16_t height)
|
||||
{
|
||||
uint32_t *dst;
|
||||
uint32_t *src;
|
||||
int dstStride, srcStride;
|
||||
int i, j;
|
||||
pixman_vector_t v;
|
||||
|
||||
fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dst, 1);
|
||||
/* pass in 0 instead of xSrc and ySrc because xSrc and ySrc need to be
|
||||
* transformed from destination space to source space */
|
||||
fbComposeGetStart (pSrc, 0, 0, uint32_t, srcStride, src, 1);
|
||||
|
||||
/* reference point is the center of the pixel */
|
||||
v.vector[0] = pixman_int_to_fixed(xSrc) + pixman_fixed_1 / 2;
|
||||
v.vector[1] = pixman_int_to_fixed(ySrc) + pixman_fixed_1 / 2;
|
||||
v.vector[2] = pixman_fixed_1;
|
||||
|
||||
if (!pixman_transform_point_3d (pSrc->common.transform, &v))
|
||||
return;
|
||||
|
||||
/* Round down to closest integer, ensuring that 0.5 rounds to 0, not 1 */
|
||||
v.vector[0] -= pixman_fixed_e;
|
||||
v.vector[1] -= pixman_fixed_e;
|
||||
|
||||
for (j = 0; j < height; j++) {
|
||||
pixman_fixed_t vx = v.vector[0];
|
||||
pixman_fixed_t vy = v.vector[1];
|
||||
for (i = 0; i < width; ++i) {
|
||||
pixman_bool_t inside_bounds;
|
||||
uint32_t result;
|
||||
int x, y;
|
||||
x = vx >> 16;
|
||||
y = vy >> 16;
|
||||
|
||||
/* apply the repeat function */
|
||||
switch (pSrc->common.repeat) {
|
||||
case PIXMAN_REPEAT_NORMAL:
|
||||
x = MOD (x, pSrc->bits.width);
|
||||
y = MOD (y, pSrc->bits.height);
|
||||
inside_bounds = TRUE;
|
||||
break;
|
||||
|
||||
case PIXMAN_REPEAT_PAD:
|
||||
x = CLIP (x, 0, pSrc->bits.width-1);
|
||||
y = CLIP (y, 0, pSrc->bits.height-1);
|
||||
inside_bounds = TRUE;
|
||||
break;
|
||||
|
||||
case PIXMAN_REPEAT_REFLECT:
|
||||
case PIXMAN_REPEAT_NONE:
|
||||
default:
|
||||
inside_bounds = (x >= 0 && x < pSrc->bits.width && y >= 0 && y < pSrc->bits.height);
|
||||
break;
|
||||
}
|
||||
|
||||
if (inside_bounds) {
|
||||
//XXX: we should move this multiplication out of the loop
|
||||
result = READ(pSrc, src + y * srcStride + x);
|
||||
} else {
|
||||
result = 0;
|
||||
}
|
||||
WRITE(pDst, dst + i, result);
|
||||
|
||||
/* adjust the x location by a unit vector in the x direction:
|
||||
* this is equivalent to transforming x+1 of the destination point to source space */
|
||||
vx += pSrc->common.transform->matrix[0][0];
|
||||
}
|
||||
/* adjust the y location by a unit vector in the y direction
|
||||
* this is equivalent to transforming y+1 of the destination point to source space */
|
||||
v.vector[1] += pSrc->common.transform->matrix[1][1];
|
||||
dst += dstStride;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
pixman_walk_composite_region (pixman_op_t op,
|
||||
pixman_image_t * pSrc,
|
||||
|
|
@ -1859,7 +1946,27 @@ pixman_image_composite (pixman_op_t op,
|
|||
if(op == PIXMAN_OP_DST)
|
||||
return;
|
||||
|
||||
if ((pSrc->type == BITS || pixman_image_can_get_solid (pSrc)) && (!pMask || pMask->type == BITS)
|
||||
if (pSrc->type == BITS
|
||||
&& srcTransform
|
||||
&& !pMask
|
||||
&& op == PIXMAN_OP_SRC
|
||||
&& !maskAlphaMap && !srcAlphaMap && !dstAlphaMap
|
||||
&& (pSrc->common.filter == PIXMAN_FILTER_NEAREST)
|
||||
&& PIXMAN_FORMAT_BPP(pDst->bits.format) == 32
|
||||
&& pSrc->bits.format == pDst->bits.format
|
||||
&& pSrc->common.src_clip == &(pSrc->common.full_region)
|
||||
&& !pSrc->common.read_func && !pSrc->common.write_func
|
||||
&& !pDst->common.read_func && !pDst->common.write_func)
|
||||
{
|
||||
/* ensure that the transform matrix only has a scale */
|
||||
if (pSrc->common.transform->matrix[0][1] == 0 &&
|
||||
pSrc->common.transform->matrix[1][0] == 0 &&
|
||||
pSrc->common.transform->matrix[2][0] == 0 &&
|
||||
pSrc->common.transform->matrix[2][1] == 0 &&
|
||||
pSrc->common.transform->matrix[2][2] == pixman_fixed_1) {
|
||||
func = fbCompositeSrcScaleNearest;
|
||||
}
|
||||
} else if ((pSrc->type == BITS || pixman_image_can_get_solid (pSrc)) && (!pMask || pMask->type == BITS)
|
||||
&& !srcTransform && !maskTransform
|
||||
&& !maskAlphaMap && !srcAlphaMap && !dstAlphaMap
|
||||
&& (pSrc->common.filter != PIXMAN_FILTER_CONVOLUTION)
|
||||
|
|
@ -1992,7 +2099,59 @@ pixman_bool_t pixman_have_vmx (void) {
|
|||
return have_vmx;
|
||||
}
|
||||
|
||||
#else
|
||||
#elif defined (__linux__)
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <linux/auxvec.h>
|
||||
#include <asm/cputable.h>
|
||||
|
||||
pixman_bool_t pixman_have_vmx (void)
|
||||
{
|
||||
if (!initialized) {
|
||||
char fname[64];
|
||||
unsigned long buf[64];
|
||||
ssize_t count = 0;
|
||||
pid_t pid;
|
||||
int fd, i;
|
||||
|
||||
pid = getpid();
|
||||
snprintf(fname, sizeof(fname)-1, "/proc/%d/auxv", pid);
|
||||
|
||||
fd = open(fname, O_RDONLY);
|
||||
if (fd >= 0) {
|
||||
for (i = 0; i <= (count / sizeof(unsigned long)); i += 2) {
|
||||
/* Read more if buf is empty... */
|
||||
if (i == (count / sizeof(unsigned long))) {
|
||||
count = read(fd, buf, sizeof(buf));
|
||||
if (count <= 0)
|
||||
break;
|
||||
i = 0;
|
||||
}
|
||||
|
||||
if (buf[i] == AT_HWCAP) {
|
||||
have_vmx = !!(buf[i+1] & PPC_FEATURE_HAS_ALTIVEC);
|
||||
initialized = TRUE;
|
||||
break;
|
||||
} else if (buf[i] == AT_NULL) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
if (!initialized) {
|
||||
/* Something went wrong. Assume 'no' rather than playing
|
||||
fragile tricks with catching SIGILL. */
|
||||
have_vmx = FALSE;
|
||||
initialized = TRUE;
|
||||
}
|
||||
|
||||
return have_vmx;
|
||||
}
|
||||
#else /* !__APPLE__ && !__linux__ */
|
||||
#include <signal.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -1330,6 +1330,8 @@ validate (region_type_t * badreg,
|
|||
int curBand;
|
||||
} RegionInfo;
|
||||
|
||||
RegionInfo stack_regions[64];
|
||||
|
||||
int numRects; /* Original numRects for badreg */
|
||||
RegionInfo *ri; /* Array of current regions */
|
||||
int numRI; /* Number of entries used in ri */
|
||||
|
|
@ -1379,10 +1381,8 @@ validate (region_type_t * badreg,
|
|||
|
||||
/* Set up the first region to be the first rectangle in badreg */
|
||||
/* Note that step 2 code will never overflow the ri[0].reg rects array */
|
||||
ri = (RegionInfo *) pixman_malloc_ab (4, sizeof(RegionInfo));
|
||||
if (!ri)
|
||||
return pixman_break (badreg);
|
||||
sizeRI = 4;
|
||||
ri = stack_regions;
|
||||
sizeRI = sizeof (stack_regions) / sizeof (stack_regions[0]);
|
||||
numRI = 1;
|
||||
ri[0].prevBand = 0;
|
||||
ri[0].curBand = 0;
|
||||
|
|
@ -1451,9 +1451,16 @@ validate (region_type_t * badreg,
|
|||
data_size = sizeRI * sizeof(RegionInfo);
|
||||
if (data_size / sizeRI != sizeof(RegionInfo))
|
||||
goto bail;
|
||||
rit = (RegionInfo *) realloc(ri, data_size);
|
||||
if (!rit)
|
||||
goto bail;
|
||||
if (ri == stack_regions) {
|
||||
rit = malloc (data_size);
|
||||
if (!rit)
|
||||
goto bail;
|
||||
memcpy (rit, ri, numRI * sizeof (RegionInfo));
|
||||
} else {
|
||||
rit = (RegionInfo *) realloc(ri, data_size);
|
||||
if (!rit)
|
||||
goto bail;
|
||||
}
|
||||
ri = rit;
|
||||
rit = &ri[numRI];
|
||||
}
|
||||
|
|
@ -1509,13 +1516,15 @@ NextRect: ;
|
|||
goto bail;
|
||||
}
|
||||
*badreg = ri[0].reg;
|
||||
free(ri);
|
||||
if (ri != stack_regions)
|
||||
free(ri);
|
||||
good(badreg);
|
||||
return ret;
|
||||
bail:
|
||||
for (i = 0; i < numRI; i++)
|
||||
freeData(&ri[i].reg);
|
||||
free (ri);
|
||||
if (ri != stack_regions)
|
||||
free (ri);
|
||||
|
||||
return pixman_break (badreg);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ typedef FASTCALL uint32_t (*fetchFromRegionProc)(bits_image_t *pict, int x, int
|
|||
* for is when src_clip is false. Since inside_bounds is statically known,
|
||||
* the last part of the if statement will normally be optimized away.
|
||||
*/
|
||||
static inline uint32_t
|
||||
static force_inline uint32_t
|
||||
do_fetch (bits_image_t *pict, int x, int y, fetchPixelProc32 fetch,
|
||||
pixman_bool_t src_clip,
|
||||
pixman_bool_t inside_bounds)
|
||||
|
|
@ -87,343 +87,155 @@ do_fetch (bits_image_t *pict, int x, int y, fetchPixelProc32 fetch,
|
|||
/*
|
||||
* Fetching Algorithms
|
||||
*/
|
||||
static void
|
||||
fbFetchTransformed_Nearest_Normal(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits, pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
static inline uint32_t
|
||||
fetch_nearest (bits_image_t *pict,
|
||||
fetchPixelProc32 fetch,
|
||||
pixman_bool_t affine,
|
||||
pixman_repeat_t repeat,
|
||||
pixman_bool_t has_src_clip,
|
||||
const pixman_vector_t *v)
|
||||
{
|
||||
fetchPixelProc32 fetch;
|
||||
pixman_bool_t src_clip;
|
||||
int x, y, i;
|
||||
|
||||
/* initialize the two function pointers */
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for ( i = 0; i < width; ++i)
|
||||
if (!v->vector[2])
|
||||
{
|
||||
if (!mask || mask[i] & maskBits)
|
||||
{
|
||||
if (!v.vector[2])
|
||||
{
|
||||
*(buffer + i) = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!affine)
|
||||
{
|
||||
y = MOD(DIV(v.vector[1],v.vector[2]), pict->height);
|
||||
x = MOD(DIV(v.vector[0],v.vector[2]), pict->width);
|
||||
}
|
||||
else
|
||||
{
|
||||
y = MOD(v.vector[1]>>16, pict->height);
|
||||
x = MOD(v.vector[0]>>16, pict->width);
|
||||
}
|
||||
|
||||
*(buffer + i) = do_fetch (pict, x, y, fetch, src_clip, TRUE);
|
||||
}
|
||||
}
|
||||
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fbFetchTransformed_Nearest_Pad(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits, pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
{
|
||||
pixman_bool_t src_clip;
|
||||
fetchPixelProc32 fetch;
|
||||
int x, y, i;
|
||||
|
||||
/* initialize the two function pointers */
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for (i = 0; i < width; ++i)
|
||||
else
|
||||
{
|
||||
if (!mask || mask[i] & maskBits)
|
||||
{
|
||||
if (!v.vector[2])
|
||||
{
|
||||
*(buffer + i) = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!affine)
|
||||
{
|
||||
y = CLIP(DIV(v.vector[1], v.vector[2]), 0, pict->height-1);
|
||||
x = CLIP(DIV(v.vector[0], v.vector[2]), 0, pict->width-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
y = CLIP(v.vector[1]>>16, 0, pict->height-1);
|
||||
x = CLIP(v.vector[0]>>16, 0, pict->width-1);
|
||||
}
|
||||
int x, y;
|
||||
pixman_bool_t inside_bounds;
|
||||
|
||||
*(buffer + i) = do_fetch (pict, x, y, fetch, src_clip, TRUE);
|
||||
}
|
||||
}
|
||||
if (!affine)
|
||||
{
|
||||
x = DIV(v->vector[0], v->vector[2]);
|
||||
y = DIV(v->vector[1], v->vector[2]);
|
||||
}
|
||||
else
|
||||
{
|
||||
x = v->vector[0]>>16;
|
||||
y = v->vector[1]>>16;
|
||||
}
|
||||
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
switch (repeat)
|
||||
{
|
||||
case PIXMAN_REPEAT_NORMAL:
|
||||
x = MOD (x, pict->width);
|
||||
y = MOD (y, pict->height);
|
||||
inside_bounds = TRUE;
|
||||
break;
|
||||
|
||||
case PIXMAN_REPEAT_PAD:
|
||||
x = CLIP (x, 0, pict->width-1);
|
||||
y = CLIP (y, 0, pict->height-1);
|
||||
inside_bounds = TRUE;
|
||||
break;
|
||||
|
||||
case PIXMAN_REPEAT_REFLECT: /* FIXME: this should be implemented for images */
|
||||
case PIXMAN_REPEAT_NONE:
|
||||
inside_bounds = FALSE;
|
||||
break;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
|
||||
return do_fetch (pict, x, y, fetch, has_src_clip, inside_bounds);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fbFetchTransformed_Nearest_General(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits, pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
static inline uint32_t
|
||||
fetch_bilinear (bits_image_t *pict,
|
||||
fetchPixelProc32 fetch,
|
||||
pixman_bool_t affine,
|
||||
pixman_repeat_t repeat,
|
||||
pixman_bool_t has_src_clip,
|
||||
const pixman_vector_t *v)
|
||||
{
|
||||
fetchPixelProc32 fetch;
|
||||
pixman_bool_t src_clip;
|
||||
int x, y, i;
|
||||
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for (i = 0; i < width; ++i) {
|
||||
if (!mask || mask[i] & maskBits)
|
||||
{
|
||||
if (!v.vector[2]) {
|
||||
*(buffer + i) = 0;
|
||||
} else {
|
||||
if (!affine) {
|
||||
y = DIV(v.vector[1],v.vector[2]);
|
||||
x = DIV(v.vector[0],v.vector[2]);
|
||||
} else {
|
||||
y = v.vector[1]>>16;
|
||||
x = v.vector[0]>>16;
|
||||
}
|
||||
|
||||
*(buffer + i) = do_fetch (pict, x, y, fetch, src_clip, FALSE);
|
||||
}
|
||||
}
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fbFetchTransformed_Bilinear_Normal(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits, pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
{
|
||||
pixman_bool_t src_clip;
|
||||
fetchPixelProc32 fetch;
|
||||
int i;
|
||||
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for (i = 0; i < width; ++i) {
|
||||
if (!mask || mask[i] & maskBits)
|
||||
{
|
||||
if (!v.vector[2]) {
|
||||
*(buffer + i) = 0;
|
||||
} else {
|
||||
int x1, x2, y1, y2, distx, idistx, disty, idisty;
|
||||
uint32_t tl, tr, bl, br, r;
|
||||
uint32_t ft, fb;
|
||||
|
||||
if (!affine) {
|
||||
pixman_fixed_48_16_t div;
|
||||
div = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2];
|
||||
x1 = div >> 16;
|
||||
distx = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
div = ((pixman_fixed_48_16_t)v.vector[1] << 16)/v.vector[2];
|
||||
y1 = div >> 16;
|
||||
disty = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
} else {
|
||||
x1 = v.vector[0] >> 16;
|
||||
distx = (v.vector[0] >> 8) & 0xff;
|
||||
y1 = v.vector[1] >> 16;
|
||||
disty = (v.vector[1] >> 8) & 0xff;
|
||||
}
|
||||
x2 = x1 + 1;
|
||||
y2 = y1 + 1;
|
||||
|
||||
idistx = 256 - distx;
|
||||
idisty = 256 - disty;
|
||||
|
||||
x1 = MOD (x1, pict->width);
|
||||
x2 = MOD (x2, pict->width);
|
||||
y1 = MOD (y1, pict->height);
|
||||
y2 = MOD (y2, pict->height);
|
||||
|
||||
tl = do_fetch (pict, x1, y1, fetch, src_clip, TRUE);
|
||||
tr = do_fetch (pict, x2, y1, fetch, src_clip, TRUE);
|
||||
bl = do_fetch (pict, x1, y2, fetch, src_clip, TRUE);
|
||||
br = do_fetch (pict, x2, y2, fetch, src_clip, TRUE);
|
||||
|
||||
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
|
||||
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
|
||||
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
||||
ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
|
||||
fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
|
||||
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
||||
ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
|
||||
fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
|
||||
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
||||
ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
|
||||
fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
|
||||
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
||||
*(buffer + i) = r;
|
||||
}
|
||||
}
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fbFetchTransformed_Bilinear_Pad(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits, pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
{
|
||||
pixman_bool_t src_clip;
|
||||
fetchPixelProc32 fetch;
|
||||
int i;
|
||||
|
||||
/* initialize the two function pointers */
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for (i = 0; i < width; ++i) {
|
||||
if (!mask || mask[i] & maskBits)
|
||||
{
|
||||
if (!v.vector[2]) {
|
||||
*(buffer + i) = 0;
|
||||
} else {
|
||||
int x1, x2, y1, y2, distx, idistx, disty, idisty;
|
||||
uint32_t tl, tr, bl, br, r;
|
||||
uint32_t ft, fb;
|
||||
|
||||
if (!affine) {
|
||||
pixman_fixed_48_16_t div;
|
||||
div = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2];
|
||||
x1 = div >> 16;
|
||||
distx = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
div = ((pixman_fixed_48_16_t)v.vector[1] << 16)/v.vector[2];
|
||||
y1 = div >> 16;
|
||||
disty = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
} else {
|
||||
x1 = v.vector[0] >> 16;
|
||||
distx = (v.vector[0] >> 8) & 0xff;
|
||||
y1 = v.vector[1] >> 16;
|
||||
disty = (v.vector[1] >> 8) & 0xff;
|
||||
}
|
||||
x2 = x1 + 1;
|
||||
y2 = y1 + 1;
|
||||
|
||||
idistx = 256 - distx;
|
||||
idisty = 256 - disty;
|
||||
|
||||
x1 = CLIP (x1, 0, pict->width-1);
|
||||
x2 = CLIP (x2, 0, pict->width-1);
|
||||
y1 = CLIP (y1, 0, pict->height-1);
|
||||
y2 = CLIP (y2, 0, pict->height-1);
|
||||
|
||||
tl = do_fetch(pict, x1, y1, fetch, src_clip, TRUE);
|
||||
tr = do_fetch(pict, x2, y1, fetch, src_clip, TRUE);
|
||||
bl = do_fetch(pict, x1, y2, fetch, src_clip, TRUE);
|
||||
br = do_fetch(pict, x2, y2, fetch, src_clip, TRUE);
|
||||
|
||||
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
|
||||
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
|
||||
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
||||
ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
|
||||
fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
|
||||
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
||||
ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
|
||||
fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
|
||||
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
||||
ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
|
||||
fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
|
||||
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
||||
*(buffer + i) = r;
|
||||
}
|
||||
}
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fbFetchTransformed_Bilinear_General(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits, pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
{
|
||||
pixman_bool_t src_clip;
|
||||
fetchPixelProc32 fetch;
|
||||
int i;
|
||||
|
||||
/* initialize the two function pointers */
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for (i = 0; i < width; ++i)
|
||||
if (!v->vector[2])
|
||||
{
|
||||
if (!mask || mask[i] & maskBits)
|
||||
{
|
||||
if (!v.vector[2]) {
|
||||
*(buffer + i) = 0;
|
||||
} else {
|
||||
int x1, x2, y1, y2, distx, idistx, disty, idisty;
|
||||
uint32_t tl, tr, bl, br, r;
|
||||
uint32_t ft, fb;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
int x1, x2, y1, y2, distx, idistx, disty, idisty;
|
||||
uint32_t tl, tr, bl, br, r;
|
||||
uint32_t ft, fb;
|
||||
pixman_bool_t inside_bounds;
|
||||
|
||||
if (!affine)
|
||||
{
|
||||
pixman_fixed_48_16_t div;
|
||||
div = ((pixman_fixed_48_16_t)v->vector[0] << 16)/v->vector[2];
|
||||
x1 = div >> 16;
|
||||
distx = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
div = ((pixman_fixed_48_16_t)v->vector[1] << 16)/v->vector[2];
|
||||
y1 = div >> 16;
|
||||
disty = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
}
|
||||
else
|
||||
{
|
||||
x1 = v->vector[0] >> 16;
|
||||
distx = (v->vector[0] >> 8) & 0xff;
|
||||
y1 = v->vector[1] >> 16;
|
||||
disty = (v->vector[1] >> 8) & 0xff;
|
||||
}
|
||||
x2 = x1 + 1;
|
||||
y2 = y1 + 1;
|
||||
|
||||
idistx = 256 - distx;
|
||||
idisty = 256 - disty;
|
||||
|
||||
if (!affine) {
|
||||
pixman_fixed_48_16_t div;
|
||||
div = ((pixman_fixed_48_16_t)v.vector[0] << 16)/v.vector[2];
|
||||
x1 = div >> 16;
|
||||
distx = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
div = ((pixman_fixed_48_16_t)v.vector[1] << 16)/v.vector[2];
|
||||
y1 = div >> 16;
|
||||
disty = ((pixman_fixed_t)div >> 8) & 0xff;
|
||||
} else {
|
||||
x1 = v.vector[0] >> 16;
|
||||
distx = (v.vector[0] >> 8) & 0xff;
|
||||
y1 = v.vector[1] >> 16;
|
||||
disty = (v.vector[1] >> 8) & 0xff;
|
||||
}
|
||||
x2 = x1 + 1;
|
||||
y2 = y1 + 1;
|
||||
switch (repeat)
|
||||
{
|
||||
case PIXMAN_REPEAT_NORMAL:
|
||||
x1 = MOD (x1, pict->width);
|
||||
x2 = MOD (x2, pict->width);
|
||||
y1 = MOD (y1, pict->height);
|
||||
y2 = MOD (y2, pict->height);
|
||||
inside_bounds = TRUE;
|
||||
break;
|
||||
|
||||
case PIXMAN_REPEAT_PAD:
|
||||
x1 = CLIP (x1, 0, pict->width-1);
|
||||
x2 = CLIP (x2, 0, pict->width-1);
|
||||
y1 = CLIP (y1, 0, pict->height-1);
|
||||
y2 = CLIP (y2, 0, pict->height-1);
|
||||
inside_bounds = TRUE;
|
||||
break;
|
||||
|
||||
case PIXMAN_REPEAT_REFLECT: /* FIXME: this should be implemented for images */
|
||||
case PIXMAN_REPEAT_NONE:
|
||||
inside_bounds = FALSE;
|
||||
break;
|
||||
|
||||
idistx = 256 - distx;
|
||||
idisty = 256 - disty;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
|
||||
tl = do_fetch(pict, x1, y1, fetch, has_src_clip, inside_bounds);
|
||||
tr = do_fetch(pict, x2, y1, fetch, has_src_clip, inside_bounds);
|
||||
bl = do_fetch(pict, x1, y2, fetch, has_src_clip, inside_bounds);
|
||||
br = do_fetch(pict, x2, y2, fetch, has_src_clip, inside_bounds);
|
||||
|
||||
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
|
||||
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
|
||||
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
||||
ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
|
||||
fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
|
||||
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
||||
ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
|
||||
fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
|
||||
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
||||
ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
|
||||
fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
|
||||
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
||||
|
||||
tl = do_fetch(pict, x1, y1, fetch, src_clip, FALSE);
|
||||
tr = do_fetch(pict, x2, y1, fetch, src_clip, FALSE);
|
||||
bl = do_fetch(pict, x1, y2, fetch, src_clip, FALSE);
|
||||
br = do_fetch(pict, x2, y2, fetch, src_clip, FALSE);
|
||||
|
||||
ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
|
||||
fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
|
||||
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
||||
ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
|
||||
fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
|
||||
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
||||
ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
|
||||
fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
|
||||
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
||||
ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
|
||||
fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
|
||||
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
||||
*(buffer + i) = r;
|
||||
}
|
||||
}
|
||||
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fbFetchTransformed_Convolution(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits, pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
fbFetchTransformed_Convolution(bits_image_t * pict, int width, uint32_t *buffer, uint32_t *mask, uint32_t maskBits,
|
||||
pixman_bool_t affine, pixman_vector_t v, pixman_vector_t unit)
|
||||
{
|
||||
fetchPixelProc32 fetch;
|
||||
int i;
|
||||
|
|
@ -560,7 +372,8 @@ ACCESS(fbFetchTransformed)(bits_image_t * pict, int x, int y, int width,
|
|||
unit.vector[0] = pict->common.transform->matrix[0][0];
|
||||
unit.vector[1] = pict->common.transform->matrix[1][0];
|
||||
unit.vector[2] = pict->common.transform->matrix[2][0];
|
||||
affine = v.vector[2] == pixman_fixed_1 && unit.vector[2] == 0;
|
||||
|
||||
affine = (v.vector[2] == pixman_fixed_1 && unit.vector[2] == 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -570,46 +383,57 @@ ACCESS(fbFetchTransformed)(bits_image_t * pict, int x, int y, int width,
|
|||
}
|
||||
|
||||
/* This allows filtering code to pretend that pixels are located at integer coordinates */
|
||||
adjust (&v, &unit, -(pixman_fixed_1 / 2));
|
||||
|
||||
if (pict->common.filter == PIXMAN_FILTER_NEAREST || pict->common.filter == PIXMAN_FILTER_FAST)
|
||||
{
|
||||
fetchPixelProc32 fetch;
|
||||
pixman_bool_t src_clip;
|
||||
int i;
|
||||
|
||||
/* Round down to closest integer, ensuring that 0.5 rounds to 0, not 1 */
|
||||
adjust (&v, &unit, pixman_fixed_1 / 2 - pixman_fixed_e);
|
||||
adjust (&v, &unit, - pixman_fixed_e);
|
||||
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
|
||||
if (pict->common.repeat == PIXMAN_REPEAT_NORMAL)
|
||||
{
|
||||
fbFetchTransformed_Nearest_Normal(pict, width, buffer, mask, maskBits, affine, v, unit);
|
||||
}
|
||||
else if (pict->common.repeat == PIXMAN_REPEAT_PAD)
|
||||
{
|
||||
fbFetchTransformed_Nearest_Pad(pict, width, buffer, mask, maskBits, affine, v, unit);
|
||||
}
|
||||
else
|
||||
{
|
||||
fbFetchTransformed_Nearest_General(pict, width, buffer, mask, maskBits, affine, v, unit);
|
||||
}
|
||||
} else if (pict->common.filter == PIXMAN_FILTER_BILINEAR ||
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for ( i = 0; i < width; ++i)
|
||||
{
|
||||
if (!mask || mask[i] & maskBits)
|
||||
*(buffer + i) = fetch_nearest (pict, fetch, affine, pict->common.repeat, src_clip, &v);
|
||||
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
}
|
||||
}
|
||||
else if (pict->common.filter == PIXMAN_FILTER_BILINEAR ||
|
||||
pict->common.filter == PIXMAN_FILTER_GOOD ||
|
||||
pict->common.filter == PIXMAN_FILTER_BEST)
|
||||
{
|
||||
if (pict->common.repeat == PIXMAN_REPEAT_NORMAL)
|
||||
{
|
||||
fbFetchTransformed_Bilinear_Normal(pict, width, buffer, mask, maskBits, affine, v, unit);
|
||||
}
|
||||
else if (pict->common.repeat == PIXMAN_REPEAT_PAD)
|
||||
{
|
||||
fbFetchTransformed_Bilinear_Pad(pict, width, buffer, mask, maskBits, affine, v, unit);
|
||||
}
|
||||
else
|
||||
{
|
||||
fbFetchTransformed_Bilinear_General(pict, width, buffer, mask, maskBits, affine, v, unit);
|
||||
}
|
||||
pixman_bool_t src_clip;
|
||||
fetchPixelProc32 fetch;
|
||||
int i;
|
||||
|
||||
/* Let the bilinear code pretend that pixels fall on integer coordinaters */
|
||||
adjust (&v, &unit, -(pixman_fixed_1 / 2));
|
||||
|
||||
fetch = ACCESS(pixman_fetchPixelProcForPicture32)(pict);
|
||||
src_clip = pict->common.src_clip != &(pict->common.full_region);
|
||||
|
||||
for (i = 0; i < width; ++i)
|
||||
{
|
||||
if (!mask || mask[i] & maskBits)
|
||||
*(buffer + i) = fetch_bilinear (pict, fetch, affine, pict->common.repeat, src_clip, &v);
|
||||
|
||||
v.vector[0] += unit.vector[0];
|
||||
v.vector[1] += unit.vector[1];
|
||||
v.vector[2] += unit.vector[2];
|
||||
}
|
||||
}
|
||||
else if (pict->common.filter == PIXMAN_FILTER_CONVOLUTION)
|
||||
{
|
||||
/* Round to closest integer, ensuring that 0.5 rounds to 0, not 1 */
|
||||
adjust (&v, &unit, pixman_fixed_1 / 2 - pixman_fixed_e);
|
||||
adjust (&v, &unit, - pixman_fixed_e);
|
||||
|
||||
fbFetchTransformed_Convolution(pict, width, buffer, mask, maskBits, affine, v, unit);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,38 +31,6 @@
|
|||
#include "pixman-mmx.h"
|
||||
#include "pixman-sse2.h"
|
||||
|
||||
PIXMAN_EXPORT pixman_bool_t
|
||||
pixman_transform_point_3d (pixman_transform_t *transform,
|
||||
pixman_vector_t *vector)
|
||||
{
|
||||
pixman_vector_t result;
|
||||
int i, j;
|
||||
pixman_fixed_32_32_t partial;
|
||||
pixman_fixed_48_16_t v;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
{
|
||||
v = 0;
|
||||
for (i = 0; i < 3; i++)
|
||||
{
|
||||
partial = ((pixman_fixed_48_16_t) transform->matrix[j][i] *
|
||||
(pixman_fixed_48_16_t) vector->vector[i]);
|
||||
v += partial >> 16;
|
||||
}
|
||||
|
||||
if (v > pixman_max_fixed_48_16 || v < pixman_min_fixed_48_16)
|
||||
return FALSE;
|
||||
|
||||
result.vector[j] = (pixman_fixed_48_16_t) v;
|
||||
}
|
||||
|
||||
if (!result.vector[2])
|
||||
return FALSE;
|
||||
|
||||
*vector = result;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#if defined(USE_SSE2) && defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__)
|
||||
__attribute__((__force_align_arg_pointer__))
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -33,9 +33,9 @@
|
|||
|
||||
#define PIXMAN_VERSION_MAJOR 0
|
||||
#define PIXMAN_VERSION_MINOR 13
|
||||
#define PIXMAN_VERSION_MICRO 1
|
||||
#define PIXMAN_VERSION_MICRO 3
|
||||
|
||||
#define PIXMAN_VERSION_STRING "0.13.1"
|
||||
#define PIXMAN_VERSION_STRING "0.13.3"
|
||||
|
||||
#define PIXMAN_VERSION_ENCODE(major, minor, micro) ( \
|
||||
((major) * 10000) \
|
||||
|
|
|
|||
|
|
@ -149,6 +149,10 @@ struct pixman_line_fixed
|
|||
pixman_point_fixed_t p1, p2;
|
||||
};
|
||||
|
||||
/*
|
||||
* Fixed point matrices
|
||||
*/
|
||||
|
||||
struct pixman_vector
|
||||
{
|
||||
pixman_fixed_t vector[3];
|
||||
|
|
@ -159,6 +163,149 @@ struct pixman_transform
|
|||
pixman_fixed_t matrix[3][3];
|
||||
};
|
||||
|
||||
/* forward declaration (sorry) */
|
||||
struct pixman_box16;
|
||||
|
||||
void
|
||||
pixman_transform_init_identity(struct pixman_transform *matrix);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_point_3d (const struct pixman_transform *transform,
|
||||
struct pixman_vector *vector);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_point(const struct pixman_transform *transform,
|
||||
struct pixman_vector *vector);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_multiply (struct pixman_transform *dst,
|
||||
const struct pixman_transform *l,
|
||||
const struct pixman_transform *r);
|
||||
|
||||
void
|
||||
pixman_transform_init_scale (struct pixman_transform *t,
|
||||
pixman_fixed_t sx,
|
||||
pixman_fixed_t sy);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_scale(struct pixman_transform *forward,
|
||||
struct pixman_transform *reverse,
|
||||
pixman_fixed_t sx, pixman_fixed_t sy);
|
||||
|
||||
void
|
||||
pixman_transform_init_rotate(struct pixman_transform *t,
|
||||
pixman_fixed_t cos,
|
||||
pixman_fixed_t sin);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_rotate(struct pixman_transform *forward,
|
||||
struct pixman_transform *reverse,
|
||||
pixman_fixed_t c, pixman_fixed_t s);
|
||||
|
||||
void
|
||||
pixman_transform_init_translate(struct pixman_transform *t,
|
||||
pixman_fixed_t tx, pixman_fixed_t ty);
|
||||
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_translate(struct pixman_transform *forward,
|
||||
struct pixman_transform *reverse,
|
||||
pixman_fixed_t tx, pixman_fixed_t ty);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_bounds(const struct pixman_transform *matrix,
|
||||
struct pixman_box16 *b);
|
||||
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_invert (struct pixman_transform *dst,
|
||||
const struct pixman_transform *src);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_is_identity(const struct pixman_transform *t);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_is_scale(const struct pixman_transform *t);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_is_int_translate(const struct pixman_transform *t);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_is_inverse (const struct pixman_transform *a,
|
||||
const struct pixman_transform *b);
|
||||
|
||||
|
||||
/*
|
||||
* Floating point matrices
|
||||
*/
|
||||
struct pixman_f_vector {
|
||||
double v[3];
|
||||
};
|
||||
|
||||
struct pixman_f_transform {
|
||||
double m[3][3];
|
||||
};
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
|
||||
const struct pixman_f_transform *ft);
|
||||
|
||||
void
|
||||
pixman_f_transform_from_pixman_transform (struct pixman_f_transform *ft,
|
||||
const struct pixman_transform *t);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
|
||||
const struct pixman_f_transform *ft);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_f_transform_invert (struct pixman_f_transform *dst,
|
||||
const struct pixman_f_transform *src);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_f_transform_point (const struct pixman_f_transform *t,
|
||||
struct pixman_f_vector *v);
|
||||
|
||||
void
|
||||
pixman_f_transform_point_3d (const struct pixman_f_transform *t,
|
||||
struct pixman_f_vector *v);
|
||||
|
||||
|
||||
void
|
||||
pixman_f_transform_multiply (struct pixman_f_transform *dst,
|
||||
const struct pixman_f_transform *l,
|
||||
const struct pixman_f_transform *r);
|
||||
|
||||
void
|
||||
pixman_f_transform_init_scale (struct pixman_f_transform *t, double sx, double sy);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_f_transform_scale (struct pixman_f_transform *forward,
|
||||
struct pixman_f_transform *reverse,
|
||||
double sx, double sy);
|
||||
|
||||
void
|
||||
pixman_f_transform_init_rotate (struct pixman_f_transform *t, double cos, double sin);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_f_transform_rotate (struct pixman_f_transform *forward,
|
||||
struct pixman_f_transform *reverse,
|
||||
double c, double s);
|
||||
|
||||
void
|
||||
pixman_f_transform_init_translate (struct pixman_f_transform *t, double tx, double ty);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_f_transform_translate (struct pixman_f_transform *forward,
|
||||
struct pixman_f_transform *reverse,
|
||||
double tx, double ty);
|
||||
|
||||
pixman_bool_t
|
||||
pixman_f_transform_bounds (const struct pixman_f_transform *t, struct pixman_box16 *b);
|
||||
|
||||
void
|
||||
pixman_f_transform_init_identity (struct pixman_f_transform *t);
|
||||
|
||||
/* Don't blame me, blame XRender */
|
||||
typedef enum
|
||||
{
|
||||
|
|
@ -436,9 +583,6 @@ pixman_bool_t pixman_fill (uint32_t *bits,
|
|||
int height,
|
||||
uint32_t _xor);
|
||||
|
||||
pixman_bool_t pixman_transform_point_3d (pixman_transform_t *transform,
|
||||
pixman_vector_t *vector);
|
||||
|
||||
int pixman_version (void);
|
||||
const char* pixman_version_string (void);
|
||||
|
||||
|
|
@ -504,7 +648,9 @@ struct pixman_indexed
|
|||
#define PIXMAN_TYPE_YUY2 6
|
||||
#define PIXMAN_TYPE_YV12 7
|
||||
|
||||
#define PIXMAN_FORMAT_COLOR(f) (PIXMAN_FORMAT_TYPE(f) & 2)
|
||||
#define PIXMAN_FORMAT_COLOR(f) \
|
||||
(PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ARGB || \
|
||||
PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ABGR)
|
||||
|
||||
/* 32bpp formats */
|
||||
typedef enum {
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче