started making samplerate and buffer size configurable for audio device selection

app/audio_thread.cpp

@@ -26,7 +26,9 @@ audio_thread::audio_thread(process_thread &p) :
   m_process_thread(p),
   m_brain_mutex(p.m_brain_mutex),
   m_stereo_mode(false),
-  m_mic_mode(false)
+  m_mic_mode(false),
+  m_bufsize(2048),
+  m_samplerate(44100)
 {
   start_audio();
   pthread_mutex_lock(m_brain_mutex);
@@ -48,8 +50,7 @@ audio_thread::~audio_thread() {
 
 void audio_thread::start_audio() {
   if (m_audio_device!=NULL) delete m_audio_device;
-  m_audio_device = new audio_device("samplebrain",48000,2048);
+  m_audio_device = new audio_device("samplebrain",m_samplerate,m_bufsize);
-  //m_audio_device = new audio_device("samplebrain",48000,2048*4);
   m_audio_device->m_client.set_callback(run_audio, this);
 }
 

app/audio_thread.h

@@ -46,6 +46,8 @@ private:
     pthread_mutex_t* m_brain_mutex;
     bool m_stereo_mode;
     bool m_mic_mode;
+    u32 m_bufsize;
+    u32 m_samplerate;
   };
 
 }

app/process_thread.cpp

