ballistics_filter.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/denormal.hpp>
 
#include <algorithm>
#include <cmath>
#include <limits>
 
namespace pulp::signal {

template <typename SampleType = float> class BallisticsFilterT {
  public:
    enum class Mode { peak, rms };
    enum class TimeConvention { legacy_nominal, exact_10_to_90 };
 
    BallisticsFilterT() = default;
 
    explicit BallisticsFilterT(TimeConvention time_convention)
        : time_convention_(time_convention) {}
 
    void prepare(SampleType sample_rate) {
        sample_rate_ = sample_rate;
        update_coefficients();
    }
 
    void set_attack_ms(SampleType ms) {
        if (!std::isfinite(static_cast<double>(ms)))
            return;
        attack_ms_ = std::max(SampleType{0.01f}, ms);
        update_coefficients();
    }
 
    void set_release_ms(SampleType ms) {
        if (!std::isfinite(static_cast<double>(ms)))
            return;
        release_ms_ = std::max(SampleType{0.01f}, ms);
        update_coefficients();
    }
 
    void set_mode(Mode m) {
        mode_ = m;
    }
 
    SampleType process(SampleType input) {
        if (!std::isfinite(static_cast<double>(input))) {
            reset();
            return SampleType{0};
        }
        if (!std::isfinite(static_cast<double>(state_)) || state_ < SampleType{0})
            reset();
 
        const SampleType magnitude = std::abs(input);
        SampleType value = magnitude;
        if (mode_ == Mode::rms) {
            const SampleType square_limit = std::sqrt(std::numeric_limits<SampleType>::max());
            value = magnitude > square_limit ? std::numeric_limits<SampleType>::max()
                                             : magnitude * magnitude;
        }
        SampleType coeff = (value > state_) ? attack_coeff_ : release_coeff_;
        // Snap the envelope state where subnormals are slow, so a long release
        // into silence does not stall in the denormal range (see
        // snap_recursion_state()). No-op above 1e-15.
        state_ = snap_recursion_state(state_ + coeff * (value - state_));
        if (!std::isfinite(static_cast<double>(state_)) || state_ < SampleType{0}) {
            reset();
            return SampleType{0};
        }
        return (mode_ == Mode::rms) ? std::sqrt(state_) : state_;
    }
 
    void process(const SampleType* input, SampleType* output, int num_samples) {
        for (int i = 0; i < num_samples; ++i) {
            output[i] = process(input[i]);
        }
    }
 
    SampleType current() const {
        if (!std::isfinite(static_cast<double>(state_)) || state_ < SampleType{0})
            return SampleType{0};
        return (mode_ == Mode::rms) ? std::sqrt(state_) : state_;
    }

    SampleType current_db(SampleType floor_db = SampleType{-160}) const {
        if (!std::isfinite(static_cast<double>(floor_db)) || floor_db > SampleType{0})
            floor_db = SampleType{-160};
        const SampleType value = current();
        if (!(value > SampleType{0}))
            return floor_db;
        const SampleType db = SampleType{20} * std::log10(value);
        return std::isfinite(static_cast<double>(db)) ? std::max(floor_db, db) : floor_db;
    }
 
    SampleType attack_ms() const noexcept {
        return attack_ms_;
    }
    SampleType release_ms() const noexcept {
        return release_ms_;
    }
    SampleType attack_coefficient() const noexcept {
        return attack_coeff_;
    }
    SampleType release_coefficient() const noexcept {
        return release_coeff_;
    }

    static SampleType coefficient_for_time_ms(SampleType ms, SampleType sample_rate) {
        if (!std::isfinite(static_cast<double>(ms)) ||
            !std::isfinite(static_cast<double>(sample_rate)) || !(sample_rate > SampleType{0}))
            return SampleType{0};
        if (!(ms > SampleType{0.01f}))
            return SampleType{1};
        return SampleType{1} -
               std::exp(SampleType{-2.2f} / (ms * SampleType{0.001f} * sample_rate));
    }

    static SampleType exact_coefficient_for_time_ms(SampleType ms, SampleType sample_rate) {
        if (!std::isfinite(static_cast<double>(ms)) ||
            !std::isfinite(static_cast<double>(sample_rate)) || !(sample_rate > SampleType{0}))
            return SampleType{0};
        if (!(ms > SampleType{0.01f}))
            return SampleType{1};
        return SampleType{1} -
               std::exp(-std::log(SampleType{9}) / (ms * SampleType{0.001} * sample_rate));
    }
 
    void reset() {
        state_ = SampleType{0.0f};
    }
 
  protected:
    SampleType detector_state() const noexcept {
        return state_;
    }
 
    void synchronize_detector_state(SampleType state) noexcept {
        state_ = std::isfinite(static_cast<double>(state)) && state >= SampleType{0}
                     ? state
                     : SampleType{0};
    }
 
  private:
    SampleType sample_rate_ = SampleType{44100.0f};
    SampleType attack_ms_ = SampleType{1.0f};
    SampleType release_ms_ = SampleType{100.0f};
    SampleType attack_coeff_ = SampleType{0.0f};
    SampleType release_coeff_ = SampleType{0.0f};
    SampleType state_ = SampleType{0.0f};
    Mode mode_ = Mode::peak;
    TimeConvention time_convention_ = TimeConvention::legacy_nominal;
 
    void update_coefficients() {
        if (sample_rate_ <= 0)
            return;
        attack_coeff_ = time_constant(attack_ms_);
        release_coeff_ = time_constant(release_ms_);
    }
 
    SampleType time_constant(SampleType ms) const {
        return time_convention_ == TimeConvention::exact_10_to_90
                   ? exact_coefficient_for_time_ms(ms, sample_rate_)
                   : coefficient_for_time_ms(ms, sample_rate_);
    }
};
 
using BallisticsFilter = BallisticsFilterT<float>;
using BallisticsFilter64 = BallisticsFilterT<double>;
 
} // namespace pulp::signal