CUAudioScheduler.h

//
//  CUAudioScheduler.h
//  Cornell University Game Library (CUGL)
//
//  Thie module provides an audio graph node for scheduling different audio
//  nodes.  When combined with AudioPlayer, this provides a classic player
//  node such as you might find in AVFoundation.  However, by generalizing
//  this concept, we are able to schedule arbitrary audio patches as well.
//
//  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_SEQUENCER_H__
#define __CU_AUDIO_SEQUENCER_H__
#include <SDL/SDL.h>
#include "CUAudioNode.h"
#include "CUAudioPlayer.h"
#include <functional>
#include <deque>

namespace cugl {
    namespace audio {

#pragma mark -
#pragma mark Audio Node Queue

class AudioNodeQueue {
private:
    struct Entry {
        std::shared_ptr<AudioNode> value;
        Sint32 loops;
        Entry* next;
        
        Entry(const std::shared_ptr<AudioNode>& node, Sint32 loop) :
            value(node), loops(loop), next(nullptr) { }
    };
    
    Entry* _first;
    std::atomic<Entry*> _divide;
    std::atomic<Entry*> _last;
    
    
public:
#pragma mark Constructors

    AudioNodeQueue();
    
    ~AudioNodeQueue();
    
    
#pragma mark Queue Methods

    bool empty() const { return _divide == _last; }
    
    void push(const std::shared_ptr<AudioNode>& node, Sint32 loops=0);

    bool peek(std::shared_ptr<AudioNode>& node, Sint32& loop) const;
    
    bool pop(std::shared_ptr<AudioNode>& node, Sint32& loop);
    
    bool fill(std::deque<std::shared_ptr<AudioNode>>& container) const;
    
    void clear();
};
    
    
#pragma mark -
#pragma mark Sequencer Node

class AudioScheduler : public AudioNode {
private:
    std::shared_ptr<AudioNode> _current;
    std::shared_ptr<AudioNode> _previous;
    std::atomic<Sint32> _loops;
    std::atomic<Uint32> _overlap;
    float* _buffer;

    AudioNodeQueue _queue;
    
    std::atomic<Uint32> _qsize;
    std::atomic<Uint32> _qskip;

    std::deque<std::shared_ptr<AudioNode>> _memory;
    Sint64 _mempos;
    
public:
#pragma mark Constructors

    AudioScheduler();
    
    ~AudioScheduler();

    virtual bool init() override;
    
    virtual bool init(Uint8 channels, Uint32 rate) override;
    
    virtual void dispose() override;
    
    static std::shared_ptr<AudioScheduler> alloc(Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioScheduler> result = std::make_shared<AudioScheduler>();
        return (result->init(channels, rate) ? result : nullptr);
    }
    
#pragma mark Queue Management

    void play(const std::shared_ptr<AudioNode>& node, Sint32 loop = 0);
    
    void append(const std::shared_ptr<AudioNode>& node, Sint32 loop = 0);
    
    std::shared_ptr<AudioNode> getCurrent() const;
    
    std::deque<std::shared_ptr<AudioNode>> getTail() const;
    
    Uint32 getTailSize() const;
    
    void clear(bool force=false);
    
    void trim(Sint32 size = -1);
    
    void skip(Uint32 n=0);
    
    bool isPlaying();
    
    double getOverlap() const;
    
    void setOverlap(double time);
    
#pragma mark Playback Sequencing

    Sint32 getLoops() const;

    void setLoops(Sint32 loop);
    
    // TODO: Add cross-fade support


#pragma mark Overriden Methods

    virtual Uint32 read(float* buffer, Uint32 frames) override;
    
    virtual bool mark() override;
    
    virtual bool unmark() override;
    
    virtual bool reset() override;
    
    virtual Sint64 advance(Uint32 frames) override;
    
    virtual Sint64 getPosition() const override;
    
    virtual Sint64 setPosition(Uint32 position) override;

    virtual double getElapsed() const override;
    
    virtual double setElapsed(double time) override;
    
#pragma mark Scheduling Helpers
private:
    std::shared_ptr<AudioNode> acquire(Sint32& loop, Uint32 skip=0, Action action=Action::COMPLETE);
};
    }
}

#endif /* __CU_AUDIO_SEQUENCER_H__ */