1/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */
2/*
3 * Copyright © 2000 SuSE, Inc.
4 * Copyright © 2007 Red Hat, Inc.
5 * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
6 *             2005 Lars Knoll & Zack Rusin, Trolltech
7 *
8 * Permission to use, copy, modify, distribute, and sell this software and its
9 * documentation for any purpose is hereby granted without fee, provided that
10 * the above copyright notice appear in all copies and that both that
11 * copyright notice and this permission notice appear in supporting
12 * documentation, and that the name of Keith Packard not be used in
13 * advertising or publicity pertaining to distribution of the software without
14 * specific, written prior permission.  Keith Packard makes no
15 * representations about the suitability of this software for any purpose.  It
16 * is provided "as is" without express or implied warranty.
17 *
18 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
19 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
20 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
21 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
22 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
23 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
24 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
25 * SOFTWARE.
26 */
27
28#ifdef HAVE_CONFIG_H
29#include <config.h>
30#endif
31#include <stdlib.h>
32#include "pixman-private.h"
33
34static pixman_bool_t
35linear_gradient_is_horizontal (pixman_image_t *image,
36			       int             x,
37			       int             y,
38			       int             width,
39			       int             height)
40{
41    linear_gradient_t *linear = (linear_gradient_t *)image;
42    pixman_vector_t v;
43    pixman_fixed_32_32_t l;
44    pixman_fixed_48_16_t dx, dy;
45    double inc;
46
47    if (image->common.transform)
48    {
49	/* projective transformation */
50	if (image->common.transform->matrix[2][0] != 0 ||
51	    image->common.transform->matrix[2][1] != 0 ||
52	    image->common.transform->matrix[2][2] == 0)
53	{
54	    return FALSE;
55	}
56
57	v.vector[0] = image->common.transform->matrix[0][1];
58	v.vector[1] = image->common.transform->matrix[1][1];
59	v.vector[2] = image->common.transform->matrix[2][2];
60    }
61    else
62    {
63	v.vector[0] = 0;
64	v.vector[1] = pixman_fixed_1;
65	v.vector[2] = pixman_fixed_1;
66    }
67
68    dx = linear->p2.x - linear->p1.x;
69    dy = linear->p2.y - linear->p1.y;
70
71    l = dx * dx + dy * dy;
72
73    if (l == 0)
74	return FALSE;
75
76    /*
77     * compute how much the input of the gradient walked changes
78     * when moving vertically through the whole image
79     */
80    inc = height * (double) pixman_fixed_1 * pixman_fixed_1 *
81	(dx * v.vector[0] + dy * v.vector[1]) /
82	(v.vector[2] * (double) l);
83
84    /* check that casting to integer would result in 0 */
85    if (-1 < inc && inc < 1)
86	return TRUE;
87
88    return FALSE;
89}
90
91static uint32_t *
92linear_get_scanline_narrow (pixman_iter_t  *iter,
93			    const uint32_t *mask)
94{
95    pixman_image_t *image  = iter->image;
96    int             x      = iter->x;
97    int             y      = iter->y;
98    int             width  = iter->width;
99    uint32_t *      buffer = iter->buffer;
100
101    pixman_vector_t v, unit;
102    pixman_fixed_32_32_t l;
103    pixman_fixed_48_16_t dx, dy;
104    gradient_t *gradient = (gradient_t *)image;
105    linear_gradient_t *linear = (linear_gradient_t *)image;
106    uint32_t *end = buffer + width;
107    pixman_gradient_walker_t walker;
108
109    _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);
110
111    /* reference point is the center of the pixel */
112    v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;
113    v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;
114    v.vector[2] = pixman_fixed_1;
115
116    if (image->common.transform)
117    {
118	if (!pixman_transform_point_3d (image->common.transform, &v))
119	    return iter->buffer;
120
121	unit.vector[0] = image->common.transform->matrix[0][0];
122	unit.vector[1] = image->common.transform->matrix[1][0];
123	unit.vector[2] = image->common.transform->matrix[2][0];
124    }
125    else
126    {
127	unit.vector[0] = pixman_fixed_1;
128	unit.vector[1] = 0;
129	unit.vector[2] = 0;
130    }
131
132    dx = linear->p2.x - linear->p1.x;
133    dy = linear->p2.y - linear->p1.y;
134
135    l = dx * dx + dy * dy;
136
137    if (l == 0 || unit.vector[2] == 0)
138    {
139	/* affine transformation only */
140        pixman_fixed_32_32_t t, next_inc;
141	double inc;
142
143	if (l == 0 || v.vector[2] == 0)
144	{
145	    t = 0;
146	    inc = 0;
147	}
148	else
149	{
150	    double invden, v2;
151
152	    invden = pixman_fixed_1 * (double) pixman_fixed_1 /
153		(l * (double) v.vector[2]);
154	    v2 = v.vector[2] * (1. / pixman_fixed_1);
155	    t = ((dx * v.vector[0] + dy * v.vector[1]) -
156		 (dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;
157	    inc = (dx * unit.vector[0] + dy * unit.vector[1]) * invden;
158	}
159	next_inc = 0;
160
161	if (((pixman_fixed_32_32_t )(inc * width)) == 0)
162	{
163	    register uint32_t color;
164
165	    color = _pixman_gradient_walker_pixel (&walker, t);
166	    while (buffer < end)
167		*buffer++ = color;
168	}
169	else
170	{
171	    int i;
172
173	    i = 0;
174	    while (buffer < end)
175	    {
176		if (!mask || *mask++)
177		{
178		    *buffer = _pixman_gradient_walker_pixel (&walker,
179							     t + next_inc);
180		}
181		i++;
182		next_inc = inc * i;
183		buffer++;
184	    }
185	}
186    }
187    else
188    {
189	/* projective transformation */
190        double t;
191
192	t = 0;
193
194	while (buffer < end)
195	{
196	    if (!mask || *mask++)
197	    {
198	        if (v.vector[2] != 0)
199		{
200		    double invden, v2;
201
202		    invden = pixman_fixed_1 * (double) pixman_fixed_1 /
203			(l * (double) v.vector[2]);
204		    v2 = v.vector[2] * (1. / pixman_fixed_1);
205		    t = ((dx * v.vector[0] + dy * v.vector[1]) -
206			 (dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;
207		}
208
209		*buffer = _pixman_gradient_walker_pixel (&walker, t);
210	    }
211
212	    ++buffer;
213
214	    v.vector[0] += unit.vector[0];
215	    v.vector[1] += unit.vector[1];
216	    v.vector[2] += unit.vector[2];
217	}
218    }
219
220    iter->y++;
221
222    return iter->buffer;
223}
224
225static uint32_t *
226linear_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
227{
228    uint32_t *buffer = linear_get_scanline_narrow (iter, NULL);
229
230    pixman_expand_to_float (
231	(argb_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
232
233    return buffer;
234}
235
236void
237_pixman_linear_gradient_iter_init (pixman_image_t *image, pixman_iter_t  *iter)
238{
239    if (linear_gradient_is_horizontal (
240	    iter->image, iter->x, iter->y, iter->width, iter->height))
241    {
242	if (iter->iter_flags & ITER_NARROW)
243	    linear_get_scanline_narrow (iter, NULL);
244	else
245	    linear_get_scanline_wide (iter, NULL);
246
247	iter->get_scanline = _pixman_iter_get_scanline_noop;
248    }
249    else
250    {
251	if (iter->iter_flags & ITER_NARROW)
252	    iter->get_scanline = linear_get_scanline_narrow;
253	else
254	    iter->get_scanline = linear_get_scanline_wide;
255    }
256}
257
258PIXMAN_EXPORT pixman_image_t *
259pixman_image_create_linear_gradient (const pixman_point_fixed_t *  p1,
260                                     const pixman_point_fixed_t *  p2,
261                                     const pixman_gradient_stop_t *stops,
262                                     int                           n_stops)
263{
264    pixman_image_t *image;
265    linear_gradient_t *linear;
266
267    image = _pixman_image_allocate ();
268
269    if (!image)
270	return NULL;
271
272    linear = &image->linear;
273
274    if (!_pixman_init_gradient (&linear->common, stops, n_stops))
275    {
276	free (image);
277	return NULL;
278    }
279
280    linear->p1 = *p1;
281    linear->p2 = *p2;
282
283    image->type = LINEAR;
284
285    return image;
286}
287
288