Feature/CEC detection (#877)

* Add CEC functionality

* Initial commit

* removed libCEC from the system skip list

Co-authored-by: Paulchen Panther <16664240+Paulchen-Panther@users.noreply.github.com>

libsrc/CMakeLists.txt

@@ -20,6 +20,10 @@ add_subdirectory(db)
 add_subdirectory(api)
 add_subdirectory(python)
 
+if(ENABLE_CEC)
+	add_subdirectory(cec)
+endif()
+
 if(ENABLE_AVAHI)
-  add_subdirectory(bonjour)
-endif()
+	add_subdirectory(bonjour)
+endif()

libsrc/api/JSONRPC_schema/schema-leddevice.json

@@ -22,7 +22,7 @@
 		"params": {
 			"type" : "object",
 			"required" : false
-		}					
+		}
 	},
 	"additionalProperties": false
 }

libsrc/api/JsonAPI.cpp

@@ -1409,7 +1409,6 @@ void JsonAPI::handleLedDeviceCommand(const QJsonObject &message, const QString &
 */	{
 		if (subc == "discover")
 		{
-
 			QJsonObject config;
 			config.insert("type", devType);
 

libsrc/cec/CECHandler.cpp

@@ -0,0 +1,339 @@
+#include <cec/CECHandler.h>
+#include <utils/Logger.h>
+
+#include <algorithm>
+
+#include <libcec/cecloader.h>
+
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+/* Enable to turn on detailed CEC logs */
+// #define VERBOSE_CEC
+
+CECHandler::CECHandler()
+{
+	qRegisterMetaType<CECEvent>("CECEvent");
+
+	 _logger = Logger::getInstance("CEC");
+
+	_cecCallbacks            = getCallbacks();
+	_cecConfig               = getConfig();
+	_cecConfig.callbacks     = &_cecCallbacks;
+	_cecConfig.callbackParam = this;
+}
+
+CECHandler::~CECHandler()
+{
+	stop();
+}
+
+bool CECHandler::start()
+{
+	if (_cecAdapter)
+		return true;
+
+	Info(_logger, "Starting CEC handler");
+
+	_cecAdapter = LibCecInitialise(&_cecConfig);
+	if(!_cecAdapter)
+	{
+		Error(_logger, "Failed loading libcec.so");
+		return false;
+	}
+
+	auto adapters = getAdapters();
+	if (adapters.isEmpty())
+	{
+		Error(_logger, "Failed to find CEC adapter");
+		UnloadLibCec(_cecAdapter);
+		_cecAdapter = nullptr;
+
+		return false;
+	}
+
+	Info(_logger, "Auto detecting CEC adapter");
+	bool opened = false;
+	for (const auto & adapter : adapters)
+	{
+		printAdapter(adapter);
+
+		if (!opened && openAdapter(adapter))
+		{
+			Info(_logger, "CEC Handler initialized with adapter : %s", adapter.strComName);
+
+			opened = true;
+		}
+	}
+
+	if (!opened)
+	{
+		UnloadLibCec(_cecAdapter);
+		_cecAdapter = nullptr;
+	}
+
+	return opened;
+}
+
+void CECHandler::stop()
+{
+	if (_cecAdapter)
+	{
+		Info(_logger, "Stopping CEC handler");
+
+		_cecAdapter->Close();
+		UnloadLibCec(_cecAdapter);
+		_cecAdapter = nullptr;
+	}
+}
+
+CECConfig CECHandler::getConfig() const
+{
+	CECConfig configuration;
+
+	const std::string name("HyperionCEC");
+	name.copy(configuration.strDeviceName, std::min(name.size(), sizeof(configuration.strDeviceName)));
+
+	configuration.deviceTypes.Add(CEC::CEC_DEVICE_TYPE_RECORDING_DEVICE);
+	configuration.clientVersion = CEC::LIBCEC_VERSION_CURRENT;
+
+	return configuration;
+}
+
+CECCallbacks CECHandler::getCallbacks() const
+{
+	CECCallbacks callbacks;
+
+	callbacks.sourceActivated      = onCecSourceActivated;
+	callbacks.commandReceived      = onCecCommandReceived;
+	callbacks.alert                = onCecAlert;
+	callbacks.logMessage           = onCecLogMessage;
+	callbacks.keyPress             = onCecKeyPress;
+	callbacks.configurationChanged = onCecConfigurationChanged;
+	callbacks.menuStateChanged     = onCecMenuStateChanged;
+
+	return callbacks;
+}
+
+QVector<CECAdapterDescriptor> CECHandler::getAdapters() const
+{
+	if (!_cecAdapter)
+		return {};
+
+	QVector<CECAdapterDescriptor> descriptors(16);
+	int8_t size = _cecAdapter->DetectAdapters(descriptors.data(), descriptors.size(), nullptr, true /*quickscan*/);
+	descriptors.resize(size);
+
+	return descriptors;
+}
+
+bool CECHandler::openAdapter(const CECAdapterDescriptor & descriptor)
+{
+	if (!_cecAdapter)
+		return false;
+
+	if(!_cecAdapter->Open(descriptor.strComName))
+	{
+		Error(_logger, QString("Failed to open the CEC adaper on port %1")
+			.arg(descriptor.strComName)
+				.toLocal8Bit());
+
+		return false;
+	}
+	return true;
+}
+
+void CECHandler::printAdapter(const CECAdapterDescriptor & descriptor) const
+{
+	Info(_logger, QString("CEC Adapter:").toLocal8Bit());
+	Info(_logger, QString("\tName   : %1").arg(descriptor.strComName).toLocal8Bit());
+	Info(_logger, QString("\tPath   : %1").arg(descriptor.strComPath).toLocal8Bit());
+}
+
+QString CECHandler::scan() const
+{
+	if (!_cecAdapter)
+		return {};
+
+	Info(_logger, "Starting CEC scan");
+
+	QJsonArray devices;
+	CECLogicalAddresses addresses = _cecAdapter->GetActiveDevices();
+	for (int address = CEC::CECDEVICE_TV; address <= CEC::CECDEVICE_BROADCAST; ++address)
+	{
+		if (addresses[address])
+		{
+			CECLogicalAddress logicalAddress = (CECLogicalAddress)address;
+
+			QJsonObject device;
+			CECVendorId vendor = (CECVendorId)_cecAdapter->GetDeviceVendorId(logicalAddress);
+			CECPowerStatus power = _cecAdapter->GetDevicePowerStatus(logicalAddress);
+
+			device["name"    ] = _cecAdapter->GetDeviceOSDName(logicalAddress).c_str();
+			device["vendor"  ] = _cecAdapter->ToString(vendor);
+			device["address" ] = _cecAdapter->ToString(logicalAddress);
+			device["power"   ] = _cecAdapter->ToString(power);
+
+			devices << device;
+
+			Info(_logger, QString("\tCECDevice: %1 / %2 / %3 / %4")
+				.arg(device["name"].toString())
+				.arg(device["vendor"].toString())
+				.arg(device["address"].toString())
+				.arg(device["power"].toString())
+				.toLocal8Bit());
+		}
+	}
+
+	return QJsonDocument(devices).toJson(QJsonDocument::Compact);
+}
+
+void CECHandler::onCecLogMessage(void * context, const CECLogMessage * message)
+{
+#ifdef VERBOSE_CEC
+	CECHandler * handler = qobject_cast<CECHandler*>(static_cast<QObject*>(context));
+	if (!handler)
+		return;
+
+	switch (message->level)
+	{
+	case CEC::CEC_LOG_ERROR:
+		Error(handler->_logger, QString("%1")
+			.arg(message->message)
+				.toLocal8Bit());
+		break;
+	case CEC::CEC_LOG_WARNING:
+		Warning(handler->_logger, QString("%1")
+			.arg(message->message)
+				.toLocal8Bit());
+		break;
+	case CEC::CEC_LOG_TRAFFIC:
+	case CEC::CEC_LOG_NOTICE:
+		Info(handler->_logger, QString("%1")
+			.arg(message->message)
+				.toLocal8Bit());
+		break;
+	case CEC::CEC_LOG_DEBUG:
+		Debug(handler->_logger, QString("%1")
+			.arg(message->message)
+				.toLocal8Bit());
+		break;
+	default:
+		break;
+	}
+#endif
+}
+
+void CECHandler::onCecKeyPress(void * context, const CECKeyPress * key)
+{
+#ifdef VERBOSE_CEC
+	CECHandler * handler = qobject_cast<CECHandler*>(static_cast<QObject*>(context));
+	if (!handler)
+		return;
+
+	CECAdapter * adapter = handler->_cecAdapter;
+
+	Debug(handler->_logger, QString("CECHandler::onCecKeyPress: %1")
+		.arg(adapter->ToString(key->keycode))
+			.toLocal8Bit());
+#endif
+}
+
+void CECHandler::onCecAlert(void * context, const CECAlert alert, const CECParameter data)
+{
+#ifdef VERBOSE_CEC
+	CECHandler * handler = qobject_cast<CECHandler*>(static_cast<QObject*>(context));
+	if (!handler)
+		return;
+
+	Error(handler->_logger, QString("CECHandler::onCecAlert: %1")
+		.arg(alert)
+			.toLocal8Bit());
+#endif
+}
+
+void CECHandler::onCecConfigurationChanged(void * context, const CECConfig * configuration)
+{
+#ifdef VERBOSE_CEC
+	CECHandler * handler = qobject_cast<CECHandler*>(static_cast<QObject*>(context));
+	if (!handler)
+		return;
+
+	Debug(handler->_logger, QString("CECHandler::onCecConfigurationChanged: %1")
+		.arg(configuration->strDeviceName)
+			.toLocal8Bit());
+#endif
+}
+
+int CECHandler::onCecMenuStateChanged(void * context, const CECMenuState state)
+{
+#ifdef VERBOSE_CEC
+	CECHandler * handler = qobject_cast<CECHandler*>(static_cast<QObject*>(context));
+	if (!handler)
+		return 0;
+
+	CECAdapter * adapter = handler->_cecAdapter;
+
+	Debug(handler->_logger, QString("CECHandler::onCecMenuStateChanged: %1")
+		.arg(adapter->ToString(state))
+			.toLocal8Bit());
+#endif
+	return 0;
+}
+
+void CECHandler::onCecCommandReceived(void * context, const CECCommand * command)
+{
+	CECHandler * handler = qobject_cast<CECHandler*>(static_cast<QObject*>(context));
+	if (!handler)
+		return;
+
+	CECAdapter * adapter = handler->_cecAdapter;
+
+#ifdef VERBOSE_CEC
+	Debug(handler->_logger, QString("CECHandler::onCecCommandReceived: %1 (%2 > %3)")
+		.arg(adapter->ToString(command->opcode))
+		.arg(adapter->ToString(command->initiator))
+		.arg(adapter->ToString(command->destination))
+			.toLocal8Bit());
+#endif
+	/* We do NOT check sender */
+	// if (address == CEC::CECDEVICE_TV)
+	{
+		if (command->opcode == CEC::CEC_OPCODE_SET_STREAM_PATH)
+		{
+			Info(handler->_logger, QString("CEC source activated: %1")
+				.arg(adapter->ToString(command->initiator))
+					.toLocal8Bit());
+			emit handler->cecEvent(CECEvent::On);
+		}
+		if (command->opcode == CEC::CEC_OPCODE_STANDBY)
+		{
+			Info(handler->_logger, QString("CEC source deactivated: %1")
+				.arg(adapter->ToString(command->initiator))
+					.toLocal8Bit());
+			emit handler->cecEvent(CECEvent::Off);
+		}
+	}
+}
+
+void CECHandler::onCecSourceActivated(void * context, const CECLogicalAddress address, const uint8_t activated)
+{
+	/* We use CECHandler::onCecCommandReceived for
+	 * source activated/deactivated notifications. */
+
+#ifdef VERBOSE_CEC
+	CECHandler * handler = qobject_cast<CECHandler*>(static_cast<QObject*>(context));
+	if (!handler)
+		return;
+
+	CECAdapter * adapter = handler->_cecAdapter;
+
+	Debug(handler->_logger, QString("CEC source %1 : %2")
+		.arg(activated ? "activated" : "deactivated")
+		.arg(adapter->ToString(address))
+			.toLocal8Bit());
+#endif
+}
+
+

libsrc/cec/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Define the current source locations
+find_package(CEC REQUIRED)
+
+SET(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/cec)
+SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/cec)
+
+FILE (GLOB CEC_SOURCES "${CURRENT_HEADER_DIR}/*.h"  "${CURRENT_SOURCE_DIR}/*.h"  "${CURRENT_SOURCE_DIR}/*.cpp")
+add_library(cechandler ${CEC_SOURCES})
+
+include_directories(${CEC_INCLUDE_DIRS})
+
+target_link_libraries(cechandler
+	dl
+	${CEC_LIBRARIES}
+	Qt5::Core
+)
+

libsrc/grabber/v4l2/CMakeLists.txt

@@ -14,5 +14,5 @@ target_link_libraries(v4l2-grabber
 if(TURBOJPEG_FOUND)
 	target_link_libraries(v4l2-grabber ${TurboJPEG_LIBRARY})
 elseif (JPEG_FOUND)
-		target_link_libraries(v4l2-grabber ${JPEG_LIBRARY})
+	target_link_libraries(v4l2-grabber ${JPEG_LIBRARY})
 endif(TURBOJPEG_FOUND)

libsrc/grabber/v4l2/V4L2Grabber.cpp

@@ -52,6 +52,8 @@ V4L2Grabber::V4L2Grabber(const QString & device
 	, _noSignalCounterThreshold(40)
 	, _noSignalThresholdColor(ColorRgb{0,0,0})
 	, _signalDetectionEnabled(true)
+	, _cecDetectionEnabled(true)
+	, _cecStandbyActivated(false)
 	, _noSignalDetected(false)
 	, _noSignalCounter(0)
 	, _x_frac_min(0.25)
@@ -1031,6 +1033,9 @@ bool V4L2Grabber::process_image(const void *p, int size)
 
 void V4L2Grabber::process_image(const uint8_t * data, int size)
 {
+	if (_cecDetectionEnabled && _cecStandbyActivated)
+		return;
+
 	Image<ColorRgb> image(_width, _height);
 
 /* ----------------------------------------------------------
@@ -1291,6 +1296,15 @@ void V4L2Grabber::setSignalDetectionEnable(bool enable)
 	}
 }
 
+void V4L2Grabber::setCecDetectionEnable(bool enable)
+{
+	if (_cecDetectionEnabled != enable)
+	{
+		_cecDetectionEnabled = enable;
+		Info(_log, QString("CEC detection is now %1").arg(enable ? "enabled" : "disabled").toLocal8Bit());
+	}
+}
+
 void V4L2Grabber::setPixelDecimation(int pixelDecimation)
 {
 	if (_pixelDecimation != pixelDecimation)
@@ -1383,3 +1397,19 @@ QStringList V4L2Grabber::getFramerates(QString devicePath)
 {
 	return _deviceProperties.value(devicePath).framerates;
 }
+
+void V4L2Grabber::handleCecEvent(CECEvent event)
+{
+	switch (event)
+	{
+		case CECEvent::On  :
+			Debug(_log,"CEC on event received");
+			_cecStandbyActivated = false;
+			return;
+		case CECEvent::Off :
+			Debug(_log,"CEC off event received");
+			_cecStandbyActivated = true;
+			return;
+		default: break;
+	}
+}

libsrc/grabber/v4l2/V4L2Wrapper.cpp

@@ -90,7 +90,22 @@ bool V4L2Wrapper::getSignalDetectionEnable()
 	return _grabber.getSignalDetectionEnabled();
 }
 
+void V4L2Wrapper::setCecDetectionEnable(bool enable)
+{
+	_grabber.setCecDetectionEnable(enable);
+}
+
+bool V4L2Wrapper::getCecDetectionEnable()
+{
+	return _grabber.getCecDetectionEnabled();
+}
+
 void V4L2Wrapper::setDeviceVideoStandard(QString device, VideoStandard videoStandard)
 {
 	_grabber.setDeviceVideoStandard(device, videoStandard);
 }
+
+void V4L2Wrapper::handleCecEvent(CECEvent event)
+{
+	_grabber.handleCecEvent(event);
+}

libsrc/hyperion/GrabberWrapper.cpp

@@ -172,6 +172,9 @@ void GrabberWrapper::handleSettingsUpdate(const settings::type& type, const QJso
 			// device framerate
 			_ggrabber->setFramerate(obj["fps"].toInt(15));
 
+			// CEC Standby
+			_ggrabber->setCecDetectionEnable(obj["cecDetection"].toBool(true));
+
 			_ggrabber->setSignalDetectionEnable(obj["signalDetection"].toBool(true));
 			_ggrabber->setSignalDetectionOffset(
 				obj["sDHOffsetMin"].toDouble(0.25),

libsrc/hyperion/Hyperion.cpp

@@ -1,4 +1,3 @@
-
 // STL includes
 #include <exception>
 #include <sstream>

libsrc/hyperion/schema/schema-grabberV4L2.json

@@ -131,13 +131,21 @@
 			"required" : true,
 			"propertyOrder" : 15
 		},
+		"cecDetection" :
+		{
+			"type" : "boolean",
+			"title" : "edt_conf_v4l2_cecDetection_title",
+			"default" : false,
+			"required" : true,
+			"propertyOrder" : 16
+		},
 		"signalDetection" :
 		{
 			"type" : "boolean",
 			"title" : "edt_conf_v4l2_signalDetection_title",
 			"default" : false,
 			"required" : true,
-			"propertyOrder" : 16
+			"propertyOrder" : 17
 		},
 		"redSignalThreshold" :
 		{
@@ -153,7 +161,7 @@
 				}
 			},
 			"required" : true,
-			"propertyOrder" : 17
+			"propertyOrder" : 18
 		},
 		"greenSignalThreshold" :
 		{
@@ -169,7 +177,7 @@
 				}
 			},
 			"required" : true,
-			"propertyOrder" : 18
+			"propertyOrder" : 19
 		},
 		"blueSignalThreshold" :
 		{
@@ -185,7 +193,7 @@
 				}
 			},
 			"required" : true,
-			"propertyOrder" : 19
+			"propertyOrder" : 20
 		},
 		"sDVOffsetMin" :
 		{
@@ -201,7 +209,7 @@
 				}
 			},
 			"required" : true,
-			"propertyOrder" : 20
+			"propertyOrder" : 21
 		},
 		"sDVOffsetMax" :
 		{
@@ -217,7 +225,7 @@
 				}
 			},
 			"required" : true,
-			"propertyOrder" : 21
+			"propertyOrder" : 22
 		},
 		"sDHOffsetMin" :
 		{
@@ -233,7 +241,7 @@
 				}
 			},
 			"required" : true,
-			"propertyOrder" : 22
+			"propertyOrder" : 23
 		},
 		"sDHOffsetMax" :
 		{
@@ -249,7 +257,7 @@
 				}
 			},
 			"required" : true,
-			"propertyOrder" : 23
+			"propertyOrder" : 24
 		}
 	},
 	"additionalProperties" : true

libsrc/utils/DefaultSignalHandler.cpp

@@ -90,7 +90,10 @@ void print_trace()
 
 	Logger* log = Logger::getInstance("CORE");
 	char ** symbols = backtrace_symbols(addresses, size);
-	for (int i = 0; i < size; ++i)
+
+	/* Skip first 2 frames as they are signal
+	 * handler and print_trace functions. */
+	for (int i = 2; i < size; ++i)
 	{
 		std::string line = "\t" + decipher_trace(symbols[i]);
 		Error(log, line.c_str());