From patchwork Mon Jun 24 14:28: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: 1504 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 082F361580 for ; Mon, 24 Jun 2019 16:27: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 relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 936A72000C; Mon, 24 Jun 2019 14:27:50 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Mon, 24 Jun 2019 16:28:54 +0200 Message-Id: <20190624142859.19313-2-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190624142859.19313-1-jacopo@jmondi.org> References: <20190624142859.19313-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v6 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: Mon, 24 Jun 2019 14:27:51 -0000 Add libcamera V4L2 control support, implemented using the V4L2 Extended Control APIs. This patch defines the types used to create and manage controls. Signed-off-by: Jacopo Mondi --- src/libcamera/include/v4l2_controls.h | 79 ++++++++ src/libcamera/meson.build | 1 + src/libcamera/v4l2_controls.cpp | 281 ++++++++++++++++++++++++++ 3 files changed, 361 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..aad4ef14ed31 --- /dev/null +++ b/src/libcamera/include/v4l2_controls.h @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2019, Google Inc. + * + * v4l2_controls.h - V4L2 Controls Support + */ + +#ifndef __LIBCAMERA_V4L2_CONTROLS_H__ +#define __LIBCAMERA_V4L2_CONTROLS_H__ + +#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 id_; + unsigned int type_; + size_t size_; + std::string name_; +}; + +class V4L2Control +{ +public: + V4L2Control(unsigned int id, int value = 0) + : id_(id), value_(value) {} + + int64_t value() const { return value_; } + void setValue(int64_t value) { value_ = value; } + + unsigned int id() const { return id_; } + +private: + unsigned int id_; + int64_t value_; +}; + +class V4L2ControlList +{ +public: + 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(); } + std::size_t size() const { return controls_.size(); } + + void clear() { controls_.clear(); } + int add(unsigned int id, int64_t value = 0); + + V4L2Control *getControl(unsigned int id); + +private: + 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..ac932d855dd6 --- /dev/null +++ b/src/libcamera/v4l2_controls.cpp @@ -0,0 +1,281 @@ +/* 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 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. 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; +} + +/** + * \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 + */ + +/** + * \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 V4L2ControlList class works as a container 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 V4L2ControlList class, and use + * them as argument for the V4L2Device::setControls() and + * V4L2Device::getControls() operations, which write and read a list of + * controls to or from a V4L2 device (a video device or a subdevice). + * + * Controls are added to a V4L2ControlList instance with the add() method, with + * or without a value. + * + * To write controls to a device, the controls of interest shall be added with + * an initial value by calling V4L2ControlList::add(unsigned int id, int64_t + * value) to prepare for a write operation. Once the values of all controls of + * interest have been added, the V4L2ControlList instance is passed to the + * V4L2Device::setControls(), which sets the controls on the device. + * + * To read controls from a device, the desired controls are added with + * V4L2ControlList::add(unsigned int id) to prepare for a read operation. The + * V4L2ControlList instance is then passed to V4L2Device::getControls(), which + * reads the controls from the device and updates the values stored in + * V4L2ControlList. + * + * V4L2ControlList instances can be reset to remove all controls they contain + * and prepare to be re-used for a new control write/read sequence. + */ + +/** + * \typedef V4L2ControlList::iterator + * \brief Iterator on the V4L2 controls contained in the instance + */ + +/** + * \typedef V4L2ControlList::const_iterator + * \brief Const iterator on the V4L2 controls contained in the instance + */ + +/** + * \fn iterator V4L2ControlList::begin() + * \brief Retrieve an iterator to the first V4L2Control in the instance + * \return An iterator to the first V4L2 control + */ + +/** + * \fn const_iterator V4L2ControlList::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 V4L2ControlList::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 V4L2ControlList::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 V4L2ControlList::empty() + * \brief Verify if the instance does not contain any control + * \return True if the instance does not contain any control, false otherwise + */ + +/** + * \fn V4L2ControlList::size() + * \brief Retrieve the number on controls in the instance + * \return The number of V4L2Control stored in the instance + */ + +/** + * \fn V4L2ControlList::clear() + * \brief Remove all controls in the instance + */ + +/** + * \brief Add control with \a id and optional \a value to the instance + * \param id The V4L2 control ID (V4L2_CID_*) + * \param value The V4L2 control value + * + * This methods add a new V4L2 control to the V4L2ControlList. The newly + * inserted control should be unique (no other control with \a id should be + * part of the V4L2 control list) otherwise a negative error code is returned. + * + * \return 0 on success or a negative error code otherwise + * \retval -EBUSY A control with \a id already exists + */ +int V4L2ControlList::add(unsigned int id, int64_t value) +{ + for (const V4L2Control &ctrl : controls_) { + if (ctrl.id() == id) + return -EBUSY; + } + + controls_.emplace_back(id, 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 \a id or nullptr if the + * control ID is not part of this instance. + */ +V4L2Control *V4L2ControlList::getControl(unsigned int id) +{ + for (V4L2Control &ctrl : controls_) { + if (ctrl.id() == id) + return &ctrl; + } + + return nullptr; +} + +} /* namespace libcamera */ From patchwork Mon Jun 24 14:28: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: 1505 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 95AE9615BC for ; Mon, 24 Jun 2019 16:27: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 relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 35E4A20012; Mon, 24 Jun 2019 14:27:51 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Mon, 24 Jun 2019 16:28:55 +0200 Message-Id: <20190624142859.19313-3-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190624142859.19313-1-jacopo@jmondi.org> References: <20190624142859.19313-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v6 2/6] libcamera: v4l2_device: List valid controls at 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: Mon, 24 Jun 2019 14:27:52 -0000 Enumerate all the valid controls a device supports at open() time. A control is valid only if its type is supported. Store the control information in a map inside the device to save querying the control when setting or getting its value from the device and provide an operation to retrieve information by control ID. Signed-off-by: Jacopo Mondi Reviewed-by: Laurent Pinchart --- src/libcamera/include/v4l2_device.h | 8 ++++ src/libcamera/v4l2_device.cpp | 57 +++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+) diff --git a/src/libcamera/include/v4l2_device.h b/src/libcamera/include/v4l2_device.h index 75f23a05b903..556960467e10 100644 --- a/src/libcamera/include/v4l2_device.h +++ b/src/libcamera/include/v4l2_device.h @@ -7,18 +7,23 @@ #ifndef __LIBCAMERA_V4L2_DEVICE_H__ #define __LIBCAMERA_V4L2_DEVICE_H__ +#include #include #include "log.h" namespace libcamera { +class V4L2ControlInfo; + class V4L2Device : protected Loggable { public: void close(); bool isOpen() const { return fd_ != -1; } + const V4L2ControlInfo *getControlInfo(unsigned int id) const; + const std::string &deviceNode() const { return deviceNode_; } protected: @@ -32,6 +37,9 @@ protected: int fd() { return fd_; } private: + void listControls(); + + std::map controls_; std::string deviceNode_; int fd_; }; diff --git a/src/libcamera/v4l2_device.cpp b/src/libcamera/v4l2_device.cpp index 99621a724b96..51764b441f92 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,8 @@ int V4L2Device::open(unsigned int flags) fd_ = ret; + listControls(); + return 0; } @@ -107,6 +110,21 @@ void V4L2Device::close() * \return True if the V4L2 device node is open, false otherwise */ +/** + * \brief Retrieve information about a control + * \param[in] id The control ID + * \return A pointer to the V4L2ControlInfo for control \a id, or nullptr + * if the device doesn't have such a control + */ +const V4L2ControlInfo *V4L2Device::getControlInfo(unsigned int id) const +{ + auto it = controls_.find(id); + if (it == controls_.end()) + return nullptr; + + return &it->second; +} + /** * \brief Perform an IOCTL system call on the device node * \param[in] request The IOCTL request code @@ -137,4 +155,43 @@ int V4L2Device::ioctl(unsigned long request, void *argp) * \return The V4L2 device file descriptor, -1 if the device node is not open */ +/* + * \brief List and store information about 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; + } + + V4L2ControlInfo info(ctrl); + switch (info.type()) { + case V4L2_CTRL_TYPE_INTEGER: + case V4L2_CTRL_TYPE_BOOLEAN: + case V4L2_CTRL_TYPE_MENU: + case V4L2_CTRL_TYPE_BUTTON: + case V4L2_CTRL_TYPE_INTEGER64: + case V4L2_CTRL_TYPE_BITMASK: + case V4L2_CTRL_TYPE_INTEGER_MENU: + break; + /* \todo Support compound controls. */ + default: + LOG(V4L2, Error) << "Control type '" << info.type() + << "' not supported"; + continue; + } + + controls_.emplace(ctrl.id, info); + ctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL; + } +} + } /* namespace libcamera */ From patchwork Mon Jun 24 14:28: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: 1506 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 51B98615BC for ; Mon, 24 Jun 2019 16:27: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 relay7-d.mail.gandi.net (Postfix) with ESMTPSA id DDE722000E; Mon, 24 Jun 2019 14:27:51 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Mon, 24 Jun 2019 16:28:56 +0200 Message-Id: <20190624142859.19313-4-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190624142859.19313-1-jacopo@jmondi.org> References: <20190624142859.19313-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v6 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: Mon, 24 Jun 2019 14:27:52 -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 Reviewed-by: Laurent Pinchart --- src/libcamera/include/v4l2_device.h | 9 ++ src/libcamera/v4l2_device.cpp | 186 ++++++++++++++++++++++++++++ 2 files changed, 195 insertions(+) diff --git a/src/libcamera/include/v4l2_device.h b/src/libcamera/include/v4l2_device.h index 556960467e10..39a47f55acb8 100644 --- a/src/libcamera/include/v4l2_device.h +++ b/src/libcamera/include/v4l2_device.h @@ -10,11 +10,14 @@ #include #include +#include + #include "log.h" namespace libcamera { class V4L2ControlInfo; +class V4L2ControlList; class V4L2Device : protected Loggable { @@ -23,6 +26,8 @@ public: bool isOpen() const { return fd_ != -1; } const V4L2ControlInfo *getControlInfo(unsigned int id) const; + int getControls(V4L2ControlList *ctrls); + int setControls(V4L2ControlList *ctrls); const std::string &deviceNode() const { return deviceNode_; } @@ -38,6 +43,10 @@ protected: private: void listControls(); + void updateControls(V4L2ControlList *ctrls, + const V4L2ControlInfo **controlInfo, + struct v4l2_ext_control *v4l2Ctrls, + unsigned int count); std::map controls_; std::string deviceNode_; diff --git a/src/libcamera/v4l2_device.cpp b/src/libcamera/v4l2_device.cpp index 51764b441f92..6319d1cfaaa1 100644 --- a/src/libcamera/v4l2_device.cpp +++ b/src/libcamera/v4l2_device.cpp @@ -125,6 +125,156 @@ const V4L2ControlInfo *V4L2Device::getControlInfo(unsigned int id) const return &it->second; } +/** + * \brief Read controls from the device + * \param[inout] ctrls The list of controls to read + * + * This method reads the value of all controls contained in \a ctrls, and stores + * their values in the corresponding \a ctrls entry. + * + * If any control in \a ctrls is not supported by the device, is disabled (i.e. + * has the V4L2_CTRL_FLAG_DISABLED flag set), is a compound control, or if any + * other error occurs during validation of the requested controls, no control is + * read and this method returns -EINVAL. + * + * If an error occurs while reading the controls, the index of the first control + * that couldn't be read is returned. The value of all controls below that index + * are updated in \a ctrls, while the value of all the other controls are not + * changed. + */ +int V4L2Device::getControls(V4L2ControlList *ctrls) +{ + unsigned int count = ctrls->size(); + if (count == 0) + return 0; + + const V4L2ControlInfo *controlInfo[count] = {}; + struct v4l2_ext_control v4l2Ctrls[count] = {}; + for (V4L2Control &ctrl : *ctrls) { + const V4L2ControlInfo *info = getControlInfo(ctrl.id()); + if (!info) { + LOG(V4L2, Error) + << "Control '" << ctrl.id() << "' not found"; + return -EINVAL; + } + + controlInfo[i] = info; + v4l2Ctrls[i].id = info->id(); + } + + 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) { + unsigned int errorIdx = v4l2ExtCtrls.error_idx; + + /* Generic validation error. */ + if (errorIdx == 0 || errorIdx >= count) { + LOG(V4L2, Error) << "Unable to read controls: " + << strerror(ret); + return -EINVAL; + } + + /* A specific control failed. */ + LOG(V4L2, Error) << "Unable to read control " << errorIdx + << ": " << strerror(ret); + count = errorIdx - 1; + ret = errorIdx; + } + + updateControls(ctrls, controlInfo, v4l2Ctrls, count); + + return ret; +} + +/** + * \brief Write controls to the device + * \param[in] ctrls The list of controls to write + * + * This method writes the value of all controls contained in \a ctrls, and + * stores the values actually applied to the device in the corresponding + * \a ctrls entry. + * + * If any control in \a ctrls is not supported by the device, is disabled (i.e. + * has the V4L2_CTRL_FLAG_DISABLED flag set), is read-only, is a + * compound control, or if any other error occurs during validation of + * the requested controls, no control is written and this method returns + * -EINVAL. + * + * If an error occurs while writing the controls, the index of the first + * control that couldn't be written is returned. All controls below that index + * are written and their values are updated in \a ctrls, while all other + * controls are not written and their values are not changed. + * + * \return 0 on success or an error code otherwise + * \retval -EINVAL One of the control is not supported or not accessible + * \retval i The index of the control that failed + */ +int V4L2Device::setControls(V4L2ControlList *ctrls) +{ + unsigned int count = ctrls->size(); + if (count == 0) + return 0; + + const V4L2ControlInfo *controlInfo[count] = {}; + struct v4l2_ext_control v4l2Ctrls[count] = {}; + for (V4L2Control &ctrl : *ctrls) { + const V4L2ControlInfo *info = getControlInfo(ctrl.id()); + if (!info) { + LOG(V4L2, Error) + << "Control '" << ctrl.id() << "' not found"; + return -EINVAL; + } + + controlInfo[i] = info; + v4l2Ctrls[i].id = info->id(); + + /* Set the v4l2_ext_control value for the write operation. */ + switch (info->type()) { + case V4L2_CTRL_TYPE_INTEGER64: + v4l2Ctrls[i].value64 = ctrl.value(); + break; + default: + /* + * \todo To be changed when support for string and + * compound controls will be added. + */ + v4l2Ctrls[i].value = 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) { + unsigned int errorIdx = v4l2ExtCtrls.error_idx; + + /* Generic validation error. */ + if (errorIdx == 0 || errorIdx >= count) { + LOG(V4L2, Error) << "Unable to read controls: " + << strerror(ret); + return -EINVAL; + } + + /* A specific control failed. */ + LOG(V4L2, Error) << "Unable to read control " << errorIdx + << ": " << strerror(ret); + count = errorIdx - 1; + ret = errorIdx; + } + + updateControls(ctrls, controlInfo, v4l2Ctrls, count); + + return ret; +} + /** * \brief Perform an IOCTL system call on the device node * \param[in] request The IOCTL request code @@ -194,4 +344,40 @@ void V4L2Device::listControls() } } +/* + * \brief Update the value of \a count V4L2 controls in \a ctrls using values + * in \a v4l2Ctrls + * \param[inout] ctrls List of V4L2 controls to update + * \param[in] controlInfo List of V4L2 control information + * \param[in] v4l2Ctrls List of V4L2 extended controls as returned by the driver + * \param[in] count The number of controls to update + */ +void V4L2Device::updateControls(V4L2ControlList *ctrls, + const V4L2ControlInfo **controlInfo, + struct v4l2_ext_control *v4l2Ctrls, + unsigned int count) +{ + unsigned int i = 0; + for (V4L2Control &ctrl : *ctrls) { + struct v4l2_ext_control *v4l2Ctrl = &v4l2Ctrls[i]; + const V4L2ControlInfo *info = controlInfo[i]; + + switch (info->type()) { + case V4L2_CTRL_TYPE_INTEGER64: + ctrl.setValue(v4l2Ctrl->value64); + break; + default: + /* + * \todo To be changed when support for string and + * compound controls will be added. + */ + ctrl.setValue(v4l2Ctrl->value); + break; + } + + if (++i == count) + break; + } +} + } /* namespace libcamera */ From patchwork Mon Jun 24 14:28: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: 1507 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 18A526162F for ; Mon, 24 Jun 2019 16:27:53 +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 relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 766352000D; Mon, 24 Jun 2019 14:27:52 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Mon, 24 Jun 2019 16:28:57 +0200 Message-Id: <20190624142859.19313-5-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190624142859.19313-1-jacopo@jmondi.org> References: <20190624142859.19313-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v6 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: Mon, 24 Jun 2019 14:27:53 -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 Reviewed-by: Laurent Pinchart --- src/libcamera/camera_sensor.cpp | 69 +++++++++++++++++++++++++++ src/libcamera/include/camera_sensor.h | 6 +++ 2 files changed, 75 insertions(+) diff --git a/src/libcamera/camera_sensor.cpp b/src/libcamera/camera_sensor.cpp index a804a68c9d91..471c3e2e6e47 100644 --- a/src/libcamera/camera_sensor.cpp +++ b/src/libcamera/camera_sensor.cpp @@ -247,6 +247,75 @@ int CameraSensor::setFormat(V4L2SubdeviceFormat *format) return subdev_->setFormat(0, format); } +/** + * \brief Retrieve information about a control + * \param[in] id The control ID + * \return A pointer to the V4L2ControlInfo for control \a id, or nullptr + * if the sensor doesn't have such a control + */ +const V4L2ControlInfo *CameraSensor::getControlInfo(unsigned int id) const +{ + return subdev_->getControlInfo(id); +} + +/** + * \brief Read controls from the sensor + * \param[inout] ctrls The list of controls to read + * + * This method reads the value of all controls contained in \a ctrls, and stores + * their values in the corresponding \a ctrls entry. + * + * If any control in \a ctrls is not supported by the device, is disabled (i.e. + * has the V4L2_CTRL_FLAG_DISABLED flag set), is a compound control, or if any + * other error occurs during validation of the requested controls, no control is + * read and this method returns -EINVAL. + * + * If an error occurs while reading the controls, the index of the first control + * that couldn't be read is returned. The value of all controls below that index + * are updated in \a ctrls, while the value of all the other controls are not + * changed. + * + * \sa V4L2Device::getControls() + * + * \return 0 on success or an error code otherwise + * \retval -EINVAL One of the control is not supported or not accessible + * \retval i The index of the control that failed + */ +int CameraSensor::getControls(V4L2ControlList *ctrls) +{ + return subdev_->getControls(ctrls); +} + +/** + * \brief Write controls to the sensor + * \param[in] ctrls The list of controls to write + * + * This method writes the value of all controls contained in \a ctrls, and + * stores the values actually applied to the device in the corresponding + * \a ctrls entry. + * + * If any control in \a ctrls is not supported by the device, is disabled (i.e. + * has the V4L2_CTRL_FLAG_DISABLED flag set), is read-only, is a + * compound control, or if any other error occurs during validation of + * the requested controls, no control is written and this method returns + * -EINVAL. + * + * If an error occurs while writing the controls, the index of the first + * control that couldn't be written is returned. All controls below that index + * are written and their values are updated in \a ctrls, while all other + * controls are not written and their values are not changed. + * + * \sa V4L2Device::setControls() + * + * \return 0 on success or an error code otherwise + * \retval -EINVAL One of the control is not supported or not accessible + * \retval i The index of the control that failed + */ +int CameraSensor::setControls(V4L2ControlList *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..b42e7b8e1343 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 V4L2ControlList; class V4L2Subdevice; struct V4L2SubdeviceFormat; @@ -41,6 +43,10 @@ public: const Size &size) const; int setFormat(V4L2SubdeviceFormat *format); + const V4L2ControlInfo *getControlInfo(unsigned int id) const; + int getControls(V4L2ControlList *ctrls); + int setControls(V4L2ControlList *ctrls); + protected: std::string logPrefix() const; From patchwork Mon Jun 24 14:28: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: 1508 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 00C1C61617 for ; Mon, 24 Jun 2019 16:27:53 +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 relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 3CB4A20006; Mon, 24 Jun 2019 14:27:53 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Mon, 24 Jun 2019 16:28:58 +0200 Message-Id: <20190624142859.19313-6-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190624142859.19313-1-jacopo@jmondi.org> References: <20190624142859.19313-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v6 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: Mon, 24 Jun 2019 14:27:54 -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 Reviewed-by: Laurent Pinchart Reviewed-by: Kieran Bingham --- src/libcamera/pipeline/ipu3/ipu3.cpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/libcamera/pipeline/ipu3/ipu3.cpp b/src/libcamera/pipeline/ipu3/ipu3.cpp index 1c0a9825b4cd..0fb044ba5513 100644 --- a/src/libcamera/pipeline/ipu3/ipu3.cpp +++ b/src/libcamera/pipeline/ipu3/ipu3.cpp @@ -22,6 +22,7 @@ #include "media_device.h" #include "pipeline_handler.h" #include "utils.h" +#include "v4l2_controls.h" #include "v4l2_subdevice.h" #include "v4l2_videodevice.h" @@ -194,6 +195,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, @@ -559,6 +566,17 @@ int PipelineHandlerIPU3::configure(Camera *camera, CameraConfiguration *c) if (ret) return ret; + /* Apply the "pipe_mode" control to the ImgU subdevice. */ + V4L2ControlList ctrls; + ctrls.add(V4L2_CID_IPU3_PIPE_MODE, vfStream->active_ ? + IPU3PipeModeVideo : + IPU3PipeModeStillCapture); + ret = imgu->imgu_->setControls(&ctrls); + if (ret) { + LOG(IPU3, Error) << "Unable to set pipe_mode control"; + return ret; + } + return 0; } From patchwork Mon Jun 24 14:28:59 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 1509 Return-Path: Received: from relay7-d.mail.gandi.net (relay7-d.mail.gandi.net [217.70.183.200]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 89C0961617 for ; Mon, 24 Jun 2019 16:27:54 +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 relay7-d.mail.gandi.net (Postfix) with ESMTPSA id 2B1B220009; Mon, 24 Jun 2019 14:27:53 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Mon, 24 Jun 2019 16:28:59 +0200 Message-Id: <20190624142859.19313-7-jacopo@jmondi.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190624142859.19313-1-jacopo@jmondi.org> References: <20190624142859.19313-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v6 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: Mon, 24 Jun 2019 14:27:55 -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 | 41 ++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/src/libcamera/pipeline/ipu3/ipu3.cpp b/src/libcamera/pipeline/ipu3/ipu3.cpp index 0fb044ba5513..6688ac7f4db7 100644 --- a/src/libcamera/pipeline/ipu3/ipu3.cpp +++ b/src/libcamera/pipeline/ipu3/ipu3.cpp @@ -677,6 +677,47 @@ int PipelineHandlerIPU3::start(Camera *camera) ImgUDevice *imgu = data->imgu_; int ret; + /* --- Get control values --- */ + V4L2ControlList 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(); + const V4L2ControlInfo *info = cio2->sensor_->getControlInfo(id); + if (!info) + continue; + + LOG(Error) << "Control : " << id << " - name : " << info->name() + << " - value: " << ctrl.value(); + } + + /* --- Set control values --- */ + controls.clear(); + controls.add(V4L2_CID_EXPOSURE, 2046); + controls.add(V4L2_CID_ANALOGUE_GAIN, 1024); + + ret = cio2->sensor_->setControls(&controls); + if (ret) { + LOG(IPU3, Error) << "Failed to set controls"; + return ret; + } + + for (const V4L2Control &ctrl : controls) { + unsigned int id = ctrl.id(); + const V4L2ControlInfo *info = cio2->sensor_->getControlInfo(id); + if (!info) + continue; + + LOG(Error) << "Control : " << id << " - name : " << info->name() + << " - value: " << ctrl.value(); + } + /* * Start the ImgU video devices, buffers will be queued to the * ImgU output and viewfinder when requests will be queued.