Nsound::Buffer Class Reference

#include <Nsound/Buffer.h>

List of all members.

Classes
class	circular_iterator
Public Types
typedef FloatVector::iterator	iterator
typedef FloatVector::const_iterator	const_iterator
Public Member Functions
	Buffer ()
	Buffer (uint32 chunk_size)
	Buffer (const FloatVector &list)
	Buffer (const std::string &filename, uint32 chunk_size=4096)
	~Buffer ()
	Buffer (const Buffer &rhs)
void	abs ()
Buffer	getAbs () const
void	add (const Buffer &buffer, uint32 offset=0, uint32 n_samples=0)
	This method adds buffer to *this.
uint32	argmax () const
uint32	argmin () const
iterator	begin ()
const_iterator	begin () const
circular_iterator	cbegin ()
circular_iterator	cbegin () const
iterator	end ()
const_iterator	end () const
uint32	getNBytes () const
void	exp ()
Buffer	getExp () const
void	convolve (const Buffer &H)
Buffer	getConvolve (const Buffer &H) const
void	dB ()
Buffer	getdB () const
void	derivative (uint32 n)
Buffer	getDerivative (uint32 n) const
void	downSample (uint32 n)
Buffer	getDownSample (uint32 n) const
Uint32Vector	findPeaks (uint32 window_size=0, const float64 &min_height=0.0) const
uint32	getLength () const
void	limit (const float64 &min, const float64 &max)
void	limit (const Buffer &min, const Buffer &max)
Buffer	getLimit (const float64 &min, const float64 &max) const
Buffer	getLimit (const Buffer &min, const Buffer &max) const
void	log ()
Buffer	getLog () const
void	log10 ()
Buffer	getLog10 () const
float64	getMax () const
float64	getMaxMagnitude () const
float64	getMean () const
float64	getMin () const
void	normalize ()
Buffer	getNormalize () const
Buffer	getSignalEnergy (uint32 window_size) const
float64	getStd () const
float64	getSum () const
void	zNorm ()
Buffer	getZNorm () const
BufferSelection	operator() (const BooleanVector &bv)
Buffer &	operator= (const Buffer &rhs)
boolean	operator== (const Buffer &rhs) const
boolean	operator!= (const Buffer &rhs) const
const float64	operator[] (uint32 index) const
float64 &	operator[] (uint32 index)
Buffer &	operator<< (const AudioStream &rhs)
Buffer &	operator<< (const Buffer &rhs)
Buffer &	operator<<= (const Buffer &rhs)
Buffer &	operator<< (const float64 &d)
Buffer &	operator<<= (const float64 &d)
Buffer &	operator+= (const Buffer &rhs)
Buffer &	operator-= (const Buffer &rhs)
Buffer &	operator*= (const Buffer &rhs)
Buffer &	operator/= (const Buffer &rhs)
Buffer &	operator^= (const Buffer &powers)
Buffer &	operator+= (const float64 &d)
Buffer &	operator-= (const float64 &d)
Buffer &	operator*= (const float64 &d)
Buffer &	operator/= (const float64 &d)
Buffer &	operator^= (const float64 &power)
BooleanVector	operator> (const float64 &rhs)
BooleanVector	operator>= (const float64 &rhs)
BooleanVector	operator< (const float64 &rhs)
BooleanVector	operator<= (const float64 &rhs)
BooleanVector	operator== (const float64 &rhs)
BooleanVector	operator!= (const float64 &rhs)
void	plot (const std::string &title="Buffer") const
const float64 *	getPointer () const
float64 *	getPointer ()
void	preallocate (uint32 n)
void	readWavefile (const char *filename)
void	resample (const float64 &factor)
void	resample (const Buffer &factor)
Buffer	getResample (const float64 &factor, const uint32 N=10, const float64 &beta=5.0) const
Buffer	getResample (const Buffer &factor, const uint32 N=10, const float64 &beta=5.0) const
Buffer	getResample (const uint32 L, const uint32 M, const uint32 N=10, const float64 &beta=5.0) const
void	reverse ()
Buffer	getReverse () const
void	round ()
Buffer	getRound () const
BufferSelection	select (const uint32 start_index, const uint32 stop_index)
void	smooth (uint32 n_passes, uint32 n_samples_per_average)
Buffer	getSmooth (uint32 n_passes, uint32 n_samples_per_average) const
void	speedUp (const float64 &step_size)
Buffer	getSpeedUp (const float64 &step_size) const
void	speedUp (const Buffer &step_size)
Buffer	getSpeedUp (const Buffer &step_size) const
void	sqrt ()
Buffer	getSqrt () const
Buffer	subbuffer (uint32 start_index, uint32 n_samples=0) const
void	upSample (uint32 n)
Buffer	getUpSample (uint32 n) const
void	writeWavefile (const char *filename) const
float64	get_at_index (int32 index) const
	SWIG helper function for operator[].
void	set_at_index (int32 index, const float64 &d)
	SWIG helper function for operator[].
void	swig_hook ()
	SWIG helper function function to shadow.
Static Public Member Functions
static Buffer	ones (const uint32 n_samples)
	Returns a Buffer full of ones of length n_samples.
static Buffer	rand (const uint32 n_samples)
	Returns a Buffer full of random values of length n_samples.
static Buffer	zeros (const uint32 n_samples)
	Returns a Buffer full of zeros of length n_samples.
Protected Types
enum	MathOperator {   ADD, SUBTRACT, MULTIPLY, DIVIDE,   POW }
Protected Member Functions
Buffer	getResample_ (const uint32 L, const uint32 M, const uint32 N, const float64 &beta) const
Buffer &	vectorOperator (const Buffer &rhs, MathOperator op)
Buffer &	scalarOperator (const float64 &d, MathOperator op)
Protected Attributes
FloatVector	data_
Static Protected Attributes
static const uint32	bytes_per_sample_ = sizeof(float64)
Friends
std::ostream &	operator<< (std::ostream &out, const Buffer &rhs)

---

Detailed Description

A Buffer for storing audio samples. This is the workhourse of Nsound. This class dynamically allocates memory and frees the user of the class from worrying about buffer sizes. This class does not have a sample rate, samples are indexed by an integer index.

Definition at line 61 of file Buffer.h.

---

Member Typedef Documentation

typedef FloatVector::iterator Nsound::Buffer::iterator

Definition at line 66 of file Buffer.h.

typedef FloatVector::const_iterator Nsound::Buffer::const_iterator

Definition at line 69 of file Buffer.h.

---

Member Enumeration Documentation

enum Nsound::Buffer::MathOperator [protected]

Enumerator:

ADD
SUBTRACT
MULTIPLY
DIVIDE
POW

Definition at line 2001 of file Buffer.h.

    {
            ADD,
            SUBTRACT,
            MULTIPLY,
            DIVIDE,
            POW
    };

---

Constructor & Destructor Documentation

Buffer::Buffer

(

)

Creates an empty Buffer that also calss std::vector::reserve() to preallocate memory for samples.

Parameters:

chunk_size

the number of samples to preallocate.

Returns:

void

Example:

 // C++
 Buffer b(1024);

 // Python
 b = Buffer(1024)

Definition at line 59 of file Buffer.cc.

References data_.

Referenced by operator<<().

00061     :
00062     data_()
00063 {
00064     data_.reserve(4096);
}

Buffer::Buffer

(

uint32

chunk_size

)

[explicit]

Definition at line 68 of file Buffer.cc.

References data_.

00070     :
00071     data_()
00072 {
00073     data_.reserve(chunk_size);
}

Buffer::Buffer

(

const FloatVector &

list

)

[explicit]

Creates a Buffer and fills it with the contents of list.

Parameters:

list

a FloatVector holding samples

Returns:

Buffer

Example:

 // C++
 FloatVector fv;
 fv.push_back(1.0);
 fv.push_back(2.0);
 fv.push_back(3.0);
 fv.push_back(4.0);
 fv.push_back(5.0);
 Buffer b(fv);

 // Python
 b = Buffer([1,2,3,4,5])

Definition at line 77 of file Buffer.cc.

00079     :
00080     data_(list) // Copies contents
00081 {
}

Buffer::Buffer	(	const std::string &	filename,
		uint32	chunk_size = 4096
	)

Creates an Buffer from a Wavefile, also specifies the chunk size.

Parameters:

	filename	a string with a wave filename to read.
	chunk_size	optional, sets the chunk size for the Buffer.

Example:

 // C++
 Buffer b("california.wav");

 // Python
 b = Buffer("california.wav")

Definition at line 85 of file Buffer.cc.

References data_.

00087     :
00088     data_()
00089 {
00090     data_.reserve(chunk_size);
00091 
00092     // This function is defined in Wavefile.h.
00093     *this << filename.c_str();
}

Buffer::~Buffer

(

)

Destroys the Buffer.

Definition at line 104 of file Buffer.cc.

{
}

Buffer::Buffer

(

const Buffer &

rhs

)

Copy constructor, must be used in Python to copy Buffers.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2(b1);

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer(b1)                 // Copies memory, Python does not have
                                 // an operator=

Definition at line 97 of file Buffer.cc.

00099     :
00100     data_(rhs.data_)
00101 {
}

---

Member Function Documentation

void Buffer::abs

(

)

Modifies the Buffer by making any negative value positive.

Example:

 // C++
 Buffer b1("california.wav");
 b1.abs();

 // Python
 b1 = Buffer("california.wav")
 b1.abs()

Definition at line 112 of file Buffer.cc.

References data_.

Referenced by Nsound::AudioStream::abs(), Buffer_UnitTest(), DelayLine_UnitTest(), FFTransform_UnitTest(), FilterCombLowPassFeedback_UnitTest(), FilterLeastSquaresFIR_UnitTest(), FilterParametricEqualizer_UnitTest(), Generator_UnitTest(), getAbs(), main(), Sine_UnitTest(), and Triangle_UnitTest().

{
    for(uint32 i = 0; i < data_.size(); ++i)
    {
        data_[i] = ::fabs(data_[i]);
    }
}

Buffer Nsound::Buffer::getAbs

(

)

const [inline]

Modifies a copy of the Buffer by making any negative value positive.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getAbs();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getAbs();

Definition at line 176 of file Buffer.h.

References abs().

Referenced by Buffer_UnitTest(), BufferResample_UnitTest(), FFTransform_UnitTest(), FilterBandPassFIR_UnitTest(), FilterBandPassIIR_UnitTest(), FilterBandRejectFIR_UnitTest(), FilterBandRejectIIR_UnitTest(), FilterHighPassFIR_UnitTest(), FilterHighPassIIR_UnitTest(), FilterLeastSquaresFIR_UnitTest(), FilterLowPassFIR_UnitTest(), FilterLowPassIIR_UnitTest(), and main().

    { Buffer temp(*this); temp.abs(); return temp; };

void Buffer::add	(	const Buffer &	buffer,
		uint32	offset = 0,
		uint32	n_samples = 0
	)

