Generator.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
//  $Id: Generator.h 874 2014-09-08 02:21:29Z weegreenblobbie $
//
//  Nsound is a C++ library and Python module for audio synthesis featuring
//  dynamic digital filters. Nsound lets you easily shape waveforms and write
//  to disk or plot them. Nsound aims to be as powerful as Csound but easy to
//  use.
//
//  Copyright (c) 2005-Present Nick Hilton
//
//  weegreenblobbie_yahoo_com (replace '_' with '@' and '.')
//
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Library General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
//-----------------------------------------------------------------------------

#ifndef _NSOUND_GENERATOR_H_
#define _NSOUND_GENERATOR_H_

#include <Nsound/Nsound.h>
#include <Nsound/WindowType.h>

namespace Nsound
{

// Forwared declarion of Buffer
class Buffer;
class RandomNumberGenerator;

//-----------------------------------------------------------------------------
//  Generator Class
class Generator
{
    public:

    Generator(const float64 & sample_rate);

    Generator(const float64 & sample_rate, const Buffer & waveform);

    //
    Generator(const std::string & wave_filename);

    Generator(const Nsound::Generator & gen);

    virtual ~Generator();

    void setRealtime(bool flag) { is_realtime_ = flag; }

    void
    addSlaveSync(Generator & slave);

    void
    buzzInit(const uint32 & max_harmonics);

    //
    float64
    buzz(
        const float64 & frequency,
        const float64 & n_harmonics,
        const float64 & delay);

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

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

    //
    void
    setChorus(
        const uint32 n_voices,
        const float64 & sigma = 0.02);

    //
    Buffer
    drawDecay(const float64 & duration, const float64 & alpha = 2.0*M_PI) const;

    //
    Buffer
    drawGaussian(
        const float64 & duration,
        const float64 & mu,
        const float64 & sigma,
        const boolean & normalize = true) const;

    //
    Buffer
    drawFatGaussian(
        const float64 & duration,
        const float64 & pass_band_percent = 0.01) const;

    //
    Buffer
    drawLine(
        const float64 & duration,
        const float64 & amplitude_start,
        const float64 & amplitude_finish) const;

    //
    Buffer
    drawParabola(
        const float64 & duration,
        const float64 & y1,
        const float64 & x2,
        const float64 & y2,
        const float64 & y3) const;

    //
    Buffer
    drawSine(
        const float64 & duration,
        const float64 & frequency);

    //
    Buffer
    drawSine(
        const float64 & duration,
        const Buffer & frequency);

    //
    Buffer
    drawSine2(
        const float64 & duration,
        const float64 & frequency,
        const float64 & phase);

    //
    Buffer
    drawSine2(
        const float64 & duration,
        const Buffer & frequency,
        const Buffer & phase);

    //
    Buffer
    drawSine2(
        const float64 & duration,
        const Buffer & frequency,
        const float64 & phase=0.0);

    //
    Buffer
    drawSine2(
        const float64 & duration,
        const float64 & frequency,
        const Buffer & phase);

    //
    float64
    drawSine(
        const float64 & frequency);

    //
    float64
    drawSine2(
        const float64 & frequency,
        const float64 & phase);

    Buffer
    drawWindow(const float64 & duration, WindowType type) const;

    //
    Buffer
    drawWindowBartlett(const float64 & duration) const;

    //
    Buffer
    drawWindowBlackman(const float64 & duration) const;

    //
    Buffer
    drawWindowBlackmanHarris(const float64 & duration) const;

    //
    Buffer
    drawWindowHamming(const float64 & duration) const;

    //
    Buffer
    drawWindowHanning(const float64 & duration) const;

    Buffer
    drawWindowKaiser(const float64 & duration, const float64 & beta=5.0) const;

    //
    Buffer
    drawWindowNuttall(const float64 & duration) const;

    Buffer
    drawWindowParzen(const float64 & duration) const;

    Buffer
    drawWindowRectangular(const float64 & duration) const;

    //
    virtual
    float64
    generate(const float64 & frequency);

    //
    virtual
    float64
    generate2(const float64 & frequency, const float64 & phase);

    //
    virtual
    Buffer
    generate(
        const float64 & duration,
        const float64 & frequency);

    //
    virtual
    Buffer
    generate2(
        const float64 & duration,
        const float64 & frequency,
        const float64 & phase);

    //
    virtual
    Buffer
    generate(
        const float64 & duration,
        const Buffer & frequencies);

    //
    virtual
    Buffer
    generate2(
        const float64 & duration,
        const float64 & frequencies,
        const Buffer &  phase);

    //
    virtual
    Buffer
    generate2(
        const float64 & duration,
        const Buffer &  frequencies,
        const float64 & phase);

    //
    virtual
    Buffer
    generate2(
        const float64 & duration,
        const Buffer &  frequencies,
        const Buffer &  phase);

    Nsound::Generator &
    operator=(const Nsound::Generator & rhs);

    void
    removeSlaveSync(Generator & slave);

    virtual
    void reset();

    RandomNumberGenerator & getRandomNumberGenerator() {return *rng_; }

    void setSeed(const uint32 seed);

    //
    Buffer
    silence(const float64 & duration) const;

    float64
    tell() const;

    Buffer
    whiteNoise(const float64 & duration) const;

    Buffer
    gaussianNoise(
        const float64 & duration,
        const float64 & mu,
        const float64 & sigma) const;

    Buffer
    tanh(const float64 & duration) const;

    protected:

    Generator();

    virtual
    void
    ctor(const float64 & sample_rate);

    virtual
    void
    ctor(
        const float64 & sample_rate,
        const Buffer & wavetable);

    bool is_realtime_;

    float64  last_frequency_;  
    float64  position_;        
    float64  sync_pos_;        
    float64  sample_rate_;     
    float64  sample_time_;     
    float64  t_;               
    Buffer * waveform_;        

    RandomNumberGenerator * rng_; 

    // buzz() stuff
    uint32               buzz_max_harmonics_;
    std::vector<float64> buzz_position_;

    // Chorus stuff
    boolean              chorus_is_on_;
    uint32               chorus_n_voices_;
    std::vector<float64> chorus_position_;
    std::vector<float64> chorus_factor_;

    // Sync stuff
    boolean sync_is_master_;               
    boolean sync_is_slave_;                
    uint32 sync_count_;                    
    std::vector<uint32> sync_vector_;      
    std::set<Generator *> sync_slaves_;    

};//Generators

}; // Nsound

// :mode=c++: jEdit modeline
#endif