cmDevCfg.h/c:Added label to domain specific cfg records.

cmDevCfg.c

 
 typedef struct cmDcmCfg_str
 {
-  cmChar_t*     dcLabelStr;   // the cfg label 
-  unsigned      cfgId;        // unique among all cfg's assigned to a loc
-  cmTypeDcmId_t typeId;       // the cfg type id (e.g. midi, audio, net, ...)
-  cmChar_t*     descStr;      // summary description string 
+  cmChar_t*     dcLabelStr;     // the cfg label 
+  unsigned      cfgId;          // unique among all cfg's assigned to a loc
+  cmTypeDcmId_t typeId;         // the cfg type id (e.g. midi, audio, net, ...)
+  cmChar_t*     descStr;        // summary description string 
 
   // NOTE: any fields added to this structure, type generic (above) 
   // or type specific (below), must be explicitely duplicated in cmDevCfgLocStore().
 
 typedef struct
 {
-  cmTypeDcmId_t tid;      // Type Id for this map or tInvalidDcmTId if the record is not active.
-  unsigned      cfgId;    // cfgId of the cfg recd assoc'd with this map
-  cmDcmCfg_t*   cfg;      // pointer to the cfg recd assoc'd with this map (cfg->cfgId == cmDcmMap_t.cfgId)
+  cmTypeDcmId_t tid;            // Type Id for this map or tInvalidDcmTId if the record is not active.
+  unsigned      cfgId;          // cfgId of the cfg recd assoc'd with this map
+  cmDcmCfg_t*   cfg;            // pointer to the cfg recd assoc'd with this map (cfg->cfgId == cmDcmMap_t.cfgId)
 } cmDcmMap_t;
 
 typedef struct
 
 typedef struct cmDcmLoc_str
 {
-  cmChar_t*            labelStr;
+  cmChar_t* labelStr;
 
-  cmDcmApp_t*          app;
-  unsigned             appCnt;
+  cmDcmApp_t* app;
+  unsigned    appCnt;
 
   cmDcmCfg_t*          cfg;
 
 {
   d->inDevLabelStr  = cmMemAllocStr(s->inDevLabelStr);
   d->outDevLabelStr = cmMemAllocStr(s->outDevLabelStr);
-  d->audioSysArgs   = s->audioSysArgs;
+  d->rtSysArgs      = s->rtSysArgs;
 }
 
 void _cmDcmFreeNet( cmDcmNet_t* r )
 {
   // unlink the cfg recd
   if( cp->prev == NULL )
-    lp->cfg = cp->next;
+    lp->cfg        = cp->next;
   else
     cp->prev->next = cp->next;
   
 
   // unlink the loc recd
   if( lp->prev == NULL )
-    p->loc = lp->next;
+    p->loc         = lp->next;
   else
     lp->prev->next = lp->next;
 
   while( p->loc != NULL )
     _cmDcmFreeLoc(p,p->loc);
   
-  p->clp    = NULL;
+  p->clp = NULL;
 }
 
 cmDcRC_t _cmDcmFree( cmDcm_t* p )
 
 cmDcmLoc_t* _cmDcmFindLoc( cmDcm_t* p, const cmChar_t* labelStr )
 {
-  cmDcmLoc_t* lp = p->loc;
+  cmDcmLoc_t* lp                      = p->loc;
   for(; lp!=NULL; lp=lp->next)
-    if(strcmp(lp->labelStr,labelStr)==0)
+    if(strcmp(lp->labelStr,labelStr) == 0)
       return lp;
   return NULL;
 }
     return cmErrMsg(&p->err,kDuplLabelDcRC,"The location label '%s' is already in use.",labelStr);
 
   // create a new loc recd
-  lp  = cmMemAllocZ(cmDcmLoc_t,1);
+  lp           = cmMemAllocZ(cmDcmLoc_t,1);
   lp->labelStr = cmMemAllocStr(labelStr);
 
   // if the cur loc is not current set - then prepend loc
   if( p->clp == NULL )
   {
-    lp->prev = NULL;
-    lp->next = p->loc;
+    lp->prev       = NULL;
+    lp->next       = p->loc;
     if( p->loc == NULL )
-      p->loc = lp;
+      p->loc       = lp;
     else
       p->loc->prev = lp;    
   }
-  else // otherwise insert loc after the cur loc
+  else                          // otherwise insert loc after the cur loc
   {
     lp->prev = p->clp;
-    lp->next = p->clp->next;
+    lp->next             = p->clp->next;
     if( p->clp->next != NULL )
       p->clp->next->prev = lp;
-    p->clp->next = lp;
+    p->clp->next         = lp;
   }
 
   // make the new loc the current loc
 
 cmDcRC_t cmDevCfgAlloc( cmCtx_t* c, cmDevCfgH_t* hp, const cmChar_t* fn )
 {
-  cmDcRC_t rc;
+  cmDcRC_t    rc;
   cmDcmLoc_t* lp;
 
   if((rc = cmDevCfgFree(hp)) != kOkDcRC )
 
 cmDcRC_t cmDevCfgFree( cmDevCfgH_t* hp )
 {
-  cmDcRC_t rc = kOkDcRC;
-  if( hp == NULL || cmDevCfgIsValid(*hp)==false )
+  cmDcRC_t rc                             = kOkDcRC;
+  if( hp == NULL || cmDevCfgIsValid(*hp) == false )
     return rc;
 
   cmDcm_t* p = _cmDcmHandleToPtr(*hp);
 
 unsigned cmDevCfgCount( cmDevCfgH_t h, cmTypeDcmId_t typeId )
 {
-  unsigned n=0;
+  unsigned n = 0;
   cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   assert( p->clp != NULL);
 
 cmDcmCfg_t* _cmDevCfgIndexToPtr( cmDcm_t* p, cmTypeDcmId_t typeId, unsigned index, bool errFl )
 {
-  unsigned n=0;
+  unsigned    n  = 0;
   assert( p->clp != NULL);
   cmDcmCfg_t* cp = p->clp->cfg;
   for(; cp!= NULL; cp=cp->next)
 
 const cmChar_t* cmDevCfgLabel( cmDevCfgH_t h, cmTypeDcmId_t typeId, unsigned index )
 {
-  cmDcm_t*    p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p                                        = _cmDcmHandleToPtr(h);
   cmDcmCfg_t* cp;
   if((cp = _cmDevCfgIndexToPtr(p,typeId,index,false)) == NULL )
     return NULL;
   for(; cp!= NULL; cp=cp->next)
     if( cp->typeId == typeId )
     {
-      if( strcmp(cp->dcLabelStr,label)==0 )
+      if( strcmp(cp->dcLabelStr,label) == 0 )
         return cp;
     }
 
 
 unsigned cmDevCfgLabelToIndex( cmDevCfgH_t h, cmTypeDcmId_t typeId, const cmChar_t* label )
 {
-  unsigned n = 0;
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  unsigned          n  = 0;
+  cmDcm_t*          p  = _cmDcmHandleToPtr(h);
   assert( p->clp != NULL);
   const cmDcmCfg_t* cp = p->clp->cfg;
   for(; cp!= NULL; cp=cp->next)
     if( cp->typeId == typeId )
     {
-      if( strcmp(cp->dcLabelStr,label)==0 )
+      if( strcmp(cp->dcLabelStr,label) == 0 )
         return n;
       ++n;
     }
   {
     if( cp->cfgId > newCfgId )
       newCfgId = cp->cfgId;
-    ep = cp;
+    ep         = cp;
   }
 
   // add one to the max cfgId to create a unique cfgId
   newCfgId += 1;
   
   // allocate a new cfg recd
-  cp = cmMemAllocZ(cmDcmCfg_t,1);
+  cp             = cmMemAllocZ(cmDcmCfg_t,1);
   cp->dcLabelStr = cmMemAllocStr(dcLabelStr);
   cp->cfgId      = newCfgId;
   cp->typeId     = typeId;
 {
   cmDcmCfg_t* cp;
   cmDcm_t*    p = _cmDcmHandleToPtr(h);
-  unsigned i,j;
+  unsigned    i,j;
 
   // locate the cfg to delete
   if((cp = _cmDcmCfgLabelToPtr(p,typeId,dcLabelStr,true)) == NULL )
 
 cmDcRC_t cmDevCfgDeleteMap( cmDevCfgH_t h, cmTypeDcmId_t typeId, unsigned usrAppId, unsigned usrMapId )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmMap_t* mp;
 
   if((mp = _cmDcmFindMap(p,typeId,usrAppId,usrMapId,false)) == NULL )
   if((cp = _cmDcmFindOrCreateCfg(p,kMidiDcmTId, dcLabelStr)) == NULL )
     return cmErrLastRC(&p->err);
 
+  cp->u.m.label        = cp->dcLabelStr;
   cp->u.m.devLabelStr  = cmMemResizeStr(cp->u.m.devLabelStr,devLabelStr);
   cp->u.m.portLabelStr = cmMemResizeStr(cp->u.m.portLabelStr,portLabelStr);
   cp->u.m.inputFl      = inputFl;
 
 const cmDcmMidi_t* cmDevCfgMidiCfg( cmDevCfgH_t h, unsigned cfgIdx )
 {
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmCfg_t* cp;
 
   if((cp = _cmDevCfgIndexToPtr(p, kMidiDcmTId, cfgIdx, true )) == NULL )
 
 const cmDcmMidi_t* cmDevCfgMidiDevMap( cmDevCfgH_t h, unsigned usrAppId, unsigned usrMapId )
 {
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmMap_t* mp;
 
   if((mp =_cmDcmFindMap(p,kMidiDcmTId, usrAppId, usrMapId, true )) == NULL )
   double          srate,
   bool            activeFl )
 {
-  cmDcm_t*    p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p         = _cmDcmHandleToPtr(h);
   cmDcmCfg_t* cp;
-  unsigned    inDevIdx   = cmInvalidIdx;
-  unsigned    outDevIdx  = cmInvalidIdx;
+  unsigned    inDevIdx  = cmInvalidIdx;
+  unsigned    outDevIdx = cmInvalidIdx;
 
   // validate the label
   if((dcLabelStr = _cmDcmTrimLabel(p,dcLabelStr,"Audio cfg")) == NULL)
   unsigned inChCnt  = cmApDeviceChannelCount( inDevIdx,  true );
   unsigned outChCnt = cmApDeviceChannelCount( outDevIdx, false );
 
-  cp->u.a.inDevLabelStr                  = cmMemAllocStr(inDevNameStr==NULL?"":inDevNameStr);
-  cp->u.a.outDevLabelStr                 = cmMemAllocStr(outDevNameStr==NULL?"":outDevNameStr);
-  cp->u.a.activeFl                       = activeFl;
-  cp->u.a.audioSysArgs.rpt               = p->err.rpt;
-  cp->u.a.audioSysArgs.inDevIdx          = inDevIdx;
-  cp->u.a.audioSysArgs.outDevIdx         = outDevIdx;
-  cp->u.a.audioSysArgs.syncInputFl       = syncInputFl;
-  cp->u.a.audioSysArgs.msgQueueByteCnt   = msgQueueByteCnt;
-  cp->u.a.audioSysArgs.devFramesPerCycle = devFramesPerCycle;
-  cp->u.a.audioSysArgs.dspFramesPerCycle = dspFramesPerCycle;
-  cp->u.a.audioSysArgs.audioBufCnt       = audioBufCnt;
-  cp->u.a.audioSysArgs.srate             = srate;
-  cp->descStr = cmTsPrintfP(cp->descStr,"%sIn: Chs:%i %s\nOut: Chs:%i %s",activeFl?"":"INACTIVE ",inChCnt,cp->u.a.inDevLabelStr,outChCnt,cp->u.a.outDevLabelStr);
+  cp->u.a.label                       = cp->dcLabelStr;
+  cp->u.a.inDevLabelStr               = cmMemAllocStr(inDevNameStr==NULL?"":inDevNameStr);
+  cp->u.a.outDevLabelStr              = cmMemAllocStr(outDevNameStr==NULL?"":outDevNameStr);
+  cp->u.a.activeFl                    = activeFl;
+  cp->u.a.rtSysArgs.rpt               = p->err.rpt;
+  cp->u.a.rtSysArgs.inDevIdx          = inDevIdx;
+  cp->u.a.rtSysArgs.outDevIdx         = outDevIdx;
+  cp->u.a.rtSysArgs.syncInputFl       = syncInputFl;
+  cp->u.a.rtSysArgs.msgQueueByteCnt   = msgQueueByteCnt;
+  cp->u.a.rtSysArgs.devFramesPerCycle = devFramesPerCycle;
+  cp->u.a.rtSysArgs.dspFramesPerCycle = dspFramesPerCycle;
+  cp->u.a.rtSysArgs.audioBufCnt       = audioBufCnt;
+  cp->u.a.rtSysArgs.srate             = srate;
+  cp->descStr                         = cmTsPrintfP(cp->descStr,"%sIn: Chs:%i %s\nOut: Chs:%i %s",activeFl?"":"INACTIVE ",inChCnt,cp->u.a.inDevLabelStr,outChCnt,cp->u.a.outDevLabelStr);
   return kOkDcRC;  
 }
 
 
 cmDcRC_t            cmDevCfgAudioSetDefaultCfgIndex( cmDevCfgH_t h, unsigned cfgIdx )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   assert( p->clp != NULL );
 
 
 unsigned   cmDevCfgAudioGetDefaultCfgIndex( cmDevCfgH_t h )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   assert( p->clp != NULL );
 
 
 bool  cmDevCfgAudioIsDeviceActive( cmDevCfgH_t h, const cmChar_t* devNameStr, bool inputFl )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   assert( p->clp != NULL );
 
 
 unsigned            cmDevCfgAudioActiveCount( cmDevCfgH_t h )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   assert( p->clp != NULL );
 
 
 const cmChar_t*     cmDevCfgAudioActiveLabel( cmDevCfgH_t h, unsigned idx )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   assert( p->clp != NULL );
 
 
 const cmDcmAudio_t* cmDevCfgAudioActiveCfg(   cmDevCfgH_t h, unsigned idx )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   assert( p->clp != NULL );
 
 
 unsigned  cmDevCfgAudioActiveIndex( cmDevCfgH_t h, const cmChar_t* cfgLabel )
 {
-  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
 
   if( cfgLabel == NULL )
     return cmInvalidIdx;
 
 const cmDcmAudio_t* cmDevCfgAudioCfg( cmDevCfgH_t h, unsigned cfgIdx )
 {
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmCfg_t* cp;
 
   if((cp = _cmDevCfgIndexToPtr(p, kAudioDcmTId, cfgIdx, true )) == NULL )
 
 const cmDcmAudio_t* cmDevCfgAudioDevMap(    cmDevCfgH_t h, unsigned usrAppId, unsigned usrMapId )
 {
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmMap_t* mp;
 
   if((mp =_cmDcmFindMap(p,kAudioDcmTId, usrAppId, usrMapId, true )) == NULL )
 
 
 cmDcRC_t cmDevCfgNameNetPort(
-  cmDevCfgH_t      h,
+  cmDevCfgH_t     h,
   const cmChar_t* dcLabelStr,
   const cmChar_t* sockAddr,
   unsigned        portNumber,
   bool            activeFl)
 {
 
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmCfg_t* cp;
 
   if( portNumber > 0xffff )
   if((cp = _cmDcmFindOrCreateCfg(p,kNetDcmTId, dcLabelStr)) == NULL )
     return cmErrLastRC(&p->err);
 
+  cp->u.n.label      = cp->dcLabelStr;
   cp->u.n.sockAddr   = cmMemAllocStr(sockAddr);
   cp->u.n.portNumber = portNumber;
   cp->u.n.localFl    = localFl;
   cp->u.n.activeFl   = activeFl;
-  cp->descStr = cmTsPrintfP(cp->descStr,"%s %s %s:%i",activeFl?"":"INACTIVE",localFl?"local":"remote",sockAddr,portNumber);
+  cp->descStr        = cmTsPrintfP(cp->descStr,"%s %s %s:%i",activeFl?"":"INACTIVE",localFl?"local":"remote",sockAddr,portNumber);
   
 
   return kOkDcRC;
 
 const cmDcmNet_t* cmDevCfgNetCfg( cmDevCfgH_t h, unsigned cfgIdx )
 {
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmCfg_t* cp;
 
   if((cp = _cmDevCfgIndexToPtr(p, kNetDcmTId, cfgIdx, true )) == NULL )
 
 const cmDcmNet_t* cmDevCfgNetDevMap(    cmDevCfgH_t h, unsigned usrAppId, unsigned usrMapId )
 {
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmMap_t* mp;
 
   if((mp =_cmDcmFindMap(p,kNetDcmTId, usrAppId, usrMapId, true )) == NULL )
 
 unsigned        cmDevCfgLocCount(  cmDevCfgH_t h )
 {
-  unsigned n = 0;
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  unsigned          n  = 0;
+  cmDcm_t*          p  = _cmDcmHandleToPtr(h);
   const cmDcmLoc_t* lp = p->loc;
   for(; lp!=NULL; lp=lp->next)
     ++n;
 }
 const cmChar_t* cmDevCfgLocLabel(  cmDevCfgH_t h, unsigned locIdx )
 {
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  cmDcm_t*          p  = _cmDcmHandleToPtr(h);
   const cmDcmLoc_t* lp = p->loc;
-  unsigned i;
+  unsigned          i;
   for(i=0; lp!=NULL; lp=lp->next,++i)
     if( i == locIdx )
       return lp->labelStr;
   if((locLabelStr = _cmDcmTrimLabel(p,locLabelStr,"location")) == NULL )
     return NULL;
 
-  cmDcmLoc_t* lp = p->loc;
+  cmDcmLoc_t* lp                          = p->loc;
   for(; lp!=NULL; lp=lp->next)
     if( strcmp(lp->labelStr,locLabelStr) == 0 )
       return lp;
 
 cmDcRC_t cmDevCfgLocStore(  cmDevCfgH_t h, const cmChar_t* locLabelStr )
 {
-  cmDcRC_t  rc = kOkDcRC;
-  cmDcm_t*   p = _cmDcmHandleToPtr(h);
+  cmDcRC_t rc = kOkDcRC;
+  cmDcm_t* p = _cmDcmHandleToPtr(h);
   unsigned i,j;
 
   // if this location label is already in use then it has already been stored.
     cmDcmApp_t* oap = olp->app + i;
 
     //nap->usrAppId = oap->usrAppId;
-    nap->activeFl = oap->activeFl;
-    nap->mapCnt   = oap->mapCnt;
-    nap->map      = cmMemAllocZ(cmDcmMap_t,nap->mapCnt);
+    nap->activeFl   = oap->activeFl;
+    nap->mapCnt     = oap->mapCnt;
+    nap->map        = cmMemAllocZ(cmDcmMap_t,nap->mapCnt);
 
     for(j=0; j<nap->mapCnt; ++j)
     {
       nmp->cfgId = omp->cfgId;
 
       if( omp->tid != kInvalidDcmTId && omp->cfg->dcLabelStr != NULL )
-        nmp->cfg   = _cmDcmCfgLabelToPtr(p,nmp->tid,omp->cfg->dcLabelStr,true);
+        nmp->cfg = _cmDcmCfgLabelToPtr(p,nmp->tid,omp->cfg->dcLabelStr,true);
     }
   }
   
 
 cmDcRC_t cmDevCfgLocRecall( cmDevCfgH_t h, const cmChar_t* locLabelStr )
 {
-  cmDcm_t*     p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmLoc_t* lp;
 
   if((lp = _cmDcmLocLabelToPtr(p,locLabelStr,true)) == NULL)
 }
 cmDcRC_t cmDevCfgLocDelete( cmDevCfgH_t h, const cmChar_t* locLabelStr )
 {
-  cmDcm_t*     p = _cmDcmHandleToPtr(h);
+  cmDcm_t*    p = _cmDcmHandleToPtr(h);
   cmDcmLoc_t* lp;
 
   if((lp = _cmDcmLocLabelToPtr(p,locLabelStr,true)) == NULL )
 
 unsigned cmDevCfgLocCurIndex(  cmDevCfgH_t h )
 {
-  unsigned i;
-  cmDcm_t* p = _cmDcmHandleToPtr(h);
+  unsigned    i;
+  cmDcm_t*    p  = _cmDcmHandleToPtr(h);
   cmDcmLoc_t* lp = p->loc;
   for(i=0; lp!=NULL; lp=lp->next,++i)
     if( lp == p->clp )
 {
   cmDcRC_t        rc          = kOkDcRC;
   const cmChar_t* errLabelPtr = NULL;
-  cmJsonNode_t* cfgNp, *locArrNp;
-  unsigned i,j;
-  cmDevCfgH_t h;
-  h.h = p;
+  cmJsonNode_t*   cfgNp, *locArrNp;
+  unsigned        i,j;
+  cmDevCfgH_t     h;
+  h.h                         = p;
 
   // clear the all locations
   _cmDcmFreeAllLocs(p);
   // for each loc object
   for(i=0; i<cmJsonChildCount(locArrNp); ++i)
   {
-    cmJsonNode_t* locObjNp, *cfgArrNp;
+    cmJsonNode_t*   locObjNp, *cfgArrNp;
     const cmChar_t* locLabelStr = NULL;
 
     // get the loc object
     { return _cmDcmJsonNotFound(p,errLabelPtr); }
 
     // create a new location recd
-    cmDcmLoc_t* locPtr = NULL;
+    cmDcmLoc_t* locPtr                             = NULL;
     if((rc = _cmDcmNewLoc(p,locLabelStr,&locPtr)) != kOkDcRC )
       return cmErrMsg(&p->err,kJsonFailDcRC,"Location '%s' create failed.",cmStringNullGuard(locLabelStr));
 
         unsigned tid,cfgId;
         cmJsonNode_t* mapObjNp;
 
-        if((mapObjNp = cmJsonArrayElement(mapArrNp,j))==NULL || cmJsonIsObject(mapObjNp)==false)
+        if((mapObjNp = cmJsonArrayElement(mapArrNp,j)) == NULL || cmJsonIsObject(mapObjNp)==false)
           return _cmDcmJsonSyntaxErr(p,"cfg object");
 
         if( cmJsonMemberValues( mapObjNp, &errLabelPtr, 
     // read each cfg object
     for(j=0; j<cmJsonChildCount(cfgArrNp); ++j)
     {
-      cmJsonNode_t* cfgObjNp;
+      cmJsonNode_t*   cfgObjNp;
       const cmChar_t* dcLabelStr;
       const cmChar_t* descStr;
-      unsigned cfgId, typeId;
+      unsigned        cfgId, typeId;
 
-      if((cfgObjNp = cmJsonArrayElement(cfgArrNp,j))==NULL || cmJsonIsObject(cfgObjNp)==false)
+      if((cfgObjNp = cmJsonArrayElement(cfgArrNp,j)) == NULL || cmJsonIsObject(cfgObjNp)==false)
         return _cmDcmJsonSyntaxErr(p,"cfg object");
       
       if( cmJsonMemberValues( cfgObjNp, &errLabelPtr,
           if( cmJsonMemberValues( cfgObjNp, &errLabelPtr,
               "inDevLabelStr",     kStringTId, &a.inDevLabelStr,
               "outDevLabelStr",    kStringTId, &a.outDevLabelStr,
-              "syncInputFl",       kBoolTId,   &a.audioSysArgs.syncInputFl,
-              "msgQueueByteCnt",   kIntTId,    &a.audioSysArgs.msgQueueByteCnt,
-              "devFramesPerCycle", kIntTId,    &a.audioSysArgs.devFramesPerCycle,
-              "dspFramesPerCycle", kIntTId,    &a.audioSysArgs.dspFramesPerCycle,
-              "audioBufCnt",       kIntTId,    &a.audioSysArgs.audioBufCnt,
-              "srate",             kRealTId,   &a.audioSysArgs.srate,
+              "syncInputFl",       kBoolTId,   &a.rtSysArgs.syncInputFl,
+              "msgQueueByteCnt",   kIntTId,    &a.rtSysArgs.msgQueueByteCnt,
+              "devFramesPerCycle", kIntTId,    &a.rtSysArgs.devFramesPerCycle,
+              "dspFramesPerCycle", kIntTId,    &a.rtSysArgs.dspFramesPerCycle,
+              "audioBufCnt",       kIntTId,    &a.rtSysArgs.audioBufCnt,
+              "srate",             kRealTId,   &a.rtSysArgs.srate,
               "active",            kBoolTId,   &a.activeFl,
               NULL ) != kOkJsRC )
           {
             goto errLabel;
           }
 
-          if((rc = cmDevCfgNameAudioPort(h,dcLabelStr,a.inDevLabelStr,a.outDevLabelStr,
-                a.audioSysArgs.syncInputFl,
-                a.audioSysArgs.msgQueueByteCnt,
-                a.audioSysArgs.devFramesPerCycle,
-                a.audioSysArgs.dspFramesPerCycle,
-                a.audioSysArgs.audioBufCnt,
-                a.audioSysArgs.srate,
+          if((rc              = cmDevCfgNameAudioPort(h,dcLabelStr,a.inDevLabelStr,a.outDevLabelStr,
+                a.rtSysArgs.syncInputFl,
+                a.rtSysArgs.msgQueueByteCnt,
+                a.rtSysArgs.devFramesPerCycle,
+                a.rtSysArgs.dspFramesPerCycle,
+                a.rtSysArgs.audioBufCnt,
+                a.rtSysArgs.srate,
                 a.activeFl)) != kOkDcRC )
           {
             goto errLabel;
 
 cmDcRC_t _cmDevCfgWrite( cmDcm_t* p, cmJsonH_t jsH, cmJsonNode_t* rootObjPtr )
 {
-  cmDcRC_t rc = kOkDcRC;
+  cmDcRC_t          rc = kOkDcRC;
   const cmDcmLoc_t* lp = p->loc;
   
   cmJsonNode_t* cfgNp = cmJsonInsertPairObject(jsH, rootObjPtr, "cfg" );
           cmJsonInsertPairs(jsH, cfgObjNp,
             "inDevLabelStr",     kStringTId, cp->u.a.inDevLabelStr,
             "outDevLabelStr",    kStringTId, cp->u.a.outDevLabelStr,
-            "syncInputFl",       kBoolTId,   cp->u.a.audioSysArgs.syncInputFl,
-            "msgQueueByteCnt",   kIntTId,    cp->u.a.audioSysArgs.msgQueueByteCnt,
-            "devFramesPerCycle", kIntTId,    cp->u.a.audioSysArgs.devFramesPerCycle,
-            "dspFramesPerCycle", kIntTId,    cp->u.a.audioSysArgs.dspFramesPerCycle,
-            "audioBufCnt",       kIntTId,    cp->u.a.audioSysArgs.audioBufCnt,
-            "srate",             kRealTId,   cp->u.a.audioSysArgs.srate,
+            "syncInputFl",       kBoolTId,   cp->u.a.rtSysArgs.syncInputFl,
+            "msgQueueByteCnt",   kIntTId,    cp->u.a.rtSysArgs.msgQueueByteCnt,
+            "devFramesPerCycle", kIntTId,    cp->u.a.rtSysArgs.devFramesPerCycle,
+            "dspFramesPerCycle", kIntTId,    cp->u.a.rtSysArgs.dspFramesPerCycle,
+            "audioBufCnt",       kIntTId,    cp->u.a.rtSysArgs.audioBufCnt,
+            "srate",             kRealTId,   cp->u.a.rtSysArgs.srate,
             "active",            kBoolTId,   cp->u.a.activeFl,
             NULL );
           break;

cmDevCfg.h

 
   typedef struct
   {
+    const cmChar_t* label;    // cfg label
     cmChar_t* devLabelStr;    // Midi device label.
     cmChar_t* portLabelStr;   // Midi device port label.
     bool      inputFl;        // 'True' if this is an input port.
 
   typedef struct
   {
+    const cmChar_t* label;         // cfg label
     cmChar_t*     inDevLabelStr;  // Input audio device label.
     cmChar_t*     outDevLabelStr; // Output audio device label.
-    cmRtSysArgs_t audioSysArgs;   // Audio system  cfg recd
+    cmRtSysArgs_t rtSysArgs;      // RT system  cfg recd
     bool          dfltFl;         // true if this is the default audio cfg.
     bool          activeFl;
   } cmDcmAudio_t;
 
   typedef struct              
   {
-    cmChar_t* sockAddr;   // socket address.
-    unsigned  portNumber; // socket port number
-    bool      localFl;    // this is the local port
-    bool      activeFl;   // this port is active/inactive
+    const cmChar_t* label;      // cfg label
+    cmChar_t*       sockAddr;   // socket address.
+    unsigned        portNumber; // socket port number
+    bool            localFl;    // this is the local port
+    bool            activeFl;   // this port is active/inactive
   } cmDcmNet_t;
 
   extern cmDevCfgH_t cmDevCfgNullHandle;