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