#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 "cmTime.h" #include "cmMidi.h" #include "cmLex.h" #include "cmCsv.h" #include "cmSymTbl.h" #include "cmMidiFile.h" #include "cmAudioFile.h" #include "cmTimeLine.h" #include "cmText.h" #include "cmFile.h" #include "cmScore.h" #include "cmVectOpsTemplateMain.h" cmScH_t cmScNullHandle = cmSTATIC_NULL_HANDLE; enum { kLabelCharCnt = 7, kInvalidDynScId = 0, }; enum { kMidiFileIdColScIdx= 0, kEventIdColScIdx = 2, kTypeLabelColScIdx = 3, kDSecsColScIdx = 4, kSecsColScIdx = 5, kD0ColScIdx = 9, kD1ColScIdx = 10, kPitchColScIdx = 11, kBarColScIdx = 13, kSkipColScIdx = 14, kEvenColScIdx = 15, kGraceColScIdx = 16, kTempoColScIdx = 17, kFracColScIdx = 18, kDynColScIdx = 19, kSectionColScIdx = 20, kRecdPlayColScIdx = 21, kRemarkColScIdx = 22 }; typedef struct { unsigned id; unsigned flag; cmChar_t label[ kLabelCharCnt + 1 ]; } cmScEvtRef_t; typedef struct cmScSect_str { const cmChar_t* label; unsigned startIdx; struct cmScSect_str* link; } cmScSect_t; typedef struct cmScSetEle_str { cmChar_t* label; unsigned eleIdx; struct cmScSetEle_str* link; } cmScSetEle_t; typedef struct cmScSet_str { unsigned typeFl; // type of this set cmScSetEle_t* eles; // indexes of set elements cmScSetEle_t* sects; // application section labels bool inFl; // true if currently accepting elements struct cmScSet_str* link; // } cmScSet_t; typedef struct cmScMark_str { cmMarkScMId_t cmdId; unsigned labelSymId; unsigned scoreIdx; unsigned csvRowIdx; struct cmScMark_str* link; } cmScMark_t; typedef struct { cmErr_t err; cmCsvH_t cH; cmSymTblH_t stH; cmScCb_t cbFunc; void* cbArg; cmChar_t* fn; double srate; cmScoreEvt_t* array; unsigned cnt; cmScoreLoc_t* loc; unsigned locCnt; cmScoreSection_t* sect; unsigned sectCnt; unsigned* markLabelArray; // one symId per unique cmScoreMarker_t.labelSymId; unsigned markLabelCnt; unsigned sciPitchLexTId; // sci pitch and section id lexer token id's unsigned sectionLexTId; cmScSect_t* sectList; // lists used during parsing cmScSet_t* setList; cmScMark_t* markList; cmScoreSet_t* sets; unsigned setCnt; unsigned* dynRefArray; unsigned dynRefCnt; unsigned nxtLocIdx; unsigned minSetLocIdx; unsigned maxSetLocIdx; } cmSc_t; cmScEvtRef_t _cmScEvtRefArray[] = { { kTimeSigEvtScId, kTimeSigMdId, "tsg" }, { kKeySigEvtScId, kKeySigMdId, "ksg" }, { kTempoEvtScId, kTempoMdId, "tmp" }, { kTrackEvtScId, kTrkNameMdId, "trk" }, { kTextEvtScId, kTextMdId, "txt" }, { kNameEvtScId, kInstrNameMdId,"nam" }, { kEOTrackEvtScId, kEndOfTrkMdId, "eot" }, { kCopyEvtScId, kCopyMdId, "cpy" }, { kBlankEvtScId, 0, "blk" }, { kBarEvtScId, 0, "bar" }, { kPgmEvtScId, kPgmMdId, "pgm" }, { kCtlEvtScId, kCtlMdId, "ctl" }, { kNonEvtScId, kNoteOnMdId, "non" }, { kInvalidEvtScId, 0, "***" } }; cmScEvtRef_t _cmScDynRefArray[] = { { 1, 0, "pppp" }, { 2, 0, "ppp" }, { 3, 0, "pp" }, { 4, 0, "p" }, { 5, 0, "mp" }, { 6, 0, "mf" }, { 7, 0, "f" }, { 8, 0, "ff" }, { 9,0, "fff" }, { kInvalidDynScId,0, "***" }, }; cmScEvtRef_t _cmScVarRefArray[] = { { kEvenVarScId, kEvenScFl, "e"}, { kDynVarScId, kDynScFl, "d"}, { kTempoVarScId,kTempoScFl,"t"}, { cmInvalidId, 0, "@"} }; cmSc_t* _cmScHandleToPtr( cmScH_t h ) { cmSc_t* p = (cmSc_t*)h.h; assert( p != NULL ); return p; } unsigned _cmScEvtTypeLabelToId( const cmChar_t* label ) { cmScEvtRef_t* r = _cmScEvtRefArray; for(; r->id != kInvalidEvtScId; ++r ) if( strcmp(label,r->label) == 0 ) return r->id; return kInvalidEvtScId; } const cmChar_t* cmScEvtTypeIdToLabel( unsigned id ) { cmScEvtRef_t* r = _cmScEvtRefArray; for(; r->id != kInvalidEvtScId; ++r ) if( r->id == id ) return r->label; return NULL; } const cmChar_t* cmScStatusToOpString( unsigned id ) { if( id == 0 ) return ""; cmScEvtRef_t* r = _cmScEvtRefArray; for(; r->id != kInvalidEvtScId; ++r ) if( r->flag == id ) return r->label; return NULL; } unsigned _cmScDynLabelToId( const cmChar_t* label ) { cmScEvtRef_t* r = _cmScDynRefArray; for(; r->id != kInvalidEvtScId; ++r ) if( strncmp(label,r->label,strlen(r->label)) == 0 ) return r->id; return kInvalidDynScId; } // return the count of dynamic label/id pairs unsigned _cmScDynLabelCount( ) { unsigned n = 0; cmScEvtRef_t* r = _cmScDynRefArray; for(; r->id != kInvalidEvtScId; ++r ) ++n; return n; } const cmChar_t* cmScDynIdToLabel( unsigned id ) { cmScEvtRef_t* r = _cmScDynRefArray; for(; r->id != kInvalidDynScId; ++r ) if( r->id == id ) return r->label; return NULL; } char _cmScVarFlagToChar( unsigned flags ) { unsigned i; for(i=0; _cmScVarRefArray[i].id!=cmInvalidId; ++i) if( _cmScVarRefArray[i].flag == flags ) return _cmScVarRefArray[i].label[0]; assert(0); return ' '; } char _cmScVarIdToChar( unsigned id ) { unsigned i; for(i=0; _cmScVarRefArray[i].id!=cmInvalidId; ++i) if( _cmScVarRefArray[i].id == id ) return _cmScVarRefArray[i].label[0]; assert(0); return ' '; } unsigned _cmScVarFlagToId( unsigned flags ) { unsigned i; for(i=0; _cmScVarRefArray[i].id!=cmInvalidId; ++i) if( _cmScVarRefArray[i].flag == flags ) return _cmScVarRefArray[i].id; assert(0); return cmInvalidId; } const char* _cmScFlagsToStr( unsigned flags, char* buf, int bufCharCnt ) { unsigned i=0; if( cmIsFlag(flags,kEvenScFl) ) { assert(i=cn || isdigit(cp[i]) == false ) return 0; ++i; // i==2 or i==3 // the 3rd or 4th char must be a digit or EOS if( i>=cn || isdigit(cp[i]) == false ) return i; ++i; return i; } unsigned _cmScLexSectionIdMatcher( const cmChar_t* cp, unsigned cn ) { if( cp==NULL || cn < 2 ) return 0; // first char must be a number if( !isdigit(cp[0]) ) return 0; // if 2nd char is a char then terminate if( 'a'<=cp[1] && cp[1]<='z' ) return 2; // if 2nd char is digit and 3rd char is char then terminate if( isdigit(cp[1]) && cn>2 && 'a'<=cp[2] && cp[2]<='z' ) return 3; return 0; } void _cmScFreeMarkList( cmScMark_t* markList ) { cmScMark_t* mp = markList; while( mp!=NULL ) { cmScMark_t* np = mp->link; cmMemFree(mp); mp = np; } } void _cmScFreeSetList( cmScSet_t* setList ) { cmScSet_t* tp = setList; cmScSet_t* ntp = NULL; while(tp!=NULL) { ntp = tp->link; cmScSetEle_t* ep = tp->eles; while( ep != NULL ) { cmScSetEle_t* nep = ep->link; cmMemFree(ep); ep = nep; } ep = tp->sects; while( ep != NULL ) { cmScSetEle_t* nep = ep->link; cmMemFree(ep->label); cmMemFree(ep); ep = nep; } cmMemFree(tp); tp = ntp; } } cmScRC_t _cmScFinalize( cmSc_t* p ) { cmScRC_t rc = kOkScRC; unsigned i; if( cmCsvFinalize(&p->cH) != kOkCsvRC ) return rc; if( p->sets != NULL ) { for(i=0; isetCnt; ++i) { cmMemFree(p->sets[i].eleArray); cmMemFree(p->sets[i].sectArray); cmMemFree(p->sets[i].symArray); cmMemFree(p->sets[i].costSymArray); } cmMemFree(p->sets); } _cmScFreeSetList(p->setList); _cmScFreeMarkList(p->markList); if( p->loc != NULL ) { for(i=0; ilocCnt; ++i) { cmMemFree(p->loc[i].evtArray); if( p->loc[i].begSectPtr != NULL ) cmMemFree(p->loc[i].begSectPtr->setArray); // free the marker list assoc'd with this location cmScoreMarker_t* smp = p->loc[i].markList; while( smp!=NULL ) { cmScoreMarker_t* np = smp->link; cmMemFree(smp); smp = np; } } cmMemFree(p->loc); } cmMemPtrFree(&p->dynRefArray); cmMemFree(p->markLabelArray); cmMemFree(p->sect); cmMemFree(p->fn); cmMemFree(p->array); cmMemFree(p); return rc; } cmScRC_t _cmScParseBar( cmSc_t* p, unsigned rowIdx, cmScoreEvt_t* s, int* barNumb ) { if((*barNumb = cmCsvCellInt(p->cH,rowIdx,kBarColScIdx)) == INT_MAX ) return cmErrMsg(&p->err,kSyntaxErrScRC,"Unable to parse the bar number."); s->type = kBarEvtScId; s->secs = 0; s->barNumb = *barNumb; s->csvRowNumb = rowIdx + 1; return kOkScRC; } cmScSet_t* _cmScNewSet( cmSc_t* p, unsigned typeFl ) { // create a new set record cmScSet_t* nsp = cmMemAllocZ(cmScSet_t,1); nsp->inFl = true; nsp->typeFl = typeFl; if( p->setList == NULL ) p->setList = nsp; else { // go to the end of the the set list cmScSet_t* sp = p->setList; assert(sp!=NULL); while( sp->link != NULL ) sp = sp->link; sp->link = nsp; } return nsp; } cmScSet_t* _cmScFindSet( cmSc_t* p, unsigned typeFl ) { // locate the set currently accepting ele's for this type cmScSet_t* sp = p->setList; for(; sp != NULL; sp=sp->link ) if( sp->typeFl == typeFl && sp->inFl ) break; return sp; } void _cmScSetDone(cmSc_t* p, unsigned typeFl) { cmScSet_t* sp = _cmScFindSet(p,typeFl); assert( sp != NULL ); sp->inFl = false; } // This function is called during parsing to // insert a set element or set section into a cmScSet_t // element or section linked list. Either the scoreIdx // or the label is valid but not both. cmScSet_t* _cmScInsertSetEle(cmSc_t* p, unsigned scoreIdx, unsigned typeFl, const cmChar_t* label, unsigned labelCharCnt) { assert( scoreIdx!=cmInvalidId || (scoreIdx==cmInvalidIdx && label!=NULL && labelCharCnt>0)); cmScSet_t* sp = _cmScFindSet(p,typeFl); if( sp == NULL ) sp = _cmScNewSet(p,typeFl); // allocate a new set element record cmScSetEle_t* nep = cmMemAllocZ(cmScSetEle_t,1); cmScSetEle_t** list = NULL; nep->eleIdx = scoreIdx; if( label == NULL ) { // all elements must be of the same type assert( sp->typeFl == typeFl ); sp->typeFl = typeFl; list = &sp->eles; } else { nep->label = cmMemAllocStrN(label,labelCharCnt); list = &sp->sects; } // *list refers to sp->sects or sp->ele's depending on the type of ele if( *list == NULL ) *list = nep; else { // got to the last element in the set cmScSetEle_t* ep = *list; while( ep->link != NULL ) ep = ep->link; // append the new element to the end of the list ep->link = nep; } return sp; } // Extract the next attribute section identifier. const cmChar_t* _cmScParseOneSetSection( cmSc_t* p, unsigned typeFl, const cmChar_t* c0p ) { // advance white space while( *c0p && (isspace(*c0p) || *c0p==',') ) ++c0p; if( *c0p==0 ) return c0p; // c0p now points to a section id or an asterisk const cmChar_t* c1p = c0p; // advance past section id while( *c1p && (!isspace(*c1p) && (isdigit(*c1p) || isalpha(*c1p)))) ++c1p; // if c0p pointed to an asterisk then c1p is still equal to c0p if( c1p > c0p ) _cmScInsertSetEle(p,cmInvalidIdx,typeFl,c0p,c1p-c0p); return c1p; } // Parse an attribute string to extract the section // identifiers which may follow the attribute token (e,t,mf,ff,...) cmScRC_t _cmScParseAttr(cmSc_t* p, unsigned scoreIdx, const cmChar_t* text, unsigned typeFl) { const cmChar_t* cp = text; // insert a set element - all attribute's produce one element record _cmScInsertSetEle(p,scoreIdx,typeFl,NULL,0); // advance past the attribute type marking (e,t,(p,mf,f,fff,etc)) in search // of section identifiers while( *cp && !isspace(*cp) ) ++cp; if( *cp ) { // search for the first section identifier if((cp =_cmScParseOneSetSection(p,typeFl,cp)) != NULL ) { bool asteriskFl = false; // search for the second section identifier if((cp = _cmScParseOneSetSection(p,typeFl,cp)) != NULL && *cp!=0 ) asteriskFl = *cp == '*'; _cmScSetDone(p,typeFl); // if the attr just parsed ended with an asterisk then it is both // the last element of the previous set and the first ele of the // next set if( asteriskFl ) { // if the attr just parsed had a section id then it was the last // element in the set - create a new set record to hold the next set _cmScNewSet(p,typeFl); _cmScInsertSetEle(p,scoreIdx,typeFl,NULL,0); } } } return kOkScRC; } // Parse a record/playback string cmScRC_t _cmScParseMarkers( cmSc_t* p, unsigned scoreIdx, const cmChar_t* text, unsigned rowIdx ) { const cmChar_t* cp = text; const cmChar_t* ip; const cmChar_t* ep; // if no symbol table has been registered then don't bother storing markers. // (NOTE - THIS IS A HACK BECAUSE THE SCORE OBJECT USED IN THE cmdIf DOES NOT HAVE // A SYMBOL TABLE - WE COULD EASILY ADD ONE IF IT EVENTUALLY NEEDS ACCESS TO THE MARKERS // - OR A SYMBOL TABLE COULD BE ADDED TO THE SCORE ITSELF.) if( cmSymTblIsValid(p->stH) == false ) return kOkScRC; for(;(cp = cmTextNextNonWhiteC(cp)) != NULL; cp=ep ) { // go to command/id space if((ip = cmTextNextWhiteOrEosC(cp)) == NULL ) goto errLabel; // goto label if((ip = cmTextNextNonWhiteC(ip)) == NULL ) goto errLabel; // goto end of label if((ep = cmTextNextWhiteOrEosC(ip)) == NULL ) goto errLabel; else { unsigned n = (ep-ip)+1; cmChar_t markTextStr[n+1]; strncpy(markTextStr,ip,n); markTextStr[n] = 0; // remove any trailing white space cmTextTrimEnd(markTextStr); cmMarkScMId_t cmdId = kInvalidScMId; switch( *cp ) { case 'c': cmdId = kRecdBegScMId; break; case 'e': cmdId = kRecdEndScMId; break; case 'p': cmdId = kPlayBegScMId; break; case 'd': cmdId = kPlayEndScMId; break; case 'f': cmdId = kFadeScMId; break; default: return cmErrMsg(&p->err,kSyntaxErrScRC,"Unrecognized marker command character '%c' at row index %i.",*cp,rowIdx); } cmScMark_t* mp = cmMemAllocZ(cmScMark_t,1); mp->cmdId = cmdId; mp->labelSymId = cmSymTblRegisterSymbol(p->stH,markTextStr); mp->scoreIdx = scoreIdx; mp->csvRowIdx = rowIdx; //printf("%i %c '%s'\n",rowIdx,*cp,markTextStr); // insert the new mark at the end of the list if( p->markList == NULL ) p->markList = mp; else { cmScMark_t* ep = p->markList; while( ep->link != NULL ) ep = ep->link; ep->link = mp; } } } return kOkScRC; errLabel: return cmErrMsg(&p->err,kSyntaxErrScRC,"Invalid record/playback field ('%s') on row index:%i.",cmStringNullGuard(text),rowIdx); } void _cmScPrintSets( const cmChar_t* label, cmScSet_t* setList ) { printf("%s\n",label); const cmScSet_t* sp = setList; for(; sp != NULL; sp=sp->link ) { const cmScSetEle_t* ep = sp->eles; for(; ep!=NULL; ep=ep->link) printf("%i ",ep->eleIdx); printf(" : "); for(ep=sp->sects; ep!=NULL; ep=ep->link) printf("%s ",cmStringNullGuard(ep->label)); printf("\n"); } } cmScRC_t _cmScParseNoteOn( cmSc_t* p, unsigned rowIdx, cmScoreEvt_t* s, unsigned scoreIdx, int barNumb, unsigned barNoteIdx ) { cmScRC_t rc = kOkScRC; unsigned flags = 0; unsigned dynVal = kInvalidDynScId; const cmChar_t* sciPitch; cmMidiByte_t midiPitch; const cmChar_t* attr; double secs; double durSecs; unsigned eventId; const cmCsvCell_t* cell; s += scoreIdx; eventId = cmCsvCellUInt(p->cH,rowIdx,kEventIdColScIdx); // verify the scientific pitch cell was formatted correcly if((cell = cmCsvCellPtr(p->cH,rowIdx,kPitchColScIdx)) == NULL || cell->lexTId != p->sciPitchLexTId ) return cmErrMsg(&p->err,kSyntaxErrScRC,"Pitch column format error."); if((sciPitch = cmCsvCellText(p->cH,rowIdx,kPitchColScIdx)) == NULL ) return cmErrMsg(&p->err,kSyntaxErrScRC,"Expected a scientific pitch value"); if((midiPitch = cmSciPitchToMidi(sciPitch)) == kInvalidMidiPitch) return cmErrMsg(&p->err,kSyntaxErrScRC,"Unable to convert the scientific pitch '%s' to a MIDI value. "); // get the sec's field - or DBL_MAX if it is not set if((secs = cmCsvCellDouble(p->cH, rowIdx, kSecsColScIdx )) == DBL_MAX) // Returns DBL_MAX on error. flags += kInvalidScFl; // skip attribute if((attr = cmCsvCellText(p->cH,rowIdx,kSkipColScIdx)) != NULL && *attr == 's' ) flags += kSkipScFl; // evenness attribute if((attr = cmCsvCellText(p->cH,rowIdx,kEvenColScIdx)) != NULL && *attr == 'e' ) { flags += kEvenScFl; _cmScParseAttr(p,scoreIdx,attr,kEvenScFl); } // grace attribute if((attr = cmCsvCellText(p->cH,rowIdx,kGraceColScIdx)) != NULL && *attr == 'g' ) { flags += kGraceScFl; if( cmIsNotFlag(flags,kEvenScFl) ) return cmErrMsg(&p->err,kSyntaxErrScRC,"All 'grace' notes should also be 'even' notes."); } // tempo attribute if((attr = cmCsvCellText(p->cH,rowIdx,kTempoColScIdx)) != NULL && *attr == 't' ) { flags += kTempoScFl; _cmScParseAttr(p,scoreIdx,attr,kTempoScFl); } // dynamics attribute if((attr = cmCsvCellText(p->cH,rowIdx,kDynColScIdx)) != NULL ) { if((dynVal = _cmScDynLabelToId(attr)) == kInvalidDynScId ) return cmErrMsg(&p->err,kSyntaxErrScRC,"Unknown dynamic label '%s'.",cmStringNullGuard(attr)); flags += kDynScFl; _cmScParseAttr(p,scoreIdx,attr,kDynScFl); } // tempo/non-grace rythmic value if( cmIsFlag(flags,kTempoScFl) || (cmIsFlag(flags,kEvenScFl) && cmIsNotFlag(flags,kGraceScFl)) ) { double frac = cmCsvCellDouble(p->cH,rowIdx,kFracColScIdx); // no 'frac' value is given for the last note of the set we must accept error // values here and validate the actual values later if( frac>0 && frac!=DBL_MAX ) s->frac = frac; } // Returns DBL_MAX on error. if((durSecs = cmCsvCellDouble(p->cH, rowIdx, kDSecsColScIdx )) == DBL_MAX) durSecs = 0.25; // parse the recd/play markers if((attr = cmCsvCellText(p->cH,rowIdx,kRecdPlayColScIdx)) != NULL ) { if((rc = _cmScParseMarkers(p,scoreIdx,attr,rowIdx)) != kOkScRC ) return rc; } s->type = kNonEvtScId; s->secs = secs; s->pitch = midiPitch; s->flags = flags; s->dynVal = dynVal; s->barNumb = barNumb; s->barNoteIdx = barNoteIdx; s->durSecs = durSecs; s->csvRowNumb = rowIdx+1; s->csvEventId = eventId; return rc; } cmScRC_t _cmScParseMidiCtlMsg( cmSc_t* p, unsigned rowIdx, cmScoreEvt_t* s, unsigned scoreIdx, int barNumb, unsigned barNoteIdx, cmScoreEvt_t** pedalV, unsigned pedalN ) { cmScRC_t rc = kOkScRC; unsigned flags = 0; const cmChar_t* attr; double secs = DBL_MAX; double durSecs = 0; const unsigned pedalBaseMidiId = 64; s += scoreIdx; // get the sec's field - or DBL_MAX if it is not set if((secs = cmCsvCellDouble(p->cH, rowIdx, kSecsColScIdx )) == DBL_MAX) // Returns DBL_MAX on error. flags += kInvalidScFl; // skip attribute if((attr = cmCsvCellText(p->cH,rowIdx,kSkipColScIdx)) != NULL && *attr == 's' ) flags += kSkipScFl; // get MIDI ctl msg data byte 1 unsigned d0 = cmCsvCellUInt( p->cH,rowIdx,kD0ColScIdx); // get MIDI ctl msg data byte 2 unsigned d1 = cmCsvCellUInt( p->cH,rowIdx,kD1ColScIdx); // if this is a pedal event if( pedalBaseMidiId <= d0 && d0 < pedalBaseMidiId + pedalN ) { bool pedalDnFl = d1 >= 64; unsigned pedalIdx = d0 - pedalBaseMidiId; // if this is a pedal-down message ... if( pedalDnFl ) { flags += kPedalDnScFl; if( pedalV[pedalIdx] != NULL ) cmErrWarnMsg(&p->err,kPedalInvalidScRC,"The score contains multiple pedal down messages withouth an intervening pedal up message in or near bar %i.",barNumb ); else { // Don't store a pointer to a skipped pedal down msg because it will not // not exist in p->array[] when the associated 'pedal-up' message is // encountered. Note the the 'postProcFl' controlled section of // _cmScParseFile() effectively eliminates cmScoreEvt_t records from // p->array[] that are marked with kSkipScFl. if( cmIsFlag(flags,kSkipScFl) ) cmErrWarnMsg(&p->err,kPedalInvalidScRC,"A 'pedal-down' msg is marked to skip in or near bar %i this will probably produce a 'missing pedal-down' warning.",barNumb ); else pedalV[pedalIdx] = s; // ... store a pointer to the scEvt recd in pedalV[] } } else // ... else this is a pedal-up msg ... { flags += kPedalUpScFl; if( pedalV[pedalIdx] == NULL ) cmErrWarnMsg(&p->err,kPedalInvalidScRC,"The score contains multiple pedal up messages withouth an intervening pedal down message in or near bar %i.",barNumb ); else // ... update the pedal down duration in the pedal-down message assoc'd w/ this pedal-up msg. { if( secs == DBL_MAX ) cmErrWarnMsg(&p->err,kPedalInvalidScRC,"A pedal-up message was encountered with an invalid time-stamp in or near bar %i the pedal down duration could therefore not be calculated.",barNumb); else { // update the pedal down event record with the pedal down duration pedalV[pedalIdx]->durSecs = secs - pedalV[pedalIdx]->secs; } pedalV[pedalIdx] = NULL; } } } s->type = kPedalEvtScId; s->secs = secs; s->pitch = d0; // store the pedal type identifer in the pitch field s->flags = flags; s->dynVal = 0; s->barNumb = barNumb; s->barNoteIdx = barNoteIdx; s->durSecs = durSecs; s->csvRowNumb = rowIdx+1; return rc; } cmScRC_t _cmScParseSectionColumn( cmSc_t* p, unsigned rowIdx, unsigned evtIdx, cmScSect_t* sectList ) { const cmCsvCell_t* cell; cmScSect_t* sect; const cmChar_t* label; // most rows don't have section labels if( (cell = cmCsvCellPtr( p->cH,rowIdx,kSectionColScIdx)) == NULL || (label = cmCsvCellText(p->cH,rowIdx,kSectionColScIdx)) == NULL) return kOkScRC; // verify the section id type if( cell->lexTId != p->sectionLexTId && cell->lexTId != kIntLexTId ) return cmErrMsg(&p->err,kSyntaxErrScRC,"'section' column format error."); sect = cmMemAllocZ(cmScSect_t,1); sect->label = label; sect->startIdx = evtIdx; //printf("section:%s\n",label); cmScSect_t* sp = sectList; assert( sp != NULL ); while( sp->link != NULL ) sp = sp->link; sp->link = sect; return kOkScRC; } cmScoreSection_t* _cmScLabelToSection( cmSc_t* p, const cmChar_t* label ) { int i; for(i=0; isectCnt; ++i) if( strcmp(p->sect[i].label,label) == 0 ) return p->sect + i; return NULL; } // Calculate the total number of all types of sets and // then convert each of the cmScSet_t linked list's to // a single linear cmScoreSet_t list (p->sets[]). cmScRC_t _cmScProcSets( cmSc_t* p ) { cmScRC_t rc = kOkScRC; // calculate the count of all sets unsigned i; unsigned n = 0; cmScSet_t* sp = p->setList; for(n=0; sp!=NULL; sp=sp->link) if( sp->eles != NULL ) ++n; // allocate the linear set array p->sets = cmMemAllocZ(cmScoreSet_t,n); p->setCnt = n; // fill in the linear set array sp = p->setList; for(i=0; sp!=NULL; sp=sp->link) if( sp->eles != NULL ) { unsigned j; unsigned en; unsigned rowNumb = 0; assert( ieles; for(en=0; ep!=NULL; ep=ep->link) ++en; assert( en > 0 ); // allocate the element array p->sets[i].eleCnt = en; p->sets[i].eleArray = cmMemAllocZ(cmScoreEvt_t*,en); // fill in the element array ep = sp->eles; unsigned graceCnt = 0; for(j=0; ep!=NULL; ep=ep->link,++j) { assert(ep->eleIdx != cmInvalidIdx && ep->eleIdxcnt); p->sets[i].eleArray[j] = p->array + ep->eleIdx; assert( cmIsFlag( p->sets[i].eleArray[j]->flags, sp->typeFl) ); rowNumb = p->array[ep->eleIdx].csvRowNumb; unsigned flags = p->array[ep->eleIdx].flags; // count grace notes if( cmIsFlag(flags,kGraceScFl) ) ++graceCnt; // validate the 'frac' field - all but the last note in // tempo and non-grace evenness sets must have a non-zero 'frac' value. if( en>0 && jtypeFl==kTempoScFl || (sp->typeFl==kEvenScFl && graceCnt==0)) && p->array[ep->eleIdx].frac==0) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The note on row number %i must have a non-zero 'frac' value.",p->array[ep->eleIdx].csvRowNumb); } // get the count of sections assoc'd with this set ep = sp->sects; for(en=0; ep!=NULL; ep=ep->link) ++en; // allocate the section array p->sets[i].varId = _cmScVarFlagToId(sp->typeFl); p->sets[i].sectCnt = en; p->sets[i].sectArray = cmMemAllocZ(cmScoreSection_t*,en); p->sets[i].symArray = cmMemAllocZ(unsigned,en); p->sets[i].costSymArray = cmMemAllocZ(unsigned,en); // fill in the section array with sections which this set will be applied to ep = sp->sects; for(j=0; ep!=NULL; ep=ep->link,++j) { cmScoreSection_t* sp; assert(ep->label != NULL); if((sp = _cmScLabelToSection(p, ep->label )) == NULL ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The section labelled '%s' could not be found for the set which includes row number %i.",ep->label,rowNumb); else { if( cmSymTblIsValid(p->stH) ) { // THIS PRINTF PREVENTS CRASH ON OSX ??????? //printf("PROCSET:%i %c %s\n",p->sets[i].varId,_cmScVarIdToChar(p->sets[i].varId),ep->label); char cc = _cmScVarIdToChar(p->sets[i].varId); int nn = snprintf(NULL,0,"%c-%s",cc,ep->label); char b[nn+2]; snprintf(b,nn,"%c-%s",cc,ep->label); p->sets[i].symArray[j] = cmSymTblRegisterSymbol(p->stH,b); snprintf(b,nn+1,"c%c-%s",cc,ep->label); p->sets[i].costSymArray[j] = cmSymTblRegisterSymbol(p->stH,b); //p->sets[i].symArray[j] = cmSymTblRegisterFmt(p->stH,"%c-%s", cc,ep->label); //p->sets[i].costSymArray[j] = cmSymTblRegisterFmt(p->stH,"c%c-%s",cc,ep->label); } else { p->sets[i].symArray[j] = cmInvalidId; p->sets[i].costSymArray[j] = cmInvalidId; } p->sets[i].sectArray[j] = sp; sp->setArray = cmMemResizeP(cmScoreSet_t*,sp->setArray,++sp->setCnt); sp->setArray[sp->setCnt-1] = p->sets + i; } } ++i; } assert(i==n); // assign each set to the location which contains it's last element. // (this is earliest point in the score location where all the // performance information contained in the set may be valid) for(i=0; isetCnt; ++i) { assert( p->sets[i].eleCnt >= 1 ); // get a ptr to the last element for the ith set const cmScoreEvt_t* ep = p->sets[i].eleArray[ p->sets[i].eleCnt-1 ]; unsigned j,k; // find the location which contains the last element for(j=0; jlocCnt; ++j) { for(k=0; kloc[j].evtCnt; ++k) if( p->loc[j].evtArray[k] == ep ) break; if(kloc[j].evtCnt) break; } assert( jlocCnt ); // assign the ith set to the location which contains it's last element p->sets[i].llink = p->loc[j].setList; p->loc[j].setList = p->sets + i; } return rc; } cmScRC_t _cmScProcSections( cmSc_t* p, cmScSect_t* sectList ) { cmScRC_t rc = kOkScRC; unsigned i; // count the sections cmScSect_t* sp = sectList; p->sectCnt = 0; for(; sp!=NULL; sp=sp->link) if( sp->label != NULL ) ++p->sectCnt; // alloc a section array p->sect = cmMemAllocZ(cmScoreSection_t,p->sectCnt); // fill the section array sp = sectList; for(i=0; sp!=NULL; sp=sp->link) if( sp->label != NULL ) { p->sect[i].label = sp->label; p->sect[i].index = i; p->sect[i].begEvtIndex = sp->startIdx; ++i; } // assign the begSectPtr to each section for(i=0; isectCnt; ++i) { assert( p->sect[i].begEvtIndex < p->cnt ); unsigned j,k; const cmScoreEvt_t* ep = p->array + p->sect[i].begEvtIndex; for(j=0; jlocCnt; ++j) { for(k=0; kloc[j].evtCnt; ++k) if( p->loc[j].evtArray[k] == ep ) { p->loc[j].begSectPtr = p->sect + i; p->sect[i].locPtr = p->loc + j; break; } if( kloc[j].evtCnt) break; } } // release the section linked list sp = sectList; cmScSect_t* np = NULL; while(sp!=NULL) { np = sp->link; cmMemFree(sp); sp = np; } //_cmScPrintSets("Sets",p->setList ); _cmScProcSets(p); return rc; } const cmScoreLoc_t* _cmScFindMarkLoc( cmSc_t* p, cmMarkScMId_t cmdId, unsigned labelSymId, const cmScoreMarker_t** markRef ) { unsigned i; for(i=0; ilocCnt; ++i) { cmScoreMarker_t* smp = p->loc[i].markList; for(; smp!=NULL; smp=smp->link) { if( smp->markTypeId==cmdId && smp->labelSymId==labelSymId ) return p->loc + i; if( markRef != NULL ) *markRef = smp; } } return NULL; } unsigned _cmScMarkerLabelIndex( cmSc_t* p, unsigned labelSymId ) { unsigned i; for(i=0; imarkLabelCnt; ++i) if( p->markLabelArray[i] == labelSymId ) return i; return cmInvalidIdx; } // Verify that the record/play begin/end and fade markers fall in the correct time order. // (e.g. 'begin' must be before 'end' and 'fade' must be between and 'begin' and 'end'). cmScRC_t _cmScValidateMarkers( cmSc_t* p ) { cmScRC_t rc = kOkScRC; unsigned i; for(i=0; ilocCnt; ++i) { cmScoreMarker_t* sm0p = p->loc[i].markList; for(; sm0p!=NULL; sm0p=sm0p->link) { const cmScoreLoc_t* sl0p; const cmScoreLoc_t* sl1p; switch( sm0p->markTypeId ) { case kRecdBegScMId: if((sl0p = _cmScFindMarkLoc(p,kRecdEndScMId, sm0p->labelSymId, NULL )) == NULL ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'record begin' marker at CSV row index %i does not have an associated 'record end' marker.",sm0p->csvRowIdx); else if( sl0p->index <= p->loc[i].index ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'record end' marker comes before associated with the 'record begin' marker at CSV row index %i.",sm0p->csvRowIdx); break; case kRecdEndScMId: if((sl0p = _cmScFindMarkLoc(p,kRecdBegScMId, sm0p->labelSymId, NULL )) == NULL ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'record end' marker at CSV row index %i does not have an associated 'record begin' marker.",sm0p->csvRowIdx); else if( sl0p->index > p->loc[i].index ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'record begin' marker comes after the associated with the 'record end' marker at CSV row index %i.",sm0p->csvRowIdx); break; case kFadeScMId: if((sl0p = _cmScFindMarkLoc(p,kPlayBegScMId, sm0p->labelSymId, NULL )) == NULL ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'fade' marker at CSV row index %i does not have an associated 'play begin' marker.",sm0p->csvRowIdx); else if((sl1p = _cmScFindMarkLoc(p,kPlayEndScMId, sm0p->labelSymId, NULL )) == NULL ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'fade' marker at CSV row index %i does not have an associated 'play end' marker.",sm0p->csvRowIdx); else if( sl0p->index > p->loc[i].index || sl1p->index < p->loc[i].index ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'fade' marker at CSV row index %i is not between it's associated 'play begin' and 'play end' markers.",sm0p->csvRowIdx); break; case kPlayBegScMId: if((sl0p = _cmScFindMarkLoc(p,kPlayEndScMId, sm0p->labelSymId, NULL )) == NULL ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'play begin' marker at CSV row index %i does not have an associated 'play end' marker.",sm0p->csvRowIdx); else if( sl0p->index <= p->loc[i].index ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'play end' marker comes before associated with the 'play begin' marker at CSV row index %i.",sm0p->csvRowIdx); break; case kPlayEndScMId: if((sl0p = _cmScFindMarkLoc(p,kPlayBegScMId, sm0p->labelSymId, NULL )) == NULL ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'play end' marker at CSV row index %i does not have an associated 'play begin' marker.",sm0p->csvRowIdx); else if( sl0p->index > p->loc[i].index ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The 'play begin' marker comes after the associated with the 'play end' marker at CSV row index %i.",sm0p->csvRowIdx); break; default: break; } } } return rc; } cmScRC_t _cmScProcMarkers( cmSc_t* p ) { // for each marker in the p->markList // (p->markList is created by _cmScParseMarkers() during CSV file parsing.) cmScMark_t* mp = p->markList; for(; mp!=NULL; mp=mp->link) { assert( mp->scoreIdx < p->cnt ); // get the score location assoc'd with this marker unsigned locIdx = p->array[ mp->scoreIdx ].locIdx; assert( locIdx < p->locCnt ); cmScoreLoc_t* slp = p->loc + locIdx; // create a cmScoreMarker record. cmScoreMarker_t* smp = cmMemAllocZ(cmScoreMarker_t,1); smp->markTypeId = mp->cmdId; smp->labelSymId = mp->labelSymId; smp->csvRowIdx = mp->csvRowIdx; smp->scoreLocPtr = slp; // attach the new scoreMarker record to the assoc'd score loc. recd if( slp->markList == NULL ) slp->markList = smp; else { cmScoreMarker_t* sm0p = slp->markList; while( sm0p->link != NULL ) sm0p = sm0p->link; sm0p->link = smp; } // if the id represented by this marker if( _cmScMarkerLabelIndex(p,smp->labelSymId) == cmInvalidIdx ) { p->markLabelArray = cmMemResizeP(unsigned,p->markLabelArray,p->markLabelCnt+1); p->markLabelArray[p->markLabelCnt] = smp->labelSymId; p->markLabelCnt += 1; } } // validate the markers return _cmScValidateMarkers(p); } cmScRC_t _cmScParseFile( cmSc_t* p, cmCtx_t* ctx, const cmChar_t* fn ) { cmScRC_t rc = kOkScRC; unsigned barNoteIdx = 0; int barEvtIdx = cmInvalidIdx; int barNumb = 0; double secs; double cur_secs = 0; const unsigned pedalN = 3; cmScoreEvt_t* pedalV[] = { NULL,NULL,NULL }; p->sectList = cmMemAllocZ(cmScSect_t,1); // section zero //_cmScNewSet(p); // preallocate the first set // initialize the CSV file parser if( cmCsvInitialize(&p->cH, ctx ) != kOkCsvRC ) { rc = cmErrMsg(&p->err,kCsvFailScRC,"Score file initialization failed."); goto errLabel; } // register custom lex token matchers for sci-pitch and section id's if( cmCsvLexRegisterMatcher(p->cH, p->sciPitchLexTId = cmCsvLexNextAvailId(p->cH)+0, _cmScLexSciPitchMatcher ) != kOkCsvRC ||cmCsvLexRegisterMatcher(p->cH, p->sectionLexTId = cmCsvLexNextAvailId(p->cH)+1, _cmScLexSectionIdMatcher) != kOkCsvRC ) { rc = cmErrMsg(&p->err,kCsvFailScRC,"CSV token matcher registration failed."); goto errLabel; } // parse the CSV file if( cmCsvParseFile(p->cH, fn, 0 ) != kOkCsvRC ) { rc = cmErrMsg(&p->err,kCsvFailScRC,"CSV file parsing failed on the file '%s'.",cmStringNullGuard(fn)); goto errLabel; } // allocate the score event array p->cnt = cmCsvRowCount(p->cH); p->array = cmMemAllocZ(cmScoreEvt_t,p->cnt); unsigned i,j; // skip labels line - start on line 1 for(i=1,j=0; icnt && rc==kOkScRC; ++i) { bool postProcFl = false; // get the row 'type' label const char* typeLabel; if((typeLabel = cmCsvCellText(p->cH,i,kTypeLabelColScIdx)) == NULL ) { rc = cmErrMsg(&p->err,kSyntaxErrScRC,"No type label."); break; } // convert the row 'type' label to an id unsigned tid; if((tid = _cmScEvtTypeLabelToId(typeLabel)) == kInvalidEvtScId) { rc = cmErrMsg(&p->err,kSyntaxErrScRC,"Unknown type '%s'.",cmStringNullGuard(typeLabel)); break; } // set the score file line number p->array[j].line = i + 1; secs = DBL_MAX; switch(tid) { case kBarEvtScId: // parse bar lines if((rc = _cmScParseBar(p,i,p->array+j,&barNumb)) == kOkScRC ) { barNoteIdx = 0; barEvtIdx = j; p->array[j].index = j; ++j; } break; case kNonEvtScId: // parse note-on events if((rc = _cmScParseNoteOn(p, i, p->array, j, barNumb, barNoteIdx )) == kOkScRC ) { postProcFl = true; ++barNoteIdx; } break; case kCtlEvtScId: if((rc = _cmScParseMidiCtlMsg(p, i, p->array, j, barNumb, barNoteIdx, pedalV, pedalN )) == kOkScRC ) { postProcFl = true; } break; default: // Returns DBL_MAX on error. secs = cmCsvCellDouble(p->cH, i, kSecsColScIdx ); break; } if( postProcFl ) { // update the 'secs' according to the parsed time secs = p->array[j].secs; // it is possible that the parsed time field was blank ... if( p->array[j].secs == DBL_MAX ) { // ... so set the msg time to the last valid time p->array[j].secs = cur_secs; // note that 'secs' is now set to DBL_MAX so cur_secs will // not be updated on this row iteration } // if this msg was marked to skip then don't advance j (and thereby // write over this scEvt with the next note). ... if( cmIsFlag(p->array[j].flags,kSkipScFl) == false ) { p->array[j].index = j; // ... otherwise advance j ++j; } } if( rc == kOkScRC ) { // if sec's is valid then update cur_secs if( secs != DBL_MAX ) cur_secs = secs; // form the section list if( j > 0 ) if((rc = _cmScParseSectionColumn(p,i,j-1,p->sectList)) != kOkScRC ) break; // the bar lines don't have times so set the time of the bar line to the // time of the first event in the bar. if( barEvtIdx != cmInvalidIdx && secs != DBL_MAX ) { assert( p->array[ barEvtIdx ].type == kBarEvtScId ); p->array[ barEvtIdx ].secs = secs; // handle the case where the previous bar had no events // BUG BUG BUG this is a hack which will fail if the first bar does not have events. if( barEvtIdx>=1 && p->array[ barEvtIdx-1].type == kBarEvtScId ) p->array[ barEvtIdx-1].secs = secs; barEvtIdx = cmInvalidIdx; } } } if( rc == kSyntaxErrScRC ) { cmErrMsg(&p->err,rc,"Syntax error on line %i in '%s'.",i+1,cmStringNullGuard(fn)); goto errLabel; } p->cnt = j; errLabel: return rc; } cmScRC_t _cmScInitLocArray( cmSc_t* p ) { cmScRC_t rc = kOkScRC; double maxDSecs = 0; // max time between events that are considered simultaneous unsigned barNumb = 0; int i,j,k; if( p->cnt==0) return rc; p->locCnt = 1; // count the number of unique time locations in the score p->locCnt = 1; for(i=1; icnt; ++i ) { if( p->array[i].secs < p->array[i-1].secs ) rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The time associated with the score entry on line %i is less than the previous line.",p->array[i].csvRowNumb); if( (p->array[i].secs - p->array[i-1].secs) > maxDSecs ) ++p->locCnt; } if( rc != kOkScRC ) return rc; // allocate the loc. array p->loc = cmMemAllocZ(cmScoreLoc_t,p->locCnt); // fill in the location array for(i=0,k=0; icnt; ++k) { j = i+1; // get the count of events at this location while( jcnt && p->array[j].secs - p->array[j-1].secs <= maxDSecs ) ++j; assert(klocCnt); p->loc[k].index = k; p->loc[k].evtCnt = j-i; p->loc[k].evtArray = cmMemAllocZ(cmScoreEvt_t*,p->loc[k].evtCnt); // fill in the location record event pointers for(j=0; jloc[k].evtCnt; ++j) { p->loc[k].evtArray[j] = p->array + (i + j); p->loc[k].evtArray[j]->locIdx = k; if( p->array[i+j].type == kBarEvtScId ) barNumb = p->array[i+j].barNumb; } // fill in the location record p->loc[k].secs = p->array[i].secs; p->loc[k].barNumb = barNumb; i += p->loc[k].evtCnt; } assert( p->locCnt == k ); return rc; } cmScRC_t cmScoreInitialize( cmCtx_t* ctx, cmScH_t* hp, const cmChar_t* fn, double srate, const unsigned* dynRefArray, unsigned dynRefCnt, cmScCb_t cbFunc, void* cbArg, cmSymTblH_t stH ) { cmScRC_t rc = kOkScRC; if((rc = cmScoreFinalize(hp)) != kOkScRC ) return rc; cmSc_t* p = cmMemAllocZ(cmSc_t,1); cmErrSetup(&p->err,&ctx->rpt,"Score"); p->stH = stH; if((rc = _cmScParseFile(p,ctx,fn)) != kOkScRC ) goto errLabel; if((rc = _cmScInitLocArray(p)) != kOkScRC ) goto errLabel; if((rc = _cmScProcSections(p,p->sectList)) != kOkScRC ) goto errLabel; if((rc = _cmScProcMarkers(p)) != kOkScRC ) goto errLabel; // load the dynamic reference array if( dynRefArray != NULL && dynRefCnt > 0) { unsigned n = _cmScDynLabelCount(); if( dynRefCnt != n ) { rc = cmErrMsg(&p->err,kInvalidDynRefCntScRC,"The count of dynamics labels must be %i not %i.",n,dynRefCnt); goto errLabel; } p->dynRefArray = cmMemAllocZ(unsigned,dynRefCnt); memcpy(p->dynRefArray,dynRefArray,sizeof(unsigned)*dynRefCnt); p->dynRefCnt = dynRefCnt; } p->srate = srate; p->cbFunc = cbFunc; p->cbArg = cbArg; p->fn = cmMemAllocStr(fn); p->nxtLocIdx = 0; p->minSetLocIdx = cmInvalidIdx; p->maxSetLocIdx = cmInvalidIdx; hp->h = p; cmScoreClearPerfInfo(*hp); //cmScorePrintLoc(*hp); errLabel: if( rc != kOkScRC ) _cmScFinalize(p); return rc; } cmScRC_t cmScoreFinalize( cmScH_t* hp ) { cmScRC_t rc = kOkScRC; if( hp == NULL || cmScoreIsValid(*hp) == false ) return kOkScRC; cmSc_t* p = _cmScHandleToPtr(*hp); if((rc = _cmScFinalize(p)) != kOkScRC ) return rc; hp->h = NULL; return rc; } const cmChar_t* cmScoreFileName( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); return p->fn; } double cmScoreSampleRate( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); return p->srate; } bool cmScoreIsValid( cmScH_t h ) { return h.h != NULL; } unsigned cmScoreEvtCount( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); return p->cnt; } cmScoreEvt_t* cmScoreEvt( cmScH_t h, unsigned idx ) { cmSc_t* p = _cmScHandleToPtr(h); if( idx >= p->cnt ) { cmErrMsg(&p->err,kInvalidIdxScRC,"%i is an invalid index for %i records.",idx,p->cnt); return NULL; } return p->array + idx; } cmScoreEvt_t* cmScoreBarEvt( cmScH_t h, unsigned barNumb ) { cmSc_t* p = _cmScHandleToPtr(h); unsigned i = 0; for(; icnt; ++i) if( p->array[i].type==kBarEvtScId && p->array[i].barNumb==barNumb ) return p->array + i; return NULL; } unsigned cmScoreSectionCount( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); return p->sectCnt; } cmScoreSection_t* cmScoreSection( cmScH_t h, unsigned idx ) { cmSc_t* p = _cmScHandleToPtr(h); assert( idx < p->sectCnt); return p->sect + idx; } unsigned cmScoreLocCount( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); return p->locCnt; } cmScoreLoc_t* cmScoreLoc( cmScH_t h, unsigned idx ) { cmSc_t* p = _cmScHandleToPtr(h); if( idx >= p->locCnt ) { cmErrMsg(&p->err,kInvalidIdxScRC,"%i is an invalid index for %i location records.",idx,p->locCnt); return NULL; } return p->loc + idx; } cmScoreLoc_t* cmScoreEvtLoc( cmScH_t h, const cmScoreEvt_t* evt ) { cmSc_t* p = _cmScHandleToPtr(h); unsigned i; if( evt != NULL ) for(i=0; ilocCnt; ++i) { unsigned j; for(j=0; jloc[i].evtCnt; ++j) if( p->loc[i].evtArray[j] == evt ) return p->loc + i; } return NULL; } void cmScorePrintLoc( cmScH_t h ) { unsigned i = 0; cmSc_t* p = _cmScHandleToPtr(h); unsigned colCnt = 10; int bufCharCnt = 4; char buf[ bufCharCnt ]; const char* emptyStr = " "; // for each set of 'colCnt' columns for(i=0; ilocCnt; i+=colCnt ) { // print the location 'index' line unsigned c,j,k; printf("index: "); for(c=0,j=i; jlocCnt && clocCnt && cloc[j].begSectPtr==NULL ) printf("%s",emptyStr); else printf("%7s ",p->loc[j].begSectPtr->label); printf("\n"); // calculate the max number of simultan. events at any one location // for this set of 'colCnt' columns. unsigned n=0; for(c=0,j=i; jlocCnt && cloc[j].evtCnt > n ) n = p->loc[j].evtCnt; // for each 'sco' line for(k=0; klocCnt && c= p->loc[j].evtCnt ) printf("%s",emptyStr); else { switch(p->loc[j].evtArray[k]->type) { case kBarEvtScId: printf(" |%3i ",p->loc[j].evtArray[k]->barNumb); break; case kNonEvtScId: { int bn=16; char b[bn]; strcpy(b,cmMidiToSciPitch(p->loc[j].evtArray[k]->pitch,NULL,0)); strcat(b,_cmScFlagsToStr( p->loc[j].evtArray[k]->flags,buf,bufCharCnt)); assert(strlen(b)locCnt && cloc[j].begSectPtr != NULL && p->loc[j].begSectPtr->setCnt > n ) n = p->loc[j].begSectPtr->setCnt; for(k=0; klocCnt && cloc[j].begSectPtr != NULL && kloc[j].begSectPtr->setCnt ) { const cmScoreSet_t* sp = p->loc[j].begSectPtr->setArray[k]; printf(" %3s-%c ",p->loc[j].begSectPtr->label,_cmScVarIdToChar(sp->varId) ); } else { printf("%s",emptyStr); } } printf("\n"); } printf("\n"); } } unsigned cmScoreSetCount( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); return p->setCnt; } unsigned cmScoreMarkerLabelCount( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); return p->markLabelCnt; } unsigned cmScoreMarkerLabelSymbolId( cmScH_t h, unsigned idx ) { cmSc_t* p = _cmScHandleToPtr(h); assert( idx < p->markLabelCnt ); return p->markLabelArray[idx]; } const cmScoreMarker_t* cmScoreMarker( cmScH_t h, cmMarkScMId_t markMId, unsigned labelSymId ) { cmSc_t* p = _cmScHandleToPtr(h); const cmScoreMarker_t* smp = NULL; if( _cmScFindMarkLoc(p, markMId, labelSymId, &smp ) == NULL ) return NULL; return smp; } cmScRC_t cmScoreSeqNotify( cmScH_t h ) { cmScRC_t rc = kOkScRC; cmSc_t* p = _cmScHandleToPtr(h); cmScMsg_t m; unsigned i; if( p->cbFunc != NULL ) { memset(&m.u.evt,0,sizeof(m.u.evt)); m.typeId = kBeginMsgScId; p->cbFunc(p->cbArg,&m,sizeof(m)); m.typeId = kEventMsgScId; for(i=0; icnt; ++i) { m.u.evt = p->array[i]; p->cbFunc(p->cbArg,&m,sizeof(m)); } m.typeId = kSectionMsgScId; for(i=0; isectCnt; ++i) { m.u.sect = p->sect[i]; p->cbFunc(p->cbArg,&m,sizeof(m)); } memset(&m.u.evt,0,sizeof(m.u.evt)); m.typeId = kEndMsgScId; p->cbFunc(p->cbArg,&m,sizeof(m)); } return rc; } cmScRC_t cmScoreSeqNotifyCb( cmScH_t h, cmScCb_t cbFunc, void* cbArg ) { cmSc_t* p = _cmScHandleToPtr(h); cmScRC_t rc = kOkScRC; cmScCb_t cbf = p->cbFunc; void* cba = p->cbArg; p->cbFunc = cbFunc; p->cbArg = cbArg; rc = cmScoreSeqNotify(h); p->cbFunc = cbf; p->cbArg = cba; return rc; } void cmScoreClearPerfInfo( cmScH_t h ) { cmSc_t* p = _cmScHandleToPtr(h); unsigned i; for(i=0; icnt; ++i) { p->array[i].perfSmpIdx = cmInvalidIdx; p->array[i].perfVel = 0; p->array[i].perfDynLvl = 0; } for(i=0; ilocCnt; ++i) { cmScoreSet_t* sp = p->loc[i].setList; for(; sp!=NULL; sp=sp->llink) sp->doneFl = false; } for(i=0; isectCnt; ++i) { unsigned j; for(j=0; jsect[i].vars[j] = DBL_MAX; } p->nxtLocIdx = 0; p->minSetLocIdx = cmInvalidIdx; p->maxSetLocIdx = cmInvalidIdx; } bool _cmScIsSetPerfDone( cmScoreSet_t* sp ) { unsigned i = 0; for(i=0; ieleCnt; ++i) if( sp->eleArray[i]->perfSmpIdx == cmInvalidIdx ) return false; return true; } void _cmScPerfSortTimes( unsigned *v, unsigned n ) { unsigned i; bool fl = true; while(fl && n) { fl = false; for(i=1; i v[i] ) { unsigned t = v[i-1]; v[i-1] = v[i]; v[i] = t; fl = true; } } --n; } } bool _cmScPerfEven(cmSc_t* p, cmScoreSet_t* stp, bool printMissFl) { unsigned i = 0; double u = 0; double x = 0; bool sortFl = false; bool printFl = true; unsigned v[ stp->eleCnt ]; unsigned d[ stp->eleCnt - 1]; assert( stp->eleCnt > 1 ); // calculate the sum of the time between events for(i=0; ieleCnt; ++i) { // if this event was not received - then the set is not valid if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx ) { if( printFl && printMissFl) printf("EVENESS: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0)); return false; } // load v[i] v[i] = stp->eleArray[i]->perfSmpIdx; // check for out of order elements if( i> 0 ) if( v[i] < v[i-1] ) sortFl = true; } // sort the times in ascending order if( sortFl ) _cmScPerfSortTimes(v,stp->eleCnt); // calc the sum of time differences for(i=1; ieleCnt; ++i) u += d[i-1] = v[i] - v[i-1]; // calculate the average time between events u /= stp->eleCnt-1; // calculate the std-dev of the time between events for(i=0; ieleCnt-1; ++i) x += (d[i]-u)*(d[i]-u); double sd = sqrt(x/(stp->eleCnt-1)); // compute the average z-score double c = 0; for(i=0; ieleCnt-1; ++i) c += fabs(d[i]-u)/sd; stp->value = c/(stp->eleCnt-1); stp->doneFl = true; if(printFl) { /* for(i=0; ieleCnt; ++i) { printf("%i %i ",i,v[i]); if( i > 0 ) printf("%i ", d[i-1]); printf("\n"); } */ printf("%s EVENESS:%f\n",sortFl?"SORTED ":"",stp->value); } return true; } bool _cmScPerfDyn( cmSc_t* p, cmScoreSet_t* stp, bool printMissFl) { double a = 0; unsigned i = 0; bool printFl = true; for(i=0; ieleCnt; ++i) { unsigned j; // if this event was not received - then the set is not valid if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx ) { if( printFl && printMissFl ) printf("DYNAMICS: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0)); return false; } unsigned m = 0; // lower bound for the first dyn. category // determine the dynamic category for the performed velocity of each event for(j=0; jdynRefCnt; ++j) { // if the vel fall's into the jth dyn. category if( m <= stp->eleArray[i]->perfVel && stp->eleArray[i]->perfVel < p->dynRefArray[j] ) break; // store the min vel for the next dyn category m = p->dynRefArray[j]; } assert( j < p->dynRefCnt ); stp->eleArray[i]->perfDynLvl = j+1; a += abs((j+1) - stp->eleArray[i]->dynVal); if( p->cbFunc != NULL ) { cmScMsg_t m; m.typeId = kDynMsgScId; m.u.dyn.evtIdx = stp->eleArray[i]->index; m.u.dyn.dynLvl = stp->eleArray[i]->perfDynLvl; p->cbFunc(p->cbArg,&m,sizeof(m)); } } stp->value = a / stp->eleCnt; stp->doneFl = true; if( printFl ) printf("DYNAMICS:%f\n",stp->value); return true; } bool _cmScPerfTempo1(cmSc_t* p, cmScoreSet_t* stp, bool printMissFl) { bool printFl = true; unsigned durSmpCnt = 0; double durBeats = 0; int i; for(i=0; ieleCnt; ++i) { // if this event was not received - then the set is not valid if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx ) { if( printFl && printMissFl ) printf("TEMPO: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0)); return false; } if( i > 0 ) durSmpCnt += stp->eleArray[i]->perfSmpIdx - stp->eleArray[i-1]->perfSmpIdx; durBeats += stp->eleArray[i]->frac; } stp->value = durBeats / (durSmpCnt / p->srate*60.0 ); stp->doneFl = true; if( printFl ) printf("TEMPO:%f\n",stp->value); return true; } bool _cmScPerfTempo(cmSc_t* p, cmScoreSet_t* stp, bool printMissFl) { bool printFl = true; unsigned durSmpCnt = 0; double durBeats = 0; int i; unsigned bi = cmInvalidIdx; unsigned ei = cmInvalidIdx; unsigned missCnt = 0; for(i=0; ieleCnt; ++i) { // if this event was not received - then the set is not valid if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx ) { ++missCnt; if( printFl && printMissFl ) printf("TEMPO: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0)); } else { if( bi == cmInvalidIdx ) bi = i; ei = i; } } if( ei > bi ) { for(i=bi; i<=ei; ++i) durBeats += stp->eleArray[i]->frac; durSmpCnt = stp->eleArray[ei]->perfSmpIdx - stp->eleArray[bi]->perfSmpIdx; stp->value = durBeats / (durSmpCnt / (p->srate*60.0) ); stp->doneFl = true; } if( printFl ) printf("TEMPO:%f bi:%i ei:%i secs:%f bts:%f\n",stp->value,bi,ei,durSmpCnt/p->srate,durBeats); return true; } void _cmScPerfExec( cmSc_t* p, cmScoreSet_t* sp, bool printMissFl ) { if( sp->doneFl == false ) { switch( sp->varId ) { case kEvenVarScId: _cmScPerfEven(p,sp,printMissFl); break; case kDynVarScId: _cmScPerfDyn(p,sp,printMissFl); break; case kTempoVarScId: _cmScPerfTempo(p,sp,printMissFl); break; default: { assert(0); } } } } void _cmScPerfExecRange( cmSc_t* p ) { if( p->minSetLocIdx == cmInvalidIdx || p->maxSetLocIdx==cmInvalidIdx ) return; unsigned i = p->minSetLocIdx; for(; i<=p->maxSetLocIdx; ++i) { cmScoreSet_t* sp = p->loc[i].setList; for(; sp!=NULL; sp=sp->llink) _cmScPerfExec(p,sp,true); } } bool _cmScSetPerfEvent( cmSc_t* p, unsigned locIdx, unsigned smpIdx, unsigned pitch, unsigned vel ) { assert(locIdx < p->locCnt ); cmScoreLoc_t* lp = p->loc + locIdx; bool doneFl = true; unsigned i; #ifndef NDEBUG bool foundFl = false; #endif // locate the event at the loc[locIdx] for(i=0; ievtCnt; ++i) { cmScoreEvt_t* ep = lp->evtArray[i]; if( ep->type == kNonEvtScId ) { if( ep->pitch == pitch ) { assert( ep->perfSmpIdx == cmInvalidIdx ); ep->perfSmpIdx = smpIdx; ep->perfVel = vel; #ifndef NDEBUG foundFl = true; #endif } // check if all notes have arrived for this location if( ep->perfSmpIdx == cmInvalidIdx ) doneFl = false; } } // the event must always be found assert( foundFl ); return doneFl; } bool cmScoreSetPerfEvent( cmScH_t h, unsigned locIdx, unsigned smpIdx, unsigned pitch, unsigned vel ) { cmSc_t* p = _cmScHandleToPtr(h); return _cmScSetPerfEvent(p,locIdx,smpIdx,pitch,vel); } void cmScoreExecPerfEvent( cmScH_t h, unsigned locIdx, unsigned smpIdx, unsigned pitch, unsigned vel ) { unsigned i; cmSc_t* p = _cmScHandleToPtr(h); bool doneFl = _cmScSetPerfEvent(p,locIdx,smpIdx,pitch,vel); unsigned printLvl = 1; cmScoreLoc_t* lp = p->loc + locIdx; // all events for a location must be complete to trigger attached events if( doneFl == false ) return; if( p->loc[locIdx].setList != NULL ) { // set idx of most recent loc w/ a set end event p->maxSetLocIdx = locIdx; if( p->minSetLocIdx == cmInvalidIdx ) p->minSetLocIdx = locIdx; } // attempt to calculate all sets between loc[p->minSetLocIdx] and loc[p->maxSetLocIdx] _cmScPerfExecRange(p); // prevent event retriggering or going backwards if( printLvl && locIdx < p->nxtLocIdx ) { printf("----- BACK ----- \n"); return; } if( printLvl && locIdx > p->nxtLocIdx ) { printf("----- SKIP ----- \n"); } // for each location between the current and previous location for(; p->nxtLocIdx<=locIdx; ++p->nxtLocIdx) { lp = p->loc + p->nxtLocIdx; // if this location is the start of a new section - then apply // sets that are assigned to this section if( lp->begSectPtr != NULL && lp->begSectPtr->setCnt > 0 ) { // notice the location of the oldest section start - once we cross this point // it is too late to notice set completions - so incr p->inSetLocIdx if( lp->begSectPtr->setCnt ) p->minSetLocIdx = p->nxtLocIdx+1; for(i=0; ibegSectPtr->setCnt; ++i) { cmScoreSet_t* stp = lp->begSectPtr->setArray[i]; // temporarily commented out for testing purposes // if( stp->doneFl == false ) // _cmScPerfExec(p, stp, printLvl>0 ); if( stp->doneFl ) { assert( stp->varId < kScVarCnt ); lp->begSectPtr->vars[ stp->varId ] = stp->value; if( p->cbFunc != NULL ) { cmScMsg_t m; m.typeId = kVarMsgScId; m.u.meas.varId = stp->varId; m.u.meas.value = stp->value; p->cbFunc(p->cbArg,&m,sizeof(m)); } } } } } } void cmScoreSetPerfValue( cmScH_t h, unsigned locIdx, unsigned varId, double value ) { cmSc_t* p = _cmScHandleToPtr(h); int li = locIdx; for(; li>=0; --li) if( p->loc[li].begSectPtr != NULL ) { assert( varId < kScVarCnt ); p->loc[li].begSectPtr->vars[varId] = value; break; } assert( li>=0); } void cmScoreSetPerfDynLevel( cmScH_t h, unsigned evtIdx, unsigned dynLvl ) { cmSc_t* p = _cmScHandleToPtr(h); assert(evtIdx < p->cnt ); p->array[ evtIdx ].perfDynLvl = dynLvl; } cmScRC_t cmScoreDecode( const void* msg, unsigned msgByteCnt, cmScMsg_t* m) { cmScMsg_t* mp = (cmScMsg_t*)msg; *m = *mp; return kOkScRC; } void cmScorePrint( cmScH_t h, cmRpt_t* rpt ) { cmSc_t* p = _cmScHandleToPtr(h); unsigned i; cmRptPrintf(rpt,"evnt CSV bar\n"); cmRptPrintf(rpt,"index line bar idx type pitch ETD Dynamic\n"); cmRptPrintf(rpt,"----- ----- --- --- ----- ----- --- -------\n"); for(i=0; icnt; ++i) { cmScoreEvt_t* r = p->array + i; switch(r->type) { case kBarEvtScId: cmRptPrintf(rpt,"%5i %5i %3i bar\n", i, r->line, r->barNumb ); break; case kNonEvtScId: cmRptPrintf(rpt,"%5i %5i %3i %3i %s %5s %c%c%c %s\n", i, r->line, r->barNumb, r->barNoteIdx, cmScEvtTypeIdToLabel(r->type), cmMidiToSciPitch(r->pitch,NULL,0), cmIsFlag(r->flags,kEvenScFl) ? 'e' : ' ', cmIsFlag(r->flags,kTempoScFl) ? 't' : ' ', cmIsFlag(r->flags,kDynScFl) ? 'd' : ' ', cmIsFlag(r->flags,kDynScFl) ? cmScDynIdToLabel(r->dynVal) : ""); break; default: break; } } } cmScRC_t cmScoreGraphicAlloc( cmScH_t h, cmScGraphic_t** vRef, unsigned* nRef) { cmScRC_t rc = kOkScRC; cmSc_t* p = _cmScHandleToPtr(h); cmScGraphic_t* v = cmMemAllocZ(cmScGraphic_t,p->cnt); unsigned i,j,k,k0; unsigned bordH = 5; unsigned bordW = 5; unsigned noteW = 30; unsigned noteH = 30; unsigned left = bordH; unsigned top = bordW; // for each score location for(i=0,k=0; ilocCnt; ++i) { left += k0!=k ? noteW + bordW : 0; top = noteH + 2*bordH; k0 = k; // for each event in location i for(j=0; jloc[i].evtCnt; ++j) { const cmScoreEvt_t* e = p->loc[i].evtArray[j]; switch( e->type) { case kBarEvtScId: top = bordH; case kNonEvtScId: assert( k < p->cnt ); v[k].type = e->type; v[k].csvEventId = e->csvEventId; v[k].left = left; v[k].top = top; v[k].width = noteW; v[k].height = noteH; if( e->type == kBarEvtScId ) v[k].text = cmTsPrintfP(NULL,"%i",e->barNumb); else v[k].text = cmMemAllocStr( cmMidiToSciPitch( e->pitch, NULL, 0)); top += noteH + bordH; k += 1; break; } } } *nRef = k; *vRef = v; return rc; } cmScRC_t cmScoreGraphicRelease( cmScH_t h, cmScGraphic_t** vRef, unsigned* nRef) { if( vRef == NULL || nRef==NULL ) return kOkScRC; unsigned i; cmScGraphic_t* v = *vRef; unsigned n = *nRef; for(i=0; ierr.rpt) != kOkFileRC ) return cmErrMsg(&p->err,kFileFailScRC,"Graphic file create failed for '%s'.",cmStringNullGuard(fn)); unsigned svgWidth = v[n-1].left + v[n-1].width + 10; unsigned svgHeight = 0; for(i=0; i svgHeight ) svgHeight = v[i].top + v[i].height; svgHeight += 10; cmFilePrintf(fH,"\n\n\n\n",svgWidth,svgHeight); if((rc != cmScoreGraphicWrite(h,fH,v,n)) != kOkScRC ) goto errLabel; cmFilePrint(fH,"\n\n\n"); errLabel: cmFileClose(&fH); return rc; } cmScRC_t cmScoreGraphicWrite( cmScH_t h, cmFileH_t fH, cmScGraphic_t* v, unsigned n ) { cmSc_t* p = _cmScHandleToPtr(h); unsigned i; for(i=0; i\n",g->left,g->top,g->width,g->height) != kOkFileRC ) return cmErrMsg(&p->err,kFileFailScRC,"File write failed on graphic file output."); if( g->text != NULL ) { unsigned tx = g->left + g->width/2; unsigned ty = g->top + 20; //g->height/2; if( cmFilePrintf(fH,"%s\n",tx,ty,g->text) != kOkFileRC ) return cmErrMsg(&p->err,kFileFailScRC,"File write failed on graphic file output."); } // //TEXT } return kOkScRC; } cmScRC_t cmScoreFileFromMidi( cmCtx_t* ctx, const cmChar_t* midiFn, const cmChar_t* scoreFn ) { cmScRC_t rc = kOkScRC; cmMidiFileH_t mfH = cmMidiFileNullHandle; cmCsvH_t csvH = cmCsvNullHandle; cmErr_t err; cmChar_t* titles[] = {"id","trk","evt","opcode","dticks","micros","status","meta","ch","d0","d1","arg0","arg1","bar","skip","even","grace","tempo","t frac","dyn","section","remark", NULL }; cmErrSetup(&err,&ctx->rpt,"MIDI to Score"); if( cmMidiFileOpen(ctx, &mfH, midiFn ) != kOkMfRC ) return cmErrMsg(&err,kMidiFileFailScRC,"Unable to open the MIDI file '%s'.",midiFn); if( cmCsvInitialize(&csvH,ctx) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Unable to initialize the CSV file: '%s'.",scoreFn); goto errLabel; } //printf("secs:%f smps:%f\n",cmMidiFileDurSecs(mfH),cmMidiFileDurSecs(mfH)*96000); unsigned msgCnt = cmMidiFileMsgCount(mfH); unsigned i; const cmMidiTrackMsg_t** tmpp = cmMidiFileMsgArray(mfH); double acc_secs = 0; unsigned lexTId = 0; cmCsvCell_t* cp = NULL; if( cmCsvAppendRow(csvH, &cp, cmCsvInsertSymText(csvH,titles[0]), kStrCsvTFl, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'id' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } for(i=1; titles[i]!=NULL; ++i) { if( cmCsvInsertIdentColAfter(csvH, cp, &cp, titles[i], lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting column index '%i' label in '%s'.",i,cmStringNullGuard(scoreFn)); goto errLabel; } } for(i=0; iamicro / 1000000.0; acc_secs += dsecs; if( tmp->status == kMetaStId ) { //opStr = cmMidiMetaStatusToLabel(tmp->metaId); opStr = cmScStatusToOpString(tmp->metaId); metaId = tmp->metaId; switch( tmp->metaId ) { case kTempoMdId: d0 = tmp->u.iVal; } } else { //opStr = cmMidiStatusToLabel(tmp->status); opStr = cmScStatusToOpString(tmp->status); if( cmMidiIsChStatus( tmp->status ) ) { midiCh = tmp->u.chMsgPtr->ch; d0 = tmp->u.chMsgPtr->d0; d1 = tmp->u.chMsgPtr->d1; } } cp = NULL; // skip note-off messages if( tmp->status == kNoteOffMdId ) continue; if( cmCsvAppendRow(csvH, &cp, cmCsvInsertSymUInt(csvH,i), kIntCsvTFl, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'id' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertUIntColAfter(csvH, cp, &cp, tmp->trkIdx, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'trk' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertUIntColAfter(csvH, cp, &cp, 0, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'evt' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertQTextColAfter(csvH, cp, &cp, opStr, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'opcode' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertDoubleColAfter(csvH, cp, &cp, dsecs, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'dticks' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertDoubleColAfter(csvH, cp, &cp, acc_secs, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'micros' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertHexColAfter(csvH, cp, &cp, tmp->status, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'status' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertUIntColAfter(csvH, cp, &cp, metaId, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'meta' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertUIntColAfter(csvH, cp, &cp, midiCh, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'ch' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertUIntColAfter(csvH, cp, &cp, d0, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'd0' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertUIntColAfter(csvH, cp, &cp, d1, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'd1' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } switch( tmp->status ) { case kNoteOnMdId: if( cmCsvInsertQTextColAfter(csvH, cp, &cp, cmMidiToSciPitch(tmp->u.chMsgPtr->d0,NULL,0), lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'opcode' column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } case kMetaStId: switch( tmp->metaId ) { case kTimeSigMdId: if( cmCsvInsertUIntColAfter(csvH, cp, &cp, tmp->u.timeSigPtr->num, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting time sign. numerator column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } if( cmCsvInsertUIntColAfter(csvH, cp, &cp, tmp->u.timeSigPtr->den, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting time sign. denominator column in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } break; case kTempoMdId: if( cmCsvInsertUIntColAfter(csvH, cp, &cp, 60000000/tmp->u.iVal, lexTId ) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"Error inserting 'tempo' in '%s'.",cmStringNullGuard(scoreFn)); goto errLabel; } break; } } } if( cmCsvWrite(csvH,scoreFn) != kOkCsvRC ) { cmErrMsg(&err,kCsvFailScRC,"The score output file '%s' could not be written.",cmStringNullGuard(scoreFn)); goto errLabel; } errLabel: cmMidiFileClose(&mfH); cmCsvFinalize(&csvH); return rc; } void cmScoreTest( cmCtx_t* ctx, const cmChar_t* fn ) { cmScH_t h = cmScNullHandle; if( cmScoreInitialize(ctx,&h,fn,0,NULL,0,NULL,NULL, cmSymTblNullHandle ) != kOkScRC ) return; cmScorePrint(h,&ctx->rpt); cmScoreFinalize(&h); } // 1. Fix absolute message time which was incorrect on original score file. // 2. void cmScoreFix( cmCtx_t* ctx ) { const cmChar_t* mfn = "/home/kevin/src/cmgv/src/gv/data/ImaginaryThemes.mid"; const cmChar_t* crfn = "/home/kevin/src/cmgv/src/gv/data/mod0a.txt"; const cmChar_t* cwfn = "/home/kevin/src/cmgv/src/gv/data/mod1.csv"; cmMidiFileH_t mfH = cmMidiFileNullHandle; cmCsvH_t csvH = cmCsvNullHandle; const cmMidiTrackMsg_t** msg = NULL; double secs = 0.0; int ci,mi,crn,mn; bool errFl = true; unsigned handCnt = 0; unsigned midiMissCnt = 0; if( cmCsvInitialize(&csvH,ctx) != kOkCsvRC ) goto errLabel; if( cmCsvLexRegisterMatcher(csvH, cmCsvLexNextAvailId(csvH), _cmScLexSciPitchMatcher ) != kOkCsvRC ) goto errLabel; if( cmCsvParseFile(csvH, crfn, 0 ) != kOkCsvRC ) goto errLabel; if( cmMidiFileOpen(ctx,&mfH,mfn) != kOkMfRC ) goto errLabel; mn = cmMidiFileMsgCount(mfH); msg = cmMidiFileMsgArray(mfH); crn = cmCsvRowCount(csvH); // for each row in the score file for(ci=1,mi=0; ciamicro/1000000.0; if( mi+1 != id ) { if( m->status == kNoteOnMdId && m->u.chMsgPtr->d1>0 ) { // this MIDI note-on does not have a corresponding score event ++midiMissCnt; } } else { cmCsvSetCellDouble( csvH, ci, kSecsColScIdx, secs ); ++mi; if( m->status == kNoteOnMdId ) cmCsvSetCellDouble( csvH, ci, kDSecsColScIdx, m->u.chMsgPtr->durMicros /1000000.0 ); break; } } if( mi==mn) printf("done on row:%i\n",ci); } } if( cmCsvLastRC(csvH) != kOkCsvRC ) goto errLabel; if( cmCsvWrite(csvH,cwfn) != kOkCsvRC ) goto errLabel; errFl = false; errLabel: if( errFl ) printf("Score fix failed.\n"); else printf("Score fix done! hand:%i miss:%i\n",handCnt,midiMissCnt); cmMidiFileClose(&mfH); cmCsvFinalize(&csvH); }