cmAudDsp,cmAudioFileDev,cmAudioPortFile,cmAudioSys: Changes to support audio port file devices.

cmAudDsp.c

 #include "cmAudioPort.h"
 #include "cmAudioAggDev.h"
 #include "cmAudioNrtDev.h"
+#include "cmAudioPortFile.h"
 #include "cmApBuf.h"
 #include "cmMidi.h"
 #include "cmMidiPort.h"
 
 typedef struct
 {
+  const cmChar_t* label;
+  const cmChar_t* inAudioFn;
+  const cmChar_t* outAudioFn;
+  unsigned        oBits;
+  unsigned        oChCnt;
+} cmAdAfpDev_t;
+
+typedef struct
+{
   cmErr_t            err;
   cmCtx_t            ctx;
   cmMsgSendFuncPtr_t cbFunc;
   cmAdNrtDev_t*      nrtDevArray;
   unsigned           nrtDevCnt;
 
+  cmAdAfpDev_t*      afpDevArray;
+  unsigned           afpDevCnt;
+
   cmAdAsCfg_t*       asCfgArray;
   unsigned           asCfgCnt;
   
   cmJsonNode_t*   asCfgArrNodePtr  = NULL;
   cmJsonNode_t*   aggDevArrNodePtr = NULL;
   cmJsonNode_t*   nrtDevArrNodePtr = NULL;
+  cmJsonNode_t*   afpDevArrNodePtr = NULL;
   cmJsonNode_t*   audDspNodePtr    = NULL;
   const cmChar_t* errLabelPtr      = NULL;
   unsigned        i;
         "audioSysCfgArray",   kArrayTId, &asCfgArrNodePtr,
         "aggDevArray",        kArrayTId | kOptArgJsFl, &aggDevArrNodePtr,
         "nrtDevArray",        kArrayTId | kOptArgJsFl, &nrtDevArrNodePtr,
+        "afpDevArray",        kArrayTId | kOptArgJsFl, &afpDevArrNodePtr,
         NULL )) != kOkJsRC )
   {
     rc = _cmAdParseMemberErr(p, jsRC, errLabelPtr, "aud_dsp" );
       }
 
     }
+    
+  }
+
+  // parse the audio file device specifications into p->afpDevArray[].
+  if( afpDevArrNodePtr != NULL && (p->afpDevCnt = cmJsonChildCount(afpDevArrNodePtr)) > 0)
+  {
+    // alloc the non-real-time spec. array
+    p->afpDevArray = cmMemResizeZ( cmAdAfpDev_t, p->afpDevArray, p->afpDevCnt );
+
+    // for each afp. device spec. recd
+    for(i=0; i<p->afpDevCnt; ++i)
+    {
+      const cmJsonNode_t* np   = cmJsonArrayElementC(afpDevArrNodePtr,i);
+
+      // read afpDevArray record values
+      if(( jsRC      = cmJsonMemberValues( np, &errLabelPtr, 
+            "label",      kStringTId,                &p->afpDevArray[i].label,
+            "iAudioFn",   kStringTId  | kOptArgJsFl, &p->afpDevArray[i].inAudioFn,
+            "oAudioFn",   kStringTId  | kOptArgJsFl, &p->afpDevArray[i].outAudioFn,
+            "oBits",      kIntTId     | kOptArgJsFl, &p->afpDevArray[i].oBits,
+            "oChCnt",     kIntTId     | kOptArgJsFl, &p->afpDevArray[i].oChCnt,
+            NULL )) != kOkJsRC )
+      {
+        rc = _cmAdParseMemberErr(p, jsRC, errLabelPtr, cmStringNullGuard(p->afpDevArray[i].label) );
+        goto errLabel;
+      }
+
+    }
 
   }
 
   return rc;
 }
 
+cmAdRC_t _cmAdCreateAfpDevices( cmAd_t* p )
+{
+  cmAdRC_t rc = kOkAdRC;
+
+  if( cmApFileAllocate(p->err.rpt) != kOkApRC )
+    return cmErrMsg(&p->err,kAfpDevSysFailAdRC,"The audio file device system allocation failed.");
+
+  unsigned i;
+  // create the audio file devices
+  for(i=0; i<p->afpDevCnt; ++i)
+  {
+    //const cmAudioSysFilePort_t* afp = cfg->afpArray + i;
+    cmAdAfpDev_t* afp = p->afpDevArray + i;
+    if( cmApFileDeviceCreate( afp->label, afp->inAudioFn, afp->outAudioFn, afp->oBits, afp->oChCnt ) != kOkApRC )
+      rc = cmErrMsg(&p->err,kAfpDevSysFailAdRC,"The audio file device '%s' creation failed.",cmStringNullGuard(afp->label));
+  }
+
+  return rc;
+}
+
 cmAdRC_t _cmAdSendAudioSysCfgLabels( cmAd_t* p)
 {
   cmAdRC_t     rc = kOkAdRC;
     goto errLabel;
   }
 
