libraries/libart_lgpl-2.3.7/art_render.c

   1 /*
   2  * art_render.c: Modular rendering architecture.
   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
  23 #include "art_misc.h"
  24 #include "art_alphagamma.h"
  25 #include "art_rgb.h"
  26
  27 #include "art_render.h"
  28
  29 typedef struct _ArtRenderPriv ArtRenderPriv;
  30
  31 struct _ArtRenderPriv {
  32   ArtRender super;
  33
  34   ArtImageSource *image_source;
  35
  36   int n_mask_source;
  37   ArtMaskSource **mask_source;
  38
  39   int n_callbacks;
  40   ArtRenderCallback **callbacks;
  41 };
  42
  43 ArtRender *
  44 art_render_new (int x0, int y0, int x1, int y1,
  45                 art_u8 *pixels, int rowstride,
  46                 int n_chan, int depth, ArtAlphaType alpha_type,
  47                 ArtAlphaGamma *alphagamma)
  48 {
  49   ArtRenderPriv *priv;
  50   ArtRender *result;
  51
  52   priv = art_new (ArtRenderPriv, 1);
  53   result = &priv->super;
  54
  55   if (n_chan > ART_MAX_CHAN)
  56     {
  57       art_warn ("art_render_new: n_chan = %d, exceeds %d max\n",
  58                 n_chan, ART_MAX_CHAN);
  59       return NULL;
  60     }
  61   if (depth > ART_MAX_DEPTH)
  62     {
  63       art_warn ("art_render_new: depth = %d, exceeds %d max\n",
  64                 depth, ART_MAX_DEPTH);
  65       return NULL;
  66     }
  67   if (x0 >= x1)
  68     {
  69       art_warn ("art_render_new: x0 >= x1 (x0 = %d, x1 = %d)\n", x0, x1);
  70       return NULL;
  71     }
  72   result->x0 = x0;
  73   result->y0 = y0;
  74   result->x1 = x1;
  75   result->y1 = y1;
  76   result->pixels = pixels;
  77   result->rowstride = rowstride;
  78   result->n_chan = n_chan;
  79   result->depth = depth;
  80   result->alpha_type = alpha_type;
  81
  82   result->clear = ART_FALSE;
  83   result->opacity = 0x10000;
  84   result->compositing_mode = ART_COMPOSITE_NORMAL;
  85   result->alphagamma = alphagamma;
  86
  87   result->alpha_buf = NULL;
  88   result->image_buf = NULL;
  89
  90   result->run = NULL;
  91   result->span_x = NULL;
  92
  93   result->need_span = ART_FALSE;
  94
  95   priv->image_source = NULL;
  96
  97   priv->n_mask_source = 0;
  98   priv->mask_source = NULL;
  99
 100   return result;
 101 }
 102
 103 /* todo on clear routines: I haven't really figured out what to do
 104    with clearing the alpha channel. It _should_ be possible to clear
 105    to an arbitrary RGBA color. */
 106
 107 /**
 108  * art_render_clear: Set clear color.
 109  * @clear_color: Color with which to clear dest.
 110  *
 111  * Sets clear color, equivalent to actually clearing the destination
 112  * buffer before rendering. This is the most general form.
 113  **/
 114 void
 115 art_render_clear (ArtRender *render, const ArtPixMaxDepth *clear_color)
 116 {
 117   int i;
 118   int n_ch = render->n_chan + (render->alpha_type != ART_ALPHA_NONE);
 119
 120   render->clear = ART_TRUE;
 121   for (i = 0; i < n_ch; i++)
 122     render->clear_color[i] = clear_color[i];
 123 }
 124
 125 /**
 126  * art_render_clear_rgb: Set clear color, given in RGB format.
 127  * @clear_rgb: Clear color, in 0xRRGGBB format.
 128  *
 129  * Sets clear color, equivalent to actually clearing the destination
 130  * buffer before rendering.
 131  **/
 132 void
 133 art_render_clear_rgb (ArtRender *render, art_u32 clear_rgb)
 134 {
 135   if (render->n_chan != 3)
 136     art_warn ("art_render_clear_rgb: called on render with %d channels, only works with 3\n",
 137               render->n_chan);
 138   else
 139     {
 140       int r, g, b;
 141
 142       render->clear = ART_TRUE;
 143       r = clear_rgb >> 16;
 144       g = (clear_rgb >> 8) & 0xff;
 145       b = clear_rgb & 0xff;
 146       render->clear_color[0] = ART_PIX_MAX_FROM_8(r);
 147       render->clear_color[1] = ART_PIX_MAX_FROM_8(g);
 148       render->clear_color[2] = ART_PIX_MAX_FROM_8(b);
 149     }
 150 }
 151
 152 static void
 153 art_render_nop_done (ArtRenderCallback *self, ArtRender *render)
 154 {
 155 }
 156
 157 static void
 158 art_render_clear_render_rgb8 (ArtRenderCallback *self, ArtRender *render,
 159                               art_u8 *dest, int y)
 160 {
 161   int width = render->x1 - render->x0;
 162   art_u8 r, g, b;
 163   ArtPixMaxDepth color_max;
 164
 165   color_max = render->clear_color[0];
 166   r = ART_PIX_8_FROM_MAX (color_max);
 167   color_max = render->clear_color[1];
 168   g = ART_PIX_8_FROM_MAX (color_max);
 169   color_max = render->clear_color[2];
 170   b = ART_PIX_8_FROM_MAX (color_max);
 171
 172   art_rgb_fill_run (dest, r, g, b, width);
 173 }
 174
 175 static void
 176 art_render_clear_render_8 (ArtRenderCallback *self, ArtRender *render,
 177                            art_u8 *dest, int y)
 178 {
 179   int width = render->x1 - render->x0;
 180   int i, j;
 181   int n_ch = render->n_chan + (render->alpha_type != ART_ALPHA_NONE);
 182   int ix;
 183   art_u8 color[ART_MAX_CHAN + 1];
 184
 185   for (j = 0; j < n_ch; j++)
 186     {
 187       ArtPixMaxDepth color_max = render->clear_color[j];
 188       color[j] = ART_PIX_8_FROM_MAX (color_max);
 189     }
 190
 191   ix = 0;
 192   for (i = 0; i < width; i++)
 193     for (j = 0; j < n_ch; j++)
 194       dest[ix++] = color[j];
 195 }
 196
 197 const ArtRenderCallback art_render_clear_rgb8_obj =
 198 {
 199   art_render_clear_render_rgb8,
 200   art_render_nop_done
 201 };
 202
 203 const ArtRenderCallback art_render_clear_8_obj =
 204 {
 205   art_render_clear_render_8,
 206   art_render_nop_done
 207 };
 208
 209 #if ART_MAX_DEPTH >= 16
 210
 211 static void
 212 art_render_clear_render_16 (ArtRenderCallback *self, ArtRender *render,
 213                             art_u8 *dest, int y)
 214 {
 215   int width = render->x1 - render->x0;
 216   int i, j;
 217   int n_ch = render->n_chan + (render->alpha_type != ART_ALPHA_NONE);
 218   int ix;
 219   art_u16 *dest_16 = (art_u16 *)dest;
 220   art_u8 color[ART_MAX_CHAN + 1];
 221
 222   for (j = 0; j < n_ch; j++)
 223     {
 224       int color_16 = render->clear_color[j];
 225       color[j] = color_16;
 226     }
 227
 228   ix = 0;
 229   for (i = 0; i < width; i++)
 230     for (j = 0; j < n_ch; j++)
 231       dest_16[ix++] = color[j];
 232 }
 233
 234 const ArtRenderCallback art_render_clear_16_obj =
 235 {
 236   art_render_clear_render_16,
 237   art_render_nop_done
 238 };
 239
 240 #endif /* ART_MAX_DEPTH >= 16 */
 241
 242 /* todo: inline */
 243 static ArtRenderCallback *
 244 art_render_choose_clear_callback (ArtRender *render)
 245 {
 246   ArtRenderCallback *clear_callback;
 247
 248   if (render->depth == 8)
 249     {
 250       if (render->n_chan == 3 &&
 251           render->alpha_type == ART_ALPHA_NONE)
 252         clear_callback = (ArtRenderCallback *)&art_render_clear_rgb8_obj;
 253       else
 254         clear_callback = (ArtRenderCallback *)&art_render_clear_8_obj;
 255     }
 256 #if ART_MAX_DEPTH >= 16
 257   else if (render->depth == 16)
 258     clear_callback = (ArtRenderCallback *)&art_render_clear_16_obj;
 259 #endif
 260   else
 261     {
 262       art_die ("art_render_choose_clear_callback: inconsistent render->depth = %d\n",
 263                render->depth);
 264     }
 265   return clear_callback;
 266 }
 267
 268 #if 0
 269 /* todo: get around to writing this */
 270 static void
 271 art_render_composite_render_noa_8_norm (ArtRenderCallback *self, ArtRender *render,
 272                                         art_u8 *dest, int y)
 273 {
 274   int width = render->x1 - render->x0;
 275
 276 }
 277 #endif
 278
 279 /* This is the most general form of the function. It is slow but
 280    (hopefully) correct. Actually, I'm still worried about roundoff
 281    errors in the premul case - it seems to me that an off-by-one could
 282    lead to overflow. */
 283 static void
 284 art_render_composite (ArtRenderCallback *self, ArtRender *render,
 285                                         art_u8 *dest, int y)
 286 {
 287   ArtRenderMaskRun *run = render->run;
 288   art_u32 depth = render->depth;
 289   int n_run = render->n_run;
 290   int x0 = render->x0;
 291   int x;
 292   int run_x0, run_x1;
 293   art_u8 *alpha_buf = render->alpha_buf;
 294   art_u8 *image_buf = render->image_buf;
 295   int i, j;
 296   art_u32 tmp;
 297   art_u32 run_alpha;
 298   art_u32 alpha;
 299   int image_ix;
 300   art_u16 src[ART_MAX_CHAN + 1];
 301   art_u16 dst[ART_MAX_CHAN + 1];
 302   int n_chan = render->n_chan;
 303   ArtAlphaType alpha_type = render->alpha_type;
 304   int n_ch = n_chan + (alpha_type != ART_ALPHA_NONE);
 305   int dst_pixstride = n_ch * (depth >> 3);
 306   int buf_depth = render->buf_depth;
 307   ArtAlphaType buf_alpha = render->buf_alpha;
 308   int buf_n_ch = n_chan + (buf_alpha != ART_ALPHA_NONE);
 309   int buf_pixstride = buf_n_ch * (buf_depth >> 3);
 310   art_u8 *bufptr;
 311   art_u32 src_alpha;
 312   art_u32 src_mul;
 313   art_u8 *dstptr;
 314   art_u32 dst_alpha;
 315   art_u32 dst_mul;
 316
 317   image_ix = 0;
 318   for (i = 0; i < n_run - 1; i++)
 319     {
 320       run_x0 = run[i].x;
 321       run_x1 = run[i + 1].x;
 322       tmp = run[i].alpha;
 323       if (tmp < 0x8100)
 324         continue;
 325
 326       run_alpha = (tmp + (tmp >> 8) + (tmp >> 16) - 0x8000) >> 8; /* range [0 .. 0x10000] */
 327       bufptr = image_buf + (run_x0 - x0) * buf_pixstride;
 328       dstptr = dest + (run_x0 - x0) * dst_pixstride;
 329       for (x = run_x0; x < run_x1; x++)
 330         {
 331           if (alpha_buf)
 332             {
 333               if (depth == 8)
 334                 {
 335                   tmp = run_alpha * alpha_buf[x - x0] + 0x80;
 336                   /* range 0x80 .. 0xff0080 */
 337                   alpha = (tmp + (tmp >> 8) + (tmp >> 16)) >> 8;
 338                 }
 339               else /* (depth == 16) */
 340                 {
 341                   tmp = ((art_u16 *)alpha_buf)[x - x0];
 342                   tmp = (run_alpha * tmp + 0x8000) >> 8;
 343                   /* range 0x80 .. 0xffff80 */
 344                   alpha = (tmp + (tmp >> 16)) >> 8;
 345                 }
 346             }
 347           else
 348             alpha = run_alpha;
 349           /* alpha is run_alpha * alpha_buf[x], range 0 .. 0x10000 */
 350
 351           /* convert (src pixel * alpha) to premul alpha form,
 352              store in src as 0..0xffff range */
 353           if (buf_alpha == ART_ALPHA_NONE)
 354             {
 355               src_alpha = alpha;
 356               src_mul = src_alpha;
 357             }
 358           else
 359             {
 360               if (buf_depth == 8)
 361                 {
 362                   tmp = alpha * bufptr[n_chan] + 0x80;
 363                   /* range 0x80 .. 0xff0080 */
 364                   src_alpha = (tmp + (tmp >> 8) + (tmp >> 16)) >> 8;
 365                 }
 366               else /* (depth == 16) */
 367                 {
 368                   tmp = ((art_u16 *)bufptr)[n_chan];
 369                   tmp = (alpha * tmp + 0x8000) >> 8;
 370                   /* range 0x80 .. 0xffff80 */
 371                   src_alpha = (tmp + (tmp >> 16)) >> 8;
 372                 }
 373               if (buf_alpha == ART_ALPHA_SEPARATE)
 374                 src_mul = src_alpha;
 375               else /* buf_alpha == (ART_ALPHA_PREMUL) */
 376                 src_mul = alpha;
 377             }
 378           /* src_alpha is the (alpha of the source pixel * alpha),
 379              range 0..0x10000 */
 380
 381           if (buf_depth == 8)
 382             {
 383               src_mul *= 0x101;
 384               for (j = 0; j < n_chan; j++)
 385                 src[j] = (bufptr[j] * src_mul + 0x8000) >> 16;
 386             }
 387           else if (buf_depth == 16)
 388             {
 389               for (j = 0; j < n_chan; j++)
 390                 src[j] = (((art_u16 *)bufptr)[j] * src_mul + 0x8000) >> 16;
 391             }
 392           bufptr += buf_pixstride;
 393
 394           /* src[0..n_chan - 1] (range 0..0xffff) and src_alpha (range
 395              0..0x10000) now contain the source pixel with
 396              premultiplied alpha */
 397
 398           /* convert dst pixel to premul alpha form,
 399              store in dst as 0..0xffff range */
 400           if (alpha_type == ART_ALPHA_NONE)
 401             {
 402               dst_alpha = 0x10000;
 403               dst_mul = dst_alpha;
 404             }
 405           else
 406             {
 407               if (depth == 8)
 408                 {
 409                   tmp = dstptr[n_chan];
 410                   /* range 0..0xff */
 411                   dst_alpha = (tmp << 8) + tmp + (tmp >> 7);
 412                 }
 413               else /* (depth == 16) */
 414                 {
 415                   tmp = ((art_u16 *)bufptr)[n_chan];
 416                   dst_alpha = (tmp + (tmp >> 15));
 417                 }
 418               if (alpha_type == ART_ALPHA_SEPARATE)
 419                 dst_mul = dst_alpha;
 420               else /* (alpha_type == ART_ALPHA_PREMUL) */
 421                 dst_mul = 0x10000;
 422             }
 423           /* dst_alpha is the alpha of the dest pixel,
 424              range 0..0x10000 */
 425
 426           if (depth == 8)
 427             {
 428               dst_mul *= 0x101;
 429               for (j = 0; j < n_chan; j++)
 430                 dst[j] = (dstptr[j] * dst_mul + 0x8000) >> 16;
 431             }
 432           else if (buf_depth == 16)
 433             {
 434               for (j = 0; j < n_chan; j++)
 435                 dst[j] = (((art_u16 *)dstptr)[j] * dst_mul + 0x8000) >> 16;
 436             }
 437
 438           /* do the compositing, dst = (src over dst) */
 439           for (j = 0; j < n_chan; j++)
 440             {
 441               art_u32 srcv, dstv;
 442               art_u32 tmp;
 443
 444               srcv = src[j];
 445               dstv = dst[j];
 446               tmp = ((dstv * (0x10000 - src_alpha) + 0x8000) >> 16) + srcv;
 447               tmp -= tmp >> 16;
 448               dst[j] = tmp;
 449             }
 450
 451           if (alpha_type == ART_ALPHA_NONE)
 452             {
 453               if (depth == 8)
 454                 dst_mul = 0xff;
 455               else /* (depth == 16) */
 456                 dst_mul = 0xffff;
 457             }
 458           else
 459             {
 460               if (src_alpha >= 0x10000)
 461                 dst_alpha = 0x10000;
 462               else
 463                 dst_alpha += ((((0x10000 - dst_alpha) * src_alpha) >> 8) + 0x80) >> 8;
 464               if (alpha_type == ART_ALPHA_PREMUL || dst_alpha == 0)
 465                 {
 466                   if (depth == 8)
 467                     dst_mul = 0xff;
 468                   else /* (depth == 16) */
 469                     dst_mul = 0xffff;
 470                 }
 471               else /* (ALPHA_TYPE == ART_ALPHA_SEPARATE && dst_alpha != 0) */
 472                 {
 473                   if (depth == 8)
 474                     dst_mul = 0xff0000 / dst_alpha;
 475                   else /* (depth == 16) */
 476                     dst_mul = 0xffff0000 / dst_alpha;
 477                 }
 478             }
 479           if (depth == 8)
 480             {
 481               for (j = 0; j < n_chan; j++)
 482                 dstptr[j] = (dst[j] * dst_mul + 0x8000) >> 16;
 483               if (alpha_type != ART_ALPHA_NONE)
 484                 dstptr[n_chan] = (dst_alpha * 0xff + 0x8000) >> 16;
 485             }
 486           else if (depth == 16)
 487             {
 488               for (j = 0; j < n_chan; j++)
 489                 ((art_u16 *)dstptr)[j] = (dst[j] * dst_mul + 0x8000) >> 16;
 490               if (alpha_type != ART_ALPHA_NONE)
 491                 dstptr[n_chan] = (dst_alpha * 0xffff + 0x8000) >> 16;
 492             }
 493           dstptr += dst_pixstride;
 494         }
 495     }
 496 }
 497
 498 const ArtRenderCallback art_render_composite_obj =
 499 {
 500   art_render_composite,
 501   art_render_nop_done
 502 };
 503
 504 static void
 505 art_render_composite_8 (ArtRenderCallback *self, ArtRender *render,
 506                         art_u8 *dest, int y)
 507 {
 508   ArtRenderMaskRun *run = render->run;
 509   int n_run = render->n_run;
 510   int x0 = render->x0;
 511   int x;
 512   int run_x0, run_x1;
 513   art_u8 *alpha_buf = render->alpha_buf;
 514   art_u8 *image_buf = render->image_buf;
 515   int i, j;
 516   art_u32 tmp;
 517   art_u32 run_alpha;
 518   art_u32 alpha;
 519   int image_ix;
 520   int n_chan = render->n_chan;
 521   ArtAlphaType alpha_type = render->alpha_type;
 522   int n_ch = n_chan + (alpha_type != ART_ALPHA_NONE);
 523   int dst_pixstride = n_ch;
 524   ArtAlphaType buf_alpha = render->buf_alpha;
 525   int buf_n_ch = n_chan + (buf_alpha != ART_ALPHA_NONE);
 526   int buf_pixstride = buf_n_ch;
 527   art_u8 *bufptr;
 528   art_u32 src_alpha;
 529   art_u32 src_mul;
 530   art_u8 *dstptr;
 531   art_u32 dst_alpha;
 532   art_u32 dst_mul, dst_save_mul;
 533
 534   image_ix = 0;
 535   for (i = 0; i < n_run - 1; i++)
 536     {
 537       run_x0 = run[i].x;
 538       run_x1 = run[i + 1].x;
 539       tmp = run[i].alpha;
 540       if (tmp < 0x10000)
 541         continue;
 542
 543       run_alpha = (tmp + (tmp >> 8) + (tmp >> 16) - 0x8000) >> 8; /* range [0 .. 0x10000] */
 544       bufptr = image_buf + (run_x0 - x0) * buf_pixstride;
 545       dstptr = dest + (run_x0 - x0) * dst_pixstride;
 546       for (x = run_x0; x < run_x1; x++)
 547         {
 548           if (alpha_buf)
 549             {
 550               tmp = run_alpha * alpha_buf[x - x0] + 0x80;
 551               /* range 0x80 .. 0xff0080 */
 552               alpha = (tmp + (tmp >> 8) + (tmp >> 16)) >> 8;
 553             }
 554           else
 555             alpha = run_alpha;
 556           /* alpha is run_alpha * alpha_buf[x], range 0 .. 0x10000 */
 557
 558           /* convert (src pixel * alpha) to premul alpha form,
 559              store in src as 0..0xffff range */
 560           if (buf_alpha == ART_ALPHA_NONE)
 561             {
 562               src_alpha = alpha;
 563               src_mul = src_alpha;
 564             }
 565           else
 566             {
 567               tmp = alpha * bufptr[n_chan] + 0x80;
 568               /* range 0x80 .. 0xff0080 */
 569               src_alpha = (tmp + (tmp >> 8) + (tmp >> 16)) >> 8;
 570
 571               if (buf_alpha == ART_ALPHA_SEPARATE)
 572                 src_mul = src_alpha;
 573               else /* buf_alpha == (ART_ALPHA_PREMUL) */
 574                 src_mul = alpha;
 575             }
 576           /* src_alpha is the (alpha of the source pixel * alpha),
 577              range 0..0x10000 */
 578
 579           src_mul *= 0x101;
 580
 581           if (alpha_type == ART_ALPHA_NONE)
 582             {
 583               dst_alpha = 0x10000;
 584               dst_mul = dst_alpha;
 585             }
 586           else
 587             {
 588               tmp = dstptr[n_chan];
 589               /* range 0..0xff */
 590               dst_alpha = (tmp << 8) + tmp + (tmp >> 7);
 591               if (alpha_type == ART_ALPHA_SEPARATE)
 592                 dst_mul = dst_alpha;
 593               else /* (alpha_type == ART_ALPHA_PREMUL) */
 594                 dst_mul = 0x10000;
 595             }
 596           /* dst_alpha is the alpha of the dest pixel,
 597              range 0..0x10000 */
 598
 599           dst_mul *= 0x101;
 600
 601           if (alpha_type == ART_ALPHA_NONE)
 602             {
 603               dst_save_mul = 0xff;
 604             }
 605           else
 606             {
 607               if (src_alpha >= 0x10000)
 608                 dst_alpha = 0x10000;
 609               else
 610                 dst_alpha += ((((0x10000 - dst_alpha) * src_alpha) >> 8) + 0x80) >> 8;
 611               if (alpha_type == ART_ALPHA_PREMUL || dst_alpha == 0)
 612                 {
 613                   dst_save_mul = 0xff;
 614                 }
 615               else /* (ALPHA_TYPE == ART_ALPHA_SEPARATE && dst_alpha != 0) */
 616                 {
 617                   dst_save_mul = 0xff0000 / dst_alpha;
 618                 }
 619             }
 620           for (j = 0; j < n_chan; j++)
 621             {
 622               art_u32 src, dst;
 623               art_u32 tmp;
 624
 625               src = (bufptr[j] * src_mul + 0x8000) >> 16;
 626               dst = (dstptr[j] * dst_mul + 0x8000) >> 16;
 627               tmp = ((dst * (0x10000 - src_alpha) + 0x8000) >> 16) + src;
 628               tmp -= tmp >> 16;
 629               dstptr[j] = (tmp * dst_save_mul + 0x8000) >> 16;
 630             }
 631           if (alpha_type != ART_ALPHA_NONE)
 632             dstptr[n_chan] = (dst_alpha * 0xff + 0x8000) >> 16;
 633
 634           bufptr += buf_pixstride;
 635           dstptr += dst_pixstride;
 636         }
 637     }
 638 }
 639
 640 const ArtRenderCallback art_render_composite_8_obj =
 641 {
 642   art_render_composite_8,
 643   art_render_nop_done
 644 };
 645
 646 /* todo: inline */
 647 static ArtRenderCallback *
 648 art_render_choose_compositing_callback (ArtRender *render)
 649 {
 650   if (render->depth == 8 && render->buf_depth == 8)
 651     return (ArtRenderCallback *)&art_render_composite_8_obj;
 652   return (ArtRenderCallback *)&art_render_composite_obj;
 653 }
 654
 655 /**
 656  * art_render_invoke_callbacks: Invoke the callbacks in the render object.
 657  * @render: The render object.
 658  * @y: The current Y coordinate value.
 659  *
 660  * Invokes the callbacks of the render object in the appropriate
 661  * order.  Drivers should call this routine once per scanline.
 662  *
 663  * todo: should management of dest devolve to this routine? very
 664  * plausibly yes.
 665  **/
 666 void
 667 art_render_invoke_callbacks (ArtRender *render, art_u8 *dest, int y)
 668 {
 669   ArtRenderPriv *priv = (ArtRenderPriv *)render;
 670   int i;
 671
 672   for (i = 0; i < priv->n_callbacks; i++)
 673     {
 674       ArtRenderCallback *callback;
 675
 676       callback = priv->callbacks[i];
 677       callback->render (callback, render, dest, y);
 678     }
 679 }
 680
 681 /**
 682  * art_render_invoke: Perform the requested rendering task.
 683  * @render: The render object.
 684  *
 685  * Invokes the renderer and all sources associated with it, to perform
 686  * the requested rendering task.
 687  **/
 688 void
 689 art_render_invoke (ArtRender *render)
 690 {
 691   ArtRenderPriv *priv = (ArtRenderPriv *)render;
 692   int width;
 693   int best_driver, best_score;
 694   int i;
 695   int n_callbacks, n_callbacks_max;
 696   ArtImageSource *image_source;
 697   ArtImageSourceFlags image_flags;
 698   int buf_depth;
 699   ArtAlphaType buf_alpha;
 700   art_boolean first = ART_TRUE;
 701
 702   if (render == NULL)
 703     {
 704       art_warn ("art_render_invoke: called with render == NULL\n");
 705       return;
 706     }
 707   if (priv->image_source == NULL)
 708     {
 709       art_warn ("art_render_invoke: no image source given\n");
 710       return;
 711     }
 712
 713   width = render->x1 - render->x0;
 714
 715   render->run = art_new (ArtRenderMaskRun, width + 1);
 716
 717   /* Elect a mask source as driver. */
 718   best_driver = -1;
 719   best_score = 0;
 720   for (i = 0; i < priv->n_mask_source; i++)
 721     {
 722       int score;
 723       ArtMaskSource *mask_source;
 724
 725       mask_source = priv->mask_source[i];
 726       score = mask_source->can_drive (mask_source, render);
 727       if (score > best_score)
 728         {
 729           best_score = score;
 730           best_driver = i;
 731         }
 732     }
 733
 734   /* Allocate alpha buffer if needed. */
 735   if (priv->n_mask_source > 1 ||
 736       (priv->n_mask_source == 1 && best_driver < 0))
 737     {
 738       render->alpha_buf = art_new (art_u8, (width * render->depth) >> 3);
 739     }
 740
 741   /* Negotiate image rendering and compositing. */
 742   image_source = priv->image_source;
 743   image_source->negotiate (image_source, render, &image_flags, &buf_depth,
 744                            &buf_alpha);
 745
 746   /* Build callback list. */
 747   n_callbacks_max = priv->n_mask_source + 3;
 748   priv->callbacks = art_new (ArtRenderCallback *, n_callbacks_max);
 749   n_callbacks = 0;
 750   for (i = 0; i < priv->n_mask_source; i++)
 751     if (i != best_driver)
 752       {
 753         ArtMaskSource *mask_source = priv->mask_source[i];
 754
 755         mask_source->prepare (mask_source, render, first);
 756         first = ART_FALSE;
 757         priv->callbacks[n_callbacks++] = &mask_source->super;
 758       }
 759
 760   if (render->clear && !(image_flags & ART_IMAGE_SOURCE_CAN_CLEAR))
 761     priv->callbacks[n_callbacks++] =
 762       art_render_choose_clear_callback (render);
 763
 764   priv->callbacks[n_callbacks++] = &image_source->super;
 765
 766   /* Allocate image buffer and add compositing callback if needed. */
 767   if (!(image_flags & ART_IMAGE_SOURCE_CAN_COMPOSITE))
 768     {
 769       int bytespp = ((render->n_chan + (buf_alpha != ART_ALPHA_NONE)) *
 770                      buf_depth) >> 3;
 771       render->buf_depth = buf_depth;
 772       render->buf_alpha = buf_alpha;
 773       render->image_buf = art_new (art_u8, width * bytespp);
 774       priv->callbacks[n_callbacks++] =
 775         art_render_choose_compositing_callback (render);
 776     }
 777
 778   priv->n_callbacks = n_callbacks;
 779
 780   if (render->need_span)
 781     render->span_x = art_new (int, width + 1);
 782
 783   /* Invoke the driver */
 784   if (best_driver >= 0)
 785     {
 786       ArtMaskSource *driver;
 787
 788       driver = priv->mask_source[best_driver];
 789       driver->invoke_driver (driver, render);
 790     }
 791   else
 792     {
 793       art_u8 *dest_ptr = render->pixels;
 794       int y;
 795
 796       /* Dummy driver */
 797       render->n_run = 2;
 798       render->run[0].x = render->x0;
 799       render->run[0].alpha = 0x8000 + 0xff * render->opacity;
 800       render->run[1].x = render->x1;
 801       render->run[1].alpha = 0x8000;
 802       if (render->need_span)
 803         {
 804           render->n_span = 2;
 805           render->span_x[0] = render->x0;
 806           render->span_x[1] = render->x1;
 807         }
 808       for (y = render->y0; y < render->y1; y++)
 809         {
 810           art_render_invoke_callbacks (render, dest_ptr, y);
 811           dest_ptr += render->rowstride;
 812         }
 813     }
 814
 815   if (priv->mask_source != NULL)
 816     art_free (priv->mask_source);
 817
 818   /* clean up callbacks */
 819   for (i = 0; i < priv->n_callbacks; i++)
 820     {
 821       ArtRenderCallback *callback;
 822
 823       callback = priv->callbacks[i];
 824       callback->done (callback, render);
 825     }
 826
 827   /* Tear down object */
 828   if (render->alpha_buf != NULL)
 829     art_free (render->alpha_buf);
 830   if (render->image_buf != NULL)
 831     art_free (render->image_buf);
 832   art_free (render->run);
 833   if (render->span_x != NULL)
 834     art_free (render->span_x);
 835   art_free (priv->callbacks);
 836   art_free (render);
 837 }
 838
 839 /**
 840  * art_render_mask_solid: Add a solid translucent mask.
 841  * @render: The render object.
 842  * @opacity: Opacity in [0..0x10000] form.
 843  *
 844  * Adds a translucent mask to the rendering object.
 845  **/
 846 void
 847 art_render_mask_solid (ArtRender *render, int opacity)
 848 {
 849   art_u32 old_opacity = render->opacity;
 850   art_u32 new_opacity_tmp;
 851
 852   if (opacity == 0x10000)
 853     /* avoid potential overflow */
 854     return;
 855   new_opacity_tmp = old_opacity * (art_u32)opacity + 0x8000;
 856   render->opacity = new_opacity_tmp >> 16;
 857 }
 858
 859 /**
 860  * art_render_add_mask_source: Add a mask source to the render object.
 861  * @render: Render object.
 862  * @mask_source: Mask source to add.
 863  *
 864  * This routine adds a mask source to the render object. In general,
 865  * client api's for adding mask sources should just take a render object,
 866  * then the mask source creation function should call this function.
 867  * Clients should never have to call this function directly, unless of
 868  * course they're creating custom mask sources.
 869  **/
 870 void
 871 art_render_add_mask_source (ArtRender *render, ArtMaskSource *mask_source)
 872 {
 873   ArtRenderPriv *priv = (ArtRenderPriv *)render;
 874   int n_mask_source = priv->n_mask_source++;
 875
 876   if (n_mask_source == 0)
 877     priv->mask_source = art_new (ArtMaskSource *, 1);
 878   /* This predicate is true iff n_mask_source is a power of two */
 879   else if (!(n_mask_source & (n_mask_source - 1)))
 880     priv->mask_source = art_renew (priv->mask_source, ArtMaskSource *,
 881                                    n_mask_source << 1);
 882
 883   priv->mask_source[n_mask_source] = mask_source;
 884 }
 885
 886 /**
 887  * art_render_add_image_source: Add a mask source to the render object.
 888  * @render: Render object.
 889  * @image_source: Image source to add.
 890  *
 891  * This routine adds an image source to the render object. In general,
 892  * client api's for adding image sources should just take a render
 893  * object, then the mask source creation function should call this
 894  * function.  Clients should never have to call this function
 895  * directly, unless of course they're creating custom image sources.
 896  **/
 897 void
 898 art_render_add_image_source (ArtRender *render, ArtImageSource *image_source)
 899 {
 900   ArtRenderPriv *priv = (ArtRenderPriv *)render;
 901
 902   if (priv->image_source != NULL)
 903     {
 904       art_warn ("art_render_add_image_source: image source already present.\n");
 905       return;
 906     }
 907   priv->image_source = image_source;
 908 }
 909
 910 /* Solid image source object and methods. Perhaps this should go into a
 911    separate file. */
 912
 913 typedef struct _ArtImageSourceSolid ArtImageSourceSolid;
 914
 915 struct _ArtImageSourceSolid {
 916   ArtImageSource super;
 917   ArtPixMaxDepth color[ART_MAX_CHAN];
 918   art_u32 *rgbtab;
 919   art_boolean init;
 920 };
 921
 922 static void
 923 art_render_image_solid_done (ArtRenderCallback *self, ArtRender *render)
 924 {
 925   ArtImageSourceSolid *z = (ArtImageSourceSolid *)self;
 926
 927   if (z->rgbtab != NULL)
 928     art_free (z->rgbtab);
 929   art_free (self);
 930 }
 931
 932 static void
 933 art_render_image_solid_rgb8_opaq_init (ArtImageSourceSolid *self, ArtRender *render)
 934 {
 935   ArtImageSourceSolid *z = (ArtImageSourceSolid *)self;
 936   ArtPixMaxDepth color_max;
 937   int r_fg, g_fg, b_fg;
 938   int r_bg, g_bg, b_bg;
 939   int r, g, b;
 940   int dr, dg, db;
 941   int i;
 942   int tmp;
 943   art_u32 *rgbtab;
 944
 945   rgbtab = art_new (art_u32, 256);
 946   z->rgbtab = rgbtab;
 947
 948   color_max = self->color[0];
 949   r_fg = ART_PIX_8_FROM_MAX (color_max);
 950   color_max = self->color[1];
 951   g_fg = ART_PIX_8_FROM_MAX (color_max);
 952   color_max = self->color[2];
 953   b_fg = ART_PIX_8_FROM_MAX (color_max);
 954
 955   color_max = render->clear_color[0];
 956   r_bg = ART_PIX_8_FROM_MAX (color_max);
 957   color_max = render->clear_color[1];
 958   g_bg = ART_PIX_8_FROM_MAX (color_max);
 959   color_max = render->clear_color[2];
 960   b_bg = ART_PIX_8_FROM_MAX (color_max);
 961
 962   r = (r_bg << 16) + 0x8000;
 963   g = (g_bg << 16) + 0x8000;
 964   b = (b_bg << 16) + 0x8000;
 965   tmp = ((r_fg - r_bg) << 16) + 0x80;
 966   dr = (tmp + (tmp >> 8)) >> 8;
 967   tmp = ((g_fg - g_bg) << 16) + 0x80;
 968   dg = (tmp + (tmp >> 8)) >> 8;
 969   tmp = ((b_fg - b_bg) << 16) + 0x80;
 970   db = (tmp + (tmp >> 8)) >> 8;
 971
 972   for (i = 0; i < 256; i++)
 973     {
 974       rgbtab[i] = (r & 0xff0000) | ((g & 0xff0000) >> 8) | (b >> 16);
 975       r += dr;
 976       g += dg;
 977       b += db;
 978     }
 979 }
 980
 981 static void
 982 art_render_image_solid_rgb8_opaq (ArtRenderCallback *self, ArtRender *render,
 983                                   art_u8 *dest, int y)
 984 {
 985   ArtImageSourceSolid *z = (ArtImageSourceSolid *)self;
 986   ArtRenderMaskRun *run = render->run;
 987   int n_run = render->n_run;
 988   art_u32 *rgbtab = z->rgbtab;
 989   art_u32 rgb;
 990   int x0 = render->x0;
 991   int x1 = render->x1;
 992   int run_x0, run_x1;
 993   int i;
 994   int ix;
 995
 996   if (n_run > 0)
 997     {
 998       run_x1 = run[0].x;
 999       if (run_x1 > x0)
1000         {
1001           rgb = rgbtab[0];
1002           art_rgb_fill_run (dest,
1003                             rgb >> 16, (rgb >> 8) & 0xff, rgb & 0xff,
1004                             run_x1 - x0);
1005         }
1006       for (i = 0; i < n_run - 1; i++)
1007         {
1008           run_x0 = run_x1;
1009           run_x1 = run[i + 1].x;
1010           rgb = rgbtab[(run[i].alpha >> 16) & 0xff];
1011           ix = (run_x0 - x0) * 3;
1012 #define OPTIMIZE_LEN_1
1013 #ifdef OPTIMIZE_LEN_1
1014           if (run_x1 - run_x0 == 1)
1015             {
1016               dest[ix] = rgb >> 16;
1017               dest[ix + 1] = (rgb >> 8) & 0xff;
1018               dest[ix + 2] = rgb & 0xff;
1019             }
1020           else
1021             {
1022               art_rgb_fill_run (dest + ix,
1023                                 rgb >> 16, (rgb >> 8) & 0xff, rgb & 0xff,
1024                                 run_x1 - run_x0);
1025             }
1026 #else
1027           art_rgb_fill_run (dest + ix,
1028                             rgb >> 16, (rgb >> 8) & 0xff, rgb & 0xff,
1029                             run_x1 - run_x0);
1030 #endif
1031         }
1032     }
1033   else
1034     {
1035       run_x1 = x0;
1036     }
1037   if (run_x1 < x1)
1038     {
1039       rgb = rgbtab[0];
1040       art_rgb_fill_run (dest + (run_x1 - x0) * 3,
1041                         rgb >> 16, (rgb >> 8) & 0xff, rgb & 0xff,
1042                         x1 - run_x1);
1043     }
1044 }
1045
1046 static void
1047 art_render_image_solid_rgb8 (ArtRenderCallback *self, ArtRender *render,
1048                              art_u8 *dest, int y)
1049 {
1050   ArtImageSourceSolid *z = (ArtImageSourceSolid *)self;
1051   int width = render->x1 - render->x0;
1052   art_u8 r, g, b;
1053   ArtPixMaxDepth color_max;
1054
1055   /* todo: replace this simple test with real sparseness */
1056   if (z->init)
1057     return;
1058   z->init = ART_TRUE;
1059
1060   color_max = z->color[0];
1061   r = ART_PIX_8_FROM_MAX (color_max);
1062   color_max = z->color[1];
1063   g = ART_PIX_8_FROM_MAX (color_max);
1064   color_max = z->color[2];
1065   b = ART_PIX_8_FROM_MAX (color_max);
1066
1067   art_rgb_fill_run (render->image_buf, r, g, b, width);
1068 }
1069
1070 static void
1071 art_render_image_solid_negotiate (ArtImageSource *self, ArtRender *render,
1072                                   ArtImageSourceFlags *p_flags,
1073                                   int *p_buf_depth, ArtAlphaType *p_alpha)
1074 {
1075   ArtImageSourceSolid *z = (ArtImageSourceSolid *)self;
1076   ArtImageSourceFlags flags = 0;
1077   static void (*render_cbk) (ArtRenderCallback *self, ArtRender *render,
1078                              art_u8 *dest, int y);
1079
1080   render_cbk = NULL;
1081
1082   if (render->depth == 8 && render->n_chan == 3 &&
1083       render->alpha_type == ART_ALPHA_NONE)
1084     {
1085       if (render->clear)
1086         {
1087           render_cbk = art_render_image_solid_rgb8_opaq;
1088           flags |= ART_IMAGE_SOURCE_CAN_CLEAR | ART_IMAGE_SOURCE_CAN_COMPOSITE;
1089           art_render_image_solid_rgb8_opaq_init (z, render);
1090         }
1091     }
1092   if (render_cbk == NULL)
1093     {
1094       if (render->depth == 8)
1095         {
1096           render_cbk = art_render_image_solid_rgb8;
1097           *p_buf_depth = 8;
1098           *p_alpha = ART_ALPHA_NONE; /* todo */
1099         }
1100     }
1101   /* todo: general case */
1102   self->super.render = render_cbk;
1103   *p_flags = flags;
1104 }
1105
1106 /**
1107  * art_render_image_solid: Add a solid color image source.
1108  * @render: The render object.
1109  * @color: Color.
1110  *
1111  * Adds an image source with the solid color given by @color. The
1112  * color need not be retained in memory after this call.
1113  **/
1114 void
1115 art_render_image_solid (ArtRender *render, ArtPixMaxDepth *color)
1116 {
1117   ArtImageSourceSolid *image_source;
1118   int i;
1119
1120   image_source = art_new (ArtImageSourceSolid, 1);
1121   image_source->super.super.render = NULL;
1122   image_source->super.super.done = art_render_image_solid_done;
1123   image_source->super.negotiate = art_render_image_solid_negotiate;
1124
1125   for (i = 0; i < render->n_chan; i++)
1126     image_source->color[i] = color[i];
1127
1128   image_source->rgbtab = NULL;
1129   image_source->init = ART_FALSE;
1130
1131   art_render_add_image_source (render, &image_source->super);
1132 }