diff --git a/include/Engine.h b/include/Engine.h
index bd3bad27787..dd53386ea00 100644
--- a/include/Engine.h
+++ b/include/Engine.h
@@ -123,6 +123,9 @@ class LMMS_EXPORT LmmsCore : public QObject
 
 
 private:
+	static class AutomatableModel*
+	getAutomatableOscModel(const QString& val, const QUrl& url);
+
 	// small helper function which sets the pointer to NULL before actually deleting
 	// the object it refers to
 	template<class T>
diff --git a/include/SpaOscModel.h b/include/SpaOscModel.h
index 1edbeca9d22..29f6c8585ad 100644
--- a/include/SpaOscModel.h
+++ b/include/SpaOscModel.h
@@ -30,14 +30,14 @@
 template <class Base> class SpaOscModel : public Base
 {
 protected:
-	class SpaInstrument *inst_ref;
-	QByteArray dest;
+	class SpaInstrument *m_instRef;
+	QByteArray m_dest;
 
 	using Base::Base;
-	void init(class SpaInstrument *_inst_ref, const QString _dest)
+	void init(class SpaInstrument *instRef, const QString dest)
 	{
-		inst_ref = _inst_ref;
-		dest = _dest.toUtf8();
+		m_instRef = instRef;
+		m_dest = dest.toUtf8();
 	}
 };
 
@@ -49,7 +49,7 @@ private slots:
 
 public:
 	BoolOscModel(
-		class SpaInstrument *inst_ref, const QString dest, bool val);
+		class SpaInstrument *instRef, const QString dest, bool val);
 };
 
 class IntOscModel : public SpaOscModel<IntModel>
@@ -59,7 +59,7 @@ private slots:
 	void sendOsc();
 
 public:
-	IntOscModel(class SpaInstrument *inst_ref, const QString dest, int min,
+	IntOscModel(class SpaInstrument *instRef, const QString dest, int min,
 		int max, int val);
 };
 
@@ -70,14 +70,14 @@ private slots:
 	void sendOsc();
 
 public:
-	FloatOscModel(class SpaInstrument *inst_ref, const QString dest,
+	FloatOscModel(class SpaInstrument *instRef, const QString dest,
 		float min, float max, float val);
 };
 
 struct SpaOscModelFactory
 {
-	AutomatableModel *res;
-	SpaOscModelFactory(class SpaInstrument *inst_ref, const QString &dest);
+	AutomatableModel *m_res;
+	SpaOscModelFactory(class SpaInstrument *instRef, const QString &dest);
 };
 
 #endif // SPAOSCMODEL_H
diff --git a/include/StringPairDrag.h b/include/StringPairDrag.h
index 40711b99900..aaad9634f14 100644
--- a/include/StringPairDrag.h
+++ b/include/StringPairDrag.h
@@ -52,12 +52,12 @@ class LMMS_EXPORT StringPairDrag : public QDrag
 
 	static const char * mimeType()
 	{
-		return( "application/x-lmms-stringpair" );
+		return "application/x-lmms-stringpair";
 	}
 
 	static const char * mimeTypeOsc()
 	{
-		return( "application/x-osc-stringpair" );
+		return "application/x-osc-stringpair";
 	}
 
 } ;
diff --git a/src/core/Engine.cpp b/src/core/Engine.cpp
index 5301695e716..86c5a081e5e 100644
--- a/src/core/Engine.cpp
+++ b/src/core/Engine.cpp
@@ -120,52 +120,69 @@ void LmmsCore::updateFramesPerTick()
 
 
 
