From 0a7b514f13baddda8641ab365aa2f9c218839c47 Mon Sep 17 00:00:00 2001 From: Luca Abeni Date: Wed, 1 Feb 2006 11:31:33 +0000 Subject: [PATCH] video4linux2 input support patch by Luca Abeni, lucabe72 $$at$$ email $$dot$$ it Originally committed as revision 4916 to svn://svn.ffmpeg.org/ffmpeg/trunk --- configure | 20 ++ ffmpeg.c | 4 + libavformat/Makefile | 4 + libavformat/allformats.c | 3 + libavformat/audio.c | 6 +- libavformat/grab.c | 4 +- libavformat/grab_bktr.c | 4 +- libavformat/v4l2.c | 520 +++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 558 insertions(+), 7 deletions(-) create mode 100644 libavformat/v4l2.c diff --git a/configure b/configure index db058bd..d5f3b2c 100755 --- a/configure +++ b/configure @@ -66,6 +66,7 @@ echo " --disable-altivec disable AltiVec usage" echo " --disable-audio-oss disable OSS audio support [default=no]" echo " --disable-audio-beos disable BeOS audio support [default=no]" echo " --disable-v4l disable video4linux grabbing [default=no]" +echo " --disable-v4l2 disable video4linux2 grabbing [default=no]" echo " --disable-bktr disable bktr video grabbing [default=no]" echo " --disable-dv1394 disable DV1394 grabbing [default=no]" echo " --disable-network disable network support [default=no]" @@ -183,6 +184,7 @@ case "$cpu" in esac gprof="no" v4l="yes" +v4l2="yes" bktr="no" audio_oss="yes" audio_beos="no" @@ -276,6 +278,7 @@ SHFLAGS=-nostart # disable Linux things audio_oss="no" v4l="no" +v4l2="no" dv1394="no" # enable BeOS things audio_beos="yes" @@ -290,6 +293,7 @@ extralibs="-lnet" fi ;; SunOS) v4l="no" +v4l2="no" audio_oss="no" dv1394="no" make="gmake" @@ -300,6 +304,7 @@ extralibs="$extralibs -lsocket -lnsl" ;; NetBSD) v4l="no" +v4l2="no" bktr="yes" audio_oss="yes" dv1394="no" @@ -312,6 +317,7 @@ esac ;; OpenBSD) v4l="no" +v4l2="no" bktr="yes" audio_oss="yes" dv1394="no" @@ -323,6 +329,7 @@ extralibs="$extralibs -lossaudio" ;; FreeBSD) v4l="no" +v4l2="no" bktr="yes" audio_oss="yes" dv1394="no" @@ -332,6 +339,7 @@ LDFLAGS="$LDFLAGS -export-dynamic -pthread" ;; BSD/OS) v4l="no" +v4l2="no" bktr="yes" audio_oss="yes" dv1394="no" @@ -343,6 +351,7 @@ installstrip="" Darwin) cc="cc" v4l="no" +v4l2="no" audio_oss="no" dv1394="no" ffserver="no" @@ -364,6 +373,7 @@ mingw32="yes" ;; CYGWIN*) v4l="no" +v4l2="no" audio_oss="yes" dv1394="no" vhook="no" @@ -377,6 +387,7 @@ LDFLAGS="$LDFLAGS -rdynamic" IRIX*) ranlib="echo ignoring ranlib" v4l="no" +v4l2="no" audio_oss="no" make="gmake" ;; @@ -397,6 +408,7 @@ EXESUF=".exe" extralibs="" pkg_requires="" v4l="no" +v4l2="no" audio_oss="no" dv1394="no" network="no" @@ -486,6 +498,8 @@ for opt do ;; --disable-v4l) v4l="no" ;; + --disable-v4l2) v4l2="no" + ;; --disable-bktr) bktr="no" ;; --disable-audio-oss) audio_oss="no" @@ -900,6 +914,7 @@ EOF exit 1 fi v4l="no" + v4l2="no" bktr="no" audio_oss="no" dv1394="no" @@ -1613,6 +1628,11 @@ if test "$v4l" = "yes" ; then echo "CONFIG_VIDEO4LINUX=yes" >> config.mak fi +if test "$v4l2" = "yes" ; then + echo "#define CONFIG_VIDEO4LINUX2 1" >> $TMPH + echo "CONFIG_VIDEO4LINUX2=yes" >> config.mak +fi + if test "$bktr" = "yes" ; then echo "#define CONFIG_BKTR 1" >> $TMPH echo "CONFIG_BKTR=yes" >> config.mak diff --git a/ffmpeg.c b/ffmpeg.c index f3f2817..6d22e43 100644 --- a/ffmpeg.c +++ b/ffmpeg.c @@ -213,8 +213,12 @@ static int rate_emu = 0; #ifdef CONFIG_BKTR static char *video_grab_format = "bktr"; #else +#ifdef CONFIG_VIDEO4LINUX2 +static char *video_grab_format = "video4linux2"; +#else static char *video_grab_format = "video4linux"; #endif +#endif static char *video_device = NULL; static char *grab_device = NULL; static int video_channel = 0; diff --git a/libavformat/Makefile b/libavformat/Makefile index 55abd2b..f4d36ae 100644 --- a/libavformat/Makefile +++ b/libavformat/Makefile @@ -50,6 +50,10 @@ ifeq ($(CONFIG_VIDEO4LINUX),yes) OBJS+= grab.o endif +ifeq ($(CONFIG_VIDEO4LINUX2),yes) +OBJS+= v4l2.o +endif + ifeq ($(CONFIG_BKTR),yes) OBJS+= grab_bktr.o endif diff --git a/libavformat/allformats.c b/libavformat/allformats.c index ce2d691..00d85d5 100644 --- a/libavformat/allformats.c +++ b/libavformat/allformats.c @@ -89,6 +89,9 @@ void av_register_all(void) #endif ffm_init(); +#if defined(CONFIG_VIDEO4LINUX2) + v4l2_init(); +#endif #if defined(CONFIG_VIDEO4LINUX) || defined(CONFIG_BKTR) video_grab_init(); #endif diff --git a/libavformat/audio.c b/libavformat/audio.c index 7537f9c..a9e9c7f 100644 --- a/libavformat/audio.c +++ b/libavformat/audio.c @@ -239,7 +239,7 @@ static int audio_read_header(AVFormatContext *s1, AVFormatParameters *ap) st->codec->sample_rate = s->sample_rate; st->codec->channels = s->channels; - av_set_pts_info(st, 48, 1, 1000000); /* 48 bits pts in us */ + av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ return 0; } @@ -271,7 +271,7 @@ static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt) if (ret == -1 && (errno == EAGAIN || errno == EINTR)) { av_free_packet(pkt); pkt->size = 0; - pkt->pts = av_gettime() & ((1LL << 48) - 1); + pkt->pts = av_gettime(); return 0; } if (!(ret == 0 || (ret == -1 && (errno == EAGAIN || errno == EINTR)))) { @@ -291,7 +291,7 @@ static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt) cur_time -= (bdelay * 1000000LL) / (s->sample_rate * s->channels); /* convert to wanted units */ - pkt->pts = cur_time & ((1LL << 48) - 1); + pkt->pts = cur_time; if (s->flip_left && s->channels == 2) { int i; diff --git a/libavformat/grab.c b/libavformat/grab.c index 218695d..15d8dbb 100644 --- a/libavformat/grab.c +++ b/libavformat/grab.c @@ -82,7 +82,7 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap) st = av_new_stream(s1, 0); if (!st) return -ENOMEM; - av_set_pts_info(st, 48, 1, 1000000); /* 48 bits pts in us */ + av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ s->width = width; s->height = height; @@ -331,7 +331,7 @@ static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt) if (av_new_packet(pkt, s->frame_size) < 0) return AVERROR_IO; - pkt->pts = curtime & ((1LL << 48) - 1); + pkt->pts = curtime; /* read one frame */ if (s->aiw_enabled) { diff --git a/libavformat/grab_bktr.c b/libavformat/grab_bktr.c index 8c02db4..3c63256 100644 --- a/libavformat/grab_bktr.c +++ b/libavformat/grab_bktr.c @@ -229,7 +229,7 @@ static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt) bktr_getframe(s->per_frame); - pkt->pts = av_gettime() & ((1LL << 48) - 1); + pkt->pts = av_gettime(); memcpy(pkt->data, video_buf, video_buf_size); return video_buf_size; @@ -260,7 +260,7 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap) st = av_new_stream(s1, 0); if (!st) return -ENOMEM; - av_set_pts_info(st, 48, 1, 1000000); /* 48 bits pts in use */ + av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in use */ s->width = width; s->height = height; diff --git a/libavformat/v4l2.c b/libavformat/v4l2.c new file mode 100644 index 0000000..78a0cac --- /dev/null +++ b/libavformat/v4l2.c @@ -0,0 +1,520 @@ +/* + * Video4Linux2 grab interface + * Copyright (c) 2000,2001 Fabrice Bellard. + * Copyright (c) 2006 Luca Abeni. + * + * Part of this file is based on the V4L2 video capture example + * (http://v4l2spec.bytesex.org/v4l2spec/capture.c) + * + * Thanks to Michael Niedermayer for providing the mapping between + * V4L2_PIX_FMT_* and PIX_FMT_* + * + * + * This library 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 of the License, or (at your option) any later version. + * + * This library 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 library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include "avformat.h" +#include +#include +#include +#include +#include +#define _LINUX_TIME_H 1 +#include +#include + +static const int desired_video_buffers = 256; + +enum io_method { + io_read, + io_mmap, + io_userptr +}; + +struct video_data { + int fd; + int frame_format; /* V4L2_PIX_FMT_* */ + enum io_method io_method; + int width, height; + int frame_rate; + int frame_rate_base; + int frame_size; + int top_field_first; + + int buffers; + void **buf_start; + unsigned int *buf_len; +}; + +struct fmt_map { + enum PixelFormat ff_fmt; + int32_t v4l2_fmt; +}; + +static struct fmt_map fmt_conversion_table[] = { + { + .ff_fmt = PIX_FMT_YUV420P, + .v4l2_fmt = V4L2_PIX_FMT_YUV420, + }, + { + .ff_fmt = PIX_FMT_YUV422P, + .v4l2_fmt = V4L2_PIX_FMT_YUV422P, + }, + { + .ff_fmt = PIX_FMT_YUV422, + .v4l2_fmt = V4L2_PIX_FMT_YUYV, + }, + { + .ff_fmt = PIX_FMT_UYVY422, + .v4l2_fmt = V4L2_PIX_FMT_UYVY, + }, + { + .ff_fmt = PIX_FMT_YUV411P, + .v4l2_fmt = V4L2_PIX_FMT_YUV411P, + }, + { + .ff_fmt = PIX_FMT_YUV410P, + .v4l2_fmt = V4L2_PIX_FMT_YUV410, + }, + { + .ff_fmt = PIX_FMT_BGR24, + .v4l2_fmt = V4L2_PIX_FMT_BGR24, + }, + { + .ff_fmt = PIX_FMT_RGB24, + .v4l2_fmt = V4L2_PIX_FMT_RGB24, + }, + /* + { + .ff_fmt = PIX_FMT_RGBA32, + .v4l2_fmt = V4L2_PIX_FMT_BGR32, + }, + */ + { + .ff_fmt = PIX_FMT_GRAY8, + .v4l2_fmt = V4L2_PIX_FMT_GREY, + }, +}; + +static int device_open(const char *devname, uint32_t *capabilities) +{ + struct v4l2_capability cap; + int fd; + int res; + + fd = open(devname, O_RDWR /*| O_NONBLOCK*/, 0); + if (fd < 0) { + av_log(NULL, AV_LOG_ERROR, "Cannot open video device %s : %s\n", + devname, strerror(errno)); + + return -1; + } + + res = ioctl(fd, VIDIOC_QUERYCAP, &cap); + if (res < 0) { + av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n", + strerror(errno)); + + return -1; + } + if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) { + av_log(NULL, AV_LOG_ERROR, "Not a video capture device\n"); + + return -1; + } + *capabilities = cap.capabilities; + + return fd; +} + +static int device_init(int fd, int width, int height, int pix_fmt) +{ + struct v4l2_format fmt; + + memset(&fmt, 0, sizeof(struct v4l2_format)); + fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + fmt.fmt.pix.width = width; + fmt.fmt.pix.height = height; + fmt.fmt.pix.pixelformat = pix_fmt; + fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; + return ioctl (fd, VIDIOC_S_FMT, &fmt); +} + +static int first_field(int fd) +{ + int res; + v4l2_std_id std; + + res = ioctl(fd, VIDIOC_G_STD, &std); + if (res < 0) { + return 0; + } + if (std & V4L2_STD_NTSC) { + return 0; + } + + return 1; +} + +static uint32_t fmt_ff2v4l(enum PixelFormat pix_fmt) +{ + int i; + + for (i = 0; i < sizeof(fmt_conversion_table) / sizeof(struct fmt_map); i++) { + if (fmt_conversion_table[i].ff_fmt == pix_fmt) { + return fmt_conversion_table[i].v4l2_fmt; + } + } + + return 0; +} + +static enum PixelFormat fmt_v4l2ff(uint32_t pix_fmt) +{ + int i; + + for (i = 0; i < sizeof(fmt_conversion_table) / sizeof(struct fmt_map); i++) { + if (fmt_conversion_table[i].v4l2_fmt == pix_fmt) { + return fmt_conversion_table[i].ff_fmt; + } + } + + return -1; +} + +static int mmap_init(struct video_data *s) +{ + struct v4l2_requestbuffers req; + int i, res; + + memset(&req, 0, sizeof(struct v4l2_requestbuffers)); + req.count = desired_video_buffers; + req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + req.memory = V4L2_MEMORY_MMAP; + res = ioctl (s->fd, VIDIOC_REQBUFS, &req); + if (res < 0) { + if (errno == EINVAL) { + av_log(NULL, AV_LOG_ERROR, "Device does not support mmap\n"); + } else { + av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS)\n"); + } + + return -1; + } + + if (req.count < 2) { + av_log(NULL, AV_LOG_ERROR, "Insufficient buffer memory\n"); + + return -1; + } + s->buffers = req.count; + s->buf_start = av_malloc(sizeof(void *) * s->buffers); + if (s->buf_start == NULL) { + av_log(NULL, AV_LOG_ERROR, "Cannot allocate buffer pointers\n"); + + return -1; + } + s->buf_len = av_malloc(sizeof(unsigned int) * s->buffers); + if (s->buf_len == NULL) { + av_log(NULL, AV_LOG_ERROR, "Cannot allocate buffer sizes\n"); + av_free(s->buf_start); + + return -1; + } + + for (i = 0; i < req.count; i++) { + struct v4l2_buffer buf; + + memset(&buf, 0, sizeof(struct v4l2_buffer)); + buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + buf.memory = V4L2_MEMORY_MMAP; + buf.index = i; + res = ioctl (s->fd, VIDIOC_QUERYBUF, &buf); + if (res < 0) { + av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF)\n"); + + return -1; + } + + s->buf_len[i] = buf.length; + if (s->buf_len[i] < s->frame_size) { + av_log(NULL, AV_LOG_ERROR, "Buffer len [%d] = %d != %d\n", i, s->buf_len[i], s->frame_size); + + return -1; + } + s->buf_start[i] = mmap (NULL, buf.length, + PROT_READ | PROT_WRITE, MAP_SHARED, s->fd, buf.m.offset); + if (s->buf_start[i] == MAP_FAILED) { + av_log(NULL, AV_LOG_ERROR, "mmap: %s\n", strerror(errno)); + + return -1; + } + } + + return 0; +} + +static int read_init(struct video_data *s) +{ + return -1; +} + +static int mmap_read_frame(struct video_data *s, void *frame, int64_t *ts) +{ + struct v4l2_buffer buf; + int res; + + memset(&buf, 0, sizeof(struct v4l2_buffer)); + buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + buf.memory = V4L2_MEMORY_MMAP; + + /* FIXME: Some special treatment might be needed in case of loss of signal... */ + while ((res = ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && + ((errno == EAGAIN) || (errno == EINTR))); + if (res < 0) { + av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n", strerror(errno)); + + return -1; + } + assert (buf.index < s->buffers); + assert(buf.bytesused == s->frame_size); + /* Image is at s->buff_start[buf.index] */ + memcpy(frame, s->buf_start[buf.index], buf.bytesused); + *ts = buf.timestamp.tv_sec * int64_t_C(1000000) + buf.timestamp.tv_usec; + + res = ioctl (s->fd, VIDIOC_QBUF, &buf); + if (res < 0) { + av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF)\n"); + + return -1; + } + + return s->buf_len[buf.index]; +} + +static int read_frame(struct video_data *s, void *frame, int64_t *ts) +{ + return -1; +} + +static int mmap_start(struct video_data *s) +{ + enum v4l2_buf_type type; + int i, res; + + for (i = 0; i < s->buffers; i++) { + struct v4l2_buffer buf; + + memset(&buf, 0, sizeof(struct v4l2_buffer)); + buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + buf.memory = V4L2_MEMORY_MMAP; + buf.index = i; + + res = ioctl (s->fd, VIDIOC_QBUF, &buf); + if (res < 0) { + av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", strerror(errno)); + + return -1; + } + } + + type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + res = ioctl (s->fd, VIDIOC_STREAMON, &type); + if (res < 0) { + av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n", strerror(errno)); + + return -1; + } + + return 0; +} + +static void mmap_close(struct video_data *s) +{ + enum v4l2_buf_type type; + int i; + + type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + /* We do not check for the result, because we could + * not do anything about it anyway... + */ + ioctl(s->fd, VIDIOC_STREAMOFF, &type); + for (i = 0; i < s->buffers; i++) { + munmap(s->buf_start[i], s->buf_len[i]); + } + av_free(s->buf_start); + av_free(s->buf_len); +} + +static int v4l2_read_header(AVFormatContext *s1, AVFormatParameters *ap) +{ + struct video_data *s = s1->priv_data; + AVStream *st; + int width, height; + int res, frame_rate, frame_rate_base; + uint32_t desired_format, capabilities; + const char *video_device; + + if (!ap || ap->width <= 0 || ap->height <= 0 || ap->time_base.den <= 0) { + av_log(s1, AV_LOG_ERROR, "Missing/Wrong parameters\n"); + + return -1; + } + + width = ap->width; + height = ap->height; + frame_rate = ap->time_base.den; + frame_rate_base = ap->time_base.num; + + if((unsigned)width > 32767 || (unsigned)height > 32767) { + av_log(s1, AV_LOG_ERROR, "Wrong size %dx%d\n", width, height); + + return -1; + } + + st = av_new_stream(s1, 0); + if (!st) { + return -ENOMEM; + } + av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ + + s->width = width; + s->height = height; + s->frame_rate = frame_rate; + s->frame_rate_base = frame_rate_base; + + video_device = ap->device; + if (!video_device) { + video_device = "/dev/video"; + } + capabilities = 0; + s->fd = device_open(video_device, &capabilities); + if (s->fd < 0) { + av_free(st); + + return AVERROR_IO; + } + av_log(s1, AV_LOG_ERROR, "[%d]Capabilities: %x\n", s->fd, capabilities); + + desired_format = fmt_ff2v4l(ap->pix_fmt); + if (desired_format == 0 || (device_init(s->fd, width, height, desired_format) < 0)) { + int i, done; + + done = 0; i = 0; + while (!done) { + desired_format = fmt_conversion_table[i].v4l2_fmt; + if (device_init(s->fd, width, height, desired_format) < 0) { + desired_format = 0; + i++; + } else { + done = 1; + } + if (i == sizeof(fmt_conversion_table) / sizeof(struct fmt_map)) { + done = 1; + } + } + } + if (desired_format == 0) { + av_log(s1, AV_LOG_ERROR, "Cannot find a proper format.\n"); + close(s->fd); + av_free(st); + + return AVERROR_IO; + } + s->frame_format = desired_format; + + st->codec->pix_fmt = fmt_v4l2ff(desired_format); + s->frame_size = avpicture_get_size(st->codec->pix_fmt, width, height); + if (capabilities & V4L2_CAP_STREAMING) { + s->io_method = io_mmap; + res = mmap_init(s); + res = mmap_start(s); + } else { + s->io_method = io_read; + res = read_init(s); + } + if (res < 0) { + close(s->fd); + av_free(st); + + return AVERROR_IO; + } + s->top_field_first = first_field(s->fd); + + st->codec->codec_type = CODEC_TYPE_VIDEO; + st->codec->codec_id = CODEC_ID_RAWVIDEO; + st->codec->width = width; + st->codec->height = height; + st->codec->time_base.den = frame_rate; + st->codec->time_base.num = frame_rate_base; + st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8; + + return 0; +} + +static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt) +{ + struct video_data *s = s1->priv_data; + int res; + + if (av_new_packet(pkt, s->frame_size) < 0) + return AVERROR_IO; + + if (s->io_method == io_mmap) { + res = mmap_read_frame(s, pkt->data, &pkt->pts); + } else if (s->io_method == io_read) { + res = read_frame(s, pkt->data, &pkt->pts); + } else { + return AVERROR_IO; + } + if (res < 0) { + return AVERROR_IO; + } + + if (s1->streams[0]->codec->coded_frame) { + s1->streams[0]->codec->coded_frame->interlaced_frame = 1; + s1->streams[0]->codec->coded_frame->top_field_first = s->top_field_first; + } + + return s->frame_size; +} + +static int v4l2_read_close(AVFormatContext *s1) +{ + struct video_data *s = s1->priv_data; + + if (s->io_method == io_mmap) { + mmap_close(s); + } + + close(s->fd); + return 0; +} + +static AVInputFormat v4l2_format = { + "video4linux2", + "video grab", + sizeof(struct video_data), + NULL, + v4l2_read_header, + v4l2_read_packet, + v4l2_read_close, + .flags = AVFMT_NOFILE, +}; + +int v4l2_init(void) +{ + av_register_input_format(&v4l2_format); + return 0; +} -- 2.7.4