tracktion_InputDevice.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 InputDevice   : public Selectable
{
public:
    enum DeviceType
    {
        waveDevice,
        trackWaveDevice,
        physicalMidiDevice,
        virtualMidiDevice,
        trackMidiDevice
    };
 
    //==============================================================================
    InputDevice (Engine&, juce::String type, juce::String name, juce::String deviceID);
    ~InputDevice() override;
 
    //==============================================================================
    const juce::String& getName() const         { return name; }
    const juce::String& getType() const         { return type; }
 
    juce::String getDeviceID() const            { return deviceID; }
 
    virtual DeviceType getDeviceType() const = 0;
    bool isTrackDevice() const;
 
    juce::String getAlias() const;
    void setAlias (const juce::String& newAlias);
 
    virtual bool isAvailableToEdit() const      { return isEnabled(); }
 
    bool isEnabled() const;
    virtual void setEnabled (bool) = 0;
 
    virtual bool isMidi() const                 { return false; }
 
    enum class MonitorMode
    {
        off,        
        automatic,  
        on          
    };
 
    MonitorMode getMonitorMode() const          { return monitorMode; }
    void setMonitorMode (MonitorMode);
 
    virtual InputDeviceInstance* createInstance (EditPlaybackContext&) = 0;
 
    virtual void masterTimeUpdate (double time) = 0;
 
    static void setRetrospectiveLock (Engine&, const juce::Array<InputDeviceInstance*>&, bool lock);
    virtual void updateRetrospectiveBufferLength (double length) = 0;
 
    //==============================================================================
    juce::String getSelectableDescription() override;
 
    virtual void saveProps() = 0;
 
    Engine& engine;
    LevelMeasurer levelMeasurer;
 
protected:
    std::atomic<bool> enabled { false };
    MonitorMode monitorMode = MonitorMode::automatic;
    MonitorMode defaultMonitorMode = MonitorMode::automatic;
    bool retrospectiveRecordLock = false;
 
private:
    const juce::String type, deviceID, name;
    juce::String alias;
 
    juce::String getAliasPropName() const;
};
 
 
//==============================================================================
//==============================================================================
class InputDeviceInstance   : protected juce::ValueTree::Listener
{
public:
    struct Destination;
 
    //==============================================================================
    //==============================================================================
    InputDeviceInstance (InputDevice&, EditPlaybackContext&);
 
    ~InputDeviceInstance() override;
 
    InputDevice& getInputDevice() noexcept      { return owner; }
 
    juce::Array<EditItemID> getTargets() const;
 
    [[ nodiscard ]] tl::expected<Destination*, juce::String> setTarget (EditItemID targetID, bool moveToTrack, juce::UndoManager*,
                                                                        std::optional<int> index = std::nullopt);
 
    [[ nodiscard ]] juce::Result removeTarget (EditItemID targetID, juce::UndoManager*);
 
    virtual bool isLivePlayEnabled (const Track&) const;
 
    virtual bool isRecordingActive() const;
 
    virtual bool isRecordingActive (EditItemID) const;
 
    virtual bool isRecordingQueuedToStop (EditItemID) = 0;
 
    bool isRecordingEnabled (EditItemID) const;
 
    void setRecordingEnabled (EditItemID, bool);
 
    virtual bool shouldTrackContentsBeMuted (const Track&)   { return false; }
 
    //==============================================================================
    //** The parameters used to configure a recording operation. */
    struct RecordingParameters
    {
        TimeRange punchRange;               
        std::vector<EditItemID> targets;    
    };
 
    class RecordingContext
    {
    public:
        virtual ~RecordingContext() = default;
 
        const EditItemID targetID; 
    protected:
        RecordingContext (EditItemID targetID_)
            : targetID (targetID_)
        {}
    };
 
    using PreparedContext = std::vector<tl::expected<std::unique_ptr<RecordingContext>, juce::String>>;
 
    [[nodiscard]] virtual PreparedContext prepareToRecord (RecordingParameters) = 0;
 
