cmProc4.h/c, cmDspKr.c : Initial changes to support scMod 'in' and 'cross'.

cmProc4.c

   { kSetLineModTId, 3, "sline" },
   { kPostModTId,    4, "post"  },
   { kExecModTId,    5, "exec"  },
+  { kInputModTId,   6, "input" },
+  { kCrossModTId,   7, "cross" },
   { kInvalidModTId, 0, "<invalid>"}
 };
 
   {
     vp = cmMemAllocZ(cmScModVar_t,1);
     vp->varSymId = varSymId;
-    vp->outVarId = cmInvalidId;
+    vp->varId = cmInvalidId;
     vp->vlink    = p->vlist;
     p->vlist     = vp;
   }
 
   g->earray[idx].scLocIdx = scLocIdx;
   g->earray[idx].typeId   = typeId;
-  g->earray[idx].varPtr   = _cmScModulatorInsertVar(p,varSymId,0);
-
-  if( g->earray[idx].varPtr->outVarId == cmInvalidIdx )
-    g->earray[idx].varPtr->outVarId = p->outVarCnt++;
 
   return g->earray + idx;
 }
 
-
 /*
 {
   [
 }
 
 
+
+// If the requested parameter has a value then return it in *valPtr.
+// If it does not then do nothing. This function applies scaling to RHS values.
+cmRC_t  _cmScModGetParam( cmScModulator* p, const cmScModParam_t* pp, double* valPtr )
+{
+  cmRC_t rc = cmOkRC;
+
+  switch( pp->pid )
+  {
+    case kInvalidModPId:
+      rc  = cmCtxRtCondition( &p->obj, cmInvalidArgRC, "An invalid parameter was encountered.");
+      goto errLabel;
+      break;
+
+    case kLiteralModPId:
+      *valPtr = pp->val;
+      break;
+
+    case kSymbolModPId:
+      {
+        cmScModVar_t* vp;
+
+        // get a pointer to the parameter variable
+        if((vp = _cmScModSymToVar(p, pp->symId )) == NULL )
+        {
+          rc  = cmCtxRtCondition( &p->obj, cmInvalidArgRC, "Variable '%s' not found.",cmSymTblLabel(p->stH,pp->symId));    
+          goto errLabel;
+        } 
+
+        // if this is not a 'calculated' paramter then scale it here.
+        if( cmIsFlag(vp->flags,kCalcModFl ) && vp->min!=DBL_MAX && vp->max!=DBL_MAX )
+          *valPtr = (vp->value - vp->min)/(vp->max-vp->min);
+        else
+          *valPtr = vp->value;
+      }
+      break;
+
+    default:
+      { assert(0); }
+  }
+
+ errLabel:
+  return rc;
+}
+
+void _cmScModDumpParam( cmScModulator* p, const cmChar_t* label, const cmScModParam_t* pp )
+{
+  printf("%s: ",label);
+
+  switch( pp->pid )
+  {
+    case kInvalidModPId:
+      printf("<invalid>");
+      break;
+
+    case kLiteralModPId:
+      if( pp->val == DBL_MAX )
+        printf("<max> ");
+      else
+        printf("%f ",pp->val);
+      break;
+
+    case kSymbolModPId:
+      printf("%s ",cmSymTblLabel(p->stH,pp->symId));
+      break;
+
+    default:
+      { assert(0); }
+  }
+}
+
+void _cmScModDumpVal( cmChar_t* label, double val )
+{
+  printf("%s:",label);
+
+  if( val == DBL_MAX )
+    printf("<max> " );
+  else
+    printf("%f ",val);
+}
+
+
+void _cmScModDumpVar( cmScModulator* p, const cmScModVar_t* vp )
+{
+   printf("%7s %3i fl:0x%x entry:%p alink:%p %s",cmSymTblLabel(p->stH,vp->varSymId),vp->varId,vp->flags,vp->entry,vp->alink, cmIsFlag(vp->flags,kInputModFl)?"input":"");
+    _cmScModDumpVal("val",vp->value);
+    _cmScModDumpVal("min",vp->min);
+    _cmScModDumpVal("max",vp->max);
+    _cmScModDumpVal("rate",vp->rate);
+    _cmScModDumpVal("v0",vp->v0);
+}
+
+void _cmScModDumpEntry( cmScModulator* p, const cmScModEntry_t* ep)
+{
+  const _cmScModTypeMap_t* tm = _cmScModTypeIdToMap( ep->typeId );
+
+  printf("%10i ",ep->scLocIdx);
+    
+  printf("%5s %7s", tm==NULL ? "invld" : tm->label, cmSymTblLabel(p->stH,ep->varPtr->varSymId));
+  _cmScModDumpParam(p," beg", &ep->beg);
+  _cmScModDumpParam(p," end", &ep->end);
+  _cmScModDumpParam(p," min", &ep->min);
+  _cmScModDumpParam(p," max", &ep->max);
+  _cmScModDumpParam(p," rate",&ep->rate);
+  printf("\n");
+  
+}
+
 cmRC_t _cmScModParseEntryGroup( cmScModulator* p, cmCtx_t* ctx, cmJsonH_t jsH, cmSymTblH_t stH, cmJsonNode_t* jnp, cmScModEntryGroup_t* g, const cmChar_t* fn )
 {
   cmRC_t          rc            = cmOkRC;
     // get the count of the elmenets in the data array
     unsigned paramCnt = cmJsonChildCount(onp);
 
+
     // fill the entry record and find or create the target var
     cmScModEntry_t* ep = _cmScModulatorInsertEntry(p,g,i,scLocIdx,varSymId,map->typeId,paramCnt);
 
+    
     typedef struct
     {
       const cmChar_t* label;
       { "val", &ep->beg },
       { "end", &ep->end },
       { "dur", &ep->dur },
+      { "arg", &ep->arg },
       { NULL, NULL }
     };
 
     for(j=0; mapArray[j].param!=NULL; ++j)
       if((dnp = cmJsonFindValue(jsH,mapArray[j].label, onp, kInvalidTId )) != NULL )
         if((rc = _cmScModulatorParseParam(p,stH,dnp,mapArray[j].param)) != cmOkRC )
-          goto errLabel;    
+          goto errLabel;
+
+    // create the variable associated with this entry
+    ep->varPtr = _cmScModulatorInsertVar(p,varSymId, ep->typeId==kInputModTId ? kInputModFl : 0);
+
+
+    // set the variable id value
+    if( ep->varPtr->varId == cmInvalidIdx )
+    {
+      if( ep->typeId != kInputModTId )
+        ep->varPtr->varId = p->outVarCnt++;
+      else
+        ep->varPtr->varId = p->inVarCnt++;
+    }
+    
   }
 
  errLabel:
   p->elist     = NULL;
   p->nei       = 0;
   p->outVarCnt = 0;
+  p->inVarCnt  = 0;
+  
   
   // reload the file
   if((rc = _cmScModulatorParse(p,ctx,p->stH,p->fn)) != cmOkRC )
   cmScModEntryGroup_t* g = p->glist;
   for(; g!=NULL; g=g->link)
     for(i=0; i<g->en; ++i)
-      if( g->earray[i].varPtr->outVarId == idx )
+      if( cmIsNotFlag(g->earray[i].varPtr->flags,kInputModFl) && g->earray[i].varPtr->varId == idx )
+        return g->earray[i].varPtr;
+
+  return NULL;  
+}
+
+unsigned        cmScModulatorInVarCount( cmScModulator* p )
+{ return p->inVarCnt; }
+
+cmScModVar_t* cmScModulatorInVar( cmScModulator* p, unsigned idx )
+{
+  unsigned i;
+  cmScModEntryGroup_t* g = p->glist;
+  for(; g!=NULL; g=g->link)
+    for(i=0; i<g->en; ++i)
+      if( cmIsFlag(g->earray[i].varPtr->flags,kInputModFl) && g->earray[i].varPtr->varId == idx )
         return g->earray[i].varPtr;
 
   return NULL;  
 }
 
-cmRC_t         cmScModulatorSetValue( cmScModulator* p, unsigned varSymId, double value, double min, double max )
+
+cmScModVar_t* _cmScModSetValuePrefix( cmScModulator* p, unsigned varSymId )
 {
   cmScModVar_t* vp;
   // if the var does not exist ....
     assert(vp!=NULL);    
   }
 
+  return vp;
+}
+
+
+cmRC_t         cmScModulatorSetValueMinMax( cmScModulator* p, unsigned varSymId, double value, double min, double max )
+{
+  cmScModVar_t* vp =  _cmScModSetValuePrefix(p, varSymId );
+  
   assert( min <= max);
 
   vp->min   = min;
   return cmOkRC;
 }
 
+cmRC_t         cmScModulatorSetValue( cmScModulator* p, unsigned varSymId, double value )
+{
+  cmScModVar_t* vp =  _cmScModSetValuePrefix(p, varSymId );
+  
+  vp->value = value;
+
+  return cmOkRC;
+}
+
 
 cmRC_t cmScModulatorReset( cmScModulator* p, cmCtx_t* ctx, unsigned scLocIdx, unsigned entryGroupSymId )
 {
   vp->entry = NULL;
 }
 
-// If the requested parameter has a value then return it in *valPtr.
-// If it does not then do nothing. This function applies scaling to RHS values.
-cmRC_t  _cmScModGetParam( cmScModulator* p, const cmScModParam_t* pp, double* valPtr )
-{
-  cmRC_t rc = cmOkRC;
-
-  switch( pp->pid )
-  {
-    case kInvalidModPId:
-      rc  = cmCtxRtCondition( &p->obj, cmInvalidArgRC, "An invalid parameter was encountered.");
-      goto errLabel;
-      break;
-
-    case kLiteralModPId:
-      *valPtr = pp->val;
-      break;
-
-    case kSymbolModPId:
-      {
-        cmScModVar_t* vp;
-
-        // get a pointer to the parameter variable
-        if((vp = _cmScModSymToVar(p, pp->symId )) == NULL )
-        {
-          rc  = cmCtxRtCondition( &p->obj, cmInvalidArgRC, "Variable '%s' not found.",cmSymTblLabel(p->stH,pp->symId));    
-          goto errLabel;
-        } 
-
-        // if this is not a 'calculated' paramter then scale it here.
-        if( cmIsFlag(vp->flags,kCalcModFl ) && vp->min!=DBL_MAX && vp->max!=DBL_MAX )
-          *valPtr = (vp->value - vp->min)/(vp->max-vp->min);
-        else
-          *valPtr = vp->value;
-      }
-      break;
-
-    default:
-      { assert(0); }
-  }
-
- errLabel:
-  return rc;
-}
-
 cmRC_t  _cmScModActivateEntries( cmScModulator* p, cmScModEntry_t* earray, unsigned* idxRef, unsigned cnt, unsigned scLocIdx );
 
 cmRC_t  _cmScModActivateGroup( cmScModulator* p, cmScModEntry_t* ep )
   return cmCtxRtCondition( &p->obj, cmInvalidArgRC, "Entry group '%s' not found.",cmSymTblLabel(p->stH,ep->beg.symId));    
 }
 
+
+cmRC_t _cmScModGetCrossParam( cmScModulator* p, cmScModEntry_t* ep, cmScModParam_t* pp, const cmChar_t* label, double* valRef )
+{
+  cmRC_t rc;
+  
+  if((rc = _cmScModGetParam(p, pp, valRef )) != cmOkRC )
+    rc = cmCtxRtCondition( &p->obj, cmInvalidArgRC, "Invalid %s parameter for cross variable:%s",label,cmSymTblLabel(p->stH,ep->varPtr->varSymId) );
+
+  return rc;
+  
+}
+
+cmRC_t _cmScModExecCross( cmScModulator* p, cmScModEntry_t* ep )
+{
+  cmRC_t rc = cmOkRC;
+  double x  = 0.0;
+  //double x0 = 0.0, x1 = 0.0;
+  double y0 = 0.0, y1 = 0.0;
+
+  if((rc = _cmScModGetCrossParam(p, ep, &ep->arg, "src var", &x )) != cmOkRC )
+    return rc;
+    
+  //if((rc = _cmScModGetCrossParam(p, ep, &ep->beg, "src min", &x0 )) != cmOkRC )
+  //  return rc;
+
+  //if((rc = _cmScModGetCrossParam(p, ep, &ep->end, "src max", &x1 )) != cmOkRC )
+  //  return rc;
+  
+  if((rc = _cmScModGetCrossParam(p, ep, &ep->min, "dst min", &y0 )) != cmOkRC )
+    return rc;
+  
+  if((rc = _cmScModGetCrossParam(p, ep, &ep->max, "dst max", &y1 )) != cmOkRC )
+    return rc;
+
+  //double xx = x0 + (x-x0) / (x1-x0);
+
+  printf("%s x:%f y0:%f y1:%f\n",__FUNCTION__,x,y0,y1);
+  
+  ep->varPtr->value =  y0 + x * (y1-y0);
+
+  return rc;  
+}
+
 // Type specific variable activation - 
 cmRC_t _cmScModActivate(cmScModulator* p, cmScModEntry_t* ep )
 {
       rc = _cmScModActivateGroup(p,ep);
       break;
 
+    case kInputModTId:
+      break;
+
+    case kCrossModTId:
+      break;
+
     default:
       { assert(0); }
   }
   return rc;
 }
 
+// Execute a variable.
 // Return true if vp should be deactivated otherwise return false.
 bool  _cmScModExec( cmScModulator* p, cmScModVar_t* vp )
 {
       
     case kSetModTId:
       {
+        // Get a new value for the variable *vp.
         if((rc = _cmScModGetParam(p,&vp->entry->beg,&vp->value)) != cmOkRC )
           goto errLabel;
         
         if((rc = _cmScModGetParam(p,&vp->entry->dur,&td)) != cmOkRC) 
           goto errLabel;
 
+        // update the value of the var *vp
         double v  = vp->v0 + (v1-vp->v0) * (vp->phase * p->samplesPerCycle) / (p->srate * td);        
 
         if((fl =  (vp->value <= v1 && v >= v1) || (vp->value >= v1 && v <= v1 )) == true )
       sendFl = false;
       break;
 
+    case kInputModTId:
+      sendFl = false;
+      break;
+      
+    case kCrossModTId:
+      _cmScModExecCross(p,vp->entry);
+      vp->phase = 0; // force the value to be sent
+      fl = true;
+      break;
+      
     default:
       { assert(0); }
   }
 }
 
 
-void _cmScModDumpParam( cmScModulator* p, const cmChar_t* label, cmScModParam_t* pp )
-{
-  printf("%s: ",label);
-
-  switch( pp->pid )
-  {
-    case kInvalidModPId:
-      printf("<invalid>");
-      break;
-
-    case kLiteralModPId:
-      if( pp->val == DBL_MAX )
-        printf("<max> ");
-      else
-        printf("%f ",pp->val);
-      break;
-
-    case kSymbolModPId:
-      printf("%s ",cmSymTblLabel(p->stH,pp->symId));
-      break;
-
-    default:
-      { assert(0); }
-  }
-}
-
-void _cmScModDumpVal( cmChar_t* label, double val )
-{
-  printf("%s:",label);
-
-  if( val == DBL_MAX )
-    printf("<max> " );
-  else
-    printf("%f ",val);
-}
-
-void _cmScModDumpVar( cmScModulator* p, const cmScModVar_t* vp )
-{
-    printf("%7s %3i fl:0x%x entry:%p alink:%p ",cmSymTblLabel(p->stH,vp->varSymId),vp->outVarId,vp->flags,vp->entry,vp->alink);
-    _cmScModDumpVal("val",vp->value);
-    _cmScModDumpVal("min",vp->min);
-    _cmScModDumpVal("max",vp->max);
-    _cmScModDumpVal("rate",vp->rate);
-    _cmScModDumpVal("v0",vp->v0);
-}
 
 cmRC_t  cmScModulatorDump(  cmScModulator* p )
 {
   cmRC_t rc = cmOkRC;
 
   printf("MOD:\n");
-  printf("nei:%i alist:%p outVarCnt:%i\n",p->nei,p->alist,p->outVarCnt);
+  printf("nei:%i alist:%p outVarCnt:%i inVarCnt:%i\n",p->nei,p->alist,p->outVarCnt,p->inVarCnt);
 
   printf("ENTRIES:\n");
   cmScModEntryGroup_t* g = p->glist;
     for(i=0; i<g->en; ++i)
     {
       cmScModEntry_t* ep = g->earray + i;
-      const _cmScModTypeMap_t* tm = _cmScModTypeIdToMap( ep->typeId );
-
       printf("%3i ",i);
-
-      printf("%10i ",ep->scLocIdx);
-    
-      printf("%5s %7s", tm==NULL ? "invld" : tm->label, cmSymTblLabel(p->stH,ep->varPtr->varSymId));
-      _cmScModDumpParam(p," beg", &ep->beg);
-      _cmScModDumpParam(p," end", &ep->end);
-      _cmScModDumpParam(p," min", &ep->min);
-      _cmScModDumpParam(p," max", &ep->max);
-      _cmScModDumpParam(p," rate",&ep->rate);
-      printf("\n");
+      
+      _cmScModDumpEntry(p,ep);
     }
   }
   

cmProc4.h

 
   //( { label:cmScMod file_desc:"Store and recall parameter information under score follower control." kw:[proc] } 
   /*
+
+    File format:
+    {
+      entry_group_label :
+      [
+        <loc> <mod> <var> <type> <params>    // entry record
+      ]
+    }
+
+
     Syntax: <loc> <mod> <var> <type>   <params>
     <loc> - score location
     <mod> - name of the modulator 
     <var> - variable name 
-    <type> - type of operation
+    <type> - type of operation (see Types: note below)
 
     <params>
 
     <val>  - type dependent value - see 'Types' below.  
     <end>  - ending value for a ramping variable
     <dur>  - determines the length of time to get to the ending value
+    <in>   - set to '1' to indicate that this is an input variable
 
     The value of parameters may be literal numeric values or may refer to
     variables by their name.
     sline  = set <var> to <val> and ramp to <end> over <dur> seconds
     post   = send a 'post' msg after each transmission (can be used to change the cross-fader after each msg)
     exec   = execute the entry group <val>
+    input  = declare an 'input' variable and set its <min> and <max>.
+    cross  = generate an output value by interpolating between two preset values.
 
   */
   enum
     kLineModTId,     // linear ramp variable to parray[0] over parray[1] seconds
     kSetLineModTId,  // set variable to parray[0] and ramp to parray[1] over parray[2] seconds
     kPostModTId,     //
