midiPlayer.h

Go to the documentation of this file.

#pragma once

 
//==============================================================================
// Includes
//==============================================================================
 
#include "swSynth.h"
#include "midiFileParser.h"
#include "cnfs_image.h"
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
 
//==============================================================================
// Defines
//==============================================================================
 
#define MIDI_CHANNEL_COUNT 16
// The total number of pooled voices
#define POOL_VOICE_COUNT 24
// The number of voices reserved for percussion
#define PERCUSSION_VOICES 8
// The number of oscillators each voice gets. Maybe we'll need more than one for like, chorus?
#define OSC_PER_VOICE 1
// The number of global MIDI players
#define NUM_GLOBAL_PLAYERS 2
// The index of the system-wide MIDI player for sound effects
#define MIDI_SFX 0
// The index of the system-wide MIDI player for background music
#define MIDI_BGM 1
// The maximum volume setting for globalMidiPlayerSetVolume()
#define MAX_VOLUME 13
 
#define MIDI_TRUE         0x7F
#define MIDI_FALSE        0x00
#define MIDI_TO_BOOL(val) (val > 63)
#define BOOL_TO_MIDI(val) (val ? MIDI_TRUE : MIDI_FALSE)
#define MIDI_DEF_HEADROOM 0x2666
#define PITCH_BEND_CENTER 0x2000

#define SAMPLES_TO_MIDI_TICKS(n, tempo, div) ((int64_t)(n) * 1000000 * (div) / DAC_SAMPLE_RATE_HZ / (tempo))

#define TICKS_TO_SAMPLES(ticks, tempo, div) ((int64_t)(ticks) * DAC_SAMPLE_RATE_HZ / (1000000) * (tempo) / (div))

#define SAMPLES_TO_MS(samp) (((samp) * 1000) / DAC_SAMPLE_RATE_HZ)

#define SAMPLES_TO_US(samp) (((samp) * 1000000) / DAC_SAMPLE_RATE_HZ)

#define MS_TO_SAMPLES(ms) ((ms) * DAC_SAMPLE_RATE_HZ / 1000)

#define MIDI_TICKS_TO_US(ticks, tempo, div) (int64_t)((int64_t)((int64_t)(ticks) * (int64_t)(tempo)) / ((int64_t)(div)))

typedef void (*songFinishedCbFn)(void);
 
//==============================================================================
// Enums
//==============================================================================

typedef enum
{
    MIDI_STREAMING,

    MIDI_FILE,
} midiPlayerMode_t;
typedef enum {…};

typedef enum
{
    WAVETABLE,
    SAMPLE,
    NOISE,
    WAVE_SHAPE,
} timbreType_t;
typedef enum {…};

typedef enum
{
    TF_NONE = 0,
    TF_PERCUSSION = 1,
    TF_MONO = 2,
} timbreFlags_t;
typedef enum {…};

typedef enum
{
    // Roland GS Extensions
    /*HIGH_Q_OR_FILTER_SNAP = 27,
    SLAP_NOISE = 28,
    SCRATCH_PUSH = 29,
    SCRATCH_PULL = 30,
    DRUM_STICKS = 31,
    SQUARE_CLICK = 32,
    METRONOME_CLICK = 33,
    METRONOME_BELL = 34,*/
    // End Roland GS Extensions
    ACOUSTIC_BASS_DRUM_OR_LOW_BASS_DRUM  = 35,
    ELECTRIC_BASS_DRUM_OR_HIGH_BASS_DRUM = 36,
    SIDE_STICK                           = 37,
    ACOUSTIC_SNARE                       = 38,
    HAND_CLAP                            = 39,
    ELECTRIC_SNARE_OR_RIMSHOT            = 40,
    LOW_FLOOR_TOM                        = 41,
    CLOSED_HI_HAT  = 42,
    HIGH_FLOOR_TOM = 43,
    PEDAL_HI_HAT = 44,
    LOW_TOM      = 45,
    OPEN_HI_HAT     = 46,
    LOW_MID_TOM     = 47,
    HIGH_MID_TOM    = 48,
    CRASH_CYMBAL_1  = 49,
    HIGH_TOM        = 50,
    RIDE_CYMBAL_1   = 51,
    CHINESE_CYMBAL  = 52,
    RIDE_BELL       = 53,
    TAMBOURINE      = 54,
    SPLASH_CYMBAL   = 55,
    COWBELL         = 56,
    CRASH_CYMBAL_2  = 57,
    VIBRASLAP       = 58,
    RIDE_CYMBAL_2   = 59,
    HIGH_BONGO      = 60,
    LOW_BONGO       = 61,
    MUTE_HIGH_CONGA = 62,
    OPEN_HIGH_CONGA = 63,
    LOW_CONGA       = 64,
    HIGH_TIMBALE    = 65,
    LOW_TIMBALE     = 66,
    HIGH_AGOGO      = 67,
    LOW_AGOGO       = 68,
    CABASA          = 69,
    MARACAS         = 70,
    SHORT_WHISTLE = 71,
    LONG_WHISTLE = 72,
    SHORT_GUIRO = 73,
    LONG_GUIRO     = 74,
    CLAVES         = 75,
    HIGH_WOODBLOCK = 76,
    LOW_WOODBLOCK  = 77,
    MUTE_CUICA = 78,
    OPEN_CUICA = 79,
    MUTE_TRIANGLE = 80,
    OPEN_TRIANGLE = 81,
    // Roland GS Extensions
    /*SHAKER = 82,
    JINGLE_BELL = 83,
    BELLTREE = 84,
    CASTANETS = 85,
    MUTE_SURDO = 86,
    OPEN_SURDO = 87,*/
    // End Roland GS Extensions
} percussionNote_t;
typedef enum {…};

