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