libcamera/vivid.git - libcamera pipeline handler for VIVID

diff options

author	Niklas Söderlund <niklas.soderlund@ragnatech.se>	2020-03-04 23:57:56 +0100
committer	Niklas Söderlund <niklas.soderlund@ragnatech.se>	2020-03-06 17:45:48 +0100
commit	bab5749227b38e62261c944480ed452833528464 (patch)
tree	da30f75d056d85b683660a26cf78a99e0f20d826 /Documentation/theme/search.html
parent	353851b773a6f2a381e5b4e93598c44bbd42903a (diff)

libcamera: V4L2BufferCache: Use the entry reference

Instead of looking up the index in the storage vector use the reference to it created at the beginning of the loop. Signed-off-by: Niklas Söderlund <niklas.soderlund@ragnatech.se> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

Diffstat (limited to 'Documentation/theme/search.html')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright 2022 NXP * * Generic format converter interface */ #include "libcamera/internal/converter.h" #include <algorithm> #include <libcamera/base/log.h> #include "libcamera/internal/media_device.h" /** * \file converter.h * \brief Abstract converter */ namespace libcamera { LOG_DEFINE_CATEGORY(Converter) /** * \class Converter * \brief Abstract Base Class for converter * * The Converter class is an Abstract Base Class defining the interfaces of * converter implementations. * * Converters offer scaling and pixel format conversion services on an input * stream. The converter can output multiple streams with individual conversion * parameters from the same input stream. */ /** * \brief Construct a Converter instance * \param[in] media The media device implementing the converter * * This searches for the entity implementing the data streaming function in the * media graph entities and use its device node as the converter device node. */ Converter::Converter(MediaDevice *media) { const std::vector<MediaEntity *> &entities = media->entities(); auto it = std::find_if(entities.begin(), entities.end(), [](MediaEntity *entity) { return entity->function() == MEDIA_ENT_F_IO_V4L; }); if (it == entities.end()) { LOG(Converter, Error) << "No entity suitable for implementing a converter in " << media->driver() << " entities list."; return; } deviceNode_ = (*it)->deviceNode(); } Converter::~Converter() { } /** * \fn Converter::loadConfiguration() * \brief Load converter configuration from file * \param[in] filename The file name path * * Load converter dependent configuration parameters to apply on the hardware. * * \return 0 on success or a negative error code otherwise */ /** * \fn Converter::isValid() * \brief Check if the converter configuration is valid * \return True is the converter is valid, false otherwise */ /** * \fn Converter::formats() * \brief Retrieve the list of supported pixel formats for an input pixel format * \param[in] input Input pixel format to retrieve output pixel format list for * \return The list of supported output pixel formats */ /** * \fn Converter::sizes() * \brief Retrieve the range of minimum and maximum output sizes for an input size * \param[in] input Input stream size to retrieve range for * \return A range of output image sizes */ /** * \fn Converter::strideAndFrameSize() * \brief Retrieve the output stride and frame size for an input configutation * \param[in] pixelFormat Input stream pixel format * \param[in] size Input stream size * \return A tuple indicating the stride and frame size or an empty tuple on error */ /** * \fn Converter::configure() * \brief Configure a set of output stream conversion from an input stream * \param[in] inputCfg Input stream configuration * \param[out] outputCfgs A list of output stream configurations * \return 0 on success or a negative error code otherwise */ /** * \fn Converter::exportBuffers() * \brief Export buffers from the converter device * \param[in] stream Output stream pointer exporting the buffers * \param[in] count Number of buffers to allocate * \param[out] buffers Vector to store allocated buffers * * This function operates similarly to V4L2VideoDevice::exportBuffers() on the * output stream indicated by the \a output. * * \return The number of allocated buffers on success or a negative error code * otherwise */ /** * \fn Converter::start() * \brief Start the converter streaming operation * \return 0 on success or a negative error code otherwise */ /** * \fn Converter::stop() * \brief Stop the converter streaming operation */ /** * \fn Converter::queueBuffers() * \brief Queue buffers to converter device * \param[in] input The frame buffer to apply the conversion * \param[out] outputs The container holding the output stream pointers and * their respective frame buffer outputs. * * This function queues the \a input frame buffer on the output streams of the * \a outputs map key and retrieve the output frame buffer indicated by the * buffer map value. * * \return 0 on success or a negative error code otherwise */ /** * \var Converter::inputBufferReady * \brief A signal emitted when the input frame buffer completes */ /** * \var Converter::outputBufferReady * \brief A signal emitted on each frame buffer completion of the output queue */ /** * \fn Converter::deviceNode() * \brief The converter device node attribute accessor * \return The converter device node string */ /** * \class ConverterFactoryBase * \brief Base class for converter factories * * The ConverterFactoryBase class is the base of all specializations of the * ConverterFactory class template. It implements the factory registration, * maintains a registry of factories, and provides access to the registered * factories. */ /** * \brief Construct a converter factory base * \param[in] name Name of the converter class * \param[in] compatibles Name aliases of the converter class * * Creating an instance of the factory base registers it with the global list of * factories, accessible through the factories() function. * * The factory \a name is used as unique identifier. If the converter * implementation fully relies on a generic framework, the name should be the * same as the framework. Otherwise, if the implementation is specialized, the * factory name should match the driver name implementing the function. * * The factory \a compatibles holds a list of driver names implementing a generic * subsystem without any personalizations. */ ConverterFactoryBase::ConverterFactoryBase(const std::string name, std::initializer_list<std::string> compatibles) : name_(name), compatibles_(compatibles) { registerType(this); } /** * \fn ConverterFactoryBase::compatibles() * \return The list of compatible name aliases of the converter */ /** * \brief Create an instance of the converter corresponding to the media device * \param[in] media The media device to create the converter for * * The converter is created by matching the factory name or any of its * compatible aliases with the media device driver name. * * \return A new instance of the converter subclass corresponding to the media * device, or null if the media device driver name doesn't match anything */ std::unique_ptr<Converter> ConverterFactoryBase::create(MediaDevice *media) { const std::vector<ConverterFactoryBase *> &factories = ConverterFactoryBase::factories(); for (const ConverterFactoryBase *factory : factories) {


context:
space:
mode: