void omax_object_ioReport(t_object *x, t_symbol *msg, int argc, t_atom *argv)
{
long buflen;
char *buf = NULL;
if(argc == 0){
t_atom a;
atom_setsym(&a, gensym("/*"));
omax_object_createIOReport(x, msg, 1, &a, &buflen, &buf);
}else{
omax_object_createIOReport(x, msg, argc, argv, &buflen, &buf);
}
if(!buf){
return;
}
char bundle[buflen + OSC_HEADER_SIZE];
osc_bundle_s_setBundleID(bundle);
memcpy(bundle + OSC_HEADER_SIZE, buf, buflen);
void *outlet = omax_object_getInfoOutlet(x);
if(outlet){
t_atom out[2];
atom_setlong(out, buflen + OSC_HEADER_SIZE);
atom_setlong(out + 1, (long)bundle);
outlet_anything(outlet, gensym("FullPacket"), 2, out);
}
if(buf){
sysmem_freeptr(buf);
}
}
void odisplay_clear(t_odisplay *x)
{
char buf[OSC_HEADER_SIZE];
memset(buf, '\0', OSC_HEADER_SIZE);
osc_bundle_s_setBundleID(buf);
odisplay_doFullPacket(x, OSC_HEADER_SIZE, buf);
}
void *ocoll_new(t_symbol *msg, short argc, t_atom *argv){
t_ocoll *x;
if((x = (t_ocoll *)object_alloc(ocoll_class))){
x->outlet = outlet_new((t_object *)x, NULL);
x->buffer_len = 1024;
if(argc){
if(atom_gettype(argv) == A_LONG){
//x->buffer_len = atom_getlong(argv);
object_error((t_object *)x, "o.collect no longer takes an argument to specify its internal buffer size.");
object_error((t_object *)x, "The buffer will expand as necessary.");
}
}
x->buffer = (char *)osc_mem_alloc(x->buffer_len * sizeof(char));
memset(x->buffer, '\0', x->buffer_len);
x->buffer_pos = OSC_HEADER_SIZE;
osc_bundle_s_setBundleID(x->buffer);
critical_new(&(x->lock));
}
return(x);
}
void odisplay_output_bundle(t_odisplay *x)
{
// the use of critical sections is a little weird here, but correct.
critical_enter(x->lock);
if(x->bndl_s){
t_osc_bndl_s *b = x->bndl_s;
long len = osc_bundle_s_getLen(b);
char *ptr = osc_bundle_s_getPtr(b);
char buf[len];
memcpy(buf, ptr, len);
critical_exit(x->lock);
omax_util_outletOSC(x->outlet, len, buf);
OSC_MEM_INVALIDATE(buf);
return;
}
critical_exit(x->lock);
char buf[OSC_HEADER_SIZE];
memset(buf, '\0', OSC_HEADER_SIZE);
osc_bundle_s_setBundleID(buf);
omax_util_outletOSC(x->outlet, OSC_HEADER_SIZE, buf);
OSC_MEM_INVALIDATE(buf);
}
void omax_FullPacket(t_object *ob, long len, long ptr)
{
t_symbol *classname = object_classname(ob);
if(!classname){
// if we can't get our classname, there's no way we can match anything
return;
}
char buf[len];
sprintf(buf, "/%s", classname->s_name);
t_context c;
c.ob = ob;
c.classname = classname;
c.osc_classname = gensym(buf);
memset(buf, '\0', len);
c.buf = buf;
osc_bundle_s_setBundleID(buf);
c.bufpos = OSC_HEADER_SIZE;
c.should_output_state = 0;
t_osc_err e = osc_bundle_s_getMessagesWithCallback(len, (char *)ptr, omax_FullPacketCallback, (void *)(&c));
if(e){
object_error(ob, "%s (%d)", osc_error_string(e), e);
return;
}
if(c.bufpos > OSC_HEADER_SIZE){
void *cout = omax_object_getContinuationOutlet(ob);
if(cout){
t_atom out[2];
atom_setlong(out, c.bufpos);
atom_setlong(out + 1, (long)(c.buf));
outlet_anything(cout, gensym("FullPacket"), 2, out);
}
}
if(c.should_output_state > 0){
omax_outputState(ob);
}
}
void omax_schemaList(t_object *ob, t_symbol *msg, int argc, t_atom *argv)
{
t_symbol *classname = object_classname(ob);
if(!classname){
return;
}
t_hashtab *ht = omax_class_getHashtab(classname->s_name);
if(!ht){
return;
}
t_schemalist *sl = NULL;
hashtab_lookup(ht, gensym("cnmat_internal_osc_schema_list"), (t_object **)&sl);
if(!sl){
return;
}
int typetaglen = (sl->address_buf_pos + 2);
while(typetaglen % 4){
typetaglen++;
}
char *address = "/osc/schema/list";
int addresslen = 20;
char buf[sl->nbytes + OSC_HEADER_SIZE + 4 + typetaglen + addresslen];
// need to add space for timetag
memset(buf, '\0', sl->nbytes + OSC_HEADER_SIZE + 4 + typetaglen);
char *bufptr = buf + OSC_HEADER_SIZE;
*((uint32_t *)bufptr) = hton32(sl->nbytes + typetaglen + addresslen);
bufptr += 4;
strncpy(bufptr, address, 16);
bufptr += addresslen;
*bufptr = ',';
memset(bufptr + 1, 's', sl->address_buf_pos);
bufptr += typetaglen;
int i;
for(i = 0; i < sl->address_buf_pos; i++){
memcpy(bufptr, sl->addresses[i].buf, sl->addresses[i].bufpos);
bufptr += sl->addresses[i].bufpos;
}
osc_bundle_s_setBundleID(buf);
// put timestamp in place...
/*
long nkeys = 0;
t_symbol **keys = NULL;
hashtab_getkeys(ht, &nkeys, &keys);
int buflen = 128;
char *buf = sysmem_newptr(buflen);
memset(buf, '\0', buflen);
int bufpos = 0;
osc_bundle_setBundleID(buf);
bufpos += OSC_HEADER_SIZE;
int i;
for(i = 0; i < nkeys; i++){
if(osc_error_validateAddress(keys[i]->s_name)){
continue;
}
t_omax_method *m = NULL;
hashtab_lookup(ht, keys[i], (t_object **)(&m));
if(!m){
continue;
}
if(m->type == OMAX_PARAMETER){
t_object *attr = object_attr_get(ob, m->sym);
long argc = 0;
t_atom *argv = NULL;
//m->m.m_fun(ob, attr, &argc, &argv);
char getter[128];
sprintf(getter, "get%s", m->sym->s_name);
long get;
method f = object_attr_method(ob, gensym(getter), (void **)(&attr), &get);
if(f){
f(ob, attr, &argc, &argv);
if(argv){
char address[128];
sprintf(address, "/parameter/%s", m->sym->s_name);
int msglen = omax_util_get_bundle_size_for_atoms(gensym(address), argc, argv);
if(msglen + bufpos >= buflen){
buf = sysmem_resizeptr(buf, buflen + msglen);
if(!buf){
object_error(ob, "out of memory!");
return;
}
}
bufpos += omax_util_encode_atoms(buf + bufpos, gensym(address), argc, argv);
sysmem_freeptr(argv);
}
}
}else
{
int msglen = omax_util_get_bundle_size_for_atoms(keys[i], 0, NULL);
if(msglen + bufpos >= buflen){
buf = sysmem_resizeptr(buf, buflen + msglen);
if(!buf){
object_error(ob, "out of memory!");
return;
}
memset(buf + buflen, '\0', msglen);
buflen += msglen;
}
char methodname[128];
sprintf(methodname, "/method/%s", m->sym->s_name);
bufpos += omax_util_encode_atoms(buf + bufpos, gensym(methodname), 0, NULL);
}
}
*/
void *infoout = omax_object_getInfoOutlet(ob);
if(infoout){
t_atom out[2];
atom_setlong(out, bufptr - buf);
atom_setlong(out + 1, (long)buf);
outlet_anything(infoout, gensym("FullPacket"), 2, out);
}
}
