vca.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/smoothed_value.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstdint>
 
namespace pulp::signal {
 
enum class VcaResponse : std::uint8_t { linear, exponential };

template <typename SampleType = float>
class VcaT {
public:
    using Response = VcaResponse;

    static constexpr double kMinRangeDb = 12.0;
    static constexpr double kMaxRangeDb = 120.0;
    static constexpr double kDefaultRangeDb = 60.0;

    static constexpr double kDefaultLagMs = 1.0;
 
    void prepare(SampleType sample_rate) {
        sample_rate_ = std::isfinite(static_cast<double>(sample_rate)) &&
                               sample_rate > SampleType{0}
                           ? sample_rate
                           : SampleType{1};
        update_lag_();
        reset();
    }
 
    void set_response(Response r) { response_ = r; }
    Response response() const { return response_; }
 
    void set_range_db(double db) {
        if (!std::isfinite(db)) return;
        range_db_ = std::clamp(db, kMinRangeDb, kMaxRangeDb);
    }
 
    double range_db() const { return range_db_; }
 
    void set_lag_ms(double ms) {
        if (!std::isfinite(ms)) return;
        lag_ms_ = std::max(0.0, ms);
        update_lag_();
    }
 
    void reset(SampleType control = SampleType{0}) {
        lag_.set_immediate(control);
        last_control_ = control;
    }

    SampleType gain_for(SampleType control) const {
        if (!std::isfinite(static_cast<double>(control))) return SampleType{0};
        const SampleType c = std::clamp(control, SampleType{0}, SampleType{1});
        if (response_ == Response::linear) return c;
        if (c <= SampleType{0}) return SampleType{0};
        // Equal control travel is equal dB travel. Keep the endpoint special
        // so a wide-open VCA remains exactly bit-transparent.
        if (c >= SampleType{1}) return SampleType{1};
        return static_cast<SampleType>(
            std::pow(10.0, (-range_db_ / 20.0) *
                               (1.0 - static_cast<double>(c))));
    }

    SampleType next_gain(SampleType control) {
        if (!std::isfinite(static_cast<double>(control))) control = SampleType{0};
        const SampleType target = std::clamp(control, SampleType{0}, SampleType{1});
        // Re-targeting every sample would restart the ramp every sample and the
        // value would approach the target without ever arriving. Only a genuine
        // change starts a new ramp, so a held control lands exactly.
        if (target != last_control_) {
            lag_.set_target(target);
            last_control_ = target;
        }
        return gain_for(lag_.next());
    }
 
    SampleType process(SampleType input, SampleType control) {
        return input * next_gain(control);
    }

    SampleType control() const { return lag_.current(); }
 
private:
    void update_lag_() {
        lag_.set_ramp_time(static_cast<SampleType>(lag_ms_ * 0.001), sample_rate_);
    }
 
    SmoothedValue<SampleType> lag_{};
    SampleType sample_rate_ = SampleType{48000};
    SampleType last_control_ = SampleType{0};
    double lag_ms_ = kDefaultLagMs;
    double range_db_ = kDefaultRangeDb;
    Response response_ = Response::linear;
};
 
using Vca = VcaT<float>;
using Vca64 = VcaT<double>;
 
} // namespace pulp::signal