libcamera/libcamera.git - libcamera official repository

diff options

author	Kieran Bingham <kieran.bingham@ideasonboard.com>	2021-03-23 13:55:09 +0000
committer	Kieran Bingham <kieran.bingham@ideasonboard.com>	2021-03-29 12:18:02 +0100
commit	70238ceca5b2f0be1330ecb9664ae0f59f151152 (patch)
tree	d4fb849274346c59b92f3faf2caf19be7a1eeac1 /src/qcam/assets/feathericons/trending-down.svg
parent	e7d367bf65c749ca1cee79db6d12a1fc130ff80e (diff)

utils: ipc: proxy: Track IPA with a state machine

Asynchronous tasks can only be submitted while the IPA is running. Further more, the shutdown sequence can not be tracked with a simple running flag. We can also be in the state 'Stopping' where we have not yet completed all events, but we must not commence anything new. Refactor the running_ boolean into a stateful enum to track this. Reviewed-by: Paul Elder <paul.elder@ideasonboard.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Signed-off-by: Kieran Bingham <kieran.bingham@ideasonboard.com>

Diffstat (limited to 'src/qcam/assets/feathericons/trending-down.svg')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2019, Google Inc. * * framebuffer_allocator.cpp - FrameBuffer allocator */ #include <libcamera/framebuffer_allocator.h> #include <errno.h> #include <libcamera/buffer.h> #include <libcamera/camera.h> #include <libcamera/stream.h> #include "libcamera/internal/log.h" #include "libcamera/internal/pipeline_handler.h" /** * \file framebuffer_allocator.h * \brief FrameBuffer allocator */ namespace libcamera { LOG_DEFINE_CATEGORY(Allocator) /** * \class FrameBufferAllocator * \brief FrameBuffer allocator for applications * * The libcamera API is designed to consume buffers provided by applications as * FrameBuffer instances. This makes libcamera a user of buffers exported by * other devices (such as displays or video encoders), or allocated from an * external allocator (such as ION on Android platforms). In some situations, * applications do not have any means to allocate or get hold of suitable * buffers, for instance when no other device is involved, on Linux platforms * that lack a centralized allocator. The FrameBufferAllocator class provides a * buffer allocator that can be used in these situations. * * Applications create a framebuffer allocator for a Camera, and use it to * allocate buffers for streams of a CameraConfiguration with allocate(). They * control which streams to allocate buffers for, and can thus use external * buffers for a subset of the streams if desired. * * Buffers are deleted for a stream with free(), and destroying the allocator * automatically deletes all allocated buffers. Applications own the buffers * allocated by the FrameBufferAllocator and are responsible for ensuring the * buffers are not deleted while they are in use (part of a Request that has * been queued and hasn't completed yet). * * Usage of the FrameBufferAllocator is optional, if all buffers for a camera * are provided externally applications shall not use this class. */ /** * \brief Construct a FrameBufferAllocator serving a camera * \param[in] camera The camera */ FrameBufferAllocator::FrameBufferAllocator(std::shared_ptr<Camera> camera) : camera_(camera) { } FrameBufferAllocator::~FrameBufferAllocator() { buffers_.clear(); } /** * \brief Allocate buffers for a configured stream * \param[in] stream The stream to allocate buffers for * * Allocate buffers suitable for capturing frames from the \a stream. The Camera * shall have been previously configured with Camera::configure() and shall be * stopped, and the stream shall be part of the active camera configuration. * * Upon successful allocation, the allocated buffers can be retrieved with the * buffers() method. * * \return The number of allocated buffers on success or a negative error code * otherwise * \retval -EACCES The camera is not in a state where buffers can be allocated * \retval -EINVAL The \a stream does not belong to the camera or the stream is * not part of the active camera configuration * \retval -EBUSY Buffers are already allocated for the \a stream */ int FrameBufferAllocator::allocate(Stream *stream) { if (buffers_.count(stream)) { LOG(Allocator, Error) << "Buffers already allocated for stream"; return -EBUSY; } int ret = camera_->exportFrameBuffers(stream, &buffers_[stream]); if (ret == -EINVAL) LOG(Allocator, Error) << "Stream is not part of " << camera_->id() << " active configuration"; return ret; } /** * \brief Free buffers previously allocated for a \a stream * \param[in] stream The stream * * Free buffers allocated with allocate(). * * This invalidates the buffers returned by buffers(). * * \return 0 on success or a negative error code otherwise * \retval -EACCES The camera is not in a state where buffers can be freed * \retval -EINVAL The allocator do not handle the \a stream */ int FrameBufferAllocator::free(Stream *stream) { auto iter = buffers_.find(stream); if (iter == buffers_.end())


context:
space:
mode: