[deb_xorg-server.git] / randr / rrtransform.c

/*
 * Copyright © 2007 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.
 */

#include "randrstr.h"
#include "rrtransform.h"

void
RRTransformInit(RRTransformPtr transform)
{
    pixman_transform_init_identity(&transform->transform);
    pixman_f_transform_init_identity(&transform->f_transform);
    pixman_f_transform_init_identity(&transform->f_inverse);
    transform->filter = NULL;
    transform->params = NULL;
    transform->nparams = 0;
}

void
RRTransformFini(RRTransformPtr transform)
{
    free(transform->params);
}

Bool
RRTransformEqual(RRTransformPtr a, RRTransformPtr b)
{
    if (a && pixman_transform_is_identity(&a->transform))
        a = NULL;
    if (b && pixman_transform_is_identity(&b->transform))
        b = NULL;
    if (a == NULL && b == NULL)
        return TRUE;
    if (a == NULL || b == NULL)
        return FALSE;
    if (memcmp(&a->transform, &b->transform, sizeof(a->transform)) != 0)
        return FALSE;
    if (a->filter != b->filter)
        return FALSE;
    if (a->nparams != b->nparams)
        return FALSE;
    if (memcmp(a->params, b->params, a->nparams * sizeof(xFixed)) != 0)
        return FALSE;
    return TRUE;
}

Bool
RRTransformSetFilter(RRTransformPtr dst,
                     PictFilterPtr filter,
                     xFixed * params, int nparams, int width, int height)
{
    xFixed *new_params;

    if (nparams) {
        new_params = malloc(nparams * sizeof(xFixed));
        if (!new_params)
            return FALSE;
        memcpy(new_params, params, nparams * sizeof(xFixed));
    }
    else
        new_params = NULL;
    free(dst->params);
    dst->filter = filter;
    dst->params = new_params;
    dst->nparams = nparams;
    dst->width = width;
    dst->height = height;
    return TRUE;
}

Bool
RRTransformCopy(RRTransformPtr dst, RRTransformPtr src)
{
    if (src && pixman_transform_is_identity(&src->transform))
        src = NULL;

    if (src) {
        if (!RRTransformSetFilter(dst, src->filter,
                                  src->params, src->nparams, src->width,
                                  src->height))
            return FALSE;
        dst->transform = src->transform;
        dst->f_transform = src->f_transform;
        dst->f_inverse = src->f_inverse;
    }
    else {
        if (!RRTransformSetFilter(dst, NULL, NULL, 0, 0, 0))
            return FALSE;
        pixman_transform_init_identity(&dst->transform);
        pixman_f_transform_init_identity(&dst->f_transform);
        pixman_f_transform_init_identity(&dst->f_inverse);
    }
    return TRUE;
}

#define F(x)	IntToxFixed(x)

static void
RRTransformRescale(struct pixman_f_transform *f_transform, double limit)
{
    double max = 0, v, scale;
    int i, j;

    for (j = 0; j < 3; j++)
        for (i = 0; i < 3; i++)
            if ((v = abs(f_transform->m[j][i])) > max)
                max = v;
    scale = limit / max;
    for (j = 0; j < 3; j++)
        for (i = 0; i < 3; i++)
            f_transform->m[j][i] *= scale;
}

/*
 * Compute the complete transformation matrix including
 * client-specified transform, rotation/reflection values and the crtc 
 * offset.
 *
 * Return TRUE if the resulting transform is not a simple translation.
 */
Bool
RRTransformCompute(int x,
                   int y,
                   int width,
                   int height,
                   Rotation rotation,
                   RRTransformPtr rr_transform,
                   PictTransformPtr transform,
                   struct pixman_f_transform *f_transform,
                   struct pixman_f_transform *f_inverse)
{
    PictTransform t_transform, inverse;
    struct pixman_f_transform tf_transform, tf_inverse;
    Bool overflow = FALSE;

    if (!transform)
        transform = &t_transform;
    if (!f_transform)
        f_transform = &tf_transform;
    if (!f_inverse)
        f_inverse = &tf_inverse;

    pixman_transform_init_identity(transform);
    pixman_transform_init_identity(&inverse);
    pixman_f_transform_init_identity(f_transform);
    pixman_f_transform_init_identity(f_inverse);
    if (rotation != RR_Rotate_0) {
        double f_rot_cos, f_rot_sin, f_rot_dx, f_rot_dy;
        double f_scale_x, f_scale_y, f_scale_dx, f_scale_dy;
        xFixed rot_cos, rot_sin, rot_dx, rot_dy;
        xFixed scale_x, scale_y, scale_dx, scale_dy;

        /* rotation */
        switch (rotation & 0xf) {
        default:
        case RR_Rotate_0:
            f_rot_cos = 1;
            f_rot_sin = 0;
            f_rot_dx = 0;
            f_rot_dy = 0;
            rot_cos = F(1);
            rot_sin = F(0);
            rot_dx = F(0);
            rot_dy = F(0);
            break;
        case RR_Rotate_90:
            f_rot_cos = 0;
            f_rot_sin = 1;
            f_rot_dx = height;
            f_rot_dy = 0;
            rot_cos = F(0);
            rot_sin = F(1);
            rot_dx = F(height);
            rot_dy = F(0);
            break;
        case RR_Rotate_180:
            f_rot_cos = -1;
            f_rot_sin = 0;
            f_rot_dx = width;
            f_rot_dy = height;
            rot_cos = F(-1);
            rot_sin = F(0);
            rot_dx = F(width);
            rot_dy = F(height);
            break;
        case RR_Rotate_270:
            f_rot_cos = 0;
            f_rot_sin = -1;
            f_rot_dx = 0;
            f_rot_dy = width;
            rot_cos = F(0);
            rot_sin = F(-1);
            rot_dx = F(0);
            rot_dy = F(width);
            break;
        }

        pixman_transform_rotate(transform, &inverse, rot_cos, rot_sin);
        pixman_transform_translate(transform, &inverse, rot_dx, rot_dy);
        pixman_f_transform_rotate(f_transform, f_inverse, f_rot_cos, f_rot_sin);
        pixman_f_transform_translate(f_transform, f_inverse, f_rot_dx,
                                     f_rot_dy);

        /* reflection */
        f_scale_x = 1;
        f_scale_dx = 0;
        f_scale_y = 1;
        f_scale_dy = 0;
        scale_x = F(1);
        scale_dx = 0;
        scale_y = F(1);
        scale_dy = 0;
        if (rotation & RR_Reflect_X) {
            f_scale_x = -1;
            scale_x = F(-1);
            if (rotation & (RR_Rotate_0 | RR_Rotate_180)) {
                f_scale_dx = width;
                scale_dx = F(width);
            }
            else {
                f_scale_dx = height;
                scale_dx = F(height);
            }
        }
        if (rotation & RR_Reflect_Y) {
            f_scale_y = -1;
            scale_y = F(-1);
            if (rotation & (RR_Rotate_0 | RR_Rotate_180)) {
                f_scale_dy = height;
                scale_dy = F(height);
            }
            else {
                f_scale_dy = width;
                scale_dy = F(width);
            }
        }

        pixman_transform_scale(transform, &inverse, scale_x, scale_y);
        pixman_f_transform_scale(f_transform, f_inverse, f_scale_x, f_scale_y);
        pixman_transform_translate(transform, &inverse, scale_dx, scale_dy);
        pixman_f_transform_translate(f_transform, f_inverse, f_scale_dx,
                                     f_scale_dy);
    }

#ifdef RANDR_12_INTERFACE
    if (rr_transform) {
        if (!pixman_transform_multiply
            (transform, &rr_transform->transform, transform))
            overflow = TRUE;
        pixman_f_transform_multiply(f_transform, &rr_transform->f_transform,
                                    f_transform);
        pixman_f_transform_multiply(f_inverse, f_inverse,
                                    &rr_transform->f_inverse);
    }
#endif
    /*
     * Compute the class of the resulting transform
     */
    if (!overflow && pixman_transform_is_identity(transform)) {
        pixman_transform_init_translate(transform, F(x), F(y));

        pixman_f_transform_init_translate(f_transform, x, y);
        pixman_f_transform_init_translate(f_inverse, -x, -y);
        return FALSE;
    }
    else {
        pixman_f_transform_translate(f_transform, f_inverse, x, y);
        if (!pixman_transform_translate(transform, &inverse, F(x), F(y)))
            overflow = TRUE;
        if (overflow) {
            struct pixman_f_transform f_scaled;

            f_scaled = *f_transform;
            RRTransformRescale(&f_scaled, 16384.0);
            pixman_transform_from_pixman_f_transform(transform, &f_scaled);
        }
        return TRUE;
    }
}
Commit	Line	Data
a09e091a JB	1	/*
	2	* Copyright © 2007 Keith Packard
	3	*
	4	* Permission to use, copy, modify, distribute, and sell this software and its
	5	* documentation for any purpose is hereby granted without fee, provided that
	6	* the above copyright notice appear in all copies and that both that copyright
	7	* notice and this permission notice appear in supporting documentation, and
	8	* that the name of the copyright holders not be used in advertising or
	9	* publicity pertaining to distribution of the software without specific,
	10	* written prior permission. The copyright holders make no representations
	11	* about the suitability of this software for any purpose. It is provided "as
	12	* is" without express or implied warranty.
	13	*
	14	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	15	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	16	* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	17	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	18	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	19	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	20	* OF THIS SOFTWARE.
	21	*/
	22
	23	#include "randrstr.h"
	24	#include "rrtransform.h"
	25
	26	void
	27	RRTransformInit(RRTransformPtr transform)
	28	{
	29	pixman_transform_init_identity(&transform->transform);
	30	pixman_f_transform_init_identity(&transform->f_transform);
	31	pixman_f_transform_init_identity(&transform->f_inverse);
	32	transform->filter = NULL;
	33	transform->params = NULL;
	34	transform->nparams = 0;
	35	}
	36
	37	void
	38	RRTransformFini(RRTransformPtr transform)
	39	{
	40	free(transform->params);
	41	}
	42
	43	Bool
	44	RRTransformEqual(RRTransformPtr a, RRTransformPtr b)
	45	{
	46	if (a && pixman_transform_is_identity(&a->transform))
	47	a = NULL;
	48	if (b && pixman_transform_is_identity(&b->transform))
	49	b = NULL;
	50	if (a == NULL && b == NULL)
	51	return TRUE;
	52	if (a == NULL \|\| b == NULL)
	53	return FALSE;
	54	if (memcmp(&a->transform, &b->transform, sizeof(a->transform)) != 0)
	55	return FALSE;
	56	if (a->filter != b->filter)
	57	return FALSE;
	58	if (a->nparams != b->nparams)
	59	return FALSE;
	60	if (memcmp(a->params, b->params, a->nparams * sizeof(xFixed)) != 0)
	61	return FALSE;
	62	return TRUE;
	63	}
	64
65	Bool
66	RRTransformSetFilter(RRTransformPtr dst,
67	PictFilterPtr filter,
68	xFixed * params, int nparams, int width, int height)
69	{
70	xFixed *new_params;
71
72	if (nparams) {
73	new_params = malloc(nparams * sizeof(xFixed));
74	if (!new_params)
75	return FALSE;
76	memcpy(new_params, params, nparams * sizeof(xFixed));
77	}
78	else
79	new_params = NULL;
80	free(dst->params);
81	dst->filter = filter;
82	dst->params = new_params;
83	dst->nparams = nparams;
84	dst->width = width;
85	dst->height = height;
86	return TRUE;
87	}
88
89	Bool
90	RRTransformCopy(RRTransformPtr dst, RRTransformPtr src)
91	{
92	if (src && pixman_transform_is_identity(&src->transform))
93	src = NULL;
94
95	if (src) {
96	if (!RRTransformSetFilter(dst, src->filter,
97	src->params, src->nparams, src->width,
98	src->height))
99	return FALSE;
100	dst->transform = src->transform;
101	dst->f_transform = src->f_transform;
102	dst->f_inverse = src->f_inverse;
103	}
104	else {
105	if (!RRTransformSetFilter(dst, NULL, NULL, 0, 0, 0))
106	return FALSE;
107	pixman_transform_init_identity(&dst->transform);
108	pixman_f_transform_init_identity(&dst->f_transform);
109	pixman_f_transform_init_identity(&dst->f_inverse);
110	}
111	return TRUE;
112	}
113
114	#define F(x) IntToxFixed(x)
115
116	static void
117	RRTransformRescale(struct pixman_f_transform *f_transform, double limit)
118	{
119	double max = 0, v, scale;
120	int i, j;
121
122	for (j = 0; j < 3; j++)
123	for (i = 0; i < 3; i++)
124	if ((v = abs(f_transform->m[j][i])) > max)
125	max = v;
126	scale = limit / max;
127	for (j = 0; j < 3; j++)
128	for (i = 0; i < 3; i++)
129	f_transform->m[j][i] *= scale;
130	}
131
132	/*
133	* Compute the complete transformation matrix including
134	* client-specified transform, rotation/reflection values and the crtc
135	* offset.
136	*
137	* Return TRUE if the resulting transform is not a simple translation.
138	*/
139	Bool
140	RRTransformCompute(int x,
141	int y,
142	int width,
143	int height,
144	Rotation rotation,
145	RRTransformPtr rr_transform,
146	PictTransformPtr transform,
147	struct pixman_f_transform *f_transform,
148	struct pixman_f_transform *f_inverse)
149	{
150	PictTransform t_transform, inverse;
151	struct pixman_f_transform tf_transform, tf_inverse;
152	Bool overflow = FALSE;
153
154	if (!transform)
155	transform = &t_transform;
156	if (!f_transform)
157	f_transform = &tf_transform;
158	if (!f_inverse)
159	f_inverse = &tf_inverse;
160
161	pixman_transform_init_identity(transform);
162	pixman_transform_init_identity(&inverse);
163	pixman_f_transform_init_identity(f_transform);
164	pixman_f_transform_init_identity(f_inverse);
165	if (rotation != RR_Rotate_0) {
166	double f_rot_cos, f_rot_sin, f_rot_dx, f_rot_dy;
167	double f_scale_x, f_scale_y, f_scale_dx, f_scale_dy;
168	xFixed rot_cos, rot_sin, rot_dx, rot_dy;
169	xFixed scale_x, scale_y, scale_dx, scale_dy;
170
171	/* rotation */
172	switch (rotation & 0xf) {
173	default:
174	case RR_Rotate_0:
175	f_rot_cos = 1;
176	f_rot_sin = 0;
177	f_rot_dx = 0;
178	f_rot_dy = 0;
179	rot_cos = F(1);
180	rot_sin = F(0);
181	rot_dx = F(0);
182	rot_dy = F(0);
183	break;
184	case RR_Rotate_90:
185	f_rot_cos = 0;
186	f_rot_sin = 1;
187	f_rot_dx = height;
188	f_rot_dy = 0;
189	rot_cos = F(0);
190	rot_sin = F(1);
191	rot_dx = F(height);
192	rot_dy = F(0);
193	break;
194	case RR_Rotate_180:
195	f_rot_cos = -1;
196	f_rot_sin = 0;
197	f_rot_dx = width;
198	f_rot_dy = height;
199	rot_cos = F(-1);
200	rot_sin = F(0);
201	rot_dx = F(width);
202	rot_dy = F(height);
203	break;
204	case RR_Rotate_270:
205	f_rot_cos = 0;
206	f_rot_sin = -1;
207	f_rot_dx = 0;
208	f_rot_dy = width;
209	rot_cos = F(0);
210	rot_sin = F(-1);
211	rot_dx = F(0);
212	rot_dy = F(width);
213	break;
214	}
215
216	pixman_transform_rotate(transform, &inverse, rot_cos, rot_sin);
217	pixman_transform_translate(transform, &inverse, rot_dx, rot_dy);
218	pixman_f_transform_rotate(f_transform, f_inverse, f_rot_cos, f_rot_sin);
219	pixman_f_transform_translate(f_transform, f_inverse, f_rot_dx,
220	f_rot_dy);
221
222	/* reflection */
223	f_scale_x = 1;
224	f_scale_dx = 0;
225	f_scale_y = 1;
226	f_scale_dy = 0;
227	scale_x = F(1);
228	scale_dx = 0;
229	scale_y = F(1);
230	scale_dy = 0;
231	if (rotation & RR_Reflect_X) {
232	f_scale_x = -1;
233	scale_x = F(-1);
234	if (rotation & (RR_Rotate_0 \| RR_Rotate_180)) {
235	f_scale_dx = width;
236	scale_dx = F(width);
237	}
238	else {
239	f_scale_dx = height;
240	scale_dx = F(height);
241	}
242	}
243	if (rotation & RR_Reflect_Y) {
244	f_scale_y = -1;
245	scale_y = F(-1);
246	if (rotation & (RR_Rotate_0 \| RR_Rotate_180)) {
247	f_scale_dy = height;
248	scale_dy = F(height);
249	}
250	else {
251	f_scale_dy = width;
252	scale_dy = F(width);
253	}
254	}
255
256	pixman_transform_scale(transform, &inverse, scale_x, scale_y);
257	pixman_f_transform_scale(f_transform, f_inverse, f_scale_x, f_scale_y);
258	pixman_transform_translate(transform, &inverse, scale_dx, scale_dy);
259	pixman_f_transform_translate(f_transform, f_inverse, f_scale_dx,
260	f_scale_dy);
261	}
262
263	#ifdef RANDR_12_INTERFACE
264	if (rr_transform) {
265	if (!pixman_transform_multiply
266	(transform, &rr_transform->transform, transform))
267	overflow = TRUE;
268	pixman_f_transform_multiply(f_transform, &rr_transform->f_transform,
269	f_transform);
270	pixman_f_transform_multiply(f_inverse, f_inverse,
271	&rr_transform->f_inverse);
272	}
273	#endif
274	/*
275	* Compute the class of the resulting transform
276	*/
277	if (!overflow && pixman_transform_is_identity(transform)) {
278	pixman_transform_init_translate(transform, F(x), F(y));
279
280	pixman_f_transform_init_translate(f_transform, x, y);
281	pixman_f_transform_init_translate(f_inverse, -x, -y);
282	return FALSE;
283	}
284	else {
285	pixman_f_transform_translate(f_transform, f_inverse, x, y);
286	if (!pixman_transform_translate(transform, &inverse, F(x), F(y)))
287	overflow = TRUE;
288	if (overflow) {
289	struct pixman_f_transform f_scaled;
290
291	f_scaled = *f_transform;
292	RRTransformRescale(&f_scaled, 16384.0);
293	pixman_transform_from_pixman_f_transform(transform, &f_scaled);
294	}
295	return TRUE;
296	}
297	}