summaryrefslogtreecommitdiff
path: root/src/ipa/rpi
AgeCommit message (Expand)Author
2024-07-31libcamera: Avoid variable-length arraysLaurent Pinchart
2024-06-28libcamera: Fix maybe-uninitialized errorStefan Klug
2024-06-26ipa: rpi: Define local functions in anonymous namespaceLaurent Pinchart
2024-06-18ipa: rpi: controller: Replace Pwl::readYaml() with YamlObject::get()Laurent Pinchart
2024-06-12ipa: rpi: controller: Use libipa's Pwl classPaul Elder
2024-06-11meson: Group libipa and libipa_includes in a dependency objectLaurent Pinchart
2024-06-04ipa: rpi: Disable StatsOutputEnable control by defaultNaushir Patuck
2024-05-27ipa: rpi: Make monoSensor() accessor constLaurent Pinchart
2024-05-16ipa: rpi: Add accessor function for monoSensor_Naushir Patuck
2024-05-16ipa: rpi: Add HDR supportNaushir Patuck
2024-05-14libcamera: pipeline: Rename pipelines to a shorter nameJulien Vuillaumier
2024-05-09libcamera: Drop remaining file name from header comment blocksLaurent Pinchart
2024-05-09ipa: rpi: Fix for incorrectly reported max shutter speedNaushir Patuck
2024-05-08libcamera: Drop file name from header comment blocksLaurent Pinchart
2024-03-06ipa: rpi: cam_helper: Extend embedded data parsing to RAW14 modesNick Hollinghurst
2024-02-27libcamera: Use utils::to_underlying()Laurent Pinchart
2024-01-09ipa: rpi: vc4: data: Update tuning files for HDRDavid Plowman
2024-01-09ipa: rpi: Implement HDR controlDavid Plowman
2024-01-09ipa: rpi: vc4: Add OV64A40 tuning filesLee Jackson
2024-01-09ipa: rpi: Provide a Camera Helper for the OV64A40Jacopo Mondi
2024-01-09ipa: vc4: Implement the StatsOutputEnable vendor controlNaushir Patuck
2024-01-09ipa: rpi: awb: Add an initialValues methodDavid Plowman
2024-01-09ipa: rpi: black_level: Add an initialValues methodDavid Plowman
2024-01-09ipa: rpi: Allow the mean of an empty histogram intervalNick Hollinghurst
2024-01-05ipa: rpi: Add hardware line rate constraintsNaushir Patuck
2023-12-07meson: Tag all installed filesLaurent Pinchart
2023-11-30ipa: rpi: cac: Minor code improvements and tidyingDavid Plowman
2023-11-30ipa: rpi: agc: Fix bug where AeLocked was never getting setDavid Plowman
2023-11-30libcamera: controls: Use vendor tags for draft controls and propertiesNaushir Patuck
2023-11-22ipa: rpi: alsc: Do not allow zero colour ratio statisticsDavid Plowman
2023-10-24ipa: rpi: agc: Make AGC controls affect all channelsDavid Plowman
2023-10-24ipa: rpi: agc: Fetch AWB status in the prepare methodDavid Plowman
2023-10-24ipa: rpi: vc4: Move denoise control handling into the VC4 derived IPANaushir Patuck
2023-10-24ipa: rpi: agc: Allow AGC channels to avoid using "fast desaturation"David Plowman
2023-10-24ipa: rpi: alsc: Do not re-read the alsc.status metadataDavid Plowman
2023-10-24ipa: rpi: hdr: Add the ability to alter the LSC tableDavid Plowman
2023-10-18ipa: rpi: agc: When AGC channels are changed, start with the 1st channelNaushir Patuck
2023-10-18ipa: rpi: agc: Avoid overwriting caller's statistics pointerDavid Plowman
2023-10-18ipa: rpi: denoise: Support different denoise configurationsDavid Plowman
2023-10-18ipa: rpi: contrast: Allow adaptive contrast enhancement to be disabledDavid Plowman
2023-10-18ipa: rpi: agc: Add an AGC stable regionDavid Plowman
2023-10-18ipa: rpi: Add new algorithms for PiSPNaushir Patuck
2023-10-18ipa: rpi: Prepare AWB for PiSP supportNaushir Patuck
2023-10-18ipa: rpi: Prepare ALSC for PiSP supportNaushir Patuck
2023-10-18ipa: rpi: Add PiSP definitions to the Controller hardware descriptionNaushir Patuck
2023-10-18ipa: rpi: Add statsInline to the Controller hardware descriptionNaushir Patuck
2023-10-18ipa: rpi: Add try_lock() to RPiController::MetadataNaushir Patuck
2023-10-18mojom: pipeline: ipa: rpi: Add fields for PiSP objectsNaushir Patuck
2023-10-18ipa: rpi: Add IpaBase::platformStart() member functionNaushir Patuck
2023-10-05ipa: rpi: Avoid skipping IPAs on the first frame after the drop framesDavid Plowman
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-25 02:49:22 +0000
' href='#n380'>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 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2022, Google Inc.
 *
 * yaml-parser.cpp - YAML parser operations tests
 */