    virtual std::vector<std::unique_ptr<RecordingContext>> startRecording (std::vector<std::unique_ptr<RecordingContext>>) = 0;
 
    struct StopRecordingParameters
    {
        std::vector<EditItemID> targetsToStop;      
        TimePosition unloopedTimeToEndRecording;    
        bool isLooping = false;                     
        TimeRange markedRange;                      
        bool discardRecordings = false;             
    };
 
    virtual tl::expected<Clip::Array, juce::String> stopRecording (StopRecordingParameters) = 0;
 
    virtual void stopRecording (StopRecordingParameters,
                                std::function<void (tl::expected<Clip::Array, juce::String>)>) = 0;
 
    virtual bool isRecording (EditItemID) = 0;
 
    virtual bool isRecording() = 0;
 
    virtual juce::File getRecordingFile (EditItemID) const     { return {}; }
 
    virtual std::shared_ptr<choc::fifo::SingleReaderSingleWriterFIFO<juce::MidiMessage>> getRecordingNotes (EditItemID) const { return nullptr; }
 
    virtual TimePosition getPunchInTime (EditItemID) = 0;
 
    virtual juce::Array<Clip*> applyRetrospectiveRecord (bool armedOnly) = 0;
 
    //==============================================================================
    juce::ValueTree state;          
    InputDevice& owner;             
    EditPlaybackContext& context;   
    Edit& edit;                     
    //==============================================================================
    struct Destination : public Selectable
    {
        ~Destination() override
        {
            notifyListenersOfDeletion();
        }
 
        InputDeviceInstance& input; 
        juce::ValueTree state;      
        const EditItemID targetID = EditItemID::fromProperty (state, IDs::targetID);
 
        const int targetIndex = state[IDs::targetIndex];
 
        juce::CachedValue<bool> recordEnabled;
 
        //==============================================================================
        Destination (InputDeviceInstance& i, juce::ValueTree v)
            : input (i), state (v)
        {
            recordEnabled.referTo (state, IDs::armed, nullptr, false);
            assert (targetID.isValid() && "Must have a valid ID!");
        }
 
        juce::String getSelectableDescription() override
        {
            return input.getInputDevice().getSelectableDescription();
        }
    };
 
    //==============================================================================
    struct WaveInputDestination : public Destination
    {
        WaveInputDestination (InputDeviceInstance& i, juce::ValueTree v) : Destination (i, v) {}
        ~WaveInputDestination() override { notifyListenersOfDeletion(); }
    };
 
    struct MidiInputDestination : public Destination
    {
        MidiInputDestination (InputDeviceInstance& i, juce::ValueTree v) : Destination (i, v) {}
        ~MidiInputDestination() override { notifyListenersOfDeletion(); }
    };
 
    struct VirtualMidiInputDestination : public Destination
    {
        VirtualMidiInputDestination (InputDeviceInstance& i, juce::ValueTree v) : Destination (i, v) {}
        ~VirtualMidiInputDestination() override { notifyListenersOfDeletion(); }
    };
 
    //==============================================================================
    struct DestinationList  : public ValueTreeObjectList<Destination>
    {
        DestinationList (InputDeviceInstance& i, const juce::ValueTree& v)
            : ValueTreeObjectList<Destination> (v), input (i)
        {
            rebuildObjects();
        }
 
        ~DestinationList() override
        {
            freeObjects();
        }
 
        bool isSuitableType (const juce::ValueTree& v) const override
        {
            return v.hasType (IDs::INPUTDEVICEDESTINATION);
        }
 
        Destination* createNewObject (const juce::ValueTree& v) override
        {
            switch (input.getInputDevice().getDeviceType())
            {
                case InputDevice::waveDevice:           [[ fallthrough ]];
                case InputDevice::trackWaveDevice:      return new WaveInputDestination (input, v);
                case InputDevice::physicalMidiDevice:   [[ fallthrough ]];
                case InputDevice::trackMidiDevice:      return new MidiInputDestination (input, v);
                case InputDevice::virtualMidiDevice:    return new VirtualMidiInputDestination (input, v);
                default:
                {
                    jassertfalse;
                    return new Destination (input, v);
                }
            }
        }
 
