summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/input/Makefile.am7
-rw-r--r--src/input/input_v4l2.c438
2 files changed, 445 insertions, 0 deletions
diff --git a/src/input/Makefile.am b/src/input/Makefile.am
index 0748c8f29..3c700ea46 100644
--- a/src/input/Makefile.am
+++ b/src/input/Makefile.am
@@ -21,6 +21,7 @@ endif
if HAVE_V4L
in_v4l = xineplug_inp_v4l.la
+in_v4l2 = xineplug_inp_v4l2.la
in_pvr = xineplug_inp_pvr.la
endif
@@ -60,6 +61,7 @@ xineplug_LTLIBRARIES = \
$(in_dvd) \
$(in_vcd) \
$(in_v4l) \
+ $(in_v4l2) \
$(in_gnome_vfs) \
$(in_smb) \
xineplug_inp_mms.la \
@@ -138,6 +140,11 @@ xineplug_inp_v4l_la_LIBADD = $(XINE_LIB) $(ALSA_LIBS) $(LTLIBINTL)
xineplug_inp_v4l_la_CFLAGS = $(VISIBILITY_FLAG) $(AM_CFLAGS)
xineplug_inp_v4l_la_LDFLAGS = -avoid-version -module
+xineplug_inp_v4l2_la_SOURCES = input_v4l2.c
+xineplug_inp_v4l2_la_LIBADD = $(XINE_LIB) $(ALSA_LIBS)
+xineplug_inp_v4l2_la_CFLAGS = $(VISIBILITY_FLAG) $(AM_CFLAGS)
+xineplug_inp_v4l2_la_LDFLAGS = -avoid-version -module
+
xineplug_inp_gnome_vfs_la_SOURCES = input_gnome_vfs.c net_buf_ctrl.c
xineplug_inp_gnome_vfs_la_LIBADD = $(XINE_LIB) $(GNOME_VFS_LIBS) $(PTHREAD_LIBS) $(LTLIBINTL)
xineplug_inp_gnome_la_CFLAGS = $(VISIBILITY_FLAG) $(AM_CFLAGS)
diff --git a/src/input/input_v4l2.c b/src/input/input_v4l2.c
new file mode 100644
index 000000000..69d0a3b75
--- /dev/null
+++ b/src/input/input_v4l2.c
@@ -0,0 +1,438 @@
+/*
+* Copyright (C) 2010 the xine project
+* Copyright (C) 2010 Trever Fischer <tdfischer@fedoraproject.org>
+*
+* This file is part of xine, a free video player.
+*
+* xine is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation; either version 2 of the License, or
+* (at your option) any later version.
+*
+* xine 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 General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+*
+* v4l2 input plugin
+*/
+
+#define LOG_MODULE "v4l2"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#define LOG
+
+#include "input_plugin.h"
+#include "xine_plugin.h"
+#include "xine_internal.h"
+
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <linux/videodev2.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <errno.h>
+
+#ifdef HAVE_LIBV4L2_H
+# include <libv4l2.h>
+#else
+# include <unistd.h>
+# include <sys/ioctl.h>
+# define v4l2_open(f,d) open(f,d)
+# define v4l2_ioctl(f,c,a) ioctl(f,c,a)
+# define v4l2_mmap(p,l,d,m,f,o) mmap(p,l,d,m,f,o)
+# define v4l2_munmap(s,l) munmap(s,l)
+# define v4l2_close(f) close(f)
+#endif
+
+typedef struct {
+ void *start;
+ size_t length;
+} buffer_data;
+
+typedef struct {
+ int width;
+ int height;
+} resolution_t;
+
+typedef struct {
+ buffer_data *buffers;
+ int bufcount;
+ resolution_t resolution;
+ struct v4l2_buffer inbuf;
+ off_t index;
+ int headerSent;
+} v4l2_video_t;
+
+typedef struct {
+ buffer_data *buffers;
+ int bufcount;
+} v4l2_radio_t;
+
+typedef struct {
+ input_plugin_t input_plugin;
+
+ int fd;
+ char* mrl;
+ struct v4l2_capability cap;
+ xine_stream_t *stream;
+
+ xine_event_queue_t *events;
+ v4l2_video_t* video;
+ v4l2_radio_t* radio;
+} v4l2_input_plugin_t;
+
+static void v4l2_input_enqueue_video_buffer(v4l2_input_plugin_t *this, int idx);
+static int v4l2_input_dequeue_video_buffer(v4l2_input_plugin_t *this, buf_element_t *input);
+static int v4l2_input_setup_video_streaming(v4l2_input_plugin_t *this);
+
+
+static int v4l2_input_open(input_plugin_t *this_gen) {
+ v4l2_input_plugin_t *this = (v4l2_input_plugin_t*) this_gen;
+ lprintf("Opening %s\n", this->mrl);
+ this->fd = v4l2_open(this->mrl, O_RDWR);
+ if (this->fd) {
+ /* TODO: Clean up this mess */
+ this->events = xine_event_new_queue(this->stream);
+ v4l2_ioctl(this->fd, VIDIOC_QUERYCAP, &(this->cap));
+ if (this->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) {
+ this->video = malloc(sizeof(v4l2_video_t));
+ this->video->headerSent = 0;
+ this->video->bufcount = 0;
+ }
+ if (this->cap.capabilities & V4L2_CAP_STREAMING) {
+ lprintf("Supports streaming. Allocating buffers...\n");
+ if (this->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) {
+ if (v4l2_input_setup_video_streaming(this)) {
+ lprintf("Video streaming ready.\n");
+ return 1;
+ } else {
+ /* TODO: Fallbacks */
+ lprintf("Video streaming setup failed.\n");
+ return 0;
+ }
+ } else {
+ /* TODO: Radio streaming */
+ lprintf("Sorry, only video is supported for now.\n");
+ return 0;
+ }
+ } else {
+ lprintf("Device doesn't support streaming. Prod the author to support the other methods.\n");
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+}
+
+static int v4l2_input_setup_video_streaming(v4l2_input_plugin_t *this) {
+ this->video->bufcount = 0;
+ struct v4l2_requestbuffers reqbuf;
+ unsigned int i;
+ memset(&reqbuf, 0, sizeof(reqbuf));
+ reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ reqbuf.memory = V4L2_MEMORY_MMAP;
+ reqbuf.count = 25;
+
+ if (-1 == v4l2_ioctl(this->fd, VIDIOC_REQBUFS, &reqbuf)) {
+ lprintf("Buffer request failed. Is streaming supported?\n");
+ return 0;
+ }
+
+ this->video->bufcount = reqbuf.count;
+ lprintf("Got %i buffers for stremaing.\n", reqbuf.count);
+
+ this->video->buffers = calloc(this->video->bufcount, sizeof(buffer_data));
+ _x_assert(this->video->buffers);
+ for (i = 0;i < this->video->bufcount;i++) {
+ struct v4l2_buffer buffer;
+ memset(&buffer, 0, sizeof(buffer));
+ buffer.type = reqbuf.type;
+ buffer.memory = reqbuf.memory;
+ buffer.index = i;
+
+ if (-1 == v4l2_ioctl(this->fd, VIDIOC_QUERYBUF, &buffer)) {
+ lprintf("Couldn't allocate buffer %i\n", i);
+ return 0;
+ }
+
+ this->video->buffers[i].length = buffer.length;
+ this->video->buffers[i].start = (void*)v4l2_mmap(NULL, buffer.length,
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED,
+ this->fd, buffer.m.offset);
+ if (MAP_FAILED == this->video->buffers[i].start) {
+ lprintf("Couldn't mmap buffer %i\n", i);
+ int j;
+ for(j = 0;j<i;j++) {
+ v4l2_munmap(this->video->buffers[i].start, this->video->buffers[i].length);
+ }
+ free(this->video->buffers);
+ this->video->bufcount = 0;
+ return 0;
+ }
+ v4l2_input_enqueue_video_buffer(this, i);
+ }
+
+ struct v4l2_format fmt;
+ memset(&fmt, 0, sizeof(fmt));
+ fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ /* TODO: Other formats? MPEG support? */
+ fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
+ if (-1 == v4l2_ioctl(this->fd, VIDIOC_S_FMT, &fmt))
+ goto fail;
+ this->video->resolution.width = fmt.fmt.pix.width;
+ this->video->resolution.height = fmt.fmt.pix.height;
+ if (-1 == v4l2_ioctl(this->fd, VIDIOC_STREAMON, &reqbuf.type))
+ goto fail;
+
+ _x_stream_info_set(this->stream, XINE_STREAM_INFO_HAS_AUDIO, 1);
+ _x_stream_info_set(this->stream, XINE_STREAM_INFO_HAS_VIDEO, 0);
+
+ return 1;
+
+ fail:
+ lprintf("Couldn't start streaming: %s\n", strerror(errno));
+ return 0;
+}
+
+
+static buf_element_t* v4l2_input_read_block(input_plugin_t *this_gen, fifo_buffer_t *fifo, off_t len) {
+ lprintf("Reading block\n");
+ v4l2_input_plugin_t *this = (v4l2_input_plugin_t*)this_gen;
+ buf_element_t *buf = fifo->buffer_pool_alloc(fifo);
+ if (!this->video->headerSent) {
+ struct timeval tv;
+ xine_monotonic_clock(&tv, NULL);
+ buf->pts = (int64_t) tv.tv_sec * 90000 + (int64_t) tv.tv_usec * 9 / 100;
+
+ lprintf("Sending video header\n");
+ xine_bmiheader bih;
+ bih.biSize = sizeof(xine_bmiheader);
+ /* HACK: Why do I need to do this and why is it magic? */
+ bih.biWidth = this->video->resolution.width*2;
+ bih.biHeight = this->video->resolution.height*2;
+ lprintf("Getting size of %ix%i\n", this->video->resolution.width, this->video->resolution.height);
+ buf->size = sizeof(xine_bmiheader);
+ buf->decoder_flags = BUF_FLAG_HEADER|BUF_FLAG_STDHEADER|BUF_FLAG_FRAME_START;
+ memcpy(buf->content, &bih, sizeof(xine_bmiheader));
+ this->video->headerSent = 1;
+ this->video->index = 0;
+ buf->type = BUF_VIDEO_YUY2;
+ } else {
+ lprintf("Sending video frame (sent %d of %d)\n", this->video->index, this->video->buffers[this->video->inbuf.index].length);
+ /* TODO: Add audio support */
+ this->video->headerSent = v4l2_input_dequeue_video_buffer(this, buf);
+ }
+ return buf;
+}
+
+static uint32_t v4l2_input_blocksize(input_plugin_t *this_gen) {
+ /* HACK */
+ return 0;
+ v4l2_input_plugin_t *this = (v4l2_input_plugin_t*)this_gen;
+ if (this->video->headerSent) {
+ lprintf("Returning block size of %zu\n",this->video->buffers[0].length);
+ return this->video->buffers[0].length;
+ } else {
+ lprintf("Returning block size of %zu\n",sizeof(xine_bmiheader));
+ return sizeof(xine_bmiheader);
+ }
+}
+
+static int v4l2_input_dequeue_video_buffer(v4l2_input_plugin_t *this, buf_element_t *output)
+{
+ if (!this->video->index)
+ {
+ memset (&this->video->inbuf, 0, sizeof (this->video->inbuf));
+ this->video->inbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ this->video->inbuf.memory = V4L2_MEMORY_MMAP;
+ v4l2_ioctl(this->fd, VIDIOC_DQBUF, &this->video->inbuf);
+ output->decoder_flags = BUF_FLAG_FRAME_START;
+ }
+ else
+ output->decoder_flags = 0;
+
+ output->content = output->mem;
+ output->type = BUF_VIDEO_YUY2;
+
+ output->size = this->video->buffers[this->video->inbuf.index].length - this->video->index;
+ if (output->size > output->max_size)
+ output->size = output->max_size;
+
+ xine_fast_memcpy (output->content, this->video->buffers[this->video->inbuf.index].start + this->video->index, output->size);
+
+ this->video->index += output->size;
+ if (this->video->index == this->video->buffers[this->video->inbuf.index].length)
+ {
+ output->decoder_flags |= BUF_FLAG_FRAME_END;
+ v4l2_input_enqueue_video_buffer(this, this->video->inbuf.index);
+ return 0;
+ }
+
+ return 1;
+}
+
+static void v4l2_input_enqueue_video_buffer(v4l2_input_plugin_t *this, int idx) {
+ struct v4l2_buffer buf;
+ memset(&buf, 0, sizeof(buf));
+ buf.index = idx;
+ buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ buf.memory = V4L2_MEMORY_MMAP;
+ v4l2_ioctl(this->fd, VIDIOC_QBUF, &buf);
+}
+
+static void v4l2_input_dispose(input_plugin_t *this_gen) {
+ lprintf("Disposing of myself.\n");
+ v4l2_input_plugin_t* this = (v4l2_input_plugin_t*)this_gen;
+
+ if (this->video != NULL) {
+ int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ if (-1 == v4l2_ioctl(this->fd, VIDIOC_STREAMOFF, &type)) {
+ lprintf("Couldn't stop streaming. Uh oh.\n");
+ }
+ if (this->video->bufcount > 0) {
+ int i;
+ for(i = 0;i<this->video->bufcount;i++) {
+ v4l2_munmap(this->video->buffers[i].start, this->video->buffers[i].length);
+ }
+ free(this->video->buffers);
+ }
+ free(this->video);
+ }
+ v4l2_close(this->fd);
+ free(this->mrl);
+ free(this);
+}
+
+static off_t v4l2_input_read(input_plugin_t *this_gen, char *buf, off_t nlen) {
+ /* Only block reads are supported. */
+ return 0;
+}
+
+static uint32_t v4l2_input_get_capabilities(input_plugin_t* this_gen) {
+ return INPUT_CAP_BLOCK;
+}
+
+static const char* v4l2_input_get_mrl(input_plugin_t* this_gen) {
+ v4l2_input_plugin_t* this = (v4l2_input_plugin_t*)this_gen;
+ /* HACK HACK HACK HACK */
+ /* So far, the only way to get the yuv_frames demuxer to work with this */
+ return "v4l:/";
+ //return this->mrl;
+}
+
+static int v4l2_input_get_optional_data(input_plugin_t *this_gen, void *data, int data_type) {
+ return INPUT_OPTIONAL_UNSUPPORTED;
+}
+
+/* Seeking not supported. */
+static off_t v4l2_input_seek(input_plugin_t *this_gen, off_t offset, int origin) {
+ return -1;
+}
+
+static off_t v4l2_input_seek_time(input_plugin_t *this_gen, int time_offset, int origin) {
+ return -1;
+}
+
+static off_t v4l2_input_pos(input_plugin_t *this_gen) {
+ /* TODO */
+ return 0;
+}
+
+static int v4l2_input_time(input_plugin_t *this_gen) {
+ /* TODO */
+ return 0;
+}
+
+static off_t v4l2_input_length(input_plugin_t *this_gen) {
+ return -1;
+}
+
+typedef struct {
+ input_class_t input_class;
+} v4l2_input_class_t;
+
+static input_plugin_t *v4l2_class_get_instance(input_class_t *gen_cls, xine_stream_t *stream, const char *mrl) {
+ v4l2_input_plugin_t *this;
+ if (strncasecmp (mrl, "v4l2:/", 6))
+ return NULL;
+ mrl += 5;
+ while (*++mrl == '/') /**/;
+ --mrl; /* point at the last slash */
+ /* TODO: Radio devices */
+ /* FIXME: Don't require devices to be of /dev/videoXXX */
+ if (strncmp(mrl, "/dev/video", 10) != 0)
+ return NULL;
+ lprintf("We can handle %s!\n", mrl);
+
+ this = calloc(1, sizeof(v4l2_input_plugin_t));
+ _x_assert(this);
+ this->mrl = strdup(mrl);
+ this->input_plugin.open = v4l2_input_open;
+ this->input_plugin.get_capabilities = v4l2_input_get_capabilities;
+ this->input_plugin.get_blocksize = v4l2_input_blocksize;
+ this->input_plugin.get_mrl = v4l2_input_get_mrl;
+ this->input_plugin.dispose = v4l2_input_dispose;
+ this->input_plugin.read = v4l2_input_read;
+ this->input_plugin.read_block = v4l2_input_read_block;
+ this->input_plugin.seek = v4l2_input_seek;
+ this->input_plugin.seek_time = v4l2_input_seek_time;
+ this->input_plugin.get_current_pos = v4l2_input_pos;
+ this->input_plugin.get_current_time = v4l2_input_time;
+ this->input_plugin.get_length = v4l2_input_length;
+ this->input_plugin.get_optional_data = v4l2_input_get_optional_data;
+ this->input_plugin.input_class = gen_cls;
+ this->stream = stream;
+
+ this->video = NULL;
+ this->radio = NULL;
+ lprintf("Ready to read!\n");
+
+ return &this->input_plugin;
+}
+
+static const char *v4l2_class_get_description(input_class_t *this_gen) {
+ /* TODO: Translatable with _() */
+ return "v4l2 input plugin";
+}
+
+static const char *v4l2_class_get_identifier(input_class_t *this_gen) {
+ return "v4l2";
+}
+
+static void v4l2_class_dispose(input_class_t *this_gen) {
+ free(this_gen);
+}
+
+static void *v4l2_init_class(xine_t *xine, void *data) {
+ v4l2_input_class_t *this;
+ this = malloc(sizeof(v4l2_input_class_t));
+ this->input_class.get_instance = v4l2_class_get_instance;
+ this->input_class.get_description = v4l2_class_get_description;
+ this->input_class.get_identifier = v4l2_class_get_identifier;
+ this->input_class.get_dir = NULL;
+ this->input_class.get_autoplay_list = NULL;
+ this->input_class.dispose = v4l2_class_dispose;
+ this->input_class.eject_media = NULL;
+ return &this->input_class;
+}
+
+const input_info_t input_info_v4l2 = {
+ 4000
+};
+
+const plugin_info_t xine_plugin_info[] EXPORTED = {
+ /* type, API, "name", version, special_info, init_function */
+ { PLUGIN_INPUT, 17, "v4l2", XINE_VERSION_CODE, &input_info_v4l2, v4l2_init_class },
+ { PLUGIN_NONE, 0, "", 0, NULL, NULL }
+};
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-22 11:38:17 +0000