Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 1.509 )
Net-addrinfo
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Net-ext
view release on metacpan or search on metacpan
SV * address
PREINIT:
struct sockaddr_in sin;
char * adata;
STRLEN adlen;
PPCODE:
Zero(&sin, sizeof sin, char);
sin.sin_family = family;
adata = SvPV(address, adlen);
sin.sin_port = htons(port);
if (adlen == sizeof sin.sin_addr) {
SV * sad
PREINIT:
char * cp;
struct sockaddr_in sin;
STRLEN len;
PPCODE:
if ((cp = SvPV(sad, len)) != (char*)0 && len >= sizeof sin) {
U16 family;
U16 port;
char * adata;
STRLEN addrlen;
SV * address
PREINIT:
struct sockaddr sad;
char * adata;
STRLEN adlen;
PPCODE:
Zero(&sad, sizeof sad, char);
sad.sa_family = family;
adata = SvPV(address, adlen);
if (adlen > sizeof(sad.sa_data)) {
SV * rval = sv_newmortal();
unpack_sockaddr(sad)
SV * sad
PREINIT:
char * cp;
STRLEN len;
PPCODE:
if ((cp = SvPV(sad, len)) != (char*)0) {
struct sockaddr sa;
U16 family;
SV * famsv;
SV * datsv;
Net-mbedTLS
view release on metacpan or search on metacpan
OUTPUT:
RETVAL
void
peer_certificates (SV* peer_obj)
PPCODE:
if (GIMME_V != G_ARRAY) croak("List context only!");
xs_connection* myconn = (xs_connection*) SvPVX( SvRV(peer_obj) );
const mbedtls_x509_crt* crt = mbedtls_ssl_get_peer_cert(&myconn->ssl);
NetAddr-IP
view release on metacpan or search on metacpan
Lite/Util/Util.xs view on Meta::CPAN
unsigned char * ap;
char * subname;
u_int32_t wa[4];
STRLEN len;
int i;
PPCODE:
ap = (unsigned char *) SvPV(s,len);
if (len != 16) {
if (ix == 2)
subname = is_ipv6to4;
else if (ix == 1)
Lite/Util/Util.xs view on Meta::CPAN
unsigned char * ap, *bp;
char * subname;
u_int32_t wa[4], wb[4];
n128 a128;
STRLEN len;
PPCODE:
ap = (unsigned char *) SvPV(as,len);
if (len != 16) {
Bail:
if (ix == 1)
subname = is_sub128;
Lite/Util/Util.xs view on Meta::CPAN
PREINIT:
n128 a128;
unsigned char * ap;
u_int32_t wa[4], wb[4];
STRLEN len;
PPCODE:
ap = (unsigned char *) SvPV(s,len);
if (len != 16) {
croak("Bad arg length for %s, length is %d, should be %d",
"NetAddr::IP::Util::addconst",len *8,128);
}
Lite/Util/Util.xs view on Meta::CPAN
NetAddr::IP::Util::bin2bcdn = 1
PREINIT:
BCD n;
unsigned char * cp;
STRLEN len;
PPCODE:
cp = (unsigned char *) SvPV(s,len);
if (ix == 0) {
if (len != 16) {
croak("Bad arg length for %s, length is %d, should be %d",
"NetAddr::IP::Util::bin2bcd",len *8,128);
Lite/Util/Util.xs view on Meta::CPAN
BCD n;
n128 c128, a128;
unsigned char * cp, badc;
char * subname;
STRLEN len;
PPCODE:
cp = (unsigned char *) SvPV(s,len);
if (len > 40) {
if (ix == 0)
subname = is_bcd2bin;
else if (ix ==1)
Lite/Util/Util.xs view on Meta::CPAN
SV * s
PREINIT:
unsigned char * ap, count;
u_int32_t wa[4];
STRLEN len;
PPCODE:
ap = (unsigned char *) SvPV(s,len);
if (len != 16) {
croak("Bad arg length for %s, length is %d, should be %d",
"NetAddr::IP::Util::countbits",len *8,128);
}
Lite/Util/Util.xs view on Meta::CPAN
PREINIT:
unsigned char * ip;
char * subname;
u_int32_t wa[4];
STRLEN len;
PPCODE:
ip = (unsigned char *) SvPV(s,len);
if (len != 4) {
if (ix == 1)
subname = is_mask4to6;
else
Lite/Util/Util.xs view on Meta::CPAN
PREINIT:
unsigned char * ip;
char * subname;
u_int32_t wa[4];
STRLEN len;
PPCODE:
ip = (unsigned char *) SvPV(s,len);
if (len == 16) /* if already 128 bits, return input */
XPUSHs(sv_2mortal(newSVpvn((char *)ip,16)));
else if (len == 4) {
if (ix == 0)
NetSNMP-OID
view release on metacpan or search on metacpan
nsop_to_array(oid1)
netsnmp_oid *oid1;
PREINIT:
int i;
PPCODE:
EXTEND(SP, oid1->len);
for(i=0; i < (int)oid1->len; i++) {
PUSHs(sv_2mortal(newSVnv(oid1->name[i])));
}
NetSNMP-TrapReceiver
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
NetSNMP-agent
view release on metacpan or search on metacpan
PREINIT:
int i;
netsnmp_oid *o;
netsnmp_handler_registration *reginfo;
SV *arg, *rarg;
PPCODE:
{
dSP;
PUSHMARK(SP);
reginfo = (netsnmp_handler_registration *) SvIV(SvRV(me));
PREINIT:
int i;
netsnmp_oid *o;
netsnmp_request_info *request;
SV *arg, *rarg;
PPCODE:
{
dSP;
PUSHMARK(SP);
request = (netsnmp_request_info *) SvIV(SvRV(me));
NetSNMP-default_store
view release on metacpan or search on metacpan
default_store.xs view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Newt
view release on metacpan or search on metacpan
void
newtGetScreenSize()
PREINIT:
int cols;
int rows;
PPCODE:
newtGetScreenSize( &cols, &rows );
XPUSHs(sv_2mortal(newSViv(cols)));
XPUSHs(sv_2mortal(newSViv(rows)));
void
char * text
PREINIT:
char *result;
int actualWidth;
int actualHeight;
PPCODE:
result = newtReflowText(text, width, flexDown, flexUp, &actualWidth, &actualHeight);
XPUSHs(sv_2mortal(newSVpv(result, PL_na)));
XPUSHs(sv_2mortal(newSViv(actualWidth)));
XPUSHs(sv_2mortal(newSViv(actualHeight)));
newtComponent co
PREINIT:
int i;
int numitems = 0;
void **array;
PPCODE:
array = newtListboxGetSelection(co, &numitems);
for(i = 0; i < numitems; i++) {
XPUSHs(sv_2mortal(newSVsv((SV *)array[i])));
}
newtFormRun(co)
newtComponent co
PREINIT:
struct newtExitStruct es;
SV sv;
PPCODE:
newtFormRun(co, &es);
XPUSHs(sv_2mortal(newSViv(es.reason)));
if(es.reason == NEWT_EXIT_COMPONENT) {
XPUSHs(sv_2mortal(sv_setref_pv(newSViv(0),
"newtComponent",
Notes
view release on metacpan or search on metacpan
int len;
char* role;
ALIAS:
acl = 0
get_acl = 1
PPCODE:
Newz( 1, a_impl, sizeof(LN_Acl_Impl), LN_Acl_Impl );
if (a_impl==A_NO_MEM) { LN_SET_NOT_OK(db); XSRETURN_NOT_OK; }
LN_STAT(db) = NSFDbReadACL( (DBHANDLE) LN_H(db), &(a_impl->h) );
LN_Acl * a;
PREINIT:
d_LN_XSVARS;
LN_Acl_Impl* a_impl;
HANDLE a_h;
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
OSMemFree( a_h ); /* OSMemFree() _always_ returns NO_ERROR */
Safefree( a_impl );
XSRETURN( 0 );
LN_Acl * a;
PREINIT:
d_LN_XSVARS;
LN_Acl_Impl* a_impl;
HANDLE a_h;
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
LN_STAT(a) = NSFDbStoreACL( (DBHANDLE)
LN_PARENT_H(a),
a_h,
PREINIT:
d_LN_XSVARS;
LN_Acl_Impl* a_impl;
HANDLE a_h;
LN_Acl_EnumEntry ln_e;
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
LN_STAT(a) =
DNCanonicalize( 0L, NULL, name, ln_e.name, MAXUSERNAME, NULL );
d_LN_XSVARS;
LN_Acl_Impl* a_impl;
HANDLE a_h;
int sp_i;
LN_Acl_EnumEntry ln_e;
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
sp_i = 0;
ln_stat = LN_OK;
int min_role;
int max_role;
ALIAS:
all_roles = 0
all_privs = 1
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
switch ( ix ) {
case 0: min_role=a_impl->r1;max_role=a_impl->rn + 1; break;
LN_RoleName role;
int is_role;
int is_priv;
int found;
int not_found;
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
len = strlen( name );
len = ( len < ACL_PRIVNAMEMAX ) ? len : ACL_PRIVNAMEMAX - 1;
has_any_roles = 1
has_no_roles = 2
has_all_privs = 3
has_any_privs = 4
has_no_privs = 5
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
if ( items <= 1 ) { XSRETURN( 0 ); }
ALIAS:
add_roles = 0
add_privs = 1
remove_roles = 2
remove_privs = 3
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
if ( items <= 1 ) { XSRETURN( 0 ); }
int is_role;
int is_priv;
ALIAS:
rename_roles = 0
rename_privs = 1
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
if ( items <= 2 ) { XSRETURN(0); }
if ( items % 2 == 0 ) { items -= 1; } /*old/new pairs!*/
dbg_all_privrolebits = 1
dbg_roles_r1 = 2
dbg_roles_rn = 3
dbg_roles_r1_free = 4
dbg_roles_rn_free = 5
PPCODE:
a_impl = (LN_Acl_Impl*) LN_H(a);
a_h = a_impl->h;
switch ( ix ) {
case 5: XSRETURN_IV( a_impl->rn_free ); break;
Numeric-LL_Array
view release on metacpan or search on metacpan
LL_Array.xs view on Meta::CPAN
d_extract(s, start, count, stride = 1)
char *s
int start
int count
int stride
PPCODE:
{
double *arr = (double *)s;
EXTEND(SP, count);
arr += start;
LL_Array.xs view on Meta::CPAN
I32 offset
int dim
SV* format
SV *sv
bool keep
PPCODE:
{
AV *av;
const char *p_s;
STRLEN sz;
dXSI32; /* ix */
LL_Array.xs view on Meta::CPAN
_0arg__INTERFACE(p, offset = 0, dim = 0, format = Nullsv)
SV *p
I32 offset
int dim
SV* format
PPCODE:
{
char *p_s;
STRLEN sz;
dXSI32; /* ix */
const f_0arg_descr *desc = F0_get(ix);
LL_Array.xs view on Meta::CPAN
I32 s_offset
I32 offset
int dim
SV* sformat
SV* format
PPCODE:
{
char *p_s;
const char *sp_s;
STRLEN sz, ssz;
dXSI32; /* ix */
LL_Array.xs view on Meta::CPAN
I32 offset
int dim
SV* s1format
SV* s2format
SV* format
PPCODE:
{ /* Not implemented yet */
char *p_s;
const char *s1p_s, *s2p_s;
STRLEN sz, s1sz, s2sz;
dXSI32; /* ix */
LL_Array.xs view on Meta::CPAN
I32 offset
int dim
SV* s2format
SV* s1format
SV* format
PPCODE:
{ /* Not implemented yet */
char *p_s;
const char *s1p_s, *s2p_s;
STRLEN sz, s1sz, s2sz;
dXSI32; /* ix */
OS2-FTP
view release on metacpan or search on metacpan
CODE:
ftplogoff();
void
ping(...)
PPCODE:
int r;
unsigned long addr;
int pktlen = SvIV(ST(1));
if (SvPOKp(ST(0))) {
char *host = SvPV(ST(0), na);
RETVAL
void
getcwd(session)
OS2_FTP * session
PPCODE:
{
char wd[500];
int r = ftppwd(session->host, session->userid, session->passwd, session->acct,
wd, sizeof wd);
if (r < 0)
RETVAL
void
sys(session)
OS2_FTP * session
PPCODE:
{
char buf[2000];
int r = ftpsys(session->host, session->userid, session->passwd, session->acct,
buf, sizeof buf);
if (r < 0)
OS2-UPM
view release on metacpan or search on metacpan
char * name
int arg
void
local_user()
PPCODE:
{
USHORT rc;
PBYTE puserid = (buffer+0);
PUSHORT ptype = (PUSHORT)(buffer+10);
rc = (_THUNK_PROLOG (4+4);
void
user_list(remote_node="",remote_type=UPM_LOCAL)
char * remote_node
int remote_type
PPCODE:
{
USHORT rc;
PBYTE premotename = (buffer+0);
PUSHORT pread = (PUSHORT)(buffer+18);
PUSHORT ptotal = (PUSHORT)(buffer+20);
OUTPUT:
RETVAL
void
local_logon()
PPCODE:
{
USHORT rc;
PBYTE puserid = (buffer+0);
PUSHORT ptype = (PUSHORT)(buffer+10);
rc = (_THUNK_PROLOG (4+4);
OS2-WinObject
view release on metacpan or search on metacpan
WinObject.xs view on Meta::CPAN
HWND hwndDesktop
C_ARGS: hwndDesktop, iSysValue, lValue
SV *
ObjectClasses()
PPCODE:
{
POBJCLASS list = EnumObjectClasses();
POBJCLASS l = list, i = list;
int c;
WinObject.xs view on Meta::CPAN
MODULE = OS2::WinObject PACKAGE = OS2::WinObject PREFIX = make
SV *
WindowPos(hwnd)
HWND hwnd;
PPCODE:
{
SWP_or_error swpe = WindowPos(hwnd);
if (!swpe.error) {
EXTEND(SP, 9);
ObjStore-Lib-PDL
view release on metacpan or search on metacpan
void
_allocate(CSV, seg)
SV *CSV;
SV *seg;
PPCODE:
os_segment *area = osp_thr::sv_2segment(seg);
PUTBACK;
OSSVPV *pv;
NEW_OS_OBJECT(pv, area, Lib__PDL1::get_os_typespec(), Lib__PDL1);
pv->bless(CSV);
RETVAL
void
_inuse_bridges(...)
PROTOTYPE: ;$
PPCODE:
IV show = items>0? sv_true(ST(0)) : 0;
IV cnt=0;
#if OSP_BRIDGE_TRACE
pdl_bridge *br = (pdl_bridge*) pdl_bridge::All.next_self();
while (br) {
warn("_inuse_bridges detail is not available");
#endif
void
OSSVPV::getndims()
PPCODE:
XPUSHs(sv_2mortal(newSViv(((Lib__PDL1*)THIS)->ndims)));
void
OSSVPV::getdim(y)
int y;
PPCODE:
XPUSHs(sv_2mortal(newSViv(((Lib__PDL1*)THIS)->dims[y])));
void
OSSVPV::setdims(sv)
SV *sv
((pdl_bridge*) THIS_bridge->info)->init(((Lib__PDL1*)THIS));
void
copy(THIS)
OSSVPV *THIS;
PPCODE:
OSSVPV *cpy;
NEW_OS_OBJECT(cpy, os_segment::of(THIS), Lib__PDL1::get_os_typespec(),
Lib__PDL1);
((Lib__PDL1*)cpy)->copy(* (Lib__PDL1*)THIS);
SV *me = osp_thr::ospv_2sv(cpy, 1);
CODE:
/* do nothing */
void
OSSVPV::at(...)
PPCODE:
Lib__PDL1_c pdl((Lib__PDL1*)THIS);
if (items-1 != pdl.ndims)
croak("PDL->set expecting %d dimensions (not %d)", pdl.ndims, items-1);
pdl.seek(&ST(1));
SV *ret;
}
XPUSHs(sv_2mortal(ret));
void
OSSVPV::set(...)
PPCODE:
Lib__PDL1_c pdl((Lib__PDL1*)THIS);
if (items-1 != pdl.ndims + 1)
croak("PDL->set expecting %d dimensions (not %d)", pdl.ndims, items-2);
pdl.seek(&ST(1));
pdl.set(ST(items-1));
void
DESTROY(sv)
SV *sv
PPCODE:
ospv_bridge* br;
br= (ospv_bridge*) typemap_any::try_decode(sv, ospdl_dynacast, 0);
if (br) {
br->leave_perl();
}
ObjStore-REP-FatTree
view release on metacpan or search on metacpan
static void
OSSVPV::new(seg, sz)
SV *seg;
int sz;
PPCODE:
SV *CSV = ST(0);
os_segment *area = osp_thr::sv_2segment(ST(1));
PUTBACK;
if (sz < 40) {
SERIOUS("ObjStore::REP::FatTree::AV->new(%d): representation not efficient for small arrays", sz);
static void
OSSVPV::new(seg, sz)
SV *seg;
int sz;
PPCODE:
SV *CSV = ST(0);
os_segment *area = osp_thr::sv_2segment(ST(1));
PUTBACK;
if (sz < 40) {
SERIOUS("ObjStore::REP::FatTree::ObjAV->new(%d): representation not efficient for small arrays", sz);
MODULE = ObjStore::REP::FatTree PACKAGE = ObjStore::REP::FatTree::Index
static void
OSPV_fatindex2::new(seg)
SV *seg;
PPCODE:
os_segment *area = osp_thr::sv_2segment(ST(1));
PUTBACK;
OSPV_fatindex2 *pv;
if (area == os_segment::get_transient_segment())
croak("transient indices are too easily corrupted");
pv->bless(ST(0));
return;
void
OSPV_fatindex2::_conf_slot(...)
PPCODE:
PUTBACK;
SV *ret = 0;
if (items == 2) {
if (TvFILL(&THIS->tv)) {
croak("Configuration of an active index cannot be changed");
MODULE = ObjStore::REP::FatTree PACKAGE = ObjStore::REP::FatTree::KCIndex
static void
OSPV_fatindex3::new(seg)
SV *seg;
PPCODE:
os_segment *area = osp_thr::sv_2segment(ST(1));
PUTBACK;
OSPV_fatindex3 *pv;
if (area == os_segment::get_transient_segment())
croak("transient indices are too easily corrupted");
pv->bless(ST(0));
return;
void
OSPV_fatindex3::_conf_slot(...)
PPCODE:
PUTBACK;
SV *ret = 0;
if (items == 2) {
if (TvFILL(&THIS->tv))
croak("Configuration of an active index cannot be changed");
ObjStore-REP-HashRecord
view release on metacpan or search on metacpan
void
new(CSV, seg)
SV *CSV;
SV *seg;
PPCODE:
os_segment *area = osp_thr::sv_2segment(seg);
PUTBACK;
OSSVPV *pv;
NEW_OS_OBJECT(pv, area, Zot_Impl1::get_os_typespec(), Zot_Impl1);
pv->bless(CSV);
ObjStore-REP-Ring
view release on metacpan or search on metacpan
static void
new(clsv, seg)
SV *clsv;
SV *seg;
PPCODE:
os_segment *area = osp_thr::sv_2segment(seg);
PUTBACK;
OSPV_ring_index1 *pv;
NEW_OS_OBJECT(pv, area, OSPV_ring_index1::get_os_typespec(), OSPV_ring_index1());
pv->bless(ST(0));
return;
void
OSSVPV::_conf_slot(...)
PPCODE:
PUTBACK;
OSPV_ring_index1 *pv = (OSPV_ring_index1 *) THIS;
SV *ret=0;
if (items == 2) {
pv->fix_stats();
ObjStore
view release on metacpan or search on metacpan
API/Core.xs view on Meta::CPAN
MODULE = ObjStore::CORE PACKAGE = ObjStore
void
_inuse_bridges(...)
PROTOTYPE: ;$
PPCODE:
IV show = items>0? sv_true(ST(0)) : 0;
IV cnt=0;
#if OSP_BRIDGE_TRACE
osp_bridge *br = (osp_bridge*) osp_bridge::All.next_self();
while (br) {
API/Core.xs view on Meta::CPAN
void
OSSVPV::_new_ref(type, sv1)
int type;
SV *sv1;
PPCODE:
PUTBACK;
os_segment *seg = osp_thr::sv_2segment(sv1);
SV *ret;
OSSVPV *tpv;
if (type == 0) {
API/Core.xs view on Meta::CPAN
SV *CLASS;
SV *sv1;
int type;
char *dump;
os_database *db;
PPCODE:
PUTBACK;
os_segment *seg = osp_thr::sv_2segment(sv1);
OSPV_Ref2 *ref;
if (type == 0) {
ref = new (seg, OSPV_Ref2_protect::get_os_typespec())
API/Core.xs view on Meta::CPAN
else warn("%p->moveto(%d): unsupported", THIS, SvIV(side));
} else croak("moveto");
void
OSPV_Cursor::at()
PPCODE:
PUTBACK; THIS->at(); return;
void
OSPV_Cursor::next()
PPCODE:
PUTBACK; THIS->next(); return;
#-----------------------------# Ref
MODULE = ObjStore::CORE PACKAGE = ObjStore::DEPRECIATED::Ref
API/Core.xs view on Meta::CPAN
int
OSPV_Ref::deleted()
void
OSPV_Ref::focus()
PPCODE:
PUTBACK;
SV *sv = osp_thr::ospv_2sv(THIS->focus());
SPAGAIN;
XPUSHs(sv);
Object-Accessor-XS
view release on metacpan or search on metacpan
PROTOTYPES: DISABLE
SV *
new (class)
char * class
PPCODE:
{
ST(0) = sv_bless(newRV_noinc((SV*)newHV()), gv_stashpv(class, TRUE));
XSRETURN(1);
}
void
_debug (message)
SV * message
PPCODE:
{
if (!SvTRUE(get_sv("DEBUG", TRUE)))
return;
ENTER;
}
void
mk_accessors (self, ...)
SV * self
PPCODE:
{
if(items > 1 && SvROK(self) && SvTYPE(SvRV(self)) == SVt_PVHV) {
HV* object = (HV*)SvRV(self);
IV i;
}
void
mk_flush (self)
SV * self
PPCODE:
{
if(SvROK(self) && SvTYPE(SvRV(self)) == SVt_PVHV) {
HV* object = (HV*)SvRV(self);
(void)hv_iterinit(object);
}
void
ls_accessors (self)
SV * self
PPCODE:
{
if(SvROK(self) && SvTYPE(SvRV(self)) == SVt_PVHV) {
HV* object = (HV*)SvRV(self);
AV* keys = newAV();
}
void
DESTROY (self)
SV * self
PPCODE:
{
/* return; */
}
Object-Pad
view release on metacpan or search on metacpan
lib/Object/Pad.xs view on Meta::CPAN
OUTPUT:
RETVAL
void
deconstruct_object(SV *obj)
PPCODE:
{
if(!SvROK(obj) || !SvOBJECT(SvRV(obj)))
croak("Expected an object reference to deconstruct_object");
ClassMeta *classmeta = mop_get_class_for_stash(SvSTASH(SvRV(obj)));
Ogg-LibOgg
view release on metacpan or search on metacpan
=cut
void
Ogg_LibOgg_make_ogg_packet()
PREINIT:
ogg_packet *memory;
PPCODE:
New(0, memory, 1, ogg_packet); // it always satisfies with what we have asked
XPUSHs(sv_2mortal(newSViv(PTR2IV(memory)))); // since i am using sv_2mortal, i don't have to worry about leaks
=head2 make_ogg_stream_state
=cut
void
Ogg_LibOgg_make_ogg_stream_state()
PREINIT:
ogg_stream_state *memory;
PPCODE:
New(0, memory, 1, ogg_stream_state);
XPUSHs(sv_2mortal(newSViv(PTR2IV(memory))));
=head2 make_ogg_page
=cut
void
Ogg_LibOgg_make_ogg_page()
PREINIT:
ogg_page *memory;
PPCODE:
New(0, memory, 1, ogg_page);
XPUSHs(sv_2mortal(newSViv(PTR2IV(memory))));
=head2 make_ogg_sync_state
=cut
void
Ogg_LibOgg_make_ogg_sync_state()
PREINIT:
ogg_sync_state *memory;
PPCODE:
New(0, memory, 1, ogg_sync_state);
XPUSHs(sv_2mortal(newSViv(PTR2IV(memory))));
=head1 Functions (Bitstream Primitives)
int oy
int size
PREINIT:
ogg_sync_state *_oy;
char *buffer;
PPCODE:
_oy = INT2PTR(ogg_sync_state *, oy);
if((buffer = ogg_sync_buffer(_oy, size)) != NULL) {
XPUSHs(sv_2mortal(newSViv(PTR2IV(buffer))));
} else {
XSRETURN_UNDEF;
Ogg-Theora-LibTheora
view release on metacpan or search on metacpan
LibTheora.xs view on Meta::CPAN
int _setup_addr
ogg_packet * _op
PREINIT:
int status;
th_setup_info *_setup;
PPCODE:
_setup = (th_setup_info *) _setup_addr;
status = th_decode_headerin(_info, _tc, &_setup, _op);
XPUSHs(sv_2mortal(newSViv(status)));
XPUSHs(sv_2mortal(newSViv((unsigned int) _setup)));
LibTheora.xs view on Meta::CPAN
th_dec_ctx * _dec
ogg_packet * _op
unsigned int _granpos
PREINIT:
int status;
PPCODE:
status = th_decode_packetin(_dec, _op, (ogg_int64_t *) &_granpos);
XPUSHs(sv_2mortal(newSViv(status)));
XPUSHs(sv_2mortal(newSViv((unsigned int) _granpos)));
LibTheora.xs view on Meta::CPAN
void
LibTheora_get_th_comment(_tc)
th_comment * _tc
PREINIT:
int i = 0;
PPCODE:
EXTEND(SP, _tc->comments);
for(i=0; i < _tc->comments; i++) {
PUSHs((SV *)sv_2mortal(newSVpv(_tc->user_comments[i], strlen(_tc->user_comments[i]))));
}
Ogg-Vorbis-LibVorbis
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Ogre
view release on metacpan or search on metacpan
xs/SceneQuery.xs view on Meta::CPAN
## virtual const set<WorldFragmentType>::type* Ogre::SceneQuery::getSupportedWorldFragmentTypes(void) const
## note: this just returns a list
void
SceneQuery::getSupportedWorldFragmentTypes()
PPCODE:
const Ogre::set<SceneQuery::WorldFragmentType>::type *wfts = THIS->getSupportedWorldFragmentTypes();
Ogre::set<SceneQuery::WorldFragmentType>::type::const_iterator it;
for (it = wfts->begin(); it != wfts->end(); it++) {
mXPUSHi((int) *it);
}
Opcodes
view release on metacpan or search on metacpan
INCLUDE: const-xs.inc
void
opcodes()
PPCODE:
if (GIMME_V == G_ARRAY) {
int i;
EXTEND(sp, MAXO);
/* ([ opcode opname ppaddr check opargs ]) from opnames.h/opcode.h */
for (i=0; i < MAXO; i++) {
OpenBSD-Checkpass
view release on metacpan or search on metacpan
Checkpass.xs view on Meta::CPAN
SV *
_newhash(const char *password)
INIT:
int rv;
char buf[_PASSWORD_LEN];
PPCODE:
rv = crypt_newhash(password, "bcrypt,a", buf, sizeof(buf));
if (rv == 0) {
XPUSHs(sv_2mortal(newSVpv(buf, 0)));
} else {
XPUSHs(sv_newmortal());
OpenCA-OpenSSL
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
OpenCL
view release on metacpan or search on metacpan
const char *
enum2str (cl_uint value)
void
platforms ()
PPCODE:
cl_platform_id *list;
cl_uint count;
int i;
NEED_SUCCESS (GetPlatformIDs, (0, 0, &count));
for (i = 0; i < count; ++i)
PUSH_CLOBJ (stash_platform, list [i]);
void
context_from_type (cl_context_properties *properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, SV *notify = &PL_sv_undef)
PPCODE:
CONTEXT_NOTIFY_CALLBACK;
NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (properties, type, pfn_notify, user_data, &res));
XPUSH_CLOBJ_CONTEXT;
void
context (cl_context_properties *properties, SV *devices, SV *notify = &PL_sv_undef)
PPCODE:
cl_uint device_count;
cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
CONTEXT_NOTIFY_CALLBACK;
NEED_SUCCESS_ARG (cl_context ctx, CreateContext, (properties, device_count, device_list, pfn_notify, user_data, &res));
MODULE = OpenCL PACKAGE = OpenCL::Platform
void
info (OpenCL::Platform self, cl_platform_info name)
PPCODE:
INFO (Platform)
void
unload_compiler (OpenCL::Platform self)
CODE:
profile = CL_PLATFORM_PROFILE
version = CL_PLATFORM_VERSION
name = CL_PLATFORM_NAME
vendor = CL_PLATFORM_VENDOR
extensions = CL_PLATFORM_EXTENSIONS
PPCODE:
size_t size;
NEED_SUCCESS (GetPlatformInfo, (self, ix, 0, 0, &size));
char *value = tmpbuf (size);
NEED_SUCCESS (GetPlatformInfo, (self, ix, size, value, 0));
EXTEND (SP, 1);
#END:platform
void
devices (OpenCL::Platform self, cl_device_type type = CL_DEVICE_TYPE_ALL)
PPCODE:
cl_device_id *list;
cl_uint count;
int i;
NEED_SUCCESS (GetDeviceIDs, (self, type, 0, 0, &count));
for (i = 0; i < count; ++i)
PUSH_CLOBJ (stash_device, list [i]);
void
context (OpenCL::Platform self, SV *properties, SV *devices, SV *notify = &PL_sv_undef)
PPCODE:
cl_context_properties extra[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)self };
cl_context_properties *props = SvCONTEXTPROPERTIES (cv, "properties", properties, extra, 2);
cl_uint device_count;
cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
NEED_SUCCESS_ARG (cl_context ctx, CreateContext, (props, device_count, device_list, pfn_notify, user_data, &res));
XPUSH_CLOBJ_CONTEXT;
void
context_from_type (OpenCL::Platform self, SV *properties = 0, cl_device_type type = CL_DEVICE_TYPE_DEFAULT, SV *notify = &PL_sv_undef)
PPCODE:
cl_context_properties extra[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)self };
cl_context_properties *props = SvCONTEXTPROPERTIES (cv, "properties", properties, extra, 2);
CONTEXT_NOTIFY_CALLBACK;
NEED_SUCCESS_ARG (cl_context ctx, CreateContextFromType, (props, type, pfn_notify, user_data, &res));
MODULE = OpenCL PACKAGE = OpenCL::Device
void
info (OpenCL::Device self, cl_device_info name)
PPCODE:
INFO (Device)
#if CL_VERSION_1_2
void
sub_devices (OpenCL::Device self, SV *properties)
PPCODE:
if (!SvROK (properties) || SvTYPE (SvRV (properties)) != SVt_PVAV)
croak ("OpenCL::Device::sub_devices: properties must be specified as reference to an array of property-value pairs");
properties = SvRV (properties);
local_mem_size = CL_DEVICE_LOCAL_MEM_SIZE
execution_capabilities = CL_DEVICE_EXECUTION_CAPABILITIES
properties = CL_DEVICE_QUEUE_PROPERTIES
double_fp_config = CL_DEVICE_DOUBLE_FP_CONFIG
half_fp_config = CL_DEVICE_HALF_FP_CONFIG
PPCODE:
cl_ulong value [1];
NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
native_vector_width_long = CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG
native_vector_width_float = CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT
native_vector_width_double = CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE
native_vector_width_half = CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF
reference_count_ext = CL_DEVICE_REFERENCE_COUNT_EXT
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
image3d_max_width = CL_DEVICE_IMAGE3D_MAX_WIDTH
image3d_max_height = CL_DEVICE_IMAGE3D_MAX_HEIGHT
image3d_max_depth = CL_DEVICE_IMAGE3D_MAX_DEPTH
max_parameter_size = CL_DEVICE_MAX_PARAMETER_SIZE
profiling_timer_resolution = CL_DEVICE_PROFILING_TIMER_RESOLUTION
PPCODE:
size_t value [1];
NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
max_work_item_sizes (OpenCL::Device self)
PPCODE:
size_t size;
NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_MAX_WORK_ITEM_SIZES, 0, 0, &size));
size_t *value = tmpbuf (size);
NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_MAX_WORK_ITEM_SIZES, size, value, 0));
int i, n = size / sizeof (*value);
error_correction_support = CL_DEVICE_ERROR_CORRECTION_SUPPORT
endian_little = CL_DEVICE_ENDIAN_LITTLE
available = CL_DEVICE_AVAILABLE
compiler_available = CL_DEVICE_COMPILER_AVAILABLE
host_unified_memory = CL_DEVICE_HOST_UNIFIED_MEMORY
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetDeviceInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no));
void
platform (OpenCL::Device self)
PPCODE:
cl_platform_id value [1];
NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PLATFORM, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSH_CLOBJ (stash_platform, value [i]);
vendor = CL_DEVICE_VENDOR
driver_version = CL_DRIVER_VERSION
profile = CL_DEVICE_PROFILE
version = CL_DEVICE_VERSION
extensions = CL_DEVICE_EXTENSIONS
PPCODE:
size_t size;
NEED_SUCCESS (GetDeviceInfo, (self, ix, 0, 0, &size));
char *value = tmpbuf (size);
NEED_SUCCESS (GetDeviceInfo, (self, ix, size, value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVpv (value, 0)));
void
parent_device_ext (OpenCL::Device self)
PPCODE:
cl_device_id value [1];
NEED_SUCCESS (GetDeviceInfo, (self, CL_DEVICE_PARENT_DEVICE_EXT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSH_CLOBJ (stash_device, value [i]);
partition_types_ext (OpenCL::Device self)
ALIAS:
partition_types_ext = CL_DEVICE_PARTITION_TYPES_EXT
affinity_domains_ext = CL_DEVICE_AFFINITY_DOMAINS_EXT
partition_style_ext = CL_DEVICE_PARTITION_STYLE_EXT
PPCODE:
size_t size;
NEED_SUCCESS (GetDeviceInfo, (self, ix, 0, 0, &size));
cl_device_partition_property_ext *value = tmpbuf (size);
NEED_SUCCESS (GetDeviceInfo, (self, ix, size, value, 0));
int i, n = size / sizeof (*value);
CODE:
clReleaseContext (self);
void
info (OpenCL::Context self, cl_context_info name)
PPCODE:
INFO (Context)
void
queue (OpenCL::Context self, OpenCL::Device device, cl_command_queue_properties properties = 0)
PPCODE:
NEED_SUCCESS_ARG (cl_command_queue queue, CreateCommandQueue, (self, device, properties, &res));
XPUSH_CLOBJ (stash_queue, queue);
void
user_event (OpenCL::Context self)
PPCODE:
NEED_SUCCESS_ARG (cl_event ev, CreateUserEvent, (self, &res));
XPUSH_CLOBJ (stash_userevent, ev);
void
buffer (OpenCL::Context self, cl_mem_flags flags, size_t len)
PPCODE:
if (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR))
croak ("OpenCL::Context::buffer: cannot use/copy host ptr when no data is given, use $context->buffer_sv instead?");
NEED_SUCCESS_ARG (cl_mem mem, CreateBuffer, (self, flags, len, 0, &res));
XPUSH_CLOBJ (stash_bufferobj, mem);
void
buffer_sv (OpenCL::Context self, cl_mem_flags flags, SV *data)
PPCODE:
STRLEN len;
char *ptr = SvOK (data) ? SvPVbyte (data, len) : 0;
if (!(flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)))
croak ("OpenCL::Context::buffer_sv: you have to specify use or copy host ptr when buffer data is given, use $context->buffer instead?");
NEED_SUCCESS_ARG (cl_mem mem, CreateBuffer, (self, flags, len, ptr, &res));
#if CL_VERSION_1_2
void
image (OpenCL::Context self, cl_mem_flags flags, cl_channel_order channel_order, cl_channel_type channel_type, cl_mem_object_type type, size_t width, size_t height, size_t depth = 0, size_t array_size = 0, size_t row_pitch = 0, size_t slice_pitch = 0...
PPCODE:
STRLEN len;
char *ptr = SvOK (data) ? SvPVbyte (data, len) : 0;
const cl_image_format format = { channel_order, channel_type };
const cl_image_desc desc = {
type,
#endif
void
image2d (OpenCL::Context self, cl_mem_flags flags, cl_channel_order channel_order, cl_channel_type channel_type, size_t width, size_t height, size_t row_pitch = 0, SV *data = &PL_sv_undef)
PPCODE:
STRLEN len;
char *ptr = SvOK (data) ? SvPVbyte (data, len) : 0;
const cl_image_format format = { channel_order, channel_type };
#if PREFER_1_1
NEED_SUCCESS_ARG (cl_mem mem, CreateImage2D, (self, flags, &format, width, height, row_pitch, ptr, &res));
#endif
XPUSH_CLOBJ (stash_image2d, mem);
void
image3d (OpenCL::Context self, cl_mem_flags flags, cl_channel_order channel_order, cl_channel_type channel_type, size_t width, size_t height, size_t depth, size_t row_pitch = 0, size_t slice_pitch = 0, SV *data = &PL_sv_undef)
PPCODE:
STRLEN len;
char *ptr = SvOK (data) ? SvPVbyte (data, len) : 0;
const cl_image_format format = { channel_order, channel_type };
#if PREFER_1_1
NEED_SUCCESS_ARG (cl_mem mem, CreateImage3D, (self, flags, &format, width, height, depth, row_pitch, slice_pitch, ptr, &res));
#if cl_apple_gl_sharing || cl_khr_gl_sharing
void
gl_buffer (OpenCL::Context self, cl_mem_flags flags, cl_GLuint bufobj)
PPCODE:
NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLBuffer, (self, flags, bufobj, &res));
XPUSH_CLOBJ (stash_bufferobj, mem);
void
gl_renderbuffer (OpenCL::Context self, cl_mem_flags flags, cl_GLuint renderbuffer)
PPCODE:
NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLRenderbuffer, (self, flags, renderbuffer, &res));
XPUSH_CLOBJ (stash_image2d, mem);
#if CL_VERSION_1_2
void
gl_texture (OpenCL::Context self, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture)
ALIAS:
PPCODE:
NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLTexture, (self, flags, target, miplevel, texture, &res));
cl_gl_object_type type;
NEED_SUCCESS (GetGLObjectInfo, (mem, &type, 0)); // TODO: use target instead?
HV *stash = stash_memory;
switch (type)
#endif
void
gl_texture2d (OpenCL::Context self, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture)
PPCODE:
#if PREFER_1_1
NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLTexture2D, (self, flags, target, miplevel, texture, &res));
#else
NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLTexture , (self, flags, target, miplevel, texture, &res));
#endif
XPUSH_CLOBJ (stash_image2d, mem);
void
gl_texture3d (OpenCL::Context self, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, cl_GLuint texture)
PPCODE:
#if PREFER_1_1
NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLTexture3D, (self, flags, target, miplevel, texture, &res));
#else
NEED_SUCCESS_ARG (cl_mem mem, CreateFromGLTexture , (self, flags, target, miplevel, texture, &res));
#endif
#endif
void
supported_image_formats (OpenCL::Context self, cl_mem_flags flags, cl_mem_object_type image_type)
PPCODE:
{
cl_uint count;
cl_image_format *list;
int i;
}
}
void
sampler (OpenCL::Context self, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode)
PPCODE:
NEED_SUCCESS_ARG (cl_sampler sampler, CreateSampler, (self, normalized_coords, addressing_mode, filter_mode, &res));
XPUSH_CLOBJ (stash_sampler, sampler);
void
program_with_source (OpenCL::Context self, SV *program)
PPCODE:
STRLEN len;
size_t len2;
const char *ptr = SvPVbyte (program, len);
len2 = len;
NEED_SUCCESS_ARG (cl_program prog, CreateProgramWithSource, (self, 1, &ptr, &len2, &res));
XPUSH_CLOBJ (stash_program, prog);
void
program_with_binary (OpenCL::Context self, SV *devices, SV *binaries)
PPCODE:
cl_uint device_count;
cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
if (!SvROK (binaries) || SvTYPE (SvRV (binaries)) != SVt_PVAV)
croak ("OpenCL::Context::program_with_binary: binaries must be specified as reference to an array of strings");
#if CL_VERSION_1_2
void
program_with_built_in_kernels (OpenCL::Context self, SV *devices, SV *kernel_names)
PPCODE:
cl_uint device_count;
cl_device_id *device_list = object_list (cv, 0, "devices", devices, "OpenCL::Device", &device_count);
NEED_SUCCESS_ARG (cl_program prog, CreateProgramWithBuiltInKernels, (self, device_count, device_list, SvPVbyte_nolen (kernel_names), &res));
void
reference_count (OpenCL::Context self)
ALIAS:
reference_count = CL_CONTEXT_REFERENCE_COUNT
num_devices = CL_CONTEXT_NUM_DEVICES
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetContextInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
devices (OpenCL::Context self)
PPCODE:
size_t size;
NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_DEVICES, 0, 0, &size));
cl_device_id *value = tmpbuf (size);
NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_DEVICES, size, value, 0));
int i, n = size / sizeof (*value);
for (i = 0; i < n; ++i)
PUSH_CLOBJ (stash_device, value [i]);
void
properties (OpenCL::Context self)
PPCODE:
size_t size;
NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_PROPERTIES, 0, 0, &size));
cl_context_properties *value = tmpbuf (size);
NEED_SUCCESS (GetContextInfo, (self, CL_CONTEXT_PROPERTIES, size, value, 0));
int i, n = size / sizeof (*value);
void
read_buffer (OpenCL::Queue self, OpenCL::Buffer mem, cl_bool blocking, size_t offset, size_t len, SV *data, ...)
ALIAS:
enqueue_read_buffer = 0
PPCODE:
EVENT_LIST (6);
SvUPGRADE (data, SVt_PV);
SvGROW (data, len);
SvPOK_only (data);
void
write_buffer (OpenCL::Queue self, OpenCL::Buffer mem, cl_bool blocking, size_t offset, SV *data, ...)
ALIAS:
enqueue_write_buffer = 0
PPCODE:
EVENT_LIST (5);
STRLEN len;
char *ptr = SvPVbyte (data, len);
void
fill_buffer (OpenCL::Queue self, OpenCL::Buffer mem, SV *data, size_t offset, size_t size, ...)
ALIAS:
enqueue_fill_buffer = 0
PPCODE:
EVENT_LIST (5);
STRLEN len;
char *ptr = SvPVbyte (data, len);
void
fill_image (OpenCL::Queue self, OpenCL::Image img, NV r, NV g, NV b, NV a, size_t x, size_t y, size_t z, size_t width, size_t height, size_t depth, ...)
ALIAS:
enqueue_fill_image = 0
PPCODE:
EVENT_LIST (12);
const size_t origin [3] = { x, y, z };
const size_t region [3] = { width, height, depth };
void
copy_buffer (OpenCL::Queue self, OpenCL::Buffer src, OpenCL::Buffer dst, size_t src_offset, size_t dst_offset, size_t len, ...)
ALIAS:
enqueue_copy_buffer = 0
PPCODE:
EVENT_LIST (6);
cl_event ev = 0;
NEED_SUCCESS (EnqueueCopyBuffer, (self, src, dst, src_offset, dst_offset, len, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
void
read_buffer_rect (OpenCL::Queue self, OpenCL::Memory buf, cl_bool blocking, size_t buf_x, size_t buf_y, size_t buf_z, size_t host_x, size_t host_y, size_t host_z, size_t width, size_t height, size_t depth, size_t buf_row_pitch, size_t buf_slice_pitch...
ALIAS:
enqueue_read_buffer_rect = 0
PPCODE:
EVENT_LIST (17);
const size_t buf_origin [3] = { buf_x , buf_y , buf_z };
const size_t host_origin[3] = { host_x, host_y, host_z };
const size_t region[3] = { width, height, depth };
void
write_buffer_rect (OpenCL::Queue self, OpenCL::Memory buf, cl_bool blocking, size_t buf_x, size_t buf_y, size_t buf_z, size_t host_x, size_t host_y, size_t host_z, size_t width, size_t height, size_t depth, size_t buf_row_pitch, size_t buf_slice_pitc...
ALIAS:
enqueue_write_buffer_rect = 0
PPCODE:
EVENT_LIST (17);
const size_t buf_origin [3] = { buf_x , buf_y , buf_z };
const size_t host_origin[3] = { host_x, host_y, host_z };
const size_t region[3] = { width, height, depth };
void
copy_buffer_rect (OpenCL::Queue self, OpenCL::Buffer src, OpenCL::Buffer dst, size_t src_x, size_t src_y, size_t src_z, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, size_t src_row_pitch, size_t src_slice_pitch,...
ALIAS:
enqueue_copy_buffer_rect = 0
PPCODE:
EVENT_LIST (16);
const size_t src_origin[3] = { src_x, src_y, src_z };
const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
const size_t region[3] = { width, height, depth };
void
read_image (OpenCL::Queue self, OpenCL::Image src, cl_bool blocking, size_t src_x, size_t src_y, size_t src_z, size_t width, size_t height, size_t depth, size_t row_pitch, size_t slice_pitch, SV *data, ...)
ALIAS:
enqueue_read_image = 0
PPCODE:
EVENT_LIST (12);
const size_t src_origin[3] = { src_x, src_y, src_z };
const size_t region[3] = { width, height, depth };
void
write_image (OpenCL::Queue self, OpenCL::Image dst, cl_bool blocking, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, size_t row_pitch, size_t slice_pitch, SV *data, ...)
ALIAS:
enqueue_write_image = 0
PPCODE:
EVENT_LIST (12);
const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
const size_t region[3] = { width, height, depth };
STRLEN len;
void
copy_image (OpenCL::Queue self, OpenCL::Image src, OpenCL::Image dst, size_t src_x, size_t src_y, size_t src_z, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, ...)
ALIAS:
enqueue_copy_image = 0
PPCODE:
EVENT_LIST (12);
const size_t src_origin[3] = { src_x, src_y, src_z };
const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
const size_t region[3] = { width, height, depth };
void
copy_image_to_buffer (OpenCL::Queue self, OpenCL::Image src, OpenCL::Buffer dst, size_t src_x, size_t src_y, size_t src_z, size_t width, size_t height, size_t depth, size_t dst_offset, ...)
ALIAS:
enqueue_copy_image_to_buffer = 0
PPCODE:
EVENT_LIST (10);
const size_t src_origin[3] = { src_x, src_y, src_z };
const size_t region [3] = { width, height, depth };
void
copy_buffer_to_image (OpenCL::Queue self, OpenCL::Buffer src, OpenCL::Image dst, size_t src_offset, size_t dst_x, size_t dst_y, size_t dst_z, size_t width, size_t height, size_t depth, ...)
ALIAS:
enqueue_copy_buffer_to_image = 0
PPCODE:
EVENT_LIST (10);
const size_t dst_origin[3] = { dst_x, dst_y, dst_z };
const size_t region [3] = { width, height, depth };
void
map_buffer (OpenCL::Queue self, OpenCL::Buffer buf, cl_bool blocking = 1, cl_map_flags map_flags = CL_MAP_READ | CL_MAP_WRITE, size_t offset = 0, SV *cb_ = &PL_sv_undef, ...)
ALIAS:
enqueue_map_buffer = 0
PPCODE:
EVENT_LIST (6);
size_t cb = SvIV (cb_);
if (!SvOK (cb_))
void
map_image (OpenCL::Queue self, OpenCL::Image img, cl_bool blocking = 1, cl_map_flags map_flags = CL_MAP_READ | CL_MAP_WRITE, size_t x = 0, size_t y = 0, size_t z = 0, SV *width_ = &PL_sv_undef, SV *height_ = &PL_sv_undef, SV *depth_ = &PL_sv_undef, ....
ALIAS:
enqueue_map_image = 0
PPCODE:
size_t width = SvIV (width_);
if (!SvOK (width_))
{
NEED_SUCCESS (GetImageInfo, (img, CL_IMAGE_WIDTH, sizeof (width), &width, 0));
width -= x;
XPUSHs (mapped_new (stash_mappedimage, self, img, map_flags, ptr, cb, ev, row_pitch, slice_pitch, 0, width, height, depth));
void
unmap (OpenCL::Queue self, OpenCL::Mapped mapped, ...)
PPCODE:
mapped_unmap (cv, ST (1), mapped, self, &ST (2), items - 2);
if (GIMME_V != G_VOID)
{
clRetainEvent (mapped->event);
XPUSH_CLOBJ (stash_event, mapped->event);
void
task (OpenCL::Queue self, OpenCL::Kernel kernel, ...)
ALIAS:
enqueue_task = 0
PPCODE:
EVENT_LIST (2);
cl_event ev = 0;
NEED_SUCCESS (EnqueueTask, (self, kernel, event_list_count, event_list_ptr, GIMME_V != G_VOID ? &ev : 0));
void
nd_range_kernel (OpenCL::Queue self, OpenCL::Kernel kernel, SV *global_work_offset, SV *global_work_size, SV *local_work_size = &PL_sv_undef, ...)
ALIAS:
enqueue_nd_range_kernel = 0
PPCODE:
EVENT_LIST (5);
size_t *gwo = 0, *gws, *lws = 0;
int gws_len;
size_t *lists;
void
migrate_mem_objects (OpenCL::Queue self, SV *objects, cl_mem_migration_flags flags, ...)
ALIAS:
enqueue_migrate_mem_objects = 0
PPCODE:
EVENT_LIST (3);
cl_uint obj_count;
cl_mem *obj_list = object_list (cv, 0, "objects", objects, "OpenCL::Memory", &obj_count);
acquire_gl_objects (OpenCL::Queue self, SV *objects, ...)
ALIAS:
release_gl_objects = 1
enqueue_acquire_gl_objects = 0
enqueue_release_gl_objects = 1
PPCODE:
EVENT_LIST (2);
cl_uint obj_count;
cl_mem *obj_list = object_list (cv, 0, "objects", objects, "OpenCL::Memory", &obj_count);
void
marker (OpenCL::Queue self, ...)
ALIAS:
enqueue_marker = 0
PPCODE:
EVENT_LIST (1);
cl_event ev = 0;
#if PREFER_1_1
if (!event_list_count)
NEED_SUCCESS (EnqueueMarker, (self, GIMME_V != G_VOID ? &ev : 0));
void
barrier (OpenCL::Queue self, ...)
ALIAS:
enqueue_barrier = 0
PPCODE:
EVENT_LIST (1);
cl_event ev = 0;
#if PREFER_1_1
if (!event_list_count && GIMME_V == G_VOID)
NEED_SUCCESS (EnqueueBarrier, (self));
CODE:
NEED_SUCCESS (Finish, (self));
void
info (OpenCL::Queue self, cl_command_queue_info name)
PPCODE:
INFO (CommandQueue)
#BEGIN:command_queue
void
context (OpenCL::Queue self)
PPCODE:
cl_context value [1];
NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_CONTEXT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainContext, (value [i]));
PUSH_CLOBJ (stash_context, value [i]);
void
device (OpenCL::Queue self)
PPCODE:
cl_device_id value [1];
NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_DEVICE, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSH_CLOBJ (stash_device, value [i]);
void
reference_count (OpenCL::Queue self)
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_REFERENCE_COUNT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
properties (OpenCL::Queue self)
PPCODE:
cl_ulong value [1];
NEED_SUCCESS (GetCommandQueueInfo, (self, CL_QUEUE_PROPERTIES, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
CODE:
clReleaseMemObject (self);
void
info (OpenCL::Memory self, cl_mem_info name)
PPCODE:
INFO (MemObject)
void
destructor_callback (OpenCL::Memory self, SV *notify)
PPCODE:
clSetMemObjectDestructorCallback (self, eq_destructor_notify, SvREFCNT_inc (s_get_cv (notify)));
#BEGIN:mem
void
type (OpenCL::Memory self)
ALIAS:
type = CL_MEM_TYPE
map_count = CL_MEM_MAP_COUNT
reference_count = CL_MEM_REFERENCE_COUNT
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetMemObjectInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
flags (OpenCL::Memory self)
PPCODE:
cl_ulong value [1];
NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_FLAGS, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
size (OpenCL::Memory self)
ALIAS:
size = CL_MEM_SIZE
offset = CL_MEM_OFFSET
PPCODE:
size_t value [1];
NEED_SUCCESS (GetMemObjectInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
host_ptr (OpenCL::Memory self)
PPCODE:
void * value [1];
NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_HOST_PTR, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv ((IV)(intptr_t)value [i])));
void
context (OpenCL::Memory self)
PPCODE:
cl_context value [1];
NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_CONTEXT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainContext, (value [i]));
PUSH_CLOBJ (stash_context, value [i]);
void
associated_memobject (OpenCL::Memory self)
PPCODE:
cl_mem value [1];
NEED_SUCCESS (GetMemObjectInfo, (self, CL_MEM_ASSOCIATED_MEMOBJECT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainMemObject, (value [i]));
#if cl_apple_gl_sharing || cl_khr_gl_sharing
void
gl_object_info (OpenCL::Memory self)
PPCODE:
cl_gl_object_type type;
cl_GLuint name;
NEED_SUCCESS (GetGLObjectInfo, (self, &type, &name));
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSVuv (type)));
MODULE = OpenCL PACKAGE = OpenCL::BufferObj
void
sub_buffer_region (OpenCL::BufferObj self, cl_mem_flags flags, size_t origin, size_t size)
PPCODE:
if (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR | CL_MEM_ALLOC_HOST_PTR))
croak ("clCreateSubBuffer: cannot use/copy/alloc host ptr, doesn't make sense, check your flags!");
cl_buffer_region crdata = { origin, size };
MODULE = OpenCL PACKAGE = OpenCL::Image
void
image_info (OpenCL::Image self, cl_image_info name)
PPCODE:
INFO (Image)
void
format (OpenCL::Image self)
PPCODE:
cl_image_format format;
NEED_SUCCESS (GetImageInfo, (self, CL_IMAGE_FORMAT, sizeof (format), &format, 0));
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSVuv (format.image_channel_order)));
PUSHs (sv_2mortal (newSVuv (format.image_channel_data_type)));
row_pitch = CL_IMAGE_ROW_PITCH
slice_pitch = CL_IMAGE_SLICE_PITCH
width = CL_IMAGE_WIDTH
height = CL_IMAGE_HEIGHT
depth = CL_IMAGE_DEPTH
PPCODE:
size_t value [1];
NEED_SUCCESS (GetImageInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
#BEGIN:gl_texture
void
target (OpenCL::Image self)
PPCODE:
cl_GLenum value [1];
NEED_SUCCESS (GetGLTextureInfo, (self, CL_GL_TEXTURE_TARGET, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
gl_mipmap_level (OpenCL::Image self)
PPCODE:
cl_GLint value [1];
NEED_SUCCESS (GetGLTextureInfo, (self, CL_GL_MIPMAP_LEVEL, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSViv (value [i])));
CODE:
clReleaseSampler (self);
void
info (OpenCL::Sampler self, cl_sampler_info name)
PPCODE:
INFO (Sampler)
#BEGIN:sampler
void
reference_count (OpenCL::Sampler self)
ALIAS:
reference_count = CL_SAMPLER_REFERENCE_COUNT
normalized_coords = CL_SAMPLER_NORMALIZED_COORDS
addressing_mode = CL_SAMPLER_ADDRESSING_MODE
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetSamplerInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
context (OpenCL::Sampler self)
PPCODE:
cl_context value [1];
NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_CONTEXT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainContext, (value [i]));
PUSH_CLOBJ (stash_context, value [i]);
void
filter_mode (OpenCL::Sampler self)
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetSamplerInfo, (self, CL_SAMPLER_FILTER_MODE, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (value [i] ? &PL_sv_yes : &PL_sv_no));
#endif
void
build_info (OpenCL::Program self, OpenCL::Device device, cl_program_build_info name)
PPCODE:
size_t size;
NEED_SUCCESS (GetProgramBuildInfo, (self, device, name, 0, 0, &size));
SV *sv = sv_2mortal (newSV (size));
SvUPGRADE (sv, SVt_PV);
SvPOK_only (sv);
#BEGIN:program_build
void
build_status (OpenCL::Program self, OpenCL::Device device)
PPCODE:
cl_int value [1];
NEED_SUCCESS (GetProgramBuildInfo, (self, device, CL_PROGRAM_BUILD_STATUS, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSViv (value [i])));
void
build_options (OpenCL::Program self, OpenCL::Device device)
ALIAS:
build_options = CL_PROGRAM_BUILD_OPTIONS
build_log = CL_PROGRAM_BUILD_LOG
PPCODE:
size_t size;
NEED_SUCCESS (GetProgramBuildInfo, (self, device, ix, 0, 0, &size));
char *value = tmpbuf (size);
NEED_SUCCESS (GetProgramBuildInfo, (self, device, ix, size, value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVpv (value, 0)));
void
binary_type (OpenCL::Program self, OpenCL::Device device)
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetProgramBuildInfo, (self, device, CL_PROGRAM_BINARY_TYPE, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv ((UV)value [i])));
#END:program_build
void
kernel (OpenCL::Program program, SV *function)
PPCODE:
NEED_SUCCESS_ARG (cl_kernel kernel, CreateKernel, (program, SvPVbyte_nolen (function), &res));
XPUSH_CLOBJ (stash_kernel, kernel);
void
kernels_in_program (OpenCL::Program program)
PPCODE:
cl_uint num_kernels;
NEED_SUCCESS (CreateKernelsInProgram, (program, 0, 0, &num_kernels));
cl_kernel *kernels = tmpbuf (sizeof (cl_kernel) * num_kernels);
NEED_SUCCESS (CreateKernelsInProgram, (program, num_kernels, kernels, 0));
for (i = 0; i < num_kernels; ++i)
PUSH_CLOBJ (stash_kernel, kernels [i]);
void
info (OpenCL::Program self, cl_program_info name)
PPCODE:
INFO (Program)
void
binaries (OpenCL::Program self)
PPCODE:
cl_uint n, i;
size_t size;
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_NUM_DEVICES , sizeof (n) , &n , 0));
if (!n) XSRETURN_EMPTY;
void
reference_count (OpenCL::Program self)
ALIAS:
reference_count = CL_PROGRAM_REFERENCE_COUNT
num_devices = CL_PROGRAM_NUM_DEVICES
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetProgramInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
context (OpenCL::Program self)
PPCODE:
cl_context value [1];
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_CONTEXT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainContext, (value [i]));
PUSH_CLOBJ (stash_context, value [i]);
void
devices (OpenCL::Program self)
PPCODE:
size_t size;
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_DEVICES, 0, 0, &size));
cl_device_id *value = tmpbuf (size);
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_DEVICES, size, value, 0));
int i, n = size / sizeof (*value);
for (i = 0; i < n; ++i)
PUSH_CLOBJ (stash_device, value [i]);
void
source (OpenCL::Program self)
PPCODE:
size_t size;
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_SOURCE, 0, 0, &size));
char *value = tmpbuf (size);
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_SOURCE, size, value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVpv (value, 0)));
void
binary_sizes (OpenCL::Program self)
PPCODE:
size_t size;
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_BINARY_SIZES, 0, 0, &size));
size_t *value = tmpbuf (size);
NEED_SUCCESS (GetProgramInfo, (self, CL_PROGRAM_BINARY_SIZES, size, value, 0));
int i, n = size / sizeof (*value);
CODE:
clSetKernelArg (self, idx, sizeof (value), &value);
void
info (OpenCL::Kernel self, cl_kernel_info name)
PPCODE:
INFO (Kernel)
#BEGIN:kernel
void
function_name (OpenCL::Kernel self)
PPCODE:
size_t size;
NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_FUNCTION_NAME, 0, 0, &size));
char *value = tmpbuf (size);
NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_FUNCTION_NAME, size, value, 0));
EXTEND (SP, 1);
void
num_args (OpenCL::Kernel self)
ALIAS:
num_args = CL_KERNEL_NUM_ARGS
reference_count = CL_KERNEL_REFERENCE_COUNT
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetKernelInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
context (OpenCL::Kernel self)
PPCODE:
cl_context value [1];
NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_CONTEXT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainContext, (value [i]));
PUSH_CLOBJ (stash_context, value [i]);
void
program (OpenCL::Kernel self)
PPCODE:
cl_program value [1];
NEED_SUCCESS (GetKernelInfo, (self, CL_KERNEL_PROGRAM, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainProgram, (value [i]));
#END:kernel
void
work_group_info (OpenCL::Kernel self, OpenCL::Device device, cl_kernel_work_group_info name)
PPCODE:
size_t size;
NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, name, 0, 0, &size));
SV *sv = sv_2mortal (newSV (size));
SvUPGRADE (sv, SVt_PV);
SvPOK_only (sv);
void
work_group_size (OpenCL::Kernel self, OpenCL::Device device)
ALIAS:
work_group_size = CL_KERNEL_WORK_GROUP_SIZE
preferred_work_group_size_multiple = CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
PPCODE:
size_t value [1];
NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
compile_work_group_size (OpenCL::Kernel self, OpenCL::Device device)
PPCODE:
size_t size;
NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, 0, 0, &size));
size_t *value = tmpbuf (size);
NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, size, value, 0));
int i, n = size / sizeof (*value);
void
local_mem_size (OpenCL::Kernel self, OpenCL::Device device)
ALIAS:
local_mem_size = CL_KERNEL_LOCAL_MEM_SIZE
private_mem_size = CL_KERNEL_PRIVATE_MEM_SIZE
PPCODE:
cl_ulong value [1];
NEED_SUCCESS (GetKernelWorkGroupInfo, (self, device, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
#if CL_VERSION_1_2
void
arg_info (OpenCL::Kernel self, cl_uint idx, cl_kernel_arg_info name)
PPCODE:
size_t size;
NEED_SUCCESS (GetKernelArgInfo, (self, idx, name, 0, 0, &size));
SV *sv = sv_2mortal (newSV (size));
SvUPGRADE (sv, SVt_PV);
SvPOK_only (sv);
void
arg_address_qualifier (OpenCL::Kernel self, cl_uint idx)
ALIAS:
arg_address_qualifier = CL_KERNEL_ARG_ADDRESS_QUALIFIER
arg_access_qualifier = CL_KERNEL_ARG_ACCESS_QUALIFIER
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetKernelArgInfo, (self, idx, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
arg_type_name (OpenCL::Kernel self, cl_uint idx)
ALIAS:
arg_type_name = CL_KERNEL_ARG_TYPE_NAME
arg_name = CL_KERNEL_ARG_NAME
PPCODE:
size_t size;
NEED_SUCCESS (GetKernelArgInfo, (self, idx, ix, 0, 0, &size));
char *value = tmpbuf (size);
NEED_SUCCESS (GetKernelArgInfo, (self, idx, ix, size, value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVpv (value, 0)));
void
arg_type_qualifier (OpenCL::Kernel self, cl_uint idx)
PPCODE:
cl_ulong value [1];
NEED_SUCCESS (GetKernelArgInfo, (self, idx, CL_KERNEL_ARG_TYPE_QUALIFIER, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
CODE:
clSetEventCallback (self, command_exec_callback_type, eq_event_notify, SvREFCNT_inc (s_get_cv (cb)));
void
info (OpenCL::Event self, cl_event_info name)
PPCODE:
INFO (Event)
#BEGIN:event
void
command_queue (OpenCL::Event self)
PPCODE:
cl_command_queue value [1];
NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_COMMAND_QUEUE, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainCommandQueue, (value [i]));
command_type (OpenCL::Event self)
ALIAS:
command_type = CL_EVENT_COMMAND_TYPE
reference_count = CL_EVENT_REFERENCE_COUNT
command_execution_status = CL_EVENT_COMMAND_EXECUTION_STATUS
PPCODE:
cl_uint value [1];
NEED_SUCCESS (GetEventInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
void
context (OpenCL::Event self)
PPCODE:
cl_context value [1];
NEED_SUCCESS (GetEventInfo, (self, CL_EVENT_CONTEXT, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
NEED_SUCCESS (RetainContext, (value [i]));
#END:event
void
profiling_info (OpenCL::Event self, cl_profiling_info name)
PPCODE:
INFO (EventProfiling)
#BEGIN:profiling
void
ALIAS:
profiling_command_queued = CL_PROFILING_COMMAND_QUEUED
profiling_command_submit = CL_PROFILING_COMMAND_SUBMIT
profiling_command_start = CL_PROFILING_COMMAND_START
profiling_command_end = CL_PROFILING_COMMAND_END
PPCODE:
cl_ulong value [1];
NEED_SUCCESS (GetEventProfilingInfo, (self, ix, sizeof (value), value, 0));
EXTEND (SP, 1);
const int i = 0;
PUSHs (sv_2mortal (newSVuv (value [i])));
OUTPUT:
RETVAL
void
wait (OpenCL::Mapped self)
PPCODE:
if (self->event)
NEED_SUCCESS (WaitForEvents, (1, &self->event));
void
event (OpenCL::Mapped self)
PPCODE:
if (!self->event)
XSRETURN_UNDEF;
clRetainEvent (self->event);
XPUSH_CLOBJ (stash_event, self->event);
memcpy (offset + (char *)self->ptr, ptr, len);
void
get_row (OpenCL::Mapped self, size_t count, size_t x = 0, size_t y = 0, size_t z = 0)
PPCODE:
if (!SvOK (ST (1)))
count = self->width - x;
if (x + count > self->width)
croak ("OpenCL::Mapped::get: x + count crosses a row boundary");
char *ptr = (char *)self->ptr + x + y * self->row_pitch + z * self->slice_pitch;
XPUSHs (sv_2mortal (newSVpvn (ptr, count)));
void
set_row (OpenCL::Mapped self, SV *data, size_t x = 0, size_t y = 0, size_t z = 0)
PPCODE:
STRLEN count;
char *dataptr = SvPVbyte (data, count);
size_t element = mapped_element_size (self);
x *= element;
OpenGL
view release on metacpan or search on metacpan
lib/OpenGL/Array.xs view on Meta::CPAN
#//# @data = $oga->retrieve($pos,$len);
#//- Get OGA data array, by offset and length
void
retrieve(oga, ...)
OpenGL::Array oga
PPCODE:
{
GLint pos = (items > 1) ? SvIV(ST(1)) : 0;
GLint len = (items > 2) ? SvIV(ST(2)) : (oga->item_count - pos);
char * offset;
int end = pos + len;
lib/OpenGL/Array.xs view on Meta::CPAN
#//# @dimensions = $oga->get_dimensions();
#//- Get OGA data array, by offset and length
void
get_dimensions(oga)
OpenGL::Array oga
PPCODE:
{
int end = oga->dimension_count;
int i = 0;
EXTEND(sp, end);
( run in 1.509 second using v1.01-cache-2.11-cpan-71847e10f99 )