AudioStream.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
//  $Id: AudioStream.h 912 2015-07-26 00:50: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) 2004-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_AUDIO_STREAM_H_
#define _NSOUND_AUDIO_STREAM_H_

#include <Nsound/Nsound.h>
#include <Nsound/AudioStreamSelection.h>
#include <Nsound/Buffer.h>

#include <iostream>
#include <string>
#include <vector>

namespace Nsound
{

//-----------------------------------------------------------------------------
//
//  Class AudioStream
//
//-----------------------------------------------------------------------------
class AudioStream
{

public:

    AudioStream();
    AudioStream(
        float64 sample_rate,
        uint32 n_channels = 1,
        uint32 n_samples_pre_allocate = 4096);

    AudioStream(const std::string & filename);

    ~AudioStream();

    AudioStream(const AudioStream & rhs);

    // abs()
    //
    //
    void
    abs();

    AudioStream
    getAbs() const
    {AudioStream temp(*this); temp.abs(); return temp;};

    // add()
    //
    //
    void
    add(const AudioStream & as,
        uint32 offset,
        uint32 n_samples = 0);

    // add()
    //
    //
    void
    add(
        const AudioStream & as,
        float64 offset_seconds,
        float64 duration_seconds = 0.0);

    void
    convolve(const Buffer & b);

    AudioStream
    getConvolve(const Buffer & b) const
    { AudioStream temp(*this); temp.convolve(b); return temp; };

    void
    dB();

    AudioStream
    getdB() const
    {AudioStream temp(*this); temp.dB(); return temp;};

    void
    derivative(uint32 n);

    AudioStream
    getDerivative(uint32 n) const
    { AudioStream temp(*this); temp.derivative(n); return temp; };

    void
    downSample(uint32 n);

    AudioStream
    getDownSample(uint32 n) const
    { AudioStream temp(*this); temp.downSample(n); return temp; };

    float64
    getDuration() const;

    uint32
    getLength() const;

    void
    limit(float64 min, float64 max);

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

    AudioStream
    getLimit(float64 min, float64 max) const
    { AudioStream temp(*this); temp.limit(min, max); return temp; };

    AudioStream
    getLimit(const Buffer & min, const Buffer & max) const
    { AudioStream temp(*this); temp.limit(min, max); return temp; };

    float64
    getMax() const;

    float64
    getMaxMagnitude() const;

    float64
    getMin() const;

    void
    mono();

    AudioStream
    getMono() const;

    inline
    uint32
    getNChannels(void) const {return channels_;}

    inline
    float64
    getSampleRate() const {return sample_rate_;}

    void
    normalize();

    AudioStream
    getNormalize() const
    {AudioStream temp(*this); temp.normalize(); return temp;};

    AudioStreamSelection
    operator()(const BooleanVectorVector & bv);

    const Buffer &
    operator[](uint32 index) const;

    Buffer &
    operator[](uint32 index);

    //  Operator ()
    float64
    operator()(uint32 channel, uint32 index) const;

    //  Operator =
    AudioStream &
    operator=(const AudioStream & rhs);

    //  Operator =
    AudioStream &
    operator=(const Buffer & rhs);

    //  Operator ==
    boolean
    operator==(const AudioStream & rhs) const;

    //  Operator !=
    inline boolean
    operator!=(const AudioStream & rhs) const {return !(*this == rhs);};

    AudioStream &
    operator<<(const AudioStream & rhs);

    AudioStream &
    operator<<(const Buffer & rhs);

    AudioStream &
    operator<<(float64 d);

    BooleanVectorVector operator>(float64 rhs);
    BooleanVectorVector operator>=(float64 rhs);
    BooleanVectorVector operator<(float64 rhs);
    BooleanVectorVector operator<=(float64 rhs);
    BooleanVectorVector operator==(float64 rhs);
    BooleanVectorVector operator!=(float64 rhs);

    //
    //  math operators
    //
    // DOXME
    AudioStream & operator+=(const AudioStream & rhs);
    AudioStream & operator-=(const AudioStream & rhs);
    AudioStream & operator*=(const AudioStream & rhs);
    AudioStream & operator/=(const AudioStream & rhs);
    AudioStream & operator^=(const AudioStream & rhs);

