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