This method adds buffer to *this.

If the length of 'buffer' is longer than *this, *this will be extended. If n_samples is 0, the whole length of buffer will get added, otherwise, only n_samples will get added.

For example:

        a = sample in *this
        b = sample in buffer
        c = a + b

        this = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa]
             + |--offset--|[bbbbbbbbb buffer bbbbbbbbbbbbbbbbbb]

             = [aaaaaaaaaaacccccccccccccccccbbbbbbbbbbbbbbbbbbb]
        

Another exampple:

        a = sample in *this
        b = sample in buffer
        c = a + b

        this = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa]
             + |--offset--|[bbbbbbbbb buffer bbbbbbbbbbbbbbbbbb]
                           |--------n_samples------|

             = [aaaaaaaaaaaccccccccccccccccccbbbbbbb]

Parameters:

	offset	- The index into this Buffer to start adding
	buffer	- The Buffer to add data from
	n_samples	- The number of samples from buffer to add

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 Buffer b1.add(0,b2);

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b1.add(0,b2);

Definition at line 220 of file Buffer.cc.

References data_, and getLength().

Referenced by Nsound::AudioStream::add(), Nsound::Granulator::generate(), main(), Nsound::Stretcher::overlapAdd(), and testBufferAdd().

{
    uint32 a_length = getLength();
    uint32 b_length = b.getLength();

    //  Case 1: n_samples == 0
    //          && a_length < offset
    //
    //           [aaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //  result = |aaaaaaaa---bbbbbbbbbbbbbbbbbbbbbbb|
    if(n_samples == 0 && a_length < offset)
    {
        // Append zeros
        for(uint32 i = a_length; i < offset; ++i)
        {
            *this << 0.0;
        }

        // Append b
        *this << b;
    }

    //  Case 2: n_samples != 0
    //          && a_length < offset
    //          && n_samples <= b_length
    //
    //           [aaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //                       |---n_samples---|
    //  result = |aaaaaaaa---bbbbbbbbbbbbbbbb|
    else if(n_samples != 0
            && a_length < offset
            && n_samples <= b_length)
    {
        // Append zeros
        for(uint32 i = a_length; i < offset; ++i)
        {
            *this << 0.0;
        }

        for(uint32 i = 0; i < n_samples; ++i)
        {
            *this << b[i];
        }
    }

    //  Case 3: n_samples != 0
    //          && a_length < offset
    //          && n_samples > b_length
    //
    //           [aaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //                       |---n_samples----------------|
    //  result = |aaaaaaaa---bbbbbbbbbbbbbbbbbbbbbbbb-----|
    else if(n_samples != 0
        && a_length < offset
        && n_samples > b_length)
    {
        // Append zeros
        for(uint32 i = a_length; i < offset; ++i)
        {
            *this << 0.0;
        }

        // Append b samples

        *this << b;

        // Append zeros

        for(uint32 i = b_length; i < n_samples; ++i)
        {
            *this << 0.0;
        }
    }

    //  Case 4: n_samples == 0
    //          && a_length >= offset
    //          && a_length < offset + b_length
    //
    //           [aaaaaaaaaaaaaaaaaaaaaaaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //  result = |aaaaaaaaaaaccccccccccccccccccbbbbb|
    else if(n_samples == 0
        && a_length >= offset
        && a_length < offset + b_length)
    {
        uint32 b_index = 0;
        for(uint32 i = offset; i < a_length; ++i)
        {
            data_[i] += b[b_index++];
        }

        for(uint32 i = b_index; i < b_length; ++i)
        {
            *this << b[i];
        }
    }

    //  Case 5: n_samples != 0
    //          && a_length >= offset
    //          && n_samples <= b_length
    //          && a_length <= offset + n_samples
    //
    //           [aaaaaaaaaaaaaaaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //                      |----n_samples----|
    //  result = |aaaaaaaaaacccccccccccbbbbbbb|
    else if(n_samples != 0
        && a_length >= offset
        && a_length <= offset + n_samples
        && n_samples <= b_length)
    {
        uint32 b_index = 0;
        for(uint32 i = offset; i < a_length; ++i)
        {
            data_[i] += b[b_index++];
        }

        for(uint32 i = b_index; i < n_samples; ++i)
        {
            *this << b[i];
        }
    }
    //  Case 6: n_samples != 0
    //          && a_length >= offset
    //          && n_samples < b_length
    //          && a_length > offset + n_samples
    //
    //           [aaaaaaaaaaaaaaaaaaaaaaaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //                      |--n_samples--|
    //  result = |aaaaaaaaaacccccccccccccccaaa|
    else if(n_samples != 0
        && a_length >= offset
        && a_length > offset + n_samples
        && n_samples < b_length)
    {
        uint32 b_index = 0;
        for(uint32 i = offset; i < offset + n_samples; ++i)
        {
            data_[i] += b[b_index++];
        }
    }

    //  Case 7:    a_length >= offset
    //          && n_samples > b_length
    //          && a_length <= offset + b_length
    //
    //           [aaaaaaaaaaaaaaaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //                      |----n_samples---------------|
    //  result = |aaaaaaaaaaaccccccccccbbbbbbbbbbbbbb----|
    else if(a_length >= offset
        &&  a_length <= offset + b_length
        &&  n_samples > b_length)
    {
        uint32 b_index = 0;
        for(uint32 i = offset; i < a_length; ++i)
        {
            data_[i] += b[b_index++];
        }

        for(uint32 i = b_index; i < b_length; ++i)
        {
            *this << b[i];
        }

        for(uint32 i = b_length; i < n_samples; ++i)
        {
            *this << 0.0;
        }
    }
    //  Case 8: n_samples == 0
    //          && a_length >= offset + b_length
    //
    //           [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbbb]
    //  result = |aaaaaaaaaaaccccccccccccccccccccccccaaaaaa|
    else if(n_samples == 0
        && a_length >= offset + b_length)
    {
        uint32 b_index = 0;
        for(uint32 i = offset; i < offset + b_length; ++i)
        {
            data_[i] += b[b_index++];
        }
    }

    //  Case 9:     a_length >= offset + n_samples
    //           && n_samples >= b_length
    //
    //  result = [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbb]
    //                      |----n_samples------------|
    //         = |aaaaaaaaaaaacccccccccccccccccccccaaaaaaaa|
    else if( a_length >= offset + n_samples
        &&   n_samples >= b_length)
    {
        uint32 b_index = 0;
        for(uint32 i = offset; i < offset + b_length; ++i)
        {
            data_[i] += b[b_index++];
        }
    }
    //  Case 10: n_samples != 0
    //           && a_length > offset + b_length
    //           && a_length < offset + n_samples
    //
    //  result = [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]
    //         + |--offset--|[bbbbbbbbbbbbbbbbbbbbb]
    //                      |----n_samples----------------------|
    //         = |aaaaaaaaaaaccccccccccccccccccccccaaaaaaa------|
    else if(n_samples != 0
        && a_length > offset + b_length
        && a_length < offset + n_samples)
    {
        uint32 b_index = 0;
        for(uint32 i = offset; i < offset + b_length; ++i)
        {
            data_[i] += b[b_index++];
        }

        for(uint32 i = a_length; i < offset + n_samples; ++i)
        {
            *this << 0.0;
        }
    }
}

uint32 Buffer::argmax

(

)

const

Retruns the index of the maximum value in the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 uint32 max_index = b1.argmax();

 // Python
 b1 = Buffer("california.wav")
 max_index = b1.argmax()

Definition at line 476 of file Buffer.cc.

References begin(), and end().

Referenced by main().

{
    uint32 index = 0;

    Buffer::const_iterator itor = begin();
    Buffer::const_iterator tend = end();

    float64 max = *itor;

    uint32 i = 0;
    while(itor != tend)
    {
        if(*itor > max)
        {
            max = *itor;
            index = i;
        }
        ++i;
        ++itor;
    }
    return index;
}

uint32 Buffer::argmin

(

)

const

Retruns the index of the minimum value in the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 uint32 min_index = b1.argmin();

 // Python
 b1 = Buffer("california.wav")
 min_index = b1.argmin()

Definition at line 502 of file Buffer.cc.

References begin(), and end().

{
    uint32 index = 0;

    Buffer::const_iterator itor = begin();
    Buffer::const_iterator tend = end();

    float64 min = *itor;

    uint32 i = 0;
    while(itor != tend)
    {
        if(*itor < min)
        {
            min = *itor;
            index = i;
        }
        ++i;
        ++itor;
    }
    return index;
}

iterator Nsound::Buffer::begin

(

)

[inline]

Retruns the itreator at the start of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer::iterator itor = b1.begin();

 // Python, you can already iterate over the samples
 b1 = Buffer("california.wav");
 for sample in b1:
     // do something

Definition at line 291 of file Buffer.h.

References data_.

Referenced by argmax(), argmin(), Nsound::FilterStageIIR::filter(), Nsound::FilterLowPassFIR::filter(), Nsound::FilterHighPassFIR::filter(), Nsound::FilterBandRejectFIR::filter(), Nsound::Filter::filter(), getResample_(), Nsound::FFTransform::ifft(), limit(), operator!=(), Nsound::BufferSelection::operator*=(), Nsound::BufferSelection::operator+=(), Nsound::BufferSelection::operator-=(), Nsound::BufferSelection::operator/=(), operator<(), operator<=(), Nsound::BufferSelection::operator=(), operator==(), operator>(), operator>=(), round(), smooth(), sqrt(), and vectorOperator().

    { return data_.begin(); };

const_iterator Nsound::Buffer::begin

(

)

const [inline]

Retruns the itreator at the start of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer::cons_iterator itor = b1.begin();

 // Python, you can iterate over the samples
 b1 = Buffer("california.wav");
 for sample in b1:
     // do something

Definition at line 310 of file Buffer.h.

References data_.

    { return data_.begin(); };

circular_iterator Nsound::Buffer::cbegin

(

)

[inline]

Retruns the itreator at the start of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer::circular_iterator ctor = b1.begin();

 // Python, currently not supported

Definition at line 326 of file Buffer.h.

References data_.

Referenced by Nsound::Stretcher::analyize(), Buffer_UnitTest(), Nsound::Generator::buzz(), Nsound::Generator::drawSine(), Nsound::Generator::drawSine2(), Nsound::Vocoder::filter(), Nsound::FilterFlanger::filter(), Nsound::FilterBandPassVocoder::filter(), Nsound::Filter::filter(), Nsound::Generator::generate(), Nsound::Generator::generate2(), limit(), and Nsound::GuitarBass::play().

    { return circular_iterator(data_.begin(), data_.end()); };

circular_iterator Nsound::Buffer::cbegin

(

)

const [inline]

Retruns the itreator at the start of the Buffer.

Example:

 // C++
 const Buffer b1("california.wav");
 Buffer::circular_iterator ctor = b1.begin();

 // Python, currently not supported

Definition at line 342 of file Buffer.h.

