Imager
view release on metacpan or search on metacpan
}
typedef i_trim_color_list Imager__TrimColorList;
#define trim_color_list_count(t) ((t).count)
#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
typedef int SysRet;
#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'
#define ICL_red(c) ((c)->rgba.r)
#define ICL_green(c) ((c)->rgba.g)
#define ICL_blue(c) ((c)->rgba.b)
#define ICL_alpha(c) ((c)->rgba.a)
#define ICLF_red(c) ((c)->rgba.r)
#define ICLF_green(c) ((c)->rgba.g)
#define ICLF_blue(c) ((c)->rgba.b)
#define ICLF_alpha(c) ((c)->rgba.a)
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:
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:
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
int
ICL_red(c)
Imager::Color c
int
ICL_green(c)
Imager::Color c
int
ICL_blue(c)
Imager::Color c
int
ICL_alpha(c)
Imager::Color c
MODULE = Imager PACKAGE = Imager::Color::Float PREFIX=ICLF_
Imager::Color::Float
ICLF_new_internal(r, g, b, a)
im_double r
im_double g
im_double b
im_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
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
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
double
ICLF_red(c)
Imager::Color::Float c
double
ICLF_green(c)
Imager::Color::Float c
double
ICLF_blue(c)
Imager::Color::Float c
double
ICLF_alpha(c)
Imager::Color::Float c
MODULE = Imager PACKAGE = Imager::ImgRaw PREFIX = IIM_
Imager::ImgRaw
IIM_new(xsize,ysize,ch)
i_img_dim xsize
i_img_dim ysize
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:
i_clear_error();
RETVAL = do_io_new_buffer(aTHX_ data_sv);
if (!RETVAL)
XSRETURN(0);
OUTPUT:
RETVAL
Imager::IO
io_new_cb(writecb, readcb, seekcb, closecb, maxwrite = CBDATA_BUFSIZE)
SV *writecb;
SV *readcb;
SV *seekcb;
SV *closecb;
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
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_
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:
i_clear_error();
RETVAL = do_io_new_buffer(aTHX_ data_sv);
if (!RETVAL)
XSRETURN(0);
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
Imager::IO
io__new_perlio(class, io)
PerlIO *io
CODE:
RETVAL = im_io_new_perlio(aTHX_ io);
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:
data = SvPVbyte(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
void
i_io_nextc(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:
data = SvPVbyte(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
int
i_img_color_model(im)
Imager::ImgRaw im
int
i_img_color_channels(im)
Imager::ImgRaw im
int
i_img_alpha_channel(im)
Imager::ImgRaw im
CODE:
if (!i_img_alpha_channel(im, &RETVAL))
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_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
Imager::ImgRaw im
im_double x
im_double y
im_double rad
Imager::Color val
void
i_circle_aa_fill(im,x,y,rad,fill)
Imager::ImgRaw im
im_double x
im_double y
im_double rad
Imager::FillHandle fill
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
im_double d1
im_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
im_double d1
im_double d2
Imager::Color val
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::Color val
PREINIT:
STRLEN size_x;
STRLEN size_y;
CODE:
if (size_x != size_y)
croak("Imager: x and y arrays to i_poly_aa must be equal length\n");
RETVAL = i_poly_aa_m(im, size_x, x, y, mode, val);
OUTPUT:
RETVAL
int
i_poly_aa_cfill_m(im, x, y, mode, fill)
Imager::ImgRaw im
double *x
double *y
i_poly_fill_mode_t mode
Imager::FillHandle fill
PREINIT:
STRLEN size_x;
STRLEN size_y;
CODE:
if (size_x != size_y)
croak("Imager: x and y arrays to i_poly_aa_cfill must be equal length\n");
RETVAL = i_poly_aa_cfill_m(im, size_x, x, y, mode, fill);
OUTPUT:
RETVAL
int
i_poly_poly_aa(im, polys, mode, color)
Imager::ImgRaw im
i_polygon_list polys
i_poly_fill_mode_t mode
Imager::Color color
CODE:
RETVAL = i_poly_poly_aa(im, polys.count, polys.polygons, mode, color);
OUTPUT:
RETVAL
int
i_poly_poly_aa_cfill(im, polys, mode, fill)
Imager::ImgRaw im
i_polygon_list polys
i_poly_fill_mode_t mode
Imager::FillHandle fill
CODE:
RETVAL = i_poly_poly_aa_cfill(im, polys.count, polys.polygons, mode, fill);
OUTPUT:
RETVAL
Imager::Color cl
im_double points
SV * str_sv
int smooth
int utf8
int align
PREINIT:
char *str;
STRLEN len;
CODE:
str = SvPV(str_sv, len);
#ifdef SvUTF8
if (SvUTF8(str_sv))
utf8 = 1;
#endif
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,smooth,utf8,align=1)
Imager::Font::TT handle
Imager::ImgRaw im
i_img_dim xb
i_img_dim yb
int channel
im_double points
SV * str_sv
int smooth
int utf8
int align
PREINIT:
char *str;
STRLEN len;
CODE:
str = SvPV(str_sv, len);
#ifdef SvUTF8
if (SvUTF8(str_sv))
utf8 = 1;
#endif
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,utf8)
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])));
}
}
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:
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) {
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:
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) {
ch = i_utf8_advance(&text, &len);
if (ch == ~0UL) {
i_push_error(0, "invalid UTF8 character");
XSRETURN_EMPTY;
}
}
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
int
i_add_file_magic(name, bits_sv, mask_sv)
const char *name
SV *bits_sv
SV *mask_sv
PREINIT:
const unsigned char *bits;
const unsigned char *mask;
size_t bits_size;
size_t mask_size;
CODE:
i_clear_error();
bits = (const unsigned char *)SvPV(bits_sv, bits_size);
mask = (const unsigned char *)SvPV(mask_sv, mask_size);
if (bits_size == 0) {
i_push_error(0, "bits must be non-empty");
XSRETURN_EMPTY;
}
if (mask_size == 0) {
i_push_error(0, "mask must be non-empty");
XSRETURN_EMPTY;
}
if (bits_size != mask_size) {
i_push_error(0, "bits and mask must be the same length");
XSRETURN_EMPTY;
}
if (!*name) {
i_push_error(0, "name must be non-empty");
XSRETURN_EMPTY;
}
RETVAL = i_add_file_magic(name, bits, mask, bits_size);
OUTPUT:
RETVAL
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
im_double Value
int Axis
Imager::ImgRaw
i_scale_nn(im,scx,scy)
Imager::ImgRaw im
im_double scx
im_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);
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)
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);
int type
int repeat
int combine
int super_sample
im_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)
im_double xa
im_double ya
im_double xb
im_double yb
int type
int repeat
int combine
int super_sample
im_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
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)) {
SvREFCNT_dec(sv);
}
XPUSHs(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 = malloc_temp(aTHX_ sizeof(i_img_dim) * num );
yo = malloc_temp(aTHX_ sizeof(i_img_dim) * num );
ival = malloc_temp(aTHX_ 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
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));
if (i_gpix(im, x, y, RETVAL) != 0) {
myfree(RETVAL);
XSRETURN_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_hv)
Imager::ImgRaw src
HV *quant_hv
PREINIT:
HV *hv;
i_quantize quant;
CODE:
memset(&quant, 0, sizeof(quant));
quant.version = 1;
quant.mc_size = 256;
i_clear_error();
if (!ip_handle_quant_opts2(aTHX_ &quant, quant_hv)) {
XSRETURN_EMPTY;
}
RETVAL = i_img_to_pal(src, &quant);
if (RETVAL) {
ip_copy_colors_back(aTHX_ quant_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 = 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);
}
}
memset(&quant, 0, sizeof(quant));
quant.version = 1;
quant.mc_size = 256;
if (!ip_handle_quant_opts2(aTHX_ &quant, quant_hv)) {
XSRETURN_EMPTY;
}
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_mortal(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);
i_addcolors(im, ...)
Imager::ImgRaw im
PREINIT:
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");
}
}
RETVAL = i_addcolors(im, colors, items-1);
myfree(colors);
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, 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);
}
}
undef_neg_int
i_colorcount(im)
Imager::ImgRaw im
undef_neg_int
i_maxcolors(im)
Imager::ImgRaw im
i_palidx
i_findcolor(im, color)
Imager::ImgRaw im
Imager::Color color
CODE:
if (!i_findcolor(im, color, &RETVAL)) {
XSRETURN_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);
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) {
XSRETURN_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_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) {
XSRETURN_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
Imager::Color::Float
i_gpixf(im, x, y)
Imager::ImgRaw im
i_img_dim x
i_img_dim y;
CODE:
RETVAL = (i_fcolor *)mymalloc(sizeof(i_fcolor));
memset(RETVAL, 0, sizeof(*RETVAL));
if (i_gpixf(im, x, y, RETVAL) != 0) {
myfree(RETVAL);
XSRETURN_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_mortal(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 = make_i_fcolor_sv(aTHX_ vals+i);
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(xsize, ysize, channels)
i_img_dim xsize
i_img_dim ysize
int channels
Imager::ImgRaw
i_img_16_new(xsize, ysize, channels)
i_img_dim xsize
i_img_dim ysize
int channels
Imager::ImgRaw
i_img_to_rgb16(im)
Imager::ImgRaw im
Imager::ImgRaw
i_img_double_new(xsize, ysize, channels)
i_img_dim xsize
i_img_dim ysize
int channels
Imager::ImgRaw
i_img_to_drgb(im)
Imager::ImgRaw im
undef_int
i_tags_addn(im, name_sv, code, idata)
Imager::ImgRaw im
SV *name_sv
int code
int idata
PREINIT:
char *name;
STRLEN len;
CODE:
SvGETMAGIC(name_sv);
if (SvOK(name_sv))
name = SvPV_nomg(name_sv, len);
int start
PREINIT:
int entry;
CODE:
if (i_tags_find(&im->tags, name, start, &entry)) {
RETVAL = entry;
} else {
XSRETURN_UNDEF;
}
OUTPUT:
RETVAL
SysRet
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)) {
RETVAL = entry;
}
else {
XSRETURN_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_sv, dx, dy)
Imager::Color fg
Imager::Color bg
int combine
int hatch
SV *cust_hatch_sv
i_img_dim dx
i_img_dim dy
PREINIT:
unsigned char *cust_hatch;
( run in 0.767 second using v1.01-cache-2.11-cpan-5511b514fd6 )