From 006c43820bfb7867c84abffc96bf178bf12437a0 Mon Sep 17 00:00:00 2001
From: Lost Robot <34612565+LostRobotMusic@users.noreply.github.com>
Date: Sun, 24 Sep 2023 04:19:19 -0700
Subject: [PATCH 01/11] Fix Compressor zero divisions (#6887)

* Fix threshold zero division

* Fix RMS zero division
---
 plugins/Compressor/Compressor.cpp              |  3 ++-
 plugins/Compressor/CompressorControlDialog.cpp | 18 ++++++++++--------
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/plugins/Compressor/Compressor.cpp b/plugins/Compressor/Compressor.cpp
index 33571606e..0fe139420 100755
--- a/plugins/Compressor/Compressor.cpp
+++ b/plugins/Compressor/Compressor.cpp
@@ -177,7 +177,8 @@ void CompressorEffect::calcRange()
 
 void CompressorEffect::resizeRMS()
 {
-	m_rmsTimeConst = exp(-1.f / (m_compressorControls.m_rmsModel.value() * 0.001f * m_sampleRate));
+	const float rmsValue = m_compressorControls.m_rmsModel.value();
+	m_rmsTimeConst = (rmsValue > 0) ? exp(-1.f / (rmsValue * 0.001f * m_sampleRate)) : 0;
 }
 
 void CompressorEffect::calcLookaheadLength()
diff --git a/plugins/Compressor/CompressorControlDialog.cpp b/plugins/Compressor/CompressorControlDialog.cpp
index 114980a7d..1516456a2 100755
--- a/plugins/Compressor/CompressorControlDialog.cpp
+++ b/plugins/Compressor/CompressorControlDialog.cpp
@@ -497,10 +497,12 @@ void CompressorControlDialog::redrawKnee()
 	float actualRatio = m_controls->m_limiterModel.value() ? 0 : m_controls->m_effect->m_ratioVal;
 
 	// Calculate endpoints for the two straight lines
-	float kneePoint1 = m_controls->m_effect->m_thresholdVal - m_controls->m_effect->m_kneeVal;
-	float kneePoint2X = m_controls->m_effect->m_thresholdVal + m_controls->m_effect->m_kneeVal;
-	float kneePoint2Y = (m_controls->m_effect->m_thresholdVal + (-m_controls->m_effect->m_thresholdVal * (actualRatio * (m_controls->m_effect->m_kneeVal / -m_controls->m_effect->m_thresholdVal))));
-	float ratioPoint = m_controls->m_effect->m_thresholdVal + (-m_controls->m_effect->m_thresholdVal * actualRatio);
+	const float thresholdVal = m_controls->m_effect->m_thresholdVal;
+	const float kneeVal = m_controls->m_effect->m_kneeVal;
+	float kneePoint1 = thresholdVal - kneeVal;
+	float kneePoint2X = thresholdVal + kneeVal;
+	float kneePoint2Y = thresholdVal + kneeVal * actualRatio;
+	float ratioPoint = thresholdVal + (-thresholdVal * actualRatio);
 
 	// Draw two straight lines
 	m_p.drawLine(0, m_kneeWindowSizeY, dbfsToXPoint(kneePoint1), dbfsToYPoint(kneePoint1));
@@ -510,7 +512,7 @@ void CompressorControlDialog::redrawKnee()
 	}
 
 	// Draw knee section
-	if (m_controls->m_effect->m_kneeVal)
+	if (kneeVal)
 	{
 		m_p.setPen(QPen(m_kneeColor2, 3));
 
@@ -522,8 +524,8 @@ void CompressorControlDialog::redrawKnee()
 		{
 			newPoint[0] = linearInterpolate(kneePoint1, kneePoint2X, (i + 1) / (float)COMP_KNEE_LINES);
 
-			const float temp = newPoint[0] - m_controls->m_effect->m_thresholdVal + m_controls->m_effect->m_kneeVal;
-			newPoint[1] = (newPoint[0] + (actualRatio - 1) * temp * temp / (4 * m_controls->m_effect->m_kneeVal));
+			const float temp = newPoint[0] - thresholdVal + kneeVal;
+			newPoint[1] = (newPoint[0] + (actualRatio - 1) * temp * temp / (4 * kneeVal));
 
 			m_p.drawLine(dbfsToXPoint(prevPoint[0]), dbfsToYPoint(prevPoint[1]), dbfsToXPoint(newPoint[0]), dbfsToYPoint(newPoint[1]));
 
@@ -768,4 +770,4 @@ void CompressorControlDialog::resetCompressorView()
 }
 
 
-} // namespace lmms::gui
\ No newline at end of file
+} // namespace lmms::gui

From c309d8bd11659a3f14557960a5e83366374d0ec2 Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Fri, 22 Sep 2023 23:54:07 +0200
Subject: [PATCH 02/11] Lv2ViewProc: Improve variable names

---
 include/Lv2ViewBase.h   |  2 +-
 src/gui/Lv2ViewBase.cpp | 22 +++++++++++-----------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/include/Lv2ViewBase.h b/include/Lv2ViewBase.h
