playbackcomponent.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Nap includes
#include <nap/resourceptr.h>
#include <audio/utility/safeptr.h>
 
// Audio includes
#include <audio/component/audiocomponentbase.h>
#include <audio/resource/audiobufferresource.h>
#include <audio/node/bufferplayernode.h>
#include <audio/node/multiplynode.h>
#include <audio/node/controlnode.h>
#include <audio/node/filternode.h>
 
namespace nap
{
    namespace audio
    {
        
        // Forward declares
        class AudioService;
        class PlaybackComponentInstance;        
        
        class NAPAPI PlaybackComponent : public AudioComponentBase
        {
        RTTI_ENABLE(AudioComponentBase)
        DECLARE_COMPONENT(PlaybackComponent, PlaybackComponentInstance)
        
        public:
            PlaybackComponent() : AudioComponentBase() { }
            
            // Properties
            ResourcePtr<AudioBufferResource> mBuffer = nullptr; 
            std::vector<int> mChannelRouting = { };           
            bool mAutoPlay = true;                              
            TimeValue mStartPosition = 0;                       
            TimeValue mDuration = 0;                            
            TimeValue mFadeInTime = 0;                          
            TimeValue mFadeOutTime = 0;                         
            ControllerValue mPitch = 1.0;                       
            ControllerValue mGain = 1.0;                        
            ControllerValue mStereoPanning = 0.5;               
            
            bool isStereo() const { return mChannelRouting.size() == 2; }
        };
        
        
        class NAPAPI PlaybackComponentInstance : public AudioComponentBaseInstance
        {
            RTTI_ENABLE(AudioComponentBaseInstance)
        public:
            PlaybackComponentInstance(EntityInstance& entity, Component& resource) : AudioComponentBaseInstance(entity, resource) { }
            
            // Inherited from ComponentInstance
            bool init(utility::ErrorState& errorState) override;
            
            void update(double deltaTime) override;
            
            // Inherited from AudioComponentBaseInstance
            int getChannelCount() const override { return mGainNodes.size(); }
            
            OutputPin* getOutputForChannel(int channel) override { return &mGainNodes[channel]->audioOutput; }
            
            void start(TimeValue startPosition = 0, TimeValue duration = 0);
            
            void stop();
            
            void setGain(ControllerValue gain);
            
             void setChannelGain(int channel, ControllerValue gain);
            
            void setStereoPanning(ControllerValue panning);
            
            void setFadeInTime(TimeValue time);
            
            void setFadeOutTime(TimeValue time);
            
            void setPitch(ControllerValue pitch);
            
            bool isStereo() const { return mGainNodes.size() == 2; }
            
            bool isPlaying() const { return mPlaying; }
            
            ControllerValue getGain() const { return mGain; }
            
            ControllerValue getStereoPanning() const { return mStereoPanning; }
            
            ControllerValue getFadeInTime() const { return mFadeInTime; }
            
            ControllerValue getFadeOutTime() const { return mFadeOutTime; }
            
            ControllerValue getPitch() const { return mPitch; }
            
            TimeValue getCurrentPlayingTime() const { return mCurrentPlayingTime; }
        
        private:
            void applyGain(TimeValue rampTime);
            
            std::vector<SafeOwner<BufferPlayerNode>> mBufferPlayers; // Nodes for each channel performing the actual audio playback.
            std::vector<SafeOwner<MultiplyNode>> mGainNodes; // Nodes for each channel to gain the signal.
            std::vector<SafeOwner<ControlNode>> mGainControls; // Nodes to control the gain for each channel.
            
            ControllerValue mGain = 0;
            std::vector<ControllerValue> mChannelGains;
            ControllerValue mStereoPanning = 0.5;
            TimeValue mFadeInTime = 0;
            TimeValue mFadeOutTime = 0;
            ControllerValue mPitch = 1.0;
            TimeValue mDuration = 0;
            TimeValue mCurrentPlayingTime = 0;
            std::vector<int> mChannelRouting;
            
            bool mPlaying = false;  // Indicates wether the component is currently playing
            
            PlaybackComponent* mResource = nullptr; // The component's resource
            NodeManager* mNodeManager = nullptr; // The audio node manager this component's audio nodes are managed by
            AudioService* mAudioService = nullptr;
        };
        
    }
    
}