CUAudioSpinner.h

//
//  CUAudioSpinnner.h
//  Cornell University Game Library (CUGL)
//
//  This module is a spatial audio audio panner.  It is used to rotate or
//  or "spin" a sound input about a sound field.  Doing this requires
//  specification of the audio channels angles about a circle.  There are
//  several default sound set-ups, but the user can specify any configuration
//  that they want.  This module is also useful for directing sound to a
//  subwoofer.
//
//  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/5/18
//
#ifndef __CU_AUDIO_SPINNER_H__
#define __CU_AUDIO_SPINNER_H__
#include "CUAudioNode.h"
#include <cugl/math/dsp/cu_dsp.h>
#include <atomic>

namespace cugl {
    namespace audio {

class AudioSpinner : public AudioNode {
public:
    enum Plan : int {
        MONAURAL     = 0,
        FRONT_STEREO = 1,
        SIDE_STEREO  = 2,
        FRONT_CENTER = 3,
        SIDE_CENTER  = 4,
        FRONT_QUADS  = 5,
        CORNER_QUADS = 6,
        BACK_5_1     = 7,
        SIDE_5_1     = 8,
        CORNER_5_1   = 9,
        BACK_7_1     = 10,
        CORNER_7_1   = 11,
        CUSTOM       = 12,
    };
    
private:
    Uint8 _field;
    std::atomic<Plan>   _inplan;
    std::atomic<Plan>   _outplan;
    std::atomic<float>* _inlines;
    std::atomic<float>* _outlines;
    std::atomic<float>  _angle;
    
    std::atomic<float> _crossover;
    std::atomic<bool>  _dirtycross;
    cugl::dsp::BiquadIIR* _filter;
    
    float* _buffer;
    Uint32 _capacity;
    
    std::shared_ptr<AudioNode> _input;

    Plan getDefaultPlan(Uint8 channels);

    bool isValidPlan(Plan plan, Uint8 channels);

    void initPlan(Plan plan, std::atomic<float>* lines);

#pragma mark -
#pragma mark Constructors
public:
    AudioSpinner();
    
    ~AudioSpinner() { dispose(); }
    
    virtual bool init() override;
    
    virtual bool init(Uint8 channels, Uint32 rate) override;
    
    bool init(Uint8 channels, Uint8 field, Uint32 rate);
    
    virtual void dispose() override;
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<AudioSpinner> alloc() {
        std::shared_ptr<AudioSpinner> result = std::make_shared<AudioSpinner>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<AudioSpinner> alloc(Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioSpinner> result = std::make_shared<AudioSpinner>();
        return (result->init(channels,rate) ? result : nullptr);
    }
    
    static std::shared_ptr<AudioSpinner> alloc(Uint8 channels, Uint8 field, Uint32 rate) {
        std::shared_ptr<AudioSpinner> result = std::make_shared<AudioSpinner>();
        return (result->init(channels,field,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() { return _input; }

#pragma mark -
#pragma mark Sound Field

    Plan  getFieldPlan() const;
    
    void  setFieldPlan(Plan plan);
    
    Plan  getChannelPlan() const;

    void  setChannelPlan(Plan plan);
    
    float getFieldOrientation(Uint32 channel) const;

    void  setFieldOrientation(Uint32 channel,float angle);
    
    float getChannelOrientation(Uint32 channel) const;
    
    void  setChannelOrientation(Uint32 channel,float angle);
    
    float getSubwoofer() const;

    void  setSubwoofer(float frequency);
    
#pragma mark -
#pragma mark Playback Control

    float getAngle() const;
    
    void  setAngle(float angle);

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