#include <Nsound/Vocoder.h>

Public Member Functions
	Vocoder (const float64 &sample_rate, const float64 &window_length, const uint32 &n_bands, const float64 &freq_max=4000.0, const bool use_mel_scale=true, const bool plot_filter_bank=false)
	Default Constructor. More...

virtual	~Vocoder ()

Buffer	filter (const Buffer &voice, const Buffer &carrier)

float64	filter (const float64 &voice, const float64 &carrier)

float64	getSampleRate () const

void	reset ()

Protected Types
typedef std::vector< Filter * >	FilterVector

Protected Attributes
float64	sample_rate_

uint32	window_size_

uint32	n_bands_

float64	freq_max_

FilterVector	filters_input_

FilterVector	filters_output_

FilterVector	moving_average_

Detailed Description

Definition at line 44 of file Vocoder.h.

Member Typedef Documentation

typedef std::vector< Filter * > Nsound::Vocoder::FilterVector

protected

Definition at line 84 of file Vocoder.h.

Constructor & Destructor Documentation

Vocoder::Vocoder	(	const float64 &	sample_rate,
		const float64 &	window_length,
		const uint32 &	n_bands,
		const float64 &	freq_max = `4000.0`,
		const bool	use_mel_scale = `true`,
		const bool	plot_filter_bank = `false`
	)

Default Constructor.

sample_rate: the sample rate window_length: the length of a window to average for the voice envelope n_bands: the number of band pass filters to use freq_max: the maximum frequency, band pass filters divide up the frequency range from 0 to freq_max

Definition at line 69 of file Vocoder.cc.

References f_to_mel(), Nsound::Plotter::figure(), filters_input_, filters_output_, freq_max_, Nsound::Buffer::getLength(), Nsound::Plotter::grid(), Nsound::Plotter::hold(), M_ASSERT_VALUE, M_CHECK_PTR, mel_to_f(), moving_average_, n_bands_, Nsound::Plotter::plot(), sample_rate_, window_size_, Nsound::Plotter::xlabel(), Nsound::Plotter::xlim(), Nsound::Plotter::ylabel(), and Nsound::Plotter::ylim().

     :
     sample_rate_(sample_rate),
     window_size_(static_cast<uint32>(window_length * sample_rate_)),
     n_bands_(n_bands),
     freq_max_(freq_max),
     filters_input_(),
     filters_output_(),
     moving_average_()
 {
     M_ASSERT_VALUE(sample_rate_, >, 0.0);
 
     uint32 min_window_size = static_cast<uint32>(sample_rate_ * 0.005);
 
     M_ASSERT_VALUE(window_size_, >=, min_window_size);
 
     uint32 min_n_bands = 4;
 
     M_ASSERT_VALUE(n_bands_, >=, min_n_bands);
 
     float64 min_freq_max = 0.05 * sample_rate_;
 
     M_ASSERT_VALUE(freq_max_, >=, min_freq_max);
 
     float64 hi = freq_max_;
 
     // convert to mel scale
 
     if(use_mel_scale)
     {
         hi = f_to_mel(hi);
     }
 
     // linear space from lo to hi.
 
     float64 band_width = hi / static_cast<float64>(n_bands_);
 
     Buffer freq_centers(n_bands_);
 
     for(uint32 i = 0; i <= n_bands_; ++i)
     {
         freq_centers << (i + 1) * band_width;
     }
 
     // Shift to the center of each window.
     freq_centers -= band_width / 2.0;
 
     // convert back to Hz scale.
     if(use_mel_scale)
     {
         for(uint32 i = 0; i < freq_centers.getLength(); ++i)
         {
             freq_centers[i] = mel_to_f(freq_centers[i]);
         }
     }
 
     uint32 start = 0;
     uint32 order = 6;
     float64 ripple = 0.01;
 
     for(uint32 i = start; i < n_bands_; ++i)
     {
         float64 freq = freq_centers[i];
 
         // Cut offs are halfway between the filters.
 
         float64 f_lo = 0.0;
 
         if(i > 0)
         {
             f_lo = (freq + freq_centers[i - 1]) / 2.0;
         }
 
         float64 f_hi = freq_max_;
 
         if(i + 1 < n_bands_)
         {
             f_hi = (freq + freq_centers[i + 1]) / 2.0;
         }
 
         FilterBandPassIIR * bp = new FilterBandPassIIR(
             sample_rate_,
             order,
             f_lo,
             f_hi,
             ripple);
 
         M_CHECK_PTR(bp);
 
         filters_input_.push_back(bp);
 
         bp = new FilterBandPassIIR(
             sample_rate_,
             order,
             f_lo,
             f_hi,
             ripple);
 
         M_CHECK_PTR(bp);
 
         filters_output_.push_back(bp);
 
         FilterMovingAverage * ma = new FilterMovingAverage(window_size_);
 
         M_CHECK_PTR(ma);
 
         moving_average_.push_back(ma);
     }
 
     if(plot_filter_bank)
     {
         Plotter pylab;
 
         pylab.figure();
         pylab.hold(true);
 
         for(size_t i = 0; i < filters_input_.size(); ++i)
         {
             Buffer x = filters_input_[i]->getFrequencyAxis();
             Buffer y = filters_input_[i]->getFrequencyResponse().getdB();
 
             pylab.plot(x, y);
         }
 
         pylab.xlim(0.0, freq_max_);
         pylab.ylim(-40.0, 10.0);
         pylab.xlabel("Frequency (Hz)");
         pylab.ylabel("Filter Frequency Response (dB)");
         pylab.grid(true);
 
 //~        pylab.show();
     }
 
 }

