/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2019, Google Inc. * * main.cpp - cam - The libcamera swiss army knife */ #include #include #include #include #include #include #include "capture.h" #include "event_loop.h" #include "main.h" #include "options.h" #include "stream_options.h" using namespace libcamera; class CamApp { public: CamApp(); ~CamApp(); static CamApp *instance(); int init(int argc, char **argv); void cleanup(); int exec(); void quit(); private: int parseOptions(int argc, char *argv[]); int prepareConfig(); int listControls(); int listProperties(); int infoConfiguration(); int run(); static CamApp *app_; OptionsParser::Options options_; CameraManager *cm_; std::shared_ptr camera_; std::unique_ptr config_; EventLoop *loop_; }; CamApp *CamApp::app_ = nullptr; CamApp::CamApp() : cm_(nullptr), camera_(nullptr), config_(nullptr), loop_(nullptr) { CamApp::app_ = this; } CamApp::~CamApp() { delete cm_; } CamApp *CamApp::instance() { return CamApp::app_; } int CamApp::init(int argc, char **argv) { int ret; ret = parseOptions(argc, argv); if (ret < 0) return ret; cm_ = new CameraManager(); ret = cm_->start(); if (ret) { std::cout << "Failed to start camera manager: " << strerror(-ret) << std::endl; return ret; } if (options_.isSet(OptCamera)) { const std::string &cameraName = options_[OptCamera]; char *endptr; unsigned long index = strtoul(cameraName.c_str(), &endptr, 10); if (*endptr == '\0' && index > 0 && index <= cm_->cameras().size()) camera_ = cm_->cameras()[index - 1]; else camera_ = cm_->get(cameraName); if (!camera_) { std::cout << "Camera " << std::string(options_[OptCamera]) << " not found" << std::endl; cm_->stop(); return -ENODEV; } if (camera_->acquire()) { std::cout << "Failed to acquire camera" << std::endl; camera_.reset(); cm_->stop(); return -EINVAL; } std::cout << "Using camera " << camera_->name() << std::endl; ret = prepareConfig(); if (ret) return ret; } loop_ = new EventLoop(cm_->eventDispatcher()); return 0; } void CamApp::cleanup() { delete loop_; loop_ = nullptr; if (camera_) { camera_->release(); camera_.reset(); } config_.reset(); cm_->stop(); } int CamApp::exec() { int ret; ret = run(); cleanup(); return ret; } void CamApp::quit() { if (loop_) loop_->exit(); } int CamApp::parseOptions(int argc, char *argv[]) { StreamKeyValueParser streamKeyValue; OptionsParser parser; parser.addOption(OptCamera, OptionString, "Specify which camera to operate on, by name or by index", "camera", ArgumentRequired, "camera"); parser.addOption(OptCapture, OptionNone, "Capture until interrupted by user", "capture"); parser.addOption(OptFile, OptionString, "Write captured frames to disk\n" "The first '#' character in the file name is expanded to the stream name and frame sequence number.\n" "The default file name is 'frame-#.bin'.", "file", ArgumentOptional, "filename"); parser.addOption(OptStream, &streamKeyValue, "Set configuration of a camera stream", "stream", true); parser.addOption(OptHelp, OptionNone, "Display this help message", "help"); parser.addOption(OptInfo, OptionNone, "Display information about stream(s)", "info"); parser.addOption(OptList, OptionNone, "List all cameras", "list"); parser.addOption(OptListControls, OptionNone, "List cameras controls", "list-controls"); parser.addOption(OptListProperties, OptionNone, "List cameras properties", "list-properties"); options_ = parser.parse(argc, argv); if (!options_.valid()) return -EINVAL; if (options_.empty() || options_.isSet(OptHelp)) { parser.usage(); return options_.empty() ? -EINVAL : -EINTR; } return 0; } int CamApp::prepareConfig() { StreamRoles roles = StreamKeyValueParser::roles(options_[OptStream]); config_ = camera_->generateConfiguration(roles); if (!config_ || config_->size() != roles.size()) { std::cerr << "Failed to get default stream configuration" << std::endl; return -EINVAL; } /* Apply configuration if explicitly requested. */ if (StreamKeyValueParser::updateConfiguration(config_.get(), options_[OptStream])) { std::cerr << "Failed to update configuration" << std::endl; return -EINVAL; } switch (config_->validate()) { case CameraConfiguration::Valid: break; case CameraConfiguration::Adjusted: std::cout << "Camera configuration adjusted" << std::endl; break; case CameraConfiguration::Invalid: std::cout << "Camera configuration invalid" << std::endl; config_.reset(); return -EINVAL; } return 0; } int CamApp::listControls() { if (!camera_) { std::cout << "Cannot list controls without a camera" << std::endl; return -EINVAL; } for (const auto &ctrl : camera_->controls()) { const ControlId *id = ctrl.first; const ControlInfo &info = ctrl.second; std::cout << "Control: " << id->name() << ": " << info.toString() << std::endl; } return 0; } int CamApp::listProperties() { if (!camera_) { std::cout << "Cannot list properties without a camera" << std::endl; return -EINVAL; } for (const auto &prop : camera_->properties()) { const ControlId *id = properties::properties.at(prop.first); const ControlValue &value = prop.second; std::cout << "Property: " << id->name() << " = " << value.toString() << std::endl; } return 0; } int CamApp::infoConfiguration() { if (!config_) { std::cout << "Cannot print stream information without a camera" << std::endl; return -EINVAL; } unsigned int index = 0; for (const StreamConfiguration &cfg : *config_) { std::cout << index << ": " << cfg.toString() << std::endl; const StreamFormats &formats = cfg.formats(); for (PixelFormat pixelformat : formats.pixelformats()) { std::cout << " * Pixelformat: " << pixelformat.toString() << " " << formats.range(pixelformat).toString() << std::endl; for (const Size &size : formats.sizes(pixelformat)) std::cout << " - " << size.toString() << std::endl; } index++; } return 0; } int CamApp::run() { int ret; if (options_.isSet(OptList)) { std::cout << "Available cameras:" << std::endl; unsigned int index = 1; for (const std::shared_ptr &cam : cm_->cameras()) { std::cout << index << ": " << cam->name() << std::endl; index++; } } if (options_.isSet(OptListControls)) { ret = listControls(); if (ret) return ret; } if (options_.isSet(OptListProperties)) { ret = listProperties(); if (ret) return ret; } if (options_.isSet(OptInfo)) { ret = infoConfiguration(); if (ret) return ret; } if (options_.isSet(OptCapture)) { Capture capture(camera_, config_.get()); return capture.run(loop_, options_); } return 0; } void signalHandler(int signal) { std::cout << "Exiting" << std::endl; CamApp::instance()->quit(); } int main(int argc, char **argv) { CamApp app; int ret; ret = app.init(argc, argv); if (ret) return ret == -EINTR ? 0 : EXIT_FAILURE; struct sigaction sa = {}; sa.sa_handler = &signalHandler; sigaction(SIGINT, &sa, nullptr); if (app.exec()) return EXIT_FAILURE; return 0; } 2 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308

/* 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<const char *>(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 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
 */

/**