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>& engine);

};

}

#endif /* __CU_AUDIO_MANAGER_H__ */