#include <Nsound/Triangle.h>

Inheritance diagram for Nsound::Triangle:

Public Member Functions
	Triangle (const Nsound::float64 &sample_rate)

	Triangle (const Nsound::float64 &sample_rate, const Nsound::float64 &attack_time, const Nsound::float64 &release_time)
	Triangle with 2 points //. More...

	Triangle (const Nsound::float64 &sample_rate, const Nsound::float64 &percent_lambda_1, const Nsound::float64 &percent_lambda_2, const Nsound::float64 &amplitude_2, const Nsound::float64 &percent_lambda_3, const Nsound::float64 &percent_lambda_4, const Nsound::float64 &percent_lambda_5, const Nsound::float64 &amplitude_5, const Nsound::float64 &percent_lambda_6)
	Triangle with 6 points //. More...

void	setRealtime (bool flag)
	Sets realtime mode, disables automatic reset() if set. More...

void	addSlaveSync (Generator &slave)
	Adds a generator as a slave to this instance for syncing. More...

void	buzzInit (const uint32 &max_harmonics)
	Initaializes Buzz settings for real-time calls. More...

float64	buzz (const float64 &frequency, const float64 &n_harmonics, const float64 &delay)
	Returns sample from a set of harmonics. Based on the Csound buzz opcode. More...

Buffer	buzz (const float64 &duration, const float64 &frequency, const float64 &n_harmonics, const float64 &delay)
	Returns a set of harmonics. Based on the Csound buzz opcode. More...

Buffer	buzz (const float64 &duration, const Buffer &frequency, const Buffer &n_harmonics, const Buffer &delay)
	Returns a set of harmonics. Based on the Csound buzz opcode. More...

void	setChorus (const uint32 n_voices, const float64 &sigma=0.02)
	Chorus or Unison. More...

Buffer	drawDecay (const float64 &duration, const float64 &alpha=2.0 *M_PI) const
	This method draws an exponential curve that decays from 1.0 to 0.0 over the duration. More...

Buffer	drawGaussian (const float64 &duration, const float64 &mu, const float64 &sigma, const boolean &normalize=true) const
	This method draws a Gaussian curve over duration seconds. More...

Buffer	drawFatGaussian (const float64 &duration, const float64 &pass_band_percent=0.01) const
	This method draws a standard Gaussian curve over duration seconds, with a specified pass band. More...

Buffer	drawLine (const float64 &duration, const float64 &amplitude_start, const float64 &amplitude_finish) const
	This method draws a linear line beteween 2 points. More...

Buffer	drawParabola (const float64 &duration, const float64 &y1, const float64 &x2, const float64 &y2, const float64 &y3) const
	This method draws a parabola between three points, intersecting the middle point. More...

Buffer	drawSine (const float64 &duration, const float64 &frequency)
	This method draws a static sine wave. More...

Buffer	drawSine (const float64 &duration, const Buffer &frequency)
	This method draws a dynamic sine wave. More...

float64	drawSine (const float64 &frequency)
	This method draws one sample of a sine wave in real-time. More...

Buffer	drawSine2 (const float64 &duration, const float64 &frequency, const float64 &phase)
	This method draws a static sine wave. More...

Buffer	drawSine2 (const float64 &duration, const Buffer &frequency, const Buffer &phase)
	This method draws a dynamic sine wave. More...

Buffer	drawSine2 (const float64 &duration, const Buffer &frequency, const float64 &phase=0.0)
	This method draws a dynamic sine wave. More...

Buffer	drawSine2 (const float64 &duration, const float64 &frequency, const Buffer &phase)
	This method draws a dynamic sine wave. More...

float64	drawSine2 (const float64 &frequency, const float64 &phase)
	This method draws one sample of a sine wave in real-time. More...

Buffer	drawWindow (const float64 &duration, WindowType type) const
	Draws a window of the specified type. More...

Buffer	drawWindowBartlett (const float64 &duration) const
	Draws a Bartlett window. More...

Buffer	drawWindowBlackman (const float64 &duration) const
	Draws a Blackman window. More...

Buffer	drawWindowBlackmanHarris (const float64 &duration) const
	Draws a Blackman-Harris window. More...

Buffer	drawWindowHamming (const float64 &duration) const
	Draws a Hamming window. More...

Buffer	drawWindowHanning (const float64 &duration) const
	Draws a Hanning window. More...

Buffer	drawWindowKaiser (const float64 &duration, const float64 &beta=5.0) const
	Draws a Kaiser window. More...

Buffer	drawWindowNuttall (const float64 &duration) const
	Draws a Nuttall window. More...

Buffer	drawWindowParzen (const float64 &duration) const
	Draws a Parzen window. More...

Buffer	drawWindowRectangular (const float64 &duration) const
	Draws a rectangular window. More...

virtual float64	generate (const float64 &frequency)
	This is a real-time method for the wavetable oscillator. More...

virtual Buffer	generate (const float64 &duration, const float64 &frequency)
	This method oscillates the waveform stored in this generator. More...

virtual Buffer	generate (const float64 &duration, const Buffer &frequencies)
	This method oscillates the waveform stored in this generator. More...

virtual float64	generate2 (const float64 &frequency, const float64 &phase)
	This is a real-time method for the wavetable oscillator. More...

virtual Buffer	generate2 (const float64 &duration, const float64 &frequency, const float64 &phase)
	This method oscillates the waveform stored in this generator. More...

virtual Buffer	generate2 (const float64 &duration, const float64 &frequencies, const Buffer &phase)
	This method oscillates the waveform stored in this generator. More...

virtual Buffer	generate2 (const float64 &duration, const Buffer &frequencies, const float64 &phase)
	This method oscillates the waveform stored in this generator. More...

virtual Buffer	generate2 (const float64 &duration, const Buffer &frequencies, const Buffer &phase)
	This method oscillates the waveform stored in this generator. More...

void	removeSlaveSync (Generator &slave)
	Removes the generator from the sync list. More...

virtual void	reset ()
	Resets the position pointer back to the begging of the waveform. More...

RandomNumberGenerator &	getRandomNumberGenerator ()

void	setSeed (const uint32 seed)
	Sets the seed for the Generator's random number generator (rng). More...

Buffer	silence (const float64 &duration) const
	This method generates silence. More...

float64	tell () const
	Returns the current position pointer, values are between 0.0 to 1.0. More...

Buffer	whiteNoise (const float64 &duration) const
	This method generates noise from a uniform distribution. More...

Buffer	gaussianNoise (const float64 &duration, const float64 &mu, const float64 &sigma) const
	This method generates noise from a Gaussian distribution. More...

Buffer	tanh (const float64 &duration) const
	This method draws the tanh function accross duration samples. More...

Protected Member Functions
virtual void	ctor (const float64 &sample_rate)
	DOXME. More...

virtual void	ctor (const float64 &sample_rate, const Buffer &wavetable)
	DOXME. More...

Protected Attributes
bool	is_realtime_

float64	last_frequency_

float64	position_
	Used for phase offset adjustment. More...

float64	sync_pos_
	The number of samples into the wavefrom. More...

float64	sample_rate_
	Used to determine when to create a sync sample. More...

float64	sample_time_
	The number of samples per second to generate. More...

float64	t_
	The time step between samples in seconds. More...

Buffer *	waveform_
	The current time (for real time draw functions.) More...

RandomNumberGenerator *	rng_
	The waveform to ossicialate. More...

uint32	buzz_max_harmonics_
	The random number generator. More...

std::vector< float64 >	buzz_position_

boolean	chorus_is_on_

uint32	chorus_n_voices_

std::vector< float64 >	chorus_position_

std::vector< float64 >	chorus_factor_

boolean	sync_is_master_

boolean	sync_is_slave_
	Indicates if this generator is the master. More...

uint32	sync_count_
	Indicates if this generator is a slave. More...

std::vector< uint32 >	sync_vector_
	Indicates the number of samples since reset. More...