-    kExecModTId      // execute an entry group 
+    kExecModTId,     // execute an entry group
+    kInputModTId,    // This is an 'input' variable.
+    kCrossModTId     // generate an output value by interpolating between two preset variable values
   };
 
   enum
   {
     kActiveModFl = 0x01,  // this variable is on the 'active' list
-    kCalcModFl   = 0x02   // when this variable is used as a parameter it's value must be calculated rather than used directly.
+    kCalcModFl   = 0x02,  // when this variable is used as a parameter it's value must be calculated rather than used directly.
+    kInputModFl  = 0x04   // this is an input variable
   };
 
   struct cmScModEntry_str;
     double       val;     // value of literals
   } cmScModParam_t;
 
+  // cmScModVar_t is used to track the value of a variable.
   typedef struct cmScModVar_str
   {
     unsigned                 flags;    // see kXXXModFl flags above.
     unsigned                 varSymId; // variable name 
-    unsigned                 outVarId; // output var id
+    unsigned                 varId;    // var id
     double                   value;    // current value of this variable
     double                   v0;       // reserved internal variable
     unsigned                 phase;    // cycle phase since activation  
     cmScModParam_t min;           // min value for this variable
     cmScModParam_t max;           // max value for this variable
     cmScModParam_t rate;          // update rate in milliseconds (DBL_MAX to disable)
+    cmScModParam_t arg;           // cross input variable
     cmScModVar_t*  varPtr;        // target variable 
   } cmScModEntry_t;
 
     cmScModVar_t*   vlist;        // variable list
     cmScModVar_t*   alist;        // active variable list
     cmScModVar_t*   elist;        // last element on the active list
