cml/libcm
1
0
Vork 0
Code Kwesties Pull-aanvragen Publicaties Wiki Activiteit
27c719dcc4
libcm/app/cmPickup.c

881 regels
24 KiB
C
Ruw Blame Geschiedenis

#include "cmPrefix.h"
#include "cmGlobal.h"
#include "cmFloatTypes.h"
#include "cmComplexTypes.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmLinkedHeap.h"
#include "cmSymTbl.h"
#include "cmJson.h"
#include "cmMidi.h"
#include "cmAudioFile.h"
#include "cmFile.h"
#include "cmFileSys.h"
#include "cmProcObj.h"
#include "cmProcTemplate.h"
#include "cmVectOpsTemplateMain.h"
#include "cmProc.h"
#include "cmProc2.h"
#include "cmProc3.h"
#include "cmPickup.h"
#include "cmAudLabelFile.h"
enum
{
kRmsPuId,
kMedPuId,
kDifPuId,
kAvgPuId,
kOnsPuId,
kFltPuId,
kSupPuId,
kAtkPuId,
kRlsPuId,
kSegPuId,
kPuCnt
};
typedef struct
{
cmErr_t err;
unsigned chCnt;
cmPuCh_t* chArray;
cmCtx_t ctx; // stored ctx used by cmAudLabelFileAllocOpen()
// cmProc objects
cmCtx* ctxp;
cmAudioFileRd* afrp;
cmShiftBuf* sbp;
cmGateDetect2* gdp;
cmBinMtxFile_t* mfp;
const cmChar_t* inAudFn;
const cmChar_t* inLabelFn;
const cmChar_t* outMtx0Fn;
const cmChar_t* outMtx1Fn;
const cmChar_t* outAudFn;
cmReal_t hopMs;
cmGateDetectParams gd0Args;
cmGateDetectParams gd1Args;
} cmPu_t;
cmPuH_t cmPuNullHandle = cmSTATIC_NULL_HANDLE;
cmPu_t* _cmPuHandleToPtr( cmPuH_t h )
{
cmPu_t* p = (cmPu_t*)h.h;
assert(p!=NULL);
return p;
}
cmPuRC_t cmPuAlloc( cmCtx_t* ctx, cmPuH_t* hp )
{
cmPuRC_t rc;
if((rc = cmPuFree(hp)) != kOkPuRC )
return rc;
cmPu_t* p = cmMemAllocZ(cmPu_t,1);
cmErrSetup(&p->err,&ctx->rpt,"Pickup");
p->ctx = *ctx;
hp->h = p;
return rc;
}
cmPuRC_t cmPuFree( cmPuH_t* hp )
{
if( hp == NULL || cmPuIsValid(*hp) == false )
return kOkPuRC;
cmPu_t* p = _cmPuHandleToPtr(*hp);
cmMemPtrFree(&p->chArray);
cmMemPtrFree(&p);
hp->h = NULL;
return kOkPuRC;
}
bool cmPuIsValid( cmPuH_t h )
{ return h.h != NULL; }
cmPuRC_t _cmPuReadLabelsAndCreateArray( cmPu_t* p, const cmChar_t* labelFn, cmReal_t srate )
{
cmPuRC_t rc = kOkPuRC;
cmAlfH_t h = cmAlfNullHandle;
unsigned i;
if( cmAudLabelFileAllocOpen(&p->ctx, &h, labelFn) != kOkAlfRC )
return cmErrMsg(&p->err,kAlfFileFailPuRC,"The auto-tune audio label file open failed on '%s'",cmStringNullGuard(labelFn));
if((p->chCnt = cmAudLabelFileCount(h)) == 0 )
{
rc = cmErrMsg(&p->err,kAlfFileFailPuRC,"The auto-tune audio label file '%s' does not contain any segment labels.",cmStringNullGuard(labelFn));
goto errLabel;
}
p->chArray = cmMemResizeZ(cmPuCh_t,p->chArray,p->chCnt);
for(i=0; i<p->chCnt; ++i)
{
const cmAlfLabel_t* lp;
if(( lp = cmAudLabelFileLabel(h,i)) == NULL )
{
rc = cmErrMsg(&p->err,kAlfFileFailPuRC,"The auto-tune label in '%s' at row %i could not be read.",cmStringNullGuard(labelFn),i+1);
goto errLabel;
}
p->chArray[i].begSmpIdx = floor(srate * lp->begSecs);
p->chArray[i].endSmpIdx = p->chArray[i].begSmpIdx; // default the segment to have 0 length.
}
errLabel:
if( cmAudLabelFileFree(&h) != kOkAlfRC )
rc = cmErrMsg(&p->err,kAlfFileFailPuRC,"The auto-tune label file close failed.");
return rc;
}
cmPuRC_t _cmPuWriteMtxFile(cmPu_t* p, bool segFl )
{
cmPuRC_t rc = kOkPuRC;
cmReal_t outV[ kPuCnt ];
outV[ kRmsPuId ] = p->gdp->rms;
outV[ kMedPuId ] = p->gdp->med;
outV[ kDifPuId ] = p->gdp->dif;
outV[ kAvgPuId ] = p->gdp->avg;
outV[ kOnsPuId ] = p->gdp->ons;
outV[ kFltPuId ] = p->gdp->flt;
outV[ kSupPuId ] = p->gdp->sup;
outV[ kAtkPuId ] = p->gdp->onFl;
outV[ kRlsPuId ] = p->gdp->offFl;
outV[ kSegPuId ] = segFl;
// write the output file - plot with cmGateDetectPlot.m
if( cmBinMtxFileExecR(p->mfp,outV,kPuCnt) != cmOkRC )
rc = cmErrMsg(&p->err,kProcFailPuRC,"Matrix file write failed.");
return rc;
}
void _cmPuCalcGains( cmPu_t* p )
{
unsigned i;
cmReal_t avg = 0;
if( p->chCnt == 0 )
return;
for(i=0; i<p->chCnt; ++i)
avg += p->chArray[i].gateMaxAvg;
avg /= p->chCnt;
for(i=0; i<p->chCnt; ++i)
{
cmReal_t d = p->chArray[i].gateMaxAvg==0 ? 1.0 : p->chArray[i].gateMaxAvg;
p->chArray[i].gain = avg / d;
}
}
cmPuCh_t* _cmPuIncrCh( cmPu_t* p, cmPuCh_t* chp, unsigned* segSmpIdxPtr )
{
if( *segSmpIdxPtr != p->chArray[0].begSmpIdx )
++chp;
if( chp >= p->chArray + p->chCnt )
return NULL;
if( chp+1 == p->chArray + p->chCnt )
*segSmpIdxPtr = p->afrp->info.frameCnt;
else
*segSmpIdxPtr = (chp+1)->begSmpIdx;
return chp;
}
cmPuRC_t _cmPuCalcRerunGateDetectors(
cmPu_t* p,
const cmChar_t* outMtxFn,
const cmChar_t* outAudFn,
const cmGateDetectParams* gdArgs,
unsigned procSmpCnt,
unsigned wndSmpCnt,
unsigned hopSmpCnt )
{
cmPuRC_t rc = kOkPuRC;
cmAudioFileWr* afwp = NULL;
unsigned outChCnt = 1;
unsigned outChIdx = 0;
unsigned bitsPerSmp = 16;
unsigned smpIdx = 0;
cmSample_t* smpV = NULL;
// rewind the audio file reader
if( cmAudioFileRdSeek(p->afrp,0) != cmOkRC )
{
cmErrMsg(&p->err,kProcFailPuRC,"Audio file seek failed.");
goto errLabel;
}
// reset the shift buffer
if( cmShiftBufInit( p->sbp, procSmpCnt, wndSmpCnt, hopSmpCnt ) != cmOkRC )
{
cmErrMsg(&p->err,kProcFailPuRC,"Shift buffer reset failed.");
goto errLabel;
}
// reset the gate detector
if( cmGateDetectInit2( p->gdp, procSmpCnt, gdArgs ) != cmOkRC )
{
cmErrMsg(&p->err,kProcFailPuRC,"Gate detector reset failed.");
goto errLabel;
}
// create an new matrix output file
if( cmBinMtxFileInit( p->mfp, outMtxFn ) != cmOkRC )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Output matrix file '%s' initialization failed.",cmStringNullGuard(outMtxFn));
goto errLabel;
}
// create an audio output file
if( (afwp = cmAudioFileWrAlloc(p->ctxp, NULL, procSmpCnt, outAudFn, p->afrp->info.srate, outChCnt, bitsPerSmp )) == NULL )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Output audio file '%s' initialization failed.",cmStringNullGuard(outAudFn));
goto errLabel;
}
smpV = cmMemAllocZ(cmSample_t,procSmpCnt);
cmPuCh_t* chp = p->chArray;
unsigned segSmpIdx = chp->begSmpIdx;
bool segFl = false;
// for each procSmpCnt samples
for(; cmAudioFileRdRead(p->afrp) != cmEofRC; smpIdx += procSmpCnt )
{
// apply auto-gain to the audio vector
cmVOS_MultVVS(smpV,p->afrp->outN,p->afrp->outV,chp->gain);
// is this a segment boundary
if( smpIdx+procSmpCnt >= p->afrp->info.frameCnt || (smpIdx <= segSmpIdx && segSmpIdx < smpIdx + procSmpCnt) )
{
segFl = true;
if((chp = _cmPuIncrCh(p,chp, &segSmpIdx )) == NULL )
break;
}
// shift the new samples into the shift buffer
while(cmShiftBufExec(p->sbp,smpV,p->afrp->outN))
{
// update the gate detector
cmGateDetectExec2(p->gdp,p->sbp->outV,p->sbp->outN);
if( _cmPuWriteMtxFile(p,segFl) != kOkPuRC )
goto errLabel;
segFl =false;
}
// write the audio output file
if( cmAudioFileWrExec(afwp, outChIdx,smpV,p->afrp->outN ) != cmOkRC )
{
cmErrMsg(&p->err,kProcFailPuRC,"A write failed to the audio output file '%s'.",outAudFn);
goto errLabel;
}
}
errLabel:
cmMemPtrFree(&smpV);
if( cmAudioFileWrFree(&afwp) != cmOkRC )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Output audio file '%s' close failed.",cmStringNullGuard(outAudFn));
goto errLabel;
}
return rc;
}
cmPuRC_t cmPuAutoGainCfg(
cmPuH_t h,
const cmChar_t* audioFn,
const cmChar_t* labelFn,
const cmChar_t* outMtx0Fn,
const cmChar_t* outMtx1Fn,
const cmChar_t* outAudFn,
unsigned procSmpCnt,
cmReal_t hopMs,
const cmGateDetectParams* gd0Args,
const cmGateDetectParams* gd1Args )
{
cmPuRC_t rc;
cmPu_t* p = _cmPuHandleToPtr(h);
int smpIdx = 0;
int chIdx = 0;
const cmReal_t rmsMax = 1.0;
cmReal_t minRms = rmsMax;
cmReal_t gateMax = 0;
cmReal_t gateSum = 0;
unsigned gateCnt = 0;
cmPuCh_t* chp = NULL;
bool segFl = false;
unsigned segSmpIdx = cmInvalidIdx;
// create a cmProc context
if((p->ctxp = cmCtxAlloc(NULL, p->err.rpt, cmLHeapNullHandle, cmSymTblNullHandle )) == NULL )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Proc context create failed.");
goto errLabel;
}
// create a cmProc audio file reader
if((p->afrp = cmAudioFileRdAlloc(p->ctxp, NULL, procSmpCnt, audioFn, chIdx, 0, cmInvalidIdx)) == NULL )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Audio file reader creation failed on '%s'.",cmStringNullGuard(audioFn));
goto errLabel;
}
// given the sample rate calculate the hop and window size in samples
unsigned hopSmpCnt = floor(p->afrp->info.srate * hopMs / 1000);
unsigned wndSmpCnt = hopSmpCnt * gd0Args->medCnt;
// create a shift buffer to maintain the RMS window for the gate detector
if((p->sbp = cmShiftBufAlloc(p->ctxp,NULL,procSmpCnt,wndSmpCnt,hopSmpCnt )) == NULL )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Shift buffer create failed.");
goto errLabel;
}
// create a gate detector
if((p->gdp = cmGateDetectAlloc2(p->ctxp,NULL,procSmpCnt,gd0Args)) == NULL )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Gate detect create failed.");
goto errLabel;
}
// create an output file to hold the results of the gate detector
if( (p->mfp = cmBinMtxFileAlloc(p->ctxp,NULL,outMtx0Fn)) == NULL )
{
rc = cmErrMsg(&p->err,kProcFailPuRC,"Binary matrix file create failed.");
goto errLabel;
}
// read the label file and create p->chArray
if((rc = _cmPuReadLabelsAndCreateArray(p, labelFn, p->afrp->info.srate)) != kOkPuRC )
goto errLabel;
chp = p->chArray;
segSmpIdx = chp->begSmpIdx;
// for each procSmpCnt samples
for(; cmAudioFileRdRead(p->afrp) != cmEofRC; smpIdx += procSmpCnt )
{
// if this audio frame marks a segment beginning or
// the end-of-audio-file will occur on the next frame
if( smpIdx+procSmpCnt >= p->afrp->info.frameCnt || (smpIdx <= segSmpIdx && segSmpIdx < smpIdx + procSmpCnt) )
{
segFl = true;
// if no ending offset was located then update the gate sum
if( gateMax != 0 )
{
gateSum += gateMax;
gateCnt += 1;
gateMax = 0;
}
// calc the avg max RMS value for this segment
chp->gateMaxAvg = gateCnt == 0 ? 0.0 : gateSum / gateCnt;
gateCnt = 0;
gateSum = 0;
gateMax = 0;
minRms = rmsMax; // force the segment end to be after the segment beginning
if((chp = _cmPuIncrCh(p,chp, &segSmpIdx )) == NULL )
break;
}
// shift the new samples into the shift buffer
while(cmShiftBufExec(p->sbp,p->afrp->outV,p->afrp->outN))
{
// update the gate detector
cmGateDetectExec2(p->gdp,p->sbp->outV,p->sbp->outN);
// write the output matrix file
if( _cmPuWriteMtxFile(p,segFl) != kOkPuRC )
goto errLabel;
segFl = false;
// if this frame is an RMS minimum or onset or offset
// then select it as a possible segment end.
// Note that for onsets this will effectively force the end to
// come after the onset because the onset will not be an energy minimum
// relative to subsequent frames.
if( p->gdp->rms < minRms || p->gdp->onFl || p->gdp->offFl )
{
minRms = p->gdp->rms;
chp->endSmpIdx = smpIdx;
// count onsets
if( p->gdp->onFl )
++chp->onCnt;
// count offsets
if( p->gdp->offFl )
{
++chp->offCnt;
// update the gate sum and count
gateSum += gateMax;
gateCnt += 1;
gateMax = 0;
}
}
// track the max RMS value during this gate
if( p->gdp->gateFl && p->gdp->rms > gateMax )
gateMax = p->gdp->rms;
}
}
// calculate the channel gains
if( rc == kOkPuRC )
_cmPuCalcGains(p);
rc = _cmPuCalcRerunGateDetectors(p,outMtx1Fn,outAudFn,gd1Args,procSmpCnt,wndSmpCnt,hopSmpCnt);
p->gd0Args = *gd0Args;
p->gd1Args = *gd1Args;
errLabel:
if( p->mfp != NULL )
cmBinMtxFileFree(&p->mfp);
if( p->gdp != NULL )
cmGateDetectFree2(&p->gdp);
if( p->sbp != NULL )
cmShiftBufFree(&p->sbp);
if( p->afrp != NULL )
cmAudioFileRdFree(&p->afrp);
if( p->ctxp != NULL )
cmCtxFree(&p->ctxp);
return rc;
}
cmPuRC_t cmPuAutoGainExec( cmPuH_t h, const cmChar_t* fileDir, unsigned procSmpCnt )
{
cmPu_t* p = _cmPuHandleToPtr(h);
const cmChar_t* inAudFn = cmFsMakeFn(fileDir, p->inAudFn, NULL, NULL );
const cmChar_t* inLabelFn = cmFsMakeFn(fileDir, p->inLabelFn, NULL, NULL );
const cmChar_t* outMtx0Fn = cmFsMakeFn(fileDir, p->outMtx0Fn, NULL, NULL );
const cmChar_t* outMtx1Fn = cmFsMakeFn(fileDir, p->outMtx1Fn, NULL, NULL );
const cmChar_t* outAudFn = cmFsMakeFn(fileDir, p->outAudFn, NULL, NULL );
cmPuRC_t rc = cmPuAutoGainCfg(h,inAudFn,inLabelFn,outMtx0Fn,outMtx1Fn,outAudFn,procSmpCnt,p->hopMs,&p->gd0Args,&p->gd1Args);
cmFsFreeFn(outAudFn);
cmFsFreeFn(outMtx1Fn);
cmFsFreeFn(outMtx0Fn);
cmFsFreeFn(inLabelFn);
cmFsFreeFn(inAudFn);
return rc;
}
cmPuRC_t cmPuAutoGainCfgFromJson(
cmPuH_t h,
const cmChar_t* cfgDir,
cmJsonH_t jsH,
cmJsonNode_t* onp,
unsigned procSmpCnt )
{
cmPuRC_t rc;
if((rc = cmPuReadJson(h,jsH,onp)) != kOkPuRC )
return rc;
return cmPuAutoGainExec(h,cfgDir,procSmpCnt);
}
void cmPuReport( cmPuH_t h, cmRpt_t* rpt )
{
cmPu_t* p = _cmPuHandleToPtr(h);
unsigned i;
for(i=0; i<p->chCnt; ++i)
{
const cmPuCh_t* chp = p->chArray + i;
cmRptPrintf(rpt,"beg:%i end:%i on:%i off:%i max:%f gain:%f\n",
chp->begSmpIdx, chp->endSmpIdx, chp->onCnt, chp->offCnt, chp->gateMaxAvg, chp->gain );
}
}
cmPuRC_t _cmPuJsonGainRead( cmPu_t* p, cmJsonH_t jsH, cmJsonNode_t* onp, const cmChar_t* label )
{
cmPuRC_t rc = kOkPuRC;
cmJsonNode_t* arp;
unsigned arrCnt = 0;
cmPuCh_t* arr = NULL;
// locate the JSON 'gain' array
if(( arp = cmJsonFindValue(jsH,label,onp,kArrayTId)) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Unable to locate the JSON array node %s.",cmStringNullGuard(label));
goto errLabel;
}
// get the count of elements in the 'gain' array
arrCnt = cmJsonChildCount(arp);
if( arrCnt > 0 )
{
arr = cmMemAllocZ(cmPuCh_t,arrCnt);
unsigned i;
for(i=0; i<arrCnt; ++i)
{
if( i<p->chCnt )
arr[i] = p->chArray[i];
if( cmJsonRealValue( cmJsonArrayElement(arp,i), &arr[i].gain ) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"An error occurred while accessing a JSON 'gain' element.");
goto errLabel;
}
}
}
errLabel:
if( rc != kOkPuRC )
{
cmMemPtrFree(&arr);
arrCnt = 0;
}
cmMemPtrFree(&p->chArray);
p->chArray = arr;
p->chCnt = arrCnt;
return rc;
}
cmPuRC_t _cmPuJsonGdParmsRead( cmPu_t* p, cmJsonH_t jsH, cmJsonNode_t* onp, const cmChar_t* label, cmGateDetectParams* gdParms )
{
cmPuRC_t rc = kOkPuRC;
cmJsonNode_t* gdp;
const char* errLabelPtr;
if(( gdp = cmJsonFindValue(jsH,label,onp,kObjectTId)) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Unable to locate the JSON object node %s.",cmStringNullGuard(label));
goto errLabel;
}
if( cmJsonMemberValues(gdp, &errLabelPtr,
"medCnt", kIntTId, &gdParms->medCnt,
"avgCnt", kIntTId, &gdParms->avgCnt,
"suprCnt", kIntTId, &gdParms->suprCnt,
"offCnt", kIntTId, &gdParms->offCnt,
"suprCoeff", kRealTId, &gdParms->suprCoeff,
"onThreshDb", kRealTId, &gdParms->onThreshDb,
"offThreshDb", kRealTId, &gdParms->offThreshDb,
NULL ) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Gate detect parameter restore failed for '%s'.",cmStringNullGuard(label));
goto errLabel;
}
errLabel:
return rc;
}
cmPuRC_t _cmPuJsonCfgParmsRead(cmPu_t* p, cmJsonH_t jsH, cmJsonNode_t* onp)
{
cmPuRC_t rc = kOkPuRC;
cmJsonNode_t* gdp = onp;
const char* errLabelPtr;
//if(( gdp = cmJsonFindValue(jsH,label,onp,kObjectTId)) == NULL )
//{
// rc = cmErrMsg(&p->err,kJsonFailPuRC,"Unable to locate the JSON object node %s.",cmStringNullGuard(label));
// goto errLabel;
// }
if( cmJsonMemberValues(gdp, &errLabelPtr,
"audioFn", kStringTId, &p->inAudFn,
"labelFn", kStringTId, &p->inLabelFn,
"outMtx0Fn", kStringTId, &p->outMtx0Fn,
"outMtx1Fn", kStringTId, &p->outMtx1Fn,
"outAudFn", kStringTId, &p->outAudFn,
"hopMs", kRealTId, &p->hopMs,
NULL ) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Autotune cfg parameter read failed.");
goto errLabel;
}
errLabel:
return rc;
}
cmPuRC_t cmPuReadJson( cmPuH_t h, cmJsonH_t jsH, cmJsonNode_t* onp )
{
cmPuRC_t rc = kOkPuRC;
cmPu_t* p = _cmPuHandleToPtr(h);
cmJsonNode_t* atp;
if(( atp = cmJsonFindValue(jsH,"cfg",onp,kObjectTId)) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"The JSON 'autotune' object was not found.");
goto errLabel;
}
if((rc = _cmPuJsonCfgParmsRead(p,jsH,atp)) != kOkPuRC )
goto errLabel;
if((rc = _cmPuJsonGdParmsRead(p,jsH,atp,"gdParms0",&p->gd0Args)) != kOkPuRC )
goto errLabel;
if((rc = _cmPuJsonGdParmsRead(p,jsH,atp,"gdParms1",&p->gd1Args)) != kOkPuRC )
goto errLabel;
if((rc = _cmPuJsonGainRead(p,jsH,atp,"gain")) != kOkPuRC )
goto errLabel;
errLabel:
return rc;
}
unsigned cmPuChannelCount( cmPuH_t h )
{
cmPu_t* p = _cmPuHandleToPtr(h);
return p->chCnt;
}
const cmPuCh_t* cmPuChannel( cmPuH_t h, unsigned chIdx )
{
cmPu_t* p = _cmPuHandleToPtr(h);
assert( chIdx < p->chCnt );
return p->chArray + chIdx;
}
cmPuRC_t _cmPuJsonSetInt( cmPu_t* p, cmJsonH_t jsH, cmJsonNode_t* gdp, const cmChar_t* label, int val )
{
cmPuRC_t rc = kOkPuRC;
if( cmJsonReplacePairInt(jsH, gdp, label, kIntTId | kRealTId, val ) != kOkJsRC )
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Error setting integer JSON field: %s.",cmStringNullGuard(label));
return rc;
}
cmPuRC_t _cmPuJsonSetReal( cmPu_t* p, cmJsonH_t jsH, cmJsonNode_t* gdp, const cmChar_t* label, cmReal_t val )
{
cmPuRC_t rc = kOkPuRC;
if( cmJsonReplacePairReal(jsH, gdp, label, kIntTId | kRealTId, val ) != kOkJsRC )
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Error setting real JSON field: %s.",cmStringNullGuard(label));
return rc;
}
cmPuRC_t _cmPuJsonGdParmsUpdate( cmPu_t* p, cmJsonH_t jsH, cmJsonNode_t* onp, const cmChar_t* label, const cmGateDetectParams* gdParms )
{
cmPuRC_t rc = kOkPuRC;
cmJsonNode_t* gdp;
if(( gdp = cmJsonFindValue(jsH,label,onp,kObjectTId)) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Unable to locate the JSON object node %s.",cmStringNullGuard(label));
goto errLabel;
}
_cmPuJsonSetInt( p, jsH, gdp, "medCnt", gdParms->medCnt);
_cmPuJsonSetInt( p, jsH, gdp, "avgCnt", gdParms->avgCnt);
_cmPuJsonSetInt( p, jsH, gdp, "suprCnt", gdParms->suprCnt);
_cmPuJsonSetInt( p, jsH, gdp, "offCnt", gdParms->offCnt);
_cmPuJsonSetReal( p, jsH, gdp, "suprCoeff", gdParms->suprCoeff);
_cmPuJsonSetReal( p, jsH, gdp, "onThreshDb", gdParms->onThreshDb);
_cmPuJsonSetReal( p, jsH, gdp, "offThresDb", gdParms->offThreshDb);
rc = cmErrLastRC(&p->err);
errLabel:
return rc;
}
cmPuRC_t _cmPuJsonGainUpdate( cmPu_t* p, cmJsonH_t jsH, cmJsonNode_t* onp, const cmChar_t* label )
{
cmPuRC_t rc = kOkPuRC;
cmJsonNode_t* arp;
unsigned i;
// locate the JSON 'gain' array
if(( arp = cmJsonFindValue(jsH,label,onp,kArrayTId)) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Unable to locate the JSON array node %s.",cmStringNullGuard(label));
goto errLabel;
}
// get the count of elements in the 'gain' array
unsigned arrCnt = cmJsonChildCount(arp);
// update the existing 'gain' array elmements from p->chArray[]
for(i=0; i<arrCnt && i<p->chCnt; ++i)
{
if(cmJsonSetReal( jsH, cmJsonArrayElement(arp,i), p->chArray[i].gain ) != kOkPuRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"Set JSON 'gain' array elment failed.");
goto errLabel;
}
}
// create new elements if the array was not long enough
for(; i<p->chCnt; ++i)
if( cmJsonCreateReal(jsH,arp,p->chArray[i].gain) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"JSON 'gain' element create failed.");
goto errLabel;
}
// remove elements if the array begain with extra elements.
if( arrCnt > p->chCnt )
{
if( cmJsonRemoveNode( jsH, cmJsonArrayElement(arp,i), true ) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"JSON 'gain' element removal failed.");
goto errLabel;
}
}
errLabel:
return rc;
}
cmPuRC_t cmPuWriteJson( cmPuH_t h, cmJsonH_t jsH, cmJsonNode_t* onp )
{
cmPuRC_t rc = kOkPuRC;
cmPu_t* p = _cmPuHandleToPtr(h);
cmJsonNode_t* atp;
if(( atp = cmJsonFindValue(jsH,"autoTune",onp,kObjectTId)) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"The JSON 'autotune' object was not found.");
goto errLabel;
}
if((rc = _cmPuJsonGdParmsUpdate(p,jsH,atp,"gdParms0",&p->gd0Args)) != kOkPuRC )
goto errLabel;
if((rc = _cmPuJsonGdParmsUpdate(p,jsH,atp,"gdParms1",&p->gd1Args)) != kOkPuRC )
goto errLabel;
if((rc = _cmPuJsonGainUpdate(p,jsH,atp,"gain")) != kOkPuRC )
goto errLabel;
errLabel:
return rc;
}
cmPuRC_t cmPuWriteJsonFile( cmPuH_t h, const cmChar_t* jsonFn )
{
cmPuRC_t rc = kOkPuRC;
cmJsonH_t jsH = cmJsonNullHandle;
cmPu_t* p = _cmPuHandleToPtr(h);
// initialize a JSON tree from 'jsonFn'.
if( cmJsonInitializeFromFile(&jsH,jsonFn,&p->ctx) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"JSON file initialization failed on '%s'.",cmStringNullGuard(jsonFn));
goto errLabel;
}
// update the 'autoTune' object in the JSON tree
if((rc = cmPuWriteJson(h,jsH,cmJsonRoot(jsH))) != kOkPuRC )
goto errLabel;
// write the JSON tree back to 'jsonFn'.
if( cmJsonWrite(jsH,cmJsonRoot(jsH),jsonFn) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailPuRC,"JSON file save failed on '%s'.",cmStringNullGuard(jsonFn));
goto errLabel;
}
errLabel:
// release the JSON tree
if( cmJsonFinalize(&jsH) != kOkJsRC )
rc = cmErrMsg(&p->err,kJsonFailPuRC,"JSON file finalization failed on '%s'.",cmStringNullGuard(jsonFn));
return rc;
}
void cmPuTest(cmCtx_t* ctx)
{
cmPuH_t h = cmPuNullHandle;
cmGateDetectParams gd0Args;
cmGateDetectParams gd1Args;
const cmChar_t* audioFn = "/home/kevin/media/audio/gate_detect/gate_detect0.aif";
const cmChar_t* labelFn = "/home/kevin/media/audio/gate_detect/gate_detect0_labels.txt";
const cmChar_t* outMtx0Fn = "/home/kevin/media/audio/gate_detect/gd0.mtx";
const cmChar_t* outMtx1Fn = "/home/kevin/media/audio/gate_detect/gd1.mtx";
const cmChar_t* outAudFn = "/home/kevin/media/audio/gate_detect/gd_gain0.aif";
const cmChar_t* jsonFn = "/home/kevin/src/kc/src/data/rsrc1.txt";
unsigned procSmpCnt = 64;
cmReal_t hopMs = 10;
gd0Args.medCnt = 5;
gd0Args.avgCnt = 9;
gd0Args.suprCnt = 6;
gd0Args.offCnt = 3;
gd0Args.suprCoeff = 1.4;
gd0Args.onThreshDb = -53.0;
gd0Args.offThreshDb = -80.0;
gd1Args = gd0Args;
gd1Args.onThreshDb = -45;
if( cmPuAlloc(ctx, &h ) != kOkPuRC )
goto errLabel;
if( cmPuAutoGainCfg(h,audioFn,labelFn,outMtx0Fn,outMtx1Fn,outAudFn,procSmpCnt,hopMs,&gd0Args,&gd1Args) == kOkPuRC )
{
cmPuReport(h,&ctx->rpt);
cmPuWriteJsonFile( h, jsonFn );
}
errLabel:
cmPuFree(&h);
}
Verwijs in nieuw issue Bekijk Git Blame Permalink kopiëren