score-plugin-vst3/Vst3/ApplicationPlugin.hpp

#pragma once
#include <Vst3/Plugin.hpp>
 
#include <score/plugins/application/GUIApplicationPlugin.hpp>
 
#include <ossia/detail/fmt.hpp>
#include <ossia/detail/string_map.hpp>
 
#include <QtCore/qglobal.h>
 
#include <score_plugin_vst3_export.h>
 
#include <base/source/fstring.h>
#include <pluginterfaces/vst/ivsteditcontroller.h>
#include <pluginterfaces/vst/ivstmessage.h>
#include <pluginterfaces/vst/ivstpluginterfacesupport.h>
 
#include <memory>
#include <stdexcept>
#include <verdigris>
 
class QTimer;
class QJsonObject;
namespace Media
{
class PluginScanner;
}
 
namespace vst3
{
struct AvailablePlugin
{
  QString path;
  QString name;
  QString url;
  std::vector<VST3::Hosting::ClassInfo> classInfo;
 
  bool isValid{};
};
 
SCORE_PLUGIN_VST3_TEST_EXPORT
AvailablePlugin parseVst3Reply(const QString& path, const QJsonObject& obj);
 
struct HostApp final : public Steinberg::Vst::IHostApplication
{
  struct InterfaceSupport final : public Steinberg::Vst::IPlugInterfaceSupport
  {
    Steinberg::tresult PLUGIN_API
    isPlugInterfaceSupported(const Steinberg::TUID _iid) override
    {
      using namespace Steinberg;
      using namespace Steinberg::Vst;
      for(const FUID* iid :
          {&IComponent::iid, &IAudioProcessor::iid, &IEditController::iid,
           &IConnectionPoint::iid, &IUnitInfo::iid, &IMidiMapping::iid})
        if(FUnknownPrivate::iidEqual(_iid, static_cast<const TUID&>(*iid)))
          return kResultTrue;
      return kResultFalse;
    }
 
    Steinberg::tresult PLUGIN_API queryInterface(const char* _iid, void** obj) override
    {
      using namespace Steinberg;
      using namespace Steinberg::Vst;
      QUERY_INTERFACE(_iid, obj, FUnknown::iid, IPlugInterfaceSupport)
      QUERY_INTERFACE(_iid, obj, IPlugInterfaceSupport::iid, IPlugInterfaceSupport)
      *obj = nullptr;
      return kNoInterface;
    }
    Steinberg::uint32 PLUGIN_API addRef() override { return 1; }
    Steinberg::uint32 PLUGIN_API release() override { return 1; }
  } m_support;
 
  HostApp() { }
  virtual ~HostApp() { }
  Steinberg::tresult PLUGIN_API getName(Steinberg::Vst::String128 name) override
  {
    Steinberg::String str("ossia score");
    str.copyTo16(name, 0, 127);
    return Steinberg::kResultTrue;
  }
 
  Steinberg::tresult
  PLUGIN_API createInstance(Steinberg::TUID cid, Steinberg::TUID _iid, void** obj) override
  {
    using namespace Steinberg;
    using namespace Steinberg::Vst;
    FUID classID(FUID::fromTUID(cid));
    FUID interfaceID(FUID::fromTUID(_iid));
    if(classID == Vst::IMessage::iid && interfaceID == Vst::IMessage::iid)
    {
      *obj = new HostMessage;
      return kResultTrue;
    }
    else if(
        classID == Vst::IAttributeList::iid && interfaceID == Vst::IAttributeList::iid)
    {
      *obj = Vst::HostAttributeList::make();
      return kResultTrue;
    }
    *obj = nullptr;
    return kResultFalse;
  }
 
  Steinberg::tresult PLUGIN_API queryInterface(const char* _iid, void** obj) override
  {
    using namespace Steinberg;
    using namespace Steinberg::Vst;
    QUERY_INTERFACE(_iid, obj, FUnknown::iid, IHostApplication)
    QUERY_INTERFACE(_iid, obj, IHostApplication::iid, IHostApplication)
 
    if(m_support.queryInterface(_iid, obj) == kResultOk)
      return kResultOk;
 
    *obj = nullptr;
    return kResultFalse;
  }
 
  Steinberg::uint32 PLUGIN_API addRef() override { return 1; }
 
  Steinberg::uint32 PLUGIN_API release() override { return 1; }
};
 
class SCORE_PLUGIN_VST3_EXPORT ApplicationPlugin
    : public QObject
    , public score::ApplicationPlugin
{
  W_OBJECT(ApplicationPlugin)
public:
  ApplicationPlugin(const score::ApplicationContext& ctx);
  ~ApplicationPlugin();
 
  void initialize() override;
 
  VST3::Hosting::Module::Ptr getModule(const std::string& path);
 
  void rescan();
  void rescan(const QStringList& paths);
  void vstChanged() E_SIGNAL(SCORE_PLUGIN_VST3_EXPORT, vstChanged);
 
  std::pair<const AvailablePlugin*, const VST3::Hosting::ClassInfo*>
  classInfo(const VST3::UID& uid) const noexcept;
  QString pathForClass(const VST3::UID& uid) const noexcept;
  std::optional<VST3::UID>
  uidForPathAndClassName(const QString& path, const QString& cls) const noexcept;
 
  HostApp m_host;
  ossia::string_map<VST3::Hosting::Module::Ptr> modules;
  std::vector<AvailablePlugin> vst_infos;
 
private:
  void onScanned(const QString& path, const QJsonObject& obj);
  void onScanFailed(const QString& path, const QString& reason);
  void removeEntriesForPath(const QString& path);
  void persistCache();
  void schedulePersist();
 
#if QT_CONFIG(process)
  std::unique_ptr<Media::PluginScanner> m_scanner;
#endif
  QTimer* m_persistTimer{};
  bool m_scanRan{};
};
}