CUAudioManager.h

//
//  CUAudiomanager.h
//  Cornell University Game Library (CUGL)
//
//  This module is a singleton for managing audio in the game engine. This
//  singleton can support multiple input and output devices for complex
//  filter graphs. This class is for when developers needs direct access
//  to the audio graph(s).  In most cases, developers can use AudioChannels
//  instead, which is built on top of this manager.
//
//  Because this is a singleton, there are no publicly accessible constructors
//  or intializers.  Use the static methods instead.
//
//  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_MANAGER_H__
#define __CU_AUDIO_MANAGER_H__
#include <SDL/SDL.h>
#include <unordered_map>
#include <vector>
#include <memory>
#include <mutex>
 
namespace cugl {
 
    namespace audio {
        class AudioOutput;
        class AudioInput;
    }
 
class AudioManager {
private:
    static AudioManager* _gManager;
    std::mutex _mutex;
    bool _active;
    Uint32 _output;
    Uint32 _input;
 
    std::unordered_map<std::string, std::shared_ptr<audio::AudioOutput>> _outputs;
    std::unordered_map<std::string, std::shared_ptr<audio::AudioInput>>  _inputs;
 
#pragma mark -
#pragma mark Constructors (Private)
 
    AudioManager();
 
    ~AudioManager() { dispose(); }
 
    bool init(Uint32 output, Uint32 input);
 
    void dispose();
 
 
#pragma mark -
#pragma mark Static Attributes
public:
    static const Uint32 DEFAULT_OUTPUT_BUFFER;
 
    static const Uint32 DEFAULT_INPUT_BUFFER;
 
#pragma mark -
#pragma mark Static Accessors
 
    static AudioManager* get() { return _gManager; }
 
    static void start();
 
    static void start(Uint32 frames);
 
    static void start(Uint32 output, Uint32 input);
 
    static void stop();
 
    static std::vector<std::string> devices(bool output);
 
    static std::vector<std::string> occupied(bool output);
 
#pragma mark -
#pragma mark Manager Properties
 
    Uint32 getReadSize() const { return _output; }
 
    Uint32 getWriteSize() const { return _input; }
 
    bool isActive();
 
    void activate();
 
    void deactivate();
 
    void reset();
 
 
#pragma mark -
#pragma mark Output Devices
 
    std::shared_ptr<audio::AudioOutput> openOutput();
 
    std::shared_ptr<audio::AudioOutput> openOutput(Uint8 channels, Uint32 rate);
 
    std::shared_ptr<audio::AudioOutput> openOutput(const char* device);
 
    std::shared_ptr<audio::AudioOutput> openOutput(const std::string& device);
 
    std::shared_ptr<audio::AudioOutput> openOutput(const char* device, Uint8 channels, Uint32 rate);
 
    std::shared_ptr<audio::AudioOutput> openOutput(const std::string& device, Uint8 channels, Uint32 rate);
 
    bool closeOutput(const std::shared_ptr<audio::AudioOutput>& device);
 
#pragma mark -
#pragma mark Input Devices
 
    std::shared_ptr<audio::AudioInput> openInput();
 
    std::shared_ptr<audio::AudioInput> openInput(Uint8 channels, Uint32 rate, Uint32 delay);
 
    std::shared_ptr<audio::AudioInput> openInput(const char* device);
 
    std::shared_ptr<audio::AudioInput> openInput(const std::string& device);
 
    std::shared_ptr<audio::AudioInput> openInput(const char* device, Uint8 channels, Uint32 rate, Uint32 delay);
 
    std::shared_ptr<audio::AudioInput> openInput(const std::string& device, Uint8 channels, Uint32 rate, Uint32 delay);
 
    bool closeInput(const std::shared_ptr<audio::AudioInput>& device);
 
};
 
}
 
#endif /* __CU_AUDIO_MANAGER_H__ */