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

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

midi

开发平台：

C/C++

fluid_seq.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.  */
  23. /*
  24.   2002 : API design by Peter Hanappe and Antoine Schmitt
  25.   August 2002 : Implementation by Antoine Schmitt as@gratin.org
  26.   as part of the infiniteCD author project
  27.   http://www.infiniteCD.org/
  28. */
  30. #include "fluid_event_priv.h"
  31. #include "fluidsynth_priv.h" // FLUID_NEW, etc
  32. #include "fluid_sys.h" // timer, threads, etc...
  33. #include "fluid_list.h"
  35. /***************************************************************
  36.  *
  37.  *                           SEQUENCER
  38.  */
  40. #define FLUID_SEQUENCER_EVENTS_MAX 1000
  42. /* Private data for SEQUENCER */
  43. struct _fluid_sequencer_t {
  44. unsigned int startMs;
  45. gint currentMs;
  46. gboolean useSystemTimer;
  47. double scale; // ticks per second
  48. fluid_list_t* clients;
  49. short clientsID;
  50. /* for queue + heap */
  51. fluid_evt_entry* preQueue;
  52. fluid_evt_entry* preQueueLast;
  53. fluid_timer_t* timer;
  54. int queue0StartTime;
  55. short prevCellNb;
  56. fluid_evt_entry* queue0[256][2];
  57. fluid_evt_entry* queue1[255][2];
  58. fluid_evt_entry* queueLater;
  59. fluid_evt_heap_t* heap;
  60. fluid_mutex_t mutex;
  61. #if FLUID_SEQ_WITH_TRACE
  62. char *tracebuf;
  63. char *traceptr;
  64. int tracelen;
  65. #endif
  66. };
  68. /* Private data for clients */
  69. typedef struct _fluid_sequencer_client_t {
  70. short id;
  71. char* name;
  72. fluid_event_callback_t callback;
  73. void* data;
  74. } fluid_sequencer_client_t;
  76. /* prototypes */
  77. static short _fluid_seq_queue_init(fluid_sequencer_t* seq, int nbEvents);
  78. static void _fluid_seq_queue_end(fluid_sequencer_t* seq);
  79. static short _fluid_seq_queue_pre_insert(fluid_sequencer_t* seq, fluid_event_t * evt);
  80. static void _fluid_seq_queue_pre_remove(fluid_sequencer_t* seq, short src, short dest, int type);
  81. static int _fluid_seq_queue_process(void* data, unsigned int msec); // callback from timer
  82. static void _fluid_seq_queue_insert_entry(fluid_sequencer_t* seq, fluid_evt_entry * evtentry);
  83. static void _fluid_seq_queue_remove_entries_matching(fluid_sequencer_t* seq, fluid_evt_entry* temp);
  84. static void _fluid_seq_queue_send_queued_events(fluid_sequencer_t* seq);
  85. static void _fluid_free_evt_queue(fluid_evt_entry** first, fluid_evt_entry** last);
  88. /* API implementation */
  90. /**
  91.  * Create a new sequencer object which uses the system timer.  Use
  92.  * new_fluid_sequencer2() to specify whether the system timer or
  93.  * fluid_sequencer_process() is used to advance the sequencer.
  94.  * @return New sequencer instance
  95.  */
  96. fluid_sequencer_t*
  97. new_fluid_sequencer (void)
  98. {
  99. return new_fluid_sequencer2 (TRUE);
  100. }
  102. /**
  103.  * Create a new sequencer object.
  104.  * @param use_system_timer If TRUE, sequencer will advance at the rate of the
  105.  *   system clock. If FALSE, call fluid_sequencer_process() to advance
  106.  *   the sequencer.
  107.  * @return New sequencer instance
  108.  * @since 1.1.0
  109.  */
  110. fluid_sequencer_t*
  111. new_fluid_sequencer2 (int use_system_timer)
  112. {
  113. fluid_sequencer_t* seq;
  115. seq = FLUID_NEW(fluid_sequencer_t);
  116. if (seq == NULL) {
  117. fluid_log(FLUID_PANIC, "sequencer: Out of memoryn");
  118. return NULL;
  119. }
  121. FLUID_MEMSET(seq, 0, sizeof(fluid_sequencer_t));
  123. seq->scale = 1000; // default value
  124. seq->useSystemTimer = use_system_timer ? TRUE : FALSE;
  125. seq->startMs = seq->useSystemTimer ? fluid_curtime() : 0;
  126. seq->clients = NULL;
  127. seq->clientsID = 0;
  129. if (-1 == _fluid_seq_queue_init(seq, FLUID_SEQUENCER_EVENTS_MAX)) {
  130. FLUID_FREE(seq);
  131. fluid_log(FLUID_PANIC, "sequencer: Out of memoryn");
  132. return NULL;
  133. }
  135. #if FLUID_SEQ_WITH_TRACE
  136. seq->tracelen = 1024*100;
  137. seq->tracebuf = (char *)FLUID_MALLOC(seq->tracelen);
  138. if (seq->tracebuf == NULL) {
  139.   _fluid_seq_queue_end(seq);
  140.   FLUID_FREE(seq);
  141. fluid_log(FLUID_PANIC, "sequencer: Out of memoryn");
  142. return NULL;
  143. }
  144. seq->traceptr = seq->tracebuf;
  145. #endif
  147. return(seq);
  148. }
  150. /**
  151.  * Free a sequencer object.
  152.  * @param seq Sequencer to delete
  153.  */
  154. void
  155. delete_fluid_sequencer (fluid_sequencer_t* seq)
  156. {
  158. if (seq == NULL) {
  159. return;
  160. }
  162. /* cleanup clients */
  163. while (seq->clients) {
  164. fluid_sequencer_client_t *client = (fluid_sequencer_client_t*)seq->clients->data;
  165. fluid_sequencer_unregister_client(seq, client->id);
  166. }
  168. _fluid_seq_queue_end(seq);
  170. /* if (seq->clients) {
  171. fluid_list_t *tmp = seq->clients;
  172. while (tmp != NULL) {
  173. fluid_sequencer_client_t *client = (fluid_sequencer_client_t*)tmp->data;
  174. if (client->name) FLUID_FREE(client->name);
  175. tmp = tmp->next;
  176. }
  177. delete_fluid_list(seq->clients);
  178. seq->clients = NULL;
  179. }*/
  181. #if FLUID_SEQ_WITH_TRACE
  182. if (seq->tracebuf != NULL)
  183. FLUID_FREE(seq->tracebuf);
  184. seq->tracebuf = NULL;
  185. #endif
  187. FLUID_FREE(seq);
  188. }
  190. /**
  191.  * Check if a sequencer is using the system timer or not.
  192.  * @param seq Sequencer object
  193.  * @return TRUE if system timer is being used, FALSE otherwise.
  194.  * @since 1.1.0
  195.  */
  196. int 
  197. fluid_sequencer_get_use_system_timer (fluid_sequencer_t* seq)
  198. {
  199. return seq->useSystemTimer ? 1 : 0;
  200. }
  203. #if FLUID_SEQ_WITH_TRACE
  205. /* trace */
  206. void
  207. fluid_seq_dotrace(fluid_sequencer_t* seq, char *fmt, ...)
  208. {
  209. va_list args;
  210. int len, remain = seq->tracelen - (seq->traceptr - seq->tracebuf);
  211. if (remain <= 0) return;
  213. va_start (args, fmt);
  214. len = vsnprintf(seq->traceptr, remain, fmt, args);
  215. va_end (args);
  217. if (len > 0) {
  218. if (len <= remain) {
  219. // all written, with 0 at end
  220. seq->traceptr += len;
  221. } else {
  222. // not enough room, set to end
  223. seq->traceptr = seq->tracebuf + seq->tracelen;
  224. }
  225. }
  227. return;
  228. }
  230. /**
  231.  * Clear sequencer trace buffer.
  232.  * @param seq Sequencer object
  233.  */
  234. void
  235. fluid_seq_cleartrace(fluid_sequencer_t* seq)
  236. {
  237. seq->traceptr = seq->tracebuf;
  238. }
  240. /**
  241.  * Get sequencer trace buffer.
  242.  * @param seq Sequencer object
  243.  */
  244. char *
  245. fluid_seq_gettrace(fluid_sequencer_t* seq)
  246. {
  247. return seq->tracebuf;
  248. }
  249. #else
  251. void fluid_seq_dotrace(fluid_sequencer_t* seq, char *fmt, ...) {}
  253. #endif // FLUID_SEQ_WITH_TRACE
  255. /* clients */
  257. /**
  258.  * Register a sequencer client.
  259.  * @param seq Sequencer object
  260.  * @param name Name of sequencer client
  261.  * @param callback Sequencer client callback or NULL for a source client.
  262.  * @param data User data to pass to the a callback
  263.  * @return Unique sequencer ID or #FLUID_FAILED on error
  264.  *
  265.  * Clients can be sources or destinations of events.  Sources don't need to
  266.  * register a callback.
  267.  */
  268. short
  269. fluid_sequencer_register_client (fluid_sequencer_t* seq, const char *name,
  270.                                  fluid_event_callback_t callback, void* data)
  271. {
  272. fluid_sequencer_client_t * client;
  273. char * nameCopy;
  275. client = FLUID_NEW(fluid_sequencer_client_t);
  276. if (client == NULL) {
  277. fluid_log(FLUID_PANIC, "sequencer: Out of memoryn");
  278. return FLUID_FAILED;
  279. }
  281. nameCopy = FLUID_STRDUP(name);
  282. if (nameCopy == NULL) {
  283. fluid_log(FLUID_PANIC, "sequencer: Out of memoryn");
  284. return FLUID_FAILED;
  285. }
  287. seq->clientsID++;
  289. client->name = nameCopy;
  290. client->id = seq->clientsID;
  291. client->callback = callback;
  292. client->data = data;
  294. seq->clients = fluid_list_append(seq->clients, (void *)client);
  296. return (client->id);
  297. }
  299. /**
  300.  * Unregister a previously registered client.
  301.  * @param seq Sequencer object
  302.  * @param id Client ID as returned by fluid_sequencer_register_client().
  303.  */
  304. void
  305. fluid_sequencer_unregister_client (fluid_sequencer_t* seq, short id)
  306. {
  307. fluid_list_t *tmp;
  308. fluid_event_t* evt;
  310. if (seq->clients == NULL) return;
  312. evt = new_fluid_event();
  313. if (evt != NULL) {
  314. fluid_event_unregistering(evt);
  315. fluid_event_set_dest(evt, id);
  316. }
  318. tmp = seq->clients;
  319. while (tmp) {
  320.    fluid_sequencer_client_t *client = (fluid_sequencer_client_t*)tmp->data;
  322.    if (client->id == id) {
  323. /* What should we really do if evt is null due to out-of-memory? */
  324. if (client->callback != NULL && evt != NULL)
  325. (client->callback)(fluid_sequencer_get_tick(seq),
  326.  evt, seq, client->data);
  327.     if (client->name)
  328. FLUID_FREE(client->name);
  329. seq->clients = fluid_list_remove_link(seq->clients, tmp);
  330. delete1_fluid_list(tmp);
  331. FLUID_FREE(client);
  332. delete_fluid_event(evt);
  333. return;
  334.    }
  335.     tmp = tmp->next;
  336. }
  337. delete_fluid_event(evt);
  338. return;
  339. }
  341. /**
  342.  * Count a sequencers registered clients.
  343.  * @param seq Sequencer object
  344.  * @return Count of sequencer clients.
  345.  */
  346. int
  347. fluid_sequencer_count_clients(fluid_sequencer_t* seq)
  348. {
  349. if (seq->clients == NULL)
  350. return 0;
  351. return fluid_list_size(seq->clients);
  352. }
  354. /**
  355.  * Get a client ID from its index (order in which it was registered).
  356.  * @param seq Sequencer object
  357.  * @param index Index of register client
  358.  * @return Client ID or #FLUID_FAILED if not found
  359.  */
  360. short fluid_sequencer_get_client_id (fluid_sequencer_t* seq, int index)
  361. {
  362. fluid_list_t *tmp = fluid_list_nth(seq->clients, index);
  363. if (tmp == NULL) {
  364. return FLUID_FAILED;
  365. } else {
  366. fluid_sequencer_client_t *client = (fluid_sequencer_client_t*)tmp->data;
  367. return client->id;
  368. }
  369. }
  371. /**
  372.  * Get the name of a registered client.
  373.  * @param seq Sequencer object
  374.  * @param id Client ID
  375.  * @return Client name or NULL if not found.  String is internal and should not
  376.  *   be modified or freed.
  377.  */
  378. char *
  379. fluid_sequencer_get_client_name(fluid_sequencer_t* seq, int id)
  380. {
  381. fluid_list_t *tmp;
  383. if (seq->clients == NULL)
  384. return NULL;
  386. tmp = seq->clients;
  387. while (tmp) {
  388.    fluid_sequencer_client_t *client = (fluid_sequencer_client_t*)tmp->data;
  390.    if (client->id == id)
  391.    return client->name;
  393.     tmp = tmp->next;
  394. }
  395. return NULL;
  396. }
  398. /**
  399.  * Check if a client is a destination client.
  400.  * @param seq Sequencer object
  401.  * @param id Client ID
  402.  * @return TRUE if client is a destination client, FALSE otherwise or if not found
  403.  */
  404. int
  405. fluid_sequencer_client_is_dest(fluid_sequencer_t* seq, int id)
  406. {
  407. fluid_list_t *tmp;
  409. if (seq->clients == NULL) return FALSE;
  411. tmp = seq->clients;
  412. while (tmp) {
  413.    fluid_sequencer_client_t *client = (fluid_sequencer_client_t*)tmp->data;
  415.    if (client->id == id)
  416.    return (client->callback != NULL);
  418.     tmp = tmp->next;
  419. }
  420. return FALSE;
  421. }
  423. /**
  424.  * Send an event immediately.
  425.  * @param seq Sequencer object
  426.  * @param evt Event to send (copied)
  427.  */
  428. /* Event not actually copied, but since its used immediately it virtually is. */
  429. void
  430. fluid_sequencer_send_now(fluid_sequencer_t* seq, fluid_event_t* evt)
  431. {
  432. short destID = fluid_event_get_dest(evt);
  434. /* find callback */
  435. fluid_list_t *tmp = seq->clients;
  436. while (tmp) {
  437.    fluid_sequencer_client_t *dest = (fluid_sequencer_client_t*)tmp->data;
  439.    if (dest->id == destID) {
  440. if (dest->callback)
  441. (dest->callback)(fluid_sequencer_get_tick(seq),
  442.  evt, seq, dest->data);
  443. return;
  444.    }
  445.     tmp = tmp->next;
  446. }
  447. }
  449. /**
  450.  * Schedule an event for sending at a later time.
  451.  * @param seq Sequencer object
  452.  * @param evt Event to send
  453.  * @param time Time value in ticks (in milliseconds with the default time scale of 1000).
  454.  * @param absolute TRUE if a time is absolute sequencer time (time since sequencer
  455.  *   creation), FALSE if relative to current time.
  456.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  457.  */
  458. int
  459. fluid_sequencer_send_at (fluid_sequencer_t* seq, fluid_event_t* evt,
  460.                          unsigned int time, int absolute)
  461. {
  462. unsigned int now = fluid_sequencer_get_tick(seq);
  464. /* set absolute */
  465. if (!absolute)
  466. time = now + time;
  468. /* time stamp event */
  469. fluid_event_set_time(evt, time);
  471. /* queue for processing later */
  472. return _fluid_seq_queue_pre_insert(seq, evt);
  473. }
  475. /**
  476.  * Remove events from the event queue.
  477.  * @param seq Sequencer object
  478.  * @param source Source client ID to match or -1 for wildcard
  479.  * @param dest Destination client ID to match or -1 for wildcard
  480.  * @param type Event type to match or -1 for wildcard (#fluid_seq_event_type)
  481.  */
  482. void
  483. fluid_sequencer_remove_events (fluid_sequencer_t* seq, short source,
  484.                                short dest, int type)
  485. {
  486. _fluid_seq_queue_pre_remove(seq, source, dest, type);
  487. }
  490. /*************************************
  491. time
  492. **************************************/
  494. /**
  495.  * Get the current tick of a sequencer.
  496.  * @param seq Sequencer object
  497.  * @return Current tick value
  498.  */
  499. unsigned int
  500. fluid_sequencer_get_tick (fluid_sequencer_t* seq)
  501. {
  502. unsigned int absMs = seq->useSystemTimer ? (int) fluid_curtime() : g_atomic_int_get(&seq->currentMs);
  503. double nowFloat;
  504. unsigned int now;
  505. nowFloat = ((double)(absMs - seq->startMs))*seq->scale/1000.0f;
  506. now = nowFloat;
  507. return now;
  508. }
  510. /**
  511.  * Set the time scale of a sequencer.
  512.  * @param seq Sequencer object
  513.  * @param scale Sequencer scale value in ticks per second
  514.  *   (default is 1000 for 1 tick per millisecond, max is 1000.0)
  515.  *
  516.  * If there are already scheduled events in the sequencer and the scale is changed
  517.  * the events are adjusted accordingly.
  518.  */
  519. void
  520. fluid_sequencer_set_time_scale (fluid_sequencer_t* seq, double scale)
  521. {
  522. if (scale <= 0) {
  523. fluid_log(FLUID_WARN, "sequencer: scale <= 0 : %fn", scale);
  524. return;
  525. }
  527. if (scale > 1000.0)
  528. // Otherwise : problems with the timer = 0ms...
  529. scale = 1000.0;
  531. if (seq->scale != scale) {
  532. double oldScale = seq->scale;
  534. // stop timer
  535. if (seq->timer) {
  536. delete_fluid_timer(seq->timer);
  537. seq->timer = NULL;
  538. }
  540. seq->scale = scale;
  542. // change start0 so that cellNb is preserved
  543. seq->queue0StartTime =  (seq->queue0StartTime + seq->prevCellNb)*(seq->scale/oldScale) - seq->prevCellNb;
  545. // change all preQueue events for new scale
  546. {
  547. fluid_evt_entry* tmp;
  548. tmp = seq->preQueue;
  549. while (tmp) {
  550. if (tmp->entryType == FLUID_EVT_ENTRY_INSERT)
  551. tmp->evt.time = tmp->evt.time*seq->scale/oldScale;
  553. tmp = tmp->next;
  554. }
  555. }
  557. /* re-start timer */
  558. if (seq->useSystemTimer) {
  559. seq->timer = new_fluid_timer((int)(1000/seq->scale), _fluid_seq_queue_process, (void *)seq, TRUE, FALSE, TRUE);
  560. }
  561. }
  562. }
  564. /**
  565.  * Get a sequencer's time scale.
  566.  * @param seq Sequencer object.
  567.  * @return Time scale value in ticks per second.
  568.  */
  569. double
  570. fluid_sequencer_get_time_scale(fluid_sequencer_t* seq)
  571. {
  572. return seq->scale;
  573. }
  576. /**********************
  578.       the queue
  580. **********************/
  582. /*
  583.   The queue stores all future events to be processed.
  585.   Data structures
  587.   There is a heap, allocated at init time, for managing a pool
  588.   of event entries, that is description of an event, its time,
  589.   and whether it is a normal event or a removal command.
  591.   The queue is separated in two arrays, and a list.  The first
  592.   array 'queue0' corresponds to the events to be sent in the
  593.   next 256 ticks (0 to 255), the second array 'queue1' contains
  594.   the events to be send from now+256 to now+65535. The list
  595.   called 'queueLater' contains the events to be sent later than
  596.   that. In each array, one cell contains a list of events having
  597.   the same time (in the queue0 array), or the same time/256 (in
  598.   the queue1 array), and a pointer to the last event in the list
  599.   of the cell so as to be able to insert fast at the end of the
  600.   list (i.e. a cell = 2 pointers).  The 'queueLater' list is
  601.   ordered by time and by post time.  This way, inserting 'soon'
  602.   events is fast (below 65535 ticks, that is about 1 minute if 1
  603.   tick=1ms).  Inserting later events is more slow, but this is a
  604.   realtime engine, isn't it ?
  606.   The queue0 starts at queue0StartTime.  When 256 ticks have
  607.   elapsed, the queue0 array is emptied, and the first cell of
  608.   the queue1 array is expanded in the queue0 array, according to
  609.   the time of each event. The queue1 array is shifted to the
  610.   left, and the first events of the queueLater list are inserte
  611.   in the last cell of the queue1 array.
  613.   We remember the previously managed cell in queue0 in the
  614.   prevCellNb variable. When processing the current cell, we
  615.   process the events in between (late events).
  617.   Functions
  619.   The main thread functions first get an event entry from the
  620.   heap, and copy the given event into it, then merely enqueue it
  621.   in a preQueue. This is in order to protect the data structure:
  622.   everything is managed in the callback (thread or interrupt,
  623.   depending on the architecture).
  625.   All queue data structure management is done in a timer
  626.   callback: '_fluid_seq_queue_process'.  The
  627.   _fluid_seq_queue_process function first process the preQueue,
  628.   inserting or removing event entrys from the queue, then
  629.   processes the queue, by sending events ready to be sent at the
  630.   current time.
  632.   Critical sections between the main thread (or app) and the
  633.   sequencer thread (or interrupt) are:
  635.   - the heap management (if two threads get a free event at the
  636.   same time)
  637.   - the preQueue access.
  639.   These are really small and fast sections (merely a pointer or
  640.   two changing value). They are not protected by a mutex for now
  641.   (August 2002). Waiting for crossplatform mutex solutions. When
  642.   changing this code, beware that the
  643.   _fluid_seq_queue_pre_insert function may be called by the
  644.   callback of the queue thread (ex : a note event inserts a
  645.   noteoff event).
  647. */
  650. /********************/
  651. /*       API        */
  652. /********************/
  654. static short
  655. _fluid_seq_queue_init(fluid_sequencer_t* seq, int maxEvents)
  656. {
  657. seq->heap = _fluid_evt_heap_init(maxEvents);
  658. if (seq->heap == NULL) {
  659. fluid_log(FLUID_PANIC, "sequencer: Out of memoryn");
  660. return -1;
  661. }
  663. seq->preQueue = NULL;
  664. seq->preQueueLast = NULL;
  666. FLUID_MEMSET(seq->queue0, 0, 2*256*sizeof(fluid_evt_entry *));
  667. FLUID_MEMSET(seq->queue1, 0, 2*255*sizeof(fluid_evt_entry *));
  669. seq->queueLater = NULL;
  670. seq->queue0StartTime = fluid_sequencer_get_tick(seq);
  671. seq->prevCellNb = -1;
  673. fluid_mutex_init(seq->mutex);
  675. /* start timer */
  676. if (seq->useSystemTimer) {
  677. seq->timer = new_fluid_timer((int)(1000/seq->scale), _fluid_seq_queue_process,
  678.      (void *)seq, TRUE, FALSE, TRUE);
  679. }
  680. return (0);
  681. }
  683. static void
  684. _fluid_seq_queue_end(fluid_sequencer_t* seq)
  685. {
  686. int i;
  688. /* free all remaining events */
  689. _fluid_free_evt_queue(&seq->preQueue, &seq->preQueueLast);
  690. for (i = 0; i < 256; i++) 
  691. _fluid_free_evt_queue(&(seq->queue0[i][0]), &(seq->queue0[i][1]));
  692. for (i = 0; i < 255; i++) 
  693. _fluid_free_evt_queue(&(seq->queue1[i][0]), &(seq->queue1[i][1]));
  694. _fluid_free_evt_queue(&seq->queueLater, NULL);
  697. if (seq->timer) {
  698. delete_fluid_timer(seq->timer);
  699. seq->timer = NULL;
  700. }
  702. if (seq->heap) {
  703. _fluid_evt_heap_free(seq->heap);
  704. seq->heap = NULL;
  705. }
  707. fluid_mutex_destroy(seq->mutex);
  708. }
  712. /********************/
  713. /* queue management */
  714. /********************/
  716. /* Create event_entry and append to the preQueue.
  717.  * May be called from the main thread (usually) but also recursively
  718.  * from the queue thread, when a callback itself does an insert... */
  719. static short
  720. _fluid_seq_queue_pre_insert(fluid_sequencer_t* seq, fluid_event_t * evt)
  721. {
  722. fluid_evt_entry * evtentry = _fluid_seq_heap_get_free(seq->heap);
  723. if (evtentry == NULL) {
  724. /* should not happen */
  725. fluid_log(FLUID_PANIC, "sequencer: no more free eventsn");
  726. return -1;
  727. }
  729. evtentry->next = NULL;
  730. evtentry->entryType = FLUID_EVT_ENTRY_INSERT;
  731. FLUID_MEMCPY(&(evtentry->evt), evt, sizeof(fluid_event_t));
  733. fluid_mutex_lock(seq->mutex);
  735. /* append to preQueue */
  736. if (seq->preQueueLast) {
  737. seq->preQueueLast->next = evtentry;
  738. } else {
  739. seq->preQueue = evtentry;
  740. }
  741. seq->preQueueLast = evtentry;
  743. fluid_mutex_unlock(seq->mutex);
  745. return (0);
  746. }
  748. /* Create event_entry and append to the preQueue.
  749.  * May be called from the main thread (usually) but also recursively
  750.  * from the queue thread, when a callback itself does an insert... */
  751. static void
  752. _fluid_seq_queue_pre_remove(fluid_sequencer_t* seq, short src, short dest, int type)
  753. {
  754. fluid_evt_entry * evtentry = _fluid_seq_heap_get_free(seq->heap);
  755. if (evtentry == NULL) {
  756. /* should not happen */
  757. fluid_log(FLUID_PANIC, "sequencer: no more free eventsn");
  758. return;
  759. }
  761. evtentry->next = NULL;
  762. evtentry->entryType = FLUID_EVT_ENTRY_REMOVE;
  763. {
  764. fluid_event_t* evt = &(evtentry->evt);
  765. fluid_event_set_source(evt, src);
  766. fluid_event_set_source(evt, src);
  767. fluid_event_set_dest(evt, dest);
  768. evt->type = type;
  769. }
  771. fluid_mutex_lock(seq->mutex);
  773. /* append to preQueue */
  774. if (seq->preQueueLast) {
  775. seq->preQueueLast->next = evtentry;
  776. } else {
  777. seq->preQueue = evtentry;
  778. }
  779. seq->preQueueLast = evtentry;
  781. fluid_mutex_unlock(seq->mutex);
  782. return;
  783. }
  785. static void
  786. _fluid_free_evt_queue(fluid_evt_entry** first, fluid_evt_entry** last)
  787. {
  788. fluid_evt_entry* tmp2;
  789. fluid_evt_entry* tmp = *first;
  790. while (tmp != NULL) {
  791. tmp2 = tmp->next;
  792. FLUID_FREE(tmp);
  793. tmp = tmp2;
  794. }
  795. *first = NULL;
  796. if (last != NULL) {
  797. *last = NULL;
  798. }
  799. }
  801. /* Callback from timer (may be in a different thread, or in an interrupt) */
  802. static int
  803. _fluid_seq_queue_process(void* data, unsigned int msec)
  804. {
  805. fluid_sequencer_t* seq = (fluid_sequencer_t *)data;
  806. fluid_sequencer_process(seq, msec);
  807. /* continue timer */
  808. return 1;
  809. }
  811. /** 
  812.  * Advance a sequencer that isn't using the system timer.
  813.  * @param seq Sequencer object
  814.  * @param msec Time to advance sequencer to (absolute time since sequencer start).
  815.  * @since 1.1.0
  816.  */
  817. void
  818. fluid_sequencer_process(fluid_sequencer_t* seq, unsigned int msec)
  819. {
  821. /* process prequeue */
  822. fluid_evt_entry* tmp;
  823. fluid_evt_entry* next;
  825. fluid_mutex_lock(seq->mutex);
  827. /* get the preQueue */
  828. tmp = seq->preQueue;
  829. seq->preQueue = NULL;
  830. seq->preQueueLast = NULL;
  832. fluid_mutex_unlock(seq->mutex);
  834. /* walk all the preQueue and process them in order : inserts and removes */
  835. while (tmp) {
  836. next = tmp->next;
  838. if (tmp->entryType == FLUID_EVT_ENTRY_REMOVE) {
  839. _fluid_seq_queue_remove_entries_matching(seq, tmp);
  840. } else {
  841. _fluid_seq_queue_insert_entry(seq, tmp);
  842. }
  844. tmp = next;
  845. }
  847. /* send queued events */
  848. g_atomic_int_set(&seq->currentMs, msec);
  849. _fluid_seq_queue_send_queued_events(seq);
  851. }
  853. #if 0
  854. static void
  855. _fluid_seq_queue_print_later(fluid_sequencer_t* seq)
  856. {
  857. int count = 0;
  858. fluid_evt_entry* tmp = seq->queueLater;
  860. printf("queueLater:n");
  862. while (tmp) {
  863. unsigned int delay = tmp->evt.time - seq->queue0StartTime;
  864. printf("queueLater: Delay = %in", delay);
  865. tmp = tmp->next;
  866. count++;
  867. }
  868. printf("queueLater: Total of %i eventsn", count);
  869. }
  870. #endif
  872. static void
  873. _fluid_seq_queue_insert_queue0(fluid_sequencer_t* seq, fluid_evt_entry* tmp, int cell)
  874. {
  875. if (seq->queue0[cell][1] == NULL) {
  876. seq->queue0[cell][1] = seq->queue0[cell][0] = tmp;
  877. } else {
  878. seq->queue0[cell][1]->next = tmp;
  879. seq->queue0[cell][1] = tmp;
  880. }
  881. tmp->next = NULL;
  882. }
  884. static void
  885. _fluid_seq_queue_insert_queue1(fluid_sequencer_t* seq, fluid_evt_entry* tmp, int cell)
  886. {
  887. if (seq->queue1[cell][1] == NULL) {
  888. seq->queue1[cell][1] = seq->queue1[cell][0] = tmp;
  889. } else {
  890. seq->queue1[cell][1]->next = tmp;
  891. seq->queue1[cell][1] = tmp;
  892. }
  893. tmp->next = NULL;
  894. }
  896. static void
  897. _fluid_seq_queue_insert_queue_later(fluid_sequencer_t* seq, fluid_evt_entry* evtentry)
  898. {
  899. fluid_evt_entry* prev;
  900. fluid_evt_entry* tmp;
  901. unsigned int time = evtentry->evt.time;
  903. /* insert in 'queueLater', after the ones that have the same
  904.  * time */
  906. /* first? */
  907. if ((seq->queueLater == NULL)
  908.     || (seq->queueLater->evt.time > time)) {
  909. evtentry->next = seq->queueLater;
  910. seq->queueLater = evtentry;
  911. return;
  912. }
  914. /* walk queueLater */
  915. /* this is the only slow thing : if the event is more
  916.    than 65535 ticks after the current time */
  918. prev = seq->queueLater;
  919. tmp = prev->next;
  920. while (tmp) {
  921. if (tmp->evt.time > time) {
  922. /* insert before tmp */
  923. evtentry->next = tmp;
  924. prev->next = evtentry;
  925. return;
  926. }
  927. prev = tmp;
  928. tmp = prev->next;
  929. }
  931. /* last */
  932. evtentry->next = NULL;
  933. prev->next = evtentry;
  934. }
  936. static void
  937. _fluid_seq_queue_insert_entry(fluid_sequencer_t* seq, fluid_evt_entry * evtentry)
  938. {
  939. /* time is relative to seq origin, in ticks */
  940. fluid_event_t * evt = &(evtentry->evt);
  941. unsigned int time = evt->time;
  942. unsigned int delay;
  944. if (seq->queue0StartTime > 0) {
  945. /* queue0StartTime could be < 0 if the scale changed a
  946.    lot early, breaking the following comparison
  947. */
  948. if (time < (unsigned int)seq->queue0StartTime) {
  949. /* we are late, send now */
  950. fluid_sequencer_send_now(seq, evt);
  952. _fluid_seq_heap_set_free(seq->heap, evtentry);
  953. return;
  954. }
  955. }
  957. if (seq->prevCellNb >= 0) {
  958. /* prevCellNb could be -1 is seq was just started - unlikely */
  959. /* prevCellNb can also be -1 if cellNb was reset to 0 in
  960.    _fluid_seq_queue_send_queued_events() */
  961. if (time <= (unsigned int)(seq->queue0StartTime + seq->prevCellNb)) {
  962. /* we are late, send now */
  963. fluid_sequencer_send_now(seq, evt);
  965. _fluid_seq_heap_set_free(seq->heap, evtentry);
  966. return;
  967. }
  968. }
  970. delay = time - seq->queue0StartTime;
  972. if (delay > 65535) {
  973. _fluid_seq_queue_insert_queue_later(seq, evtentry);
  975. } else if (delay > 255) {
  976. _fluid_seq_queue_insert_queue1(seq, evtentry, delay/256 - 1);
  978. } else {
  979. _fluid_seq_queue_insert_queue0(seq, evtentry, delay);
  980. }
  981. }
  983. static int
  984. _fluid_seq_queue_matchevent(fluid_event_t* evt, int templType, short templSrc, short templDest)
  985. {
  986. int eventType;
  988. if (templSrc != -1 && templSrc != fluid_event_get_source(evt))
  989. return 0;
  991. if (templDest != -1 && templDest != fluid_event_get_dest(evt))
  992. return 0;
  994. if (templType == -1)
  995. return 1;
  997. eventType = fluid_event_get_type(evt);
  999. if (templType == eventType)
  1000. return 1;
  1002. if (templType == FLUID_SEQ_ANYCONTROLCHANGE)
  1003. if (eventType == FLUID_SEQ_PITCHBEND ||
  1004.     eventType == FLUID_SEQ_MODULATION ||
  1005.     eventType == FLUID_SEQ_SUSTAIN ||
  1006.     eventType == FLUID_SEQ_PAN ||
  1007.     eventType == FLUID_SEQ_VOLUME ||
  1008.     eventType == FLUID_SEQ_REVERBSEND ||
  1009.     eventType == FLUID_SEQ_CONTROLCHANGE ||
  1010.     eventType == FLUID_SEQ_CHORUSSEND)
  1011. return 1;
  1013. return 0;
  1014. }
  1016. static void
  1017. _fluid_seq_queue_remove_entries_matching(fluid_sequencer_t* seq, fluid_evt_entry* templ)
  1018. {
  1019. /* we walk everything : this is slow, but that is life */
  1020. int i, type;
  1021. short src, dest;
  1023. src = templ->evt.src;
  1024. dest = templ->evt.dest;
  1025. type = templ->evt.type;
  1027. /* we can set it free now */
  1028. _fluid_seq_heap_set_free(seq->heap, templ);
  1030. /* queue0 */
  1031. for (i = 0 ; i < 256 ; i++) {
  1032. fluid_evt_entry* tmp = seq->queue0[i][0];
  1033. fluid_evt_entry* prev = NULL;
  1034. while (tmp) {
  1035. /* remove and/or walk */
  1036. if (_fluid_seq_queue_matchevent((&tmp->evt), type, src, dest)) {
  1037. /* remove */
  1038. if (prev) {
  1039. prev->next = tmp->next;
  1040. if (tmp == seq->queue0[i][1]) // last one in list
  1041. seq->queue0[i][1] = prev;
  1043. _fluid_seq_heap_set_free(seq->heap, tmp);
  1044. tmp = prev->next;
  1045. } else {
  1046. /* first one in list */
  1047. seq->queue0[i][0] = tmp->next;
  1048. if (tmp == seq->queue0[i][1]) // last one in list
  1049. seq->queue0[i][1] = NULL;
  1051. _fluid_seq_heap_set_free(seq->heap, tmp);
  1052. tmp = seq->queue0[i][0];
  1053. }
  1054. } else {
  1055. prev = tmp;
  1056. tmp = prev->next;
  1057. }
  1058. }
  1059. }
  1061. /* queue1 */
  1062. for (i = 0 ; i < 255 ; i++) {
  1063. fluid_evt_entry* tmp = seq->queue1[i][0];
  1064. fluid_evt_entry* prev = NULL;
  1065. while (tmp) {
  1066. if (_fluid_seq_queue_matchevent((&tmp->evt), type, src, dest)) {
  1067. /* remove */
  1068. if (prev) {
  1069. prev->next = tmp->next;
  1070. if (tmp == seq->queue1[i][1]) // last one in list
  1071. seq->queue1[i][1] = prev;
  1073. _fluid_seq_heap_set_free(seq->heap, tmp);
  1074. tmp = prev->next;
  1075. } else {
  1076. /* first one in list */
  1077. seq->queue1[i][0] = tmp->next;
  1078. if (tmp == seq->queue1[i][1]) // last one in list
  1079. seq->queue1[i][1] = NULL;
  1081. _fluid_seq_heap_set_free(seq->heap, tmp);
  1082. tmp = seq->queue1[i][0];
  1083. }
  1084. } else {
  1085. prev = tmp;
  1086. tmp = prev->next;
  1087. }
  1088. }
  1089. }
  1091. /* queueLater */
  1092. {
  1093. fluid_evt_entry* tmp = seq->queueLater;
  1094. fluid_evt_entry* prev = NULL;
  1095. while (tmp) {
  1096. if (_fluid_seq_queue_matchevent((&tmp->evt), type, src, dest)) {
  1097. /* remove */
  1098. if (prev) {
  1099. prev->next = tmp->next;
  1101. _fluid_seq_heap_set_free(seq->heap, tmp);
  1102. tmp = prev->next;
  1103. } else {
  1104. seq->queueLater = tmp->next;
  1106. _fluid_seq_heap_set_free(seq->heap, tmp);
  1107. tmp = seq->queueLater;
  1108. }
  1109. } else {
  1110. prev = tmp;
  1111. tmp = prev->next;
  1112. }
  1113. }
  1114. }
  1115. }
  1117. static void
  1118. _fluid_seq_queue_send_cell_events(fluid_sequencer_t* seq, int cellNb)
  1119. {
  1120. fluid_evt_entry* next;
  1121. fluid_evt_entry* tmp;
  1123. tmp = seq->queue0[cellNb][0];
  1124. while (tmp) {
  1125. fluid_sequencer_send_now(seq, &(tmp->evt));
  1127. next = tmp->next;
  1129. _fluid_seq_heap_set_free(seq->heap, tmp);
  1130. tmp = next;
  1131. }
  1132. seq->queue0[cellNb][0] = NULL;
  1133. seq->queue0[cellNb][1] = NULL;
  1134. }
  1136. static void
  1137. _fluid_seq_queue_slide(fluid_sequencer_t* seq)
  1138. {
  1139. short i;
  1140. fluid_evt_entry* next;
  1141. fluid_evt_entry* tmp;
  1142. int count = 0;
  1144. /* do the slide */
  1145. seq->queue0StartTime += 256;
  1147. /* sort all queue1[0] into queue0 according to new queue0StartTime */
  1148. tmp = seq->queue1[0][0];
  1149. while (tmp) {
  1150. unsigned int delay = tmp->evt.time - seq->queue0StartTime;
  1151. next = tmp->next;
  1152. if (delay > 255) {
  1153. /* should not happen !! */
  1154. /* append it to queue1[1] */
  1155. _fluid_seq_queue_insert_queue1(seq, tmp, 1);
  1156. } else {
  1157. _fluid_seq_queue_insert_queue0(seq, tmp, delay);
  1158. }
  1159. tmp = next;
  1160. count++;
  1161. }
  1163. /* slide all queue1[i] into queue1[i-1] */
  1164. for (i = 1 ; i < 255 ; i++) {
  1165. seq->queue1[i-1][0] = seq->queue1[i][0];
  1166. seq->queue1[i-1][1] = seq->queue1[i][1];
  1167. }
  1168. seq->queue1[254][0] = NULL;
  1169. seq->queue1[254][1] = NULL;
  1172. /* append queueLater to queue1[254] */
  1173. count = 0;
  1174. tmp = seq->queueLater;
  1175. while (tmp) {
  1176. unsigned int delay = tmp->evt.time - seq->queue0StartTime;
  1178. if (delay > 65535) {
  1179. break;
  1180. }
  1182. next = tmp->next;
  1184. /* append it */
  1185. _fluid_seq_queue_insert_queue1(seq, tmp, 254);
  1186. tmp = next;
  1187. count++;
  1188. }
  1190. seq->queueLater = tmp;
  1191. }
  1193. static void
  1194. _fluid_seq_queue_send_queued_events(fluid_sequencer_t* seq)
  1195. {
  1196. unsigned int nowTicks = fluid_sequencer_get_tick(seq);
  1197. short cellNb;
  1199. cellNb = seq->prevCellNb + 1;
  1200. while (cellNb <= (int)(nowTicks - seq->queue0StartTime)) {
  1201. if (cellNb == 256) {
  1202. cellNb = 0;
  1203. _fluid_seq_queue_slide(seq);
  1204. } /* slide */
  1207. /* process queue0[cellNb] */
  1208. _fluid_seq_queue_send_cell_events(seq, cellNb);
  1210. /* next cell */
  1211. cellNb++;
  1212. }
  1214. seq->prevCellNb = cellNb - 1;
  1215. }