dry_wet_mixer.hpp

Go to the documentation of this file.

#pragma once
 
// Dry/wet mix with optional latency compensation.
// Use to blend original (dry) signal with processed (wet) signal.
 
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstring>
 
namespace pulp::signal {

enum class MixCurve {
    Linear,
    EqualPower,
    Balanced,
    Sin3dB,
    Sin4_5dB,
    Sin6dB,
    Sqrt3dB,
    Sqrt4_5dB,
};
 
template <typename SampleType = float>
class DryWetMixerT {
public:
    void set_mix(SampleType mix) {
        mix_ = std::clamp(mix, SampleType{0.0f}, SampleType{1.0f});
        if (ramp_samples_ <= 0) {
            current_mix_ = mix_;
            ramp_remaining_ = 0;
            mix_increment_ = SampleType{0.0f};
            return;
        }
        mix_increment_ = (mix_ - current_mix_) /
                         static_cast<SampleType>(ramp_samples_);
        ramp_remaining_ = ramp_samples_;
    }

    SampleType mix() const { return mix_; }

    SampleType current_mix() const { return current_mix_; }

    void set_ramp_samples(int samples) {
        const int new_ramp = std::max(0, samples);
        if (new_ramp == ramp_samples_) return;
        ramp_samples_ = new_ramp;
        if (ramp_samples_ <= 0) {
            // Dropping the ramp settles immediately rather than leaving a
            // partially-applied ratio in place.
            current_mix_ = mix_;
            ramp_remaining_ = 0;
            mix_increment_ = SampleType{0.0f};
            return;
        }
        if (ramp_remaining_ > 0) {
            ramp_remaining_ = std::min(ramp_remaining_, ramp_samples_);
            mix_increment_ = ramp_remaining_ > 0
                ? (mix_ - current_mix_) /
                      static_cast<SampleType>(ramp_remaining_)
                : SampleType{0.0f};
        }
    }
    int ramp_samples() const { return ramp_samples_; }

    void set_ramp_time(SampleType seconds, SampleType sample_rate) {
        if (!(seconds > SampleType{0.0f}) || !(sample_rate > SampleType{0.0f})) {
            set_ramp_samples(0);
            return;
        }
        set_ramp_samples(static_cast<int>(seconds * sample_rate));
    }

    bool is_ramping() const { return ramp_remaining_ > 0; }

    void set_curve(MixCurve curve) { curve_ = curve; }

    void set_wet_latency(int samples) {
        const int new_latency = std::max(0, samples);
        if (new_latency == latency_)
            return;
 
        latency_ = new_latency;
        delay_pos_ = 0;
 
        if (latency_ > 0 && max_channels_ > 0)
            delay_buffer_.assign(static_cast<size_t>(latency_ * max_channels_),
                                 SampleType{0.0f});
        else
            delay_buffer_.clear();
 
        for (auto& ch : dry_buffer_)
            std::fill(ch.begin(), ch.end(), SampleType{0.0f});
    }

    void prepare(int max_channels, int max_block_size) {
        settle_ramp();
        max_channels_ = std::max(0, max_channels);
        max_block_size_ = std::max(0, max_block_size);
        delay_pos_ = 0;
        if (latency_ > 0 && max_channels_ > 0)
            delay_buffer_.assign(static_cast<size_t>(latency_ * max_channels_),
                                 SampleType{0.0f});
        else
            delay_buffer_.clear();
 
        dry_buffer_.resize(static_cast<size_t>(max_channels_));
        for (auto& ch : dry_buffer_)
            ch.assign(static_cast<size_t>(max_block_size_), SampleType{0.0f});
        active_dry_channels_ = 0;
        active_dry_samples_ = 0;
    }

    void push_dry(const SampleType* const* channels, int num_channels, int num_samples) {
        if (channels == nullptr || num_channels <= 0 || num_samples <= 0) {
            active_dry_channels_ = 0;
            active_dry_samples_ = 0;
            return;
        }
 
        ensure_dry_storage(num_channels, num_samples);
 
        if (latency_ <= 0) {
            // No latency compensation — just store the dry signal
            for (int ch = 0; ch < num_channels; ++ch) {
                std::memcpy(dry_buffer_[ch].data(), channels[ch],
                            static_cast<size_t>(num_samples) * sizeof(SampleType));
            }
            active_dry_channels_ = num_channels;
            active_dry_samples_ = num_samples;
            return;
        }
 
        // With latency compensation — delay the dry signal.
        // Process sample-by-sample (all channels per sample) so the delay
        // position advances once per frame, not once per channel.
        const int count = std::min(num_channels, max_channels_);
 
        for (int i = 0; i < num_samples; ++i) {
            for (int ch = 0; ch < count; ++ch) {
                size_t idx = static_cast<size_t>(delay_pos_ * max_channels_ + ch);
                dry_buffer_[ch][i] = delay_buffer_[idx];
                delay_buffer_[idx] = channels[ch][i];
            }
            delay_pos_ = (delay_pos_ + 1) % latency_;
        }
        active_dry_channels_ = count;
        active_dry_samples_ = num_samples;
    }

    void mix_wet(SampleType* const* wet_channels, int num_channels, int num_samples) {
        const int channel_count = std::min(num_channels, active_dry_channels_);
        const int sample_count = std::min(num_samples, active_dry_samples_);
        if (channel_count <= 0 || sample_count <= 0) return;
 
        if (ramp_remaining_ <= 0) {
            // Settled: one gain pair for the whole block.
            SampleType dry_gain, wet_gain;
            compute_gains(current_mix_, dry_gain, wet_gain);
            for (int ch = 0; ch < channel_count; ++ch) {
                for (int i = 0; i < sample_count; ++i) {
                    wet_channels[ch][i] = dry_buffer_[ch][i] * dry_gain +
                                          wet_channels[ch][i] * wet_gain;
                }
            }
            return;
        }
 
        // Ramping: the ratio advances once per frame, so frames are the
        // outer loop and every channel of a frame shares its gain pair.
        for (int i = 0; i < sample_count; ++i) {
            if (ramp_remaining_ > 0) {
                current_mix_ += mix_increment_;
                if (--ramp_remaining_ == 0) current_mix_ = mix_;
            }
            SampleType dry_gain, wet_gain;
            compute_gains(current_mix_, dry_gain, wet_gain);
            for (int ch = 0; ch < channel_count; ++ch) {
                wet_channels[ch][i] = dry_buffer_[ch][i] * dry_gain +
                                      wet_channels[ch][i] * wet_gain;
            }
        }
    }
 
    void reset() {
        std::fill(delay_buffer_.begin(), delay_buffer_.end(), SampleType{0.0f});
        delay_pos_ = 0;
        for (auto& ch : dry_buffer_)
            std::fill(ch.begin(), ch.end(), SampleType{0.0f});
        settle_ramp();
    }
 
private:
    SampleType mix_ = SampleType{1.0f};
    SampleType current_mix_ = SampleType{1.0f};
    SampleType mix_increment_ = SampleType{0.0f};
    int ramp_samples_ = 0;
    int ramp_remaining_ = 0;
    MixCurve curve_ = MixCurve::Linear;
    int latency_ = 0;
    int max_channels_ = 2;
    int max_block_size_ = 0;
    int delay_pos_ = 0;
    int active_dry_channels_ = 0;
    int active_dry_samples_ = 0;
    std::vector<SampleType> delay_buffer_;
    std::vector<std::vector<SampleType>> dry_buffer_;
 
    void ensure_dry_storage(int num_channels, int num_samples) {
        if (num_channels <= static_cast<int>(dry_buffer_.size())) {
            for (int ch = 0; ch < num_channels; ++ch) {
                if (num_samples > static_cast<int>(dry_buffer_[ch].size()))
                    dry_buffer_[ch].resize(static_cast<size_t>(num_samples));
            }
            return;
        }
 
        const auto old_size = dry_buffer_.size();
        dry_buffer_.resize(static_cast<size_t>(num_channels));
        for (std::size_t ch = old_size; ch < dry_buffer_.size(); ++ch)
            dry_buffer_[ch].resize(static_cast<size_t>(std::max(max_block_size_, num_samples)));
        for (std::size_t ch = 0; ch < old_size; ++ch) {
            if (num_samples > static_cast<int>(dry_buffer_[ch].size()))
                dry_buffer_[ch].resize(static_cast<size_t>(num_samples));
        }
    }
 
    void settle_ramp() {
        current_mix_ = mix_;
        ramp_remaining_ = 0;
        mix_increment_ = SampleType{0.0f};
    }
 
    void compute_gains(SampleType ratio, SampleType& dry, SampleType& wet) const {
        constexpr SampleType kHalfPi = SampleType{1.57079632679489661923f};
        const SampleType theta = ratio * kHalfPi;
        switch (curve_) {
            case MixCurve::Linear:
                dry = SampleType{1.0f} - ratio;
                wet = ratio;
                break;
            case MixCurve::EqualPower:
            case MixCurve::Sin3dB:
                dry = std::cos(theta);
                wet = std::sin(theta);
                break;
            case MixCurve::Balanced:
                dry = ratio <= SampleType{0.5f}
                    ? SampleType{1.0f}
                    : (SampleType{1.0f} - ratio) * SampleType{2.0f};
                wet = ratio >= SampleType{0.5f}
                    ? SampleType{1.0f}
                    : ratio * SampleType{2.0f};
                break;
            case MixCurve::Sin4_5dB: {
                // Clamp before pow to guard against tiny negative residue.
                const SampleType c = std::max(SampleType{0.0f}, std::cos(theta));
                const SampleType s = std::max(SampleType{0.0f}, std::sin(theta));
                dry = std::pow(c, SampleType{1.5f});
                wet = std::pow(s, SampleType{1.5f});
                break;
            }
            case MixCurve::Sin6dB:
                dry = std::cos(theta) * std::cos(theta);
                wet = std::sin(theta) * std::sin(theta);
                break;
            case MixCurve::Sqrt3dB:
                dry = std::sqrt(SampleType{1.0f} - ratio);
                wet = std::sqrt(ratio);
                break;
            case MixCurve::Sqrt4_5dB:
                // -4.5 dB = geometric mean of -3 dB sqrt (exp 0.5) and
                // -6 dB linear (exp 1.0) → exponent 0.75. At mix=0.5
                // produces 0.5^0.75 ≈ 0.5946 per side ≈ -4.51 dB,
                // matching the documented midpoint notch.
                dry = std::pow(SampleType{1.0f} - ratio, SampleType{0.75f});
                wet = std::pow(ratio, SampleType{0.75f});
                break;
        }
    }
};
 
using DryWetMixer = DryWetMixerT<float>;
using DryWetMixer64 = DryWetMixerT<double>;
 
}  // namespace pulp::signal