References data_.

    { return circular_iterator(data_.begin(), data_.end()); };

iterator Nsound::Buffer::end

(

)

[inline]

Retruns the itreator at the end of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer::iterator end = b1.end();

 // Python, currently not supported

Definition at line 358 of file Buffer.h.

References data_.

Referenced by argmax(), argmin(), Nsound::FilterStageIIR::filter(), Nsound::FilterLowPassFIR::filter(), Nsound::FilterHighPassFIR::filter(), Nsound::FilterBandRejectFIR::filter(), Nsound::Filter::filter(), getResample_(), limit(), operator!=(), Nsound::BufferSelection::operator*=(), Nsound::BufferSelection::operator+=(), Nsound::BufferSelection::operator-=(), Nsound::BufferSelection::operator/=(), operator<(), operator<<(), operator<=(), Nsound::BufferSelection::operator=(), operator==(), operator>(), operator>=(), round(), scalarOperator(), smooth(), sqrt(), and vectorOperator().

    { return data_.end(); };

const_iterator Nsound::Buffer::end

(

)

const [inline]

Retruns the itreator at the end of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer::iterator end = b1.end();

 // Python, currently not supported

Definition at line 374 of file Buffer.h.

References data_.

    { return data_.end(); };

uint32 Nsound::Buffer::getNBytes

(

)

const [inline]

Retruns the number of bytes held in the Buffer array.

Example:

 // C++
 Buffer b1("california.wav");
 uint32 n_bytes = b1.getNBytes();

 // Python
 b1 = Buffer("california.wav")
 n_bytes = b1.getNBytes()

Definition at line 392 of file Buffer.h.

References bytes_per_sample_, and data_.

    { return bytes_per_sample_ * data_.size(); };

void Buffer::exp

(

)

Each sample in the Buffer becomes the power e^x. Each sample in the Buffer becomes the power e^x, where x is the Buffer sample.

Example:

 // C++
 Buffer b1("california.wav");
 b1.exp();

 // Python
 b1 = Buffer("california.wav")
 b1.exp()

Definition at line 528 of file Buffer.cc.

References data_, and getLength().

Referenced by Nsound::Generator::drawDecay(), Nsound::Generator::drawGaussian(), and getExp().

{
    for(uint32 i = 0; i < getLength(); ++i)
    {
        data_[i] = ::exp(data_[i]);
    }
}

Buffer Nsound::Buffer::getExp

(

)

const [inline]

Each sample in the Buffer becomes the power e^x. Each sample in the Buffer becomes the power e^x, where x is the Buffer sample.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getExp();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getExp()

Definition at line 431 of file Buffer.h.

References exp().

    { Buffer temp(*this); temp.exp(); return temp; };

void Buffer::convolve

(

const Buffer &

H

)

Convolves the Buffer with another Buffer.

Parameters:

H

another Buffer to convole with.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 b1.convolve(b2);

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b1.convolve(b2)

Definition at line 539 of file Buffer.cc.

References getConvolve().

Referenced by Nsound::AudioStream::convolve().

{
    *this = getConvolve(H);
}

Buffer Buffer::getConvolve

(

const Buffer &

H

)

const

Convolves a copy of the Buffer with another Buffer.

Parameters:

H

another Buffer to convole with.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 Buffer b3 = b1.getConvolve(b2);

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b3 = b1.getConvolve(b2)

Definition at line 547 of file Buffer.cc.

References getLength().

Referenced by convolve(), and main().

{
    // Alocate the output Buffer will all zeros.
    Buffer y = *this * 0.0;

    // Pad y with H.getLength() samples.
    for(uint32 i = 0; i < H.getLength(); ++i)
    {
        y << 0.0;
    }

    // For each sample in this Buffer.
    for(uint32 i = 0; i < getLength(); ++i)
    {
        // For each sample in H.
        for(uint32 j = 0; j < H.getLength(); ++j)
        {
            y[i + j] += (*this)[i] * H[j];
        }
    }

    return y;
}

void Buffer::dB

(

)

Modifies the Buffer so each sample is converted to dB, 20 * log10(sample).

Example:

 // C++
 Buffer b1("california.wav");
 b1.dB();

 // Python
 b1 = Buffer("california.wav")
 b1.dB()

Definition at line 574 of file Buffer.cc.

References log10().

Referenced by Nsound::AudioStream::dB(), getdB(), and Nsound::FFTChunk::plot().

{
//~    FloatVector::iterator itor = data_.begin();
//~    FloatVector::iterator end  = data_.end();

//~    while(itor != end)
//~    {
//~        if(*itor == 0.0)
//~        {
//~            *itor = -150.0;
//~        }
//~        else
//~        {
//~            *itor = 20.0 * ::log10(*itor);
//~        }

//~        ++itor;
//~    }

    log10();
    *this *= 20.0;
}

Buffer Nsound::Buffer::getdB

(

)

const [inline]

Returns the Buffer in dB.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getdB();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getdB()

Definition at line 505 of file Buffer.h.

References dB().

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

    { Buffer temp(*this); temp.dB(); return temp; };

void Buffer::derivative

(

uint32

n

)

Calculates the nth derivative of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1.derivative(1);

 // Python
 b1 = Buffer("california.wav")
 b1.derivative(1)

Definition at line 600 of file Buffer.cc.

References data_.

Referenced by Nsound::AudioStream::derivative(), and getDerivative().

{
    for(uint32 pass = 0; pass < n; ++pass)
    {
        for(uint32 i = 1; i < data_.size(); ++i)
        {
            data_[i - 1] = (data_[i] - data_[i - 1]);
        }
    }
}

Buffer Nsound::Buffer::getDerivative

(

uint32

n

)

const [inline]

Returns the nth derivative of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getDerivative(1);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getDerivative(1)

Definition at line 538 of file Buffer.h.

References derivative().

Referenced by Nsound::FilterLeastSquaresFIR::makeKernel().

    { Buffer temp(*this); temp.derivative(n); return temp; };

void Buffer::downSample

(

uint32

n

)

Downsample this Buffer by a integral factor. N must be > 1.

Example:

 // C++
 Buffer b1("california.wav");
 b1.downSample(2);

 // Python
 b1 = Buffer("california.wav")
 b1.downSample(2)

Definition at line 614 of file Buffer.cc.

References getDownSample().

Referenced by Nsound::AudioStream::downSample().

{
    *this = getDownSample(n);
}

Buffer Buffer::getDownSample

(

uint32

n

)

const

Returns a copy of this Buffer downsampled by a integral factor. N must be > 1.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getDownSample(2);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getDownSample(2)

Definition at line 625 of file Buffer.cc.

References getResample().

Referenced by downSample().

{
    return getResample(static_cast<uint32>(1),M);
}

Uint32Vector Buffer::findPeaks	(	uint32	window_size = 0,
		const float64 &	min_height = 0.0
	)			const

Find the peaks in the Buffer and return a vector of indicies.

Example:

 // C++
 Buffer b1("california.wav");
 Uint32Vector v = b1.findPeaks(1000, 0.0);

 // Python
 b1 = Buffer("california.wav")
 peaks = b1.findPeaks(1000, 0.0)

Definition at line 633 of file Buffer.cc.

References data_, and getLength().

Referenced by main().

{
    Uint32Vector peaks;
    peaks.reserve(128);

    uint32 h_window_size = window_size / 2 + 1;  // half window size

    uint32 n_samples = getLength();

    for(uint32 i = 1; i < n_samples - 1; ++i)
    {
        boolean is_peak = false;

        float64 sample = data_[i];

        if(window_size <= 2)
        {
            if( sample > data_[i - 1] &&
                sample > data_[i + 1])
            {
                is_peak = true;
            }
        }
        else
        {
            // Assume it's a peak.

            is_peak = true;

            for(uint32 j = 1; j < h_window_size; ++j)
            {
                if(j < i)
                {
                    if(data_[i - j] > sample)
                    {
                        is_peak = false;
                        break;
                    }
                }

                if(i + j < n_samples)
                {
                    if(data_[i + j] > sample)
                    {
                        is_peak = false;
                        break;
                    }
                }
            }
        }

        if(is_peak && sample > min_height)
        {
            peaks.push_back(i);
        }
    }

    return peaks;
}

uint32 Nsound::Buffer::getLength

(

)

const [inline]

Returns the number of samples in the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 uint32 length = b1.getLength();

 // Python
 b1 = Buffer("california.wav")
 length = b1.getLength()

Definition at line 612 of file Buffer.h.

References data_.

Referenced by add(), Nsound::AdsrEnvelope::AdsrEnvelope(), Nsound::Stretcher::analyize(), Buffer_UnitTest(), BufferResample_UnitTest(), cosinewindow(), Nsound::Generator::ctor(), Nsound::Envelope::ctor(), Nsound::FilterIIR::designKernel(), Nsound::Generator::drawWindowKaiser(), exp(), Nsound::FFTransform::fft(), FFTransform_UnitTest(), Nsound::Vocoder::filter(), Nsound::ReverberationRoom::filter(), Nsound::FilterStageIIR::filter(), Nsound::FilterSlinky::filter(), Nsound::FilterParametricEqualizer::filter(), Nsound::FilterLowPassFIR::filter(), Nsound::FilterFlanger::filter(), Nsound::FilterDC::filter(), Nsound::FilterBandRejectIIR::filter(), Nsound::FilterBandRejectFIR::filter(), Nsound::FilterBandPassVocoder::filter(), Nsound::Filter::filter(), findPeaks(), Nsound::Granulator::generate(), Nsound::Generator::Generator(), get_at_index(), getConvolve(), Nsound::AudioStream::getDuration(), Nsound::FFTChunk::getFrequencyAxis(), Nsound::FFTChunk::getImaginary(), Nsound::AudioStream::getLength(), Nsound::FFTChunk::getMagnitude(), getMean(), Nsound::BufferWindowSearch::getNextWindow(), Nsound::FFTChunk::getPhase(), Nsound::Filter::getPhaseResponse(), Nsound::FFTChunk::getReal(), getResample(), getResample_(), Nsound::FilterIIR::getRMS(), Nsound::BufferWindowSearch::getSamplesLeft(), getSignalEnergy(), getStd(), Nsound::Granulator::Granulator(), Nsound::FFTransform::ifft(), Nsound::Plotter::imagesc(), log(), log10(), main(), Nsound::FilterLeastSquaresFIR::makeKernel(), Nsound::Plotter::makePyListFromBuffer(), Nsound::operator/(), Nsound::operator^(), Nsound::Stretcher::overlapAdd(), Nsound::AudioStream::pad(), Nsound::AudioStream::pan(), Nsound::FluteSlide::play(), Nsound::Clarinet::play(), play_int(), Nsound::Plotter::plot(), Nsound::FFTChunk::plot(), reverse(), Nsound::FilterIIR::savePlot(), select(), set_at_index(), Nsound::Kernel::setA(), Nsound::Kernel::setB(), Nsound::FilterLeastSquaresFIR::setKernel(), Nsound::Envelope::shape(), Nsound::Spectrogram::Spectrogram(), speedUp(), Nsound::Square::Square(), Nsound::Stretcher::Stretcher(), Nsound::Mesh2D::strike(), subbuffer(), testAutioStream(), testBufferAdd(), Nsound::FFTChunk::toCartesian(), Nsound::FFTChunk::toPolar(), Nsound::Triangle::Triangle(), Nsound::Wavefile::write(), and zNorm().

    { return data_.size(); };

