Nsound::Buffer Class Reference

A Buffer for storing audio samples. More...

#include <Nsound/Buffer.h>

Public Types
typedef Nsound::circular_iterator	circular_iterator
typedef Nsound::const_circular_iterator	const_circular_iterator
typedef FloatVector::iterator	iterator
typedef FloatVector::const_iterator	const_iterator

Public Member Functions
	Buffer ()
	Creates an empty Buffer that also calss std::vector::reserve() to preallocate memory for samples. More...
	Buffer (uint32 chunk_size)
	Buffer (const FloatVector &list)
	Creates a Buffer and fills it with the contents of list. More...
	Buffer (const std::string &filename, uint32 chunk_size=4096)
	Creates an Buffer from a Wavefile, also specifies the chunk size. More...
	~Buffer ()
	Destroys the Buffer. More...
	Buffer (const Buffer &rhs)
	Copy constructor, must be used in Python to copy Buffers. More...
	Buffer (Buffer &&move)
void	abs ()
	Modifies the Buffer by making any negative value positive. More...
Buffer	getAbs () const
	Modifies a copy of the Buffer by making any negative value positive. More...
void	add (const Buffer &buffer, uint32 offset=0, uint32 n_samples=0)
	This method adds buffer to *this. More...
uint32	argmax () const
	Retruns the index of the maximum value in the Buffer. More...
uint32	argmin () const
	Retruns the index of the minimum value in the Buffer. More...
iterator	begin ()
	Retruns the itreator at the start of the Buffer. More...
const_iterator	begin () const
	Retruns the itreator at the start of the Buffer. More...
circular_iterator	cbegin ()
	Retruns the itreator at the start of the Buffer. More...
const_circular_iterator	cbegin () const
	Retruns the itreator at the start of the Buffer. More...
iterator	end ()
	Retruns the itreator at the end of the Buffer. More...
const_iterator	end () const
	Retruns the itreator at the end of the Buffer. More...
uint32	getNBytes () const
	Retruns the number of bytes held in the Buffer array. More...
void	exp ()
	Each sample in the Buffer becomes the power e^x. More...
Buffer	getExp () const
	Each sample in the Buffer becomes the power e^x. More...
void	convolve (const Buffer &H)
	Convolves the Buffer with another Buffer. More...
Buffer	getConvolve (const Buffer &H) const
	Convolves a copy of the Buffer with another Buffer. More...
void	dB ()
	Modifies the Buffer so each sample is converted to dB, 20 * log10(sample). More...
Buffer	getdB () const
	Returns the Buffer in dB. More...
void	derivative (uint32 n)
	Calculates the nth derivative of the Buffer. More...
Buffer	getDerivative (uint32 n) const
	Returns the nth derivative of the Buffer. More...
void	downSample (uint32 n)
	Downsample this Buffer by a integral factor. N must be > 1. More...
Buffer	getDownSample (uint32 n) const
	Returns a copy of this Buffer downsampled by a integral factor. N must be > 1. More...
Uint32Vector	findPeaks (uint32 window_size=0, float64 min_height=0.0) const
	Find the peaks in the Buffer and return a vector of indicies. More...
uint32	getLength () const
	Returns the number of samples in the Buffer. More...
void	limit (float64 min, float64 max)
	Limits the Buffer to min and max. More...
void	limit (const Buffer &min, const Buffer &max)
	Limits the Buffer to min and max. More...
Buffer	getLimit (float64 min, float64 max) const
	Returns a copy of the Buffer with min and max limits. More...
Buffer	getLimit (const Buffer &min, const Buffer &max) const
	Returns a copy of the Buffer with min and max limits. More...
void	log ()
	Sets each sample in the Buffer to the natural log. More...
Buffer	getLog () const
	Returns the the Buffer where each sample is the natural log. More...
void	log10 ()
	Sets each sample in the Buffer to log base 10. More...
Buffer	getLog10 () const
	Returns the the Buffer where each sample is the natural log. More...
float64	getMax () const
	Returns the maximum sample value in the Buffer. More...
float64	getMaxMagnitude () const
	Returns the maximum magnitude value in the Buffer, i.e. max(abs(samples)). More...
float64	getMean () const
	Returns the mean sample value in the Buffer. More...
float64	getMin () const
	Returns the minimum sample value in the Buffer. More...
