CUAudioMixer.h

//
//  CUAudioMixer.h
//  Cornell University Game Library (CUGL)
//
//  Thie module provides an audio graph node for mixing together several input
//  streams into a single output stream. The input nodes must all have the same
//  same number of channels and sampling rate.
//
//  Mixing works by adding together all of the streams.  This means that the
//  results may exceed the range [-1,1], causing clipping.  The mixer provides
//  a "soft-knee" option for confining the results to the range [-1,1].
//
//  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/7/18
//
#ifndef __CU_AUDIO_MIXER_H__
#define __CU_AUDIO_MIXER_H__
#include "CUAudioNode.h"
 
namespace cugl {
    namespace audio {
class AudioMixer : public AudioNode {
private:
    std::shared_ptr<AudioNode>* _inputs;
    Uint8 _width;
 
    float* _buffer;
    Uint32 _capacity;
    
    std::atomic<float>  _knee;
 
public:
#pragma mark Constructors
 
    static const Uint8 DEFAULT_WIDTH;
    static const float DEFAULT_KNEE;
 
    AudioMixer();
    
    ~AudioMixer() { dispose(); }
    
    virtual bool init() override;
 
    bool init(Uint8 width);
 
    virtual bool init(Uint8 channels, Uint32 rate) override;
    
    bool init(Uint8 width, Uint8 channels, Uint32 rate);
    
    virtual void dispose() override;
 
#pragma mark Static Constructors
 
    static std::shared_ptr<AudioMixer> alloc(Uint8 width=8) {
        std::shared_ptr<AudioMixer> result = std::make_shared<AudioMixer>();
        return (result->init(width) ? result : nullptr);
    }
 
    static std::shared_ptr<AudioMixer> alloc(Uint8 width, Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioMixer> result = std::make_shared<AudioMixer>();
        return (result->init(width,channels, rate) ? result : nullptr);
    }
    
#pragma mark Audio Graph Methods
 
    std::shared_ptr<AudioNode> attach(Uint8 slot, const std::shared_ptr<AudioNode>& input);
    
    std::shared_ptr<AudioNode> detach(Uint8 slot);
    
    virtual Uint32 read(float* buffer, Uint32 frames) override;
    
#pragma mark Anticlipping Methods
 
    float getKnee() const;
    
    void setKnee(float knee);
 
};
    }
}
 
#endif /* __CU_AUDIO_MIXER_H__ */