render.im

   1 /*
   2 Render utilities
   3 */
   4 #include "imager.h"
   5
   6 #define RENDER_MAGIC 0x765AE
   7
   8 typedef void (*render_color_f)(i_render *, i_img_dim, i_img_dim, i_img_dim, unsigned char const *src, i_color const *color);
   9
  10 #define i_has_alpha(channels) ((channels) == 2 || (channels) == 4)
  11
  12 #define i_color_channels(channels) (i_has_alpha(channels) ? (channels)-1 : (channels))
  13
  14 #code
  15
  16 static void IM_SUFFIX(render_color_alpha)(i_render *r, i_img_dim x, i_img_dim y, i_img_dim width, unsigned char const *src, i_color const *color);
  17 static void IM_SUFFIX(render_color_13)(i_render *r, i_img_dim x, i_img_dim y, i_img_dim width, unsigned char const *src, i_color const *color);
  18
  19 static render_color_f IM_SUFFIX(render_color_tab)[] =
  20   {
  21     NULL,
  22     IM_SUFFIX(render_color_13),
  23     IM_SUFFIX(render_color_alpha),
  24     IM_SUFFIX(render_color_13),
  25     IM_SUFFIX(render_color_alpha),
  26   };
  27
  28 static void IM_SUFFIX(combine_line_noalpha)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count);
  29 static void IM_SUFFIX(combine_line_alpha)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count);
  30 /* the copy variant copies the source alpha to the the output alpha channel */
  31 static void IM_SUFFIX(combine_line_alpha_na)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count);
  32
  33 static void IM_SUFFIX(combine_line)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count);
  34 static void IM_SUFFIX(combine_line_na)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count);
  35
  36 #/code
  37
  38 /*
  39 =item i_render_new(im, width)
  40 =category Blit tools
  41
  42 Allocate a new C<i_render> object and initialize it.
  43
  44 =cut
  45 */
  46
  47 i_render *
  48 i_render_new(i_img *im, i_img_dim width) {
  49   i_render *r = mymalloc(sizeof(i_render));
  50
  51   i_render_init(r, im, width);
  52
  53   return r;
  54 }
  55
  56 /*
  57 =item i_render_delete(r)
  58 =category Blit tools
  59
  60 Release an C<i_render> object.
  61
  62 =cut
  63 */
  64
  65 void
  66 i_render_delete(i_render *r) {
  67   i_render_done(r);
  68   myfree(r);
  69 }
  70
  71 void
  72 i_render_init(i_render *r, i_img *im, i_img_dim width) {
  73   r->magic = RENDER_MAGIC;
  74   r->im = im;
  75   r->line_width = width;
  76   r->line_8 = NULL;
  77   r->line_double = NULL;
  78   r->fill_width = width;
  79   r->fill_line_8 = NULL;
  80   r->fill_line_double = NULL;
  81 }
  82
  83 void
  84 i_render_done(i_render *r) {
  85   if (r->line_8)
  86     myfree(r->line_8);
  87   if (r->line_double)
  88     myfree(r->line_double);
  89   if (r->fill_line_8)
  90     myfree(r->fill_line_8);
  91   if (r->fill_line_double)
  92     myfree(r->fill_line_double);
  93   r->magic = 0;
  94 }
  95
  96 static void
  97 alloc_line(i_render *r, i_img_dim width, i_img_dim eight_bit) {
  98   if (width > r->line_width) {
  99     i_img_dim new_width = r->line_width * 2;
 100     if (new_width < width)
 101       new_width = width;
 102
 103     if (eight_bit) {
 104       if (r->line_8)
 105         r->line_8 = myrealloc(r->line_8, sizeof(i_color) * new_width);
 106       else
 107         r->line_8 = mymalloc(sizeof(i_color) * new_width);
 108       if (r->line_double) {
 109         myfree(r->line_double);
 110         r->line_double = NULL;
 111       }
 112     }
 113     else {
 114       if (r->line_double)
 115         r->line_double = myrealloc(r->line_double, sizeof(i_fcolor) * new_width);
 116       else
 117         r->line_double = mymalloc(sizeof(i_fcolor) * new_width);
 118       if (r->line_8) {
 119         myfree(r->line_8);
 120         r->line_double = NULL;
 121       }
 122     }
 123
 124     r->line_width = new_width;
 125   }
 126   else {
 127     if (eight_bit) {
 128       if (!r->line_8)
 129         r->line_8 = mymalloc(sizeof(i_color) * r->line_width);
 130       if (r->line_double) {
 131         myfree(r->line_double);
 132         r->line_double = NULL;
 133       }
 134     }
 135     else {
 136       if (!r->line_double)
 137         r->line_double = mymalloc(sizeof(i_fcolor) * r->line_width);
 138       if (r->line_8) {
 139         myfree(r->line_8);
 140         r->line_8 = NULL;
 141       }
 142     }
 143   }
 144 }
 145
 146 static void
 147 alloc_fill_line(i_render *r, i_img_dim width, int eight_bit) {
 148   if (width > r->fill_width) {
 149     i_img_dim new_width = r->fill_width * 2;
 150     if (new_width < width)
 151       new_width = width;
 152
 153     if (eight_bit) {
 154       if (r->line_8)
 155         r->fill_line_8 = myrealloc(r->fill_line_8, sizeof(i_color) * new_width);
 156       else
 157         r->fill_line_8 = mymalloc(sizeof(i_color) * new_width);
 158       if (r->fill_line_double) {
 159         myfree(r->fill_line_double);
 160         r->fill_line_double = NULL;
 161       }
 162     }
 163     else {
 164       if (r->fill_line_double)
 165         r->fill_line_double = myrealloc(r->fill_line_double, sizeof(i_fcolor) * new_width);
 166       else
 167         r->fill_line_double = mymalloc(sizeof(i_fcolor) * new_width);
 168       if (r->fill_line_8) {
 169         myfree(r->fill_line_8);
 170         r->fill_line_double = NULL;
 171       }
 172     }
 173
 174     r->fill_width = new_width;
 175   }
 176   else {
 177     if (eight_bit) {
 178       if (!r->fill_line_8)
 179         r->fill_line_8 = mymalloc(sizeof(i_color) * r->fill_width);
 180       if (r->fill_line_double) {
 181         myfree(r->fill_line_double);
 182         r->fill_line_double = NULL;
 183       }
 184     }
 185     else {
 186       if (!r->fill_line_double)
 187         r->fill_line_double = mymalloc(sizeof(i_fcolor) * r->fill_width);
 188       if (r->fill_line_8) {
 189         myfree(r->fill_line_8);
 190         r->fill_line_8 = NULL;
 191       }
 192     }
 193   }
 194 }
 195
 196 /*
 197 =item i_render_color(r, x, y, width, source, color)
 198 =category Blit tools
 199
 200 Render the given color with the coverage specified by C<source[0]> to
 201 C<source[width-1]>.
 202
 203 Renders in normal combine mode.
 204
 205 =cut
 206 */
 207
 208 void
 209 i_render_color(i_render *r, i_img_dim x, i_img_dim y, i_img_dim width,
 210                unsigned char const *src, i_color const *color) {
 211   i_img *im = r->im;
 212   if (y < 0 || y >= im->ysize)
 213     return;
 214   if (x < 0) {
 215     width += x;
 216     src -= x;
 217     x = 0;
 218   }
 219   if (x + width > im->xsize) {
 220     width = im->xsize - x;
 221   }
 222   if (x >= im->xsize || x + width <= 0 || width <= 0)
 223     return;
 224
 225   /* avoid as much work as we can */
 226   while (width > 0 && *src == 0) {
 227     --width;
 228     ++src;
 229     ++x;
 230   }
 231   while (width > 0 && src[width-1] == 0) {
 232     --width;
 233   }
 234   if (!width)
 235     return;
 236
 237   alloc_line(r, width, r->im->bits <= 8);
 238
 239 #code r->im->bits <= 8
 240   /*if (r->IM_SUFFIX(line) == NULL)
 241     r->IM_SUFFIX(line) = mymalloc(sizeof(IM_COLOR) * r->width);*/
 242   (IM_SUFFIX(render_color_tab)[im->channels])(r, x, y, width, src, color);
 243 #/code
 244 }
 245
 246 /*
 247 =item i_render_fill(r, x, y, width, source, fill)
 248 =category Blit tools
 249
 250 Render the given fill with the coverage in C<source[0]> through
 251 C<source[width-1]>.
 252
 253 =cut
 254 */
 255
 256 void
 257 i_render_fill(i_render *r, i_img_dim x, i_img_dim y, i_img_dim width,
 258               unsigned char const *src, i_fill_t *fill) {
 259   i_img *im = r->im;
 260   int fill_channels = im->channels;
 261
 262   if (fill_channels == 1 || fill_channels == 3)
 263     ++fill_channels;
 264
 265   if (y < 0 || y >= im->ysize)
 266     return;
 267   if (x < 0) {
 268     width += x;
 269     src -= x;
 270     x = 0;
 271   }
 272   if (x + width > im->xsize) {
 273     width = im->xsize - x;
 274   }
 275   if (x >= im->xsize || x + width <= 0 || width <= 0)
 276     return;
 277
 278   if (src) {
 279     /* avoid as much work as we can */
 280     while (width > 0 && *src == 0) {
 281       --width;
 282       ++src;
 283       ++x;
 284     }
 285     while (width > 0 && src[width-1] == 0) {
 286       --width;
 287     }
 288   }
 289   if (!width)
 290     return;
 291
 292   alloc_line(r, width, r->im->bits <= 8 && fill->f_fill_with_color != NULL);
 293   alloc_fill_line(r, width, r->im->bits <= 8 && fill->f_fill_with_color != NULL);
 294
 295 #code r->im->bits <= 8 && fill->f_fill_with_color
 296   if (IM_FILL_COMBINE(fill)) {
 297     IM_COLOR *srcc = r->IM_SUFFIX(fill_line);
 298     IM_COLOR *destc = r->IM_SUFFIX(line);
 299     IM_FILL_FILLER(fill)(fill, x, y, width, fill_channels, r->IM_SUFFIX(fill_line));
 300     if (src) {
 301       unsigned char const *srcc = src;
 302       IM_COLOR *fillc = r->IM_SUFFIX(fill_line);
 303       i_img_dim work_width = width;
 304       while (work_width) {
 305         if (*srcc == 0) {
 306           fillc->channel[fill_channels-1] = 0;
 307         }
 308         else if (*srcc != 255) {
 309           fillc->channel[fill_channels-1] =
 310             fillc->channel[fill_channels-1] * *srcc / 255;
 311         }
 312         --work_width;
 313         ++srcc;
 314         ++fillc;
 315       }
 316     }
 317     IM_GLIN(r->im, x, x+width, y, r->IM_SUFFIX(line));
 318     IM_FILL_COMBINE(fill)(destc, srcc, r->im->channels, width);
 319   }
 320   else {
 321     if (src) {
 322       i_img_dim work_width = width;
 323       IM_COLOR *srcc = r->IM_SUFFIX(fill_line);
 324       IM_COLOR *destc = r->IM_SUFFIX(line);
 325       int ch;
 326
 327       IM_FILL_FILLER(fill)(fill, x, y, width, fill_channels, r->IM_SUFFIX(fill_line));
 328       IM_GLIN(r->im, x, x+width, y, r->IM_SUFFIX(line));
 329       while (work_width) {
 330         if (*src == 255) {
 331           /* just replace it */
 332           *destc = *srcc;
 333         }
 334         else if (*src) {
 335           for (ch = 0; ch < im->channels; ++ch) {
 336             IM_WORK_T work = (destc->channel[ch] * (255 - *src)
 337                               + srcc->channel[ch] * *src) / 255.0;
 338             destc->channel[ch] = IM_LIMIT(work);
 339           }
 340         }
 341
 342         ++srcc;
 343         ++destc;
 344         ++src;
 345         --work_width;
 346       }
 347     }
 348     else { /* if (src) */
 349       IM_FILL_FILLER(fill)(fill, x, y, width, fill_channels, r->IM_SUFFIX(line));
 350     }
 351   }
 352   IM_PLIN(im, x, x+width, y, r->IM_SUFFIX(line));
 353 #/code
 354 }
 355
 356 #if 0
 357
 358 /* for debuggin */
 359
 360 static void
 361 dump_src(const char *note, unsigned char const *src, i_img_dim width) {
 362   i_img_dim i;
 363   printf("%s - %p/%" i_DF "\n", note, src, i_DFc(width));
 364   for (i = 0; i < width; ++i) {
 365     printf("%02x ", src[i]);
 366   }
 367   putchar('\n');
 368 }
 369
 370 #endif
 371
 372 #code
 373
 374 /*
 375 =item i_render_line(r, x, y, width, source, fill)
 376 =category Blit tools
 377
 378 Render the given fill with the coverage in C<source[0]> through
 379 C<source[width-1]>.
 380
 381 =cut
 382
 383 =item i_render_linef(r, x, y, width, source, fill)
 384 =category Blit tools
 385
 386 Render the given fill with the coverage in C<source[0]> through
 387 C<source[width-1]>.
 388
 389 =cut
 390 */
 391
 392 void
 393 IM_RENDER_LINE(i_render *r, i_img_dim x, i_img_dim y, i_img_dim width,
 394                const IM_SAMPLE_T *src, IM_COLOR *line,
 395                IM_FILL_COMBINE_F combine) {
 396   i_img *im = r->im;
 397   int src_chans = im->channels;
 398
 399   /* src must always have an alpha channel */
 400   if (src_chans == 1 || src_chans == 3)
 401     ++src_chans;
 402
 403   if (y < 0 || y >= im->ysize)
 404     return;
 405   if (x < 0) {
 406     src -= x;
 407     line -= x;
 408     width += x;
 409     x = 0;
 410   }
 411   if (x + width > im->xsize)
 412     width = r->im->xsize - x;
 413
 414 #ifdef IM_EIGHT_BIT
 415   alloc_line(r, width, 1);
 416 #else
 417   alloc_line(r, width, 0);
 418 #endif
 419
 420   if (combine) {
 421     if (src) {
 422       i_img_dim work_width = width;
 423       IM_COLOR *linep = line;
 424       const IM_SAMPLE_T *srcp = src;
 425       int alpha_chan = src_chans - 1;
 426
 427       while (work_width) {
 428         if (*srcp) {
 429           if (*srcp != IM_SAMPLE_MAX)
 430             linep->channel[alpha_chan] =
 431               linep->channel[alpha_chan] * *srcp / IM_SAMPLE_MAX;
 432         }
 433         else {
 434           linep->channel[alpha_chan] = 0;
 435         }
 436         --work_width;
 437         ++srcp;
 438         ++linep;
 439       }
 440     }
 441     IM_GLIN(im, x, x+width, y, r->IM_SUFFIX(line));
 442     combine(r->IM_SUFFIX(line), line, im->channels, width);
 443     IM_PLIN(im, x, x+width, y, r->IM_SUFFIX(line));
 444   }
 445   else {
 446     if (src) {
 447       i_img_dim work_width = width;
 448       IM_COLOR *srcc = line;
 449       IM_COLOR *destc = r->IM_SUFFIX(line);
 450
 451       IM_GLIN(im, x, x+width, y, r->IM_SUFFIX(line));
 452       while (work_width) {
 453         if (*src == 255) {
 454           /* just replace it */
 455           *destc = *srcc;
 456         }
 457         else if (*src) {
 458           int ch;
 459           for (ch = 0; ch < im->channels; ++ch) {
 460             IM_WORK_T work = (destc->channel[ch] * (IM_SAMPLE_MAX - *src)
 461                               + srcc->channel[ch] * *src) / IM_SAMPLE_MAX;
 462             destc->channel[ch] = IM_LIMIT(work);
 463           }
 464         }
 465
 466         ++srcc;
 467         ++destc;
 468         ++src;
 469         --work_width;
 470       }
 471       IM_PLIN(im, x, x+width, y, r->IM_SUFFIX(line));
 472     }
 473     else {
 474       IM_PLIN(im, x, x+width, y, line);
 475     }
 476   }
 477 }
 478
 479 static
 480 void
 481 IM_SUFFIX(render_color_13)(i_render *r, i_img_dim x, i_img_dim y,
 482                            i_img_dim width, unsigned char const *src,
 483                            i_color const *color) {
 484   i_img *im = r->im;
 485   IM_COLOR *linep = r->IM_SUFFIX(line);
 486   int ch, channels = im->channels;
 487   i_img_dim fetch_offset;
 488   int color_alpha = color->channel[im->channels];
 489 #undef STORE_COLOR
 490 #ifdef IM_EIGHT_BIT
 491 #define STORE_COLOR (*color)
 492 #else
 493   i_fcolor fcolor;
 494
 495   for (ch = 0; ch < channels; ++ch) {
 496     fcolor.channel[ch] = color->channel[ch] / 255.0;
 497   }
 498 #define STORE_COLOR fcolor
 499 #endif
 500
 501   fetch_offset = 0;
 502   if (color_alpha == 0xFF) {
 503     while (fetch_offset < width && *src == 0xFF) {
 504       *linep++ = STORE_COLOR;
 505       ++src;
 506       ++fetch_offset;
 507     }
 508   }
 509   IM_GLIN(im, x+fetch_offset, x+width, y, linep);
 510   while (fetch_offset < width) {
 511 #ifdef IM_EIGHT_BIT
 512     IM_WORK_T alpha = *src++ * color_alpha / 255;
 513 #else
 514     IM_WORK_T alpha = *src++ * color_alpha / (255.0 * 255.0);
 515 #endif
 516     if (alpha == IM_SAMPLE_MAX)
 517       *linep = STORE_COLOR;
 518     else if (alpha) {
 519       for (ch = 0; ch < channels; ++ch) {
 520         linep->channel[ch] = (linep->channel[ch] * (IM_SAMPLE_MAX - alpha)
 521                               + STORE_COLOR.channel[ch] * alpha) / IM_SAMPLE_MAX;
 522       }
 523     }
 524     ++linep;
 525     ++fetch_offset;
 526   }
 527   IM_PLIN(im, x, x+width, y, r->IM_SUFFIX(line));
 528 }
 529
 530 static
 531 void
 532 IM_SUFFIX(render_color_alpha)(i_render *r, i_img_dim x, i_img_dim y,
 533                               i_img_dim width, unsigned char const *src,
 534                               i_color const *color) {
 535   IM_COLOR *linep = r->IM_SUFFIX(line);
 536   int ch;
 537   int alpha_channel = r->im->channels - 1;
 538   i_img_dim fetch_offset;
 539   int color_alpha = color->channel[alpha_channel];
 540 #undef STORE_COLOR
 541 #ifdef IM_EIGHT_BIT
 542 #define STORE_COLOR (*color)
 543 #else
 544   i_fcolor fcolor;
 545
 546   for (ch = 0; ch < r->im->channels; ++ch) {
 547     fcolor.channel[ch] = color->channel[ch] / 255.0;
 548   }
 549 #define STORE_COLOR fcolor
 550 #endif
 551
 552   fetch_offset = 0;
 553   if (color->channel[alpha_channel] == 0xFF) {
 554     while (fetch_offset < width && *src == 0xFF) {
 555       *linep++ = STORE_COLOR;
 556       ++src;
 557       ++fetch_offset;
 558     }
 559   }
 560   IM_GLIN(r->im, x+fetch_offset, x+width, y, linep);
 561   while (fetch_offset < width) {
 562 #ifdef IM_EIGHT_BIT
 563     IM_WORK_T src_alpha = *src++ * color_alpha / 255;
 564 #else
 565     IM_WORK_T src_alpha = *src++ * color_alpha / (255.0 * 255.0);
 566 #endif
 567     if (src_alpha == IM_SAMPLE_MAX)
 568       *linep = STORE_COLOR;
 569     else if (src_alpha) {
 570       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 571       IM_WORK_T orig_alpha = linep->channel[alpha_channel];
 572       IM_WORK_T dest_alpha = src_alpha + (remains * orig_alpha) / IM_SAMPLE_MAX;
 573       for (ch = 0; ch < alpha_channel; ++ch) {
 574         linep->channel[ch] = ( src_alpha * STORE_COLOR.channel[ch]
 575                                + remains * linep->channel[ch] * orig_alpha / IM_SAMPLE_MAX
 576                                ) / dest_alpha;
 577       }
 578       linep->channel[alpha_channel] = dest_alpha;
 579     }
 580     ++linep;
 581     ++fetch_offset;
 582   }
 583   IM_PLIN(r->im, x, x+width, y, r->IM_SUFFIX(line));
 584 #undef STORE_COLOR
 585 }
 586
 587 /* combine a line of image data with an output line, both the input
 588    and output lines include an alpha channel.
 589
 590    Both input and output lines have I<channels> of data, channels
 591    should be either 2 or 4.
 592 */
 593
 594 static void
 595 IM_SUFFIX(combine_line_alpha)(IM_COLOR *out, IM_COLOR const *in,
 596                               int channels, i_img_dim count) {
 597   int ch;
 598   int alpha_channel = channels - 1;
 599
 600   while (count) {
 601     IM_WORK_T src_alpha = in->channel[alpha_channel];
 602
 603     if (src_alpha == IM_SAMPLE_MAX)
 604       *out = *in;
 605     else if (src_alpha) {
 606       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 607       IM_WORK_T orig_alpha = out->channel[alpha_channel];
 608       IM_WORK_T dest_alpha = src_alpha + (remains * orig_alpha) / IM_SAMPLE_MAX;
 609
 610       for (ch = 0; ch < alpha_channel; ++ch) {
 611         out->channel[ch] = ( src_alpha * in->channel[ch]
 612                              + remains * out->channel[ch] * orig_alpha / IM_SAMPLE_MAX
 613                              ) / dest_alpha;
 614       }
 615       out->channel[alpha_channel] = dest_alpha;
 616     }
 617
 618     ++out;
 619     ++in;
 620     --count;
 621   }
 622 }
 623
 624 /* combine a line of image data with an output line.  The input line
 625    includes an alpha channel, the output line has no alpha channel.
 626
 627    The input line has I<channels>+1 of color data.  The output line
 628    has I<channels> of color data.
 629 */
 630
 631 static void
 632 IM_SUFFIX(combine_line_noalpha)
 633      (IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count) {
 634   int ch;
 635
 636   while (count) {
 637     IM_WORK_T src_alpha = in->channel[channels];
 638
 639     if (src_alpha == IM_SAMPLE_MAX)
 640       *out = *in;
 641     else if (src_alpha) {
 642       IM_WORK_T remains;
 643
 644       remains = IM_SAMPLE_MAX - src_alpha;
 645       for (ch = 0; ch < channels; ++ch) {
 646         out->channel[ch] = ( in->channel[ch] * src_alpha
 647                              + out->channel[ch] * remains) / IM_SAMPLE_MAX;
 648       }
 649     }
 650
 651     ++out;
 652     ++in;
 653     --count;
 654   }
 655 }
 656
 657 /* combine a line of image data with an output line, both the input
 658    and output lines include an alpha channel.
 659
 660    Both input and output lines have I<channels> of data, channels
 661    should be either 2 or 4.
 662
 663    This variant does not modify the output alpha channel.
 664 */
 665
 666 static void
 667 IM_SUFFIX(combine_line_alpha_na)(IM_COLOR *out, IM_COLOR const *in,
 668                                    int channels, i_img_dim count) {
 669   int ch;
 670   int alpha_channel = channels - 1;
 671
 672   while (count) {
 673     IM_WORK_T src_alpha = in->channel[alpha_channel];
 674
 675     if (src_alpha == IM_SAMPLE_MAX)
 676       *out = *in;
 677     else if (src_alpha) {
 678       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 679       IM_WORK_T orig_alpha = out->channel[alpha_channel];
 680       IM_WORK_T dest_alpha = src_alpha + (remains * orig_alpha) / IM_SAMPLE_MAX;
 681
 682       for (ch = 0; ch < alpha_channel; ++ch) {
 683         out->channel[ch] = ( src_alpha * in->channel[ch]
 684                              + remains * out->channel[ch] * orig_alpha / IM_SAMPLE_MAX
 685                              ) / dest_alpha;
 686       }
 687     }
 688
 689     ++out;
 690     ++in;
 691     --count;
 692   }
 693 }
 694
 695 static void
 696 IM_SUFFIX(combine_line)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count) {
 697   if (channels == 2 || channels == 4)
 698     IM_SUFFIX(combine_line_alpha)(out, in, channels, count);
 699   else
 700     IM_SUFFIX(combine_line_noalpha)(out, in, channels, count);
 701 }
 702
 703 static void
 704 IM_SUFFIX(combine_line_na)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count) {
 705   if (channels == 2 || channels == 4)
 706     IM_SUFFIX(combine_line_alpha_na)(out, in, channels, count);
 707   else
 708     IM_SUFFIX(combine_line_noalpha)(out, in, channels, count);
 709 }
 710
 711 static void IM_SUFFIX(combine_alphablend)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 712 static void IM_SUFFIX(combine_mult)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 713 static void IM_SUFFIX(combine_dissolve)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 714 static void IM_SUFFIX(combine_add)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 715 static void IM_SUFFIX(combine_subtract)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 716 static void IM_SUFFIX(combine_diff)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 717 static void IM_SUFFIX(combine_darken)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 718 static void IM_SUFFIX(combine_lighten)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 719 static void IM_SUFFIX(combine_hue)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 720 static void IM_SUFFIX(combine_sat)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 721 static void IM_SUFFIX(combine_value)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 722 static void IM_SUFFIX(combine_color)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 723
 724 static const IM_FILL_COMBINE_F IM_SUFFIX(combines)[] =
 725 {
 726   NULL,
 727   IM_SUFFIX(combine_alphablend),
 728   IM_SUFFIX(combine_mult),
 729   IM_SUFFIX(combine_dissolve),
 730   IM_SUFFIX(combine_add),
 731   IM_SUFFIX(combine_subtract),
 732   IM_SUFFIX(combine_diff),
 733   IM_SUFFIX(combine_lighten),
 734   IM_SUFFIX(combine_darken),
 735   IM_SUFFIX(combine_hue),
 736   IM_SUFFIX(combine_sat),
 737   IM_SUFFIX(combine_value),
 738   IM_SUFFIX(combine_color)
 739 };
 740
 741 #/code
 742
 743 /*
 744 =item i_get_combine(combine, color_func, fcolor_func)
 745
 746 =cut
 747 */
 748
 749 void i_get_combine(int combine, i_fill_combine_f *color_func,
 750                    i_fill_combinef_f *fcolor_func) {
 751   if (combine < 0 || combine >= sizeof(combines_8) / sizeof(*combines_8))
 752     combine = 0;
 753
 754   *color_func = combines_8[combine];
 755   *fcolor_func = combines_double[combine];
 756 }
 757
 758 #code
 759
 760 /*
 761   Three good references for implementing combining modes:
 762
 763   http://www.w3.org/TR/2004/WD-SVG12-20041027/rendering.html
 764   referenced as [svg1.2]
 765
 766   http://gimp-savvy.com/BOOK/index.html?node55.html
 767   ("The Blending Modes", if it changes)
 768   referenced as [savvy]
 769
 770   http://www.pegtop.net/delphi/articles/blendmodes/
 771   referenced as [pegtop]
 772
 773   Where differences exist, I follow the SVG practice, the gimp
 774   practice, and lastly pegtop.
 775 */
 776
 777
 778 static void
 779 IM_SUFFIX(combine_alphablend)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 780   IM_SUFFIX(combine_line)(out, in, channels, count);
 781 }
 782
 783 /*
 784 Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
 785 Da'  = Sa.Da + Sa.(1 - Da) + Da.(1 - Sa)
 786      = Sa + Da - Sa.Da
 787
 788 When Da=1
 789
 790 Dc' = Sc.Sa.Dc + Dc.(1 - Sa)
 791  */
 792 static void
 793 IM_SUFFIX(combine_mult)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 794   int ch;
 795   IM_COLOR *inp = in;
 796   IM_COLOR *outp = out;
 797   i_img_dim work_count = count;
 798   int color_channels = i_color_channels(channels);
 799
 800   if (i_has_alpha(channels)) {
 801     while (work_count--) {
 802       IM_WORK_T orig_alpha = outp->channel[color_channels];
 803       IM_WORK_T src_alpha = inp->channel[color_channels];
 804
 805       if (src_alpha) {
 806         IM_WORK_T dest_alpha = src_alpha + orig_alpha
 807           - (src_alpha * orig_alpha) / IM_SAMPLE_MAX;
 808
 809         for (ch = 0; ch < color_channels; ++ch) {
 810           outp->channel[ch] =
 811             (inp->channel[ch] * src_alpha * outp->channel[ch] / IM_SAMPLE_MAX
 812              * orig_alpha
 813              + inp->channel[ch] * src_alpha * (IM_SAMPLE_MAX - orig_alpha)
 814              + outp->channel[ch] * orig_alpha * (IM_SAMPLE_MAX - src_alpha))
 815             / IM_SAMPLE_MAX / dest_alpha;
 816         }
 817         outp->channel[color_channels] = dest_alpha;
 818       }
 819       ++outp;
 820       ++inp;
 821     }
 822   }
 823   else {
 824     while (work_count--) {
 825       IM_WORK_T src_alpha = inp->channel[color_channels];
 826       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 827
 828       if (src_alpha) {
 829         for (ch = 0; ch < color_channels; ++ch) {
 830           outp->channel[ch] =
 831             (src_alpha * inp->channel[ch] * outp->channel[ch] / IM_SAMPLE_MAX
 832              + outp->channel[ch] * remains) / IM_SAMPLE_MAX;
 833         }
 834       }
 835       ++outp;
 836       ++inp;
 837     }
 838   }
 839 }
 840
 841 static void
 842 IM_SUFFIX(combine_dissolve)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 843   int color_channels = i_color_channels(channels);
 844   int ch;
 845
 846   if (i_has_alpha(channels)) {
 847     while (count--) {
 848       if (in->channel[channels-1] > rand() * ((double)IM_SAMPLE_MAX / RAND_MAX)) {
 849         for (ch = 0; ch < color_channels; ++ch) {
 850           out->channel[ch] = in->channel[ch];
 851         }
 852         out->channel[color_channels] = IM_SAMPLE_MAX;
 853       }
 854       ++out;
 855       ++in;
 856     }
 857   }
 858   else {
 859     while (count--) {
 860       if (in->channel[channels] > rand() * ((double)IM_SAMPLE_MAX / RAND_MAX)) {
 861         for (ch = 0; ch < color_channels; ++ch) {
 862           out->channel[ch] = in->channel[ch];
 863         }
 864       }
 865       ++out;
 866       ++in;
 867     }
 868   }
 869 }
 870
 871 /*
 872 Dca' = Sca.Da + Dca.Sa + Sca.(1 - Da) + Dca.(1 - Sa)
 873      = Sca + Dca
 874 Da'  = Sa.Da + Da.Sa + Sa.(1 - Da) + Da.(1 - Sa)
 875      = Sa + Da
 876 */
 877
 878 static void
 879 IM_SUFFIX(combine_add)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 880   int ch;
 881   int color_channels = i_color_channels(channels);
 882   i_img_dim work_count = count;
 883   IM_COLOR *inp = in;
 884   IM_COLOR *outp = out;
 885
 886   if (i_has_alpha(channels)) {
 887     while (work_count--) {
 888       IM_WORK_T src_alpha = inp->channel[color_channels];
 889       if (src_alpha) {
 890         IM_WORK_T orig_alpha = outp->channel[color_channels];
 891         IM_WORK_T dest_alpha = src_alpha + orig_alpha;
 892         if (dest_alpha > IM_SAMPLE_MAX)
 893           dest_alpha = IM_SAMPLE_MAX;
 894         for (ch = 0; ch < color_channels; ++ch) {
 895           IM_WORK_T total = (outp->channel[ch] * orig_alpha + inp->channel[ch] * src_alpha) / dest_alpha;
 896           if (total > IM_SAMPLE_MAX)
 897             total = IM_SAMPLE_MAX;
 898           outp->channel[ch] = total;
 899         }
 900         outp->channel[color_channels] = dest_alpha;
 901       }
 902
 903       ++outp;
 904       ++inp;
 905     }
 906   }
 907   else {
 908     while (work_count--) {
 909       IM_WORK_T src_alpha = inp->channel[color_channels];
 910       if (src_alpha) {
 911         for (ch = 0; ch < color_channels; ++ch) {
 912           IM_WORK_T total = outp->channel[ch] + inp->channel[ch] * src_alpha / IM_SAMPLE_MAX;
 913           if (total > IM_SAMPLE_MAX)
 914             total = IM_SAMPLE_MAX;
 915           outp->channel[ch] = total;
 916         }
 917       }
 918
 919       ++outp;
 920       ++inp;
 921     }
 922   }
 923 }
 924
 925 /*
 926    [pegtop] documents this as max(A+B-256, 0) while [savvy] documents
 927    it as max(A-B, 0). [svg1.2] doesn't cover it.
 928
 929    [savvy] doesn't document how it works with an alpha channel.  GIMP
 930    actually seems to calculate the final value then use the alpha
 931    channel to apply that to the target.
 932  */
 933 static void
 934 IM_SUFFIX(combine_subtract)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 935   int ch;
 936   IM_COLOR const *inp = in;
 937   IM_COLOR *outp = out;
 938   i_img_dim work_count = count;
 939   int color_channels = i_color_channels(channels);
 940
 941   if (i_has_alpha(channels)) {
 942     while (work_count--) {
 943       IM_WORK_T src_alpha = inp->channel[color_channels];
 944       if (src_alpha) {
 945         IM_WORK_T orig_alpha = outp->channel[color_channels];
 946         IM_WORK_T dest_alpha = src_alpha + orig_alpha;
 947         if (dest_alpha > IM_SAMPLE_MAX)
 948           dest_alpha = IM_SAMPLE_MAX;
 949         for (ch = 0; ch < color_channels; ++ch) {
 950           IM_WORK_T total =
 951             (outp->channel[ch] * orig_alpha - inp->channel[ch] * src_alpha)
 952             / dest_alpha;
 953           if (total < 0)
 954             total = 0;
 955           outp->channel[ch] = total;
 956         }
 957         outp->channel[color_channels] = dest_alpha;
 958       }
 959       ++outp;
 960       ++inp;
 961     }
 962   }
 963   else {
 964     while (work_count--) {
 965       IM_WORK_T src_alpha = inp->channel[color_channels];
 966       if (src_alpha) {
 967         for (ch = 0; ch < color_channels; ++ch) {
 968           IM_WORK_T total = outp->channel[ch] - inp->channel[ch] * src_alpha / IM_SAMPLE_MAX;
 969           if (total < 0)
 970             total = 0;
 971           outp->channel[ch] = total;
 972         }
 973       }
 974       ++outp;
 975       ++inp;
 976     }
 977   }
 978 }
 979
 980 #ifdef IM_EIGHT_BIT
 981 #define IM_abs(x) abs(x)
 982 #else
 983 #define IM_abs(x) fabs(x)
 984 #endif
 985
 986 /*
 987 Dca' = abs(Dca.Sa - Sca.Da) + Sca.(1 - Da) + Dca.(1 - Sa)
 988      = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
 989 Da'  = Sa + Da - Sa.Da
 990 */
 991 static void
 992 IM_SUFFIX(combine_diff)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 993   int ch;
 994   IM_COLOR const *inp = in;
 995   IM_COLOR *outp = out;
 996   i_img_dim work_count = count;
 997   int color_channels = i_color_channels(channels);
 998
 999   if (i_has_alpha(channels)) {
1000     while (work_count--) {
1001       IM_WORK_T src_alpha = inp->channel[color_channels];
1002       if (src_alpha) {
1003         IM_WORK_T orig_alpha = outp->channel[color_channels];
1004         IM_WORK_T dest_alpha = src_alpha + orig_alpha
1005           - src_alpha * orig_alpha / IM_SAMPLE_MAX;
1006         for (ch = 0; ch < color_channels; ++ch) {
1007           IM_WORK_T src = inp->channel[ch] * src_alpha;
1008           IM_WORK_T orig = outp->channel[ch] * orig_alpha;
1009           IM_WORK_T src_da = src * orig_alpha;
1010           IM_WORK_T dest_sa = orig * src_alpha;
1011           IM_WORK_T diff = src_da < dest_sa ? src_da : dest_sa;
1012           outp->channel[ch] = (src + orig - 2 * diff / IM_SAMPLE_MAX) / dest_alpha;
1013         }
1014         outp->channel[color_channels] = dest_alpha;
1015       }
1016       ++inp;
1017       ++outp;
1018     }
1019   }
1020   else {
1021     while (work_count--) {
1022       IM_WORK_T src_alpha = inp->channel[color_channels];
1023       if (src_alpha) {
1024         for (ch = 0; ch < color_channels; ++ch) {
1025           IM_WORK_T src = inp->channel[ch] * src_alpha;
1026           IM_WORK_T orig = outp->channel[ch] * IM_SAMPLE_MAX;
1027           IM_WORK_T src_da = src * IM_SAMPLE_MAX;
1028           IM_WORK_T dest_sa = orig * src_alpha;
1029           IM_WORK_T diff = src_da < dest_sa ? src_da : dest_sa;
1030           outp->channel[ch] = (src + orig - 2 * diff / IM_SAMPLE_MAX) / IM_SAMPLE_MAX;
1031         }
1032       }
1033       ++inp;
1034       ++outp;
1035     }
1036   }
1037 }
1038
1039 #undef IM_abs
1040
1041 /*
1042   Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca(1 - Sa)
1043   Da' = Sa + Da - Sa.Da
1044
1045   To hoist some code:
1046
1047   Dca' = min(Sc.Sa.Da, Dc.Da.Sa) + Sca - Sca.Da + Dca - Dca.Sa
1048        = Sa.Da.min(Sc, Dc) + Sca - Sca.Da + Dca - Dca.Sa
1049
1050   When Da=1:
1051
1052   Dca' = min(Sca.1, Dc.1.Sa) + Sca.(1 - 1) + Dc.1(1 - Sa)
1053        = min(Sca, Dc.Sa) + Dc(1-Sa)
1054        = Sa.min(Sc, Dc) + Dc - Dc.Sa
1055   Da'  = Sa + 1 - Sa.1
1056        = 1
1057  */
1058 static void
1059 IM_SUFFIX(combine_darken)(IM_COLOR *out, IM_COLOR *in, int channels,
1060                           i_img_dim count) {
1061   int ch;
1062   IM_COLOR const *inp = in;
1063   IM_COLOR *outp = out;
1064   i_img_dim work_count = count;
1065   int color_channels = i_color_channels(channels);
1066
1067   if (i_has_alpha(channels)) {
1068     while (work_count--) {
1069       IM_WORK_T src_alpha = inp->channel[color_channels];
1070
1071       if (src_alpha) {
1072         IM_WORK_T orig_alpha = outp->channel[color_channels];
1073         IM_WORK_T dest_alpha = src_alpha + orig_alpha
1074           - src_alpha * orig_alpha / IM_SAMPLE_MAX;
1075         for (ch = 0; ch < color_channels; ++ch) {
1076           IM_WORK_T Sca = inp->channel[ch] * src_alpha;
1077           IM_WORK_T Dca = outp->channel[ch] * orig_alpha;
1078           IM_WORK_T ScaDa = Sca * orig_alpha;
1079           IM_WORK_T DcaSa = Dca * src_alpha;
1080           IM_WORK_T minc = ScaDa < DcaSa ? ScaDa : DcaSa;
1081           outp->channel[ch] =
1082             (
1083              minc + (Sca + Dca) * IM_SAMPLE_MAX
1084              - ScaDa - DcaSa
1085              ) / (IM_SAMPLE_MAX * dest_alpha);
1086         }
1087         outp->channel[color_channels] = dest_alpha;
1088       }
1089       ++outp;
1090       ++inp;
1091     }
1092   }
1093   else {
1094     while (work_count--) {
1095       IM_WORK_T src_alpha = inp->channel[color_channels];
1096
1097       if (src_alpha) {
1098         for (ch = 0; ch < color_channels; ++ch) {
1099           IM_WORK_T minc = outp->channel[ch] < inp->channel[ch]
1100             ? outp->channel[ch] : inp->channel[ch];
1101           outp->channel[ch] =
1102             (
1103              src_alpha * minc +
1104              outp->channel[ch] * ( IM_SAMPLE_MAX - src_alpha )
1105              ) / IM_SAMPLE_MAX;
1106         }
1107       }
1108       ++outp;
1109       ++inp;
1110     }
1111   }
1112 }
1113
1114 static void
1115 IM_SUFFIX(combine_lighten)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1116   int ch;
1117   IM_COLOR const *inp = in;
1118   IM_COLOR *outp = out;
1119   i_img_dim work_count = count;
1120   int color_channels = i_color_channels(channels);
1121
1122   if (i_has_alpha(channels)) {
1123     while (work_count--) {
1124       IM_WORK_T src_alpha = inp->channel[color_channels];
1125
1126       if (src_alpha) {
1127         IM_WORK_T orig_alpha = outp->channel[color_channels];
1128         IM_WORK_T dest_alpha = src_alpha + orig_alpha
1129           - src_alpha * orig_alpha / IM_SAMPLE_MAX;
1130         for (ch = 0; ch < color_channels; ++ch) {
1131           IM_WORK_T Sca = inp->channel[ch] * src_alpha;
1132           IM_WORK_T Dca = outp->channel[ch] * orig_alpha;
1133           IM_WORK_T ScaDa = Sca * orig_alpha;
1134           IM_WORK_T DcaSa = Dca * src_alpha;
1135           IM_WORK_T maxc = ScaDa > DcaSa ? ScaDa : DcaSa;
1136           outp->channel[ch] =
1137             (
1138              maxc + (Sca + Dca) * IM_SAMPLE_MAX
1139              - ScaDa - DcaSa
1140              ) / (IM_SAMPLE_MAX * dest_alpha);
1141         }
1142         outp->channel[color_channels] = dest_alpha;
1143       }
1144       ++outp;
1145       ++inp;
1146     }
1147   }
1148   else {
1149     while (work_count--) {
1150       IM_WORK_T src_alpha = inp->channel[color_channels];
1151
1152       if (src_alpha) {
1153         for (ch = 0; ch < color_channels; ++ch) {
1154           IM_WORK_T maxc = outp->channel[ch] > inp->channel[ch]
1155             ? outp->channel[ch] : inp->channel[ch];
1156           outp->channel[ch] =
1157             (
1158              src_alpha * maxc +
1159              outp->channel[ch] * ( IM_SAMPLE_MAX - src_alpha )
1160              ) / IM_SAMPLE_MAX;
1161         }
1162       }
1163       ++outp;
1164       ++inp;
1165     }
1166   }
1167 }
1168
1169 #if IM_EIGHT_BIT
1170 #define IM_RGB_TO_HSV i_rgb_to_hsv
1171 #define IM_HSV_TO_RGB i_hsv_to_rgb
1172 #else
1173 #define IM_RGB_TO_HSV i_rgb_to_hsvf
1174 #define IM_HSV_TO_RGB i_hsv_to_rgbf
1175 #endif
1176
1177 static void
1178 IM_SUFFIX(combine_hue)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1179   if (channels > 2) {
1180     IM_COLOR *inp = in;
1181     IM_COLOR const *outp = out;
1182     i_img_dim work_count = count;
1183
1184     if (i_has_alpha(channels)) {
1185       while (work_count--) {
1186         IM_COLOR c = *inp;
1187         IM_RGB_TO_HSV(&c);
1188         /* only transfer hue if there's saturation */
1189         if (c.channel[1] && inp->channel[3] && outp->channel[3]) {
1190           *inp = *outp;
1191           IM_RGB_TO_HSV(inp);
1192           /* and no point in setting the target hue if the target has no sat */
1193           if (inp->channel[1]) {
1194             inp->channel[0] = c.channel[0];
1195             IM_HSV_TO_RGB(inp);
1196             inp->channel[3] = c.channel[3];
1197           }
1198           else {
1199             inp->channel[3] = 0;
1200           }
1201         }
1202         else {
1203           inp->channel[3] = 0;
1204         }
1205
1206         ++outp;
1207         ++inp;
1208       }
1209     }
1210     else {
1211       while (work_count--) {
1212         IM_COLOR c = *inp;
1213         IM_RGB_TO_HSV(&c);
1214         /* only transfer hue if there's saturation */
1215         if (c.channel[1] && inp->channel[3]) {
1216           *inp = *outp;
1217           IM_RGB_TO_HSV(inp);
1218           /* and no point in setting the target hue if the target has no sat */
1219           if (inp->channel[1]) {
1220             inp->channel[0] = c.channel[0];
1221             IM_HSV_TO_RGB(inp);
1222             inp->channel[3] = c.channel[3];
1223           }
1224         }
1225         else {
1226           inp->channel[3] = 0;
1227         }
1228
1229         ++outp;
1230         ++inp;
1231       }
1232     }
1233
1234     IM_SUFFIX(combine_line_na)(out, in, channels, count);
1235   }
1236 }
1237
1238 static void
1239 IM_SUFFIX(combine_sat)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1240   if (channels > 2) {
1241     IM_COLOR *inp = in;
1242     IM_COLOR const *outp = out;
1243     i_img_dim work_count = count;
1244
1245     while (work_count--) {
1246       IM_COLOR c = *inp;
1247       *inp = *outp;
1248       IM_RGB_TO_HSV(&c);
1249       IM_RGB_TO_HSV(inp);
1250       inp->channel[1] = c.channel[1];
1251       IM_HSV_TO_RGB(inp);
1252       inp->channel[3] = c.channel[3];
1253       ++outp;
1254       ++inp;
1255     }
1256
1257     IM_SUFFIX(combine_line_na)(out, in, channels, count);
1258   }
1259 }
1260
1261 static void
1262 IM_SUFFIX(combine_value)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1263   if (channels > 2) {
1264     IM_COLOR *inp = in;
1265     IM_COLOR const *outp = out;
1266     i_img_dim work_count = count;
1267
1268     while (work_count--) {
1269       IM_COLOR c = *inp;
1270       *inp = *outp;
1271       IM_RGB_TO_HSV(&c);
1272       IM_RGB_TO_HSV(inp);
1273       inp->channel[2] = c.channel[2];
1274       IM_HSV_TO_RGB(inp);
1275       inp->channel[3] = c.channel[3];
1276       ++outp;
1277       ++inp;
1278     }
1279   }
1280
1281   /* all images have a "value channel" - for greyscale it's the only
1282      colour channel */
1283   IM_SUFFIX(combine_line_na)(out, in, channels, count);
1284 }
1285
1286 static void
1287 IM_SUFFIX(combine_color)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1288   if (channels > 2) {
1289     IM_COLOR *inp = in;
1290     IM_COLOR const *outp = out;
1291     i_img_dim work_count = count;
1292
1293     while (work_count--) {
1294       IM_COLOR c = *inp;
1295       *inp = *outp;
1296       IM_RGB_TO_HSV(&c);
1297       IM_RGB_TO_HSV(inp);
1298       inp->channel[0] = c.channel[0];
1299       inp->channel[1] = c.channel[1];
1300       IM_HSV_TO_RGB(inp);
1301       inp->channel[3] = c.channel[3];
1302       ++outp;
1303       ++inp;
1304     }
1305
1306     IM_SUFFIX(combine_line_na)(out, in, channels, count);
1307   }
1308 }
1309
1310 #undef IM_RGB_TO_HSV
1311 #undef IM_HSV_TO_RGB
1312
1313 #/code