typedef enum
{
    MCC_BANK_MSB             = 0,
    MCC_MODULATION_WHEEL_MSB = 1,
    MCC_BREATH_MSB           = 2,
 
    MCC_FOOT_PEDAL_MSB      = 4,
    MCC_PORTAMENTO_TIME_MSB = 5,
    MCC_DATA_ENTRY_MSB      = 6,
    MCC_VOLUME_MSB          = 7,
    MCC_BALANCE_MSB         = 8,
 
    MCC_PAN_MSB        = 10,
    MCC_EXPRESSION_MSB = 11,
    MCC_EFFECT_1_MSB   = 12,
    MCC_EFFECT_2_MSB   = 13,
 
    MCC_GP_SLIDER_1 = 16,
    MCC_GP_SLIDER_2 = 17,
    MCC_GP_SLIDER_3 = 18,
    MCC_GP_SLIDER_4 = 19,
 
    MCC_BANK_LSB             = 32,
    MCC_MODULATION_WHEEL_LSB = 33,
    MCC_BREATH_LSB           = 34,
 
    MCC_FOOT_PEDAL_LSB      = 36,
    MCC_PORTAMENTO_TIME_LSB = 37,
    MCC_DATA_ENTRY_LSB      = 38,
    MCC_VOLUME_LSB          = 39,
    MCC_BALANCE_LSB         = 40,
 
    MCC_PAN_LSB        = 42,
    MCC_EXPRESSION_LSB = 43,
    MCC_EFFECT_1_LSB   = 44,
    MCC_EFFECT_2_LSB   = 45,
 
    //< Switch
    MCC_HOLD_PEDAL = 64,
    //< Switch
    MCC_PORTAMENTO = 65,
    //< Switch
    MCC_SUSTENUTO_PEDAL = 66,
    //< Switch
    MCC_SOFT_PEDAL = 67,
    //< Switch
    MCC_LEGATO_PEDAL = 68,
    //< Switch
    MCC_HOLD_2_PEDAL       = 69,
    MCC_SOUND_VARIATION    = 70,
    MCC_SOUND_TIMBRE       = 71,
    MCC_SOUND_RELEASE_TIME = 72,
    MCC_SOUND_ATTACK_TIME  = 73,
    MCC_SOUND_BRIGHTNESS   = 74,
    // Decay
    MCC_SOUND_CONTROL_6 = 75,
    // Sustain level
    MCC_SOUND_CONTROL_7  = 76,
    MCC_SOUND_CONTROL_8  = 77,
    MCC_SOUND_CONTROL_9  = 78,
    MCC_SOUND_CONTROL_10 = 79,
    //< Switch
    MCC_GP_BUTTON_1 = 80,
    //< Switch
    MCC_GP_BUTTON_2 = 81,
    //< Switch
    MCC_GP_BUTTON_3 = 82,
    //< Switch
    MCC_GP_BUTTON_4 = 83,
 
    MCC_EFFECTS_LEVEL            = 91,
    MCC_TREMOLO_LEVEL            = 92,
    MCC_CHORUS_LEVEL             = 93,
    MCC_DETUNE_LEVEL             = 94,
    MCC_PHASER_LEVEL             = 95,
    MCC_DATA_BUTTON_INC          = 96,
    MCC_DATA_BUTTON_DEC          = 97,
    MCC_NON_REGISTERED_PARAM_LSB = 98,
    MCC_NON_REGISTERED_PARAM_MSB = 99,
    MCC_REGISTERED_PARAM_LSB     = 100,
    MCC_REGISTERED_PARAM_MSB     = 101,
 
    //< No data
    MCC_ALL_SOUND_OFF = 120,
    //< No data
    MCC_ALL_CONTROLS_OFF = 121,
    //< Switch
    MCC_LOCAL_KEYBOARD = 122,
    //< No data
    MCC_ALL_NOTE_OFF = 123,
    //< No data
    MCC_OMNI_MODE_OFF = 124,
    //< No data
    MCC_OMNI_MODE_ON = 125,
    //< No data
    MCC_MONO_OPERATION = 126,
    //< No data
    MCC_POLY_OPERATION = 127,
} midiControl_t;
typedef enum {…};