void Buffer::limit	(	const float64 &	min,
		const float64 &	max
	)

Limits the Buffer to min and max.

Example:

 // C++
 Buffer b1("california.wav");
 b1.limit(-1.0, 1.0);

 // Python
 b1 = Buffer("california.wav")
 b1.limit(-1.0, 1.0);

Definition at line 886 of file Buffer.cc.

References begin(), and end().

Referenced by getLimit(), Nsound::AudioStream::limit(), and Nsound::DrumBD01::play().

{
    Buffer::iterator itor = this->begin();
    Buffer::iterator end  = this->end();

    while(itor != end)
    {
        float64 s = *itor;

        if(s > max) s = max;
        if(s < min) s = min;

        *itor = s;

        ++itor;
    }
}

void Buffer::limit	(	const Buffer &	min,
		const Buffer &	max
	)

Limits the Buffer to min and max.

Example:

 // C++
 Sine gen(100.0);
 Buffer b1("california.wav");
 Buffer b2 = gen.generate(5.0, 2.0);  // 5 seconds at 2 Hz
 b1.limit(b2, b2 + 1.0);

 // Python
 gen = Sine(100.0)
 b1 = Buffer("california.wav")
 b2 = Buffer(100)                 // sets chunk size to 100
 b2 << gen.generate(5.0, 2.0)     // 5 seconds at 2 Hz
 b1.limit(b2, b2 + 1.0)

Definition at line 907 of file Buffer.cc.

References begin(), cbegin(), and end().

{
    Buffer::circular_iterator imin = min.cbegin();
    Buffer::circular_iterator imax = max.cbegin();

    Buffer::iterator itor = this->begin();
    Buffer::iterator end  = this->end();

    while(itor != end)
    {
        float64 s = *itor;

        if(s > *imax) s = *imax;
        if(s < *imin) s = *imin;

        *itor = s;

        ++itor;
        ++imax;
        ++imin;
    }
}

Buffer Nsound::Buffer::getLimit	(	const float64 &	min,
		const float64 &	max
	)			const [inline]

Returns a copy of the Buffer with min and max limits.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getLimit(-1.0, 1.0);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getLimit(-1.0, 1.0);

Definition at line 666 of file Buffer.h.

References limit().

    { Buffer temp(*this); temp.limit(min, max); return temp; };

Buffer Nsound::Buffer::getLimit	(	const Buffer &	min,
		const Buffer &	max
	)			const [inline]

Returns a copy of the Buffer with min and max limits.

Example:

 // C++
 Sine gen(100.0);
 Buffer b1("california.wav");
 Buffer b2 = gen.generate(5.0, 2.0);  // 5 seconds at 2 Hz
 Buffer b3 = b1.getLimit(b2, b2 + 1.0);

 // Python
 gen = Sine(100.0)
 b1 = Buffer("california.wav")
 b2 = Buffer(100)                 // sets chunk size to 100
 b2 << gen.generate(5.0, 2.0)     // 5 seconds at 2 Hz
 b3 = b1.getLimit(b2, b2 + 1.0)

Definition at line 688 of file Buffer.h.

References limit().

    { Buffer temp(*this); temp.limit(min, max); return temp; };

void Buffer::log

(

)

Sets each sample in the Buffer to the natural log.

Example:

 // C++
 Buffer b1("california.wav");
 b1.log();

 // Python
 b1 = Buffer("california.wav")
 b1.log()

Definition at line 935 of file Buffer.cc.

References data_, getLength(), and LM_MAX.

Referenced by getLog(), and Nsound::Vocoder::Vocoder().

{
    for(uint32 i = 0; i < getLength(); ++i)
    {
        // Avoid taking log of really tiny numbers.
        float64 t = LM_MAX(data_[i], 1e-9);

        data_[i] = ::log(t);
    }
}

Buffer Nsound::Buffer::getLog

(

)

const [inline]

Returns the the Buffer where each sample is the natural log.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b1_log = b1.getLog();

 // Python
 b1 = Buffer("california.wav")
 l = b1.getLog()

Definition at line 721 of file Buffer.h.

References log().

    { Buffer temp(*this); temp.log(); return temp; };

void Buffer::log10

(

)

Sets each sample in the Buffer to log base 10.

Example:

 // C++
 Buffer b1("california.wav");
 b1.log10();

 // Python
 b1 = Buffer("california.wav")
 b1.log10()

Definition at line 949 of file Buffer.cc.

References data_, getLength(), and LM_MAX.

Referenced by dB(), and getLog10().

{
    for(uint32 i = 0; i < getLength(); ++i)
    {
        // Avoid taking log of really tiny numbers.
        float64 t = LM_MAX(data_[i], 1e-9);

        data_[i] = ::log10(t);
    }
}

Buffer Nsound::Buffer::getLog10

(

)

const [inline]

Returns the the Buffer where each sample is the natural log.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b1_log = b1.getLog();

 // Python
 b1 = Buffer("california.wav")
 l = b1.getLog()

Definition at line 754 of file Buffer.h.

References log10().

    { Buffer temp(*this); temp.log10(); return temp; };

float64 Buffer::getMax

(

)

const

Returns the maximum sample value in the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 float64 max = b1.getMax();

 // Python
 b1 = Buffer("california.wav")
 m = b1.getMax()

Definition at line 965 of file Buffer.cc.

References data_.

Referenced by Buffer_UnitTest(), BufferResample_UnitTest(), Nsound::Generator::buzz(), DelayLine_UnitTest(), FFTransform_UnitTest(), FilterBandPassFIR_UnitTest(), Nsound::FilterBandPassIIR::FilterBandPassIIR(), FilterBandPassIIR_UnitTest(), FilterBandRejectFIR_UnitTest(), FilterBandRejectIIR_UnitTest(), FilterCombLowPassFeedback_UnitTest(), FilterHighPassFIR_UnitTest(), FilterHighPassIIR_UnitTest(), FilterLeastSquaresFIR_UnitTest(), FilterLowPassFIR_UnitTest(), FilterLowPassIIR_UnitTest(), FilterParametricEqualizer_UnitTest(), Generator_UnitTest(), Nsound::AudioStream::getMax(), main(), Nsound::Plotter::plot(), Nsound::Filter::plot(), Nsound::FilterIIR::savePlot(), Sine_UnitTest(), and Triangle_UnitTest().

{
    float64 max = data_[0];

    for(const_iterator itor = data_.begin();
        itor != data_.end();
        ++itor)
    {
        float64 t = *itor;
        if(t > max)
        {
            max = t;
        }
    }

    return max;
}

float64 Buffer::getMaxMagnitude

(

)

const

Returns the maximum magnitude value in the Buffer, i.e. max(abs(samples)).

Example:

 // C++
 Buffer b1("california.wav");
 float64 max = b1.getMaxMagnitude();

 // Python
 b1 = Buffer("california.wav")
 m = b1.getMaxMagnitude()

Definition at line 986 of file Buffer.cc.

References data_.

Referenced by Nsound::AudioStream::getMaxMagnitude(), and normalize().

{
    float64 max = data_[0];

    for(const_iterator itor = data_.begin();
        itor != data_.end();
        ++itor)
    {
        float64 t = std::fabs(*itor);
        if( t > max)
        {
            max = t;
        }
    }

    return max;
}

float64 Buffer::getMean

(

)

const

Returns the mean sample value in the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 float64 mean = b1.getMean();

 // Python
 b1 = Buffer("california.wav")
 m = b1.getMean()

Definition at line 1007 of file Buffer.cc.

References getLength(), and getSum().

Referenced by getResample(), getStd(), main(), and zNorm().

{
    float64 sum = getSum();

    return sum / static_cast<float64>(getLength());
}

float64 Buffer::getMin

(

)

const

Returns the minimum sample value in the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 float64 min = b1.getMin();

 // Python
 b1 = Buffer("california.wav")
 m = b1.getMin()

Definition at line 1017 of file Buffer.cc.

References data_.

Referenced by Buffer_UnitTest(), Nsound::AudioStream::getMin(), Nsound::FilterLeastSquaresFIR::makeKernel(), and Nsound::Plotter::plot().

{
    float64 min = data_[0];

    for(const_iterator itor = data_.begin();
        itor != data_.end();
        ++itor)
    {
        if(*itor < min)
        {
            min = *itor;
        }
    }

    return min;
}

void Buffer::normalize

(

)

Multiplies the Buffer by a constant gain so the peak sample has magnitude 1.0.

Example:

 // C++
 Buffer b1("california.wav");
 b1.normalize();

 // Python
 b1 = Buffer("california.wav")
 b1.normalize()

Definition at line 1037 of file Buffer.cc.

References getMaxMagnitude().

Referenced by Nsound::Generator::drawGaussian(), FilterBandPassFIR_UnitTest(), FilterBandPassIIR_UnitTest(), FilterBandRejectFIR_UnitTest(), FilterBandRejectIIR_UnitTest(), FilterCombLowPassFeedback_UnitTest(), FilterHighPassFIR_UnitTest(), FilterHighPassIIR_UnitTest(), FilterLowPassIIR_UnitTest(), Nsound::Pluck::generate(), getNormalize(), main(), and Nsound::DrumBD01::play().

{
    float64 peak = getMaxMagnitude();

    float64 normal_factor = 1.0 / peak;

    *this *= normal_factor;
}

Buffer Nsound::Buffer::getNormalize

(

)

const [inline]

Returns a copy of the Buffer normalized.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getNormalize();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getNormalize()

Definition at line 851 of file Buffer.h.

References normalize().

    { Buffer temp(*this); temp.normalize(); return temp; };

Buffer Buffer::getSignalEnergy

(

uint32

window_size

)

const

Returns the signal energy: E = 1 / N * sum(|x(i)|) over the window of N samples

Example:

 // C++
 Buffer b1("california.wav");
 float64 energy = b1.getSignalEnergy();

 // Python
 b1 = Buffer("california.wav")
 energy = b1.getSignalEnergy()

Definition at line 1049 of file Buffer.cc.

References data_, and getLength().

{
    float64 n = static_cast<float64>(N);

    Buffer y;

    uint32 length = getLength();

    for(uint32 i = 0; i < length; ++i)
    {
        float64 sum = 0.0;

        for(uint32 j = 0; j < N; ++j)
        {
            if(i + j < length - 1)
            {
                sum += ::fabs(data_[i + j]);
            }
        }
        sum /= n;

        y << sum;

    }

    return y;
}

