render.im

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