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.

cmSyncRecd.c 14KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563
  1. #include "cmGlobal.h"
  2. #include "cmFloatTypes.h"
  3. #include "cmRpt.h"
  4. #include "cmErr.h"
  5. #include "cmCtx.h"
  6. #include "cmMem.h"
  7. #include "cmMallocDebug.h"
  8. #include "cmTime.h"
  9. #include "cmFile.h"
  10. #include "cmAudioFile.h"
  11. #include "cmSyncRecd.h"
  12. #include "cmVectOpsTemplateMain.h"
  13. #include "cmMidi.h"
  14. typedef enum
  15. {
  16. kInvalidSrId,
  17. kMidiSrId,
  18. kAudioSrId
  19. } cmSrTypeId_t;
  20. typedef struct cmSrMidi_str
  21. {
  22. cmTimeSpec_t timestamp;
  23. unsigned status;
  24. unsigned d0;
  25. unsigned d1;
  26. } cmSrMidi_t;
  27. typedef struct cmSrAudio_str
  28. {
  29. cmTimeSpec_t timestamp;
  30. unsigned smpIdx;
  31. } cmSrAudio_t;
  32. typedef struct cmSrRecd_str
  33. {
  34. cmSrTypeId_t tid;
  35. union
  36. {
  37. cmSrMidi_t m;
  38. cmSrAudio_t a;
  39. } u;
  40. } cmSrRecd_t;
  41. enum
  42. {
  43. kReadSrFl = 0x01, // This is a read (not a write) file
  44. kFileUUSrId = 0xf00d
  45. };
  46. typedef struct cmSr_str
  47. {
  48. cmErr_t err;
  49. cmFileH_t fH;
  50. cmAudioFileH_t afH;
  51. unsigned flags; // See kXXXSrFl
  52. cmSrRecd_t* cache; // cache[cn]
  53. cmSrAudio_t* map; //
  54. unsigned cn; // count of records in cache[].
  55. unsigned ci; // next cache recd index
  56. unsigned fn; // count of recds written to file
  57. long offs;
  58. cmAudioFileInfo_t afInfo;
  59. } cmSr_t;
  60. cmSyncRecdH_t cmSyncRecdNullHandle = cmSTATIC_NULL_HANDLE;
  61. cmSr_t* _cmSrHtoP( cmSyncRecdH_t h )
  62. {
  63. cmSr_t* p = (cmSr_t*)h.h;
  64. assert(p!=NULL);
  65. return p;
  66. }
  67. cmSrRC_t _cmSrWriteCache( cmSr_t* p )
  68. {
  69. if( cmFileWrite(p->fH,p->cache,p->ci * sizeof(cmSrRecd_t)) != kOkFileRC )
  70. return cmErrMsg(&p->err,kFileFailSrRC,"File write failed.");
  71. p->fn += p->ci;
  72. p->ci = 0;
  73. return kOkSrRC;
  74. }
  75. cmSrRC_t _cmSrFinal( cmSr_t* p )
  76. {
  77. cmSrRC_t rc = kOkSrRC;
  78. // write any remaining cache records
  79. if( cmIsFlag(p->flags,kReadSrFl) == false )
  80. {
  81. if((rc = _cmSrWriteCache(p)) == kOkSrRC )
  82. {
  83. if(cmFileSeek(p->fH,kBeginFileFl,p->offs) != kOkFileRC )
  84. rc = cmErrMsg(&p->err,kFileFailSrRC, "File seek fail on file offset positioning.");
  85. else
  86. if(cmFileWriteUInt(p->fH,&p->fn,1) != kOkFileRC )
  87. rc = cmErrMsg(&p->err,kFileFailSrRC, "File write failed on record count.");
  88. }
  89. }
  90. // release the audio file object
  91. if( cmAudioFileIsValid(p->afH) )
  92. if( cmAudioFileDelete(&p->afH) != kOkAfRC )
  93. return cmErrMsg(&p->err,kAudioFileFailSrRC,"Audio file object delete failed.");
  94. // release the sync-recd file object
  95. if( cmFileIsValid(p->fH) )
  96. if( cmFileClose(&p->fH) != kOkFileRC )
  97. return cmErrMsg(&p->err,kFileFailSrRC,"File close failed.");
  98. cmMemFree(p->cache);
  99. cmMemFree(p->map);
  100. cmMemFree(p);
  101. return rc;
  102. }
  103. cmSr_t* _cmSrAlloc( cmCtx_t* ctx, unsigned flags )
  104. {
  105. cmSr_t* p = cmMemAllocZ(cmSr_t,1);
  106. cmErrSetup(&p->err,&ctx->rpt,"SyncRecd");
  107. p->cn = 2048;
  108. p->cache = cmMemAllocZ(cmSrRecd_t,p->cn);
  109. return p;
  110. }
  111. cmSrRC_t cmSyncRecdCreate( cmCtx_t* ctx, cmSyncRecdH_t* hp, const cmChar_t* srFn, const cmChar_t* audioFn, double srate, unsigned chCnt, unsigned bits )
  112. {
  113. cmSrRC_t rc = kOkSrRC;
  114. cmRC_t afRC = kOkAfRC;
  115. assert( audioFn != NULL );
  116. if((rc = cmSyncRecdFinal(hp)) != kOkSrRC )
  117. return rc;
  118. cmSr_t* p = _cmSrAlloc(ctx,0);
  119. if( cmFileOpen(&p->fH,srFn,kWriteFileFl,&ctx->rpt) != kOkFileRC )
  120. {
  121. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to create the sync-recd file '%s'.",cmStringNullGuard(srFn));
  122. goto errLabel;
  123. }
  124. if( cmAudioFileIsValid(p->afH = cmAudioFileNewCreate(audioFn,srate,bits,chCnt,&afRC,&ctx->rpt))==false)
  125. {
  126. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Unable to create the sync-recd audio file '%s'.",cmStringNullGuard(audioFn));
  127. goto errLabel;
  128. }
  129. unsigned fileUUId = kFileUUSrId;
  130. unsigned audioFnCnt = strlen(audioFn)+1;
  131. if( cmFileWriteUInt(p->fH,&fileUUId,1) != kOkFileRC )
  132. {
  133. rc = cmErrMsg(&p->err,kFileFailSrRC,"File write failed on UUID.");
  134. goto errLabel;
  135. }
  136. if( cmFileWriteUInt(p->fH,&audioFnCnt,1) != kOkFileRC )
  137. {
  138. rc = cmErrMsg(&p->err,kFileFailSrRC,"File write failed on audio file length write count.");
  139. goto errLabel;
  140. }
  141. if( cmFileWriteChar(p->fH,audioFn,audioFnCnt) != kOkFileRC )
  142. {
  143. rc = cmErrMsg(&p->err,kFileFailSrRC,"File write failed on audio file string.");
  144. goto errLabel;
  145. }
  146. if( cmFileTell(p->fH,&p->offs) != kOkFileRC )
  147. {
  148. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to determine file offset.");
  149. goto errLabel;
  150. }
  151. if( cmFileWriteUInt(p->fH,&p->fn,1) != kOkFileRC )
  152. {
  153. rc = cmErrMsg(&p->err,kFileFailSrRC,"File write failed on initial record count.");
  154. goto errLabel;
  155. }
  156. hp->h = p;
  157. errLabel:
  158. if( rc != kOkSrRC )
  159. _cmSrFinal(p);
  160. return rc;
  161. }
  162. cmSrRC_t cmSyncRecdOpen( cmCtx_t* ctx, cmSyncRecdH_t* hp, const cmChar_t* srFn )
  163. {
  164. cmSrRC_t rc = kOkSrRC;
  165. cmRC_t afRC = kOkAfRC;
  166. unsigned fileUUId = cmInvalidId;
  167. unsigned audioFnCnt = 0;
  168. cmChar_t* audioFn = NULL;
  169. unsigned i;
  170. unsigned acnt = 0;
  171. unsigned mcnt = 0;
  172. unsigned* tiV = NULL;
  173. if((rc = cmSyncRecdFinal(hp)) != kOkSrRC )
  174. return rc;
  175. cmSr_t* p = _cmSrAlloc(ctx,kReadSrFl);
  176. if( cmFileOpen(&p->fH,srFn,kReadFileFl,&ctx->rpt) != kOkFileRC )
  177. {
  178. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to open the sync-recd file '%s'.",cmStringNullGuard(srFn));
  179. goto errLabel;
  180. }
  181. if( cmFileReadUInt(p->fH,&fileUUId,1) != kOkFileRC )
  182. {
  183. rc = cmErrMsg(&p->err,kFileFailSrRC,"File read failed on UUId.");
  184. goto errLabel;
  185. }
  186. if( cmFileReadUInt(p->fH,&audioFnCnt,1) != kOkFileRC )
  187. {
  188. rc = cmErrMsg(&p->err,kFileFailSrRC,"File read failed on audio file name count.");
  189. goto errLabel;
  190. }
  191. audioFn = cmMemAllocZ(cmChar_t,audioFnCnt);
  192. if( cmFileReadChar(p->fH,audioFn,audioFnCnt) != kOkFileRC )
  193. {
  194. rc = cmErrMsg(&p->err,kFileFailSrRC,"File read failed on audio file string.");
  195. goto errLabel;
  196. }
  197. if( cmFileReadUInt(p->fH,&p->fn,1) != kOkFileRC )
  198. {
  199. rc = cmErrMsg(&p->err,kFileFailSrRC,"File read failed on record count.");
  200. goto errLabel;
  201. }
  202. // store the file offset to the first recd
  203. if( cmFileTell(p->fH,&p->offs) != kOkFileRC )
  204. {
  205. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to determine the current file offset.");
  206. goto errLabel;
  207. }
  208. // read each file - and count the types
  209. for(i=0; i<p->fn; ++i)
  210. {
  211. cmSrRecd_t r;
  212. if( cmFileRead(p->fH,&r,sizeof(r)) != kOkFileRC )
  213. {
  214. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to read the record at index %i.");
  215. goto errLabel;
  216. }
  217. switch(r.tid)
  218. {
  219. case kMidiSrId:
  220. mcnt += 1;
  221. break;
  222. case kAudioSrId:
  223. acnt += 1;
  224. break;
  225. default:
  226. { assert(0); }
  227. }
  228. }
  229. printf("%i %i = %i\n",mcnt,acnt,p->fn);
  230. // rewind to the begining of the records
  231. if( cmFileSeek(p->fH,kBeginFileFl,p->offs) != kOkFileRC )
  232. {
  233. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to seek to first recd offset.");
  234. goto errLabel;
  235. }
  236. // allocate space to hold the MIDI records
  237. p->cn = mcnt;
  238. p->ci = 0;
  239. p->cache = cmMemResizeZ(cmSrRecd_t,p->cache,p->cn);
  240. p->map = cmMemAllocZ(cmSrAudio_t,p->cn);
  241. tiV = cmMemAllocZ(unsigned,p->cn);
  242. for(i=0; p->ci<p->cn && i<p->fn; ++i)
  243. {
  244. if( cmFileRead(p->fH,p->cache + p->ci,sizeof(cmSrRecd_t)) != kOkFileRC )
  245. {
  246. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to read the record at index %i.");
  247. goto errLabel;
  248. }
  249. if( p->cache[p->ci].tid == kMidiSrId )
  250. p->ci += 1;
  251. }
  252. // assert that all the MIDI records were read
  253. assert( p->ci == p->cn);
  254. // rewind to the first recd
  255. if( cmFileSeek(p->fH,kBeginFileFl,p->offs) != kOkFileRC )
  256. {
  257. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to seek to first recd offset.");
  258. goto errLabel;
  259. }
  260. // for each recd in the file
  261. for(i=0; i<p->fn; ++i)
  262. {
  263. cmSrRecd_t r;
  264. if( cmFileRead(p->fH,&r,sizeof(r)) != kOkFileRC )
  265. {
  266. rc = cmErrMsg(&p->err,kFileFailSrRC,"Unable to read the record at index %i.");
  267. goto errLabel;
  268. }
  269. // if this is an audio record
  270. if( r.tid == kAudioSrId )
  271. {
  272. unsigned j;
  273. // for each midi record
  274. for(j=0; j<p->cn; ++j)
  275. {
  276. // measure the time interval between this midi and this audio recd
  277. unsigned time_interval_micros = cmTimeAbsElapsedMicros(&r.u.a.timestamp,&p->cache[j].u.m.timestamp);
  278. // if the audio recd is closer to this midi recd than prior audio records ...
  279. if( time_interval_micros < tiV[j] || i==0 )
  280. {
  281. // ... then store the audio time stamp in the map
  282. tiV[j] = time_interval_micros;
  283. p->map[j].timestamp = r.u.a.timestamp;
  284. p->map[j].smpIdx = r.u.a.smpIdx;
  285. }
  286. }
  287. }
  288. }
  289. // open the audio file
  290. if( cmAudioFileIsValid(p->afH = cmAudioFileNewOpen(audioFn,&p->afInfo,&afRC,&ctx->rpt ))==false)
  291. {
  292. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Unable to open the sync-recd audio file '%s'.",cmStringNullGuard(audioFn));
  293. goto errLabel;
  294. }
  295. p->flags = cmSetFlag(p->flags,kReadSrFl);
  296. hp->h = p;
  297. errLabel:
  298. cmMemFree(tiV);
  299. cmMemFree(audioFn);
  300. if( rc != kOkSrRC )
  301. _cmSrFinal(p);
  302. return rc;
  303. }
  304. cmSrRC_t cmSyncRecdFinal( cmSyncRecdH_t* hp )
  305. {
  306. cmSrRC_t rc = kOkSrRC;
  307. if( hp==NULL || cmSyncRecdIsValid(*hp)==false)
  308. return rc;
  309. cmSr_t* p = _cmSrHtoP(*hp);
  310. if((rc = _cmSrFinal(p)) != kOkSrRC )
  311. return rc;
  312. hp->h = NULL;
  313. return rc;
  314. }
  315. bool cmSyncRecdIsValid( cmSyncRecdH_t h )
  316. { return h.h != NULL; }
  317. cmSrRC_t cmSyncRecdMidiWrite( cmSyncRecdH_t h, const cmTimeSpec_t* timestamp, unsigned status, unsigned d0, unsigned d1 )
  318. {
  319. cmSrRC_t rc = kOkSrRC;
  320. cmSr_t* p = _cmSrHtoP(h);
  321. cmSrRecd_t* rp = p->cache + p->ci;
  322. rp->tid = kMidiSrId;
  323. rp->u.m.timestamp = *timestamp;
  324. rp->u.m.status = status;
  325. rp->u.m.d0 = d0;
  326. rp->u.m.d1 = d1;
  327. p->ci += 1;
  328. if( p->ci == p->cn )
  329. rc = _cmSrWriteCache(p);
  330. return rc;
  331. }
  332. cmSrRC_t cmSyncRecdAudioWrite( cmSyncRecdH_t h, const cmTimeSpec_t* timestamp, unsigned smpIdx, const cmSample_t* ch[], unsigned chCnt, unsigned frmCnt )
  333. {
  334. cmSrRC_t rc = kOkSrRC;
  335. cmSr_t* p = _cmSrHtoP(h);
  336. cmSrRecd_t* rp = p->cache + p->ci;
  337. rp->tid = kAudioSrId;
  338. rp->u.a.timestamp = *timestamp;
  339. rp->u.a.smpIdx = smpIdx;
  340. p->ci += 1;
  341. if( p->ci == p->cn )
  342. if((rc = _cmSrWriteCache(p)) != kOkSrRC )
  343. goto errLabel;
  344. if( cmAudioFileWriteSample(p->afH,frmCnt,chCnt,(cmSample_t**)ch) != kOkAfRC )
  345. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Audio file write failed.");
  346. errLabel:
  347. return rc;
  348. }
  349. cmSrRC_t cmSyncRecdPrint( cmSyncRecdH_t h )
  350. {
  351. cmSrRC_t rc = kOkSrRC;
  352. cmSr_t* p = _cmSrHtoP(h);
  353. unsigned i;
  354. if( cmIsFlag(p->flags,kReadSrFl)==false)
  355. return cmErrMsg(&p->err,kInvalidOpSrRC,"The 'print' operation is only valid on sync-recd files opened for reading.");
  356. for(i=0; i<p->cn; ++i)
  357. {
  358. cmSrRecd_t* r = p->cache + i;
  359. cmRptPrintf(p->err.rpt,"0x%x %3i %3i %ld %5.3f : %ld %5.3f %i",r->u.m.status,r->u.m.d0,r->u.m.d1,r->u.m.timestamp.tv_sec,r->u.m.timestamp.tv_nsec/1000000000.0,p->map[i].timestamp.tv_sec,p->map[i].timestamp.tv_nsec/1000000000.0,p->map[i].smpIdx);
  360. }
  361. return rc;
  362. }
  363. cmSrRC_t cmSyncRecdAudioFile( cmSyncRecdH_t h, const cmChar_t* fn )
  364. {
  365. cmSrRC_t rc = kOkSrRC;
  366. cmSr_t* p = _cmSrHtoP(h);
  367. cmAudioFileH_t afH = cmNullAudioFileH;
  368. unsigned chCnt = 2;
  369. unsigned frmCnt = 1024;
  370. unsigned chIdx = 0;
  371. cmRC_t afRC = kOkAfRC;
  372. unsigned actFrmCnt = 0;
  373. unsigned smpIdx = 0;
  374. cmSample_t* chs[chCnt];
  375. cmSample_t buf[frmCnt*2];
  376. chs[0] = buf;
  377. chs[1] = buf+frmCnt;
  378. if( cmIsFlag(p->flags,kReadSrFl)==false)
  379. return cmErrMsg(&p->err,kInvalidOpSrRC,"The 'audio-file-output' operation is only valid on sync-recd files opened for reading.");
  380. /// Open an audio file for writing
  381. if(cmAudioFileIsValid(afH = cmAudioFileNewCreate(fn, p->afInfo.srate, p->afInfo.bits, chCnt, &afRC, p->err.rpt))==false)
  382. {
  383. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Unable to create the synchronized audio file '%s'.",cmStringNullGuard(fn));
  384. goto errLabel;
  385. }
  386. // rewind the input audio file
  387. if( cmAudioFileSeek(p->afH,0) != kOkAfRC )
  388. {
  389. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Seek failed during synchronized audio file output.");
  390. goto errLabel;
  391. }
  392. actFrmCnt = frmCnt;
  393. // for each buffer of audio
  394. for(smpIdx=0; actFrmCnt==frmCnt; smpIdx+=actFrmCnt)
  395. {
  396. unsigned i;
  397. // read frmCnt samples from the first channel of the input audio file
  398. if( cmAudioFileReadSample(p->afH, frmCnt, chIdx, 1, chs, &actFrmCnt ) != kOkAfRC )
  399. {
  400. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Audio file read failed.");
  401. break;
  402. }
  403. // zero the output buffer for the second audio channel
  404. cmVOS_Zero(chs[1],frmCnt);
  405. // insert impulses at the location of the MIDI messages.
  406. for(i=0; i<p->cn; ++i)
  407. if( p->cache[i].u.m.status==kNoteOnMdId && smpIdx <= p->map[i].smpIdx && p->map[i].smpIdx < smpIdx+frmCnt )
  408. chs[1][ p->map[i].smpIdx - smpIdx ] = 1.0;
  409. // write the audio output samples
  410. if( cmAudioFileWriteSample(afH, frmCnt, chCnt, chs ) != kOkAfRC )
  411. {
  412. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Synchronized audio file write failed.");
  413. break;
  414. }
  415. }
  416. errLabel:
  417. if( cmAudioFileDelete(&afH) != kOkAfRC )
  418. rc = cmErrMsg(&p->err,kAudioFileFailSrRC,"Synchronized audio file close failed.");
  419. return rc;
  420. }
  421. cmSrRC_t cmSyncRecdTest( cmCtx_t* ctx )
  422. {
  423. enum
  424. {
  425. kOkTestRC,
  426. kTestFailRC,
  427. };
  428. cmSrRC_t rc = kOkSrRC;
  429. const cmChar_t* srFn = "/home/kevin/temp/kr/sr/sr0.sr";
  430. const cmChar_t* aFn = "/home/kevin/temp/kr/sr/sync_af.aiff";
  431. cmErr_t err;
  432. cmSyncRecdH_t srH = cmSyncRecdNullHandle;
  433. cmErrSetup(&err,&ctx->rpt,"SyncRecdTest");
  434. if((rc = cmSyncRecdOpen(ctx, &srH, srFn )) != kOkSrRC )
  435. {
  436. cmErrMsg(&err,kTestFailRC,"Sync-recd open failed.");
  437. goto errLabel;
  438. }
  439. cmSyncRecdPrint(srH);
  440. cmSyncRecdAudioFile(srH,aFn);
  441. errLabel:
  442. if((rc = cmSyncRecdFinal(&srH)) != kOkSrRC )
  443. cmErrMsg(&err,kTestFailRC,"Sync-recd close failed.");
  444. return rc;
  445. }