index : libcamera/vivid.git	pobrn/rebase vivid
	libcamera pipeline handler for VIVID	git repository hosting on libcamera.org

summaryrefslogtreecommitdiff

log msg author committer range

Age	Commit message (Expand)	Author
2022-07-19	utils: ipu3-pack: Provide a 10-bit bayer packing utility	Umang Jain
2022-07-19	libcamera: controls: Avoid double lookups	Laurent Pinchart
2022-07-19	libcamera: controls: Use std::optional to handle invalid control values	Christian Rauch
2022-07-18	qcam: viewfinder_qt: Support X RGB variants	Kieran Bingham
2022-07-18	qcam: format_converter: Support X RGB variants	Kieran Bingham
2022-07-18	qcam: viewfinder_qt: Fix include orders	Kieran Bingham
2022-07-18	qcam: main_window: Fix include ordering	Kieran Bingham
2022-07-18	libcamera: raspberry: Fix format validation	Jacopo Mondi
2022-07-15	cam: sdl: Use uint32_t in place of SDL_PixelFormatEnum	Jacopo Mondi
2022-07-15	utils: rkisp1: Support optional CSI-2 receiver subdev	Laurent Pinchart
2022-07-15	utils: rkisp1: Fix pixel format for raw capture	Laurent Pinchart
2022-07-15	utils: rkisp1: Fix sensor format parsing	Laurent Pinchart
2022-07-15	utils: rkisp1: Remove frames before starting capture	Laurent Pinchart
2022-07-14	pipeline: raspberrypi: Fix incorrect advertising of ScalerCrop	Naushir Patuck
2022-07-14	pipeline: rkisp1: Support media graph with separate CSI RX	Paul Elder
2022-07-13	utils: ipu3-unpack: Fix error string	Umang Jain
2022-07-13	libcamera: base: Suppress clang-11 compile error on ARM32	Naushir Patuck
2022-07-07	meson: Correctly pass the global include to the compiler	Eli Schwartz
2022-07-06	utils: raspberrypi: ctt: load_image: Ignore JPEG files with no raw data	William Vinnicombe
2022-07-06	test: delayed_controls: Remove sequenceOffset	Jacopo Mondi
2022-07-05	libcamera: camera: Reset request sequence number on stop/start	Umang Jain
2022-07-05	delayed_controls: Remove reduandant firstSequence_	Kieran Bingham
2022-07-04	gstreamer: Fix race conditions in task pause/resume	Laurent Pinchart
2022-07-04	gstreamer: Split completed request processing to a separate function	Laurent Pinchart
2022-07-04	gstreamer: Split request creation to a separate function	Laurent Pinchart
2022-07-04	gstreamer: Fix pads locking	Laurent Pinchart
2022-07-04	gstreamer: Use dedicated lock for request queues	Laurent Pinchart
2022-07-04	gstreamer: Combine the two pad loops in the task run handler	Laurent Pinchart
2022-07-04	gstreamer: Handle completed requests in the libcamerasrc task	Laurent Pinchart
2022-07-04	gstreamer: Rename queued requests queue to queuedRequests_	Laurent Pinchart
2022-07-04	gstreamer: Move timestamp calculation out of pad loop	Laurent Pinchart
2022-07-04	gstreamer: Pass Stream to RequestWrap::addBuffer()	Laurent Pinchart
2022-07-04	gstreamer: Move variable to loop scope	Laurent Pinchart
2022-07-04	gstreamer: Use gst_task_resume() when available	Laurent Pinchart
2022-07-04	libcamera: framebuffer: Turn the cookie into a 64-bit integer	Laurent Pinchart
2022-06-29	ipa: rkisp1: Add support of Black Level Correction tuning	Florian Sylvestre
2022-06-29	ipa: rkisp1: Add OV5640 tuning file	Florian Sylvestre
2022-06-29	ipa: rkisp1: Add IMX219 tuning file	Laurent Pinchart
2022-06-29	ipa: rkisp1: Add YAML tuning file support	Florian Sylvestre
2022-06-29	ipa: rkisp1: Register algorithms	Laurent Pinchart
2022-06-29	pipeline: rkisp1: Support IPA tuning file	Florian Sylvestre
2022-06-29	ipa: libipa: module: Make the Module class Loggable	Laurent Pinchart
2022-06-29	ipa: libipa: module: Add support for instantiation from YAML	Laurent Pinchart
2022-06-29	ipa: libipa: algorithm: Add init() function to the Algorithm class	Florian Sylvestre
2022-06-29	ipa: libipa: algorithm: Add an algorithm registration mechanism	Laurent Pinchart
2022-06-29	ipa: libipa: Move ipa namespace documentation to module.cpp	Laurent Pinchart
2022-06-29	ipa: libipa: Introduce a Module class template	Laurent Pinchart
2022-06-29	pipeline: raspberrypi: Advertise ScalerCrop from the pipeline handler	Naushir Patuck
2022-06-29	pipeline: ipa: raspberrypi: Correctly report available control limits	Naushir Patuck
2022-06-29	pipeline: ipa: raspberrypi: Move ControlInfoMap to the IPA	Naushir Patuck