-AutomatableModel *LmmsCore::getAutomatableModel(const QString& val, bool hasOsc)
+AutomatableModel *LmmsCore::getAutomatableOscModel(const QString& val,
+	const QUrl& url)
 {
 	AutomatableModel* mod = nullptr;
 
-	if(hasOsc)
+	// qDebug() << val;
+	const QMap<int, class SpaInstrument*>& insMap = getSpaInstruments();
+	auto itr = insMap.find(url.port());
+	if(itr == insMap.end())
 	{
-		QUrl url(val);
-		if(!url.isValid())
+		puts(	"DnD from an instrument which is not "
+			"in LMMS... ignoring");
+		// TODO: MessageBox?
+	}
+	else
+	{
+		QMap<QString, AutomatableModel*>& connectedModels
+			= itr.value()->m_connectedModels;
+		auto itr2 = connectedModels.find(url.path());
+		if(itr2 != connectedModels.end())
 		{
-			printf("Could not find a port in %s => "
-			       "can not make connection\n", val.toUtf8().data());
+			mod = *itr2;
 		}
 		else
 		{
-			// qDebug() << val;
-			const QMap<int, class SpaInstrument*>& insmap = Engine::getSpaInstruments();
-			auto itr = insmap.find(url.port());
-			if(itr == insmap.end())
+			AutomatableModel* spaMod = SpaOscModelFactory(itr.value(),
+							url.path()).m_res;
+			if(spaMod)
 			{
-				puts("DnD from an instrument which is not in LMMS... ignoring");
-				// TODO: MessageBox?
+				itr.value()->m_connectedModels.insert(
+					url.path(), spaMod);
+				mod = spaMod;
 			}
-			else
-			{
-				QMap<QString, AutomatableModel*>& connectedModels
-					= itr.value()->connectedModels;
-				auto itr2 = connectedModels.find(url.path());
-				if(itr2 != connectedModels.end())
-				{
-					return *itr2;
-				}
-				else
-				{
-					AutomatableModel* spamod = SpaOscModelFactory(itr.value(), url.path()).res;
-					if(spamod)
-					{
-						itr.value()->connectedModels.insert(url.path(), spamod);
-						mod = spamod;
-					}
-					else {
-						qDebug() << "LMMS: Could not create model from OSC port (received \"" << val << "\")";
-					}
-				}
+			else {
+				qDebug() <<	"LMMS: Could not create model from "
+						"OSC port (received \"" << val << "\")";
 			}
 		}
 	}
+
+	return mod;
+}
+
+
+
+
+AutomatableModel *LmmsCore::getAutomatableModel(const QString& val, bool hasOsc)
+{
+	AutomatableModel* mod = nullptr;
+	if(hasOsc)
+	{
+		QUrl url(val);
+		if(!url.isValid())
+		{
+			printf( "Could not find a port in %s => "
+				"can not make connection\n",
+				val.toUtf8().data());
+		}
+		else
+		{
+			mod = getAutomatableOscModel(val, url);
+		}
+	}
 	else
 	{
 		mod = dynamic_cast<AutomatableModel *>(
diff --git a/src/core/Plugin.cpp b/src/core/Plugin.cpp
index fb2af500051..be02f707455 100644
--- a/src/core/Plugin.cpp
+++ b/src/core/Plugin.cpp
@@ -111,24 +111,24 @@ Plugin * Plugin::instantiate( const QString& pluginName, Model * parent,
 	}
 
 	Plugin* inst;
-	spa::descriptor_loader_t spa_loader;
+	spa::descriptor_loader_t spaLoader;
 	InstantiationHook instantiationHook;
-	if( (instantiationHook = ( InstantiationHook ) pi.library->resolve( "lmms_plugin_main" )) )
+	if ((instantiationHook = ( InstantiationHook ) pi.library->resolve( "lmms_plugin_main" )))
 	{
 		inst = instantiationHook( parent, data );
 	}
-	else if( (spa_loader = (spa::descriptor_loader_t) pi.library->resolve( spa::descriptor_name )) )
+	else if ((spaLoader = (spa::descriptor_loader_t) pi.library->resolve( spa::descriptor_name )))
 	{
 		// instantiate a SPA Instrument
 		// it will load and contain the SPA plugin
 		// and transfer LMMS events to SPA function calls
-		SpaInstrument* spa_inst = new SpaInstrument(
+		SpaInstrument* spaInst = new SpaInstrument(
 			static_cast<InstrumentTrack *>( data ),
 			pi.file.absoluteFilePath().toUtf8().data(),
 			pi.descriptor);
-		unsigned port = spa_inst->plugin->net_port();
-		Engine::getSpaInstruments().insert(port, spa_inst);
-		inst = spa_inst;
+		unsigned port = spaInst->m_plugin->net_port();
+		Engine::getSpaInstruments().insert(port, spaInst);
+		inst = spaInst;
 	}
 	else
 	{
diff --git a/src/core/PluginFactory.cpp b/src/core/PluginFactory.cpp
index 0740618d6f2..3f692fb0d65 100644
--- a/src/core/PluginFactory.cpp
+++ b/src/core/PluginFactory.cpp
@@ -184,14 +184,14 @@ void PluginFactory::discoverPlugins()
 			spa::descriptor* descriptor = (*spaDescriptorLoader)(0 /* = plugin number, TODO */);
 			if(descriptor)
 			{
-				std::string unique_name =
+				std::string uniqueName =
 					spa::unique_name(*descriptor);
-				m_garbage.push_back(unique_name);
+				m_garbage.push_back(uniqueName);
 
 				const char** xpm = descriptor->xpm_load();
 				assert(xpm);
 				QString xpmKey = "spa-plugin:" +
-					QString::fromStdString(unique_name);
+					QString::fromStdString(uniqueName);
 
 				// spa (simple plugin API) plugin
 				pluginDescriptor = new Plugin::Descriptor {
@@ -218,7 +218,7 @@ void PluginFactory::discoverPlugins()
 			info.descriptor = pluginDescriptor;
 			pluginInfos << info;
 
-			if(info.descriptor->supportedFileTypes)
+			if (info.descriptor->supportedFileTypes)
 			for (const QString& ext : QString(info.descriptor->supportedFileTypes).split(','))
 			{
 				m_pluginByExt.insert(ext, info);
diff --git a/src/core/SpaOscModel.cpp b/src/core/SpaOscModel.cpp
index ead5dff70f3..259cb5269fa 100644
--- a/src/core/SpaOscModel.cpp
+++ b/src/core/SpaOscModel.cpp
@@ -31,72 +31,77 @@
 
 struct SpaOscModelFactoryVisitor : public spa::audio::visitor
 {
-	class SpaInstrument *inst_ref;
-	const QString *dest;
-	AutomatableModel *res = nullptr;
+	class SpaInstrument *m_instRef;
+	const QString *m_dest;
+	AutomatableModel *m_res = nullptr;
 
 	template <class ModelType, class T> void make(T min, T max, T val)
 	{
-		res = new ModelType(inst_ref, *dest, min, max, val);
+		m_res = new ModelType(m_instRef, *m_dest, min, max, val);
 	}
 
-	template <class T> using c_in = spa::audio::control_in<T>;
-	virtual void visit(c_in<float> &in)
+	template <class T> using CtlIn = spa::audio::control_in<T>;
+	virtual void visit(CtlIn<float> &in)
 	{
 		make<FloatOscModel>(in.min, in.max, in.def);
 	}
-	virtual void visit(c_in<double> &in)
+	virtual void visit(CtlIn<double> &in)
 	{
 		make<FloatOscModel>(in.min, in.max, in.def);
 	}
-	virtual void visit(c_in<int> &in)
+	virtual void visit(CtlIn<int> &in)
 	{
 		make<IntOscModel>(in.min, in.max, in.def);
 	}
-	virtual void visit(c_in<bool> &in)
+	virtual void visit(CtlIn<bool> &in)
 	{
-		res = new BoolOscModel(inst_ref, *dest, in.def);
+		m_res = new BoolOscModel(m_instRef, *m_dest, in.def);
 	}
 };
 
 SpaOscModelFactory::SpaOscModelFactory(
-	SpaInstrument *inst_ref, const QString &dest)
+	SpaInstrument *instRef, const QString &dest)
 {
 	SpaOscModelFactoryVisitor vis;
-	vis.inst_ref = inst_ref;
-	vis.dest = &dest;
-	spa::port_ref_base &base = inst_ref->plugin->port(dest.toUtf8().data());
+	vis.m_instRef = instRef;
+	vis.m_dest = &dest;
+	spa::port_ref_base &base = instRef->m_plugin->port(dest.toUtf8().data());
 	base.accept(vis);
-	res = vis.res;
+	m_res = vis.m_res;
 }
 
 void BoolOscModel::sendOsc()
 {
-	inst_ref->writeOsc(dest.data(), value() ? "T" : "F");
+	m_instRef->writeOsc(m_dest.data(), value() ? "T" : "F");
+}
+void IntOscModel::sendOsc()
+{
+	m_instRef->writeOsc(m_dest.data(), "i", value());
+}
+void FloatOscModel::sendOsc()
+{
+	m_instRef->writeOsc(m_dest.data(), "f", value());
 }
-void IntOscModel::sendOsc() { inst_ref->writeOsc(dest.data(), "i", value()); }
-void FloatOscModel::sendOsc() { inst_ref->writeOsc(dest.data(), "f", value()); }
 
-BoolOscModel::BoolOscModel(
-	SpaInstrument *inst_ref, const QString dest, bool val) :
+BoolOscModel::BoolOscModel(SpaInstrument *instRef, const QString dest, bool val) :
 	SpaOscModel<BoolModel>(val, nullptr, dest, false)
 {
 	qDebug() << "LMMS: receiving bool model: val = " << val;
-	init(inst_ref, dest);
+	init(instRef, dest);
 	QObject::connect(this, SIGNAL(dataChanged()), this, SLOT(sendOsc()));
 }
 
-IntOscModel::IntOscModel(SpaInstrument *inst_ref, const QString dest, int min,
+IntOscModel::IntOscModel(SpaInstrument *instRef, const QString dest, int min,
 	int max, int val) :
 	SpaOscModel<IntModel>(val, min, max, nullptr, dest, false)
 {
 	qDebug() << "LMMS: receiving int model: (val, min, max) = (" << val
 		 << ", " << min << ", " << max << ")";
-	init(inst_ref, dest);
+	init(instRef, dest);
 	QObject::connect(this, SIGNAL(dataChanged()), this, SLOT(sendOsc()));
 }
 
-FloatOscModel::FloatOscModel(SpaInstrument *inst_ref, const QString dest,
+FloatOscModel::FloatOscModel(SpaInstrument *instRef, const QString dest,
 	float min, float max, float val) :
 	SpaOscModel<FloatModel>(val, min, max, 0.1f, nullptr, dest, false)
 /* TODO: get step from plugin (we currently need a plugin where this
@@ -104,6 +109,6 @@ FloatOscModel::FloatOscModel(SpaInstrument *inst_ref, const QString dest,
 {
 	qDebug() << "LMMS: receiving float model: (val, min, max) = (" << val
 		 << ", " << min << ", " << max << ")";
-	init(inst_ref, dest);
+	init(instRef, dest);
 	QObject::connect(this, SIGNAL(dataChanged()), this, SLOT(sendOsc()));
 }
diff --git a/src/core/spa/SpaInstrument.cpp b/src/core/spa/SpaInstrument.cpp
index 1106fa55444..0c5688d0c9b 100644
--- a/src/core/spa/SpaInstrument.cpp
+++ b/src/core/spa/SpaInstrument.cpp
@@ -48,22 +48,22 @@
 #include "embed.h"
 #include "gui_templates.h"
 
-SpaInstrument::SpaInstrument(InstrumentTrack *_instrumentTrack,
-	const char *libraryName, const Descriptor *plugin_descriptor) :
-	Instrument(_instrumentTrack, plugin_descriptor),
-	ports(Engine::mixer()->framesPerPeriod()), m_hasGUI(false),
-	libraryName(libraryName)
+SpaInstrument::SpaInstrument(InstrumentTrack *instrumentTrackArg,
+	const char *libraryName, const Descriptor *pluginDescriptor) :
+	Instrument(instrumentTrackArg, pluginDescriptor),
+	m_ports(Engine::mixer()->framesPerPeriod()), m_hasGUI(false),
+	m_libraryName(libraryName)
 {
 	for (int i = 0; i < NumKeys; ++i)
 		m_runningNotes[i] = 0;
 
 	initPlugin();
 
-	if (plugin)
+	if (m_plugin)
 	{
 		// now we need a play-handle which cares for calling play()
 		InstrumentPlayHandle *iph =
-			new InstrumentPlayHandle(this, _instrumentTrack);
+			new InstrumentPlayHandle(this, instrumentTrackArg);
 		Engine::mixer()->addPlayHandle(iph);
 
 		connect(Engine::mixer(), SIGNAL(sampleRateChanged()), this,
@@ -84,22 +84,22 @@ SpaInstrument::~SpaInstrument()
 
 // not yet working
 #ifndef SPA_INSTRUMENT_USE_MIDI
-void SpaInstrument::playNote(NotePlayHandle *_n, sampleFrame *)
+void SpaInstrument::playNote(NotePlayHandle *nph, sampleFrame *)
 {
 	// no idea what that means
-	if (_n->isMasterNote() || (_n->hasParent() && _n->isReleased()))
+	if (nph->isMasterNote() || (nph->hasParent() && nph->isReleased()))
 	{
 		return;
 	}
 
-	const f_cnt_t tfp = _n->totalFramesPlayed();
+	const f_cnt_t tfp = nph->totalFramesPlayed();
 
 	const float LOG440 = 2.643452676f;
 
 	int midiNote = (int)floor(
-		12.0 * (log2(_n->unpitchedFrequency()) - LOG440) - 4.0);
+		12.0 * (log2(nph->unpitchedFrequency()) - LOG440) - 4.0);
 
-	qDebug() << "midiNote: " << midiNote << ", r? " << _n->isReleased();
+	qDebug() << "midiNote: " << midiNote << ", r? " << nph->isReleased();
 	// out of range?
 	if (midiNote <= 0 || midiNote >= 128)
 	{
@@ -112,23 +112,23 @@ void SpaInstrument::playNote(NotePlayHandle *_n, sampleFrame *)
 			instrumentTrack()->midiPort()->baseVelocity();
 		plugin->send_osc("/noteOn", "iii", 0, midiNote, baseVelocity);
 	}
-	else if (_n->isReleased() &&
-		!_n->instrumentTrack()
+	else if (nph->isReleased() &&
+		!nph->instrumentTrack()
 			 ->isSustainPedalPressed()) // note is released during
 						    // this period
 	{
 		plugin->send_osc("/noteOff", "ii", 0, midiNote);
 	}
-	else if (_n->framesLeft() <= 0)
+	else if (nph->framesLeft() <= 0)
 	{
 		plugin->send_osc("/noteOff", "ii", 0, midiNote);
 	}
 }
 #endif
 
-void SpaInstrument::saveSettings(QDomDocument &_doc, QDomElement &_this)
+void SpaInstrument::saveSettings(QDomDocument &doc, QDomElement &that)
 {
-	if (!descriptor->save_has())
+	if (!m_descriptor->save_has())
 		return;
 
 	QTemporaryFile tf;
@@ -137,44 +137,44 @@ void SpaInstrument::saveSettings(QDomDocument &_doc, QDomElement &_this)
 		const std::string fn =
 			QSTR_TO_STDSTR(QDir::toNativeSeparators(tf.fileName()));
 		m_pluginMutex.lock();
-		plugin->save(fn.c_str(), ++save_ticket);
+		m_plugin->save(fn.c_str(), ++m_saveTicket);
 		m_pluginMutex.unlock();
 
-		while (!plugin->save_check(fn.c_str(), save_ticket))
+		while (!m_plugin->save_check(fn.c_str(), m_saveTicket))
 			QThread::msleep(1);
 
-		QDomCDATASection cdata = _doc.createCDATASection(
+		QDomCDATASection cdata = doc.createCDATASection(
 			QString::fromUtf8(tf.readAll()));
-		_this.appendChild(cdata);
+		that.appendChild(cdata);
 	}
 	tf.remove();
 
-	if (connectedModels.size())
+	if (m_connectedModels.size())
 	{
-		QDomElement newNode = _doc.createElement("connected-models");
+		QDomElement newNode = doc.createElement("connected-models");
 		QMap<QString, AutomatableModel *>::const_iterator i =
-			connectedModels.constBegin();
-		while (i != connectedModels.constEnd())
+			m_connectedModels.constBegin();
+		while (i != m_connectedModels.constEnd())
 		{
-			i.value()->saveSettings(_doc, newNode, i.key());
+			i.value()->saveSettings(doc, newNode, i.key());
 			++i;
 		}
 
-		_this.appendChild(newNode);
+		that.appendChild(newNode);
 	}
 }
 
-void SpaInstrument::loadSettings(const QDomElement &_this)
+void SpaInstrument::loadSettings(const QDomElement &that)
 {
-	if (!descriptor->load_has())
+	if (!m_descriptor->load_has())
 		return;
 
-	if (!_this.hasChildNodes())
+	if (!that.hasChildNodes())
 	{
 		return;
 	}
 
-	for (QDomNode node = _this.firstChild(); !node.isNull();
+	for (QDomNode node = that.firstChild(); !node.isNull();
 		node = node.nextSibling())
 	{
 		QDomCDATASection cdata = node.toCDATASection();
@@ -206,66 +206,66 @@ void SpaInstrument::loadSettings(const QDomElement &_this)
 							"nodename");
 					using fact = SpaOscModelFactory;
 					AutomatableModel *m =
-						fact(this, name).res;
+						fact(this, name).m_res;
 					m->loadSettings(elem, name);
-					connectedModels[name] = m;
+					m_connectedModels[name] = m;
 				}
 		}
 	}
 }
 
-void SpaInstrument::loadFileInternal(const QString &_file)
+void SpaInstrument::loadFileInternal(const QString &file)
 {
-	const QByteArray fn = _file.toUtf8();
+	const QByteArray fn = file.toUtf8();
 	m_pluginMutex.lock();
-	plugin->load(fn.data(), ++save_ticket);
-	while (!plugin->load_check(fn.data(), save_ticket))
+	m_plugin->load(fn.data(), ++m_saveTicket);
+	while (!m_plugin->load_check(fn.data(), m_saveTicket))
 		QThread::msleep(1);
 	m_pluginMutex.unlock();
 }
 
-void SpaInstrument::loadFile(const QString &_file)
+void SpaInstrument::loadFile(const QString &file)
 {
-	loadFileInternal(_file);
-	instrumentTrack()->setName(QFileInfo(_file).baseName().replace(
+	loadFileInternal(file);
+	instrumentTrack()->setName(QFileInfo(file).baseName().replace(
 		QRegExp("^[0-9]{4}-"), QString()));
 	emit settingsChanged();
 }
 
 QString SpaInstrument::nodeName() const { return Plugin::descriptor()->name; }
 
-void SpaInstrument::play(sampleFrame *_buf)
+void SpaInstrument::play(sampleFrame *buf)
 {
-	if (plugin)
+	if (m_plugin)
 	{
 		m_pluginMutex.lock();
-		ports.samplecount = ports.buffersize;
-		plugin->run();
+		m_ports.samplecount = m_ports.buffersize;
+		m_plugin->run();
 		m_pluginMutex.unlock();
-		for (std::size_t f = 0; f < ports.buffersize; ++f)
+		for (std::size_t f = 0; f < m_ports.buffersize; ++f)
 		{
-			_buf[f][0] = ports.l_processed[f];
-			_buf[f][1] = ports.r_processed[f];
+			buf[f][0] = m_ports.m_lProcessed[f];
+			buf[f][1] = m_ports.m_rProcessed[f];
 		}
 	}
 	instrumentTrack()->processAudioBuffer(
-		_buf, Engine::mixer()->framesPerPeriod(), nullptr);
+		buf, Engine::mixer()->framesPerPeriod(), nullptr);
 }
 
 void SpaInstrument::reloadPlugin()
 {
 	// refresh ports that are only read on restore
-	ports.samplerate = Engine::mixer()->processingSampleRate();
-	ports.buffersize = Engine::mixer()->framesPerPeriod();
+	m_ports.samplerate = Engine::mixer()->processingSampleRate();
+	m_ports.buffersize = Engine::mixer()->framesPerPeriod();
 
-	if (descriptor->restore_has())
+	if (m_descriptor->restore_has())
 	{
 		// use the offered restore function
 		m_pluginMutex.lock();
-		plugin->restore(++restore_ticket);
+		m_plugin->restore(++m_restoreTicket);
 		m_pluginMutex.unlock();
 
-		while (!plugin->restore_check(restore_ticket))
+		while (!m_plugin->restore_check(m_restoreTicket))
 			QThread::msleep(1);
 	}
 	else
@@ -291,20 +291,20 @@ void SpaInstrument::updatePitchRange()
 
 void SpaInstrument::shutdownPlugin()
 {
-	plugin->deactivate();
+	m_plugin->deactivate();
 
-	delete plugin;
-	plugin = nullptr;
-	delete descriptor;
-	descriptor = nullptr;
+	delete m_plugin;
+	m_plugin = nullptr;
+	delete m_descriptor;
+	m_descriptor = nullptr;
 
 	m_pluginMutex.lock();
-	if (lib)
+	if (m_lib)
 	{
 #ifdef SPA_INSTRUMENT_USE_QLIBRARY
-		lib->unload();
-		delete lib;
-		lib = nullptr;
+		m_lib->unload();
+		delete m_lib;
+		m_lib = nullptr;
 #else
 		dlclose(lib);
 		lib = nullptr;
@@ -313,35 +313,35 @@ void SpaInstrument::shutdownPlugin()
 	m_pluginMutex.unlock();
 }
 
-struct lmms_visitor final : public virtual spa::audio::visitor
+struct lmmsVisitor final : public virtual spa::audio::visitor
 {
-	SpaInstrument::lmms_ports *ports;
+	SpaInstrument::lmmsPorts *ports;
 
 	void visit(spa::audio::in &p) override
 	{
 		qDebug() << "in, c: " << +p.channel;
 		p.set_ref((p.channel == spa::audio::stereo::left)
-				? ports->l_unprocessed.data()
-				: ports->r_unprocessed.data());
+				? ports->m_lUnprocessed.data()
+				: ports->m_rUnprocessed.data());
 	}
 	void visit(spa::audio::out &p) override
 	{
 		qDebug() << "out, c: %d\n" << +p.channel;
 		p.set_ref((p.channel == spa::audio::stereo::left)
-				? ports->l_processed.data()
-				: ports->r_processed.data());
+				? ports->m_lProcessed.data()
+				: ports->m_rProcessed.data());
 	}
 	void visit(spa::audio::stereo::in &p) override
 	{
 		qDebug() << "in, stereo";
-		p.left = ports->l_unprocessed.data();
-		p.right = ports->r_unprocessed.data();
+		p.left = ports->m_lUnprocessed.data();
+		p.right = ports->m_rUnprocessed.data();
 	}
 	void visit(spa::audio::stereo::out &p) override
 	{
 		qDebug() << "out, stereo";
-		p.left = ports->l_processed.data();
-		p.right = ports->r_processed.data();
+		p.left = ports->m_lProcessed.data();
+		p.right = ports->m_rProcessed.data();
 	}
 	void visit(spa::audio::buffersize &p) override
 	{
@@ -361,8 +361,8 @@ struct lmms_visitor final : public virtual spa::audio::visitor
 	void visit(spa::port_ref<const float> &p) override
 	{
 		qDebug() << "unknown control port";
-		ports->unknown_controls.push_back(.0f);
-		p.set_ref(&ports->unknown_controls.back());
+		ports->m_unknownControls.push_back(.0f);
+		p.set_ref(&ports->m_unknownControls.back());
 	}
 	void visit(spa::audio::osc_ringbuffer_in &p) override
 	{
@@ -386,39 +386,40 @@ bool SpaInstrument::initPlugin()
 {
 	m_pluginMutex.lock();
 
-	spa::descriptor_loader_t spa_descriptor_loader;
+	spa::descriptor_loader_t spaDescriptorLoader;
 #ifdef SPA_INSTRUMENT_USE_QLIBRARY
-	lib = new QLibrary(libraryName);
-	lib->load();
+	m_lib = new QLibrary(m_libraryName);
+	m_lib->load();
 
-	if (!lib->isLoaded())
-		qDebug() << "Warning: Could not load library " << libraryName
-			 << ": " << lib->errorString();
+	if (!m_lib->isLoaded())
+		qDebug() << "Warning: Could not load library " << m_libraryName
+			 << ": " << m_lib->errorString();
 
-	spa_descriptor_loader =
-		(spa::descriptor_loader_t)lib->resolve(spa::descriptor_name);
+	spaDescriptorLoader =
+		(spa::descriptor_loader_t)m_lib->resolve(spa::descriptor_name);
 #else
 	lib = dlopen(libraryName.toAscii().data(), RTLD_LAZY | RTLD_LOCAL);
 	if (!lib)
 		qDebug() << "Warning: Could not load library " << libraryName
 			 << ": " << dlerror();
 
-	*(void **)(&spa_descriptor_loader) = dlsym(lib, spa::descriptor_name);
+	*(void **)(&spaDescriptorLoader) = dlsym(lib, spa::descriptor_name);
 #endif
 
-	if (!spa_descriptor_loader)
+	if (!spaDescriptorLoader)
 		qDebug() << "Warning: Could not resolve \"osc_descriptor\" in "
-			 << libraryName;
+			 << m_libraryName;
 
-	if (spa_descriptor_loader)
+	if (spaDescriptorLoader)
 	{
-		descriptor =
-			(*spa_descriptor_loader)(0 /* = plugin number, TODO */);
-		if (descriptor)
+		m_descriptor =
+			(*spaDescriptorLoader)(0 /* = plugin number, TODO */);
+		if (m_descriptor)
+		{
 			try
 			{
-				spa::assert_versions_match(*descriptor);
-				plugin = descriptor->instantiate();
+				spa::assert_versions_match(*m_descriptor);
+				m_plugin = m_descriptor->instantiate();
 				// TODO: unite error handling in the ctor
 			}
 			catch (spa::version_mismatch &mismatch)
@@ -435,23 +436,24 @@ bool SpaInstrument::initPlugin()
 					<< mismatch.least_version.major() << "."
 					<< mismatch.least_version.minor() << "."
 					<< mismatch.least_version.patch();
-				descriptor = nullptr;
+				m_descriptor = nullptr;
 			}
+		}
 	}
 	m_pluginMutex.unlock();
 
-	ports.samplerate = Engine::mixer()->processingSampleRate();
-	spa::simple_vec<spa::simple_str> port_names = descriptor->port_names();
-	for (const spa::simple_str &portname : port_names)
+	m_ports.samplerate = Engine::mixer()->processingSampleRate();
+	spa::simple_vec<spa::simple_str> portNames = m_descriptor->port_names();
+	for (const spa::simple_str &portname : portNames)
 	{
 		try
 		{
 			// qDebug() << "portname: " << portname.data();
 			spa::port_ref_base &port_ref =
-				plugin->port(portname.data());
+				m_plugin->port(portname.data());
 
-			lmms_visitor v;
-			v.ports = &ports;
+			lmmsVisitor v;
+			v.ports = &m_ports;
 			port_ref.accept(v);
 		}
 		catch (spa::port_not_found &e)
@@ -463,16 +465,16 @@ bool SpaInstrument::initPlugin()
 			else
 				qWarning() << "plugin specifies invalid port, "
 					      "but does not provide it";
-			plugin = nullptr; // TODO: free plugin, handle etc...
+			m_plugin = nullptr; // TODO: free plugin, handle etc...
 			return false;
 		}
 	}
 
 	// all initial ports are already set, we can do
 	// initialization of buffers etc.
-	plugin->init();
+	m_plugin->init();
 
-	plugin->activate();
+	m_plugin->activate();
 
 	// checks not yet implemented:
 	//	spa::host_utils::check_ports(descriptor, plugin);
@@ -532,14 +534,14 @@ bool SpaInstrument::handleMidiEvent(
 }
 #endif
 
-PluginView *SpaInstrument::instantiateView(QWidget *_parent)
+PluginView *SpaInstrument::instantiateView(QWidget *parent)
 {
-	return new SpaView(this, _parent);
+	return new SpaView(this, parent);
 }
 
 void SpaInstrument::writeOsc(const char *dest, const char *args, va_list va)
 {
-	ports.rb->write(dest, args, va);
+	m_ports.rb->write(dest, args, va);
 }
 
 void SpaInstrument::writeOsc(const char *dest, const char *args, ...)
@@ -582,10 +584,10 @@ SpaView::SpaView(Instrument *_instrument, QWidget *_parent) :
 SpaView::~SpaView()
 {
 	SpaInstrument *model = castModel<SpaInstrument>();
-	if (model && model->descriptor->ui_ext() && model->m_hasGUI)
+	if (model && model->m_descriptor->ui_ext() && model->m_hasGUI)
 	{
 		qDebug() << "shutting down UI...";
-		model->plugin->ui_ext_show(false);
+		model->m_plugin->ui_ext_show(false);
 	}
 }
 
@@ -630,11 +632,11 @@ void SpaView::modelChanged()
 void SpaView::toggleUI()
 {
 	SpaInstrument *model = castModel<SpaInstrument>();
-	if (model->descriptor->ui_ext() &&
+	if (model->m_descriptor->ui_ext() &&
 		model->m_hasGUI != m_toggleUIButton->isChecked())
 	{
 		model->m_hasGUI = m_toggleUIButton->isChecked();
-		model->plugin->ui_ext_show(model->m_hasGUI);
+		model->m_plugin->ui_ext_show(model->m_hasGUI);
 		ControllerConnection::finalizeConnections();
 	}
 }
@@ -645,9 +647,9 @@ void SpaView::reloadPlugin()
 	model->reloadPlugin();
 }
 
-SpaInstrument::lmms_ports::lmms_ports(int buffersize) :
-	buffersize(buffersize), l_unprocessed(buffersize),
-	r_unprocessed(buffersize), l_processed(buffersize),
-	r_processed(buffersize)
+SpaInstrument::lmmsPorts::lmmsPorts(int bufferSize) :
+	buffersize(bufferSize), m_lUnprocessed(bufferSize),
+	m_rUnprocessed(bufferSize), m_lProcessed(bufferSize),
+	m_rProcessed(bufferSize)
 {
 }
diff --git a/src/core/spa/SpaInstrument.h b/src/core/spa/SpaInstrument.h
index a7f101ef645..e1a209c55d2 100644
--- a/src/core/spa/SpaInstrument.h
+++ b/src/core/spa/SpaInstrument.h
@@ -57,22 +57,22 @@ class SpaInstrument : public Instrument
 {
 	Q_OBJECT
 public:
-	SpaInstrument(InstrumentTrack *_instrument_track,
-		const char *libraryName, const Descriptor *plugin_descriptor);
+	SpaInstrument(InstrumentTrack *instrumentTrackArg,
+		const char *m_libraryName, const Descriptor *pluginDescriptor);
 	virtual ~SpaInstrument();
 
 #ifdef SPA_INSTRUMENT_USE_MIDI
 	virtual bool handleMidiEvent(const MidiEvent &event,
 		const MidiTime &time = MidiTime(), f_cnt_t offset = 0);
 #else
-	virtual void playNote(NotePlayHandle *_n, sampleFrame *);
+	virtual void playNote(NotePlayHandle *nph, sampleFrame *);
 #endif
-	virtual void play(sampleFrame *_working_buffer);
+	virtual void play(sampleFrame *buf);
 
-	virtual void saveSettings(QDomDocument &_doc, QDomElement &_parent);
-	virtual void loadSettings(const QDomElement &_this);
+	virtual void saveSettings(QDomDocument &doc, QDomElement &that);
+	virtual void loadSettings(const QDomElement &that);
 
-	virtual void loadFile(const QString &_file);
+	virtual void loadFile(const QString &file);
 
 	virtual QString nodeName() const;
 
@@ -85,37 +85,37 @@ class SpaInstrument : public Instrument
 #endif
 	}
 
-	virtual PluginView *instantiateView(QWidget *_parent);
+	virtual PluginView *instantiateView(QWidget *parent);
 
-	void setLibraryName(const QString &name) { libraryName = name; }
+	void setLibraryName(const QString &name) { m_libraryName = name; }
 
 	void writeOsc(const char *dest, const char *args, va_list va);
 	void writeOsc(const char *dest, const char *args, ...);
 
-	const spa::descriptor *descriptor = nullptr;
-	spa::plugin *plugin = nullptr;
+	const spa::descriptor *m_descriptor = nullptr;
+	spa::plugin *m_plugin = nullptr;
 
-	QMap<QString, AutomatableModel *> connectedModels;
-	uint64_t load_ticket = 0, save_ticket = 0, restore_ticket = 0;
+	QMap<QString, AutomatableModel *> m_connectedModels;
+	uint64_t m_loadTicket = 0, m_saveTicket = 0, m_restoreTicket = 0;
 
 private slots:
 	void reloadPlugin();
 	void updatePitchRange();
 
 private:
-	struct lmms_ports
+	struct lmmsPorts
 	{
 		unsigned samplecount;
 		unsigned buffersize;
 		long samplerate; // TODO: use const?
-		std::vector<float> l_unprocessed, r_unprocessed, l_processed,
-			r_processed;
-		std::vector<float> unknown_controls;
-		lmms_ports(int buffersize);
+		std::vector<float> m_lUnprocessed, m_rUnprocessed, m_lProcessed,
+			m_rProcessed;
+		std::vector<float> m_unknownControls;
+		lmmsPorts(int bufferSize);
 		std::unique_ptr<spa::audio::osc_ringbuffer> rb;
-	} ports;
+	} m_ports;
 
-	friend struct lmms_visitor;
+	friend struct lmmsVisitor;
 
 #ifdef SPA_INSTRUMENT_USE_MIDI
 	QMutex m_pluginMutex;
@@ -130,16 +130,16 @@ private slots:
 
 	friend class SpaView;
 
-	bool loaded;
+	bool m_loaded;
 #ifdef SPA_INSTRUMENT_USE_QLIBRARY
-	class QLibrary *lib = nullptr;
+	class QLibrary *m_lib = nullptr;
 #else
-	void *lib = nullptr; //!< dlopen() handle
+	void *m_lib = nullptr; //!< dlopen() handle
 #endif
-	QString libraryName;
+	QString m_libraryName;
 
 	//! load a file in the plugin, but don't do anything in LMMS
-	void loadFileInternal(const QString &_file);
+	void loadFileInternal(const QString &file);
 signals:
 	void settingsChanged();
 };
diff --git a/src/gui/StringPairDrag.cpp b/src/gui/StringPairDrag.cpp
index d71d5ff3636..833a228f6b6 100644
--- a/src/gui/StringPairDrag.cpp
+++ b/src/gui/StringPairDrag.cpp
@@ -85,14 +85,14 @@ bool StringPairDrag::processDragEnterEvent( QDragEnterEvent * _dee,
 				? "none"
 				: _dee->mimeData()->formats().front().
 					toUtf8().data());
-		return( false );
+		return false;
 	}
 	QString txt = _dee->mimeData()->data( mimeType() );
 	if( _allowed_keys.split( ',' ).contains( txt.section( ':', 0, 0 ) ) )
 	{
 		_dee->acceptProposedAction();
 		puts("will accept DnD");
-		return( true );
+		return true;
 	}
 	else {
 		QString txtOsc = _dee->mimeData()->data( mimeTypeOsc() );
@@ -100,13 +100,13 @@ bool StringPairDrag::processDragEnterEvent( QDragEnterEvent * _dee,
 		{
 			_dee->acceptProposedAction();
 			puts("will accept OSC DnD");
-			return( true );
+			return true;
 		}
 		else
 			printf("will reject: cannot drop \"%s\" or \"%s\" here\n", txt.toUtf8().data(), txtOsc.toUtf8().data());
 	}
 	_dee->ignore();
-	return( false );
+	return false;
 }
 
 
@@ -115,8 +115,8 @@ bool StringPairDrag::processDragEnterEvent( QDragEnterEvent * _dee,
 QString StringPairDrag::decodeMimeKey( const QMimeData * mimeData )
 {
 	bool hasMt = (mimeData->hasFormat(mimeType()));
-	return( QString::fromUtf8( mimeData->data(
-		hasMt ? mimeType() : mimeTypeOsc() ) ).section( ':', 0, 0 ) );
+	return	QString::fromUtf8( mimeData->data(
+		hasMt ? mimeType() : mimeTypeOsc() ) ).section( ':', 0, 0 );
 }
 
 
@@ -127,8 +127,8 @@ QString StringPairDrag::decodeMimeValue( const QMimeData * mimeData )
 	const char* myMimeType = (mimeData->hasFormat(mimeType()))
 			? mimeType()
 			: mimeTypeOsc();
-	return( QString::fromUtf8( mimeData->data( myMimeType ) ).
-		section( ':', 1, -1 ) );
+	return	QString::fromUtf8( mimeData->data( myMimeType ) ).
+		section( ':', 1, -1 );
 }