float64 Buffer::getStd

(

)

const

Returns the standard deviation of the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 float64 std = b1.getStd();

 // Python
 b1 = Buffer("california.wav")
 std = b1.getStd()

Definition at line 1080 of file Buffer.cc.

References getLength(), getMean(), getSum(), and sqrt().

{
    Buffer diff = *this - getMean();

    diff ^= 2.0;

    return ::sqrt(diff.getSum() / static_cast<float64>(getLength()));
}

float64 Buffer::getSum

(

)

const

Returns the sum of all samples.

Example:

 // C++
 Buffer b1("california.wav");
 float64 sum = b1.getSum();

 // Python
 b1 = Buffer("california.wav")
 sum = b1.getSum()

Definition at line 1092 of file Buffer.cc.

References data_.

Referenced by getMean(), Nsound::FilterIIR::getRMS(), getStd(), Nsound::Stretcher::searchForBestMatch(), and zNorm().

{
    float64 sum = 0.0;

    for(const_iterator itor = data_.begin();
        itor != data_.end();
        ++itor)
    {
        sum += *itor;
    }

    return sum;
}

void Buffer::zNorm

(

)

Normalized the Buffer using Z score normalizing. z = (x - mean(x)) / std(x)

Example:

 // C++
 Buffer b1("california.wav");
 b1.zNorm();

 // Python
 b1 = Buffer("california.wav")
 b1.zNorm()

Definition at line 1109 of file Buffer.cc.

References getLength(), getMean(), getSum(), and sqrt().

Referenced by getZNorm().

{
    // z = (x - mean(x)) / std(x)

    // We won't call getStd() to avoid calculatig the diff and mean twice.

    // z = (x - mean(x)) / sqrt( sum((x - mean(x))^2) / N)

    float64 mean = getMean();

    Buffer diff = *this - mean;

    float64 std = (diff*diff).getSum() / static_cast<float64>(getLength());

    std = ::sqrt(std);

    *this = diff / (std + 1e-20);
}

Buffer Nsound::Buffer::getZNorm

(

)

const [inline]

Returns a Z score normalized copy of the Buffer. z = (x - mean(x)) / std(x)

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getNorm();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getZNorm()

Definition at line 936 of file Buffer.h.

References zNorm().

    { Buffer temp(*this); temp.zNorm(); return temp; };

BufferSelection Buffer::operator()

(

const BooleanVector &

bv

)

Returns a BufferSelection object used for manipulation of a selected region of samples.

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection bs = b1 > 0.5;

 // Python
 b1 = Buffer("california.wav")
 bs = b1 > 0.5

Definition at line 1151 of file Buffer.cc.

{
    BufferSelection bs(*this, bv);

    return bs;
}

Buffer & Buffer::operator=

(

const Buffer &

rhs

)

The assignment operator. C++ only, for Python, use the copy constructor.

Definition at line 1132 of file Buffer.cc.

References data_.

{
    if(this == &rhs_buffer) // If it is the same object, return it.
    {
        return *this;
    }

    // Allocate or deallocate BufferChunks as necessary.

    data_.clear();

    *this << rhs_buffer;

    return *this;
}

boolean Buffer::operator==

(

const Buffer &

rhs

)

const

Tests of equality.

Definition at line 1161 of file Buffer.cc.

References data_.

{
    if(data_.size() != rhs_buffer.data_.size())
    {
        return false;
    }

    for(uint32 i = 0; i < data_.size(); ++i)
    {
        if(data_[i] != rhs_buffer.data_[i])
        {
            return false;
        }
    }

    return true;
}

boolean Buffer::operator!=

(

const Buffer &

rhs

)

const

Tests of inequality.

Definition at line 1182 of file Buffer.cc.

References data_.

{
    if(data_.size() != rhs_buffer.data_.size())
    {
        return true;
    }

    for(uint32 i = 0; i < data_.size(); ++i)
    {
        if(data_[i] != rhs_buffer.data_[i])
        {
            return true;
        }
    }

    return false;
}

const float64 Nsound::Buffer::operator[]

(

uint32

index

)

const [inline]

Returns a const reference into the Buffer.

Definition at line 974 of file Buffer.h.

References data_.

    { return data_[index]; };

float64& Nsound::Buffer::operator[]

(

uint32

index

)

[inline]

Retruns a reference into the Buffer.

Definition at line 981 of file Buffer.h.

References data_.

    { return data_[index]; };

Buffer & Buffer::operator<<

(

const AudioStream &

rhs

)

Concatenates Buffers and AudioStreams together.

Example:

 // C++
 Buffer b1("california.wav");
 AudioStream a2("walle.wav");
 b1 << a2;

 // Python
 b1 = Buffer("california.wav")
 a2 = AudioStream("walle.wav")
 b1 << a2

Definition at line 1203 of file Buffer.cc.

References Nsound::AudioStream::getMono().

{
    (*this) << rhs.getMono()[0];

    return *this;
}

Buffer & Buffer::operator<<

(

const Buffer &

rhs

)

Concatenates Buffers together.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 b1 << b2;

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b1 << b2

Definition at line 1213 of file Buffer.cc.

References Buffer(), data_, and end().

{
    if(this == & rhs_buffer)
    {
        Buffer * rhs = new Buffer(rhs_buffer);
        *this << *rhs;
        delete rhs;

        return *this;
    }

    std::vector<float64>::const_iterator itor = rhs_buffer.data_.begin();
    std::vector<float64>::const_iterator end = rhs_buffer.data_.end();

    while(itor != end)
    {
        data_.push_back(*itor);
        ++itor;
    }

    return *this;
}

Buffer & Buffer::operator<<=

(

const Buffer &

rhs

)

Definition at line 1239 of file Buffer.cc.

{
    return (*this) << rhs_buffer;
}

Buffer& Nsound::Buffer::operator<<

(

const float64 &

d

)

[inline]

Concatenates samples to the Buffer.

Definition at line 1027 of file Buffer.h.

References data_.

    { data_.push_back(d); return *this; };

Buffer& Nsound::Buffer::operator<<=

(

const float64 &

d

)

[inline]

Concatenates samples to the Buffer.

Definition at line 1034 of file Buffer.h.

References data_.

    { data_.push_back(d); return *this; };

Buffer & Buffer::operator+=

(

const Buffer &

rhs

)

Adds each sample from the right hand side (rhs) Buffer with this Buffer. All arithmatic operations only operate for N samples where N is min(b1.getLength(), b2.getLength()).

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 b1 += b2;

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b1 += b2

Definition at line 1251 of file Buffer.cc.

References ADD, and vectorOperator().

{
    return vectorOperator(rhs,ADD);
}

Buffer & Buffer::operator-=

(

const Buffer &

rhs

)

Subracts each sample from the right hand side (rhs) Buffer from this Buffer. All arithmatic operations only operate for N samples where N is min(b1.getLength(), b2.getLength()).

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 b1 -= b2;

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b1 -= b2

Definition at line 1257 of file Buffer.cc.

References SUBTRACT, and vectorOperator().

{
    return vectorOperator(rhs,SUBTRACT);
}

Buffer & Buffer::operator*=

(

const Buffer &

rhs

)

Multiplies each sample from the right hand side (rhs) with this Buffer. All arithmatic operations only operate for N samples where N is min(b1.getLength(), b2.getLength()).

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 b1 *= b2;

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b1 *= b2

Definition at line 1263 of file Buffer.cc.

References MULTIPLY, and vectorOperator().

{
    return vectorOperator(rhs,MULTIPLY);
}

Buffer & Buffer::operator/=

(

const Buffer &

rhs

)

Divides each sample in this Buffer with the right hand side (rhs) Buffer. All arithmatic operations only operate for N samples where N is min(b1.getLength(), b2.getLength()).

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("walle.wav");
 b1 /= b2;

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("walle.wav")
 b1 /= b2

Definition at line 1270 of file Buffer.cc.

References DIVIDE, and vectorOperator().

{
    return vectorOperator(rhs,DIVIDE);
}

Buffer & Buffer::operator^=

(

const Buffer &

powers

)

Each sample in the Buffer becomes the power x^n. Each sample in the Buffer becomes the power x^n, where x is the Buffer sample and N is the power.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2("california.wav");
 b1 ^= b2;

 // Python
 b1 = Buffer("california.wav")
 b2 = Buffer("california.wav")
 b1 **= b2

Definition at line 1277 of file Buffer.cc.

References POW, and vectorOperator().

{
    return vectorOperator(rhs,POW);
}

Buffer & Buffer::operator+=

(

const float64 &

d

)

Adds the sample d to each sample in this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1 += 0.26;

 // Python
 b1 = Buffer("california.wav")
 b1 += 0.26

Definition at line 1373 of file Buffer.cc.

References ADD, and scalarOperator().

{
    return scalarOperator(d,ADD);
}

Buffer & Buffer::operator-=

(

const float64 &

d

)

Subtracts the sample d from each sample in this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1 += 0.26;

 // Python
 b1 = Buffer("california.wav")
 b1 += 0.26

Definition at line 1380 of file Buffer.cc.

References scalarOperator(), and SUBTRACT.

{
    return scalarOperator(d,SUBTRACT);
}

Buffer & Buffer::operator*=

(

const float64 &

d

)

Multiplies the sample d with each sample in this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1 *= 0.26;

 // Python
 b1 = Buffer("california.wav")
 b1 *= 0.26

Definition at line 1387 of file Buffer.cc.

References MULTIPLY, and scalarOperator().

{
    return scalarOperator(d,MULTIPLY);
}

Buffer & Buffer::operator/=

(

const float64 &

d

)

Divides each sample in this Buffer by d.

Example:

 // C++
 Buffer b1("california.wav");
 b1 /= 0.26;

 // Python
 b1 = Buffer("california.wav")
 b1 /= 0.26

Definition at line 1394 of file Buffer.cc.

References DIVIDE, and scalarOperator().

{
    return scalarOperator(d,DIVIDE);
}

Buffer & Buffer::operator^=

(

const float64 &

power

)

Each sample in the Buffer becomes the power x^n. Each sample in the Buffer becomes the power x^n, where x is the Buffer sample and N is the power.

Example:

 // C++
 Buffer b1("california.wav");
 b1 ^= 2.0;

 // Python
 b1 = Buffer("california.wav")
 b1 **= 2.0

WARNING: sometimes one may want to do this:

 // C++
 mag = real ^ 2 + imag ^ 2;

But C++'s default operator precedence will actually compile this:

 mag = (real ^ (2 + imag)) ^ 2;

because operator+ has high presedence. To avoid this, in C++ you must use parentheses.

 mag = (real ^ 2) + (imag ^ 2);

Definition at line 1401 of file Buffer.cc.

References POW, and scalarOperator().

{
    return scalarOperator(d,POW);
}

BooleanVector Buffer::operator>

(

const float64 &

rhs

)

