summaryrefslogtreecommitdiff
path: root/utils/tuning
AgeCommit message (Expand)Author
2024-12-20utils: tuning: rkisp1: Replace static AWB with new AWB moduleStefan Klug
2024-12-20libtuning: Add initial AWB moduleStefan Klug
2024-12-20libtuning: Fix access to color member in ctt_awb.awb()Stefan Klug
2024-12-20libtuning: Remove the Cam object from ctt_awb.awb()Stefan Klug
2024-12-20libtuning: Use logging framework in ctt_awb.awb()Stefan Klug
2024-12-18utils: tuning: libtuning: Fix tuning for non RGGB RAWsStefan Klug
2024-12-04libipa: agc_mean_luminance: Rename yaml key from exposure-time to exposureTimeStefan Klug
2024-11-26libcamera: Rename "shutter speed" to "exposure time"Laurent Pinchart
2024-08-14utils: tuning: Change Tuner.add() to accept a list of modulesStefan Klug
2024-08-14utils: tuning: rkisp1: Clean up tuner constructionStefan Klug
2024-07-05libtuning: agc: rkisp1: Increase y-targetStefan Klug
2024-07-05libtuning: lsc: Prevent negative valuesStefan Klug
2024-07-05libtuning: lsc: rkisp1: Do not calculate ratios to greenStefan Klug
2024-07-05tuning: rkisp1: Add some static modulesStefan Klug
2024-07-05libtuning: Add static moduleStefan Klug
2024-07-05libtuning: Only warn if processing returns NoneStefan Klug
2024-07-05libtuning: Handle cases, where no lsc tuning images are presentStefan Klug
2024-07-05libtuning: modules: Add initial CCM modulePaul Elder
2024-07-05libtuning: Remove need for Cam object from ccmStefan Klug
2024-07-05libtuning: Use the color member of the Image classStefan Klug
2024-07-05libtuning: lsc: rkisp1: Clip lsc values to valid rangeStefan Klug
2024-07-05libtuning: Be a bit more verboseStefan Klug
2024-07-05libtuning: Reactivate macbeth locatorStefan Klug
2024-07-05libtuning: Implement a minimal yaml parserStefan Klug
2024-07-05libtuning: Improve filename parsingStefan Klug
2024-07-05libtuning: Fix visualize_macbeth_chart()Stefan Klug
2024-07-05libtuning: Migrate prints to python logging frameworkStefan Klug
2024-07-05libtuning: Fix importsStefan Klug
2024-07-05utils: tuning: Add requirements file and update readmeStefan Klug
2024-07-05libtuning: Copy visualize_macbeth_chart from raspberry piStefan Klug
2024-07-05libtuning: Copy files from raspberrypiStefan Klug
2024-07-05libtuning: Fix reference imageStefan Klug
2024-07-05libtuning: Backport improvements in MacBeth search reliabilityStefan Klug
2024-06-29utils: libtuning: Correct GBRG Image parsingDaniel Scally
2024-06-14utils: tuning: rkisp1: Add skeletal AGC to the rkisp1 tuning scriptPaul Elder
2024-06-14utils: libtuning: modules: Add skeletal AGC modulePaul Elder
2024-05-08libcamera: Drop file name from header comment blocksLaurent Pinchart
2024-03-19utils: tuning: readme: Improve names of dependency packagesPaul Elder
2022-11-25utils: tuning: Add tuning script for rkisp1Paul Elder
2022-11-25utils: tuning: Add alsc-only libtuning raspberrypi tuning scriptPaul Elder
2022-11-25utils: libtuning: generators: Add yaml outputPaul Elder
2022-11-25utils: libtuning: parsers: Add yaml parserPaul Elder
2022-11-25utils: libtuning: generators: Add raspberrypi outputPaul Elder
2022-11-25utils: libtuning: parsers: Add raspberrypi parserPaul Elder
2022-11-25utils: libtuning: modules: alsc: Add rkisp1 LSC modulePaul Elder
2022-11-25utils: libtuning: modules: alsc: Add raspberrypi ALSC modulePaul Elder
2022-11-25utils: libtuning: modules: Add base LSC modulePaul Elder
2022-11-25utils: tuning: libtuning: Implement extensible components of libtuningPaul Elder
2022-11-25utils: tuning: libtuning: Implement math helpersPaul Elder
2022-11-25utils: tuning: libtuning: Implement the core of libtuningPaul Elder
generated by cgit v1.2.1 (git 2.18.0) at 2025-04-24 11:19:03 +0000
' href='#n343'>343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2020, Google Inc.
 *
 * ipa_data_serializer_test.cpp - Test serializing/deserializing with IPADataSerializer
 */

