midiPlayer.h

Go to the documentation of this file.

#pragma once

 
//==============================================================================
// Includes
//==============================================================================
 
#include "swSynth.h"
#include "midiFileParser.h"
#include "cnfs_image.h"
#include "hdw-dac.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 16
// 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 0x4000
#define PITCH_BEND_CENTER 0x2000

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

#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,
    MULTI_SAMPLE,
    PLAY_FUNC,
} timbreType_t;

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

typedef enum
{
    VOICE_WAVE_FUNC,
    VOICE_PLAY_FUNC,
    VOICE_SAMPLE,
} voiceType_t;

typedef enum
{
    ADSR_ON = 0,
    ADSR_ATTACK = 1,
    ADSR_DECAY = 2,
    ADSR_SUSTAIN = 3,
    ADSR_RELEASE = 4,
    ADSR_OFF = 5,
} adsrState_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
{
    cnfsFileIdx_t fIdx;

    uint32_t rate;

    uq8_24 baseNote;

    int8_t tune;

    uint32_t loop;

    uint32_t loopStart;

    uint32_t loopEnd;
} timbreSample_t;
 
typedef struct
{
    uint8_t noteStart;
    uint8_t noteEnd;
    timbreSample_t sample;
    envelope_t envelope;
} noteSampleMap_t;

typedef struct
{
    timbreType_t type;

    timbreFlags_t flags;
 
    union
    {
        struct
        {
            uint16_t waveIndex;

            waveFunc_t waveFunc;
        };
 
        timbreSample_t sample;
 
        struct
        {
            const noteSampleMap_t* map;
            size_t count;
        } multiSample;
 
        struct
        {
            percussionFunc_t func;
            void* data;
        } playFunc;

        oscillatorShape_t shape;
    };

    envelope_t envelope;

    timbreEffects_t effects;

    const char* name;
} midiTimbre_t;

typedef struct
{
    uq8_24 curVol;

    q8_24 volRate;

    q8_24 volAccel;

    uint32_t voiceTick;

    uint32_t sampleTick;

    uint32_t stateChangeTick;

    uq16_16 pitch;

    uint8_t note;

    uint8_t velocity;

    uint8_t channel;

    voiceType_t type;
 
    union
    {
        struct
        {
            const uint8_t* data;
            uint32_t length;

            uint32_t rate;

            uint32_t loopStart;
            uint32_t loopEnd;

            uq16_16 baseNote;

            int8_t tune;

            uq24_8 error;

            uint32_t loopsRemaining;

            uq24_8 sampleRateRatio;
        } sample;
 
        struct
        {
            waveFunc_t func;
            synthOscillator_t oscillator;
        } wave;
 
        struct
        {
            percussionFunc_t func;
            uint32_t scratch[4];
        } playFunc;
    };

    envelope_t envelope;
} 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;

    midiPlayerMode_t mode;

    midiFileReader_t reader;

    midiStreamingCallback_t streamingCallback;

    midiTextCallback_t textMessageCallback;

    songFinishedCbFn songFinishedCallback;

    int32_t headroom;

    uint32_t clipped;

    uint64_t sampleCount;

    uint32_t tick;

    midiEvent_t pendingEvent;

    bool eventAvailable;

    uint32_t tempo;

    bool paused;

    bool seeking;

    bool loop;

    bool songEnding;

    bool forceCheckEvents;
} 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);

const midiTimbre_t* getTimbreForProgram(bool percussion, uint8_t bank, uint8_t program);

const midiVoice_t* soundNoteOn(midiPlayer_t* player, uint8_t chanId, uint8_t note, uint8_t velocity,
                               const midiTimbre_t* timbre, bool percussion);

void soundNoteOff(midiPlayer_t* player, uint8_t chanId, uint8_t note, uint8_t velocity, bool percussion);

void soundVoiceRelease(midiPlayer_t* player, const midiVoice_t* voice);

void soundVoiceOff(midiPlayer_t* player, const midiVoice_t* voice);