lib/art/art_render_gradient.c

   1 /*
   2  * art_render_gradient.c: Gradient image source for modular rendering.
   3  *
   4  * Libart_LGPL - library of basic graphic primitives
   5  * Copyright (C) 2000 Raph Levien
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * Authors: Raph Levien <raph@acm.org>
  23  *          Alexander Larsson <alla@lysator.liu.se>
  24  */
  25
  26 #include "config.h"
  27 #include "art_render_gradient.h"
  28
  29 #include <math.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <assert.h>
  34
  35 /* Hack to find out how to define alloca on different platforms.
  36  * Modified version of glib/galloca.h.
  37  */
  38
  39 #ifdef  __GNUC__
  40 /* GCC does the right thing */
  41 # undef alloca
  42 # define alloca(size)   __builtin_alloca (size)
  43 #elif defined (HAVE_ALLOCA_H)
  44 /* a native and working alloca.h is there */
  45 # include <alloca.h>
  46 #else /* !__GNUC__ && !HAVE_ALLOCA_H */
  47 # ifdef _MSC_VER
  48 #  include <malloc.h>
  49 #  define alloca _alloca
  50 # else /* !_MSC_VER */
  51 #  ifdef _AIX
  52  #pragma alloca
  53 #  else /* !_AIX */
  54 #   ifndef alloca /* predefined by HP cc +Olibcalls */
  55 char *alloca ();
  56 #   endif /* !alloca */
  57 #  endif /* !_AIX */
  58 # endif /* !_MSC_VER */
  59 #endif /* !__GNUC__ && !HAVE_ALLOCA_H */
  60
  61 #undef DEBUG_SPEW
  62
  63 typedef struct _ArtImageSourceGradLin ArtImageSourceGradLin;
  64 typedef struct _ArtImageSourceGradRad ArtImageSourceGradRad;
  65
  66 /* The stops will be copied right after this structure */
  67 struct _ArtImageSourceGradLin {
  68   ArtImageSource super;
  69   ArtGradientLinear gradient;
  70   ArtGradientStop stops[1];
  71 };
  72
  73 /* The stops will be copied right after this structure */
  74 struct _ArtImageSourceGradRad {
  75   ArtImageSource super;
  76   ArtGradientRadial gradient;
  77   double a;
  78   ArtGradientStop stops[1];
  79 };
  80
  81 #define EPSILON 1e-6
  82
  83 #ifndef MAX
  84 #define MAX(a, b)  (((a) > (b)) ? (a) : (b))
  85 #endif /* MAX */
  86
  87 #ifndef MIN
  88 #define MIN(a, b)  (((a) < (b)) ? (a) : (b))
  89 #endif /* MIN */
  90
  91 static void
  92 art_rgba_gradient_run (art_u8 *buf,
  93                        art_u8 *color1,
  94                        art_u8 *color2,
  95                        int len)
  96 {
  97   int i;
  98   int r, g, b, a;
  99   int dr, dg, db, da;
 100
 101 #ifdef DEBUG_SPEW
 102   printf ("gradient run from %3d %3d %3d %3d to %3d %3d %3d %3d in %d pixels\n",
 103           color1[0], color1[1], color1[2], color1[3],
 104           color2[0], color2[1], color2[2], color2[3],
 105           len);
 106 #endif
 107
 108   r = (color1[0] << 16) + 0x8000;
 109   g = (color1[1] << 16) + 0x8000;
 110   b = (color1[2] << 16) + 0x8000;
 111   a = (color1[3] << 16) + 0x8000;
 112   dr = ((color2[0] - color1[0]) << 16) / len;
 113   dg = ((color2[1] - color1[1]) << 16) / len;
 114   db = ((color2[2] - color1[2]) << 16) / len;
 115   da = ((color2[3] - color1[3]) << 16) / len;
 116
 117   for (i = 0; i < len; i++)
 118     {
 119       *buf++ = (r>>16);
 120       *buf++ = (g>>16);
 121       *buf++ = (b>>16);
 122       *buf++ = (a>>16);
 123
 124       r += dr;
 125       g += dg;
 126       b += db;
 127       a += da;
 128     }
 129 }
 130
 131 static void
 132 calc_color_at (ArtGradientStop *stops,
 133                int n_stops,
 134                ArtGradientSpread spread,
 135                double offset,
 136                double offset_fraction,
 137                int favor_start,
 138                int ix,
 139                art_u8 *color)
 140 {
 141   double off0, off1;
 142   int j;
 143
 144   if (spread == ART_GRADIENT_PAD)
 145     {
 146       if (offset < 0.0)
 147         {
 148           color[0] = ART_PIX_8_FROM_MAX (stops[0].color[0]);
 149           color[1] = ART_PIX_8_FROM_MAX (stops[0].color[1]);
 150           color[2] = ART_PIX_8_FROM_MAX (stops[0].color[2]);
 151           color[3] = ART_PIX_8_FROM_MAX (stops[0].color[3]);
 152           return;
 153         }
 154       if (offset >= 1.0)
 155         {
 156           color[0] = ART_PIX_8_FROM_MAX (stops[n_stops-1].color[0]);
 157           color[1] = ART_PIX_8_FROM_MAX (stops[n_stops-1].color[1]);
 158           color[2] = ART_PIX_8_FROM_MAX (stops[n_stops-1].color[2]);
 159           color[3] = ART_PIX_8_FROM_MAX (stops[n_stops-1].color[3]);
 160           return;
 161         }
 162     }
 163
 164   if (ix > 0 && ix < n_stops)
 165     {
 166       off0 = stops[ix - 1].offset;
 167       off1 = stops[ix].offset;
 168       if (fabs (off1 - off0) > EPSILON)
 169         {
 170           double interp;
 171           double o;
 172           o = offset_fraction;
 173
 174           if ((fabs (o) < EPSILON) && (!favor_start))
 175             o = 1.0;
 176           else if ((fabs (o-1.0) < EPSILON) && (favor_start))
 177             o = 0.0;
 178
 179           /*
 180           if (offset_fraction == 0.0  && !favor_start)
 181             offset_fraction = 1.0;
 182           */
 183
 184           interp = (o - off0) / (off1 - off0);
 185           for (j = 0; j < 4; j++)
 186             {
 187               int z0, z1;
 188               int z;
 189               z0 = stops[ix - 1].color[j];
 190               z1 = stops[ix].color[j];
 191               z = floor (z0 + (z1 - z0) * interp + 0.5);
 192               color[j] = ART_PIX_8_FROM_MAX (z);
 193             }
 194           return;
 195         }
 196       /* If offsets are too close to safely do the division, just
 197          pick the ix color. */
 198       color[0] = ART_PIX_8_FROM_MAX (stops[ix].color[0]);
 199       color[1] = ART_PIX_8_FROM_MAX (stops[ix].color[1]);
 200       color[2] = ART_PIX_8_FROM_MAX (stops[ix].color[2]);
 201       color[3] = ART_PIX_8_FROM_MAX (stops[ix].color[3]);
 202       return;
 203     }
 204
 205   printf ("WARNING! bad ix %d in calc_color_at() [internal error]\n", ix);
 206   assert (0);
 207 }
 208
 209 static void
 210 art_render_gradient_linear_render_8 (ArtRenderCallback *self,
 211                                      ArtRender *render,
 212                                      art_u8 *dest, int y)
 213 {
 214   ArtImageSourceGradLin *z = (ArtImageSourceGradLin *)self;
 215   const ArtGradientLinear *gradient = &(z->gradient);
 216   int i;
 217   int width = render->x1 - render->x0;
 218   int len;
 219   double offset, d_offset;
 220   double offset_fraction;
 221   int next_stop;
 222   int ix;
 223   art_u8 color1[4], color2[4];
 224   int n_stops = gradient->n_stops;
 225   int extra_stops;
 226   ArtGradientStop *stops = gradient->stops;
 227   ArtGradientStop *tmp_stops;
 228   art_u8 *bufp = render->image_buf;
 229   ArtGradientSpread spread = gradient->spread;
 230
 231 #ifdef DEBUG_SPEW
 232   printf ("x1: %d, x2: %d, y: %d\n", render->x0, render->x1, y);
 233   printf ("spread: %d, stops:", gradient->spread);
 234   for (i=0;i<n_stops;i++)
 235     {
 236       printf ("%f, ", gradient->stops[i].offset);
 237     }
 238   printf ("\n");
 239   printf ("a: %f, b: %f, c: %f\n", gradient->a, gradient->b, gradient->c);
 240 #endif
 241
 242   offset = render->x0 * gradient->a + y * gradient->b + gradient->c;
 243   d_offset = gradient->a;
 244
 245   /* We need to force the gradient to extend the whole 0..1 segment,
 246      because the rest of the code doesn't handle partial gradients
 247      correctly */
 248   if ((gradient->stops[0].offset > EPSILON /* == 0.0 */) ||
 249       (gradient->stops[n_stops-1].offset < (1.0 - EPSILON)))
 250   {
 251     extra_stops = 0;
 252     tmp_stops = stops = (ArtGradientStop*)alloca (sizeof (ArtGradientStop) * (n_stops + 2));
 253     if (gradient->stops[0].offset > EPSILON /* 0.0 */)
 254       {
 255         memcpy (tmp_stops, gradient->stops, sizeof (ArtGradientStop));
 256         tmp_stops[0].offset = 0.0;
 257         tmp_stops += 1;
 258         extra_stops++;
 259       }
 260     memcpy (tmp_stops, gradient->stops, sizeof (ArtGradientStop) * n_stops);
 261     if (gradient->stops[n_stops-1].offset < (1.0 - EPSILON))
 262       {
 263         tmp_stops += n_stops;
 264         memcpy (tmp_stops, &gradient->stops[n_stops-1], sizeof (ArtGradientStop));
 265         tmp_stops[0].offset = 1.0;
 266         extra_stops++;
 267       }
 268     n_stops += extra_stops;
 269
 270
 271 #ifdef DEBUG_SPEW
 272     printf ("start/stop modified stops:");
 273     for (i=0;i<n_stops;i++)
 274       {
 275         printf ("%f, ", stops[i].offset);
 276       }
 277     printf ("\n");
 278 #endif
 279
 280   }
 281
 282   if (spread == ART_GRADIENT_REFLECT)
 283     {
 284       tmp_stops = stops;
 285       stops = (ArtGradientStop*)alloca (sizeof (ArtGradientStop) * n_stops * 2);
 286       memcpy (stops, tmp_stops, sizeof (ArtGradientStop) * n_stops);
 287
 288       for (i = 0; i< n_stops; i++)
 289         {
 290           stops[n_stops * 2 - 1 - i].offset = (1.0 - stops[i].offset / 2.0);
 291           memcpy (stops[n_stops * 2 - 1 - i].color, stops[i].color, sizeof (stops[i].color));
 292           stops[i].offset = stops[i].offset / 2.0;
 293         }
 294
 295       spread = ART_GRADIENT_REPEAT;
 296       offset = offset / 2.0;
 297       d_offset = d_offset / 2.0;
 298
 299       n_stops = 2 * n_stops;
 300
 301 #ifdef DEBUG_SPEW
 302       printf ("reflect modified stops:");
 303       for (i=0;i<n_stops;i++)
 304         {
 305           printf ("%f, ", stops[i].offset);
 306         }
 307       printf ("\n");
 308 #endif
 309     }
 310
 311   offset_fraction = offset - floor (offset);
 312 #ifdef DEBUG_SPEW
 313   printf ("inital offset: %f, fraction: %f d_offset: %f\n", offset, offset_fraction, d_offset);
 314 #endif
 315   /* ix is selected so that offset_fraction is
 316      stops[ix-1] <= offset_fraction <= stops[ix]
 317      If offset_fraction is equal to one of the edges, ix
 318      is selected so the the section of the line extending
 319      in the same direction as d_offset is between ix-1 and ix.
 320   */
 321   for (ix = 0; ix < n_stops; ix++)
 322     if (stops[ix].offset > offset_fraction ||
 323         (d_offset < 0.0 && fabs (stops[ix].offset - offset_fraction) < EPSILON))
 324       break;
 325   if (ix == 0)
 326     ix = n_stops - 1;
 327   else if (ix == n_stops)
 328     ix = n_stops - 1;
 329
 330 #ifdef DEBUG_SPEW
 331   printf ("Initial ix: %d\n", ix);
 332 #endif
 333
 334   assert (ix > 0);
 335   assert (ix < n_stops);
 336   assert ((stops[ix-1].offset <= offset_fraction + EPSILON) ||
 337           ((stops[ix].offset > (1.0 - EPSILON)) && (offset_fraction < EPSILON /* == 0.0*/)));
 338   assert (offset_fraction <= stops[ix].offset);
 339   /* FIXME: These asserts may be broken, it is for now
 340      safer to not use them.  Should be fixed!
 341      See bug #121850
 342   assert ((offset_fraction != stops[ix-1].offset) ||
 343           (d_offset >= 0.0));
 344   assert ((offset_fraction != stops[ix].offset) ||
 345           (d_offset <= 0.0));
 346   */
 347
 348   while (width > 0)
 349     {
 350 #ifdef DEBUG_SPEW
 351       printf ("ix: %d\n", ix);
 352       printf ("start offset: %f\n", offset);
 353 #endif
 354       calc_color_at (stops, n_stops,
 355                      spread,
 356                      offset,
 357                      offset_fraction,
 358                      (d_offset > -EPSILON),
 359                      ix,
 360                      color1);
 361
 362       if (d_offset > 0)
 363         next_stop = ix;
 364       else
 365         next_stop = ix-1;
 366
 367 #ifdef DEBUG_SPEW
 368       printf ("next_stop: %d\n", next_stop);
 369 #endif
 370       if (fabs (d_offset) > EPSILON)
 371         {
 372           double o;
 373           o = offset_fraction;
 374
 375           if ((fabs (o) <= EPSILON) && (ix == n_stops - 1))
 376             o = 1.0;
 377           else if ((fabs (o-1.0) <= EPSILON) && (ix == 1))
 378             o = 0.0;
 379
 380 #ifdef DEBUG_SPEW
 381           printf ("o: %f\n", o);
 382 #endif
 383           len = (int)floor (fabs ((stops[next_stop].offset - o) / d_offset)) + 1;
 384           len = MAX (len, 0);
 385           len = MIN (len, width);
 386         }
 387       else
 388         {
 389           len = width;
 390         }
 391 #ifdef DEBUG_SPEW
 392       printf ("len: %d\n", len);
 393 #endif
 394       if (len > 0)
 395         {
 396           offset = offset + (len-1) * d_offset;
 397           offset_fraction = offset - floor (offset);
 398 #ifdef DEBUG_SPEW
 399           printf ("end offset: %f, fraction: %f\n", offset, offset_fraction);
 400 #endif
 401           calc_color_at (stops, n_stops,
 402                          spread,
 403                          offset,
 404                          offset_fraction,
 405                          (d_offset < EPSILON),
 406                          ix,
 407                          color2);
 408
 409           art_rgba_gradient_run (bufp,
 410                                  color1,
 411                                  color2,
 412                                  len);
 413           offset += d_offset;
 414           offset_fraction = offset - floor (offset);
 415         }
 416
 417       if (d_offset > 0)
 418         {
 419           do
 420             {
 421               ix++;
 422               if (ix == n_stops)
 423                 ix = 1;
 424               /* Note: offset_fraction can actually be one here on x86 machines that
 425                  does calculations with extended precision, but later rounds to 64bit.
 426                  This happens if the 80bit offset_fraction is larger than the
 427                  largest 64bit double that is less than one.
 428               */
 429             }
 430           while (!((stops[ix-1].offset <= offset_fraction &&
 431                    offset_fraction < stops[ix].offset) ||
 432                    (ix == 1 && offset_fraction > (1.0 - EPSILON))));
 433         }
 434       else
 435         {
 436           do
 437             {
 438               ix--;
 439               if (ix == 0)
 440                 ix = n_stops - 1;
 441             }
 442           while (!((stops[ix-1].offset < offset_fraction &&
 443                     offset_fraction <= stops[ix].offset) ||
 444                    (ix == n_stops - 1 && offset_fraction < EPSILON /* == 0.0*/)));
 445         }
 446
 447       bufp += 4*len;
 448       width -= len;
 449     }
 450 }
 451
 452
 453 /**
 454  * art_render_gradient_setpix: Set a gradient pixel.
 455  * @render: The render object.
 456  * @dst: Pointer to destination (where to store pixel).
 457  * @n_stops: Number of stops in @stops.
 458  * @stops: The stops for the gradient.
 459  * @offset: The offset.
 460  *
 461  * @n_stops must be > 0.
 462  *
 463  * Sets a gradient pixel, storing it at @dst.
 464  **/
 465 static void
 466 art_render_gradient_setpix (ArtRender *render,
 467                             art_u8 *dst,
 468                             int n_stops, ArtGradientStop *stops,
 469                             double offset)
 470 {
 471   int ix;
 472   int j;
 473   double off0, off1;
 474   int n_ch = render->n_chan + 1;
 475
 476   for (ix = 0; ix < n_stops; ix++)
 477     if (stops[ix].offset > offset)
 478       break;
 479   /* stops[ix - 1].offset < offset < stops[ix].offset */
 480   if (ix > 0 && ix < n_stops)
 481     {
 482       off0 = stops[ix - 1].offset;
 483       off1 = stops[ix].offset;
 484       if (fabs (off1 - off0) > EPSILON)
 485         {
 486           double interp;
 487
 488           interp = (offset - off0) / (off1 - off0);
 489           for (j = 0; j < n_ch; j++)
 490             {
 491               int z0, z1;
 492               int z;
 493               z0 = stops[ix - 1].color[j];
 494               z1 = stops[ix].color[j];
 495               z = floor (z0 + (z1 - z0) * interp + 0.5);
 496               if (render->buf_depth == 8)
 497                 dst[j] = ART_PIX_8_FROM_MAX (z);
 498               else /* (render->buf_depth == 16) */
 499                 ((art_u16 *)dst)[j] = z;
 500             }
 501           return;
 502         }
 503     }
 504   else if (ix == n_stops)
 505     ix--;
 506
 507   for (j = 0; j < n_ch; j++)
 508     {
 509       int z;
 510       z = stops[ix].color[j];
 511       if (render->buf_depth == 8)
 512         dst[j] = ART_PIX_8_FROM_MAX (z);
 513       else /* (render->buf_depth == 16) */
 514         ((art_u16 *)dst)[j] = z;
 515     }
 516 }
 517
 518 static void
 519 art_render_gradient_linear_done (ArtRenderCallback *self, ArtRender *render)
 520 {
 521   art_free (self);
 522 }
 523
 524 static void
 525 art_render_gradient_linear_render (ArtRenderCallback *self, ArtRender *render,
 526                                    art_u8 *dest, int y)
 527 {
 528   ArtImageSourceGradLin *z = (ArtImageSourceGradLin *)self;
 529   const ArtGradientLinear *gradient = &(z->gradient);
 530   int pixstride = (render->n_chan + 1) * (render->depth >> 3);
 531   int x;
 532   int width = render->x1 - render->x0;
 533   double offset, d_offset;
 534   double actual_offset;
 535   int n_stops = gradient->n_stops;
 536   ArtGradientStop *stops = gradient->stops;
 537   art_u8 *bufp = render->image_buf;
 538   ArtGradientSpread spread = gradient->spread;
 539
 540   offset = render->x0 * gradient->a + y * gradient->b + gradient->c;
 541   d_offset = gradient->a;
 542
 543   for (x = 0; x < width; x++)
 544     {
 545       if (spread == ART_GRADIENT_PAD)
 546         actual_offset = offset;
 547       else if (spread == ART_GRADIENT_REPEAT)
 548         actual_offset = offset - floor (offset);
 549       else /* (spread == ART_GRADIENT_REFLECT) */
 550         {
 551           double tmp;
 552
 553           tmp = offset - 2 * floor (0.5 * offset);
 554           actual_offset = tmp > 1 ? 2 - tmp : tmp;
 555         }
 556       art_render_gradient_setpix (render, bufp, n_stops, stops, actual_offset);
 557       offset += d_offset;
 558       bufp += pixstride;
 559     }
 560 }
 561
 562 static void
 563 art_render_gradient_linear_negotiate (ArtImageSource *self, ArtRender *render,
 564                                       int *p_flags,
 565                                       int *p_buf_depth, ArtAlphaType *p_alpha)
 566 {
 567   if (render->depth == 8 &&
 568       render->n_chan == 3)
 569     {
 570       self->super.render = art_render_gradient_linear_render_8;
 571       *p_flags = 0;
 572       *p_buf_depth = 8;
 573       *p_alpha = ART_ALPHA_PREMUL;
 574       return;
 575     }
 576
 577   self->super.render = art_render_gradient_linear_render;
 578   *p_flags = 0;
 579   *p_buf_depth = render->depth;
 580   *p_alpha = ART_ALPHA_PREMUL;
 581 }
 582
 583 /**
 584  * art_render_gradient_linear: Add a linear gradient image source.
 585  * @render: The render object.
 586  * @gradient: The linear gradient.
 587  *
 588  * Adds the linear gradient @gradient as the image source for rendering
 589  * in the render object @render.
 590  **/
 591 void
 592 art_render_gradient_linear (ArtRender *render,
 593                             const ArtGradientLinear *gradient,
 594                             ArtFilterLevel level)
 595 {
 596   ArtImageSourceGradLin *image_source = (ArtImageSourceGradLin*)art_alloc (sizeof (ArtImageSourceGradLin) +
 597                                                    sizeof (ArtGradientStop) * (gradient->n_stops - 1));
 598
 599   image_source->super.super.render = NULL;
 600   image_source->super.super.done = art_render_gradient_linear_done;
 601   image_source->super.negotiate = art_render_gradient_linear_negotiate;
 602
 603   /* copy the gradient into the structure */
 604   image_source->gradient = *gradient;
 605   image_source->gradient.stops = image_source->stops;
 606   memcpy (image_source->gradient.stops, gradient->stops, sizeof (ArtGradientStop) * gradient->n_stops);
 607
 608   art_render_add_image_source (render, &image_source->super);
 609 }
 610
 611 static void
 612 art_render_gradient_radial_done (ArtRenderCallback *self, ArtRender *render)
 613 {
 614   art_free (self);
 615 }
 616
 617 static void
 618 art_render_gradient_radial_render (ArtRenderCallback *self, ArtRender *render,
 619                                    art_u8 *dest, int y)
 620 {
 621   ArtImageSourceGradRad *z = (ArtImageSourceGradRad *)self;
 622   const ArtGradientRadial *gradient = &(z->gradient);
 623   int pixstride = (render->n_chan + 1) * (render->depth >> 3);
 624   int x;
 625   int x0 = render->x0;
 626   int width = render->x1 - x0;
 627   int n_stops = gradient->n_stops;
 628   ArtGradientStop *stops = gradient->stops;
 629   art_u8 *bufp = render->image_buf;
 630   double fx = gradient->fx;
 631   double fy = gradient->fy;
 632   double dx, dy;
 633   double *affine = (double*)&gradient->affine[0];
 634   double aff0 = affine[0];
 635   double aff1 = affine[1];
 636   const double a = z->a;
 637   const double arecip = 1.0 / a;
 638   double b, db;
 639   double c, dc, ddc;
 640   double b_a, db_a;
 641   double rad, drad, ddrad;
 642
 643   dx = x0 * aff0 + y * affine[2] + affine[4] - fx;
 644   dy = x0 * aff1 + y * affine[3] + affine[5] - fy;
 645   b = dx * fx + dy * fy;
 646   db = aff0 * fx + aff1 * fy;
 647   c = dx * dx + dy * dy;
 648   dc = 2 * aff0 * dx + aff0 * aff0 + 2 * aff1 * dy + aff1 * aff1;
 649   ddc = 2 * aff0 * aff0 + 2 * aff1 * aff1;
 650
 651   b_a = b * arecip;
 652   db_a = db * arecip;
 653
 654   rad = b_a * b_a + c * arecip;
 655   drad = 2 * b_a * db_a + db_a * db_a + dc * arecip;
 656   ddrad = 2 * db_a * db_a + ddc * arecip;
 657
 658   for (x = 0; x < width; x++)
 659     {
 660       double z;
 661
 662       if (rad > 0)
 663         z = b_a + sqrt (rad);
 664       else
 665         z = b_a;
 666       art_render_gradient_setpix (render, bufp, n_stops, stops, z);
 667       bufp += pixstride;
 668       b_a += db_a;
 669       rad += drad;
 670       drad += ddrad;
 671     }
 672 }
 673
 674 static void
 675 art_render_gradient_radial_negotiate (ArtImageSource *self, ArtRender *render,
 676                                       int *p_flags,
 677                                       int *p_buf_depth, ArtAlphaType *p_alpha)
 678 {
 679   self->super.render = art_render_gradient_radial_render;
 680   *p_flags = 0;
 681   *p_buf_depth = render->depth;
 682   *p_alpha = ART_ALPHA_PREMUL;
 683 }
 684
 685 /**
 686  * art_render_gradient_radial: Add a radial gradient image source.
 687  * @render: The render object.
 688  * @gradient: The radial gradient.
 689  *
 690  * Adds the radial gradient @gradient as the image source for rendering
 691  * in the render object @render.
 692  **/
 693 void
 694 art_render_gradient_radial (ArtRender *render,
 695                             const ArtGradientRadial *gradient,
 696                             ArtFilterLevel level)
 697 {
 698   ArtImageSourceGradRad *image_source = (ArtImageSourceGradRad*)art_alloc (sizeof (ArtImageSourceGradRad) +
 699                                                    sizeof (ArtGradientStop) * (gradient->n_stops - 1));
 700   double fx = gradient->fx;
 701   double fy = gradient->fy;
 702
 703   image_source->super.super.render = NULL;
 704   image_source->super.super.done = art_render_gradient_radial_done;
 705   image_source->super.negotiate = art_render_gradient_radial_negotiate;
 706
 707   /* copy the gradient into the structure */
 708   image_source->gradient = *gradient;
 709   image_source->gradient.stops = image_source->stops;
 710   memcpy (image_source->gradient.stops, gradient->stops, sizeof (ArtGradientStop) * gradient->n_stops);
 711
 712   /* todo: sanitycheck fx, fy? */
 713   image_source->a = 1 - fx * fx - fy * fy;
 714
 715   art_render_add_image_source (render, &image_source->super);
 716 }