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; }
int OscReceiver::handler(const char *path, const char *types, lo_arg **argv, int argc, lo_message msg, void *data) { bool matched = false; string pathString(path); if(useThru_) { // Rebroadcast any matching messages if(!pathString.compare(0, thruPrefix_.length(), thruPrefix_)) lo_send_message(thruAddress_, path, msg); } // Check if the incoming message matches the global prefix for this program. If not, discard it. if(pathString.compare(0, globalPrefix_.length(), globalPrefix_)) { cout << "OSC message '" << path << "' received\n"; return 1; } // Lock the mutex so the list of listeners doesn't change midway through pthread_mutex_lock(&oscListenerMutex_); // Now remove the global prefix and compare the rest of the message to the registered handlers. multimap<string, OscHandler*>::iterator it; pair<multimap<string, OscHandler*>::iterator,multimap<string, OscHandler*>::iterator> ret; string truncatedPath = pathString.substr(globalPrefix_.length(), pathString.length() - globalPrefix_.length()); ret = noteListeners_.equal_range(truncatedPath); it = ret.first; while(it != ret.second) { OscHandler *object = (*it++).second; #ifdef DEBUG_MESSAGES cout << "Matched OSC path '" << path << "' to handler " << object << endl; #endif object->oscHandlerMethod(truncatedPath.c_str(), types, argc, argv, data); matched = true; } pthread_mutex_unlock(&oscListenerMutex_); if(matched) // This message has been handled return 0; printf("Unhandled OSC path: <%s>\n", path); #ifdef DEBUG_MESSAGES for (int i=0; i<argc; i++) { printf("arg %d '%c' ", i, types[i]); lo_arg_pp((lo_type)types[i], argv[i]); printf("\n"); } #endif return 1; }
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; }
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 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); }
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 ); }
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 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
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); }
void OscSender::sendMessage(const std::string &OSCpath, lo_message msg) const { lo_send_message(address_, OSCpath.c_str(), msg); // Let's free the message after (not sure if this is necessary): lo_message_free(msg); }
static void client_callback (const char* client, int yn, void* arg) { lo_message reply=lo_message_new(); lo_message_add_string(reply,client); if(yn) { lo_send_message (loa, "/oscev/client/registered", reply); } else { lo_send_message (loa, "/oscev/client/unregistered", reply); } lo_message_free (reply); printf ("Client %s %s\n", client, (yn ? "registered" : "unregistered")); }
//========================================================= void io_simple(char *path) { if(io_()) { lo_message msgio=lo_message_new(); lo_send_message(loio, path, msgio); lo_message_free(msgio); } }
static void port_callback (jack_port_id_t port, int yn, void* arg) { lo_message reply=lo_message_new(); lo_message_add_int32(reply,port); if(yn) { lo_send_message (loa, "/oscev/port/registered", reply); } else { lo_send_message (loa, "/oscev/port/unregistered", reply); } lo_message_free (reply); printf ("Port %d %s\n", port, (yn ? "registered" : "unregistered")); }
//========================================================= void io_simple_float(char *path, float f) { if(io_()) { lo_message msgio=lo_message_new(); lo_message_add_float(msgio, f); lo_send_message(loio, path, msgio); lo_message_free(msgio); } }
//========================================================= void io_simple_long(char *path, uint64_t l) { if(io_()) { lo_message msgio=lo_message_new(); lo_message_add_int64(msgio, l); lo_send_message(loio, path, msgio); lo_message_free(msgio); } }
//========================================================= void io_simple_string(char *path, const char *string) { if(io_()) { lo_message msgio=lo_message_new(); lo_message_add_string(msgio, string); lo_send_message(loio, path, msgio); lo_message_free(msgio); } }
static void connect_callback (jack_port_id_t a, jack_port_id_t b, int yn, void* arg) { lo_message reply=lo_message_new(); lo_message_add_int32(reply,a); lo_message_add_int32(reply,b); if(yn) { lo_send_message (loa, "/oscev/port/connected", reply); } else { lo_send_message (loa, "/oscev/port/disconnected", reply); } lo_message_free (reply); printf ("Ports %d and %d %s\n", a, b, (yn ? "connected" : "disconnected")); }
//========================================================= void io_simple_int(char *path, int i) { if(io_()) { lo_message msgio=lo_message_new(); lo_message_add_int32(msgio, i); lo_send_message(loio, path, msgio); lo_message_free(msgio); } }
//========================================================= 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); } }
void OscController::send(OscHostRef hostRef, const osc::OutboundPacketStream &stream) { if (hostRef == 0) return; OscHostAddress *hostAddress; hostAddress = static_cast<OscHostAddress*>(hostRef); lo_send_message(hostAddress->getHostAddress(), stream.Data(), stream.Size()); }
static int graph_callback (void* arg) { lo_message reply=lo_message_new(); lo_send_message (loa, "/oscev/graph_reordered", reply); lo_message_free (reply); printf ("Graph reordered\n"); return 0; }
//================================================================ void io_dump_config() { if(io_()) { lo_message msgio=lo_message_new(); //common properties with jack_audio_send first lo_message_add_int32(msgio,atoi(localPort)); //0 //local jack info lo_message_add_string(msgio,client_name); //1 lo_message_add_string(msgio,server_name); //2 lo_message_add_int32(msgio,sample_rate); //3 lo_message_add_int32(msgio,period_size); //4 lo_message_add_int32(msgio,output_port_count); //5 //this is not a property of local JACK lo_message_add_int32(msgio,bytes_per_sample); //6 lo_message_add_int32(msgio,test_mode); //7 lo_message_add_int32(msgio,receive_max); //8 //gap for future common props lo_message_add_int32(msgio,0); //9 lo_message_add_int32(msgio,0); //10 lo_message_add_int32(msgio,0); //11 lo_message_add_int32(msgio,0); //12 lo_message_add_int32(msgio,0); //13 lo_message_add_int32(msgio,0); //14 lo_message_add_int32(msgio,0); //15 lo_message_add_int32(msgio,0); //16 lo_message_add_int32(msgio,0); //17 lo_message_add_int32(msgio,0); //18 lo_message_add_int32(msgio,0); //19 //custom properties start here lo_message_add_int32(msgio,channel_offset); //20 //multi-channel period size // lo_message_add_float(msgio,output_port_count*period_size*bytes_per_sample); lo_message_add_int32(msgio,zero_on_underflow); //21 lo_message_add_int32(msgio,rebuffer_on_restart); //22 lo_message_add_int32(msgio,rebuffer_on_underflow); //23 lo_message_add_int32(msgio,allow_remote_buffer_control); //24 lo_message_add_int32(msgio,close_on_incomp); //25 // fprintf(stderr,"receiving on TCP port: %s\n",localPort); // fprintf(stderr,"receiving on UDP port: %s\n",localPort); // lo_message_add_int32(msgio,max_buffer_size); //should be global // lo_message_add_int32(msgio,rb_size); lo_send_message(loio, "/config_dump", msgio); lo_message_free(msgio); }//end if io_ }//end io_dump_config
int veejay_send_osc_strargs( void *osc, const char *msg, int n_str, char **strs ) { oscclient_t *c = (oscclient_t*) osc; lo_message lmsg = lo_message_new(); int i; for( i = 0; i < n_str; i ++ ) { lo_message_add_string( lmsg, strs[i] ); } int result = lo_send_message( c->addr, msg, lmsg ); lo_message_free( lmsg ); return result; }
int test_varargs(lo_address a, const char *path, const char *types, ...) { va_list ap; lo_message m = lo_message_new(); int error; va_start(ap, types); if ((error=lo_message_add_varargs(m, types, ap))==0) lo_send_message(a, path, m); else printf("lo_message_add_varargs returned %d\n", error); lo_message_free(m); return error<0; }
static int send_msg(lo_address a, char *path, term_t args) { lo_message msg=lo_message_new(); if (add_msg_args(msg,args)) { if (lo_send_message(a,path,msg)==-1) { lo_message_free(msg); return osc_error(lo_address_errno(a),lo_address_errstr(a),path); } else { lo_message_free(msg); return TRUE; } } else return FALSE; }
void SLClip::send2SL(const char* pathend, lo_message msg) { auto mainlog = spdlog::get( "main" ); mainlog->info( "SLClip::send2SL"); lo_message_pp( msg ); lo_address target = ((SLBus*)parent_)->getSLTarget(); mainlog->info( "* address : {}", target); std::string path = "/sl/" + std::to_string( sl_id_ ) + pathend; mainlog->info( "* path : {}", path); if ( lo_send_message( target, path.c_str(), msg ) == -1 ) { mainlog->error( "OSC error {}: {}", lo_address_errno(target), lo_address_errstr(target) ); } mainlog->info( "/SLClip::send2SL"); }
int veejay_vevo_send_osc( void *osc, const char *msg, void *vevo_port ) { char **keys = vevo_list_properties( vevo_port ); int i; lo_message lmsg = lo_message_new(); oscclient_t *c = (oscclient_t*) osc; for ( i = 0; keys[i] != NULL; i ++ ) { char *format = vevo_format_kind( vevo_port, keys[i] ); int n_elems = vevo_property_num_elements( vevo_port, keys[i] ); while( *format ) { switch(*format) { case 'd': _vevo_get_int( vevo_port, keys[i], n_elems, lmsg ); break; case 'g': _vevo_get_dbl( vevo_port, keys[i], n_elems, lmsg ); break; default: break; } *format++; } free(keys[i]); } free(keys); int result = lo_send_message( c->addr, msg, lmsg ); lo_message_free( lmsg ); if( result == -1) return VEVO_ERROR_HARDWARE; //@ long live bogus error codes return VEVO_NO_ERROR; }
void OscTransmitter::sendMessage(const char * path, const char * type, const lo_message& message) { if(debugMessages_) { cout << path << " " << type << " "; int argc = lo_message_get_argc(message); lo_arg **argv = lo_message_get_argv(message); for (int i=0; i<argc; i++) { lo_arg_pp((lo_type)type[i], argv[i]); cout << " "; } cout << endl; } // Send message to everyone who's currently listening for(vector<lo_address>::iterator it = addresses_.begin(); it != addresses_.end(); it++) { lo_send_message(*it, path, message); } }
int veejay_send_osc( void *osc ,const char *msg, const char *format, ... ) { oscclient_t *c = (oscclient_t*) osc; lo_message lmsg = lo_message_new(); va_list ap; if( format ) { va_start( ap, format ); veejay_add_arguments_( lmsg, format, ap ); va_end(ap); } int result = lo_send_message( c->addr, msg, lmsg ); lo_message_free( lmsg ); return result; }