diff --git a/cmProc5.c b/cmProc5.c index afcc545..d1760ef 100644 --- a/cmProc5.c +++ b/cmProc5.c @@ -680,14 +680,14 @@ cmReflectCalc_t* cmReflectCalcAlloc( cmCtx* ctx, cmReflectCalc_t* p, const cmGol cmRC_t rc = cmOkRC; // allocate the Gold code signal generator - if( (p->gs = cmGoldSigAlloc(ctx,NULL,NULL)) == NULL ) + if( (op->gs = cmGoldSigAlloc(ctx,NULL,NULL)) == NULL ) { rc = cmCtxRtCondition(&p->obj,cmSubSysFailRC,"Gold sig allocate failed."); goto errLabel; } // allocate the PHAT object - if( (p->phat = cmPhatAlloc(ctx,NULL,0,0,0,0,0)) == NULL ) + if( (op->phat = cmPhatAlloc(ctx,NULL,0,0,0,0,0)) == NULL ) { rc = cmCtxRtCondition(&p->obj,cmSubSysFailRC,"PHAT allocate failed."); goto errLabel; @@ -718,6 +718,8 @@ cmRC_t cmReflectCalcFree( cmReflectCalc_t** pp ) cmReflectCalc_t* p = *pp; + cmReflectCalcWrite(p,"/home/kevin/temp/cmkc"); + if((rc = cmReflectCalcFinal(p)) != cmOkRC ) return rc; @@ -779,9 +781,12 @@ cmRC_t cmReflectCalcFinal( cmReflectCalc_t* p ) return cmOkRC; } -cmRC_t cmReflectCalcExec( cmReflectCalc_t* p, const cmSample_t xV, cmSample_t* yV, unsigned xyN ) +cmRC_t cmReflectCalcExec( cmReflectCalc_t* p, const cmSample_t* xV, cmSample_t* yV, unsigned xyN ) { unsigned i; + + // feed audio into the PHAT's buffer + cmPhatExec(p->phat,xV,xyN); for(i=0; ixi) { @@ -790,12 +795,16 @@ cmRC_t cmReflectCalcExec( cmReflectCalc_t* p, const cmSample_t xV, cmSample_t* y else yV[i] = 0; + // if the PHAT has a complete buffer if( p->xi == p->phat->fhN ) { p->xi = 0; + // execute the correlation cmPhatChExec(p->phat,0,0,0); + // p->phat->xV now holds the correlation result + if( p->va != NULL ) cmVectArrayAppendS(p->va,p->phat->xV,p->phat->fhN ); } @@ -805,3 +814,20 @@ cmRC_t cmReflectCalcExec( cmReflectCalc_t* p, const cmSample_t xV, cmSample_t* y return cmOkRC; } + +cmRC_t cmReflectCalcWrite( cmReflectCalc_t* p, const char* dirStr ) +{ + cmRC_t rc = cmOkRC; + + if( p->va != NULL) + { + const char* path = NULL; + + if((rc = cmVectArrayWrite(p->va, path = cmFsMakeFn(path,"reflect_calc","va",dirStr,NULL) )) != cmOkRC ) + rc = cmCtxRtCondition(&p->obj,cmSubSysFailRC,"Reflect calc file write failed."); + + cmFsFreeFn(path); + } + + return rc; +} diff --git a/cmProc5.h b/cmProc5.h index 682eb74..56b683e 100644 --- a/cmProc5.h +++ b/cmProc5.h @@ -209,11 +209,11 @@ extern "C" { cmReflectCalc_t* cmReflectCalcAlloc( cmCtx* ctx, cmReflectCalc_t* p, const cmGoldSigArg_t* gsa, float phat_alpha, unsigned phat_mult ); - cmRC_t cmReflectCalcFree( cmReflectCalc_t** pp ); - cmRC_t cmReflectCalcInit( cmReflectCalc_t* p, const cmGoldSigArg_t* gsa, float phat_alpha, unsigned phat_mult ); + cmRC_t cmReflectCalcFree( cmReflectCalc_t** pp ); + cmRC_t cmReflectCalcInit( cmReflectCalc_t* p, const cmGoldSigArg_t* gsa, float phat_alpha, unsigned phat_mult ); cmRC_t cmReflectCalcFinal( cmReflectCalc_t* p ); - cmRC_t cmReflectCalcExec( cmReflectCalc_t* p, const cmSample_t xV, cmSample_t* yV, unsigned xyN ); - + cmRC_t cmReflectCalcExec( cmReflectCalc_t* p, const cmSample_t* xV, cmSample_t* yV, unsigned xyN ); + cmRC_t cmReflectCalcWrite( cmReflectCalc_t* p, const char* dirStr ); #ifdef __cplusplus diff --git a/dsp/cmDspBuiltIn.c b/dsp/cmDspBuiltIn.c index 37e3680..0ef37b2 100644 --- a/dsp/cmDspBuiltIn.c +++ b/dsp/cmDspBuiltIn.c @@ -5837,6 +5837,7 @@ cmDspClassConsFunc_t _cmDspClassBuiltInArray[] = cmSyncRecdClassCons, cmTakeSeqBldrClassCons, cmTakeSeqRendClassCons, + cmReflectCalcClassCons, NULL, }; diff --git a/dsp/cmDspKr.c b/dsp/cmDspKr.c index 3b0ff10..325bf63 100644 --- a/dsp/cmDspKr.c +++ b/dsp/cmDspKr.c @@ -3587,3 +3587,160 @@ struct cmDspClass_str* cmTakeSeqRendClassCons( cmDspCtx_t* ctx ) return &_cmTakeSeqRendDC; } + +//========================================================================================================================================== +enum +{ + kLfsrN_RcId, + kMlsCoeff0RcId, + kMlsCoeff1RcId, + kSmpPerChipRcId, + kRcosBetaRcId, + kRcosOS_RcId, + kCarrierHzRcId, + kAtkDcyMsRcId, + kPhatAlphaRcId, + kPhatMultRcId, + kInRcId, + kOutRcId, +}; + +cmDspClass_t _cmReflectCalcDC; + +typedef struct +{ + cmDspInst_t inst; + cmReflectCalc_t* r; +} cmDspReflectCalc_t; + + +cmDspInst_t* _cmDspReflectCalcAlloc(cmDspCtx_t* ctx, cmDspClass_t* classPtr, unsigned storeSymId, unsigned instSymId, unsigned id, unsigned va_cnt, va_list vl ) +{ + + /* + if( va_cnt !=3 ) + { + cmDspClassErr(ctx,classPtr,kVarArgParseFailDspRC,"The 'ReflectCalc' constructor must have two arguments: a channel count and frequency array."); + return NULL; + } + */ + + cmDspReflectCalc_t* p = cmDspInstAllocV(cmDspReflectCalc_t,ctx,classPtr,instSymId,id,storeSymId,va_cnt,vl, + 1, "lfsrN", kLfsrN_RcId, 0,0, kInDsvFl | kUIntDsvFl, "Gold code generator LFSR length", + 1, "mlsc0", kMlsCoeff0RcId, 0,0, kInDsvFl | kUIntDsvFl, "LFSR coefficient 0", + 1, "mlsc1", kMlsCoeff1RcId, 0,0, kInDsvFl | kUIntDsvFl, "LFSR coefficient 0", + 1, "spchip",kSmpPerChipRcId,0,0, kInDsvFl | kUIntDsvFl, "Samples per spreading code bit.", + 1, "rcosb", kRcosBetaRcId, 0,0, kInDsvFl | kDoubleDsvFl, "Raised cosine beta", + 1, "rcosos",kRcosOS_RcId, 0,0, kInDsvFl | kUIntDsvFl, "Raised cosine oversample factor.", + 1, "carhz", kCarrierHzRcId, 0,0, kInDsvFl | kDoubleDsvFl, "Carrier frequency in Hertz.", + 1, "envms", kAtkDcyMsRcId, 0,0, kInDsvFl | kDoubleDsvFl, "Signal Attack/Decay milliseconds.", + 1, "alpha", kPhatAlphaRcId, 0,0, kInDsvFl | kDoubleDsvFl, "PHAT alpha coefficient.", + 1, "mult", kPhatMultRcId, 0,0, kInDsvFl | kUIntDsvFl, "PHAT multiplier coefficient.", + 1, "in", kInRcId, 0,1, kInDsvFl | kAudioBufDsvFl,"Audio input", + 1, "out", kOutRcId, 0,1, kOutDsvFl | kAudioBufDsvFl,"Audio output", + 0 ); + + +p->r = cmReflectCalcAlloc(ctx->cmProcCtx, NULL, NULL, 0, 0 ); + + cmDspSetDefaultUInt( ctx, &p->inst, kLfsrN_RcId, 0, 8); + cmDspSetDefaultUInt( ctx, &p->inst, kMlsCoeff0RcId, 0, 0x8e); + cmDspSetDefaultUInt( ctx, &p->inst, kMlsCoeff1RcId, 0, 0x96); + cmDspSetDefaultUInt( ctx, &p->inst, kSmpPerChipRcId, 0, 64); + cmDspSetDefaultDouble( ctx, &p->inst, kRcosBetaRcId, 0, 0.5); + cmDspSetDefaultUInt( ctx, &p->inst, kRcosOS_RcId, 0, 4); + cmDspSetDefaultDouble( ctx, &p->inst, kCarrierHzRcId, 0, 2500.0); + cmDspSetDefaultDouble( ctx, &p->inst, kAtkDcyMsRcId, 0, 50.0); + cmDspSetDefaultDouble( ctx, &p->inst, kPhatAlphaRcId, 0, 0.5); + cmDspSetDefaultUInt( ctx, &p->inst, kPhatMultRcId, 0, 4); + + return &p->inst; +} + +cmDspRC_t _cmDspReflectCalcSetup( cmDspCtx_t* ctx, cmDspInst_t* inst ) +{ + cmDspRC_t rc = kOkDspRC; + cmDspReflectCalc_t* p = (cmDspReflectCalc_t*)inst; + cmGoldSigArg_t gsa; + + gsa.chN = 1; + gsa.srate = cmDspSampleRate(ctx); + gsa.lfsrN = cmDspUInt(inst,kLfsrN_RcId); + gsa.mlsCoeff0 = cmDspUInt(inst,kMlsCoeff0RcId); + gsa.mlsCoeff1 = cmDspUInt(inst,kMlsCoeff1RcId); + gsa.samplesPerChip = cmDspUInt(inst,kSmpPerChipRcId); + gsa.rcosBeta = cmDspDouble(inst,kRcosBetaRcId); + gsa.rcosOSFact = cmDspUInt(inst,kRcosOS_RcId); + gsa.carrierHz = cmDspDouble(inst,kCarrierHzRcId); + gsa.envMs = cmDspDouble(inst,kAtkDcyMsRcId); + + double phatAlpha = cmDspDouble(inst,kPhatAlphaRcId); + unsigned phatMult = cmDspUInt(inst,kPhatMultRcId); + + if( cmReflectCalcInit(p->r,&gsa,phatAlpha,phatMult) != cmOkRC ) + rc = cmErrMsg(&inst->classPtr->err, kSubSysFailDspRC, "Unable to initialize the internal ReflectCalc detector."); + + return rc; +} + +cmDspRC_t _cmDspReflectCalcFree(cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt ) +{ + cmDspRC_t rc = kOkDspRC; + cmDspReflectCalc_t* p = (cmDspReflectCalc_t*)inst; + + cmReflectCalcFree(&p->r); + + return rc; +} + +cmDspRC_t _cmDspReflectCalcReset(cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt ) +{ +//cmDspReflectCalc_t* p = (cmDspReflectCalc_t*)inst; + + cmDspApplyAllDefaults(ctx,inst); + + return _cmDspReflectCalcSetup(ctx, inst ); +} + +cmDspRC_t _cmDspReflectCalcExec(cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt ) +{ + cmDspRC_t rc = kOkDspRC; + cmDspReflectCalc_t* p = (cmDspReflectCalc_t*)inst; + const cmSample_t* xV = cmDspAudioBuf(ctx,inst,kInRcId,0); + unsigned xN = cmDspAudioBufSmpCount(ctx,inst,kInRcId,0); + cmSample_t* yV = cmDspAudioBuf(ctx,inst,kOutRcId,0); + unsigned yN = cmDspAudioBufSmpCount(ctx,inst,kOutRcId,0); + + if( xV != NULL && yV != NULL ) + { + assert( xN == yN ); + cmReflectCalcExec(p->r,xV,yV,xN); + } + + return rc; +} + +cmDspRC_t _cmDspReflectCalcRecv(cmDspCtx_t* ctx, cmDspInst_t* inst, const cmDspEvt_t* evt ) +{ +//cmDspReflectCalc_t* p = (cmDspReflectCalc_t*)inst; + + cmDspSetEvent(ctx,inst,evt); + + return kOkDspRC; +} + +struct cmDspClass_str* cmReflectCalcClassCons( cmDspCtx_t* ctx ) +{ + cmDspClassSetup(&_cmReflectCalcDC,ctx,"ReflectCalc", + NULL, + _cmDspReflectCalcAlloc, + _cmDspReflectCalcFree, + _cmDspReflectCalcReset, + _cmDspReflectCalcExec, + _cmDspReflectCalcRecv, + NULL, + NULL, + "Reflecttion time calculator"); + + return &_cmReflectCalcDC; +} diff --git a/dsp/cmDspKr.h b/dsp/cmDspKr.h index 13459be..e8ac4e6 100644 --- a/dsp/cmDspKr.h +++ b/dsp/cmDspKr.h @@ -21,6 +21,7 @@ extern "C" { struct cmDspClass_str* cmSyncRecdClassCons( cmDspCtx_t* ctx ); struct cmDspClass_str* cmTakeSeqBldrClassCons( cmDspCtx_t* ctx ); struct cmDspClass_str* cmTakeSeqRendClassCons( cmDspCtx_t* ctx ); + struct cmDspClass_str* cmReflectCalcClassCons( cmDspCtx_t* ctx ); #ifdef __cplusplus } diff --git a/dsp/cmDspPgm.c b/dsp/cmDspPgm.c index 0a67855..9397504 100644 --- a/dsp/cmDspPgm.c +++ b/dsp/cmDspPgm.c @@ -26,6 +26,51 @@ #include "cmDspPgmPP.h" #include "cmDspPgmKr.h" + +cmDspRC_t _cmDspSysPgm_ReflectCalc( cmDspSysH_t h, void** userPtrPtr ) +{ + + // audio inputs + cmDspInst_t* ai0 = cmDspSysAllocInst(h,"AudioIn", NULL, 1, 0 ); + cmDspInst_t* ai1 = cmDspSysAllocInst(h,"AudioIn", NULL, 1, 1 ); + + cmDspInst_t* rc0 = cmDspSysAllocInst(h,"ReflectCalc", NULL, 0 ); + //cmDspInst_t* rc1 = cmDspSysAllocInst(h,"ReflectCalc", NULL, 0 ); + + // audio outputs + cmDspInst_t* ao0 = cmDspSysAllocInst(h,"AudioOut",NULL, 1, 0 ); + cmDspInst_t* ao1 = cmDspSysAllocInst(h,"AudioOut",NULL, 1, 1 ); + + // input meters + cmDspInst_t* im0 = cmDspSysAllocInst(h,"AMeter","In 0", 0); + cmDspInst_t* im1 = cmDspSysAllocInst(h,"AMeter","In 1", 0); + + // output meters + //cmDspInst_t* om0 = cmDspSysAllocInst(h,"AMeter","Out 0", 0); + //cmDspInst_t* om1 = cmDspSysAllocInst(h,"AMeter","Out 1",0); + + // gain controls + cmDspInst_t* igain = cmDspSysAllocInst( h,"Scalar", "In Gain", 5, kNumberDuiId, 0.0, 4.0, 0.01, 1.0); + cmDspInst_t* ogain = cmDspSysAllocInst( h,"Scalar", "Out Gain", 5, kNumberDuiId, 0.0, 4.0, 0.01, 1.0); + + cmDspSysConnectAudio(h, ai0, "out", im0, "in"); // ain0 -> imtr0 + cmDspSysConnectAudio(h, ai1, "out", im1, "in"); // ain1 -> imtr1 + + cmDspSysInstallCb( h, igain,"val", ai0, "gain", NULL); // igain -> ain0 + cmDspSysInstallCb( h, igain,"val", ai1, "gain", NULL); // igain -> ain0 + + cmDspSysInstallCb( h, ogain,"val", ao0, "gain", NULL); // igain -> ain0 + cmDspSysInstallCb( h, ogain,"val", ao1, "gain", NULL); // igain -> ain0 + + + cmDspSysConnectAudio(h, ai0,"out", rc0, "in" ); + cmDspSysConnectAudio(h, rc0,"out", ao0, "in" ); + + cmDspSysConnectAudio(h, ai1,"out", ao1, "in" ); + + return kOkDspRC; +} + cmDspRC_t _cmDspSysPgm_SyncRecd( cmDspSysH_t h, void** userPtrPtr ) { cmDspRC_t rc = kOkDspRC; @@ -2834,7 +2879,7 @@ cmDspRC_t _cmDspSysPgm_BinEnc( cmDspSysH_t h, void** userPtrPtr ) double maxDurMs = 60000.0; double azimBeg = 0.0; double azimEnd = 360.0; - const char* fn1 = "media/audio/sourcetone/Jazz/Ella & Louis - Under A Blanket Of Blue"; + //const char* fn1 = "media/audio/sourcetone/Jazz/Ella & Louis - Under A Blanket Of Blue"; const char* fn0 = "temp/comhear/drw/monty.wav"; cmDspInst_t* twod = cmDspSysAllocInst( h, "twod", NULL, 0); @@ -2901,8 +2946,7 @@ cmDspRC_t _cmDspSysPgm_BinEnc( cmDspSysH_t h, void** userPtrPtr ) _cmDspSysPgm_t _cmDspSysPgmArray[] = { - { "two-d", _cmDspSysPgm_TwoD, NULL, NULL }, - { "bin-enc", _cmDspSysPgm_BinEnc, NULL, NULL }, + { "reflect", _cmDspSysPgm_ReflectCalc, NULL, NULL }, { "tksb", _cmDspSysPgm_Tksb, NULL, NULL }, { "time_line", _cmDspSysPgm_TimeLine, NULL, NULL }, { "seq-bldr", _cmDspSysPgm_TakeSeqBldr, NULL, NULL }, @@ -2951,6 +2995,8 @@ _cmDspSysPgm_t _cmDspSysPgmArray[] = { "scalar op", _cmDspSysPgm_ScalarOp, NULL, NULL }, { "seg_line", _cmDspSysPgm_SegLine, NULL, NULL }, { "avail_ch", _cmDspSysPgm_AvailCh, NULL, NULL }, + { "two-d", _cmDspSysPgm_TwoD, NULL, NULL }, + { "bin-enc", _cmDspSysPgm_BinEnc, NULL, NULL }, { NULL , NULL, NULL, NULL } };