• [prev]
• [next]

generated by cgit v1.2.1 (git 2.18.0) at 2024-12-23 02:40:32 +0000

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * controls.cpp - Control handling
 */

#include <libcamera/controls.h>

#include <iomanip>
#include <sstream>
#include <string>
#include <string.h>

#include "libcamera/internal/control_validator.h"
#include "libcamera/internal/log.h"
#include "libcamera/internal/utils.h"

/**
 * \file controls.h
 * \brief Framework to manage controls related to an object
 *
 * A control is a mean to govern or influence the operation of an object, and in
 * particular of a camera. Every control is defined by a unique numerical ID, a
 * name string and the data type of the value it stores. The libcamera API
 * defines a set of standard controls in the libcamera::controls namespace, as
 * a set of instances of the Control class.
 *
 * The main way for applications to interact with controls is through the
 * ControlList stored in the Request class:
 *
 * \code{.cpp}
 * Request *req = ...;
 * ControlList &controls = req->controls();
 * controls->set(controls::AwbEnable, false);
 * controls->set(controls::ManualExposure, 1000);
 *
 * ...
 *
 * int32_t exposure = controls->get(controls::ManualExposure);
 * \endcode
 *
 * The ControlList::get() and ControlList::set() methods automatically deduce
 * the data type based on the control.
 */