std::set< Generator * >	sync_slaves_
	Stores sample counts when synced. More...

Detailed Description

Triangle generator.

Definition at line 48 of file Triangle.h.

Constructor & Destructor Documentation

Triangle::Triangle ( const Nsound::float64 & sample_rate )

Definition at line 41 of file Triangle.cc.

References Nsound::Generator::ctor(), Nsound::Generator::drawLine(), Nsound::Buffer::getLength(), and Nsound::Buffer::subbuffer().

                                       : Generator(sample_rate)
 {
     float64 third = 1.0/3.0;
 
     Buffer waveform;
 
     waveform << drawLine(third, 0.0, 1.0);
     waveform << drawLine(third, 1.0, -1.0);
     waveform << drawLine(third, -1.0, 0.0);
 
     uint32 n = static_cast<uint32>(sample_rate);
 
     // Pad if necessary.
     while(waveform.getLength() < n) waveform << 0.0;
 
     // Throw away if necessary.
     if(waveform.getLength() > n)
     {
         waveform = waveform.subbuffer(0, n);
     }
 
     ctor(sample_rate, waveform);
 }

Triangle::Triangle	(	const Nsound::float64 &	sample_rate,
		const Nsound::float64 &	attack_time,
		const Nsound::float64 &	release_time
	)

Triangle with 2 points //.

/\ // / \ // / \ // / \ // / \ release // / \ |--—| // |---—| \ / // attack \ / // \ / // \ / // \/ // // //

Definition at line 66 of file Triangle.cc.

References Nsound::Generator::ctor(), Nsound::Generator::drawLine(), and M_ASSERT_VALUE.

                                   : Generator(sample_rate)
 {
     M_ASSERT_VALUE(attack_time, >=, 0);
     M_ASSERT_VALUE(release_time, >=, 0);
     M_ASSERT_VALUE(1.0 - attack_time - release_time, >, 0);
 
     Buffer waveform;
 
     if(attack_time > 0)
     {
         waveform <<  drawLine(attack_time, 0, 1.0);
     }
 
     waveform << drawLine(1.0 - attack_time - release_time, 1.0, -1.0);
 
     if(release_time > 0)
     {
         waveform << drawLine(release_time, -1.0, 0.0);
     }
 
     ctor(sample_rate, waveform);
 }

Triangle::Triangle	(	const Nsound::float64 &	sample_rate,
		const Nsound::float64 &	percent_lambda_1,
		const Nsound::float64 &	percent_lambda_2,
		const Nsound::float64 &	amplitude_2,
		const Nsound::float64 &	percent_lambda_3,
		const Nsound::float64 &	percent_lambda_4,
		const Nsound::float64 &	percent_lambda_5,
		const Nsound::float64 &	amplitude_5,
		const Nsound::float64 &	percent_lambda_6
	)

Triangle with 6 points //.

2 // /\ // / \ // / \ // / \ // –1 3–4 6– // \ / // \ / // \ / // \ / // \/ // 5 // // |-------—lambda-------—| //

Definition at line 162 of file Triangle.cc.

References Nsound::Generator::ctor(), and drawTriangle().

                                       : Generator(sample_rate)
 {
     //         2                        //
     //        /\                        //
     //       /  \                       //
     //      /    \                      //
     //     /      \                     //
     //  --1        3--4          6--    //
     //                 \        /       //
     //                  \      /        //
     //                   \    /         //
     //                    \  /          //
     //                     \/           //
     //                      5           //
     //                                  //
     //  |----------lambda----------|    //
 
     Buffer waveform = drawTriangle(
         sample_rate,
         percent_lambda_1,
         percent_lambda_2,
         amplitude_2,
         percent_lambda_3,
         percent_lambda_4,
         percent_lambda_5,
         amplitude_5,
         percent_lambda_6);
 
     ctor(sample_rate, waveform);
 }

Member Function Documentation

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

inlineinherited

Sets realtime mode, disables automatic reset() if set.

Definition at line 72 of file Generator.h.

References Nsound::Generator::is_realtime_.

72 { is_realtime_ = flag; }

Nsound::Generator::is_realtime_

bool is_realtime_

Definition: Generator.h:611

void Generator::addSlaveSync ( Generator & slave )

inherited

Adds a generator as a slave to this instance for syncing.

Definition at line 237 of file Generator.cc.

References Nsound::Generator::reset(), Nsound::Generator::sync_is_master_, Nsound::Generator::sync_is_slave_, and Nsound::Generator::sync_slaves_.

Referenced by main().

 {
     sync_is_master_ = true;
     slave.sync_is_slave_ = true;
 
     if(sync_slaves_.count(&slave) == 0)
     {
         sync_slaves_.insert(&slave);
     }
 
     reset();
 }

void Generator::buzzInit ( const uint32 & max_harmonics )

inherited

Initaializes Buzz settings for real-time calls.

Definition at line 252 of file Generator.cc.

References Nsound::Generator::buzz_max_harmonics_, and Nsound::Generator::reset().

Referenced by Nsound::Generator::buzz().

 {
     buzz_max_harmonics_ = max_harmonics;
     reset();
 }

float64 Generator::buzz	(	const float64 &	frequency,
		const float64 &	n_harmonics,
		const float64 &	delay
	)

inherited

Returns sample from a set of harmonics. Based on the Csound buzz opcode.

Chorus can not be used with this function.

Definition at line 260 of file Generator.cc.

References Nsound::Generator::last_frequency_, Nsound::Generator::position_, and Nsound::Generator::sample_rate_.

Referenced by Nsound::Generator::buzz(), FFTransform_UnitTest(), and Generator_UnitTest().

 {
     // This function is based on the csound buzz opcode.
 
     float64 n = static_cast<int32>(n_harmonics);
 
     n = fabs(n);
     if(n < 1.0) n = 1.0;
 
     float64 two_n_plus_1 = 2.0 * n + 1.0;
     float64 scale = static_cast<float64>(0.5) / n;
 
     float64 sign = 1.0;
     for(int i = 0; i < n; ++i) sign = -sign;
 
     float64 phase = fabs(phase_offset / static_cast<float64>(2.0));
 
     while(phase >= 0.5) phase -= 0.5;
 
     position_ += (phase - last_frequency_) * sample_rate_;
 
     last_frequency_ = phase;
 
     float64 y;
 
     while(position_ >= sample_rate_) position_ -= sample_rate_;
 
     float64 denom = (*waveform_)[static_cast<int32>(position_ + 0.5)] * sign;
 
     if(fabs(denom) > 1e-12)
     {
         float64 up_phase = position_ * two_n_plus_1;
         while(up_phase >= sample_rate_) up_phase -= sample_rate_;
 
         float64 num = (*waveform_)[static_cast<int32>(up_phase)];
 
         y = (num / denom - static_cast<float64>(1.0)) * scale;
     }
     else
     {
         y = 1.0; // this assumes cosine wave!
     }
 
     position_ += 0.5*frequency;
 
     return y;
 }

Buffer Generator::buzz	(	const float64 &	duration,
		const float64 &	frequency,
		const float64 &	n_harmonics,
		const float64 &	delay
	)

inherited

Returns a set of harmonics. Based on the Csound buzz opcode.

Definition at line 313 of file Generator.cc.

References Nsound::Generator::buzz(), Nsound::Generator::buzzInit(), and Nsound::Generator::sample_rate_.

 {
     buzzInit(static_cast<uint32>(n_harmonics));
 
     int32 n_samples = static_cast<int32>(duration * sample_rate_);
 
     Buffer y(n_samples);
 
     for(int i = 0; i < n_samples; ++i)
     {
         y << buzz(frequency, n_harmonics, phase_offset+0.5);
     }
 
     return y;
 }

Buffer Generator::buzz	(	const float64 &	duration,
		const Buffer &	frequency,
		const Buffer &	n_harmonics,
		const Buffer &	delay
	)