-    unsigned        nei;          // next entry index
+    unsigned        nei;          // next entry index in xlist->earray[] to examine for activation
     unsigned        outVarCnt;    // count of unique vars that are targets of entry recds
+    unsigned        inVarCnt;     
     bool            postFl;       // send a 'post' msg after each transmission
-    cmScModEntryGroup_t* xlist;
-    cmScModEntryGroup_t* glist;
+    cmScModEntryGroup_t* xlist;   // entry group to execute
+    cmScModEntryGroup_t* glist;   // entry group list
   } cmScModulator;
 
 
   unsigned       cmScModulatorOutVarCount( cmScModulator* p );
 
   // Return a pointer to the variable at vlist[idx].
-  cmScModVar_t*  cmScModulatorOutVar( cmScModulator* p, unsigned idx ); 
+  cmScModVar_t*  cmScModulatorOutVar( cmScModulator* p, unsigned idx );
+
+  unsigned       cmScModulatorInVarCount( cmScModulator* p );
+  cmScModVar_t*  cmScModulatorInVar( cmScModulator* p, unsigned idx );
+  
 
-  cmRC_t         cmScModulatorSetValue( cmScModulator* p, unsigned varSymId, double value, double min, double max );
+  cmRC_t         cmScModulatorSetValueMinMax( cmScModulator* p, unsigned varSymId, double value, double min, double max );
+  cmRC_t         cmScModulatorSetValue(       cmScModulator* p, unsigned varSymId, double value );
 
   cmRC_t         cmScModulatorReset( cmScModulator* p, cmCtx_t* ctx, unsigned scLocIdx, unsigned entryGroupSymId );
   cmRC_t         cmScModulatorExec(  cmScModulator* p, unsigned scLocIdx );

