7 image.c - implements most of the basic functions of Imager and much of the rest
13 c = i_color_new(red, green, blue, alpha);
21 image.c implements the basic functions to create and destroy image and
22 color objects for Imager.
24 =head1 FUNCTION REFERENCE
26 Some of these functions are internal.
37 #define minmax(a,b,i) ( ((a>=i)?a: ( (b<=i)?b:i )) )
39 /* Hack around an obscure linker bug on solaris - probably due to builtin gcc thingies */
40 static void fake(void) { ceil(1); }
42 static int i_ppix_d(i_img *im, int x, int y, const i_color *val);
43 static int i_gpix_d(i_img *im, int x, int y, i_color *val);
44 static int i_glin_d(i_img *im, int l, int r, int y, i_color *vals);
45 static int i_plin_d(i_img *im, int l, int r, int y, const i_color *vals);
46 static int i_ppixf_d(i_img *im, int x, int y, const i_fcolor *val);
47 static int i_gpixf_d(i_img *im, int x, int y, i_fcolor *val);
48 static int i_glinf_d(i_img *im, int l, int r, int y, i_fcolor *vals);
49 static int i_plinf_d(i_img *im, int l, int r, int y, const i_fcolor *vals);
50 static int i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, const int *chans, int chan_count);
51 static int i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, const int *chans, int chan_count);
52 /*static int i_psamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, int *chans, int chan_count);
53 static int i_psampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, int *chans, int chan_count);*/
56 =item ICL_new_internal(r, g, b, a)
58 Return a new color object with values passed to it.
60 r - red component (range: 0 - 255)
61 g - green component (range: 0 - 255)
62 b - blue component (range: 0 - 255)
63 a - alpha component (range: 0 - 255)
69 ICL_new_internal(unsigned char r,unsigned char g,unsigned char b,unsigned char a) {
72 mm_log((1,"ICL_new_internal(r %d,g %d,b %d,a %d)\n", r, g, b, a));
74 if ( (cl=mymalloc(sizeof(i_color))) == NULL) i_fatal(2,"malloc() error\n");
79 mm_log((1,"(%p) <- ICL_new_internal\n",cl));
85 =item ICL_set_internal(cl, r, g, b, a)
87 Overwrite a color with new values.
89 cl - pointer to color object
90 r - red component (range: 0 - 255)
91 g - green component (range: 0 - 255)
92 b - blue component (range: 0 - 255)
93 a - alpha component (range: 0 - 255)
99 ICL_set_internal(i_color *cl,unsigned char r,unsigned char g,unsigned char b,unsigned char a) {
100 mm_log((1,"ICL_set_internal(cl* %p,r %d,g %d,b %d,a %d)\n",cl,r,g,b,a));
102 if ( (cl=mymalloc(sizeof(i_color))) == NULL)
103 i_fatal(2,"malloc() error\n");
108 mm_log((1,"(%p) <- ICL_set_internal\n",cl));
114 =item ICL_add(dst, src, ch)
116 Add src to dst inplace - dst is modified.
118 dst - pointer to destination color object
119 src - pointer to color object that is added
120 ch - number of channels
126 ICL_add(i_color *dst,i_color *src,int ch) {
129 tmp=dst->channel[i]+src->channel[i];
130 dst->channel[i]= tmp>255 ? 255:tmp;
137 Dump color information to log - strictly for debugging.
139 cl - pointer to color object
145 ICL_info(i_color const *cl) {
146 mm_log((1,"i_color_info(cl* %p)\n",cl));
147 mm_log((1,"i_color_info: (%d,%d,%d,%d)\n",cl->rgba.r,cl->rgba.g,cl->rgba.b,cl->rgba.a));
153 Destroy ancillary data for Color object.
155 cl - pointer to color object
161 ICL_DESTROY(i_color *cl) {
162 mm_log((1,"ICL_DESTROY(cl* %p)\n",cl));
167 =item i_fcolor_new(double r, double g, double b, double a)
171 i_fcolor *i_fcolor_new(double r, double g, double b, double a) {
174 mm_log((1,"i_fcolor_new(r %g,g %g,b %g,a %g)\n", r, g, b, a));
176 if ( (cl=mymalloc(sizeof(i_fcolor))) == NULL) i_fatal(2,"malloc() error\n");
181 mm_log((1,"(%p) <- i_fcolor_new\n",cl));
187 =item i_fcolor_destroy(i_fcolor *cl)
191 void i_fcolor_destroy(i_fcolor *cl) {
196 =item IIM_base_8bit_direct (static)
198 A static i_img object used to initialize direct 8-bit per sample images.
202 static i_img IIM_base_8bit_direct =
204 0, /* channels set */
205 0, 0, 0, /* xsize, ysize, bytes */
208 i_direct_type, /* type */
211 { 0, 0, NULL }, /* tags */
214 i_ppix_d, /* i_f_ppix */
215 i_ppixf_d, /* i_f_ppixf */
216 i_plin_d, /* i_f_plin */
217 i_plinf_d, /* i_f_plinf */
218 i_gpix_d, /* i_f_gpix */
219 i_gpixf_d, /* i_f_gpixf */
220 i_glin_d, /* i_f_glin */
221 i_glinf_d, /* i_f_glinf */
222 i_gsamp_d, /* i_f_gsamp */
223 i_gsampf_d, /* i_f_gsampf */
227 NULL, /* i_f_addcolors */
228 NULL, /* i_f_getcolors */
229 NULL, /* i_f_colorcount */
230 NULL, /* i_f_maxcolors */
231 NULL, /* i_f_findcolor */
232 NULL, /* i_f_setcolors */
234 NULL, /* i_f_destroy */
237 /*static void set_8bit_direct(i_img *im) {
238 im->i_f_ppix = i_ppix_d;
239 im->i_f_ppixf = i_ppixf_d;
240 im->i_f_plin = i_plin_d;
241 im->i_f_plinf = i_plinf_d;
242 im->i_f_gpix = i_gpix_d;
243 im->i_f_gpixf = i_gpixf_d;
244 im->i_f_glin = i_glin_d;
245 im->i_f_glinf = i_glinf_d;
248 im->i_f_addcolor = NULL;
249 im->i_f_getcolor = NULL;
250 im->i_f_colorcount = NULL;
251 im->i_f_findcolor = NULL;
255 =item IIM_new(x, y, ch)
257 =item i_img_8_new(x, y, ch)
259 =category Image creation
261 Creates a new image object I<x> pixels wide, and I<y> pixels high with
269 IIM_new(int x,int y,int ch) {
271 mm_log((1,"IIM_new(x %d,y %d,ch %d)\n",x,y,ch));
273 im=i_img_empty_ch(NULL,x,y,ch);
275 mm_log((1,"(%p) <- IIM_new\n",im));
281 IIM_DESTROY(i_img *im) {
282 mm_log((1,"IIM_DESTROY(im* %p)\n",im));
290 Create new image reference - notice that this isn't an object yet and
291 this should be fixed asap.
301 mm_log((1,"i_img_struct()\n"));
302 if ( (im=mymalloc(sizeof(i_img))) == NULL)
303 i_fatal(2,"malloc() error\n");
305 *im = IIM_base_8bit_direct;
313 mm_log((1,"(%p) <- i_img_struct\n",im));
318 =item i_img_empty(im, x, y)
320 Re-new image reference (assumes 3 channels)
323 x - xsize of destination image
324 y - ysize of destination image
326 **FIXME** what happens if a live image is passed in here?
328 Should this just call i_img_empty_ch()?
334 i_img_empty(i_img *im,int x,int y) {
335 mm_log((1,"i_img_empty(*im %p, x %d, y %d)\n",im, x, y));
336 return i_img_empty_ch(im, x, y, 3);
340 =item i_img_empty_ch(im, x, y, ch)
342 Re-new image reference
345 x - xsize of destination image
346 y - ysize of destination image
347 ch - number of channels
353 i_img_empty_ch(i_img *im,int x,int y,int ch) {
356 mm_log((1,"i_img_empty_ch(*im %p, x %d, y %d, ch %d)\n", im, x, y, ch));
358 if (x < 1 || y < 1) {
359 i_push_error(0, "Image sizes must be positive");
362 if (ch < 1 || ch > MAXCHANNELS) {
363 i_push_errorf(0, "channels must be between 1 and %d", MAXCHANNELS);
366 /* check this multiplication doesn't overflow */
368 if (bytes / y / ch != x) {
369 i_push_errorf(0, "integer overflow calculating image allocation");
374 if ( (im=mymalloc(sizeof(i_img))) == NULL)
375 i_fatal(2,"malloc() error\n");
377 memcpy(im, &IIM_base_8bit_direct, sizeof(i_img));
378 i_tags_new(&im->tags);
382 im->ch_mask = MAXINT;
384 if ( (im->idata=mymalloc(im->bytes)) == NULL)
385 i_fatal(2,"malloc() error\n");
386 memset(im->idata,0,(size_t)im->bytes);
390 mm_log((1,"(%p) <- i_img_empty_ch\n",im));
395 =item i_img_exorcise(im)
405 i_img_exorcise(i_img *im) {
406 mm_log((1,"i_img_exorcise(im* 0x%x)\n",im));
407 i_tags_destroy(&im->tags);
409 (im->i_f_destroy)(im);
410 if (im->idata != NULL) { myfree(im->idata); }
416 im->i_f_ppix=i_ppix_d;
417 im->i_f_gpix=i_gpix_d;
418 im->i_f_plin=i_plin_d;
419 im->i_f_glin=i_glin_d;
424 =item i_img_destroy(im)
428 Destroy image and free data via exorcise.
436 i_img_destroy(i_img *im) {
437 mm_log((1,"i_img_destroy(im %p)\n",im));
439 if (im) { myfree(im); }
443 =item i_img_info(im, info)
447 Return image information
450 info - pointer to array to return data
452 info is an array of 4 integers with the following values:
457 info[3] - channel mask
464 i_img_info(i_img *im,int *info) {
465 mm_log((1,"i_img_info(im 0x%x)\n",im));
467 mm_log((1,"i_img_info: xsize=%d ysize=%d channels=%d mask=%ud\n",im->xsize,im->ysize,im->channels,im->ch_mask));
468 mm_log((1,"i_img_info: idata=0x%d\n",im->idata));
471 info[2] = im->channels;
472 info[3] = im->ch_mask;
482 =item i_img_setmask(im, ch_mask)
484 =synopsis // only channel 0 writeable
485 =synopsis i_img_setmask(img, 0x01);
487 Set the image channel mask for I<im> to I<ch_mask>.
492 i_img_setmask(i_img *im,int ch_mask) { im->ch_mask=ch_mask; }
496 =item i_img_getmask(im)
498 =synopsis mask = i_img_getmask(img);
500 Get the image channel mask for I<im>.
505 i_img_getmask(i_img *im) { return im->ch_mask; }
508 =item i_img_getchannels(im)
510 =synopsis channels = i_img_getchannels(img);
512 Get the number of channels in I<im>.
517 i_img_getchannels(i_img *im) { return im->channels; }
520 =item i_img_get_width(im)
522 =synopsis width = i_img_get_width(im);
524 Returns the width in pixels of the image.
529 i_img_get_width(i_img *im) {
534 =item i_img_get_height(im)
536 =synopsis height = i_img_get_height(im);
538 Returns the height in pixels of the image.
543 i_img_get_height(i_img *im) {
548 =item i_copyto_trans(im, src, x1, y1, x2, y2, tx, ty, trans)
552 (x1,y1) (x2,y2) specifies the region to copy (in the source coordinates)
553 (tx,ty) specifies the upper left corner for the target image.
554 pass NULL in trans for non transparent i_colors.
560 i_copyto_trans(i_img *im,i_img *src,int x1,int y1,int x2,int y2,int tx,int ty,const i_color *trans) {
562 int x,y,t,ttx,tty,tt,ch;
564 mm_log((1,"i_copyto_trans(im* %p,src 0x%x, x1 %d, y1 %d, x2 %d, y2 %d, tx %d, ty %d, trans* 0x%x)\n",
565 im, src, x1, y1, x2, y2, tx, ty, trans));
567 if (x2<x1) { t=x1; x1=x2; x2=t; }
568 if (y2<y1) { t=y1; y1=y2; y2=t; }
580 for(ch=0;ch<im->channels;ch++) if (trans->channel[ch]!=pv.channel[ch]) tt++;
581 if (tt) i_ppix(im,ttx,tty,&pv);
582 } else i_ppix(im,ttx,tty,&pv);
590 =item i_copyto(dest, src, x1, y1, x2, y2, tx, ty)
594 Copies image data from the area (x1,y1)-[x2,y2] in the source image to
595 a rectangle the same size with it's top-left corner at (tx,ty) in the
598 If x1 > x2 or y1 > y2 then the corresponding co-ordinates are swapped.
604 i_copyto(i_img *im, i_img *src, int x1, int y1, int x2, int y2, int tx, int ty) {
605 int x, y, t, ttx, tty;
607 if (x2<x1) { t=x1; x1=x2; x2=t; }
608 if (y2<y1) { t=y1; y1=y2; y2=t; }
610 /* adjust everything equally */
620 if (x1 >= src->xsize || y1 >= src->ysize)
621 return; /* nothing to do */
626 if (x1 == x2 || y1 == y2)
627 return; /* nothing to do */
629 mm_log((1,"i_copyto(im* %p, src %p, x1 %d, y1 %d, x2 %d, y2 %d, tx %d, ty %d)\n",
630 im, src, x1, y1, x2, y2, tx, ty));
632 if (im->bits == i_8_bits) {
633 i_color *row = mymalloc(sizeof(i_color) * (x2-x1));
635 for(y=y1; y<y2; y++) {
637 i_glin(src, x1, x2, y, row);
638 i_plin(im, tx, tx+x2-x1, tty, row);
646 for(y=y1; y<y2; y++) {
648 for(x=x1; x<x2; x++) {
649 i_gpixf(src, x, y, &pv);
650 i_ppixf(im, ttx, tty, &pv);
663 Creates a new image that is a copy of src.
665 Tags are not copied, only the image data.
675 i_img *im = i_sametype(src, src->xsize, src->ysize);
677 mm_log((1,"i_copy(src %p)\n", src));
684 if (src->type == i_direct_type) {
685 if (src->bits == i_8_bits) {
687 pv = mymalloc(sizeof(i_color) * x1);
689 for (y = 0; y < y1; ++y) {
690 i_glin(src, 0, x1, y, pv);
691 i_plin(im, 0, x1, y, pv);
698 pv = mymalloc(sizeof(i_fcolor) * x1);
699 for (y = 0; y < y1; ++y) {
700 i_glinf(src, 0, x1, y, pv);
701 i_plinf(im, 0, x1, y, pv);
713 i_img_pal_new_low(im, x1, y1, src->channels, i_maxcolors(src));
714 /* copy across the palette */
715 count = i_colorcount(src);
716 for (index = 0; index < count; ++index) {
717 i_getcolors(src, index, &temp, 1);
718 i_addcolors(im, &temp, 1);
721 vals = mymalloc(sizeof(i_palidx) * x1);
722 for (y = 0; y < y1; ++y) {
723 i_gpal(src, 0, x1, y, vals);
724 i_ppal(im, 0, x1, y, vals);
734 =item i_flipxy(im, axis)
736 Flips the image inplace around the axis specified.
737 Returns 0 if parameters are invalid.
740 axis - 0 = x, 1 = y, 2 = both
746 i_flipxy(i_img *im, int direction) {
747 int x, x2, y, y2, xm, ym;
751 mm_log((1, "i_flipxy(im %p, direction %d)\n", im, direction ));
756 case XAXIS: /* Horizontal flip */
759 for(y=0; y<ym; y++) {
761 for(x=0; x<xm; x++) {
763 i_gpix(im, x, y, &val1);
764 i_gpix(im, x2, y, &val2);
765 i_ppix(im, x, y, &val2);
766 i_ppix(im, x2, y, &val1);
771 case YAXIS: /* Vertical flip */
775 for(y=0; y<ym; y++) {
776 for(x=0; x<xm; x++) {
778 i_gpix(im, x, y, &val1);
779 i_gpix(im, x, y2, &val2);
780 i_ppix(im, x, y, &val2);
781 i_ppix(im, x, y2, &val1);
786 case XYAXIS: /* Horizontal and Vertical flip */
790 for(y=0; y<ym; y++) {
792 for(x=0; x<xm; x++) {
794 i_gpix(im, x, y, &val1);
795 i_gpix(im, x2, y2, &val2);
796 i_ppix(im, x, y, &val2);
797 i_ppix(im, x2, y2, &val1);
799 i_gpix(im, x2, y, &val1);
800 i_gpix(im, x, y2, &val2);
801 i_ppix(im, x2, y, &val2);
802 i_ppix(im, x, y2, &val1);
807 if (xm*2 != xs) { /* odd number of column */
808 mm_log((1, "i_flipxy: odd number of columns\n"));
811 for(y=0; y<ym; y++) {
813 i_gpix(im, x, y, &val1);
814 i_gpix(im, x, y2, &val2);
815 i_ppix(im, x, y, &val2);
816 i_ppix(im, x, y2, &val1);
820 if (ym*2 != ys) { /* odd number of rows */
821 mm_log((1, "i_flipxy: odd number of rows\n"));
824 for(x=0; x<xm; x++) {
826 i_gpix(im, x, y, &val1);
827 i_gpix(im, x2, y, &val2);
828 i_ppix(im, x, y, &val2);
829 i_ppix(im, x2, y, &val1);
835 mm_log((1, "i_flipxy: direction is invalid\n" ));
853 if ((x >= 2.0) || (x <= -2.0)) return (0.0);
854 else if (x == 0.0) return (1.0);
855 else return(sin(PIx) / PIx * sin(PIx2) / PIx2);
860 =item i_scaleaxis(im, value, axis)
862 Returns a new image object which is I<im> scaled by I<value> along
863 wither the x-axis (I<axis> == 0) or the y-axis (I<axis> == 1).
869 i_scaleaxis(i_img *im, float Value, int Axis) {
870 int hsize, vsize, i, j, k, l, lMax, iEnd, jEnd;
871 int LanczosWidthFactor;
872 float *l0, *l1, OldLocation;
875 float F, PictureValue[MAXCHANNELS];
877 i_color val,val1,val2;
880 mm_log((1,"i_scaleaxis(im %p,Value %.2f,Axis %d)\n",im,Value,Axis));
884 hsize = (int)(0.5 + im->xsize * Value);
887 Value = 1.0 / im->xsize;
895 vsize = (int)(0.5 + im->ysize * Value);
899 Value = 1.0 / im->ysize;
906 new_img = i_img_empty_ch(NULL, hsize, vsize, im->channels);
908 /* 1.4 is a magic number, setting it to 2 will cause rather blurred images */
909 LanczosWidthFactor = (Value >= 1) ? 1 : (int) (1.4/Value);
910 lMax = LanczosWidthFactor << 1;
912 l0 = mymalloc(lMax * sizeof(float));
913 l1 = mymalloc(lMax * sizeof(float));
915 for (j=0; j<jEnd; j++) {
916 OldLocation = ((float) j) / Value;
917 T = (int) (OldLocation);
918 F = OldLocation - (float) T;
920 for (l = 0; l<lMax; l++) {
921 l0[lMax-l-1] = Lanczos(((float) (lMax-l-1) + F) / (float) LanczosWidthFactor);
922 l1[l] = Lanczos(((float) (l+1) - F) / (float) LanczosWidthFactor);
925 /* Make sure filter is normalized */
927 for(l=0; l<lMax; l++) {
931 t /= (float)LanczosWidthFactor;
933 for(l=0; l<lMax; l++) {
940 for (i=0; i<iEnd; i++) {
941 for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
942 for (l=0; l<lMax; l++) {
945 mx = (mx < 0) ? 0 : mx;
946 Mx = (Mx >= im->xsize) ? im->xsize-1 : Mx;
948 i_gpix(im, Mx, i, &val1);
949 i_gpix(im, mx, i, &val2);
951 for (k=0; k<im->channels; k++) {
952 PictureValue[k] += l1[l] * val1.channel[k];
953 PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
956 for(k=0;k<im->channels;k++) {
957 psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
958 val.channel[k]=minmax(0,255,psave);
960 i_ppix(new_img, j, i, &val);
965 for (i=0; i<iEnd; i++) {
966 for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
967 for (l=0; l < lMax; l++) {
970 mx = (mx < 0) ? 0 : mx;
971 Mx = (Mx >= im->ysize) ? im->ysize-1 : Mx;
973 i_gpix(im, i, Mx, &val1);
974 i_gpix(im, i, mx, &val2);
975 for (k=0; k<im->channels; k++) {
976 PictureValue[k] += l1[l] * val1.channel[k];
977 PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
980 for (k=0; k<im->channels; k++) {
981 psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
982 val.channel[k] = minmax(0, 255, psave);
984 i_ppix(new_img, i, j, &val);
992 mm_log((1,"(%p) <- i_scaleaxis\n", new_img));
999 =item i_scale_nn(im, scx, scy)
1001 Scale by using nearest neighbor
1002 Both axes scaled at the same time since
1003 nothing is gained by doing it in two steps
1010 i_scale_nn(i_img *im, float scx, float scy) {
1012 int nxsize,nysize,nx,ny;
1016 mm_log((1,"i_scale_nn(im 0x%x,scx %.2f,scy %.2f)\n",im,scx,scy));
1018 nxsize = (int) ((float) im->xsize * scx);
1021 scx = 1 / im->xsize;
1023 nysize = (int) ((float) im->ysize * scy);
1026 scy = 1 / im->ysize;
1029 new_img=i_img_empty_ch(NULL,nxsize,nysize,im->channels);
1031 for(ny=0;ny<nysize;ny++) for(nx=0;nx<nxsize;nx++) {
1032 i_gpix(im,((float)nx)/scx,((float)ny)/scy,&val);
1033 i_ppix(new_img,nx,ny,&val);
1036 mm_log((1,"(0x%x) <- i_scale_nn\n",new_img));
1042 =item i_sametype(i_img *im, int xsize, int ysize)
1044 =category Image creation
1046 Returns an image of the same type (sample size, channels, paletted/direct).
1048 For paletted images the palette is copied from the source.
1053 i_img *i_sametype(i_img *src, int xsize, int ysize) {
1054 if (src->type == i_direct_type) {
1055 if (src->bits == 8) {
1056 return i_img_empty_ch(NULL, xsize, ysize, src->channels);
1058 else if (src->bits == i_16_bits) {
1059 return i_img_16_new(xsize, ysize, src->channels);
1061 else if (src->bits == i_double_bits) {
1062 return i_img_double_new(xsize, ysize, src->channels);
1065 i_push_error(0, "Unknown image bits");
1073 i_img *targ = i_img_pal_new(xsize, ysize, src->channels, i_maxcolors(src));
1074 for (i = 0; i < i_colorcount(src); ++i) {
1075 i_getcolors(src, i, &col, 1);
1076 i_addcolors(targ, &col, 1);
1084 =item i_sametype_chans(i_img *im, int xsize, int ysize, int channels)
1086 =category Image creation
1088 Returns an image of the same type (sample size).
1090 For paletted images the equivalent direct type is returned.
1095 i_img *i_sametype_chans(i_img *src, int xsize, int ysize, int channels) {
1096 if (src->bits == 8) {
1097 return i_img_empty_ch(NULL, xsize, ysize, channels);
1099 else if (src->bits == i_16_bits) {
1100 return i_img_16_new(xsize, ysize, channels);
1102 else if (src->bits == i_double_bits) {
1103 return i_img_double_new(xsize, ysize, channels);
1106 i_push_error(0, "Unknown image bits");
1112 =item i_transform(im, opx, opxl, opy, opyl, parm, parmlen)
1114 Spatially transforms I<im> returning a new image.
1116 opx for a length of opxl and opy for a length of opy are arrays of
1117 operators that modify the x and y positions to retreive the pixel data from.
1119 parm and parmlen define extra parameters that the operators may use.
1121 Note that this function is largely superseded by the more flexible
1122 L<transform.c/i_transform2>.
1124 Returns the new image.
1126 The operators for this function are defined in L<stackmach.c>.
1131 i_transform(i_img *im, int *opx,int opxl,int *opy,int opyl,double parm[],int parmlen) {
1133 int nxsize,nysize,nx,ny;
1137 mm_log((1,"i_transform(im 0x%x, opx 0x%x, opxl %d, opy 0x%x, opyl %d, parm 0x%x, parmlen %d)\n",im,opx,opxl,opy,opyl,parm,parmlen));
1140 nysize = im->ysize ;
1142 new_img=i_img_empty_ch(NULL,nxsize,nysize,im->channels);
1143 /* fprintf(stderr,"parm[2]=%f\n",parm[2]); */
1144 for(ny=0;ny<nysize;ny++) for(nx=0;nx<nxsize;nx++) {
1145 /* parm[parmlen-2]=(double)nx;
1146 parm[parmlen-1]=(double)ny; */
1151 /* fprintf(stderr,"(%d,%d) ->",nx,ny); */
1152 rx=i_op_run(opx,opxl,parm,parmlen);
1153 ry=i_op_run(opy,opyl,parm,parmlen);
1154 /* fprintf(stderr,"(%f,%f)\n",rx,ry); */
1155 i_gpix(im,rx,ry,&val);
1156 i_ppix(new_img,nx,ny,&val);
1159 mm_log((1,"(0x%x) <- i_transform\n",new_img));
1164 =item i_img_diff(im1, im2)
1166 Calculates the sum of the squares of the differences between
1167 correspoding channels in two images.
1169 If the images are not the same size then only the common area is
1170 compared, hence even if images are different sizes this function
1176 i_img_diff(i_img *im1,i_img *im2) {
1177 int x,y,ch,xb,yb,chb;
1181 mm_log((1,"i_img_diff(im1 0x%x,im2 0x%x)\n",im1,im2));
1183 xb=(im1->xsize<im2->xsize)?im1->xsize:im2->xsize;
1184 yb=(im1->ysize<im2->ysize)?im1->ysize:im2->ysize;
1185 chb=(im1->channels<im2->channels)?im1->channels:im2->channels;
1187 mm_log((1,"i_img_diff: xb=%d xy=%d chb=%d\n",xb,yb,chb));
1190 for(y=0;y<yb;y++) for(x=0;x<xb;x++) {
1191 i_gpix(im1,x,y,&val1);
1192 i_gpix(im2,x,y,&val2);
1194 for(ch=0;ch<chb;ch++) tdiff+=(val1.channel[ch]-val2.channel[ch])*(val1.channel[ch]-val2.channel[ch]);
1196 mm_log((1,"i_img_diff <- (%.2f)\n",tdiff));
1200 /* just a tiny demo of haar wavelets */
1208 i_img *new_img,*new_img2;
1209 i_color val1,val2,dval1,dval2;
1217 /* horizontal pass */
1219 new_img=i_img_empty_ch(NULL,fx*2,fy*2,im->channels);
1220 new_img2=i_img_empty_ch(NULL,fx*2,fy*2,im->channels);
1223 for(y=0;y<my;y++) for(x=0;x<fx;x++) {
1224 i_gpix(im,x*2,y,&val1);
1225 i_gpix(im,x*2+1,y,&val2);
1226 for(ch=0;ch<im->channels;ch++) {
1227 dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1228 dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1230 i_ppix(new_img,x,y,&dval1);
1231 i_ppix(new_img,x+fx,y,&dval2);
1234 for(y=0;y<fy;y++) for(x=0;x<mx;x++) {
1235 i_gpix(new_img,x,y*2,&val1);
1236 i_gpix(new_img,x,y*2+1,&val2);
1237 for(ch=0;ch<im->channels;ch++) {
1238 dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1239 dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1241 i_ppix(new_img2,x,y,&dval1);
1242 i_ppix(new_img2,x,y+fy,&dval2);
1245 i_img_destroy(new_img);
1250 =item i_count_colors(im, maxc)
1252 returns number of colors or -1
1253 to indicate that it was more than max colors
1257 /* This function has been changed and is now faster. It's using
1258 * i_gsamp instead of i_gpix */
1260 i_count_colors(i_img *im,int maxc) {
1268 int xsize = im->xsize;
1269 int ysize = im->ysize;
1270 if (im->channels >= 3) {
1274 channels[0] = channels[1] = channels[2] = 0;
1275 samp_chans = channels;
1277 int samp_cnt = 3 * xsize;
1280 samp = (i_sample_t *) mymalloc( xsize * 3 * sizeof(i_sample_t));
1283 for(y = 0; y < ysize; ) {
1284 i_gsamp(im, 0, xsize, y++, samp, samp_chans, 3);
1285 for(x = 0; x < samp_cnt; ) {
1286 colorcnt += octt_add(ct, samp[x], samp[x+1], samp[x+2]);
1288 if (colorcnt > maxc) {
1299 /* sorts the array ra[0..n-1] into increasing order using heapsort algorithm
1300 * (adapted from the Numerical Recipes)
1302 /* Needed by get_anonymous_color_histo */
1303 void hpsort(unsigned int n, int *ra) {
1328 if (j < ir && ra[j] < ra[j+1]) j++;
1340 /* This function constructs an ordered list which represents how much the
1341 * different colors are used. So for instance (100, 100, 500) means that one
1342 * color is used for 500 pixels, another for 100 pixels and another for 100
1343 * pixels. It's tuned for performance. You might not like the way I've hardcoded
1344 * the maxc ;-) and you might want to change the name... */
1345 /* Uses octt_histo */
1347 get_anonymous_color_histo(i_img *im, unsigned int **col_usage) {
1351 int maxc = 10000000;
1352 unsigned int *col_usage_it;
1355 int xsize = im->xsize;
1356 int ysize = im->ysize;
1357 int samp_cnt = 3 * xsize;
1360 samp = (i_sample_t *) mymalloc( xsize * 3 * sizeof(i_sample_t));
1363 for(y = 0; y < ysize; ) {
1364 i_gsamp(im, 0, xsize, y++, samp, NULL, 3);
1365 for(x = 0; x < samp_cnt; ) {
1366 colorcnt += octt_add(ct, samp[x], samp[x+1], samp[x+2]);
1368 if (colorcnt > maxc) {
1375 /* Now that we know the number of colours... */
1376 col_usage_it = *col_usage = (unsigned int *) mymalloc(colorcnt * 2 * sizeof(unsigned int));
1377 octt_histo(ct, &col_usage_it);
1378 hpsort(colorcnt, *col_usage);
1388 =head2 8-bit per sample image internal functions
1390 These are the functions installed in an 8-bit per sample image.
1394 =item i_ppix_d(im, x, y, col)
1398 This is the function kept in the i_f_ppix member of an i_img object.
1399 It does a normal store of a pixel into the image with range checking.
1401 Returns 0 if the pixel could be set, -1 otherwise.
1407 i_ppix_d(i_img *im, int x, int y, const i_color *val) {
1410 if ( x>-1 && x<im->xsize && y>-1 && y<im->ysize ) {
1411 for(ch=0;ch<im->channels;ch++)
1412 if (im->ch_mask&(1<<ch))
1413 im->idata[(x+y*im->xsize)*im->channels+ch]=val->channel[ch];
1416 return -1; /* error was clipped */
1420 =item i_gpix_d(im, x, y, &col)
1424 This is the function kept in the i_f_gpix member of an i_img object.
1425 It does normal retrieval of a pixel from the image with range checking.
1427 Returns 0 if the pixel could be set, -1 otherwise.
1433 i_gpix_d(i_img *im, int x, int y, i_color *val) {
1435 if (x>-1 && x<im->xsize && y>-1 && y<im->ysize) {
1436 for(ch=0;ch<im->channels;ch++)
1437 val->channel[ch]=im->idata[(x+y*im->xsize)*im->channels+ch];
1440 for(ch=0;ch<im->channels;ch++) val->channel[ch] = 0;
1441 return -1; /* error was cliped */
1445 =item i_glin_d(im, l, r, y, vals)
1447 Reads a line of data from the image, storing the pixels at vals.
1449 The line runs from (l,y) inclusive to (r,y) non-inclusive
1451 vals should point at space for (r-l) pixels.
1453 l should never be less than zero (to avoid confusion about where to
1454 put the pixels in vals).
1456 Returns the number of pixels copied (eg. if r, l or y is out of range)
1462 i_glin_d(i_img *im, int l, int r, int y, i_color *vals) {
1464 unsigned char *data;
1465 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1468 data = im->idata + (l+y*im->xsize) * im->channels;
1470 for (i = 0; i < count; ++i) {
1471 for (ch = 0; ch < im->channels; ++ch)
1472 vals[i].channel[ch] = *data++;
1482 =item i_plin_d(im, l, r, y, vals)
1484 Writes a line of data into the image, using the pixels at vals.
1486 The line runs from (l,y) inclusive to (r,y) non-inclusive
1488 vals should point at (r-l) pixels.
1490 l should never be less than zero (to avoid confusion about where to
1491 get the pixels in vals).
1493 Returns the number of pixels copied (eg. if r, l or y is out of range)
1499 i_plin_d(i_img *im, int l, int r, int y, const i_color *vals) {
1501 unsigned char *data;
1502 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1505 data = im->idata + (l+y*im->xsize) * im->channels;
1507 for (i = 0; i < count; ++i) {
1508 for (ch = 0; ch < im->channels; ++ch) {
1509 if (im->ch_mask & (1 << ch))
1510 *data = vals[i].channel[ch];
1522 =item i_ppixf_d(im, x, y, val)
1528 i_ppixf_d(i_img *im, int x, int y, const i_fcolor *val) {
1531 if ( x>-1 && x<im->xsize && y>-1 && y<im->ysize ) {
1532 for(ch=0;ch<im->channels;ch++)
1533 if (im->ch_mask&(1<<ch)) {
1534 im->idata[(x+y*im->xsize)*im->channels+ch] =
1535 SampleFTo8(val->channel[ch]);
1539 return -1; /* error was clipped */
1543 =item i_gpixf_d(im, x, y, val)
1549 i_gpixf_d(i_img *im, int x, int y, i_fcolor *val) {
1551 if (x>-1 && x<im->xsize && y>-1 && y<im->ysize) {
1552 for(ch=0;ch<im->channels;ch++) {
1554 Sample8ToF(im->idata[(x+y*im->xsize)*im->channels+ch]);
1558 return -1; /* error was cliped */
1562 =item i_glinf_d(im, l, r, y, vals)
1564 Reads a line of data from the image, storing the pixels at vals.
1566 The line runs from (l,y) inclusive to (r,y) non-inclusive
1568 vals should point at space for (r-l) pixels.
1570 l should never be less than zero (to avoid confusion about where to
1571 put the pixels in vals).
1573 Returns the number of pixels copied (eg. if r, l or y is out of range)
1579 i_glinf_d(i_img *im, int l, int r, int y, i_fcolor *vals) {
1581 unsigned char *data;
1582 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1585 data = im->idata + (l+y*im->xsize) * im->channels;
1587 for (i = 0; i < count; ++i) {
1588 for (ch = 0; ch < im->channels; ++ch)
1589 vals[i].channel[ch] = Sample8ToF(*data++);
1599 =item i_plinf_d(im, l, r, y, vals)
1601 Writes a line of data into the image, using the pixels at vals.
1603 The line runs from (l,y) inclusive to (r,y) non-inclusive
1605 vals should point at (r-l) pixels.
1607 l should never be less than zero (to avoid confusion about where to
1608 get the pixels in vals).
1610 Returns the number of pixels copied (eg. if r, l or y is out of range)
1616 i_plinf_d(i_img *im, int l, int r, int y, const i_fcolor *vals) {
1618 unsigned char *data;
1619 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1622 data = im->idata + (l+y*im->xsize) * im->channels;
1624 for (i = 0; i < count; ++i) {
1625 for (ch = 0; ch < im->channels; ++ch) {
1626 if (im->ch_mask & (1 << ch))
1627 *data = SampleFTo8(vals[i].channel[ch]);
1639 =item i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, int *chans, int chan_count)
1641 Reads sample values from im for the horizontal line (l, y) to (r-1,y)
1642 for the channels specified by chans, an array of int with chan_count
1645 Returns the number of samples read (which should be (r-l) * bits_set(chan_mask)
1651 i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps,
1652 const int *chans, int chan_count) {
1653 int ch, count, i, w;
1654 unsigned char *data;
1656 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1659 data = im->idata + (l+y*im->xsize) * im->channels;
1664 /* make sure we have good channel numbers */
1665 for (ch = 0; ch < chan_count; ++ch) {
1666 if (chans[ch] < 0 || chans[ch] >= im->channels) {
1667 i_push_errorf(0, "No channel %d in this image", chans[ch]);
1671 for (i = 0; i < w; ++i) {
1672 for (ch = 0; ch < chan_count; ++ch) {
1673 *samps++ = data[chans[ch]];
1676 data += im->channels;
1680 for (i = 0; i < w; ++i) {
1681 for (ch = 0; ch < chan_count; ++ch) {
1682 *samps++ = data[ch];
1685 data += im->channels;
1697 =item i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, int *chans, int chan_count)
1699 Reads sample values from im for the horizontal line (l, y) to (r-1,y)
1700 for the channels specified by chan_mask, where bit 0 is the first
1703 Returns the number of samples read (which should be (r-l) * bits_set(chan_mask)
1709 i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps,
1710 const int *chans, int chan_count) {
1711 int ch, count, i, w;
1712 unsigned char *data;
1713 for (ch = 0; ch < chan_count; ++ch) {
1714 if (chans[ch] < 0 || chans[ch] >= im->channels) {
1715 i_push_errorf(0, "No channel %d in this image", chans[ch]);
1718 if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1721 data = im->idata + (l+y*im->xsize) * im->channels;
1726 /* make sure we have good channel numbers */
1727 for (ch = 0; ch < chan_count; ++ch) {
1728 if (chans[ch] < 0 || chans[ch] >= im->channels) {
1729 i_push_errorf(0, "No channel %d in this image", chans[ch]);
1733 for (i = 0; i < w; ++i) {
1734 for (ch = 0; ch < chan_count; ++ch) {
1735 *samps++ = Sample8ToF(data[chans[ch]]);
1738 data += im->channels;
1742 for (i = 0; i < w; ++i) {
1743 for (ch = 0; ch < chan_count; ++ch) {
1744 *samps++ = Sample8ToF(data[ch]);
1747 data += im->channels;
1760 =head2 Image method wrappers
1762 These functions provide i_fsample_t functions in terms of their
1763 i_sample_t versions.
1767 =item i_ppixf_fp(i_img *im, int x, int y, i_fcolor *pix)
1772 int i_ppixf_fp(i_img *im, int x, int y, const i_fcolor *pix) {
1776 for (ch = 0; ch < im->channels; ++ch)
1777 temp.channel[ch] = SampleFTo8(pix->channel[ch]);
1779 return i_ppix(im, x, y, &temp);
1783 =item i_gpixf_fp(i_img *im, int x, int y, i_fcolor *pix)
1787 int i_gpixf_fp(i_img *im, int x, int y, i_fcolor *pix) {
1791 if (i_gpix(im, x, y, &temp)) {
1792 for (ch = 0; ch < im->channels; ++ch)
1793 pix->channel[ch] = Sample8ToF(temp.channel[ch]);
1801 =item i_plinf_fp(i_img *im, int l, int r, int y, i_fcolor *pix)
1805 int i_plinf_fp(i_img *im, int l, int r, int y, const i_fcolor *pix) {
1808 if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1814 work = mymalloc(sizeof(i_color) * (r-l));
1815 for (i = 0; i < r-l; ++i) {
1816 for (ch = 0; ch < im->channels; ++ch)
1817 work[i].channel[ch] = SampleFTo8(pix[i].channel[ch]);
1819 ret = i_plin(im, l, r, y, work);
1834 =item i_glinf_fp(i_img *im, int l, int r, int y, i_fcolor *pix)
1838 int i_glinf_fp(i_img *im, int l, int r, int y, i_fcolor *pix) {
1841 if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1847 work = mymalloc(sizeof(i_color) * (r-l));
1848 ret = i_plin(im, l, r, y, work);
1849 for (i = 0; i < r-l; ++i) {
1850 for (ch = 0; ch < im->channels; ++ch)
1851 pix[i].channel[ch] = Sample8ToF(work[i].channel[ch]);
1867 =item i_gsampf_fp(i_img *im, int l, int r, int y, i_fsample_t *samp, int *chans, int chan_count)
1871 int i_gsampf_fp(i_img *im, int l, int r, int y, i_fsample_t *samp,
1872 int const *chans, int chan_count) {
1875 if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1881 work = mymalloc(sizeof(i_sample_t) * (r-l));
1882 ret = i_gsamp(im, l, r, y, work, chans, chan_count);
1883 for (i = 0; i < ret; ++i) {
1884 samp[i] = Sample8ToF(work[i]);
1902 =head2 Palette wrapper functions
1904 Used for virtual images, these forward palette calls to a wrapped image,
1905 assuming the wrapped image is the first pointer in the structure that
1906 im->ext_data points at.
1910 =item i_addcolors_forward(i_img *im, const i_color *colors, int count)
1914 int i_addcolors_forward(i_img *im, const i_color *colors, int count) {
1915 return i_addcolors(*(i_img **)im->ext_data, colors, count);
1919 =item i_getcolors_forward(i_img *im, int i, i_color *color, int count)
1923 int i_getcolors_forward(i_img *im, int i, i_color *color, int count) {
1924 return i_getcolors(*(i_img **)im->ext_data, i, color, count);
1928 =item i_setcolors_forward(i_img *im, int i, const i_color *color, int count)
1932 int i_setcolors_forward(i_img *im, int i, const i_color *color, int count) {
1933 return i_setcolors(*(i_img **)im->ext_data, i, color, count);
1937 =item i_colorcount_forward(i_img *im)
1941 int i_colorcount_forward(i_img *im) {
1942 return i_colorcount(*(i_img **)im->ext_data);
1946 =item i_maxcolors_forward(i_img *im)
1950 int i_maxcolors_forward(i_img *im) {
1951 return i_maxcolors(*(i_img **)im->ext_data);
1955 =item i_findcolor_forward(i_img *im, const i_color *color, i_palidx *entry)
1959 int i_findcolor_forward(i_img *im, const i_color *color, i_palidx *entry) {
1960 return i_findcolor(*(i_img **)im->ext_data, color, entry);
1966 =head2 Stream reading and writing wrapper functions
1970 =item i_gen_reader(i_gen_read_data *info, char *buf, int length)
1972 Performs general read buffering for file readers that permit reading
1973 to be done through a callback.
1975 The final callback gets two parameters, a I<need> value, and a I<want>
1976 value, where I<need> is the amount of data that the file library needs
1977 to read, and I<want> is the amount of space available in the buffer
1978 maintained by these functions.
1980 This means if you need to read from a stream that you don't know the
1981 length of, you can return I<need> bytes, taking the performance hit of
1982 possibly expensive callbacks (eg. back to perl code), or if you are
1983 reading from a stream where it doesn't matter if some data is lost, or
1984 if the total length of the stream is known, you can return I<want>
1991 i_gen_reader(i_gen_read_data *gci, char *buf, int length) {
1994 if (length < gci->length - gci->cpos) {
1996 memcpy(buf, gci->buffer+gci->cpos, length);
1997 gci->cpos += length;
2002 memcpy(buf, gci->buffer+gci->cpos, gci->length-gci->cpos);
2003 total += gci->length - gci->cpos;
2004 length -= gci->length - gci->cpos;
2005 buf += gci->length - gci->cpos;
2006 if (length < (int)sizeof(gci->buffer)) {
2010 && (did_read = (gci->cb)(gci->userdata, gci->buffer, length,
2011 sizeof(gci->buffer))) > 0) {
2013 gci->length = did_read;
2015 copy_size = i_min(length, gci->length);
2016 memcpy(buf, gci->buffer, copy_size);
2017 gci->cpos += copy_size;
2020 length -= copy_size;
2024 /* just read the rest - too big for our buffer*/
2026 while ((did_read = (gci->cb)(gci->userdata, buf, length, length)) > 0) {
2036 =item i_gen_read_data_new(i_read_callback_t cb, char *userdata)
2038 For use by callback file readers to initialize the reader buffer.
2040 Allocates, initializes and returns the reader buffer.
2042 See also L<image.c/free_gen_read_data> and L<image.c/i_gen_reader>.
2047 i_gen_read_data_new(i_read_callback_t cb, char *userdata) {
2048 i_gen_read_data *self = mymalloc(sizeof(i_gen_read_data));
2050 self->userdata = userdata;
2058 =item i_free_gen_read_data(i_gen_read_data *)
2064 void i_free_gen_read_data(i_gen_read_data *self) {
2069 =item i_gen_writer(i_gen_write_data *info, char const *data, int size)
2071 Performs write buffering for a callback based file writer.
2073 Failures are considered fatal, if a write fails then data will be
2080 i_gen_write_data *self,
2084 if (self->filledto && self->filledto+size > self->maxlength) {
2085 if (self->cb(self->userdata, self->buffer, self->filledto)) {
2093 if (self->filledto+size <= self->maxlength) {
2095 memcpy(self->buffer+self->filledto, data, size);
2096 self->filledto += size;
2099 /* doesn't fit - hand it off */
2100 return self->cb(self->userdata, data, size);
2104 =item i_gen_write_data_new(i_write_callback_t cb, char *userdata, int max_length)
2106 Allocates and initializes the data structure used by i_gen_writer.
2108 This should be released with L<image.c/i_free_gen_write_data>
2112 i_gen_write_data *i_gen_write_data_new(i_write_callback_t cb,
2113 char *userdata, int max_length)
2115 i_gen_write_data *self = mymalloc(sizeof(i_gen_write_data));
2117 self->userdata = userdata;
2118 self->maxlength = i_min(max_length, sizeof(self->buffer));
2119 if (self->maxlength < 0)
2120 self->maxlength = sizeof(self->buffer);
2127 =item i_free_gen_write_data(i_gen_write_data *info, int flush)
2129 Cleans up the write buffer.
2131 Will flush any left-over data if I<flush> is non-zero.
2133 Returns non-zero if flush is zero or if info->cb() returns non-zero.
2135 Return zero only if flush is non-zero and info->cb() returns zero.
2141 int i_free_gen_write_data(i_gen_write_data *info, int flush)
2143 int result = !flush ||
2144 info->filledto == 0 ||
2145 info->cb(info->userdata, info->buffer, info->filledto);
2151 struct magic_entry {
2152 unsigned char *magic;
2155 unsigned char *mask;
2159 test_magic(unsigned char *buffer, size_t length, struct magic_entry const *magic) {
2160 if (length < magic->magic_size)
2164 unsigned char *bufp = buffer,
2165 *maskp = magic->mask,
2166 *magicp = magic->magic;
2168 for (i = 0; i < magic->magic_size; ++i) {
2169 int mask = *maskp == 'x' ? 0xFF : *maskp == ' ' ? 0 : *maskp;
2172 if ((*bufp++ & mask) != (*magicp++ & mask))
2179 return !memcmp(magic->magic, buffer, magic->magic_size);
2184 =item i_test_format_probe(io_glue *data, int length)
2186 Check the beginning of the supplied file for a 'magic number'
2191 #define FORMAT_ENTRY(magic, type) \
2192 { (unsigned char *)(magic ""), sizeof(magic)-1, type }
2193 #define FORMAT_ENTRY2(magic, type, mask) \
2194 { (unsigned char *)(magic ""), sizeof(magic)-1, type, (unsigned char *)(mask) }
2197 i_test_format_probe(io_glue *data, int length) {
2198 static const struct magic_entry formats[] = {
2199 FORMAT_ENTRY("\xFF\xD8", "jpeg"),
2200 FORMAT_ENTRY("GIF87a", "gif"),
2201 FORMAT_ENTRY("GIF89a", "gif"),
2202 FORMAT_ENTRY("MM\0*", "tiff"),
2203 FORMAT_ENTRY("II*\0", "tiff"),
2204 FORMAT_ENTRY("BM", "bmp"),
2205 FORMAT_ENTRY("\x89PNG\x0d\x0a\x1a\x0a", "png"),
2206 FORMAT_ENTRY("P1", "pnm"),
2207 FORMAT_ENTRY("P2", "pnm"),
2208 FORMAT_ENTRY("P3", "pnm"),
2209 FORMAT_ENTRY("P4", "pnm"),
2210 FORMAT_ENTRY("P5", "pnm"),
2211 FORMAT_ENTRY("P6", "pnm"),
2212 FORMAT_ENTRY("/* XPM", "xpm"),
2213 FORMAT_ENTRY("\x8aMNG", "mng"),
2214 FORMAT_ENTRY("\x8aJNG", "jng"),
2215 /* SGI RGB - with various possible parameters to avoid false positives
2217 values are: 2 byte magic, rle flags (0 or 1), bytes/sample (1 or 2)
2219 FORMAT_ENTRY("\x01\xDA\x00\x01", "sgi"),
2220 FORMAT_ENTRY("\x01\xDA\x00\x02", "sgi"),
2221 FORMAT_ENTRY("\x01\xDA\x01\x01", "sgi"),
2222 FORMAT_ENTRY("\x01\xDA\x01\x02", "sgi"),
2224 FORMAT_ENTRY2("FORM ILBM", "ilbm", "xxxx xxxx"),
2226 /* different versions of PCX format
2227 http://www.fileformat.info/format/pcx/
2229 FORMAT_ENTRY("\x0A\x00\x01", "pcx"),
2230 FORMAT_ENTRY("\x0A\x02\x01", "pcx"),
2231 FORMAT_ENTRY("\x0A\x03\x01", "pcx"),
2232 FORMAT_ENTRY("\x0A\x04\x01", "pcx"),
2233 FORMAT_ENTRY("\x0A\x05\x01", "pcx"),
2235 /* FITS - http://fits.gsfc.nasa.gov/ */
2236 FORMAT_ENTRY("SIMPLE =", "fits"),
2238 /* PSD - Photoshop */
2239 FORMAT_ENTRY("8BPS\x00\x01", "psd"),
2241 /* EPS - Encapsulated Postscript */
2242 /* only reading 18 chars, so we don't include the F in EPSF */
2243 FORMAT_ENTRY("%!PS-Adobe-2.0 EPS", "eps"),
2246 FORMAT_ENTRY("\x52\xCC", "utah"),
2248 /* GZIP compressed, only matching deflate for now */
2249 FORMAT_ENTRY("\x1F\x8B\x08", "gzip"),
2251 /* bzip2 compressed */
2252 FORMAT_ENTRY("BZh", "bzip2"),
2254 static const struct magic_entry more_formats[] = {
2255 /* these were originally both listed as ico, but cur files can
2256 include hotspot information */
2257 FORMAT_ENTRY("\x00\x00\x01\x00", "ico"), /* Windows icon */
2258 FORMAT_ENTRY("\x00\x00\x02\x00", "cur"), /* Windows cursor */
2259 FORMAT_ENTRY2("\x00\x00\x00\x00\x00\x00\x00\x07",
2260 "xwd", " xxxx"), /* X Windows Dump */
2264 unsigned char head[18];
2267 io_glue_commit_types(data);
2268 rc = data->readcb(data, head, 18);
2269 if (rc == -1) return NULL;
2270 data->seekcb(data, -rc, SEEK_CUR);
2272 for(i=0; i<sizeof(formats)/sizeof(formats[0]); i++) {
2273 struct magic_entry const *entry = formats + i;
2275 if (test_magic(head, rc, entry))
2280 tga_header_verify(head))
2283 for(i=0; i<sizeof(more_formats)/sizeof(more_formats[0]); i++) {
2284 struct magic_entry const *entry = more_formats + i;
2286 if (test_magic(head, rc, entry))
2294 =item i_img_is_monochrome(img, &zero_is_white)
2296 Tests an image to check it meets our monochrome tests.
2298 The idea is that a file writer can use this to test where it should
2299 write the image in whatever bi-level format it uses, eg. pbm for pnm.
2301 For performance of encoders we require monochrome images:
2311 have a palette of two colors, containing only (0,0,0) and
2312 (255,255,255) in either order.
2316 zero_is_white is set to non-zero iff the first palette entry is white.
2322 i_img_is_monochrome(i_img *im, int *zero_is_white) {
2323 if (im->type == i_palette_type
2324 && i_colorcount(im) == 2) {
2326 i_getcolors(im, 0, colors, 2);
2327 if (im->channels == 3) {
2328 if (colors[0].rgb.r == 255 &&
2329 colors[0].rgb.g == 255 &&
2330 colors[0].rgb.b == 255 &&
2331 colors[1].rgb.r == 0 &&
2332 colors[1].rgb.g == 0 &&
2333 colors[1].rgb.b == 0) {
2337 else if (colors[0].rgb.r == 0 &&
2338 colors[0].rgb.g == 0 &&
2339 colors[0].rgb.b == 0 &&
2340 colors[1].rgb.r == 255 &&
2341 colors[1].rgb.g == 255 &&
2342 colors[1].rgb.b == 255) {
2347 else if (im->channels == 1) {
2348 if (colors[0].channel[0] == 255 &&
2349 colors[1].channel[1] == 0) {
2353 else if (colors[0].channel[0] == 0 &&
2354 colors[0].channel[0] == 255) {
2370 Arnar M. Hrafnkelsson <addi@umich.edu>
2372 Tony Cook <tony@develop-help.com>