]> git.imager.perl.org - imager.git/blame - Imager.xs
projects / imager.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ensure alpha channels are initialized for mediancut make_colors
[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
0231b97e
TC		 1140#define ICL_red(c) ((c)->rgba.r)
1141#define ICL_green(c) ((c)->rgba.g)
1142#define ICL_blue(c) ((c)->rgba.b)
1143#define ICL_alpha(c) ((c)->rgba.a)
1144
1145#define ICLF_red(c) ((c)->rgba.r)
1146#define ICLF_green(c) ((c)->rgba.g)
1147#define ICLF_blue(c) ((c)->rgba.b)
1148#define ICLF_alpha(c) ((c)->rgba.a)
1149
02d1d628
AMH		 1150MODULE = Imager PACKAGE = Imager::Color PREFIX = ICL_
1151
1152Imager::Color
1153ICL_new_internal(r,g,b,a)
1154 unsigned char r
1155 unsigned char g
1156 unsigned char b
1157 unsigned char a
1158
1159void
1160ICL_DESTROY(cl)
1161 Imager::Color cl
1162
1163
29106a11 1164void
02d1d628
AMH		 1165ICL_set_internal(cl,r,g,b,a)
1166 Imager::Color cl
1167 unsigned char r
1168 unsigned char g
1169 unsigned char b
1170 unsigned char a
29106a11 1171 PPCODE:
b7346865
TC		 1172 cl->rgba.r = r;
1173 cl->rgba.g = g;
1174 cl->rgba.b = b;
1175 cl->rgba.a = a;
29106a11
TC		 1176 EXTEND(SP, 1);
1177 PUSHs(ST(0));
02d1d628
AMH		 1178
1179void
1180ICL_info(cl)
1181 Imager::Color cl
1182
1183
1184void
1185ICL_rgba(cl)
1186 Imager::Color cl
1187 PPCODE:
1188 EXTEND(SP, 4);
b482243a
TC		 1189 PUSHs(sv_2mortal(newSViv(cl->rgba.r)));
1190 PUSHs(sv_2mortal(newSViv(cl->rgba.g)));
1191 PUSHs(sv_2mortal(newSViv(cl->rgba.b)));
1192 PUSHs(sv_2mortal(newSViv(cl->rgba.a)));
02d1d628 1193
efdc2568
TC		 1194Imager::Color
1195i_hsv_to_rgb(c)
1196 Imager::Color c
1197 CODE:
1198 RETVAL = mymalloc(sizeof(i_color));
1199 *RETVAL = *c;
1200 i_hsv_to_rgb(RETVAL);
1201 OUTPUT:
1202 RETVAL
1203
1204Imager::Color
1205i_rgb_to_hsv(c)
1206 Imager::Color c
1207 CODE:
1208 RETVAL = mymalloc(sizeof(i_color));
1209 *RETVAL = *c;
1210 i_rgb_to_hsv(RETVAL);
1211 OUTPUT:
1212 RETVAL
1213
0231b97e
TC		 1214int
1215ICL_red(c)
1216 Imager::Color c
1217
1218int
1219ICL_green(c)
1220 Imager::Color c
1221
1222int
1223ICL_blue(c)
1224 Imager::Color c
02d1d628 1225
0231b97e
TC		 1226int
1227ICL_alpha(c)
1228 Imager::Color c
02d1d628 1229
faa9b3e7 1230MODULE = Imager PACKAGE = Imager::Color::Float PREFIX=ICLF_
02d1d628 1231
faa9b3e7
TC		 1232Imager::Color::Float
1233ICLF_new_internal(r, g, b, a)
5824f4c2
TC		 1234 im_double r
1235 im_double g
1236 im_double b
1237 im_double a
faa9b3e7
TC		 1238
1239void
1240ICLF_DESTROY(cl)
1241 Imager::Color::Float cl
02d1d628 1242
faa9b3e7
TC		 1243void
1244ICLF_rgba(cl)
1245 Imager::Color::Float cl
1246 PREINIT:
1247 int ch;
1248 PPCODE:
1249 EXTEND(SP, MAXCHANNELS);
1250 for (ch = 0; ch < MAXCHANNELS; ++ch) {
1251 /* printf("%d: %g\n", ch, cl->channel[ch]); */
1252 PUSHs(sv_2mortal(newSVnv(cl->channel[ch])));
1253 }
1254
1255void
1256ICLF_set_internal(cl,r,g,b,a)
1257 Imager::Color::Float cl
5824f4c2
TC		 1258 im_double r
1259 im_double g
1260 im_double b
1261 im_double a
faa9b3e7
TC		 1262 PPCODE:
1263 cl->rgba.r = r;
1264 cl->rgba.g = g;
1265 cl->rgba.b = b;
1266 cl->rgba.a = a;
1267 EXTEND(SP, 1);
1268 PUSHs(ST(0));
02d1d628 1269
efdc2568
TC		 1270Imager::Color::Float
1271i_hsv_to_rgb(c)
1272 Imager::Color::Float c
1273 CODE:
1274 RETVAL = mymalloc(sizeof(i_fcolor));
1275 *RETVAL = *c;
1276 i_hsv_to_rgbf(RETVAL);
1277 OUTPUT:
1278 RETVAL
1279
1280Imager::Color::Float
1281i_rgb_to_hsv(c)
1282 Imager::Color::Float c
1283 CODE:
1284 RETVAL = mymalloc(sizeof(i_fcolor));
1285 *RETVAL = *c;
1286 i_rgb_to_hsvf(RETVAL);
1287 OUTPUT:
1288 RETVAL
efdc2568 1289
0231b97e
TC		 1290double
1291ICLF_red(c)
1292 Imager::Color::Float c
1293
1294double
1295ICLF_green(c)
1296 Imager::Color::Float c
1297
1298double
1299ICLF_blue(c)
1300 Imager::Color::Float c
1301
1302double
1303ICLF_alpha(c)
1304 Imager::Color::Float c
1305
02d1d628
AMH		 1306MODULE = Imager PACKAGE = Imager::ImgRaw PREFIX = IIM_
1307
1308Imager::ImgRaw
5824f4c2
TC		 1309IIM_new(xsize,ysize,ch)
1310 i_img_dim xsize
1311 i_img_dim ysize
02d1d628
AMH		 1312 int ch
1313
1314void
1315IIM_DESTROY(im)
1316 Imager::ImgRaw im
1317
1318
1319
1320MODULE = Imager PACKAGE = Imager
1321
1322PROTOTYPES: ENABLE
1323
1324
1325Imager::IO
1326io_new_fd(fd)
1327 int fd
1328
1329Imager::IO
1330io_new_bufchain()
1331
1332
4dfa5522 1333Imager::IO
6d5c85a2
TC		 1334io_new_buffer(data_sv)
1335 SV *data_sv
4dfa5522 1336 CODE:
a87997b2 1337 i_clear_error();
6d5c85a2 1338 RETVAL = do_io_new_buffer(aTHX_ data_sv);
a87997b2
TC		 1339 if (!RETVAL)
1340 XSRETURN(0);
4dfa5522
AMH		 1341 OUTPUT:
1342 RETVAL
10461f9a
TC		 1343
1344Imager::IO
1345io_new_cb(writecb, readcb, seekcb, closecb, maxwrite = CBDATA_BUFSIZE)
1346 SV *writecb;
1347 SV *readcb;
1348 SV *seekcb;
1349 SV *closecb;
10461f9a 1350 CODE:
6d5c85a2 1351 RETVAL = do_io_new_cb(aTHX_ writecb, readcb, seekcb, closecb);
10461f9a
TC		 1352 OUTPUT:
1353 RETVAL
4dfa5522 1354
6d5c85a2 1355SV *
02d1d628
AMH		 1356io_slurp(ig)
1357 Imager::IO ig
1358 PREINIT:
1359 unsigned char* data;
4dfa5522 1360 size_t tlength;
6d5c85a2 1361 CODE:
02d1d628
AMH		 1362 data = NULL;
1363 tlength = io_slurp(ig, &data);
6d5c85a2 1364 RETVAL = newSVpv((char *)data,tlength);
02d1d628 1365 myfree(data);
6d5c85a2
TC		 1366 OUTPUT:
1367 RETVAL
02d1d628
AMH		 1368
1369
77157728
TC		 1370undef_int
1371i_set_image_file_limits(width, height, bytes)
8d14daab
TC		 1372 i_img_dim width
1373 i_img_dim height
1374 size_t bytes
77157728
TC		 1375
1376void
1377i_get_image_file_limits()
1378 PREINIT:
8d14daab
TC		 1379 i_img_dim width, height;
1380 size_t bytes;
77157728
TC		 1381 PPCODE:
1382 if (i_get_image_file_limits(&width, &height, &bytes)) {
1383 EXTEND(SP, 3);
1384 PUSHs(sv_2mortal(newSViv(width)));
1385 PUSHs(sv_2mortal(newSViv(height)));
8d14daab 1386 PUSHs(sv_2mortal(newSVuv(bytes)));
77157728
TC		 1387 }
1388
e1558ffe
TC		 1389bool
1390i_int_check_image_file_limits(width, height, channels, sample_size)
1391 i_img_dim width
1392 i_img_dim height
1393 int channels
1394 size_t sample_size
1395 PROTOTYPE: DISABLE
1396
6d5c85a2
TC		 1397MODULE = Imager PACKAGE = Imager::IO PREFIX = io_
1398
1399Imager::IO
1400io_new_fd(class, fd)
1401 int fd
1402 CODE:
1403 RETVAL = io_new_fd(fd);
1404 OUTPUT:
1405 RETVAL
1406
1407Imager::IO
1408io_new_buffer(class, data_sv)
1409 SV *data_sv
1410 CODE:
a87997b2 1411 i_clear_error();
6d5c85a2 1412 RETVAL = do_io_new_buffer(aTHX_ data_sv);
a87997b2
TC		 1413 if (!RETVAL)
1414 XSRETURN(0);
6d5c85a2
TC		 1415 OUTPUT:
1416 RETVAL
1417
1418Imager::IO
1419io_new_cb(class, writecb, readcb, seekcb, closecb)
1420 SV *writecb;
1421 SV *readcb;
1422 SV *seekcb;
1423 SV *closecb;
1424 CODE:
1425 RETVAL = do_io_new_cb(aTHX_ writecb, readcb, seekcb, closecb);
1426 OUTPUT:
1427 RETVAL
1428
1429Imager::IO
1430io_new_bufchain(class)
1431 CODE:
1432 RETVAL = io_new_bufchain();
1433 OUTPUT:
1434 RETVAL
1435
52d990d6
TC		 1436Imager::IO
1437io__new_perlio(class, io)
1438 PerlIO *io
1439 CODE:
1440 RETVAL = im_io_new_perlio(aTHX_ io);
1441 OUTPUT:
1442 RETVAL
1443
6d5c85a2
TC		 1444SV *
1445io_slurp(class, ig)
1446 Imager::IO ig
1447 PREINIT:
1448 unsigned char* data;
1449 size_t tlength;
1450 CODE:
1451 data = NULL;
1452 tlength = io_slurp(ig, &data);
1453 RETVAL = newSVpv((char *)data,tlength);
1454 myfree(data);
1455 OUTPUT:
1456 RETVAL
1457
eda1622c
TC		 1458MODULE = Imager PACKAGE = Imager::IO PREFIX = i_io_
1459
6d5c85a2
TC		 1460IV
1461i_io_raw_write(ig, data_sv)
eda1622c
TC		 1462 Imager::IO ig
1463 SV *data_sv
1464 PREINIT:
1465 void *data;
1466 STRLEN size;
1467 CODE:
40a88898 1468 data = SvPVbyte(data_sv, size);
6d5c85a2 1469 RETVAL = i_io_raw_write(ig, data, size);
eda1622c
TC		 1470 OUTPUT:
1471 RETVAL
1472
1f6c1c10 1473void
6d5c85a2 1474i_io_raw_read(ig, buffer_sv, size)
eda1622c
TC		 1475 Imager::IO ig
1476 SV *buffer_sv
8d14daab 1477 IV size
eda1622c
TC		 1478 PREINIT:
1479 void *buffer;
8d14daab 1480 ssize_t result;
1f6c1c10
TC		 1481 PPCODE:
1482 if (size <= 0)
6d5c85a2 1483 croak("size negative in call to i_io_raw_read()");
d1442cc4
TC		 1484 /* prevent an undefined value warning if they supplied an
1485 undef buffer.
1486 Orginally conditional on !SvOK(), but this will prevent the
1487 downgrade from croaking */
1488 sv_setpvn(buffer_sv, "", 0);
1489#ifdef SvUTF8
1490 if (SvUTF8(buffer_sv))
1491 sv_utf8_downgrade(buffer_sv, FALSE);
1492#endif
eda1622c 1493 buffer = SvGROW(buffer_sv, size+1);
6d5c85a2 1494 result = i_io_raw_read(ig, buffer, size);
1f6c1c10
TC		 1495 if (result >= 0) {
1496 SvCUR_set(buffer_sv, result);
1497 *SvEND(buffer_sv) = '\0';
1498 SvPOK_only(buffer_sv);
1499 EXTEND(SP, 1);
1500 PUSHs(sv_2mortal(newSViv(result)));
eda1622c 1501 }
1f6c1c10
TC		 1502 ST(1) = buffer_sv;
1503 SvSETMAGIC(ST(1));
1504
1505void
6d5c85a2 1506i_io_raw_read2(ig, size)
1f6c1c10 1507 Imager::IO ig
8d14daab 1508 IV size
1f6c1c10
TC		 1509 PREINIT:
1510 SV *buffer_sv;
1511 void *buffer;
8d14daab 1512 ssize_t result;
1f6c1c10
TC		 1513 PPCODE:
1514 if (size <= 0)
1515 croak("size negative in call to i_io_read2()");
1516 buffer_sv = newSV(size);
1517 buffer = SvGROW(buffer_sv, size+1);
6d5c85a2 1518 result = i_io_raw_read(ig, buffer, size);
1f6c1c10 1519 if (result >= 0) {
eda1622c
TC		 1520 SvCUR_set(buffer_sv, result);
1521 *SvEND(buffer_sv) = '\0';
1522 SvPOK_only(buffer_sv);
1f6c1c10
TC		 1523 EXTEND(SP, 1);
1524 PUSHs(sv_2mortal(buffer_sv));
eda1622c 1525 }
1f6c1c10
TC		 1526 else {
1527 /* discard it */
1528 SvREFCNT_dec(buffer_sv);
1529 }
eda1622c 1530
8d14daab 1531off_t
6d5c85a2 1532i_io_raw_seek(ig, position, whence)
eda1622c 1533 Imager::IO ig
8d14daab 1534 off_t position
eda1622c 1535 int whence
c3cc977e 1536
1f6c1c10 1537int
6d5c85a2 1538i_io_raw_close(ig)
eda1622c
TC		 1539 Imager::IO ig
1540
1541void
1542i_io_DESTROY(ig)
c3cc977e
AMH		 1543 Imager::IO ig
1544
ffddd407
TC		 1545int
1546i_io_CLONE_SKIP(...)
1547 CODE:
8d14daab 1548 (void)items; /* avoid unused warning for XS variable */
ffddd407
TC		 1549 RETVAL = 1;
1550 OUTPUT:
1551 RETVAL
1552
6d5c85a2
TC		 1553int
1554i_io_getc(ig)
1555 Imager::IO ig
1556
215d9ead
TC		 1557void
1558i_io_nextc(ig)
1559 Imager::IO ig
1560
6d5c85a2
TC		 1561int
1562i_io_putc(ig, c)
1563 Imager::IO ig
1564 int c
1565
1566int
1567i_io_close(ig)
1568 Imager::IO ig
1569
1570int
1571i_io_flush(ig)
1572 Imager::IO ig
1573
1574int
1575i_io_peekc(ig)
1576 Imager::IO ig
1577
1578int
1579i_io_seek(ig, off, whence)
1580 Imager::IO ig
1581 off_t off
1582 int whence
1583
1584void
1585i_io_peekn(ig, size)
1586 Imager::IO ig
1587 STRLEN size
1588 PREINIT:
1589 SV *buffer_sv;
1590 void *buffer;
1591 ssize_t result;
1592 PPCODE:
1593 buffer_sv = newSV(size+1);
1594 buffer = SvGROW(buffer_sv, size+1);
1595 result = i_io_peekn(ig, buffer, size);
1596 if (result >= 0) {
1597 SvCUR_set(buffer_sv, result);
1598 *SvEND(buffer_sv) = '\0';
1599 SvPOK_only(buffer_sv);
1600 EXTEND(SP, 1);
1601 PUSHs(sv_2mortal(buffer_sv));
1602 }
1603 else {
1604 /* discard it */
1605 SvREFCNT_dec(buffer_sv);
1606 }
1607
1608void
1609i_io_read(ig, buffer_sv, size)
1610 Imager::IO ig
1611 SV *buffer_sv
1612 IV size
1613 PREINIT:
1614 void *buffer;
1615 ssize_t result;
1616 PPCODE:
1617 if (size <= 0)
1618 croak("size negative in call to i_io_read()");
d1442cc4
TC		 1619 /* prevent an undefined value warning if they supplied an
1620 undef buffer.
1621 Orginally conditional on !SvOK(), but this will prevent the
1622 downgrade from croaking */
1623 sv_setpvn(buffer_sv, "", 0);
1624#ifdef SvUTF8
1625 if (SvUTF8(buffer_sv))
1626 sv_utf8_downgrade(buffer_sv, FALSE);
1627#endif
6d5c85a2
TC		 1628 buffer = SvGROW(buffer_sv, size+1);
1629 result = i_io_read(ig, buffer, size);
1630 if (result >= 0) {
1631 SvCUR_set(buffer_sv, result);
1632 *SvEND(buffer_sv) = '\0';
1633 SvPOK_only(buffer_sv);
1634 EXTEND(SP, 1);
1635 PUSHs(sv_2mortal(newSViv(result)));
1636 }
1637 ST(1) = buffer_sv;
1638 SvSETMAGIC(ST(1));
1639
1640void
1641i_io_read2(ig, size)
1642 Imager::IO ig
1643 STRLEN size
1644 PREINIT:
1645 SV *buffer_sv;
1646 void *buffer;
1647 ssize_t result;
1648 PPCODE:
1649 if (size == 0)
1650 croak("size zero in call to read2()");
1651 buffer_sv = newSV(size);
1652 buffer = SvGROW(buffer_sv, size+1);
1653 result = i_io_read(ig, buffer, size);
1654 if (result > 0) {
1655 SvCUR_set(buffer_sv, result);
1656 *SvEND(buffer_sv) = '\0';
1657 SvPOK_only(buffer_sv);
1658 EXTEND(SP, 1);
1659 PUSHs(sv_2mortal(buffer_sv));
1660 }
1661 else {
1662 /* discard it */
1663 SvREFCNT_dec(buffer_sv);
1664 }
1665
1666void
1667i_io_gets(ig, size = 8192, eol = NEWLINE)
1668 Imager::IO ig
1669 STRLEN size
1670 int eol
1671 PREINIT:
1672 SV *buffer_sv;
1673 void *buffer;
1674 ssize_t result;
1675 PPCODE:
1676 if (size < 2)
1677 croak("size too small in call to gets()");
1678 buffer_sv = sv_2mortal(newSV(size+1));
1679 buffer = SvPVX(buffer_sv);
1680 result = i_io_gets(ig, buffer, size+1, eol);
1681 if (result > 0) {
1682 SvCUR_set(buffer_sv, result);
1683 *SvEND(buffer_sv) = '\0';
1684 SvPOK_only(buffer_sv);
1685 EXTEND(SP, 1);
1686 PUSHs(buffer_sv);
1687 }
1688
1689IV
1690i_io_write(ig, data_sv)
1691 Imager::IO ig
1692 SV *data_sv
1693 PREINIT:
1694 void *data;
1695 STRLEN size;
1696 CODE:
40a88898 1697 data = SvPVbyte(data_sv, size);
6d5c85a2
TC		 1698 RETVAL = i_io_write(ig, data, size);
1699 OUTPUT:
1700 RETVAL
1701
1702void
1703i_io_dump(ig, flags = I_IO_DUMP_DEFAULT)
1704 Imager::IO ig
1705 int flags
1706
1707bool
1708i_io_set_buffered(ig, flag = 1)
1709 Imager::IO ig
1710 int flag
1711
1712bool
1713i_io_is_buffered(ig)
1714 Imager::IO ig
1715
1716bool
1717i_io_eof(ig)
1718 Imager::IO ig
1719
1720bool
1721i_io_error(ig)
1722 Imager::IO ig
1723
c3cc977e
AMH		 1724MODULE = Imager PACKAGE = Imager
1725
1726PROTOTYPES: ENABLE
1727
02d1d628
AMH		 1728void
1729i_list_formats()
1730 PREINIT:
1731 char* item;
1732 int i;
1733 PPCODE:
1734 i=0;
1735 while( (item=i_format_list[i++]) != NULL ) {
1736 EXTEND(SP, 1);
1737 PUSHs(sv_2mortal(newSVpv(item,0)));
1738 }
1739
ec76939c
TC		 1740Imager::ImgRaw
1741i_sametype(im, x, y)
1742 Imager::ImgRaw im
8d14daab
TC		 1743 i_img_dim x
1744 i_img_dim y
ec76939c
TC		 1745
1746Imager::ImgRaw
1747i_sametype_chans(im, x, y, channels)
1748 Imager::ImgRaw im
8d14daab
TC		 1749 i_img_dim x
1750 i_img_dim y
ec76939c
TC		 1751 int channels
1752
10ea52a3 1753int
bd8052a6
TC		 1754i_init_log(name_sv,level)
1755 SV* name_sv
02d1d628 1756 int level
bd8052a6
TC		 1757 PREINIT:
1758 const char *name = SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
1759 CODE:
10ea52a3
TC		 1760 RETVAL = i_init_log(name, level);
1761 OUTPUT:
1762 RETVAL
02d1d628 1763
7f882a01 1764void
bf1573f9 1765i_log_entry(string,level)
7f882a01
AMH		 1766 char* string
1767 int level
1768
10ea52a3
TC		 1769int
1770i_log_enabled()
7f882a01 1771
02d1d628
AMH		 1772void
1773i_img_info(im)
1774 Imager::ImgRaw im
1775 PREINIT:
8d14daab 1776 i_img_dim info[4];
02d1d628
AMH		 1777 PPCODE:
1778 i_img_info(im,info);
1779 EXTEND(SP, 4);
1780 PUSHs(sv_2mortal(newSViv(info[0])));
1781 PUSHs(sv_2mortal(newSViv(info[1])));
1782 PUSHs(sv_2mortal(newSViv(info[2])));
1783 PUSHs(sv_2mortal(newSViv(info[3])));
1784
1785
1786
1787
1788void
1789i_img_setmask(im,ch_mask)
1790 Imager::ImgRaw im
1791 int ch_mask
1792
1793int
1794i_img_getmask(im)
1795 Imager::ImgRaw im
1796
1797int
1798i_img_getchannels(im)
1799 Imager::ImgRaw im
1800
1801void
1802i_img_getdata(im)
1803 Imager::ImgRaw im
1804 PPCODE:
1805 EXTEND(SP, 1);
26fd367b
TC		 1806 PUSHs(im->idata ?
1807 sv_2mortal(newSVpv((char *)im->idata, im->bytes))
faa9b3e7 1808 : &PL_sv_undef);
02d1d628 1809
3b000586
TC		 1810IV
1811i_img_get_width(im)
1812 Imager::ImgRaw im
1813
1814IV
1815i_img_get_height(im)
1816 Imager::ImgRaw im
1817
35db02fc
TC		 1818int
1819i_img_color_model(im)
1820 Imager::ImgRaw im
1821
1822int
1823i_img_color_channels(im)
1824 Imager::ImgRaw im
1825
1826int
1827i_img_alpha_channel(im)
1828 Imager::ImgRaw im
1829 CODE:
1830 if (!i_img_alpha_channel(im, &RETVAL))
1831 XSRETURN(0);
1832 OUTPUT:
1833 RETVAL
3b000586 1834
bd8052a6
TC		 1835void
1836i_img_is_monochrome(im)
1837 Imager::ImgRaw im
1838 PREINIT:
1839 int zero_is_white;
1840 int result;
1841 PPCODE:
1842 result = i_img_is_monochrome(im, &zero_is_white);
1843 if (result) {
1844 if (GIMME_V == G_ARRAY) {
1845 EXTEND(SP, 2);
1846 PUSHs(&PL_sv_yes);
1847 PUSHs(sv_2mortal(newSViv(zero_is_white)));
1848 }
1849 else {
1850 EXTEND(SP, 1);
1851 PUSHs(&PL_sv_yes);
1852 }
1853 }
02d1d628
AMH		 1854
1855void
aa833c97 1856i_line(im,x1,y1,x2,y2,val,endp)
02d1d628 1857 Imager::ImgRaw im
8d14daab
TC		 1858 i_img_dim x1
1859 i_img_dim y1
1860 i_img_dim x2
1861 i_img_dim y2
02d1d628 1862 Imager::Color val
aa833c97 1863 int endp
02d1d628
AMH		 1864
1865void
b437ce0a 1866i_line_aa(im,x1,y1,x2,y2,val,endp)
02d1d628 1867 Imager::ImgRaw im
8d14daab
TC		 1868 i_img_dim x1
1869 i_img_dim y1
1870 i_img_dim x2
1871 i_img_dim y2
02d1d628 1872 Imager::Color val
b437ce0a 1873 int endp
02d1d628
AMH		 1874
1875void
1876i_box(im,x1,y1,x2,y2,val)
1877 Imager::ImgRaw im
8d14daab
TC		 1878 i_img_dim x1
1879 i_img_dim y1
1880 i_img_dim x2
1881 i_img_dim y2
02d1d628
AMH		 1882 Imager::Color val
1883
1884void
1885i_box_filled(im,x1,y1,x2,y2,val)
1886 Imager::ImgRaw im
8d14daab
TC		 1887 i_img_dim x1
1888 i_img_dim y1
1889 i_img_dim x2
1890 i_img_dim y2
02d1d628
AMH		 1891 Imager::Color val
1892
7477ff14
TC		 1893int
1894i_box_filledf(im,x1,y1,x2,y2,val)
1895 Imager::ImgRaw im
8d14daab
TC		 1896 i_img_dim x1
1897 i_img_dim y1
1898 i_img_dim x2
1899 i_img_dim y2
7477ff14
TC		 1900 Imager::Color::Float val
1901
f1ac5027
TC		 1902void
1903i_box_cfill(im,x1,y1,x2,y2,fill)
1904 Imager::ImgRaw im
8d14daab
TC		 1905 i_img_dim x1
1906 i_img_dim y1
1907 i_img_dim x2
1908 i_img_dim y2
f1ac5027
TC		 1909 Imager::FillHandle fill
1910
02d1d628
AMH		 1911void
1912i_arc(im,x,y,rad,d1,d2,val)
1913 Imager::ImgRaw im
8d14daab
TC		 1914 i_img_dim x
1915 i_img_dim y
5824f4c2
TC		 1916 im_double rad
1917 im_double d1
1918 im_double d2
02d1d628
AMH		 1919 Imager::Color val
1920
a8652edf
TC		 1921void
1922i_arc_aa(im,x,y,rad,d1,d2,val)
1923 Imager::ImgRaw im
5824f4c2
TC		 1924 im_double x
1925 im_double y
1926 im_double rad
1927 im_double d1
1928 im_double d2
a8652edf
TC		 1929 Imager::Color val
1930
f1ac5027
TC		 1931void
1932i_arc_cfill(im,x,y,rad,d1,d2,fill)
1933 Imager::ImgRaw im
8d14daab
TC		 1934 i_img_dim x
1935 i_img_dim y
5824f4c2
TC		 1936 im_double rad
1937 im_double d1
1938 im_double d2
f1ac5027
TC		 1939 Imager::FillHandle fill
1940
a8652edf
TC		 1941void
1942i_arc_aa_cfill(im,x,y,rad,d1,d2,fill)
1943 Imager::ImgRaw im
5824f4c2
TC		 1944 im_double x
1945 im_double y
1946 im_double rad
1947 im_double d1
1948 im_double d2
a8652edf 1949 Imager::FillHandle fill
02d1d628
AMH		 1950
1951
6af18d2b
AMH		 1952void
1953i_circle_aa(im,x,y,rad,val)
1954 Imager::ImgRaw im
5824f4c2
TC		 1955 im_double x
1956 im_double y
1957 im_double rad
6af18d2b
AMH		 1958 Imager::Color val
1959
bf18ef3a
TC		 1960void
1961i_circle_aa_fill(im,x,y,rad,fill)
1962 Imager::ImgRaw im
5824f4c2
TC		 1963 im_double x
1964 im_double y
1965 im_double rad
bf18ef3a
TC		 1966 Imager::FillHandle fill
1967
40068b33
TC		 1968int
1969i_circle_out(im,x,y,rad,val)
1970 Imager::ImgRaw im
1971 i_img_dim x
1972 i_img_dim y
1973 i_img_dim rad
1974 Imager::Color val
1975
1976int
1977i_circle_out_aa(im,x,y,rad,val)
1978 Imager::ImgRaw im
1979 i_img_dim x
1980 i_img_dim y
1981 i_img_dim rad
1982 Imager::Color val
1983
1984int
1985i_arc_out(im,x,y,rad,d1,d2,val)
1986 Imager::ImgRaw im
1987 i_img_dim x
1988 i_img_dim y
1989 i_img_dim rad
5824f4c2
TC		 1990 im_double d1
1991 im_double d2
40068b33
TC		 1992 Imager::Color val
1993
1994int
1995i_arc_out_aa(im,x,y,rad,d1,d2,val)
1996 Imager::ImgRaw im
1997 i_img_dim x
1998 i_img_dim y
1999 i_img_dim rad
5824f4c2
TC		 2000 im_double d1
2001 im_double d2
40068b33 2002 Imager::Color val
6af18d2b
AMH		 2003
2004
02d1d628 2005void
987245e2 2006i_bezier_multi(im,x,y,val)
02d1d628 2007 Imager::ImgRaw im
987245e2
TC		 2008 double *x
2009 double *y
2010 Imager::Color val
2011 PREINIT:
2012 STRLEN size_x;
2013 STRLEN size_y;
2014 PPCODE:
2015 if (size_x != size_y)
2016 croak("Imager: x and y arrays to i_bezier_multi must be equal length\n");
2017 i_bezier_multi(im,size_x,x,y,val);
02d1d628 2018
1c5252ed 2019int
0d80f37e 2020i_poly_aa_m(im,x,y,mode,val)
02d1d628 2021 Imager::ImgRaw im
19e9591b
TC		 2022 double *x
2023 double *y
0d80f37e 2024 i_poly_fill_mode_t mode
a54e32ba
TC		 2025 Imager::Color val
2026 PREINIT:
19e9591b
TC		 2027 STRLEN size_x;
2028 STRLEN size_y;
a54e32ba 2029 CODE:
19e9591b 2030 if (size_x != size_y)
a54e32ba 2031 croak("Imager: x and y arrays to i_poly_aa must be equal length\n");
0d80f37e 2032 RETVAL = i_poly_aa_m(im, size_x, x, y, mode, val);
a54e32ba
TC		 2033 OUTPUT:
2034 RETVAL
02d1d628 2035
1c5252ed 2036int
0d80f37e 2037i_poly_aa_cfill_m(im, x, y, mode, fill)
43c5dacb 2038 Imager::ImgRaw im
19e9591b
TC		 2039 double *x
2040 double *y
0d80f37e 2041 i_poly_fill_mode_t mode
a54e32ba
TC		 2042 Imager::FillHandle fill
2043 PREINIT:
19e9591b
TC		 2044 STRLEN size_x;
2045 STRLEN size_y;
a54e32ba 2046 CODE:
19e9591b 2047 if (size_x != size_y)
a54e32ba 2048 croak("Imager: x and y arrays to i_poly_aa_cfill must be equal length\n");
0d80f37e 2049 RETVAL = i_poly_aa_cfill_m(im, size_x, x, y, mode, fill);
a54e32ba
TC		 2050 OUTPUT:
2051 RETVAL
02d1d628 2052
0d80f37e
TC		 2053int
2054i_poly_poly_aa(im, polys, mode, color)
2055 Imager::ImgRaw im
2056 i_polygon_list polys
2057 i_poly_fill_mode_t mode
2058 Imager::Color color
2059 CODE:
2060 RETVAL = i_poly_poly_aa(im, polys.count, polys.polygons, mode, color);
2061 OUTPUT:
2062 RETVAL
2063
2064int
2065i_poly_poly_aa_cfill(im, polys, mode, fill)
2066 Imager::ImgRaw im
2067 i_polygon_list polys
2068 i_poly_fill_mode_t mode
2069 Imager::FillHandle fill
2070 CODE:
2071 RETVAL = i_poly_poly_aa_cfill(im, polys.count, polys.polygons, mode, fill);
2072 OUTPUT:
2073 RETVAL
2074
a321d497 2075undef_int
02d1d628
AMH		 2076i_flood_fill(im,seedx,seedy,dcol)
2077 Imager::ImgRaw im
8d14daab
TC		 2078 i_img_dim seedx
2079 i_img_dim seedy
02d1d628
AMH		 2080 Imager::Color dcol
2081
a321d497 2082undef_int
cc6483e0
TC		 2083i_flood_cfill(im,seedx,seedy,fill)
2084 Imager::ImgRaw im
8d14daab
TC		 2085 i_img_dim seedx
2086 i_img_dim seedy
cc6483e0
TC		 2087 Imager::FillHandle fill
2088
3efb0915
TC		 2089undef_int
2090i_flood_fill_border(im,seedx,seedy,dcol, border)
2091 Imager::ImgRaw im
8d14daab
TC		 2092 i_img_dim seedx
2093 i_img_dim seedy
3efb0915
TC		 2094 Imager::Color dcol
2095 Imager::Color border
2096
2097undef_int
2098i_flood_cfill_border(im,seedx,seedy,fill, border)
2099 Imager::ImgRaw im
8d14daab
TC		 2100 i_img_dim seedx
2101 i_img_dim seedy
3efb0915
TC		 2102 Imager::FillHandle fill
2103 Imager::Color border
2104
02d1d628
AMH		 2105
2106void
2107i_copyto(im,src,x1,y1,x2,y2,tx,ty)
2108 Imager::ImgRaw im
2109 Imager::ImgRaw src
8d14daab
TC		 2110 i_img_dim x1
2111 i_img_dim y1
2112 i_img_dim x2
2113 i_img_dim y2
2114 i_img_dim tx
2115 i_img_dim ty
02d1d628
AMH		 2116
2117
2118void
2119i_copyto_trans(im,src,x1,y1,x2,y2,tx,ty,trans)
2120 Imager::ImgRaw im
2121 Imager::ImgRaw src
8d14daab
TC		 2122 i_img_dim x1
2123 i_img_dim y1
2124 i_img_dim x2
2125 i_img_dim y2
2126 i_img_dim tx
2127 i_img_dim ty
02d1d628
AMH		 2128 Imager::Color trans
2129
92bda632
TC		 2130Imager::ImgRaw
2131i_copy(src)
02d1d628
AMH		 2132 Imager::ImgRaw src
2133
2134
faa9b3e7 2135undef_int
71dc4a83 2136i_rubthru(im,src,tx,ty,src_minx,src_miny,src_maxx,src_maxy)
02d1d628
AMH		 2137 Imager::ImgRaw im
2138 Imager::ImgRaw src
8d14daab
TC		 2139 i_img_dim tx
2140 i_img_dim ty
2141 i_img_dim src_minx
2142 i_img_dim src_miny
2143 i_img_dim src_maxx
2144 i_img_dim src_maxy
71dc4a83 2145
9b1ec2b8
TC		 2146undef_int
2147i_compose(out, src, out_left, out_top, src_left, src_top, width, height, combine = ic_normal, opacity = 0.0)
2148 Imager::ImgRaw out
2149 Imager::ImgRaw src
8d14daab
TC		 2150 i_img_dim out_left
2151 i_img_dim out_top
2152 i_img_dim src_left
2153 i_img_dim src_top
2154 i_img_dim width
2155 i_img_dim height
9b1ec2b8 2156 int combine
5824f4c2 2157 im_double opacity
9b1ec2b8
TC		 2158
2159undef_int
2160i_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)
2161 Imager::ImgRaw out
2162 Imager::ImgRaw src
2163 Imager::ImgRaw mask
8d14daab
TC		 2164 i_img_dim out_left
2165 i_img_dim out_top
2166 i_img_dim src_left
2167 i_img_dim src_top
2168 i_img_dim mask_left
2169 i_img_dim mask_top
2170 i_img_dim width
2171 i_img_dim height
9b1ec2b8 2172 int combine
5824f4c2 2173 im_double opacity
02d1d628 2174
b47464c1
TC		 2175Imager::ImgRaw
2176i_combine(src_av, channels_av = NULL)
2177 AV *src_av
2178 AV *channels_av
2179 PREINIT:
2180 i_img **imgs = NULL;
2181 STRLEN in_count;
2182 int *channels = NULL;
2183 int i;
2184 SV **psv;
2185 IV tmp;
2186 CODE:
2187 in_count = av_len(src_av) + 1;
2188 if (in_count > 0) {
2189 imgs = mymalloc(sizeof(i_img*) * in_count);
2190 channels = mymalloc(sizeof(int) * in_count);
2191 for (i = 0; i < in_count; ++i) {
2192 psv = av_fetch(src_av, i, 0);
2193 if (!psv || !*psv || !sv_derived_from(*psv, "Imager::ImgRaw")) {
2194 myfree(imgs);
2195 myfree(channels);
2196 croak("imgs must contain only images");
2197 }
2198 tmp = SvIV((SV*)SvRV(*psv));
2199 imgs[i] = INT2PTR(i_img*, tmp);
2200 if (channels_av &&
2201 (psv = av_fetch(channels_av, i, 0)) != NULL &&
2202 *psv) {
2203 channels[i] = SvIV(*psv);
2204 }
2205 else {
2206 channels[i] = 0;
2207 }
2208 }
2209 }
2210 RETVAL = i_combine(imgs, channels, in_count);
2211 myfree(imgs);
2212 myfree(channels);
2213 OUTPUT:
2214 RETVAL
2215
142c26ff
AMH		 2216undef_int
2217i_flipxy(im, direction)
2218 Imager::ImgRaw im
2219 int direction
2220
faa9b3e7
TC		 2221Imager::ImgRaw
2222i_rotate90(im, degrees)
2223 Imager::ImgRaw im
2224 int degrees
2225
2226Imager::ImgRaw
0d3b936e 2227i_rotate_exact(im, amount, ...)
faa9b3e7 2228 Imager::ImgRaw im
5824f4c2 2229 im_double amount
0d3b936e
TC		 2230 PREINIT:
2231 i_color *backp = NULL;
2232 i_fcolor *fbackp = NULL;
2233 int i;
2234 SV * sv1;
2235 CODE:
2236 /* extract the bg colors if any */
2237 /* yes, this is kind of strange */
2238 for (i = 2; 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_rotate_exact_bg(im, amount, backp, fbackp);
2250 OUTPUT:
2251 RETVAL
faa9b3e7
TC		 2252
2253Imager::ImgRaw
87b3f212 2254i_matrix_transform(im, xsize, ysize, matrix_av, ...)
faa9b3e7 2255 Imager::ImgRaw im
487ec752
TC		 2256 i_img_dim xsize
2257 i_img_dim ysize
87b3f212 2258 AV *matrix_av
487ec752
TC		 2259 PREINIT:
2260 double matrix[9];
2261 STRLEN len;
2262 SV *sv1;
2263 int i;
2264 i_color *backp = NULL;
2265 i_fcolor *fbackp = NULL;
2266 CODE:
2267 len=av_len(matrix_av)+1;
2268 if (len > 9)
2269 len = 9;
2270 for (i = 0; i < len; ++i) {
2271 sv1=(*(av_fetch(matrix_av,i,0)));
2272 matrix[i] = SvNV(sv1);
2273 }
2274 for (; i < 9; ++i)
2275 matrix[i] = 0;
2276 /* extract the bg colors if any */
2277 /* yes, this is kind of strange */
2278 for (i = 4; i < items; ++i) {
2279 sv1 = ST(i);
2280 if (sv_derived_from(sv1, "Imager::Color")) {
2281 IV tmp = SvIV((SV*)SvRV(sv1));
2282 backp = INT2PTR(i_color *, tmp);
2283 }
2284 else if (sv_derived_from(sv1, "Imager::Color::Float")) {
2285 IV tmp = SvIV((SV*)SvRV(sv1));
2286 fbackp = INT2PTR(i_fcolor *, tmp);
2287 }
2288 }
2289 RETVAL = i_matrix_transform_bg(im, xsize, ysize, matrix, backp, fbackp);
2290 OUTPUT:
2291 RETVAL
02d1d628 2292
167660cd 2293undef_int
3d3b6bed 2294i_gaussian(im,stddev)
02d1d628 2295 Imager::ImgRaw im
3d3b6bed
TC		 2296 im_double stddev
2297
2298undef_int
2299i_gaussian2(im,stddevX,stddevY)
2300 Imager::ImgRaw im
2301 im_double stddevX
2302 im_double stddevY
02d1d628 2303
b6381851
TC		 2304void
2305i_unsharp_mask(im,stdev,scale)
2306 Imager::ImgRaw im
5824f4c2
TC		 2307 im_double stdev
2308 im_double scale
b6381851 2309
6a3cbaef
TC		 2310int
2311i_conv(im,coef)
2312 Imager::ImgRaw im
2313 AV *coef
2314 PREINIT:
2315 double* c_coef;
2316 int len;
2317 SV* sv1;
2318 int i;
2319 CODE:
2320 len = av_len(coef) + 1;
2321 c_coef=mymalloc( len * sizeof(double) );
2322 for(i = 0; i < len; i++) {
2323 sv1 = (*(av_fetch(coef, i, 0)));
2324 c_coef[i] = (double)SvNV(sv1);
2325 }
2326 RETVAL = i_conv(im, c_coef, len);
2327 myfree(c_coef);
2328 OUTPUT:
2329 RETVAL
02d1d628 2330
d5477d3d
TC		 2331Imager::ImgRaw
2332i_convert(src, avmain)
f5991c03 2333 Imager::ImgRaw src
d5477d3d 2334 AV *avmain
f5991c03 2335 PREINIT:
62869327 2336 double *coeff;
f5991c03
TC		 2337 int outchan;
2338 int inchan;
f5991c03 2339 SV **temp;
f5991c03
TC		 2340 AV *avsub;
2341 int len;
2342 int i, j;
2343 CODE:
f5991c03
TC		 2344 outchan = av_len(avmain)+1;
2345 /* find the biggest */
2346 inchan = 0;
2347 for (j=0; j < outchan; ++j) {
2348 temp = av_fetch(avmain, j, 0);
2349 if (temp && SvROK(*temp) && SvTYPE(SvRV(*temp)) == SVt_PVAV) {
2350 avsub = (AV*)SvRV(*temp);
2351 len = av_len(avsub)+1;
2352 if (len > inchan)
2353 inchan = len;
2354 }
26eb06dd
TC		 2355 else {
2356 i_push_errorf(0, "invalid matrix: element %d is not an array ref", j);
2357 XSRETURN(0);
2358 }
f5991c03 2359 }
62869327 2360 coeff = mymalloc(sizeof(double) * outchan * inchan);
f5991c03
TC		 2361 for (j = 0; j < outchan; ++j) {
2362 avsub = (AV*)SvRV(*av_fetch(avmain, j, 0));
2363 len = av_len(avsub)+1;
2364 for (i = 0; i < len; ++i) {
2365 temp = av_fetch(avsub, i, 0);
2366 if (temp)
2367 coeff[i+j*inchan] = SvNV(*temp);
2368 else
2369 coeff[i+j*inchan] = 0;
2370 }
2371 while (i < inchan)
2372 coeff[i++ + j*inchan] = 0;
2373 }
d5477d3d 2374 RETVAL = i_convert(src, coeff, outchan, inchan);
f5991c03 2375 myfree(coeff);
f5991c03
TC		 2376 OUTPUT:
2377 RETVAL
40eba1ea
AMH		 2378
2379
1136f089 2380undef_int
85f38e13 2381i_map(im, pmaps_av)
40eba1ea 2382 Imager::ImgRaw im
85f38e13 2383 AV *pmaps_av
64655904
TC		 2384 PREINIT:
2385 unsigned int mask = 0;
64655904
TC		 2386 AV *avsub;
2387 SV **temp;
2388 int len;
2389 int i, j;
2390 unsigned char (*maps)[256];
2391 CODE:
2392 len = av_len(pmaps_av)+1;
2393 if (im->channels < len)
2394 len = im->channels;
2395 maps = mymalloc( len * sizeof(unsigned char [256]) );
2396 for (j=0; j<len ; j++) {
2397 temp = av_fetch(pmaps_av, j, 0);
2398 if (temp && SvROK(*temp) && (SvTYPE(SvRV(*temp)) == SVt_PVAV) ) {
2399 avsub = (AV*)SvRV(*temp);
2400 if(av_len(avsub) != 255)
2401 continue;
2402 mask |= 1<<j;
2403 for (i=0; i<256 ; i++) {
2404 int val;
2405 temp = av_fetch(avsub, i, 0);
2406 val = temp ? SvIV(*temp) : 0;
2407 if (val<0) val = 0;
2408 if (val>255) val = 255;
2409 maps[j][i] = val;
2410 }
2411 }
2412 }
2413 i_map(im, maps, mask);
2414 myfree(maps);
2415 RETVAL = 1;
2416 OUTPUT:
2417 RETVAL
40eba1ea 2418
02d1d628
AMH		 2419float
2420i_img_diff(im1,im2)
2421 Imager::ImgRaw im1
2422 Imager::ImgRaw im2
2423
e41cfe8f
TC		 2424double
2425i_img_diffd(im1,im2)
2426 Imager::ImgRaw im1
2427 Imager::ImgRaw im2
02d1d628 2428
4498c8bd
TC		 2429int
2430i_img_samef(im1, im2, epsilon = i_img_epsilonf(), what=NULL)
2431 Imager::ImgRaw im1
2432 Imager::ImgRaw im2
5824f4c2 2433 im_double epsilon
4498c8bd
TC		 2434 const char *what
2435
2436double
2437i_img_epsilonf()
2438
813d4d0a
TC		 2439bool
2440_is_color_object(sv)
2441 SV* sv
2442 CODE:
2443 SvGETMAGIC(sv);
2444 RETVAL = SvOK(sv) && SvROK(sv) &&
2445 (sv_derived_from(sv, "Imager::Color")
2446 || sv_derived_from(sv, "Imager::Color::Float"));
2447 OUTPUT:
2448 RETVAL
2449
02d1d628
AMH		 2450#ifdef HAVE_LIBTT
2451
2452
4b19f77a 2453Imager::Font::TT
02d1d628
AMH		 2454i_tt_new(fontname)
2455 char* fontname
2456
4b19f77a
AMH		 2457
2458MODULE = Imager PACKAGE = Imager::Font::TT PREFIX=TT_
2459
2460#define TT_DESTROY(handle) i_tt_destroy(handle)
2461
02d1d628 2462void
4b19f77a
AMH		 2463TT_DESTROY(handle)
2464 Imager::Font::TT handle
2465
ffddd407
TC		 2466int
2467TT_CLONE_SKIP(...)
2468 CODE:
8d14daab 2469 (void)items; /* avoid unused warning */
ffddd407
TC		 2470 RETVAL = 1;
2471 OUTPUT:
2472 RETVAL
2473
02d1d628 2474
4b19f77a 2475MODULE = Imager PACKAGE = Imager
02d1d628
AMH		 2476
2477
2478undef_int
e3b4d6c3 2479i_tt_text(handle,im,xb,yb,cl,points,str_sv,smooth,utf8,align=1)
4b19f77a 2480 Imager::Font::TT handle
02d1d628 2481 Imager::ImgRaw im
8d14daab
TC		 2482 i_img_dim xb
2483 i_img_dim yb
02d1d628 2484 Imager::Color cl
5824f4c2 2485 im_double points
4f68b48f 2486 SV * str_sv
02d1d628 2487 int smooth
4f68b48f 2488 int utf8
9ab6338b 2489 int align
4f68b48f
TC		 2490 PREINIT:
2491 char *str;
2492 STRLEN len;
2493 CODE:
e3b4d6c3 2494 str = SvPV(str_sv, len);
4f68b48f
TC		 2495#ifdef SvUTF8
2496 if (SvUTF8(str_sv))
2497 utf8 = 1;
2498#endif
4f68b48f 2499 RETVAL = i_tt_text(handle, im, xb, yb, cl, points, str,
9ab6338b 2500 len, smooth, utf8, align);
4f68b48f
TC		 2501 OUTPUT:
2502 RETVAL
02d1d628
AMH		 2503
2504
2505undef_int
e3b4d6c3 2506i_tt_cp(handle,im,xb,yb,channel,points,str_sv,smooth,utf8,align=1)
4b19f77a 2507 Imager::Font::TT handle
02d1d628 2508 Imager::ImgRaw im
8d14daab
TC		 2509 i_img_dim xb
2510 i_img_dim yb
02d1d628 2511 int channel
5824f4c2 2512 im_double points
4f68b48f 2513 SV * str_sv
02d1d628 2514 int smooth
4f68b48f 2515 int utf8
9ab6338b 2516 int align
4f68b48f
TC		 2517 PREINIT:
2518 char *str;
2519 STRLEN len;
2520 CODE:
e3b4d6c3 2521 str = SvPV(str_sv, len);
4f68b48f
TC		 2522#ifdef SvUTF8
2523 if (SvUTF8(str_sv))
2524 utf8 = 1;
2525#endif
4f68b48f 2526 RETVAL = i_tt_cp(handle, im, xb, yb, channel, points, str, len,
9ab6338b 2527 smooth, utf8, align);
4f68b48f
TC		 2528 OUTPUT:
2529 RETVAL
02d1d628
AMH		 2530
2531
a659442a 2532void
7e3298ec 2533i_tt_bbox(handle,point,str_sv,utf8)
4b19f77a 2534 Imager::Font::TT handle
5824f4c2 2535 im_double point
4f68b48f 2536 SV* str_sv
4f68b48f 2537 int utf8
02d1d628 2538 PREINIT:
8d14daab
TC		 2539 i_img_dim cords[BOUNDING_BOX_COUNT];
2540 int rc;
4f68b48f
TC		 2541 char * str;
2542 STRLEN len;
3799c4d1 2543 int i;
02d1d628 2544 PPCODE:
7e3298ec 2545 str = SvPV(str_sv, len);
4f68b48f
TC		 2546#ifdef SvUTF8
2547 if (SvUTF8(ST(2)))
2548 utf8 = 1;
2549#endif
4f68b48f 2550 if ((rc=i_tt_bbox(handle,point,str,len,cords, utf8))) {
3799c4d1
TC		 2551 EXTEND(SP, rc);
2552 for (i = 0; i < rc; ++i) {
2553 PUSHs(sv_2mortal(newSViv(cords[i])));
2554 }
02d1d628
AMH		 2555 }
2556
eeaa33fd
TC		 2557void
2558i_tt_has_chars(handle, text_sv, utf8)
2559 Imager::Font::TT handle
2560 SV *text_sv
2561 int utf8
2562 PREINIT:
2563 char const *text;
2564 STRLEN len;
2565 char *work;
8d14daab
TC		 2566 size_t count;
2567 size_t i;
eeaa33fd 2568 PPCODE:
7e3298ec
TC		 2569 i_clear_error();
2570 text = SvPV(text_sv, len);
eeaa33fd
TC		 2571#ifdef SvUTF8
2572 if (SvUTF8(text_sv))
2573 utf8 = 1;
2574#endif
eeaa33fd
TC		 2575 work = mymalloc(len);
2576 count = i_tt_has_chars(handle, text, len, utf8, work);
2577 if (GIMME_V == G_ARRAY) {
7eb58d07
TC		 2578 if (count) {
2579 EXTEND(SP, count);
2580 for (i = 0; i < count; ++i) {
2581 PUSHs(boolSV(work[i]));
2582 }
2583 }
eeaa33fd
TC		 2584 }
2585 else {
2586 EXTEND(SP, 1);
2587 PUSHs(sv_2mortal(newSVpv(work, count)));
2588 }
2589 myfree(work);
02d1d628 2590
3799c4d1
TC		 2591void
2592i_tt_dump_names(handle)
2593 Imager::Font::TT handle
02d1d628 2594
3799c4d1
TC		 2595void
2596i_tt_face_name(handle)
2597 Imager::Font::TT handle
2598 PREINIT:
2599 char name[255];
8d14daab 2600 size_t len;
3799c4d1
TC		 2601 PPCODE:
2602 len = i_tt_face_name(handle, name, sizeof(name));
2603 if (len) {
2604 EXTEND(SP, 1);
8d14daab 2605 PUSHs(sv_2mortal(newSVpv(name, len-1)));
3799c4d1 2606 }
02d1d628 2607
19fa4baf
AMH		 2608void
2609i_tt_glyph_name(handle, text_sv, utf8 = 0)
3799c4d1
TC		 2610 Imager::Font::TT handle
2611 SV *text_sv
2612 int utf8
2613 PREINIT:
2614 char const *text;
2615 STRLEN work_len;
718b8c97 2616 size_t len;
8d14daab 2617 size_t outsize;
3799c4d1
TC		 2618 char name[255];
2619 PPCODE:
7e3298ec
TC		 2620 i_clear_error();
2621 text = SvPV(text_sv, work_len);
3799c4d1
TC		 2622#ifdef SvUTF8
2623 if (SvUTF8(text_sv))
2624 utf8 = 1;
2625#endif
3799c4d1
TC		 2626 len = work_len;
2627 while (len) {
17892255 2628 unsigned long ch;
3799c4d1
TC		 2629 if (utf8) {
2630 ch = i_utf8_advance(&text, &len);
2631 if (ch == ~0UL) {
2632 i_push_error(0, "invalid UTF8 character");
7e3298ec 2633 XSRETURN_EMPTY;
3799c4d1
TC		 2634 }
2635 }
2636 else {
2637 ch = *text++;
2638 --len;
2639 }
ea3099db 2640 EXTEND(SP, 1);
af070d99 2641 if ((outsize = i_tt_glyph_name(handle, ch, name, sizeof(name))) != 0) {
ea3099db 2642 PUSHs(sv_2mortal(newSVpv(name, 0)));
3799c4d1
TC		 2643 }
2644 else {
ea3099db 2645 PUSHs(&PL_sv_undef);
7e3298ec 2646 }
3799c4d1
TC		 2647 }
2648
2649#endif
02d1d628 2650
53a6bbd4 2651const char *
e10bf46e
AMH		 2652i_test_format_probe(ig, length)
2653 Imager::IO ig
2654 int length
2655
b7028a2e
TC		 2656int
2657i_add_file_magic(name, bits_sv, mask_sv)
2658 const char *name
2659 SV *bits_sv
2660 SV *mask_sv
2661 PREINIT:
2662 const unsigned char *bits;
2663 const unsigned char *mask;
2664 size_t bits_size;
2665 size_t mask_size;
2666 CODE:
2667 i_clear_error();
2668 bits = SvPV(bits_sv, bits_size);
2669 mask = SvPV(mask_sv, mask_size);
2670 if (bits_size == 0) {
2671 i_push_error(0, "bits must be non-empty");
2672 XSRETURN_EMPTY;
2673 }
2674 if (mask_size == 0) {
2675 i_push_error(0, "mask must be non-empty");
2676 XSRETURN_EMPTY;
2677 }
2678 if (bits_size != mask_size) {
2679 i_push_error(0, "bits and mask must be the same length");
2680 XSRETURN_EMPTY;
2681 }
2682 if (!*name) {
2683 i_push_error(0, "name must be non-empty");
2684 XSRETURN_EMPTY;
2685 }
2686 RETVAL = i_add_file_magic(name, bits, mask, bits_size);
2687 OUTPUT:
2688 RETVAL
2689
02d1d628 2690Imager::ImgRaw
d87dc9a4 2691i_readpnm_wiol(ig, allow_incomplete)
02d1d628 2692 Imager::IO ig
d87dc9a4 2693 int allow_incomplete
02d1d628
AMH		 2694
2695
2086be61
TC		 2696void
2697i_readpnm_multi_wiol(ig, allow_incomplete)
2698 Imager::IO ig
2699 int allow_incomplete
2700 PREINIT:
2701 i_img **imgs;
2702 int count=0;
2703 int i;
2704 PPCODE:
2705 imgs = i_readpnm_multi_wiol(ig, &count, allow_incomplete);
2706 if (imgs) {
2707 EXTEND(SP, count);
2708 for (i = 0; i < count; ++i) {
2709 SV *sv = sv_newmortal();
2710 sv_setref_pv(sv, "Imager::ImgRaw", (void *)imgs[i]);
2711 PUSHs(sv);
2712 }
2713 myfree(imgs);
2714 }
2715
067d6bdc
AMH		 2716undef_int
2717i_writeppm_wiol(im, ig)
2718 Imager::ImgRaw im
2719 Imager::IO ig
2720
2721
2086be61
TC		 2722
2723
2724
02d1d628 2725Imager::ImgRaw
895dbd34
AMH		 2726i_readraw_wiol(ig,x,y,datachannels,storechannels,intrl)
2727 Imager::IO ig
8d14daab
TC		 2728 i_img_dim x
2729 i_img_dim y
02d1d628
AMH		 2730 int datachannels
2731 int storechannels
2732 int intrl
2733
2734undef_int
895dbd34 2735i_writeraw_wiol(im,ig)
02d1d628 2736 Imager::ImgRaw im
895dbd34
AMH		 2737 Imager::IO ig
2738
261f91c5
TC		 2739undef_int
2740i_writebmp_wiol(im,ig)
2741 Imager::ImgRaw im
2742 Imager::IO ig
02d1d628 2743
705fd961 2744Imager::ImgRaw
d87dc9a4 2745i_readbmp_wiol(ig, allow_incomplete=0)
705fd961 2746 Imager::IO ig
d87dc9a4 2747 int allow_incomplete
705fd961 2748
1ec86afa
AMH		 2749
2750undef_int
febba01f 2751i_writetga_wiol(im,ig, wierdpack, compress, idstring)
1ec86afa
AMH		 2752 Imager::ImgRaw im
2753 Imager::IO ig
febba01f
AMH		 2754 int wierdpack
2755 int compress
2756 char* idstring
2757 PREINIT:
febba01f
AMH		 2758 int idlen;
2759 CODE:
2760 idlen = SvCUR(ST(4));
2761 RETVAL = i_writetga_wiol(im, ig, wierdpack, compress, idstring, idlen);
2762 OUTPUT:
2763 RETVAL
2764
1ec86afa
AMH		 2765
2766Imager::ImgRaw
2767i_readtga_wiol(ig, length)
2768 Imager::IO ig
2769 int length
2770
2771
737a830c
AMH		 2772
2773
02d1d628
AMH		 2774Imager::ImgRaw
2775i_scaleaxis(im,Value,Axis)
2776 Imager::ImgRaw im
5824f4c2 2777 im_double Value
02d1d628
AMH		 2778 int Axis
2779
2780Imager::ImgRaw
2781i_scale_nn(im,scx,scy)
2782 Imager::ImgRaw im
5824f4c2
TC		 2783 im_double scx
2784 im_double scy
02d1d628 2785
658f724e
TC		 2786Imager::ImgRaw
2787i_scale_mixing(im, width, height)
2788 Imager::ImgRaw im
8d14daab
TC		 2789 i_img_dim width
2790 i_img_dim height
658f724e 2791
02d1d628
AMH		 2792Imager::ImgRaw
2793i_haar(im)
2794 Imager::ImgRaw im
2795
2796int
2797i_count_colors(im,maxc)
2798 Imager::ImgRaw im
2799 int maxc
2800
fe622da1 2801void
a60905e4
TC		 2802i_get_anonymous_color_histo(im, maxc = 0x40000000)
2803 Imager::ImgRaw im
2804 int maxc
4c99febf 2805 PREINIT:
fe622da1 2806 int i;
a60905e4 2807 unsigned int * col_usage = NULL;
4c99febf
TC		 2808 int col_cnt;
2809 PPCODE:
2810 col_cnt = i_get_anonymous_color_histo(im, &col_usage, maxc);
8b810590
TC		 2811 if (col_cnt <= 0) {
2812 XSRETURN_EMPTY;
2813 }
2814 EXTEND(SP, col_cnt);
2815 for (i = 0; i < col_cnt; i++) {
2816 PUSHs(sv_2mortal(newSViv( col_usage[i])));
fe622da1 2817 }
8b810590 2818 myfree(col_usage);
fe622da1 2819
02d1d628 2820
fb9cb3f9 2821void
19e9591b 2822i_transform(im, opx, opy, parm)
02d1d628 2823 Imager::ImgRaw im
19e9591b
TC		 2824 int *opx
2825 int *opy
2826 double *parm
02d1d628 2827 PREINIT:
19e9591b 2828 STRLEN size_opx, size_opy, size_parm;
fb9cb3f9
TC		 2829 i_img *result;
2830 PPCODE:
19e9591b 2831 result=i_transform(im,opx,size_opx,opy,size_opy,parm,size_parm);
fb9cb3f9
TC		 2832 if (result) {
2833 SV *result_sv = sv_newmortal();
2834 EXTEND(SP, 1);
2835 sv_setref_pv(result_sv, "Imager::ImgRaw", (void*)result);
2836 PUSHs(result_sv);
2837 }
02d1d628 2838
fb9cb3f9 2839void
e5744e01
TC		 2840i_transform2(sv_width,sv_height,channels,sv_ops,av_n_regs,av_c_regs,av_in_imgs)
2841 SV *sv_width
2842 SV *sv_height
2843 SV *sv_ops
2844 AV *av_n_regs
2845 AV *av_c_regs
2846 AV *av_in_imgs
2847 int channels
02d1d628 2848 PREINIT:
8d14daab
TC		 2849 i_img_dim width;
2850 i_img_dim height;
02d1d628 2851 struct rm_op *ops;
953209f8 2852 STRLEN ops_len;
02d1d628
AMH		 2853 int ops_count;
2854 double *n_regs;
2855 int n_regs_count;
2856 i_color *c_regs;
2857 int c_regs_count;
2858 int in_imgs_count;
2859 i_img **in_imgs;
ea9e6c3f 2860 SV *sv1;
02d1d628
AMH		 2861 IV tmp;
2862 int i;
fb9cb3f9
TC		 2863 i_img *result;
2864 PPCODE:
e5744e01
TC		 2865
2866 in_imgs_count = av_len(av_in_imgs)+1;
2867 for (i = 0; i < in_imgs_count; ++i) {
2868 sv1 = *av_fetch(av_in_imgs, i, 0);
2869 if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
2870 croak("sv_in_img must contain only images");
02d1d628
AMH		 2871 }
2872 }
b8c2033e 2873 if (in_imgs_count > 0) {
02d1d628
AMH		 2874 in_imgs = mymalloc(in_imgs_count*sizeof(i_img*));
2875 for (i = 0; i < in_imgs_count; ++i) {
e5744e01 2876 sv1 = *av_fetch(av_in_imgs,i,0);
02d1d628
AMH		 2877 if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
2878 croak("Parameter 5 must contain only images");
2879 }
2880 tmp = SvIV((SV*)SvRV(sv1));
e375fbd8 2881 in_imgs[i] = INT2PTR(i_img*, tmp);
02d1d628
AMH		 2882 }
2883 }
2884 else {
2885 /* no input images */
2886 in_imgs = NULL;
2887 }
2888 /* default the output size from the first input if possible */
e5744e01
TC		 2889 if (SvOK(sv_width))
2890 width = SvIV(sv_width);
02d1d628
AMH		 2891 else if (in_imgs_count)
2892 width = in_imgs[0]->xsize;
2893 else
2894 croak("No output image width supplied");
2895
e5744e01
TC		 2896 if (SvOK(sv_height))
2897 height = SvIV(sv_height);
02d1d628
AMH		 2898 else if (in_imgs_count)
2899 height = in_imgs[0]->ysize;
2900 else
2901 croak("No output image height supplied");
2902
e5744e01 2903 ops = (struct rm_op *)SvPV(sv_ops, ops_len);
02d1d628
AMH		 2904 if (ops_len % sizeof(struct rm_op))
2905 croak("Imager: Parameter 3 must be a bitmap of regops\n");
2906 ops_count = ops_len / sizeof(struct rm_op);
e5744e01
TC		 2907
2908 n_regs_count = av_len(av_n_regs)+1;
02d1d628
AMH		 2909 n_regs = mymalloc(n_regs_count * sizeof(double));
2910 for (i = 0; i < n_regs_count; ++i) {
e5744e01 2911 sv1 = *av_fetch(av_n_regs,i,0);
02d1d628
AMH		 2912 if (SvOK(sv1))
2913 n_regs[i] = SvNV(sv1);
2914 }
e5744e01 2915 c_regs_count = av_len(av_c_regs)+1;
02d1d628
AMH		 2916 c_regs = mymalloc(c_regs_count * sizeof(i_color));
2917 /* I don't bother initializing the colou?r registers */
2918
fb9cb3f9 2919 result=i_transform2(width, height, channels, ops, ops_count,
02d1d628
AMH		 2920 n_regs, n_regs_count,
2921 c_regs, c_regs_count, in_imgs, in_imgs_count);
2922 if (in_imgs)
2923 myfree(in_imgs);
2924 myfree(n_regs);
2925 myfree(c_regs);
fb9cb3f9
TC		 2926 if (result) {
2927 SV *result_sv = sv_newmortal();
2928 EXTEND(SP, 1);
2929 sv_setref_pv(result_sv, "Imager::ImgRaw", (void*)result);
2930 PUSHs(result_sv);
2931 }
02d1d628
AMH		 2932
2933
2934void
2935i_contrast(im,intensity)
2936 Imager::ImgRaw im
5824f4c2 2937 im_float intensity
02d1d628
AMH		 2938
2939void
2940i_hardinvert(im)
2941 Imager::ImgRaw im
2942
5558f899
TC		 2943void
2944i_hardinvertall(im)
2945 Imager::ImgRaw im
2946
02d1d628
AMH		 2947void
2948i_noise(im,amount,type)
2949 Imager::ImgRaw im
5824f4c2 2950 im_float amount
02d1d628
AMH		 2951 unsigned char type
2952
2953void
2954i_bumpmap(im,bump,channel,light_x,light_y,strength)
2955 Imager::ImgRaw im
2956 Imager::ImgRaw bump
2957 int channel
8d14daab
TC		 2958 i_img_dim light_x
2959 i_img_dim light_y
2960 i_img_dim strength
02d1d628 2961
b2778574
AMH		 2962
2963void
2964i_bumpmap_complex(im,bump,channel,tx,ty,Lx,Ly,Lz,cd,cs,n,Ia,Il,Is)
2965 Imager::ImgRaw im
2966 Imager::ImgRaw bump
2967 int channel
8d14daab
TC		 2968 i_img_dim tx
2969 i_img_dim ty
5824f4c2
TC		 2970 im_double Lx
2971 im_double Ly
2972 im_double Lz
2973 im_float cd
2974 im_float cs
2975 im_float n
b2778574
AMH		 2976 Imager::Color Ia
2977 Imager::Color Il
2978 Imager::Color Is
2979
2980
2981
02d1d628
AMH		 2982void
2983i_postlevels(im,levels)
2984 Imager::ImgRaw im
2985 int levels
2986
2987void
2988i_mosaic(im,size)
2989 Imager::ImgRaw im
8d14daab 2990 i_img_dim size
02d1d628
AMH		 2991
2992void
2993i_watermark(im,wmark,tx,ty,pixdiff)
2994 Imager::ImgRaw im
2995 Imager::ImgRaw wmark
8d14daab
TC		 2996 i_img_dim tx
2997 i_img_dim ty
02d1d628
AMH		 2998 int pixdiff
2999
3000
3001void
3002i_autolevels(im,lsat,usat,skew)
3003 Imager::ImgRaw im
5824f4c2
TC		 3004 im_float lsat
3005 im_float usat
3006 im_float skew
02d1d628 3007
ac00f58d
TC		 3008void
3009i_autolevels_mono(im,lsat,usat)
3010 Imager::ImgRaw im
5824f4c2
TC		 3011 im_float lsat
3012 im_float usat
ac00f58d 3013
02d1d628
AMH		 3014void
3015i_radnoise(im,xo,yo,rscale,ascale)
3016 Imager::ImgRaw im
5824f4c2
TC		 3017 im_float xo
3018 im_float yo
3019 im_float rscale
3020 im_float ascale
02d1d628
AMH		 3021
3022void
3023i_turbnoise(im, xo, yo, scale)
3024 Imager::ImgRaw im
5824f4c2
TC		 3025 im_float xo
3026 im_float yo
3027 im_float scale
02d1d628
AMH		 3028
3029
3030void
0aaa8b4d 3031i_gradgen(im, xo, yo, ac, dmeasure)
02d1d628 3032 Imager::ImgRaw im
0aaa8b4d
TC		 3033 i_img_dim *xo
3034 i_img_dim *yo
3035 i_color *ac
3036 int dmeasure
02d1d628 3037 PREINIT:
0aaa8b4d
TC		 3038 STRLEN size_xo;
3039 STRLEN size_yo;
3040 STRLEN size_ac;
02d1d628 3041 CODE:
0aaa8b4d
TC		 3042 if (size_xo != size_yo || size_xo != size_ac)
3043 croak("i_gradgen: x, y and color arrays must be the same size");
3044 if (size_xo < 2)
3045 croak("Usage: i_gradgen array refs must have more than 1 entry each");
3046 i_gradgen(im, size_xo, xo, yo, ac, dmeasure);
a73aeb5f 3047
dff75dee
TC		 3048Imager::ImgRaw
3049i_diff_image(im, im2, mindist=0)
3050 Imager::ImgRaw im
3051 Imager::ImgRaw im2
5824f4c2 3052 im_double mindist
02d1d628 3053
e310e5f9 3054undef_int
6607600c
TC		 3055i_fountain(im, xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
3056 Imager::ImgRaw im
5824f4c2
TC		 3057 im_double xa
3058 im_double ya
3059 im_double xb
3060 im_double yb
6607600c
TC		 3061 int type
3062 int repeat
3063 int combine
3064 int super_sample
5824f4c2 3065 im_double ssample_param
6607600c 3066 PREINIT:
6607600c 3067 AV *asegs;
6607600c
TC		 3068 int count;
3069 i_fountain_seg *segs;
6607600c 3070 CODE:
6607600c
TC		 3071 if (!SvROK(ST(10)) || ! SvTYPE(SvRV(ST(10))))
3072 croak("i_fountain: argument 11 must be an array ref");
3073
3074 asegs = (AV *)SvRV(ST(10));
b13a3ddb 3075 segs = load_fount_segs(aTHX_ asegs, &count);
e310e5f9
TC		 3076 RETVAL = i_fountain(im, xa, ya, xb, yb, type, repeat, combine,
3077 super_sample, ssample_param, count, segs);
6607600c 3078 myfree(segs);
e310e5f9
TC		 3079 OUTPUT:
3080 RETVAL
02d1d628 3081
f1ac5027
TC		 3082Imager::FillHandle
3083i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
5824f4c2
TC		 3084 im_double xa
3085 im_double ya
3086 im_double xb
3087 im_double yb
f1ac5027
TC		 3088 int type
3089 int repeat
3090 int combine
3091 int super_sample
5824f4c2 3092 im_double ssample_param
f1ac5027
TC		 3093 PREINIT:
3094 AV *asegs;
3095 int count;
3096 i_fountain_seg *segs;
3097 CODE:
3098 if (!SvROK(ST(9)) || ! SvTYPE(SvRV(ST(9))))
3099 croak("i_fountain: argument 11 must be an array ref");
3100
3101 asegs = (AV *)SvRV(ST(9));
b13a3ddb 3102 segs = load_fount_segs(aTHX_ asegs, &count);
f1ac5027
TC		 3103 RETVAL = i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine,
3104 super_sample, ssample_param, count, segs);
3105 myfree(segs);
3106 OUTPUT:
3107 RETVAL
3108
52f2b10a
TC		 3109Imager::FillHandle
3110i_new_fill_opacity(other_fill, alpha_mult)
3111 Imager::FillHandle other_fill
5824f4c2 3112 im_double alpha_mult
52f2b10a 3113
4f4f776a
TC		 3114void
3115i_errors()
3116 PREINIT:
3117 i_errmsg *errors;
3118 int i;
4f4f776a 3119 AV *av;
4f4f776a
TC		 3120 SV *sv;
3121 PPCODE:
3122 errors = i_errors();
3123 i = 0;
3124 while (errors[i].msg) {
3125 av = newAV();
3126 sv = newSVpv(errors[i].msg, strlen(errors[i].msg));
3127 if (!av_store(av, 0, sv)) {
3128 SvREFCNT_dec(sv);
3129 }
3130 sv = newSViv(errors[i].code);
3131 if (!av_store(av, 1, sv)) {
3132 SvREFCNT_dec(sv);
3133 }
57bbbbe7 3134 XPUSHs(sv_2mortal(newRV_noinc((SV*)av)));
4f4f776a
TC		 3135 ++i;
3136 }
02d1d628 3137
2b405c9e
TC		 3138void
3139i_clear_error()
3140
3141void
3142i_push_error(code, msg)
3143 int code
3144 const char *msg
3145
e310e5f9 3146undef_int
02d1d628
AMH		 3147i_nearest_color(im, ...)
3148 Imager::ImgRaw im
3149 PREINIT:
3150 int num;
8d14daab
TC		 3151 i_img_dim *xo;
3152 i_img_dim *yo;
02d1d628
AMH		 3153 i_color *ival;
3154 int dmeasure;
3155 int i;
3156 SV *sv;
3157 AV *axx;
3158 AV *ayy;
3159 AV *ac;
3160 CODE:
3161 if (items != 5)
3162 croak("Usage: i_nearest_color(im, xo, yo, ival, dmeasure)");
3163 if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
3164 croak("i_nearest_color: Second argument must be an array ref");
3165 if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
3166 croak("i_nearest_color: Third argument must be an array ref");
3167 if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
3168 croak("i_nearest_color: Fourth argument must be an array ref");
3169 axx = (AV *)SvRV(ST(1));
3170 ayy = (AV *)SvRV(ST(2));
3171 ac = (AV *)SvRV(ST(3));
3172 dmeasure = (int)SvIV(ST(4));
3173
3174 num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
3175 num = num <= av_len(ac) ? num : av_len(ac);
3176 num++;
3177 if (num < 2) croak("Usage: i_nearest_color array refs must have more than 1 entry each");
945dff7f
TC		 3178 xo = malloc_temp(aTHX_ sizeof(i_img_dim) * num );
3179 yo = malloc_temp(aTHX_ sizeof(i_img_dim) * num );
3180 ival = malloc_temp(aTHX_ sizeof(i_color) * num );
02d1d628 3181 for(i = 0; i<num; i++) {
8d14daab
TC		 3182 xo[i] = (i_img_dim)SvIV(* av_fetch(axx, i, 0));
3183 yo[i] = (i_img_dim)SvIV(* av_fetch(ayy, i, 0));
02d1d628
AMH		 3184 sv = *av_fetch(ac, i, 0);
3185 if ( !sv_derived_from(sv, "Imager::Color") ) {
3186 free(axx); free(ayy); free(ac);
3187 croak("i_nearest_color: Element of fourth argument is not derived from Imager::Color");
3188 }
4c4c2ffd 3189 ival[i] = *INT2PTR(i_color *, SvIV((SV *)SvRV(sv)));
02d1d628 3190 }
e310e5f9
TC		 3191 RETVAL = i_nearest_color(im, num, xo, yo, ival, dmeasure);
3192 OUTPUT:
3193 RETVAL
02d1d628
AMH		 3194
3195void
3196malloc_state()
3197
02d1d628
AMH		 3198void
3199DSO_open(filename)
3200 char* filename
3201 PREINIT:
3202 void *rc;
3203 char *evstr;
3204 PPCODE:
3205 rc=DSO_open(filename,&evstr);
3206 if (rc!=NULL) {
3207 if (evstr!=NULL) {
3208 EXTEND(SP,2);
e375fbd8 3209 PUSHs(sv_2mortal(newSViv(PTR2IV(rc))));
02d1d628
AMH		 3210 PUSHs(sv_2mortal(newSVpvn(evstr, strlen(evstr))));
3211 } else {
3212 EXTEND(SP,1);
e375fbd8 3213 PUSHs(sv_2mortal(newSViv(PTR2IV(rc))));
02d1d628
AMH		 3214 }
3215 }
3216
3217
3218undef_int
3219DSO_close(dso_handle)
3220 void* dso_handle
3221
3222void
3223DSO_funclist(dso_handle_v)
3224 void* dso_handle_v
3225 PREINIT:
3226 int i;
3227 DSO_handle *dso_handle;
d8e0c3ba 3228 func_ptr *functions;
02d1d628
AMH		 3229 PPCODE:
3230 dso_handle=(DSO_handle*)dso_handle_v;
d8e0c3ba 3231 functions = DSO_funclist(dso_handle);
02d1d628 3232 i=0;
d8e0c3ba 3233 while( functions[i].name != NULL) {
02d1d628 3234 EXTEND(SP,1);
d8e0c3ba 3235 PUSHs(sv_2mortal(newSVpv(functions[i].name,0)));
02d1d628 3236 EXTEND(SP,1);
d8e0c3ba 3237 PUSHs(sv_2mortal(newSVpv(functions[i++].pcode,0)));
02d1d628
AMH		 3238 }
3239
02d1d628
AMH		 3240void
3241DSO_call(handle,func_index,hv)
3242 void* handle
3243 int func_index
75cebca8 3244 HV *hv
02d1d628 3245 PPCODE:
02d1d628
AMH		 3246 DSO_call( (DSO_handle *)handle,func_index,hv);
3247
befd4be1 3248Imager::Color
f5991c03
TC		 3249i_get_pixel(im, x, y)
3250 Imager::ImgRaw im
8d14daab
TC		 3251 i_img_dim x
3252 i_img_dim y;
faa9b3e7 3253 CODE:
befd4be1 3254 RETVAL = (i_color *)mymalloc(sizeof(i_color));
2ea4aa42 3255 memset(RETVAL, 0, sizeof(*RETVAL));
befd4be1
TC		 3256 if (i_gpix(im, x, y, RETVAL) != 0) {
3257 myfree(RETVAL);
3258 XSRETURN_UNDEF;
faa9b3e7 3259 }
a659442a
TC		 3260 OUTPUT:
3261 RETVAL
faa9b3e7
TC		 3262
3263
3264int
3265i_ppix(im, x, y, cl)
3266 Imager::ImgRaw im
8d14daab
TC		 3267 i_img_dim x
3268 i_img_dim y
faa9b3e7
TC		 3269 Imager::Color cl
3270
3271Imager::ImgRaw
3272i_img_pal_new(x, y, channels, maxpal)
8d14daab
TC		 3273 i_img_dim x
3274 i_img_dim y
faa9b3e7
TC		 3275 int channels
3276 int maxpal
3277
3278Imager::ImgRaw
05f2584a 3279i_img_to_pal(src, quant_hv)
faa9b3e7 3280 Imager::ImgRaw src
05f2584a 3281 HV *quant_hv
faa9b3e7
TC		 3282 PREINIT:
3283 HV *hv;
3284 i_quantize quant;
3285 CODE:
faa9b3e7 3286 memset(&quant, 0, sizeof(quant));
ec6d8908 3287 quant.version = 1;
faa9b3e7 3288 quant.mc_size = 256;
a3b721bb
TC		 3289 i_clear_error();
3290 if (!ip_handle_quant_opts2(aTHX_ &quant, quant_hv)) {
3291 XSRETURN_EMPTY;
3292 }
faa9b3e7
TC		 3293 RETVAL = i_img_to_pal(src, &quant);
3294 if (RETVAL) {
05f2584a 3295 ip_copy_colors_back(aTHX_ quant_hv, &quant);
faa9b3e7 3296 }
ec6d8908 3297 ip_cleanup_quant_opts(aTHX_ &quant);
faa9b3e7
TC		 3298 OUTPUT:
3299 RETVAL
3300
3301Imager::ImgRaw
3302i_img_to_rgb(src)
3303 Imager::ImgRaw src
3304
5e9a7fbd
TC		 3305void
3306i_img_make_palette(HV *quant_hv, ...)
3307 PREINIT:
3308 size_t count = items - 1;
3309 i_quantize quant;
3310 i_img **imgs = NULL;
3311 ssize_t i;
3312 PPCODE:
3313 if (count <= 0)
3314 croak("Please supply at least one image (%d)", (int)count);
e9689cbf 3315 imgs = malloc_temp(aTHX_ count * sizeof(i_img *));
5e9a7fbd
TC		 3316 for (i = 0; i < count; ++i) {
3317 SV *img_sv = ST(i + 1);
3318 if (SvROK(img_sv) && sv_derived_from(img_sv, "Imager::ImgRaw")) {
3319 imgs[i] = INT2PTR(i_img *, SvIV((SV*)SvRV(img_sv)));
3320 }
3321 else {
ec2f6280 3322 croak("Image %d is not an image object", (int)i+1);
5e9a7fbd
TC		 3323 }
3324 }
3325 memset(&quant, 0, sizeof(quant));
3326 quant.version = 1;
3327 quant.mc_size = 256;
a3b721bb
TC		 3328 if (!ip_handle_quant_opts2(aTHX_ &quant, quant_hv)) {
3329 XSRETURN_EMPTY;
3330 }
5e9a7fbd
TC		 3331 i_quant_makemap(&quant, imgs, count);
3332 EXTEND(SP, quant.mc_count);
3333 for (i = 0; i < quant.mc_count; ++i) {
3334 SV *sv_c = make_i_color_sv(aTHX_ quant.mc_colors + i);
3335 PUSHs(sv_c);
3336 }
3337 ip_cleanup_quant_opts(aTHX_ &quant);
3338
3339
faa9b3e7
TC		 3340void
3341i_gpal(im, l, r, y)
3342 Imager::ImgRaw im
8d14daab
TC		 3343 i_img_dim l
3344 i_img_dim r
3345 i_img_dim y
faa9b3e7
TC		 3346 PREINIT:
3347 i_palidx *work;
3348 int count, i;
3349 PPCODE:
3350 if (l < r) {
3351 work = mymalloc((r-l) * sizeof(i_palidx));
3352 count = i_gpal(im, l, r, y, work);
3353 if (GIMME_V == G_ARRAY) {
3354 EXTEND(SP, count);
3355 for (i = 0; i < count; ++i) {
3356 PUSHs(sv_2mortal(newSViv(work[i])));
3357 }
3358 }
3359 else {
3360 EXTEND(SP, 1);
26fd367b 3361 PUSHs(sv_2mortal(newSVpv((char *)work, count * sizeof(i_palidx))));
faa9b3e7
TC		 3362 }
3363 myfree(work);
3364 }
3365 else {
3366 if (GIMME_V != G_ARRAY) {
3367 EXTEND(SP, 1);
3368 PUSHs(&PL_sv_undef);
3369 }
3370 }
3371
3372int
3373i_ppal(im, l, y, ...)
3374 Imager::ImgRaw im
8d14daab
TC		 3375 i_img_dim l
3376 i_img_dim y
faa9b3e7
TC		 3377 PREINIT:
3378 i_palidx *work;
ebe9b189 3379 i_img_dim i;
faa9b3e7
TC		 3380 CODE:
3381 if (items > 3) {
ebe9b189 3382 work = malloc_temp(aTHX_ sizeof(i_palidx) * (items-3));
faa9b3e7
TC		 3383 for (i=0; i < items-3; ++i) {
3384 work[i] = SvIV(ST(i+3));
3385 }
4cda4e76 3386 validate_i_ppal(im, work, items - 3);
faa9b3e7 3387 RETVAL = i_ppal(im, l, l+items-3, y, work);
faa9b3e7
TC		 3388 }
3389 else {
3390 RETVAL = 0;
3391 }
3392 OUTPUT:
3393 RETVAL
3394
4cda4e76
TC		 3395int
3396i_ppal_p(im, l, y, data)
3397 Imager::ImgRaw im
8d14daab
TC		 3398 i_img_dim l
3399 i_img_dim y
4cda4e76
TC		 3400 SV *data
3401 PREINIT:
3402 i_palidx const *work;
4cda4e76 3403 STRLEN len;
4cda4e76
TC		 3404 CODE:
3405 work = (i_palidx const *)SvPV(data, len);
3406 len /= sizeof(i_palidx);
3407 if (len > 0) {
3408 validate_i_ppal(im, work, len);
3409 RETVAL = i_ppal(im, l, l+len, y, work);
3410 }
3411 else {
3412 RETVAL = 0;
3413 }
3414 OUTPUT:
3415 RETVAL
3416
42505e61 3417SysRet
faa9b3e7
TC		 3418i_addcolors(im, ...)
3419 Imager::ImgRaw im
3420 PREINIT:
faa9b3e7
TC		 3421 i_color *colors;
3422 int i;
3423 CODE:
3424 if (items < 2)
3425 croak("i_addcolors: no colors to add");
3426 colors = mymalloc((items-1) * sizeof(i_color));
3427 for (i=0; i < items-1; ++i) {
3428 if (sv_isobject(ST(i+1))
3429 && sv_derived_from(ST(i+1), "Imager::Color")) {
3430 IV tmp = SvIV((SV *)SvRV(ST(i+1)));
4c4c2ffd 3431 colors[i] = *INT2PTR(i_color *, tmp);
faa9b3e7
TC		 3432 }
3433 else {
3434 myfree(colors);
ca4d914e 3435 croak("i_addcolor: pixels must be Imager::Color objects");
faa9b3e7
TC		 3436 }
3437 }
42505e61 3438 RETVAL = i_addcolors(im, colors, items-1);
7d5febef 3439 myfree(colors);
a659442a
TC		 3440 OUTPUT:
3441 RETVAL
faa9b3e7 3442
1501d9b3 3443undef_int
faa9b3e7
TC		 3444i_setcolors(im, index, ...)
3445 Imager::ImgRaw im
3446 int index
3447 PREINIT:
3448 i_color *colors;
3449 int i;
3450 CODE:
3451 if (items < 3)
3452 croak("i_setcolors: no colors to add");
3453 colors = mymalloc((items-2) * sizeof(i_color));
3454 for (i=0; i < items-2; ++i) {
3455 if (sv_isobject(ST(i+2))
3456 && sv_derived_from(ST(i+2), "Imager::Color")) {
3457 IV tmp = SvIV((SV *)SvRV(ST(i+2)));
4c4c2ffd 3458 colors[i] = *INT2PTR(i_color *, tmp);
faa9b3e7
TC		 3459 }
3460 else {
3461 myfree(colors);
3462 croak("i_setcolors: pixels must be Imager::Color objects");
3463 }
3464 }
3465 RETVAL = i_setcolors(im, index, colors, items-2);
3466 myfree(colors);
1501d9b3
TC		 3467 OUTPUT:
3468 RETVAL
faa9b3e7
TC		 3469
3470void
1592522f 3471i_getcolors(im, index, count=1)
faa9b3e7
TC		 3472 Imager::ImgRaw im
3473 int index
1592522f 3474 int count
faa9b3e7
TC		 3475 PREINIT:
3476 i_color *colors;
faa9b3e7
TC		 3477 int i;
3478 PPCODE:
faa9b3e7
TC		 3479 if (count < 1)
3480 croak("i_getcolors: count must be positive");
1592522f 3481 colors = malloc_temp(aTHX_ sizeof(i_color) * count);
faa9b3e7 3482 if (i_getcolors(im, index, colors, count)) {
1592522f 3483 EXTEND(SP, count);
faa9b3e7 3484 for (i = 0; i < count; ++i) {
5e9a7fbd 3485 SV *sv = make_i_color_sv(aTHX_ colors+i);
faa9b3e7
TC		 3486 PUSHs(sv);
3487 }
3488 }
faa9b3e7 3489
a659442a 3490undef_neg_int
faa9b3e7
TC		 3491i_colorcount(im)
3492 Imager::ImgRaw im
faa9b3e7 3493
a659442a 3494undef_neg_int
faa9b3e7
TC		 3495i_maxcolors(im)
3496 Imager::ImgRaw im
faa9b3e7 3497
0862f397 3498i_palidx
faa9b3e7
TC		 3499i_findcolor(im, color)
3500 Imager::ImgRaw im
3501 Imager::Color color
faa9b3e7 3502 CODE:
0862f397
TC		 3503 if (!i_findcolor(im, color, &RETVAL)) {
3504 XSRETURN_UNDEF;
faa9b3e7 3505 }
a659442a
TC		 3506 OUTPUT:
3507 RETVAL
faa9b3e7
TC		 3508
3509int
3510i_img_bits(im)
3511 Imager::ImgRaw im
3512
3513int
3514i_img_type(im)
3515 Imager::ImgRaw im
3516
3517int
3518i_img_virtual(im)
3519 Imager::ImgRaw im
3520
3521void
6a9807e8 3522i_gsamp(im, l, r, y, channels)
faa9b3e7 3523 Imager::ImgRaw im
8d14daab
TC		 3524 i_img_dim l
3525 i_img_dim r
3526 i_img_dim y
6a9807e8 3527 i_channel_list channels
faa9b3e7 3528 PREINIT:
faa9b3e7 3529 i_sample_t *data;
8d14daab 3530 i_img_dim count, i;
faa9b3e7 3531 PPCODE:
faa9b3e7 3532 if (l < r) {
f37708ce 3533 data = mymalloc(sizeof(i_sample_t) * (r-l) * channels.count);
6a9807e8 3534 count = i_gsamp(im, l, r, y, data, channels.channels, channels.count);
faa9b3e7
TC		 3535 if (GIMME_V == G_ARRAY) {
3536 EXTEND(SP, count);
3537 for (i = 0; i < count; ++i)
3538 PUSHs(sv_2mortal(newSViv(data[i])));
3539 }
3540 else {
3541 EXTEND(SP, 1);
26fd367b 3542 PUSHs(sv_2mortal(newSVpv((char *)data, count * sizeof(i_sample_t))));
faa9b3e7 3543 }
a73aeb5f 3544 myfree(data);
faa9b3e7
TC		 3545 }
3546 else {
3547 if (GIMME_V != G_ARRAY) {
f37708ce 3548 XSRETURN_UNDEF;
faa9b3e7
TC		 3549 }
3550 }
3551
bd8052a6 3552undef_neg_int
6a9807e8 3553i_gsamp_bits(im, l, r, y, bits, target, offset, channels)
bd8052a6 3554 Imager::ImgRaw im
8d14daab
TC		 3555 i_img_dim l
3556 i_img_dim r
3557 i_img_dim y
bd8052a6
TC		 3558 int bits
3559 AV *target
8d14daab 3560 STRLEN offset
6a9807e8 3561 i_channel_list channels
bd8052a6 3562 PREINIT:
bd8052a6 3563 unsigned *data;
8d14daab 3564 i_img_dim count, i;
bd8052a6
TC		 3565 CODE:
3566 i_clear_error();
3567 if (items < 8)
3568 croak("No channel numbers supplied to g_samp()");
3569 if (l < r) {
6a9807e8
TC		 3570 data = mymalloc(sizeof(unsigned) * (r-l) * channels.count);
3571 count = i_gsamp_bits(im, l, r, y, data, channels.channels, channels.count, bits);
bd8052a6
TC		 3572 for (i = 0; i < count; ++i) {
3573 av_store(target, i+offset, newSVuv(data[i]));
3574 }
3575 myfree(data);
3576 RETVAL = count;
3577 }
3578 else {
3579 RETVAL = 0;
3580 }
3581 OUTPUT:
3582 RETVAL
3583
3584undef_neg_int
6a9807e8 3585i_psamp_bits(im, l, y, bits, channels, data_av, data_offset = 0, pixel_count = -1)
bd8052a6 3586 Imager::ImgRaw im
8d14daab
TC		 3587 i_img_dim l
3588 i_img_dim y
bd8052a6 3589 int bits
6a9807e8 3590 i_channel_list channels
bd8052a6 3591 AV *data_av
848b7f32
TC		 3592 i_img_dim data_offset
3593 i_img_dim pixel_count
bd8052a6 3594 PREINIT:
8d14daab
TC		 3595 STRLEN data_count;
3596 size_t data_used;
bd8052a6 3597 unsigned *data;
8d14daab 3598 ptrdiff_t i;
bd8052a6
TC		 3599 CODE:
3600 i_clear_error();
bd8052a6
TC		 3601
3602 data_count = av_len(data_av) + 1;
3603 if (data_offset < 0) {
848b7f32 3604 croak("data_offset must be non-negative");
bd8052a6
TC		 3605 }
3606 if (data_offset > data_count) {
3607 croak("data_offset greater than number of samples supplied");
3608 }
3609 if (pixel_count == -1 ||
6a9807e8
TC		 3610 data_offset + pixel_count * channels.count > data_count) {
3611 pixel_count = (data_count - data_offset) / channels.count;
bd8052a6
TC		 3612 }
3613
6a9807e8 3614 data_used = pixel_count * channels.count;
bd8052a6
TC		 3615 data = mymalloc(sizeof(unsigned) * data_count);
3616 for (i = 0; i < data_used; ++i)
3617 data[i] = SvUV(*av_fetch(data_av, data_offset + i, 0));
3618
6a9807e8
TC		 3619 RETVAL = i_psamp_bits(im, l, l + pixel_count, y, data, channels.channels,
3620 channels.count, bits);
bd8052a6
TC		 3621
3622 if (data)
3623 myfree(data);
bd8052a6
TC		 3624 OUTPUT:
3625 RETVAL
a73aeb5f 3626
48b9a7bf 3627undef_neg_int
848b7f32 3628i_psamp(im, x, y, channels, data, offset = 0, width = -1)
48b9a7bf
TC		 3629 Imager::ImgRaw im
3630 i_img_dim x
3631 i_img_dim y
3632 i_channel_list channels
3633 i_sample_list data
848b7f32
TC		 3634 i_img_dim offset
3635 i_img_dim width
48b9a7bf
TC		 3636 PREINIT:
3637 i_img_dim r;
3638 CODE:
48b9a7bf 3639 i_clear_error();
848b7f32
TC		 3640 if (offset < 0) {
3641 i_push_error(0, "offset must be non-negative");
3642 XSRETURN_UNDEF;
3643 }
3644 if (offset > 0) {
3645 if (offset > data.count) {
3646 i_push_error(0, "offset greater than number of samples supplied");
3647 XSRETURN_UNDEF;
3648 }
3649 data.samples += offset;
3650 data.count -= offset;
3651 }
3652 if (width == -1 ||
3653 width * channels.count > data.count) {
3654 width = data.count / channels.count;
3655 }
3656 r = x + width;
48b9a7bf
TC		 3657 RETVAL = i_psamp(im, x, r, y, data.samples, channels.channels, channels.count);
3658 OUTPUT:
3659 RETVAL
3660
3661undef_neg_int
848b7f32 3662i_psampf(im, x, y, channels, data, offset = 0, width = -1)
48b9a7bf
TC		 3663 Imager::ImgRaw im
3664 i_img_dim x
3665 i_img_dim y
3666 i_channel_list channels
3667 i_fsample_list data
848b7f32
TC		 3668 i_img_dim offset
3669 i_img_dim width
48b9a7bf
TC		 3670 PREINIT:
3671 i_img_dim r;
3672 CODE:
48b9a7bf 3673 i_clear_error();
848b7f32
TC		 3674 if (offset < 0) {
3675 i_push_error(0, "offset must be non-negative");
3676 XSRETURN_UNDEF;
3677 }
3678 if (offset > 0) {
3679 if (offset > data.count) {
3680 i_push_error(0, "offset greater than number of samples supplied");
3681 XSRETURN_UNDEF;
3682 }
3683 data.samples += offset;
3684 data.count -= offset;
3685 }
3686 if (width == -1 ||
3687 width * channels.count > data.count) {
3688 width = data.count / channels.count;
3689 }
3690 r = x + width;
48b9a7bf
TC		 3691 RETVAL = i_psampf(im, x, r, y, data.samples, channels.channels, channels.count);
3692 OUTPUT:
3693 RETVAL
3694
faa9b3e7
TC		 3695Imager::ImgRaw
3696i_img_masked_new(targ, mask, x, y, w, h)
3697 Imager::ImgRaw targ
8d14daab
TC		 3698 i_img_dim x
3699 i_img_dim y
3700 i_img_dim w
3701 i_img_dim h
faa9b3e7
TC		 3702 PREINIT:
3703 i_img *mask;
3704 CODE:
3705 if (SvOK(ST(1))) {
3706 if (!sv_isobject(ST(1))
3707 || !sv_derived_from(ST(1), "Imager::ImgRaw")) {
3708 croak("i_img_masked_new: parameter 2 must undef or an image");
3709 }
4c4c2ffd 3710 mask = INT2PTR(i_img *, SvIV((SV *)SvRV(ST(1))));
faa9b3e7
TC		 3711 }
3712 else
3713 mask = NULL;
3714 RETVAL = i_img_masked_new(targ, mask, x, y, w, h);
3715 OUTPUT:
3716 RETVAL
3717
3718int
3719i_plin(im, l, y, ...)
3720 Imager::ImgRaw im
8d14daab
TC		 3721 i_img_dim l
3722 i_img_dim y
faa9b3e7
TC		 3723 PREINIT:
3724 i_color *work;
8d14daab 3725 STRLEN i;
ca4d914e 3726 STRLEN len;
8d14daab 3727 size_t count;
faa9b3e7
TC		 3728 CODE:
3729 if (items > 3) {
ca4d914e
TC		 3730 if (items == 4 && SvOK(ST(3)) && !SvROK(ST(3))) {
3731 /* supplied as a byte string */
3732 work = (i_color *)SvPV(ST(3), len);
3733 count = len / sizeof(i_color);
3734 if (count * sizeof(i_color) != len) {
3735 croak("i_plin: length of scalar argument must be multiple of sizeof i_color");
faa9b3e7 3736 }
ca4d914e
TC		 3737 RETVAL = i_plin(im, l, l+count, y, work);
3738 }
3739 else {
3740 work = mymalloc(sizeof(i_color) * (items-3));
3741 for (i=0; i < items-3; ++i) {
3742 if (sv_isobject(ST(i+3))
3743 && sv_derived_from(ST(i+3), "Imager::Color")) {
3744 IV tmp = SvIV((SV *)SvRV(ST(i+3)));
3745 work[i] = *INT2PTR(i_color *, tmp);
3746 }
3747 else {
3748 myfree(work);
3749 croak("i_plin: pixels must be Imager::Color objects");
3750 }
faa9b3e7 3751 }
ca4d914e
TC		 3752 RETVAL = i_plin(im, l, l+items-3, y, work);
3753 myfree(work);
faa9b3e7 3754 }
faa9b3e7
TC		 3755 }
3756 else {
3757 RETVAL = 0;
3758 }
3759 OUTPUT:
3760 RETVAL
3761
3762int
3763i_ppixf(im, x, y, cl)
3764 Imager::ImgRaw im
8d14daab
TC		 3765 i_img_dim x
3766 i_img_dim y
faa9b3e7
TC		 3767 Imager::Color::Float cl
3768
3769void
6a9807e8 3770i_gsampf(im, l, r, y, channels)
faa9b3e7 3771 Imager::ImgRaw im
8d14daab
TC		 3772 i_img_dim l
3773 i_img_dim r
3774 i_img_dim y
6a9807e8 3775 i_channel_list channels
faa9b3e7 3776 PREINIT:
faa9b3e7 3777 i_fsample_t *data;
8d14daab 3778 i_img_dim count, i;
faa9b3e7 3779 PPCODE:
faa9b3e7 3780 if (l < r) {
6a9807e8
TC		 3781 data = mymalloc(sizeof(i_fsample_t) * (r-l) * channels.count);
3782 count = i_gsampf(im, l, r, y, data, channels.channels, channels.count);
faa9b3e7
TC		 3783 if (GIMME_V == G_ARRAY) {
3784 EXTEND(SP, count);
3785 for (i = 0; i < count; ++i)
3786 PUSHs(sv_2mortal(newSVnv(data[i])));
3787 }
3788 else {
3789 EXTEND(SP, 1);
3790 PUSHs(sv_2mortal(newSVpv((void *)data, count * sizeof(i_fsample_t))));
3791 }
3631271b 3792 myfree(data);
faa9b3e7
TC		 3793 }
3794 else {
3795 if (GIMME_V != G_ARRAY) {
5736f588 3796 XSRETURN_UNDEF;
faa9b3e7
TC		 3797 }
3798 }
3799
3800int
3801i_plinf(im, l, y, ...)
3802 Imager::ImgRaw im
8d14daab
TC		 3803 i_img_dim l
3804 i_img_dim y
faa9b3e7
TC		 3805 PREINIT:
3806 i_fcolor *work;
8d14daab 3807 i_img_dim i;
ca4d914e 3808 STRLEN len;
8d14daab 3809 size_t count;
faa9b3e7
TC		 3810 CODE:
3811 if (items > 3) {
ca4d914e
TC		 3812 if (items == 4 && SvOK(ST(3)) && !SvROK(ST(3))) {
3813 /* supplied as a byte string */
3814 work = (i_fcolor *)SvPV(ST(3), len);
3815 count = len / sizeof(i_fcolor);
3816 if (count * sizeof(i_fcolor) != len) {
3817 croak("i_plin: length of scalar argument must be multiple of sizeof i_fcolor");
faa9b3e7 3818 }
ca4d914e
TC		 3819 RETVAL = i_plinf(im, l, l+count, y, work);
3820 }
3821 else {
3822 work = mymalloc(sizeof(i_fcolor) * (items-3));
3823 for (i=0; i < items-3; ++i) {
3824 if (sv_isobject(ST(i+3))
3825 && sv_derived_from(ST(i+3), "Imager::Color::Float")) {
3826 IV tmp = SvIV((SV *)SvRV(ST(i+3)));
3827 work[i] = *INT2PTR(i_fcolor *, tmp);
3828 }
3829 else {
3830 myfree(work);
3831 croak("i_plinf: pixels must be Imager::Color::Float objects");
3832 }
faa9b3e7 3833 }
ca4d914e
TC		 3834 /**(char *)0 = 1;*/
3835 RETVAL = i_plinf(im, l, l+items-3, y, work);
3836 myfree(work);
faa9b3e7 3837 }
faa9b3e7
TC		 3838 }
3839 else {
3840 RETVAL = 0;
3841 }
3842 OUTPUT:
3843 RETVAL
3844
73d80423 3845Imager::Color::Float
faa9b3e7
TC		 3846i_gpixf(im, x, y)
3847 Imager::ImgRaw im
8d14daab
TC		 3848 i_img_dim x
3849 i_img_dim y;
faa9b3e7 3850 CODE:
73d80423 3851 RETVAL = (i_fcolor *)mymalloc(sizeof(i_fcolor));
2ea4aa42 3852 memset(RETVAL, 0, sizeof(*RETVAL));
73d80423
TC		 3853 if (i_gpixf(im, x, y, RETVAL) != 0) {
3854 myfree(RETVAL);
3855 XSRETURN_UNDEF;
faa9b3e7 3856 }
a659442a
TC		 3857 OUTPUT:
3858 RETVAL
3859
faa9b3e7
TC		 3860void
3861i_glin(im, l, r, y)
3862 Imager::ImgRaw im
8d14daab
TC		 3863 i_img_dim l
3864 i_img_dim r
3865 i_img_dim y
faa9b3e7
TC		 3866 PREINIT:
3867 i_color *vals;
8d14daab 3868 i_img_dim count, i;
faa9b3e7
TC		 3869 PPCODE:
3870 if (l < r) {
3871 vals = mymalloc((r-l) * sizeof(i_color));
b3aa972f 3872 memset(vals, 0, (r-l) * sizeof(i_color));
faa9b3e7 3873 count = i_glin(im, l, r, y, vals);
ca4d914e
TC		 3874 if (GIMME_V == G_ARRAY) {
3875 EXTEND(SP, count);
3876 for (i = 0; i < count; ++i) {
5e9a7fbd 3877 SV *sv = make_i_color_sv(aTHX_ vals+i);
ca4d914e
TC		 3878 PUSHs(sv);
3879 }
3880 }
3881 else if (count) {
3882 EXTEND(SP, 1);
3883 PUSHs(sv_2mortal(newSVpv((void *)vals, count * sizeof(i_color))));
faa9b3e7
TC		 3884 }
3885 myfree(vals);
3886 }
3887
3888void
3889i_glinf(im, l, r, y)
3890 Imager::ImgRaw im
8d14daab
TC		 3891 i_img_dim l
3892 i_img_dim r
3893 i_img_dim y
faa9b3e7
TC		 3894 PREINIT:
3895 i_fcolor *vals;
8d14daab 3896 i_img_dim count, i;
919e0000 3897 i_fcolor zero;
faa9b3e7 3898 PPCODE:
919e0000
TC		 3899 for (i = 0; i < MAXCHANNELS; ++i)
3900 zero.channel[i] = 0;
faa9b3e7
TC		 3901 if (l < r) {
3902 vals = mymalloc((r-l) * sizeof(i_fcolor));
b3aa972f
TC		 3903 for (i = 0; i < r-l; ++i)
3904 vals[i] = zero;
faa9b3e7 3905 count = i_glinf(im, l, r, y, vals);
ca4d914e
TC		 3906 if (GIMME_V == G_ARRAY) {
3907 EXTEND(SP, count);
3908 for (i = 0; i < count; ++i) {
3909 SV *sv;
3910 i_fcolor *col = mymalloc(sizeof(i_fcolor));
3911 *col = vals[i];
3912 sv = sv_newmortal();
3913 sv_setref_pv(sv, "Imager::Color::Float", (void *)col);
3914 PUSHs(sv);
3915 }
3916 }
3917 else if (count) {
3918 EXTEND(SP, 1);
3919 PUSHs(sv_2mortal(newSVpv((void *)vals, count * sizeof(i_fcolor))));
faa9b3e7
TC		 3920 }
3921 myfree(vals);
3922 }
3923
bdd4c63b 3924Imager::ImgRaw
5824f4c2
TC		 3925i_img_8_new(xsize, ysize, channels)
3926 i_img_dim xsize
3927 i_img_dim ysize
3928 int channels
bdd4c63b 3929
faa9b3e7 3930Imager::ImgRaw
5824f4c2
TC		 3931i_img_16_new(xsize, ysize, channels)
3932 i_img_dim xsize
3933 i_img_dim ysize
3934 int channels
faa9b3e7 3935
167660cd
TC		 3936Imager::ImgRaw
3937i_img_to_rgb16(im)
3938 Imager::ImgRaw im
3939
365ea842 3940Imager::ImgRaw
5824f4c2
TC		 3941i_img_double_new(xsize, ysize, channels)
3942 i_img_dim xsize
3943 i_img_dim ysize
3944 int channels
365ea842 3945
bfe6ba3f
TC		 3946Imager::ImgRaw
3947i_img_to_drgb(im)
3948 Imager::ImgRaw im
3949
faa9b3e7 3950undef_int
b9e2571f 3951i_tags_addn(im, name_sv, code, idata)
faa9b3e7 3952 Imager::ImgRaw im
b9e2571f 3953 SV *name_sv
faa9b3e7
TC		 3954 int code
3955 int idata
3956 PREINIT:
3957 char *name;
3958 STRLEN len;
3959 CODE:
b9e2571f
TC		 3960 SvGETMAGIC(name_sv);
3961 if (SvOK(name_sv))
3962 name = SvPV_nomg(name_sv, len);
faa9b3e7
TC		 3963 else
3964 name = NULL;
3965 RETVAL = i_tags_addn(&im->tags, name, code, idata);
3966 OUTPUT:
3967 RETVAL
3968
3969undef_int
a4da28d7 3970i_tags_add(im, name_sv, code, data_sv, idata)
faa9b3e7 3971 Imager::ImgRaw im
a4da28d7 3972 SV *name_sv
faa9b3e7 3973 int code
a4da28d7 3974 SV *data_sv
faa9b3e7
TC		 3975 int idata
3976 PREINIT:
3977 char *name;
3978 char *data;
3979 STRLEN len;
3980 CODE:
a4da28d7
TC		 3981 SvGETMAGIC(name_sv);
3982 if (SvOK(name_sv))
3983 name = SvPV_nomg(name_sv, len);
faa9b3e7
TC		 3984 else
3985 name = NULL;
a4da28d7
TC		 3986 SvGETMAGIC(data_sv);
3987 if (SvOK(data_sv))
3988 data = SvPV(data_sv, len);
faa9b3e7
TC		 3989 else {
3990 data = NULL;
3991 len = 0;
3992 }
3993 RETVAL = i_tags_add(&im->tags, name, code, data, len, idata);
3994 OUTPUT:
3995 RETVAL
3996
f4aca831 3997SysRet
faa9b3e7
TC		 3998i_tags_find(im, name, start)
3999 Imager::ImgRaw im
4000 char *name
4001 int start
4002 PREINIT:
4003 int entry;
4004 CODE:
4005 if (i_tags_find(&im->tags, name, start, &entry)) {
f4aca831 4006 RETVAL = entry;
faa9b3e7 4007 } else {
f4aca831 4008 XSRETURN_UNDEF;
faa9b3e7 4009 }
a659442a
TC		 4010 OUTPUT:
4011 RETVAL
faa9b3e7 4012
f4aca831 4013SysRet
faa9b3e7
TC		 4014i_tags_findn(im, code, start)
4015 Imager::ImgRaw im
4016 int code
4017 int start
4018 PREINIT:
4019 int entry;
4020 CODE:
4021 if (i_tags_findn(&im->tags, code, start, &entry)) {
f4aca831 4022 RETVAL = entry;
faa9b3e7 4023 }
a659442a 4024 else {
f4aca831 4025 XSRETURN_UNDEF;
a659442a
TC		 4026 }
4027 OUTPUT:
4028 RETVAL
faa9b3e7
TC		 4029
4030int
4031i_tags_delete(im, entry)
4032 Imager::ImgRaw im
4033 int entry
4034 CODE:
4035 RETVAL = i_tags_delete(&im->tags, entry);
4036 OUTPUT:
4037 RETVAL
4038
4039int
4040i_tags_delbyname(im, name)
4041 Imager::ImgRaw im
4042 char * name
4043 CODE:
4044 RETVAL = i_tags_delbyname(&im->tags, name);
4045 OUTPUT:
4046 RETVAL
4047
4048int
4049i_tags_delbycode(im, code)
4050 Imager::ImgRaw im
4051 int code
4052 CODE:
4053 RETVAL = i_tags_delbycode(&im->tags, code);
4054 OUTPUT:
4055 RETVAL
4056
4057void
4058i_tags_get(im, index)
4059 Imager::ImgRaw im
4060 int index
4061 PPCODE:
4062 if (index >= 0 && index < im->tags.count) {
4063 i_img_tag *entry = im->tags.tags + index;
4064 EXTEND(SP, 5);
4065
4066 if (entry->name) {
4067 PUSHs(sv_2mortal(newSVpv(entry->name, 0)));
4068 }
4069 else {
4070 PUSHs(sv_2mortal(newSViv(entry->code)));
4071 }
4072 if (entry->data) {
4073 PUSHs(sv_2mortal(newSVpvn(entry->data, entry->size)));
4074 }
4075 else {
4076 PUSHs(sv_2mortal(newSViv(entry->idata)));
4077 }
4078 }
4079
241defe8
TC		 4080void
4081i_tags_get_string(im, what_sv)
4082 Imager::ImgRaw im
4083 SV *what_sv
4084 PREINIT:
4085 char const *name = NULL;
4086 int code;
4087 char buffer[200];
241defe8
TC		 4088 PPCODE:
4089 if (SvIOK(what_sv)) {
4090 code = SvIV(what_sv);
4091 name = NULL;
4092 }
4093 else {
4094 name = SvPV_nolen(what_sv);
4095 code = 0;
4096 }
4097 if (i_tags_get_string(&im->tags, name, code, buffer, sizeof(buffer))) {
4098 EXTEND(SP, 1);
4099 PUSHs(sv_2mortal(newSVpv(buffer, 0)));
4100 }
4101
faa9b3e7
TC		 4102int
4103i_tags_count(im)
4104 Imager::ImgRaw im
4105 CODE:
4106 RETVAL = im->tags.count;
4107 OUTPUT:
4108 RETVAL
4109
faa9b3e7 4110
faa9b3e7 4111
f1ac5027
TC		 4112MODULE = Imager PACKAGE = Imager::FillHandle PREFIX=IFILL_
4113
4114void
4115IFILL_DESTROY(fill)
4116 Imager::FillHandle fill
4117
ffddd407
TC		 4118int
4119IFILL_CLONE_SKIP(...)
4120 CODE:
8d14daab 4121 (void)items; /* avoid unused warning for XS variable */
ffddd407
TC		 4122 RETVAL = 1;
4123 OUTPUT:
4124 RETVAL
4125
f1ac5027
TC		 4126MODULE = Imager PACKAGE = Imager
4127
4128Imager::FillHandle
4129i_new_fill_solid(cl, combine)
4130 Imager::Color cl
4131 int combine
4132
4133Imager::FillHandle
4134i_new_fill_solidf(cl, combine)
4135 Imager::Color::Float cl
4136 int combine
4137
4138Imager::FillHandle
a309fbc6 4139i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch_sv, dx, dy)
f1ac5027
TC		 4140 Imager::Color fg
4141 Imager::Color bg
4142 int combine
4143 int hatch
a309fbc6 4144 SV *cust_hatch_sv
8d14daab
TC		 4145 i_img_dim dx
4146 i_img_dim dy
f1ac5027
TC		 4147 PREINIT:
4148 unsigned char *cust_hatch;
4149 STRLEN len;
4150 CODE:
a309fbc6
TC		 4151 SvGETMAGIC(cust_hatch_sv);
4152 if (SvOK(cust_hatch_sv)) {
4153 cust_hatch = (unsigned char *)SvPV_nomg(cust_hatch_sv, len);
f1ac5027
TC		 4154 }
4155 else
4156 cust_hatch = NULL;
4157 RETVAL = i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy);
4158 OUTPUT:
4159 RETVAL
4160
efdc2568 4161Imager::FillHandle
a309fbc6 4162i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch_sv, dx, dy)
efdc2568
TC		 4163 Imager::Color::Float fg
4164 Imager::Color::Float bg
4165 int combine
4166 int hatch
a309fbc6 4167 SV *cust_hatch_sv
8d14daab
TC		 4168 i_img_dim dx
4169 i_img_dim dy
efdc2568
TC		 4170 PREINIT:
4171 unsigned char *cust_hatch;
4172 STRLEN len;
4173 CODE:
a309fbc6
TC		 4174 SvGETMAGIC(cust_hatch_sv);
4175 if (SvOK(cust_hatch_sv)) {
4176 cust_hatch = (unsigned char *)SvPV(cust_hatch_sv, len);
efdc2568
TC		 4177 }
4178 else
4179 cust_hatch = NULL;
4180 RETVAL = i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy);
4181 OUTPUT:
4182 RETVAL
4183
f576ce7e 4184Imager::FillHandle
c0f38779 4185i_new_fill_image(src, matrix_sv, xoff, yoff, combine)
f576ce7e 4186 Imager::ImgRaw src
c0f38779 4187 SV *matrix_sv
8d14daab
TC		 4188 i_img_dim xoff
4189 i_img_dim yoff
f576ce7e
TC		 4190 int combine
4191 PREINIT:
4192 double matrix[9];
4193 double *matrixp;
4194 AV *av;
4195 IV len;
4196 SV *sv1;
4197 int i;
4198 CODE:
c0f38779
TC		 4199 SvGETMAGIC(matrix_sv);
4200 if (!SvOK(matrix_sv)) {
f576ce7e
TC		 4201 matrixp = NULL;
4202 }
4203 else {
c0f38779
TC		 4204 if (!SvROK(matrix_sv) || SvTYPE(SvRV(matrix_sv)) != SVt_PVAV)
4205 croak("i_new_fill_image: matrix parameter must be an arrayref or undef");
4206 av=(AV*)SvRV(matrix_sv);
f576ce7e
TC		 4207 len=av_len(av)+1;
4208 if (len > 9)
4209 len = 9;
4210 for (i = 0; i < len; ++i) {
4211 sv1=(*(av_fetch(av,i,0)));
4212 matrix[i] = SvNV(sv1);
4213 }
4214 for (; i < 9; ++i)
4215 matrix[i] = 0;
4216 matrixp = matrix;
4217 }
4218 RETVAL = i_new_fill_image(src, matrixp, xoff, yoff, combine);
4219 OUTPUT:
4220 RETVAL
042cdaea 4221
a8652edf
TC		 4222MODULE = Imager PACKAGE = Imager::Internal::Hlines PREFIX=i_int_hlines_
4223
4224# this class is only exposed for testing
4225
4226int
4227i_int_hlines_testing()
4228
4229#if i_int_hlines_testing()
4230
4231Imager::Internal::Hlines
4232i_int_hlines_new(start_y, count_y, start_x, count_x)
8d14daab 4233 i_img_dim start_y
a8652edf 4234 int count_y
8d14daab 4235 i_img_dim start_x
a8652edf
TC		 4236 int count_x
4237
4238Imager::Internal::Hlines
4239i_int_hlines_new_img(im)
4240 Imager::ImgRaw im
4241
4242void
4243i_int_hlines_add(hlines, y, minx, width)
4244 Imager::Internal::Hlines hlines
8d14daab
TC		 4245 i_img_dim y
4246 i_img_dim minx
4247 i_img_dim width
a8652edf
TC		 4248
4249void
4250i_int_hlines_DESTROY(hlines)
4251 Imager::Internal::Hlines hlines
4252
4253SV *
4254i_int_hlines_dump(hlines)
4255 Imager::Internal::Hlines hlines
4256
ffddd407
TC		 4257int
4258i_int_hlines_CLONE_SKIP(cls)
ffddd407 4259
a8652edf 4260#endif
92bda632 4261
31a13473
TC		 4262MODULE = Imager PACKAGE = Imager::Context PREFIX=im_context_
4263
4264void
4265im_context_DESTROY(ctx)
4266 Imager::Context ctx
4267
4268#ifdef PERL_IMPLICIT_CONTEXT
4269
4270void
4271im_context_CLONE(...)
4272 CODE:
4273 MY_CXT_CLONE;
39512ead 4274 (void)items;
31a13473
TC		 4275 /* the following sv_setref_pv() will free this inc */
4276 im_context_refinc(MY_CXT.ctx, "CLONE");
4277 MY_CXT.ctx = im_context_clone(MY_CXT.ctx, "CLONE");
9ca939d0
TC		 4278 if (MY_CXT.ctx == NULL) {
4279 croak("Failed to clone Imager context");
4280 }
31a13473
TC		 4281 sv_setref_pv(get_sv("Imager::_context", GV_ADD), "Imager::Context", MY_CXT.ctx);
4282
4283#endif
4284
92bda632
TC		 4285BOOT:
4286 PERL_SET_GLOBAL_CALLBACKS;
6d5c85a2 4287 PERL_PL_SET_GLOBAL_CALLBACKS;
39512ead 4288#ifdef PERL_IMPLICIT_CONTEXT
54064d2e
TC		 4289 {
4290 MY_CXT_INIT;
4291 (void)MY_CXT;
4292 }
39512ead 4293#endif
31a13473 4294 start_context(aTHX);
cf8c77ae 4295 im_get_context = perl_get_context;
eee347a1
TC		 4296#ifdef HAVE_LIBTT
4297 i_tt_start();
4298#endif
Image manipulation for perl