dsp/cmDspKr.c

         cmDsvSetDouble(&vv,ap->sfp->smp->set[i].value);
         cmDsvSetDouble(&cv,ap->sfp->smp->set[i].match_cost);
 
+               
         for(j=0; j<ap->sfp->smp->set[i].sp->sectCnt; ++j)
         {
           cmDspStoreSetValueViaSym(ap->ctx->dsH, ap->sfp->smp->set[i].sp->symArray[j], &vv );
   cmDspRC_t     rc;
   if((rc = cmDspApplyAllDefaults(ctx,inst)) != kOkDspRC )
     return rc;
-
+  
   return _cmDspScFolOpenScore(ctx,inst);
 }
 
   unsigned       offSymId;
   unsigned       postSymId;
   unsigned       dumpSymId;
+  unsigned       minInVarId;
+  unsigned       maxInVarId;
+  unsigned*      inVarIdMap;
+  unsigned       inVarIdOffs;
 } cmDspScMod_t;
 
 void _cmDspScModCb( void* arg, unsigned varSymId, double value, bool postFl )
     return NULL;
   }
   unsigned      fixArgCnt = sizeof(args)/sizeof(args[0]) - 1;
-  unsigned      argCnt    = fixArgCnt + cmScModulatorOutVarCount(mp);
+  unsigned      outVarCnt = cmScModulatorOutVarCount(mp);
+  unsigned      inVarCnt  = cmScModulatorInVarCount(mp);
+  unsigned      argCnt    = fixArgCnt + inVarCnt + outVarCnt;
   cmDspVarArg_t a[ argCnt+1 ];
   unsigned      i;
