libcamera/libcamera.git - libcamera official repository

diff options

author	Sebastian Fricke <sebastian.fricke@posteo.net>	2021-01-26 19:48:51 +0100
committer	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2021-02-04 21:00:38 +0200
commit	11a946bc22212abd9eef467633e8ab359df57299 (patch)
tree	bb2bb2c0792ed88e984464f799cb780d555025c8 /src/qcam/assets/feathericons/phone.svg
parent	83e434b2dccbcc3c9653767dce000052e1e52297 (diff)

libcamera: bayer_format: Remove unnecessary constructor

The new `fromV4l2PixelFormat` static member function renders an old BayerFormat constructor useless, remove it together with the `v4l2ToBayer` mapping table. The new function searches for a matching mapped value instead of a matching key, therefore the `bayerToV4l2` table is sufficient. Signed-off-by: Sebastian Fricke <sebastian.fricke@posteo.net> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

Diffstat (limited to 'src/qcam/assets/feathericons/phone.svg')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2018, Google Inc. * * media_device.cpp - Media device handler */ #include "libcamera/internal/media_device.h" #include <errno.h> #include <fcntl.h> #include <stdint.h> #include <string> #include <string.h> #include <sys/ioctl.h> #include <unistd.h> #include <vector> #include <linux/media.h> #include <libcamera/base/log.h> /** * \file media_device.h * \brief Provide a representation of a Linux kernel Media Controller device * that exposes the full graph topology. */ namespace libcamera { LOG_DEFINE_CATEGORY(MediaDevice) /** * \class MediaDevice * \brief The MediaDevice represents a Media Controller device with its full * graph of connected objects. * * A MediaDevice instance is associated with a media controller device node when * created, and that association is kept for the lifetime of the MediaDevice * instance. * * The instance is created with an empty media graph. Before performing any * other operation, it must be populate by calling populate(). Instances of * MediaEntity, MediaPad and MediaLink are created to model the media graph, * and stored in a map indexed by object id. * * The graph is valid once successfully populated, as reported by the isValid() * function. It can be queried to list all entities(), or entities can be * looked up by name with getEntityByName(). The graph can be traversed from * entity to entity through pads and links as exposed by the corresponding * classes. * * Media devices can be claimed for exclusive use with acquire(), released with * release() and tested with busy(). This mechanism is aimed at pipeline * managers to claim media devices they support during enumeration. */ /** * \brief Construct a MediaDevice * \param[in] deviceNode The media device node path * * Once constructed the media device is invalid, and must be populated with * populate() before the media graph can be queried. */ MediaDevice::MediaDevice(const std::string &deviceNode) : deviceNode_(deviceNode), valid_(false), acquired_(false) { } MediaDevice::~MediaDevice() { fd_.reset(); clear(); } std::string MediaDevice::logPrefix() const { return deviceNode() + "[" + driver() + "]"; } /** * \brief Claim a device for exclusive use * * The device claiming mechanism offers simple media device access arbitration * between multiple users. When the media device is created, it is available to * all users. Users can query the media graph to determine whether they can * support the device and, if they do, claim the device for exclusive use. Other * users are then expected to skip over media devices in use as reported by the * busy() function. * * Once claimed the device shall be released by its user when not needed anymore * by calling the release() function. Acquiring the media device opens a file * descriptor to the device which is kept open until release() is called. * * Exclusive access is only guaranteed if all users of the media device abide by * the device claiming mechanism, as it isn't enforced by the media device * itself. * * \return true if the device was successfully claimed, or false if it was * already in use * \sa release(), busy() */ bool MediaDevice::acquire() { if (acquired_) return false; if (open()) return false; acquired_ = true; return true; } /** * \brief Release a device previously claimed for exclusive use * \sa acquire(), busy() */ void MediaDevice::release() { close(); acquired_ = false; } /** * \brief Lock the device to prevent it from being used by other instances of * libcamera * * Multiple instances of libcamera might be running on the same system, at the * same time. To allow the different instances to coexist, system resources in * the form of media devices must be accessible for enumerating the cameras * they provide at all times, while still allowing an instance to lock a * resource while it prepares to actively use a camera from the resource. * * This function shall not be called from a pipeline handler implementation * directly, as the base PipelineHandler implementation handles this on the * behalf of the specified implementation. * * \return True if the device could be locked, false otherwise * \sa unlock() */ bool MediaDevice::lock() { if (!fd_.isValid()) return false; if (lockf(fd_.get(), F_TLOCK, 0)) return false; return true; } /** * \brief Unlock the device and free it for use for libcamera instances * * This function shall not be called from a pipeline handler implementation * directly, as the base PipelineHandler implementation handles this on the * behalf of the specified implementation. * * \sa lock() */ void MediaDevice::unlock() { if (!fd_.isValid()) return; lockf(fd_.get(), F_ULOCK, 0); } /** * \fn MediaDevice::busy() * \brief Check if a device is in use * \return true if the device has been claimed for exclusive use, or false if it * is available * \sa acquire(), release() */ /** * \brief Populate the MediaDevice with device information and media objects * * This function retrieves the media device information and enumerates all * media objects in the media device graph and creates their MediaObject * representations. All entities, pads and links are stored as MediaEntity, * MediaPad and MediaLink respectively, with cross-references between objects. * Interfaces are not processed. * * Entities are stored in a separate list in the MediaDevice to ease lookup, * while pads are accessible from the entity they belong to and links from the * pads they connect. * * \return 0 on success or a negative error code otherwise */ int MediaDevice::populate() { struct media_v2_topology topology = {}; struct media_v2_entity *ents = nullptr; struct media_v2_interface *interfaces = nullptr; struct media_v2_link *links = nullptr; struct media_v2_pad *pads = nullptr; __u64 version = -1; int ret; clear(); ret = open(); if (ret) return ret; struct media_device_info info = {}; ret = ioctl(fd_.get(), MEDIA_IOC_DEVICE_INFO, &info); if (ret) { ret = -errno; LOG(MediaDevice, Error) << "Failed to get media device info " << strerror(-ret); goto done; } driver_ = info.driver; model_ = info.model; version_ = info.media_version; hwRevision_ = info.hw_revision; /* * Keep calling G_TOPOLOGY until the version number stays stable. */ while (true) { topology.topology_version = 0; topology.ptr_entities = reinterpret_cast<uintptr_t>(ents); topology.ptr_interfaces = reinterpret_cast<uintptr_t>(interfaces); topology.ptr_links = reinterpret_cast<uintptr_t>(links); topology.ptr_pads = reinterpret_cast<uintptr_t>(pads); ret = ioctl(fd_.get(), MEDIA_IOC_G_TOPOLOGY, &topology); if (ret < 0) { ret = -errno; LOG(MediaDevice, Error) << "Failed to enumerate topology: " << strerror(-ret); goto done; } if (version == topology.topology_version) break; delete[] ents; delete[] interfaces; delete[] pads; delete[] links; ents = new struct media_v2_entity[topology.num_entities](); interfaces = new struct media_v2_interface[topology.num_interfaces](); links = new struct media_v2_link[topology.num_links](); pads = new struct media_v2_pad[topology.num_pads](); version = topology.topology_version; } /* Populate entities, pads and links. */ if (populateEntities(topology) && populatePads(topology) && populateLinks(topology)) valid_ = true; ret = 0; done: close(); delete[] ents; delete[] interfaces; delete[] pads; delete[] links; if (!valid_) { clear(); return -EINVAL; } return ret; } /** * \fn MediaDevice::isValid() * \brief Query whether the media graph has been populated and is valid * \return true if the media graph is valid, false otherwise */ /** * \fn MediaDevice::driver() * \brief Retrieve the media device driver name * \return The name of the kernel driver that handles the MediaDevice */ /** * \fn MediaDevice::deviceNode() * \brief Retrieve the media device node path * \return The MediaDevice deviceNode path */ /** * \fn MediaDevice::model() * \brief Retrieve the media device model name * \return The MediaDevice model name */ /** * \fn MediaDevice::version() * \brief Retrieve the media device API version * * The version is formatted with the KERNEL_VERSION() macro. * * \return The MediaDevice API version */ /** * \fn MediaDevice::hwRevision() * \brief Retrieve the media device hardware revision * * The hardware revision is in a driver-specific format. * * \return The MediaDevice hardware revision */ /** * \fn MediaDevice::entities() * \brief Retrieve the list of entities in the media graph * \return The list of MediaEntities registered in the MediaDevice */ /** * \brief Return the MediaEntity with name \a name * \param[in] name The entity name * \return The entity with \a name, or nullptr if no such entity is found */ MediaEntity *MediaDevice::getEntityByName(const std::string &name) const { for (MediaEntity *e : entities_) if (e->name() == name) return e; return nullptr; } /** * \brief Retrieve the MediaLink connecting two pads, identified by entity * names and pad indexes * \param[in] sourceName The source entity name * \param[in] sourceIdx The index of the source pad * \param[in] sinkName The sink entity name * \param[in] sinkIdx The index of the sink pad * * Find the link that connects the pads at index \a sourceIdx of the source * entity with name \a sourceName, to the pad at index \a sinkIdx of the * sink entity with name \a sinkName, if any. * * \sa MediaDevice::link(const MediaEntity *source, unsigned int sourceIdx, const MediaEntity *sink, unsigned int sinkIdx) const * \sa MediaDevice::link(const MediaPad *source, const MediaPad *sink) const * * \return The link that connects the two pads, or nullptr if no such a link * exists */ MediaLink *MediaDevice::link(const std::string &sourceName, unsigned int sourceIdx, const std::string &sinkName, unsigned int sinkIdx) { const MediaEntity *source = getEntityByName(sourceName); const MediaEntity *sink = getEntityByName(sinkName); if (!source || !sink) return nullptr; return link(source, sourceIdx, sink, sinkIdx); } /** * \brief Retrieve the MediaLink connecting two pads, identified by the * entities they belong to and pad indexes


context:
space:
mode: