Completed AvailCh DSP Object

Added state[] variable to XFader DSP object.
Completed _cmDspSysPgm_AvailCh() example program.

cmProc3.c

   {
     cmXfaderCh* cp = p->chArray + i;
 
+    cp->onFl  = false;
+    cp->offFl = false;
+
     if( chGateV != NULL )
+    {
+      cp->onFl =   chGateV[i] && !cp->gateFl;  // notice fade-in transition begin
       cp->gateFl = chGateV[i];
+    }
+    
+    cmReal_t g = cp->gain;
 
     if( cp->gateFl )
       cp->gain = cmMin(cp->gain + dgain,1.0); 
     else
+    {
       cp->gain = cmMax(cp->gain - dgain,0.0); 
+      cp->offFl = g>0.0 && cp->gain==0.0; // notice fade-out transition end
+    }
 
     if( cp->gain != 0.0 )
       gateFl = true;
+
   }
 
   p->onFl  = false;

cmProc3.h

   typedef struct
   {
     cmReal_t gain;
-    bool     gateFl;
+    bool     gateFl; // true if channel is on
+    bool     onFl;   // true if gateFl transitioned to true on this cycle  
+    bool     offFl;  // true if gateFl transitioned to false on this cycle
   } cmXfaderCh;
 
   typedef struct

dsp/cmDspFx.c

   cmXfader*    xfdp;
   unsigned     inBaseXfId;
   unsigned     outBaseXfId;
+  unsigned     stateBaseXfId;
   unsigned     gainBaseXfId;
   unsigned     chCnt;
   bool*        chGateV;
     { "chs",   kChCntXfId,      0, 0,               kUIntDsvFl   | kReqArgDsvFl, "Input and Output channel count"},
     { "ms",    kFadeTimeMsXfId, 0, 0,   kInDsvFl  | kDoubleDsvFl | kOptArgDsvFl, "Fade time in milliseonds."},
     { "mgate", kMstrGateXfId,   0, 0,   kInDsvFl  | kBoolDsvFl   | kOptArgDsvFl, "Master gate - can be used to set all gates."},
-    { "on",    kOnXfId,         0, 0,   kOutDsvFl | kSymDsvFl,                  "Send 'on' when all ch's transition from off to on."},
-    { "off",   kOffXfId,        0, 0,   kOutDsvFl | kSymDsvFl,                  "Send 'off' when all ch's transition from on to off."},
+    { "on",    kOnXfId,         0, 0,   kOutDsvFl | kSymDsvFl,                   "Send 'on' when all ch's transition from off to on."},
+    { "off",   kOffXfId,        0, 0,   kOutDsvFl | kSymDsvFl,                   "Send 'off' when all ch's transition from on to off."},
   };
 
   if( va_cnt < 1 )
   va_list vl1;
   va_copy(vl1,vl);
 
-  unsigned      chCnt     = va_arg(vl,int);
-  unsigned      fixArgCnt = sizeof(args)/sizeof(args[0]);
-  unsigned      argCnt    = fixArgCnt + 4*chCnt;
-  unsigned      inBaseXfId  = kGateBaseXfId + chCnt;
-  unsigned      outBaseXfId = inBaseXfId + chCnt;
-  unsigned      gainBaseXfId= outBaseXfId + chCnt;
+  unsigned chCnt         = va_arg(vl,int);
+  unsigned fixArgCnt     = sizeof(args)/sizeof(args[0]);
+  unsigned argCnt        = fixArgCnt + 5*chCnt;
+  unsigned inBaseXfId    = kGateBaseXfId + chCnt;
+  unsigned outBaseXfId   = inBaseXfId + chCnt;
+  unsigned stateBaseXfId = outBaseXfId + chCnt;
+  unsigned gainBaseXfId  = stateBaseXfId + chCnt;
   cmDspVarArg_t a[ argCnt+1 ];
   
 
   cmDspArgSetupN(ctx, a, argCnt, kGateBaseXfId, chCnt, "gate", kGateBaseXfId, 0, 0, kInDsvFl  | kBoolDsvFl,     "gate flags");
   cmDspArgSetupN(ctx, a, argCnt, inBaseXfId,    chCnt, "in",   inBaseXfId,    0, 0, kInDsvFl  | kAudioBufDsvFl, "audio input");
   cmDspArgSetupN(ctx, a, argCnt, outBaseXfId,   chCnt, "out",  outBaseXfId,   0, 1, kOutDsvFl | kAudioBufDsvFl, "audio output"); 
