projects / imager.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
notes Win32 libpng and set_internal changes
[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;
19typedef i_img* Imager__ImgRaw;
20
21
22#ifdef HAVE_LIBTT
23typedef TT_Fonthandle* Imager__TTHandle;
24#endif
25
26typedef struct i_reader_data_tag
27{
28 /* presumably a CODE ref or name of a sub */
29 SV *sv;
30} i_reader_data;
31
32/* used by functions that want callbacks */
33static int read_callback(char *userdata, char *buffer, int need, int want) {
34 i_reader_data *rd = (i_reader_data *)userdata;
35 int count;
36 int result;
37 SV *data;
38 dSP; dTARG = sv_newmortal();
39 /* thanks to Simon Cozens for help with the dTARG above */
40
41 ENTER;
42 SAVETMPS;
43 EXTEND(SP, 2);
44 PUSHMARK(SP);
45 PUSHi(want);
46 PUSHi(need);
47 PUTBACK;
48
49 count = perl_call_sv(rd->sv, G_SCALAR);
50
51 SPAGAIN;
52
53 if (count != 1)
54 croak("Result of perl_call_sv(..., G_SCALAR) != 1");
55
56 data = POPs;
57
58 if (SvOK(data)) {
59 STRLEN len;
60 char *ptr = SvPV(data, len);
61 if (len > want)
62 croak("Too much data returned in reader callback");
63
64 memcpy(buffer, ptr, len);
65 result = len;
66 }
67 else {
68 result = -1;
69 }
70
71 PUTBACK;
72 FREETMPS;
73 LEAVE;
74
75 return result;
76}
77
78typedef struct
79{
80 SV *sv; /* a coderef or sub name */
81} i_writer_data;
82
83/* used by functions that want callbacks */
84static int write_callback(char *userdata, char const *data, int size) {
85 i_writer_data *wd = (i_writer_data *)userdata;
86 int count;
87 int success;
88 SV *sv;
89 dSP;
90
91 ENTER;
92 SAVETMPS;
93 EXTEND(SP, 1);
94 PUSHMARK(SP);
95 XPUSHs(sv_2mortal(newSVpv((char *)data, size)));
96 PUTBACK;
97
98 count = perl_call_sv(wd->sv, G_SCALAR);
99
100 SPAGAIN;
101
102 if (count != 1)
103 croak("Result of perl_call_sv(..., G_SCALAR) != 1");
104
105 sv = POPs;
106 success = SvTRUE(sv);
107
108
109 PUTBACK;
110 FREETMPS;
111 LEAVE;
112
113 return success;
114}
115
116struct value_name {
117 char *name;
118 int value;
119};
120static int lookup_name(struct value_name *names, int count, char *name, int def_value)
121{
122 int i;
123 for (i = 0; i < count; ++i)
124 if (strEQ(names[i].name, name))
125 return names[i].value;
126
127 return def_value;
128}
129static struct value_name transp_names[] =
130{
131 { "none", tr_none },
132 { "threshold", tr_threshold },
133 { "errdiff", tr_errdiff },
134 { "ordered", tr_ordered, },
135};
136
137static struct value_name make_color_names[] =
138{
139 { "none", mc_none, },
140 { "webmap", mc_web_map, },
141 { "addi", mc_addi, },
142};
143
144static struct value_name translate_names[] =
145{
146#ifdef HAVE_LIBGIF
147 { "giflib", pt_giflib, },
148#endif
149 { "closest", pt_closest, },
150 { "perturb", pt_perturb, },
151 { "errdiff", pt_errdiff, },
152};
153
154static struct value_name errdiff_names[] =
155{
156 { "floyd", ed_floyd, },
157 { "jarvis", ed_jarvis, },
158 { "stucki", ed_stucki, },
159 { "custom", ed_custom, },
160};
161
162static struct value_name orddith_names[] =
163{
164 { "random", od_random, },
165 { "dot8", od_dot8, },
166 { "dot4", od_dot4, },
167 { "hline", od_hline, },
168 { "vline", od_vline, },
169 { "/line", od_slashline, },
170 { "slashline", od_slashline, },
171 { "\\line", od_backline, },
172 { "backline", od_backline, },
173 { "custom", od_custom, },
174};
175
176/* look through the hash for quantization options */
177static void handle_quant_opts(i_quantize *quant, HV *hv)
178{
179 /*** POSSIBLY BROKEN: do I need to unref the SV from hv_fetch ***/
180 SV **sv;
181 int i;
182 STRLEN len;
183 char *str;
184
185 sv = hv_fetch(hv, "transp", 6, 0);
186 if (sv && *sv && (str = SvPV(*sv, len))) {
187 quant->transp =
188 lookup_name(transp_names, sizeof(transp_names)/sizeof(*transp_names),
189 str, tr_none);
190 if (quant->transp != tr_none) {
191 quant->tr_threshold = 127;
192 sv = hv_fetch(hv, "tr_threshold", 12, 0);
193 if (sv && *sv)
194 quant->tr_threshold = SvIV(*sv);
195 }
196 if (quant->transp == tr_errdiff) {
197 sv = hv_fetch(hv, "tr_errdiff", 10, 0);
198 if (sv && *sv && (str = SvPV(*sv, len)))
199 quant->tr_errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
200 }
201 if (quant->transp == tr_ordered) {
202 quant->tr_orddith = od_random;
203 sv = hv_fetch(hv, "tr_orddith", 10, 0);
204 if (sv && *sv && (str = SvPV(*sv, len)))
205 quant->tr_orddith = lookup_name(orddith_names, sizeof(orddith_names)/sizeof(*orddith_names), str, od_random);
206
207 if (quant->tr_orddith == od_custom) {
208 sv = hv_fetch(hv, "tr_map", 6, 0);
209 if (sv && *sv && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
210 AV *av = (AV*)SvRV(*sv);
211 len = av_len(av) + 1;
212 if (len > sizeof(quant->tr_custom))
213 len = sizeof(quant->tr_custom);
214 for (i = 0; i < len; ++i) {
215 SV **sv2 = av_fetch(av, i, 0);
216 if (sv2 && *sv2) {
217 quant->tr_custom[i] = SvIV(*sv2);
218 }
219 }
220 while (i < sizeof(quant->tr_custom))
221 quant->tr_custom[i++] = 0;
222 }
223 }
224 }
225 }
226 quant->make_colors = mc_addi;
227 sv = hv_fetch(hv, "make_colors", 11, 0);
228 if (sv && *sv && (str = SvPV(*sv, len))) {
229 quant->make_colors =
230 lookup_name(make_color_names, sizeof(make_color_names)/sizeof(*make_color_names), str, mc_addi);
231 }
232 sv = hv_fetch(hv, "colors", 6, 0);
233 if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
234 /* needs to be an array of Imager::Color
235 note that the caller allocates the mc_color array and sets mc_size
236 to it's size */
237 AV *av = (AV *)SvRV(*sv);
238 quant->mc_count = av_len(av)+1;
239 if (quant->mc_count > quant->mc_size)
240 quant->mc_count = quant->mc_size;
241 for (i = 0; i < quant->mc_count; ++i) {
242 SV **sv1 = av_fetch(av, i, 0);
243 if (sv1 && *sv1 && SvROK(*sv1) && sv_derived_from(*sv1, "Imager::Color")) {
244 i_color *col = (i_color *)SvIV((SV*)SvRV(*sv1));
245 quant->mc_colors[i] = *col;
246 }
247 }
248 }
249 sv = hv_fetch(hv, "max_colors", 10, 0);
250 if (sv && *sv) {
251 i = SvIV(*sv);
252 if (i <= quant->mc_size && i >= quant->mc_count)
253 quant->mc_size = i;
254 }
255
256 quant->translate = pt_closest;
257 sv = hv_fetch(hv, "translate", 9, 0);
258 if (sv && *sv && (str = SvPV(*sv, len))) {
259 quant->translate = lookup_name(translate_names, sizeof(translate_names)/sizeof(*translate_names), str, pt_closest);
260 }
261 sv = hv_fetch(hv, "errdiff", 7, 0);
262 if (sv && *sv && (str = SvPV(*sv, len))) {
263 quant->errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
264 }
265 if (quant->translate == pt_errdiff && quant->errdiff == ed_custom) {
266 /* get the error diffusion map */
267 sv = hv_fetch(hv, "errdiff_width", 13, 0);
268 if (sv && *sv)
269 quant->ed_width = SvIV(*sv);
270 sv = hv_fetch(hv, "errdiff_height", 14, 0);
271 if (sv && *sv)
272 quant->ed_height = SvIV(*sv);
273 sv = hv_fetch(hv, "errdiff_orig", 12, 0);
274 if (sv && *sv)
275 quant->ed_orig = SvIV(*sv);
276 if (quant->ed_width > 0 && quant->ed_height > 0) {
277 int sum = 0;
278 quant->ed_map = mymalloc(sizeof(int)*quant->ed_width*quant->ed_height);
279 sv = hv_fetch(hv, "errdiff_map", 11, 0);
280 if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
281 AV *av = (AV*)SvRV(*sv);
282 len = av_len(av) + 1;
283 if (len > quant->ed_width * quant->ed_height)
284 len = quant->ed_width * quant->ed_height;
285 for (i = 0; i < len; ++i) {
286 SV **sv2 = av_fetch(av, i, 0);
287 if (sv2 && *sv2) {
288 quant->ed_map[i] = SvIV(*sv2);
289 sum += quant->ed_map[i];
290 }
291 }
292 }
293 if (!sum) {
294 /* broken map */
295 myfree(quant->ed_map);
296 quant->ed_map = 0;
297 quant->errdiff = ed_floyd;
298 }
299 }
300 }
301 sv = hv_fetch(hv, "perturb", 7, 0);
302 if (sv && *sv)
303 quant->perturb = SvIV(*sv);
304}
305
306/* look through the hash for options to add to opts */
307static void handle_gif_opts(i_gif_opts *opts, HV *hv)
308{
309 /*** FIXME: POSSIBLY BROKEN: do I need to unref the SV from hv_fetch? ***/
310 SV **sv;
311 int i;
312 /**((char *)0) = '\0';*/
313 sv = hv_fetch(hv, "gif_each_palette", 16, 0);
314 if (sv && *sv)
315 opts->each_palette = SvIV(*sv);
316 sv = hv_fetch(hv, "interlace", 9, 0);
317 if (sv && *sv)
318 opts->interlace = SvIV(*sv);
319 sv = hv_fetch(hv, "gif_delays", 10, 0);
320 if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
321 AV *av = (AV*)SvRV(*sv);
322 opts->delay_count = av_len(av)+1;
323 opts->delays = mymalloc(sizeof(int) * opts->delay_count);
324 for (i = 0; i < opts->delay_count; ++i) {
325 SV *sv1 = *av_fetch(av, i, 0);
326 opts->delays[i] = SvIV(sv1);
327 }
328 }
329 sv = hv_fetch(hv, "gif_user_input", 14, 0);
330 if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
331 AV *av = (AV*)SvRV(*sv);
332 opts->user_input_count = av_len(av)+1;
333 opts->user_input_flags = mymalloc(opts->user_input_count);
334 for (i = 0; i < opts->user_input_count; ++i) {
335 SV *sv1 = *av_fetch(av, i, 0);
336 opts->user_input_flags[i] = SvIV(sv1) != 0;
337 }
338 }
339 sv = hv_fetch(hv, "gif_disposal", 12, 0);
340 if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
341 AV *av = (AV*)SvRV(*sv);
342 opts->disposal_count = av_len(av)+1;
343 opts->disposal = mymalloc(opts->disposal_count);
344 for (i = 0; i < opts->disposal_count; ++i) {
345 SV *sv1 = *av_fetch(av, i, 0);
346 opts->disposal[i] = SvIV(sv1);
347 }
348 }
349 sv = hv_fetch(hv, "gif_tran_color", 14, 0);
350 if (sv && *sv && SvROK(*sv) && sv_derived_from(*sv, "Imager::Color")) {
351 i_color *col = (i_color *)SvIV((SV *)SvRV(*sv));
352 opts->tran_color = *col;
353 }
354 sv = hv_fetch(hv, "gif_positions", 13, 0);
355 if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
356 AV *av = (AV *)SvRV(*sv);
357 opts->position_count = av_len(av) + 1;
358 opts->positions = mymalloc(sizeof(i_gif_pos) * opts->position_count);
359 for (i = 0; i < opts->position_count; ++i) {
360 SV **sv2 = av_fetch(av, i, 0);
361 opts->positions[i].x = opts->positions[i].y = 0;
362 if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
363 AV *av2 = (AV*)SvRV(*sv2);
364 SV **sv3;
365 sv3 = av_fetch(av2, 0, 0);
366 if (sv3 && *sv3)
367 opts->positions[i].x = SvIV(*sv3);
368 sv3 = av_fetch(av2, 1, 0);
369 if (sv3 && *sv3)
370 opts->positions[i].y = SvIV(*sv3);
371 }
372 }
373 }
374 /* Netscape2.0 loop count extension */
375 sv = hv_fetch(hv, "gif_loop_count", 14, 0);
376 if (sv && *sv)
377 opts->loop_count = SvIV(*sv);
378}
379
380/* copies the color map from the hv into the colors member of the HV */
381static void copy_colors_back(HV *hv, i_quantize *quant) {
382 SV **sv;
383 AV *av;
384 int i;
385 SV *work;
386
387 sv = hv_fetch(hv, "colors", 6, 0);
388 if (!sv || !*sv || !SvROK(*sv) || SvTYPE(SvRV(*sv)) != SVt_PVAV) {
389 SV *ref;
390 av = newAV();
391 ref = newRV_inc((SV*) av);
392 sv = hv_store(hv, "colors", 6, ref, 0);
393 }
394 else {
395 av = (AV *)SvRV(*sv);
396 }
397 av_extend(av, quant->mc_count+1);
398 for (i = 0; i < quant->mc_count; ++i) {
399 i_color *in = quant->mc_colors+i;
400 Imager__Color c = ICL_new_internal(in->rgb.r, in->rgb.g, in->rgb.b, 255);
401 work = sv_newmortal();
402 sv_setref_pv(work, "Imager::Color", (void *)c);
403 SvREFCNT_inc(work);
404 if (!av_store(av, i, work)) {
405 SvREFCNT_dec(work);
406 }
407 }
408}
409
02d1d628
AMH		 410MODULE = Imager PACKAGE = Imager::Color PREFIX = ICL_
411
412Imager::Color
413ICL_new_internal(r,g,b,a)
414 unsigned char r
415 unsigned char g
416 unsigned char b
417 unsigned char a
418
419void
420ICL_DESTROY(cl)
421 Imager::Color cl
422
423
29106a11 424void
02d1d628
AMH		 425ICL_set_internal(cl,r,g,b,a)
426 Imager::Color cl
427 unsigned char r
428 unsigned char g
429 unsigned char b
430 unsigned char a
29106a11
TC		 431 PPCODE:
432 EXTEND(SP, 1);
433 PUSHs(ST(0));
02d1d628
AMH		 434
435void
436ICL_info(cl)
437 Imager::Color cl
438
439
440void
441ICL_rgba(cl)
442 Imager::Color cl
443 PPCODE:
444 EXTEND(SP, 4);
445 PUSHs(sv_2mortal(newSVnv(cl->rgba.r)));
446 PUSHs(sv_2mortal(newSVnv(cl->rgba.g)));
447 PUSHs(sv_2mortal(newSVnv(cl->rgba.b)));
448 PUSHs(sv_2mortal(newSVnv(cl->rgba.a)));
449
450
451
452
453
454
455
456MODULE = Imager PACKAGE = Imager::ImgRaw PREFIX = IIM_
457
458Imager::ImgRaw
459IIM_new(x,y,ch)
460 int x
461 int y
462 int ch
463
464void
465IIM_DESTROY(im)
466 Imager::ImgRaw im
467
468
469
470MODULE = Imager PACKAGE = Imager
471
472PROTOTYPES: ENABLE
473
474
475Imager::IO
476io_new_fd(fd)
477 int fd
478
479Imager::IO
480io_new_bufchain()
481
482
483void
484io_slurp(ig)
485 Imager::IO ig
486 PREINIT:
487 unsigned char* data;
488 size_t tlength;
489 SV* r;
490 PPCODE:
491 data = NULL;
492 tlength = io_slurp(ig, &data);
493 r = sv_newmortal();
494 EXTEND(SP,1);
495 PUSHs(sv_2mortal(newSVpv(data,tlength)));
496 myfree(data);
497
498
499
500void
501i_list_formats()
502 PREINIT:
503 char* item;
504 int i;
505 PPCODE:
506 i=0;
507 while( (item=i_format_list[i++]) != NULL ) {
508 EXTEND(SP, 1);
509 PUSHs(sv_2mortal(newSVpv(item,0)));
510 }
511
512undef_int
513i_has_format(frmt)
514 char* frmt
515
516Imager::ImgRaw
517i_img_new()
518
519Imager::ImgRaw
520i_img_empty(im,x,y)
521 Imager::ImgRaw im
522 int x
523 int y
524
525Imager::ImgRaw
526i_img_empty_ch(im,x,y,ch)
527 Imager::ImgRaw im
528 int x
529 int y
530 int ch
531
532void
533init_log(name,level)
534 char* name
535 int level
536
537void
538i_img_exorcise(im)
539 Imager::ImgRaw im
540
541void
542i_img_destroy(im)
543 Imager::ImgRaw im
544
545void
546i_img_info(im)
547 Imager::ImgRaw im
548 PREINIT:
549 int info[4];
550 PPCODE:
551 i_img_info(im,info);
552 EXTEND(SP, 4);
553 PUSHs(sv_2mortal(newSViv(info[0])));
554 PUSHs(sv_2mortal(newSViv(info[1])));
555 PUSHs(sv_2mortal(newSViv(info[2])));
556 PUSHs(sv_2mortal(newSViv(info[3])));
557
558
559
560
561void
562i_img_setmask(im,ch_mask)
563 Imager::ImgRaw im
564 int ch_mask
565
566int
567i_img_getmask(im)
568 Imager::ImgRaw im
569
570int
571i_img_getchannels(im)
572 Imager::ImgRaw im
573
574void
575i_img_getdata(im)
576 Imager::ImgRaw im
577 PPCODE:
578 EXTEND(SP, 1);
579 PUSHs(sv_2mortal(newSVpv(im->data, im->bytes)));
580
581
582void
583i_draw(im,x1,y1,x2,y2,val)
584 Imager::ImgRaw im
585 int x1
586 int y1
587 int x2
588 int y2
589 Imager::Color val
590
591void
592i_line_aa(im,x1,y1,x2,y2,val)
593 Imager::ImgRaw im
594 int x1
595 int y1
596 int x2
597 int y2
598 Imager::Color val
599
600void
601i_box(im,x1,y1,x2,y2,val)
602 Imager::ImgRaw im
603 int x1
604 int y1
605 int x2
606 int y2
607 Imager::Color val
608
609void
610i_box_filled(im,x1,y1,x2,y2,val)
611 Imager::ImgRaw im
612 int x1
613 int y1
614 int x2
615 int y2
616 Imager::Color val
617
618void
619i_arc(im,x,y,rad,d1,d2,val)
620 Imager::ImgRaw im
621 int x
622 int y
623 float rad
624 float d1
625 float d2
626 Imager::Color val
627
628
629
630void
631i_bezier_multi(im,xc,yc,val)
632 Imager::ImgRaw im
633 Imager::Color val
634 PREINIT:
635 double *x,*y;
636 int len;
637 AV *av1;
638 AV *av2;
639 SV *sv1;
640 SV *sv2;
641 int i;
642 PPCODE:
643 ICL_info(val);
644 if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
645 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
646 if (!SvROK(ST(2))) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
647 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
648 av1=(AV*)SvRV(ST(1));
649 av2=(AV*)SvRV(ST(2));
650 if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_bezier_multi must be equal length\n");
651 len=av_len(av1)+1;
652 x=mymalloc( len*sizeof(double) );
653 y=mymalloc( len*sizeof(double) );
654 for(i=0;i<len;i++) {
655 sv1=(*(av_fetch(av1,i,0)));
656 sv2=(*(av_fetch(av2,i,0)));
657 x[i]=(double)SvNV(sv1);
658 y[i]=(double)SvNV(sv2);
659 }
660 i_bezier_multi(im,len,x,y,val);
661 myfree(x);
662 myfree(y);
663
664
665void
666i_poly_aa(im,xc,yc,val)
667 Imager::ImgRaw im
668 Imager::Color val
669 PREINIT:
670 double *x,*y;
671 int len;
672 AV *av1;
673 AV *av2;
674 SV *sv1;
675 SV *sv2;
676 int i;
677 PPCODE:
678 ICL_info(val);
679 if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
680 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
681 if (!SvROK(ST(2))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
682 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
683 av1=(AV*)SvRV(ST(1));
684 av2=(AV*)SvRV(ST(2));
685 if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_poly_aa must be equal length\n");
686 len=av_len(av1)+1;
687 x=mymalloc( len*sizeof(double) );
688 y=mymalloc( len*sizeof(double) );
689 for(i=0;i<len;i++) {
690 sv1=(*(av_fetch(av1,i,0)));
691 sv2=(*(av_fetch(av2,i,0)));
692 x[i]=(double)SvNV(sv1);
693 y[i]=(double)SvNV(sv2);
694 }
695 i_poly_aa(im,len,x,y,val);
696 myfree(x);
697 myfree(y);
698
699
700
701void
702i_flood_fill(im,seedx,seedy,dcol)
703 Imager::ImgRaw im
704 int seedx
705 int seedy
706 Imager::Color dcol
707
708
709void
710i_copyto(im,src,x1,y1,x2,y2,tx,ty)
711 Imager::ImgRaw im
712 Imager::ImgRaw src
713 int x1
714 int y1
715 int x2
716 int y2
717 int tx
718 int ty
719
720
721void
722i_copyto_trans(im,src,x1,y1,x2,y2,tx,ty,trans)
723 Imager::ImgRaw im
724 Imager::ImgRaw src
725 int x1
726 int y1
727 int x2
728 int y2
729 int tx
730 int ty
731 Imager::Color trans
732
733void
734i_copy(im,src)
735 Imager::ImgRaw im
736 Imager::ImgRaw src
737
738
739void
740i_rubthru(im,src,tx,ty)
741 Imager::ImgRaw im
742 Imager::ImgRaw src
743 int tx
744 int ty
745
746
747void
748i_gaussian(im,stdev)
749 Imager::ImgRaw im
750 float stdev
751
752void
753i_conv(im,pcoef)
754 Imager::ImgRaw im
755 PREINIT:
756 float* coeff;
757 int len;
758 AV* av;
759 SV* sv1;
760 int i;
761 PPCODE:
762 if (!SvROK(ST(1))) croak("Imager: Parameter 1 must be a reference to an array\n");
763 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 must be a reference to an array\n");
764 av=(AV*)SvRV(ST(1));
765 len=av_len(av)+1;
766 coeff=mymalloc( len*sizeof(float) );
767 for(i=0;i<len;i++) {
768 sv1=(*(av_fetch(av,i,0)));
769 coeff[i]=(float)SvNV(sv1);
770 }
771 i_conv(im,coeff,len);
772 myfree(coeff);
773
774
775float
776i_img_diff(im1,im2)
777 Imager::ImgRaw im1
778 Imager::ImgRaw im2
779
780
781
782undef_int
783i_init_fonts()
784
785#ifdef HAVE_LIBT1
786
787void
788i_t1_set_aa(st)
789 int st
790
791int
792i_t1_new(pfb,afm=NULL)
793 char* pfb
794 char* afm
795
796int
797i_t1_destroy(font_id)
798 int font_id
799
800
801undef_int
802i_t1_cp(im,xb,yb,channel,fontnum,points,str,len,align)
803 Imager::ImgRaw im
804 int xb
805 int yb
806 int channel
807 int fontnum
808 float points
809 char* str
810 int len
811 int align
812
813void
814i_t1_bbox(fontnum,point,str,len)
815 int fontnum
816 float point
817 char* str
818 int len
819 PREINIT:
820 int cords[6];
821 PPCODE:
822 i_t1_bbox(fontnum,point,str,len,cords);
823 EXTEND(SP, 4);
824 PUSHs(sv_2mortal(newSViv(cords[0])));
825 PUSHs(sv_2mortal(newSViv(cords[1])));
826 PUSHs(sv_2mortal(newSViv(cords[2])));
827 PUSHs(sv_2mortal(newSViv(cords[3])));
828 PUSHs(sv_2mortal(newSViv(cords[4])));
829 PUSHs(sv_2mortal(newSViv(cords[5])));
830
831
832
833undef_int
834i_t1_text(im,xb,yb,cl,fontnum,points,str,len,align)
835 Imager::ImgRaw im
836 int xb
837 int yb
838 Imager::Color cl
839 int fontnum
840 float points
841 char* str
842 int len
843 int align
844
845#endif
846
847#ifdef HAVE_LIBTT
848
849
850Imager::TTHandle
851i_tt_new(fontname)
852 char* fontname
853
854void
855i_tt_destroy(handle)
856 Imager::TTHandle handle
857
858
859
860undef_int
861i_tt_text(handle,im,xb,yb,cl,points,str,len,smooth)
862 Imager::TTHandle handle
863 Imager::ImgRaw im
864 int xb
865 int yb
866 Imager::Color cl
867 float points
868 char* str
869 int len
870 int smooth
871
872
873undef_int
874i_tt_cp(handle,im,xb,yb,channel,points,str,len,smooth)
875 Imager::TTHandle handle
876 Imager::ImgRaw im
877 int xb
878 int yb
879 int channel
880 float points
881 char* str
882 int len
883 int smooth
884
885
886
887undef_int
888i_tt_bbox(handle,point,str,len)
889 Imager::TTHandle handle
890 float point
891 char* str
892 int len
893 PREINIT:
894 int cords[6],rc;
895 PPCODE:
896 if ((rc=i_tt_bbox(handle,point,str,len,cords))) {
897 EXTEND(SP, 4);
898 PUSHs(sv_2mortal(newSViv(cords[0])));
899 PUSHs(sv_2mortal(newSViv(cords[1])));
900 PUSHs(sv_2mortal(newSViv(cords[2])));
901 PUSHs(sv_2mortal(newSViv(cords[3])));
902 PUSHs(sv_2mortal(newSViv(cords[4])));
903 PUSHs(sv_2mortal(newSViv(cords[5])));
904 }
905
906
907#endif
908
909
910
911
912#ifdef HAVE_LIBJPEG
913undef_int
914i_writejpeg(im,fd,qfactor)
915 Imager::ImgRaw im
916 int fd
917 int qfactor
918
919void
920i_readjpeg(fd)
921 int fd
922 PREINIT:
923 char* iptc_itext;
924 int tlength;
925 i_img* rimg;
926 SV* r;
927 PPCODE:
928 iptc_itext = NULL;
929 rimg=i_readjpeg(fd,&iptc_itext,&tlength);
930 if (iptc_itext == NULL) {
931 r = sv_newmortal();
932 EXTEND(SP,1);
933 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
934 PUSHs(r);
935 } else {
936 r = sv_newmortal();
937 EXTEND(SP,2);
938 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
939 PUSHs(r);
940 PUSHs(sv_2mortal(newSVpv(iptc_itext,tlength)));
941 myfree(iptc_itext);
942 }
943
944
945void
946i_readjpeg_scalar(...)
947 PROTOTYPE: $
948 PREINIT:
949 char* data;
950 unsigned int length;
951 char* iptc_itext;
952 int tlength;
953 i_img* rimg;
954 SV* r;
955 PPCODE:
956 iptc_itext = NULL;
957 data = (char *)SvPV(ST(0), length);
958 rimg=i_readjpeg_scalar(data,length,&iptc_itext,&tlength);
959 mm_log((1,"i_readjpeg_scalar: 0x%08X\n",rimg));
960 if (iptc_itext == NULL) {
961 r = sv_newmortal();
962 EXTEND(SP,1);
963 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
964 PUSHs(r);
965 } else {
966 r = sv_newmortal();
967 EXTEND(SP,2);
968 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
969 PUSHs(r);
970 PUSHs(sv_2mortal(newSVpv(iptc_itext,tlength)));
971 myfree(iptc_itext);
972 }
973
974
975void
976i_readjpeg_wiol(ig)
977 Imager::IO ig
978 PREINIT:
979 char* iptc_itext;
980 int tlength;
981 i_img* rimg;
982 SV* r;
983 PPCODE:
984 iptc_itext = NULL;
985 rimg = i_readjpeg_wiol(ig,-1,&iptc_itext,&tlength);
986 if (iptc_itext == NULL) {
987 r = sv_newmortal();
988 EXTEND(SP,1);
989 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
990 PUSHs(r);
991 } else {
992 r = sv_newmortal();
993 EXTEND(SP,2);
994 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
995 PUSHs(r);
996 PUSHs(sv_2mortal(newSVpv(iptc_itext,tlength)));
997 myfree(iptc_itext);
998 }
999
1000
1001#endif
1002
1003
1004
1005
1006#ifdef HAVE_LIBTIFF
1007
1008Imager::ImgRaw
1009i_readtiff_wiol(ig, length)
1010 Imager::IO ig
1011 int length
1012
1013
1014undef_int
1015i_writetiff_wiol(im, ig)
1016 Imager::ImgRaw im
1017 Imager::IO ig
1018
1019
1020#endif /* HAVE_LIBTIFF */
1021
1022
1023
1024
1025
1026#ifdef HAVE_LIBPNG
1027
1028Imager::ImgRaw
1029i_readpng(fd)
1030 int fd
1031
1032
1033undef_int
1034i_writepng(im,fd)
1035 Imager::ImgRaw im
1036 int fd
1037
1038
1039Imager::ImgRaw
1040i_readpng_scalar(...)
1041 PROTOTYPE: $
1042 PREINIT:
1043 char* data;
1044 unsigned int length;
1045 CODE:
1046 data = (char *)SvPV(ST(0), length);
1047 RETVAL=i_readpng_scalar(data,length);
1048 OUTPUT:
1049 RETVAL
1050
1051
1052
1053#endif
1054
1055
1056#ifdef HAVE_LIBGIF
1057
1058undef_int
1059i_writegif(im,fd,colors,pixdev,fixed)
1060 Imager::ImgRaw im
1061 int fd
1062 int colors
1063 int pixdev
1064 PREINIT:
1065 int fixedlen;
1066 Imager__Color fixed;
1067 Imager__Color tmp;
1068 AV* av;
1069 SV* sv1;
1070 IV Itmp;
1071 int i;
1072 CODE:
1073 if (!SvROK(ST(4))) croak("Imager: Parameter 4 must be a reference to an array\n");
1074 if (SvTYPE(SvRV(ST(4))) != SVt_PVAV) croak("Imager: Parameter 4 must be a reference to an array\n");
1075 av=(AV*)SvRV(ST(4));
1076 fixedlen=av_len(av)+1;
1077 fixed=mymalloc( fixedlen*sizeof(i_color) );
1078 for(i=0;i<fixedlen;i++) {
1079 sv1=(*(av_fetch(av,i,0)));
1080 if (sv_derived_from(sv1, "Imager::Color")) {
1081 Itmp = SvIV((SV*)SvRV(sv1));
1082 tmp = (i_color*) Itmp;
1083 } else croak("Imager: one of the elements of array ref is not of Imager::Color type\n");
1084 fixed[i]=*tmp;
1085 }
1086 RETVAL=i_writegif(im,fd,colors,pixdev,fixedlen,fixed);
1087 myfree(fixed);
1088 ST(0) = sv_newmortal();
1089 if (RETVAL == 0) ST(0)=&PL_sv_undef;
1090 else sv_setiv(ST(0), (IV)RETVAL);
1091
1092
1093
1094
1095undef_int
1096i_writegifmc(im,fd,colors)
1097 Imager::ImgRaw im
1098 int fd
1099 int colors
1100
1101undef_int
1102i_writegifex(im,fd)
1103 Imager::ImgRaw im
1104 int fd
1105
1106undef_int
1107i_writegif_gen(fd, ...)
1108 int fd
1109 PROTOTYPE: $$@
1110 PREINIT:
1111 i_quantize quant;
1112 i_gif_opts opts;
1113 i_img **imgs = NULL;
1114 int img_count;
1115 int i;
1116 HV *hv;
1117 CODE:
1118 if (items < 3)
1119 croak("Usage: i_writegif_gen(fd,hashref, images...)");
1120 if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
1121 croak("i_writegif_gen: Second argument must be a hash ref");
1122 hv = (HV *)SvRV(ST(1));
1123 memset(&quant, 0, sizeof(quant));
1124 quant.mc_size = 256;
1125 quant.mc_colors = mymalloc(quant.mc_size * sizeof(i_color));
1126 memset(&opts, 0, sizeof(opts));
1127 handle_quant_opts(&quant, hv);
1128 handle_gif_opts(&opts, hv);
1129 img_count = items - 2;
1130 RETVAL = 1;
1131 if (img_count < 1) {
1132 RETVAL = 0;
1133 }
1134 else {
1135 imgs = mymalloc(sizeof(i_img *) * img_count);
1136 for (i = 0; i < img_count; ++i) {
1137 SV *sv = ST(2+i);
1138 imgs[i] = NULL;
1139 if (SvROK(sv) && sv_derived_from(sv, "Imager::ImgRaw")) {
1140 imgs[i] = (i_img *)SvIV((SV*)SvRV(sv));
1141 }
1142 else {
1143 RETVAL = 0;
1144 break;
1145 }
1146 }
1147 if (RETVAL) {
1148 RETVAL = i_writegif_gen(&quant, fd, imgs, img_count, &opts);
1149 }
1150 myfree(imgs);
1151 if (RETVAL) {
1152 copy_colors_back(hv, &quant);
1153 }
1154 }
1155 ST(0) = sv_newmortal();
1156 if (RETVAL == 0) ST(0)=&PL_sv_undef;
1157 else sv_setiv(ST(0), (IV)RETVAL);
1158
1159undef_int
1160i_writegif_callback(cb, maxbuffer,...)
1161 int maxbuffer;
1162 PREINIT:
1163 i_quantize quant;
1164 i_gif_opts opts;
1165 i_img **imgs = NULL;
1166 int img_count;
1167 int i;
1168 HV *hv;
1169 i_writer_data wd;
1170 CODE:
1171 if (items < 4)
1172 croak("Usage: i_writegif_callback(\\&callback,maxbuffer,hashref, images...)");
1173 if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
1174 croak("i_writegif_callback: Second argument must be a hash ref");
1175 hv = (HV *)SvRV(ST(2));
1176 memset(&quant, 0, sizeof(quant));
1177 quant.mc_size = 256;
1178 quant.mc_colors = mymalloc(quant.mc_size * sizeof(i_color));
1179 memset(&opts, 0, sizeof(opts));
1180 handle_quant_opts(&quant, hv);
1181 handle_gif_opts(&opts, hv);
1182 img_count = items - 3;
1183 RETVAL = 1;
1184 if (img_count < 1) {
1185 RETVAL = 0;
1186 }
1187 else {
1188 imgs = mymalloc(sizeof(i_img *) * img_count);
1189 for (i = 0; i < img_count; ++i) {
1190 SV *sv = ST(3+i);
1191 imgs[i] = NULL;
1192 if (SvROK(sv) && sv_derived_from(sv, "Imager::ImgRaw")) {
1193 imgs[i] = (i_img *)SvIV((SV*)SvRV(sv));
1194 }
1195 else {
1196 RETVAL = 0;
1197 break;
1198 }
1199 }
1200 if (RETVAL) {
1201 wd.sv = ST(0);
1202 RETVAL = i_writegif_callback(&quant, write_callback, (char *)&wd, maxbuffer, imgs, img_count, &opts);
1203 }
1204 myfree(imgs);
1205 if (RETVAL) {
1206 copy_colors_back(hv, &quant);
1207 }
1208 }
1209 ST(0) = sv_newmortal();
1210 if (RETVAL == 0) ST(0)=&PL_sv_undef;
1211 else sv_setiv(ST(0), (IV)RETVAL);
1212
1213void
1214i_readgif(fd)
1215 int fd
1216 PREINIT:
1217 int* colour_table;
1218 int colours, q, w;
1219 i_img* rimg;
1220 SV* temp[3];
1221 AV* ct;
1222 SV* r;
1223 PPCODE:
1224 colour_table = NULL;
1225 colours = 0;
1226
1227 if(GIMME_V == G_ARRAY) {
1228 rimg = i_readgif(fd,&colour_table,&colours);
1229 } else {
1230 /* don't waste time with colours if they aren't wanted */
1231 rimg = i_readgif(fd,NULL,NULL);
1232 }
1233
1234 if (colour_table == NULL) {
1235 EXTEND(SP,1);
1236 r=sv_newmortal();
1237 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1238 PUSHs(r);
1239 } else {
1240 /* the following creates an [[r,g,b], [r, g, b], [r, g, b]...] */
1241 /* I don't know if I have the reference counts right or not :( */
1242 /* Neither do I :-) */
1243 /* No Idea here either */
1244
1245 ct=newAV();
1246 av_extend(ct, colours);
1247 for(q=0; q<colours; q++) {
1248 for(w=0; w<3; w++)
1249 temp[w]=sv_2mortal(newSViv(colour_table[q*3 + w]));
1250 av_store(ct, q, (SV*)newRV_noinc((SV*)av_make(3, temp)));
1251 }
1252 myfree(colour_table);
1253
1254 EXTEND(SP,2);
1255 r=sv_newmortal();
1256 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1257 PUSHs(r);
1258 PUSHs(newRV_noinc((SV*)ct));
1259 }
1260
1261
1262
1263
1264
1265void
1266i_readgif_scalar(...)
1267 PROTOTYPE: $
1268 PREINIT:
1269 char* data;
1270 unsigned int length;
1271 int* colour_table;
1272 int colours, q, w;
1273 i_img* rimg;
1274 SV* temp[3];
1275 AV* ct;
1276 SV* r;
1277 PPCODE:
1278 data = (char *)SvPV(ST(0), length);
1279 colour_table=NULL;
1280 colours=0;
1281
1282 if(GIMME_V == G_ARRAY) {
1283 rimg=i_readgif_scalar(data,length,&colour_table,&colours);
1284 } else {
1285 /* don't waste time with colours if they aren't wanted */
1286 rimg=i_readgif_scalar(data,length,NULL,NULL);
1287 }
1288
1289 if (colour_table == NULL) {
1290 EXTEND(SP,1);
1291 r=sv_newmortal();
1292 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1293 PUSHs(r);
1294 } else {
1295 /* the following creates an [[r,g,b], [r, g, b], [r, g, b]...] */
1296 /* I don't know if I have the reference counts right or not :( */
1297 /* Neither do I :-) */
1298 ct=newAV();
1299 av_extend(ct, colours);
1300 for(q=0; q<colours; q++) {
1301 for(w=0; w<3; w++)
1302 temp[w]=sv_2mortal(newSViv(colour_table[q*3 + w]));
1303 av_store(ct, q, (SV*)newRV_noinc((SV*)av_make(3, temp)));
1304 }
1305 myfree(colour_table);
1306
1307 EXTEND(SP,2);
1308 r=sv_newmortal();
1309 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1310 PUSHs(r);
1311 PUSHs(newRV_noinc((SV*)ct));
1312 }
1313
1314void
1315i_readgif_callback(...)
1316 PROTOTYPE: &
1317 PREINIT:
1318 char* data;
1319 int length;
1320 int* colour_table;
1321 int colours, q, w;
1322 i_img* rimg;
1323 SV* temp[3];
1324 AV* ct;
1325 SV* r;
1326 i_reader_data rd;
1327 PPCODE:
1328 rd.sv = ST(0);
1329 colour_table=NULL;
1330 colours=0;
1331
1332 if(GIMME_V == G_ARRAY) {
1333 rimg=i_readgif_callback(read_callback, (char *)&rd,&colour_table,&colours);
1334 } else {
1335 /* don't waste time with colours if they aren't wanted */
1336 rimg=i_readgif_callback(read_callback, (char *)&rd,NULL,NULL);
1337 }
1338
1339 if (colour_table == NULL) {
1340 EXTEND(SP,1);
1341 r=sv_newmortal();
1342 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1343 PUSHs(r);
1344 } else {
1345 /* the following creates an [[r,g,b], [r, g, b], [r, g, b]...] */
1346 /* I don't know if I have the reference counts right or not :( */
1347 /* Neither do I :-) */
1348 /* Neither do I - maybe I'll move this somewhere */
1349 ct=newAV();
1350 av_extend(ct, colours);
1351 for(q=0; q<colours; q++) {
1352 for(w=0; w<3; w++)
1353 temp[w]=sv_2mortal(newSViv(colour_table[q*3 + w]));
1354 av_store(ct, q, (SV*)newRV_noinc((SV*)av_make(3, temp)));
1355 }
1356 myfree(colour_table);
1357
1358 EXTEND(SP,2);
1359 r=sv_newmortal();
1360 sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
1361 PUSHs(r);
1362 PUSHs(newRV_noinc((SV*)ct));
1363 }
1364
1365
1366
1367
1368
1369
1370#endif
1371
1372
1373
1374Imager::ImgRaw
1375i_readpnm_wiol(ig, length)
1376 Imager::IO ig
1377 int length
1378
1379
1380undef_int
1381i_writeppm(im,fd)
1382 Imager::ImgRaw im
1383 int fd
1384
1385Imager::ImgRaw
1386i_readraw(fd,x,y,datachannels,storechannels,intrl)
1387 int fd
1388 int x
1389 int y
1390 int datachannels
1391 int storechannels
1392 int intrl
1393
1394undef_int
1395i_writeraw(im,fd)
1396 Imager::ImgRaw im
1397 int fd
1398
1399
1400Imager::ImgRaw
1401i_scaleaxis(im,Value,Axis)
1402 Imager::ImgRaw im
1403 float Value
1404 int Axis
1405
1406Imager::ImgRaw
1407i_scale_nn(im,scx,scy)
1408 Imager::ImgRaw im
1409 float scx
1410 float scy
1411
1412Imager::ImgRaw
1413i_haar(im)
1414 Imager::ImgRaw im
1415
1416int
1417i_count_colors(im,maxc)
1418 Imager::ImgRaw im
1419 int maxc
1420
1421
1422Imager::ImgRaw
1423i_transform(im,opx,opy,parm)
1424 Imager::ImgRaw im
1425 PREINIT:
1426 double* parm;
1427 int* opx;
1428 int* opy;
1429 int opxl;
1430 int opyl;
1431 int parmlen;
1432 AV* av;
1433 SV* sv1;
1434 int i;
1435 CODE:
1436 if (!SvROK(ST(1))) croak("Imager: Parameter 1 must be a reference to an array\n");
1437 if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to an array\n");
1438 if (!SvROK(ST(3))) croak("Imager: Parameter 3 must be a reference to an array\n");
1439 if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 must be a reference to an array\n");
1440 if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 must be a reference to an array\n");
1441 if (SvTYPE(SvRV(ST(3))) != SVt_PVAV) croak("Imager: Parameter 3 must be a reference to an array\n");
1442 av=(AV*)SvRV(ST(1));
1443 opxl=av_len(av)+1;
1444 opx=mymalloc( opxl*sizeof(int) );
1445 for(i=0;i<opxl;i++) {
1446 sv1=(*(av_fetch(av,i,0)));
1447 opx[i]=(int)SvIV(sv1);
1448 }
1449 av=(AV*)SvRV(ST(2));
1450 opyl=av_len(av)+1;
1451 opy=mymalloc( opyl*sizeof(int) );
1452 for(i=0;i<opyl;i++) {
1453 sv1=(*(av_fetch(av,i,0)));
1454 opy[i]=(int)SvIV(sv1);
1455 }
1456 av=(AV*)SvRV(ST(3));
1457 parmlen=av_len(av)+1;
1458 parm=mymalloc( parmlen*sizeof(double) );
1459 for(i=0;i<parmlen;i++) { /* FIXME: Bug? */
1460 sv1=(*(av_fetch(av,i,0)));
1461 parm[i]=(double)SvNV(sv1);
1462 }
1463 RETVAL=i_transform(im,opx,opxl,opy,opyl,parm,parmlen);
1464 myfree(parm);
1465 myfree(opy);
1466 myfree(opx);
1467 ST(0) = sv_newmortal();
1468 if (RETVAL == 0) ST(0)=&PL_sv_undef;
1469 else sv_setref_pv(ST(0), "Imager::ImgRaw", (void*)RETVAL);
1470
1471Imager::ImgRaw
1472i_transform2(width,height,ops,n_regs,c_regs,in_imgs)
1473 PREINIT:
1474 int width;
1475 int height;
1476 double* parm;
1477 struct rm_op *ops;
1478 unsigned int ops_len;
1479 int ops_count;
1480 double *n_regs;
1481 int n_regs_count;
1482 i_color *c_regs;
1483 int c_regs_count;
1484 int in_imgs_count;
1485 i_img **in_imgs;
1486 AV* av;
1487 SV* sv1;
1488 IV tmp;
1489 int i;
1490 CODE:
1491 if (!SvROK(ST(3))) croak("Imager: Parameter 4 must be a reference to an array\n");
1492 if (!SvROK(ST(4))) croak("Imager: Parameter 5 must be a reference to an array\n");
1493 if (!SvROK(ST(5))) croak("Imager: Parameter 6 must be a reference to an array of images\n");
1494 if (SvTYPE(SvRV(ST(3))) != SVt_PVAV) croak("Imager: Parameter 4 must be a reference to an array\n");
1495 if (SvTYPE(SvRV(ST(4))) != SVt_PVAV) croak("Imager: Parameter 5 must be a reference to an array\n");
1496
1497 /*if (SvTYPE(SvRV(ST(5))) != SVt_PVAV) croak("Imager: Parameter 6 must be a reference to an array\n");*/
1498
1499 if (SvTYPE(SvRV(ST(5))) == SVt_PVAV) {
1500 av = (AV*)SvRV(ST(5));
1501 in_imgs_count = av_len(av)+1;
1502 for (i = 0; i < in_imgs_count; ++i) {
1503 sv1 = *av_fetch(av, i, 0);
1504 if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
1505 croak("Parameter 5 must contain only images");
1506 }
1507 }
1508 }
1509 else {
1510 in_imgs_count = 0;
1511 }
1512 if (SvTYPE(SvRV(ST(5))) == SVt_PVAV) {
1513 av = (AV*)SvRV(ST(5));
1514 in_imgs = mymalloc(in_imgs_count*sizeof(i_img*));
1515 for (i = 0; i < in_imgs_count; ++i) {
1516 sv1 = *av_fetch(av,i,0);
1517 if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
1518 croak("Parameter 5 must contain only images");
1519 }
1520 tmp = SvIV((SV*)SvRV(sv1));
1521 in_imgs[i] = (i_img*)tmp;
1522 }
1523 }
1524 else {
1525 /* no input images */
1526 in_imgs = NULL;
1527 }
1528 /* default the output size from the first input if possible */
1529 if (SvOK(ST(0)))
1530 width = SvIV(ST(0));
1531 else if (in_imgs_count)
1532 width = in_imgs[0]->xsize;
1533 else
1534 croak("No output image width supplied");
1535
1536 if (SvOK(ST(1)))
1537 height = SvIV(ST(1));
1538 else if (in_imgs_count)
1539 height = in_imgs[0]->ysize;
1540 else
1541 croak("No output image height supplied");
1542
1543 ops = (struct rm_op *)SvPV(ST(2), ops_len);
1544 if (ops_len % sizeof(struct rm_op))
1545 croak("Imager: Parameter 3 must be a bitmap of regops\n");
1546 ops_count = ops_len / sizeof(struct rm_op);
1547 av = (AV*)SvRV(ST(3));
1548 n_regs_count = av_len(av)+1;
1549 n_regs = mymalloc(n_regs_count * sizeof(double));
1550 for (i = 0; i < n_regs_count; ++i) {
1551 sv1 = *av_fetch(av,i,0);
1552 if (SvOK(sv1))
1553 n_regs[i] = SvNV(sv1);
1554 }
1555 av = (AV*)SvRV(ST(4));
1556 c_regs_count = av_len(av)+1;
1557 c_regs = mymalloc(c_regs_count * sizeof(i_color));
1558 /* I don't bother initializing the colou?r registers */
1559
1560 RETVAL=i_transform2(width, height, 3, ops, ops_count,
1561 n_regs, n_regs_count,
1562 c_regs, c_regs_count, in_imgs, in_imgs_count);
1563 if (in_imgs)
1564 myfree(in_imgs);
1565 myfree(n_regs);
1566 myfree(c_regs);
1567 ST(0) = sv_newmortal();
1568 if (RETVAL == 0) ST(0)=&PL_sv_undef;
1569 else sv_setref_pv(ST(0), "Imager::ImgRaw", (void*)RETVAL);
1570
1571
1572void
1573i_contrast(im,intensity)
1574 Imager::ImgRaw im
1575 float intensity
1576
1577void
1578i_hardinvert(im)
1579 Imager::ImgRaw im
1580
1581void
1582i_noise(im,amount,type)
1583 Imager::ImgRaw im
1584 float amount
1585 unsigned char type
1586
1587void
1588i_bumpmap(im,bump,channel,light_x,light_y,strength)
1589 Imager::ImgRaw im
1590 Imager::ImgRaw bump
1591 int channel
1592 int light_x
1593 int light_y
1594 int strength
1595
1596void
1597i_postlevels(im,levels)
1598 Imager::ImgRaw im
1599 int levels
1600
1601void
1602i_mosaic(im,size)
1603 Imager::ImgRaw im
1604 int size
1605
1606void
1607i_watermark(im,wmark,tx,ty,pixdiff)
1608 Imager::ImgRaw im
1609 Imager::ImgRaw wmark
1610 int tx
1611 int ty
1612 int pixdiff
1613
1614
1615void
1616i_autolevels(im,lsat,usat,skew)
1617 Imager::ImgRaw im
1618 float lsat
1619 float usat
1620 float skew
1621
1622void
1623i_radnoise(im,xo,yo,rscale,ascale)
1624 Imager::ImgRaw im
1625 float xo
1626 float yo
1627 float rscale
1628 float ascale
1629
1630void
1631i_turbnoise(im, xo, yo, scale)
1632 Imager::ImgRaw im
1633 float xo
1634 float yo
1635 float scale
1636
1637
1638void
1639i_gradgen(im, ...)
1640 Imager::ImgRaw im
1641 PREINIT:
1642 int num;
1643 int *xo;
1644 int *yo;
1645 i_color *ival;
1646 int dmeasure;
1647 int i;
1648 SV *sv;
1649 AV *axx;
1650 AV *ayy;
1651 AV *ac;
1652 CODE:
1653 if (items != 5)
1654 croak("Usage: i_gradgen(im, xo, yo, ival, dmeasure)");
1655 if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
1656 croak("i_gradgen: Second argument must be an array ref");
1657 if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
1658 croak("i_gradgen: Third argument must be an array ref");
1659 if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
1660 croak("i_gradgen: Fourth argument must be an array ref");
1661 axx = (AV *)SvRV(ST(1));
1662 ayy = (AV *)SvRV(ST(2));
1663 ac = (AV *)SvRV(ST(3));
1664 dmeasure = (int)SvIV(ST(4));
1665
1666 num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
1667 num = num <= av_len(ac) ? num : av_len(ac);
1668 num++;
1669 if (num < 2) croak("Usage: i_gradgen array refs must have more than 1 entry each");
1670 xo = mymalloc( sizeof(int) * num );
1671 yo = mymalloc( sizeof(int) * num );
1672 ival = mymalloc( sizeof(i_color) * num );
1673 for(i = 0; i<num; i++) {
1674 xo[i] = (int)SvIV(* av_fetch(axx, i, 0));
1675 yo[i] = (int)SvIV(* av_fetch(ayy, i, 0));
1676 sv = *av_fetch(ac, i, 0);
1677 if ( !sv_derived_from(sv, "Imager::Color") ) {
1678 free(axx); free(ayy); free(ac);
1679 croak("i_gradgen: Element of fourth argument is not derived from Imager::Color");
1680 }
1681 ival[i] = *(i_color *)SvIV((SV *)SvRV(sv));
1682 }
1683 i_gradgen(im, num, xo, yo, ival, dmeasure);
1684
1685
1686
1687
1688
1689
1690
1691
1692void
1693i_nearest_color(im, ...)
1694 Imager::ImgRaw im
1695 PREINIT:
1696 int num;
1697 int *xo;
1698 int *yo;
1699 i_color *ival;
1700 int dmeasure;
1701 int i;
1702 SV *sv;
1703 AV *axx;
1704 AV *ayy;
1705 AV *ac;
1706 CODE:
1707 if (items != 5)
1708 croak("Usage: i_nearest_color(im, xo, yo, ival, dmeasure)");
1709 if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
1710 croak("i_nearest_color: Second argument must be an array ref");
1711 if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
1712 croak("i_nearest_color: Third argument must be an array ref");
1713 if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
1714 croak("i_nearest_color: Fourth argument must be an array ref");
1715 axx = (AV *)SvRV(ST(1));
1716 ayy = (AV *)SvRV(ST(2));
1717 ac = (AV *)SvRV(ST(3));
1718 dmeasure = (int)SvIV(ST(4));
1719
1720 num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
1721 num = num <= av_len(ac) ? num : av_len(ac);
1722 num++;
1723 if (num < 2) croak("Usage: i_nearest_color array refs must have more than 1 entry each");
1724 xo = mymalloc( sizeof(int) * num );
1725 yo = mymalloc( sizeof(int) * num );
1726 ival = mymalloc( sizeof(i_color) * num );
1727 for(i = 0; i<num; i++) {
1728 xo[i] = (int)SvIV(* av_fetch(axx, i, 0));
1729 yo[i] = (int)SvIV(* av_fetch(ayy, i, 0));
1730 sv = *av_fetch(ac, i, 0);
1731 if ( !sv_derived_from(sv, "Imager::Color") ) {
1732 free(axx); free(ayy); free(ac);
1733 croak("i_nearest_color: Element of fourth argument is not derived from Imager::Color");
1734 }
1735 ival[i] = *(i_color *)SvIV((SV *)SvRV(sv));
1736 }
1737 i_nearest_color(im, num, xo, yo, ival, dmeasure);
1738
1739
1740
1741
1742void
1743malloc_state()
1744
1745void
1746hashinfo(hv)
1747 PREINIT:
1748 HV* hv;
1749 int stuff;
1750 PPCODE:
1751 if (!SvROK(ST(0))) croak("Imager: Parameter 0 must be a reference to a hash\n");
1752 hv=(HV*)SvRV(ST(0));
1753 if (SvTYPE(hv)!=SVt_PVHV) croak("Imager: Parameter 0 must be a reference to a hash\n");
1754 if (getint(hv,"stuff",&stuff)) printf("ok: %d\n",stuff); else printf("key doesn't exist\n");
1755 if (getint(hv,"stuff2",&stuff)) printf("ok: %d\n",stuff); else printf("key doesn't exist\n");
1756
1757void
1758DSO_open(filename)
1759 char* filename
1760 PREINIT:
1761 void *rc;
1762 char *evstr;
1763 PPCODE:
1764 rc=DSO_open(filename,&evstr);
1765 if (rc!=NULL) {
1766 if (evstr!=NULL) {
1767 EXTEND(SP,2);
1768 PUSHs(sv_2mortal(newSViv((IV)rc)));
1769 PUSHs(sv_2mortal(newSVpvn(evstr, strlen(evstr))));
1770 } else {
1771 EXTEND(SP,1);
1772 PUSHs(sv_2mortal(newSViv((IV)rc)));
1773 }
1774 }
1775
1776
1777undef_int
1778DSO_close(dso_handle)
1779 void* dso_handle
1780
1781void
1782DSO_funclist(dso_handle_v)
1783 void* dso_handle_v
1784 PREINIT:
1785 int i;
1786 DSO_handle *dso_handle;
1787 PPCODE:
1788 dso_handle=(DSO_handle*)dso_handle_v;
1789 i=0;
1790 while( dso_handle->function_list[i].name != NULL) {
1791 EXTEND(SP,1);
1792 PUSHs(sv_2mortal(newSVpv(dso_handle->function_list[i].name,0)));
1793 EXTEND(SP,1);
1794 PUSHs(sv_2mortal(newSVpv(dso_handle->function_list[i++].pcode,0)));
1795 }
1796
1797
1798void
1799DSO_call(handle,func_index,hv)
1800 void* handle
1801 int func_index
1802 PREINIT:
1803 HV* hv;
1804 PPCODE:
1805 if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to a hash\n");
1806 hv=(HV*)SvRV(ST(2));
1807 if (SvTYPE(hv)!=SVt_PVHV) croak("Imager: Parameter 2 must be a reference to a hash\n");
1808 DSO_call( (DSO_handle *)handle,func_index,hv);
1809
1810
1811
1812
Image manipulation for perl