Nsound::FilterIIR Class Reference

#include <Nsound/FilterIIR.h>

Inheritance diagram for Nsound::FilterIIR:

Public Member Functions
	FilterIIR (const float64 &sample_rate, uint32 n_poles)
	FilterIIR (const FilterIIR &copy)
virtual	~FilterIIR ()
Buffer	designFrequencyResponse (const Buffer &frequency_response, const float64 &max_error=0.01, const int32 max_iterations=1000)
	Designs a filter kernel using a genetic algorithm that trys to match the provided frequency response. More...
Buffer	designImpulseResponse (const Buffer &impulse_response, const float64 &max_error=0.01, const int32 max_iterations=1000)
	Designs a filter kernel using a genetic algorithm that trys to match the provided impulse response. More...
AudioStream	filter (const AudioStream &x)
AudioStream	filter (const AudioStream &x, const Buffer &frequencies)
Buffer	filter (const Buffer &x)
Buffer	filter (const Buffer &x, const Buffer &frequencies)
float64	filter (const float64 &x)
float64	filter (const float64 &x, const float64 &frequency)
uint32	getKernelSize () const
Buffer	getImpulseResponse (const uint32 n_samples=8192)
FilterIIR &	operator= (const FilterIIR &rhs)
void	reset ()
void	setRealtime (bool flag)
AudioStream	filter (const AudioStream &x, const float64 &frequency)
Buffer	filter (const Buffer &x, const float64 &frequency)
Buffer	getFrequencyAxis (const uint32 n_fft=8192)
Buffer	getFrequencyResponse (const uint32 n_fft=8192)
Buffer	getPhaseResponse ()
float64	getSampleRate () const
void	plot (boolean show_phase=false)

Protected Types
enum	SignalType { FREQUENCY_RESSPONSE = 0, IMPULSE_RESPONSE }

Protected Member Functions
Buffer	designKernel (const Buffer &response, const float64 &max_rms_error, const int32 max_iterations, const SignalType type)
	Designs a filter kernel that trys to match the provide frequency response. More...
float64	getRMS (const Kernel &kernel, const Buffer &response, const SignalType type)
void	savePlot (const Kernel &k, const Buffer &response, uint32 n, const float64 &error)

Protected Attributes
uint32	n_poles_
Kernel *	kernel_
float64 *	x_history_
float64 *	x_ptr_
float64 *	x_end_ptr_
float64 *	y_history_
float64 *	y_ptr_
float64 *	y_end_ptr_
RngTausworthe *	rng_
float64	sample_rate_
float64	two_pi_over_sample_rate_
float64	sample_time_
uint32	kernel_size_
bool	is_realtime_

Friends
std::ostream &	operator<< (std::ostream &out, const FilterIIR &rhs)
	Prints the coeffents. More...

Detailed Description

WARNING: This is Experimental, you should not use this class as it may not be working or will change in future releases of Nsound.

Definition at line 52 of file FilterIIR.h.

Member Enumeration Documentation

enum Nsound::FilterIIR::SignalType

protected

Enumerator
FREQUENCY_RESSPONSE
IMPULSE_RESPONSE

Definition at line 132 of file FilterIIR.h.

    {
        FREQUENCY_RESSPONSE = 0,
        IMPULSE_RESPONSE
    };

Constructor & Destructor Documentation

FilterIIR::FilterIIR	(	const float64 &	sample_rate,
		uint32	n_poles
	)

Definition at line 59 of file FilterIIR.cc.

References kernel_, n_poles_, reset(), rng_, x_end_ptr_, x_history_, x_ptr_, y_end_ptr_, y_history_, and y_ptr_.

    :
    Filter(sample_rate),
    n_poles_(n_poles),
    kernel_(NULL),
    x_history_(NULL),
    x_ptr_(NULL),
    x_end_ptr_(NULL),
    y_history_(NULL),
    y_ptr_(NULL),
    y_end_ptr_(NULL),
    rng_(NULL)
{
    kernel_ = new Kernel(n_poles_, n_poles_);

    x_history_ = new float64 [n_poles_ + 1];
    x_ptr_     = x_history_;
    x_end_ptr_ = x_history_ + n_poles_ + 1;

    y_history_ = new float64 [n_poles_ + 1];
    y_ptr_     = y_history_;
    y_end_ptr_ = y_history_ + n_poles_ + 1;

    rng_ = new RngTausworthe();

    reset();
}

FilterIIR::FilterIIR

(

const FilterIIR &

copy

)

Definition at line 91 of file FilterIIR.cc.

