New LUT calibration based on mp4 test videos (part I)

.gitmodules

@@ -31,3 +31,6 @@
 [submodule "external/stb"]
 	path = external/stb
 	url = https://github.com/nothings/stb.git
+[submodule "external/linalg"]
+	path = external/linalg
+	url = https://github.com/sgorsten/linalg.git

CMakeLists.txt

@@ -550,14 +550,11 @@ if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-psabi")
 		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-psabi")
 	endif()
-	if(COMPILER_SUPPORTS_CXX17 AND Qt_VERSION EQUAL 6)
-			message(STATUS "Enabling support for C++17 for QT6")
+	if(COMPILER_SUPPORTS_CXX17)
+			message(STATUS "Enabling support for C++17")
 			set(CMAKE_CXX_STANDARD 17)
-	elseif(COMPILER_SUPPORTS_CXX11)
-			message(STATUS "Enabling support for C++11")
-			set(CMAKE_CXX_STANDARD 11)
 	else()
-			message(STATUS "No support for C++11 detected. Compilation will most likely fail on your compiler")
+			message(STATUS "No support for C++17 detected. Compilation will most likely fail on your compiler")
 	endif()
 else()
 	include(CheckCXXCompilerFlag)
@@ -691,8 +688,8 @@ add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_D
 include (${CMAKE_CURRENT_SOURCE_DIR}/cmake/packages.cmake)
 
 # external targets
-if (WIN32 AND TARGET stb AND TARGET flatbuffers AND TARGET protobuf-nanopb AND TARGET lunasvg AND TARGET flatc AND TARGET qmqtt AND TARGET liblzma AND TARGET sqlite3)
-	set_target_properties(stb qmqtt flatbuffers protobuf-nanopb lunasvg flatc resources uninstall liblzma sqlite3 PROPERTIES FOLDER ExternalLibsTargets)	
+if (WIN32 AND TARGET stb AND TARGET flatbuffers AND TARGET protobuf-nanopb AND TARGET lunasvg AND TARGET flatc AND TARGET qmqtt AND TARGET liblzma AND TARGET sqlite3 AND TARGET precompiled_hyperhdr_headers)
+	set_target_properties(stb qmqtt flatbuffers protobuf-nanopb lunasvg flatc resources uninstall liblzma sqlite3 precompiled_hyperhdr_headers PROPERTIES FOLDER ExternalLibsTargets)	
 else()
 	set_target_properties(resources uninstall PROPERTIES FOLDER ExternalLibsTargets)
 endif()

external/CMakeLists.txt

@@ -78,6 +78,14 @@ if(ENABLE_WS281XPWM)
 	add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/rpi_ws281x)			
 endif()
 