void	mul (const Buffer &buffer, uint32 offset=0, uint32 n_samples=0)
	This method multiplies a Buffer to *this over a sub range. More...
void	normalize ()
	Multiplies the Buffer by a constant gain so the peak sample has magnitude 1.0. More...
Buffer	getNormalize () const
	Returns a copy of the Buffer normalized. More...
Buffer	getSignalEnergy (uint32 window_size) const
	Returns the signal energy: E = 1 / N * sum(|x(i)|) over the window of N samples. More...
float64	getStd () const
	Returns the standard deviation of the Buffer. More...
float64	getSum () const
	Returns the sum of all samples. More...
void	zNorm ()
	Normalized the Buffer using Z score normalizing. More...
Buffer	getZNorm () const
	Returns a Z score normalized copy of the Buffer. More...
BufferSelection	operator() (const BooleanVector &bv)
	Returns a BufferSelection object used for manipulation of a selected region of samples. More...
Buffer &	operator= (const Buffer &rhs)
	The assignment operator. C++ only, for Python, use the copy constructor. More...
boolean	operator== (const Buffer &rhs) const
	Tests of equality. More...
boolean	operator!= (const Buffer &rhs) const
	Tests of inequality. More...
float64 &	operator[] (uint32 index)
	Retruns a reference into the Buffer. More...
const float64 &	operator[] (uint32 index) const
	Returns a const reference into the Buffer. More...
Buffer &	operator<< (const AudioStream &rhs)
	Concatenates Buffers and AudioStreams together. More...
Buffer &	operator<< (const Buffer &rhs)
	Concatenates Buffers together. More...
Buffer &	operator<< (float64 d)
	Concatenates samples to the Buffer. More...
Buffer &	operator+= (const Buffer &rhs)
	Adds each sample from the right hand side (rhs) Buffer with this Buffer. More...
Buffer &	operator-= (const Buffer &rhs)
	Subracts each sample from the right hand side (rhs) Buffer from this Buffer. More...
Buffer &	operator*= (const Buffer &rhs)
	Multiplies each sample from the right hand side (rhs) with this Buffer. More...
Buffer &	operator/= (const Buffer &rhs)
	Divides each sample in this Buffer with the right hand side (rhs) Buffer. More...
Buffer &	operator^= (const Buffer &powers)
	Each sample in the Buffer becomes the power x^n. More...
Buffer &	operator+= (float64 d)
	Adds the sample d to each sample in this Buffer. More...
Buffer &	operator-= (float64 d)
	Subtracts the sample d from each sample in this Buffer. More...
Buffer &	operator*= (float64 d)
	Multiplies the sample d with each sample in this Buffer. More...
Buffer &	operator/= (float64 d)
	Divides each sample in this Buffer by d. More...
Buffer &	operator^= (float64 power)
	Each sample in the Buffer becomes the power x^n. More...
BooleanVector	operator> (float64 rhs)
	Creates a BooleanVector where each value is true iff Buffer[n] > rhs. More...
BooleanVector	operator>= (float64 rhs)
	Creates a BooleanVector where each value is true iff Buffer[n] >= rhs. More...
BooleanVector	operator< (float64 rhs)
	Creates a BooleanVector where each value is true iff Buffer[n] < rhs. More...
BooleanVector	operator<= (float64 rhs)
	Creates a BooleanVector where each value is true iff Buffer[n] <= rhs. More...
BooleanVector	operator== (float64 rhs)
	Creates a BooleanVector where each value is true iff Buffer[n] == rhs. More...
BooleanVector	operator!= (float64 rhs)
	Creates a BooleanVector where each value is true iff Buffer[n] != rhs. More...
void	plot (const std::string &title="Buffer") const
	Requires matplotlib. Creates a plot of this Buffer. More...
const float64 *	getPointer () const
	Returns the raw point to the first sample in the Buffer. More...
float64 *	getPointer ()
	Requires matplotlib. Creates a plot of this Buffer. More...
void	preallocate (uint32 n)
	Preallocates memory to hold an additional n samples. More...
void	readWavefile (const char *filename)
	Sets this Buffer to the contents of the wavefile on the disk. More...
void	resample (float64 factor)
	Resamples this Buffer using discrete-time resampling. More...
void	resample (const Buffer &factor)
	Resamples this Buffer using discrete-time resampling. More...
Buffer	getResample (float64 factor, const uint32 N=10, float64 beta=5.0) const
	Resamples a copy of this Buffer using discrete-time resampling. More...
