/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2019, Google Inc. * * v4l2_controls.cpp - V4L2 Controls Support */ #include "v4l2_controls.h" /** * \file v4l2_controls.h * \brief Support for V4L2 Controls using the V4L2 Extended Controls APIs * * The V4L2 Control API allows application to inspect and modify sets of * configurable parameters on a video device or subdevice. The nature of the * parameters an application can modify using the control framework depends on * what the driver implements support for, and on the characteristics of the * underlying hardware platform. Generally controls are used to modify user * visible settings, such as the image brightness and exposure time, or * non-standard parameters which cannot be controlled through the V4L2 format * negotiation API. * * Controls are identified by a numerical ID, defined by the V4L2 kernel headers * and have an associated type. Each control has a value, which is the data that * can be modified with V4L2Device::setControls() or retrieved with * V4L2Device::getControls(). * * The control's type along with the control's flags define the type of the * control's value content. Controls can transport a single data value stored in * variable inside the control, or they might as well deal with more complex * data types, such as arrays of matrices, stored in a contiguous memory * locations associated with the control and called 'the payload'. Such controls * are called 'compound controls' and are currently not supported by the * libcamera V4L2 control framework. * * libcamera implements support for controls using the V4L2 Extended Control * API, which allows future handling of controls with payloads of arbitrary * sizes. * * The libcamera V4L2 Controls framework operates on lists of controls, wrapped * by the V4L2ControlList class, to match the V4L2 extended controls API. The * interface to set and get control is implemented by the V4L2Device class, and * this file only provides the data type definitions. * * \todo Add support for compound controls */ namespace libcamera { /** * \class V4L2ControlInfo * \brief Information on a V4L2 control * * The V4L2ControlInfo class represents all the information related to a V4L2 * control, such as its ID, its type, its user-readable name and the expected * size of its value data. * * V4L2ControlInfo instances are created by inspecting the fieldS of a struct * v4l2_query_ext_ctrl structure, after it has been filled by the device driver * as a consequence of a VIDIOC_QUERY_EXT_CTRL ioctl call. * * This class does not contain the control value, but only static information on * the control, which shall be cached by the caller at initialisation time or * the first time the control information is accessed. */ /** * \brief Construct a V4L2ControlInfo from a struct v4l2_query_ext_ctrl * \param ctrl The struct v4l2_query_ext_ctrl as returned by the kernel */ V4L2ControlInfo::V4L2ControlInfo(const struct v4l2_query_ext_ctrl &ctrl) { id_ = ctrl.id; type_ = ctrl.type; name_ = static_cast(ctrl.name); size_ = ctrl.elem_size * ctrl.elems; min_ = ctrl.minimum; max_ = ctrl.maximum; } /** * \fn V4L2ControlInfo::id() * \brief Retrieve the control ID * \return The V4L2 control ID */ /** * \fn V4L2ControlInfo::type() * \brief Retrieve the control type as defined by V4L2_CTRL_TYPE_* * \return The V4L2 control type */ /** * \fn V4L2ControlInfo::size() * \brief Retrieve the control value data size (in bytes) * \return The V4L2 control value data size */ /** * \fn V4L2ControlInfo::name() * \brief Retrieve the control user readable name * \return The V4L2 control user readable name */ /** * \fn V4L2ControlInfo::min() * \brief Retrieve the control minimum value * \return The V4L2 control minimum value */ /** * \fn V4L2ControlInfo::max() * \brief Retrieve the control maximum value * \return The V4L2 control maximum value */ /** * \typedef V4L2ControlInfoMap * \brief A map of control ID to V4L2ControlInfo */ /** * \class V4L2Control * \brief A V4L2 control value * * The V4L2Control class represent the value of a V4L2 control. The class * stores values that have been read from or will be applied to a V4L2 device. * * The value stored in the class instances does not reflect what is actually * applied to the hardware but is a pure software cache optionally initialized * at control creation time and modified by a control read or write operation. * * The write and read controls the V4L2Control class instances are not meant * to be directly used but are instead intended to be grouped in * V4L2ControlList instances, which are then passed as parameters to * V4L2Device::setControls() and V4L2Device::getControls() operations. */ /** * \fn V4L2Control::V4L2Control * \brief Construct a V4L2 control with \a id and \a value * \param id The V4L2 control ID * \param value The control value */ /** * \fn V4L2Control::value() * \brief Retrieve the value of the control * * This method returns the cached control value, initially set by * V4L2ControlList::add() and then updated when the controls are read or * written with V4L2Device::getControls() and V4L2Device::setControls(). * * \return The V4L2 control value */ /** * \fn V4L2Control::setValue() * \brief Set the value of the control * \param value The new V4L2 control value * * This method stores the control value, which will be applied to the * device when calling V4L2Device::setControls(). */ /** * \fn V4L2Control::id() * \brief Retrieve the control ID this instance refers to * \return The V4L2Control ID */ /** * \class V4L2ControlList * \brief Container of V4L2Control instances * * The V4L2Contr/* SPDX-License-Identifier: BSD-2-Clause */ /* * Copyright (C) 2019, Raspberry Pi (Trading) Limited * * black_level.cpp - black level control algorithm */ #include <math.h> #include <stdint.h> #include <libcamera/base/log.h> #include "../black_level_status.h" #include "black_level.hpp" using namespace RPiController; using namespace libcamera; LOG_DEFINE_CATEGORY(RPiBlackLevel) #define NAME "rpi.black_level" BlackLevel::BlackLevel(Controller *controller) : Algorithm(controller) { } char const *BlackLevel::Name() const { return NAME; } void BlackLevel::Read(boost::property_tree::ptree const &params) { uint16_t black_level = params.get<uint16_t>( "black_level", 4096); // 64 in 10 bits scaled to 16 bits black_level_r_ = params.get<uint16_t>("black_level_r", black_level); black_level_g_ = params.get<uint16_t>("black_level_g", black_level); black_level_b_ = params.get<uint16_t>("black_level_b", black_level); LOG(RPiBlackLevel, Debug) << " Read black levels red " << black_level_r_ << " green " << black_level_g_ << " blue " << black_level_b_; } void BlackLevel::Prepare(Metadata *image_metadata) { // Possibly we should think about doing this in a switch_mode or // something? struct BlackLevelStatus status; status.black_level_r = black_level_r_; status.black_level_g = black_level_g_; status.black_level_b = black_level_b_; image_metadata->Set("black_level.status", status); } // Register algorithm with the system. static Algorithm *Create(Controller *controller) { return new BlackLevel(controller); } static RegisterAlgorithm reg(NAME, &Create);