#include <algorithm>
#include <cxxabi.h>
#include <fcntl.h>
#include <iostream>
#include <limits>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <tuple>
#include <unistd.h>
#include <vector>

#include <libcamera/base/thread.h>
#include <libcamera/base/timer.h>

#include "libcamera/internal/ipa_data_serializer.h"

#include "serialization_test.h"
#include "test.h"

using namespace std;
using namespace libcamera;

static const ControlInfoMap Controls = ControlInfoMap({
		{ &controls::AeEnable, ControlInfo(false, true) },
		{ &controls::ExposureTime, ControlInfo(0, 999999) },
		{ &controls::AnalogueGain, ControlInfo(1.0f, 32.0f) },
		{ &controls::ColourGains, ControlInfo(0.0f, 32.0f) },
		{ &controls::Brightness, ControlInfo(-1.0f, 1.0f) },
	}, controls::controls);

namespace libcamera {

static bool operator==(const ControlInfoMap &lhs, const ControlInfoMap &rhs)
{
	return SerializationTest::equals(lhs, rhs);
}

} /* namespace libcamera */

template<typename T>
int testPodSerdes(T in)
{
	std::vector<uint8_t> buf;
	std::vector<SharedFD> fds;

	std::tie(buf, fds) = IPADataSerializer<T>::serialize(in);
	T out = IPADataSerializer<T>::deserialize(buf, fds);
	if (in == out)
		return TestPass;

	char *name = abi::__cxa_demangle(typeid(T).name(), nullptr,
					 nullptr, nullptr);
	cerr << "Deserialized " << name << " doesn't match original" << endl;
	free(name);
	return TestFail;
}

template<typename T>
int testVectorSerdes(const std::vector<T> &in,
		     ControlSerializer *cs = nullptr)
{
	std::vector<uint8_t> buf;
	std::vector<SharedFD> fds;

	std::tie(buf, fds) = IPADataSerializer<std::vector<T>>::serialize(in, cs);
	std::vector<T> out = IPADataSerializer<std::vector<T>>::deserialize(buf, fds, cs);
	if (in == out)
		return TestPass;

	char *name = abi::__cxa_demangle(typeid(T).name(), nullptr,
					 nullptr, nullptr);
	cerr << "Deserialized std::vector<" << name
	     << "> doesn't match original" << endl;
	free(name);
	return TestFail;
}

template<typename K, typename V>
int testMapSerdes(const std::map<K, V> &in,
		  ControlSerializer *cs = nullptr)
{
	std::vector<uint8_t> buf;
	std::vector<SharedFD> fds;

	std::tie(buf, fds) = IPADataSerializer<std::map<K, V>>::serialize(in, cs);
	std::map<K, V> out = IPADataSerializer<std::map<K, V>>::deserialize(buf, fds, cs);
	if (in == out)
		return TestPass;

	char *nameK = abi::__cxa_demangle(typeid(K).name(), nullptr,
					  nullptr, nullptr);
	char *nameV = abi::__cxa_demangle(typeid(V).name(), nullptr,
					  nullptr, nullptr);
	cerr << "Deserialized std::map<" << nameK << ", " << nameV
	     << "> doesn't match original" << endl;
	free(nameK);
	free(nameV);
	return TestFail;
}

class IPADataSerializerTest : public CameraTest, public Test
{
public:
	IPADataSerializerTest()
		: CameraTest("platform/vimc.0 Sensor B")
	{
	}

protected:
	int init() override
	{
		return status_;
	}

	int run() override
	{
		int ret;

		ret = testControls();
		if (ret != TestPass)
			return ret;

		ret = testVector();
		if (ret != TestPass)
			return ret;

		ret = testMap();
		if (ret != TestPass)
			return ret;

		ret = testPod();
		if (ret != TestPass)
			return ret;

		return TestPass;
	}

private:
	ControlList generateControlList(const ControlInfoMap &infoMap)
	{
		/* Create a control list with three controls. */
		ControlList list(infoMap);

		list.set(controls::Brightness, 0.5f);
		list.set(controls::Contrast, 1.2f);
		list.set(controls::Saturation, 0.2f);

		return list;
	}

