made the 3 osc ports configurable via (cross-platform) config scripts and move them outside of well used ranges for UDP

app/MainWindow.cpp

@@ -27,9 +27,11 @@
 
 using namespace std;
 
-MainWindow::MainWindow() :
+MainWindow::MainWindow(const string &port, const string &audio_port, const string &process_port) :
     m_last_file("."),
-    m_feedback("8890")
+    m_feedback(port),
+    m_audio_port(audio_port),
+    m_process_port(process_port)
 {
   m_sound_item_enable_mapper = new QSignalMapper(this);
   m_sound_item_delete_mapper = new QSignalMapper(this);
@@ -59,8 +61,8 @@ MainWindow::MainWindow() :
     for (int i=0; i<10; i++) {
       osc_destination d;
       d.m_id=i;
-      d.m_audio_address = lo_address_new_from_url("osc.udp://localhost:8888");
-      d.m_process_address = lo_address_new_from_url("osc.udp://localhost:8889");
+      d.m_audio_address = lo_address_new_from_url(string("osc.udp://localhost:"+m_audio_port).c_str());
+      d.m_process_address = lo_address_new_from_url(string("osc.udp://localhost:"+m_process_port).c_str());
       if (i==0) d.m_enabled=true;
       else d.m_enabled=false;
       add_gui_address(d,enable_mapper);

app/MainWindow.h

@@ -18,6 +18,7 @@
 #include <QDirIterator>
 #include <QFileDialog>
 #include <QLineEdit>
+#include <QMessageBox>
 #include "ui_samplebrain.h"
 #include "SettingsDialog.h"
 
@@ -37,7 +38,15 @@ class MainWindow : public QMainWindow
   Q_OBJECT
 
 public:
-    MainWindow();
+  MainWindow(const string &port, const string &audio_port, const string &process_port);
+
+  void message(const string &msg) {
+    QMessageBox::information(this,"problem",msg.c_str(), QMessageBox::Ok);    
+  }
+
+  bool ok() {
+    return m_feedback.ok();
+  }
   
   // all this to work around liblo's use of varargs...
   void send_audio_osc(const char *name, const char *types) {
@@ -385,8 +394,8 @@ private slots:
       string url = d.m_address->text().toUtf8().constData();
       lo_address_free(d.m_audio_address);
       lo_address_free(d.m_process_address);
-        d.m_audio_address = lo_address_new_from_url(string(url+":8888").c_str());
-        d.m_process_address = lo_address_new_from_url(string(url+":8889").c_str());
+      d.m_audio_address = lo_address_new_from_url(string(url+":"+m_audio_port).c_str());
+      d.m_process_address = lo_address_new_from_url(string(url+":"+m_process_port).c_str());
       // start sending messages here
       d.m_enabled=true;
     } else {
@@ -442,4 +451,6 @@ private:
   SettingsDialog *m_settings_dialog;
   audio_thread *m_audio_thread;
   
+  string m_audio_port;
+  string m_process_port;
 };

app/audio_thread.cpp

@@ -20,26 +20,23 @@
 using namespace spiralcore;
 using namespace std;
 
-audio_thread::audio_thread(process_thread &p) :
+audio_thread::audio_thread(const string &port, process_thread &p) :
   m_audio_device(NULL),
-  m_osc("8888"),
+  m_osc(port),
   m_process_thread(p),
   m_brain_mutex(p.m_brain_mutex),
   m_stereo_mode(false),
   m_mic_mode(false),
   m_bufsize(2048),
   m_samplerate(44100),
-  m_device("")
-{
-  //  start_audio();
+  m_device("") {
+
   pthread_mutex_lock(m_brain_mutex);
   m_left_renderer = new renderer(p.m_source,p.m_left_target);
   m_right_renderer = new renderer(p.m_source,p.m_right_target);
   m_block_stream = new block_stream();
   pthread_mutex_unlock(m_brain_mutex);
   m_osc.run();
-  // it this threadsafe? 
-  //  m_audio_device->report_devices();
 }
 
 static bool state = 1;

app/audio_thread.h

@@ -26,12 +26,12 @@ namespace spiralcore {
 
   class audio_thread {
   public:
-    audio_thread(process_thread &p);
+    audio_thread(const string &port, process_thread &p);
     ~audio_thread();
 
     void start_audio();
     void restart_audio(const string device, unsigned int samplerate, unsigned int bufsize);
-
+    bool ok() { return m_osc.ok(); }
     void process(sample &left_in, sample &right_in, sample &left_out, sample &right_out);
 
     static void run_audio(void* c, unsigned int frames);

app/feedback.h

@@ -29,6 +29,7 @@ class feedback {
 public:
   feedback(std::string address);
   void poll(QStatusBar *s, sound_items *sound_items, SettingsDialog *settings);
+  bool ok() { return m_osc.ok(); }
   
 private:
 

app/process_thread.cpp

@@ -32,8 +32,8 @@ static void* _process(void *c) {
   return NULL;
 }
 
-process_thread::process_thread() :
-  m_osc("8889"),
+process_thread::process_thread(const string &port) :
+  m_osc(port),
   m_source_block_size(1000),
   m_source_overlap(0.75),
   m_target_block_size(1000),

app/process_thread.h

@@ -27,7 +27,7 @@ namespace spiralcore {
 
   class process_thread {
   public:
-    process_thread();
+    process_thread(const string &port);
     ~process_thread();
 
     pthread_mutex_t* m_brain_mutex;
@@ -47,6 +47,9 @@ public:
     void load_session(const std::string &filename);
     void save_session(const std::string &filename);
 
+
+    bool ok() { return m_osc.ok(); }
+
     // only for use in mutex
     brain m_source, m_left_target, m_right_target;
 

app/qtmain.cpp

@@ -19,22 +19,54 @@
 #include <iostream>
 #include <unistd.h>
 #include <QtGui>
+#include <QSettings>
+
 #include "MainWindow.h"
 
 #include "process_thread.h"
 #include "audio_thread.h"
+#include "status.h"
 
 using namespace std;
 
 int main( int argc , char *argv[] ){
-    QApplication app(argc, argv);
-    MainWindow mainWin;
-    mainWin.show();
-    process_thread pt;
-    audio_thread at(pt);
-    pt.register_renderer(at.m_left_renderer, at.m_right_renderer, at.m_block_stream);
 
+  
+  QApplication app(argc, argv);
+  
+  QSettings settings("thentrythis", "samplebrain");
+
+  // slight over-use of OSC servers here, but the are packaged nicely for
+  // threadsafe (nonblocking) communication, and it's useful to expose all
+  // moving parts for external control (i.e. the processing and the audio)
+  
+  if (!settings.contains("gui_port")) settings.setValue("gui_port", "62345");
+  if (!settings.contains("audio_port")) settings.setValue("audio_port", "62346");
+  if (!settings.contains("process_port")) settings.setValue("process_port", "62347");  
+
+  string gui_port = settings.value("gui_port").toByteArray().constData();  
+  string audio_port = settings.value("audio_port").toByteArray().constData();
+  string process_port = settings.value("process_port").toByteArray().constData();
+
+  status::set_port(gui_port);
+  
+  MainWindow mainWin(gui_port,audio_port,process_port);
+  mainWin.show();
+  process_thread pt(process_port);
+  audio_thread at(audio_port,pt);
+  
+  pt.register_renderer(at.m_left_renderer, at.m_right_renderer, at.m_block_stream);
   mainWin.set_audio_thread(&at);
 
+  if (!at.ok()) {
+    mainWin.message("problem starting audio thread on port "+audio_port);
+  }
+  if (!pt.ok()) {
+    mainWin.message("problem starting process thread on port "+process_port);
+  }
+  if (!mainWin.ok()) {
+    mainWin.message("problem starting gui thread on port "+gui_port);
+  }
+
   return app.exec();
 }

brain/src/spiralcore/OSC_server.cpp

@@ -33,39 +33,38 @@ extern "C" {
 OSC_server::OSC_server(const string &port) :
   m_port(port),
   m_exit(false),
-m_command_ring_buffer(262144)
-{
+  m_command_ring_buffer(262144) {
   //cerr<<"using port: ["<<port<<"]"<<endl;
   m_server = lo_server_thread_new(port.c_str(), error_handler);
+  if (m_server) {
+    cerr<<m_server<<endl;
     lo_server_thread_add_method(m_server, NULL, NULL, default_handler, this);
   }
+}
 
-OSC_server::~OSC_server()
-{
+OSC_server::~OSC_server() {
   m_exit=true;
   lo_server_thread_stop(m_server);
 }
 
-void OSC_server::run()
-{
+void OSC_server::run() {
+  if (!m_server) return;
   lo_server_thread_start(m_server);
   //    while (!m_exit) usleep(1000);
 }
 
-void OSC_server::error_handler(int num, const char *msg, const char *path)
-{
+void OSC_server::error_handler(int num, const char *msg, const char *path) {
   //cerr<<"liblo server error "<<num<<" in path "<<path<<": "<<msg<<endl;
   cerr<<"liblo server error "<<num<<endl;
 }
 
 int OSC_server::default_handler(const char *path, const char *types, lo_arg **argv,
-                    int argc, void *data, void *user_data)
-{
+                                int argc, void *data, void *user_data) {
   OSC_server *server = (OSC_server*)user_data;
+  if (!server) return -1;
 
   unsigned int size = 0;
-        for (int i=0; i<argc; i++)
-        {
+  for (int i=0; i<argc; i++) {
     size+=lo_arg_size((lo_type)types[i],argv[i]);
     // add one for the null terminator
     if (types[i]=='s') size++;
@@ -73,14 +72,10 @@ int OSC_server::default_handler(const char *path, const char *types, lo_arg **ar
 
   char *newdata=new char[size];
   unsigned int pos=0;
-        for (int i=0; i<argc; i++)
-        {
-                switch (types[i])
-                {
-                        case LO_INT32:
-                        {
-                                if (pos+4>COMMAND_DATA_SIZE)
-                                {
+  for (int i=0; i<argc; i++) {
+    switch (types[i]) {
+    case LO_INT32: {
+      if (pos+4>COMMAND_DATA_SIZE) {
         cerr<<"osc data too big for ringbuffer command"<<endl;
         delete[] newdata;
         return 1;
@@ -90,10 +85,8 @@ int OSC_server::default_handler(const char *path, const char *types, lo_arg **ar
       pos+=4;
     }
       break;
-                        case LO_FLOAT:
-                        {
-                                if (pos+4>COMMAND_DATA_SIZE)
-                                {
+    case LO_FLOAT: {
+      if (pos+4>COMMAND_DATA_SIZE) {
         cerr<<"osc data too big for ringbuffer command"<<endl;
         delete[] newdata;
         return 1;
@@ -103,12 +96,10 @@ int OSC_server::default_handler(const char *path, const char *types, lo_arg **ar
       pos+=4;
     }
       break;
-                        case LO_STRING:
-                        {
+    case LO_STRING: {
       int size=strlen(&argv[i]->s);
 
-                                if (pos+size+1>COMMAND_DATA_SIZE)
-                                {
+      if (pos+size+1>COMMAND_DATA_SIZE) {
         cerr<<"osc data too big for ringbuffer command"<<endl;
         delete[] newdata;
         return 1;
@@ -119,8 +110,7 @@ int OSC_server::default_handler(const char *path, const char *types, lo_arg **ar
       pos+=size+1;
     }
       break;
-                        default:
-                        {
+    default: {
       cerr<<"unsupported type: "<<types[i]<<endl;
       delete[] newdata;
       return 1;
@@ -129,16 +119,14 @@ int OSC_server::default_handler(const char *path, const char *types, lo_arg **ar
     }
   }
 
-        if (1)//pos==size) hmm
-        {
+  if (1) { //pos==size) hmm
+    
     command_ring_buffer::command command(path,types,newdata,pos);
-                if (!server->m_command_ring_buffer.send(command))
-                {
+    if (!server->m_command_ring_buffer.send(command))  {
       //cerr<<"OSC_server - ringbuffer full!"<<endl;
     }
   }
-        else
-        {
+  else {
     cerr<<"OSC_server::default_handler: size mismatch ["<<pos<<":"<<size<<"], not sending message"<<endl;
   }
 

brain/src/spiralcore/OSC_server.h

@@ -29,6 +29,7 @@ public:
   
   void run();
   bool get(command_ring_buffer::command& command) { return m_command_ring_buffer.get(command);}
+  bool ok() { return m_server!=NULL; }
   
 private:
   static int default_handler(const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data);

brain/src/status.cpp

@@ -22,6 +22,10 @@ using namespace std;
 
 lo_address status::m_address = lo_address_new_from_url("osc.udp://localhost:8890");
 
+void status::set_port(const std::string &port) {
+  status::m_address = lo_address_new_from_url(string("osc.udp://localhost:"+port).c_str());
+}
+
 void status::_update(const std::string &msg) {
     lo_send(m_address,"/report","s",msg.c_str());
 }

brain/src/status.h

@@ -24,6 +24,7 @@ namespace spiralcore {
 
 class status {
 public:
+  static void set_port(const std::string &port);
   static void _update(const std::string &msg);
   static void update(const char *msg, ...);
   static void sound_item(const std::string &name, const std::string &colour);