Stop using RTLD_DEEPBIND to allow ASan to work; Modify method names

include/ClapFile.h

@@ -63,7 +63,7 @@ class ClapFile
 	{
 	public:
 		//! Loads plugin info but does not activate
-		ClapPluginInfo(const clap_plugin_factory* factory, uint32_t index);
+		ClapPluginInfo(const clap_plugin_factory* factory, std::uint32_t index);
 		ClapPluginInfo(const ClapPluginInfo&) = delete;
 		ClapPluginInfo(ClapPluginInfo&& other) noexcept;
 		ClapPluginInfo& operator=(const ClapPluginInfo&) = delete;
@@ -73,34 +73,34 @@ class ClapFile
 		auto isValid() const -> bool { return m_valid; }
 		void invalidate() const { m_valid = false; }
 
-		auto getFactory() const -> const clap_plugin_factory* { return m_factory; };
-		auto getIndex() const -> uint32_t { return m_index; }
-		auto getType() const -> Plugin::Type { return m_type; }
-		auto getDescriptor() const -> const clap_plugin_descriptor* { return m_descriptor; }
+		auto factory() const -> const clap_plugin_factory* { return m_factory; };
+		auto index() const -> std::uint32_t { return m_index; }
+		auto type() const -> Plugin::Type { return m_type; }
+		auto descriptor() const -> const clap_plugin_descriptor* { return m_descriptor; }
 
 	private:
 
 		// Are set when the .clap file is loaded:
 		const clap_plugin_factory* m_factory;
-		uint32_t m_index; //!< Plugin index within the .clap file
-		const clap_plugin_descriptor* m_descriptor;
-		Plugin::Type m_type{Plugin::Type::Undefined};
-		mutable bool m_valid{false};
+		std::uint32_t m_index; //!< Plugin index within the .clap file
+		const clap_plugin_descriptor* m_descriptor = nullptr;
+		Plugin::Type m_type = Plugin::Type::Undefined;
+		mutable bool m_valid = false;
 		std::unordered_set<PluginIssue, PluginIssueHash> m_issues;
 	};
 
 	//! Call after creating ClapFile to load the .clap file
 	auto load() -> bool;
 
-	auto getParent() const -> const ClapManager* { return m_parent; }
-	auto getFilename() const -> const std::filesystem::path& { return m_filename; }
-	auto getFactory() const -> const clap_plugin_factory* { return m_factory; }
+	auto parent() const -> const ClapManager* { return m_parent; }
+	auto filename() const -> const std::filesystem::path& { return m_filename; }
+	auto factory() const -> const clap_plugin_factory* { return m_factory; }
 
 	//! Only includes plugins that successfully loaded
 	auto pluginInfo() const -> const std::vector<std::shared_ptr<const ClapPluginInfo>>& { return m_pluginInfo; }
 
 	//! Includes plugins that failed to load
-	auto getPluginCount() const -> uint32_t { return m_pluginCount; }
+	auto pluginCount() const -> std::uint32_t { return m_pluginCount; }
 	auto isValid() const -> bool { return m_valid; }
 
 	//! Removes any invalid plugin info objects - be careful when using
@@ -111,14 +111,14 @@ class ClapFile
 	void unload();
 
 	// Are set when the .clap file is loaded:
-	const ClapManager* m_parent; //!< Always valid, so storing it is okay
+	const ClapManager* m_parent = nullptr; //!< Always valid, so storing it is okay
 	std::filesystem::path m_filename;
 	std::unique_ptr<QLibrary> m_library;
-	const clap_plugin_entry* m_entry{nullptr};
-	const clap_plugin_factory* m_factory{nullptr};
+	const clap_plugin_entry* m_entry = nullptr;
+	const clap_plugin_factory* m_factory = nullptr;
 	std::vector<std::shared_ptr<const ClapPluginInfo>> m_pluginInfo; //!< Only includes info for plugins that successfully loaded
-	uint32_t m_pluginCount{0}; //!< Includes plugins that failed to load
-	bool m_valid{false};
+	std::uint32_t m_pluginCount = 0; //!< Includes plugins that failed to load
+	bool m_valid = false;
 };
 
 using ClapPluginInfo = ClapFile::ClapPluginInfo;

include/ClapInstance.h

@@ -160,10 +160,10 @@ class ClapInstance final : public LinkedModelGroup
 	auto isMonoInput() const -> bool { return m_monoInput; } //!< Can call after pluginInit()
 	auto isMonoOutput() const -> bool { return m_monoOutput; } //!< Can call after pluginInit()
 
