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