[libcamera-devel] [PATCH v2 2/2] v4l2: v4l2_compat: Add V4L2 compatibility layer
Paul Elder
paul.elder at ideasonboard.com
Mon Dec 9 05:58:21 CET 2019
On Sun, Dec 08, 2019 at 11:56:03PM -0500, Paul Elder wrote:
> Add libcamera V4L2 compatibility layer.
>
> This initial implementation supports the minimal set of V4L2 operations,
> which allows getting, setting, and enumerating formats, and streaming
> frames from a video device. Some data about the wrapped V4L2 video
> device are hardcoded.
>
> Add a build option named 'v4l2' and adjust the build system to
> selectively compile the V4L2 compatibility layer.
>
> Note that until we have a way of mapping V4L2 device nodes to libcamera
> cameras, the V4L2 compatibility layer will always selects and use the
> first enumerated libcamera camera.
I'm sorry, I just realized I forgot to update this description.
In this version we match the V4L2 device node to libcamera camera based
on the name exposed in sysfs for the device node, and with the libcamera
camera's exposed name.
Paul
> Signed-off-by: Paul Elder <paul.elder at ideasonboard.com>
>
> ---
> Changes in v2:
> - move all errno acrobatics to V4L2CameraProxy
> - remove all mentions of dmabuf
> - make V4L2CompatManager::getCamera return pointer rather than
> shared_ptr
> - match V4L2 device nodes to libcamera cameras using Camera::name()
> compared to /sys/dev/char/maj:min/name (only works for UVC cameras)
> - in V4L2CompatManager::getCameraIndex()
> - add -fvisibility=hidden to v4l2 compat
> - cache the results of V4L2CompatManager::imageSize() within V4L2Camera
> (where V4L2Camera is interested)
> - remove V4L2CompatManager::valid[fd|mmap], and where those methods were
> used, check V4L2CompatManager::getCamera() != nullptr instead
> - fixed V4L2CompatManager::drmToV4L2() mappings for DRM_FORMAT_BGR888
> and DRM_FORMAT_RGB888
> - other cosmetic changes
> ---
> meson_options.txt | 5 +
> src/meson.build | 4 +
> src/v4l2/meson.build | 30 ++
> src/v4l2/v4l2_camera.cpp | 299 ++++++++++++++++++++
> src/v4l2/v4l2_camera.h | 67 +++++
> src/v4l2/v4l2_camera_proxy.cpp | 452 +++++++++++++++++++++++++++++++
> src/v4l2/v4l2_camera_proxy.h | 63 +++++
> src/v4l2/v4l2_compat.cpp | 81 ++++++
> src/v4l2/v4l2_compat_manager.cpp | 382 ++++++++++++++++++++++++++
> src/v4l2/v4l2_compat_manager.h | 86 ++++++
> 10 files changed, 1469 insertions(+)
> create mode 100644 src/v4l2/meson.build
> create mode 100644 src/v4l2/v4l2_camera.cpp
> create mode 100644 src/v4l2/v4l2_camera.h
> create mode 100644 src/v4l2/v4l2_camera_proxy.cpp
> create mode 100644 src/v4l2/v4l2_camera_proxy.h
> create mode 100644 src/v4l2/v4l2_compat.cpp
> create mode 100644 src/v4l2/v4l2_compat_manager.cpp
> create mode 100644 src/v4l2/v4l2_compat_manager.h
>
> diff --git a/meson_options.txt b/meson_options.txt
> index 1a328045..b06dd494 100644
> --- a/meson_options.txt
> +++ b/meson_options.txt
> @@ -10,3 +10,8 @@ option('documentation',
> option('test',
> type : 'boolean',
> description: 'Compile and include the tests')
> +
> +option('v4l2',
> + type : 'boolean',
> + value : false,
> + description : 'Compile libcamera with V4L2 compatibility layer')
> diff --git a/src/meson.build b/src/meson.build
> index 67ad20aa..5adcd61f 100644
> --- a/src/meson.build
> +++ b/src/meson.build
> @@ -6,3 +6,7 @@ subdir('libcamera')
> subdir('ipa')
> subdir('cam')
> subdir('qcam')
> +
> +if get_option('v4l2')
> + subdir('v4l2')
> +endif
> diff --git a/src/v4l2/meson.build b/src/v4l2/meson.build
> new file mode 100644
> index 00000000..1650048e
> --- /dev/null
> +++ b/src/v4l2/meson.build
> @@ -0,0 +1,30 @@
> +v4l2_compat_sources = files([
> + 'v4l2_camera.cpp',
> + 'v4l2_camera_proxy.cpp',
> + 'v4l2_compat.cpp',
> + 'v4l2_compat_manager.cpp',
> +])
> +
> +v4l2_compat_includes = [
> + libcamera_includes,
> + libcamera_internal_includes,
> +]
> +
> +v4l2_compat_cpp_args = [
> + # Meson enables large file support unconditionally, which redirect file
> + # operations to 64-bit versions. This results in some symbols being
> + # renamed, for instance open() being renamed to open64(). As the V4L2
> + # adaptation wrapper needs to provide both 32-bit and 64-bit versions of
> + # file operations, disable transparent large file support.
> + '-U_FILE_OFFSET_BITS',
> + '-fvisibility=hidden',
> +]
> +
> +v4l2_compat = shared_library('v4l2-compat',
> + v4l2_compat_sources,
> + name_prefix : '',
> + install : true,
> + link_with : libcamera,
> + include_directories : v4l2_compat_includes,
> + dependencies : libcamera_deps,
> + cpp_args : v4l2_compat_cpp_args)
> diff --git a/src/v4l2/v4l2_camera.cpp b/src/v4l2/v4l2_camera.cpp
> new file mode 100644
> index 00000000..f944c577
> --- /dev/null
> +++ b/src/v4l2/v4l2_camera.cpp
> @@ -0,0 +1,299 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * v4l2_camera.cpp - V4L2 compatibility camera
> + */
> +#include "v4l2_camera.h"
> +
> +#include <errno.h>
> +#include <linux/videodev2.h>
> +#include <sys/mman.h>
> +#include <sys/syscall.h>
> +#include <time.h>
> +#include <unistd.h>
> +
> +#include "log.h"
> +#include "v4l2_compat_manager.h"
> +
> +using namespace libcamera;
> +
> +LOG_DECLARE_CATEGORY(V4L2Compat);
> +
> +V4L2Camera::V4L2Camera(std::shared_ptr<Camera> camera)
> + : camera_(camera), bufferCount_(0), isRunning_(false)
> +{
> + camera_->requestCompleted.connect(this, &V4L2Camera::requestComplete);
> +};
> +
> +V4L2Camera::~V4L2Camera()
> +{
> + while (!pendingRequests_.empty()) {
> + delete pendingRequests_.front();
> + pendingRequests_.pop();
> + }
> +
> + bufferLock_.lock();
> + while (!completedBuffers_.empty()) {
> + delete completedBuffers_.front();
> + completedBuffers_.pop();
> + }
> + bufferLock_.unlock();
> +
> + camera_->release();
> +}
> +
> +void V4L2Camera::open(int *ret, bool nonblock)
> +{
> + nonblock_ = nonblock;
> +
> + if (camera_->acquire() < 0) {
> + LOG(V4L2Compat, Error) << "Failed to acquire camera";
> + *ret = -EINVAL;
> + return;
> + }
> +
> + config_ = camera_->generateConfiguration({ StreamRole::Viewfinder });
> + if (config_ == nullptr) {
> + *ret = -EINVAL;
> + return;
> + }
> +
> + updateSizeImage();
> +
> + *ret = 0;
> +}
> +
> +void V4L2Camera::close(int *ret)
> +{
> + *ret = camera_->release();
> +}
> +
> +void V4L2Camera::getStreamConfig(StreamConfiguration *streamConfig)
> +{
> + *streamConfig = config_->at(0);
> +}
> +
> +void V4L2Camera::updateSizeImage()
> +{
> + StreamConfiguration &streamConfig = config_->at(0);
> + sizeimage_ =
> + V4L2CompatManager::imageSize(
> + V4L2CompatManager::drmToV4L2(streamConfig.pixelFormat),
> + streamConfig.size.width,
> + streamConfig.size.height);
> +}
> +
> +void V4L2Camera::requestComplete(Request *request)
> +{
> + if (request->status() == Request::RequestCancelled) {
> + LOG(V4L2Compat, Error) << "Request not succesfully completed: "
> + << request->status();
> + return;
> + }
> +
> + /* We only have one stream at the moment. */
> + bufferLock_.lock();
> + Buffer *buffer = request->buffers().begin()->second;
> + completedBuffers_.push(buffer);
> + bufferLock_.unlock();
> +
> + bufferSema_.release();
> +}
> +
> +void V4L2Camera::configure(int *ret, struct v4l2_format *arg,
> + unsigned int bufferCount)
> +{
> + StreamConfiguration &streamConfig = config_->at(0);
> + streamConfig.size.width = arg->fmt.pix.width;
> + streamConfig.size.height = arg->fmt.pix.height;
> + streamConfig.pixelFormat =
> + V4L2CompatManager::v4l2ToDrm(arg->fmt.pix.pixelformat);
> + bufferCount_ = bufferCount;
> + streamConfig.bufferCount = bufferCount_;
> + /* \todo memoryType (interval vs external) */
> +
> + CameraConfiguration::Status validation = config_->validate();
> + if (validation == CameraConfiguration::Invalid) {
> + LOG(V4L2Compat, Error) << "Configuration invalid";
> + *ret = -EINVAL;
> + return;
> + }
> + if (validation == CameraConfiguration::Adjusted)
> + LOG(V4L2Compat, Info) << "Configuration adjusted";
> +
> + LOG(V4L2Compat, Info) << "Validated configuration is: "
> + << streamConfig.toString();
> +
> + *ret = camera_->configure(config_.get());
> + if (*ret < 0)
> + return;
> +
> + bufferCount_ = streamConfig.bufferCount;
> +
> + updateSizeImage();
> + if (sizeimage_ == 0)
> + *ret = -EINVAL;
> +}
> +
> +void V4L2Camera::mmap(void **ret, int *err, void *addr, size_t length, int prot, off_t offset)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing MMAP";
> +
> + if (prot != (PROT_READ | PROT_WRITE)) {
> + *ret = MAP_FAILED;
> + *err = ENOTSUP;
> + return;
> + }
> +
> + unsigned int index = offset / sizeimage_;
> + if (index * sizeimage_ != offset || length != sizeimage_) {
> + *ret = MAP_FAILED;
> + *err = EINVAL;
> + return;
> + }
> +
> + Stream *stream = *camera_->streams().begin();
> + *ret = stream->buffers()[index].planes()[0].mem();
> + *err = 0;
> +}
> +
> +void V4L2Camera::munmap(int *ret, void *addr, size_t length)
> +{
> + *ret = 0;
> +
> + if (length != sizeimage_)
> + *ret = -EINVAL;
> +}
> +
> +void V4L2Camera::validStreamType(bool *ret, uint32_t type)
> +{
> + *ret = (type == V4L2_BUF_TYPE_VIDEO_CAPTURE);
> +}
> +
> +void V4L2Camera::validMemoryType(bool *ret, uint32_t memory)
> +{
> + *ret = (memory == V4L2_MEMORY_MMAP);
> +}
> +
> +void V4L2Camera::allocBuffers(int *ret, unsigned int count)
> +{
> + LOG(V4L2Compat, Debug) << "Allocating libcamera bufs";
> + *ret = camera_->allocateBuffers();
> + if (*ret == -EACCES)
> + *ret = -EBUSY;
> +}
> +
> +void V4L2Camera::freeBuffers()
> +{
> + camera_->freeBuffers();
> + bufferCount_ = 0;
> +}
> +
> +void V4L2Camera::streamOn(int *ret)
> +{
> + *ret = 0;
> +
> + if (isRunning_)
> + return;
> +
> + *ret = camera_->start();
> + if (*ret < 0) {
> + if (*ret == -EACCES)
> + *ret = -EBUSY;
> + return;
> + }
> + isRunning_ = true;
> +
> + while (!pendingRequests_.empty()) {
> + *ret = camera_->queueRequest(pendingRequests_.front());
> + pendingRequests_.pop();
> + if (*ret < 0)
> + return;
> + }
> +}
> +
> +void V4L2Camera::streamOff(int *ret)
> +{
> + *ret = 0;
> +
> + /* \todo restore buffers to reqbufs state? */
> + if (!isRunning_)
> + return;
> +
> + *ret = camera_->stop();
> + if (*ret < 0) {
> + if (*ret == -EACCES)
> + *ret = -EBUSY;
> + return;
> + }
> + isRunning_ = false;
> +}
> +
> +void V4L2Camera::qbuf(int *ret, struct v4l2_buffer *arg)
> +{
> + Stream *stream = config_->at(0).stream();
> + std::unique_ptr<Buffer> buffer = stream->createBuffer(arg->index);
> + if (!buffer) {
> + LOG(V4L2Compat, Error) << "Can't create buffer";
> + *ret = -ENOMEM;
> + return;
> + }
> +
> + Request *request = camera_->createRequest();
> + if (request == nullptr) {
> + LOG(V4L2Compat, Error) << "Can't create request";
> + *ret = -ENOMEM;
> + return;
> + }
> +
> + *ret = request->addBuffer(std::move(buffer));
> + if (*ret < 0) {
> + LOG(V4L2Compat, Error) << "Can't set buffer for request";
> + *ret = -ENOMEM;
> + return;
> + }
> +
> + if (!isRunning_) {
> + pendingRequests_.push(request);
> + } else {
> + *ret = camera_->queueRequest(request);
> + if (*ret < 0) {
> + LOG(V4L2Compat, Error) << "Can't queue request";
> + if (*ret == -EACCES)
> + *ret = -EBUSY;
> + return;
> + }
> + }
> +
> + arg->flags |= V4L2_BUF_FLAG_QUEUED;
> + arg->flags |= V4L2_BUF_FLAG_MAPPED;
> + arg->flags &= ~V4L2_BUF_FLAG_DONE;
> + *ret = 0;
> +}
> +
> +int V4L2Camera::dqbuf(struct v4l2_buffer *arg)
> +{
> + if (nonblock_ && !bufferSema_.tryAcquire())
> + return -EAGAIN;
> + else
> + bufferSema_.acquire();
> +
> + bufferLock_.lock();
> + Buffer *buffer = completedBuffers_.front();
> + completedBuffers_.pop();
> + bufferLock_.unlock();
> +
> + arg->bytesused = buffer->bytesused();
> + arg->field = V4L2_FIELD_NONE;
> + arg->timestamp.tv_sec = buffer->timestamp() / 1000000000;
> + arg->timestamp.tv_usec = buffer->timestamp() / 1000;
> + arg->sequence = buffer->sequence();
> +
> + arg->flags &= ~V4L2_BUF_FLAG_QUEUED;
> + arg->flags &= ~V4L2_BUF_FLAG_DONE;
> +
> + arg->length = sizeimage_;
> +
> + return 0;
> +}
> diff --git a/src/v4l2/v4l2_camera.h b/src/v4l2/v4l2_camera.h
> new file mode 100644
> index 00000000..73a427c4
> --- /dev/null
> +++ b/src/v4l2/v4l2_camera.h
> @@ -0,0 +1,67 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * v4l2_camera.h - V4L2 compatibility camera
> + */
> +#ifndef __V4L2_CAMERA_H__
> +#define __V4L2_CAMERA_H__
> +
> +#include <linux/videodev2.h>
> +#include <mutex>
> +#include <queue>
> +
> +#include <libcamera/camera.h>
> +#include "semaphore.h"
> +
> +using namespace libcamera;
> +
> +class V4L2Camera : public Object
> +{
> +public:
> + V4L2Camera(std::shared_ptr<Camera> camera);
> + ~V4L2Camera();
> +
> + void open(int *ret, bool nonblock);
> + void close(int *ret);
> + void getStreamConfig(StreamConfiguration *streamConfig);
> + void requestComplete(Request *request);
> +
> + void mmap(void **ret, int *err, void *addr, size_t length,
> + int prot, off_t offset);
> + void munmap(int *ret, void *addr, size_t length);
> +
> + void configure(int *ret, struct v4l2_format *arg,
> + unsigned int bufferCount);
> +
> + void validStreamType(bool *ret, uint32_t type);
> + void validMemoryType(bool *ret, uint32_t memory);
> +
> + void allocBuffers(int *ret, unsigned int count);
> + void freeBuffers();
> + void streamOn(int *ret);
> + void streamOff(int *ret);
> +
> + void qbuf(int *ret, struct v4l2_buffer *arg);
> + int dqbuf(struct v4l2_buffer *arg);
> +
> +private:
> + void updateSizeImage();
> +
> + std::shared_ptr<Camera> camera_;
> + std::unique_ptr<CameraConfiguration> config_;
> +
> + unsigned int bufferCount_;
> + bool isRunning_;
> + bool nonblock_;
> +
> + unsigned int sizeimage_;
> +
> + Semaphore bufferSema_;
> + std::mutex bufferLock_;
> +
> + std::queue<Request *> pendingRequests_;
> + std::queue<Buffer *> completedBuffers_;
> +};
> +
> +#endif /* __V4L2_CAMERA_H__ */
> diff --git a/src/v4l2/v4l2_camera_proxy.cpp b/src/v4l2/v4l2_camera_proxy.cpp
> new file mode 100644
> index 00000000..66d558e4
> --- /dev/null
> +++ b/src/v4l2/v4l2_camera_proxy.cpp
> @@ -0,0 +1,452 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * v4l2_camera_proxy.cpp - Proxy to V4L2 compatibility camera
> + */
> +#include "v4l2_camera_proxy.h"
> +
> +#include <algorithm>
> +#include <linux/videodev2.h>
> +#include <string.h>
> +#include <sys/mman.h>
> +
> +#include <libcamera/camera.h>
> +#include <libcamera/object.h>
> +
> +#include "log.h"
> +#include "utils.h"
> +#include "v4l2_camera.h"
> +#include "v4l2_compat_manager.h"
> +
> +#define KERNEL_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
> +
> +using namespace libcamera;
> +
> +LOG_DECLARE_CATEGORY(V4L2Compat);
> +
> +V4L2CameraProxy::V4L2CameraProxy(unsigned int index,
> + std::shared_ptr<Camera> camera)
> + : index_(index), bufferCount_(0), currentBuf_(0),
> + vcam_(utils::make_unique<V4L2Camera>(camera))
> +{
> + querycap(camera);
> +}
> +
> +V4L2CameraProxy::~V4L2CameraProxy()
> +{
> +}
> +
> +int V4L2CameraProxy::open(bool nonblock)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing OPEN";
> +
> + int ret;
> + vcam_->invokeMethod(&V4L2Camera::open, ConnectionTypeBlocking,
> + &ret, nonblock);
> + if (ret < 0) {
> + errno = -ret;
> + return -1;
> + }
> +
> + vcam_->invokeMethod(&V4L2Camera::getStreamConfig,
> + ConnectionTypeBlocking, &streamConfig_);
> + setFmtFromConfig();
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::close()
> +{
> + LOG(V4L2Compat, Debug) << "Servicing CLOSE";
> +
> + int ret;
> + vcam_->invokeMethod(&V4L2Camera::close, ConnectionTypeBlocking, &ret);
> + if (ret < 0) {
> + errno = EIO;
> + return -1;
> + }
> +
> + return ret;
> +}
> +
> +void *V4L2CameraProxy::mmap(void *addr, size_t length, int prot, int flags,
> + off_t offset)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing MMAP";
> +
> + void *val;
> + int err;
> + vcam_->invokeMethod(&V4L2Camera::mmap, ConnectionTypeBlocking,
> + &val, &err, addr, length, prot, offset);
> + if (val == MAP_FAILED)
> + errno = err;
> + return val;
> +}
> +
> +int V4L2CameraProxy::munmap(void *addr, size_t length)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing MUNMAP";
> +
> + int ret;
> + vcam_->invokeMethod(&V4L2Camera::munmap, ConnectionTypeBlocking,
> + &ret, addr, length);
> + if (ret < 0) {
> + errno = -ret;
> + return -1;
> + }
> +
> + return ret;
> +}
> +
> +bool V4L2CameraProxy::hasPixelFormat(unsigned int format)
> +{
> + const std::vector<PixelFormat> &formats =
> + streamConfig_.formats().pixelformats();
> + return std::find(formats.begin(), formats.end(), format) != formats.end();
> +}
> +
> +/* \todo getDeviceCaps? getMemoryCaps? */
> +
> +bool V4L2CameraProxy::hasSize(unsigned int format, Size size)
> +{
> + const std::vector<Size> &sizes = streamConfig_.formats().sizes(format);
> + return std::find(sizes.begin(), sizes.end(), size) != sizes.end();
> +}
> +
> +bool V4L2CameraProxy::validateStreamType(uint32_t type)
> +{
> + bool valid;
> + vcam_->invokeMethod(&V4L2Camera::validStreamType,
> + ConnectionTypeBlocking, &valid, type);
> + if (!valid)
> + return false;
> +
> + return true;
> +}
> +
> +bool V4L2CameraProxy::validateMemoryType(uint32_t memory)
> +{
> + bool valid;
> + vcam_->invokeMethod(&V4L2Camera::validMemoryType,
> + ConnectionTypeBlocking, &valid, memory);
> + if (!valid)
> + return false;
> +
> + return true;
> +}
> +
> +void V4L2CameraProxy::setFmtFromConfig()
> +{
> + curV4L2Format_.fmt.pix.width = streamConfig_.size.width;
> + curV4L2Format_.fmt.pix.height = streamConfig_.size.height;
> + curV4L2Format_.fmt.pix.pixelformat =
> + V4L2CompatManager::drmToV4L2(streamConfig_.pixelFormat);
> + curV4L2Format_.fmt.pix.field = V4L2_FIELD_NONE;
> + curV4L2Format_.fmt.pix.bytesperline =
> + V4L2CompatManager::bplMultiplier(
> + curV4L2Format_.fmt.pix.pixelformat) *
> + curV4L2Format_.fmt.pix.width;
> + curV4L2Format_.fmt.pix.sizeimage =
> + V4L2CompatManager::imageSize(curV4L2Format_.fmt.pix.pixelformat,
> + curV4L2Format_.fmt.pix.width,
> + curV4L2Format_.fmt.pix.height);
> + curV4L2Format_.fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
> +}
> +
> +void V4L2CameraProxy::querycap(std::shared_ptr<Camera> camera)
> +{
> + std::string driver = "libcamera";
> + std::string bus_info = driver + ":" + std::to_string(index_);
> +
> + memcpy(capabilities_.driver, driver.c_str(),
> + sizeof(capabilities_.driver));
> + memcpy(capabilities_.card, camera->name().c_str(),
> + sizeof(capabilities_.card));
> + memcpy(capabilities_.bus_info, bus_info.c_str(),
> + sizeof(capabilities_.bus_info));
> + capabilities_.version = KERNEL_VERSION(5, 2, 0);
> + capabilities_.device_caps = V4L2_CAP_VIDEO_CAPTURE;
> + capabilities_.capabilities =
> + capabilities_.device_caps | V4L2_CAP_DEVICE_CAPS;
> + memset(capabilities_.reserved, 0, sizeof(capabilities_.reserved));
> +}
> +
> +int V4L2CameraProxy::vidioc_querycap(struct v4l2_capability *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_QUERYCAP";
> +
> + memcpy(arg, &capabilities_, sizeof(*arg));
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::vidioc_enum_fmt(struct v4l2_fmtdesc *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_ENUM_FMT";
> +
> + if (!validateStreamType(arg->type))
> + return -EINVAL;
> + if (arg->index > streamConfig_.formats().pixelformats().size())
> + return -EINVAL;
> +
> + memcpy(arg->description, "asdf", 5);
> + arg->pixelformat =
> + V4L2CompatManager::drmToV4L2(
> + streamConfig_.formats().pixelformats()[arg->index]);
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::vidioc_g_fmt(struct v4l2_format *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_G_FMT";
> +
> + if (!validateStreamType(arg->type))
> + return -EINVAL;
> +
> + arg->fmt.pix.width = curV4L2Format_.fmt.pix.width;
> + arg->fmt.pix.height = curV4L2Format_.fmt.pix.height;
> + arg->fmt.pix.pixelformat = curV4L2Format_.fmt.pix.pixelformat;
> + arg->fmt.pix.field = curV4L2Format_.fmt.pix.field;
> + arg->fmt.pix.bytesperline = curV4L2Format_.fmt.pix.bytesperline;
> + arg->fmt.pix.sizeimage = curV4L2Format_.fmt.pix.sizeimage;
> + arg->fmt.pix.colorspace = curV4L2Format_.fmt.pix.colorspace;
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::vidioc_s_fmt(struct v4l2_format *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_S_FMT";
> +
> + int ret = vidioc_try_fmt(arg);
> + if (ret < 0)
> + return ret;
> +
> + vcam_->invokeMethod(&V4L2Camera::configure, ConnectionTypeBlocking,
> + &ret, arg, bufferCount_);
> + if (ret < 0)
> + return -EINVAL;
> +
> + vcam_->invokeMethod(&V4L2Camera::getStreamConfig,
> + ConnectionTypeBlocking, &streamConfig_);
> + setFmtFromConfig();
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::vidioc_try_fmt(struct v4l2_format *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_TRY_FMT";
> + if (!validateStreamType(arg->type))
> + return -EINVAL;
> +
> + unsigned int format = arg->fmt.pix.pixelformat;
> + if (!hasPixelFormat(format))
> + format = streamConfig_.formats().pixelformats()[0];
> +
> + Size size(arg->fmt.pix.width, arg->fmt.pix.height);
> + if (!hasSize(format, size))
> + size = streamConfig_.formats().sizes(format)[0];
> +
> + arg->fmt.pix.width = size.width;
> + arg->fmt.pix.height = size.height;
> + arg->fmt.pix.pixelformat = format;
> + arg->fmt.pix.field = V4L2_FIELD_NONE;
> + arg->fmt.pix.bytesperline =
> + V4L2CompatManager::bplMultiplier(
> + V4L2CompatManager::drmToV4L2(format)) *
> + arg->fmt.pix.width;
> + arg->fmt.pix.sizeimage =
> + V4L2CompatManager::imageSize(
> + V4L2CompatManager::drmToV4L2(format),
> + arg->fmt.pix.width, arg->fmt.pix.height);
> + arg->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::vidioc_reqbufs(struct v4l2_requestbuffers *arg)
> +{
> + int ret;
> +
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_REQBUFS";
> + if (!validateStreamType(arg->type))
> + return -EINVAL;
> + if (!validateMemoryType(arg->memory))
> + return -EINVAL;
> +
> + LOG(V4L2Compat, Debug) << arg->count << " bufs requested ";
> +
> + arg->capabilities = V4L2_BUF_CAP_SUPPORTS_MMAP;
> +
> + if (arg->count == 0) {
> + LOG(V4L2Compat, Debug) << "Freeing libcamera bufs";
> + vcam_->invokeMethod(&V4L2Camera::streamOff,
> + ConnectionTypeBlocking, &ret);
> + if (ret < 0) {
> + LOG(V4L2Compat, Error) << "Failed to stop stream";
> + return ret;
> + }
> + vcam_->invokeMethod(&V4L2Camera::freeBuffers,
> + ConnectionTypeBlocking);
> + bufferCount_ = 0;
> + return 0;
> + }
> +
> + vcam_->invokeMethod(&V4L2Camera::configure, ConnectionTypeBlocking,
> + &ret, &curV4L2Format_, arg->count);
> + if (ret < 0)
> + return -EINVAL;
> + arg->count = streamConfig_.bufferCount;
> + bufferCount_ = arg->count;
> +
> + if (arg->memory != V4L2_MEMORY_MMAP)
> + return -EINVAL;
> +
> + vcam_->invokeMethod(&V4L2Camera::allocBuffers,
> + ConnectionTypeBlocking, &ret, arg->count);
> + if (ret < 0) {
> + arg->count = 0;
> + return ret == -EACCES ? -EBUSY : ret;
> + }
> +
> + LOG(V4L2Compat, Debug) << "Allocated " << arg->count << " buffers";
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::vidioc_querybuf(struct v4l2_buffer *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_QUERYBUF";
> + Stream *stream = streamConfig_.stream();
> +
> + if (!validateStreamType(arg->type))
> + return -EINVAL;
> + if (arg->index >= stream->buffers().size())
> + return -EINVAL;
> +
> + unsigned int index = arg->index;
> + memset(arg, 0, sizeof(*arg));
> + arg->index = index;
> + arg->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> + arg->length = curV4L2Format_.fmt.pix.sizeimage;
> + arg->memory = V4L2_MEMORY_MMAP;
> + arg->m.offset = arg->index * curV4L2Format_.fmt.pix.sizeimage;
> +
> + return 0;
> +}
> +
> +int V4L2CameraProxy::vidioc_qbuf(struct v4l2_buffer *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_QBUF, index = "
> + << arg->index;
> +
> + Stream *stream = streamConfig_.stream();
> +
> + if (!validateStreamType(arg->type))
> + return -EINVAL;
> + if (!validateMemoryType(arg->memory))
> + return -EINVAL;
> + if (arg->index >= stream->buffers().size())
> + return -EINVAL;
> +
> + int ret;
> + vcam_->invokeMethod(&V4L2Camera::qbuf, ConnectionTypeBlocking,
> + &ret, arg);
> + return ret;
> +}
> +
> +int V4L2CameraProxy::vidioc_dqbuf(struct v4l2_buffer *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_DQBUF";
> +
> + if (!validateStreamType(arg->type))
> + return -EINVAL;
> + if (!validateMemoryType(arg->memory))
> + return -EINVAL;
> +
> + arg->index = currentBuf_;
> + currentBuf_ = (currentBuf_ + 1) % bufferCount_;
> +
> + return vcam_->dqbuf(arg);
> +}
> +
> +int V4L2CameraProxy::vidioc_streamon(int *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_STREAMON";
> +
> + if (!validateStreamType(*arg))
> + return -EINVAL;
> +
> + int ret;
> + vcam_->invokeMethod(&V4L2Camera::streamOn,
> + ConnectionTypeBlocking, &ret);
> + return ret;
> +}
> +
> +int V4L2CameraProxy::vidioc_streamoff(int *arg)
> +{
> + LOG(V4L2Compat, Debug) << "Servicing VIDIOC_STREAMOFF";
> +
> + if (!validateStreamType(*arg))
> + return -EINVAL;
> +
> + int ret;
> + vcam_->invokeMethod(&V4L2Camera::streamOff,
> + ConnectionTypeBlocking, &ret);
> + return ret;
> +}
> +
> +int V4L2CameraProxy::ioctl(unsigned long request, void *arg)
> +{
> + int ret;
> + switch (request) {
> + case VIDIOC_QUERYCAP:
> + ret = vidioc_querycap(static_cast<struct v4l2_capability *>(arg));
> + break;
> + case VIDIOC_ENUM_FMT:
> + ret = vidioc_enum_fmt(static_cast<struct v4l2_fmtdesc *>(arg));
> + break;
> + case VIDIOC_G_FMT:
> + ret = vidioc_g_fmt(static_cast<struct v4l2_format *>(arg));
> + break;
> + case VIDIOC_S_FMT:
> + ret = vidioc_s_fmt(static_cast<struct v4l2_format *>(arg));
> + break;
> + case VIDIOC_TRY_FMT:
> + ret = vidioc_try_fmt(static_cast<struct v4l2_format *>(arg));
> + break;
> + case VIDIOC_REQBUFS:
> + ret = vidioc_reqbufs(static_cast<struct v4l2_requestbuffers *>(arg));
> + break;
> + case VIDIOC_QUERYBUF:
> + ret = vidioc_querybuf(static_cast<struct v4l2_buffer *>(arg));
> + break;
> + case VIDIOC_QBUF:
> + ret = vidioc_qbuf(static_cast<struct v4l2_buffer *>(arg));
> + break;
> + case VIDIOC_DQBUF:
> + ret = vidioc_dqbuf(static_cast<struct v4l2_buffer *>(arg));
> + break;
> + case VIDIOC_STREAMON:
> + ret = vidioc_streamon(static_cast<int *>(arg));
> + break;
> + case VIDIOC_STREAMOFF:
> + ret = vidioc_streamoff(static_cast<int *>(arg));
> + break;
> + case VIDIOC_EXPBUF:
> + case VIDIOC_ENUM_FRAMESIZES:
> + default:
> + ret = -ENOTTY;
> + }
> +
> + if (ret < 0) {
> + errno = -ret;
> + return -1;
> + }
> +
> + errno = 0;
> + return ret;
> +}
> diff --git a/src/v4l2/v4l2_camera_proxy.h b/src/v4l2/v4l2_camera_proxy.h
> new file mode 100644
> index 00000000..64c7aadd
> --- /dev/null
> +++ b/src/v4l2/v4l2_camera_proxy.h
> @@ -0,0 +1,63 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * v4l2_camera_proxy.h - Proxy to V4L2 compatibility camera
> + */
> +#ifndef __V4L2_CAMERA_PROXY_H__
> +#define __V4L2_CAMERA_PROXY_H__
> +
> +#include <linux/videodev2.h>
> +
> +#include <libcamera/camera.h>
> +
> +#include "v4l2_camera.h"
> +
> +using namespace libcamera;
> +
> +class V4L2CameraProxy
> +{
> +public:
> + V4L2CameraProxy(unsigned int index, std::shared_ptr<Camera> camera);
> + ~V4L2CameraProxy();
> +
> + int open(bool nonblock);
> + int close();
> + void *mmap(void *addr, size_t length, int prot, int flags,
> + off_t offset);
> + int munmap(void *addr, size_t length);
> +
> + int ioctl(unsigned long request, void *arg);
> +
> +private:
> + bool hasPixelFormat(unsigned int format);
> + bool hasSize(unsigned int format, Size size);
> + bool validateStreamType(uint32_t type);
> + bool validateMemoryType(uint32_t memory);
> + void setFmtFromConfig();
> + void querycap(std::shared_ptr<Camera> camera);
> +
> + int vidioc_querycap(struct v4l2_capability *arg);
> + int vidioc_enum_fmt(struct v4l2_fmtdesc *arg);
> + int vidioc_g_fmt(struct v4l2_format *arg);
> + int vidioc_s_fmt(struct v4l2_format *arg);
> + int vidioc_try_fmt(struct v4l2_format *arg);
> + int vidioc_reqbufs(struct v4l2_requestbuffers *arg);
> + int vidioc_querybuf(struct v4l2_buffer *arg);
> + int vidioc_qbuf(struct v4l2_buffer *arg);
> + int vidioc_dqbuf(struct v4l2_buffer *arg);
> + int vidioc_streamon(int *arg);
> + int vidioc_streamoff(int *arg);
> +
> + unsigned int index_;
> +
> + struct v4l2_format curV4L2Format_;
> + StreamConfiguration streamConfig_;
> + struct v4l2_capability capabilities_;
> + unsigned int bufferCount_;
> + unsigned int currentBuf_;
> +
> + std::unique_ptr<V4L2Camera> vcam_;
> +};
> +
> +#endif /* __V4L2_CAMERA_PROXY_H__ */
> diff --git a/src/v4l2/v4l2_compat.cpp b/src/v4l2/v4l2_compat.cpp
> new file mode 100644
> index 00000000..3330e7bc
> --- /dev/null
> +++ b/src/v4l2/v4l2_compat.cpp
> @@ -0,0 +1,81 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * v4l2_compat.cpp - V4L2 compatibility layer
> + */
> +
> +#include "v4l2_compat_manager.h"
> +
> +#include <iostream>
> +
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <linux/videodev2.h>
> +#include <stdarg.h>
> +#include <sys/mman.h>
> +#include <sys/stat.h>
> +#include <sys/types.h>
> +
> +#define LIBCAMERA_PUBLIC __attribute__((visibility("default")))
> +
> +using namespace libcamera;
> +
> +#define extract_va_arg(type, arg, last) \
> +{ \
> + va_list ap; \
> + va_start(ap, last); \
> + arg = va_arg(ap, type); \
> + va_end(ap); \
> +}
> +
> +extern "C" {
> +LIBCAMERA_PUBLIC int open(const char *path, int oflag, ...)
> +{
> + mode_t mode = 0;
> + if (oflag & O_CREAT || oflag & O_TMPFILE)
> + extract_va_arg(mode_t, mode, oflag);
> +
> + return openat(AT_FDCWD, path, oflag, mode);
> +}
> +
> +LIBCAMERA_PUBLIC int openat(int dirfd, const char *path, int oflag, ...)
> +{
> + mode_t mode = 0;
> + if (oflag & O_CREAT || oflag & O_TMPFILE)
> + extract_va_arg(mode_t, mode, oflag);
> +
> + return V4L2CompatManager::instance()->openat(dirfd, path, oflag, mode);
> +}
> +
> +LIBCAMERA_PUBLIC int dup(int oldfd)
> +{
> + return V4L2CompatManager::instance()->dup(oldfd);
> +}
> +
> +LIBCAMERA_PUBLIC int close(int fd)
> +{
> + return V4L2CompatManager::instance()->close(fd);
> +}
> +
> +LIBCAMERA_PUBLIC void *mmap(void *addr, size_t length, int prot, int flags,
> + int fd, off_t offset)
> +{
> + void *val = V4L2CompatManager::instance()->mmap(addr, length, prot, flags, fd, offset);
> + return val;
> +}
> +
> +LIBCAMERA_PUBLIC int munmap(void *addr, size_t length)
> +{
> + return V4L2CompatManager::instance()->munmap(addr, length);
> +}
> +
> +LIBCAMERA_PUBLIC int ioctl(int fd, unsigned long request, ...)
> +{
> + void *arg;
> + extract_va_arg(void *, arg, request);
> +
> + return V4L2CompatManager::instance()->ioctl(fd, request, arg);
> +}
> +
> +}
> diff --git a/src/v4l2/v4l2_compat_manager.cpp b/src/v4l2/v4l2_compat_manager.cpp
> new file mode 100644
> index 00000000..90416b35
> --- /dev/null
> +++ b/src/v4l2/v4l2_compat_manager.cpp
> @@ -0,0 +1,382 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * v4l2_compat_manager.cpp - V4L2 compatibility manager
> + */
> +#include "v4l2_compat_manager.h"
> +
> +#include <dlfcn.h>
> +#include <fcntl.h>
> +#include <fstream>
> +#include <iostream>
> +#include <linux/drm_fourcc.h>
> +#include <linux/videodev2.h>
> +#include <map>
> +#include <stdarg.h>
> +#include <string.h>
> +#include <sys/eventfd.h>
> +#include <sys/mman.h>
> +#include <sys/stat.h>
> +#include <sys/sysmacros.h>
> +#include <sys/types.h>
> +#include <unistd.h>
> +
> +#include <libcamera/camera.h>
> +#include <libcamera/camera_manager.h>
> +#include <libcamera/stream.h>
> +
> +#include "log.h"
> +
> +using namespace libcamera;
> +
> +LOG_DEFINE_CATEGORY(V4L2Compat)
> +
> +V4L2CompatManager::V4L2CompatManager()
> + : cm_(nullptr)
> +{
> + openat_func_ = (openat_func_t )dlsym(RTLD_NEXT, "openat");
> + dup_func_ = (dup_func_t )dlsym(RTLD_NEXT, "dup");
> + close_func_ = (close_func_t )dlsym(RTLD_NEXT, "close");
> + ioctl_func_ = (ioctl_func_t )dlsym(RTLD_NEXT, "ioctl");
> + mmap_func_ = (mmap_func_t )dlsym(RTLD_NEXT, "mmap");
> + munmap_func_ = (munmap_func_t )dlsym(RTLD_NEXT, "munmap");
> +}
> +
> +V4L2CompatManager::~V4L2CompatManager()
> +{
> + devices_.clear();
> +
> + if (isRunning()) {
> + exit(0);
> + /* \todo Wait with a timeout, just in case. */
> + wait();
> + }
> +}
> +
> +int V4L2CompatManager::init()
> +{
> + start();
> +
> + MutexLocker locker(mutex_);
> + cv_.wait(locker);
> +
> + return 0;
> +}
> +
> +void V4L2CompatManager::run()
> +{
> + cm_ = new CameraManager();
> +
> + int ret = cm_->start();
> + if (ret) {
> + LOG(V4L2Compat, Error) << "Failed to start camera manager: "
> + << strerror(-ret);
> + return;
> + }
> +
> + LOG(V4L2Compat, Debug) << "Started camera manager";
> +
> + /*
> + * For each Camera registered in the system, a V4L2CameraProxy
> + * gets created here to wraps a camera device.
> + */
> + unsigned int index = 0;
> + for (auto &camera : cm_->cameras()) {
> + V4L2CameraProxy *proxy = new V4L2CameraProxy(index, camera);
> + proxies_.emplace_back(proxy);
> + ++index;
> + }
> +
> + /*
> + * libcamera has been initialized. Unlock the init() caller
> + * as we're now ready to handle calls from the framework.
> + */
> + cv_.notify_one();
> +
> + /* Now start processing events and messages. */
> + exec();
> +
> + cm_->stop();
> + delete cm_;
> + cm_ = nullptr;
> +}
> +
> +V4L2CompatManager *V4L2CompatManager::instance()
> +{
> + static V4L2CompatManager v4l2CompatManager;
> + return &v4l2CompatManager;
> +}
> +
> +V4L2CameraProxy *V4L2CompatManager::getCamera(int fd)
> +{
> + auto device = devices_.find(fd);
> + if (device == devices_.end())
> + return nullptr;
> +
> + return device->second.get();
> +}
> +
> +V4L2CameraProxy *V4L2CompatManager::getCamera(void *addr)
> +{
> + auto map = mmaps_.find(addr);
> + if (map == mmaps_.end())
> + return nullptr;
> +
> + return devices_.at(map->second).get();
> +}
> +
> +int V4L2CompatManager::getCameraIndex(int fd)
> +{
> + struct stat statbuf;
> + fstat(fd, &statbuf);
> + unsigned int dev_major = major(statbuf.st_rdev);
> + unsigned int dev_minor = minor(statbuf.st_rdev);
> +
> + std::string name;
> + std::ifstream nameFile;
> + nameFile.open("/sys/dev/char/" + std::to_string(dev_major) + ":" +
> + std::to_string(dev_minor) + "/name");
> + if (!nameFile)
> + return -1;
> +
> + std::getline(nameFile, name);
> + nameFile.close();
> +
> + unsigned int index = 0;
> + for (auto &camera : cm_->cameras()) {
> + if (!camera->name().compare(name))
> + break;
> + ++index;
> + }
> +
> + if (index >= cm_->cameras().size())
> + return -1;
> +
> + return index;
> +}
> +
> +int V4L2CompatManager::openat(int dirfd, const char *path, int oflag, mode_t mode)
> +{
> + int fd = openat_func_(dirfd, path, oflag, mode);
> + if (fd < 0)
> + return fd;
> +
> + if (std::string(path).find("video") == std::string::npos)
> + return fd;
> +
> + if (!isRunning())
> + init();
> +
> + int ret = getCameraIndex(fd);
> + if (ret < 0) {
> + LOG(V4L2Compat, Error) << "No camera found for " << path;
> + return fd;
> + }
> +
> + unsigned int camera_index = static_cast<unsigned int>(ret);
> +
> + std::shared_ptr<V4L2CameraProxy> proxy = proxies_[camera_index];
> + ret = proxy->open(mode & O_NONBLOCK);
> + if (ret < 0)
> + return ret;
> +
> + int efd = eventfd(0, (mode & O_CLOEXEC) | (mode & O_NONBLOCK));
> + if (efd < 0)
> + return efd;
> +
> + devices_.emplace(efd, proxy);
> +
> + return efd;
> +}
> +
> +int V4L2CompatManager::dup(int oldfd)
> +{
> + int newfd = dup_func_(oldfd);
> + if (getCamera(oldfd))
> + devices_[newfd] = devices_[oldfd];
> +
> + return newfd;
> +}
> +
> +int V4L2CompatManager::close(int fd)
> +{
> + V4L2CameraProxy *proxy = getCamera(fd);
> + if (proxy)
> + return proxy->close();
> +
> + int ret = close_func_(fd);
> + return ret;
> +}
> +
> +void *V4L2CompatManager::mmap(void *addr, size_t length, int prot, int flags,
> + int fd, off_t offset)
> +{
> + V4L2CameraProxy *proxy = getCamera(fd);
> + if (!proxy)
> + return mmap_func_(addr, length, prot, flags, fd, offset);
> +
> + void *map = proxy->mmap(addr, length, prot, flags, offset);
> + if (map == MAP_FAILED)
> + return map;
> +
> + mmaps_[addr] = fd;
> + return map;
> +}
> +
> +int V4L2CompatManager::munmap(void *addr, size_t length)
> +{
> + V4L2CameraProxy *proxy = getCamera(addr);
> + if (!proxy)
> + return munmap_func_(addr, length);
> +
> + int ret = proxy->munmap(addr, length);
> + if (ret < 0)
> + return ret;
> +
> + mmaps_.erase(addr);
> + addr = nullptr;
> +
> + return 0;
> +}
> +
> +int V4L2CompatManager::ioctl(int fd, unsigned long request, void *arg)
> +{
> + V4L2CameraProxy *proxy = getCamera(fd);
> + if (!proxy)
> + return ioctl_func_(fd, request, arg);
> +
> + return proxy->ioctl(request, arg);
> +}
> +
> +/* \todo make libcamera export these */
> +int V4L2CompatManager::bplMultiplier(unsigned int format)
> +{
> + switch (format) {
> + case V4L2_PIX_FMT_NV12:
> + case V4L2_PIX_FMT_NV21:
> + case V4L2_PIX_FMT_NV16:
> + case V4L2_PIX_FMT_NV61:
> + case V4L2_PIX_FMT_NV24:
> + case V4L2_PIX_FMT_NV42:
> + return 1;
> + case V4L2_PIX_FMT_BGR24:
> + case V4L2_PIX_FMT_RGB24:
> + return 3;
> + case V4L2_PIX_FMT_ARGB32:
> + return 4;
> + case V4L2_PIX_FMT_VYUY:
> + case V4L2_PIX_FMT_YVYU:
> + case V4L2_PIX_FMT_UYVY:
> + case V4L2_PIX_FMT_YUYV:
> + return 2;
> + default:
> + return 0;
> + };
> +}
> +
> +int V4L2CompatManager::imageSize(unsigned int format,
> + unsigned int width, unsigned int height)
> +{
> + switch (format) {
> + case V4L2_PIX_FMT_NV12:
> + case V4L2_PIX_FMT_NV21:
> + return width * height + width * height / 2;
> + case V4L2_PIX_FMT_NV16:
> + case V4L2_PIX_FMT_NV61:
> + return width * height * 2;
> + case V4L2_PIX_FMT_NV24:
> + case V4L2_PIX_FMT_NV42:
> + return width * height * 3;
> + case V4L2_PIX_FMT_BGR24:
> + case V4L2_PIX_FMT_RGB24:
> + return width * height * 3;
> + case V4L2_PIX_FMT_ARGB32:
> + return width * height * 4;
> + case V4L2_PIX_FMT_VYUY:
> + case V4L2_PIX_FMT_YVYU:
> + case V4L2_PIX_FMT_UYVY:
> + case V4L2_PIX_FMT_YUYV:
> + return width * height * 2;
> + default:
> + return 0;
> + };
> +}
> +
> +unsigned int V4L2CompatManager::v4l2ToDrm(unsigned int pixelformat)
> +{
> + switch (pixelformat) {
> + /* RGB formats. */
> + case V4L2_PIX_FMT_RGB24:
> + return DRM_FORMAT_BGR888;
> + case V4L2_PIX_FMT_BGR24:
> + return DRM_FORMAT_RGB888;
> + case V4L2_PIX_FMT_ARGB32:
> + return DRM_FORMAT_BGRA8888;
> +
> + /* YUV packed formats. */
> + case V4L2_PIX_FMT_YUYV:
> + return DRM_FORMAT_YUYV;
> + case V4L2_PIX_FMT_YVYU:
> + return DRM_FORMAT_YVYU;
> + case V4L2_PIX_FMT_UYVY:
> + return DRM_FORMAT_UYVY;
> + case V4L2_PIX_FMT_VYUY:
> + return DRM_FORMAT_VYUY;
> +
> + /* YUY planar formats. */
> + case V4L2_PIX_FMT_NV16:
> + return DRM_FORMAT_NV16;
> + case V4L2_PIX_FMT_NV61:
> + return DRM_FORMAT_NV61;
> + case V4L2_PIX_FMT_NV12:
> + return DRM_FORMAT_NV12;
> + case V4L2_PIX_FMT_NV21:
> + return DRM_FORMAT_NV21;
> + case V4L2_PIX_FMT_NV24:
> + return DRM_FORMAT_NV24;
> + case V4L2_PIX_FMT_NV42:
> + return DRM_FORMAT_NV42;
> + default:
> + return pixelformat;
> + };
> +}
> +
> +unsigned int V4L2CompatManager::drmToV4L2(unsigned int pixelformat)
> +{
> + switch (pixelformat) {
> + /* RGB formats. */
> + case DRM_FORMAT_BGR888:
> + return V4L2_PIX_FMT_RGB24;
> + case DRM_FORMAT_RGB888:
> + return V4L2_PIX_FMT_BGR24;
> + case DRM_FORMAT_BGRA8888:
> + return V4L2_PIX_FMT_ARGB32;
> +
> + /* YUV packed formats. */
> + case DRM_FORMAT_YUYV:
> + return V4L2_PIX_FMT_YUYV;
> + case DRM_FORMAT_YVYU:
> + return V4L2_PIX_FMT_YVYU;
> + case DRM_FORMAT_UYVY:
> + return V4L2_PIX_FMT_UYVY;
> + case DRM_FORMAT_VYUY:
> + return V4L2_PIX_FMT_VYUY;
> +
> + /* YUY planar formats. */
> + case DRM_FORMAT_NV16:
> + return V4L2_PIX_FMT_NV16;
> + case DRM_FORMAT_NV61:
> + return V4L2_PIX_FMT_NV61;
> + case DRM_FORMAT_NV12:
> + return V4L2_PIX_FMT_NV12;
> + case DRM_FORMAT_NV21:
> + return V4L2_PIX_FMT_NV21;
> + case DRM_FORMAT_NV24:
> + return V4L2_PIX_FMT_NV24;
> + case DRM_FORMAT_NV42:
> + return V4L2_PIX_FMT_NV42;
> + default:
> + return pixelformat;
> + }
> +}
> diff --git a/src/v4l2/v4l2_compat_manager.h b/src/v4l2/v4l2_compat_manager.h
> new file mode 100644
> index 00000000..d5ae7810
> --- /dev/null
> +++ b/src/v4l2/v4l2_compat_manager.h
> @@ -0,0 +1,86 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * v4l2_compat_manager.h - V4L2 compatibility manager
> + */
> +#ifndef __V4L2_COMPAT_MANAGER_H__
> +#define __V4L2_COMPAT_MANAGER_H__
> +
> +#include <condition_variable>
> +#include <linux/videodev2.h>
> +#include <map>
> +#include <mutex>
> +#include <queue>
> +#include <sys/syscall.h>
> +#include <unistd.h>
> +#include <vector>
> +
> +#include <libcamera/camera.h>
> +#include <libcamera/camera_manager.h>
> +#include <libcamera/stream.h>
> +
> +#include "thread.h"
> +#include "v4l2_camera_proxy.h"
> +
> +using namespace libcamera;
> +
> +class V4L2CompatManager : public Thread
> +{
> +public:
> + static V4L2CompatManager *instance();
> +
> + int init();
> +
> + int openat(int dirfd, const char *path, int oflag, mode_t mode);
> +
> + V4L2CameraProxy *getCamera(int fd);
> + V4L2CameraProxy *getCamera(void *addr);
> +
> + int dup(int oldfd);
> + int close(int fd);
> + void *mmap(void *addr, size_t length, int prot, int flags,
> + int fd, off_t offset);
> + int munmap(void *addr, size_t length);
> + int ioctl(int fd, unsigned long request, void *arg);
> +
> + static int bplMultiplier(unsigned int format);
> + static int imageSize(unsigned int format, unsigned int width,
> + unsigned int height);
> +
> + static unsigned int v4l2ToDrm(unsigned int pixelformat);
> + static unsigned int drmToV4L2(unsigned int pixelformat);
> +
> +private:
> + V4L2CompatManager();
> + ~V4L2CompatManager();
> +
> + void run() override;
> + int getCameraIndex(int fd);
> +
> + typedef int (*openat_func_t)(int dirfd, const char *path, int oflag, ...);
> + typedef int (*dup_func_t)(int oldfd);
> + typedef int (*close_func_t)(int fd);
> + typedef int (*ioctl_func_t)(int fd, unsigned long request, ...);
> + typedef void *(*mmap_func_t)(void *addr, size_t length, int prot,
> + int flags, int fd, off_t offset);
> + typedef int (*munmap_func_t)(void *addr, size_t length);
> +
> + openat_func_t openat_func_;
> + dup_func_t dup_func_;
> + close_func_t close_func_;
> + ioctl_func_t ioctl_func_;
> + mmap_func_t mmap_func_;
> + munmap_func_t munmap_func_;
> +
> + CameraManager *cm_;
> +
> + std::mutex mutex_;
> + std::condition_variable cv_;
> +
> + std::vector<std::shared_ptr<V4L2CameraProxy>> proxies_;
> + std::map<int, std::shared_ptr<V4L2CameraProxy>> devices_;
> + std::map<void *, int> mmaps_;
> +};
> +
> +#endif /* __V4L2_COMPAT_MANAGER_H__ */
> --
> 2.23.0
>
More information about the libcamera-devel
mailing list