inherited

Returns a set of harmonics. Based on the Csound buzz opcode.

Definition at line 335 of file Generator.cc.

References Nsound::Generator::buzz(), Nsound::Generator::buzzInit(), Nsound::Buffer::cbegin(), Nsound::Buffer::getMax(), and Nsound::Generator::sample_rate_.

 {
     buzzInit(static_cast<uint32>(n_harmonics.getMax()));
 
     int32 n_samples = static_cast<int32>(duration * sample_rate_);
 
     Buffer::const_circular_iterator f = frequencies.cbegin();
     Buffer::const_circular_iterator n = n_harmonics.cbegin();
     Buffer::const_circular_iterator p = phase_offset.cbegin();
 
     Buffer y(n_samples);
 
     for(int32 i = 0; i < n_samples; ++i, ++f, ++n, ++p)
     {
         y << buzz(*f, *n, *p+0.5);
     }
 
     return y;
 }

void Generator::setChorus	(	const uint32	n_voices,
		const float64 &	sigma = `0.02`
	)

inherited

Chorus or Unison.

When chorus is not enabled, samples are generated using one frequency indexing into the wave table. However, when chorus is turned on, the output sample will be the average of N frequencies indexing into the wavetable. A set of scalar is randomally selected, each frequncy in the set is calculated by

$f_n = \left({1.0 + \alpha_n}\right) f$

where $\alpha_n$ is a random scalar selected inside $\pm\sigma$ .

Definition at line 361 of file Generator.cc.

References Nsound::Generator::chorus_factor_, Nsound::Generator::chorus_is_on_, Nsound::Generator::chorus_n_voices_, Nsound::Generator::chorus_position_, Nsound::RandomNumberGenerator::get(), Nsound::Generator::reset(), and Nsound::Generator::rng_.

Referenced by Generator_UnitTest(), and Sine_UnitTest().

 {
     if(n_voices == 0)
     {
         chorus_is_on_ = false;
         return;
     }
 
     chorus_is_on_ = true;
 
     chorus_n_voices_ = n_voices;
 
     chorus_factor_.clear();
     chorus_position_.clear();
 
     for(uint32 i = 0; i < chorus_n_voices_; ++i)
     {
         chorus_factor_.push_back(1.0 + rng_->get(-amount, amount));
 
         chorus_position_.push_back(0.0);
     }
 
     reset();
 }

Buffer Generator::drawDecay	(	const float64 &	duration,
		const float64 &	alpha = `2.0*M_PI`
	)		const

inherited

This method draws an exponential curve that decays from 1.0 to 0.0 over the duration.

$y\left[n\right]=e^{-\alpha n\tau}$

where the default value for $\alpha$ is $2\pi$ and $\tau$ is the sample time.

Definition at line 388 of file Generator.cc.

References Nsound::Generator::drawLine(), and Nsound::Buffer::exp().

Referenced by Nsound::Granulator::Granulator(), main(), Nsound::DrumBD01::play(), Nsound::DrumKickBass::play(), and Nsound::Hat::play().

 {
     if(duration <= 0.0) return Buffer();
 
     Buffer t = drawLine(duration, 0.0, 1.0);
 
     t *= -alpha;
 
     t.exp();
 
     return t;
 }

Buffer Generator::drawGaussian	(	const float64 &	duration,
		const float64 &	mu,
		const float64 &	sigma,
		const boolean &	normalize = `true`
	)		const

inherited

This method draws a Gaussian curve over duration seconds.

Parameters

duration	the number of seconds to draw
mu	$\left(\mu\right)$ the location of the peak in seconds
sigma	$\left(\sigma\right)$ the width of the Gaussian in seconds
normalize	a flag to normalize the Gaussian so the peak is 1.0

Returns: Buffer

The generatl equation for a discrete Gaussian is given by

$y\left[n\right]=\frac{1}{\sqrt{2\pi\sigma^{2}}}e^{-\frac{\left(n\tau-\mu\right)^{2}}{2\sigma^{2}}}$

where $\tau$ is the sample time.

Definition at line 403 of file Generator.cc.

References Nsound::Generator::drawLine(), Nsound::Buffer::exp(), M_2PI, and Nsound::Buffer::normalize().

Referenced by Nsound::Generator::drawFatGaussian(), Nsound::Generator::drawWindow(), Nsound::Granulator::Granulator(), and main().

 {
     if(duration <= 0.0) return Buffer();
 
     float64 variance = sigma * sigma;
 
     Buffer g = drawLine(duration, 0.0, duration);
 
     g -= mu;
 
     g *= g;
 
     g /= (2.0 * variance);
 
     g *= -1.0;
 
     g.exp();
 
     g /= ::sqrt(M_2PI * variance);
 
     if(normalize) g.normalize();
 
     return g;
 }

Buffer Generator::drawFatGaussian	(	const float64 &	duration,
		const float64 &	pass_band_percent = `0.01`
	)		const

inherited

This method draws a standard Gaussian curve over duration seconds, with a specified pass band.

Parameters

duration	the number of seconds to draw
pass_band_percent	the width of the pass band in percent of duraiton
sigma	the standard deviation of the gaussian curve

Returns: Buffer

The curve is always normaized so the peak is 1.0.

Definition at line 434 of file Generator.cc.

References Nsound::Generator::drawGaussian(), Nsound::Generator::drawLine(), and M_ASSERT_VALUE.

Referenced by Nsound::Generator::drawWindow(), Nsound::Granulator::Granulator(), main(), and softTones().

 {
     M_ASSERT_VALUE(duration, >, 0.0);
     M_ASSERT_VALUE(pass_band_percent, >, 0.0);
     M_ASSERT_VALUE(pass_band_percent, <, 1.0);
 
     float64 pass_band_time = duration * pass_band_percent;
 
     float64 gauss_time = duration - pass_band_time;
 
     float64 h_gauss_time = gauss_time / 2.0;
 
     // Using a constant sigma ratio so the shape of the fat gaussian doesn't
     // change given a duration.
 
     float64 sigma = 0.275 * h_gauss_time;
 
     Buffer y;
 
     y << drawGaussian(h_gauss_time, h_gauss_time, sigma)
       << drawLine(pass_band_time, 1.0, 1.0)
       << drawGaussian(h_gauss_time, 0.0, sigma);
 
     return y;
 }

Buffer Generator::drawLine	(	const float64 &	duration,
		const float64 &	amplitude_start,
		const float64 &	amplitude_finish
	)		const

inherited

This method draws a linear line beteween 2 points.

Parameters

duration	the number of seconds to draw
amplitude_start	the starting amplitude value
amplitude_finish	the finishing amplitude value

Returns: Buffer

The two points are located at (x1,y1) = (0.0, amplitude_1) and (x2,y2) = (duration, amplitude_2).

Definition at line 464 of file Generator.cc.

References M_ASSERT_VALUE, and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     Buffer buffer;
 
     float64 n_samples = duration * sample_rate_;
 
     float64 slope = (y2 - y1) / n_samples;
 
     float64 current_sample = y1;
 
     for(uint32 i = 0; i < static_cast<uint32>(n_samples+0.5); ++i)
     {
         buffer << current_sample;
         current_sample += slope;
     }
 
     return buffer;
 }

Buffer Generator::drawParabola	(	const float64 &	duration,
		const float64 &	y1,
		const float64 &	x2,
		const float64 &	y2,
		const float64 &	y3
	)		const

inherited

This method draws a parabola between three points, intersecting the middle point.

Parameters

duration	the number of seconds to draw
y1	the y1 amplitude
x2	the x2 time
y2	the y2 amplitude
y3	the y3 amplitude

Returns: Buffer

The general equation for a discrete parabola is:

$y\left[n\right]=a\left(n\tau\right)^{2}+b\left(n\tau\right)+c$