namespace libcamera {

LOG_DEFINE_CATEGORY(Controls)

namespace {

static constexpr size_t ControlValueSize[] = {
	[ControlTypeNone]		= 0,
	[ControlTypeBool]		= sizeof(bool),
	[ControlTypeByte]		= sizeof(uint8_t),
	[ControlTypeInteger32]		= sizeof(int32_t),
	[ControlTypeInteger64]		= sizeof(int64_t),
	[ControlTypeFloat]		= sizeof(float),
	[ControlTypeString]		= sizeof(char),
	[ControlTypeRectangle]		= sizeof(Rectangle),
	[ControlTypeSize]		= sizeof(Size),
};

} /* namespace */

/**
 * \enum ControlType
 * \brief Define the data type of a Control
 * \var ControlTypeNone
 * Invalid type, for empty values
 * \var ControlTypeBool
 * The control stores a boolean value
 * \var ControlTypeByte
 * The control stores a byte value as an unsigned 8-bit integer
 * \var ControlTypeInteger32
 * The control stores a 32-bit integer value
 * \var ControlTypeInteger64
 * The control stores a 64-bit integer value
 * \var ControlTypeFloat
 * The control stores a 32-bit floating point value
 * \var ControlTypeString
 * The control stores a string value as an array of char
 */

/**
 * \class ControlValue
 * \brief Abstract type representing the value of a control
 */

/** \todo Revisit the ControlValue layout when stabilizing the ABI */
static_assert(sizeof(ControlValue) == 16, "Invalid size of ControlValue class");

/**
 * \brief Construct an empty ControlValue.
 */
ControlValue::ControlValue()
	: type_(ControlTypeNone), isArray_(false), numElements_(0)
{
}

/**
 * \fn template<typename T> T ControlValue::ControlValue(const T &value)
 * \brief Construct a ControlValue of type T
 * \param[in] value Initial value
 *
 * This function constructs a new instance of ControlValue and stores the \a
 * value inside it. If the type \a T is equivalent to Span<R>, the instance
 * stores an array of values of type \a R. Otherwise the instance stores a
 * single value of type \a T. The numElements() and type() are updated to
 * reflect the stored value.
 */

void ControlValue::release()
{
	std::size_t size = numElements_ * ControlValueSize[type_];

	if (size > sizeof(value_)) {
		delete[] reinterpret_cast<uint8_t *>(storage_);
		storage_ = nullptr;
	}
}

ControlValue::~ControlValue()
{
	release();
}

/**
 * \brief Construct a ControlValue with the content of \a other
 * \param[in] other The ControlValue to copy content from
 */
ControlValue::ControlValue(const ControlValue &other)
	: type_(ControlTypeNone), numElements_(0)
{
	*this = other;
}

/**
 * \brief Replace the content of the ControlValue with a copy of the content
 * of \a other
 * \param[in] other The ControlValue to copy content from
 * \return The ControlValue with its content replaced with the one of \a other
 */
ControlValue &ControlValue::operator=(const ControlValue &other)
{
	set(other.type_, other.isArray_, other.data().data(),
	    other.numElements_, ControlValueSize[other.type_]);
	return *this;
}

/**
 * \fn ControlValue::type()
 * \brief Retrieve the data type of the value
 * \return The value data type
 */

/**
 * \fn ControlValue::isNone()
 * \brief Determine if the value is not initialised
 * \return True if the value type is ControlTypeNone, false otherwise
 */

/**
 * \fn ControlValue::isArray()
 * \brief Determine if the value stores an array
 * \return True if the value stores an array, false otherwise
 */

/**
 * \fn ControlValue::numElements()
 * \brief Retrieve the number of elements stored in the ControlValue
 *
 * For instances storing an array, this function returns the number of elements
 * in the array. For instances storing a string, it returns the length of the
 * string, not counting the terminating '\0'. Otherwise, it returns 1.
 *
 * \return The number of elements stored in the ControlValue
 */

/**
 * \brief Retrieve the raw data of a control value
 * \return The raw data of the control value as a span of uint8_t
 */
Span<const uint8_t> ControlValue::data() const
{
	std::size_t size = numElements_ * ControlValueSize[type_];
	const uint8_t *data = size > sizeof(value_)
			    ? reinterpret_cast<const uint8_t *>(storage_)
			    : reinterpret_cast<const uint8_t *>(&value_);
	return { data, size };
}

/**
 * \copydoc ControlValue::data() const
 */
Span<uint8_t> ControlValue::data()
{
	Span<const uint8_t> data = const_cast<const ControlValue *>(this)->data();
	return { const_cast<uint8_t *>(data.data()), data.size() };
}

/**
 * \brief Assemble and return a string describing the value
 * \return A string describing the ControlValue
 */
std::string ControlValue::toString() const
{
	if (type_ == ControlTypeNone)
		return "<ValueType Error>";

	const uint8_t *data = ControlValue::data().data();

	if (type_ == ControlTypeString)
		return std::string(reinterpret_cast<const char *>(data),
				   numElements_);

	std::string str(isArray_ ? "[ " : "");

	for (unsigned int i = 0; i < numElements_; ++i) {
		switch (type_) {
		case ControlTypeBool: {
			const bool *value = reinterpret_cast<const bool *>(data);
			str += *value ? "true" : "false";
			break;
		}
		case ControlTypeByte: {
			const uint8_t *value = reinterpret_cast<const uint8_t *>(data);
			str += std::to_string(*value);
			break;
		}
		case ControlTypeInteger32: {
			const int32_t *value = reinterpret_cast<const int32_t *>(data);
			str += std::to_string(*value);
			break;
		}
		case ControlTypeInteger64: {
			const int64_t *value = reinterpret_cast<const int64_t *>(data);
			str += std::to_string(*value);
			break;
		}
		case ControlTypeFloat: {
			const float *value = reinterpret_cast<const float *>(data);
			str += std::to_string(*value);
			break;
		}
		case ControlTypeRectangle: {
			const Rectangle *value = reinterpret_cast<const Rectangle *>(data);
			str += value->toString();
			break;
		}
		case ControlTypeSize: {
			const Size *value = reinterpret_cast<const Size *>(data);
			str += value->toString();
			break;
		}
		case ControlTypeNone:
		case ControlTypeString:
			break;
		}