image.c

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