-	auto getHost() const -> const clap_host* { return &m_host; }
-	auto getPlugin() const -> const clap_plugin* { return m_plugin; }
-	auto getInfo() const -> const ClapPluginInfo& { return *m_pluginInfo; }
-	auto getParams() const -> const std::vector<ClapParam*>& { return m_params; }
+	auto host() const -> const clap_host* { return &m_host; }
+	auto plugin() const -> const clap_plugin* { return m_plugin; }
+	auto info() const -> const ClapPluginInfo& { return *m_pluginInfo; }
+	auto params() const -> const std::vector<ClapParam*>& { return m_params; }
 
 	/////////////////////////////////////////
 	// Host
@@ -178,7 +178,7 @@ class ClapInstance final : public LinkedModelGroup
 	// Plugin
 	/////////////////////////////////////////
 
-	auto getPluginState() const -> PluginState { return m_pluginState; };
+	auto pluginState() const -> PluginState { return m_pluginState; };
 
 	auto pluginStart() -> bool; //!< Loads, inits, and activates in that order
 	auto pluginRestart() -> bool;
@@ -189,9 +189,9 @@ class ClapInstance final : public LinkedModelGroup
 	auto pluginActivate() -> bool;
 	auto pluginDeactivate() -> bool;
 
-	auto pluginProcessBegin(uint32_t frames) -> bool;
-	auto pluginProcess(uint32_t frames) -> bool;
-	auto pluginProcessEnd(uint32_t frames) -> bool;
+	auto pluginProcessBegin(std::uint32_t frames) -> bool;
+	auto pluginProcess(std::uint32_t frames) -> bool;
+	auto pluginProcessEnd(std::uint32_t frames) -> bool;
 
 	void paramFlushOnMainThread();
 	void handlePluginOutputEvents();
@@ -227,20 +227,20 @@ class ClapInstance final : public LinkedModelGroup
 	static void hostExtLogLog([[maybe_unused]] const clap_host_t* host, clap_log_severity severity, const char* msg);
 	static auto hostExtThreadCheckIsMainThread(const clap_host_t* host) -> bool;
 	static auto hostExtThreadCheckIsAudioThread(const clap_host_t* host) -> bool;
-	static void hostExtParamsRescan(const clap_host* host, uint32_t flags);
+	static void hostExtParamsRescan(const clap_host* host, std::uint32_t flags);
 	static void hostExtParamsClear(const clap_host* host, clap_id param_id, clap_param_clear_flags flags);
 	static void hostExtParamsRequestFlush(const clap_host* host);
 
 	auto canUsePluginParams() const noexcept -> bool;
 	//bool canUsePluginGui() const noexcept;
-	//static const char* getCurrentClapGuiApi();
+	//static const char* currentClapGuiApi();
 
 	void setParamValueByHost(ClapParam& param, double value);
 	void setParamModulationByHost(ClapParam& param, double value);
 	void checkValidParamValue(const ClapParam& param, double value);
 	auto getParamValue(const clap_param_info& info) const -> double;
-	static auto clapParamsRescanMayValueChange(uint32_t flags) -> bool { return flags & (CLAP_PARAM_RESCAN_ALL | CLAP_PARAM_RESCAN_VALUES); }
-	static auto clapParamsRescanMayInfoChange(uint32_t flags) -> bool { return flags & (CLAP_PARAM_RESCAN_ALL | CLAP_PARAM_RESCAN_INFO); }
+	static auto clapParamsRescanMayValueChange(std::uint32_t flags) -> bool { return flags & (CLAP_PARAM_RESCAN_ALL | CLAP_PARAM_RESCAN_VALUES); }
+	static auto clapParamsRescanMayInfoChange(std::uint32_t flags) -> bool { return flags & (CLAP_PARAM_RESCAN_ALL | CLAP_PARAM_RESCAN_INFO); }
 
 	clap_host m_host;
 	std::queue<std::function<bool()>> m_idleQueue;
@@ -289,11 +289,11 @@ class ClapInstance final : public LinkedModelGroup
 	class AudioBuffer
 	{
 	public:
-		AudioBuffer(uint32_t channels, uint32_t frames)
+		AudioBuffer(std::uint32_t channels, std::uint32_t frames)
 			: m_channels(channels), m_frames(frames)
 		{
 			m_data = new float*[m_channels]();
-			for (uint32_t channel = 0; channel < m_channels; ++channel)
+			for (std::uint32_t channel = 0; channel < m_channels; ++channel)
 			{
 				m_data[channel] = new float[m_frames]();
 			}
@@ -334,15 +334,15 @@ class ClapInstance final : public LinkedModelGroup
 		void free() noexcept
 		{
 			if (!m_data) { return; }
-			for (uint32_t channel = 0; channel < m_channels; ++channel)
+			for (std::uint32_t channel = 0; channel < m_channels; ++channel)
 			{
 				if (m_data[channel]) { delete[] m_data[channel]; }
 			}
 			delete[] m_data;
 		}
 
-		uint32_t m_channels;
-		uint32_t m_frames;
+		std::uint32_t m_channels;
+		std::uint32_t m_frames;
 		float** m_data = nullptr;
 	};
 
@@ -418,7 +418,7 @@ class ClapInstance final : public LinkedModelGroup
 	struct AudioPort
 	{
 		clap_audio_port_info info{};
-		uint32_t index = 0; //!< Index on plugin side, not m_audioPorts***
+		std::uint32_t index = 0; //!< Index on plugin side, not m_audioPorts***
 		bool is_input = false;
 		AudioPortType type = AudioPortType::Unsupported;
 		bool used = false; //!< In use by LMMS
@@ -458,7 +458,6 @@ class ClapInstance final : public LinkedModelGroup
 	 * Plugin/Host extension data
 	*/
 	bool m_hostExtStateIsDirty = false;
-
 };
 
 }

