Move main non Thread Objects to Smart Pointers

CHANGELOG.md

@@ -126,6 +126,7 @@ To allow segment streaming, enable "Realtime - Use main segment only" in WLED's
 - hyperion-remote: Extracting reply for a configGet request correctly (#1555)
 - Grabber fps setting was not applied correctly
 - Smoothing:  No empty updates
+- Addressed serious (#1425) and some smaller memory leaks
 
 ### Technical
 - Add CodeQL for GitHub code scanning

include/events/EventHandler.h

@@ -13,10 +13,9 @@ class EventHandler : public QObject
 	Q_OBJECT
 
 public:
-	EventHandler();
 	~EventHandler() override;
 
-	static EventHandler* getInstance();
+	static QScopedPointer<EventHandler>& getInstance();
 
 public slots:
 
@@ -40,6 +39,12 @@ protected:
 	Logger * _log {};
 
 private:
+	EventHandler();
+	EventHandler(const EventHandler&) = delete;
+	EventHandler& operator=(const EventHandler&) = delete;
+
+	static QScopedPointer<EventHandler> instance;
+
 	bool _isSuspended;
 	bool _isIdle;
 };

include/hyperion/GrabberWrapper.h

@@ -6,6 +6,7 @@
 #include <QString>
 #include <QStringList>
 #include <QMultiMap>
+#include <QScopedPointer>
 
 #include <utils/Logger.h>
 #include <utils/Components.h>
@@ -91,8 +92,8 @@ public:
 	template <typename Grabber_T>
 	bool transferFrame(Grabber_T &grabber)
 	{
-		unsigned w = grabber.getImageWidth();
-		unsigned h = grabber.getImageHeight();
+		int w = grabber.getImageWidth();
+		int h = grabber.getImageHeight();
 		if ( _image.width() != w || _image.height() != h)
 		{
 			_image.resize(w, h);
@@ -185,7 +186,7 @@ protected:
 	Logger * _log;
 
 	/// The timer for generating events with the specified update rate
-	QTimer* _timer;
+	QScopedPointer<QTimer> _timer;
 
 	/// The calculated update rate [ms]
 	int _updateInterval_ms;

libsrc/api/JsonAPI.cpp

@@ -142,7 +142,7 @@ void JsonAPI::initialize()
 	}
 
 	//notify eventhadler on suspend/resume/idle requests
-	connect(this, &JsonAPI::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+        connect(this, &JsonAPI::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 
 	connect(_ledStreamTimer, &QTimer::timeout, this, &JsonAPI::streamLedColorsUpdate, Qt::UniqueConnection);
 }

libsrc/cec/CECHandler.cpp

@@ -165,7 +165,7 @@ bool CECHandler::enable()
 			else
 			{
 				_isOpen=true;
-				QObject::connect(this, &CECHandler::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+				QObject::connect(this, &CECHandler::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 #ifdef VERBOSE_CEC
 				std::cout << "Found Devices: " << scan().toStdString() << std::endl;
 #endif
@@ -188,7 +188,7 @@ void CECHandler::disable()
 {
 	if (_isInitialised)
 	{
-		QObject::disconnect(this, &CECHandler::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+		 QObject::disconnect(this, &CECHandler::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 		_cecAdapter->Close();
 		_isOpen=false;
 		Info(_logger, "CEC handler disabled");

libsrc/events/EventHandler.cpp

@@ -7,6 +7,8 @@
 #include <utils/Process.h>
 #include <hyperion/HyperionIManager.h>
 
+QScopedPointer<EventHandler> EventHandler::instance;
+
 EventHandler::EventHandler()
 	: _isSuspended(false)
 	, _isIdle(false)
@@ -22,10 +24,14 @@ EventHandler::~EventHandler()
 	QObject::disconnect(this, &EventHandler::signalEvent, HyperionIManager::getInstance(), &HyperionIManager::handleEvent);
 }
 
-EventHandler* EventHandler::getInstance()
+QScopedPointer<EventHandler>& EventHandler::getInstance()
 {
-	static EventHandler instance;
-	return &instance;
+	if (!instance)
+	{
+		instance.reset(new EventHandler());
+	}
+
+	return instance;
 }
 
 void EventHandler::suspend()

libsrc/events/EventScheduler.cpp

@@ -15,12 +15,12 @@ EventScheduler::EventScheduler()
 	qRegisterMetaType<Event>("Event");
 	_log = Logger::getInstance("EVENTS-SCHED");
 
-	QObject::connect(this, &EventScheduler::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+	QObject::connect(this, &EventScheduler::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 }
 
 EventScheduler::~EventScheduler()
 {
-	QObject::disconnect(this, &EventScheduler::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+	QObject::disconnect(this, &EventScheduler::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 	clearTimers();
 	Info(_log, "Event scheduler stopped");
 }

libsrc/events/OsEventHandler.cpp

@@ -39,12 +39,12 @@ OsEventHandlerBase::OsEventHandlerBase()
 	{
 		_isService = true;
 	}
-	QObject::connect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+	QObject::connect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 }
 
 OsEventHandlerBase::~OsEventHandlerBase()
 {
-	QObject::disconnect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+	QObject::disconnect(this, &OsEventHandlerBase::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 
 	OsEventHandlerBase::unregisterLockHandler();
 	OsEventHandlerBase::unregisterOsEventHandler();

libsrc/hyperion/GrabberWrapper.cpp

@@ -27,36 +27,43 @@ bool GrabberWrapper::GLOBAL_GRABBER_AUDIO_ENABLE = false;
 GrabberWrapper::GrabberWrapper(const QString& grabberName, Grabber * ggrabber, int updateRate_Hz)
 	: _grabberName(grabberName)
 	  , _log(Logger::getInstance(grabberName.toUpper()))
-	  , _timer(new QTimer(this))
+	  , _timer(nullptr)
 	  , _updateInterval_ms(1000/updateRate_Hz)
 	  , _ggrabber(ggrabber)
 {
 	GrabberWrapper::instance = this;
 
+	_timer.reset(new QTimer(this));
+
 	// Configure the timer to generate events every n milliseconds
 	_timer->setTimerType(Qt::PreciseTimer);
 	_timer->setInterval(_updateInterval_ms);
 
-	connect(_timer, &QTimer::timeout, this, &GrabberWrapper::action);
+	connect(_timer.get(), &QTimer::timeout, this, &GrabberWrapper::action);
 
 	// connect the image forwarding
 	if (_grabberName.startsWith("V4L"))
+	{
 		connect(this, &GrabberWrapper::systemImage, GlobalSignals::getInstance(), &GlobalSignals::setV4lImage);
+	}
 	else if (_grabberName.startsWith("Audio"))
+	{
 		connect(this, &GrabberWrapper::systemImage, GlobalSignals::getInstance(), &GlobalSignals::setAudioImage);
+	}
 	else
+	{
 		connect(this, &GrabberWrapper::systemImage, GlobalSignals::getInstance(), &GlobalSignals::setSystemImage);
+	}
 
 	// listen for source requests
 	connect(GlobalSignals::getInstance(), &GlobalSignals::requestSource, this, &GrabberWrapper::handleSourceRequest);
 
-	QObject::connect(EventHandler::getInstance(), &EventHandler::signalEvent, this, &GrabberWrapper::handleEvent);
+		QObject::connect(EventHandler::getInstance().data(), &EventHandler::signalEvent, this, &GrabberWrapper::handleEvent);
 }
 
 GrabberWrapper::~GrabberWrapper()
 {
 	_timer->stop();
-	delete _timer;
 	GrabberWrapper::instance = nullptr;
 }
 
@@ -104,20 +111,26 @@ QStringList GrabberWrapper::getActive(int inst, GrabberTypeFilter type) const
 	if (type == GrabberTypeFilter::SCREEN || type == GrabberTypeFilter::ALL)
 	{
 		if (GRABBER_SYS_CLIENTS.contains(inst))
+		{
 			result << GRABBER_SYS_CLIENTS.value(inst);
 		}
+	}
 
 	if (type == GrabberTypeFilter::VIDEO || type == GrabberTypeFilter::ALL)
 	{
 		if (GRABBER_V4L_CLIENTS.contains(inst))
+		{
 			result << GRABBER_V4L_CLIENTS.value(inst);
 		}
+	}
 
 	if (type == GrabberTypeFilter::AUDIO || type == GrabberTypeFilter::ALL)
 	{
 		if (GRABBER_AUDIO_CLIENTS.contains(inst))
+		{
 			result << GRABBER_AUDIO_CLIENTS.value(inst);
 		}
+	}
 
 	return result;
 }
@@ -208,8 +221,10 @@ void GrabberWrapper::updateTimer(int interval)
 		_timer->setInterval(_updateInterval_ms);
 
 		if(timerWasActive)
+		{
 			_timer->start();
 		}
+	}
 }
 
 void GrabberWrapper::handleSettingsUpdate(settings::type type, const QJsonDocument& config)
@@ -269,41 +284,65 @@ void GrabberWrapper::handleSourceRequest(hyperion::Components component, int hyp
 		!_grabberName.startsWith("Audio"))
 	{
 		if (listen)
+		{
 			GRABBER_SYS_CLIENTS.insert(hyperionInd, _grabberName);
+		}
 		else
+		{
 			GRABBER_SYS_CLIENTS.remove(hyperionInd);
+		}
 
 		if (GRABBER_SYS_CLIENTS.empty() || !getSysGrabberState())
+		{
 			stop();
+		}
 		else
+		{
 			start();
 		}
+	}
 	else if (component == hyperion::Components::COMP_V4L &&
 		_grabberName.startsWith("V4L"))
 	{
 		if (listen)
+		{
 			GRABBER_V4L_CLIENTS.insert(hyperionInd, _grabberName);
+		}
 		else
+		{
 			GRABBER_V4L_CLIENTS.remove(hyperionInd);
+		}
 
 		if (GRABBER_V4L_CLIENTS.empty() || !getV4lGrabberState())
+		{
 			stop();
+		}
 		else
+		{
 			start();
 		}
+	}
 	else if (component == hyperion::Components::COMP_AUDIO &&
 		_grabberName.startsWith("Audio"))
 	{
 		if (listen)
+		{
 			GRABBER_AUDIO_CLIENTS.insert(hyperionInd, _grabberName);
+		}
 		else
+		{
 			GRABBER_AUDIO_CLIENTS.remove(hyperionInd);
+		}
 
 		if (GRABBER_AUDIO_CLIENTS.empty() || !getAudioGrabberState())
+		{
 			stop();
+		}
 		else
+		{
 			start();
 		}
+	}
 }
 
 void GrabberWrapper::tryStart()

src/hyperiond/hyperiond.cpp

@@ -76,9 +76,13 @@ HyperionDaemon::HyperionDaemon(const QString& rootPath, QObject* parent, bool lo
 #if defined(ENABLE_EFFECTENGINE)
 	, _pyInit(new PythonInit())
 #endif
+	, _ssdp(nullptr)
 	, _webserver(nullptr)
 	, _sslWebserver(nullptr)
 	, _jsonServer(nullptr)
+	, _eventHandler(nullptr)
+	, _osEventHandler(nullptr)
+	, _eventScheduler(nullptr)
 	, _videoGrabber(nullptr)
 	, _dispmanx(nullptr)
 	, _x11Grabber(nullptr)
@@ -89,13 +93,10 @@ HyperionDaemon::HyperionDaemon(const QString& rootPath, QObject* parent, bool lo
 	, _qtGrabber(nullptr)
 	, _dxGrabber(nullptr)
 	, _audioGrabber(nullptr)
-	, _ssdp(nullptr)
-	, _eventHandler(nullptr)
-	, _osEventHandler(nullptr)
-	, _eventScheduler(nullptr)
-	#ifdef ENABLE_CEC
+#ifdef ENABLE_CEC
 	, _cecHandler(nullptr)
-	#endif
+#endif
+	, _settingsManager(new SettingsManager(GLOABL_INSTANCE_ID, this, readonlyMode)) // init settings, this settingsManager accesses global settings which are independent from instances
 	, _currVideoMode(VideoMode::VIDEO_2D)
 {
 	HyperionDaemon::daemon = this;
@@ -108,9 +109,6 @@ HyperionDaemon::HyperionDaemon(const QString& rootPath, QObject* parent, bool lo
 	qRegisterMetaType<QMap<quint8, QJsonObject>>("QMap<quint8,QJsonObject>");
 	qRegisterMetaType<std::vector<ColorRgb>>("std::vector<ColorRgb>");
 
-	// init settings, this settingsManager accesses global settings which are independent from instances
-	_settingsManager = new SettingsManager(GLOABL_INSTANCE_ID, this, readonlyMode);
-
 	// set inital log lvl if the loglvl wasn't overwritten by arg
 	if (!logLvlOverwrite)
 	{
@@ -130,11 +128,11 @@ HyperionDaemon::HyperionDaemon(const QString& rootPath, QObject* parent, bool lo
 
 	// connect and apply settings for AuthManager
 	connect(this, &HyperionDaemon::settingsChanged, _authManager, &AuthManager::handleSettingsUpdate);
-	_authManager->handleSettingsUpdate(settings::NETWORK, _settingsManager->getSetting(settings::NETWORK));
+	_authManager->handleSettingsUpdate(settings::NETWORK, _settingsManager.get()->getSetting(settings::NETWORK));
 
 	// connect and apply settings for NetOrigin
 	connect(this, &HyperionDaemon::settingsChanged, _netOrigin, &NetOrigin::handleSettingsUpdate);
-	_netOrigin->handleSettingsUpdate(settings::NETWORK, _settingsManager->getSetting(settings::NETWORK));
+	_netOrigin->handleSettingsUpdate(settings::NETWORK, _settingsManager.get()->getSetting(settings::NETWORK));
 
 	// spawn all Hyperion instances (non blocking)
 	_instanceManager->startAll();
@@ -179,7 +177,6 @@ HyperionDaemon::HyperionDaemon(const QString& rootPath, QObject* parent, bool lo
 
 HyperionDaemon::~HyperionDaemon()
 {
-	delete _settingsManager;
 #if defined(ENABLE_EFFECTENGINE)
 	delete _pyInit;
 #endif
@@ -265,8 +262,6 @@ void HyperionDaemon::freeObjects()
 	Debug(_log, "Cleaning up Hyperion before quit.");
 
 	stopCecHandler();
-	delete _eventScheduler;
-	delete _osEventHandler;
 
 #ifdef ENABLE_MDNS
 	if (_mDNSProvider != nullptr)
@@ -333,24 +328,6 @@ void HyperionDaemon::freeObjects()
 
 	// stop Hyperions (non blocking)
 	_instanceManager->stopAll();
-
-	delete _amlGrabber;
-	delete _dispmanx;
-	delete _fbGrabber;
-	delete _osxGrabber;
-	delete _qtGrabber;
-	delete _dxGrabber;
-	delete _videoGrabber;
-	delete _audioGrabber;
-
-	_videoGrabber = nullptr;
-	_amlGrabber = nullptr;
-	_dispmanx = nullptr;
-	_fbGrabber = nullptr;
-	_osxGrabber = nullptr;
-	_qtGrabber = nullptr;
-	_dxGrabber = nullptr;
-	_audioGrabber = nullptr;
 }
 
 void HyperionDaemon::startNetworkServices()
@@ -418,27 +395,18 @@ void HyperionDaemon::startNetworkServices()
 
 void HyperionDaemon::startEventServices()
 {
-	if (_eventHandler == nullptr)
-	{
-		_eventHandler = EventHandler::getInstance();
+	_eventHandler->getInstance();
 	Debug(_log, "Hyperion event handler created");
-	}
 
-	if (_eventScheduler == nullptr)
-	{
-		_eventScheduler = new EventScheduler();
+	_eventScheduler.reset(new EventScheduler());
 	_eventScheduler->handleSettingsUpdate(settings::SCHEDEVENTS, getSetting(settings::SCHEDEVENTS));
-		connect(this, &HyperionDaemon::settingsChanged, _eventScheduler, &EventScheduler::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::settingsChanged, _eventScheduler.get(), &EventScheduler::handleSettingsUpdate);
 	Debug(_log, "Hyperion event scheduler created");
-	}
 
-	if (_osEventHandler == nullptr)
-	{
-		_osEventHandler = new OsEventHandler();
+	_osEventHandler.reset(new OsEventHandler());
 	_osEventHandler->handleSettingsUpdate(settings::OSEVENTS, getSetting(settings::OSEVENTS));
-		connect(this, &HyperionDaemon::settingsChanged, _osEventHandler, &OsEventHandler::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::settingsChanged, _osEventHandler.get(), &OsEventHandler::handleSettingsUpdate);
 	Debug(_log, "Operating System event handler created");
-	}
 
 	startCecHandler();
 }
@@ -534,91 +502,18 @@ void HyperionDaemon::handleSettingsUpdate(settings::type settingsType, const QJs
 
 		if (_prevType != type)
 		{
-			// stop all capture interfaces
-#ifdef ENABLE_FB
-			if (_fbGrabber != nullptr)
-			{
-				_fbGrabber->stop();
-				delete _fbGrabber;
-				_fbGrabber = nullptr;
-			}
-#endif
-#ifdef ENABLE_DISPMANX
-			if (_dispmanx != nullptr)
-			{
-				_dispmanx->stop();
-				delete _dispmanx;
-				_dispmanx = nullptr;
-			}
-#endif
-#ifdef ENABLE_AMLOGIC
-			if (_amlGrabber != nullptr)
-			{
-				_amlGrabber->stop();
-				delete _amlGrabber;
-				_amlGrabber = nullptr;
-			}
-#endif
-#ifdef ENABLE_OSX
-			if (_osxGrabber != nullptr)
-			{
-				_osxGrabber->stop();
-				delete _osxGrabber;
-				_osxGrabber = nullptr;
-			}
-#endif
-#ifdef ENABLE_X11
-			if (_x11Grabber != nullptr)
-			{
-				_x11Grabber->stop();
-				delete _x11Grabber;
-				_x11Grabber = nullptr;
-			}
-#endif
-#ifdef ENABLE_XCB
-			if (_xcbGrabber != nullptr)
-			{
-				_xcbGrabber->stop();
-				delete _xcbGrabber;
-				_xcbGrabber = nullptr;
-			}
-#endif
-#ifdef ENABLE_QT
-			if (_qtGrabber != nullptr)
-			{
-				_qtGrabber->stop();
-				delete _qtGrabber;
-				_qtGrabber = nullptr;
-			}
-#endif
-#ifdef ENABLE_DX
-			if (_dxGrabber != nullptr)
-			{
-				_dxGrabber->stop();
-				delete _dxGrabber;
-				_dxGrabber = nullptr;
-			}
-#endif
-
 			// create/start capture interface
 			if (type == "framebuffer")
-			{
-				if (_fbGrabber == nullptr)
 			{
 				createGrabberFramebuffer(grabberConfig);
-				}
 #ifdef ENABLE_FB
 				_fbGrabber->handleSettingsUpdate(settings::SYSTEMCAPTURE, getSetting(settings::SYSTEMCAPTURE));
 				_fbGrabber->tryStart();
 #endif
 			}
 			else if (type == "dispmanx")
-			{
-				if (_dispmanx == nullptr)
 			{
 				createGrabberDispmanx(grabberConfig);
-				}
-
 #ifdef ENABLE_DISPMANX
 				if (_dispmanx != nullptr)
 				{
@@ -628,66 +523,48 @@ void HyperionDaemon::handleSettingsUpdate(settings::type settingsType, const QJs
 #endif
 			}
 			else if (type == "amlogic")
-			{
-				if (_amlGrabber == nullptr)
 			{
 				createGrabberAmlogic(grabberConfig);
-				}
 #ifdef ENABLE_AMLOGIC
 				_amlGrabber->handleSettingsUpdate(settings::SYSTEMCAPTURE, getSetting(settings::SYSTEMCAPTURE));
 				_amlGrabber->tryStart();
 #endif
 			}
 			else if (type == "osx")
-			{
-				if (_osxGrabber == nullptr)
 			{
 				createGrabberOsx(grabberConfig);
-				}
 #ifdef ENABLE_OSX
 				_osxGrabber->handleSettingsUpdate(settings::SYSTEMCAPTURE, getSetting(settings::SYSTEMCAPTURE));
 				_osxGrabber->tryStart();
 #endif
 			}
 			else if (type == "x11")
-			{
-				if (_x11Grabber == nullptr)
 			{
 				createGrabberX11(grabberConfig);
-				}
 #ifdef ENABLE_X11
 				_x11Grabber->handleSettingsUpdate(settings::SYSTEMCAPTURE, getSetting(settings::SYSTEMCAPTURE));
 				_x11Grabber->tryStart();
 #endif
 			}
 			else if (type == "xcb")
-			{
-				if (_xcbGrabber == nullptr)
 			{
 				createGrabberXcb(grabberConfig);
-				}
 #ifdef ENABLE_XCB
 				_xcbGrabber->handleSettingsUpdate(settings::SYSTEMCAPTURE, getSetting(settings::SYSTEMCAPTURE));
 				_xcbGrabber->tryStart();
 #endif
 			}
 			else if (type == "qt")
-			{
-				if (_qtGrabber == nullptr)
 			{
 				createGrabberQt(grabberConfig);
-				}
 #ifdef ENABLE_QT
 				_qtGrabber->handleSettingsUpdate(settings::SYSTEMCAPTURE, getSetting(settings::SYSTEMCAPTURE));
 				_qtGrabber->tryStart();
 #endif
 			}
 			else if (type == "dx")
-			{
-				if (_dxGrabber == nullptr)
 			{
 				createGrabberDx(grabberConfig);
-				}
 #ifdef ENABLE_DX
 				_dxGrabber->handleSettingsUpdate(settings::SYSTEMCAPTURE, getSetting(settings::SYSTEMCAPTURE));
 				_dxGrabber->tryStart();
@@ -704,9 +581,7 @@ void HyperionDaemon::handleSettingsUpdate(settings::type settingsType, const QJs
 	else if (settingsType == settings::V4L2)
 	{
 #if defined(ENABLE_V4L2) || defined(ENABLE_MF)
-		if (_videoGrabber == nullptr)
-		{
-			_videoGrabber = new VideoWrapper();
+		_videoGrabber.reset(new VideoWrapper());
 		_videoGrabber->handleSettingsUpdate(settings::V4L2, getSetting(settings::V4L2));
 
 #if defined(ENABLE_MF)
@@ -714,11 +589,9 @@ void HyperionDaemon::handleSettingsUpdate(settings::type settingsType, const QJs
 #elif defined(ENABLE_V4L2)
 		Debug(_log, "V4L2 grabber created");
 #endif
-
 		// connect to HyperionDaemon signal
-			connect(this, &HyperionDaemon::videoMode, _videoGrabber, &VideoWrapper::setVideoMode);
-			connect(this, &HyperionDaemon::settingsChanged, _videoGrabber, &VideoWrapper::handleSettingsUpdate);
-		}
+		connect(this, &HyperionDaemon::videoMode, _videoGrabber.get(), &VideoWrapper::setVideoMode);
+		connect(this, &HyperionDaemon::settingsChanged, _videoGrabber.get(), &VideoWrapper::handleSettingsUpdate);
 #else
 		Debug(_log, "The v4l2 grabber is not supported on this platform");
 #endif
@@ -727,15 +600,12 @@ void HyperionDaemon::handleSettingsUpdate(settings::type settingsType, const QJs
 	{
 #ifdef ENABLE_AUDIO
 		// Create Audio Grabber
-		if (_audioGrabber == nullptr)
-		{
-			_audioGrabber = new AudioWrapper();
+		_audioGrabber.reset(new AudioWrapper());
 		_audioGrabber->handleSettingsUpdate(settings::AUDIO, getSetting(settings::AUDIO));
 
-			connect(this, &HyperionDaemon::settingsChanged, _audioGrabber, &AudioWrapper::handleSettingsUpdate);
+		connect(this, &HyperionDaemon::settingsChanged, _audioGrabber.get(), &AudioWrapper::handleSettingsUpdate);
 
 		Debug(_log, "Audio grabber created");
-		}
 #else
 		Debug(_log, "Audio capture not supported on this platform");
 #endif
@@ -745,15 +615,13 @@ void HyperionDaemon::handleSettingsUpdate(settings::type settingsType, const QJs
 void HyperionDaemon::createGrabberDispmanx(const QJsonObject& /*grabberConfig*/)
 {
 #ifdef ENABLE_DISPMANX
-	_dispmanx = new DispmanxWrapper(
+	_dispmanx.reset(new DispmanxWrapper(
 		_grabber_frequency,
 		_grabber_pixelDecimation
-	);
+	));
 
 	if (!_dispmanx->available)
 	{
-		delete _dispmanx;
-		_dispmanx = nullptr;
 		Debug(_log, "The dispmanx framegrabber is not supported on this platform");
 		return;
 	}
@@ -761,8 +629,8 @@ void HyperionDaemon::createGrabberDispmanx(const QJsonObject& /*grabberConfig*/)
 	_dispmanx->setCropping(_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom);
 
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _dispmanx, &DispmanxWrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _dispmanx, &DispmanxWrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _dispmanx.get(), &DispmanxWrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _dispmanx.get(), &DispmanxWrapper::handleSettingsUpdate);
 
 	Info(_log, "DISPMANX frame grabber created");
 #else
@@ -773,15 +641,15 @@ void HyperionDaemon::createGrabberDispmanx(const QJsonObject& /*grabberConfig*/)
 void HyperionDaemon::createGrabberAmlogic(const QJsonObject& /*grabberConfig*/)
 {
 #ifdef ENABLE_AMLOGIC
-	_amlGrabber = new AmlogicWrapper(
+	_amlGrabber.reset(new AmlogicWrapper(
 		_grabber_frequency,
 		_grabber_pixelDecimation
-	);
+	));
 	_amlGrabber->setCropping(_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom);
 
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _amlGrabber, &AmlogicWrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _amlGrabber, &AmlogicWrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _amlGrabber.get(), &AmlogicWrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _amlGrabber.get(), &AmlogicWrapper::handleSettingsUpdate);
 
 	Info(_log, "AMLOGIC grabber created");
 #else
@@ -792,16 +660,17 @@ void HyperionDaemon::createGrabberAmlogic(const QJsonObject& /*grabberConfig*/)
 void HyperionDaemon::createGrabberX11(const QJsonObject& /*grabberConfig*/)
 {
 #ifdef ENABLE_X11
-	_x11Grabber = new X11Wrapper(
+	qDebug() << "createGrabberX11";
+	_x11Grabber.reset(new X11Wrapper(
 		_grabber_frequency,
 		_grabber_pixelDecimation,
 		_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom
-	);
+	));
 	_x11Grabber->setCropping(_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom);
 
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _x11Grabber, &X11Wrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _x11Grabber, &X11Wrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _x11Grabber.get(), &X11Wrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _x11Grabber.get(), &X11Wrapper::handleSettingsUpdate);
 
 	Info(_log, "X11 grabber created");
 #else
@@ -812,16 +681,16 @@ void HyperionDaemon::createGrabberX11(const QJsonObject& /*grabberConfig*/)
 void HyperionDaemon::createGrabberXcb(const QJsonObject& /*grabberConfig*/)
 {
 #ifdef ENABLE_XCB
-	_xcbGrabber = new XcbWrapper(
+	_xcbGrabber.reset(new XcbWrapper(
 		_grabber_frequency,
 		_grabber_pixelDecimation,
 		_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom
-	);
+	));
 	_xcbGrabber->setCropping(_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom);
 
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _xcbGrabber, &XcbWrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _xcbGrabber, &XcbWrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _xcbGrabber.get(), &XcbWrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _xcbGrabber.get(), &XcbWrapper::handleSettingsUpdate);
 
 	Info(_log, "XCB grabber created");
 #else
@@ -832,16 +701,16 @@ void HyperionDaemon::createGrabberXcb(const QJsonObject& /*grabberConfig*/)
 void HyperionDaemon::createGrabberQt(const QJsonObject& grabberConfig)
 {
 #ifdef ENABLE_QT
-	_qtGrabber = new QtWrapper(
+	_qtGrabber.reset(new QtWrapper(
 		_grabber_frequency,
 		grabberConfig["input"].toInt(0),
 		_grabber_pixelDecimation,
 		_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom
-	);
+	));
 
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _qtGrabber, &QtWrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _qtGrabber, &QtWrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _qtGrabber.get(), &QtWrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _qtGrabber.get(), &QtWrapper::handleSettingsUpdate);
 
 	Info(_log, "Qt grabber created");
 #else
@@ -852,16 +721,16 @@ void HyperionDaemon::createGrabberQt(const QJsonObject& grabberConfig)
 void HyperionDaemon::createGrabberDx(const QJsonObject& grabberConfig)
 {
 #ifdef ENABLE_DX
-	_dxGrabber = new DirectXWrapper(
+	_dxGrabber.reset(new DirectXWrapper(
 		_grabber_frequency,
 		grabberConfig["display"].toInt(0),
 		_grabber_pixelDecimation,
 		_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom
-	);
+	));
 
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _dxGrabber, &DirectXWrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _dxGrabber, &DirectXWrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _dxGrabber.get(), &DirectXWrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _dxGrabber.get(), &DirectXWrapper::handleSettingsUpdate);
 
 	Info(_log, "DirectX grabber created");
 #else
@@ -876,15 +745,15 @@ void HyperionDaemon::createGrabberFramebuffer(const QJsonObject& grabberConfig)
 
 	int fbIdx = grabberConfig["input"].toInt(0);
 	QString devicePath = QString("/dev/fb%1").arg(fbIdx);
-	_fbGrabber = new FramebufferWrapper(
+	_fbGrabber.reset(new FramebufferWrapper(
 		_grabber_frequency,
 		devicePath,
 		_grabber_pixelDecimation
-	);
+	));
 	_fbGrabber->setCropping(_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom);
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _fbGrabber, &FramebufferWrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _fbGrabber, &FramebufferWrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _fbGrabber.get(), &FramebufferWrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _fbGrabber.get(), &FramebufferWrapper::handleSettingsUpdate);
 
 	Info(_log, "Framebuffer grabber created");
 #else
@@ -896,16 +765,16 @@ void HyperionDaemon::createGrabberOsx(const QJsonObject& grabberConfig)
 {
 #ifdef ENABLE_OSX
 	// Construct and start the osx grabber if the configuration is present
-	_osxGrabber = new OsxWrapper(
+	_osxGrabber.reset(new OsxWrapper(
 		_grabber_frequency,
 		grabberConfig["input"].toInt(0),
 		_grabber_pixelDecimation
-	);
+	));
 	_osxGrabber->setCropping(_grabber_cropLeft, _grabber_cropRight, _grabber_cropTop, _grabber_cropBottom);
 
 	// connect to HyperionDaemon signal
-	connect(this, &HyperionDaemon::videoMode, _osxGrabber, &OsxWrapper::setVideoMode);
-	connect(this, &HyperionDaemon::settingsChanged, _osxGrabber, &OsxWrapper::handleSettingsUpdate);
+	connect(this, &HyperionDaemon::videoMode, _osxGrabber.get(), &OsxWrapper::setVideoMode);
+	connect(this, &HyperionDaemon::settingsChanged, _osxGrabber.get(), &OsxWrapper::handleSettingsUpdate);
 
 	Info(_log, "OSX grabber created");
 #else

src/hyperiond/hyperiond.h

@@ -199,33 +199,36 @@ private:
 #if defined(ENABLE_EFFECTENGINE)
 	PythonInit*                _pyInit;
 #endif
+	SSDPHandler*               _ssdp;
 	WebServer*                 _webserver;
 	WebServer*                 _sslWebserver;
 	JsonServer*                _jsonServer;
-	VideoWrapper*              _videoGrabber;
-	DispmanxWrapper*           _dispmanx;
-	X11Wrapper*                _x11Grabber;
-	XcbWrapper*                _xcbGrabber;
-	AmlogicWrapper*            _amlGrabber;
-	FramebufferWrapper*        _fbGrabber;
-	OsxWrapper*                _osxGrabber;
-	QtWrapper*                 _qtGrabber;
-	DirectXWrapper*            _dxGrabber;
-	AudioWrapper*			   _audioGrabber;
-	SSDPHandler*               _ssdp;
-	EventHandler*              _eventHandler;
-	OsEventHandler*            _osEventHandler;
-	EventScheduler*            _eventScheduler;
-#ifdef ENABLE_CEC
-CECHandler*                _cecHandler;
-#endif
 
+	QScopedPointer<EventHandler> _eventHandler;
+	QScopedPointer<OsEventHandler> _osEventHandler;
+	QScopedPointer<EventScheduler> _eventScheduler;
+
+	QScopedPointer<VideoWrapper> _videoGrabber;
+	QScopedPointer<DispmanxWrapper> _dispmanx;
+	QScopedPointer<X11Wrapper> _x11Grabber;
+	QScopedPointer<XcbWrapper> _xcbGrabber;
+	QScopedPointer<AmlogicWrapper> _amlGrabber;
+	QScopedPointer<FramebufferWrapper> _fbGrabber;
+	QScopedPointer<OsxWrapper> _osxGrabber;
+	QScopedPointer<QtWrapper> _qtGrabber;
+	QScopedPointer<DirectXWrapper> _dxGrabber;
+	QScopedPointer<AudioWrapper> _audioGrabber;
+
+	#ifdef ENABLE_CEC
+	CECHandler*                _cecHandler;
+	#endif
 	#if defined(ENABLE_FLATBUF_SERVER)
 	FlatBufferServer*          _flatBufferServer;
 	#endif
 	#if defined(ENABLE_PROTOBUF_SERVER)
 	ProtoServer*               _protoServer;
 	#endif
+
 	int                        _grabber_width;
 	int                        _grabber_height;
 	int                        _grabber_pixelDecimation;
@@ -234,9 +237,8 @@ CECHandler*                _cecHandler;
 	int                        _grabber_cropRight;
 	int                        _grabber_cropTop;
 	int                        _grabber_cropBottom;
-
 	QString                    _prevType;
-
 	VideoMode                  _currVideoMode;
-	SettingsManager*           _settingsManager;
+
+	QScopedPointer<SettingsManager> _settingsManager;
 };

src/hyperiond/systray.cpp

@@ -45,7 +45,7 @@ SysTray::SysTray(HyperionDaemon *hyperiond)
 	// instance changes
 	connect(_instanceManager, &HyperionIManager::instanceStateChanged, this, &SysTray::handleInstanceStateChange);
 
-	connect(this, &SysTray::signalEvent, EventHandler::getInstance(), &EventHandler::handleEvent);
+        connect(this, &SysTray::signalEvent, EventHandler::getInstance().data(), &EventHandler::handleEvent);
 }
 
 SysTray::~SysTray()