	int testControls()
	{
		ControlSerializer cs(ControlSerializer::Role::Proxy);

		const ControlInfoMap &infoMap = camera_->controls();
		ControlList list = generateControlList(infoMap);

		std::vector<uint8_t> infoMapBuf;
		std::tie(infoMapBuf, std::ignore) =
			IPADataSerializer<ControlInfoMap>::serialize(infoMap, &cs);

		std::vector<uint8_t> listBuf;
		std::tie(listBuf, std::ignore) =
			IPADataSerializer<ControlList>::serialize(list, &cs);

		const ControlInfoMap infoMapOut =
			IPADataSerializer<ControlInfoMap>::deserialize(infoMapBuf, &cs);

		ControlList listOut = IPADataSerializer<ControlList>::deserialize(listBuf, &cs);

		if (!SerializationTest::equals(infoMap, infoMapOut)) {
			cerr << "Deserialized map doesn't match original" << endl;
			return TestFail;
		}

		if (!SerializationTest::equals(list, listOut)) {
			cerr << "Deserialized list doesn't match original" << endl;
			return TestFail;
		}

		return TestPass;
	}

	int testVector()
	{
		ControlSerializer cs(ControlSerializer::Role::Proxy);

		/*
		 * We don't test SharedFD serdes because it dup()s, so we
		 * can't check for equality.
		 */
		std::vector<uint8_t>  vecUint8  = { 1, 2, 3, 4, 5, 6 };
		std::vector<uint16_t> vecUint16 = { 1, 2, 3, 4, 5, 6 };
		std::vector<uint32_t> vecUint32 = { 1, 2, 3, 4, 5, 6 };
		std::vector<uint64_t> vecUint64 = { 1, 2, 3, 4, 5, 6 };
		std::vector<int8_t>   vecInt8   = { 1, 2, 3, -4, 5, -6 };
		std::vector<int16_t>  vecInt16  = { 1, 2, 3, -4, 5, -6 };
		std::vector<int32_t>  vecInt32  = { 1, 2, 3, -4, 5, -6 };
		std::vector<int64_t>  vecInt64  = { 1, 2, 3, -4, 5, -6 };
		std::vector<float>    vecFloat  = { 1.1, 2.2, 3.3, -4.4, 5.5, -6.6 };
		std::vector<double>   vecDouble = { 1.1, 2.2, 3.3, -4.4, 5.5, -6.6 };
		std::vector<bool>     vecBool   = { true, true, false, false, true, false };
		std::vector<std::string>   vecString = { "foo", "bar", "baz" };
		std::vector<ControlInfoMap> vecControlInfoMap = {
			camera_->controls(),
			Controls,
		};

		std::vector<uint8_t> buf;
		std::vector<SharedFD> fds;

		if (testVectorSerdes(vecUint8) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecUint16) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecUint32) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecUint64) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecInt8) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecInt16) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecInt32) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecInt64) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecFloat) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecDouble) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecBool) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecString) != TestPass)
			return TestFail;

		if (testVectorSerdes(vecControlInfoMap, &cs) != TestPass)
			return TestFail;

		return TestPass;
	}

	int testMap()
	{
		ControlSerializer cs(ControlSerializer::Role::Proxy);

		/*
		 * Realistically, only string and integral keys.
		 * Test simple, complex, and nested compound value.
		 */
		std::map<uint64_t, std::string> mapUintStr =
			{ { 101, "foo" }, { 102, "bar" }, { 103, "baz" } };
		std::map<int64_t, std::string> mapIntStr =
			{ { 101, "foo" }, { -102, "bar" }, { -103, "baz" } };
		std::map<std::string, std::string> mapStrStr =
			{ { "a", "foo" }, { "b", "bar" }, { "c", "baz" } };
		std::map<uint64_t, ControlInfoMap> mapUintCIM =
			{ { 201, camera_->controls() }, { 202, Controls } };
		std::map<int64_t, ControlInfoMap> mapIntCIM =
			{ { 201, camera_->controls() }, { -202, Controls } };
		std::map<std::string, ControlInfoMap> mapStrCIM =
			{ { "a", camera_->controls() }, { "b", Controls } };
		std::map<uint64_t, std::vector<uint8_t>> mapUintBVec =
			{ { 301, { 1, 2, 3 } }, { 302, { 4, 5, 6 } }, { 303, { 7, 8, 9 } } };
		std::map<int64_t, std::vector<uint8_t>> mapIntBVec =
			{ { 301, { 1, 2, 3 } }, { -302, { 4, 5, 6} }, { -303, { 7, 8, 9 } } };
		std::map<std::string, std::vector<uint8_t>> mapStrBVec =
			{ { "a", { 1, 2, 3 } }, { "b", { 4, 5, 6 } }, { "c", { 7, 8, 9 } } };

		std::vector<uint8_t> buf;
		std::vector<SharedFD> fds;

		if (testMapSerdes(mapUintStr) != TestPass)
			return TestFail;

		if (testMapSerdes(mapIntStr) != TestPass)
			return TestFail;

		if (testMapSerdes(mapStrStr) != TestPass)
			return TestFail;

		if (testMapSerdes(mapUintCIM, &cs) != TestPass)
			return TestFail;

		if (testMapSerdes(mapIntCIM,  &cs) != TestPass)
			return TestFail;

		if (testMapSerdes(mapStrCIM,  &cs) != TestPass)
			return TestFail;

		if (testMapSerdes(mapUintBVec) != TestPass)
			return TestFail;

		if (testMapSerdes(mapIntBVec) != TestPass)
			return TestFail;

		if (testMapSerdes(mapStrBVec) != TestPass)
			return TestFail;

		return TestPass;
	}

	int testPod()
	{
		uint32_t u32min = std::numeric_limits<uint32_t>::min();
		uint32_t u32max = std::numeric_limits<uint32_t>::max();
		uint32_t u32one = 1;
		int32_t  i32min = std::numeric_limits<int32_t>::min();
		int32_t  i32max = std::numeric_limits<int32_t>::max();
		int32_t  i32one = 1;

		uint64_t u64min = std::numeric_limits<uint64_t>::min();
		uint64_t u64max = std::numeric_limits<uint64_t>::max();
		uint64_t u64one = 1;
		int64_t  i64min = std::numeric_limits<int64_t>::min();
		int64_t  i64max = std::numeric_limits<int64_t>::max();
		int64_t  i64one = 1;

		float  flow = std::numeric_limits<float>::lowest();
		float  fmin = std::numeric_limits<float>::min();
		float  fmax = std::numeric_limits<float>::max();
		float  falmostOne = 1 + 1.0e-37;
		double dlow = std::numeric_limits<double>::lowest();
		double dmin = std::numeric_limits<double>::min();
		double dmax = std::numeric_limits<double>::max();
		double dalmostOne = 1 + 1.0e-307;

		bool t = true;
		bool f = false;

		std::stringstream ss;
		for (unsigned int i = 0; i < (1 << 11); i++)
			ss << "0123456789";

		std::string strLong = ss.str();
		std::string strEmpty = "";

		std::vector<uint8_t> buf;
		std::vector<SharedFD> fds;

		if (testPodSerdes(u32min) != TestPass)
			return TestFail;

		if (testPodSerdes(u32max) != TestPass)
			return TestFail;

		if (testPodSerdes(u32one) != TestPass)
			return TestFail;

		if (testPodSerdes(i32min) != TestPass)
			return TestFail;

		if (testPodSerdes(i32max) != TestPass)
			return TestFail;

		if (testPodSerdes(i32one) != TestPass)
			return TestFail;

		if (testPodSerdes(u64min) != TestPass)
			return TestFail;

		if (testPodSerdes(u64max) != TestPass)
			return TestFail;

		if (testPodSerdes(u64one) != TestPass)
			return TestFail;

		if (testPodSerdes(i64min) != TestPass)
			return TestFail;

		if (testPodSerdes(i64max) != TestPass)
			return TestFail;

		if (testPodSerdes(i64one) != TestPass)
			return TestFail;

		if (testPodSerdes(flow) != TestPass)
			return TestFail;

		if (testPodSerdes(fmin) != TestPass)
			return TestFail;

		if (testPodSerdes(fmax) != TestPass)
			return TestFail;

		if (testPodSerdes(falmostOne) != TestPass)
			return TestFail;

		if (testPodSerdes(dlow) != TestPass)
			return TestFail;

		if (testPodSerdes(dmin) != TestPass)
			return TestFail;

		if (testPodSerdes(dmax) != TestPass)
			return TestFail;

		if (testPodSerdes(dalmostOne) != TestPass)
			return TestFail;

		if (testPodSerdes(t) != TestPass)
			return TestFail;

		if (testPodSerdes(f) != TestPass)
			return TestFail;

		if (testPodSerdes(strLong) != TestPass)
			return TestFail;

		if (testPodSerdes(strEmpty) != TestPass)
			return TestFail;

		return TestPass;
	}
};

TEST_REGISTER(IPADataSerializerTest)
generated by cgit v1.2.1 (git 2.18.0) at 2025-04-24 11:19:03 +0000