CUAudioChannels.h

//
//  CUAudioEngine.h
//  Cornell University Game Library (CUGL)
//
//  This module is a singleton providing a legacy (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
//  simpler to use.
//
//  Because this is a singleton, there are no publicly accessible constructors
//  or intializers.  Use the static methods instead.  This singleton should be
//  used instead of AudioManager, and not used at the same time as it.
//
//  This engine has been refactored to take advantage of our more modern audio
//  graph backend.  However, we have kept the legacy API for backwards
//  compatibility with older versions of CUGL.  The mixer graph behind the
//  scenes is a little complicated because we make heavy use of AudioFader.
//  This is to prevent the audible "clicking" that comes when sound is stopped
//  or paused, and was a major problem with OpenAL.
//
//  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: 12/20/18
//
#ifndef __CU_AUDIO_CHANNELS_H__
#define __CU_AUDIO_CHANNELS_H__
#include <cugl/audio/CUAudioManager.h>
#include <cugl/audio/CUSound.h>
#include <cugl/util/CUTimestamp.h>
#include <unordered_map>
#include <functional>
#include <vector>
#include <deque>
#include <queue>

#define DEFAULT_FADE     0.015

namespace cugl {
    namespace audio {
        class AudioOutput;
        class AudioScheduler;
        class AudioMixer;
        class AudioFader;
        class AudioPanner;
    }
class AudioChannels {
#pragma mark Sound State
public:
    enum class State {
        INACTIVE,
        PLAYING,
        PAUSED
    };

private:
    static AudioChannels* _gEngine;

    unsigned int _capacity;
    std::unordered_map<std::string,std::shared_ptr<audio::AudioFader>> _effects;
    std::deque<std::string> _equeue;
    //std::deque<std::string,> _equeue;

    std::shared_ptr<audio::AudioOutput> _output;
    std::shared_ptr<audio::AudioMixer>  _mixer;
    std::vector<std::shared_ptr<audio::AudioScheduler>> _channel;
    std::vector<std::shared_ptr<audio::AudioFader>>     _chfader;

    std::deque<std::shared_ptr<audio::AudioFader>>  _fadePool;
    std::deque<std::shared_ptr<audio::AudioPanner>> _pan1Pool;
    std::deque<std::shared_ptr<audio::AudioPanner>> _pan2Pool;

    std::function<void(Sound* asset, bool status)> _musicCB;

    std::function<void(const std::string& key , bool status)> _soundCB;

#pragma mark -
#pragma mark Constructors (Private)

    AudioChannels();

    ~AudioChannels() { dispose(); }

    bool init();

    bool init(Uint32 slots);

    void dispose();


#pragma mark -
#pragma mark Internal Helpers

    void removeKey(std::string key);

    std::shared_ptr<audio::AudioFader> wrapInstance(const std::shared_ptr<Sound>& asset);

    std::shared_ptr<Sound> accessInstance(const std::shared_ptr<audio::AudioNode>& node) const;

    std::shared_ptr<Sound> disposeInstance(const std::shared_ptr<audio::AudioNode>& node);

    void gcMusic(const std::shared_ptr<audio::AudioNode>& sound, bool status);

    void gcEffect(const std::shared_ptr<audio::AudioNode>& sound, bool status);

#pragma mark -
#pragma mark Static Accessors
public:
    static AudioChannels* get() { return _gEngine; }

    static void start(Uint32 slots);

    static void start(Uint32 channels, Uint32 buffer);

    static void stop();


#pragma mark -
#pragma mark Music Playback

    void playMusic(const std::shared_ptr<Sound>& music, bool loop=false,
                   float volume=-1.0f, float fade=0.0f);

    const Sound* currentMusic() const;

    State getMusicState() const;

    bool isMusicLoop() const;

    void setMusicLoop(bool loop);

    float getMusicVolume() const;

    void setMusicVolume(float volume);

    float getMusicPan() const;

    void setMusicPan(float pan);

    float getMusicDuration() const;

    float getMusicElapsed() const;

    float getMusicRemaining() const;

    void setMusicElapsed(float time);

    void setMusicRemaining(float time);

    void stopMusic(float fade=DEFAULT_FADE);

    void pauseMusic(float fade=DEFAULT_FADE);

    void resumeMusic();

    void setMusicListener(std::function<void(Sound*,bool)> callback) {
        _musicCB = callback;
    }

    std::function<void(Sound*,bool)> getMusicListener() const {
        return _musicCB;
    }

#pragma mark -
#pragma mark Music Queue Management

    void queueMusic(const std::shared_ptr<Sound>& music, bool loop=false,
                    float volume=-1.0f, float fade=0.0f);

    const std::vector<Sound*> getMusicQueue() const;

    size_t getMusicPending() const;

    float getOverlap() const;

    void setOverlap(double time);

    void advanceMusicQueue(float fade=DEFAULT_FADE,unsigned int steps=0);

    void clearMusicQueue();


#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 getEffectPan(const std::string& key) const;

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

    void setEffectPan(const std::string& key, float pan);

    void setEffectPan(const char* key, float pan) {
        setEffectPan(std::string(key),pan);
    }

    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));
    }

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

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

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

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

    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,float fade=DEFAULT_FADE);

    void stopEffect(const char* key,float fade=DEFAULT_FADE) {
        stopEffect(std::string(key));
    }

    void pauseEffect(const std::string& key,float fade=DEFAULT_FADE);

    void pauseEffect(const char* key,float fade=DEFAULT_FADE) {
        pauseEffect(std::string(key));
    }

    void resumeEffect(std::string key);

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

    void stopAllEffects(float fade=DEFAULT_FADE);

    void pauseAllEffects(float fade=DEFAULT_FADE);

    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;
    }

#pragma mark -
#pragma mark Global Management

    void stopAll(float fade=DEFAULT_FADE);

    void pauseAll(float fade=DEFAULT_FADE);

    void resumeAll();
};

}


#endif /* __CU_AUDIO_CHANNELS_H__ */