image.c

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