Creates a BooleanVector where each value is true iff Buffer[n] > rhs.

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection bs = b1 > 0.26;

 // Python
 b1 = Buffer("california.wav")
 bs = b1 > 0.26

Definition at line 2408 of file Buffer.cc.

References begin(), and end().

{
    BooleanVector bv;

    Buffer::const_iterator itor = this->begin();
    Buffer::const_iterator end  = this->end();

    while(itor != end)
    {
        if(*itor > rhs) bv.push_back(true);
        else            bv.push_back(false);
        ++itor;
    }

    return bv;
}

BooleanVector Buffer::operator>=

(

const float64 &

rhs

)

Creates a BooleanVector where each value is true iff Buffer[n] >= rhs.

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection bs = b1 >= 0.26;

 // Python
 b1 = Buffer("california.wav")
 bs = b1 >= 0.26

Definition at line 2428 of file Buffer.cc.

References begin(), and end().

{
    BooleanVector bv;

    Buffer::const_iterator itor = this->begin();
    Buffer::const_iterator end  = this->end();

    while(itor != end)
    {
        if(*itor >= rhs) bv.push_back(true);
        else             bv.push_back(false);
        ++itor;
    }

    return bv;
}

BooleanVector Buffer::operator<

(

const float64 &

rhs

)

Creates a BooleanVector where each value is true iff Buffer[n] < rhs.

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection bs = b1 < 0.26;

 // Python
 b1 = Buffer("california.wav")
 bs = b1 < 0.26

Definition at line 2448 of file Buffer.cc.

References begin(), and end().

{
    BooleanVector bv;

    Buffer::const_iterator itor = this->begin();
    Buffer::const_iterator end  = this->end();

    while(itor != end)
    {
        if(*itor < rhs) bv.push_back(true);
        else            bv.push_back(false);
        ++itor;
    }

    return bv;
}

BooleanVector Buffer::operator<=

(

const float64 &

rhs

)

Creates a BooleanVector where each value is true iff Buffer[n] <= rhs.

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection bs = b1 <= 0.26;

 // Python
 b1 = Buffer("california.wav")
 bs = b1 <= 0.26

Definition at line 2468 of file Buffer.cc.

References begin(), and end().

{
    BooleanVector bv;

    Buffer::const_iterator itor = this->begin();
    Buffer::const_iterator end  = this->end();

    while(itor != end)
    {
        if(*itor <= rhs) bv.push_back(true);
        else             bv.push_back(false);
        ++itor;
    }

    return bv;
}

BooleanVector Buffer::operator==

(

const float64 &

rhs

)

Creates a BooleanVector where each value is true iff Buffer[n] == rhs.

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection bs = b1 == 0.26;

 // Python
 b1 = Buffer("california.wav")
 bs = b1 == 0.26

Definition at line 2488 of file Buffer.cc.

References begin(), and end().

{
    BooleanVector bv;

    Buffer::const_iterator itor = this->begin();
    Buffer::const_iterator end  = this->end();

    while(itor != end)
    {
        bv.push_back(*itor == rhs);
        ++itor;
    }

    return bv;
}

BooleanVector Buffer::operator!=

(

const float64 &

rhs

)

Creates a BooleanVector where each value is true iff Buffer[n] != rhs.

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection bs = b1 != 0.26;

 // Python
 b1 = Buffer("california.wav")
 bs = b1 != 0.26

Definition at line 2507 of file Buffer.cc.

References begin(), and end().

{
    BooleanVector bv;

    Buffer::const_iterator itor = this->begin();
    Buffer::const_iterator end  = this->end();

    while(itor != end)
    {
        bv.push_back(*itor != rhs);
        ++itor;
    }

    return bv;
}

void Buffer::plot

(

const std::string &

title = "Buffer"

)

const

Requires matplotlib. Creates a plot of this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1.plot("This is california.wav");
 Plotter::show(); // This will render any plots created.

 // Python
 b1 = Buffer("california.wav")
 b1.plot("This is california.wav")
 Plotter.show()

Definition at line 1683 of file Buffer.cc.

References Nsound::Plotter::figure(), Nsound::Plotter::plot(), and Nsound::Plotter::title().

Referenced by Buffer_UnitTest(), BufferResample_UnitTest(), DelayLine_UnitTest(), FFTransform_UnitTest(), FilterBandPassFIR_UnitTest(), FilterBandPassIIR_UnitTest(), FilterBandRejectFIR_UnitTest(), FilterBandRejectIIR_UnitTest(), FilterCombLowPassFeedback_UnitTest(), FilterHighPassFIR_UnitTest(), FilterHighPassIIR_UnitTest(), FilterLeastSquaresFIR_UnitTest(), FilterLowPassFIR_UnitTest(), FilterLowPassIIR_UnitTest(), FilterParametricEqualizer_UnitTest(), Generator_UnitTest(), main(), Sine_UnitTest(), testBufferAdd(), and Triangle_UnitTest().

{
    Plotter pylab;

    pylab.figure();
    pylab.plot(*this);
    pylab.title(title);
}

const float64* Nsound::Buffer::getPointer

(

)

const [inline]

Returns the raw point to the first sample in the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 const flaot64 * ptr = b1.getPointer();

 // Python, not supported or needed.

Definition at line 1393 of file Buffer.h.

References data_.

Referenced by Nsound::FilterLeastSquaresFIR::FilterLeastSquaresFIR(), Nsound::FilterLeastSquaresFIR::makeKernel(), Nsound::FilterLeastSquaresFIR::setKernel(), and Nsound::FilterLeastSquaresFIR::setWindow().

    { return &(data_[0]); }

float64* Nsound::Buffer::getPointer

(

)

[inline]

Requires matplotlib. Creates a plot of this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1.plot("This is california.wav");
 Plotter::show(); // This will render any plots created.

 // Python, not supported or needed.

Definition at line 1409 of file Buffer.h.

References data_.

    { return &(data_[0]); }

void Buffer::preallocate

(

uint32

n

)

Preallocates memory to hold an additional n samples. This makes a call to std::vector::reserve( this->getLength() + n).

Example:

 // C++
 Buffer b1("california.wav");
 b1.preallocate(100);

 // Python
 b1 = Buffer("california.wav")
 b1.preallocate(100);

Definition at line 1675 of file Buffer.cc.

References data_.

Referenced by Nsound::AudioStream::AudioStream().

{
    data_.reserve(data_.size() + n);
}

void Buffer::readWavefile

(

const char *

filename

)

Sets this Buffer to the contents of the wavefile on the disk. If the wavefile is stereo, it only reads the first channel.

Example:

 // C++
 Buffer b1;
 b1.readWavefile("california.wav");

 // Python
 b1 = Buffer()
 b1.readWavefile("california.wav")

Definition at line 1695 of file Buffer.cc.

{
    if(filename == NULL) return;

    *this << filename;
}

void Nsound::Buffer::resample

(

const float64 &

factor

)

[inline]

Resamples this Buffer using discrete-time resampling.

Example:

 // C++
 Buffer b1("california.wav");
 b1.resample(0.666);

 // Python
 b1 = Buffer("california.wav")
 b1.resample(0.666)

Definition at line 1461 of file Buffer.h.

References getResample().

Referenced by main(), and Nsound::AudioStream::resample().

    { *this = getResample(factor, 10, 5.0); };

void Nsound::Buffer::resample

(

const Buffer &

factor

)

[inline]

Resamples this Buffer using discrete-time resampling.

Example:

 // C++
 Buffer b1("california.wav");
 Sine gen(44100);
 Buffer factor = gen.generate(2.0, 5.0);
 b1.resample(factor);

 // Python
 b1 = Buffer("california.wav")
 gen = Sine(44100)
 factor = Buffer()
 factor << gen.generate(2.0, 5.0)
 b1.resample(factor)

Definition at line 1483 of file Buffer.h.

References getResample().

    { *this = getResample(factor, 10, 5.0); };

Buffer Buffer::getResample	(	const float64 &	factor,
		const uint32	N = 10,
		const float64 &	beta = 5.0
	)			const

Resamples a copy of this Buffer using discrete-time resampling.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getResample(0.666);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getResample(0.666)

Definition at line 1742 of file Buffer.cc.

References find_fraction().

Referenced by BufferResample_UnitTest(), getDownSample(), getResample(), getUpSample(), Nsound::Stretcher::pitchShift(), and resample().

{
    uint32 L = 0;
    uint32 M = 0;

    find_fraction(factor, 0.0001, L, M);

    return getResample(L,M,N,beta);
}

Buffer Buffer::getResample	(	const Buffer &	factor,
		const uint32	N = 10,
		const float64 &	beta = 5.0
	)			const

Resamples a copy of this Buffer using discrete-time resampling.

Example:

 // C++
 Buffer b1("california.wav");
 Sine gen(44100);
 Buffer factor = gen.generate(2.0, 5.0);
 Buffer b2 = b1.getResample(factor);

 // Python
 b1 = Buffer("california.wav")
 gen = Sine(44100)
 factor = Buffer()
 factor << gen.generate(2.0, 5.0)
 b2 = b1.getResample(factor)

Definition at line 1758 of file Buffer.cc.

References getLength(), getMean(), Nsound::BufferWindowSearch::getNextWindow(), getResample(), Nsound::BufferWindowSearch::getSamplesLeft(), and subbuffer().

{
    BufferWindowSearch search(*this, 1024);

    uint32 pos = 0;

    Buffer y;

    while(search.getSamplesLeft() > 0)
    {
        Buffer window = search.getNextWindow();

        uint32 Lw = window.getLength();

        Buffer ratio = factor.subbuffer(pos, Lw);

        float64 r = ratio.getMean();

        y << window.getResample(r,N,beta);

        pos += Lw;
    }

    return y;
}

Buffer Buffer::getResample	(	const uint32	L,
		const uint32	M,
		const uint32	N = 10,
		const float64 &	beta = 5.0
	)			const

Resamples a copy of this Buffer using discrete-time resampling.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getResample(1, 3);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getResample(1, 3)

Definition at line 1790 of file Buffer.cc.

References getLength(), Nsound::BufferWindowSearch::getNextWindow(), getResample_(), and Nsound::BufferWindowSearch::getSamplesLeft().

{
    Buffer y;

    // If the Buffer is really long, break it up into window to reduce memory
    // usage.
    if(getLength() > 40000)
    {
        BufferWindowSearch search(*this, 2048);

        while(search.getSamplesLeft() > 0)
        {
            Buffer window = search.getNextWindow();

            y << window.getResample_(L,M,N,beta);
        }
    }
    else
    {
        y << getResample_(L,M,N,beta);
    }

    return y;
}

void Buffer::reverse

(

)

Reverses the samples in this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1.reverse();

 // Python
 b1 = Buffer("california.wav")
 b1.reverse()

Definition at line 2001 of file Buffer.cc.

References data_, and getLength().

Referenced by Buffer_UnitTest(), getReverse(), and Nsound::AudioStream::reverse().

