CUAudioWaveform.h

//
//  CUAudioWaveform.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the interface for creating a single-frequency waveform.
//  Examples include sine waves, square waves, sawtooth waves, and triangle
//  waves. This waveform may serve as the source node in an audio graph.
//
//  This module is not intended to be "music quality".  The audio waveforms
//  are good enough for procedural sound generation in most games.  In
//  particular, we use the PolyBLEP technique for bandwidth-limiting our
//  various waveforms. This technique is known to have audible aliasing near
//  the Nyquist frequency and overly attenuate higher frequencies.  However,
//  it is compact and ideal for real-time sound generation.  Because the
//  problems are less of an issue for sound-effect generation, this the
//  approach that we have chosen.
//
//  CUGL MIT License:
//
//     This software is provided 'as-is', without any express or implied
//     warranty.  In no event will the authors be held liable for any damages
//     arising from the use of this software.
//
//     Permission is granted to anyone to use this software for any purpose,
//     including commercial applications, and to alter it and redistribute it
//     freely, subject to the following restrictions:
//
//  1. The origin of this software must not be misrepresented; you must not
//     claim that you wrote the original software. If you use this software
//     in a product, an acknowledgment in the product documentation would be
//     appreciated but is not required.
//
//  2. Altered source versions must be plainly marked as such, and must not
//     be misrepresented as being the original software.
//
//  3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 12/20/18
//
#ifndef __CU_AUDIO_WAVE_FORM_H__
#define __CU_AUDIO_WAVE_FORM_H__
#include <SDL/SDL.h>
#include <cugl/assets/CUJsonValue.h>
#include "CUSound.h"
#include <random>
 
namespace  cugl {
class AudioWaveform : public Sound {
public:
    const static float DEFAULT_FREQUENCY;
    
    enum class Type : int {
        NOISE           = 0,
        SINE            = 1,
        NAIVE_TRIANG    = 2,
        NAIVE_SQUARE    = 3,
        NAIVE_TOOTH     = 4,
        NAIVE_TRAIN     = 5,
        POLY_TRIANG     = 6,
        POLY_SQUARE     = 7,
        POLY_TOOTH      = 8,
        BLIT_TRAIN     = 9,
        UNKNOWN        = 10
    };
    
protected:
    std::atomic<int>    _type;
    std::atomic<bool>   _upper;
    std::atomic<float>  _frequency;
    std::atomic<bool>   _newfreq;
    std::atomic<double> _duration;
 
    std::minstd_rand0   _random;
    
public:
#pragma mark Constructors
 
    AudioWaveform();
    
    ~AudioWaveform() { dispose(); }
    
    bool init();
    
    bool init(Uint8 channels, Uint32 rate);
    
    bool init(Uint8 channels, Uint32 rate, Type type, float frequency);
    
    virtual void dispose() override;
    
#pragma mark Static Constructors
 
    static std::shared_ptr<AudioWaveform> alloc() {
        std::shared_ptr<AudioWaveform> result = std::make_shared<AudioWaveform>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<AudioWaveform> alloc(Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioWaveform> result = std::make_shared<AudioWaveform>();
        return (result->init(channels,rate) ? result : nullptr);
    }
    
    static std::shared_ptr<AudioWaveform> alloc(Uint8 channels, Uint32 rate, Type type, float frequency) {
        std::shared_ptr<AudioWaveform> result = std::make_shared<AudioWaveform>();
        return (result->init(channels,rate,type,frequency) ? result : nullptr);
    }
    
    static std::shared_ptr<AudioWaveform> allocWithData(const std::shared_ptr<JsonValue>& data);
 
#pragma mark Generator Attributes
 
    Type getType() const;
    
    void setType(Type type);
 
    bool isUpper() const;
    
    void setUpper(bool upper);
 
    float getFrequency() const;
    
    void setFrequency(float frequency);
    
    virtual Sint64 getLength() const override;
    
    virtual double getDuration() const override;
    
    void setDuration(double time);
    
    Uint32 generate(float* buffer, Uint32 frames, Uint64 offset, float last);
    
    virtual std::shared_ptr<audio::AudioNode> createNode() override;
};
}
 
#endif /* __CU_AUDIO_WAVE_FORM_H__ */