libcm/dsp/cmDspPgmPPMain.c

#include "cmPrefix.h"
#include "cmGlobal.h"
#include "cmFloatTypes.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmLinkedHeap.h"
#include "cmFileSys.h"
#include "cmSymTbl.h"
#include "cmJson.h"
#include "cmText.h"
#include "cmPrefs.h"
#include "cmDspValue.h"
#include "cmMsgProtocol.h"
#include "cmThread.h"
#include "cmUdpPort.h"
#include "cmUdpNet.h"
#include "cmTime.h"
#include "cmAudioSys.h"
#include "cmProcObj.h"
#include "cmDspCtx.h"
#include "cmDspClass.h"
#include "cmDspSys.h"
#include "cmDspPgm.h"
#include "cmDspPgmPPMain.h"

#include "cmAudioFile.h"
#include "cmProcObj.h"
#include "cmProc.h"
#include "cmProc3.h"
#include "cmVectOpsTemplateMain.h"

#define COL_WIDTH (150)




cmDspInst_t** allocInstPtrArray( cmDspSysH_t h, unsigned cnt )
{ return cmLhAllocZ(cmDspSysLHeap(h),cmDspInst_t*,cnt); }


#define formLabel( h, lbl, i) cmTsPrintfH( cmDspSysLHeap(h), "%s-%i", lbl, i )



//=====================================================================================================================
cmDspInst_t*  _cmDspSys_PresetMgmt( cmDspSysH_t h, const cmChar_t* preLbl, unsigned presetGroupSymId )
{
  cmLHeapH_t   lhH       = cmDspSysLHeap(h);
  cmDspInst_t* preset    = cmDspSysAllocInst( h, "Preset", NULL, 1, presetGroupSymId );
  cmDspInst_t* presetLbl = cmDspSysAllocInst( h, "Text",   NULL,      2, "", "Preset Label" );
  cmDspInst_t* storeBtn  = cmDspSysAllocInst( h, "Button", cmTsPrintfH(lhH,"%s-store", preLbl),  2, kButtonDuiId, 0.0);
  cmDspInst_t* recallBtn = cmDspSysAllocInst( h, "Button", cmTsPrintfH(lhH,"%s-recall",preLbl),  2, kButtonDuiId, 0.0);
  cmDspInst_t* ptsStore = cmDspSysAllocInst(  h, "PortToSym", NULL, 1, "store" );
  cmDspInst_t* ptsRecall = cmDspSysAllocInst( h, "PortToSym", NULL, 1, "recall" );

  cmDspSysInstallCb(   h, presetLbl, "val", preset, "label",NULL);
  cmDspSysInstallCb(   h, storeBtn,  "out", ptsStore, "store", NULL );
  cmDspSysInstallCb(   h, recallBtn, "out", ptsRecall, "recall", NULL );
  cmDspSysInstallCb(   h, ptsStore,  "out", preset, "cmd", NULL );
  cmDspSysInstallCb(   h, ptsRecall, "out", preset, "cmd", NULL );


  return preset;
}
//=====================================================================================================================
typedef struct
{
  unsigned        circuitSymId;  // enable/disable symId

  cmDspInst_t**   aout;    // aout[ ctx->outChCnt ]
  const cmChar_t* aoutLbl; // "out" 
  
} cmDspPP_Circuit_t;

//=====================================================================================================================
typedef struct
{
  cmDspPP_Circuit_t c;
  
  cmDspInst_t** sfmt;
  cmDspInst_t** rmtr;
  cmDspInst_t** gmtr;
  
} cmDspPP_TestCircuit_t;


cmDspRC_t _cmDspPP_TestCircuitAlloc(
  cmDspSysH_t              h, 
  _cmDspPP_Ctx_t*          ctx,   
  cmDspPP_TestCircuit_t*   p,
  const cmChar_t*          title,
  const cmChar_t*          preLbl,
  cmDspInst_t*             selChk,
  cmDspInst_t**            ain,
  cmDspInst_t*             ptIn )
{
  cmDspRC_t rc;

  p->c.circuitSymId     = cmDspSysRegisterInstAttrSymbolStr(h,title);
  unsigned    presetGroupSymId = cmDspSysPresetRegisterGroup(h,title);
  _cmDspSys_PresetMgmt(h,preLbl,presetGroupSymId);
  cmDspSysNewColumn(h,COL_WIDTH);

  p->c.aout  = allocInstPtrArray(h, ctx->oChCnt);


  // make processors for each input channel
  cmDspInst_t** sfmt = cmDspSysAllocInstArray( h, ctx->iChCnt, "Sprintf", NULL,  NULL, 1, "gate-%i:");
  cmDspInst_t** rmtr = cmDspSysAllocInstArray( h, ctx->iChCnt, "Meter",   "RMS", NULL, 3, 0.0, 0.0, 1.0 );
  cmDspSysNewColumn(h,COL_WIDTH);
  cmDspInst_t** gmtr = cmDspSysAllocInstArray( h, ctx->iChCnt, "Meter",   "Gate",NULL, 3, 0.0, 0.0, 1.0 );


  // make processors for each output channel
  if( ctx->oChCnt )
    p->c.aout[0] = cmDspSysAllocInst( h, "AMix", NULL, 1, ctx->iChCnt );
  p->c.aoutLbl = "out";
  
  
  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  if( ctx->oChCnt )
    cmDspSysConnectAudioN11N(h, ain, "out", p->c.aout[0], "in", ctx->iChCnt );

  cmDspSysInstallCb1NN1(h, ptIn, "f-out", rmtr,    "in",   ctx->iChCnt );  // RMS input
  cmDspSysInstallCb1NN1(h, ptIn, "b-out", gmtr,    "in",   ctx->iChCnt );  // Gate input 
  cmDspSysInstallCb1NN1(h, ptIn, "b-out", sfmt,    "in-0", ctx->iChCnt );  // format string
  //cmDspSysInstallCbN111(h, p->sfmt, "out",   ctx->print, "in",   ctx->iChCnt);// print string
  
 errLabel:

  cmDspSysRemoveInstAttrSymbol(h,p->c.circuitSymId);

  return rc;
}

//=====================================================================================================================

typedef struct
{
  cmDspInst_t** tmop;
  cmDspInst_t** amop;
  cmDspInst_t** cf;
  cmDspInst_t** sg;
  cmDspInst_t** eq;
  cmDspInst_t** env;
  cmDspInst_t** rtr;
  cmDspInst_t** bts;
  cmDspInst_t*  mix; 
} cmDspSys_NShp_t;