typedef enum
{
    MMFR_EDUCATIONAL_USE         = 0x807D,
    MMFR_UNIVERSAL_NON_REAL_TIME = 0x807E,
    MMFR_UNIVERSAL_REAL_TIME     = 0x807F,
} midiManufacturerId_t;
typedef enum {…};
 
//==============================================================================
// Structs
//==============================================================================

typedef struct
{
    int32_t attackTime;

    q24_8 attackTimeVel;

    int32_t decayTime;

    q24_8 decayTimeVel;

    int32_t releaseTime;

    q24_8 releaseTimeVel;

    uint8_t sustainVol;

    q24_8 sustainVolVel;

    // uint32_t loopStart;
    // uint32_t loopEnd;
 
} envelope_t;
typedef struct {…};
 
typedef struct
{
    uint8_t chorus;
} timbreEffects_t;
typedef struct {…};

typedef int8_t (*percussionFunc_t)(percussionNote_t drum, uint32_t idx, bool* done, uint32_t scratch[4], void* data);

typedef void (*midiTextCallback_t)(metaEventType_t type, const char* text, uint32_t length);

typedef bool (*midiStreamingCallback_t)(midiEvent_t* event);

typedef struct
{
    timbreType_t type;

    timbreFlags_t flags;
 
    union
    {
        struct
        {
            uint16_t waveIndex;

            waveFunc_t waveFunc;
        };
        struct {…};
 
        struct
        {
 
            // This should just always be C4? (440 << 8)
            // uint32_t freq = (440 << 8);
 
            union
            {
                struct
                {
                    const uint8_t* data;

                    uint32_t count;
                };
                struct {…};
 
                struct
                {
                    cnfsFileIdx_t fIdx;
                } config;
                struct {…};
            };
            union {…};

            uint32_t rate;

            uq8_24 baseNote;

            uint32_t loop;
        } sample;
        struct {…};
 
        struct
        {
            percussionFunc_t playFunc;
            void* data;
        } percussion;
        struct {…};

        oscillatorShape_t shape;
    };
    union {…};

    envelope_t envelope;

    timbreEffects_t effects;

    const char* name;
} midiTimbre_t;
typedef struct {…};

typedef struct
{
    uint32_t transitionTicks;

    uint32_t transitionTicksTotal;

    uint8_t transitionStartVol;

    uint8_t targetVol;

    uint32_t sampleTick;

    uint8_t note;

    uint8_t velocity;

    uint8_t channel;

    synthOscillator_t oscillators[OSC_PER_VOICE];
 
    // TODO union this with the oscillators? They shouldn't both be used
    // But we need to make sure those oscillators don't get summed
    union
    {
        uint32_t percScratch[4];
 
        struct
        {
            uint32_t sampleError;

            uint32_t sampleLoops;
        };
        struct {…};
    };
    union {…};

    const midiTimbre_t* timbre;
} midiVoice_t;
typedef struct {…};

typedef struct
{
    uint32_t on;

    uint32_t attack;

    uint32_t sustain;

    uint32_t decay;

    uint32_t release;

    uint32_t held;

    uint32_t sustenuto;
} voiceStates_t;
typedef struct {…};

typedef struct
{
    uint16_t volume;

    uint16_t bank;

    uint8_t program;

    bool registeredParameter;

    uint16_t selectedParameter;

    midiTimbre_t timbre;

    uint32_t allocedVoices;

    uint16_t pitchBend;

    bool percussion;

    bool held;

    bool sustenuto;

    bool ignore;
} midiChannel_t;
typedef struct {…};

