RealtimeEffectManager.h

Go to the documentation of this file.

/**********************************************************************
 
 Audacity: A Digital Audio Editor
 
 RealtimeEffectManager.h
 
 Paul Licameli split from EffectManager.h
 
 **********************************************************************/
 
#ifndef __AUDACITY_REALTIME_EFFECT_MANAGER__
#define __AUDACITY_REALTIME_EFFECT_MANAGER__
 
#include <atomic>
#include <chrono>
#include <memory>
#include <mutex>
#include <optional>
#include <unordered_map>
#include <vector>
 
#include "ClientData.h"
#include "Observer.h"
#include "PluginProvider.h" // for PluginID
#include "RealtimeEffectList.h"
 
class ChannelGroup;
class EffectInstance;
 
namespace RealtimeEffects {
   class InitializationScope;
   class ProcessingScope;
}
 
struct RealtimeEffectManagerMessage
{
   enum class Type
   {
      EffectAdded,
      EffectReplaced,
      EffectRemoved
   };
   Type type{};
   ChannelGroup *group{}; 
};
 
class REALTIME_EFFECTS_API RealtimeEffectManager final :
   public ClientData::Base,
   public Observer::Publisher<RealtimeEffectManagerMessage>
{
public:
   using Latency = std::chrono::microseconds;
 
   RealtimeEffectManager(AudacityProject &project);
   ~RealtimeEffectManager();
 
   static RealtimeEffectManager & Get(AudacityProject &project);
   static const RealtimeEffectManager & Get(const AudacityProject &project);
 
   // Realtime effect processing
 
   bool IsActive() const noexcept;
//   Latency GetLatency() const;
 
 
   std::shared_ptr<RealtimeEffectState> AddState(
      RealtimeEffects::InitializationScope *pScope,
      ChannelGroup *pGroup,
      const PluginID & id);
 
 
   std::shared_ptr<RealtimeEffectState> ReplaceState(
      RealtimeEffects::InitializationScope *pScope,
      ChannelGroup *pGroup,
      size_t index, const PluginID & id);
 
 
   void RemoveState(RealtimeEffects::InitializationScope *pScope,
      ChannelGroup *pGroup,
      std::shared_ptr<RealtimeEffectState> pState);
 
   std::optional<size_t> FindState(
      ChannelGroup *pGroup,
      const std::shared_ptr<RealtimeEffectState> &pState) const;
 
   bool GetSuspended() const
      { return mSuspended.load(std::memory_order_relaxed); }
 
 
   void SetSuspended(bool value)
      { mSuspended.store(value, std::memory_order_relaxed); }
 
private:
   friend RealtimeEffects::InitializationScope;
 
   std::shared_ptr<RealtimeEffectState>
   MakeNewState(RealtimeEffects::InitializationScope *pScope,
      ChannelGroup *pGroup,
      const PluginID &id);
 
   void Initialize(RealtimeEffects::InitializationScope &scope,
      double sampleRate);
   void AddGroup(RealtimeEffects::InitializationScope &scope,
      const ChannelGroup &group, unsigned chans, float rate);
   void Finalize() noexcept;
 
   friend RealtimeEffects::ProcessingScope;
   struct REALTIME_EFFECTS_API AllListsLock {
      RealtimeEffectManager *mpManager{};
      AllListsLock(RealtimeEffectManager *pManager = nullptr);
      AllListsLock(AllListsLock &&other);
      AllListsLock& operator= (AllListsLock &&other);
      void Reset();
      ~AllListsLock() { Reset(); }
   };
 
   void ProcessStart(bool suspended);
   size_t Process(bool suspended,
      const ChannelGroup &group,
      float *const *buffers, float *const *scratch, float *dummy,
      unsigned nBuffers, size_t numSamples);
   void ProcessEnd(bool suspended) noexcept;
 
   RealtimeEffectManager(const RealtimeEffectManager&) = delete;
   RealtimeEffectManager &operator=(const RealtimeEffectManager&) = delete;
 
   // Type that state visitor functions would have for out-of-line definition
   // of VisitGroup and VisitAll
   // using StateVisitor =
      // std::function<void(RealtimeEffectState &state, bool listIsActive)> ;
 
   template<typename StateVisitor>
   void VisitGroup(ChannelGroup &group, const StateVisitor &func)
   {
      // Call the function for each effect on the master list
      RealtimeEffectList::Get(mProject).Visit(func);
 
      // Call the function for each effect on the group list
      RealtimeEffectList::Get(group).Visit(func);
   }
 
   template<typename StateVisitor>
   void VisitGroup(
      const ChannelGroup &group, const StateVisitor &func)
   {
      // Call the function for each effect on the master list
      RealtimeEffectList::Get(mProject).Visit(func);
 
      // Call the function for each effect on the group list
      RealtimeEffectList::Get(group).Visit(func);
   }
 
 
   template<typename StateVisitor>
   void VisitAll(const StateVisitor &func)
   {
      // Call the function for each effect on the master list
      RealtimeEffectList::Get(mProject).Visit(func);
 
      // And all group lists
      for (auto group : mGroups)
         RealtimeEffectList::Get(*group).Visit(func);
   }
 
   AudacityProject &mProject;
   Latency mLatency{ 0 };
 
   std::atomic<bool> mSuspended{ true };
 
   bool mActive{ false };
 
   // This member is mutated only by Initialize(), AddGroup(), Finalize()
   // which are to be called only while there is no playback
   std::vector<const ChannelGroup *> mGroups; 
 
   std::unordered_map<const ChannelGroup *, double> mRates;
};
 