cmDspSys_NShp_t*  _cmDspSys_NShpAlloc( cmDspSysH_t h, unsigned pgSymId, const cmChar_t* preLbl, unsigned chCnt, bool seqFl )
{
  cmDspRC_t       rc           = kOkDspRC;

  unsigned        secCnt       = 3;

  double          cntMin       = 1;
  double          cntMax       = secCnt;

  unsigned        sgShapeId    = 2;
  unsigned        sgOtCnt      = 5;

  double          cfMinHz      = 20.0;
  double          cfHz         = 500;
  double          cfAlpha      = 0.9;
  bool            cfFbFl       = true;
  bool            cfBypassFl   = false;

  double          adsrMaxMs    = 20000;
  double          adsrMinMs    = 0;
  double          adsrIncMs    = 1;
  double          adsrMaxLevel = 100.0;
  double          adsrSusLevel = 100.0;
  double          adsrMinLevel =   0.0;
  double          adsrIncLevel = 0.001;

  bool            eqBypassFl = false;
  unsigned        eqModeSymId = cmSymTblRegisterStaticSymbol(cmDspSysSymbolTable(h),"LP");
  double          eqF0hz      = 250;
  double          eqQ         = 1.0;
  double          eqFgain     = 1.0;
  
  bool            mtBypassFl = false;
  double          mtTimeScale= 1.0;
  double          mtFeedback = 0.5;

  double          multMin  = 0.0;
  double          multMax  = 100.0;
  double          multInc  = 0.01;
  double          offsMin  = 0.0;
  double          offsMax  = 100.0;
  double          offsInc  = 0.01;

  cmDspSys_NShp_t* p = cmLhAllocZ( cmDspSysLHeap(h),cmDspSys_NShp_t,1);

  cmDspInst_t** bts   = NULL;
  cmDspInst_t** rtr   = NULL;
  cmDspInst_t** cnt0  = NULL;
  cmDspInst_t** cnt1  = NULL;
  cmDspInst_t** cnt2  = NULL;
  cmDspInst_t** seq0  = NULL;
  cmDspInst_t** seq1  = NULL;
  cmDspInst_t** seq2  = NULL;


  cmDspSysNewColumn(h,COL_WIDTH);
  cmDspInst_t** sg   = p->sg  = cmDspSysAllocInstArray( h, chCnt, "SigGen",    NULL, NULL, 2, 1000.0, sgShapeId, 1.0, sgOtCnt  );
  cmDspInst_t** cf   = p->cf  = cmDspSysAllocInstArray( h, chCnt, "CombFilt",  NULL, NULL, 5, cfBypassFl, cfMinHz, cfFbFl, cfHz, cfAlpha );
  cmDspInst_t** eq   = p->eq  = cmDspSysAllocInstArray( h, chCnt, "BiQuadEq",  NULL, NULL, 5, eqBypassFl, eqModeSymId, eqF0hz, eqQ, eqFgain ); 
  cmDspInst_t** mt   =          cmDspSysAllocInstArray( h, chCnt, "MtDelay",   NULL, NULL, 9, mtBypassFl, mtTimeScale, mtFeedback,   20.0, 0.8,   15.0, 0.9,    12.0, 0.9 );  

  // adsr time/ampl scale/offset 
  cmDspInst_t** tmop = p->tmop= cmDspSysAllocInstArray(h,  chCnt, "ScalarOp",  NULL, NULL, 6, 2, "*", "in-0", 1.0, "in-1", 1.0 );
  cmDspInst_t** toop =          cmDspSysAllocInstArray(h,  chCnt, "ScalarOp",  NULL, NULL, 6, 2, "+", "in-0", 0.0, "in-1", 0.0 ); 
  cmDspInst_t** amop = p->amop= cmDspSysAllocInstArray(h,  chCnt, "ScalarOp",  NULL, NULL, 6, 2, "*", "in-0", 1.0, "in-1", 1.0 );
  cmDspInst_t** aoop =          cmDspSysAllocInstArray(h,  chCnt, "ScalarOp",  NULL, NULL, 6, 2, "+", "in-0", 0.0, "in-1", 0.0 ); 
  cmDspInst_t** env  = p->env = cmDspSysAllocInstArray( h, chCnt, "Adsr",      NULL, NULL, 2, true, adsrMinLevel );
  cmDspInst_t** d2l  =          cmDspSysAllocInstArray( h, chCnt, "DbToLin",   NULL, NULL, 0 );

  if( seqFl )
  {
    bts   = p->bts = cmDspSysAllocInstArray(   h, chCnt, "GateToSym",NULL, NULL, 0 );
    rtr   = p->rtr = cmDspSysAllocInstArray(   h, chCnt, "Router",   NULL, NULL, 2, secCnt, 0 );
    cnt0  =          cmDspSysAllocInstArray(   h, chCnt, "Counter",  NULL, NULL, 3, cntMin, cntMax, 1.0 );
    cnt1  =          cmDspSysAllocInstArray(   h, chCnt, "Counter",  NULL, NULL, 3, cntMin, cntMax, 1.0 );
    cnt2  =          cmDspSysAllocInstArray(   h, chCnt, "Counter",  NULL, NULL, 3, cntMin, cntMax, 1.0 );
    seq0  =          cmDspSysAllocInstArray(   h, chCnt, "MsgList",  NULL, NULL, 1, "ns_seq0");
    seq1  =          cmDspSysAllocInstArray(   h, chCnt, "MsgList",  NULL, NULL, 1, "ns_seq1");
    seq2  =          cmDspSysAllocInstArray(   h, chCnt, "MsgList",  NULL, NULL, 1, "ns_seq2");
  }

  // output mixer
  cmDspInst_t* mix    = p->mix = cmDspSysAllocInst( h, "AMix", NULL, 2, chCnt, 0.0 );

  // comb filter parameters
  cmDspSysNewColumn(h,COL_WIDTH);
  cmDspInst_t* alpha  = cmDspSysAllocScalarP(   h, pgSymId, preLbl, "alpha", -1.0, 1.0, 0.001, cfAlpha );

  // time/amp scale multiply and offset controls
  cmDspInst_t* tmul   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Time Mult",  multMin,   multMax,   multInc, 1.0);
  cmDspInst_t* toff   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Time Offs",  offsMin,   offsMax,   offsInc, 0.0);
  cmDspInst_t* amul   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Ampl Mult",  multMin,   multMax,   multInc, 1.0);
  cmDspInst_t* aoff   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Ampl Offs",  offsMin,   offsMax,   offsInc, 0.0);
 
  // ADSR parameters
  cmDspInst_t* dly   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Dly Ms",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 0.0);
  cmDspInst_t* atk   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Atk Ms",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 5000.0);
  cmDspInst_t* dcy   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Dcy Ms",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 100.0);
  cmDspInst_t* hold  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Hold Ms", adsrMinMs,   adsrMaxMs,   adsrIncMs, 100.0);
  cmDspInst_t* rls   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Rls Ms",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 9000.0);
  cmDspInst_t* alvl  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "AdsrMax", adsrMinLevel,adsrMaxLevel,adsrIncLevel, adsrMaxLevel);  
  cmDspInst_t* sus   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Sustain", adsrMinLevel,adsrMaxLevel,adsrIncLevel, adsrSusLevel );  

  cmDspSysNewColumn(h,COL_WIDTH);
  cmDspInst_t* eqbyp   = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "Eq Byp", 0 );
  cmDspInst_t* eqmode  = cmDspSysAllocMsgListP(h, pgSymId, preLbl, "Mode", NULL, "biQuadEqMode", 1);
  cmDspInst_t* eqq     = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Q",          -100.0, 100.0, 0.1, eqQ);
  cmDspInst_t* eqfgn   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Filt Gain",   0.0,     1.0, 0.1, eqFgain);

  cmDspInst_t* mtfb   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Mt Feedback",   0.0,     1.0, 0.01, mtFeedback);
  cmDspInst_t* mtscale= cmDspSysAllocScalarP( h, pgSymId, preLbl, "Mt Time Scale", 0.01,   10.0, 0.01, mtTimeScale);

  cmDspInst_t* sgsh   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Sg Shape",   0.0,     8.0, 1.0, ((double)sgShapeId));
  cmDspInst_t* sgot   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Sg OT Cnt",  0.0,    10.0, 1.0, ((double)sgOtCnt));

  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  cmDspSysConnectAudioN1N1( h, sg,  "out",  cf,  "in",   chCnt );  // sg  -> CF
  cmDspSysConnectAudioN1N1( h, cf,  "out",  eq,  "in",   chCnt );  // CF -> EQ
  cmDspSysConnectAudioN1N1( h, eq,  "out",  mt,  "in",   chCnt );  // EQ -> MT
  cmDspSysConnectAudioN11N( h, mt,  "out",  mix, "in",   chCnt );  // MT  -> mix

  cmDspSysInstallCb11N1(    h, tmul, "val", tmop, "in-1",   chCnt );
  cmDspSysInstallCb11N1(    h, toff, "val", toop, "in-1",   chCnt );
  cmDspSysInstallCbN1N1(    h, tmop, "out", toop, "in-0",   chCnt );
  cmDspSysInstallCbN1N1(    h, toop, "out", env,  "tscale", chCnt );

  cmDspSysInstallCb11N1(    h, amul, "val", amop, "in-1",   chCnt );
  cmDspSysInstallCb11N1(    h, aoff, "val", aoop, "in-1",   chCnt );
  cmDspSysInstallCbN1N1(    h, amop, "out", aoop, "in-0",   chCnt );
  cmDspSysInstallCbN1N1(    h, aoop, "out", env,  "ascale", chCnt );

  cmDspSysInstallCbN1N1(   h, env,   "out",  d2l,  "in",   chCnt );   // adsr -> dbtolin
  cmDspSysInstallCbN11N(   h, d2l,   "out",  mix,  "gain", chCnt );   // db2lin -> mix (gain)

  cmDspSysInstallCbN1N1(   h, env,   "out",  d2l,  "in",    chCnt );
  cmDspSysInstallCbN11N(   h, d2l,   "out",  mix,  "gain",  chCnt ); 
  cmDspSysInstallCb11N1(   h, alpha, "val",  cf,   "alpha", chCnt );  // CF alpha

  cmDspSysInstallCb11N1( h, sgsh,  "val",  sg,   "shape",  chCnt );
  cmDspSysInstallCb11N1( h, sgot,  "val",  sg,   "ot",     chCnt );

  cmDspSysInstallCb11N1( h, dly,  "val", env, "dly",  chCnt );
  cmDspSysInstallCb11N1( h, atk,  "val", env, "atk",  chCnt );
  cmDspSysInstallCb11N1( h, dcy,  "val", env, "dcy",  chCnt );
  cmDspSysInstallCb11N1( h, hold, "val", env, "hold", chCnt );
  cmDspSysInstallCb11N1( h, rls,  "val", env, "rls",  chCnt );
  cmDspSysInstallCb11N1( h, alvl, "val", env, "alvl", chCnt );
  cmDspSysInstallCb11N1( h, sus,  "val", env, "sus",  chCnt );


  cmDspSysInstallCb11N1(   h, eqbyp,  "out",  eq,    "bypass", chCnt );
  cmDspSysInstallCb11N1(   h, eqmode, "mode", eq,    "mode",   chCnt );
  cmDspSysInstallCb11N1(   h, eqq,    "val",  eq,    "Q",      chCnt );
  cmDspSysInstallCb11N1(   h, eqfgn,  "val",  eq,    "gain",   chCnt );

  cmDspSysInstallCb11N1(   h, mtfb,   "val",  mt,    "fb",      chCnt );
  cmDspSysInstallCb11N1(   h, mtscale,"val",  mt,    "scale",   chCnt );


  if( seqFl )
  {
    cmDspSysInstallCbN1N1( h, bts, "out",     rtr,  "s-in",   chCnt );
    cmDspSysInstallCbN1N1( h, rtr, "s-out-0", cnt0, "next", chCnt );
    cmDspSysInstallCbN1N1( h, rtr, "s-out-1", cnt1, "next", chCnt );
    cmDspSysInstallCbN1N1( h, rtr, "s-out-2", cnt2, "next", chCnt );

    cmDspSysInstallCbN1N1(h, seq0, "cnt",  cnt0, "max",  chCnt );
    cmDspSysInstallCbN1N1(h, seq1, "cnt",  cnt1, "max",  chCnt );
    cmDspSysInstallCbN1N1(h, seq2, "cnt",  cnt2, "max",  chCnt );

    cmDspSysInstallCbN1N1(h, cnt0, "out",  seq0, "sel",  chCnt );
    cmDspSysInstallCbN1N1(h, cnt1, "out",  seq1, "sel",  chCnt );
    cmDspSysInstallCbN1N1(h, cnt2, "out",  seq2, "sel",  chCnt );

    cmDspSysInstallCbN1N1(h, seq0, "hz",  cf, "hz",  chCnt );
    cmDspSysInstallCbN1N1(h, seq1, "hz",  cf, "hz",  chCnt );
    cmDspSysInstallCbN1N1(h, seq2, "hz",  cf, "hz",  chCnt );

    cmDspSysInstallCbN1N1(h, seq0, "hz",  eq, "f0",  chCnt );
    cmDspSysInstallCbN1N1(h, seq1, "hz",  eq, "f0",  chCnt );
    cmDspSysInstallCbN1N1(h, seq2, "hz",  eq, "f0",  chCnt );

    cmDspSysInstallCbN1N1(h, seq0, "hz",  sg, "hz",  chCnt );
    cmDspSysInstallCbN1N1(h, seq1, "hz",  sg, "hz",  chCnt );
    cmDspSysInstallCbN1N1(h, seq2, "hz",  sg, "hz",  chCnt );
  }


 errLabel:
  if(cmDspSysLastRC(h) != kOkDspRC )
    p = NULL;

  return p;

}



typedef struct 
{
  cmDspPP_Circuit_t c;
  cmDspSys_NShp_t*  ns0p;
  cmDspSys_NShp_t*  ns1p;
} cmDspPP_NSh_Circuit_t;


cmDspRC_t _cmDspPP_NoiseShaperAlloc(
  cmDspSysH_t              h, 
  cmErr_t*                 err,
  cmDspPP_NSh_Circuit_t*   p,
  const cmChar_t*          title,
  const cmChar_t*          preLbl,
  cmDspInst_t*             selChk,
  cmDspInst_t*             ptIn,
  unsigned                 iChCnt,
  unsigned                 oChCnt)
{
  cmDspRC_t       rc             = kOkDspRC;
  double          secCnt         = 3;
  unsigned        nsCnt          = 0;
  unsigned        nsCnt1         = 0;
  const cmChar_t* nsPitchRsrcStr = "nsMidi";
  const cmChar_t* nsChIdxRsrcStr = "nsSelCh";

  // get the active channel list (indexes of the input channels which will be used by the noise shaper);
  if( cmDspRsrcArrayCount( h, &nsCnt1, nsChIdxRsrcStr, NULL ) != kOkDspRC )
    return cmErrMsg(err,kPgmCfgFailDspRC,"The noise shaper channel index list '%s' could not be read.",cmStringNullGuard(nsChIdxRsrcStr));

  // get the pitches associated with each active channel
  if( cmDspRsrcArrayCount( h, &nsCnt, nsPitchRsrcStr, NULL ) != kOkDspRC )
    return cmErrMsg(err,kPgmCfgFailDspRC,"The noise shaper pitch list '%s' could not be read.",cmStringNullGuard(nsPitchRsrcStr));

  // the channel and pitch list must contain the same number of elements
  assert( nsCnt1 == nsCnt );

  p->c.circuitSymId =  cmDspSysRegisterInstAttrSymbolStr(h,title);
  unsigned       presetGrpSymId = cmDspSysPresetRegisterGroup(h,title);
  _cmDspSys_PresetMgmt(h,preLbl,presetGrpSymId);
  cmDspSysNewColumn(h,COL_WIDTH);
  
  //cmDspInst_t* printBtn  = cmDspSysAllocInst( h, "Button", "_print",  2, kButtonDuiId, 0.0);
  //cmDspInst_t* bcast     = cmDspSysAllocInst( h, "BcastSym",   NULL,  1, p->c.circuitSymId );
  //cmDspSysInstallCb( h, printBtn, "sym", bcast, "msg", NULL );

  p->c.aout  = allocInstPtrArray(h,oChCnt);

  // nom - selects active channels from among all possible input channels - coming from the EF's
  cmDspInst_t* nom = cmDspSysAllocInst( h, "NofM", NULL, 2, iChCnt, nsCnt );  // EF's -> Nsh switch
 
  // Allocate the noise shapers
  p->ns0p = _cmDspSys_NShpAlloc( h, presetGrpSymId, "f", nsCnt, false ); 
  p->ns1p = _cmDspSys_NShpAlloc( h, presetGrpSymId, "s", nsCnt, true );

  cmDspSysNewColumn(h,COL_WIDTH);
  cmDspInst_t*  sectn  = cmDspSysAllocScalar(    h, "Section",  0, secCnt-1, 1.0, 0.0);
  cmDspInst_t*  pts    = cmDspSysAllocInst(      h, "PortToSym", NULL, 2, "off", "send" );
  cmDspInst_t*  pitarr = cmDspSysAllocInst(      h, "Array", NULL, 1, nsPitchRsrcStr );
  cmDspInst_t*  charr  = cmDspSysAllocInst(      h, "Array", NULL, 1, nsChIdxRsrcStr );
  cmDspInst_t** eqpc   = cmDspSysAllocInstArray( h, nsCnt, "PitchCvt", NULL, NULL, 0 );
  cmDspInst_t** cfpc   = cmDspSysAllocInstArray( h, nsCnt, "PitchCvt", NULL, NULL, 0 );
  cmDspInst_t** sgpc   = cmDspSysAllocInstArray( h, nsCnt, "PitchCvt", NULL, NULL, 0 );

  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  assert( oChCnt >= 2 );

  // put the 'f' noise in ch:0 and the 's' noise in ch:1
  p->c.aoutLbl = "out";
  p->c.aout[1] = p->ns0p->mix;
  p->c.aout[0] = p->ns1p->mix;


  // selChk is the circuit selector check box in the main window
  cmDspSysInstallCb(       h, selChk, "out",      pts,    "off",  NULL );  // First send 'off' to nom to clear its selector
  cmDspSysInstallCb(       h, selChk, "out",      pts,    "send", NULL );  // Second send 'send' to charr to select active ports on nom.
  cmDspSysInstallCb(       h, pts,    "off",      nom,    "cmd",  NULL );  // Clear the nom (all inputs are turned off)
  cmDspSysInstallCb(       h, pts,    "send",     charr,  "cmd",  NULL );  // Send the active channel indexes to the nom
  cmDspSysInstallCb(       h, pts,    "send",     pitarr, "cmd",  NULL );  // Send the pitch values to the circuits (eq,cf,sg,..)
  cmDspSysInstallCb(       h, charr,  "done",     nom,    "cmd",  NULL );  // Tell the nom when its setup is complete

  cmDspSysInstallCb1N11(   h, charr,  "out",      nom,    "seli", nsCnt );   // EF nom channel index selectors 
  cmDspSysInstallCb1N1N(   h, ptIn,   "b-out",    nom,    "b-in", iChCnt );  // EF -> nom (gates)
  cmDspSysInstallCb1N1N(   h, ptIn,   "f-out",    nom,    "f-in", iChCnt );  // EF -> nom (rms)


  cmDspSysInstallCb1NN1(   h, pitarr, "out",      cfpc,   "midi", nsCnt );   // pitch array -> pitch converter
  cmDspSysInstallCb1NN1(   h, pitarr, "out",      eqpc,   "midi", nsCnt );   
  cmDspSysInstallCb1NN1(   h, pitarr, "out",      sgpc,   "midi", nsCnt );

  cmDspSysInstallCbN1N1(   h, cfpc,   "hz",    p->ns0p->cf,   "hz",   nsCnt );   // pitch cvt -> CF (Hz)
  cmDspSysInstallCbN1N1(   h, eqpc,   "hz",    p->ns0p->eq,   "f0",   nsCnt );   // pitch cvt -> Eq (Hz)
  cmDspSysInstallCbN1N1(   h, sgpc,   "hz",    p->ns0p->sg,   "hz",   nsCnt );   // pitch cvt -> SG (Hz)

  cmDspSysInstallCb1NN1(   h, nom,   "b-out",  p->ns0p->env,  "gate", nsCnt );   // EF  -> adsr  (gate)
  cmDspSysInstallCb1NN1(   h, nom,   "b-out",  p->ns1p->env,  "gate", nsCnt );   // 


  cmDspSysInstallCb1NN1(   h, nom,   "f-out",  p->ns0p->tmop,  "in-0",  nsCnt );   // EF (level) -> adsr time scale
  cmDspSysInstallCb1NN1(   h, nom,   "f-out",  p->ns0p->amop,  "in-0",  nsCnt );   // EF (level) -> adsr ampl scale
  cmDspSysInstallCb1NN1(   h, nom,   "f-out",  p->ns1p->tmop,  "in-0",  nsCnt );   // EF (level) -> adsr time scale
  cmDspSysInstallCb1NN1(   h, nom,   "f-out",  p->ns1p->amop,  "in-0",  nsCnt );   // EF (level) -> adsr ampl scale

  cmDspSysInstallCb11N1(   h, sectn, "val",    p->ns1p->rtr,  "sel",  nsCnt );   // section scalar -> rtr sel input
  cmDspSysInstallCb1NN1(   h, nom,   "b-out",  p->ns1p->bts,  "on",   nsCnt );   // nom gate -> bool-to-sym -> rtr input 

 errLabel:

  cmDspSysRemoveInstAttrSymbol(h,p->c.circuitSymId);
  return rc;
}



