source/libs/pixman/pixman-src/pixman/pixman-linear-gradient.c

   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
  34 static pixman_bool_t
  35 linear_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
  91 static uint32_t *
  92 linear_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
 225 static uint32_t *
 226 linear_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
 236 void
 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
 258 PIXMAN_EXPORT pixman_image_t *
 259 pixman_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