cml/libcm
1
0
Förgrening 0
Kod Ärenden Pull-förfrågningar Släpp Wiki Aktiviteter
7c6a0f5da5
libcm/app/cmTakeSeqBldr.c
Kevin Larke 4ddbe2c1d6 cmTakeSeqBldr.h/c : Many changes and additions.
2015-03-30 14:38:49 -07:00

1619 rader
42 KiB
C
Rå Blame Historik

#include "cmPrefix.h"
#include "cmGlobal.h"
#include "cmFloatTypes.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmLinkedHeap.h"
#include "cmJson.h"
#include "cmTime.h"
#include "cmMidi.h"
#include "cmMidiFile.h"
#include "cmAudioFile.h"
#include "cmTimeLine.h"
#include "cmSymTbl.h"
#include "cmScore.h"
#include "cmTakeSeqBldr.h"
// Score track record: Map a score event to a MIDI event.
typedef struct cmScTrkMidiTsb_str
{
unsigned mni; // MIDI note index as an offset from the take marker
unsigned muid; // MIDI file msg unique id
unsigned scEvtIdx; // score event index this note/pedal is assoc'd with or -1 if it did not match
unsigned flags; // flags from cmScMatcherResult_t
} cmScTrkMidiTsb_t;
// Score Tracking info. from a single take (time-line marker)
typedef struct cmScTrkTakeTsb_str
{
unsigned tlMarkerUid; // marker time line uid assoc'd with this take
cmScTrkMidiTsb_t* midiV; // midiV[midiN] score to midi file map recd. array.
unsigned midiN; // count of records in midiV[]
unsigned minMuid; // min MIDI muid in midiV[]
unsigned maxMuid; // max MIDI muid in midiV[]
unsigned minScEvtIdx; // min scEvtIdx in midiV[]
unsigned maxScEvtIdx; // max scEvtIdx in midiV[]
bool failFl;
} cmScTrkTakeTsb_t;
//
typedef struct cmMidiTsb_str
{
unsigned rid; // unique id among all object in this take
unsigned srcId; // marker uid or -1 if this event was manually inserted
unsigned scEvtIdx; // score event assocd with this midi event
unsigned flags; // copy of cmScTrkMidiTsb_t.flags or 0 if not assoc'd with a score event
struct cmMidiTsb_str* ref; // previous MIDI event in time
unsigned offsetSmp; // time offset from *ref
unsigned durSmp; // duration of this MIDI event
unsigned status; // MIDI status value
unsigned d0; // d0 MIDI channel msg data byte 0.
unsigned d1; // d1 MIDI channel msg data byte 1.
struct cmMidiTsb_str* link; // pointer to next MIDI event in list
} cmMidiTsb_t;
// This record contains all the score events and and score synchronized MIDI events
// associated with a given take. Each call to cmTakeSeqBldrLoadTake() creates
// one of these records.
typedef struct cmTakeTsb_str
{
unsigned tlMarkerUid; // time-line marker uid associated with this take
cmScTrkTakeTsb_t* stt; // score tracking info
cmMidiTsb_t* midi; // midi events contained by this take
struct cmTakeTsb_str* link;
} cmTakeTsb_t;
typedef struct
{
cmCtx_t ctx; // application context
cmErr_t err; // internal error object
cmJsonH_t jsH; // JSON tree used to hold score tracker info.
const cmChar_t* tlFn; // time line filename
const cmChar_t* scFn; // score file name
const cmChar_t* tlPrefixPath; // path to time line audio and MIDI files
cmTlH_t tlH; // time-line handle
cmScH_t scH; // score handle
cmScTrkTakeTsb_t* scTrkTakeV; // score tracker file info scTrkTakeV[ scTrkTakeN ]
unsigned scTrkTakeN; // (one record per take)
cmTakeTsb_t* takes; // list of loaded takes
cmTakeTsb_t* manual; // list of manually inserted MIDI events
cmTakeTsb_t* out; // render list
cmMidiTsb_t* evt; // next event to play from the render list
unsigned absPlaySmp; // absolute sample index of the clock
unsigned absEvtSmp; // absolute sample index of the next event to play
unsigned nextRid;
cmMidiTsb_t* rend;
} cmTsb_t;
cmTakeSeqBldrH_t cmTakeSeqBldrNullHandle = cmSTATIC_NULL_HANDLE;
cmTsb_t* _cmTsbHandleToPtr( cmTakeSeqBldrH_t h )
{
cmTsb_t* p = (cmTsb_t*)h.h;
return p;
}
//-------------------------------------------------------------------------------------------------------------------------
typedef struct cmOrderTsb_str
{
cmTakeTsb_t* t;
unsigned minScEvtIdx; // take begin
unsigned maxScEvtIdx; // take end
unsigned begScEvtIdx; // render begin (render beg/end is always contained
unsigned endScEvtIdx; // render end withing min/maxScEvtIdx)
struct cmOrderTsb_str* link;
} cmOrderTsb_t;
// Notes:
// 1) begScEvtIdx - endScEvtIdx is always contained within minScEvtIdx-maxScEvtIdx.
// 2) If begScEvtIdx == cmInvalidIdx then the take was entirely contained inside the
// previous take and is therefore skipped over.
// Free a linked list of cmOrderTsb_t records
void _cmTakeSeqBldrFreeOrder( cmOrderTsb_t* o )
{
while(o!=NULL)
{
cmOrderTsb_t* o0 = o->link;
cmMemFree(o);
o = o0;
}
}
// Create a linked list of cmOrderTsb_t records from the p->takes list.
cmOrderTsb_t* _cmTakeSeqBldrAllocOrder( cmTsb_t* p )
{
cmOrderTsb_t* o = NULL;
cmOrderTsb_t* o0 = NULL;
cmTakeTsb_t* t = p->takes;
// create a list of order records - one per take
for(; t!=NULL; t=t->link)
if( t->stt != NULL )
{
cmOrderTsb_t* o1 = cmMemAllocZ(cmOrderTsb_t,1);
o1->t = t;
o1->minScEvtIdx = t->stt->minScEvtIdx;
o1->maxScEvtIdx = t->stt->maxScEvtIdx;
o1->begScEvtIdx = o1->minScEvtIdx;
o1->endScEvtIdx = o1->maxScEvtIdx;
if( o0 == NULL )
o = o1;
else
o0->link = o1;
o0 = o1;
}
return o;
}
// Sort a list of cmOrderTsb_t records on minScEvtIdx.
cmOrderTsb_t* _cmTakeSeqBldrSortOrder( cmOrderTsb_t* o )
{
cmOrderTsb_t* beg = NULL;
cmOrderTsb_t* end = NULL;
cmOrderTsb_t* m = NULL;
// while elements remain on the unordered list
while( o != NULL )
{
cmOrderTsb_t* c0 = NULL;
cmOrderTsb_t* c1 = o->link;
m = o;
// set m to point to the recd with the min minScEvtIdx
for(; c1!=NULL; c1=c1->link )
if( c1->minScEvtIdx < m->minScEvtIdx )
m = c1;
// for each recd on the unordered list
for(c1=o; c1!=NULL; c1=c1->link)
{
// if this is the min record
if( c1==m )
{
// remove the min recd from this list
if( c0 == NULL )
o = c1->link;
else
c0->link = c1->link;
c1->link = NULL;
break;
}
c0 = c1;
}
// c1 now points to the min record
assert(c1==m);
if( end == NULL )
beg = end = m;
else
{
end->link = m;
end = m;
}
}
return beg;
}
// Set the begScEvtIdx and endScEvtIdx fields to settle conflicts
// between overlapping takes.
void _cmTakeSeqBldrSetBegEndOrder( cmOrderTsb_t* o )
{
if( o == NULL )
return;
// Earlier takes have priority over later takes so the first
// take has highest priority and therefore it's beg=min and end=max.
o->begScEvtIdx = o->minScEvtIdx;
o->endScEvtIdx = o->maxScEvtIdx;
cmOrderTsb_t* o0 = o;
cmOrderTsb_t* o1 = o->link;
while( o1!=NULL)
{
bool skipFl = false;
// if this take begins after the previous take
if( o1->minScEvtIdx > o0->endScEvtIdx )
{
o1->begScEvtIdx = o1->minScEvtIdx;
o1->endScEvtIdx = o1->maxScEvtIdx;
}
else
{
// if this take is entirely contained in the previous take
// then this take is skipped.
if( o0->endScEvtIdx > o1->maxScEvtIdx )
{
o1->begScEvtIdx = cmInvalidIdx;
o1->endScEvtIdx = cmInvalidIdx;
skipFl = true;
}
else // this take overlaps with the previous take
{
o1->begScEvtIdx = o0->endScEvtIdx + 1;
o1->endScEvtIdx = o1->maxScEvtIdx;
}
}
if( skipFl )
{
// the current take is being skipped so do not change o0
o1 = o1->link;
}
else
{
// advance to the next take
o0 = o1;
o1 = o0->link;
}
}
}
void _cmTakeSeqBldrPrintOrder( cmOrderTsb_t* o )
{
int i;
for(i=0; o!=NULL; o=o->link,++i)
printf("%i : %p min:%i max:%i beg:%i end:%i\n",i, o->t, o->minScEvtIdx, o->maxScEvtIdx, o->begScEvtIdx, o->endScEvtIdx);
printf("\n");
}
//-------------------------------------------------------------------------------------------------------------------------
typedef struct
{
cmScoreEvt_t* sep;
unsigned absSmp;
} cmTsbTempo_t;
void _cmTsbTempoPrint( cmTsbTempo_t* r, unsigned rN )
{
unsigned i;
for(i=0; i<rN; ++i)
printf("%s %i\n",cmScEvtTypeIdToLabel(r[i].sep->type),r[i].absSmp);
printf("\n");
}
cmTsbTempo_t* _cmTsbTempoFind( cmTsbTempo_t* r, unsigned rN, unsigned scEvtIdx )
{
unsigned i;
for(i=0; i<rN; ++i)
if( r[i].sep->index == scEvtIdx )
return r + i;
return NULL;
}
// Starting at r[ri] calc the tempo for the next two bars.
unsigned _cmTsbTempoCalc( cmTsbTempo_t* r, unsigned rN, unsigned ri, double srate )
{
unsigned durBarCnt = 2;
unsigned barIdx = 0;
double beats = 0;
unsigned abs0Smp = -1;
unsigned abs1Smp = -1;
for(; ri<rN; ++ri)
{
// if this is a note event
if( r[ri].sep->type == kNonEvtScId )
{
beats += r[ri].sep->frac;
if( abs0Smp == -1 )
abs0Smp = r[ri].absSmp;
if( r[ri].absSmp != -1 )
abs1Smp = r[ri].absSmp;
}
// if this is a bar event
if( r[ri].sep->type == kBarEvtScId )
{
barIdx += 1;
if( barIdx == durBarCnt )
break;
}
}
double durSmp = abs1Smp - abs0Smp;
if( durSmp == 0 )
return 0;
return (unsigned)round(beats / (durSmp / (srate * 60.0)));
}
cmTsbRC_t _cmTsbCalcTempo( cmTsb_t* p, cmTakeTsb_t* t, unsigned* begBpSRef, unsigned* endBpSRef )
{
unsigned i,j;
assert( begBpSRef != NULL && endBpSRef != NULL );
*begBpSRef = 0;
*endBpSRef = 0;
if( t->stt == NULL )
return cmErrMsg(&p->err,kMissingScTrkTsbRC,"The tempo of takes without score-tracking results cannot be calculated.");
if( t->midi == NULL )
return cmErrMsg(&p->err,kInvalidArgTsbRC,"The tempo of a take without MIDI events cannot be estimated.");
// allocate an array to with one record per score event in the take
unsigned rN = t->stt->maxScEvtIdx - t->stt->minScEvtIdx + 1;
cmTsbTempo_t r[ rN ];
// assign a score event pointer to each record
for(i=0; i<rN; ++i)
{
r[i].sep = cmScoreEvt(p->scH,t->stt->minScEvtIdx + i);
assert( r[i].sep != NULL );
r[i].absSmp = -1;
}
// use MIDI events with score information to assign absolute
// time information to as many score events as possible.
unsigned absSmp = 0;
cmMidiTsb_t* m = t->midi;
while( m!=NULL )
{
cmTsbTempo_t* r0 = NULL;
if( m->scEvtIdx != cmInvalidIdx && (r0 = _cmTsbTempoFind(r,rN,m->scEvtIdx)) != NULL )
{
assert( r0->sep->type == kNonEvtScId );
r0->absSmp = absSmp;
}
m = m->link;
if( m != NULL )
absSmp += m->offsetSmp;
}
unsigned barCnt = 0;
// assign an absolute time to each bar recd
for(i=0; i<rN; ++i)
if( r[i].sep->type == kBarEvtScId )
{
barCnt += 1; // count the number of bars found
// search ahead from the bar to the next note
unsigned j;
for(j=i; j<rN; ++j)
if( r[j].sep->type == kNonEvtScId )
{
r[i].absSmp = r[j].absSmp; // the bar time is the same as the next
break;
}
}
//_cmTsbTempoPrint(r,rN);
unsigned tempoV[ barCnt ];
for(i=0,j=0; i<rN && j<barCnt; ++i)
{
tempoV[j++] = _cmTsbTempoCalc(r, rN, i, cmTimeLineSampleRate(p->tlH) );
for(; i<rN; ++i)
if( r[i].sep->type == kBarEvtScId )
break;
}
if( j > 0 )
{
*begBpSRef = tempoV[0];
*endBpSRef = tempoV[j-1];
}
printf("Bars:%i ",barCnt);
for(i=0; i<j; ++i)
printf("%i ",tempoV[i]);
printf("\n");
return kOkTsbRC;
}
//-------------------------------------------------------------------------------------------------------------------------
void _cmTsbPrintMidi( cmTakeTsb_t* t )
{
if( t==NULL )
return;
cmMidiTsb_t* m = t->midi;
for(; m!=NULL; m=m->link)
printf("mark:%4i sei:%4i fl:0x%x offs:%8i dur:%8i\n", m->srcId, m->scEvtIdx,m->flags,m->offsetSmp,m->durSmp);
printf("\n");
}
void _cmTsbTakePrint( cmTakeTsb_t* t )
{
for(; t!=NULL; t=t->link)
{
printf("Take:%i %p\n", t->tlMarkerUid, t->stt);
_cmTsbPrintMidi(t);
}
}
cmTsbRC_t _cmTsbScoreTrkFree( cmTsb_t* p )
{
cmTsbRC_t rc = kOkTsbRC;
unsigned i;
if( cmJsonFinalize(&p->jsH) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON object finalize failed.");
goto errLabel;
}
if( p->scTrkTakeV != NULL )
{
for(i=0; i<p->scTrkTakeN; ++i)
cmMemPtrFree(&p->scTrkTakeV[i].midiV);
cmMemPtrFree(&p->scTrkTakeV);
}
if( cmTimeLineFinalize(&p->tlH) != kOkTlRC )
rc = cmErrMsg(&p->err,kTimeLineFailTsbRC,"Time line object finalize failed.");
if( cmScoreFinalize(&p->scH) != kOkScRC )
rc = cmErrMsg(&p->err,kScoreFailTsbRC,"Score finalize failed.");
errLabel:
return rc;
}
// Free a take record. Note that the record must be unlinked
// from p->takes (See _cmTakeTsbUnlink().) prior to calling this function.
void _cmTsbTakeFree( cmTsb_t* p, cmTakeTsb_t** tp )
{
if( tp==NULL || *tp==NULL )
return;
cmMidiTsb_t* m = (*tp)->midi;
while( m != NULL )
{
cmMidiTsb_t* nm = m->link;
cmMemFree(m);
m = nm;
}
cmMemPtrFree(tp);
}
void _cmTsbRendTakeFree( cmTsb_t* p, cmTakeTsb_t** t )
{
_cmTsbTakeFree(p,t);
p->evt = NULL;
p->absPlaySmp = 0;
p->absEvtSmp = 0;
p->nextRid = 0;
p->rend = NULL;
}
// Unlink a 'take' record from p->takes.
cmTakeTsb_t* _cmTsbTakeUnlink( cmTsb_t* p, cmTakeTsb_t* t )
{
cmTakeTsb_t* t0 = NULL;
cmTakeTsb_t* t1 = p->takes;
while( t1 != NULL )
{
if( t1 == t )
{
if( t0 == NULL )
p->takes = t->link;
else
t0->link = t->link;
return t;
}
}
return NULL;
}
cmTsbRC_t _cmTsbFree( cmTsb_t* p )
{
cmTsbRC_t rc = kOkTsbRC;
if((rc = _cmTsbScoreTrkFree(p)) != kOkTsbRC )
goto errLabel;
//_cmTsbTakePrint(p->takes);
//_cmTsbTakePrint(p->out);
cmTakeTsb_t* t = p->takes;
while( t != NULL )
{
cmTakeTsb_t* nt = t->link;
_cmTsbTakeFree(p,&t);
t = nt;
}
_cmTsbRendTakeFree(p,&p->out);
cmMemFree(p);
errLabel:
return rc;
}
cmScTrkTakeTsb_t* _cmTsbMarkerIdToScTrkTake( cmTsb_t* p, unsigned markerUid )
{
unsigned i;
for(i=0; p->scTrkTakeN; ++i)
if( p->scTrkTakeV[i].tlMarkerUid == markerUid )
return p->scTrkTakeV + i;
return NULL;
}
cmScTrkMidiTsb_t* _cmTsbMuidToScTrkMidi( cmScTrkTakeTsb_t* t, unsigned muid )
{
unsigned i;
for(i=0; i<t->midiN; ++i)
if( t->midiV[i].muid == muid )
return t->midiV + i;
return NULL;
}
cmTsbRC_t _cmTsbLoadScoreTrkFile( cmTsb_t* p, const cmChar_t* scoreTrkFn )
{
cmTsbRC_t rc = kOkTsbRC;
cmJsonNode_t* tkArrObj = NULL;
cmJsRC_t jsRC = kOkJsRC;
const cmChar_t* errMsg = NULL;
unsigned i;
// initialize the TSB json object
if(( rc = cmJsonInitializeFromFile(&p->jsH,scoreTrkFn,&p->ctx)) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"The Take Sequence Builder JSON file object could not be initialized from '%s'.",cmStringNullGuard(scoreTrkFn));
goto errLabel;
}
// parse the header
if((jsRC = cmJsonMemberValues( cmJsonRoot(p->jsH), &errMsg,
"timeLineFn", kStringTId, &p->tlFn,
"scoreFn", kStringTId, &p->scFn,
"tlPrefixPath", kStringTId, &p->tlPrefixPath,
"takeArray", kArrayTId | kOptArgJsFl, &tkArrObj,
NULL )) != kOkJsRC )
{
if( jsRC == kNodeNotFoundJsRC && errMsg != NULL )
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file header parse failed missing required field:'%s'",errMsg);
else
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file header parse failed.");
goto errLabel;
}
// count of take records
p->scTrkTakeN = cmJsonChildCount(tkArrObj);
// array of take records
p->scTrkTakeV = cmMemAllocZ(cmScTrkTakeTsb_t,p->scTrkTakeN);
// for each take record
for(i=0; i<p->scTrkTakeN; ++i)
{
cmJsonNode_t* takeObj = NULL;
cmJsonNode_t* noteArrObj = NULL;
cmScTrkTakeTsb_t* t = p->scTrkTakeV + i;
unsigned j;
// get a pointer to the take record JSON object
if((takeObj = cmJsonArrayElement(tkArrObj,i)) == NULL )
{
rc = cmErrMsg(&p->err,kParseFailTsbRC,"Take record header at index %i access failed.",i);
goto errLabel;
}
// parse the take record
if((jsRC = cmJsonMemberValues( takeObj, &errMsg,
"markerUid",kIntTId, &t->tlMarkerUid,
"failFl", kIntTId, &t->failFl,
"array", kArrayTId, &noteArrObj,
NULL)) != kOkJsRC )
{
if( jsRC == kNodeNotFoundJsRC && errMsg != NULL )
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file take record parse failed missing required field:'%s'",errMsg);
else
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file take record parse failed.");
goto errLabel;
}
// get the count of note records
t->midiN = cmJsonChildCount(noteArrObj);
// allocate a note record array for this take
t->midiV = cmMemAllocZ(cmScTrkMidiTsb_t, t->midiN);
t->minMuid = INT_MAX;
t->maxMuid = 0;
t->minScEvtIdx = INT_MAX;
t->maxScEvtIdx = 0;
// for each note record
for(j=0; j<t->midiN; ++j)
{
cmJsonNode_t* noteObj = NULL;
// get the note record JSON object
if((noteObj = cmJsonArrayElement(noteArrObj,j)) == NULL )
{
rc = cmErrMsg(&p->err,kParseFailTsbRC,"Access failed for note record at index %i at take index %i.",j,i);
goto errLabel;
}
// parse the note record
if((jsRC = cmJsonMemberValues( noteObj, &errMsg,
"mni", kIntTId, &t->midiV[j].mni,
"muid", kIntTId, &t->midiV[j].muid,
"scEvtIdx", kIntTId, &t->midiV[j].scEvtIdx,
"flags", kIntTId, &t->midiV[j].flags,
NULL)) != kOkJsRC )
{
if( jsRC == kNodeNotFoundJsRC && errMsg != NULL )
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file note record parse failed missing required field:'%s'",errMsg);
else
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file note record parse failed.");
goto errLabel;
}
if( t->midiV[j].muid < t->minMuid )
t->minMuid = t->midiV[j].muid;
if( t->midiV[j].muid > t->maxMuid )
t->maxMuid = t->midiV[j].muid;
unsigned scEvtIdx = t->midiV[j].scEvtIdx;
if( scEvtIdx!=0 && scEvtIdx!=cmInvalidIdx && scEvtIdx < t->minScEvtIdx )
t->minScEvtIdx = scEvtIdx;
if( scEvtIdx!=0 && scEvtIdx!=cmInvalidIdx && scEvtIdx > t->maxScEvtIdx )
t->maxScEvtIdx = t->midiV[j].scEvtIdx;
}
}
errLabel:
if( rc != kOkTsbRC )
rc = _cmTsbScoreTrkFree(p);
return rc;
}
cmTsbRC_t _cmTakeSeqBldrRender( cmTsb_t* p )
{
cmTsbRC_t rc = kOkTsbRC;
unsigned takeCnt = 0;
unsigned midiCnt = 0;
// delete the previous output rendering
_cmTsbRendTakeFree(p,&p->out);
// allocate a take order list
cmOrderTsb_t* o = _cmTakeSeqBldrAllocOrder( p );
// sort the list by minScEvtIdx
o = _cmTakeSeqBldrSortOrder(o);
// assign beg/endScEvtIdx values to each take
_cmTakeSeqBldrSetBegEndOrder(o);
//_cmTakeSeqBldrPrintOrder(o);
// if the render take has not yet been allocated
p->out = cmMemAllocZ(cmTakeTsb_t,1);
p->out->tlMarkerUid = cmInvalidId;
p->nextRid = 0;
cmMidiTsb_t* m0 = NULL;
cmOrderTsb_t* t = o;
for(; t!=NULL; t=t->link)
{
// skip takes whose begScEvtIdx is not valid
if( t->begScEvtIdx == cmInvalidIdx )
continue;
takeCnt += 1;
//_cmTsbPrintMidi(t->t);
// advance to the MIDI event assoc'd with t->begScEvtIdx
cmMidiTsb_t* m = t->t->midi;
for(; m!=NULL; m=m->link)
if( m->scEvtIdx >= t->begScEvtIdx )
break;
// copy the MIDI events from the take into the render list
for(; m!=NULL; m=m->link)
{
midiCnt += 1;
// allocate a MIDI record to hold this render event
cmMidiTsb_t* m1 = cmMemAllocZ(cmMidiTsb_t,1);
// copy in the MIDI record
*m1 = *m;
//memcpy(m1,m,sizeof(cmMidiTsb_t));
m1->link= NULL; // NULLify the copied link
m1->ref = m0; // set prev. link
m1->rid = p->nextRid++; // set the unique id
// if this is not the first MIDI event ...
if( m0 != NULL )
m0->link = m1; // then set next link on the previous record
else //
{ // otherwise
p->out->midi = m1; // 1) set the render take event list
m1->offsetSmp = 0; // 2) the first event always starts at time zero.
p->evt = m1; // 3) set the first event to play
p->absPlaySmp = 0; // 4) set the current play clock to 0
p->absEvtSmp = 0; // 5) set the current next play event time to 0
}
m0 = m1;
// if this is the last event in this take
if( m0->scEvtIdx == t->endScEvtIdx )
break;
}
}
// free the take order list
_cmTakeSeqBldrFreeOrder(o);
printf("rendered takes:%i events:%i\n",takeCnt,midiCnt);
//_cmTsbPrintMidi(p->out);
return rc;
}
cmTsbRC_t cmTakeSeqBldrAlloc( cmCtx_t* ctx, cmTakeSeqBldrH_t* hp )
{
cmTsbRC_t rc;
if((rc = cmTakeSeqBldrFree(hp)) != kOkTsbRC )
return kOkTsbRC;
cmTsb_t* p = cmMemAllocZ(cmTsb_t,1);
cmErrSetup(&p->err,&ctx->rpt,"TakeSeqBldr");
p->ctx = *ctx;
hp->h = p;
return rc;
}
cmTsbRC_t cmTakeSeqBldrAllocFn( cmCtx_t* ctx, cmTakeSeqBldrH_t* hp, const cmChar_t* scoreTrkFn )
{
cmTsbRC_t rc;
if((rc = cmTakeSeqBldrAlloc(ctx,hp)) != kOkTsbRC )
return rc;
if((rc = cmTakeSeqBldrInitialize(*hp,scoreTrkFn)) != kOkTsbRC )
return rc;
return rc;
}
cmTsbRC_t cmTakeSeqBldrFree( cmTakeSeqBldrH_t* hp )
{
cmRC_t rc = kOkTsbRC;
if( hp == NULL || cmTakeSeqBldrIsValid(*hp)==false )
return kOkTsbRC;
cmTsb_t* p = _cmTsbHandleToPtr(*hp);
if((rc = _cmTsbFree(p)) != kOkTsbRC )
return rc;
hp->h = NULL;
return rc;
}
bool cmTakeSeqBldrIsValid( cmTakeSeqBldrH_t h )
{ return h.h != NULL; }
cmTsbRC_t cmTakeSeqBldrInitialize( cmTakeSeqBldrH_t h, const cmChar_t* scoreTrkFn )
{
cmTsbRC_t rc = kOkTsbRC;
cmTsb_t* p = _cmTsbHandleToPtr(h);
if(( rc = _cmTsbLoadScoreTrkFile( p, scoreTrkFn )) != kOkTsbRC )
return rc;
if( cmTimeLineInitializeFromFile(&p->ctx, &p->tlH, NULL, NULL, p->tlFn, p->tlPrefixPath ) != kOkTlRC )
{
rc = cmErrMsg(&p->err,kTimeLineFailTsbRC,"The time-line file '%s' could not be loaded.",p->tlFn);
goto errLabel;
}
if( cmScoreInitialize(&p->ctx, &p->scH, p->scFn, 0, NULL, 0, NULL, NULL, cmSymTblNullHandle ) != kOkScRC )
{
rc = cmErrMsg(&p->err,kScoreFailTsbRC,"The score file '%s' could not be loaded.",p->scFn);
goto errLabel;
}
errLabel:
if( rc != kOkTsbRC )
_cmTsbScoreTrkFree(p);
return rc;
}
cmTakeTsb_t* _cmTsbMarkerUidToTake( cmTsb_t* p, unsigned tlMarkerUid )
{
cmTakeTsb_t* t = p->takes;
for(; t != NULL; t=t->link)
if( t->tlMarkerUid == tlMarkerUid )
return t;
return NULL;
}
cmTsbRC_t cmTakeSeqBldrLoadTake( cmTakeSeqBldrH_t h, unsigned tlMarkUid, bool overwriteFL )
{
cmTsbRC_t rc = kOkTsbRC;
cmTsb_t* p = _cmTsbHandleToPtr(h);
cmTlMarker_t* mark = NULL;
cmTlMidiFile_t* mf = NULL;
cmMidiFileH_t mfH = cmMidiFileNullHandle;
cmScTrkTakeTsb_t* stt = NULL;
// verify that the requested take has not already been loaded
if( _cmTsbMarkerUidToTake( p, tlMarkUid ) != NULL )
{
rc = cmErrMsg(&p->err,kInvalidArgTsbRC,"The take indicated by marker id %i has already been loaded.",tlMarkUid );
goto errLabel;
}
// find the score tracked take for the requested marker
if((stt = _cmTsbMarkerIdToScTrkTake(p,tlMarkUid )) == NULL )
{
rc = cmErrMsg(&p->err,kInvalidArgTsbRC,"The score tracked take indicated by marker id %i could not be found.", tlMarkUid );
goto errLabel;
}
// get a pointer to the time-line marker object
if((mark = cmTlMarkerObjPtr( p->tlH, cmTimeLineIdToObj( p->tlH, cmInvalidId, tlMarkUid))) == NULL )
{
rc = cmErrMsg(&p->err,kInvalidArgTsbRC,"The time-line marker uid '%i' is not valid.",tlMarkUid);
goto errLabel;
}
// get the name of the MIDI file which contains the marker
if((mf = cmTimeLineMidiFileAtTime( p->tlH, mark->obj.seqId, mark->obj.seqSmpIdx )) == NULL )
{
rc = cmErrMsg(&p->err,kInvalidArgTsbRC,"The time-line marker '%i' does not intersect with a MIDI file.",tlMarkUid);
goto errLabel;
}
// open the MIDI file
if( cmMidiFileOpen( cmMidiFileName(mf->h), &mfH, &p->ctx ) != kOkMfRC )
{
rc = cmErrMsg(&p->err,kInvalidArgTsbRC,"The MIDI file '%s' could not be opened.", cmStringNullGuard(cmMidiFileName(mf->h)));
goto errLabel;
}
// convert the dtick field to delta samples
cmMidiFileTickToSamples( mfH, cmTimeLineSampleRate(p->tlH), false );
// calculate MIDI note and pedal durations (see cmMidiChMsg_t.durTicks)
cmMidiFileCalcNoteDurations( mfH );
unsigned i = 0;
unsigned n = cmMidiFileMsgCount(mfH);
const cmMidiTrackMsg_t** a = cmMidiFileMsgArray(mfH);
// allocate and link a new take render record
cmTakeTsb_t* t = cmMemAllocZ(cmTakeTsb_t,1);
t->tlMarkerUid = tlMarkUid;
t->stt = stt;
t->link = p->takes;
p->takes = t;
unsigned rid = 0;
cmMidiTsb_t* m0 = NULL;
const cmMidiTrackMsg_t* mf0 = NULL;
// for each MIDI message in the file
for(i=0; i<n; ++i)
{
const cmMidiTrackMsg_t* mf1 = a[i];
// we are only interested in rendering notes and control msgs
switch( mf1->status )
{
case kNoteOnMdId:
case kNoteOffMdId:
case kCtlMdId:
break;
default:
continue;
}
// if this MIDI message is inside the tracked region of the take
if( stt->minMuid > mf1->uid || mf1->uid > stt->maxMuid )
continue;
// get a pointer to the tracking map for the given MIDI file event.
// (Note that since control messages are not tracked so this function may return NULL.)
cmScTrkMidiTsb_t* stm = _cmTsbMuidToScTrkMidi(stt, mf1->uid );
// create a MIDI render event
cmMidiTsb_t* m1 = cmMemAllocZ(cmMidiTsb_t,1);
m1->rid = rid++;
m1->srcId = tlMarkUid;
m1->scEvtIdx = stm != NULL ? stm->scEvtIdx : cmInvalidIdx;
m1->flags = stm != NULL ? stm->flags : 0;
m1->ref = m0;
m1->offsetSmp = mf0 == NULL ? 0 : mf1->dtick;
m1->durSmp = mf1->u.chMsgPtr->durTicks;
m1->d0 = mf1->u.chMsgPtr->d0;
m1->d1 = mf1->u.chMsgPtr->d1;
m1->status = mf1->status;
m1->link = NULL;
//printf("0x%x %f %f\n",m1->status,m1->offsetSmp/96000.0,m1->durSmp/96000.0);
if( m0 != NULL )
m0->link = m1;
if( t->midi == NULL )
t->midi = m1;
m0 = m1;
mf0 = mf1;
}
//unsigned begBpS, endBpS;
//_cmTsbCalcTempo(p, t, &begBpS, &endBpS );
// render the new output sequence
if((rc = _cmTakeSeqBldrRender(p)) != kOkTsbRC)
cmErrMsg(&p->err,rc,"Take sequence builder rendering failed.");
errLabel:
if( cmMidiFileClose(&mfH) != kOkMfRC )
rc = cmErrMsg(&p->err,kMidiFileFailTsbRC,"MIDI file close failed.");
return rc;
}
cmTsbRC_t cmTakeSeqBldrUnloadTake( cmTakeSeqBldrH_t h, unsigned tlMarkUid )
{
cmTsbRC_t rc = kOkTsbRC;
cmTsb_t* p = _cmTsbHandleToPtr(h);
cmTakeTsb_t* t;
if((t = _cmTsbMarkerUidToTake(p, tlMarkUid )) == NULL )
return cmErrMsg(&p->err,kInvalidArgTsbRC,"The take indicated by marker id %i could not be found.",tlMarkUid);
t = _cmTsbTakeUnlink(p,t);
assert( t != NULL );
_cmTsbTakeFree(p,&t);
// render the new output sequence
if((rc = _cmTakeSeqBldrRender(p)) != kOkTsbRC)
cmErrMsg(&p->err,rc,"Take sequence builder rendering failed.");
return rc;
}
double cmTakeSeqBldrSampleRate( cmTakeSeqBldrH_t h )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
if( cmTimeLineIsValid( p->tlH ) )
return cmTimeLineSampleRate(p->tlH );
return 0;
}
cmScH_t cmTakeSeqBldrScoreHandle( cmTakeSeqBldrH_t h )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
return p->scH;
}
unsigned cmTakeSeqBldrScTrkTakeCount( cmTakeSeqBldrH_t h )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
return p->scTrkTakeN;
}
cmTsbRC_t cmTakeSeqBldrScTrkTake( cmTakeSeqBldrH_t h, unsigned idx, cmTksbScTrkTake_t* ref )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
assert( idx < p->scTrkTakeN );
ref->minScEvtIdx = p->scTrkTakeV[ idx ].minScEvtIdx;
ref->maxScEvtIdx = p->scTrkTakeV[ idx ].maxScEvtIdx;
ref->tlMarkerUid = p->scTrkTakeV[idx].tlMarkerUid;
return kOkTsbRC;
}
const cmChar_t* cmTakeSeqBldrScTrkTakeText( cmTakeSeqBldrH_t h, unsigned tlMarkerUid )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
cmTlObj_t* tlObj = NULL;
cmTlMarker_t* tlMark = NULL;
if((tlObj = cmTimeLineIdToObj( p->tlH, cmInvalidId, tlMarkerUid )) == NULL )
{
cmErrMsg(&p->err,kTimeLineFailTsbRC,"Unable to locate the time line record for score-track-take uid: %i.",tlMarkerUid);
return NULL;
}
if((tlMark = cmTimeLineMarkerObjPtr( p->tlH, tlObj)) == NULL )
{
cmErrMsg(&p->err,kTimeLineFailTsbRC,"Unable to cast a time line marker object for score-track-take %i.",tlMarkerUid);
return NULL;
}
return tlMark->text;
}
cmTsbRC_t cmTakeSeqBldrPlaySeekLoc( cmTakeSeqBldrH_t h, unsigned scLocIdx )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
if( p->out == NULL )
return cmErrMsg(&p->err,kRenderSeqEmptyTsbRC,"Seek faied. The render sequence is empty.");
if( scLocIdx == cmInvalidIdx )
p->evt = p->out->midi;
else
{
cmScoreLoc_t* loc;
if(( loc = cmScoreLoc(p->scH, scLocIdx )) == NULL )
return cmErrMsg(&p->err,kInvalidArgTsbRC,"Seek failed. The requested score location (%i) could not be found.",scLocIdx);
if( loc->evtCnt == 0 || loc->evtArray[0]==NULL )
return cmErrMsg(&p->err,kInvalidArgTsbRC,"Seek failed. The requested score location (%i) has no associated event.",scLocIdx);
unsigned scEvtIdx = loc->evtArray[0]->index;
cmMidiTsb_t* m = p->out->midi;
for(; m!=NULL; m=m->link)
if( m->scEvtIdx >= scEvtIdx )
{
p->evt = m;
break;
}
if( m == NULL )
return cmErrMsg(&p->err,kInvalidArgTsbRC,"Seek failed. The requested score event index (%i) is out of range.",scEvtIdx );
}
return kOkTsbRC;
}
cmTsbRC_t cmTakeSeqBldrPlayExec( cmTakeSeqBldrH_t h, unsigned deltaSmp, cmTakeSeqBldrPlayFunc_t cbFunc, void* cbArg )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
if( p->evt == NULL )
return kOkTsbRC;
// advance the play clock
p->absPlaySmp += deltaSmp;
// if the next event time has elapsed
while( p->evt != NULL && p->absEvtSmp <= p->absPlaySmp )
{
// make the event callback
cmTksbEvent_t e;
e.smpIdx = p->absEvtSmp;
e.status = p->evt->status;
e.d0 = p->evt->d0;
e.d1 = p->evt->d1;
cbFunc(cbArg,&e);
do
{
// advance the current play event
p->evt = p->evt->link;
// the last event was not encountered and the events offset time is legal
if( p->evt != NULL && p->evt->offsetSmp != cmInvalidIdx )
{
// advance the event absolute time
p->absEvtSmp += p->evt->offsetSmp;
break;
}
}while( p->evt != NULL );
}
return kOkTsbRC;
}
void cmTakeSeqBldrRendReset( cmTakeSeqBldrH_t h )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
if( p->out == NULL )
return;
p->rend = p->out->midi;
}
void _cmTakeSeqBldrMidiToRend( cmTksbRend_t* r, const cmMidiTsb_t* m )
{
r->rid = m->rid;
r->srcId = m->srcId;
r->scEvtIdx = m->scEvtIdx;
r->flags = m->flags;
r->offsetSmp = m->offsetSmp;
r->durSmp = m->durSmp;
r->evt.smpIdx = 0;
r->evt.status = m->status;
r->evt.d0 = m->d0;
r->evt.d1 = m->d1;
}
cmMidiTsb_t* _cmTakeSeqBldrRidToMidi( cmTsb_t* p, unsigned rid )
{
cmMidiTsb_t* m;
if( p->out == NULL )
return NULL;
for(m=p->out->midi; m!=NULL; m=m->link)
if( m->rid == rid )
return m;
return NULL;
}
bool cmTakeSeqBldrRendNext(cmTakeSeqBldrH_t h, cmTksbRend_t* r)
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
cmMidiTsb_t* m = p->rend;
if( m == NULL )
return false;
p->rend = p->rend->link;
_cmTakeSeqBldrMidiToRend(r,m);
return true;
}
cmTsbRC_t cmTakeSeqBldrRendInfo( cmTakeSeqBldrH_t h, unsigned rid, cmTksbRend_t* r )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
cmMidiTsb_t* m;
if((m = _cmTakeSeqBldrRidToMidi(p, rid )) == NULL )
return cmErrMsg(&p->err,kInvalidArgTsbRC,"Unable to locate the MIDI render record associated with rid:%i.",rid);
_cmTakeSeqBldrMidiToRend(r,m);
return kOkTsbRC;
}
cmTsbRC_t cmTakeSeqBldrRendDelete( cmTakeSeqBldrH_t h, unsigned rid )
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
if( p->out == NULL || p->out->midi == NULL )
return kOkTsbRC;
cmMidiTsb_t* m1 = p->out->midi;
for(; m1!=NULL; m1=m1->link)
if( m1->rid == rid )
{
// if there is no recd before m1
if( m1->ref == NULL )
{
p->out->midi = m1->link;
// if there is a record after m1
if( p->out->midi != NULL )
{
p->out->midi->ref = NULL;
p->out->midi->offsetSmp = 0; // the first record never has a time offset
}
}
else // there is a record before m1
{
m1->ref->link = m1->link;
// if there is a record after m1
if( m1->link != NULL )
{
m1->link->ref = m1->ref;
m1->link->offsetSmp += m1->offsetSmp; // absorb m1's offset time into the next revent
}
}
cmMemFree(m1);
break;
}
_cmTsbTakePrint(p->out);
return kOkTsbRC;
}
cmTsbRC_t cmTakeSeqBldrRendInsert( cmTakeSeqBldrH_t h, const cmTksbEvent_t* e, unsigned durSmp, unsigned* ridRef)
{
cmTsb_t* p = _cmTsbHandleToPtr(h);
if( ridRef != NULL )
*ridRef = cmInvalidId;
cmMidiTsb_t* nm = cmMemAllocZ(cmMidiTsb_t,1);
nm->rid = p->nextRid++;
nm->srcId = cmInvalidId;
nm->scEvtIdx = cmInvalidId;
nm->flags = 0;
nm->durSmp = durSmp;
nm->status = e->status;
nm->d0 = e->d0;
nm->d1 = e->d1;
if( p->out == NULL )
{
p->out = cmMemAllocZ(cmTakeTsb_t,1);
p->out->tlMarkerUid = cmInvalidId;
}
if( p->out->midi == NULL )
{
p->out->midi = nm;
goto doneLabel;
}
cmMidiTsb_t* m0 = NULL;
cmMidiTsb_t* m1 = p->out->midi;
unsigned absSmpIdx = m1==NULL ? 0 : m1->offsetSmp;
for(; m1!=NULL; m1=m1->link)
{
// absSmpIdx is the absolute time of m1
// if m1 is the recd just after the new record
if( absSmpIdx > e->smpIdx )
{
// the record prior to the new record is m0
nm->ref = m0;
// the reocrd after the new record is m1
nm->link = m1;
// the new record is before m1
m1->ref = nm;
// if the new record is first on the list
if( m0 == NULL )
{
p->out->midi = nm;
// TODO: without giving more information there is no way
// to give the old first event an offset relative to the new
// first event - so the both events will be scheduled at
// time zero.
nm->offsetSmp = 0;
}
else // the new record is between m0 and m1
{
m0->link = nm;
// offset from new record to m1
unsigned dsi = absSmpIdx - e->smpIdx;
// m1's time offset is being reduced
assert( m1->offsetSmp >= dsi );
// the offset to the new record from m0
nm->offsetSmp = m1->offsetSmp - dsi;
m1->offsetSmp = dsi;
}
break;
}
// if m1 is not the last element on the list
if( m1->link != NULL )
absSmpIdx += m1->link->offsetSmp;
else
{
// insert the new event at the end of the list
nm->ref = m1;
nm->link = NULL;
m1->link = nm;
assert( e->smpIdx > absSmpIdx );
nm->offsetSmp = e->smpIdx - absSmpIdx;
break;
}
m0 = m1;
}
doneLabel:
if( ridRef != NULL )
*ridRef = nm->rid;
//_cmTsbTakePrint(p->out);
return kOkTsbRC;
}
cmTsbRC_t cmTakeSeqBldrWrite( cmTakeSeqBldrH_t h, const cmChar_t* fn )
{
cmTsbRC_t rc = kOkTsbRC;
cmJsonH_t jsH = cmJsonNullHandle;
cmJsonNode_t* arr;
cmMidiTsb_t* m;
cmTsb_t* p = _cmTsbHandleToPtr(h);
if( p->out == NULL )
return rc;
// allocate a JSON tree
if( cmJsonInitialize(&jsH,&p->ctx) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON write tree allocate failed.");
goto errLabel;
}
// insert the root object
if( cmJsonCreateObject(jsH, NULL ) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON root object allocate failed.");
goto errLabel;
}
// create the header record
if( cmJsonInsertPairs(jsH, cmJsonRoot(jsH),
"tlMarkerUid", kIntTId, p->out->tlMarkerUid,
"tlFileName", kStringTId, cmTimeLineFileName(p->tlH),
NULL) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON header record create failed.");
goto errLabel;
}
// create the MIDI event array
if((arr = cmJsonInsertPairArray(jsH, cmJsonRoot(jsH), "midi")) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"Create the MIDI event array.");
goto errLabel;
}
// fill the MIDI array
for(m=p->out->midi; m!=NULL; m=m->link)
{
if( cmJsonCreateFilledObject(jsH, arr,
"rid", kIntTId, m->rid,
"srcId", kIntTId, m->srcId,
"scEvtIdx", kIntTId, m->scEvtIdx,
"flags", kIntTId, m->flags,
"offsetSmp", kIntTId, m->offsetSmp,
"durSmp", kIntTId, m->durSmp,
"status", kIntTId, m->status,
"d0", kIntTId, m->d0,
"d1", kIntTId, m->d1,
NULL) == NULL )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON MIDI record create failed.");
goto errLabel;
}
}
// write the tree
if( cmJsonWrite( jsH, cmJsonRoot(jsH), fn ) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON write to '%s' failed.",cmStringNullGuard(fn));
}
errLabel:
if( cmJsonFinalize(&jsH) != kOkJsRC )
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON tree finalize failed.");
return rc;
}
cmTsbRC_t cmTakeSeqBldrRead( cmTakeSeqBldrH_t h, const cmChar_t* fn )
{
cmTsbRC_t rc = kOkTsbRC;
cmTsb_t* p = _cmTsbHandleToPtr(h);
cmJsonH_t jsH = cmJsonNullHandle;
const cmChar_t* jsErrLabel = NULL;
cmTakeTsb_t* t = NULL;
cmMidiTsb_t* m0 = NULL;
cmJsonNode_t* arr = NULL;
cmJsRC_t jsRC;
if( cmJsonInitializeFromFile( &jsH, fn, &p->ctx ) != kOkJsRC )
{
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"Unable to parse the JSON file '%s'.",cmStringNullGuard(fn));
goto errLabel;
}
t = cmMemAllocZ(cmTakeTsb_t,1);
if((jsRC = cmJsonMemberValues( cmJsonRoot(jsH), &jsErrLabel,
"tlMarkerUid", kIntTId, &t->tlMarkerUid,
"midi", kArrayTId, &arr,
NULL)) != kOkJsRC )
{
if( jsRC == kNodeNotFoundJsRC && jsErrLabel != NULL )
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file MIDI render header failed missing required field:'%s'",cmStringNullGuard(jsErrLabel));
else
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file MIDI render header parse failed.");
goto errLabel;
}
unsigned n = cmJsonChildCount(arr);
unsigned i;
for(i=0; i<n; ++i)
{
const cmJsonNode_t* e = cmJsonArrayElementC(arr, i );
cmMidiTsb_t* m = cmMemAllocZ(cmMidiTsb_t,1);
if((jsRC = cmJsonMemberValues( e, &jsErrLabel,
"rid", kIntTId, &m->rid,
"srcId", kIntTId, &m->srcId,
"scEvtIdx", kIntTId, &m->scEvtIdx,
"flags", kIntTId, &m->flags,
"offsetSmp", kIntTId, &m->offsetSmp,
"durSmp", kIntTId, &m->durSmp,
"status", kIntTId, &m->status,
"d0", kIntTId, &m->d0,
"d1", kIntTId, &m->d1,
NULL)) != kOkJsRC )
{
if( jsRC == kNodeNotFoundJsRC && jsErrLabel != NULL )
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file MIDI render element failed missing required field:'%s' on index:%i",cmStringNullGuard(jsErrLabel),i);
else
rc = cmErrMsg(&p->err,kParseFailTsbRC,"JSON file MIDI render element parse failed on index: %i.", i);
goto errLabel;
}
m->ref = m0;
if( m0 == NULL )
t->midi = m;
else
m0->link = m;
}
errLabel:
if( cmJsonFinalize(&jsH) != kOkJsRC )
rc = cmErrMsg(&p->err,kJsonFailTsbRC,"JSON finalize failed.");
if( rc != kOkTsbRC )
_cmTsbTakeFree(p,&t);
else
{
_cmTsbRendTakeFree(p,&p->out);
p->out = t;
}
return rc;
}
cmTsbRC_t cmTakeSeqBldrTest( cmCtx_t* ctx )
{
const cmChar_t* scoreTrkFn = "/home/kevin/src/cmkc/src/kc/data/takeSeqBldr0.js";
cmTakeSeqBldrH_t tsbH = cmTakeSeqBldrNullHandle;
cmTsbRC_t tsbRC = kOkTsbRC;
unsigned markerIdV[] = { 2200, 2207 };
unsigned markerN = sizeof(markerIdV)/sizeof(markerIdV[0]);
unsigned i;
if((tsbRC = cmTakeSeqBldrAllocFn(ctx, &tsbH, scoreTrkFn )) != kOkTsbRC )
return cmErrMsg(&ctx->err,tsbRC,"TSB Allocate and parse '%s' failed.",scoreTrkFn);
cmRptPrintf(&ctx->rpt, "TakeSeqBldr Allocation Completed.");
for(i=0; i<markerN; ++i)
{
if((tsbRC = cmTakeSeqBldrLoadTake(tsbH,markerIdV[i],false)) != kOkTsbRC )
cmErrMsg(&ctx->err,tsbRC,"TSB load take failed.");
cmRptPrintf(&ctx->rpt, "TakeSeqBldr Load Take %i Completed.",markerIdV[i]);
}
if((tsbRC = cmTakeSeqBldrFree(&tsbH)) != kOkTsbRC )
return cmErrMsg(&ctx->err,tsbRC,"TSB Free failed.");
return tsbRC;
}
Referens i nytt ärende View Git Blame Copy Permalink