4 imgdouble.c - implements double per sample images
8 i_img *im = i_img_double_new(width, height, channels);
9 # use like a normal image
13 Implements double/sample images.
15 This basic implementation is required so that we have some larger
16 sample image type to work with.
23 #define IMAGER_NO_CONTEXT
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);
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);
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);
45 =item IIM_base_16bit_direct
47 Base structure used to initialize a 16-bit/sample image.
53 static i_img IIM_base_double_direct =
56 0, 0, 0, /* xsize, ysize, bytes */
58 i_double_bits, /* bits */
59 i_direct_type, /* type */
62 { 0, 0, NULL }, /* tags */
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 */
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 */
85 NULL, /* i_f_destroy */
88 NULL, /* i_f_psamp_bits */
90 i_psamp_ddoub, /* i_f_psamp */
91 i_psampf_ddoub /* i_f_psampf */
95 =item im_img_double_new(ctx, x, y, ch)
96 X<im_img_double_new API>X<i_img_double_new API>
97 =category Image creation/destruction
98 =synopsis i_img *img = im_img_double_new(aIMCTX, width, height, channels);
99 =synopsis i_img *img = i_img_double_new(width, height, channels);
101 Creates a new double per sample image.
103 Also callable as C<i_img_double_new(width, height, channels)>.
108 im_img_double_new(pIMCTX, i_img_dim x, i_img_dim y, int ch) {
112 im_log((aIMCTX, 1,"i_img_double_new(x %" i_DF ", y %" i_DF ", ch %d)\n",
113 i_DFc(x), i_DFc(y), ch));
115 if (x < 1 || y < 1) {
116 im_push_error(aIMCTX, 0, "Image sizes must be positive");
119 if (ch < 1 || ch > MAXCHANNELS) {
120 im_push_errorf(aIMCTX, 0, "channels must be between 1 and %d", MAXCHANNELS);
123 bytes = x * y * ch * sizeof(double);
124 if (bytes / y / ch / sizeof(double) != x) {
125 im_push_errorf(aIMCTX, 0, "integer overflow calculating image allocation");
129 im = im_img_alloc(aIMCTX);
130 *im = IIM_base_double_direct;
131 i_tags_new(&im->tags);
137 im->idata = mymalloc(im->bytes);
138 memset(im->idata, 0, im->bytes);
139 im_img_init(aIMCTX, im);
144 static int i_ppix_ddoub(i_img *im, i_img_dim x, i_img_dim y, const i_color *val) {
148 if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
151 off = (x + y * im->xsize) * im->channels;
152 if (I_ALL_CHANNELS_WRITABLE(im)) {
153 for (ch = 0; ch < im->channels; ++ch)
154 ((double*)im->idata)[off+ch] = Sample8ToF(val->channel[ch]);
157 for (ch = 0; ch < im->channels; ++ch)
158 if (im->ch_mask & (1<<ch))
159 ((double*)im->idata)[off+ch] = Sample8ToF(val->channel[ch]);
165 static int i_gpix_ddoub(i_img *im, i_img_dim x, i_img_dim y, i_color *val) {
169 if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
172 off = (x + y * im->xsize) * im->channels;
173 for (ch = 0; ch < im->channels; ++ch)
174 val->channel[ch] = SampleFTo8(((double *)im->idata)[off+ch]);
179 static int i_ppixf_ddoub(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *val) {
183 if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
186 off = (x + y * im->xsize) * im->channels;
187 if (I_ALL_CHANNELS_WRITABLE(im)) {
188 for (ch = 0; ch < im->channels; ++ch)
189 ((double *)im->idata)[off+ch] = val->channel[ch];
192 for (ch = 0; ch < im->channels; ++ch)
193 if (im->ch_mask & (1 << ch))
194 ((double *)im->idata)[off+ch] = val->channel[ch];
200 static int i_gpixf_ddoub(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *val) {
204 if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
207 off = (x + y * im->xsize) * im->channels;
208 for (ch = 0; ch < im->channels; ++ch)
209 val->channel[ch] = ((double *)im->idata)[off+ch];
214 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) {
218 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
221 off = (l+y*im->xsize) * im->channels;
223 for (i = 0; i < count; ++i) {
224 for (ch = 0; ch < im->channels; ++ch) {
225 vals[i].channel[ch] = SampleFTo8(((double *)im->idata)[off]);
236 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) {
240 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
243 off = (l+y*im->xsize) * im->channels;
245 if (I_ALL_CHANNELS_WRITABLE(im)) {
246 for (i = 0; i < count; ++i) {
247 for (ch = 0; ch < im->channels; ++ch) {
248 ((double *)im->idata)[off] = Sample8ToF(vals[i].channel[ch]);
254 for (i = 0; i < count; ++i) {
255 for (ch = 0; ch < im->channels; ++ch) {
256 if (im->ch_mask & (1 << ch))
257 ((double *)im->idata)[off] = Sample8ToF(vals[i].channel[ch]);
269 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) {
273 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
276 off = (l+y*im->xsize) * im->channels;
278 for (i = 0; i < count; ++i) {
279 for (ch = 0; ch < im->channels; ++ch) {
280 vals[i].channel[ch] = ((double *)im->idata)[off];
291 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) {
295 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
298 off = (l+y*im->xsize) * im->channels;
300 if (I_ALL_CHANNELS_WRITABLE(im)) {
301 for (i = 0; i < count; ++i) {
302 for (ch = 0; ch < im->channels; ++ch) {
303 ((double *)im->idata)[off] = vals[i].channel[ch];
309 for (i = 0; i < count; ++i) {
310 for (ch = 0; ch < im->channels; ++ch) {
311 if (im->ch_mask & (1 << ch))
312 ((double *)im->idata)[off] = vals[i].channel[ch];
324 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,
325 int const *chans, int chan_count) {
327 i_img_dim count, i, w;
330 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
333 off = (l+y*im->xsize) * im->channels;
338 /* make sure we have good channel numbers */
339 for (ch = 0; ch < chan_count; ++ch) {
340 if (chans[ch] < 0 || chans[ch] >= im->channels) {
342 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
346 for (i = 0; i < w; ++i) {
347 for (ch = 0; ch < chan_count; ++ch) {
348 *samps++ = SampleFTo8(((double *)im->idata)[off+chans[ch]]);
355 if (chan_count <= 0 || chan_count > im->channels) {
357 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
361 for (i = 0; i < w; ++i) {
362 for (ch = 0; ch < chan_count; ++ch) {
363 *samps++ = SampleFTo8(((double *)im->idata)[off+ch]);
377 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,
378 int const *chans, int chan_count) {
380 i_img_dim count, i, w;
383 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
386 off = (l+y*im->xsize) * im->channels;
391 /* make sure we have good channel numbers */
392 for (ch = 0; ch < chan_count; ++ch) {
393 if (chans[ch] < 0 || chans[ch] >= im->channels) {
395 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
399 for (i = 0; i < w; ++i) {
400 for (ch = 0; ch < chan_count; ++ch) {
401 *samps++ = ((double *)im->idata)[off+chans[ch]];
408 if (chan_count <= 0 || chan_count > im->channels) {
410 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
414 for (i = 0; i < w; ++i) {
415 for (ch = 0; ch < chan_count; ++ch) {
416 *samps++ = ((double *)im->idata)[off+ch];
431 =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)
433 Writes sample values to im for the horizontal line (l, y) to (r-1,y)
434 for the channels specified by chans, an array of int with chan_count
437 Returns the number of samples written (which should be (r-l) *
445 i_psamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
446 const i_sample_t *samps, const int *chans, int chan_count) {
448 i_img_dim count, i, w;
450 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
454 offset = (l+y*im->xsize) * im->channels;
459 /* make sure we have good channel numbers */
460 /* and test if all channels specified are in the mask */
462 for (ch = 0; ch < chan_count; ++ch) {
463 if (chans[ch] < 0 || chans[ch] >= im->channels) {
465 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
468 if (!((1 << chans[ch]) & im->ch_mask))
472 for (i = 0; i < w; ++i) {
473 for (ch = 0; ch < chan_count; ++ch) {
474 ((double*)im->idata)[offset + chans[ch]] = Sample8ToF(*samps);
478 offset += im->channels;
482 for (i = 0; i < w; ++i) {
483 for (ch = 0; ch < chan_count; ++ch) {
484 if (im->ch_mask & (1 << (chans[ch])))
485 ((double*)im->idata)[offset + chans[ch]] = Sample8ToF(*samps);
490 offset += im->channels;
495 if (chan_count <= 0 || chan_count > im->channels) {
497 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
501 for (i = 0; i < w; ++i) {
503 for (ch = 0; ch < chan_count; ++ch) {
504 if (im->ch_mask & mask)
505 ((double*)im->idata)[offset + ch] = Sample8ToF(*samps);
511 offset += im->channels;
519 i_push_error(0, "Image position outside of image");
525 =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)
527 Writes sample values to im for the horizontal line (l, y) to (r-1,y)
528 for the channels specified by chans, an array of int with chan_count
531 Returns the number of samples written (which should be (r-l) *
539 i_psampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
540 const i_fsample_t *samps, const int *chans, int chan_count) {
542 i_img_dim count, i, w;
544 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
548 offset = (l+y*im->xsize) * im->channels;
553 /* make sure we have good channel numbers */
554 /* and test if all channels specified are in the mask */
556 for (ch = 0; ch < chan_count; ++ch) {
557 if (chans[ch] < 0 || chans[ch] >= im->channels) {
559 im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
562 if (!((1 << chans[ch]) & im->ch_mask))
566 for (i = 0; i < w; ++i) {
567 for (ch = 0; ch < chan_count; ++ch) {
568 ((double*)im->idata)[offset + chans[ch]] = *samps;
572 offset += im->channels;
576 for (i = 0; i < w; ++i) {
577 for (ch = 0; ch < chan_count; ++ch) {
578 if (im->ch_mask & (1 << (chans[ch])))
579 ((double*)im->idata)[offset + chans[ch]] = *samps;
584 offset += im->channels;
589 if (chan_count <= 0 || chan_count > im->channels) {
591 im_push_errorf(aIMCTX, 0, "chan_count %d out of range, must be >0, <= channels",
595 for (i = 0; i < w; ++i) {
597 for (ch = 0; ch < chan_count; ++ch) {
598 if (im->ch_mask & mask)
599 ((double*)im->idata)[offset + ch] = *samps;
605 offset += im->channels;
613 i_push_error(0, "Image position outside of image");
619 =item i_img_to_drgb(im)
621 =category Image creation
623 Returns a double/sample version of the supplied image.
625 Returns the image on success, or NULL on failure.
631 i_img_to_drgb(i_img *im) {
637 targ = im_img_double_new(aIMCTX, im->xsize, im->ysize, im->channels);
640 line = mymalloc(sizeof(i_fcolor) * im->xsize);
641 for (y = 0; y < im->ysize; ++y) {
642 i_glinf(im, 0, im->xsize, y, line);
643 i_plinf(targ, 0, im->xsize, y, line);
656 Tony Cook <tony@develop-help.com>