tempo_sync.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/audio/rt_safety_contract.hpp>
 
#include <cstdint>
 
namespace pulp::playback {
 
class MasterTransport;
class TempoSyncSource;

class TempoSyncHostTime {
  public:
    TempoSyncHostTime() = default;
 
  private:
    friend class MasterTransport;
    friend class TempoSyncSource;
    TempoSyncHostTime(std::int64_t micros, const TempoSyncSource* source) noexcept
        : micros_(micros), source_(source) {}
 
    std::int64_t micros_ = 0;
    const TempoSyncSource* source_ = nullptr;
};

struct TempoSyncCommand {
    double tempo_bpm = 120.0;
    double beat = 0.0;
    bool request_tempo = false;
    bool request_beat = false;
    bool request_playing = false;
    bool playing = false;
};

struct TempoSyncBlockRequest {
    std::int64_t output_host_time_micros = 0;
    std::uint32_t frame_count = 0;
    double sample_rate = 0.0;
    double quantum_beats = 4.0;
    TempoSyncCommand command{};
};

struct TempoSyncBlockState {
    double tempo_bpm = 120.0;
    double beat_start = 0.0;
    double beat_end = 0.0;
    std::int64_t is_playing_at_host_time_micros = 0;
    bool is_playing = false;
};
 
enum class TempoSyncPlayingBoundary : std::uint8_t {
    BeforeOrAtBlockStart,
    InsideBlock,
    AtOrAfterBlockEnd,
};

struct TempoSyncPlayingProjection {
    TempoSyncPlayingBoundary boundary = TempoSyncPlayingBoundary::BeforeOrAtBlockStart;
    bool playing_for_block = false;
    bool transition_deferred = false;
};
 
enum class TempoSyncError : std::uint8_t {
    None,
    Disabled,
    InvalidRequest,
    InvalidState,
    BackendFailure,
};
 
bool valid_tempo_sync_request(const TempoSyncBlockRequest& request) noexcept;
bool valid_tempo_sync_state(const TempoSyncBlockState& state) noexcept;
bool tempo_sync_add_output_latency(std::int64_t clock_time_micros,
                                   std::uint32_t output_latency_frames, double sample_rate,
                                   std::int64_t& output_host_time_micros) noexcept;
bool tempo_sync_block_end_host_time_micros(const TempoSyncBlockRequest& request,
                                           std::int64_t& block_end) noexcept;
TempoSyncPlayingProjection project_tempo_sync_playing(const TempoSyncBlockRequest& request,
                                                      const TempoSyncBlockState& state,
                                                      bool previous_playing) noexcept;

class TempoSyncSource {
  public:
    static constexpr audio::RtSafetyClass capture_audio_block_rt_safety_class =
        audio::RtSafetyClass::AudioCallbackSafeAfterPrepare;
 
    virtual ~TempoSyncSource() = default;
 
    virtual TempoSyncError capture_audio_block(const TempoSyncBlockRequest& request,
                                               TempoSyncBlockState& state) noexcept = 0;
 
  protected:
    TempoSyncHostTime make_host_time(std::int64_t micros) const noexcept {
        return TempoSyncHostTime{micros, this};
    }
};
 
} // namespace pulp::playback