2012-11-15 04:01:05 +00:00
|
|
|
#include "cmPrefix.h"
|
|
|
|
#include "cmGlobal.h"
|
|
|
|
#include "cmRpt.h"
|
|
|
|
#include "cmErr.h"
|
|
|
|
#include "cmCtx.h"
|
|
|
|
#include "cmMem.h"
|
|
|
|
#include "cmMallocDebug.h"
|
|
|
|
#include "cmLinkedHeap.h"
|
|
|
|
#include "cmFloatTypes.h"
|
|
|
|
#include "cmComplexTypes.h"
|
|
|
|
#include "cmFileSys.h"
|
|
|
|
#include "cmJson.h"
|
|
|
|
#include "cmSymTbl.h"
|
|
|
|
#include "cmAudioFile.h"
|
|
|
|
#include "cmProcObj.h"
|
|
|
|
#include "cmProcTemplate.h"
|
|
|
|
#include "cmMath.h"
|
|
|
|
#include "cmProc.h"
|
|
|
|
#include "cmVectOps.h"
|
|
|
|
#include "cmMidi.h"
|
|
|
|
#include "cmMidiFile.h"
|
|
|
|
#include "cmTimeLine.h"
|
|
|
|
#include "cmScore.h"
|
|
|
|
#include "cmProc4.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-11-19 06:41:27 +00:00
|
|
|
cmScFol* cmScFolAlloc( cmCtx* c, cmScFol* p, cmReal_t srate, unsigned bufN, cmReal_t wndMs, cmScH_t scH )
|
2012-11-15 04:01:05 +00:00
|
|
|
{
|
|
|
|
cmScFol* op = cmObjAlloc(cmScFol,c,p);
|
|
|
|
if( srate != 0 )
|
2012-11-19 06:41:27 +00:00
|
|
|
if( cmScFolInit(op,srate,bufN,wndMs,scH) != cmOkRC )
|
2012-11-15 04:01:05 +00:00
|
|
|
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].pitchV);
|
|
|
|
|
|
|
|
cmMemFree(p->loc);
|
|
|
|
cmObjFree(pp);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
cmRC_t cmScFolFinal( cmScFol* p )
|
|
|
|
{ return cmOkRC; }
|
|
|
|
|
|
|
|
void _cmScFolPrint( cmScFol* p )
|
|
|
|
{
|
|
|
|
int i,j;
|
|
|
|
for(i=0; i<p->locN; ++i)
|
|
|
|
{
|
2012-11-19 06:41:27 +00:00
|
|
|
printf("%2i %5i ",p->loc[i].barNumb,p->loc[i].scIdx);
|
2012-11-15 04:01:05 +00:00
|
|
|
for(j=0; j<p->loc[i].pitchCnt; ++j)
|
|
|
|
printf("%s ",cmMidiToSciPitch(p->loc[i].pitchV[j],NULL,0));
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-19 06:41:27 +00:00
|
|
|
cmRC_t cmScFolInit( cmScFol* p, cmReal_t srate, unsigned bufN, cmReal_t wndMs, cmScH_t scH )
|
2012-11-15 04:01:05 +00:00
|
|
|
{
|
|
|
|
cmRC_t rc;
|
|
|
|
if((rc = cmScFolFinal(p)) != cmOkRC )
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
p->srate = srate;
|
|
|
|
p->scH = scH;
|
2012-11-19 06:41:27 +00:00
|
|
|
p->bufN = bufN;
|
|
|
|
p->bufV = cmMemResizeZ(cmScFolBufEle_t,p->bufV,bufN);
|
2012-11-15 04:01:05 +00:00
|
|
|
p->locN = cmScoreEvtCount(scH);
|
|
|
|
p->loc = cmMemResizeZ(cmScFolLoc_t,p->loc,p->locN);
|
|
|
|
p->sbi = cmInvalidIdx;
|
|
|
|
p->sei = cmInvalidIdx;
|
2012-11-19 06:41:27 +00:00
|
|
|
p->msln = 7;
|
|
|
|
p->mswn = 30;
|
|
|
|
p->edWndMtx = cmVOU_LevEditDistAllocMtx(p->bufN);
|
2012-11-15 04:01:05 +00:00
|
|
|
|
|
|
|
|
|
|
|
int i,n;
|
2012-11-19 06:41:27 +00:00
|
|
|
double maxDSecs = 0; // max time between score entries to be considered simultaneous
|
2012-11-15 04:01:05 +00:00
|
|
|
cmScoreEvt_t* e0p = NULL;
|
|
|
|
int j0 = 0;
|
|
|
|
|
|
|
|
// for each score event
|
|
|
|
for(i=0,n=0; i<p->locN; ++i)
|
|
|
|
{
|
|
|
|
cmScoreEvt_t* ep = cmScoreEvt(scH,i);
|
|
|
|
|
|
|
|
// if the event is not a note then ignore it
|
|
|
|
if( ep->type == kNonEvtScId )
|
|
|
|
{
|
|
|
|
assert( j0+n < p->locN );
|
|
|
|
|
2012-11-19 06:41:27 +00:00
|
|
|
p->loc[j0+n].scIdx = i;
|
2012-11-15 04:01:05 +00:00
|
|
|
p->loc[j0+n].barNumb = ep->barNumb;
|
|
|
|
|
|
|
|
// if the first event has not yet been selected
|
|
|
|
if( e0p == NULL )
|
|
|
|
{
|
|
|
|
e0p = ep;
|
|
|
|
n = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// time can never reverse
|
|
|
|
assert( ep->secs >= e0p->secs );
|
|
|
|
|
|
|
|
// calc seconds between first event and current event
|
|
|
|
double dsecs = ep->secs - e0p->secs;
|
|
|
|
|
|
|
|
// if the first event and current event are simultaneous...
|
|
|
|
if( dsecs <= maxDSecs )
|
|
|
|
++n; // ... incr. the count of simultaneous events
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int k;
|
|
|
|
// ... a complete set of simultaneous events have been located
|
|
|
|
// duplicate all the events at each of their respective time locations
|
|
|
|
for(k=0; k<n; ++k)
|
|
|
|
{
|
|
|
|
int m;
|
|
|
|
assert( j0+k < p->locN );
|
|
|
|
|
|
|
|
p->loc[j0+k].pitchCnt = n;
|
|
|
|
p->loc[j0+k].pitchV = cmMemAllocZ(unsigned,n);
|
|
|
|
|
|
|
|
for(m=0; m<n; ++m)
|
|
|
|
{
|
2012-11-19 06:41:27 +00:00
|
|
|
cmScoreEvt_t* tp = cmScoreEvt(scH,p->loc[j0+m].scIdx);
|
2012-11-15 04:01:05 +00:00
|
|
|
assert(tp!=NULL);
|
|
|
|
p->loc[j0+k].pitchV[m] = tp->pitch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
e0p = ep;
|
|
|
|
j0 += n;
|
|
|
|
n = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
p->locN = j0;
|
|
|
|
|
|
|
|
//_cmScFolPrint(p);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmRC_t cmScFolReset( cmScFol* p, unsigned scoreIndex )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-11-19 06:41:27 +00:00
|
|
|
|
|
|
|
// empty the event buffer
|
|
|
|
memset(p->bufV,0,sizeof(cmScFolBufEle_t)*p->bufN);
|
2012-11-15 04:01:05 +00:00
|
|
|
|
|
|
|
// don't allow the score index to be prior to the first note
|
2012-11-19 06:41:27 +00:00
|
|
|
if( scoreIndex < p->loc[0].scIdx )
|
|
|
|
scoreIndex = p->loc[0].scIdx;
|
|
|
|
|
|
|
|
p->sei = cmInvalidIdx;
|
|
|
|
p->sbi = cmInvalidIdx;
|
2012-11-15 04:01:05 +00:00
|
|
|
|
|
|
|
// locate the score element in svV[] that is closest to,
|
|
|
|
// and possibly after, scoreIndex.
|
|
|
|
for(i=0; i<p->locN-1; ++i)
|
2012-11-19 06:41:27 +00:00
|
|
|
if( p->loc[i].scIdx <= scoreIndex && scoreIndex < p->loc[i+1].scIdx )
|
|
|
|
{
|
2012-11-15 04:01:05 +00:00
|
|
|
p->sbi = i;
|
|
|
|
break;
|
2012-11-19 06:41:27 +00:00
|
|
|
}
|
2012-11-15 04:01:05 +00:00
|
|
|
|
2012-11-19 06:41:27 +00:00
|
|
|
// locate the score element at the end of the look-ahead region
|
|
|
|
for(; i<p->locN-1; ++i)
|
|
|
|
if( p->loc[i].scIdx <= scoreIndex + p->msln && scoreIndex + p->msln < p->loc[i+1].scIdx )
|
|
|
|
{
|
2012-11-15 04:01:05 +00:00
|
|
|
p->sei = i;
|
|
|
|
break;
|
2012-11-19 06:41:27 +00:00
|
|
|
}
|
|
|
|
|
2012-11-15 04:01:05 +00:00
|
|
|
|
|
|
|
return cmOkRC;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool _cmScFolIsMatch( const cmScFolLoc_t* loc, unsigned pitch )
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for(i=0; i<loc->pitchCnt; ++i)
|
|
|
|
if( loc->pitchV[i] == pitch )
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int _cmScFolDist(unsigned mtxMaxN, unsigned* m, const unsigned* 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;
|
|
|
|
|
|
|
|
//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;
|
|
|
|
}
|
|
|
|
|
2012-11-19 06:41:27 +00:00
|
|
|
/*
|
2012-11-15 04:01:05 +00:00
|
|
|
unsigned cmScFolExec( cmScFol* p, unsigned smpIdx, unsigned status, cmMidiByte_t d0, cmMidiByte_t d1 )
|
|
|
|
{
|
|
|
|
assert( p->sri != cmInvalidIdx );
|
|
|
|
|
|
|
|
unsigned ret_idx = cmInvalidIdx;
|
|
|
|
unsigned ewnd[ p->wndN ];
|
|
|
|
|
|
|
|
if( status != kNoteOnMdId && d1>0 )
|
|
|
|
return ret_idx;
|
|
|
|
|
|
|
|
// left shift wndV[] to make the right-most element available - then copy in the new element
|
|
|
|
memmove(p->wndV, p->wndV+1, sizeof(cmScFolWndEle_t)*(p->wndN-1));
|
|
|
|
p->wndV[ p->wndN-1 ].smpIdx = smpIdx;
|
|
|
|
p->wndV[ p->wndN-1 ].val = d0;
|
|
|
|
p->wndV[ p->wndN-1 ].validFl= true;
|
|
|
|
|
|
|
|
// fill in ewnd[] with the valid values in wndV[]
|
|
|
|
int i = p->wndN-1;
|
|
|
|
int en = 0;
|
|
|
|
for(; i>=0; --i,++en)
|
|
|
|
{
|
2012-11-19 06:41:27 +00:00
|
|
|
//if( p->wndV[i].validFl && ((smpIdx-p->wnd[i].smpIdx)<=maxWndSmp))
|
|
|
|
if( p->wndV[i].validFl )
|
2012-11-15 04:01:05 +00:00
|
|
|
ewnd[i] = p->wndV[i].val;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++i; // increment i to the first valid element in ewnd[].
|
|
|
|
|
|
|
|
int k;
|
|
|
|
printf("en:%i sbi:%i sei:%i pitch:%s : ",en,p->sbi,p->sei,cmMidiToSciPitch(d0,NULL,0));
|
|
|
|
for(k=i; k<p->wndN; ++k)
|
|
|
|
printf("%s ", cmMidiToSciPitch(ewnd[k],NULL,0));
|
|
|
|
printf("\n");
|
|
|
|
|
|
|
|
// en is the count of valid elements in ewnd[].
|
|
|
|
// ewnd[i] is the first valid element
|
|
|
|
|
|
|
|
int j = 0;
|
|
|
|
int dist;
|
|
|
|
int minDist = INT_MAX;
|
|
|
|
int minIdx = cmInvalidIdx;
|
|
|
|
for(j=0; p->sbi+en+j <= p->sei; ++j)
|
|
|
|
if((dist = _cmScFolDist(p->wndN, p->edWndMtx, ewnd+i, p->loc + p->sbi+j, en )) < minDist )
|
|
|
|
{
|
|
|
|
minDist = dist;
|
|
|
|
minIdx = j;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The best fit is on the score window: p->loc[sbi+minIdx : sbi+minIdx+en-1 ]
|
|
|
|
|
|
|
|
int evalWndN = cmMin(en,p->evalWndN);
|
|
|
|
|
|
|
|
assert(evalWndN<p->wndN);
|
|
|
|
|
|
|
|
j = p->sbi+minIdx+en - evalWndN;
|
|
|
|
|
|
|
|
// Determine how many of the last evalWndN elements match
|
|
|
|
dist = _cmScFolDist(p->wndN, p->edWndMtx, ewnd+p->wndN-evalWndN, p->loc+j, evalWndN );
|
|
|
|
|
|
|
|
// a successful match has <= allowedMissCnt and an exact match on the last element
|
|
|
|
//if( dist <= p->allowedMissCnt && ewnd[p->wndN-1] == p->loc[p->sbi+minIdx+en-1] )
|
2012-11-19 06:41:27 +00:00
|
|
|
//if( dist <= p->allowedMissCnt && _cmScFolIsMatch(p->loc+(p->sbi+minIdx+en-1),ewnd[p->wndN-1]))
|
|
|
|
if( _cmScFolIsMatch(p->loc+(p->sbi+minIdx+en-1),ewnd[p->wndN-1]))
|
2012-11-15 04:01:05 +00:00
|
|
|
{
|
|
|
|
p->sbi = p->sbi + minIdx;
|
|
|
|
p->sei = cmMin(p->sei+minIdx,p->locN-1);
|
|
|
|
ret_idx = p->sbi+minIdx+en-1;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("minDist:%i minIdx:%i evalDist:%i sbi:%i sei:%i\n",minDist,minIdx,dist,p->sbi,p->sei);
|
|
|
|
|
|
|
|
return ret_idx;
|
|
|
|
}
|
2012-11-19 06:41:27 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
unsigned cmScFolExec( cmScFol* p, unsigned smpIdx, unsigned status, cmMidiByte_t d0, cmMidiByte_t d1 )
|
|
|
|
{
|
|
|
|
|
|
|
|
unsigned ret_idx = cmInvalidIdx;
|
|
|
|
unsigned ebuf[ p->bufN ];
|
|
|
|
|
|
|
|
if( status != kNoteOnMdId && d1>0 )
|
|
|
|
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 i = p->bufN-1;
|
|
|
|
int en = 0;
|
|
|
|
for(; i>=0; --i,++en)
|
|
|
|
{
|
|
|
|
if( p->bufV[i].validFl)
|
|
|
|
ebuf[i] = p->bufV[i].val;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
++i; // increment i to the first valid element in ebuf[].
|
|
|
|
|
|
|
|
|
|
|
|
// 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 <= p->sei; ++j)
|
|
|
|
if((dist = _cmScFolDist(p->bufN, p->edWndMtx, ebuf+i, p->loc + p->sbi+j, en )) < minDist )
|
|
|
|
{
|
|
|
|
minDist = dist;
|
|
|
|
minIdx = j;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The best fit is on the score window: p->loc[sbi+minIdx : sbi+minIdx+en-1 ]
|
|
|
|
|
|
|
|
// if a perfect match occurred
|
|
|
|
if( minDist == 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 just past last match
|
|
|
|
ret_idx = p->sbi + minIdx + en - 1;
|
|
|
|
// BUG BUG BUG - is the window length valid -
|
|
|
|
// - sbi and sei must be inside 0:locN
|
|
|
|
// - sei-sbi + 1 must be >= en
|
|
|
|
}
|
|
|
|
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),ebuf[p->bufN-1]) )
|
|
|
|
ret_idx = p->sbi + minIdx + en - 1;
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
|
|
|
assert( p->sei > p->sbi );
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
|
|
|
// BUG BUG BUG - is the window length valid -
|
|
|
|
// - sbi and sei must be inside 0:locN
|
|
|
|
// - sei-sbi + 1 must be >= en
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// BUG BUG BUG - this is not currently guarded against
|
|
|
|
assert( p->sei < p->locN );
|
|
|
|
assert( p->sbi < p->locN );
|
|
|
|
|
|
|
|
return ret_idx;
|
|
|
|
}
|