cml/libcm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
25932dc723
libcm/app/cmSdb.c

725 lines
17 KiB
C
Raw Blame History

#include "cmGlobal.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmLinkedHeap.h"
#include "cmLex.h"
#include "cmCsv.h"
#include "cmSdb.h"
#include "cmText.h"
typedef enum
{
kUuidColIdx,
kBaseUuidColIdx,
kChIdxColIdx,
kObiColIdx,
kIbiColIdx,
kIeiColIdx,
kOeiColIdx,
kSrcColIdx,
kMidiColIdx,
kInstrColIdx,
kSrateColIdx,
kChCntColIdx,
kNotesColIdx,
kAfnColIdx,
kInvalidColIdx
} cmSdbColIdx_t;
struct cmSdb_str;
typedef struct cmSdbRspBlk_str
{
unsigned* indexV; // indexV[ cmSdb_t.blkIdxAllocCnt ]
unsigned cnt; // count of indexes used
struct cmSdbRspBlk_str* link; // cmSdbRsp_t.blocks link
} cmSdbRspBlk_t;
typedef struct cmSdbRsp_str
{
struct cmSdb_str* p; //
cmSdbRspBlk_t* blocks; // first block ptr
cmSdbRspBlk_t* ebp; // end block ptr
unsigned cnt; // total count of indexes
struct cmSdbRsp_str* link; // cmSdb_t.responses link
} cmSdbRsp_t;
typedef struct cmSdb_str
{
cmCtx_t ctx;
cmLHeapH_t lhH;
cmCsvH_t csvH;
cmSdbEvent_t* eV;
unsigned eN;
unsigned blkIdxAllocCnt;
struct cmSdbRsp_str* responses;
} cmSdb_t;
cmSdbH_t cmSdbNullHandle = cmSTATIC_NULL_HANDLE;
cmSdbResponseH_t cmSdbResponseNullHandle = cmSTATIC_NULL_HANDLE;
cmSdb_t* _cmSdbHandleToPtr( cmSdbH_t h )
{
cmSdb_t* p = (cmSdb_t*)h.h;
assert( p != NULL );
return p;
}
cmSdbRsp_t* _cmSdbRspHandleToPtr( cmSdbResponseH_t h )
{
cmSdbRsp_t* p = (cmSdbRsp_t*)h.h;
assert( p != NULL );
return p;
}
void _cmSdbRspBlkFree( cmSdb_t* p, cmSdbRspBlk_t* bp )
{
cmLhFree(p->lhH, bp->indexV);
cmLhFree(p->lhH, bp);
}
cmSdbRspBlk_t* _cmSdbRspBlkUnlink( cmSdbRsp_t* rp, cmSdbRspBlk_t* bp )
{
cmSdbRspBlk_t* dp = rp->blocks;
cmSdbRspBlk_t* pp = NULL;
for(; dp!=NULL; dp=dp->link)
{
if( dp == bp )
{
if( pp == NULL )
rp->blocks = dp->link;
else
pp->link = dp->link;
return bp;
}
pp = dp;
}
assert(0);
return NULL;
}
void _cmSdbRspInsertIndex( cmSdb_t* p, cmSdbRsp_t* rp, unsigned evtIndex )
{
if( rp->ebp == NULL || rp->ebp->cnt == p->blkIdxAllocCnt )
{
cmSdbRspBlk_t* bp = cmLhAllocZ(p->lhH,cmSdbRspBlk_t,1);
bp->indexV = cmLhAllocZ(p->lhH,unsigned,p->blkIdxAllocCnt);
if( rp->ebp != NULL )
rp->ebp->link = bp;
if( rp->blocks == NULL )
rp->blocks = bp;
rp->ebp = bp;
}
assert( rp->ebp!=NULL && rp->ebp->cnt < p->blkIdxAllocCnt );
rp->ebp->indexV[ rp->ebp->cnt++ ] = evtIndex;
rp->cnt += 1;
}
void _cmSdbRspRelease( cmSdbRsp_t* rp )
{
while( rp->blocks != NULL )
{
cmSdbRspBlk_t* np = rp->blocks->link;
cmSdbRspBlk_t* bp;
if((bp = _cmSdbRspBlkUnlink(rp,rp->blocks)) != NULL )
_cmSdbRspBlkFree(rp->p,bp);
rp->blocks = np;
}
cmLhFree(rp->p->lhH,rp);
}
cmSdbRsp_t* _cmSdbRspUnlink( cmSdbRsp_t* rp )
{
cmSdb_t* p = rp->p;
cmSdbRsp_t* dp = p->responses;
cmSdbRsp_t* pp = NULL;
for(; dp!=NULL; dp=dp->link)
{
if( dp == rp )
{
if( pp == NULL )
p->responses = dp->link;
else
pp->link = dp->link;
return rp;
}
pp = dp;
}
assert( 0 );
return NULL;
}
void _cmSdbRspFree( cmSdbRsp_t* rp )
{
_cmSdbRspUnlink(rp);
_cmSdbRspRelease(rp);
}
cmSdbRsp_t* _cmSdbRspAlloc( cmSdb_t* p, cmSdbResponseH_t* rhp )
{
if( cmSdbResponseFree(rhp) != kOkSdbRC )
return NULL;
cmSdbRsp_t* rp = cmLhAllocZ(p->lhH,cmSdbRsp_t,1);
rp->p = p;
rp->link = p->responses;
p->responses = rp;
rhp->h = rp;
return rp;
}
cmSdbRC_t _cmSdbDestroy( cmSdb_t* p )
{
cmSdbRC_t rc = kOkSdbRC;
if( cmCsvFinalize(&p->csvH) != kOkCsvRC )
rc = cmErrMsg(&p->ctx.err,kCsvFailSdbRC,"CSV file finalize failed.");
while( p->responses != NULL )
_cmSdbRspRelease(p->responses);
cmLHeapDestroy(&p->lhH);
cmMemFree(p);
return rc;
}
cmSdbRC_t cmSdbCreate( cmCtx_t* ctx, cmSdbH_t* hp, const cmChar_t* audioDir, const cmChar_t* csvFn )
{
cmSdbRC_t rc;
if((rc = cmSdbDestroy(hp)) != kOkSdbRC )
return rc;
cmSdb_t* p = cmMemAllocZ(cmSdb_t,1);
p->ctx = *ctx;
p->blkIdxAllocCnt = 1024;
cmErrSetup(&p->ctx.err,&ctx->rpt,"sdb");
if( cmLHeapIsValid( p->lhH = cmLHeapCreate(8192,ctx)) == false )
{
rc = cmErrMsg(&p->ctx.err,kLHeapFailSdbRC,"Linked heap mgr. allocation failed.");
goto errLabel;
}
hp->h = p;
if( csvFn != NULL )
if((rc = cmSdbLoad(*hp,csvFn)) != kOkSdbRC )
goto errLabel;
errLabel:
if( rc != kOkSdbRC )
_cmSdbDestroy(p);
return rc;
}
cmSdbRC_t cmSdbDestroy( cmSdbH_t* hp )
{
cmSdbRC_t rc = kOkSdbRC;
if( hp==NULL || cmSdbIsValid(*hp)==false )
return rc;
cmSdb_t* p = _cmSdbHandleToPtr(*hp);
if((rc = _cmSdbDestroy(p)) != kOkSdbRC )
return rc;
hp->h = NULL;
return rc;
}
bool cmSdbIsValid( cmSdbH_t h )
{ return h.h != NULL; }
cmSdbRC_t _cmSdbSyntaxError(cmSdb_t* p, const cmChar_t* csvFn, unsigned rowIdx, unsigned colIdx, const cmChar_t* colLabel )
{
return cmErrMsg(&p->ctx.err,kSyntaxErrSdbRC,"A syntax error was found at row %i col %i (label:%s) in '%s'.",rowIdx+1,colIdx+1,cmStringNullGuard(colLabel),cmStringNullGuard(csvFn));
}
cmSdbRC_t cmSdbLoad( cmSdbH_t h, const cmChar_t* csvFn )
{
cmSdbRC_t rc = kOkSdbRC;
unsigned i;
cmSdb_t* p = _cmSdbHandleToPtr(h);
if( cmCsvInitializeFromFile(&p->csvH, csvFn, 0, &p->ctx ) != kOkCsvRC )
{
rc = cmErrMsg(&p->ctx.err,kCsvFailSdbRC,"CSV file load fail on '%s'.",cmStringNullGuard(csvFn));
goto errLabel;
}
p->eN = cmCsvRowCount(p->csvH)-1;
// release all the memory held by the linked heap
cmLHeapClear(p->lhH,true);
p->eV = cmLhAllocZ(p->lhH,cmSdbEvent_t,p->eN);
for(i=0; rc==kOkSdbRC && i<p->eN; ++i)
{
unsigned rowIdx = i+1;
if((p->eV[i].uuid = cmCsvCellUInt(p->csvH,rowIdx,kUuidColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kUuidColIdx,"uuid");
if((p->eV[i].baseUuid = cmCsvCellUInt(p->csvH,rowIdx,kBaseUuidColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kBaseUuidColIdx,"baseUuid");
if((p->eV[i].chIdx = cmCsvCellUInt(p->csvH,rowIdx,kChIdxColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kChIdxColIdx,"chIdx");
else
p->eV[i].chIdx -= 1; // CSV channel index is 1 based
if((p->eV[i].obi = cmCsvCellUInt(p->csvH,rowIdx,kObiColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kObiColIdx,"obi");
else
p->eV[i].obi -= 1;
if((p->eV[i].ibi = cmCsvCellUInt(p->csvH,rowIdx,kIbiColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kIbiColIdx,"ibi");
else
p->eV[i].ibi -= 1;
if((p->eV[i].iei = cmCsvCellUInt(p->csvH,rowIdx,kIeiColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kIeiColIdx,"obi");
else
p->eV[i].iei -= 1;
if((p->eV[i].oei = cmCsvCellUInt(p->csvH,rowIdx,kOeiColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kOeiColIdx,"ibi");
else
p->eV[i].oei -= 1;
if((p->eV[i].src = cmCsvCellText(p->csvH,rowIdx,kSrcColIdx)) == NULL )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kSrcColIdx,"src");
if((p->eV[i].midi = cmCsvCellInt(p->csvH,rowIdx,kMidiColIdx)) == INT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kMidiColIdx,"midi");
if((p->eV[i].instr = cmCsvCellText(p->csvH,rowIdx,kInstrColIdx)) == NULL )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kInstrColIdx,"instr");
if((p->eV[i].srate = cmCsvCellUInt(p->csvH,rowIdx,kSrateColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kSrateColIdx,"srate");
if((p->eV[i].chCnt = cmCsvCellUInt(p->csvH,rowIdx,kChCntColIdx)) == UINT_MAX )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kChCntColIdx,"chCnt");
cmCsvCell_t* c;
if((c = cmCsvCellPtr(p->csvH,rowIdx,kNotesColIdx)) == NULL )
{
rc = cmErrMsg(&p->ctx.err,kSyntaxErrSdbRC,"Syntax Error: No 'notes' or 'audio file name' field for row %i in '%s'.",rowIdx+1,cmStringNullGuard(csvFn));
goto errLabel;
}
// count the number of 'notes'
unsigned nn = 0;
for(; c->rowPtr != NULL; c=c->rowPtr)
++nn;
if( nn > 0 )
{
unsigned k = 0;
// allocate the 'notes' ptr array - the last entry is set to NULL.
p->eV[i].notesV = cmLhAllocZ(p->lhH,const cmChar_t*,nn+1);
// read each note
for(c=cmCsvCellPtr(p->csvH,rowIdx,kNotesColIdx); c!=NULL&&c->rowPtr!=NULL; c=c->rowPtr,++k)
if(( p->eV[i].notesV[k] = cmCsvCellText(p->csvH,rowIdx,kNotesColIdx+k)) == NULL )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kNotesColIdx+k,"notes");
assert(k==nn);
}
// read the audio file name
if((p->eV[i].afn = cmCsvCellText(p->csvH,rowIdx,kNotesColIdx+nn)) == NULL )
rc = _cmSdbSyntaxError(p,csvFn,rowIdx,kNotesColIdx+nn,"afn");
}
errLabel:
return rc;
}
// Compare 'label' to every string in tV[i] and return true if any comparision is a match.
// If 'subFlV[i]' is set then 'label' must only contain tV[i] as a substring to match.
// If 'negFlV[i]' is set then return true if any comparision is a mismatch.
bool _cmSdbSelectText( const cmSdbEvent_t* r, const cmChar_t** tV, const bool* subFlV, const bool* negFlV, const cmChar_t* label )
{
unsigned i;
if( label == NULL )
return false;
if( tV == NULL )
return true;
for(i=0; tV[i]!=NULL; ++i)
{
bool matchFl = false;
if( subFlV[i] )
matchFl = strstr(label,tV[i]) != NULL;
else
matchFl = strcmp(tV[i],label)==0;
if( negFlV[i] )
matchFl = !matchFl;
if(matchFl)
return true;
}
return false;
}
unsigned _cmSdbStrVectCnt( const cmChar_t** v )
{
unsigned n = 0;
unsigned i = 0;
if( v == NULL )
return 0;
for(i=0; v[i]!=NULL; ++i)
++n;
return n;
}
void _cmSdbStrVectFlags( const cmChar_t** v, bool* sV, bool* nV )
{
unsigned i = 0;
if( v == NULL )
return;
for(i=0; v[i]!=NULL; ++i)
{
nV[i] = false;
sV[i] = false;
if( strncmp(v[i],"*!",2)==0 || strncmp(v[i],"!*",2)==0)
{
sV[i] = nV[i] = true;
v[i] += 2;
}
else
{
if( strncmp(v[i],"!",1)==0 )
{
nV[i] = true;
v[i] += 1;
}
if( strncmp(v[i],"*",1)==0 )
{
sV[i] = true;
v[i] += 1;
}
}
}
}
cmSdbRC_t cmSdbSelect(
cmSdbH_t h,
double srate,
const cmChar_t** instrV,
const cmChar_t** srcV,
const cmChar_t** notesV,
double minDurSec,
double maxDurSec,
unsigned minChCnt,
cmSdbResponseH_t* rhp )
{
cmSdbRC_t rc = kOkSdbRC;
cmSdb_t* p = _cmSdbHandleToPtr(h);
unsigned i;
cmSdbRsp_t* rp = _cmSdbRspAlloc(p,rhp);
// get the length of each string vector
unsigned srcN = _cmSdbStrVectCnt(srcV);
unsigned insN = _cmSdbStrVectCnt(instrV);
unsigned notN = _cmSdbStrVectCnt(notesV);
// allocate flag vectors
bool srcSubFlV[ srcN ];
bool srcNegFlV[ srcN ];
bool insSubFlV[ insN ];
bool insNegFlV[ insN ];
bool notSubFlV[ notN ];
bool notNegFlV[ notN ];
// fill the flag vectors
_cmSdbStrVectFlags(srcV, srcSubFlV,srcNegFlV);
_cmSdbStrVectFlags(instrV,insSubFlV,insNegFlV);
_cmSdbStrVectFlags(notesV,notSubFlV,notNegFlV);
for(i=0; i<p->eN; ++i)
{
const cmSdbEvent_t* r = p->eV + i;
double durSec = (double)r->srate * (r->oei - r->obi);
unsigned j;
if( srate!=0 && srate!=r->srate )
continue;
if( durSec < minDurSec || (maxDurSec!=0 && maxDurSec < durSec) )
continue;
if( minChCnt!=0 && r->chCnt > minChCnt )
continue;
if( !_cmSdbSelectText(r,srcV,srcSubFlV,srcNegFlV,r->src) )
continue;
if( !_cmSdbSelectText(r,instrV,insSubFlV,insNegFlV,r->instr) )
continue;
if( r->notesV != NULL )
for(j=0; r->notesV[j]!=NULL; ++j)
if( _cmSdbSelectText(r,notesV,notSubFlV,notNegFlV,r->notesV[j]) == true )
break;
if( r->notesV[j]==NULL )
continue;
_cmSdbRspInsertIndex(p,rp,i);
}
return rc;
}
cmSdbRC_t cmSdbSelectChPairs( cmSdbH_t h, const cmSdbEvent_t* ep, cmSdbResponseH_t* rhp )
{
cmSdbRC_t rc = kOkSdbRC;
cmSdb_t* p = _cmSdbHandleToPtr(h);
cmSdbRsp_t* rp = _cmSdbRspAlloc(p,rhp);
unsigned i;
// for each channel of this event
for(i=0; i<ep->chCnt; ++i)
{
// if i channel is not the known events channel
if( ep->chIdx != i )
{
unsigned j;
// examine each record
for(j=0; j<p->eN; ++j)
// if eV[j] shares a baseUuid but is on a different channel than *ep ...
if( p->eV[j].baseUuid == ep->baseUuid && p->eV[j].chIdx==i )
{
// .. then a match has been found
_cmSdbRspInsertIndex(p,rp,j);
break;
}
if( j== p->eN )
{
rc = cmErrMsg(&p->ctx.err,kChPairNotFoundSdbRC,"The channel pair associated with 'id:%i instr:%s src:%s ch index:%i could not be found.",ep->uuid,cmStringNullGuard(ep->instr),cmStringNullGuard(ep->src),ep->chIdx);
}
}
}
return rc;
}
unsigned cmSdbResponseCount( cmSdbResponseH_t rh )
{
cmSdbRsp_t* rp = _cmSdbRspHandleToPtr(rh);
return rp->cnt;
}
const cmSdbEvent_t* cmSdbResponseEvent( cmSdbResponseH_t rh, unsigned index )
{
cmSdbRsp_t* rp = _cmSdbRspHandleToPtr(rh);
if( index >= rp->cnt )
return NULL;
cmSdbRspBlk_t* bp = rp->blocks;
unsigned i;
for(i=0; bp!=NULL; i+=bp->cnt,bp=bp->link)
if( i <= index && index < (i + bp->cnt) )
return rp->p->eV + bp->indexV[index-i];
cmErrMsg(&rp->p->ctx.err,kInvalidRspIdxSdbRC,"Invalid query response index=%i.",index);
return NULL;
}
bool cmSdbResponseIsValid( cmSdbResponseH_t rh )
{ return rh.h != NULL; }
cmSdbRC_t cmSdbResponseFree( cmSdbResponseH_t* rhp )
{
cmSdbRC_t rc = kOkSdbRC;
if( rhp == NULL || cmSdbResponseIsValid(*rhp)==false )
return rc;
cmSdbRsp_t* rp = _cmSdbRspHandleToPtr(*rhp);
_cmSdbRspFree(rp);
rhp->h = NULL;
return rc;
}
void cmSdbResponsePrint( cmSdbResponseH_t rh, cmRpt_t* rpt )
{
unsigned n = cmSdbResponseCount(rh);
unsigned i;
for(i=0; i<n; ++i)
{
const cmSdbEvent_t* e = cmSdbResponseEvent(rh,i);
if( e != NULL )
cmRptPrintf(rpt,"%6i %6i %2i %12i %12i %12i %12i %2i %6i %2i %10s %15s\n",
e->uuid,e->baseUuid,e->chIdx,e->obi,e->ibi,e->iei,e->oei,e->midi,e->srate,e->chCnt,
cmStringNullGuard(e->src), cmStringNullGuard(e->instr) );
}
}
cmSdbRC_t cmSdbSyncChPairs( cmSdbH_t h )
{
cmSdbRC_t rc = kOkSdbRC;
cmSdb_t* p = _cmSdbHandleToPtr(h);
unsigned i;
// for each multi-channel event
for(i=0; i<p->eN; ++i)
if(p->eV[i].chCnt > 1 )
{
const cmSdbEvent_t* ep = p->eV + i;
unsigned iV[ep->chCnt];
unsigned j,k;
// load iV[] with the event indexes of the channel pairs
for(j=0,k=0; j<p->eN && k<ep->chCnt; ++j)
if( p->eV[j].baseUuid == ep->baseUuid )
{
assert( p->eV[j].chIdx < ep->chCnt );
iV[p->eV[j].chIdx] = j;
++k;
}
if( k != ep->chCnt )
rc = cmErrMsg(&p->ctx.err,kChPairNotFoundSdbRC,"The channel pair associated with 'id:%i instr:%s src:%s ch index:%i could not be found.",ep->uuid,cmStringNullGuard(ep->instr),cmStringNullGuard(ep->src),ep->chIdx);
else
{
unsigned mobi = ep->obi;
unsigned mibi = ep->ibi;
unsigned miei = ep->iei;
unsigned moei = ep->oei;
// get the min onsets and max offsets
for(j=0; j<ep->chCnt; ++j)
{
mobi = cmMin(mobi,p->eV[ iV[j] ].obi);
mibi = cmMin(mibi,p->eV[ iV[j] ].ibi);
miei = cmMax(miei,p->eV[ iV[j] ].iei);
moei = cmMax(moei,p->eV[ iV[j] ].oei);
}
// set the onsets to the min onset / offsets to max offsets
for(j=0; j<ep->chCnt; ++j)
{
p->eV[ iV[j] ].obi = mobi;
p->eV[ iV[j] ].ibi = mibi;
p->eV[ iV[j] ].iei = miei;
p->eV[ iV[j] ].oei = moei;
}
}
}
return rc;
}
cmSdbRC_t cmSdbTest( cmCtx_t* ctx )
{
cmSdbRC_t rc = kOkSdbRC;
cmSdbH_t h = cmSdbNullHandle;
const cmChar_t* audioDir = "/home/kevin/media/audio";
const cmChar_t* csvFn = "/home/kevin/temp/sdb0/sdb_master.csv";
cmErr_t err;
cmErrSetup(&err,&ctx->rpt,"sdb test");
if((rc = cmSdbCreate(ctx, &h, audioDir, csvFn )) != kOkSdbRC )
{
rc = cmErrMsg(&err,rc,"sdb create failed.");
goto errLabel;
}
if((rc = cmSdbSyncChPairs(h)) != kOkSdbRC )
{
rc = cmErrMsg(&err,rc,"sdb sync-ch-pairs failed.");
goto errLabel;
}
if(0)
{
cmSdbResponseH_t rH = cmSdbResponseNullHandle;
const cmChar_t* instrV[] = { "*viol", NULL };
if((rc = cmSdbSelect(h,0,instrV,NULL,NULL,0,0,0,&rH)) != kOkSdbRC )
{
rc = cmErrMsg(&err,rc,"sdb query failed.");
goto errLabel;
}
cmSdbResponsePrint(rH,&ctx->rpt);
cmSdbResponseFree(&rH);
}
errLabel:
if((rc = cmSdbDestroy(&h)) != kOkSdbRC )
rc = cmErrMsg(&err,rc,"sdb destroy failed.");
return rc;
}
Reference in New Issue View Git Blame Copy Permalink