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; }
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; }
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; }
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 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; }
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); }
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; }
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 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; }
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; }
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; }
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; }
static int dispatch_queued(lo_server s) { queued_msg_list *head = s->queued; queued_msg_list *tailhead; lo_timetag disp_time; if (!head) { lo_throw(s, LO_INT_ERR, "attempted to dispatch with empty queue", "timeout"); return 1; } disp_time = head->ts; do { char *path; lo_message msg; tailhead = head->next; path = ((queued_msg_list *)s->queued)->path; msg = ((queued_msg_list *)s->queued)->msg; dispatch_method(s, path, msg); free(path); lo_message_free(msg); free((queued_msg_list *)s->queued); s->queued = tailhead; head = tailhead; } while (head && lo_timetag_diff(head->ts, disp_time) < FLT_EPSILON); return 0; }
//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 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 io_simple(char *path) { if(io_()) { lo_message msgio=lo_message_new(); 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 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_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_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); } }
int lo_send_from(lo_address to, lo_server from, lo_timetag ts, const char *path, const char *types, ...) #endif { lo_bundle b = NULL; va_list ap; int ret; #ifndef __GNUC__ const char *file = ""; int line = 0; #endif 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; va_start(ap, types); ret = lo_message_add_varargs_internal(msg, types, ap, file, line); if (to->errnum) { if (b) lo_bundle_free(b); lo_message_free(msg); return to->errnum; } 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 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_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
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; }
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; }
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; }
void Mixer::discover_peers ( void ) { if ( nsm->is_active() ) { lo_message m = lo_message_new(); lo_message_add_string( m, "/non/finger" ); lo_message_add_string( m, osc_endpoint->url() ); nsm->broadcast( m ); lo_message_free( m ); } }
void veejay_bundle_sample_add_fx_atom( void *osc, int id,int entry, const char *word, const char *format, int type, void *value ) { 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/fx_%d/%s", id, entry,word ); lo_message lmsg = lo_message_new(); char realwin[128]; sprintf(realwin, "%sFX%d", c->window, entry ); lo_message_add_string(lmsg, realwin ); lo_message_add_string(lmsg, osc_path ); int ival; char *str; double gval; uint64_t val; switch(type) { case VEVO_ATOM_TYPE_STRING: str = (char*) *( (char*) value); lo_message_add_string( lmsg, str ); break; case VEVO_ATOM_TYPE_BOOL: case VEVO_ATOM_TYPE_INT: ival = (int) *( (int*) value ); lo_message_add_int32( lmsg, ival ); break; case VEVO_ATOM_TYPE_DOUBLE: gval = (double) *( (double*) value ); lo_message_add_double( lmsg, gval ); break; case VEVO_ATOM_TYPE_UINT64: val = (uint64_t) *( (uint64_t*) value ); lo_message_add_int64( lmsg, (int64_t) val ); break; default: lo_message_free( lmsg ); return; break; } lo_bundle_add_message( c->bundle,"/update/widget", lmsg ); }