VST3EffectsModule.cpp

Go to the documentation of this file.

/**********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file VST3EffectsModule.cpp
 
  @author Vitaly Sverchinsky
 
  @brief Part of Audacity VST3 module
 
**********************************************************************/
 
 
#include "VST3EffectsModule.h"
 
#include <stdexcept>
 
#include <wx/stdpaths.h>
#include <wx/dir.h>
#include <wx/log.h>
#include <wx/utils.h>
 
#include "AudacityVst3HostApplication.h"
#include "ModuleManager.h"
 
#include "wxArrayStringEx.h"
#include "PlatformCompatibility.h"
#include "PluginInterface.h"
#include "PluginProvider.h"
#include "PluginProvider.h"
#include "VST3Utils.h"
#include "VST3Wrapper.h"
 
 
DECLARE_PROVIDER_ENTRY(AudacityModule)
{
   // Create our effects module and register
   // Trust the module manager not to leak this
   return std::make_unique<VST3EffectsModule>();
}
 
DECLARE_BUILTIN_PROVIDER(VST3Builtin);
 
//Helper class used to find vst3 effects during folder traversal
class VST3PluginTraverser final : public wxDirTraverser
{
   std::function<void(const wxString&)> mOnPluginFound;
public:
   VST3PluginTraverser(std::function<void(const wxString&)> onPluginFound)
      : mOnPluginFound(std::move(onPluginFound))
   {
   }
 
   wxDirTraverseResult OnFile(const wxString& filename) override
   {
      if(filename.Matches("*.vst3"))
         mOnPluginFound(filename);
      return wxDIR_CONTINUE;
   }
   wxDirTraverseResult OnDir(const wxString& dirname) override
   {
      if(dirname.Matches("*.vst3"))
      {
         mOnPluginFound(dirname);
         return wxDIR_IGNORE;//do not look inside...
      }
      return wxDIR_CONTINUE;
   }
};
 
std::shared_ptr<VST3::Hosting::Module> VST3EffectsModule::GetModule(const wxString& path)
{
   const auto it = mModules.find(path);
   if(it != mModules.end())
   {
      if(auto lock = it->second.lock())
         return lock;
   }
 
   std::string moduleCreateError;
   //VST sdk provides platform-specific module loading routines as well,
   //implementation is conditionally included (see CMakeLists.txt)
   auto module = VST3::Hosting::Module::create(path.ToStdString(), moduleCreateError);
   if(!module)
      throw std::runtime_error(moduleCreateError.c_str());
 
   module->getFactory().setHostContext(&AudacityVst3HostApplication::Get());
 
   mModules[path] = module;
   return module;
}
 
PluginPath VST3EffectsModule::GetPath() const
{
   return {};
}
 
ComponentInterfaceSymbol VST3EffectsModule::GetSymbol() const
{
   return XO("VST3 Effects");
}
 
VendorSymbol VST3EffectsModule::GetVendor() const
{
   return XO("The Audacity Team");
}
 
wxString VST3EffectsModule::GetVersion() const
{
   return AUDACITY_VERSION_STRING;
}
 
TranslatableString VST3EffectsModule::GetDescription() const
{
   return XO("Adds the ability to use VST3 effects in Audacity.");
}
 
bool VST3EffectsModule::Initialize()
{
   return true;
}
 
void VST3EffectsModule::Terminate()
{
}
 
EffectFamilySymbol VST3EffectsModule::GetOptionalFamilySymbol()
{
   return VST3EffectBase::GetFamilySymbol();
}
 
const FileExtensions& VST3EffectsModule::GetFileExtensions()
{
   static const FileExtensions ext {
      { _T("vst3") }
   };
   return ext;
}
 
FilePath VST3EffectsModule::InstallPath()
{
#ifdef VST3_DEFAULT_INSTALL_PATH
   return FilePath { VST3_DEFAULT_INSTALL_PATH };
#else
   return {};
#endif
}
 
void VST3EffectsModule::AutoRegisterPlugins(PluginManagerInterface &)
{
}
 
bool VST3EffectsModule::SupportsCustomModulePaths() const
{
   return true;
}
 
