midiPlayer.h

Go to the documentation of this file.

#pragma once
 
//==============================================================================
// Includes
//==============================================================================
 
#include "swSynth.h"
#include "midiFileParser.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
{
    WAVETABLE,
    SAMPLE,
    NOISE,
    WAVE_SHAPE,
} timbreType_t;
 
typedef enum
{
    TF_NONE = 0,
    TF_PERCUSSION = 1,
    TF_MONO = 2,
} timbreFlags_t;
 
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
{
    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
{
    MMFR_EDUCATIONAL_USE         = 0x807D,
    MMFR_UNIVERSAL_NON_REAL_TIME = 0x807E,
    MMFR_UNIVERSAL_REAL_TIME     = 0x807F,
} midiManufacturerId_t;
 
//==============================================================================
// 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
{
    uint8_t chorus;
} timbreEffects_t;
 
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
        {
 
            // This should just always be C4? (440 << 8)
            // uint32_t freq = (440 << 8);
 
            union
            {
                struct
                {
                    const uint8_t* data;
 
                    uint32_t count;
                };
 
                struct
                {
                    const char* sampleName;
                } config;
            };
 
            uint32_t rate;
 
            uq8_24 baseNote;
 
            uint32_t loop;
        } sample;
 
        struct
        {
            percussionFunc_t playFunc;
            void* data;
        } percussion;
 
        oscillatorShape_t shape;
    };
 
    envelope_t envelope;
 
    timbreEffects_t effects;
 
    const char* name;
} midiTimbre_t;
 
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;
        };
    };
 
    const midiTimbre_t* timbre;
} midiVoice_t;
 
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
{
    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
{
    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;
 
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);