cmProc4.h/c : Deleted experimental score trackers.
This commit is contained in:
Kevin Larke
parent
e5dbc44c61
commit
205f7c6c6b
743
cmProc4.c
743
cmProc4.c
@ -27,749 +27,6 @@
|
||||
#include "cmScore.h"
|
||||
#include "cmProc4.h"
|
||||
|
||||
|
||||
cmScFol* cmScFolAlloc( cmCtx* c, cmScFol* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel )
|
||||
{
|
||||
cmScFol* op = cmObjAlloc(cmScFol,c,p);
|
||||
if( srate != 0 )
|
||||
if( cmScFolInit(op,srate,scH,bufN,minWndLookAhead,maxWndCnt,minVel) != cmOkRC )
|
||||
cmScFolFree(&op);
|
||||
return op;
|
||||
}
|
||||
|
||||
cmRC_t cmScFolFree( cmScFol** pp )
|
||||
{
|
||||
cmRC_t rc = cmOkRC;
|
||||
if( pp==NULL || *pp==NULL )
|
||||
return rc;
|
||||
|
||||
cmScFol* p = *pp;
|
||||
if((rc = cmScFolFinal(p)) != cmOkRC )
|
||||
return rc;
|
||||
|
||||
unsigned i;
|
||||
for(i=0; i<p->locN; ++i)
|
||||
cmMemFree(p->loc[i].evtV);
|
||||
|
||||
cmMemFree(p->loc);
|
||||
cmMemFree(p->bufV);
|
||||
cmObjFree(pp);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
cmRC_t cmScFolFinal( cmScFol* p )
|
||||
{
|
||||
cmMemFree(p->edWndMtx);
|
||||
return cmOkRC;
|
||||
}
|
||||
|
||||
void _cmScFolPrint( cmScFol* p )
|
||||
{
|
||||
int i,j;
|
||||
for(i=0; i<p->locN; ++i)
|
||||
{
|
||||
printf("%2i %5i ",p->loc[i].barNumb,p->loc[i].scIdx);
|
||||
for(j=0; j<p->loc[i].evtCnt; ++j)
|
||||
printf("%s ",cmMidiToSciPitch(p->loc[i].evtV[j].pitch,NULL,0));
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
unsigned* _cmScFolAllocEditDistMtx(unsigned maxN)
|
||||
{
|
||||
maxN += 1;
|
||||
|
||||
unsigned* m = cmMemAllocZ(unsigned,maxN*maxN);
|
||||
unsigned* p = m;
|
||||
unsigned i;
|
||||
|
||||
// initialize the comparison matrix with the default costs in the
|
||||
// first row and column
|
||||
// (Note that this matrix is not oriented in column major order like most 'cm' matrices.)
|
||||
for(i=0; i<maxN; ++i)
|
||||
{
|
||||
p[i] = i; // 0th row
|
||||
p[ i * maxN ] = i; // 0th col
|
||||
}
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
cmRC_t cmScFolInit( cmScFol* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel )
|
||||
{
|
||||
cmRC_t rc;
|
||||
if((rc = cmScFolFinal(p)) != cmOkRC )
|
||||
return rc;
|
||||
|
||||
if( bufN > maxWndCnt )
|
||||
return cmCtxRtCondition( &p->obj, cmInvalidArgRC, "The score follower buffer count (%i) must be less than the max. window length (%i).",bufN,maxWndCnt );
|
||||
|
||||
if( minWndLookAhead > maxWndCnt )
|
||||
return cmCtxRtCondition( &p->obj, cmInvalidArgRC, "The score follower look-ahead count (%i) must be less than the max. window length (%i).",minWndLookAhead,maxWndCnt);
|
||||
|
||||
p->srate = srate;
|
||||
p->scH = scH;
|
||||
p->bufN = bufN;
|
||||
p->bufV = cmMemResizeZ(cmScFolBufEle_t,p->bufV,bufN);
|
||||
p->locN = cmScoreEvtCount(scH);
|
||||
p->loc = cmMemResizeZ(cmScFolLoc_t,p->loc,p->locN);
|
||||
p->sbi = cmInvalidIdx;
|
||||
p->sei = cmInvalidIdx;
|
||||
p->msln = minWndLookAhead;
|
||||
p->mswn = maxWndCnt;
|
||||
p->forwardCnt = 2;
|
||||
p->maxDist = 4;
|
||||
p->edWndMtx = _cmScFolAllocEditDistMtx(p->bufN);
|
||||
p->minVel = minVel;
|
||||
p->printFl = true;
|
||||
p->noBackFl = true;
|
||||
p->missCnt = 0;
|
||||
p->matchCnt = 0;
|
||||
p->eventIdx = 0;
|
||||
p->skipCnt = 0;
|
||||
p->ret_idx = cmInvalidIdx;
|
||||
|
||||
// for each score location
|
||||
unsigned li,ei;
|
||||
|
||||
for(li=0,ei=0; li<cmScoreLocCount(p->scH); ++li)
|
||||
{
|
||||
unsigned i,n;
|
||||
|
||||
const cmScoreLoc_t* lp = cmScoreLoc(p->scH,li);
|
||||
|
||||
// count the number of note events at location li
|
||||
for(n=0,i=0; i<lp->evtCnt; ++i)
|
||||
if( lp->evtArray[i]->type == kNonEvtScId )
|
||||
++n;
|
||||
|
||||
assert( ei+n <= p->locN );
|
||||
|
||||
// duplicate each note at location li n times
|
||||
for(i=0; i<n; ++i)
|
||||
{
|
||||
unsigned j,k;
|
||||
|
||||
p->loc[ei+i].evtCnt = n;
|
||||
p->loc[ei+i].evtV = cmMemAllocZ(cmScFolEvt_t,n);
|
||||
p->loc[ei+i].scIdx = li;
|
||||
p->loc[ei+i].barNumb = lp->barNumb;
|
||||
for(j=0,k=0; j<lp->evtCnt; ++j)
|
||||
if( lp->evtArray[j]->type == kNonEvtScId )
|
||||
{
|
||||
p->loc[ei+i].evtV[k].pitch = lp->evtArray[j]->pitch;
|
||||
p->loc[ei+i].evtV[k].scEvtIdx = lp->evtArray[j]->index;
|
||||
++k;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
ei += n;
|
||||
|
||||
}
|
||||
|
||||
p->locN = ei;
|
||||
|
||||
//_cmScFolPrint(p);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
cmRC_t cmScFolReset( cmScFol* p, unsigned scEvtIdx )
|
||||
{
|
||||
int i,j;
|
||||
|
||||
// empty the event buffer
|
||||
memset(p->bufV,0,sizeof(cmScFolBufEle_t)*p->bufN);
|
||||
|
||||
// don't allow the score index to be prior to the first note
|
||||
//if( scEvtIdx < p->loc[0].scIdx )
|
||||
// scEvtIdx = p->loc[0].scIdx;
|
||||
|
||||
p->sei = cmInvalidIdx;
|
||||
p->sbi = cmInvalidIdx;
|
||||
p->missCnt = 0;
|
||||
p->matchCnt = 0;
|
||||
p->eventIdx = 0;
|
||||
p->skipCnt = 0;
|
||||
p->ret_idx = cmInvalidIdx;
|
||||
|
||||
// locate the score element in svV[] that is closest to,
|
||||
// and possibly after, scEvtIdx.
|
||||
for(i=0; i<p->locN-1; ++i)
|
||||
{
|
||||
for(j=0; j<p->loc[i].evtCnt; ++j)
|
||||
if( p->loc[i].evtV[j].scEvtIdx <= scEvtIdx )
|
||||
p->sbi = i;
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
// locate the score element at the end of the look-ahead region
|
||||
for(; i<p->locN; ++i)
|
||||
{
|
||||
for(j=0; j<p->loc[i].evtCnt; ++j)
|
||||
if( p->loc[i].evtV[j].scEvtIdx <= scEvtIdx + p->msln )
|
||||
p->sei = i;
|
||||
}
|
||||
|
||||
return cmOkRC;
|
||||
}
|
||||
|
||||
bool _cmScFolIsMatch( const cmScFolLoc_t* loc, unsigned pitch )
|
||||
{
|
||||
unsigned i;
|
||||
for(i=0; i<loc->evtCnt; ++i)
|
||||
if( loc->evtV[i].pitch == pitch )
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
int _cmScFolMatchCost( const cmScFolLoc_t* loc, unsigned li, const cmScFolBufEle_t* pitch, unsigned pi )
|
||||
{
|
||||
if( _cmScFolIsMatch(loc+li,pitch[pi].val) )
|
||||
return 0;
|
||||
|
||||
if( li>0 && pi>0 )
|
||||
if( _cmScFolIsMatch(loc+li-1,pitch[pi].val) && _cmScFolIsMatch(loc+li,pitch[pi-1].val) )
|
||||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int _cmScFolDist(unsigned mtxMaxN, unsigned* m, const cmScFolBufEle_t* s1, const cmScFolLoc_t* s0, int n )
|
||||
{
|
||||
mtxMaxN += 1;
|
||||
|
||||
assert( n < mtxMaxN );
|
||||
|
||||
int v = 0;
|
||||
unsigned i;
|
||||
// Note that m[maxN,maxN] is not oriented in column major order like most 'cm' matrices.
|
||||
|
||||
for(i=1; i<n+1; ++i)
|
||||
{
|
||||
unsigned ii = i * mtxMaxN; // current row
|
||||
unsigned i_1 = ii - mtxMaxN; // previous row
|
||||
unsigned j;
|
||||
for( j=1; j<n+1; ++j)
|
||||
{
|
||||
//int cost = s0[i-1] == s1[j-1] ? 0 : 1;
|
||||
//int cost = _cmScFolIsMatch(s0 + i-1, s1[j-1]) ? 0 : 1;
|
||||
int cost = _cmScFolMatchCost(s0,i-1,s1,j-1);
|
||||
|
||||
//m[i][j] = min( m[i-1][j] + 1, min( m[i][j-1] + 1, m[i-1][j-1] + cost ) );
|
||||
|
||||
m[ ii + j ] = v = cmMin( m[ i_1 + j] + 1, cmMin( m[ ii + j - 1] + 1, m[ i_1 + j - 1 ] + cost ) );
|
||||
}
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
void _cmScFolRpt0( cmScFol* p, unsigned locIdx, unsigned locN, const cmScFolBufEle_t* b, unsigned bn, unsigned min_idx )
|
||||
{
|
||||
unsigned i;
|
||||
int n;
|
||||
|
||||
printf("--------------- event:%i ------------- \n",p->eventIdx);
|
||||
|
||||
printf("loc: ");
|
||||
for(i=0; i<locN; ++i)
|
||||
printf("%4i ",i+locIdx);
|
||||
printf("\n");
|
||||
|
||||
for(n=0,i=0; i<locN; ++i)
|
||||
if( p->loc[locIdx+i].evtCnt > n )
|
||||
n = p->loc[locIdx+i].evtCnt;
|
||||
|
||||
--n;
|
||||
for(; n>=0; --n)
|
||||
{
|
||||
printf("sc%1i: ",n);
|
||||
for(i=0; i<locN; ++i)
|
||||
{
|
||||
if( n < p->loc[locIdx+i].evtCnt )
|
||||
printf("%4s ",cmMidiToSciPitch(p->loc[locIdx+i].evtV[n].pitch,NULL,0));
|
||||
else
|
||||
printf(" ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
printf("perf:");
|
||||
for(i=0; i<min_idx; ++i)
|
||||
printf(" ");
|
||||
|
||||
for(i=0; i<bn; ++i)
|
||||
printf("%4s ",cmMidiToSciPitch(b[i].val,NULL,0));
|
||||
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void _cmScFolRpt1( cmScFol*p, unsigned minDist, unsigned ret_idx, unsigned d1, unsigned missCnt, unsigned matchCnt )
|
||||
{
|
||||
printf("dist:%i miss:%i match:%i skip:%i vel:%i ",minDist,missCnt,matchCnt,p->skipCnt,d1);
|
||||
if( ret_idx != cmInvalidIdx )
|
||||
printf("ret_idx:%i ",ret_idx);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
unsigned cmScFolExec( cmScFol* p, unsigned smpIdx, unsigned status, cmMidiByte_t d0, cmMidiByte_t d1 )
|
||||
{
|
||||
unsigned ret_idx = cmInvalidIdx;
|
||||
|
||||
if( p->sbi == cmInvalidIdx )
|
||||
{
|
||||
cmCtxRtCondition( &p->obj, cmInvalidArgRC, "An initial score search location has not been set." );
|
||||
return ret_idx;
|
||||
}
|
||||
|
||||
if( (status&0xf0) != kNoteOnMdId )
|
||||
return ret_idx;
|
||||
|
||||
++p->eventIdx;
|
||||
|
||||
// reject notes with very low velocity
|
||||
if( d1 < p->minVel )
|
||||
{
|
||||
++p->skipCnt;
|
||||
return ret_idx;
|
||||
}
|
||||
|
||||
// left shift bufV[] to make the right-most element available - then copy in the new element
|
||||
memmove(p->bufV, p->bufV+1, sizeof(cmScFolBufEle_t)*(p->bufN-1));
|
||||
p->bufV[ p->bufN-1 ].smpIdx = smpIdx;
|
||||
p->bufV[ p->bufN-1 ].val = d0;
|
||||
p->bufV[ p->bufN-1 ].validFl= true;
|
||||
|
||||
// fill in ebuf[] with the valid values in bufV[]
|
||||
int en = cmMin(p->eventIdx,p->bufN);
|
||||
int bbi = p->eventIdx>=p->bufN ? 0 : p->bufN-p->eventIdx;
|
||||
|
||||
|
||||
// en is the count of valid elements in ebuf[].
|
||||
// ebuf[p->boi] is the first valid element
|
||||
|
||||
int j = 0;
|
||||
int minDist = INT_MAX;
|
||||
int minIdx = cmInvalidIdx;
|
||||
int dist;
|
||||
|
||||
// the score wnd must always be as long as the buffer n
|
||||
// at the end of the score this may not be the case
|
||||
// (once sei hits locN - at this point we must begin
|
||||
// shrinking ewnd[] to contain only the last p->sei-p->sbi+1 elements)
|
||||
assert( p->sei-p->sbi+1 >= en );
|
||||
|
||||
for(j=0; p->sbi+en+j-1 <= p->sei; ++j)
|
||||
{
|
||||
// use <= minDist to choose the latest window with the lowest match
|
||||
if((dist = _cmScFolDist(p->bufN, p->edWndMtx, p->bufV+bbi, p->loc + p->sbi+j, en )) < minDist )
|
||||
{
|
||||
// only make an eql match if the posn is greater than the last location
|
||||
if( dist==minDist && p->ret_idx != cmInvalidId && p->ret_idx >= p->sbi+minIdx+en-1 )
|
||||
continue;
|
||||
|
||||
minDist = dist;
|
||||
minIdx = j;
|
||||
}
|
||||
}
|
||||
|
||||
// The best fit is on the score window: p->loc[sbi+minIdx : sbi+minIdx+en-1 ]
|
||||
|
||||
if( p->printFl )
|
||||
_cmScFolRpt0( p, p->sbi, p->sei-p->sbi+1, p->bufV+bbi, en, minIdx );
|
||||
|
||||
// save current missCnt for later printing
|
||||
unsigned missCnt = p->missCnt;
|
||||
|
||||
// if a perfect match occurred
|
||||
if( minDist == 0 )
|
||||
{
|
||||
ret_idx = p->sbi + minIdx + en - 1;
|
||||
p->missCnt = 0;
|
||||
|
||||
// we had a perfect match - shrink the window to it's minumum size
|
||||
p->sbi += (en==p->bufN) ? minIdx + 1 : 0; // move wnd begin forward to just past first match
|
||||
p->sei = p->sbi + minIdx + en + p->msln; // move wnd end forward to lead by the min look-ahead
|
||||
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
if( minDist > p->maxDist )
|
||||
ret_idx = cmInvalidIdx;
|
||||
else
|
||||
// if the last event matched - then return the match location as the current score location
|
||||
if( _cmScFolIsMatch(p->loc+(p->sbi+minIdx+en-1),p->bufV[p->bufN-1].val) )
|
||||
{
|
||||
ret_idx = p->sbi + minIdx + en - 1;
|
||||
p->missCnt = 0;
|
||||
|
||||
// this is probably a pretty good match reduce the part of the window prior to
|
||||
// the first match (bring the end of the window almost up to the end of the
|
||||
// buffers sync position)
|
||||
if( en >= p->bufN-1 && (en+2) <= ret_idx )
|
||||
p->sbi = ret_idx - (en+2);
|
||||
|
||||
}
|
||||
else // the last event does not match based on the optimal edit-distance alignment
|
||||
{
|
||||
// Look backward from the closest match location for a match to the current pitch.
|
||||
// The backward search scope is limited by the current value of 'missCnt'.
|
||||
unsigned i;
|
||||
j = p->sbi+minIdx+en-2;
|
||||
for(i=1; i+1 <= p->bufN && j>=p->sbi && i<=p->missCnt; ++i,--j)
|
||||
{
|
||||
// if this look-back location already matched then stop the backward search
|
||||
if(_cmScFolIsMatch(p->loc+j,p->bufV[p->bufN-1-i].val))
|
||||
break;
|
||||
|
||||
// does this look-back location match the current pitch
|
||||
if(_cmScFolIsMatch(p->loc+j,p->bufV[p->bufN-1].val))
|
||||
{
|
||||
ret_idx = j;
|
||||
p->missCnt = i; // set missCnt to the cnt of steps backward necessary for a match
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// If the backward search did not find a match - look forward
|
||||
if( ret_idx == cmInvalidIdx )
|
||||
{
|
||||
unsigned i;
|
||||
j = p->sbi+minIdx+en;
|
||||
for(i=0; j<=p->sei && i<p->forwardCnt; ++i,++j)
|
||||
if( _cmScFolIsMatch(p->loc+j,p->bufV[p->bufN-1].val) )
|
||||
{
|
||||
ret_idx = j;
|
||||
break;
|
||||
}
|
||||
|
||||
p->missCnt = ret_idx == cmInvalidIdx ? p->missCnt + 1 : 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Adjust the end window position (sei) based on the match location
|
||||
if( ret_idx == cmInvalidIdx )
|
||||
{
|
||||
// even though we didn't match move the end of the score window forward
|
||||
// this will enlarge the score window by one
|
||||
p->sei += 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert( p->sei>=ret_idx);
|
||||
|
||||
// force sei to lead by min look-ahead
|
||||
if( p->sei - ret_idx < p->msln )
|
||||
p->sei = ret_idx + p->msln;
|
||||
|
||||
}
|
||||
|
||||
assert( p->sei > p->sbi );
|
||||
|
||||
// Adjust the begin window position
|
||||
if( p->noBackFl && ret_idx != cmInvalidIdx && en>=p->bufN && p->sbi > p->bufN )
|
||||
p->sbi = ret_idx - p->bufN;
|
||||
|
||||
// if the score window length surpasses the max score window size
|
||||
// move the beginning index forward
|
||||
if( p->sei - p->sbi + 1 > p->mswn && p->sei > p->mswn )
|
||||
p->sbi = p->sei - p->mswn + 1;
|
||||
|
||||
|
||||
}
|
||||
|
||||
if( p->printFl )
|
||||
_cmScFolRpt1(p, minDist, ret_idx, d1, missCnt, p->matchCnt );
|
||||
|
||||
// don't allow the returned location to repeat or go backwards
|
||||
if( p->noBackFl && p->ret_idx != cmInvalidIdx && ret_idx <= p->ret_idx )
|
||||
ret_idx = cmInvalidIdx;
|
||||
|
||||
|
||||
// track the number of consecutive matches
|
||||
if( ret_idx == cmInvalidIdx )
|
||||
p->matchCnt = 0;
|
||||
else
|
||||
{
|
||||
++p->matchCnt;
|
||||
|
||||
p->ret_idx = ret_idx;
|
||||
}
|
||||
|
||||
// Force the window to remain valid when it is at the end of the score
|
||||
// - sbi and sei must be inside 0:locN
|
||||
// - sei-sbi + 1 must be >= en
|
||||
if( p->sei >= p->locN )
|
||||
{
|
||||
p->sei = p->locN - 1;
|
||||
p->sbi = p->sei - p->bufN + 1;
|
||||
}
|
||||
|
||||
if( ret_idx != cmInvalidIdx )
|
||||
ret_idx = p->loc[ret_idx].scIdx;
|
||||
|
||||
return ret_idx;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//=======================================================================================================================
|
||||
|
||||
cmScTrk* cmScTrkAlloc( cmCtx* c, cmScTrk* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel )
|
||||
{
|
||||
cmScTrk* op = cmObjAlloc(cmScTrk,c,p);
|
||||
|
||||
op->sfp = cmScFolAlloc(c,NULL,srate,scH,bufN,minWndLookAhead,maxWndCnt,minVel);
|
||||
|
||||
if( srate != 0 )
|
||||
if( cmScTrkInit(op,srate,scH,bufN,minWndLookAhead,maxWndCnt,minVel) != cmOkRC )
|
||||
cmScTrkFree(&op);
|
||||
return op;
|
||||
}
|
||||
|
||||
cmRC_t cmScTrkFree( cmScTrk** pp )
|
||||
{
|
||||
cmRC_t rc = cmOkRC;
|
||||
if( pp==NULL || *pp==NULL )
|
||||
return rc;
|
||||
|
||||
cmScTrk* p = *pp;
|
||||
if((rc = cmScTrkFinal(p)) != cmOkRC )
|
||||
return rc;
|
||||
|
||||
cmScFolFree(&p->sfp);
|
||||
|
||||
cmObjFree(pp);
|
||||
return rc;
|
||||
|
||||
}
|
||||
|
||||
void _cmScTrkPrint( cmScTrk* p )
|
||||
{
|
||||
int i,j;
|
||||
for(i=0; i<p->locN; ++i)
|
||||
{
|
||||
printf("%2i %5i ",p->loc[i].barNumb,p->loc[i].scIdx);
|
||||
for(j=0; j<p->loc[i].evtCnt; ++j)
|
||||
printf("%s ",cmMidiToSciPitch(p->loc[i].evtV[j].pitch,NULL,0));
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
cmRC_t cmScTrkInit( cmScTrk* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel )
|
||||
{
|
||||
cmRC_t rc;
|
||||
if((rc = cmScTrkFinal(p)) != cmOkRC )
|
||||
return rc;
|
||||
|
||||
if( minWndLookAhead > maxWndCnt )
|
||||
return cmCtxRtCondition( &p->obj, cmInvalidArgRC, "The score follower look-ahead count (%i) must be less than the max. window length (%i).",minWndLookAhead,maxWndCnt);
|
||||
|
||||
if((rc = cmScFolInit(p->sfp,srate,scH,bufN,minWndLookAhead,maxWndCnt,minVel)) != cmOkRC )
|
||||
return rc;
|
||||
|
||||
p->srate = srate;
|
||||
p->scH = scH;
|
||||
p->locN = cmScoreLocCount(scH);
|
||||
p->loc = cmMemResizeZ(cmScTrkLoc_t,p->loc,p->locN);
|
||||
p->minVel = minVel;
|
||||
p->maxWndCnt = maxWndCnt;
|
||||
p->minWndLookAhead= 4; //minWndLookAhead;
|
||||
p->printFl = true;
|
||||
p->curLocIdx = cmInvalidIdx;
|
||||
p->evtIndex = 0;
|
||||
|
||||
// for each score location
|
||||
unsigned li;
|
||||
|
||||
for(li=0; li<cmScoreLocCount(p->scH); ++li)
|
||||
{
|
||||
unsigned i,j,k,n;
|
||||
|
||||
const cmScoreLoc_t* lp = cmScoreLoc(p->scH,li);
|
||||
|
||||
// count the number of note events at location li
|
||||
for(n=0,i=0; i<lp->evtCnt; ++i)
|
||||
if( lp->evtArray[i]->type == kNonEvtScId )
|
||||
++n;
|
||||
|
||||
p->loc[li].evtCnt = n;
|
||||
p->loc[li].evtV = cmMemAllocZ(cmScTrkEvt_t,n);
|
||||
p->loc[li].scIdx = li;
|
||||
p->loc[li].barNumb = lp->barNumb;
|
||||
for(j=0,k=0; j<lp->evtCnt; ++j)
|
||||
if( lp->evtArray[j]->type == kNonEvtScId )
|
||||
{
|
||||
p->loc[li].evtV[k].pitch = lp->evtArray[j]->pitch;
|
||||
p->loc[li].evtV[k].scEvtIdx = lp->evtArray[j]->index;
|
||||
++k;
|
||||
}
|
||||
}
|
||||
|
||||
//_cmScTrkPrint(p);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
cmRC_t cmScTrkFinal( cmScTrk* p )
|
||||
{
|
||||
unsigned i;
|
||||
for(i=0; i<p->locN; ++i)
|
||||
cmMemPtrFree(&p->loc[i].evtV);
|
||||
|
||||
return cmOkRC;
|
||||
}
|
||||
|
||||
cmRC_t cmScTrkReset( cmScTrk* p, unsigned scEvtIdx )
|
||||
{
|
||||
unsigned i;
|
||||
|
||||
cmScFolReset(p->sfp,scEvtIdx);
|
||||
|
||||
p->curLocIdx = cmInvalidIdx;
|
||||
p->evtIndex = 0;
|
||||
|
||||
|
||||
// locate the score element in svV[] that is closest to,
|
||||
// and possibly after, scEvtIdx.
|
||||
for(i=0; i<p->locN; ++i)
|
||||
{
|
||||
unsigned j;
|
||||
|
||||
for(j=0; j<p->loc[i].evtCnt; ++j)
|
||||
{
|
||||
p->loc[i].evtV[j].matchFl = false;
|
||||
|
||||
// it is possible that scEvtIdx is before the first event included in p->loc[0]
|
||||
// using the p->curLocIdx==cmInvalidIdx forces the first evt in p->loc[0] to be
|
||||
// selected in this case
|
||||
if( p->loc[i].evtV[j].scEvtIdx <= scEvtIdx || p->curLocIdx==cmInvalidIdx )
|
||||
p->curLocIdx = i;
|
||||
}
|
||||
}
|
||||
|
||||
if( p->curLocIdx == cmInvalidIdx )
|
||||
return cmCtxRtCondition( &p->obj, cmInvalidArgRC, "The initial score search location event %i was not found.", scEvtIdx );
|
||||
|
||||
return cmOkRC;
|
||||
}
|
||||
|
||||
unsigned _cmScTrkIsMatch(cmScTrk* p, int d, unsigned pitch )
|
||||
{
|
||||
if( 0 <= p->curLocIdx + d && p->curLocIdx+1 < p->locN )
|
||||
{
|
||||
unsigned i;
|
||||
const cmScTrkLoc_t* lp = p->loc + p->curLocIdx + d;
|
||||
for(i=0; i<lp->evtCnt; ++i)
|
||||
if( lp->evtV[i].pitch == pitch && lp->evtV[i].matchFl==false)
|
||||
return i;
|
||||
}
|
||||
return cmInvalidIdx;
|
||||
}
|
||||
|
||||
void _cmScTrkRpt0( cmScTrk* p, unsigned pitch, unsigned vel, unsigned nli, unsigned nei )
|
||||
{
|
||||
bool missFl = nli==cmInvalidIdx || nei==cmInvalidIdx;
|
||||
|
||||
printf("------- event:%i %s vel:%i cur:%i new:%i %s-------\n",p->evtIndex,cmMidiToSciPitch(pitch,NULL,0),vel,p->curLocIdx,nli,missFl?"MISS ":"");
|
||||
|
||||
int bi = p->curLocIdx < p->minWndLookAhead ? 0 : p->curLocIdx - p->minWndLookAhead;
|
||||
int ei = cmMin(p->locN-1,p->curLocIdx+p->minWndLookAhead);
|
||||
unsigned i,n=0;
|
||||
for(i=bi; i<=ei; ++i)
|
||||
if( p->loc[i].evtCnt>n )
|
||||
n = p->loc[i].evtCnt;
|
||||
|
||||
printf("loc ");
|
||||
for(i=bi; i<=ei; ++i)
|
||||
printf("%4i ",i);
|
||||
printf("\n");
|
||||
|
||||
for(i=0; i<n; ++i)
|
||||
{
|
||||
unsigned j;
|
||||
printf("sc%2i ",i);
|
||||
for(j=bi; j<=ei; ++j)
|
||||
{
|
||||
if( i < p->loc[j].evtCnt )
|
||||
{
|
||||
char* X = p->loc[j].evtV[i].matchFl ? "__" : " ";
|
||||
|
||||
if( nli==j && nei==i)
|
||||
{
|
||||
X = "**";
|
||||
assert( p->loc[j].evtV[i].pitch == pitch );
|
||||
}
|
||||
|
||||
printf("%4s%s ",cmMidiToSciPitch(p->loc[j].evtV[i].pitch,NULL,0),X);
|
||||
}
|
||||
else
|
||||
printf(" ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
unsigned cmScTrkExec( cmScTrk* p, unsigned smpIdx, unsigned status, cmMidiByte_t d0, cmMidiByte_t d1 )
|
||||
{
|
||||
unsigned ret_idx = cmInvalidIdx;
|
||||
|
||||
//cmScFolExec(p->sfp, smpIdx, status, d0, d1);
|
||||
|
||||
if( (status&0xf0) != kNoteOnMdId )
|
||||
return cmInvalidIdx;
|
||||
|
||||
if( p->curLocIdx == cmInvalidIdx )
|
||||
{
|
||||
cmCtxRtCondition( &p->obj, cmInvalidArgRC, "An initial score search location has not been set." );
|
||||
return cmInvalidIdx;
|
||||
}
|
||||
|
||||
int i,nei,nli=cmInvalidIdx;
|
||||
|
||||
// try to match curLocIdx first
|
||||
if((nei = _cmScTrkIsMatch(p,0,d0)) != cmInvalidIdx )
|
||||
nli = p->curLocIdx;
|
||||
|
||||
for(i=1; nei==cmInvalidIdx && i<p->minWndLookAhead; ++i)
|
||||
{
|
||||
// go forward
|
||||
if((nei = _cmScTrkIsMatch(p,i,d0)) != cmInvalidIdx )
|
||||
nli = p->curLocIdx + i;
|
||||
else
|
||||
// go backward
|
||||
if((nei = _cmScTrkIsMatch(p,-i,d0)) != cmInvalidIdx )
|
||||
nli = p->curLocIdx - i;
|
||||
}
|
||||
|
||||
if( p->printFl )
|
||||
{
|
||||
_cmScTrkRpt0(p, d0, d1, nli, nei );
|
||||
}
|
||||
|
||||
|
||||
if( nli != cmInvalidIdx )
|
||||
{
|
||||
p->loc[nli].evtV[nei].matchFl = true;
|
||||
ret_idx = p->loc[nli].scIdx;
|
||||
|
||||
if( nli > p->curLocIdx )
|
||||
p->curLocIdx = nli;
|
||||
|
||||
}
|
||||
|
||||
++p->evtIndex;
|
||||
|
||||
return ret_idx;
|
||||
}
|
||||
|
||||
//=======================================================================================================================
|
||||
//----------------------------------------------------------------------------------------
|
||||
void ed_print_mtx( ed_r* r)
|
||||
|
||||
108
cmProc4.h
108
cmProc4.h
@ -5,114 +5,6 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned smpIdx; // time tag sample index for val
|
||||
cmMidiByte_t val; //
|
||||
bool validFl; //
|
||||
} cmScFolBufEle_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned pitch;
|
||||
unsigned scEvtIdx;
|
||||
} cmScFolEvt_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned evtCnt; //
|
||||
cmScFolEvt_t* evtV; // pitchV[pitchCnt]
|
||||
unsigned scIdx; // index of the score loc (into cmScoreEvt[]) at this location
|
||||
int barNumb; // bar number of this location
|
||||
} cmScFolLoc_t;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
cmObj obj;
|
||||
cmReal_t srate; //
|
||||
cmScH_t scH; // score handle
|
||||
unsigned bufN; // event buffer count
|
||||
cmScFolBufEle_t* bufV; // event buffer bufV[bufN] - bufV[bufN-1] newest event, bufV[boi] oldest event
|
||||
int locN; // count of score locations
|
||||
cmScFolLoc_t* loc; // score loc[locN]
|
||||
unsigned sbi; // oldest score window index
|
||||
unsigned sei; // newest score window index
|
||||
unsigned msln; // minimum score look ahead count
|
||||
unsigned mswn; // maximum score window length
|
||||
unsigned forwardCnt; // count of score loc's to look ahead for a match to the current pitch when the optimal edit-dist alignment does not produce a match for the current pitch
|
||||
unsigned maxDist; // max. dist allowed to still consider matching
|
||||
unsigned minVel; // notes < minVel are ignored
|
||||
bool printFl; // true if pitch tracker reporting should be included
|
||||
bool noBackFl; // prevent the tracker from going backwards in time
|
||||
unsigned* edWndMtx;
|
||||
|
||||
unsigned missCnt; // current consecutive unmatched notes
|
||||
unsigned matchCnt; // current consecutive matched notes
|
||||
unsigned eventIdx; // events since reset
|
||||
unsigned skipCnt; // notes skipped due to velocity
|
||||
unsigned ret_idx; // last tracked location
|
||||
|
||||
} cmScFol;
|
||||
|
||||
cmScFol* cmScFolAlloc( cmCtx* ctx, cmScFol* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel );
|
||||
cmRC_t cmScFolFree( cmScFol** pp );
|
||||
cmRC_t cmScFolInit( cmScFol* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel );
|
||||
cmRC_t cmScFolFinal( cmScFol* p );
|
||||
|
||||
// Jump to a score location and reset the internal state of the follower.
|
||||
cmRC_t cmScFolReset( cmScFol* p, unsigned scoreIndex );
|
||||
|
||||
// Give the follower a MIDI performance event. Only MIDI note-on events are acted upon;
|
||||
// all others are ignored.
|
||||
unsigned cmScFolExec( cmScFol* p, unsigned smpIdx, unsigned status, cmMidiByte_t d0, cmMidiByte_t d1 );
|
||||
|
||||
//=======================================================================================================================
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned pitch;
|
||||
unsigned scEvtIdx;
|
||||
bool matchFl;
|
||||
} cmScTrkEvt_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned evtCnt; //
|
||||
cmScTrkEvt_t* evtV; // evtV[evtCnt]
|
||||
unsigned scIdx; // index of the score event (into cmScoreEvt[]) at this location
|
||||
int barNumb; // bar number of this location
|
||||
} cmScTrkLoc_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
cmObj obj;
|
||||
cmScFol* sfp;
|
||||
double srate;
|
||||
cmScH_t scH;
|
||||
unsigned locN;
|
||||
cmScTrkLoc_t* loc;
|
||||
unsigned minVel;
|
||||
unsigned maxWndCnt;
|
||||
unsigned minWndLookAhead;
|
||||
bool printFl;
|
||||
|
||||
int curLocIdx;
|
||||
unsigned evtIndex;
|
||||
|
||||
} cmScTrk;
|
||||
|
||||
cmScTrk* cmScTrkAlloc( cmCtx* ctx, cmScTrk* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel );
|
||||
cmRC_t cmScTrkFree( cmScTrk** pp );
|
||||
cmRC_t cmScTrkInit( cmScTrk* p, cmReal_t srate, cmScH_t scH, unsigned bufN, unsigned minWndLookAhead, unsigned maxWndCnt, unsigned minVel );
|
||||
cmRC_t cmScTrkFinal( cmScTrk* p );
|
||||
|
||||
// Jump to a score location and reset the internal state of the follower.
|
||||
cmRC_t cmScTrkReset( cmScTrk* p, unsigned scoreIndex );
|
||||
|
||||
// Give the follower a MIDI performance event. Only MIDI note-on events are acted upon;
|
||||
// all others are ignored.
|
||||
unsigned cmScTrkExec( cmScTrk* p, unsigned smpIdx, unsigned status, cmMidiByte_t d0, cmMidiByte_t d1 );
|
||||
|
||||
//=======================================================================================================================
|
||||
//
|
||||
|
||||
Loading…
Reference in New Issue
Block a user