/////////////////////////////////////////////////////////
// enumerate devices
//
/////////////////////////////////////////////////////////
void pix_video :: enumerateMess()
{
std::vector<std::string>data;
std::vector<std::string>backends;
unsigned int i=0;
for(i=0; i<m_videoHandles.size(); i++) {
// a.insert(a.end(), b.begin(), b.end());
if(m_videoHandles[i]) {
std::string name=m_videoHandles[i]->getName();
logpost(NULL, 5, "enumerating: %s", name.c_str());
std::vector<std::string>temp=m_videoHandles[i]->enumerate();
unsigned int i=0;
for(i=0; i<temp.size(); i++) {
backends.push_back(name);
data.push_back(temp[i]);
}
}
}
if(data.size()<=0) {
error("no devices found");
}
t_atom ap[2];
SETFLOAT(ap, data.size());
outlet_anything(m_infoOut, gensym("devices"), 1, ap);
for(i=0; i<data.size(); i++) {
SETSYMBOL(ap+0, gensym(data[i].c_str()));
SETSYMBOL(ap+1, gensym(backends[i].c_str()));
outlet_anything(m_infoOut, gensym("device"), 2, ap);
// post("%d: %s", i, data[i].c_str());
}
}
static void wiimote_cwiid_motionplus(t_wiimote *x, struct cwiid_motionplus_mesg *mesg)
{
t_atom ap[4];
t_float scale = 1.f;// / ((uint16_t)0xFFFF);
t_float phi = scale*mesg->angle_rate[CWIID_PHI];
t_float theta= scale*mesg->angle_rate[CWIID_THETA];
t_float psi = scale*mesg->angle_rate[CWIID_PSI];
t_float phi_speed = 1.;
t_float theta_speed = 1.;
t_float psi_speed = 1.;
SETSYMBOL(ap+0, gensym("low_speed"));
#ifdef HAVE_CWIID_MOTIONPLUS_LOWSPEED
phi_speed = mesg->low_speed[CWIID_PHI];
theta_speed= mesg->low_speed[CWIID_THETA];
psi_speed = mesg->low_speed[CWIID_PSI];
#endif
SETFLOAT (ap+1, phi_speed);
SETFLOAT (ap+2, theta_speed);
SETFLOAT (ap+3, psi_speed);
outlet_anything(x->outlet_data, gensym("motionplus"), 4, ap);
SETSYMBOL(ap+0, gensym("angle_rate"));
SETFLOAT (ap+1, phi);
SETFLOAT (ap+2, theta);
SETFLOAT (ap+3, psi);
outlet_anything(x->outlet_data, gensym("motionplus"), 4, ap);
}
static void glinfo_bang(t_glinfo *info) {
GLint major, minor;
glGetIntegerv(GL_MAJOR_VERSION, &major);
glGetIntegerv(GL_MINOR_VERSION, &minor);
t_atom version[2];
SETFLOAT(version, (float)major);
SETFLOAT(version+1, (float)minor);
post("gl.info: %s, major: %d, minor: %d\n", glGetString(GL_VERSION), major, minor);
outlet_list(info->out_version, gensym("version"), 2, version);
t_atom vendor[1];
char *vendor_str = (char*)glGetString(GL_VENDOR);
SETSYMBOL(vendor, gensym(vendor_str?vendor_str:"(null)"));
outlet_list(info->out_vendor, gensym("vendor"), 1, vendor);
t_atom renderer[1];
char *renderer_str = (char*)glGetString(GL_RENDERER);
SETSYMBOL(renderer, gensym(renderer_str?renderer_str:"(null)"));
outlet_list(info->out_vendor, gensym("renderer"), 1, renderer);
GLint numextensions;
glGetIntegerv(GL_NUM_EXTENSIONS, &numextensions);
t_atom extensions[numextensions];
for (int i = 0; i < numextensions; i++) {
SETSYMBOL(extensions+i, gensym((char*)glGetStringi(GL_EXTENSIONS, i)));
}
outlet_list(info->out_extensions, gensym("extensions"), numextensions, extensions);
t_atom glsl_version[1];
char *glsl_version_str = (char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
SETSYMBOL(glsl_version, gensym(glsl_version_str?glsl_version_str:"(null)"));
outlet_list(info->out_glsl_ver, gensym("glsl-version"), 1, glsl_version);
}
/////////////////////////////////////////////////////////
// spits out a list of installed codecs and stores them
//
/////////////////////////////////////////////////////////
void pix_record :: getCodecList()
{
m_pimpl->clearCodecHandle();
unsigned int i=0;
for(i=0; i<m_handles.size(); i++) {
std::vector<std::string>c=m_handles[i]->getCodecs();
unsigned int j;
for(j=0; j<c.size(); j++) {
m_pimpl->addCodecHandle(m_handles[i], c[j]);
}
}
for(i=0; i<m_pimpl->m_codecs.size(); i++) {
const std::string id=m_pimpl->m_codecs[i];
std::vector<PIMPL::codechandle>handles=m_pimpl->m_codechandle[id];
unsigned int j=0;
for(j=0; j<handles.size(); j++) {
gem::plugins::record*handle=handles[j].handle;
const std::string codecname=handles[j].codec;
const std::string descr=handle->getCodecDescription(codecname);
t_atom ap[3];
logpost(NULL, 6, "codec%d: '%s': %s", i, codecname.c_str(), (descr.empty()?"":descr.c_str()));
SETFLOAT (ap+0, static_cast<t_float>(i));
SETSYMBOL(ap+1, gensym(codecname.c_str()));
SETSYMBOL(ap+2, gensym(descr.c_str()));
outlet_anything(m_outInfo, gensym("codec"), 3, ap);
}
}
}
static int imaction_P2_scope(t_port *x, char *name)
{
if (x->x_inatoms > 6)
{
t_atom *out = x->x_outmess;
int i, xpix, ypix;
SETSYMBOL(out, gensym("#X")); out++;
SETSYMBOL(out, gensym("obj")); out++;
port_setxy(x, 3, out);
xpix = (int)out++->a_w.w_float;
ypix = (int)out->a_w.w_float;
binbuf_add(x->x_outbb, 4, x->x_outmess);
import_addclassname(x, name, &x->x_inmess[2]);
out = x->x_outmess;
port_setxy(x, 5, out);
out++->a_w.w_float -= xpix;
out++->a_w.w_float -= ypix;
out = import_copyatoms(out, x->x_inmess + 7, x->x_inatoms - 7);
SETSEMI(out);
binbuf_add(x->x_outbb, x->x_inatoms - 4, x->x_outmess);
x->x_nobj++;
return (PORT_NEXT);
}
else return (PORT_CORRUPT);
}
static void bin_ambi_reduced_decode_fft_load_HRIR(t_bin_ambi_reduced_decode_fft *x, t_float findex)
{
int xindex=(int)findex - 1;
int p;
char buf[60];
if(xindex < 0)
xindex = 0;
if(xindex >= (x->x_n_ind_ls + x->x_n_mrg_mir_ls))
xindex = x->x_n_ind_ls + x->x_n_mrg_mir_ls - 1;
p = x->x_phi[xindex];
if(p)/*change*/
p = 360 - p;
if(p < 10)
sprintf(buf, "L%de00%da.wav", x->x_delta[xindex], p);
else if(p < 100)
sprintf(buf, "L%de0%da.wav", x->x_delta[xindex], p);
else
sprintf(buf, "L%de%da.wav", x->x_delta[xindex], p);
x->x_hrir_filename[xindex] = gensym(buf);
SETSYMBOL(x->x_at, x->x_hrir_filename[xindex]);
SETSYMBOL(x->x_at+1, x->x_s_hrir[xindex]);
outlet_list(x->x_obj.ob_outlet, &s_list, 2, x->x_at);
}
static void plugin_tilde_ladspa_describe(const char * pcFullFilename,
void * pvPluginHandle,
LADSPA_Descriptor_Function fDescriptorFunction, void* user_data) {
Pd_Plugin_Tilde* x = (((void**)user_data)[0]);
t_atom at[1];
const LADSPA_Descriptor * psDescriptor;
long lIndex;
SETSYMBOL(at, gensym(pcFullFilename));
outlet_anything (x->control_outlet, gensym ("library"), 1, at);
for (lIndex = 0;
(psDescriptor = fDescriptorFunction(lIndex)) != NULL;
lIndex++) {
SETSYMBOL(at, gensym ((char*)psDescriptor->Name));
outlet_anything (x->control_outlet, gensym ("name"), 1, at);
SETSYMBOL(at, gensym ((char*)psDescriptor->Label));
outlet_anything (x->control_outlet, gensym ("label"), 1, at);
SETFLOAT(at, psDescriptor->UniqueID);
outlet_anything (x->control_outlet, gensym ("id"), 1, at);
SETSYMBOL(at, gensym ((char*)psDescriptor->Maker));
outlet_anything (x->control_outlet, gensym ("maker"), 1, at);
}
}
void pix_video :: getPropertyMess(int argc, t_atom*argv)
{
if(argc) {
int i=0;
m_readprops.clear();
for(i=0; i<argc; i++) {
addProperties(m_readprops, 1, argv+i);
}
} else {
/* LATER: read all properties */
}
t_atom ap[4];
if(m_videoHandle) {
m_videoHandle->getProperties(m_readprops);
std::vector<std::string>keys=m_readprops.keys();
unsigned int i=0;
for(i=0; i<keys.size(); i++) {
std::string key=keys[i];
SETSYMBOL(ap+0, gensym(key.c_str()));
int ac=0;
switch(m_readprops.type(key)) {
default:
case gem::Properties::UNSET:
ac=0;
break;
case gem::Properties::NONE:
ac=1;
break;
case gem::Properties::DOUBLE:
do {
double d=0;
if(m_readprops.get(key, d)) {
ac=2;
SETFLOAT(ap+1, d);
}
} while(0);
break;
case gem::Properties::STRING:
do {
std::string s;
if(m_readprops.get(key, s)) {
ac=2;
SETSYMBOL(ap+1, gensym(s.c_str()));
}
} while(0);
break;
}
if(ac) {
outlet_anything(m_infoOut, gensym("prop"), ac, ap);
} else {
post("oops: %s", key.c_str());
}
}
} else {
logpost(NULL, 5, "no open videodevice...remembering properties...");
}
}
static void wiimote_cwiid_classic(t_wiimote *x, struct cwiid_classic_mesg *mesg)
{
t_atom ap[3];
// t_float scale = 1.f / ((uint16_t)0xFFFF);
SETSYMBOL(ap+0, gensym("left_stick"));
SETFLOAT (ap+1, mesg->l_stick[CWIID_X]);
SETFLOAT (ap+2, mesg->l_stick[CWIID_Y]);
outlet_anything(x->outlet_data, gensym("classic"), 3, ap);
SETSYMBOL(ap+0, gensym("right_stick"));
SETFLOAT (ap+1, mesg->r_stick[CWIID_X]);
SETFLOAT (ap+2, mesg->r_stick[CWIID_Y]);
outlet_anything(x->outlet_data, gensym("classic"), 3, ap);
SETSYMBOL(ap+0, gensym("left"));
SETFLOAT (ap+1, mesg->l);
outlet_anything(x->outlet_data, gensym("classic"), 2, ap);
SETSYMBOL(ap+0, gensym("right"));
SETFLOAT (ap+1, mesg->r);
outlet_anything(x->outlet_data, gensym("classic"), 2, ap);
SETSYMBOL(ap+0, gensym("button"));
SETFLOAT(ap+1, (mesg->buttons & 0xFF00)>>8);
SETFLOAT(ap+2, mesg->buttons & 0x00FF);
outlet_anything(x->outlet_data, gensym("classic"), 3, ap);
}
/* send stream info */
static void udpsend_tilde_info(t_udpsend_tilde *x)
{
t_atom list[2];
t_symbol *sf_format;
t_float bitrate;
bitrate = (t_float)((SF_SIZEOF(x->x_tag.format) * x->x_samplerate * 8 * x->x_tag.channels) / 1000.);
switch (x->x_tag.format)
{
case SF_FLOAT:
{
sf_format = ps_sf_float;
break;
}
case SF_16BIT:
{
sf_format = ps_sf_16bit;
break;
}
case SF_8BIT:
{
sf_format = ps_sf_8bit;
break;
}
default:
{
sf_format = ps_sf_unknown;
break;
}
}
/* --- stream information (t_tag) --- */
/* audio format */
SETSYMBOL(list, (t_symbol *)sf_format);
outlet_anything(x->x_outlet2, ps_format, 1, list);
/* channels */
SETFLOAT(list, (t_float)x->x_tag.channels);
outlet_anything(x->x_outlet2, ps_channels, 1, list);
/* current signal vector size */
SETFLOAT(list, (t_float)x->x_vecsize);
outlet_anything(x->x_outlet2, ps_vecsize, 1, list);
/* framesize */
SETFLOAT(list, (t_float)(ntohl(x->x_tag.framesize)));
outlet_anything(x->x_outlet2, ps_framesize, 1, list);
/* bitrate */
SETFLOAT(list, (t_float)bitrate);
outlet_anything(x->x_outlet2, ps_bitrate, 1, list);
/* IP address */
SETSYMBOL(list, (t_symbol *)x->x_hostname);
outlet_anything(x->x_outlet2, ps_hostname, 1, list);
}
static void mtxFFTMatrixHot (MtxFFT *x, t_symbol *s,
int argc, t_atom *argv)
{
int rows, columns, size;
int fft_count;
t_atom *list_re = x->list_re;
t_atom *list_im = x->list_im;
t_float *f_re = x->f_re;
t_float *f_im = x->f_im;
/* fftsize check */
if(iemmatrix_check(x, argc, argv, 0))return;
rows = atom_getint (argv++);
columns = atom_getint (argv++);
size = rows * columns;
if (size != x->size) {
pd_error(x, "[mtx_fft]: left matrix has other dimensions than right matrix");
} else if (columns < 4) {
pd_error(x, "[mtx_fft]: matrix must have at least 4 columns");
} else if (columns == (1 << ilog2(columns))) {
/* ok, do the FFT! */
/* main part */
readFloatFromList (size, argv, f_re);
fft_count = rows;
list_re += 2;
list_im += 2;
while (fft_count--) {
mayer_fft (columns, f_re, f_im);
writeFloatIntoList (columns, list_re, f_re);
writeFloatIntoList (columns, list_im, f_im);
f_im += columns;
f_re += columns;
list_re += columns;
list_im += columns;
}
list_re = x->list_re;
list_im = x->list_im;
SETSYMBOL(list_re, gensym("matrix"));
SETSYMBOL(list_im, gensym("matrix"));
SETFLOAT(list_re, rows);
SETFLOAT(list_im, rows);
SETFLOAT(list_re+1, columns);
SETFLOAT(list_im+1, columns);
outlet_anything(x->list_im_out, gensym("matrix"),
x->size+2, list_im);
outlet_anything(x->list_re_out, gensym("matrix"),
x->size+2, list_re);
} else {
pd_error(x, "[mtx_fft]: rowvector size no power of 2!");
}
}
static void import_addclassname(t_port *x, char *outname, t_atom *inatom)
{
t_atom at;
if (outname)
SETSYMBOL(&at, gensym(outname));
else
{
t_symbol *insym = 0;
if (inatom->a_type == A_SYMBOL)
{
/* LATER bash inatom to lowercase (CHECKME first) */
insym = inatom->a_w.w_symbol;
if (import_mapping && import_mapsize)
{
char **fromp = import_mapping, **top = import_mapping + 1;
int cnt = import_mapsize;
while (cnt--)
{
if (strcmp(*fromp, insym->s_name))
{
fromp += 2;
top += 2;
}
else
{
insym = gensym(*top);
inatom = 0;
break;
}
}
}
if (insym != &s_bang && insym != &s_float &&
insym != &s_symbol && insym != &s_list &&
(insym == portps_inlet || insym == portps_outlet ||
zgetfn(&pd_objectmaker, insym) == 0))
{
x->x_withbogus = 1;
SETSYMBOL(&at, portps_bogus);
binbuf_add(x->x_outbb, 1, &at);
}
}
if (inatom)
import_copyatoms(&at, inatom, 1);
else if (insym)
SETSYMBOL(&at, insym);
else
{
loudbug_bug("import_addclassname");
SETSYMBOL(&at, gensym("???"));
}
}
binbuf_add(x->x_outbb, 1, &at);
}
void classtable_tovec(int size, t_atom *vec)
{
t_classtable *t;
int i;
for(t = ct, i = 0; t && i < size; t = t->ct_next, i++)
if (!t->ct_class->c_name)
{
SETSYMBOL(vec+i, gensym("anonymous-class"));
}
else
SETSYMBOL(vec+i, t->ct_class->c_name);
}
void gemglutwindow :: menuMess(void) {
int id=glutCreateMenu(menuCb);
glutAttachMenu(GLUT_RIGHT_BUTTON);
std::vector<t_atom>alist;
t_atom a;
SETSYMBOL(&a, gensym("menu")); alist.push_back(a);
SETSYMBOL(&a, gensym("new") ); alist.push_back(a);
SETFLOAT (&a, id ); alist.push_back(a);
info(alist);
}
/*--------------------------------------------------------------------
* get , get CATEGORY
*/
static void locale_get(t_locale *x, t_symbol *catsym)
{
int cat = sym2cat((t_object*)x, catsym);
char *val;
t_atom valatom;
val = setlocale(cat, NULL);
if (val) {
SETSYMBOL(&valatom,gensym(val));
} else {
SETSYMBOL(&valatom,&s_);
}
outlet_anything(x->x_outlet, catsym, 1, &valatom);
}
static void h_multimap_value(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
{
t_h_multimap *x = (t_h_multimap *)(p->x);
// symbol without selector "symbol":
if(argc == 0)
{
t_atom tmp;
SETSYMBOL(&tmp, s);
x->value.setAtoms(1, &tmp);
x->event_set = true;
return;
}
// input is a list without selector "list":
// input is a list without selector "list":
if ( argc && (strcmp(s->s_name,"list")!=0)
&& (strcmp(s->s_name,"float")!=0)
&& (strcmp(s->s_name,"symbol")!=0)
&& (strcmp(s->s_name,"pointer")!=0) )
{
t_atom *atoms = (t_atom*)getbytes( (argc+1)*sizeof(t_atom) );
// add the selector symbol to the list:
SETSYMBOL(atoms, s);
for(int i=0; i<argc; i++)
{
if(argv[i].a_type == A_FLOAT)
SETFLOAT(&atoms[i+1],argv[i].a_w.w_float);
if(argv[i].a_type == A_SYMBOL)
SETSYMBOL(&atoms[i+1],argv[i].a_w.w_symbol);
if(argv[i].a_type == A_POINTER)
SETPOINTER(&atoms[i+1],argv[i].a_w.w_gpointer);
}
x->value.setAtoms(argc+1, atoms);
x->event_set = true;
freebytes(atoms, (argc+1)*sizeof(t_atom));
return;
}
// "normal" input (list, float, symbol or pointer):
if (argc)
{
x->value.setAtoms(argc, argv);
x->event_set = true;
return;
}
}
static void audiosettings_listdevices(t_audiosettings *x)
{
int i;
char indevlist[MAXNDEV][DEVDESCSIZE], outdevlist[MAXNDEV][DEVDESCSIZE];
int indevs = 0, outdevs = 0, canmulti = 0, cancallback = 0;
t_atom atoms[3];
sys_get_audio_devs((char*)indevlist, &indevs,
(char*)outdevlist, &outdevs,
&canmulti, &cancallback,
MAXNDEV, DEVDESCSIZE);
SETSYMBOL (atoms+0, gensym("driver"));
SETSYMBOL (atoms+1, as_getdrivername(sys_audioapi));
outlet_anything(x->x_info, gensym("device"), 2, atoms);
SETSYMBOL (atoms+0, gensym("multi"));
SETFLOAT (atoms+1, (t_float)canmulti);
outlet_anything(x->x_info, gensym("device"), 2, atoms);
SETSYMBOL (atoms+0, gensym("callback"));
SETFLOAT (atoms+1, (t_float)cancallback);
outlet_anything(x->x_info, gensym("device"), 2, atoms);
SETSYMBOL(atoms+0, gensym("in"));
SETSYMBOL(atoms+1, gensym("devices"));
SETFLOAT (atoms+2, (t_float)indevs);
outlet_anything(x->x_info, gensym("device"), 3, atoms);
for(i=0; i<indevs; i++) {
SETFLOAT (atoms+1, (t_float)i);
SETSYMBOL(atoms+2, gensym(indevlist[i]));
outlet_anything(x->x_info, gensym("device"), 3, atoms);
}
SETSYMBOL(atoms+0, gensym("out"));
SETSYMBOL(atoms+1, gensym("devices"));
SETFLOAT (atoms+2, (t_float)outdevs);
outlet_anything(x->x_info, gensym("device"), 3, atoms);
for(i=0; i<outdevs; i++) {
SETFLOAT (atoms+1, (t_float)i);
SETSYMBOL(atoms+2, gensym(outdevlist[i]));
outlet_anything(x->x_info, gensym("device"), 3, atoms);
}
}
// not yet...
static void radialBeamformInfo (RadialBeamform *x) {
t_atom list[3];
SETSYMBOL(&list[0],gensym("n"));
SETFLOAT(&list[1],x->sh_degree);
outlet_list(x->list_outlet, &s_list,2,list);
if (x->bf_mode==VELOCITY)
SETSYMBOL(&list[0],gensym("v"));
else
SETSYMBOL(&list[0],gensym("p"));
outlet_list(x->list_outlet, &s_list,1,list);
SETSYMBOL(&list[0],gensym("max_wng"));
SETFLOAT(&list[1],x->max_wng);
outlet_list(x->list_outlet, &s_list,2,list);
SETSYMBOL(&list[0],gensym("omega_cutoff"));
SETFLOAT(&list[1],x->omega_cutoff);
outlet_list(x->list_outlet, &s_list,2,list);
SETSYMBOL(&list[0],gensym("cutoff_slope"));
SETFLOAT(&list[1],x->slope_cutoff);
outlet_list(x->list_outlet, &s_list,2,list);
SETSYMBOL(&list[0],gensym("delta_n"));
SETFLOAT(&list[1],x->delta_n);
outlet_list(x->list_outlet, &s_list,2,list);
SETSYMBOL(&list[0],gensym("delta_n0"));
SETFLOAT(&list[1],x->delta_n0);
outlet_list(x->list_outlet, &s_list,2,list);
}
/* keyboard buttons */
void GemWindow::key(int devId, std::string sid, int iid, int state) {
t_atom ap[4];
SETFLOAT (ap+0, devId);
SETSYMBOL(ap+1, gensym("keyname"));
SETSYMBOL(ap+2, gensym(sid.c_str()));
SETFLOAT (ap+3, state);
info(gensym("keyboard"), 4, ap);
//SETFLOAT (ap+0, devId);
SETSYMBOL(ap+1, gensym("key"));
SETFLOAT (ap+2, iid);
//SETFLOAT (ap+3, state);
info(gensym("keyboard"), 4, ap);
}
static void trigger2_anything(t_trigger2 *x, t_symbol *s, int argc, t_atom *argv){
t_atom *av2 = NULL;
t_trigger2out *u;
int i, j = 0;
for (i = x->x_n, u = x->x_vec + i; u--, i--;){
if (u->u_type == TR_BANG)
outlet_bang(u->u_outlet);
else if (u->u_type == TR_ANYTHING)
outlet_anything(u->u_outlet, s, argc, argv);
else if (u->u_type == TR_STATIC_FLOAT)
outlet_float(u->u_outlet, u->u_float);
else if (u->u_type == TR_STATIC_SYMBOL)
outlet_symbol(u->u_outlet, u->u_sym);
else{
// copying trigger2_list behavior except that here we keep
// the outlet number and therefore avoid redundant printouts
if (u->u_type == TR_FLOAT)
outlet_float(u->u_outlet, (argc ? atom_getfloat(argv) : 0));
else if (u->u_type == TR_BANG)
outlet_bang(u->u_outlet);
else if (u->u_type == TR_SYMBOL)
outlet_symbol(u->u_outlet,
(s != NULL ? s : (argc ? atom_getsymbol(argv) : &s_symbol)));
else if (u->u_type == TR_ANYTHING)
outlet_anything(u->u_outlet, s, argc, argv);
else if (u->u_type == TR_POINTER)
if (!argc || argv->a_type != TR_POINTER)
pd_error(x, "unpack: bad pointer");
else outlet_pointer(u->u_outlet, argv->a_w.w_gpointer);
else if (u->u_type == TR_STATIC_FLOAT)
outlet_float(u->u_outlet, u->u_float);
else if (u->u_type == TR_STATIC_SYMBOL)
outlet_symbol(u->u_outlet, u->u_sym);
else{ // Ico: don't have to worry about zero element case (AFAICT)
av2 = (t_atom *)getbytes((argc + 1) * sizeof(t_atom));
SETSYMBOL(av2, s);
if (argc == 0)
outlet_list(u->u_outlet, &s_symbol, argc+1, av2);
else{
for (j = 0; j < argc; j++)
av2[j + 1] = argv[j];
SETSYMBOL(av2, s);
outlet_list(u->u_outlet, &s_list, argc+1, av2);
}
freebytes(av2, (argc + 1) * sizeof(t_atom));
}
}
}
}
void split_anything(t_split *x,t_symbol* s,t_int argc,t_atom* argv)
{
int i = argc; int j;
t_symbol* cur;
t_atom a_out[256];
int c_out = 0;
t_atom* a = a_out;
// char *str;
char u[MAXPDSTRING];
char v[MAXPDSTRING];
// char *v;
u[0] = '\0';
v[0] = '\0';
int isnum = 1;
// float tf;
for(j=0; j<strlen(s->s_name); j++) {
u[0] = s->s_name[j];
if(u[0] == x->x_splitter->s_name[0]) {
if(v[0] != '\0') { // delimiter is first character
// check if string is digits only
if(split_string_isnum(v)) {
SETFLOAT(a, (float)atof(v));
}
else {
SETSYMBOL(a, gensym(v));
}
a++; c_out++;
// reset stuff
v[0] = '\0';
isnum = 1;
} // v[0] != '\0'
} else {
strncat(v, u, 1);
} // char matches splitter
}
// have to do this again here, damn.
if(split_string_isnum(v)) {
SETFLOAT(a, (float)atof(v));
}
else {
SETSYMBOL(a, gensym(v));
}
a++, c_out++;
outlet_list(x->x_obj.ob_outlet, &s_list, c_out, (t_atom*)&a_out);
// outlet_anything(x->x_obj.ob_outlet,gensym("list"),c_out,(t_atom*)&a_out);
}
static void pd_defaultsymbol(t_pd *x, t_symbol *s)
{
if (*(*x)->c_listmethod != pd_defaultlist)
{
t_atom at;
SETSYMBOL(&at, s);
(*(*x)->c_listmethod)(x, 0, 1, &at);
}
else
{
t_atom at;
SETSYMBOL(&at, s);
(*(*x)->c_anymethod)(x, &s_symbol, 1, &at);
}
}
static t_atom *scommon_dump(t_scommon *x,t_symbol *s)
{
int i;
t_atom *atombuf;
atombuf = (t_atom *)getbytes(sizeof(t_atom)*x->c_len);
for(i=0; i<x->c_len; i++)
{
if(x->c_array[i]==&s_) SETSYMBOL(&atombuf[i],s);
else SETSYMBOL(&atombuf[i],x->c_array[i]);
}
return atombuf;
}
static void *trigger_new(t_symbol *s, int argc, t_atom *argv)
{
#ifdef ROCKBOX
(void) s;
#endif
t_trigger *x = (t_trigger *)pd_new(trigger_class);
t_atom defarg[2], *ap;
t_triggerout *u;
int i;
if (!argc)
{
argv = defarg;
argc = 2;
SETSYMBOL(&defarg[0], &s_bang);
SETSYMBOL(&defarg[1], &s_bang);
}
x->x_n = argc;
x->x_vec = (t_triggerout *)getbytes(argc * sizeof(*x->x_vec));
for (i = 0, ap = argv, u = x->x_vec; i < argc; u++, ap++, i++)
{
t_atomtype thistype = ap->a_type;
char c;
if (thistype == TR_SYMBOL) c = ap->a_w.w_symbol->s_name[0];
else if (thistype == TR_FLOAT) c = 'f';
else c = 0;
if (c == 'p')
u->u_type = TR_POINTER,
u->u_outlet = outlet_new(&x->x_obj, &s_pointer);
else if (c == 'f')
u->u_type = TR_FLOAT, u->u_outlet = outlet_new(&x->x_obj, &s_float);
else if (c == 'b')
u->u_type = TR_BANG, u->u_outlet = outlet_new(&x->x_obj, &s_bang);
else if (c == 'l')
u->u_type = TR_LIST, u->u_outlet = outlet_new(&x->x_obj, &s_list);
else if (c == 's')
u->u_type = TR_SYMBOL,
u->u_outlet = outlet_new(&x->x_obj, &s_symbol);
else if (c == 'a')
u->u_type = TR_ANYTHING,
u->u_outlet = outlet_new(&x->x_obj, &s_symbol);
else
{
pd_error(x, "trigger: %s: bad type", ap->a_w.w_symbol->s_name);
u->u_type = TR_FLOAT, u->u_outlet = outlet_new(&x->x_obj, &s_float);
}
}
return (x);
}
static void plugin_tilde_info (Pd_Plugin_Tilde* x) {
unsigned port_index = 0;
t_atom at[5];
LADSPA_PortDescriptor port_type;
LADSPA_PortRangeHintDescriptor iHintDescriptor;
if(!plugin_tilde_have_plugin(x))return;
for (port_index = 0; port_index < x->plugin.ladspa.type->PortCount; port_index++) {
port_type = x->plugin.ladspa.type->PortDescriptors[port_index];
iHintDescriptor = x->plugin.ladspa.type->PortRangeHints[port_index].HintDescriptor;
t_symbol*xlet=gensym("unknown");
t_symbol*type=gensym("unknown");
t_symbol*name=gensym("unknown");
t_float bound_lo=0.;
t_float bound_hi=1.;
if(LADSPA_IS_PORT_INPUT (port_type))
xlet=gensym("in");
else if (LADSPA_IS_PORT_OUTPUT (port_type))
xlet=gensym("out");
if (LADSPA_IS_PORT_CONTROL (port_type))
type=gensym("control");
else if (LADSPA_IS_PORT_AUDIO (port_type))
type=gensym("audio");
name=gensym(x->plugin.ladspa.type->PortNames[port_index]);
if (LADSPA_IS_HINT_BOUNDED_BELOW(iHintDescriptor))
bound_lo=x->plugin.ladspa.type->PortRangeHints[port_index].LowerBound;
if (LADSPA_IS_HINT_BOUNDED_ABOVE(iHintDescriptor))
bound_hi=x->plugin.ladspa.type->PortRangeHints[port_index].UpperBound;
// post("port#%d: %s %s %s %f..%f", port_index, xlet->s_name, type->s_name, name->s_name, bound_lo, bound_hi);
SETSYMBOL(at+0, xlet);
SETSYMBOL(at+1, type);
SETSYMBOL(at+2, name);
SETFLOAT (at+3, bound_lo);
SETFLOAT (at+4, bound_hi);
outlet_anything (x->control_outlet, gensym ("port"), 5, at);
}
}
static void hammergui__vised(t_hammergui *snk, t_symbol *s, t_floatarg f)
{
#ifdef HAMMERGUI_DEBUG
fprintf(stderr, "_vised %s %g (sink %x)\n",
(s ? s->s_name : "???"), f, (int)snk);
#endif
if (!snk->g_psvised)
{
bug("hammergui__vised");
return;
}
if (snk->g_psvised->s_thing)
{
t_atom at[2];
SETSYMBOL(&at[0], s);
SETFLOAT(&at[1], f);
pd_typedmess(snk->g_psvised->s_thing, ps__vised, 2, at);
}
#if 0
/* How to be notified about changes of button state, prior to gui objects
in a canvas? LATER find a reliable way -- delete if failed */
sys_vgui("bindtags %s {hammertag %s Canvas . all}\n",
s->s_name, s->s_name);
#endif
}
void split_list(t_split *x,t_symbol* s,t_int argc,t_atom* argv)
{
int i = argc;
t_symbol* cur;
t_atom a_out[256];
int c_out = 0;
t_atom* a = a_out;
while (i--) {
switch( argv->a_type) {
case A_FLOAT:
// post("flo: %f",atom_getfloat(argv));
SETFLOAT(a,atom_getfloat(argv));
a++;
c_out++;
break;
case A_SYMBOL:
// post("sym: %s",atom_getsymbol(argv)->s_name);
SETSYMBOL(a,atom_getsymbol(argv));
a++;
c_out++;
break;
default:
post("split.c: unknown type");
}
argv++;
}
outlet_anything(x->x_obj.ob_outlet,x->x_splitter,c_out,(t_atom*)&a_out);
//post("done");
}
static void add_symbol_to_output(t_group *x, t_symbol *s)
{
t_atom *temp_atom = getbytes(sizeof(t_atom));
SETSYMBOL(temp_atom, s);
add_atom_to_output(x,temp_atom);
freebytes(temp_atom,sizeof(t_atom));
}
static void list_cat_anything(t_list_cat *x, t_symbol *s,
int argc, t_atom *argv)
{
t_atom *outv;
int outc = x->x_alist.l_n + argc + 1;
XL_ATOMS_ALLOCA(outv, outc);
SETSYMBOL(outv + x->x_alist.l_n, s);
atoms_copy(argc, argv, outv + x->x_alist.l_n + 1);
if (x->x_alist.l_npointer)
{
t_alist y;
alist_clone(&x->x_alist, &y);
alist_toatoms(&y, outv);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
alist_clear(&y);
}
else
{
alist_toatoms(&x->x_alist, outv);
outlet_list(x->x_obj.ob_outlet, &s_list, outc, outv);
}
if (x->x_alist.l_n <= 1)
alist_anything(&x->x_alist, s, outc, outv);
else
alist_list(&x->x_alist, s, outc, outv);
XL_ATOMS_FREEA(outv, outc);
}
void gemglfw2window::charCallback(int character, int action) {
t_atom ap[3];
std::string sid;
switch(character) {
case 32:
sid = "Space";
break;
default:
sid += character;
}
SETSYMBOL(ap+0, gensym("keyname"));
SETSYMBOL(ap+1, gensym(sid.c_str()));
SETFLOAT (ap+2, action);
info(gensym("keyboard"), 3, ap);
}