+  cmDspArgSetupN(ctx, a, argCnt, stateBaseXfId, chCnt, "state",stateBaseXfId, 0, 0, kOutDsvFl | kBoolDsvFl,     "current fader state"); 
   cmDspArgSetupN(ctx, a, argCnt, gainBaseXfId,  chCnt, "gain", gainBaseXfId,  0, 0, kOutDsvFl | kDoubleDsvFl,   "gain output"); 
   cmDspArgSetupNull( a+argCnt); // set terminating arg. flag
 
   p->xfdp           = cmXfaderAlloc(ctx->cmProcCtx,NULL,cmDspSampleRate(ctx), chCnt, fadeTimeMs);
   p->inBaseXfId     = inBaseXfId;
   p->outBaseXfId    = outBaseXfId;
+  p->stateBaseXfId  = stateBaseXfId;
   p->gainBaseXfId   = gainBaseXfId;
   p->chCnt          = chCnt;
   p->chGateV        = cmMemAllocZ(bool,p->chCnt);
   // set default values for the parameters that were not explicitely set in the va_arg list
   cmDspSetDefaultDouble( ctx, &p->inst, kFadeTimeMsXfId,  0,     100 );
   cmDspSetDefaultBool(   ctx, &p->inst, kMstrGateXfId,    false, false);
-  cmDspSetDefaultSymbol(   ctx, &p->inst, kOnXfId,    p->onSymId );
-  cmDspSetDefaultSymbol(   ctx, &p->inst, kOffXfId,   p->offSymId );  
+  cmDspSetDefaultSymbol( ctx, &p->inst, kOnXfId,    p->onSymId );
+  cmDspSetDefaultSymbol( ctx, &p->inst, kOffXfId,   p->offSymId );  
+
+  int i;
+  for(i=0; i<chCnt; ++i)
+    cmDspSetDefaultBool( ctx, &p->inst, stateBaseXfId+i, false, false );
+
   return &p->inst;
 }
 
         cmVOS_MultVVS(op,n,ip,gain);
     }
 
+    if( p->xfdp->chArray[i].onFl )
+      cmDspSetBool(ctx,inst,p->stateBaseXfId+i,true);
+
+    if( p->xfdp->chArray[i].offFl )
+      cmDspSetBool(ctx,inst,p->stateBaseXfId+i,false);
+
     // send the gain output
     cmDspSetDouble(ctx,inst,p->gainBaseXfId+i,gain);
   }
       break;
   }
   
-    
-
   // record gate changes into p->chGateV[] for later use in _cmDspXfaderExec().
   if( kGateBaseXfId <= evt->dstVarId && evt->dstVarId < kGateBaseXfId + p->chCnt )
   {
   cmDspGateToSym_t* p = cmDspInstAllocV(cmDspGateToSym_t,ctx,classPtr,instSymId,id,storeSymId,va_cnt,vl,
     1,     "on_sym", kOnSymGsId,   0, 0, kSymDsvFl    | kInDsvFl | kOptArgDsvFl,"'on' symbol id (default:'on')",
     1,     "off_sym",kOffSymGsId,  0, 0, kSymDsvFl    | kInDsvFl | kOptArgDsvFl,"'off' symbol id (default:'off')",
-    1,     "on",    kOnGsId,      0, 0, kBoolDsvFl   | kInDsvFl,    "On - send out 'on' symbol when a 'true' is received.",
-    1,     "off",   kOffGsId,     0, 0, kBoolDsvFl   | kInDsvFl,    "Off - send out 'off' symbol when a 'false' is received.",
-    1,     "both",  kBothGsId,    0, 0, kBoolDsvFl   | kInDsvFl,    "Send 'on' on 'true' and 'off' on 'false'.",
-    1,     "out",   kOutGsId,     0, 0, kSymDsvFl    | kOutDsvFl,   "Output",
+    1,     "on",    kOnGsId,       0, 0, kBoolDsvFl   | kInDsvFl,                "On - send out 'on' symbol when a 'true' is received.",
+    1,     "off",   kOffGsId,      0, 0, kBoolDsvFl   | kInDsvFl,                "Off - send out 'off' symbol when a 'false' is received.",
+    1,     "both",  kBothGsId,     0, 0, kBoolDsvFl   | kInDsvFl,                "Send 'on' on 'true' and 'off' on 'false'.",
+    1,     "out",   kOutGsId,      0, 0, kSymDsvFl    | kOutDsvFl,               "Output",
     0 );
 
 
 }
 
 //==========================================================================================================================================
