Imager.xs

   1 #define PERL_NO_GET_CONTEXT
   2 #ifdef __cplusplus
   3 extern "C" {
   4 #endif
   5 #include "EXTERN.h"
   6 #include "perl.h"
   7 #include "XSUB.h"
   8 #define NEED_newRV_noinc
   9 #define NEED_sv_2pv_nolen
  10 #define NEED_sv_2pvbyte
  11 #include "ppport.h"
  12 #ifdef __cplusplus
  13 }
  14 #endif
  15
  16 #define i_int_hlines_testing() 1
  17
  18 #include "imager.h"
  19 #include "feat.h"
  20 #include "dynaload.h"
  21 #include "regmach.h"
  22 #include "imextdef.h"
  23 #include "imextpltypes.h"
  24 #include <float.h>
  25
  26 #if i_int_hlines_testing()
  27 #include "imageri.h"
  28 #endif
  29
  30 #include "imperl.h"
  31
  32 /*
  33
  34 Allocate memory that will be discarded when mortals are discarded.
  35
  36 */
  37
  38 static void *
  39 malloc_temp(pTHX_ size_t size) {
  40   SV *sv = sv_2mortal(newSV(size));
  41
  42   return SvPVX(sv);
  43 }
  44
  45 /* These functions are all shared - then comes platform dependant code */
  46 static int getstr(void *hv_t,char *key,char **store) {
  47   dTHX;
  48   SV** svpp;
  49   HV* hv=(HV*)hv_t;
  50
  51   mm_log((1,"getstr(hv_t %p, key %s, store %p)\n",hv_t,key,store));
  52
  53   if ( !hv_exists(hv,key,strlen(key)) ) return 0;
  54
  55   svpp=hv_fetch(hv, key, strlen(key), 0);
  56   *store=SvPV(*svpp, PL_na );
  57
  58   return 1;
  59 }
  60
  61 static int getint(void *hv_t,char *key,int *store) {
  62   dTHX;
  63   SV** svpp;
  64   HV* hv=(HV*)hv_t;
  65
  66   mm_log((1,"getint(hv_t %p, key %s, store %p)\n",hv_t,key,store));
  67
  68   if ( !hv_exists(hv,key,strlen(key)) ) return 0;
  69
  70   svpp=hv_fetch(hv, key, strlen(key), 0);
  71   *store=(int)SvIV(*svpp);
  72   return 1;
  73 }
  74
  75 static int getdouble(void *hv_t,char* key,double *store) {
  76   dTHX;
  77   SV** svpp;
  78   HV* hv=(HV*)hv_t;
  79
  80   mm_log((1,"getdouble(hv_t %p, key %s, store %p)\n",hv_t,key,store));
  81
  82   if ( !hv_exists(hv,key,strlen(key)) ) return 0;
  83   svpp=hv_fetch(hv, key, strlen(key), 0);
  84   *store=(double)SvNV(*svpp);
  85   return 1;
  86 }
  87
  88 static int getvoid(void *hv_t,char* key,void **store) {
  89   dTHX;
  90   SV** svpp;
  91   HV* hv=(HV*)hv_t;
  92
  93   mm_log((1,"getvoid(hv_t %p, key %s, store %p)\n",hv_t,key,store));
  94
  95   if ( !hv_exists(hv,key,strlen(key)) ) return 0;
  96
  97   svpp=hv_fetch(hv, key, strlen(key), 0);
  98   *store = INT2PTR(void*, SvIV(*svpp));
  99
 100   return 1;
 101 }
 102
 103 static int getobj(void *hv_t,char *key,char *type,void **store) {
 104   dTHX;
 105   SV** svpp;
 106   HV* hv=(HV*)hv_t;
 107
 108   mm_log((1,"getobj(hv_t %p, key %s,type %s, store %p)\n",hv_t,key,type,store));
 109
 110   if ( !hv_exists(hv,key,strlen(key)) ) return 0;
 111
 112   svpp=hv_fetch(hv, key, strlen(key), 0);
 113
 114   if (sv_derived_from(*svpp,type)) {
 115     IV tmp = SvIV((SV*)SvRV(*svpp));
 116     *store = INT2PTR(void*, tmp);
 117   } else {
 118     mm_log((1,"getobj: key exists in hash but is not of correct type"));
 119     return 0;
 120   }
 121
 122   return 1;
 123 }
 124
 125 UTIL_table_t i_UTIL_table={getstr,getint,getdouble,getvoid,getobj};
 126
 127 void my_SvREFCNT_dec(void *p) {
 128   dTHX;
 129   SvREFCNT_dec((SV*)p);
 130 }
 131
 132
 133 static void
 134 i_log_entry(char *string, int level) {
 135   mm_log((level, "%s", string));
 136 }
 137
 138
 139 #define CBDATA_BUFSIZE 8192
 140
 141 struct cbdata {
 142   /* the SVs we use to call back to Perl */
 143   SV *writecb;
 144   SV *readcb;
 145   SV *seekcb;
 146   SV *closecb;
 147 };
 148
 149 static ssize_t
 150 call_reader(struct cbdata *cbd, void *buf, size_t size,
 151             size_t maxread) {
 152   dTHX;
 153   int count;
 154   int result;
 155   SV *data;
 156   dSP;
 157
 158   if (!SvOK(cbd->readcb))
 159     return -1;
 160
 161   ENTER;
 162   SAVETMPS;
 163   EXTEND(SP, 2);
 164   PUSHMARK(SP);
 165   PUSHs(sv_2mortal(newSViv(size)));
 166   PUSHs(sv_2mortal(newSViv(maxread)));
 167   PUTBACK;
 168
 169   count = perl_call_sv(cbd->readcb, G_SCALAR);
 170
 171   SPAGAIN;
 172
 173   if (count != 1)
 174     croak("Result of perl_call_sv(..., G_SCALAR) != 1");
 175
 176   data = POPs;
 177
 178   if (SvOK(data)) {
 179     STRLEN len;
 180     char *ptr = SvPVbyte(data, len);
 181     if (len > maxread)
 182       croak("Too much data returned in reader callback (wanted %d, got %d, expected %d)",
 183       (int)size, (int)len, (int)maxread);
 184
 185     memcpy(buf, ptr, len);
 186     result = len;
 187   }
 188   else {
 189     result = -1;
 190   }
 191
 192   PUTBACK;
 193   FREETMPS;
 194   LEAVE;
 195
 196   return result;
 197 }
 198
 199 static off_t
 200 io_seeker(void *p, off_t offset, int whence) {
 201   dTHX;
 202   struct cbdata *cbd = p;
 203   int count;
 204   off_t result;
 205   dSP;
 206
 207   if (!SvOK(cbd->seekcb))
 208     return -1;
 209
 210   ENTER;
 211   SAVETMPS;
 212   EXTEND(SP, 2);
 213   PUSHMARK(SP);
 214   PUSHs(sv_2mortal(newSViv(offset)));
 215   PUSHs(sv_2mortal(newSViv(whence)));
 216   PUTBACK;
 217
 218   count = perl_call_sv(cbd->seekcb, G_SCALAR);
 219
 220   SPAGAIN;
 221
 222   if (count != 1)
 223     croak("Result of perl_call_sv(..., G_SCALAR) != 1");
 224
 225   result = POPi;
 226
 227   PUTBACK;
 228   FREETMPS;
 229   LEAVE;
 230
 231   return result;
 232 }
 233
 234 static ssize_t
 235 io_writer(void *p, void const *data, size_t size) {
 236   dTHX;
 237   struct cbdata *cbd = p;
 238   I32 count;
 239   SV *sv;
 240   dSP;
 241   bool success;
 242
 243   if (!SvOK(cbd->writecb))
 244     return -1;
 245
 246   ENTER;
 247   SAVETMPS;
 248   EXTEND(SP, 1);
 249   PUSHMARK(SP);
 250   PUSHs(sv_2mortal(newSVpv((char *)data, size)));
 251   PUTBACK;
 252
 253   count = perl_call_sv(cbd->writecb, G_SCALAR);
 254
 255   SPAGAIN;
 256   if (count != 1)
 257     croak("Result of perl_call_sv(..., G_SCALAR) != 1");
 258
 259   sv = POPs;
 260   success = SvTRUE(sv);
 261
 262
 263   PUTBACK;
 264   FREETMPS;
 265   LEAVE;
 266
 267   return success ? size : -1;
 268 }
 269
 270 static ssize_t
 271 io_reader(void *p, void *data, size_t size) {
 272   struct cbdata *cbd = p;
 273
 274   return call_reader(cbd, data, size, size);
 275 }
 276
 277 static int io_closer(void *p) {
 278   dTHX;
 279   struct cbdata *cbd = p;
 280   int success = 1;
 281
 282   if (SvOK(cbd->closecb)) {
 283     dSP;
 284     I32 count;
 285     SV *sv;
 286
 287     ENTER;
 288     SAVETMPS;
 289     PUSHMARK(SP);
 290     PUTBACK;
 291
 292     count = perl_call_sv(cbd->closecb, G_SCALAR);
 293
 294     SPAGAIN;
 295
 296     sv = POPs;
 297     success = SvTRUE(sv);
 298
 299     PUTBACK;
 300     FREETMPS;
 301     LEAVE;
 302   }
 303
 304   return success ? 0 : -1;
 305 }
 306
 307 static void io_destroyer(void *p) {
 308   dTHX;
 309   struct cbdata *cbd = p;
 310
 311   SvREFCNT_dec(cbd->writecb);
 312   SvREFCNT_dec(cbd->readcb);
 313   SvREFCNT_dec(cbd->seekcb);
 314   SvREFCNT_dec(cbd->closecb);
 315   myfree(cbd);
 316 }
 317
 318 static i_io_glue_t *
 319 do_io_new_buffer(pTHX_ SV *data_sv) {
 320   const char *data;
 321   STRLEN length;
 322
 323   data = SvPVbyte(data_sv, length);
 324   SvREFCNT_inc(data_sv);
 325   return io_new_buffer(data, length, my_SvREFCNT_dec, data_sv);
 326 }
 327
 328 static i_io_glue_t *
 329 do_io_new_cb(pTHX_ SV *writecb, SV *readcb, SV *seekcb, SV *closecb) {
 330   struct cbdata *cbd;
 331
 332   cbd = mymalloc(sizeof(struct cbdata));
 333   cbd->writecb = newSVsv(writecb);
 334   cbd->readcb = newSVsv(readcb);
 335   cbd->seekcb = newSVsv(seekcb);
 336   cbd->closecb = newSVsv(closecb);
 337
 338   return io_new_cb(cbd, io_reader, io_writer, io_seeker, io_closer,
 339                    io_destroyer);
 340 }
 341
 342 struct value_name {
 343   char *name;
 344   int value;
 345 };
 346 static int lookup_name(struct value_name *names, int count, char *name, int def_value)
 347 {
 348   int i;
 349   for (i = 0; i < count; ++i)
 350     if (strEQ(names[i].name, name))
 351       return names[i].value;
 352
 353   return def_value;
 354 }
 355 static struct value_name transp_names[] =
 356 {
 357   { "none", tr_none },
 358   { "threshold", tr_threshold },
 359   { "errdiff", tr_errdiff },
 360   { "ordered", tr_ordered, },
 361 };
 362
 363 static struct value_name make_color_names[] =
 364 {
 365   { "none", mc_none, },
 366   { "webmap", mc_web_map, },
 367   { "addi", mc_addi, },
 368   { "mediancut", mc_median_cut, },
 369   { "mono", mc_mono, },
 370   { "monochrome", mc_mono, },
 371 };
 372
 373 static struct value_name translate_names[] =
 374 {
 375   { "giflib", pt_giflib, },
 376   { "closest", pt_closest, },
 377   { "perturb", pt_perturb, },
 378   { "errdiff", pt_errdiff, },
 379 };
 380
 381 static struct value_name errdiff_names[] =
 382 {
 383   { "floyd", ed_floyd, },
 384   { "jarvis", ed_jarvis, },
 385   { "stucki", ed_stucki, },
 386   { "custom", ed_custom, },
 387 };
 388
 389 static struct value_name orddith_names[] =
 390 {
 391   { "random", od_random, },
 392   { "dot8", od_dot8, },
 393   { "dot4", od_dot4, },
 394   { "hline", od_hline, },
 395   { "vline", od_vline, },
 396   { "/line", od_slashline, },
 397   { "slashline", od_slashline, },
 398   { "\\line", od_backline, },
 399   { "backline", od_backline, },
 400   { "tiny", od_tiny, },
 401   { "custom", od_custom, },
 402 };
 403
 404 /* look through the hash for quantization options */
 405 static void
 406 ip_handle_quant_opts(pTHX_ i_quantize *quant, HV *hv)
 407 {
 408   /*** POSSIBLY BROKEN: do I need to unref the SV from hv_fetch ***/
 409   SV **sv;
 410   int i;
 411   STRLEN len;
 412   char *str;
 413
 414   quant->mc_colors = mymalloc(quant->mc_size * sizeof(i_color));
 415
 416   sv = hv_fetch(hv, "transp", 6, 0);
 417   if (sv && *sv && (str = SvPV(*sv, len))) {
 418     quant->transp =
 419       lookup_name(transp_names, sizeof(transp_names)/sizeof(*transp_names),
 420                   str, tr_none);
 421     if (quant->transp != tr_none) {
 422       quant->tr_threshold = 127;
 423       sv = hv_fetch(hv, "tr_threshold", 12, 0);
 424       if (sv && *sv)
 425         quant->tr_threshold = SvIV(*sv);
 426     }
 427     if (quant->transp == tr_errdiff) {
 428       sv = hv_fetch(hv, "tr_errdiff", 10, 0);
 429       if (sv && *sv && (str = SvPV(*sv, len)))
 430         quant->tr_errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
 431     }
 432     if (quant->transp == tr_ordered) {
 433       quant->tr_orddith = od_tiny;
 434       sv = hv_fetch(hv, "tr_orddith", 10, 0);
 435       if (sv && *sv && (str = SvPV(*sv, len)))
 436         quant->tr_orddith = lookup_name(orddith_names, sizeof(orddith_names)/sizeof(*orddith_names), str, od_random);
 437
 438       if (quant->tr_orddith == od_custom) {
 439         sv = hv_fetch(hv, "tr_map", 6, 0);
 440         if (sv && *sv && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
 441           AV *av = (AV*)SvRV(*sv);
 442           len = av_len(av) + 1;
 443           if (len > sizeof(quant->tr_custom))
 444             len = sizeof(quant->tr_custom);
 445           for (i = 0; i < len; ++i) {
 446             SV **sv2 = av_fetch(av, i, 0);
 447             if (sv2 && *sv2) {
 448               quant->tr_custom[i] = SvIV(*sv2);
 449             }
 450           }
 451           while (i < sizeof(quant->tr_custom))
 452             quant->tr_custom[i++] = 0;
 453         }
 454       }
 455     }
 456   }
 457   quant->make_colors = mc_median_cut;
 458   sv = hv_fetch(hv, "make_colors", 11, 0);
 459   if (sv && *sv && (str = SvPV(*sv, len))) {
 460     quant->make_colors =
 461       lookup_name(make_color_names, sizeof(make_color_names)/sizeof(*make_color_names), str, mc_median_cut);
 462   }
 463   sv = hv_fetch(hv, "colors", 6, 0);
 464   if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
 465     /* needs to be an array of Imager::Color
 466        note that the caller allocates the mc_color array and sets mc_size
 467        to it's size */
 468     AV *av = (AV *)SvRV(*sv);
 469     quant->mc_count = av_len(av)+1;
 470     if (quant->mc_count > quant->mc_size)
 471       quant->mc_count = quant->mc_size;
 472     for (i = 0; i < quant->mc_count; ++i) {
 473       SV **sv1 = av_fetch(av, i, 0);
 474       if (sv1 && *sv1 && SvROK(*sv1) && sv_derived_from(*sv1, "Imager::Color")) {
 475         i_color *col = INT2PTR(i_color *, SvIV((SV*)SvRV(*sv1)));
 476         quant->mc_colors[i] = *col;
 477       }
 478     }
 479   }
 480   sv = hv_fetch(hv, "max_colors", 10, 0);
 481   if (sv && *sv) {
 482     i = SvIV(*sv);
 483     if (i <= quant->mc_size && i >= quant->mc_count)
 484       quant->mc_size = i;
 485   }
 486
 487   quant->translate = pt_closest;
 488   sv = hv_fetch(hv, "translate", 9, 0);
 489   if (sv && *sv && (str = SvPV(*sv, len))) {
 490     quant->translate = lookup_name(translate_names, sizeof(translate_names)/sizeof(*translate_names), str, pt_closest);
 491   }
 492   sv = hv_fetch(hv, "errdiff", 7, 0);
 493   if (sv && *sv && (str = SvPV(*sv, len))) {
 494     quant->errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
 495   }
 496   if (quant->translate == pt_errdiff && quant->errdiff == ed_custom) {
 497     /* get the error diffusion map */
 498     sv = hv_fetch(hv, "errdiff_width", 13, 0);
 499     if (sv && *sv)
 500       quant->ed_width = SvIV(*sv);
 501     sv = hv_fetch(hv, "errdiff_height", 14, 0);
 502     if (sv && *sv)
 503       quant->ed_height = SvIV(*sv);
 504     sv = hv_fetch(hv, "errdiff_orig", 12, 0);
 505     if (sv && *sv)
 506       quant->ed_orig = SvIV(*sv);
 507     if (quant->ed_width > 0 && quant->ed_height > 0) {
 508       int sum = 0;
 509       quant->ed_map = mymalloc(sizeof(int)*quant->ed_width*quant->ed_height);
 510       sv = hv_fetch(hv, "errdiff_map", 11, 0);
 511       if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
 512         AV *av = (AV*)SvRV(*sv);
 513         len = av_len(av) + 1;
 514         if (len > quant->ed_width * quant->ed_height)
 515           len = quant->ed_width * quant->ed_height;
 516         for (i = 0; i < len; ++i) {
 517           SV **sv2 = av_fetch(av, i, 0);
 518           if (sv2 && *sv2) {
 519             quant->ed_map[i] = SvIV(*sv2);
 520             sum += quant->ed_map[i];
 521           }
 522         }
 523       }
 524       if (!sum) {
 525         /* broken map */
 526         myfree(quant->ed_map);
 527         quant->ed_map = 0;
 528         quant->errdiff = ed_floyd;
 529       }
 530     }
 531   }
 532   sv = hv_fetch(hv, "perturb", 7, 0);
 533   if (sv && *sv)
 534     quant->perturb = SvIV(*sv);
 535 }
 536
 537 static void
 538 ip_cleanup_quant_opts(pTHX_ i_quantize *quant) {
 539   myfree(quant->mc_colors);
 540   if (quant->ed_map)
 541     myfree(quant->ed_map);
 542 }
 543
 544 /* copies the color map from the hv into the colors member of the HV */
 545 static void
 546 ip_copy_colors_back(pTHX_ HV *hv, i_quantize *quant) {
 547   SV **sv;
 548   AV *av;
 549   int i;
 550   SV *work;
 551
 552   sv = hv_fetch(hv, "colors", 6, 0);
 553   if (!sv || !*sv || !SvROK(*sv) || SvTYPE(SvRV(*sv)) != SVt_PVAV) {
 554     /* nothing to do */
 555     return;
 556   }
 557
 558   av = (AV *)SvRV(*sv);
 559   av_clear(av);
 560   av_extend(av, quant->mc_count+1);
 561   for (i = 0; i < quant->mc_count; ++i) {
 562     i_color *in = quant->mc_colors+i;
 563     Imager__Color c = ICL_new_internal(in->rgb.r, in->rgb.g, in->rgb.b, 255);
 564     work = sv_newmortal();
 565     sv_setref_pv(work, "Imager::Color", (void *)c);
 566     SvREFCNT_inc(work);
 567     av_push(av, work);
 568   }
 569 }
 570
 571 /* loads the segments of a fountain fill into an array */
 572 static i_fountain_seg *
 573 load_fount_segs(pTHX_ AV *asegs, int *count) {
 574   /* Each element of segs must contain:
 575      [ start, middle, end, c0, c1, segtype, colortrans ]
 576      start, middle, end are doubles from 0 to 1
 577      c0, c1 are Imager::Color::Float or Imager::Color objects
 578      segtype, colortrans are ints
 579   */
 580   int i, j;
 581   AV *aseg;
 582   i_fountain_seg *segs;
 583   double work[3];
 584   int worki[2];
 585
 586   *count = av_len(asegs)+1;
 587   if (*count < 1)
 588     croak("i_fountain must have at least one segment");
 589   segs = mymalloc(sizeof(i_fountain_seg) * *count);
 590   for(i = 0; i < *count; i++) {
 591     SV **sv1 = av_fetch(asegs, i, 0);
 592     if (!sv1 || !*sv1 || !SvROK(*sv1)
 593         || SvTYPE(SvRV(*sv1)) != SVt_PVAV) {
 594       myfree(segs);
 595       croak("i_fountain: segs must be an arrayref of arrayrefs");
 596     }
 597     aseg = (AV *)SvRV(*sv1);
 598     if (av_len(aseg) != 7-1) {
 599       myfree(segs);
 600       croak("i_fountain: a segment must have 7 members");
 601     }
 602     for (j = 0; j < 3; ++j) {
 603       SV **sv2 = av_fetch(aseg, j, 0);
 604       if (!sv2 || !*sv2) {
 605         myfree(segs);
 606         croak("i_fountain: XS error");
 607       }
 608       work[j] = SvNV(*sv2);
 609     }
 610     segs[i].start  = work[0];
 611     segs[i].middle = work[1];
 612     segs[i].end    = work[2];
 613     for (j = 0; j < 2; ++j) {
 614       SV **sv3 = av_fetch(aseg, 3+j, 0);
 615       if (!sv3 || !*sv3 || !SvROK(*sv3) ||
 616           (!sv_derived_from(*sv3, "Imager::Color")
 617            && !sv_derived_from(*sv3, "Imager::Color::Float"))) {
 618         myfree(segs);
 619         croak("i_fountain: segs must contain colors in elements 3 and 4");
 620       }
 621       if (sv_derived_from(*sv3, "Imager::Color::Float")) {
 622         segs[i].c[j] = *INT2PTR(i_fcolor *, SvIV((SV *)SvRV(*sv3)));
 623       }
 624       else {
 625         i_color c = *INT2PTR(i_color *, SvIV((SV *)SvRV(*sv3)));
 626         int ch;
 627         for (ch = 0; ch < MAXCHANNELS; ++ch) {
 628           segs[i].c[j].channel[ch] = c.channel[ch] / 255.0;
 629         }
 630       }
 631     }
 632     for (j = 0; j < 2; ++j) {
 633       SV **sv2 = av_fetch(aseg, j+5, 0);
 634       if (!sv2 || !*sv2) {
 635         myfree(segs);
 636         croak("i_fountain: XS error");
 637       }
 638       worki[j] = SvIV(*sv2);
 639     }
 640     segs[i].type = worki[0];
 641     segs[i].color = worki[1];
 642   }
 643
 644   return segs;
 645 }
 646
 647 /* validates the indexes supplied to i_ppal
 648
 649 i_ppal() doesn't do that for speed, but I'm not comfortable doing that
 650 for calls from perl.
 651
 652 */
 653 static void
 654 validate_i_ppal(i_img *im, i_palidx const *indexes, int count) {
 655   int color_count = i_colorcount(im);
 656   int i;
 657
 658   if (color_count == -1)
 659     croak("i_plin() called on direct color image");
 660
 661   for (i = 0; i < count; ++i) {
 662     if (indexes[i] >= color_count) {
 663       croak("i_plin() called with out of range color index %d (max %d)",
 664         indexes[i], color_count-1);
 665     }
 666   }
 667 }
 668
 669
 670 /* I don't think ICLF_* names belong at the C interface
 671    this makes the XS code think we have them, to let us avoid
 672    putting function bodies in the XS code
 673 */
 674 #define ICLF_new_internal(r, g, b, a) i_fcolor_new((r), (g), (b), (a))
 675 #define ICLF_DESTROY(cl) i_fcolor_destroy(cl)
 676
 677 #ifdef IMAGER_LOG
 678 #define i_log_enabled() 1
 679 #else
 680 #define i_log_enabled() 0
 681 #endif
 682
 683 #if i_int_hlines_testing()
 684
 685 typedef i_int_hlines *Imager__Internal__Hlines;
 686
 687 static i_int_hlines *
 688 i_int_hlines_new(i_img_dim start_y, i_img_dim count_y, i_img_dim start_x, i_img_dim count_x) {
 689   i_int_hlines *result = mymalloc(sizeof(i_int_hlines));
 690   i_int_init_hlines(result, start_y, count_y, start_x, count_x);
 691
 692   return result;
 693 }
 694
 695 static i_int_hlines *
 696 i_int_hlines_new_img(i_img *im) {
 697   i_int_hlines *result = mymalloc(sizeof(i_int_hlines));
 698   i_int_init_hlines_img(result, im);
 699
 700   return result;
 701 }
 702
 703 static void
 704 i_int_hlines_DESTROY(i_int_hlines *hlines) {
 705   i_int_hlines_destroy(hlines);
 706   myfree(hlines);
 707 }
 708
 709 #define i_int_hlines_CLONE_SKIP(cls) 1
 710
 711 static int seg_compare(const void *vleft, const void *vright) {
 712   const i_int_hline_seg *left = vleft;
 713   const i_int_hline_seg *right = vright;
 714
 715   return left->minx - right->minx;
 716 }
 717
 718 static SV *
 719 i_int_hlines_dump(i_int_hlines *hlines) {
 720   dTHX;
 721   SV *dump = newSVpvf("start_y: %" i_DF " limit_y: %" i_DF " start_x: %" i_DF " limit_x: %" i_DF"\n",
 722         i_DFc(hlines->start_y), i_DFc(hlines->limit_y), i_DFc(hlines->start_x), i_DFc(hlines->limit_x));
 723   i_img_dim y;
 724
 725   for (y = hlines->start_y; y < hlines->limit_y; ++y) {
 726     i_int_hline_entry *entry = hlines->entries[y-hlines->start_y];
 727     if (entry) {
 728       int i;
 729       /* sort the segments, if any */
 730       if (entry->count)
 731         qsort(entry->segs, entry->count, sizeof(i_int_hline_seg), seg_compare);
 732
 733       sv_catpvf(dump, " %" i_DF " (%" i_DF "):", i_DFc(y), i_DFc(entry->count));
 734       for (i = 0; i < entry->count; ++i) {
 735         sv_catpvf(dump, " [%" i_DF ", %" i_DF ")", i_DFc(entry->segs[i].minx),
 736                   i_DFc(entry->segs[i].x_limit));
 737       }
 738       sv_catpv(dump, "\n");
 739     }
 740   }
 741
 742   return dump;
 743 }
 744
 745 #endif
 746
 747 static off_t
 748 i_sv_off_t(pTHX_ SV *sv) {
 749 #if LSEEKSIZE > IVSIZE
 750   return (off_t)SvNV(sv);
 751 #else
 752   return (off_t)SvIV(sv);
 753 #endif
 754 }
 755
 756 static SV *
 757 i_new_sv_off_t(pTHX_ off_t off) {
 758 #if LSEEKSIZE > IVSIZE
 759   return newSVnv(off);
 760 #else
 761   return newSViv(off);
 762 #endif
 763 }
 764
 765 static im_pl_ext_funcs im_perl_funcs =
 766 {
 767   IMAGER_PL_API_VERSION,
 768   IMAGER_PL_API_LEVEL,
 769   ip_handle_quant_opts,
 770   ip_cleanup_quant_opts,
 771   ip_copy_colors_back
 772 };
 773
 774 #define PERL_PL_SET_GLOBAL_CALLBACKS \
 775   sv_setiv(get_sv(PERL_PL_FUNCTION_TABLE_NAME, 1), PTR2IV(&im_perl_funcs));
 776
 777 #ifdef IMEXIF_ENABLE
 778 #define i_exif_enabled() 1
 779 #else
 780 #define i_exif_enabled() 0
 781 #endif
 782
 783 /* trying to use more C style names, map them here */
 784 #define i_io_DESTROY(ig) io_glue_destroy(ig)
 785
 786 #define i_img_get_width(im) ((im)->xsize)
 787 #define i_img_get_height(im) ((im)->ysize)
 788
 789 #define i_img_epsilonf() (DBL_EPSILON * 4)
 790
 791 /* avoid some xsubpp strangeness */
 792 #define NEWLINE '\n'
 793
 794 MODULE = Imager         PACKAGE = Imager::Color PREFIX = ICL_
 795
 796 Imager::Color
 797 ICL_new_internal(r,g,b,a)
 798                unsigned char     r
 799                unsigned char     g
 800                unsigned char     b
 801                unsigned char     a
 802
 803 void
 804 ICL_DESTROY(cl)
 805                Imager::Color    cl
 806
 807
 808 void
 809 ICL_set_internal(cl,r,g,b,a)
 810                Imager::Color    cl
 811                unsigned char     r
 812                unsigned char     g
 813                unsigned char     b
 814                unsigned char     a
 815            PPCODE:
 816                ICL_set_internal(cl, r, g, b, a);
 817                EXTEND(SP, 1);
 818                PUSHs(ST(0));
 819
 820 void
 821 ICL_info(cl)
 822                Imager::Color    cl
 823
 824
 825 void
 826 ICL_rgba(cl)
 827               Imager::Color     cl
 828             PPCODE:
 829                 EXTEND(SP, 4);
 830                 PUSHs(sv_2mortal(newSVnv(cl->rgba.r)));
 831                 PUSHs(sv_2mortal(newSVnv(cl->rgba.g)));
 832                 PUSHs(sv_2mortal(newSVnv(cl->rgba.b)));
 833                 PUSHs(sv_2mortal(newSVnv(cl->rgba.a)));
 834
 835 Imager::Color
 836 i_hsv_to_rgb(c)
 837         Imager::Color c
 838       CODE:
 839         RETVAL = mymalloc(sizeof(i_color));
 840         *RETVAL = *c;
 841         i_hsv_to_rgb(RETVAL);
 842       OUTPUT:
 843         RETVAL
 844
 845 Imager::Color
 846 i_rgb_to_hsv(c)
 847         Imager::Color c
 848       CODE:
 849         RETVAL = mymalloc(sizeof(i_color));
 850         *RETVAL = *c;
 851         i_rgb_to_hsv(RETVAL);
 852       OUTPUT:
 853         RETVAL
 854
 855
 856
 857 MODULE = Imager        PACKAGE = Imager::Color::Float  PREFIX=ICLF_
 858
 859 Imager::Color::Float
 860 ICLF_new_internal(r, g, b, a)
 861         double r
 862         double g
 863         double b
 864         double a
 865
 866 void
 867 ICLF_DESTROY(cl)
 868         Imager::Color::Float    cl
 869
 870 void
 871 ICLF_rgba(cl)
 872         Imager::Color::Float    cl
 873       PREINIT:
 874         int ch;
 875       PPCODE:
 876         EXTEND(SP, MAXCHANNELS);
 877         for (ch = 0; ch < MAXCHANNELS; ++ch) {
 878         /* printf("%d: %g\n", ch, cl->channel[ch]); */
 879           PUSHs(sv_2mortal(newSVnv(cl->channel[ch])));
 880         }
 881
 882 void
 883 ICLF_set_internal(cl,r,g,b,a)
 884         Imager::Color::Float    cl
 885         double     r
 886         double     g
 887         double     b
 888         double     a
 889       PPCODE:
 890         cl->rgba.r = r;
 891         cl->rgba.g = g;
 892         cl->rgba.b = b;
 893         cl->rgba.a = a;
 894         EXTEND(SP, 1);
 895         PUSHs(ST(0));
 896
 897 Imager::Color::Float
 898 i_hsv_to_rgb(c)
 899         Imager::Color::Float c
 900       CODE:
 901         RETVAL = mymalloc(sizeof(i_fcolor));
 902         *RETVAL = *c;
 903         i_hsv_to_rgbf(RETVAL);
 904       OUTPUT:
 905         RETVAL
 906
 907 Imager::Color::Float
 908 i_rgb_to_hsv(c)
 909         Imager::Color::Float c
 910       CODE:
 911         RETVAL = mymalloc(sizeof(i_fcolor));
 912         *RETVAL = *c;
 913         i_rgb_to_hsvf(RETVAL);
 914       OUTPUT:
 915         RETVAL
 916
 917 MODULE = Imager         PACKAGE = Imager::ImgRaw        PREFIX = IIM_
 918
 919 Imager::ImgRaw
 920 IIM_new(x,y,ch)
 921                i_img_dim     x
 922                i_img_dim     y
 923                int     ch
 924
 925 void
 926 IIM_DESTROY(im)
 927                Imager::ImgRaw    im
 928
 929
 930
 931 MODULE = Imager         PACKAGE = Imager
 932
 933 PROTOTYPES: ENABLE
 934
 935
 936 Imager::IO
 937 io_new_fd(fd)
 938                          int     fd
 939
 940 Imager::IO
 941 io_new_bufchain()
 942
 943
 944 Imager::IO
 945 io_new_buffer(data_sv)
 946           SV   *data_sv
 947         CODE:
 948           RETVAL = do_io_new_buffer(aTHX_ data_sv);
 949         OUTPUT:
 950           RETVAL
 951
 952 Imager::IO
 953 io_new_cb(writecb, readcb, seekcb, closecb, maxwrite = CBDATA_BUFSIZE)
 954         SV *writecb;
 955         SV *readcb;
 956         SV *seekcb;
 957         SV *closecb;
 958         int maxwrite;
 959       CODE:
 960         RETVAL = do_io_new_cb(aTHX_ writecb, readcb, seekcb, closecb);
 961       OUTPUT:
 962         RETVAL
 963
 964 SV *
 965 io_slurp(ig)
 966         Imager::IO     ig
 967              PREINIT:
 968               unsigned char*    data;
 969               size_t    tlength;
 970              CODE:
 971               data    = NULL;
 972               tlength = io_slurp(ig, &data);
 973               RETVAL = newSVpv((char *)data,tlength);
 974               myfree(data);
 975              OUTPUT:
 976               RETVAL
 977
 978
 979 undef_int
 980 i_set_image_file_limits(width, height, bytes)
 981         i_img_dim width
 982         i_img_dim height
 983         size_t bytes
 984
 985 void
 986 i_get_image_file_limits()
 987       PREINIT:
 988         i_img_dim width, height;
 989         size_t bytes;
 990       PPCODE:
 991         if (i_get_image_file_limits(&width, &height, &bytes)) {
 992           EXTEND(SP, 3);
 993           PUSHs(sv_2mortal(newSViv(width)));
 994           PUSHs(sv_2mortal(newSViv(height)));
 995           PUSHs(sv_2mortal(newSVuv(bytes)));
 996         }
 997
 998 MODULE = Imager         PACKAGE = Imager::IO    PREFIX = io_
 999
