开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
fluid_midi.c
资源名称：trunk-r284.zip　[点击查看]
上传用户：tjmskj2
上传日期：2020-08-17
资源大小：577k
文件大小：37k
源码类别：

midi

开发平台：

C/C++

fluid_midi.c：源码内容
  1. /* FluidSynth - A Software Synthesizer
  2.  *
  3.  * Copyright (C) 2003  Peter Hanappe and others.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Library General Public License
  7.  * as published by the Free Software Foundation; either version 2 of
  8.  * the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Library General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Library General Public
  16.  * License along with this library; if not, write to the Free
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.  * 02111-1307, USA
  19.  */
  21. #include "fluid_midi.h"
  22. #include "fluid_sys.h"
  23. #include "fluid_synth.h"
  24. #include "fluid_settings.h"
  27. static int fluid_midi_event_length(unsigned char event);
  30. /***************************************************************
  31.  *
  32.  *                      MIDIFILE
  33.  */
  35. /**
  36.  * Open a MIDI file and return a new MIDI file handle.
  37.  * @internal
  38.  * @param filename Path of file to open.
  39.  * @return New MIDI file handle or NULL on error.
  40.  */
  41. fluid_midi_file* new_fluid_midi_file(char* filename)
  42. {
  43. fluid_midi_file* mf;
  45. mf = FLUID_NEW(fluid_midi_file);
  46. if (mf == NULL) {
  47. FLUID_LOG(FLUID_ERR, "Out of memory");
  48. return NULL;
  49. }
  50. FLUID_MEMSET(mf, 0, sizeof(fluid_midi_file));
  52. mf->c = -1;
  53. mf->running_status = -1;
  54. mf->fp = FLUID_FOPEN(filename, "rb");
  56. if (mf->fp == NULL) {
  57. FLUID_LOG(FLUID_ERR, "Couldn't open the MIDI file");
  58. FLUID_FREE(mf);
  59. return NULL;
  60. }
  62. if (fluid_midi_file_read_mthd(mf) != FLUID_OK) {
  63. FLUID_FREE(mf);
  64. return NULL;
  65. }
  66. return mf;
  67. }
  69. /**
  70.  * Delete a MIDI file handle.
  71.  * @internal
  72.  * @param mf MIDI file handle to close and free.
  73.  */
  74. void delete_fluid_midi_file(fluid_midi_file* mf)
  75. {
  76. if (mf == NULL) {
  77. return;
  78. }
  79. if (mf->fp != NULL) {
  80. FLUID_FCLOSE(mf->fp);
  81. }
  82. FLUID_FREE(mf);
  83. return;
  84. }
  86. /*
  87.  * Get the next byte in a MIDI file.
  88.  */
  89. int fluid_midi_file_getc(fluid_midi_file* mf)
  90. {
  91. unsigned char c;
  92. int n;
  93. if (mf->c >= 0) {
  94. c = mf->c;
  95. mf->c = -1;
  96. } else {
  97. n = FLUID_FREAD(&c, 1, 1, mf->fp);
  98. mf->trackpos++;
  99. }
  100. return (int) c;
  101. }
  103. /*
  104.  * fluid_midi_file_push
  105.  */
  106. int fluid_midi_file_push(fluid_midi_file* mf, int c)
  107. {
  108. mf->c = c;
  109. return FLUID_OK;
  110. }
  112. /*
  113.  * fluid_midi_file_read
  114.  */
  115. int fluid_midi_file_read(fluid_midi_file* mf, void* buf, int len)
  116. {
  117. int num = FLUID_FREAD(buf, 1, len, mf->fp);
  118. mf->trackpos += num;
  119. #if DEBUG
  120. if (num != len) {
  121. FLUID_LOG(FLUID_DBG, "Coulnd't read the requested number of bytes");
  122. }
  123. #endif
  124. return (num != len)? FLUID_FAILED : FLUID_OK;
  125. }
  127. /*
  128.  * fluid_midi_file_skip
  129.  */
  130. int fluid_midi_file_skip(fluid_midi_file* mf, int skip)
  131. {
  132. int err = FLUID_FSEEK(mf->fp, skip, SEEK_CUR);
  133. if (err) {
  134. FLUID_LOG(FLUID_ERR, "Failed to seek position in file");
  135. return FLUID_FAILED;
  136. }
  137. return FLUID_OK;
  138. }
  140. /*
  141.  * fluid_midi_file_read_mthd
  142.  */
  143. int fluid_midi_file_read_mthd(fluid_midi_file* mf)
  144. {
  145. char mthd[15];
  146. if (fluid_midi_file_read(mf, mthd, 14) != FLUID_OK) {
  147. return FLUID_FAILED;
  148. }
  149. if ((FLUID_STRNCMP(mthd, "MThd", 4) != 0) || (mthd[7] != 6) || (mthd[9] > 2)) {
  150. FLUID_LOG(FLUID_ERR, "Doesn't look like a MIDI file: invalid MThd header");
  151. return FLUID_FAILED;
  152. }
  153. mf->type = mthd[9];
  154. mf->ntracks = (unsigned) mthd[11];
  155. mf->ntracks += (unsigned int) (mthd[10]) << 16;
  156. if((mthd[12]) < 0){
  157. mf->uses_smpte = 1;
  158. mf->smpte_fps = -mthd[12];
  159. mf->smpte_res = (unsigned) mthd[13];
  160. FLUID_LOG(FLUID_ERR, "File uses SMPTE timing -- Not implemented yet");
  161. return FLUID_FAILED;
  162. } else {
  163. mf->uses_smpte = 0;
  164. mf->division = (mthd[12] << 8) | (mthd[13] & 0xff);
  165. FLUID_LOG(FLUID_DBG, "Division=%d", mf->division);
  166. }
  167. return FLUID_OK;
  168. }
  170. /*
  171.  * fluid_midi_file_load_tracks
  172.  */
  173. int fluid_midi_file_load_tracks(fluid_midi_file* mf, fluid_player_t* player)
  174. {
  175. int i;
  176. for (i = 0; i < mf->ntracks; i++) {
  177. if (fluid_midi_file_read_track(mf, player, i) != FLUID_OK) {
  178. return FLUID_FAILED;
  179. }
  180. }
  181. return FLUID_OK;
  182. }
  184. /*
  185.  * fluid_isasciistring
  186.  */
  187. int fluid_isasciistring(char* s)
  188. {
  189. int i;
  190. int len = (int) FLUID_STRLEN(s);
  191. for (i = 0; i < len; i++) {
  192. if (!fluid_isascii(s[i])) {
  193. return 0;
  194. }
  195. }
  196. return 1;
  197. }
  199. /*
  200.  * fluid_getlength
  201.  */
  202. long fluid_getlength(unsigned char *s)
  203. {
  204. long i = 0;
  205. i = s[3] | (s[2]<<8) | (s[1]<<16) | (s[0]<<24);
  206. return i;
  207. }
  209. /*
  210.  * fluid_midi_file_read_tracklen
  211.  */
  212. int fluid_midi_file_read_tracklen(fluid_midi_file* mf)
  213. {
  214. unsigned char length[5];
  215. if (fluid_midi_file_read(mf, length, 4) != FLUID_OK) {
  216. return FLUID_FAILED;
  217. }
  218. mf->tracklen = fluid_getlength(length);
  219. mf->trackpos = 0;
  220. mf->eot = 0;
  221. return FLUID_OK;
  222. }
  224. /*
  225.  * fluid_midi_file_eot
  226.  */
  227. int fluid_midi_file_eot(fluid_midi_file* mf)
  228. {
  229. #if DEBUG
  230. if (mf->trackpos > mf->tracklen) {
  231. printf("track overrun: %d > %dn", mf->trackpos, mf->tracklen);
  232. }
  233. #endif
  234. return mf->eot || (mf->trackpos >= mf->tracklen);
  235. }
  237. /*
  238.  * fluid_midi_file_read_track
  239.  */
  240. int fluid_midi_file_read_track(fluid_midi_file* mf, fluid_player_t* player, int num)
  241. {
  242. fluid_track_t* track;
  243. unsigned char id[5], length[5];
  244. int found_track = 0;
  245. int skip;
  247. if (fluid_midi_file_read(mf, id, 4) != FLUID_OK) {
  248. return FLUID_FAILED;
  249. }
  250. id[4]='';
  251. mf->dtime = 0;
  253. while (!found_track){
  255. if (fluid_isasciistring((char*) id) == 0) {
  256. FLUID_LOG(FLUID_ERR, "An non-ascii track header found, corrupt file");
  257. return FLUID_FAILED;
  259. } else if (strcmp((char*) id, "MTrk") == 0) {
  261. found_track = 1;
  263. if (fluid_midi_file_read_tracklen(mf) != FLUID_OK) {
  264. return FLUID_FAILED;
  265. }
  267. track = new_fluid_track(num);
  268. if (track == NULL) {
  269. FLUID_LOG(FLUID_ERR, "Out of memory");
  270. return FLUID_FAILED;
  271. }
  273. while (!fluid_midi_file_eot(mf)) {
  274. if (fluid_midi_file_read_event(mf, track) != FLUID_OK) {
  275. return FLUID_FAILED;
  276. }
  277. }
  279. /* Skip remaining track data, if any */
  280. if (mf->trackpos < mf->tracklen)
  281. fluid_midi_file_skip (mf, mf->tracklen - mf->trackpos);
  283. fluid_player_add_track(player, track);
  285. } else {
  286. found_track = 0;
  287. if (fluid_midi_file_read(mf, length, 4) != FLUID_OK) {
  288. return FLUID_FAILED;
  289. }
  290. skip = fluid_getlength(length);
  291. /*        fseek(mf->fp, skip, SEEK_CUR); */
  292. if (fluid_midi_file_skip(mf, skip) != FLUID_OK) {
  293. return FLUID_FAILED;
  294. }
  295. }
  296. }
  297. if (feof(mf->fp)) {
  298. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  299. return FLUID_FAILED;
  300. }
  301. return FLUID_OK;
  302. }
  304. /*
  305.  * fluid_midi_file_read_varlen
  306.  */
  307. int fluid_midi_file_read_varlen(fluid_midi_file* mf)
  308. {
  309. int i;
  310. int c;
  311. mf->varlen = 0;
  312. for (i = 0;;i++) {
  313. if (i == 4) {
  314. FLUID_LOG(FLUID_ERR, "Invalid variable length number");
  315. return FLUID_FAILED;
  316. }
  317. c = fluid_midi_file_getc(mf);
  318. if (c < 0) {
  319. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  320. return FLUID_FAILED;
  321. }
  322. if (c & 0x80){
  323. mf->varlen |= (int) (c & 0x7F);
  324. mf->varlen <<= 7;
  325. } else {
  326. mf->varlen += c;
  327. break;
  328. }
  329. }
  330. return FLUID_OK;
  331. }
  333. /*
  334.  * fluid_midi_file_read_event
  335.  */
  336. int fluid_midi_file_read_event(fluid_midi_file* mf, fluid_track_t* track)
  337. {
  338. int status;
  339. int type;
  340. int tempo;
  341. unsigned char* metadata = NULL;
  342. unsigned char* dyn_buf = NULL;
  343. unsigned char static_buf[256];
  344. int nominator, denominator, clocks, notes, sf, mi;
  345. fluid_midi_event_t* evt;
  346. int channel = 0;
  347. int param1 = 0;
  348. int param2 = 0;
  349. int size;
  351. /* read the delta-time of the event */
  352. if (fluid_midi_file_read_varlen(mf) != FLUID_OK) {
  353. return FLUID_FAILED;
  354. }
  355. mf->dtime += mf->varlen;
  357. /* read the status byte */
  358. status = fluid_midi_file_getc(mf);
  359. if (status < 0) {
  360. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  361. return FLUID_FAILED;
  362. }
  364. /* not a valid status byte: use the running status instead */
  365. if ((status & 0x80) == 0) {
  366. if ((mf->running_status & 0x80) == 0) {
  367. FLUID_LOG(FLUID_ERR, "Undefined status and invalid running status");
  368. return FLUID_FAILED;
  369. }
  370. fluid_midi_file_push(mf, status);
  371. status = mf->running_status;
  372. }
  374. /* check what message we have */
  376. mf->running_status = status;
  378. if ((status == MIDI_SYSEX)) {     /* system exclusif */
  379. /* read the length of the message */
  380. if (fluid_midi_file_read_varlen(mf) != FLUID_OK) {
  381. return FLUID_FAILED;
  382. }
  384. if (mf->varlen) {
  385. FLUID_LOG(FLUID_DBG, "%s: %d: alloc metadata, len = %d", __FILE__, __LINE__, mf->varlen);
  386. metadata = FLUID_MALLOC(mf->varlen + 1);
  388. if (metadata == NULL) {
  389. FLUID_LOG(FLUID_PANIC, "Out of memory");
  390. return FLUID_FAILED;
  391. }
  393. /* read the data of the message */
  394. if (fluid_midi_file_read(mf, metadata, mf->varlen) != FLUID_OK) {
  395. FLUID_FREE (metadata);
  396. return FLUID_FAILED;
  397. }
  399. evt = new_fluid_midi_event();
  400. if (evt == NULL) {
  401. FLUID_LOG(FLUID_ERR, "Out of memory");
  402. FLUID_FREE (metadata);
  403. return FLUID_FAILED;
  404. }
  406. evt->dtime = mf->dtime;
  407. size = mf->varlen;
  409. if (metadata[mf->varlen - 1] == MIDI_EOX)
  410. size--;
  412. /* Add SYSEX event and indicate that its dynamically allocated and should be freed with event */
  413. fluid_midi_event_set_sysex (evt, metadata, size, TRUE);
  414. fluid_track_add_event (track, evt);
  415. mf->dtime = 0;
  416. }
  418. return FLUID_OK;
  420. } else if (status == MIDI_META_EVENT) {             /* meta events */
  422. int result = FLUID_OK;
  424. /* get the type of the meta message */
  425. type = fluid_midi_file_getc(mf);
  426. if (type < 0) {
  427. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  428. return FLUID_FAILED;
  429. }
  431. /* get the length of the data part */
  432. if (fluid_midi_file_read_varlen(mf) != FLUID_OK) {
  433. return FLUID_FAILED;
  434. }
  436. if (mf->varlen < 255) {
  437. metadata = &static_buf[0];
  438. } else {
  439. FLUID_LOG(FLUID_DBG, "%s: %d: alloc metadata, len = %d", __FILE__, __LINE__, mf->varlen);
  440. dyn_buf = FLUID_MALLOC(mf->varlen + 1);
  441. if (dyn_buf == NULL) {
  442. FLUID_LOG(FLUID_PANIC, "Out of memory");
  443. return FLUID_FAILED;
  444. }
  445. metadata = dyn_buf;
  446. }
  448. /* read the data */
  449. if (mf->varlen)
  450. {
  451. if (fluid_midi_file_read(mf, metadata, mf->varlen) != FLUID_OK) {
  452. if (dyn_buf) {
  453. FLUID_FREE(dyn_buf);
  454. }
  455. return FLUID_FAILED;
  456. }
  457. }
  459. /* handle meta data */
  460. switch (type) {
  462. case MIDI_COPYRIGHT:
  463. metadata[mf->varlen] = 0;
  464. break;
  466. case MIDI_TRACK_NAME:
  467. metadata[mf->varlen] = 0;
  468. fluid_track_set_name(track, (char*) metadata);
  469. break;
  471. case MIDI_INST_NAME:
  472. metadata[mf->varlen] = 0;
  473. break;
  475. case MIDI_LYRIC:
  476. break;
  478. case MIDI_MARKER:
  479. break;
  481. case MIDI_CUE_POINT:
  482. break; /* don't care much for text events */
  484. case MIDI_EOT:
  485. if (mf->varlen != 0) {
  486. FLUID_LOG(FLUID_ERR, "Invalid length for EndOfTrack event");
  487. result = FLUID_FAILED;
  488. break;
  489. }
  490. mf->eot = 1;
  491. break;
  493. case MIDI_SET_TEMPO:
  494. if (mf->varlen != 3) {
  495. FLUID_LOG(FLUID_ERR, "Invalid length for SetTempo meta event");
  496. result = FLUID_FAILED;
  497. break;
  498. }
  499. tempo = (metadata[0] << 16) + (metadata[1] << 8) + metadata[2];
  500. evt = new_fluid_midi_event();
  501. if (evt == NULL) {
  502. FLUID_LOG(FLUID_ERR, "Out of memory");
  503. result = FLUID_FAILED;
  504. break;
  505. }
  506. evt->dtime = mf->dtime;
  507. evt->type = MIDI_SET_TEMPO;
  508. evt->channel = 0;
  509. evt->param1 = tempo;
  510. evt->param2 = 0;
  511. fluid_track_add_event(track, evt);
  512. mf->dtime = 0;
  513. break;
  515. case MIDI_SMPTE_OFFSET:
  516. if (mf->varlen != 5) {
  517. FLUID_LOG(FLUID_ERR, "Invalid length for SMPTE Offset meta event");
  518. result = FLUID_FAILED;
  519. break;
  520. }
  521. break; /* we don't use smtp */
  523. case MIDI_TIME_SIGNATURE:
  524. if (mf->varlen != 4) {
  525. FLUID_LOG(FLUID_ERR, "Invalid length for TimeSignature meta event");
  526. result = FLUID_FAILED;
  527. break;
  528. }
  529. nominator = metadata[0];
  530. denominator = pow(2.0, (double) metadata[1]);
  531. clocks = metadata[2];
  532. notes = metadata[3];
  534. FLUID_LOG(FLUID_DBG, "signature=%d/%d, metronome=%d, 32nd-notes=%d",
  535.   nominator, denominator, clocks, notes);
  537. break;
  539. case MIDI_KEY_SIGNATURE:
  540. if (mf->varlen != 2) {
  541. FLUID_LOG(FLUID_ERR, "Invalid length for KeySignature meta event");
  542. result = FLUID_FAILED;
  543. break;
  544. }
  545. sf = metadata[0];
  546. mi = metadata[1];
  547. break;
  549. case MIDI_SEQUENCER_EVENT:
  550. break;
  552. default:
  553. break;
  554. }
  556. if (dyn_buf) {
  557. FLUID_LOG(FLUID_DBG, "%s: %d: free metadata", __FILE__, __LINE__);
  558. FLUID_FREE(dyn_buf);
  559. }
  561. return result;
  563. } else {                /* channel messages */
  565. type = status & 0xf0;
  566. channel = status & 0x0f;
  568. /* all channel message have at least 1 byte of associated data */
  569. if ((param1 = fluid_midi_file_getc(mf)) < 0) {
  570. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  571. return FLUID_FAILED;
  572. }
  574. switch (type) {
  576. case NOTE_ON:
  577. if ((param2 = fluid_midi_file_getc(mf)) < 0) {
  578. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  579. return FLUID_FAILED;
  580. }
  581. break;
  583. case NOTE_OFF:
  584. if ((param2 = fluid_midi_file_getc(mf)) < 0) {
  585. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  586. return FLUID_FAILED;
  587. }
  588. break;
  590. case KEY_PRESSURE:
  591. if ((param2 = fluid_midi_file_getc(mf)) < 0) {
  592. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  593. return FLUID_FAILED;
  594. }
  595. break;
  597. case CONTROL_CHANGE:
  598. if ((param2 = fluid_midi_file_getc(mf)) < 0) {
  599. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  600. return FLUID_FAILED;
  601. }
  602. break;
  604. case PROGRAM_CHANGE:
  605. break;
  607. case CHANNEL_PRESSURE:
  608. break;
  610. case PITCH_BEND:
  611. if ((param2 = fluid_midi_file_getc(mf)) < 0) {
  612. FLUID_LOG(FLUID_ERR, "Unexpected end of file");
  613. return FLUID_FAILED;
  614. }
  616. param1 = ((param2 & 0x7f) << 7) | (param1 & 0x7f);
  617. param2 = 0;
  618. break;
  620. default:
  621. /* Can't possibly happen !? */
  622. FLUID_LOG(FLUID_ERR, "Unrecognized MIDI event");
  623. return FLUID_FAILED;
  624. }
  625. evt = new_fluid_midi_event();
  626. if (evt == NULL) {
  627. FLUID_LOG(FLUID_ERR, "Out of memory");
  628. return FLUID_FAILED;
  629. }
  630. evt->dtime = mf->dtime;
  631. evt->type = type;
  632. evt->channel = channel;
  633. evt->param1 = param1;
  634. evt->param2 = param2;
  635. fluid_track_add_event(track, evt);
  636. mf->dtime = 0;
  637. }
  638. return FLUID_OK;
  639. }
  641. /*
  642.  * fluid_midi_file_get_division
  643.  */
  644. int fluid_midi_file_get_division(fluid_midi_file* midifile)
  645. {
  646. return midifile->division;
  647. }
  649. /******************************************************
  650.  *
  651.  *     fluid_track_t
  652.  */
  654. /**
  655.  * Create a MIDI event structure.
  656.  * @return New MIDI event structure or NULL when out of memory.
  657.  */
  658. fluid_midi_event_t* new_fluid_midi_event()
  659. {
  660. fluid_midi_event_t* evt;
  661. evt = FLUID_NEW(fluid_midi_event_t);
  662. if (evt == NULL) {
  663. FLUID_LOG(FLUID_ERR, "Out of memory");
  664. return NULL;
  665. }
  666. evt->dtime = 0;
  667. evt->type = 0;
  668. evt->channel = 0;
  669. evt->param1 = 0;
  670. evt->param2 = 0;
  671. evt->next = NULL;
  672. evt->paramptr = NULL;
  673. return evt;
  674. }
  676. /**
  677.  * Delete MIDI event structure.
  678.  * @param evt MIDI event structure
  679.  * @return Always returns #FLUID_OK
  680.  */
  681. int delete_fluid_midi_event(fluid_midi_event_t* evt)
  682. {
  683. fluid_midi_event_t *temp;
  685. while (evt)
  686. {
  687. temp = evt->next;
  689. /* Dynamic SYSEX event? - free (param2 indicates if dynamic) */
  690. if (evt->type == MIDI_SYSEX && evt->paramptr && evt->param2)
  691. FLUID_FREE (evt->paramptr);
  693. FLUID_FREE(evt);
  694. evt = temp;
  695. }
  696. return FLUID_OK;
  697. }
  699. /**
  700.  * Get the event type field of a MIDI event structure.
  701.  * @param evt MIDI event structure
  702.  * @return Event type field (MIDI status byte without channel)
  703.  */
  704. int fluid_midi_event_get_type(fluid_midi_event_t* evt)
  705. {
  706. return evt->type;
  707. }
  709. /**
  710.  * Set the event type field of a MIDI event structure.
  711.  * @param evt MIDI event structure
  712.  * @param type Event type field (MIDI status byte without channel)
  713.  * @return Always returns #FLUID_OK
  714.  */
  715. int fluid_midi_event_set_type(fluid_midi_event_t* evt, int type)
  716. {
  717. evt->type = type;
  718. return FLUID_OK;
  719. }
  721. /**
  722.  * Get the channel field of a MIDI event structure.
  723.  * @param evt MIDI event structure
  724.  * @return Channel field
  725.  */
  726. int fluid_midi_event_get_channel(fluid_midi_event_t* evt)
  727. {
  728. return evt->channel;
  729. }
  731. /**
  732.  * Set the channel field of a MIDI event structure.
  733.  * @param evt MIDI event structure
  734.  * @param chan MIDI channel field
  735.  * @return Always returns #FLUID_OK
  736.  */
  737. int fluid_midi_event_set_channel(fluid_midi_event_t* evt, int chan)
  738. {
  739. evt->channel = chan;
  740. return FLUID_OK;
  741. }
  743. /**
  744.  * Get the key field of a MIDI event structure.
  745.  * @param evt MIDI event structure
  746.  * @return MIDI note number (0-127)
  747.  */
  748. int fluid_midi_event_get_key(fluid_midi_event_t* evt)
  749. {
  750. return evt->param1;
  751. }
  753. /**
  754.  * Set the key field of a MIDI event structure.
  755.  * @param evt MIDI event structure
  756.  * @param v MIDI note number (0-127)
  757.  * @return Always returns #FLUID_OK
  758.  */
  759. int fluid_midi_event_set_key(fluid_midi_event_t* evt, int v)
  760. {
  761. evt->param1 = v;
  762. return FLUID_OK;
  763. }
  765. /**
  766.  * Get the velocity field of a MIDI event structure.
  767.  * @param evt MIDI event structure
  768.  * @return MIDI velocity number (0-127)
  769.  */
  770. int fluid_midi_event_get_velocity(fluid_midi_event_t* evt)
  771. {
  772. return evt->param2;
  773. }
  775. /**
  776.  * Set the velocity field of a MIDI event structure.
  777.  * @param evt MIDI event structure
  778.  * @param v MIDI velocity value
  779.  * @return Always returns #FLUID_OK
  780.  */
  781. int fluid_midi_event_set_velocity(fluid_midi_event_t* evt, int v)
  782. {
  783. evt->param2 = v;
  784. return FLUID_OK;
  785. }
  787. /**
  788.  * Get the control number of a MIDI event structure.
  789.  * @param evt MIDI event structure
  790.  * @return MIDI control number
  791.  */
  792. int fluid_midi_event_get_control(fluid_midi_event_t* evt)
  793. {
  794. return evt->param1;
  795. }
  797. /**
  798.  * Set the control field of a MIDI event structure.
  799.  * @param evt MIDI event structure
  800.  * @param v MIDI control number
  801.  * @return Always returns #FLUID_OK
  802.  */
  803. int fluid_midi_event_set_control(fluid_midi_event_t* evt, int v)
  804. {
  805. evt->param1 = v;
  806. return FLUID_OK;
  807. }
  809. /**
  810.  * Get the value field from a MIDI event structure.
  811.  * @param evt MIDI event structure
  812.  * @return Value field
  813.  */
  814. int fluid_midi_event_get_value(fluid_midi_event_t* evt)
  815. {
  816. return evt->param2;
  817. }
  819. /**
  820.  * Set the value field of a MIDI event structure.
  821.  * @param evt MIDI event structure
  822.  * @param v Value to assign
  823.  * @return Always returns #FLUID_OK
  824.  */
  825. int fluid_midi_event_set_value(fluid_midi_event_t* evt, int v)
  826. {
  827. evt->param2 = v;
  828. return FLUID_OK;
  829. }
  831. /**
  832.  * Get the program field of a MIDI event structure.
  833.  * @param evt MIDI event structure
  834.  * @return MIDI program number (0-127)
  835.  */
  836. int fluid_midi_event_get_program(fluid_midi_event_t* evt)
  837. {
  838. return evt->param1;
  839. }
  841. /**
  842.  * Set the program field of a MIDI event structure.
  843.  * @param evt MIDI event structure
  844.  * @param val MIDI program number (0-127)
  845.  * @return Always returns #FLUID_OK
  846.  */
  847. int fluid_midi_event_set_program(fluid_midi_event_t* evt, int val)
  848. {
  849. evt->param1 = val;
  850. return FLUID_OK;
  851. }
  853. /**
  854.  * Get the pitch field of a MIDI event structure.
  855.  * @param evt MIDI event structure
  856.  * @return Pitch value (14 bit value, 0-16383, 8192 is center)
  857.  */
  858. int fluid_midi_event_get_pitch(fluid_midi_event_t* evt)
  859. {
  860. return evt->param1;
  861. }
  863. /**
  864.  * Set the pitch field of a MIDI event structure.
  865.  * @param evt MIDI event structure
  866.  * @param val Pitch value (14 bit value, 0-16383, 8192 is center)
  867.  * @return Always returns FLUID_OK
  868.  */
  869. int fluid_midi_event_set_pitch(fluid_midi_event_t* evt, int val)
  870. {
  871. evt->param1 = val;
  872. return FLUID_OK;
  873. }
  875. /**
  876.  * Assign sysex data to a MIDI event structure.
  877.  * @param evt MIDI event structure
  878.  * @param data Pointer to SYSEX data
  879.  * @param size Size of SYSEX data
  880.  * @param dynamic TRUE if the SYSEX data has been dynamically allocated and
  881.  *   should be freed when the event is freed (only applies if event gets destroyed
  882.  *   with delete_fluid_midi_event())
  883.  * @return Always returns #FLUID_OK
  884.  *
  885.  * NOTE: Unlike the other event assignment functions, this one sets evt->type.
  886.  */
  887. int
  888. fluid_midi_event_set_sysex(fluid_midi_event_t* evt, void *data, int size, int dynamic)
  889. {
  890. evt->type = MIDI_SYSEX;
  891. evt->paramptr = data;
  892. evt->param1 = size;
  893. evt->param2 = dynamic;
  894. return FLUID_OK;
  895. }
  897. /******************************************************
  898.  *
  899.  *     fluid_track_t
  900.  */
  902. /*
  903.  * new_fluid_track
  904.  */
  905. fluid_track_t* new_fluid_track(int num)
  906. {
  907. fluid_track_t* track;
  908. track = FLUID_NEW(fluid_track_t);
  909. if (track == NULL) {
  910. return NULL;
  911. }
  912. track->name = NULL;
  913. track->num = num;
  914. track->first = NULL;
  915. track->cur = NULL;
  916. track->last = NULL;
  917. track->ticks = 0;
  918. return track;
  919. }
  921. /*
  922.  * delete_fluid_track
  923.  */
  924. int delete_fluid_track(fluid_track_t* track)
  925. {
  926. if (track->name != NULL) {
  927. FLUID_FREE(track->name);
  928. }
  929. if (track->first != NULL) {
  930. delete_fluid_midi_event(track->first);
  931. }
  932. FLUID_FREE(track);
  933. return FLUID_OK;
  934. }
  936. /*
  937.  * fluid_track_set_name
  938.  */
  939. int fluid_track_set_name(fluid_track_t* track, char* name)
  940. {
  941. int len;
  942. if (track->name != NULL) {
  943. FLUID_FREE(track->name);
  944. }
  945. if (name == NULL) {
  946. track->name = NULL;
  947. return FLUID_OK;
  948. }
  949. len = FLUID_STRLEN(name);
  950. track->name = FLUID_MALLOC(len + 1);
  951. if (track->name == NULL) {
  952. FLUID_LOG(FLUID_ERR, "Out of memory");
  953. return FLUID_FAILED;
  954. }
  955. FLUID_STRCPY(track->name, name);
  956. return FLUID_OK;
  957. }
  959. /*
  960.  * fluid_track_get_name
  961.  */
  962. char* fluid_track_get_name(fluid_track_t* track)
  963. {
  964. return track->name;
  965. }
  967. /*
  968.  * fluid_track_get_duration
  969.  */
  970. int fluid_track_get_duration(fluid_track_t* track)
  971. {
  972. int time = 0;
  973. fluid_midi_event_t* evt = track->first;
  974. while (evt != NULL) {
  975. time += evt->dtime;
  976. evt = evt->next;
  977. }
  978. return time;
  979. }
  981. /*
  982.  * fluid_track_count_events
  983.  */
  984. int fluid_track_count_events(fluid_track_t* track, int* on, int* off)
  985. {
  986. fluid_midi_event_t* evt = track->first;
  987. while (evt != NULL) {
  988. if (evt->type == NOTE_ON) {
  989. (*on)++;
  990. } else if (evt->type == NOTE_OFF) {
  991. (*off)++;
  992. }
  993. evt = evt->next;
  994. }
  995. return FLUID_OK;
  996. }
  998. /*
  999.  * fluid_track_add_event
  1000.  */
  1001. int fluid_track_add_event(fluid_track_t* track, fluid_midi_event_t* evt)
  1002. {
  1003. evt->next = NULL;
  1004. if (track->first == NULL) {
  1005. track->first = evt;
  1006. track->cur = evt;
  1007. track->last = evt;
  1008. } else {
  1009. track->last->next = evt;
  1010. track->last = evt;
  1011. }
  1012. return FLUID_OK;
  1013. }
  1015. /*
  1016.  * fluid_track_first_event
  1017.  */
  1018. fluid_midi_event_t* fluid_track_first_event(fluid_track_t* track)
  1019. {
  1020. track->cur = track->first;
  1021. return track->cur;
  1022. }
  1024. /*
  1025.  * fluid_track_next_event
  1026.  */
  1027. fluid_midi_event_t* fluid_track_next_event(fluid_track_t* track)
  1028. {
  1029. if (track->cur != NULL) {
  1030. track->cur = track->cur->next;
  1031. }
  1032. return track->cur;
  1033. }
  1035. /*
  1036.  * fluid_track_reset
  1037.  */
  1038. int
  1039. fluid_track_reset(fluid_track_t* track)
  1040. {
  1041. track->ticks = 0;
  1042. track->cur = track->first;
  1043. return FLUID_OK;
  1044. }
  1046. /*
  1047.  * fluid_track_send_events
  1048.  */
  1049. int
  1050. fluid_track_send_events(fluid_track_t* track,
  1051. fluid_synth_t* synth,
  1052. fluid_player_t* player,
  1053. unsigned int ticks)
  1054. {
  1055. int status = FLUID_OK;
  1056. fluid_midi_event_t* event;
  1058. while (1) {
  1060. event = track->cur;
  1061. if (event == NULL) {
  1062. return status;
  1063. }
  1065. /*  printf("track=%02dtticks=%05uttrack=%05utdtime=%05utnext=%05un", */
  1066. /*         track->num, */
  1067. /*         ticks, */
  1068. /*         track->ticks, */
  1069. /*         event->dtime, */
  1070. /*         track->ticks + event->dtime); */
  1072. if (track->ticks + event->dtime > ticks) {
  1073. return status;
  1074. }
  1077. track->ticks += event->dtime;
  1079. if (event->type != MIDI_SET_TEMPO)
  1080. fluid_synth_handle_midi_event (synth, event);
  1081. else if (player) fluid_player_set_midi_tempo (player, event->param1);
  1083. fluid_track_next_event(track);
  1085. }
  1086. return status;
  1087. }
  1089. /******************************************************
  1090.  *
  1091.  *     fluid_player
  1092.  */
  1094. /**
  1095.  * Create a new MIDI player.
  1096.  * @param synth Fluid synthesizer instance to create player for
  1097.  * @return New MIDI player instance or NULL on error (out of memory)
  1098.  */
  1099. fluid_player_t* new_fluid_player(fluid_synth_t* synth)
  1100. {
  1101. int i;
  1102. fluid_player_t* player;
  1103. player = FLUID_NEW(fluid_player_t);
  1104. if (player == NULL) {
  1105. FLUID_LOG(FLUID_ERR, "Out of memory");
  1106. return NULL;
  1107. }
  1108. player->status = FLUID_PLAYER_READY;
  1109. player->loop = 1;
  1110. player->ntracks = 0;
  1111. for (i = 0; i < MAX_NUMBER_OF_TRACKS; i++) {
  1112. player->track[i] = NULL;
  1113. }
  1114. player->synth = synth;
  1115. player->system_timer = NULL;
  1116. player->sample_timer = NULL;
  1117. player->playlist = NULL;
  1118. player->currentfile = NULL;
  1119. player->division = 0;
  1120. player->send_program_change = 1;
  1121. player->miditempo = 480000;
  1122. player->deltatime = 4.0;
  1124. player->use_system_timer = 
  1125. fluid_settings_str_equal(synth->settings, "player.timing-source", "system");
  1127. fluid_settings_getint (synth->settings, "player.reset-synth", &i);
  1128. player->reset_synth_between_songs = i;
  1130. return player;
  1131. }
  1133. /**
  1134.  * Delete a MIDI player instance.
  1135.  * @param player MIDI player instance
  1136.  * @return Always returns #FLUID_OK
  1137.  */
  1138. int delete_fluid_player(fluid_player_t* player)
  1139. {
  1140. fluid_list_t* q;
  1142. if (player == NULL) {
  1143. return FLUID_OK;
  1144. }
  1145. fluid_player_stop(player);
  1146. fluid_player_reset(player);
  1148. while (player->playlist != NULL) {
  1149. q = player->playlist->next;
  1150. FLUID_FREE(player->playlist->data);
  1151. delete1_fluid_list(player->playlist);
  1152. player->playlist = q;
  1153. }
  1155. FLUID_FREE(player);
  1156. return FLUID_OK;
  1157. }
  1159. /**
  1160.  * Registers settings related to the MIDI player
  1161.  */
  1162. void fluid_player_settings(fluid_settings_t* settings)
  1163. {
  1164. /* player.timing-source can be either "system" (use system timer) 
  1165. or "sample" (use timer based on number of written samples) */
  1166. fluid_settings_register_str(settings, "player.timing-source", "sample", 0, NULL, NULL);
  1167. fluid_settings_add_option(settings, "player.timing-source", "sample");
  1168. fluid_settings_add_option(settings, "player.timing-source", "system");
  1170. /* Selects whether the player should reset the synth between songs, or not. */
  1171. fluid_settings_register_int(settings, "player.reset-synth", 1, 0, 1,
  1172.                                     FLUID_HINT_TOGGLED, NULL, NULL);
  1173. }
  1176. int fluid_player_reset(fluid_player_t* player)
  1177. {
  1178. int i;
  1180. for (i = 0; i < MAX_NUMBER_OF_TRACKS; i++) {
  1181. if (player->track[i] != NULL) {
  1182. delete_fluid_track(player->track[i]);
  1183. player->track[i] = NULL;
  1184. }
  1185. }
  1186. /* player->current_file = NULL; */
  1187. /* player->status = FLUID_PLAYER_READY; */
  1188. /* player->loop = 1; */
  1189. player->ntracks = 0;
  1190. player->division = 0;
  1191. player->send_program_change = 1;
  1192. player->miditempo = 480000;
  1193. player->deltatime = 4.0;
  1194. return 0;
  1195. }
  1197. /*
  1198.  * fluid_player_add_track
  1199.  */
  1200. int fluid_player_add_track(fluid_player_t* player, fluid_track_t* track)
  1201. {
  1202. if (player->ntracks < MAX_NUMBER_OF_TRACKS) {
  1203. player->track[player->ntracks++] = track;
  1204. return FLUID_OK;
  1205. } else {
  1206. return FLUID_FAILED;
  1207. }
  1208. }
  1210. /*
  1211.  * fluid_player_count_tracks
  1212.  */
  1213. int fluid_player_count_tracks(fluid_player_t* player)
  1214. {
  1215. return player->ntracks;
  1216. }
  1218. /*
  1219.  * fluid_player_get_track
  1220.  */
  1221. fluid_track_t* fluid_player_get_track(fluid_player_t* player, int i)
  1222. {
  1223. if ((i >= 0) && (i < MAX_NUMBER_OF_TRACKS)) {
  1224. return player->track[i];
  1225. } else {
  1226. return NULL;
  1227. }
  1228. }
  1230. /**
  1231.  * Add a MIDI file to a player queue.
  1232.  * @param player MIDI player instance
  1233.  * @param midifile File name of the MIDI file to add
  1234.  * @return #FLUID_OK
  1235.  */
  1236. int
  1237. fluid_player_add(fluid_player_t* player, const char* midifile)
  1238. {
  1239. char *s = FLUID_STRDUP(midifile);
  1240. player->playlist = fluid_list_append(player->playlist, s);
  1241. return FLUID_OK;
  1242. }
  1244. /*
  1245.  * fluid_player_load
  1246.  */
  1247. int fluid_player_load(fluid_player_t* player, char *filename)
  1248. {
  1249. fluid_midi_file* midifile;
  1251. midifile = new_fluid_midi_file(filename);
  1252. if (midifile == NULL) {
  1253. return FLUID_FAILED;
  1254. }
  1255. player->division = fluid_midi_file_get_division(midifile);
  1256. fluid_player_set_midi_tempo(player, player->miditempo); // Update deltatime
  1257. /*FLUID_LOG(FLUID_DBG, "quarter note division=%dn", player->division); */
  1259. if (fluid_midi_file_load_tracks(midifile, player) != FLUID_OK){
  1260. return FLUID_FAILED;
  1261. }
  1262. delete_fluid_midi_file(midifile);
  1263. return FLUID_OK;
  1264. }
  1266. void fluid_player_advancefile(fluid_player_t* player)
  1267. {
  1268. if (player->playlist == NULL) {
  1269. return; /* No files to play */
  1270. }
  1271. if (player->currentfile != NULL) {
  1272. player->currentfile = fluid_list_next(player->currentfile);
  1273. }
  1274. if (player->currentfile == NULL) {
  1275. if (player->loop == 0) {
  1276. return; /* We're done playing */ 
  1277. }
  1278. if (player->loop > 0) {
  1279. player->loop--;
  1280. } 
  1281. player->currentfile = player->playlist;
  1282. } 
  1283. }
  1285. void fluid_player_playlist_load(fluid_player_t* player, unsigned int msec)
  1286. {
  1287. char* current_filename;
  1288. int i;
  1290. do {
  1291. fluid_player_advancefile(player);
  1292. if (player->currentfile == NULL) { 
  1293. /* Failed to find next song, probably since we're finished */
  1294. player->status = FLUID_PLAYER_DONE;
  1295. return;
  1296. }
  1298. fluid_player_reset(player);
  1299. current_filename = (char*) player->currentfile->data;
  1300. FLUID_LOG(FLUID_DBG, "%s: %d: Loading midifile %s", __FILE__, __LINE__, current_filename);
  1301. } while (fluid_player_load(player, current_filename) != FLUID_OK);
  1303. /* Successfully loaded midi file */
  1305. player->begin_msec = msec;
  1306. player->start_msec = msec;
  1307. player->start_ticks = 0;
  1308. player->cur_ticks = 0;
  1310. if (player->reset_synth_between_songs) {
  1311. fluid_synth_system_reset(player->synth);
  1312. }
  1314. for (i = 0; i < player->ntracks; i++) {
  1315. if (player->track[i] != NULL) {
  1316. fluid_track_reset(player->track[i]);
  1317. }
  1318. }
  1319. }
  1322. /*
  1323.  * fluid_player_callback
  1324.  */
  1325. int fluid_player_callback(void* data, unsigned int msec)
  1326. {
  1327. int i;
  1328. int loadnextfile;
  1329. int status = FLUID_PLAYER_DONE;
  1330. fluid_player_t* player;
  1331. fluid_synth_t* synth;
  1332. player = (fluid_player_t*) data;
  1333. synth = player->synth;
  1335. loadnextfile = player->currentfile == NULL ? 1 : 0; 
  1336. do {
  1337. if (loadnextfile) {
  1338. loadnextfile = 0;
  1339. fluid_player_playlist_load(player, msec);
  1340. if (player->currentfile == NULL) {
  1341. return 0;
  1342. }
  1343. }
  1345. player->cur_msec = msec;
  1346. player->cur_ticks = (player->start_ticks +
  1347. (int) ((double) (player->cur_msec - player->start_msec) / player->deltatime));
  1349. for (i = 0; i < player->ntracks; i++) {
  1350. if (!fluid_track_eot(player->track[i])) {
  1351. status = FLUID_PLAYER_PLAYING;
  1352. if (fluid_track_send_events(player->track[i], synth, player, player->cur_ticks) != FLUID_OK) {
  1353. /* */
  1354. }
  1355. }
  1356. }
  1358. if (status == FLUID_PLAYER_DONE) {
  1359. FLUID_LOG(FLUID_DBG, "%s: %d: Duration=%.3f sec",
  1360.   __FILE__, __LINE__, (msec - player->begin_msec) / 1000.0);
  1361. loadnextfile = 1;
  1362. }
  1363. } while (loadnextfile);
  1365. player->status = status;
  1367. return 1;
  1368. }
  1370. /**
  1371.  * Activates play mode for a MIDI player if not already playing.
  1372.  * @param player MIDI player instance
  1373.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  1374.  */
  1375. int fluid_player_play(fluid_player_t* player)
  1376. {
  1377. if (player->status == FLUID_PLAYER_PLAYING) {
  1378. return FLUID_OK;
  1379. }
  1381. if (player->playlist == NULL) {
  1382. return FLUID_OK;
  1383. }
  1385. player->status = FLUID_PLAYER_PLAYING;
  1387. if (player->use_system_timer) {
  1388. player->system_timer = new_fluid_timer((int) player->deltatime, fluid_player_callback,
  1389. (void*) player, TRUE, FALSE, TRUE);
  1390. if (player->system_timer == NULL) {
  1391. return FLUID_FAILED;
  1392. }
  1393. } else {
  1394. player->sample_timer = new_fluid_sample_timer(player->synth, fluid_player_callback,
  1395. (void*) player);
  1397. if (player->sample_timer == NULL) {
  1398. return FLUID_FAILED;
  1399. }
  1400. }
  1401. return FLUID_OK;
  1402. }
  1404. /**
  1405.  * Stops a MIDI player.
  1406.  * @param player MIDI player instance
  1407.  * @return Always returns #FLUID_OK
  1408.  */
  1409. int fluid_player_stop(fluid_player_t* player)
  1410. {
  1411. if (player->system_timer != NULL) {
  1412. delete_fluid_timer(player->system_timer);
  1413. }
  1414. if (player->sample_timer != NULL) {
  1415. delete_fluid_sample_timer(player->synth, player->sample_timer);
  1416. }
  1417. player->status = FLUID_PLAYER_DONE;
  1418. player->sample_timer = NULL;
  1419. player->system_timer = NULL;
  1420. return FLUID_OK;
  1421. }
  1423. /**
  1424.  * Get MIDI player status.
  1425.  * @param player MIDI player instance
  1426.  * @return Player status (#fluid_player_status)
  1427.  * @since 1.1.0
  1428.  */
  1429. int
  1430. fluid_player_get_status(fluid_player_t* player)
  1431. {
  1432. return player->status;
  1433. }
  1435. /**
  1436.  * Enable looping of a MIDI player 
  1437.  * @param player MIDI player instance
  1438.  * @param loop Times left to loop the playlist. -1 means loop infinitely.
  1439.  * @return Always returns #FLUID_OK
  1440.  * @since 1.1.0
  1441.  *
  1442.  * For example, if you want to loop the playlist twice, set loop to 2 
  1443.  * and call this function before you start the player.
  1444.  */
  1445. int fluid_player_set_loop(fluid_player_t* player, int loop)
  1446. {
  1447. player->loop = loop;
  1448. return FLUID_OK;
  1449. }
  1451. /**
  1452.  * Set the tempo of a MIDI player.
  1453.  * @param player MIDI player instance
  1454.  * @param tempo Tempo to set playback speed to (in microseconds per quarter note, as per MIDI file spec)
  1455.  * @return Always returns #FLUID_OK
  1456.  */
  1457. int fluid_player_set_midi_tempo(fluid_player_t* player, int tempo)
  1458. {
  1459. player->miditempo = tempo;
  1460. player->deltatime = (double) tempo / player->division / 1000.0; /* in milliseconds */
  1461. player->start_msec = player->cur_msec;
  1462. player->start_ticks = player->cur_ticks;
  1464. FLUID_LOG(FLUID_DBG,"tempo=%d, tick time=%f msec, cur time=%d msec, cur tick=%d",
  1465.   tempo, player->deltatime, player->cur_msec, player->cur_ticks);
  1467. return FLUID_OK;
  1468. }
  1470. /**
  1471.  * Set the tempo of a MIDI player in beats per minute.
  1472.  * @param player MIDI player instance
  1473.  * @param bpm Tempo in beats per minute
  1474.  * @return Always returns #FLUID_OK
  1475.  */
  1476. int fluid_player_set_bpm(fluid_player_t* player, int bpm)
  1477. {
  1478. return fluid_player_set_midi_tempo(player, (int)((double) 60 * 1e6 / bpm));
  1479. }
  1481. /**
  1482.  * Wait for a MIDI player to terminate (when done playing).
  1483.  * @param player MIDI player instance
  1484.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  1485.  */
  1486. int fluid_player_join(fluid_player_t* player)
  1487. {
  1488. if (player->system_timer) {
  1489. return fluid_timer_join(player->system_timer);
  1490. } else if (player->sample_timer) {
  1491. /* Busy-wait loop, since there's no thread to wait for... */
  1492. while (player->status == FLUID_PLAYER_PLAYING) {
  1493. #if defined(WIN32)
  1494. Sleep(10);
  1495. #else
  1496. usleep(10000);
  1497. #endif
  1498. }
  1499. }
  1500. return FLUID_OK;
  1501. }
  1503. /************************************************************************
  1504.  *       MIDI PARSER
  1505.  *
  1506.  */
  1508. /*
  1509.  * new_fluid_midi_parser
  1510.  */
  1511. fluid_midi_parser_t* new_fluid_midi_parser()
  1512. {
  1513. fluid_midi_parser_t* parser;
  1514. parser = FLUID_NEW(fluid_midi_parser_t);
  1515. if (parser == NULL) {
  1516. FLUID_LOG(FLUID_ERR, "Out of memory");
  1517. return NULL;
  1518. }
  1519. parser->status = 0; /* As long as the status is 0, the parser won't do anything -> no need to initialize all the fields. */
  1520. return parser;
  1521. }
  1523. /*
  1524.  * delete_fluid_midi_parser
  1525.  */
  1526. int delete_fluid_midi_parser(fluid_midi_parser_t* parser)
  1527. {
  1528. FLUID_FREE(parser);
  1529. return FLUID_OK;
  1530. }
  1532. /**
  1533.  * Parse a MIDI stream one character at a time.
  1534.  * @param parser Parser instance
  1535.  * @param c Next character in MIDI stream
  1536.  * @return A parsed MIDI event or NULL if none.  Event is internal and should
  1537.  *   not be modified or freed and is only valid until next call to this function.
  1538.  */
  1539. fluid_midi_event_t *
  1540. fluid_midi_parser_parse(fluid_midi_parser_t* parser, unsigned char c)
  1541. {
  1542.   fluid_midi_event_t *event;
  1544.   /* Real-time messages (0xF8-0xFF) can occur anywhere, even in the middle
  1545.    * of another message. */
  1546.   if (c >= 0xF8)
  1547.   {
  1548.     if (c == MIDI_SYSTEM_RESET)
  1549.     {
  1550.       parser->event.type = c;
  1551.       parser->status = 0;       /* clear the status */
  1552.       return &parser->event;
  1553.     }
  1555.     return NULL;
  1556.   }
  1558.   /* Status byte? - If previous message not yet complete, it is discarded (re-sync). */
  1559.   if (c & 0x80)
  1560.   {
  1561.     /* Any status byte terminates SYSEX messages (not just 0xF7) */
  1562.     if (parser->status == MIDI_SYSEX && parser->nr_bytes > 0)
  1563.     {
  1564.       event = &parser->event;
  1565.       fluid_midi_event_set_sysex (event, parser->data, parser->nr_bytes, FALSE);
  1566.     }
  1567.     else event = NULL;
  1569.     if (c < 0xF0)       /* Voice category message? */
  1570.     {
  1571.       parser->channel = c & 0x0F;
  1572.       parser->status = c & 0xF0;
  1574.       /* The event consumes x bytes of data... (subtract 1 for the status byte) */
  1575.       parser->nr_bytes_total = fluid_midi_event_length (parser->status) - 1;
  1577.       parser->nr_bytes = 0;     /* 0  bytes read so far */
  1578.     }
  1579.     else if (c == MIDI_SYSEX)
  1580.     {
  1581.       parser->status = MIDI_SYSEX;
  1582.       parser->nr_bytes = 0;
  1583.     }
  1584.     else parser->status = 0;    /* Discard other system messages (0xF1-0xF7) */
  1586.     return event;       /* Return SYSEX event or NULL */
  1587.   }
  1590.   /* Data/parameter byte */
  1593.   /* Discard data bytes for events we don't care about */
  1594.   if (parser->status == 0)
  1595.     return NULL;
  1597.   /* Max data size exceeded? (SYSEX messages only really) */
  1598.   if (parser->nr_bytes == FLUID_MIDI_PARSER_MAX_DATA_SIZE)
  1599.   {
  1600.     parser->status = 0;         /* Discard the rest of the message */
  1601.     return NULL;
  1602.   }
  1604.   /* Store next byte */
  1605.   parser->data[parser->nr_bytes++] = c;
  1607.   /* Do we still need more data to get this event complete? */
  1608.   if (parser->nr_bytes < parser->nr_bytes_total)
  1609.     return NULL;
  1611.   /* Event is complete, return it.
  1612.    * Running status byte MIDI feature is also handled here. */
  1613.   parser->event.type = parser->status;
  1614.   parser->event.channel = parser->channel;
  1615.   parser->nr_bytes = 0;         /* Reset data size, in case there are additional running status messages */
  1617.   switch (parser->status)
  1618.   {
  1619.     case NOTE_OFF:
  1620.     case NOTE_ON:
  1621.     case KEY_PRESSURE:
  1622.     case CONTROL_CHANGE:
  1623.     case PROGRAM_CHANGE:
  1624.     case CHANNEL_PRESSURE:
  1625.       parser->event.param1 = parser->data[0]; /* For example key number */
  1626.       parser->event.param2 = parser->data[1]; /* For example velocity */
  1627.       break;
  1628.     case PITCH_BEND:
  1629.       /* Pitch-bend is transmitted with 14-bit precision. */
  1630.       parser->event.param1 = (parser->data[1] << 7) | parser->data[0];
  1631.       break;
  1632.     default: /* Unlikely */
  1633.       return NULL;
  1634.   }
  1636.   return &parser->event;
  1637. }
  1639. /* Purpose:
  1640.  * Returns the length of a MIDI message. */
  1641. static int
  1642. fluid_midi_event_length(unsigned char event)
  1643. {
  1644. switch (event & 0xF0) {
  1645. case NOTE_OFF: 
  1646. case NOTE_ON:
  1647. case KEY_PRESSURE:
  1648. case CONTROL_CHANGE:
  1649. case PITCH_BEND: 
  1650. return 3;
  1651. case PROGRAM_CHANGE:
  1652. case CHANNEL_PRESSURE: 
  1653. return 2;
  1654. }
  1655. switch (event) {
  1656. case MIDI_TIME_CODE:
  1657. case MIDI_SONG_SELECT:
  1658. case 0xF4:
  1659. case 0xF5:
  1660. return 2;
  1661. case MIDI_TUNE_REQUEST:
  1662. return 1;
  1663. case MIDI_SONG_POSITION:
  1664. return 3;
  1665. }
  1666. return 1;
  1667. }