Vocoder::~Vocoder ( )

virtual

Definition at line 212 of file Vocoder.cc.

References filters_input_, filters_output_, and moving_average_.

 {
     FilterVector::iterator fi = filters_input_.begin();
     FilterVector::iterator fo = filters_output_.begin();
     FilterVector::iterator ma = moving_average_.begin();
 
     FilterVector::iterator end = filters_input_.end();
 
     while(fi != end)
     {
         delete *fi;
         delete *fo;
         delete *ma;
 
         ++fi;
         ++fo;
         ++ma;
     }
 }

Member Function Documentation

Buffer Vocoder::filter	(	const Buffer &	voice,
		const Buffer &	carrier
	)

Definition at line 234 of file Vocoder.cc.

References Nsound::Buffer::cbegin(), and Nsound::Buffer::getLength().

Referenced by main(), and my_main().

 {
     Buffer y;
 
     Buffer::const_circular_iterator v = voice.cbegin();
 
     uint32 n_samples = x.getLength();
 
     for(uint32 n = 0; n < n_samples; ++n, ++v)
     {
         y << Vocoder::filter(*v, x[n]);
     }
 
     return y;
 }

float64 Vocoder::filter	(	const float64 &	voice,
		const float64 &	carrier
	)

Definition at line 252 of file Vocoder.cc.

References filters_input_, filters_output_, and moving_average_.

 {
     FilterVector::iterator fi = filters_input_.begin();
     FilterVector::iterator fo = filters_output_.begin();
     FilterVector::iterator ma = moving_average_.begin();
 
     FilterVector::iterator end = filters_input_.end();
 
     float64 y = 0.0;
 
     while(fi != end)
     {
         // Filter the voice to use as an envelope..
         float64 envelope = (*fi)->filter(voice);
 
         // Use the abs of the envelope.
         envelope = std::fabs(envelope);
 
         // Smooth the filtered envelope.
         envelope = (*ma)->filter(envelope);
 
         // Shape the filtered input signal.
         y += envelope * (*fo)->filter(x);
 
         ++fi;
         ++fo;
         ++ma;
     }
 
     return y;
 }

float64 Nsound::Vocoder::getSampleRate ( ) const

inline

Definition at line 72 of file Vocoder.h.

References sample_rate_.

72 { return sample_rate_; };

Nsound::Vocoder::sample_rate_

float64 sample_rate_

Definition: Vocoder.h:79

void Vocoder::reset ( )

Definition at line 286 of file Vocoder.cc.

References filters_input_, filters_output_, and moving_average_.

Referenced by main().

 {
     FilterVector::iterator fi = filters_input_.begin();
     FilterVector::iterator fo = filters_output_.begin();
     FilterVector::iterator ma = moving_average_.begin();
 
     FilterVector::iterator end = filters_input_.end();
 
     while(fi != end)
     {
         (*fi)->reset();
         (*fo)->reset();
         (*ma)->reset();
 
         ++fi;
         ++fo;
         ++ma;
     }
 }