tracktion_EditPlaybackContext.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
//==========================================================================
//==========================================================================
class EditPlaybackContext
{
public:
    EditPlaybackContext (TransportControl&);
    ~EditPlaybackContext();
 
    void removeInstanceForDevice (InputDevice&);
 
    void addWaveInputDeviceInstance (InputDevice&);
    void addMidiInputDeviceInstance (InputDevice&);
 
    void clearNodes();
    void createPlayAudioNodes (TimePosition startTime);
    void createPlayAudioNodesIfNeeded (TimePosition startTime);
    void reallocate();
 
    bool isPlaybackGraphAllocated() const       { return isAllocated; }
 
    // Prepares the graph but doesn't actually start the playhead
    void prepareForPlaying (TimePosition startTime);
    void prepareForRecording (TimePosition startTime, TimePosition punchIn);
 
    // Plays this context in sync with another context
    void syncToContext (EditPlaybackContext* contextToSyncTo, TimePosition previousBarTime, TimeDuration syncInterval);
 
    tl::expected<Clip::Array, juce::String> stopRecording (InputDeviceInstance&, bool discardRecordings);
    tl::expected<Clip::Array, juce::String> stopRecording (TimePosition unloopedEnd, bool discardRecordings);
    juce::Result applyRetrospectiveRecord (juce::Array<Clip*>* clipsCreated = nullptr, bool armedOnly = false);
 
    juce::Array<InputDeviceInstance*> getAllInputs();
    InputDeviceInstance* getInputFor (InputDevice*) const;
    OutputDeviceInstance* getOutputFor (OutputDevice*) const;
 
    Edit& edit;
    TransportControl& transport;
    LevelMeasurer masterLevels;
    MidiNoteDispatcher midiDispatcher;
 
    struct ScopedDeviceListReleaser
    {
        ScopedDeviceListReleaser (EditPlaybackContext&, bool reallocate);
        ~ScopedDeviceListReleaser();
 
        EditPlaybackContext& owner;
        const bool shouldReallocate;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ScopedDeviceListReleaser)
    };
 
    // This is a global setting
    static bool shouldAddAntiDenormalisationNoise (Engine&);
    static void setAddAntiDenormalisationNoise (Engine&, bool);
 
    //==============================================================================
    struct RealtimePriorityDisabler
    {
        RealtimePriorityDisabler (Engine&);
        ~RealtimePriorityDisabler();
 
        Engine& engine;
    };
 
    //==============================================================================
    // These methods deal directly with the playhead so won't have any latency induced by syncing to the messaged thread.
    bool isPlaying() const;
    bool isLooping() const;
    bool isDragging() const;
 
    TimePosition getPosition() const;
    TimePosition getUnloopedPosition() const;
    TimeRange getLoopTimes() const;
 
    int getLatencySamples() const;
    TimePosition getAudibleTimelineTime();
    double getSampleRate() const;
    void updateNumCPUs();
 
    void setSpeedCompensation (double plusOrMinus);
 
    void setTempoAdjustment (double plusOrMinusProportion);
 
    void postPosition (TimePosition positionToJumpTo, std::optional<TimePosition> whenToJump = {});
 
    std::optional<TimePosition> getPendingPositionChange() const;
 
    void play();
    void stop();
 
    std::optional<SyncPoint> getSyncPoint() const;
 
    TimePosition globalStreamTimeToEditTime (double) const;
    TimePosition globalStreamTimeToEditTimeUnlooped (double) const;
    void resyncToGlobalStreamTime (juce::Range<double>, double sampleRate);
 
    tracktion::graph::PlayHead* getNodePlayHead() const;
 
    void blockUntilSyncPointChange();
 
    static void setThreadPoolStrategy (int);
    static int getThreadPoolStrategy();
 
    static void enablePooledMemory (bool);
 
    static void enableNodeMemorySharing (bool);
 
    static void enableAudioWorkgroup (bool);
 
    int getNumActivelyRecordingDevices() const;
    void incrementNumActivelyRecordingDevices();
    void decrementNumActivelyRecordingDevices();
 
private:
    bool isAllocated = false;
 
    struct ProcessPriorityBooster
    {
        ProcessPriorityBooster (Engine& engine);
        ~ProcessPriorityBooster();
 
        Engine& engine;
    };
 
    std::unique_ptr<ProcessPriorityBooster> priorityBooster;
 
    juce::OwnedArray<InputDeviceInstance> waveInputs, midiInputs;
    juce::OwnedArray<WaveOutputDeviceInstance> waveOutputs;
    juce::OwnedArray<MidiOutputDeviceInstance> midiOutputs;
 
    void releaseDeviceList();
    void rebuildDeviceList();
 
    void prepareOutputDevices (TimePosition start);
    juce::Result startRecording (TimePosition start, TimePosition punchIn);
    void startPlaying (TimePosition start);
 
    friend class DeviceManager;
 
    juce::WeakReference<EditPlaybackContext> contextToSyncTo;
    TimePosition previousBarTime;
    TimeDuration syncInterval;
    bool hasSynced = false;
    double lastStreamPos = 0;
 
    struct ContextSyncroniser;
    std::unique_ptr<ContextSyncroniser> contextSyncroniser;
 
    struct NodePlaybackContext;
    std::unique_ptr<NodePlaybackContext> nodePlaybackContext;
 
    juce::WeakReference<EditPlaybackContext> nodeContextToSyncTo;
    std::atomic<double> audiblePlaybackTime { 0.0 };
    std::atomic<int> activelyRecordingInputDevices { 0 };
 
    void createNode();
    void fillNextNodeBlock (float* const* allChannels, int numChannels, int numSamples);
 
    JUCE_DECLARE_WEAK_REFERENCEABLE (EditPlaybackContext)
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (EditPlaybackContext)
};
 
//==============================================================================
//==============================================================================
namespace detail
{
    struct ScopedActiveRecordingDevice
    {
        ScopedActiveRecordingDevice (EditPlaybackContext& e) : epc (e)
        {
            epc.incrementNumActivelyRecordingDevices();
        }
 
        ~ScopedActiveRecordingDevice()
        {
            epc.decrementNumActivelyRecordingDevices();
        }
 
        EditPlaybackContext& epc;
    };
}
 
}} // namespace tracktion { inline namespace engine