+#=============================================================================
+# LINALG
+#=============================================================================
+
+add_library(linalg INTERFACE)
+target_compile_definitions(linalg INTERFACE LINALG_FORWARD_COMPATIBLE )
+target_include_directories(linalg INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/linalg")
+
 #=============================================================================
 # LUNASVG
 #=============================================================================

include/api/BaseAPI.h

@@ -1,5 +1,10 @@
 #pragma once
 
+#ifndef PCH_ENABLED
+	#include <QThread>
+	#include <memory>
+#endif
+
 #include <base/HyperHdrInstance.h>
 #include <base/HyperHdrManager.h>
 #include <base/AccessManager.h>
@@ -18,12 +23,12 @@ class BaseAPI : public QObject
 
 	struct ImageCmdData
 	{
-		int priority;
+		int priority = 0;
 		QString origin;
-		int64_t duration;
-		int width;
-		int height;
-		int scale;
+		int64_t duration = 0;
+		int width = 0;
+		int height = 0;
+		int scale = 0;
 		QString format;
 		QString imgName;
 		QString imagedata;
@@ -122,6 +127,7 @@ class BaseAPI : public QObject
 	std::shared_ptr<GrabberHelper> _systemGrabber;
 	std::shared_ptr<PerformanceCounters> _performanceCounters;
 	std::shared_ptr<DiscoveryWrapper> _discoveryWrapper;
+	std::unique_ptr<QThread, std::function<void(QThread*)>> _lutCalibratorThread;
 
 	struct {
 		bool	init = false;

include/api/CallbackAPI.h

@@ -32,7 +32,6 @@ class CallbackAPI : public BaseAPI
 	void subscribe(QJsonArray subsArr);
 
 protected:
-	std::unique_ptr<LutCalibrator> _lutCalibrator;
 	Image<ColorRgb> _liveImage;
 
 	void stopDataConnections() override = 0;
@@ -59,11 +58,12 @@ private slots:
 	void instancesListChangedHandler();
 	void tokenChangeHandler(const QVector<AccessManager::AuthDefinition>& def);
 	void signalBenchmarkUpdateHandler(int status, QString message);
-	void lutCalibrationUpdateHandler(const QJsonObject& data);
 	void performanceUpdateHandler(const QJsonObject& data);
 #ifdef ENABLE_BONJOUR
 	void signalDiscoveryFoundServiceHandler(DiscoveryRecord::Service type, QList<DiscoveryRecord> records);
 #endif
+public slots:
+	void lutCalibrationUpdateHandler(const QJsonObject& data);
 
 private:
 	QStringList _availableCommands;

include/base/Grabber.h

@@ -117,9 +117,7 @@ class Grabber : public DetectionAutomatic, public DetectionManual, protected Lut
 
 	void setSignalDetectionEnable(bool enable);
 
-	void setAutoSignalDetectionEnable(bool enable);
-
-	void benchmarkCapture(int status, QString message);
+	void setAutoSignalDetectionEnable(bool enable);	
 
 	QList<Grabber::DevicePropertiesItem> getVideoDeviceModesFullInfo(const QString& devicePath);
 
@@ -163,6 +161,8 @@ public slots:
 
 	QStringList getVideoDevices() const;
 
+	void signalSetLutHandler(MemoryBuffer<uint8_t>* lut);
+
 signals:
 	void SignalNewCapturedFrame(const Image<ColorRgb>& image);
 
@@ -268,9 +268,6 @@ public slots:
 	bool		_signalDetectionEnabled;
 	bool		_signalAutoDetectionEnabled;
 	QSemaphore  _synchro;
-
-	int			_benchmarkStatus;
-	QString		_benchmarkMessage;
 };
 
 bool sortDevicePropertiesItem(const Grabber::DevicePropertiesItem& v1, const Grabber::DevicePropertiesItem& v2);

include/base/GrabberWrapper.h

@@ -39,8 +39,6 @@ public slots:
 	void stop();
 	void revive();
 
-	void benchmarkCapture(int status, QString message);
-
 	QJsonObject getJsonInfo();
 
 	QJsonDocument startCalibration();
@@ -57,7 +55,6 @@ private slots:
 	void SignalNewVideoImage(const QString& name, const Image<ColorRgb>& image);
 	void SignalVideoStreamChanged(QString device, QString videoMode);
 	void SignalCecKeyPressed(int key);
-	void SignalBenchmarkUpdate(int status, QString message);
 	void SignalInstancePauseChanged(int instance, bool isEnabled);
 	void SignalSetNewComponentStateToAllInstances(hyperhdr::Components component, bool enable);
 	void SignalSaveCalibration(QString saveData);

include/base/HyperHdrManager.h

@@ -6,6 +6,7 @@
 #endif
 
 #include <image/ColorRgb.h>
+#include <utils/VideoBenchmark.h>
 #include <utils/Logger.h>
 #include <utils/settings.h>
 #include <utils/Components.h>
@@ -43,6 +44,8 @@ class HyperHdrManager : public QObject
 	bool areInstancesReady();
 
 public slots:
+	void handleRequestComponent(hyperhdr::Components component, int hyperHdrInd, bool listen);
+
 	void setSmoothing(int time);
 
 	void setSignalStateByCEC(bool enable);
@@ -101,6 +104,9 @@ public slots:
 
 	void SignalInstancePauseChanged(int instance, bool isEnabled);
 
+	void SignalBenchmarkUpdate(int status, QString message);
+	void SignalBenchmarkCapture(int status, QString message);
+
 private slots:
 	void handleInstanceJustStarted();
 
@@ -126,4 +132,5 @@ private slots:
 	int		_fireStarter;
 
 	QMap<quint8, PendingRequests> _pendingRequests;
+	VideoBenchmark	_videoBenchmark;
 };

include/flatbuffers/server/FlatBuffersServer.h

@@ -37,6 +37,8 @@ class FlatBuffersServer : public QObject, protected LutLoader
 	void SignalImportFromProto(int priority, int duration, const Image<ColorRgb>& image, QString clientDescription);
 
 public slots:
+	void handleRequestComponent(hyperhdr::Components component, int hyperHdrInd, bool listen);
+	void signalSetLutHandler(MemoryBuffer<uint8_t>* lut);
 	void handleSettingsUpdate(settings::type type, const QJsonDocument& config);
 	void initServer();
 	int getHdrToneMappingEnabled();
@@ -70,4 +72,6 @@ private slots:
 	QString		_userLutFile;
 	PixelFormat	_currentLutPixelFormat;
 	int			_flatbufferToneMappingMode;
+	bool		_quarterOfFrameMode;
+	bool		_active;
 };

