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