SEQ_MIDI_OUT

Data Structures

struct  seq_midi_out_queue_item_t

Defines

#define DEBUG_VERBOSE_LEVEL   1
#define SEQ_MIDI_OUT_MALLOC_FLAG_WIDTH   1
#define SEQ_MIDI_OUT_MALLOC_FLAG_MASK   1

Functions

s32 SEQ_MIDI_OUT_Init (u32 mode)
s32 SEQ_MIDI_OUT_Callback_MIDI_SendPackage_Set (void *_callback_midi_send_package)
s32 SEQ_MIDI_OUT_Callback_BPM_IsRunning_Set (void *_callback_bpm_is_running)
s32 SEQ_MIDI_OUT_Callback_BPM_TickGet_Set (void *_callback_bpm_tick_get)
s32 SEQ_MIDI_OUT_Callback_BPM_Set_Set (void *_callback_bpm_set)
s32 SEQ_MIDI_OUT_Send (mios32_midi_port_t port, mios32_midi_package_t midi_package, seq_midi_out_event_type_t event_type, u32 timestamp, u32 len)
s32 SEQ_MIDI_OUT_ReSchedule (u8 tag, seq_midi_out_event_type_t event_type, u32 timestamp, u32 *reschedule_filter)
s32 SEQ_MIDI_OUT_FlushQueue (void)
s32 SEQ_MIDI_OUT_FreeHeap (void)
s32 SEQ_MIDI_OUT_Handler (void)

Variables

u32 seq_midi_out_allocated
 contains number of events which have allocated memory

Detailed Description

Functions for schedules MIDI output

Define Documentation

#define DEBUG_VERBOSE_LEVEL   1
#define SEQ_MIDI_OUT_MALLOC_FLAG_MASK   1
#define SEQ_MIDI_OUT_MALLOC_FLAG_WIDTH   1

Function Documentation

s32 SEQ_MIDI_OUT_Callback_BPM_IsRunning_Set ( void *  _callback_bpm_is_running  ) 

Allows to change the function which is called to check if the BPM generator is running.

Together with the other callback functions, this becomes useful if the MIDI output should be rendered into a MIDI file (in this case, the function should return 1, so that SEQ_MIDI_OUT_Handler handler will generate MIDI output)

Parameters:
[in] *_callback_bpm_is_running pointer to callback function:

   s32 callback_bpm_is_running(void)
   {
     return 1; // always running
   }

If set to NULL, the default function SEQ_BPM_IsRunning function will be used. This allows you to restore the default setup properly.

Returns:
< 0 on errors

Here is the call graph for this function:

s32 SEQ_MIDI_OUT_Callback_BPM_Set_Set ( void *  _callback_bpm_set  ) 

Allows to change the function which is called to change the song tempo.

Together with the other callback functions, this becomes useful if the MIDI output should be rendered into a MIDI file (in this case, the function should add the appr. meta event into the MIDI file).

Parameters:
[in] *_callback_bpm_set pointer to callback function:

   u32 callback_bpm_set(float bpm)
   {
     // ...
     // do something with bpm value
     // ...

     return 0; // no error
   }

If set to NULL, the default function SEQ_BPM_Set function will be used. This allows you to restore the default setup properly.

Returns:
< 0 on errors

Here is the call graph for this function:

s32 SEQ_MIDI_OUT_Callback_BPM_TickGet_Set ( void *  _callback_bpm_tick_get  ) 

Allows to change the function which is called to retrieve the current BPM tick.

Together with the other callback functions, this becomes useful if the MIDI output should be rendered into a MIDI file (in this case, the function should return a number which is incremented after each rendering step).

Parameters:
[in] *_callback_bpm_tick_get pointer to callback function:

   u32 callback_bpm_tick_get(void)
   {
     return my_bpm_tick; // this variable will be incremented after each rendering step
   }

If set to NULL, the default function SEQ_BPM_TickGet function will be used. This allows you to restore the default setup properly.

Returns:
< 0 on errors

Here is the call graph for this function:

s32 SEQ_MIDI_OUT_Callback_MIDI_SendPackage_Set ( void *  _callback_midi_send_package  ) 

Allows to change the function which is called whenever a MIDI package should be sent.

This becomes useful if the MIDI output should be filtered, converted or rendered into a MIDI file.

Parameters:
[in] *_callback_midi_send_package pointer to callback function:

   s32 callback_midi_send_package(mios32_midi_port_t port, mios32_midi_package_t midi_package)
   {
     // ...
     // do something with port and midi_package
     // ...

     return 0; // no error
   }

If set to NULL, the default function MIOS32_MIDI_SendPackage function will be used. This allows you to restore the default setup properly.

Returns:
< 0 on errors

Here is the call graph for this function:

s32 SEQ_MIDI_OUT_FlushQueue ( void   ) 

This function empties the queue and plays all "off" events

Returns:
< 0 on errors
s32 SEQ_MIDI_OUT_FreeHeap ( void   ) 

This function frees the complete allocated memory.
It should only be called after SEQ_MIDI_OUT_FlushQueue to prevent stucking Note events

s32 SEQ_MIDI_OUT_Handler ( void   ) 

This function should be called periodically (1 mS) to check for timestamped MIDI events which have to be sent.

Returns:
< 0 on errors

Here is the call graph for this function:

s32 SEQ_MIDI_OUT_Init ( u32  mode  ) 

Initialisation of MIDI output scheduler

Parameters:
[in] mode currently only mode 0 supported
Returns:
< 0 if initialisation failed

Here is the call graph for this function:

s32 SEQ_MIDI_OUT_ReSchedule ( u8  tag,
seq_midi_out_event_type_t  event_type,
u32  timestamp,
u32 *  reschedule_filter 
)

This function re-schedules MIDI Off/OnOff events assigned to a given "tag" (0..15, stored in mios32_midi_package_t.cable of events which already have been sent.

Usually only SEQ_MIDI_OUT_Off events will be re-scheduled, all events which don't match the event_type will be ignored so that no special tag is required for such events.

Usecase: sustained notes can be realized this way: schedule a Note Off event at timestamp 0xffffffff, reschedule it to timestamp == bpm_tick once the sequencer determined, that the off event should be played.

Parameters:
[in] tag (0..15) the mios32_midi_package.t.cable number of events which should be re-scheduled
[in] event_type the event type which should be rescheduled
[in] timestamp the bpm_tick value at which the event should be sent
[in] reschedule_filter if != NULL, we expect a 4*32 bit word which contains flags for all Note and CC values which shouldn't be rescheduled (e.g. don't send note off for notes which are played on a keyboard)
Returns:
< 0 on errors

Here is the call graph for this function:

s32 SEQ_MIDI_OUT_Send ( mios32_midi_port_t  port,
mios32_midi_package_t  midi_package,
seq_midi_out_event_type_t  event_type,
u32  timestamp,
u32  len 
)

This function schedules a MIDI event, which will be sent over a given port at a given bpm_tick

Parameters:
[in] port MIDI port (DEFAULT, USB0..USB7, UART0..UART1, IIC0..IIC7)
[in] midi_package MIDI package If the re-schedule feature SEQ_MIDI_OUT_ReSchedule() should be used, the mios32_midi_package_t.cable field should be initialized with a tag (supported range: 0-15)
[in] event_type the event type
[in] timestamp the bpm_tick value at which the event should be sent
Returns:
0 if event has been scheduled successfully
-1 if out of memory

Here is the call graph for this function:

Variable Documentation

u32 seq_midi_out_allocated

contains number of events which have allocated memory

Generated on 22 Jan 2016 for MIOS32 by  doxygen 1.6.1