PluginPaths
VST3EffectsModule::FindModulePaths(PluginManagerInterface &pluginManager)
{
   //Note: The host recursively scans these folders at startup in this order (User/Global/Application).
   //https://developer.steinberg.help/display/VST/Plug-in+Locations
 
   FilePaths pathList;
#ifdef __WXMSW__
   // Windows specific VST3 search paths
   {
      wxString programFilesPath;
      if(wxGetEnv("programfiles", &programFilesPath))
         pathList.push_back(programFilesPath + "\\Common Files\\VST3");
   }
#elif __WXMAC__
   pathList.push_back("~/Library/Audio/Plug-ins/VST3/");
   pathList.push_back("/Library/Audio/Plug-ins/VST3/");
   pathList.push_back("/Network/Library/Audio/Plug-ins/VST3/");
#elif __WXGTK__
   pathList.push_back(wxGetHomeDir() + "/.vst3/");
   pathList.push_back("/usr/lib/vst3/");
   pathList.push_back("/usr/local/lib/vst3/");
#endif
 
   // bundled/app specific
   {
      auto path = wxFileName(PlatformCompatibility::GetExecutablePath());
#ifdef __WXGTK__
      path.AppendDir("vst3");
#else
      path.AppendDir("VST3");
#endif
      pathList.push_back(path.GetPath());
   }
   {
      auto customPaths = pluginManager.ReadCustomPaths(*this);
      std::copy(customPaths.begin(), customPaths.end(), std::back_inserter(pathList));
   }
 
   PluginPaths result;
   VST3PluginTraverser vst3PluginTraverser([&](const wxString& pluginPath){
      result.push_back(pluginPath);
   });
 
   for(const auto& path : pathList)
   {
      wxDir dir(path);
      if(dir.IsOpened())
         dir.Traverse(vst3PluginTraverser, wxEmptyString, wxDIR_DEFAULT);
   }
   return result;
}
 
unsigned VST3EffectsModule::DiscoverPluginsAtPath(const PluginPath& path, TranslatableString& errMsg,
   const RegistrationCallback& callback)
{
   try
   {
      auto module = GetModule(path);
 
      const auto moduleFactory = module->getFactory();
      auto nEffects { 0u };
      for(auto& classInfo : moduleFactory.classInfos())
      {
         if(classInfo.category() == kVstAudioEffectClass)
         {
            std::unique_ptr<VST3EffectBase> effect;
            try
            {
               effect = Factory::Call(module, classInfo);
               ++nEffects;
            }
            catch(std::exception& e)
            {
               wxLogError(
                  "Effect %s@%s cannot be loaded: %s", 
                  classInfo.name().c_str(),
                  path.c_str(),
                  e.what()
               );
            }
            catch(...)
            {
               wxLogError(
                  "Effect %s@%s cannot be loaded: unknown error",
                  classInfo.name().c_str(),
                  path.c_str()
               );
            }
            if(effect && callback)
               callback(this, effect.get());
         }
      }
      if(nEffects == 0u)
         throw std::runtime_error("no effects found");
      
      return nEffects;
   }
   catch(std::exception& e)
   {
      errMsg = XO("VST3 module error: %s").Format(e.what());
   }
 
   return 0u;
}
 
std::unique_ptr<ComponentInterface>
VST3EffectsModule::LoadPlugin(const PluginPath& pluginPath)
{
   try
   {
      wxString modulePath;
      std::string effectUIDString;
 
      if(!VST3Utils::ParsePluginPath(pluginPath, &modulePath, &effectUIDString))
         throw std::runtime_error("failed to parse plugin string");
 
      auto module = GetModule(modulePath);
      const auto pluginFactory = module->getFactory();
      for(const auto& classInfo : pluginFactory.classInfos())
      {
         if(effectUIDString == classInfo.ID().toString()) {
            auto result = Factory::Call(module, classInfo);
            return result;
         }
      }
      throw std::runtime_error("effect UID not found");
   }
   catch(std::exception& e)
   {
      wxLogError("VST3 Module was not loaded: %s", e.what());
   }
   return nullptr;
}
 
class VST3PluginValidator final : public PluginProvider::Validator
{
public:
   
   void Validate(ComponentInterface& component) override
   {
      if(auto vst3effect = dynamic_cast<VST3EffectBase*>(&component))
      {
         VST3Wrapper wrapper (
            *vst3effect->mModule,
            vst3effect->mEffectClassInfo
         );
         wrapper.InitializeComponents();
      }
      else
         throw std::runtime_error("Not a VST3Effect");
   }
 
};
 
std::unique_ptr<PluginProvider::Validator> VST3EffectsModule::MakeValidator() const
{
   return std::make_unique<VST3PluginValidator>();
}
 
 
bool VST3EffectsModule::CheckPluginExist(const PluginPath& path) const
{
   wxString modulePath;
   if(VST3Utils::ParsePluginPath(path, &modulePath, nullptr))
      return wxFileName::FileExists(modulePath) || wxFileName::DirExists(modulePath);
 
   return wxFileName::FileExists(path) || wxFileName::DirExists(path);
}