Imager
view release on metacpan or search on metacpan
double cheight
double cwidth
SV *text_sv
int utf8
PREINIT:
i_img_dim bbox[BOUNDING_BOX_COUNT];
int i;
char *text;
STRLEN text_len;
int rc;
PPCODE:
text = SvPV(text_sv, text_len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
rc = i_ft2_bbox(font, cheight, cwidth, text, text_len, bbox, utf8);
if (rc) {
EXTEND(SP, rc);
for (i = 0; i < rc; ++i)
PUSHs(sv_2mortal(newSViv(bbox[i])));
double cheight
double cwidth
SV *text_sv
int vlayout
int utf8
PREINIT:
i_img_dim bbox[8];
int i;
const char *text;
STRLEN len;
PPCODE:
text = SvPV(text_sv, len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
if (i_ft2_bbox_r(font, cheight, cwidth, text, len, vlayout,
utf8, bbox)) {
EXTEND(SP, 8);
for (i = 0; i < 8; ++i)
PUSHs(sv_2mortal(newSViv(bbox[i])));
void
ft2_transform_box(font, x0, x1, x2, x3)
Imager::Font::FT2x font
i_img_dim x0
i_img_dim x1
i_img_dim x2
i_img_dim x3
PREINIT:
i_img_dim box[4];
PPCODE:
box[0] = x0; box[1] = x1; box[2] = x2; box[3] = x3;
ft2_transform_box(font, box);
EXTEND(SP, 4);
PUSHs(sv_2mortal(newSViv(box[0])));
PUSHs(sv_2mortal(newSViv(box[1])));
PUSHs(sv_2mortal(newSViv(box[2])));
PUSHs(sv_2mortal(newSViv(box[3])));
void
i_ft2_has_chars(handle, text_sv, utf8)
Imager::Font::FT2x handle
SV *text_sv
int utf8
PREINIT:
char *text;
STRLEN len;
char *work;
size_t count;
size_t i;
PPCODE:
text = SvPV(text_sv, len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
work = mymalloc(len);
count = i_ft2_has_chars(handle, text, len, utf8, work);
if (GIMME_V == G_ARRAY) {
if (count) {
EXTEND(SP, count);
PUSHs(sv_2mortal(newSVpv(work, count)));
}
myfree(work);
void
i_ft2_face_name(handle)
Imager::Font::FT2x handle
PREINIT:
char name[255];
size_t len;
PPCODE:
len = i_ft2_face_name(handle, name, sizeof(name));
if (len) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv(name, 0)));
}
undef_int
i_ft2_can_face_name()
void
Imager::Font::FT2x handle
SV *text_sv
int utf8
int reliable_only
PREINIT:
char const *text;
STRLEN work_len;
size_t len;
char name[255];
SSize_t count = 0;
PPCODE:
i_clear_error();
text = SvPV(text_sv, work_len);
len = work_len;
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
while (len) {
unsigned long ch;
if (utf8) {
int
i_ft2_is_multiple_master(handle)
Imager::Font::FT2x handle
void
i_ft2_get_multiple_masters(handle)
Imager::Font::FT2x handle
PREINIT:
i_font_mm mm;
int i;
PPCODE:
if (i_ft2_get_multiple_masters(handle, &mm)) {
EXTEND(SP, 2+mm.num_axis);
PUSHs(sv_2mortal(newSViv(mm.num_axis)));
PUSHs(sv_2mortal(newSViv(mm.num_designs)));
for (i = 0; i < mm.num_axis; ++i) {
AV *av = newAV();
SV *sv;
av_extend(av, 3);
sv = newSVpv(mm.axis[i].name, strlen(mm.axis[i].name));
SvREFCNT_inc(sv);
void
i_readgif_wiol(ig)
Imager::IO ig
PREINIT:
int* colour_table;
int colours, q, w;
i_img* rimg;
SV* temp[3];
AV* ct;
SV* r;
PPCODE:
colour_table = NULL;
colours = 0;
if(GIMME_V == G_ARRAY) {
rimg = i_readgif_wiol(ig,&colour_table,&colours);
} else {
/* don't waste time with colours if they aren't wanted */
rimg = i_readgif_wiol(ig,NULL,NULL);
}
Imager::IO ig
int page
void
i_readgif_multi_wiol(ig)
Imager::IO ig
PREINIT:
i_img **imgs;
int count;
int i;
PPCODE:
imgs = i_readgif_multi_wiol(ig, &count);
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);
}
void
i_readico_multi(ig, masked = 0, alpha_masked = 0)
Imager::IO ig
bool masked
bool alpha_masked
PREINIT:
i_img **imgs;
int count;
int i;
PPCODE:
imgs = i_readico_multi(ig, &count, masked, alpha_masked);
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);
}
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:
cl->rgba.r = r;
cl->rgba.g = g;
cl->rgba.b = b;
cl->rgba.a = 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(newSViv(cl->rgba.r)));
PUSHs(sv_2mortal(newSViv(cl->rgba.g)));
PUSHs(sv_2mortal(newSViv(cl->rgba.b)));
PUSHs(sv_2mortal(newSViv(cl->rgba.a)));
Imager::Color
i_hsv_to_rgb(c)
Imager::Color c
CODE:
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
im_double r
im_double g
im_double b
im_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
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
void
i_trim_rect(Imager::ImgRaw im, double transp_threshold, Imager::TrimColorList cls)
PREINIT:
i_img_dim left, top, right, bottom;
PPCODE:
if (!i_trim_rect(im, transp_threshold, cls.count, cls.colors, &left, &top, &right, &bottom))
XSRETURN(0);
EXTEND(SP, 4);
PUSHs(newSViv(left));
PUSHs(newSViv(top));
PUSHs(newSViv(right));
PUSHs(newSViv(bottom));
MODULE = Imager PACKAGE = Imager::IO PREFIX = io_
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);
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);
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));
}
}
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);
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);
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);
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
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])));
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
XSRETURN(0);
OUTPUT:
RETVAL
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_bezier_multi(im,x,y,val)
Imager::ImgRaw im
double *x
double *y
Imager::Color val
PREINIT:
STRLEN size_x;
STRLEN size_y;
PPCODE:
if (size_x != size_y)
croak("Imager: x and y arrays to i_bezier_multi must be equal length\n");
i_bezier_multi(im,size_x,x,y,val);
int
i_poly_aa_m(im,x,y,mode,val)
Imager::ImgRaw im
double *x
double *y
i_poly_fill_mode_t mode
Imager::Font::TT handle
im_double point
SV* str_sv
int utf8
PREINIT:
i_img_dim cords[BOUNDING_BOX_COUNT];
int rc;
char * str;
STRLEN len;
int i;
PPCODE:
str = SvPV(str_sv, len);
#ifdef SvUTF8
if (SvUTF8(ST(2)))
utf8 = 1;
#endif
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])));
}
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:
i_clear_error();
text = SvPV(text_sv, len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
work = mymalloc(len);
count = i_tt_has_chars(handle, text, len, utf8, work);
if (GIMME_V == G_ARRAY) {
if (count) {
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:
i_clear_error();
text = SvPV(text_sv, work_len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
len = work_len;
while (len) {
unsigned long ch;
if (utf8) {
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);
}
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);
if (col_cnt <= 0) {
XSRETURN_EMPTY;
}
EXTEND(SP, col_cnt);
for (i = 0; i < col_cnt; i++) {
PUSHs(sv_2mortal(newSViv( col_usage[i])));
}
myfree(col_usage);
void
i_transform(im, opx, opy, parm)
Imager::ImgRaw im
int *opx
int *opy
double *parm
PREINIT:
STRLEN size_opx, size_opy, size_parm;
i_img *result;
PPCODE:
result=i_transform(im,opx,size_opx,opy,size_opy,parm,size_parm);
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)
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*));
Imager::FillHandle other_fill
im_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)) {
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))));
}
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
HV *hv
PPCODE:
DSO_call( (DSO_handle *)handle,func_index,hv);
Imager::Color
i_get_pixel(im, x, y)
Imager::ImgRaw im
i_img_dim x
i_img_dim y;
CODE:
RETVAL = (i_color *)mymalloc(sizeof(i_color));
memset(RETVAL, 0, sizeof(*RETVAL));
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 = malloc_temp(aTHX_ count * sizeof(i_img *));
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 {
croak("Image %d is not an image object", (int)i+1);
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 {
RETVAL
void
i_getcolors(im, index, count=1)
Imager::ImgRaw im
int index
int count
PREINIT:
i_color *colors;
int i;
PPCODE:
if (count < 1)
croak("i_getcolors: count must be positive");
colors = malloc_temp(aTHX_ sizeof(i_color) * count);
if (i_getcolors(im, index, colors, count)) {
EXTEND(SP, count);
for (i = 0; i < count; ++i) {
SV *sv = make_i_color_sv_mortal(aTHX_ colors+i);
PUSHs(sv);
}
}
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);
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);
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);
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_mortal(aTHX_ vals+i);
PUSHs(sv);
}
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) {
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)));
}
}
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);
JPEG/JPEG.xs view on Meta::CPAN
void
i_readjpeg_wiol(ig)
Imager::IO ig
PREINIT:
char* iptc_itext;
int tlength;
i_img* rimg;
SV* r;
PPCODE:
iptc_itext = NULL;
rimg = i_readjpeg_wiol(ig,-1,&iptc_itext,&tlength);
if (iptc_itext == NULL) {
r = sv_newmortal();
EXTEND(SP,1);
sv_setref_pv(r, "Imager::ImgRaw", (void*)rimg);
PUSHs(r);
} else {
r = sv_newmortal();
EXTEND(SP,2);
unsigned
i_png_lib_version()
MODULE = Imager::File::PNG PACKAGE = Imager::File::PNG PREFIX=i_png_
void
i_png_features(...)
PREINIT:
const char * const *p;
PPCODE:
p = i_png_features();
while (*p) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv(*p, 0)));
++p;
}
int
IMPNG_READ_IGNORE_BENIGN_ERRORS()
CODE:
double point
SV* str_sv
int utf8
char* flags
PREINIT:
const char *str;
STRLEN len;
i_img_dim cords[BOUNDING_BOX_COUNT];
int i;
int rc;
PPCODE:
str = SvPV(str_sv, len);
#ifdef SvUTF8
if (SvUTF8(str_sv))
utf8 = 1;
#endif
rc = i_t1_bbox(fontnum,point,str,len,cords,utf8,flags);
if (rc > 0) {
EXTEND(SP, rc);
for (i = 0; i < rc; ++i)
PUSHs(sv_2mortal(newSViv(cords[i])));
i_t1_has_chars(font, text_sv, utf8 = 0)
Imager::Font::T1xs font
SV *text_sv
int utf8
PREINIT:
char const *text;
STRLEN len;
char *work;
int count;
int i;
PPCODE:
text = SvPV(text_sv, len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
work = mymalloc(len);
count = i_t1_has_chars(font, text, len, utf8, work);
if (GIMME_V == G_ARRAY) {
EXTEND(SP, count);
PUSHs(sv_2mortal(newSVpv(work, count)));
}
myfree(work);
void
i_t1_face_name(font)
Imager::Font::T1xs font
PREINIT:
char name[255];
int len;
PPCODE:
len = i_t1_face_name(font, name, sizeof(name));
if (len) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVpv(name, strlen(name))));
}
void
i_t1_glyph_names(font, text_sv, utf8 = 0)
Imager::Font::T1xs font
SV *text_sv
int utf8
PREINIT:
char const *text;
STRLEN work_len;
size_t len;
char name[255];
SSize_t count = 0;
PPCODE:
text = SvPV(text_sv, work_len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
i_clear_error();
len = work_len;
while (len) {
unsigned long ch;
if (utf8) {
TIFF/TIFF.xs view on Meta::CPAN
int allow_incomplete
int page
void
i_readtiff_multi_wiol(ig)
Imager::IO ig
PREINIT:
i_img **imgs;
int count;
int i;
PPCODE:
imgs = i_readtiff_multi_wiol(ig, &count);
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);
}
TIFF/TIFF.xs view on Meta::CPAN
const char *
i_tiff_buildversion(...)
C_ARGS:
const char *
i_tiff_libversion(...)
C_ARGS:
void
i_tiff_codecs(class)
PPCODE:
size_t count;
i_tiff_codec *codecs = i_tiff_get_codecs(&count);
EXTEND(SP, count);
for (int i = 0; i < count; ++i) {
i_tiff_codec *codec = codecs + i;
HV *hv = newHV();
hv_stores(hv, "description", newSVpvn(codec->description, strlen(codec->description)));
hv_stores(hv, "name", newSVpv(codec->name, 0));
hv_stores(hv, "code", newSViv(codec->code));
SV *rv = newRV_noinc((SV*)hv);
i_wf_bbox(face, size, text_sv, utf8=0)
const char *face
i_img_dim size
SV *text_sv
int utf8
PREINIT:
i_img_dim cords[BOUNDING_BOX_COUNT];
int rc, i;
char const *text;
STRLEN text_len;
PPCODE:
text = SvPV(text_sv, text_len);
#ifdef SvUTF8
if (SvUTF8(text_sv))
utf8 = 1;
#endif
if (rc = i_wf_bbox(face, size, text, text_len, cords, utf8)) {
EXTEND(SP, rc);
for (i = 0; i < rc; ++i)
PUSHs(sv_2mortal(newSViv(cords[i])));
}
( run in 2.739 seconds using v1.01-cache-2.11-cpan-5511b514fd6 )