From 22e28216336da876e1fd17f380ce42eaf1446769 Mon Sep 17 00:00:00 2001 From: Tim Redfern Date: Mon, 17 Feb 2014 13:36:38 +0000 Subject: chasing indexing error --- ffmpeg/libavdevice/v4l2.c | 1031 --------------------------------------------- 1 file changed, 1031 deletions(-) delete mode 100644 ffmpeg/libavdevice/v4l2.c (limited to 'ffmpeg/libavdevice/v4l2.c') diff --git a/ffmpeg/libavdevice/v4l2.c b/ffmpeg/libavdevice/v4l2.c deleted file mode 100644 index cb962b7..0000000 --- a/ffmpeg/libavdevice/v4l2.c +++ /dev/null @@ -1,1031 +0,0 @@ -/* - * Copyright (c) 2000,2001 Fabrice Bellard - * Copyright (c) 2006 Luca Abeni - * - * This file is part of FFmpeg. - * - * FFmpeg 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. - * - * FFmpeg 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 FFmpeg; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - */ - -/** - * @file - * Video4Linux2 grab interface - * - * Part of this file is based on the V4L2 video capture example - * (http://linuxtv.org/downloads/v4l-dvb-apis/capture-example.html) - * - * Thanks to Michael Niedermayer for providing the mapping between - * V4L2_PIX_FMT_* and AV_PIX_FMT_* - */ - -#include "v4l2-common.h" - -#if CONFIG_LIBV4L2 -#include -#endif - -static const int desired_video_buffers = 256; - -#define V4L_ALLFORMATS 3 -#define V4L_RAWFORMATS 1 -#define V4L_COMPFORMATS 2 - -/** - * Return timestamps to the user exactly as returned by the kernel - */ -#define V4L_TS_DEFAULT 0 -/** - * Autodetect the kind of timestamps returned by the kernel and convert to - * absolute (wall clock) timestamps. - */ -#define V4L_TS_ABS 1 -/** - * Assume kernel timestamps are from the monotonic clock and convert to - * absolute timestamps. - */ -#define V4L_TS_MONO2ABS 2 - -/** - * Once the kind of timestamps returned by the kernel have been detected, - * the value of the timefilter (NULL or not) determines whether a conversion - * takes place. - */ -#define V4L_TS_CONVERT_READY V4L_TS_DEFAULT - -struct video_data { - AVClass *class; - int fd; - int frame_format; /* V4L2_PIX_FMT_* */ - int width, height; - int frame_size; - int interlaced; - int top_field_first; - int ts_mode; - TimeFilter *timefilter; - int64_t last_time_m; - - int buffers; - volatile int buffers_queued; - void **buf_start; - unsigned int *buf_len; - char *standard; - v4l2_std_id std_id; - int channel; - char *pixel_format; /**< Set by a private option. */ - int list_format; /**< Set by a private option. */ - int list_standard; /**< Set by a private option. */ - char *framerate; /**< Set by a private option. */ - - int use_libv4l2; - int (*open_f)(const char *file, int oflag, ...); - int (*close_f)(int fd); - int (*dup_f)(int fd); - int (*ioctl_f)(int fd, unsigned long int request, ...); - ssize_t (*read_f)(int fd, void *buffer, size_t n); - void *(*mmap_f)(void *start, size_t length, int prot, int flags, int fd, int64_t offset); - int (*munmap_f)(void *_start, size_t length); -}; - -struct buff_data { - struct video_data *s; - int index; -}; - -static int device_open(AVFormatContext *ctx) -{ - struct video_data *s = ctx->priv_data; - struct v4l2_capability cap; - int fd; - int ret; - int flags = O_RDWR; - -#define SET_WRAPPERS(prefix) do { \ - s->open_f = prefix ## open; \ - s->close_f = prefix ## close; \ - s->dup_f = prefix ## dup; \ - s->ioctl_f = prefix ## ioctl; \ - s->read_f = prefix ## read; \ - s->mmap_f = prefix ## mmap; \ - s->munmap_f = prefix ## munmap; \ -} while (0) - - if (s->use_libv4l2) { -#if CONFIG_LIBV4L2 - SET_WRAPPERS(v4l2_); -#else - av_log(ctx, AV_LOG_ERROR, "libavdevice is not build with libv4l2 support.\n"); - return AVERROR(EINVAL); -#endif - } else { - SET_WRAPPERS(); - } - -#define v4l2_open s->open_f -#define v4l2_close s->close_f -#define v4l2_dup s->dup_f -#define v4l2_ioctl s->ioctl_f -#define v4l2_read s->read_f -#define v4l2_mmap s->mmap_f -#define v4l2_munmap s->munmap_f - - if (ctx->flags & AVFMT_FLAG_NONBLOCK) { - flags |= O_NONBLOCK; - } - - fd = v4l2_open(ctx->filename, flags, 0); - if (fd < 0) { - ret = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s: %s\n", - ctx->filename, av_err2str(ret)); - return ret; - } - - if (v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) { - ret = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n", - av_err2str(ret)); - goto fail; - } - - av_log(ctx, AV_LOG_VERBOSE, "fd:%d capabilities:%x\n", - fd, cap.capabilities); - - if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { - av_log(ctx, AV_LOG_ERROR, "Not a video capture device.\n"); - ret = AVERROR(ENODEV); - goto fail; - } - - if (!(cap.capabilities & V4L2_CAP_STREAMING)) { - av_log(ctx, AV_LOG_ERROR, - "The device does not support the streaming I/O method.\n"); - ret = AVERROR(ENOSYS); - goto fail; - } - - return fd; - -fail: - v4l2_close(fd); - return ret; -} - -static int device_init(AVFormatContext *ctx, int *width, int *height, - uint32_t pix_fmt) -{ - struct video_data *s = ctx->priv_data; - int fd = s->fd; - struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE }; - struct v4l2_pix_format *pix = &fmt.fmt.pix; - - int res = 0; - - pix->width = *width; - pix->height = *height; - pix->pixelformat = pix_fmt; - pix->field = V4L2_FIELD_ANY; - - if (v4l2_ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) - res = AVERROR(errno); - - if ((*width != fmt.fmt.pix.width) || (*height != fmt.fmt.pix.height)) { - av_log(ctx, AV_LOG_INFO, - "The V4L2 driver changed the video from %dx%d to %dx%d\n", - *width, *height, fmt.fmt.pix.width, fmt.fmt.pix.height); - *width = fmt.fmt.pix.width; - *height = fmt.fmt.pix.height; - } - - if (pix_fmt != fmt.fmt.pix.pixelformat) { - av_log(ctx, AV_LOG_DEBUG, - "The V4L2 driver changed the pixel format " - "from 0x%08X to 0x%08X\n", - pix_fmt, fmt.fmt.pix.pixelformat); - res = AVERROR(EINVAL); - } - - if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED) { - av_log(ctx, AV_LOG_DEBUG, - "The V4L2 driver is using the interlaced mode\n"); - s->interlaced = 1; - } - - return res; -} - -static int first_field(const struct video_data *s, int fd) -{ - int res; - v4l2_std_id std; - - res = v4l2_ioctl(fd, VIDIOC_G_STD, &std); - if (res < 0) { - return 0; - } - if (std & V4L2_STD_NTSC) { - return 0; - } - - return 1; -} - -#if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE -static void list_framesizes(AVFormatContext *ctx, int fd, uint32_t pixelformat) -{ - const struct video_data *s = ctx->priv_data; - struct v4l2_frmsizeenum vfse = { .pixel_format = pixelformat }; - - while(!v4l2_ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &vfse)) { - switch (vfse.type) { - case V4L2_FRMSIZE_TYPE_DISCRETE: - av_log(ctx, AV_LOG_INFO, " %ux%u", - vfse.discrete.width, vfse.discrete.height); - break; - case V4L2_FRMSIZE_TYPE_CONTINUOUS: - case V4L2_FRMSIZE_TYPE_STEPWISE: - av_log(ctx, AV_LOG_INFO, " {%u-%u, %u}x{%u-%u, %u}", - vfse.stepwise.min_width, - vfse.stepwise.max_width, - vfse.stepwise.step_width, - vfse.stepwise.min_height, - vfse.stepwise.max_height, - vfse.stepwise.step_height); - } - vfse.index++; - } -} -#endif - -static void list_formats(AVFormatContext *ctx, int fd, int type) -{ - const struct video_data *s = ctx->priv_data; - struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE }; - - while(!v4l2_ioctl(fd, VIDIOC_ENUM_FMT, &vfd)) { - enum AVCodecID codec_id = avpriv_fmt_v4l2codec(vfd.pixelformat); - enum AVPixelFormat pix_fmt = avpriv_fmt_v4l2ff(vfd.pixelformat, codec_id); - - vfd.index++; - - if (!(vfd.flags & V4L2_FMT_FLAG_COMPRESSED) && - type & V4L_RAWFORMATS) { - const char *fmt_name = av_get_pix_fmt_name(pix_fmt); - av_log(ctx, AV_LOG_INFO, "Raw : %9s : %20s :", - fmt_name ? fmt_name : "Unsupported", - vfd.description); - } else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED && - type & V4L_COMPFORMATS) { - AVCodec *codec = avcodec_find_decoder(codec_id); - av_log(ctx, AV_LOG_INFO, "Compressed: %9s : %20s :", - codec ? codec->name : "Unsupported", - vfd.description); - } else { - continue; - } - -#ifdef V4L2_FMT_FLAG_EMULATED - if (vfd.flags & V4L2_FMT_FLAG_EMULATED) - av_log(ctx, AV_LOG_INFO, " Emulated :"); -#endif -#if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE - list_framesizes(ctx, fd, vfd.pixelformat); -#endif - av_log(ctx, AV_LOG_INFO, "\n"); - } -} - -static void list_standards(AVFormatContext *ctx) -{ - int ret; - struct video_data *s = ctx->priv_data; - struct v4l2_standard standard; - - if (s->std_id == 0) - return; - - for (standard.index = 0; ; standard.index++) { - if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) { - ret = AVERROR(errno); - if (ret == AVERROR(EINVAL)) { - break; - } else { - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret)); - return; - } - } - av_log(ctx, AV_LOG_INFO, "%2d, %16"PRIx64", %s\n", - standard.index, (uint64_t)standard.id, standard.name); - } -} - -static int mmap_init(AVFormatContext *ctx) -{ - int i, res; - struct video_data *s = ctx->priv_data; - struct v4l2_requestbuffers req = { - .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, - .count = desired_video_buffers, - .memory = V4L2_MEMORY_MMAP - }; - - if (v4l2_ioctl(s->fd, VIDIOC_REQBUFS, &req) < 0) { - res = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS): %s\n", av_err2str(res)); - return res; - } - - if (req.count < 2) { - av_log(ctx, AV_LOG_ERROR, "Insufficient buffer memory\n"); - return AVERROR(ENOMEM); - } - s->buffers = req.count; - s->buf_start = av_malloc(sizeof(void *) * s->buffers); - if (s->buf_start == NULL) { - av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer pointers\n"); - return AVERROR(ENOMEM); - } - s->buf_len = av_malloc(sizeof(unsigned int) * s->buffers); - if (s->buf_len == NULL) { - av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer sizes\n"); - av_free(s->buf_start); - return AVERROR(ENOMEM); - } - - for (i = 0; i < req.count; i++) { - struct v4l2_buffer buf = { - .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, - .index = i, - .memory = V4L2_MEMORY_MMAP - }; - if (v4l2_ioctl(s->fd, VIDIOC_QUERYBUF, &buf) < 0) { - res = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF): %s\n", av_err2str(res)); - return res; - } - - s->buf_len[i] = buf.length; - if (s->frame_size > 0 && s->buf_len[i] < s->frame_size) { - av_log(ctx, AV_LOG_ERROR, - "buf_len[%d] = %d < expected frame size %d\n", - i, s->buf_len[i], s->frame_size); - return AVERROR(ENOMEM); - } - s->buf_start[i] = v4l2_mmap(NULL, buf.length, - PROT_READ | PROT_WRITE, MAP_SHARED, - s->fd, buf.m.offset); - - if (s->buf_start[i] == MAP_FAILED) { - res = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", av_err2str(res)); - return res; - } - } - - return 0; -} - -#if FF_API_DESTRUCT_PACKET -static void dummy_release_buffer(AVPacket *pkt) -{ - av_assert0(0); -} -#endif - -static void mmap_release_buffer(void *opaque, uint8_t *data) -{ - struct v4l2_buffer buf = { 0 }; - int res; - struct buff_data *buf_descriptor = opaque; - struct video_data *s = buf_descriptor->s; - - buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - buf.memory = V4L2_MEMORY_MMAP; - buf.index = buf_descriptor->index; - av_free(buf_descriptor); - - if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) < 0) { - res = AVERROR(errno); - av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", - av_err2str(res)); - } - - avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1); -} - -#if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC) -static int64_t av_gettime_monotonic(void) -{ - struct timespec tv; - - clock_gettime(CLOCK_MONOTONIC, &tv); - return (int64_t)tv.tv_sec * 1000000 + tv.tv_nsec / 1000; -} -#endif - -static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts) -{ - struct video_data *s = ctx->priv_data; - int64_t now; - - now = av_gettime(); - if (s->ts_mode == V4L_TS_ABS && - ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE) { - av_log(ctx, AV_LOG_INFO, "Detected absolute timestamps\n"); - s->ts_mode = V4L_TS_CONVERT_READY; - return 0; - } -#if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC) - now = av_gettime_monotonic(); - if (s->ts_mode == V4L_TS_MONO2ABS || - (ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE)) { - AVRational tb = {AV_TIME_BASE, 1}; - int64_t period = av_rescale_q(1, tb, ctx->streams[0]->avg_frame_rate); - av_log(ctx, AV_LOG_INFO, "Detected monotonic timestamps, converting\n"); - /* microseconds instead of seconds, MHz instead of Hz */ - s->timefilter = ff_timefilter_new(1, period, 1.0E-6); - if (!s->timefilter) - return AVERROR(ENOMEM); - s->ts_mode = V4L_TS_CONVERT_READY; - return 0; - } -#endif - av_log(ctx, AV_LOG_ERROR, "Unknown timestamps\n"); - return AVERROR(EIO); -} - -static int convert_timestamp(AVFormatContext *ctx, int64_t *ts) -{ - struct video_data *s = ctx->priv_data; - - if (s->ts_mode) { - int r = init_convert_timestamp(ctx, *ts); - if (r < 0) - return r; - } -#if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC) - if (s->timefilter) { - int64_t nowa = av_gettime(); - int64_t nowm = av_gettime_monotonic(); - ff_timefilter_update(s->timefilter, nowa, nowm - s->last_time_m); - s->last_time_m = nowm; - *ts = ff_timefilter_eval(s->timefilter, *ts - nowm); - } -#endif - return 0; -} - -static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt) -{ - struct video_data *s = ctx->priv_data; - struct v4l2_buffer buf = { - .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, - .memory = V4L2_MEMORY_MMAP - }; - int res; - - /* FIXME: Some special treatment might be needed in case of loss of signal... */ - while ((res = v4l2_ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR)); - if (res < 0) { - if (errno == EAGAIN) { - pkt->size = 0; - return AVERROR(EAGAIN); - } - res = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n", av_err2str(res)); - return res; - } - - if (buf.index >= s->buffers) { - av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n"); - return AVERROR(EINVAL); - } - avpriv_atomic_int_add_and_fetch(&s->buffers_queued, -1); - // always keep at least one buffer queued - av_assert0(avpriv_atomic_int_get(&s->buffers_queued) >= 1); - - /* CPIA is a compressed format and we don't know the exact number of bytes - * used by a frame, so set it here as the driver announces it. - */ - if (ctx->video_codec_id == AV_CODEC_ID_CPIA) - s->frame_size = buf.bytesused; - - if (s->frame_size > 0 && buf.bytesused != s->frame_size) { - av_log(ctx, AV_LOG_ERROR, - "The v4l2 frame is %d bytes, but %d bytes are expected\n", - buf.bytesused, s->frame_size); - return AVERROR_INVALIDDATA; - } - - /* Image is at s->buff_start[buf.index] */ - if (avpriv_atomic_int_get(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) { - /* when we start getting low on queued buffers, fall back on copying data */ - res = av_new_packet(pkt, buf.bytesused); - if (res < 0) { - av_log(ctx, AV_LOG_ERROR, "Error allocating a packet.\n"); - if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) == 0) - avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1); - return res; - } - memcpy(pkt->data, s->buf_start[buf.index], buf.bytesused); - - if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) < 0) { - res = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", av_err2str(res)); - av_free_packet(pkt); - return res; - } - avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1); - } else { - struct buff_data *buf_descriptor; - - pkt->data = s->buf_start[buf.index]; - pkt->size = buf.bytesused; -#if FF_API_DESTRUCT_PACKET -FF_DISABLE_DEPRECATION_WARNINGS - pkt->destruct = dummy_release_buffer; -FF_ENABLE_DEPRECATION_WARNINGS -#endif - - buf_descriptor = av_malloc(sizeof(struct buff_data)); - if (buf_descriptor == NULL) { - /* Something went wrong... Since av_malloc() failed, we cannot even - * allocate a buffer for memcpying into it - */ - av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n"); - if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) == 0) - avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1); - - return AVERROR(ENOMEM); - } - buf_descriptor->index = buf.index; - buf_descriptor->s = s; - - pkt->buf = av_buffer_create(pkt->data, pkt->size, mmap_release_buffer, - buf_descriptor, 0); - if (!pkt->buf) { - av_log(ctx, AV_LOG_ERROR, "Failed to create a buffer\n"); - if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) == 0) - avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1); - av_freep(&buf_descriptor); - return AVERROR(ENOMEM); - } - } - pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec; - convert_timestamp(ctx, &pkt->pts); - - return s->buf_len[buf.index]; -} - -static int mmap_start(AVFormatContext *ctx) -{ - struct video_data *s = ctx->priv_data; - enum v4l2_buf_type type; - int i, res; - - for (i = 0; i < s->buffers; i++) { - struct v4l2_buffer buf = { - .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, - .index = i, - .memory = V4L2_MEMORY_MMAP - }; - - if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) < 0) { - res = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", av_err2str(res)); - return res; - } - } - s->buffers_queued = s->buffers; - - type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (v4l2_ioctl(s->fd, VIDIOC_STREAMON, &type) < 0) { - res = AVERROR(errno); - av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n", av_err2str(res)); - return res; - } - - 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... - */ - v4l2_ioctl(s->fd, VIDIOC_STREAMOFF, &type); - for (i = 0; i < s->buffers; i++) { - v4l2_munmap(s->buf_start[i], s->buf_len[i]); - } - av_free(s->buf_start); - av_free(s->buf_len); -} - -static int v4l2_set_parameters(AVFormatContext *s1) -{ - struct video_data *s = s1->priv_data; - struct v4l2_standard standard = { 0 }; - struct v4l2_streamparm streamparm = { 0 }; - struct v4l2_fract *tpf; - AVRational framerate_q = { 0 }; - int i, ret; - - if (s->framerate && - (ret = av_parse_video_rate(&framerate_q, s->framerate)) < 0) { - av_log(s1, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", - s->framerate); - return ret; - } - - if (s->standard) { - if (s->std_id) { - ret = 0; - av_log(s1, AV_LOG_DEBUG, "Setting standard: %s\n", s->standard); - /* set tv standard */ - for (i = 0; ; i++) { - standard.index = i; - if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) { - ret = AVERROR(errno); - break; - } - if (!av_strcasecmp(standard.name, s->standard)) - break; - } - if (ret < 0) { - av_log(s1, AV_LOG_ERROR, "Unknown or unsupported standard '%s'\n", s->standard); - return ret; - } - - if (v4l2_ioctl(s->fd, VIDIOC_S_STD, &standard.id) < 0) { - ret = AVERROR(errno); - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_S_STD): %s\n", av_err2str(ret)); - return ret; - } - } else { - av_log(s1, AV_LOG_WARNING, - "This device does not support any standard\n"); - } - } - - /* get standard */ - if (v4l2_ioctl(s->fd, VIDIOC_G_STD, &s->std_id) == 0) { - tpf = &standard.frameperiod; - for (i = 0; ; i++) { - standard.index = i; - if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) { - ret = AVERROR(errno); - if (ret == AVERROR(EINVAL)) { - tpf = &streamparm.parm.capture.timeperframe; - break; - } - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret)); - return ret; - } - if (standard.id == s->std_id) { - av_log(s1, AV_LOG_DEBUG, - "Current standard: %s, id: %"PRIx64", frameperiod: %d/%d\n", - standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator); - break; - } - } - } else { - tpf = &streamparm.parm.capture.timeperframe; - } - - streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (v4l2_ioctl(s->fd, VIDIOC_G_PARM, &streamparm) < 0) { - ret = AVERROR(errno); - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n", av_err2str(ret)); - return ret; - } - - if (framerate_q.num && framerate_q.den) { - if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) { - tpf = &streamparm.parm.capture.timeperframe; - - av_log(s1, AV_LOG_DEBUG, "Setting time per frame to %d/%d\n", - framerate_q.den, framerate_q.num); - tpf->numerator = framerate_q.den; - tpf->denominator = framerate_q.num; - - if (v4l2_ioctl(s->fd, VIDIOC_S_PARM, &streamparm) < 0) { - ret = AVERROR(errno); - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_S_PARM): %s\n", av_err2str(ret)); - return ret; - } - - if (framerate_q.num != tpf->denominator || - framerate_q.den != tpf->numerator) { - av_log(s1, AV_LOG_INFO, - "The driver changed the time per frame from " - "%d/%d to %d/%d\n", - framerate_q.den, framerate_q.num, - tpf->numerator, tpf->denominator); - } - } else { - av_log(s1, AV_LOG_WARNING, - "The driver does not allow to change time per frame\n"); - } - } - s1->streams[0]->avg_frame_rate.num = tpf->denominator; - s1->streams[0]->avg_frame_rate.den = tpf->numerator; - s1->streams[0]->r_frame_rate = s1->streams[0]->avg_frame_rate; - - return 0; -} - -static int device_try_init(AVFormatContext *s1, - enum AVPixelFormat pix_fmt, - int *width, - int *height, - uint32_t *desired_format, - enum AVCodecID *codec_id) -{ - int ret, i; - - *desired_format = avpriv_fmt_ff2v4l(pix_fmt, s1->video_codec_id); - - if (*desired_format) { - ret = device_init(s1, width, height, *desired_format); - if (ret < 0) { - *desired_format = 0; - if (ret != AVERROR(EINVAL)) - return ret; - } - } - - if (!*desired_format) { - for (i = 0; avpriv_fmt_conversion_table[i].codec_id != AV_CODEC_ID_NONE; i++) { - if (s1->video_codec_id == AV_CODEC_ID_NONE || - avpriv_fmt_conversion_table[i].codec_id == s1->video_codec_id) { - av_log(s1, AV_LOG_DEBUG, "Trying to set codec:%s pix_fmt:%s\n", - avcodec_get_name(avpriv_fmt_conversion_table[i].codec_id), - (char *)av_x_if_null(av_get_pix_fmt_name(avpriv_fmt_conversion_table[i].ff_fmt), "none")); - - *desired_format = avpriv_fmt_conversion_table[i].v4l2_fmt; - ret = device_init(s1, width, height, *desired_format); - if (ret >= 0) - break; - else if (ret != AVERROR(EINVAL)) - return ret; - *desired_format = 0; - } - } - - if (*desired_format == 0) { - av_log(s1, AV_LOG_ERROR, "Cannot find a proper format for " - "codec '%s' (id %d), pixel format '%s' (id %d)\n", - avcodec_get_name(s1->video_codec_id), s1->video_codec_id, - (char *)av_x_if_null(av_get_pix_fmt_name(pix_fmt), "none"), pix_fmt); - ret = AVERROR(EINVAL); - } - } - - *codec_id = avpriv_fmt_v4l2codec(*desired_format); - av_assert0(*codec_id != AV_CODEC_ID_NONE); - return ret; -} - -static int v4l2_read_header(AVFormatContext *s1) -{ - struct video_data *s = s1->priv_data; - AVStream *st; - int res = 0; - uint32_t desired_format; - enum AVCodecID codec_id = AV_CODEC_ID_NONE; - enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE; - struct v4l2_input input = { 0 }; - - st = avformat_new_stream(s1, NULL); - if (!st) - return AVERROR(ENOMEM); - -#if CONFIG_LIBV4L2 - /* silence libv4l2 logging. if fopen() fails v4l2_log_file will be NULL - and errors will get sent to stderr */ - if (s->use_libv4l2) - v4l2_log_file = fopen("/dev/null", "w"); -#endif - - s->fd = device_open(s1); - if (s->fd < 0) - return s->fd; - - if (s->channel != -1) { - /* set video input */ - av_log(s1, AV_LOG_DEBUG, "Selecting input_channel: %d\n", s->channel); - if (v4l2_ioctl(s->fd, VIDIOC_S_INPUT, &s->channel) < 0) { - res = AVERROR(errno); - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_S_INPUT): %s\n", av_err2str(res)); - return res; - } - } else { - /* get current video input */ - if (v4l2_ioctl(s->fd, VIDIOC_G_INPUT, &s->channel) < 0) { - res = AVERROR(errno); - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_INPUT): %s\n", av_err2str(res)); - return res; - } - } - - /* enum input */ - input.index = s->channel; - if (v4l2_ioctl(s->fd, VIDIOC_ENUMINPUT, &input) < 0) { - res = AVERROR(errno); - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMINPUT): %s\n", av_err2str(res)); - return res; - } - s->std_id = input.std; - av_log(s1, AV_LOG_DEBUG, "Current input_channel: %d, input_name: %s, input_std: %"PRIx64"\n", - s->channel, input.name, (uint64_t)input.std); - - if (s->list_format) { - list_formats(s1, s->fd, s->list_format); - return AVERROR_EXIT; - } - - if (s->list_standard) { - list_standards(s1); - return AVERROR_EXIT; - } - - avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ - - if (s->pixel_format) { - AVCodec *codec = avcodec_find_decoder_by_name(s->pixel_format); - - if (codec) - s1->video_codec_id = codec->id; - - pix_fmt = av_get_pix_fmt(s->pixel_format); - - if (pix_fmt == AV_PIX_FMT_NONE && !codec) { - av_log(s1, AV_LOG_ERROR, "No such input format: %s.\n", - s->pixel_format); - - return AVERROR(EINVAL); - } - } - - if (!s->width && !s->height) { - struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE }; - - av_log(s1, AV_LOG_VERBOSE, - "Querying the device for the current frame size\n"); - if (v4l2_ioctl(s->fd, VIDIOC_G_FMT, &fmt) < 0) { - res = AVERROR(errno); - av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n", av_err2str(res)); - return res; - } - - s->width = fmt.fmt.pix.width; - s->height = fmt.fmt.pix.height; - av_log(s1, AV_LOG_VERBOSE, - "Setting frame size to %dx%d\n", s->width, s->height); - } - - res = device_try_init(s1, pix_fmt, &s->width, &s->height, &desired_format, &codec_id); - if (res < 0) { - v4l2_close(s->fd); - return res; - } - - /* If no pixel_format was specified, the codec_id was not known up - * until now. Set video_codec_id in the context, as codec_id will - * not be available outside this function - */ - if (codec_id != AV_CODEC_ID_NONE && s1->video_codec_id == AV_CODEC_ID_NONE) - s1->video_codec_id = codec_id; - - if ((res = av_image_check_size(s->width, s->height, 0, s1)) < 0) - return res; - - s->frame_format = desired_format; - - if ((res = v4l2_set_parameters(s1)) < 0) - return res; - - st->codec->pix_fmt = avpriv_fmt_v4l2ff(desired_format, codec_id); - s->frame_size = - avpicture_get_size(st->codec->pix_fmt, s->width, s->height); - - if ((res = mmap_init(s1)) || - (res = mmap_start(s1)) < 0) { - v4l2_close(s->fd); - return res; - } - - s->top_field_first = first_field(s, s->fd); - - st->codec->codec_type = AVMEDIA_TYPE_VIDEO; - st->codec->codec_id = codec_id; - if (codec_id == AV_CODEC_ID_RAWVIDEO) - st->codec->codec_tag = - avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt); - else if (codec_id == AV_CODEC_ID_H264) { - st->need_parsing = AVSTREAM_PARSE_HEADERS; - } - if (desired_format == V4L2_PIX_FMT_YVU420) - st->codec->codec_tag = MKTAG('Y', 'V', '1', '2'); - else if (desired_format == V4L2_PIX_FMT_YVU410) - st->codec->codec_tag = MKTAG('Y', 'V', 'U', '9'); - st->codec->width = s->width; - st->codec->height = s->height; - st->codec->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8; - - return 0; -} - -static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt) -{ - struct video_data *s = s1->priv_data; - AVFrame *frame = s1->streams[0]->codec->coded_frame; - int res; - - av_init_packet(pkt); - if ((res = mmap_read_frame(s1, pkt)) < 0) { - return res; - } - - if (frame && s->interlaced) { - frame->interlaced_frame = 1; - frame->top_field_first = s->top_field_first; - } - - return pkt->size; -} - -static int v4l2_read_close(AVFormatContext *s1) -{ - struct video_data *s = s1->priv_data; - - if (avpriv_atomic_int_get(&s->buffers_queued) != s->buffers) - av_log(s1, AV_LOG_WARNING, "Some buffers are still owned by the caller on " - "close.\n"); - - mmap_close(s); - - v4l2_close(s->fd); - return 0; -} - -#define OFFSET(x) offsetof(struct video_data, x) -#define DEC AV_OPT_FLAG_DECODING_PARAM - -static const AVOption options[] = { - { "standard", "set TV standard, used only by analog frame grabber", OFFSET(standard), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC }, - { "channel", "set TV channel, used only by frame grabber", OFFSET(channel), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, DEC }, - { "video_size", "set frame size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC }, - { "pixel_format", "set preferred pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, - { "input_format", "set preferred pixel format (for raw video) or codec name", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, - { "framerate", "set frame rate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, - - { "list_formats", "list available formats and exit", OFFSET(list_format), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC, "list_formats" }, - { "all", "show all available formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_ALLFORMATS }, 0, INT_MAX, DEC, "list_formats" }, - { "raw", "show only non-compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_RAWFORMATS }, 0, INT_MAX, DEC, "list_formats" }, - { "compressed", "show only compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_COMPFORMATS }, 0, INT_MAX, DEC, "list_formats" }, - - { "list_standards", "list supported standards and exit", OFFSET(list_standard), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, DEC, "list_standards" }, - { "all", "show all supported standards", OFFSET(list_standard), AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, DEC, "list_standards" }, - - { "timestamps", "set type of timestamps for grabbed frames", OFFSET(ts_mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, "timestamps" }, - { "ts", "set type of timestamps for grabbed frames", OFFSET(ts_mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, "timestamps" }, - { "default", "use timestamps from the kernel", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_DEFAULT }, 0, 2, DEC, "timestamps" }, - { "abs", "use absolute timestamps (wall clock)", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_ABS }, 0, 2, DEC, "timestamps" }, - { "mono2abs", "force conversion from monotonic to absolute timestamps", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_MONO2ABS }, 0, 2, DEC, "timestamps" }, - { "use_libv4l2", "use libv4l2 (v4l-utils) convertion functions", OFFSET(use_libv4l2), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC }, - { NULL }, -}; - -static const AVClass v4l2_class = { - .class_name = "V4L2 indev", - .item_name = av_default_item_name, - .option = options, - .version = LIBAVUTIL_VERSION_INT, -}; - -AVInputFormat ff_v4l2_demuxer = { - .name = "video4linux2,v4l2", - .long_name = NULL_IF_CONFIG_SMALL("Video4Linux2 device grab"), - .priv_data_size = sizeof(struct video_data), - .read_header = v4l2_read_header, - .read_packet = v4l2_read_packet, - .read_close = v4l2_read_close, - .flags = AVFMT_NOFILE, - .priv_class = &v4l2_class, -}; -- cgit v1.2.3