+// Purpose: AvailCh can be used to implement a channel switching circuit.
+// 
+// Inputs:
+//   chs         - The count of channels. Constructor only argument. 
+//   trig        - Any input causes the next available channel, i, to be enabled.
+//                 gate[i] transmits 'true'.  In 'exclusive (0) mode all active
+//                 channels are then requested to shutdown by transmitting 'false' on
+//                 gate[] - only the new channel will be active.  In 'multi' (1) mode
+//                 no signal is sent out the gate[].
+//   dis[chCnt]  - Recieves a gate signal from an external object which indicates 
+//                 when a channel is no longer active. When a 'false' is received on dis[i]
+//                 the channel i is marked as available.  In 'multi' mode 'false' is 
+//                 then transmitted on gate[i].
+// Outputs:
+//   gate[chCnt] - 'true' is transmitted when a channel is made active (see trig)
+//                 'false' is transmitted to notify the channel that it should shutdown.
+//                 The channel is not considered actually shutdown until dis[i]
+//                 recieves a 'false'.
+// Notes:
+//   The gate[] output is designed to work with the gate[] input of Xfader.  When
+//   availCh.gate[] goes high Xfader fades in, when availCh.gate[] goes low
+//   Xfader fades out.  The dis[] channel is designed to connect from Xfader.state[].
+//   When Xfader.state[] goes low, when a fade-out is complete, the connected AvailCh 
+//   is marked as available. 
 enum
 {
   kChCntAvId,
+  kModeAvId,
   kTrigAvId,
   kChIdxAvId,  
-  kBaseInDisAvId,
+  kBaseDisInAvId,
+
+  kExclusiveModeAvId=0,
+  kMultiModeAvId=1
 };
 
 cmDspClass_t _cmAvailCh_DC;
 {
   cmDspInst_t   inst;
   unsigned      chCnt;
-  unsigned      baseOutEnaAvId; 
-  unsigned      baseInDisAvId;
-  unsigned      enableSymId;
-  unsigned      disableSymId;
+  unsigned      baseDisInAvId;
+  unsigned      baseGateOutAvId;
   bool*         stateArray;
 } cmDspAvailCh_t;
 
     return NULL;
   }
 
-  unsigned baseInDisAvId     = kBaseInDisAvId;
-  unsigned baseOutEnaAvId    = baseInDisAvId + chCnt;
+  unsigned baseDisInAvId    = kBaseDisInAvId;
+  unsigned baseGateOutAvId  = baseDisInAvId + chCnt;
 
   cmDspAvailCh_t* p = cmDspInstAllocV(cmDspAvailCh_t,ctx,classPtr,instSymId,id,storeSymId,va_cnt,vl1,
-    1,         "chs",    kChCntAvId,        0, 0, kUIntDsvFl     | kReqArgDsvFl,  "Channel count.",
-    1,         "trig",   kTrigAvId,         0, 0, kTypeDsvMask   | kInDsvFl,      "Trigger the unit to select the next available channel.", 
-    1,         "ch",     kChIdxAvId,        0, 0, kUIntDsvFl     | kReqArgDsvFl | kInDsvFl,    "Currently selected channel.",
-    chCnt,     "dis",    baseInDisAvId,     0, 0, kTypeDsvMask   | kInDsvFl,     "Disable inputs.",
-    chCnt,     "ena",    baseOutEnaAvId,    0, 0, kSymDsvFl      | kOutDsvFl,    "'enable' outputs",
+    1,         "chs",    kChCntAvId,        0, 0, kUIntDsvFl     | kReqArgDsvFl, "Channel count.",
+    1,         "mode",   kModeAvId,         0, 0, kUIntDsvFl     | kInDsvFl,     "Mode: 0=exclusive (dflt) 1=multi",
+    1,         "trig",   kTrigAvId,         0, 0, kTypeDsvMask   | kInDsvFl,     "Trigger the unit to select the next available channel.", 
+    1,         "ch",     kChIdxAvId,        0, 0, kUIntDsvFl     | kOutDsvFl,    "Currently selected channel.",
+    chCnt,     "dis",    baseDisInAvId,     0, 0, kBoolDsvFl     | kInDsvFl,     "Disable channel gate",
+    chCnt,     "gate",   baseGateOutAvId,   0, 0, kBoolDsvFl     | kOutDsvFl,    "Active channel gate",
     0 );
 
   p->chCnt     = chCnt;
 