-
+  unsigned*     inVarIdMap = cmMemAllocZ( unsigned, inVarCnt );
   cmDspArgCopy( a, argCnt, 0, args, fixArgCnt );
 
   for(i=fixArgCnt; i<argCnt; ++i)
   {
-    unsigned            varIdx    = i - fixArgCnt;
-    const cmScModVar_t* vp        = cmScModulatorOutVar(mp,varIdx);
+    unsigned            inVarIdx  = i - fixArgCnt;
+    unsigned            outVarIdx = inVarIdx - inVarCnt; 
+    bool                inputFl   = inVarIdx < inVarCnt;
+    const cmScModVar_t* vp        = inputFl ? cmScModulatorInVar(mp,inVarIdx) : cmScModulatorOutVar(mp,outVarIdx);
     const cmChar_t*     label     = cmSymTblLabel( ctx->stH, vp->varSymId );
-    const cmChar_t*     docStr    = cmTsPrintfS("Variable output for %s",label);
+    const cmChar_t*     docStr    = cmTsPrintfS("Variable %s for %s",inputFl?"input":"output",label);
+    unsigned            flags     = inputFl ? kInDsvFl : kOutDsvFl;
+
+    if( inputFl )
+      inVarIdMap[ inVarIdx ] = vp->varSymId;
 
-    cmDspArgSetup(ctx, a + i, label, cmInvalidId, i, 0, 0, kOutDsvFl | kDoubleDsvFl, docStr ); 
+    cmDspArgSetup(ctx, a + i, label, cmInvalidId, i, 0, 0, flags | kDoubleDsvFl, docStr ); 
   }
   cmDspArgSetupNull(a+argCnt); // set terminating arg. flags
 
   cmDspScMod_t* p = cmDspInstAlloc(cmDspScMod_t,ctx,classPtr,a,instSymId,id,storeSymId,va_cnt,vl);
 
 