#include <array>
#include <iostream>
#include <map>
#include <string>
#include <unistd.h>

#include <libcamera/base/file.h>
#include <libcamera/base/utils.h>

#include "libcamera/internal/yaml_parser.h"

#include "test.h"

using namespace libcamera;
using namespace std;

static const string testYaml =
	"string: libcamera\n"
	"double: 3.14159\n"
	"int8_t: -100\n"
	"uint8_t: 100\n"
	"int16_t: -1000\n"
	"uint16_t: 1000\n"
	"int32_t: -100000\n"
	"uint32_t: 100000\n"
	"size: [1920, 1080]\n"
	"list:\n"
	"  - James\n"
	"  - Mary\n"
	"dictionary:\n"
	"  a: 1\n"
	"  c: 3\n"
	"  b: 2\n"
	"level1:\n"
	"  level2:\n"
	"    - [1, 2]\n"
	"    - {one: 1, two: 2}\n";

static const string invalidYaml =
	"Invalid : - YAML : - Content";

class YamlParserTest : public Test
{
protected:
	bool createFile(const string &content, string &filename)
	{
		filename = "/tmp/libcamera.test.XXXXXX";
		int fd = mkstemp(&filename.front());
		if (fd == -1)
			return false;

		int ret = write(fd, content.c_str(), content.size());
		close(fd);

		if (ret != static_cast<int>(content.size()))
			return false;

		return true;
	}

	int init()
	{
		if (!createFile(testYaml, testYamlFile_))
			return TestFail;

		if (!createFile(invalidYaml, invalidYamlFile_))
			return TestFail;

		return TestPass;
	}

	enum class Type {
		String,
		Int8,
		UInt8,
		Int16,
		UInt16,
		Int32,
		UInt32,
		Double,
		Size,
		List,
		Dictionary,
	};

	int testObjectType(const YamlObject &obj, const char *name, Type type)
	{
		bool isList = type == Type::List || type == Type::Size;
		bool isScalar = !isList && type != Type::Dictionary;
		bool isInteger8 = type == Type::Int8 || type == Type::UInt8;
		bool isInteger16 = type == Type::Int16 || type == Type::UInt16;
		bool isInteger32 = type == Type::Int32 || type == Type::UInt32;
		bool isIntegerUpTo16 = isInteger8 || isInteger16;
		bool isIntegerUpTo32 = isIntegerUpTo16 || isInteger32;
		bool isSigned = type == Type::Int8 || type == Type::Int16 ||
			        type == Type::Int32;

		if ((isScalar && !obj.isValue()) || (!isScalar && obj.isValue())) {
			std::cerr
				<< "Object " << name << " type mismatch when compared to "
				<< "value" << std::endl;
			return TestFail;
		}

		if ((isList && !obj.isList()) || (!isList && obj.isList())) {
			std::cerr
				<< "Object " << name << " type mismatch when compared to "
				<< "list" << std::endl;
			return TestFail;
		}

		if ((type == Type::Dictionary && !obj.isDictionary()) ||
		    (type != Type::Dictionary && obj.isDictionary())) {
			std::cerr
				<< "Object " << name << " type mismatch when compared to "
				<< "dictionary" << std::endl;
			return TestFail;
		}

		if (!isScalar && obj.get<std::string>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "string" << std::endl;
			return TestFail;
		}

		if (!isInteger8 && obj.get<int8_t>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "int8_t" << std::endl;
			return TestFail;
		}

		if ((!isInteger8 || isSigned) && obj.get<uint8_t>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "uint8_t" << std::endl;
			return TestFail;
		}

		if (!isIntegerUpTo16 && obj.get<int16_t>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "int16_t" << std::endl;
			return TestFail;
		}

		if ((!isIntegerUpTo16 || isSigned) && obj.get<uint16_t>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "uint16_t" << std::endl;
			return TestFail;
		}

		if (!isIntegerUpTo32 && obj.get<int32_t>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "int32_t" << std::endl;
			return TestFail;
		}

		if ((!isIntegerUpTo32 || isSigned) && obj.get<uint32_t>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "uint32_t" << std::endl;
			return TestFail;
		}

		if (!isIntegerUpTo32 && type != Type::Double && obj.get<double>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "double" << std::endl;
			return TestFail;
		}

		if (type != Type::Size && obj.get<Size>()) {
			std::cerr
				<< "Object " << name << " didn't fail to parse as "
				<< "Size" << std::endl;
			return TestFail;
		}

		return TestPass;
	}

