CUAudioPanner.h

//
//  CUAudioPanner.h
//  Cornell University Game Library (CUGL)
//
//  This module is a general purpose audio panner.  It can convert an audio node
//  with any given number of channels to one with a different number of channels
//  (but the same sampling rate).  It does this via a panning matrix.  This
//  matrix specifies the contribution (in a range of 0 to 1) of each input
//  channel to each output channel.
//
//  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_PANNER_H__
#define __CU_AUDIO_PANNER_H__
#include "CUAudioNode.h"
#include <atomic>
 
namespace cugl {
    namespace audio {
class AudioPanner : public AudioNode {
private:
    Uint8 _field;
    
    float* _buffer;
    Uint32 _capacity;
    
    std::shared_ptr<AudioNode> _input;
    std::atomic<float>* _mapper;
 
#pragma mark -
#pragma mark Constructors
public:
    AudioPanner();
    
    ~AudioPanner() { 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<AudioPanner> alloc() {
        std::shared_ptr<AudioPanner> result = std::make_shared<AudioPanner>();
        return (result->init() ? result : nullptr);
    }
 
    static std::shared_ptr<AudioPanner> alloc(Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioPanner> result = std::make_shared<AudioPanner>();
        return (result->init(channels,rate) ? result : nullptr);
    }
 
    static std::shared_ptr<AudioPanner> alloc(Uint8 channels, Uint8 field, Uint32 rate) {
        std::shared_ptr<AudioPanner> result = std::make_shared<AudioPanner>();
        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() const { return _input; }
    
    Uint32 getField() const { return _field; }
    
    float getPan(Uint32 field, Uint32 channel) const;
 
    void setPan(Uint32 field, Uint32 channel, float value);
 
#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_SWITCHER_H__ */