libcm is a C development framework with an emphasis on audio signal processing applications.
Du kannst nicht mehr als 25 Themen auswählen Themen müssen mit entweder einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.

cmScore.c 48KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018
  1. #include "cmPrefix.h"
  2. #include "cmGlobal.h"
  3. #include "cmFloatTypes.h"
  4. #include "cmRpt.h"
  5. #include "cmErr.h"
  6. #include "cmCtx.h"
  7. #include "cmMem.h"
  8. #include "cmMallocDebug.h"
  9. #include "cmMidi.h"
  10. #include "cmLex.h"
  11. #include "cmCsv.h"
  12. #include "cmSymTbl.h"
  13. #include "cmMidiFile.h"
  14. #include "cmAudioFile.h"
  15. #include "cmTimeLine.h"
  16. #include "cmScore.h"
  17. #include "cmVectOpsTemplateMain.h"
  18. cmScH_t cmScNullHandle = cmSTATIC_NULL_HANDLE;
  19. enum
  20. {
  21. kLabelCharCnt = 7,
  22. kInvalidDynScId = 0,
  23. };
  24. enum
  25. {
  26. kMidiFileIdColScIdx= 0,
  27. kTypeLabelColScIdx = 3,
  28. kDSecsColScIdx = 4,
  29. kSecsColScIdx = 5,
  30. kPitchColScIdx = 11,
  31. kBarColScIdx = 13,
  32. kSkipColScIdx = 14,
  33. kEvenColScIdx = 15,
  34. kGraceColScIdx = 16,
  35. kTempoColScIdx = 17,
  36. kFracColScIdx = 18,
  37. kDynColScIdx = 19,
  38. kSectionColScIdx = 20,
  39. kRemarkColScIdx = 21
  40. };
  41. typedef struct
  42. {
  43. unsigned id;
  44. unsigned flag;
  45. cmChar_t label[ kLabelCharCnt + 1 ];
  46. } cmScEvtRef_t;
  47. typedef struct cmScSect_str
  48. {
  49. const cmChar_t* label;
  50. unsigned startIdx;
  51. struct cmScSect_str* link;
  52. } cmScSect_t;
  53. typedef struct cmScSetEle_str
  54. {
  55. cmChar_t* label;
  56. unsigned eleIdx;
  57. struct cmScSetEle_str* link;
  58. } cmScSetEle_t;
  59. typedef struct cmScSet_str
  60. {
  61. unsigned typeFl; // type of this set
  62. cmScSetEle_t* eles; // indexes of set elements
  63. cmScSetEle_t* sects; // application section labels
  64. bool inFl; // true if currently accepting elements
  65. struct cmScSet_str* link; //
  66. } cmScSet_t;
  67. typedef struct
  68. {
  69. cmErr_t err;
  70. cmCsvH_t cH;
  71. cmSymTblH_t stH;
  72. cmScCb_t cbFunc;
  73. void* cbArg;
  74. cmChar_t* fn;
  75. double srate;
  76. cmScoreEvt_t* array;
  77. unsigned cnt;
  78. cmScoreLoc_t* loc;
  79. unsigned locCnt;
  80. cmScoreSection_t* sect;
  81. unsigned sectCnt;
  82. unsigned sciPitchLexTId; // sci pitch and section id lexer token id's
  83. unsigned sectionLexTId;
  84. cmScSect_t* sectList; // lists used during parsing
  85. cmScSet_t* setList;
  86. cmScoreSet_t* sets;
  87. unsigned setCnt;
  88. unsigned* dynRefArray;
  89. unsigned dynRefCnt;
  90. unsigned nxtLocIdx;
  91. unsigned minSetLocIdx;
  92. unsigned maxSetLocIdx;
  93. } cmSc_t;
  94. cmScEvtRef_t _cmScEvtRefArray[] =
  95. {
  96. { kTimeSigEvtScId, 0, "tsg" },
  97. { kKeySigEvtScId, 0, "ksg" },
  98. { kTempoEvtScId, 0, "tmp" },
  99. { kTrackEvtScId, 0, "trk" },
  100. { kTextEvtScId, 0, "txt" },
  101. { kEOTrackEvtScId, 0, "eot" },
  102. { kCopyEvtScId, 0, "cpy" },
  103. { kBlankEvtScId, 0, "blk" },
  104. { kBarEvtScId, 0, "bar" },
  105. { kPgmEvtScId, 0, "pgm" },
  106. { kCtlEvtScId, 0, "ctl" },
  107. { kNonEvtScId, 0, "non" },
  108. { kInvalidEvtScId, 0, "***" }
  109. };
  110. cmScEvtRef_t _cmScDynRefArray[] =
  111. {
  112. { 1, 0, "pppp" },
  113. { 2, 0, "ppp" },
  114. { 3, 0, "pp" },
  115. { 4, 0, "p" },
  116. { 5, 0, "mp" },
  117. { 6, 0, "mf" },
  118. { 7, 0, "f" },
  119. { 8, 0, "ff" },
  120. { 9,0, "fff" },
  121. { kInvalidDynScId,0, "***" },
  122. };
  123. cmScEvtRef_t _cmScVarRefArray[] =
  124. {
  125. { kEvenVarScId, kEvenScFl, "e"},
  126. { kDynVarScId, kDynScFl, "d"},
  127. { kTempoVarScId,kTempoScFl,"t"},
  128. { cmInvalidId, 0, "@"}
  129. };
  130. cmSc_t* _cmScHandleToPtr( cmScH_t h )
  131. {
  132. cmSc_t* p = (cmSc_t*)h.h;
  133. assert( p != NULL );
  134. return p;
  135. }
  136. unsigned _cmScEvtTypeLabelToId( const cmChar_t* label )
  137. {
  138. cmScEvtRef_t* r = _cmScEvtRefArray;
  139. for(; r->id != kInvalidEvtScId; ++r )
  140. if( strcmp(label,r->label) == 0 )
  141. return r->id;
  142. return kInvalidEvtScId;
  143. }
  144. const cmChar_t* cmScEvtTypeIdToLabel( unsigned id )
  145. {
  146. cmScEvtRef_t* r = _cmScEvtRefArray;
  147. for(; r->id != kInvalidEvtScId; ++r )
  148. if( r->id == id )
  149. return r->label;
  150. return NULL;
  151. }
  152. unsigned _cmScDynLabelToId( const cmChar_t* label )
  153. {
  154. cmScEvtRef_t* r = _cmScDynRefArray;
  155. for(; r->id != kInvalidEvtScId; ++r )
  156. if( strncmp(label,r->label,strlen(r->label)) == 0 )
  157. return r->id;
  158. return kInvalidDynScId;
  159. }
  160. // return the count of dynamic label/id pairs
  161. unsigned _cmScDynLabelCount( )
  162. {
  163. unsigned n = 0;
  164. cmScEvtRef_t* r = _cmScDynRefArray;
  165. for(; r->id != kInvalidEvtScId; ++r )
  166. ++n;
  167. return n;
  168. }
  169. const cmChar_t* cmScDynIdToLabel( unsigned id )
  170. {
  171. cmScEvtRef_t* r = _cmScDynRefArray;
  172. for(; r->id != kInvalidDynScId; ++r )
  173. if( r->id == id )
  174. return r->label;
  175. return NULL;
  176. }
  177. char _cmScVarFlagToChar( unsigned flags )
  178. {
  179. unsigned i;
  180. for(i=0; _cmScVarRefArray[i].id!=cmInvalidId; ++i)
  181. if( _cmScVarRefArray[i].flag == flags )
  182. return _cmScVarRefArray[i].label[0];
  183. assert(0);
  184. return ' ';
  185. }
  186. char _cmScVarIdToChar( unsigned id )
  187. {
  188. unsigned i;
  189. for(i=0; _cmScVarRefArray[i].id!=cmInvalidId; ++i)
  190. if( _cmScVarRefArray[i].id == id )
  191. return _cmScVarRefArray[i].label[0];
  192. assert(0);
  193. return ' ';
  194. }
  195. unsigned _cmScVarFlagToId( unsigned flags )
  196. {
  197. unsigned i;
  198. for(i=0; _cmScVarRefArray[i].id!=cmInvalidId; ++i)
  199. if( _cmScVarRefArray[i].flag == flags )
  200. return _cmScVarRefArray[i].id;
  201. assert(0);
  202. return cmInvalidId;
  203. }
  204. const char* _cmScFlagsToStr( unsigned flags, char* buf, int bufCharCnt )
  205. {
  206. unsigned i=0;
  207. if( cmIsFlag(flags,kEvenScFl) )
  208. {
  209. assert(i<bufCharCnt);
  210. buf[i] = 'e';
  211. ++i;
  212. }
  213. if( cmIsFlag(flags,kDynScFl) )
  214. {
  215. assert(i<bufCharCnt);
  216. buf[i] = 'd';
  217. ++i;
  218. }
  219. if( cmIsFlag(flags,kTempoScFl ))
  220. {
  221. assert(i<bufCharCnt);
  222. buf[i] = 't';
  223. ++i;
  224. }
  225. assert(i<bufCharCnt);
  226. buf[i] = 0;
  227. return buf;
  228. }
  229. unsigned _cmScLexSciPitchMatcher( const cmChar_t* cp, unsigned cn )
  230. {
  231. if( cp==NULL || cn < 2 )
  232. return 0;
  233. // first char must be "A-G"
  234. if( strspn(cp,"ABCDEFG") != 1 )
  235. return 0;
  236. unsigned i = 1;
  237. // next char could be accidental
  238. if( cp[i] == '#' || cp[i] == 'b' )
  239. ++i; // i==2
  240. // the 2nd or 3rd char must be a digit
  241. if( i>=cn || isdigit(cp[i]) == false )
  242. return 0;
  243. ++i; // i==2 or i==3
  244. // the 3rd or 4th char must be a digit or EOS
  245. if( i>=cn || isdigit(cp[i]) == false )
  246. return i;
  247. ++i;
  248. return i;
  249. }
  250. unsigned _cmScLexSectionIdMatcher( const cmChar_t* cp, unsigned cn )
  251. {
  252. if( cp==NULL || cn < 2 )
  253. return 0;
  254. // first char must be a number
  255. if( !isdigit(cp[0]) )
  256. return 0;
  257. // if 2nd char is a char then terminate
  258. if( 'a'<=cp[1] && cp[1]<='z' )
  259. return 2;
  260. // if 2nd char is digit and 3rd char is char then terminate
  261. if( isdigit(cp[1]) && cn>2 && 'a'<=cp[2] && cp[2]<='z' )
  262. return 3;
  263. return 0;
  264. }
  265. void _cmScFreeSetList( cmScSet_t* setList )
  266. {
  267. cmScSet_t* tp = setList;
  268. cmScSet_t* ntp = NULL;
  269. while(tp!=NULL)
  270. {
  271. ntp = tp->link;
  272. cmScSetEle_t* ep = tp->eles;
  273. while( ep != NULL )
  274. {
  275. cmScSetEle_t* nep = ep->link;
  276. cmMemFree(ep);
  277. ep = nep;
  278. }
  279. ep = tp->sects;
  280. while( ep != NULL )
  281. {
  282. cmScSetEle_t* nep = ep->link;
  283. cmMemFree(ep->label);
  284. cmMemFree(ep);
  285. ep = nep;
  286. }
  287. cmMemFree(tp);
  288. tp = ntp;
  289. }
  290. }
  291. cmScRC_t _cmScFinalize( cmSc_t* p )
  292. {
  293. cmScRC_t rc = kOkScRC;
  294. unsigned i;
  295. if( cmCsvFinalize(&p->cH) != kOkCsvRC )
  296. return rc;
  297. if( p->sets != NULL )
  298. {
  299. for(i=0; i<p->setCnt; ++i)
  300. {
  301. cmMemFree(p->sets[i].eleArray);
  302. cmMemFree(p->sets[i].sectArray);
  303. cmMemFree(p->sets[i].symArray);
  304. cmMemFree(p->sets[i].costSymArray);
  305. }
  306. cmMemFree(p->sets);
  307. }
  308. _cmScFreeSetList(p->setList);
  309. if( p->loc != NULL )
  310. {
  311. for(i=0; i<p->locCnt; ++i)
  312. {
  313. cmMemFree(p->loc[i].evtArray);
  314. if( p->loc[i].begSectPtr != NULL )
  315. cmMemFree(p->loc[i].begSectPtr->setArray);
  316. }
  317. cmMemFree(p->loc);
  318. }
  319. cmMemPtrFree(&p->dynRefArray);
  320. cmMemFree(p->sect);
  321. cmMemFree(p->fn);
  322. cmMemFree(p->array);
  323. cmMemFree(p);
  324. return rc;
  325. }
  326. cmScRC_t _cmScParseBar( cmSc_t* p, unsigned rowIdx, cmScoreEvt_t* s, int* barNumb )
  327. {
  328. if((*barNumb = cmCsvCellInt(p->cH,rowIdx,kBarColScIdx)) == INT_MAX )
  329. return cmErrMsg(&p->err,kSyntaxErrScRC,"Unable to parse the bar number.");
  330. s->type = kBarEvtScId;
  331. s->secs = 0;
  332. s->barNumb = *barNumb;
  333. s->csvRowNumb = rowIdx + 1;
  334. return kOkScRC;
  335. }
  336. cmScSet_t* _cmScNewSet( cmSc_t* p, unsigned typeFl )
  337. {
  338. // create a new set record
  339. cmScSet_t* nsp = cmMemAllocZ(cmScSet_t,1);
  340. nsp->inFl = true;
  341. nsp->typeFl = typeFl;
  342. if( p->setList == NULL )
  343. p->setList = nsp;
  344. else
  345. {
  346. // go to the end of the the set list
  347. cmScSet_t* sp = p->setList;
  348. assert(sp!=NULL);
  349. while( sp->link != NULL )
  350. sp = sp->link;
  351. sp->link = nsp;
  352. }
  353. return nsp;
  354. }
  355. cmScSet_t* _cmScFindSet( cmSc_t* p, unsigned typeFl )
  356. {
  357. // locate the set currently accepting ele's for this type
  358. cmScSet_t* sp = p->setList;
  359. for(; sp != NULL; sp=sp->link )
  360. if( sp->typeFl == typeFl && sp->inFl )
  361. break;
  362. return sp;
  363. }
  364. void _cmScSetDone(cmSc_t* p, unsigned typeFl)
  365. {
  366. cmScSet_t* sp = _cmScFindSet(p,typeFl);
  367. assert( sp != NULL );
  368. sp->inFl = false;
  369. }
  370. // This function is called during parsing to
  371. // insert a set element or set section into a cmScSet_t
  372. // element or section linked list. Either the scoreIdx
  373. // or the label is valid but not both.
  374. cmScSet_t* _cmScInsertSetEle(cmSc_t* p, unsigned scoreIdx, unsigned typeFl, const cmChar_t* label, unsigned labelCharCnt)
  375. {
  376. assert( scoreIdx!=cmInvalidId || (scoreIdx==cmInvalidIdx && label!=NULL && labelCharCnt>0));
  377. cmScSet_t* sp = _cmScFindSet(p,typeFl);
  378. if( sp == NULL )
  379. sp = _cmScNewSet(p,typeFl);
  380. // allocate a new set element record
  381. cmScSetEle_t* nep = cmMemAllocZ(cmScSetEle_t,1);
  382. cmScSetEle_t** list = NULL;
  383. nep->eleIdx = scoreIdx;
  384. if( label == NULL )
  385. {
  386. // all elements must be of the same type
  387. assert( sp->typeFl == typeFl );
  388. sp->typeFl = typeFl;
  389. list = &sp->eles;
  390. }
  391. else
  392. {
  393. nep->label = cmMemAllocStrN(label,labelCharCnt);
  394. list = &sp->sects;
  395. }
  396. // *list refers to sp->sects or sp->ele's depending on the type of ele
  397. if( *list == NULL )
  398. *list = nep;
  399. else
  400. {
  401. // got to the last element in the set
  402. cmScSetEle_t* ep = *list;
  403. while( ep->link != NULL )
  404. ep = ep->link;
  405. // append the new element to the end of the list
  406. ep->link = nep;
  407. }
  408. return sp;
  409. }
  410. // Extract the next attribute section identifier.
  411. const cmChar_t* _cmScParseOneSetSection( cmSc_t* p, unsigned typeFl, const cmChar_t* c0p )
  412. {
  413. // advance white space
  414. while( *c0p && (isspace(*c0p) || *c0p==',') )
  415. ++c0p;
  416. if( *c0p==0 )
  417. return c0p;
  418. // c0p now points to a section id or an asterisk
  419. const cmChar_t* c1p = c0p;
  420. // advance past section id
  421. while( *c1p && (!isspace(*c1p) && (isdigit(*c1p) || isalpha(*c1p))))
  422. ++c1p;
  423. // if c0p pointed to an asterisk then c1p is still equal to c0p
  424. if( c1p > c0p )
  425. _cmScInsertSetEle(p,cmInvalidIdx,typeFl,c0p,c1p-c0p);
  426. return c1p;
  427. }
  428. // Parse an attribute string to extract the section
  429. // identifiers which may follow the attribute token (e,t,mf,ff,...)
  430. cmScRC_t _cmScParseAttr(cmSc_t* p, unsigned scoreIdx, const cmChar_t* text, unsigned typeFl)
  431. {
  432. const cmChar_t* cp = text;
  433. // insert a set element - all attribute's produce one element record
  434. _cmScInsertSetEle(p,scoreIdx,typeFl,NULL,0);
  435. // advance past the attribute type marking (e,t,(p,mf,f,fff,etc)) in search
  436. // of section identifiers
  437. while( *cp && !isspace(*cp) )
  438. ++cp;
  439. if( *cp )
  440. {
  441. // search for the first section identifier
  442. if((cp =_cmScParseOneSetSection(p,typeFl,cp)) != NULL )
  443. {
  444. bool asteriskFl = false;
  445. // search for the second section identifier
  446. if((cp = _cmScParseOneSetSection(p,typeFl,cp)) != NULL && *cp!=0 )
  447. asteriskFl = *cp == '*';
  448. _cmScSetDone(p,typeFl);
  449. // if the attr just parsed ended with an asterisk then it is both
  450. // the last element of the previous set and the first ele of the
  451. // next set
  452. if( asteriskFl )
  453. {
  454. // if the attr just parsed had a section id then it was the last
  455. // element in the set - create a new set record to hold the next set
  456. _cmScNewSet(p,typeFl);
  457. _cmScInsertSetEle(p,scoreIdx,typeFl,NULL,0);
  458. }
  459. }
  460. }
  461. return kOkScRC;
  462. }
  463. void _cmScPrintSets( const cmChar_t* label, cmScSet_t* setList )
  464. {
  465. printf("%s\n",label);
  466. const cmScSet_t* sp = setList;
  467. for(; sp != NULL; sp=sp->link )
  468. {
  469. const cmScSetEle_t* ep = sp->eles;
  470. for(; ep!=NULL; ep=ep->link)
  471. printf("%i ",ep->eleIdx);
  472. printf(" : ");
  473. for(ep=sp->sects; ep!=NULL; ep=ep->link)
  474. printf("%s ",cmStringNullGuard(ep->label));
  475. printf("\n");
  476. }
  477. }
  478. cmScRC_t _cmScParseNoteOn( cmSc_t* p, unsigned rowIdx, cmScoreEvt_t* s, unsigned scoreIdx, int barNumb, unsigned barNoteIdx )
  479. {
  480. cmScRC_t rc = kOkScRC;
  481. unsigned flags = 0;
  482. unsigned dynVal = kInvalidDynScId;
  483. const cmChar_t* sciPitch;
  484. cmMidiByte_t midiPitch;
  485. const cmChar_t* attr;
  486. double secs;
  487. double durSecs;
  488. const cmCsvCell_t* cell;
  489. s += scoreIdx;
  490. // verify the scientific pitch cell was formatted correcly
  491. if((cell = cmCsvCellPtr(p->cH,rowIdx,kPitchColScIdx)) == NULL || cell->lexTId != p->sciPitchLexTId )
  492. return cmErrMsg(&p->err,kSyntaxErrScRC,"Pitch column format error.");
  493. if((sciPitch = cmCsvCellText(p->cH,rowIdx,kPitchColScIdx)) == NULL )
  494. return cmErrMsg(&p->err,kSyntaxErrScRC,"Expected a scientific pitch value");
  495. if((midiPitch = cmSciPitchToMidi(sciPitch)) == kInvalidMidiPitch)
  496. return cmErrMsg(&p->err,kSyntaxErrScRC,"Unable to convert the scientific pitch '%s' to a MIDI value. ");
  497. // it is possible that note delta-secs field is empty - so default to 0
  498. if((secs = cmCsvCellDouble(p->cH, rowIdx, kSecsColScIdx )) == DBL_MAX) // Returns DBL_MAX on error.
  499. flags += kInvalidScFl;
  500. // skip attribute
  501. if((attr = cmCsvCellText(p->cH,rowIdx,kSkipColScIdx)) != NULL && *attr == 's' )
  502. flags += kSkipScFl;
  503. // evenness attribute
  504. if((attr = cmCsvCellText(p->cH,rowIdx,kEvenColScIdx)) != NULL && *attr == 'e' )
  505. {
  506. flags += kEvenScFl;
  507. _cmScParseAttr(p,scoreIdx,attr,kEvenScFl);
  508. }
  509. // grace attribute
  510. if((attr = cmCsvCellText(p->cH,rowIdx,kGraceColScIdx)) != NULL && *attr == 'g' )
  511. {
  512. flags += kGraceScFl;
  513. if( cmIsNotFlag(flags,kEvenScFl) )
  514. return cmErrMsg(&p->err,kSyntaxErrScRC,"All 'grace' notes should also be 'even' notes.");
  515. }
  516. // tempo attribute
  517. if((attr = cmCsvCellText(p->cH,rowIdx,kTempoColScIdx)) != NULL && *attr == 't' )
  518. {
  519. flags += kTempoScFl;
  520. _cmScParseAttr(p,scoreIdx,attr,kTempoScFl);
  521. }
  522. // dynamics attribute
  523. if((attr = cmCsvCellText(p->cH,rowIdx,kDynColScIdx)) != NULL )
  524. {
  525. if((dynVal = _cmScDynLabelToId(attr)) == kInvalidDynScId )
  526. return cmErrMsg(&p->err,kSyntaxErrScRC,"Unknown dynamic label '%s'.",cmStringNullGuard(attr));
  527. flags += kDynScFl;
  528. _cmScParseAttr(p,scoreIdx,attr,kDynScFl);
  529. }
  530. // tempo/non-grace rythmic value
  531. if( cmIsFlag(flags,kTempoScFl) || (cmIsFlag(flags,kEvenScFl) && cmIsNotFlag(flags,kGraceScFl)) )
  532. {
  533. double frac = cmCsvCellDouble(p->cH,rowIdx,kFracColScIdx);
  534. // no 'frac' value is given for the last note of the set we must accept error
  535. // values here and validate the actual values later
  536. if( frac>0 && frac!=DBL_MAX )
  537. s->frac = frac;
  538. }
  539. // Returns DBL_MAX on error.
  540. if((durSecs = cmCsvCellDouble(p->cH, rowIdx, kDSecsColScIdx )) == DBL_MAX)
  541. durSecs = 0.25;
  542. s->type = kNonEvtScId;
  543. s->secs = secs;
  544. s->pitch = midiPitch;
  545. s->flags = flags;
  546. s->dynVal = dynVal;
  547. s->barNumb = barNumb;
  548. s->barNoteIdx = barNoteIdx;
  549. s->durSecs = durSecs;
  550. s->csvRowNumb = rowIdx+1;
  551. return rc;
  552. }
  553. cmScRC_t _cmScParseSectionColumn( cmSc_t* p, unsigned rowIdx, unsigned evtIdx, cmScSect_t* sectList )
  554. {
  555. const cmCsvCell_t* cell;
  556. cmScSect_t* sect;
  557. const cmChar_t* label;
  558. // most rows don't have section labels
  559. if( (cell = cmCsvCellPtr( p->cH,rowIdx,kSectionColScIdx)) == NULL
  560. || (label = cmCsvCellText(p->cH,rowIdx,kSectionColScIdx)) == NULL)
  561. return kOkScRC;
  562. // verify the section id type
  563. if( cell->lexTId != p->sectionLexTId && cell->lexTId != kIntLexTId )
  564. return cmErrMsg(&p->err,kSyntaxErrScRC,"'section' column format error.");
  565. sect = cmMemAllocZ(cmScSect_t,1);
  566. sect->label = label;
  567. sect->startIdx = evtIdx;
  568. //printf("section:%s\n",label);
  569. cmScSect_t* sp = sectList;
  570. assert( sp != NULL );
  571. while( sp->link != NULL )
  572. sp = sp->link;
  573. sp->link = sect;
  574. return kOkScRC;
  575. }
  576. cmScoreSection_t* _cmScLabelToSection( cmSc_t* p, const cmChar_t* label )
  577. {
  578. int i;
  579. for(i=0; i<p->sectCnt; ++i)
  580. if( strcmp(p->sect[i].label,label) == 0 )
  581. return p->sect + i;
  582. return NULL;
  583. }
  584. // Calculate the total number of all types of sets and
  585. // then convert each of the cmScSet_t linked list's to
  586. // a single linear cmScoreSet_t list (p->sets[]).
  587. cmScRC_t _cmScProcSets( cmSc_t* p )
  588. {
  589. cmScRC_t rc = kOkScRC;
  590. // calculate the count of all sets
  591. unsigned i;
  592. unsigned n = 0;
  593. cmScSet_t* sp = p->setList;
  594. for(n=0; sp!=NULL; sp=sp->link)
  595. if( sp->eles != NULL )
  596. ++n;
  597. // allocate the linear set array
  598. p->sets = cmMemAllocZ(cmScoreSet_t,n);
  599. p->setCnt = n;
  600. // fill in the linear set array
  601. sp = p->setList;
  602. for(i=0; sp!=NULL; sp=sp->link)
  603. if( sp->eles != NULL )
  604. {
  605. unsigned j;
  606. unsigned en;
  607. unsigned rowNumb = 0;
  608. assert( i<n );
  609. // get the count of elements assoc'd with this set
  610. cmScSetEle_t* ep = sp->eles;
  611. for(en=0; ep!=NULL; ep=ep->link)
  612. ++en;
  613. assert( en > 0 );
  614. // allocate the element array
  615. p->sets[i].eleCnt = en;
  616. p->sets[i].eleArray = cmMemAllocZ(cmScoreEvt_t*,en);
  617. // fill in the element array
  618. ep = sp->eles;
  619. unsigned graceCnt = 0;
  620. for(j=0; ep!=NULL; ep=ep->link,++j)
  621. {
  622. assert(ep->eleIdx != cmInvalidIdx && ep->eleIdx<p->cnt);
  623. p->sets[i].eleArray[j] = p->array + ep->eleIdx;
  624. assert( cmIsFlag( p->sets[i].eleArray[j]->flags, sp->typeFl) );
  625. rowNumb = p->array[ep->eleIdx].csvRowNumb;
  626. unsigned flags = p->array[ep->eleIdx].flags;
  627. // count grace notes
  628. if( cmIsFlag(flags,kGraceScFl) )
  629. ++graceCnt;
  630. // validate the 'frac' field - all but the last note in
  631. // tempo and non-grace evenness sets must have a non-zero 'frac' value.
  632. if( en>0 && j<en-1 && (sp->typeFl==kTempoScFl || (sp->typeFl==kEvenScFl && graceCnt==0)) && p->array[ep->eleIdx].frac==0)
  633. rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The note on row number %i must have a non-zero 'frac' value.",p->array[ep->eleIdx].csvRowNumb);
  634. }
  635. // get the count of sections assoc'd with this set
  636. ep = sp->sects;
  637. for(en=0; ep!=NULL; ep=ep->link)
  638. ++en;
  639. // allocate the section array
  640. p->sets[i].varId = _cmScVarFlagToId(sp->typeFl);
  641. p->sets[i].sectCnt = en;
  642. p->sets[i].sectArray = cmMemAllocZ(cmScoreSection_t*,en);
  643. p->sets[i].symArray = cmMemAllocZ(unsigned,en);
  644. p->sets[i].costSymArray = cmMemAllocZ(unsigned,en);
  645. // fill in the section array with sections which this set will be applied to
  646. ep = sp->sects;
  647. for(j=0; ep!=NULL; ep=ep->link,++j)
  648. {
  649. cmScoreSection_t* sp;
  650. assert(ep->label != NULL);
  651. if((sp = _cmScLabelToSection(p, ep->label )) == NULL )
  652. rc = cmErrMsg(&p->err,kSyntaxErrScRC,"The section labelled '%s' could not be found for the set which includes row number %i.",ep->label,rowNumb);
  653. else
  654. {
  655. if( cmSymTblIsValid(p->stH) )
  656. {
  657. p->sets[i].symArray[j] = cmSymTblRegisterFmt(p->stH,"%c-%s", _cmScVarIdToChar(p->sets[i].varId),ep->label);
  658. p->sets[i].costSymArray[j] = cmSymTblRegisterFmt(p->stH,"c%c-%s",_cmScVarIdToChar(p->sets[i].varId),ep->label);
  659. }
  660. else
  661. {
  662. p->sets[i].symArray[j] = cmInvalidId;
  663. p->sets[i].symArray[j] = cmInvalidId;
  664. }
  665. p->sets[i].sectArray[j] = sp;
  666. sp->setArray = cmMemResizeP(cmScoreSet_t*,sp->setArray,++sp->setCnt);
  667. sp->setArray[sp->setCnt-1] = p->sets + i;
  668. }
  669. }
  670. ++i;
  671. }
  672. assert(i==n);
  673. // assign each set to the location which contains it's last element.
  674. // (this is earliest point in the score location where all the
  675. // performance information contained in the set may be valid)
  676. for(i=0; i<p->setCnt; ++i)
  677. {
  678. assert( p->sets[i].eleCnt >= 1 );
  679. // get a ptr to the last element for the ith set
  680. const cmScoreEvt_t* ep = p->sets[i].eleArray[ p->sets[i].eleCnt-1 ];
  681. unsigned j,k;
  682. // find the location which contains the last element
  683. for(j=0; j<p->locCnt; ++j)
  684. {
  685. for(k=0; k<p->loc[j].evtCnt; ++k)
  686. if( p->loc[j].evtArray[k] == ep )
  687. break;
  688. if(k<p->loc[j].evtCnt)
  689. break;
  690. }
  691. assert( j<p->locCnt );
  692. // assign the ith set to the location which contains it's last element
  693. p->sets[i].llink = p->loc[j].setList;
  694. p->loc[j].setList = p->sets + i;
  695. }
  696. return rc;
  697. }
  698. cmScRC_t _cmScProcSections( cmSc_t* p, cmScSect_t* sectList )
  699. {
  700. cmScRC_t rc = kOkScRC;
  701. unsigned i;
  702. // count the sections
  703. cmScSect_t* sp = sectList;
  704. p->sectCnt = 0;
  705. for(; sp!=NULL; sp=sp->link)
  706. if( sp->label != NULL )
  707. ++p->sectCnt;
  708. // alloc a section array
  709. p->sect = cmMemAllocZ(cmScoreSection_t,p->sectCnt);
  710. // fill the section array
  711. sp = sectList;
  712. for(i=0; sp!=NULL; sp=sp->link)
  713. if( sp->label != NULL )
  714. {
  715. p->sect[i].label = sp->label;
  716. p->sect[i].index = i;
  717. p->sect[i].begEvtIndex = sp->startIdx;
  718. ++i;
  719. }
  720. // assign the begSectPtr to each section
  721. for(i=0; i<p->sectCnt; ++i)
  722. {
  723. assert( p->sect[i].begEvtIndex < p->cnt );
  724. unsigned j,k;
  725. const cmScoreEvt_t* ep = p->array + p->sect[i].begEvtIndex;
  726. for(j=0; j<p->locCnt; ++j)
  727. {
  728. for(k=0; k<p->loc[j].evtCnt; ++k)
  729. if( p->loc[j].evtArray[k] == ep )
  730. {
  731. p->loc[j].begSectPtr = p->sect + i;
  732. p->sect[i].locPtr = p->loc + j;
  733. break;
  734. }
  735. if( k<p->loc[j].evtCnt)
  736. break;
  737. }
  738. }
  739. // release the section linked list
  740. sp = sectList;
  741. cmScSect_t* np = NULL;
  742. while(sp!=NULL)
  743. {
  744. np = sp->link;
  745. cmMemFree(sp);
  746. sp = np;
  747. }
  748. //_cmScPrintSets("Sets",p->setList );
  749. _cmScProcSets(p);
  750. return rc;
  751. }
  752. cmScRC_t _cmScParseFile( cmSc_t* p, cmCtx_t* ctx, const cmChar_t* fn )
  753. {
  754. cmScRC_t rc = kOkScRC;
  755. unsigned barNoteIdx = 0;
  756. int barEvtIdx = cmInvalidIdx;
  757. int barNumb = 0;
  758. double secs;
  759. double cur_secs = 0;
  760. p->sectList = cmMemAllocZ(cmScSect_t,1); // section zero
  761. //_cmScNewSet(p); // preallocate the first set
  762. // initialize the CSV file parser
  763. if( cmCsvInitialize(&p->cH, ctx ) != kOkCsvRC )
  764. {
  765. rc = cmErrMsg(&p->err,kCsvFailScRC,"Score file initialization failed.");
  766. goto errLabel;
  767. }
  768. // register custom lex token matchers for sci-pitch and section id's
  769. if( cmCsvLexRegisterMatcher(p->cH, p->sciPitchLexTId = cmCsvLexNextAvailId(p->cH)+0, _cmScLexSciPitchMatcher ) != kOkCsvRC
  770. ||cmCsvLexRegisterMatcher(p->cH, p->sectionLexTId = cmCsvLexNextAvailId(p->cH)+1, _cmScLexSectionIdMatcher) != kOkCsvRC )
  771. {
  772. rc = cmErrMsg(&p->err,kCsvFailScRC,"CSV token matcher registration failed.");
  773. goto errLabel;
  774. }
  775. // parse the CSV file
  776. if( cmCsvParseFile(p->cH, fn, 0 ) != kOkCsvRC )
  777. {
  778. rc = cmErrMsg(&p->err,kCsvFailScRC,"CSV file parsing failed on the file '%s'.",cmStringNullGuard(fn));
  779. goto errLabel;
  780. }
  781. // allocate the score event array
  782. p->cnt = cmCsvRowCount(p->cH);
  783. p->array = cmMemAllocZ(cmScoreEvt_t,p->cnt);
  784. unsigned i,j;
  785. // skip labels line - start on line 1
  786. for(i=1,j=0; i<p->cnt && rc==kOkScRC; ++i)
  787. {
  788. // get the row 'type' label
  789. const char* typeLabel;
  790. if((typeLabel = cmCsvCellText(p->cH,i,kTypeLabelColScIdx)) == NULL )
  791. {
  792. rc = cmErrMsg(&p->err,kSyntaxErrScRC,"No type label.");
  793. break;
  794. }
  795. // convert the row 'type' label to an id
  796. unsigned tid;
  797. if((tid = _cmScEvtTypeLabelToId(typeLabel)) == kInvalidEvtScId)
  798. {
  799. rc = cmErrMsg(&p->err,kSyntaxErrScRC,"Unknown type '%s'.",cmStringNullGuard(typeLabel));
  800. break;
  801. }
  802. secs = DBL_MAX;
  803. switch(tid)
  804. {
  805. case kBarEvtScId: // parse bar lines
  806. if((rc = _cmScParseBar(p,i,p->array+j,&barNumb)) == kOkScRC )
  807. {
  808. barNoteIdx = 0;
  809. barEvtIdx = j;
  810. p->array[j].index = j;
  811. ++j;
  812. }
  813. break;
  814. case kNonEvtScId: // parse note-on events
  815. if((rc = _cmScParseNoteOn(p, i, p->array, j, barNumb, barNoteIdx )) == kOkScRC )
  816. {
  817. secs = p->array[j].secs;
  818. if( p->array[j].secs == DBL_MAX )
  819. p->array[j].secs = cur_secs;
  820. if( cmIsFlag(p->array[j].flags,kSkipScFl) == false )
  821. {
  822. p->array[j].index = j;
  823. ++j;
  824. }
  825. ++barNoteIdx;
  826. }
  827. break;
  828. default:
  829. // Returns DBL_MAX on error.
  830. secs = cmCsvCellDouble(p->cH, i, kSecsColScIdx );
  831. break;
  832. }
  833. if( secs != DBL_MAX )
  834. cur_secs = secs;
  835. // form the section list
  836. if( j > 0 )
  837. if((rc = _cmScParseSectionColumn(p,i,j-1,p->sectList)) != kOkScRC )
  838. break;
  839. // the bar lines don't have times so set the time of the bar line to the
  840. // time of the first event in the bar.
  841. if( barEvtIdx != cmInvalidIdx && secs != DBL_MAX )
  842. {
  843. assert( p->array[ barEvtIdx ].type == kBarEvtScId );
  844. p->array[ barEvtIdx ].secs = secs;
  845. // handle the case where the previous bar had no events
  846. // BUG BUG BUG this is a hack which will fail if the first bar does not have events.
  847. if( barEvtIdx>=1 && p->array[ barEvtIdx-1].type == kBarEvtScId )
  848. p->array[ barEvtIdx-1].secs = secs;
  849. barEvtIdx = cmInvalidIdx;
  850. }
  851. }
  852. if( rc == kSyntaxErrScRC )
  853. {
  854. cmErrMsg(&p->err,rc,"Syntax error on line %i in '%s'.",i+1,cmStringNullGuard(fn));
  855. goto errLabel;
  856. }
  857. p->cnt = j;
  858. errLabel:
  859. return rc;
  860. }
  861. cmScRC_t _cmScInitLocArray( cmSc_t* p )
  862. {
  863. cmScRC_t rc = kOkScRC;
  864. double maxDSecs = 0; // max time between events that are considered simultaneous
  865. unsigned barNumb = 0;
  866. int i,j,k;
  867. if( p->cnt==0)
  868. return rc;
  869. p->locCnt = 1;
  870. // count the number of unique time locations in the score
  871. p->locCnt = 1;
  872. for(i=1; i<p->cnt; ++i )
  873. {
  874. if( p->array[i].secs < p->array[i-1].secs )
  875. 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);
  876. if( (p->array[i].secs - p->array[i-1].secs) > maxDSecs )
  877. ++p->locCnt;
  878. }
  879. if( rc != kOkScRC )
  880. return rc;
  881. // allocate the loc. array
  882. p->loc = cmMemAllocZ(cmScoreLoc_t,p->locCnt);
  883. // fill in the location array
  884. for(i=0,k=0; i<p->cnt; ++k)
  885. {
  886. j = i+1;
  887. // get the count of events at this location
  888. while( j<p->cnt && p->array[j].secs - p->array[j-1].secs <= maxDSecs )
  889. ++j;
  890. assert(k<p->locCnt);
  891. p->loc[k].index = k;
  892. p->loc[k].evtCnt = j-i;
  893. p->loc[k].evtArray = cmMemAllocZ(cmScoreEvt_t*,p->loc[k].evtCnt);
  894. // fill in the location record event pointers
  895. for(j=0; j<p->loc[k].evtCnt; ++j)
  896. {
  897. p->loc[k].evtArray[j] = p->array + (i + j);
  898. p->loc[k].evtArray[j]->locIdx = k;
  899. if( p->array[i+j].type == kBarEvtScId )
  900. barNumb = p->array[i+j].barNumb;
  901. }
  902. // fill in the location record
  903. p->loc[k].secs = p->array[i].secs;
  904. p->loc[k].barNumb = barNumb;
  905. i += p->loc[k].evtCnt;
  906. }
  907. assert( p->locCnt == k );
  908. return rc;
  909. }
  910. 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 )
  911. {
  912. cmScRC_t rc = kOkScRC;
  913. if((rc = cmScoreFinalize(hp)) != kOkScRC )
  914. return rc;
  915. cmSc_t* p = cmMemAllocZ(cmSc_t,1);
  916. cmErrSetup(&p->err,&ctx->rpt,"Score");
  917. p->stH = stH;
  918. if((rc = _cmScParseFile(p,ctx,fn)) != kOkScRC )
  919. goto errLabel;
  920. if((rc = _cmScInitLocArray(p)) != kOkScRC )
  921. goto errLabel;
  922. if((rc = _cmScProcSections(p,p->sectList)) != kOkScRC )
  923. goto errLabel;
  924. // load the dynamic reference array
  925. if( dynRefArray != NULL && dynRefCnt > 0)
  926. {
  927. unsigned n = _cmScDynLabelCount();
  928. if( dynRefCnt != n )
  929. {
  930. rc = cmErrMsg(&p->err,kInvalidDynRefCntScRC,"The count of dynamics labels must be %i not %i.",n,dynRefCnt);
  931. goto errLabel;
  932. }
  933. p->dynRefArray = cmMemAllocZ(unsigned,dynRefCnt);
  934. memcpy(p->dynRefArray,dynRefArray,sizeof(unsigned)*dynRefCnt);
  935. p->dynRefCnt = dynRefCnt;
  936. }
  937. p->srate = srate;
  938. p->cbFunc = cbFunc;
  939. p->cbArg = cbArg;
  940. p->fn = cmMemAllocStr(fn);
  941. p->nxtLocIdx = 0;
  942. p->minSetLocIdx = cmInvalidIdx;
  943. p->maxSetLocIdx = cmInvalidIdx;
  944. hp->h = p;
  945. cmScoreClearPerfInfo(*hp);
  946. //cmScorePrintLoc(*hp);
  947. errLabel:
  948. if( rc != kOkScRC )
  949. _cmScFinalize(p);
  950. return rc;
  951. }
  952. cmScRC_t cmScoreFinalize( cmScH_t* hp )
  953. {
  954. cmScRC_t rc = kOkScRC;
  955. if( hp == NULL || cmScoreIsValid(*hp) == false )
  956. return kOkScRC;
  957. cmSc_t* p = _cmScHandleToPtr(*hp);
  958. if((rc = _cmScFinalize(p)) != kOkScRC )
  959. return rc;
  960. hp->h = NULL;
  961. return rc;
  962. }
  963. const cmChar_t* cmScoreFileName( cmScH_t h )
  964. {
  965. cmSc_t* p = _cmScHandleToPtr(h);
  966. return p->fn;
  967. }
  968. double cmScoreSampleRate( cmScH_t h )
  969. {
  970. cmSc_t* p = _cmScHandleToPtr(h);
  971. return p->srate;
  972. }
  973. bool cmScoreIsValid( cmScH_t h )
  974. { return h.h != NULL; }
  975. unsigned cmScoreEvtCount( cmScH_t h )
  976. {
  977. cmSc_t* p = _cmScHandleToPtr(h);
  978. return p->cnt;
  979. }
  980. cmScoreEvt_t* cmScoreEvt( cmScH_t h, unsigned idx )
  981. {
  982. cmSc_t* p = _cmScHandleToPtr(h);
  983. if( idx >= p->cnt )
  984. {
  985. cmErrMsg(&p->err,kInvalidIdxScRC,"%i is an invalid index for %i records.",idx,p->cnt);
  986. return NULL;
  987. }
  988. return p->array + idx;
  989. }
  990. unsigned cmScoreSectionCount( cmScH_t h )
  991. {
  992. cmSc_t* p = _cmScHandleToPtr(h);
  993. return p->sectCnt;
  994. }
  995. cmScoreSection_t* cmScoreSection( cmScH_t h, unsigned idx )
  996. {
  997. cmSc_t* p = _cmScHandleToPtr(h);
  998. assert( idx < p->sectCnt);
  999. return p->sect + idx;
  1000. }
  1001. unsigned cmScoreLocCount( cmScH_t h )
  1002. {
  1003. cmSc_t* p = _cmScHandleToPtr(h);
  1004. return p->locCnt;
  1005. }
  1006. cmScoreLoc_t* cmScoreLoc( cmScH_t h, unsigned idx )
  1007. {
  1008. cmSc_t* p = _cmScHandleToPtr(h);
  1009. if( idx >= p->locCnt )
  1010. {
  1011. cmErrMsg(&p->err,kInvalidIdxScRC,"%i is an invalid index for %i location records.",idx,p->locCnt);
  1012. return NULL;
  1013. }
  1014. return p->loc + idx;
  1015. }
  1016. void cmScorePrintLoc( cmScH_t h )
  1017. {
  1018. unsigned i = 0;
  1019. cmSc_t* p = _cmScHandleToPtr(h);
  1020. unsigned colCnt = 10;
  1021. int bufCharCnt = 4;
  1022. char buf[ bufCharCnt ];
  1023. const char* emptyStr = " ";
  1024. // for each set of 'colCnt' columns
  1025. for(i=0; i<p->locCnt; i+=colCnt )
  1026. {
  1027. // print the location 'index' line
  1028. unsigned c,j,k;
  1029. printf("index: ");
  1030. for(c=0,j=i; j<p->locCnt && c<colCnt; ++c,++j)
  1031. printf("%7i ",j);
  1032. printf("\n");
  1033. // print the 'sectn' label line
  1034. printf("sectn: ");
  1035. for(c=0,j=i; j<p->locCnt && c<colCnt; ++c,++j)
  1036. if( p->loc[j].begSectPtr==NULL )
  1037. printf("%s",emptyStr);
  1038. else
  1039. printf("%7s ",p->loc[j].begSectPtr->label);
  1040. printf("\n");
  1041. // calculate the max number of simultan. events at any one location
  1042. // for this set of 'colCnt' columns.
  1043. unsigned n=0;
  1044. for(c=0,j=i; j<p->locCnt && c<colCnt; ++c,++j)
  1045. if( p->loc[j].evtCnt > n )
  1046. n = p->loc[j].evtCnt;
  1047. // for each 'sco' line
  1048. for(k=0; k<n; ++k)
  1049. {
  1050. printf("sco%2i: ",k);
  1051. for(c=0,j=i; j<p->locCnt && c<colCnt; ++c,++j)
  1052. if( k >= p->loc[j].evtCnt )
  1053. printf("%s",emptyStr);
  1054. else
  1055. {
  1056. switch(p->loc[j].evtArray[k]->type)
  1057. {
  1058. case kBarEvtScId:
  1059. printf(" |%3i ",p->loc[j].evtArray[k]->barNumb);
  1060. break;
  1061. case kNonEvtScId:
  1062. {
  1063. int bn=16;
  1064. char b[bn];
  1065. strcpy(b,cmMidiToSciPitch(p->loc[j].evtArray[k]->pitch,NULL,0));
  1066. strcat(b,_cmScFlagsToStr( p->loc[j].evtArray[k]->flags,buf,bufCharCnt));
  1067. assert(strlen(b)<bn);
  1068. printf("%7s ",b);
  1069. break;
  1070. }
  1071. }
  1072. }
  1073. printf("\n");
  1074. }
  1075. // calc the max number of set triggers which will occur on
  1076. // any one location for this set of 'colCnt' columns.
  1077. n=0;
  1078. for(c=0,j=i; j<p->locCnt && c<colCnt; ++c,++j)
  1079. if(p->loc[j].begSectPtr != NULL && p->loc[j].begSectPtr->setCnt > n )
  1080. n = p->loc[j].begSectPtr->setCnt;
  1081. for(k=0; k<n; ++k)
  1082. {
  1083. printf("trig%1i: ",k);
  1084. for(c=0,j=i; j<p->locCnt && c<colCnt; ++c,++j)
  1085. {
  1086. if( p->loc[j].begSectPtr != NULL && k<p->loc[j].begSectPtr->setCnt )
  1087. {
  1088. const cmScoreSet_t* sp = p->loc[j].begSectPtr->setArray[k];
  1089. printf(" %3s-%c ",p->loc[j].begSectPtr->label,_cmScVarIdToChar(sp->varId) );
  1090. }
  1091. else
  1092. {
  1093. printf("%s",emptyStr);
  1094. }
  1095. }
  1096. printf("\n");
  1097. }
  1098. printf("\n");
  1099. }
  1100. }
  1101. unsigned cmScoreSetCount( cmScH_t h )
  1102. {
  1103. cmSc_t* p = _cmScHandleToPtr(h);
  1104. return p->setCnt;
  1105. }
  1106. cmScRC_t cmScoreSeqNotify( cmScH_t h )
  1107. {
  1108. cmScRC_t rc = kOkScRC;
  1109. cmSc_t* p = _cmScHandleToPtr(h);
  1110. cmScMsg_t m;
  1111. unsigned i;
  1112. if( p->cbFunc != NULL )
  1113. {
  1114. memset(&m.u.evt,0,sizeof(m.u.evt));
  1115. m.typeId = kBeginMsgScId;
  1116. p->cbFunc(p->cbArg,&m,sizeof(m));
  1117. m.typeId = kEventMsgScId;
  1118. for(i=0; i<p->cnt; ++i)
  1119. {
  1120. m.u.evt = p->array[i];
  1121. p->cbFunc(p->cbArg,&m,sizeof(m));
  1122. }
  1123. m.typeId = kSectionMsgScId;
  1124. for(i=0; i<p->sectCnt; ++i)
  1125. {
  1126. m.u.sect = p->sect[i];
  1127. p->cbFunc(p->cbArg,&m,sizeof(m));
  1128. }
  1129. memset(&m.u.evt,0,sizeof(m.u.evt));
  1130. m.typeId = kEndMsgScId;
  1131. p->cbFunc(p->cbArg,&m,sizeof(m));
  1132. }
  1133. return rc;
  1134. }
  1135. void cmScoreClearPerfInfo( cmScH_t h )
  1136. {
  1137. cmSc_t* p = _cmScHandleToPtr(h);
  1138. unsigned i;
  1139. for(i=0; i<p->cnt; ++i)
  1140. {
  1141. p->array[i].perfSmpIdx = cmInvalidIdx;
  1142. p->array[i].perfVel = 0;
  1143. p->array[i].perfDynLvl = 0;
  1144. }
  1145. for(i=0; i<p->locCnt; ++i)
  1146. {
  1147. cmScoreSet_t* sp = p->loc[i].setList;
  1148. for(; sp!=NULL; sp=sp->llink)
  1149. sp->doneFl = false;
  1150. }
  1151. for(i=0; i<p->sectCnt; ++i)
  1152. {
  1153. unsigned j;
  1154. for(j=0; j<kScVarCnt; ++j)
  1155. p->sect[i].vars[j] = DBL_MAX;
  1156. }
  1157. p->nxtLocIdx = 0;
  1158. p->minSetLocIdx = cmInvalidIdx;
  1159. p->maxSetLocIdx = cmInvalidIdx;
  1160. }
  1161. bool _cmScIsSetPerfDone( cmScoreSet_t* sp )
  1162. {
  1163. unsigned i = 0;
  1164. for(i=0; i<sp->eleCnt; ++i)
  1165. if( sp->eleArray[i]->perfSmpIdx == cmInvalidIdx )
  1166. return false;
  1167. return true;
  1168. }
  1169. void _cmScPerfSortTimes( unsigned *v, unsigned n )
  1170. {
  1171. unsigned i;
  1172. bool fl = true;
  1173. while(fl && n)
  1174. {
  1175. fl = false;
  1176. for(i=1; i<n; ++i)
  1177. {
  1178. if( v[i-1] > v[i] )
  1179. {
  1180. unsigned t = v[i-1];
  1181. v[i-1] = v[i];
  1182. v[i] = t;
  1183. fl = true;
  1184. }
  1185. }
  1186. --n;
  1187. }
  1188. }
  1189. bool _cmScPerfEven(cmSc_t* p, cmScoreSet_t* stp, bool printMissFl)
  1190. {
  1191. unsigned i = 0;
  1192. double u = 0;
  1193. double x = 0;
  1194. bool sortFl = false;
  1195. bool printFl = true;
  1196. unsigned v[ stp->eleCnt ];
  1197. unsigned d[ stp->eleCnt - 1];
  1198. assert( stp->eleCnt > 1 );
  1199. // calculate the sum of the time between events
  1200. for(i=0; i<stp->eleCnt; ++i)
  1201. {
  1202. // if this event was not received - then the set is not valid
  1203. if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx )
  1204. {
  1205. if( printFl && printMissFl)
  1206. printf("EVENESS: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0));
  1207. return false;
  1208. }
  1209. // load v[i]
  1210. v[i] = stp->eleArray[i]->perfSmpIdx;
  1211. // check for out of order elements
  1212. if( i> 0 )
  1213. if( v[i] < v[i-1] )
  1214. sortFl = true;
  1215. }
  1216. // sort the times in ascending order
  1217. if( sortFl )
  1218. _cmScPerfSortTimes(v,stp->eleCnt);
  1219. // calc the sum of time differences
  1220. for(i=1; i<stp->eleCnt; ++i)
  1221. u += d[i-1] = v[i] - v[i-1];
  1222. // calculate the average time between events
  1223. u /= stp->eleCnt-1;
  1224. // calculate the std-dev of the time between events
  1225. for(i=0; i<stp->eleCnt-1; ++i)
  1226. x += (d[i]-u)*(d[i]-u);
  1227. double sd = sqrt(x/(stp->eleCnt-1));
  1228. // compute the average z-score
  1229. double c = 0;
  1230. for(i=0; i<stp->eleCnt-1; ++i)
  1231. c += fabs(d[i]-u)/sd;
  1232. stp->value = c/(stp->eleCnt-1);
  1233. stp->doneFl = true;
  1234. if(printFl)
  1235. {
  1236. /*
  1237. for(i=0; i<stp->eleCnt; ++i)
  1238. {
  1239. printf("%i %i ",i,v[i]);
  1240. if( i > 0 )
  1241. printf("%i ", d[i-1]);
  1242. printf("\n");
  1243. }
  1244. */
  1245. printf("%s EVENESS:%f\n",sortFl?"SORTED ":"",stp->value);
  1246. }
  1247. return true;
  1248. }
  1249. bool _cmScPerfDyn( cmSc_t* p, cmScoreSet_t* stp, bool printMissFl)
  1250. {
  1251. double a = 0;
  1252. unsigned i = 0;
  1253. bool printFl = true;
  1254. for(i=0; i<stp->eleCnt; ++i)
  1255. {
  1256. unsigned j;
  1257. // if this event was not received - then the set is not valid
  1258. if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx )
  1259. {
  1260. if( printFl && printMissFl )
  1261. printf("DYNAMICS: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0));
  1262. return false;
  1263. }
  1264. unsigned m = 0; // lower bound for the first dyn. category
  1265. // determine the dynamic category for the performed velocity of each event
  1266. for(j=0; j<p->dynRefCnt; ++j)
  1267. {
  1268. // if the vel fall's into the jth dyn. category
  1269. if( m <= stp->eleArray[i]->perfVel && stp->eleArray[i]->perfVel < p->dynRefArray[j] )
  1270. break;
  1271. // store the min vel for the next dyn category
  1272. m = p->dynRefArray[j];
  1273. }
  1274. assert( j < p->dynRefCnt );
  1275. stp->eleArray[i]->perfDynLvl = j+1;
  1276. a += abs((j+1) - stp->eleArray[i]->dynVal);
  1277. if( p->cbFunc != NULL )
  1278. {
  1279. cmScMsg_t m;
  1280. m.typeId = kDynMsgScId;
  1281. m.u.dyn.evtIdx = stp->eleArray[i]->index;
  1282. m.u.dyn.dynLvl = stp->eleArray[i]->perfDynLvl;
  1283. p->cbFunc(p->cbArg,&m,sizeof(m));
  1284. }
  1285. }
  1286. stp->value = a / stp->eleCnt;
  1287. stp->doneFl = true;
  1288. if( printFl )
  1289. printf("DYNAMICS:%f\n",stp->value);
  1290. return true;
  1291. }
  1292. bool _cmScPerfTempo1(cmSc_t* p, cmScoreSet_t* stp, bool printMissFl)
  1293. {
  1294. bool printFl = true;
  1295. unsigned durSmpCnt = 0;
  1296. double durBeats = 0;
  1297. int i;
  1298. for(i=0; i<stp->eleCnt; ++i)
  1299. {
  1300. // if this event was not received - then the set is not valid
  1301. if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx )
  1302. {
  1303. if( printFl && printMissFl )
  1304. printf("TEMPO: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0));
  1305. return false;
  1306. }
  1307. if( i > 0 )
  1308. durSmpCnt += stp->eleArray[i]->perfSmpIdx - stp->eleArray[i-1]->perfSmpIdx;
  1309. durBeats += stp->eleArray[i]->frac;
  1310. }
  1311. stp->value = durBeats / (durSmpCnt / p->srate*60.0 );
  1312. stp->doneFl = true;
  1313. if( printFl )
  1314. printf("TEMPO:%f\n",stp->value);
  1315. return true;
  1316. }
  1317. bool _cmScPerfTempo(cmSc_t* p, cmScoreSet_t* stp, bool printMissFl)
  1318. {
  1319. bool printFl = true;
  1320. unsigned durSmpCnt = 0;
  1321. double durBeats = 0;
  1322. int i;
  1323. unsigned bi = cmInvalidIdx;
  1324. unsigned ei = cmInvalidIdx;
  1325. unsigned missCnt = 0;
  1326. for(i=0; i<stp->eleCnt; ++i)
  1327. {
  1328. // if this event was not received - then the set is not valid
  1329. if( stp->eleArray[i]->perfSmpIdx == cmInvalidIdx )
  1330. {
  1331. ++missCnt;
  1332. if( printFl && printMissFl )
  1333. printf("TEMPO: missing loc:%i %s\n",stp->eleArray[i]->locIdx,cmMidiToSciPitch(stp->eleArray[i]->pitch,NULL,0));
  1334. }
  1335. else
  1336. {
  1337. if( bi == cmInvalidIdx )
  1338. bi = i;
  1339. ei = i;
  1340. }
  1341. }
  1342. if( ei > bi )
  1343. {
  1344. for(i=bi; i<=ei; ++i)
  1345. durBeats += stp->eleArray[i]->frac;
  1346. durSmpCnt = stp->eleArray[ei]->perfSmpIdx - stp->eleArray[bi]->perfSmpIdx;
  1347. stp->value = durBeats / (durSmpCnt / (p->srate*60.0) );
  1348. stp->doneFl = true;
  1349. }
  1350. if( printFl )
  1351. printf("TEMPO:%f bi:%i ei:%i secs:%f bts:%f\n",stp->value,bi,ei,durSmpCnt/p->srate,durBeats);
  1352. return true;
  1353. }
  1354. void _cmScPerfExec( cmSc_t* p, cmScoreSet_t* sp, bool printMissFl )
  1355. {
  1356. if( sp->doneFl == false )
  1357. {
  1358. switch( sp->varId )
  1359. {
  1360. case kEvenVarScId:
  1361. _cmScPerfEven(p,sp,printMissFl);
  1362. break;
  1363. case kDynVarScId:
  1364. _cmScPerfDyn(p,sp,printMissFl);
  1365. break;
  1366. case kTempoVarScId:
  1367. _cmScPerfTempo(p,sp,printMissFl);
  1368. break;
  1369. default:
  1370. { assert(0); }
  1371. }
  1372. }
  1373. }
  1374. void _cmScPerfExecRange( cmSc_t* p )
  1375. {
  1376. if( p->minSetLocIdx == cmInvalidIdx || p->maxSetLocIdx==cmInvalidIdx )
  1377. return;
  1378. unsigned i = p->minSetLocIdx;
  1379. for(; i<=p->maxSetLocIdx; ++i)
  1380. {
  1381. cmScoreSet_t* sp = p->loc[i].setList;
  1382. for(; sp!=NULL; sp=sp->llink)
  1383. _cmScPerfExec(p,sp,true);
  1384. }
  1385. }
  1386. bool _cmScSetPerfEvent( cmSc_t* p, unsigned locIdx, unsigned smpIdx, unsigned pitch, unsigned vel )
  1387. {
  1388. assert(locIdx < p->locCnt );
  1389. cmScoreLoc_t* lp = p->loc + locIdx;
  1390. bool foundFl = false;
  1391. bool doneFl = true;
  1392. unsigned i;
  1393. // locate the event at the loc[locIdx]
  1394. for(i=0; i<lp->evtCnt; ++i)
  1395. {
  1396. cmScoreEvt_t* ep = lp->evtArray[i];
  1397. if( ep->type == kNonEvtScId )
  1398. {
  1399. if( ep->pitch == pitch )
  1400. {
  1401. assert( ep->perfSmpIdx == cmInvalidIdx );
  1402. ep->perfSmpIdx = smpIdx;
  1403. ep->perfVel = vel;
  1404. foundFl = true;
  1405. }
  1406. // check if all notes have arrived for this location
  1407. if( ep->perfSmpIdx == cmInvalidIdx )
  1408. doneFl = false;
  1409. }
  1410. }
  1411. // the event must always be found
  1412. assert( foundFl );
  1413. return doneFl;
  1414. }
  1415. bool cmScoreSetPerfEvent( cmScH_t h, unsigned locIdx, unsigned smpIdx, unsigned pitch, unsigned vel )
  1416. {
  1417. cmSc_t* p = _cmScHandleToPtr(h);
  1418. return _cmScSetPerfEvent(p,locIdx,smpIdx,pitch,vel);
  1419. }
  1420. void cmScoreExecPerfEvent( cmScH_t h, unsigned locIdx, unsigned smpIdx, unsigned pitch, unsigned vel )
  1421. {
  1422. unsigned i;
  1423. cmSc_t* p = _cmScHandleToPtr(h);
  1424. bool doneFl = _cmScSetPerfEvent(p,locIdx,smpIdx,pitch,vel);
  1425. unsigned printLvl = 1;
  1426. cmScoreLoc_t* lp = p->loc + locIdx;
  1427. // all events for a location must be complete to trigger attached events
  1428. if( doneFl == false )
  1429. return;
  1430. if( p->loc[locIdx].setList != NULL )
  1431. {
  1432. // set idx of most recent loc w/ a set end event
  1433. p->maxSetLocIdx = locIdx;
  1434. if( p->minSetLocIdx == cmInvalidIdx )
  1435. p->minSetLocIdx = locIdx;
  1436. }
  1437. // attempt to calculate all sets between loc[p->minSetLocIdx] and loc[p->maxSetLocIdx]
  1438. _cmScPerfExecRange(p);
  1439. // prevent event retriggering or going backwards
  1440. if( printLvl && locIdx < p->nxtLocIdx )
  1441. {
  1442. printf("----- BACK ----- \n");
  1443. return;
  1444. }
  1445. if( printLvl && locIdx > p->nxtLocIdx )
  1446. {
  1447. printf("----- SKIP ----- \n");
  1448. }
  1449. // for each location between the current and previous location
  1450. for(; p->nxtLocIdx<=locIdx; ++p->nxtLocIdx)
  1451. {
  1452. lp = p->loc + p->nxtLocIdx;
  1453. // if this location is the start of a new section - then apply
  1454. // sets that are assigned to this section
  1455. if( lp->begSectPtr != NULL && lp->begSectPtr->setCnt > 0 )
  1456. {
  1457. // notice the location of the oldest section start - once we cross this point
  1458. // it is too late to notice set completions - so incr p->inSetLocIdx
  1459. if( lp->begSectPtr->setCnt )
  1460. p->minSetLocIdx = p->nxtLocIdx+1;
  1461. for(i=0; i<lp->begSectPtr->setCnt; ++i)
  1462. {
  1463. cmScoreSet_t* stp = lp->begSectPtr->setArray[i];
  1464. // temporarily commented out for testing purposes
  1465. // if( stp->doneFl == false )
  1466. // _cmScPerfExec(p, stp, printLvl>0 );
  1467. if( stp->doneFl )
  1468. {
  1469. assert( stp->varId < kScVarCnt );
  1470. lp->begSectPtr->vars[ stp->varId ] = stp->value;
  1471. if( p->cbFunc != NULL )
  1472. {
  1473. cmScMsg_t m;
  1474. m.typeId = kVarMsgScId;
  1475. m.u.meas.varId = stp->varId;
  1476. m.u.meas.value = stp->value;
  1477. p->cbFunc(p->cbArg,&m,sizeof(m));
  1478. }
  1479. }
  1480. }
  1481. }
  1482. }
  1483. }
  1484. void cmScoreSetPerfValue( cmScH_t h, unsigned locIdx, unsigned varId, double value )
  1485. {
  1486. cmSc_t* p = _cmScHandleToPtr(h);
  1487. int li = locIdx;
  1488. for(; li>=0; --li)
  1489. if( p->loc[li].begSectPtr != NULL )
  1490. {
  1491. assert( varId < kScVarCnt );
  1492. p->loc[li].begSectPtr->vars[varId] = value;
  1493. break;
  1494. }
  1495. assert( li>=0);
  1496. }
  1497. void cmScoreSetPerfDynLevel( cmScH_t h, unsigned evtIdx, unsigned dynLvl )
  1498. {
  1499. cmSc_t* p = _cmScHandleToPtr(h);
  1500. assert(evtIdx < p->cnt );
  1501. p->array[ evtIdx ].perfDynLvl = dynLvl;
  1502. }
  1503. cmScRC_t cmScoreDecode( const void* msg, unsigned msgByteCnt, cmScMsg_t* m)
  1504. {
  1505. cmScMsg_t* mp = (cmScMsg_t*)msg;
  1506. *m = *mp;
  1507. return kOkScRC;
  1508. }
  1509. void cmScorePrint( cmScH_t h, cmRpt_t* rpt )
  1510. {
  1511. cmSc_t* p = _cmScHandleToPtr(h);
  1512. unsigned i;
  1513. for(i=0; i<20 /*p->cnt*/; ++i)
  1514. {
  1515. cmScoreEvt_t* r = p->array + i;
  1516. switch(r->type)
  1517. {
  1518. case kNonEvtScId:
  1519. cmRptPrintf(rpt,"%5i %3i %3i %s 0x%2x %c%c%c %s\n",
  1520. i,
  1521. r->barNumb,
  1522. r->barNoteIdx,
  1523. cmScEvtTypeIdToLabel(r->type),
  1524. r->pitch,
  1525. cmIsFlag(r->flags,kEvenScFl) ? 'e' : ' ',
  1526. cmIsFlag(r->flags,kTempoScFl) ? 't' : ' ',
  1527. cmIsFlag(r->flags,kDynScFl) ? 'd' : ' ',
  1528. cmIsFlag(r->flags,kDynScFl) ? cmScDynIdToLabel(r->dynVal) : "");
  1529. break;
  1530. default:
  1531. break;
  1532. }
  1533. }
  1534. }
  1535. void cmScoreTest( cmCtx_t* ctx, const cmChar_t* fn )
  1536. {
  1537. cmScH_t h = cmScNullHandle;
  1538. if( cmScoreInitialize(ctx,&h,fn,0,NULL,0,NULL,NULL, cmSymTblNullHandle ) != kOkScRC )
  1539. return;
  1540. cmScorePrint(h,&ctx->rpt);
  1541. cmScoreFinalize(&h);
  1542. }
  1543. // 1. Fix absolute message time which was incorrect on original score file.
  1544. // 2.
  1545. void cmScoreFix( cmCtx_t* ctx )
  1546. {
  1547. const cmChar_t* mfn = "/home/kevin/src/cmgv/src/gv/data/ImaginaryThemes.mid";
  1548. const cmChar_t* crfn = "/home/kevin/src/cmgv/src/gv/data/mod0a.txt";
  1549. const cmChar_t* cwfn = "/home/kevin/src/cmgv/src/gv/data/mod1.csv";
  1550. cmMidiFileH_t mfH = cmMidiFileNullHandle;
  1551. cmCsvH_t csvH = cmCsvNullHandle;
  1552. const cmMidiTrackMsg_t** msg = NULL;
  1553. double secs = 0.0;
  1554. int ci,mi,crn,mn;
  1555. bool errFl = true;
  1556. unsigned handCnt = 0;
  1557. unsigned midiMissCnt = 0;
  1558. if( cmCsvInitialize(&csvH,ctx) != kOkCsvRC )
  1559. goto errLabel;
  1560. if( cmCsvLexRegisterMatcher(csvH, cmCsvLexNextAvailId(csvH), _cmScLexSciPitchMatcher ) != kOkCsvRC )
  1561. goto errLabel;
  1562. if( cmCsvParseFile(csvH, crfn, 0 ) != kOkCsvRC )
  1563. goto errLabel;
  1564. if( cmMidiFileOpen(mfn,&mfH,ctx) != kOkMfRC )
  1565. goto errLabel;
  1566. cmMidiFileTickToMicros(mfH);
  1567. cmMidiFileCalcNoteDurations(mfH);
  1568. mn = cmMidiFileMsgCount(mfH);
  1569. msg = cmMidiFileMsgArray(mfH);
  1570. crn = cmCsvRowCount(csvH);
  1571. // for each row in the score file
  1572. for(ci=1,mi=0; ci<crn && cmCsvLastRC(csvH)==kOkCsvRC; ++ci)
  1573. {
  1574. unsigned id;
  1575. // zero the duration column
  1576. if( cmCsvCellPtr(csvH, ci, kDSecsColScIdx ) != NULL )
  1577. cmCsvSetCellUInt( csvH, ci, kDSecsColScIdx, 0 );
  1578. // get the MIDI file event id for this row
  1579. if((id = cmCsvCellUInt(csvH,ci,kMidiFileIdColScIdx)) == UINT_MAX)
  1580. {
  1581. // this is a hand-entered event - so it has no event id
  1582. ++handCnt;
  1583. }
  1584. else
  1585. {
  1586. for(; mi<mn; ++mi)
  1587. {
  1588. const cmMidiTrackMsg_t* m = msg[mi];
  1589. assert( mi+1 <= id );
  1590. secs += m->dtick/1000000.0;
  1591. if( mi+1 != id )
  1592. {
  1593. if( m->status == kNoteOnMdId && m->u.chMsgPtr->d1>0 )
  1594. {
  1595. // this MIDI note-on does not have a corresponding score event
  1596. ++midiMissCnt;
  1597. }
  1598. }
  1599. else
  1600. {
  1601. cmCsvSetCellDouble( csvH, ci, kSecsColScIdx, secs );
  1602. ++mi;
  1603. if( m->status == kNoteOnMdId )
  1604. cmCsvSetCellDouble( csvH, ci, kDSecsColScIdx, m->u.chMsgPtr->durTicks/1000000.0 );
  1605. break;
  1606. }
  1607. }
  1608. if( mi==mn)
  1609. printf("done on row:%i\n",ci);
  1610. }
  1611. }
  1612. if( cmCsvLastRC(csvH) != kOkCsvRC )
  1613. goto errLabel;
  1614. if( cmCsvWrite(csvH,cwfn) != kOkCsvRC )
  1615. goto errLabel;
  1616. errFl = false;
  1617. errLabel:
  1618. if( errFl )
  1619. printf("Score fix failed.\n");
  1620. else
  1621. printf("Score fix done! hand:%i miss:%i\n",handCnt,midiMissCnt);
  1622. cmMidiFileClose(&mfH);
  1623. cmCsvFinalize(&csvH);
  1624. }