        void deleteObject (Destination* c) override
        {
            delete c;
        }
 
        void newObjectAdded (Destination*) override {}
        void objectRemoved (Destination*) override {}
        void objectOrderChanged() override {}
 
        InputDeviceInstance& input;
    };
 
    DestinationList destinations { *this, state };
 
    //==============================================================================
    struct Consumer
    {
        virtual ~Consumer() = default;
 
        virtual void acceptInputBuffer (choc::buffer::ChannelArrayView<float>) {}
 
        virtual void handleIncomingMidiMessage (const juce::MidiMessage&) {}
 
        virtual void discardRecordings (EditItemID /*targetID*/) {}
    };
 
    virtual void addConsumer (Consumer*) = 0;
 
    virtual void removeConsumer (Consumer*) = 0;
 
protected:
    void valueTreePropertyChanged (juce::ValueTree&, const juce::Identifier&) override;
    void valueTreeChildAdded (juce::ValueTree&, juce::ValueTree&) override;
    void valueTreeChildRemoved (juce::ValueTree&, juce::ValueTree&, int) override;
 
    ClipSlot* getFreeSlot (AudioTrack&);
 
private:
    mutable AsyncCaller trackDeviceEnabler, recordStatusUpdater;
    bool wasLivePlayActive = false;
    std::vector<EditItemID> changedTargetTrackIDs;
    void updateRecordingStatus();
 
    JUCE_DECLARE_WEAK_REFERENCEABLE (InputDeviceInstance)
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (InputDeviceInstance)
};
 
 
//==============================================================================
//==============================================================================
[[ nodiscard ]] juce::Array<std::pair<AudioTrack*, int>> getTargetTracksAndIndexes (InputDeviceInstance&);
 
[[ nodiscard ]] juce::Array<AudioTrack*> getTargetTracks (InputDeviceInstance&);
 
[[ nodiscard ]] bool isOnTargetTrack (InputDeviceInstance&, const Track&, int idx);
 
[[ nodiscard ]] bool isAttached (InputDeviceInstance&);
 
[[ nodiscard ]] juce::Result clearFromTargets (InputDeviceInstance&, juce::UndoManager*);
 
//==============================================================================
[[ nodiscard ]] InputDeviceInstance::Destination* getDestination (InputDeviceInstance&, const Track& track, int index);
 
[[ nodiscard ]] InputDeviceInstance::Destination* getDestination (InputDeviceInstance&, const ClipSlot&);
 
[[ nodiscard ]] InputDeviceInstance::Destination* getDestination (InputDeviceInstance&, const juce::ValueTree& destinationState);
 
 
//==============================================================================
[[ nodiscard ]] inline bool hasErrors (const InputDeviceInstance::PreparedContext& pc)
{
    for (auto& res : pc)
        if (! res)
            return true;
 
    return false;
}
 
inline InputDeviceInstance::PreparedContext& append (InputDeviceInstance::PreparedContext& dest, InputDeviceInstance::PreparedContext&& src)
{
    std::move (src.begin(), src.end(), std::back_inserter(dest));
    return dest;
}
 
[[ nodiscard ]] inline std::pair<std::vector<std::unique_ptr<InputDeviceInstance::RecordingContext>>, juce::StringArray> extract (InputDeviceInstance::PreparedContext&& pc)
{
    std::vector<std::unique_ptr<InputDeviceInstance::RecordingContext>> recContexts;
    juce::StringArray errors;
 
    for (auto& res : pc)
    {
        if (res)
            recContexts.emplace_back (std::move (res.value()));
        else
            errors.add (res.error());
    }
 
    return { std::move (recContexts), std::move (errors) };
}
 
 
}} // namespace tracktion { inline namespace engine