hyperion.ng/libsrc/hyperion/GrabberWrapper.cpp

// Hyperion includes
#include <hyperion/GrabberWrapper.h>
#include <hyperion/Grabber.h>
#include <HyperionConfig.h>

// utils includes
#include <utils/GlobalSignals.h>

// qt
#include <QTimer>

GrabberWrapper* GrabberWrapper::instance = nullptr;
const int GrabberWrapper::DEFAULT_RATE_HZ = 10;
const int GrabberWrapper::DEFAULT_MIN_GRAB_RATE_HZ = 1;
const int GrabberWrapper::DEFAULT_MAX_GRAB_RATE_HZ = 30;
const int GrabberWrapper::DEFAULT_PIXELDECIMATION = 8;

/// Map of Hyperion instances with grabber name that requested screen capture
QMap<int, QString> GrabberWrapper::GRABBER_SYS_CLIENTS = QMap<int, QString>();
QMap<int, QString> GrabberWrapper::GRABBER_V4L_CLIENTS = QMap<int, QString>();
bool GrabberWrapper::GLOBAL_GRABBER_SYS_ENABLE = false;
bool GrabberWrapper::GLOBAL_GRABBER_V4L_ENABLE = false;

GrabberWrapper::GrabberWrapper(const QString& grabberName, Grabber * ggrabber, int updateRate_Hz)
	: _grabberName(grabberName)
	  , _log(Logger::getInstance(grabberName.toUpper()))
	  , _timer(new QTimer(this))
	  , _updateInterval_ms(1000/updateRate_Hz)
	  , _ggrabber(ggrabber)
	  , _image(0,0)
{
	GrabberWrapper::instance = 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 the image forwarding
	(_grabberName.startsWith("V4L"))
		? connect(this, &GrabberWrapper::systemImage, GlobalSignals::getInstance(), &GlobalSignals::setV4lImage)
		: connect(this, &GrabberWrapper::systemImage, GlobalSignals::getInstance(), &GlobalSignals::setSystemImage);

	// listen for source requests
	connect(GlobalSignals::getInstance(), &GlobalSignals::requestSource, this, &GrabberWrapper::handleSourceRequest);
}

GrabberWrapper::~GrabberWrapper()
{
	Debug(_log,"Close grabber: %s", QSTRING_CSTR(_grabberName));
}

bool GrabberWrapper::start()
{
	bool rc = false;
	if ( open() )
	{
		if (!_timer->isActive())
		{
			// Start the timer with the pre configured interval
			Debug(_log,"Grabber start()");
			_timer->start();
		}

		rc = _timer->isActive();
	}
	return rc;
}

void GrabberWrapper::stop()
{
	if (_timer->isActive())
	{
		// Stop the timer, effectively stopping the process
		Debug(_log,"Grabber stop()");
		_timer->stop();
	}
}

bool GrabberWrapper::isActive() const
{
	return _timer->isActive();
}

QStringList GrabberWrapper::getActive(int inst) const
{
	QStringList result = QStringList();

	if(GRABBER_V4L_CLIENTS.contains(inst))
		result << GRABBER_V4L_CLIENTS.value(inst);

	if(GRABBER_SYS_CLIENTS.contains(inst))
		result << GRABBER_SYS_CLIENTS.value(inst);

	return result;
}

QStringList GrabberWrapper::availableGrabbers()
{
	QStringList grabbers;

#ifdef ENABLE_DISPMANX
	grabbers << "dispmanx";
#endif

#if defined(ENABLE_V4L2) || defined(ENABLE_MF)
	grabbers << "v4l2";
#endif

#ifdef ENABLE_FB
	grabbers << "framebuffer";
#endif

#ifdef ENABLE_AMLOGIC
	grabbers << "amlogic";
#endif

#ifdef ENABLE_OSX
	grabbers << "osx";
#endif

#ifdef ENABLE_X11
	grabbers << "x11";
#endif

#ifdef ENABLE_XCB
	grabbers << "xcb";
#endif

#ifdef ENABLE_QT
	grabbers << "qt";
#endif

#ifdef ENABLE_DX
	grabbers << "dx";
#endif

	return grabbers;
}

void GrabberWrapper::setVideoMode(VideoMode mode)
{
	if (_ggrabber != nullptr)
	{
		Info(_log,"setVideoMode");
		_ggrabber->setVideoMode(mode);
	}
}

void GrabberWrapper::setFlipMode(const QString& flipMode)
{
	_ggrabber->setFlipMode(parseFlipMode(flipMode));
}

void GrabberWrapper::setCropping(int cropLeft, int cropRight, int cropTop, int cropBottom)
{
	_ggrabber->setCropping(cropLeft, cropRight, cropTop, cropBottom);
}

void GrabberWrapper::updateTimer(int interval)
{
	if(_updateInterval_ms != interval)
	{
		_updateInterval_ms = interval;

		const bool& timerWasActive = _timer->isActive();
		_timer->stop();
		_timer->setInterval(_updateInterval_ms);

		if(timerWasActive)
			_timer->start();
	}
}

void GrabberWrapper::handleSettingsUpdate(settings::type type, const QJsonDocument& config)
{	if(type == settings::SYSTEMCAPTURE && !_grabberName.startsWith("V4L"))
	{
		// extract settings
		const QJsonObject& obj = config.object();

		// set global grabber state
		setSysGrabberState(obj["enable"].toBool(false));

		if (getSysGrabberState())
		{
			// width/height
			_ggrabber->setWidthHeight(obj["width"].toInt(96), obj["height"].toInt(96));

			// display index for MAC
			_ggrabber->setDisplayIndex(obj["input"].toInt(0));

			// pixel decimation for x11
			_ggrabber->setPixelDecimation(obj["pixelDecimation"].toInt(DEFAULT_PIXELDECIMATION));

			// crop for system capture
			_ggrabber->setCropping(
				obj["cropLeft"].toInt(0),
				obj["cropRight"].toInt(0),
				obj["cropTop"].toInt(0),
				obj["cropBottom"].toInt(0));

			_ggrabber->setFramerate(obj["fps"].toInt(DEFAULT_RATE_HZ));
			// eval new update time
			updateTimer(_ggrabber->getUpdateInterval());
		}
		else
		{
			stop();
		}
	}
}

void GrabberWrapper::handleSourceRequest(hyperion::Components component, int hyperionInd, bool listen)
{
	if(component == hyperion::Components::COMP_GRABBER  && !_grabberName.startsWith("V4L"))
	{
		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();
	}
}

void GrabberWrapper::tryStart()
{
	// verify start condition
	if(!_grabberName.startsWith("V4L") && !GRABBER_SYS_CLIENTS.empty() && getSysGrabberState())
		start();
}