index f7d0e9bcb..3c8f1bc3f 100644
--- a/include/Lv2ViewBase.h
+++ b/include/Lv2ViewBase.h
@@ -56,7 +56,7 @@ class Lv2ViewProc : public LinkedModelGroupView
 {
 public:
 	//! @param colNum numbers of columns for the controls
-	Lv2ViewProc(QWidget *parent, Lv2Proc *ctrlBase, int colNum);
+	Lv2ViewProc(QWidget *parent, Lv2Proc *proc, int colNum);
 	~Lv2ViewProc() override = default;
 
 private:
diff --git a/src/gui/Lv2ViewBase.cpp b/src/gui/Lv2ViewBase.cpp
index 3fd1d44b1..12be5e069 100644
--- a/src/gui/Lv2ViewBase.cpp
+++ b/src/gui/Lv2ViewBase.cpp
@@ -51,13 +51,13 @@ namespace lmms::gui
 {
 
 
-Lv2ViewProc::Lv2ViewProc(QWidget* parent, Lv2Proc* ctrlBase, int colNum) :
-	LinkedModelGroupView (parent, ctrlBase, colNum)
+Lv2ViewProc::Lv2ViewProc(QWidget* parent, Lv2Proc* proc, int colNum) :
+	LinkedModelGroupView (parent, proc, colNum)
 {
-	class SetupWidget : public Lv2Ports::ConstVisitor
+	class SetupTheWidget : public Lv2Ports::ConstVisitor
 	{
 	public:
-		QWidget* m_par; // input
+		QWidget* m_parent; // input
 		const LilvNode* m_commentUri; // input
 		Control* m_control = nullptr; // output
 		void visit(const Lv2Ports::Control& port) override
@@ -69,20 +69,20 @@ Lv2ViewProc::Lv2ViewProc(QWidget* parent, Lv2Proc* ctrlBase, int colNum) :
 				switch (port.m_vis)
 				{
 					case PortVis::Generic:
-						m_control = new KnobControl(m_par);
+						m_control = new KnobControl(m_parent);
 						break;
 					case PortVis::Integer:
 					{
 						sample_rate_t sr = Engine::audioEngine()->processingSampleRate();
 						m_control = new LcdControl((port.max(sr) <= 9.0f) ? 1 : 2,
-													m_par);
+													m_parent);
 						break;
 					}
 					case PortVis::Enumeration:
-						m_control = new ComboControl(m_par);
+						m_control = new ComboControl(m_parent);
 						break;
 					case PortVis::Toggled:
-						m_control = new CheckControl(m_par);
+						m_control = new CheckControl(m_parent);
 						break;
 				}
 				m_control->setText(port.name());
@@ -100,14 +100,14 @@ Lv2ViewProc::Lv2ViewProc(QWidget* parent, Lv2Proc* ctrlBase, int colNum) :
 	};
 
 	AutoLilvNode commentUri = uri(LILV_NS_RDFS "comment");
-	ctrlBase->foreach_port(
+	proc->foreach_port(
 		[this, &commentUri](const Lv2Ports::PortBase* port)
 		{
 			if(!lilv_port_has_property(port->m_plugin, port->m_port,
 										uri(LV2_PORT_PROPS__notOnGUI).get()))
 			{
-				SetupWidget setup;
-				setup.m_par = this;
+				SetupTheWidget setup;
+				setup.m_parent = this;
 				setup.m_commentUri = commentUri.get();
 				port->accept(setup);
 

From d97377b640c3f288ed68860a3ffcf60ad7b5c7d9 Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Fri, 22 Sep 2023 23:58:52 +0200
Subject: [PATCH 03/11] Lv2: Improve LED widget's digit calculation

This improves the way digits are calculated for display in
`Lv2ViewProc`:

- More than 2 digits are now recognized
- Minus signs are now recognized
- Tests have been added
---
 include/lmms_math.h         | 26 ++++++++++++++++++
 src/gui/Lv2ViewBase.cpp     |  7 +++--
 tests/CMakeLists.txt        |  1 +
 tests/src/core/MathTest.cpp | 53 +++++++++++++++++++++++++++++++++++++
 4 files changed, 85 insertions(+), 2 deletions(-)
 create mode 100644 tests/src/core/MathTest.cpp

diff --git a/include/lmms_math.h b/include/lmms_math.h
index b62da81c2..ea0a75581 100644
--- a/include/lmms_math.h
+++ b/include/lmms_math.h
@@ -325,6 +325,32 @@ static inline T absMin( T a, T b )
 	return std::abs(a) < std::abs(b) ? a : b;
 }
 
+// @brief Calculate number of digits which LcdSpinBox would show for a given number
+// @note Once we upgrade to C++20, we could probably use std::formatted_size
+static inline int numDigitsAsInt(float f)
+{
+	// use rounding:
+	// LcdSpinBox sometimes uses roundf(), sometimes cast rounding
+	// we use rounding to be on the "safe side"
+	const float rounded = roundf(f);
+	int asInt = static_cast<int>(rounded);
+	int digits = 1; // always at least 1
+	if(asInt < 0)
+	{
+		++digits;
+		asInt = -asInt;
+	}
+	// "asInt" is positive from now
+	int32_t power = 1;
+	for(int32_t i = 1; i<10; ++i)
+	{
+		power *= 10;
+		if(static_cast<int32_t>(asInt) >= power) { ++digits; } // 2 digits for >=10, 3 for >=100
+		else { break; }
+	}
+	return digits;
+}
+
 
 } // namespace lmms
 
diff --git a/src/gui/Lv2ViewBase.cpp b/src/gui/Lv2ViewBase.cpp
index 12be5e069..830a994c8 100644
--- a/src/gui/Lv2ViewBase.cpp
+++ b/src/gui/Lv2ViewBase.cpp
@@ -39,6 +39,7 @@
 #include "GuiApplication.h"
 #include "embed.h"
 #include "gui_templates.h"
+#include "lmms_math.h"
 #include "Lv2ControlBase.h"
 #include "Lv2Manager.h"
 #include "Lv2Proc.h"
@@ -74,8 +75,10 @@ Lv2ViewProc::Lv2ViewProc(QWidget* parent, Lv2Proc* proc, int colNum) :
 					case PortVis::Integer:
 					{
 						sample_rate_t sr = Engine::audioEngine()->processingSampleRate();
-						m_control = new LcdControl((port.max(sr) <= 9.0f) ? 1 : 2,
-													m_parent);
+						auto pMin = port.min(sr);
+						auto pMax = port.max(sr);
+						int numDigits = std::max(numDigitsAsInt(pMin), numDigitsAsInt(pMax));
+						m_control = new LcdControl(numDigits, m_parent);
 						break;
 					}
 					case PortVis::Enumeration:
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 514bf7815..ddf9e2962 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -21,6 +21,7 @@ ADD_EXECUTABLE(tests
 
 	src/core/ArrayVectorTest.cpp
 	src/core/AutomatableModelTest.cpp
+	src/core/MathTest.cpp
 	src/core/ProjectVersionTest.cpp
 	src/core/RelativePathsTest.cpp
 
diff --git a/tests/src/core/MathTest.cpp b/tests/src/core/MathTest.cpp
new file mode 100644
index 000000000..2b6404cfd
--- /dev/null
+++ b/tests/src/core/MathTest.cpp
@@ -0,0 +1,53 @@
+/*
+ * MathTest.cpp
+ *
+ * Copyright (c) 2023 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
+ *
+ * This file is part of LMMS - https://lmms.io
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+
+#include "QTestSuite.h"
+
+#include "lmms_math.h"
+
+#include <QDir>
+
+class MathTest : QTestSuite
+{
+	Q_OBJECT
+private slots:
+	void NumDigitsTest()
+	{
+		using namespace lmms;
+		QCOMPARE(numDigitsAsInt(1.f), 1);
+		QCOMPARE(numDigitsAsInt(9.9f), 2);
+		QCOMPARE(numDigitsAsInt(10.f), 2);
+		QCOMPARE(numDigitsAsInt(0.f), 1);
+		QCOMPARE(numDigitsAsInt(-100.f), 4);
+		QCOMPARE(numDigitsAsInt(-99.f), 3);
+		QCOMPARE(numDigitsAsInt(-0.4f), 1); // there is no "-0" for LED spinbox
+		QCOMPARE(numDigitsAsInt(-0.99f), 2);
+		QCOMPARE(numDigitsAsInt(1000000000), 10);
+		QCOMPARE(numDigitsAsInt(-1000000000), 11);
+		QCOMPARE(numDigitsAsInt(900000000), 9);
+		QCOMPARE(numDigitsAsInt(-900000000), 10);
+	}
+} MathTests;
+
+#include "MathTest.moc"

From 9c46370234fe45437f0f64fab963a232cb3e9a46 Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Sat, 23 Sep 2023 00:00:02 +0200
Subject: [PATCH 04/11] Support LV2_BUF_SIZE__powerOf2BlockLength

---
 src/core/lv2/Lv2Manager.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/core/lv2/Lv2Manager.cpp b/src/core/lv2/Lv2Manager.cpp
index 9c62703e0..df6e5a7c1 100644
--- a/src/core/lv2/Lv2Manager.cpp
+++ b/src/core/lv2/Lv2Manager.cpp
@@ -35,6 +35,7 @@
 #include <QDebug>
 #include <QElapsedTimer>
 
+#include "AudioEngine.h"
 #include "Engine.h"
 #include "Plugin.h"
 #include "Lv2ControlBase.h"
@@ -156,6 +157,10 @@ Lv2Manager::Lv2Manager() :
 	m_supportedFeatureURIs.insert(LV2_BUF_SIZE__boundedBlockLength);
 	// block length is only changed initially in AudioEngine CTOR
 	m_supportedFeatureURIs.insert(LV2_BUF_SIZE__fixedBlockLength);
+	if (const auto fpp = Engine::audioEngine()->framesPerPeriod(); (fpp & (fpp - 1)) == 0)  // <=> ffp is power of 2 (for ffp > 0)
+	{
+		m_supportedFeatureURIs.insert(LV2_BUF_SIZE__powerOf2BlockLength);
+	}
 
 	auto supportOpt = [this](Lv2UridCache::Id id)
 	{

From 61b612634d1690ba5ac21c4a9fea455e8a9e6f64 Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Fri, 22 Sep 2023 23:38:57 +0200
Subject: [PATCH 05/11] Add plugin blacklist for buffersize<=32

---
 include/Lv2Features.h        |  3 ++-
 include/Lv2Manager.h         | 20 ++++++++++----------
 src/core/lv2/Lv2Features.cpp |  6 +++---
 src/core/lv2/Lv2Manager.cpp  | 31 +++++++++++++++++++++----------
 src/core/lv2/Lv2Proc.cpp     | 16 ++++++++++++----
 5 files changed, 48 insertions(+), 28 deletions(-)

diff --git a/include/Lv2Features.h b/include/Lv2Features.h
index b5bc284c8..69a456bbd 100644
--- a/include/Lv2Features.h
+++ b/include/Lv2Features.h
@@ -30,6 +30,7 @@
 #ifdef LMMS_HAVE_LV2
 
 #include <map>
+#include <string_view>
 #include <vector>
 #include "Lv2Manager.h"
 
@@ -78,7 +79,7 @@ private:
 	//! pointers to m_features, required for lilv_plugin_instantiate
 	std::vector<const LV2_Feature*> m_featurePointers;
 	//! features + data, ordered by URI
-	std::map<const char*, void*, Lv2Manager::CmpStr> m_featureByUri;
+	std::map<std::string_view, void*> m_featureByUri;
 };
 
 
diff --git a/include/Lv2Manager.h b/include/Lv2Manager.h
index 909dba560..58126a0a4 100644
--- a/include/Lv2Manager.h
+++ b/include/Lv2Manager.h
@@ -31,6 +31,7 @@
 
 #include <map>
 #include <set>
+#include <string_view>
 #include <lilv/lilv.h>
 
 #include "Lv2Basics.h"
@@ -120,15 +121,9 @@ public:
 	Iterator begin() { return m_lv2InfoMap.begin(); }
 	Iterator end() { return m_lv2InfoMap.end(); }
 
-	//! strcmp based key comparator for std::set and std::map
-	struct CmpStr
-	{
-		bool operator()(char const *a, char const *b) const;
-	};
-
 	UridMap& uridMap() { return m_uridMap; }
 	const Lv2UridCache& uridCache() const { return m_uridCache; }
-	const std::set<const char*, CmpStr>& supportedFeatureURIs() const
+	const std::set<std::string_view>& supportedFeatureURIs() const
 	{
 		return m_supportedFeatureURIs;
 	}
@@ -136,17 +131,21 @@ public:
 	AutoLilvNodes findNodes(const LilvNode *subject,
 		const LilvNode *predicate, const LilvNode *object);
 
-	static const std::set<const char*, Lv2Manager::CmpStr>& getPluginBlacklist()
+	static const std::set<std::string_view>& getPluginBlacklist()
 	{
 		return pluginBlacklist;
 	}
+	static const std::set<std::string_view>& getPluginBlacklistBuffersizeLessThan32()
+	{
+		return pluginBlacklistBuffersizeLessThan32;
+	}
 
 private:
 	// general data
 	bool m_debug; //!< if set, debug output will be printed
 	LilvWorld* m_world;
 	Lv2InfoMap m_lv2InfoMap;
-	std::set<const char*, CmpStr> m_supportedFeatureURIs;
+	std::set<std::string_view> m_supportedFeatureURIs;
 
 	// feature data that are common for all Lv2Proc
 	UridMap m_uridMap;
@@ -155,7 +154,8 @@ private:
 	Lv2UridCache m_uridCache;
 
 	// static
-	static const std::set<const char*, Lv2Manager::CmpStr> pluginBlacklist;
+	static const std::set<std::string_view>
+		pluginBlacklist, pluginBlacklistBuffersizeLessThan32;
 
 	// functions
 	bool isSubclassOf(const LilvPluginClass *clvss, const char *uriStr);
diff --git a/src/core/lv2/Lv2Features.cpp b/src/core/lv2/Lv2Features.cpp
index 6e74a8936..c8fc05465 100644
--- a/src/core/lv2/Lv2Features.cpp
+++ b/src/core/lv2/Lv2Features.cpp
@@ -48,7 +48,7 @@ Lv2Features::Lv2Features()
 {
 	const Lv2Manager* man = Engine::getLv2Manager();
 	// create (yet empty) map feature URI -> feature
-	for(const char* uri : man->supportedFeatureURIs())
+	for(auto uri : man->supportedFeatureURIs())
 	{
 		m_featureByUri.emplace(uri, nullptr);
 	}
@@ -71,7 +71,7 @@ void Lv2Features::initCommon()
 void Lv2Features::createFeatureVectors()
 {
 	// create vector of features
-	for(std::pair<const char* const, void*>& pr : m_featureByUri)
+	for(const auto& [uri, feature] : m_featureByUri)
 	{
 		/*
 			If pr.second is nullptr here, this means that the LV2_feature
@@ -82,7 +82,7 @@ void Lv2Features::createFeatureVectors()
 			  vector creation (This can be done in
 			  Lv2Proc::initPluginSpecificFeatures or in Lv2Features::initCommon)
 		*/
-		m_features.push_back(LV2_Feature { pr.first, pr.second });
+		m_features.push_back(LV2_Feature{(const char*)uri.data(), (void*)feature});
 	}
 
 	// create pointer vector (for lilv_plugin_instantiate)
diff --git a/src/core/lv2/Lv2Manager.cpp b/src/core/lv2/Lv2Manager.cpp
index df6e5a7c1..489e613b7 100644
--- a/src/core/lv2/Lv2Manager.cpp
+++ b/src/core/lv2/Lv2Manager.cpp
@@ -28,7 +28,6 @@
 
 #include <algorithm>
 #include <cstdlib>
-#include <cstring>
 #include <lilv/lilv.h>
 #include <lv2/lv2plug.in/ns/ext/buf-size/buf-size.h>
 #include <lv2/lv2plug.in/ns/ext/options/options.h>
@@ -47,7 +46,7 @@ namespace lmms
 {
 
 
-const std::set<const char*, Lv2Manager::CmpStr> Lv2Manager::pluginBlacklist =
+const std::set<std::string_view> Lv2Manager::pluginBlacklist =
 {
 	// github.com/calf-studio-gear/calf, #278
 	"http://calf.sourceforge.net/plugins/Analyzer",
@@ -138,6 +137,26 @@ const std::set<const char*, Lv2Manager::CmpStr> Lv2Manager::pluginBlacklist =
 	"urn:juced:DrumSynth"
 };
 
+const std::set<std::string_view> Lv2Manager::pluginBlacklistBuffersizeLessThan32 =
+{
+	"http://moddevices.com/plugins/mod-devel/2Voices",
+	"http://moddevices.com/plugins/mod-devel/Capo",
+	"http://moddevices.com/plugins/mod-devel/Drop",
+	"http://moddevices.com/plugins/mod-devel/Harmonizer",
+	"http://moddevices.com/plugins/mod-devel/Harmonizer2",
+	"http://moddevices.com/plugins/mod-devel/HarmonizerCS",
+	"http://moddevices.com/plugins/mod-devel/SuperCapo",
+	"http://moddevices.com/plugins/mod-devel/SuperWhammy",
+	"http://moddevices.com/plugins/mod-devel/Gx2Voices",
+	"http://moddevices.com/plugins/mod-devel/GxCapo",
+	"http://moddevices.com/plugins/mod-devel/GxDrop",
+	"http://moddevices.com/plugins/mod-devel/GxHarmonizer",
+	"http://moddevices.com/plugins/mod-devel/GxHarmonizer2",
+	"http://moddevices.com/plugins/mod-devel/GxHarmonizerCS",
+	"http://moddevices.com/plugins/mod-devel/GxSuperCapo",
+	"http://moddevices.com/plugins/mod-devel/GxSuperWhammy"
+};
+
 
 
 
@@ -293,14 +312,6 @@ void Lv2Manager::initPlugins()
 
 
 
-bool Lv2Manager::CmpStr::operator()(const char *a, const char *b) const
-{
-	return std::strcmp(a, b) < 0;
-}
-
-
-
-
 bool Lv2Manager::isFeatureSupported(const char *featName) const
 {
 	return m_supportedFeatureURIs.find(featName) != m_supportedFeatureURIs.end();
diff --git a/src/core/lv2/Lv2Proc.cpp b/src/core/lv2/Lv2Proc.cpp
index e0541b948..6776a26ed 100644
--- a/src/core/lv2/Lv2Proc.cpp
+++ b/src/core/lv2/Lv2Proc.cpp
@@ -75,11 +75,19 @@ Plugin::Type Lv2Proc::check(const LilvPlugin *plugin,
 	// TODO: manage a global blacklist outside of the code
 	//       for now, this will help
 	//       this is only a fix for the meantime
-	const auto& pluginBlacklist = Lv2Manager::getPluginBlacklist();
-	if (!Engine::ignorePluginBlacklist() &&
-		pluginBlacklist.find(pluginUri) != pluginBlacklist.end())
+	if (!Engine::ignorePluginBlacklist())
 	{
-		issues.emplace_back(PluginIssueType::Blacklisted);
+		const auto& pluginBlacklist = Lv2Manager::getPluginBlacklist();
+		const auto& pluginBlacklist32 = Lv2Manager::getPluginBlacklistBuffersizeLessThan32();
+		if(pluginBlacklist.find(pluginUri) != pluginBlacklist.end())
+		{
+			issues.emplace_back(PluginIssueType::Blacklisted);
+		}
+		else if(Engine::audioEngine()->framesPerPeriod() <= 32 &&
+			pluginBlacklist32.find(pluginUri) != pluginBlacklist32.end())
+		{
+			issues.emplace_back(PluginIssueType::Blacklisted);  // currently no special blacklist category
+		}
 	}
 
 	for (unsigned portNum = 0; portNum < maxPorts; ++portNum)

From 7aca8ae726ab425b47802721703fb5589fe8289a Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Fri, 22 Sep 2023 23:56:45 +0200
Subject: [PATCH 06/11] SetupDialog: Warn of unusual buffersizes

This displays a warning dialog if the users requests unusual
buffersizes:

- buffersizes less than 32
- buffersizes which are not a (natural number) power of 2

This commit also replaces some `setGeometry` stuff by `QBoxLayout`.
---
 include/SetupDialog.h          |  2 ++
 src/gui/modals/SetupDialog.cpp | 38 ++++++++++++++++++++++++++++------
 2 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/include/SetupDialog.h b/include/SetupDialog.h
index de4cdd9dd..fa41325db 100644
--- a/include/SetupDialog.h
+++ b/include/SetupDialog.h
@@ -102,6 +102,7 @@ private slots:
 	// Audio settings widget.
 	void audioInterfaceChanged(const QString & driver);
 	void toggleHQAudioDev(bool enabled);
+	void updateBufferSizeWarning(int value);
 	void setBufferSize(int value);
 	void resetBufferSize();
 
@@ -179,6 +180,7 @@ private:
 	int m_bufferSize;
 	QSlider * m_bufferSizeSlider;
 	QLabel * m_bufferSizeLbl;
+	QLabel * m_bufferSizeWarnLbl;
 
 	// MIDI settings widgets.
 	QComboBox * m_midiInterfaces;
diff --git a/src/gui/modals/SetupDialog.cpp b/src/gui/modals/SetupDialog.cpp
index 63b84506e..0266285a7 100644
--- a/src/gui/modals/SetupDialog.cpp
+++ b/src/gui/modals/SetupDialog.cpp
@@ -579,32 +579,39 @@ SetupDialog::SetupDialog(ConfigTab tab_to_open) :
 
 	// Buffer size tab.
 	auto bufferSize_tw = new TabWidget(tr("Buffer size"), audio_w);
-	bufferSize_tw->setFixedHeight(76);
+	auto bufferSize_layout = new QVBoxLayout(bufferSize_tw);
+	bufferSize_layout->setSpacing(10);
+	bufferSize_layout->setContentsMargins(10, 18, 10, 10);
 
 	m_bufferSizeSlider = new QSlider(Qt::Horizontal, bufferSize_tw);
 	m_bufferSizeSlider->setRange(1, 128);
 	m_bufferSizeSlider->setTickInterval(8);
 	m_bufferSizeSlider->setPageStep(8);
 	m_bufferSizeSlider->setValue(m_bufferSize / BUFFERSIZE_RESOLUTION);
-	m_bufferSizeSlider->setGeometry(10, 18, 340, 18);
 	m_bufferSizeSlider->setTickPosition(QSlider::TicksBelow);
 
+	m_bufferSizeLbl = new QLabel(bufferSize_tw);
+
+	m_bufferSizeWarnLbl = new QLabel(bufferSize_tw);
+	m_bufferSizeWarnLbl->setWordWrap(true);
+
 	connect(m_bufferSizeSlider, SIGNAL(valueChanged(int)),
 			this, SLOT(setBufferSize(int)));
 	connect(m_bufferSizeSlider, SIGNAL(valueChanged(int)),
 			this, SLOT(showRestartWarning()));
-
-	m_bufferSizeLbl = new QLabel(bufferSize_tw);
-	m_bufferSizeLbl->setGeometry(10, 40, 200, 24);
 	setBufferSize(m_bufferSizeSlider->value());
 
 	auto bufferSize_reset_btn = new QPushButton(embed::getIconPixmap("reload"), "", bufferSize_tw);
-	bufferSize_reset_btn->setGeometry(320, 40, 28, 28);
 	connect(bufferSize_reset_btn, SIGNAL(clicked()),
 			this, SLOT(resetBufferSize()));
 	bufferSize_reset_btn->setToolTip(
 			tr("Reset to default value"));
 
+	bufferSize_layout->addWidget(m_bufferSizeSlider);
+	bufferSize_layout->addWidget(m_bufferSizeLbl);
+	bufferSize_layout->addWidget(m_bufferSizeWarnLbl);
+	bufferSize_layout->addWidget(bufferSize_reset_btn);
+
 
 	// Audio layout ordering.
 	audio_layout->addWidget(audioiface_tw);
@@ -1172,6 +1179,24 @@ void SetupDialog::audioInterfaceChanged(const QString & iface)
 }
 
 
+void SetupDialog::updateBufferSizeWarning(int value)
+{
+	QString text = "<ul>";
+	if((value & (value - 1)) != 0)  // <=> value is not a power of 2 (for value > 0)
+	{
+		text += "<li>" + tr("The currently selected value is not a power of 2 "
+					"(32, 64, 128, 256, 512, 1024, ...). Some plugins may not be available.") + "</li>";
+	}
+	if(value <= 32)
+	{
+		text += "<li>" + tr("The currently selected value is less than or equal to 32. "
+					"Some plugins may not be available.") + "</li>";
+	}
+	text += "</ul>";
+	m_bufferSizeWarnLbl->setText(text);
+}
+
+
 void SetupDialog::setBufferSize(int value)
 {
 	const int step = DEFAULT_BUFFER_SIZE / BUFFERSIZE_RESOLUTION;
@@ -1197,6 +1222,7 @@ void SetupDialog::setBufferSize(int value)
 	m_bufferSize = value * BUFFERSIZE_RESOLUTION;
 	m_bufferSizeLbl->setText(tr("Frames: %1\nLatency: %2 ms").arg(m_bufferSize).arg(
 		1000.0f * m_bufferSize / Engine::audioEngine()->processingSampleRate(), 0, 'f', 1));
+	updateBufferSizeWarning(m_bufferSize);
 }
 
 

From 94608eaad1da0622a5eb1fa6d169f8e92d06a6aa Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Fri, 22 Sep 2023 23:42:45 +0200
Subject: [PATCH 07/11] Lv2Proc: Sort scale point maps (#6859)

lilv can return the scale points in randomized order, and so the linked
models (of stereo effects wit 2 `Lv2Proc`) may have different scale
points. This would mean that the same combo enumeration value would have
different float values in linked models. This problem is fixed by
sorting the scale values.

Also, it is more natural for users if scale points are enumerated in a
numerical order.
---
 include/Lv2Basics.h      |  6 ++++++
 src/core/lv2/Lv2Proc.cpp | 28 +++++++++++++++++-----------
 2 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/include/Lv2Basics.h b/include/Lv2Basics.h
index 9a958d973..53489e30d 100644
--- a/include/Lv2Basics.h
+++ b/include/Lv2Basics.h
@@ -47,8 +47,14 @@ struct LilvNodesDeleter
 	void operator()(LilvNodes* n) { lilv_nodes_free(n); }
 };
 
+struct LilvScalePointsDeleter
+{
+	void operator()(LilvScalePoints* s) { lilv_scale_points_free(s); }
+};
+
 using AutoLilvNode = std::unique_ptr<LilvNode, LilvNodeDeleter>;
 using AutoLilvNodes = std::unique_ptr<LilvNodes, LilvNodesDeleter>;
+using AutoLilvScalePoints = std::unique_ptr<LilvScalePoints, LilvScalePointsDeleter>;
 
 /**
 	Return QString from a plugin's node, everything will be freed automatically
diff --git a/src/core/lv2/Lv2Proc.cpp b/src/core/lv2/Lv2Proc.cpp
index 6776a26ed..a5fdf4041 100644
--- a/src/core/lv2/Lv2Proc.cpp
+++ b/src/core/lv2/Lv2Proc.cpp
@@ -574,19 +574,25 @@ void Lv2Proc::createPort(std::size_t portNum)
 						break;
 					case Lv2Ports::Vis::Enumeration:
 					{
-						auto comboModel = new ComboBoxModel(nullptr, dispName);
-						LilvScalePoints* sps =
-							lilv_port_get_scale_points(m_plugin, lilvPort);
-						LILV_FOREACH(scale_points, i, sps)
+						ComboBoxModel* comboModel = new ComboBoxModel(nullptr, dispName);
+
 						{
-							const LilvScalePoint* sp = lilv_scale_points_get(sps, i);
-							ctrl->m_scalePointMap.push_back(lilv_node_as_float(
-											lilv_scale_point_get_value(sp)));
-							comboModel->addItem(
-								lilv_node_as_string(
-									lilv_scale_point_get_label(sp)));
+							AutoLilvScalePoints sps (static_cast<LilvScalePoints*>(lilv_port_get_scale_points(m_plugin, lilvPort)));
+							// temporary map, since lilv may return scale points in random order
+							std::map<float, const char*> scalePointMap;
+							LILV_FOREACH(scale_points, i, sps.get())
+							{
+								const LilvScalePoint* sp = lilv_scale_points_get(sps.get(), i);
+								const float f = lilv_node_as_float(lilv_scale_point_get_value(sp));
+								const char* s = lilv_node_as_string(lilv_scale_point_get_label(sp));
+								scalePointMap[f] = s;
+							}
+							for (const auto& [f,s] : scalePointMap)
+							{
+								ctrl->m_scalePointMap.push_back(f);
+								comboModel->addItem(s);
+							}
 						}
-						lilv_scale_points_free(sps);
 						ctrl->m_connectedModel.reset(comboModel);
 						// TODO: use default value on comboModel, too?
 						break;

From 83777dc1f73736ec58376590f09cba92331cd901 Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Fri, 22 Sep 2023 23:42:45 +0200
Subject: [PATCH 08/11] Lv2Proc: Set def val for ComboModel, too

---
 src/core/lv2/Lv2Proc.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/core/lv2/Lv2Proc.cpp b/src/core/lv2/Lv2Proc.cpp
index a5fdf4041..242f3d92b 100644
--- a/src/core/lv2/Lv2Proc.cpp
+++ b/src/core/lv2/Lv2Proc.cpp
@@ -593,8 +593,16 @@ void Lv2Proc::createPort(std::size_t portNum)
 								comboModel->addItem(s);
 							}
 						}
+						for(std::size_t i = 0; i < ctrl->m_scalePointMap.size(); ++i)
+						{
+							if(meta.def() == ctrl->m_scalePointMap[i])
+							{
+								comboModel->setValue(i);
+								comboModel->setInitValue(i);
+								break;
+							}
+						}
 						ctrl->m_connectedModel.reset(comboModel);
-						// TODO: use default value on comboModel, too?
 						break;
 					}
 					case Lv2Ports::Vis::Toggled:

From 33d1baddc0284bd68df752a08ff9c673a706c4d7 Mon Sep 17 00:00:00 2001
From: Johannes Lorenz <j.git@lorenz-ho.me>
Date: Fri, 22 Sep 2023 23:27:02 +0200
Subject: [PATCH 09/11] Implement Lv2 Worker (#6484)

---
 include/AudioEngine.h        |   1 +
 include/LmmsSemaphore.h      |  93 ++++++++++++++++
 include/LocklessRingBuffer.h |   3 +-
 include/Lv2Proc.h            |  13 ++-
 include/Lv2Worker.h          |  93 ++++++++++++++++
 src/core/CMakeLists.txt      |   2 +
 src/core/LmmsSemaphore.cpp   | 143 ++++++++++++++++++++++++
 src/core/lv2/Lv2Manager.cpp  |   2 +
 src/core/lv2/Lv2Proc.cpp     |  31 +++++-
 src/core/lv2/Lv2Worker.cpp   | 203 +++++++++++++++++++++++++++++++++++
 10 files changed, 580 insertions(+), 4 deletions(-)
 create mode 100644 include/LmmsSemaphore.h
 create mode 100644 include/Lv2Worker.h
 create mode 100644 src/core/LmmsSemaphore.cpp
 create mode 100644 src/core/lv2/Lv2Worker.cpp

diff --git a/include/AudioEngine.h b/include/AudioEngine.h
index f056c22e1..d3d0d025f 100644
--- a/include/AudioEngine.h
+++ b/include/AudioEngine.h
@@ -197,6 +197,7 @@ public:
 
 	// audio-device-stuff
 
+	bool renderOnly() const { return m_renderOnly; }
 	// Returns the current audio device's name. This is not necessarily
 	// the user's preferred audio device, in case you were thinking that.
 	inline const QString & audioDevName() const
diff --git a/include/LmmsSemaphore.h b/include/LmmsSemaphore.h
new file mode 100644
index 000000000..4170eef6c
--- /dev/null
+++ b/include/LmmsSemaphore.h
@@ -0,0 +1,93 @@
+/*
+ * Semaphore.h - Semaphore declaration
+ *
+ * Copyright (c) 2022-2022 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
+ *
+ * This file is part of LMMS - https://lmms.io
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+
+/*
+ * This code has been copied and adapted from https://github.com/drobilla/jalv
+ * File src/zix/sem.h
+ */
+
+#ifndef LMMS_SEMAPHORE_H
+#define LMMS_SEMAPHORE_H
+
+#include "lmmsconfig.h"
+
+#ifdef LMMS_BUILD_APPLE
+#    include <mach/mach.h>
+#elif defined(LMMS_BUILD_WIN32)
+#    include <windows.h>
+#else
+#    include <semaphore.h>
+#endif
+
+#include <system_error>
+
+namespace lmms {
+
+/**
+   A counting semaphore.
+
+   This is an integer that is always positive, and has two main operations:
+   increment (post) and decrement (wait).  If a decrement can not be performed
+   (i.e. the value is 0) the caller will be blocked until another thread posts
+   and the operation can succeed.
+
+   Semaphores can be created with any starting value, but typically this will
+   be 0 so the semaphore can be used as a simple signal where each post
+   corresponds to one wait.
+
+   Semaphores are very efficient (much moreso than a mutex/cond pair).  In
+   particular, at least on Linux, post is async-signal-safe, which means it
+   does not block and will not be interrupted.  If you need to signal from
+   a realtime thread, this is the most appropriate primitive to use.
+
+   @note Likely outdated with C++20's std::counting_semaphore
+		 (though we have to check that this will be RT conforming on all platforms)
+*/
+class Semaphore
+{
+public:
+	Semaphore(unsigned initial);
+	Semaphore(const Semaphore&) = delete;
+	Semaphore& operator=(const Semaphore&) = delete;
+	Semaphore(Semaphore&&) = delete;
+	Semaphore& operator=(Semaphore&&) = delete;
+	~Semaphore();
+
+	void post();
+	void wait();
+	bool tryWait();
+
+private:
+#ifdef LMMS_BUILD_APPLE
+	semaphore_t m_sem;
+#elif defined(LMMS_BUILD_WIN32)
+	HANDLE m_sem;
+#else
+	sem_t m_sem;
+#endif
+};
+
+} // namespace lmms
+
+#endif // LMMS_SEMAPHORE_H
diff --git a/include/LocklessRingBuffer.h b/include/LocklessRingBuffer.h
index 99c48cc90..2d65badfe 100644
--- a/include/LocklessRingBuffer.h
+++ b/include/LocklessRingBuffer.h
@@ -51,13 +51,14 @@ public:
 	std::size_t capacity() const {return m_buffer.maximum_eventual_write_space();}
 	std::size_t free() const {return m_buffer.write_space();}
 	void wakeAll() {m_notifier.wakeAll();}
-	std::size_t write(const sampleFrame *src, std::size_t cnt, bool notify = false)
+	std::size_t write(const T *src, std::size_t cnt, bool notify = false)
 	{
 		std::size_t written = LocklessRingBuffer<T>::m_buffer.write(src, cnt);
 		// Let all waiting readers know new data are available.
 		if (notify) {LocklessRingBuffer<T>::m_notifier.wakeAll();}
 		return written;
 	}
+	void mlock() { m_buffer.mlock(); }
 
 protected:
 	ringbuffer_t<T> m_buffer;
diff --git a/include/Lv2Proc.h b/include/Lv2Proc.h
index 62070def7..76fa5eec2 100644
--- a/include/Lv2Proc.h
+++ b/include/Lv2Proc.h
@@ -1,7 +1,7 @@
 /*
  * Lv2Proc.h - Lv2 processor class
  *
- * Copyright (c) 2019-2020 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
+ * Copyright (c) 2019-2022 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -31,11 +31,14 @@
 
 #include <lilv/lilv.h>
 #include <memory>
+#include <optional>
 
+#include "LinkedModelGroups.h"
+#include "LmmsSemaphore.h"
 #include "Lv2Basics.h"
 #include "Lv2Features.h"
 #include "Lv2Options.h"
-#include "LinkedModelGroups.h"
+#include "Lv2Worker.h"
 #include "Plugin.h"
 #include "../src/3rdparty/ringbuffer/include/ringbuffer/ringbuffer.h"
 #include "TimePos.h"
@@ -174,8 +177,14 @@ private:
 	const LilvPlugin* m_plugin;
 	LilvInstance* m_instance;
 	Lv2Features m_features;
+
+	// options
 	Lv2Options m_options;
 
+	// worker
+	std::optional<Lv2Worker> m_worker;
+	Semaphore m_workLock; // this must be shared by different workers
+
 	// full list of ports
 	std::vector<std::unique_ptr<Lv2Ports::PortBase>> m_ports;
 	// quick reference to specific, unique ports
diff --git a/include/Lv2Worker.h b/include/Lv2Worker.h
new file mode 100644
index 000000000..7931f8e7c
--- /dev/null
+++ b/include/Lv2Worker.h
@@ -0,0 +1,93 @@
+/*
+ * Lv2Worker.h - Lv2Worker class
+ *
+ * Copyright (c) 2022-2022 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
+ *
+ * This file is part of LMMS - https://lmms.io
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef LV2WORKER_H
+#define LV2WORKER_H
+
+#include "lmmsconfig.h"
+
+#ifdef LMMS_HAVE_LV2
+
+#include <lilv/lilv.h>
+#include <lv2/lv2plug.in/ns/ext/worker/worker.h>
+#include <thread>
+#include <vector>
+
+#include "LocklessRingBuffer.h"
+#include "LmmsSemaphore.h"
+
+namespace lmms
+{
+
+/**
+	Worker container
+*/
+class Lv2Worker
+{
+public:
+	// CTOR/DTOR/feature access
+	Lv2Worker(const LV2_Worker_Interface* iface, Semaphore* common_work_lock, bool threaded);
+	~Lv2Worker();
+	void setHandle(LV2_Handle handle) { m_handle = handle; }
+	LV2_Worker_Schedule* feature() { return &m_scheduleFeature; }
+
+	// public API
+	void emitResponses();
+	void notifyPluginThatRunFinished()
+	{
+		if(m_iface->end_run) { m_iface->end_run(m_scheduleFeature.handle); }
+	}
+
+	// to be called only by static functions
+	LV2_Worker_Status scheduleWork(uint32_t size, const void* data);
+	LV2_Worker_Status respond(uint32_t size, const void* data);
+
+private:
+	// functions
+	void workerFunc();
+	std::size_t bufferSize() const;  //!< size of internal buffers
+
+	// parameters
+	const LV2_Worker_Interface* m_iface;
+	bool m_threaded;
+	LV2_Handle m_handle;
+	LV2_Worker_Schedule m_scheduleFeature;
+
+	// threading/synchronization
+	std::thread m_thread;
+	std::vector<char> m_response;  //!< buffer where single requests from m_requests are unpacked
+	LocklessRingBuffer<char> m_requests, m_responses;  //!< ringbuffer to queue multiple requests
+	LocklessRingBufferReader<char> m_requestsReader, m_responsesReader;
+	std::atomic<bool> m_exit = false;  //!< Whether the worker function should keep looping
+	Semaphore m_sem;
+	Semaphore* m_workLock;
+};
+
+
+} // namespace lmms
+
+#endif // LMMS_HAVE_LV2
+
+#endif // LV2WORKER_H
+
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 319882af2..1155f5e0d 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -70,6 +70,7 @@ set(LMMS_SRCS
 	core/SamplePlayHandle.cpp
 	core/SampleRecordHandle.cpp
 	core/Scale.cpp
+	core/LmmsSemaphore.cpp
 	core/SerializingObject.cpp
 	core/Song.cpp
 	core/TempoSyncKnobModel.cpp
@@ -112,6 +113,7 @@ set(LMMS_SRCS
 	core/lv2/Lv2SubPluginFeatures.cpp
 	core/lv2/Lv2UridCache.cpp
 	core/lv2/Lv2UridMap.cpp
+	core/lv2/Lv2Worker.cpp
 
 	core/midi/MidiAlsaRaw.cpp
 	core/midi/MidiAlsaSeq.cpp
diff --git a/src/core/LmmsSemaphore.cpp b/src/core/LmmsSemaphore.cpp
new file mode 100644
index 000000000..daa70a45b
--- /dev/null
+++ b/src/core/LmmsSemaphore.cpp
@@ -0,0 +1,143 @@
+/*
+ * Semaphore.cpp - Semaphore implementation
+ *
+ * Copyright (c) 2022-2022 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
+ *
+ * This file is part of LMMS - https://lmms.io
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+
+/*
+ * This code has been copied and adapted from https://github.com/drobilla/jalv
+ * File src/zix/sem.h
+ */
+
+#include "LmmsSemaphore.h"
+
+#if defined(LMMS_BUILD_WIN32)
+#    include <limits.h>
+#else
+#    include <errno.h>
+#endif
+
+#include <system_error>
+
+namespace lmms {
+
+#ifdef LMMS_BUILD_APPLE
+Semaphore::Semaphore(unsigned val)
+{
+	kern_return_t rval = semaphore_create(mach_task_self(), &m_sem, SYNC_POLICY_FIFO, val);
+	if(rval != 0) {
+		throw std::system_error(rval, std::system_category(), "Could not create semaphore");
+	}
+}
+
+Semaphore::~Semaphore()
+{
+	semaphore_destroy(mach_task_self(), m_sem);
+}
+
+void Semaphore::post()
+{
+	semaphore_signal(m_sem);
+}
+
+void Semaphore::wait()
+{
+	kern_return_t rval = semaphore_wait(m_sem);
+	if (rval != KERN_SUCCESS) {
+		throw std::system_error(rval, std::system_category(), "Waiting for semaphore failed");
+	}
+}
+
+bool Semaphore::tryWait()
+{
+	const mach_timespec_t zero = { 0, 0 };
+	return semaphore_timedwait(m_sem, zero) == KERN_SUCCESS;
+}
+
+#elif defined(LMMS_BUILD_WIN32)
+
+Semaphore::Semaphore(unsigned initial)
+{
+	if(CreateSemaphore(nullptr, initial, LONG_MAX, nullptr) == nullptr) {
+		throw std::system_error(GetLastError(), std::system_category(), "Could not create semaphore");
+	}
+}
+
+Semaphore::~Semaphore()
+{
+	CloseHandle(m_sem);
+}
+
+void Semaphore::post()
+{
+	ReleaseSemaphore(m_sem, 1, nullptr);
+}
+
+void Semaphore::wait()
+{
+	if (WaitForSingleObject(m_sem, INFINITE) != WAIT_OBJECT_0) {
+		throw std::system_error(GetLastError(), std::system_category(), "Waiting for semaphore failed");
+	}
+}
+
+bool Semaphore::tryWait()
+{
+	return WaitForSingleObject(m_sem, 0) == WAIT_OBJECT_0;
+}
+
+#else  /* !defined(LMMS_BUILD_APPLE) && !defined(LMMS_BUILD_WIN32) */
+
+Semaphore::Semaphore(unsigned initial)
+{
+	if(sem_init(&m_sem, 0, initial) != 0) {
+		throw std::system_error(errno, std::generic_category(), "Could not create semaphore");
+	}
+}
+
+Semaphore::~Semaphore()
+{
+	sem_destroy(&m_sem);
+}
+
+void Semaphore::post()
+{
+	sem_post(&m_sem);
+}
+
+void Semaphore::wait()
+{
+	while (sem_wait(&m_sem) != 0) {
+		if (errno != EINTR) {
+			throw std::system_error(errno, std::generic_category(), "Waiting for semaphore failed");
+		}
+		/* Otherwise, interrupted, so try again. */
+	}
+}
+
+bool Semaphore::tryWait()
+{
+	return (sem_trywait(&m_sem) == 0);
+}
+
+#endif
+
+} // namespace lmms
+
diff --git a/src/core/lv2/Lv2Manager.cpp b/src/core/lv2/Lv2Manager.cpp
index 489e613b7..6a1b2a8af 100644
--- a/src/core/lv2/Lv2Manager.cpp
+++ b/src/core/lv2/Lv2Manager.cpp
@@ -31,6 +31,7 @@
 #include <lilv/lilv.h>
 #include <lv2/lv2plug.in/ns/ext/buf-size/buf-size.h>
 #include <lv2/lv2plug.in/ns/ext/options/options.h>
+#include <lv2/lv2plug.in/ns/ext/worker/worker.h>
 #include <QDebug>
 #include <QElapsedTimer>
 
@@ -172,6 +173,7 @@ Lv2Manager::Lv2Manager() :
 	m_supportedFeatureURIs.insert(LV2_URID__map);
 	m_supportedFeatureURIs.insert(LV2_URID__unmap);
 	m_supportedFeatureURIs.insert(LV2_OPTIONS__options);
+	m_supportedFeatureURIs.insert(LV2_WORKER__schedule);
 	// min/max is always passed in the options
 	m_supportedFeatureURIs.insert(LV2_BUF_SIZE__boundedBlockLength);
 	// block length is only changed initially in AudioEngine CTOR
diff --git a/src/core/lv2/Lv2Proc.cpp b/src/core/lv2/Lv2Proc.cpp
index 242f3d92b..11290013e 100644
--- a/src/core/lv2/Lv2Proc.cpp
+++ b/src/core/lv2/Lv2Proc.cpp
@@ -1,7 +1,7 @@
 /*
  * Lv2Proc.cpp - Lv2 processor class
  *
- * Copyright (c) 2019-2020 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
+ * Copyright (c) 2019-2022 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
  *
  * This file is part of LMMS - https://lmms.io
  *
@@ -30,6 +30,7 @@
 #include <lv2/lv2plug.in/ns/ext/midi/midi.h>
 #include <lv2/lv2plug.in/ns/ext/atom/atom.h>
 #include <lv2/lv2plug.in/ns/ext/resize-port/resize-port.h>
+#include <lv2/lv2plug.in/ns/ext/worker/worker.h>
 #include <QDebug>
 #include <QDomDocument>
 #include <QtGlobal>
@@ -170,6 +171,7 @@ Plugin::Type Lv2Proc::check(const LilvPlugin *plugin,
 Lv2Proc::Lv2Proc(const LilvPlugin *plugin, Model* parent) :
 	LinkedModelGroup(parent),
 	m_plugin(plugin),
+	m_workLock(1),
 	m_midiInputBuf(m_maxMidiInputEvents),
 	m_midiInputReader(m_midiInputBuf)
 {
@@ -360,7 +362,19 @@ void Lv2Proc::copyBuffersToCore(sampleFrame* buf,
 
 void Lv2Proc::run(fpp_t frames)
 {
+	if (m_worker)
+	{
+		// Process any worker replies
+		m_worker->emitResponses();
+	}
+
 	lilv_instance_run(m_instance, static_cast<uint32_t>(frames));
+
+	if (m_worker)
+	{
+		// Notify the plugin the run() cycle is finished
+		m_worker->notifyPluginThatRunFinished();
+	}
 }
 
 
@@ -428,6 +442,9 @@ void Lv2Proc::initPlugin()
 
 	if (m_instance)
 	{
+		if(m_worker) {
+			m_worker->setHandle(lilv_instance_get_handle(m_instance));
+		}
 		for (std::size_t portNum = 0; portNum < m_ports.size(); ++portNum)
 			connectPort(portNum);
 		lilv_instance_activate(m_instance);
@@ -504,8 +521,20 @@ void Lv2Proc::initMOptions()
 
 void Lv2Proc::initPluginSpecificFeatures()
 {
+	// options
 	initMOptions();
 	m_features[LV2_OPTIONS__options] = const_cast<LV2_Options_Option*>(m_options.feature());
+
+	// worker (if plugin has worker extension)
+	Lv2Manager* mgr = Engine::getLv2Manager();
+	if (lilv_plugin_has_extension_data(m_plugin, mgr->uri(LV2_WORKER__interface).get())) {
+		const auto iface = static_cast<const LV2_Worker_Interface*>(
+			lilv_instance_get_extension_data(m_instance, LV2_WORKER__interface));
+		bool threaded = !Engine::audioEngine()->renderOnly();
+		m_worker.emplace(iface, &m_workLock, threaded);
+		m_features[LV2_WORKER__schedule] = m_worker->feature();
+		// Note: m_worker::setHandle will still need to be called later
+	}
 }
 
 
diff --git a/src/core/lv2/Lv2Worker.cpp b/src/core/lv2/Lv2Worker.cpp
new file mode 100644
index 000000000..5af955ff7
--- /dev/null
+++ b/src/core/lv2/Lv2Worker.cpp
@@ -0,0 +1,203 @@
+/*
+ * Lv2Worker.cpp - Lv2Worker implementation
+ *
+ * Copyright (c) 2022-2022 Johannes Lorenz <jlsf2013$users.sourceforge.net, $=@>
+ *
+ * This file is part of LMMS - https://lmms.io
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program (see COPYING); if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ */
+
+#include "Lv2Worker.h"
+
+#include <cassert>
+#include <QDebug>
+
+#ifdef LMMS_HAVE_LV2
+
+#include "Engine.h"
+
+
+namespace lmms
+{
+
+
+// static wrappers
+
+static LV2_Worker_Status
+staticWorkerRespond(LV2_Worker_Respond_Handle handle,
+	uint32_t size, const void* data)
+{
+	Lv2Worker* worker = static_cast<Lv2Worker*>(handle);
+	return worker->respond(size, data);
+}
+
+
+
+
+std::size_t Lv2Worker::bufferSize() const
+{
+	// ardour uses this fixed size for ALSA:
+	return 8192 * 4;
+	// for jack, they use 4 * jack_port_type_get_buffer_size (..., JACK_DEFAULT_MIDI_TYPE)
+	// (possible extension for AudioDevice)
+}
+
+
+
+
+Lv2Worker::Lv2Worker(const LV2_Worker_Interface* iface,
+	Semaphore* common_work_lock,
+	bool threaded) :
+	m_iface(iface),
+	m_threaded(threaded),
+	m_response(bufferSize()),
+	m_requests(bufferSize()),
+	m_responses(bufferSize()),
+	m_requestsReader(m_requests),
+	m_responsesReader(m_responses),
+	m_sem(0),
+	m_workLock(common_work_lock)
+{
+	assert(iface);
+	m_scheduleFeature.handle = static_cast<LV2_Worker_Schedule_Handle>(this);
+	m_scheduleFeature.schedule_work = [](LV2_Worker_Schedule_Handle handle,
+		uint32_t size, const void* data) -> LV2_Worker_Status
+		{
+			Lv2Worker* worker = static_cast<Lv2Worker*>(handle);
+			return worker->scheduleWork(size, data);
+		};
+
+	if (threaded) { m_thread = std::thread(&Lv2Worker::workerFunc, this); }
+
+	m_requests.mlock();
+	m_responses.mlock();
+}
+
+
+
+
+Lv2Worker::~Lv2Worker()
+{
+	m_exit = true;
+	if(m_threaded) {
+		m_sem.post();
+		m_thread.join();
+	}
+}
+
+
+
+
+// Let the worker send responses to the audio thread
+LV2_Worker_Status Lv2Worker::respond(uint32_t size, const void* data)
+{
+	if(m_threaded)
+	{
+		if(m_responses.free() < sizeof(size) + size)
+		{
+			return LV2_WORKER_ERR_NO_SPACE;
+		}
+		else
+		{
+			m_responses.write((const char*)&size, sizeof(size));
+			if(size && data) { m_responses.write((const char*)data, size); }
+		}
+	}
+	else
+	{
+		m_iface->work_response(m_handle, size, data);
+	}
+	return LV2_WORKER_SUCCESS;
+}
+
+
+
+
+// Let the worker receive work from the audio thread and "work" on it
+void Lv2Worker::workerFunc()
+{
+	std::vector<char> buf;
+	uint32_t size;
+	while (true) {
+		m_sem.wait();
+		if (m_exit) { break; }
+		const std::size_t readSpace = m_requestsReader.read_space();
+		if (readSpace <= sizeof(size)) { continue; } // (should not happen)
+
+		m_requestsReader.read(sizeof(size)).copy((char*)&size, sizeof(size));
+		assert(size <= readSpace - sizeof(size));
+		if(size > buf.size()) { buf.resize(size); }
+		if(size) { m_requestsReader.read(size).copy(buf.data(), size); }
+
+		m_workLock->wait();
+		m_iface->work(m_handle, staticWorkerRespond, this, size, buf.data());
+		m_workLock->post();
+	}
+}
+
+
+
+
+// Let the audio thread schedule work for the worker
+LV2_Worker_Status Lv2Worker::scheduleWork(uint32_t size, const void *data)
+{
+	if (m_threaded)
+	{
+		if(m_requests.free() < sizeof(size) + size)
+		{
+			return LV2_WORKER_ERR_NO_SPACE;
+		}
+		else
+		{
+			// Schedule a request to be executed by the worker thread
+			m_requests.write((const char*)&size, sizeof(size));
+			if(size && data) { m_requests.write((const char*)data, size); }
+			m_sem.post();
+		}
+	}
+	else
+	{
+		// Execute work immediately in this thread
+		m_workLock->wait();
+		m_iface->work(m_handle, staticWorkerRespond, this, size, data);
+		m_workLock->post();
+	}
+
+	return LV2_WORKER_SUCCESS;
+}
+
+
+
+
+// Let the audio thread read incoming worker responses, and process it
+void Lv2Worker::emitResponses()
+{
+	std::size_t read_space = m_responsesReader.read_space();
+	uint32_t size;
+	while (read_space > sizeof(size)) {
+		m_responsesReader.read(sizeof(size)).copy((char*)&size, sizeof(size));
+		if(size) { m_responsesReader.read(size).copy(m_response.data(), size); }
+		m_iface->work_response(m_handle, size, m_response.data());
+		read_space -= sizeof(size) + size;
+	}
+}
+
+
+} // namespace lmms
+
+#endif // LMMS_HAVE_LV2

From f664698c80f8bf55992071a409cff4b24da84739 Mon Sep 17 00:00:00 2001
From: Bimal Poudel <anytizer@users.noreply.github.com>
Date: Sun, 24 Sep 2023 16:58:56 -0600
Subject: [PATCH 10/11] Update copyright year (#6888)

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4163ca5cc..0b6d3b4ff 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,7 +35,7 @@ INCLUDE(GenerateExportHeader)
 
 STRING(TOUPPER          "${CMAKE_PROJECT_NAME}" PROJECT_NAME_UCASE)
 
-SET(PROJECT_YEAR 2020)
+SET(PROJECT_YEAR 2023)
 
 SET(PROJECT_AUTHOR      "LMMS Developers")
 SET(PROJECT_URL         "https://lmms.io")

From 23ef89b4a15b6c7cccd7eae89f5fd512a460688a Mon Sep 17 00:00:00 2001
From: Bimal Poudel <anytizer@users.noreply.github.com>
Date: Sun, 24 Sep 2023 19:03:29 -0600
Subject: [PATCH 11/11] Update SampleBuffer.cpp (#6892)

File information corrected.
---
 src/core/SampleBuffer.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/SampleBuffer.cpp b/src/core/SampleBuffer.cpp
index 5e2d09c57..c96111bba 100644
--- a/src/core/SampleBuffer.cpp
+++ b/src/core/SampleBuffer.cpp
@@ -1389,7 +1389,7 @@ SampleBuffer * SampleBuffer::resample(const sample_rate_t srcSR, const sample_ra
 	}
 	else
 	{
-		printf("Error: src_new() failed in sample_buffer.cpp!\n");
+		printf("Error: src_new() failed in SampleBuffer.cpp!\n");
 	}
 	dstSB->update();
 	return dstSB;
@@ -1612,7 +1612,7 @@ SampleBuffer::handleState::handleState(bool varyingPitch, int interpolationMode)
 
 	if ((m_resamplingData = src_new(interpolationMode, DEFAULT_CHANNELS, &error)) == nullptr)
 	{
-		qDebug("Error: src_new() failed in sample_buffer.cpp!\n");
+		qDebug("Error: src_new() failed in SampleBuffer.cpp!\n");
 	}
 }