//=====================================================================================================================
typedef struct
{
  cmDspInst_t*  start;   // circ. sel check -> start  
  cmDspInst_t** tmop;    // level -> time scale input
  cmDspInst_t** amop;    // level -> ampl scale input
  cmDspInst_t** adsr;    // gate  -> adsr input
  cmDspInst_t** mix;     // audio -> input mixer
  cmDspInst_t** ps;      // pitch shifter
  cmDspInst_t** eq;
  cmDspInst_t** mt;      // output prior to the mixer
  cmDspInst_t*  mixo;    // output mixer -> aout
} cmDspFx0_Chain_t;


cmDspRC_t _cmDspFx0_ChainAlloc( 
  cmDspSysH_t       h, 
  cmErr_t*          err,
  unsigned          pgSymId, 
  const cmChar_t*   preLbl, 
  const cmChar_t*   rsrc,
  unsigned          chainChCnt, 
  cmDspFx0_Chain_t* p )
{
  cmDspRC_t       rc           = kOkDspRC;

  double          multMin  = 0.0;
  double          multMax  = 100.0;
  double          multInc  = 0.01;
  double          offsMin  = 0.0;
  double          offsMax  = 100.0;
  double          offsInc  = 0.01;

  double          adsrMaxMs    = 20000;
  double          adsrMinMs    = 0;
  double          adsrIncMs    = 1;
  double          adsrMaxLevel = 100.0;
  double          adsrSusLevel = 100.0;
  double          adsrMinLevel =   0.0;
  double          adsrIncLevel = 0.001;

  unsigned        sgShapeId    = 2;
  unsigned        sgOtCnt      = 5;

  bool            lpBypassFl   = true;

  bool            cmpBypassFl  = false;
  double          cmpInGain     = 1.0;
  double          cmpThreshDb  = -40.0;
  double          cmpRatio_num = 4.0;
  double          cmpAtkMs     = 15.0;
  double          cmpRlsMs     = 50.0;
  double          cmpMakeup    = 4.0;
  double          cmpWndMaxMs  = 1000.0;
  double          cmpWndMs     = 200.0;
  double          cmpMaxGain   = 100.0;

  bool            distBypassFl   = false;
  double          distInGain     = 4.0;
  double          distDsrate     = 44100.0;
  double          distBits       = 24.0;
  bool            distRectifyFl  = false;
  bool            distFullRectFl = false;
  double          distClipDb     = -10.0;

  double          cfMinHz      = 20.0;
  double          cfHz         = 500;
  double          cfAlpha      = 0.9;
  bool            cfFbFl       = true;
  bool            cfBypassFl   = true;

  bool            eqBypassFl   = false;
  unsigned        eqModeSymId  = cmSymTblRegisterStaticSymbol(cmDspSysSymbolTable(h),"LP");
  double          eqF0hz       = 250;
  double          eqQ          = 1.0;
  double          eqFgain      = 1.0;

  bool            psBypassFl   = true;
  double          psMaxRatio   = 10.0;
  double          psRatio      = 1.0;

  double          dlyFb        = 0.0;
  double          dlyMaxMs     = 3000.0;
  double          dlyMs        = 1;

  bool            mtBypassFl   = true;
  double          mtTimeScale  = 1.0;
  double          mtFeedback   = 0.0;

  double          stOffs = 96;

  double          voiceMult = 1.0 / chainChCnt;

  cmDspInst_t** adsr = p->adsr= cmDspSysAllocInstArray(h, chainChCnt, "Adsr",      NULL, NULL, 2, true, adsrMinLevel );
  cmDspInst_t** dtl  =          cmDspSysAllocInstArray(h, chainChCnt, "DbToLin",   NULL, NULL, 0 );
  cmDspInst_t** phs  =          cmDspSysAllocInstArray(h, chainChCnt, "Phasor",    NULL, NULL, 1, cmDspSysSampleRate(h) );
  cmDspInst_t** wt   =          cmDspSysAllocInstArray(h, chainChCnt, "WaveTable", NULL, NULL, 4, ((unsigned)cmDspSysSampleRate(h)), 2, NULL, NULL, -1 ); 

  //cmDspInst_t** sgmul=          cmDspSysAllocScalarA(  h, chainChCnt, pgSymId, preLbl, "Sg Mult",    0.0,    10.0, 0.01, 1.0 );
  //cmDspInst_t** mul  =          cmDspSysAllocInstArray(h, chainChCnt, "ScalarOp",  NULL, NULL, 6, 2, "*", "in-0", 1.0, "in-1", 1.0 );
  cmDspInst_t** mixa = p->mix = cmDspSysAllocInstArray(h, chainChCnt, "AMix",      NULL, NULL, 1, 1);
  cmDspInst_t** mixs =          cmDspSysAllocInstArray(h, chainChCnt, "AMix",      NULL, NULL, 2, 1, 0.0);
  cmDspInst_t** mixm =          cmDspSysAllocInstArray(h, chainChCnt, "AMix",      NULL, NULL, 3, 2, 0.5, 0.5);

  cmDspInst_t** loop =          cmDspSysAllocInstArray(h, chainChCnt, "LoopRecd",  NULL, NULL, 0 );
  cmDspInst_t** ps   = p->ps =  cmDspSysAllocInstArray(h, chainChCnt, "PShift",    NULL, NULL, 2, psBypassFl,   psRatio );

  cmDspInst_t** cmp  =          cmDspSysAllocInstArray(h, chainChCnt, "Compressor",NULL, NULL, 8, cmpBypassFl, cmpThreshDb, cmpRatio_num, cmpAtkMs, cmpRlsMs, cmpInGain, cmpMakeup, cmpWndMs, cmpWndMaxMs ); 
  cmDspInst_t** dist =          cmDspSysAllocInstArray(h, chainChCnt, "DistDs",    NULL, NULL, 3, distBypassFl, distInGain, distDsrate, distBits  ); 
  cmDspInst_t** cf   =          cmDspSysAllocInstArray(h, chainChCnt, "CombFilt",  NULL, NULL, 5, cfBypassFl,   cfMinHz, cfFbFl, cfHz, cfAlpha );
  cmDspInst_t** eq   = p->eq =  cmDspSysAllocInstArray(h, chainChCnt, "BiQuadEq",  NULL, NULL, 5, eqBypassFl,   eqModeSymId, eqF0hz, eqQ, eqFgain );    
  cmDspInst_t** dly  =          cmDspSysAllocInstArray(h, chainChCnt, "Delay",     NULL, NULL, 2, dlyMaxMs,     dlyFb );
  cmDspInst_t** mt   = p->mt  = cmDspSysAllocInstArray(h, chainChCnt, "MtDelay",   NULL, NULL, 5, mtBypassFl,   mtTimeScale, mtFeedback,   20.0, 0.3 );      
  cmDspInst_t*  mixo = p->mixo= cmDspSysAllocInst(     h,             "AMix",      NULL,       1, chainChCnt );

  cmDspSysNewColumn(h,COL_WIDTH);
  cmDspInst_t** dlyms =         cmDspSysAllocScalarA(  h, chainChCnt, pgSymId, preLbl, "Dly ms",    0.0,    10000.0, 1.0, dlyMs);

  cmDspInst_t*  start = p->start = cmDspSysAllocInst(     h,             "PortToSym", NULL, 1, "send" );  // all msgs to start send the 'hz' symbol
  cmDspInst_t** sgpc  =            cmDspSysAllocInstArray(h, chainChCnt, "PitchCvt",  NULL, NULL, 0 );    
  cmDspInst_t** cfpc  =            cmDspSysAllocInstArray(h, chainChCnt, "PitchCvt",  NULL, NULL, 0 );    
  cmDspInst_t** eqpc  =            cmDspSysAllocInstArray(h, chainChCnt, "PitchCvt",  NULL, NULL, 0 );    
  cmDspInst_t*  midiV =            cmDspSysAllocInst(     h,             "Array",     NULL, 1, rsrc );

  cmDspSysNewColumn(h,COL_WIDTH);
  
  cmDspInst_t** tmop = p->tmop= cmDspSysAllocInstArray(h,  chainChCnt, "ScalarOp",  NULL, NULL, 6, 2, "*", "in-0", 1.0, "in-1", 1.0 );
  cmDspInst_t** toop =          cmDspSysAllocInstArray(h,  chainChCnt, "ScalarOp",  NULL, NULL, 6, 2, "+", "in-0", 0.0, "in-1", 0.0 ); 
  cmDspInst_t** amop = p->amop= cmDspSysAllocInstArray(h,  chainChCnt, "ScalarOp",  NULL, NULL, 6, 2, "*", "in-0", 1.0, "in-1", 1.0 );
  cmDspInst_t** aoop =          cmDspSysAllocInstArray(h,  chainChCnt, "ScalarOp",  NULL, NULL, 6, 2, "+", "in-0", 0.0, "in-1", 0.0 ); 

  // time/amp scale multiply and offset controls
  cmDspInst_t* tmul   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Time Mult",  multMin,   multMax,   multInc, 1.0);
  cmDspInst_t* toff   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Time Offs",  offsMin,   offsMax,   offsInc, 0.0);
  cmDspInst_t* amul   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Ampl Mult",  multMin,   multMax,   multInc, 1.0);
  cmDspInst_t* aoff   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Ampl Offs",  offsMin,   offsMax,   offsInc, 0.0);

  // ADSR controls
  cmDspInst_t* adly  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "sg-Dly",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 0.0);
  cmDspInst_t* atk   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "sg-Atk",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 20.0);
  cmDspInst_t* dcy   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "sg-Dcy",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 100.0);
  cmDspInst_t* hold  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "sg-Hold", adsrMinMs,   adsrMaxMs,   adsrIncMs, 100.0);
  cmDspInst_t* rls   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "sg-Rls",  adsrMinMs,   adsrMaxMs,   adsrIncMs, 1000.0);
  cmDspInst_t* alvl  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "sg-AdsrMax", adsrMinLevel,adsrMaxLevel,adsrIncLevel, adsrMaxLevel);  
  cmDspInst_t* sus   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "sg-SusLvl", adsrMinLevel,adsrMaxLevel,adsrIncLevel, adsrSusLevel );  
  //cmDspInst_t* zero  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "zero",  0.0,  0.0, 0.0, 0.0);

  // SigGen controls
  cmDspInst_t* sgsh   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Sg Shape",   0.0,    11.0, 1.0, ((double)sgShapeId));
  cmDspInst_t* sgot   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Sg OT Cnt",  0.0,    20.0, 1.0, ((double)sgOtCnt));
  cmDspInst_t* sgpoffs = cmDspSysAllocScalarP(h, pgSymId, preLbl, "Sg ST off", -stOffs, stOffs, 0.01, 0.0 );


  cmDspSysNewColumn(h,COL_WIDTH);
  // Loop recorder controls
  cmDspInst_t* lpByp  = cmDspSysAllocCheckP(  h, pgSymId, preLbl,  "Lp Byps", lpBypassFl );
  cmDspInst_t* lpRcd  = cmDspSysAllocCheckP(  h, pgSymId, preLbl,  "Lp Recd", false );
  cmDspInst_t* lpRat  = cmDspSysAllocScalarP( h, pgSymId, preLbl,  "Lp Ratio",0.0,  10.0, 0.01, 1.0 );

  // Pitch Shifter controls
  cmDspInst_t* psbyp  = cmDspSysAllocCheckP(   h, pgSymId, preLbl, "PS Byp",   psBypassFl );
  cmDspInst_t* psrat  = cmDspSysAllocScalarP(  h, pgSymId, preLbl, "PS Ratio", 0.0, psMaxRatio, 0.01, psRatio  );


  cmDspSysNewColumn(h,COL_WIDTH);
  // Compressor controls
  cmDspInst_t* cbyp   = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "Byp Cmp",   cmpBypassFl);
  cmDspInst_t* cgain  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "In Gain",  0.0, cmpMaxGain, 0.01,cmpInGain );
  cmDspInst_t* cthr   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "ThreshDb", -100.0, 0.0,     0.1, cmpThreshDb);
  cmDspInst_t* crat   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Ratio",    0.1,  100.0,     0.1, cmpRatio_num);
  cmDspInst_t* catk   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Atk Ms",   0.0, 1000.0,     0.1, cmpAtkMs);
  cmDspInst_t* crls   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Rls Ms",   0.0, 1000.0,     0.1, cmpRlsMs);
  cmDspInst_t* cmkup  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Makeup",   0.0, cmpMaxGain, 0.01, cmpMakeup);
  cmDspInst_t* cwnd   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Wnd Ms",   1.0, cmpWndMaxMs,1.0, cmpWndMs );

  // Distortion controls
  cmDspInst_t* dbyp   = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "Dist Byp",  distBypassFl);
  cmDspInst_t* drct   = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "Rectify",   distRectifyFl);
  cmDspInst_t* dful   = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "Full/Half", distFullRectFl);
  cmDspInst_t* dsr    = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Dsrate",       0.0, 96000.0, 1.0, distDsrate);
  cmDspInst_t* dbt    = cmDspSysAllocScalarP( h, pgSymId, preLbl, "bits",         2.0,    32.0, 1.0, distBits);
  cmDspInst_t* dclip  = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Clip dB",   -100.0,     0.0, 0.1, distClipDb);
  cmDspInst_t* dogn   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Out Gain",     0.0,    10.0, 0.01, 1.0);

  cmDspSysNewColumn(h,COL_WIDTH);
  // Comb filter controls
  cmDspInst_t* cfbyp   = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "CF Byp",  cfBypassFl);
  cmDspInst_t* cfalpha = cmDspSysAllocScalarP( h, pgSymId, preLbl, "CF alpha", -1.0, 1.0, 0.001, cfAlpha );
  cmDspInst_t* cfpoffs = cmDspSysAllocScalarP( h, pgSymId, preLbl, "CF ST off", -stOffs, stOffs, 0.01, 0.0 );

  // Eq controls
  cmDspInst_t* eqbyp   = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "Eq Byp", 0 );
  cmDspInst_t* eqmode  = cmDspSysAllocMsgListP(h, pgSymId, preLbl, "Mode", NULL, "biQuadEqMode", 1);
  cmDspInst_t* eqq     = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Eq Q",     -100.0, 100.0, 0.1, eqQ);
  cmDspInst_t* eqfgn   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Filt Gain",   0.0,  10.0, 0.1, eqFgain);
  cmDspInst_t* eqpoffs = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Eq ST off", -stOffs, stOffs, 0.01, 0.0 );

  // Delay Controls
  cmDspInst_t* dlybyp = cmDspSysAllocCheckP(   h, pgSymId, preLbl, "Dly Byp", 0 );
  //cmDspInst_t* dlyms  = cmDspSysAllocScalarP(  h, pgSymId, preLbl, "Dly Time", 0.0, dlyMaxMs, 1.0, dlyMs  );
  cmDspInst_t* dlyfb  = cmDspSysAllocScalarP(  h, pgSymId, preLbl, "Dly Fb",   -1.0, 1.0, 0.001, dlyFb );

  // multi-tap controls
  cmDspInst_t* mtbyp  = cmDspSysAllocCheckP(  h, pgSymId, preLbl, "Mt Byp", mtBypassFl);
  cmDspInst_t* mtfb   = cmDspSysAllocScalarP( h, pgSymId, preLbl, "Feedback",   0.0,     1.0, 0.01, mtFeedback);
  cmDspInst_t* mtscale= cmDspSysAllocScalarP( h, pgSymId, preLbl, "Tm Scale",   0.01,     10.0, 0.01, mtTimeScale);

  // voice scaler
  cmDspInst_t* vmult = cmDspSysAllocScalarP(  h, pgSymId, preLbl, "Voc Scale",   0.0,    10.0, 0.001, voiceMult);
  
  // Compression Meters
  cmDspSysNewColumn(h,COL_WIDTH);
  cmDspSysAllocLabel(h,"Compression",kLeftAlignDuiId);

  cmDspInst_t** cmtr =  cmDspSysAllocInstArray(h, chainChCnt, "Meter", NULL, NULL, 3, 0.0, 0.0, 1.0);


  // Check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  // NOTE:
  // NOTE:  ain goes to mix "in-0"
  // NOTE:

  // audio connections - 
  cmDspSysConnectAudioN1N1(h, phs,  "out", wt,   "phs",  chainChCnt ); //  phs -> wt
  cmDspSysConnectAudioN1N1(h, wt,   "out", mixs, "in",   chainChCnt ); //  wt -> mix
  cmDspSysConnectAudioN1N1(h, mixs, "out", mixm, "in-0", chainChCnt ); //  
  cmDspSysConnectAudioN1N1(h, mixa, "out", mixm, "in-1", chainChCnt ); //  
  cmDspSysConnectAudioN1N1(h, mixm, "out", loop, "in",   chainChCnt ); //  mix -> loop
  cmDspSysConnectAudioN1N1(h, loop, "out", ps,   "in",   chainChCnt ); //  loop -> ps
  cmDspSysConnectAudioN1N1(h, ps,   "out", cmp,  "in",   chainChCnt ); //  ps   -> cmp  
  cmDspSysConnectAudioN1N1(h, cmp,  "out", dist, "in",   chainChCnt ); //  cmp  -> dist
  cmDspSysConnectAudioN1N1(h, dist, "out", cf,   "in",   chainChCnt ); //  dist -> cf  
  cmDspSysConnectAudioN1N1(h, cf,   "out", eq,   "in",   chainChCnt ); //  cf   -> eq  
  cmDspSysConnectAudioN1N1(h, eq,   "out", dly,  "in",   chainChCnt ); //  cf   -> dly
  cmDspSysConnectAudioN1N1(h, dly,  "out", mt,   "in",  chainChCnt );  //  dly -> mt
  cmDspSysConnectAudioN11N(h, mt,   "out", mixo, "in",  chainChCnt );  //  mt -> mixo

  cmDspSysInstallCb(       h, start,      "send", midiV,  "cmd", NULL );        // force the hz value to be sent out the midV
  cmDspSysInstallCb1NN1(   h, midiV,      "out",  sgpc,   "midi", chainChCnt ); // midiV -> pcvt (convert midi to pitch)
  cmDspSysInstallCb1NN1(   h, midiV,      "out",  cfpc,   "midi", chainChCnt ); // midiV -> pcvt (convert midi to pitch)
  cmDspSysInstallCb1NN1(   h, midiV,      "out",  eqpc,   "midi", chainChCnt ); // midiV -> pcvt (convert midi to pitch)

  //cmDspSysInstallCb11N1( h, zero, "val",   mix,  "gain-0", chainChCnt ); 
  //cmDspSysInstallCb11N1( h, zero, "val",   mixs,  "gain", chainChCnt );   // force the osc mixer to start turned off

  // Adssr scale/offset controls
  cmDspSysInstallCb11N1(    h, tmul, "val", tmop, "in-1",   chainChCnt );
  cmDspSysInstallCb11N1(    h, toff, "val", toop, "in-1",   chainChCnt );
  cmDspSysInstallCbN1N1(    h, tmop, "out", toop, "in-0",   chainChCnt );
  cmDspSysInstallCbN1N1(    h, toop, "out", adsr,  "tscale", chainChCnt );

  cmDspSysInstallCb11N1(    h, amul, "val", amop, "in-1",   chainChCnt );
  cmDspSysInstallCb11N1(    h, aoff, "val", aoop, "in-1",   chainChCnt );
  cmDspSysInstallCbN1N1(    h, amop, "out", aoop, "in-0",   chainChCnt );
  cmDspSysInstallCbN1N1(    h, aoop, "out", adsr,  "ascale", chainChCnt );

  // ADSR parameter controls
  cmDspSysInstallCb11N1( h, adly, "val",   adsr, "dly",  chainChCnt );
  cmDspSysInstallCb11N1( h, atk,  "val",   adsr, "atk",  chainChCnt );
  cmDspSysInstallCb11N1( h, dcy,  "val",   adsr, "dcy",  chainChCnt );
  cmDspSysInstallCb11N1( h, hold, "val",   adsr, "hold", chainChCnt );
  cmDspSysInstallCb11N1( h, rls,  "val",   adsr, "rls",  chainChCnt );
  cmDspSysInstallCb11N1( h, alvl, "val",   adsr, "alvl", chainChCnt );
  cmDspSysInstallCb11N1( h, sus,  "val",   adsr, "sus",  chainChCnt );  
  cmDspSysInstallCbN1N1( h, adsr, "out",   dtl,  "in",   chainChCnt );   // adsr    -> dbToLin
  cmDspSysInstallCbN1N1( h, dtl,  "out",   mixs, "gain", chainChCnt );   // dbToLin -> mix (gain)

  // SigGen parameter controls
  //cmDspSysInstallCb11N1(   h, start,      "send", sgmul,  "send",   chainChCnt ); // send cur sgmul value to mul in-0
  //cmDspSysInstallCbN1N1(   h, sgpc,       "hz",   mul,    "in-1",   chainChCnt ); // send hz        value to mul in-1 
  //cmDspSysInstallCbN1N1(   h, sgmul,      "val",  mul,    "in-0",   chainChCnt );  
  cmDspSysInstallCb11N1(   h, sgpoffs,    "val",  sgpc,   "offs",   chainChCnt );
  //cmDspSysInstallCbN1N1(   h, mul,        "out",  phs,     "mult",  chainChCnt );
  cmDspSysInstallCbN1N1(   h, sgpc,       "hz",   phs,    "mult",   chainChCnt );
  cmDspSysInstallCb11N1(   h, sgsh,       "val",  wt,     "shape",  chainChCnt );
  cmDspSysInstallCb11N1(   h, sgot,       "val",  wt,     "ot",     chainChCnt );


  // Pitch Shift parameter controls
  cmDspSysInstallCb11N1(   h, psbyp,  "out",  ps, "bypass", chainChCnt );
  cmDspSysInstallCb11N1(   h, psrat,  "val",  ps, "ratio",   chainChCnt );

  // Loop recorder parameter controls
  cmDspSysInstallCb11N1(h, lpByp, "out", loop, "bypass", chainChCnt );
  cmDspSysInstallCb11N1(h, lpRcd, "out", loop, "recd",   chainChCnt );
  cmDspSysInstallCb11N1(h, lpRat, "val", loop, "ratio",  chainChCnt );

  // Compressor paramter controls
  cmDspSysInstallCb11N1(h, cbyp,  "out", cmp, "bypass", chainChCnt );
  cmDspSysInstallCb11N1(h, cgain, "val", cmp, "igain",  chainChCnt );
  cmDspSysInstallCb11N1(h, cthr,  "val", cmp, "thr",    chainChCnt );
  cmDspSysInstallCb11N1(h, crat,  "val", cmp, "ratio",  chainChCnt );
  cmDspSysInstallCb11N1(h, catk,  "val", cmp, "atk",    chainChCnt );
  cmDspSysInstallCb11N1(h, crls,  "val", cmp, "rls",    chainChCnt );
  cmDspSysInstallCb11N1(h, cmkup, "val", cmp, "ogain",  chainChCnt );
  cmDspSysInstallCb11N1(h, cwnd,  "val", cmp, "wnd",    chainChCnt );
  cmDspSysInstallCbN1N1(h, cmp,   "env", cmtr, "in",    chainChCnt ); // compressor meter

  // Distortion parameter controls
  cmDspSysInstallCb11N1(h, dbyp,  "out", dist, "bypass",chainChCnt );
  cmDspSysInstallCb11N1(h, dsr,   "val", dist, "srate", chainChCnt );
  cmDspSysInstallCb11N1(h, dbt,   "val", dist, "bits",  chainChCnt );
  cmDspSysInstallCb11N1(h, drct,  "out", dist, "rect",  chainChCnt );
  cmDspSysInstallCb11N1(h, dful,  "out", dist, "full",  chainChCnt );
  cmDspSysInstallCb11N1(h, dclip, "val", dist, "clip",  chainChCnt );
  cmDspSysInstallCb11N1(h, dogn,  "val", dist, "ogain", chainChCnt );

  // Comb filter parameter controls
  cmDspSysInstallCb11N1(h, cfbyp,      "out", cf,   "bypass",chainChCnt );
  cmDspSysInstallCb11N1(h, cfalpha,    "val", cf,   "alpha", chainChCnt );
  cmDspSysInstallCb11N1(h, cfpoffs,    "val", cfpc, "offs",  chainChCnt );
  cmDspSysInstallCbN1N1(h, cfpc,       "hz",  cf,   "hz",    chainChCnt ); 
  //cmDspSysInstallCbN1N1(h, mul,        "out", cf,   "hz",    chainChCnt );

  // EQ parameter controls
  cmDspSysInstallCb11N1(   h, eqbyp,      "out",  eq,    "bypass", chainChCnt );
  cmDspSysInstallCb11N1(   h, eqmode,     "mode", eq,    "mode",   chainChCnt );
  cmDspSysInstallCb11N1(   h, eqq,        "val",  eq,    "Q",      chainChCnt );
  cmDspSysInstallCb11N1(   h, eqfgn,      "val",  eq,    "gain",   chainChCnt );
  cmDspSysInstallCb11N1(   h, eqpoffs,    "val",  eqpc,  "offs",   chainChCnt );
  cmDspSysInstallCbN1N1(   h, eqpc,       "hz",   eq,    "f0",     chainChCnt );   // chCfg -> Eq Hz
  //cmDspSysInstallCbN1N1(   h, mul,        "out",  eq,     "f0",    chainChCnt );

  // Delay parameter controls
  cmDspSysInstallCb11N1(   h, dlybyp, "out",  dly, "bypass", chainChCnt );
  //cmDspSysInstallCb11N1(   h, dlyms,  "val",  dly, "time",   chainChCnt );
  cmDspSysInstallCb11N1(   h, dlyfb,  "val",  dly, "fb",     chainChCnt );
  cmDspSysInstallCbN1N1(   h, dlyms,  "val",  dly, "time",   chainChCnt );  

  // Multi-tap parameter controls
  cmDspSysInstallCb11N1(   h, mtbyp,   "out",  mt,    "bypass",  chainChCnt );
  cmDspSysInstallCb11N1(   h, mtfb,    "val",  mt,    "fb",      chainChCnt );
  cmDspSysInstallCb11N1(   h, mtscale, "val",  mt,    "scale",   chainChCnt );

  cmDspSysInstallCb111N(   h, vmult,   "val",  mixo,  "gain",    chainChCnt );

 errLabel:

  return rc;
}