{
    for(uint32 front = 0, back = getLength() - 1;
        front < back;
        ++front, --back)
    {
        float64 temp = data_[front];
        data_[front] = data_[back];
        data_[back] = temp;
    }
}

Buffer Nsound::Buffer::getReverse

(

)

const [inline]

Reverses the samples in a copy of this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getReverse();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getReverse()

Definition at line 1579 of file Buffer.h.

References reverse().

Referenced by getResample_(), Nsound::Granulator::Granulator(), Nsound::FFTransform::ifft(), Nsound::FilterLeastSquaresFIR::makeKernel(), and Nsound::Stretcher::overlapAdd().

    { Buffer temp(*this); temp.reverse(); return temp; };

void Buffer::round

(

)

Rounds the samples in this Buffer to the nearest integer value. Values with remainders 0.5 or greater are rounded up, otherwise truncated.

Example:

 // C++
 Buffer b1("california.wav");
 b1.round();

 // Python
 b1 = Buffer("california.wav")
 b1.round()

Definition at line 2016 of file Buffer.cc.

References begin(), and end().

Referenced by getRound().

{
    for(Buffer::iterator i = this->begin();
        i != this->end();
        ++i)
    {
        *i = std::floor(*i + 0.5);
    }
}

Buffer Nsound::Buffer::getRound

(

)

const [inline]

Rounds the samples in a copy of this Buffer to the nearest integer value. Values with remainders 0.5 or greater are rounded up, otherwise truncated.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getRound();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getRound()

Definition at line 1616 of file Buffer.h.

References round().

    { Buffer temp(*this); temp.round(); return temp; };

BufferSelection Buffer::select	(	const uint32	start_index,
		const uint32	stop_index
	)

Returns a BufferSelection for the range of indicies.

Parameters:

	start_index	the start of the selection
	stop_index	the stop of the selection

Example:

 // C++
 Buffer b1("california.wav");
 BufferSelection selection = b1.select(20,80);

 // Python
 b1 = Buffer("california.wav")
 selection = b1.select(20,80)

Definition at line 2046 of file Buffer.cc.

References getLength().

{
    uint32 n_samples = getLength();

    BooleanVector bv;

    bv.reserve(n_samples);

    for(uint32 i = 0; i < n_samples; ++i)
    {
        if( i >= start_index && i <= stop_index)
        {
            bv.push_back(true);
        }
        else
        {
            bv.push_back(false);
        }
    }

    return BufferSelection(*this, bv);
}

void Buffer::smooth	(	uint32	n_passes,
		uint32	n_samples_per_average
	)

Applies a moving average filter to smooth this Buffer.

Parameters:

	n_passes	the number of times to repeat the moving average
	n_samples_per_average	the number of samples to average

Example:

 // C++
 Buffer b1("california.wav");
 b1.smooth(1, 15);

 // Python
 b1 = Buffer("california.wav")
 b1.smooth(1,15)

Definition at line 2072 of file Buffer.cc.

References begin(), end(), and Nsound::FilterMovingAverage::filter().

Referenced by Buffer_UnitTest(), Nsound::Pluck::generate(), getSmooth(), main(), and Nsound::AudioStream::smooth().

{
    if(n_samples_to_average < 2)
    {
        return;
    }

    FilterMovingAverage maf(n_samples_to_average);

    Buffer::iterator end = this->end();

    for(uint32 i = 0; i < n_passes; ++i)
    {
        Buffer::iterator itor = this->begin();

        while(itor != end)
        {
            *itor = maf.filter(*itor);
            ++itor;
        }
    }
}

Buffer Nsound::Buffer::getSmooth	(	uint32	n_passes,
		uint32	n_samples_per_average
	)			const [inline]

Applies a moving average filter to smooth a copy of this Buffer.

Parameters:

	n_passes	the number of times to repeat the moving average
	n_samples_per_average	the number of samples to average

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getSmooth(1, 15);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getSmooth(1,15)

Definition at line 1674 of file Buffer.h.

References smooth().

    { Buffer temp(*this); temp.smooth(n_passes, n_samples_per_average); return temp; };

void Buffer::speedUp

(

const float64 &

step_size

)

Resamples this Buffer by the step_size, no interpolation.

Example:

 // C++
 Buffer b1("california.wav");
 b1.speedUp(2.0);                // b1 is now half the length
 b1.speedUp(0.5);                // b1 is now original length

 // Python
 b1 = Buffer("california.wav")
 b1.speedUp(2.0)                 // b1 is now half the length
 b1.speedUp(0.5)                 // b1 is now original length

Definition at line 2098 of file Buffer.cc.

References data_.

Referenced by getSpeedUp(), and Nsound::AudioStream::speedUp().

{
    Buffer new_buffer;

    float64 n_samples = static_cast<float64>(data_.size());

    for(float64 i = 0.0; i < n_samples; i += step_size)
    {
        new_buffer << data_[static_cast<uint32>(i)];
    }

    *this = new_buffer;
}

Buffer Nsound::Buffer::getSpeedUp

(

const float64 &

step_size

)

const [inline]

Resamples a copy of this Buffer by the step_size, no interpolation.

Example:

 // C++
 Buffer b1("california.wav");
 b1.speedUp(2.0);                // b1 is now half the length
 b1.speedUp(0.5);                // b1 is now original length

 // Python
 b1 = Buffer("california.wav")
 b1.speedUp(2.0)                 // b1 is now half the length
 b1.speedUp(0.5)                 // b1 is now original length

Definition at line 1711 of file Buffer.h.

References speedUp().

Referenced by Nsound::FFTransform::fft(), and Nsound::Stretcher::pitchShift().

    { Buffer temp(*this); temp.speedUp(step_size); return temp; };

void Buffer::speedUp

(

const Buffer &

step_size

)

Resamples this Buffer on a sample by sample basis, no interpolation.

Example:

 // C++
 Buffer b1("california.wav");
 Sine gen(44100);
 Buffer factor = gen.generate(2.0, 5.0);
 b1.speedUp(factor);

 // Python
 b1 = Buffer("california.wav")
 gen = Sine(44100)
 factor = Buffer()
 factor << gen.generate(2.0, 5.0)
 b1.speedUp(factor)

Definition at line 2115 of file Buffer.cc.

References getLength().

{
    Buffer new_buffer;

    float32 n_samples = static_cast<float32>(getLength());
    uint32 step_buffer_size = step_buffer.getLength();

    uint32 step_buffer_index = 0;
    float32 step_size = 0.0;

    for(float32 i = 0.0; i < n_samples; i += step_size)
    {
        new_buffer << data_[static_cast<uint32>(i)];

        step_size = step_buffer[step_buffer_index++];

        if(step_buffer_index >= step_buffer_size)
        {
            step_buffer_index -= step_buffer_size;
        }
    }

    *this = new_buffer;
}

Buffer Nsound::Buffer::getSpeedUp

(

const Buffer &

step_size

)

const [inline]

Resamples a copy of this Buffer on a sample by sample basis, no interpolation.

Example:

 // C++
 Buffer b1("california.wav");
 Sine gen(44100);
 Buffer factor = gen.generate(2.0, 5.0);
 Buffer b2 = b1.getSpeedUp(factor);

 // Python
 b1 = Buffer("california.wav")
 gen = Sine(44100)
 factor = Buffer()
 factor << gen.generate(2.0, 5.0)
 b2 = b1.getSpeedUp(factor)

Definition at line 1754 of file Buffer.h.

References speedUp().

    { Buffer temp(*this); temp.speedUp(step_size); return temp; };

void Buffer::sqrt

(

)

Takes the square root of each sample in this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 b1.sqrt();

 // Python
 b1 = Buffer("california.wav")
 b1.sqrt()

Definition at line 2143 of file Buffer.cc.

References begin(), and end().

Referenced by getSqrt(), getStd(), main(), Nsound::AudioStream::sqrt(), and zNorm().

{
    Buffer::iterator itor = this->begin();
    Buffer::iterator end  = this->end();

    while(itor != end)
    {
        float64 v = *itor;
        if(v > 0.0)
        {
            *itor = std::sqrt(v);
        }
        else if(v < 0.0)
        {
            *itor = -std::sqrt(-v);
        }
        ++itor;
    }
}

Buffer Nsound::Buffer::getSqrt

(

)

const [inline]

Taks the square root of each sample in a copy of this Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getSqrt();

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getSqrt()

Definition at line 1787 of file Buffer.h.

References sqrt().

Referenced by Nsound::DrumBD01::play().

    { Buffer temp(*this); temp.sqrt(); return temp; };

Buffer Buffer::subbuffer	(	uint32	start_index,
		uint32	n_samples = 0
	)			const

Slice the Buffer.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.subbuffer(5,1000);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.subbuffer(5,1000)
 // OR
 b2 = b1[5:1005]

Definition at line 2166 of file Buffer.cc.

References data_, and getLength().

Referenced by Buffer_UnitTest(), Nsound::FFTransform::fft(), Nsound::FFTChunk::getImaginary(), Nsound::FFTChunk::getMagnitude(), Nsound::BufferWindowSearch::getNextWindow(), Nsound::FFTChunk::getPhase(), Nsound::Filter::getPhaseResponse(), Nsound::FFTChunk::getReal(), getResample(), getResample_(), Nsound::FFTransform::ifft(), main(), Nsound::FilterLeastSquaresFIR::makeKernel(), Nsound::Stretcher::overlapAdd(), Nsound::FFTChunk::plot(), Nsound::Stretcher::searchForBestMatch(), Nsound::Spectrogram::Spectrogram(), and Nsound::AudioStream::substream().

{
    uint32 n = n_samples;

    if(n > getLength()) n = getLength();

    Buffer new_buffer(n);

    if(start_index >= data_.size())
        return new_buffer;

    uint32 stop_index = start_index + n;

    if(n == 0 || stop_index >= data_.size())
    {
        stop_index = data_.size();
    }

    for(uint32 i = start_index; i < stop_index; ++i)
    {
        new_buffer << data_[i];
    }

    return new_buffer;
}

void Buffer::upSample

(

uint32

n

)

Upsample this Buffer by a integral factor. N must be > 1.

Example:

 // C++
 Buffer b1("california.wav");
 b1.upSample(2);

 // Python
 b1 = Buffer("california.wav")
 b1.upSample(2)

Definition at line 2195 of file Buffer.cc.

References getUpSample().

Referenced by Nsound::AudioStream::upSample().

{
    *this = getUpSample(n);
}

Buffer Buffer::getUpSample

(

uint32

n

)

const

Upsample a copy of this Buffer by a integral factor. N must be > 1.

Example:

 // C++
 Buffer b1("california.wav");
 Buffer b2 = b1.getUpSample(2);

 // Python
 b1 = Buffer("california.wav")
 b2 = b1.getUpSample(2)

Definition at line 2206 of file Buffer.cc.

References getResample().

Referenced by upSample().