Buffer	getResample (const Buffer &factor, const uint32 N=10, float64 beta=5.0) const
	Resamples a copy of this Buffer using discrete-time resampling. More...
Buffer	getResample (const uint32 L, const uint32 M, const uint32 N=10, float64 beta=5.0) const
	Resamples a copy of this Buffer using discrete-time resampling. More...
void	reverse ()
	Reverses the samples in this Buffer. More...
Buffer	getReverse () const
	Reverses the samples in a copy of this Buffer. More...
void	round ()
	Rounds the samples in this Buffer to the nearest integer value. More...
Buffer	getRound () const
	Rounds the samples in a copy of this Buffer to the nearest integer value. More...
BufferSelection	select (const uint32 start_index, const uint32 stop_index)
	Returns a BufferSelection for the range of indicies. More...
std::ostream &	write (std::ostream &out) const
	Serializes the Buffer to output stream, no endian checks. More...
std::string	write () const
std::istream &	read (std::istream &stream_in)
	Constructs a Buffer from seralized data in the inputstream. More...
void	read (const std::string &string_in)
void	smooth (uint32 n_passes, uint32 n_samples_per_average)
	Applies a moving average filter to smooth this Buffer. More...
Buffer	getSmooth (uint32 n_passes, uint32 n_samples_per_average) const
	Applies a moving average filter to smooth a copy of this Buffer. More...
void	speedUp (float64 step_size)
	Resamples this Buffer by the step_size, no interpolation. More...
Buffer	getSpeedUp (float64 step_size) const
	Resamples a copy of this Buffer by the step_size, no interpolation. More...
void	speedUp (const Buffer &step_size)
	Resamples this Buffer on a sample by sample basis, no interpolation. More...
Buffer	getSpeedUp (const Buffer &step_size) const
	Resamples a copy of this Buffer on a sample by sample basis, no interpolation. More...
void	sqrt ()
	Takes the square root of each sample in this Buffer. More...
Buffer	getSqrt () const
	Taks the square root of each sample in a copy of this Buffer. More...
Buffer	subbuffer (uint32 start_index, uint32 n_samples=0) const
	Slice the Buffer. More...
void	upSample (uint32 n)
	Upsample this Buffer by a integral factor. N must be > 1. More...
Buffer	getUpSample (uint32 n) const
	Upsample a copy of this Buffer by a integral factor. N must be > 1. More...
void	writeWavefile (const char *filename) const
	Writes the Buffer to a Wavefile. More...
void	_set_at_index (int32 index, float64 x)
	SWIG helper function function to shadow. More...
void	_swig_shadow ()
	SWIG helper function function to shadow. More...

Static Public Member Functions
static Buffer	ones (const uint32 n_samples)
	Returns a Buffer full of ones of length n_samples. More...
static Buffer	rand (const uint32 n_samples)
	Returns a Buffer full of random values of length n_samples. More...
static Buffer	zeros (const uint32 n_samples)
	Returns a Buffer full of zeros of length n_samples. More...

Protected Member Functions
Buffer	_get_resample (const uint32 L, const uint32 M, const uint32 N, float64 beta) const

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)
	Sends the contents of the Buffer to the output stream. More...

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 60 of file Buffer.h.

Member Typedef Documentation

typedef Nsound::circular_iterator Nsound::Buffer::circular_iterator

Definition at line 66 of file Buffer.h.

typedef Nsound::const_circular_iterator Nsound::Buffer::const_circular_iterator

Definition at line 67 of file Buffer.h.

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

Definition at line 69 of file Buffer.h.

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

Definition at line 70 of file Buffer.h.

Constructor & Destructor Documentation

Nsound::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 62 of file Buffer.cc.

References data_.

    :
    data_()
{
    data_.reserve(4096);
}

Nsound::Buffer::Buffer ( uint32  chunk_size )

explicit

Definition at line 70 of file Buffer.cc.

References data_.

    :
    data_()
{
    data_.reserve(chunk_size);
}

Nsound::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 78 of file Buffer.cc.

    :
    data_(list) // Copies contents
{
}

Nsound::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_.

    :
    data_()
{
    data_.reserve(chunk_size);

    // This function is defined in Wavefile.h.
    *this << filename.c_str();
}

Nsound::Buffer::~Buffer

(

)

Destroys the Buffer.

Definition at line 112 of file Buffer.cc.