//=====================================================================================================================
typedef struct
{
  cmDspPP_Circuit_t c;
  cmDspFx0_Chain_t  fx;  
} cmDspPP_Fx0_t;


cmDspRC_t _cmDspPP_Fx0Alloc(
  cmDspSysH_t              h, 
  _cmDspPP_Ctx_t*          ctx,   
  cmDspPP_Fx0_t*           p,
  const cmChar_t*          title,
  const cmChar_t*          preLbl,
  cmDspInst_t*             selChk,
  cmDspInst_t**            ain,
  cmDspInst_t*             ptIn )
{
  cmDspRC_t rc;
  unsigned i;

  p->c.circuitSymId     = cmDspSysRegisterInstAttrSymbolStr(h,title);
  unsigned presetGroupSymId = cmDspSysPresetRegisterGroup(h,title);
  _cmDspSys_PresetMgmt(h,preLbl,presetGroupSymId);
  cmDspSysNewColumn(h,COL_WIDTH);

  unsigned fxChCnt = ctx->iChCnt;

  // make processors for each input channel
  if((rc = _cmDspFx0_ChainAlloc(h,ctx->err, presetGroupSymId, preLbl, "midiList", fxChCnt, &p->fx)) != kOkDspRC )
    goto errLabel;

  
  // make mixers for each output channel
  p->c.aout    = cmDspSysAllocInstArray( h, ctx->oChCnt, "AMix", NULL,NULL, 1, fxChCnt );  
  p->c.aoutLbl = "out";


  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  cmDspSysConnectAudioN1N1(h, ain,  "out",    p->fx.mix,   "in",    ctx->iChCnt );   // ain -> sg/ain mixer
  cmDspSysInstallCb1NN1(   h, ptIn, "b-out",  p->fx.adsr,  "gate",  ctx->iChCnt );   // gate -> adsr
  cmDspSysInstallCb1NN1(   h, ptIn, "f-out",  p->fx.tmop,  "in-0",  ctx->iChCnt );   // level ->adsr (tscale)
  cmDspSysInstallCb1NN1(   h, ptIn, "f-out",  p->fx.amop,  "in-0",  ctx->iChCnt );   // level ->adsr (ascale)

  if(0)
  {
    for(i=0; i<ctx->iChCnt; ++i)
    {
      cmDspSysConnectAudio( h, ain[i],   "out",               p->fx.mix[  ctx->iChCnt + i],  "in"    ); // ain -> sg/ain mixer
      cmDspSysInstallCb(    h, ptIn, formLabel(h,"b-out",i),  p->fx.adsr[ ctx->iChCnt + i],  "gate",  NULL );   // gate -> adsr
      cmDspSysInstallCb(    h, ptIn, formLabel(h,"f-out",i),  p->fx.tmop[ ctx->iChCnt + i],  "in-0",  NULL );   // level ->adsr (tscale)
      cmDspSysInstallCb(    h, ptIn, formLabel(h,"f-out",i),  p->fx.amop[ ctx->iChCnt + i],  "in-0",  NULL );   // level ->adsr (ascale)
    }
  }

  for( i=0; i<ctx->oChCnt; ++i)
  {
    cmDspSysConnectAudioN11N(h, p->fx.mt, "out", p->c.aout[i], "in", fxChCnt ); // fx.mix -> mixer
  }


  // reset the chain - called by the master 'reset' button
  cmDspSysInstallCb( h, selChk, "out", p->fx.start, "send", NULL );

 errLabel:

  cmDspSysRemoveInstAttrSymbol(h,p->c.circuitSymId);

  return rc;
}

