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