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