@@ -181,9 +181,6 @@ void process_thread::load_session(const std::string &filename) {
   ifs||m_source_block_size||m_source_overlap;
   ifs||m_target_block_size||m_target_overlap;
   ifs||m_window_type||m_target_window_type;
-
-  cerr<<"loading window type session "<<m_target_window_type<<endl;
-
   ifs||m_source;
   ifs||m_left_target;
   ifs||m_right_target;
@@ -200,9 +197,6 @@ void process_thread::save_session(const std::string &filename) {
   ofs||(*m_right_renderer);
   ofs||m_source_block_size||m_source_overlap;
   ofs||m_target_block_size||m_target_overlap;
-
-  cerr<<"saving window type session "<<m_target_window_type<<endl;
-
   ofs||m_window_type||m_target_window_type;
   ofs||m_source;
   ofs||m_left_target;

brain/src/block.cpp

@@ -77,7 +77,7 @@ block::block(u64 id, const string &filename, const sample &pcm, u32 rate, const
   m_orig_filename(filename),
   m_usage(0)
 {
-  init_fft(m_pcm.get_length());
+  init_fft(m_pcm.get_length(),rate);
   assert(m_mfcc_proc!=NULL);
   assert(m_fftw!=NULL);
 
@@ -97,12 +97,12 @@ block::block(u64 id, const string &filename, const sample &pcm, u32 rate, const
 }
 
 
-void block::init_fft(u32 block_size) {
+void block::init_fft(u32 block_size, u32 rate) {
   if (m_fftw == NULL || m_fftw->m_length!=block_size) {
     if (m_fftw == NULL) delete m_fftw;
-    m_fftw = new FFT(block_size,100);
+    m_fftw = new FFT(block_size,rate,100);
     if (m_mfcc_proc == NULL) delete m_mfcc_proc;
-    m_mfcc_proc = new Aquila::Mfcc(block_size);
+    m_mfcc_proc = new Aquila::Mfcc(block_size,rate);
   }
 }
 

brain/src/block.h

@@ -38,7 +38,7 @@ namespace spiralcore {
     // returns distance based on ratio of fft-mfcc values
     double compare(const block &other, const search_params &params) const;
 
-    static void init_fft(u32 block_size);
+    static void init_fft(u32 block_size, u32 rate);
     static bool unit_test();
 
     const sample &get_pcm() const { return m_pcm; }

brain/src/brain.cpp

@@ -377,34 +377,6 @@ void brain::deplete_usage() {
   }
 }
 
-
-// take another brain and rebuild this brain from bits of that one
-// (presumably this one is made from a single sample)
-/*void brain::resynth(const string &filename, const brain &other, const search_params &params){
-  sample out((m_block_size-m_overlap)*m_blocks.size());
-  out.zero();
-  u32 pos = 0;
-  u32 count = 0;
-  cerr<<other.m_blocks.size()<<" brain blocks..."<<endl;
-  cerr<<endl;
-  for (vector<block>::iterator i=m_blocks.begin(); i!=m_blocks.end(); ++i) {
-  cerr<<'\r';
-  cerr<<"searching: "<<count/float(m_blocks.size())*100;
-  u32 index = other.search(*i, params);
-  //cerr<<index<<endl;
-  out.mul_mix(other.get_block_pcm(index),pos,0.2);
-
-  if (count%1000==0) {
-  audio_device::save_sample(filename,out);
-  }
-
-  ++count;
-  pos += (m_block_size-m_overlap);
-  }
-  audio_device::save_sample(filename,out);
-  }
-*/
-
 ios &spiralcore::operator||(ios &s, brain::sound &b) {
   u32 version=1;
   string id("brain::sound");

brain/src/fft.cpp

@@ -24,8 +24,9 @@ using namespace std;
 
 static const int MAX_FFT_LENGTH = 4096;
 
-FFT::FFT(u32 length, u32 bins) :
+FFT::FFT(u32 length, u32 rate, u32 bins) :
   m_length(length),
+  m_rate(rate),
   m_num_bins(bins),
   m_in(new double[length]),
   m_spectrum(new fftw_complex[length]),
@@ -35,26 +36,19 @@ FFT::FFT(u32 length, u32 bins) :
   m_plan = fftw_plan_dft_r2c_1d(m_length, m_in, m_spectrum, FFTW_ESTIMATE);
 }
 
-FFT::~FFT()
+FFT::~FFT() {
-{
   delete[] m_in;
   fftw_destroy_plan(m_plan);
 }
 
-void FFT::impulse2freq(const float *imp)
+void FFT::impulse2freq(const float *imp) {
-{
   unsigned int i;
-
+  for (i=0; i<m_length; i++) {
-  for (i=0; i<m_length; i++)
-    {
     m_in[i] = imp[i];
   }
-
   fftw_execute(m_plan);
 }
 
-static const float SRATE = 44100;
-
 float FFT::calculate_dominant_freq() {
   double highest = 0;
   u32 index = 0;
@@ -65,7 +59,7 @@ float FFT::calculate_dominant_freq() {
       highest=t;
     }
   }
-  float freq = index * (SRATE/(float)m_length);
+  float freq = index * (m_rate/(float)m_length);
   if (freq<0.01) freq=0.01;
   return freq;
 }

brain/src/fft.h

@@ -27,7 +27,7 @@ namespace spiralcore {
   class FFT
   {
   public:
-    FFT(u32 length, u32 num_bins);
+    FFT(u32 length, u32 rate, u32 num_bins);
     ~FFT();
 	void impulse2freq(const float *imp);
     void calculate_bins();
@@ -35,6 +35,7 @@ namespace spiralcore {
 
 	fftw_plan m_plan;
 	u32 m_length;
+    u32 m_rate;
     u32 m_num_bins;
 	double *m_in;
 	fftw_complex *m_spectrum;

brain/src/mfcc.cpp

@@ -26,7 +26,7 @@ namespace Aquila
     {
         //auto spectrum = m_fft->fft(source);
 
-        Aquila::MelFilterBank bank(44100, m_inputSize);
+        Aquila::MelFilterBank bank(m_sampleRate, m_inputSize);
         auto filterOutput = bank.applyAll(spectrum);
 
         Aquila::Dct dct;

brain/src/mfcc.h

@@ -59,8 +59,9 @@ namespace Aquila
          *
          * @param inputSize input length (common to all inputs)
          */
-        Mfcc(std::size_t inputSize):
+        Mfcc(std::size_t inputSize, unsigned int sampleRate):
-        m_inputSize(inputSize)//, m_fft(FftFactory::getFft(inputSize))
+        m_inputSize(inputSize), // m_fft(FftFactory::getFft(inputSize))
+        m_sampleRate(sampleRate)
         {
         }
 
@@ -71,6 +72,7 @@ namespace Aquila
          * Number of samples in each processed input.
          */
         const std::size_t m_inputSize;
+        const unsigned int m_sampleRate;
         
         /**
          * FFT calculator.

brain/src/spiralcore/audio.cpp

@@ -27,7 +27,8 @@ audio_device::audio_device(const string &clientname, u32 samplerate, u32 buffer_
     left_in(buffer_size),
     right_in(buffer_size),
     m_recording(false),
-    m_record_filename("")
+    m_record_filename(""),
+    m_samplerate(samplerate)
 {
     portaudio_client::device_options opt;
     opt.buffer_size = buffer_size;
@@ -46,7 +47,7 @@ void audio_device::save_sample(const string &filename, const sample s) {
     SF_INFO sfinfo;
     sfinfo.format=SF_FORMAT_WAV | SF_FORMAT_FLOAT;
     sfinfo.frames=s.get_length();
-    sfinfo.samplerate=44100;
+    sfinfo.samplerate=m_samplerate;
     sfinfo.channels=1;
     sfinfo.sections=1;
     sfinfo.seekable=0;

brain/src/spiralcore/audio.h

@@ -42,7 +42,7 @@ public:
 
     portaudio_client m_client;
 
-    static void save_sample(const std::string &filename, const sample s);
+    void save_sample(const std::string &filename, const sample s);
 
   private:
     bool m_recording;
@@ -50,7 +50,7 @@ private:
     sample m_record_buffer_left;
     sample m_record_buffer_right;
     u32 m_record_counter;
-
+    u32 m_samplerate;
   };
 
 }

brain/src/spiralcore/portaudio_client.cpp

@@ -21,7 +21,6 @@
 
 bool              portaudio_client::m_attached   = false;
 long unsigned int portaudio_client::m_buffer_size = 0;
-long unsigned int portaudio_client::m_sample_rate = 44100;
 void            (*portaudio_client::run_callback)(void*, unsigned int buf_size)=NULL;
 void             *portaudio_client::run_context   = NULL;
 const float *portaudio_client::m_right_data=NULL;
@@ -42,6 +41,23 @@ portaudio_client::~portaudio_client() {
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
+vector<string> portaudio_client::sniff_devices() {
+  vector<string> ret;
+  int numDevices = Pa_GetDeviceCount();
+  if(numDevices < 0) {
+    // this is an error I guess
+    return ret;
+  } 
+  const   PaDeviceInfo *deviceInfo;
+  for(int i=0; i<numDevices; i++) {
+    deviceInfo = Pa_GetDeviceInfo(i);
+    ret.push_back(deviceInfo->name);
+  }
+  return ret;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+
 bool portaudio_client::attach(const string &client_name, const device_options &dopt) {
   if (m_attached) return true;
 

brain/src/spiralcore/portaudio_client.h

@@ -42,6 +42,7 @@ class portaudio_client
     unsigned int out_channels;
   };
 
+  vector<string> sniff_devices();
   bool   attach(const string &client_name, const device_options &dopt);
   void   detach();
   bool   is_attached()                   { return m_attached; }
@@ -60,7 +61,6 @@ class portaudio_client
  private:
 
   static long unsigned int  m_buffer_size;
-  static long unsigned int  m_sample_rate;
   static bool               m_attached;
 
   static const float *m_right_data;

brain/src/status.cpp

@@ -34,6 +34,10 @@ void status::sound_item_refresh() {
   lo_send(m_address,"/sound-item-refresh","");
 }
 
+void status::add_audio_device(const std::string &name) {
+  lo_send(m_address,"/add_audio_device",name.c_str());
+}
+
 void status::update(const char *msg, ...) {
     va_list args;
     va_start(args, msg);

brain/src/status.h

@@ -28,6 +28,7 @@ public:
   static void update(const char *msg, ...);
   static void sound_item(const std::string &name, const std::string &colour);
   static void sound_item_refresh();
+  static void add_audio_device(const std::string &name);
   static lo_address m_address;
 };