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