Filter.cpp

Go to the documentation of this file.

#include "Filter.hpp"
 
#include "MayaFlux/Kinesis/Discrete/Coefficients.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
 
namespace MayaFlux::Nodes::Filters {
 
Filter::Filter(const std::shared_ptr<Node>& input, const std::vector<double>& a_coef, const std::vector<double>& b_coef)
    : m_input_node(input)
    , m_context(0.0, m_input_history, m_output_history, m_coef_a, m_coef_b)
    , m_context_gpu(0.0, m_input_history, m_output_history, m_coef_a, m_coef_b, get_gpu_data_buffer())
{
    setACoefficients(a_coef);
    setBCoefficients(b_coef);
}
 
Filter::Filter(const std::vector<double>& a_coef, const std::vector<double>& b_coef)
    : Filter(nullptr, a_coef, b_coef)
{
}
 
void Filter::set_coefs(const std::vector<double>& new_coefs, coefficients type)
{
    if (type == coefficients::OUTPUT) {
        setACoefficients(new_coefs);
    } else if (type == coefficients::INPUT) {
        setBCoefficients(new_coefs);
    } else {
        setACoefficients(new_coefs);
        setBCoefficients(new_coefs);
    }
}
 
void Filter::build_input_history(double current_sample)
{
    if (m_use_external_input_context && !m_external_input_context.empty()) {
        size_t available = m_external_input_context.size();
        size_t lookback = std::min(available, m_input_history.size() - 1);
 
        m_input_history[0] = current_sample;
 
        for (size_t i = 0; i < lookback; ++i) {
            m_input_history[i + 1] = m_external_input_context[available - 1 - i];
        }
    } else {
        update_inputs(current_sample);
    }
}
 
void Filter::update_inputs(double current_sample)
{
    for (unsigned int i = m_input_history.size() - 1; i > 0; i--) {
        m_input_history[i] = m_input_history[i - 1];
    }
    m_input_history[0] = current_sample;
}
 
void Filter::update_outputs(double current_sample)
{
    for (unsigned int i = m_output_history.size() - 1; i > 0; i--) {
        m_output_history[i] = m_output_history[i - 1];
    }
    m_output_history[0] = current_sample;
}
 
void Filter::setACoefficients(const std::vector<double>& new_coefs)
{
    if (new_coefs.empty()) {
        error<std::invalid_argument>(Journal::Component::Nodes, Journal::Context::Configuration, std::source_location::current(),
            "Denominator coefficients cannot be empty. Received size: {}", new_coefs.size());
    }
    if (std::abs(new_coefs[0]) < k_min_leading_coef) {
        error<std::invalid_argument>(Journal::Component::Nodes, Journal::Context::Configuration, std::source_location::current(),
            "First denominator coefficient (a[0]) magnitude below {}. Received a[0]: {}", k_min_leading_coef, new_coefs[0]);
    }
 
    m_coef_a = new_coefs;
    const double a0 = m_coef_a[0];
    for (auto& coef : m_coef_a) {
        coef /= a0;
    }
    m_output_history.assign(m_coef_a.size(), 0.0);
}
 
void Filter::setBCoefficients(const std::vector<double>& new_coefs)
{
    if (new_coefs.empty()) {
        error<std::invalid_argument>(Journal::Component::Nodes, Journal::Context::Configuration, std::source_location::current(),
            "Numerator coefficients cannot be empty. Received size: {}", new_coefs.size());
    }
 
    m_coef_b = new_coefs;
    m_input_history.assign(m_coef_b.size(), 0.0);
}
 
void Filter::update_coefs_from_node(int length, const std::shared_ptr<Node>& source, coefficients type)
{
    std::vector<double> samples = source->process_batch(length);
    set_coefs(samples, type);
}
 
void Filter::update_coef_from_input(int length, coefficients type)
{
    if (m_input_node) {
        std::vector<double> samples = m_input_node->process_batch(length);
        set_coefs(samples, type);
    } else {
        MF_WARN(Journal::Component::Nodes, Journal::Context::NodeProcessing, "No input node set for Filter. Use Filter::setInputNode() to set an input node. Alternatively, use Filter::updateCoefficientsFromNode() to specify a different source node.");
    }
}
 
void Filter::add_coef_internal(uint64_t index, double value, std::vector<double>& buffer)
{
    if (index >= buffer.size()) {
        buffer.resize(index + 1, 0.0);
    }
    buffer[index] = value;
 
    if (&buffer == &m_coef_a) {
        if (std::abs(m_coef_a[0]) < k_min_leading_coef) {
            MF_WARN(Journal::Component::Nodes, Journal::Context::Configuration,
                "Leading denominator coefficient {} below floor; restoring 1.0", m_coef_a[0]);
            m_coef_a[0] = 1.0;
        }
        const double a0 = m_coef_a[0];
        if (a0 != 1.0) {
            for (auto& coef : m_coef_a) {
                coef /= a0;
            }
        }
        m_output_history.resize(m_coef_a.size(), 0.0);
    } else {
        m_input_history.resize(m_coef_b.size(), 0.0);
    }
}
 
void Filter::add_coef(int index, double value, coefficients type)
{
    switch (type) {
    case coefficients::INPUT:
        add_coef_internal(index, value, m_coef_b);
        break;
    case coefficients::OUTPUT:
        add_coef_internal(index, value, m_coef_a);
        break;
    default:
        add_coef_internal(index, value, m_coef_a);
        add_coef_internal(index, value, m_coef_b);
        break;
    }
}
 
double Filter::max_pole_magnitude() const
{
    return Kinesis::Discrete::max_pole_magnitude(m_coef_a);
}
 
void Filter::reset()
{
    std::ranges::fill(m_input_history, 0.0);
    std::ranges::fill(m_output_history, 0.0);
}
 
void Filter::normalize_coefficients(coefficients type)
{
    if (type == coefficients::OUTPUT || type == coefficients::ALL) {
        if (!m_coef_a.empty() && m_coef_a[0] != 0.0) {
            double a0 = m_coef_a[0];
            for (auto& coef : m_coef_a) {
                coef /= a0;
            }
        }
    }
 
    if (type == coefficients::INPUT || type == coefficients::ALL) {
        if (!m_coef_b.empty()) {
            double max_coef = 0.0;
            for (const auto& coef : m_coef_b) {
                max_coef = std::max(max_coef, std::abs(coef));
            }
 
            if (max_coef > 0.0) {
                for (auto& coef : m_coef_b) {
                    coef /= max_coef;
                }
            }
        }
    }
}
 
std::complex<double> Filter::get_frequency_response(double frequency, double sample_rate) const
{
    double omega = 2.0 * M_PI * frequency / sample_rate;
    std::complex<double> z = std::exp(std::complex<double>(0, omega));
 
    std::complex<double> numerator = 0.0;
    for (size_t i = 0; i < m_coef_b.size(); ++i) {
        numerator += m_coef_b[i] * std::pow(z, -static_cast<int>(i));
    }
 
    std::complex<double> denominator = 0.0;
    for (size_t i = 0; i < m_coef_a.size(); ++i) {
        denominator += m_coef_a[i] * std::pow(z, -static_cast<int>(i));
    }
 
    return numerator / denominator;
}
 
double Filter::get_magnitude_response(double frequency, double sample_rate) const
{
    return std::abs(get_frequency_response(frequency, sample_rate));
}
 
double Filter::get_phase_response(double frequency, double sample_rate) const
{
    return std::arg(get_frequency_response(frequency, sample_rate));
}
 
std::vector<double> Filter::process_batch(unsigned int num_samples)
{
    std::vector<double> output(num_samples);
    for (unsigned int i = 0; i < num_samples; ++i) {
        output[i] = process_sample(0.0);
    }
    return output;
}
 
void Filter::update_context(double value)
{
    if (m_gpu_compatible) {
        m_context_gpu.value = value;
 
        const auto& src = m_context_gpu.input_history;
        m_context_gpu.gpu_float_buffer.resize(src.size());
        for (size_t i = 0; i < src.size(); ++i)
            m_context_gpu.gpu_float_buffer[i] = static_cast<float>(src[i]);
 
        m_context_gpu.m_gpu_data = std::span<const float>(m_context_gpu.gpu_float_buffer);
    } else {
        m_context.value = value;
    }
}
 
void Filter::notify_tick(double value)
{
    update_context(value);
    auto& ctx = get_last_context();
 
    for (auto& callback : m_callbacks) {
        callback(ctx);
    }
    for (auto& [callback, condition] : m_conditional_callbacks) {
        if (condition(ctx)) {
            callback(ctx);
        }
    }
}
 
NodeContext& Filter::get_last_context()
{
    if (m_gpu_compatible) {
        return m_context_gpu;
    }
    return m_context;
}
 
void Filter::on_tick(const TypedHook<FilterContext>& callback)
{
    m_callbacks.emplace_back([callback](NodeContext& ctx) {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
        callback(static_cast<FilterContext&>(ctx));
    });
}
 
void Filter::on_tick_if(const NodeCondition& condition, const TypedHook<FilterContext>& callback)
{
    m_conditional_callbacks.emplace_back([callback](NodeContext& ctx) {
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
        callback(static_cast<FilterContext&>(ctx));
    },
        condition);
}
 
std::vector<std::pair<ModulatorRole, std::shared_ptr<Node>>>
Filter::get_modulators() const
{
    if (m_input_node)
        return { { ModulatorRole::SignalMod, m_input_node } };
    return {};
}
 
}