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