src/cairo-gl-gradient.c

   1 /* cairo - a vector graphics library with display and print output
   2  *
   3  * Copyright © 2009 Eric Anholt
   4  * Copyright © 2009 Chris Wilson
   5  * Copyright © 2005,2010 Red Hat, Inc
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it either under the terms of the GNU Lesser General Public
   9  * License version 2.1 as published by the Free Software Foundation
  10  * (the "LGPL") or, at your option, under the terms of the Mozilla
  11  * Public License Version 1.1 (the "MPL"). If you do not alter this
  12  * notice, a recipient may use your version of this file under either
  13  * the MPL or the LGPL.
  14  *
  15  * You should have received a copy of the LGPL along with this library
  16  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
  18  * You should have received a copy of the MPL along with this library
  19  * in the file COPYING-MPL-1.1
  20  *
  21  * The contents of this file are subject to the Mozilla Public License
  22  * Version 1.1 (the "License"); you may not use this file except in
  23  * compliance with the License. You may obtain a copy of the License at
  24  * http://www.mozilla.org/MPL/
  25  *
  26  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
  27  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
  28  * the specific language governing rights and limitations.
  29  *
  30  * The Original Code is the cairo graphics library.
  31  *
  32  * The Initial Developer of the Original Code is Red Hat, Inc.
  33  *
  34  * Contributor(s):
  35  *      Benjamin Otte <otte@gnome.org>
  36  *      Carl Worth <cworth@cworth.org>
  37  *      Chris Wilson <chris@chris-wilson.co.uk>
  38  *      Eric Anholt <eric@anholt.net>
  39  */
  40
  41 #include "cairoint.h"
  42
  43 #include "cairo-error-private.h"
  44 #include "cairo-gl-gradient-private.h"
  45 #include "cairo-gl-private.h"
  46
  47
  48 static int
  49 _cairo_gl_gradient_sample_width (unsigned int                 n_stops,
  50                                  const cairo_gradient_stop_t *stops)
  51 {
  52     unsigned int n;
  53     int width;
  54
  55     width = 8;
  56     for (n = 1; n < n_stops; n++) {
  57         double dx = stops[n].offset - stops[n-1].offset;
  58         double delta, max;
  59         int ramp;
  60
  61         if (dx == 0)
  62             return 1024; /* we need to emulate an infinitely sharp step */
  63
  64         max = fabs (stops[n].color.red - stops[n-1].color.red);
  65
  66         delta = fabs (stops[n].color.green - stops[n-1].color.green);
  67         if (delta > max)
  68             max = delta;
  69
  70         delta = fabs (stops[n].color.blue - stops[n-1].color.blue);
  71         if (delta > max)
  72             max = delta;
  73
  74         delta = fabs (stops[n].color.alpha - stops[n-1].color.alpha);
  75         if (delta > max)
  76             max = delta;
  77
  78         ramp = 128 * max / dx;
  79         if (ramp > width)
  80             width = ramp;
  81     }
  82
  83     return (width + 7) & -8;
  84 }
  85
  86 /*
  87  # to avoid warning : defined but not used [-Wunused-function]
  88 static uint8_t premultiply(double c, double a)
  89 {
  90     int v = c * a * 256;
  91     return v - (v >> 8);
  92 }
  93
  94 static uint32_t color_stop_to_pixel(const cairo_gradient_stop_t *stop)
  95 {
  96     uint8_t a, r, g, b;
  97
  98     a = stop->color.alpha_short >> 8;
  99     r = premultiply(stop->color.red,   stop->color.alpha);
 100     g = premultiply(stop->color.green, stop->color.alpha);
 101     b = premultiply(stop->color.blue,  stop->color.alpha);
 102
 103     if (_cairo_is_little_endian ())
 104         return a << 24 | r << 16 | g << 8 | b << 0;
 105     else
 106         return a << 0 | r << 8 | g << 16 | b << 24;
 107 }
 108 */
 109
 110 static cairo_status_t
 111 _cairo_gl_gradient_render (const cairo_gl_context_t    *ctx,
 112                            unsigned int                 n_stops,
 113                            const cairo_gradient_stop_t *stops,
 114                            void                        *bytes,
 115                            int                          width)
 116 {
 117     pixman_image_t *gradient, *image;
 118     pixman_gradient_stop_t pixman_stops_stack[32];
 119     pixman_gradient_stop_t *pixman_stops;
 120     pixman_point_fixed_t p1, p2;
 121     unsigned int i;
 122     pixman_format_code_t gradient_pixman_format;
 123
 124     /*
 125      * Ensure that the order of the gradient's components in memory is BGRA.
 126      * This is done so that the gradient's pixel data is always suitable for
 127      * texture upload using format=GL_BGRA and type=GL_UNSIGNED_BYTE.
 128      */
 129     if (_cairo_is_little_endian ())
 130         gradient_pixman_format = PIXMAN_a8r8g8b8;
 131     else
 132         gradient_pixman_format = PIXMAN_b8g8r8a8;
 133
 134     pixman_stops = pixman_stops_stack;
 135     if (unlikely (n_stops > ARRAY_LENGTH (pixman_stops_stack))) {
 136         pixman_stops = _cairo_malloc_ab (n_stops,
 137                                          sizeof (pixman_gradient_stop_t));
 138         if (unlikely (pixman_stops == NULL))
 139             return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 140     }
 141
 142     for (i = 0; i < n_stops; i++) {
 143         pixman_stops[i].x = _cairo_fixed_16_16_from_double (stops[i].offset);
 144         pixman_stops[i].color.red   = stops[i].color.red_short;
 145         pixman_stops[i].color.green = stops[i].color.green_short;
 146         pixman_stops[i].color.blue  = stops[i].color.blue_short;
 147         pixman_stops[i].color.alpha = stops[i].color.alpha_short;
 148     }
 149
 150     p1.x = _cairo_fixed_16_16_from_double (0.5);
 151     p1.y = 0;
 152     p2.x = _cairo_fixed_16_16_from_double (width - 0.5);
 153     p2.y = 0;
 154
 155     gradient = pixman_image_create_linear_gradient (&p1, &p2,
 156                                                     pixman_stops,
 157                                                     n_stops);
 158     if (pixman_stops != pixman_stops_stack)
 159         free (pixman_stops);
 160
 161     if (unlikely (gradient == NULL))
 162         return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 163
 164     pixman_image_set_filter (gradient, PIXMAN_FILTER_BILINEAR, NULL, 0);
 165     pixman_image_set_repeat (gradient, PIXMAN_REPEAT_PAD);
 166
 167     image = pixman_image_create_bits (gradient_pixman_format, width, 1,
 168                                       bytes, sizeof(uint32_t)*width);
 169     if (unlikely (image == NULL)) {
 170         pixman_image_unref (gradient);
 171         return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 172     }
 173
 174     pixman_image_composite32 (PIXMAN_OP_SRC,
 175                               gradient, NULL, image,
 176                               0, 0,
 177                               0, 0,
 178                               0, 0,
 179                               width, 1);
 180
 181     pixman_image_unref (gradient);
 182     pixman_image_unref (image);
 183
 184     /* We need to fudge pixel 0 to hold the left-most color stop and not
 185      * the neareset stop to the zeroth pixel centre in order to correctly
 186      * populate the border color. For completeness, do both edges.
 187      */
 188
 189     /* This not needed as we have generated pixman pixels by using the
 190      * half pixel from left and right border
 191      */
 192     /* ((uint32_t*)bytes)[0] = color_stop_to_pixel(&stops[0]);
 193      * ((uint32_t*)bytes)[width-1] = color_stop_to_pixel(&stops[n_stops-1]);
 194      */
 195
 196     return CAIRO_STATUS_SUCCESS;
 197 }
 198
 199 static unsigned long
 200 _cairo_gl_gradient_hash (unsigned int                  n_stops,
 201                          const cairo_gradient_stop_t  *stops)
 202 {
 203     return _cairo_hash_bytes (n_stops,
 204                               stops,
 205                               sizeof (cairo_gradient_stop_t) * n_stops);
 206 }
 207
 208 static cairo_gl_gradient_t *
 209 _cairo_gl_gradient_lookup (cairo_gl_context_t           *ctx,
 210                            unsigned long                 hash,
 211                            unsigned int                  n_stops,
 212                            const cairo_gradient_stop_t  *stops)
 213 {
 214     cairo_gl_gradient_t lookup;
 215
 216     lookup.cache_entry.hash = hash,
 217     lookup.n_stops = n_stops;
 218     lookup.stops = stops;
 219
 220     return _cairo_cache_lookup (&ctx->gradients, &lookup.cache_entry);
 221 }
 222
 223 cairo_bool_t
 224 _cairo_gl_gradient_equal (const void *key_a, const void *key_b)
 225 {
 226     const cairo_gl_gradient_t *a = key_a;
 227     const cairo_gl_gradient_t *b = key_b;
 228
 229     if (a->n_stops != b->n_stops)
 230         return FALSE;
 231
 232     return memcmp (a->stops, b->stops, a->n_stops * sizeof (cairo_gradient_stop_t)) == 0;
 233 }
 234
 235 cairo_int_status_t
 236 _cairo_gl_gradient_create (cairo_gl_context_t           *ctx,
 237                            unsigned int                  n_stops,
 238                            const cairo_gradient_stop_t  *stops,
 239                            cairo_gl_gradient_t         **gradient_out)
 240 {
 241     unsigned long hash;
 242     cairo_gl_gradient_t *gradient;
 243     cairo_status_t status;
 244     int tex_width;
 245     GLint internal_format;
 246     void *data;
 247
 248     if ((unsigned int) ctx->max_texture_size / 2 <= n_stops)
 249         return CAIRO_INT_STATUS_UNSUPPORTED;
 250
 251     hash = _cairo_gl_gradient_hash (n_stops, stops);
 252
 253     gradient = _cairo_gl_gradient_lookup (ctx, hash, n_stops, stops);
 254     if (gradient) {
 255         *gradient_out = _cairo_gl_gradient_reference (gradient);
 256         return CAIRO_STATUS_SUCCESS;
 257     }
 258
 259     gradient = malloc (sizeof (cairo_gl_gradient_t) + sizeof (cairo_gradient_stop_t) * (n_stops - 1));
 260     if (gradient == NULL)
 261         return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 262
 263     tex_width = _cairo_gl_gradient_sample_width (n_stops, stops);
 264     if (tex_width > ctx->max_texture_size)
 265         tex_width = ctx->max_texture_size;
 266
 267     CAIRO_REFERENCE_COUNT_INIT (&gradient->ref_count, 2);
 268     gradient->cache_entry.hash = hash;
 269     gradient->cache_entry.size = tex_width;
 270     gradient->device = &ctx->base;
 271     gradient->n_stops = n_stops;
 272     gradient->stops = gradient->stops_embedded;
 273     memcpy (gradient->stops_embedded, stops, n_stops * sizeof (cairo_gradient_stop_t));
 274
 275     if (n_stops != 2) {
 276         ctx->dispatch.GenTextures (1, &gradient->tex);
 277         _cairo_gl_context_activate (ctx, CAIRO_GL_TEX_TEMP);
 278         ctx->dispatch.BindTexture (ctx->tex_target, gradient->tex);
 279
 280         data = _cairo_malloc_ab (tex_width, sizeof (uint32_t));
 281         if (unlikely (data == NULL)) {
 282             status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
 283             goto cleanup_gradient;
 284         }
 285
 286         status = _cairo_gl_gradient_render (ctx, n_stops, stops, data, tex_width);
 287         if (unlikely (status))
 288             goto cleanup_data;
 289
 290         /*
 291          * In OpenGL ES 2.0 no format conversion is allowed i.e. 'internalFormat'
 292          * must match 'format' in glTexImage2D.
 293          */
 294         if (_cairo_gl_get_flavor (&ctx->dispatch) == CAIRO_GL_FLAVOR_ES2 ||
 295             _cairo_gl_get_flavor (&ctx->dispatch) == CAIRO_GL_FLAVOR_ES3)
 296             internal_format = GL_BGRA;
 297         else
 298             internal_format = GL_RGBA;
 299
 300         ctx->dispatch.TexImage2D (ctx->tex_target, 0, internal_format,
 301                                   tex_width, 1, 0,
 302                                   GL_BGRA, GL_UNSIGNED_BYTE, data);
 303
 304         free (data);
 305     }
 306
 307     /* we ignore errors here and just return an uncached gradient */
 308     if (unlikely (_cairo_cache_insert (&ctx->gradients, &gradient->cache_entry)))
 309         CAIRO_REFERENCE_COUNT_INIT (&gradient->ref_count, 1);
 310
 311     *gradient_out = gradient;
 312     return CAIRO_STATUS_SUCCESS;
 313
 314 cleanup_data:
 315     free (data);
 316 cleanup_gradient:
 317     free (gradient);
 318     return status;
 319 }
 320
 321 cairo_gl_gradient_t *
 322 _cairo_gl_gradient_reference (cairo_gl_gradient_t *gradient)
 323 {
 324     assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&gradient->ref_count));
 325
 326     _cairo_reference_count_inc (&gradient->ref_count);
 327
 328     return gradient;
 329 }
 330
 331 void
 332 _cairo_gl_gradient_destroy (cairo_gl_gradient_t *gradient)
 333 {
 334     cairo_gl_context_t *ctx;
 335     cairo_status_t ignore;
 336
 337     assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&gradient->ref_count));
 338
 339     if (! _cairo_reference_count_dec_and_test (&gradient->ref_count))
 340         return;
 341
 342     if (_cairo_gl_context_acquire (gradient->device, &ctx) == CAIRO_STATUS_SUCCESS) {
 343         /* The gradient my still be active in the last operation, so flush */
 344         _cairo_gl_composite_flush (ctx);
 345         ctx->dispatch.DeleteTextures (1, &gradient->tex);
 346         ignore = _cairo_gl_context_release (ctx, CAIRO_STATUS_SUCCESS);
 347     }
 348
 349     free (gradient);
 350 }