References n_poles_, reset(), rng_, x_history_, and y_history_.

    :
    Filter(copy.sample_rate_),
    n_poles_(copy.n_poles_),
    kernel_(NULL),
    x_history_(NULL),
    x_ptr_(NULL),
    x_end_ptr_(NULL),
    y_history_(NULL),
    y_ptr_(NULL),
    y_end_ptr_(NULL),
    rng_(NULL)
{
    x_history_ = new float64 [n_poles_];
    y_history_ = new float64 [n_poles_];

    rng_ = new RngTausworthe();

    *this = copy;

    reset();
}

FilterIIR::~FilterIIR ( )

virtual

Definition at line 116 of file FilterIIR.cc.

References kernel_, rng_, x_history_, and y_history_.

{
    delete kernel_;
    delete [] x_history_;
    delete [] y_history_;

    delete rng_;
}

Member Function Documentation

Buffer FilterIIR::designFrequencyResponse	(	const Buffer &	frequency_response,
		const float64 &	max_error = 0.01,
		const int32	max_iterations = 1000
	)

Designs a filter kernel using a genetic algorithm that trys to match the provided frequency response.

Designs a filter kernel that trys to match the provide frequency response. The method uses a genetic algorithm to arrive at a fit solution and retuns the error per generation. The error signal is nice to plot to get an idea of how quickly the solution was found.

Definition at line 127 of file FilterIIR.cc.

References designKernel(), and FREQUENCY_RESSPONSE.

Referenced by main().

{
    return designKernel(
        frequency_response,
        max_error,
        max_iterations,
        FREQUENCY_RESSPONSE);
}

Buffer FilterIIR::designImpulseResponse	(	const Buffer &	impulse_response,
		const float64 &	max_error = 0.01,
		const int32	max_iterations = 1000
	)

Designs a filter kernel using a genetic algorithm that trys to match the provided impulse response.

Designs a filter kernel that trys to match the provide impulse response The method uses a genetic algorithm to arrive at a fit solution and retuns the error per generation. The error signal is nice to plot to get an idea of how quickly the solution was found.

Definition at line 141 of file FilterIIR.cc.

References designKernel(), and IMPULSE_RESPONSE.

{
    return designKernel(
        impulse_response,
        max_error,
        max_iterations,
        IMPULSE_RESPONSE);
}

AudioStream Nsound::FilterIIR::filter ( const AudioStream &  x )

inline

Definition at line 89 of file FilterIIR.h.

References Nsound::Filter::filter().

Referenced by filter().

    { return Filter::filter(x);};

AudioStream Nsound::FilterIIR::filter ( const AudioStream &  x, const Buffer &  frequencies  )

inline

Definition at line 93 of file FilterIIR.h.

References Nsound::Filter::filter().

    { return Filter::filter(x);};

Buffer Nsound::FilterIIR::filter ( const Buffer &  x )

inline

Definition at line 97 of file FilterIIR.h.

References Nsound::Filter::filter().

    {return Filter::filter(x);};

Buffer Nsound::FilterIIR::filter ( const Buffer &  x, const Buffer &  frequencies  )

inline

Definition at line 101 of file FilterIIR.h.

References filter().

    {return filter(x);};

float64 FilterIIR::filter ( const float64 &  x )

virtual

Implements Nsound::Filter.

Definition at line 609 of file FilterIIR.cc.

References Nsound::Kernel::getA(), Nsound::Kernel::getB(), kernel_, n_poles_, x_end_ptr_, x_history_, x_ptr_, y_end_ptr_, y_history_, and y_ptr_.

{
    // Write x to history
    *x_ptr_ = x;

    // Increment history pointer
    ++x_ptr_;

    // Bounds check
    if(x_ptr_ >= x_end_ptr_)
    {
        x_ptr_ = x_history_;
    }

    float64 y = 0.0;
    float64 * x_hist = x_ptr_;
    const float64 * bb = kernel_->getB();
    const float64 * b_end = bb + n_poles_;
    for(const float64 * b = bb; b < b_end; ++b)
    {
        // When we enter this loop, x_hist is pointing at x[n + 1]
        --x_hist;

        // Bounds check
        if(x_hist < x_history_)
        {
            x_hist = x_end_ptr_ - 1;
        }

        y += *b * *x_hist;
    }

    float64 * y_hist = y_ptr_;
    const float64 * aa = kernel_->getA();
    const float64 * a_end = aa + n_poles_;
    for(const float64 * a = aa + 1; a < a_end; ++a)
    {
        // When we enter this loop, y_hist is pointing at y[n + 1]
        --y_hist;

        // Bounds check
        if(y_hist < y_history_)
        {
            y_hist = y_end_ptr_ - 1;
        }

        y += *a * *y_hist;
    }

    // insert output into history buffer
    *y_ptr_ = y;

    // Increment history pointer
    ++y_ptr_;

    // Bounds check
    if(y_ptr_ >= y_end_ptr_)
    {
        y_ptr_ = y_history_;
    }

    return y;
}

