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] * (IM_SAMPLE_MAX - *src)
 337                               + srcc->channel[ch] * *src) / IM_SAMPLE_MAX;
 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 #undef STORE_COLOR
 489 #ifdef IM_EIGHT_BIT
 490 #define STORE_COLOR (*color)
 491 #else
 492   i_fcolor fcolor;
 493
 494   for (ch = 0; ch < channels; ++ch) {
 495     fcolor.channel[ch] = color->channel[ch] / 255.0;
 496   }
 497 #define STORE_COLOR fcolor
 498 #endif
 499
 500   fetch_offset = 0;
 501   while (fetch_offset < width && *src == 0xFF) {
 502     *linep++ = STORE_COLOR;
 503     ++src;
 504     ++fetch_offset;
 505   }
 506   IM_GLIN(im, x+fetch_offset, x+width, y, linep);
 507   while (fetch_offset < width) {
 508 #ifdef IM_EIGHT_BIT
 509     IM_WORK_T alpha = *src++;
 510 #else
 511     IM_WORK_T alpha = *src++ / 255.0;
 512 #endif
 513     if (alpha == IM_SAMPLE_MAX)
 514       *linep = STORE_COLOR;
 515     else if (alpha) {
 516       for (ch = 0; ch < channels; ++ch) {
 517         linep->channel[ch] = (linep->channel[ch] * (IM_SAMPLE_MAX - alpha)
 518                               + STORE_COLOR.channel[ch] * alpha) / IM_SAMPLE_MAX;
 519       }
 520     }
 521     ++linep;
 522     ++fetch_offset;
 523   }
 524   IM_PLIN(im, x, x+width, y, r->IM_SUFFIX(line));
 525 }
 526
 527 static
 528 void
 529 IM_SUFFIX(render_color_alpha)(i_render *r, i_img_dim x, i_img_dim y,
 530                               i_img_dim width, unsigned char const *src,
 531                               i_color const *color) {
 532   IM_COLOR *linep = r->IM_SUFFIX(line);
 533   int ch;
 534   int alpha_channel = r->im->channels - 1;
 535   i_img_dim fetch_offset;
 536 #undef STORE_COLOR
 537 #ifdef IM_EIGHT_BIT
 538 #define STORE_COLOR (*color)
 539 #else
 540   i_fcolor fcolor;
 541
 542   for (ch = 0; ch < r->im->channels; ++ch) {
 543     fcolor.channel[ch] = color->channel[ch] / 255.0;
 544   }
 545 #define STORE_COLOR fcolor
 546 #endif
 547
 548   fetch_offset = 0;
 549   while (fetch_offset < width && *src == 0xFF) {
 550     *linep++ = STORE_COLOR;
 551     ++src;
 552     ++fetch_offset;
 553   }
 554   IM_GLIN(r->im, x+fetch_offset, x+width, y, linep);
 555   while (fetch_offset < width) {
 556 #ifdef IM_EIGHT_BIT
 557     IM_WORK_T src_alpha = *src++;
 558 #else
 559     IM_WORK_T src_alpha = *src++ / 255.0;
 560 #endif
 561     if (src_alpha == IM_SAMPLE_MAX)
 562       *linep = STORE_COLOR;
 563     else if (src_alpha) {
 564       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 565       IM_WORK_T orig_alpha = linep->channel[alpha_channel];
 566       IM_WORK_T dest_alpha = src_alpha + (remains * orig_alpha) / IM_SAMPLE_MAX;
 567       for (ch = 0; ch < alpha_channel; ++ch) {
 568         linep->channel[ch] = ( src_alpha * STORE_COLOR.channel[ch]
 569                                + remains * linep->channel[ch] * orig_alpha / IM_SAMPLE_MAX
 570                                ) / dest_alpha;
 571       }
 572       linep->channel[alpha_channel] = dest_alpha;
 573     }
 574     ++linep;
 575     ++fetch_offset;
 576   }
 577   IM_PLIN(r->im, x, x+width, y, r->IM_SUFFIX(line));
 578 #undef STORE_COLOR
 579 }
 580
 581 /* combine a line of image data with an output line, both the input
 582    and output lines include an alpha channel.
 583
 584    Both input and output lines have I<channels> of data, channels
 585    should be either 2 or 4.
 586 */
 587
 588 static void
 589 IM_SUFFIX(combine_line_alpha)(IM_COLOR *out, IM_COLOR const *in,
 590                               int channels, i_img_dim count) {
 591   int ch;
 592   int alpha_channel = channels - 1;
 593
 594   while (count) {
 595     IM_WORK_T src_alpha = in->channel[alpha_channel];
 596
 597     if (src_alpha == IM_SAMPLE_MAX)
 598       *out = *in;
 599     else if (src_alpha) {
 600       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 601       IM_WORK_T orig_alpha = out->channel[alpha_channel];
 602       IM_WORK_T dest_alpha = src_alpha + (remains * orig_alpha) / IM_SAMPLE_MAX;
 603
 604       for (ch = 0; ch < alpha_channel; ++ch) {
 605         out->channel[ch] = ( src_alpha * in->channel[ch]
 606                              + remains * out->channel[ch] * orig_alpha / IM_SAMPLE_MAX
 607                              ) / dest_alpha;
 608       }
 609       out->channel[alpha_channel] = dest_alpha;
 610     }
 611
 612     ++out;
 613     ++in;
 614     --count;
 615   }
 616 }
 617
 618 /* combine a line of image data with an output line.  The input line
 619    includes an alpha channel, the output line has no alpha channel.
 620
 621    The input line has I<channels>+1 of color data.  The output line
 622    has I<channels> of color data.
 623 */
 624
 625 static void
 626 IM_SUFFIX(combine_line_noalpha)
 627      (IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count) {
 628   int ch;
 629
 630   while (count) {
 631     IM_WORK_T src_alpha = in->channel[channels];
 632
 633     if (src_alpha == IM_SAMPLE_MAX)
 634       *out = *in;
 635     else if (src_alpha) {
 636       IM_WORK_T remains;
 637
 638       remains = IM_SAMPLE_MAX - src_alpha;
 639       for (ch = 0; ch < channels; ++ch) {
 640         out->channel[ch] = ( in->channel[ch] * src_alpha
 641                              + out->channel[ch] * remains) / IM_SAMPLE_MAX;
 642       }
 643     }
 644
 645     ++out;
 646     ++in;
 647     --count;
 648   }
 649 }
 650
 651 /* combine a line of image data with an output line, both the input
 652    and output lines include an alpha channel.
 653
 654    Both input and output lines have I<channels> of data, channels
 655    should be either 2 or 4.
 656
 657    This variant does not modify the output alpha channel.
 658 */
 659
 660 static void
 661 IM_SUFFIX(combine_line_alpha_na)(IM_COLOR *out, IM_COLOR const *in,
 662                                    int channels, i_img_dim count) {
 663   int ch;
 664   int alpha_channel = channels - 1;
 665
 666   while (count) {
 667     IM_WORK_T src_alpha = in->channel[alpha_channel];
 668
 669     if (src_alpha == IM_SAMPLE_MAX)
 670       *out = *in;
 671     else if (src_alpha) {
 672       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 673       IM_WORK_T orig_alpha = out->channel[alpha_channel];
 674       IM_WORK_T dest_alpha = src_alpha + (remains * orig_alpha) / IM_SAMPLE_MAX;
 675
 676       for (ch = 0; ch < alpha_channel; ++ch) {
 677         out->channel[ch] = ( src_alpha * in->channel[ch]
 678                              + remains * out->channel[ch] * orig_alpha / IM_SAMPLE_MAX
 679                              ) / dest_alpha;
 680       }
 681     }
 682
 683     ++out;
 684     ++in;
 685     --count;
 686   }
 687 }
 688
 689 static void
 690 IM_SUFFIX(combine_line)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count) {
 691   if (channels == 2 || channels == 4)
 692     IM_SUFFIX(combine_line_alpha)(out, in, channels, count);
 693   else
 694     IM_SUFFIX(combine_line_noalpha)(out, in, channels, count);
 695 }
 696
 697 static void
 698 IM_SUFFIX(combine_line_na)(IM_COLOR *out, IM_COLOR const *in, int channels, i_img_dim count) {
 699   if (channels == 2 || channels == 4)
 700     IM_SUFFIX(combine_line_alpha_na)(out, in, channels, count);
 701   else
 702     IM_SUFFIX(combine_line_noalpha)(out, in, channels, count);
 703 }
 704
 705 static void IM_SUFFIX(combine_alphablend)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 706 static void IM_SUFFIX(combine_mult)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 707 static void IM_SUFFIX(combine_dissolve)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 708 static void IM_SUFFIX(combine_add)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 709 static void IM_SUFFIX(combine_subtract)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 710 static void IM_SUFFIX(combine_diff)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 711 static void IM_SUFFIX(combine_darken)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 712 static void IM_SUFFIX(combine_lighten)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 713 static void IM_SUFFIX(combine_hue)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 714 static void IM_SUFFIX(combine_sat)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 715 static void IM_SUFFIX(combine_value)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 716 static void IM_SUFFIX(combine_color)(IM_COLOR *, IM_COLOR *, int, i_img_dim);
 717
 718 static const IM_FILL_COMBINE_F IM_SUFFIX(combines)[] =
 719 {
 720   NULL,
 721   IM_SUFFIX(combine_alphablend),
 722   IM_SUFFIX(combine_mult),
 723   IM_SUFFIX(combine_dissolve),
 724   IM_SUFFIX(combine_add),
 725   IM_SUFFIX(combine_subtract),
 726   IM_SUFFIX(combine_diff),
 727   IM_SUFFIX(combine_lighten),
 728   IM_SUFFIX(combine_darken),
 729   IM_SUFFIX(combine_hue),
 730   IM_SUFFIX(combine_sat),
 731   IM_SUFFIX(combine_value),
 732   IM_SUFFIX(combine_color)
 733 };
 734
 735 #/code
 736
 737 /*
 738 =item i_get_combine(combine, color_func, fcolor_func)
 739
 740 =cut
 741 */
 742
 743 void i_get_combine(int combine, i_fill_combine_f *color_func,
 744                    i_fill_combinef_f *fcolor_func) {
 745   if (combine < 0 || combine > sizeof(combines_8) / sizeof(*combines_8))
 746     combine = 0;
 747
 748   *color_func = combines_8[combine];
 749   *fcolor_func = combines_double[combine];
 750 }
 751
 752 #code
 753
 754 /*
 755   Three good references for implementing combining modes:
 756
 757   http://www.w3.org/TR/2004/WD-SVG12-20041027/rendering.html
 758   referenced as [svg1.2]
 759
 760   http://gimp-savvy.com/BOOK/index.html?node55.html
 761   ("The Blending Modes", if it changes)
 762   referenced as [savvy]
 763
 764   http://www.pegtop.net/delphi/articles/blendmodes/
 765   referenced as [pegtop]
 766
 767   Where differences exist, I follow the SVG practice, the gimp
 768   practice, and lastly pegtop.
 769 */
 770
 771
 772 static void
 773 IM_SUFFIX(combine_alphablend)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 774   IM_SUFFIX(combine_line)(out, in, channels, count);
 775 }
 776
 777 /*
 778 Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
 779 Da'  = Sa.Da + Sa.(1 - Da) + Da.(1 - Sa)
 780      = Sa + Da - Sa.Da
 781
 782 When Da=1
 783
 784 Dc' = Sc.Sa.Dc + Dc.(1 - Sa)
 785  */
 786 static void
 787 IM_SUFFIX(combine_mult)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 788   int ch;
 789   IM_COLOR *inp = in;
 790   IM_COLOR *outp = out;
 791   i_img_dim work_count = count;
 792   int color_channels = i_color_channels(channels);
 793
 794   if (i_has_alpha(channels)) {
 795     while (work_count--) {
 796       IM_WORK_T orig_alpha = outp->channel[color_channels];
 797       IM_WORK_T src_alpha = inp->channel[color_channels];
 798
 799       if (src_alpha) {
 800         IM_WORK_T dest_alpha = src_alpha + orig_alpha
 801           - (src_alpha * orig_alpha) / IM_SAMPLE_MAX;
 802
 803         for (ch = 0; ch < color_channels; ++ch) {
 804           outp->channel[ch] =
 805             (inp->channel[ch] * src_alpha * outp->channel[ch] / IM_SAMPLE_MAX
 806              * orig_alpha
 807              + inp->channel[ch] * src_alpha * (IM_SAMPLE_MAX - orig_alpha)
 808              + outp->channel[ch] * orig_alpha * (IM_SAMPLE_MAX - src_alpha))
 809             / IM_SAMPLE_MAX / dest_alpha;
 810         }
 811         outp->channel[color_channels] = dest_alpha;
 812       }
 813       ++outp;
 814       ++inp;
 815     }
 816   }
 817   else {
 818     while (work_count--) {
 819       IM_WORK_T src_alpha = inp->channel[color_channels];
 820       IM_WORK_T remains = IM_SAMPLE_MAX - src_alpha;
 821
 822       if (src_alpha) {
 823         for (ch = 0; ch < color_channels; ++ch) {
 824           outp->channel[ch] =
 825             (src_alpha * inp->channel[ch] * outp->channel[ch] / IM_SAMPLE_MAX
 826              + outp->channel[ch] * remains) / IM_SAMPLE_MAX;
 827         }
 828       }
 829       ++outp;
 830       ++inp;
 831     }
 832   }
 833 }
 834
 835 static void
 836 IM_SUFFIX(combine_dissolve)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 837   int color_channels = i_color_channels(channels);
 838   int ch;
 839
 840   if (i_has_alpha(channels)) {
 841     while (count--) {
 842       if (in->channel[channels-1] > rand() * ((double)IM_SAMPLE_MAX / RAND_MAX)) {
 843         for (ch = 0; ch < color_channels; ++ch) {
 844           out->channel[ch] = in->channel[ch];
 845         }
 846         out->channel[color_channels] = IM_SAMPLE_MAX;
 847       }
 848       ++out;
 849       ++in;
 850     }
 851   }
 852   else {
 853     while (count--) {
 854       if (in->channel[channels] > rand() * ((double)IM_SAMPLE_MAX / RAND_MAX)) {
 855         for (ch = 0; ch < color_channels; ++ch) {
 856           out->channel[ch] = in->channel[ch];
 857         }
 858       }
 859       ++out;
 860       ++in;
 861     }
 862   }
 863 }
 864
 865 /*
 866 Dca' = Sca.Da + Dca.Sa + Sca.(1 - Da) + Dca.(1 - Sa)
 867      = Sca + Dca
 868 Da'  = Sa.Da + Da.Sa + Sa.(1 - Da) + Da.(1 - Sa)
 869      = Sa + Da
 870 */
 871
 872 static void
 873 IM_SUFFIX(combine_add)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 874   int ch;
 875   int color_channels = i_color_channels(channels);
 876   i_img_dim work_count = count;
 877   IM_COLOR *inp = in;
 878   IM_COLOR *outp = out;
 879
 880   if (i_has_alpha(channels)) {
 881     while (work_count--) {
 882       IM_WORK_T src_alpha = inp->channel[color_channels];
 883       if (src_alpha) {
 884         IM_WORK_T orig_alpha = outp->channel[color_channels];
 885         IM_WORK_T dest_alpha = src_alpha + orig_alpha;
 886         if (dest_alpha > IM_SAMPLE_MAX)
 887           dest_alpha = IM_SAMPLE_MAX;
 888         for (ch = 0; ch < color_channels; ++ch) {
 889           IM_WORK_T total = (outp->channel[ch] * orig_alpha + inp->channel[ch] * src_alpha) / dest_alpha;
 890           if (total > IM_SAMPLE_MAX)
 891             total = IM_SAMPLE_MAX;
 892           outp->channel[ch] = total;
 893         }
 894         outp->channel[color_channels] = dest_alpha;
 895       }
 896
 897       ++outp;
 898       ++inp;
 899     }
 900   }
 901   else {
 902     while (work_count--) {
 903       IM_WORK_T src_alpha = inp->channel[color_channels];
 904       if (src_alpha) {
 905         for (ch = 0; ch < color_channels; ++ch) {
 906           IM_WORK_T total = outp->channel[ch] + inp->channel[ch] * src_alpha / IM_SAMPLE_MAX;
 907           if (total > IM_SAMPLE_MAX)
 908             total = IM_SAMPLE_MAX;
 909           outp->channel[ch] = total;
 910         }
 911       }
 912
 913       ++outp;
 914       ++inp;
 915     }
 916   }
 917 }
 918
 919 /*
 920    [pegtop] documents this as max(A+B-256, 0) while [savvy] documents
 921    it as max(A-B, 0). [svg1.2] doesn't cover it.
 922
 923    [savvy] doesn't document how it works with an alpha channel.  GIMP
 924    actually seems to calculate the final value then use the alpha
 925    channel to apply that to the target.
 926  */
 927 static void
 928 IM_SUFFIX(combine_subtract)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 929   int ch;
 930   IM_COLOR const *inp = in;
 931   IM_COLOR *outp = out;
 932   i_img_dim work_count = count;
 933   int color_channels = i_color_channels(channels);
 934
 935   if (i_has_alpha(channels)) {
 936     while (work_count--) {
 937       IM_WORK_T src_alpha = inp->channel[color_channels];
 938       if (src_alpha) {
 939         IM_WORK_T orig_alpha = outp->channel[color_channels];
 940         IM_WORK_T dest_alpha = src_alpha + orig_alpha;
 941         if (dest_alpha > IM_SAMPLE_MAX)
 942           dest_alpha = IM_SAMPLE_MAX;
 943         for (ch = 0; ch < color_channels; ++ch) {
 944           IM_WORK_T total =
 945             (outp->channel[ch] * orig_alpha - inp->channel[ch] * src_alpha)
 946             / dest_alpha;
 947           if (total < 0)
 948             total = 0;
 949           outp->channel[ch] = total;
 950         }
 951         outp->channel[color_channels] = dest_alpha;
 952       }
 953       ++outp;
 954       ++inp;
 955     }
 956   }
 957   else {
 958     while (work_count--) {
 959       IM_WORK_T src_alpha = inp->channel[color_channels];
 960       if (src_alpha) {
 961         for (ch = 0; ch < color_channels; ++ch) {
 962           IM_WORK_T total = outp->channel[ch] - inp->channel[ch] * src_alpha / IM_SAMPLE_MAX;
 963           if (total < 0)
 964             total = 0;
 965           outp->channel[ch] = total;
 966         }
 967       }
 968       ++outp;
 969       ++inp;
 970     }
 971   }
 972 }
 973
 974 #ifdef IM_EIGHT_BIT
 975 #define IM_abs(x) abs(x)
 976 #else
 977 #define IM_abs(x) fabs(x)
 978 #endif
 979
 980 /*
 981 Dca' = abs(Dca.Sa - Sca.Da) + Sca.(1 - Da) + Dca.(1 - Sa)
 982      = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
 983 Da'  = Sa + Da - Sa.Da
 984 */
 985 static void
 986 IM_SUFFIX(combine_diff)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
 987   int ch;
 988   IM_COLOR const *inp = in;
 989   IM_COLOR *outp = out;
 990   i_img_dim work_count = count;
 991   int color_channels = i_color_channels(channels);
 992
 993   if (i_has_alpha(channels)) {
 994     while (work_count--) {
 995       IM_WORK_T src_alpha = inp->channel[color_channels];
 996       if (src_alpha) {
 997         IM_WORK_T orig_alpha = outp->channel[color_channels];
 998         IM_WORK_T dest_alpha = src_alpha + orig_alpha
 999           - src_alpha * orig_alpha / IM_SAMPLE_MAX;
1000         for (ch = 0; ch < color_channels; ++ch) {
1001           IM_WORK_T src = inp->channel[ch] * src_alpha;
1002           IM_WORK_T orig = outp->channel[ch] * orig_alpha;
1003           IM_WORK_T src_da = src * orig_alpha;
1004           IM_WORK_T dest_sa = orig * src_alpha;
1005           IM_WORK_T diff = src_da < dest_sa ? src_da : dest_sa;
1006           outp->channel[ch] = (src + orig - 2 * diff / IM_SAMPLE_MAX) / dest_alpha;
1007         }
1008         outp->channel[color_channels] = dest_alpha;
1009       }
1010       ++inp;
1011       ++outp;
1012     }
1013   }
1014   else {
1015     while (work_count--) {
1016       IM_WORK_T src_alpha = inp->channel[color_channels];
1017       if (src_alpha) {
1018         for (ch = 0; ch < color_channels; ++ch) {
1019           IM_WORK_T src = inp->channel[ch] * src_alpha;
1020           IM_WORK_T orig = outp->channel[ch] * IM_SAMPLE_MAX;
1021           IM_WORK_T src_da = src * IM_SAMPLE_MAX;
1022           IM_WORK_T dest_sa = orig * src_alpha;
1023           IM_WORK_T diff = src_da < dest_sa ? src_da : dest_sa;
1024           outp->channel[ch] = (src + orig - 2 * diff / IM_SAMPLE_MAX) / IM_SAMPLE_MAX;
1025         }
1026       }
1027       ++inp;
1028       ++outp;
1029     }
1030   }
1031 }
1032
1033 #undef IM_abs
1034
1035 /*
1036   Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca(1 - Sa)
1037   Da' = Sa + Da - Sa.Da
1038
1039   To hoist some code:
1040
1041   Dca' = min(Sc.Sa.Da, Dc.Da.Sa) + Sca - Sca.Da + Dca - Dca.Sa
1042        = Sa.Da.min(Sc, Dc) + Sca - Sca.Da + Dca - Dca.Sa
1043
1044   When Da=1:
1045
1046   Dca' = min(Sca.1, Dc.1.Sa) + Sca.(1 - 1) + Dc.1(1 - Sa)
1047        = min(Sca, Dc.Sa) + Dc(1-Sa)
1048        = Sa.min(Sc, Dc) + Dc - Dc.Sa
1049   Da'  = Sa + 1 - Sa.1
1050        = 1
1051  */
1052 static void
1053 IM_SUFFIX(combine_darken)(IM_COLOR *out, IM_COLOR *in, int channels,
1054                           i_img_dim count) {
1055   int ch;
1056   IM_COLOR const *inp = in;
1057   IM_COLOR *outp = out;
1058   i_img_dim work_count = count;
1059   int color_channels = i_color_channels(channels);
1060
1061   if (i_has_alpha(channels)) {
1062     while (work_count--) {
1063       IM_WORK_T src_alpha = inp->channel[color_channels];
1064
1065       if (src_alpha) {
1066         IM_WORK_T orig_alpha = outp->channel[color_channels];
1067         IM_WORK_T dest_alpha = src_alpha + orig_alpha
1068           - src_alpha * orig_alpha / IM_SAMPLE_MAX;
1069         for (ch = 0; ch < color_channels; ++ch) {
1070           IM_WORK_T Sca = inp->channel[ch] * src_alpha;
1071           IM_WORK_T Dca = outp->channel[ch] * orig_alpha;
1072           IM_WORK_T ScaDa = Sca * orig_alpha;
1073           IM_WORK_T DcaSa = Dca * src_alpha;
1074           IM_WORK_T minc = ScaDa < DcaSa ? ScaDa : DcaSa;
1075           outp->channel[ch] =
1076             (
1077              minc + (Sca + Dca) * IM_SAMPLE_MAX
1078              - ScaDa - DcaSa
1079              ) / (IM_SAMPLE_MAX * dest_alpha);
1080         }
1081         outp->channel[color_channels] = dest_alpha;
1082       }
1083       ++outp;
1084       ++inp;
1085     }
1086   }
1087   else {
1088     while (work_count--) {
1089       IM_WORK_T src_alpha = inp->channel[color_channels];
1090
1091       if (src_alpha) {
1092         for (ch = 0; ch < color_channels; ++ch) {
1093           IM_WORK_T minc = outp->channel[ch] < inp->channel[ch]
1094             ? outp->channel[ch] : inp->channel[ch];
1095           outp->channel[ch] =
1096             (
1097              src_alpha * minc +
1098              outp->channel[ch] * ( IM_SAMPLE_MAX - src_alpha )
1099              ) / IM_SAMPLE_MAX;
1100         }
1101       }
1102       ++outp;
1103       ++inp;
1104     }
1105   }
1106 }
1107
1108 static void
1109 IM_SUFFIX(combine_lighten)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1110   int ch;
1111   IM_COLOR const *inp = in;
1112   IM_COLOR *outp = out;
1113   i_img_dim work_count = count;
1114   int color_channels = i_color_channels(channels);
1115
1116   if (i_has_alpha(channels)) {
1117     while (work_count--) {
1118       IM_WORK_T src_alpha = inp->channel[color_channels];
1119
1120       if (src_alpha) {
1121         IM_WORK_T orig_alpha = outp->channel[color_channels];
1122         IM_WORK_T dest_alpha = src_alpha + orig_alpha
1123           - src_alpha * orig_alpha / IM_SAMPLE_MAX;
1124         for (ch = 0; ch < color_channels; ++ch) {
1125           IM_WORK_T Sca = inp->channel[ch] * src_alpha;
1126           IM_WORK_T Dca = outp->channel[ch] * orig_alpha;
1127           IM_WORK_T ScaDa = Sca * orig_alpha;
1128           IM_WORK_T DcaSa = Dca * src_alpha;
1129           IM_WORK_T maxc = ScaDa > DcaSa ? ScaDa : DcaSa;
1130           outp->channel[ch] =
1131             (
1132              maxc + (Sca + Dca) * IM_SAMPLE_MAX
1133              - ScaDa - DcaSa
1134              ) / (IM_SAMPLE_MAX * dest_alpha);
1135         }
1136         outp->channel[color_channels] = dest_alpha;
1137       }
1138       ++outp;
1139       ++inp;
1140     }
1141   }
1142   else {
1143     while (work_count--) {
1144       IM_WORK_T src_alpha = inp->channel[color_channels];
1145
1146       if (src_alpha) {
1147         for (ch = 0; ch < color_channels; ++ch) {
1148           IM_WORK_T maxc = outp->channel[ch] > inp->channel[ch]
1149             ? outp->channel[ch] : inp->channel[ch];
1150           outp->channel[ch] =
1151             (
1152              src_alpha * maxc +
1153              outp->channel[ch] * ( IM_SAMPLE_MAX - src_alpha )
1154              ) / IM_SAMPLE_MAX;
1155         }
1156       }
1157       ++outp;
1158       ++inp;
1159     }
1160   }
1161 }
1162
1163 #if IM_EIGHT_BIT
1164 #define IM_RGB_TO_HSV i_rgb_to_hsv
1165 #define IM_HSV_TO_RGB i_hsv_to_rgb
1166 #else
1167 #define IM_RGB_TO_HSV i_rgb_to_hsvf
1168 #define IM_HSV_TO_RGB i_hsv_to_rgbf
1169 #endif
1170
1171 static void
1172 IM_SUFFIX(combine_hue)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1173   if (channels > 2) {
1174     IM_COLOR *inp = in;
1175     IM_COLOR const *outp = out;
1176     i_img_dim work_count = count;
1177
1178     if (i_has_alpha(channels)) {
1179       while (work_count--) {
1180         IM_COLOR c = *inp;
1181         IM_RGB_TO_HSV(&c);
1182         /* only transfer hue if there's saturation */
1183         if (c.channel[1] && inp->channel[3] && outp->channel[3]) {
1184           *inp = *outp;
1185           IM_RGB_TO_HSV(inp);
1186           /* and no point in setting the target hue if the target has no sat */
1187           if (inp->channel[1]) {
1188             inp->channel[0] = c.channel[0];
1189             IM_HSV_TO_RGB(inp);
1190             inp->channel[3] = c.channel[3];
1191           }
1192           else {
1193             inp->channel[3] = 0;
1194           }
1195         }
1196         else {
1197           inp->channel[3] = 0;
1198         }
1199
1200         ++outp;
1201         ++inp;
1202       }
1203     }
1204     else {
1205       while (work_count--) {
1206         IM_COLOR c = *inp;
1207         IM_RGB_TO_HSV(&c);
1208         /* only transfer hue if there's saturation */
1209         if (c.channel[1] && inp->channel[3]) {
1210           *inp = *outp;
1211           IM_RGB_TO_HSV(inp);
1212           /* and no point in setting the target hue if the target has no sat */
1213           if (inp->channel[1]) {
1214             inp->channel[0] = c.channel[0];
1215             IM_HSV_TO_RGB(inp);
1216             inp->channel[3] = c.channel[3];
1217           }
1218         }
1219         else {
1220           inp->channel[3] = 0;
1221         }
1222
1223         ++outp;
1224         ++inp;
1225       }
1226     }
1227
1228     IM_SUFFIX(combine_line_na)(out, in, channels, count);
1229   }
1230 }
1231
1232 static void
1233 IM_SUFFIX(combine_sat)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1234   if (channels > 2) {
1235     IM_COLOR *inp = in;
1236     IM_COLOR const *outp = out;
1237     i_img_dim work_count = count;
1238
1239     while (work_count--) {
1240       IM_COLOR c = *inp;
1241       *inp = *outp;
1242       IM_RGB_TO_HSV(&c);
1243       IM_RGB_TO_HSV(inp);
1244       inp->channel[1] = c.channel[1];
1245       IM_HSV_TO_RGB(inp);
1246       inp->channel[3] = c.channel[3];
1247       ++outp;
1248       ++inp;
1249     }
1250
1251     IM_SUFFIX(combine_line_na)(out, in, channels, count);
1252   }
1253 }
1254
1255 static void
1256 IM_SUFFIX(combine_value)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1257   if (channels > 2) {
1258     IM_COLOR *inp = in;
1259     IM_COLOR const *outp = out;
1260     i_img_dim work_count = count;
1261
1262     while (work_count--) {
1263       IM_COLOR c = *inp;
1264       *inp = *outp;
1265       IM_RGB_TO_HSV(&c);
1266       IM_RGB_TO_HSV(inp);
1267       inp->channel[2] = c.channel[2];
1268       IM_HSV_TO_RGB(inp);
1269       inp->channel[3] = c.channel[3];
1270       ++outp;
1271       ++inp;
1272     }
1273   }
1274
1275   /* all images have a "value channel" - for greyscale it's the only
1276      colour channel */
1277   IM_SUFFIX(combine_line_na)(out, in, channels, count);
1278 }
1279
1280 static void
1281 IM_SUFFIX(combine_color)(IM_COLOR *out, IM_COLOR *in, int channels, i_img_dim count) {
1282   if (channels > 2) {
1283     IM_COLOR *inp = in;
1284     IM_COLOR const *outp = out;
1285     i_img_dim work_count = count;
1286
1287     while (work_count--) {
1288       IM_COLOR c = *inp;
1289       *inp = *outp;
1290       IM_RGB_TO_HSV(&c);
1291       IM_RGB_TO_HSV(inp);
1292       inp->channel[0] = c.channel[0];
1293       inp->channel[1] = c.channel[1];
1294       IM_HSV_TO_RGB(inp);
1295       inp->channel[3] = c.channel[3];
1296       ++outp;
1297       ++inp;
1298     }
1299
1300     IM_SUFFIX(combine_line_na)(out, in, channels, count);
1301   }
1302 }
1303
1304 #undef IM_RGB_TO_HSV
1305 #undef IM_HSV_TO_RGB
1306
1307 #/code