imgdouble.c

filter: Statementstmt 87.1% 251 / 288 Branchbran 82.7% 235 / 284 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 84.9% 486 / 572 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« img8.c ↑ Summary limits.c »
1 /*
2 =head1 NAME
3  
4 imgdouble.c - implements double per sample images
5  
6 =head1 SYNOPSIS
7  
8 i_img *im = i_img_double_new(width, height, channels);
9 # use like a normal image
10  
11 =head1 DESCRIPTION
12  
13 Implements double/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 #include "imager.h"
25 #include "imageri.h"
26  
27 static int i_ppix_ddoub(i_img *im, i_img_dim x, i_img_dim y, const i_color *val);
28 static int i_gpix_ddoub(i_img *im, i_img_dim x, i_img_dim y, i_color *val);
29 static i_img_dim i_glin_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals);
30 static i_img_dim i_plin_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals);
31 static int i_ppixf_ddoub(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *val);
32 static int i_gpixf_ddoub(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *val);
33 static i_img_dim i_glinf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals);
34 static i_img_dim i_plinf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals);
35 static i_img_dim i_gsamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samps,
36 int const *chans, int chan_count);
37 static i_img_dim i_gsampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samps,
38 int const *chans, int chan_count);
39 static i_img_dim
40 i_psamp_ddoub(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);
41 static i_img_dim
42 i_psampf_ddoub(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);
43  
44 /*
45 =item IIM_base_16bit_direct
46  
47 Base structure used to initialize a 16-bit/sample image.
48  
49 Internal.
50  
51 =cut
52 */
53 static i_img IIM_base_double_direct =
54 {
55 0, /* channels set */
56 0, 0, 0, /* xsize, ysize, bytes */
57 ~0U, /* ch_mask */
58 i_double_bits, /* bits */
59 i_direct_type, /* type */
60 0, /* virtual */
61 NULL, /* idata */
62 { 0, 0, NULL }, /* tags */
63 NULL, /* ext_data */
64  
65 i_ppix_ddoub, /* i_f_ppix */
66 i_ppixf_ddoub, /* i_f_ppixf */
67 i_plin_ddoub, /* i_f_plin */
68 i_plinf_ddoub, /* i_f_plinf */
69 i_gpix_ddoub, /* i_f_gpix */
70 i_gpixf_ddoub, /* i_f_gpixf */
71 i_glin_ddoub, /* i_f_glin */
72 i_glinf_ddoub, /* i_f_glinf */
73 i_gsamp_ddoub, /* i_f_gsamp */
74 i_gsampf_ddoub, /* i_f_gsampf */
75  
76 NULL, /* i_f_gpal */
77 NULL, /* i_f_ppal */
78 NULL, /* i_f_addcolors */
79 NULL, /* i_f_getcolors */
80 NULL, /* i_f_colorcount */
81 NULL, /* i_f_maxcolors */
82 NULL, /* i_f_findcolor */
83 NULL, /* i_f_setcolors */
84  
85 NULL, /* i_f_destroy */
86  
87 i_gsamp_bits_fb,
88 NULL, /* i_f_psamp_bits */
89  
90 i_psamp_ddoub, /* i_f_psamp */
91 i_psampf_ddoub, /* i_f_psampf */
92  
93 NULL,
94 NULL
95 };
96  
97 /*
98 =item im_img_double_new(ctx, x, y, ch)
99 X<im_img_double_new API>X<i_img_double_new API>
100 =category Image creation/destruction
101 =synopsis i_img *img = im_img_double_new(aIMCTX, width, height, channels);
102 =synopsis i_img *img = i_img_double_new(width, height, channels);
103  
104 Creates a new double per sample image.
105  
106 Also callable as C<i_img_double_new(width, height, channels)>.
107  
108 =cut
109 */
110 i_img *
111 136 im_img_double_new(pIMCTX, i_img_dim x, i_img_dim y, int ch) {
112 size_t bytes;
113 i_img *im;
114  
115 136 im_log((aIMCTX, 1,"i_img_double_new(x %" i_DF ", y %" i_DF ", ch %d)\n",
116 i_DFc(x), i_DFc(y), ch));
117 136 i_clear_error();
118 136 ▶ if (x < 1 || y < 1) {
Branch: 2 branches
BranchTrueFalseTotal
if (x < 1 || y < 1) { 134 2 136
if (x < 1 || y < 1) { 2 132 134
119 4 im_push_error(aIMCTX, 0, "Image sizes must be positive");
120 4 return NULL;
121 }
122 132 ▶ if (ch < 1 || ch > MAXCHANNELS) {
Branch: 2 branches
BranchTrueFalseTotal
if (ch < 1 || ch > MAXCHANNELS) { 131 1 132
if (ch < 1 || ch > MAXCHANNELS) { 1 130 131
123 2 im_push_errorf(aIMCTX, 0, "channels must be between 1 and %d", MAXCHANNELS);
124 2 return NULL;
125 }
126  
127 130 ▶ if (im_mult_overflow4(&bytes, x, y, ch, sizeof(double))) {
Branch: 1 branch
BranchTrueFalseTotal
if (im_mult_overflow4(&bytes, x, y, ch, sizeof(double))) { 0 130 130
128 0 im_push_errorf(aIMCTX, 0, "integer overflow calculating image allocation");
129 0 return NULL;
130 }
131
132 130 im = im_img_alloc(aIMCTX);
133 130 *im = IIM_base_double_direct;
134
135 130 im->idata = i_malloc_fail(bytes);
136 130 ▶ if (im->idata == NULL) {
Branch: 1 branch
BranchTrueFalseTotal
if (im->idata == NULL) { 0 130 130
137 /* can't i_img_destroy() until we've done i_img_init() */
138 0 i_free(im);
139  
140 0 im_log((aIMCTX, 1, "i_img_double_new(): out of memory\n"));
141 0 i_push_error(0, "Out of memory allocating image surface");
142 0 return NULL;
143 }
144 130 memset(im->idata, 0, bytes);
145  
146 130 i_tags_new(&im->tags);
147 130 im->xsize = x;
148 130 im->ysize = y;
149 130 im->channels = ch;
150 130 im->bytes = bytes;
151 130 im->ext_data = NULL;
152 130 im_img_init(aIMCTX, im);
153
154 130 return im;
155 }
156  
157 11818 static int i_ppix_ddoub(i_img *im, i_img_dim x, i_img_dim y, const i_color *val) {
158 i_img_dim off;
159 int ch;
160  
161 11818 ▶ 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) 11817 1 11818
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 11816 1 11817
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 11815 1 11816
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 1 11814 11815
162 4 return -1;
163  
164 11814 off = (x + y * im->xsize) * im->channels;
165 11814 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 11813 1 11814
166 47252 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 35439 11813 47252
167 35439 ((double*)im->idata)[off+ch] = Sample8ToF(val->channel[ch]);
168 }
169 else {
170 4 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 3 1 4
171 3 ▶ if (im->ch_mask & (1<<ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1<<ch)) 2 1 3
172 2 ((double*)im->idata)[off+ch] = Sample8ToF(val->channel[ch]);
173 }
174  
175 11814 return 0;
176 }
177  
178 90278 static int i_gpix_ddoub(i_img *im, i_img_dim x, i_img_dim y, i_color *val) {
179 i_img_dim off;
180 int ch;
181  
182 90278 ▶ 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) 90276 2 90278
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 90274 2 90276
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 90272 2 90274
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 2 90270 90272
183 8 return -1;
184  
185 90270 off = (x + y * im->xsize) * im->channels;
186 361118 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 270848 90270 361118
187 270848 val->channel[ch] = SampleFTo8(((double *)im->idata)[off+ch]);
188  
189 90270 return 0;
190 }
191  
192 180019 static int i_ppixf_ddoub(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *val) {
193 i_img_dim off;
194 int ch;
195  
196 180019 ▶ 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) 180018 1 180019
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 180017 1 180018
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 180016 1 180017
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 1 180015 180016
197 4 return -1;
198  
199 180015 off = (x + y * im->xsize) * im->channels;
200 180015 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 180014 1 180015
201 720057 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 540043 180014 720057
202 540043 ((double *)im->idata)[off+ch] = val->channel[ch];
203 }
204 else {
205 4 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 3 1 4
206 3 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 2 1 3
207 2 ((double *)im->idata)[off+ch] = val->channel[ch];
208 }
209  
210 180015 return 0;
211 }
212  
213 1581816 static int i_gpixf_ddoub(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *val) {
214 i_img_dim off;
215 int ch;
216  
217 1581816 ▶ 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) 1581816 0 1581816
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 1581816 0 1581816
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 1581816 0 1581816
if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize) 0 1581816 1581816
218 0 return -1;
219  
220 1581816 off = (x + y * im->xsize) * im->channels;
221 6325871 ▶ for (ch = 0; ch < im->channels; ++ch)
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) 4744055 1581816 6325871
222 4744055 val->channel[ch] = ((double *)im->idata)[off+ch];
223  
224 1581816 return 0;
225 }
226  
227 12 static i_img_dim i_glin_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals) {
228 int ch;
229 i_img_dim count, i;
230 i_img_dim off;
231 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) { 12 0 12
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 12 0 12
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 12 0 12
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 12 0 12
232 12 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 12 12
233 0 r = im->xsize;
234 12 off = (l+y*im->xsize) * im->channels;
235 12 count = r - l;
236 136 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 124 12 136
237 496 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 372 124 496
238 372 vals[i].channel[ch] = SampleFTo8(((double *)im->idata)[off]);
239 372 ++off;
240 }
241 }
242 12 return count;
243 }
244 else {
245 0 return 0;
246 }
247 }
248  
249 2122 static i_img_dim i_plin_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals) {
250 int ch;
251 i_img_dim count, i;
252 i_img_dim off;
253 2122 ▶ 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) { 2122 0 2122
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2122 0 2122
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2122 0 2122
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 2122 0 2122
254 2122 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 2122 2122
255 0 r = im->xsize;
256 2122 off = (l+y*im->xsize) * im->channels;
257 2122 count = r - l;
258 2122 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 2121 1 2122
259 155688 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 153567 2121 155688
260 609784 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 456217 153567 609784
261 456217 ((double *)im->idata)[off] = Sample8ToF(vals[i].channel[ch]);
262 456217 ++off;
263 }
264 }
265 }
266 else {
267 2 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 1 1 2
268 4 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 3 1 4
269 3 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 2 1 3
270 2 ((double *)im->idata)[off] = Sample8ToF(vals[i].channel[ch]);
271 3 ++off;
272 }
273 }
274 }
275 2122 return count;
276 }
277 else {
278 0 return 0;
279 }
280 }
281  
282 7010 static i_img_dim i_glinf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals) {
283 int ch;
284 i_img_dim count, i;
285 i_img_dim off;
286 7010 ▶ 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) { 7010 0 7010
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 7010 0 7010
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 7010 0 7010
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 7010 0 7010
287 7010 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 7010 7010
288 0 r = im->xsize;
289 7010 off = (l+y*im->xsize) * im->channels;
290 7010 count = r - l;
291 691105 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 684095 7010 691105
292 2756903 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 2072808 684095 2756903
293 2072808 vals[i].channel[ch] = ((double *)im->idata)[off];
294 2072808 ++off;
295 }
296 }
297 7010 return count;
298 }
299 else {
300 0 return 0;
301 }
302 }
303  
304 8424 static i_img_dim i_plinf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals) {
305 int ch;
306 i_img_dim count, i;
307 i_img_dim off;
308 8424 ▶ 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) { 8424 0 8424
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 8423 1 8424
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 8423 0 8423
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 8423 0 8423
309 8423 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 8423 8423
310 0 r = im->xsize;
311 8423 off = (l+y*im->xsize) * im->channels;
312 8423 count = r - l;
313 8423 ▶ if (I_ALL_CHANNELS_WRITABLE(im)) {
Branch: 1 branch
BranchTrueFalseTotal
if (I_ALL_CHANNELS_WRITABLE(im)) { 8422 1 8423
314 824879 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 816457 8422 824879
315 3105517 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 2289060 816457 3105517
316 2289060 ((double *)im->idata)[off] = vals[i].channel[ch];
317 2289060 ++off;
318 }
319 }
320 }
321 else {
322 2 ▶ for (i = 0; i < count; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < count; ++i) { 1 1 2
323 4 ▶ for (ch = 0; ch < im->channels; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < im->channels; ++ch) { 3 1 4
324 3 ▶ if (im->ch_mask & (1 << ch))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << ch)) 2 1 3
325 2 ((double *)im->idata)[off] = vals[i].channel[ch];
326 3 ++off;
327 }
328 }
329 }
330 8423 return count;
331 }
332 else {
333 1 return 0;
334 }
335 }
336  
337 342 static i_img_dim i_gsamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samps,
338 int const *chans, int chan_count) {
339 int ch;
340 i_img_dim count, i, w;
341 i_img_dim off;
342  
343 342 ▶ 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) { 342 0 342
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 342 0 342
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 342 0 342
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 342 0 342
344 342 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 342 342
345 0 r = im->xsize;
346 342 off = (l+y*im->xsize) * im->channels;
347 342 w = r - l;
348 342 count = 0;
349  
350 342 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 2 340 342
351 /* make sure we have good channel numbers */
352 8 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 6 2 8
353 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
354 0 dIMCTXim(im);
355 0 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
356 0 return 0;
357 }
358 }
359 22 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 20 2 22
360 80 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 60 20 80
361 60 *samps++ = SampleFTo8(((double *)im->idata)[off+chans[ch]]);
362 60 ++count;
363 }
364 20 off += im->channels;
365 }
366 }
367 else {
368 340 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 340 0 340
if (chan_count <= 0 || chan_count > im->channels) { 0 340 340
369 0 dIMCTXim(im);
370 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
371 chan_count);
372 0 return 0;
373 }
374 27781 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 27441 340 27781
375 109764 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 82323 27441 109764
376 82323 *samps++ = SampleFTo8(((double *)im->idata)[off+ch]);
377 82323 ++count;
378 }
379 27441 off += im->channels;
380 }
381 }
382  
383 342 return count;
384 }
385 else {
386 0 return 0;
387 }
388 }
389  
390 1738 static i_img_dim i_gsampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samps,
391 int const *chans, int chan_count) {
392 int ch;
393 i_img_dim count, i, w;
394 i_img_dim off;
395  
396 1738 ▶ 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) { 1738 0 1738
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 1738 0 1738
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 1738 0 1738
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 1738 0 1738
397 1738 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 0 1738 1738
398 0 r = im->xsize;
399 1738 off = (l+y*im->xsize) * im->channels;
400 1738 w = r - l;
401 1738 count = 0;
402  
403 1738 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 1271 467 1738
404 /* make sure we have good channel numbers */
405 2542 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 1271 1271 2542
406 1271 ▶ if (chans[ch] < 0 || chans[ch] >= im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chans[ch] < 0 || chans[ch] >= im->channels) { 1271 0 1271
if (chans[ch] < 0 || chans[ch] >= im->channels) { 0 1271 1271
407 0 dIMCTXim(im);
408 0 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
409 0 return 0;
410 }
411 }
412 150207 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 148936 1271 150207
413 297872 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 148936 148936 297872
414 148936 *samps++ = ((double *)im->idata)[off+chans[ch]];
415 148936 ++count;
416 }
417 148936 off += im->channels;
418 }
419 }
420 else {
421 467 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 467 0 467
if (chan_count <= 0 || chan_count > im->channels) { 0 467 467
422 0 dIMCTXim(im);
423 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
424 chan_count);
425 0 return 0;
426 }
427 42462 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 41995 467 42462
428 169580 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 127585 41995 169580
429 127585 *samps++ = ((double *)im->idata)[off+ch];
430 127585 ++count;
431 }
432 41995 off += im->channels;
433 }
434 }
435  
436 1738 return count;
437 }
438 else {
439 0 return 0;
440 }
441 }
442  
443 /*
444 =item i_psamp_ddoub(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)
445  
446 Writes sample values to im for the horizontal line (l, y) to (r-1,y)
447 for the channels specified by chans, an array of int with chan_count
448 elements.
449  
450 Returns the number of samples written (which should be (r-l) *
451 bits_set(chan_mask)
452  
453 =cut
454 */
455  
456 static
457 i_img_dim
458 11 i_psamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
459 const i_sample_t *samps, const int *chans, int chan_count) {
460 int ch;
461 i_img_dim count, i, w;
462  
463 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
464 i_img_dim offset;
465 8 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 1 7 8
466 1 r = im->xsize;
467 8 offset = (l+y*im->xsize) * im->channels;
468 8 w = r - l;
469 8 count = 0;
470  
471 8 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 6 2 8
472 /* make sure we have good channel numbers */
473 /* and test if all channels specified are in the mask */
474 6 int all_in_mask = 1;
475 21 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 17 4 21
476 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
477 2 dIMCTXim(im);
478 2 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
479 2 return -1;
480 }
481 15 ▶ if (!((1 << chans[ch]) & im->ch_mask))
Branch: 1 branch
BranchTrueFalseTotal
if (!((1 << chans[ch]) & im->ch_mask)) 1 14 15
482 1 all_in_mask = 0;
483 }
484 4 ▶ if (all_in_mask) {
Branch: 1 branch
BranchTrueFalseTotal
if (all_in_mask) { 3 1 4
485 17 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 14 3 17
486 54 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 40 14 54
487 40 ((double*)im->idata)[offset + chans[ch]] = Sample8ToF(*samps);
488 40 ++samps;
489 40 ++count;
490 }
491 14 offset += im->channels;
492 }
493 }
494 else {
495 2 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 1 1 2
496 4 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 3 1 4
497 3 ▶ if (im->ch_mask & (1 << (chans[ch])))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << (chans[ch]))) 2 1 3
498 2 ((double*)im->idata)[offset + chans[ch]] = Sample8ToF(*samps);
499
500 3 ++samps;
501 3 ++count;
502 }
503 1 offset += im->channels;
504 }
505 }
506 }
507 else {
508 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
509 0 dIMCTXim(im);
510 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
511 chan_count);
512 0 return -1;
513 }
514 4 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 2 2 4
515 2 unsigned mask = 1;
516 8 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 6 2 8
517 6 ▶ if (im->ch_mask & mask)
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & mask) 5 1 6
518 5 ((double*)im->idata)[offset + ch] = Sample8ToF(*samps);
519  
520 6 ++samps;
521 6 ++count;
522 6 mask <<= 1;
523 }
524 2 offset += im->channels;
525 }
526 }
527  
528 6 return count;
529 }
530 else {
531 3 dIMCTXim(im);
532 3 i_push_error(0, "Image position outside of image");
533 3 return -1;
534 }
535 }
536  
537 /*
538 =item i_psampf_ddoub(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)
539  
540 Writes sample values to im for the horizontal line (l, y) to (r-1,y)
541 for the channels specified by chans, an array of int with chan_count
542 elements.
543  
544 Returns the number of samples written (which should be (r-l) *
545 bits_set(chan_mask)
546  
547 =cut
548 */
549  
550 static
551 i_img_dim
552 22 i_psampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
553 const i_fsample_t *samps, const int *chans, int chan_count) {
554 int ch;
555 i_img_dim count, i, w;
556  
557 22 ▶ 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) { 21 1 22
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 20 1 21
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 19 1 20
if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) { 18 1 19
558 i_img_dim offset;
559 18 ▶ if (r > im->xsize)
Branch: 1 branch
BranchTrueFalseTotal
if (r > im->xsize) 1 17 18
560 1 r = im->xsize;
561 18 offset = (l+y*im->xsize) * im->channels;
562 18 w = r - l;
563 18 count = 0;
564  
565 18 ▶ if (chans) {
Branch: 1 branch
BranchTrueFalseTotal
if (chans) { 6 12 18
566 /* make sure we have good channel numbers */
567 /* and test if all channels specified are in the mask */
568 6 int all_in_mask = 1;
569 21 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 17 4 21
570 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
571 2 dIMCTXim(im);
572 2 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
573 2 return -1;
574 }
575 15 ▶ if (!((1 << chans[ch]) & im->ch_mask))
Branch: 1 branch
BranchTrueFalseTotal
if (!((1 << chans[ch]) & im->ch_mask)) 1 14 15
576 1 all_in_mask = 0;
577 }
578 4 ▶ if (all_in_mask) {
Branch: 1 branch
BranchTrueFalseTotal
if (all_in_mask) { 3 1 4
579 17 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 14 3 17
580 54 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 40 14 54
581 40 ((double*)im->idata)[offset + chans[ch]] = *samps;
582 40 ++samps;
583 40 ++count;
584 }
585 14 offset += im->channels;
586 }
587 }
588 else {
589 2 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 1 1 2
590 4 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 3 1 4
591 3 ▶ if (im->ch_mask & (1 << (chans[ch])))
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & (1 << (chans[ch]))) 2 1 3
592 2 ((double*)im->idata)[offset + chans[ch]] = *samps;
593
594 3 ++samps;
595 3 ++count;
596 }
597 1 offset += im->channels;
598 }
599 }
600 }
601 else {
602 12 ▶ if (chan_count <= 0 || chan_count > im->channels) {
Branch: 2 branches
BranchTrueFalseTotal
if (chan_count <= 0 || chan_count > im->channels) { 12 0 12
if (chan_count <= 0 || chan_count > im->channels) { 0 12 12
603 0 dIMCTXim(im);
604 0 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
605 chan_count);
606 0 return -1;
607 }
608 114 ▶ for (i = 0; i < w; ++i) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < w; ++i) { 102 12 114
609 102 unsigned mask = 1;
610 408 ▶ for (ch = 0; ch < chan_count; ++ch) {
Branch: 1 branch
BranchTrueFalseTotal
for (ch = 0; ch < chan_count; ++ch) { 306 102 408
611 306 ▶ if (im->ch_mask & mask)
Branch: 1 branch
BranchTrueFalseTotal
if (im->ch_mask & mask) 305 1 306
612 305 ((double*)im->idata)[offset + ch] = *samps;
613  
614 306 ++samps;
615 306 ++count;
616 306 mask <<= 1;
617 }
618 102 offset += im->channels;
619 }
620 }
621  
622 16 return count;
623 }
624 else {
625 4 dIMCTXim(im);
626 4 i_push_error(0, "Image position outside of image");
627 4 return -1;
628 }
629 }
630  
631 /*
632 =item i_img_to_drgb(im)
633  
634 =category Image creation
635  
636 Returns a double/sample version of the supplied image.
637  
638 Returns the image on success, or NULL on failure.
639  
640 =cut
641 */
642  
643 i_img *
644 2 i_img_to_drgb(i_img *im) {
645 i_img *targ;
646 i_fcolor *line;
647 i_img_dim y;
648 2 dIMCTXim(im);
649  
650 2 targ = im_img_double_new(aIMCTX, im->xsize, im->ysize, im->channels);
651 2 ▶ if (!targ)
Branch: 1 branch
BranchTrueFalseTotal
if (!targ) 0 2 2
652 0 return NULL;
653 2 line = mymalloc(sizeof(i_fcolor) * im->xsize);
654 162 ▶ for (y = 0; y < im->ysize; ++y) {
Branch: 1 branch
BranchTrueFalseTotal
for (y = 0; y < im->ysize; ++y) { 160 2 162
655 160 i_glinf(im, 0, im->xsize, y, line);
656 160 i_plinf(targ, 0, im->xsize, y, line);
657 }
658  
659 2 myfree(line);
660  
661 2 return targ;
662 }
663  
664 /*
665 =back
666  
667 =head1 AUTHOR
668  
669 Tony Cook <tony@develop-help.com>
670  
671 =head1 SEE ALSO
672  
673 Imager(3)
674  
675 =cut
676 */
« img8.c ↑ Summary limits.c »