+  if( cmApFileFree() != kOkApRC )
+  {
+    rc = cmErrMsg(&p->err,kAfpDevSysFailAdRC,"The audio file device system release failed.");
+    goto errLabel;
+  }
+
   if( cmApNrtFree() != kOkAgRC )
   {
-    rc = cmErrMsg(&p->err,kNrtDevSysFailAdRC,"The non-real-time device system realease failed.");
+    rc = cmErrMsg(&p->err,kNrtDevSysFailAdRC,"The non-real-time device system release failed.");
     goto errLabel;
   }
 
   if( _cmAdCreateNrtDevices(p) != kOkAdRC )
     goto errLabel;
 
+  // create the audio file devices
+  if( _cmAdCreateAfpDevices(p) != kOkAdRC )
+    goto errLabel;
+
   // initialize the audio device system
   if( cmApInitialize(&ctx->rpt) != kOkApRC )
   {

cmAudDsp.h

     kAggDevSysFailAdRC,
     kAggDevCreateFailAdRC,
     kNrtDevSysFailAdRC,
+    kAfpDevSysFailAdRC,
     kNetSysFailAdRC
   };
 

cmAudioFileDev.c

       goto errLabel;
     }
 
-
-
     p->iPkt.devIdx         = devIdx;
     p->iPkt.begChIdx       = 0;
     p->iPkt.chCnt          = afInfo.chCnt;   // setting iPkt.chCnt to a non-zero value marks the input file as active
 
 cmAfdRC_t cmAudioFileDevSetup( 
   cmAfdH_t                        h, 
+  unsigned                        baseDevIdx,
   double                          srate, 
   unsigned                        framesPerCycle, 
   cmApCallbackPtr_t               callbackPtr, 
 
     cmApSample_t* bp = (cmApSample_t*)p->oPkt.audioBytesPtr;
 
-    p->oPkt.devIdx         = p->devIdx;
+    p->oPkt.devIdx         = p->devIdx + baseDevIdx;
     p->oPkt.begChIdx       = 0;
     p->oPkt.chCnt          = p->oChCnt;
     p->oPkt.audioFramesCnt = framesPerCycle;
     p->oPkt.bitsPerSample  = p->oBits;
     p->oPkt.flags          = kFloatApFl;
     p->oPkt.audioBytesPtr  = bp = cmMemResizeZ( cmApSample_t, bp, framesPerCycle*p->oChCnt );
+    p->oPkt.userCbPtr      = cbDataPtr;
     p->oChArray            = cmMemResizeZ( cmApSample_t*, p->oChArray, p->oChCnt );
     
     for(i=0; i<p->oChCnt; ++i)
   {
     cmApSample_t* bp = (cmApSample_t*)p->iPkt.audioBytesPtr;
 
+    p->iPkt.devIdx         = p->devIdx + baseDevIdx;
     p->iPkt.audioFramesCnt = framesPerCycle;
     p->iPkt.audioBytesPtr  = bp = cmMemResizeZ( cmApSample_t, bp, framesPerCycle*p->iPkt.chCnt ); ;
+    p->iPkt.userCbPtr      = cbDataPtr;
     for(i=0; i<p->iPkt.chCnt; ++i)
       p->iChArray[i] = bp + (i*framesPerCycle);
   }
   if( cmAudioFileDevInitialize(&afdH,"file",devIdx,iFn,oFn,oBits,oChCnt,rpt) != kOkAfdRC )
     goto errLabel;
 
-  if( cmAudioFileDevSetup(afdH,srate,framesPerCycle,_cmAfdCallback,cbDataPtr) != kOkAfdRC )
+  if( cmAudioFileDevSetup(afdH,0,srate,framesPerCycle,_cmAfdCallback,cbDataPtr) != kOkAfdRC )
     goto errLabel;
 
   char c;

cmAudioFileDev.h

 /// Setup the device. This function must be called prior to cmAudioFileDevStart().
 cmAfdRC_t cmAudioFileDevSetup( 
   cmAfdH_t          h, 
+  unsigned          baseApDevIdx,
   double            srate, 
   unsigned          framesPerCycle, 
   cmApCallbackPtr_t callbackPtr, 

cmAudioNrtDev.c

 typedef struct cmApNrtDev_str
 {
   unsigned               flags;
-  unsigned               devIdx; // nrt device index
+  unsigned               devIdx;       // nrt device index
   unsigned               baseApDevIdx; // global audio device index for first nrt device
   cmChar_t*              label;         
   unsigned               iChCnt;

cmAudioPortFile.c

 typedef struct
 {
   cmAfdH_t devH;
+  unsigned devIdx;  // afp dev idx
+  unsigned baseApDevIdx; // global audio device index for first afp device
 } cmApDev_t;
 
 typedef struct
   cmErr_t    err;
   cmApDev_t* devArray;
   unsigned   devCnt;
+  unsigned   baseApDevIdx;
 } cmApf_t;
 
 cmApf_t* _cmApf = NULL;
 
-cmApRC_t      cmApFileInitialize( cmRpt_t* rpt, unsigned baseApDevIdx )
+cmApRC_t      cmApFileAllocate( cmRpt_t* rpt )
 {
-  cmApRC_t rc;
-  if((rc = cmApFileFinalize()) != kOkApRC )
-    return rc;
+  cmApRC_t rc = kOkApRC;
+
+  if( _cmApf != NULL )
+    cmApFileFree();
 
   _cmApf = cmMemAllocZ(cmApf_t,1);
 
   cmErrSetup(&_cmApf->err,rpt,"Audio Port File");
+  _cmApf->devArray     = NULL;
+  _cmApf->devCnt       = 0;
+  _cmApf->baseApDevIdx = 0;
+
+  return rc;
+}
+
+cmApRC_t      cmApFileFree()
+{
+  cmApRC_t rc = kOkApRC;
+
+  if( _cmApf == NULL )
+    return rc;
+
+  if((rc = cmApFileFinalize()) != kOkApRC )
+    return rc;
+
+  cmMemFree(_cmApf);
+  _cmApf = NULL;
+  return rc;
+}
+
+
+cmApRC_t      cmApFileInitialize( cmRpt_t* rpt, unsigned baseApDevIdx )
+{
+  cmApRC_t rc = kOkApRC;
+
+  unsigned i = 0;
+  for(; i<_cmApf->devCnt; ++i)
+    _cmApf->devArray[i].baseApDevIdx = baseApDevIdx;
+
+  _cmApf->baseApDevIdx = baseApDevIdx;
 
   return rc;      
 }
   {
     cmErrMsg(&_cmApf->err,kAudioPortFileFailApRC,"The audio file device initialization failed.");
     i = cmInvalidIdx;
+    goto errLabel;
   }
+
+  _cmApf->devArray[i].devIdx = i;
+
+ errLabel:
   
   return i;
 }
 {
   assert( devIdx < cmApFileDeviceCount());
 
-  if( cmAudioFileDevSetup( _cmApf->devArray[devIdx].devH,srate,framesPerCycle,callbackPtr,userCbPtr) != kOkAfdRC )
+  if( cmAudioFileDevSetup( _cmApf->devArray[devIdx].devH,_cmApf->baseApDevIdx,srate,framesPerCycle,callbackPtr,userCbPtr) != kOkAfdRC )
     return cmErrMsg(&_cmApf->err,kAudioPortFileFailApRC,"The audio file device setup failed.");
 
   return kOkApRC;

cmAudioPortFile.h

 extern "C" {
 #endif
 
+  cmApRC_t      cmApFileAllocate( cmRpt_t* rpt );
+  cmApRC_t      cmApFileFree();
 
   cmApRC_t      cmApFileInitialize( cmRpt_t* rpt, unsigned baseApDevIdx );
   cmApRC_t      cmApFileFinalize();

cmAudioSys.c

     return rc;
 
   // create the audio file devices
+  /*
   for(i=0; i<cfg->afpCnt; ++i)
   {
     const cmAudioSysFilePort_t* afp = cfg->afpArray + i;
     cmApFileDeviceCreate( afp->devLabel, afp->inAudioFn, afp->outAudioFn, afp->oBits, afp->oChCnt );
   }
+  */
 
   p->ssArray = cmMemAllocZ( _cmAsCfg_t, cfg->ssCnt );
   p->ssCnt   = cfg->ssCnt;
 
   cfg.ssArray = &ss;
   cfg.ssCnt   = 1;
-  cfg.afpArray= NULL;
-  cfg.afpCnt  = 0;
+  //cfg.afpArray= NULL;
+  //cfg.afpCnt  = 0;
   cfg.meterMs = 50;
 
   if(_cmAsGetBoolOpt(argc,argv,"-h",false))

cmAudioSys.h

     
   } cmAudioSysCtx_t;
 
+  /*
   typedef struct
   {
     const cmChar_t* devLabel;
     unsigned        oBits;
     unsigned        oChCnt;
   } cmAudioSysFilePort_t;
-
+  */
 
   /// Audio system configuration record used by cmAudioSysAllocate().
   typedef struct cmAudioSysCfg_str
   {
     cmAudioSysSubSys_t*   ssArray;      ///< sub-system cfg record array
     unsigned              ssCnt;        ///< count of sub-systems   
-    cmAudioSysFilePort_t* afpArray;     ///< audio port file cfg recd array
-    unsigned              afpCnt;       ///< audio port file cnt
+    //cmAudioSysFilePort_t* afpArray;     ///< audio port file cfg recd array
+    //unsigned              afpCnt;       ///< audio port file cnt
     unsigned              meterMs;      ///< Meter sample period in milliseconds
     void*                 clientCbData; ///< User arg. for clientCbFunc().
     cmTsQueueCb_t         clientCbFunc; ///< Called by  cmAudioSysReceiveMsg() to deliver internally generated msg's to the host.