include/image/ColorRgb.h

@@ -4,8 +4,11 @@
 	#include <sstream>
 	#include <cstdint>
 	#include <iostream>
+	#include <cmath>
 #endif
 
+
+
 struct ColorRgb
 {
 	uint8_t red = 0;
@@ -100,6 +103,11 @@ struct ColorRgb
 		return (x < 0) ? 0 : ((x > 255) ? 255 : uint8_t(x));
 	}
 
+	inline static uint8_t round(double x)
+	{
+		return (x < 0) ? 0 : ((x > 255) ? 255 : static_cast<uint8_t>(std::lround(x)));
+	}
+
 	static void rgb2hsv(uint8_t red, uint8_t green, uint8_t blue, uint16_t& _hue, uint8_t& _saturation, uint8_t& _value);
 	static void hsv2rgb(uint16_t hue, uint8_t saturation, uint8_t value, uint8_t& red, uint8_t& green, uint8_t& blue);
 	static void rgb2hsl(uint8_t red, uint8_t green, uint8_t blue, uint16_t& hue, float& saturation, float& luminance);

include/image/Image.h

@@ -2,6 +2,8 @@
 
 #include <image/ImageData.h>
 
+enum class PixelFormat;
+
 template <typename ColorSpace>
 class Image
 {
@@ -36,6 +38,10 @@ class Image
 
 	ColorSpace& operator()(unsigned x, unsigned y);
 
+	void setOriginFormat(PixelFormat pf);
+
+	PixelFormat getOriginFormat() const;
+
 	void resize(unsigned width, unsigned height);
 
 	uint8_t* rawMem();
@@ -46,6 +52,9 @@ class Image
 
 	void clear();
 
+	bool save(const char* filename) const;
+
 private:
 	std::shared_ptr<ImageData<ColorSpace>> _sharedData;
+	PixelFormat	_pixelFormat;
 };

include/lut-calibrator/BestResult.h