namespace RealtimeEffects {
class InitializationScope {
public:
   InitializationScope() {}
   explicit InitializationScope(
      std::weak_ptr<AudacityProject> wProject, double sampleRate,
      unsigned numPlaybackChannels
   )  : mSampleRate{ sampleRate }
      , mwProject{ move(wProject) }
      , mNumPlaybackChannels{ numPlaybackChannels }
   {
      if (auto pProject = mwProject.lock())
         RealtimeEffectManager::Get(*pProject).Initialize(*this, sampleRate);
   }
   InitializationScope( InitializationScope &&other ) = default;
   InitializationScope& operator=( InitializationScope &&other ) = default;
   ~InitializationScope()
   {
      if (auto pProject = mwProject.lock())
         RealtimeEffectManager::Get(*pProject).Finalize();
   }
 
   void AddGroup(const ChannelGroup &group,
      unsigned chans, float rate)
   {
      if (auto pProject = mwProject.lock())
         RealtimeEffectManager::Get(*pProject)
            .AddGroup(*this, group, chans, rate);
   }
 
   std::vector<std::shared_ptr<EffectInstance>> mInstances;
   double mSampleRate;
   unsigned mNumPlaybackChannels;
 
private:
   std::weak_ptr<AudacityProject> mwProject;
};
 
class ProcessingScope {
public:
   ProcessingScope()
   {
      if (auto pProject = mwProject.lock()) {
         auto &manager = RealtimeEffectManager::Get(*pProject);
         mLocks = { &manager };
         mSuspended = manager.GetSuspended();
      }
   }
   explicit ProcessingScope(InitializationScope &,
      std::weak_ptr<AudacityProject> wProject)
      : mwProject{ move(wProject) }
   {
      if (auto pProject = mwProject.lock())
         RealtimeEffectManager::Get(*pProject).ProcessStart(mSuspended);
   }
   ProcessingScope( ProcessingScope &&other ) = default;
   ProcessingScope& operator=( ProcessingScope &&other ) = default;
   ~ProcessingScope()
   {
      if (auto pProject = mwProject.lock())
         RealtimeEffectManager::Get(*pProject).ProcessEnd(mSuspended);
   }
 
   size_t Process(const ChannelGroup &group,
      float *const *buffers,
      float *const *scratch,
      float *dummy,
      unsigned nBuffers, 
      size_t numSamples 
   )
   {
      if (auto pProject = mwProject.lock())
         return RealtimeEffectManager::Get(*pProject)
            .Process(mSuspended, group, buffers, scratch, dummy,
               nBuffers, numSamples);
      else
         return 0; // consider them trivially processed
   }
 
private:
   RealtimeEffectManager::AllListsLock mLocks;
   std::weak_ptr<AudacityProject> mwProject;
   bool mSuspended{};
};
}
 
#endif