typedef struct
{
    uint16_t volume;

    midiChannel_t channels[MIDI_CHANNEL_COUNT];

    midiVoice_t percVoices[PERCUSSION_VOICES];

    voiceStates_t percVoiceStates;

    uint32_t percSpecialStates;

    midiVoice_t poolVoices[POOL_VOICE_COUNT];

    voiceStates_t poolVoiceStates;

    synthOscillator_t* allOscillators[(POOL_VOICE_COUNT + PERCUSSION_VOICES) * OSC_PER_VOICE];

    uint16_t oscillatorCount;

    midiPlayerMode_t mode;

    midiFileReader_t reader;

    midiStreamingCallback_t streamingCallback;

    midiTextCallback_t textMessageCallback;

    songFinishedCbFn songFinishedCallback;

    int32_t headroom;

    uint32_t clipped;

    uint64_t sampleCount;

    midiEvent_t pendingEvent;

    bool eventAvailable;

    uint32_t tempo;

    bool paused;

    bool seeking;

    bool loop;
} midiPlayer_t;
typedef struct {…};

void midiPlayerInit(midiPlayer_t* player);

void midiPlayerReset(midiPlayer_t* player);

void midiPlayerResetNewSong(midiPlayer_t* player);

int32_t midiPlayerStep(midiPlayer_t* player);

void midiPlayerFillBuffer(midiPlayer_t* player, uint8_t* samples, int16_t len);

void midiPlayerFillBufferMulti(midiPlayer_t* players, uint8_t playerCount, uint8_t* samples, int16_t len);

void midiAllSoundOff(midiPlayer_t* player);

void midiResetChannelControllers(midiPlayer_t* player, uint8_t channel);

void midiGmOn(midiPlayer_t* player);

void midiGmOff(midiPlayer_t* player);

void midiAllNotesOff(midiPlayer_t* player, uint8_t channel);

void midiNoteOn(midiPlayer_t* player, uint8_t channel, uint8_t note, uint8_t velocity);

void midiAfterTouch(midiPlayer_t* player, uint8_t channel, uint8_t note, uint8_t velocity);

void midiNoteOff(midiPlayer_t* player, uint8_t channel, uint8_t note, uint8_t velocity);

void midiSetProgram(midiPlayer_t* player, uint8_t channel, uint8_t program);

void midiSustain(midiPlayer_t* player, uint8_t channel, uint8_t val);

void midiSustenuto(midiPlayer_t* player, uint8_t channel, uint8_t val);

void midiControlChange(midiPlayer_t* player, uint8_t channel, midiControl_t control, uint8_t val);

uint8_t midiGetControlValue(midiPlayer_t* player, uint8_t channel, midiControl_t control);

uint16_t midiGetControlValue14bit(midiPlayer_t* player, uint8_t channel, midiControl_t control);

void midiSetParameter(midiPlayer_t* player, uint8_t channel, bool registered, uint16_t param, uint16_t value);

uint16_t midiGetParameterValue(midiPlayer_t* player, uint8_t channel, bool registered, uint16_t param);

void midiPitchWheel(midiPlayer_t* player, uint8_t channel, uint16_t value);

void midiSetTempo(midiPlayer_t* player, uint32_t tempo);

void midiSetFile(midiPlayer_t* player, const midiFile_t* file);

void midiPause(midiPlayer_t* player, bool pause);

void midiSeek(midiPlayer_t* player, uint32_t ticks);
 
//==============================================================================
// Global MIDI Player Functions
//==============================================================================

void initGlobalMidiPlayer(void);

void deinitGlobalMidiPlayer(void);

void globalMidiPlayerFillBuffer(uint8_t* samples, int16_t len);

void globalMidiPlayerPlaySong(midiFile_t* song, uint8_t trackType);

void globalMidiPlayerPlaySongCb(midiFile_t* song, uint8_t trackType, songFinishedCbFn cb);

void globalMidiPlayerSetVolume(uint8_t trackType, int32_t volumeSetting);

void globalMidiPlayerPauseAll(void);

void globalMidiPlayerResumeAll(void);

void globalMidiPlayerStop(bool reset);

void* globalMidiSave(void);

void globalMidiRestore(void* data);

midiPlayer_t* globalMidiPlayerGet(uint8_t trackType);