where $\tau$ is the sample time. The three points are located at (x1,y1), (x2,y2), (x3,y3) with x1 = 0.0 and x3 = duration.

Definition at line 490 of file Generator.cc.

References Nsound::Generator::drawLine(), and M_ASSERT_VALUE.

Referenced by drum().

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     // In this discustion, amp = amplitude.
     //
     // The general equation for a parabola is:
     //
     // y = A*x^2 + B*x + C
     //
     // This alogorithm uses Gaussian elimination to solve for A,B,C.
     //
     // y1 = A * x1^2 + B * x1 + C            (1)
     //
     // y2 = A * x2^2 + B * x2 + C            (2)
     //
     // y3 = A * x3^2 + B * x3 + C            (3)
     //
     // Solve for C using (1), with x1 = 0.0:
     //
     // C = y1
     //
     // Solve for A using (2) and substituting C:
     //
     // A = (y2 - y1 - B * x2) / (x2^2)
     //
     // Solve for B using (3) and substituting A,C, I used WolframAlpha, awesome!
     //
     // solve y_3 = (y_2 - y_1 - B*x_2) / (x_2 * x_2) * (x_3 * x_3) + B*(x_3) + y_1 for B
     //
     //  B = [x2 * x2 * ( y3 - y1 ) + x3 * x3 * (y1 - y2)] / [x2 * x3 * (x2 - x3)]
     //
     M_ASSERT_VALUE(x2, <, duration);
 
     float64 x3 = duration;
 
     float64 C = y1;
 
     float64 B = (  x2*x2*(y3 - y1) + x3*x3*(y1 - y2)  ) / ( x2*x3*(x2 - x3) );
 
     float64 A = (y2 - y1 - B*x2) / (x2*x2);
 
     Buffer t = drawLine(duration, 0.0, duration);
 
     return A*t*t + B*t + C;
 }

Buffer Generator::drawSine	(	const float64 &	duration,
		const float64 &	frequency
	)

inherited

This method draws a static sine wave.

Parameters

duration	the number of seconds to draw
frequency	$\left(f\right)$ the frequency in Hz

Returns: Buffer

This is a special case of drawSine2(const float64 & duration, const float64 & frequency, const float64 & phase) with phase set to 0.0.

Definition at line 544 of file Generator.cc.

References Nsound::Generator::drawSine2(), M_ASSERT_VALUE, Nsound::Generator::sample_rate_, and Nsound::Generator::t_.

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

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     t_ = 0.0;
 
     Buffer y;
 
     uint64 n_samples = static_cast<uint64>(duration * sample_rate_ + 0.5);
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         y << drawSine2(frequency, 0.0);
     }
 
     return y;
 }

Buffer Generator::drawSine	(	const float64 &	duration,
		const Buffer &	frequency
	)

inherited

This method draws a dynamic sine wave.

Parameters

duration	the number of seconds to draw
frequency	$\left(f\right)$ the frequency in Hz

Returns: Buffer

This is a special case of drawSine2(const float64 & duration, const Buffer & frequency, const Buffer & phase) with the phase set to 0.0.

Definition at line 566 of file Generator.cc.

References Nsound::Buffer::cbegin(), Nsound::Generator::drawSine2(), M_ASSERT_VALUE, Nsound::Generator::sample_rate_, and Nsound::Generator::t_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     t_ = 0.0;
 
     Buffer y;
 
     uint64 n_samples = static_cast<uint64>(duration * sample_rate_ + 0.5);
 
     Buffer::const_circular_iterator f = frequency.cbegin();
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         y << drawSine2(*f, 0.0);
         ++f;
     }
 
     return y;
 }

float64 Generator::drawSine ( const float64 & frequency )

inherited

This method draws one sample of a sine wave in real-time.

Parameters

frequency $\left(f\right)$ the frequency in Hz

Returns: float64

This is a special case of drawSine2(const float64 & frequency, const float64 & phase) with the phase = 0.0.

Definition at line 694 of file Generator.cc.

References Nsound::Generator::drawSine2().

 {
     return drawSine2(frequency, 0.0);
 }

Buffer Generator::drawSine2	(	const float64 &	duration,
		const float64 &	frequency,
		const float64 &	phase
	)

inherited

This method draws a static sine wave.

Parameters

duration	the number of seconds to draw
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

The general discrete sine wave is given by

$y\left[n\right]=\sin\left(2\pi fn\tau+\pi\varphi\right)$

where $\tau$ is the sample time. This function will produce a cosine wave if $\varphi$ is 0.5.

Definition at line 591 of file Generator.cc.

References M_ASSERT_VALUE, Nsound::Generator::sample_rate_, and Nsound::Generator::t_.

Referenced by Nsound::Cosine::Cosine(), Nsound::Generator::drawSine(), Nsound::Generator::drawSine2(), and Generator_UnitTest().

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     t_ = 0.0;
 
     Buffer y;
 
     uint64 n_samples = static_cast<uint64>(duration * sample_rate_ + 0.5);
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         y << drawSine2(frequency, phase);
     }
 
     return y;
 }

Buffer Generator::drawSine2	(	const float64 &	duration,
		const Buffer &	frequency,
		const Buffer &	phase
	)

inherited

This method draws a dynamic sine wave.

Parameters

duration	the number of seconds to draw
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

The general dynamic discrete sine wave is given by

$y\left[n\right]=\sin\left(2\pi s\left[n\right]\tau+\pi\varphi_{n}\right)$

where $s\left[n\right]$ is given by

$s\left[n\right]=\sum_{i=0}^{n}f_{n}$

and $s\left[n\right]=0$ when $n=0$ and $\tau$ is the sample time.

This function will produce a cosine wave if $\varphi_n$ is 0.5.

Definition at line 614 of file Generator.cc.

References Nsound::Buffer::cbegin(), Nsound::Generator::drawSine2(), M_ASSERT_VALUE, Nsound::Generator::sample_rate_, and Nsound::Generator::t_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     t_ = 0.0;
 
     Buffer y;
 
     uint64 n_samples = static_cast<uint64>(duration * sample_rate_ + 0.5);
 
     Buffer::const_circular_iterator f = frequency.cbegin();
     Buffer::const_circular_iterator p = phase.cbegin();
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         y << drawSine2(*f, *p);
         ++f;
         ++p;
     }
 
     return y;
 }

Buffer Generator::drawSine2	(	const float64 &	duration,
		const Buffer &	frequency,
		const float64 &	phase = `0.0`
	)

inherited

This method draws a dynamic sine wave.

Parameters

duration	the number of seconds to draw
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

This is a special case of drawSine2(const float64 & duration, const Buffer & frequency, const Buffer & phase) with the phase set to a constant value.

Definition at line 642 of file Generator.cc.

References Nsound::Generator::drawSine2().

 {
     Buffer p(1);
     p << phase;
 
     return drawSine2(duration, frequency, p);
 }

Buffer Generator::drawSine2	(	const float64 &	duration,
		const float64 &	frequency,
		const Buffer &	phase
	)

inherited

This method draws a dynamic sine wave.

Parameters

duration	the number of seconds to draw
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

This is a special case of drawSine2(const float64 & duration, const Buffer & frequency, const Buffer & phase) with the frequency set to a constant value.

Definition at line 655 of file Generator.cc.

References Nsound::Generator::drawSine2().

 {
     Buffer f(1);
     f << frequency;
 
     return drawSine2(duration, f, phase);
 }

float64 Generator::drawSine2	(	const float64 &	frequency,
		const float64 &	phase
	)

inherited

This method draws one sample of a sine wave in real-time.

Parameters

frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: float64

Definition at line 668 of file Generator.cc.

