/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2020, Google Inc. * Copyright (C) 2021, Collabora Ltd. * * main.cpp - lc-compliance - The libcamera compliance tool */ #include #include #include #include #include #include "environment.h" #include "../cam/options.h" using namespace libcamera; enum { OptCamera = 'c', OptList = 'l', OptFilter = 'f', OptHelp = 'h', }; /* * Make asserts act like exceptions, otherwise they only fail (or skip) the * current function. From gtest documentation: * https://google.github.io/googletest/advanced.html#asserting-on-subroutines-with-an-exception */ class ThrowListener : public testing::EmptyTestEventListener { void OnTestPartResult(const testing::TestPartResult &result) override { if (result.type() == testing::TestPartResult::kFatalFailure || result.type() == testing::TestPartResult::kSkip) throw testing::AssertionException(result); } }; static void listCameras(CameraManager *cm) { for (const std::shared_ptr &cam : cm->cameras()) std::cout << "- " << cam.get()->id() << std::endl; } static int initCamera(CameraManager *cm, OptionsParser::Options options) { std::shared_ptr camera; int ret = cm->start(); if (ret) { std::cout << "Failed to start camera manager: " << strerror(-ret) << std::endl; return ret; } if (!options.isSet(OptCamera)) { std::cout << "No camera specified, available cameras:" << std::endl; listCameras(cm); return -ENODEV; } const std::string &cameraId = options[OptCamera]; camera = cm->get(cameraId); if (!camera) { std::cout << "Camera " << cameraId << " not found, available cameras:" << std::endl; listCameras(cm); return -ENODEV; } Environment::get()->setup(cm, cameraId); std::cout << "Using camera " << cameraId << std::endl; return 0; } static int initGtestParameters(char *arg0, OptionsParser::Options options) { const std::map gtestFlags = { { "list", "--gtest_list_tests" }, { "filter", "--gtest_filter" } }; int argc = 0; std::string filterParam; /* * +2 to have space for both the 0th argument that is needed but not * used and the null at the end. */ char **argv = new char *[(gtestFlags.size() + 2)]; if (!argv) return -ENOMEM; argv[0] = arg0; argc++; if (options.isSet(OptList)) { argv[argc] = const_cast(gtestFlags.at("list").c_str()); argc++; } if (options.isSet(OptFilter)) { /* * The filter flag needs to be passed as a single parameter, in * the format --gtest_filter=filterStr */ filterParam = gtestFlags.at("filter") + "=" + static_cast(options[OptFilter]); argv[argc] = const_cast(filterParam.c_str()); argc++; } argv[argc] = nullptr; ::testing::InitGoogleTest(&argc, argv); delete[] argv; return 0; } static int initGtest(char *arg0, OptionsParser::Options options) { int ret = initGtestParameters(arg0, options); if (ret) return ret; testing::UnitTest::GetInstance()->listeners().Append(new ThrowListener); return 0; } static int parseOptions(int argc, char **argv, OptionsParser::Options *options) { OptionsParser parser; parser.addOption(OptCamera, OptionString, "Specify which camera to operate on, by id", "camera", ArgumentRequired, "camera"); parser.addOption(OptList, OptionNone, "List all tests and exit", "list"); parser.addOption(OptFilter, OptionString, "Specify which tests to run", "filter", ArgumentRequired, "filter"); parser.addOption(OptHelp, OptionNone, "Display this help message", "help"); *options = parser.parse(argc, argv); if (!options->valid()) return -EINVAL; if (options->isSet(OptHelp)) { parser.usage(); std::cerr << "Further options from Googletest can be passed as environment variables" << std::endl; return -EINTR; } return 0; } int main(int argc, char **argv) { OptionsParser::Options options; int ret = parseOptions(argc, argv, &options); if (ret == -EINTR) return EXIT_SUCCESS; if (ret < 0) return EXIT_FAILURE; std::unique_ptr cm = std::make_unique(); /* No need to initialize the camera if we'll just list tests */ if (!options.isSet(OptList)) { ret = initCamera(cm.get(), options); if (ret) return ret; } ret = initGtest(argv[0], options); if (ret) return ret; ret = RUN_ALL_TESTS(); if (!options.isSet(OptList)) cm->stop(); return ret; } ref='#n23'>23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140

/* SPDX-License-Identifier: BSD-2-Clause */
/*
 * Copyright (C) 2019, Raspberry Pi (Trading) Limited
 *
 * agc.hpp - AGC/AEC control algorithm
 */
#pragma once

#include <vector>
#include <mutex>

#include <libcamera/base/utils.h>

#include "../agc_algorithm.hpp"
#include "../agc_status.h"
#include "../pwl.hpp"

