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;
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   for(y=0;y<my;y++) for(x=0;x<fx;x++) {
1069     i_gpix(im,x*2,y,&val1);
1070     i_gpix(im,x*2+1,y,&val2);
1071     for(ch=0;ch<im->channels;ch++) {
1072       dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1073       dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1074     }
1075     i_ppix(new_img,x,y,&dval1);
1076     i_ppix(new_img,x+fx,y,&dval2);
1077   }
1078
1079   for(y=0;y<fy;y++) for(x=0;x<mx;x++) {
1080     i_gpix(new_img,x,y*2,&val1);
1081     i_gpix(new_img,x,y*2+1,&val2);
1082     for(ch=0;ch<im->channels;ch++) {
1083       dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1084       dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1085     }
1086     i_ppix(new_img2,x,y,&dval1);
1087     i_ppix(new_img2,x,y+fy,&dval2);
1088   }
1089
1090   i_img_destroy(new_img);
1091   return new_img2;
1092 }
1093
1094 /*
1095 =item i_count_colors(im, maxc)
1096
1097 returns number of colors or -1
1098 to indicate that it was more than max colors
1099
1100 =cut
1101 */
1102 /* This function has been changed and is now faster. It's using
1103  * i_gsamp instead of i_gpix */
1104 int
1105 i_count_colors(i_img *im,int maxc) {
1106   struct octt *ct;
1107   i_img_dim x,y;
1108   int colorcnt;
1109   int channels[3];
1110   int *samp_chans;
1111   i_sample_t * samp;
1112   i_img_dim xsize = im->xsize;
1113   i_img_dim ysize = im->ysize;
1114   int samp_cnt = 3 * xsize;
1115
1116   if (im->channels >= 3) {
1117     samp_chans = NULL;
1118   }
1119   else {
1120     channels[0] = channels[1] = channels[2] = 0;
1121     samp_chans = channels;
1122   }
1123
1124   ct = octt_new();
1125
1126   samp = (i_sample_t *) mymalloc( xsize * 3 * sizeof(i_sample_t));
1127
1128   colorcnt = 0;
1129   for(y = 0; y < ysize; ) {
1130       i_gsamp(im, 0, xsize, y++, samp, samp_chans, 3);
1131       for(x = 0; x < samp_cnt; ) {
1132           colorcnt += octt_add(ct, samp[x], samp[x+1], samp[x+2]);
1133           x += 3;
1134           if (colorcnt > maxc) {
1135               octt_delete(ct);
1136               return -1;
1137           }
1138       }
1139   }
1140   myfree(samp);
1141   octt_delete(ct);
1142   return colorcnt;
1143 }
1144
1145 /* sorts the array ra[0..n-1] into increasing order using heapsort algorithm
1146  * (adapted from the Numerical Recipes)
1147  */
1148 /* Needed by get_anonymous_color_histo */
1149 static void
1150 hpsort(unsigned int n, unsigned *ra) {
1151     unsigned int i,
1152                  ir,
1153                  j,
1154                  l,
1155                  rra;
1156
1157     if (n < 2) return;
1158     l = n >> 1;
1159     ir = n - 1;
1160     for(;;) {
1161         if (l > 0) {
1162             rra = ra[--l];
1163         }
1164         else {
1165             rra = ra[ir];
1166             ra[ir] = ra[0];
1167             if (--ir == 0) {
1168                 ra[0] = rra;
1169                 break;
1170             }
1171         }
1172         i = l;
1173         j = 2 * l + 1;
1174         while (j <= ir) {
1175             if (j < ir && ra[j] < ra[j+1]) j++;
1176             if (rra < ra[j]) {
1177                 ra[i] = ra[j];
1178                 i = j;
1179                 j++; j <<= 1; j--;
1180             }
1181             else break;
1182         }
1183         ra[i] = rra;
1184     }
1185 }
1186
1187 /* This function constructs an ordered list which represents how much the
1188  * different colors are used. So for instance (100, 100, 500) means that one
1189  * color is used for 500 pixels, another for 100 pixels and another for 100
1190  * pixels. It's tuned for performance. You might not like the way I've hardcoded
1191  * the maxc ;-) and you might want to change the name... */
1192 /* Uses octt_histo */
1193 int
1194 i_get_anonymous_color_histo(i_img *im, unsigned int **col_usage, int maxc) {
1195   struct octt *ct;
1196   i_img_dim x,y;
1197   int colorcnt;
1198   unsigned int *col_usage_it;
1199   i_sample_t * samp;
1200   int channels[3];
1201   int *samp_chans;
1202
1203   i_img_dim xsize = im->xsize;
1204   i_img_dim ysize = im->ysize;
1205   int samp_cnt = 3 * xsize;
1206   ct = octt_new();
1207
1208   samp = (i_sample_t *) mymalloc( xsize * 3 * sizeof(i_sample_t));
1209
1210   if (im->channels >= 3) {
1211     samp_chans = NULL;
1212   }
1213   else {
1214     channels[0] = channels[1] = channels[2] = 0;
1215     samp_chans = channels;
1216   }
1217
1218   colorcnt = 0;
1219   for(y = 0; y < ysize; ) {
1220     i_gsamp(im, 0, xsize, y++, samp, samp_chans, 3);
1221     for(x = 0; x < samp_cnt; ) {
1222       colorcnt += octt_add(ct, samp[x], samp[x+1], samp[x+2]);
1223       x += 3;
1224       if (colorcnt > maxc) {
1225         octt_delete(ct);
1226         return -1;
1227       }
1228     }
1229   }
1230   myfree(samp);
1231   /* Now that we know the number of colours... */
1232   col_usage_it = *col_usage = (unsigned int *) mymalloc(colorcnt * sizeof(unsigned int));
1233   octt_histo(ct, &col_usage_it);
1234   hpsort(colorcnt, *col_usage);
1235   octt_delete(ct);
1236   return colorcnt;
1237 }
1238
1239 /*
1240 =back
1241
1242 =head2 Image method wrappers
1243
1244 These functions provide i_fsample_t functions in terms of their
1245 i_sample_t versions.
1246
1247 =over
1248
1249 =item i_ppixf_fp(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix)
1250
1251 =cut
1252 */
1253
1254 int i_ppixf_fp(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix) {
1255   i_color temp;
1256   int ch;
1257
1258   for (ch = 0; ch < im->channels; ++ch)
1259     temp.channel[ch] = SampleFTo8(pix->channel[ch]);
1260
1261   return i_ppix(im, x, y, &temp);
1262 }
1263
1264 /*
1265 =item i_gpixf_fp(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix)
1266
1267 =cut
1268 */
1269 int i_gpixf_fp(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix) {
1270   i_color temp;
1271   int ch;
1272
1273   if (i_gpix(im, x, y, &temp) == 0) {
1274     for (ch = 0; ch < im->channels; ++ch)
1275       pix->channel[ch] = Sample8ToF(temp.channel[ch]);
1276     return 0;
1277   }
1278   else
1279     return -1;
1280 }
1281
1282 /*
1283 =item i_plinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *pix)
1284
1285 =cut
1286 */
1287 i_img_dim
1288 i_plinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *pix) {
1289   i_color *work;
1290
1291   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1292     if (r > im->xsize)
1293       r = im->xsize;
1294     if (r > l) {
1295       i_img_dim ret;
1296       i_img_dim i;
1297       int ch;
1298       work = mymalloc(sizeof(i_color) * (r-l));
1299       for (i = 0; i < r-l; ++i) {
1300         for (ch = 0; ch < im->channels; ++ch)
1301           work[i].channel[ch] = SampleFTo8(pix[i].channel[ch]);
1302       }
1303       ret = i_plin(im, l, r, y, work);
1304       myfree(work);
1305
1306       return ret;
1307     }
1308     else {
1309       return 0;
1310     }
1311   }
1312   else {
1313     return 0;
1314   }
1315 }
1316
1317 /*
1318 =item i_glinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *pix)
1319
1320 =cut
1321 */
1322 i_img_dim
1323 i_glinf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *pix) {
1324   i_color *work;
1325
1326   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1327     if (r > im->xsize)
1328       r = im->xsize;
1329     if (r > l) {
1330       i_img_dim ret;
1331       i_img_dim i;
1332       int ch;
1333       work = mymalloc(sizeof(i_color) * (r-l));
1334       ret = i_plin(im, l, r, y, work);
1335       for (i = 0; i < r-l; ++i) {
1336         for (ch = 0; ch < im->channels; ++ch)
1337           pix[i].channel[ch] = Sample8ToF(work[i].channel[ch]);
1338       }
1339       myfree(work);
1340
1341       return ret;
1342     }
1343     else {
1344       return 0;
1345     }
1346   }
1347   else {
1348     return 0;
1349   }
1350 }
1351
1352 /*
1353 =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)
1354
1355 =cut
1356 */
1357
1358 i_img_dim
1359 i_gsampf_fp(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samp,
1360                 int const *chans, int chan_count) {
1361   i_sample_t *work;
1362
1363   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1364     if (r > im->xsize)
1365       r = im->xsize;
1366     if (r > l) {
1367       i_img_dim ret;
1368       i_img_dim i;
1369       work = mymalloc(sizeof(i_sample_t) * (r-l));
1370       ret = i_gsamp(im, l, r, y, work, chans, chan_count);
1371       for (i = 0; i < ret; ++i) {
1372           samp[i] = Sample8ToF(work[i]);
1373       }
1374       myfree(work);
1375
1376       return ret;
1377     }
1378     else {
1379       return 0;
1380     }
1381   }
1382   else {
1383     return 0;
1384   }
1385 }
1386
1387 /*
1388 =back
1389
1390 =head2 Palette wrapper functions
1391
1392 Used for virtual images, these forward palette calls to a wrapped image,
1393 assuming the wrapped image is the first pointer in the structure that
1394 im->ext_data points at.
1395
1396 =over
1397
1398 =item i_addcolors_forward(i_img *im, const i_color *colors, int count)
1399
1400 =cut
1401 */
1402 int i_addcolors_forward(i_img *im, const i_color *colors, int count) {
1403   return i_addcolors(*(i_img **)im->ext_data, colors, count);
1404 }
1405
1406 /*
1407 =item i_getcolors_forward(i_img *im, int i, i_color *color, int count)
1408
1409 =cut
1410 */
1411 int i_getcolors_forward(i_img *im, int i, i_color *color, int count) {
1412   return i_getcolors(*(i_img **)im->ext_data, i, color, count);
1413 }
1414
1415 /*
1416 =item i_setcolors_forward(i_img *im, int i, const i_color *color, int count)
1417
1418 =cut
1419 */
1420 int i_setcolors_forward(i_img *im, int i, const i_color *color, int count) {
1421   return i_setcolors(*(i_img **)im->ext_data, i, color, count);
1422 }
1423
1424 /*
1425 =item i_colorcount_forward(i_img *im)
1426
1427 =cut
1428 */
1429 int i_colorcount_forward(i_img *im) {
1430   return i_colorcount(*(i_img **)im->ext_data);
1431 }
1432
1433 /*
1434 =item i_maxcolors_forward(i_img *im)
1435
1436 =cut
1437 */
1438 int i_maxcolors_forward(i_img *im) {
1439   return i_maxcolors(*(i_img **)im->ext_data);
1440 }
1441
1442 /*
1443 =item i_findcolor_forward(i_img *im, const i_color *color, i_palidx *entry)
1444
1445 =cut
1446 */
1447 int i_findcolor_forward(i_img *im, const i_color *color, i_palidx *entry) {
1448   return i_findcolor(*(i_img **)im->ext_data, color, entry);
1449 }
1450
1451 /*
1452 =back
1453
1454 =head2 Fallback handler
1455
1456 =over
1457
1458 =item i_gsamp_bits_fb
1459
1460 =cut
1461 */
1462
1463 i_img_dim
1464 i_gsamp_bits_fb(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned *samps,
1465                 const int *chans, int chan_count, int bits) {
1466   dIMCTXim(im);
1467
1468   if (bits < 1 || bits > 32) {
1469     i_push_error(0, "Invalid bits, must be 1..32");
1470     return -1;
1471   }
1472
1473   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1474     double scale;
1475     int ch;
1476     i_img_dim count, i, w;
1477
1478     if (bits == 32)
1479       scale = 4294967295.0;
1480     else
1481       scale = (double)(1 << bits) - 1;
1482
1483     if (r > im->xsize)
1484       r = im->xsize;
1485     w = r - l;
1486     count = 0;
1487
1488     if (chans) {
1489       /* make sure we have good channel numbers */
1490       for (ch = 0; ch < chan_count; ++ch) {
1491         if (chans[ch] < 0 || chans[ch] >= im->channels) {
1492           im_push_errorf(aIMCTX, 0, "No channel %d in this image", chans[ch]);
1493           return -1;
1494         }
1495       }
1496       for (i = 0; i < w; ++i) {
1497         i_fcolor c;
1498         i_gpixf(im, l+i, y, &c);
1499         for (ch = 0; ch < chan_count; ++ch) {
1500           *samps++ = (unsigned)(c.channel[ch] * scale + 0.5);
1501           ++count;
1502         }
1503       }
1504     }
1505     else {
1506       if (chan_count <= 0 || chan_count > im->channels) {
1507         i_push_error(0, "Invalid channel count");
1508         return -1;
1509       }
1510       for (i = 0; i < w; ++i) {
1511         i_fcolor c;
1512         i_gpixf(im, l+i, y, &c);
1513         for (ch = 0; ch < chan_count; ++ch) {
1514           *samps++ = (unsigned)(c.channel[ch] * scale + 0.5);
1515           ++count;
1516         }
1517       }
1518     }
1519
1520     return count;
1521   }
1522   else {
1523     i_push_error(0, "Image position outside of image");
1524     return -1;
1525   }
1526 }
1527
1528 struct magic_entry {
1529   unsigned char *magic;
1530   size_t magic_size;
1531   char *name;
1532   unsigned char *mask;
1533 };
1534
1535 static int
1536 test_magic(unsigned char *buffer, size_t length, struct magic_entry const *magic) {
1537   if (length < magic->magic_size)
1538     return 0;
1539   if (magic->mask) {
1540     int i;
1541     unsigned char *bufp = buffer,
1542       *maskp = magic->mask,
1543       *magicp = magic->magic;
1544
1545     for (i = 0; i < magic->magic_size; ++i) {
1546       int mask = *maskp == 'x' ? 0xFF : *maskp == ' ' ? 0 : *maskp;
1547       ++maskp;
1548
1549       if ((*bufp++ & mask) != (*magicp++ & mask))
1550         return 0;
1551     }
1552
1553     return 1;
1554   }
1555   else {
1556     return !memcmp(magic->magic, buffer, magic->magic_size);
1557   }
1558 }
1559
1560 /*
1561 =item i_test_format_probe(io_glue *data, int length)
1562
1563 Check the beginning of the supplied file for a 'magic number'
1564
1565 =cut
1566 */
1567
1568 #define FORMAT_ENTRY(magic, type) \
1569   { (unsigned char *)(magic ""), sizeof(magic)-1, type }
1570 #define FORMAT_ENTRY2(magic, type, mask) \
1571   { (unsigned char *)(magic ""), sizeof(magic)-1, type, (unsigned char *)(mask) }
1572
1573 const char *
1574 i_test_format_probe(io_glue *data, int length) {
1575   static const struct magic_entry formats[] = {
1576     FORMAT_ENTRY("\xFF\xD8", "jpeg"),
1577     FORMAT_ENTRY("GIF87a", "gif"),
1578     FORMAT_ENTRY("GIF89a", "gif"),
1579     FORMAT_ENTRY("MM\0*", "tiff"),
1580     FORMAT_ENTRY("II*\0", "tiff"),
1581     FORMAT_ENTRY("BM", "bmp"),
1582     FORMAT_ENTRY("\x89PNG\x0d\x0a\x1a\x0a", "png"),
1583     FORMAT_ENTRY("P1", "pnm"),
1584     FORMAT_ENTRY("P2", "pnm"),
1585     FORMAT_ENTRY("P3", "pnm"),
1586     FORMAT_ENTRY("P4", "pnm"),
1587     FORMAT_ENTRY("P5", "pnm"),
1588     FORMAT_ENTRY("P6", "pnm"),
1589     FORMAT_ENTRY("/* XPM", "xpm"),
1590     FORMAT_ENTRY("\x8aMNG", "mng"),
1591     FORMAT_ENTRY("\x8aJNG", "jng"),
1592     /* SGI RGB - with various possible parameters to avoid false positives
1593        on similar files
1594        values are: 2 byte magic, rle flags (0 or 1), bytes/sample (1 or 2)
1595     */
1596     FORMAT_ENTRY("\x01\xDA\x00\x01", "sgi"),
1597     FORMAT_ENTRY("\x01\xDA\x00\x02", "sgi"),
1598     FORMAT_ENTRY("\x01\xDA\x01\x01", "sgi"),
1599     FORMAT_ENTRY("\x01\xDA\x01\x02", "sgi"),
1600
1601     FORMAT_ENTRY2("FORM    ILBM", "ilbm", "xxxx    xxxx"),
1602
1603     /* different versions of PCX format
1604        http://www.fileformat.info/format/pcx/
1605     */
1606     FORMAT_ENTRY("\x0A\x00\x01", "pcx"),
1607     FORMAT_ENTRY("\x0A\x02\x01", "pcx"),
1608     FORMAT_ENTRY("\x0A\x03\x01", "pcx"),
1609     FORMAT_ENTRY("\x0A\x04\x01", "pcx"),
1610     FORMAT_ENTRY("\x0A\x05\x01", "pcx"),
1611
1612     /* FITS - http://fits.gsfc.nasa.gov/ */
1613     FORMAT_ENTRY("SIMPLE  =", "fits"),
1614
1615     /* PSD - Photoshop */
1616     FORMAT_ENTRY("8BPS\x00\x01", "psd"),
1617
1618     /* EPS - Encapsulated Postscript */
1619     /* only reading 18 chars, so we don't include the F in EPSF */
1620     FORMAT_ENTRY("%!PS-Adobe-2.0 EPS", "eps"),
1621
1622     /* Utah RLE */
1623     FORMAT_ENTRY("\x52\xCC", "utah"),
1624
1625     /* GZIP compressed, only matching deflate for now */
1626     FORMAT_ENTRY("\x1F\x8B\x08", "gzip"),
1627
1628     /* bzip2 compressed */
1629     FORMAT_ENTRY("BZh", "bzip2"),
1630
1631     /* WEBP
1632        http://code.google.com/speed/webp/docs/riff_container.html */
1633     FORMAT_ENTRY2("RIFF    WEBP", "webp", "xxxx    xxxx"),
1634
1635     /* JPEG 2000
1636        This might match a little loosely */
1637     FORMAT_ENTRY("\x00\x00\x00\x0CjP  \x0D\x0A\x87\x0A", "jp2"),
1638   };
1639   static const struct magic_entry more_formats[] = {
1640     /* these were originally both listed as ico, but cur files can
1641        include hotspot information */
1642     FORMAT_ENTRY("\x00\x00\x01\x00", "ico"), /* Windows icon */
1643     FORMAT_ENTRY("\x00\x00\x02\x00", "cur"), /* Windows cursor */
1644     FORMAT_ENTRY2("\x00\x00\x00\x00\x00\x00\x00\x07",
1645                   "xwd", "    xxxx"), /* X Windows Dump */
1646   };
1647
1648   unsigned int i;
1649   unsigned char head[18];
1650   ssize_t rc;
1651
1652   rc = i_io_peekn(data, head, 18);
1653   if (rc == -1) return NULL;
1654 #if 0
1655   {
1656     int i;
1657     fprintf(stderr, "%d bytes -", (int)rc);
1658     for (i = 0; i < rc; ++i)
1659       fprintf(stderr, " %02x", head[i]);
1660     fprintf(stderr, "\n");
1661   }
1662 #endif
1663
1664   for(i=0; i<sizeof(formats)/sizeof(formats[0]); i++) {
1665     struct magic_entry const *entry = formats + i;
1666
1667     if (test_magic(head, rc, entry))
1668       return entry->name;
1669   }
1670
1671   if ((rc == 18) &&
1672       tga_header_verify(head))
1673     return "tga";
1674
1675   for(i=0; i<sizeof(more_formats)/sizeof(more_formats[0]); i++) {
1676     struct magic_entry const *entry = more_formats + i;
1677
1678     if (test_magic(head, rc, entry))
1679       return entry->name;
1680   }
1681
1682   return NULL;
1683 }
1684
1685 /*
1686 =item i_img_is_monochrome(img, &zero_is_white)
1687
1688 =category Image Information
1689
1690 Tests an image to check it meets our monochrome tests.
1691
1692 The idea is that a file writer can use this to test where it should
1693 write the image in whatever bi-level format it uses, eg. C<pbm> for
1694 C<pnm>.
1695
1696 For performance of encoders we require monochrome images:
1697
1698 =over
1699
1700 =item *
1701
1702 be paletted
1703
1704 =item *
1705
1706 have a palette of two colors, containing only C<(0,0,0)> and
1707 C<(255,255,255)> in either order.
1708
1709 =back
1710
1711 C<zero_is_white> is set to non-zero if the first palette entry is white.
1712
1713 =cut
1714 */
1715
1716 int
1717 i_img_is_monochrome(i_img *im, int *zero_is_white) {
1718   if (im->type == i_palette_type
1719       && i_colorcount(im) == 2) {
1720     i_color colors[2];
1721     i_getcolors(im, 0, colors, 2);
1722     if (im->channels == 3) {
1723       if (colors[0].rgb.r == 255 &&
1724           colors[0].rgb.g == 255 &&
1725           colors[0].rgb.b == 255 &&
1726           colors[1].rgb.r == 0 &&
1727           colors[1].rgb.g == 0 &&
1728           colors[1].rgb.b == 0) {
1729         *zero_is_white = 1;
1730         return 1;
1731       }
1732       else if (colors[0].rgb.r == 0 &&
1733                colors[0].rgb.g == 0 &&
1734                colors[0].rgb.b == 0 &&
1735                colors[1].rgb.r == 255 &&
1736                colors[1].rgb.g == 255 &&
1737                colors[1].rgb.b == 255) {
1738         *zero_is_white = 0;
1739         return 1;
1740       }
1741     }
1742     else if (im->channels == 1) {
1743       if (colors[0].channel[0] == 255 &&
1744           colors[1].channel[0] == 0) {
1745         *zero_is_white = 1;
1746         return 1;
1747       }
1748       else if (colors[0].channel[0] == 0 &&
1749                colors[1].channel[0] == 255) {
1750         *zero_is_white = 0;
1751         return 1;
1752       }
1753     }
1754   }
1755
1756   *zero_is_white = 0;
1757   return 0;
1758 }
1759
1760 /*
1761 =item i_get_file_background(im, &bg)
1762
1763 =category Files
1764
1765 Retrieve the file write background color tag from the image.
1766
1767 If not present, C<bg> is set to black.
1768
1769 Returns 1 if the C<i_background> tag was found and valid.
1770
1771 =cut
1772 */
1773
1774 int
1775 i_get_file_background(i_img *im, i_color *bg) {
1776   int result = i_tags_get_color(&im->tags, "i_background", 0, bg);
1777   if (!result) {
1778     /* black default */
1779     bg->channel[0] = bg->channel[1] = bg->channel[2] = 0;
1780   }
1781   /* always full alpha */
1782   bg->channel[3] = 255;
1783
1784   return result;
1785 }
1786
1787 /*
1788 =item i_get_file_backgroundf(im, &bg)
1789
1790 =category Files
1791
1792 Retrieve the file write background color tag from the image as a
1793 floating point color.
1794
1795 Implemented in terms of i_get_file_background().
1796
1797 If not present, C<bg> is set to black.
1798
1799 Returns 1 if the C<i_background> tag was found and valid.
1800
1801 =cut
1802 */
1803
1804 int
1805 i_get_file_backgroundf(i_img *im, i_fcolor *fbg) {
1806   i_color bg;
1807   int result = i_get_file_background(im, &bg);
1808   fbg->rgba.r = Sample8ToF(bg.rgba.r);
1809   fbg->rgba.g = Sample8ToF(bg.rgba.g);
1810   fbg->rgba.b = Sample8ToF(bg.rgba.b);
1811   fbg->rgba.a = 1.0;
1812
1813   return result;
1814 }
1815
1816 /*
1817 =back
1818
1819 =head1 AUTHOR
1820
1821 Arnar M. Hrafnkelsson <addi@umich.edu>
1822
1823 Tony Cook <tonyc@cpan.org>
1824
1825 =head1 SEE ALSO
1826
1827 L<Imager>, L<gif.c>
1828
1829 =cut
1830 */