References Nsound::Generator::chorus_factor_, Nsound::Generator::chorus_is_on_, Nsound::Generator::chorus_n_voices_, Nsound::Generator::chorus_position_, M_2PI, M_PI, Nsound::Generator::sample_time_, and Nsound::Generator::t_.

 {
     float64 f = 0.0;
     float64 sample = 0.0;
 
     if(chorus_is_on_)
     {
         for(uint32 i = 0; i < chorus_n_voices_; ++i)
         {
             f = M_2PI * chorus_position_[i] * sample_time_ + M_PI * phase;
             sample += ::sin(f);
             chorus_position_[i] += frequency * chorus_factor_[i];
         }
         sample /= static_cast<float64>(chorus_n_voices_);
     }
     else
     {
         sample = ::sin(M_2PI * t_ * sample_time_ + M_PI * phase);
         t_ += frequency;
     }
 
     return sample;
 }

Buffer Generator::drawWindow	(	const float64 &	duration,
		WindowType	type
	)		const

inherited

Draws a window of the specified type.

Definition at line 702 of file Generator.cc.

Referenced by Nsound::FFTransform::fft(), Nsound::FilterLeastSquaresFIR::setWindow(), and Nsound::Spectrogram::Spectrogram().

 {
     switch(type)
     {
         case BARTLETT:        return drawWindowBartlett(duration);
         case BLACKMAN:        return drawWindowBlackman(duration);
         case BLACKMAN_HARRIS: return drawWindowBlackmanHarris(duration);
         case GAUSSIAN:        return drawGaussian(duration, duration/2.0, 1.0);
         case GAUSSIAN_05:     return drawFatGaussian(duration, 0.05);
         case GAUSSIAN_10:     return drawFatGaussian(duration, 0.10);
         case GAUSSIAN_15:     return drawFatGaussian(duration, 0.15);
         case GAUSSIAN_20:     return drawFatGaussian(duration, 0.20);
         case GAUSSIAN_25:     return drawFatGaussian(duration, 0.25);
         case GAUSSIAN_30:     return drawFatGaussian(duration, 0.30);
         case GAUSSIAN_33:     return drawFatGaussian(duration, 0.3333);
         case GAUSSIAN_35:     return drawFatGaussian(duration, 0.35);
         case GAUSSIAN_40:     return drawFatGaussian(duration, 0.40);
         case GAUSSIAN_45:     return drawFatGaussian(duration, 0.45);
         case GAUSSIAN_50:     return drawFatGaussian(duration, 0.50);
         case GAUSSIAN_55:     return drawFatGaussian(duration, 0.55);
         case GAUSSIAN_60:     return drawFatGaussian(duration, 0.60);
         case GAUSSIAN_65:     return drawFatGaussian(duration, 0.65);
         case GAUSSIAN_66:     return drawFatGaussian(duration, 0.6666);
         case GAUSSIAN_70:     return drawFatGaussian(duration, 0.70);
         case GAUSSIAN_75:     return drawFatGaussian(duration, 0.75);
         case GAUSSIAN_80:     return drawFatGaussian(duration, 0.80);
         case GAUSSIAN_85:     return drawFatGaussian(duration, 0.85);
         case GAUSSIAN_90:     return drawFatGaussian(duration, 0.90);
         case GAUSSIAN_95:     return drawFatGaussian(duration, 0.95);
         case GAUSSIAN_99:     return drawFatGaussian(duration, 0.9999);
         case HAMMING:         return drawWindowHamming(duration);
         case HANNING:         return drawWindowHanning(duration);
         case KAISER:          return drawWindowKaiser(duration);
         case NUTTALL:         return drawWindowNuttall(duration);
         case PARZEN:          return drawWindowParzen(duration);
         case RECTANGULAR:     return drawWindowRectangular(duration);
         default:              M_THROW("Unkown window type " << type);
     }
 
     return drawWindowRectangular(duration);
 }

Buffer Generator::drawWindowBartlett ( const float64 & duration ) const

inherited

Draws a Bartlett window.

Definition at line 765 of file Generator.cc.

References Nsound::Generator::drawLine(), and Nsound::Generator::sample_rate_.

Referenced by Nsound::Generator::drawWindow().

 {
     Buffer window = drawLine(duration, 1.0, 1.0);
 
     int32 n = static_cast<int32>(duration * sample_rate_);
 
     float64 n_over_2 = static_cast<float64>(n / 2);
 
     for(int32 i = 0; i < n / 2; ++i)
     {
         float64 t = static_cast<float64>(i) / n_over_2;
         window[i] *= t;
         window[i + n/2] *= 1.0 - t;
     }
 
     return window;
 }

Buffer Generator::drawWindowBlackman ( const float64 & duration ) const

inherited

Draws a Blackman window.

The general discrete cosine window is given by

$w\left[n\right]=a_{0}-a_{1}\cos\left(2\pi n\tau\right)+a_{2}\cos\left(4\pi n\tau\right)-a_{3}\cos\left(6\pi n\tau\right)$

where $\tau$ is the sample time. The Blackman window is a special case of the cosesine window with $a_0$ = 0.42, $a_1$ = 0.50, $a_2$ = 0.08, $a_3$ = 0.00.

Definition at line 785 of file Generator.cc.

References cosinewindow(), and Nsound::Generator::drawLine().

Referenced by Nsound::Generator::drawWindow().

 {
     Buffer window = drawLine(duration, 1.0, 1.0);
 
     cosinewindow(window, 0.42, 0.50, 0.08, 0.00);
 
     return window;
 }

Buffer Generator::drawWindowBlackmanHarris ( const float64 & duration ) const

inherited

Draws a Blackman-Harris window.

The general discrete cosine window is given by

$w\left[n\right]=a_{0}-a_{1}\cos\left(2\pi n\tau\right)+a_{2}\cos\left(4\pi n\tau\right)-a_{3}\cos\left(6\pi n\tau\right)$

where $\tau$ is the sample time. The Blackman-Harris window is a special case of the cosesine window with $a_0$ = 0.35875, $a_1$ = 0.48829, $a_2$ = 0.14128, $a_3$ = 0.01168.

Definition at line 796 of file Generator.cc.

References cosinewindow(), and Nsound::Generator::drawLine().

Referenced by Nsound::Generator::drawWindow().

 {
     Buffer window = drawLine(duration, 1.0, 1.0);
 
     cosinewindow(window, 0.35875, 0.48829, 0.14128, 0.01168);
 
     return window;
 }

Buffer Generator::drawWindowHamming ( const float64 & duration ) const

inherited

Draws a Hamming window.

The general discrete cosine window is given by

$w\left[n\right]=a_{0}-a_{1}\cos\left(2\pi n\tau\right)+a_{2}\cos\left(4\pi n\tau\right)-a_{3}\cos\left(6\pi n\tau\right)$

where $\tau$ is the sample time. The Hamming window is a special case of the cosesine window with $a_0$ = 0.54, $a_1$ = 0.46, $a_2$ = 0.00, $a_3$ = 0.00.

Definition at line 808 of file Generator.cc.

References cosinewindow(), and Nsound::Generator::drawLine().

Referenced by Nsound::Generator::drawWindow().

 {
     Buffer window = drawLine(duration, 1.0, 1.0);
 
     cosinewindow(window, 0.54, 0.46, 0.00, 0.00);
 
     return window;
 }

Buffer Generator::drawWindowHanning ( const float64 & duration ) const

inherited

Draws a Hanning window.

The general discrete cosine window is given by

$w\left[n\right]=a_{0}-a_{1}\cos\left(2\pi n\tau\right)+a_{2}\cos\left(4\pi n\tau\right)-a_{3}\cos\left(6\pi n\tau\right)$

where $\tau$ is the sample time. The Hanning window is a special case of the cosesine window with $a_0$ = 0.50, $a_1$ = 0.50, $a_2$ = 0.00, $a_3$ = 0.00.

Definition at line 819 of file Generator.cc.

References cosinewindow(), and Nsound::Generator::drawLine().

Referenced by Nsound::Generator::drawWindow(), my_main(), and Nsound::Stretcher::Stretcher().

 {
     Buffer window = drawLine(duration, 1.0, 1.0);
 
     cosinewindow(window, 0.50, 0.50, 0.00, 0.00);
 
     return window;
 }

