RealtimeEffectState.h

Go to the documentation of this file.

/**********************************************************************
 
 Audacity: A Digital Audio Editor
 
 @file RealtimeEffectState.h
 
 Paul Licameli split from RealtimeEffectManager.cpp
 
 *********************************************************************/
 
#ifndef __AUDACITY_REALTIMEEFFECTSTATE_H__
#define __AUDACITY_REALTIMEEFFECTSTATE_H__
 
#include <atomic>
#include <cstddef>
#include <optional>
#include <unordered_map>
#include <vector>
#include "ClientData.h"
#include "EffectInterface.h"
#include "GlobalVariable.h"
#include "MemoryX.h"
#include "Observer.h"
#include "PluginProvider.h" // for PluginID
#include "XMLTagHandler.h"
 
class ChannelGroup;
class EffectSettingsAccess;
 
enum class RealtimeEffectStateChange { EffectOff, EffectOn };
 
class REALTIME_EFFECTS_API RealtimeEffectState
   : public XMLTagHandler
   , public std::enable_shared_from_this<RealtimeEffectState>
   , public SharedNonInterfering<RealtimeEffectState>
   , public ClientData::Site<RealtimeEffectState>
   , public Observer::Publisher<RealtimeEffectStateChange>
{
public:
   struct REALTIME_EFFECTS_API EffectFactory : GlobalHook<EffectFactory,
      const EffectInstanceFactory *(const PluginID &)
   >{};
 
   explicit RealtimeEffectState(const PluginID & id);
   RealtimeEffectState(const RealtimeEffectState &other) = delete;
   RealtimeEffectState &operator =(const RealtimeEffectState &other) = delete;
   ~RealtimeEffectState();
 
 
   void SetID(const PluginID & id);
   const PluginID& GetID() const noexcept;
   const EffectInstanceFactory *GetEffect();
   const EffectInstanceFactory *GetEffect() const { return mPlugin; }
 
 
   std::shared_ptr<EffectInstance> GetInstance();
 
   const EffectOutputs *GetOutputs() const { return mMovedOutputs.get(); }
 
   std::shared_ptr<EffectInstance> Initialize(double rate);
   std::shared_ptr<EffectInstance>
   AddGroup(
      const ChannelGroup *group, unsigned chans, float sampleRate);
 
   bool ProcessStart(bool running);
 
   size_t Process(const ChannelGroup *group,
      unsigned chans, // How many channels the playback device needs
      const float *const *inbuf, 
      float *const *outbuf, 
      float *dummybuf, 
      size_t numSamples);
   bool ProcessEnd();
 
   const EffectSettings &GetSettings() const { return mMainSettings.settings; }
 
   bool IsEnabled() const noexcept;
 
   bool IsActive() const noexcept;
 
   void SetActive(bool active);
 
   bool Finalize() noexcept;
 
   static const std::string &XMLTag();
   bool HandleXMLTag(
      const std::string_view &tag, const AttributesList &attrs) override;
   void HandleXMLEndTag(const std::string_view &tag) override;
   XMLTagHandler *HandleXMLChild(const std::string_view &tag) override;
   void WriteXML(XMLWriter &xmlFile);
 
 
   std::shared_ptr<EffectSettingsAccess> GetAccess();
 
private:
 
   std::shared_ptr<EffectInstance> MakeInstance();
   std::shared_ptr<EffectInstance> EnsureInstance(double rate);
 
   struct Access;
   struct AccessState;
 
   AccessState *GetAccessState() const
   {
      return mpAccessState.load(std::memory_order_relaxed);
   }
   AccessState *TestAccessState() const
   {
      return mpAccessState.load(std::memory_order_acquire);
   }
 
   PluginID mID;
   
   std::weak_ptr<EffectInstance> mwInstance;
   const EffectInstanceFactory *mPlugin{};
 
   struct SettingsAndCounter {
      using Counter = unsigned char;
 
      EffectSettings settings;
      Counter counter{ 0 };
 
      void swap(SettingsAndCounter &other) {
         settings.swap(other.settings);
         std::swap(counter, other.counter);
      }
   };
 
   struct Response {
      using Counter = unsigned char;
 
      Counter counter{ 0 };
      std::unique_ptr<EffectOutputs> pOutputs;
   };
 
   NonInterfering<SettingsAndCounter> mMainSettings;
   std::unique_ptr<EffectInstance::Message> mMessage;
   std::unique_ptr<EffectOutputs> mMovedOutputs;
 
   NonInterfering<SettingsAndCounter> mWorkerSettings;
   std::unique_ptr<EffectInstance::Message> mMovedMessage;
   std::unique_ptr<EffectOutputs> mOutputs;
 
   std::optional<EffectInstance::SampleCount> mLatency;
   bool mLastActive{};
 
 
   std::unordered_map<const ChannelGroup *, std::pair<size_t, double>>
      mGroups;
 
   // This must not be reset to nullptr while a worker thread is running.
   // In fact it is never yet reset to nullptr, before destruction.
   // Destroy before mWorkerSettings:
   AtomicUniquePointer<AccessState> mpAccessState{ nullptr };
 
   wxString mParameters;  // Used only during deserialization
   size_t mCurrentProcessor{ 0 };
   bool mInitialized{ false };
 
};
 
#endif // __AUDACITY_REALTIMEEFFECTSTATE_H__