// ***************************************************************************** std::vector<lo_message> ConstraintsNode::getState () const { // inherit state from base class std::vector<lo_message> ret = GroupNode::getState(); lo_message msg; osg::Vec3 v; msg = lo_message_new(); lo_message_add(msg, "ss", "setTarget", this->getTarget()); ret.push_back(msg); msg = lo_message_new(); lo_message_add(msg, "si", "setConstraintMode", this->getConstraintMode()); ret.push_back(msg); msg = lo_message_new(); v = getCubeSize(); lo_message_add(msg, "sfff", "setCubeSize", v.x(), v.y(), v.z()); ret.push_back(msg); msg = lo_message_new(); v = getCubeOffset(); lo_message_add(msg, "sfff", "setCubeOffset", v.x(), v.y(), v.z()); ret.push_back(msg); return ret; }
void nfosc_stop() { int i; if (!running) return; running = false; if( main_thread ) pthread_detach(main_thread); main_thread = NULL; lo_bundle osc_bundle = lo_bundle_new(LO_TT_IMMEDIATE); for (i=0;i<buffer_size;i++) { lo_message del_message = lo_message_new(); lo_message_add_int32(del_message, tag_buffer[i].device_id); lo_message_add_int32(del_message, tag_buffer[i].symbol_id); lo_message_add_int32(del_message, tag_buffer[i].type_id); lo_message_add_string(del_message, tag_buffer[i].uid_str); lo_bundle_add_message(osc_bundle, "/nfosc/del", del_message); if (verbose) printf("del %d %d %d %s\n",tag_buffer[i].session_id,tag_buffer[i].symbol_id,tag_buffer[i].type_id,tag_buffer[i].uid_str); } lo_timetag frame_time; lo_timetag_now (&frame_time); for (int dev=0;dev<no_devices;dev++) { if (pnd[dev]==NULL) continue; lo_message frm_message = lo_message_new(); lo_message_add_int32(frm_message, -1); lo_message_add_timetag(frm_message, frame_time); lo_message_add_int32(frm_message, 0); // sensor dim if (device_count>1) sprintf(source_string, "NFOSC:%d",dev); lo_message_add_string(frm_message, source_string); // source name lo_bundle_add_message(osc_bundle, "/tuio2/frm", frm_message); lo_message sid_message = lo_message_new(); lo_bundle_add_message(osc_bundle, "/tuio2/alv", sid_message); } int ret = lo_send_bundle(target, osc_bundle); if(ret == -1) { fprintf(stderr, "an OSC error occured: %s\n", lo_address_errstr(target)); exit(1); } for (int dev=0;dev<no_devices;dev++) { if (pnd[dev]!=NULL) { printf("closing NFC reader #%d: %s\n",dev,nfc_device_get_name(pnd[dev])); nfc_close(pnd[dev]); } } nfc_exit(context); write_database(); }
std::vector<lo_message> GeometryNode::getState () const { // inherit state from base class std::vector<lo_message> ret = GroupNode::getState(); lo_message msg; osg::Vec3 v3; osg::Vec4 v4; // put this one last: /* msg = lo_message_new(); lo_message_add(msg, "sfffffffffff", "setVertices", getVertices()); ret.push_back(msg); */ osg::Vec3Array *vArray = dynamic_cast<osg::Vec3Array*>(geometry_->getVertexArray()); for (unsigned int i=0; i<vArray->getNumElements(); i++) { //v3 = (*vArray)[i]; msg = lo_message_new(); lo_message_add(msg, "sifff", "setVertex", i, (*vArray)[i].x(), (*vArray)[i].y(), (*vArray)[i].z()); ret.push_back(msg); } osg::Vec4Array *cArray = dynamic_cast<osg::Vec4Array*>(geometry_->getColorArray()); for (unsigned int i=0; i<cArray->getNumElements(); i++) { msg = lo_message_new(); lo_message_add(msg, "siffff", "setColor", i, (*cArray)[i].x(), (*cArray)[i].y(), (*cArray)[i].z(), (*cArray)[i].w()); ret.push_back(msg); } osg::Vec2Array *tArray = dynamic_cast<osg::Vec2Array*>(geometry_->getTexCoordArray(0)); for (unsigned int i=0; i<tArray->getNumElements(); i++) { msg = lo_message_new(); lo_message_add(msg, "siff", "setTexCoord", i, (*tArray)[i].x(), (*tArray)[i].y()); ret.push_back(msg); } msg = lo_message_new(); lo_message_add(msg, "si", "setSingleSided", getSingleSided()); ret.push_back(msg); return ret; }
//================================================================ void osc_error_handler(int num, const char *msg, const char *path) { if(close_on_incomp==1 && shutdown_in_progress==0) { fprintf(stderr,"/!\\ liblo server error %d: %s %s\n", num, path, msg); fprintf(stderr,"telling sender to pause.\n"); //lo_address loa=lo_address_new(sender_host,sender_port); lo_address loa=lo_address_new_with_proto(lo_proto, sender_host,sender_port); lo_message msg=lo_message_new(); lo_send_message(loa, "/pause", msg); lo_message_free(msg); io_quit("incompatible_jack_settings"); fprintf(stderr,"cleaning up..."); jack_client_close(client); //lo_server_thread_free(lo_st); jack_ringbuffer_free(rb); jack_ringbuffer_free(rb_helper); fprintf(stderr," done.\n"); exit(1); } else if(shutdown_in_progress==0) { fprintf(stderr,"\r/!\\ liblo server error %d: %s %s\n", num, path, msg); //should be a param } }//end osc_error_handler
int osc_send( const char *port, const char *msg, const char *format, ...) { lo_address t = lo_address_new(NULL, port); lo_message message = lo_message_new(); va_list args; va_start( args, format); while( *format != '\0') { switch( *format) { case 's': lo_message_add_string( message, va_arg( args, const char *)); break; case 'i': lo_message_add_int32( message, va_arg( args, int)); break; case 'f': lo_message_add_float( message, va_arg( args, double)); break; } ++format; } va_end( args); if( !lo_send_message( t, msg, message)) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } if( osc_log) osc_log_print( msg, message); lo_message_free( message); lo_address_free( t); return 0; }
int osc_controller::_deactivate_cb(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg) { if (!m_restricted || is_target (lo_message_get_source(msg))) { pair<int,int> net_id(argv[0]->i, argv[1]->i); map<pair<int,int>, int>::iterator it = m_local_id.find(net_id); world_node obj; if (it != m_local_id.end() && !(obj = m_world->find_node(it->second)).is_null()) { m_skip++; m_world->deactivate_node(obj); m_skip--; if (m_broadcast) { lo_message newmsg = lo_message_new(); lo_message_add_int32(newmsg, argv[0]->i); lo_message_add_int32(newmsg, argv[1]->i); broadcast_message_from(PSYNTH_OSC_MSG_DEACTIVATE, newmsg, lo_message_get_source(msg)); lo_message_free(newmsg); } } } return 0; }
int osc_controller::_add_cb(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg) { if (!m_restricted || is_target(lo_message_get_source(msg))) { pair<int,int> net_id(argv[0]->i, argv[1]->i); m_skip++; world_node obj = m_world->add_node(std::string(&argv[2]->s)); m_skip--; if (!obj.is_null()) { int local_id = obj.get_id (); m_net_id[local_id] = net_id; m_local_id[net_id] = local_id; if (m_broadcast) { lo_message newmsg = lo_message_new(); lo_message_add_int32(newmsg, argv[0]->i); lo_message_add_int32(newmsg, argv[1]->i); lo_message_add_string(newmsg, &argv[2]->s); broadcast_message_from(PSYNTH_OSC_MSG_ADD, newmsg, lo_message_get_source(msg)); lo_message_free(newmsg); } } } return 0; }
bool OscController::sendMessage(const char *path, const char *types, ...) { if(path == NULL || types == NULL || transmitAddress_ == NULL) return false; va_list ap; bool ret = false; char *totalPath = (char *)malloc((strlen(path) + globalPrefix_.length())*sizeof(char)); strcpy(totalPath, globalPrefix_.c_str()); strcat(totalPath, path); lo_message msg = lo_message_new(); va_start(ap, types); ret = (lo_message_add_varargs(msg, types, ap) == 0); // Check for success (return of 0) if(!ret) cerr << "Error in OscController::sendMessage -- lo_message_add_varargs failed.\n"; else ret = (lo_send_message(transmitAddress_, totalPath, msg) == 0); va_end(ap); lo_message_free(msg); free(totalPath); return ret; }
lo_message make_message(int i, char *s) { lo_message msg = lo_message_new(); lo_message_add_int32(msg, i); lo_message_add_string(msg, s); return msg; }
static int lo_send_varargs_internal(lo_address t, const char *file, const int line, const char *path, const char *types, va_list ap) { int ret; lo_message msg = lo_message_new(); t->errnum = 0; t->errstr = NULL; ret = lo_message_add_varargs_internal(msg, types, ap, file, line); if (ret) { lo_message_free(msg); t->errnum = ret; if (ret == -1) t->errstr = "unknown type"; else t->errstr = "bad format/args"; return ret; } ret = lo_send_message(t, path, msg); lo_message_free(msg); return ret; }
void mapper_monitor_link(mapper_monitor mon, const char* source_device, const char* dest_device, mapper_db_link_t *props, unsigned int props_flags) { if (props && (props_flags & LINK_NUM_SCOPES) && props->num_scopes && ((props_flags & LINK_SCOPE_NAMES) || (props_flags & LINK_SCOPE_HASHES))) { lo_message m = lo_message_new(); if (!m) return; lo_message_add_string(m, source_device); lo_message_add_string(m, dest_device); lo_message_add_string(m, "@scope"); int i; if (props_flags & LINK_SCOPE_NAMES) { for (i=0; i<props->num_scopes; i++) { lo_message_add_string(m, props->scope_names[i]); } } else if (props_flags & LINK_SCOPE_HASHES) { for (i=0; i<props->num_scopes; i++) { lo_message_add_int32(m, props->scope_hashes[i]); } } lo_send_message(mon->admin->admin_addr, "/link", m); free(m); } else mapper_admin_send_osc( mon->admin, 0, "/link", "ss", source_device, dest_device ); }
lo_message live_play_scene_message_t::createMessage() { // pic::logmsg() << "live_play_scene_message_t::createMessage() " << topic() <<"-" << scene_; lo_message m=lo_message_new(); lo_message_add(m,"i",scene_); return m; }
int lo_send(lo_address t, const char *path, const char *types, ...) #endif { va_list ap; int ret; #ifndef __GNUC__ const char *file = ""; int line = 0; #endif lo_message msg = lo_message_new(); t->errnum = 0; t->errstr = NULL; va_start(ap, types); ret = lo_message_add_varargs_internal(msg, types, ap, file, line); if (ret) { lo_message_free(msg); t->errnum = ret; if (ret == -1) t->errstr = "unknown type"; else t->errstr = "bad format/args"; return ret; } ret = lo_send_message(t, path, msg); lo_message_free(msg); return ret; }
//ctrl+c etc static void signal_handler(int sig) { shutdown_in_progress=1; process_enabled=0; fprintf(stderr,"\nterminate signal %d received.\n",sig); if(close_on_incomp==0) { fprintf(stderr,"telling sender to pause.\n"); //lo_address loa = lo_address_new(sender_host,sender_port); lo_address loa = lo_address_new_with_proto(lo_proto, sender_host,sender_port); lo_message msg=lo_message_new(); lo_send_message (loa, "/pause", msg); lo_message_free(msg); } usleep(1000); fprintf(stderr,"cleaning up..."); lo_server_thread_free(lo_st); rb_free(rb); rb_free(rb_helper); fprintf(stderr,"done.\n"); fflush(stderr); exit(0); }
static void sendOsc(const char *s, float *f,int n){ lo_message msg = lo_message_new(); for(int i=0;i<n;i++) lo_message_add_float(msg,f[i]); int ret = lo_send_message(lo,s,msg); lo_message_free(msg); }
std::vector<lo_message> PointerNode::getState () const { // inherit state from base class std::vector<lo_message> ret = RayNode::getState(); lo_message msg; msg = lo_message_new(); lo_message_add(msg, "si", "setGrabMode", getGrabMode()); ret.push_back(msg); /* msg = lo_message_new(); lo_message_add(msg, "ss", "setType", this->getType()); ret.push_back(msg); msg = lo_message_new(); lo_message_add(msg, "si", "highlight", this->getHighlight()); ret.push_back(msg); msg = lo_message_new(); lo_message_add(msg, "si", "manipulate", this->getManipulate()); ret.push_back(msg); */ return ret; }
int lo_send_timestamped(lo_address t, lo_timetag ts, const char *path, const char *types, ...) #endif { va_list ap; int ret; lo_message msg = lo_message_new(); lo_bundle b = lo_bundle_new(ts); #ifndef __GNUC__ const char *file = ""; int line = 0; #endif t->errnum = 0; t->errstr = NULL; va_start(ap, types); ret = lo_message_add_varargs_internal(msg, types, ap, file, line); if (t->errnum) { lo_message_free(msg); return t->errnum; } lo_bundle_add_message(b, path, msg); ret = lo_send_bundle(t, b); lo_message_free(msg); lo_bundle_free(b); return ret; }
void veejay_bundle_sample_add( void *osc, int id, const char *word, const char *format, ... ) { char osc_path[256]; oscclient_t *c = (oscclient_t*) osc; if(!c->bundle) { c->bundle = lo_bundle_new( LO_TT_IMMEDIATE ); } sprintf(osc_path, "/sample_%d/%s", id, word ); lo_message lmsg = lo_message_new(); lo_message_add_string(lmsg, c->window ); lo_message_add_string(lmsg, osc_path ); va_list ap; if( format ) { va_start( ap, format ); veejay_add_arguments_( lmsg, format, ap ); va_end(ap); } lo_bundle_add_message( c->bundle, "/update/widget", lmsg ); }
static int lo_send_timestamped_varargs_internal(lo_address t, const char *file, const int line, lo_timetag ts, const char *path, const char *types, va_list ap) { int ret; lo_message msg = lo_message_new(); lo_bundle b = lo_bundle_new(ts); t->errnum = 0; t->errstr = NULL; ret = lo_message_add_varargs_internal(msg, types, ap, file, line); if (ret == 0) { lo_bundle_add_message(b, path, msg); ret = lo_send_bundle(t, b); } lo_message_free(msg); lo_bundle_free(b); return ret; }
static int lo_send_from_varargs_internal(lo_address to, lo_server from, const char *file, const int line, lo_timetag ts, const char *path, const char *types, va_list ap) { lo_bundle b = NULL; int ret; lo_message msg = lo_message_new(); if (ts.sec != LO_TT_IMMEDIATE.sec || ts.frac != LO_TT_IMMEDIATE.frac) b = lo_bundle_new(ts); // Clear any previous errors to->errnum = 0; to->errstr = NULL; ret = lo_message_add_varargs_internal(msg, types, ap, file, line); if (ret == 0) { if (b) { lo_bundle_add_message(b, path, msg); ret = lo_send_bundle_from(to, from, b); } else { ret = lo_send_message_from(to, from, path, msg); } } // Free-up memory lo_message_free(msg); if (b) lo_bundle_free(b); return ret; }
void Client::send( const osc::Message &message ) { lo_message msg = lo_message_new(); for ( size_t i = 0; i < message.getNumArgs(); i++ ) { switch ( message.getArgType( i ) ) { case 'i': lo_message_add_int32( msg, message.getArg< int32_t >( i ) ); break; case 'f': lo_message_add_float( msg, message.getArg< float >( i ) ); break; case 's': lo_message_add_string( msg, message.getArg< std::string >( i ).c_str() ); break; default: break; } } lo_send_message( mAddress, message.getAddressPattern().c_str(), msg ); lo_message_free( msg ); }
void OscTransmitter::sendMessage(const char * path, const char * type, ...) { va_list v; va_start(v, type); lo_message msg = lo_message_new(); lo_message_add_varargs(msg, type, v); /*if(debugMessages_) { cout << path << " " << type << ": "; lo_arg **args = lo_message_get_argv(msg); for(int i = 0; i < lo_message_get_argc(msg); i++) { switch(type[i]) { case 'i': cout << args[i]->i << " "; break; case 'f': cout << args[i]->f << " "; break; default: cout << "? "; } } cout << endl; //lo_message_pp(msg); }*/ sendMessage(path, type, msg); lo_message_free(msg); va_end(v); }
lo_message live_arm_message_t::createMessage() { //pic::logmsg() << "live_arm_message_t::createMessage() " << topic() << " - " << track_; lo_message m=lo_message_new(); lo_message_add(m,"i",track_); lo_message_add(m,"i",(int) armed_); // enable/arm track return m; }
lo_message live_clip_info_message_t::createMessage() { // pic::logmsg() << "live_clip_info_message_t::createMessage() " << topic() << " - " << track_ << "," << clip_; lo_message m=lo_message_new(); lo_message_add(m,"i",track_); lo_message_add(m,"i",clip_); return m; }
std::vector<lo_message> GridNode::getState () const { // inherit state from base class std::vector<lo_message> ret = ReferencedNode::getState(); lo_message msg; msg = lo_message_new(); lo_message_add(msg, "si", "setSize", getSize()); ret.push_back(msg); msg = lo_message_new(); osg::Vec4 v = this->getColor(); lo_message_add(msg, "sffff", "setColor", v.x(), v.y(), v.z(), v.w()); ret.push_back(msg); return ret; }
//========================================================= void io_simple(char *path) { if(io_()) { lo_message msgio=lo_message_new(); lo_send_message(loio, path, msgio); lo_message_free(msgio); } }
// Generate OSC message with default format void genOscMsg(lo_bundle *bundle, char *name, int buffIndex) { if (handMode || posConfidence >= 0.5f) { lo_message msg = lo_message_new(); lo_message_add_string(msg, name); if (!kitchenMode) lo_message_add_int32(msg, userID); for (int i = 0; i < nDimensions; i++) lo_message_add_float(msg, jointCoords[i]); lo_bundle_add_message(*bundle, "/joint", msg); } if (!kitchenMode && sendOrient && orientConfidence >= 0.5f) { lo_message msg = lo_message_new(); lo_message_add_string(msg, name); if (!kitchenMode) lo_message_add_int32(msg, userID); // x data is in first column lo_message_add_float(msg, jointOrients[0]); lo_message_add_float(msg, jointOrients[0+3]); lo_message_add_float(msg, jointOrients[0+6]); // y data is in 2nd column lo_message_add_float(msg, jointOrients[1]); lo_message_add_float(msg, jointOrients[1+3]); lo_message_add_float(msg, jointOrients[1+6]); // z data is in 3rd column lo_message_add_float(msg, jointOrients[2]); lo_message_add_float(msg, jointOrients[2+3]); lo_message_add_float(msg, jointOrients[2+6]); lo_bundle_add_message(*bundle, "/orient", msg); } }
//========================================================= void io_quit(char *token) { if(io_()) { lo_message msgio=lo_message_new(); lo_message_add_string(msgio,token); lo_send_message(loio, "/quit", msgio); lo_message_free(msgio); } }
lo_message live_selection_message_t::createMessage() { // pic::logmsg() << "live_selection_message_t::createMessage() " << topic() << " - " << track_ << "," << clip_ << "," << width_ << "," << height_; lo_message m=lo_message_new(); lo_message_add(m,"i",(int) track_); lo_message_add(m,"i",(int) clip_); lo_message_add(m,"i",(int) width_); lo_message_add(m,"i",(int) height_); return m; }
void OscSender::sendMessage(const std::string &OSCpath, const char *types, va_list ap) const { lo_message msg = lo_message_new(); int err = lo_message_add_varargs(msg, types, ap); if (!err) sendMessage(OSCpath, msg); else std::cout << "ERROR (OscSender::sendMessage): " << err << std::endl; }