CUAudioNode.h

//
//  CUAudioNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides the base class for a node in the audio graph.  While
//  you will never use this class directly, it provides the base features that
//  allow for a polymorphic audio graph.
//
//  The audio graph and its nodes will always be accessed by two threads: the
//  main thread and the audio thread.  The audio graph is designed to safely
//  coordinate between these two threads.  However, it is minimizes locking
//  and instead relies on a fail-fast model.  If part of the audio graph is
//  not in a state to be used by the audio thread, it will skip over that part
//  of the graph until the next render frame.  Hence some changes should only
//  be made if the graph is paused.  When there is some question about the
//  thread safety, the methods are clearly marked.
//
//  It is NEVER safe to access the audio graph outside of the main thread. The
//  coordination algorithms only assume coordination between two threads.
//
//  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: 11/20/18
//
#ifndef __CU_AUDIO_NODE_H__
#define __CU_AUDIO_NODE_H__
#include <SDL/SDL.h>
#include <atomic>
#include <memory>
#include <functional>
#include <string>
 
namespace cugl {
    
    namespace audio {
    
class AudioNode : public std::enable_shared_from_this<AudioNode> {
public:
    enum Action : int {
        COMPLETE  = 0,
        INTERRUPT = 1,
        FADE_OUT  = 2,
        FADE_IN   = 3,
        FADE_DIP  = 4,
        LOOPBACK  = 5
    };
    
    typedef std::function<void (const std::shared_ptr<AudioNode>& node, Action type)> Callback;
 
    std::string _classname;
 
#pragma mark Values
protected:
    Uint8  _channels;
    
    Uint32 _sampling;
 
    bool _booted;
    
    std::atomic<float> _ndgain;
    
    std::atomic<bool> _paused;
 
    std::atomic<bool> _polling;
    
    Callback _callback;
    std::atomic<bool> _calling;
 
    Sint32 _tag;
    
    std::string _localname;
    
    //std::string _classname;
    
    size_t _hashOfName;
    
    void notify(const std::shared_ptr<AudioNode>& node, Action action);
    
#pragma mark -
#pragma mark Static Attributes
public:
    const static Uint32 DEFAULT_CHANNELS;
    
    const static Uint32 DEFAULT_SAMPLING;
    
#pragma mark -
#pragma mark Constructors
 
    AudioNode();
    
    virtual ~AudioNode();
    
    virtual bool init();
    
    virtual bool init(Uint8 channels, Uint32 rate);
    
    virtual void dispose();
    
#pragma mark -
#pragma mark Node Attributes
 
    Uint8 getChannels() const { return _channels; }
    
    Uint32 getRate() const { return _sampling; }
    
    float getGain();
    
    virtual void setGain(float gain);
    
    const std::string& getName() const { return _localname; }
    
    void setName(const std::string& name);
 
    void setName(const char* name) {
        setName(std::string(name));
    }
    
    Sint32 getTag() const { return _tag; }
    
    void setTag(Sint32 tag) { _tag = tag; }
 
    virtual std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }
    
#pragma mark -
#pragma mark Playback Controls
 
    Callback getCallback();
    
    void setCallback(Callback callback);
    
    virtual bool isPaused();
    
    virtual bool pause();
    
    virtual bool resume();
    
    virtual bool completed() { return false; }
    
    virtual Uint32 read(float* buffer, Uint32 frames);
 
#pragma mark -
#pragma mark Optional Methods
 
    virtual bool mark() { return false; }
 
    virtual bool unmark() { return false; }
    
    virtual bool reset() { return false; }
    
    virtual Sint64 advance(Uint32 frames) { return -1; }
    
    virtual Sint64 getPosition() const { return -1; }
    
    virtual Sint64 setPosition(Uint32 position) { return -1; }
    
    virtual double getElapsed() const { return -1; }
    
    virtual double setElapsed(double time) { return -1; }
 
    virtual double getRemaining() const { return -1; }
    
    virtual double setRemaining(double time) { return -1; }
    
};
    }
}
 
#endif /* __CU_AUDIO_NODE_H__ */