CUAudioFader.h

//
//  CUAudioFader.h
//  Cornell University Game Library (CUGL)
//
//  This module provides an audio node wrapper for fade-in and fade-out support.
//  We have decoupled fade-in and out from the player since we want to apply it
//  to arbitrary audio patches. We have also decoupled it from the scheduler,
//  as the schedule API is complicated enough as it is.  By factoring this
//  out into its own node, it is easier for us to support nonlinear fades (such
//  as with an easing function.
//
//  NOTE: Easing functions are not yet supported.  They are on the milestone
//  for the next release.
//
//  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/20/18
//
#ifndef __CU_AUDIO_FADER_H__
#define __CU_AUDIO_FADER_H__
#include <SDL/SDL.h>
#include "CUAudioNode.h"
#include <mutex>

namespace cugl {
    namespace audio {

class AudioFader : public AudioNode {
protected:
    std::shared_ptr<AudioNode> _input;

    std::mutex _mutex;
    
    // Fade-in: For softer starts
    Sint64 _inmark;
    Uint64 _fadein;
    
    // Fade-out: For smooth stopping
    Sint64 _outmark;
    Uint64 _fadeout;
    bool   _outdone;
    bool   _outkeep;
    
    // Fade-dip: For smooth pausing
    Uint64 _fadedip;
    Sint64 _dipmark;
    Uint64 _dipstop;
    bool   _diphalf;
    bool   _dipstart;

    
    Uint32 doFadeIn(float* buffer, Uint32 frames);
    
    Uint32 doFadeOut(float* buffer, Uint32 frames);
    
    Uint32 doFadePause(float* buffer, Uint32 frames);

public:
#pragma mark Constructors

    AudioFader();
    
    ~AudioFader() { dispose(); }
    
    virtual bool init() override;
    
    virtual bool init(Uint8 channels, Uint32 rate) override;
    
    bool init(const std::shared_ptr<AudioNode>& input);
    
    virtual void dispose() override;
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<AudioFader> alloc() {
        std::shared_ptr<AudioFader> result = std::make_shared<AudioFader>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<AudioFader> alloc(Uint8 channels, Uint32 rate) {
        std::shared_ptr<AudioFader> result = std::make_shared<AudioFader>();
        return (result->init(channels,rate) ? result : nullptr);
    }

    static std::shared_ptr<AudioFader> alloc(const std::shared_ptr<AudioNode>& input) {
        std::shared_ptr<AudioFader> result = std::make_shared<AudioFader>();
        return (result->init(input) ? result : nullptr);
    }

#pragma mark -
#pragma mark Fade In/Out Support

    bool attach(const std::shared_ptr<AudioNode>& node);
    
    std::shared_ptr<AudioNode> detach();
    
    std::shared_ptr<AudioNode> getInput() { return _input; }

    // TODO: Add easing functions for fade-in/fade-out
    void fadeIn(double duration);
    
    bool isFadeIn();
    
    void fadeOut(double duration, bool wrap=false);

    bool isFadeOut();

    void fadePause(double duration);
    
    bool isFadePause();

    void fadePause(double fadein, double fadeout);

#pragma mark -
#pragma mark Overriden Methods

    virtual bool isPaused() override;
    
    virtual bool pause() override;
    
    virtual bool resume() override;

    virtual Uint32 read(float* buffer, Uint32 frames) override;
    
    virtual bool completed() override;
    
    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_FADER_H__ */