include/ClapManager.h

@@ -64,37 +64,32 @@ class ClapManager
 	 * Returns a cached URI-to-PluginInfo map
 	 * ClapManager doesn't own the ClapPluginInfo objects, so pointers may be invalidated.
 	*/
-	auto uriPluginInfo() const -> const std::unordered_map<std::string, std::weak_ptr<const ClapPluginInfo>>& { return m_uriToPluginInfo; }
-
-	//! Allows access to plugin instances
-	auto instances() const -> const std::vector<std::shared_ptr<ClapInstance>>& { return m_instances; }
+	auto uriToPluginInfo() const -> const std::unordered_map<std::string, std::weak_ptr<const ClapPluginInfo>>& { return m_uriToPluginInfo; }
 
 	//! Return plugin info with URI @p uri or nullptr if none exists
-	auto getPluginInfo(const std::string& uri) -> std::weak_ptr<const ClapPluginInfo>;
+	auto pluginInfo(const std::string& uri) -> std::weak_ptr<const ClapPluginInfo>;
 	//! Return plugin info with URI @p uri or nullptr if none exists
-	auto getPluginInfo(const QString& uri) -> std::weak_ptr<const ClapPluginInfo>;
+	auto pluginInfo(const QString& uri) -> std::weak_ptr<const ClapPluginInfo>;
 
 	//! Called by Engine at LMMS startup
 	void initPlugins();
 
 	//! Creates a plugin instance given plugin info; Plugin instance is owned by ClapManager
 	//auto createInstance(const ClapPluginInfo* info) -> std::weak_ptr<ClapPluginInstance>;
 
-	static auto getClapGuiApi() -> const char*;
+	static auto clapGuiApi() -> const char*;
 
 	static bool s_debug; //!< If LMMS_CLAP_DEBUG is set, debug output will be printed
 
 private:
 
 	std::vector<std::filesystem::path> m_searchPaths; //!< Owns all CLAP search paths; Populated by findSearchPaths()
 	std::vector<ClapFile> m_files; //!< Owns all loaded .clap files; Populated by loadClapFiles()
-	std::vector<std::shared_ptr<ClapInstance>> m_instances; //!< Owns all fully initialized CLAP host/plugin instance pairs
 
 	// Non-owning plugin caches (for fast iteration/lookup)
 	std::vector<std::weak_ptr<const ClapPluginInfo>> m_pluginInfo; //!< Non-owning vector of info for all successfully loaded CLAP plugins
-	std::unordered_map<std::string, std::weak_ptr<const ClapPluginInfo>> m_uriToPluginInfo; //!< Non-owning map of plugin URIs (IDs) to ClapPluginInfo // TODO: Any changes to m_instances must be done here too
-	//std::unordered_multimap<std::string, std::string_ptr<ClapPluginInstance>> m_uriToPluginInstance; //!< Non-owning map of plugin URIs (IDs) to ClapPluginInstances
-	//std::vector<const clap_plugin_t*> m_plugins; //!< Non-owning vector of all CLAP plugin instances
+	std::unordered_map<std::string, std::weak_ptr<const ClapPluginInfo>> m_uriToPluginInfo; //!< Non-owning map of plugin URIs (IDs) to ClapPluginInfo
+	//std::vector<std::weak_ptr<ClapInstance>> m_instances; //!< Vector of all CLAP plugin instances (for guaranteeing correct clean-up order)
 
 	//! Finds all CLAP search paths and populates m_searchPaths
 	void findSearchPaths();

include/ClapParam.h

@@ -64,8 +64,8 @@ class ClapParam : public QObject
 
 	auto model() const -> AutomatableModel* { return m_connectedModel.get(); }
 	auto valueType() const -> ParamType { return m_valueType; }
-	auto getId() const -> std::string_view { return m_id; }
-	auto getDisplayName() const -> std::string_view { return m_displayName; }
+	auto id() const -> std::string_view { return m_id; }
+	auto displayName() const -> std::string_view { return m_displayName; }
 	auto getValueText(const clap_plugin* plugin, const clap_plugin_params* params) const -> std::string;
 
 	auto value() const -> double { return m_value; }