float64 FilterIIR::filter ( const float64 &  x, const float64 &  frequency  )

virtual

Implements Nsound::Filter.

Definition at line 675 of file FilterIIR.cc.

References filter().

{
    return FilterIIR::filter(x);
}

uint32 Nsound::FilterIIR::getKernelSize ( ) const

inlinevirtual

Reimplemented from Nsound::Filter.

Definition at line 111 of file FilterIIR.h.

References n_poles_.

{return n_poles_;};

Buffer Nsound::FilterIIR::getImpulseResponse ( const uint32  n_samples = 8192 )

inline

Definition at line 114 of file FilterIIR.h.

References Nsound::Filter::getImpulseResponse(), and reset().

Referenced by getRMS().

    { reset(); return Filter::getImpulseResponse(n_samples); };

FilterIIR & FilterIIR::operator=

(

const FilterIIR &

rhs

)

Definition at line 683 of file FilterIIR.cc.

References kernel_, n_poles_, rng_, Nsound::Filter::sample_rate_, x_history_, and y_history_.

{
    if(this == &rhs)
    {
        return *this;
    }

    sample_rate_ = rhs.sample_rate_;

    if(n_poles_ != rhs.n_poles_)
    {
        delete [] x_history_;
        delete [] y_history_;

        n_poles_ = rhs.n_poles_;

        x_history_ = new float64 [n_poles_];
        y_history_ = new float64 [n_poles_];
    }

    memcpy(x_history_, rhs.x_history_, sizeof(float64) * n_poles_);
    memcpy(y_history_, rhs.y_history_, sizeof(float64) * n_poles_);

    *kernel_ = *rhs.kernel_;
    *rng_ = *rhs.rng_;

    return *this;
}

void FilterIIR::reset ( )

virtual

Implements Nsound::Filter.

Definition at line 724 of file FilterIIR.cc.

References n_poles_, x_history_, x_ptr_, y_history_, and y_ptr_.

Referenced by FilterIIR(), getImpulseResponse(), getRMS(), and savePlot().

{
    memset(x_history_, 0, sizeof(float64) * (n_poles_ + 1));
    memset(y_history_, 0, sizeof(float64) * (n_poles_ + 1));

    x_ptr_ = x_history_;
    y_ptr_ = y_history_;
}

Buffer FilterIIR::designKernel ( const Buffer &  response, const float64 &  max_rms_error, const int32  max_iterations, const SignalType  type  )

protected

Designs a filter kernel that trys to match the provide frequency response.

This method is VERY EXPERMENTAL! Use at your own risk!

Designs a filter kernel that trys to match the provide frequency response. The method uses a genetic algorithm to arrive at a fit solution and retuns the error per generation. The error signal is nice to plot to get an idea of how quickly the solution was found.

Definition at line 249 of file FilterIIR.cc.

References Nsound::Kernel::ga_interleave(), Nsound::Kernel::ga_swap_ab(), Nsound::RngTausworthe::get(), Nsound::Kernel::getA(), Nsound::Kernel::getB(), Nsound::Buffer::getLength(), getRMS(), Nsound::Kernel::getSum(), kernel_, M_ASSERT_VALUE, n_poles_, PRINT_LINE, Nsound::Kernel::randomize(), rng_, Nsound::Kernel::setA(), and Nsound::Kernel::setB().

Referenced by designFrequencyResponse(), and designImpulseResponse().