Buffer Generator::drawWindowKaiser	(	const float64 &	duration,
		const float64 &	beta = `5.0`
	)		const

inherited

Draws a Kaiser window.

Definition at line 879 of file Generator.cc.

References bessel_i0(), Nsound::Generator::drawLine(), and Nsound::Buffer::getLength().

Referenced by Nsound::Generator::drawWindow(), Nsound::FilterLeastSquaresFIR::FilterLeastSquaresFIR(), and Nsound::FilterLeastSquaresFIR::setKernel().

 {
     Buffer window = drawLine(duration, 0.0, 0.0);
 
     int32 n_samples = window.getLength();
     float64 f_n_samples = float64(n_samples);
 
     float64 b = ::fabs(beta);
 
     if(b < 1.0)
     {
         b = 1.0;
     }
 
     // Calculate window coefficients
     //
     // alpha = n_samples / 2
     //
     // for n = 0 : n_samples -1
     //
     //     w[n] = bessel_i0( beta * sqrt(1.0 - [(n - alpha)/alpha]^2)
     //          / bessel_i0(beta)
     //
     //
 
     float64 alpha = f_n_samples / 2.0;
 
     float64 denominator = bessel_i0(b);
 
     for(int32 i = 0 ; i < n_samples; ++i)
     {
         float64 temp = (float64(i) - alpha) / alpha;
         temp *= temp;
 
         window[i] = bessel_i0( b * ::sqrt(1.0 - temp)) / denominator;
     }
 
     return window;
 }

Buffer Generator::drawWindowNuttall ( const float64 & duration ) const

inherited

Draws a Nuttall window.

The general discrete cosine window is given by

$w\left[n\right]=a_{0}-a_{1}\cos\left(2\pi n\tau\right)+a_{2}\cos\left(4\pi n\tau\right)-a_{3}\cos\left(6\pi n\tau\right)$

where $\tau$ is the sample time. The Nuttall window is a special case of the cosesine window with $a_0$ = 0.3635819, $a_1$ = 0.4891775, $a_2$ = 0.1365995, $a_3$ = 0.0106411.

Definition at line 921 of file Generator.cc.

References cosinewindow(), and Nsound::Generator::drawLine().

Referenced by Nsound::Generator::drawWindow().

 {
     Buffer window = drawLine(duration, 1.0, 1.0);
 
     cosinewindow(window, 0.3635819, 0.4891775, 0.1365995, 0.0106411);
 
     return window;
 }

Buffer Generator::drawWindowParzen ( const float64 & duration ) const

inherited

Draws a Parzen window.

Definition at line 932 of file Generator.cc.

References Nsound::Generator::drawLine(), and Nsound::Generator::sample_rate_.

Referenced by Nsound::Generator::drawWindow().

 {
     Buffer window = drawLine(duration, 1.0, 1.0);
 
     int32 n = static_cast<int32>(duration * sample_rate_);
 
     int32 N = n -1;
 
     float64 Nf = static_cast<float64>(N);
 
     for(int32 i = 0; i < N / 4; ++i)
     {
         float64 m = 2 * pow(1.0 - (Nf / 2 - i) / (Nf / 2), 3.0);
         window[i] *= m;
         window[N - i] *= m;
     }
 
     for(int32 i = N/4; i <= N/2; ++i)
     {
         int32 wn = i - N/2;
         float64 m = 1.0
                   - 6.0 * pow(wn / (Nf/2),2.0)
                       * (1.0 - fabs(static_cast<float64>(wn)) / (Nf/2));
 
         window[i] *= m;
         window[N-i] *= m;
     }
 
     return window;
 }

Buffer Generator::drawWindowRectangular ( const float64 & duration ) const

inherited

Draws a rectangular window.

Definition at line 965 of file Generator.cc.

References Nsound::Generator::drawLine().

Referenced by Nsound::Generator::drawWindow().

 {
     return drawLine(duration, 1.0, 1.0);
 }

float64 Generator::generate ( const float64 & frequency )

virtualinherited

This is a real-time method for the wavetable oscillator.

Parameters

frequency $\left(f\right)$ the frequency in Hz

Returns: float64

This is a special case of generate2(const float64 & frequency, const float64 & phase) with phase = 0.0.

Reimplemented in Nsound::Pulse, Nsound::GeneratorDecay, and Nsound::Pluck.

Definition at line 972 of file Generator.cc.

References Nsound::Generator::generate2().

Referenced by Buffer_UnitTest(), BufferResample_UnitTest(), DelayLine_UnitTest(), drum(), Nsound::FilterFlanger::filter(), FilterDelay_UnitTest(), Nsound::FilterFlanger::FilterFlanger(), Nsound::FilterPhaser::FilterPhaser(), Nsound::Granulator::generate(), Nsound::Generator::generate(), Generator_UnitTest(), main(), Nsound::GuitarBass::play(), Nsound::Clarinet::play(), Nsound::DrumBD01::play(), Nsound::DrumKickBass::play(), Nsound::OrganPipe::play(), Nsound::Hat::play(), Sine_UnitTest(), softTones(), testAutioStream(), Triangle_UnitTest(), and Wavefile_UnitTest().

 {
     return generate2(frequency, 0.0);
 }

Buffer Generator::generate	(	const float64 &	duration,
		const float64 &	frequency
	)

virtualinherited

This method oscillates the waveform stored in this generator.

Parameters

duration	the number of seconds to oscillate the waveform
frequency	$\left(f\right)$ the frequency in Hz

Returns: Buffer

Example:: // C++

Generator gen("some_waveform.wav");

Buffer b = gen.generate(1.0, 3.0);

// Python

gen = Generator("some_waveform.wav")

b = gen.generate(1.0, 3.0)

Reimplemented in Nsound::Pluck.

Definition at line 1065 of file Generator.cc.

References Nsound::Generator::generate(), Nsound::Generator::is_realtime_, M_ASSERT_VALUE, Nsound::Generator::reset(), and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     if(!is_realtime_) reset();
 
     Buffer buffer;
 
     uint64 n_samples = static_cast<uint64>(std::ceil(duration * sample_rate_));
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         buffer << generate(frequency);
     }
 
     return buffer;
 }

Buffer Generator::generate	(	const float64 &	duration,
		const Buffer &	frequencies
	)

virtualinherited

This method oscillates the waveform stored in this generator.

Parameters

duration	the number of seconds to oscillate the waveform
frequency	$\left(f\right)$ the frequency in Hz

Returns: Buffer

This is a special case of generate2(const float64 & duration, const Buffer & frequencies, const Buffer & phase) with phase = 0.0.

Reimplemented in Nsound::Pluck.

Definition at line 1110 of file Generator.cc.

References Nsound::Buffer::cbegin(), Nsound::Generator::generate(), Nsound::Generator::is_realtime_, M_ASSERT_VALUE, Nsound::Generator::reset(), and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     if(!is_realtime_) reset();
 
     uint32 n_samples = static_cast<uint32>(std::ceil(duration * sample_rate_));
 
     Buffer y(n_samples);
 
     Buffer::const_circular_iterator freq = frequencies.cbegin();
 
     for(uint32 i = 0; i < n_samples; ++i, ++freq)
     {
         y << generate(*freq);
     }
 
     return y;
 }

float64 Generator::generate2	(	const float64 &	frequency,
		const float64 &	phase
	)

virtualinherited

This is a real-time method for the wavetable oscillator.

Parameters

frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: float64

The general wavetable oscillator equation is given by

$y\left[n\right]=wavetable\left[s\left[n\right]\right]$

where the index into the table, $s\left[n\right]$ is given by the recursive function

$s\left[n\right]=\left(s\left[n-1\right]+f+\pi\varphi\right)\div N$