{
}

Nsound::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 96 of file Buffer.cc.

    :
    data_(copy.data_)
{
}

Nsound::Buffer::Buffer

(

Buffer &&

move

)

Definition at line 103 of file Buffer.cc.

References data_.

    :
    data_()
{
    std::swap(data_, move.data_);
}

Member Function Documentation

void Nsound::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 119 of file Buffer.cc.

References data_.

Referenced by 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 174 of file Buffer.h.

References abs().

Referenced by Buffer_UnitTest(), BufferResample_UnitTest(), FFTransform_UnitTest(), FilterLeastSquaresFIR_UnitTest(), and main().

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

void Nsound::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 225 of file Buffer.cc.

References data_, and getLength().

Referenced by 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 Nsound::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 460 of file Buffer.cc.

References begin(), and end().

Referenced by my_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 Nsound::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 485 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 285 of file Buffer.h.

References data_.

Referenced by _get_resample(), argmax(), argmin(), Nsound::FilterHighPassFIR::filter(), Nsound::FilterLowPassFIR::filter(), Nsound::Filter::filter(), Nsound::FilterStageIIR::filter(), Nsound::FilterBandRejectFIR::filter(), Nsound::FFTransform::ifft(), limit(), operator!=(), operator<(), operator<=(), operator==(), operator>(), operator>=(), round(), Nsound::EnvelopeAdsr::shape(), smooth(), and sqrt().

    { 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 303 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 318 of file Buffer.h.

References data_.

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

    { return circular_iterator(data_); }

const_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 333 of file Buffer.h.

References data_.

    { return const_circular_iterator(data_); }

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 348 of file Buffer.h.

References data_.

Referenced by _get_resample(), argmax(), argmin(), Nsound::FilterHighPassFIR::filter(), Nsound::FilterLowPassFIR::filter(), Nsound::Filter::filter(), Nsound::FilterStageIIR::filter(), Nsound::FilterBandRejectFIR::filter(), limit(), operator!=(), operator<(), operator<<(), operator<=(), operator==(), operator>(), operator>=(), round(), Nsound::EnvelopeAdsr::shape(), smooth(), and sqrt().

    { 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 363 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 380 of file Buffer.h.

References bytes_per_sample_, and data_.

    { return static_cast<uint32>(bytes_per_sample_ * data_.size()); }

void Nsound::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 510 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 417 of file Buffer.h.

References exp().

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

void Nsound::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 520 of file Buffer.cc.

References getConvolve().

{
    *this = getConvolve(H);
}

Buffer Nsound::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 527 of file Buffer.cc.

References getLength().

Referenced by convolve().

{
    // 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;
    }

//~    uint32 N = getLength() / 1000;

//~    printf("%6.2f", 0.0);

    // For each sample in this Buffer.
    for(uint32 i = 0; i < getLength(); ++i)
    {
//~        // DEBUG
//~        if(i % N == 0)
//~        {
//~            float64 p_done = 100.0 * i / float64(getLength());
//~            printf("\b\b\b\b\b\b%6.2f", p_done);
//~            fflush(stdout);
//~        }

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

//~    printf("\b\b\b\b\b\b%6.2f\n", 100.0);

    return y;
}

void Nsound::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 567 of file Buffer.cc.

References log10().

Referenced by 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 487 of file Buffer.h.

References dB().

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

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

void Nsound::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 592 of file Buffer.cc.

References data_.

Referenced by 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 518 of file Buffer.h.

References derivative().

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

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

void Nsound::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 605 of file Buffer.cc.

References getDownSample().

{
    *this = getDownSample(n);
}

Buffer Nsound::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 615 of file Buffer.cc.

References getResample(), and M_ASSERT_VALUE.

Referenced by downSample().

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

Uint32Vector Nsound::Buffer::findPeaks	(	uint32	window_size = 0,
		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 623 of file Buffer.cc.

References data_, and getLength().

{
    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 587 of file Buffer.h.

References data_.

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

    { return static_cast<uint32>(data_.size()); }

void Nsound::Buffer::limit	(	float64	min,
		float64	max
	)

Limits the Buffer to min and max.

Example:

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

// alternate expressions

b1(b1 >  1.0) = 1.0
b1(b1 < -1.0) = -1.0

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

# alternalte expressions

b1(b1 >  1.0).set(1.0)
b1(b1 < -1.0).set(-1.0)

Definition at line 876 of file Buffer.cc.

References begin(), and end().

Referenced by getLimit(), 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 Nsound::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 896 of file Buffer.cc.

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

{
    Buffer::const_circular_iterator imin = min.cbegin();
    Buffer::const_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 ( float64  min, 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 649 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 670 of file Buffer.h.

References limit().

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

void Nsound::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 923 of file Buffer.cc.

References data_, getLength(), and LM_MAX.

Referenced by getLog().

{
    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 701 of file Buffer.h.

References log().

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

void Nsound::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 936 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 732 of file Buffer.h.

References log10().

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

float64 Nsound::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 951 of file Buffer.cc.

References data_, and M_ASSERT_VALUE.

Referenced by Buffer_UnitTest(), BufferResample_UnitTest(), Nsound::Generator::buzz(), DelayLine_UnitTest(), FFTransform_UnitTest(), Nsound::FilterBandPassIIR::FilterBandPassIIR(), FilterCombLowPassFeedback_UnitTest(), FilterLeastSquaresFIR_UnitTest(), FilterParametricEqualizer_UnitTest(), Generator_UnitTest(), main(), Nsound::Filter::plot(), Nsound::FilterIIR::savePlot(), Sine_UnitTest(), and Triangle_UnitTest().

{
    M_ASSERT_VALUE(data_.size(), >=, 1);

    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 Nsound::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 973 of file Buffer.cc.

References data_, and M_ASSERT_VALUE.

Referenced by normalize().

{
    M_ASSERT_VALUE(data_.size(), >=, 1);

    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 Nsound::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 995 of file Buffer.cc.

References getLength(), and getSum().

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

{
    float64 sum = getSum();

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

float64 Nsound::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 1004 of file Buffer.cc.

References data_, and M_ASSERT_VALUE.

Referenced by Buffer_UnitTest(), main(), and Nsound::FilterLeastSquaresFIR::makeKernel().

{
    M_ASSERT_VALUE(data_.size(), >=, 1);

    float64 min = data_[0];

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

    return min;
}

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

This method multiplies a Buffer to *this over a sub range.

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.

Examples:

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

this = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa]
     * |  offset  |[bbbbbbbbb buffer bbbbbbbbbbbbbbbbbb]

     = [aaaaaaaaaaaccccccccccccccccc]

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

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

     = [aaaaaaaaaaacccccccccccccccaa]

Parameters

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

Example:

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

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

Definition at line 1025 of file Buffer.cc.

References getLength(), and M_ASSERT_VALUE.

{
    M_ASSERT_VALUE(offset, >=, 0);
    M_ASSERT_VALUE(offset, <, getLength());

    uint32 b0 = offset;
    uint32 b1 = 0;

    uint32 n = n_samples;

    if(n_samples == 0)
    {
        n = buffer.getLength();
    }

    b1 = b0 + n;

    if(b1 > getLength())
    {
        b1 = getLength();
        n = b1 - b0;
    }

    // Limit
    if(n > buffer.getLength())
    {
        b1 = b0 + buffer.getLength();
    }

    uint32 k = 0;
    for(uint32 i = b0; i < b1; ++i)
    {
        (*this)[i] *= buffer[k];
        ++k;
    }
}

void Nsound::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 1064 of file Buffer.cc.

References getMaxMagnitude().

Referenced by Nsound::Generator::drawGaussian(), FilterCombLowPassFeedback_UnitTest(), Nsound::Pluck::generate(), getNormalize(), main(), my_main(), and Nsound::DrumBD01::play().

{
    float64 peak = getMaxMagnitude();

    float64 scale = 1.0;

    if(peak != 0.0) scale = 1.0 / peak;

    *this *= scale;
}

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 885 of file Buffer.h.

References normalize().

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

Buffer Nsound::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 1077 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 Nsound::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 1107 of file Buffer.cc.

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

{
    Buffer diff = *this - getMean();

    diff ^= 2.0;

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

float64 Nsound::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 1118 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 Nsound::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 1134 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 965 of file Buffer.h.

References zNorm().

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

BufferSelection Nsound::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(b1 > 0.5);

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

Definition at line 1170 of file Buffer.cc.

{
    BufferSelection bs(*this, bv);

    return bs;
}

Buffer & Nsound::Buffer::operator=

(

const Buffer &

rhs

)

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

Definition at line 1156 of file Buffer.cc.

References data_.

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

    data_ = rhs_buffer.data_;

    return *this;
}

boolean Nsound::Buffer::operator==

(

const Buffer &

rhs

)

const

Tests of equality.

Definition at line 1179 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 Nsound::Buffer::operator!=

(

const Buffer &

rhs

)

const

Tests of inequality.

Definition at line 1199 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;
}

float64& Nsound::Buffer::operator[] ( uint32  index )

inline

Retruns a reference into the Buffer.

Definition at line 998 of file Buffer.h.

References data_.

    { return data_[index]; }

const float64& Nsound::Buffer::operator[] ( uint32  index ) const

inline

Returns a const reference into the Buffer.

Definition at line 1004 of file Buffer.h.

References data_.

    { return data_[index]; }

Buffer & Nsound::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 1219 of file Buffer.cc.

References Nsound::AudioStream::getMono().

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

Buffer & Nsound::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 1226 of file Buffer.cc.

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

{
    if(this == & rhs_buffer)
    {
        uint32 size = getLength();

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

        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& Nsound::Buffer::operator<< ( float64  d )

inline

Concatenates samples to the Buffer.

Definition at line 1044 of file Buffer.h.

References data_.

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

Buffer & Nsound::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 1254 of file Buffer.cc.

References data_, and getLength().

{
    std::size_t N = std::min(getLength(), rhs.getLength());
    for(std::size_t i = 0; i < N; ++i) data_[i] += rhs.data_[i];
    return *this;
}

Buffer & Nsound::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 1263 of file Buffer.cc.

References data_, and getLength().

{
    std::size_t N = std::min(getLength(), rhs.getLength());
    for(std::size_t i = 0; i < N; ++i) data_[i] -= rhs.data_[i];
    return *this;
}

Buffer & Nsound::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 1272 of file Buffer.cc.

References data_, and getLength().

{
    std::size_t N = std::min(getLength(), rhs.getLength());
    for(std::size_t i = 0; i < N; ++i) data_[i] *= rhs.data_[i];
    return *this;
}

Buffer & Nsound::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 1281 of file Buffer.cc.

References data_, and getLength().

{
    std::size_t N = std::min(getLength(), rhs.getLength());
    for(std::size_t i = 0; i < N; ++i) data_[i] /= rhs.data_[i];
    return *this;
}

Buffer & Nsound::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 1290 of file Buffer.cc.

References data_, and getLength().

{
    std::size_t N = std::min(getLength(), rhs.getLength());
    for(std::size_t i = 0; i < N; ++i) data_[i] = std::pow(data_[i], rhs.data_[i]);
    return *this;
}

Buffer & Nsound::Buffer::operator+=

(

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 1299 of file Buffer.cc.

References data_.

{
    for(auto & x : data_) x += d;
    return *this;
}

Buffer & Nsound::Buffer::operator-=

(

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 1307 of file Buffer.cc.

References data_.

{
    for(auto & x : data_) x -= d;
    return *this;
}

Buffer & Nsound::Buffer::operator*=

(

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 1315 of file Buffer.cc.

References data_.

{
    for(auto & x : data_) x *= d;
    return *this;
}

Buffer & Nsound::Buffer::operator/=

(

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 1323 of file Buffer.cc.

References data_.

{
    for(auto & x : data_) x /= d;
    return *this;
}

Buffer & Nsound::Buffer::operator^=

(

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 1331 of file Buffer.cc.

References data_.

{
    for(auto & x : data_) x = std::pow(x, d);
    return *this;
}

BooleanVector Nsound::Buffer::operator>

(

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 2127 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 Nsound::Buffer::operator>=

(

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 2146 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 Nsound::Buffer::operator<

(

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 2165 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 Nsound::Buffer::operator<=

(

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 2184 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 Nsound::Buffer::operator==

(

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 2203 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 Nsound::Buffer::operator!=

(

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 2221 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 Nsound::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 1551 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(), FilterCombLowPassFeedback_UnitTest(), FilterLeastSquaresFIR_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 1382 of file Buffer.h.

References data_.

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

    { return data_.data(); }

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 1397 of file Buffer.h.

References data_.

    { return data_.data(); }

void Nsound::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 1544 of file Buffer.cc.

References data_.

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

void Nsound::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 1562 of file Buffer.cc.

References M_CHECK_PTR.

{
    M_CHECK_PTR(filename);

    *this << filename;
}

void Nsound::Buffer::resample ( 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 1446 of file Buffer.h.

References getResample().

Referenced by main().

    { *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 1467 of file Buffer.h.

References getResample().

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

Buffer Nsound::Buffer::getResample	(	float64	factor,
		const uint32	N = 10,
		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 1607 of file Buffer.cc.

References Nsound::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 Nsound::Buffer::getResample	(	const Buffer &	factor,
		const uint32	N = 10,
		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 1622 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 Nsound::Buffer::getResample	(	const uint32	L,
		const uint32	M,
		const uint32	N = 10,
		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 1653 of file Buffer.cc.

References _get_resample(), getLength(), Nsound::BufferWindowSearch::getNextWindow(), 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._get_resample(L,M,N,beta);
        }
    }
    else
    {
        y << _get_resample(L,M,N,beta);
    }

    return y;
}

void Nsound::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 1850 of file Buffer.cc.

References data_, and getLength().

Referenced by Buffer_UnitTest(), and getReverse().

{
    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 1558 of file Buffer.h.

References reverse().

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

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

void Nsound::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 1864 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 1593 of file Buffer.h.

References round().

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

BufferSelection Nsound::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 1897 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);
}

std::ostream & Nsound::Buffer::write

(

std::ostream &

out

)

const

Serializes the Buffer to output stream, no endian checks.

Parameters

out	the std::ostream to write bytes to

Definition at line 1922 of file Buffer.cc.

References data_, and getLength().

{
    out & 'b' & 'u' & 'f' & 'f' & getLength();

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

    return out;
}

std::string Nsound::Buffer::write

(

)

const

Definition at line 1936 of file Buffer.cc.

{
    std::stringstream ss;
    write(ss);
    return ss.str();
}

std::istream & Nsound::Buffer::read

(

std::istream &

stream_in

)

Constructs a Buffer from seralized data in the inputstream.

Parameters

in	the std::istream to read bytes from

Definition at line 1945 of file Buffer.cc.

References data_, and M_THROW.

Referenced by read().

{
    char id[4];
    uint32 size = 0;

    in & id[0] & id[1] & id[2] & id[3] & size;

    if(id[0] != 'b' || id[1] != 'u' || id[2] != 'f' || id[3] != 'f')
    {
        M_THROW("Did not find any Nsound Buffer data in input stream!");
    }

    data_.clear();
    data_.reserve(size);

    for(uint32 i = 0; i < size; ++i)
    {
        float64 d;
        in & d;
        data_.push_back(d);
    }

    return in;
}

void Nsound::Buffer::read

(

const std::string &

string_in

)

Definition at line 1972 of file Buffer.cc.

References read().

{
    std::stringstream ss(in);

    read(ss);
}

void Nsound::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 1981 of file Buffer.cc.

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

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

{
    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)
    {
        maf.reset();

        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 1672 of file Buffer.h.

References smooth().

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

void Nsound::Buffer::speedUp

(

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 2008 of file Buffer.cc.

References data_.

Referenced by getSpeedUp().

{
    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 ( 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 1707 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 Nsound::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 2024 of file Buffer.cc.

References getLength().

{
    Buffer new_buffer;

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

    uint32 step_buffer_index = 0;
    float64 step_size = 0.0;

    for(float64 i = 0.0; i < n_samples; i += step_size)
    {
        new_buffer << data_[static_cast<size_t>(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 1748 of file Buffer.h.

References speedUp().

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

void Nsound::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 2051 of file Buffer.cc.

References begin(), and end().

Referenced by getSqrt(), 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 1779 of file Buffer.h.

References sqrt().

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

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

Buffer Nsound::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 2073 of file Buffer.cc.

References data_, and getLength().

Referenced by _get_resample(), Buffer_UnitTest(), Nsound::Spectrogram::computeMagnitude(), Nsound::FFTransform::fft(), Nsound::FFTChunk::getImaginary(), Nsound::FFTChunk::getMagnitude(), Nsound::BufferWindowSearch::getNextWindow(), Nsound::FFTChunk::getPhase(), Nsound::Filter::getPhaseResponse(), Nsound::FFTChunk::getReal(), getResample(), Nsound::FFTransform::ifft(), Nsound::FilterLeastSquaresFIR::makeKernel(), my_main(), Nsound::Stretcher::overlapAdd(), Nsound::FFTChunk::plot(), Nsound::Stretcher::searchForBestMatch(), Nsound::Spectrogram::Spectrogram(), and Nsound::Triangle::Triangle().

{
    uint32 n = n_samples;

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

    Buffer new_buffer(n);

    if(start_index >= getLength())
        return new_buffer;

    uint32 stop_index = start_index + n;

    if(n == 0 || stop_index >= getLength())
    {
        stop_index = getLength();
    }

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

    return new_buffer;
}

void Nsound::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 2101 of file Buffer.cc.

References getUpSample().

{
    *this = getUpSample(n);
}

Buffer Nsound::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 2111 of file Buffer.cc.

References getResample().

Referenced by upSample().

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

void Nsound::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 2118 of file Buffer.cc.

References M_CHECK_PTR, and Nsound::operator>>().

{
    M_CHECK_PTR(filename);

    operator>>(*this, filename);
}

void Nsound::Buffer::_set_at_index	(	int32	index,
		float64	x
	)

SWIG helper function function to shadow.

Definition at line 1876 of file Buffer.cc.

References data_, getLength(), and M_THROW.

{
    int32 len = getLength();

    if(index >= 0 && index < len)
    {
        data_[index] = d;
    }
    else if(index < 0 && index >= -len)
    {
        data_[len + index] = d;
    }
    else
    {
        M_THROW(
            "IndexError: " << index << " is out of bounds (0 : " << len << ")");
    }
}

void Nsound::Buffer::_swig_shadow ( )

inline

SWIG helper function function to shadow.

Definition at line 1848 of file Buffer.h.

{}

Buffer Nsound::Buffer::ones ( const uint32  n_samples )

static

Returns a Buffer full of ones of length n_samples.

Definition at line 2239 of file Buffer.cc.

References Nsound::Generator::drawLine().

Referenced by Buffer_UnitTest(), and Nsound::AudioStream::pad().

{
    Buffer b(n_samples);

    Generator g(1);

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

    return b;
}

Buffer Nsound::Buffer::rand ( const uint32  n_samples )

static

Returns a Buffer full of random values of length n_samples.

Definition at line 2252 of file Buffer.cc.

References Nsound::Generator::whiteNoise().

{
    Buffer b(n_samples);

    Generator g(1);

    b << g.whiteNoise(n_samples);

    return b;
}

Buffer Nsound::Buffer::zeros ( const uint32  n_samples )

static

Returns a Buffer full of zeros of length n_samples.

Definition at line 2265 of file Buffer.cc.

References Nsound::Generator::drawLine().

Referenced by Nsound::Spectrogram::computeMagnitude(), 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 Nsound::Buffer::_get_resample ( const uint32  L, const uint32  M, const uint32  N, float64  beta  ) const

protected

Definition at line 1684 of file Buffer.cc.

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

Referenced by getResample().

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

    M_ASSERT_VALUE(L, !=, 0);
    M_ASSERT_VALUE(M, !=, 0);
    M_ASSERT_VALUE(N, !=, 0);
    M_ASSERT_VALUE(beta, >=, 0.0);

    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(int32 j = Lh - L; j >= 0 && j < static_cast<int32>(Lh); j -= L)
            {
                poly_h << h[j + i];
            }

            poly_f.setKernel(poly_h.getReverse());

            bank.push_back(poly_f);
        }
    }

    uint32 n_filters = static_cast<uint32>(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;
}

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.

Definition at line 1338 of file Buffer.cc.

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

    while(rhs != end)
    {
        out << *rhs << endl;
        ++rhs;
    }

    return out;
}

Member Data Documentation

FloatVector Nsound::Buffer::data_

protected

Definition at line 1874 of file Buffer.h.

Referenced by _get_resample(), _set_at_index(), abs(), add(), begin(), Buffer(), cbegin(), derivative(), end(), exp(), findPeaks(), getLength(), getMax(), getMaxMagnitude(), getMin(), getNBytes(), getPointer(), getSignalEnergy(), getSum(), log(), log10(), operator!=(), operator*=(), operator+=(), operator-=(), operator/=(), operator<<(), Nsound::operator<<(), operator=(), operator==(), operator[](), operator^=(), preallocate(), read(), reverse(), speedUp(), subbuffer(), and write().

const uint32 Nsound::Buffer::bytes_per_sample_ = sizeof(float64)

staticprotected

Definition at line 1876 of file Buffer.h.

Referenced by getNBytes().

---

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

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