{
    // The reference response curve must be a power of two to guarentee correct
    // comparision to the designed kernel response.

    uint32 p2 = 2;
    uint32 ref_size = ref_response.getLength();

    while( p2 < ref_size )
    {
        p2 <<= 1;
    }

    M_ASSERT_VALUE(ref_size, ==, p2);

    if(ref_size != p2) ::exit(1);

    // Create the initial 2 parents
    Kernel * mom = new Kernel(n_poles_, n_poles_);

    float64 LARGE_RMS = 1.0;
    float64 STALE_RMS = 0.001;

    float64 rms_error = LARGE_RMS;
    int32 dead_count = 0;
    while(rms_error > LARGE_RMS && dead_count < 1000)
    {
        mom->randomize(-0.1, 0.1);
        rms_error = getRMS(*mom, ref_response, type);
        dead_count++;
    }

    M_ASSERT_VALUE(rms_error, <=, LARGE_RMS);

    if(rms_error > LARGE_RMS) ::exit(1);

    Kernel * dad = new Kernel(n_poles_, n_poles_);

    dad->randomize(-0.1, 0.1);

    int32 N_CHILDREN = 14;

    // Allocate N children
    Kernel ** child = new Kernel * [N_CHILDREN];

    for(int32 i = 0; i < N_CHILDREN; ++i)
    {
        child[i] = new Kernel(n_poles_, n_poles_);
    }

    Buffer rms_history;

    rms_history << rms_error;

    float64 dad_rms_error = getRMS(*dad, ref_response, type);

    cout << std::setprecision(10)
         << "mom's RMS = " << rms_error << endl
         << "dad's RMS = " << dad_rms_error << endl;

    float64 rms_error1 = LARGE_RMS;
    float64 rms_error2 = LARGE_RMS;

    Kernel * low1 = NULL;
    Kernel * low2 = NULL;

    float64 last_rms_error = rms_error;
    int32 stale_count = 0;
    int32 major_stale_count = 0;
    int32 count = 0;

    while(count < max_iterations && rms_error > max_rms_error)
    {
        ++count;

        // First two children just swap mom & dads a & b coeffs;
        *child[0] = *mom;
        *child[1] = *dad;
        child[0]->ga_swap_ab(*child[1]);

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // Next two children interleave coeffs
        *child[2] = *mom;
        *child[3] = *dad;

        child[2]->ga_interleave(*child[3]);

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // The next two children randomly mutate one coeff from mom & dad
        *child[4] = *mom;
        *child[5] = *dad;

        for(uint32 i = 4; i < 6; ++i)
        {
            float64 delta = rng_->get(-0.1f, 0.1f);

            uint32 index = rng_->get(0, n_poles_);

            child[i]->setB(child[i]->getB(index) + delta, index);

            delta = rng_->get(-0.1f, 0.1f);

            index = rng_->get(0, n_poles_);

            child[i]->setA(child[i]->getA(index) + delta, index);
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // The next two children randomly mutate sign
        *child[6] = *mom;
        *child[7] = *dad;

        for(uint32 i = 6; i < 8; ++i)
        {
            uint32 index = rng_->get(0, n_poles_);

            float64 a_or_b = rng_->get(-1.0f, 1.0f);

            if(a_or_b > 0.0)
            {
                child[i]->setB(child[i]->getB(index) * -1.0, index);
            }
            else
            {
                child[i]->setA(child[i]->getA(index) * -1.0, index);
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // These two children randomly multiply one coef.
        *child[8] = *mom;
        *child[9] = *dad;

        for(uint32 i = 8; i < 10; ++i)
        {
            uint32 index = rng_->get(0, n_poles_);

            float64 a_or_b = rng_->get(-1.0f, 1.0f);

            float64 delta = rng_->get(-0.1f, 0.1f);

            if(a_or_b > 0.0)
            {
                child[i]->setB(child[i]->getB(index) * delta, index);
            }
            else
            {
                child[i]->setA(child[i]->getA(index) * delta, index);
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // These two children randomly swap mom & dad coeffs
        *child[10] = *mom;
        *child[11] = *dad;

        uint32 start_index = rng_->get(0, n_poles_);
        uint32 stop_index  = rng_->get(0, n_poles_);

        if(stop_index >= n_poles_) stop_index = n_poles_ - 1;

        if(start_index > stop_index)
        {
            uint32 temp = start_index;
            start_index = stop_index;
            stop_index = temp;
        }

        for(uint32 j = start_index; j < stop_index; ++j)
        {
            child[10]->setB(dad->getB(j), j);
            child[11]->setB(mom->getB(j), j);
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        start_index = rng_->get(0, n_poles_);
        stop_index  = rng_->get(0, n_poles_);

        if(stop_index >= n_poles_) stop_index = n_poles_ - 1;

        if(start_index > stop_index)
        {
            int32 temp = start_index;
            start_index = stop_index;
            stop_index = temp;
        }

        for(uint32 j = start_index; j < stop_index; ++j)
        {
            child[10]->setA(dad->getA(j), j);
            child[11]->setA(mom->getA(j), j);
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        // These two children randomly add mom & dad coeffs
        *child[12] = *mom;
        *child[13] = *dad;

        for(uint32 i = 12; i < 14; ++i)
        {
            for(uint32 j = 0; j < n_poles_; ++j)
            {
                child[i]->setB(child[i]->getB(j) + rng_->get(-0.1f, 0.1f), j);
                child[i]->setA(child[i]->getA(j) + rng_->get(-0.1f, 0.1f), j);
            }
        }

        // Score the kiddies.

        rms_error1 = getRMS(*mom, ref_response, type);
        rms_error2 = getRMS(*dad, ref_response, type);

        low1 = mom;
        low2 = dad;

        for(int32 i = 0; i < N_CHILDREN; ++i)
        {
            float64 rms = getRMS(*child[i], ref_response, type);

            if(rms > LARGE_RMS) continue;

            if(rms < rms_error1)
            {
                rms_error1 = rms;
                low1 = child[i];
            }
            else if(rms < rms_error2)
            {
                rms_error2 = rms;
                low2 = child[i];
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl << endl;
        #endif

        *mom = *low1;
        *dad = *low2;

        rms_error     = getRMS(*mom, ref_response, type);
        dad_rms_error = getRMS(*dad, ref_response, type);

        rms_history << rms_error;

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl;
        #endif

        // Check if dad is unstable.
        if(dad_rms_error > LARGE_RMS)
        {
            cout << PRINT_LINE << "dad's RMS > 10, ballistic!" << endl;
            dad->randomize(-0.01f, 0.01f);
        }

        // Check if our evolution is getting stale
        if(std::fabs(rms_error - last_rms_error) < STALE_RMS)
        {
            ++stale_count;
        }
        else
        {
            stale_count = 0;
        }

        last_rms_error = rms_error;

        if(count % 200 == 0)
        {
            cout << "Generation " << count << endl
                 << "    1st maximum RMS = " << rms_error     << endl
                 << "    2nd maximum RMS = " << dad_rms_error << endl;
//~                  << "    major_stale_count = " << major_stale_count << endl;
        }

        if(stale_count > 6)
        {
            for(uint32 i = 0; i < n_poles_; ++i)
            {
                dad->setB(dad->getB(i) + rng_->get(-0.10501f, 0.10501f), i);
                dad->setA(dad->getA(i) + rng_->get(-0.10501f, 0.10501f), i);
            }

            stale_count = 0;
            ++major_stale_count;

            if(major_stale_count > 1)
            {
                for(uint32 i = 0; i < n_poles_; ++i)
                {
                    dad->setB(dad->getB(i) * rng_->get(-0.501f, 0.501f), i);
                    dad->setA(dad->getA(i) * rng_->get(-0.501f, 0.501f), i);
                }

                major_stale_count = 0;
            }
        }

        #ifdef GA_DEBUG
            cout << __LINE__ << "\tmom.getSum() = " << mom->getSum()
                 << "\terror = " << error << endl;
        #endif

    }

    cout << "count = " << count << "  RMS = " << rms_error << endl;

    // copy mom into the filter.
    *kernel_ = *mom;

    for(int32 i = 0; i < N_CHILDREN; ++i)
    {
        delete child[i];
    }

    delete [] child;
    delete mom;
    delete dad;

    return rms_history;
}

float64 FilterIIR::getRMS ( const Kernel &  kernel, const Buffer &  response, const SignalType  type  )

protected

Definition at line 211 of file FilterIIR.cc.

References FREQUENCY_RESSPONSE, Nsound::Filter::getFrequencyResponse(), getImpulseResponse(), Nsound::Buffer::getLength(), Nsound::Buffer::getSum(), kernel_, and reset().

Referenced by designKernel().

{
    Kernel * orig_k = kernel_;

    kernel_ = const_cast<Kernel *>(&k);

    reset();

    Buffer r;

    if(type == FREQUENCY_RESSPONSE)
    {
        r = getFrequencyResponse(ref_response.getLength() * 2);
    }
    else
    {
        r = getImpulseResponse(ref_response.getLength() * 2);
    }

    kernel_ = orig_k;

    Buffer delta = ref_response - r;
    delta *= delta;

    float64 rms = delta.getSum() / static_cast<float64>(delta.getLength());

    rms = ::sqrt(rms);

    return rms;
}

void FilterIIR::savePlot ( const Kernel &  k, const Buffer &  response, uint32  n, const float64 &  error  )

protected

Definition at line 735 of file FilterIIR.cc.

References Nsound::Plotter::figure(), Nsound::Filter::getFrequencyAxis(), Nsound::Filter::getFrequencyResponse(), Nsound::Buffer::getLength(), Nsound::Buffer::getMax(), kernel_, Nsound::Plotter::plot(), reset(), Nsound::Plotter::text(), Nsound::Plotter::title(), Nsound::Plotter::xlabel(), Nsound::Plotter::xlim(), Nsound::Plotter::ylabel(), and Nsound::Plotter::ylim().

{
    Kernel * orig_k = kernel_;

    kernel_ = const_cast<Kernel *>(&k);

    Buffer fr_ref = fr_reference;
    Buffer fr = getFrequencyResponse();
    Buffer faxis = getFrequencyAxis();

    while(fr_ref.getLength() < fr.getLength())
    {
        fr_ref << 0.0;
    }

    float64 max = fr_ref.getMax();

    Plotter pylab;

    pylab.figure();
    pylab.plot(faxis, fr_ref);
    pylab.plot(faxis, fr);

    pylab.xlabel("Frequency Hz");
    pylab.ylabel("Frequency Response");

    char buffer[256];

    sprintf(buffer, "Generation %06d", n);

    pylab.title(std::string(buffer));

    pylab.xlim(0.0, faxis[fr_reference.getLength() - 1]);
    pylab.ylim(0.0, 1.1 * max);

    sprintf(buffer, "Error = %5.2f", error);

    pylab.text(
        faxis[static_cast<uint32>(faxis.getLength() * 0.66)],
        0.66,
        std::string(buffer));

    sprintf(buffer, "generation_%06d.png", n);

//~    pylab.savefig(std::string(buffer));

    kernel_ = orig_k;

    reset();
}

void Nsound::Filter::setRealtime ( bool  flag )

inlineinherited

Definition at line 57 of file Filter.h.

References Nsound::Filter::is_realtime_.

{is_realtime_ = flag;}

AudioStream Filter::filter ( const AudioStream &  x, const float64 &  frequency  )

inherited

Definition at line 76 of file Filter.cc.

References Nsound::Filter::filter(), Nsound::AudioStream::getNChannels(), Nsound::AudioStream::getSampleRate(), Nsound::Filter::is_realtime_, M_THROW, and Nsound::Filter::reset().

{
    if(!is_realtime_) reset();

    uint32 n_channels = x.getNChannels();

    if(is_realtime_ && n_channels > 1)
    {
        M_THROW("In real-time mode, a filter per audio channel must be used!");
    }

    AudioStream y(x.getSampleRate(), n_channels);

    for(uint32 channel = 0; channel < n_channels; ++channel)
    {
        y[channel] = filter(x[channel], frequency);
    }

    return y;
}

Buffer Filter::filter ( const Buffer &  x, const float64 &  frequency  )

inherited

Definition at line 140 of file Filter.cc.

References Nsound::Buffer::begin(), Nsound::Buffer::end(), Nsound::Filter::filter(), Nsound::Buffer::getLength(), Nsound::Filter::is_realtime_, and Nsound::Filter::reset().

{
    if(!is_realtime_) reset();

    Buffer::const_iterator itor = x.begin();
    Buffer::const_iterator end = x.end();

    Buffer y(x.getLength());

    while(itor != end)
    {
        y << filter(*itor, frequency);

        ++itor;
    }

    return y;
}

Buffer Filter::getFrequencyAxis ( const uint32  n_fft = 8192 )

inherited

Definition at line 185 of file Filter.cc.

References Nsound::FFTransform::roundUp2(), and Nsound::Filter::sample_rate_.

Referenced by main(), Nsound::Filter::plot(), and savePlot().

{
    uint32 fft_chunk_size = FFTransform::roundUp2(
        static_cast<int32>(n_fft));

    uint32 n_samples = fft_chunk_size / 2 + 1;

    float64 f_step = (1.0 / (static_cast<float64>(fft_chunk_size) / 2.0))
                   * (sample_rate_ / 2.0);

    Buffer f_axis;

    float64 f = 0.0;

    for(uint32 i = 0; i < n_samples; ++i)
    {
        f_axis << f;
        f += f_step;
    }

    return f_axis;
};

Buffer Filter::getFrequencyResponse ( const uint32  n_fft = 8192 )

inherited

Definition at line 210 of file Filter.cc.

References Nsound::FFTransform::fft(), Nsound::Filter::getImpulseResponse(), and Nsound::Filter::sample_rate_.

Referenced by Nsound::FilterBandPassIIR::FilterBandPassIIR(), FilterLeastSquaresFIR_UnitTest(), getRMS(), main(), Nsound::Filter::plot(), and savePlot().

{
    FFTransform fft(sample_rate_);

//~    fft.setWindow(HANNING);

    FFTChunkVector vec;

    vec = fft.fft(getImpulseResponse(), n_fft);

    return vec[0].getMagnitude();
}

Buffer Filter::getPhaseResponse ( )

inherited

Definition at line 245 of file Filter.cc.

References Nsound::FFTransform::fft(), Nsound::Filter::getImpulseResponse(), Nsound::Buffer::getLength(), Nsound::Filter::sample_rate_, and Nsound::Buffer::subbuffer().

Referenced by Nsound::Filter::plot().

{
    uint32 n_samples = static_cast<uint32>(sample_rate_ * 2);

    FFTransform fft(n_samples);

    FFTChunkVector vec;

    vec = fft.fft(getImpulseResponse(), n_samples);

    Buffer phase = vec[0].getPhase();

    return phase.subbuffer(0, phase.getLength() / 2 + 1);
}

float64 Nsound::Filter::getSampleRate ( ) const

inlineinherited

Definition at line 102 of file Filter.h.

References Nsound::Filter::sample_rate_.

{ return sample_rate_; };

void Filter::plot ( boolean  show_phase = false )

inherited

Definition at line 262 of file Filter.cc.

References Nsound::Plotter::figure(), Nsound::Buffer::getdB(), Nsound::Filter::getFrequencyAxis(), Nsound::Filter::getFrequencyResponse(), Nsound::Buffer::getMax(), Nsound::Filter::getPhaseResponse(), Nsound::Plotter::plot(), Nsound::Plotter::subplot(), Nsound::Plotter::xlabel(), Nsound::Plotter::ylabel(), and Nsound::Plotter::ylim().

Referenced by main(), Nsound::FilterLowPassMoogVcf::plot(), Nsound::FilterPhaser::plot(), Nsound::FilterTone::plot(), Nsound::FilterHighPassIIR::plot(), Nsound::FilterCombLowPassFeedback::plot(), Nsound::FilterLowPassIIR::plot(), Nsound::FilterLowPassFIR::plot(), Nsound::FilterHighPassFIR::plot(), Nsound::FilterAllPass::plot(), Nsound::FilterBandPassVocoder::plot(), Nsound::FilterBandPassFIR::plot(), Nsound::FilterLeastSquaresFIR::plot(), Nsound::FilterFlanger::plot(), Nsound::FilterBandRejectFIR::plot(), Nsound::FilterBandPassIIR::plot(), Nsound::FilterBandRejectIIR::plot(), and Nsound::FilterParametricEqualizer::plot().

{
    Buffer x = getFrequencyAxis();
    Buffer fr = getFrequencyResponse().getdB();

    Plotter pylab;

    pylab.figure();

    uint32 n_rows = 1;
    uint32 n_cols = 1;

    if(show_phase)
    {
        n_rows = 2;
    }

    pylab.subplot(n_rows, n_cols, 1);

    // Frequency response
    pylab.plot(x,fr, "blue");

    pylab.xlabel("Frequency (Hz)");
    pylab.ylabel("Frequency Response (dB)");

    // Phase response
    if(show_phase)
    {
        pylab.subplot(n_rows, n_cols, 2);

        Buffer pr = getPhaseResponse().getdB();

        pylab.plot(x,pr);

        pylab.xlabel("Frequency (Hz)");
        pylab.ylabel("Phase Response (dB)");
    }

    float64 ymax = fr.getMax();
    float64 height = ymax - -60.0;

    pylab.ylim(-60.0, ymax + 0.05 * height);
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  out, const FilterIIR &  rhs  )

friend

Prints the coeffents.

Member Data Documentation

uint32 Nsound::FilterIIR::n_poles_

protected

Definition at line 164 of file FilterIIR.h.

Referenced by designKernel(), filter(), FilterIIR(), getKernelSize(), operator=(), and reset().

Kernel* Nsound::FilterIIR::kernel_

protected

Definition at line 166 of file FilterIIR.h.

Referenced by designKernel(), filter(), FilterIIR(), getRMS(), Nsound::operator<<(), operator=(), savePlot(), and ~FilterIIR().

float64* Nsound::FilterIIR::x_history_

protected

Definition at line 168 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), operator=(), reset(), and ~FilterIIR().

float64* Nsound::FilterIIR::x_ptr_

protected

Definition at line 169 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), and reset().

float64* Nsound::FilterIIR::x_end_ptr_

protected

Definition at line 170 of file FilterIIR.h.

Referenced by filter(), and FilterIIR().

float64* Nsound::FilterIIR::y_history_

protected

Definition at line 172 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), operator=(), reset(), and ~FilterIIR().

float64* Nsound::FilterIIR::y_ptr_

protected

Definition at line 173 of file FilterIIR.h.

Referenced by filter(), FilterIIR(), and reset().

float64* Nsound::FilterIIR::y_end_ptr_

protected

Definition at line 174 of file FilterIIR.h.

Referenced by filter(), and FilterIIR().

RngTausworthe* Nsound::FilterIIR::rng_

protected

Definition at line 176 of file FilterIIR.h.

Referenced by designKernel(), FilterIIR(), operator=(), and ~FilterIIR().

float64 Nsound::Filter::sample_rate_

protectedinherited

Definition at line 113 of file Filter.h.

Referenced by Nsound::FilterPhaser::filter(), Nsound::FilterCombLowPassFeedback::filter(), Nsound::FilterDelay::filter(), Nsound::FilterAllPass::FilterAllPass(), Nsound::FilterCombLowPassFeedback::FilterCombLowPassFeedback(), Nsound::FilterDelay::FilterDelay(), Nsound::FilterFlanger::FilterFlanger(), Nsound::FilterPhaser::FilterPhaser(), Nsound::FilterSlinky::FilterSlinky(), Nsound::Filter::getFrequencyAxis(), Nsound::Filter::getFrequencyResponse(), Nsound::Filter::getPhaseResponse(), Nsound::Filter::getSampleRate(), Nsound::FilterStageIIR::makeIIRKernelHelper(), Nsound::FilterHighPassFIR::makeKernel(), Nsound::FilterStageIIR::makeKernel(), Nsound::FilterBandPassVocoder::makeKernel(), Nsound::FilterLeastSquaresFIR::makeKernel(), Nsound::FilterParametricEqualizer::makeKernel(), Nsound::FilterPhaser::operator=(), Nsound::FilterLeastSquaresFIR::operator=(), Nsound::FilterFlanger::operator=(), operator=(), Nsound::FilterLowPassMoogVcf::plot(), Nsound::FilterPhaser::plot(), Nsound::FilterTone::plot(), Nsound::FilterHighPassIIR::plot(), Nsound::FilterLowPassIIR::plot(), Nsound::FilterCombLowPassFeedback::plot(), Nsound::FilterLowPassFIR::plot(), Nsound::FilterHighPassFIR::plot(), Nsound::FilterAllPass::plot(), Nsound::FilterBandPassFIR::plot(), Nsound::FilterLeastSquaresFIR::plot(), Nsound::FilterFlanger::plot(), Nsound::FilterBandRejectFIR::plot(), Nsound::FilterBandRejectIIR::plot(), Nsound::FilterBandPassIIR::plot(), Nsound::FilterParametricEqualizer::plot(), Nsound::FilterLowPassIIR::setCutoff(), and Nsound::FilterLeastSquaresFIR::setWindow().

float64 Nsound::Filter::two_pi_over_sample_rate_

protectedinherited

Definition at line 114 of file Filter.h.

Referenced by Nsound::FilterTone::makeKernel(), Nsound::FilterLowPassFIR::makeKernel(), and Nsound::FilterParametricEqualizer::makeKernel().

float64 Nsound::Filter::sample_time_

protectedinherited

Definition at line 115 of file Filter.h.

Referenced by Nsound::FilterLowPassMoogVcf::_make_filter().

uint32 Nsound::Filter::kernel_size_

protectedinherited

Definition at line 116 of file Filter.h.

Referenced by Nsound::FilterLowPassFIR::filter(), Nsound::FilterLeastSquaresFIR::filter(), Nsound::FilterBandPassFIR::FilterBandPassFIR(), Nsound::FilterBandPassIIR::FilterBandPassIIR(), Nsound::FilterBandRejectIIR::FilterBandRejectIIR(), Nsound::FilterHighPassIIR::FilterHighPassIIR(), Nsound::FilterLeastSquaresFIR::FilterLeastSquaresFIR(), Nsound::FilterLowPassFIR::FilterLowPassFIR(), Nsound::FilterLowPassIIR::FilterLowPassIIR(), Nsound::FilterLeastSquaresFIR::getKernel(), Nsound::Filter::getKernelSize(), Nsound::FilterHighPassFIR::makeKernel(), Nsound::FilterLowPassFIR::makeKernel(), Nsound::FilterBandRejectFIR::makeKernel(), Nsound::FilterLeastSquaresFIR::makeKernel(), Nsound::FilterLeastSquaresFIR::operator=(), Nsound::FilterLowPassFIR::plot(), Nsound::FilterHighPassFIR::plot(), Nsound::FilterLeastSquaresFIR::plot(), Nsound::FilterBandRejectFIR::plot(), Nsound::FilterLowPassFIR::reset(), Nsound::FilterHighPassFIR::reset(), Nsound::FilterLeastSquaresFIR::reset(), Nsound::FilterLeastSquaresFIR::setKernel(), Nsound::FilterLeastSquaresFIR::setWindow(), and Nsound::FilterHighPassFIR::spectraReversal_().

bool Nsound::Filter::is_realtime_

protectedinherited

Definition at line 118 of file Filter.h.

Referenced by Nsound::Filter::filter(), Nsound::FilterBandRejectIIR::filter(), Nsound::FilterBandRejectFIR::filter(), Nsound::Filter::getImpulseResponse(), and Nsound::Filter::setRealtime().

---

The documentation for this class was generated from the following files:

• Nsound/FilterIIR.h
• Nsound/FilterIIR.cc