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