headless.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/audio/offline_processor.hpp>
#include <pulp/format/processor.hpp>
#include <pulp/state/parameter_event_queue.hpp>
 
namespace pulp::format {

class HeadlessHost {
public:
    explicit HeadlessHost(ProcessorFactory factory);

    void prepare(double sample_rate, int max_buffer_size,
                 int input_channels = 2, int output_channels = 2);

    [[nodiscard]] bool try_prepare(
        double sample_rate, int max_buffer_size,
        int input_channels = 2, int output_channels = 2,
        PrepareResourceLimits resource_limits = {});

    [[nodiscard]] bool try_prepare_bus_layout(
        std::size_t layout_index, double sample_rate, int max_buffer_size,
        PrepareResourceLimits resource_limits = {});

    PrepareResourceLimit last_prepare_limit_failure() const {
        return last_prepare_limit_failure_;
    }

    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input);

    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input,
                 ProcessContext context);

    void process_with_sidechain(
        audio::BufferView<float>& output,
        const audio::BufferView<const float>& input,
        const audio::BufferView<const float>& sidechain,
        ProcessContext context = {});

    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input,
                 midi::MidiBuffer& midi_in,
                 midi::MidiBuffer& midi_out);

    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input,
                 const state::ParameterEventQueue& param_events);

    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input,
                 midi::MidiBuffer& midi_in,
                 midi::MidiBuffer& midi_out,
                 ProcessContext context);
 
    void process_with_sidechain(
        audio::BufferView<float>& output,
        const audio::BufferView<const float>& input,
        const audio::BufferView<const float>& sidechain,
        midi::MidiBuffer& midi_in,
        midi::MidiBuffer& midi_out,
        ProcessContext context);

    void process(audio::BufferView<float>& output,
                 const audio::BufferView<const float>& input,
                 midi::MidiBuffer& midi_in,
                 midi::MidiBuffer& midi_out,
                 const state::ParameterEventQueue& param_events,
                 ProcessContext context);

    void process_f64(audio::BufferView<double>& output,
                     const audio::BufferView<const double>& input);

    void process_f64(audio::BufferView<double>& output,
                     const audio::BufferView<const double>& input,
                     ProcessContext context);

    void process_f64(audio::BufferView<double>& output,
                     const audio::BufferView<const double>& input,
                     midi::MidiBuffer& midi_in,
                     midi::MidiBuffer& midi_out);

    void process_f64(audio::BufferView<double>& output,
                     const audio::BufferView<const double>& input,
                     const state::ParameterEventQueue& param_events);

    void process_f64(audio::BufferView<double>& output,
                     const audio::BufferView<const double>& input,
                     midi::MidiBuffer& midi_in,
                     midi::MidiBuffer& midi_out,
                     ProcessContext context);

    void process_f64(audio::BufferView<double>& output,
                     const audio::BufferView<const double>& input,
                     midi::MidiBuffer& midi_in,
                     midi::MidiBuffer& midi_out,
                     const state::ParameterEventQueue& param_events,
                     ProcessContext context);

    std::optional<audio::AudioFileData> render_offline(
        const audio::AudioFileData& input,
        const audio::OfflineRenderOptions& options = {});

    std::optional<audio::AudioFileData> render_offline_with_sidechain(
        const audio::AudioFileData& input,
        const audio::AudioFileData& sidechain,
        const audio::OfflineRenderOptions& options = {});

    void release();

    bool valid() const noexcept { return processor_ != nullptr; }

    Processor* processor() noexcept { return processor_.get(); }
    const Processor* processor() const noexcept { return processor_.get(); }
    template <class T>
    T* processor_as() noexcept { return dynamic_cast<T*>(processor_.get()); }

    state::StateStore& state() { return store_; }
    const state::StateStore& state() const { return store_; }

    const PluginDescriptor& descriptor() const { return descriptor_; }

    std::vector<uint8_t> save_state() const;

    bool load_state(std::span<const uint8_t> data);
 
private:
    std::optional<audio::AudioFileData> render_offline_impl(
        const audio::AudioFileData& input,
        const audio::AudioFileData* sidechain,
        const audio::OfflineRenderOptions& options);
    // The store is declared before the Processor so it is destroyed after it.
    // `Processor::state()` dereferences a pointer to this store, and a Processor
    // may read it from its destructor or from a worker thread that destructor is
    // about to join. Reversing these two lines hands that thread a freed store.
    state::StateStore store_;
    std::unique_ptr<Processor> processor_;
    PluginDescriptor descriptor_;
    std::shared_ptr<PanicState> panic_state_;
    double sample_rate_ = 48000.0;
    PrepareResourceLimit last_prepare_limit_failure_ = PrepareResourceLimit::None;
};
 
} // namespace pulp::format