-  p->fn       = cmMemAllocStr(fn);
-  p->modLabel = cmMemAllocStr(modLabel);
-  p->mp       = mp;
-  p->onSymId  = cmSymTblId(ctx->stH,"on");
-  p->offSymId = cmSymTblId(ctx->stH,"off");
-  p->postSymId = cmSymTblRegisterStaticSymbol(ctx->stH,"post");
-  p->dumpSymId = cmSymTblId(ctx->stH,"dump");
+  p->fn          = cmMemAllocStr(fn);
+  p->modLabel    = cmMemAllocStr(modLabel);
+  p->mp          = mp;
+  p->onSymId     = cmSymTblId(ctx->stH,"on");
+  p->offSymId    = cmSymTblId(ctx->stH,"off");
+  p->postSymId   = cmSymTblRegisterStaticSymbol(ctx->stH,"post");
+  p->dumpSymId   = cmSymTblId(ctx->stH,"dump");
+  p->minInVarId  = fixArgCnt;
+  p->maxInVarId  = p->minInVarId + inVarCnt - 1;
+  p->inVarIdMap  = inVarIdMap;
+  p->inVarIdOffs = fixArgCnt;
 
   mp->cbArg = p;  // set the modulator callback arg
 
 
   cmMemFree(p->fn);
   cmMemFree(p->modLabel);
+  cmMemFree(p->inVarIdMap);
   return rc;
 }
 
   cmDspScMod_t* p  = (cmDspScMod_t*)inst;
 
   cmDspSetEvent(ctx,inst,evt);
+
+  if( p->minInVarId <= evt->dstVarId && evt->dstVarId <= p->maxInVarId )
+  {
+    double v = cmDspDouble(inst,evt->dstVarId);
+    printf("%s : %i %f\n",__FUNCTION__,evt->dstVarId,v);
+    cmScModulatorSetValue( p->mp, p->inVarIdMap[ evt->dstVarId - p->inVarIdOffs ], v );
+  }
   
   switch( evt->dstVarId )
   {