From patchwork Thu May 19 12:35:59 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yordan Kamenov X-Patchwork-Id: 797442 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by demeter1.kernel.org (8.14.4/8.14.3) with ESMTP id p4JCaIYv016144 for ; Thu, 19 May 2011 12:36:18 GMT Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932697Ab1ESMgQ (ORCPT ); Thu, 19 May 2011 08:36:16 -0400 Received: from ns.mm-sol.com ([213.240.235.226]:32953 "EHLO extserv.mm-sol.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932622Ab1ESMgO (ORCPT ); Thu, 19 May 2011 08:36:14 -0400 Received: from intsrv.int.mm-sol.com (unknown [172.18.0.2]) by extserv.mm-sol.com (Postfix) with ESMTP id CCE2CC382; Thu, 19 May 2011 15:36:12 +0300 (EEST) Received: from localhost (localhost [127.0.0.1]) by intsrv.int.mm-sol.com (Postfix) with ESMTP id BCF8EFC2F57; Thu, 19 May 2011 15:36:12 +0300 (EEST) X-Virus-Scanned: by amavisd-new-2.6.4 (20090625) Received: from intsrv.int.mm-sol.com ([127.0.0.1]) by localhost (mail.mm-sol.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id QXyyREgs-q8O; Thu, 19 May 2011 15:36:02 +0300 (EEST) Received: from localhost (ykamenov.int.mm-sol.com [172.20.6.109]) by intsrv.int.mm-sol.com (Postfix) with ESMTP id DB7FEFC2F46; Thu, 19 May 2011 15:36:02 +0300 (EEST) From: Yordan Kamenov To: linux-media@vger.kernel.org Cc: sakari.ailus@maxwell.research.nokia.com, Yordan Kamenov Subject: [RESEND PATCH 1/1] libv4l2: Add plugin support to libv4l Date: Thu, 19 May 2011 15:35:59 +0300 Message-Id: <1678f1f41284ad9665de8717b7b8be117ddf9596.1305807275.git.ykamenov@mm-sol.com> X-Mailer: git-send-email 1.5.6.5 Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org X-Greylist: IP, sender and recipient auto-whitelisted, not delayed by milter-greylist-4.2.6 (demeter1.kernel.org [140.211.167.41]); Thu, 19 May 2011 12:36:19 +0000 (UTC) A libv4l2 plugin will sit in between libv4l2 itself and the actual /dev/video device node a fd refers to. It will be called each time libv4l2 wants to do an operation (read/write/ioctl) on the actual /dev/video node in question. Signed-off-by: Yordan Kamenov --- lib/include/libv4l2-plugin.h | 36 ++++++ lib/include/libv4lconvert.h | 5 +- lib/libv4l2/Makefile | 6 +- lib/libv4l2/libv4l2-priv.h | 10 ++ lib/libv4l2/libv4l2.c | 88 ++++++++++---- lib/libv4l2/v4l2-plugin.c | 158 ++++++++++++++++++++++++ lib/libv4l2/v4l2convert.c | 9 -- lib/libv4lconvert/control/libv4lcontrol-priv.h | 4 + lib/libv4lconvert/control/libv4lcontrol.c | 35 ++++-- lib/libv4lconvert/control/libv4lcontrol.h | 5 +- lib/libv4lconvert/libv4lconvert-priv.h | 2 + lib/libv4lconvert/libv4lconvert.c | 34 ++++-- utils/qv4l2/qv4l2.cpp | 17 +++- utils/qv4l2/qv4l2.h | 1 + 14 files changed, 347 insertions(+), 63 deletions(-) create mode 100644 lib/include/libv4l2-plugin.h create mode 100644 lib/libv4l2/v4l2-plugin.c diff --git a/lib/include/libv4l2-plugin.h b/lib/include/libv4l2-plugin.h new file mode 100644 index 0000000..158c0c2 --- /dev/null +++ b/lib/include/libv4l2-plugin.h @@ -0,0 +1,36 @@ +/* +* Copyright (C) 2010 Nokia Corporation + +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU Lesser General Public License as published by +* the Free Software Foundation; either version 2.1 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#ifndef __LIBV4L2_PLUGIN_H +#define __LIBV4L2_PLUGIN_H + +#include + +/* Structure libv4l2_dev_ops holds the calls from libv4ls to video nodes. + They can be normal open/close/ioctl etc. or any of them may be replaced + with a callback by a loaded plugin. +*/ + +struct libv4l2_dev_ops { + void * (*init)(int fd); + void (*close)(void *dev_ops_priv); + int (*ioctl)(void *dev_ops_priv, int fd, unsigned long int request, void *arg); + ssize_t (*read)(void *dev_ops_priv, int fd, void *buffer, size_t n); +}; + +#endif diff --git a/lib/include/libv4lconvert.h b/lib/include/libv4lconvert.h index 0264290..351142e 100644 --- a/lib/include/libv4lconvert.h +++ b/lib/include/libv4lconvert.h @@ -38,6 +38,8 @@ #include +#include "libv4l2-plugin.h" + #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ @@ -50,7 +52,8 @@ extern "C" { struct v4lconvert_data; -LIBV4L_PUBLIC struct v4lconvert_data *v4lconvert_create(int fd); +LIBV4L_PUBLIC struct v4lconvert_data *v4lconvert_create(int fd, + void *dev_ops_priv, struct libv4l2_dev_ops *dev_ops); LIBV4L_PUBLIC void v4lconvert_destroy(struct v4lconvert_data *data); /* When doing flipping / rotating / video-processing, only supported diff --git a/lib/libv4l2/Makefile b/lib/libv4l2/Makefile index d78632f..f8b3714 100644 --- a/lib/libv4l2/Makefile +++ b/lib/libv4l2/Makefile @@ -1,12 +1,12 @@ override CPPFLAGS += -I../include -fvisibility=hidden -LIBS_libv4l2 = -lpthread +LIBS_libv4l2 = -lpthread -ldl -V4L2_OBJS = libv4l2.o log.o +V4L2_OBJS = libv4l2.o v4l2-plugin.o log.o V4L2CONVERT = v4l2convert.so V4L2CONVERT_O = v4l2convert.o libv4l2.so TARGETS = $(V4L2_LIB) libv4l2.pc -INCLUDES = ../include/libv4l2.h +INCLUDES = ../include/libv4l2.h ../include/libv4l2-plugin.h ifeq ($(LINKTYPE),static) V4L2_LIB = libv4l2.a diff --git a/lib/libv4l2/libv4l2-priv.h b/lib/libv4l2/libv4l2-priv.h index 46d6103..d06a508 100644 --- a/lib/libv4l2/libv4l2-priv.h +++ b/lib/libv4l2/libv4l2-priv.h @@ -85,8 +85,18 @@ struct v4l2_dev_info { /* buffer when doing conversion and using read() for read() */ int readbuf_size; unsigned char *readbuf; + struct libv4l2_dev_ops *dev_ops; + /* plugin info */ + void *plugin_library; + void *dev_ops_priv; }; +void v4l2_plugin_init(int fd, void **plugin_lib_ret, void **plugin_priv_ret, + struct libv4l2_dev_ops **dev_ops_ret); +void v4l2_plugin_cleanup(void *plugin_priv, void *plugin_lib, + struct libv4l2_dev_ops *dev_ops); + + /* From log.c */ void v4l2_log_ioctl(unsigned long int request, void *arg, int result); diff --git a/lib/libv4l2/libv4l2.c b/lib/libv4l2/libv4l2.c index ab85ea7..018350e 100644 --- a/lib/libv4l2/libv4l2.c +++ b/lib/libv4l2/libv4l2.c @@ -67,6 +67,7 @@ #include #include "libv4l2.h" #include "libv4l2-priv.h" +#include "libv4l2-plugin.h" /* Note these flags are stored together with the flags passed to v4l2_fd_open() in v4l2_dev_info's flags member, so care should be taken that the do not @@ -102,7 +103,8 @@ static int v4l2_request_read_buffers(int index) devices[index].nreadbuffers; req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.memory = V4L2_MEMORY_MMAP; - result = SYS_IOCTL(devices[index].fd, VIDIOC_REQBUFS, &req); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_REQBUFS, &req); if (result < 0) { int saved_err = errno; @@ -131,7 +133,8 @@ static void v4l2_unrequest_read_buffers(int index) req.count = 0; req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.memory = V4L2_MEMORY_MMAP; - if (SYS_IOCTL(devices[index].fd, VIDIOC_REQBUFS, &req) < 0) + if (devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_REQBUFS, &req) < 0) return; devices[index].no_frames = MIN(req.count, V4L2_MAX_NO_FRAMES); @@ -152,7 +155,8 @@ static int v4l2_map_buffers(int index) buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = i; - result = SYS_IOCTL(devices[index].fd, VIDIOC_QUERYBUF, &buf); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_QUERYBUF, &buf); if (result) { int saved_err = errno; @@ -202,7 +206,8 @@ static int v4l2_streamon(int index) enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (!(devices[index].flags & V4L2_STREAMON)) { - result = SYS_IOCTL(devices[index].fd, VIDIOC_STREAMON, &type); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_STREAMON, &type); if (result) { int saved_err = errno; @@ -223,7 +228,8 @@ static int v4l2_streamoff(int index) enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (devices[index].flags & V4L2_STREAMON) { - result = SYS_IOCTL(devices[index].fd, VIDIOC_STREAMOFF, &type); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_STREAMOFF, &type); if (result) { int saved_err = errno; @@ -252,7 +258,8 @@ static int v4l2_queue_read_buffer(int index, int buffer_index) buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = buffer_index; - result = SYS_IOCTL(devices[index].fd, VIDIOC_QBUF, &buf); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_QBUF, &buf); if (result) { int saved_err = errno; @@ -277,7 +284,8 @@ static int v4l2_dequeue_and_convert(int index, struct v4l2_buffer *buf, return result; do { - result = SYS_IOCTL(devices[index].fd, VIDIOC_DQBUF, buf); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_DQBUF, buf); if (result) { if (errno != EAGAIN) { int saved_err = errno; @@ -356,7 +364,8 @@ static int v4l2_read_and_convert(int index, unsigned char *dest, int dest_size) } do { - result = SYS_READ(devices[index].fd, devices[index].readbuf, buf_size); + result = devices[index].dev_ops->read(devices[index].dev_ops_priv, + devices[index].fd, devices[index].readbuf, buf_size); if (result <= 0) { if (result && errno != EAGAIN) { int saved_err = errno; @@ -496,7 +505,8 @@ static int v4l2_buffers_mapped(int index) buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = i; - if (SYS_IOCTL(devices[index].fd, VIDIOC_QUERYBUF, &buf)) { + if (devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_QUERYBUF, &buf)) { int saved_err = errno; V4L2_LOG_ERR("querying buffer %u: %s\n", i, strerror(errno)); @@ -561,6 +571,11 @@ int v4l2_fd_open(int fd, int v4l2_flags) struct v4l2_capability cap; struct v4l2_format fmt; struct v4lconvert_data *convert; + struct libv4l2_dev_ops *dev_ops; + void *plugin_library; + void *plugin_data; + + v4l2_plugin_init(fd, &plugin_library, &plugin_data, &dev_ops); /* If no log file was set by the app, see if one was specified through the environment */ @@ -571,9 +586,10 @@ int v4l2_fd_open(int fd, int v4l2_flags) } /* check that this is an v4l2 device */ - if (SYS_IOCTL(fd, VIDIOC_QUERYCAP, &cap)) { + if (dev_ops->ioctl(plugin_data, fd, VIDIOC_QUERYCAP, &cap)) { int saved_err = errno; + v4l2_plugin_cleanup(plugin_data, plugin_library, dev_ops); V4L2_LOG_ERR("getting capabilities: %s\n", strerror(errno)); errno = saved_err; return -1; @@ -581,29 +597,38 @@ int v4l2_fd_open(int fd, int v4l2_flags) /* we only add functionality for video capture devices */ if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) || - !(cap.capabilities & (V4L2_CAP_STREAMING | V4L2_CAP_READWRITE))) + !(cap.capabilities & (V4L2_CAP_STREAMING | V4L2_CAP_READWRITE))) { + v4l2_plugin_cleanup(plugin_data, plugin_library, dev_ops); return fd; + } /* Get current cam format */ fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (SYS_IOCTL(fd, VIDIOC_G_FMT, &fmt)) { + if (dev_ops->ioctl(plugin_data, fd, VIDIOC_G_FMT, &fmt)) { int saved_err = errno; + v4l2_plugin_cleanup(plugin_data, plugin_library, dev_ops); V4L2_LOG_ERR("getting pixformat: %s\n", strerror(errno)); errno = saved_err; return -1; } /* init libv4lconvert */ - convert = v4lconvert_create(fd); - if (!convert) + convert = v4lconvert_create(fd, plugin_data, dev_ops); + if (!convert) { + v4l2_plugin_cleanup(plugin_data, plugin_library, dev_ops); return -1; + } /* So we have a v4l2 capture device, register it in our devices array */ pthread_mutex_lock(&v4l2_open_mutex); for (index = 0; index < V4L2_MAX_DEVICES; index++) if (devices[index].fd == -1) { devices[index].fd = fd; + + devices[index].plugin_library = plugin_library; + devices[index].dev_ops_priv = plugin_data; + devices[index].dev_ops = dev_ops; break; } pthread_mutex_unlock(&v4l2_open_mutex); @@ -611,6 +636,7 @@ int v4l2_fd_open(int fd, int v4l2_flags) if (index == V4L2_MAX_DEVICES) { V4L2_LOG_ERR("attempting to open more then %d video devices\n", V4L2_MAX_DEVICES); + v4l2_plugin_cleanup(plugin_data, plugin_library, dev_ops); errno = EBUSY; return -1; } @@ -700,6 +726,9 @@ int v4l2_close(int fd) if (result) return 0; + v4l2_plugin_cleanup(devices[index].dev_ops_priv, + devices[index].plugin_library, devices[index].dev_ops); + /* Free resources */ v4l2_unmap_buffers(index); if (devices[index].convert_mmap_buf != MAP_FAILED) { @@ -879,7 +908,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) } if (!is_capture_request) { - result = SYS_IOCTL(fd, request, arg); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + fd, request, arg); saved_err = errno; v4l2_log_ioctl(request, arg, result); errno = saved_err; @@ -927,7 +957,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) case VIDIOC_QUERYCAP: { struct v4l2_capability *cap = arg; - result = SYS_IOCTL(devices[index].fd, VIDIOC_QUERYCAP, cap); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_QUERYCAP, cap); if (result == 0) /* We always support read() as we fake it using mmap mode */ cap->capabilities |= V4L2_CAP_READWRITE; @@ -977,8 +1008,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) } if (devices[index].flags & V4L2_DISABLE_CONVERSION) { - result = SYS_IOCTL(devices[index].fd, VIDIOC_TRY_FMT, - dest_fmt); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_TRY_FMT, dest_fmt); src_fmt = *dest_fmt; } else { result = v4lconvert_try_format(devices[index].convert, dest_fmt, @@ -1018,7 +1049,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) break; req_pix_fmt = src_fmt.fmt.pix; - result = SYS_IOCTL(devices[index].fd, VIDIOC_S_FMT, &src_fmt); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_S_FMT, &src_fmt); if (result) { saved_err = errno; V4L2_LOG_ERR("setting pixformat: %s\n", strerror(errno)); @@ -1067,7 +1099,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) if (req->count > V4L2_MAX_NO_FRAMES) req->count = V4L2_MAX_NO_FRAMES; - result = SYS_IOCTL(devices[index].fd, VIDIOC_REQBUFS, req); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_REQBUFS, req); if (result < 0) break; result = 0; /* some drivers return the number of buffers on success */ @@ -1088,7 +1121,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) /* Do a real query even when converting to let the driver fill in things like buf->field */ - result = SYS_IOCTL(devices[index].fd, VIDIOC_QUERYBUF, buf); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_QUERYBUF, buf); if (result || !v4l2_needs_conversion(index)) break; @@ -1115,7 +1149,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) break; } - result = SYS_IOCTL(devices[index].fd, VIDIOC_QBUF, arg); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_QBUF, arg); break; case VIDIOC_DQBUF: { @@ -1128,7 +1163,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) } if (!v4l2_needs_conversion(index)) { - result = SYS_IOCTL(devices[index].fd, VIDIOC_DQBUF, buf); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + devices[index].fd, VIDIOC_DQBUF, buf); if (result) { int saved_err = errno; @@ -1187,7 +1223,8 @@ int v4l2_ioctl(int fd, unsigned long int request, ...) break; default: - result = SYS_IOCTL(fd, request, arg); + result = devices[index].dev_ops->ioctl(devices[index].dev_ops_priv, + fd, request, arg); break; } @@ -1217,7 +1254,8 @@ ssize_t v4l2_read(int fd, void *dest, size_t n) it */ if ((devices[index].flags & V4L2_SUPPORTS_READ) && !v4l2_needs_conversion(index)) { - result = SYS_READ(fd, dest, n); + result = devices[index].dev_ops->read(devices[index].dev_ops_priv, + fd, dest, n); goto leave; } diff --git a/lib/libv4l2/v4l2-plugin.c b/lib/libv4l2/v4l2-plugin.c new file mode 100644 index 0000000..3735193 --- /dev/null +++ b/lib/libv4l2/v4l2-plugin.c @@ -0,0 +1,158 @@ +/* +* Copyright (C) 2010 Nokia Corporation + +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU Lesser General Public License as published by +* the Free Software Foundation; either version 2.1 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include +#include +#include +#include +#include +#include +#include "libv4l2.h" +#include "libv4l2-priv.h" +#include "libv4l2-plugin.h" + +/* libv4l plugin support: + it is provided by functions v4l2_plugin_[open,close,etc]. + + When open() is called libv4l dlopens files in /usr/lib[64]/libv4l/plugins + 1 at a time and call open callback passing through the applications + parameters unmodified. + + If a plugin is relevant for the specified device node, it can indicate so + by returning a value other then -1 (the actual file descriptor). + As soon as a plugin returns another value then -1 plugin loading stops and + information about it (fd and corresponding library handle) is stored. For + each function v4l2_[ioctl,read,close,etc] is called corresponding + v4l2_plugin_* function which looks if there is loaded plugin for that file + and call it's callbacks. + + v4l2_plugin_* function indicates by it's first argument if plugin was used, + and if it was not then v4l2_* functions proceed with their usual behavior. +*/ + +#define PLUGINS_PATTERN "/usr/lib/libv4l/plugins/*.so" + +static void * dev_init(int fd) +{ + return NULL; +} + +static void dev_close(void *dev_ops_priv) +{ +} + +static int dev_ioctl(void *dev_ops_priv, int fd, unsigned long cmd, void *arg) +{ + return SYS_IOCTL(fd, cmd, arg); +} + +static ssize_t dev_read(void *dev_ops_priv, int fd, void *buf, size_t len) +{ + return SYS_READ(fd, buf, len); +} + + +struct libv4l2_dev_ops default_operations = { + .init = &dev_init, + .close = &dev_close, + .ioctl = &dev_ioctl, + .read = &dev_read +}; + +void v4l2_plugin_init(int fd, void **plugin_lib_ret, void **plugin_priv_ret, + struct libv4l2_dev_ops **dev_ops_ret) +{ + char *error; + int glob_ret, plugin_num; + void *plugin_library = NULL; + struct libv4l2_dev_ops *libv4l2_plugin = NULL; + glob_t globbuf; + + *dev_ops_ret = &default_operations; + + glob_ret = glob(PLUGINS_PATTERN, 0, NULL, &globbuf); + + if (glob_ret == GLOB_NOSPACE) { + *plugin_lib_ret = NULL; + *plugin_priv_ret = NULL; + return; + } + + if (glob_ret == GLOB_ABORTED || glob_ret == GLOB_NOMATCH) { + *plugin_lib_ret = NULL; + *plugin_priv_ret = NULL; + goto leave; + } + + for (plugin_num = 0; plugin_num < globbuf.gl_pathc; plugin_num++) { + + V4L2_LOG("PLUGIN: dlopen(%s);\n", globbuf.gl_pathv[plugin_num]); + + plugin_library = dlopen(globbuf.gl_pathv[plugin_num], + RTLD_LAZY); + + if (!plugin_library) + continue; + + dlerror(); /* Clear any existing error */ + libv4l2_plugin = (struct libv4l2_dev_ops *) + dlsym(plugin_library, "libv4l2_plugin"); + + error = dlerror(); + if (error != NULL) { + V4L2_LOG_ERR("PLUGIN: dlsym failed: %s\n", error); + dlclose(plugin_library); + + continue; + } + + *plugin_priv_ret = NULL; + if (libv4l2_plugin->init) + *plugin_priv_ret = libv4l2_plugin->init(fd); + + if (!*plugin_priv_ret) { + V4L2_LOG("PLUGIN: plugin open() returned NULL\n"); + dlclose(plugin_library); + *plugin_lib_ret = NULL; + continue; + } + + (*dev_ops_ret)->init = libv4l2_plugin->init; + if (libv4l2_plugin->close != NULL) + (*dev_ops_ret)->close = libv4l2_plugin->close; + if (libv4l2_plugin->ioctl != NULL) + (*dev_ops_ret)->ioctl = libv4l2_plugin->ioctl; + if (libv4l2_plugin->read != NULL) + (*dev_ops_ret)->read = libv4l2_plugin->read; + + break; + + } + +leave: + globfree(&globbuf); +} + +void v4l2_plugin_cleanup(void *plugin_priv, void *plugin_lib, + struct libv4l2_dev_ops *dev_ops) +{ + if (plugin_priv) { + dev_ops->close(plugin_priv); + dlclose(plugin_lib); + } +} diff --git a/lib/libv4l2/v4l2convert.c b/lib/libv4l2/v4l2convert.c index e251085..03f34ad 100644 --- a/lib/libv4l2/v4l2convert.c +++ b/lib/libv4l2/v4l2convert.c @@ -46,7 +46,6 @@ LIBV4L_PUBLIC int open(const char *file, int oflag, ...) { int fd; - struct v4l2_capability cap; int v4l_device = 0; /* check if we're opening a video4linux2 device */ @@ -76,14 +75,6 @@ LIBV4L_PUBLIC int open(const char *file, int oflag, ...) if (fd == -1 || !v4l_device) return fd; - /* check that this is an v4l2 device, libv4l2 only supports v4l2 devices */ - if (SYS_IOCTL(fd, VIDIOC_QUERYCAP, &cap)) - return fd; - - /* libv4l2 only adds functionality to capture capable devices */ - if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) - return fd; - /* Try to Register with libv4l2 (in case of failure pass the fd to the application as is) */ v4l2_fd_open(fd, 0); diff --git a/lib/libv4lconvert/control/libv4lcontrol-priv.h b/lib/libv4lconvert/control/libv4lcontrol-priv.h index 22cdf34..1259e6b 100644 --- a/lib/libv4lconvert/control/libv4lcontrol-priv.h +++ b/lib/libv4lconvert/control/libv4lcontrol-priv.h @@ -22,6 +22,8 @@ #ifndef __LIBV4LCONTROL_PRIV_H #define __LIBV4LCONTROL_PRIV_H +#include "libv4l2-plugin.h" + #define V4LCONTROL_SHM_SIZE 4096 #define V4LCONTROL_SUPPORTS_NEXT_CTRL 0x01 @@ -37,6 +39,8 @@ struct v4lcontrol_data { unsigned int *shm_values; /* shared memory control value store */ unsigned int old_values[V4LCONTROL_COUNT]; /* for controls_changed() */ const struct v4lcontrol_flags_info *flags_info; + struct libv4l2_dev_ops *dev_ops; + void *dev_ops_priv; }; struct v4lcontrol_flags_info { diff --git a/lib/libv4lconvert/control/libv4lcontrol.c b/lib/libv4lconvert/control/libv4lcontrol.c index 116bef5..24a5600 100644 --- a/lib/libv4lconvert/control/libv4lcontrol.c +++ b/lib/libv4lconvert/control/libv4lcontrol.c @@ -747,7 +747,8 @@ static void v4lcontrol_get_flags_from_db(struct v4lcontrol_data *data, } } -struct v4lcontrol_data *v4lcontrol_create(int fd, int always_needs_conversion) +struct v4lcontrol_data *v4lcontrol_create(int fd, void *dev_ops_priv, + struct libv4l2_dev_ops *dev_ops, int always_needs_conversion) { int shm_fd; int i, rc, got_usb_ids, init = 0; @@ -767,10 +768,12 @@ struct v4lcontrol_data *v4lcontrol_create(int fd, int always_needs_conversion) } data->fd = fd; + data->dev_ops = dev_ops; + data->dev_ops_priv = dev_ops_priv; /* Check if the driver has indicated some form of flipping is needed */ - if ((SYS_IOCTL(data->fd, VIDIOC_G_INPUT, &input.index) == 0) && - (SYS_IOCTL(data->fd, VIDIOC_ENUMINPUT, &input) == 0)) { + if ((data->dev_ops->ioctl(data->dev_ops_priv, data->fd, VIDIOC_G_INPUT, &input.index) == 0) && + (data->dev_ops->ioctl(data->dev_ops_priv, data->fd, VIDIOC_ENUMINPUT, &input) == 0)) { if (input.status & V4L2_IN_ST_HFLIP) data->flags |= V4LCONTROL_HFLIPPED; if (input.status & V4L2_IN_ST_VFLIP) @@ -787,7 +790,8 @@ struct v4lcontrol_data *v4lcontrol_create(int fd, int always_needs_conversion) data->flags = strtol(s, NULL, 0); ctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL; - if (SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, &ctrl) == 0) + if (data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_QUERYCTRL, &ctrl) == 0) data->priv_flags |= V4LCONTROL_SUPPORTS_NEXT_CTRL; /* If the device always needs conversion, we can add fake controls at no cost @@ -795,7 +799,8 @@ struct v4lcontrol_data *v4lcontrol_create(int fd, int always_needs_conversion) if (always_needs_conversion || v4lcontrol_needs_conversion(data)) { for (i = 0; i < V4LCONTROL_AUTO_ENABLE_COUNT; i++) { ctrl.id = fake_controls[i].id; - rc = SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, &ctrl); + rc = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_QUERYCTRL, &ctrl); if (rc == -1 || (rc == 0 && (ctrl.flags & V4L2_CTRL_FLAG_DISABLED))) data->controls |= 1 << i; } @@ -807,17 +812,20 @@ struct v4lcontrol_data *v4lcontrol_create(int fd, int always_needs_conversion) different sensors with / without autogain or the necessary controls. */ while (data->flags & V4LCONTROL_WANTS_AUTOGAIN) { ctrl.id = V4L2_CID_AUTOGAIN; - rc = SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, &ctrl); + rc = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_QUERYCTRL, &ctrl); if (rc == 0 && !(ctrl.flags & V4L2_CTRL_FLAG_DISABLED)) break; ctrl.id = V4L2_CID_EXPOSURE; - rc = SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, &ctrl); + rc = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_QUERYCTRL, &ctrl); if (rc != 0 || (ctrl.flags & V4L2_CTRL_FLAG_DISABLED)) break; ctrl.id = V4L2_CID_GAIN; - rc = SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, &ctrl); + rc = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_QUERYCTRL, &ctrl); if (rc != 0 || (ctrl.flags & V4L2_CTRL_FLAG_DISABLED)) break; @@ -834,7 +842,7 @@ struct v4lcontrol_data *v4lcontrol_create(int fd, int always_needs_conversion) if (data->controls == 0) return data; /* No need to create a shared memory segment */ - if (SYS_IOCTL(fd, VIDIOC_QUERYCAP, &cap)) { + if (data->dev_ops->ioctl(data->dev_ops_priv, fd, VIDIOC_QUERYCAP, &cap)) { perror("libv4lcontrol: error querying device capabilities"); goto error; } @@ -1020,7 +1028,8 @@ int v4lcontrol_vidioc_queryctrl(struct v4lcontrol_data *data, void *arg) } /* find out what the kernel driver would respond. */ - retval = SYS_IOCTL(data->fd, VIDIOC_QUERYCTRL, arg); + retval = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_QUERYCTRL, arg); if ((data->priv_flags & V4LCONTROL_SUPPORTS_NEXT_CTRL) && (orig_id & V4L2_CTRL_FLAG_NEXT_CTRL)) { @@ -1057,7 +1066,8 @@ int v4lcontrol_vidioc_g_ctrl(struct v4lcontrol_data *data, void *arg) return 0; } - return SYS_IOCTL(data->fd, VIDIOC_G_CTRL, arg); + return data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_G_CTRL, arg); } int v4lcontrol_vidioc_s_ctrl(struct v4lcontrol_data *data, void *arg) @@ -1078,7 +1088,8 @@ int v4lcontrol_vidioc_s_ctrl(struct v4lcontrol_data *data, void *arg) return 0; } - return SYS_IOCTL(data->fd, VIDIOC_S_CTRL, arg); + return data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_S_CTRL, arg); } int v4lcontrol_get_flags(struct v4lcontrol_data *data) diff --git a/lib/libv4lconvert/control/libv4lcontrol.h b/lib/libv4lconvert/control/libv4lcontrol.h index 974e97a..1c09546 100644 --- a/lib/libv4lconvert/control/libv4lcontrol.h +++ b/lib/libv4lconvert/control/libv4lcontrol.h @@ -22,6 +22,8 @@ #ifndef __LIBV4LCONTROL_H #define __LIBV4LCONTROL_H +#include "libv4l2-plugin.h" + /* Flags */ #define V4LCONTROL_HFLIPPED 0x01 #define V4LCONTROL_VFLIPPED 0x02 @@ -47,7 +49,8 @@ enum { struct v4lcontrol_data; -struct v4lcontrol_data *v4lcontrol_create(int fd, int always_needs_conversion); +struct v4lcontrol_data *v4lcontrol_create(int fd, void *dev_ops_priv, + struct libv4l2_dev_ops *dev_ops, int always_needs_conversion); void v4lcontrol_destroy(struct v4lcontrol_data *data); /* Functions used by v4lprocessing to get the control state */ diff --git a/lib/libv4lconvert/libv4lconvert-priv.h b/lib/libv4lconvert/libv4lconvert-priv.h index 84c706e..9cb6e1c 100644 --- a/lib/libv4lconvert/libv4lconvert-priv.h +++ b/lib/libv4lconvert/libv4lconvert-priv.h @@ -65,6 +65,8 @@ struct v4lconvert_data { unsigned char *convert_pixfmt_buf; struct v4lcontrol_data *control; struct v4lprocessing_data *processing; + struct libv4l2_dev_ops *dev_ops; + void *dev_ops_priv; /* Data for external decompression helpers code */ pid_t decompress_pid; diff --git a/lib/libv4lconvert/libv4lconvert.c b/lib/libv4lconvert/libv4lconvert.c index e4863fd..6861986 100644 --- a/lib/libv4lconvert/libv4lconvert.c +++ b/lib/libv4lconvert/libv4lconvert.c @@ -92,7 +92,8 @@ static const int v4lconvert_crop_res[][2] = { { 176, 144 }, }; -struct v4lconvert_data *v4lconvert_create(int fd) +struct v4lconvert_data *v4lconvert_create(int fd, void *dev_ops_priv, + struct libv4l2_dev_ops *dev_ops) { int i, j; struct v4lconvert_data *data = calloc(1, sizeof(struct v4lconvert_data)); @@ -108,6 +109,8 @@ struct v4lconvert_data *v4lconvert_create(int fd) } data->fd = fd; + data->dev_ops = dev_ops; + data->dev_ops_priv = dev_ops_priv; data->decompress_pid = -1; /* Check supported formats */ @@ -116,7 +119,7 @@ struct v4lconvert_data *v4lconvert_create(int fd) fmt.index = i; - if (SYS_IOCTL(data->fd, VIDIOC_ENUM_FMT, &fmt)) + if (data->dev_ops->ioctl(data->dev_ops_priv, data->fd, VIDIOC_ENUM_FMT, &fmt)) break; for (j = 0; j < ARRAY_SIZE(supported_src_pixfmts); j++) @@ -135,7 +138,8 @@ struct v4lconvert_data *v4lconvert_create(int fd) data->no_formats = i; /* Check if this cam has any special flags */ - if (SYS_IOCTL(data->fd, VIDIOC_QUERYCAP, &cap) == 0) { + if (data->dev_ops->ioctl(data->dev_ops_priv, + data->fd, VIDIOC_QUERYCAP, &cap) == 0) { if (!strcmp((char *)cap.driver, "uvcvideo")) data->flags |= V4LCONVERT_IS_UVC; @@ -143,7 +147,8 @@ struct v4lconvert_data *v4lconvert_create(int fd) always_needs_conversion = 0; } - data->control = v4lcontrol_create(fd, always_needs_conversion); + data->control = v4lcontrol_create(fd, dev_ops_priv, dev_ops, + always_needs_conversion); if (!data->control) { free(data); return NULL; @@ -206,7 +211,8 @@ int v4lconvert_enum_fmt(struct v4lconvert_data *data, struct v4l2_fmtdesc *fmt) if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || (!v4lconvert_supported_dst_fmt_only(data) && fmt->index < data->no_formats)) - return SYS_IOCTL(data->fd, VIDIOC_ENUM_FMT, fmt); + return data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_ENUM_FMT, fmt); for (i = 0; i < ARRAY_SIZE(supported_dst_pixfmts); i++) if (v4lconvert_supported_dst_fmt_only(data) || @@ -314,7 +320,8 @@ static int v4lconvert_do_try_format(struct v4lconvert_data *data, try_fmt = *dest_fmt; try_fmt.fmt.pix.pixelformat = supported_src_pixfmts[i].fmt; - if (!SYS_IOCTL(data->fd, VIDIOC_TRY_FMT, &try_fmt)) { + if (!data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_TRY_FMT, &try_fmt)) { if (try_fmt.fmt.pix.pixelformat == supported_src_pixfmts[i].fmt) { int size_x_diff = abs((int)try_fmt.fmt.pix.width - (int)dest_fmt->fmt.pix.width); @@ -382,7 +389,8 @@ int v4lconvert_try_format(struct v4lconvert_data *data, if (!v4lconvert_supported_dst_format(dest_fmt->fmt.pix.pixelformat) || dest_fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || v4lconvert_do_try_format(data, &try_dest, &try_src)) { - result = SYS_IOCTL(data->fd, VIDIOC_TRY_FMT, dest_fmt); + result = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_TRY_FMT, dest_fmt); if (src_fmt) *src_fmt = *dest_fmt; return result; @@ -1241,7 +1249,8 @@ static void v4lconvert_get_framesizes(struct v4lconvert_data *data, for (i = 0; ; i++) { frmsize.index = i; - if (SYS_IOCTL(data->fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) + if (data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_ENUM_FRAMESIZES, &frmsize)) break; /* We got a framesize, check we don't have the same one already */ @@ -1301,7 +1310,8 @@ int v4lconvert_enum_framesizes(struct v4lconvert_data *data, errno = EINVAL; return -1; } - return SYS_IOCTL(data->fd, VIDIOC_ENUM_FRAMESIZES, frmsize); + return data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_ENUM_FRAMESIZES, frmsize); } if (frmsize->index >= data->no_framesizes) { @@ -1337,7 +1347,8 @@ int v4lconvert_enum_frameintervals(struct v4lconvert_data *data, errno = EINVAL; return -1; } - res = SYS_IOCTL(data->fd, VIDIOC_ENUM_FRAMEINTERVALS, frmival); + res = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_ENUM_FRAMEINTERVALS, frmival); if (res) V4LCONVERT_ERR("%s\n", strerror(errno)); return res; @@ -1382,7 +1393,8 @@ int v4lconvert_enum_frameintervals(struct v4lconvert_data *data, frmival->pixel_format = src_fmt.fmt.pix.pixelformat; frmival->width = src_fmt.fmt.pix.width; frmival->height = src_fmt.fmt.pix.height; - res = SYS_IOCTL(data->fd, VIDIOC_ENUM_FRAMEINTERVALS, frmival); + res = data->dev_ops->ioctl(data->dev_ops_priv, data->fd, + VIDIOC_ENUM_FRAMEINTERVALS, frmival); if (res) { int dest_pixfmt = dest_fmt.fmt.pix.pixelformat; int src_pixfmt = src_fmt.fmt.pix.pixelformat; diff --git a/utils/qv4l2/qv4l2.cpp b/utils/qv4l2/qv4l2.cpp index 232a318..349d1ca 100644 --- a/utils/qv4l2/qv4l2.cpp +++ b/utils/qv4l2/qv4l2.cpp @@ -47,6 +47,17 @@ #include #include #include +#include + +int defIoctl(void *dev_ops_priv, int fd, unsigned long cmd, void *arg) +{ + return syscall(SYS_ioctl, (int)(fd), (unsigned long)(cmd), + (void *)(arg)); +} +ssize_t defRead(void *dev_ops_priv, int fd, void *buf, size_t len) +{ + return syscall(SYS_read, (int)(fd), (void *)(buf), (size_t)(len)); +} ApplicationWindow::ApplicationWindow() : m_capture(NULL), @@ -59,6 +70,10 @@ ApplicationWindow::ApplicationWindow() : m_frameData = NULL; m_nbuffers = 0; m_buffers = NULL; + m_defauldDevOps.init = NULL; + m_defauldDevOps.close = NULL; + m_defauldDevOps.ioctl = &defIoctl; + m_defauldDevOps.read = &defRead; QAction *openAct = new QAction(QIcon(":/fileopen.png"), "&Open device", this); openAct->setStatusTip("Open a v4l device, use libv4l2 wrapper if possible"); @@ -144,7 +159,7 @@ void ApplicationWindow::setDevice(const QString &device, bool rawOpen) } m_tabs->show(); m_tabs->setFocus(); - m_convertData = v4lconvert_create(fd()); + m_convertData = v4lconvert_create(fd(), NULL, &m_defauldDevOps); m_capStartAct->setEnabled(fd() >= 0); } diff --git a/utils/qv4l2/qv4l2.h b/utils/qv4l2/qv4l2.h index 0a3e5ef..d847fe6 100644 --- a/utils/qv4l2/qv4l2.h +++ b/utils/qv4l2/qv4l2.h @@ -91,6 +91,7 @@ private: unsigned char *m_frameData; unsigned m_nbuffers; struct v4lconvert_data *m_convertData; + struct libv4l2_dev_ops m_defauldDevOps; CapMethod m_capMethod; private slots: