additive_spectral_envelope.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
 
namespace pulp::signal {

enum class SpectralDomain : std::uint8_t { absolute_hz, relative_to_f0 };

class SpectralEnvelope {
public:
    static constexpr int kMaxBreakpoints = 64;

    void clear() { count_ = 0; }
 
    int size() const { return count_; }

    bool add(double abscissa, double gain_db) {
        if (count_ >= kMaxBreakpoints) return false;
        if (!(std::isfinite(abscissa) && abscissa > 0.0) || !std::isfinite(gain_db))
            return false;
        if (count_ > 0 && abscissa <= x_[static_cast<std::size_t>(count_ - 1)])
            return false;
        x_[static_cast<std::size_t>(count_)] = abscissa;
        db_[static_cast<std::size_t>(count_)] = gain_db;
        ++count_;
        return true;
    }

    double gain_db_at(double abscissa) const {
        if (count_ == 0) return 0.0;
        if (count_ == 1 || abscissa <= x_[0]) return db_[0];
        const auto last = static_cast<std::size_t>(count_ - 1);
        if (abscissa >= x_[last]) return db_[last];
 
        std::size_t hi = 1;
        while (hi < last && x_[hi] < abscissa) ++hi;
        const double lx = std::log2(x_[hi - 1]);
        const double hx = std::log2(x_[hi]);
        const double t = (std::log2(abscissa) - lx) / (hx - lx);
        return db_[hi - 1] + t * (db_[hi] - db_[hi - 1]);
    }

    static SpectralEnvelope tilt(double db_per_octave, double reference = 1.0) {
        SpectralEnvelope e;
        const double lo = reference * 0.001;
        const double hi = reference * 1000.0;
        e.add(lo, db_per_octave * std::log2(lo / reference));
        e.add(hi, db_per_octave * std::log2(hi / reference));
        return e;
    }
 
private:
    std::array<double, kMaxBreakpoints> x_{};
    std::array<double, kMaxBreakpoints> db_{};
    int count_ = 0;
};
 
}  // namespace pulp::signal