CUAudioSynchronizer.h

//
//  CUAudioSynchronizer.h
//  CUGL
//
//  Created by Walker White on 1/27/19.
//  Copyright © 2019 Game Design Initiative at Cornell. All rights reserved.
//
 
#ifndef __CU_AUDIO_SYNCHRONIZER_H__
#define __CU_AUDIO_SYNCHRONIZER_H__
#include <cugl/audio/graph/CUAudioNode.h>
#include <cugl/util/CUTimestamp.h>
#include <atomic>
#include <mutex>
 
namespace cugl {
    namespace audio {
class AudioSynchronizer : public AudioNode {
private:
    std::shared_ptr<AudioNode> _input;
    
    std::mutex _mutex;
    
    std::atomic<double> _overhead;
 
    std::atomic<double> _jitter;
 
    std::atomic<double> _inputBPM;
    std::atomic<Sint32> _prevbeat;
 
 
    std::atomic<timestamp_t> _timestamp;
    
    std::atomic<Sint32> _liveStart;
    std::atomic<Sint32> _liveDone;
    std::atomic<Sint32> _waitStart;
    std::atomic<Sint32> _waitDone;
 
    float* _buffer;
    Uint32 _capacity;
    
#pragma mark -
#pragma mark Constructors
public:
    AudioSynchronizer();
    
    ~AudioSynchronizer() { dispose(); }
    
    virtual bool init() override;
    
    virtual bool init(Uint8 channels, Uint32 rate) override;
    
    virtual void dispose() override;
    
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<AudioSynchronizer> alloc() {
        std::shared_ptr<AudioSynchronizer> result = std::make_shared<AudioSynchronizer>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<AudioSynchronizer> alloc(Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioSynchronizer> result = std::make_shared<AudioSynchronizer>();
        return (result->init(channels,rate) ? result : nullptr);
    }
 
#pragma mark -
#pragma mark Synchronization Methods
 
    double getOverhead() const {
        return _overhead.load(std::memory_order_relaxed);
    }
 
    void setOverhead(double overhead);
 
    double getJitter() const {
        return _jitter.load(std::memory_order_relaxed);
    }
 
    void clearJitter();
    
    bool onBeat();
    
#pragma mark -
#pragma mark Audio Graph
 
    bool attach(const std::shared_ptr<AudioNode>& node, double bpm=0.0);
    
    std::shared_ptr<AudioNode> detach();
    
    std::shared_ptr<AudioNode> getInput() const { return _input; }
    
#pragma mark -
#pragma mark Playback Control
 
    virtual bool completed() override;
    
    virtual Uint32 read(float* buffer, Uint32 frames) override;
    
#pragma mark -
#pragma mark Optional Methods
 
    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;
    
    virtual double getRemaining() const override;
    
    virtual double setRemaining(double time) override;
};
    }
}
#endif /* __CU_AUDIO_SYNCHRONIZER_H__ */