From patchwork Wed Jun 19 11:08:53 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1474 Return-Path: Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id C548D6194F for ; Wed, 19 Jun 2019 13:07:49 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay9-d.mail.gandi.net (Postfix) with ESMTPSA id 5484BFF803; Wed, 19 Jun 2019 11:07:49 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Wed, 19 Jun 2019 13:08:53 +0200 Message-Id: <20190619110858.20980-2-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190619110858.20980-1-jacopo@jmondi.org> References: <20190619110858.20980-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4 1/6] libcamera: Add V4L2Controls X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 19 Jun 2019 11:07:49 -0000 Add Libcamera V4L2 control support, implemented using the V4L2 Extended Control APIs. This patch defines the types used to define and manage controls. Signed-off-by: Jacopo Mondi --- src/libcamera/include/v4l2_controls.h | 96 ++++++++ src/libcamera/meson.build | 1 + src/libcamera/v4l2_controls.cpp | 337 ++++++++++++++++++++++++++ 3 files changed, 434 insertions(+) create mode 100644 src/libcamera/include/v4l2_controls.h create mode 100644 src/libcamera/v4l2_controls.cpp diff --git a/src/libcamera/include/v4l2_controls.h b/src/libcamera/include/v4l2_controls.h new file mode 100644 index 000000000000..d7b12801329e --- /dev/null +++ b/src/libcamera/include/v4l2_controls.h @@ -0,0 +1,96 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2019, Google Inc. + * + * v4l2_controls.h - V4L2 Extended Control Support + */ + +#ifndef __LIBCAMERA_V4L2_CONTROLS_H__ +#define __LIBCAMERA_V4L2_CONTROLS_H__ + +#include +#include +#include + +#include + +#include +#include + +namespace libcamera { + +class V4L2ControlInfo +{ +public: + V4L2ControlInfo(const struct v4l2_query_ext_ctrl &ctrl); + + unsigned int id() const { return id_; } + unsigned int type() const { return type_; } + size_t size() const { return size_; } + const std::string &name() const { return name_; } + +private: + unsigned int type_; + std::string name_; + unsigned int id_; + size_t size_; +}; + +class V4L2Control +{ +public: + unsigned int id() const { return id_; } + +private: + friend class V4L2Device; + friend class V4L2Controls; + + V4L2Control(unsigned int id) + : id_(id) {} + V4L2Control(unsigned int id, int value) + : id_(id), value_(value) {} + + long int value() const { return value_; } + void setValue(long int value) { value_ = value; } + + unsigned int id_; + long int value_; +}; + +class V4L2Controls +{ +public: + V4L2Controls &operator=(const V4L2Controls &) = delete; + + using iterator = std::vector::iterator; + using const_iterator = std::vector::const_iterator; + + iterator begin() { return controls_.begin(); } + const_iterator begin() const { return controls_.begin(); } + iterator end() { return controls_.end(); } + const_iterator end() const { return controls_.end(); } + + bool empty() const { return controls_.empty(); } + size_t size() { return controls_.size(); } + void reset() { controls_.clear(); } + + V4L2Control *operator[](unsigned int index) + { + return &controls_[index]; + } + + void add(unsigned int id, long int value); + void add(unsigned int id); + + int get(unsigned int id); + int set(unsigned int id, long int value); + +private: + V4L2Control *getControl(unsigned int id); + + std::vector controls_; +}; + +} /* namespace libcamera */ + +#endif /* __LIBCAMERA_V4L2_CONTROLS_H__ */ diff --git a/src/libcamera/meson.build b/src/libcamera/meson.build index f26ad5b2dc57..985aa7e8ab0e 100644 --- a/src/libcamera/meson.build +++ b/src/libcamera/meson.build @@ -23,6 +23,7 @@ libcamera_sources = files([ 'stream.cpp', 'timer.cpp', 'utils.cpp', + 'v4l2_controls.cpp', 'v4l2_device.cpp', 'v4l2_subdevice.cpp', 'v4l2_videodevice.cpp', diff --git a/src/libcamera/v4l2_controls.cpp b/src/libcamera/v4l2_controls.cpp new file mode 100644 index 000000000000..75b9c29ca133 --- /dev/null +++ b/src/libcamera/v4l2_controls.cpp @@ -0,0 +1,337 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2019, Google Inc. + * + * v4l2_controls.cpp - V4L2 Extended Control Support + */ + +#include "v4l2_controls.h" + +/** + * \file v4l2_controls.h + * \brief Support for V4L2 Controls using the V4L2 Extended Controls APIs. + * + * The V4L2 defined "Control API" allows application to inspect and modify set + * of configurable parameters on the video device or subdevice of interest. The + * nature of the parameters an application could 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 and class. Each control has a 'value', which is + * the data that can be modified with a call to the 'V4L2Device::setControls()' + * operation or retrieved with a call to 'V4L2Device::getControls()'. + * + * A control class defines the control purpose while its type (along with the + * control's flags) defines the type of the control's value content. Controls + * might 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. + * + * \todo Add support for compound controls + * + * Libcamera implements support for control using the V4L2 'Extended Control' + * framework, which allows easier future handling of controls with payloads + * of arbitrary sizes. + * + * The Libcamera V4L2 Controls framework operates on lists of controls, wrapped + * by the V4L2Controls class, to match the V4L2 extended controls framework. + * The interface to set and get control is implemented by the V4L2Device class, + * and this file only provides the data type definitions. + */ + +namespace libcamera { + +/** + * \class V4L2ControlInfo + * \brief Information on a V4L2 control + * + * The V4L2ControlInfo class represent all the informations relative 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 field of + * a struct v4l2_query_ext_ctrl structure, after it has been filled by the + * device driver as a consequence of an VIDIOC_QUERY_EXT_CTRL ioctl call. + * + * This class does not contain the control value, but only static informations + * on the control, which should ideally be cached the first time the control + * is accessed to be reused each time the control value need to be read or + * applied to the hardware. + */ + +/** + * \brief Construct a V4L2ControlInfo from a struct v4l2_query_ext_ctrl + */ +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; +} + +/** + * \fn V4L2ControlInfo::id() + * \brief Retrieve the control id this instance refers to + * \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 + */ + +/** + * \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 only modified by a control read operation or a + * call to V4L2Controls::set(). + * + * The V4L2Control class instances are not meant to be directly used but are + * instead intended to be grouped in V4L2Controls instances, which are then + * passed as parameters to the set and get control operations implemented in + * V4L2Device::setControls() and V4L2Device::setControls() respectively. + * + * In facts, access to the class constructor and to the control value accessor + * and modifier are restricted to the friend V4L2Controls and V4L2Device + * classes. + */ + +/** + * \fn V4L2Control::id() + * \brief Retrieve the control id this instance refers to + * \return The V4L2Control id + */ + +/** + * \class V4L2Controls + * \brief Wraps a list of V4L2Control + * + * The V4L2Controls class works as a wrapper for a list of V4L2Control + * instances. The class provides operations to add a new control to the list, + * get back a control value, and reset the list of controls it contains. + * + * In order to set and get controls, user of the Libcamera V4L2 control + * framework should operate on instances of the V4L2Controls class, and use + * them as argument for the V4L2Device::setControls() and + * V4L2Device::getControls() operations, which write and read a list of + * controls from or to a V4L2 device (a video device or a subdevice). + * + * Controls are added to a V4L2Controls instance with the add() method, with + * or without an initial value. + * + * To write controls to a device, the controls of interest should be added + * with an initial value by calling V4L2Controls::add(unsigned int id, long + * int value) to prepare for a write operation. The value of controls which + * are already part of the instance could be updated with a call to + * V4L2Controls::set() operation. Once the values of all controls of interest + * have been initialized in a V4L2Controls instance, this should be then + * passed to the V4L2Device::setControls() operation, which applies each + * control in the list to the hardware. + * + * Alternatively a control can be add without any initial value by calling + * V4L2Controls::add(unsigned int id) and then read from the device passing + * the V4L2Controls instance to V4L2Device::getControls() which read each + * control value from the hardware. + * + * Reading controls with an initialized value from the device, overwrites the + * control's value, reflecting what has been actually read from the hardware. + * + * V4L2Controls instances can be reset to remove all controls it contains and + * prepare to be re-used for a new control write/read sequence. Alternatively, + * the value of a control already part of the instance could be updated by using + * the V4L2Controls::set() method, to avoid going through a reset() when a + * control has to be read then written to the hardware in sequence. + * + * In facts, the following pseudo-code sequences lead to the same result: + * + * V4L2Controls controls; + * controls.add(V4L2_CID_xx); + * dev->getControls(&controls); + * controls.set(V4L2_CID_xx, value); + * dev->setControls(&controls); + * + * V4L2Controls controls; + * controls.add(V4L2_CID_xx); + * dev->getControls(&controls); + * controls.reset(); + * controls.add(V4L2_CID_xx, value); + * dev->setControls(&controls); + */ + +/** + * \typedef V4L2Controls::iterator + * \brief Iterator on the V4L2 controls contained in the instance + */ + +/** + * \typedef V4L2Controls::const_iterator + * \brief Const iterator on the V4L2 controls contained in the instance + */ + +/** + * \fn iterator V4L2Controls::begin() + * \brief Retrieve an iterator to the first V4L2Control in the instance + * \return An iterator to the first V4L2 control + */ + +/** + * \fn const_iterator V4L2Controls::begin() const + * \brief Retrieve a constant iterator to the first V4L2Control in the instance + * \return A constant iterator to the first V4L2 control + */ + +/** + * \fn iterator V4L2Controls::end() + * \brief Retrieve an iterator pointing to the past-the-end V4L2Control in the + * instance + * \return An iterator to the element following the last V4L2 control in the + * instance + */ + +/** + * \fn const_iterator V4L2Controls::end() const + * \brief Retrieve a constant iterator pointing to the past-the-end V4L2Control + * in the instance + * \return A constant iterator to the element following the last V4L2 control + * in the instance + */ + +/** + * \fn V4L2Controls::empty() + * \brief Verify if the instance does not contain any control + * \return True if the instance does not contain any control, false otherwise + */ + +/** + * \fn V4L2Controls::size() + * \brief Retrieve the number on controls in the instance + * \return The number of V4L2Control stored in the instance + */ + +/** + * \fn V4L2Controls::reset() + * \brief Removes all controls in the instance + */ + +/** + * \fn V4L2Controls::operator[](unsigned int index) + * \brief Access the control at index \a index + * \param index The index to access + */ + +/** + * \brief Add control \a id with a \a value to the instance + * \param id The V4L2 control id (V4L2_CID_xx) + * \param value The V4L2 control value + */ +void V4L2Controls::add(unsigned int id, long int value) +{ + /* Cannot use emplace_back() as the V4L2Control ctor is private. */ + V4L2Control ctrl(id, value); + controls_.push_back(ctrl); +} + +/** + * \brief Add control \a id without an initial value to the instance + * \param id The V4L2 control id (V4L2_CID_xx) + */ +void V4L2Controls::add(unsigned int id) +{ + /* Cannot use emplace_back() as the V4L2Control ctor is private. */ + V4L2Control ctrl(id); + controls_.push_back(ctrl); +} + +/** + * \brief Retrieve the value of the control with \a id + * \param id The V4L2 control id (V4L2_CID_xx) + * + * Retrieve the value of the control with id \a id. + * + * It is important to notice that the returned value is not read from the + * hardware at the time this operation is called, but it's the cached value + * obtained the most recent time the control has been read with + * V4L2Device::getControls() or the value of the control has been set to by the + * user with the add() or set() operation. + * + * \return The V4L2 control value or a negative error code if the control id + * is not part of this instance + */ +int V4L2Controls::get(unsigned int id) +{ + V4L2Control *ctrl = getControl(id); + if (!ctrl) + return -EINVAL; + + return ctrl->value(); +} + +/** + * \brief Set the value of the control with \a id + * \param id The V4L2 control id (V4L2_CID_xx) + * \param value The new V4L2 control value + * + * Set the value of the control with id \a id. + * + * It is important to notice that the value is not applied to the + * hardware at the time this operation is called, but it will only + * be actually pplied only by calling V4L2Device::setControls(). + * + * \return 0 on success or a negative error code if the control id + * is not part of this instance + */ +int V4L2Controls::set(unsigned int id, long int value) +{ + V4L2Control *ctrl = getControl(id); + if (!ctrl) + return -EINVAL; + + ctrl->setValue(value); + + return 0; +} + +/* + * \brief Get a pointer the control with \a id + * \param id The V4L2 control id (V4L2_CID_xx) + * \return A pointer to the V4L2Control with id \a id or nullptr if the + * control id is not part of this instance. + */ +V4L2Control *V4L2Controls::getControl(unsigned int id) +{ + for (V4L2Control &ctrl : controls_) { + if (ctrl.id() == id) + return &ctrl; + } + + return nullptr; +} + +} /* namespace libcamera */ From patchwork Wed Jun 19 11:08:54 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1475 Return-Path: Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 5824E6194F for ; Wed, 19 Jun 2019 13:07:50 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay9-d.mail.gandi.net (Postfix) with ESMTPSA id EC0C9FF806; Wed, 19 Jun 2019 11:07:49 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Wed, 19 Jun 2019 13:08:54 +0200 Message-Id: <20190619110858.20980-3-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190619110858.20980-1-jacopo@jmondi.org> References: <20190619110858.20980-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4 2/6] libcamera: v4l2_device: List controls at device open X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 19 Jun 2019 11:07:50 -0000 Enumerate all the controls a device supports at open() time. Store the control informations in a map inside the device to save querying the control when setting or getting its value from the device. Signed-off-by: Jacopo Mondi --- src/libcamera/include/v4l2_device.h | 8 +++++++- src/libcamera/v4l2_device.cpp | 30 +++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/src/libcamera/include/v4l2_device.h b/src/libcamera/include/v4l2_device.h index 2c26f3eae2b4..563be151c257 100644 --- a/src/libcamera/include/v4l2_device.h +++ b/src/libcamera/include/v4l2_device.h @@ -7,12 +7,15 @@ #ifndef __LIBCAMERA_V4L2_DEVICE_H__ #define __LIBCAMERA_V4L2_DEVICE_H__ +#include #include #include "log.h" namespace libcamera { +class V4L2ControlInfo; + class V4L2Device : protected Loggable { public: @@ -22,7 +25,7 @@ public: protected: V4L2Device(const std::string &deviceNode, const std::string &logTag); - ~V4L2Device() {} + ~V4L2Device(); int fd() { return fd_; } @@ -33,6 +36,9 @@ protected: std::string logPrefix() const { return "'" + logTag_ + "'"; } private: + void listControls(); + + std::map controls_; std::string deviceNode_; std::string logTag_; int fd_; diff --git a/src/libcamera/v4l2_device.cpp b/src/libcamera/v4l2_device.cpp index eeed0a70fb0e..58dd94836686 100644 --- a/src/libcamera/v4l2_device.cpp +++ b/src/libcamera/v4l2_device.cpp @@ -13,6 +13,7 @@ #include #include "log.h" +#include "v4l2_controls.h" /** * \file v4l2_device.h @@ -82,6 +83,12 @@ V4L2Device::V4L2Device(const std::string &deviceNode, const std::string &logTag) { } +V4L2Device::~V4L2Device() +{ + for (auto &pair : controls_) + delete pair.second; +} + /** * \fn V4L2Device::fd() * \brief Retrieve the V4L2 device file descriptor @@ -114,6 +121,8 @@ int V4L2Device::open(unsigned int flags) fd_ = ret; + listControls(); + return 0; } @@ -141,4 +150,25 @@ int V4L2Device::ioctl(unsigned long request, void *argp) * \return The tag to prefix log messages with */ +/* + * \brief List and store all controls supported by the V4L2 device + */ +void V4L2Device::listControls() +{ + struct v4l2_query_ext_ctrl ctrl = {}; + + /* \todo: add support for menu and compound controls. */ + ctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL; + while (ioctl(VIDIOC_QUERY_EXT_CTRL, &ctrl) == 0) { + if (ctrl.type == V4L2_CTRL_TYPE_CTRL_CLASS || + ctrl.flags & V4L2_CTRL_FLAG_DISABLED) { + ctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL; + continue; + } + + controls_[ctrl.id] = new V4L2ControlInfo(ctrl); + ctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL; + } +} + } /* namespace libcamera */ From patchwork Wed Jun 19 11:08:55 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1476 Return-Path: Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id F0BBC61A3D for ; Wed, 19 Jun 2019 13:07:50 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay9-d.mail.gandi.net (Postfix) with ESMTPSA id 82E13FF803; Wed, 19 Jun 2019 11:07:50 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Wed, 19 Jun 2019 13:08:55 +0200 Message-Id: <20190619110858.20980-4-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190619110858.20980-1-jacopo@jmondi.org> References: <20190619110858.20980-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4 3/6] libcamera: v4l2_device: Implement get and set controls X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 19 Jun 2019 11:07:51 -0000 Implement getControls() and setControls() operations in V4L2Device class. Both operations take a V4L2Controls instance and read or write the V4L2 controls on the V4L2 device. Signed-off-by: Jacopo Mondi --- src/libcamera/include/v4l2_device.h | 6 + src/libcamera/v4l2_device.cpp | 189 ++++++++++++++++++++++++++++ 2 files changed, 195 insertions(+) diff --git a/src/libcamera/include/v4l2_device.h b/src/libcamera/include/v4l2_device.h index 563be151c257..e66cc7ebe737 100644 --- a/src/libcamera/include/v4l2_device.h +++ b/src/libcamera/include/v4l2_device.h @@ -15,6 +15,7 @@ namespace libcamera { class V4L2ControlInfo; +class V4L2Controls; class V4L2Device : protected Loggable { @@ -23,6 +24,10 @@ public: bool isOpen() const { return fd_ != -1; } const std::string &deviceNode() const { return deviceNode_; } + V4L2ControlInfo *getControlInfo(unsigned int id); + int getControls(V4L2Controls *ctrls); + int setControls(V4L2Controls *ctrls); + protected: V4L2Device(const std::string &deviceNode, const std::string &logTag); ~V4L2Device(); @@ -37,6 +42,7 @@ protected: private: void listControls(); + int validateControlType(V4L2ControlInfo *info); std::map controls_; std::string deviceNode_; diff --git a/src/libcamera/v4l2_device.cpp b/src/libcamera/v4l2_device.cpp index 58dd94836686..5af0ddc468fe 100644 --- a/src/libcamera/v4l2_device.cpp +++ b/src/libcamera/v4l2_device.cpp @@ -66,6 +66,170 @@ void V4L2Device::close() * \return The device node path */ +/** + * \brief Get informations for control with \a id + * \param[in] id The control id to search info for + * \return The V4L2ControlInfo associated to the V4L2 control with \a id or + * nullptr if the control is not supported by the V4L2Device + */ +V4L2ControlInfo *V4L2Device::getControlInfo(unsigned int id) +{ + auto it = controls_.find(id); + if (it == controls_.end()) + return nullptr; + + return it->second; +} + +/** + * \brief Read values of a list of controls from the device + * \param[inout] ctrls The list of controls to read + * + * Read the value of each V4L2Controls contained in \a ctrls, overwriting + * it's current value with the one returned by the device. + * + * Each V4L2Control instance in \a ctrls should be supported by the device. + * + * \return 0 on success or a negative error code otherwise + */ +int V4L2Device::getControls(V4L2Controls *ctrls) +{ + unsigned int count = ctrls->size(); + if (count == 0) + return 0; + + struct V4L2ControlInfo *controlInfo[count]; + struct v4l2_ext_control v4l2Ctrls[count]; + for (unsigned int i = 0; i < count; ++i) { + V4L2Control *ctrl = (*ctrls)[i]; + + /* Validate the control. */ + V4L2ControlInfo *info = getControlInfo(ctrl->id()); + if (!info) { + LOG(V4L2, Error) << "Control '" << ctrl->id() + << "' not valid"; + return -EINVAL; + } + + if (validateControlType(info)) + return -EINVAL; + + controlInfo[i] = info; + + /* Prepare the v4l2_ext_control entry for the read operation. */ + struct v4l2_ext_control *v4l2Ctrl = &v4l2Ctrls[i]; + v4l2Ctrl->id = info->id(); + v4l2Ctrl->size = info->size(); + } + + struct v4l2_ext_controls v4l2ExtCtrls = {}; + v4l2ExtCtrls.which = V4L2_CTRL_WHICH_CUR_VAL; + v4l2ExtCtrls.controls = v4l2Ctrls; + v4l2ExtCtrls.count = count; + + int ret = ioctl(VIDIOC_G_EXT_CTRLS, &v4l2ExtCtrls); + if (ret) { + LOG(V4L2, Error) << "Unable to read controls: " + << strerror(ret); + return ret; + } + + /* + * For each control read from the device, set the value in the + * V4L2ControlValue provided by the caller. + */ + for (unsigned int i = 0; i < count; ++i) { + struct v4l2_ext_control *v4l2Ctrl = &v4l2Ctrls[i]; + V4L2ControlInfo *info = controlInfo[i]; + V4L2Control *ctrl = (*ctrls)[i]; + + switch (info->type()) { + case V4L2_CTRL_TYPE_INTEGER64: + ctrl->setValue(v4l2Ctrl->value64); + break; + case V4L2_CTRL_TYPE_INTEGER: + case V4L2_CTRL_TYPE_BOOLEAN: + case V4L2_CTRL_TYPE_BUTTON: + case V4L2_CTRL_TYPE_MENU: + ctrl->setValue(static_cast(v4l2Ctrl->value)); + break; + } + } + + return 0; +} + +/** + * \brief Write a list of controls to the device + * \param[in] ctrls The list of controls to apply + * + * Write the value of each V4L2Control contained in \a ctrls. Each + * control should be initialized by the caller with a value, otherwise + * the result of the operation is undefined. + * + * The value of each control is not updated to reflect what has been + * actually applied on the device. To read the actual value of a control + * after a setControls(), users should read the control value back with + * getControls(). + * + * Each V4L2Control instance in \a ctrls should be supported by the device. + * + * \return 0 on success or a negative error code otherwise + */ +int V4L2Device::setControls(V4L2Controls *ctrls) +{ + unsigned int count = ctrls->size(); + if (count == 0) + return 0; + + struct v4l2_ext_control v4l2Ctrls[count]; + for (unsigned int i = 0; i < count; ++i) { + V4L2Control *ctrl = (*ctrls)[i]; + + /* Validate the control. */ + V4L2ControlInfo *info = getControlInfo(ctrl->id()); + if (!info) { + LOG(V4L2, Error) << "Control '" << ctrl->id() + << "' not valid"; + return -EINVAL; + } + + if (validateControlType(info)) + return -EINVAL; + + /* Prepare the v4l2_ext_control entry for the write operation. */ + struct v4l2_ext_control *v4l2Ctrl = &v4l2Ctrls[i]; + v4l2Ctrl->id = info->id(); + v4l2Ctrl->size = info->size(); + + switch (info->type()) { + case V4L2_CTRL_TYPE_INTEGER64: + v4l2Ctrl->value64 = ctrl->value(); + break; + case V4L2_CTRL_TYPE_INTEGER: + case V4L2_CTRL_TYPE_BOOLEAN: + case V4L2_CTRL_TYPE_BUTTON: + case V4L2_CTRL_TYPE_MENU: + v4l2Ctrl->value = static_cast(ctrl->value()); + break; + } + } + + struct v4l2_ext_controls v4l2ExtCtrls = {}; + v4l2ExtCtrls.which = V4L2_CTRL_WHICH_CUR_VAL; + v4l2ExtCtrls.controls = v4l2Ctrls; + v4l2ExtCtrls.count = count; + + int ret = ioctl(VIDIOC_S_EXT_CTRLS, &v4l2ExtCtrls); + if (ret) { + LOG(V4L2, Error) << "Unable to write controls: " + << strerror(ret); + return ret; + } + + return 0; +} + /** * \brief Construct a V4L2Device * \param[in] deviceNode The device node filesystem path @@ -171,4 +335,29 @@ void V4L2Device::listControls() } } +/* + * \brief Make sure the control type is supported + * \param[in] info The V4L2ControlInfo to inspect type of + * \return 0 on success or a negative error code otherwise + * \retval -EINVAL The control type is not supported + */ +int V4L2Device::validateControlType(V4L2ControlInfo *info) +{ + /* \todo support compound and menu controls. */ + switch (info->type()) { + case V4L2_CTRL_TYPE_INTEGER64: + case V4L2_CTRL_TYPE_INTEGER: + case V4L2_CTRL_TYPE_BOOLEAN: + case V4L2_CTRL_TYPE_BUTTON: + case V4L2_CTRL_TYPE_MENU: + break; + default: + LOG(V4L2, Error) << "Control type '" << info->type() + << "' not supported"; + return -EINVAL; + } + + return 0; +} + } /* namespace libcamera */ From patchwork Wed Jun 19 11:08:56 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1477 Return-Path: Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 88C9E61A3D for ; Wed, 19 Jun 2019 13:07:51 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay9-d.mail.gandi.net (Postfix) with ESMTPSA id 2853AFF806; Wed, 19 Jun 2019 11:07:50 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Wed, 19 Jun 2019 13:08:56 +0200 Message-Id: <20190619110858.20980-5-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190619110858.20980-1-jacopo@jmondi.org> References: <20190619110858.20980-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4 4/6] libcamera: camera_sensor: Add V4L2 control operations X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 19 Jun 2019 11:07:52 -0000 Add operations to get and set control and to retrieve the informations on a V4L2 control. For simple camera sensors, the operations are directly called on the underlying V4L2 subdevice. Signed-off-by: Jacopo Mondi --- src/libcamera/camera_sensor.cpp | 58 +++++++++++++++++++++++++++ src/libcamera/include/camera_sensor.h | 6 +++ 2 files changed, 64 insertions(+) diff --git a/src/libcamera/camera_sensor.cpp b/src/libcamera/camera_sensor.cpp index a804a68c9d91..28a32a96ef7b 100644 --- a/src/libcamera/camera_sensor.cpp +++ b/src/libcamera/camera_sensor.cpp @@ -247,6 +247,64 @@ int CameraSensor::setFormat(V4L2SubdeviceFormat *format) return subdev_->setFormat(0, format); } +/** + * \brief Retrieve the V4L2 control info from the sensor's subdevice + * \param id The V4L2 control id + * + * Retrieve the V4L2ControlInfo from the V4L2 subdevice backing the + * camera sensor. + * + * More complex camera sensors, which expose multiple subdevices should + * override this method. + * + * \sa V4L2Device::getControlInfo() + * + * \return The V4L2ControlInfo associated to the V4L2 control with \a id or + * nullptr if the control is not supported. + */ +V4L2ControlInfo *CameraSensor::getControlInfo(unsigned int id) +{ + return subdev_->getControlInfo(id); +} + +/** + * \brief Read a list of controls from the sensor's subdevice + * \param ctrls The list of controls to read + * + * Read V4L2 controls values on the V4L2 subdevice backing the + * camera sensor. + * + * More complex camera sensors, which expose multiple subdevices should + * override this method. + * + * \sa V4L2Device::getControls() + * + * \return 0 on success or a negative error code otherwise + */ +int CameraSensor::getControls(V4L2Controls *ctrls) +{ + return subdev_->getControls(ctrls); +} + +/** + * \brief Write a list of controls from the sensor's subdevice + * \param ctrls The list of controls to write + * + * Write V4L2 controls values on the V4L2 subdevice backing the + * camera sensor. + * + * More complex camera sensors, which expose multiple subdevices should + * override this method. + * + * \sa V4L2Device::setControls() + * + * \return 0 on success or a negative error code otherwise + */ +int CameraSensor::setControls(V4L2Controls *ctrls) +{ + return subdev_->setControls(ctrls); +} + std::string CameraSensor::logPrefix() const { return "'" + subdev_->entity()->name() + "'"; diff --git a/src/libcamera/include/camera_sensor.h b/src/libcamera/include/camera_sensor.h index b823480241a7..ed6bb16f5686 100644 --- a/src/libcamera/include/camera_sensor.h +++ b/src/libcamera/include/camera_sensor.h @@ -17,6 +17,8 @@ namespace libcamera { class MediaEntity; +class V4L2ControlInfo; +class V4L2Controls; class V4L2Subdevice; struct V4L2SubdeviceFormat; @@ -41,6 +43,10 @@ public: const Size &size) const; int setFormat(V4L2SubdeviceFormat *format); + V4L2ControlInfo *getControlInfo(unsigned int id); + int getControls(V4L2Controls *ctrls); + int setControls(V4L2Controls *ctrls); + protected: std::string logPrefix() const; From patchwork Wed Jun 19 11:08:57 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1478 Return-Path: Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 1FC026194F for ; Wed, 19 Jun 2019 13:07:52 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay9-d.mail.gandi.net (Postfix) with ESMTPSA id B30FEFF803; Wed, 19 Jun 2019 11:07:51 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Wed, 19 Jun 2019 13:08:57 +0200 Message-Id: <20190619110858.20980-6-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190619110858.20980-1-jacopo@jmondi.org> References: <20190619110858.20980-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4 5/6] libcamera: ipu3: Set pipe_mode based on stream configuration X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 19 Jun 2019 11:07:52 -0000 Set the ImgU pipe_mode control based on the active stream configuration. Use 'Video' pipe mode unless the viewfinder stream is not active. Signed-off-by: Jacopo Mondi --- src/libcamera/pipeline/ipu3/ipu3.cpp | 34 ++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/src/libcamera/pipeline/ipu3/ipu3.cpp b/src/libcamera/pipeline/ipu3/ipu3.cpp index 1c0a9825b4cd..8c26d2c8c60c 100644 --- a/src/libcamera/pipeline/ipu3/ipu3.cpp +++ b/src/libcamera/pipeline/ipu3/ipu3.cpp @@ -22,6 +22,8 @@ #include "media_device.h" #include "pipeline_handler.h" #include "utils.h" +#include "v4l2_controls.h" +#include "v4l2_device.h" #include "v4l2_subdevice.h" #include "v4l2_videodevice.h" @@ -194,6 +196,12 @@ private: class PipelineHandlerIPU3 : public PipelineHandler { public: + static constexpr unsigned int V4L2_CID_IPU3_PIPE_MODE = 0x009819c1; + enum IPU3PipeModes { + IPU3PipeModeVideo = 0, + IPU3PipeModeStillCapture = 1, + }; + PipelineHandlerIPU3(CameraManager *manager); CameraConfiguration *generateConfiguration(Camera *camera, @@ -535,7 +543,13 @@ int PipelineHandlerIPU3::configure(Camera *camera, CameraConfiguration *c) * As we need to set format also on the non-active streams, use * the configuration of the active one for that purpose (there should * be at least one active stream in the configuration request). + * + * Also set the IPU3 pipe mode: video mode by default, unless the only + * requested stream is the still capture output one. + * \todo: This works as long as only two concurrent streams per pipe + * are supported. */ + int pipeMode = IPU3PipeModeVideo; if (!outStream->active_) { ret = imgu->configureOutput(outStream->device_, config->at(0)); if (ret) @@ -546,6 +560,8 @@ int PipelineHandlerIPU3::configure(Camera *camera, CameraConfiguration *c) ret = imgu->configureOutput(vfStream->device_, config->at(0)); if (ret) return ret; + + pipeMode = IPU3PipeModeStillCapture; } /* @@ -559,6 +575,24 @@ int PipelineHandlerIPU3::configure(Camera *camera, CameraConfiguration *c) if (ret) return ret; + /* Apply the "pipe_mode" control to the ImgU subdevice. */ + V4L2Controls ctrls; + ctrls.add(V4L2_CID_IPU3_PIPE_MODE, pipeMode); + ret = imgu->imgu_->setControls(&ctrls); + if (ret) { + LOG(IPU3, Error) << "Unable to set pipe_mode control"; + return ret; + } + + ret = imgu->imgu_->getControls(&ctrls); + if (ret) { + LOG(IPU3, Error) << "Unable to get pipe_mode control value"; + return ret; + } + + pipeMode = ctrls.get(V4L2_CID_IPU3_PIPE_MODE); + LOG(IPU3, Debug) << "ImgU pipe mode set to: " + << (pipeMode ? "'Still Capture'" : "'Video'"); return 0; } From patchwork Wed Jun 19 11:08:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1479 Return-Path: Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id A598861A1F for ; Wed, 19 Jun 2019 13:07:52 +0200 (CEST) X-Originating-IP: 2.224.242.101 Received: from uno.lan (2-224-242-101.ip172.fastwebnet.it [2.224.242.101]) (Authenticated sender: jacopo@jmondi.org) by relay9-d.mail.gandi.net (Postfix) with ESMTPSA id 4B7A8FF802; Wed, 19 Jun 2019 11:07:52 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Wed, 19 Jun 2019 13:08:58 +0200 Message-Id: <20190619110858.20980-7-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190619110858.20980-1-jacopo@jmondi.org> References: <20190619110858.20980-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v4 6/6] [HACK] ipu3: Set and get a few sensor controls X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 19 Jun 2019 11:07:53 -0000 Not to merge patch to demonstrate how to set controls on the image sensor device. Not-Signed-off-by: Jacopo Mondi --- src/libcamera/pipeline/ipu3/ipu3.cpp | 49 ++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/src/libcamera/pipeline/ipu3/ipu3.cpp b/src/libcamera/pipeline/ipu3/ipu3.cpp index 8c26d2c8c60c..8401ced17282 100644 --- a/src/libcamera/pipeline/ipu3/ipu3.cpp +++ b/src/libcamera/pipeline/ipu3/ipu3.cpp @@ -693,6 +693,55 @@ int PipelineHandlerIPU3::start(Camera *camera) ImgUDevice *imgu = data->imgu_; int ret; + /* --- Get control values --- */ + V4L2Controls controls; + controls.add(V4L2_CID_EXPOSURE); + controls.add(V4L2_CID_ANALOGUE_GAIN); + ret = cio2->sensor_->getControls(&controls); + if (ret) { + LOG(Error) << "Failed to get control values"; + return -EINVAL; + } + + for (const V4L2Control &ctrl : controls) { + unsigned int id = ctrl.id(); + V4L2ControlInfo *info = cio2->sensor_->getControlInfo(id); + if (!info) + continue; + + int val = controls.get(id); + LOG(Error) << "Control : " << id << " - name : " << info->name() + << " - value: " << val; + } + + /* --- Set control values --- */ + controls.set(V4L2_CID_EXPOSURE, 2046); + controls.set(V4L2_CID_ANALOGUE_GAIN, 1024); + + ret = cio2->sensor_->setControls(&controls); + if (ret) { + LOG(IPU3, Error) << "Failed to set controls"; + return ret; + } + + /* --- Get control values back again and verify they have changed --- */ + ret = cio2->sensor_->getControls(&controls); + if (ret) { + LOG(Error) << "Failed to get control values"; + return -EINVAL; + } + + for (const V4L2Control &ctrl : controls) { + unsigned int id = ctrl.id(); + V4L2ControlInfo *info = cio2->sensor_->getControlInfo(id); + if (!info) + continue; + + int val = controls.get(id); + LOG(Error) << "Control : " << id << " - name : " << info->name() + << " - value: " << val; + } + /* * Start the ImgU video devices, buffers will be queued to the * ImgU output and viewfinder when requests will be queued.