src/ipa/rpi/controller/device_status.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/* SPDX-License-Identifier: BSD-2-Clause */
/*
 * Copyright (C) 2019-2021, Raspberry Pi Ltd
 *
 * device (image sensor) status
 */
#pragma once

#include <iostream>
#include <optional>

#include <libcamera/base/utils.h>

/*
 * Definition of "device metadata" which stores things like shutter time and
 * analogue gain that downstream control algorithms will want to know.
 */

struct DeviceStatus {
	DeviceStatus()
		: shutterSpeed(std::chrono::seconds(0)), frameLength(0),
		  lineLength(std::chrono::seconds(0)), analogueGain(0.0)
	{
	}

	friend std::ostream &operator<<(std::ostream &out, const DeviceStatus &d);

	/* time shutter is open */
	libcamera::utils::Duration shutterSpeed;
	/* frame length given in number of lines */
	uint32_t frameLength;
	/* line length for the current frame */
	libcamera::utils::Duration lineLength;
	double analogueGain;
	/* 1.0/distance-in-metres */
	std::optional<double> lensPosition;
	/* 1/f so that brightness quadruples when this doubles */
	std::optional<double> aperture;
	/* proportional to brightness with 0 = no flash, 1 = maximum flash */
	std::optional<double> flashIntensity;
	/* Sensor reported temperature value (in degrees) */
	std::optional<double> sensorTemperature;
};
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2018, Google Inc.
 *
 * utils.cpp - Miscellaneous utility tests
 */

#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>

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

#include <libcamera/geometry.h>

#include "test.h"

using namespace std;
using namespace libcamera;
using namespace std::literals::chrono_literals;

class UtilsTest : public Test
{
protected:
	int testDirname()
	{
		static const std::vector<std::string> paths = {
			"",
			"///",
			"/bin",
			"/usr/bin",
			"//etc////",
			"//tmp//d//",
			"current_file",
			"./current_file",
			"./current_dir/",
			"current_dir/",
		};

		static const std::vector<std::string> expected = {
			".",
			"/",
			"/",
			"/usr",
			"/",
			"//tmp",
			".",
			".",
			".",
			".",
		};

		std::vector<std::string> results;

		for (const auto &path : paths)
			results.push_back(utils::dirname(path));

		if (results != expected) {
			cerr << "utils::dirname() tests failed" << endl;

			cerr << "expected: " << endl;
			for (const auto &path : expected)
				cerr << "\t" << path << endl;

			cerr << "results: " << endl;
			for (const auto &path : results)
				cerr << "\t" << path << endl;

			return TestFail;
		}

		return TestPass;
	}

	int testEnumerate()
	{
		std::vector<unsigned int> integers{ 1, 2, 3, 4, 5 };
		unsigned int i = 0;

		for (auto [index, value] : utils::enumerate(integers)) {
			if (index != i || value != i + 1) {
				cerr << "utils::enumerate(<vector>) test failed: i=" << i
				     << ", index=" << index << ", value=" << value
				     << std::endl;
				return TestFail;
			}

			/* Verify that we can modify the value. */
			--value;
			++i;
		}

		if (integers != std::vector<unsigned int>{ 0, 1, 2, 3, 4 }) {
			cerr << "Failed to modify container in enumerated range loop" << endl;
			return TestFail;
		}

		Span<const unsigned int> span{ integers };
		i = 0;

		for (auto [index, value] : utils::enumerate(span)) {
			if (index != i || value != i) {
				cerr << "utils::enumerate(<span>) test failed: i=" << i
				     << ", index=" << index << ", value=" << value
				     << std::endl;
				return TestFail;
			}

			++i;
		}

		const unsigned int array[] = { 0, 2, 4, 6, 8 };
		i = 0;

		for (auto [index, value] : utils::enumerate(array)) {
			if (index != i || value != i * 2) {
				cerr << "utils::enumerate(<array>) test failed: i=" << i
				     << ", index=" << index << ", value=" << value
				     << std::endl;
				return TestFail;
			}

			++i;
		}

		return TestPass;
	}

	int testDuration()
	{
		std::ostringstream os;
		utils::Duration exposure;
		double ratio;

		exposure = 25ms + 25ms;
		if (exposure.get<std::micro>() != 50000.0) {
			cerr << "utils::Duration failed to return microsecond count";
			return TestFail;
		}

		exposure = 1.0s / 4;
		if (exposure != 250ms) {
			cerr << "utils::Duration failed scalar divide test";
			return TestFail;
		}

		exposure = 5000.5us;
		if (!exposure) {
			cerr << "utils::Duration failed boolean test";
			return TestFail;
		}

		os << exposure;
		if (os.str() != "5000.50us") {
			cerr << "utils::Duration operator << failed";
			return TestFail;
		}

		exposure = 100ms;
		ratio = exposure / 25ms;
		if (ratio != 4.0) {
			cerr << "utils::Duration failed ratio test";
			return TestFail;
		}

		return TestPass;
	}