/* SPDX-License-Identifier: BSD-2-Clause */ /* * Copyright (C) 2019, Raspberry Pi (Trading) Limited * * lux.cpp - Lux control algorithm */ #include #include "linux/bcm2835-isp.h" #include "../device_status.h" #include "../logging.hpp" #include "lux.hpp" using namespace RPi; #define NAME "rpi.lux" Lux::Lux(Controller *controller) : Algorithm(controller) { // Put in some defaults as there will be no meaningful values until // Process has run. status_.aperture = 1.0; status_.lux = 400; } char const *Lux::Name() const { return NAME; } void Lux::Read(boost::property_tree::ptree const ¶ms) { RPI_LOG(Name()); reference_shutter_speed_ = params.get("reference_shutter_speed"); reference_gain_ = params.get("reference_gain"); reference_aperture_ = params.get("reference_aperture", 1.0); reference_Y_ = params.get("reference_Y"); reference_lux_ = params.get("reference_lux"); current_aperture_ = reference_aperture_; } void Lux::Prepare(Metadata *image_metadata) { std::unique_lock lock(mutex_); image_metadata->Set("lux.status", status_); } void Lux::Process(StatisticsPtr &stats, Metadata *image_metadata) { // set some initial values to shut the compiler up DeviceStatus device_status = { .shutter_speed = 1.0, .analogue_gain = 1.0, .lens_position = 0.0, .aperture = 0.0, .flash_intensity = 0.0 }; if (image_metadata->Get("device.status", device_status) == 0) { double current_gain = device_status.analogue_gain; double current_shutter_speed = device_status.shutter_speed; double current_aperture = device_status.aperture; if (current_aperture == 0) current_aperture = current_aperture_; uint64_t sum = 0; uint32_t num = 0; uint32_t *bin = stats->hist[0].g_hist; const int num_bins = sizeof(stats->hist[0].g_hist) / sizeof(stats->hist[0].g_hist[0]); for (int i = 0; i < num_bins; i++) sum += bin[i] * (uint64_t)i, num += bin[i]; // add .5 to reflect the mid-points of bins double current_Y = sum / (double)num + .5; double gain_ratio = reference_gain_ / current_gain; double shutter_speed_ratio = reference_shutter_speed_ / current_shutter_speed; double aperture_ratio = reference_aperture_ / current_aperture; double Y_ratio = current_Y * (65536 / num_bins) / reference_Y_; double estimated_lux = shutter_speed_ratio * gain_ratio * aperture_ratio * aperture_ratio * Y_ratio * reference_lux_; LuxStatus status; status.lux = estimated_lux; status.aperture = current_aperture; RPI_LOG(Name() << ": estimated lux " << estimated_lux); { std::unique_lock lock(mutex_); status_ = status; } // Overwrite the metadata here as well, so that downstream // algorithms get the latest value. image_metadata->Set("lux.status", status); } else RPI_WARN(Name() << ": no device metadata"); } // Register algorithm with the system. static Algorithm *Create(Controller *controller) { return (Algorithm *)new Lux(controller); } static RegisterAlgorithm reg(NAME, &Create); 12'>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 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

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * event.cpp - Event test
 */

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

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

#include "test.h"

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

class EventTest : public Test
{
protected:
	void readReady()
	{
		size_ = read(notifier_->fd(), data_, sizeof(data_));
		notified_ = true;
	}

	int init()
	{
		notifier_ = nullptr;

		return pipe(pipefd_);
	}

	int run()
	{
		EventDispatcher *dispatcher = Thread::current()->eventDispatcher();
		std::string data("H2G2");
		Timer timeout;
		ssize_t ret;

		notifier_ = new EventNotifier(pipefd_[0], EventNotifier::Read);
		notifier_->activated.connect(this, &EventTest::readReady);

		/* Test read notification with data. */
		memset(data_, 0, sizeof(data_));
		size_ = 0;

		ret = write(pipefd_[1], data.data(), data.size());
		if (ret < 0) {
			cout << "Pipe write failed" << endl;
			return TestFail;
		}

		timeout.start(100ms);
		dispatcher->processEvents();
		timeout.stop();

		if (static_cast<size_t>(size_) != data.size()) {
			cout << "Event notifier read ready test failed" << endl;
			return TestFail;
		}

		/* Test read notification without data. */
		notified_ = false;

		timeout.start(100ms);
		dispatcher->processEvents();
		timeout.stop();

		if (notified_) {
			cout << "Event notifier read no ready test failed" << endl;
			return TestFail;
		}

		/* Test read notifier disabling. */
		notified_ = false;
		notifier_->setEnabled(false);

		ret = write(pipefd_[1], data.data(), data.size());
		if (ret < 0) {
			cout << "Pipe write failed" << endl;
			return TestFail;
		}

		timeout.start(100ms);
		dispatcher->processEvents();
		timeout.stop();

		if (notified_) {
			cout << "Event notifier read disabling failed" << endl;
			return TestFail;
		}

		/* Test read notifier enabling. */
		notified_ = false;
		notifier_->setEnabled(true);

		timeout.start(100ms);
		dispatcher->processEvents();
		timeout.stop();

		if (!notified_) {
			cout << "Event notifier read enabling test failed" << endl;
			return TestFail;
		}

		return TestPass;
	}

	void cleanup()
	{
		delete notifier_;

		close(pipefd_[0]);
		close(pipefd_[1]);
	}

private:
	int pipefd_[2];

	EventNotifier *notifier_;
	bool notified_;
	char data_[16];
	ssize_t size_;
};

TEST_REGISTER(EventTest)