image.c

   1 #include "image.h"
   2 #include "imagei.h"
   3 #include "io.h"
   4
   5 /*
   6 =head1 NAME
   7
   8 image.c - implements most of the basic functions of Imager and much of the rest
   9
  10 =head1 SYNOPSIS
  11
  12   i_img *i;
  13   i_color *c;
  14   c = i_color_new(red, green, blue, alpha);
  15   ICL_DESTROY(c);
  16   i = i_img_new();
  17   i_img_destroy(i);
  18   // and much more
  19
  20 =head1 DESCRIPTION
  21
  22 image.c implements the basic functions to create and destroy image and
  23 color objects for Imager.
  24
  25 =head1 FUNCTION REFERENCE
  26
  27 Some of these functions are internal.
  28
  29 =over
  30
  31 =cut
  32 */
  33
  34 #define XAXIS 0
  35 #define YAXIS 1
  36 #define XYAXIS 2
  37
  38 #define minmax(a,b,i) ( ((a>=i)?a: ( (b<=i)?b:i   )) )
  39
  40 /* Hack around an obscure linker bug on solaris - probably due to builtin gcc thingies */
  41 static void fake(void) { ceil(1); }
  42
  43 static int i_ppix_d(i_img *im, int x, int y, i_color *val);
  44 static int i_gpix_d(i_img *im, int x, int y, i_color *val);
  45 static int i_glin_d(i_img *im, int l, int r, int y, i_color *vals);
  46 static int i_plin_d(i_img *im, int l, int r, int y, i_color *vals);
  47 static int i_ppixf_d(i_img *im, int x, int y, i_fcolor *val);
  48 static int i_gpixf_d(i_img *im, int x, int y, i_fcolor *val);
  49 static int i_glinf_d(i_img *im, int l, int r, int y, i_fcolor *vals);
  50 static int i_plinf_d(i_img *im, int l, int r, int y, i_fcolor *vals);
  51 static int i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, const int *chans, int chan_count);
  52 static int i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, const int *chans, int chan_count);
  53 /*static int i_psamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, int *chans, int chan_count);
  54   static int i_psampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, int *chans, int chan_count);*/
  55
  56 /*
  57 =item ICL_new_internal(r, g, b, a)
  58
  59 Return a new color object with values passed to it.
  60
  61    r - red   component (range: 0 - 255)
  62    g - green component (range: 0 - 255)
  63    b - blue  component (range: 0 - 255)
  64    a - alpha component (range: 0 - 255)
  65
  66 =cut
  67 */
  68
  69 i_color *
  70 ICL_new_internal(unsigned char r,unsigned char g,unsigned char b,unsigned char a) {
  71   i_color *cl = NULL;
  72
  73   mm_log((1,"ICL_new_internal(r %d,g %d,b %d,a %d)\n", r, g, b, a));
  74
  75   if ( (cl=mymalloc(sizeof(i_color))) == NULL) m_fatal(2,"malloc() error\n");
  76   cl->rgba.r = r;
  77   cl->rgba.g = g;
  78   cl->rgba.b = b;
  79   cl->rgba.a = a;
  80   mm_log((1,"(%p) <- ICL_new_internal\n",cl));
  81   return cl;
  82 }
  83
  84
  85 /*
  86 =item ICL_set_internal(cl, r, g, b, a)
  87
  88  Overwrite a color with new values.
  89
  90    cl - pointer to color object
  91    r - red   component (range: 0 - 255)
  92    g - green component (range: 0 - 255)
  93    b - blue  component (range: 0 - 255)
  94    a - alpha component (range: 0 - 255)
  95
  96 =cut
  97 */
  98
  99 i_color *
 100 ICL_set_internal(i_color *cl,unsigned char r,unsigned char g,unsigned char b,unsigned char a) {
 101   mm_log((1,"ICL_set_internal(cl* %p,r %d,g %d,b %d,a %d)\n",cl,r,g,b,a));
 102   if (cl == NULL)
 103     if ( (cl=mymalloc(sizeof(i_color))) == NULL)
 104       m_fatal(2,"malloc() error\n");
 105   cl->rgba.r=r;
 106   cl->rgba.g=g;
 107   cl->rgba.b=b;
 108   cl->rgba.a=a;
 109   mm_log((1,"(%p) <- ICL_set_internal\n",cl));
 110   return cl;
 111 }
 112
 113
 114 /*
 115 =item ICL_add(dst, src, ch)
 116
 117 Add src to dst inplace - dst is modified.
 118
 119    dst - pointer to destination color object
 120    src - pointer to color object that is added
 121    ch - number of channels
 122
 123 =cut
 124 */
 125
 126 void
 127 ICL_add(i_color *dst,i_color *src,int ch) {
 128   int tmp,i;
 129   for(i=0;i<ch;i++) {
 130     tmp=dst->channel[i]+src->channel[i];
 131     dst->channel[i]= tmp>255 ? 255:tmp;
 132   }
 133 }
 134
 135 /*
 136 =item ICL_info(cl)
 137
 138 Dump color information to log - strictly for debugging.
 139
 140    cl - pointer to color object
 141
 142 =cut
 143 */
 144
 145 void
 146 ICL_info(i_color *cl) {
 147   mm_log((1,"i_color_info(cl* %p)\n",cl));
 148   mm_log((1,"i_color_info: (%d,%d,%d,%d)\n",cl->rgba.r,cl->rgba.g,cl->rgba.b,cl->rgba.a));
 149 }
 150
 151 /*
 152 =item ICL_DESTROY
 153
 154 Destroy ancillary data for Color object.
 155
 156    cl - pointer to color object
 157
 158 =cut
 159 */
 160
 161 void
 162 ICL_DESTROY(i_color *cl) {
 163   mm_log((1,"ICL_DESTROY(cl* %p)\n",cl));
 164   myfree(cl);
 165 }
 166
 167 /*
 168 =item i_fcolor_new(double r, double g, double b, double a)
 169
 170 =cut
 171 */
 172 i_fcolor *i_fcolor_new(double r, double g, double b, double a) {
 173   i_fcolor *cl = NULL;
 174
 175   mm_log((1,"i_fcolor_new(r %g,g %g,b %g,a %g)\n", r, g, b, a));
 176
 177   if ( (cl=mymalloc(sizeof(i_fcolor))) == NULL) m_fatal(2,"malloc() error\n");
 178   cl->rgba.r = r;
 179   cl->rgba.g = g;
 180   cl->rgba.b = b;
 181   cl->rgba.a = a;
 182   mm_log((1,"(%p) <- i_fcolor_new\n",cl));
 183
 184   return cl;
 185 }
 186
 187 /*
 188 =item i_fcolor_destroy(i_fcolor *cl)
 189
 190 =cut
 191 */
 192 void i_fcolor_destroy(i_fcolor *cl) {
 193   myfree(cl);
 194 }
 195
 196 /*
 197 =item IIM_base_8bit_direct (static)
 198
 199 A static i_img object used to initialize direct 8-bit per sample images.
 200
 201 =cut
 202 */
 203 static i_img IIM_base_8bit_direct =
 204 {
 205   0, /* channels set */
 206   0, 0, 0, /* xsize, ysize, bytes */
 207   ~0U, /* ch_mask */
 208   i_8_bits, /* bits */
 209   i_direct_type, /* type */
 210   0, /* virtual */
 211   NULL, /* idata */
 212   { 0, 0, NULL }, /* tags */
 213   NULL, /* ext_data */
 214
 215   i_ppix_d, /* i_f_ppix */
 216   i_ppixf_d, /* i_f_ppixf */
 217   i_plin_d, /* i_f_plin */
 218   i_plinf_d, /* i_f_plinf */
 219   i_gpix_d, /* i_f_gpix */
 220   i_gpixf_d, /* i_f_gpixf */
 221   i_glin_d, /* i_f_glin */
 222   i_glinf_d, /* i_f_glinf */
 223   i_gsamp_d, /* i_f_gsamp */
 224   i_gsampf_d, /* i_f_gsampf */
 225
 226   NULL, /* i_f_gpal */
 227   NULL, /* i_f_ppal */
 228   NULL, /* i_f_addcolors */
 229   NULL, /* i_f_getcolors */
 230   NULL, /* i_f_colorcount */
 231   NULL, /* i_f_maxcolors */
 232   NULL, /* i_f_findcolor */
 233   NULL, /* i_f_setcolors */
 234
 235   NULL, /* i_f_destroy */
 236 };
 237
 238 /*static void set_8bit_direct(i_img *im) {
 239   im->i_f_ppix = i_ppix_d;
 240   im->i_f_ppixf = i_ppixf_d;
 241   im->i_f_plin = i_plin_d;
 242   im->i_f_plinf = i_plinf_d;
 243   im->i_f_gpix = i_gpix_d;
 244   im->i_f_gpixf = i_gpixf_d;
 245   im->i_f_glin = i_glin_d;
 246   im->i_f_glinf = i_glinf_d;
 247   im->i_f_gpal = NULL;
 248   im->i_f_ppal = NULL;
 249   im->i_f_addcolor = NULL;
 250   im->i_f_getcolor = NULL;
 251   im->i_f_colorcount = NULL;
 252   im->i_f_findcolor = NULL;
 253   }*/
 254
 255 /*
 256 =item IIM_new(x, y, ch)
 257
 258 Creates a new image object I<x> pixels wide, and I<y> pixels high with I<ch> channels.
 259
 260 =cut
 261 */
 262
 263
 264 i_img *
 265 IIM_new(int x,int y,int ch) {
 266   i_img *im;
 267   mm_log((1,"IIM_new(x %d,y %d,ch %d)\n",x,y,ch));
 268
 269   im=i_img_empty_ch(NULL,x,y,ch);
 270
 271   mm_log((1,"(%p) <- IIM_new\n",im));
 272   return im;
 273 }
 274
 275
 276 void
 277 IIM_DESTROY(i_img *im) {
 278   mm_log((1,"IIM_DESTROY(im* %p)\n",im));
 279   i_img_destroy(im);
 280   /*   myfree(cl); */
 281 }
 282
 283
 284
 285 /*
 286 =item i_img_new()
 287
 288 Create new image reference - notice that this isn't an object yet and
 289 this should be fixed asap.
 290
 291 =cut
 292 */
 293
 294
 295 i_img *
 296 i_img_new() {
 297   i_img *im;
 298
 299   mm_log((1,"i_img_struct()\n"));
 300   if ( (im=mymalloc(sizeof(i_img))) == NULL)
 301     m_fatal(2,"malloc() error\n");
 302
 303   *im = IIM_base_8bit_direct;
 304   im->xsize=0;
 305   im->ysize=0;
 306   im->channels=3;
 307   im->ch_mask=MAXINT;
 308   im->bytes=0;
 309   im->idata=NULL;
 310
 311   mm_log((1,"(%p) <- i_img_struct\n",im));
 312   return im;
 313 }
 314
 315 /*
 316 =item i_img_empty(im, x, y)
 317
 318 Re-new image reference (assumes 3 channels)
 319
 320    im - Image pointer
 321    x - xsize of destination image
 322    y - ysize of destination image
 323
 324 **FIXME** what happens if a live image is passed in here?
 325
 326 Should this just call i_img_empty_ch()?
 327
 328 =cut
 329 */
 330
 331 i_img *
 332 i_img_empty(i_img *im,int x,int y) {
 333   mm_log((1,"i_img_empty(*im %p, x %d, y %d)\n",im, x, y));
 334   return i_img_empty_ch(im, x, y, 3);
 335 }
 336
 337 /*
 338 =item i_img_empty_ch(im, x, y, ch)
 339
 340 Re-new image reference
 341
 342    im - Image pointer
 343    x  - xsize of destination image
 344    y  - ysize of destination image
 345    ch - number of channels
 346
 347 =cut
 348 */
 349
 350 i_img *
 351 i_img_empty_ch(i_img *im,int x,int y,int ch) {
 352   mm_log((1,"i_img_empty_ch(*im %p, x %d, y %d, ch %d)\n", im, x, y, ch));
 353   if (im == NULL)
 354     if ( (im=mymalloc(sizeof(i_img))) == NULL)
 355       m_fatal(2,"malloc() error\n");
 356
 357   memcpy(im, &IIM_base_8bit_direct, sizeof(i_img));
 358   i_tags_new(&im->tags);
 359   im->xsize    = x;
 360   im->ysize    = y;
 361   im->channels = ch;
 362   im->ch_mask  = MAXINT;
 363   im->bytes=x*y*im->channels;
 364   if ( (im->idata=mymalloc(im->bytes)) == NULL) m_fatal(2,"malloc() error\n");
 365   memset(im->idata,0,(size_t)im->bytes);
 366
 367   im->ext_data = NULL;
 368
 369   mm_log((1,"(%p) <- i_img_empty_ch\n",im));
 370   return im;
 371 }
 372
 373 /*
 374 =item i_img_exorcise(im)
 375
 376 Free image data.
 377
 378    im - Image pointer
 379
 380 =cut
 381 */
 382
 383 void
 384 i_img_exorcise(i_img *im) {
 385   mm_log((1,"i_img_exorcise(im* 0x%x)\n",im));
 386   i_tags_destroy(&im->tags);
 387   if (im->i_f_destroy)
 388     (im->i_f_destroy)(im);
 389   if (im->idata != NULL) { myfree(im->idata); }
 390   im->idata    = NULL;
 391   im->xsize    = 0;
 392   im->ysize    = 0;
 393   im->channels = 0;
 394
 395   im->i_f_ppix=i_ppix_d;
 396   im->i_f_gpix=i_gpix_d;
 397   im->i_f_plin=i_plin_d;
 398   im->i_f_glin=i_glin_d;
 399   im->ext_data=NULL;
 400 }
 401
 402 /*
 403 =item i_img_destroy(im)
 404
 405 Destroy image and free data via exorcise.
 406
 407    im - Image pointer
 408
 409 =cut
 410 */
 411
 412 void
 413 i_img_destroy(i_img *im) {
 414   mm_log((1,"i_img_destroy(im %p)\n",im));
 415   i_img_exorcise(im);
 416   if (im) { myfree(im); }
 417 }
 418
 419 /*
 420 =item i_img_info(im, info)
 421
 422 Return image information
 423
 424    im - Image pointer
 425    info - pointer to array to return data
 426
 427 info is an array of 4 integers with the following values:
 428
 429  info[0] - width
 430  info[1] - height
 431  info[2] - channels
 432  info[3] - channel mask
 433
 434 =cut
 435 */
 436
 437
 438 void
 439 i_img_info(i_img *im,int *info) {
 440   mm_log((1,"i_img_info(im 0x%x)\n",im));
 441   if (im != NULL) {
 442     mm_log((1,"i_img_info: xsize=%d ysize=%d channels=%d mask=%ud\n",im->xsize,im->ysize,im->channels,im->ch_mask));
 443     mm_log((1,"i_img_info: idata=0x%d\n",im->idata));
 444     info[0] = im->xsize;
 445     info[1] = im->ysize;
 446     info[2] = im->channels;
 447     info[3] = im->ch_mask;
 448   } else {
 449     info[0] = 0;
 450     info[1] = 0;
 451     info[2] = 0;
 452     info[3] = 0;
 453   }
 454 }
 455
 456 /*
 457 =item i_img_setmask(im, ch_mask)
 458
 459 Set the image channel mask for I<im> to I<ch_mask>.
 460
 461 =cut
 462 */
 463 void
 464 i_img_setmask(i_img *im,int ch_mask) { im->ch_mask=ch_mask; }
 465
 466
 467 /*
 468 =item i_img_getmask(im)
 469
 470 Get the image channel mask for I<im>.
 471
 472 =cut
 473 */
 474 int
 475 i_img_getmask(i_img *im) { return im->ch_mask; }
 476
 477 /*
 478 =item i_img_getchannels(im)
 479
 480 Get the number of channels in I<im>.
 481
 482 =cut
 483 */
 484 int
 485 i_img_getchannels(i_img *im) { return im->channels; }
 486
 487
 488
 489 /*
 490 =item i_copyto_trans(im, src, x1, y1, x2, y2, tx, ty, trans)
 491
 492 (x1,y1) (x2,y2) specifies the region to copy (in the source coordinates)
 493 (tx,ty) specifies the upper left corner for the target image.
 494 pass NULL in trans for non transparent i_colors.
 495
 496 =cut
 497 */
 498
 499 void
 500 i_copyto_trans(i_img *im,i_img *src,int x1,int y1,int x2,int y2,int tx,int ty,i_color *trans) {
 501   i_color pv;
 502   int x,y,t,ttx,tty,tt,ch;
 503
 504   mm_log((1,"i_copyto_trans(im* %p,src 0x%x, x1 %d, y1 %d, x2 %d, y2 %d, tx %d, ty %d, trans* 0x%x)\n",
 505           im, src, x1, y1, x2, y2, tx, ty, trans));
 506
 507   if (x2<x1) { t=x1; x1=x2; x2=t; }
 508   if (y2<y1) { t=y1; y1=y2; y2=t; }
 509
 510   ttx=tx;
 511   for(x=x1;x<x2;x++)
 512     {
 513       tty=ty;
 514       for(y=y1;y<y2;y++)
 515         {
 516           i_gpix(src,x,y,&pv);
 517           if ( trans != NULL)
 518           {
 519             tt=0;
 520             for(ch=0;ch<im->channels;ch++) if (trans->channel[ch]!=pv.channel[ch]) tt++;
 521             if (tt) i_ppix(im,ttx,tty,&pv);
 522           } else i_ppix(im,ttx,tty,&pv);
 523           tty++;
 524         }
 525       ttx++;
 526     }
 527 }
 528
 529 /*
 530 =item i_copyto(dest, src, x1, y1, x2, y2, tx, ty)
 531
 532 Copies image data from the area (x1,y1)-[x2,y2] in the source image to
 533 a rectangle the same size with it's top-left corner at (tx,ty) in the
 534 destination image.
 535
 536 If x1 > x2 or y1 > y2 then the corresponding co-ordinates are swapped.
 537
 538 =cut
 539 */
 540
 541 void
 542 i_copyto(i_img *im, i_img *src, int x1, int y1, int x2, int y2, int tx, int ty) {
 543   int x, y, t, ttx, tty;
 544
 545   if (x2<x1) { t=x1; x1=x2; x2=t; }
 546   if (y2<y1) { t=y1; y1=y2; y2=t; }
 547
 548   mm_log((1,"i_copyto(im* %p, src %p, x1 %d, y1 %d, x2 %d, y2 %d, tx %d, ty %d)\n",
 549           im, src, x1, y1, x2, y2, tx, ty));
 550
 551   if (im->bits == i_8_bits) {
 552     i_color pv;
 553     tty = ty;
 554     for(y=y1; y<y2; y++) {
 555       ttx = tx;
 556       for(x=x1; x<x2; x++) {
 557         i_gpix(src, x,   y,   &pv);
 558         i_ppix(im,  ttx, tty, &pv);
 559         ttx++;
 560       }
 561       tty++;
 562     }
 563   }
 564   else {
 565     i_fcolor pv;
 566     tty = ty;
 567     for(y=y1; y<y2; y++) {
 568       ttx = tx;
 569       for(x=x1; x<x2; x++) {
 570         i_gpixf(src, x,   y,   &pv);
 571         i_ppixf(im,  ttx, tty, &pv);
 572         ttx++;
 573       }
 574       tty++;
 575     }
 576   }
 577 }
 578
 579 /*
 580 =item i_copy(im, src)
 581
 582 Copies the contents of the image I<src> over the image I<im>.
 583
 584 =cut
 585 */
 586
 587 void
 588 i_copy(i_img *im, i_img *src) {
 589   int y, y1, x1;
 590
 591   mm_log((1,"i_copy(im* %p,src %p)\n", im, src));
 592
 593   x1 = src->xsize;
 594   y1 = src->ysize;
 595   if (src->type == i_direct_type) {
 596     if (src->bits == i_8_bits) {
 597       i_color *pv;
 598       i_img_empty_ch(im, x1, y1, src->channels);
 599       pv = mymalloc(sizeof(i_color) * x1);
 600
 601       for (y = 0; y < y1; ++y) {
 602         i_glin(src, 0, x1, y, pv);
 603         i_plin(im, 0, x1, y, pv);
 604       }
 605       myfree(pv);
 606     }
 607     else {
 608       i_fcolor *pv;
 609       if (src->bits == i_16_bits)
 610         i_img_16_new_low(im, x1, y1, src->channels);
 611       else if (src->bits == i_double_bits)
 612         i_img_double_new_low(im, x1, y1, src->channels);
 613       else {
 614         fprintf(stderr, "i_copy(): Unknown image bit size %d\n", src->bits);
 615         return; /* I dunno */
 616       }
 617
 618       pv = mymalloc(sizeof(i_fcolor) * x1);
 619       for (y = 0; y < y1; ++y) {
 620         i_glinf(src, 0, x1, y, pv);
 621         i_plinf(im, 0, x1, y, pv);
 622       }
 623       myfree(pv);
 624     }
 625   }
 626   else {
 627     i_color temp;
 628     int index;
 629     int count;
 630     i_palidx *vals;
 631
 632     /* paletted image */
 633     i_img_pal_new_low(im, x1, y1, src->channels, i_maxcolors(src));
 634     /* copy across the palette */
 635     count = i_colorcount(src);
 636     for (index = 0; index < count; ++index) {
 637       i_getcolors(src, index, &temp, 1);
 638       i_addcolors(im, &temp, 1);
 639     }
 640
 641     vals = mymalloc(sizeof(i_palidx) * x1);
 642     for (y = 0; y < y1; ++y) {
 643       i_gpal(src, 0, x1, y, vals);
 644       i_ppal(im, 0, x1, y, vals);
 645     }
 646     myfree(vals);
 647   }
 648 }
 649
 650
 651 /*
 652 =item i_rubthru(im, src, tx, ty)
 653
 654 Takes the image I<src> and applies it at an original (I<tx>,I<ty>) in I<im>.
 655
 656 The alpha channel of each pixel in I<src> is used to control how much
 657 the existing colour in I<im> is replaced, if it is 255 then the colour
 658 is completely replaced, if it is 0 then the original colour is left
 659 unmodified.
 660
 661 =cut
 662 */
 663
 664 int
 665 i_rubthru(i_img *im,i_img *src,int tx,int ty) {
 666   int x, y, ttx, tty;
 667   int chancount;
 668   int chans[3];
 669   int alphachan;
 670   int ch;
 671
 672   mm_log((1,"i_rubthru(im %p, src %p, tx %d, ty %d)\n", im, src, tx, ty));
 673   i_clear_error();
 674
 675   if (im->channels == 3 && src->channels == 4) {
 676     chancount = 3;
 677     chans[0] = 0; chans[1] = 1; chans[2] = 2;
 678     alphachan = 3;
 679   }
 680   else if (im->channels == 3 && src->channels == 2) {
 681     chancount = 3;
 682     chans[0] = chans[1] = chans[2] = 0;
 683     alphachan = 1;
 684   }
 685   else if (im->channels == 1 && src->channels == 2) {
 686     chancount = 1;
 687     chans[0] = 0;
 688     alphachan = 1;
 689   }
 690   else {
 691     i_push_error(0, "rubthru can only work where (dest, src) channels are (3,4), (3,2) or (1,2)");
 692     return 0;
 693   }
 694
 695   if (im->bits <= 8) {
 696     /* if you change this code, please make sure the else branch is
 697        changed in a similar fashion - TC */
 698     int alpha;
 699     i_color pv, orig, dest;
 700     ttx = tx;
 701     for(x=0; x<src->xsize; x++) {
 702       tty=ty;
 703       for(y=0;y<src->ysize;y++) {
 704         /* fprintf(stderr,"reading (%d,%d) writing (%d,%d).\n",x,y,ttx,tty); */
 705         i_gpix(src, x,   y,   &pv);
 706         i_gpix(im,  ttx, tty, &orig);
 707         alpha = pv.channel[alphachan];
 708         for (ch = 0; ch < chancount; ++ch) {
 709           dest.channel[ch] = (alpha * pv.channel[chans[ch]]
 710                               + (255 - alpha) * orig.channel[ch])/255;
 711         }
 712         i_ppix(im, ttx, tty, &dest);
 713         tty++;
 714       }
 715       ttx++;
 716     }
 717   }
 718   else {
 719     double alpha;
 720     i_fcolor pv, orig, dest;
 721
 722     ttx = tx;
 723     for(x=0; x<src->xsize; x++) {
 724       tty=ty;
 725       for(y=0;y<src->ysize;y++) {
 726         /* fprintf(stderr,"reading (%d,%d) writing (%d,%d).\n",x,y,ttx,tty); */
 727         i_gpixf(src, x,   y,   &pv);
 728         i_gpixf(im,  ttx, tty, &orig);
 729         alpha = pv.channel[alphachan];
 730         for (ch = 0; ch < chancount; ++ch) {
 731           dest.channel[ch] = alpha * pv.channel[chans[ch]]
 732                               + (1 - alpha) * orig.channel[ch];
 733         }
 734         i_ppixf(im, ttx, tty, &dest);
 735         tty++;
 736       }
 737       ttx++;
 738     }
 739   }
 740
 741   return 1;
 742 }
 743
 744
 745 /*
 746 =item i_flipxy(im, axis)
 747
 748 Flips the image inplace around the axis specified.
 749 Returns 0 if parameters are invalid.
 750
 751    im   - Image pointer
 752    axis - 0 = x, 1 = y, 2 = both
 753
 754 =cut
 755 */
 756
 757 undef_int
 758 i_flipxy(i_img *im, int direction) {
 759   int x, x2, y, y2, xm, ym;
 760   int xs = im->xsize;
 761   int ys = im->ysize;
 762
 763   mm_log((1, "i_flipxy(im %p, direction %d)\n", im, direction ));
 764
 765   if (!im) return 0;
 766
 767   switch (direction) {
 768   case XAXIS: /* Horizontal flip */
 769     xm = xs/2;
 770     ym = ys;
 771     for(y=0; y<ym; y++) {
 772       x2 = xs-1;
 773       for(x=0; x<xm; x++) {
 774         i_color val1, val2;
 775         i_gpix(im, x,  y,  &val1);
 776         i_gpix(im, x2, y,  &val2);
 777         i_ppix(im, x,  y,  &val2);
 778         i_ppix(im, x2, y,  &val1);
 779         x2--;
 780       }
 781     }
 782     break;
 783   case YAXIS: /* Vertical flip */
 784     xm = xs;
 785     ym = ys/2;
 786     y2 = ys-1;
 787     for(y=0; y<ym; y++) {
 788       for(x=0; x<xm; x++) {
 789         i_color val1, val2;
 790         i_gpix(im, x,  y,  &val1);
 791         i_gpix(im, x,  y2, &val2);
 792         i_ppix(im, x,  y,  &val2);
 793         i_ppix(im, x,  y2, &val1);
 794       }
 795       y2--;
 796     }
 797     break;
 798   case XYAXIS: /* Horizontal and Vertical flip */
 799     xm = xs/2;
 800     ym = ys/2;
 801     y2 = ys-1;
 802     for(y=0; y<ym; y++) {
 803       x2 = xs-1;
 804       for(x=0; x<xm; x++) {
 805         i_color val1, val2;
 806         i_gpix(im, x,  y,  &val1);
 807         i_gpix(im, x2, y2, &val2);
 808         i_ppix(im, x,  y,  &val2);
 809         i_ppix(im, x2, y2, &val1);
 810
 811         i_gpix(im, x2, y,  &val1);
 812         i_gpix(im, x,  y2, &val2);
 813         i_ppix(im, x2, y,  &val2);
 814         i_ppix(im, x,  y2, &val1);
 815         x2--;
 816       }
 817       y2--;
 818     }
 819     if (xm*2 != xs) { /* odd number of column */
 820       mm_log((1, "i_flipxy: odd number of columns\n"));
 821       x = xm;
 822       y2 = ys-1;
 823       for(y=0; y<ym; y++) {
 824         i_color val1, val2;
 825         i_gpix(im, x,  y,  &val1);
 826         i_gpix(im, x,  y2, &val2);
 827         i_ppix(im, x,  y,  &val2);
 828         i_ppix(im, x,  y2, &val1);
 829         y2--;
 830       }
 831     }
 832     if (ym*2 != ys) { /* odd number of rows */
 833       mm_log((1, "i_flipxy: odd number of rows\n"));
 834       y = ym;
 835       x2 = xs-1;
 836       for(x=0; x<xm; x++) {
 837         i_color val1, val2;
 838         i_gpix(im, x,  y,  &val1);
 839         i_gpix(im, x2, y,  &val2);
 840         i_ppix(im, x,  y,  &val2);
 841         i_ppix(im, x2, y,  &val1);
 842         x2--;
 843       }
 844     }
 845     break;
 846   default:
 847     mm_log((1, "i_flipxy: direction is invalid\n" ));
 848     return 0;
 849   }
 850   return 1;
 851 }
 852
 853
 854
 855
 856
 857 static
 858 float
 859 Lanczos(float x) {
 860   float PIx, PIx2;
 861
 862   PIx = PI * x;
 863   PIx2 = PIx / 2.0;
 864
 865   if ((x >= 2.0) || (x <= -2.0)) return (0.0);
 866   else if (x == 0.0) return (1.0);
 867   else return(sin(PIx) / PIx * sin(PIx2) / PIx2);
 868 }
 869
 870 /*
 871 =item i_scaleaxis(im, value, axis)
 872
 873 Returns a new image object which is I<im> scaled by I<value> along
 874 wither the x-axis (I<axis> == 0) or the y-axis (I<axis> == 1).
 875
 876 =cut
 877 */
 878
 879 i_img*
 880 i_scaleaxis(i_img *im, float Value, int Axis) {
 881   int hsize, vsize, i, j, k, l, lMax, iEnd, jEnd;
 882   int LanczosWidthFactor;
 883   float *l0, *l1, OldLocation;
 884   int T;
 885   float t;
 886   float F, PictureValue[MAXCHANNELS];
 887   short psave;
 888   i_color val,val1,val2;
 889   i_img *new_img;
 890
 891   mm_log((1,"i_scaleaxis(im %p,Value %.2f,Axis %d)\n",im,Value,Axis));
 892
 893   if (Axis == XAXIS) {
 894     hsize = (int)(0.5 + im->xsize * Value);
 895     vsize = im->ysize;
 896
 897     jEnd = hsize;
 898     iEnd = vsize;
 899   } else {
 900     hsize = im->xsize;
 901     vsize = (int)(0.5 + im->ysize * Value);
 902
 903     jEnd = vsize;
 904     iEnd = hsize;
 905   }
 906
 907   new_img = i_img_empty_ch(NULL, hsize, vsize, im->channels);
 908
 909   /* 1.4 is a magic number, setting it to 2 will cause rather blurred images */
 910   LanczosWidthFactor = (Value >= 1) ? 1 : (int) (1.4/Value);
 911   lMax = LanczosWidthFactor << 1;
 912
 913   l0 = mymalloc(lMax * sizeof(float));
 914   l1 = mymalloc(lMax * sizeof(float));
 915
 916   for (j=0; j<jEnd; j++) {
 917     OldLocation = ((float) j) / Value;
 918     T = (int) (OldLocation);
 919     F = OldLocation - (float) T;
 920
 921     for (l = 0; l<lMax; l++) {
 922       l0[lMax-l-1] = Lanczos(((float) (lMax-l-1) + F) / (float) LanczosWidthFactor);
 923       l1[l]        = Lanczos(((float) (l+1)      - F) / (float) LanczosWidthFactor);
 924     }
 925
 926     /* Make sure filter is normalized */
 927     t = 0.0;
 928     for(l=0; l<lMax; l++) {
 929       t+=l0[l];
 930       t+=l1[l];
 931     }
 932     t /= (float)LanczosWidthFactor;
 933
 934     for(l=0; l<lMax; l++) {
 935       l0[l] /= t;
 936       l1[l] /= t;
 937     }
 938
 939     if (Axis == XAXIS) {
 940
 941       for (i=0; i<iEnd; i++) {
 942         for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
 943         for (l=0; l<lMax; l++) {
 944           int mx = T-lMax+l+1;
 945           int Mx = T+l+1;
 946           mx = (mx < 0) ? 0 : mx;
 947           Mx = (Mx >= im->xsize) ? im->xsize-1 : Mx;
 948
 949           i_gpix(im, Mx, i, &val1);
 950           i_gpix(im, mx, i, &val2);
 951
 952           for (k=0; k<im->channels; k++) {
 953             PictureValue[k] += l1[l]        * val1.channel[k];
 954             PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
 955           }
 956         }
 957         for(k=0;k<im->channels;k++) {
 958           psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
 959           val.channel[k]=minmax(0,255,psave);
 960         }
 961         i_ppix(new_img, j, i, &val);
 962       }
 963
 964     } else {
 965
 966       for (i=0; i<iEnd; i++) {
 967         for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
 968         for (l=0; l < lMax; l++) {
 969           int mx = T-lMax+l+1;
 970           int Mx = T+l+1;
 971           mx = (mx < 0) ? 0 : mx;
 972           Mx = (Mx >= im->ysize) ? im->ysize-1 : Mx;
 973
 974           i_gpix(im, i, Mx, &val1);
 975           i_gpix(im, i, mx, &val2);
 976           for (k=0; k<im->channels; k++) {
 977             PictureValue[k] += l1[l]        * val1.channel[k];
 978             PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
 979           }
 980         }
 981         for (k=0; k<im->channels; k++) {
 982           psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
 983           val.channel[k] = minmax(0, 255, psave);
 984         }
 985         i_ppix(new_img, i, j, &val);
 986       }
 987
 988     }
 989   }
 990   myfree(l0);
 991   myfree(l1);
 992
 993   mm_log((1,"(%p) <- i_scaleaxis\n", new_img));
 994
 995   return new_img;
 996 }
 997
 998
 999 /*
1000 =item i_scale_nn(im, scx, scy)
1001
1002 Scale by using nearest neighbor
1003 Both axes scaled at the same time since
1004 nothing is gained by doing it in two steps
1005
1006 =cut
1007 */
1008
1009
1010 i_img*
1011 i_scale_nn(i_img *im, float scx, float scy) {
1012
1013   int nxsize,nysize,nx,ny;
1014   i_img *new_img;
1015   i_color val;
1016
1017   mm_log((1,"i_scale_nn(im 0x%x,scx %.2f,scy %.2f)\n",im,scx,scy));
1018
1019   nxsize = (int) ((float) im->xsize * scx);
1020   nysize = (int) ((float) im->ysize * scy);
1021
1022   new_img=i_img_empty_ch(NULL,nxsize,nysize,im->channels);
1023
1024   for(ny=0;ny<nysize;ny++) for(nx=0;nx<nxsize;nx++) {
1025     i_gpix(im,((float)nx)/scx,((float)ny)/scy,&val);
1026     i_ppix(new_img,nx,ny,&val);
1027   }
1028
1029   mm_log((1,"(0x%x) <- i_scale_nn\n",new_img));
1030
1031   return new_img;
1032 }
1033
1034 /*
1035 =item i_sametype(i_img *im, int xsize, int ysize)
1036
1037 Returns an image of the same type (sample size, channels, paletted/direct).
1038
1039 For paletted images the palette is copied from the source.
1040
1041 =cut
1042 */
1043
1044 i_img *i_sametype(i_img *src, int xsize, int ysize) {
1045   if (src->type == i_direct_type) {
1046     if (src->bits == 8) {
1047       return i_img_empty_ch(NULL, xsize, ysize, src->channels);
1048     }
1049     else if (src->bits == i_16_bits) {
1050       return i_img_16_new(xsize, ysize, src->channels);
1051     }
1052     else if (src->bits == i_double_bits) {
1053       return i_img_double_new(xsize, ysize, src->channels);
1054     }
1055     else {
1056       i_push_error(0, "Unknown image bits");
1057       return NULL;
1058     }
1059   }
1060   else {
1061     i_color col;
1062     int i;
1063
1064     i_img *targ = i_img_pal_new(xsize, ysize, src->channels, i_maxcolors(src));
1065     for (i = 0; i < i_colorcount(src); ++i) {
1066       i_getcolors(src, i, &col, 1);
1067       i_addcolors(targ, &col, 1);
1068     }
1069
1070     return targ;
1071   }
1072 }
1073
1074 /*
1075 =item i_sametype_chans(i_img *im, int xsize, int ysize, int channels)
1076
1077 Returns an image of the same type (sample size).
1078
1079 For paletted images the equivalent direct type is returned.
1080
1081 =cut
1082 */
1083
1084 i_img *i_sametype_chans(i_img *src, int xsize, int ysize, int channels) {
1085   if (src->bits == 8) {
1086     return i_img_empty_ch(NULL, xsize, ysize, channels);
1087   }
1088   else if (src->bits == i_16_bits) {
1089     return i_img_16_new(xsize, ysize, channels);
1090   }
1091   else if (src->bits == i_double_bits) {
1092     return i_img_double_new(xsize, ysize, channels);
1093   }
1094   else {
1095     i_push_error(0, "Unknown image bits");
1096     return NULL;
1097   }
1098 }
1099
1100 /*
1101 =item i_transform(im, opx, opxl, opy, opyl, parm, parmlen)
1102
1103 Spatially transforms I<im> returning a new image.
1104
1105 opx for a length of opxl and opy for a length of opy are arrays of
1106 operators that modify the x and y positions to retreive the pixel data from.
1107
1108 parm and parmlen define extra parameters that the operators may use.
1109
1110 Note that this function is largely superseded by the more flexible
1111 L<transform.c/i_transform2>.
1112
1113 Returns the new image.
1114
1115 The operators for this function are defined in L<stackmach.c>.
1116
1117 =cut
1118 */
1119 i_img*
1120 i_transform(i_img *im, int *opx,int opxl,int *opy,int opyl,double parm[],int parmlen) {
1121   double rx,ry;
1122   int nxsize,nysize,nx,ny;
1123   i_img *new_img;
1124   i_color val;
1125
1126   mm_log((1,"i_transform(im 0x%x, opx 0x%x, opxl %d, opy 0x%x, opyl %d, parm 0x%x, parmlen %d)\n",im,opx,opxl,opy,opyl,parm,parmlen));
1127
1128   nxsize = im->xsize;
1129   nysize = im->ysize ;
1130
1131   new_img=i_img_empty_ch(NULL,nxsize,nysize,im->channels);
1132   /*   fprintf(stderr,"parm[2]=%f\n",parm[2]);   */
1133   for(ny=0;ny<nysize;ny++) for(nx=0;nx<nxsize;nx++) {
1134     /*     parm[parmlen-2]=(double)nx;
1135            parm[parmlen-1]=(double)ny; */
1136
1137     parm[0]=(double)nx;
1138     parm[1]=(double)ny;
1139
1140     /*     fprintf(stderr,"(%d,%d) ->",nx,ny);  */
1141     rx=i_op_run(opx,opxl,parm,parmlen);
1142     ry=i_op_run(opy,opyl,parm,parmlen);
1143     /*    fprintf(stderr,"(%f,%f)\n",rx,ry); */
1144     i_gpix(im,rx,ry,&val);
1145     i_ppix(new_img,nx,ny,&val);
1146   }
1147
1148   mm_log((1,"(0x%x) <- i_transform\n",new_img));
1149   return new_img;
1150 }
1151
1152 /*
1153 =item i_img_diff(im1, im2)
1154
1155 Calculates the sum of the squares of the differences between
1156 correspoding channels in two images.
1157
1158 If the images are not the same size then only the common area is
1159 compared, hence even if images are different sizes this function
1160 can return zero.
1161
1162 =cut
1163 */
1164 float
1165 i_img_diff(i_img *im1,i_img *im2) {
1166   int x,y,ch,xb,yb,chb;
1167   float tdiff;
1168   i_color val1,val2;
1169
1170   mm_log((1,"i_img_diff(im1 0x%x,im2 0x%x)\n",im1,im2));
1171
1172   xb=(im1->xsize<im2->xsize)?im1->xsize:im2->xsize;
1173   yb=(im1->ysize<im2->ysize)?im1->ysize:im2->ysize;
1174   chb=(im1->channels<im2->channels)?im1->channels:im2->channels;
1175
1176   mm_log((1,"i_img_diff: xb=%d xy=%d chb=%d\n",xb,yb,chb));
1177
1178   tdiff=0;
1179   for(y=0;y<yb;y++) for(x=0;x<xb;x++) {
1180     i_gpix(im1,x,y,&val1);
1181     i_gpix(im2,x,y,&val2);
1182
1183     for(ch=0;ch<chb;ch++) tdiff+=(val1.channel[ch]-val2.channel[ch])*(val1.channel[ch]-val2.channel[ch]);
1184   }
1185   mm_log((1,"i_img_diff <- (%.2f)\n",tdiff));
1186   return tdiff;
1187 }
1188
1189 /* just a tiny demo of haar wavelets */
1190
1191 i_img*
1192 i_haar(i_img *im) {
1193   int mx,my;
1194   int fx,fy;
1195   int x,y;
1196   int ch,c;
1197   i_img *new_img,*new_img2;
1198   i_color val1,val2,dval1,dval2;
1199
1200   mx=im->xsize;
1201   my=im->ysize;
1202   fx=(mx+1)/2;
1203   fy=(my+1)/2;
1204
1205
1206   /* horizontal pass */
1207
1208   new_img=i_img_empty_ch(NULL,fx*2,fy*2,im->channels);
1209   new_img2=i_img_empty_ch(NULL,fx*2,fy*2,im->channels);
1210
1211   c=0;
1212   for(y=0;y<my;y++) for(x=0;x<fx;x++) {
1213     i_gpix(im,x*2,y,&val1);
1214     i_gpix(im,x*2+1,y,&val2);
1215     for(ch=0;ch<im->channels;ch++) {
1216       dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1217       dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1218     }
1219     i_ppix(new_img,x,y,&dval1);
1220     i_ppix(new_img,x+fx,y,&dval2);
1221   }
1222
1223   for(y=0;y<fy;y++) for(x=0;x<mx;x++) {
1224     i_gpix(new_img,x,y*2,&val1);
1225     i_gpix(new_img,x,y*2+1,&val2);
1226     for(ch=0;ch<im->channels;ch++) {
1227       dval1.channel[ch]=(val1.channel[ch]+val2.channel[ch])/2;
1228       dval2.channel[ch]=(255+val1.channel[ch]-val2.channel[ch])/2;
1229     }
1230     i_ppix(new_img2,x,y,&dval1);
1231     i_ppix(new_img2,x,y+fy,&dval2);
1232   }
1233
1234   i_img_destroy(new_img);
1235   return new_img2;
1236 }
1237
1238 /*
1239 =item i_count_colors(im, maxc)
1240
1241 returns number of colors or -1
1242 to indicate that it was more than max colors
1243
1244 =cut
1245 */
1246 int
1247 i_count_colors(i_img *im,int maxc) {
1248   struct octt *ct;
1249   int x,y;
1250   int xsize,ysize;
1251   i_color val;
1252   int colorcnt;
1253
1254   mm_log((1,"i_count_colors(im 0x%08X,maxc %d)\n"));
1255
1256   xsize=im->xsize;
1257   ysize=im->ysize;
1258   ct=octt_new();
1259
1260   colorcnt=0;
1261   for(y=0;y<ysize;y++) for(x=0;x<xsize;x++) {
1262     i_gpix(im,x,y,&val);
1263     colorcnt+=octt_add(ct,val.rgb.r,val.rgb.g,val.rgb.b);
1264     if (colorcnt > maxc) { octt_delete(ct); return -1; }
1265   }
1266   octt_delete(ct);
1267   return colorcnt;
1268 }
1269
1270 /*
1271 =back
1272
1273 =head2 8-bit per sample image internal functions
1274
1275 These are the functions installed in an 8-bit per sample image.
1276
1277 =over
1278
1279 =item i_ppix_d(im, x, y, col)
1280
1281 Internal function.
1282
1283 This is the function kept in the i_f_ppix member of an i_img object.
1284 It does a normal store of a pixel into the image with range checking.
1285
1286 Returns 0 if the pixel could be set, -1 otherwise.
1287
1288 =cut
1289 */
1290 static
1291 int
1292 i_ppix_d(i_img *im, int x, int y, i_color *val) {
1293   int ch;
1294
1295   if ( x>-1 && x<im->xsize && y>-1 && y<im->ysize ) {
1296     for(ch=0;ch<im->channels;ch++)
1297       if (im->ch_mask&(1<<ch))
1298         im->idata[(x+y*im->xsize)*im->channels+ch]=val->channel[ch];
1299     return 0;
1300   }
1301   return -1; /* error was clipped */
1302 }
1303
1304 /*
1305 =item i_gpix_d(im, x, y, &col)
1306
1307 Internal function.
1308
1309 This is the function kept in the i_f_gpix member of an i_img object.
1310 It does normal retrieval of a pixel from the image with range checking.
1311
1312 Returns 0 if the pixel could be set, -1 otherwise.
1313
1314 =cut
1315 */
1316 static
1317 int
1318 i_gpix_d(i_img *im, int x, int y, i_color *val) {
1319   int ch;
1320   if (x>-1 && x<im->xsize && y>-1 && y<im->ysize) {
1321     for(ch=0;ch<im->channels;ch++)
1322       val->channel[ch]=im->idata[(x+y*im->xsize)*im->channels+ch];
1323     return 0;
1324   }
1325   for(ch=0;ch<im->channels;ch++) val->channel[ch] = 0;
1326   return -1; /* error was cliped */
1327 }
1328
1329 /*
1330 =item i_glin_d(im, l, r, y, vals)
1331
1332 Reads a line of data from the image, storing the pixels at vals.
1333
1334 The line runs from (l,y) inclusive to (r,y) non-inclusive
1335
1336 vals should point at space for (r-l) pixels.
1337
1338 l should never be less than zero (to avoid confusion about where to
1339 put the pixels in vals).
1340
1341 Returns the number of pixels copied (eg. if r, l or y is out of range)
1342
1343 =cut
1344 */
1345 static
1346 int
1347 i_glin_d(i_img *im, int l, int r, int y, i_color *vals) {
1348   int ch, count, i;
1349   unsigned char *data;
1350   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1351     if (r > im->xsize)
1352       r = im->xsize;
1353     data = im->idata + (l+y*im->xsize) * im->channels;
1354     count = r - l;
1355     for (i = 0; i < count; ++i) {
1356       for (ch = 0; ch < im->channels; ++ch)
1357         vals[i].channel[ch] = *data++;
1358     }
1359     return count;
1360   }
1361   else {
1362     return 0;
1363   }
1364 }
1365
1366 /*
1367 =item i_plin_d(im, l, r, y, vals)
1368
1369 Writes a line of data into the image, using the pixels at vals.
1370
1371 The line runs from (l,y) inclusive to (r,y) non-inclusive
1372
1373 vals should point at (r-l) pixels.
1374
1375 l should never be less than zero (to avoid confusion about where to
1376 get the pixels in vals).
1377
1378 Returns the number of pixels copied (eg. if r, l or y is out of range)
1379
1380 =cut
1381 */
1382 static
1383 int
1384 i_plin_d(i_img *im, int l, int r, int y, i_color *vals) {
1385   int ch, count, i;
1386   unsigned char *data;
1387   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1388     if (r > im->xsize)
1389       r = im->xsize;
1390     data = im->idata + (l+y*im->xsize) * im->channels;
1391     count = r - l;
1392     for (i = 0; i < count; ++i) {
1393       for (ch = 0; ch < im->channels; ++ch) {
1394         if (im->ch_mask & (1 << ch))
1395           *data = vals[i].channel[ch];
1396         ++data;
1397       }
1398     }
1399     return count;
1400   }
1401   else {
1402     return 0;
1403   }
1404 }
1405
1406 /*
1407 =item i_ppixf_d(im, x, y, val)
1408
1409 =cut
1410 */
1411 static
1412 int
1413 i_ppixf_d(i_img *im, int x, int y, i_fcolor *val) {
1414   int ch;
1415
1416   if ( x>-1 && x<im->xsize && y>-1 && y<im->ysize ) {
1417     for(ch=0;ch<im->channels;ch++)
1418       if (im->ch_mask&(1<<ch)) {
1419         im->idata[(x+y*im->xsize)*im->channels+ch] =
1420           SampleFTo8(val->channel[ch]);
1421       }
1422     return 0;
1423   }
1424   return -1; /* error was clipped */
1425 }
1426
1427 /*
1428 =item i_gpixf_d(im, x, y, val)
1429
1430 =cut
1431 */
1432 static
1433 int
1434 i_gpixf_d(i_img *im, int x, int y, i_fcolor *val) {
1435   int ch;
1436   if (x>-1 && x<im->xsize && y>-1 && y<im->ysize) {
1437     for(ch=0;ch<im->channels;ch++) {
1438       val->channel[ch] =
1439         Sample8ToF(im->idata[(x+y*im->xsize)*im->channels+ch]);
1440     }
1441     return 0;
1442   }
1443   return -1; /* error was cliped */
1444 }
1445
1446 /*
1447 =item i_glinf_d(im, l, r, y, vals)
1448
1449 Reads a line of data from the image, storing the pixels at vals.
1450
1451 The line runs from (l,y) inclusive to (r,y) non-inclusive
1452
1453 vals should point at space for (r-l) pixels.
1454
1455 l should never be less than zero (to avoid confusion about where to
1456 put the pixels in vals).
1457
1458 Returns the number of pixels copied (eg. if r, l or y is out of range)
1459
1460 =cut
1461 */
1462 static
1463 int
1464 i_glinf_d(i_img *im, int l, int r, int y, i_fcolor *vals) {
1465   int ch, count, i;
1466   unsigned char *data;
1467   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1468     if (r > im->xsize)
1469       r = im->xsize;
1470     data = im->idata + (l+y*im->xsize) * im->channels;
1471     count = r - l;
1472     for (i = 0; i < count; ++i) {
1473       for (ch = 0; ch < im->channels; ++ch)
1474         vals[i].channel[ch] = Sample8ToF(*data++);
1475     }
1476     return count;
1477   }
1478   else {
1479     return 0;
1480   }
1481 }
1482
1483 /*
1484 =item i_plinf_d(im, l, r, y, vals)
1485
1486 Writes a line of data into the image, using the pixels at vals.
1487
1488 The line runs from (l,y) inclusive to (r,y) non-inclusive
1489
1490 vals should point at (r-l) pixels.
1491
1492 l should never be less than zero (to avoid confusion about where to
1493 get the pixels in vals).
1494
1495 Returns the number of pixels copied (eg. if r, l or y is out of range)
1496
1497 =cut
1498 */
1499 static
1500 int
1501 i_plinf_d(i_img *im, int l, int r, int y, i_fcolor *vals) {
1502   int ch, count, i;
1503   unsigned char *data;
1504   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1505     if (r > im->xsize)
1506       r = im->xsize;
1507     data = im->idata + (l+y*im->xsize) * im->channels;
1508     count = r - l;
1509     for (i = 0; i < count; ++i) {
1510       for (ch = 0; ch < im->channels; ++ch) {
1511         if (im->ch_mask & (1 << ch))
1512           *data = SampleFTo8(vals[i].channel[ch]);
1513         ++data;
1514       }
1515     }
1516     return count;
1517   }
1518   else {
1519     return 0;
1520   }
1521 }
1522
1523 /*
1524 =item i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, int *chans, int chan_count)
1525
1526 Reads sample values from im for the horizontal line (l, y) to (r-1,y)
1527 for the channels specified by chans, an array of int with chan_count
1528 elements.
1529
1530 Returns the number of samples read (which should be (r-l) * bits_set(chan_mask)
1531
1532 =cut
1533 */
1534 static
1535 int
1536 i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps,
1537               const int *chans, int chan_count) {
1538   int ch, count, i, w;
1539   unsigned char *data;
1540
1541   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1542     if (r > im->xsize)
1543       r = im->xsize;
1544     data = im->idata + (l+y*im->xsize) * im->channels;
1545     w = r - l;
1546     count = 0;
1547
1548     if (chans) {
1549       /* make sure we have good channel numbers */
1550       for (ch = 0; ch < chan_count; ++ch) {
1551         if (chans[ch] < 0 || chans[ch] >= im->channels) {
1552           i_push_errorf(0, "No channel %d in this image", chans[ch]);
1553           return 0;
1554         }
1555       }
1556       for (i = 0; i < w; ++i) {
1557         for (ch = 0; ch < chan_count; ++ch) {
1558           *samps++ = data[chans[ch]];
1559           ++count;
1560         }
1561         data += im->channels;
1562       }
1563     }
1564     else {
1565       for (i = 0; i < w; ++i) {
1566         for (ch = 0; ch < chan_count; ++ch) {
1567           *samps++ = data[ch];
1568           ++count;
1569         }
1570         data += im->channels;
1571       }
1572     }
1573
1574     return count;
1575   }
1576   else {
1577     return 0;
1578   }
1579 }
1580
1581 /*
1582 =item i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, int *chans, int chan_count)
1583
1584 Reads sample values from im for the horizontal line (l, y) to (r-1,y)
1585 for the channels specified by chan_mask, where bit 0 is the first
1586 channel.
1587
1588 Returns the number of samples read (which should be (r-l) * bits_set(chan_mask)
1589
1590 =cut
1591 */
1592 static
1593 int
1594 i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps,
1595            const int *chans, int chan_count) {
1596   int ch, count, i, w;
1597   unsigned char *data;
1598   for (ch = 0; ch < chan_count; ++ch) {
1599     if (chans[ch] < 0 || chans[ch] >= im->channels) {
1600       i_push_errorf(0, "No channel %d in this image", chans[ch]);
1601     }
1602   }
1603   if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
1604     if (r > im->xsize)
1605       r = im->xsize;
1606     data = im->idata + (l+y*im->xsize) * im->channels;
1607     w = r - l;
1608     count = 0;
1609
1610     if (chans) {
1611       /* make sure we have good channel numbers */
1612       for (ch = 0; ch < chan_count; ++ch) {
1613         if (chans[ch] < 0 || chans[ch] >= im->channels) {
1614           i_push_errorf(0, "No channel %d in this image", chans[ch]);
1615           return 0;
1616         }
1617       }
1618       for (i = 0; i < w; ++i) {
1619         for (ch = 0; ch < chan_count; ++ch) {
1620           *samps++ = Sample8ToF(data[chans[ch]]);
1621           ++count;
1622         }
1623         data += im->channels;
1624       }
1625     }
1626     else {
1627       for (i = 0; i < w; ++i) {
1628         for (ch = 0; ch < chan_count; ++ch) {
1629           *samps++ = Sample8ToF(data[ch]);
1630           ++count;
1631         }
1632         data += im->channels;
1633       }
1634     }
1635     return count;
1636   }
1637   else {
1638     return 0;
1639   }
1640 }
1641
1642 /*
1643 =back
1644
1645 =head2 Image method wrappers
1646
1647 These functions provide i_fsample_t functions in terms of their
1648 i_sample_t versions.
1649
1650 =over
1651
1652 =item i_ppixf_fp(i_img *im, int x, int y, i_fcolor *pix)
1653
1654 =cut
1655 */
1656
1657 int i_ppixf_fp(i_img *im, int x, int y, i_fcolor *pix) {
1658   i_color temp;
1659   int ch;
1660
1661   for (ch = 0; ch < im->channels; ++ch)
1662     temp.channel[ch] = SampleFTo8(pix->channel[ch]);
1663
1664   return i_ppix(im, x, y, &temp);
1665 }
1666
1667 /*
1668 =item i_gpixf_fp(i_img *im, int x, int y, i_fcolor *pix)
1669
1670 =cut
1671 */
1672 int i_gpixf_fp(i_img *im, int x, int y, i_fcolor *pix) {
1673   i_color temp;
1674   int ch;
1675
1676   if (i_gpix(im, x, y, &temp)) {
1677     for (ch = 0; ch < im->channels; ++ch)
1678       pix->channel[ch] = Sample8ToF(temp.channel[ch]);
1679     return 0;
1680   }
1681   else
1682     return -1;
1683 }
1684
1685 /*
1686 =item i_plinf_fp(i_img *im, int l, int r, int y, i_fcolor *pix)
1687
1688 =cut
1689 */
1690 int i_plinf_fp(i_img *im, int l, int r, int y, i_fcolor *pix) {
1691   i_color *work;
1692
1693   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1694     if (r > im->xsize)
1695       r = im->xsize;
1696     if (r > l) {
1697       int ret;
1698       int i, ch;
1699       work = mymalloc(sizeof(i_color) * (r-l));
1700       for (i = 0; i < r-l; ++i) {
1701         for (ch = 0; ch < im->channels; ++ch)
1702           work[i].channel[ch] = SampleFTo8(pix[i].channel[ch]);
1703       }
1704       ret = i_plin(im, l, r, y, work);
1705       myfree(work);
1706
1707       return ret;
1708     }
1709     else {
1710       return 0;
1711     }
1712   }
1713   else {
1714     return 0;
1715   }
1716 }
1717
1718 /*
1719 =item i_glinf_fp(i_img *im, int l, int r, int y, i_fcolor *pix)
1720
1721 =cut
1722 */
1723 int i_glinf_fp(i_img *im, int l, int r, int y, i_fcolor *pix) {
1724   i_color *work;
1725
1726   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1727     if (r > im->xsize)
1728       r = im->xsize;
1729     if (r > l) {
1730       int ret;
1731       int i, ch;
1732       work = mymalloc(sizeof(i_color) * (r-l));
1733       ret = i_plin(im, l, r, y, work);
1734       for (i = 0; i < r-l; ++i) {
1735         for (ch = 0; ch < im->channels; ++ch)
1736           pix[i].channel[ch] = Sample8ToF(work[i].channel[ch]);
1737       }
1738       myfree(work);
1739
1740       return ret;
1741     }
1742     else {
1743       return 0;
1744     }
1745   }
1746   else {
1747     return 0;
1748   }
1749 }
1750
1751 /*
1752 =item i_gsampf_fp(i_img *im, int l, int r, int y, i_fsample_t *samp, int *chans, int chan_count)
1753
1754 =cut
1755 */
1756 int i_gsampf_fp(i_img *im, int l, int r, int y, i_fsample_t *samp,
1757                 int const *chans, int chan_count) {
1758   i_sample_t *work;
1759
1760   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
1761     if (r > im->xsize)
1762       r = im->xsize;
1763     if (r > l) {
1764       int ret;
1765       int i;
1766       work = mymalloc(sizeof(i_sample_t) * (r-l));
1767       ret = i_gsamp(im, l, r, y, work, chans, chan_count);
1768       for (i = 0; i < ret; ++i) {
1769           samp[i] = Sample8ToF(work[i]);
1770       }
1771       myfree(work);
1772
1773       return ret;
1774     }
1775     else {
1776       return 0;
1777     }
1778   }
1779   else {
1780     return 0;
1781   }
1782 }
1783
1784 /*
1785 =back
1786
1787 =head2 Palette wrapper functions
1788
1789 Used for virtual images, these forward palette calls to a wrapped image,
1790 assuming the wrapped image is the first pointer in the structure that
1791 im->ext_data points at.
1792
1793 =over
1794
1795 =item i_addcolors_forward(i_img *im, i_color *colors, int count)
1796
1797 =cut
1798 */
1799 int i_addcolors_forward(i_img *im, i_color *colors, int count) {
1800   return i_addcolors(*(i_img **)im->ext_data, colors, count);
1801 }
1802
1803 /*
1804 =item i_getcolors_forward(i_img *im, int i, i_color *color, int count)
1805
1806 =cut
1807 */
1808 int i_getcolors_forward(i_img *im, int i, i_color *color, int count) {
1809   return i_getcolors(*(i_img **)im->ext_data, i, color, count);
1810 }
1811
1812 /*
1813 =item i_setcolors_forward(i_img *im, int i, i_color *color, int count)
1814
1815 =cut
1816 */
1817 int i_setcolors_forward(i_img *im, int i, i_color *color, int count) {
1818   return i_setcolors(*(i_img **)im->ext_data, i, color, count);
1819 }
1820
1821 /*
1822 =item i_colorcount_forward(i_img *im)
1823
1824 =cut
1825 */
1826 int i_colorcount_forward(i_img *im) {
1827   return i_colorcount(*(i_img **)im->ext_data);
1828 }
1829
1830 /*
1831 =item i_maxcolors_forward(i_img *im)
1832
1833 =cut
1834 */
1835 int i_maxcolors_forward(i_img *im) {
1836   return i_maxcolors(*(i_img **)im->ext_data);
1837 }
1838
1839 /*
1840 =item i_findcolor_forward(i_img *im, i_color *color, i_palidx *entry)
1841
1842 =cut
1843 */
1844 int i_findcolor_forward(i_img *im, i_color *color, i_palidx *entry) {
1845   return i_findcolor(*(i_img **)im->ext_data, color, entry);
1846 }
1847
1848 /*
1849 =back
1850
1851 =head2 Stream reading and writing wrapper functions
1852
1853 =over
1854
1855 =item i_gen_reader(i_gen_read_data *info, char *buf, int length)
1856
1857 Performs general read buffering for file readers that permit reading
1858 to be done through a callback.
1859
1860 The final callback gets two parameters, a I<need> value, and a I<want>
1861 value, where I<need> is the amount of data that the file library needs
1862 to read, and I<want> is the amount of space available in the buffer
1863 maintained by these functions.
1864
1865 This means if you need to read from a stream that you don't know the
1866 length of, you can return I<need> bytes, taking the performance hit of
1867 possibly expensive callbacks (eg. back to perl code), or if you are
1868 reading from a stream where it doesn't matter if some data is lost, or
1869 if the total length of the stream is known, you can return I<want>
1870 bytes.
1871
1872 =cut
1873 */
1874
1875 int
1876 i_gen_reader(i_gen_read_data *gci, char *buf, int length) {
1877   int total;
1878
1879   if (length < gci->length - gci->cpos) {
1880     /* simplest case */
1881     memcpy(buf, gci->buffer+gci->cpos, length);
1882     gci->cpos += length;
1883     return length;
1884   }
1885
1886   total = 0;
1887   memcpy(buf, gci->buffer+gci->cpos, gci->length-gci->cpos);
1888   total  += gci->length - gci->cpos;
1889   length -= gci->length - gci->cpos;
1890   buf    += gci->length - gci->cpos;
1891   if (length < (int)sizeof(gci->buffer)) {
1892     int did_read;
1893     int copy_size;
1894     while (length
1895            && (did_read = (gci->cb)(gci->userdata, gci->buffer, length,
1896                                     sizeof(gci->buffer))) > 0) {
1897       gci->cpos = 0;
1898       gci->length = did_read;
1899
1900       copy_size = i_min(length, gci->length);
1901       memcpy(buf, gci->buffer, copy_size);
1902       gci->cpos += copy_size;
1903       buf += copy_size;
1904       total += copy_size;
1905       length -= copy_size;
1906     }
1907   }
1908   else {
1909     /* just read the rest - too big for our buffer*/
1910     int did_read;
1911     while ((did_read = (gci->cb)(gci->userdata, buf, length, length)) > 0) {
1912       length -= did_read;
1913       total += did_read;
1914       buf += did_read;
1915     }
1916   }
1917   return total;
1918 }
1919
1920 /*
1921 =item i_gen_read_data_new(i_read_callback_t cb, char *userdata)
1922
1923 For use by callback file readers to initialize the reader buffer.
1924
1925 Allocates, initializes and returns the reader buffer.
1926
1927 See also L<image.c/free_gen_read_data> and L<image.c/i_gen_reader>.
1928
1929 =cut
1930 */
1931 i_gen_read_data *
1932 i_gen_read_data_new(i_read_callback_t cb, char *userdata) {
1933   i_gen_read_data *self = mymalloc(sizeof(i_gen_read_data));
1934   self->cb = cb;
1935   self->userdata = userdata;
1936   self->length = 0;
1937   self->cpos = 0;
1938
1939   return self;
1940 }
1941
1942 /*
1943 =item i_free_gen_read_data(i_gen_read_data *)
1944
1945 Cleans up.
1946
1947 =cut
1948 */
1949 void i_free_gen_read_data(i_gen_read_data *self) {
1950   myfree(self);
1951 }
1952
1953 /*
1954 =item i_gen_writer(i_gen_write_data *info, char const *data, int size)
1955
1956 Performs write buffering for a callback based file writer.
1957
1958 Failures are considered fatal, if a write fails then data will be
1959 dropped.
1960
1961 =cut
1962 */
1963 int
1964 i_gen_writer(
1965 i_gen_write_data *self,
1966 char const *data,
1967 int size)
1968 {
1969   if (self->filledto && self->filledto+size > self->maxlength) {
1970     if (self->cb(self->userdata, self->buffer, self->filledto)) {
1971       self->filledto = 0;
1972     }
1973     else {
1974       self->filledto = 0;
1975       return 0;
1976     }
1977   }
1978   if (self->filledto+size <= self->maxlength) {
1979     /* just save it */
1980     memcpy(self->buffer+self->filledto, data, size);
1981     self->filledto += size;
1982     return 1;
1983   }
1984   /* doesn't fit - hand it off */
1985   return self->cb(self->userdata, data, size);
1986 }
1987
1988 /*
1989 =item i_gen_write_data_new(i_write_callback_t cb, char *userdata, int max_length)
1990
1991 Allocates and initializes the data structure used by i_gen_writer.
1992
1993 This should be released with L<image.c/i_free_gen_write_data>
1994
1995 =cut
1996 */
1997 i_gen_write_data *i_gen_write_data_new(i_write_callback_t cb,
1998                                        char *userdata, int max_length)
1999 {
2000   i_gen_write_data *self = mymalloc(sizeof(i_gen_write_data));
2001   self->cb = cb;
2002   self->userdata = userdata;
2003   self->maxlength = i_min(max_length, sizeof(self->buffer));
2004   if (self->maxlength < 0)
2005     self->maxlength = sizeof(self->buffer);
2006   self->filledto = 0;
2007
2008   return self;
2009 }
2010
2011 /*
2012 =item i_free_gen_write_data(i_gen_write_data *info, int flush)
2013
2014 Cleans up the write buffer.
2015
2016 Will flush any left-over data if I<flush> is non-zero.
2017
2018 Returns non-zero if flush is zero or if info->cb() returns non-zero.
2019
2020 Return zero only if flush is non-zero and info->cb() returns zero.
2021 ie. if it fails.
2022
2023 =cut
2024 */
2025
2026 int i_free_gen_write_data(i_gen_write_data *info, int flush)
2027 {
2028   int result = !flush ||
2029     info->filledto == 0 ||
2030     info->cb(info->userdata, info->buffer, info->filledto);
2031   myfree(info);
2032
2033   return result;
2034 }
2035
2036 /*
2037 =back
2038
2039 =head1 AUTHOR
2040
2041 Arnar M. Hrafnkelsson <addi@umich.edu>
2042
2043 Tony Cook <tony@develop-help.com>
2044
2045 =head1 SEE ALSO
2046
2047 L<Imager>, L<gif.c>
2048
2049 =cut
2050 */