CUAudioOutput.h

//
//  CUAudioOutput.h
//  Cornell University Game Library (CUGL)
//
//  This module provides interface to an audio output device. As such, it is
//  often the final node in an audio stream DAG. It is analogous to AVAudioEngine
//  in Apple's AVFoundation API. The main differences is that it does not have
//  a dedicated mixer node.  Instead, you attach the single terminal node of the
//  audio graph.  In addition, it is possible to have a distinct audio graph for
//  each output device.
//
//  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: 8/20/18
//
#ifndef __CU_AUDIO_OUTPUT_H__
#define __CU_AUDIO_OUTPUT_H__
#include <SDL/SDL.h>
#include "CUAudioNode.h"
#include <cugl/math/dsp/CUBiquadIIR.h>
#include <unordered_set>
#include <string>
#include <memory>
#include <vector>
 
namespace cugl {
    
    class AudioManager;
    
    namespace audio {
class AudioOutput : public AudioNode {
private:
    std::string _dvname;
    
    std::atomic<Uint64> _overhd;
 
    SDL_AudioDeviceID _device;
    SDL_AudioSpec  _audiospec;
    
    std::atomic<bool> _active;
 
    std::shared_ptr<AudioNode> _input;
    
    SDL_AudioStream* _resampler;
    float* _cvtbuffer;
    float  _cvtratio;
    size_t _bitrate;
 
#pragma mark -
#pragma mark AudioManager Methods
 
    virtual bool init() override;
 
    virtual bool init(Uint8 channels, Uint32 rate) override;
    
    bool init(Uint8 channels, Uint32 rate, Uint32 buffer);
    
    bool init(const std::string& device);
    
    bool init(const std::string& device, Uint8 channels, Uint32 rate, Uint32 buffer);
    
    virtual void dispose() override;
    
    void setActive(bool active);
 
    friend class cugl::AudioManager;
    
public:
    AudioOutput();
    
    ~AudioOutput();
 
#pragma mark -
#pragma mark Data Access
 
    const SDL_AudioDeviceID getAUID() const  { return _device; }
    
    const std::string& getDevice() const;
 
    bool isDefault() const { return _dvname == ""; }
    
    Uint16 getCapacity()  const { return _audiospec.samples;  }
 
     size_t getBitRate()  const { return _bitrate;  }
    
#pragma mark -
#pragma mark Audio Graph
 
    bool attach(const std::shared_ptr<AudioNode>& node);
    
    std::shared_ptr<AudioNode> detach();
    
    std::shared_ptr<AudioNode> getInput() { return _input; }
    
#pragma mark -
#pragma mark Playback Control
 
    virtual bool pause() override;
    
    virtual bool resume() override;
    
    virtual bool completed() override;
    
    virtual Uint32 read(float* buffer, Uint32 frames) override;
   
    void reboot();
    
    Uint64 getOverhead() const;
    
#pragma mark -
#pragma mark Optional Methods
 
    virtual bool mark() override;
    
    virtual bool unmark() override;
    
    virtual bool reset() override;
    
    virtual Sint64 advance(Uint32 frames) override;
    
    virtual Sint64 getPosition() const override;
    
    virtual Sint64 setPosition(Uint32 position) override;
    
    virtual double getElapsed() const override;
    
    virtual double setElapsed(double time) override;
    
    virtual double getRemaining() const override;
    
    virtual double setRemaining(double time) override;
  
    // TODO: May need to add a push option.
};
    }
}
 
#endif /* __CU_AUDIO_OUTPUT_H__ */