CUAudioResampler.h

//
//  CUAudioResampler.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a graph node for converting from one sample rate to
//  another.  It uses SDL_AudioStream to perform continuous resampling on a
//  potentially infinite audio stream.  This is is necessary for cross-platform
//  reasons as iPhones are very stubborn about delivering any requested sampling
//  rates other than 48000.
//
//  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: 1/26/19
//
#ifndef __CU_AUDIO_RESAMPLER_H__
#define __CU_AUDIO_RESAMPLER_H__
#include <cugl/audio/graph/CUAudioNode.h>
#include <SDL/SDL.h>
#include <mutex>
#include <atomic>
 
namespace cugl {
    
    namespace audio {
class AudioResampler : public AudioNode {
private:
    mutable std::mutex _buffmtex;
 
    std::shared_ptr<AudioNode> _input;
    
    SDL_AudioStream* _resampler;
    Uint32 _inputrate;
    float* _cvtbuffer;
    size_t _capacity;
    std::atomic<float>  _cvtratio;
    
public:
#pragma mark -
#pragma mark Constructors
 
    AudioResampler();
    
    ~AudioResampler() { 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<AudioResampler> alloc() {
        std::shared_ptr<AudioResampler> result = std::make_shared<AudioResampler>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<AudioResampler> alloc(Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioResampler> result = std::make_shared<AudioResampler>();
        return (result->init(channels,rate) ? result : nullptr);
    }
    
#pragma mark -
#pragma mark Audio Graph
 
    bool attach(const std::shared_ptr<AudioNode>& node);
    
    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_RESAMPLER_H__ */