int main(unsigned int argc, char* argv[])
{
int err;
pthread_t lp2osc_thread, osc2lp_thread;
// Launchpad initialization
lp = lp_register();
// OSC initialization
osc = lo_server_new(port, error_handler);
printf("port: %d\n", lo_server_get_port(osc));
fflush(stdout);
err = pthread_create(&lp2osc_thread, NULL, lp2osc, NULL);
if (err){
fprintf(stderr, "failed to start lp2osc thread, with error %d", err);
return 0;
}
err = pthread_create(&osc2lp_thread, NULL, osc2lp, NULL);
if (err){
fprintf(stderr, "failed to start osc2lp thread, with error %d", err);
return 0;
}
pthread_join(lp2osc_thread, NULL);
pthread_join(osc2lp_thread, NULL);
lp_deregister(lp);
lo_server_free(osc);
return 0;
}
void *zmqthread(void *data){
void *context = zmq_ctx_new ();
void *subscriber = zmq_socket (context, ZMQ_SUB);
void *buffer = (void *) malloc(MAXOSCSZ);
int rc = zmq_connect (subscriber, ZEROMQ);
lo_server s = lo_server_new("7772", error);
lo_server_add_method(s, "/play", "iisffffffsffffi",
play_handler,
NULL
);
lo_server_add_method(s, "/kriole", "iifff",
kriole_handler,
NULL
);
lo_server_add_method(s, NULL, NULL, generic_handler, NULL);
assert(rc == 0);
// Subscribe to all
rc = zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE,
NULL, 0);
assert (rc == 0);
while(1) {
int size = zmq_recv(subscriber, buffer, MAXOSCSZ, 0);
if (size > 0) {
lo_server_dispatch_data(s, buffer, size);
}
else {
printf("oops.\n");
}
}
return(NULL);
}
void
init_osc ( const char *osc_port )
{
losrv = lo_server_new( osc_port, NULL );
//error_handler );
char *url = lo_server_get_url(losrv);
printf("OSC: %s\n",url);
free(url);
/* NSM */
lo_server_add_method( losrv, "/nsm/client/save", "", osc_save, NULL );
lo_server_add_method( losrv, "/nsm/client/open", "sss", osc_open, NULL );
lo_server_add_method( losrv, "/nsm/client/show_optional_gui", "", osc_show_gui, NULL );
lo_server_add_method( losrv, "/nsm/client/hide_optional_gui", "", osc_hide_gui, NULL );
lo_server_add_method( losrv, "/error", "sis", osc_announce_error, NULL );
lo_server_add_method( losrv, "/reply", "ssss", osc_announce_reply, NULL );
/* GUI */
lo_server_add_method( losrv, "/nsm/proxy/label", "s", osc_label, NULL );
lo_server_add_method( losrv, "/nsm/proxy/save_signal", "i", osc_save_signal, NULL );
lo_server_add_method( losrv, "/nsm/proxy/kill", "", osc_kill, NULL );
lo_server_add_method( losrv, "/nsm/proxy/start", "ss", osc_start, NULL );
lo_server_add_method( losrv, "/nsm/proxy/update", "", osc_update, NULL );
}
int xjosc_initialize (int osc_port) {
char tmp[8];
uint32_t port = (osc_port>100 && osc_port< 60000)?osc_port:7000;
snprintf(tmp, sizeof(tmp), "%d", port);
fprintf(stderr, "OSC trying port:%i\n",port);
osc_server = lo_server_new (tmp, oscb_error);
//fprintf (stderr,"OSC port %i is in use.\n", port);
if (!osc_server) {
if(!want_quiet) fprintf(stderr, "OSC start failed.");
return(1);
}
if(!want_quiet) {
char *urlstr;
urlstr = lo_server_get_url (osc_server);
fprintf(stderr, "OSC server name: %s\n",urlstr);
free (urlstr);
}
int i;
for (i = 0; i < sizeof(OSCC) / sizeof(struct osc_command); ++i) {
lo_server_add_method(osc_server, OSCC[i].path, OSCC[i].typespec, OSCC[i].handler, NULL);
}
if(want_verbose) fprintf(stderr, "OSC server started on port %i\n",port);
return (0);
}
NonBlockOSCServer::NonBlockOSCServer( const char* port )
{
server = lo_server_new( port, NULL );
if( server == NULL ){
throw EServ();
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int err;
lo_server s;
if (nrhs != 1) {
mexErrMsgTxt("Please specify one arguement, port.");
return;
}
if (nlhs > 1) {
mexErrMsgTxt("Too many output arguments.");
return;
}
if(! mxIsNumeric(prhs[0])) {
mexErrMsgTxt("Expecting a numeric scalar in the first argument.");
return;
}
sprintf(port, "%d", (int)(mxGetScalar(prhs[0])));
s = lo_server_new(port, NULL); // No error handler...
if(! s) {
mexErrMsgTxt("Error creating server.");
return;
}
sprintf(maddr, "osc_server:%x", (void*) s);
plhs[0] = mxCreateString(maddr);
}
bool OscReceiver::start()
{
if (running_)
return false;
// TODO: handle errors
if (Logger::isEnabledFor(INFO))
{
std::ostringstream os;
os << "OscReceive.start(): calling lo_server_new(" << port_ << ", " << onError << ")";
Logger::log(INFO, os);
}
server_ = lo_server_new(boost::lexical_cast<std::string>(port_).c_str(), onError);
if (! server_)
{
std::ostringstream os;
os << "OscReceive.start(): aborting OSC receiver.";
Logger::log(WARNING, os);
return false;
}
if (Logger::isEnabledFor(INFO))
{
std::ostringstream os;
os << "OscReceive.start(): calling lo_server_add_method(" << server_ << ", NULL, NULL, " << generic_handler << ", this)";
Logger::log(INFO, os);
}
/* add method that will match any path and args */
lo_server_add_method(server_, NULL, NULL, generic_handler, this);
running_ = true;
return true;
}
my_server_thread my_server_thread_new(const char *port, lo_err_handler err_h)
{
my_server_thread st = malloc(sizeof(struct _my_server_thread));
st->s = lo_server_new(port, err_h);
st->active = 0;
st->done = 0;
if (!st->s) {
free(st);
return NULL;
}
return st;
}
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;
}
static lo_server *setup_osc_server(sosc_dev_datastore_t *devs)
{
lo_server *srv;
if (!(srv = lo_server_new(SOSC_SUPERVISOR_OSC_PORT, NULL)))
return NULL;
lo_server_add_method(
srv, "/serialosc/list", "si", dsc_list_devices, devs);
lo_server_add_method(
srv, "/serialosc/notify", "si", add_notification_endpoint, devs);
return srv;
}
int nosc_init()
{
if (!SAFE_NYQUIST) {
the_server = lo_server_new("7770", error);
/* add method that will match the path /slider, with two numbers, coerced
* to int and float */
lo_server_add_method(the_server, "/slider", "if", slider_handler, NULL);
lo_server_add_method(the_server, "/wii/orientation", "ff",
wii_orientation_handler, NULL);
lo_fd = lo_server_get_socket_fd(the_server);
nosc_enabled = true;
}
return 0;
}
OSCProxy::OSCProxy(const char* oscport) : osc_valid(false)
{
/* start a new server */
osc_server = lo_server_new(oscport, error_cb);
if (!osc_server)
return;
if (!lo_server_add_method(osc_server, "/pointers", "ffffff", pointer_handler, this)) {
lo_server_free(osc_server);
return;
}
/* get the file descriptor of the server socket, if supported */
osc_fd = lo_server_get_socket_fd(osc_server);
osc_valid = true;
}
static void
create_osc (LADSPA_Handle instance, const char *value)
{
holharm_t *s = (holharm_t *) instance;
printf ("value = %s\n", value);
char *temp;
char *host = lo_url_get_hostname (value);
char *port = lo_url_get_port (value);
char *path = lo_url_get_path (value);
s->osc_server = 0;
s->m_host = lo_address_new (host, port);
s->osc_configure_path = osc_build_path (path, "/configure");
s->osc_server = lo_server_new (NULL, osc_error);
lo_server_add_method (s->osc_server, s->osc_configure_path, "ss", NULL,
NULL);
temp = lo_server_get_url (s->osc_server);
return;
}
int main(int argc, char **argv)
{
lo_server server;
if(argc < 2) {
usage();
exit(1);
}
server = lo_server_new(argv[1], errorHandler);
if(server == NULL) {
printf("Could not start a server with port %s\n", argv[1]);
exit(1);
}
lo_server_add_method(server, NULL, NULL, messageHandler, NULL);
for(;;) {
lo_server_recv(server);
}
return 0;
}
int
main (int argc, char **argv)
{
int i;
int lo_fd;
fd_set rfds;
struct timeval tv;
int retval;
int done = 0;
int loadOK = 0;
funcion = 0;
gui.Pexit = 0 ;
gui.Pexitprogram = 0;
gui.ready = 0;
gui.D_Vol_c = 0;
gui.D_Tune_c = 0;
gui.D_Portamento_c = 0;
gui.D_LFO_Volume_c = 0;
gui.D_LFO_Frequency_c = 0;
gui.D_LFO_Delay_c = 0;
gui.D_LFO_Wave_c = 0;
gui.cop = 0;
for (i = 0; i < 6; i++)
{
gui.D_Wave_c[i] = 0;
gui.D_H_c[i] = 0;
gui.D_HF_c[i] = 0;
gui.D_OVol_c[i] = 0;
gui.D_pLFO_c[i] = 0;
gui.D_Attack_c[i] = 0;
gui.D_Decay_c[i] = 0;
gui.D_Sustain_c[i] = 0;
gui.D_Release_c[i] = 0;
}
gui.D_Ftype_c = 0;
gui.D_Fgain_c = 0;
gui.D_Fcutoff_c = 0;
gui.D_Fq_c = 0;
gui.D_FLFO_c = 0;
gui.D_FADSR_c = 0;
gui.D_Fstages_c = 0;
gui.D_Fvelocity_c = 0;
gui.D_Algo_c = 0;
New ();
New_Bank ();
char *url = argv[1];
char *host = lo_url_get_hostname (url);
char *port = lo_url_get_port (url);
char *path = lo_url_get_path (url);
char *label = argv[3];
char *temp;
pthread_create (&thr1, NULL, thread1, NULL);
gui.ui_win->copy_label (argv[3]);
gui.ui_win->show ();
sprintf (gui.uBankFilename, "%s/Default.goomf", DATADIR);
loadOK = loadbank (gui.uBankFilename);
osc_server = 0;
m_host = lo_address_new (host, port);
osc_configure_path = osc_build_path (path, "/configure");
osc_control_path = osc_build_path (path, "/control");
osc_exiting_path = osc_build_path (path, "/exiting");
osc_hide_path = osc_build_path (path, "/hide");
osc_midi_path = osc_build_path (path, "/midi");
osc_program_path = osc_build_path (path, "/program");
osc_quit_path = osc_build_path (path, "/quit");
osc_show_path = osc_build_path (path, "/show");
osc_update_path = osc_build_path (path, "/update");
osc_server = lo_server_new (NULL, osc_error);
lo_server_add_method (osc_server, osc_configure_path, "ss",
configure_handler, NULL);
lo_server_add_method (osc_server, osc_control_path, "if", control_handler,
NULL);
lo_server_add_method (osc_server, osc_hide_path, "", hide_handler, NULL);
lo_server_add_method (osc_server, osc_program_path, "ii", program_handler,
NULL);
lo_server_add_method (osc_server, osc_quit_path, "", quit_handler, NULL);
lo_server_add_method (osc_server, osc_exiting_path, "", exiting_handler,
NULL);
lo_server_add_method (osc_server, osc_show_path, "", show_handler, NULL);
lo_server_add_method (osc_server, NULL, NULL, debug_handler, NULL);
temp = lo_server_get_url (osc_server);
myurl = osc_build_path (temp, (strlen (path) > 1 ? path + 1 : path));
lo_send (m_host, osc_update_path, "s", myurl);
sleep (2);
gui.d_osc_label->copy_label (myurl);
gui.d_osc_label->redraw ();
if (!loadOK)
Send_laristra ();
lo_fd = lo_server_get_socket_fd (osc_server);
if (lo_fd > 0)
{
do
{
FD_ZERO (&rfds);
FD_SET (lo_fd, &rfds);
retval = select (lo_fd + 1, &rfds, NULL, NULL, NULL);
if (retval == -1)
{
printf ("select() error\n");
exit (1);
}
else if (retval > 0)
{
if (FD_ISSET (0, &rfds))
{
read_stdin ();
}
if (FD_ISSET (lo_fd, &rfds))
{
lo_server_recv_noblock (osc_server, 0);
}
}
}
while (!done);
}
else
{
do
{
FD_ZERO (&rfds);
FD_SET (0, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 10000;
retval = select (1, &rfds, NULL, NULL, &tv);
if (retval == -1)
{
printf ("select() error\n");
exit (1);
}
else if (retval > 0 && FD_ISSET (0, &rfds))
{
read_stdin ();
}
lo_server_recv_noblock (osc_server, 0);
}
while (!done);
}
free (host);
free (port);
free (path);
free (osc_configure_path);
free (osc_control_path);
free (osc_exiting_path);
free (osc_hide_path);
free (osc_midi_path);
free (osc_program_path);
free (osc_quit_path);
free (osc_show_path);
free (osc_update_path);
free (myurl);
return (0);
}
int
main(int argc, char *argv[])
{
char *host, *port, *path, *tmp_url;
lo_server osc_server;
gint osc_server_socket_tag;
Y_DEBUG_INIT("WhySynth_gtk");
#ifdef Y_DEBUG
GDB_MESSAGE(GDB_MAIN, " starting (pid %d)...\n", getpid());
#else
fprintf(stderr, "WhySynth_gtk starting (pid %d)...\n", getpid());
#endif
/* { int i; fprintf(stderr, "args:\n"); for(i=0; i<argc; i++) printf("%d: %s\n", i, argv[i]); } // debug */
gtk_init(&argc, &argv);
if (argc > 1 && !strcmp(argv[1], "-test")) {
gui_test_mode = 1;
test_argv[0] = argv[0];
test_argv[1] = "osc.udp://localhost:9/test/mode";
if (argc >= 5)
test_argv[4] = argv[4];
argc = 5;
argv = test_argv;
} else if (argc != 5) {
fprintf(stderr, "usage: %s <osc url> <plugin dllname> <plugin label> <user-friendly id>\n"
" or: %s -test\n", argv[0], argv[0]);
exit(1);
}
/* set up OSC support */
osc_host_url = argv[1];
host = lo_url_get_hostname(osc_host_url);
port = lo_url_get_port(osc_host_url);
path = lo_url_get_path(osc_host_url);
osc_host_address = lo_address_new(host, port);
osc_configure_path = osc_build_path(path, "/configure");
osc_control_path = osc_build_path(path, "/control");
osc_exiting_path = osc_build_path(path, "/exiting");
osc_hide_path = osc_build_path(path, "/hide");
osc_midi_path = osc_build_path(path, "/midi");
osc_program_path = osc_build_path(path, "/program");
osc_quit_path = osc_build_path(path, "/quit");
osc_rate_path = osc_build_path(path, "/sample-rate");
osc_show_path = osc_build_path(path, "/show");
osc_update_path = osc_build_path(path, "/update");
osc_server = lo_server_new(NULL, osc_error);
lo_server_add_method(osc_server, osc_configure_path, "ss", osc_configure_handler, NULL);
lo_server_add_method(osc_server, osc_control_path, "if", osc_control_handler, NULL);
lo_server_add_method(osc_server, osc_hide_path, "", osc_action_handler, "hide");
lo_server_add_method(osc_server, osc_program_path, "ii", osc_program_handler, NULL);
lo_server_add_method(osc_server, osc_quit_path, "", osc_action_handler, "quit");
lo_server_add_method(osc_server, osc_rate_path, "i", osc_action_handler, "sample-rate");
lo_server_add_method(osc_server, osc_show_path, "", osc_action_handler, "show");
lo_server_add_method(osc_server, NULL, NULL, osc_debug_handler, NULL);
tmp_url = lo_server_get_url(osc_server);
osc_self_url = osc_build_path(tmp_url, (strlen(path) > 1 ? path + 1 : path));
free(tmp_url);
GDB_MESSAGE(GDB_OSC, ": listening at %s\n", osc_self_url);
/* set up GTK+ */
update_port_wavetable_counts();
create_windows(argv[4]);
/* add OSC server socket to GTK+'s watched I/O */
if (lo_server_get_socket_fd(osc_server) < 0) {
fprintf(stderr, "WhySynth_gtk fatal: OSC transport does not support exposing socket fd\n");
exit(1);
}
osc_server_socket_tag = gdk_input_add(lo_server_get_socket_fd(osc_server),
GDK_INPUT_READ,
osc_data_on_socket_callback,
osc_server);
/* default patches, temporary patchfile support */
gui_data_friendly_patches();
rebuild_patches_list();
patches_dirty = 0;
last_configure_load_was_from_tmp = 0;
create_patches_tmp_filename(path);
/* schedule our update request */
update_request_timeout_tag = g_timeout_add(50,
update_request_timeout_callback,
NULL);
/* let GTK+ take it from here */
gtk_main();
/* clean up and exit */
GDB_MESSAGE(GDB_MAIN, ": yep, we got to the cleanup!\n");
/* release test note, if playing */
release_test_note();
/* GTK+ cleanup */
if (update_request_timeout_tag != 0)
gtk_timeout_remove(update_request_timeout_tag);
gdk_input_remove(osc_server_socket_tag);
/* say bye-bye */
if (!host_requested_quit) {
lo_send(osc_host_address, osc_exiting_path, "");
}
/* clean up patches */
if (patches) free(patches);
if (project_directory) free(project_directory);
/* clean up OSC support */
lo_server_free(osc_server);
free(host);
free(port);
free(path);
free(osc_configure_path);
free(osc_control_path);
free(osc_exiting_path);
free(osc_hide_path);
free(osc_midi_path);
free(osc_program_path);
free(osc_quit_path);
free(osc_rate_path);
free(osc_show_path);
free(osc_update_path);
free(osc_self_url);
return 0;
}
int main(int argc, char *argv[]) {
char c, *device, *sport, *aport, *ahost;
monome_rotate_t rotate = MONOME_ROTATE_0;
int i;
struct option arguments[] = {
{"help", no_argument, 0, 'h'},
{"device", required_argument, 0, 'd'},
{"server-port", required_argument, 0, 's'},
{"application-port", required_argument, 0, 'a'},
{"application-host", required_argument, 0, 'o'},
{"rotation", required_argument, 0, 'r'}
};
device = DEFAULT_MONOME_DEVICE;
sport = DEFAULT_OSC_SERVER_PORT;
aport = DEFAULT_OSC_APP_PORT;
ahost = DEFAULT_OSC_APP_HOST;
while( (c = getopt_long(argc, argv, "hd:s:a:o:r:",
arguments, &i)) > 0 ) {
switch( c ) {
case 'h':
usage(argv[0]);
return 1;
case 'd':
device = optarg;
break;
case 's':
if( is_numstr(optarg) )
sport = optarg;
else
printf("warning: \"%s\" is not a valid server port.\n",
optarg);
break;
case 'a':
if( is_numstr(optarg) )
aport = optarg;
else
printf("warning: \"%s\" is not a valid application port.\n",
optarg);
break;
case 'o':
ahost = optarg;
break;
case 'r':
switch(*optarg) {
case 'l':
case '0':
rotate = MONOME_ROTATE_0;
break;
case 't':
case '9':
rotate = MONOME_ROTATE_90;
break;
case 'r':
case '1':
rotate = MONOME_ROTATE_180;
break;
case 'b':
case '2':
rotate = MONOME_ROTATE_270;
break;
}
break;
}
}
if( optind == argc )
state.lo_prefix = m_strdup(DEFAULT_OSC_PREFIX);
else
state.lo_prefix = m_strdup(argv[optind]);
if( !(state.monome = monome_open(device)) ) {
printf("failed to open %s\n", device);
return EXIT_FAILURE;
}
if( !(state.server = lo_server_new(sport, lo_error)) )
return EXIT_FAILURE;
state.outgoing = lo_address_new(ahost, aport);
monome_register_handler(state.monome, MONOME_BUTTON_DOWN,
monome_handle_press, state.lo_prefix);
monome_register_handler(state.monome, MONOME_BUTTON_UP,
monome_handle_press, state.lo_prefix);
register_osc_methods(state.lo_prefix, state.monome);
monome_set_rotation(state.monome, rotate);
monome_led_all(state.monome, 0);
printf("monomeserial version %s, yay!\n\n", VERSION);
printf("initialized device %s at %s, which is %dx%d\n",
monome_get_serial(state.monome), monome_get_devpath(state.monome),
monome_get_rows(state.monome), monome_get_cols(state.monome));
printf("running with prefix /%s\n\n", state.lo_prefix);
/* main_loop() returns 1 if the monome was disconnected */
if( main_loop() )
printf("%s disconnected, monomeserial exiting.\nsee you later!\n\n",
monome_get_devpath(state.monome));
monome_close(state.monome);
unregister_osc_methods(state.lo_prefix);
m_free(state.lo_prefix);
lo_address_free(state.outgoing);
lo_server_free(state.server);
return EXIT_SUCCESS;
}
void osc_init() {
s = lo_server_new("12321", error);
lo_server_add_method(s, NULL, NULL, generic_handler, NULL);
}
int main()
{
int lo_fd;
fd_set rfds;
#ifndef WIN32
struct timeval tv;
#endif
int retval;
/* start a new server on port 7770 */
lo_server s = lo_server_new("7770", error);
/* add method that will match any path and args */
lo_server_add_method(s, NULL, NULL, generic_handler, NULL);
/* add method that will match the path /foo/bar, with two numbers, coerced
* to float and int */
lo_server_add_method(s, "/foo/bar", "fi", foo_handler, NULL);
/* add method that will match the path /quit with no args */
lo_server_add_method(s, "/quit", "", quit_handler, NULL);
/* get the file descriptor of the server socket, if supported */
lo_fd = lo_server_get_socket_fd(s);
if (lo_fd > 0) {
/* select() on lo_server fd is supported, so we'll use select()
* to watch both stdin and the lo_server fd. */
do {
FD_ZERO(&rfds);
#ifndef WIN32
FD_SET(0, &rfds); /* stdin */
#endif
FD_SET(lo_fd, &rfds);
retval = select(lo_fd + 1, &rfds, NULL, NULL, NULL); /* no timeout */
if (retval == -1) {
printf("select() error\n");
exit(1);
} else if (retval > 0) {
if (FD_ISSET(0, &rfds)) {
read_stdin();
}
if (FD_ISSET(lo_fd, &rfds)) {
lo_server_recv_noblock(s, 0);
}
}
} while (!done);
} else {
/* lo_server protocol does not support select(), so we'll watch
* stdin while polling the lo_server. */
#ifdef WIN32
printf
("non-blocking input from stdin not supported under Windows\n");
exit(1);
#else
do {
FD_ZERO(&rfds);
FD_SET(0, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 10000;
retval = select(1, &rfds, NULL, NULL, &tv); /* timeout every 10ms */
if (retval == -1) {
printf("select() error\n");
exit(1);
} else if (retval > 0 && FD_ISSET(0, &rfds)) {
read_stdin();
}
lo_server_recv_noblock(s, 0);
} while (!done);
#endif
}
return 0;
}
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;
}