//=====================================================================================================================
#define cdChainCnt (5)

typedef struct 
{
  const cmChar_t* preLbl;
  const cmChar_t* title;
  const cmChar_t* midiRsrc;
  const cmChar_t* chanRsrc;
  unsigned        chCnt;
  cmDspInst_t*    nom;
  cmDspInst_t*    ogain;
  cmDspInst_t**   mtr;
  cmDspInst_t**   envm;
  unsigned*       map;
} cmDspPP_Cd0_Desc_t;


typedef struct
{
  cmDspPP_Circuit_t   c;
  cmDspFx0_Chain_t    ch[ cdChainCnt ];
} cmDspPP_Cd0_t;



cmDspRC_t _cmDspPP_Cd0Alloc(
  cmDspSysH_t              h, 
  _cmDspPP_Ctx_t*          ctx,   
  cmDspPP_Cd0_t*           p,
  const cmChar_t*          title,
  const cmChar_t*          preLbl,
  cmDspInst_t*             selChk,
  cmDspInst_t**            ain,
  cmDspInst_t*             ptIn )
{
  cmDspRC_t       rc              = kOkDspRC;
  cmReal_t        cdMaxTimeSpanMs = 50;
  cmReal_t        cdMinNoteCnt    = 2;
  cmReal_t        nomXfadeMs      = 25.0;

  unsigned i,j;

  cmDspPP_Cd0_Desc_t desc[] = 
  {
    { "ch","Chose", "CDmidi",  "CDchan",  0, NULL, NULL, NULL, NULL, NULL },
    { "ot","Other", "CDmidi",  "CDchan",  0, NULL, NULL, NULL, NULL, NULL },
    { "g0","Grp0",  "CD0midi", "CD0chan", 0, NULL, NULL, NULL, NULL, NULL },
    { "g1","Grp1",  "CD1midi", "CD1chan", 0, NULL, NULL, NULL, NULL, NULL },
    { "ee","Else",  "NONmidi", "NONchan", 0, NULL, NULL, NULL, NULL, NULL }
  };

  assert( sizeof(desc)/sizeof(desc[0]) == cdChainCnt );

  for(i=0; i<cdChainCnt; ++i)
  {
    // read channel index resource array
    if( cmDspRsrcUIntArray( h, &desc[i].chCnt, &desc[i].map, desc[i].chanRsrc, NULL ) != kOkDspRC )
      return cmErrMsg(ctx->err,kInvalidArgDspRC,"The chord detector channel index resource '%s' could not be read.",cmStringNullGuard(desc[i].chanRsrc));
  }


  p->c.circuitSymId = cmDspSysRegisterInstAttrSymbolStr(h,title);

  /*
  cmDspInst_t* printBtn  = cmDspSysAllocInst( h, "Button", "_print",  2, kButtonDuiId, 0.0);
  cmDspInst_t* bcast     = cmDspSysAllocInst( h, "BcastSym",   NULL,  1, p->c.circuitSymId );
  cmDspSysInstallCb( h, printBtn, "sym", bcast, "msg", NULL );
  */

  cmDspInst_t* cd = cmDspSysAllocInst(h, "ChordDetect", NULL, 1, "cdSel" );
  cmDspInst_t* ns = cmDspSysAllocInst(h, "NoteSelect",  NULL, 1, ctx->iChCnt );
  
  // allocate the switching noms and gain controls
  for(i=0; i<cdChainCnt; ++i)
  {
    desc[i].nom    = cmDspSysAllocInst(  h, "NofM",  NULL, 3, desc[i].chCnt, desc[i].chCnt, nomXfadeMs );
    desc[i].ogain  = cmDspSysAllocScalar(h,formLabel(h,"Out Gn",i),0.0,10.0,0.01,1.0); 
  }

  // chord detector parameters
  cmDspInst_t* cdSpanMs  = cmDspSysAllocScalar(h,"Span Ms",  10.0,1000.0,1.0,cdMaxTimeSpanMs);
  cmDspInst_t* cdNoteCnt = cmDspSysAllocScalar(h,"Note Cnt",  1.0, 100.0,1.0,cdMinNoteCnt );
  cmDspInst_t* cdCount   = cmDspSysAllocScalar(h,"Ch. Count",   0, 1, 0, 0);
  cmDspInst_t* nomXfade  = cmDspSysAllocScalar(h,"Xfade ms",    0, 1000, 0, nomXfadeMs);

  cmDspInst_t* btn       = cmDspSysAllocButton(h,"print",0);

  // note select gate meters
  for(j=0; j<cdChainCnt; ++j)
  {
    cmDspSysNewColumn(h,50);
    cmDspSysAllocLabel(h,desc[j].title,kLeftAlignDuiId );
    desc[j].mtr = cmDspSysAllocInstArray(h, ctx->iChCnt, "Meter", NULL, NULL, 3, 0.0, 0.0, 1.0 );
  }

  //  audio output meters
  for(j=0; j<cdChainCnt; ++j)
  {                                                                     
    cmDspSysNewColumn(h,COL_WIDTH);
    cmDspSysAllocLabel(h,desc[j].title,kLeftAlignDuiId );
    desc[j].envm = cmDspSysAllocInstArray(h,desc[j].chCnt,"AMeter", NULL, NULL, 3, 0.0, 0.0, 1.0 );
  }

  // create the fx chains
  for(i=0; i<cdChainCnt; ++i )
  {
    cmDspSysNewPage(h,desc[i].title);
    unsigned presetGroupSymId = cmDspSysPresetRegisterGroup(h,desc[i].title);

    _cmDspSys_PresetMgmt(h,desc[i].preLbl,presetGroupSymId);
    cmDspSysNewColumn(h,COL_WIDTH);

    // create an fx chain with desc[i].chCnt channels
    if((rc = _cmDspFx0_ChainAlloc(h, ctx->err, presetGroupSymId, desc[i].preLbl, desc[i].midiRsrc, desc[i].chCnt, p->ch + i)) != kOkDspRC )
      goto errLabel;

  }

  // make mixers for each chain
  p->c.aout    = cmDspSysAllocInstArray( h, ctx->oChCnt, "AMix", NULL, NULL, 1, cdChainCnt );  
  p->c.aoutLbl = "out";

  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  cmDspSysInstallCb1N1N(h, ptIn, "b-out",  cd,   "gate", ctx->iChCnt ); // EF -> CD gate
  cmDspSysInstallCb1N1N(h, ptIn, "f-out",  cd,   "rms",  ctx->iChCnt ); // EF -> CD rms
  cmDspSysInstallCb1N1N(h, cd,   "gate",   ns,   "gate", ctx->iChCnt ); // CD -> NS gate
  cmDspSysInstallCb1N1N(h, cd,   "rms",    ns,   "rms",  ctx->iChCnt ); // CD -> NS rms
  cmDspSysInstallCb(h,     cd,   "detect", ns,   "trig",  NULL );       // CD -> NS trigger

  // chord detector paramter controls
  cmDspSysInstallCb(h, cdSpanMs,  "val",   cd,      "span",  NULL );
  cmDspSysInstallCb(h, cdNoteCnt, "val",   cd,      "notes", NULL );
  cmDspSysInstallCb(h, cd,       "count",  cdCount, "val",   NULL );

  for(i=0; i<cdChainCnt; ++i)
  {
    cmDspSysInstallCb(         h, nomXfade, "val", desc[i].nom, "ms", NULL );

    cmDspSysInstallCb1N1NM(    h, ns,    formLabel(h,"gate",i), ctx->iChCnt, desc[i].nom, "sel",  desc[i].chCnt, desc[i].map ); // NS -> nom's (selectors)
    cmDspSysInstallCb1NN1 (    h, ns,    formLabel(h,"gate",i),              desc[i].mtr, "in",   ctx->iChCnt                ); // NS -> Meter 
    cmDspSysInstallCb(         h, ns,    "done",                desc[i].nom, "cmd",  NULL );        // NS -> nom's (done triggers)

    cmDspSysConnectAudioN11NM( h, ain,   "out",                 ctx->iChCnt, desc[i].nom, "a-in", desc[i].chCnt, desc[i].map ); // ain -> nom's

    cmDspSysInstallCb1N1NM(    h, ptIn,  "b-out",               ctx->iChCnt, desc[i].nom, "b-in", desc[i].chCnt, desc[i].map ); // NS -> nom (gate)
    cmDspSysInstallCb1N1NM(    h, ptIn,  "f-out",               ctx->iChCnt, desc[i].nom, "f-in", desc[i].chCnt, desc[i].map ); // NS -> nom (rms)

    cmDspSysConnectAudio1NN1(h, desc[i].nom, "a-out", p->ch[i].mix,  "in",   desc[i].chCnt );   // nom -> chain sg/ain mixer (audio)
    cmDspSysInstallCb1NN1(   h, desc[i].nom, "b-out", p->ch[i].adsr, "gate", desc[i].chCnt );   // nom -> chain adsr (gate)
    cmDspSysInstallCb1NN1(   h, desc[i].nom, "f-out", p->ch[i].tmop, "in-0", desc[i].chCnt );   // nom -> chain adsr (tscale)
    cmDspSysInstallCb1NN1(   h, desc[i].nom, "f-out", p->ch[i].amop, "in-0", desc[i].chCnt );   // nom -> chain adsr (ascale)

    cmDspSysInstallCb(       h, btn, "sym",   desc[i].nom,   "cmd",  NULL );

    cmDspSysConnectAudioN1N1( h, p->ch[i].mt,   "out", desc[i].envm, "in",                  desc[i].chCnt ); // chain aout -> mtr
    cmDspSysConnectAudio11N1( h, p->ch[i].mixo, "out", p->c.aout,     formLabel(h,"in", i), ctx->oChCnt);    // chain aout -> mix out


    // reset the chain - (called by the master 'reset' button)
    cmDspSysInstallCb( h, selChk, "out", p->ch[i].start, "send", NULL );

  }

 errLabel:

  cmDspSysRemoveInstAttrSymbol(h,p->c.circuitSymId);

  return rc;
}

