Plugin.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <complex>
#include <concepts>
#include <cstdint>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
// Vamp C API uses unsigned int as size type (blockSize, stepSize, channelCount, outputCount, ...).
// Make sure it has at least 32 bit and use uint32_t as size type in C++ interfaces.
static_assert(sizeof(unsigned int) >= sizeof(uint32_t), "Size type must have at least 32 bit");
 
namespace rtvamp::pluginsdk {
 
class PluginBase {
public:
    PluginBase() = default;
    virtual ~PluginBase() = default;
 
    PluginBase(const PluginBase&) = default;
    PluginBase(PluginBase&&) = default;
    PluginBase& operator=(const PluginBase&) = default;
    PluginBase& operator=(PluginBase&&) = default;
 
    enum class InputDomain { Time, Frequency };
 
    struct ParameterDescriptor {
        // use const char* for compile-time evaluation and mapping to C API
        const char*          identifier   = "";
        const char*          name         = "";
        const char*          description  = "";
        const char*          unit         = "";
        float                defaultValue = 0.0F;
        float                minValue     = 0.0F;
        float                maxValue     = 0.0F;
        std::optional<float> quantizeStep = std::nullopt;
        // std::vector<const char*> valueNames{};  // currently not possible -> wait for constexpr vectors
    };
 
    struct OutputDescriptor {
        std::string               identifier;
        std::string               name;
        std::string               description;
        std::string               unit;
        uint32_t                  binCount = 1;
        std::vector<std::string>  binNames = {};  // NOLINT(*redundant-member-init)
        bool                      hasKnownExtents = false;
        float                     minValue        = 0.0F;
        float                     maxValue        = 0.0F;
        std::optional<float>      quantizeStep    = std::nullopt;
    };
 
    using TimeDomainBuffer      = std::span<const float>;  
    using FrequencyDomainBuffer = std::span<const std::complex<float>>;  
    using InputBuffer           = std::variant<TimeDomainBuffer, FrequencyDomainBuffer>;  
    using Feature               = std::vector<float>;  
};
 
template <uint32_t NOutputs>
class Plugin : public PluginBase {
public:
    explicit constexpr Plugin(float inputSampleRate) : inputSampleRate_(inputSampleRate) {}
 
    using OutputList = std::array<OutputDescriptor, NOutputs>;  
    using FeatureSet = std::array<Feature, NOutputs>;           
 
    static constexpr uint32_t outputCount = NOutputs;  
 
    struct Meta {
        const char*  identifier    = "";
        const char*  name          = "";
        const char*  description   = "";
        const char*  maker         = "";
        const char*  copyright     = "";
        int          pluginVersion = 1;
        InputDomain  inputDomain   = InputDomain::Time;
    };
 
    static constexpr Meta                               meta{};        
    static constexpr std::array<ParameterDescriptor, 0> parameters{};  
    static constexpr std::array<const char*, 0>         programs{};    
 
    virtual std::optional<float> getParameter(std::string_view id) const { return {}; }
    virtual bool                 setParameter(std::string_view id, float value) { return false; } 
 
    virtual std::string_view     getCurrentProgram() const { return {}; }
    virtual bool                 selectProgram(std::string_view name) { return false; }
 
    virtual uint32_t             getPreferredStepSize()  const { return 0; }
    virtual uint32_t             getPreferredBlockSize() const { return 0; }
 
    virtual OutputList           getOutputDescriptors() const = 0;
 
    virtual bool                 initialise(uint32_t stepSize, uint32_t blockSize) = 0;
    virtual void                 reset() = 0;
    virtual const FeatureSet&    process(InputBuffer buffer, uint64_t nsec) = 0;
 
protected:
    float       getInputSampleRate() const noexcept { return inputSampleRate_; };
    FeatureSet& getFeatureSet() noexcept { return featureSet_; }
 
    void initialiseFeatureSet() {
        const auto outputs     = getOutputDescriptors();
        auto&      featureSet  = getFeatureSet();
        for (size_t i = 0; i < outputCount; ++i) {
            featureSet[i].resize(outputs[i].binCount);
        }
    }
 
private:
    float      inputSampleRate_;
    FeatureSet featureSet_;
};
 
/* ------------------------------------------- Concept ------------------------------------------ */
 
template <typename T>
concept HasParameters = requires {
    { T::parameters } -> std::convertible_to<std::array<PluginBase::ParameterDescriptor, T::parameters.size()>>;
};
 
template <typename T>
concept HasPrograms = requires {
    { T::programs } -> std::convertible_to<std::array<const char*, T::programs.size()>>;
};
 
template <typename T>
concept IsPlugin = std::constructible_from<T, float> && requires(
    T plugin,
    std::string_view parameterName,
    float parameterValue,
    std::string_view programName,
    uint32_t stepSize,
    uint32_t blockSize,
    PluginBase::InputBuffer buffer,
    uint64_t nsec
) {
    { T::outputCount } -> std::convertible_to<uint32_t>;
    { T::meta } -> std::convertible_to<typename T::Meta>;
 
    requires (!HasParameters<T> || requires {
        { plugin.getParameter(parameterName) } -> std::same_as<std::optional<float>>;
        { plugin.setParameter(parameterName, parameterValue) } -> std::same_as<bool>;
    });
 
    requires (!HasPrograms<T> || requires {
        { plugin.getCurrentProgram() } -> std::same_as<std::string_view>;
        { plugin.selectProgram(programName) } -> std::same_as<bool>;
    });
 
    { plugin.getPreferredStepSize() } -> std::same_as<uint32_t>;
    { plugin.getPreferredBlockSize() } -> std::same_as<uint32_t>;
    { plugin.getOutputDescriptors() } -> std::same_as<std::array<PluginBase::OutputDescriptor, T::outputCount>>;
    { plugin.initialise(stepSize, blockSize) } -> std::same_as<bool>;
    { plugin.reset() } -> std::same_as<void>;
    { plugin.process(buffer, nsec) } -> std::convertible_to<const std::array<PluginBase::Feature, T::outputCount>&>;
};
 
}  // namespace rtvamp::pluginsdk