int osc_start(struct deck *deck, struct library *library)
{
osc_deck = deck;
osc_library = library;
address[0] = lo_address_new_from_url("osc.udp://0.0.0.0:7771/");
address[1] = lo_address_new_from_url("osc.udp://0.0.0.0:7771/");
/* start a new server on port 7770 */
st = lo_server_thread_new("7770", error);
lo_server_thread_add_method(st, "/xwax/load_track", "isss", load_track_handler, NULL);
lo_server_thread_add_method(st, "/xwax/set_cue", "iif", set_cue_handler, NULL);
lo_server_thread_add_method(st, "/xwax/punch_cue", "ii", punch_cue_handler, NULL);
lo_server_thread_add_method(st, "/xwax/get_status", "i", get_status_handler, NULL);
lo_server_thread_add_method(st, "/xwax/recue", "i", recue_handler, NULL);
lo_server_thread_add_method(st, "/xwax/disconnect", "i", disconnect_handler, NULL);
lo_server_thread_add_method(st, "/xwax/reconnect", "i", reconnect_handler, NULL);
lo_server_thread_add_method(st, "/xwax/connect", "", connect_handler, NULL);
lo_server_thread_add_method(st, "/xwax/pitch", "if", pitch_handler, NULL);
lo_server_thread_add_method(st, "/xwax/position", "if", position_handler, NULL);
/* add method that will match the path /quit with no args */
lo_server_thread_add_method(st, "/quit", "", quit_handler, NULL);
lo_server_thread_start(st);
///* Start a TCP server used for receiving PPM packets */
//st_tcp = lo_server_thread_new_with_proto("7771", LO_TCP, error);
//if (!st_tcp) {
//printf("Could not create tcp server thread.\n");
//exit(1);
//}
//lo_server s = lo_server_thread_get_server(st);
///* add method that will match the path /foo/bar, with two numbers, coerced
//* to float and int */
//lo_server_thread_start(st_tcp);
//printf("Listening on TCP port %s\n", "7771");
return 0;
}
explicit OSCClientSender(const Raul::URI& url,
size_t max_packet_size)
: Shared::OSCSender(max_packet_size)
, _url(url)
{
_address = lo_address_new_from_url(url.c_str());
}
bool SpinEditorApp::OnCmdLineParsed(wxCmdLineParser& parser)
{
spin::spinApp &spin = spin::spinApp::Instance();
if (parser.Found(wxT("v")))
{
std::cout << "SPIN Framework: version " << VERSION << std::endl;
return false;
}
wxString sceneID;
if (parser.Found(wxT("s"), &sceneID))
spin.setSceneID(sceneID.ToStdString());
wxString userID;
if (parser.Found(wxT("u"), &userID))
spin.setUserID(userID.ToStdString());
wxString serverAddr;
if (parser.Found(wxT("r"), &serverAddr))
{
spinListener.lo_txAddrs_.clear();
spinListener.lo_txAddrs_.push_back(lo_address_new_from_url(serverAddr.c_str()));
}
return true;
}
void loop()
{
printf("-------------------- GO ! --------------------\n");
int i = 0;
if (automate) {
char source_name[1024], destination_name[1024];
printf("%s\n", mdev_name(source));
printf("%s\n", mdev_name(destination));
lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570");
lo_address_set_ttl(a, 1);
lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination));
msig_full_name(sendsig, source_name, 1024);
msig_full_name(recvsig, destination_name, 1024);
lo_send(a, "/connect", "ssss", source_name, destination_name,
"@mode", "reverse");
lo_address_free(a);
}
while (i >= 0 && !done) {
msig_update_float(recvsig, ((i % 10) * 1.0f));
printf("\ndestination value updated to %f -->\n", (i % 10) * 1.0f);
mdev_poll(destination, 1);
mdev_poll(source, 100);
i++;
}
}
void
Client::announce(const char *application_name,
const char *capabilities,
const char *process_name)
{
// MESSAGE( "Announcing to NSM" );
lo_address to = lo_address_new_from_url(nsm_url);
if(!to)
// MESSAGE( "Bad address" );
return;
int pid = (int)getpid();
lo_send_from(to,
_server,
LO_TT_IMMEDIATE,
"/nsm/server/announce",
"sssiii",
application_name,
capabilities,
process_name,
1,
/* api_major_version */
0,
/* api_minor_version */
pid);
lo_address_free(to);
}
// Constructor.
qtractorNsmClient::qtractorNsmClient (
const QString& nsm_url, QObject *pParent )
: QObject(pParent),
#ifdef CONFIG_LIBLO
m_address(NULL),
m_thread(NULL),
m_server(NULL),
#endif
m_active(false)
{
#ifdef CONFIG_LIBLO
m_address = lo_address_new_from_url(nsm_url.toUtf8().constData());
const int proto = lo_address_get_protocol(m_address);
m_thread = lo_server_thread_new_with_proto(NULL, proto, NULL);
if (m_thread) {
m_server = lo_server_thread_get_server(m_thread);
lo_server_thread_add_method(m_thread,
"/error", "sis", osc_nsm_error, this);
lo_server_thread_add_method(m_thread,
"/reply", "ssss", osc_nsm_reply, this);
lo_server_thread_add_method(m_thread,
"/nsm/client/open", "sss", osc_nsm_open, this);
lo_server_thread_add_method(m_thread,
"/nsm/client/save", "", osc_nsm_save, this);
lo_server_thread_add_method(m_thread,
"/nsm/client/session_is_loaded", "", osc_nsm_loaded, this);
lo_server_thread_add_method(m_thread,
"/nsm/client/show_optional_gui", "", osc_nsm_show, this);
lo_server_thread_add_method(m_thread,
"/nsm/client/hide_optional_gui", "", osc_nsm_hide, this);
lo_server_thread_start(m_thread);
}
#endif
}
void connect_signals()
{
char source_name[1024], destination_name[1024];
printf("%s\n", mdev_name(source));
printf("%s\n", mdev_name(destination));
lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570");
lo_address_set_ttl(a, 1);
lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination));
int j = 50;
while (j >= 0) {
mdev_poll(source, 10);
mdev_poll(destination, 10);
j--;
}
msig_full_name(sendsig, source_name, 1024);
msig_full_name(recvsig, destination_name, 1024);
lo_send(a, "/connect", "ss", source_name, destination_name);
lo_address_free(a);
}
int main(int argc, char *argv[])
{
lo_server st = lo_server_thread_new(NULL, NULL);
lo_address t;
if (argc != 2) {
fprintf(stderr, "Usage: subtest <uri>\n");
return 1;
}
lo_server_thread_add_method(st, NULL, "i", subtest_handler, NULL);
lo_server_thread_start(st);
t = lo_address_new_from_url(argv[1]);
lo_send(t, "/subtest", "i", 0xf00);
#ifdef WIN32
Sleep(4000);
#else
sleep(4);
#endif
return 0;
}
void
Mixer::reply_to_finger ( lo_message msg )
{
int argc = lo_message_get_argc( msg );
lo_arg **argv = lo_message_get_argv( msg );
if ( argc >= 4 )
{
const char *url = &argv[0]->s;
const char *name = &argv[1]->s;
const char *version = &argv[2]->s;
const char *id = &argv[3]->s;
MESSAGE( "Discovered NON peer %s (%s) @ %s with ID \"%s\"", name, version, url, id );
MESSAGE( "Registering Signals" );
lo_address to = lo_address_new_from_url( &argv[0]->s );
osc_endpoint->send( to,
"/non/hello",
osc_endpoint->url(),
APP_NAME,
VERSION,
instance_name );
mixer->osc_endpoint->hello( url );
lo_address_free( to );
}
}
void connect_signals()
{
char source_name[1024], destination_name[1024];
printf("%s\n", mdev_name(source));
printf("%s\n", mdev_name(destination));
lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570");
lo_address_set_ttl(a, 1);
lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination));
// wait for link to be processed
int j = 50;
while (j >= 0) {
mdev_poll(source, 10);
mdev_poll(destination, 10);
j--;
}
msig_full_name(sendsig, source_name, 1024);
msig_full_name(recvsig, destination_name, 1024);
lo_send(a, "/connect", "ssssss", source_name, destination_name, "@mode", "expression", "@expression", "y=y{-1}+1");
lo_address_free(a);
// wait for connection to be processed
j = 50;
while (j >= 0) {
mdev_poll(source, 10);
mdev_poll(destination, 10);
j--;
}
}
int
osc_update ( const char *path, const char *types, lo_arg **argv, int argc, lo_message msg, void *user_data )
{
lo_address to = lo_address_new_from_url( lo_address_get_url( lo_message_get_source( msg ) ));
nsm_proxy->update( to );
gui_addr = to;
return 0;
}
void *veejay_new_osc_sender_uri( const char *uri )
{
oscclient_t *osc = (oscclient_t*) vj_malloc(sizeof(oscclient_t));
memset(osc,0,sizeof(oscclient_t));
osc->addr = lo_address_new_from_url( uri );
osc->addr_str = strdup(lo_address_get_hostname( osc->addr ));
osc->port_str = strdup(lo_address_get_port ( osc->addr ));
veejay_msg(0,"New OSC sender from uri '%s', Host %s, Port %s",
uri, osc->addr_str, osc->port_str );
return (void*) osc;
}
int main(int argc, char *argv[])
{
lo_address ad;
if (argc > 1) {
printf("Connecting to %s\n", argv[1]);
ad = lo_address_new_from_url(argv[1]);
} else {
printf("Connecting to %s\n", MONOHORN_URL);
ad = lo_address_new_from_url(MONOHORN_URL);
}
if (lo_address_errno(ad) < 0) {
fprintf(stderr, "LO Error: %s\n", lo_address_errstr(ad));
return 1;
}
int ret = 0;
while (1)
{
rb_raise();
rb_bottom();
rb_render(ad);
if (lo_send(ad, "/render", NULL) < 0)
{
fprintf(stderr, "LO Error: %s\n", lo_address_errstr(ad));
ret = 1;
break;
}
// 15 frames /sec
usleep(1000000 / 15);
}
lo_send(ad, "/clear", NULL);
return ret;
}
int
osc_announce_reply ( const char *path, const char *types, lo_arg **argv, int argc, lo_message msg, void *user_data )
{
if ( strcmp( "/nsm/server/announce", &argv[0]->s ) )
return -1;
printf( "Successfully registered. NSM says: %s", &argv[1]->s );
nsm_is_active = 1;
nsm_addr = lo_address_new_from_url( lo_address_get_url( lo_message_get_source( msg ) ) );
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 5) {
g_critical("not enough arguments supplied");
return 1;
}
gtk_init(&argc, &argv);
//char *exe_path = argv[0];
char *host_url = argv[1];
//char *lib_name = argv[2];
char *plug_name = argv[3];
char *identifier = argv[4];
_osc_path = lo_url_get_path(host_url);
_osc_host_addr = lo_address_new_from_url(host_url);
_osc_server = lo_server_new(NULL, osc_error);
lo_server_add_method(_osc_server, tmpstr("/%s/control", _osc_path), "if", osc_control_handler, NULL);
lo_server_add_method(_osc_server, tmpstr("/%s/sample-rate", _osc_path), "i", osc_samplerate_handler, NULL);
lo_server_add_method(_osc_server, tmpstr("/%s/program", _osc_path), "ii", osc_program_handler, NULL);
lo_server_add_method(_osc_server, tmpstr("/%s/show", _osc_path), NULL, osc_show_handler, NULL);
lo_server_add_method(_osc_server, tmpstr("/%s/hide", _osc_path), NULL, osc_hide_handler, NULL);
lo_server_add_method(_osc_server, tmpstr("/%s/quit", _osc_path), NULL, osc_quit_handler, NULL);
lo_server_add_method(_osc_server, NULL, NULL, osc_fallback_handler, NULL);
host_request_update();
gdk_input_add(lo_server_get_socket_fd(_osc_server), GDK_INPUT_READ, (GdkInputFunction)lo_server_recv_noblock, _osc_server);
_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_title(_window, tmpstr("%s - %s", plug_name, identifier));
gtk_signal_connect(GTK_OBJECT(_window), "delete-event", on_window_deleted, NULL);
size_t i; for (i=0; i<kAmsynthParameterCount; i++) {
gdouble value = 0, lower = 0, upper = 0, step_increment = 0;
get_parameter_properties(i, &lower, &upper, &value, &step_increment);
_adjustments[i] = (GtkAdjustment *)gtk_adjustment_new(value, lower, upper, step_increment, 0, 0);
g_signal_connect(_adjustments[i], "value-changed", (GCallback)&on_adjustment_value_changed, (gpointer)i);
}
GtkWidget *editor = editor_pane_new(new SynthesizerStub, _adjustments, TRUE);
gtk_container_add(GTK_CONTAINER(_window), editor);
gtk_widget_show_all(GTK_WIDGET(editor));
gtk_main();
return 0;
}
int
Client::init_thread(const char *nsm_url)
{
this->nsm_url = nsm_url;
lo_address addr = lo_address_new_from_url(nsm_url);
int proto = lo_address_get_protocol(addr);
lo_address_free(addr);
_st = lo_server_thread_new_with_proto(NULL, proto, NULL);
_server = lo_server_thread_get_server(_st);
if(!_server || !_st)
return -1;
lo_server_thread_add_method(_st,
"/error",
"sis",
&Client::osc_error,
this);
lo_server_thread_add_method(_st,
"/reply",
"ssss",
&Client::osc_announce_reply,
this);
lo_server_thread_add_method(_st,
"/nsm/client/open",
"sss",
&Client::osc_open,
this);
lo_server_thread_add_method(_st,
"/nsm/client/save",
"",
&Client::osc_save,
this);
lo_server_thread_add_method(_st,
"/nsm/client/session_is_loaded",
"",
&Client::osc_session_is_loaded,
this);
lo_server_thread_add_method(_st,
NULL,
NULL,
&Client::osc_broadcast,
this);
return 0;
}
void
announce ( const char *nsm_url, const char *client_name, const char *process_name )
{
printf( "Announcing to NSM\n" );
lo_address to = lo_address_new_from_url( nsm_url );
int pid = (int)getpid();
lo_send_from( to, losrv, LO_TT_IMMEDIATE, "/nsm/server/announce", "sssiii",
client_name,
":optional-gui:",
process_name,
1, /* api_major_version */
0, /* api_minor_version */
pid );
lo_address_free( to );
}
void loop()
{
printf("-------------------- GO ! --------------------\n");
int i = 0, j = 0, count;
if (automate) {
char source_name[1024], destination_name[1024];
printf("%s\n", mdev_name(source));
printf("%s\n", mdev_name(destination));
lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570");
lo_address_set_ttl(a, 1);
lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination));
for (int i = 0; i < 4; i++) {
msig_full_name(sendsig[i], source_name, 1024);
msig_full_name(recvsig[i], destination_name, 1024);
lo_send(a, "/connect", "ss", source_name, destination_name);
}
lo_address_free(a);
}
while (i >= 0 && !done) {
for (j = 0; j < 4; j++) {
msig_update_float(recvsig[j], ((i % 10) * 1.0f));
}
printf("\ndestination values updated to %d -->\n", i % 10);
for (j = 0; j < 4; j++) {
count = msig_query_remote(sendsig[j], dummysig[j]);
printf("Sent %i queries for sendsig[%i]\n", count, j);
}
mdev_poll(destination, 100);
mdev_poll(source, 0);
i++;
usleep(500 * 1000);
}
}
void port_checker::server::init(const char* target_url)
{
target = lo_address_new_from_url(target_url);
if(!target || !lo_address_get_url(target) ||
!lo_address_get_port(target) ||
lo_address_get_protocol(target) != LO_UDP)
throw std::runtime_error("invalid address");
srv = lo_server_new_with_proto(nullptr, LO_UDP, liblo_error_cb);
if(srv == nullptr)
throw std::runtime_error("Could not create lo server");
lo_server_add_method(srv, nullptr, nullptr, handle_st, this);
rtosc_arg_val_t hi[2];
hi[0].type = hi[1].type = 's';
hi[0].val.s = hi[1].val.s = "";
send_msg("/path-search", 2, hi);
std::vector<rtosc_arg_val_t> reply;
std::vector<char> buf;
wait_for_reply(&buf, &reply, "/paths");
}
void loop()
{
printf("-------------------- GO ! --------------------\n");
int i = 0;
if (automate) {
char source_name_1[1024], destination_name_1[1024];
char source_name_2[1024], destination_name_2[1024];
printf("%s\n", mdev_name(source));
printf("%s\n", mdev_name(destination));
lo_address a = lo_address_new_from_url("osc.udp://224.0.1.3:7570");
lo_address_set_ttl(a, 1);
lo_send(a, "/link", "ss", mdev_name(source), mdev_name(destination));
msig_full_name(sendsig_1, source_name_1, 1024);
msig_full_name(recvsig_1, destination_name_1, 1024);
lo_send(a, "/connect", "ss", source_name_1, destination_name_1);
msig_full_name(sendsig_2, source_name_2, 1024);
msig_full_name(recvsig_2, destination_name_2, 1024);
lo_send(a, "/connect", "ss", source_name_2, destination_name_2);
lo_address_free(a);
}
while (i >= 0 && !done) {
mdev_poll(source, 0);
msig_update_float(source->outputs[0], ((i % 10) * 1.0f));
msig_update_float(source->outputs[1], ((i % 10) * 1.0f));
printf("source value updated to %d -->\n", i % 10);
printf("Received %i messages.\n\n", mdev_poll(destination, 100));
i++;
}
}
int connect_handler(const char *path, const char *types, lo_arg ** argv,
int argc, void *data, void *user_data)
{
/* example showing pulling the argument values out of the argv array */
printf("%s\n", path);
fflush(stdout);
lo_address a = lo_message_get_source(data);
if(strcmp(lo_address_get_url(address[0]), lo_address_get_url(a)) == 0 ||
strcmp(lo_address_get_url(address[1]), lo_address_get_url(a)) == 0) {
// already stored as a client
} else {
address[osc_nconnection%2] = lo_address_new_from_url(lo_address_get_url(a));
printf("OSC client %i address changed to:%s\n", osc_nconnection%2, lo_address_get_url(address[osc_nconnection%2]));
++osc_nconnection;
if(osc_nclient < 2)
++osc_nclient;
}
struct deck *de;
struct player *pl;
fprintf(stderr, "osc_nclient %i osc_ndeck: %i\n", osc_nclient, osc_ndeck);
int d;
for(d = 0; d < osc_ndeck; ++d) {
de = &osc_deck[d];
pl = &de->player;
osc_send_track_load(de);
osc_send_ppm_block(pl->track);
}
return 0;
}
int
Client::osc_announce_reply(const char *path,
const char *types,
lo_arg **argv,
int argc,
lo_message msg,
void *user_data)
{
if(strcmp(&argv[0]->s, "/nsm/server/announce"))
return -1;
NSM::Client *nsm = (NSM::Client *)user_data;
// MESSAGE( "Successfully registered. NSM says: %s", &argv[1]->s );
nsm->nsm_is_active = true;
nsm->_session_manager_name = strdup(&argv[2]->s);
nsm->nsm_addr =
lo_address_new_from_url(lo_address_get_url(lo_message_get_source(
msg)));
nsm->command_active(nsm->nsm_is_active);
return 0;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int err;
int hslen;
lo_address d;
if (nrhs != 2 && nrhs!=1) {
mexErrMsgTxt("Please specify host name/address and port or URL");
return;
}
if (nlhs > 1) {
mexErrMsgTxt("Too many output arguments.");
return;
}
if(! mxIsChar(prhs[0])) {
mexErrMsgTxt("Expecting a character array in the first argument (hostname or URL).");
return;
}
if(nrhs==2 && ! mxIsNumeric(prhs[1])) {
mexErrMsgTxt("Expecting a numeric scalar in the second argument (port number).");
return;
}
hslen = (mxGetM(prhs[0]) * mxGetN(prhs[0])) + 1;
if(hslen > sizeof(host)+1) {
mexErrMsgTxt("Maximum url/hostname string length is 255 characters.");
return;
}
err = mxGetString(prhs[0], host, hslen);
if(err != 0) {
mexErrMsgTxt("Error reading url/hostname string.");
return;
}
if (nrhs==2) {
sprintf(port, "%d", (int)(mxGetScalar(prhs[1])));
d = lo_address_new(host, port);
} else {
d = lo_address_new_from_url(host);
}
if(! d) {
mexErrMsgTxt(lo_address_errstr(d));
return;
}
if(sizeof(d) == sizeof(long int)) {
sprintf(maddr, "osc_address:%lx", (long int)d);
} else if(sizeof(d) == sizeof(long long int)) {
sprintf(maddr, "osc_address:%llx", (long long int)d);
} else {
mexErrMsgTxt("Unsupported pointer size.");
return;
}
plhs[0] = mxCreateString(maddr);
}
// *********************************************************
// -(new)---------------------------------------------------
void *oscmulticast_new(t_symbol *s, int argc, t_atom *argv)
{
t_oscmulticast *x = NULL;
int i, got_port = 0;
char address[64];
#ifdef MAXMSP
if ((x = object_alloc(oscmulticast_class))) {
x->outlet3 = listout((t_object *)x);
x->outlet2 = listout((t_object *)x);
x->outlet1 = listout((t_object *)x);
#else
if (x = (t_oscmulticast *) pd_new(oscmulticast_class)) {
x->outlet1 = outlet_new(&x->ob, gensym("list"));
x->outlet2 = outlet_new(&x->ob, gensym("list"));
x->outlet3 = outlet_new(&x->ob, gensym("list"));
#endif
x->group = NULL;
x->iface = NULL;
if (argc < 4) {
post("oscmulticast: not enough arguments!\n");
return NULL;
}
for (i = 0; i < argc; i++) {
if(strcmp(maxpd_atom_get_string(argv+i), "@group") == 0) {
if ((argv+i+1)->a_type == A_SYM) {
x->group = strdup(maxpd_atom_get_string(argv+i+1));
i++;
}
}
else if (strcmp(maxpd_atom_get_string(argv+i), "@port") == 0) {
if ((argv+i+1)->a_type == A_FLOAT) {
snprintf(x->port, 10, "%i", (int)maxpd_atom_get_float(argv+i+1));
got_port = 1;
i++;
}
#ifdef MAXMSP
else if ((argv+i+1)->a_type == A_LONG) {
snprintf(x->port, 10, "%i", (int)atom_getlong(argv+i+1));
got_port = 1;
i++;
}
#endif
}
else if(strcmp(maxpd_atom_get_string(argv+i), "@interface") == 0) {
if ((argv+i+1)->a_type == A_SYM) {
x->iface = strdup(maxpd_atom_get_string(argv+i+1));
i++;
}
}
}
if (!x->group || !got_port) {
post("oscmulticast: need to specify group and port!");
return NULL;
}
/* Open address */
snprintf(address, 64, "osc.udp://%s:%s", x->group, x->port);
x->address = lo_address_new_from_url(address);
if (!x->address) {
post("oscmulticast: could not create lo_address.");
return NULL;
}
/* Set TTL for packet to 1 -> local subnet */
lo_address_set_ttl(x->address, 1);
/* Specify the interface to use for multicasting */
if (x->iface) {
if (lo_address_set_iface(x->address, x->iface, 0)) {
post("oscmulticast: could not create lo_address.");
return NULL;
}
x->server = lo_server_new_multicast_iface(x->group, x->port, x->iface, 0, 0);
}
else {
x->server = lo_server_new_multicast(x->group, x->port, 0);
}
if (!x->server) {
post("oscmulticast: could not create lo_server");
lo_address_free(x->address);
return NULL;
}
// Disable liblo message queueing
lo_server_enable_queue(x->server, 0, 1);
if (x->iface)
post("oscmulticast: using interface %s", lo_address_get_iface(x->address));
else
post("oscmulticast: using default interface");
lo_server_add_method(x->server, NULL, NULL, oscmulticast_handler, x);
#ifdef MAXMSP
x->clock = clock_new(x, (method)oscmulticast_poll); // Create the timing clock
#else
x->clock = clock_new(x, (t_method)oscmulticast_poll);
#endif
clock_delay(x->clock, INTERVAL); // Set clock to go off after delay
}
return (x);
}
// *********************************************************
// -(free)--------------------------------------------------
void oscmulticast_free(t_oscmulticast *x)
{
if (x->clock) {
clock_unset(x->clock); // Remove clock routine from the scheduler
clock_free(x->clock); // Frees memory used by clock
}
if (x->server) {
lo_server_free(x->server);
}
if (x->address) {
lo_address_free(x->address);
}
if (x->iface) {
free(x->iface);
}
if (x->group) {
free(x->group);
}
}
// *********************************************************
// -(inlet/outlet assist - maxmsp only)---------------------
#ifdef MAXMSP
void oscmulticast_assist(t_oscmulticast *x, void *b, long m, long a, char *s)
{
if (m == ASSIST_INLET) { // inlet
sprintf(s, "OSC to be sent to multicast bus");
}
else { // outlet
sprintf(s, "OSC from multicast bus");
}
}
#endif
// *********************************************************
// -(interface)---------------------------------------------
static void oscmulticast_interface(t_oscmulticast *x, t_symbol *s, int argc, t_atom *argv)
{
const char *iface = 0;
if (argc < 1)
return;
if (argv->a_type != A_SYM)
return;
iface = maxpd_atom_get_string(argv);
if (lo_address_set_iface(x->address, iface, 0)) {
post("oscmulticast: could not create lo_address.");
return;
}
if (x->server)
lo_server_free(x->server);
x->server = lo_server_new_multicast_iface(x->group, x->port, iface, 0, 0);
if (!x->server) {
post("oscmulticast: could not create lo_server");
return;
}
post("oscmulticast: using interface %s", lo_address_get_iface(x->address));
lo_server_add_method(x->server, NULL, NULL, oscmulticast_handler, x);
}
// *********************************************************
// -(anything)----------------------------------------------
void oscmulticast_anything(t_oscmulticast *x, t_symbol *s, int argc, t_atom *argv)
{
lo_message m = lo_message_new();
if (!m) {
post("lo_message_new() error");
return;
}
int i;
for (i=0; i<argc; i++)
{
switch ((argv + i)->a_type)
{
case A_FLOAT:
lo_message_add_float(m, atom_getfloat(argv + i));
break;
#ifdef MAXMSP
case A_LONG:
lo_message_add_int32(m, (int)atom_getlong(argv + i));
break;
#endif
case A_SYM:
lo_message_add_string(m, maxpd_atom_get_string(argv + i));
break;
}
}
//set timetag?
lo_send_message(x->address, s->s_name, m);
lo_message_free(m);
}
int main()
{
lo_blob btest = lo_blob_new(sizeof(testdata), testdata);
lo_server_thread st, sta, stb;
lo_server s = lo_server_new(NULL, error);
lo_bundle b;
lo_message m1, m2;
char *server_url, *path, *protocol, *host, *port;
const char *host2, *port2;
lo_address a;
uint8_t midi_data[4] = {0xff, 0xf7, 0xAA, 0x00};
union end_test32 et32;
union end_test64 et64;
lo_timetag tt = {0x1, 0x80000000}, sched;
int count;
int proto;
char cmd[256];
test_deserialise();
sta = lo_server_thread_new("7591", error);
stb = lo_server_thread_new("7591", rep_error);
if (stb) {
fprintf(stderr, "FAILED: create bad server thread object!\n");
exit(1);
}
lo_server_thread_free(sta);
/* leak check */
st = lo_server_thread_new(NULL, error);
lo_server_thread_start(st);
#ifdef WIN32
Sleep(4);
#else
usleep(4000);
#endif
lo_server_thread_stop(st);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
lo_server_thread_start(st);
lo_server_thread_stop(st);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
lo_server_thread_free(st);
st = lo_server_thread_new(NULL, error);
a = lo_address_new_from_url("osc://localhost/");
TEST(a != NULL);
lo_address_free(a);
a = lo_address_new_from_url("osc.://localhost/");
TEST(a == NULL);
atexit(exitcheck);
printf("type tests\n");
TEST(sizeof(float) == sizeof(int32_t));
TEST(sizeof(double) == sizeof(int64_t));
et32.i = 0x23242526U;
et32.i = lo_htoo32(et32.i);
if (et32.c[0] != 0x23 || et32.c[1] != 0x24 || et32.c[2] != 0x25 ||
et32.c[3] != 0x26) {
fprintf(stderr, "failed 32bit endian conversion test\n");
fprintf(stderr, "0x23242526 -> %X\n", et32.i);
exit(1);
} else {
printf("passed 32bit endian conversion test\n");
}
et64.i = 0x232425262728292AULL;
et64.i = lo_htoo64(et64.i);
if (et64.c[0] != 0x23 || et64.c[1] != 0x24 || et64.c[2] != 0x25 ||
et64.c[3] != 0x26 || et64.c[4] != 0x27 || et64.c[5] != 0x28 ||
et64.c[6] != 0x29 || et64.c[7] != 0x2A) {
fprintf(stderr, "failed 64bit endian conversion\n");
fprintf(stderr, "0x232425262728292A -> %llX\n", (long long unsigned int)et64.i);
exit(1);
} else {
printf("passed 64bit endian conversion\n");
}
printf("\n");
/* OSC URL tests */
path = lo_url_get_path("osc.udp://localhost:9999/a/path/is/here");
if (strcmp(path, "/a/path/is/here")) {
printf("failed lo_url_get_path() test1\n");
printf("'%s' != '/a/path/is/here'\n", path);
exit(1);
} else {
printf("passed lo_url_get_path() test1\n");
}
free(path);
protocol = lo_url_get_protocol("osc.udp://localhost:9999/a/path/is/here");
if (strcmp(protocol, "udp")) {
printf("failed lo_url_get_protocol() test1\n");
printf("'%s' != 'udp'\n", protocol);
exit(1);
} else {
printf("passed lo_url_get_protocol() test1\n");
}
free(protocol);
protocol = lo_url_get_protocol("osc.tcp://localhost:9999/a/path/is/here");
if (strcmp(protocol, "tcp")) {
printf("failed lo_url_get_protocol() test2\n");
printf("'%s' != 'tcp'\n", protocol);
exit(1);
} else {
printf("passed lo_url_get_protocol() test2\n");
}
free(protocol);
protocol = lo_url_get_protocol("osc.udp://[::ffff:localhost]:9999/a/path/is/here");
if (strcmp(protocol, "udp")) {
printf("failed lo_url_get_protocol() test1 (IPv6)\n");
printf("'%s' != 'udp'\n", protocol);
exit(1);
} else {
printf("passed lo_url_get_protocol() test1 (IPv6)\n");
}
free(protocol);
proto = lo_url_get_protocol_id("osc.udp://localhost:9999/a/path/is/here");
if (proto != LO_UDP) {
printf("failed lo_url_get_protocol_id() test1\n");
printf("'%d' != LO_UDP\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test1\n");
}
proto = lo_url_get_protocol_id("osc.tcp://localhost:9999/a/path/is/here");
if (proto != LO_TCP) {
printf("failed lo_url_get_protocol_id() test2\n");
printf("'%d' != LO_TCP\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test2\n");
}
proto = lo_url_get_protocol_id("osc.invalid://localhost:9999/a/path/is/here");
if (proto != -1) {
printf("failed lo_url_get_protocol_id() test3\n");
printf("'%d' != -1\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test3\n");
}
proto = lo_url_get_protocol_id("osc.udp://[::ffff:localhost]:9999/a/path/is/here");
if (proto != LO_UDP) {
printf("failed lo_url_get_protocol_id() test1 (IPv6)\n");
printf("'%d' != LO_UDP\n", proto);
exit(1);
} else {
printf("passed lo_url_get_protocol_id() test1 (IPv6)\n");
}
host = lo_url_get_hostname("osc.udp://foo.example.com:9999/a/path/is/here");
if (strcmp(host, "foo.example.com")) {
printf("failed lo_url_get_hostname() test1\n");
printf("'%s' != 'foo.example.com'\n", host);
exit(1);
} else {
printf("passed lo_url_get_hostname() test1\n");
}
free(host);
host = lo_url_get_hostname("osc.udp://[0000::::0001]:9999/a/path/is/here");
if (strcmp(host, "0000::::0001")) {
printf("failed lo_url_get_hostname() test2 (IPv6)\n");
printf("'%s' != '0000::::0001'\n", host);
exit(1);
} else {
printf("passed lo_url_get_hostname() test2 (IPv6)\n");
}
free(host);
port = lo_url_get_port("osc.udp://localhost:9999/a/path/is/here");
if (strcmp(port, "9999")) {
printf("failed lo_url_get_port() test1\n");
printf("'%s' != '9999'\n", port);
exit(1);
} else {
printf("passed lo_url_get_port() test1\n");
}
free(port);
port = lo_url_get_port("osc.udp://[::ffff:127.0.0.1]:9999/a/path/is/here");
if (strcmp(port, "9999")) {
printf("failed lo_url_get_port() test1 (IPv6)\n");
printf("'%s' != '9999'\n", port);
exit(1);
} else {
printf("passed lo_url_get_port() test1 (IPv6)\n");
}
free(port);
printf("\n");
a = lo_address_new_from_url("osc.tcp://foo.example.com:9999/");
host2 = lo_address_get_hostname(a);
if (strcmp(host2, "foo.example.com")) {
printf("failed lo_address_get_hostname() test\n");
printf("'%s' != 'foo.example.com'\n", host2);
exit(1);
} else {
printf("passed lo_address_get_hostname() test\n");
}
port2 = lo_address_get_port(a);
if (strcmp(port2, "9999")) {
printf("failed lo_address_get_port() test\n");
printf("'%s' != '9999'\n", port2);
exit(1);
} else {
printf("passed lo_address_get_port() test\n");
}
proto = lo_address_get_protocol(a);
if (proto != LO_TCP) {
printf("failed lo_address_get_protocol() test\n");
printf("'%d' != '%d'\n", proto, LO_TCP);
exit(1);
} else {
printf("passed lo_address_get_protocol() test\n");
}
server_url = lo_address_get_url(a);
if (strcmp(server_url, "osc.tcp://foo.example.com:9999/")) {
printf("failed lo_address_get_url() test\n");
printf("'%s' != '%s'\n", server_url, "osc.tcp://foo.example.com:9999/");
exit(1);
} else {
printf("passed lo_address_get_url() test\n");
}
free(server_url);
lo_address_free( a );
printf("\n");
/* Test blod sizes */
if (lo_blob_datasize(btest) != 5 || lo_blobsize(btest) != 12) {
printf("blob is %d (%d) bytes long, should be 5 (12)\n",
lo_blob_datasize(btest), lo_blobsize(btest));
lo_arg_pp(LO_BLOB, btest);
printf(" <- blob\n");
exit(1);
}
/* Server method handler tests */
server_url = lo_server_thread_get_url(st);
a = lo_address_new_from_url(server_url);
printf("Server URL: %s\n", server_url);
free(server_url);
/* add method that will match the path /foo/bar, with two numbers, coerced
* to float and int */
lo_server_thread_add_method(st, "/foo/bar", "fi", foo_handler, lo_server_thread_get_server(st));
lo_server_thread_add_method(st, "/reply", "s", reply_handler, NULL);
lo_server_thread_add_method(st, "/lotsofformats", "fisbmhtdSccTFNI",
lots_handler, NULL);
lo_server_thread_add_method(st, "/coerce", "dfhiSs",
coerce_handler, NULL);
lo_server_thread_add_method(st, "/bundle", NULL,
bundle_handler, NULL);
lo_server_thread_add_method(st, "/timestamp", NULL,
timestamp_handler, NULL);
lo_server_thread_add_method(st, "/jitter", "ti",
jitter_handler, NULL);
lo_server_thread_add_method(st, "/pattern/foo", NULL,
pattern_handler, "foo");
lo_server_thread_add_method(st, "/pattern/bar", NULL,
pattern_handler, "bar");
lo_server_thread_add_method(st, "/pattern/baz", NULL,
pattern_handler, "baz");
lo_server_thread_add_method(st, "/subtest", "i",
subtest_handler, st);
lo_server_thread_add_method(st, "/subtest-reply", "i",
subtest_reply_handler, NULL);
/* add method that will match any path and args */
lo_server_thread_add_method(st, NULL, NULL, generic_handler, NULL);
/* add method that will match the path /quit with no args */
lo_server_thread_add_method(st, "/quit", "", quit_handler, NULL);
/* check that the thread restarts */
lo_server_thread_start(st);
lo_server_thread_stop(st);
lo_server_thread_start(st);
if (lo_send(a, "/foo/bar", "ff", 0.12345678f, 23.0f) == -1) {
printf("OSC error A %d: %s\n", lo_address_errno(a), lo_address_errstr(a));
exit(1);
}
if (lo_send(a, "/foo/bar", "ff", 0.12345678f, 23.0f) == -1) {
printf("OSC error B %d: %s\n", lo_address_errno(a), lo_address_errstr(a));
exit(1);
}
test_validation(a);
test_multicast(st);
lo_send(a, "/", "i", 242);
lo_send(a, "/pattern/", "i", 243);
#ifndef _MSC_VER /* MS compiler refuses to compile this case */
lo_send(a, "/bar", "ff", 0.12345678f, 1.0/0.0);
#endif
lo_send(a, "/lotsofformats", "fisbmhtdSccTFNI", 0.12345678f, 123, "123",
btest, midi_data, 0x0123456789abcdefULL, tt, 0.9999, "sym",
'X', 'Y');
lo_send(a, "/coerce", "fdihsS", 0.1f, 0.2, 123, 124LL, "aaa", "bbb");
lo_send(a, "/coerce", "ffffss", 0.1f, 0.2f, 123.0, 124.0, "aaa", "bbb");
lo_send(a, "/coerce", "ddddSS", 0.1, 0.2, 123.0, 124.0, "aaa", "bbb");
lo_send(a, "/a/b/c/d", "sfsff", "one", 0.12345678f, "three",
-0.00000023001f, 1.0);
lo_send(a, "/a/b/c/d", "b", btest);
TEST(test_varargs(a, "/lotsofformats", "fisbmhtdSccTFNI", 0.12345678f, 123,
"123", btest, midi_data, 0x0123456789abcdefULL, tt,
0.9999, "sym", 'X', 'Y', LO_ARGS_END) == 0);
#ifdef __GNUC__
// Note: Lack of support for variable-argument macros in non-GCC compilers
// does not allow us to test for these conditions.
// too many args
TEST(test_varargs(a, "/lotsofformats", "f", 0.12345678f, 123,
"123", btest, midi_data, 0x0123456789abcdefULL, tt,
0.9999, "sym", 'X', 'Y', LO_ARGS_END) != 0);
// too many types
TEST(test_varargs(a, "/lotsofformats", "fisbmhtdSccTFNI", 0.12345678f, 123,
"123", btest, midi_data, 0x0123456789abcdefULL, tt, 0.5,
LO_ARGS_END) != 0);
#endif
// test lo_message_add
m1 = lo_message_new();
TEST(lo_message_add(m1, "fisbmhtdSccTFNI", 0.12345678f, 123, "123",
btest, midi_data, 0x0123456789abcdefULL, tt, 0.9999, "sym",
'X', 'Y') == 0);
lo_send_message(a, "/lotsofformats", m1);
lo_message_free(m1);
lo_blob_free(btest);
lo_send(a, "/pattern/*", "s", "a");
lo_send(a, "/pattern/ba[rz]", "s", "b");
server_url = lo_server_thread_get_url(st);
sprintf(cmd, "." PATHDELIM "subtest %s &", server_url);
if (system(cmd) != 0) {
fprintf(stderr, "Cannot execute subtest command\n");
exit(1);
}
system(cmd);
free(server_url);
#ifdef WIN32
Sleep(2000);
#else
sleep(2);
#endif
TEST(reply_count == 3);
TEST(pattern_count == 5);
TEST(subtest_count == 2);
TEST(subtest_reply_count == 22);
printf("\n");
{
lo_timetag t = {10,0xFFFFFFFC};
b = lo_bundle_new(t);
}
m1 = lo_message_new();
lo_message_add_string(m1, "abcdefghijklmnopqrstuvwxyz");
lo_message_add_string(m1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
lo_bundle_add_message(b, "/bundle", m1);
lo_send_bundle(a, b);
/* This should be safe for multiple copies of the same message. */
lo_bundle_free_messages(b);
{
lo_timetag t = {1,2};
b = lo_bundle_new(t);
}
m1 = lo_message_new();
lo_message_add_int32(m1, 23);
lo_message_add_string(m1, "23");
lo_bundle_add_message(b, "/bundle", m1);
m2 = lo_message_new();
lo_message_add_string(m2, "24");
lo_message_add_int32(m2, 24);
lo_bundle_add_message(b, "/bundle", m2);
lo_bundle_add_message(b, "/bundle", m1);
/*
lo_send_bundle(a, b);
if (a->errnum) {
printf("error %d: %s\n", a->errnum, a->errstr);
exit(1);
}
*/
TEST(lo_send_bundle(a, b) == 88);
/* Test freeing out-of-order copies of messages in a bundle. */
lo_bundle_free_messages(b);
{
lo_timetag t = {10,0xFFFFFFFE};
b = lo_bundle_new(t);
}
m1 = lo_message_new();
lo_message_add_string(m1, "abcdefghijklmnopqrstuvwxyz");
lo_message_add_string(m1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
lo_bundle_add_message(b, "/bundle", m1);
lo_send_bundle(a, b);
lo_message_free(m1);
lo_bundle_free(b);
lo_timetag_now(&sched);
sched.sec += 5;
b = lo_bundle_new(sched);
m1 = lo_message_new();
lo_message_add_string(m1, "future");
lo_message_add_string(m1, "time");
lo_message_add_string(m1, "test");
lo_bundle_add_message(b, "/bundle", m1);
lo_send_bundle(a, b);
lo_message_free(m1);
lo_bundle_free(b);
lo_send_timestamped(a, sched, "/bundle", "s", "lo_send_timestamped() test");
/* test bundle timestamp ends up in message struct (and doesn't end up in
unbundled messages) */
lo_timetag_now(&sched);
lo_send_timestamped(a, sched, "/timestamp", "it", 1, sched);
lo_send(a, "/timestamp", "it", 0, sched);
#define JITTER_ITS 25
/* jitter tests */
{
lo_timetag stamps[JITTER_ITS];
lo_timetag now;
int i;
for (i=0; i<JITTER_ITS; i++) {
lo_timetag_now(&now);
stamps[i] = now;
stamps[i].sec += 1;
stamps[i].frac = rand();
lo_send_timestamped(a, stamps[i], "/jitter", "ti", stamps[i], i);
}
}
#ifdef WIN32
Sleep(2000);
#else
sleep(2);
#endif
lo_address_free(a);
TEST(lo_server_thread_events_pending(st));
while (lo_server_thread_events_pending(st)) {
printf("pending events, wait...\n");
#ifdef WIN32
fflush(stdout);
Sleep(1000);
#else
sleep(1);
#endif
}
TEST(bundle_count == 7);
printf("\n");
printf("bundle timing jitter results:\n"
"max jitter = %fs\n"
"avg jitter = %fs\n"
"min jitter = %fs\n\n",
jitter_max, jitter_total/(float)jitter_count, jitter_min);
server_url = lo_server_get_url(s);
lo_server_add_method(s, NULL, NULL, generic_handler, NULL);
a = lo_address_new_from_url(server_url);
TEST(lo_server_recv_noblock(s, 0) == 0);
printf("Testing noblock API on %s\n", server_url);
lo_send(a, "/non-block-test", "f", 23.0);
count = 0;
while (!lo_server_recv_noblock(s, 10) && count++ < 1000) { }
if (count >= 1000) {
printf("lo_server_recv_noblock() test failed\n");
exit(1);
}
/* Delete methods */
lo_server_thread_del_method(st, "/coerce", "dfhiSs");
lo_server_del_method(s, NULL, NULL);
lo_address_free(a);
lo_server_free(s);
free(server_url);
#ifndef WIN32
{ /* UNIX domain tests */
lo_address ua;
lo_server us;
char *addr;
unlink("/tmp/testlo.osc");
us = lo_server_new_with_proto("/tmp/testlo.osc", LO_UNIX, error);
ua = lo_address_new_from_url("osc.unix:///tmp/testlo.osc");
TEST(lo_server_get_protocol(us) == LO_UNIX);
TEST(lo_send(ua, "/unix", "f", 23.0) == 16);
TEST(lo_server_recv(us) == 16);
addr = lo_server_get_url(us);
TEST(!strcmp("osc.unix:////tmp/testlo.osc", addr));
free(addr);
lo_address_free(ua);
ua = lo_address_new_with_proto(LO_UNIX, NULL, "/tmp/testlo.osc");
TEST(lo_send(ua, "/unix", "f", 23.0) == 16);
TEST(lo_server_recv(us) == 16);
lo_server_free(us);
lo_address_free(ua);
}
#endif
{ /* TCP tests */
lo_address ta;
lo_server ts;
char *addr;
ts = lo_server_new_with_proto(NULL, LO_TCP, error);
addr = lo_server_get_url(ts);
ta = lo_address_new_from_url(addr);
if (lo_address_errno(ta)) {
printf("err: %s\n", lo_address_errstr(ta));
exit(1);
}
TEST(lo_server_get_protocol(ts) == LO_TCP);
TEST(lo_send(ta, "/tcp", "f", 23.0) == 16);
TEST(lo_send(ta, "/tcp", "f", 23.0) == 16);
TEST(lo_server_recv(ts) == 16);
TEST(lo_server_recv(ts) == 16);
free(addr);
lo_server_free(ts);
lo_address_free(ta);
}
server_url = lo_server_thread_get_url(st);
a = lo_address_new_from_url(server_url);
/* exit */
lo_send(a, "/quit", NULL);
lo_address_free(a);
while (!done) {
#ifdef WIN32
Sleep(1);
#else
usleep(1000);
#endif
}
lo_server_thread_free(st);
free(server_url);
return 0;
}
/* catch any osc incoming messages. */
int
OscCtrlServer::osc_handler(const char *path,
const char *types,
lo_arg ** argv, int argc, void * /*data */ ,
void *user_data) {
OscCtrlServer *context = static_cast<OscCtrlServer *>(user_data);
std::shared_ptr<QuiddityManager> manager =
context->get_quiddity_manager();
if (!(bool) manager) {
g_warning("OscCtrlServer: cannot get quiddity manager");
return 0;
}
// create
if (g_str_has_prefix(path, "/c") || g_str_has_prefix(path, "/C")) {
if (argc == 1) {
gchar *class_name = string_from_osc_arg(types[0], argv[0]);
manager->create(class_name);
g_free(class_name);
}
else if (argc == 2) {
gchar *class_name = string_from_osc_arg(types[0], argv[0]);
gchar *quid_name = string_from_osc_arg(types[1], argv[1]);
manager->create(class_name, quid_name);
g_free(class_name);
g_free(quid_name);
}
else
g_warning("OSCctl: wrong arg number for create");
return 0;
}
// remove
if (g_str_has_prefix(path, "/r") || g_str_has_prefix(path, "/R")) {
if (argc == 1) {
gchar *quid_name = string_from_osc_arg(types[0], argv[0]);
manager->remove(quid_name);
g_free(quid_name);
}
else
g_warning("OSCctl: wrong arg number for remove");
return 0;
}
// set_property
if (g_str_has_prefix(path, "/s") || g_str_has_prefix(path, "/S")) {
if (argc == 3) {
gchar *quid_name = string_from_osc_arg(types[0], argv[0]);
gchar *prop_name = string_from_osc_arg(types[1], argv[1]);
gchar *value = string_from_osc_arg(types[2], argv[2]);
manager->set_property(quid_name, prop_name, value);
g_free(quid_name);
g_free(prop_name);
g_free(value);
}
else
g_warning("OSCctl: wrong arg number for set_property");
return 0;
}
// invoke
if (g_str_has_prefix(path, "/i") || g_str_has_prefix(path, "/I")) {
if (argc >= 2) {
gchar *quid_name = string_from_osc_arg(types[0], argv[0]);
gchar *method_name = string_from_osc_arg(types[1], argv[1]);
int i;
std::vector<std::string> args;
for (i = 2; i < argc; i++) {
gchar *val = string_from_osc_arg(types[i], argv[i]);
args.push_back(val);
g_free(val);
}
manager->invoke(quid_name, method_name, nullptr, args);
g_free(quid_name);
g_free(method_name);
}
else
g_warning("OSCctl: wrong arg number for invoke");
return 0;
}
// add an osc subscriber
if (g_str_has_prefix(path, "/a") || g_str_has_prefix(path, "/A")) {
if (argc == 3) {
gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]);
gchar *host = string_from_osc_arg(types[1], argv[1]);
gchar *port = string_from_osc_arg(types[2], argv[2]);
gchar *port_int = string_float_to_string_int(port);
gchar *internal_subscriber_name =
context->make_internal_subscriber_name(subscriber_name);
if (context->osc_subscribers_.end() ==
context->osc_subscribers_.find(internal_subscriber_name)) {
g_warning
("OscCtrlServer: a subscriber named %s is already registered",
subscriber_name);
return 0;
}
if (host == nullptr || port_int == nullptr) {
g_warning("OscCtrlServer: issue with host name or port");
return 0;
}
context->osc_subscribers_[internal_subscriber_name] =
std::make_pair(host, port_int);
if (!manager->make_property_subscriber(internal_subscriber_name,
OscCtrlServer::prop_cb,
context))
return 0;
g_debug("subscriber %s, %s, %s", subscriber_name, host, port_int);
g_free(internal_subscriber_name);
g_free(subscriber_name);
g_free(host);
g_free(port);
g_free(port_int);
}
else
g_warning("OSCctl: add subscriber needs 3 args (name, host, port)");
return 0;
}
// delete an osc subscriber
if (g_str_has_prefix(path, "/d") || g_str_has_prefix(path, "/D")) {
if (argc == 1) {
gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]);
gchar *internal_subscriber_name =
context->make_internal_subscriber_name(subscriber_name);
auto it = context->osc_subscribers_.find(internal_subscriber_name);
if (context->osc_subscribers_.end() == it) {
g_warning
("OscCtrlServer: cannot delete non existing subscriber named %s",
subscriber_name);
return 0;
}
manager->remove_property_subscriber(internal_subscriber_name);
context->osc_subscribers_.erase(it);
g_free(internal_subscriber_name);
g_free(subscriber_name);
}
else
g_warning("OSCctl: delete subscriber needs 1 args (name)");
return 0;
}
// subscribe to a property
if (g_strcmp0(path, "/get") == 0) {
if (argc == 3) {
gchar *quiddity_name = string_from_osc_arg(types[0], argv[0]);
gchar *property_name = string_from_osc_arg(types[1], argv[1]);
gchar *response_url = string_from_osc_arg(types[2], argv[2]);
if (quiddity_name == nullptr || property_name == nullptr
|| response_url == nullptr) {
g_warning
("OscCtrlServer: issue with quiddity name or property name or response url");
return 0;
}
std::string value = manager->get_property(quiddity_name,
property_name);
lo_address response_lo_address =
lo_address_new_from_url(response_url);
if (response_lo_address != nullptr
&& !lo_address_errno(response_lo_address)) {
gchar *message = g_strdup_printf("/%s/%s",
quiddity_name,
property_name);
lo_send(response_lo_address, message, "s", value.c_str());
lo_address_free(response_lo_address);
g_free(message);
}
else
g_debug("url osc error in get");
g_free(quiddity_name);
g_free(property_name);
g_free(response_url);
}
else
g_warning
("OSCctl: subscribe property needs 3 args (name, quiddity, property)");
return 0;
}
// subscribe to a property
if (g_str_has_prefix(path, "/get_property_")
|| g_str_has_prefix(path, "/G")) {
if (argc == 3) {
gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]);
gchar *quiddity_name = string_from_osc_arg(types[1], argv[1]);
gchar *property_name = string_from_osc_arg(types[2], argv[2]);
gchar *internal_subscriber_name =
context->make_internal_subscriber_name(subscriber_name);
if (context->osc_subscribers_.end() ==
context->osc_subscribers_.find(internal_subscriber_name)) {
g_warning
("OscCtrlServer: a subscriber named %s does not exist",
subscriber_name);
return 0;
}
if (quiddity_name == nullptr || property_name == nullptr) {
g_warning
("OscCtrlServer: issue with quiddity name or property name");
return 0;
}
if (!manager->subscribe_property(internal_subscriber_name,
quiddity_name, property_name))
g_warning("OscCtrlServer: pb subscribing to %s, %s",
quiddity_name, property_name);
g_free(internal_subscriber_name);
g_free(subscriber_name);
g_free(quiddity_name);
g_free(property_name);
}
else
g_warning
("OSCctl: subscribe property needs 3 args (name, quiddity, property)");
return 0;
}
// unsubscribe to a property
if (g_str_has_prefix(path, "/u") || g_str_has_prefix(path, "/U")) {
if (argc == 3) {
gchar *subscriber_name = string_from_osc_arg(types[0], argv[0]);
gchar *quiddity_name = string_from_osc_arg(types[1], argv[1]);
gchar *property_name = string_from_osc_arg(types[2], argv[2]);
gchar *internal_subscriber_name =
context->make_internal_subscriber_name(subscriber_name);
if (context->osc_subscribers_.end() ==
context->osc_subscribers_.find(internal_subscriber_name)) {
g_warning
("OscCtrlServer: a subscriber named %s does not exist",
subscriber_name);
return 0;
}
if (quiddity_name == nullptr || property_name == nullptr) {
g_warning
("OscCtrlServer: issue with quiddity name or property name");
return 0;
}
if (!manager->unsubscribe_property(internal_subscriber_name,
quiddity_name, property_name))
g_warning("OscCtrlServer: pb unsubscribing to %s, %s",
quiddity_name, property_name);
g_free(internal_subscriber_name);
g_free(subscriber_name);
g_free(quiddity_name);
g_free(property_name);
}
else
g_warning
("OSCctl: unsubscribe property needs 3 args (name, quiddity, property)");
return 0;
}
g_debug("unknown osc path %s", path);
return 0;
}
int dest_handler(const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data)
{
if (dest != NULL) free(dest);
dest = lo_address_new_from_url((char*) argv[0]);
return 0;
}