	int testIntegerObject(const YamlObject &obj, const char *name, Type type,
			      int64_t value)
	{
		uint64_t unsignedValue = static_cast<uint64_t>(value);
		std::string strValue = std::to_string(value);
		bool isInteger8 = type == Type::Int8 || type == Type::UInt8;
		bool isInteger16 = type == Type::Int16 || type == Type::UInt16;
		bool isSigned = type == Type::Int8 || type == Type::Int16 ||
				type == Type::Int32;

		/* All integers can be parsed as strings or double. */

		if (obj.get<string>().value_or("") != strValue ||
		    obj.get<string>("") != strValue) {
			std::cerr
				<< "Object " << name << " failed to parse as "
				<< "string" << std::endl;
			return TestFail;
		}

		if (obj.get<double>().value_or(0.0) != value ||
		    obj.get<double>(0.0) != value) {
			std::cerr
				<< "Object " << name << " failed to parse as "
				<< "double" << std::endl;
			return TestFail;
		}

		if (isInteger8) {
			if (obj.get<int8_t>().value_or(0) != value ||
			    obj.get<int8_t>(0) != value) {
				std::cerr
					<< "Object " << name << " failed to parse as "
					<< "int8_t" << std::endl;
				return TestFail;
			}
		}

		if (isInteger8 && !isSigned) {
			if (obj.get<uint8_t>().value_or(0) != unsignedValue ||
			    obj.get<uint8_t>(0) != unsignedValue) {
				std::cerr
					<< "Object " << name << " failed to parse as "
					<< "uint8_t" << std::endl;
				return TestFail;
			}
		}

		if (isInteger8 || isInteger16) {
			if (obj.get<int16_t>().value_or(0) != value ||
			    obj.get<int16_t>(0) != value) {
				std::cerr
					<< "Object " << name << " failed to parse as "
					<< "int16_t" << std::endl;
				return TestFail;
			}
		}

		if ((isInteger8 || isInteger16) && !isSigned) {
			if (obj.get<uint16_t>().value_or(0) != unsignedValue ||
			    obj.get<uint16_t>(0) != unsignedValue) {
				std::cerr
					<< "Object " << name << " failed to parse as "
					<< "uint16_t" << std::endl;
				return TestFail;
			}
		}

		if (obj.get<int32_t>().value_or(0) != value ||
		    obj.get<int32_t>(0) != value) {
			std::cerr
				<< "Object " << name << " failed to parse as "
				<< "int32_t" << std::endl;
			return TestFail;
		}

		if (!isSigned) {
			if (obj.get<uint32_t>().value_or(0) != unsignedValue ||
			    obj.get<uint32_t>(0) != unsignedValue) {
				std::cerr
					<< "Object " << name << " failed to parse as "
					<< "uint32_t" << std::endl;
				return TestFail;
			}
		}

		return TestPass;
	}

