CUAudioEngine.h

//
//  CUAudioEngine.h
//  Cornell University Game Library (CUGL)
//
//  This module is a singleton providing a simple 2000-era audio engine.  Like
//  all engines of this era, it provides a flat channel structure for playing
//  sounds as well as a single channel for background music.  This is much
//  more primitive than modern sound engines, with the advantage that it is
//  much simpler to use.
//
//  Because this is a singleton, there are no publicly accessible constructors
//  or intializers.  Use the static methods instead.
//
//  We have factored out the platform-dependent code and have hidden it
//  behind this class as an abstraction.
//
//  CUGL zlib 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/10/16
//
#ifndef __CU_AUDIO_ENGINE_H__
#define __CU_AUDIO_ENGINE_H__
#include <cugl/audio/CUSound.h>
#include <cugl/audio/CUMusic.h>
#include <cugl/util/CUTimestamp.h>
#include <functional>
#include <unordered_map>
#include <vector>
#include <deque>

#define AUDIO_INPUT_CHANNELS  24

#define AUDIO_OUTPUT_CHANNELS 2

#define AUDIO_FREQUENCY 44100

#if defined (__MACOSX__) || defined (__IPHONEOS__)
    #define CU_AUDIO_AVFOUNDATION 1
#endif


namespace cugl {
    
class SoundChannel;
class MusicQueue;
    
class AudioEngine {
#pragma mark -
#pragma mark Sound State
public:
    enum class State {
        INACTIVE,
        PLAYING,
        PAUSED
    };

    
private:
    static AudioEngine* _gEngine;
    
    std::shared_ptr<MusicQueue> _mqueue;
    
    unsigned int _capacity;
    std::vector<std::shared_ptr<SoundChannel>> _channels;
    std::unordered_map<std::string,int> _effects;
    std::deque<std::string> _equeue;
    
    std::function<void(Music* asset, bool status)> _musicCB;

    std::function<void(const std::string& key , bool status)> _soundCB;
    
#pragma mark -
#pragma mark Constructors (Private)

    AudioEngine() : _capacity(0) {}
    
    ~AudioEngine() { dispose(); }
    
    bool init(unsigned int channels=AUDIO_INPUT_CHANNELS);
    
    void dispose();

    
#pragma mark -
#pragma mark Internal Helpers

    void removeKey(std::string key);
    
    
#pragma mark -
#pragma mark Static Accessors
public:
    static AudioEngine* get() { return _gEngine; }
    
    static void start(unsigned int channels=AUDIO_INPUT_CHANNELS);
    
    static void stop();
    
    
#pragma mark -
#pragma mark Music Management

    void playMusic(const std::shared_ptr<Music>& music, bool loop=false, float volume=-1.0f, float fade=0.0f);
    
    const Music* currentMusic() const;
    
    State getMusicState() const;
    
    bool isMusicLoop() const;
    
    void setMusicLoop(bool loop);  // Clears the queue
    
    float getMusicVolume() const;
    
    void setMusicVolume(float volume);
    
    float getMusicDuration() const;
    
    float getMusicElapsed() const;
    
    float getMusicRemaining() const;
    
    void setMusicElapsed(float time);
    
    void setMusicRemaining(float time);
    
    void stopMusic(float fade=0.0f);
    
    void clearMusicQueue();
    
    void pauseMusic();
    
    void resumeMusic();
    
    void setMusicListener(std::function<void(Music*,bool)> callback) {
        _musicCB = callback;
    }
    
    std::function<void(Music*,bool)> getMusicListener() const {
        return _musicCB;
    }
    
    void gcMusic(bool status);
    
    
#pragma mark -
#pragma mark Music Queue

    void queueMusic(const std::shared_ptr<Music>& music, bool loop=false, float volume=-1.0f, float fade=0.0f);
    
    const std::vector<const Music*> getMusicQueue() const;
    
    size_t getMusicQueueSize() const;
    
    void advanceMusicQueue(unsigned int steps=0);
    
    
#pragma mark -
#pragma mark Sound Effect Management

    bool playEffect(const std::string& key, const std::shared_ptr<Sound>& sound,
                    bool loop=false, float volume=-1.0f, bool force=false);

    bool playEffect(const char* key, const std::shared_ptr<Sound>& sound,
                    bool loop=false, float volume=-1.0f, bool force=false) {
        return playEffect(std::string(key),sound,loop,volume,force);
    }

    size_t getAvailableChannels() const {
        return (size_t)_capacity-_effects.size();
    }
    
    State getEffectState(const std::string& key) const;

    State getEffectState(const char* key) const {
        return getEffectState(std::string(key));
    }
    
    bool isActiveEffect(const std::string& key) const {
        return _effects.find(key) != _effects.end();
    }

    bool isActiveEffect(const char* key) const {
        return isActiveEffect(std::string(key));
    }
    
    const Sound* currentEffect(const std::string& key) const;

    const Sound* currentEffect(const char* key) const {
        return currentEffect(std::string(key));
    }

    bool isEffectLoop(const std::string& key) const;

    bool isEffectLoop(const char* key) const {
        return isEffectLoop(std::string(key));
    }
    
    void setEffectLoop(const std::string& key, bool loop);

    void setEffectLoop(const char* key, bool loop) {
        setEffectLoop(std::string(key),loop);
    }
    
    float getEffectVolume(const std::string& key) const;
    
    float getEffectVolume(const char* key) const {
        return getEffectVolume(std::string(key));
    }
    
    void setEffectVolume(const std::string& key, float volume);

    void setEffectVolume(const char* key, float volume) {
        setEffectVolume(std::string(key),volume);
    }

    float getEffectDuration(const std::string& key) const;

    float getEffectDuration(const char* key) const {
        return getEffectDuration(std::string(key));
    }
    
    float getEffectElapsed(const std::string& key) const;
    
    float getEffectElapsed(const char* key) const {
        return getEffectElapsed(std::string(key));
    }
    
    float getEffectRemaining(const std::string& key) const;

    float getEffectRemaining(const char* key) const {
        return getEffectRemaining(std::string(key));
    }

    void setEffectElapsed(const std::string& key, float time);

    void setEffectElapsed(const char* key, float time) {
        setEffectElapsed(std::string(key),time);
    }
    
    void setEffectRemaining(const std::string& key, float time);

    void setEffectRemaining(const char* key, float time) {
        setEffectRemaining(std::string(key),time);
    }
    
    void stopEffect(const std::string& key);
    
    void stopEffect(const char* key) {
        stopEffect(std::string(key));
    }
    
    void pauseEffect(const std::string& key);

    void pauseEffect(const char* key) {
        pauseEffect(std::string(key));
    }

    void resumeEffect(std::string key);

    void resumeEffect(const char* key) {
        resumeEffect(std::string(key));
    }
    
    void stopAllEffects();
    
    void pauseAllEffects();
    
    void resumeAllEffects();
    
    void setEffectListener(std::function<void(const std::string& key,bool)> callback) {
        _soundCB = callback;
    }
    
    std::function<void(const std::string& key,bool)> getEffectListener() const {
        return _soundCB;
    }

    void gcEffect(int id, bool status);
    
    
#pragma mark -
#pragma mark Global Management

    void stopAll();
    
    void pauseAll();
    
    void resumeAll();
};

}


#endif /* __CU_AUDIO_ENGINE_H__ */