juce_ARAHosting.h

Go to the documentation of this file.

 /*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
#pragma once
 
#if (JUCE_PLUGINHOST_ARA && (JUCE_PLUGINHOST_VST3 || JUCE_PLUGINHOST_AU) && (JUCE_MAC || JUCE_WINDOWS || JUCE_LINUX)) || DOXYGEN
 
// Include ARA SDK headers
JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wgnu-zero-variadic-macro-arguments")
 
#include <ARA_API/ARAInterface.h>
#include <ARA_Library/Dispatch/ARAHostDispatch.h>
 
JUCE_END_IGNORE_WARNINGS_GCC_LIKE
 
//==============================================================================
namespace juce
{
class ARAEditGuard
{
public:
    explicit ARAEditGuard (ARA::Host::DocumentController& dcIn);
    ~ARAEditGuard();
 
private:
    ARA::Host::DocumentController& dc;
};
 
namespace ARAHostModel
{
 
//==============================================================================
template <typename A, typename B>
struct ConversionFunctions
{
    static_assert (sizeof (A) <= sizeof (B),
                   "It is only possible to convert between types of the same size");
 
    static B toHostRef (A value)
    {
        return readUnaligned<B> (&value);
    }
 
    static A fromHostRef (B value)
    {
        return readUnaligned<A> (&value);
    }
};
 
//==============================================================================
template <typename Base, typename PtrIn>
class ManagedARAHandle
{
public:
    using Ptr = PtrIn;
 
    ManagedARAHandle (ARA::Host::DocumentController& dc, Ptr ptr) noexcept
        : handle (ptr, Deleter { dc }) {}
 
    auto& getDocumentController() const { return handle.get_deleter().documentController; }
 
    Ptr getPluginRef() const { return handle.get(); }
 
private:
    struct Deleter
    {
        void operator() (Ptr ptr) const noexcept
        {
            const ARAEditGuard guard (documentController);
            Base::destroy (documentController, ptr);
        }
 
        ARA::Host::DocumentController& documentController;
    };
 
    std::unique_ptr<std::remove_pointer_t<Ptr>, Deleter> handle;
};
 
//==============================================================================
class AudioSource : public ManagedARAHandle<AudioSource, ARA::ARAAudioSourceRef>
{
public:
    static constexpr auto getEmptyProperties() { return makeARASizedStruct (&ARA::ARAAudioSourceProperties::merits64BitSamples); }
 
    AudioSource (ARA::ARAAudioSourceHostRef hostRef,
                 ARA::Host::DocumentController& dc,
                 const ARA::ARAAudioSourceProperties& props);
 
    ~AudioSource() = default;
 
    void update (const ARA::ARAAudioSourceProperties& props);
 
    void enableAudioSourceSamplesAccess (bool);
 
    static void destroy (ARA::Host::DocumentController&, Ptr);
};
 
class AudioModification : public ManagedARAHandle<AudioModification, ARA::ARAAudioModificationRef>
{
public:
    static constexpr auto getEmptyProperties()
    {
        return makeARASizedStruct (&ARA::ARAAudioModificationProperties::persistentID);
    }
 
    AudioModification (ARA::ARAAudioModificationHostRef hostRef,
                       ARA::Host::DocumentController& dc,
                       AudioSource& s,
                       const ARA::ARAAudioModificationProperties& props);
 
    void update (const ARA::ARAAudioModificationProperties& props);
 
    auto& getAudioSource() const { return source; }
 
    static void destroy (ARA::Host::DocumentController&, Ptr);
 
private:
    AudioSource& source;
};
 
struct DeletionListener
{
    virtual ~DeletionListener() = default;
 
    virtual void removeListener (DeletionListener& other) noexcept = 0;
};
 
struct PlaybackRegion
{
public:
    static constexpr auto getEmptyProperties()
    {
        return makeARASizedStruct (&ARA::ARAPlaybackRegionProperties::color);
    }
 
    PlaybackRegion (ARA::ARAPlaybackRegionHostRef hostRef,
                    ARA::Host::DocumentController& dc,
                    AudioModification& m,
                    const ARA::ARAPlaybackRegionProperties& props);
 
    ~PlaybackRegion();
 
    void update (const ARA::ARAPlaybackRegionProperties& props);
 
    void addListener (DeletionListener& x);
 
    auto& getAudioModification() const;
 
    ARA::ARAPlaybackRegionRef getPluginRef() const noexcept;
    DeletionListener& getDeletionListener() const noexcept;
 
private:
    class Impl;
 
    std::unique_ptr<Impl> impl;
};
 
class MusicalContext : public ManagedARAHandle<MusicalContext, ARA::ARAMusicalContextRef>
{
public:
    static constexpr auto getEmptyProperties()
    {
        return makeARASizedStruct (&ARA::ARAMusicalContextProperties::color);
    }
 
    MusicalContext (ARA::ARAMusicalContextHostRef hostRef,
                    ARA::Host::DocumentController& dc,
                    const ARA::ARAMusicalContextProperties& props);
 
    void update (const ARA::ARAMusicalContextProperties& props);
 
    static void destroy (ARA::Host::DocumentController&, Ptr);
};
 
class RegionSequence : public ManagedARAHandle<RegionSequence, ARA::ARARegionSequenceRef>
{
public:
    static constexpr auto getEmptyProperties()
    {
        return makeARASizedStruct (&ARA::ARARegionSequenceProperties::color);
    }
 
    RegionSequence (ARA::ARARegionSequenceHostRef hostRef,
                    ARA::Host::DocumentController& dc,
                    const ARA::ARARegionSequenceProperties& props);
 
    void update (const ARA::ARARegionSequenceProperties& props);
 
    static void destroy (ARA::Host::DocumentController&, Ptr);
};
 
//==============================================================================
template <typename RendererRef, typename Interface>
class PlaybackRegionRegistry
{
public:
    PlaybackRegionRegistry() = default;
 
    PlaybackRegionRegistry (RendererRef rendererRefIn, const Interface* interfaceIn)
        : registry (std::make_unique<Registry> (rendererRefIn, interfaceIn))
    {
    }
 
    void add    (PlaybackRegion& region) { registry->add    (region); }
 
    void remove (PlaybackRegion& region) { registry->remove (region); }
 
    bool isValid() { return registry->isValid(); }
 
private:
    class Registry : private DeletionListener
    {
    public:
        Registry (RendererRef rendererRefIn, const Interface* interfaceIn)
            : rendererRef (rendererRefIn), rendererInterface (interfaceIn)
        {
        }
 
        Registry (const Registry&) = delete;
        Registry (Registry&&) noexcept = delete;
 
        Registry& operator= (const Registry&) = delete;
        Registry& operator= (Registry&&) noexcept = delete;
 
        ~Registry() override
        {
            for (const auto& region : regions)
                doRemoveListener (*region.first);
        }
 
        bool isValid() { return rendererRef != nullptr && rendererInterface != nullptr; }
 
        void add (PlaybackRegion& region)
        {
            if (isValid())
                rendererInterface->addPlaybackRegion (rendererRef, region.getPluginRef());
 
            regions.emplace (&region.getDeletionListener(), region.getPluginRef());
            region.addListener (*this);
        }
 
        void remove (PlaybackRegion& region)
        {
            doRemoveListener (region.getDeletionListener());
        }
 
    private:
        void doRemoveListener (DeletionListener& listener) noexcept
        {
            listener.removeListener (*this);
            removeListener (listener);
        }
 
        void removeListener (DeletionListener& listener) noexcept override
        {
            const auto it = regions.find (&listener);
 
            if (it == regions.end())
            {
                jassertfalse;
                return;
            }
 
            if (isValid())
                rendererInterface->removePlaybackRegion (rendererRef, it->second);
 
            regions.erase (it);
        }
 
        RendererRef rendererRef = nullptr;
        const Interface* rendererInterface = nullptr;
        std::map<DeletionListener*, ARA::ARAPlaybackRegionRef> regions;
    };
 
    std::unique_ptr<Registry> registry;
};
 
//==============================================================================
using PlaybackRendererInterface = PlaybackRegionRegistry<ARA::ARAPlaybackRendererRef, ARA::ARAPlaybackRendererInterface>;
 
//==============================================================================
using EditorRendererInterface   = PlaybackRegionRegistry<ARA::ARAEditorRendererRef,   ARA::ARAEditorRendererInterface>;
 
//==============================================================================
class PlugInExtensionInstance final
{
public:
    PlugInExtensionInstance() = default;
 
    explicit PlugInExtensionInstance (const ARA::ARAPlugInExtensionInstance* instanceIn)
        : instance (instanceIn)
    {
    }
 
    PlaybackRendererInterface getPlaybackRendererInterface() const;
 
    EditorRendererInterface   getEditorRendererInterface() const;
 
    bool isValid() const noexcept { return instance != nullptr; }
 
private:
    const ARA::ARAPlugInExtensionInstance* instance = nullptr;
};
 
} // namespace ARAHostModel
 
//==============================================================================
class ARAHostDocumentController final
{
public:
    static std::unique_ptr<ARAHostDocumentController>
        create (ARAFactoryWrapper factory,
                const String& documentName,
                std::unique_ptr<ARA::Host::AudioAccessControllerInterface> audioAccessController,
                std::unique_ptr<ARA::Host::ArchivingControllerInterface> archivingController,
                std::unique_ptr<ARA::Host::ContentAccessControllerInterface> contentAccessController = nullptr,
                std::unique_ptr<ARA::Host::ModelUpdateControllerInterface> modelUpdateController = nullptr,
                std::unique_ptr<ARA::Host::PlaybackControllerInterface> playbackController = nullptr);
 
    ~ARAHostDocumentController();
 
    ARA::Host::DocumentController& getDocumentController() const;
 
    ARAHostModel::PlugInExtensionInstance bindDocumentToPluginInstance (AudioPluginInstance& instance,
                                                                        ARA::ARAPlugInInstanceRoleFlags knownRoles,
                                                                        ARA::ARAPlugInInstanceRoleFlags assignedRoles);
 
private:
    class Impl;
    std::unique_ptr<Impl> impl;
 
    explicit ARAHostDocumentController (std::unique_ptr<Impl>&& implIn);
};
 
void createARAFactoryAsync (AudioPluginInstance& instance, std::function<void (ARAFactoryWrapper)> cb);
 
} // namespace juce
 
//==============================================================================
#undef ARA_REF
#undef ARA_HOST_REF
 
#endif