seq_model.h

Aller à la documentation de ce fichier.

#ifndef BRICK_CORE_SEQ_SEQ_MODEL_H_
#define BRICK_CORE_SEQ_SEQ_MODEL_H_
 
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define SEQ_MODEL_STEPS_PER_PATTERN   64U
#define SEQ_MODEL_VOICES_PER_STEP     4U
#define SEQ_MODEL_MAX_PLOCKS_PER_STEP 24U
 
#define SEQ_MODEL_DEFAULT_VELOCITY_PRIMARY   100U
#define SEQ_MODEL_DEFAULT_VELOCITY_SECONDARY 0U
 
typedef struct {
    uint32_t value; 
} seq_model_gen_t;
 
typedef uint8_t seq_model_voice_state_t;
enum {
    SEQ_MODEL_VOICE_DISABLED = 0U, 
    SEQ_MODEL_VOICE_ENABLED = 1U   
};
 
typedef uint8_t seq_model_plock_domain_t;
enum {
    SEQ_MODEL_PLOCK_INTERNAL = 0U, 
    SEQ_MODEL_PLOCK_CART = 1U      
};
 
typedef uint8_t seq_model_plock_internal_param_t;
enum {
    SEQ_MODEL_PLOCK_PARAM_NOTE = 0U,  
    SEQ_MODEL_PLOCK_PARAM_VELOCITY,   
    SEQ_MODEL_PLOCK_PARAM_LENGTH,     
    SEQ_MODEL_PLOCK_PARAM_MICRO,      
    SEQ_MODEL_PLOCK_PARAM_GLOBAL_TR,  
    SEQ_MODEL_PLOCK_PARAM_GLOBAL_VE,  
    SEQ_MODEL_PLOCK_PARAM_GLOBAL_LE,  
    SEQ_MODEL_PLOCK_PARAM_GLOBAL_MI   
};
 
typedef uint8_t seq_model_quantize_grid_t;
enum {
    SEQ_MODEL_QUANTIZE_1_4 = 0U,
    SEQ_MODEL_QUANTIZE_1_8,
    SEQ_MODEL_QUANTIZE_1_16,
    SEQ_MODEL_QUANTIZE_1_32,
    SEQ_MODEL_QUANTIZE_1_64
};
 
typedef uint8_t seq_model_scale_mode_t;
enum {
    SEQ_MODEL_SCALE_CHROMATIC = 0U,
    SEQ_MODEL_SCALE_MAJOR,
    SEQ_MODEL_SCALE_MINOR,
    SEQ_MODEL_SCALE_DORIAN,
    SEQ_MODEL_SCALE_MIXOLYDIAN
};
 
typedef struct {
    int16_t value;                   
    uint16_t parameter_id;           
    seq_model_plock_domain_t domain; 
    uint8_t voice_index;             
    seq_model_plock_internal_param_t internal_param; 
} seq_model_plock_t;
 
typedef struct {
    uint8_t note;                  
    uint8_t velocity;              
    uint8_t length;                
    int8_t micro_offset;           
    seq_model_voice_state_t state; 
} seq_model_voice_t;
 
typedef struct {
    int16_t velocity;  
    int8_t transpose;  
    int8_t length;     
    int8_t micro;      
} seq_model_step_offsets_t;
 
typedef struct {
    uint8_t active : 1;     
    uint8_t automation : 1; 
    uint8_t reserved : 6;   
} seq_model_step_flags_t;
 
typedef struct {
    seq_model_voice_t voices[SEQ_MODEL_VOICES_PER_STEP]; 
    seq_model_plock_t plocks[SEQ_MODEL_MAX_PLOCKS_PER_STEP]; 
    uint8_t plock_count; 
    seq_model_step_offsets_t offsets; 
    seq_model_step_flags_t flags; 
} seq_model_step_t;
 
typedef struct {
    bool enabled;                            
    seq_model_quantize_grid_t grid;          
    uint8_t strength;                        
} seq_model_quantize_config_t;
 
typedef struct {
    int8_t global;                                   
    int8_t per_voice[SEQ_MODEL_VOICES_PER_STEP];     
} seq_model_transpose_config_t;
 
typedef struct {
    bool enabled;                  
    uint8_t root;                  
    seq_model_scale_mode_t mode;   
} seq_model_scale_config_t;
 
typedef struct {
    seq_model_quantize_config_t quantize; 
    seq_model_transpose_config_t transpose; 
    seq_model_scale_config_t scale; 
} seq_model_pattern_config_t;
 
typedef struct {
    seq_model_step_t steps[SEQ_MODEL_STEPS_PER_PATTERN]; 
    seq_model_pattern_config_t config; 
    seq_model_gen_t generation; 
} seq_model_pattern_t;
 
void seq_model_gen_reset(seq_model_gen_t *gen);
void seq_model_gen_bump(seq_model_gen_t *gen);
bool seq_model_gen_has_changed(const seq_model_gen_t *lhs, const seq_model_gen_t *rhs);
 
void seq_model_voice_init(seq_model_voice_t *voice, bool primary);
void seq_model_step_init(seq_model_step_t *step);
void seq_model_step_init_default(seq_model_step_t *step, uint8_t note);
void seq_model_step_make_neutral(seq_model_step_t *step);
void seq_model_step_make_automation_only(seq_model_step_t *step);
void seq_model_pattern_init(seq_model_pattern_t *pattern);
 
const seq_model_voice_t *seq_model_step_get_voice(const seq_model_step_t *step, size_t voice_index);
bool seq_model_step_set_voice(seq_model_step_t *step, size_t voice_index, const seq_model_voice_t *voice);
 
bool seq_model_step_add_plock(seq_model_step_t *step, const seq_model_plock_t *plock);
void seq_model_step_clear_plocks(seq_model_step_t *step);
bool seq_model_step_remove_plock(seq_model_step_t *step, size_t index);
bool seq_model_step_get_plock(const seq_model_step_t *step, size_t index, seq_model_plock_t *out);
 
void seq_model_step_set_offsets(seq_model_step_t *step, const seq_model_step_offsets_t *offsets);
const seq_model_step_offsets_t *seq_model_step_get_offsets(const seq_model_step_t *step);
 
bool seq_model_step_has_playable_voice(const seq_model_step_t *step);
bool seq_model_step_is_automation_only(const seq_model_step_t *step);
bool seq_model_step_has_any_plock(const seq_model_step_t *step);
bool seq_model_step_has_seq_plock(const seq_model_step_t *step);
bool seq_model_step_has_cart_plock(const seq_model_step_t *step);
void seq_model_step_recompute_flags(seq_model_step_t *step);
 
void seq_model_pattern_set_quantize(seq_model_pattern_t *pattern, const seq_model_quantize_config_t *config);
void seq_model_pattern_set_transpose(seq_model_pattern_t *pattern, const seq_model_transpose_config_t *config);
void seq_model_pattern_set_scale(seq_model_pattern_t *pattern, const seq_model_scale_config_t *config);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* BRICK_CORE_SEQ_SEQ_MODEL_H_ */