    AudioStream & operator+=(const Buffer & rhs);
    AudioStream & operator-=(const Buffer & rhs);
    AudioStream & operator*=(const Buffer & rhs);
    AudioStream & operator/=(const Buffer & rhs);
    AudioStream & operator^=(const Buffer & rhs);

    AudioStream & operator+=(float64 d);
    AudioStream & operator-=(float64 d);
    AudioStream & operator*=(float64 d);
    AudioStream & operator/=(float64 d);
    AudioStream & operator^=(float64 d);

    #ifndef SWIG
    //  Output Operator << AudioStream
    // DOXME
    friend
    std::ostream &
    operator<<(std::ostream & out, const AudioStream & rhs);
    #endif

    //
    // DOXME
    void
    pad(float64 fill = 0.0);

    //
    // DOXME
    AudioStream
    getPad(float64 fill = 0.0) const
    { AudioStream temp(*this); temp.pad(fill); return temp;};

    //
    //
    void
    pan(float64 pan);

    //
    //
    AudioStream
    getPan(float64 pan) const
    { AudioStream temp(*this); temp.pan(pan); return temp;};

    //
    //
    void
    pan(const Buffer & pan);

    //
    //
    AudioStream
    getPan(const Buffer & pan) const
    { AudioStream temp(*this); temp.pan(pan); return temp;};

    // Plot the AudioStream
    void
    plot(const std::string & title = "AudioStream") const;

    void
    readWavefile(const char * filename);

    void
    resample(float64 factor);

    void
    resample(const Buffer & factor);

    AudioStream
    getResample(float64 factor) const
    { AudioStream temp(*this); temp.resample(factor); return temp; };

    AudioStream
    getResample(const Buffer & factor) const
    { AudioStream temp(*this); temp.resample(factor); return temp; };

    void
    resample2(float64 new_sample_rate);

    AudioStream
    getResample2(float64 new_sample_rate) const
    {
        AudioStream temp(*this);
        temp.resample2(new_sample_rate);
        return temp;
    };

    // reverse()
    void
    reverse();

    AudioStream
    getReverse() const
    {AudioStream temp(*this); temp.reverse(); return temp;};

    //
    AudioStreamSelection
    select(const uint32 start_index, const uint32 stop_index);

    //
    //
    std::ostream &
    write(std::ostream & out) const;

    std::string
    write() const;

    //
    //
    std::istream &
    read(std::istream & stream_in);

    void
    read(const std::string & string_in);

    //  setNChannels()
    // DOXME
    void
    setNChannels(uint32 channels);

    // setSampleRate()
    // DOXME
    inline
    void
    setSampleRate(uint32 sample_rate) {sample_rate_ = sample_rate;}

    //
    void
    smooth(uint32 n_passes, uint32 n_samples_per_average);

    AudioStream
    getSmooth(uint32 n_passes, uint32 n_samples_per_average) const
    {AudioStream temp(*this); temp.smooth(n_passes, n_samples_per_average); return temp;};

    void
    speedUp(float32 step_size);

    AudioStream
    getSpeedUp(float32 step_size) const
    { AudioStream temp(*this); temp.speedUp(step_size); return temp; };

    void
    speedUp(const Buffer & step_size);

    AudioStream
    getSpeedUp(const Buffer & step_size) const
    { AudioStream temp(*this); temp.speedUp(step_size); return temp; };

    void
    sqrt();

    AudioStream
    getSqrt() const
    { AudioStream temp(*this); temp.sqrt(); return temp; };

    // DOXME
    AudioStream
    substream(uint32 start_index, uint32 n_samples = 0) const;

    AudioStream
    substream(int32 start_index, int32 n_samples = 0) const;

    // DOXME
    AudioStream
    substream(float64 start_time, float64 duration = 0) const;

    //
    void
    transpose();

    AudioStream
    getTranspose() const
    { AudioStream temp(*this); temp.transpose(); return temp; };

    void
    upSample(uint32 n);

    AudioStream
    getUpSample(uint32 n) const
    { AudioStream temp(*this); temp.upSample(n); return temp; };

