image.c

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