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 osc_controller::add_methods (lo_server s) { lo_server_add_method (s, PSYNTH_OSC_MSG_ADD, "iis", &add_cb, this); lo_server_add_method (s, PSYNTH_OSC_MSG_DELETE, "ii", &delete_cb, this); lo_server_add_method (s, PSYNTH_OSC_MSG_PARAM, NULL, ¶m_cb, this); lo_server_add_method (s, PSYNTH_OSC_MSG_ACTIVATE, "ii", &activate_cb, this); lo_server_add_method (s, PSYNTH_OSC_MSG_DEACTIVATE, "ii", &deactivate_cb, this); }
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; }
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; }
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; }
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); }
int main(int argc, const char *argv[]) { printf("Usage: lo_benchmk_client [n_addrs]\n" " n_addrs is number of paths, default is 20\n" " end n_addrs with t for TCP, e.g. 20t\n"); if (argc == 2) { n_addrs = atoi(argv[1]); printf("n_addrs is %d\n", n_addrs); use_tcp = (strchr(argv[1], 't') != NULL); } // create address for server server = lo_address_new_with_proto(use_tcp ? LO_TCP : LO_UDP, "localhost", "8000"); // create client lo_server client = lo_server_new_with_proto("8001", use_tcp ? LO_TCP : LO_UDP, NULL); // make addresses and register them with server addresses = (char **) malloc(sizeof(char **) * n_addrs); for (int i = 0; i < n_addrs; i++) { char path[100]; sprintf(path, "/benchmark/%d", i); addresses[i] = (char *) malloc(strlen(path)); strcpy(addresses[i], path); lo_server_add_method(client, path, "i", &handler, NULL); } lo_send(server, addresses[msg_count % n_addrs], "i", msg_count); while (1) { lo_server_recv_noblock(client, 0); } }
lo_method lo_server_thread_add_method(lo_server_thread st, const char *path, const char *typespec, lo_method_handler h, void *user_data) { return lo_server_add_method(st->s, path, typespec, h, user_data); }
// run OSC server in this thread but with an extra message handler // to allow the /plosc/stop message to terminate the loop. static int run_stoppable_server(my_server_thread s, int timeout) { lo_server_add_method(s->s, "/plosc/stop", NULL, stop_handler, (void *)s); my_server_thread_run(s,timeout); lo_server_del_method(s->s,"/plosc/stop",NULL); return TRUE; }
void test_multicast(lo_server_thread st) { /* test multicast server and sender */ /* message is sent from st otherwise reply doesn't work */ lo_server ms = lo_server_new_multicast("224.0.1.1", "15432", error); lo_address ma = lo_address_new("224.0.1.1", "15432"); lo_address_set_ttl(ma, 1); lo_server_add_method(ms, "/foo/bar", "fi", foo_handler, ms); lo_server_add_method(ms, "/reply", "s", reply_handler, NULL); if (lo_send_from(ma, lo_server_thread_get_server(st), LO_TT_IMMEDIATE, "/foo/bar", "ff", 0.12345678f, 23.0f) == -1) { printf("multicast send error %d: %s\n", lo_address_errno(ma), lo_address_errstr(ma)); exit(1); } TEST(lo_server_recv(ms)==24); lo_server_free(ms); lo_address_free(ma); }
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; }
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; }
foreign_t add_handler(term_t server, term_t msg, term_t types, term_t goal) { my_server_thread s; lo_method method; char *pattern, *typespec; char buffer[256]; // !! space for up to 255 arguments int rc; rc = get_server(server,&s) && get_msg(msg,&pattern) && get_types(types,buffer,256,&typespec); if (rc) { record_t goal_record=PL_record(goal); method = lo_server_add_method(s->s, pattern, typespec, prolog_handler, (void *)goal_record); } return rc; }
int main(int argc, const char * argv[]) { int tcpflag = 1; printf("Usage: lo_oscrecv [u] (u means use UDP)\n"); if (argc == 2) { tcpflag = (strchr(argv[1], 'u') == NULL); } printf("tcpflag %d\n", tcpflag); lo_server server = lo_server_new_with_proto("8100", tcpflag ? LO_TCP : LO_UDP, NULL); lo_server_add_method(server, "/i", "i", &osc_i_handler, NULL); while (message_count < 10 || timed_count < 10) { lo_server_recv_noblock(server, 0); usleep(10000); // 10ms } printf("OSCRECV DONE\n"); return 0; }
void wxSpinTreeCtrl::connectToSpin() { // add our liblo callback to all listener sockets: spin::spinBaseContext *listener = spin::spinApp::Instance().getContext(); std::vector<lo_server>::iterator servIter; for (servIter = listener->lo_rxServs_.begin(); servIter != listener->lo_rxServs_.end(); ++servIter) { std::string oscPattern = std::string("/SPIN/" + spin::spinApp::Instance().getSceneID()); // remove existing callback (if exists): lo_server_del_method((*servIter), oscPattern.c_str(), NULL); // add new callback: lo_server_add_method((*servIter), oscPattern.c_str(), NULL, wxSpinTreeCtrl_liblo_callback, this); // TODO: we should really have callbacks for node messages and scene // messages rather than parsing every single message received //lo_server_add_method((*servIter), NULL, NULL, wxSpinTreeCtrl_liblo_callback, this); } }
void* osc2lp() { // register methods lo_server_add_method(osc, NULL, NULL, generic_handler, NULL); lo_server_add_method(osc, "/lp/matrix", "iii", matrix_handler, NULL); lo_server_add_method(osc, "/lp/scene", "ii", scene_handler, NULL); lo_server_add_method(osc, "/lp/ctrl", "ii", ctrl_handler, NULL); lo_server_add_method(osc, "/lp/reset", "", reset_handler, NULL); lo_server_add_method(osc, "/lp/dest", "s", dest_handler, NULL); while (true) { fflush(stdout); lo_server_recv(osc); } }
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"); }
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 Client::init(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); _server = lo_server_new_with_proto(NULL, proto, NULL); if(!_server) return -1; lo_server_add_method(_server, "/error", "sis", &Client::osc_error, this); lo_server_add_method(_server, "/reply", "ssss", &Client::osc_announce_reply, this); lo_server_add_method(_server, "/nsm/client/open", "sss", &Client::osc_open, this); lo_server_add_method(_server, "/nsm/client/save", "", &Client::osc_save, this); lo_server_add_method(_server, "/nsm/client/session_is_loaded", "", &Client::osc_session_is_loaded, this); lo_server_add_method(_server, NULL, NULL, &Client::osc_broadcast, this); return 0; }
static void register_osc_methods(char *prefix, monome_t *monome) { lo_server_thread srv = state.server; char *cmd_buf; ASPRINTF_OR_BAIL(&cmd_buf, "/%s/led", prefix); lo_server_add_method(srv, cmd_buf, "iii", osc_led_handler, monome); m_free(cmd_buf); ASPRINTF_OR_BAIL(&cmd_buf, "/%s/clear", prefix); lo_server_add_method(srv, cmd_buf, "", osc_led_all_handler, monome); lo_server_add_method(srv, cmd_buf, "i", osc_led_all_handler, monome); m_free(cmd_buf); ASPRINTF_OR_BAIL(&cmd_buf, "/%s/frame", prefix); lo_server_add_method(srv, cmd_buf, "iiiiiiii", osc_led_map_handler, monome); lo_server_add_method(srv, cmd_buf, "iiiiiiiiii", osc_led_map_handler, monome); m_free(cmd_buf); ASPRINTF_OR_BAIL(&cmd_buf, "/%s/led_row", prefix); lo_server_add_method(srv, cmd_buf, "ii", osc_led_col_row_handler, monome); lo_server_add_method(srv, cmd_buf, "iii", osc_led_col_row_handler, monome); m_free(cmd_buf); ASPRINTF_OR_BAIL(&cmd_buf, "/%s/led_col", prefix); lo_server_add_method(srv, cmd_buf, "ii", osc_led_col_row_handler, monome); lo_server_add_method(srv, cmd_buf, "iii", osc_led_col_row_handler, monome); m_free(cmd_buf); ASPRINTF_OR_BAIL(&cmd_buf, "/%s/intensity", prefix); lo_server_add_method(srv, cmd_buf, "", osc_intensity_handler, monome); lo_server_add_method(srv, cmd_buf, "i", osc_intensity_handler, monome); m_free(cmd_buf); }
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 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; }
void NonBlockOSCServer::addMethod( const char* path, const char* types, lo_method_handler h, void* user_data ) { lo_server_add_method( server, path, types, h, user_data ); }
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 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; }
void osc_init() { s = lo_server_new("12321", error); lo_server_add_method(s, NULL, NULL, generic_handler, NULL); }
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); }
// ********************************************************* // -(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); }