docs and warnings fixed

brain/src/block_stream.cpp

@@ -113,8 +113,9 @@ const block &block_stream::get_block(u32 index) const {
 
 //-----------------------------------------------------------
 
-void _run_worker(void *p) {
+void *_run_worker(void *p) {
   ((block_stream::worker *)p)->run();
+  return NULL;
 }
 
 block_stream::worker::worker(u32 id, window *w) :

brain/src/brain.cpp

@@ -53,7 +53,7 @@ void brain::load_sound(std::string filename, stereo_mode mode) {
       for(u32 i=0; i<sfinfo.frames; i++) {
 	s[i]=0;
 	// mix down stereo to mono
-	for(u32 j = 0; j < sfinfo.channels; j++) {
+	for(s32 j = 0; j < sfinfo.channels; j++) {
 	  s[i]+=temp[i*sfinfo.channels + j];
 	}
       }
@@ -135,7 +135,7 @@ void brain::chop_and_add(sound &s, u32 count, bool ditchpcm) {
     m_blocks.push_back(block(m_blocks.size(),s.m_filename,region,44100,m_window,ditchpcm));
     pos += (m_block_size-m_overlap);
 
-    // periodic progress update
+     // periodic progress update
     if (update_tick>update_period) {
       status::update("processing sample %d: %d%%",count,(int)(pos/(float)s.m_sample.get_length()*100));
       update_tick=0;
@@ -248,16 +248,16 @@ void brain::build_synapses_thresh(search_params &params, double thresh) {
     status::update("building synapses %d%%",(int)(outer_index/(float)brain_size*100));
     for (auto &j : m_blocks) {
       if (index!=outer_index) {
-	// collect connections that are under threshold in closeness
-	double diff = i.compare(j,params);
-	if (diff<err) {
-	  i.get_synapse().push_back(index);
-	}
+        // collect connections that are under threshold in closeness
+        double diff = i.compare(j,params);
+        if (diff<err) {
+          i.get_synapse().push_back(index);
+        }
       }
       ++index;
     }
     ++outer_index;
-  }
+  }  
 }
 
 void brain::build_synapses_fixed(search_params &params) {
@@ -267,8 +267,17 @@ void brain::build_synapses_fixed(search_params &params) {
   u32 num_synapses = NUM_FIXED_SYNAPSES;
   if (num_synapses>=m_blocks.size()) num_synapses=m_blocks.size()-1;
 
+  // need to stop the progress updates flooding osc
+  u32 update_period = 100;
+  u32 update_tick = 0;
+
   for (auto &i:m_blocks) {
-    status::update("building synapses %d%%",(int)(outer_index/(float)brain_size*100));
+    if (update_tick>update_period) {
+      status::update("building synapses %d%%",(int)(outer_index/(float)brain_size*100));     
+      update_tick=0;
+    }
+    update_tick++;
+ 
     u32 index = 0;
     vector<pair<u32,double>> collect;
 

brain/src/spiralcore/ring_buffer.cpp

@@ -27,48 +27,42 @@ ring_buffer::ring_buffer(unsigned int size):
   m_write_pos(0),
   m_size(size),
   m_size_mask(size-1),
-  m_buffer(NULL)
-{
+  m_buffer(NULL) {
   m_buffer = new char[m_size];
   memset(m_buffer,'Z',m_size);
 }
 
-ring_buffer::~ring_buffer()	
-{
+ring_buffer::~ring_buffer()	{
   delete[] m_buffer;
 }
 
-bool ring_buffer::write(char *src, unsigned int size)
-{
+bool ring_buffer::write(char *src, unsigned int size) {
   //cerr<<"write pos: "<<m_write_pos<<endl;
   unsigned int space=write_space();
 
-  if (space<size) 
-    {
-      cerr<<"ringbuffer ran out of space, needed: "<<size<<" have: "<<space<<endl;
-      return false;
-    }
+  if (space<size) {
+    //cerr<<"ringbuffer ran out of space, needed: "<<size<<" have: "<<space<<endl;
+    return false;
+  }
 	
-  if (size<m_size-m_write_pos)
-    {
-      //cerr<<"written to: "<<m_write_pos<<endl;
-      memcpy(&(m_buffer[m_write_pos]), src, size);
-      m_write_pos += size;
-      m_write_pos &= m_size_mask;
-    }
-  else // have to split data over boundary
-    {
-      unsigned int first = m_size-m_write_pos;
-      unsigned int second = (m_write_pos+size) & m_size_mask;
-		
-      memcpy(&(m_buffer[m_write_pos]), src, first);
-      m_write_pos += first;
-      m_write_pos &= m_size_mask;
-		
-      memcpy(&(m_buffer[m_write_pos]), &src[first], second);
-      m_write_pos += second;
-      m_write_pos &= m_size_mask;
-    }
+  if (size<m_size-m_write_pos) {
+    //cerr<<"written to: "<<m_write_pos<<endl;
+    memcpy(&(m_buffer[m_write_pos]), src, size);
+    m_write_pos += size;
+    m_write_pos &= m_size_mask;
+  } else {
+    // have to split data over boundary
+    unsigned int first = m_size-m_write_pos;
+    unsigned int second = (m_write_pos+size) & m_size_mask;
+    
+    memcpy(&(m_buffer[m_write_pos]), src, first);
+    m_write_pos += first;
+    m_write_pos &= m_size_mask;
+	
+    memcpy(&(m_buffer[m_write_pos]), &src[first], second);
+    m_write_pos += second;
+    m_write_pos &= m_size_mask;
+  }
 	
   return true;
 }
@@ -79,38 +73,34 @@ bool ring_buffer::read(char *dest, unsigned int size)
   unsigned int space=read_space();
   if (space==0 || size>m_size) return false;
 	
-  if (size<m_size-m_read_pos)
-    {
+  if (size<m_size-m_read_pos) {
       //cerr<<"reading from: "<<m_read_pos<<endl;
       memcpy(dest, &(m_buffer[m_read_pos]), size);
       m_read_pos += size;
       m_read_pos &= m_size_mask;
-    }
-  else // have to split data over boundary
-    {
-      unsigned int first = m_size-m_read_pos;
-      unsigned int second = (m_read_pos+size) & m_size_mask;
-		
-      memcpy(dest, &(m_buffer[m_read_pos]), first);
-      m_read_pos += first;
-      m_read_pos &= m_size_mask;
-		
-      memcpy(&dest[first], &(m_buffer[m_read_pos]), second);
-      m_read_pos += second;
-      m_read_pos &= m_size_mask;
-    }
+  } else {
+    // have to split data over boundary
+    unsigned int first = m_size-m_read_pos;
+    unsigned int second = (m_read_pos+size) & m_size_mask;
+    
+    memcpy(dest, &(m_buffer[m_read_pos]), first);
+    m_read_pos += first;
+    m_read_pos &= m_size_mask;
+	
+    memcpy(&dest[first], &(m_buffer[m_read_pos]), second);
+    m_read_pos += second;
+    m_read_pos &= m_size_mask;
+  }
 	
   return true;
 }
 
-void ring_buffer::dump()
-{
+void ring_buffer::dump() {
   for (unsigned int i=0; i<m_size; i++) cerr<<m_buffer[i];
   cerr<<endl;
 }
 
-unsigned int ring_buffer::write_space()
-{
+unsigned int ring_buffer::write_space() {
   unsigned int read = m_read_pos;
   unsigned int write = m_write_pos;
 	
@@ -119,8 +109,7 @@ unsigned int ring_buffer::write_space()
   return m_size - 1;
 }
 
-unsigned int ring_buffer::read_space()
-{
+unsigned int ring_buffer::read_space() {
   unsigned int read = m_read_pos;
   unsigned int write = m_write_pos;