transition_mixer.hpp

Go to the documentation of this file.

#pragma once

 
#include "crossfade.hpp"
 
#include <algorithm>
#include <cmath>
#include <cstddef>
 
namespace pulp::signal {
 
enum class TransitionCurve { Smoothstep, EqualPower };
 
template <typename SampleType = float>
class TransitionMixerT {
public:
    TransitionMixerT() = default;

    void configure(std::size_t length_samples, TransitionCurve curve) {
        length_ = length_samples;
        curve_ = curve;
        pos_ = 0;
    }
    void set_curve(TransitionCurve curve) { curve_ = curve; }
    TransitionCurve curve() const { return curve_; }
 
    void reset() { pos_ = 0; }
    void advance(std::size_t frames) { pos_ += frames; }
 
    std::size_t length() const { return length_; }
    std::size_t position() const { return pos_; }
    bool done() const { return length_ == 0 || pos_ >= length_; }

    void gains_at(std::size_t fade_pos,
                  SampleType& old_gain,
                  SampleType& new_gain) const {
        const SampleType t = (length_ == 0)
            ? SampleType{1.0f}
            : static_cast<SampleType>(fade_pos) / static_cast<SampleType>(length_);
        // Smoothstep-shaped progress (click-free ends), then the shared old→new
        // gain law: EqualPower → constant power (cos/sin), Smoothstep → equal gain.
        const SampleType u = crossfade_smoothstep(t);
        crossfade_gains(u,
                        curve_ == TransitionCurve::EqualPower
                            ? CrossfadeGainLaw::EqualPower
                            : CrossfadeGainLaw::EqualGain,
                        old_gain, new_gain);
    }
 
private:
    std::size_t length_ = 0;
    std::size_t pos_ = 0;
    TransitionCurve curve_ = TransitionCurve::Smoothstep;
};
 
using TransitionMixer = TransitionMixerT<float>;
using TransitionMixer64 = TransitionMixerT<double>;

template <class Mixer, class OutView, class OldView>
inline bool blend_fade_out(Mixer& mixer, OutView& out, const OldView& old_render) noexcept {
    const std::size_t frames = std::min<std::size_t>(out.num_samples(), old_render.num_samples());
    const std::size_t ch = std::min<std::size_t>(out.num_channels(), old_render.num_channels());
    const std::size_t base = mixer.position();
    // The old/new gain pair depends only on the (shared) fade position, not the
    // channel, so compute each pair ONCE per frame and reuse it across channels
    // instead of re-evaluating gains_at (two transcendentals for EqualPower) per
    // channel per sample. Precompute in bounded stack chunks to stay alloc-free
    // while keeping the per-channel apply loop contiguous. Bit-identical to the
    // previous channel-outer form (gains_at is a pure function of base+n).
    constexpr std::size_t kChunk = 64;
    float old_gain[kChunk];
    float new_gain[kChunk];
    for (std::size_t start = 0; start < frames; start += kChunk) {
        const std::size_t len = std::min<std::size_t>(kChunk, frames - start);
        for (std::size_t j = 0; j < len; ++j)
            mixer.gains_at(base + start + j, old_gain[j], new_gain[j]);
        for (std::size_t c = 0; c < ch; ++c) {
            auto o = out.channel(c);
            auto old_ch = old_render.channel(c);
            for (std::size_t j = 0; j < len; ++j)
                o[start + j] = old_ch[start + j] * old_gain[j] + o[start + j] * new_gain[j];
        }
    }
    mixer.advance(frames);
    return mixer.done();
}
 
}  // namespace pulp::signal