// Destructor. ~DssiEditor() { if (target) lo_address_free(target); if (source) lo_address_free(source); if (path) ::free(path); }
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--; } }
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++; } }
// BLOB functions int addr_release(atom_t a) { PL_blob_t *type; size_t len; void *p=PL_blob_data(a,&len,&type); if (p) lo_address_free(*(lo_address *)p); return TRUE; }
static void *controller_thread(void *p) { int last_scene = -1; lo_address address = lo_address_new(NULL, OSC_PORT); printf("THREAD\n"); while (scene != EXITV) { #ifdef DEBUG printf(". %d\n", scene); #endif if (last_scene != scene) { last_scene = scene; if (last_scene > 0 && last_scene <= NUM_SCENES) { lo_send(address, OSC_PATH, "i", last_scene); } } #ifdef DEBUG usleep(1000000); #else usleep(10000); #endif } lo_address_free(address); #ifdef DEBUG printf("DONE\n"); #endif return NULL; }
int main() { // install signal handler if (signal(SIGINT, endall) == SIG_ERR) printf("[FAILED] to install SIGINT handle\n"); // we're reading directly from serial ArduinoSerial arduino(ARDUINO_SERIAL); char buffer[BUFFER_S]; memset(buffer, '\0', BUFFER_S); // our main loop while(1) { // getLine() blocks until we get a newline or cr // and fills buffer with stuff arduino.getLine( buffer); printf("%s", buffer); // this message looks like "p\n" if( buffer[0] == 'p') { printf("got play\n"); lo_address server = lo_address_new(SERVER, SERVER_PORT); lo_send(server, "/playtrigger", ""); lo_address_free(server);; } // get rid of previous data memset(buffer, BUFFER_S, '\0'); } return 0; }
int main(int argc,char *argv[]) { srand(time(NULL)); int quit = 0; int seed = rand() % 255; lo_address client = lo_address_new("localhost","9999"); lo_server_thread server = lo_server_thread_new("9998",err_callback); lo_server_thread_add_method(server,"/client/quit","",quit_callback,(void*)&quit); lo_server_thread_add_method(server,NULL,NULL,all_callback,NULL); printf("starting osc server at %s with seed %d\n",lo_server_thread_get_url(server),seed); lo_server_thread_start(server); int k = 0; while (!quit) { if (lo_send(client,"/client/test","ii",seed,k++) < 0) fprintf(stderr,"osc client error: %s\n",lo_address_errstr(client)); sleep(1); } printf("stopping osc server\n"); lo_server_thread_stop(server); lo_server_thread_free(server); lo_address_free(client); return 0; }
static int info_prop_handler(lo_arg **argv, int argc, void *user_data, info_reply_func_t cb) { sosc_state_t *state = user_data; const char *host = NULL; char port[6]; lo_address *dst; if (argc == 2) host = &argv[0]->s; else host = lo_address_get_hostname(state->outgoing); portstr(port, argv[argc - 1]->i); if (!(dst = lo_address_new(host, port))) { fprintf(stderr, "sys_info_handler(): error in lo_address_new()"); return 1; } cb(dst, state); lo_address_free(dst); return 0; }
static int notify(sosc_ipc_type_t type, sosc_device_info_t *dev) { lo_address dst; char *path; int i; switch (type) { case SOSC_DEVICE_CONNECTION: path = "/serialosc/add"; break; case SOSC_DEVICE_DISCONNECTION: path = "/serialosc/remove"; break; default: return 1; } for (i = 0; i < notifications.count; i++) { if (!(dst = lo_address_new( notifications.endpoints[i].host, notifications.endpoints[i].port))) { fprintf(stderr, "notify(): couldn't allocate lo_address\n"); continue; } lo_send_from(dst, srv, LO_TT_IMMEDIATE, path, "ssi", dev->serial, dev->friendly, dev->port); lo_address_free(dst); } return 0; }
void mapper_receiver_free(mapper_receiver r) { int i; if (r) { if (r->props.src_addr) lo_address_free(r->props.src_addr); while (r->signals) { mapper_receiver_signal rs = r->signals; mapper_receiver_signal tmp = rs->next; while (rs->connections) { mapper_receiver_remove_connection(r, rs->connections); } int i; for (i=0; i<rs->num_instances; i++) { free(rs->history[i].value); free(rs->history[i].timetag); } free(rs->history); r->signals = rs->next; free(rs); rs = tmp; } for (i=0; i<r->props.num_scopes; i++) { free(r->props.scope_names[i]); } free(r->props.scope_names); free(r->props.scope_hashes); free(r); } }
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)); 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); }
void OscCtrlServer::prop_cb(const std::string &internal_subscriber_name, const std::string &quiddity_name, const std::string &property_name, const std::string &value, void *user_data) { OscCtrlServer *context = static_cast<OscCtrlServer *>(user_data); auto it = context->osc_subscribers_.find(internal_subscriber_name); if (context->osc_subscribers_.end() == it) return; std::pair<std::string, std::string> address = context->osc_subscribers_[internal_subscriber_name]; lo_address t = lo_address_new(address.first.c_str(), address.second.c_str()); gchar *subscriber_name = context->retrieve_subscriber_name(internal_subscriber_name.c_str()); gchar *message = g_strdup_printf("/property/%s/%s/%s", subscriber_name, quiddity_name.c_str(), property_name.c_str()); lo_send(t, message, "s", value.c_str()); g_free(subscriber_name); g_free(message); lo_address_free(t); }
void RoutingTable::deleteRoute(char *ip, char *osc) { for (int i=0; i<aNum; i++) { const char *addr = lo_address_get_hostname(loAddr[i]); //対象のアドレス検索 if (strcmp(ip, addr)==0 && strcmp(osc, oscAddr[i])==0) { //対象のアドレス解放、アドレス数デクリメント lo_address_free(loAddr[i]); memset(oscAddr[i], 0, sizeof(char)*64); aNum--; //ルートのアドレスをずらす for (int j=i; j<aNum; j++) { loAddr[j] = loAddr[j+1]; strcpy(oscAddr[j], oscAddr[j+1]); } loAddr[aNum] = NULL; memset(oscAddr[aNum], 0, sizeof(char)*64); //ループから出る break; } } }
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); }
~CarlaNSM() { CARLA_SAFE_ASSERT(fReadyActionOpen); CARLA_SAFE_ASSERT(fReadyActionSave); if (fServerThread != nullptr) { lo_server_thread_stop(fServerThread); lo_server_thread_free(fServerThread); fServerThread = nullptr; fServer = nullptr; } if (fServerURL != nullptr) { std::free(fServerURL); fServerURL = nullptr; } if (fReplyAddress != nullptr) { lo_address_free(fReplyAddress); fReplyAddress = nullptr; } }
RoutingTable::~RoutingTable() { for (int i=0; i<MAX_ANUM; i++) { if (loAddr[i] != NULL) lo_address_free(loAddr[i]); free(oscAddr[i]); } }
int osc_send( const char *port, const char *msg, const char *format, ...) { lo_address t = lo_address_new(NULL, port); lo_message message = lo_message_new(); va_list args; va_start( args, format); while( *format != '\0') { switch( *format) { case 's': lo_message_add_string( message, va_arg( args, const char *)); break; case 'i': lo_message_add_int32( message, va_arg( args, int)); break; case 'f': lo_message_add_float( message, va_arg( args, double)); break; } ++format; } va_end( args); if( !lo_send_message( t, msg, message)) { printf("OSC error %d: %s\n", lo_address_errno(t), lo_address_errstr(t)); } if( osc_log) osc_log_print( msg, message); lo_message_free( message); lo_address_free( t); return 0; }
RelayExpr() { // Create local relay relay = new RmmApp(RELAY_PORT, "R0"); client = new RmmApp(SOURCE_PORT, "CLIENT", MONITOR_PORT); relay->start(false); client->start(false); usleep(1e6); client->requestRegistration(SERVER_IP_VIRGINIA, RELAY_PORT); usleep(1e6); // ask the relay to redirect client->join(SERVER_IP, RELAY_PORT); usleep(1e6); lo_address target = lo_address_new(SERVER_IP, RELAY_PORT); lo_send_from(target, client->getserverptr(), LO_TT_IMMEDIATE, "/status", ""); lo_address_free(target); client->setTestListener(this); client->changeTargetName(SERVER_NAME); client->addRelayConnection(SERVER_IP_VIRGINIA, RELAY_PORT); client->addRelayConnection(SERVER_IP_TX, RELAY_PORT); client->addRelayConnection(SERVER_IP_GA, RELAY_PORT); client->addRelayConnection(SERVER_IP_UK, RELAY_PORT); for (int a = 0; a < 1000; ++a) { usleep(1000); client->poll(); relay->poll(); } }
static int oscsend_deinit(CSOUND *csound, OSCSEND *p) { lo_address a = (lo_address)p->addr; if(a != NULL) lo_address_free(a); p->addr = NULL; return OK; }
void OscTransmitter::clearAddresses() { vector<lo_address>::iterator it = addresses_.begin(); while(it != addresses_.end()) { lo_address_free(*it++); } addresses_.clear(); }
// Destructor. qtractorNsmClient::~qtractorNsmClient (void) { #ifdef CONFIG_LIBLO if (m_thread) { lo_server_thread_stop(m_thread); lo_server_thread_free(m_thread); } if (m_address) lo_address_free(m_address); #endif }
MToken::~MToken() { if(mm_addr) lo_address_free(mm_addr); if(iconData) free(iconData); auto it = inputInfo.begin(); while (it != inputInfo.end()) { char *m = *it; free(m); it = inputInfo.erase(it); } }
// Destructor. synthv1_nsm::~synthv1_nsm (void) { #ifdef CONFIG_LIBLO if (m_thread) { lo_server_thread_stop(m_thread); lo_server_thread_free(m_thread); } if (m_address) lo_address_free(m_address); #endif }
int main (int argc, char * argv[]) { lo_server_thread st; // server to receive messages from lo_address addr; // address to send messages to static struct filter ftr; // stores data to be passed to handler int i, j; // index variables /* Set up the filter signature. The signature helps us verify that things * that we think are filters are actually filters. */ srandom ((unsigned int) time (NULL)); FILTER_SIGNATURE = random (); /* check for read port and write port */ if (argc < 3) { printf ("- Missing Argument -\nUsage: oschand read_port write_port\n"); exit (1); } // if /* start a new server and set up write port */ st = lo_server_thread_new (argv[1], &error); addr = lo_address_new ("127.0.0.1", argv[2]); /* setup filter structure to be passed to joint handler */ ftr.signature = FILTER_SIGNATURE; ftr.addr = addr; ftr.num_joints = argc - 3; ftr.joints = (char **) malloc (sizeof (char *) * ftr.num_joints); for (j = 0, i = 3; j < ftr.num_joints; j++, i++) ftr.joints[j] = argv[i]; /* add method that will handle joints */ lo_server_thread_add_method (st, "/joint", "sifff", joint_handler, &ftr); /* 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); /* wait for messages */ while (!done) { #ifdef WIN32 Sleep (1); #else usleep (1000); #endif } // while lo_server_thread_free (st); lo_address_free (addr); return 0; } // main
void veejay_free_osc_sender( void *dosc ) { oscclient_t *osc = (oscclient_t*) dosc; if(osc->addr) lo_address_free( osc->addr ); if( osc->port_str ) free( osc->port_str); if( osc->addr_str) free(osc->addr_str); if( osc->window ) free(osc->window); free(osc); osc = NULL; }
void AudioPluginOSCGUI::setGUIUrl(QString url) { if (m_address) lo_address_free(m_address); QByteArray burl = url.toUtf8(); char *host = lo_url_get_hostname(burl.data()); char *port = lo_url_get_port(burl.data()); m_address = lo_address_new(host, port); free(host); free(port); m_basePath = lo_url_get_path(burl.data()); }
int main(int argc, const char * argv[]) { int tcpflag = 1; printf("Usage: lo_bndlsend [u] (u means use UDP)\n"); if (argc == 2) { tcpflag = (strchr(argv[1], 'u') == NULL); } printf("tcpflag %d\n", tcpflag); sleep(2); // allow some time for server to start client = lo_address_new_with_proto(tcpflag ? LO_TCP : LO_UDP, "localhost", "8100"); printf("client: %p\n", client); char s[128]; lo_timetag now; lo_timetag_now(&now); lo_timetag timetag; for (int i = 9; i >= 5; i--) { // make the bundle timetag_add(&timetag, now, 2 + i * 0.1); lo_bundle bndl = lo_bundle_new(timetag); // make first message sprintf(s, "an arbitrary string at 2.%d", i); lo_message msg1 = make_message(1000 + i, s); // add the message to the bundle lo_bundle_add_message(bndl, "/xyz/msg1", msg1); // make second message sprintf(s, "another arbitrary string at 2.%d", i); lo_message msg2 = make_message(2000 + i, s); // add the message to the bundle lo_bundle_add_message(bndl, "/abcdefg/msg2", msg2); // send it lo_send_bundle(client, bndl); } send_nested(now, 3.0, 0.0, 3000); send_nested(now, 3.1, 3.2, 4000); sleep(1); // make sure messages go out lo_address_free(client); sleep(1); // time to clean up socketsa printf("OSCSEND DONE\n"); 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; }
bool announce(const int pid, const char* const executableName) { CARLA_SAFE_ASSERT_RETURN(pid != 0, false); CARLA_SAFE_ASSERT_RETURN(executableName != nullptr && executableName[0] != '\0', false); const char* const NSM_URL(std::getenv("NSM_URL")); if (NSM_URL == nullptr) return false; const lo_address nsmAddress(lo_address_new_from_url(NSM_URL)); CARLA_SAFE_ASSERT_RETURN(nsmAddress != nullptr, false); const int proto = lo_address_get_protocol(nsmAddress); if (fServerThread == nullptr) { // create new OSC server fServerThread = lo_server_thread_new_with_proto(nullptr, proto, _osc_error_handler); CARLA_SAFE_ASSERT_RETURN(fServerThread != nullptr, false); // register message handlers lo_server_thread_add_method(fServerThread, "/error", "sis", _error_handler, this); lo_server_thread_add_method(fServerThread, "/reply", "ssss", _reply_handler, this); lo_server_thread_add_method(fServerThread, "/nsm/client/open", "sss", _open_handler, this); lo_server_thread_add_method(fServerThread, "/nsm/client/save", "", _save_handler, this); lo_server_thread_add_method(fServerThread, "/nsm/client/session_is_loaded", "", _loaded_handler, this); lo_server_thread_add_method(fServerThread, "/nsm/client/show_optional_gui", "", _show_gui_handler, this); lo_server_thread_add_method(fServerThread, "/nsm/client/hide_optional_gui", "", _hide_gui_handler, this); lo_server_thread_add_method(fServerThread, nullptr, nullptr, _broadcast_handler, this); fServer = lo_server_thread_get_server(fServerThread); fServerURL = lo_server_thread_get_url(fServerThread); } const char* appName = std::getenv("CARLA_NSM_NAME"); if (appName == nullptr) appName = "Carla"; lo_send_from(nsmAddress, fServer, LO_TT_IMMEDIATE, "/nsm/server/announce", "sssiii", appName, NSM_CLIENT_FEATURES, executableName, NSM_API_VERSION_MAJOR, NSM_API_VERSION_MINOR, pid); lo_address_free(nsmAddress); return true; }