realtime_stretch_state_bank.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/audio/realtime_time_stretch.hpp>
#include <pulp/playback/audio_renderer_limits.hpp>
#include <pulp/timeline/model.hpp>
 
#include <compare>
#include <cstdint>
#include <memory>
#include <span>
#include <vector>
 
namespace pulp::playback {
 
class PlaybackProgram;
 
struct RealtimeStretchStateSpec {
    timeline::ItemId clip_id;
    std::uint32_t channels = 0;
    audio::RealtimeTimeStretchQuality quality = audio::RealtimeTimeStretchQuality::low_latency;
    float max_time_ratio = 1.0f;
    constexpr auto operator<=>(const RealtimeStretchStateSpec&) const = default;
};
 
enum class RealtimeStretchStateBankError : std::uint8_t {
    None,
    InvalidConfiguration,
    InvalidIdentity,
    DuplicateIdentity,
    StateLimitExceeded,
    ChannelLimitExceeded,
    TimeRatioLimitExceeded,
    StateBytesExceeded,
    ProcessorPrepareRejected,
    AllocationFailed,
};
 
struct RealtimeStretchStateBankAdmission {
    RealtimeStretchStateBankError code = RealtimeStretchStateBankError::None;
    timeline::ItemId clip_id;
    std::uint64_t actual = 0;
    std::uint64_t limit = 0;
    std::uint64_t reserved_state_bytes = 0;
    audio::RealtimeTimeStretchPrepareStatus processor_status =
        audio::RealtimeTimeStretchPrepareStatus::prepared;
 
    constexpr explicit operator bool() const noexcept {
        return code == RealtimeStretchStateBankError::None;
    }
};

RealtimeStretchStateBankAdmission
admit_realtime_stretch_state_bank(std::span<const RealtimeStretchStateSpec> specs,
                                  double sample_rate, std::uint32_t maximum_block_frames,
                                  const AudioRendererLimits& limits) noexcept;

RealtimeStretchStateBankAdmission admit_realtime_stretch_program(const PlaybackProgram& program,
                                                                 double sample_rate,
                                                                 std::uint32_t maximum_block_frames,
                                                                 const AudioRendererLimits& limits);

class RealtimeStretchStateBank {
  public:
    RealtimeStretchStateBank();
    ~RealtimeStretchStateBank();
    RealtimeStretchStateBank(RealtimeStretchStateBank&&) noexcept;
    RealtimeStretchStateBank& operator=(RealtimeStretchStateBank&&) noexcept;
    RealtimeStretchStateBank(const RealtimeStretchStateBank&) = delete;
    RealtimeStretchStateBank& operator=(const RealtimeStretchStateBank&) = delete;
 
    RealtimeStretchStateBankAdmission prepare(std::span<const RealtimeStretchStateSpec> specs,
                                              double sample_rate,
                                              std::uint32_t maximum_block_frames,
                                              const AudioRendererLimits& limits);
 
    audio::RealtimeTimeStretchProcessor* state_for_epoch(timeline::ItemId clip_id,
                                                         std::uint64_t playback_epoch) noexcept;
    const audio::RealtimeTimeStretchProcessor* find(timeline::ItemId clip_id) const noexcept;
    void reset() noexcept;
 
    std::size_t size() const noexcept {
        return states_.size();
    }
    std::uint64_t reserved_state_bytes() const noexcept {
        return reserved_state_bytes_;
    }
 
  private:
    struct State;
    std::vector<std::unique_ptr<State>> states_;
    std::uint64_t reserved_state_bytes_ = 0;
};
 
} // namespace pulp::playback