-  p->baseInDisAvId   =  baseInDisAvId;
-  p->baseOutEnaAvId  =  baseOutEnaAvId;
-  p->enableSymId     =  cmSymTblRegisterStaticSymbol(ctx->stH,"enable");
-  p->disableSymId    =  cmSymTblRegisterStaticSymbol(ctx->stH,"disable");
+  p->baseDisInAvId   =  baseDisInAvId;
+  p->baseGateOutAvId =  baseGateOutAvId;
 
   unsigned i;
   for(i=0; i<chCnt; ++i)
-    cmDspSetDefaultSymbol( ctx, &p->inst, baseOutEnaAvId+i, p->disableSymId );
-
+  {
+    cmDspSetDefaultBool( ctx, &p->inst, baseDisInAvId+i,  false, false );
+    cmDspSetDefaultBool( ctx, &p->inst, baseGateOutAvId+i, false, false );
+  }
+  cmDspSetDefaultUInt( ctx, &p->inst, kModeAvId,  0, kExclusiveModeAvId );
   cmDspSetDefaultUInt( ctx, &p->inst, kChIdxAvId, 0, cmInvalidIdx );
+  
+  
 
   return &p->inst;
 }
   cmDspRC_t    rc = kOkDspRC;
   cmDspAvailCh_t* p  = (cmDspAvailCh_t*)inst;
 
+  bool exclModeFl  = cmDspUInt(inst, kModeAvId ) == kExclusiveModeAvId;
+
   // if this is a trigger
   if( evt->dstVarId == kTrigAvId )
   {
     unsigned i;
+    bool     fl = true;
     for(i=0; i<p->chCnt; ++i)
-      if( cmDspSymbol(inst,p->baseOutEnaAvId+i) == p->disableSymId )
+    {
+      // the actual channel's active state is held in the 'dis' variable.
+      bool activeFl = cmDspBool(inst,p->baseDisInAvId+i);
+
+      // if ch[i] is the first avail inactive channel
+      if( fl && !activeFl )
       {
         cmDspSetUInt(ctx,inst,kChIdxAvId,i);
-        cmDspSetSymbol(ctx,inst,p->baseOutEnaAvId,p->enableSymId);
+        cmDspSetBool(ctx, inst, p->baseDisInAvId   + i, true);
+        cmDspSetBool(ctx, inst, p->baseGateOutAvId + i, true);
+        fl = false;
       }
+
+      // if ch[i] is active - then request that it shutdown 
+      if( activeFl && exclModeFl)
+        cmDspSetBool(ctx, inst, p->baseGateOutAvId + i, false);
+
+    }
     return rc;
   }
 
   // if this is an incoming disable message.
-  if( p->baseInDisAvId <= evt->dstVarId && evt->dstVarId < p->baseInDisAvId+p->chCnt )
+  if( p->baseDisInAvId <= evt->dstVarId && evt->dstVarId < p->baseDisInAvId+p->chCnt && cmDsvGetBool(evt->valuePtr) == false)
   {
-    cmDspSetSymbol(ctx,inst,p->baseOutEnaAvId,p->disableSymId);
-    return rc;
+    cmDspSetEvent(ctx,inst,evt);
+    if( !exclModeFl )
+      cmDspSetBool(ctx, inst, p->baseGateOutAvId + (evt->dstVarId - p->baseDisInAvId), false);
   }
 
   return rc;