// This is our implementation of AGC.

// This is the number actually set up by the firmware, not the maximum possible
// number (which is 16).

#define AGC_STATS_SIZE 15

namespace RPiController {

using namespace std::literals::chrono_literals;

struct AgcMeteringMode {
	double weights[AGC_STATS_SIZE];
	void Read(boost::property_tree::ptree const &params);
};

struct AgcExposureMode {
	std::vector<libcamera::utils::Duration> shutter;
	std::vector<double> gain;
	void Read(boost::property_tree::ptree const &params);
};

struct AgcConstraint {
	enum class Bound { LOWER = 0, UPPER = 1 };
	Bound bound;
	double q_lo;
	double q_hi;
	Pwl Y_target;
	void Read(boost::property_tree::ptree const &params);
};

typedef std::vector<AgcConstraint> AgcConstraintMode;

struct AgcConfig {
	void Read(boost::property_tree::ptree const &params);
	std::map<std::string, AgcMeteringMode> metering_modes;
	std::map<std::string, AgcExposureMode> exposure_modes;
	std::map<std::string, AgcConstraintMode> constraint_modes;
	Pwl Y_target;
	double speed;
	uint16_t startup_frames;
	unsigned int convergence_frames;
	double max_change;
	double min_change;
	double fast_reduce_threshold;
	double speed_up_threshold;
	std::string default_metering_mode;
	std::string default_exposure_mode;
	std::string default_constraint_mode;
	double base_ev;
	libcamera::utils::Duration default_exposure_time;
	double default_analogue_gain;
};

class Agc : public AgcAlgorithm
{
public:
	Agc(Controller *controller);
	char const *Name() const override;
	void Read(boost::property_tree::ptree const &params) override;
	// AGC handles "pausing" for itself.
	bool IsPaused() const override;
	void Pause() override;
	void Resume() override;
	unsigned int GetConvergenceFrames() const override;
	void SetEv(double ev) override;
	void SetFlickerPeriod(libcamera::utils::Duration flicker_period) override;
	void SetMaxShutter(libcamera::utils::Duration max_shutter) override;
	void SetFixedShutter(libcamera::utils::Duration fixed_shutter) override;
	void SetFixedAnalogueGain(double fixed_analogue_gain) override;
	void SetMeteringMode(std::string const &metering_mode_name) override;
	void SetExposureMode(std::string const &exposure_mode_name) override;
	void SetConstraintMode(std::string const &contraint_mode_name) override;
	void SwitchMode(CameraMode const &camera_mode, Metadata *metadata) override;
	void Prepare(Metadata *image_metadata) override;
	void Process(StatisticsPtr &stats, Metadata *image_metadata) override;

private:
	void updateLockStatus(DeviceStatus const &device_status);
	AgcConfig config_;
	void housekeepConfig();
	void fetchCurrentExposure(Metadata *image_metadata);
	void fetchAwbStatus(Metadata *image_metadata);
	void computeGain(bcm2835_isp_stats *statistics, Metadata *image_metadata,
			 double &gain, double &target_Y);
	void computeTargetExposure(double gain);
	bool applyDigitalGain(double gain, double target_Y);
	void filterExposure(bool desaturate);
	void divideUpExposure();
	void writeAndFinish(Metadata *image_metadata, bool desaturate);
	libcamera::utils::Duration clipShutter(libcamera::utils::Duration shutter);
	AgcMeteringMode *metering_mode_;
	AgcExposureMode *exposure_mode_;
	AgcConstraintMode *constraint_mode_;
	uint64_t frame_count_;
	AwbStatus awb_;
	struct ExposureValues {
		ExposureValues() : shutter(0s), analogue_gain(0),
				   total_exposure(0s), total_exposure_no_dg(0s) {}
		libcamera::utils::Duration shutter;
		double analogue_gain;
		libcamera::utils::Duration total_exposure;
		libcamera::utils::Duration total_exposure_no_dg; // without digital gain
	};
	ExposureValues current_;  // values for the current frame
	ExposureValues target_;   // calculate the values we want here
	ExposureValues filtered_; // these values are filtered towards target
	AgcStatus status_;
	int lock_count_;
	DeviceStatus last_device_status_;
	libcamera::utils::Duration last_target_exposure_;
	// Below here the "settings" that applications can change.
	std::string metering_mode_name_;
	std::string exposure_mode_name_;
	std::string constraint_mode_name_;
	double ev_;
	libcamera::utils::Duration flicker_period_;
	libcamera::utils::Duration max_shutter_;
	libcamera::utils::Duration fixed_shutter_;
	double fixed_analogue_gain_;
};

} // namespace RPiController