    void
    writeWavefile(const char * filename) const;

    void _set_at_index(int32 i, const Buffer &);

    void _swig_shadow(){};

    static
    AudioStream
    ones(
        float64 sample_rate,
        const uint32 n_channels,
        float64 duration);

    static
    AudioStream
    rand(
        float64 sample_rate,
        const uint32 n_channels,
        float64 duration);

    static
    AudioStream
    zeros(
        float64 sample_rate,
        const uint32 n_channels,
        float64 duration);

private:

//~    // DOXME
//~    enum MathOperator
//~    {
//~        ADD,
//~        SUBTRACT,
//~        MULTIPLY,
//~        DIVIDE,
//~        POW
//~    };

//~
//~
//~    AudioStream & vectorOperator(const AudioStream & rhs, MathOperator op);
//~    AudioStream & scalarOperator(float64 rhs, MathOperator op);

    // Data members

    float64  sample_rate_;
    uint32   channels_;

    std::vector<Buffer *> buffers_;

}; // class

//-----------------------------------------------------------------------------
// Non class methods

inline AudioStream operator+(const AudioStream & lhs, const AudioStream & rhs)
{
    AudioStream temp(lhs);
    return temp += rhs;
}

inline AudioStream operator-(const AudioStream & lhs, const AudioStream & rhs)
{
    AudioStream temp(lhs);
    return temp -= rhs;
}

inline AudioStream operator*(const AudioStream & lhs, const AudioStream & rhs)
{
    AudioStream temp(lhs);
    return temp *= rhs;
}

inline AudioStream operator/(const AudioStream & lhs, const AudioStream & rhs)
{
    AudioStream temp(lhs);
    return temp /= rhs;
}

inline AudioStream operator^(const AudioStream & lhs, const AudioStream & rhs)
{
    AudioStream temp(lhs);
    return temp ^= rhs;
}

inline AudioStream operator+(const AudioStream & lhs, const Buffer & rhs)
{
    AudioStream temp(lhs);
    return temp += rhs;
}

inline AudioStream operator-(const AudioStream & lhs, const Buffer & rhs)
{
    AudioStream temp(lhs);
    return temp -= rhs;
}

inline AudioStream operator*(const AudioStream & lhs, const Buffer & rhs)
{
    AudioStream temp(lhs);
    return temp *= rhs;
}

inline AudioStream operator/(const AudioStream & lhs, const Buffer & rhs)
{
    AudioStream temp(lhs);
    return temp /= rhs;
}

inline AudioStream operator^(const AudioStream & lhs, const Buffer & rhs)
{
    AudioStream temp(lhs);
    return temp ^= rhs;
}

inline AudioStream operator+(const AudioStream & lhs, float64 d)
{
    AudioStream temp(lhs);
    return temp += d;
}

inline AudioStream operator-(const AudioStream & lhs, float64 d)
{
    AudioStream temp(lhs);
    return temp -= d;
}

inline AudioStream operator*(const AudioStream & lhs, float64 d)
{
    AudioStream temp(lhs);
    return temp *= d;
}

inline AudioStream operator/(const AudioStream & lhs, float64 d)
{
    AudioStream temp(lhs);
    return temp /= d;
}

inline AudioStream operator^(const AudioStream & lhs, float64 d)
{
    AudioStream temp(lhs);
    return temp ^= d;
}

inline AudioStream operator+(float64 d, const AudioStream & rhs)
{
    AudioStream temp(rhs);
    return temp += d;
}

inline AudioStream operator-(float64 d, const AudioStream & rhs)
{
    AudioStream temp(rhs * -1.0);
    return temp += d;
}

inline AudioStream operator*(float64 d, const AudioStream & rhs)
{
    AudioStream temp(rhs);
    return temp *= d;
}

inline AudioStream operator/(float64 d, const AudioStream & rhs)
{
    AudioStream temp(rhs.getSampleRate(), rhs.getNChannels());

    for(uint32 i = 0; i < rhs.getNChannels(); ++i)
    {
        temp[i] = d / rhs[i];
    }

    return temp;
}


}// Nsound

// :mode=c++:

#endif