where $\div$ is the modulus operator, $N$ is the wavetable length, when $n<0$ , $s\left[n\right]=0$ . In Nsound, the wavetable size, $N$ , is equal to the sample rate.

Reimplemented in Nsound::Pulse, Nsound::GeneratorDecay, and Nsound::Pluck.

Definition at line 979 of file Generator.cc.

References Nsound::Generator::chorus_factor_, Nsound::Generator::chorus_is_on_, Nsound::Generator::chorus_n_voices_, Nsound::Generator::chorus_position_, M_CHECK_PTR, Nsound::Generator::position_, Nsound::Generator::sample_rate_, Nsound::Generator::sync_count_, Nsound::Generator::sync_is_master_, Nsound::Generator::sync_is_slave_, Nsound::Generator::sync_pos_, Nsound::Generator::sync_slaves_, Nsound::Generator::sync_vector_, and Nsound::Generator::waveform_.

Referenced by Nsound::Generator::generate(), Nsound::GeneratorDecay::generate2(), Nsound::Pulse::generate2(), Nsound::Generator::generate2(), and Sine_UnitTest().

 {
     M_CHECK_PTR(waveform_);
 
     ++sync_count_;
 
     if(sync_is_slave_ && !sync_vector_.empty())
     {
         uint32 sync_count = sync_vector_.front();
 
         if(sync_count_ == sync_count)
         {
             sync_vector_.erase(sync_vector_.begin());
             position_ = 0;
             sync_pos_ = 0;
         }
     }
 
     // Move with phase
     float64 ph = (phase * sample_rate_ / 2.0);
     float64 position2 = position_ + ph + 0.5;
 
     // Range checks
 
     while(position2 >= sample_rate_)
     {
         position2 -= sample_rate_;
     }
 
     while(position2 < 0.0)
     {
         position2 += sample_rate_;
     }
 
     float64 sample = 0.0;
 
     if(chorus_is_on_)
     {
         for(uint32 i = 0; i < chorus_n_voices_; ++i)
         {
             float64 pos = chorus_position_[i]
                         + chorus_factor_[i] * frequency
                         + ph
                         + 0.5;
 
             // Range check
             while(pos >= sample_rate_) pos -= sample_rate_;
             while(pos <  0)            pos += sample_rate_;
 
             sample += (*waveform_)[static_cast<uint32>(pos)];
 
             chorus_position_[i] += frequency * chorus_factor_[i];
         }
 
         sample /= static_cast<float64>(chorus_n_voices_);
     }
     else
     {
         sample = (*waveform_)[static_cast<uint32>(position2)];
     }
 
     position_ += frequency;
     sync_pos_ += frequency;
 
     // limit
     if(sync_pos_ > sample_rate_)
     {
         sync_pos_ -= sample_rate_;
 
         if(sync_is_master_)
         {
             std::set<Generator *>::iterator itor = sync_slaves_.begin();
 
             while(itor != sync_slaves_.end())
             {
                 (*itor)->sync_vector_.push_back(sync_count_);
                 ++itor;
             }
         }
     }
 
     return sample;
 }

Buffer Generator::generate2	(	const float64 &	duration,
		const float64 &	frequency,
		const float64 &	phase
	)

virtualinherited

This method oscillates the waveform stored in this generator.

Parameters

duration	the number of seconds to oscillate the waveform
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

Example:: // C++

Generator gen("some_waveform.wav");

Buffer b = gen.generate2(1.0, 3.0, 0.5); // 90 degrees out of phase

// Python

gen = Generator("some_waveform.wav")

b = gen.generate(1.0, 3.0, 0.5)

Reimplemented in Nsound::Pulse, Nsound::GeneratorDecay, and Nsound::Pluck.

Definition at line 1087 of file Generator.cc.

References Nsound::Generator::generate2(), Nsound::Generator::is_realtime_, M_ASSERT_VALUE, Nsound::Generator::reset(), and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     if(!is_realtime_) reset();
 
     Buffer buffer;
 
     uint64 n_samples = static_cast<uint64>(std::ceil(duration * sample_rate_));
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         buffer << generate2(frequency, phase);
     }
 
     return buffer;
 }

Buffer Generator::generate2	(	const float64 &	duration,
		const float64 &	frequencies,
		const Buffer &	phase
	)

virtualinherited

This method oscillates the waveform stored in this generator.

Parameters

duration	the number of seconds to oscillate the waveform
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

This is a special case of generate2(const float64 & duration, const Buffer & frequencies, const Buffer & phase) with constant frequency.

Reimplemented in Nsound::Pulse, Nsound::GeneratorDecay, and Nsound::Pluck.

Definition at line 1134 of file Generator.cc.

References Nsound::Buffer::cbegin(), Nsound::Generator::generate2(), Nsound::Generator::is_realtime_, M_ASSERT_VALUE, Nsound::Generator::reset(), and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     if(!is_realtime_) reset();
 
     uint32 n_samples = static_cast<uint32>(std::ceil(duration * sample_rate_));
 
     Buffer y(n_samples);
 
     Buffer::const_circular_iterator p = phase.cbegin();
 
     for(uint32 i = 0; i < n_samples; ++i, ++p)
     {
         y << generate2(frequency,*p);
     }
 
     return y;
 }

Buffer Generator::generate2	(	const float64 &	duration,
		const Buffer &	frequencies,
		const float64 &	phase
	)

virtualinherited

This method oscillates the waveform stored in this generator.

Parameters

duration	the number of seconds to oscillate the waveform
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

This is a special case of generate2(const float64 & duration, const Buffer & frequencies, const Buffer & phase) with constant phase.

Reimplemented in Nsound::Pulse, Nsound::GeneratorDecay, and Nsound::Pluck.

Definition at line 1159 of file Generator.cc.

References Nsound::Buffer::cbegin(), Nsound::Generator::generate2(), Nsound::Generator::is_realtime_, M_ASSERT_VALUE, Nsound::Generator::reset(), and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     if(!is_realtime_) reset();
 
     uint32 n_samples = static_cast<uint32>(std::ceil(duration * sample_rate_));
 
     Buffer y(n_samples);
 
     Buffer::const_circular_iterator f = frequencies.cbegin();
 
     for(uint32 i = 0; i < n_samples; ++i, ++f)
     {
         y << generate2(*f, phase);
     }
 
     return y;
 }

Buffer Generator::generate2	(	const float64 &	duration,
		const Buffer &	frequencies,
		const Buffer &	phase
	)

virtualinherited

This method oscillates the waveform stored in this generator.

Parameters

duration	the number of seconds to oscillate the waveform
frequency	$\left(f\right)$ the frequency in Hz
phase	$\left(\varphi\right)$ the natural phase (0.0 to 1.0)

Returns: Buffer

Reimplemented in Nsound::GeneratorDecay, Nsound::Pulse, and Nsound::Pluck.

Definition at line 1184 of file Generator.cc.

References Nsound::Buffer::cbegin(), Nsound::Generator::generate2(), Nsound::Generator::is_realtime_, M_ASSERT_VALUE, Nsound::Generator::reset(), and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     if(!is_realtime_) reset();
 
     uint32 n_samples = static_cast<uint32>(std::ceil(duration * sample_rate_));
 
     Buffer y(n_samples);
 
     Buffer::const_circular_iterator f = frequencies.cbegin();
     Buffer::const_circular_iterator p = phase.cbegin();
 
     for(uint32 i = 0; i < n_samples; ++i, ++f, ++p)
     {
         y << generate2(*f,*p);
     }
 
     return y;
 }

void Generator::removeSlaveSync ( Generator & slave )

inherited

Removes the generator from the sync list.

Definition at line 1259 of file Generator.cc.

References Nsound::Generator::reset(), Nsound::Generator::sync_is_slave_, and Nsound::Generator::sync_slaves_.

 {
     slave.sync_is_slave_ = false;
 
     if(sync_slaves_.count(&slave) == 0) return;
 
     sync_slaves_.erase(&slave);
 
     reset();
 }

