processing_switch_crossfade.hpp

Go to the documentation of this file.

#pragma once

 
#include "transition_mixer.hpp"
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
 
namespace pulp::signal {

struct ProcessingSwitchPlan {
    std::int64_t warm_samples = 0;
    std::int64_t fade_samples = 1;
 
    [[nodiscard]] constexpr std::int64_t total_samples() const noexcept {
        return warm_samples + fade_samples;
    }
};

[[nodiscard]] inline ProcessingSwitchPlan plan_processing_switch(std::int64_t incoming_latency,
                                                                 std::int64_t incoming_history,
                                                                 double sample_rate,
                                                                 double fade_seconds) noexcept {
    ProcessingSwitchPlan plan;
    plan.warm_samples =
        std::max<std::int64_t>(0, incoming_latency) + std::max<std::int64_t>(0, incoming_history);
    const double rate = (std::isfinite(sample_rate) && sample_rate > 0.0) ? sample_rate : 48000.0;
    const double fade = (std::isfinite(fade_seconds) && fade_seconds > 0.0) ? fade_seconds : 0.0;
    plan.fade_samples = std::max<std::int64_t>(1, std::llround(fade * rate));
    return plan;
}

template <typename SampleType = float>
inline void processing_switch_gains_at(const ProcessingSwitchPlan& plan, std::int64_t position,
                                       SampleType& outgoing, SampleType& incoming) noexcept {
    const std::int64_t into_fade = position - plan.warm_samples;
    if (into_fade < 0) {
        outgoing = SampleType{1};
        incoming = SampleType{0};
        return;
    }
    if (into_fade >= plan.fade_samples) {
        outgoing = SampleType{0};
        incoming = SampleType{1};
        return;
    }
    TransitionMixerT<SampleType> mixer;
    mixer.configure(static_cast<std::size_t>(plan.fade_samples), TransitionCurve::EqualPower);
    mixer.gains_at(static_cast<std::size_t>(into_fade), outgoing, incoming);
}

template <typename SampleType = float> class ProcessingSwitchCrossfadeT {
  public:
    void begin(const ProcessingSwitchPlan& plan) noexcept {
        plan_ = plan;
        if (plan_.fade_samples < 1)
            plan_.fade_samples = 1;
        mixer_.configure(static_cast<std::size_t>(plan_.fade_samples), TransitionCurve::EqualPower);
        position_ = 0;
        active_ = true;
    }
    void cancel() noexcept {
        active_ = false;
        position_ = 0;
    }
 
    [[nodiscard]] bool active() const noexcept {
        return active_;
    }
    [[nodiscard]] bool finished() const noexcept {
        return active_ && position_ >= plan_.total_samples();
    }
    [[nodiscard]] bool warming() const noexcept {
        return active_ && position_ < plan_.warm_samples;
    }
    [[nodiscard]] std::int64_t position() const noexcept {
        return position_;
    }
    [[nodiscard]] const ProcessingSwitchPlan& plan() const noexcept {
        return plan_;
    }

    void mix(SampleType* const* output, const SampleType* const* incoming, int channels,
             int num_samples) noexcept {
        if (!active_ || num_samples <= 0)
            return;
        for (int i = 0; i < num_samples; ++i) {
            const std::int64_t into_fade = position_ - plan_.warm_samples;
            if (into_fade >= plan_.fade_samples) {
                for (int ch = 0; ch < channels; ++ch)
                    output[ch][i] = incoming[ch][i];
            } else if (into_fade >= 0) {
                SampleType g_out{}, g_in{};
                mixer_.gains_at(static_cast<std::size_t>(into_fade), g_out, g_in);
                for (int ch = 0; ch < channels; ++ch)
                    output[ch][i] = g_out * output[ch][i] + g_in * incoming[ch][i];
            }
            ++position_;
        }
    }
 
  private:
    ProcessingSwitchPlan plan_{};
    TransitionMixerT<SampleType> mixer_{};
    std::int64_t position_ = 0;
    bool active_ = false;
};
 
using ProcessingSwitchCrossfade = ProcessingSwitchCrossfadeT<float>;
using ProcessingSwitchCrossfade64 = ProcessingSwitchCrossfadeT<double>;
 
} // namespace pulp::signal