Aren/kolibrios
1
0
Fork 0
mirror of https://github.com/KolibriOS/kolibrios.git synced 2024-12-17 04:12:34 +03:00
Code Issues Packages Projects Releases Wiki Activity
c7be7bd71e
kolibrios/contrib/sdk/sources/pixman/pixman-matrix.c
Sergey Semyonov (Serge) 754f9336f0 upload sdk 
git-svn-id: svn://kolibrios.org@4349 a494cfbc-eb01-0410-851d-a64ba20cac60
2013-12-15 08:09:20 +00:00

1074 lines
28 KiB
C
Raw Blame History

/*
* 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)
static force_inline int
count_leading_zeros (uint32_t x)
{
#ifdef __GNUC__
return __builtin_clz (x);
#else
int n = 0;
while (x)
{
n++;
x >>= 1;
}
return 32 - n;
#endif
}
/*
* Large signed/unsigned integer division with rounding for the platforms with
* only 64-bit integer data type supported (no 128-bit data type).
*
* Arguments:
* hi, lo - high and low 64-bit parts of the dividend
* div - 48-bit divisor
*
* Returns: lowest 64 bits of the result as a return value and highest 64
* bits of the result to "result_hi" pointer
*/
/* grade-school unsigned division (128-bit by 48-bit) with rounding to nearest */
static force_inline uint64_t
rounded_udiv_128_by_48 (uint64_t hi,
uint64_t lo,
uint64_t div,
uint64_t *result_hi)
{
uint64_t tmp, remainder, result_lo;
assert(div < ((uint64_t)1 << 48));
remainder = hi % div;
*result_hi = hi / div;
tmp = (remainder << 16) + (lo >> 48);
result_lo = tmp / div;
remainder = tmp % div;
tmp = (remainder << 16) + ((lo >> 32) & 0xFFFF);
result_lo = (result_lo << 16) + (tmp / div);
remainder = tmp % div;
tmp = (remainder << 16) + ((lo >> 16) & 0xFFFF);
result_lo = (result_lo << 16) + (tmp / div);
remainder = tmp % div;
tmp = (remainder << 16) + (lo & 0xFFFF);
result_lo = (result_lo << 16) + (tmp / div);
remainder = tmp % div;
/* round to nearest */
if (remainder * 2 >= div && ++result_lo == 0)
*result_hi += 1;
return result_lo;
}
/* signed division (128-bit by 49-bit) with rounding to nearest */
static inline int64_t
rounded_sdiv_128_by_49 (int64_t hi,
uint64_t lo,
int64_t div,
int64_t *signed_result_hi)
{
uint64_t result_lo, result_hi;
int sign = 0;
if (div < 0)
{
div = -div;
sign ^= 1;
}
if (hi < 0)
{
if (lo != 0)
hi++;
hi = -hi;
lo = -lo;
sign ^= 1;
}
result_lo = rounded_udiv_128_by_48 (hi, lo, div, &result_hi);
if (sign)
{
if (result_lo != 0)
result_hi++;
result_hi = -result_hi;
result_lo = -result_lo;
}
if (signed_result_hi)
{
*signed_result_hi = result_hi;
}
return result_lo;
}
/*
* Multiply 64.16 fixed point value by (2^scalebits) and convert
* to 128-bit integer.
*/
static force_inline void
fixed_64_16_to_int128 (int64_t hi,
int64_t lo,
int64_t *rhi,
int64_t *rlo,
int scalebits)
{
/* separate integer and fractional parts */
hi += lo >> 16;
lo &= 0xFFFF;
if (scalebits <= 0)
{
*rlo = hi >> (-scalebits);
*rhi = *rlo >> 63;
}
else
{
*rhi = hi >> (64 - scalebits);
*rlo = (uint64_t)hi << scalebits;
if (scalebits < 16)
*rlo += lo >> (16 - scalebits);
else
*rlo += lo << (scalebits - 16);
}
}
/*
* Convert 112.16 fixed point value to 48.16 with clamping for the out
* of range values.
*/
static force_inline pixman_fixed_48_16_t
fixed_112_16_to_fixed_48_16 (int64_t hi, int64_t lo, pixman_bool_t *clampflag)
{
if ((lo >> 63) != hi)
{
*clampflag = TRUE;
return hi >= 0 ? INT64_MAX : INT64_MIN;
}
else
{
return lo;
}
}
/*
* Transform a point with 31.16 fixed point coordinates from the destination
* space to a point with 48.16 fixed point coordinates in the source space.
* No overflows are possible for affine transformations and the results are
* accurate including the least significant bit. Projective transformations
* may overflow, in this case the results are just clamped to return maximum
* or minimum 48.16 values (so that the caller can at least handle the NONE
* and PAD repeats correctly) and the return value is FALSE to indicate that
* such clamping has happened.
*/
PIXMAN_EXPORT pixman_bool_t
pixman_transform_point_31_16 (const pixman_transform_t *t,
const pixman_vector_48_16_t *v,
pixman_vector_48_16_t *result)
{
pixman_bool_t clampflag = FALSE;
int i;
int64_t tmp[3][2], divint;
uint16_t divfrac;
/* input vector values must have no more than 31 bits (including sign)
* in the integer part */
assert (v->v[0] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[0] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[1] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[1] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[2] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[2] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
for (i = 0; i < 3; i++)
{
tmp[i][0] = (int64_t)t->matrix[i][0] * (v->v[0] >> 16);
tmp[i][1] = (int64_t)t->matrix[i][0] * (v->v[0] & 0xFFFF);
tmp[i][0] += (int64_t)t->matrix[i][1] * (v->v[1] >> 16);
tmp[i][1] += (int64_t)t->matrix[i][1] * (v->v[1] & 0xFFFF);
tmp[i][0] += (int64_t)t->matrix[i][2] * (v->v[2] >> 16);
tmp[i][1] += (int64_t)t->matrix[i][2] * (v->v[2] & 0xFFFF);
}
/*
* separate 64-bit integer and 16-bit fractional parts for the divisor,
* which is also scaled by 65536 after fixed point multiplication.
*/
divint = tmp[2][0] + (tmp[2][1] >> 16);
divfrac = tmp[2][1] & 0xFFFF;
if (divint == pixman_fixed_1 && divfrac == 0)
{
/*
* this is a simple affine transformation
*/
result->v[0] = tmp[0][0] + ((tmp[0][1] + 0x8000) >> 16);
result->v[1] = tmp[1][0] + ((tmp[1][1] + 0x8000) >> 16);
result->v[2] = pixman_fixed_1;
}
else if (divint == 0 && divfrac == 0)
{
/*
* handle zero divisor (if the values are non-zero, set the
* results to maximum positive or minimum negative)
*/
clampflag = TRUE;
result->v[0] = tmp[0][0] + ((tmp[0][1] + 0x8000) >> 16);
result->v[1] = tmp[1][0] + ((tmp[1][1] + 0x8000) >> 16);
if (result->v[0] > 0)
result->v[0] = INT64_MAX;
else if (result->v[0] < 0)
result->v[0] = INT64_MIN;
if (result->v[1] > 0)
result->v[1] = INT64_MAX;
else if (result->v[1] < 0)
result->v[1] = INT64_MIN;
}
else
{
/*
* projective transformation, analyze the top 32 bits of the divisor
*/
int32_t hi32divbits = divint >> 32;
if (hi32divbits < 0)
hi32divbits = ~hi32divbits;
if (hi32divbits == 0)
{
/* the divisor is small, we can actually keep all the bits */
int64_t hi, rhi, lo, rlo;
int64_t div = (divint << 16) + divfrac;
fixed_64_16_to_int128 (tmp[0][0], tmp[0][1], &hi, &lo, 32);
rlo = rounded_sdiv_128_by_49 (hi, lo, div, &rhi);
result->v[0] = fixed_112_16_to_fixed_48_16 (rhi, rlo, &clampflag);
fixed_64_16_to_int128 (tmp[1][0], tmp[1][1], &hi, &lo, 32);
rlo = rounded_sdiv_128_by_49 (hi, lo, div, &rhi);
result->v[1] = fixed_112_16_to_fixed_48_16 (rhi, rlo, &clampflag);
}
else
{
/* the divisor needs to be reduced to 48 bits */
int64_t hi, rhi, lo, rlo, div;
int shift = 32 - count_leading_zeros (hi32divbits);
fixed_64_16_to_int128 (divint, divfrac, &hi, &div, 16 - shift);
fixed_64_16_to_int128 (tmp[0][0], tmp[0][1], &hi, &lo, 32 - shift);
rlo = rounded_sdiv_128_by_49 (hi, lo, div, &rhi);
result->v[0] = fixed_112_16_to_fixed_48_16 (rhi, rlo, &clampflag);
fixed_64_16_to_int128 (tmp[1][0], tmp[1][1], &hi, &lo, 32 - shift);
rlo = rounded_sdiv_128_by_49 (hi, lo, div, &rhi);
result->v[1] = fixed_112_16_to_fixed_48_16 (rhi, rlo, &clampflag);
}
}
result->v[2] = pixman_fixed_1;
return !clampflag;
}
PIXMAN_EXPORT void
pixman_transform_point_31_16_affine (const pixman_transform_t *t,
const pixman_vector_48_16_t *v,
pixman_vector_48_16_t *result)
{
int64_t hi0, lo0, hi1, lo1;
/* input vector values must have no more than 31 bits (including sign)
* in the integer part */
assert (v->v[0] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[0] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[1] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[1] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
hi0 = (int64_t)t->matrix[0][0] * (v->v[0] >> 16);
lo0 = (int64_t)t->matrix[0][0] * (v->v[0] & 0xFFFF);
hi0 += (int64_t)t->matrix[0][1] * (v->v[1] >> 16);
lo0 += (int64_t)t->matrix[0][1] * (v->v[1] & 0xFFFF);
hi0 += (int64_t)t->matrix[0][2];
hi1 = (int64_t)t->matrix[1][0] * (v->v[0] >> 16);
lo1 = (int64_t)t->matrix[1][0] * (v->v[0] & 0xFFFF);
hi1 += (int64_t)t->matrix[1][1] * (v->v[1] >> 16);
lo1 += (int64_t)t->matrix[1][1] * (v->v[1] & 0xFFFF);
hi1 += (int64_t)t->matrix[1][2];
result->v[0] = hi0 + ((lo0 + 0x8000) >> 16);
result->v[1] = hi1 + ((lo1 + 0x8000) >> 16);
result->v[2] = pixman_fixed_1;
}
PIXMAN_EXPORT void
pixman_transform_point_31_16_3d (const pixman_transform_t *t,
const pixman_vector_48_16_t *v,
pixman_vector_48_16_t *result)
{
int i;
int64_t tmp[3][2];
/* input vector values must have no more than 31 bits (including sign)
* in the integer part */
assert (v->v[0] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[0] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[1] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[1] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[2] < ((pixman_fixed_48_16_t)1 << (30 + 16)));
assert (v->v[2] >= -((pixman_fixed_48_16_t)1 << (30 + 16)));
for (i = 0; i < 3; i++)
{
tmp[i][0] = (int64_t)t->matrix[i][0] * (v->v[0] >> 16);
tmp[i][1] = (int64_t)t->matrix[i][0] * (v->v[0] & 0xFFFF);
tmp[i][0] += (int64_t)t->matrix[i][1] * (v->v[1] >> 16);
tmp[i][1] += (int64_t)t->matrix[i][1] * (v->v[1] & 0xFFFF);
tmp[i][0] += (int64_t)t->matrix[i][2] * (v->v[2] >> 16);
tmp[i][1] += (int64_t)t->matrix[i][2] * (v->v[2] & 0xFFFF);
}
result->v[0] = tmp[0][0] + ((tmp[0][1] + 0x8000) >> 16);
result->v[1] = tmp[1][0] + ((tmp[1][1] + 0x8000) >> 16);
result->v[2] = tmp[2][0] + ((tmp[2][1] + 0x8000) >> 16);
}
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)
{
pixman_vector_48_16_t tmp;
tmp.v[0] = vector->vector[0];
tmp.v[1] = vector->vector[1];
tmp.v[2] = vector->vector[2];
pixman_transform_point_31_16_3d (transform, &tmp, &tmp);
vector->vector[0] = tmp.v[0];
vector->vector[1] = tmp.v[1];
vector->vector[2] = tmp.v[2];
return vector->vector[0] == tmp.v[0] &&
vector->vector[1] == tmp.v[1] &&
vector->vector[2] == tmp.v[2];
}
PIXMAN_EXPORT pixman_bool_t
pixman_transform_point (const struct pixman_transform *transform,
struct pixman_vector * vector)
{
pixman_vector_48_16_t tmp;
tmp.v[0] = vector->vector[0];
tmp.v[1] = vector->vector[1];
tmp.v[2] = vector->vector[2];
if (!pixman_transform_point_31_16 (transform, &tmp, &tmp))
return FALSE;
vector->vector[0] = tmp.v[0];
vector->vector[1] = tmp.v[1];
vector->vector[2] = tmp.v[2];
return vector->vector[0] == tmp.v[0] &&
vector->vector[1] == tmp.v[1] &&
vector->vector[2] == tmp.v[2];
}
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 + 0x8000) >> 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;
pixman_f_transform_from_pixman_transform (&m, src);
if (!pixman_f_transform_invert (&m, &m))
return FALSE;
if (!pixman_transform_from_pixman_f_transform (dst, &m))
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;
if (!pixman_transform_multiply (&t, a, b))
return FALSE;
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;
}
PIXMAN_EXPORT pixman_bool_t
pixman_f_transform_invert (struct pixman_f_transform * dst,
const struct pixman_f_transform *src)
{
static const int a[3] = { 2, 2, 1 };
static const int b[3] = { 1, 0, 0 };
pixman_f_transform_t d;
double det;
int i, j;
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;
d.m[j][i] = det * p;
}
}
*dst = d;
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;
}
}
Reference in New Issue View Git Blame Copy Permalink