void Generator::reset ( )

virtualinherited

Resets the position pointer back to the begging of the waveform.

Reimplemented in Nsound::Pulse.

Definition at line 1272 of file Generator.cc.

References Nsound::Generator::buzz_max_harmonics_, Nsound::Generator::buzz_position_, Nsound::Generator::chorus_n_voices_, Nsound::Generator::chorus_position_, Nsound::Generator::last_frequency_, Nsound::Generator::position_, Nsound::Generator::sync_count_, Nsound::Generator::sync_pos_, Nsound::Generator::sync_slaves_, and Nsound::Generator::t_.

Referenced by Nsound::Generator::addSlaveSync(), Nsound::Generator::buzzInit(), Nsound::Generator::generate(), Nsound::Generator::generate2(), Nsound::Generator::removeSlaveSync(), Nsound::FilterFlanger::reset(), and Nsound::Generator::setChorus().

 {
     last_frequency_ = -1.0;
     position_ = 0.0;
     sync_count_ = 0;
     sync_pos_ = 0.0;
     t_ = 0.0;
 
     buzz_position_.reserve(buzz_max_harmonics_);
 
     for(uint32 i = 0; i < buzz_max_harmonics_; ++i)
     {
         buzz_position_[i] = 0.0;
     }
 
     for(uint32 i = 0; i < chorus_n_voices_; ++i)
     {
         chorus_position_[i] = 0.0;
     }
 
     std::set<Generator *>::iterator itor = sync_slaves_.begin();
 
     while(itor != sync_slaves_.end())
     {
         (*itor)->sync_vector_.clear();
         ++itor;
     }
 }

RandomNumberGenerator& Nsound::Generator::getRandomNumberGenerator ( )

inlineinherited

Definition at line 562 of file Generator.h.

References Nsound::Generator::rng_.

562 {return *rng_; }

Nsound::Generator::rng_

RandomNumberGenerator * rng_

The waveform to ossicialate.

Definition: Generator.h:621

void Generator::setSeed ( const uint32 seed )

inherited

Sets the seed for the Generator's random number generator (rng).

Definition at line 1303 of file Generator.cc.

References Nsound::Generator::rng_, and Nsound::RandomNumberGenerator::setSeed().

Referenced by Generator_UnitTest(), and Sine_UnitTest().

 {
     rng_->setSeed(seed);
 }

Buffer Generator::silence ( const float64 & duration ) const

inherited

This method generates silence.

This is a special coase of drawLine(const float64 & duration, const float64 & amplitude_start, const float64 & amplitude_finish) const where the start and stopping amplitudes are 0.0.

Definition at line 1310 of file Generator.cc.

References Nsound::Generator::drawLine().

Referenced by Nsound::FFTransform::fft(), FilterDelay_UnitTest(), main(), my_main(), Nsound::Hat::play(), and Nsound::Spectrogram::Spectrogram().

 {
     return drawLine(duration,0.0,0.0);
 }

float64 Generator::tell ( ) const

inherited

Returns the current position pointer, values are between 0.0 to 1.0.

Definition at line 1317 of file Generator.cc.

References Nsound::Generator::position_, and Nsound::Generator::sample_rate_.

 {
     return position_ / sample_rate_;
 }

Buffer Generator::whiteNoise ( const float64 & duration ) const

inherited

This method generates noise from a uniform distribution.

Definition at line 1325 of file Generator.cc.

References Nsound::RandomNumberGenerator::get(), M_ASSERT_VALUE, Nsound::Generator::rng_, and Nsound::Generator::sample_rate_.

Referenced by Nsound::Pluck::generate(), Nsound::Granulator::Granulator(), main(), Nsound::FluteSlide::play(), Nsound::DrumBD01::play(), Nsound::AudioStream::rand(), and Nsound::Buffer::rand().

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     Buffer buffer;
 
     uint64 n_samples = static_cast<uint64>(std::ceil(duration * sample_rate_));
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         buffer << rng_->get(-1.0f,1.0f);
     }
 
     return buffer;
 }

Buffer Generator::gaussianNoise	(	const float64 &	duration,
		const float64 &	mu,
		const float64 &	sigma
	)		const

inherited

This method generates noise from a Gaussian distribution.

Definition at line 1343 of file Generator.cc.

References Nsound::RandomNumberGenerator::get(), M_ASSERT_VALUE, Nsound::Generator::rng_, and Nsound::Generator::sample_rate_.

 {
     Buffer buffer;
 
     uint32 n_samples = static_cast<uint32>(std::ceil(duration * sample_rate_));
 
     M_ASSERT_VALUE(n_samples, >, 0);
 
     // The polar form of the Box-Muller transformation.
 
     uint32 i = 0;
     while(true)
     {
         float64 f = 0.0;
         float64 x1 = 0.0;
         float64 x2 = 0.0;
         float64 r2 = 0.0;
 
         while(r2 == 0.0 || r2 >= 1.0)
         {
             x1 = rng_->get(-1.0f, 1.0f);
             x2 = rng_->get(-1.0f, 1.0f);
             r2 = x1 * x1 + x2 * x2;
         }
 
         f = ::sqrt(-2.0 * ::log(r2) / r2);
 
         buffer << mu + sigma * f * x1;
 
         ++i;
 
         if(i >= n_samples)
         {
             break;
         }
 
         buffer << mu + sigma * f * x2;
 
         ++i;
 
         if(i >= n_samples)
         {
             break;
         }
     }
 
     return buffer;
 }

Buffer Generator::tanh ( const float64 & duration ) const

inherited

This method draws the tanh function accross duration samples.

Definition at line 1397 of file Generator.cc.

References M_ASSERT_VALUE, M_PI, and Nsound::Generator::sample_rate_.

 {
     M_ASSERT_VALUE(duration, >, 0.0);
 
     Buffer buffer;
 
     uint64 n_samples = static_cast<uint64>(std::ceil(duration * sample_rate_));
 
     float64 step = (2.0 * M_PI) / n_samples;
 
     float64 x = -1.0 * M_PI;
 
     for(uint64 i = 0; i < n_samples; ++i)
     {
         buffer << std::tanh(x);
         x += step;
     }
 
     return buffer;
 }

void Generator::ctor ( const float64 & sample_rate )

protectedvirtualinherited

DOXME.

Definition at line 201 of file Generator.cc.

References Nsound::Generator::rng_, Nsound::Generator::sample_rate_, Nsound::Generator::sample_time_, and Nsound::Generator::waveform_.

Referenced by Nsound::Cosine::Cosine(), Nsound::Generator::ctor(), Nsound::Generator::Generator(), Nsound::Sawtooth::Sawtooth(), Nsound::Sine::Sine(), Nsound::Square::Square(), and Triangle().

 {
     sample_rate_ = sample_rate;
     sample_time_ = 1.0 / sample_rate_;
     waveform_ = NULL;
     rng_ = new RngTausworthe();
 }

void Generator::ctor	(	const float64 &	sample_rate,
		const Buffer &	wavetable
	)

protectedvirtualinherited

DOXME.

Definition at line 212 of file Generator.cc.

References Nsound::Generator::ctor(), Nsound::Buffer::getLength(), M_THROW, Nsound::Generator::rng_, Nsound::Generator::sample_rate_, Nsound::Generator::sample_time_, and Nsound::Generator::waveform_.

 {
     if(waveform.getLength() != sample_rate)
     {
         M_THROW("Generator::ctor(): waveform.getLength() != sample_rate ("
              << waveform.getLength()
              << " != "
              << sample_rate
              << ")");
         ctor(sample_rate);
     }
     else
     {
         delete waveform_;
         delete rng_;
 
         sample_rate_ = sample_rate;
         sample_time_ = 1.0 / sample_rate_;
         waveform_ = new Buffer(waveform);
         rng_ = new RngTausworthe();
     }
 }