include/ClapSubPluginFeatures.h

@@ -53,7 +53,7 @@ class LMMS_EXPORT ClapSubPluginFeatures : public Plugin::Descriptor::SubPluginFe
 	auto logo(const Key& key) const -> const PixmapLoader* override;
 
 private:
-	static auto getPluginInfo(const Key& key) -> std::shared_ptr<const ClapPluginInfo>;
+	static auto pluginInfo(const Key& key) -> std::shared_ptr<const ClapPluginInfo>;
 };
 
 

src/core/clap/ClapControlBase.cpp

@@ -42,7 +42,7 @@ ClapControlBase::ClapControlBase(Model* that, const QString& uri)
 {
 	qDebug() << "ClapControlBase::ClapControlBase";
 	auto manager = Engine::getClapManager();
-	m_info = manager->getPluginInfo(uri).lock().get();
+	m_info = manager->pluginInfo(uri).lock().get();
 	if (!m_info)
 	{
 		qCritical() << "No CLAP plugin found for URI" << uri;

src/core/clap/ClapFile.cpp

@@ -51,17 +51,12 @@ ClapFile::~ClapFile()
 
 auto ClapFile::load() -> bool
 {
-	m_valid = false;
-
-	m_library = std::make_unique<QLibrary>();
-	if (!m_library) { return false; }
-
-	m_library->setFileName(QString::fromUtf8(m_filename.c_str()));
-	m_library->setLoadHints(QLibrary::ResolveAllSymbolsHint | QLibrary::DeepBindHint);
-
 	// Do not allow reloading yet
-	if (m_library->isLoaded()) { return false; }
+	if (m_library && m_library->isLoaded()) { return false; }
+
+	m_valid = false;
 
+	m_library = std::make_unique<QLibrary>(QString::fromUtf8(m_filename.c_str()));
 	if (!m_library->load())
 	{
 		qWarning() << m_library->errorString();
@@ -71,20 +66,20 @@ auto ClapFile::load() -> bool
 	const auto pluginEntry = reinterpret_cast<const clap_plugin_entry*>(m_library->resolve("clap_entry"));
 	if (!pluginEntry)
 	{
-		qWarning() << "Unable to resolve entry point 'clap_entry' in '" << getFilename().c_str() << "'";
+		qWarning() << "Unable to resolve entry point 'clap_entry' in '" << filename().c_str() << "'";
 		m_library->unload();
 		return false;
 	}
 
-	pluginEntry->init(getFilename().c_str());
+	pluginEntry->init(filename().c_str());
 	m_factory = static_cast<const clap_plugin_factory*>(pluginEntry->get_factory(CLAP_PLUGIN_FACTORY_ID));
 
 	m_pluginCount = m_factory->get_plugin_count(m_factory);
 	if (ClapManager::s_debug) { qDebug() << "plugin count:" << m_pluginCount; }
 	if (m_pluginCount <= 0) { return false; }
 
 	m_pluginInfo.clear();
-	for (uint32_t i = 0; i < m_pluginCount; ++i)
+	for (std::uint32_t i = 0; i < m_pluginCount; ++i)
 	{
 		auto& plugin = m_pluginInfo.emplace_back(std::make_shared<ClapPluginInfo>(m_factory, i));
 		if (!plugin || !plugin->isValid())
@@ -100,8 +95,9 @@ auto ClapFile::load() -> bool
 
 void ClapFile::unload()
 {
-	// Need to destroy any plugin instances from this .clap file before
-	// calling this method. See ClapManager::unload().
+	// NOTE: Need to destroy any plugin instances from this .clap file before
+	// calling this method. This should be okay as long as the ClapManager
+	// singleton is destroyed after any ClapControlBase objects.
 
 	if (m_entry)
 	{
@@ -115,6 +111,8 @@ void ClapFile::unload()
 		m_library->unload();
 		m_library = nullptr;
 	}
+
+	m_valid = false;
 }
 
 void ClapFile::purgeInvalidPlugins()
@@ -130,12 +128,9 @@ void ClapFile::purgeInvalidPlugins()
 // ClapPluginInfo
 ////////////////////////////////
 
-ClapPluginInfo::ClapPluginInfo(const clap_plugin_factory* factory, uint32_t index)
+ClapPluginInfo::ClapPluginInfo(const clap_plugin_factory* factory, std::uint32_t index)
+	: m_factory{factory}, m_index{index}
 {
-	m_valid = false;
-	m_factory = factory;
-	m_index = index;
-
 	m_descriptor = m_factory->get_plugin_descriptor(m_factory, m_index);
 	if (!m_descriptor)
 	{