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); } }