img16.c

filter: Statementstmt 80.6% 296 / 367 Branchbran 78.5% 278 / 354 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 79.6% 574 / 721 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« iolayer.c ↑ Summary render.im »
1 /*
2 =head1 NAME
3  
4 img16.c - implements 16-bit images
5  
6 =head1 SYNOPSIS
7  
8 i_img *im = i_img_16_new(i_img_dim x, i_img_dim y, int channels);
9 # use like a normal image
10  
11 =head1 DESCRIPTION
12  
13 Implements 16-bit/sample images.
14  
15 This basic implementation is required so that we have some larger
16 sample image type to work with.
17  
18 =over
19  
20 =cut
21 */
22  
23 #define IMAGER_NO_CONTEXT
24  
25 #include "imager.h"
26 #include "imageri.h"
27  
28 static int i_ppix_d16(i_img *im, i_img_dim x, i_img_dim y, const i_color *val);
29 static int i_gpix_d16(i_img *im, i_img_dim x, i_img_dim y, i_color *val);
30 static i_img_dim i_glin_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals);
31 static i_img_dim i_plin_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals);
32 static int i_ppixf_d16(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *val);
33 static int i_gpixf_d16(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *val);
34 static i_img_dim i_glinf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals);
35 static i_img_dim i_plinf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals);
36 static i_img_dim i_gsamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samps,
37 int const *chans, int chan_count);
38 static i_img_dim i_gsampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samps,
39 int const *chans, int chan_count);
40 static i_img_dim i_gsamp_bits_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned *samps,
41 int const *chans, int chan_count, int bits);
42 static i_img_dim i_psamp_bits_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned const *samps,
43 int const *chans, int chan_count, int bits);
44 static i_img_dim i_psamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, const int *chans, int chan_count);
45 static i_img_dim i_psampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, const int *chans, int chan_count);
46  
47 /*
48 =item IIM_base_16bit_direct
49  
50 Base structure used to initialize a 16-bit/sample image.
51  
52 Internal.
53  
54 =cut
55 */
56 static i_img IIM_base_16bit_direct =
57 {
58 0, /* channels set */
59 0, 0, 0, /* xsize, ysize, bytes */
60 ~0U, /* ch_mask */
61 i_16_bits, /* bits */
62 i_direct_type, /* type */
63 0, /* virtual */
64 NULL, /* idata */
65 { 0, 0, NULL }, /* tags */
66 NULL, /* ext_data */
67  
68 i_ppix_d16, /* i_f_ppix */
69 i_ppixf_d16, /* i_f_ppixf */
70 i_plin_d16, /* i_f_plin */
71 i_plinf_d16, /* i_f_plinf */
72 i_gpix_d16, /* i_f_gpix */
73 i_gpixf_d16, /* i_f_gpixf */
74 i_glin_d16, /* i_f_glin */
75 i_glinf_d16, /* i_f_glinf */
76 i_gsamp_d16, /* i_f_gsamp */
77 i_gsampf_d16, /* i_f_gsampf */
78  
79 NULL, /* i_f_gpal */
80 NULL, /* i_f_ppal */
81 NULL, /* i_f_addcolors */
82 NULL, /* i_f_getcolors */
83 NULL, /* i_f_colorcount */
84 NULL, /* i_f_maxcolors */
85 NULL, /* i_f_findcolor */
86 NULL, /* i_f_setcolors */
87  
88 NULL, /* i_f_destroy */
89  
90 i_gsamp_bits_d16,
91 i_psamp_bits_d16,
92  
93 i_psamp_d16,
94 i_psampf_d16,
95  
96 NULL,
97 NULL
98 };
99  
100 /* it's possible some platforms won't have a 16-bit integer type,
101 so we check for one otherwise we work by bytes directly
102  
103 We do assume 8-bit char
104  
105 "Compaq C V6.4-009 on Compaq Tru64 UNIX V5.1A (Rev. 1885)" says it
106 supports C99, but doesn't supply stdint.h, which is required for
107 both hosted and freestanding implementations. So guard against it.
108 */
109 #if __STDC_VERSION__ >= 199901L && !defined(OS_dec_osf)
110 /* C99 should define something useful */
111 #include <stdint.h>
112 #ifdef UINT16_MAX
113 typedef uint16_t i_sample16_t;
114 #define GOT16
115 #endif
116 #endif
117  
118 /* check out unsigned short */
119 #ifndef GOT16
120 #include <limits.h>
121 #if USHRT_MAX == 65535
122 typedef unsigned short i_sample16_t;
123 #define GOT16
124 #endif
125 #endif
126  
127 #ifdef GOT16
128  
129 /* we have a real 16-bit unsigned integer */
130 #define STORE16(bytes, offset, word) \
131 (((i_sample16_t *)(bytes))[offset] = (word))
132 #define STORE8as16(bytes, offset, byte) \
133 (((i_sample16_t *)(bytes))[offset] = (byte) * 256 + (byte))
134 #define GET16(bytes, offset) \
135 (((i_sample16_t *)(bytes))[offset])
136 #else
137  
138 /* we have to do this the hard way */
139 #define STORE16(bytes, offset, word) \
140 ((((unsigned char *)(bytes))[(offset)*2] = (word) >> 8), \
141 (((unsigned char *)(bytes))[(offset)*2+1] = (word) & 0xFF))
142 #define STORE8as16(bytes, offset, byte) \
143 ((((unsigned char *)(bytes))[(offset)*2] = (byte)), \
144 (((unsigned char *)(bytes))[(offset)*2+1] = (byte)))
145
146 #define GET16(bytes, offset) \
147 (((unsigned char *)(bytes))[(offset)*2] * 256 \
148 + ((unsigned char *)(bytes))[(offset)*2+1])
149  
150 #endif
151  
152 #define GET16as8(bytes, offset) \
153 ((((i_sample16_t *)(bytes))[offset]+127) / 257)
154  
155 /*
156 =item im_img_16_new(ctx, x, y, ch)
157 X<im_img_16_new API>X<i_img_16_new API>
158 =category Image creation/destruction
159 =synopsis i_img *img = im_img_16_new(aIMCTX, width, height, channels);
160 =synopsis i_img *img = i_img_16_new(width, height, channels);
161  
162 Create a new 16-bit/sample image.
163  
164 Returns the image on success, or NULL on failure.
165  
166 Also callable as C<i_img_16_new(x, y, ch)>
167  
168 =cut
169 */
170  
171 i_img *
172 102 im_img_16_new(pIMCTX, i_img_dim x, i_img_dim y, int ch) {
173 i_img *im;
174 size_t bytes, line_bytes;
175  
176 102 im_log((aIMCTX, 1,"i_img_16_new(x %" i_DF ", y %" i_DF ", ch %d)\n",
177 i_DFc(x), i_DFc(y), ch));
178 102 i_clear_error();
179 102 ▶ if (x < 1 || y < 1) {
Branch: 2 branches
BranchTrueFalseTotal
if (x < 1 || y < 1) { 99 3 102
if (x < 1 || y < 1) { 2 97 99
180 5 im_push_error(aIMCTX, 0, "Image sizes must be positive");
181 5 return NULL;
182 }
183 97 ▶ if (ch < 1 || ch > MAXCHANNELS) {
Branch: 2 branches
BranchTrueFalseTotal
if (ch < 1 || ch > MAXCHANNELS) { 96 1 97
if (ch < 1 || ch > MAXCHANNELS) { 1 95 96
184 2 im_push_errorf(aIMCTX, 0, "channels must be between 1 and %d", MAXCHANNELS);
185 2 return NULL;
186 }
187  
188 95 ▶ if (im_mult_overflow4(&bytes, x, y, ch, 2u)) {
Branch: 1 branch
BranchTrueFalseTotal
if (im_mult_overflow4(&bytes, x, y, ch, 2u)) { 0 95 95
189 0 im_push_errorf(aIMCTX, 0, "integer overflow calculating image allocation");
190 0 return NULL;
191 }
192
193 /* basic assumption: we can always allocate a buffer representing a
194 line from the image, otherwise we're going to have trouble
195 working with the image */
196 95 line_bytes = sizeof(i_fcolor) * x;
197 95 ▶ if (line_bytes / x != sizeof(i_fcolor)) {
Branch: 1 branch
BranchTrueFalseTotal
if (line_bytes / x != sizeof(i_fcolor)) { 0 95 95
198 0 im_push_error(aIMCTX, 0, "integer overflow calculating scanline allocation");
199 0 return NULL;
200 }
201  
202 95 im = im_img_alloc(aIMCTX);
203 95 *im = IIM_base_16bit_direct;
204  
205 95 im->idata = i_malloc_fail(bytes);
206 95 ▶ if (im->idata == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (im->idata == NULL) { 0 95 95
207 /* can't i_img_destroy() until we've done i_img_init() */
208 0 i_free(im);
209  
210 0 im_log((aIMCTX, 1, "i_img_16_new(): out of memory\n"));
211 0 i_push_error(0, "Out of memory allocating image surface");
212 0 return NULL;
213 }
214 95 memset(im->idata, 0, bytes);
215  
216 95 i_tags_new(&im->tags);
217 95 im->xsize = x;
218 95 im->ysize = y;
219 95 im->channels = ch;
220 95 im->bytes = bytes;
221 95 im->ext_data = NULL;
222  
223 95 im_img_init(aIMCTX, im);
224  
225 95 return im;
226 }
227  
228 /*
229 =item i_img_to_rgb16(im)
230  
231 =category Image creation
232  
233 Returns a 16-bit/sample version of the supplied image.
234  
235 Returns the image on success, or NULL on failure.
236  
237 =cut
238 */
239  
240 i_img *
241 8 i_img_to_rgb16(i_img *im) {
242 i_img *targ;
243 i_fcolor *line;
244 i_img_dim y;
245 8 dIMCTXim(im);
246  
247 8 targ = im_img_16_new(aIMCTX, im->xsize, im->ysize, im->channels);
248 8 ▶ if (!targ)
Branch: 1 branch
BranchTrueFalseTotal
if (!targ) 0 8 8
249 0 return NULL;
250 8 line = mymalloc(sizeof(i_fcolor) * im->xsize);
251 1286 ▶ for (y = 0; y < im->ysize; ++y) {
Branch: 1 branch
BranchTrueFalseTotal
for (y = 0; y < im->ysize; ++y) { 1278 8 1286
252 1278 i_glinf(im, 0, im->xsize, y, line);
253 1278 i_plinf(targ, 0, im->xsize, y, line);
254 }
255  
256 8 myfree(line);
257  
258 8 return targ;
259 }
260  
261 58045 static int i_ppix_d16(i_img *im, i_img_dim x, i_img_dim y, const i_color *val) {
262 i_img_dim off;
263 int ch;
264  
265 58045 ▶ if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
Branch: 4 branches
BranchTrueFalseTotal
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 58044 1 58045
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 58042 2 58044
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 58041 1 58042
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 1 58040 58041
266 5 return -1;
267  
268 58040 off = (x + y * im->xsize) * im->channels;
269 58040 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 58039 1 58040
270 208564 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 150525 58039 208564
271 150525 STORE8as16(im->idata, off+ch, val->channel[ch]);
272 }
273 else {
274 4 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 3 1 4
275 3 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 2 1 3
276 2 STORE8as16(im->idata, off+ch, val->channel[ch]);
277 }
278  
279 58040 return 0;
280 }
281  
282 451636 static int i_gpix_d16(i_img *im, i_img_dim x, i_img_dim y, i_color *val) {
283 i_img_dim off;
284 int ch;
285  
286 451636 ▶ if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
Branch: 4 branches
BranchTrueFalseTotal
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 451634 2 451636
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 451632 2 451634
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 451630 2 451632
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 2 451628 451630
287 8 return -1;
288  
289 451628 off = (x + y * im->xsize) * im->channels;
290 1806513 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 1354885 451628 1806513
291 1354885 val->channel[ch] = GET16as8(im->idata, off+ch);
292  
293 451628 return 0;
294 }
295  
296 800007 static int i_ppixf_d16(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *val) {
297 i_img_dim off;
298 int ch;
299  
300 800007 ▶ if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
Branch: 4 branches
BranchTrueFalseTotal
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 800006 1 800007
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 800005 1 800006
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 800004 1 800005
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 1 800003 800004
301 4 return -1;
302  
303 800003 off = (x + y * im->xsize) * im->channels;
304 800003 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 800002 1 800003
305 2920008 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 2120006 800002 2920008
306 2120006 STORE16(im->idata, off+ch, SampleFTo16(val->channel[ch]));
307 }
308 else {
309 4 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 3 1 4
310 3 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 2 1 3
311 2 STORE16(im->idata, off+ch, SampleFTo16(val->channel[ch]));
312 }
313  
314 800003 return 0;
315 }
316  
317 5841923 static int i_gpixf_d16(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *val) {
318 i_img_dim off;
319 int ch;
320  
321 5841923 ▶ if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
Branch: 4 branches
BranchTrueFalseTotal
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 5805417 36506 5841923
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 5768911 36506 5805417
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 5732287 36624 5768911
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 36624 5695663 5732287
322 146260 return -1;
323  
324 5695663 off = (x + y * im->xsize) * im->channels;
325 20982650 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 15286987 5695663 20982650
326 15286987 val->channel[ch] = Sample16ToF(GET16(im->idata, off+ch));
327  
328 5695663 return 0;
329 }
330  
331 0 static i_img_dim i_glin_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals) {
332 int ch;
333 i_img_dim count, i;
334 i_img_dim off;
335 0 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 0 0 0
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 0 0 0
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 0 0 0
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 0 0 0
336 0 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 0 0
337 0 r = im->xsize;
338 0 off = (l+y*im->xsize) * im->channels;
339 0 count = r - l;
340 0 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 0 0 0
341 0 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 0 0 0
342 0 vals[i].channel[ch] = GET16as8(im->idata, off);
343 0 ++off;
344 }
345 }
346 0 return count;
347 }
348 else {
349 0 return 0;
350 }
351 }
352  
353 2450 static i_img_dim i_plin_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals) {
354 int ch;
355 i_img_dim count, i;
356 i_img_dim off;
357 2450 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2450 0 2450
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2450 0 2450
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2450 0 2450
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2450 0 2450
358 2450 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 2450 2450
359 0 r = im->xsize;
360 2450 off = (l+y*im->xsize) * im->channels;
361 2450 count = r - l;
362 2450 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 2449 1 2450
363 150506 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 148057 2449 150506
364 493844 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 345787 148057 493844
365 345787 STORE8as16(im->idata, off, vals[i].channel[ch]);
366 345787 ++off;
367 }
368 }
369 }
370 else {
371 2 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 1 1 2
372 4 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 3 1 4
373 3 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 2 1 3
374 2 STORE8as16(im->idata, off, vals[i].channel[ch]);
375 3 ++off;
376 }
377 }
378 }
379 2450 return count;
380 }
381 else {
382 0 return 0;
383 }
384 }
385  
386 2424 static i_img_dim i_glinf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals) {
387 int ch;
388 i_img_dim count, i;
389 i_img_dim off;
390 2424 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2424 0 2424
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2424 0 2424
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2424 0 2424
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2424 0 2424
391 2424 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 2424 2424
392 0 r = im->xsize;
393 2424 off = (l+y*im->xsize) * im->channels;
394 2424 count = r - l;
395 366060 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 363636 2424 366060
396 1492093 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 1128457 363636 1492093
397 1128457 vals[i].channel[ch] = Sample16ToF(GET16(im->idata, off));
398 1128457 ++off;
399 }
400 }
401 2424 return count;
402 }
403 else {
404 0 return 0;
405 }
406 }
407  
408 5197 static i_img_dim i_plinf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals) {
409 int ch;
410 i_img_dim count, i;
411 i_img_dim off;
412 5197 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 5197 0 5197
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 5196 1 5197
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 5196 0 5196
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 5196 0 5196
413 5196 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 5196 5196
414 0 r = im->xsize;
415 5196 off = (l+y*im->xsize) * im->channels;
416 5196 count = r - l;
417 5196 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 4625 571 5196
418 711807 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 707182 4625 711807
419 2776069 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 2068887 707182 2776069
420 2068887 STORE16(im->idata, off, SampleFTo16(vals[i].channel[ch]));
421 2068887 ++off;
422 }
423 }
424 }
425 else {
426 70472 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 69901 571 70472
427 279604 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 209703 69901 279604
428 209703 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 69902 139801 209703
429 69902 STORE16(im->idata, off, SampleFTo16(vals[i].channel[ch]));
430 209703 ++off;
431 }
432 }
433 }
434 5196 return count;
435 }
436 else {
437 1 return 0;
438 }
439 }
440  
441 1652 static i_img_dim i_gsamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samps,
442 int const *chans, int chan_count) {
443 int ch;
444 i_img_dim count, i, w;
445 i_img_dim off;
446  
447 1652 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 1652 0 1652
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 1652 0 1652
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 1652 0 1652
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 1652 0 1652
448 1652 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 1652 1652
449 0 r = im->xsize;
450 1652 off = (l+y*im->xsize) * im->channels;
451 1652 w = r - l;
452 1652 count = 0;
453  
454 1652 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 2 1650 1652
455 /* make sure we have good channel numbers */
456 8 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 6 2 8
457 6 ▶ if (chans[ch] < 0 || chans[ch] >= im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chans[ch] < 0 || chans[ch] >= im->channels) { 6 0 6
if (chans[ch] < 0 || chans[ch] >= im->channels) { 0 6 6
458 0 dIMCTXim(im);
459 0 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
460 0 return 0;
461 }
462 }
463 22 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 20 2 22
464 80 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 60 20 80
465 60 *samps++ = GET16as8(im->idata, off+chans[ch]);
466 60 ++count;
467 }
468 20 off += im->channels;
469 }
470 }
471 else {
472 1650 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 1650 0 1650
if (chan_count <= 0 || chan_count > im->channels) { 0 1650 1650
473 0 dIMCTXim(im);
474 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
475 chan_count);
476 0 return 0;
477 }
478 294150 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 292500 1650 294150
479 1035000 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 742500 292500 1035000
480 742500 *samps++ = GET16as8(im->idata, off+ch);
481 742500 ++count;
482 }
483 292500 off += im->channels;
484 }
485 }
486  
487 1652 return count;
488 }
489 else {
490 0 return 0;
491 }
492 }
493  
494 3398 static i_img_dim i_gsampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samps,
495 int const *chans, int chan_count) {
496 int ch;
497 i_img_dim count, i, w;
498 i_img_dim off;
499  
500 3398 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 3398 0 3398
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 3398 0 3398
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 3398 0 3398
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 3398 0 3398
501 3398 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 3398 3398
502 0 r = im->xsize;
503 3398 off = (l+y*im->xsize) * im->channels;
504 3398 w = r - l;
505 3398 count = 0;
506  
507 3398 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 1952 1446 3398
508 /* make sure we have good channel numbers */
509 3904 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 1952 1952 3904
510 1952 ▶ if (chans[ch] < 0 || chans[ch] >= im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chans[ch] < 0 || chans[ch] >= im->channels) { 1952 0 1952
if (chans[ch] < 0 || chans[ch] >= im->channels) { 0 1952 1952
511 0 dIMCTXim(im);
512 0 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
513 0 return 0;
514 }
515 }
516 429752 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 427800 1952 429752
517 855600 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 427800 427800 855600
518 427800 *samps++ = Sample16ToF(GET16(im->idata, off+chans[ch]));
519 427800 ++count;
520 }
521 427800 off += im->channels;
522 }
523 }
524 else {
525 1446 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 1446 0 1446
if (chan_count <= 0 || chan_count > im->channels) { 0 1446 1446
526 0 dIMCTXim(im);
527 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
528 chan_count);
529 0 return 0;
530 }
531 280668 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 279222 1446 280668
532 1233600 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 954378 279222 1233600
533 954378 *samps++ = Sample16ToF(GET16(im->idata, off+ch));
534 954378 ++count;
535 }
536 279222 off += im->channels;
537 }
538 }
539  
540 3398 return count;
541 }
542 else {
543 0 return 0;
544 }
545 }
546  
547 static i_img_dim
548 5 i_gsamp_bits_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned *samps,
549 int const *chans, int chan_count, int bits) {
550 int ch;
551 i_img_dim count, i, w;
552 i_img_dim off;
553  
554 5 ▶ if (bits != 16) {
Branch: 1 branch
BranchTrueFalseTotal
if (bits != 16) { 1 4 5
555 1 return i_gsamp_bits_fb(im, l, r, y, samps, chans, chan_count, bits);
556 }
557  
558 4 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 4 0 4
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 4 0 4
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 4 0 4
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 4 0 4
559 4 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 4 4
560 0 r = im->xsize;
561 4 off = (l+y*im->xsize) * im->channels;
562 4 w = r - l;
563 4 count = 0;
564  
565 4 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 3 1 4
566 /* make sure we have good channel numbers */
567 11 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 8 3 11
568 8 ▶ if (chans[ch] < 0 || chans[ch] >= im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chans[ch] < 0 || chans[ch] >= im->channels) { 8 0 8
if (chans[ch] < 0 || chans[ch] >= im->channels) { 0 8 8
569 0 dIMCTXim(im);
570 0 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
571 0 return -1;
572 }
573 }
574 15 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 12 3 15
575 44 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 32 12 44
576 32 *samps++ = GET16(im->idata, off+chans[ch]);
577 32 ++count;
578 }
579 12 off += im->channels;
580 }
581 }
582 else {
583 1 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 1 0 1
if (chan_count <= 0 || chan_count > im->channels) { 0 1 1
584 0 dIMCTXim(im);
585 0 i_push_error(0, "Invalid channel count");
586 0 return -1;
587 }
588 11 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 10 1 11
589 40 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 30 10 40
590 30 *samps++ = GET16(im->idata, off+ch);
591 30 ++count;
592 }
593 10 off += im->channels;
594 }
595 }
596  
597 4 return count;
598 }
599 else {
600 0 dIMCTXim(im);
601 0 i_push_error(0, "Image position outside of image");
602 0 return -1;
603 }
604 }
605  
606 static i_img_dim
607 2 i_psamp_bits_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned const *samps,
608 int const *chans, int chan_count, int bits) {
609 int ch;
610 i_img_dim count, i, w;
611 i_img_dim off;
612  
613 2 ▶ if (bits != 16) {
Branch: 1 branch
BranchTrueFalseTotal
if (bits != 16) { 0 2 2
614 0 dIMCTXim(im);
615 0 i_push_error(0, "Invalid bits for 16-bit image");
616 0 return -1;
617 }
618  
619 2 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2 0 2
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2 0 2
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2 0 2
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2 0 2
620 2 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 2 2
621 0 r = im->xsize;
622 2 off = (l+y*im->xsize) * im->channels;
623 2 w = r - l;
624 2 count = 0;
625  
626 2 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 1 1 2
627 /* make sure we have good channel numbers */
628 4 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 3 1 4
629 3 ▶ if (chans[ch] < 0 || chans[ch] >= im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chans[ch] < 0 || chans[ch] >= im->channels) { 3 0 3
if (chans[ch] < 0 || chans[ch] >= im->channels) { 0 3 3
630 0 dIMCTXim(im);
631 0 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
632 0 return -1;
633 }
634 }
635 5 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 4 1 5
636 16 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 12 4 16
637 12 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 12 0 12
638 12 STORE16(im->idata, off+chans[ch], *samps);
639 12 ++samps;
640 12 ++count;
641 }
642 4 off += im->channels;
643 }
644 }
645 else {
646 1 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 1 0 1
if (chan_count <= 0 || chan_count > im->channels) { 0 1 1
647 0 dIMCTXim(im);
648 0 i_push_error(0, "Invalid channel count");
649 0 return -1;
650 }
651 11 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 10 1 11
652 40 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 30 10 40
653 30 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 30 0 30
654 30 STORE16(im->idata, off+ch, *samps);
655 30 ++samps;
656 30 ++count;
657 }
658 10 off += im->channels;
659 }
660 }
661  
662 2 return count;
663 }
664 else {
665 0 dIMCTXim(im);
666 0 i_push_error(0, "Image position outside of image");
667 0 return -1;
668 }
669 }
670  
671 /*
672 =item i_psamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, int *chans, int chan_count)
673  
674 Writes sample values to im for the horizontal line (l, y) to (r-1,y)
675 for the channels specified by chans, an array of int with chan_count
676 elements.
677  
678 Returns the number of samples written (which should be (r-l) *
679 bits_set(chan_mask)
680  
681 =cut
682 */
683  
684 static
685 i_img_dim
686 11 i_psamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
687 const i_sample_t *samps, const int *chans, int chan_count) {
688 int ch;
689 i_img_dim count, i, w;
690  
691 11 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 10 1 11
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 9 1 10
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 9 0 9
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 8 1 9
692 i_img_dim offset;
693 8 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 1 7 8
694 1 r = im->xsize;
695 8 offset = (l+y*im->xsize) * im->channels;
696 8 w = r - l;
697 8 count = 0;
698  
699 8 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 6 2 8
700 /* make sure we have good channel numbers */
701 /* and test if all channels specified are in the mask */
702 6 int all_in_mask = 1;
703 21 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 17 4 21
704 17 ▶ if (chans[ch] < 0 || chans[ch] >= im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chans[ch] < 0 || chans[ch] >= im->channels) { 16 1 17
if (chans[ch] < 0 || chans[ch] >= im->channels) { 1 15 16
705 2 dIMCTXim(im);
706 2 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
707 2 return -1;
708 }
709 15 ▶ if (!((1 << chans[ch]) & im->ch_mask))
Branch: 1 branch
BranchTrueFalseTotal
if (!((1 << chans[ch]) & im->ch_mask)) 1 14 15
710 1 all_in_mask = 0;
711 }
712 4 ▶ if (all_in_mask) {
Branch: 1 branch
BranchTrueFalseTotal
if (all_in_mask) { 3 1 4
713 17 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 14 3 17
714 54 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 40 14 54
715 40 STORE8as16(im->idata, offset + chans[ch], *samps);
716 40 ++samps;
717 40 ++count;
718 }
719 14 offset += im->channels;
720 }
721 }
722 else {
723 2 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 1 1 2
724 4 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 3 1 4
725 3 ▶ if (im->ch_mask & (1 << (chans[ch])))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << (chans[ch]))) 2 1 3
726 2 STORE8as16(im->idata, offset + chans[ch], *samps);
727 3 ++samps;
728 3 ++count;
729 }
730 1 offset += im->channels;
731 }
732 }
733 }
734 else {
735 2 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 2 0 2
if (chan_count <= 0 || chan_count > im->channels) { 0 2 2
736 0 dIMCTXim(im);
737 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
738 chan_count);
739 0 return -1;
740 }
741 4 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 2 2 4
742 2 unsigned mask = 1;
743 8 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 6 2 8
744 6 ▶ if (im->ch_mask & mask)
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & mask) 5 1 6
745 5 STORE8as16(im->idata, offset + ch, *samps);
746 6 ++samps;
747 6 ++count;
748 6 mask <<= 1;
749 }
750 2 offset += im->channels;
751 }
752 }
753  
754 6 return count;
755 }
756 else {
757 3 dIMCTXim(im);
758 3 i_push_error(0, "Image position outside of image");
759 3 return -1;
760 }
761 }
762  
763 /*
764 =item i_psampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, int *chans, int chan_count)
765  
766 Writes sample values to im for the horizontal line (l, y) to (r-1,y)
767 for the channels specified by chans, an array of int with chan_count
768 elements.
769  
770 Returns the number of samples written (which should be (r-l) *
771 bits_set(chan_mask)
772  
773 =cut
774 */
775  
776 static
777 i_img_dim
778 12 i_psampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
779 const i_fsample_t *samps, const int *chans, int chan_count) {
780 int ch;
781 i_img_dim count, i, w;
782  
783 12 ▶ if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
Branch: 4 branches
BranchTrueFalseTotal
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 11 1 12
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 10 1 11
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 9 1 10
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 8 1 9
784 i_img_dim offset;
785 8 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 1 7 8
786 1 r = im->xsize;
787 8 offset = (l+y*im->xsize) * im->channels;
788 8 w = r - l;
789 8 count = 0;
790  
791 8 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 6 2 8
792 /* make sure we have good channel numbers */
793 /* and test if all channels specified are in the mask */
794 6 int all_in_mask = 1;
795 21 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 17 4 21
796 17 ▶ if (chans[ch] < 0 || chans[ch] >= im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chans[ch] < 0 || chans[ch] >= im->channels) { 16 1 17
if (chans[ch] < 0 || chans[ch] >= im->channels) { 1 15 16
797 2 dIMCTXim(im);
798 2 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
799 2 return -1;
800 }
801 15 ▶ if (!((1 << chans[ch]) & im->ch_mask))
Branch: 1 branch
BranchTrueFalseTotal
if (!((1 << chans[ch]) & im->ch_mask)) 1 14 15
802 1 all_in_mask = 0;
803 }
804 4 ▶ if (all_in_mask) {
Branch: 1 branch
BranchTrueFalseTotal
if (all_in_mask) { 3 1 4
805 17 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 14 3 17
806 54 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 40 14 54
807 40 unsigned samp16 = SampleFTo16(*samps);
808 40 STORE16(im->idata, offset + chans[ch], samp16);
809 40 ++samps;
810 40 ++count;
811 }
812 14 offset += im->channels;
813 }
814 }
815 else {
816 2 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 1 1 2
817 4 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 3 1 4
818 3 ▶ if (im->ch_mask & (1 << (chans[ch]))) {
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << (chans[ch]))) { 2 1 3
819 2 unsigned samp16 = SampleFTo16(*samps);
820 2 STORE16(im->idata, offset + chans[ch], samp16);
821 }
822 3 ++samps;
823 3 ++count;
824 }
825 1 offset += im->channels;
826 }
827 }
828 }
829 else {
830 2 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 2 0 2
if (chan_count <= 0 || chan_count > im->channels) { 0 2 2
831 0 dIMCTXim(im);
832 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
833 chan_count);
834 0 return -1;
835 }
836 4 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 2 2 4
837 2 unsigned mask = 1;
838 8 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 6 2 8
839 6 ▶ if (im->ch_mask & mask) {
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & mask) { 5 1 6
840 5 unsigned samp16 = SampleFTo16(*samps);
841 5 STORE16(im->idata, offset + ch, samp16);
842 }
843 6 ++samps;
844 6 ++count;
845 6 mask <<= 1;
846 }
847 2 offset += im->channels;
848 }
849 }
850  
851 6 return count;
852 }
853 else {
854 4 dIMCTXim(im);
855 4 i_push_error(0, "Image position outside of image");
856 4 return -1;
857 }
858 }
859  
860 /*
861 =back
862  
863 =head1 AUTHOR
864  
865 Tony Cook <tony@develop-help.com>
866  
867 =head1 SEE ALSO
868  
869 Imager(3)
870  
871 =cut
872 */
« iolayer.c ↑ Summary render.im »