recording.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/runtime/result.hpp>
#include <pulp/timebase/rational_time.hpp>
#include <pulp/timeline/clip.hpp>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace pulp::timeline {

 
// A Take is one recorded region that references a sealed media asset. It lives
// in a TakeLane on a Track and is anchored to absolute (sample) time: raw
// captures are sample-accurate against the transport, not musical. The take's
// timeline length is its media frame_count. A Take owns a stable ItemId because
// comps select take segments by identity. The asset reference is
// external (Project::create validates it exists); the take never owns the asset.
class Take {
  public:
    static runtime::Result<Take, ModelError> create(ItemId id, MediaRef media,
                                                    timebase::SamplePosition placement_start,
                                                    timebase::RationalRate sample_rate);

    ItemId id() const noexcept {
        return id_;
    }

    const MediaRef& media() const noexcept {
        return media_;
    }

    timebase::SamplePosition placement_start() const noexcept {
        return placement_start_;
    }

    timebase::RationalRate sample_rate() const noexcept {
        return sample_rate_;
    }
 
  private:
    Take(ItemId id, MediaRef media, timebase::SamplePosition placement_start,
         timebase::RationalRate sample_rate) noexcept
        : id_(id), media_(media), placement_start_(placement_start), sample_rate_(sample_rate) {}
 
    ItemId id_;
    MediaRef media_;
    timebase::SamplePosition placement_start_;
    timebase::RationalRate sample_rate_;
};
 
static_assert(std::is_nothrow_copy_constructible_v<Take>);
static_assert(std::is_nothrow_move_constructible_v<Take>);

struct TakeCompSegment {
    ItemId take_id;
    AbsoluteTimeRange range;
    constexpr bool operator==(const TakeCompSegment& other) const noexcept {
        return take_id == other.take_id && range.start == other.range.start &&
               range.sample_count == other.range.sample_count &&
               range.sample_rate == other.range.sample_rate;
    }
};

struct TrackFreeze {
    MediaRef media;
    timebase::SamplePosition placement_start;
    timebase::RationalRate sample_rate;
    ContentHash render_plan_hash;
    constexpr bool operator==(const TrackFreeze& other) const noexcept {
        return media.asset_id == other.media.asset_id &&
               media.source_start == other.media.source_start &&
               media.frame_count == other.media.frame_count &&
               placement_start == other.placement_start && sample_rate == other.sample_rate &&
               render_plan_hash == other.render_plan_hash;
    }
};

class TakeLane {
  public:
    static runtime::Result<TakeLane, ModelError> create(ItemId id, std::string name,
                                                        std::vector<Take> takes,
                                                        std::vector<TakeCompSegment> comp = {});
    runtime::Result<TakeLane, ModelError> insert_take(Take take) const;
    runtime::Result<TakeLane, ModelError> erase_take(ItemId id) const;
    runtime::Result<TakeLane, ModelError>
    with_comp_segments(std::vector<TakeCompSegment> comp) const;

    ItemId id() const noexcept;
    const std::string& name() const noexcept;
    std::span<const Take> takes() const noexcept;
    std::span<const TakeCompSegment> comp_segments() const noexcept;
    const Take* find_take(ItemId id) const noexcept;
 
  private:
    struct Data;
    explicit TakeLane(std::shared_ptr<const Data> data) : data_(std::move(data)) {}
    std::shared_ptr<const Data> data_;
};

struct TrackMixer {
    float gain_linear = 1.0f;
    float pan = 0.0f;
    constexpr bool operator==(const TrackMixer&) const = default;
};

inline constexpr float kMaximumTrackGainLinear = 64.0f;

 
} // namespace pulp::timeline