cwFlowProc.cpp : Implemented new voice stealing algorithm and

cwFlowProc.cpp

@@ -4418,6 +4418,15 @@ namespace cw
     //
     // Poly Voice Control
     //
+    // Don't forget this scenario:
+    // 1. msg i: note-on pitch 64 starts voice-x
+    // 2. voice x is stolen
+    // 3. msg j: note-on pitch 64 starts voice-y
+    // 4. note-off matching msg i turns off voice-y.
+    //
+    // This is a bug.  voice-y should continue to sound until the second note-off message is received.
+    // In practice this probably a rare sequence insofar as MIDI notes on the same channel and pitch tend not to overlap
+    // nonetheless we have to prevent it.
     namespace poly_voice_ctl
     {
       enum {
@@ -4433,21 +4442,31 @@ namespace cw
       
       typedef struct voice_str
       {
-        bool            noffFl;   // true if this voice has received a note-off
-        bool            activeFl; // true if this voice is currently active
-        unsigned        pitch;    // pitch associated with this voice
-        unsigned        age;      // age of this voice in exec() cycles.
+        bool     noffFl;        // true if this voice has received a note-off 
+        bool     activeFl;      // true if this voice is currently active      (between note-on and 'done' msg)
+        bool     earlyStopFl;   // true if this voice is in the process of being stopped early
+        unsigned pitch;         // pitch associated with this voice        
+        unsigned age;           // age of this voice in exec() cycles.
         
-        midi::ch_msg_t* msgA;     // msgA[ msgN ] msg buffer for this voice 
+        midi::ch_msg_t* msgA;     // msgA[ msgN ] msg buffer for this voice  - a voice may receive multiple MIDI msg's per cycle
         unsigned        msgN;     //
         unsigned        msg_idx;  // current count of msg's in msgA[]
 
         mbuf_t*         mbuf;      // cached mbuf for this output variable
       } voice_t;
+
+      typedef struct midi_note_str
+      {
+        unsigned cnt;          // incr'd on note-on, decr'd on note-off (voice only get's note-off msg if cnt==0 and voice!=nullptr)
+        unsigned voice_idx;    // voice assigned to this note or null if no voice is assigned to this note.
+        unsigned cycle_idx;    // BUG BUG BUG: see _reset_voice() below.
+      } midi_t;
       
       typedef struct
       {
         unsigned baseDoneFlPId;
+
+        midi_t midiA[ midi::kMidiNoteCnt ];
         
         unsigned voiceN;   // voiceA[ voiceN ]
         voice_t* voiceA; 
@@ -4457,6 +4476,7 @@ namespace cw
 
         unsigned  midi_fld_idx;
 
+        // note_state debugging related variables
         bool          ns_fl;
         note_state_t* nsV;
         unsigned      nsN;
@@ -4464,8 +4484,14 @@ namespace cw
       } inst_t;
 
 
+      // mark a voice as available
       void _reset_voice( proc_t* proc, inst_t* p, unsigned voice_idx )
       {
+        // BUG BUG BUG: don't clear midiA[].voice_idx if it was turned on earlier in this cycle
+
+        if( p->voiceA[voice_idx].pitch < midi::kMidiNoteCnt )
+          p->midiA[ p->voiceA[voice_idx].pitch ].voice_idx = kInvalidIdx;
+        
         p->voiceA[voice_idx].activeFl = false;
         p->voiceA[voice_idx].pitch = midi::kInvalidMidiPitch;
         
@@ -4526,6 +4552,12 @@ namespace cw
             goto errLabel;
         }
 
+        for(unsigned i=0; i<midi::kMidiNoteCnt; ++i)
+        {
+          p->midiA[i].cnt = 0;
+          p->midiA[i].voice_idx = kInvalidIdx;
+        }
+
         p->ns_fl = false;
         p->nsN = 500;
         p->nsV = mem::allocZ<note_state_t>(p->nsN);
@@ -4556,51 +4588,9 @@ namespace cw
       rc_t _notify( proc_t* proc, inst_t* p, variable_t* var )
       {
         rc_t rc = kOkRC;
-        /*
-        if( p->baseDoneFlPId <= var->vid && var->vid < p->baseDoneFlPId + p->voiceN )
-        {          
-          p->voiceA[ var->vid - p->baseDoneFlPId ].activeFl = false;
-        }
-        */
         return rc;
       }
 
-      unsigned _get_next_avail_voice( inst_t* p, unsigned pitch )
-      {
-        unsigned max_age_idx    = 0;
-        unsigned inactive_idx = kInvalidIdx;
-        unsigned same_pitch_idx = kInvalidIdx;
-        
-        for(unsigned i=0; i<p->voiceN; ++i)
-        {
-          // get the inactive channel
-          if( inactive_idx==kInvalidIdx && p->voiceA[i].activeFl == false )
-            inactive_idx = i;
-
-          // check for a re-attacking note
-          if( p->voiceA[i].activeFl && p->voiceA[i].pitch == pitch )
-            same_pitch_idx = i;
-                      
-          if( p->voiceA[i].age > p->voiceA[ max_age_idx].age )
-            max_age_idx = i;          
-          
-        }
-
-        // BUG BUG BUG
-        // Uncommenting this causes output from the transforms to stop after about 30 notes
-        
-        // Return the re-attacking voice index
-        //if( same_pitch_idx != kInvalidIdx )
-        //  return same_pitch_idx;
-        
-        if( inactive_idx != kInvalidIdx )
-          return inactive_idx;
-        
-        cwLogWarning("Stealing:%i",p->voiceA[max_age_idx].pitch );
-        return max_age_idx;
-      }
-      
-
       rc_t _update_voice_msg( proc_t* proc, inst_t* p, unsigned voice_idx, const midi::ch_msg_t* m )
       {
         rc_t     rc   = kOkRC;
@@ -4624,19 +4614,118 @@ namespace cw
         return rc;
       }
 
+      
+      rc_t _stop_note_early(proc_t* proc, inst_t* p, unsigned voice_idx )
+      {
+        midi::ch_msg_t m{};
+        m.status = midi::kNoteOffMdId;
+        m.d0 = p->voiceA[ voice_idx ].pitch;
+
+        p->voiceA[ voice_idx ].earlyStopFl = true;
+        
+        cwLogInfo("Early stop:%i",m.d0);
+        
+        return  _update_voice_msg(proc,p,voice_idx,&m);        
+      }
+
+      unsigned _get_next_avail_voice( proc_t* proc, inst_t* p, unsigned pitch )
+      {
+        unsigned next_voice_idx = kInvalidIdx;
+        unsigned max_age_idx    = 0;
+        unsigned inactive_idx   = kInvalidIdx;
+        unsigned same_pitch_idx = kInvalidIdx;
+        unsigned early_stop_idx = kInvalidIdx;
+        unsigned early_stop_cnt = 0;
+        unsigned active_voice_cnt = 0;
+
+        // examine all the voices
+        for(unsigned i=0; i<p->voiceN; ++i)
+        {
+          // get the inactive channel
+          if( inactive_idx==kInvalidIdx && p->voiceA[i].activeFl == false )
+            inactive_idx = i;
+
+          // if this voice is active
+          if( p->voiceA[i].activeFl )
+          {
+            active_voice_cnt += 1;
+
+            // check for a re-attacking note
+            if( p->voiceA[i].pitch == pitch )
+              same_pitch_idx = i;
+
+            // if this is the oldest active voice
+            if( p->voiceA[i].age > p->voiceA[ max_age_idx].age )
+            {
+              max_age_idx = i;
+              
+              // if this voice has already been marked for eary stopping 
+              if( p->voiceA[i].earlyStopFl )
+                early_stop_cnt += 1; // count the number of voices that are marked for early stopping
+              else
+                early_stop_idx = i;  // otherwise it is a candidate to stop early
+            }
+            
+          }
+
+        }
+
+        // BUG BUG BUG
+        // Uncommenting this causes output from the transforms to stop after about 30 notes
+        
+        // Return the re-attacking voice index
+        //if( same_pitch_idx != kInvalidIdx )
+        //  return same_pitch_idx;
+
+        
+        // if an inactive note was found
+        if( inactive_idx != kInvalidIdx )
+        {
+          next_voice_idx = inactive_idx;
+        }
+        else
+        {
+          cwLogWarning("All voices active!.");
+          next_voice_idx = max_age_idx;
+        }
+
+        // if more than half the voices are in use then begin turning off old voices
+        if( active_voice_cnt > p->voiceN/2 )
+          _stop_note_early(proc,p,early_stop_idx==kInvalidIdx ? max_age_idx : early_stop_idx );
+        
+        return next_voice_idx;
+      }
+      
+
       rc_t _on_note_on( proc_t* proc, inst_t* p, const midi::ch_msg_t* m  )
       {
         rc_t     rc         = kOkRC;
-        unsigned voice_idx  = _get_next_avail_voice(p,m->d0);
+        
+        assert( m->d0 < midi::kMidiNoteCnt );
+        
+        unsigned voice_idx = p->midiA[ m->d0 ].voice_idx;
+        
+        p->midiA[ m->d0 ].cnt += 1;
 
+        // if this note does not have a voice then get one
+        if( voice_idx == kInvalidIdx )
+        {
+          voice_idx  = _get_next_avail_voice(proc,p,m->d0);
+          
+          p->midiA[ m->d0 ].voice_idx = voice_idx;          
+
+        }
+        
         assert( voice_idx <= p->voiceN);
 
         voice_t* v = p->voiceA + voice_idx;
 
-        v->age      = 0;
-        v->activeFl = true;
-        v->noffFl   = false;
-        v->pitch    = m->d0;
+        v->age         = 0;
+        v->activeFl    = true;
+        v->noffFl      = false;
+        v->earlyStopFl = false;
+        v->pitch       = m->d0;
+
 
         //printf("v_idx:%i non\n",voice_idx);
 
@@ -4651,22 +4740,48 @@ namespace cw
       rc_t _on_note_off( proc_t* proc, inst_t* p, const midi::ch_msg_t* m )
       {
         rc_t     rc   = kOkRC;
-        for(unsigned i=0; i<p->voiceN; ++i)
-          if(p->voiceA[i].activeFl && p->voiceA[i].noffFl==false && p->voiceA[i].pitch==m->d0 )
+
+        // if this pitch does not have any assoc'd note-on's then there is nothing to do
+        if( p->midiA[ m->d0 ].cnt == 0 )
+        {
+          cwLogWarning("Extra note-off:%i.",m->d0);
+          goto errLabel;
+        }
+
+        // if this pitch is active then decr the cnt
+        if( p->midiA[ m->d0 ].cnt >= 1 )
+        {
+          p->midiA[ m->d0 ].cnt -= 1;
+        }
+
+        // if this pitch should be turned-off
+        if( p->midiA[ m->d0 ].cnt == 0 )
+        {
+
+          unsigned voice_idx = p->midiA[ m->d0 ].voice_idx;
+
+          if( voice_idx == kInvalidIdx )
+            cwLogWarning("Voice not found for note-off:%i.",m->d0);
+          else
           {
-            p->voiceA[i].noffFl = true;
+
+            voice_t* v = p->voiceA + voice_idx;
             
-            rc = _update_voice_msg(proc,p,i,m);
+            if(v->activeFl && v->noffFl==false && v->pitch==m->d0 )
+            {
+              v->noffFl = true;
+            
+              rc = _update_voice_msg(proc,p,voice_idx,m);
 
-            if( p->ns_fl )
-              _store_note_state( proc, p, m->uid, midi::kNoteOffMdId, m->d0, 0, i );
+              if( p->ns_fl )
+                _store_note_state( proc, p, m->uid, midi::kNoteOffMdId, m->d0, 0, voice_idx );
 
-            goto errLabel;
+              goto errLabel;
 
+            }
+          
           }
-        
-        cwLogWarning("Voice not found for note-off:%i.",m->d0);
-
+        }
       errLabel:
         return rc;
       }
@@ -4694,13 +4809,13 @@ namespace cw
         for(unsigned i=0; i<p->voiceN; ++i)
         {
           bool done_fl;
-          
+          // get the 'done_fl' for voice i
           var_get(proc,p->baseDoneFlPId+i,kAnyChIdx,done_fl);
 
           // notice notes that have transitioned from 'active' to 'inactive'
           if( p->voiceA[i].activeFl && done_fl )
           {
-            _reset_voice(proc,p,i);
+            _reset_voice(proc,p,i);            
           }
 
           // track the age of the voice
@@ -4720,10 +4835,10 @@ namespace cw
         // process the incoming MIDI messages
         for(unsigned i=0; i<rbuf->recdN; ++i)
         {
-          //const midi::ch_msg_t* m = mbuf->msgA + i;
           const recd_t* r = rbuf->recdA + i;
           const midi::ch_msg_t* m = nullptr;
 
+          // get the midi msg stored in the record
           if((rc = recd_get(rbuf->type,r,p->midi_fld_idx,m)) != kOkRC )
           {
             rc = cwLogError(rc,"Record 'midi' field read failed.");
@@ -4731,7 +4846,8 @@ namespace cw
           }
 
           //printf("0x%x %i %i\n",m->status,m->d0,m->d1);
-          
+
+          // dispatch the midi message
           switch( m->status )
           {
             case midi::kNoteOnMdId:

cwIo.cpp

@@ -9,6 +9,7 @@
 #include "cwText.h"
 #include "cwTextBuf.h"
 
+#include "cwThread.h"
 #include "cwIo.h"
 
 #include "cwMidi.h"
@@ -17,7 +18,6 @@
 
 #include "cwObject.h"
 
-#include "cwThread.h"
 #include "cwThreadMach.h"
 #include "cwMutex.h"
 
@@ -115,6 +115,18 @@ namespace cw
       unsigned sockA_index;
       unsigned userId;      
     } socket_t;
+    
+    typedef struct thread_once_str
+    {
+      struct io_str*          p;
+      thread::handle_t        threadH;
+      void*                   arg;
+      thread_once_func_t      cbFunc;
+      unsigned                id;
+      struct thread_once_str* link;
+      bool                    asyncFl;
+      bool                    doneFl;
+    } thread_once_t;
 
     typedef struct io_str
     {
@@ -175,6 +187,8 @@ namespace cw
       sample_t                      latency_meas_thresh_lin;
       bool                          latency_meas_enable_fl;
       latency_meas_result_t         latency_meas_result;
+
+      thread_once_t*                threadOnceList;
     } io_t;
   
 
@@ -270,7 +284,7 @@ namespace cw
     {
       rc_t        rc  = kOkRC;
       thread_t*    t  = (thread_t*)arg;
-      thread_msg_t tm = { .id=t->id, .arg=t->arg };
+      thread_msg_t tm = { .id=t->id, .arg=t->arg, .rc=kOkRC };
       msg_t        m;
 
       m.tid       = kThreadTId;
@@ -293,6 +307,62 @@ namespace cw
       }
     }
 
+    bool  _thread_once_func( void* arg )
+    {
+      rc_t           rc = kOkRC;
+      thread_once_t* t  = (thread_once_t*)arg;
+
+      rc = t->cbFunc(t->arg);
+
+      thread_msg_t tm = { .id=t->id, .arg=t->arg, .rc=rc };
+      msg_t        m;
+
+      m.tid      = kThreadTId;
+      m.u.thread = &tm;
+    
+      if((rc = _ioCallback( t->p, t->asyncFl, &m )) != kOkRC )
+        cwLogError(rc,"Thread app callback failed.");
+
+      t->doneFl = true;
+      
+      return false;
+    }
+
+    void _thread_once_cleanup(  io_t* p, bool force_clean_fl=false )
+    {
+      thread_once_t* t0 = nullptr;
+      thread_once_t* t = p->threadOnceList;
+      while( t != nullptr )
+      {
+        thread_once_t* t_next = t->link;
+        
+        if( t->doneFl || force_clean_fl )
+        {
+          thread_once_t* tt = t;
+          
+          // point the previous link around this link
+          if( t0 != nullptr )
+          {
+            t0->link = t_next;
+          }
+          else
+          { // first link is being removed
+            p->threadOnceList = t_next;
+          }
+
+          thread::destroy(tt->threadH);
+          mem::release(tt);
+
+        }
+        else
+        {
+          t0 = t;
+        }
+
+        t = t_next;
+      }
+    }
+
 
     //----------------------------------------------------------------------------------------------------------
     //
@@ -2334,6 +2404,9 @@ namespace cw
       if((rc = thread_mach::destroy(p->threadMachH)) != kOkRC )
         return rc;
 
+
+      _thread_once_cleanup(p,true);
+      
       for(unsigned i=0; i<p->timerN; ++i)
         mem::release(p->timerA[i].label);
       
@@ -2365,7 +2438,6 @@ namespace cw
         p->cfg->free();
 
       
-      
       mem::release(p);
 
       return rc;
@@ -2564,6 +2636,9 @@ cw::rc_t cw::io::exec( handle_t h, unsigned timeOutMs, void* execCbArg )
   if( p->audioMeterDevEnabledN ) 
     _audioDeviceProcessMeters(p);
 
+  if( p->threadOnceList != nullptr )
+    _thread_once_cleanup(p);
+  
   msg_t m;
   m.tid = kExecTId;
   m.u.exec.execArg = execCbArg;
@@ -2627,7 +2702,7 @@ cw::rc_t cw::io::threadCreate( handle_t h, unsigned id, bool asyncFl, void* arg,
 {
   rc_t      rc = kOkRC;
   io_t*     p  = _handleToPtr(h);
-  thread_t* t  = mem::allocZ<thread_t>(1);
+  thread_t* t  = mem::allocZ<thread_t>(1);  // BUG BUG BUG: where does this get released()
   
   t->id      = id;
   t->asyncFl = asyncFl;
@@ -2642,6 +2717,46 @@ cw::rc_t cw::io::threadCreate( handle_t h, unsigned id, bool asyncFl, void* arg,
   return rc;
 }
 
+cw::rc_t  cw::io::threadRunOnce( handle_t h, unsigned id, bool asyncFl, thread_once_func_t func, void* arg,  const char* thread_label )
+{
+  
+  rc_t      rc = kOkRC;
+  io_t*     p  = _handleToPtr(h);
+  thread_once_t* t = mem::allocZ<thread_once_t>();
+
+  t->p       = p;
+  t->arg     = arg;
+  t->cbFunc  = func;
+  t->asyncFl = asyncFl;
+  t->doneFl  = false;
+  t->id      = id;
+  t->link    = p->threadOnceList;
+  p->threadOnceList = t;
+
+  if((rc = thread::create(t->threadH,_thread_once_func,t,thread_label)) != kOkRC )
+  {
+    rc = cwLogError(rc,"One-time thread '%s' create failed.",cwStringNullGuard(thread_label));
+    goto errLabel;
+  }
+
+  sleepMs(10);
+
+  if((rc = thread::unpause(t->threadH)) != kOkRC )
+  {
+    rc = cwLogError(rc,"One-time '%s' thread start failed.",cwStringNullGuard(thread_label));
+    goto errLabel;
+  }
+  
+errLabel:
+  if( rc != kOkRC )
+  {
+    thread::destroy(t->threadH);
+    mem::release(t);
+  }
+  return rc;  
+}
+
+
 //----------------------------------------------------------------------------------------------------------
 //
 // Timer

cwIo.h

@@ -43,8 +43,9 @@ namespace cw
 
     typedef struct thread_msg_str
     {
-      unsigned id;
-      void*    arg;
+      unsigned id;  // user supplied thread id
+      void*    arg; // user supplied arg passed to threadRunOnce() thread func
+      rc_t     rc;  // rc returned from user supplied threadRunOncec() thread func
     } thread_msg_t;
     
     typedef struct timer_msg_str
@@ -186,6 +187,10 @@ namespace cw
     //
     rc_t  threadCreate(    handle_t h, unsigned id, bool asyncFl, void* arg, const char* label );
 
+    // Run 'func(arg)' in a thread and callback the app with a thread_msg_t when the func is complete.
+    typedef rc_t (*thread_once_func_t)(void* arg);
+    rc_t  threadRunOnce( handle_t h, unsigned id, bool asyncFl, thread_once_func_t func, void* arg, const char* thread_label );
+
     //----------------------------------------------------------------------------------------------------------
     //
     // Timer

cwThread.cpp

@@ -59,6 +59,11 @@ namespace cw
 
         if(curStateId == stateId )
           break;
+
+        if(curStateId == kExitedThId)
+        {
+          return cwLogError(kInvalidStateRC,"Cannot wait on an thread that has already exited.");          
+        }
         
         sleepUs( p->waitMicros );