seq_engine.h

Aller à la documentation de ce fichier.

#ifndef BRICK_CORE_SEQ_SEQ_ENGINE_H_
#define BRICK_CORE_SEQ_SEQ_ENGINE_H_
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "ch.h"
 
#include "clock_manager.h"
#include "seq_model.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define SEQ_ENGINE_SCHEDULER_CAPACITY 64U
 
typedef enum {
    SEQ_ENGINE_EVENT_NOTE_ON = 0,  
    SEQ_ENGINE_EVENT_NOTE_OFF,     
    SEQ_ENGINE_EVENT_PLOCK         
} seq_engine_event_type_t;
 
typedef enum {
    SEQ_ENGINE_PLOCK_APPLY = 0,  
    SEQ_ENGINE_PLOCK_RESTORE     
} seq_engine_plock_action_t;
 
typedef struct {
    uint8_t voice;       
    uint8_t note;        
    uint8_t velocity;    
} seq_engine_note_on_t;
 
typedef struct {
    uint8_t voice;       
    uint8_t note;        
} seq_engine_note_off_t;
 
typedef struct {
    seq_model_plock_t plock;      
    seq_engine_plock_action_t action; 
} seq_engine_plock_t;
 
typedef struct {
    seq_engine_event_type_t type; 
    systime_t scheduled_time;     
    union {
        seq_engine_note_on_t note_on;   
        seq_engine_note_off_t note_off; 
        seq_engine_plock_t plock;       
    } data; 
} seq_engine_event_t;
 
typedef struct {
    seq_engine_event_t buffer[SEQ_ENGINE_SCHEDULER_CAPACITY]; 
    size_t head;    
    size_t count;   
} seq_engine_scheduler_t;
 
typedef struct {
    const seq_model_pattern_t *pattern; 
    size_t step_index;                  
    seq_model_gen_t last_generation;    
    bool step_has_playable_voice;       
    bool step_has_automation;           
} seq_engine_reader_t;
 
typedef struct {
    thread_t *thread; 
    bool running;     
} seq_engine_player_t;
 
typedef msg_t (*seq_engine_note_on_cb_t)(const seq_engine_note_on_t *note_on,
                                         systime_t scheduled_time);
typedef msg_t (*seq_engine_note_off_cb_t)(const seq_engine_note_off_t *note_off,
                                          systime_t scheduled_time);
typedef msg_t (*seq_engine_plock_cb_t)(const seq_engine_plock_t *plock,
                                       systime_t scheduled_time);
 
typedef struct {
    seq_engine_note_on_cb_t note_on; 
    seq_engine_note_off_cb_t note_off; 
    seq_engine_plock_cb_t plock; 
} seq_engine_callbacks_t;
 
typedef bool (*seq_engine_track_muted_cb_t)(uint8_t track);
 
typedef struct {
    seq_model_pattern_t *pattern; 
    seq_engine_callbacks_t callbacks; 
    seq_engine_track_muted_cb_t is_track_muted; 
} seq_engine_config_t;
 
typedef struct {
    seq_engine_reader_t reader;     
    seq_engine_scheduler_t scheduler; 
    seq_engine_player_t player;     
    seq_engine_config_t config;     
    mutex_t scheduler_lock;         
    binary_semaphore_t player_sem;  
    bool clock_attached;            
    bool voice_active[SEQ_MODEL_VOICES_PER_STEP]; 
    uint8_t voice_note[SEQ_MODEL_VOICES_PER_STEP]; 
} seq_engine_t;
 
void seq_engine_init(seq_engine_t *engine, const seq_engine_config_t *config);
void seq_engine_set_callbacks(seq_engine_t *engine, const seq_engine_callbacks_t *callbacks);
void seq_engine_attach_pattern(seq_engine_t *engine, seq_model_pattern_t *pattern);
msg_t seq_engine_start(seq_engine_t *engine);
void seq_engine_stop(seq_engine_t *engine);
void seq_engine_reset(seq_engine_t *engine);
bool seq_engine_scheduler_push(seq_engine_scheduler_t *scheduler, const seq_engine_event_t *event);
bool seq_engine_scheduler_pop(seq_engine_scheduler_t *scheduler, seq_engine_event_t *out_event);
bool seq_engine_scheduler_peek(const seq_engine_scheduler_t *scheduler, seq_engine_event_t *out_event);
void seq_engine_scheduler_clear(seq_engine_scheduler_t *scheduler);
 
void seq_engine_process_step(seq_engine_t *engine, const clock_step_info_t *info);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* BRICK_CORE_SEQ_SEQ_ENGINE_H_ */