Fixed i_transform2() so malloc(0) doesn't happen. Also corrected pod errors and
[imager.git] / Imager.xs
1 #ifdef __cplusplus
2 extern "C" {
3 #endif
4 #include "EXTERN.h"
5 #include "perl.h"
6 #include "XSUB.h"
7 #include "ppport.h"
8 #ifdef __cplusplus
9
10 #endif
11
12 #include "image.h"
13 #include "feat.h"
14 #include "dynaload.h"
15 #include "regmach.h"
16
17 typedef io_glue* Imager__IO;
18 typedef i_color* Imager__Color;
19 typedef i_fcolor* Imager__Color__Float;
20 typedef i_img*   Imager__ImgRaw;
21
22
23 #ifdef HAVE_LIBTT
24 typedef TT_Fonthandle* Imager__TTHandle;
25 #endif
26
27 #ifdef HAVE_FT2
28 typedef FT2_Fonthandle* Imager__Font__FT2;
29 #endif
30
31 typedef struct i_reader_data_tag
32 {
33   /* presumably a CODE ref or name of a sub */
34   SV *sv;
35 } i_reader_data;
36
37 /* used by functions that want callbacks */
38 static int read_callback(char *userdata, char *buffer, int need, int want) {
39   i_reader_data *rd = (i_reader_data *)userdata;
40   int count;
41   int result;
42   SV *data;
43   dSP; dTARG = sv_newmortal();
44   /* thanks to Simon Cozens for help with the dTARG above */
45
46   ENTER;
47   SAVETMPS;
48   EXTEND(SP, 2);
49   PUSHMARK(SP);
50   PUSHi(want);
51   PUSHi(need);
52   PUTBACK;
53
54   count = perl_call_sv(rd->sv, G_SCALAR);
55
56   SPAGAIN;
57
58   if (count != 1)
59     croak("Result of perl_call_sv(..., G_SCALAR) != 1");
60
61   data = POPs;
62
63   if (SvOK(data)) {
64     STRLEN len;
65     char *ptr = SvPV(data, len);
66     if (len > want)
67       croak("Too much data returned in reader callback");
68     
69     memcpy(buffer, ptr, len);
70     result = len;
71   }
72   else {
73     result = -1;
74   }
75
76   PUTBACK;
77   FREETMPS;
78   LEAVE;
79
80   return result;
81 }
82
83 typedef struct
84 {
85   SV *sv; /* a coderef or sub name */
86 } i_writer_data;
87
88 /* used by functions that want callbacks */
89 static int write_callback(char *userdata, char const *data, int size) {
90   i_writer_data *wd = (i_writer_data *)userdata;
91   int count;
92   int success;
93   SV *sv;
94   dSP; 
95
96   ENTER;
97   SAVETMPS;
98   EXTEND(SP, 1);
99   PUSHMARK(SP);
100   XPUSHs(sv_2mortal(newSVpv((char *)data, size)));
101   PUTBACK;
102
103   count = perl_call_sv(wd->sv, G_SCALAR);
104
105   SPAGAIN;
106
107   if (count != 1)
108     croak("Result of perl_call_sv(..., G_SCALAR) != 1");
109
110   sv = POPs;
111   success = SvTRUE(sv);
112
113
114   PUTBACK;
115   FREETMPS;
116   LEAVE;
117
118   return success;
119 }
120
121 struct value_name {
122   char *name;
123   int value;
124 };
125 static int lookup_name(struct value_name *names, int count, char *name, int def_value)
126 {
127   int i;
128   for (i = 0; i < count; ++i)
129     if (strEQ(names[i].name, name))
130       return names[i].value;
131
132   return def_value;
133 }
134 static struct value_name transp_names[] =
135 {
136   { "none", tr_none },
137   { "threshold", tr_threshold },
138   { "errdiff", tr_errdiff },
139   { "ordered", tr_ordered, },
140 };
141
142 static struct value_name make_color_names[] =
143 {
144   { "none", mc_none, },
145   { "webmap", mc_web_map, },
146   { "addi", mc_addi, },
147 };
148
149 static struct value_name translate_names[] =
150 {
151 #ifdef HAVE_LIBGIF
152   { "giflib", pt_giflib, },
153 #endif
154   { "closest", pt_closest, },
155   { "perturb", pt_perturb, },
156   { "errdiff", pt_errdiff, },
157 };
158
159 static struct value_name errdiff_names[] =
160 {
161   { "floyd", ed_floyd, },
162   { "jarvis", ed_jarvis, },
163   { "stucki", ed_stucki, },
164   { "custom", ed_custom, },
165 };
166
167 static struct value_name orddith_names[] =
168 {
169   { "random", od_random, },
170   { "dot8", od_dot8, },
171   { "dot4", od_dot4, },
172   { "hline", od_hline, },
173   { "vline", od_vline, },
174   { "/line", od_slashline, },
175   { "slashline", od_slashline, },
176   { "\\line", od_backline, },
177   { "backline", od_backline, },
178   { "tiny", od_tiny, },
179   { "custom", od_custom, },
180 };
181
182 static int
183 hv_fetch_bool(HV *hv, char *name, int def) {
184   SV **sv;
185
186   sv = hv_fetch(hv, name, strlen(name), 0);
187   if (sv && *sv) {
188     return SvTRUE(*sv);
189   }
190   else
191     return def;
192 }
193
194 static int
195 hv_fetch_int(HV *hv, char *name, int def) {
196   SV **sv;
197
198   sv = hv_fetch(hv, name, strlen(name), 0);
199   if (sv && *sv) {
200     return SvIV(*sv);
201   }
202   else
203     return def;
204 }
205
206 /* look through the hash for quantization options */
207 static void handle_quant_opts(i_quantize *quant, HV *hv)
208 {
209   /*** POSSIBLY BROKEN: do I need to unref the SV from hv_fetch ***/
210   SV **sv;
211   int i;
212   STRLEN len;
213   char *str;
214
215   sv = hv_fetch(hv, "transp", 6, 0);
216   if (sv && *sv && (str = SvPV(*sv, len))) {
217     quant->transp = 
218       lookup_name(transp_names, sizeof(transp_names)/sizeof(*transp_names), 
219                   str, tr_none);
220     if (quant->transp != tr_none) {
221       quant->tr_threshold = 127;
222       sv = hv_fetch(hv, "tr_threshold", 12, 0);
223       if (sv && *sv)
224         quant->tr_threshold = SvIV(*sv);
225     }
226     if (quant->transp == tr_errdiff) {
227       sv = hv_fetch(hv, "tr_errdiff", 10, 0);
228       if (sv && *sv && (str = SvPV(*sv, len)))
229         quant->tr_errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
230     }
231     if (quant->transp == tr_ordered) {
232       quant->tr_orddith = od_tiny;
233       sv = hv_fetch(hv, "tr_orddith", 10, 0);
234       if (sv && *sv && (str = SvPV(*sv, len)))
235         quant->tr_orddith = lookup_name(orddith_names, sizeof(orddith_names)/sizeof(*orddith_names), str, od_random);
236
237       if (quant->tr_orddith == od_custom) {
238         sv = hv_fetch(hv, "tr_map", 6, 0);
239         if (sv && *sv && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
240           AV *av = (AV*)SvRV(*sv);
241           len = av_len(av) + 1;
242           if (len > sizeof(quant->tr_custom))
243             len = sizeof(quant->tr_custom);
244           for (i = 0; i < len; ++i) {
245             SV **sv2 = av_fetch(av, i, 0);
246             if (sv2 && *sv2) {
247               quant->tr_custom[i] = SvIV(*sv2);
248             }
249           }
250           while (i < sizeof(quant->tr_custom))
251             quant->tr_custom[i++] = 0;
252         }
253       }
254     }
255   }
256   quant->make_colors = mc_addi;
257   sv = hv_fetch(hv, "make_colors", 11, 0);
258   if (sv && *sv && (str = SvPV(*sv, len))) {
259     quant->make_colors = 
260       lookup_name(make_color_names, sizeof(make_color_names)/sizeof(*make_color_names), str, mc_addi);
261   }
262   sv = hv_fetch(hv, "colors", 6, 0);
263   if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
264     /* needs to be an array of Imager::Color
265        note that the caller allocates the mc_color array and sets mc_size
266        to it's size */
267     AV *av = (AV *)SvRV(*sv);
268     quant->mc_count = av_len(av)+1;
269     if (quant->mc_count > quant->mc_size)
270       quant->mc_count = quant->mc_size;
271     for (i = 0; i < quant->mc_count; ++i) {
272       SV **sv1 = av_fetch(av, i, 0);
273       if (sv1 && *sv1 && SvROK(*sv1) && sv_derived_from(*sv1, "Imager::Color")) {
274         i_color *col = (i_color *)SvIV((SV*)SvRV(*sv1));
275         quant->mc_colors[i] = *col;
276       }
277     }
278   }
279   sv = hv_fetch(hv, "max_colors", 10, 0);
280   if (sv && *sv) {
281     i = SvIV(*sv);
282     if (i <= quant->mc_size && i >= quant->mc_count)
283       quant->mc_size = i;
284   }
285
286   quant->translate = pt_closest;
287   sv = hv_fetch(hv, "translate", 9, 0);
288   if (sv && *sv && (str = SvPV(*sv, len))) {
289     quant->translate = lookup_name(translate_names, sizeof(translate_names)/sizeof(*translate_names), str, pt_closest);
290   }
291   sv = hv_fetch(hv, "errdiff", 7, 0);
292   if (sv && *sv && (str = SvPV(*sv, len))) {
293     quant->errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
294   }
295   if (quant->translate == pt_errdiff && quant->errdiff == ed_custom) {
296     /* get the error diffusion map */
297     sv = hv_fetch(hv, "errdiff_width", 13, 0);
298     if (sv && *sv)
299       quant->ed_width = SvIV(*sv);
300     sv = hv_fetch(hv, "errdiff_height", 14, 0);
301     if (sv && *sv)
302       quant->ed_height = SvIV(*sv);
303     sv = hv_fetch(hv, "errdiff_orig", 12, 0);
304     if (sv && *sv)
305       quant->ed_orig = SvIV(*sv);
306     if (quant->ed_width > 0 && quant->ed_height > 0) {
307       int sum = 0;
308       quant->ed_map = mymalloc(sizeof(int)*quant->ed_width*quant->ed_height);
309       sv = hv_fetch(hv, "errdiff_map", 11, 0);
310       if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
311         AV *av = (AV*)SvRV(*sv);
312         len = av_len(av) + 1;
313         if (len > quant->ed_width * quant->ed_height)
314           len = quant->ed_width * quant->ed_height;
315         for (i = 0; i < len; ++i) {
316           SV **sv2 = av_fetch(av, i, 0);
317           if (sv2 && *sv2) {
318             quant->ed_map[i] = SvIV(*sv2);
319             sum += quant->ed_map[i];
320           }
321         }
322       }
323       if (!sum) {
324         /* broken map */
325         myfree(quant->ed_map);
326         quant->ed_map = 0;
327         quant->errdiff = ed_floyd;
328       }
329     }
330   }
331   sv = hv_fetch(hv, "perturb", 7, 0);
332   if (sv && *sv)
333     quant->perturb = SvIV(*sv);
334 }
335
336 /* look through the hash for options to add to opts */
337 static void handle_gif_opts(i_gif_opts *opts, HV *hv)
338 {
339   SV **sv;
340   int i;
341   /**((char *)0) = '\0';*/
342   opts->each_palette = hv_fetch_bool(hv, "gif_each_palette", 0);
343   opts->interlace = hv_fetch_bool(hv, "interlace", 0);
344
345   sv = hv_fetch(hv, "gif_delays", 10, 0);
346   if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
347     AV *av = (AV*)SvRV(*sv);
348     opts->delay_count = av_len(av)+1;
349     opts->delays = mymalloc(sizeof(int) * opts->delay_count);
350     for (i = 0; i < opts->delay_count; ++i) {
351       SV *sv1 = *av_fetch(av, i, 0);
352       opts->delays[i] = SvIV(sv1);
353     }
354   }
355   sv = hv_fetch(hv, "gif_user_input", 14, 0);
356   if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
357     AV *av = (AV*)SvRV(*sv);
358     opts->user_input_count = av_len(av)+1;
359     opts->user_input_flags = mymalloc(opts->user_input_count);
360     for (i = 0; i < opts->user_input_count; ++i) {
361       SV *sv1 = *av_fetch(av, i, 0);
362       opts->user_input_flags[i] = SvIV(sv1) != 0;
363     }
364   }
365   sv = hv_fetch(hv, "gif_disposal", 12, 0);
366   if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
367     AV *av = (AV*)SvRV(*sv);
368     opts->disposal_count = av_len(av)+1;
369     opts->disposal = mymalloc(opts->disposal_count);
370     for (i = 0; i < opts->disposal_count; ++i) {
371       SV *sv1 = *av_fetch(av, i, 0);
372       opts->disposal[i] = SvIV(sv1);
373     }
374   }
375   sv = hv_fetch(hv, "gif_tran_color", 14, 0);
376   if (sv && *sv && SvROK(*sv) && sv_derived_from(*sv, "Imager::Color")) {
377     i_color *col = (i_color *)SvIV((SV *)SvRV(*sv));
378     opts->tran_color = *col;
379   }
380   sv = hv_fetch(hv, "gif_positions", 13, 0);
381   if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
382     AV *av = (AV *)SvRV(*sv);
383     opts->position_count = av_len(av) + 1;
384     opts->positions = mymalloc(sizeof(i_gif_pos) * opts->position_count);
385     for (i = 0; i < opts->position_count; ++i) {
386       SV **sv2 = av_fetch(av, i, 0);
387       opts->positions[i].x = opts->positions[i].y = 0;
388       if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
389         AV *av2 = (AV*)SvRV(*sv2);
390         SV **sv3;
391         sv3 = av_fetch(av2, 0, 0);
392         if (sv3 && *sv3)
393           opts->positions[i].x = SvIV(*sv3);
394         sv3 = av_fetch(av2, 1, 0);
395         if (sv3 && *sv3)
396           opts->positions[i].y = SvIV(*sv3);
397       }
398     }
399   }
400   /* Netscape2.0 loop count extension */
401   opts->loop_count = hv_fetch_int(hv, "gif_loop_count", 0);
402
403   opts->eliminate_unused = hv_fetch_bool(hv, "gif_eliminate_unused", 1);
404 }
405
406 /* copies the color map from the hv into the colors member of the HV */
407 static void copy_colors_back(HV *hv, i_quantize *quant) {
408   SV **sv;
409   AV *av;
410   int i;
411   SV *work;
412
413   sv = hv_fetch(hv, "colors", 6, 0);
414   if (!sv || !*sv || !SvROK(*sv) || SvTYPE(SvRV(*sv)) != SVt_PVAV) {
415     SV *ref;
416     av = newAV();
417     ref = newRV_inc((SV*) av);
418     sv = hv_store(hv, "colors", 6, ref, 0);
419   }
420   else {
421     av = (AV *)SvRV(*sv);
422   }
423   av_extend(av, quant->mc_count+1);
424   for (i = 0; i < quant->mc_count; ++i) {
425     i_color *in = quant->mc_colors+i;
426     Imager__Color c = ICL_new_internal(in->rgb.r, in->rgb.g, in->rgb.b, 255);
427     work = sv_newmortal();
428     sv_setref_pv(work, "Imager::Color", (void *)c);
429     SvREFCNT_inc(work);
430     if (!av_store(av, i, work)) {
431       SvREFCNT_dec(work);
432     }
433   }
434 }
435
436 /* loads the segments of a fountain fill into an array */
437 i_fountain_seg *load_fount_segs(AV *asegs, int *count) {
438   /* Each element of segs must contain:
439      [ start, middle, end, c0, c1, segtype, colortrans ]
440      start, middle, end are doubles from 0 to 1
441      c0, c1 are Imager::Color::Float or Imager::Color objects
442      segtype, colortrans are ints
443   */
444   int i, j;
445   AV *aseg;
446   SV *sv;
447   i_fountain_seg *segs;
448   double work[3];
449   int worki[2];
450
451   *count = av_len(asegs)+1;
452   if (*count < 1) 
453     croak("i_fountain must have at least one segment");
454   segs = mymalloc(sizeof(i_fountain_seg) * *count);
455   for(i = 0; i < *count; i++) {
456     SV **sv1 = av_fetch(asegs, i, 0);
457     if (!sv1 || !*sv1 || !SvROK(*sv1) 
458         || SvTYPE(SvRV(*sv1)) != SVt_PVAV) {
459       myfree(segs);
460       croak("i_fountain: segs must be an arrayref of arrayrefs");
461     }
462     aseg = (AV *)SvRV(*sv1);
463     if (av_len(aseg) != 7-1) {
464       myfree(segs);
465       croak("i_fountain: a segment must have 7 members");
466     }
467     for (j = 0; j < 3; ++j) {
468       SV **sv2 = av_fetch(aseg, j, 0);
469       if (!sv2 || !*sv2) {
470         myfree(segs);
471         croak("i_fountain: XS error");
472       }
473       work[j] = SvNV(*sv2);
474     }
475     segs[i].start  = work[0];
476     segs[i].middle = work[1];
477     segs[i].end    = work[2];
478     for (j = 0; j < 2; ++j) {
479       SV **sv3 = av_fetch(aseg, 3+j, 0);
480       if (!sv3 || !*sv3 || !SvROK(*sv3) ||
481           (!sv_derived_from(*sv3, "Imager::Color")
482            && !sv_derived_from(*sv3, "Imager::Color::Float"))) {
483         myfree(segs);
484         croak("i_fountain: segs must contain colors in elements 3 and 4");
485       }
486       if (sv_derived_from(*sv3, "Imager::Color::Float")) {
487         segs[i].c[j] = *(i_fcolor *)SvIV((SV *)SvRV(*sv3));
488       }
489       else {
490         i_color c = *(i_color *)SvIV((SV *)SvRV(*sv3));
491         int ch;
492         for (ch = 0; ch < MAXCHANNELS; ++ch) {
493           segs[i].c[j].channel[ch] = c.channel[ch] / 255.0;
494         }
495       }
496     }
497     for (j = 0; j < 2; ++j) {
498       SV **sv2 = av_fetch(aseg, j+5, 0);
499       if (!sv2 || !*sv2) {
500         myfree(segs);
501         croak("i_fountain: XS error");
502       }
503       worki[j] = SvIV(*sv2);
504     }
505     segs[i].type = worki[0];
506     segs[i].color = worki[1];
507   }
508
509   return segs;
510 }
511
512 /* I don't think ICLF_* names belong at the C interface
513    this makes the XS code think we have them, to let us avoid 
514    putting function bodies in the XS code
515 */
516 #define ICLF_new_internal(r, g, b, a) i_fcolor_new((r), (g), (b), (a))
517 #define ICLF_DESTROY(cl) i_fcolor_destroy(cl)
518
519 /* for the fill objects
520    Since a fill object may later have dependent images, (or fills!)
521    we need perl wrappers - oh well
522 */
523 #define IFILL_DESTROY(fill) i_fill_destroy(fill);
524 typedef i_fill_t* Imager__FillHandle;
525
526 MODULE = Imager         PACKAGE = Imager::Color PREFIX = ICL_
527
528 Imager::Color
529 ICL_new_internal(r,g,b,a)
530                unsigned char     r
531                unsigned char     g
532                unsigned char     b
533                unsigned char     a
534
535 void
536 ICL_DESTROY(cl)
537                Imager::Color    cl
538
539
540 void
541 ICL_set_internal(cl,r,g,b,a)
542                Imager::Color    cl
543                unsigned char     r
544                unsigned char     g
545                unsigned char     b
546                unsigned char     a
547            PPCODE:
548                ICL_set_internal(cl, r, g, b, a);
549                EXTEND(SP, 1);
550                PUSHs(ST(0));
551
552 void
553 ICL_info(cl)
554                Imager::Color    cl
555
556
557 void
558 ICL_rgba(cl)
559               Imager::Color     cl
560             PPCODE:
561                 EXTEND(SP, 4);
562                 PUSHs(sv_2mortal(newSVnv(cl->rgba.r)));
563                 PUSHs(sv_2mortal(newSVnv(cl->rgba.g)));
564                 PUSHs(sv_2mortal(newSVnv(cl->rgba.b)));
565                 PUSHs(sv_2mortal(newSVnv(cl->rgba.a)));
566
567 Imager::Color
568 i_hsv_to_rgb(c)
569         Imager::Color c
570       CODE:
571         RETVAL = mymalloc(sizeof(i_color));
572         *RETVAL = *c;
573         i_hsv_to_rgb(RETVAL);
574       OUTPUT:
575         RETVAL
576         
577 Imager::Color
578 i_rgb_to_hsv(c)
579         Imager::Color c
580       CODE:
581         RETVAL = mymalloc(sizeof(i_color));
582         *RETVAL = *c;
583         i_rgb_to_hsv(RETVAL);
584       OUTPUT:
585         RETVAL
586         
587
588
589 MODULE = Imager        PACKAGE = Imager::Color::Float  PREFIX=ICLF_
590
591 Imager::Color::Float
592 ICLF_new_internal(r, g, b, a)
593         double r
594         double g
595         double b
596         double a
597
598 void
599 ICLF_DESTROY(cl)
600         Imager::Color::Float    cl
601
602 void
603 ICLF_rgba(cl)
604         Imager::Color::Float    cl
605       PREINIT:
606         int ch;
607       PPCODE:
608         EXTEND(SP, MAXCHANNELS);
609         for (ch = 0; ch < MAXCHANNELS; ++ch) {
610         /* printf("%d: %g\n", ch, cl->channel[ch]); */
611           PUSHs(sv_2mortal(newSVnv(cl->channel[ch])));
612         }
613
614 void
615 ICLF_set_internal(cl,r,g,b,a)
616         Imager::Color::Float    cl
617         double     r
618         double     g
619         double     b
620         double     a
621       PPCODE:
622         cl->rgba.r = r;
623         cl->rgba.g = g;
624         cl->rgba.b = b;
625         cl->rgba.a = a;                
626         EXTEND(SP, 1);
627         PUSHs(ST(0));
628
629 Imager::Color::Float
630 i_hsv_to_rgb(c)
631         Imager::Color::Float c
632       CODE:
633         RETVAL = mymalloc(sizeof(i_fcolor));
634         *RETVAL = *c;
635         i_hsv_to_rgbf(RETVAL);
636       OUTPUT:
637         RETVAL
638         
639 Imager::Color::Float
640 i_rgb_to_hsv(c)
641         Imager::Color::Float c
642       CODE:
643         RETVAL = mymalloc(sizeof(i_fcolor));
644         *RETVAL = *c;
645         i_rgb_to_hsvf(RETVAL);
646       OUTPUT:
647         RETVAL
648         
649
650 MODULE = Imager         PACKAGE = Imager::ImgRaw        PREFIX = IIM_
651
652 Imager::ImgRaw
653 IIM_new(x,y,ch)
654                int     x
655                int     y
656                int     ch
657
658 void
659 IIM_DESTROY(im)
660                Imager::ImgRaw    im
661
662
663
664 MODULE = Imager         PACKAGE = Imager
665
666 PROTOTYPES: ENABLE
667
668
669 Imager::IO
670 io_new_fd(fd)
671                          int     fd
672
673 Imager::IO
674 io_new_bufchain()
675
676
677 void
678 io_slurp(ig)
679         Imager::IO     ig
680              PREINIT:
681               unsigned char*    data;
682              size_t    tlength;
683                 SV*    r;
684              PPCODE:
685               data    = NULL;
686               tlength = io_slurp(ig, &data);
687               r = sv_newmortal();
688               EXTEND(SP,1);
689               PUSHs(sv_2mortal(newSVpv(data,tlength)));
690               myfree(data);
691
692
693 MODULE = Imager         PACKAGE = Imager::IO    PREFIX = io_glue_
694
695 void
696 io_glue_DESTROY(ig)
697         Imager::IO     ig
698
699
700 MODULE = Imager         PACKAGE = Imager
701
702 PROTOTYPES: ENABLE
703
704
705
706 void
707 i_list_formats()
708              PREINIT:
709               char*    item;
710                int     i;
711              PPCODE:
712                i=0;
713                while( (item=i_format_list[i++]) != NULL ) {
714                       EXTEND(SP, 1);
715                       PUSHs(sv_2mortal(newSVpv(item,0)));
716                }
717
718 undef_int
719 i_has_format(frmt)
720               char*    frmt
721
722 Imager::ImgRaw
723 i_img_new()
724
725 Imager::ImgRaw
726 i_img_empty(im,x,y)
727     Imager::ImgRaw     im
728                int     x
729                int     y
730
731 Imager::ImgRaw
732 i_img_empty_ch(im,x,y,ch)
733     Imager::ImgRaw     im
734                int     x
735                int     y
736                int     ch
737
738 void
739 init_log(name,level)
740               char*    name
741                int     level
742
743 void
744 i_img_exorcise(im)
745     Imager::ImgRaw     im
746
747 void
748 i_img_destroy(im)
749     Imager::ImgRaw     im
750
751 void
752 i_img_info(im)
753     Imager::ImgRaw     im
754              PREINIT:
755                int     info[4];
756              PPCODE:
757                i_img_info(im,info);
758                EXTEND(SP, 4);
759                PUSHs(sv_2mortal(newSViv(info[0])));
760                PUSHs(sv_2mortal(newSViv(info[1])));
761                PUSHs(sv_2mortal(newSViv(info[2])));
762                PUSHs(sv_2mortal(newSViv(info[3])));
763
764
765
766
767 void
768 i_img_setmask(im,ch_mask)
769     Imager::ImgRaw     im
770                int     ch_mask
771
772 int
773 i_img_getmask(im)
774     Imager::ImgRaw     im
775
776 int
777 i_img_getchannels(im)
778     Imager::ImgRaw     im
779
780 void
781 i_img_getdata(im)
782     Imager::ImgRaw     im
783              PPCODE:
784                EXTEND(SP, 1);
785                PUSHs(im->idata ? sv_2mortal(newSVpv(im->idata, im->bytes)) 
786                      : &PL_sv_undef);
787
788
789 void
790 i_draw(im,x1,y1,x2,y2,val)
791     Imager::ImgRaw     im
792                int     x1
793                int     y1
794                int     x2
795                int     y2
796      Imager::Color     val
797
798 void
799 i_line_aa(im,x1,y1,x2,y2,val)
800     Imager::ImgRaw     im
801                int     x1
802                int     y1
803                int     x2
804                int     y2
805      Imager::Color     val
806
807 void
808 i_box(im,x1,y1,x2,y2,val)
809     Imager::ImgRaw     im
810                int     x1
811                int     y1
812                int     x2
813                int     y2
814      Imager::Color     val
815
816 void
817 i_box_filled(im,x1,y1,x2,y2,val)
818     Imager::ImgRaw     im
819                int     x1
820                int     y1
821                int     x2
822                int     y2
823            Imager::Color    val
824
825 void
826 i_box_cfill(im,x1,y1,x2,y2,fill)
827     Imager::ImgRaw     im
828                int     x1
829                int     y1
830                int     x2
831                int     y2
832            Imager::FillHandle    fill
833
834 void
835 i_arc(im,x,y,rad,d1,d2,val)
836     Imager::ImgRaw     im
837                int     x
838                int     y
839              float     rad
840              float     d1
841              float     d2
842            Imager::Color    val
843
844 void
845 i_arc_cfill(im,x,y,rad,d1,d2,fill)
846     Imager::ImgRaw     im
847                int     x
848                int     y
849              float     rad
850              float     d1
851              float     d2
852            Imager::FillHandle    fill
853
854
855
856 void
857 i_circle_aa(im,x,y,rad,val)
858     Imager::ImgRaw     im
859              float     x
860              float     y
861              float     rad
862            Imager::Color    val
863
864
865
866 void
867 i_bezier_multi(im,xc,yc,val)
868     Imager::ImgRaw     im
869              Imager::Color  val
870              PREINIT:
871              double   *x,*y;
872              int       len;
873              AV       *av1;
874              AV       *av2;
875              SV       *sv1;
876              SV       *sv2;
877              int i;
878              PPCODE:
879              ICL_info(val);
880              if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
881              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
882              if (!SvROK(ST(2))) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
883              if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
884              av1=(AV*)SvRV(ST(1));
885              av2=(AV*)SvRV(ST(2));
886              if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_bezier_multi must be equal length\n");
887              len=av_len(av1)+1;
888              x=mymalloc( len*sizeof(double) );
889              y=mymalloc( len*sizeof(double) );
890              for(i=0;i<len;i++) {
891                sv1=(*(av_fetch(av1,i,0)));
892                sv2=(*(av_fetch(av2,i,0)));
893                x[i]=(double)SvNV(sv1);
894                y[i]=(double)SvNV(sv2);
895              }
896              i_bezier_multi(im,len,x,y,val);
897              myfree(x);
898              myfree(y);
899
900
901 void
902 i_poly_aa(im,xc,yc,val)
903     Imager::ImgRaw     im
904              Imager::Color  val
905              PREINIT:
906              double   *x,*y;
907              int       len;
908              AV       *av1;
909              AV       *av2;
910              SV       *sv1;
911              SV       *sv2;
912              int i;
913              PPCODE:
914              ICL_info(val);
915              if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
916              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
917              if (!SvROK(ST(2))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
918              if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
919              av1=(AV*)SvRV(ST(1));
920              av2=(AV*)SvRV(ST(2));
921              if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_poly_aa must be equal length\n");
922              len=av_len(av1)+1;
923              x=mymalloc( len*sizeof(double) );
924              y=mymalloc( len*sizeof(double) );
925              for(i=0;i<len;i++) {
926                sv1=(*(av_fetch(av1,i,0)));
927                sv2=(*(av_fetch(av2,i,0)));
928                x[i]=(double)SvNV(sv1);
929                y[i]=(double)SvNV(sv2);
930              }
931              i_poly_aa(im,len,x,y,val);
932              myfree(x);
933              myfree(y);
934
935
936
937 void
938 i_flood_fill(im,seedx,seedy,dcol)
939     Imager::ImgRaw     im
940                int     seedx
941                int     seedy
942      Imager::Color     dcol
943
944 void
945 i_flood_cfill(im,seedx,seedy,fill)
946     Imager::ImgRaw     im
947                int     seedx
948                int     seedy
949      Imager::FillHandle     fill
950
951
952 void
953 i_copyto(im,src,x1,y1,x2,y2,tx,ty)
954     Imager::ImgRaw     im
955     Imager::ImgRaw     src
956                int     x1
957                int     y1
958                int     x2
959                int     y2
960                int     tx
961                int     ty
962
963
964 void
965 i_copyto_trans(im,src,x1,y1,x2,y2,tx,ty,trans)
966     Imager::ImgRaw     im
967     Imager::ImgRaw     src
968                int     x1
969                int     y1
970                int     x2
971                int     y2
972                int     tx
973                int     ty
974      Imager::Color     trans
975
976 void
977 i_copy(im,src)
978     Imager::ImgRaw     im
979     Imager::ImgRaw     src
980
981
982 undef_int
983 i_rubthru(im,src,tx,ty)
984     Imager::ImgRaw     im
985     Imager::ImgRaw     src
986                int     tx
987                int     ty
988
989 undef_int
990 i_flipxy(im, direction)
991     Imager::ImgRaw     im
992                int     direction
993
994 Imager::ImgRaw
995 i_rotate90(im, degrees)
996     Imager::ImgRaw      im
997                int      degrees
998
999 Imager::ImgRaw
1000 i_rotate_exact(im, amount)
1001     Imager::ImgRaw      im
1002             double      amount
1003
1004 Imager::ImgRaw
1005 i_matrix_transform(im, xsize, ysize, matrix)
1006     Imager::ImgRaw      im
1007                int      xsize
1008                int      ysize
1009       PREINIT:
1010         double matrix[9];
1011         AV *av;
1012         IV len;
1013         SV *sv1;
1014         int i;
1015       CODE:
1016         if (!SvROK(ST(3)) || SvTYPE(SvRV(ST(3))) != SVt_PVAV)
1017           croak("i_matrix_transform: parameter 4 must be an array ref\n");
1018         av=(AV*)SvRV(ST(3));
1019         len=av_len(av)+1;
1020         if (len > 9)
1021           len = 9;
1022         for (i = 0; i < len; ++i) {
1023           sv1=(*(av_fetch(av,i,0)));
1024           matrix[i] = SvNV(sv1);
1025         }
1026         for (; i < 9; ++i)
1027           matrix[i] = 0;
1028         RETVAL = i_matrix_transform(im, xsize, ysize, matrix);        
1029       OUTPUT:
1030         RETVAL
1031
1032 void
1033 i_gaussian(im,stdev)
1034     Imager::ImgRaw     im
1035              float     stdev
1036
1037 void
1038 i_unsharp_mask(im,stdev,scale)
1039     Imager::ImgRaw     im
1040              float     stdev
1041              double    scale
1042
1043 void
1044 i_conv(im,pcoef)
1045     Imager::ImgRaw     im
1046              PREINIT:
1047              float*    coeff;
1048              int     len;
1049              AV* av;
1050              SV* sv1;
1051              int i;
1052              PPCODE:
1053              if (!SvROK(ST(1))) croak("Imager: Parameter 1 must be a reference to an array\n");
1054              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 must be a reference to an array\n");
1055              av=(AV*)SvRV(ST(1));
1056              len=av_len(av)+1;
1057              coeff=mymalloc( len*sizeof(float) );
1058              for(i=0;i<len;i++) {
1059                sv1=(*(av_fetch(av,i,0)));
1060                coeff[i]=(float)SvNV(sv1);
1061              }
1062              i_conv(im,coeff,len);
1063              myfree(coeff);
1064
1065 undef_int
1066 i_convert(im, src, coeff)
1067     Imager::ImgRaw     im
1068     Imager::ImgRaw     src
1069         PREINIT:
1070           float *coeff;
1071           int outchan;
1072           int inchan;
1073           AV *avmain;
1074           SV **temp;
1075           SV *svsub;
1076           AV *avsub;
1077           int len;
1078           int i, j;
1079         CODE:
1080           if (!SvROK(ST(2)) || SvTYPE(SvRV(ST(2))) != SVt_PVAV)
1081             croak("i_convert: parameter 3 must be an arrayref\n");
1082           avmain = (AV*)SvRV(ST(2));
1083           outchan = av_len(avmain)+1;
1084           /* find the biggest */
1085           inchan = 0;
1086           for (j=0; j < outchan; ++j) {
1087             temp = av_fetch(avmain, j, 0);
1088             if (temp && SvROK(*temp) && SvTYPE(SvRV(*temp)) == SVt_PVAV) {
1089               avsub = (AV*)SvRV(*temp);
1090               len = av_len(avsub)+1;
1091               if (len > inchan)
1092                 inchan = len;
1093             }
1094           }
1095           coeff = mymalloc(sizeof(float) * outchan * inchan);
1096           for (j = 0; j < outchan; ++j) {
1097             avsub = (AV*)SvRV(*av_fetch(avmain, j, 0));
1098             len = av_len(avsub)+1;
1099             for (i = 0; i < len; ++i) {
1100               temp = av_fetch(avsub, i, 0);
1101               if (temp)
1102                 coeff[i+j*inchan] = SvNV(*temp);
1103               else
1104                 coeff[i+j*inchan] = 0;
1105             }
1106             while (i < inchan)
1107               coeff[i++ + j*inchan] = 0;
1108           }
1109           RETVAL = i_convert(im, src, coeff, outchan, inchan);
1110           myfree(coeff);
1111         OUTPUT:
1112           RETVAL
1113
1114
1115 void
1116 i_map(im, pmaps)
1117     Imager::ImgRaw     im
1118         PREINIT:
1119           unsigned int mask = 0;
1120           AV *avmain;
1121           AV *avsub;
1122           SV **temp;
1123           int len;
1124           int i, j;
1125           unsigned char (*maps)[256];
1126         CODE:
1127           if (!SvROK(ST(1)) || SvTYPE(SvRV(ST(1))) != SVt_PVAV)
1128             croak("i_map: parameter 2 must be an arrayref\n");
1129           avmain = (AV*)SvRV(ST(1));
1130           len = av_len(avmain)+1;
1131           if (im->channels < len) len = im->channels;
1132
1133           maps = mymalloc( len * sizeof(unsigned char [256]) );
1134
1135           for (j=0; j<len ; j++) {
1136             temp = av_fetch(avmain, j, 0);
1137             if (temp && SvROK(*temp) && (SvTYPE(SvRV(*temp)) == SVt_PVAV) ) {
1138               avsub = (AV*)SvRV(*temp);
1139               if(av_len(avsub) != 255) continue;
1140               mask |= 1<<j;
1141               for (i=0; i<256 ; i++) {
1142                 int val;
1143                 temp = av_fetch(avsub, i, 0);
1144                 val = temp ? SvIV(*temp) : 0;
1145                 if (val<0) val = 0;
1146                 if (val>255) val = 255;
1147                 maps[j][i] = val;
1148               }
1149             }
1150           }
1151           i_map(im, maps, mask);
1152           myfree(maps);
1153
1154
1155
1156 float
1157 i_img_diff(im1,im2)
1158     Imager::ImgRaw     im1
1159     Imager::ImgRaw     im2
1160
1161
1162
1163 undef_int         
1164 i_init_fonts()
1165
1166 #ifdef HAVE_LIBT1
1167
1168 void
1169 i_t1_set_aa(st)
1170                int     st
1171
1172 int
1173 i_t1_new(pfb,afm=NULL)
1174               char*    pfb
1175               char*    afm
1176
1177 int
1178 i_t1_destroy(font_id)
1179                int     font_id
1180
1181
1182 undef_int
1183 i_t1_cp(im,xb,yb,channel,fontnum,points,str,len,align)
1184     Imager::ImgRaw     im
1185                int     xb
1186                int     yb
1187                int     channel
1188                int     fontnum
1189              float     points
1190               char*    str
1191                int     len
1192                int     align
1193
1194 void
1195 i_t1_bbox(fontnum,point,str,len)
1196                int     fontnum
1197              float     point
1198               char*    str
1199                int     len
1200              PREINIT:
1201                int     cords[6];
1202              PPCODE:
1203                i_t1_bbox(fontnum,point,str,len,cords);
1204                EXTEND(SP, 4);
1205                PUSHs(sv_2mortal(newSViv(cords[0])));
1206                PUSHs(sv_2mortal(newSViv(cords[1])));
1207                PUSHs(sv_2mortal(newSViv(cords[2])));
1208                PUSHs(sv_2mortal(newSViv(cords[3])));
1209                PUSHs(sv_2mortal(newSViv(cords[4])));
1210                PUSHs(sv_2mortal(newSViv(cords[5])));
1211
1212
1213
1214 undef_int
1215 i_t1_text(im,xb,yb,cl,fontnum,points,str,len,align)
1216     Imager::ImgRaw     im
1217                int     xb
1218                int     yb
1219      Imager::Color    cl
1220                int     fontnum
1221              float     points
1222               char*    str
1223                int     len
1224                int     align
1225
1226 #endif 
1227
1228 #ifdef HAVE_LIBTT
1229
1230
1231 Imager::TTHandle
1232 i_tt_new(fontname)
1233               char*     fontname
1234
1235 void
1236 i_tt_destroy(handle)
1237      Imager::TTHandle    handle
1238
1239
1240
1241 undef_int
1242 i_tt_text(handle,im,xb,yb,cl,points,str,len,smooth)
1243   Imager::TTHandle     handle
1244     Imager::ImgRaw     im
1245                int     xb
1246                int     yb
1247      Imager::Color     cl
1248              float     points
1249               char*    str
1250                int     len
1251                int     smooth
1252
1253
1254 undef_int
1255 i_tt_cp(handle,im,xb,yb,channel,points,str,len,smooth)
1256   Imager::TTHandle     handle
1257     Imager::ImgRaw     im
1258                int     xb
1259                int     yb
1260                int     channel
1261              float     points
1262               char*    str
1263                int     len
1264                int     smooth
1265
1266
1267
1268 undef_int
1269 i_tt_bbox(handle,point,str,len)
1270   Imager::TTHandle     handle
1271              float     point
1272               char*    str
1273                int     len
1274              PREINIT:
1275                int     cords[6],rc;
1276              PPCODE:
1277                if ((rc=i_tt_bbox(handle,point,str,len,cords))) {
1278                  EXTEND(SP, 4);
1279                  PUSHs(sv_2mortal(newSViv(cords[0])));
1280                  PUSHs(sv_2mortal(newSViv(cords[1])));
1281                  PUSHs(sv_2mortal(newSViv(cords[2])));
1282                  PUSHs(sv_2mortal(newSViv(cords[3])));
1283                  PUSHs(sv_2mortal(newSViv(cords[4])));
1284                  PUSHs(sv_2mortal(newSViv(cords[5])));
1285                }
1286
1287
1288 #endif 
1289
1290
1291
1292
1293 #ifdef HAVE_LIBJPEG
1294 undef_int
1295 i_writejpeg_wiol(im, ig, qfactor)
1296     Imager::ImgRaw     im
1297         Imager::IO     ig
1298                int     qfactor
1299
1300
1301 void
1302 i_readjpeg_wiol(ig)
1303         Imager::IO     ig
1304              PREINIT:
1305               char*    iptc_itext;
1306                int     tlength;
1307              i_img*    rimg;
1308                 SV*    r;
1309              PPCODE:
1310               iptc_itext = NULL;
1311               rimg = i_readjpeg_wiol(ig,-1,&iptc_itext,&tlength);
1312               if (iptc_itext == NULL) {
1313                     r = sv_newmortal();
1314                     EXTEND(SP,1);
1315                     sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1316                     PUSHs(r);
1317               } else {
1318                     r = sv_newmortal();
1319                     EXTEND(SP,2);
1320                     sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1321                     PUSHs(r);
1322                     PUSHs(sv_2mortal(newSVpv(iptc_itext,tlength)));
1323                     myfree(iptc_itext);
1324               }
1325
1326
1327 #endif
1328
1329
1330
1331
1332 #ifdef HAVE_LIBTIFF
1333
1334 Imager::ImgRaw
1335 i_readtiff_wiol(ig, length)
1336         Imager::IO     ig
1337                int     length
1338
1339
1340 undef_int
1341 i_writetiff_wiol(im, ig)
1342     Imager::ImgRaw     im
1343         Imager::IO     ig
1344
1345 undef_int
1346 i_writetiff_wiol_faxable(im, ig, fine)
1347     Imager::ImgRaw     im
1348         Imager::IO     ig
1349                int     fine
1350
1351
1352 #endif /* HAVE_LIBTIFF */
1353
1354
1355
1356
1357
1358 #ifdef HAVE_LIBPNG
1359
1360 Imager::ImgRaw
1361 i_readpng_wiol(ig, length)
1362         Imager::IO     ig
1363                int     length
1364
1365
1366 undef_int
1367 i_writepng_wiol(im, ig)
1368     Imager::ImgRaw     im
1369         Imager::IO     ig
1370
1371
1372 #endif
1373
1374
1375 #ifdef HAVE_LIBGIF
1376
1377 void
1378 i_giflib_version()
1379         PPCODE:
1380           PUSHs(sv_2mortal(newSVnv(IM_GIFMAJOR+IM_GIFMINOR*0.1)));
1381
1382 undef_int
1383 i_writegif(im,fd,colors,pixdev,fixed)
1384     Imager::ImgRaw     im
1385                int     fd
1386                int     colors
1387                int     pixdev
1388              PREINIT:
1389              int     fixedlen;
1390              Imager__Color  fixed;
1391              Imager__Color  tmp;
1392              AV* av;
1393              SV* sv1;
1394              IV  Itmp;
1395              int i;
1396              CODE:
1397              if (!SvROK(ST(4))) croak("Imager: Parameter 4 must be a reference to an array\n");
1398              if (SvTYPE(SvRV(ST(4))) != SVt_PVAV) croak("Imager: Parameter 4 must be a reference to an array\n");
1399              av=(AV*)SvRV(ST(4));
1400              fixedlen=av_len(av)+1;
1401              fixed=mymalloc( fixedlen*sizeof(i_color) );
1402              for(i=0;i<fixedlen;i++) {
1403                sv1=(*(av_fetch(av,i,0)));
1404                if (sv_derived_from(sv1, "Imager::Color")) {
1405                  Itmp = SvIV((SV*)SvRV(sv1));
1406                  tmp = (i_color*) Itmp;
1407                } else croak("Imager: one of the elements of array ref is not of Imager::Color type\n");
1408                fixed[i]=*tmp;
1409              }
1410              RETVAL=i_writegif(im,fd,colors,pixdev,fixedlen,fixed);
1411              myfree(fixed);
1412              ST(0) = sv_newmortal();
1413              if (RETVAL == 0) ST(0)=&PL_sv_undef;
1414              else sv_setiv(ST(0), (IV)RETVAL);
1415
1416
1417
1418
1419 undef_int
1420 i_writegifmc(im,fd,colors)
1421     Imager::ImgRaw    im
1422                int     fd
1423                int     colors
1424
1425
1426 undef_int
1427 i_writegif_gen(fd, ...)
1428                int     fd
1429       PROTOTYPE: $$@
1430       PREINIT:
1431         i_quantize quant;
1432         i_gif_opts opts;
1433         i_img **imgs = NULL;
1434         int img_count;
1435         int i;
1436         HV *hv;
1437       CODE:
1438         if (items < 3)
1439             croak("Usage: i_writegif_gen(fd,hashref, images...)");
1440         if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
1441             croak("i_writegif_gen: Second argument must be a hash ref");
1442         hv = (HV *)SvRV(ST(1));
1443         memset(&quant, 0, sizeof(quant));
1444         quant.mc_size = 256;
1445         quant.mc_colors = mymalloc(quant.mc_size * sizeof(i_color));
1446         memset(&opts, 0, sizeof(opts));
1447         handle_quant_opts(&quant, hv);
1448         handle_gif_opts(&opts, hv);
1449         img_count = items - 2;
1450         RETVAL = 1;
1451         if (img_count < 1) {
1452           RETVAL = 0;
1453           i_clear_error();
1454           i_push_error(0, "You need to specify images to save");
1455         }
1456         else {
1457           imgs = mymalloc(sizeof(i_img *) * img_count);
1458           for (i = 0; i < img_count; ++i) {
1459             SV *sv = ST(2+i);
1460             imgs[i] = NULL;
1461             if (SvROK(sv) && sv_derived_from(sv, "Imager::ImgRaw")) {
1462               imgs[i] = (i_img *)SvIV((SV*)SvRV(sv));
1463             }
1464             else {
1465               i_clear_error();
1466               i_push_error(0, "Only images can be saved");
1467               RETVAL = 0;
1468               break;
1469             }
1470           }
1471           if (RETVAL) {
1472             RETVAL = i_writegif_gen(&quant, fd, imgs, img_count, &opts);
1473           }
1474           myfree(imgs);
1475           if (RETVAL) {
1476             copy_colors_back(hv, &quant);
1477           }
1478         }
1479              ST(0) = sv_newmortal();
1480              if (RETVAL == 0) ST(0)=&PL_sv_undef;
1481              else sv_setiv(ST(0), (IV)RETVAL);
1482
1483 undef_int
1484 i_writegif_callback(cb, maxbuffer,...)
1485         int maxbuffer;
1486       PREINIT:
1487         i_quantize quant;
1488         i_gif_opts opts;
1489         i_img **imgs = NULL;
1490         int img_count;
1491         int i;
1492         HV *hv;
1493         i_writer_data wd;
1494       CODE:
1495         if (items < 4)
1496             croak("Usage: i_writegif_callback(\\&callback,maxbuffer,hashref, images...)");
1497         if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
1498             croak("i_writegif_callback: Second argument must be a hash ref");
1499         hv = (HV *)SvRV(ST(2));
1500         memset(&quant, 0, sizeof(quant));
1501         quant.mc_size = 256;
1502         quant.mc_colors = mymalloc(quant.mc_size * sizeof(i_color));
1503         memset(&opts, 0, sizeof(opts));
1504         handle_quant_opts(&quant, hv);
1505         handle_gif_opts(&opts, hv);
1506         img_count = items - 3;
1507         RETVAL = 1;
1508         if (img_count < 1) {
1509           RETVAL = 0;
1510         }
1511         else {
1512           imgs = mymalloc(sizeof(i_img *) * img_count);
1513           for (i = 0; i < img_count; ++i) {
1514             SV *sv = ST(3+i);
1515             imgs[i] = NULL;
1516             if (SvROK(sv) && sv_derived_from(sv, "Imager::ImgRaw")) {
1517               imgs[i] = (i_img *)SvIV((SV*)SvRV(sv));
1518             }
1519             else {
1520               RETVAL = 0;
1521               break;
1522             }
1523           }
1524           if (RETVAL) {
1525             wd.sv = ST(0);
1526             RETVAL = i_writegif_callback(&quant, write_callback, (char *)&wd, maxbuffer, imgs, img_count, &opts);
1527           }
1528           myfree(imgs);
1529           if (RETVAL) {
1530             copy_colors_back(hv, &quant);
1531           }
1532         }
1533              ST(0) = sv_newmortal();
1534              if (RETVAL == 0) ST(0)=&PL_sv_undef;
1535              else sv_setiv(ST(0), (IV)RETVAL);
1536
1537 void
1538 i_readgif(fd)
1539                int     fd
1540               PREINIT:
1541                 int*    colour_table;
1542                 int     colours, q, w;
1543               i_img*    rimg;
1544                  SV*    temp[3];
1545                  AV*    ct; 
1546                  SV*    r;
1547                PPCODE:
1548                colour_table = NULL;
1549                colours = 0;
1550
1551         if(GIMME_V == G_ARRAY) {
1552             rimg = i_readgif(fd,&colour_table,&colours);
1553         } else {
1554             /* don't waste time with colours if they aren't wanted */
1555             rimg = i_readgif(fd,NULL,NULL);
1556         }
1557         
1558         if (colour_table == NULL) {
1559             EXTEND(SP,1);
1560             r=sv_newmortal();
1561             sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1562             PUSHs(r);
1563         } else {
1564             /* the following creates an [[r,g,b], [r, g, b], [r, g, b]...] */
1565             /* I don't know if I have the reference counts right or not :( */
1566             /* Neither do I :-) */
1567             /* No Idea here either */
1568
1569             ct=newAV();
1570             av_extend(ct, colours);
1571             for(q=0; q<colours; q++) {
1572                 for(w=0; w<3; w++)
1573                     temp[w]=sv_2mortal(newSViv(colour_table[q*3 + w]));
1574                 av_store(ct, q, (SV*)newRV_noinc((SV*)av_make(3, temp)));
1575             }
1576             myfree(colour_table);
1577
1578             EXTEND(SP,2);
1579             r = sv_newmortal();
1580             sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1581             PUSHs(r);
1582             PUSHs(newRV_noinc((SV*)ct));
1583         }
1584
1585
1586
1587
1588
1589 void
1590 i_readgif_scalar(...)
1591           PROTOTYPE: $
1592             PREINIT:
1593                char*    data;
1594        unsigned int     length;
1595                 int*    colour_table;
1596                 int     colours, q, w;
1597               i_img*    rimg;
1598                  SV*    temp[3];
1599                  AV*    ct; 
1600                  SV*    r;
1601                PPCODE:
1602         data = (char *)SvPV(ST(0), length);
1603         colour_table=NULL;
1604         colours=0;
1605
1606         if(GIMME_V == G_ARRAY) {  
1607             rimg=i_readgif_scalar(data,length,&colour_table,&colours);
1608         } else {
1609             /* don't waste time with colours if they aren't wanted */
1610             rimg=i_readgif_scalar(data,length,NULL,NULL);
1611         }
1612
1613         if (colour_table == NULL) {
1614             EXTEND(SP,1);
1615             r=sv_newmortal();
1616             sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1617             PUSHs(r);
1618         } else {
1619             /* the following creates an [[r,g,b], [r, g, b], [r, g, b]...] */
1620             /* I don't know if I have the reference counts right or not :( */
1621             /* Neither do I :-) */
1622             ct=newAV();
1623             av_extend(ct, colours);
1624             for(q=0; q<colours; q++) {
1625                 for(w=0; w<3; w++)
1626                     temp[w]=sv_2mortal(newSViv(colour_table[q*3 + w]));
1627                 av_store(ct, q, (SV*)newRV_noinc((SV*)av_make(3, temp)));
1628             }
1629             myfree(colour_table);
1630             
1631             EXTEND(SP,2);
1632             r=sv_newmortal();
1633             sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1634             PUSHs(r);
1635             PUSHs(newRV_noinc((SV*)ct));
1636         }
1637
1638 void
1639 i_readgif_callback(...)
1640           PROTOTYPE: &
1641             PREINIT:
1642                char*    data;
1643                 int     length;
1644                 int*    colour_table;
1645                 int     colours, q, w;
1646               i_img*    rimg;
1647                  SV*    temp[3];
1648                  AV*    ct; 
1649                  SV*    r;
1650        i_reader_data    rd;
1651                PPCODE:
1652         rd.sv = ST(0);
1653         colour_table=NULL;
1654         colours=0;
1655
1656         if(GIMME_V == G_ARRAY) {  
1657             rimg=i_readgif_callback(read_callback, (char *)&rd,&colour_table,&colours);
1658         } else {
1659             /* don't waste time with colours if they aren't wanted */
1660             rimg=i_readgif_callback(read_callback, (char *)&rd,NULL,NULL);
1661         }
1662
1663         if (colour_table == NULL) {
1664             EXTEND(SP,1);
1665             r=sv_newmortal();
1666             sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1667             PUSHs(r);
1668         } else {
1669             /* the following creates an [[r,g,b], [r, g, b], [r, g, b]...] */
1670             /* I don't know if I have the reference counts right or not :( */
1671             /* Neither do I :-) */
1672             /* Neither do I - maybe I'll move this somewhere */
1673             ct=newAV();
1674             av_extend(ct, colours);
1675             for(q=0; q<colours; q++) {
1676                 for(w=0; w<3; w++)
1677                     temp[w]=sv_2mortal(newSViv(colour_table[q*3 + w]));
1678                 av_store(ct, q, (SV*)newRV_noinc((SV*)av_make(3, temp)));
1679             }
1680             myfree(colour_table);
1681             
1682             EXTEND(SP,2);
1683             r=sv_newmortal();
1684             sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1685             PUSHs(r);
1686             PUSHs(newRV_noinc((SV*)ct));
1687         }
1688
1689 void
1690 i_readgif_multi(fd)
1691         int     fd
1692       PREINIT:
1693         i_img **imgs;
1694         int count;
1695         int i;
1696       PPCODE:
1697         imgs = i_readgif_multi(fd, &count);
1698         if (imgs) {
1699           EXTEND(SP, count);
1700           for (i = 0; i < count; ++i) {
1701             SV *sv = sv_newmortal();
1702             sv_setref_pv(sv, "Imager::ImgRaw", (void *)imgs[i]);
1703             PUSHs(sv);
1704           }
1705           myfree(imgs);
1706         }
1707
1708 void
1709 i_readgif_multi_scalar(data)
1710       PREINIT:
1711         i_img **imgs;
1712         int count;
1713         char *data;
1714         unsigned int length;
1715         int i;
1716       PPCODE:
1717         data = (char *)SvPV(ST(0), length);
1718         imgs = i_readgif_multi_scalar(data, length, &count);
1719         if (imgs) {
1720           EXTEND(SP, count);
1721           for (i = 0; i < count; ++i) {
1722             SV *sv = sv_newmortal();
1723             sv_setref_pv(sv, "Imager::ImgRaw", (void *)imgs[i]);
1724             PUSHs(sv);
1725           }
1726           myfree(imgs);
1727         }
1728
1729 void
1730 i_readgif_multi_callback(cb)
1731       PREINIT:
1732         i_reader_data rd;
1733         i_img **imgs;
1734         int count;
1735         int i;
1736       PPCODE:
1737         rd.sv = ST(0);
1738         imgs = i_readgif_multi_callback(read_callback, (char *)&rd, &count);
1739         if (imgs) {
1740           EXTEND(SP, count);
1741           for (i = 0; i < count; ++i) {
1742             SV *sv = sv_newmortal();
1743             sv_setref_pv(sv, "Imager::ImgRaw", (void *)imgs[i]);
1744             PUSHs(sv);
1745           }
1746           myfree(imgs);
1747         }
1748
1749 #endif
1750
1751
1752
1753 Imager::ImgRaw
1754 i_readpnm_wiol(ig, length)
1755         Imager::IO     ig
1756                int     length
1757
1758
1759 undef_int
1760 i_writeppm_wiol(im, ig)
1761     Imager::ImgRaw     im
1762         Imager::IO     ig
1763
1764
1765 Imager::ImgRaw
1766 i_readraw_wiol(ig,x,y,datachannels,storechannels,intrl)
1767         Imager::IO     ig
1768                int     x
1769                int     y
1770                int     datachannels
1771                int     storechannels
1772                int     intrl
1773
1774 undef_int
1775 i_writeraw_wiol(im,ig)
1776     Imager::ImgRaw     im
1777         Imager::IO     ig
1778
1779 undef_int
1780 i_writebmp_wiol(im,ig)
1781     Imager::ImgRaw     im
1782         Imager::IO     ig
1783
1784 Imager::ImgRaw
1785 i_readbmp_wiol(ig)
1786         Imager::IO     ig
1787
1788
1789 undef_int
1790 i_writetga_wiol(im,ig, wierdpack, compress, idstring)
1791     Imager::ImgRaw     im
1792         Imager::IO     ig
1793                int     wierdpack
1794                int     compress
1795               char*    idstring
1796             PREINIT:
1797                 SV* sv1;
1798                 int rc;
1799                 int idlen;
1800                CODE:
1801                 idlen  = SvCUR(ST(4));
1802                 RETVAL = i_writetga_wiol(im, ig, wierdpack, compress, idstring, idlen);
1803                 OUTPUT:
1804                 RETVAL
1805
1806
1807 Imager::ImgRaw
1808 i_readtga_wiol(ig, length)
1809         Imager::IO     ig
1810                int     length
1811
1812
1813 Imager::ImgRaw
1814 i_scaleaxis(im,Value,Axis)
1815     Imager::ImgRaw     im
1816              float     Value
1817                int     Axis
1818
1819 Imager::ImgRaw
1820 i_scale_nn(im,scx,scy)
1821     Imager::ImgRaw     im
1822              float     scx
1823              float     scy
1824
1825 Imager::ImgRaw
1826 i_haar(im)
1827     Imager::ImgRaw     im
1828
1829 int
1830 i_count_colors(im,maxc)
1831     Imager::ImgRaw     im
1832                int     maxc
1833
1834
1835 Imager::ImgRaw
1836 i_transform(im,opx,opy,parm)
1837     Imager::ImgRaw     im
1838              PREINIT:
1839              double* parm;
1840              int*    opx;
1841              int*    opy;
1842              int     opxl;
1843              int     opyl;
1844              int     parmlen;
1845              AV* av;
1846              SV* sv1;
1847              int i;
1848              CODE:
1849              if (!SvROK(ST(1))) croak("Imager: Parameter 1 must be a reference to an array\n");
1850              if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to an array\n");
1851              if (!SvROK(ST(3))) croak("Imager: Parameter 3 must be a reference to an array\n");
1852              if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 must be a reference to an array\n");
1853              if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 must be a reference to an array\n");
1854              if (SvTYPE(SvRV(ST(3))) != SVt_PVAV) croak("Imager: Parameter 3 must be a reference to an array\n");
1855              av=(AV*)SvRV(ST(1));
1856              opxl=av_len(av)+1;
1857              opx=mymalloc( opxl*sizeof(int) );
1858              for(i=0;i<opxl;i++) {
1859                sv1=(*(av_fetch(av,i,0)));
1860                opx[i]=(int)SvIV(sv1);
1861              }
1862              av=(AV*)SvRV(ST(2));
1863              opyl=av_len(av)+1;
1864              opy=mymalloc( opyl*sizeof(int) );
1865              for(i=0;i<opyl;i++) {
1866                sv1=(*(av_fetch(av,i,0)));
1867                opy[i]=(int)SvIV(sv1);
1868              }
1869              av=(AV*)SvRV(ST(3));
1870              parmlen=av_len(av)+1;
1871              parm=mymalloc( parmlen*sizeof(double) );
1872              for(i=0;i<parmlen;i++) { /* FIXME: Bug? */
1873                sv1=(*(av_fetch(av,i,0)));
1874                parm[i]=(double)SvNV(sv1);
1875              }
1876              RETVAL=i_transform(im,opx,opxl,opy,opyl,parm,parmlen);
1877              myfree(parm);
1878              myfree(opy);
1879              myfree(opx);
1880              ST(0) = sv_newmortal();
1881              if (RETVAL == 0) ST(0)=&PL_sv_undef;
1882              else sv_setref_pv(ST(0), "Imager::ImgRaw", (void*)RETVAL);
1883
1884 Imager::ImgRaw
1885 i_transform2(width,height,ops,n_regs,c_regs,in_imgs)
1886              PREINIT:
1887              int width;
1888              int height;
1889              double* parm;
1890              struct rm_op *ops;
1891              STRLEN ops_len;
1892              int ops_count;
1893              double *n_regs;
1894              int n_regs_count;
1895              i_color *c_regs;
1896              int c_regs_count;
1897              int in_imgs_count;
1898              i_img **in_imgs;
1899              AV* av;
1900              SV* sv1;
1901              IV tmp;
1902              int i;
1903              CODE:
1904              if (!SvROK(ST(3))) croak("Imager: Parameter 4 must be a reference to an array\n");
1905              if (!SvROK(ST(4))) croak("Imager: Parameter 5 must be a reference to an array\n");
1906              if (!SvROK(ST(5))) croak("Imager: Parameter 6 must be a reference to an array of images\n");
1907              if (SvTYPE(SvRV(ST(3))) != SVt_PVAV) croak("Imager: Parameter 4 must be a reference to an array\n");
1908              if (SvTYPE(SvRV(ST(4))) != SVt_PVAV) croak("Imager: Parameter 5 must be a reference to an array\n");
1909
1910         /*if (SvTYPE(SvRV(ST(5))) != SVt_PVAV) croak("Imager: Parameter 6 must be a reference to an array\n");*/
1911
1912              if (SvTYPE(SvRV(ST(5))) == SVt_PVAV) {
1913                av = (AV*)SvRV(ST(5));
1914                in_imgs_count = av_len(av)+1;
1915                for (i = 0; i < in_imgs_count; ++i) {
1916                  sv1 = *av_fetch(av, i, 0);
1917                  if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
1918                    croak("Parameter 5 must contain only images");
1919                  }
1920                }
1921              }
1922              else {
1923                in_imgs_count = 0;
1924              }
1925              if (in_imgs_count > 0) {
1926                av = (AV*)SvRV(ST(5));
1927                in_imgs = mymalloc(in_imgs_count*sizeof(i_img*));
1928                for (i = 0; i < in_imgs_count; ++i) {              
1929                  sv1 = *av_fetch(av,i,0);
1930                  if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
1931                    croak("Parameter 5 must contain only images");
1932                  }
1933                  tmp = SvIV((SV*)SvRV(sv1));
1934                  in_imgs[i] = (i_img*)tmp;
1935                }
1936              }
1937              else {
1938                /* no input images */
1939                in_imgs = NULL;
1940              }
1941              /* default the output size from the first input if possible */
1942              if (SvOK(ST(0)))
1943                width = SvIV(ST(0));
1944              else if (in_imgs_count)
1945                width = in_imgs[0]->xsize;
1946              else
1947                croak("No output image width supplied");
1948
1949              if (SvOK(ST(1)))
1950                height = SvIV(ST(1));
1951              else if (in_imgs_count)
1952                height = in_imgs[0]->ysize;
1953              else
1954                croak("No output image height supplied");
1955
1956              ops = (struct rm_op *)SvPV(ST(2), ops_len);
1957              if (ops_len % sizeof(struct rm_op))
1958                  croak("Imager: Parameter 3 must be a bitmap of regops\n");
1959              ops_count = ops_len / sizeof(struct rm_op);
1960              av = (AV*)SvRV(ST(3));
1961              n_regs_count = av_len(av)+1;
1962              n_regs = mymalloc(n_regs_count * sizeof(double));
1963              for (i = 0; i < n_regs_count; ++i) {
1964                sv1 = *av_fetch(av,i,0);
1965                if (SvOK(sv1))
1966                  n_regs[i] = SvNV(sv1);
1967              }
1968              av = (AV*)SvRV(ST(4));
1969              c_regs_count = av_len(av)+1;
1970              c_regs = mymalloc(c_regs_count * sizeof(i_color));
1971              /* I don't bother initializing the colou?r registers */
1972
1973              RETVAL=i_transform2(width, height, 3, ops, ops_count, 
1974                                  n_regs, n_regs_count, 
1975                                  c_regs, c_regs_count, in_imgs, in_imgs_count);
1976              if (in_imgs)
1977                  myfree(in_imgs);
1978              myfree(n_regs);
1979              myfree(c_regs);
1980              ST(0) = sv_newmortal();
1981              if (RETVAL == 0) ST(0)=&PL_sv_undef;
1982              else sv_setref_pv(ST(0), "Imager::ImgRaw", (void*)RETVAL);
1983
1984
1985 void
1986 i_contrast(im,intensity)
1987     Imager::ImgRaw     im
1988              float     intensity
1989
1990 void
1991 i_hardinvert(im)
1992     Imager::ImgRaw     im
1993
1994 void
1995 i_noise(im,amount,type)
1996     Imager::ImgRaw     im
1997              float     amount
1998      unsigned char     type
1999
2000 void
2001 i_bumpmap(im,bump,channel,light_x,light_y,strength)
2002     Imager::ImgRaw     im
2003     Imager::ImgRaw     bump
2004                int     channel
2005                int     light_x
2006                int     light_y
2007                int     strength
2008
2009
2010 void
2011 i_bumpmap_complex(im,bump,channel,tx,ty,Lx,Ly,Lz,cd,cs,n,Ia,Il,Is)
2012     Imager::ImgRaw     im
2013     Imager::ImgRaw     bump
2014                int     channel
2015                int     tx
2016                int     ty
2017              float     Lx
2018              float     Ly
2019              float     Lz
2020              float     cd
2021              float     cs
2022              float     n
2023      Imager::Color     Ia
2024      Imager::Color     Il
2025      Imager::Color     Is
2026
2027
2028
2029 void
2030 i_postlevels(im,levels)
2031     Imager::ImgRaw     im
2032              int       levels
2033
2034 void
2035 i_mosaic(im,size)
2036     Imager::ImgRaw     im
2037                int     size
2038
2039 void
2040 i_watermark(im,wmark,tx,ty,pixdiff)
2041     Imager::ImgRaw     im
2042     Imager::ImgRaw     wmark
2043                int     tx
2044                int     ty
2045                int     pixdiff
2046
2047
2048 void
2049 i_autolevels(im,lsat,usat,skew)
2050     Imager::ImgRaw     im
2051              float     lsat
2052              float     usat
2053              float     skew
2054
2055 void
2056 i_radnoise(im,xo,yo,rscale,ascale)
2057     Imager::ImgRaw     im
2058              float     xo
2059              float     yo
2060              float     rscale
2061              float     ascale
2062
2063 void
2064 i_turbnoise(im, xo, yo, scale)
2065     Imager::ImgRaw     im
2066              float     xo
2067              float     yo
2068              float     scale
2069
2070
2071 void
2072 i_gradgen(im, ...)
2073     Imager::ImgRaw     im
2074       PREINIT:
2075         int num;
2076         int *xo;
2077         int *yo;
2078         i_color *ival;
2079         int dmeasure;
2080         int i;
2081         SV *sv;
2082         AV *axx;
2083         AV *ayy;
2084         AV *ac;
2085       CODE:
2086         if (items != 5)
2087             croak("Usage: i_gradgen(im, xo, yo, ival, dmeasure)");
2088         if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
2089             croak("i_gradgen: Second argument must be an array ref");
2090         if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
2091             croak("i_gradgen: Third argument must be an array ref");
2092         if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
2093             croak("i_gradgen: Fourth argument must be an array ref");
2094         axx = (AV *)SvRV(ST(1));
2095         ayy = (AV *)SvRV(ST(2));
2096         ac  = (AV *)SvRV(ST(3));
2097         dmeasure = (int)SvIV(ST(4));
2098         
2099         num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
2100         num = num <= av_len(ac) ? num : av_len(ac);
2101         num++; 
2102         if (num < 2) croak("Usage: i_gradgen array refs must have more than 1 entry each");
2103         xo = mymalloc( sizeof(int) * num );
2104         yo = mymalloc( sizeof(int) * num );
2105         ival = mymalloc( sizeof(i_color) * num );
2106         for(i = 0; i<num; i++) {
2107           xo[i]   = (int)SvIV(* av_fetch(axx, i, 0));
2108           yo[i]   = (int)SvIV(* av_fetch(ayy, i, 0));
2109           sv = *av_fetch(ac, i, 0);
2110           if ( !sv_derived_from(sv, "Imager::Color") ) {
2111             free(axx); free(ayy); free(ac);
2112             croak("i_gradgen: Element of fourth argument is not derived from Imager::Color");
2113           }
2114           ival[i] = *(i_color *)SvIV((SV *)SvRV(sv));
2115         }
2116         i_gradgen(im, num, xo, yo, ival, dmeasure);
2117
2118 void
2119 i_fountain(im, xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
2120     Imager::ImgRaw     im
2121             double     xa
2122             double     ya
2123             double     xb
2124             double     yb
2125                int     type
2126                int     repeat
2127                int     combine
2128                int     super_sample
2129             double     ssample_param
2130       PREINIT:
2131         AV *asegs;
2132         int count;
2133         i_fountain_seg *segs;
2134       CODE:
2135         if (!SvROK(ST(10)) || ! SvTYPE(SvRV(ST(10))))
2136             croak("i_fountain: argument 11 must be an array ref");
2137         
2138         asegs = (AV *)SvRV(ST(10));
2139         segs = load_fount_segs(asegs, &count);
2140         i_fountain(im, xa, ya, xb, yb, type, repeat, combine, super_sample, 
2141                    ssample_param, count, segs);
2142         myfree(segs);
2143
2144 Imager::FillHandle
2145 i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
2146             double     xa
2147             double     ya
2148             double     xb
2149             double     yb
2150                int     type
2151                int     repeat
2152                int     combine
2153                int     super_sample
2154             double     ssample_param
2155       PREINIT:
2156         AV *asegs;
2157         int count;
2158         i_fountain_seg *segs;
2159       CODE:
2160         if (!SvROK(ST(9)) || ! SvTYPE(SvRV(ST(9))))
2161             croak("i_fountain: argument 11 must be an array ref");
2162         
2163         asegs = (AV *)SvRV(ST(9));
2164         segs = load_fount_segs(asegs, &count);
2165         RETVAL = i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine, 
2166                                   super_sample, ssample_param, count, segs);
2167         myfree(segs);        
2168       OUTPUT:
2169         RETVAL
2170
2171 void
2172 i_errors()
2173       PREINIT:
2174         i_errmsg *errors;
2175         int i;
2176         AV *av;
2177         SV *ref;
2178         SV *sv;
2179       PPCODE:
2180         errors = i_errors();
2181         i = 0;
2182         while (errors[i].msg) {
2183           av = newAV();
2184           sv = newSVpv(errors[i].msg, strlen(errors[i].msg));
2185           if (!av_store(av, 0, sv)) {
2186             SvREFCNT_dec(sv);
2187           }
2188           sv = newSViv(errors[i].code);
2189           if (!av_store(av, 1, sv)) {
2190             SvREFCNT_dec(sv);
2191           }
2192           PUSHs(sv_2mortal(newRV_noinc((SV*)av)));
2193           ++i;
2194         }
2195
2196 void
2197 i_nearest_color(im, ...)
2198     Imager::ImgRaw     im
2199       PREINIT:
2200         int num;
2201         int *xo;
2202         int *yo;
2203         i_color *ival;
2204         int dmeasure;
2205         int i;
2206         SV *sv;
2207         AV *axx;
2208         AV *ayy;
2209         AV *ac;
2210       CODE:
2211         if (items != 5)
2212             croak("Usage: i_nearest_color(im, xo, yo, ival, dmeasure)");
2213         if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
2214             croak("i_nearest_color: Second argument must be an array ref");
2215         if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
2216             croak("i_nearest_color: Third argument must be an array ref");
2217         if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
2218             croak("i_nearest_color: Fourth argument must be an array ref");
2219         axx = (AV *)SvRV(ST(1));
2220         ayy = (AV *)SvRV(ST(2));
2221         ac  = (AV *)SvRV(ST(3));
2222         dmeasure = (int)SvIV(ST(4));
2223         
2224         num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
2225         num = num <= av_len(ac) ? num : av_len(ac);
2226         num++; 
2227         if (num < 2) croak("Usage: i_nearest_color array refs must have more than 1 entry each");
2228         xo = mymalloc( sizeof(int) * num );
2229         yo = mymalloc( sizeof(int) * num );
2230         ival = mymalloc( sizeof(i_color) * num );
2231         for(i = 0; i<num; i++) {
2232           xo[i]   = (int)SvIV(* av_fetch(axx, i, 0));
2233           yo[i]   = (int)SvIV(* av_fetch(ayy, i, 0));
2234           sv = *av_fetch(ac, i, 0);
2235           if ( !sv_derived_from(sv, "Imager::Color") ) {
2236             free(axx); free(ayy); free(ac);
2237             croak("i_nearest_color: Element of fourth argument is not derived from Imager::Color");
2238           }
2239           ival[i] = *(i_color *)SvIV((SV *)SvRV(sv));
2240         }
2241         i_nearest_color(im, num, xo, yo, ival, dmeasure);
2242
2243
2244
2245
2246 void
2247 malloc_state()
2248
2249 void
2250 hashinfo(hv)
2251              PREINIT:
2252                HV* hv;
2253                int stuff;
2254              PPCODE:
2255                if (!SvROK(ST(0))) croak("Imager: Parameter 0 must be a reference to a hash\n");        
2256                hv=(HV*)SvRV(ST(0));
2257                if (SvTYPE(hv)!=SVt_PVHV) croak("Imager: Parameter 0 must be a reference to a hash\n");
2258                if (getint(hv,"stuff",&stuff)) printf("ok: %d\n",stuff); else printf("key doesn't exist\n");
2259                if (getint(hv,"stuff2",&stuff)) printf("ok: %d\n",stuff); else printf("key doesn't exist\n");
2260                
2261 void
2262 DSO_open(filename)
2263              char*       filename
2264              PREINIT:
2265                void *rc;
2266                char *evstr;
2267              PPCODE:
2268                rc=DSO_open(filename,&evstr);
2269                if (rc!=NULL) {
2270                  if (evstr!=NULL) {
2271                    EXTEND(SP,2); 
2272                    PUSHs(sv_2mortal(newSViv((IV)rc)));
2273                    PUSHs(sv_2mortal(newSVpvn(evstr, strlen(evstr))));
2274                  } else {
2275                    EXTEND(SP,1);
2276                    PUSHs(sv_2mortal(newSViv((IV)rc)));
2277                  }
2278                }
2279
2280
2281 undef_int
2282 DSO_close(dso_handle)
2283              void*       dso_handle
2284
2285 void
2286 DSO_funclist(dso_handle_v)
2287              void*       dso_handle_v
2288              PREINIT:
2289                int i;
2290                DSO_handle *dso_handle;
2291              PPCODE:
2292                dso_handle=(DSO_handle*)dso_handle_v;
2293                i=0;
2294                while( dso_handle->function_list[i].name != NULL) {
2295                  EXTEND(SP,1);
2296                  PUSHs(sv_2mortal(newSVpv(dso_handle->function_list[i].name,0)));
2297                  EXTEND(SP,1);
2298                  PUSHs(sv_2mortal(newSVpv(dso_handle->function_list[i++].pcode,0)));
2299                }
2300
2301
2302 void
2303 DSO_call(handle,func_index,hv)
2304                void*  handle
2305                int    func_index
2306              PREINIT:
2307                HV* hv;
2308              PPCODE:
2309                if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to a hash\n");        
2310                hv=(HV*)SvRV(ST(2));
2311                if (SvTYPE(hv)!=SVt_PVHV) croak("Imager: Parameter 2 must be a reference to a hash\n");
2312                DSO_call( (DSO_handle *)handle,func_index,hv);
2313
2314
2315
2316 # this is mostly for testing...
2317 SV *
2318 i_get_pixel(im, x, y)
2319         Imager::ImgRaw im
2320         int x
2321         int y;
2322       PREINIT:
2323         i_color *color;
2324       CODE:
2325         color = (i_color *)mymalloc(sizeof(i_color));
2326         if (i_gpix(im, x, y, color) == 0) {
2327           ST(0) = sv_newmortal();
2328           sv_setref_pv(ST(0), "Imager::Color", (void *)color);
2329         }
2330         else {
2331           myfree(color);
2332           ST(0) = &PL_sv_undef;
2333         }
2334         
2335
2336 int
2337 i_ppix(im, x, y, cl)
2338         Imager::ImgRaw im
2339         int x
2340         int y
2341         Imager::Color cl
2342
2343 Imager::ImgRaw
2344 i_img_pal_new(x, y, channels, maxpal)
2345         int     x
2346         int     y
2347         int     channels
2348         int     maxpal
2349
2350 Imager::ImgRaw
2351 i_img_to_pal(src, quant)
2352         Imager::ImgRaw src
2353       PREINIT:
2354         HV *hv;
2355         i_quantize quant;
2356       CODE:
2357         if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
2358           croak("i_img_to_pal: second argument must be a hash ref");
2359         hv = (HV *)SvRV(ST(1));
2360         memset(&quant, 0, sizeof(quant));
2361         quant.mc_size = 256;
2362         quant.mc_colors = mymalloc(quant.mc_size * sizeof(i_color));
2363         handle_quant_opts(&quant, hv);
2364         RETVAL = i_img_to_pal(src, &quant);
2365         if (RETVAL) {
2366           copy_colors_back(hv, &quant);
2367         }
2368         myfree(quant.mc_colors);
2369       OUTPUT:
2370         RETVAL
2371
2372 Imager::ImgRaw
2373 i_img_to_rgb(src)
2374         Imager::ImgRaw src
2375
2376 void
2377 i_gpal(im, l, r, y)
2378         Imager::ImgRaw  im
2379         int     l
2380         int     r
2381         int     y
2382       PREINIT:
2383         i_palidx *work;
2384         int count, i;
2385       PPCODE:
2386         if (l < r) {
2387           work = mymalloc((r-l) * sizeof(i_palidx));
2388           count = i_gpal(im, l, r, y, work);
2389           if (GIMME_V == G_ARRAY) {
2390             EXTEND(SP, count);
2391             for (i = 0; i < count; ++i) {
2392               PUSHs(sv_2mortal(newSViv(work[i])));
2393             }
2394           }
2395           else {
2396             EXTEND(SP, 1);
2397             PUSHs(sv_2mortal(newSVpv(work, count * sizeof(i_palidx))));
2398           }
2399           myfree(work);
2400         }
2401         else {
2402           if (GIMME_V != G_ARRAY) {
2403             EXTEND(SP, 1);
2404             PUSHs(&PL_sv_undef);
2405           }
2406         }
2407
2408 int
2409 i_ppal(im, l, y, ...)
2410         Imager::ImgRaw  im
2411         int     l
2412         int     y
2413       PREINIT:
2414         i_palidx *work;
2415         int count, i;
2416       CODE:
2417         if (items > 3) {
2418           work = mymalloc(sizeof(i_palidx) * (items-3));
2419           for (i=0; i < items-3; ++i) {
2420             work[i] = SvIV(ST(i+3));
2421           }
2422           RETVAL = i_ppal(im, l, l+items-3, y, work);
2423           myfree(work);
2424         }
2425         else {
2426           RETVAL = 0;
2427         }
2428       OUTPUT:
2429         RETVAL
2430
2431 SV *
2432 i_addcolors(im, ...)
2433         Imager::ImgRaw  im
2434       PREINIT:
2435         int index;
2436         i_color *colors;
2437         int i;
2438       CODE:
2439         if (items < 2)
2440           croak("i_addcolors: no colors to add");
2441         colors = mymalloc((items-1) * sizeof(i_color));
2442         for (i=0; i < items-1; ++i) {
2443           if (sv_isobject(ST(i+1)) 
2444               && sv_derived_from(ST(i+1), "Imager::Color")) {
2445             IV tmp = SvIV((SV *)SvRV(ST(i+1)));
2446             colors[i] = *(i_color *)tmp;
2447           }
2448           else {
2449             myfree(colors);
2450             croak("i_plin: pixels must be Imager::Color objects");
2451           }
2452         }
2453         index = i_addcolors(im, colors, items-1);
2454         myfree(colors);
2455         if (index == 0) {
2456           ST(0) = sv_2mortal(newSVpv("0 but true", 0));
2457         }
2458         else if (index == -1) {
2459           ST(0) = &PL_sv_undef;
2460         }
2461         else {
2462           ST(0) = sv_2mortal(newSViv(index));
2463         }
2464
2465 int 
2466 i_setcolors(im, index, ...)
2467         Imager::ImgRaw  im
2468         int index
2469       PREINIT:
2470         i_color *colors;
2471         int i;
2472       CODE:
2473         if (items < 3)
2474           croak("i_setcolors: no colors to add");
2475         colors = mymalloc((items-2) * sizeof(i_color));
2476         for (i=0; i < items-2; ++i) {
2477           if (sv_isobject(ST(i+2)) 
2478               && sv_derived_from(ST(i+2), "Imager::Color")) {
2479             IV tmp = SvIV((SV *)SvRV(ST(i+2)));
2480             colors[i] = *(i_color *)tmp;
2481           }
2482           else {
2483             myfree(colors);
2484             croak("i_setcolors: pixels must be Imager::Color objects");
2485           }
2486         }
2487         RETVAL = i_setcolors(im, index, colors, items-2);
2488         myfree(colors);
2489
2490 void
2491 i_getcolors(im, index, ...)
2492         Imager::ImgRaw im
2493         int index
2494       PREINIT:
2495         i_color *colors;
2496         int count = 1;
2497         int i;
2498       PPCODE:
2499         if (items > 3)
2500           croak("i_getcolors: too many arguments");
2501         if (items == 3)
2502           count = SvIV(ST(2));
2503         if (count < 1)
2504           croak("i_getcolors: count must be positive");
2505         colors = mymalloc(sizeof(i_color) * count);
2506         if (i_getcolors(im, index, colors, count)) {
2507           for (i = 0; i < count; ++i) {
2508             i_color *pv;
2509             SV *sv = sv_newmortal();
2510             pv = mymalloc(sizeof(i_color));
2511             *pv = colors[i];
2512             sv_setref_pv(sv, "Imager::Color", (void *)pv);
2513             PUSHs(sv);
2514           }
2515         }
2516         myfree(colors);
2517
2518
2519 SV *
2520 i_colorcount(im)
2521         Imager::ImgRaw im
2522       PREINIT:
2523         int count;
2524       CODE:
2525         count = i_colorcount(im);
2526         if (count >= 0) {
2527           ST(0) = sv_2mortal(newSViv(count));
2528         }
2529         else {
2530           ST(0) = &PL_sv_undef;
2531         }
2532
2533 SV *
2534 i_maxcolors(im)
2535         Imager::ImgRaw im
2536       PREINIT:
2537         int count;
2538       CODE:
2539         count = i_maxcolors(im);
2540         if (count >= 0) {
2541           ST(0) = sv_2mortal(newSViv(count));
2542         }
2543         else {
2544           ST(0) = &PL_sv_undef;
2545         }
2546
2547 SV *
2548 i_findcolor(im, color)
2549         Imager::ImgRaw im
2550         Imager::Color color
2551       PREINIT:
2552         i_palidx index;
2553       CODE:
2554         if (i_findcolor(im, color, &index)) {
2555           ST(0) = sv_2mortal(newSViv(index));
2556         }
2557         else {
2558           ST(0) = &PL_sv_undef;
2559         }
2560
2561 int
2562 i_img_bits(im)
2563         Imager::ImgRaw  im
2564
2565 int
2566 i_img_type(im)
2567         Imager::ImgRaw  im
2568
2569 int
2570 i_img_virtual(im)
2571         Imager::ImgRaw  im
2572
2573 void
2574 i_gsamp(im, l, r, y, ...)
2575         Imager::ImgRaw im
2576         int l
2577         int r
2578         int y
2579       PREINIT:
2580         int *chans;
2581         int chan_count;
2582         i_sample_t *data;
2583         int count, i;
2584       PPCODE:
2585         if (items < 5)
2586           croak("No channel numbers supplied to g_samp()");
2587         if (l < r) {
2588           chan_count = items - 4;
2589           chans = mymalloc(sizeof(int) * chan_count);
2590           for (i = 0; i < chan_count; ++i)
2591             chans[i] = SvIV(ST(i+4));
2592           data = mymalloc(sizeof(i_sample_t) * (r-l) * chan_count);
2593           count = i_gsamp(im, l, r, y, data, chans, chan_count);
2594           if (GIMME_V == G_ARRAY) {
2595             EXTEND(SP, count);
2596             for (i = 0; i < count; ++i)
2597               PUSHs(sv_2mortal(newSViv(data[i])));
2598           }
2599           else {
2600             EXTEND(SP, 1);
2601             PUSHs(sv_2mortal(newSVpv(data, count * sizeof(i_sample_t))));
2602           }
2603         }
2604         else {
2605           if (GIMME_V != G_ARRAY) {
2606             EXTEND(SP, 1);
2607             PUSHs(&PL_sv_undef);
2608           }
2609         }
2610
2611 Imager::ImgRaw
2612 i_img_masked_new(targ, mask, x, y, w, h)
2613         Imager::ImgRaw targ
2614         int x
2615         int y
2616         int w
2617         int h
2618       PREINIT:
2619         i_img *mask;
2620       CODE:
2621         if (SvOK(ST(1))) {
2622           if (!sv_isobject(ST(1)) 
2623               || !sv_derived_from(ST(1), "Imager::ImgRaw")) {
2624             croak("i_img_masked_new: parameter 2 must undef or an image");
2625           }
2626           mask = (i_img *)SvIV((SV *)SvRV(ST(1)));
2627         }
2628         else
2629           mask = NULL;
2630         RETVAL = i_img_masked_new(targ, mask, x, y, w, h);
2631       OUTPUT:
2632         RETVAL
2633
2634 int
2635 i_plin(im, l, y, ...)
2636         Imager::ImgRaw  im
2637         int     l
2638         int     y
2639       PREINIT:
2640         i_color *work;
2641         int count, i;
2642       CODE:
2643         if (items > 3) {
2644           work = mymalloc(sizeof(i_color) * (items-3));
2645           for (i=0; i < items-3; ++i) {
2646             if (sv_isobject(ST(i+3)) 
2647                 && sv_derived_from(ST(i+3), "Imager::Color")) {
2648               IV tmp = SvIV((SV *)SvRV(ST(i+3)));
2649               work[i] = *(i_color *)tmp;
2650             }
2651             else {
2652               myfree(work);
2653               croak("i_plin: pixels must be Imager::Color objects");
2654             }
2655           }
2656           /**(char *)0 = 1;*/
2657           RETVAL = i_plin(im, l, l+items-3, y, work);
2658           myfree(work);
2659         }
2660         else {
2661           RETVAL = 0;
2662         }
2663       OUTPUT:
2664         RETVAL
2665
2666 int
2667 i_ppixf(im, x, y, cl)
2668         Imager::ImgRaw im
2669         int x
2670         int y
2671         Imager::Color::Float cl
2672
2673 void
2674 i_gsampf(im, l, r, y, ...)
2675         Imager::ImgRaw im
2676         int l
2677         int r
2678         int y
2679       PREINIT:
2680         int *chans;
2681         int chan_count;
2682         i_fsample_t *data;
2683         int count, i;
2684       PPCODE:
2685         if (items < 5)
2686           croak("No channel numbers supplied to g_sampf()");
2687         if (l < r) {
2688           chan_count = items - 4;
2689           chans = mymalloc(sizeof(int) * chan_count);
2690           for (i = 0; i < chan_count; ++i)
2691             chans[i] = SvIV(ST(i+4));
2692           data = mymalloc(sizeof(i_fsample_t) * (r-l) * chan_count);
2693           count = i_gsampf(im, l, r, y, data, chans, chan_count);
2694           if (GIMME_V == G_ARRAY) {
2695             EXTEND(SP, count);
2696             for (i = 0; i < count; ++i)
2697               PUSHs(sv_2mortal(newSVnv(data[i])));
2698           }
2699           else {
2700             EXTEND(SP, 1);
2701             PUSHs(sv_2mortal(newSVpv((void *)data, count * sizeof(i_fsample_t))));
2702           }
2703         }
2704         else {
2705           if (GIMME_V != G_ARRAY) {
2706             EXTEND(SP, 1);
2707             PUSHs(&PL_sv_undef);
2708           }
2709         }
2710
2711 int
2712 i_plinf(im, l, y, ...)
2713         Imager::ImgRaw  im
2714         int     l
2715         int     y
2716       PREINIT:
2717         i_fcolor *work;
2718         int count, i;
2719       CODE:
2720         if (items > 3) {
2721           work = mymalloc(sizeof(i_fcolor) * (items-3));
2722           for (i=0; i < items-3; ++i) {
2723             if (sv_isobject(ST(i+3)) 
2724                 && sv_derived_from(ST(i+3), "Imager::Color::Float")) {
2725               IV tmp = SvIV((SV *)SvRV(ST(i+3)));
2726               work[i] = *(i_fcolor *)tmp;
2727             }
2728             else {
2729               myfree(work);
2730               croak("i_plin: pixels must be Imager::Color::Float objects");
2731             }
2732           }
2733           /**(char *)0 = 1;*/
2734           RETVAL = i_plinf(im, l, l+items-3, y, work);
2735           myfree(work);
2736         }
2737         else {
2738           RETVAL = 0;
2739         }
2740       OUTPUT:
2741         RETVAL
2742
2743 SV *
2744 i_gpixf(im, x, y)
2745         Imager::ImgRaw im
2746         int x
2747         int y;
2748       PREINIT:
2749         i_fcolor *color;
2750       CODE:
2751         color = (i_fcolor *)mymalloc(sizeof(i_fcolor));
2752         if (i_gpixf(im, x, y, color) == 0) {
2753           ST(0) = sv_newmortal();
2754           sv_setref_pv(ST(0), "Imager::Color::Float", (void *)color);
2755         }
2756         else {
2757           myfree(color);
2758           ST(0) = &PL_sv_undef;
2759         }
2760         
2761 void
2762 i_glin(im, l, r, y)
2763         Imager::ImgRaw im
2764         int l
2765         int r
2766         int y
2767       PREINIT:
2768         i_color *vals;
2769         int count, i;
2770       PPCODE:
2771         if (l < r) {
2772           vals = mymalloc((r-l) * sizeof(i_color));
2773           count = i_glin(im, l, r, y, vals);
2774           EXTEND(SP, count);
2775           for (i = 0; i < count; ++i) {
2776             SV *sv;
2777             i_color *col = mymalloc(sizeof(i_color));
2778             sv = sv_newmortal();
2779             sv_setref_pv(sv, "Imager::Color", (void *)col);
2780             PUSHs(sv);
2781           }
2782           myfree(vals);
2783         }
2784
2785 void
2786 i_glinf(im, l, r, y)
2787         Imager::ImgRaw im
2788         int l
2789         int r
2790         int y
2791       PREINIT:
2792         i_fcolor *vals;
2793         int count, i;
2794       PPCODE:
2795         if (l < r) {
2796           vals = mymalloc((r-l) * sizeof(i_fcolor));
2797           count = i_glinf(im, l, r, y, vals);
2798           EXTEND(SP, count);
2799           for (i = 0; i < count; ++i) {
2800             SV *sv;
2801             i_fcolor *col = mymalloc(sizeof(i_fcolor));
2802             *col = vals[i];
2803             sv = sv_newmortal();
2804             sv_setref_pv(sv, "Imager::Color::Float", (void *)col);
2805             PUSHs(sv);
2806           }
2807           myfree(vals);
2808         }
2809
2810 Imager::ImgRaw
2811 i_img_16_new(x, y, ch)
2812         int x
2813         int y
2814         int ch
2815
2816 Imager::ImgRaw
2817 i_img_double_new(x, y, ch)
2818         int x
2819         int y
2820         int ch
2821
2822 undef_int
2823 i_tags_addn(im, name, code, idata)
2824         Imager::ImgRaw im
2825         int     code
2826         int     idata
2827       PREINIT:
2828         char *name;
2829         STRLEN len;
2830       CODE:
2831         if (SvOK(ST(1)))
2832           name = SvPV(ST(1), len);
2833         else
2834           name = NULL;
2835         RETVAL = i_tags_addn(&im->tags, name, code, idata);
2836       OUTPUT:
2837         RETVAL
2838
2839 undef_int
2840 i_tags_add(im, name, code, data, idata)
2841         Imager::ImgRaw  im
2842         int code
2843         int idata
2844       PREINIT:
2845         char *name;
2846         char *data;
2847         STRLEN len;
2848       CODE:
2849         if (SvOK(ST(1)))
2850           name = SvPV(ST(1), len);
2851         else
2852           name = NULL;
2853         if (SvOK(ST(3)))
2854           data = SvPV(ST(3), len);
2855         else {
2856           data = NULL;
2857           len = 0;
2858         }
2859         RETVAL = i_tags_add(&im->tags, name, code, data, len, idata);
2860       OUTPUT:
2861         RETVAL
2862
2863 SV *
2864 i_tags_find(im, name, start)
2865         Imager::ImgRaw  im
2866         char *name
2867         int start
2868       PREINIT:
2869         int entry;
2870       CODE:
2871         if (i_tags_find(&im->tags, name, start, &entry)) {
2872           if (entry == 0)
2873             ST(0) = sv_2mortal(newSVpv("0 but true", 0));
2874           else
2875             ST(0) = sv_2mortal(newSViv(entry));
2876         } else {
2877           ST(0) = &PL_sv_undef;
2878         }
2879
2880 SV *
2881 i_tags_findn(im, code, start)
2882         Imager::ImgRaw  im
2883         int             code
2884         int             start
2885       PREINIT:
2886         int entry;
2887       CODE:
2888         if (i_tags_findn(&im->tags, code, start, &entry)) {
2889           if (entry == 0)
2890             ST(0) = sv_2mortal(newSVpv("0 but true", 0));
2891           else
2892             ST(0) = sv_2mortal(newSViv(entry));
2893         }
2894         else
2895           ST(0) = &PL_sv_undef;
2896
2897 int
2898 i_tags_delete(im, entry)
2899         Imager::ImgRaw  im
2900         int             entry
2901       CODE:
2902         RETVAL = i_tags_delete(&im->tags, entry);
2903       OUTPUT:
2904         RETVAL
2905
2906 int
2907 i_tags_delbyname(im, name)
2908         Imager::ImgRaw  im
2909         char *          name
2910       CODE:
2911         RETVAL = i_tags_delbyname(&im->tags, name);
2912       OUTPUT:
2913         RETVAL
2914
2915 int
2916 i_tags_delbycode(im, code)
2917         Imager::ImgRaw  im
2918         int             code
2919       CODE:
2920         RETVAL = i_tags_delbycode(&im->tags, code);
2921       OUTPUT:
2922         RETVAL
2923
2924 void
2925 i_tags_get(im, index)
2926         Imager::ImgRaw  im
2927         int             index
2928       PPCODE:
2929         if (index >= 0 && index < im->tags.count) {
2930           i_img_tag *entry = im->tags.tags + index;
2931           EXTEND(SP, 5);
2932         
2933           if (entry->name) {
2934             PUSHs(sv_2mortal(newSVpv(entry->name, 0)));
2935           }
2936           else {
2937             PUSHs(sv_2mortal(newSViv(entry->code)));
2938           }
2939           if (entry->data) {
2940             PUSHs(sv_2mortal(newSVpvn(entry->data, entry->size)));
2941           }
2942           else {
2943             PUSHs(sv_2mortal(newSViv(entry->idata)));
2944           }
2945         }
2946
2947 int
2948 i_tags_count(im)
2949         Imager::ImgRaw  im
2950       CODE:
2951         RETVAL = im->tags.count;
2952       OUTPUT:
2953         RETVAL
2954
2955 #ifdef HAVE_WIN32
2956
2957 void
2958 i_wf_bbox(face, size, text)
2959         char *face
2960         int size
2961         char *text
2962       PREINIT:
2963         int cords[6];
2964       PPCODE:
2965         if (i_wf_bbox(face, size, text, strlen(text), cords)) {
2966           EXTEND(SP, 6);  
2967           PUSHs(sv_2mortal(newSViv(cords[0])));
2968           PUSHs(sv_2mortal(newSViv(cords[1])));
2969           PUSHs(sv_2mortal(newSViv(cords[2])));
2970           PUSHs(sv_2mortal(newSViv(cords[3])));
2971           PUSHs(sv_2mortal(newSViv(cords[4])));
2972           PUSHs(sv_2mortal(newSViv(cords[5])));
2973         }
2974
2975 undef_int
2976 i_wf_text(face, im, tx, ty, cl, size, text, align, aa)
2977         char *face
2978         Imager::ImgRaw im
2979         int tx
2980         int ty
2981         Imager::Color cl
2982         int size
2983         char *text
2984         int align
2985         int aa
2986       CODE:
2987         RETVAL = i_wf_text(face, im, tx, ty, cl, size, text, strlen(text), 
2988                            align, aa);
2989       OUTPUT:
2990         RETVAL
2991
2992 undef_int
2993 i_wf_cp(face, im, tx, ty, channel, size, text, align, aa)
2994         char *face
2995         Imager::ImgRaw im
2996         int tx
2997         int ty
2998         int channel
2999         int size
3000         char *text
3001         int align
3002         int aa
3003       CODE:
3004         RETVAL = i_wf_cp(face, im, tx, ty, channel, size, text, strlen(text), 
3005                          align, aa);
3006       OUTPUT:
3007         RETVAL
3008
3009
3010 #endif
3011
3012 #ifdef HAVE_FT2
3013
3014 MODULE = Imager         PACKAGE = Imager::Font::FT2     PREFIX=FT2_
3015
3016 #define FT2_DESTROY(font) i_ft2_destroy(font)
3017
3018 void
3019 FT2_DESTROY(font)
3020         Imager::Font::FT2 font
3021
3022 MODULE = Imager         PACKAGE = Imager::Font::FreeType2 
3023
3024 Imager::Font::FT2
3025 i_ft2_new(name, index)
3026         char *name
3027         int index
3028
3029 undef_int
3030 i_ft2_setdpi(font, xdpi, ydpi)
3031         Imager::Font::FT2 font
3032         int xdpi
3033         int ydpi
3034
3035 void
3036 i_ft2_getdpi(font)
3037         Imager::Font::FT2 font
3038       PREINIT:
3039         int xdpi, ydpi;
3040       CODE:
3041         if (i_ft2_getdpi(font, &xdpi, &ydpi)) {
3042           EXTEND(SP, 2);
3043           PUSHs(sv_2mortal(newSViv(xdpi)));
3044           PUSHs(sv_2mortal(newSViv(ydpi)));
3045         }
3046
3047 undef_int
3048 i_ft2_sethinting(font, hinting)
3049         Imager::Font::FT2 font
3050         int hinting
3051
3052 undef_int
3053 i_ft2_settransform(font, matrix)
3054         Imager::Font::FT2 font
3055       PREINIT:
3056         double matrix[6];
3057         int len;
3058         AV *av;
3059         SV *sv1;
3060         int i;
3061       CODE:
3062         if (!SvROK(ST(1)) || SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3063           croak("i_ft2_settransform: parameter 2 must be an array ref\n");
3064         av=(AV*)SvRV(ST(1));
3065         len=av_len(av)+1;
3066         if (len > 6)
3067           len = 6;
3068         for (i = 0; i < len; ++i) {
3069           sv1=(*(av_fetch(av,i,0)));
3070           matrix[i] = SvNV(sv1);
3071         }
3072         for (; i < 6; ++i)
3073           matrix[i] = 0;
3074         RETVAL = i_ft2_settransform(font, matrix);
3075       OUTPUT:
3076         RETVAL
3077
3078 void
3079 i_ft2_bbox(font, cheight, cwidth, text)
3080         Imager::Font::FT2 font
3081         double cheight
3082         double cwidth
3083         char *text
3084       PREINIT:
3085         int bbox[6];
3086         int i;
3087       PPCODE:
3088         if (i_ft2_bbox(font, cheight, cwidth, text, strlen(text), bbox)) {
3089           EXTEND(SP, 6);
3090           for (i = 0; i < 6; ++i)
3091             PUSHs(sv_2mortal(newSViv(bbox[i])));
3092         }
3093
3094 void
3095 i_ft2_bbox_r(font, cheight, cwidth, text, vlayout, utf8)
3096         Imager::Font::FT2 font
3097         double cheight
3098         double cwidth
3099         char *text
3100         int vlayout
3101         int utf8
3102       PREINIT:
3103         int bbox[8];
3104         int i;
3105       PPCODE:
3106 #ifdef SvUTF8
3107         if (SvUTF8(ST(3)))
3108           utf8 = 1;
3109 #endif
3110         if (i_ft2_bbox_r(font, cheight, cwidth, text, strlen(text), vlayout,
3111                          utf8, bbox)) {
3112           EXTEND(SP, 8);
3113           for (i = 0; i < 8; ++i)
3114             PUSHs(sv_2mortal(newSViv(bbox[i])));
3115         }
3116
3117 undef_int
3118 i_ft2_text(font, im, tx, ty, cl, cheight, cwidth, text, align, aa, vlayout, utf8)
3119         Imager::Font::FT2 font
3120         Imager::ImgRaw im
3121         int tx
3122         int ty
3123         Imager::Color cl
3124         double cheight
3125         double cwidth
3126         int align
3127         int aa
3128         int vlayout
3129         int utf8
3130       PREINIT:
3131         char *text;
3132         STRLEN len;
3133       CODE:
3134 #ifdef SvUTF8
3135         if (SvUTF8(ST(7))) {
3136           utf8 = 1;
3137         }
3138 #endif
3139         text = SvPV(ST(7), len);
3140         RETVAL = i_ft2_text(font, im, tx, ty, cl, cheight, cwidth, text,
3141                             len, align, aa, vlayout, utf8);
3142       OUTPUT:
3143         RETVAL
3144
3145 undef_int
3146 i_ft2_cp(font, im, tx, ty, channel, cheight, cwidth, text, align, aa, vlayout, utf8)
3147         Imager::Font::FT2 font
3148         Imager::ImgRaw im
3149         int tx
3150         int ty
3151         int channel
3152         double cheight
3153         double cwidth
3154         char *text
3155         int align
3156         int aa
3157         int vlayout
3158         int utf8
3159       CODE:
3160 #ifdef SvUTF8
3161         if (SvUTF8(ST(7)))
3162           utf8 = 1;
3163 #endif
3164         RETVAL = i_ft2_cp(font, im, tx, ty, channel, cheight, cwidth, text,
3165                           strlen(text), align, aa, vlayout, 1);
3166       OUTPUT:
3167         RETVAL
3168
3169 void
3170 ft2_transform_box(font, x0, x1, x2, x3)
3171         Imager::Font::FT2 font
3172         int x0
3173         int x1
3174         int x2
3175         int x3
3176       PREINIT:
3177         int box[4];
3178       PPCODE:
3179         box[0] = x0; box[1] = x1; box[2] = x2; box[3] = x3;
3180         ft2_transform_box(font, box);
3181           EXTEND(SP, 4);
3182           PUSHs(sv_2mortal(newSViv(box[0])));
3183           PUSHs(sv_2mortal(newSViv(box[1])));
3184           PUSHs(sv_2mortal(newSViv(box[2])));
3185           PUSHs(sv_2mortal(newSViv(box[3])));
3186         
3187 #endif
3188
3189 MODULE = Imager         PACKAGE = Imager::FillHandle PREFIX=IFILL_
3190
3191 void
3192 IFILL_DESTROY(fill)
3193         Imager::FillHandle fill
3194
3195 MODULE = Imager         PACKAGE = Imager
3196
3197 Imager::FillHandle
3198 i_new_fill_solid(cl, combine)
3199         Imager::Color cl
3200         int combine
3201
3202 Imager::FillHandle
3203 i_new_fill_solidf(cl, combine)
3204         Imager::Color::Float cl
3205         int combine
3206
3207 Imager::FillHandle
3208 i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy)
3209         Imager::Color fg
3210         Imager::Color bg
3211         int combine
3212         int hatch
3213         int dx
3214         int dy
3215       PREINIT:
3216         unsigned char *cust_hatch;
3217         STRLEN len;
3218       CODE:
3219         if (SvOK(ST(4))) {
3220           cust_hatch = SvPV(ST(4), len);
3221         }
3222         else
3223           cust_hatch = NULL;
3224         RETVAL = i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy);
3225       OUTPUT:
3226         RETVAL
3227
3228 Imager::FillHandle
3229 i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy)
3230         Imager::Color::Float fg
3231         Imager::Color::Float bg
3232         int combine
3233         int hatch
3234         int dx
3235         int dy
3236       PREINIT:
3237         unsigned char *cust_hatch;
3238         STRLEN len;
3239       CODE:
3240         if (SvOK(ST(4))) {
3241           cust_hatch = SvPV(ST(4), len);
3242         }
3243         else
3244           cust_hatch = NULL;
3245         RETVAL = i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy);
3246       OUTPUT:
3247         RETVAL
3248
3249 Imager::FillHandle
3250 i_new_fill_image(src, matrix, xoff, yoff, combine)
3251         Imager::ImgRaw src
3252         int xoff
3253         int yoff
3254         int combine
3255       PREINIT:
3256         double matrix[9];
3257         double *matrixp;
3258         AV *av;
3259         IV len;
3260         SV *sv1;
3261         int i;
3262       CODE:
3263         if (!SvOK(ST(1))) {
3264           matrixp = NULL;
3265         }
3266         else {
3267           if (!SvROK(ST(1)) || SvTYPE(SvRV(ST(1))) != SVt_PVAV)
3268             croak("i_new_fill_image: parameter must be an arrayref");
3269           av=(AV*)SvRV(ST(1));
3270           len=av_len(av)+1;
3271           if (len > 9)
3272             len = 9;
3273           for (i = 0; i < len; ++i) {
3274             sv1=(*(av_fetch(av,i,0)));
3275             matrix[i] = SvNV(sv1);
3276           }
3277           for (; i < 9; ++i)
3278             matrix[i] = 0;
3279           matrixp = matrix;
3280         }
3281         RETVAL = i_new_fill_image(src, matrixp, xoff, yoff, combine);
3282       OUTPUT:
3283         RETVAL