playbackhandler.h

Go to the documentation of this file.

/*
 * Copyright © 2014-2023 Synthstrom Audible Limited
 *
 * This file is part of The Synthstrom Audible Deluge Firmware.
 *
 * The Synthstrom Audible Deluge Firmware is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software Foundation,
 * either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef PLAYBACKHANDLER_H
#define PLAYBACKHANDLER_H
 
#include "r_typedefs.h"
#include "definitions.h"
 
 
#define MIDI_OUT_OFF 0
#define MIDI_OUT_INCIDENTAL 1
#define MIDI_OUT_MASTER 2
 
#define RECORDING_OFF 0
#define RECORDING_NORMAL 1
#define RECORDING_ARRANGEMENT 2
 
#define NUM_INPUT_TICKS_FOR_MOVING_AVERAGE 24
 
#define PLAYBACK_CLOCK_INTERNAL_ACTIVE 1
#define PLAYBACK_CLOCK_EXTERNAL_ACTIVE 2
#define PLAYBACK_SWITCHED_ON 4
 
#define PLAYBACK_CLOCK_EITHER_ACTIVE (PLAYBACK_CLOCK_INTERNAL_ACTIVE | PLAYBACK_CLOCK_EXTERNAL_ACTIVE)
 
 
class Song;
class InstrumentClip;
class NoteRow;
class Kit;
class Clip;
class Action;
class MIDIDevice;
 
const uint8_t metronomeValuesBPM[16] = {60, 63, 66, 69, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116};
 
const uint16_t metronomeValueBoundaries[16] = {1793, 1709, 1633, 1542, 1490, 1413, 1345, 1282, 1225, 1173, 1125, 1081, 1040, 1002, 967, 934};
 
class PlaybackHandler
{
public:
    PlaybackHandler();
    void routine();
 
    void playButtonPressed(int buttonPressLatency);
    void recordButtonPressed();
    void setupPlaybackUsingInternalClock(int buttonPressLatencyForTempolessRecord = 0, bool allowCountIn = true);
    void setupPlaybackUsingExternalClock(bool switchingFromInternalClock = false, bool fromContinueCommand = false);
    void setupPlayback(int newPlaybackState, int32_t playFromPos, bool doOneLastAudioRoutineCall = false, bool shouldShiftAccordingToClipInstance = true, int buttonPressLatencyForTempolessRecord = 0);
    void endPlayback();
    void inputTick(bool fromTriggerClock = false, uint32_t time = 0);
    void startMessageReceived();
    void continueMessageReceived();
    void stopMessageReceived();
    void clockMessageReceived(uint32_t time);
    void tempoEncoderAction(int8_t offset, bool encoderButtonPressed, bool shiftButtonPressed);
    bool isCurrentlyRecording();
    void positionPointerReceived(uint8_t data1, uint8_t data2);
    void programChangeReceived(int channel, int program);
    void doSongSwap(bool preservePlayPosition = false);
    void forceResetPlayPos(Song* song);
    void expectEvent();
    void setMidiInClockEnabled(bool newValue);
    int32_t getActualArrangementRecordPos();
    int32_t getArrangementRecordPosAtLastActionedSwungTick();
    void slowRoutine();
    void scheduleSwungTickFromExternalClock();
    int getNumSwungTicksInSinceLastTimerTick(uint32_t* timeRemainder = NULL);
    int getNumSwungTicksInSinceLastActionedSwungTick(uint32_t* timeRemainder = NULL);
    int64_t getActualSwungTickCount(uint32_t* timeRemainder = NULL);
    int64_t getCurrentInternalTickCount(uint32_t* remainder = NULL);
    void scheduleSwungTick();
    int32_t getInternalTickTime(int64_t internalTickCount);
    void scheduleTriggerClockOutTick();
    void scheduleMIDIClockOutTick();
    void scheduleNextTimerTick(uint32_t doubleSwingInterval);
 
 
    // MIDI-clock-out ticks
    bool midiClockOutTickScheduled;
    uint32_t timeNextMIDIClockOutTick;
    int64_t lastMIDIClockOutTickDone;
 
 
 
    // Playback
    uint8_t playbackState;
    bool usingAnalogClockInput; // Value is only valid if usingInternalClock is false
    uint8_t recording;
    bool ignoringMidiClockInput;
 
    int32_t posToNextContinuePlaybackFrom; // This will then have 1 subtracted from it when actually physically set
    uint32_t timeLastMIDIStartOrContinueMessageSent;
 
    // Timer ticks
    int64_t lastTimerTickActioned;  // Not valid while playback being set up
    int64_t nextTimerTickScheduled; // *Yes* valid while (internal clock) playback being set up. Will be zero during that time
    uint64_t timeNextTimerTickBig;  // Not valid while playback being set up
    uint64_t timeLastTimerTickBig;  // Not valid while playback being set up
 
    // Input ticks
    uint32_t timeLastInputTicks[NUM_INPUT_TICKS_FOR_MOVING_AVERAGE];
    uint32_t timePerInputTickMovingAverage; // 0 means that a default will be set the first time it's used
    uint8_t numInputTickTimesCounted;
 
    bool tempoMagnitudeMatchingActiveNow;
    //unsigned long timeFirstInputTick; // First tick received for current tally
    unsigned long timeVeryFirstInputTick; // Very first tick received in playback. Only used for tempo magnitude matching
    int64_t lastInputTickReceived;
    unsigned long targetedTimePerInputTick;
 
    // Swung ticks
    bool swungTickScheduled;
    uint32_t scheduledSwungTickTime;
    // Now, swung ticks are only "actioned" in the following circumstances:
    // - A note starts or ends
    // - Automation event
    // - A clip loops
    // - A "launch" event
    // - Start of playback, including if count-in ends
    int64_t lastSwungTickActioned; // Will be set to a phony-ish "0" while playback being set up
 
    // Trigger-clock-out ticks
    bool triggerClockOutTickScheduled;
    uint32_t timeNextTriggerClockOutTick;
    int64_t lastTriggerClockOutTickDone;
 
    uint32_t analogOutTicksPPQN; // Relative to the "external world", which also means relative to the displayed tempo
    uint32_t analogInTicksPPQN;
    uint32_t timeLastAnalogClockInputRisingEdge;
    bool analogClockInputAutoStart;
 
    bool songSwapShouldPreserveTempo;
 
    // User options
    bool metronomeOn;
    bool midiOutClockEnabled;
    bool midiInClockEnabled;
    bool tempoMagnitudeMatchingEnabled;
    bool countInEnabled;
 
    int32_t swungTicksTilNextEvent;
 
    int32_t ticksLeftInCountIn;
    int currentVisualCountForCountIn;
 
    int32_t metronomeOffset;
 
    void setLedStates();
    void tapTempoAutoSwitchOff();
    void reassessInputTickScaling();
    void resyncInternalTicksToInputTicks(Song* song);
    bool shouldRecordNotesNow();
    void stopAnyRecording();
    uint32_t getTimePerInternalTick();
    uint64_t getTimePerInternalTickBig();
    float getTimePerInternalTickFloat();
    uint32_t getTimePerInternalTickInverse(bool getStickyValue = false);
    void tapTempoButtonPress();
    void doTriggerClockOutTick();
    void doMIDIClockOutTick();
    void resyncAnalogOutTicksToInternalTicks();
    void resyncMIDIClockOutTicksToInternalTicks();
    void analogClockRisingEdge(uint32_t time);
    void toggleMetronomeStatus();
    void displayTempoByCalculation();
    void displaySwingAmount();
    void setMidiOutClockMode(bool newValue);
    void pitchBendReceived(MIDIDevice* fromDevice, uint8_t channel, uint8_t data1, uint8_t data2, bool* doingMidiThru);
    void midiCCReceived(MIDIDevice* fromDevice, uint8_t channel, uint8_t ccNumber, uint8_t value, bool* doingMidiThru);
    void aftertouchReceived(MIDIDevice* fromDevice, int channel, int value, int noteCode, bool* doingMidiThru); // noteCode -1 means channel-wide
    void loopCommand(int overdubNature);
    void grabTempoFromClip(Clip* clip);
    int32_t getTimeLeftInCountIn();
 
    void noteMessageReceived(MIDIDevice* fromDevice, bool on, int channel, int note, int velocity, bool* doingMidiThru);
    bool subModeAllowsRecording();
 
    void songSelectReceived(uint8_t songId);
    float calculateBPM(float timePerInternalTick);
    void switchToArrangement();
    void switchToSession();
    void finishTempolessRecording(bool startPlaybackAgain, int buttonLatencyForTempolessRecord, bool shouldExitRecordMode = true);
 
    int32_t arrangementPosToStartAtOnSwitch;
 
    bool stopOutputRecordingAtLoopEnd;
 
 
 
    void actionTimerTick();
    void actionTimerTickPart2();
    void actionSwungTick();
    void scheduleSwungTickFromInternalClock();
    bool currentlySendingMIDIOutputClocks();
 
 
    inline bool isEitherClockActive() {
        return (playbackState & PLAYBACK_CLOCK_EITHER_ACTIVE);
    }
 
 
private:
 
    uint32_t timerTicksToOutputTicks(uint32_t timerTicks);
 
    // These are all only relevant while playing synced.
    uint32_t timePerInternalTickMovingAverage; // Recalculated every ~24 clocks
    uint32_t veryCurrentTimePerInternalTickInverse; // Recalculated at every received clock message
    uint32_t stickyCurrentTimePerInternalTickInverse; // Moving average kinda thing
    uint32_t lowpassedTimePerInternalTick;
    uint32_t slowpassedTimePerInternalTick;
    uint32_t stickyTimePerInternalTick;
 
 
    uint16_t tapTempoNumPresses;
    uint32_t tapTempoFirstPressTime;
 
    int numOutputClocksWaitingToBeSent;
    int numInputTicksToSkip;
 
 
    void resetTimePerInternalTickMovingAverage();
    void getCurrentTempoParams(int32_t *magnitude, int8_t *whichValue);
    void displayTempoFromParams(int32_t magnitude, int8_t whichValue);
    void displayTempoBPM(float tempoBPM);
    void getAnalogOutTicksToInternalTicksRatio(uint32_t* internalTicksPer, uint32_t* analogOutTicksPer);
    void getMIDIClockOutTicksToInternalTicksRatio(uint32_t* internalTicksPer, uint32_t* midiClockOutTicksPer);
    void getInternalTicksToInputTicksRatio(uint32_t* inputTicksPer, uint32_t* internalTicksPer);
    void sendOutPositionViaMIDI(int32_t pos, bool outputClocksWereSwitchedOff = false);
    //void scheduleNextTimerTick();
    bool startIgnoringMidiClockInputIfNecessary();
    uint32_t setTempoFromAudioClipLength(uint64_t loopLengthSamples, Action* action);
    bool tryGlobalMIDICommands(MIDIDevice* device, int channel, int note);
    void decideOnCurrentPlaybackMode();
    float getCurrentInternalTickFloatFollowingExternalClock();
    void scheduleTriggerClockOutTickParamsKnown(uint32_t analogOutTicksPer, uint64_t fractionLastTimerTick, uint64_t fractionNextAnalogOutTick);
    void scheduleMIDIClockOutTickParamsKnown(uint32_t midiClockOutTicksPer, uint64_t fractionLastTimerTick, uint64_t fractionNextMIDIClockOutTick);
 
};
 
extern PlaybackHandler playbackHandler;
#endif // PLAYBACKHANDLER_H