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__ */