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