AirAbsorptionFilter.cpp

Go to the documentation of this file.

namespace krotos
{
    AirAbsorptionFilter::AirAbsorptionFilter()
    {
        m_filter1[0].a = m_a1;
        m_filter1[1].a = m_a1;
 
        m_filter2[0].a = m_a2;
        m_filter2[1].a = m_a2;
    }
 
    void AirAbsorptionFilter::prepare(double sampleRate, int samplesPerBlock)
    {
        ignoreUnused(sampleRate);
        ignoreUnused(samplesPerBlock);
 
        for (int j = 0; j < 2; j++)
        {
            m_filter1[j].reset();
            m_filter2[j].reset();
        }
    }
 
    float AirAbsorptionFilter::process(float inputSample, int numChannel)
    {
        inputSample = inputSample * m_gain;
        inputSample = m_filter1[numChannel](inputSample);
        inputSample = m_filter2[numChannel](inputSample);
 
        return inputSample;
    }
 
    void AirAbsorptionFilter::setDistance(float distance)
    {
        m_gain = 10.0f / std::max(distance, 10.0f); // inverse square law
 
        auto index = jmap<float>(distance, 1.0f, 70.0f, 0.0f, 6.0f);
        auto mu = index - std::floor(index);
        auto b1 = linear_interpolate(m_b1[std::size_t(index)], m_b1[std::size_t(index) + 1], mu);
        auto b2 = linear_interpolate(m_b2[std::size_t(index)], m_b2[std::size_t(index) + 1], mu);
 
        m_filter1[0].b = b1;
        m_filter1[1].b = b1;
 
        m_filter2[0].b = b2;
        m_filter2[1].b = b2;
    }
 
    void AirAbsorptionFilter::test_impulse_response(std::size_t index, String outfile)
    {
        jassert(index < 7);
 
        // Figure 4 (Petruzzellis & Zanghieri 2013)
        // Temperature 0°C, relative humidity 10%
        const float a1 = 0.0503f;
        const float a2 = 0.849f;
        const std::array<float, 7> b1Array{0.0168f, 0.034f, 0.052f, 0.069f, 0.085f, 0.102f, 0.1182f};
        const std::array<float, 7> b2Array{0.02f, 0.02f, 0.06f, 0.08f, 0.1f, 0.12f, 0.14f};
        auto b1 = b1Array[index];
        auto b2 = b2Array[index];
 
        m_filter1[0].reset();
        m_filter2[0].reset();
        m_filter1[0].config(a1, b1);
        m_filter2[0].config(a2, b2);
 
        const int N = 1024;
        std::vector<float> y(N);
        for (int i = 0; i < N; ++i)
        {
            // Dirac
            auto x = (i == 0) ? 1.0f : 0.0f;
            x = m_filter1[0](x);
            x = m_filter2[0](x);
            y[i] = x;
        }
        std::ofstream outputFile(outfile.toStdString());
        if (!outputFile.is_open())
        {
            DBG("Failed to open file: ");
            return;
        }
        for (const auto& value : y)
        {
            outputFile << value << " ";
        }
        outputFile << '\n';
        outputFile.close();
 
        m_filter1[0].reset();
        m_filter2[0].reset();
    }
 
    AirAbsorptionFilter::modified_lowpass::modified_lowpass(float a, float b) : a(a), b(b), x1(0), y1(0) {}
 
    float AirAbsorptionFilter::modified_lowpass::operator()(float s)
    {
        // compute result
        auto r = (a + b - 1.0f) * s + (1.0f - b) * x1 + (1.0f - a) * y1;
 
        // shift s to x1
        x1 = s;
 
        // shift r to y1
        y1 = r;
 
        return r;
    }
 
    void AirAbsorptionFilter::modified_lowpass::config(float a_, float b_)
    {
        a = a_;
        b = b_;
    }
 
    void AirAbsorptionFilter::modified_lowpass::reset()
    {
        x1 = 0.0f;
        y1 = 0.0f;
    }
 
} // namespace krotos