track_mixer_program.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/playback/automation_program.hpp>
#include <pulp/timebase/compiled_tempo_map.hpp>
#include <pulp/timeline/model.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
 
namespace pulp::playback {

inline constexpr float kMaximumTrackMixerGain = 64.0f;
static_assert(kMaximumTrackMixerGain == timeline::kMaximumTrackGainLinear,
              "the render path must bound an automated fader by exactly the range the "
              "document accepts for a static one, or a curve could ask for a gain the "
              "model refuses to store");

struct TrackMixerProgram {
    float gain_linear = 1.0f;
    float pan = 0.0f;
    const AutomationProgram* gain_automation = nullptr;
    const AutomationProgram* pan_automation = nullptr;

    bool transparent() const noexcept {
        return gain_automation == nullptr && pan_automation == nullptr && gain_linear == 1.0f &&
               pan == 0.0f;
    }
};

constexpr float clamped_track_gain(float value) noexcept {
    if (!(value >= 0.0f))
        return value <= 0.0f ? 0.0f : 1.0f;
    return value > kMaximumTrackMixerGain ? kMaximumTrackMixerGain : value;
}
 
constexpr float clamped_track_pan(float value) noexcept {
    if (!(value >= -1.0f))
        return value <= -1.0f ? -1.0f : 0.0f;
    return value > 1.0f ? 1.0f : value;
}

struct TrackMixerChannelGains {
    float left = 1.0f;
    float right = 1.0f;
};
 
constexpr TrackMixerChannelGains track_mixer_channel_gains(float pan) noexcept {
    return {pan > 0.0f ? 1.0f - pan : 1.0f, pan < 0.0f ? 1.0f + pan : 1.0f};
}

constexpr float track_mixer_channel_gain(float pan, std::size_t channel,
                                         std::size_t channel_count) noexcept {
    if (channel_count < 2)
        return 1.0f;
    const auto gains = track_mixer_channel_gains(pan);
    return channel % 2u == 0u ? gains.left : gains.right;
}

class TrackMixerControlCursor {
  public:
    void reset(const AutomationProgram* program, float constant) noexcept {
        program_ = program && !program->empty() ? program : nullptr;
        constant_ = constant;
        segment_index_ = 0;
        cold_ = true;
    }

    bool automated() const noexcept {
        return program_ != nullptr;
    }

    void restart(const timebase::CompiledTempoMap& map) noexcept {
        if (!program_)
            return;
        tempo_.reset(map);
        segment_index_ = 0;
        cold_ = true;
    }
 
    float value_at(timebase::SamplePosition sample) noexcept {
        if (!program_)
            return constant_;
        segment_index_ = select_automation_segment(*program_, sample, cold_, segment_index_);
        const auto tick = cold_ ? tempo_.seek(sample).tick : tempo_.advance(sample).tick;
        cold_ = false;
        if (sample < program_->segments().front().start_sample)
            return program_->leading_value();
        return evaluate_automation_segment(*program_, segment_index_, sample, tick);
    }

    float value_at_tick(long double tick) noexcept {
        if (!program_)
            return constant_;
        const auto segments = program_->segments();
        if (cold_) {
            const auto found = std::upper_bound(
                segments.begin(), segments.end(), tick,
                [](long double value, const AutomationProgramSegment& segment) {
                    return value <
                           static_cast<long double>(segment.end_tick.value);
                });
            segment_index_ =
                found == segments.end()
                    ? segments.size() - 1u
                    : static_cast<std::size_t>(found - segments.begin());
            cold_ = false;
        } else {
            while (segment_index_ + 1u < segments.size() &&
                   tick >= static_cast<long double>(
                               segments[segment_index_].end_tick.value))
                ++segment_index_;
        }
        if (tick < static_cast<long double>(segments.front().start_tick.value))
            return program_->leading_value();
        const auto& segment = segments[segment_index_];
        if (segment.start_tick == segment.end_tick)
            return segment.end_value;
        const auto start = static_cast<long double>(segment.start_tick.value);
        const auto end = static_cast<long double>(segment.end_tick.value);
        if (tick <= start)
            return segment.start_value;
        if (tick >= end)
            return segment.end_value;
        if (segment.interpolation == timeline::AutomationInterpolation::Hold)
            return segment.start_value;
        const auto fraction = std::clamp((tick - start) / (end - start), 0.0L, 1.0L);
        const auto bend = static_cast<long double>(segment.curvature);
        const auto quadratic =
            bend >= 0.0L ? fraction * fraction : std::fma(-fraction, fraction, 2.0L * fraction);
        const auto shaped = std::fma(std::abs(bend), quadratic - fraction, fraction);
        return static_cast<float>(std::fma(static_cast<long double>(segment.end_value) -
                                               static_cast<long double>(segment.start_value),
                                           shaped, static_cast<long double>(segment.start_value)));
    }
 
  private:
    const AutomationProgram* program_ = nullptr;
    float constant_ = 1.0f;
    timebase::TempoCursor tempo_;
    std::size_t segment_index_ = 0;
    bool cold_ = true;
};
 
} // namespace pulp::playback