static short
_fluid_seq_queue_init(fluid_sequencer_t* seq, int maxEvents)
{
seq->heap = _fluid_evt_heap_init(maxEvents);
if (seq->heap == NULL) {
fluid_log(FLUID_PANIC, "sequencer: Out of memory\n");
return -1;
}
seq->preQueue = NULL;
seq->preQueueLast = NULL;
FLUID_MEMSET(seq->queue0, 0, 2*256*sizeof(fluid_evt_entry *));
FLUID_MEMSET(seq->queue1, 0, 2*255*sizeof(fluid_evt_entry *));
seq->queueLater = NULL;
seq->queue0StartTime = fluid_sequencer_get_tick(seq);
seq->prevCellNb = -1;
fluid_mutex_init(seq->mutex);
/* start timer */
if (seq->useSystemTimer) {
seq->timer = new_fluid_timer((int)(1000/seq->scale), _fluid_seq_queue_process,
(void *)seq, TRUE, FALSE, TRUE);
}
return (0);
}
fluid_evt_heap_t*
_fluid_evt_heap_init(int nbEvents)
{
#ifdef HEAP_WITH_DYNALLOC
int i;
fluid_evt_heap_t* heap;
fluid_evt_entry *tmp;
heap = FLUID_NEW(fluid_evt_heap_t);
if (heap == NULL) {
fluid_log(FLUID_PANIC, "sequencer: Out of memory\n");
return NULL;
}
heap->freelist = NULL;
fluid_mutex_init(heap->mutex);
/* LOCK */
fluid_mutex_lock(heap->mutex);
/* Allocate the event entries */
for (i = 0; i < nbEvents; i++) {
tmp = FLUID_NEW(fluid_evt_entry);
tmp->next = heap->freelist;
heap->freelist = tmp;
}
/* UNLOCK */
fluid_mutex_unlock(heap->mutex);
#else
int i;
fluid_evt_heap_t* heap;
int siz = 2*sizeof(fluid_evt_entry *) + sizeof(fluid_evt_entry)*nbEvents;
heap = (fluid_evt_heap_t *)FLUID_MALLOC(siz);
if (heap == NULL) {
fluid_log(FLUID_PANIC, "sequencer: Out of memory\n");
return NULL;
}
FLUID_MEMSET(heap, 0, siz);
/* link all heap events */
{
fluid_evt_entry *tmp = &(heap->pool);
for (i = 0 ; i < nbEvents - 1 ; i++)
tmp[i].next = &(tmp[i+1]);
tmp[nbEvents-1].next = NULL;
/* set head & tail */
heap->tail = &(tmp[nbEvents-1]);
heap->head = &(heap->pool);
}
#endif
return (heap);
}
/**
* Create a new midi router. The default rules will pass all events unmodified.
* @param settings Settings used to configure MIDI router
* @param handler MIDI event callback.
* @param event_handler_data Caller defined data pointer which gets passed to 'handler'
* @return New MIDI router instance or NULL on error
*
* The MIDI handler callback should process the possibly filtered/modified MIDI
* events from the MIDI router and forward them on to a synthesizer for example.
* The function fluid_synth_handle_midi_event() can be used for \a handle and
* a #fluid_synth_t passed as the \a event_handler_data parameter for this purpose.
*/
fluid_midi_router_t *
new_fluid_midi_router(fluid_settings_t *settings, handle_midi_event_func_t handler,
void *event_handler_data)
{
fluid_midi_router_t *router = NULL;
int i;
router = FLUID_NEW (fluid_midi_router_t);
if (router == NULL)
{
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET (router, 0, sizeof (fluid_midi_router_t));
/* Retrieve the number of MIDI channels for range limiting */
fluid_settings_getint(settings, "synth.midi-channels", &router->nr_midi_channels);
fluid_mutex_init (router->rules_mutex);
router->synth = (fluid_synth_t *)event_handler_data;
router->event_handler = handler;
router->event_handler_data = event_handler_data;
/* Create default routing rules which pass all events unmodified */
for (i = 0; i < FLUID_MIDI_ROUTER_RULE_COUNT; i++)
{
router->rules[i] = new_fluid_midi_router_rule ();
if (!router->rules[i]) goto error_recovery;
}
return router;
error_recovery:
delete_fluid_midi_router (router);
return NULL;
}