	int run()
	{
		/* Test invalid YAML file */
		File file{ invalidYamlFile_ };
		if (!file.open(File::OpenModeFlag::ReadOnly)) {
			cerr << "Fail to open invalid YAML file" << std::endl;
			return TestFail;
		}

		std::unique_ptr<YamlObject> root = YamlParser::parse(file);
		if (root) {
			cerr << "Invalid YAML file parse successfully" << std::endl;
			return TestFail;
		}

		/* Test YAML file */
		file.close();
		file.setFileName(testYamlFile_);
		if (!file.open(File::OpenModeFlag::ReadOnly)) {
			cerr << "Fail to open test YAML file" << std::endl;
			return TestFail;
		}

		root = YamlParser::parse(file);

		if (!root) {
			cerr << "Fail to parse test YAML file: " << std::endl;
			return TestFail;
		}

		if (!root->isDictionary()) {
			cerr << "YAML root is not dictionary" << std::endl;
			return TestFail;
		}

		std::vector<const char *> rootElemNames = {
			"string", "double", "int8_t", "uint8_t", "int16_t",
			"uint16_t", "int32_t", "uint32_t", "size", "list",
			"dictionary", "level1",
		};

		for (const char *name : rootElemNames) {
			if (!root->contains(name)) {
				cerr << "Missing " << name << " object in YAML root"
				     << std::endl;
				return TestFail;
			}
		}

		/* Test string object */
		auto &strObj = (*root)["string"];

		if (testObjectType(strObj, "string", Type::String) != TestPass)
			return TestFail;

		if (strObj.get<string>().value_or("") != "libcamera" ||
		    strObj.get<string>("") != "libcamera") {
			cerr << "String object parse as wrong content" << std::endl;
			return TestFail;
		}

		/* Test int8_t object */
		auto &int8Obj = (*root)["int8_t"];

		if (testObjectType(int8Obj, "int8_t", Type::Int8) != TestPass)
			return TestFail;

		if (testIntegerObject(int8Obj, "int8_t", Type::Int8, -100) != TestPass)
			return TestFail;

		/* Test uint8_t object */
		auto &uint8Obj = (*root)["uint8_t"];

		if (testObjectType(uint8Obj, "uint8_t", Type::UInt8) != TestPass)
			return TestFail;

		if (testIntegerObject(uint8Obj, "uint8_t", Type::UInt8, 100) != TestPass)
			return TestFail;

		/* Test int16_t object */
		auto &int16Obj = (*root)["int16_t"];

		if (testObjectType(int16Obj, "int16_t", Type::Int16) != TestPass)
			return TestFail;

		if (testIntegerObject(int16Obj, "int16_t", Type::Int16, -1000) != TestPass)
			return TestFail;

		/* Test uint16_t object */
		auto &uint16Obj = (*root)["uint16_t"];

		if (testObjectType(uint16Obj, "uint16_t", Type::UInt16) != TestPass)
			return TestFail;

		if (testIntegerObject(uint16Obj, "uint16_t", Type::UInt16, 1000) != TestPass)
			return TestFail;

		/* Test int32_t object */
		auto &int32Obj = (*root)["int32_t"];

		if (testObjectType(int32Obj, "int32_t", Type::Int32) != TestPass)
			return TestFail;

		if (testIntegerObject(int32Obj, "int32_t", Type::Int32, -100000) != TestPass)
			return TestFail;

		/* Test uint32_t object */
		auto &uint32Obj = (*root)["uint32_t"];

		if (testObjectType(uint32Obj, "uint32_t", Type::UInt32) != TestPass)
			return TestFail;

		if (testIntegerObject(uint32Obj, "uint32_t", Type::UInt32, 100000) != TestPass)
			return TestFail;

		/* Test double value */
		auto &doubleObj = (*root)["double"];

		if (testObjectType(doubleObj, "double", Type::Double) != TestPass)
			return TestFail;

		if (doubleObj.get<string>().value_or("") != "3.14159" ||
		    doubleObj.get<string>("") != "3.14159") {
			cerr << "Double object fail to parse as string" << std::endl;
			return TestFail;
		}

		if (doubleObj.get<double>().value_or(0.0) != 3.14159 ||
		    doubleObj.get<double>(0.0) != 3.14159) {
			cerr << "Double object parse as wrong value" << std::endl;
			return TestFail;
		}

		/* Test Size value */
		auto &sizeObj = (*root)["size"];

		if (testObjectType(sizeObj, "size", Type::Size) != TestPass)
			return TestFail;

		if (sizeObj.get<Size>().value_or(Size(0, 0)) != Size(1920, 1080) ||
		    sizeObj.get<Size>(Size(0, 0)) != Size(1920, 1080)) {
			cerr << "Size object parse as wrong value" << std::endl;
			return TestFail;
		}

		/* Test list object */
		auto &listObj = (*root)["list"];

		if (testObjectType(listObj, "list", Type::List) != TestPass)
			return TestFail;

		static constexpr std::array<const char *, 2> listValues{
			"James",
			"Mary",
		};

		if (listObj.size() != listValues.size()) {
			cerr << "List object parse with wrong size" << std::endl;
			return TestFail;
		}

		unsigned int i = 0;
		for (auto &elem : listObj.asList()) {
			if (i >= listValues.size()) {
				std::cerr << "Too many elements in list during iteration"
					  << std::endl;
				return TestFail;
			}

			std::string value = listValues[i];

			if (&elem != &listObj[i]) {
				std::cerr << "List element " << i << " has wrong address"
					  << std::endl;
				return TestFail;
			}

			if (elem.get<std::string>("") != value) {
				std::cerr << "List element " << i << " has wrong value"
					  << std::endl;
				return TestFail;
			}

			i++;
		}

		/* Test dictionary object */
		auto &dictObj = (*root)["dictionary"];

		if (testObjectType(dictObj, "dictionary", Type::Dictionary) != TestPass)
			return TestFail;

		static constexpr std::array<std::pair<const char *, int>, 3> dictValues{ {
			{ "a", 1 },
			{ "c", 3 },
			{ "b", 2 },
		} };

		size_t dictSize = dictValues.size();

		if (dictObj.size() != dictSize) {
			cerr << "Dictionary object has wrong size" << std::endl;
			return TestFail;
		}

		i = 0;
		for (const auto &[key, elem] : dictObj.asDict()) {
			if (i >= dictSize) {
				std::cerr << "Too many elements in dictionary during iteration"
					  << std::endl;
				return TestFail;
			}

			const auto &item = dictValues[i];
			if (item.first != key) {
				std::cerr << "Dictionary key " << i << " has wrong value"
					  << std::endl;
				return TestFail;
			}

			if (&elem != &dictObj[key]) {
				std::cerr << "Dictionary element " << i << " has wrong address"
					  << std::endl;
				return TestFail;
			}

			if (elem.get<int32_t>(0) != item.second) {
				std::cerr << "Dictionary element " << i << " has wrong value"
					  << std::endl;
				return TestFail;
			}

			i++;
		}

		/* Make sure utils::map_keys() works on the adapter. */
		(void)utils::map_keys(dictObj.asDict());

		/* Test leveled objects */
		auto &level1Obj = (*root)["level1"];

		if (!level1Obj.isDictionary()) {
			cerr << "level1 object fail to parse as Dictionary" << std::endl;
			return TestFail;
		}

		auto &level2Obj = level1Obj["level2"];

		if (!level2Obj.isList() || level2Obj.size() != 2) {
			cerr << "level2 object should be 2 element list" << std::endl;
			return TestFail;
		}

		auto &firstElement = level2Obj[0];
		if (!firstElement.isList() ||
		    firstElement.size() != 2 ||
		    firstElement[0].get<int32_t>(0) != 1 ||
		    firstElement[1].get<int32_t>(0) != 2) {
			cerr << "The first element of level2 object fail to parse as integer list" << std::endl;
			return TestFail;
		}

		const auto &values = firstElement.getList<uint16_t>();
		if (!values || values->size() != 2 || (*values)[0] != 1 || (*values)[1] != 2) {
			cerr << "getList() failed to return correct vector" << std::endl;
			return TestFail;
		}

		auto &secondElement = level2Obj[1];
		if (!secondElement.isDictionary() ||
		    !secondElement.contains("one") ||
		    !secondElement.contains("two") ||
		    secondElement["one"].get<int32_t>(0) != 1 ||
		    secondElement["two"].get<int32_t>(0) != 2) {
			cerr << "The second element of level2 object fail to parse as dictionary" << std::endl;
			return TestFail;
		}

		return TestPass;
	}

	void cleanup()
	{
		unlink(testYamlFile_.c_str());
		unlink(invalidYamlFile_.c_str());
	}

private:
	std::string testYamlFile_;
	std::string invalidYamlFile_;
};

TEST_REGISTER(YamlParserTest)
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-25 02:49:21 +0000