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