fix method index entry for add_file_magic()
[imager.git] / image.c
1 #define IMAGER_NO_CONTEXT
2
3 #include "imager.h"
4 #include "imageri.h"
5
6 /*
7 =head1 NAME
8
9 image.c - implements most of the basic functions of Imager and much of the rest
10
11 =head1 SYNOPSIS
12
13   i_img *i;
14   i_color *c;
15   c = i_color_new(red, green, blue, alpha);
16   ICL_DESTROY(c);
17   i = i_img_8_new();
18   i_img_destroy(i);
19   // and much more
20
21 =head1 DESCRIPTION
22
23 image.c implements the basic functions to create and destroy image and
24 color objects for Imager.
25
26 =head1 FUNCTION REFERENCE
27
28 Some of these functions are internal.
29
30 =over
31
32 =cut
33 */
34
35 im_context_t (*im_get_context)(void) = NULL;
36
37 #define XAXIS 0
38 #define YAXIS 1
39 #define XYAXIS 2
40
41 #define minmax(a,b,i) ( ((a>=i)?a: ( (b<=i)?b:i   )) )
42
43 /* Hack around an obscure linker bug on solaris - probably due to builtin gcc thingies */
44 void i_linker_bug_fake(void) { ceil(1); }
45
46 /*
47 =item im_img_alloc(aIMCTX)
48 X<im_img_alloc API>X<i_img_alloc API>
49 =category Image Implementation
50 =synopsis i_img *im = im_img_alloc(aIMCTX);
51 =synopsis i_img *im = i_img_alloc();
52
53 Allocates a new i_img structure.
54
55 When implementing a new image type perform the following steps in your
56 image object creation function:
57
58 =over
59
60 =item 1.
61
62 allocate the image with i_img_alloc().
63
64 =item 2.
65
66 initialize any function pointers or other data as needed, you can
67 overwrite the whole block if you need to.
68
69 =item 3.
70
71 initialize Imager's internal data by calling i_img_init() on the image
72 object.
73
74 =back
75
76 =cut
77 */
78
79 i_img *
80 im_img_alloc(pIMCTX) {
81   return mymalloc(sizeof(i_img));
82 }
83
84 /*
85 =item im_img_init(aIMCTX, image)
86 X<im_img_init API>X<i_img_init API>
87 =category Image Implementation
88 =synopsis im_img_init(aIMCTX, im);
89 =synopsis i_img_init(im);
90
91 Imager internal initialization of images.
92
93 See L</im_img_alloc(aIMCTX)> for more information.
94
95 =cut
96 */
97
98 void
99 im_img_init(pIMCTX, i_img *img) {
100   img->im_data = NULL;
101   img->context = aIMCTX;
102   im_context_refinc(aIMCTX, "img_init");
103 }
104
105 /* 
106 =item ICL_new_internal(r, g, b, a)
107
108 Return a new color object with values passed to it.
109
110    r - red   component (range: 0 - 255)
111    g - green component (range: 0 - 255)
112    b - blue  component (range: 0 - 255)
113    a - alpha component (range: 0 - 255)
114
115 =cut
116 */
117
118 i_color *
119 ICL_new_internal(unsigned char r,unsigned char g,unsigned char b,unsigned char a) {
120   i_color *cl = NULL;
121   dIMCTX;
122
123   im_log((aIMCTX,1,"ICL_new_internal(r %d,g %d,b %d,a %d)\n", r, g, b, a));
124
125   if ( (cl=mymalloc(sizeof(i_color))) == NULL) im_fatal(aIMCTX, 2,"malloc() error\n");
126   cl->rgba.r = r;
127   cl->rgba.g = g;
128   cl->rgba.b = b;
129   cl->rgba.a = a;
130   im_log((aIMCTX,1,"(%p) <- ICL_new_internal\n",cl));
131   return cl;
132 }
133
134
135 /*
136 =item ICL_set_internal(cl, r, g, b, a)
137
138  Overwrite a color with new values.
139
140    cl - pointer to color object
141    r - red   component (range: 0 - 255)
142    g - green component (range: 0 - 255)
143    b - blue  component (range: 0 - 255)
144    a - alpha component (range: 0 - 255)
145
146 =cut
147 */
148
149 i_color *
150 ICL_set_internal(i_color *cl,unsigned char r,unsigned char g,unsigned char b,unsigned char a) {
151   dIMCTX;
152   im_log((aIMCTX,1,"ICL_set_internal(cl* %p,r %d,g %d,b %d,a %d)\n",cl,r,g,b,a));
153   if (cl == NULL)
154     if ( (cl=mymalloc(sizeof(i_color))) == NULL)
155       im_fatal(aIMCTX, 2,"malloc() error\n");
156   cl->rgba.r=r;
157   cl->rgba.g=g;
158   cl->rgba.b=b;
159   cl->rgba.a=a;
160   im_log((aIMCTX,1,"(%p) <- ICL_set_internal\n",cl));
161   return cl;
162 }
163
164
165 /* 
166 =item ICL_add(dst, src, ch)
167
168 Add src to dst inplace - dst is modified.
169
170    dst - pointer to destination color object
171    src - pointer to color object that is added
172    ch - number of channels
173
174 =cut
175 */
176
177 void
178 ICL_add(i_color *dst,i_color *src,int ch) {
179   int tmp,i;
180   for(i=0;i<ch;i++) {
181     tmp=dst->channel[i]+src->channel[i];
182     dst->channel[i]= tmp>255 ? 255:tmp;
183   }
184 }
185
186 /* 
187 =item ICL_info(cl)
188
189 Dump color information to log - strictly for debugging.
190
191    cl - pointer to color object
192
193 =cut
194 */
195
196 void
197 ICL_info(i_color const *cl) {
198   dIMCTX;
199   im_log((aIMCTX, 1,"i_color_info(cl* %p)\n",cl));
200   im_log((aIMCTX, 1,"i_color_info: (%d,%d,%d,%d)\n",cl->rgba.r,cl->rgba.g,cl->rgba.b,cl->rgba.a));
201 }
202
203 /* 
204 =item ICL_DESTROY
205
206 Destroy ancillary data for Color object.
207
208    cl - pointer to color object
209
210 =cut
211 */
212
213 void
214 ICL_DESTROY(i_color *cl) {
215   dIMCTX;
216   im_log((aIMCTX, 1,"ICL_DESTROY(cl* %p)\n",cl));
217   myfree(cl);
218 }
219
220 /*
221 =item i_fcolor_new(double r, double g, double b, double a)
222
223 =cut
224 */
225 i_fcolor *i_fcolor_new(double r, double g, double b, double a) {
226   i_fcolor *cl = NULL;
227   dIMCTX;
228
229   im_log((aIMCTX, 1,"i_fcolor_new(r %g,g %g,b %g,a %g)\n", r, g, b, a));
230
231   if ( (cl=mymalloc(sizeof(i_fcolor))) == NULL) im_fatal(aIMCTX, 2,"malloc() error\n");
232   cl->rgba.r = r;
233   cl->rgba.g = g;
234   cl->rgba.b = b;
235   cl->rgba.a = a;
236   im_log((aIMCTX, 1,"(%p) <- i_fcolor_new\n",cl));
237
238   return cl;
239 }
240
241 /*
242 =item i_fcolor_destroy(i_fcolor *cl) 
243
244 =cut
245 */
246 void i_fcolor_destroy(i_fcolor *cl) {
247   myfree(cl);
248 }
249
250 /* 
251 =item i_img_exorcise(im)
252
253 Free image data.
254
255    im - Image pointer
256
257 =cut
258 */
259
260 void
261 i_img_exorcise(i_img *im) {
262   dIMCTXim(im);
263   im_log((aIMCTX,1,"i_img_exorcise(im* %p)\n",im));
264   i_tags_destroy(&im->tags);
265   if (im->i_f_destroy)
266     (im->i_f_destroy)(im);
267   if (im->idata != NULL) { myfree(im->idata); }
268   im->idata    = NULL;
269   im->xsize    = 0;
270   im->ysize    = 0;
271   im->channels = 0;
272
273   im->ext_data=NULL;
274 }
275
276 /* 
277 =item i_img_destroy(C<img>)
278 =order 90
279 =category Image creation/destruction
280 =synopsis i_img_destroy(img)
281
282 Destroy an image object
283
284 =cut
285 */
286
287 void
288 i_img_destroy(i_img *im) {
289   dIMCTXim(im);
290   im_log((aIMCTX, 1,"i_img_destroy(im %p)\n",im));
291   i_img_exorcise(im);
292   myfree(im);
293   im_context_refdec(aIMCTX, "img_destroy");
294 }
295
296 /* 
297 =item i_img_info(im, info)
298
299 =category Image
300
301 Return image information
302
303    im - Image pointer
304    info - pointer to array to return data
305
306 info is an array of 4 integers with the following values:
307
308  info[0] - width
309  info[1] - height
310  info[2] - channels
311  info[3] - channel mask
312
313 =cut
314 */
315
316
317 void
318 i_img_info(i_img *im, i_img_dim *info) {
319   dIMCTXim(im);
320   im_log((aIMCTX,1,"i_img_info(im %p)\n",im));
321
322   im_log((aIMCTX,1,"i_img_info: xsize=%" i_DF " ysize=%" i_DF " channels=%d "
323           "mask=%ud\n",
324           i_DFc(im->xsize), i_DFc(im->ysize), im->channels,im->ch_mask));
325   im_log((aIMCTX,1,"i_img_info: idata=%p\n",im->idata));
326   info[0] = im->xsize;
327   info[1] = im->ysize;
328   info[2] = im->channels;
329   info[3] = im->ch_mask;
330 }
331
332 /*
333 =item i_img_setmask(C<im>, C<ch_mask>)
334 =category Image Information
335 =synopsis // only channel 0 writable 
336 =synopsis i_img_setmask(img, 0x01);
337
338 Set the image channel mask for C<im> to C<ch_mask>.
339
340 The image channel mask gives some control over which channels can be
341 written to in the image.
342
343 =cut
344 */
345 void
346 i_img_setmask(i_img *im,int ch_mask) { im->ch_mask=ch_mask; }
347
348
349 /*
350 =item i_img_getmask(C<im>)
351 =category Image Information
352 =synopsis int mask = i_img_getmask(img);
353
354 Get the image channel mask for C<im>.
355
356 =cut
357 */
358 int
359 i_img_getmask(i_img *im) { return im->ch_mask; }
360
361 /*
362 =item i_img_getchannels(C<im>)
363 =category Image Information
364 =synopsis int channels = i_img_getchannels(img);
365
366 Get the number of channels in C<im>.
367
368 =cut
369 */
370 int
371 i_img_getchannels(i_img *im) { return im->channels; }
372
373 /*
374 =item i_img_get_width(C<im>)
375 =category Image Information
376 =synopsis i_img_dim width = i_img_get_width(im);
377
378 Returns the width in pixels of the image.
379
380 =cut
381 */
382 i_img_dim
383 i_img_get_width(i_img *im) {
384   return im->xsize;
385 }
386
387 /*
388 =item i_img_get_height(C<im>)
389 =category Image Information
390 =synopsis i_img_dim height = i_img_get_height(im);
391
392 Returns the height in pixels of the image.
393
394 =cut
395 */
396 i_img_dim
397 i_img_get_height(i_img *im) {
398   return im->ysize;
399 }
400
401 /*
402 =item i_img_color_model(im)
403 =category Image Information
404 =synopsis i_color_model_t cm = i_img_color_model(im);
405
406 Returns the color model for the image.
407
408 A future version of Imager will allow for images with extra channels
409 beyond gray/rgb and alpha.
410
411 =cut
412 */
413 i_color_model_t
414 i_img_color_model(i_img *im) {
415   return (i_color_model_t)im->channels;
416 }
417
418 /*
419 =item i_img_alpha_channel(im, &channel)
420 =category Image Information
421 =synopsis int alpha_channel;
422 =synopsis int has_alpha = i_img_alpha_channel(im, &alpha_channel);
423
424 Work out the alpha channel for an image.
425
426 If the image has an alpha channel, sets C<*channel> to the alpha
427 channel index and returns non-zero.
428
429 If the image has no alpha channel, returns zero and C<*channel> is not
430 modified.
431
432 C<channel> may be C<NULL>.
433
434 =cut
435 */
436
437 int
438 i_img_alpha_channel(i_img *im, int *channel) {
439   i_color_model_t model = i_img_color_model(im);
440   switch (model) {
441   case icm_gray_alpha:
442   case icm_rgb_alpha:
443     if (channel) *channel = (int)model - 1;
444     return 1;
445
446   default:
447     return 0;
448   }
449 }
450
451 /*
452 =item i_img_color_channels(im)
453 =category Image Information
454 =synopsis int color_channels = i_img_color_channels(im);
455
456 Returns the number of color channels in the image.  For now this is
457 always 1 (for grayscale) or 3 (for RGB) but may be 0 in some special
458 cases in a future release of Imager.
459
460 =cut
461 */
462
463 int
464 i_img_color_channels(i_img *im) {
465   i_color_model_t model = i_img_color_model(im);
466   switch (model) {
467   case icm_gray_alpha:
468   case icm_rgb_alpha:
469     return (int)model - 1;
470
471   case icm_gray:
472   case icm_rgb:
473     return (int)model;
474
475   default:
476     return 0;
477   }
478 }
479
480 /*
481 =item i_copyto_trans(C<im>, C<src>, C<x1>, C<y1>, C<x2>, C<y2>, C<tx>, C<ty>, C<trans>)
482
483 =category Image
484
485 (C<x1>,C<y1>) (C<x2>,C<y2>) specifies the region to copy (in the
486 source coordinates) (C<tx>,C<ty>) specifies the upper left corner for
487 the target image.  pass NULL in C<trans> for non transparent i_colors.
488
489 =cut
490 */
491
492 void
493 i_copyto_trans(i_img *im,i_img *src,i_img_dim x1,i_img_dim y1,i_img_dim x2,i_img_dim y2,i_img_dim tx,i_img_dim ty,const i_color *trans) {
494   i_color pv;
495   i_img_dim x,y,t,ttx,tty,tt;
496   int ch;
497   dIMCTXim(im);
498
499   im_log((aIMCTX, 1,"i_copyto_trans(im* %p,src %p, p1(" i_DFp "), p2(" i_DFp "), "
500           "to(" i_DFp "), trans* %p)\n",
501           im, src, i_DFcp(x1, y1), i_DFcp(x2, y2), i_DFcp(tx, ty), trans));
502   
503   if (x2<x1) { t=x1; x1=x2; x2=t; }
504   if (y2<y1) { t=y1; y1=y2; y2=t; }
505
506   ttx=tx;
507   for(x=x1;x<x2;x++)
508     {
509       tty=ty;
510       for(y=y1;y<y2;y++)
511         {
512           i_gpix(src,x,y,&pv);
513           if ( trans != NULL)
514           {
515             tt=0;
516             for(ch=0;ch<im->channels;ch++) if (trans->channel[ch]!=pv.channel[ch]) tt++;
517             if (tt) i_ppix(im,ttx,tty,&pv);
518           } else i_ppix(im,ttx,tty,&pv);
519           tty++;
520         }
521       ttx++;
522     }
523 }
524
525 /*
526 =item i_copy(source)
527
528 =category Image
529
530 Creates a new image that is a copy of the image C<source>.
531
532 Tags are not copied, only the image data.
533
534 Returns: i_img *
535
536 =cut
537 */
538
539 i_img *
540 i_copy(i_img *src) {
541   i_img_dim y, y1, x1;
542   dIMCTXim(src);
543   i_img *im = i_sametype(src, src->xsize, src->ysize);
544
545   im_log((aIMCTX,1,"i_copy(src %p)\n", src));
546
547   if (!im)
548     return NULL;
549
550   x1 = src->xsize;
551   y1 = src->ysize;
552   if (src->type == i_direct_type) {
553     if (src->bits == i_8_bits) {
554       i_color *pv;
555       pv = mymalloc(sizeof(i_color) * x1);
556       
557       for (y = 0; y < y1; ++y) {
558         i_glin(src, 0, x1, y, pv);
559         i_plin(im, 0, x1, y, pv);
560       }
561       myfree(pv);
562     }
563     else {
564       i_fcolor *pv;
565
566       pv = mymalloc(sizeof(i_fcolor) * x1);
567       for (y = 0; y < y1; ++y) {
568         i_glinf(src, 0, x1, y, pv);
569         i_plinf(im, 0, x1, y, pv);
570       }
571       myfree(pv);
572     }
573   }
574   else {
575     i_palidx *vals;
576
577     vals = mymalloc(sizeof(i_palidx) * x1);
578     for (y = 0; y < y1; ++y) {
579       i_gpal(src, 0, x1, y, vals);
580       i_ppal(im, 0, x1, y, vals);
581     }
582     myfree(vals);
583   }
584
585   return im;
586 }
587
588 /*
589
590 http://en.wikipedia.org/wiki/Lanczos_resampling
591
592 */
593
594 static
595 float
596 Lanczos(float x) {
597   float PIx, PIx2;
598   
599   PIx = PI * x;
600   PIx2 = PIx / 2.0;
601   
602   if ((x >= 2.0) || (x <= -2.0)) return (0.0);
603   else if (x == 0.0) return (1.0);
604   else return(sin(PIx) / PIx * sin(PIx2) / PIx2);
605 }
606
607
608 /*
609 =item i_scaleaxis(im, value, axis)
610
611 Returns a new image object which is I<im> scaled by I<value> along
612 wither the x-axis (I<axis> == 0) or the y-axis (I<axis> == 1).
613
614 =cut
615 */
616
617 i_img*
618 i_scaleaxis(i_img *im, double Value, int Axis) {
619   i_img_dim hsize, vsize, i, j, k, l, lMax, iEnd, jEnd;
620   i_img_dim LanczosWidthFactor;
621   float *l0, *l1;
622   double OldLocation;
623   i_img_dim T; 
624   double t;
625   float F, PictureValue[MAXCHANNELS];
626   short psave;
627   i_color val,val1,val2;
628   i_img *new_img;
629   int has_alpha = i_img_has_alpha(im);
630   int color_chans = i_img_color_channels(im);
631   dIMCTXim(im);
632
633   i_clear_error();
634   im_log((aIMCTX, 1,"i_scaleaxis(im %p,Value %.2f,Axis %d)\n",im,Value,Axis));
635
636   if (Axis == XAXIS) {
637     hsize = (i_img_dim)(0.5 + im->xsize * Value);
638     if (hsize < 1) {
639       hsize = 1;
640       Value = 1.0 / im->xsize;
641     }
642     vsize = im->ysize;
643     
644     jEnd = hsize;
645     iEnd = vsize;
646   } else {
647     hsize = im->xsize;
648     vsize = (i_img_dim)(0.5 + im->ysize * Value);
649
650     if (vsize < 1) {
651       vsize = 1;
652       Value = 1.0 / im->ysize;
653     }
654
655     jEnd = vsize;
656     iEnd = hsize;
657   }
658   
659   new_img = i_img_8_new(hsize, vsize, im->channels);
660   if (!new_img) {
661     i_push_error(0, "cannot create output image");
662     return NULL;
663   }
664   
665   /* 1.4 is a magic number, setting it to 2 will cause rather blurred images */
666   LanczosWidthFactor = (Value >= 1) ? 1 : (i_img_dim) (1.4/Value); 
667   lMax = LanczosWidthFactor << 1;
668   
669   l0 = mymalloc(lMax * sizeof(float));
670   l1 = mymalloc(lMax * sizeof(float));
671   
672   for (j=0; j<jEnd; j++) {
673     OldLocation = ((double) j) / Value;
674     T = (i_img_dim) (OldLocation);
675     F = OldLocation - T;
676     
677     for (l = 0; l<lMax; l++) {
678       l0[lMax-l-1] = Lanczos(((float) (lMax-l-1) + F) / (float) LanczosWidthFactor);
679       l1[l]        = Lanczos(((float) (l+1)      - F) / (float) LanczosWidthFactor);
680     }
681     
682     /* Make sure filter is normalized */
683     t = 0.0;
684     for(l=0; l<lMax; l++) {
685       t+=l0[l];
686       t+=l1[l];
687     }
688     t /= (double)LanczosWidthFactor;
689     
690     for(l=0; l<lMax; l++) {
691       l0[l] /= t;
692       l1[l] /= t;
693     }
694
695     if (Axis == XAXIS) {
696       
697       for (i=0; i<iEnd; i++) {
698         for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
699         for (l=0; l<lMax; l++) {
700           i_img_dim mx = T-lMax+l+1;
701           i_img_dim Mx = T+l+1;
702           mx = (mx < 0) ? 0 : mx;
703           Mx = (Mx >= im->xsize) ? im->xsize-1 : Mx;
704           
705           i_gpix(im, Mx, i, &val1);
706           i_gpix(im, mx, i, &val2);
707
708           if (has_alpha) {
709             i_sample_t alpha1 = val1.channel[color_chans];
710             i_sample_t alpha2 = val2.channel[color_chans];
711             for (k=0; k < color_chans; k++) {
712               PictureValue[k] += l1[l]        * val1.channel[k] * alpha1 / 255;
713               PictureValue[k] += l0[lMax-l-1] * val2.channel[k] * alpha2 / 255;
714             }
715             PictureValue[color_chans] += l1[l] * val1.channel[color_chans];
716             PictureValue[color_chans] += l0[lMax-l-1] * val2.channel[color_chans];
717           }
718           else {
719             for (k=0; k<im->channels; k++) {
720               PictureValue[k] += l1[l]        * val1.channel[k];
721               PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
722             }
723           }
724         }
725
726         if (has_alpha) {
727           float fa = PictureValue[color_chans] / LanczosWidthFactor;
728           int alpha = minmax(0, 255, fa+0.5);
729           if (alpha) {
730             for (k = 0; k < color_chans; ++k) {
731               psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor * 255 / fa));
732               val.channel[k]=minmax(0,255,psave);
733             }
734             val.channel[color_chans] = alpha;
735           }
736           else {
737             /* zero alpha, so the pixel has no color */
738             for (k = 0; k < im->channels; ++k)
739               val.channel[k] = 0;
740           }
741         }
742         else {
743           for(k=0;k<im->channels;k++) {
744             psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
745             val.channel[k]=minmax(0,255,psave);
746           }
747         }
748         i_ppix(new_img, j, i, &val);
749       }
750       
751     } else {
752       
753       for (i=0; i<iEnd; i++) {
754         for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
755         for (l=0; l < lMax; l++) {
756           i_img_dim mx = T-lMax+l+1;
757           i_img_dim Mx = T+l+1;
758           mx = (mx < 0) ? 0 : mx;
759           Mx = (Mx >= im->ysize) ? im->ysize-1 : Mx;
760
761           i_gpix(im, i, Mx, &val1);
762           i_gpix(im, i, mx, &val2);
763           if (has_alpha) {
764             i_sample_t alpha1 = val1.channel[color_chans];
765             i_sample_t alpha2 = val2.channel[color_chans];
766             for (k=0; k < color_chans; k++) {
767               PictureValue[k] += l1[l]        * val1.channel[k] * alpha1 / 255;
768               PictureValue[k] += l0[lMax-l-1] * val2.channel[k] * alpha2 / 255;
769             }
770             PictureValue[color_chans] += l1[l] * val1.channel[color_chans];
771             PictureValue[color_chans] += l0[lMax-l-1] * val2.channel[color_chans];
772           }
773           else {
774             for (k=0; k<im->channels; k++) {
775               PictureValue[k] += l1[l]        * val1.channel[k];
776               PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
777             }
778           }
779         }
780         if (has_alpha) {
781           float fa = PictureValue[color_chans] / LanczosWidthFactor;
782           int alpha = minmax(0, 255, fa+0.5);
783           if (alpha) {
784             for (k = 0; k < color_chans; ++k) {
785               psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor * 255 / fa));
786               val.channel[k]=minmax(0,255,psave);
787             }
788             val.channel[color_chans] = alpha;
789           }
790           else {
791             for (k = 0; k < im->channels; ++k)
792               val.channel[k] = 0;
793           }
794         }
795         else {
796           for(k=0;k<im->channels;k++) {
797             psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
798             val.channel[k]=minmax(0,255,psave);
799           }
800         }
801         i_ppix(new_img, i, j, &val);
802       }
803       
804     }
805   }
806   myfree(l0);
807   myfree(l1);
808
809   im_log((aIMCTX, 1,"(%p) <- i_scaleaxis\n", new_img));
810
811   return new_img;
812 }
813
814
815 /* 
816 =item i_scale_nn(im, scx, scy)
817
818 Scale by using nearest neighbor 
819 Both axes scaled at the same time since 
820 nothing is gained by doing it in two steps 
821
822 =cut
823 */
824
825
826 i_img*
827 i_scale_nn(i_img *im, double scx, double scy) {
828
829   i_img_dim nxsize,nysize,nx,ny;
830   i_img *new_img;
831   i_color val;
832   dIMCTXim(im);
833
834   im_log((aIMCTX, 1,"i_scale_nn(im %p,scx %.2f,scy %.2f)\n",im,scx,scy));
835
836   nxsize = (i_img_dim) ((double) im->xsize * scx);
837   if (nxsize < 1) {
838     nxsize = 1;
839     scx = 1.0 / im->xsize;
840   }
841   nysize = (i_img_dim) ((double) im->ysize * scy);
842   if (nysize < 1) {
843     nysize = 1;
844     scy = 1.0 / im->ysize;
845   }
846   im_assert(scx != 0 && scy != 0);
847     
848   new_img=i_img_empty_ch(NULL,nxsize,nysize,im->channels);
849   
850   for(ny=0;ny<nysize;ny++) for(nx=0;nx<nxsize;nx++) {
851     i_gpix(im,((double)nx)/scx,((double)ny)/scy,&val);
852     i_ppix(new_img,nx,ny,&val);
853   }
854
855   im_log((aIMCTX, 1,"(%p) <- i_scale_nn\n",new_img));
856
857   return new_img;
858 }
859
860 /*
861 =item i_sametype(C<im>, C<xsize>, C<ysize>)
862
863 =category Image creation/destruction
864 =synopsis i_img *img = i_sametype(src, width, height);
865
866 Returns an image of the same type (sample size, channels, paletted/direct).
867
868 For paletted images the palette is copied from the source.
869
870 =cut
871 */
872
873 i_img *
874 i_sametype(i_img *src, i_img_dim xsize, i_img_dim ysize) {
875   dIMCTXim(src);
876
877   if (src->type == i_direct_type) {
878     if (src->bits == 8) {
879       return i_img_empty_ch(NULL, xsize, ysize, src->channels);
880     }
881     else if (src->bits == i_16_bits) {
882       return i_img_16_new(xsize, ysize, src->channels);
883     }
884     else if (src->bits == i_double_bits) {
885       return i_img_double_new(xsize, ysize, src->channels);
886     }
887     else {
888       i_push_error(0, "Unknown image bits");
889       return NULL;
890     }
891   }
892   else {
893     i_color col;
894     int i;
895
896     i_img *targ = i_img_pal_new(xsize, ysize, src->channels, i_maxcolors(src));
897     for (i = 0; i < i_colorcount(src); ++i) {
898       i_getcolors(src, i, &col, 1);
899       i_addcolors(targ, &col, 1);
900     }
901
902     return targ;
903   }
904 }
905
906 /*
907 =item i_sametype_chans(C<im>, C<xsize>, C<ysize>, C<channels>)
908
909 =category Image creation/destruction
910 =synopsis i_img *img = i_sametype_chans(src, width, height, channels);
911
912 Returns an image of the same type (sample size).
913
914 For paletted images the equivalent direct type is returned.
915
916 =cut
917 */
918
919 i_img *
920 i_sametype_chans(i_img *src, i_img_dim xsize, i_img_dim ysize, int channels) {
921   dIMCTXim(src);
922
923   if (src->bits == 8) {
924     return i_img_empty_ch(NULL, xsize, ysize, channels);
925   }
926   else if (src->bits == i_16_bits) {
927     return i_img_16_new(xsize, ysize, channels);
928   }
929   else if (src->bits == i_double_bits) {
930     return i_img_double_new(xsize, ysize, channels);
931   }
932   else {
933     i_push_error(0, "Unknown image bits");
934     return NULL;
935   }
936 }
937
938 /*
939 =item i_transform(im, opx, opxl, opy, opyl, parm, parmlen)
940
941 Spatially transforms I<im> returning a new image.
942
943 opx for a length of opxl and opy for a length of opy are arrays of
944 operators that modify the x and y positions to retreive the pixel data from.
945
946 parm and parmlen define extra parameters that the operators may use.
947
948 Note that this function is largely superseded by the more flexible
949 L<transform.c/i_transform2>.
950
951 Returns the new image.
952
953 The operators for this function are defined in L<stackmach.c>.
954
955 =cut
956 */
957 i_img*
958 i_transform(i_img *im, int *opx,int opxl,int *opy,int opyl,double parm[],int parmlen) {
959   double rx,ry;
960   i_img_dim nxsize,nysize,nx,ny;
961   i_img *new_img;
962   i_color val;
963   dIMCTXim(im);
964   
965   im_log((aIMCTX, 1,"i_transform(im %p, opx %p, opxl %d, opy %p, opyl %d, parm %p, parmlen %d)\n",im,opx,opxl,opy,opyl,parm,parmlen));
966
967   nxsize = im->xsize;
968   nysize = im->ysize ;
969   
970   new_img=i_img_empty_ch(NULL,nxsize,nysize,im->channels);
971   /*   fprintf(stderr,"parm[2]=%f\n",parm[2]);   */
972   for(ny=0;ny<nysize;ny++) for(nx=0;nx<nxsize;nx++) {
973     /*     parm[parmlen-2]=(double)nx;
974            parm[parmlen-1]=(double)ny; */
975
976     parm[0]=(double)nx;
977     parm[1]=(double)ny;
978
979     /*     fprintf(stderr,"(%d,%d) ->",nx,ny);  */
980     rx=i_op_run(opx,opxl,parm,parmlen);
981     ry=i_op_run(opy,opyl,parm,parmlen);
982     /*    fprintf(stderr,"(%f,%f)\n",rx,ry); */
983     i_gpix(im,rx,ry,&val);
984     i_ppix(new_img,nx,ny,&val);
985   }
986
987   im_log((aIMCTX, 1,"(%p) <- i_transform\n",new_img));
988   return new_img;
989 }
990
991 /*
992 =item i_img_diff(im1, im2)
993
994 Calculates the sum of the squares of the differences between
995 correspoding channels in two images.
996
997 If the images are not the same size then only the common area is 
998 compared, hence even if images are different sizes this function 
999 can return zero.
1000
1001 =cut
1002 */
1003
1004 float
1005 i_img_diff(i_img *im1,i_img *im2) {
1006   i_img_dim x, y, xb, yb;
1007   int ch, chb;
1008   float tdiff;
1009   i_color val1,val2;
1010   dIMCTXim(im1);
1011
1012   im_log((aIMCTX, 1,"i_img_diff(im1 %p,im2 %p)\n",im1,im2));
1013
1014   xb=(im1->xsize<im2->xsize)?im1->xsize:im2->xsize;
1015   yb=(im1->ysize<im2->ysize)?im1->ysize:im2->ysize;
1016   chb=(im1->channels<im2->channels)?im1->channels:im2->channels;
1017
1018   im_log((aIMCTX, 1,"i_img_diff: b=(" i_DFp ") chb=%d\n",
1019           i_DFcp(xb,yb), chb));
1020
1021   tdiff=0;
1022   for(y=0;y<yb;y++) for(x=0;x<xb;x++) {
1023     i_gpix(im1,x,y,&val1);
1024     i_gpix(im2,x,y,&val2);
1025
1026     for(ch=0;ch<chb;ch++) tdiff+=(val1.channel[ch]-val2.channel[ch])*(val1.channel[ch]-val2.channel[ch]);
1027   }
1028   im_log((aIMCTX, 1,"i_img_diff <- (%.2f)\n",tdiff));
1029   return tdiff;
1030 }
1031
1032 /*
1033 =item i_img_diffd(im1, im2)
1034
1035 Calculates the sum of the squares of the differences between
1036 correspoding channels in two images.
1037
1038 If the images are not the same size then only the common area is 
1039 compared, hence even if images are different sizes this function 
1040 can return zero.
1041
1042 This is like i_img_diff() but looks at floating point samples instead.
1043
1044 =cut
1045 */
1046
1047 double
1048 i_img_diffd(i_img *im1,i_img *im2) {
1049   i_img_dim x, y, xb, yb;
1050   int ch, chb;
1051   double tdiff;
1052   i_fcolor val1,val2;
1053   dIMCTXim(im1);
1054
1055   im_log((aIMCTX, 1,"i_img_diffd(im1 %p,im2 %p)\n",im1,im2));
1056
1057   xb=(im1->xsize<im2->xsize)?im1->xsize:im2->xsize;
1058   yb=(im1->ysize<im2->ysize)?im1->ysize:im2->ysize;
1059   chb=(im1->channels<im2->channels)?im1->channels:im2->channels;
1060
1061   im_log((aIMCTX, 1,"i_img_diffd: b(" i_DFp ") chb=%d\n",
1062           i_DFcp(xb, yb), chb));
1063
1064   tdiff=0;
1065   for(y=0;y<yb;y++) for(x=0;x<xb;x++) {
1066     i_gpixf(im1,x,y,&val1);
1067     i_gpixf(im2,x,y,&val2);
1068
1069     for(ch=0;ch<chb;ch++) {
1070       double sdiff = val1.channel[ch]-val2.channel[ch];
1071       tdiff += sdiff * sdiff;
1072     }
1073   }
1074   im_log((aIMCTX, 1,"i_img_diffd <- (%.2f)\n",tdiff));
1075
1076   return tdiff;
1077 }
1078
1079 int
1080 i_img_samef(i_img *im1,i_img *im2, double epsilon, char const *what) {
1081   i_img_dim x,y,xb,yb;
1082   int ch, chb;
1083   i_fcolor val1,val2;
1084   dIMCTXim(im1);
1085
1086   if (what == NULL)
1087     what = "(null)";
1088
1089   im_log((aIMCTX,1,"i_img_samef(im1 %p,im2 %p, epsilon %g, what '%s')\n", im1, im2, epsilon, what));
1090
1091   xb=(im1->xsize<im2->xsize)?im1->xsize:im2->xsize;
1092   yb=(im1->ysize<im2->ysize)?im1->ysize:im2->ysize;
1093   chb=(im1->channels<im2->channels)?im1->channels:im2->channels;
1094
1095   im_log((aIMCTX, 1,"i_img_samef: b(" i_DFp ") chb=%d\n",
1096           i_DFcp(xb, yb), chb));
1097
1098   for(y = 0; y < yb; y++) {
1099     for(x = 0; x < xb; x++) {
1100       i_gpixf(im1, x, y, &val1);
1101       i_gpixf(im2, x, y, &val2);
1102       
1103       for(ch = 0; ch < chb; ch++) {
1104         double sdiff = val1.channel[ch] - val2.channel[ch];
1105         if (fabs(sdiff) > epsilon) {
1106           im_log((aIMCTX, 1,"i_img_samef <- different %g @(" i_DFp ")\n",
1107                   sdiff, i_DFcp(x, y)));
1108           return 0;
1109         }
1110       }
1111     }
1112   }
1113   im_log((aIMCTX, 1,"i_img_samef <- same\n"));
1114
1115   return 1;
1116 }
1117
1118 /* just a tiny demo of haar wavelets */
1119
1120 i_img*
1121 i_haar(i_img *im) {
1122   i_img_dim mx,my;
1123   i_img_dim fx,fy;
1124   i_img_dim x,y;
1125   int ch;
1126   i_img *new_img,*new_img2;
1127   i_color val1,val2,dval1,dval2;
1128   dIMCTXim(im);
1129   
1130   mx=im->xsize;
1131   my=im->ysize;
1132   fx=(mx+1)/2;
1133   fy=(my+1)/2;
1134
1135
1136   /* horizontal pass */
1137   
1138   new_img=i_img_empty_ch(NULL,fx*2,fy*2,im->channels);
1139   new_img2=i_img_empty_ch(NULL,fx*2,fy*2,im->channels);
1140
1141   for(y=0;y<my;y++) for(x=0;x<fx;x++) {
1142     i_gpix(im,x*2,y,&val1);
1143     i_gpix(im,x*2+1,y,&val2);
1144     for(ch=0;ch<im->channels;ch++) {
1145       dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1146       dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1147     }
1148     i_ppix(new_img,x,y,&dval1);
1149     i_ppix(new_img,x+fx,y,&dval2);
1150   }
1151
1152   for(y=0;y<fy;y++) for(x=0;x<mx;x++) {
1153     i_gpix(new_img,x,y*2,&val1);
1154     i_gpix(new_img,x,y*2+1,&val2);
1155     for(ch=0;ch<im->channels;ch++) {
1156       dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1157       dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1158     }
1159     i_ppix(new_img2,x,y,&dval1);
1160     i_ppix(new_img2,x,y+fy,&dval2);
1161   }
1162
1163   i_img_destroy(new_img);
1164   return new_img2;
1165 }
1166
1167 /* 
1168 =item i_count_colors(im, maxc)
1169
1170 returns number of colors or -1 
1171 to indicate that it was more than max colors
1172
1173 =cut
1174 */
1175 /* This function has been changed and is now faster. It's using
1176  * i_gsamp instead of i_gpix */
1177 int
1178 i_count_colors(i_img *im,int maxc) {
1179   struct octt *ct;
1180   i_img_dim x,y;
1181   int colorcnt;
1182   int channels[3];
1183   int *samp_chans;
1184   i_sample_t * samp;
1185   i_img_dim xsize = im->xsize; 
1186   i_img_dim ysize = im->ysize;
1187   int samp_cnt = 3 * xsize;
1188
1189   if (im->channels >= 3) {
1190     samp_chans = NULL;
1191   }
1192   else {
1193     channels[0] = channels[1] = channels[2] = 0;
1194     samp_chans = channels;
1195   }
1196
1197   ct = octt_new();
1198
1199   samp = (i_sample_t *) mymalloc( xsize * 3 * sizeof(i_sample_t));
1200
1201   colorcnt = 0;
1202   for(y = 0; y < ysize; ) {
1203       i_gsamp(im, 0, xsize, y++, samp, samp_chans, 3);
1204       for(x = 0; x < samp_cnt; ) {
1205           colorcnt += octt_add(ct, samp[x], samp[x+1], samp[x+2]);
1206           x += 3;
1207           if (colorcnt > maxc) {
1208               myfree(samp);
1209               octt_delete(ct); 
1210               return -1; 
1211           }
1212       }
1213   }
1214   myfree(samp);
1215   octt_delete(ct);
1216   return colorcnt;
1217 }
1218
1219 /* sorts the array ra[0..n-1] into increasing order using heapsort algorithm 
1220  * (adapted from the Numerical Recipes)
1221  */
1222 /* Needed by get_anonymous_color_histo */
1223 static void
1224 hpsort(unsigned int n, unsigned *ra) {
1225     unsigned int i,
1226                  ir,
1227                  j,
1228                  l, 
1229                  rra;
1230
1231     if (n < 2) return;
1232     l = n >> 1;
1233     ir = n - 1;
1234     for(;;) {
1235         if (l > 0) {
1236             rra = ra[--l];
1237         }
1238         else {
1239             rra = ra[ir];
1240             ra[ir] = ra[0];
1241             if (--ir == 0) {
1242                 ra[0] = rra;
1243                 break;
1244             }
1245         }
1246         i = l;
1247         j = 2 * l + 1;
1248         while (j <= ir) {
1249             if (j < ir && ra[j] < ra[j+1]) j++;
1250             if (rra < ra[j]) {
1251                 ra[i] = ra[j];
1252                 i = j;
1253                 j++; j <<= 1; j--;
1254             }
1255             else break;
1256         }
1257         ra[i] = rra;
1258     }
1259 }
1260
1261 /* This function constructs an ordered list which represents how much the
1262  * different colors are used. So for instance (100, 100, 500) means that one
1263  * color is used for 500 pixels, another for 100 pixels and another for 100
1264  * pixels. It's tuned for performance. You might not like the way I've hardcoded
1265  * the maxc ;-) and you might want to change the name... */
1266 /* Uses octt_histo */
1267 int
1268 i_get_anonymous_color_histo(i_img *im, unsigned int **col_usage, int maxc) {
1269   struct octt *ct;
1270   i_img_dim x,y;
1271   int colorcnt;
1272   unsigned int *col_usage_it;
1273   i_sample_t * samp;
1274   int channels[3];
1275   int *samp_chans;
1276   
1277   i_img_dim xsize = im->xsize; 
1278   i_img_dim ysize = im->ysize;
1279   int samp_cnt = 3 * xsize;
1280   ct = octt_new();
1281   
1282   samp = (i_sample_t *) mymalloc( xsize * 3 * sizeof(i_sample_t));
1283   
1284   if (im->channels >= 3) {
1285     samp_chans = NULL;
1286   }
1287   else {
1288     channels[0] = channels[1] = channels[2] = 0;
1289     samp_chans = channels;
1290   }
1291
1292   colorcnt = 0;
1293   for(y = 0; y < ysize; ) {
1294     i_gsamp(im, 0, xsize, y++, samp, samp_chans, 3);
1295     for(x = 0; x < samp_cnt; ) {
1296       colorcnt += octt_add(ct, samp[x], samp[x+1], samp[x+2]);
1297       x += 3;
1298       if (colorcnt > maxc) { 
1299         octt_delete(ct);
1300         myfree(samp);
1301         return -1; 
1302       }
1303     }
1304   }
1305   myfree(samp);
1306   /* Now that we know the number of colours... */
1307   col_usage_it = *col_usage = (unsigned int *) mymalloc(colorcnt * sizeof(unsigned int));
1308   octt_histo(ct, &col_usage_it);
1309   hpsort(colorcnt, *col_usage);
1310   octt_delete(ct);
1311   return colorcnt;
1312 }
1313
1314 /*
1315 =back
1316
1317 =head2 Image method wrappers
1318
1319 These functions provide i_fsample_t functions in terms of their
1320 i_sample_t versions.
1321
1322 =over
1323
1324 =item i_ppixf_fp(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix)
1325
1326 =cut
1327 */
1328
1329 int i_ppixf_fp(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix) {
1330   i_color temp;
1331   int ch;
1332
1333   for (ch = 0; ch < im->channels; ++ch)
1334     temp.channel[ch] = SampleFTo8(pix->channel[ch]);
1335   
1336   return i_ppix(im, x, y, &temp);
1337 }
1338
1339 /*
1340 =item i_gpixf_fp(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix)
1341
1342 =cut
1343 */
1344 int i_gpixf_fp(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix) {
1345   i_color temp;
1346   int ch;
1347
1348   if (i_gpix(im, x, y, &temp) == 0) {
1349     for (ch = 0; ch < im->channels; ++ch)
1350       pix->channel[ch] = Sample8ToF(temp.channel[ch]);
1351     return 0;
1352   }
1353   else 
1354     return -1;
1355 }
1356
1357 /*
1358 =item i_plinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *pix)
1359
1360 =cut
1361 */
1362 i_img_dim
1363 i_plinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *pix) {
1364   i_color *work;
1365
1366   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1367     if (r > im->xsize)
1368       r = im->xsize;
1369     if (r > l) {
1370       i_img_dim ret;
1371       i_img_dim i;
1372       int ch;
1373       work = mymalloc(sizeof(i_color) * (r-l));
1374       for (i = 0; i < r-l; ++i) {
1375         for (ch = 0; ch < im->channels; ++ch) 
1376           work[i].channel[ch] = SampleFTo8(pix[i].channel[ch]);
1377       }
1378       ret = i_plin(im, l, r, y, work);
1379       myfree(work);
1380
1381       return ret;
1382     }
1383     else {
1384       return 0;
1385     }
1386   }
1387   else {
1388     return 0;
1389   }
1390 }
1391
1392 /*
1393 =item i_glinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *pix)
1394
1395 =cut
1396 */
1397 i_img_dim
1398 i_glinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *pix) {
1399   i_color *work;
1400
1401   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1402     if (r > im->xsize)
1403       r = im->xsize;
1404     if (r > l) {
1405       i_img_dim ret;
1406       i_img_dim i;
1407       int ch;
1408       work = mymalloc(sizeof(i_color) * (r-l));
1409       ret = i_plin(im, l, r, y, work);
1410       for (i = 0; i < r-l; ++i) {
1411         for (ch = 0; ch < im->channels; ++ch) 
1412           pix[i].channel[ch] = Sample8ToF(work[i].channel[ch]);
1413       }
1414       myfree(work);
1415
1416       return ret;
1417     }
1418     else {
1419       return 0;
1420     }
1421   }
1422   else {
1423     return 0;
1424   }
1425 }
1426
1427 /*
1428 =item i_gsampf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samp, int *chans, int chan_count)
1429
1430 =cut
1431 */
1432
1433 i_img_dim
1434 i_gsampf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samp, 
1435                 int const *chans, int chan_count) {
1436   i_sample_t *work;
1437
1438   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1439     if (r > im->xsize)
1440       r = im->xsize;
1441     if (r > l) {
1442       i_img_dim ret;
1443       i_img_dim i;
1444       work = mymalloc(sizeof(i_sample_t) * (r-l));
1445       ret = i_gsamp(im, l, r, y, work, chans, chan_count);
1446       for (i = 0; i < ret; ++i) {
1447           samp[i] = Sample8ToF(work[i]);
1448       }
1449       myfree(work);
1450
1451       return ret;
1452     }
1453     else {
1454       return 0;
1455     }
1456   }
1457   else {
1458     return 0;
1459   }
1460 }
1461
1462 /*
1463 =back
1464
1465 =head2 Palette wrapper functions
1466
1467 Used for virtual images, these forward palette calls to a wrapped image, 
1468 assuming the wrapped image is the first pointer in the structure that 
1469 im->ext_data points at.
1470
1471 =over
1472
1473 =item i_addcolors_forward(i_img *im, const i_color *colors, int count)
1474
1475 =cut
1476 */
1477 int i_addcolors_forward(i_img *im, const i_color *colors, int count) {
1478   return i_addcolors(*(i_img **)im->ext_data, colors, count);
1479 }
1480
1481 /*
1482 =item i_getcolors_forward(i_img *im, int i, i_color *color, int count)
1483
1484 =cut
1485 */
1486 int i_getcolors_forward(i_img *im, int i, i_color *color, int count) {
1487   return i_getcolors(*(i_img **)im->ext_data, i, color, count);
1488 }
1489
1490 /*
1491 =item i_setcolors_forward(i_img *im, int i, const i_color *color, int count)
1492
1493 =cut
1494 */
1495 int i_setcolors_forward(i_img *im, int i, const i_color *color, int count) {
1496   return i_setcolors(*(i_img **)im->ext_data, i, color, count);
1497 }
1498
1499 /*
1500 =item i_colorcount_forward(i_img *im)
1501
1502 =cut
1503 */
1504 int i_colorcount_forward(i_img *im) {
1505   return i_colorcount(*(i_img **)im->ext_data);
1506 }
1507
1508 /*
1509 =item i_maxcolors_forward(i_img *im)
1510
1511 =cut
1512 */
1513 int i_maxcolors_forward(i_img *im) {
1514   return i_maxcolors(*(i_img **)im->ext_data);
1515 }
1516
1517 /*
1518 =item i_findcolor_forward(i_img *im, const i_color *color, i_palidx *entry)
1519
1520 =cut
1521 */
1522 int i_findcolor_forward(i_img *im, const i_color *color, i_palidx *entry) {
1523   return i_findcolor(*(i_img **)im->ext_data, color, entry);
1524 }
1525
1526 /*
1527 =back
1528
1529 =head2 Fallback handler
1530
1531 =over
1532
1533 =item i_gsamp_bits_fb
1534
1535 =cut
1536 */
1537
1538 i_img_dim
1539 i_gsamp_bits_fb(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned *samps, 
1540                 const int *chans, int chan_count, int bits) {
1541   dIMCTXim(im);
1542
1543   if (bits < 1 || bits > 32) {
1544     i_push_error(0, "Invalid bits, must be 1..32");
1545     return -1;
1546   }
1547
1548   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1549     double scale;
1550     int ch;
1551     i_img_dim count, i, w;
1552     
1553     if (bits == 32)
1554       scale = 4294967295.0;
1555     else
1556       scale = (double)(1 << bits) - 1;
1557
1558     if (r > im->xsize)
1559       r = im->xsize;
1560     w = r - l;
1561     count = 0;
1562
1563     if (chans) {
1564       /* make sure we have good channel numbers */
1565       for (ch = 0; ch < chan_count; ++ch) {
1566         if (chans[ch] < 0 || chans[ch] >= im->channels) {
1567           im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
1568           return -1;
1569         }
1570       }
1571       for (i = 0; i < w; ++i) {
1572         i_fcolor c;
1573         i_gpixf(im, l+i, y, &c);
1574         for (ch = 0; ch < chan_count; ++ch) {
1575           *samps++ = (unsigned)(c.channel[ch] * scale + 0.5);
1576           ++count;
1577         }
1578       }
1579     }
1580     else {
1581       if (chan_count <= 0 || chan_count > im->channels) {
1582         i_push_error(0, "Invalid channel count");
1583         return -1;
1584       }
1585       for (i = 0; i < w; ++i) {
1586         i_fcolor c;
1587         i_gpixf(im, l+i, y, &c);
1588         for (ch = 0; ch < chan_count; ++ch) {
1589           *samps++ = (unsigned)(c.channel[ch] * scale + 0.5);
1590           ++count;
1591         }
1592       }
1593     }
1594
1595     return count;
1596   }
1597   else {
1598     i_push_error(0, "Image position outside of image");
1599     return -1;
1600   }
1601 }
1602
1603 static int
1604 test_magic(unsigned char *buffer, size_t length, struct file_magic_entry const *magic) {
1605   if (length < magic->magic_size)
1606     return 0;
1607   if (magic->mask) {
1608     int i;
1609     unsigned char *bufp = buffer, 
1610       *maskp = magic->mask, 
1611       *magicp = magic->magic;
1612
1613     for (i = 0; i < magic->magic_size; ++i) {
1614       int mask = *maskp == 'x' ? 0xFF : *maskp == ' ' ? 0 : *maskp;
1615       ++maskp;
1616
1617       if ((*bufp++ & mask) != (*magicp++ & mask)) 
1618         return 0;
1619     }
1620
1621     return 1;
1622   }
1623   else {
1624     return !memcmp(magic->magic, buffer, magic->magic_size);
1625   }
1626 }
1627
1628 /*
1629 =item i_test_format_probe(io_glue *data, int length)
1630
1631 Check the beginning of the supplied file for a 'magic number'
1632
1633 =cut
1634 */
1635
1636 #define FORMAT_ENTRY(magic, type) \
1637   { (unsigned char *)(magic ""), sizeof(magic)-1, type }
1638 #define FORMAT_ENTRY2(magic, type, mask) \
1639   { (unsigned char *)(magic ""), sizeof(magic)-1, type, (unsigned char *)(mask) }
1640
1641 const char *
1642 im_test_format_probe(im_context_t ctx, io_glue *data, int length) {
1643   static const struct file_magic_entry formats[] = {
1644     FORMAT_ENTRY("\xFF\xD8", "jpeg"),
1645     FORMAT_ENTRY("GIF87a", "gif"),
1646     FORMAT_ENTRY("GIF89a", "gif"),
1647     FORMAT_ENTRY("MM\0*", "tiff"),
1648     FORMAT_ENTRY("II*\0", "tiff"),
1649     FORMAT_ENTRY("BM", "bmp"),
1650     FORMAT_ENTRY("\x89PNG\x0d\x0a\x1a\x0a", "png"),
1651     FORMAT_ENTRY("P1", "pnm"),
1652     FORMAT_ENTRY("P2", "pnm"),
1653     FORMAT_ENTRY("P3", "pnm"),
1654     FORMAT_ENTRY("P4", "pnm"),
1655     FORMAT_ENTRY("P5", "pnm"),
1656     FORMAT_ENTRY("P6", "pnm"),
1657     FORMAT_ENTRY("/* XPM", "xpm"),
1658     FORMAT_ENTRY("\x8aMNG", "mng"),
1659     FORMAT_ENTRY("\x8aJNG", "jng"),
1660     /* SGI RGB - with various possible parameters to avoid false positives
1661        on similar files 
1662        values are: 2 byte magic, rle flags (0 or 1), bytes/sample (1 or 2)
1663     */
1664     FORMAT_ENTRY("\x01\xDA\x00\x01", "sgi"),
1665     FORMAT_ENTRY("\x01\xDA\x00\x02", "sgi"),
1666     FORMAT_ENTRY("\x01\xDA\x01\x01", "sgi"),
1667     FORMAT_ENTRY("\x01\xDA\x01\x02", "sgi"),
1668     
1669     FORMAT_ENTRY2("FORM    ILBM", "ilbm", "xxxx    xxxx"),
1670
1671     /* different versions of PCX format 
1672        http://www.fileformat.info/format/pcx/
1673     */
1674     FORMAT_ENTRY("\x0A\x00\x01", "pcx"),
1675     FORMAT_ENTRY("\x0A\x02\x01", "pcx"),
1676     FORMAT_ENTRY("\x0A\x03\x01", "pcx"),
1677     FORMAT_ENTRY("\x0A\x04\x01", "pcx"),
1678     FORMAT_ENTRY("\x0A\x05\x01", "pcx"),
1679
1680     /* FITS - http://fits.gsfc.nasa.gov/ */
1681     FORMAT_ENTRY("SIMPLE  =", "fits"),
1682
1683     /* PSD - Photoshop */
1684     FORMAT_ENTRY("8BPS\x00\x01", "psd"),
1685     
1686     /* EPS - Encapsulated Postscript */
1687     /* only reading 18 chars, so we don't include the F in EPSF */
1688     FORMAT_ENTRY("%!PS-Adobe-2.0 EPS", "eps"),
1689
1690     /* Utah RLE */
1691     FORMAT_ENTRY("\x52\xCC", "utah"),
1692
1693     /* GZIP compressed, only matching deflate for now */
1694     FORMAT_ENTRY("\x1F\x8B\x08", "gzip"),
1695
1696     /* bzip2 compressed */
1697     FORMAT_ENTRY("BZh", "bzip2"),
1698
1699     /* WEBP
1700        http://code.google.com/speed/webp/docs/riff_container.html */
1701     FORMAT_ENTRY2("RIFF    WEBP", "webp", "xxxx    xxxx"),
1702
1703     /* JPEG 2000 
1704        This might match a little loosely */
1705     FORMAT_ENTRY("\x00\x00\x00\x0CjP  \x0D\x0A\x87\x0A", "jp2"),
1706
1707     /* FLIF - Free Lossless Image Format - https://flif.info/spec.html */
1708     FORMAT_ENTRY("FLIF", "flif")
1709   };
1710   static const struct file_magic_entry more_formats[] = {
1711     /* these were originally both listed as ico, but cur files can
1712        include hotspot information */
1713     FORMAT_ENTRY("\x00\x00\x01\x00", "ico"), /* Windows icon */
1714     FORMAT_ENTRY("\x00\x00\x02\x00", "cur"), /* Windows cursor */
1715     FORMAT_ENTRY2("\x00\x00\x00\x00\x00\x00\x00\x07", 
1716                   "xwd", "    xxxx"), /* X Windows Dump */
1717   };
1718
1719   unsigned int i;
1720   unsigned char head[18];
1721   ssize_t rc;
1722
1723   rc = i_io_peekn(data, head, 18);
1724   if (rc == -1) return NULL;
1725 #if 0
1726   {
1727     int i;
1728     fprintf(stderr, "%d bytes -", (int)rc);
1729     for (i = 0; i < rc; ++i)
1730       fprintf(stderr, " %02x", head[i]);
1731     fprintf(stderr, "\n");
1732   }
1733 #endif
1734
1735   {
1736     im_file_magic *p = ctx->file_magic;
1737     while (p) {
1738       if (test_magic(head, rc, &p->m)) {
1739         return p->m.name;
1740       }
1741       p = p->next;
1742     }
1743   }
1744
1745   for(i=0; i<sizeof(formats)/sizeof(formats[0]); i++) { 
1746     struct file_magic_entry const *entry = formats + i;
1747
1748     if (test_magic(head, rc, entry)) 
1749       return entry->name;
1750   }
1751
1752   if ((rc == 18) &&
1753       tga_header_verify(head))
1754     return "tga";
1755
1756   for(i=0; i<sizeof(more_formats)/sizeof(more_formats[0]); i++) { 
1757     struct file_magic_entry const *entry = more_formats + i;
1758
1759     if (test_magic(head, rc, entry)) 
1760       return entry->name;
1761   }
1762
1763   return NULL;
1764 }
1765
1766 /*
1767 =item i_img_is_monochrome(img, &zero_is_white)
1768
1769 =category Image Information
1770
1771 Tests an image to check it meets our monochrome tests.
1772
1773 The idea is that a file writer can use this to test where it should
1774 write the image in whatever bi-level format it uses, eg. C<pbm> for
1775 C<pnm>.
1776
1777 For performance of encoders we require monochrome images:
1778
1779 =over
1780
1781 =item *
1782
1783 be paletted
1784
1785 =item *
1786
1787 have a palette of two colors, containing only C<(0,0,0)> and
1788 C<(255,255,255)> in either order.
1789
1790 =back
1791
1792 C<zero_is_white> is set to non-zero if the first palette entry is white.
1793
1794 =cut
1795 */
1796
1797 int
1798 i_img_is_monochrome(i_img *im, int *zero_is_white) {
1799   if (im->type == i_palette_type
1800       && i_colorcount(im) == 2) {
1801     i_color colors[2];
1802     if (!i_getcolors(im, 0, colors, 2))
1803       return 0;
1804     if (im->channels == 3) {
1805       if (colors[0].rgb.r == 255 && 
1806           colors[0].rgb.g == 255 &&
1807           colors[0].rgb.b == 255 &&
1808           colors[1].rgb.r == 0 &&
1809           colors[1].rgb.g == 0 &&
1810           colors[1].rgb.b == 0) {
1811         *zero_is_white = 1;
1812         return 1;
1813       }
1814       else if (colors[0].rgb.r == 0 && 
1815                colors[0].rgb.g == 0 &&
1816                colors[0].rgb.b == 0 &&
1817                colors[1].rgb.r == 255 &&
1818                colors[1].rgb.g == 255 &&
1819                colors[1].rgb.b == 255) {
1820         *zero_is_white = 0;
1821         return 1;
1822       }
1823     }
1824     else if (im->channels == 1) {
1825       if (colors[0].channel[0] == 255 &&
1826           colors[1].channel[0] == 0) {
1827         *zero_is_white = 1;
1828         return 1;
1829       }
1830       else if (colors[0].channel[0] == 0 &&
1831                colors[1].channel[0] == 255) {
1832         *zero_is_white = 0;
1833         return 1;         
1834       }
1835     }
1836   }
1837
1838   *zero_is_white = 0;
1839   return 0;
1840 }
1841
1842 /*
1843 =item i_get_file_background(im, &bg)
1844
1845 =category Files
1846
1847 Retrieve the file write background color tag from the image.
1848
1849 If not present, C<bg> is set to black.
1850
1851 Returns 1 if the C<i_background> tag was found and valid.
1852
1853 =cut
1854 */
1855
1856 int
1857 i_get_file_background(i_img *im, i_color *bg) {
1858   int result = i_tags_get_color(&im->tags, "i_background", 0, bg);
1859   if (!result) {
1860     /* black default */
1861     bg->channel[0] = bg->channel[1] = bg->channel[2] = 0;
1862   }
1863   /* always full alpha */
1864   bg->channel[3] = 255;
1865
1866   return result;
1867 }
1868
1869 /*
1870 =item i_get_file_backgroundf(im, &bg)
1871
1872 =category Files
1873
1874 Retrieve the file write background color tag from the image as a
1875 floating point color.
1876
1877 Implemented in terms of i_get_file_background().
1878
1879 If not present, C<bg> is set to black.
1880
1881 Returns 1 if the C<i_background> tag was found and valid.
1882
1883 =cut
1884 */
1885
1886 int
1887 i_get_file_backgroundf(i_img *im, i_fcolor *fbg) {
1888   i_color bg;
1889   int result = i_get_file_background(im, &bg);
1890   fbg->rgba.r = Sample8ToF(bg.rgba.r);
1891   fbg->rgba.g = Sample8ToF(bg.rgba.g);
1892   fbg->rgba.b = Sample8ToF(bg.rgba.b);
1893   fbg->rgba.a = 1.0;
1894
1895   return result;
1896 }
1897
1898 /*
1899 =back
1900
1901 =head1 AUTHOR
1902
1903 Arnar M. Hrafnkelsson <addi@umich.edu>
1904
1905 Tony Cook <tonyc@cpan.org>
1906
1907 =head1 SEE ALSO
1908
1909 L<Imager>, L<gif.c>
1910
1911 =cut
1912 */