bfd325608d
Add a maxQueuedRequestsDevice constructor parameter to allow pipeline handler classes to limit the maximum number of requests that get queued to the device in queueRequestDevice(). The default value is set to an arbitrary number of 32 which is big enough for all currently known use cases. Signed-off-by: Kieran Bingham <kieran.bingham@ideasonboard.com> Signed-off-by: Stefan Klug <stefan.klug@ideasonboard.com> Reviewed-by: Umang Jain <uajain@igalia.com> Tested-by: Sven Püschel <s.pueschel@pengutronix.de>
146 lines
3.7 KiB
C++
146 lines
3.7 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2018, Google Inc.
|
|
*
|
|
* Pipeline handler infrastructure
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <sys/types.h>
|
|
#include <vector>
|
|
|
|
#include <libcamera/base/object.h>
|
|
|
|
#include <libcamera/controls.h>
|
|
#include <libcamera/stream.h>
|
|
|
|
namespace libcamera {
|
|
|
|
class Camera;
|
|
class CameraConfiguration;
|
|
class CameraManager;
|
|
class DeviceEnumerator;
|
|
class DeviceMatch;
|
|
class FrameBuffer;
|
|
class MediaDevice;
|
|
class PipelineHandler;
|
|
class Request;
|
|
|
|
class PipelineHandler : public std::enable_shared_from_this<PipelineHandler>,
|
|
public Object
|
|
{
|
|
public:
|
|
PipelineHandler(CameraManager *manager,
|
|
unsigned int maxQueuedRequestsDevice = 32);
|
|
virtual ~PipelineHandler();
|
|
|
|
virtual bool match(DeviceEnumerator *enumerator) = 0;
|
|
MediaDevice *acquireMediaDevice(DeviceEnumerator *enumerator,
|
|
const DeviceMatch &dm);
|
|
|
|
bool acquire(Camera *camera);
|
|
void release(Camera *camera);
|
|
|
|
virtual std::unique_ptr<CameraConfiguration> generateConfiguration(Camera *camera,
|
|
Span<const StreamRole> roles) = 0;
|
|
virtual int configure(Camera *camera, CameraConfiguration *config) = 0;
|
|
|
|
virtual int exportFrameBuffers(Camera *camera, Stream *stream,
|
|
std::vector<std::unique_ptr<FrameBuffer>> *buffers) = 0;
|
|
|
|
virtual int start(Camera *camera, const ControlList *controls) = 0;
|
|
void stop(Camera *camera);
|
|
bool hasPendingRequests(const Camera *camera) const;
|
|
|
|
void registerRequest(Request *request);
|
|
void queueRequest(Request *request);
|
|
|
|
bool completeBuffer(Request *request, FrameBuffer *buffer);
|
|
void completeRequest(Request *request);
|
|
void cancelRequest(Request *request);
|
|
|
|
std::string configurationFile(const std::string &subdir,
|
|
const std::string &name,
|
|
bool silent = false) const;
|
|
|
|
const char *name() const { return name_; }
|
|
|
|
CameraManager *cameraManager() const { return manager_; }
|
|
|
|
protected:
|
|
void registerCamera(std::shared_ptr<Camera> camera);
|
|
void hotplugMediaDevice(MediaDevice *media);
|
|
|
|
virtual int queueRequestDevice(Camera *camera, Request *request) = 0;
|
|
virtual void stopDevice(Camera *camera) = 0;
|
|
|
|
virtual bool acquireDevice(Camera *camera);
|
|
virtual void releaseDevice(Camera *camera);
|
|
|
|
CameraManager *manager_;
|
|
const unsigned int maxQueuedRequestsDevice_;
|
|
|
|
private:
|
|
void unlockMediaDevices();
|
|
|
|
void mediaDeviceDisconnected(MediaDevice *media);
|
|
virtual void disconnect();
|
|
|
|
void doQueueRequest(Request *request);
|
|
void doQueueRequests(Camera *camera);
|
|
|
|
std::vector<std::shared_ptr<MediaDevice>> mediaDevices_;
|
|
std::vector<std::weak_ptr<Camera>> cameras_;
|
|
|
|
const char *name_;
|
|
unsigned int useCount_;
|
|
|
|
friend class PipelineHandlerFactoryBase;
|
|
};
|
|
|
|
class PipelineHandlerFactoryBase
|
|
{
|
|
public:
|
|
PipelineHandlerFactoryBase(const char *name);
|
|
virtual ~PipelineHandlerFactoryBase() = default;
|
|
|
|
std::shared_ptr<PipelineHandler> create(CameraManager *manager) const;
|
|
|
|
const std::string &name() const { return name_; }
|
|
|
|
static std::vector<PipelineHandlerFactoryBase *> &factories();
|
|
static const PipelineHandlerFactoryBase *getFactoryByName(const std::string &name);
|
|
|
|
private:
|
|
static void registerType(PipelineHandlerFactoryBase *factory);
|
|
|
|
virtual std::unique_ptr<PipelineHandler>
|
|
createInstance(CameraManager *manager) const = 0;
|
|
|
|
std::string name_;
|
|
};
|
|
|
|
template<typename _PipelineHandler>
|
|
class PipelineHandlerFactory final : public PipelineHandlerFactoryBase
|
|
{
|
|
public:
|
|
PipelineHandlerFactory(const char *name)
|
|
: PipelineHandlerFactoryBase(name)
|
|
{
|
|
}
|
|
|
|
std::unique_ptr<PipelineHandler>
|
|
createInstance(CameraManager *manager) const override
|
|
{
|
|
return std::make_unique<_PipelineHandler>(manager);
|
|
}
|
|
};
|
|
|
|
#define REGISTER_PIPELINE_HANDLER(handler, name) \
|
|
static PipelineHandlerFactory<handler> global_##handler##Factory(name);
|
|
|
|
} /* namespace libcamera */
|