soft_bypass.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <cstddef>
#include <utility>
 
namespace pulp::signal {
 
template <typename Processor, typename SampleType = float>
class SoftBypassT {
public:
    SoftBypassT() = default;
    explicit SoftBypassT(Processor processor) : processor_(std::move(processor)) {}

    Processor& processor() noexcept { return processor_; }
    const Processor& processor() const noexcept { return processor_; }

    void set_fade_samples(int samples) noexcept {
        fade_step_ = SampleType{1.0f} /
                     static_cast<SampleType>(samples < 1 ? 1 : samples);
    }

    void set_bypassed(bool bypassed) noexcept {
        target_wet_ = bypassed ? SampleType{0.0f} : SampleType{1.0f};
    }

    bool bypassed() const noexcept { return target_wet_ <= SampleType{0.0f}; }
    bool fading() const noexcept { return current_wet_ != target_wet_; }
    SampleType wet_mix() const noexcept { return current_wet_; }

    SampleType process(SampleType input) noexcept {
        advance_fade();
        // Fully bypassed and settled: skip the wrapped processor entirely. The
        // fade-in on re-engage ramps the wet contribution up from zero, so this
        // stays click-free despite the processor's state being frozen meanwhile.
        if (current_wet_ <= SampleType{0.0f}) return input;
        const SampleType wet = processor_.process(input);
        if (current_wet_ >= SampleType{1.0f}) return wet;
        return input * (SampleType{1.0f} - current_wet_) + wet * current_wet_;
    }

    void process(SampleType* data, int num_samples) noexcept {
        for (int i = 0; i < num_samples; ++i) data[i] = process(data[i]);
    }

    void reset() noexcept {
        if constexpr (requires { processor_.reset(); }) processor_.reset();
        current_wet_ = target_wet_;
    }
 
private:
    void advance_fade() noexcept {
        if (current_wet_ < target_wet_) {
            current_wet_ = std::min(target_wet_, current_wet_ + fade_step_);
        } else if (current_wet_ > target_wet_) {
            current_wet_ = std::max(target_wet_, current_wet_ - fade_step_);
        }
    }
 
    Processor processor_{};
    SampleType current_wet_ = SampleType{1.0f};  // start active
    SampleType target_wet_ = SampleType{1.0f};
    SampleType fade_step_ = SampleType{1.0f} / SampleType{256.0f};  // ~256-sample default fade
};
 
template <typename Processor>
using SoftBypass = SoftBypassT<Processor, float>;
 
template <typename Processor>
using SoftBypass64 = SoftBypassT<Processor, double>;
 
}  // namespace pulp::signal