1000 Imager::IO
1001 io_new_fd(class, fd)
1002         int fd
1003     CODE:
1004         RETVAL = io_new_fd(fd);
1005     OUTPUT:
1006         RETVAL
1007
1008 Imager::IO
1009 io_new_buffer(class, data_sv)
1010         SV *data_sv
1011     CODE:
1012         RETVAL = do_io_new_buffer(aTHX_ data_sv);
1013     OUTPUT:
1014         RETVAL
1015
1016 Imager::IO
1017 io_new_cb(class, writecb, readcb, seekcb, closecb)
1018         SV *writecb;
1019         SV *readcb;
1020         SV *seekcb;
1021         SV *closecb;
1022     CODE:
1023         RETVAL = do_io_new_cb(aTHX_ writecb, readcb, seekcb, closecb);
1024     OUTPUT:
1025         RETVAL
1026
1027 Imager::IO
1028 io_new_bufchain(class)
1029     CODE:
1030         RETVAL = io_new_bufchain();
1031     OUTPUT:
1032         RETVAL
1033
1034 SV *
1035 io_slurp(class, ig)
1036         Imager::IO     ig
1037     PREINIT:
1038         unsigned char*    data;
1039         size_t    tlength;
1040     CODE:
1041         data    = NULL;
1042         tlength = io_slurp(ig, &data);
1043         RETVAL = newSVpv((char *)data,tlength);
1044         myfree(data);
1045     OUTPUT:
1046         RETVAL
1047
1048 MODULE = Imager         PACKAGE = Imager::IO    PREFIX = i_io_
1049
1050 IV
1051 i_io_raw_write(ig, data_sv)
1052         Imager::IO ig
1053         SV *data_sv
1054       PREINIT:
1055         void *data;
1056         STRLEN size;
1057       CODE:
1058 #ifdef SvUTF8
1059         if (SvUTF8(data_sv)) {
1060           data_sv = sv_2mortal(newSVsv(data_sv));
1061           /* yes, we want this to croak() if the SV can't be downgraded */
1062           sv_utf8_downgrade(data_sv, FALSE);
1063         }
1064 #endif
1065         data = SvPV(data_sv, size);
1066         RETVAL = i_io_raw_write(ig, data, size);
1067       OUTPUT:
1068         RETVAL
1069
1070 void
1071 i_io_raw_read(ig, buffer_sv, size)
1072         Imager::IO ig
1073         SV *buffer_sv
1074         IV size
1075       PREINIT:
1076         void *buffer;
1077         ssize_t result;
1078       PPCODE:
1079         if (size <= 0)
1080           croak("size negative in call to i_io_raw_read()");
1081         /* prevent an undefined value warning if they supplied an
1082            undef buffer.
1083            Orginally conditional on !SvOK(), but this will prevent the
1084            downgrade from croaking */
1085         sv_setpvn(buffer_sv, "", 0);
1086 #ifdef SvUTF8
1087         if (SvUTF8(buffer_sv))
1088           sv_utf8_downgrade(buffer_sv, FALSE);
1089 #endif
1090         buffer = SvGROW(buffer_sv, size+1);
1091         result = i_io_raw_read(ig, buffer, size);
1092         if (result >= 0) {
1093           SvCUR_set(buffer_sv, result);
1094           *SvEND(buffer_sv) = '\0';
1095           SvPOK_only(buffer_sv);
1096           EXTEND(SP, 1);
1097           PUSHs(sv_2mortal(newSViv(result)));
1098         }
1099         ST(1) = buffer_sv;
1100         SvSETMAGIC(ST(1));
1101
1102 void
1103 i_io_raw_read2(ig, size)
1104         Imager::IO ig
1105         IV size
1106       PREINIT:
1107         SV *buffer_sv;
1108         void *buffer;
1109         ssize_t result;
1110       PPCODE:
1111         if (size <= 0)
1112           croak("size negative in call to i_io_read2()");
1113         buffer_sv = newSV(size);
1114         buffer = SvGROW(buffer_sv, size+1);
1115         result = i_io_raw_read(ig, buffer, size);
1116         if (result >= 0) {
1117           SvCUR_set(buffer_sv, result);
1118           *SvEND(buffer_sv) = '\0';
1119           SvPOK_only(buffer_sv);
1120           EXTEND(SP, 1);
1121           PUSHs(sv_2mortal(buffer_sv));
1122         }
1123         else {
1124           /* discard it */
1125           SvREFCNT_dec(buffer_sv);
1126         }
1127
1128 off_t
1129 i_io_raw_seek(ig, position, whence)
1130         Imager::IO ig
1131         off_t position
1132         int whence
1133
1134 int
1135 i_io_raw_close(ig)
1136         Imager::IO ig
1137
1138 void
1139 i_io_DESTROY(ig)
1140         Imager::IO     ig
1141
1142 int
1143 i_io_CLONE_SKIP(...)
1144     CODE:
1145         (void)items; /* avoid unused warning for XS variable */
1146         RETVAL = 1;
1147     OUTPUT:
1148         RETVAL
1149
1150 int
1151 i_io_getc(ig)
1152         Imager::IO ig
1153
1154 int
1155 i_io_putc(ig, c)
1156         Imager::IO ig
1157         int c
1158
1159 int
1160 i_io_close(ig)
1161         Imager::IO ig
1162
1163 int
1164 i_io_flush(ig)
1165         Imager::IO ig
1166
1167 int
1168 i_io_peekc(ig)
1169         Imager::IO ig
1170
1171 int
1172 i_io_seek(ig, off, whence)
1173         Imager::IO ig
1174         off_t off
1175         int whence
1176
1177 void
1178 i_io_peekn(ig, size)
1179         Imager::IO ig
1180         STRLEN size
1181       PREINIT:
1182         SV *buffer_sv;
1183         void *buffer;
1184         ssize_t result;
1185       PPCODE:
1186         buffer_sv = newSV(size+1);
1187         buffer = SvGROW(buffer_sv, size+1);
1188         result = i_io_peekn(ig, buffer, size);
1189         if (result >= 0) {
1190           SvCUR_set(buffer_sv, result);
1191           *SvEND(buffer_sv) = '\0';
1192           SvPOK_only(buffer_sv);
1193           EXTEND(SP, 1);
1194           PUSHs(sv_2mortal(buffer_sv));
1195         }
1196         else {
1197           /* discard it */
1198           SvREFCNT_dec(buffer_sv);
1199         }
1200
1201 void
1202 i_io_read(ig, buffer_sv, size)
1203         Imager::IO ig
1204         SV *buffer_sv
1205         IV size
1206       PREINIT:
1207         void *buffer;
1208         ssize_t result;
1209       PPCODE:
1210         if (size <= 0)
1211           croak("size negative in call to i_io_read()");
1212         /* prevent an undefined value warning if they supplied an
1213            undef buffer.
1214            Orginally conditional on !SvOK(), but this will prevent the
1215            downgrade from croaking */
1216         sv_setpvn(buffer_sv, "", 0);
1217 #ifdef SvUTF8
1218         if (SvUTF8(buffer_sv))
1219           sv_utf8_downgrade(buffer_sv, FALSE);
1220 #endif
1221         buffer = SvGROW(buffer_sv, size+1);
1222         result = i_io_read(ig, buffer, size);
1223         if (result >= 0) {
1224           SvCUR_set(buffer_sv, result);
1225           *SvEND(buffer_sv) = '\0';
1226           SvPOK_only(buffer_sv);
1227           EXTEND(SP, 1);
1228           PUSHs(sv_2mortal(newSViv(result)));
1229         }
1230         ST(1) = buffer_sv;
1231         SvSETMAGIC(ST(1));
1232
1233 void
1234 i_io_read2(ig, size)
1235         Imager::IO ig
1236         STRLEN size
1237       PREINIT:
1238         SV *buffer_sv;
1239         void *buffer;
1240         ssize_t result;
1241       PPCODE:
1242         if (size == 0)
1243           croak("size zero in call to read2()");
1244         buffer_sv = newSV(size);
1245         buffer = SvGROW(buffer_sv, size+1);
1246         result = i_io_read(ig, buffer, size);
1247         if (result > 0) {
1248           SvCUR_set(buffer_sv, result);
1249           *SvEND(buffer_sv) = '\0';
1250           SvPOK_only(buffer_sv);
1251           EXTEND(SP, 1);
1252           PUSHs(sv_2mortal(buffer_sv));
1253         }
1254         else {
1255           /* discard it */
1256           SvREFCNT_dec(buffer_sv);
1257         }
1258
1259 void
1260 i_io_gets(ig, size = 8192, eol = NEWLINE)
1261         Imager::IO ig
1262         STRLEN size
1263         int eol
1264       PREINIT:
1265         SV *buffer_sv;
1266         void *buffer;
1267         ssize_t result;
1268       PPCODE:
1269         if (size < 2)
1270           croak("size too small in call to gets()");
1271         buffer_sv = sv_2mortal(newSV(size+1));
1272         buffer = SvPVX(buffer_sv);
1273         result = i_io_gets(ig, buffer, size+1, eol);
1274         if (result > 0) {
1275           SvCUR_set(buffer_sv, result);
1276           *SvEND(buffer_sv) = '\0';
1277           SvPOK_only(buffer_sv);
1278           EXTEND(SP, 1);
1279           PUSHs(buffer_sv);
1280         }
1281
1282 IV
1283 i_io_write(ig, data_sv)
1284         Imager::IO ig
1285         SV *data_sv
1286       PREINIT:
1287         void *data;
1288         STRLEN size;
1289       CODE:
1290 #ifdef SvUTF8
1291         if (SvUTF8(data_sv)) {
1292           data_sv = sv_2mortal(newSVsv(data_sv));
1293           /* yes, we want this to croak() if the SV can't be downgraded */
1294           sv_utf8_downgrade(data_sv, FALSE);
1295         }
1296 #endif
1297         data = SvPV(data_sv, size);
1298         RETVAL = i_io_write(ig, data, size);
1299       OUTPUT:
1300         RETVAL
1301
1302 void
1303 i_io_dump(ig, flags = I_IO_DUMP_DEFAULT)
1304         Imager::IO ig
1305         int flags
1306
1307 bool
1308 i_io_set_buffered(ig, flag = 1)
1309         Imager::IO ig
1310         int flag
1311
1312 bool
1313 i_io_is_buffered(ig)
1314         Imager::IO ig
1315
1316 bool
1317 i_io_eof(ig)
1318         Imager::IO ig
1319
1320 bool
1321 i_io_error(ig)
1322         Imager::IO ig
1323
1324 MODULE = Imager         PACKAGE = Imager
1325
1326 PROTOTYPES: ENABLE
1327
1328 void
1329 i_list_formats()
1330              PREINIT:
1331               char*    item;
1332                int     i;
1333              PPCODE:
1334                i=0;
1335                while( (item=i_format_list[i++]) != NULL ) {
1336                       EXTEND(SP, 1);
1337                       PUSHs(sv_2mortal(newSVpv(item,0)));
1338                }
1339
1340 Imager::ImgRaw
1341 i_img_new()
1342
1343 Imager::ImgRaw
1344 i_img_empty(im,x,y)
1345     Imager::ImgRaw     im
1346                i_img_dim     x
1347                i_img_dim     y
1348
1349 Imager::ImgRaw
1350 i_img_empty_ch(im,x,y,ch)
1351     Imager::ImgRaw     im
1352                i_img_dim     x
1353                i_img_dim     y
1354                int     ch
1355
1356 Imager::ImgRaw
1357 i_sametype(im, x, y)
1358     Imager::ImgRaw im
1359                i_img_dim x
1360                i_img_dim y
1361
1362 Imager::ImgRaw
1363 i_sametype_chans(im, x, y, channels)
1364     Imager::ImgRaw im
1365                i_img_dim x
1366                i_img_dim y
1367                int channels
1368
1369 int
1370 i_init_log(name_sv,level)
1371               SV*    name_sv
1372                int     level
1373         PREINIT:
1374           const char *name = SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
1375         CODE:
1376           RETVAL = i_init_log(name, level);
1377         OUTPUT:
1378           RETVAL
1379
1380 void
1381 i_log_entry(string,level)
1382               char*    string
1383                int     level
1384
1385 int
1386 i_log_enabled()
1387
1388 void
1389 i_img_exorcise(im)
1390     Imager::ImgRaw     im
1391
1392 void
1393 i_img_destroy(im)
1394     Imager::ImgRaw     im
1395
1396 void
1397 i_img_info(im)
1398     Imager::ImgRaw     im
1399              PREINIT:
1400                i_img_dim     info[4];
1401              PPCODE:
1402                i_img_info(im,info);
1403                EXTEND(SP, 4);
1404                PUSHs(sv_2mortal(newSViv(info[0])));
1405                PUSHs(sv_2mortal(newSViv(info[1])));
1406                PUSHs(sv_2mortal(newSViv(info[2])));
1407                PUSHs(sv_2mortal(newSViv(info[3])));
1408
1409
1410
1411
1412 void
1413 i_img_setmask(im,ch_mask)
1414     Imager::ImgRaw     im
1415                int     ch_mask
1416
1417 int
1418 i_img_getmask(im)
1419     Imager::ImgRaw     im
1420
1421 int
1422 i_img_getchannels(im)
1423     Imager::ImgRaw     im
1424
1425 void
1426 i_img_getdata(im)
1427     Imager::ImgRaw     im
1428              PPCODE:
1429                EXTEND(SP, 1);
1430                PUSHs(im->idata ?
1431                      sv_2mortal(newSVpv((char *)im->idata, im->bytes))
1432                      : &PL_sv_undef);
1433
1434 IV
1435 i_img_get_width(im)
1436     Imager::ImgRaw      im
1437
1438 IV
1439 i_img_get_height(im)
1440     Imager::ImgRaw      im
1441
1442
1443 void
1444 i_img_is_monochrome(im)
1445         Imager::ImgRaw im
1446       PREINIT:
1447         int zero_is_white;
1448         int result;
1449       PPCODE:
1450         result = i_img_is_monochrome(im, &zero_is_white);
1451         if (result) {
1452           if (GIMME_V == G_ARRAY) {
1453             EXTEND(SP, 2);
1454             PUSHs(&PL_sv_yes);
1455             PUSHs(sv_2mortal(newSViv(zero_is_white)));
1456           }
1457           else {
1458             EXTEND(SP, 1);
1459             PUSHs(&PL_sv_yes);
1460           }
1461         }
1462
1463 void
1464 i_line(im,x1,y1,x2,y2,val,endp)
1465     Imager::ImgRaw     im
1466                i_img_dim     x1
1467                i_img_dim     y1
1468                i_img_dim     x2
1469                i_img_dim     y2
1470      Imager::Color     val
1471                int     endp
1472
1473 void
1474 i_line_aa(im,x1,y1,x2,y2,val,endp)
1475     Imager::ImgRaw     im
1476                i_img_dim     x1
1477                i_img_dim     y1
1478                i_img_dim     x2
1479                i_img_dim     y2
1480      Imager::Color     val
1481                int     endp
1482
1483 void
1484 i_box(im,x1,y1,x2,y2,val)
1485     Imager::ImgRaw     im
1486                i_img_dim     x1
1487                i_img_dim     y1
1488                i_img_dim     x2
1489                i_img_dim     y2
1490      Imager::Color     val
1491
1492 void
1493 i_box_filled(im,x1,y1,x2,y2,val)
1494     Imager::ImgRaw     im
1495                i_img_dim     x1
1496                i_img_dim     y1
1497                i_img_dim     x2
1498                i_img_dim     y2
1499            Imager::Color    val
1500
1501 int
1502 i_box_filledf(im,x1,y1,x2,y2,val)
1503     Imager::ImgRaw     im
1504                i_img_dim     x1
1505                i_img_dim     y1
1506                i_img_dim     x2
1507                i_img_dim     y2
1508            Imager::Color::Float    val
1509
1510 void
1511 i_box_cfill(im,x1,y1,x2,y2,fill)
1512     Imager::ImgRaw     im
1513                i_img_dim     x1
1514                i_img_dim     y1
1515                i_img_dim     x2
1516                i_img_dim     y2
1517            Imager::FillHandle    fill
1518
1519 void
1520 i_arc(im,x,y,rad,d1,d2,val)
1521     Imager::ImgRaw     im
1522                i_img_dim     x
1523                i_img_dim     y
1524              double     rad
1525              double     d1
1526              double     d2
1527            Imager::Color    val
1528
1529 void
1530 i_arc_aa(im,x,y,rad,d1,d2,val)
1531     Imager::ImgRaw     im
1532             double     x
1533             double     y
1534             double     rad
1535             double     d1
1536             double     d2
1537            Imager::Color    val
1538
1539 void
1540 i_arc_cfill(im,x,y,rad,d1,d2,fill)
1541     Imager::ImgRaw     im
1542                i_img_dim     x
1543                i_img_dim     y
1544              double     rad
1545              double     d1
1546              double     d2
1547            Imager::FillHandle    fill
1548
1549 void
1550 i_arc_aa_cfill(im,x,y,rad,d1,d2,fill)
1551     Imager::ImgRaw     im
1552             double     x
1553             double     y
1554             double     rad
1555             double     d1
1556             double     d2
1557            Imager::FillHandle   fill
1558
1559
1560 void
1561 i_circle_aa(im,x,y,rad,val)
1562     Imager::ImgRaw     im
1563              double     x
1564              double     y
1565              double     rad
1566            Imager::Color    val
1567
1568 int
1569 i_circle_out(im,x,y,rad,val)
1570     Imager::ImgRaw     im
1571              i_img_dim     x
1572              i_img_dim     y
1573              i_img_dim     rad
1574            Imager::Color    val
1575
1576 int
1577 i_circle_out_aa(im,x,y,rad,val)
1578     Imager::ImgRaw     im
1579              i_img_dim     x
1580              i_img_dim     y
1581              i_img_dim     rad
1582            Imager::Color    val
1583
1584 int
1585 i_arc_out(im,x,y,rad,d1,d2,val)
1586     Imager::ImgRaw     im
1587              i_img_dim     x
1588              i_img_dim     y
1589              i_img_dim     rad
1590              double d1
1591              double d2
1592            Imager::Color    val
1593
1594 int
1595 i_arc_out_aa(im,x,y,rad,d1,d2,val)
1596     Imager::ImgRaw     im
1597              i_img_dim     x
1598              i_img_dim     y
1599              i_img_dim     rad
1600              double d1
1601              double d2
1602            Imager::Color    val
1603
1604
1605 void
1606 i_bezier_multi(im,xc,yc,val)
1607     Imager::ImgRaw     im
1608              Imager::Color  val
1609              PREINIT:
1610              double   *x,*y;
1611              int       len;
1612              AV       *av1;
1613              AV       *av2;
1614              SV       *sv1;
1615              SV       *sv2;
1616              int i;
1617              PPCODE:
1618              ICL_info(val);
1619              if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
1620              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
1621              if (!SvROK(ST(2))) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
1622              if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
1623              av1=(AV*)SvRV(ST(1));
1624              av2=(AV*)SvRV(ST(2));
1625              if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_bezier_multi must be equal length\n");
1626              len=av_len(av1)+1;
1627              x=mymalloc( len*sizeof(double) );
1628              y=mymalloc( len*sizeof(double) );
1629              for(i=0;i<len;i++) {
1630                sv1=(*(av_fetch(av1,i,0)));
1631                sv2=(*(av_fetch(av2,i,0)));
1632                x[i]=(double)SvNV(sv1);
1633                y[i]=(double)SvNV(sv2);
1634              }
1635              i_bezier_multi(im,len,x,y,val);
1636              myfree(x);
1637              myfree(y);
1638
1639
1640 int
1641 i_poly_aa(im,xc,yc,val)
1642     Imager::ImgRaw     im
1643              Imager::Color  val
1644              PREINIT:
1645              double   *x,*y;
1646              int       len;
1647              AV       *av1;
1648              AV       *av2;
1649              SV       *sv1;
1650              SV       *sv2;
1651              int i;
1652              CODE:
1653              ICL_info(val);
1654              if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
1655              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
1656              if (!SvROK(ST(2))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
1657              if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
1658              av1=(AV*)SvRV(ST(1));
1659              av2=(AV*)SvRV(ST(2));
1660              if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_poly_aa must be equal length\n");
1661              len=av_len(av1)+1;
1662              x=mymalloc( len*sizeof(double) );
1663              y=mymalloc( len*sizeof(double) );
1664              for(i=0;i<len;i++) {
1665                sv1=(*(av_fetch(av1,i,0)));
1666                sv2=(*(av_fetch(av2,i,0)));
1667                x[i]=(double)SvNV(sv1);
1668                y[i]=(double)SvNV(sv2);
1669              }
1670              RETVAL = i_poly_aa(im,len,x,y,val);
1671              myfree(x);
1672              myfree(y);
1673              OUTPUT:
1674                RETVAL
1675
1676 int
1677 i_poly_aa_cfill(im,xc,yc,fill)
1678     Imager::ImgRaw     im
1679      Imager::FillHandle     fill
1680              PREINIT:
1681              double   *x,*y;
1682              int       len;
1683              AV       *av1;
1684              AV       *av2;
1685              SV       *sv1;
1686              SV       *sv2;
1687              int i;
1688              CODE:
1689              if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
1690              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
1691              if (!SvROK(ST(2))) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
1692              if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
1693              av1=(AV*)SvRV(ST(1));
1694              av2=(AV*)SvRV(ST(2));
1695              if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_poly_aa_cfill must be equal length\n");
1696              len=av_len(av1)+1;
1697              x=mymalloc( len*sizeof(double) );
1698              y=mymalloc( len*sizeof(double) );
1699              for(i=0;i<len;i++) {
1700                sv1=(*(av_fetch(av1,i,0)));
1701                sv2=(*(av_fetch(av2,i,0)));
1702                x[i]=(double)SvNV(sv1);
1703                y[i]=(double)SvNV(sv2);
1704              }
1705              RETVAL = i_poly_aa_cfill(im,len,x,y,fill);
1706              myfree(x);
1707              myfree(y);
1708              OUTPUT:
1709                RETVAL
1710
1711
1712
1713 undef_int
1714 i_flood_fill(im,seedx,seedy,dcol)
1715     Imager::ImgRaw     im
1716                i_img_dim     seedx
1717                i_img_dim     seedy
1718      Imager::Color     dcol
1719
1720 undef_int
1721 i_flood_cfill(im,seedx,seedy,fill)
1722     Imager::ImgRaw     im
1723                i_img_dim     seedx
1724                i_img_dim     seedy
1725      Imager::FillHandle     fill
1726
1727 undef_int
1728 i_flood_fill_border(im,seedx,seedy,dcol, border)
1729     Imager::ImgRaw     im
1730                i_img_dim     seedx
1731                i_img_dim     seedy
1732      Imager::Color     dcol
1733      Imager::Color     border
1734
1735 undef_int
1736 i_flood_cfill_border(im,seedx,seedy,fill, border)
1737     Imager::ImgRaw     im
1738                i_img_dim     seedx
1739                i_img_dim     seedy
1740      Imager::FillHandle     fill
1741      Imager::Color     border
1742
1743
1744 void
1745 i_copyto(im,src,x1,y1,x2,y2,tx,ty)
1746     Imager::ImgRaw     im
1747     Imager::ImgRaw     src
1748                i_img_dim     x1
1749                i_img_dim     y1
1750                i_img_dim     x2
1751                i_img_dim     y2
1752                i_img_dim     tx
1753                i_img_dim     ty
1754
1755
1756 void
1757 i_copyto_trans(im,src,x1,y1,x2,y2,tx,ty,trans)
1758     Imager::ImgRaw     im
1759     Imager::ImgRaw     src
1760                i_img_dim     x1
1761                i_img_dim     y1
1762                i_img_dim     x2
1763                i_img_dim     y2
1764                i_img_dim     tx
1765                i_img_dim     ty
1766      Imager::Color     trans
1767
1768 Imager::ImgRaw
1769 i_copy(src)
1770     Imager::ImgRaw     src
1771
1772
1773 undef_int
1774 i_rubthru(im,src,tx,ty,src_minx,src_miny,src_maxx,src_maxy)
1775     Imager::ImgRaw     im
1776     Imager::ImgRaw     src
1777                i_img_dim     tx
1778                i_img_dim     ty
1779                i_img_dim     src_minx
1780                i_img_dim     src_miny
1781                i_img_dim     src_maxx
1782                i_img_dim     src_maxy
1783
1784 undef_int
1785 i_compose(out, src, out_left, out_top, src_left, src_top, width, height, combine = ic_normal, opacity = 0.0)
1786     Imager::ImgRaw out
1787     Imager::ImgRaw src
1788         i_img_dim out_left
1789         i_img_dim out_top
1790         i_img_dim src_left
1791         i_img_dim src_top
1792         i_img_dim width
1793         i_img_dim height
1794         int combine
1795         double opacity
1796
1797 undef_int
1798 i_compose_mask(out, src, mask, out_left, out_top, src_left, src_top, mask_left, mask_top, width, height, combine = ic_normal, opacity = 0.0)
1799     Imager::ImgRaw out
1800     Imager::ImgRaw src
1801     Imager::ImgRaw mask
1802         i_img_dim out_left
1803         i_img_dim out_top
1804         i_img_dim src_left
1805         i_img_dim src_top
1806         i_img_dim mask_left
1807         i_img_dim mask_top
1808         i_img_dim width
1809         i_img_dim height
1810         int combine
1811         double opacity
1812
1813 Imager::ImgRaw
1814 i_combine(src_av, channels_av = NULL)
1815         AV *src_av
1816         AV *channels_av
1817   PREINIT:
1818         i_img **imgs = NULL;
1819         STRLEN in_count;
1820         int *channels = NULL;
1821         int i;
1822         SV **psv;
1823         IV tmp;
1824   CODE:
1825         in_count = av_len(src_av) + 1;
1826         if (in_count > 0) {
1827           imgs = mymalloc(sizeof(i_img*) * in_count);
1828           channels = mymalloc(sizeof(int) * in_count);
1829           for (i = 0; i < in_count; ++i) {
1830             psv = av_fetch(src_av, i, 0);
1831             if (!psv || !*psv || !sv_derived_from(*psv, "Imager::ImgRaw")) {
1832               myfree(imgs);
1833               myfree(channels);
1834               croak("imgs must contain only images");
1835             }
1836             tmp = SvIV((SV*)SvRV(*psv));
1837             imgs[i] = INT2PTR(i_img*, tmp);
1838             if (channels_av &&
1839                 (psv = av_fetch(channels_av, i, 0)) != NULL &&
1840                 *psv) {
1841               channels[i] = SvIV(*psv);
1842             }
1843             else {
1844               channels[i] = 0;
1845             }
1846           }
1847         }
1848         RETVAL = i_combine(imgs, channels, in_count);
1849         myfree(imgs);
1850         myfree(channels);
1851   OUTPUT:
1852         RETVAL
1853
1854 undef_int
1855 i_flipxy(im, direction)
1856     Imager::ImgRaw     im
1857                int     direction
1858
1859 Imager::ImgRaw
1860 i_rotate90(im, degrees)
1861     Imager::ImgRaw      im
1862                int      degrees
1863
1864 Imager::ImgRaw
1865 i_rotate_exact(im, amount, ...)
1866     Imager::ImgRaw      im
1867             double      amount
1868       PREINIT:
1869         i_color *backp = NULL;
1870         i_fcolor *fbackp = NULL;
1871         int i;
1872         SV * sv1;
1873       CODE:
1874         /* extract the bg colors if any */
1875         /* yes, this is kind of strange */
1876         for (i = 2; i < items; ++i) {
1877           sv1 = ST(i);
1878           if (sv_derived_from(sv1, "Imager::Color")) {
1879             IV tmp = SvIV((SV*)SvRV(sv1));
1880             backp = INT2PTR(i_color *, tmp);
1881           }
1882           else if (sv_derived_from(sv1, "Imager::Color::Float")) {
1883             IV tmp = SvIV((SV*)SvRV(sv1));
1884             fbackp = INT2PTR(i_fcolor *, tmp);
1885           }
1886         }
1887         RETVAL = i_rotate_exact_bg(im, amount, backp, fbackp);
1888       OUTPUT:
1889         RETVAL
1890
1891 Imager::ImgRaw
1892 i_matrix_transform(im, xsize, ysize, matrix, ...)
1893     Imager::ImgRaw      im
1894                i_img_dim      xsize
1895                i_img_dim      ysize
1896       PREINIT:
1897         double matrix[9];
1898         AV *av;
1899         IV len;
1900         SV *sv1;
1901         int i;
1902         i_color *backp = NULL;
1903         i_fcolor *fbackp = NULL;
1904       CODE:
1905         if (!SvROK(ST(3)) || SvTYPE(SvRV(ST(3))) != SVt_PVAV)
1906           croak("i_matrix_transform: parameter 4 must be an array ref\n");
1907         av=(AV*)SvRV(ST(3));
1908         len=av_len(av)+1;
1909         if (len > 9)
1910           len = 9;
1911         for (i = 0; i < len; ++i) {
1912           sv1=(*(av_fetch(av,i,0)));
1913           matrix[i] = SvNV(sv1);
1914         }
1915         for (; i < 9; ++i)
1916           matrix[i] = 0;
1917         /* extract the bg colors if any */
1918         /* yes, this is kind of strange */
1919         for (i = 4; i < items; ++i) {
1920           sv1 = ST(i);
1921           if (sv_derived_from(sv1, "Imager::Color")) {
1922             IV tmp = SvIV((SV*)SvRV(sv1));
1923             backp = INT2PTR(i_color *, tmp);
1924           }
1925           else if (sv_derived_from(sv1, "Imager::Color::Float")) {
1926             IV tmp = SvIV((SV*)SvRV(sv1));
1927             fbackp = INT2PTR(i_fcolor *, tmp);
1928           }
1929         }
1930         RETVAL = i_matrix_transform_bg(im, xsize, ysize, matrix, backp, fbackp);
1931       OUTPUT:
1932         RETVAL
1933
1934 undef_int
1935 i_gaussian(im,stdev)
1936     Imager::ImgRaw     im
1937             double     stdev
1938
1939 void
1940 i_unsharp_mask(im,stdev,scale)
1941     Imager::ImgRaw     im
1942              double    stdev
1943              double    scale
1944
1945 int
1946 i_conv(im,coef)
1947         Imager::ImgRaw     im
1948         AV *coef
1949      PREINIT:
1950         double*    c_coef;
1951         int     len;
1952         SV* sv1;
1953         int i;
1954     CODE:
1955         len = av_len(coef) + 1;
1956         c_coef=mymalloc( len * sizeof(double) );
1957         for(i = 0; i  < len; i++) {
1958           sv1 = (*(av_fetch(coef, i, 0)));
1959           c_coef[i] = (double)SvNV(sv1);
1960         }
1961         RETVAL = i_conv(im, c_coef, len);
1962         myfree(c_coef);
1963     OUTPUT:
1964         RETVAL
1965
1966 Imager::ImgRaw
1967 i_convert(src, avmain)
1968     Imager::ImgRaw     src
1969     AV *avmain
1970         PREINIT:
1971           double *coeff;
1972           int outchan;
1973           int inchan;
1974           SV **temp;
1975           AV *avsub;
1976           int len;
1977           int i, j;
1978         CODE:
1979           outchan = av_len(avmain)+1;
1980           /* find the biggest */
1981           inchan = 0;
1982           for (j=0; j < outchan; ++j) {
1983             temp = av_fetch(avmain, j, 0);
1984             if (temp && SvROK(*temp) && SvTYPE(SvRV(*temp)) == SVt_PVAV) {
1985               avsub = (AV*)SvRV(*temp);
1986               len = av_len(avsub)+1;
1987               if (len > inchan)
1988                 inchan = len;
1989             }
1990           }
1991           coeff = mymalloc(sizeof(double) * outchan * inchan);
1992           for (j = 0; j < outchan; ++j) {
1993             avsub = (AV*)SvRV(*av_fetch(avmain, j, 0));
1994             len = av_len(avsub)+1;
1995             for (i = 0; i < len; ++i) {
1996               temp = av_fetch(avsub, i, 0);
1997               if (temp)
1998                 coeff[i+j*inchan] = SvNV(*temp);
1999               else
2000                 coeff[i+j*inchan] = 0;
2001             }
2002             while (i < inchan)
2003               coeff[i++ + j*inchan] = 0;
2004           }
2005           RETVAL = i_convert(src, coeff, outchan, inchan);
2006           myfree(coeff);
2007         OUTPUT:
2008           RETVAL
2009
2010
2011 void
2012 i_map(im, pmaps)
2013     Imager::ImgRaw     im
2014         PREINIT:
2015           unsigned int mask = 0;
2016           AV *avmain;
2017           AV *avsub;
2018           SV **temp;
2019           int len;
2020           int i, j;
2021           unsigned char (*maps)[256];
2022         CODE:
2023           if (!SvROK(ST(1)) || SvTYPE(SvRV(ST(1))) != SVt_PVAV)
2024             croak("i_map: parameter 2 must be an arrayref\n");
2025           avmain = (AV*)SvRV(ST(1));
2026           len = av_len(avmain)+1;
2027           if (im->channels < len) len = im->channels;
2028
2029           maps = mymalloc( len * sizeof(unsigned char [256]) );
2030
2031           for (j=0; j<len ; j++) {
2032             temp = av_fetch(avmain, j, 0);
2033             if (temp && SvROK(*temp) && (SvTYPE(SvRV(*temp)) == SVt_PVAV) ) {
2034               avsub = (AV*)SvRV(*temp);
2035               if(av_len(avsub) != 255) continue;
2036               mask |= 1<<j;
2037               for (i=0; i<256 ; i++) {
2038                 int val;
2039                 temp = av_fetch(avsub, i, 0);
2040                 val = temp ? SvIV(*temp) : 0;
2041                 if (val<0) val = 0;
2042                 if (val>255) val = 255;
2043                 maps[j][i] = val;
2044               }
2045             }
2046           }
2047           i_map(im, maps, mask);
2048           myfree(maps);
2049
2050
2051
2052 float
2053 i_img_diff(im1,im2)
2054     Imager::ImgRaw     im1
2055     Imager::ImgRaw     im2
2056
2057 double
2058 i_img_diffd(im1,im2)
2059     Imager::ImgRaw     im1
2060     Imager::ImgRaw     im2
2061
2062 int
2063 i_img_samef(im1, im2, epsilon = i_img_epsilonf(), what=NULL)
2064     Imager::ImgRaw    im1
2065     Imager::ImgRaw    im2
2066     double epsilon
2067     const char *what
2068
2069 double
2070 i_img_epsilonf()
2071
2072 bool
2073 _is_color_object(sv)
2074         SV* sv
2075     CODE:
2076         SvGETMAGIC(sv);
2077         RETVAL = SvOK(sv) && SvROK(sv) &&
2078            (sv_derived_from(sv, "Imager::Color")
2079           || sv_derived_from(sv, "Imager::Color::Float"));
2080     OUTPUT:
2081         RETVAL
2082
2083 #ifdef HAVE_LIBTT
2084
2085
2086 Imager::Font::TT
2087 i_tt_new(fontname)
2088               char*     fontname
2089
2090
2091 MODULE = Imager         PACKAGE = Imager::Font::TT      PREFIX=TT_
2092
2093 #define TT_DESTROY(handle) i_tt_destroy(handle)
2094
2095 void
2096 TT_DESTROY(handle)
2097      Imager::Font::TT   handle
2098
2099 int
2100 TT_CLONE_SKIP(...)
2101     CODE:
2102         (void)items; /* avoid unused warning */
2103         RETVAL = 1;
2104     OUTPUT:
2105         RETVAL
2106
2107
2108 MODULE = Imager         PACKAGE = Imager
2109
2110
2111 undef_int
2112 i_tt_text(handle,im,xb,yb,cl,points,str_sv,len_ignored,smooth,utf8,align=1)
2113   Imager::Font::TT     handle
2114     Imager::ImgRaw     im
2115                i_img_dim     xb
2116                i_img_dim     yb
2117      Imager::Color     cl
2118              double     points
2119               SV *     str_sv
2120                int     smooth
2121                int     utf8
2122                int     align
2123              PREINIT:
2124                char *str;
2125                STRLEN len;
2126              CODE:
2127 #ifdef SvUTF8
2128                if (SvUTF8(str_sv))
2129                  utf8 = 1;
2130 #endif
2131                str = SvPV(str_sv, len);
2132                RETVAL = i_tt_text(handle, im, xb, yb, cl, points, str,
2133                                   len, smooth, utf8, align);
2134              OUTPUT:
2135                RETVAL
2136
2137
2138 undef_int
2139 i_tt_cp(handle,im,xb,yb,channel,points,str_sv,len_ignored,smooth,utf8,align=1)
2140   Imager::Font::TT     handle
2141     Imager::ImgRaw     im
2142                i_img_dim     xb
2143                i_img_dim     yb
2144                int     channel
2145              double     points
2146               SV *     str_sv
2147                int     smooth
2148                int     utf8
2149                int     align
2150              PREINIT:
2151                char *str;
2152                STRLEN len;
2153              CODE:
2154 #ifdef SvUTF8
2155                if (SvUTF8(str_sv))
2156                  utf8 = 1;
2157 #endif
2158                str = SvPV(str_sv, len);
2159                RETVAL = i_tt_cp(handle, im, xb, yb, channel, points, str, len,
2160                                 smooth, utf8, align);
2161              OUTPUT:
2162                 RETVAL
2163
2164
2165 void
2166 i_tt_bbox(handle,point,str_sv,len_ignored, utf8)
2167   Imager::Font::TT     handle
2168              double     point
2169                SV*    str_sv
2170                int     utf8
2171              PREINIT:
2172                i_img_dim cords[BOUNDING_BOX_COUNT];
2173                int rc;
2174                char *  str;
2175                STRLEN len;
2176                int i;
2177              PPCODE:
2178 #ifdef SvUTF8
2179                if (SvUTF8(ST(2)))
2180                  utf8 = 1;
2181 #endif
2182                str = SvPV(str_sv, len);
2183                if ((rc=i_tt_bbox(handle,point,str,len,cords, utf8))) {
2184                  EXTEND(SP, rc);
2185                  for (i = 0; i < rc; ++i) {
2186                    PUSHs(sv_2mortal(newSViv(cords[i])));
2187                  }
2188                }
2189
2190 void
2191 i_tt_has_chars(handle, text_sv, utf8)
2192         Imager::Font::TT handle
2193         SV  *text_sv
2194         int utf8
2195       PREINIT:
2196         char const *text;
2197         STRLEN len;
2198         char *work;
2199         size_t count;
2200         size_t i;
2201       PPCODE:
2202 #ifdef SvUTF8
2203         if (SvUTF8(text_sv))
2204           utf8 = 1;
2205 #endif
2206         text = SvPV(text_sv, len);
2207         work = mymalloc(len);
2208         count = i_tt_has_chars(handle, text, len, utf8, work);
2209         if (GIMME_V == G_ARRAY) {
2210           EXTEND(SP, count);
2211           for (i = 0; i < count; ++i) {
2212             PUSHs(boolSV(work[i]));
2213           }
2214         }
2215         else {
2216           EXTEND(SP, 1);
2217           PUSHs(sv_2mortal(newSVpv(work, count)));
2218         }
2219         myfree(work);
2220
2221 void
2222 i_tt_dump_names(handle)
2223         Imager::Font::TT handle
2224
2225 void
2226 i_tt_face_name(handle)
2227         Imager::Font::TT handle
2228       PREINIT:
2229         char name[255];
2230         size_t len;
2231       PPCODE:
2232         len = i_tt_face_name(handle, name, sizeof(name));
2233         if (len) {
2234           EXTEND(SP, 1);
2235           PUSHs(sv_2mortal(newSVpv(name, len-1)));
2236         }
2237
2238 void
2239 i_tt_glyph_name(handle, text_sv, utf8 = 0)
2240         Imager::Font::TT handle
2241         SV *text_sv
2242         int utf8
2243       PREINIT:
2244         char const *text;
2245         STRLEN work_len;
2246         size_t len;
2247         size_t outsize;
2248         char name[255];
2249       PPCODE:
2250 #ifdef SvUTF8
2251         if (SvUTF8(text_sv))
2252           utf8 = 1;
2253 #endif
2254         text = SvPV(text_sv, work_len);
2255         len = work_len;
2256         while (len) {
2257           unsigned long ch;
2258           if (utf8) {
2259             ch = i_utf8_advance(&text, &len);
2260             if (ch == ~0UL) {
2261               i_push_error(0, "invalid UTF8 character");
2262               break;
2263             }
2264           }
2265           else {
2266             ch = *text++;
2267             --len;
2268           }
2269           EXTEND(SP, 1);
2270           if ((outsize = i_tt_glyph_name(handle, ch, name, sizeof(name))) != 0) {
2271             PUSHs(sv_2mortal(newSVpv(name, 0)));
2272           }
2273           else {
2274             PUSHs(&PL_sv_undef);
2275           }
2276         }
2277
2278 #endif
2279
2280 const char *
2281 i_test_format_probe(ig, length)
2282         Imager::IO     ig
2283                int     length
2284
2285 Imager::ImgRaw
2286 i_readpnm_wiol(ig, allow_incomplete)
2287         Imager::IO     ig
2288                int     allow_incomplete
2289
2290
2291 void
2292 i_readpnm_multi_wiol(ig, allow_incomplete)
2293         Imager::IO ig
2294                int     allow_incomplete
2295       PREINIT:
2296         i_img **imgs;
2297         int count=0;
2298         int i;
2299       PPCODE:
2300         imgs = i_readpnm_multi_wiol(ig, &count, allow_incomplete);
2301         if (imgs) {
2302           EXTEND(SP, count);
2303           for (i = 0; i < count; ++i) {
2304             SV *sv = sv_newmortal();
2305             sv_setref_pv(sv, "Imager::ImgRaw", (void *)imgs[i]);
2306             PUSHs(sv);
2307           }
2308           myfree(imgs);
2309         }
2310
2311 undef_int
2312 i_writeppm_wiol(im, ig)
2313     Imager::ImgRaw     im
2314         Imager::IO     ig
2315
2316
2317
2318
2319
2320 Imager::ImgRaw
2321 i_readraw_wiol(ig,x,y,datachannels,storechannels,intrl)
2322         Imager::IO     ig
2323                i_img_dim     x
2324                i_img_dim     y
2325                int     datachannels
2326                int     storechannels
2327                int     intrl
2328
2329 undef_int
2330 i_writeraw_wiol(im,ig)
2331     Imager::ImgRaw     im
2332         Imager::IO     ig
2333
2334 undef_int
2335 i_writebmp_wiol(im,ig)
2336     Imager::ImgRaw     im
2337         Imager::IO     ig
2338
2339 Imager::ImgRaw
2340 i_readbmp_wiol(ig, allow_incomplete=0)
2341         Imager::IO     ig
2342         int            allow_incomplete
2343
2344
2345 undef_int
2346 i_writetga_wiol(im,ig, wierdpack, compress, idstring)
2347     Imager::ImgRaw     im
2348         Imager::IO     ig
2349                int     wierdpack
2350                int     compress
2351               char*    idstring
2352             PREINIT:
2353                 int idlen;
2354                CODE:
2355                 idlen  = SvCUR(ST(4));
2356                 RETVAL = i_writetga_wiol(im, ig, wierdpack, compress, idstring, idlen);
2357                 OUTPUT:
2358                 RETVAL
2359
2360
2361 Imager::ImgRaw
2362 i_readtga_wiol(ig, length)
2363         Imager::IO     ig
2364                int     length
2365
2366
2367
2368
2369 Imager::ImgRaw
2370 i_scaleaxis(im,Value,Axis)
2371     Imager::ImgRaw     im
2372              double     Value
2373                int     Axis
2374
2375 Imager::ImgRaw
2376 i_scale_nn(im,scx,scy)
2377     Imager::ImgRaw     im
2378              double    scx
2379              double    scy
2380
2381 Imager::ImgRaw
2382 i_scale_mixing(im, width, height)
2383     Imager::ImgRaw     im
2384                i_img_dim     width
2385                i_img_dim     height
2386
2387 Imager::ImgRaw
2388 i_haar(im)
2389     Imager::ImgRaw     im
2390
2391 int
2392 i_count_colors(im,maxc)
2393     Imager::ImgRaw     im
2394                int     maxc
2395
2396 void
2397 i_get_anonymous_color_histo(im, maxc = 0x40000000)
2398    Imager::ImgRaw  im
2399    int maxc
2400     PREINIT:
2401         int i;
2402         unsigned int * col_usage = NULL;
2403         int col_cnt;
2404     PPCODE:
2405         col_cnt = i_get_anonymous_color_histo(im, &col_usage, maxc);
2406         EXTEND(SP, col_cnt);
2407         for (i = 0; i < col_cnt; i++)  {
2408             PUSHs(sv_2mortal(newSViv( col_usage[i])));
2409         }
2410         myfree(col_usage);
2411         XSRETURN(col_cnt);
2412
2413
2414 void
2415 i_transform(im,opx,opy,parm)
2416     Imager::ImgRaw     im
2417              PREINIT:
2418              double* parm;
2419              int *opx;
2420              int *opy;
2421              int     opxl;
2422              int     opyl;
2423              int     parmlen;
2424              AV* av;
2425              SV* sv1;
2426              int i;
2427              i_img *result;
2428              PPCODE:
2429              if (!SvROK(ST(1))) croak("Imager: Parameter 1 must be a reference to an array\n");
2430              if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to an array\n");
2431              if (!SvROK(ST(3))) croak("Imager: Parameter 3 must be a reference to an array\n");
2432              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 must be a reference to an array\n");
2433              if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 must be a reference to an array\n");
2434              if (SvTYPE(SvRV(ST(3))) != SVt_PVAV) croak("Imager: Parameter 3 must be a reference to an array\n");
2435              av=(AV*)SvRV(ST(1));
2436              opxl=av_len(av)+1;
2437              opx=mymalloc( opxl*sizeof(int) );
2438              for(i=0;i<opxl;i++) {
2439                sv1=(*(av_fetch(av,i,0)));
2440                opx[i]=(int)SvIV(sv1);
2441              }
2442              av=(AV*)SvRV(ST(2));
2443              opyl=av_len(av)+1;
2444              opy=mymalloc( opyl*sizeof(int) );
2445              for(i=0;i<opyl;i++) {
2446                sv1=(*(av_fetch(av,i,0)));
2447                opy[i]=(int)SvIV(sv1);
2448              }
2449              av=(AV*)SvRV(ST(3));
2450              parmlen=av_len(av)+1;
2451              parm=mymalloc( parmlen*sizeof(double) );
2452              for(i=0;i<parmlen;i++) { /* FIXME: Bug? */
2453                sv1=(*(av_fetch(av,i,0)));
2454                parm[i]=(double)SvNV(sv1);
2455              }
2456              result=i_transform(im,opx,opxl,opy,opyl,parm,parmlen);
2457              myfree(parm);
2458              myfree(opy);
2459              myfree(opx);
2460              if (result) {
2461                SV *result_sv = sv_newmortal();
2462                EXTEND(SP, 1);
2463                sv_setref_pv(result_sv, "Imager::ImgRaw", (void*)result);
2464                PUSHs(result_sv);
2465              }
2466
2467 void
2468 i_transform2(sv_width,sv_height,channels,sv_ops,av_n_regs,av_c_regs,av_in_imgs)
2469         SV *sv_width
2470         SV *sv_height
2471         SV *sv_ops
2472         AV *av_n_regs
2473         AV *av_c_regs
2474         AV *av_in_imgs
2475         int channels
2476              PREINIT:
2477              i_img_dim width;
2478              i_img_dim height;
2479              struct rm_op *ops;
2480              STRLEN ops_len;
2481              int ops_count;
2482              double *n_regs;
2483              int n_regs_count;
2484              i_color *c_regs;
2485              int c_regs_count;
2486              int in_imgs_count;
2487              i_img **in_imgs;
2488              SV *sv1;
2489              IV tmp;
2490              int i;
2491              i_img *result;
2492              PPCODE:
2493
2494              in_imgs_count = av_len(av_in_imgs)+1;
2495              for (i = 0; i < in_imgs_count; ++i) {
2496                sv1 = *av_fetch(av_in_imgs, i, 0);
2497                if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
2498                  croak("sv_in_img must contain only images");
2499                }
2500              }
2501              if (in_imgs_count > 0) {
2502                in_imgs = mymalloc(in_imgs_count*sizeof(i_img*));
2503                for (i = 0; i < in_imgs_count; ++i) {
2504                  sv1 = *av_fetch(av_in_imgs,i,0);
2505                  if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
2506                    croak("Parameter 5 must contain only images");
2507                  }
2508                  tmp = SvIV((SV*)SvRV(sv1));
2509                  in_imgs[i] = INT2PTR(i_img*, tmp);
2510                }
2511              }
2512              else {
2513                /* no input images */
2514                in_imgs = NULL;
2515              }
2516              /* default the output size from the first input if possible */
2517              if (SvOK(sv_width))
2518                width = SvIV(sv_width);
2519              else if (in_imgs_count)
2520                width = in_imgs[0]->xsize;
2521              else
2522                croak("No output image width supplied");
2523
2524              if (SvOK(sv_height))
2525                height = SvIV(sv_height);
2526              else if (in_imgs_count)
2527                height = in_imgs[0]->ysize;
2528              else
2529                croak("No output image height supplied");
2530
2531              ops = (struct rm_op *)SvPV(sv_ops, ops_len);
2532              if (ops_len % sizeof(struct rm_op))
2533                  croak("Imager: Parameter 3 must be a bitmap of regops\n");
2534              ops_count = ops_len / sizeof(struct rm_op);
2535
2536              n_regs_count = av_len(av_n_regs)+1;
2537              n_regs = mymalloc(n_regs_count * sizeof(double));
2538              for (i = 0; i < n_regs_count; ++i) {
2539                sv1 = *av_fetch(av_n_regs,i,0);
2540                if (SvOK(sv1))
2541                  n_regs[i] = SvNV(sv1);
2542              }
2543              c_regs_count = av_len(av_c_regs)+1;
2544              c_regs = mymalloc(c_regs_count * sizeof(i_color));
2545              /* I don't bother initializing the colou?r registers */
2546
2547              result=i_transform2(width, height, channels, ops, ops_count,
2548                                  n_regs, n_regs_count,
2549                                  c_regs, c_regs_count, in_imgs, in_imgs_count);
2550              if (in_imgs)
2551                  myfree(in_imgs);
2552              myfree(n_regs);
2553              myfree(c_regs);
2554              if (result) {
2555                SV *result_sv = sv_newmortal();
2556                EXTEND(SP, 1);
2557                sv_setref_pv(result_sv, "Imager::ImgRaw", (void*)result);
2558                PUSHs(result_sv);
2559              }
2560
2561
2562 void
2563 i_contrast(im,intensity)
2564     Imager::ImgRaw     im
2565              float     intensity
2566
2567 void
2568 i_hardinvert(im)
2569     Imager::ImgRaw     im
2570
2571 void
2572 i_hardinvertall(im)
2573     Imager::ImgRaw     im
2574
2575 void
2576 i_noise(im,amount,type)
2577     Imager::ImgRaw     im
2578              float     amount
2579      unsigned char     type
2580
2581 void
2582 i_bumpmap(im,bump,channel,light_x,light_y,strength)
2583     Imager::ImgRaw     im
2584     Imager::ImgRaw     bump
2585                int     channel
2586          i_img_dim     light_x
2587          i_img_dim     light_y
2588          i_img_dim     strength
2589
2590
2591 void
2592 i_bumpmap_complex(im,bump,channel,tx,ty,Lx,Ly,Lz,cd,cs,n,Ia,Il,Is)
2593     Imager::ImgRaw     im
2594     Imager::ImgRaw     bump
2595                int     channel
2596                i_img_dim     tx
2597                i_img_dim     ty
2598              double     Lx
2599              double     Ly
2600              double     Lz
2601              float     cd
2602              float     cs
2603              float     n
2604      Imager::Color     Ia
2605      Imager::Color     Il
2606      Imager::Color     Is
2607
2608
2609
2610 void
2611 i_postlevels(im,levels)
2612     Imager::ImgRaw     im
2613              int       levels
2614
2615 void
2616 i_mosaic(im,size)
2617     Imager::ImgRaw     im
2618          i_img_dim     size
2619
2620 void
2621 i_watermark(im,wmark,tx,ty,pixdiff)
2622     Imager::ImgRaw     im
2623     Imager::ImgRaw     wmark
2624                i_img_dim     tx
2625                i_img_dim     ty
2626                int     pixdiff
2627
2628
2629 void
2630 i_autolevels(im,lsat,usat,skew)
2631     Imager::ImgRaw     im
2632              float     lsat
2633              float     usat
2634              float     skew
2635
2636 void
2637 i_radnoise(im,xo,yo,rscale,ascale)
2638     Imager::ImgRaw     im
2639              float     xo
2640              float     yo
2641              float     rscale
2642              float     ascale
2643
2644 void
2645 i_turbnoise(im, xo, yo, scale)
2646     Imager::ImgRaw     im
2647              float     xo
2648              float     yo
2649              float     scale
2650
2651
2652 void
2653 i_gradgen(im, ...)
2654     Imager::ImgRaw     im
2655       PREINIT:
2656         int num;
2657         i_img_dim *xo;
2658         i_img_dim *yo;
2659         i_color *ival;
2660         int dmeasure;
2661         int i;
2662         SV *sv;
2663         AV *axx;
2664         AV *ayy;
2665         AV *ac;
2666       CODE:
2667         if (items != 5)
2668             croak("Usage: i_gradgen(im, xo, yo, ival, dmeasure)");
2669         if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
2670             croak("i_gradgen: Second argument must be an array ref");
2671         if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
2672             croak("i_gradgen: Third argument must be an array ref");
2673         if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
2674             croak("i_gradgen: Fourth argument must be an array ref");
2675         axx = (AV *)SvRV(ST(1));
2676         ayy = (AV *)SvRV(ST(2));
2677         ac  = (AV *)SvRV(ST(3));
2678         dmeasure = (int)SvIV(ST(4));
2679
2680         num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
2681         num = num <= av_len(ac) ? num : av_len(ac);
2682         num++;
2683         if (num < 2) croak("Usage: i_gradgen array refs must have more than 1 entry each");
2684         xo = mymalloc( sizeof(i_img_dim) * num );
2685         yo = mymalloc( sizeof(i_img_dim) * num );
2686         ival = mymalloc( sizeof(i_color) * num );
2687         for(i = 0; i<num; i++) {
2688           xo[i]   = (i_img_dim)SvIV(* av_fetch(axx, i, 0));
2689           yo[i]   = (i_img_dim)SvIV(* av_fetch(ayy, i, 0));
2690           sv = *av_fetch(ac, i, 0);
2691           if ( !sv_derived_from(sv, "Imager::Color") ) {
2692             free(axx); free(ayy); free(ac);
2693             croak("i_gradgen: Element of fourth argument is not derived from Imager::Color");
2694           }
2695           ival[i] = *INT2PTR(i_color *, SvIV((SV *)SvRV(sv)));
2696         }
2697         i_gradgen(im, num, xo, yo, ival, dmeasure);
2698         myfree(xo);
2699         myfree(yo);
2700         myfree(ival);
2701
2702 Imager::ImgRaw
2703 i_diff_image(im, im2, mindist=0)
2704     Imager::ImgRaw     im
2705     Imager::ImgRaw     im2
2706             double     mindist
2707
2708 undef_int
2709 i_fountain(im, xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
2710     Imager::ImgRaw     im
2711             double     xa
2712             double     ya
2713             double     xb
2714             double     yb
2715                int     type
2716                int     repeat
2717                int     combine
2718                int     super_sample
2719             double     ssample_param
2720       PREINIT:
2721         AV *asegs;
2722         int count;
2723         i_fountain_seg *segs;
2724       CODE:
2725         if (!SvROK(ST(10)) || ! SvTYPE(SvRV(ST(10))))
2726             croak("i_fountain: argument 11 must be an array ref");
2727
2728         asegs = (AV *)SvRV(ST(10));
2729         segs = load_fount_segs(aTHX_ asegs, &count);
2730         RETVAL = i_fountain(im, xa, ya, xb, yb, type, repeat, combine,
2731                             super_sample, ssample_param, count, segs);
2732         myfree(segs);
2733       OUTPUT:
2734         RETVAL
2735
2736 Imager::FillHandle
2737 i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
2738             double     xa
2739             double     ya
2740             double     xb
2741             double     yb
2742                int     type
2743                int     repeat
2744                int     combine
2745                int     super_sample
2746             double     ssample_param
2747       PREINIT:
2748         AV *asegs;
2749         int count;
2750         i_fountain_seg *segs;
2751       CODE:
2752         if (!SvROK(ST(9)) || ! SvTYPE(SvRV(ST(9))))
2753             croak("i_fountain: argument 11 must be an array ref");
2754
2755         asegs = (AV *)SvRV(ST(9));
2756         segs = load_fount_segs(aTHX_ asegs, &count);
2757         RETVAL = i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine,
2758                                   super_sample, ssample_param, count, segs);
2759         myfree(segs);
2760       OUTPUT:
2761         RETVAL
2762
2763 Imager::FillHandle
2764 i_new_fill_opacity(other_fill, alpha_mult)
2765     Imager::FillHandle other_fill
2766     double alpha_mult
2767
2768 void
2769 i_errors()
2770       PREINIT:
2771         i_errmsg *errors;
2772         int i;
2773         AV *av;
2774         SV *sv;
2775       PPCODE:
2776         errors = i_errors();
2777         i = 0;
2778         while (errors[i].msg) {
2779           av = newAV();
2780           sv = newSVpv(errors[i].msg, strlen(errors[i].msg));
2781           if (!av_store(av, 0, sv)) {
2782             SvREFCNT_dec(sv);
2783           }
2784           sv = newSViv(errors[i].code);
2785           if (!av_store(av, 1, sv)) {
2786             SvREFCNT_dec(sv);
2787           }
2788           PUSHs(sv_2mortal(newRV_noinc((SV*)av)));
2789           ++i;
2790         }
2791
2792 void
2793 i_clear_error()
2794
2795 void
2796 i_push_error(code, msg)
2797         int code
2798         const char *msg
2799
2800 undef_int
2801 i_nearest_color(im, ...)
2802     Imager::ImgRaw     im
2803       PREINIT:
2804         int num;
2805         i_img_dim *xo;
2806         i_img_dim *yo;
2807         i_color *ival;
2808         int dmeasure;
2809         int i;
2810         SV *sv;
2811         AV *axx;
2812         AV *ayy;
2813         AV *ac;
2814       CODE:
2815         if (items != 5)
2816             croak("Usage: i_nearest_color(im, xo, yo, ival, dmeasure)");
2817         if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
2818             croak("i_nearest_color: Second argument must be an array ref");
2819         if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
2820             croak("i_nearest_color: Third argument must be an array ref");
2821         if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
2822             croak("i_nearest_color: Fourth argument must be an array ref");
2823         axx = (AV *)SvRV(ST(1));
2824         ayy = (AV *)SvRV(ST(2));
2825         ac  = (AV *)SvRV(ST(3));
2826         dmeasure = (int)SvIV(ST(4));
2827
2828         num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
2829         num = num <= av_len(ac) ? num : av_len(ac);
2830         num++;
2831         if (num < 2) croak("Usage: i_nearest_color array refs must have more than 1 entry each");
2832         xo = mymalloc( sizeof(i_img_dim) * num );
2833         yo = mymalloc( sizeof(i_img_dim) * num );
2834         ival = mymalloc( sizeof(i_color) * num );
2835         for(i = 0; i<num; i++) {
2836           xo[i]   = (i_img_dim)SvIV(* av_fetch(axx, i, 0));
2837           yo[i]   = (i_img_dim)SvIV(* av_fetch(ayy, i, 0));
2838           sv = *av_fetch(ac, i, 0);
2839           if ( !sv_derived_from(sv, "Imager::Color") ) {
2840             free(axx); free(ayy); free(ac);
2841             croak("i_nearest_color: Element of fourth argument is not derived from Imager::Color");
2842           }
2843           ival[i] = *INT2PTR(i_color *, SvIV((SV *)SvRV(sv)));
2844         }
2845         RETVAL = i_nearest_color(im, num, xo, yo, ival, dmeasure);
2846       OUTPUT:
2847         RETVAL
2848
2849 void
2850 malloc_state()
2851
2852 void
2853 DSO_open(filename)
2854              char*       filename
2855              PREINIT:
2856                void *rc;
2857                char *evstr;
2858              PPCODE:
2859                rc=DSO_open(filename,&evstr);
2860                if (rc!=NULL) {
2861                  if (evstr!=NULL) {
2862                    EXTEND(SP,2);
2863                    PUSHs(sv_2mortal(newSViv(PTR2IV(rc))));
2864                    PUSHs(sv_2mortal(newSVpvn(evstr, strlen(evstr))));
2865                  } else {
2866                    EXTEND(SP,1);
2867                    PUSHs(sv_2mortal(newSViv(PTR2IV(rc))));
2868                  }
2869                }
2870
2871
2872 undef_int
2873 DSO_close(dso_handle)
2874              void*       dso_handle
2875
2876 void
2877 DSO_funclist(dso_handle_v)
2878              void*       dso_handle_v
2879              PREINIT:
2880                int i;
2881                DSO_handle *dso_handle;
2882                func_ptr *functions;
2883              PPCODE:
2884                dso_handle=(DSO_handle*)dso_handle_v;
2885                functions = DSO_funclist(dso_handle);
2886                i=0;
2887                while( functions[i].name != NULL) {
2888                  EXTEND(SP,1);
2889                  PUSHs(sv_2mortal(newSVpv(functions[i].name,0)));
2890                  EXTEND(SP,1);
2891                  PUSHs(sv_2mortal(newSVpv(functions[i++].pcode,0)));
2892                }
2893
2894 void
2895 DSO_call(handle,func_index,hv)
2896                void*  handle
2897                int    func_index
2898              PREINIT:
2899                HV* hv;
2900              PPCODE:
2901                if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to a hash\n");
2902                hv=(HV*)SvRV(ST(2));
2903                if (SvTYPE(hv)!=SVt_PVHV) croak("Imager: Parameter 2 must be a reference to a hash\n");
2904                DSO_call( (DSO_handle *)handle,func_index,hv);
2905
2906 SV *
2907 i_get_pixel(im, x, y)
2908         Imager::ImgRaw im
2909         i_img_dim x
2910         i_img_dim y;
2911       PREINIT:
2912         i_color *color;
2913       CODE:
2914         color = (i_color *)mymalloc(sizeof(i_color));
2915         if (i_gpix(im, x, y, color) == 0) {
2916           RETVAL = NEWSV(0, 0);
2917           sv_setref_pv(RETVAL, "Imager::Color", (void *)color);
2918         }
2919         else {
2920           myfree(color);
2921           RETVAL = &PL_sv_undef;
2922         }
2923       OUTPUT:
2924         RETVAL
2925
2926
2927 int
2928 i_ppix(im, x, y, cl)
2929         Imager::ImgRaw im
2930         i_img_dim x
2931         i_img_dim y
2932         Imager::Color cl
2933
2934 Imager::ImgRaw
2935 i_img_pal_new(x, y, channels, maxpal)
2936         i_img_dim x
2937         i_img_dim y
2938         int     channels
2939         int     maxpal
2940
2941 Imager::ImgRaw
2942 i_img_to_pal(src, quant)
2943         Imager::ImgRaw src
2944       PREINIT:
2945         HV *hv;
2946         i_quantize quant;
2947       CODE:
2948         if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
2949           croak("i_img_to_pal: second argument must be a hash ref");
2950         hv = (HV *)SvRV(ST(1));
2951         memset(&quant, 0, sizeof(quant));
2952         quant.version = 1;
2953         quant.mc_size = 256;
2954         ip_handle_quant_opts(aTHX_ &quant, hv);
2955         RETVAL = i_img_to_pal(src, &quant);
2956         if (RETVAL) {
2957           ip_copy_colors_back(aTHX_ hv, &quant);
2958         }
2959         ip_cleanup_quant_opts(aTHX_ &quant);
2960       OUTPUT:
2961         RETVAL
2962
2963 Imager::ImgRaw
2964 i_img_to_rgb(src)
2965         Imager::ImgRaw src
2966
2967 void
2968 i_gpal(im, l, r, y)
2969         Imager::ImgRaw  im
2970         i_img_dim     l
2971         i_img_dim     r
2972         i_img_dim     y
2973       PREINIT:
2974         i_palidx *work;
2975         int count, i;
2976       PPCODE:
2977         if (l < r) {
2978           work = mymalloc((r-l) * sizeof(i_palidx));
2979           count = i_gpal(im, l, r, y, work);
2980           if (GIMME_V == G_ARRAY) {
2981             EXTEND(SP, count);
2982             for (i = 0; i < count; ++i) {
2983               PUSHs(sv_2mortal(newSViv(work[i])));
2984             }
2985           }
2986           else {
2987             EXTEND(SP, 1);
2988             PUSHs(sv_2mortal(newSVpv((char *)work, count * sizeof(i_palidx))));
2989           }
2990           myfree(work);
2991         }
2992         else {
2993           if (GIMME_V != G_ARRAY) {
2994             EXTEND(SP, 1);
2995             PUSHs(&PL_sv_undef);
2996           }
2997         }
2998
2999 int
3000 i_ppal(im, l, y, ...)
3001         Imager::ImgRaw  im
3002         i_img_dim     l
3003         i_img_dim     y
3004       PREINIT:
3005         i_palidx *work;
3006         i_img_dim i;
3007       CODE:
3008         if (items > 3) {
3009           work = malloc_temp(aTHX_ sizeof(i_palidx) * (items-3));
3010           for (i=0; i < items-3; ++i) {
3011             work[i] = SvIV(ST(i+3));
3012           }
3013           validate_i_ppal(im, work, items - 3);
3014           RETVAL = i_ppal(im, l, l+items-3, y, work);
3015         }
3016         else {
3017           RETVAL = 0;
3018         }
3019       OUTPUT:
3020         RETVAL
3021
3022 int
3023 i_ppal_p(im, l, y, data)
3024         Imager::ImgRaw  im
3025         i_img_dim     l
3026         i_img_dim     y
3027         SV *data
3028       PREINIT:
3029         i_palidx const *work;
3030         STRLEN len;
3031       CODE:
3032         work = (i_palidx const *)SvPV(data, len);
3033         len /= sizeof(i_palidx);
3034         if (len > 0) {
3035           validate_i_ppal(im, work, len);
3036           RETVAL = i_ppal(im, l, l+len, y, work);
3037         }
3038         else {
3039           RETVAL = 0;
3040         }
3041       OUTPUT:
3042         RETVAL
3043
3044 SV *
3045 i_addcolors(im, ...)
3046         Imager::ImgRaw  im
3047       PREINIT:
3048         int index;
3049         i_color *colors;
3050         int i;
3051       CODE:
3052         if (items < 2)
3053           croak("i_addcolors: no colors to add");
3054         colors = mymalloc((items-1) * sizeof(i_color));
3055         for (i=0; i < items-1; ++i) {
3056           if (sv_isobject(ST(i+1))
3057               && sv_derived_from(ST(i+1), "Imager::Color")) {
3058             IV tmp = SvIV((SV *)SvRV(ST(i+1)));
3059             colors[i] = *INT2PTR(i_color *, tmp);
3060           }
3061           else {
3062             myfree(colors);
3063             croak("i_addcolor: pixels must be Imager::Color objects");
3064           }
3065         }
3066         index = i_addcolors(im, colors, items-1);
3067         myfree(colors);
3068         if (index == 0) {
3069           RETVAL = newSVpv("0 but true", 0);
3070         }
3071         else if (index == -1) {
3072           RETVAL = &PL_sv_undef;
3073         }
3074         else {
3075           RETVAL = newSViv(index);
3076         }
3077       OUTPUT:
3078         RETVAL
3079
3080 undef_int
3081 i_setcolors(im, index, ...)
3082         Imager::ImgRaw  im
3083         int index
3084       PREINIT:
3085         i_color *colors;
3086         int i;
3087       CODE:
3088         if (items < 3)
3089           croak("i_setcolors: no colors to add");
3090         colors = mymalloc((items-2) * sizeof(i_color));
3091         for (i=0; i < items-2; ++i) {
3092           if (sv_isobject(ST(i+2))
3093               && sv_derived_from(ST(i+2), "Imager::Color")) {
3094             IV tmp = SvIV((SV *)SvRV(ST(i+2)));
3095             colors[i] = *INT2PTR(i_color *, tmp);
3096           }
3097           else {
3098             myfree(colors);
3099             croak("i_setcolors: pixels must be Imager::Color objects");
3100           }
3101         }
3102         RETVAL = i_setcolors(im, index, colors, items-2);
3103         myfree(colors);
3104       OUTPUT:
3105         RETVAL
3106
3107 void
3108 i_getcolors(im, index, ...)
3109         Imager::ImgRaw im
3110         int index
3111       PREINIT:
3112         i_color *colors;
3113         int count = 1;
3114         int i;
3115       PPCODE:
3116         if (items > 3)
3117           croak("i_getcolors: too many arguments");
3118         if (items == 3)
3119           count = SvIV(ST(2));
3120         if (count < 1)
3121           croak("i_getcolors: count must be positive");
3122         colors = mymalloc(sizeof(i_color) * count);
3123         if (i_getcolors(im, index, colors, count)) {
3124           for (i = 0; i < count; ++i) {
3125             i_color *pv;
3126             SV *sv = sv_newmortal();
3127             pv = mymalloc(sizeof(i_color));
3128             *pv = colors[i];
3129             sv_setref_pv(sv, "Imager::Color", (void *)pv);
3130             PUSHs(sv);
3131           }
3132         }
3133         myfree(colors);
3134
3135
3136 undef_neg_int
3137 i_colorcount(im)
3138         Imager::ImgRaw im
3139
3140 undef_neg_int
3141 i_maxcolors(im)
3142         Imager::ImgRaw im
3143
3144 SV *
3145 i_findcolor(im, color)
3146         Imager::ImgRaw im
3147         Imager::Color color
3148       PREINIT:
3149         i_palidx index;
3150       CODE:
3151         if (i_findcolor(im, color, &index)) {
3152           RETVAL = newSViv(index);
3153         }
3154         else {
3155           RETVAL = &PL_sv_undef;
3156         }
3157       OUTPUT:
3158         RETVAL
3159
3160 int
3161 i_img_bits(im)
3162         Imager::ImgRaw  im
3163
3164 int
3165 i_img_type(im)
3166         Imager::ImgRaw  im
3167
3168 int
3169 i_img_virtual(im)
3170         Imager::ImgRaw  im
3171
3172 void
3173 i_gsamp(im, l, r, y, ...)
3174         Imager::ImgRaw im
3175         i_img_dim l
3176         i_img_dim r
3177         i_img_dim y
3178       PREINIT:
3179         int *chans;
3180         int chan_count;
3181         i_sample_t *data;
3182         i_img_dim count, i;
3183       PPCODE:
3184         if (items < 5)
3185           croak("No channel numbers supplied to g_samp()");
3186         if (l < r) {
3187           chan_count = items - 4;
3188           chans = mymalloc(sizeof(int) * chan_count);
3189           for (i = 0; i < chan_count; ++i)
3190             chans[i] = SvIV(ST(i+4));
3191           data = mymalloc(sizeof(i_sample_t) * (r-l) * chan_count); /* XXX: memleak? */
3192           count = i_gsamp(im, l, r, y, data, chans, chan_count);
3193           myfree(chans);
3194           if (GIMME_V == G_ARRAY) {
3195             EXTEND(SP, count);
3196             for (i = 0; i < count; ++i)
3197               PUSHs(sv_2mortal(newSViv(data[i])));
3198           }
3199           else {
3200             EXTEND(SP, 1);
3201             PUSHs(sv_2mortal(newSVpv((char *)data, count * sizeof(i_sample_t))));
3202           }
3203           myfree(data);
3204         }
3205         else {
3206           if (GIMME_V != G_ARRAY) {
3207             EXTEND(SP, 1);
3208             PUSHs(&PL_sv_undef);
3209           }
3210         }
3211
3212 undef_neg_int
3213 i_gsamp_bits(im, l, r, y, bits, target, offset, ...)
3214         Imager::ImgRaw im
3215         i_img_dim l
3216         i_img_dim r
3217         i_img_dim y
3218         int bits
3219         AV *target
3220         STRLEN offset
3221       PREINIT:
3222         int *chans;
3223         int chan_count;
3224         unsigned *data;
3225         i_img_dim count, i;
3226       CODE:
3227         i_clear_error();
3228         if (items < 8)
3229           croak("No channel numbers supplied to g_samp()");
3230         if (l < r) {
3231           chan_count = items - 7;
3232           chans = mymalloc(sizeof(int) * chan_count);
3233           for (i = 0; i < chan_count; ++i)
3234             chans[i] = SvIV(ST(i+7));
3235           data = mymalloc(sizeof(unsigned) * (r-l) * chan_count);
3236           count = i_gsamp_bits(im, l, r, y, data, chans, chan_count, bits);
3237           myfree(chans);
3238           for (i = 0; i < count; ++i) {
3239             av_store(target, i+offset, newSVuv(data[i]));
3240           }
3241           myfree(data);
3242           RETVAL = count;
3243         }
3244         else {
3245           RETVAL = 0;
3246         }
3247       OUTPUT:
3248         RETVAL
3249
3250 undef_neg_int
3251 i_psamp_bits(im, l, y, bits, channels_sv, data_av, data_offset = 0, pixel_count = -1)
3252         Imager::ImgRaw im
3253         i_img_dim l
3254         i_img_dim y
3255         int bits
3256         SV *channels_sv
3257         AV *data_av
3258         int data_offset
3259         int pixel_count
3260       PREINIT:
3261         int chan_count;
3262         int *channels;
3263         STRLEN data_count;
3264         size_t data_used;
3265         unsigned *data;
3266         ptrdiff_t i;
3267       CODE:
3268         i_clear_error();
3269         if (SvOK(channels_sv)) {
3270           AV *channels_av;
3271           if (!SvROK(channels_sv) || SvTYPE(SvRV(channels_sv)) != SVt_PVAV) {
3272             croak("channels is not an array ref");
3273           }
3274           channels_av = (AV *)SvRV(channels_sv);
3275           chan_count = av_len(channels_av) + 1;
3276           if (chan_count < 1) {
3277             croak("i_psamp_bits: no channels provided");
3278           }
3279           channels = mymalloc(sizeof(int) * chan_count);
3280           for (i = 0; i < chan_count; ++i)
3281             channels[i] = SvIV(*av_fetch(channels_av, i, 0));
3282         }
3283         else {
3284           chan_count = im->channels;
3285           channels = NULL;
3286         }
3287
3288         data_count = av_len(data_av) + 1;
3289         if (data_offset < 0) {
3290           croak("data_offset must by non-negative");
3291         }
3292         if (data_offset > data_count) {
3293           croak("data_offset greater than number of samples supplied");
3294         }
3295         if (pixel_count == -1 ||
3296             data_offset + pixel_count * chan_count > data_count) {
3297           pixel_count = (data_count - data_offset) / chan_count;
3298         }
3299
3300         data_used = pixel_count * chan_count;
3301         data = mymalloc(sizeof(unsigned) * data_count);
3302         for (i = 0; i < data_used; ++i)
3303           data[i] = SvUV(*av_fetch(data_av, data_offset + i, 0));
3304
3305         RETVAL = i_psamp_bits(im, l, l + pixel_count, y, data, channels,
3306                               chan_count, bits);
3307
3308         if (data)
3309           myfree(data);
3310         if (channels)
3311           myfree(channels);
3312       OUTPUT:
3313         RETVAL
3314
3315 Imager::ImgRaw
3316 i_img_masked_new(targ, mask, x, y, w, h)
3317         Imager::ImgRaw targ
3318         i_img_dim x
3319         i_img_dim y
3320         i_img_dim w
3321         i_img_dim h
3322       PREINIT:
3323         i_img *mask;
3324       CODE:
3325         if (SvOK(ST(1))) {
3326           if (!sv_isobject(ST(1))
3327               || !sv_derived_from(ST(1), "Imager::ImgRaw")) {
3328             croak("i_img_masked_new: parameter 2 must undef or an image");
3329           }
3330           mask = INT2PTR(i_img *, SvIV((SV *)SvRV(ST(1))));
3331         }
3332         else
3333           mask = NULL;
3334         RETVAL = i_img_masked_new(targ, mask, x, y, w, h);
3335       OUTPUT:
3336         RETVAL
3337
3338 int
3339 i_plin(im, l, y, ...)
3340         Imager::ImgRaw  im
3341         i_img_dim     l
3342         i_img_dim     y
3343       PREINIT:
3344         i_color *work;
3345         STRLEN i;
3346         STRLEN len;
3347         size_t count;
3348       CODE:
3349         if (items > 3) {
3350           if (items == 4 && SvOK(ST(3)) && !SvROK(ST(3))) {
3351             /* supplied as a byte string */
3352             work = (i_color *)SvPV(ST(3), len);
3353             count = len / sizeof(i_color);
3354             if (count * sizeof(i_color) != len) {
3355               croak("i_plin: length of scalar argument must be multiple of sizeof i_color");
3356             }
3357             RETVAL = i_plin(im, l, l+count, y, work);
3358           }
3359           else {
3360             work = mymalloc(sizeof(i_color) * (items-3));
3361             for (i=0; i < items-3; ++i) {
3362               if (sv_isobject(ST(i+3))
3363                   && sv_derived_from(ST(i+3), "Imager::Color")) {
3364                 IV tmp = SvIV((SV *)SvRV(ST(i+3)));
3365                 work[i] = *INT2PTR(i_color *, tmp);
3366               }
3367               else {
3368                 myfree(work);
3369                 croak("i_plin: pixels must be Imager::Color objects");
3370               }
3371             }
3372             RETVAL = i_plin(im, l, l+items-3, y, work);
3373             myfree(work);
3374           }
3375         }
3376         else {
3377           RETVAL = 0;
3378         }
3379       OUTPUT:
3380         RETVAL
3381
3382 int
3383 i_ppixf(im, x, y, cl)
3384         Imager::ImgRaw im
3385         i_img_dim x
3386         i_img_dim y
3387         Imager::Color::Float cl
3388
3389 void
3390 i_gsampf(im, l, r, y, ...)
3391         Imager::ImgRaw im
3392         i_img_dim l
3393         i_img_dim r
3394         i_img_dim y
3395       PREINIT:
3396         int *chans;
3397         int chan_count;
3398         i_fsample_t *data;
3399         i_img_dim count, i;
3400       PPCODE:
3401         if (items < 5)
3402           croak("No channel numbers supplied to g_sampf()");
3403         if (l < r) {
3404           chan_count = items - 4;
3405           chans = mymalloc(sizeof(int) * chan_count);
3406           for (i = 0; i < chan_count; ++i)
3407             chans[i] = SvIV(ST(i+4));
3408           data = mymalloc(sizeof(i_fsample_t) * (r-l) * chan_count);
3409           count = i_gsampf(im, l, r, y, data, chans, chan_count);
3410           myfree(chans);
3411           if (GIMME_V == G_ARRAY) {
3412             EXTEND(SP, count);
3413             for (i = 0; i < count; ++i)
3414               PUSHs(sv_2mortal(newSVnv(data[i])));
3415           }
3416           else {
3417             EXTEND(SP, 1);
3418             PUSHs(sv_2mortal(newSVpv((void *)data, count * sizeof(i_fsample_t))));
3419           }
3420           myfree(data);
3421         }
3422         else {
3423           if (GIMME_V != G_ARRAY) {
3424             EXTEND(SP, 1);
3425             PUSHs(&PL_sv_undef);
3426           }
3427         }
3428
3429 int
3430 i_plinf(im, l, y, ...)
3431         Imager::ImgRaw  im
3432         i_img_dim     l
3433         i_img_dim     y
3434       PREINIT:
3435         i_fcolor *work;
3436         i_img_dim i;
3437         STRLEN len;
3438         size_t count;
3439       CODE:
3440         if (items > 3) {
3441           if (items == 4 && SvOK(ST(3)) && !SvROK(ST(3))) {
3442             /* supplied as a byte string */
3443             work = (i_fcolor *)SvPV(ST(3), len);
3444             count = len / sizeof(i_fcolor);
3445             if (count * sizeof(i_fcolor) != len) {
3446               croak("i_plin: length of scalar argument must be multiple of sizeof i_fcolor");
3447             }
3448             RETVAL = i_plinf(im, l, l+count, y, work);
3449           }
3450           else {
3451             work = mymalloc(sizeof(i_fcolor) * (items-3));
3452             for (i=0; i < items-3; ++i) {
3453               if (sv_isobject(ST(i+3))
3454                   && sv_derived_from(ST(i+3), "Imager::Color::Float")) {
3455                 IV tmp = SvIV((SV *)SvRV(ST(i+3)));
3456                 work[i] = *INT2PTR(i_fcolor *, tmp);
3457               }
3458               else {
3459                 myfree(work);
3460                 croak("i_plinf: pixels must be Imager::Color::Float objects");
3461               }
3462             }
3463             /**(char *)0 = 1;*/
3464             RETVAL = i_plinf(im, l, l+items-3, y, work);
3465             myfree(work);
3466           }
3467         }
3468         else {
3469           RETVAL = 0;
3470         }
3471       OUTPUT:
3472         RETVAL
3473
3474 SV *
3475 i_gpixf(im, x, y)
3476         Imager::ImgRaw im
3477         i_img_dim x
3478         i_img_dim y;
3479       PREINIT:
3480         i_fcolor *color;
3481       CODE:
3482         color = (i_fcolor *)mymalloc(sizeof(i_fcolor));
3483         if (i_gpixf(im, x, y, color) == 0) {
3484           RETVAL = NEWSV(0,0);
3485           sv_setref_pv(RETVAL, "Imager::Color::Float", (void *)color);
3486         }
3487         else {
3488           myfree(color);
3489           RETVAL = &PL_sv_undef;
3490         }
3491       OUTPUT:
3492         RETVAL
3493
3494 void
3495 i_glin(im, l, r, y)
3496         Imager::ImgRaw im
3497         i_img_dim l
3498         i_img_dim r
3499         i_img_dim y
3500       PREINIT:
3501         i_color *vals;
3502         i_img_dim count, i;
3503       PPCODE:
3504         if (l < r) {
3505           vals = mymalloc((r-l) * sizeof(i_color));
3506           memset(vals, 0, (r-l) * sizeof(i_color));
3507           count = i_glin(im, l, r, y, vals);
3508           if (GIMME_V == G_ARRAY) {
3509             EXTEND(SP, count);
3510             for (i = 0; i < count; ++i) {
3511               SV *sv;
3512               i_color *col = mymalloc(sizeof(i_color));
3513               *col = vals[i];
3514               sv = sv_newmortal();
3515               sv_setref_pv(sv, "Imager::Color", (void *)col);
3516               PUSHs(sv);
3517             }
3518           }
3519           else if (count) {
3520             EXTEND(SP, 1);
3521             PUSHs(sv_2mortal(newSVpv((void *)vals, count * sizeof(i_color))));
3522           }
3523           myfree(vals);
3524         }
3525
3526 void
3527 i_glinf(im, l, r, y)
3528         Imager::ImgRaw im
3529         i_img_dim l
3530         i_img_dim r
3531         i_img_dim y
3532       PREINIT:
3533         i_fcolor *vals;
3534         i_img_dim count, i;
3535         i_fcolor zero;
3536       PPCODE:
3537         for (i = 0; i < MAXCHANNELS; ++i)
3538           zero.channel[i] = 0;
3539         if (l < r) {
3540           vals = mymalloc((r-l) * sizeof(i_fcolor));
3541           for (i = 0; i < r-l; ++i)
3542             vals[i] = zero;
3543           count = i_glinf(im, l, r, y, vals);
3544           if (GIMME_V == G_ARRAY) {
3545             EXTEND(SP, count);
3546             for (i = 0; i < count; ++i) {
3547               SV *sv;
3548               i_fcolor *col = mymalloc(sizeof(i_fcolor));
3549               *col = vals[i];
3550               sv = sv_newmortal();
3551               sv_setref_pv(sv, "Imager::Color::Float", (void *)col);
3552               PUSHs(sv);
3553             }
3554           }
3555           else if (count) {
3556             EXTEND(SP, 1);
3557             PUSHs(sv_2mortal(newSVpv((void *)vals, count * sizeof(i_fcolor))));
3558           }
3559           myfree(vals);
3560         }
3561
3562 Imager::ImgRaw
3563 i_img_16_new(x, y, ch)
3564         i_img_dim x
3565         i_img_dim y
3566         int ch
3567
3568 Imager::ImgRaw
3569 i_img_to_rgb16(im)
3570        Imager::ImgRaw im
3571
3572 Imager::ImgRaw
3573 i_img_double_new(x, y, ch)
3574         i_img_dim x
3575         i_img_dim y
3576         int ch
3577
3578 Imager::ImgRaw
3579 i_img_to_drgb(im)
3580        Imager::ImgRaw im
3581
3582 undef_int
3583 i_tags_addn(im, name, code, idata)
3584         Imager::ImgRaw im
3585         int     code
3586         int     idata
3587       PREINIT:
3588         char *name;
3589         STRLEN len;
3590       CODE:
3591         if (SvOK(ST(1)))
3592           name = SvPV(ST(1), len);
3593         else
3594           name = NULL;
3595         RETVAL = i_tags_addn(&im->tags, name, code, idata);
3596       OUTPUT:
3597         RETVAL
3598
3599 undef_int
3600 i_tags_add(im, name, code, data, idata)
3601         Imager::ImgRaw  im
3602         int code
3603         int idata
3604       PREINIT:
3605         char *name;
3606         char *data;
3607         STRLEN len;
3608       CODE:
3609         if (SvOK(ST(1)))
3610           name = SvPV(ST(1), len);
3611         else
3612           name = NULL;
3613         if (SvOK(ST(3)))
3614           data = SvPV(ST(3), len);
3615         else {
3616           data = NULL;
3617           len = 0;
3618         }
3619         RETVAL = i_tags_add(&im->tags, name, code, data, len, idata);
3620       OUTPUT:
3621         RETVAL
3622
3623 SV *
3624 i_tags_find(im, name, start)
3625         Imager::ImgRaw  im
3626         char *name
3627         int start
3628       PREINIT:
3629         int entry;
3630       CODE:
3631         if (i_tags_find(&im->tags, name, start, &entry)) {
3632           if (entry == 0)
3633             RETVAL = newSVpv("0 but true", 0);
3634           else
3635             RETVAL = newSViv(entry);
3636         } else {
3637           RETVAL = &PL_sv_undef;
3638         }
3639       OUTPUT:
3640         RETVAL
3641
3642 SV *
3643 i_tags_findn(im, code, start)
3644         Imager::ImgRaw  im
3645         int             code
3646         int             start
3647       PREINIT:
3648         int entry;
3649       CODE:
3650         if (i_tags_findn(&im->tags, code, start, &entry)) {
3651           if (entry == 0)
3652             RETVAL = newSVpv("0 but true", 0);
3653           else
3654             RETVAL = newSViv(entry);
3655         }
3656         else {
3657           RETVAL = &PL_sv_undef;
3658         }
3659       OUTPUT:
3660         RETVAL
3661
3662 int
3663 i_tags_delete(im, entry)
3664         Imager::ImgRaw  im
3665         int             entry
3666       CODE:
3667         RETVAL = i_tags_delete(&im->tags, entry);
3668       OUTPUT:
3669         RETVAL
3670
3671 int
3672 i_tags_delbyname(im, name)
3673         Imager::ImgRaw  im
3674         char *          name
3675       CODE:
3676         RETVAL = i_tags_delbyname(&im->tags, name);
3677       OUTPUT:
3678         RETVAL
3679
3680 int
3681 i_tags_delbycode(im, code)
3682         Imager::ImgRaw  im
3683         int             code
3684       CODE:
3685         RETVAL = i_tags_delbycode(&im->tags, code);
3686       OUTPUT:
3687         RETVAL
3688
3689 void
3690 i_tags_get(im, index)
3691         Imager::ImgRaw  im
3692         int             index
3693       PPCODE:
3694         if (index >= 0 && index < im->tags.count) {
3695           i_img_tag *entry = im->tags.tags + index;
3696           EXTEND(SP, 5);
3697
3698           if (entry->name) {
3699             PUSHs(sv_2mortal(newSVpv(entry->name, 0)));
3700           }
3701           else {
3702             PUSHs(sv_2mortal(newSViv(entry->code)));
3703           }
3704           if (entry->data) {
3705             PUSHs(sv_2mortal(newSVpvn(entry->data, entry->size)));
3706           }
3707           else {
3708             PUSHs(sv_2mortal(newSViv(entry->idata)));
3709           }
3710         }
3711
3712 void
3713 i_tags_get_string(im, what_sv)
3714         Imager::ImgRaw  im
3715         SV *what_sv
3716       PREINIT:
3717         char const *name = NULL;
3718         int code;
3719         char buffer[200];
3720       PPCODE:
3721         if (SvIOK(what_sv)) {
3722           code = SvIV(what_sv);
3723           name = NULL;
3724         }
3725         else {
3726           name = SvPV_nolen(what_sv);
3727           code = 0;
3728         }
3729         if (i_tags_get_string(&im->tags, name, code, buffer, sizeof(buffer))) {
3730           EXTEND(SP, 1);
3731           PUSHs(sv_2mortal(newSVpv(buffer, 0)));
3732         }
3733
3734 int
3735 i_tags_count(im)
3736         Imager::ImgRaw  im
3737       CODE:
3738         RETVAL = im->tags.count;
3739       OUTPUT:
3740         RETVAL
3741
3742
3743
3744 MODULE = Imager         PACKAGE = Imager::FillHandle PREFIX=IFILL_
3745
3746 void
3747 IFILL_DESTROY(fill)
3748         Imager::FillHandle fill
3749
3750 int
3751 IFILL_CLONE_SKIP(...)
3752     CODE:
3753         (void)items; /* avoid unused warning for XS variable */
3754         RETVAL = 1;
3755     OUTPUT:
3756         RETVAL
3757
3758 MODULE = Imager         PACKAGE = Imager
3759
3760 Imager::FillHandle
3761 i_new_fill_solid(cl, combine)
3762         Imager::Color cl
3763         int combine
3764
3765 Imager::FillHandle
3766 i_new_fill_solidf(cl, combine)
3767         Imager::Color::Float cl
3768         int combine
3769
3770 Imager::FillHandle
3771 i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy)
3772         Imager::Color fg
3773         Imager::Color bg
3774         int combine
3775         int hatch
3776         i_img_dim dx
3777         i_img_dim dy
3778       PREINIT:
3779         unsigned char *cust_hatch;
3780         STRLEN len;
3781       CODE:
3782         if (SvOK(ST(4))) {
3783           cust_hatch = (unsigned char *)SvPV(ST(4), len);
3784         }
3785         else
3786           cust_hatch = NULL;
3787         RETVAL = i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy);
3788       OUTPUT:
3789         RETVAL
3790
3791 Imager::FillHandle
3792 i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy)
3793         Imager::Color::Float fg
3794         Imager::Color::Float bg
3795         int combine
3796         int hatch
3797         i_img_dim dx
3798         i_img_dim dy
3799       PREINIT:
3800         unsigned char *cust_hatch;
3801         STRLEN len;
3802       CODE:
3803         if (SvOK(ST(4))) {
3804           cust_hatch = (unsigned char *)SvPV(ST(4), len);
3805         }
3806         else
3807           cust_hatch = NULL;
3808         RETVAL = i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy);
3809       OUTPUT:
3810         RETVAL
3811
3812 Imager::FillHandle
3813 i_new_fill_image(src, matrix, xoff, yoff, combine)
3814         Imager::ImgRaw src
3815         i_img_dim xoff
3816         i_img_dim yoff
3817         int combine
3818       PREINIT:
3819         double matrix[9];
3820         double *matrixp;
3821         AV *av;
3822         IV len;
3823         SV *sv1;
3824         int i;
3825       CODE:
3826         if (!SvOK(ST(1))) {
3827           matrixp = NULL;
3828         }
3829         else {
3830           if (!SvROK(ST(1)) || SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3831             croak("i_new_fill_image: parameter must be an arrayref");
3832           av=(AV*)SvRV(ST(1));
3833           len=av_len(av)+1;
3834           if (len > 9)
3835             len = 9;
3836           for (i = 0; i < len; ++i) {
3837             sv1=(*(av_fetch(av,i,0)));
3838             matrix[i] = SvNV(sv1);
3839           }
3840           for (; i < 9; ++i)
3841             matrix[i] = 0;
3842           matrixp = matrix;
3843         }
3844         RETVAL = i_new_fill_image(src, matrixp, xoff, yoff, combine);
3845       OUTPUT:
3846         RETVAL
3847
3848 MODULE = Imager  PACKAGE = Imager::Internal::Hlines  PREFIX=i_int_hlines_
3849
3850 # this class is only exposed for testing
3851
3852 int
3853 i_int_hlines_testing()
3854
3855 #if i_int_hlines_testing()
3856
3857 Imager::Internal::Hlines
3858 i_int_hlines_new(start_y, count_y, start_x, count_x)
3859         i_img_dim start_y
3860         int count_y
3861         i_img_dim start_x
3862         int count_x
3863
3864 Imager::Internal::Hlines
3865 i_int_hlines_new_img(im)
3866         Imager::ImgRaw im
3867
3868 void
3869 i_int_hlines_add(hlines, y, minx, width)
3870         Imager::Internal::Hlines hlines
3871         i_img_dim y
3872         i_img_dim minx
3873         i_img_dim width
3874
3875 void
3876 i_int_hlines_DESTROY(hlines)
3877         Imager::Internal::Hlines hlines
3878
3879 SV *
3880 i_int_hlines_dump(hlines)
3881         Imager::Internal::Hlines hlines
3882
3883 int
3884 i_int_hlines_CLONE_SKIP(cls)
3885
3886 #endif
3887
3888 BOOT:
3889         PERL_SET_GLOBAL_CALLBACKS;
3890         PERL_PL_SET_GLOBAL_CALLBACKS;