{
    return getResample(L,static_cast<uint32>(1));
}

void Buffer::writeWavefile

(

const char *

filename

)

const

Writes the Buffer to a Wavefile.

Example:

 // C++
 Buffer b1("california.wav");
 b1.writeWavefile("california_copy.wav");

 // Python
 b1 = Buffer("california.wav")
 b1.writeWavefile("california_copy.wav")

Definition at line 2214 of file Buffer.cc.

References Nsound::operator>>().

{

    if(filename == NULL) return;

    Nsound::operator>>(*this, filename);
}

float64 Buffer::get_at_index

(

int32

index

)

const

SWIG helper function for operator[].

Definition at line 867 of file Buffer.cc.

References data_, and getLength().

{
    int32 len = getLength();

    if(index >= 0 && index < len)
    {
        return data_[index];
    }
    else if( index >= -len)
    {
        return data_[getLength() + index];
    }

    return 0.0;
}

void Buffer::set_at_index	(	int32	index,
		const float64 &	d
	)

SWIG helper function for operator[].

Definition at line 2029 of file Buffer.cc.

References data_, and getLength().

{
    int32 len = getLength();

    if(index >= 0 && index < len)
    {
        data_[index] = d;
    }
    else if( index >= -len)
    {
        data_[getLength() + index] = d;
    }
}

void Nsound::Buffer::swig_hook

(

)

[inline]

SWIG helper function function to shadow.

Definition at line 1973 of file Buffer.h.

{};

Buffer Buffer::ones

(

const uint32

n_samples

)

[static]

Returns a Buffer full of ones of length n_samples.

Definition at line 2526 of file Buffer.cc.

References Nsound::Generator::drawLine().

{
    Buffer b(n_samples);

    Generator g(1);

    b << g.drawLine(n_samples, 1.0, 1.0);

    return b;
}

Buffer Buffer::rand

(

const uint32

n_samples

)

[static]

Returns a Buffer full of random values of length n_samples.

Definition at line 2540 of file Buffer.cc.

References Nsound::Generator::whiteNoise().

{
    Buffer b(n_samples);

    Generator g(1);

    b << g.whiteNoise(n_samples);

    return b;
}

Buffer Buffer::zeros

(

const uint32

n_samples

)

[static]

Returns a Buffer full of zeros of length n_samples.

Definition at line 2554 of file Buffer.cc.

References Nsound::Generator::drawLine().

Referenced by Nsound::Sawtooth::Sawtooth(), and Nsound::Square::Square().

{
    Buffer b(n_samples);

    Generator g(1);

    b << g.drawLine(n_samples, 0.0, 0.0);

    return b;
}

Buffer Buffer::getResample_	(	const uint32	L,
		const uint32	M,
		const uint32	N,
		const float64 &	beta
	)			const [protected]

Definition at line 1822 of file Buffer.cc.

References begin(), data_, end(), Nsound::FilterLeastSquaresFIR::filter(), Nsound::FilterLeastSquaresFIR::getKernel(), getLength(), getReverse(), Nsound::FilterLeastSquaresFIR::setKernel(), sr, and subbuffer().

Referenced by getResample().

{
//~    cout << "\tL=" << L << "\tM=" << M << endl;

    if(L == 1 && M == 1)
    {
        return *this;
    }

    if( (L == 0)           ||
        (M == 0)           ||
        (N == 0)           ||
        (beta < 0.0))
    {
        cerr << __FILE__ << ":" << __LINE__
             << "::getResample(): bad parameters"
             << endl;

        return *this;
    }

    uint32 LMmax = (L > M) ? L : M;

    float64 fc = 1.0 / 2.0 / static_cast<float64>(LMmax);

    // ensure kernel length is a multiple of L
    uint32 Lh = 2 * N * LMmax;

    float64 sr = 1000.0; // arbitrary, but usefull if the filter is plotted.

    Buffer f(4);
    Buffer a(4);

    f << 0.0 << sr*fc  << sr*fc  << sr*0.5;
    a << 1.0 << 1.0 << 0.0 << 0.0;

    FilterLeastSquaresFIR lpf(sr, Lh, f, a, beta);

    uint32 delay = (Lh-1)/2;

    // Create Polyphase filter bank if interpolating
    std::vector<FilterLeastSquaresFIR> bank;
    if(L > 1)
    {
        // Get the kernel.
        Buffer h = lpf.getKernel();

        Buffer pseudo_f(2);
        Buffer pseudo_a(2);

        pseudo_f << 0.0 << 0.5;
        pseudo_a << 0.0 << 0.0;

        for(uint32 i = 0; i < L; ++i)
        {
            FilterLeastSquaresFIR poly_f(1.0, L, pseudo_f, pseudo_a, beta);

            Buffer poly_h(Lh/L);

            // Pull out cooefficents for the polyphase filter
            for(uint32 j = Lh-L; j >= 0 && j < Lh; j -= L)
            {
                poly_h << h[j+i];
            }

            poly_f.setKernel(poly_h.getReverse());

            bank.push_back(poly_f);
        }
    }

    uint32 n_filters = bank.size();

    // Interpolation

    Buffer::const_iterator x     = data_.begin();
    Buffer::const_iterator x_end = data_.end();

    uint32 Lx = getLength();
    uint32 Ly = getLength() * L / M;

    Buffer y(Ly);

    if(L > 1)
    {
//~        cerr << "Interpolation by " << L << endl << flush;

        float64 scale = static_cast<float64>(L);

        // Loop over all the samples
        while(x != x_end)
        {
            // Polyphase filter the input, for all L-1 samples
            for(uint32 j = 0; j < L; ++j)
            {
                float64 sample = *x * scale;

                for(uint32 k = 0; k < n_filters; ++k)
                {
                    y << bank[k].filter(sample);
                }
                ++x;
                if(x == x_end) break;
            }

            // Add some samples to the end for filter delay compansation.
            if(x == x_end)
            {
                float64 x_n = data_[Lx - 1] * scale;

                for(uint32 j = 0; j < Lh/L; ++j)
                {
                    for(uint32 k = 0; k < n_filters; ++k)
                    {
                        y << bank[k].filter(x_n);
                    }
                }
                break;
            }
        }
    }

    // Only down sampling, still need to filter.
    else
    {
        for(uint32 i = 0; i < Lx; ++i)
        {
            y << lpf.filter(data_[i]);
        }

        // Add some samples to the end for filter delay compansation.
        float64 x_n = data_[Lx - 1];
        for(uint32 i = 0; i < Lh; ++i)
        {
            y << lpf.filter(x_n);
        }
    }

    // Compensate for filter delay.
    y = y.subbuffer(delay, Lx*L);

    // Decimation
    if(M > 1)
    {
//~        cerr << "Decimation by " << M << endl << flush;

        x     = y.begin();
        x_end = y.end();

        Buffer y2(Ly / M);

        uint32 i = 0;
        while(x != x_end)
        {
            if(i % M == 0)
            {
                y2 << *x;
            }

            ++x;
            ++i;
        }

        y = y2;
    }

    return y;
}

Buffer & Buffer::vectorOperator	(	const Buffer &	rhs,
		MathOperator	op
	)			[protected]

Definition at line 1284 of file Buffer.cc.

References ADD, begin(), DIVIDE, end(), MULTIPLY, POW, and SUBTRACT.

Referenced by operator*=(), operator+=(), operator-=(), operator/=(), and operator^=().

{
    Buffer::iterator lhs = this->begin();
    Buffer::iterator lhs_end = this->end();

    Buffer::const_iterator rhs = rhs_buffer.begin();
    Buffer::const_iterator rhs_end = rhs_buffer.end();

    switch(op)
    {
        case ADD:
        {
            while(lhs != lhs_end && rhs != rhs_end)
            {
                *lhs += *rhs;

                ++lhs;
                ++rhs;
            }
            break;
        }
        case SUBTRACT:
        {
            while(lhs != lhs_end && rhs != rhs_end)
            {
                *lhs -= *rhs;

                ++lhs;
                ++rhs;
            }
            break;
        }
        case MULTIPLY:
        {
            while(lhs != lhs_end && rhs != rhs_end)
            {
                *lhs *= *rhs;

                ++lhs;
                ++rhs;
            }
            break;
        }
        case DIVIDE:
        {
            while(lhs != lhs_end && rhs != rhs_end)
            {
                *lhs /= (*rhs +1e-20)  ;  // avoid dividing by zero.

                ++lhs;
                ++rhs;
            }
            break;
        }
        case POW:
        {
            while(lhs != lhs_end && rhs != rhs_end)
            {
                *lhs = ::pow(*lhs, *rhs);

                ++lhs;
                ++rhs;
            }
            break;
        }
    }

    return *this;
}

Buffer & Buffer::scalarOperator	(	const float64 &	d,
		MathOperator	op
	)			[protected]

Definition at line 1408 of file Buffer.cc.

References ADD, data_, DIVIDE, end(), MULTIPLY, POW, and SUBTRACT.

Referenced by operator*=(), operator+=(), operator-=(), operator/=(), and operator^=().

{
    std::vector<float64>::iterator lhs = data_.begin();
    std::vector<float64>::iterator end = data_.end();

    switch(op)
    {
        case ADD:
        {
            while(lhs != end)
            {
                *lhs += d;
                ++lhs;
            }
            break;
        }
        case SUBTRACT:
        {
            while(lhs != end)
            {
                *lhs -= d;
                ++lhs;
            }
            break;
        }
        case MULTIPLY:
        {
            while(lhs != end)
            {
                *lhs *= d;
                ++lhs;
            }
            break;
        }
        case DIVIDE:
        {
            while(lhs != end)
            {
                *lhs /= (d + 1e-16);  // avoid dividing by zero.
                ++lhs;
            }
            break;
        }
        case POW:
        {
            while(lhs != end)
            {
                *lhs = ::pow(*lhs, d);
                ++lhs;
            }
            break;
        }
    }

    return *this;
}

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	out,
		const Buffer &	rhs
	)			[friend]

Sends the contents of the Buffer to the output stream.

---

Member Data Documentation

FloatVector Nsound::Buffer::data_ [protected]

Definition at line 2016 of file Buffer.h.

Referenced by abs(), add(), begin(), Buffer(), cbegin(), derivative(), end(), exp(), findPeaks(), get_at_index(), getLength(), getMax(), getMaxMagnitude(), getMin(), getNBytes(), getPointer(), getResample_(), getSignalEnergy(), getSum(), log(), log10(), operator!=(), Nsound::operator<<(), operator<<(), operator<<=(), operator=(), operator==(), operator[](), preallocate(), reverse(), scalarOperator(), set_at_index(), speedUp(), and subbuffer().

const uint32 Nsound::Buffer::bytes_per_sample_ = sizeof(float64) [static, protected]

Definition at line 2018 of file Buffer.h.

Referenced by getNBytes().

---

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

• Nsound/Buffer.h
• Nsound/Buffer.cc