@@ -0,0 +1,127 @@
+#pragma once
+
+/* BestResult.h
+*
+*  MIT License
+*
+*  Copyright (c) 2020-2024 awawa-dev
+*
+*  Project homesite: https://github.com/awawa-dev/HyperHDR
+*
+*  Permission is hereby granted, free of charge, to any person obtaining a copy
+*  of this software and associated documentation files (the "Software"), to deal
+*  in the Software without restriction, including without limitation the rights
+*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+*  copies of the Software, and to permit persons to whom the Software is
+*  furnished to do so, subject to the following conditions:
+*
+*  The above copyright notice and this permission notice shall be included in all
+*  copies or substantial portions of the Software.
+
+*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+*  SOFTWARE.
+*/
+
+#ifndef PCH_ENABLED
+	#include <QJsonArray>
+	#include <QJsonObject>
+	#include <QFile>
+	#include <QDateTime>
+	#include <QThread>
+
+	#include <cmath>
+	#include <cfloat>
+	#include <climits>	
+#endif
+
+#include <linalg.h>
+#include <lut-calibrator/ColorSpace.h>
+#include <lut-calibrator/BoardUtils.h>
+#include <lut-calibrator/YuvConverter.h>
+
+using namespace linalg;
+using namespace aliases;
+using namespace ColorSpaceMath;
+using namespace BoardUtils;
+
+struct LchLists
+{
+	std::list<double4> low;
+	std::list<double4> mid;
+	std::list<double4> high;
+};
+
+struct BestResult
+{
+	YuvConverter::YUV_COEFS coef = YuvConverter::YUV_COEFS::BT601;
+	double4x4	coefMatrix;
+	double2		coefDelta;
+	int			coloredAspectMode = 0;
+	std::pair<double3, double3> colorAspect;
+	double3		aspect;
+	int			bt2020Range = 0;
+	int			altConvert = 0;
+	double3x3	altPrimariesToSrgb;
+	ColorSpaceMath::HDR_GAMMA gamma = ColorSpaceMath::HDR_GAMMA::PQ;
+	double		gammaHLG = 0;
+	double		nits = 0;
+	bool		lchEnabled = false;
+	LchLists	lchPrimaries;
+
+	struct Signal
+	{
+		YuvConverter::COLOR_RANGE range = YuvConverter::COLOR_RANGE::FULL;
+		double yRange = 0;
+		double upYLimit = 0;
+		double downYLimit = 0;
+		double yShift = 0;
+	} signal;
+
+	long long int minError = MAX_CALIBRATION_ERROR;
+
+	void serializePrimaries(std::stringstream& out) const
+	{
+		for (const auto& p : { lchPrimaries.low, lchPrimaries.mid, lchPrimaries.high })
+		{
+			out << std::endl << "\t\t\tstd::list<double4>{" << std::endl << "\t\t\t\t";
+			for (const auto& v : p)
+			{
+				out << "double4";  ColorSpaceMath::serialize(out, v); out << ", ";
+			}
+			out << std::endl << "\t\t\t}," << std::endl;
+		}
+	}
+
+	void serialize(std::stringstream& out) const
+	{
+		out.precision(12);
+		out << "/*" << std::endl;
+		out << "BestResult bestResult;" << std::endl;
+		out << "bestResult.coef = YuvConverter::YUV_COEFS(" << std::to_string(coef) << ");" << std::endl;
+		out << "bestResult.coefMatrix = double4x4"; ColorSpaceMath::serialize(out, coefMatrix); out << ";" << std::endl;
+		out << "bestResult.coefDelta = double2"; ColorSpaceMath::serialize(out, coefDelta); out << ";" << std::endl;
+		out << "bestResult.coloredAspectMode = " << std::to_string(coloredAspectMode) << ";" << std::endl;
+		out << "bestResult.colorAspect = std::pair<double3, double3>(double3";  ColorSpaceMath::serialize(out, colorAspect.first); out << ", double3";  ColorSpaceMath::serialize(out, colorAspect.second);  out << ");" << std::endl;
+		out << "bestResult.aspect = double3";  ColorSpaceMath::serialize(out, aspect); out << ";" << std::endl;
+		out << "bestResult.bt2020Range = " << std::to_string(bt2020Range) << ";" << std::endl;
+		out << "bestResult.altConvert = " << std::to_string(altConvert) << ";" << std::endl;
+		out << "bestResult.altPrimariesToSrgb = double3x3"; ColorSpaceMath::serialize(out, altPrimariesToSrgb); out << ";" << std::endl;
+		out << "bestResult.gamma = ColorSpaceMath::HDR_GAMMA(" << std::to_string(gamma) << ");" << std::endl;
+		out << "bestResult.gammaHLG = " << std::to_string(gammaHLG) << ";" << std::endl;
+		out << "bestResult.lchEnabled = " << std::to_string(lchEnabled) << ";" << std::endl;
+		out << "bestResult.lchPrimaries = LchLists{"; serializePrimaries(out); out << "\t\t};" << std::endl;
+		out << "bestResult.nits = " << std::to_string(nits) << ";" << std::endl;
+		out << "bestResult.signal.range = YuvConverter::COLOR_RANGE(" << std::to_string(signal.range) << ");" << std::endl;
+		out << "bestResult.signal.yRange = " << std::to_string(signal.yRange) << ";" << std::endl;
+		out << "bestResult.signal.upYLimit = " << std::to_string(signal.upYLimit) << ";" << std::endl;
+		out << "bestResult.signal.downYLimit = " << std::to_string(signal.downYLimit) << ";" << std::endl;
+		out << "bestResult.signal.yShift = " << std::to_string(signal.yShift) << ";" << std::endl;
+		out << "bestResult.minError = " << std::to_string(std::round(minError * 100.0) / 30000.0) << ";" << std::endl;
+		out << "*/" << std::endl;
+	}
+};