//=====================================================================================================================

#define cd1ChainCnt (10)

typedef struct 
{
  const cmChar_t* preLbl;
  const cmChar_t* title;
  unsigned        chCnt;
  cmDspInst_t*    nom;
  cmDspInst_t*    ogain;
  cmDspInst_t**   mtr;
  cmDspInst_t**   envm;
  const cmChar_t* midiRsrc;
  unsigned*       midi;
  const cmChar_t* chanRsrc;
  unsigned*       chan;
} cmDspPP_Cd1_Desc_t;


typedef struct
{
  cmDspPP_Circuit_t   c;
  cmDspFx0_Chain_t    ch[ cd1ChainCnt ];
} cmDspPP_Cd1_t;



cmDspRC_t _cmDspPP_Cd1Alloc(
  cmDspSysH_t              h, 
  _cmDspPP_Ctx_t*          ctx,   
  cmDspPP_Cd1_t*           p,
  const cmChar_t*          title,
  const cmChar_t*          preLbl,
  cmDspInst_t*             selChk,
  cmDspInst_t**            ain,
  cmDspInst_t*             ptIn )
{
  cmDspRC_t       rc              = kOkDspRC;
  cmReal_t        cdMaxTimeSpanMs = 50;
  cmReal_t        cdMinNoteCnt    = 2;
  cmReal_t        nomXfadeMs      = 25.0;
  unsigned        cdNetNodeId     = cmInvalidId;
  const cmChar_t* cdNetNodeLabel  = NULL;
  const cmChar_t* nonCdNetNodeLabel = NULL;
  unsigned        cdChCnt         = 0;
  cmDspInst_t*    cd              = NULL;
  cmDspInst_t*    ns              = NULL;
  cmDspInst_t*    cdSpanMs        = NULL;
  cmDspInst_t*    cdNoteCnt       = NULL;
  cmDspInst_t*    cdCount         = NULL;
  cmDspInst_t*    btn             = NULL;
  unsigned        cd1ChainCnto2   = cd1ChainCnt/2;
  unsigned        pgSymId         = cmInvalidId;

  unsigned i,j;

  cmDspPP_Cd1_Desc_t desc[] = 
  {
    // resources for local (this) machine
    { "ch0","Ch0",   0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "ot0","Oth0",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "g00","Gr00",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "g01","Gr01",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "ee0","Ee00",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },

    // resources for remote (other) machine
    { "ch1","Ch1",   0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "ot1","Oth1",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "g10","Gr10",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "g11","Gr11",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { "ee1","Ee01",  0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }

  };

  assert( (sizeof(desc)/sizeof(desc[0])) == cd1ChainCnt );

  // get the chord detector network node label of this machine
  if( cmDspRsrcString(h, &cdNetNodeLabel, "cdLocalNetNode", NULL ) != kOkDspRC )
  {
    rc = cmErrMsg(ctx->err,kRsrcNotFoundDspRC,"The resource 'cdLocalNetNode' could not be read.");
    goto errLabel;
  }

  // convert the chord detector network node label to an id
  if( (cdNetNodeId = cmDspSysNetNodeLabelToId(h,cdNetNodeLabel)) == cmInvalidId )
  {
    rc = cmErrMsg(ctx->err,kInvalidArgDspRC,"The chord detector network node label '%s' is not valid.",cmStringNullGuard(cdNetNodeLabel));
    goto errLabel;
  }

  // get the label of the network node which is not running the chord detector
  if( cmDspRsrcString(h, &nonCdNetNodeLabel, "cdRemoteNetNode", NULL ) != kOkDspRC )
  {
    rc = cmErrMsg(ctx->err,kRsrcNotFoundDspRC,"The resource 'cdRemoteNetNode' could not be read.");
    goto errLabel;
  }

  // validate the non-chord detector network node label
  if( cmDspSysNetNodeLabelToId(h,nonCdNetNodeLabel) == cmInvalidId )
  {
    rc = cmErrMsg(ctx->err,kInvalidArgDspRC,"The net node label '%s' is not valid.",cmStringNullGuard(nonCdNetNodeLabel));
    goto errLabel;    
  }

  // is this the chord detector node
  bool     cdIsLocalFl = cdNetNodeId == cmDspSysNetNodeId(h);
  unsigned ii          = cdIsLocalFl ? 0 : cd1ChainCnto2;
  unsigned nn          = ii + cd1ChainCnto2;

  // read all the resource arrays 
  for(i=0; i<cd1ChainCnt; ++i)
  {
    desc[i].midiRsrc = cmTsPrintfH( cmDspSysLHeap(h), "nsMidi-%i",i);
    desc[i].chanRsrc = cmTsPrintfH( cmDspSysLHeap(h), "nsChan-%i",i);

    if( cmDspRsrcUIntArray(h,&desc[i].chCnt,&desc[i].midi,desc[i].midiRsrc,NULL) != kOkDspRC )
    {
      rc = cmErrMsg(ctx->err,kRsrcNotFoundDspRC,"The note selector MIDI pitch resource '%s' could not be read.",cmStringNullGuard(desc[i].midiRsrc));
      goto errLabel;
    }

    if( cmDspRsrcUIntArray(h,&desc[i].chCnt,&desc[i].chan,desc[i].chanRsrc,NULL) != kOkDspRC )
    {
      rc = cmErrMsg(ctx->err,kRsrcNotFoundDspRC,"The note selector channel map resource '%s' could not be read.",cmStringNullGuard(desc[i].chanRsrc));
      goto errLabel;
    }

  }

  p->c.circuitSymId = cmDspSysRegisterInstAttrSymbolStr(h,title);

  if( cdIsLocalFl )
  {
    // get the count of chord detector input channels
    if( cmDspRsrcArrayCount(h,&cdChCnt,"ChordList",NULL) != kOkDspRC )
      return cmErrMsg(ctx->err,kInvalidArgDspRC,"The 'ChordList' resource could not be read.");
    
    cd = cmDspSysAllocInst(h, "ChordDetect",    "cd", 1, "ChordList" );
    ns = cmDspSysAllocInst(h, "NetNoteSelect",  "ns", 1, cdChCnt );


    // chord detector parameters
    cdSpanMs  = cmDspSysAllocScalarP(h, pgSymId, preLbl, "Span Ms",  10.0,1000.0,1.0,cdMaxTimeSpanMs);
    cdNoteCnt = cmDspSysAllocScalarP(h, pgSymId, preLbl, "Note Cnt",  1.0, 100.0,1.0,cdMinNoteCnt );
    cdCount   = cmDspSysAllocScalarP(h, pgSymId, preLbl, "Ch. Count",   0, 1,0,0);
  }

  cmDspInst_t* nomXfade  = cmDspSysAllocScalarP(h, pgSymId, preLbl, "Xfade ms",  0, 1000, 0, nomXfadeMs);


  btn  = cmDspSysAllocButtonP(h,preLbl,"print",0);

  // allocate the switching noms and gain controls
  for(i=ii; i<nn; ++i)
  {
    desc[i].nom    = cmDspSysAllocInst(  h, "NofM",  formLabel(h,"nom",i), 3, desc[i].chCnt, desc[i].chCnt, nomXfadeMs );
    desc[i].ogain  = cmDspSysAllocScalarP(h, pgSymId, preLbl, formLabel(h,"Out Gn",i),0.0,10.0,0.01,1.0); 
  }

  // note-select gate meters
  for(j=ii; cdIsLocalFl && j<nn; ++j)
  {
    cmDspSysNewColumn(h,50);
    cmDspSysAllocLabel(h,desc[j].title,kLeftAlignDuiId );
    desc[j].mtr = cmDspSysAllocInstArray(h, cdChCnt, "Meter", NULL, NULL, 3, 0.0, 0.0, 1.0 );
  }

  //  audio output meters
  for(j=ii; j<nn; ++j)
  {                                                                     
    cmDspSysNewColumn(h,50);
    cmDspSysAllocLabel(h,desc[j].title,kLeftAlignDuiId );
    desc[j].envm = cmDspSysAllocInstArray(h,desc[j].chCnt,"AMeter", NULL, NULL, 3, 0.0, 0.0, 1.0 );
  }

  // create the fx chains
  for(i=ii; i<nn; ++i )
  {
    cmDspSysNewPage(h,desc[i].title);
    unsigned presetGroupSymId = cmDspSysPresetRegisterGroup(h,desc[i].title);

    _cmDspSys_PresetMgmt(h,desc[i].preLbl,presetGroupSymId);
    cmDspSysNewColumn(h,200);

    // create an fx chain with desc[i].chCnt channels
    if((rc = _cmDspFx0_ChainAlloc(h, ctx->err, presetGroupSymId, desc[i].preLbl, desc[i].midiRsrc, desc[i].chCnt, p->ch + i)) != kOkDspRC )
      goto errLabel;

  }

  // make mixers for each chain
  p->c.aout    = cmDspSysAllocInstArray( h, ctx->oChCnt, "AMix", NULL, NULL, 1, cd1ChainCnto2 );  
  p->c.aoutLbl = "out";

  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  if( cdIsLocalFl )
  {
    cmDspSysInstallCb1N1N(h, ptIn, "b-out",  cd,   "gate", ctx->iChCnt ); // EF -> CD gate
    cmDspSysInstallCb1N1N(h, ptIn, "f-out",  cd,   "rms",  ctx->iChCnt ); // EF -> CD rms
    cmDspSysInstallCb1N1N(h, cd,   "gate",   ns,   "gate", cdChCnt     ); // CD -> NS gate
    cmDspSysInstallCb1N1N(h, cd,   "rms",    ns,   "rms",  cdChCnt     ); // CD -> NS rms
    cmDspSysInstallCb(h,     cd,   "detect", ns,   "trig",  NULL );       // CD -> NS trigger

    // chord detector paramter controls
    cmDspSysInstallCb(h, cdSpanMs,  "val",   cd,      "span",  NULL );
    cmDspSysInstallCb(h, cdNoteCnt, "val",   cd,      "notes", NULL );
    cmDspSysInstallCb(h, cd,       "count",  cdCount, "val",   NULL );
  }
  else
  {
    cmDspSysInstallNetCb1N1N(h, ptIn,  "b-out",  cdNetNodeLabel, "cd", "gate", 16, ctx->iChCnt  );
    cmDspSysInstallNetCb1N1N(h, ptIn,  "f-out",  cdNetNodeLabel, "cd", "rms",  16, ctx->iChCnt  );
  }

  for(i=ii; i<nn; ++i)
  {

    if( cdIsLocalFl )
    {
      // local NS -> nom's (selectors) 
      cmDspSysInstallCb1N1N(    h, ns,    formLabel(h,"gate",i), desc[i].nom, "sel",  desc[i].chCnt ); 
      cmDspSysInstallCb(        h, ns,    "done",                desc[i].nom, "cmd",  NULL );        // NS -> nom's (done triggers)

      // local NS -> meters
      cmDspSysInstallCb1NN1M2(  h, ns,    formLabel(h,"gate",i), desc[i].chCnt, desc[i].chan, desc[i].mtr, "in", cdChCnt ); 

    }


    cmDspSysConnectAudioN11NM( h, ain, "out", ctx->iChCnt,   desc[i].nom, "a-in", desc[i].chCnt, desc[i].chan ); // ain -> nom's

    cmDspSysInstallCb1N1NM(   h, ptIn, "b-out", ctx->iChCnt, desc[i].nom, "b-in", desc[i].chCnt, desc[i].chan ); // EF -> nom (gate)
    cmDspSysInstallCb1N1NM(   h, ptIn, "f-out", ctx->iChCnt, desc[i].nom, "f-in", desc[i].chCnt, desc[i].chan ); // EF -> nom (level)

    cmDspSysConnectAudio1NN1(h, desc[i].nom, "a-out", p->ch[i].mix,  "in",   desc[i].chCnt );   // nom -> chain sg/ain mixer (audio)
    cmDspSysInstallCb1NN1(   h, desc[i].nom, "b-out", p->ch[i].adsr, "gate", desc[i].chCnt );   // nom -> chain adsr (gate)
    cmDspSysInstallCb1NN1(   h, desc[i].nom, "f-out", p->ch[i].tmop, "in-0", desc[i].chCnt );   // nom -> chain adsr (tscale)
    cmDspSysInstallCb1NN1(   h, desc[i].nom, "f-out", p->ch[i].amop, "in-0", desc[i].chCnt );   // nom -> chain adsr (ascale)

    cmDspSysInstallCb(       h, btn,      "sym", desc[i].nom, "cmd",  NULL );
    cmDspSysInstallCb(       h, nomXfade, "val", desc[i].nom, "ms",   NULL );

    cmDspSysConnectAudioN1N1( h, p->ch[i].mt,   "out", desc[i].envm, "in",                     desc[i].chCnt ); // chain aout  -> mtr
    cmDspSysConnectAudio11N1( h, p->ch[i].mixo, "out", p->c.aout,    formLabel(h,"in",  i-ii), ctx->oChCnt);    // chain aout  -> mix out
    cmDspSysInstallCb11N1(    h, desc[i].ogain, "val", p->c.aout,    formLabel(h,"gain",i-ii), ctx->oChCnt);    // chain ogain -> mix gain

    // reset the chain - (called by the master 'reset' button)
    cmDspSysInstallCb( h, selChk, "out", p->ch[i].start, "send", NULL );

  }

  // local note-select to remote 'nom' connections
  if( cdIsLocalFl )
  {
    for(i=cd1ChainCnto2; i<cd1ChainCnt; ++i)
    {
      // NS -> nom's (selectors and done trigger)
      cmDspSysInstallNetCb1N1N( h, ns,  formLabel(h,"gate",i), nonCdNetNodeLabel, cmTsPrintfS("nom-%i",i), "sel",  0, desc[i].chCnt );
      cmDspSysInstallNetCb(     h, ns,  "done",                nonCdNetNodeLabel, cmTsPrintfS("nom-%i",i), "cmd"  );        

      // NS -> meters 
      unsigned map[ ctx->iChCnt ];
      cmVOU_AddVVS(map,ctx->iChCnt,desc[i].chan,ctx->iChCnt );
      cmDspSysInstallCb1NN1M2(   h, ns,  formLabel(h,"gate",i), desc[i].chCnt, map, desc[i-cd1ChainCnto2].mtr, "in", cdChCnt ); 

    }
    
  }
 errLabel:

  cmDspSysRemoveInstAttrSymbol(h,p->c.circuitSymId);

  return rc;
}

//=====================================================================================================================
typedef struct
{
  cmDspInst_t* phs;
  cmDspInst_t* wt;
  cmDspInst_t* sel;
  cmDspInst_t* bts;
  cmDspInst_t* gain;
} cmDspPP_Fp_t;

cmDspRC_t _cmDspPP_FilePlayer( 
    cmDspSysH_t     h, 
    const cmChar_t* fn,
    const cmChar_t* label,
    cmDspPP_Fp_t*   p
)
{
  cmDspRC_t rc         = kOkDspRC;
  int       wtPlayCnt  = 1;
  int       wtMode     = 1;     // file
  int       wtBeg      = 0;
  int       wtEnd      = -1;
  unsigned  wtOffSymId = cmDspSysRegisterStaticSymbol(h,"off");
  bool      selFl      = false;

  p->sel  =  cmDspSysAllocCheck( h,label,selFl);

  p->phs  =  cmDspSysAllocInst(  h,"Phasor",   NULL,  0 );
  p->wt   =  cmDspSysAllocInst(  h,"WaveTable",NULL,  7, ((int)cmDspSysSampleRate(h)), wtMode, fn, wtPlayCnt, wtBeg, wtEnd, wtOffSymId );
  p->bts  =  cmDspSysAllocInst(  h,"GateToSym", NULL, 0 );
  p->gain =  cmDspSysAllocScalar(h,NULL,0.0,10.0,0.01,1.0);

  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  cmDspSysConnectAudio(h,p->phs,"out",p->wt,"phs");

  cmDspSysInstallCb( h, p->sel, "out", p->bts, "both", NULL );
  cmDspSysInstallCb( h, p->bts, "out", p->wt,  "cmd", NULL );
  cmDspSysInstallCb( h, p->sel, "out", p->phs, "phs", NULL );

 errLabel:
  return rc;
}

typedef struct
{
  cmDspPP_Circuit_t   c;
} cmDspPP_Sp0_t;


cmDspRC_t _cmDspPP_SmpPlayAlloc(
  cmDspSysH_t     h, 
  _cmDspPP_Ctx_t* ctx,   
  cmDspPP_Sp0_t*  p,
  const cmChar_t* title,
  const cmChar_t* preLbl,
  cmDspInst_t*    selChk,
  cmDspInst_t**   ain,
  cmDspInst_t*    ptIn,
  const cmChar_t** fnArray,
  const cmChar_t** titleArray,
  unsigned         fnCnt )
{
  cmDspRC_t rc;
  unsigned i,j;

  cmDspPP_Fp_t fp[ fnCnt ];

  p->c.circuitSymId     = cmDspSysRegisterInstAttrSymbolStr(h,title);
  unsigned    presetGroupSymId = cmDspSysPresetRegisterGroup(h,title);
  _cmDspSys_PresetMgmt(h,preLbl,presetGroupSymId);
  cmDspSysNewColumn(h,COL_WIDTH);

  // make sample players
  for(i=0; i<fnCnt; ++i)
  {
    if((rc = _cmDspPP_FilePlayer(h, fnArray[i], titleArray[i], fp + i )) != kOkDspRC )
      break;
  }

  // make processors for each output channel
  p->c.aout = cmDspSysAllocInstArray( h, ctx->oChCnt, "AMix", NULL, NULL, 1, fnCnt );
  p->c.aoutLbl = "out";
  
  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  for(i=0; i<ctx->oChCnt; ++i)
    for(j=0; j<fnCnt; ++j)
    {
      cmDspSysConnectAudio(h, fp[j].wt,   "out", p->c.aout[i], formLabel(h,"in",j) );
      cmDspSysInstallCb(   h, fp[j].gain, "val", p->c.aout[i], formLabel(h,"gain",j), NULL);
    }

 errLabel:

  cmDspSysRemoveInstAttrSymbol(h,p->c.circuitSymId);

  return rc;

}

//=====================================================================================================================
typedef struct
{
  cmDspPP_Circuit_t   c;
  cmDspFx0_Chain_t    fx0;
  cmDspFx0_Chain_t    fx1;
} cmDspPP_Gliss_t;


cmDspRC_t _cmDspPP_GlissAlloc(
  cmDspSysH_t              h, 
  _cmDspPP_Ctx_t*          ctx,   
  cmDspPP_Gliss_t*   p,
  const cmChar_t*          title,
  const cmChar_t*          preLbl,
  cmDspInst_t*             selChk,
  cmDspInst_t**            ain,
  cmDspInst_t*             ptIn )
{
  cmDspRC_t rc;
  const cmChar_t* glissChIdxRsrcStr = "glissChIdx";
  const cmChar_t* glissPitchRsrcStr = "glissPitch";
  const cmChar_t* glissSlineRsrcStr = "glissSline";
  unsigned        chCnt = 0;
  unsigned        i ;

  p->c.circuitSymId     = cmDspSysRegisterInstAttrSymbolStr(h,title);
  unsigned    presetGroupSymId = cmDspSysPresetRegisterGroup(h,title);
  _cmDspSys_PresetMgmt(h,preLbl,presetGroupSymId);
  cmDspSysNewColumn(h,COL_WIDTH);

  p->c.aout  = allocInstPtrArray(h, ctx->oChCnt);

  // get the active channel list (indexes of the input channels which will be used by glisser);
  if( cmDspRsrcArrayCount( h, &chCnt, glissChIdxRsrcStr, NULL ) != kOkDspRC )
    return cmErrMsg(ctx->err,kPgmCfgFailDspRC,"The noise shaper channel index list '%s' could not be read.",cmStringNullGuard(glissChIdxRsrcStr));

  cmDspInst_t*  print  = cmDspSysAllocInst(      h, "Printer",   NULL, 0 );
  cmDspInst_t*  nom    = cmDspSysAllocInst(      h, "NofM",      NULL, 2, ctx->iChCnt, chCnt );  
  cmDspInst_t*  pts    = cmDspSysAllocInst(      h, "PortToSym", NULL, 2, "off", "send" );
  cmDspInst_t*  pitarr = cmDspSysAllocInst(      h, "Array",     NULL, 1, glissPitchRsrcStr );
  cmDspInst_t*  charr  = cmDspSysAllocInst(      h, "Array",     NULL, 1, glissChIdxRsrcStr );
  cmDspInst_t** gts    = cmDspSysAllocInstArray( h, chCnt, "GateToSym", NULL, NULL, 0 );
  cmDspInst_t** pcvt   = cmDspSysAllocInstArray( h, chCnt, "PitchCvt",  NULL, NULL, 0 );
  

  cmDspInst_t** sline = allocInstPtrArray(h, chCnt);
  for(i=0; i<chCnt; ++i)
    sline[i] = cmDspSysAllocInst( h, "SegLine", NULL, 1, formLabel(h,glissSlineRsrcStr,i) );


  if((rc = _cmDspFx0_ChainAlloc(h,ctx->err, presetGroupSymId, formLabel(h,preLbl,0), glissPitchRsrcStr, chCnt, &p->fx0)) != kOkDspRC )
    goto errLabel;

  cmDspSysNewPage(h,"G-Thru");

  if((rc = _cmDspFx0_ChainAlloc(h,ctx->err, presetGroupSymId, formLabel(h,preLbl,1), glissPitchRsrcStr, chCnt, &p->fx1)) != kOkDspRC )
    goto errLabel;

  cmDspInst_t** mix  = cmDspSysAllocInstArray( h, chCnt, "AMix", NULL, NULL, 1, 2 );

  p->c.aout = cmDspSysAllocInstArray( h, ctx->iChCnt, "AMix", NULL, NULL, 1, chCnt );
  p->c.aoutLbl = "out";

  // check for allocation errors
  if((rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  // selChk is the circuit selector check box in the main window
  cmDspSysInstallCb(       h, selChk, "out",      pts,    "off",  NULL );  // First send 'off' to nom to clear its selector
  cmDspSysInstallCb(       h, selChk, "out",      pts,    "send", NULL );  // Second send 'send' to charr to select active ports on nom.
  cmDspSysInstallCb(       h, pts,    "off",      nom,    "cmd",  NULL );  // Clear the nom (all inputs are turned off)
  cmDspSysInstallCb(       h, pts,    "send",     charr,  "cmd",  NULL );  // Send the active channel indexes to the nom
  cmDspSysInstallCb(       h, pts,    "send",     pitarr, "cmd",  NULL );  // Send the pitch values to the circuits (eq,cf,sg,..)
  cmDspSysInstallCb11N1(   h, pts,    "send",     sline,  "cmd",  chCnt );
  cmDspSysInstallCb(       h, charr,  "done",     nom,    "cmd",  NULL );  // Tell the nom when its setup is complete

  cmDspSysInstallCb1N11(   h, charr,  "out",      nom,    "seli", chCnt );        // EF nom channel index selectors 
  cmDspSysConnectAudioN11N(h, ain,    "out",      nom,    "a-in", ctx->iChCnt );  // ain -> nom 
  cmDspSysInstallCb1N1N(   h, ptIn,   "b-out",    nom,    "b-in", ctx->iChCnt );  // EF -> nom (gates)
  cmDspSysInstallCb1N1N(   h, ptIn,   "f-out",    nom,    "f-in", ctx->iChCnt );  // EF -> nom (level)
  cmDspSysInstallCb1NN1(   h, pitarr, "out",      pcvt,   "midi", chCnt );        // pitch array -> pitch converter

  cmDspSysInstallCb1NN1(   h, nom,    "b-out",    gts,      "on",   chCnt );      
  cmDspSysInstallCbN1N1(   h, gts,    "out",      sline,    "trig", chCnt );
  cmDspSysInstallCbN1N1(   h, sline,  "out",      pcvt,     "offs", chCnt );
  cmDspSysInstallCbN1N1(   h, pcvt,   "ratio",    p->fx0.ps,"ratio",chCnt );

  cmDspSysInstallCbN111(   h, sline, "out", print, "in", chCnt );


  cmDspSysConnectAudio1NN1( h, nom, "a-out",  p->fx0.mix,   "in",    chCnt );   // ain -> sg/ain mixer
  cmDspSysInstallCb1NN1(    h, nom, "b-out",  p->fx0.adsr,  "gate",  chCnt );   // gate -> adsr
  cmDspSysInstallCb1NN1(    h, nom, "f-out",  p->fx0.tmop,  "in-0",  chCnt );   // level ->adsr (tscale)
  cmDspSysInstallCb1NN1(    h, nom, "f-out",  p->fx0.amop,  "in-0",  chCnt );   // level ->adsr (ascale)

  cmDspSysConnectAudio1NN1( h, nom, "a-out",  p->fx1.mix,   "in",    chCnt );   // ain -> sg/ain mixer
  cmDspSysInstallCb1NN1(    h, nom, "b-out",  p->fx1.adsr,  "gate",  chCnt );   // gate -> adsr
  cmDspSysInstallCb1NN1(    h, nom, "f-out",  p->fx1.tmop,  "in-0",  chCnt );   // level ->adsr (tscale)
  cmDspSysInstallCb1NN1(    h, nom, "f-out",  p->fx1.amop,  "in-0",  chCnt );   // level ->adsr (ascale)

  cmDspSysConnectAudioN1N1( h, p->fx0.mt, "out", mix, "in-0", chCnt );
  cmDspSysConnectAudioN1N1( h, p->fx1.mt, "out", mix, "in-1", chCnt );

  for( i=0; i<ctx->oChCnt; ++i)
  {
    cmDspSysConnectAudioN11N(h, mix, "out", p->c.aout[i], "in", chCnt ); 
  }

  // reset the chain - called by the master 'reset' button
  cmDspSysInstallCb( h, selChk, "out", p->fx0.start, "send", NULL );
  cmDspSysInstallCb( h, selChk, "out", p->fx1.start, "send", NULL );
  
 errLabel:

  cmDspSysRemoveInstAttrSymbol(h,p->c.circuitSymId);

  return rc;

}

//=====================================================================================================================
_cmDspPP_CircDesc_t _cmDspPP_CircDescArray[] =
{
  { "Test","      tc"  },
  { "N Shaper",   "ns"  },
  { "Fx0",            "fx0" },
  { "Smp Play",    "sp"  },
  { "CD",             "cd"  },
  { "Net CD", "ncd" },
  { "Gliss",          "gss" }
};

unsigned                  _cmDspPP_CircuitDescCount()
{
  return sizeof(_cmDspPP_CircDescArray)/sizeof(_cmDspPP_CircDescArray[0]);
}

const _cmDspPP_CircDesc_t* _cmDspPP_CircuitDesc( unsigned idx )
{ 
  assert(idx < _cmDspPP_CircuitDescCount());
  return _cmDspPP_CircDescArray + idx;
}


cmDspRC_t _cmDspPP_CircuitSwitchAlloc( 
  cmDspSysH_t              h, 
  _cmDspPP_Ctx_t*          ctx, 
  cmDspPP_CircuitSwitch_t* p, 
  cmDspInst_t*             reset,
  cmDspInst_t**            sel,
  cmDspInst_t**            ain, 
  cmDspInst_t**            ef  )
{
  cmDspRC_t rc      = kOkDspRC;
  double    xfadeMs = 50.0;
  unsigned  enaSym  = cmDspSysRegisterStaticSymbol(h,"_enable");
  unsigned  disSym  = cmDspSysRegisterStaticSymbol(h,"_disable");
  unsigned  i;

  cmDspPP_TestCircuit_t Tst; memset(&Tst,0,sizeof(Tst));
  cmDspPP_NSh_Circuit_t NSh; memset(&NSh,0,sizeof(NSh));
  cmDspPP_Fx0_t         Fx0; memset(&Fx0,0,sizeof(Fx0));
  cmDspPP_Cd0_t         Cd0; memset(&Cd0,0,sizeof(Cd0));
  cmDspPP_Cd1_t         Cd1; memset(&Cd1,0,sizeof(Cd1));
  cmDspPP_Sp0_t         Sp0; memset(&Sp0,0,sizeof(Sp0));
  cmDspPP_Gliss_t       Gls; memset(&Gls,0,sizeof(Gls));

  const cmChar_t* spFnArr[] = 
  {
    "/home/kevin/media/audio/PP/Siren Blast 2 Peaking.wav",
    "/home/kevin/media/audio/PP/Siren Blast 2.wav"
  };

  const cmChar_t* spLblArr[] = 
  {
    "File 0",
    "File 1"
  };

  unsigned spCnt  = sizeof(spFnArr)  / sizeof(spFnArr[0]);
  unsigned splCnt = sizeof(spLblArr) / sizeof(spLblArr[0]);
  assert( spCnt == splCnt );


  p->circuitCnt = _cmDspPP_CircuitDescCount();

  cmDspInst_t*       ofd[  p->circuitCnt ];
  cmDspPP_Circuit_t* carr[ p->circuitCnt ];

   cmDspInst_t** mxm     = cmDspSysAllocInstArray(h,ctx->oChCnt,"AMeter", NULL, NULL, 3, 0.0, 0.0, 1.0 );

  for(i = 0; rc==kOkDspRC && i<p->circuitCnt; ++i)
  {

    const cmChar_t* title  =  _cmDspPP_CircDescArray[i].title;
    const cmChar_t* preLbl =  _cmDspPP_CircDescArray[i].preLbl;

    cmDspSysNewPage(h, title );

    carr[i] = NULL;

    // allocate the input switches for this circuit
    cmDspInst_t* bts      = cmDspSysAllocInst(h,"GateToSym", NULL, 0 );
    cmDspInst_t* bts_ena  = cmDspSysAllocInst(h,"GateToSym", NULL, 2, enaSym, disSym );
    cmDspInst_t* ipt      = cmDspSysAllocInst(h,"NofM",      NULL, 2, ctx->iChCnt, ctx->iChCnt   );

    // allocate the circuits
    switch( i )
    {
      case 0:
        if((rc = _cmDspPP_TestCircuitAlloc(h,ctx,&Tst,title,preLbl,sel[i],ain,ipt)) == kOkDspRC )
          carr[i] = &Tst.c;
        break;

      case 1:
        if((rc =  _cmDspPP_NoiseShaperAlloc(h,ctx->err,&NSh,title,preLbl,sel[i],ipt,ctx->iChCnt,ctx->oChCnt)) == kOkDspRC )
          carr[i] = &NSh.c;
        break;

      case 2:
        if((rc =_cmDspPP_Fx0Alloc(h,ctx,&Fx0,title,preLbl,sel[i],ain,ipt)) == kOkDspRC )
          carr[i] = &Fx0.c;
        break;

      case 3:
        if((rc =_cmDspPP_SmpPlayAlloc(h,ctx,&Sp0,title,preLbl,sel[i],ain,ipt,spFnArr,spLblArr,spCnt)) == kOkDspRC )
          carr[i] = &Sp0.c;
        break;

      case 4:
        if((rc =_cmDspPP_Cd0Alloc(h,ctx,&Cd0,title,preLbl,sel[i],ain,ipt)) == kOkDspRC )
          carr[i] = &Cd0.c;
        break;
        
      case 5:
        if((rc = _cmDspPP_Cd1Alloc(h,ctx,&Cd1,title,preLbl,sel[i],ain,ipt)) == kOkDspRC )
          carr[i] = &Cd1.c;
        break;

      case 6:
        if((rc = _cmDspPP_GlissAlloc(h,ctx,&Gls,title,preLbl,sel[i],ain,ipt)) == kOkDspRC )
          carr[i] = &Gls.c;
        break;
        
      default:
        { assert(0); }
    }

    if( rc == kOkDspRC && carr[i] != NULL )
    {
      printf("title:%s circuit sym id:%i\n",title,carr[i]->circuitSymId);

      cmDspInst_t* pts_dis  = cmDspSysAllocInst( h, "PortToSym", NULL,  1, "_disable");
      cmDspInst_t* bcast    = cmDspSysAllocInst( h, "BcastSym",   NULL, 1, carr[i]->circuitSymId );
      ofd[i]                = cmDspSysAllocInst( h, "Xfader",     NULL, 2, ctx->oChCnt, xfadeMs );
      cmDspSysNewColumn(h,COL_WIDTH);
      cmDspInst_t** fdm     = cmDspSysAllocInstArray(h,ctx->oChCnt,"AMeter", NULL, NULL, 3, 0.0, 0.0, 1.0 );
      
      // check for allocation errors
      if((rc = cmDspSysLastRC(h)) != kOkDspRC )
        goto errLabel;

      cmDspSysConnectAudio1NN1( h, ofd[i], "out", fdm, "in", ctx->oChCnt ); // fdr -> meter
      
      cmDspSysInstallCb(    h, sel[i], "out", bts,       "both",    NULL );  // Convert circuit selection gate to 'on'/'off' symbols
      cmDspSysInstallCb(    h, bts,    "out", ipt,       "cmd",     NULL );  // send 'on'/'off' to this circuits Gate/RMS switch

      cmDspSysInstallCb(    h, sel[i], "out", bts_ena,   "both",    NULL );  // Convert circuit selection gate to '_enable/_disable' symbols
      cmDspSysInstallCb(    h, bts_ena,"out", bcast,     "msg",     NULL );  // send '_enable/_disable' to this circuits instances.

      cmDspSysInstallCb(    h, reset,  "out", pts_dis,   "_disable",NULL );  // Convert 'reset' button output to '_disable' symbol
      cmDspSysInstallCb(    h, ofd[i], "off", pts_dis,   "_disable",NULL );  // Convert circuit output fader 'off' event to '_disable' symbol.
      cmDspSysInstallCb(    h, pts_dis,"out", bcast,     "msg",     NULL );  // Bcast _disable symbol generated from 'reset' btn or fader 'off'
    
      cmDspSysInstallCb(    h, sel[i], "out", ofd[i],    "mgate", NULL );   // Convert circuit selection gate to master fader gate 'on'/'off' msg's

      cmDspSysInstallCbN11N( h, ef,   "gate",  ipt,      "b-in", ctx->iChCnt );  // EF -> circuit (gate) pass-through
      cmDspSysInstallCbN11N( h, ef,   "level", ipt,      "f-in", ctx->iChCnt );  // EF -> circuit (RMS)  pass-through

    }

  }

  p->omix = cmDspSysAllocInstArray(h,ctx->oChCnt,"AMix",NULL,NULL,1,p->circuitCnt);

   // check for allocation errors
  if(rc!=kOkDspRC || (rc = cmDspSysLastRC(h)) != kOkDspRC )
    goto errLabel;

  for(i=0; i<p->circuitCnt; ++i)
  {
    unsigned j;
    for(j=0; j<ctx->oChCnt; ++j)
      if( carr[i] != NULL && carr[i]->aout != NULL && carr[i]->aout[j] != NULL )
      {
        // circuit-> out fader
        cmDspSysConnectAudio( h, carr[i]->aout[j], carr[i]->aoutLbl, ofd[i], cmDspSysPrintLabel("in",j) ); 

        // out fader -> mixer
        cmDspSysConnectAudio( h, ofd[i], cmDspSysPrintLabel("out",j), p->omix[j], cmDspSysPrintLabel2("in",i) );
      }

  }

  cmDspSysConnectAudioN1N1( h, p->omix, "out", mxm, "in", ctx->oChCnt );  // mix -> meters

 errLabel:


  return rc;
}

cmDspRC_t _cmDspPP_CircuitSwitchFree(  cmDspSysH_t h, cmDspPP_CircuitSwitch_t* p)
{
  return kOkDspRC;
}