Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

3999 lines (3544 sloc) 95.481 kB
#define PERL_NO_GET_CONTEXT
#ifdef __cplusplus
extern "C" {
#endif
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#define NEED_newRV_noinc
#define NEED_sv_2pv_nolen
#define NEED_sv_2pvbyte
#include "ppport.h"
#ifdef __cplusplus
}
#endif
#define i_int_hlines_testing() 1
#include "imager.h"
#include "feat.h"
#include "dynaload.h"
#include "regmach.h"
#include "imextdef.h"
#include "imextpltypes.h"
#include <float.h>
#if i_int_hlines_testing()
#include "imageri.h"
#endif
#include "imperl.h"
/* used to represent channel lists parameters */
typedef struct i_channel_list_tag {
int *channels;
int count;
} i_channel_list;
typedef struct {
size_t count;
const i_sample_t *samples;
} i_sample_list;
typedef struct {
size_t count;
const i_fsample_t *samples;
} i_fsample_list;
/*
Allocate memory that will be discarded when mortals are discarded.
*/
static void *
malloc_temp(pTHX_ size_t size) {
SV *sv = sv_2mortal(newSV(size));
return SvPVX(sv);
}
/* These functions are all shared - then comes platform dependant code */
static int getstr(void *hv_t,char *key,char **store) {
dTHX;
SV** svpp;
HV* hv=(HV*)hv_t;
mm_log((1,"getstr(hv_t %p, key %s, store %p)\n",hv_t,key,store));
if ( !hv_exists(hv,key,strlen(key)) ) return 0;
svpp=hv_fetch(hv, key, strlen(key), 0);
*store=SvPV(*svpp, PL_na );
return 1;
}
static int getint(void *hv_t,char *key,int *store) {
dTHX;
SV** svpp;
HV* hv=(HV*)hv_t;
mm_log((1,"getint(hv_t %p, key %s, store %p)\n",hv_t,key,store));
if ( !hv_exists(hv,key,strlen(key)) ) return 0;
svpp=hv_fetch(hv, key, strlen(key), 0);
*store=(int)SvIV(*svpp);
return 1;
}
static int getdouble(void *hv_t,char* key,double *store) {
dTHX;
SV** svpp;
HV* hv=(HV*)hv_t;
mm_log((1,"getdouble(hv_t %p, key %s, store %p)\n",hv_t,key,store));
if ( !hv_exists(hv,key,strlen(key)) ) return 0;
svpp=hv_fetch(hv, key, strlen(key), 0);
*store=(double)SvNV(*svpp);
return 1;
}
static int getvoid(void *hv_t,char* key,void **store) {
dTHX;
SV** svpp;
HV* hv=(HV*)hv_t;
mm_log((1,"getvoid(hv_t %p, key %s, store %p)\n",hv_t,key,store));
if ( !hv_exists(hv,key,strlen(key)) ) return 0;
svpp=hv_fetch(hv, key, strlen(key), 0);
*store = INT2PTR(void*, SvIV(*svpp));
return 1;
}
static int getobj(void *hv_t,char *key,char *type,void **store) {
dTHX;
SV** svpp;
HV* hv=(HV*)hv_t;
mm_log((1,"getobj(hv_t %p, key %s,type %s, store %p)\n",hv_t,key,type,store));
if ( !hv_exists(hv,key,strlen(key)) ) return 0;
svpp=hv_fetch(hv, key, strlen(key), 0);
if (sv_derived_from(*svpp,type)) {
IV tmp = SvIV((SV*)SvRV(*svpp));
*store = INT2PTR(void*, tmp);
} else {
mm_log((1,"getobj: key exists in hash but is not of correct type"));
return 0;
}
return 1;
}
UTIL_table_t i_UTIL_table={getstr,getint,getdouble,getvoid,getobj};
void my_SvREFCNT_dec(void *p) {
dTHX;
SvREFCNT_dec((SV*)p);
}
static void
i_log_entry(char *string, int level) {
mm_log((level, "%s", string));
}
static SV *
make_i_color_sv(pTHX_ const i_color *c) {
SV *sv;
i_color *col = mymalloc(sizeof(i_color));
*col = *c;
sv = sv_newmortal();
sv_setref_pv(sv, "Imager::Color", (void *)col);
return sv;
}
#define CBDATA_BUFSIZE 8192
struct cbdata {
/* the SVs we use to call back to Perl */
SV *writecb;
SV *readcb;
SV *seekcb;
SV *closecb;
};
static ssize_t
call_reader(struct cbdata *cbd, void *buf, size_t size,
size_t maxread) {
dTHX;
int count;
int result;
SV *data;
dSP;
if (!SvOK(cbd->readcb)) {
mm_log((1, "read callback called but no readcb supplied\n"));
i_push_error(0, "read callback called but no readcb supplied");
return -1;
}
ENTER;
SAVETMPS;
EXTEND(SP, 2);
PUSHMARK(SP);
PUSHs(sv_2mortal(newSViv(size)));
PUSHs(sv_2mortal(newSViv(maxread)));
PUTBACK;
count = perl_call_sv(cbd->readcb, G_SCALAR);
SPAGAIN;
if (count != 1)
croak("Result of perl_call_sv(..., G_SCALAR) != 1");
data = POPs;
if (SvOK(data)) {
STRLEN len;
char *ptr = SvPVbyte(data, len);
if (len > maxread)
croak("Too much data returned in reader callback (wanted %d, got %d, expected %d)",
(int)size, (int)len, (int)maxread);
memcpy(buf, ptr, len);
result = len;
}
else {
result = -1;
}
PUTBACK;
FREETMPS;
LEAVE;
return result;
}
static off_t
io_seeker(void *p, off_t offset, int whence) {
dTHX;
struct cbdata *cbd = p;
int count;
off_t result;
dSP;
if (!SvOK(cbd->seekcb)) {
mm_log((1, "seek callback called but no seekcb supplied\n"));
i_push_error(0, "seek callback called but no seekcb supplied");
return -1;
}
ENTER;
SAVETMPS;
EXTEND(SP, 2);
PUSHMARK(SP);
PUSHs(sv_2mortal(newSViv(offset)));
PUSHs(sv_2mortal(newSViv(whence)));
PUTBACK;
count = perl_call_sv(cbd->seekcb, G_SCALAR);
SPAGAIN;
if (count != 1)
croak("Result of perl_call_sv(..., G_SCALAR) != 1");
result = POPi;
PUTBACK;
FREETMPS;
LEAVE;
return result;
}
static ssize_t
io_writer(void *p, void const *data, size_t size) {
dTHX;
struct cbdata *cbd = p;
I32 count;
SV *sv;
dSP;
bool success;
if (!SvOK(cbd->writecb)) {
mm_log((1, "write callback called but no writecb supplied\n"));
i_push_error(0, "write callback called but no writecb supplied");
return -1;
}
ENTER;
SAVETMPS;
EXTEND(SP, 1);
PUSHMARK(SP);
PUSHs(sv_2mortal(newSVpv((char *)data, size)));
PUTBACK;
count = perl_call_sv(cbd->writecb, G_SCALAR);
SPAGAIN;
if (count != 1)
croak("Result of perl_call_sv(..., G_SCALAR) != 1");
sv = POPs;
success = SvTRUE(sv);
PUTBACK;
FREETMPS;
LEAVE;
return success ? size : -1;
}
static ssize_t
io_reader(void *p, void *data, size_t size) {
struct cbdata *cbd = p;
return call_reader(cbd, data, size, size);
}
static int io_closer(void *p) {
dTHX;
struct cbdata *cbd = p;
int success = 1;
if (SvOK(cbd->closecb)) {
dSP;
I32 count;
SV *sv;
ENTER;
SAVETMPS;
PUSHMARK(SP);
PUTBACK;
count = perl_call_sv(cbd->closecb, G_SCALAR);
SPAGAIN;
sv = POPs;
success = SvTRUE(sv);
PUTBACK;
FREETMPS;
LEAVE;
}
return success ? 0 : -1;
}
static void io_destroyer(void *p) {
dTHX;
struct cbdata *cbd = p;
SvREFCNT_dec(cbd->writecb);
SvREFCNT_dec(cbd->readcb);
SvREFCNT_dec(cbd->seekcb);
SvREFCNT_dec(cbd->closecb);
myfree(cbd);
}
static i_io_glue_t *
do_io_new_buffer(pTHX_ SV *data_sv) {
const char *data;
STRLEN length;
data = SvPVbyte(data_sv, length);
SvREFCNT_inc(data_sv);
return io_new_buffer(data, length, my_SvREFCNT_dec, data_sv);
}
static const char *
describe_sv(SV *sv) {
if (SvOK(sv)) {
if (SvROK(sv)) {
svtype type = SvTYPE(SvRV(sv));
switch (type) {
case SVt_PVCV: return "CV";
case SVt_PVGV: return "GV";
case SVt_PVLV: return "LV";
default: return "some reference";
}
}
else {
return "non-reference scalar";
}
}
else {
return "undef";
}
}
static i_io_glue_t *
do_io_new_cb(pTHX_ SV *writecb, SV *readcb, SV *seekcb, SV *closecb) {
struct cbdata *cbd;
cbd = mymalloc(sizeof(struct cbdata));
cbd->writecb = newSVsv(writecb);
cbd->readcb = newSVsv(readcb);
cbd->seekcb = newSVsv(seekcb);
cbd->closecb = newSVsv(closecb);
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)));
return io_new_cb(cbd, io_reader, io_writer, io_seeker, io_closer,
io_destroyer);
}
struct value_name {
char *name;
int value;
};
static int lookup_name(struct value_name *names, int count, char *name, int def_value)
{
int i;
for (i = 0; i < count; ++i)
if (strEQ(names[i].name, name))
return names[i].value;
return def_value;
}
static struct value_name transp_names[] =
{
{ "none", tr_none },
{ "threshold", tr_threshold },
{ "errdiff", tr_errdiff },
{ "ordered", tr_ordered, },
};
static struct value_name make_color_names[] =
{
{ "none", mc_none, },
{ "webmap", mc_web_map, },
{ "addi", mc_addi, },
{ "mediancut", mc_median_cut, },
{ "mono", mc_mono, },
{ "monochrome", mc_mono, },
{ "gray", mc_gray, },
{ "gray4", mc_gray4, },
{ "gray16", mc_gray16, },
};
static struct value_name translate_names[] =
{
{ "giflib", pt_giflib, },
{ "closest", pt_closest, },
{ "perturb", pt_perturb, },
{ "errdiff", pt_errdiff, },
};
static struct value_name errdiff_names[] =
{
{ "floyd", ed_floyd, },
{ "jarvis", ed_jarvis, },
{ "stucki", ed_stucki, },
{ "custom", ed_custom, },
};
static struct value_name orddith_names[] =
{
{ "random", od_random, },
{ "dot8", od_dot8, },
{ "dot4", od_dot4, },
{ "hline", od_hline, },
{ "vline", od_vline, },
{ "/line", od_slashline, },
{ "slashline", od_slashline, },
{ "\\line", od_backline, },
{ "backline", od_backline, },
{ "tiny", od_tiny, },
{ "custom", od_custom, },
};
/* look through the hash for quantization options */
static void
ip_handle_quant_opts(pTHX_ i_quantize *quant, HV *hv)
{
/*** POSSIBLY BROKEN: do I need to unref the SV from hv_fetch ***/
SV **sv;
int i;
STRLEN len;
char *str;
quant->mc_colors = mymalloc(quant->mc_size * sizeof(i_color));
sv = hv_fetch(hv, "transp", 6, 0);
if (sv && *sv && (str = SvPV(*sv, len))) {
quant->transp =
lookup_name(transp_names, sizeof(transp_names)/sizeof(*transp_names),
str, tr_none);
if (quant->transp != tr_none) {
quant->tr_threshold = 127;
sv = hv_fetch(hv, "tr_threshold", 12, 0);
if (sv && *sv)
quant->tr_threshold = SvIV(*sv);
}
if (quant->transp == tr_errdiff) {
sv = hv_fetch(hv, "tr_errdiff", 10, 0);
if (sv && *sv && (str = SvPV(*sv, len)))
quant->tr_errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
}
if (quant->transp == tr_ordered) {
quant->tr_orddith = od_tiny;
sv = hv_fetch(hv, "tr_orddith", 10, 0);
if (sv && *sv && (str = SvPV(*sv, len)))
quant->tr_orddith = lookup_name(orddith_names, sizeof(orddith_names)/sizeof(*orddith_names), str, od_random);
if (quant->tr_orddith == od_custom) {
sv = hv_fetch(hv, "tr_map", 6, 0);
if (sv && *sv && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
AV *av = (AV*)SvRV(*sv);
len = av_len(av) + 1;
if (len > sizeof(quant->tr_custom))
len = sizeof(quant->tr_custom);
for (i = 0; i < len; ++i) {
SV **sv2 = av_fetch(av, i, 0);
if (sv2 && *sv2) {
quant->tr_custom[i] = SvIV(*sv2);
}
}
while (i < sizeof(quant->tr_custom))
quant->tr_custom[i++] = 0;
}
}
}
}
quant->make_colors = mc_median_cut;
sv = hv_fetch(hv, "make_colors", 11, 0);
if (sv && *sv && (str = SvPV(*sv, len))) {
quant->make_colors =
lookup_name(make_color_names, sizeof(make_color_names)/sizeof(*make_color_names), str, mc_median_cut);
}
sv = hv_fetch(hv, "colors", 6, 0);
if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
/* needs to be an array of Imager::Color
note that the caller allocates the mc_color array and sets mc_size
to it's size */
AV *av = (AV *)SvRV(*sv);
quant->mc_count = av_len(av)+1;
if (quant->mc_count > quant->mc_size)
quant->mc_count = quant->mc_size;
for (i = 0; i < quant->mc_count; ++i) {
SV **sv1 = av_fetch(av, i, 0);
if (sv1 && *sv1 && SvROK(*sv1) && sv_derived_from(*sv1, "Imager::Color")) {
i_color *col = INT2PTR(i_color *, SvIV((SV*)SvRV(*sv1)));
quant->mc_colors[i] = *col;
}
}
}
sv = hv_fetch(hv, "max_colors", 10, 0);
if (sv && *sv) {
i = SvIV(*sv);
if (i <= quant->mc_size && i >= quant->mc_count)
quant->mc_size = i;
}
quant->translate = pt_closest;
sv = hv_fetch(hv, "translate", 9, 0);
if (sv && *sv && (str = SvPV(*sv, len))) {
quant->translate = lookup_name(translate_names, sizeof(translate_names)/sizeof(*translate_names), str, pt_closest);
}
sv = hv_fetch(hv, "errdiff", 7, 0);
if (sv && *sv && (str = SvPV(*sv, len))) {
quant->errdiff = lookup_name(errdiff_names, sizeof(errdiff_names)/sizeof(*errdiff_names), str, ed_floyd);
}
if (quant->translate == pt_errdiff && quant->errdiff == ed_custom) {
/* get the error diffusion map */
sv = hv_fetch(hv, "errdiff_width", 13, 0);
if (sv && *sv)
quant->ed_width = SvIV(*sv);
sv = hv_fetch(hv, "errdiff_height", 14, 0);
if (sv && *sv)
quant->ed_height = SvIV(*sv);
sv = hv_fetch(hv, "errdiff_orig", 12, 0);
if (sv && *sv)
quant->ed_orig = SvIV(*sv);
if (quant->ed_width > 0 && quant->ed_height > 0) {
int sum = 0;
quant->ed_map = mymalloc(sizeof(int)*quant->ed_width*quant->ed_height);
sv = hv_fetch(hv, "errdiff_map", 11, 0);
if (sv && *sv && SvROK(*sv) && SvTYPE(SvRV(*sv)) == SVt_PVAV) {
AV *av = (AV*)SvRV(*sv);
len = av_len(av) + 1;
if (len > quant->ed_width * quant->ed_height)
len = quant->ed_width * quant->ed_height;
for (i = 0; i < len; ++i) {
SV **sv2 = av_fetch(av, i, 0);
if (sv2 && *sv2) {
quant->ed_map[i] = SvIV(*sv2);
sum += quant->ed_map[i];
}
}
}
if (!sum) {
/* broken map */
myfree(quant->ed_map);
quant->ed_map = 0;
quant->errdiff = ed_floyd;
}
}
}
sv = hv_fetch(hv, "perturb", 7, 0);
if (sv && *sv)
quant->perturb = SvIV(*sv);
}
static void
ip_cleanup_quant_opts(pTHX_ i_quantize *quant) {
myfree(quant->mc_colors);
if (quant->ed_map)
myfree(quant->ed_map);
}
/* copies the color map from the hv into the colors member of the HV */
static void
ip_copy_colors_back(pTHX_ HV *hv, i_quantize *quant) {
SV **sv;
AV *av;
int i;
SV *work;
sv = hv_fetch(hv, "colors", 6, 0);
if (!sv || !*sv || !SvROK(*sv) || SvTYPE(SvRV(*sv)) != SVt_PVAV) {
/* nothing to do */
return;
}
av = (AV *)SvRV(*sv);
av_clear(av);
av_extend(av, quant->mc_count+1);
for (i = 0; i < quant->mc_count; ++i) {
i_color *in = quant->mc_colors+i;
Imager__Color c = ICL_new_internal(in->rgb.r, in->rgb.g, in->rgb.b, 255);
work = sv_newmortal();
sv_setref_pv(work, "Imager::Color", (void *)c);
SvREFCNT_inc(work);
av_push(av, work);
}
}
/* loads the segments of a fountain fill into an array */
static i_fountain_seg *
load_fount_segs(pTHX_ AV *asegs, int *count) {
/* Each element of segs must contain:
[ start, middle, end, c0, c1, segtype, colortrans ]
start, middle, end are doubles from 0 to 1
c0, c1 are Imager::Color::Float or Imager::Color objects
segtype, colortrans are ints
*/
int i, j;
AV *aseg;
i_fountain_seg *segs;
double work[3];
int worki[2];
*count = av_len(asegs)+1;
if (*count < 1)
croak("i_fountain must have at least one segment");
segs = mymalloc(sizeof(i_fountain_seg) * *count);
for(i = 0; i < *count; i++) {
SV **sv1 = av_fetch(asegs, i, 0);
if (!sv1 || !*sv1 || !SvROK(*sv1)
|| SvTYPE(SvRV(*sv1)) != SVt_PVAV) {
myfree(segs);
croak("i_fountain: segs must be an arrayref of arrayrefs");
}
aseg = (AV *)SvRV(*sv1);
if (av_len(aseg) != 7-1) {
myfree(segs);
croak("i_fountain: a segment must have 7 members");
}
for (j = 0; j < 3; ++j) {
SV **sv2 = av_fetch(aseg, j, 0);
if (!sv2 || !*sv2) {
myfree(segs);
croak("i_fountain: XS error");
}
work[j] = SvNV(*sv2);
}
segs[i].start = work[0];
segs[i].middle = work[1];
segs[i].end = work[2];
for (j = 0; j < 2; ++j) {
SV **sv3 = av_fetch(aseg, 3+j, 0);
if (!sv3 || !*sv3 || !SvROK(*sv3) ||
(!sv_derived_from(*sv3, "Imager::Color")
&& !sv_derived_from(*sv3, "Imager::Color::Float"))) {
myfree(segs);
croak("i_fountain: segs must contain colors in elements 3 and 4");
}
if (sv_derived_from(*sv3, "Imager::Color::Float")) {
segs[i].c[j] = *INT2PTR(i_fcolor *, SvIV((SV *)SvRV(*sv3)));
}
else {
i_color c = *INT2PTR(i_color *, SvIV((SV *)SvRV(*sv3)));
int ch;
for (ch = 0; ch < MAXCHANNELS; ++ch) {
segs[i].c[j].channel[ch] = c.channel[ch] / 255.0;
}
}
}
for (j = 0; j < 2; ++j) {
SV **sv2 = av_fetch(aseg, j+5, 0);
if (!sv2 || !*sv2) {
myfree(segs);
croak("i_fountain: XS error");
}
worki[j] = SvIV(*sv2);
}
segs[i].type = worki[0];
segs[i].color = worki[1];
}
return segs;
}
/* validates the indexes supplied to i_ppal
i_ppal() doesn't do that for speed, but I'm not comfortable doing that
for calls from perl.
*/
static void
validate_i_ppal(i_img *im, i_palidx const *indexes, int count) {
int color_count = i_colorcount(im);
int i;
if (color_count == -1)
croak("i_plin() called on direct color image");
for (i = 0; i < count; ++i) {
if (indexes[i] >= color_count) {
croak("i_plin() called with out of range color index %d (max %d)",
indexes[i], color_count-1);
}
}
}
/* I don't think ICLF_* names belong at the C interface
this makes the XS code think we have them, to let us avoid
putting function bodies in the XS code
*/
#define ICLF_new_internal(r, g, b, a) i_fcolor_new((r), (g), (b), (a))
#define ICLF_DESTROY(cl) i_fcolor_destroy(cl)
#ifdef IMAGER_LOG
#define i_log_enabled() 1
#else
#define i_log_enabled() 0
#endif
#if i_int_hlines_testing()
typedef i_int_hlines *Imager__Internal__Hlines;
static i_int_hlines *
i_int_hlines_new(i_img_dim start_y, i_img_dim count_y, i_img_dim start_x, i_img_dim count_x) {
i_int_hlines *result = mymalloc(sizeof(i_int_hlines));
i_int_init_hlines(result, start_y, count_y, start_x, count_x);
return result;
}
static i_int_hlines *
i_int_hlines_new_img(i_img *im) {
i_int_hlines *result = mymalloc(sizeof(i_int_hlines));
i_int_init_hlines_img(result, im);
return result;
}
static void
i_int_hlines_DESTROY(i_int_hlines *hlines) {
i_int_hlines_destroy(hlines);
myfree(hlines);
}
#define i_int_hlines_CLONE_SKIP(cls) 1
static int seg_compare(const void *vleft, const void *vright) {
const i_int_hline_seg *left = vleft;
const i_int_hline_seg *right = vright;
return left->minx - right->minx;
}
static SV *
i_int_hlines_dump(i_int_hlines *hlines) {
dTHX;
SV *dump = newSVpvf("start_y: %" i_DF " limit_y: %" i_DF " start_x: %" i_DF " limit_x: %" i_DF"\n",
i_DFc(hlines->start_y), i_DFc(hlines->limit_y), i_DFc(hlines->start_x), i_DFc(hlines->limit_x));
i_img_dim y;
for (y = hlines->start_y; y < hlines->limit_y; ++y) {
i_int_hline_entry *entry = hlines->entries[y-hlines->start_y];
if (entry) {
int i;
/* sort the segments, if any */
if (entry->count)
qsort(entry->segs, entry->count, sizeof(i_int_hline_seg), seg_compare);
sv_catpvf(dump, " %" i_DF " (%" i_DF "):", i_DFc(y), i_DFc(entry->count));
for (i = 0; i < entry->count; ++i) {
sv_catpvf(dump, " [%" i_DF ", %" i_DF ")", i_DFc(entry->segs[i].minx),
i_DFc(entry->segs[i].x_limit));
}
sv_catpv(dump, "\n");
}
}
return dump;
}
#endif
static off_t
i_sv_off_t(pTHX_ SV *sv) {
#if LSEEKSIZE > IVSIZE
return (off_t)SvNV(sv);
#else
return (off_t)SvIV(sv);
#endif
}
static SV *
i_new_sv_off_t(pTHX_ off_t off) {
#if LSEEKSIZE > IVSIZE
return newSVnv(off);
#else
return newSViv(off);
#endif
}
static im_pl_ext_funcs im_perl_funcs =
{
IMAGER_PL_API_VERSION,
IMAGER_PL_API_LEVEL,
ip_handle_quant_opts,
ip_cleanup_quant_opts,
ip_copy_colors_back
};
#define PERL_PL_SET_GLOBAL_CALLBACKS \
sv_setiv(get_sv(PERL_PL_FUNCTION_TABLE_NAME, 1), PTR2IV(&im_perl_funcs));
#define IIM_new i_img_8_new
#define IIM_DESTROY i_img_destroy
#ifdef IMEXIF_ENABLE
#define i_exif_enabled() 1
#else
#define i_exif_enabled() 0
#endif
/* trying to use more C style names, map them here */
#define i_io_DESTROY(ig) io_glue_destroy(ig)
#define i_img_get_width(im) ((im)->xsize)
#define i_img_get_height(im) ((im)->ysize)
#define i_img_epsilonf() (DBL_EPSILON * 4)
/* avoid some xsubpp strangeness */
#define NEWLINE '\n'
MODULE = Imager PACKAGE = Imager::Color PREFIX = ICL_
Imager::Color
ICL_new_internal(r,g,b,a)
unsigned char r
unsigned char g
unsigned char b
unsigned char a
void
ICL_DESTROY(cl)
Imager::Color cl
void
ICL_set_internal(cl,r,g,b,a)
Imager::Color cl
unsigned char r
unsigned char g
unsigned char b
unsigned char a
PPCODE:
ICL_set_internal(cl, r, g, b, a);
EXTEND(SP, 1);
PUSHs(ST(0));
void
ICL_info(cl)
Imager::Color cl
void
ICL_rgba(cl)
Imager::Color cl
PPCODE:
EXTEND(SP, 4);
PUSHs(sv_2mortal(newSVnv(cl->rgba.r)));
PUSHs(sv_2mortal(newSVnv(cl->rgba.g)));
PUSHs(sv_2mortal(newSVnv(cl->rgba.b)));
PUSHs(sv_2mortal(newSVnv(cl->rgba.a)));
Imager::Color
i_hsv_to_rgb(c)
Imager::Color c
CODE:
RETVAL = mymalloc(sizeof(i_color));
*RETVAL = *c;
i_hsv_to_rgb(RETVAL);
OUTPUT:
RETVAL
Imager::Color
i_rgb_to_hsv(c)
Imager::Color c
CODE:
RETVAL = mymalloc(sizeof(i_color));
*RETVAL = *c;
i_rgb_to_hsv(RETVAL);
OUTPUT:
RETVAL
MODULE = Imager PACKAGE = Imager::Color::Float PREFIX=ICLF_
Imager::Color::Float
ICLF_new_internal(r, g, b, a)
double r
double g
double b
double a
void
ICLF_DESTROY(cl)
Imager::Color::Float cl
void
ICLF_rgba(cl)
Imager::Color::Float cl
PREINIT:
int ch;
PPCODE:
EXTEND(SP, MAXCHANNELS);
for (ch = 0; ch < MAXCHANNELS; ++ch) {
/* printf("%d: %g\n", ch, cl->channel[ch]); */
PUSHs(sv_2mortal(newSVnv(cl->channel[ch])));
}
void
ICLF_set_internal(cl,r,g,b,a)
Imager::Color::Float cl
double r
double g
double b
double a
PPCODE:
cl->rgba.r = r;
cl->rgba.g = g;
cl->rgba.b = b;
cl->rgba.a = a;
EXTEND(SP, 1);
PUSHs(ST(0));
Imager::Color::Float
i_hsv_to_rgb(c)
Imager::Color::Float c
CODE:
RETVAL = mymalloc(sizeof(i_fcolor));
*RETVAL = *c;
i_hsv_to_rgbf(RETVAL);
OUTPUT:
RETVAL
Imager::Color::Float
i_rgb_to_hsv(c)
Imager::Color::Float c
CODE:
RETVAL = mymalloc(sizeof(i_fcolor));
*RETVAL = *c;
i_rgb_to_hsvf(RETVAL);
OUTPUT:
RETVAL
MODULE = Imager PACKAGE = Imager::ImgRaw PREFIX = IIM_
Imager::ImgRaw
IIM_new(x,y,ch)
i_img_dim x
i_img_dim y
int ch
void
IIM_DESTROY(im)
Imager::ImgRaw im
MODULE = Imager PACKAGE = Imager
PROTOTYPES: ENABLE
Imager::IO
io_new_fd(fd)
int fd
Imager::IO
io_new_bufchain()
Imager::IO
io_new_buffer(data_sv)
SV *data_sv
CODE:
RETVAL = do_io_new_buffer(aTHX_ data_sv);
OUTPUT:
RETVAL
Imager::IO
io_new_cb(writecb, readcb, seekcb, closecb, maxwrite = CBDATA_BUFSIZE)
SV *writecb;
SV *readcb;
SV *seekcb;
SV *closecb;
int maxwrite;
CODE:
RETVAL = do_io_new_cb(aTHX_ writecb, readcb, seekcb, closecb);
OUTPUT:
RETVAL
SV *
io_slurp(ig)
Imager::IO ig
PREINIT:
unsigned char* data;
size_t tlength;
CODE:
data = NULL;
tlength = io_slurp(ig, &data);
RETVAL = newSVpv((char *)data,tlength);
myfree(data);
OUTPUT:
RETVAL
undef_int
i_set_image_file_limits(width, height, bytes)
i_img_dim width
i_img_dim height
size_t bytes
void
i_get_image_file_limits()
PREINIT:
i_img_dim width, height;
size_t bytes;
PPCODE:
if (i_get_image_file_limits(&width, &height, &bytes)) {
EXTEND(SP, 3);
PUSHs(sv_2mortal(newSViv(width)));
PUSHs(sv_2mortal(newSViv(height)));
PUSHs(sv_2mortal(newSVuv(bytes)));
}
bool
i_int_check_image_file_limits(width, height, channels, sample_size)
i_img_dim width
i_img_dim height
int channels
size_t sample_size
PROTOTYPE: DISABLE
MODULE = Imager PACKAGE = Imager::IO PREFIX = io_
Imager::IO
io_new_fd(class, fd)
int fd
CODE:
RETVAL = io_new_fd(fd);
OUTPUT:
RETVAL
Imager::IO
io_new_buffer(class, data_sv)
SV *data_sv
CODE:
RETVAL = do_io_new_buffer(aTHX_ data_sv);
OUTPUT:
RETVAL
Imager::IO
io_new_cb(class, writecb, readcb, seekcb, closecb)
SV *writecb;
SV *readcb;
SV *seekcb;
SV *closecb;
CODE:
RETVAL = do_io_new_cb(aTHX_ writecb, readcb, seekcb, closecb);
OUTPUT:
RETVAL
Imager::IO
io_new_bufchain(class)
CODE:
RETVAL = io_new_bufchain();
OUTPUT:
RETVAL
SV *
io_slurp(class, ig)
Imager::IO ig
PREINIT:
unsigned char* data;
size_t tlength;
CODE:
data = NULL;
tlength = io_slurp(ig, &data);
RETVAL = newSVpv((char *)data,tlength);
myfree(data);
OUTPUT:
RETVAL
MODULE = Imager PACKAGE = Imager::IO PREFIX = i_io_
IV
i_io_raw_write(ig, data_sv)
Imager::IO ig
SV *data_sv
PREINIT:
void *data;
STRLEN size;
CODE:
#ifdef SvUTF8
if (SvUTF8(data_sv)) {
data_sv = sv_2mortal(newSVsv(data_sv));
/* yes, we want this to croak() if the SV can't be downgraded */
sv_utf8_downgrade(data_sv, FALSE);
}
#endif
data = SvPV(data_sv, size);
RETVAL = i_io_raw_write(ig, data, size);
OUTPUT:
RETVAL
void
i_io_raw_read(ig, buffer_sv, size)
Imager::IO ig
SV *buffer_sv
IV size
PREINIT:
void *buffer;
ssize_t result;
PPCODE:
if (size <= 0)
croak("size negative in call to i_io_raw_read()");
/* prevent an undefined value warning if they supplied an
undef buffer.
Orginally conditional on !SvOK(), but this will prevent the
downgrade from croaking */
sv_setpvn(buffer_sv, "", 0);
#ifdef SvUTF8
if (SvUTF8(buffer_sv))
sv_utf8_downgrade(buffer_sv, FALSE);
#endif
buffer = SvGROW(buffer_sv, size+1);
result = i_io_raw_read(ig, buffer, size);
if (result >= 0) {
SvCUR_set(buffer_sv, result);
*SvEND(buffer_sv) = '\0';
SvPOK_only(buffer_sv);
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSViv(result)));
}
ST(1) = buffer_sv;
SvSETMAGIC(ST(1));
void
i_io_raw_read2(ig, size)
Imager::IO ig
IV size
PREINIT:
SV *buffer_sv;
void *buffer;
ssize_t result;
PPCODE:
if (size <= 0)
croak("size negative in call to i_io_read2()");
buffer_sv = newSV(size);
buffer = SvGROW(buffer_sv, size+1);
result = i_io_raw_read(ig, buffer, size);
if (result >= 0) {
SvCUR_set(buffer_sv, result);
*SvEND(buffer_sv) = '\0';
SvPOK_only(buffer_sv);
EXTEND(SP, 1);
PUSHs(sv_2mortal(buffer_sv));
}
else {
/* discard it */
SvREFCNT_dec(buffer_sv);
}
off_t
i_io_raw_seek(ig, position, whence)
Imager::IO ig
off_t position
int whence
int
i_io_raw_close(ig)
Imager::IO ig
void
i_io_DESTROY(ig)
Imager::IO ig
int
i_io_CLONE_SKIP(...)
CODE:
(void)items; /* avoid unused warning for XS variable */
RETVAL = 1;
OUTPUT:
RETVAL
int
i_io_getc(ig)
Imager::IO ig
int
i_io_putc(ig, c)
Imager::IO ig
int c
int
i_io_close(ig)
Imager::IO ig
int
i_io_flush(ig)
Imager::IO ig
int
i_io_peekc(ig)
Imager::IO ig
int
i_io_seek(ig, off, whence)
Imager::IO ig
off_t off
int whence
void
i_io_peekn(ig, size)
Imager::IO ig
STRLEN size
PREINIT:
SV *buffer_sv;
void *buffer;
ssize_t result;
PPCODE:
buffer_sv = newSV(size+1);
buffer = SvGROW(buffer_sv, size+1);
result = i_io_peekn(ig, buffer, size);
if (result >= 0) {
SvCUR_set(buffer_sv, result);
*SvEND(buffer_sv) = '\0';
SvPOK_only(buffer_sv);
EXTEND(SP, 1);
PUSHs(sv_2mortal(buffer_sv));
}
else {
/* discard it */
SvREFCNT_dec(buffer_sv);
}
void
i_io_read(ig, buffer_sv, size)
Imager::IO ig
SV *buffer_sv
IV size
PREINIT:
void *buffer;
ssize_t result;
PPCODE:
if (size <= 0)
croak("size negative in call to i_io_read()");
/* prevent an undefined value warning if they supplied an
undef buffer.
Orginally conditional on !SvOK(), but this will prevent the
downgrade from croaking */
sv_setpvn(buffer_sv, "", 0);
#ifdef SvUTF8
if (SvUTF8(buffer_sv))
sv_utf8_downgrade(buffer_sv, FALSE);
#endif
buffer = SvGROW(buffer_sv, size+1);
result = i_io_read(ig, buffer, size);
if (result >= 0) {
SvCUR_set(buffer_sv, result);
*SvEND(buffer_sv) = '\0';
SvPOK_only(buffer_sv);
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSViv(result)));
}
ST(1) = buffer_sv;
SvSETMAGIC(ST(1));
void
i_io_read2(ig, size)
Imager::IO ig
STRLEN size
PREINIT:
SV *buffer_sv;
void *buffer;
ssize_t result;
PPCODE:
if (size == 0)
croak("size zero in call to read2()");
buffer_sv = newSV(size);
buffer = SvGROW(buffer_sv, size+1);
result = i_io_read(ig, buffer, size);
if (result > 0) {
SvCUR_set(buffer_sv, result);
*SvEND(buffer_sv) = '\0';
SvPOK_only(buffer_sv);
EXTEND(SP, 1);
PUSHs(sv_2mortal(buffer_sv));
}
else {
/* discard it */
SvREFCNT_dec(buffer_sv);
}
void
i_io_gets(ig, size = 8192, eol = NEWLINE)
Imager::IO ig
STRLEN size
int eol
PREINIT:
SV *buffer_sv;
void *buffer;
ssize_t result;
PPCODE:
if (size < 2)
croak("size too small in call to gets()");
buffer_sv = sv_2mortal(newSV(size+1));
buffer = SvPVX(buffer_sv);
result = i_io_gets(ig, buffer, size+1, eol);
if (result > 0) {
SvCUR_set(buffer_sv, result);
*SvEND(buffer_sv) = '\0';
SvPOK_only(buffer_sv);
EXTEND(SP, 1);
PUSHs(buffer_sv);
}
IV
i_io_write(ig, data_sv)
Imager::IO ig
SV *data_sv
PREINIT:
void *data;
STRLEN size;
CODE:
#ifdef SvUTF8
if (SvUTF8(data_sv)) {
data_sv = sv_2mortal(newSVsv(data_sv));
/* yes, we want this to croak() if the SV can't be downgraded */
sv_utf8_downgrade(data_sv, FALSE);
}
#endif
data = SvPV(data_sv, size);
RETVAL = i_io_write(ig, data, size);
OUTPUT:
RETVAL
void
i_io_dump(ig, flags = I_IO_DUMP_DEFAULT)
Imager::IO ig
int flags
bool
i_io_set_buffered(ig, flag = 1)
Imager::IO ig
int flag
bool
i_io_is_buffered(ig)
Imager::IO ig
bool
i_io_eof(ig)
Imager::IO ig
bool
i_io_error(ig)
Imager::IO ig
MODULE = Imager PACKAGE = Imager
PROTOTYPES: ENABLE
void
i_list_formats()
PREINIT:
char* item;
int i;
PPCODE:
i=0;
while( (item=i_format_list[i++]) != NULL ) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv(item,0)));
}
Imager::ImgRaw
i_sametype(im, x, y)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
Imager::ImgRaw
i_sametype_chans(im, x, y, channels)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
int channels
int
i_init_log(name_sv,level)
SV* name_sv
int level
PREINIT:
const char *name = SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
CODE:
RETVAL = i_init_log(name, level);
OUTPUT:
RETVAL
void
i_log_entry(string,level)
char* string
int level
int
i_log_enabled()
void
i_img_info(im)
Imager::ImgRaw im
PREINIT:
i_img_dim info[4];
PPCODE:
i_img_info(im,info);
EXTEND(SP, 4);
PUSHs(sv_2mortal(newSViv(info[0])));
PUSHs(sv_2mortal(newSViv(info[1])));
PUSHs(sv_2mortal(newSViv(info[2])));
PUSHs(sv_2mortal(newSViv(info[3])));
void
i_img_setmask(im,ch_mask)
Imager::ImgRaw im
int ch_mask
int
i_img_getmask(im)
Imager::ImgRaw im
int
i_img_getchannels(im)
Imager::ImgRaw im
void
i_img_getdata(im)
Imager::ImgRaw im
PPCODE:
EXTEND(SP, 1);
PUSHs(im->idata ?
sv_2mortal(newSVpv((char *)im->idata, im->bytes))
: &PL_sv_undef);
IV
i_img_get_width(im)
Imager::ImgRaw im
IV
i_img_get_height(im)
Imager::ImgRaw im
void
i_img_is_monochrome(im)
Imager::ImgRaw im
PREINIT:
int zero_is_white;
int result;
PPCODE:
result = i_img_is_monochrome(im, &zero_is_white);
if (result) {
if (GIMME_V == G_ARRAY) {
EXTEND(SP, 2);
PUSHs(&PL_sv_yes);
PUSHs(sv_2mortal(newSViv(zero_is_white)));
}
else {
EXTEND(SP, 1);
PUSHs(&PL_sv_yes);
}
}
void
i_line(im,x1,y1,x2,y2,val,endp)
Imager::ImgRaw im
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
Imager::Color val
int endp
void
i_line_aa(im,x1,y1,x2,y2,val,endp)
Imager::ImgRaw im
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
Imager::Color val
int endp
void
i_box(im,x1,y1,x2,y2,val)
Imager::ImgRaw im
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
Imager::Color val
void
i_box_filled(im,x1,y1,x2,y2,val)
Imager::ImgRaw im
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
Imager::Color val
int
i_box_filledf(im,x1,y1,x2,y2,val)
Imager::ImgRaw im
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
Imager::Color::Float val
void
i_box_cfill(im,x1,y1,x2,y2,fill)
Imager::ImgRaw im
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
Imager::FillHandle fill
void
i_arc(im,x,y,rad,d1,d2,val)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
double rad
double d1
double d2
Imager::Color val
void
i_arc_aa(im,x,y,rad,d1,d2,val)
Imager::ImgRaw im
double x
double y
double rad
double d1
double d2
Imager::Color val
void
i_arc_cfill(im,x,y,rad,d1,d2,fill)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
double rad
double d1
double d2
Imager::FillHandle fill
void
i_arc_aa_cfill(im,x,y,rad,d1,d2,fill)
Imager::ImgRaw im
double x
double y
double rad
double d1
double d2
Imager::FillHandle fill
void
i_circle_aa(im,x,y,rad,val)
Imager::ImgRaw im
double x
double y
double rad
Imager::Color val
int
i_circle_out(im,x,y,rad,val)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
i_img_dim rad
Imager::Color val
int
i_circle_out_aa(im,x,y,rad,val)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
i_img_dim rad
Imager::Color val
int
i_arc_out(im,x,y,rad,d1,d2,val)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
i_img_dim rad
double d1
double d2
Imager::Color val
int
i_arc_out_aa(im,x,y,rad,d1,d2,val)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
i_img_dim rad
double d1
double d2
Imager::Color val
void
i_bezier_multi(im,xc,yc,val)
Imager::ImgRaw im
Imager::Color val
PREINIT:
double *x,*y;
int len;
AV *av1;
AV *av2;
SV *sv1;
SV *sv2;
int i;
PPCODE:
ICL_info(val);
if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_bezier_multi must be a reference to an array\n");
if (!SvROK(ST(2))) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 to i_bezier_multi must be a reference to an array\n");
av1=(AV*)SvRV(ST(1));
av2=(AV*)SvRV(ST(2));
if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_bezier_multi must be equal length\n");
len=av_len(av1)+1;
x=mymalloc( len*sizeof(double) );
y=mymalloc( len*sizeof(double) );
for(i=0;i<len;i++) {
sv1=(*(av_fetch(av1,i,0)));
sv2=(*(av_fetch(av2,i,0)));
x[i]=(double)SvNV(sv1);
y[i]=(double)SvNV(sv2);
}
i_bezier_multi(im,len,x,y,val);
myfree(x);
myfree(y);
int
i_poly_aa(im,xc,yc,val)
Imager::ImgRaw im
Imager::Color val
PREINIT:
double *x,*y;
int len;
AV *av1;
AV *av2;
SV *sv1;
SV *sv2;
int i;
CODE:
ICL_info(val);
if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
if (!SvROK(ST(2))) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa must be a reference to an array\n");
av1=(AV*)SvRV(ST(1));
av2=(AV*)SvRV(ST(2));
if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_poly_aa must be equal length\n");
len=av_len(av1)+1;
x=mymalloc( len*sizeof(double) );
y=mymalloc( len*sizeof(double) );
for(i=0;i<len;i++) {
sv1=(*(av_fetch(av1,i,0)));
sv2=(*(av_fetch(av2,i,0)));
x[i]=(double)SvNV(sv1);
y[i]=(double)SvNV(sv2);
}
RETVAL = i_poly_aa(im,len,x,y,val);
myfree(x);
myfree(y);
OUTPUT:
RETVAL
int
i_poly_aa_cfill(im,xc,yc,fill)
Imager::ImgRaw im
Imager::FillHandle fill
PREINIT:
double *x,*y;
int len;
AV *av1;
AV *av2;
SV *sv1;
SV *sv2;
int i;
CODE:
if (!SvROK(ST(1))) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
if (!SvROK(ST(2))) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 1 to i_poly_aa_cfill must be a reference to an array\n");
av1=(AV*)SvRV(ST(1));
av2=(AV*)SvRV(ST(2));
if (av_len(av1) != av_len(av2)) croak("Imager: x and y arrays to i_poly_aa_cfill must be equal length\n");
len=av_len(av1)+1;
x=mymalloc( len*sizeof(double) );
y=mymalloc( len*sizeof(double) );
for(i=0;i<len;i++) {
sv1=(*(av_fetch(av1,i,0)));
sv2=(*(av_fetch(av2,i,0)));
x[i]=(double)SvNV(sv1);
y[i]=(double)SvNV(sv2);
}
RETVAL = i_poly_aa_cfill(im,len,x,y,fill);
myfree(x);
myfree(y);
OUTPUT:
RETVAL
undef_int
i_flood_fill(im,seedx,seedy,dcol)
Imager::ImgRaw im
i_img_dim seedx
i_img_dim seedy
Imager::Color dcol
undef_int
i_flood_cfill(im,seedx,seedy,fill)
Imager::ImgRaw im
i_img_dim seedx
i_img_dim seedy
Imager::FillHandle fill
undef_int
i_flood_fill_border(im,seedx,seedy,dcol, border)
Imager::ImgRaw im
i_img_dim seedx
i_img_dim seedy
Imager::Color dcol
Imager::Color border
undef_int
i_flood_cfill_border(im,seedx,seedy,fill, border)
Imager::ImgRaw im
i_img_dim seedx
i_img_dim seedy
Imager::FillHandle fill
Imager::Color border
void
i_copyto(im,src,x1,y1,x2,y2,tx,ty)
Imager::ImgRaw im
Imager::ImgRaw src
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
i_img_dim tx
i_img_dim ty
void
i_copyto_trans(im,src,x1,y1,x2,y2,tx,ty,trans)
Imager::ImgRaw im
Imager::ImgRaw src
i_img_dim x1
i_img_dim y1
i_img_dim x2
i_img_dim y2
i_img_dim tx
i_img_dim ty
Imager::Color trans
Imager::ImgRaw
i_copy(src)
Imager::ImgRaw src
undef_int
i_rubthru(im,src,tx,ty,src_minx,src_miny,src_maxx,src_maxy)
Imager::ImgRaw im
Imager::ImgRaw src
i_img_dim tx
i_img_dim ty
i_img_dim src_minx
i_img_dim src_miny
i_img_dim src_maxx
i_img_dim src_maxy
undef_int
i_compose(out, src, out_left, out_top, src_left, src_top, width, height, combine = ic_normal, opacity = 0.0)
Imager::ImgRaw out
Imager::ImgRaw src
i_img_dim out_left
i_img_dim out_top
i_img_dim src_left
i_img_dim src_top
i_img_dim width
i_img_dim height
int combine
double opacity
undef_int
i_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)
Imager::ImgRaw out
Imager::ImgRaw src
Imager::ImgRaw mask
i_img_dim out_left
i_img_dim out_top
i_img_dim src_left
i_img_dim src_top
i_img_dim mask_left
i_img_dim mask_top
i_img_dim width
i_img_dim height
int combine
double opacity
Imager::ImgRaw
i_combine(src_av, channels_av = NULL)
AV *src_av
AV *channels_av
PREINIT:
i_img **imgs = NULL;
STRLEN in_count;
int *channels = NULL;
int i;
SV **psv;
IV tmp;
CODE:
in_count = av_len(src_av) + 1;
if (in_count > 0) {
imgs = mymalloc(sizeof(i_img*) * in_count);
channels = mymalloc(sizeof(int) * in_count);
for (i = 0; i < in_count; ++i) {
psv = av_fetch(src_av, i, 0);
if (!psv || !*psv || !sv_derived_from(*psv, "Imager::ImgRaw")) {
myfree(imgs);
myfree(channels);
croak("imgs must contain only images");
}
tmp = SvIV((SV*)SvRV(*psv));
imgs[i] = INT2PTR(i_img*, tmp);
if (channels_av &&
(psv = av_fetch(channels_av, i, 0)) != NULL &&
*psv) {
channels[i] = SvIV(*psv);
}
else {
channels[i] = 0;
}
}
}
RETVAL = i_combine(imgs, channels, in_count);
myfree(imgs);
myfree(channels);
OUTPUT:
RETVAL
undef_int
i_flipxy(im, direction)
Imager::ImgRaw im
int direction
Imager::ImgRaw
i_rotate90(im, degrees)
Imager::ImgRaw im
int degrees
Imager::ImgRaw
i_rotate_exact(im, amount, ...)
Imager::ImgRaw im
double amount
PREINIT:
i_color *backp = NULL;
i_fcolor *fbackp = NULL;
int i;
SV * sv1;
CODE:
/* extract the bg colors if any */
/* yes, this is kind of strange */
for (i = 2; i < items; ++i) {
sv1 = ST(i);
if (sv_derived_from(sv1, "Imager::Color")) {
IV tmp = SvIV((SV*)SvRV(sv1));
backp = INT2PTR(i_color *, tmp);
}
else if (sv_derived_from(sv1, "Imager::Color::Float")) {
IV tmp = SvIV((SV*)SvRV(sv1));
fbackp = INT2PTR(i_fcolor *, tmp);
}
}
RETVAL = i_rotate_exact_bg(im, amount, backp, fbackp);
OUTPUT:
RETVAL
Imager::ImgRaw
i_matrix_transform(im, xsize, ysize, matrix, ...)
Imager::ImgRaw im
i_img_dim xsize
i_img_dim ysize
PREINIT:
double matrix[9];
AV *av;
IV len;
SV *sv1;
int i;
i_color *backp = NULL;
i_fcolor *fbackp = NULL;
CODE:
if (!SvROK(ST(3)) || SvTYPE(SvRV(ST(3))) != SVt_PVAV)
croak("i_matrix_transform: parameter 4 must be an array ref\n");
av=(AV*)SvRV(ST(3));
len=av_len(av)+1;
if (len > 9)
len = 9;
for (i = 0; i < len; ++i) {
sv1=(*(av_fetch(av,i,0)));
matrix[i] = SvNV(sv1);
}
for (; i < 9; ++i)
matrix[i] = 0;
/* extract the bg colors if any */
/* yes, this is kind of strange */
for (i = 4; i < items; ++i) {
sv1 = ST(i);
if (sv_derived_from(sv1, "Imager::Color")) {
IV tmp = SvIV((SV*)SvRV(sv1));
backp = INT2PTR(i_color *, tmp);
}
else if (sv_derived_from(sv1, "Imager::Color::Float")) {
IV tmp = SvIV((SV*)SvRV(sv1));
fbackp = INT2PTR(i_fcolor *, tmp);
}
}
RETVAL = i_matrix_transform_bg(im, xsize, ysize, matrix, backp, fbackp);
OUTPUT:
RETVAL
undef_int
i_gaussian(im,stdev)
Imager::ImgRaw im
double stdev
void
i_unsharp_mask(im,stdev,scale)
Imager::ImgRaw im
double stdev
double scale
int
i_conv(im,coef)
Imager::ImgRaw im
AV *coef
PREINIT:
double* c_coef;
int len;
SV* sv1;
int i;
CODE:
len = av_len(coef) + 1;
c_coef=mymalloc( len * sizeof(double) );
for(i = 0; i < len; i++) {
sv1 = (*(av_fetch(coef, i, 0)));
c_coef[i] = (double)SvNV(sv1);
}
RETVAL = i_conv(im, c_coef, len);
myfree(c_coef);
OUTPUT:
RETVAL
Imager::ImgRaw
i_convert(src, avmain)
Imager::ImgRaw src
AV *avmain
PREINIT:
double *coeff;
int outchan;
int inchan;
SV **temp;
AV *avsub;
int len;
int i, j;
CODE:
outchan = av_len(avmain)+1;
/* find the biggest */
inchan = 0;
for (j=0; j < outchan; ++j) {
temp = av_fetch(avmain, j, 0);
if (temp && SvROK(*temp) && SvTYPE(SvRV(*temp)) == SVt_PVAV) {
avsub = (AV*)SvRV(*temp);
len = av_len(avsub)+1;
if (len > inchan)
inchan = len;
}
else {
i_push_errorf(0, "invalid matrix: element %d is not an array ref", j);
XSRETURN(0);
}
}
coeff = mymalloc(sizeof(double) * outchan * inchan);
for (j = 0; j < outchan; ++j) {
avsub = (AV*)SvRV(*av_fetch(avmain, j, 0));
len = av_len(avsub)+1;
for (i = 0; i < len; ++i) {
temp = av_fetch(avsub, i, 0);
if (temp)
coeff[i+j*inchan] = SvNV(*temp);
else
coeff[i+j*inchan] = 0;
}
while (i < inchan)
coeff[i++ + j*inchan] = 0;
}
RETVAL = i_convert(src, coeff, outchan, inchan);
myfree(coeff);
OUTPUT:
RETVAL
void
i_map(im, pmaps)
Imager::ImgRaw im
PREINIT:
unsigned int mask = 0;
AV *avmain;
AV *avsub;
SV **temp;
int len;
int i, j;
unsigned char (*maps)[256];
CODE:
if (!SvROK(ST(1)) || SvTYPE(SvRV(ST(1))) != SVt_PVAV)
croak("i_map: parameter 2 must be an arrayref\n");
avmain = (AV*)SvRV(ST(1));
len = av_len(avmain)+1;
if (im->channels < len) len = im->channels;
maps = mymalloc( len * sizeof(unsigned char [256]) );
for (j=0; j<len ; j++) {
temp = av_fetch(avmain, j, 0);
if (temp && SvROK(*temp) && (SvTYPE(SvRV(*temp)) == SVt_PVAV) ) {
avsub = (AV*)SvRV(*temp);
if(av_len(avsub) != 255) continue;
mask |= 1<<j;
for (i=0; i<256 ; i++) {
int val;
temp = av_fetch(avsub, i, 0);
val = temp ? SvIV(*temp) : 0;
if (val<0) val = 0;
if (val>255) val = 255;
maps[j][i] = val;
}
}
}
i_map(im, maps, mask);
myfree(maps);
float
i_img_diff(im1,im2)
Imager::ImgRaw im1
Imager::ImgRaw im2
double
i_img_diffd(im1,im2)
Imager::ImgRaw im1
Imager::ImgRaw im2
int
i_img_samef(im1, im2, epsilon = i_img_epsilonf(), what=NULL)
Imager::ImgRaw im1
Imager::ImgRaw im2
double epsilon
const char *what
double
i_img_epsilonf()
bool
_is_color_object(sv)
SV* sv
CODE:
SvGETMAGIC(sv);
RETVAL = SvOK(sv) && SvROK(sv) &&
(sv_derived_from(sv, "Imager::Color")
|| sv_derived_from(sv, "Imager::Color::Float"));
OUTPUT:
RETVAL
#ifdef HAVE_LIBTT
Imager::Font::TT
i_tt_new(fontname)
char* fontname
MODULE = Imager PACKAGE = Imager::Font::TT PREFIX=TT_
#define TT_DESTROY(handle) i_tt_destroy(handle)
void
TT_DESTROY(handle)
Imager::Font::TT handle
int
TT_CLONE_SKIP(...)
CODE:
(void)items; /* avoid unused warning */
RETVAL = 1;
OUTPUT:
RETVAL
MODULE = Imager PACKAGE = Imager
undef_int
i_tt_text(handle,im,xb,yb,cl,points,str_sv,len_ignored,smooth,utf8,align=1)
Imager::Font::TT handle
Imager::ImgRaw im
i_img_dim xb
i_img_dim yb
Imager::Color cl
double points
SV * str_sv
int smooth
int utf8
int align
PREINIT:
char *str;
STRLEN len;
CODE:
#ifdef SvUTF8
if (SvUTF8(str_sv))
utf8 = 1;
#endif
str = SvPV(str_sv, len);
RETVAL = i_tt_text(handle, im, xb, yb, cl, points, str,
len, smooth, utf8, align);
OUTPUT:
RETVAL
undef_int
i_tt_cp(handle,im,xb,yb,channel,points,str_sv,len_ignored,smooth,utf8,align=1)
Imager::Font::TT handle
Imager::ImgRaw im
i_img_dim xb
i_img_dim yb
int channel
double points
SV * str_sv
int smooth
int utf8
int align
PREINIT:
char *str;
STRLEN len;
CODE:
#ifdef SvUTF8
if (SvUTF8(str_sv))
utf8 = 1;
#endif
str = SvPV(str_sv, len);
RETVAL = i_tt_cp(handle, im, xb, yb, channel, points, str, len,
smooth, utf8, align);
OUTPUT:
RETVAL
void
i_tt_bbox(handle,point,str_sv,len_ignored, utf8)
Imager::Font::TT handle
double point
SV* str_sv
int utf8
PREINIT:
i_img_dim cords[BOUNDING_BOX_COUNT];
int rc;
char * str;
STRLEN len;
int i;
PPCODE:
#ifdef SvUTF8
if (SvUTF8(ST(2)))
utf8 = 1;
#endif
str = SvPV(str_sv, len);
if ((rc=i_tt_bbox(handle,point,str,len,cords, utf8))) {
EXTEND(SP, rc);
for (i = 0; i < rc; ++i) {
PUSHs(sv_2mortal(newSViv(cords[i])));
}
}
void
i_tt_has_chars(handle, text_sv, utf8)
Imager::Font::TT handle
SV *text_sv
int utf8
PREINIT:
char const *text;
STRLEN len;
char *work;
size_t count;
size_t i;
PPCODE:
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
text = SvPV(text_sv, len);
work = mymalloc(len);
count = i_tt_has_chars(handle, text, len, utf8, work);
if (GIMME_V == G_ARRAY) {
EXTEND(SP, count);
for (i = 0; i < count; ++i) {
PUSHs(boolSV(work[i]));
}
}
else {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv(work, count)));
}
myfree(work);
void
i_tt_dump_names(handle)
Imager::Font::TT handle
void
i_tt_face_name(handle)
Imager::Font::TT handle
PREINIT:
char name[255];
size_t len;
PPCODE:
len = i_tt_face_name(handle, name, sizeof(name));
if (len) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv(name, len-1)));
}
void
i_tt_glyph_name(handle, text_sv, utf8 = 0)
Imager::Font::TT handle
SV *text_sv
int utf8
PREINIT:
char const *text;
STRLEN work_len;
size_t len;
size_t outsize;
char name[255];
PPCODE:
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
text = SvPV(text_sv, work_len);
len = work_len;
while (len) {
unsigned long ch;
if (utf8) {
ch = i_utf8_advance(&text, &len);
if (ch == ~0UL) {
i_push_error(0, "invalid UTF8 character");
break;
}
}
else {
ch = *text++;
--len;
}
EXTEND(SP, 1);
if ((outsize = i_tt_glyph_name(handle, ch, name, sizeof(name))) != 0) {
PUSHs(sv_2mortal(newSVpv(name, 0)));
}
else {
PUSHs(&PL_sv_undef);
}
}
#endif
const char *
i_test_format_probe(ig, length)
Imager::IO ig
int length
Imager::ImgRaw
i_readpnm_wiol(ig, allow_incomplete)
Imager::IO ig
int allow_incomplete
void
i_readpnm_multi_wiol(ig, allow_incomplete)
Imager::IO ig
int allow_incomplete
PREINIT:
i_img **imgs;
int count=0;
int i;
PPCODE:
imgs = i_readpnm_multi_wiol(ig, &count, allow_incomplete);
if (imgs) {
EXTEND(SP, count);
for (i = 0; i < count; ++i) {
SV *sv = sv_newmortal();
sv_setref_pv(sv, "Imager::ImgRaw", (void *)imgs[i]);
PUSHs(sv);
}
myfree(imgs);
}
undef_int
i_writeppm_wiol(im, ig)
Imager::ImgRaw im
Imager::IO ig
Imager::ImgRaw
i_readraw_wiol(ig,x,y,datachannels,storechannels,intrl)
Imager::IO ig
i_img_dim x
i_img_dim y
int datachannels
int storechannels
int intrl
undef_int
i_writeraw_wiol(im,ig)
Imager::ImgRaw im
Imager::IO ig
undef_int
i_writebmp_wiol(im,ig)
Imager::ImgRaw im
Imager::IO ig
Imager::ImgRaw
i_readbmp_wiol(ig, allow_incomplete=0)
Imager::IO ig
int allow_incomplete
undef_int
i_writetga_wiol(im,ig, wierdpack, compress, idstring)
Imager::ImgRaw im
Imager::IO ig
int wierdpack
int compress
char* idstring
PREINIT:
int idlen;
CODE:
idlen = SvCUR(ST(4));
RETVAL = i_writetga_wiol(im, ig, wierdpack, compress, idstring, idlen);
OUTPUT:
RETVAL
Imager::ImgRaw
i_readtga_wiol(ig, length)
Imager::IO ig
int length
Imager::ImgRaw
i_scaleaxis(im,Value,Axis)
Imager::ImgRaw im
double Value
int Axis
Imager::ImgRaw
i_scale_nn(im,scx,scy)
Imager::ImgRaw im
double scx
double scy
Imager::ImgRaw
i_scale_mixing(im, width, height)
Imager::ImgRaw im
i_img_dim width
i_img_dim height
Imager::ImgRaw
i_haar(im)
Imager::ImgRaw im
int
i_count_colors(im,maxc)
Imager::ImgRaw im
int maxc
void
i_get_anonymous_color_histo(im, maxc = 0x40000000)
Imager::ImgRaw im
int maxc
PREINIT:
int i;
unsigned int * col_usage = NULL;
int col_cnt;
PPCODE:
col_cnt = i_get_anonymous_color_histo(im, &col_usage, maxc);
EXTEND(SP, col_cnt);
for (i = 0; i < col_cnt; i++) {
PUSHs(sv_2mortal(newSViv( col_usage[i])));
}
myfree(col_usage);
XSRETURN(col_cnt);
void
i_transform(im,opx,opy,parm)
Imager::ImgRaw im
PREINIT:
double* parm;
int *opx;
int *opy;
int opxl;
int opyl;
int parmlen;
AV* av;
SV* sv1;
int i;
i_img *result;
PPCODE:
if (!SvROK(ST(1))) croak("Imager: Parameter 1 must be a reference to an array\n");
if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to an array\n");
if (!SvROK(ST(3))) croak("Imager: Parameter 3 must be a reference to an array\n");
if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) croak("Imager: Parameter 1 must be a reference to an array\n");
if (SvTYPE(SvRV(ST(2))) != SVt_PVAV) croak("Imager: Parameter 2 must be a reference to an array\n");
if (SvTYPE(SvRV(ST(3))) != SVt_PVAV) croak("Imager: Parameter 3 must be a reference to an array\n");
av=(AV*)SvRV(ST(1));
opxl=av_len(av)+1;
opx=mymalloc( opxl*sizeof(int) );
for(i=0;i<opxl;i++) {
sv1=(*(av_fetch(av,i,0)));
opx[i]=(int)SvIV(sv1);
}
av=(AV*)SvRV(ST(2));
opyl=av_len(av)+1;
opy=mymalloc( opyl*sizeof(int) );
for(i=0;i<opyl;i++) {
sv1=(*(av_fetch(av,i,0)));
opy[i]=(int)SvIV(sv1);
}
av=(AV*)SvRV(ST(3));
parmlen=av_len(av)+1;
parm=mymalloc( parmlen*sizeof(double) );
for(i=0;i<parmlen;i++) { /* FIXME: Bug? */
sv1=(*(av_fetch(av,i,0)));
parm[i]=(double)SvNV(sv1);
}
result=i_transform(im,opx,opxl,opy,opyl,parm,parmlen);
myfree(parm);
myfree(opy);
myfree(opx);
if (result) {
SV *result_sv = sv_newmortal();
EXTEND(SP, 1);
sv_setref_pv(result_sv, "Imager::ImgRaw", (void*)result);
PUSHs(result_sv);
}
void
i_transform2(sv_width,sv_height,channels,sv_ops,av_n_regs,av_c_regs,av_in_imgs)
SV *sv_width
SV *sv_height
SV *sv_ops
AV *av_n_regs
AV *av_c_regs
AV *av_in_imgs
int channels
PREINIT:
i_img_dim width;
i_img_dim height;
struct rm_op *ops;
STRLEN ops_len;
int ops_count;
double *n_regs;
int n_regs_count;
i_color *c_regs;
int c_regs_count;
int in_imgs_count;
i_img **in_imgs;
SV *sv1;
IV tmp;
int i;
i_img *result;
PPCODE:
in_imgs_count = av_len(av_in_imgs)+1;
for (i = 0; i < in_imgs_count; ++i) {
sv1 = *av_fetch(av_in_imgs, i, 0);
if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
croak("sv_in_img must contain only images");
}
}
if (in_imgs_count > 0) {
in_imgs = mymalloc(in_imgs_count*sizeof(i_img*));
for (i = 0; i < in_imgs_count; ++i) {
sv1 = *av_fetch(av_in_imgs,i,0);
if (!sv_derived_from(sv1, "Imager::ImgRaw")) {
croak("Parameter 5 must contain only images");
}
tmp = SvIV((SV*)SvRV(sv1));
in_imgs[i] = INT2PTR(i_img*, tmp);
}
}
else {
/* no input images */
in_imgs = NULL;
}
/* default the output size from the first input if possible */
if (SvOK(sv_width))
width = SvIV(sv_width);
else if (in_imgs_count)
width = in_imgs[0]->xsize;
else
croak("No output image width supplied");
if (SvOK(sv_height))
height = SvIV(sv_height);
else if (in_imgs_count)
height = in_imgs[0]->ysize;
else
croak("No output image height supplied");
ops = (struct rm_op *)SvPV(sv_ops, ops_len);
if (ops_len % sizeof(struct rm_op))
croak("Imager: Parameter 3 must be a bitmap of regops\n");
ops_count = ops_len / sizeof(struct rm_op);
n_regs_count = av_len(av_n_regs)+1;
n_regs = mymalloc(n_regs_count * sizeof(double));
for (i = 0; i < n_regs_count; ++i) {
sv1 = *av_fetch(av_n_regs,i,0);
if (SvOK(sv1))
n_regs[i] = SvNV(sv1);
}
c_regs_count = av_len(av_c_regs)+1;
c_regs = mymalloc(c_regs_count * sizeof(i_color));
/* I don't bother initializing the colou?r registers */
result=i_transform2(width, height, channels, ops, ops_count,
n_regs, n_regs_count,
c_regs, c_regs_count, in_imgs, in_imgs_count);
if (in_imgs)
myfree(in_imgs);
myfree(n_regs);
myfree(c_regs);
if (result) {
SV *result_sv = sv_newmortal();
EXTEND(SP, 1);
sv_setref_pv(result_sv, "Imager::ImgRaw", (void*)result);
PUSHs(result_sv);
}
void
i_contrast(im,intensity)
Imager::ImgRaw im
float intensity
void
i_hardinvert(im)
Imager::ImgRaw im
void
i_hardinvertall(im)
Imager::ImgRaw im
void
i_noise(im,amount,type)
Imager::ImgRaw im
float amount
unsigned char type
void
i_bumpmap(im,bump,channel,light_x,light_y,strength)
Imager::ImgRaw im
Imager::ImgRaw bump
int channel
i_img_dim light_x
i_img_dim light_y
i_img_dim strength
void
i_bumpmap_complex(im,bump,channel,tx,ty,Lx,Ly,Lz,cd,cs,n,Ia,Il,Is)
Imager::ImgRaw im
Imager::ImgRaw bump
int channel
i_img_dim tx
i_img_dim ty
double Lx
double Ly
double Lz
float cd
float cs
float n
Imager::Color Ia
Imager::Color Il
Imager::Color Is
void
i_postlevels(im,levels)
Imager::ImgRaw im
int levels
void
i_mosaic(im,size)
Imager::ImgRaw im
i_img_dim size
void
i_watermark(im,wmark,tx,ty,pixdiff)
Imager::ImgRaw im
Imager::ImgRaw wmark
i_img_dim tx
i_img_dim ty
int pixdiff
void
i_autolevels(im,lsat,usat,skew)
Imager::ImgRaw im
float lsat
float usat
float skew
void
i_radnoise(im,xo,yo,rscale,ascale)
Imager::ImgRaw im
float xo
float yo
float rscale
float ascale
void
i_turbnoise(im, xo, yo, scale)
Imager::ImgRaw im
float xo
float yo
float scale
void
i_gradgen(im, ...)
Imager::ImgRaw im
PREINIT:
int num;
i_img_dim *xo;
i_img_dim *yo;
i_color *ival;
int dmeasure;
int i;
SV *sv;
AV *axx;
AV *ayy;
AV *ac;
CODE:
if (items != 5)
croak("Usage: i_gradgen(im, xo, yo, ival, dmeasure)");
if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
croak("i_gradgen: Second argument must be an array ref");
if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
croak("i_gradgen: Third argument must be an array ref");
if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
croak("i_gradgen: Fourth argument must be an array ref");
axx = (AV *)SvRV(ST(1));
ayy = (AV *)SvRV(ST(2));
ac = (AV *)SvRV(ST(3));
dmeasure = (int)SvIV(ST(4));
num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
num = num <= av_len(ac) ? num : av_len(ac);
num++;
if (num < 2) croak("Usage: i_gradgen array refs must have more than 1 entry each");
xo = mymalloc( sizeof(i_img_dim) * num );
yo = mymalloc( sizeof(i_img_dim) * num );
ival = mymalloc( sizeof(i_color) * num );
for(i = 0; i<num; i++) {
xo[i] = (i_img_dim)SvIV(* av_fetch(axx, i, 0));
yo[i] = (i_img_dim)SvIV(* av_fetch(ayy, i, 0));
sv = *av_fetch(ac, i, 0);
if ( !sv_derived_from(sv, "Imager::Color") ) {
free(axx); free(ayy); free(ac);
croak("i_gradgen: Element of fourth argument is not derived from Imager::Color");
}
ival[i] = *INT2PTR(i_color *, SvIV((SV *)SvRV(sv)));
}
i_gradgen(im, num, xo, yo, ival, dmeasure);
myfree(xo);
myfree(yo);
myfree(ival);
Imager::ImgRaw
i_diff_image(im, im2, mindist=0)
Imager::ImgRaw im
Imager::ImgRaw im2
double mindist
undef_int
i_fountain(im, xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
Imager::ImgRaw im
double xa
double ya
double xb
double yb
int type
int repeat
int combine
int super_sample
double ssample_param
PREINIT:
AV *asegs;
int count;
i_fountain_seg *segs;
CODE:
if (!SvROK(ST(10)) || ! SvTYPE(SvRV(ST(10))))
croak("i_fountain: argument 11 must be an array ref");
asegs = (AV *)SvRV(ST(10));
segs = load_fount_segs(aTHX_ asegs, &count);
RETVAL = i_fountain(im, xa, ya, xb, yb, type, repeat, combine,
super_sample, ssample_param, count, segs);
myfree(segs);
OUTPUT:
RETVAL
Imager::FillHandle
i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine, super_sample, ssample_param, segs)
double xa
double ya
double xb
double yb
int type
int repeat
int combine
int super_sample
double ssample_param
PREINIT:
AV *asegs;
int count;
i_fountain_seg *segs;
CODE:
if (!SvROK(ST(9)) || ! SvTYPE(SvRV(ST(9))))
croak("i_fountain: argument 11 must be an array ref");
asegs = (AV *)SvRV(ST(9));
segs = load_fount_segs(aTHX_ asegs, &count);
RETVAL = i_new_fill_fount(xa, ya, xb, yb, type, repeat, combine,
super_sample, ssample_param, count, segs);
myfree(segs);
OUTPUT:
RETVAL
Imager::FillHandle
i_new_fill_opacity(other_fill, alpha_mult)
Imager::FillHandle other_fill
double alpha_mult
void
i_errors()
PREINIT:
i_errmsg *errors;
int i;
AV *av;
SV *sv;
PPCODE:
errors = i_errors();
i = 0;
while (errors[i].msg) {
av = newAV();
sv = newSVpv(errors[i].msg, strlen(errors[i].msg));
if (!av_store(av, 0, sv)) {
SvREFCNT_dec(sv);
}
sv = newSViv(errors[i].code);
if (!av_store(av, 1, sv)) {
SvREFCNT_dec(sv);
}
PUSHs(sv_2mortal(newRV_noinc((SV*)av)));
++i;
}
void
i_clear_error()
void
i_push_error(code, msg)
int code
const char *msg
undef_int
i_nearest_color(im, ...)
Imager::ImgRaw im
PREINIT:
int num;
i_img_dim *xo;
i_img_dim *yo;
i_color *ival;
int dmeasure;
int i;
SV *sv;
AV *axx;
AV *ayy;
AV *ac;
CODE:
if (items != 5)
croak("Usage: i_nearest_color(im, xo, yo, ival, dmeasure)");
if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
croak("i_nearest_color: Second argument must be an array ref");
if (!SvROK(ST(2)) || ! SvTYPE(SvRV(ST(2))))
croak("i_nearest_color: Third argument must be an array ref");
if (!SvROK(ST(3)) || ! SvTYPE(SvRV(ST(3))))
croak("i_nearest_color: Fourth argument must be an array ref");
axx = (AV *)SvRV(ST(1));
ayy = (AV *)SvRV(ST(2));
ac = (AV *)SvRV(ST(3));
dmeasure = (int)SvIV(ST(4));
num = av_len(axx) < av_len(ayy) ? av_len(axx) : av_len(ayy);
num = num <= av_len(ac) ? num : av_len(ac);
num++;
if (num < 2) croak("Usage: i_nearest_color array refs must have more than 1 entry each");
xo = mymalloc( sizeof(i_img_dim) * num );
yo = mymalloc( sizeof(i_img_dim) * num );
ival = mymalloc( sizeof(i_color) * num );
for(i = 0; i<num; i++) {
xo[i] = (i_img_dim)SvIV(* av_fetch(axx, i, 0));
yo[i] = (i_img_dim)SvIV(* av_fetch(ayy, i, 0));
sv = *av_fetch(ac, i, 0);
if ( !sv_derived_from(sv, "Imager::Color") ) {
free(axx); free(ayy); free(ac);
croak("i_nearest_color: Element of fourth argument is not derived from Imager::Color");
}
ival[i] = *INT2PTR(i_color *, SvIV((SV *)SvRV(sv)));
}
RETVAL = i_nearest_color(im, num, xo, yo, ival, dmeasure);
OUTPUT:
RETVAL
void
malloc_state()
void
DSO_open(filename)
char* filename
PREINIT:
void *rc;
char *evstr;
PPCODE:
rc=DSO_open(filename,&evstr);
if (rc!=NULL) {
if (evstr!=NULL) {
EXTEND(SP,2);
PUSHs(sv_2mortal(newSViv(PTR2IV(rc))));
PUSHs(sv_2mortal(newSVpvn(evstr, strlen(evstr))));
} else {
EXTEND(SP,1);
PUSHs(sv_2mortal(newSViv(PTR2IV(rc))));
}
}
undef_int
DSO_close(dso_handle)
void* dso_handle
void
DSO_funclist(dso_handle_v)
void* dso_handle_v
PREINIT:
int i;
DSO_handle *dso_handle;
func_ptr *functions;
PPCODE:
dso_handle=(DSO_handle*)dso_handle_v;
functions = DSO_funclist(dso_handle);
i=0;
while( functions[i].name != NULL) {
EXTEND(SP,1);
PUSHs(sv_2mortal(newSVpv(functions[i].name,0)));
EXTEND(SP,1);
PUSHs(sv_2mortal(newSVpv(functions[i++].pcode,0)));
}
void
DSO_call(handle,func_index,hv)
void* handle
int func_index
PREINIT:
HV* hv;
PPCODE:
if (!SvROK(ST(2))) croak("Imager: Parameter 2 must be a reference to a hash\n");
hv=(HV*)SvRV(ST(2));
if (SvTYPE(hv)!=SVt_PVHV) croak("Imager: Parameter 2 must be a reference to a hash\n");
DSO_call( (DSO_handle *)handle,func_index,hv);
SV *
i_get_pixel(im, x, y)
Imager::ImgRaw im
i_img_dim x
i_img_dim y;
PREINIT:
i_color *color;
CODE:
color = (i_color *)mymalloc(sizeof(i_color));
if (i_gpix(im, x, y, color) == 0) {
RETVAL = NEWSV(0, 0);
sv_setref_pv(RETVAL, "Imager::Color", (void *)color);
}
else {
myfree(color);
RETVAL = &PL_sv_undef;
}
OUTPUT:
RETVAL
int
i_ppix(im, x, y, cl)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
Imager::Color cl
Imager::ImgRaw
i_img_pal_new(x, y, channels, maxpal)
i_img_dim x
i_img_dim y
int channels
int maxpal
Imager::ImgRaw
i_img_to_pal(src, quant)
Imager::ImgRaw src
PREINIT:
HV *hv;
i_quantize quant;
CODE:
if (!SvROK(ST(1)) || ! SvTYPE(SvRV(ST(1))))
croak("i_img_to_pal: second argument must be a hash ref");
hv = (HV *)SvRV(ST(1));
memset(&quant, 0, sizeof(quant));
quant.version = 1;
quant.mc_size = 256;
ip_handle_quant_opts(aTHX_ &quant, hv);
RETVAL = i_img_to_pal(src, &quant);
if (RETVAL) {
ip_copy_colors_back(aTHX_ hv, &quant);
}
ip_cleanup_quant_opts(aTHX_ &quant);
OUTPUT:
RETVAL
Imager::ImgRaw
i_img_to_rgb(src)
Imager::ImgRaw src
void
i_img_make_palette(HV *quant_hv, ...)
PREINIT:
size_t count = items - 1;
i_quantize quant;
i_img **imgs = NULL;
ssize_t i;
PPCODE:
if (count <= 0)
croak("Please supply at least one image (%d)", (int)count);
imgs = mymalloc(sizeof(i_img *) * count);
for (i = 0; i < count; ++i) {
SV *img_sv = ST(i + 1);
if (SvROK(img_sv) && sv_derived_from(img_sv, "Imager::ImgRaw")) {
imgs[i] = INT2PTR(i_img *, SvIV((SV*)SvRV(img_sv)));
}
else {
myfree(imgs);
croak("Image %d is not an image object", (int)i+1);
}
}
memset(&quant, 0, sizeof(quant));
quant.version = 1;
quant.mc_size = 256;
ip_handle_quant_opts(aTHX_ &quant, quant_hv);
i_quant_makemap(&quant, imgs, count);
EXTEND(SP, quant.mc_count);
for (i = 0; i < quant.mc_count; ++i) {
SV *sv_c = make_i_color_sv(aTHX_ quant.mc_colors + i);
PUSHs(sv_c);
}
ip_cleanup_quant_opts(aTHX_ &quant);
void
i_gpal(im, l, r, y)
Imager::ImgRaw im
i_img_dim l
i_img_dim r
i_img_dim y
PREINIT:
i_palidx *work;
int count, i;
PPCODE:
if (l < r) {
work = mymalloc((r-l) * sizeof(i_palidx));
count = i_gpal(im, l, r, y, work);
if (GIMME_V == G_ARRAY) {
EXTEND(SP, count);
for (i = 0; i < count; ++i) {
PUSHs(sv_2mortal(newSViv(work[i])));
}
}
else {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv((char *)work, count * sizeof(i_palidx))));
}
myfree(work);
}
else {
if (GIMME_V != G_ARRAY) {
EXTEND(SP, 1);
PUSHs(&PL_sv_undef);
}
}
int
i_ppal(im, l, y, ...)
Imager::ImgRaw im
i_img_dim l
i_img_dim y
PREINIT:
i_palidx *work;
i_img_dim i;
CODE:
if (items > 3) {
work = malloc_temp(aTHX_ sizeof(i_palidx) * (items-3));
for (i=0; i < items-3; ++i) {
work[i] = SvIV(ST(i+3));
}
validate_i_ppal(im, work, items - 3);
RETVAL = i_ppal(im, l, l+items-3, y, work);
}
else {
RETVAL = 0;
}
OUTPUT:
RETVAL
int
i_ppal_p(im, l, y, data)
Imager::ImgRaw im
i_img_dim l
i_img_dim y
SV *data
PREINIT:
i_palidx const *work;
STRLEN len;
CODE:
work = (i_palidx const *)SvPV(data, len);
len /= sizeof(i_palidx);
if (len > 0) {
validate_i_ppal(im, work, len);
RETVAL = i_ppal(im, l, l+len, y, work);
}
else {
RETVAL = 0;
}
OUTPUT:
RETVAL
SV *
i_addcolors(im, ...)
Imager::ImgRaw im
PREINIT:
int index;
i_color *colors;
int i;
CODE:
if (items < 2)
croak("i_addcolors: no colors to add");
colors = mymalloc((items-1) * sizeof(i_color));
for (i=0; i < items-1; ++i) {
if (sv_isobject(ST(i+1))
&& sv_derived_from(ST(i+1), "Imager::Color")) {
IV tmp = SvIV((SV *)SvRV(ST(i+1)));
colors[i] = *INT2PTR(i_color *, tmp);
}
else {
myfree(colors);
croak("i_addcolor: pixels must be Imager::Color objects");
}
}
index = i_addcolors(im, colors, items-1);
myfree(colors);
if (index == 0) {
RETVAL = newSVpv("0 but true", 0);
}
else if (index == -1) {
RETVAL = &PL_sv_undef;
}
else {
RETVAL = newSViv(index);
}
OUTPUT:
RETVAL
undef_int
i_setcolors(im, index, ...)
Imager::ImgRaw im
int index
PREINIT:
i_color *colors;
int i;
CODE:
if (items < 3)
croak("i_setcolors: no colors to add");
colors = mymalloc((items-2) * sizeof(i_color));
for (i=0; i < items-2; ++i) {
if (sv_isobject(ST(i+2))
&& sv_derived_from(ST(i+2), "Imager::Color")) {
IV tmp = SvIV((SV *)SvRV(ST(i+2)));
colors[i] = *INT2PTR(i_color *, tmp);
}
else {
myfree(colors);
croak("i_setcolors: pixels must be Imager::Color objects");
}
}
RETVAL = i_setcolors(im, index, colors, items-2);
myfree(colors);
OUTPUT:
RETVAL
void
i_getcolors(im, index, ...)
Imager::ImgRaw im
int index
PREINIT:
i_color *colors;
int count = 1;
int i;
PPCODE:
if (items > 3)
croak("i_getcolors: too many arguments");
if (items == 3)
count = SvIV(ST(2));
if (count < 1)
croak("i_getcolors: count must be positive");
colors = mymalloc(sizeof(i_color) * count);
if (i_getcolors(im, index, colors, count)) {
for (i = 0; i < count; ++i) {
SV *sv = make_i_color_sv(aTHX_ colors+i);
PUSHs(sv);
}
}
myfree(colors);
undef_neg_int
i_colorcount(im)
Imager::ImgRaw im
undef_neg_int
i_maxcolors(im)
Imager::ImgRaw im
SV *
i_findcolor(im, color)
Imager::ImgRaw im
Imager::Color color
PREINIT:
i_palidx index;
CODE:
if (i_findcolor(im, color, &index)) {
RETVAL = newSViv(index);
}
else {
RETVAL = &PL_sv_undef;
}
OUTPUT:
RETVAL
int
i_img_bits(im)
Imager::ImgRaw im
int
i_img_type(im)
Imager::ImgRaw im
int
i_img_virtual(im)
Imager::ImgRaw im
void
i_gsamp(im, l, r, y, channels)
Imager::ImgRaw im
i_img_dim l
i_img_dim r
i_img_dim y
i_channel_list channels
PREINIT:
i_sample_t *data;
i_img_dim count, i;
PPCODE:
if (l < r) {
data = mymalloc(sizeof(i_sample_t) * (r-l) * channels.count); /* XXX: memleak? */
count = i_gsamp(im, l, r, y, data, channels.channels, channels.count);
if (GIMME_V == G_ARRAY) {
EXTEND(SP, count);
for (i = 0; i < count; ++i)
PUSHs(sv_2mortal(newSViv(data[i])));
}
else {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv((char *)data, count * sizeof(i_sample_t))));
}
myfree(data);
}
else {
if (GIMME_V != G_ARRAY) {
EXTEND(SP, 1);
PUSHs(&PL_sv_undef);
}
}
undef_neg_int
i_gsamp_bits(im, l, r, y, bits, target, offset, channels)
Imager::ImgRaw im
i_img_dim l
i_img_dim r
i_img_dim y
int bits
AV *target
STRLEN offset
i_channel_list channels
PREINIT:
unsigned *data;
i_img_dim count, i;
CODE:
i_clear_error();
if (items < 8)
croak("No channel numbers supplied to g_samp()");
if (l < r) {
data = mymalloc(sizeof(unsigned) * (r-l) * channels.count);
count = i_gsamp_bits(im, l, r, y, data, channels.channels, channels.count, bits);
for (i = 0; i < count; ++i) {
av_store(target, i+offset, newSVuv(data[i]));
}
myfree(data);
RETVAL = count;
}
else {
RETVAL = 0;
}
OUTPUT:
RETVAL
undef_neg_int
i_psamp_bits(im, l, y, bits, channels, data_av, data_offset = 0, pixel_count = -1)
Imager::ImgRaw im
i_img_dim l
i_img_dim y
int bits
i_channel_list channels
AV *data_av
i_img_dim data_offset
i_img_dim pixel_count
PREINIT:
STRLEN data_count;
size_t data_used;
unsigned *data;
ptrdiff_t i;
CODE:
i_clear_error();
data_count = av_len(data_av) + 1;
if (data_offset < 0) {
croak("data_offset must be non-negative");
}
if (data_offset > data_count) {
croak("data_offset greater than number of samples supplied");
}
if (pixel_count == -1 ||
data_offset + pixel_count * channels.count > data_count) {
pixel_count = (data_count - data_offset) / channels.count;
}
data_used = pixel_count * channels.count;
data = mymalloc(sizeof(unsigned) * data_count);
for (i = 0; i < data_used; ++i)
data[i] = SvUV(*av_fetch(data_av, data_offset + i, 0));
RETVAL = i_psamp_bits(im, l, l + pixel_count, y, data, channels.channels,
channels.count, bits);
if (data)
myfree(data);
OUTPUT:
RETVAL
undef_neg_int
i_psamp(im, x, y, channels, data, offset = 0, width = -1)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
i_channel_list channels
i_sample_list data
i_img_dim offset
i_img_dim width
PREINIT:
i_img_dim r;
CODE:
i_clear_error();
if (offset < 0) {
i_push_error(0, "offset must be non-negative");
XSRETURN_UNDEF;
}
if (offset > 0) {
if (offset > data.count) {
i_push_error(0, "offset greater than number of samples supplied");
XSRETURN_UNDEF;
}
data.samples += offset;
data.count -= offset;
}
if (width == -1 ||
width * channels.count > data.count) {
width = data.count / channels.count;
}
r = x + width;
RETVAL = i_psamp(im, x, r, y, data.samples, channels.channels, channels.count);
OUTPUT:
RETVAL
undef_neg_int
i_psampf(im, x, y, channels, data, offset = 0, width = -1)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
i_channel_list channels
i_fsample_list data
i_img_dim offset
i_img_dim width
PREINIT:
i_img_dim r;
CODE:
i_clear_error();
if (offset < 0) {
i_push_error(0, "offset must be non-negative");
XSRETURN_UNDEF;
}
if (offset > 0) {
if (offset > data.count) {
i_push_error(0, "offset greater than number of samples supplied");
XSRETURN_UNDEF;
}
data.samples += offset;
data.count -= offset;
}
if (width == -1 ||
width * channels.count > data.count) {
width = data.count / channels.count;
}
r = x + width;
RETVAL = i_psampf(im, x, r, y, data.samples, channels.channels, channels.count);
OUTPUT:
RETVAL
Imager::ImgRaw
i_img_masked_new(targ, mask, x, y, w, h)
Imager::ImgRaw targ
i_img_dim x
i_img_dim y
i_img_dim w
i_img_dim h
PREINIT:
i_img *mask;
CODE:
if (SvOK(ST(1))) {
if (!sv_isobject(ST(1))
|| !sv_derived_from(ST(1), "Imager::ImgRaw")) {
croak("i_img_masked_new: parameter 2 must undef or an image");
}
mask = INT2PTR(i_img *, SvIV((SV *)SvRV(ST(1))));
}
else
mask = NULL;
RETVAL = i_img_masked_new(targ, mask, x, y, w, h);
OUTPUT:
RETVAL
int
i_plin(im, l, y, ...)
Imager::ImgRaw im
i_img_dim l
i_img_dim y
PREINIT:
i_color *work;
STRLEN i;
STRLEN len;
size_t count;
CODE:
if (items > 3) {
if (items == 4 && SvOK(ST(3)) && !SvROK(ST(3))) {
/* supplied as a byte string */
work = (i_color *)SvPV(ST(3), len);
count = len / sizeof(i_color);
if (count * sizeof(i_color) != len) {
croak("i_plin: length of scalar argument must be multiple of sizeof i_color");
}
RETVAL = i_plin(im, l, l+count, y, work);
}
else {
work = mymalloc(sizeof(i_color) * (items-3));
for (i=0; i < items-3; ++i) {
if (sv_isobject(ST(i+3))
&& sv_derived_from(ST(i+3), "Imager::Color")) {
IV tmp = SvIV((SV *)SvRV(ST(i+3)));
work[i] = *INT2PTR(i_color *, tmp);
}
else {
myfree(work);
croak("i_plin: pixels must be Imager::Color objects");
}
}
RETVAL = i_plin(im, l, l+items-3, y, work);
myfree(work);
}
}
else {
RETVAL = 0;
}
OUTPUT:
RETVAL
int
i_ppixf(im, x, y, cl)
Imager::ImgRaw im
i_img_dim x
i_img_dim y
Imager::Color::Float cl
void
i_gsampf(im, l, r, y, channels)
Imager::ImgRaw im
i_img_dim l
i_img_dim r
i_img_dim y
i_channel_list channels
PREINIT:
i_fsample_t *data;
i_img_dim count, i;
PPCODE:
if (l < r) {
data = mymalloc(sizeof(i_fsample_t) * (r-l) * channels.count);
count = i_gsampf(im, l, r, y, data, channels.channels, channels.count);
if (GIMME_V == G_ARRAY) {
EXTEND(SP, count);
for (i = 0; i < count; ++i)
PUSHs(sv_2mortal(newSVnv(data[i])));
}
else {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv((void *)data, count * sizeof(i_fsample_t))));
}
myfree(data);
}
else {
if (GIMME_V != G_ARRAY) {
EXTEND(SP, 1);
PUSHs(&PL_sv_undef);
}
}
int
i_plinf(im, l, y, ...)
Imager::ImgRaw im
i_img_dim l
i_img_dim y
PREINIT:
i_fcolor *work;
i_img_dim i;
STRLEN len;
size_t count;
CODE:
if (items > 3) {
if (items == 4 && SvOK(ST(3)) && !SvROK(ST(3))) {
/* supplied as a byte string */
work = (i_fcolor *)SvPV(ST(3), len);
count = len / sizeof(i_fcolor);
if (count * sizeof(i_fcolor) != len) {
croak("i_plin: length of scalar argument must be multiple of sizeof i_fcolor");
}
RETVAL = i_plinf(im, l, l+count, y, work);
}
else {
work = mymalloc(sizeof(i_fcolor) * (items-3));
for (i=0; i < items-3; ++i) {
if (sv_isobject(ST(i+3))
&& sv_derived_from(ST(i+3), "Imager::Color::Float")) {
IV tmp = SvIV((SV *)SvRV(ST(i+3)));
work[i] = *INT2PTR(i_fcolor *, tmp);
}
else {
myfree(work);
croak("i_plinf: pixels must be Imager::Color::Float objects");
}
}
/**(char *)0 = 1;*/
RETVAL = i_plinf(im, l, l+items-3, y, work);
myfree(work);
}
}
else {
RETVAL = 0;
}
OUTPUT:
RETVAL
SV *
i_gpixf(im, x, y)
Imager::ImgRaw im
i_img_dim x
i_img_dim y;
PREINIT:
i_fcolor *color;
CODE:
color = (i_fcolor *)mymalloc(sizeof(i_fcolor));
if (i_gpixf(im, x, y, color) == 0) {
RETVAL = NEWSV(0,0);
sv_setref_pv(RETVAL, "Imager::Color::Float", (void *)color);
}
else {
myfree(color);
RETVAL = &PL_sv_undef;
}
OUTPUT:
RETVAL
void
i_glin(im, l, r, y)
Imager::ImgRaw im
i_img_dim l
i_img_dim r
i_img_dim y
PREINIT:
i_color *vals;
i_img_dim count, i;
PPCODE:
if (l < r) {
vals = mymalloc((r-l) * sizeof(i_color));
memset(vals, 0, (r-l) * sizeof(i_color));
count = i_glin(im, l, r, y, vals);
if (GIMME_V == G_ARRAY) {
EXTEND(SP, count);
for (i = 0; i < count; ++i) {
SV *sv = make_i_color_sv(aTHX_ vals+i);
PUSHs(sv);
}
}
else if (count) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv((void *)vals, count * sizeof(i_color))));
}
myfree(vals);
}
void
i_glinf(im, l, r, y)
Imager::ImgRaw im
i_img_dim l
i_img_dim r
i_img_dim y
PREINIT:
i_fcolor *vals;
i_img_dim count, i;
i_fcolor zero;
PPCODE:
for (i = 0; i < MAXCHANNELS; ++i)
zero.channel[i] = 0;
if (l < r) {
vals = mymalloc((r-l) * sizeof(i_fcolor));
for (i = 0; i < r-l; ++i)
vals[i] = zero;
count = i_glinf(im, l, r, y, vals);
if (GIMME_V == G_ARRAY) {
EXTEND(SP, count);
for (i = 0; i < count; ++i) {
SV *sv;
i_fcolor *col = mymalloc(sizeof(i_fcolor));
*col = vals[i];
sv = sv_newmortal();
sv_setref_pv(sv, "Imager::Color::Float", (void *)col);
PUSHs(sv);
}
}
else if (count) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv((void *)vals, count * sizeof(i_fcolor))));
}
myfree(vals);
}
Imager::ImgRaw
i_img_8_new(x, y, ch)
i_img_dim x
i_img_dim y
int ch
Imager::ImgRaw
i_img_16_new(x, y, ch)
i_img_dim x
i_img_dim y
int ch
Imager::ImgRaw
i_img_to_rgb16(im)
Imager::ImgRaw im
Imager::ImgRaw
i_img_double_new(x, y, ch)
i_img_dim x
i_img_dim y
int ch
Imager::ImgRaw
i_img_to_drgb(im)
Imager::ImgRaw im
undef_int
i_tags_addn(im, name, code, idata)
Imager::ImgRaw im
int code
int idata
PREINIT:
char *name;
STRLEN len;
CODE:
if (SvOK(ST(1)))
name = SvPV(ST(1), len);
else
name = NULL;
RETVAL = i_tags_addn(&im->tags, name, code, idata);
OUTPUT:
RETVAL
undef_int
i_tags_add(im, name, code, data, idata)
Imager::ImgRaw im
int code
int idata
PREINIT:
char *name;
char *data;
STRLEN len;
CODE:
if (SvOK(ST(1)))
name = SvPV(ST(1), len);
else
name = NULL;
if (SvOK(ST(3)))
data = SvPV(ST(3), len);
else {
data = NULL;
len = 0;
}
RETVAL = i_tags_add(&im->tags, name, code, data, len, idata);
OUTPUT:
RETVAL
SV *
i_tags_find(im, name, start)
Imager::ImgRaw im
char *name
int start
PREINIT:
int entry;
CODE:
if (i_tags_find(&im->tags, name, start, &entry)) {
if (entry == 0)
RETVAL = newSVpv("0 but true", 0);
else
RETVAL = newSViv(entry);
} else {
RETVAL = &PL_sv_undef;
}
OUTPUT:
RETVAL
SV *
i_tags_findn(im, code, start)
Imager::ImgRaw im
int code
int start
PREINIT:
int entry;
CODE:
if (i_tags_findn(&im->tags, code, start, &entry)) {
if (entry == 0)
RETVAL = newSVpv("0 but true", 0);
else
RETVAL = newSViv(entry);
}
else {
RETVAL = &PL_sv_undef;
}
OUTPUT:
RETVAL
int
i_tags_delete(im, entry)
Imager::ImgRaw im
int entry
CODE:
RETVAL = i_tags_delete(&im->tags, entry);
OUTPUT:
RETVAL
int
i_tags_delbyname(im, name)
Imager::ImgRaw im
char * name
CODE:
RETVAL = i_tags_delbyname(&im->tags, name);
OUTPUT:
RETVAL
int
i_tags_delbycode(im, code)
Imager::ImgRaw im
int code
CODE:
RETVAL = i_tags_delbycode(&im->tags, code);
OUTPUT:
RETVAL
void
i_tags_get(im, index)
Imager::ImgRaw im
int index
PPCODE:
if (index >= 0 && index < im->tags.count) {
i_img_tag *entry = im->tags.tags + index;
EXTEND(SP, 5);
if (entry->name) {
PUSHs(sv_2mortal(newSVpv(entry->name, 0)));
}
else {
PUSHs(sv_2mortal(newSViv(entry->code)));
}
if (entry->data) {
PUSHs(sv_2mortal(newSVpvn(entry->data, entry->size)));
}
else {
PUSHs(sv_2mortal(newSViv(entry->idata)));
}
}
void
i_tags_get_string(im, what_sv)
Imager::ImgRaw im
SV *what_sv
PREINIT:
char const *name = NULL;
int code;
char buffer[200];
PPCODE:
if (SvIOK(what_sv)) {
code = SvIV(what_sv);
name = NULL;
}
else {
name = SvPV_nolen(what_sv);
code = 0;
}
if (i_tags_get_string(&im->tags, name, code, buffer, sizeof(buffer))) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv(buffer, 0)));
}
int
i_tags_count(im)
Imager::ImgRaw im
CODE:
RETVAL = im->tags.count;
OUTPUT:
RETVAL
MODULE = Imager PACKAGE = Imager::FillHandle PREFIX=IFILL_
void
IFILL_DESTROY(fill)
Imager::FillHandle fill
int
IFILL_CLONE_SKIP(...)
CODE:
(void)items; /* avoid unused warning for XS variable */
RETVAL = 1;
OUTPUT:
RETVAL
MODULE = Imager PACKAGE = Imager
Imager::FillHandle
i_new_fill_solid(cl, combine)
Imager::Color cl
int combine
Imager::FillHandle
i_new_fill_solidf(cl, combine)
Imager::Color::Float cl
int combine
Imager::FillHandle
i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy)
Imager::Color fg
Imager::Color bg
int combine
int hatch
i_img_dim dx
i_img_dim dy
PREINIT:
unsigned char *cust_hatch;
STRLEN len;
CODE:
if (SvOK(ST(4))) {
cust_hatch = (unsigned char *)SvPV(ST(4), len);
}
else
cust_hatch = NULL;
RETVAL = i_new_fill_hatch(fg, bg, combine, hatch, cust_hatch, dx, dy);
OUTPUT:
RETVAL
Imager::FillHandle
i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy)
Imager::Color::Float fg
Imager::Color::Float bg
int combine
int hatch
i_img_dim dx
i_img_dim dy
PREINIT:
unsigned char *cust_hatch;
STRLEN len;
CODE:
if (SvOK(ST(4))) {
cust_hatch = (unsigned char *)SvPV(ST(4), len);
}
else
cust_hatch = NULL;
RETVAL = i_new_fill_hatchf(fg, bg, combine, hatch, cust_hatch, dx, dy);
OUTPUT:
RETVAL
Imager::FillHandle
i_new_fill_image(src, matrix, xoff, yoff, combine)
Imager::ImgRaw src
i_img_dim xoff
i_img_dim yoff
int combine
PREINIT:
double matrix[9];
double *matrixp;
AV *av;
IV len;
SV *sv1;
int i;
CODE:
if (!SvOK(ST(1))) {
matrixp = NULL;
}
else {
if (!SvROK(ST(1)) || SvTYPE(SvRV(ST(1))) != SVt_PVAV)
croak("i_new_fill_image: parameter must be an arrayref");
av=(AV*)SvRV(ST(1));
len=av_len(av)+1;
if (len > 9)
len = 9;
for (i = 0; i < len; ++i) {
sv1=(*(av_fetch(av,i,0)));
matrix[i] = SvNV(sv1);
}
for (; i < 9; ++i)
matrix[i] = 0;
matrixp = matrix;
}
RETVAL = i_new_fill_image(src, matrixp, xoff, yoff, combine);
OUTPUT:
RETVAL
MODULE = Imager PACKAGE = Imager::Internal::Hlines PREFIX=i_int_hlines_
# this class is only exposed for testing
int
i_int_hlines_testing()
#if i_int_hlines_testing()
Imager::Internal::Hlines
i_int_hlines_new(start_y, count_y, start_x, count_x)
i_img_dim start_y
int count_y
i_img_dim start_x
int count_x
Imager::Internal::Hlines
i_int_hlines_new_img(im)
Imager::ImgRaw im
void
i_int_hlines_add(hlines, y, minx, width)
Imager::Internal::Hlines hlines
i_img_dim y
i_img_dim minx
i_img_dim width
void
i_int_hlines_DESTROY(hlines)
Imager::Internal::Hlines hlines
SV *
i_int_hlines_dump(hlines)
Imager::Internal::Hlines hlines
int
i_int_hlines_CLONE_SKIP(cls)
#endif
BOOT:
PERL_SET_GLOBAL_CALLBACKS;
PERL_PL_SET_GLOBAL_CALLBACKS;
Jump to Line
Something went wrong with that request. Please try again.