dsp/cmDspPgm.c

 
   const char*  fn    = "/home/kevin/media/audio/20110723-Kriesberg/Audio Files/Piano 3_01.wav";
   
-  cmDspInst_t* chk   = cmDspSysAllocInst(h,"Button", "Next",  2, kCheckDuiId, 0.0 );
+  cmDspInst_t* chk0   = cmDspSysAllocInst(h,"Button", "0",  2, kButtonDuiId, 0.0 );
+  //cmDspInst_t* chk1   = cmDspSysAllocInst(h,"Button", "1",  2, kCheckDuiId, 0.0 );
 
+  cmDspInst_t* achp  = cmDspSysAllocInst( h, "AvailCh", NULL, 1, xfadeChCnt );
   
   cmDspInst_t* sphp  =  cmDspSysAllocInst( h, "Phasor",    NULL,   2, cmDspSysSampleRate(h), frqHz );
   cmDspInst_t* swtp  =  cmDspSysAllocInst( h, "WaveTable", NULL,   2, ((int)cmDspSysSampleRate(h)), 4);
   cmDspInst_t* fphp  =  cmDspSysAllocInst( h, "Phasor",    NULL,   1, cmDspSysSampleRate(h) );
   cmDspInst_t* fwtp  =  cmDspSysAllocInst( h, "WaveTable", NULL,   5, ((int)cmDspSysSampleRate(h)), 1, fn, -1, 7000000 );
   cmDspInst_t* fad0  =  cmDspSysAllocInst( h, "Xfader",    NULL,   3, xfadeChCnt,  xfadeMs, xfadeInitFl ); 
-  cmDspInst_t* fad1  =  cmDspSysAllocInst( h, "Xfader",    NULL,   3, xfadeChCnt,  xfadeMs, xfadeInitFl );
+
+  cmDspInst_t*  prp  = cmDspSysAllocInst(      h, "Printer",  NULL, 1, ">" );
 
   cmDspInst_t* ao0p = cmDspSysAllocInst(h,"AudioOut",  NULL,   1, 0 );
   cmDspInst_t* ao1p = cmDspSysAllocInst(h,"AudioOut",  NULL,   1, 1 );
     
 
-  cmDspSysConnectAudio(h, sphp, "out", swtp, "phs" );
-  cmDspSysConnectAudio(h, swtp, "out", fad0, "in" ); 
-  cmDspSysConnectAudio(h, fad0, "out", ao0p, "in" );
-  cmDspSysConnectAudio(h, fphp, "out", fwtp, "phs" );
-  cmDspSysConnectAudio(h, fwtp, "out", fad1, "in" ); 
-  cmDspSysConnectAudio(h, fad1, "out", ao1p, "in" ); 
+  // phasor->sine->fad-0->aout
+  cmDspSysConnectAudio(h, sphp, "out",   swtp, "phs" );
+  cmDspSysConnectAudio(h, swtp, "out",   fad0, "in-0" ); 
+  cmDspSysConnectAudio(h, fad0, "out-0", ao0p, "in" );
+
+  // phasor->file->fad-1->aout
+  cmDspSysConnectAudio(h, fphp, "out",   fwtp, "phs" );
+  cmDspSysConnectAudio(h, fwtp, "out",   fad0, "in-1" ); 
+  cmDspSysConnectAudio(h, fad0, "out-1", ao1p, "in" ); 
+
+  //cmDspSysInstallCb(h, chk0, "out", fad0, "gate-0", NULL);
+  //cmDspSysInstallCb(h, chk1, "out", fad0, "gate-1", NULL);
+
+  cmDspSysInstallCb(h, chk0, "sym",     achp, "trig",   NULL);
+  cmDspSysInstallCb(h, achp, "gate-0",  fad0, "gate-0", NULL );
+  cmDspSysInstallCb(h, fad0, "state-0", achp, "dis-0",   NULL );
+
+  cmDspSysInstallCb(h, achp, "gate-1",  fad0, "gate-1", NULL );
+  cmDspSysInstallCb(h, fad0, "state-1", achp, "dis-1",   NULL );
+
+  cmDspSysInstallCb(h, fad0, "state-0", prp, "in", NULL);
 
   return kOkDspRC;