image.c

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