Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2000,2001 Fabrice Bellard
  3.  * Copyright (c) 2006 Luca Abeni
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. /**
  23.  * @file
  24.  * Video4Linux2 grab interface
  25.  *
  26.  * Part of this file is based on the V4L2 video capture example
  27.  * (http://linuxtv.org/downloads/v4l-dvb-apis/capture-example.html)
  28.  *
  29.  * Thanks to Michael Niedermayer for providing the mapping between
  30.  * V4L2_PIX_FMT_* and AV_PIX_FMT_*
  31.  */
  32.  
  33. #include "v4l2-common.h"
  34. #include <dirent.h>
  35.  
  36. #if CONFIG_LIBV4L2
  37. #include <libv4l2.h>
  38. #endif
  39.  
  40. static const int desired_video_buffers = 256;
  41.  
  42. #define V4L_ALLFORMATS  3
  43. #define V4L_RAWFORMATS  1
  44. #define V4L_COMPFORMATS 2
  45.  
  46. /**
  47.  * Return timestamps to the user exactly as returned by the kernel
  48.  */
  49. #define V4L_TS_DEFAULT  0
  50. /**
  51.  * Autodetect the kind of timestamps returned by the kernel and convert to
  52.  * absolute (wall clock) timestamps.
  53.  */
  54. #define V4L_TS_ABS      1
  55. /**
  56.  * Assume kernel timestamps are from the monotonic clock and convert to
  57.  * absolute timestamps.
  58.  */
  59. #define V4L_TS_MONO2ABS 2
  60.  
  61. /**
  62.  * Once the kind of timestamps returned by the kernel have been detected,
  63.  * the value of the timefilter (NULL or not) determines whether a conversion
  64.  * takes place.
  65.  */
  66. #define V4L_TS_CONVERT_READY V4L_TS_DEFAULT
  67.  
  68. struct video_data {
  69.     AVClass *class;
  70.     int fd;
  71.     int pixelformat; /* V4L2_PIX_FMT_* */
  72.     int width, height;
  73.     int frame_size;
  74.     int interlaced;
  75.     int top_field_first;
  76.     int ts_mode;
  77.     TimeFilter *timefilter;
  78.     int64_t last_time_m;
  79.  
  80.     int buffers;
  81.     volatile int buffers_queued;
  82.     void **buf_start;
  83.     unsigned int *buf_len;
  84.     char *standard;
  85.     v4l2_std_id std_id;
  86.     int channel;
  87.     char *pixel_format; /**< Set by a private option. */
  88.     int list_format;    /**< Set by a private option. */
  89.     int list_standard;  /**< Set by a private option. */
  90.     char *framerate;    /**< Set by a private option. */
  91.  
  92.     int use_libv4l2;
  93.     int (*open_f)(const char *file, int oflag, ...);
  94.     int (*close_f)(int fd);
  95.     int (*dup_f)(int fd);
  96.     int (*ioctl_f)(int fd, unsigned long int request, ...);
  97.     ssize_t (*read_f)(int fd, void *buffer, size_t n);
  98.     void *(*mmap_f)(void *start, size_t length, int prot, int flags, int fd, int64_t offset);
  99.     int (*munmap_f)(void *_start, size_t length);
  100. };
  101.  
  102. struct buff_data {
  103.     struct video_data *s;
  104.     int index;
  105. };
  106.  
  107. static int device_open(AVFormatContext *ctx)
  108. {
  109.     struct video_data *s = ctx->priv_data;
  110.     struct v4l2_capability cap;
  111.     int fd;
  112.     int err;
  113.     int flags = O_RDWR;
  114.  
  115. #define SET_WRAPPERS(prefix) do {       \
  116.     s->open_f   = prefix ## open;       \
  117.     s->close_f  = prefix ## close;      \
  118.     s->dup_f    = prefix ## dup;        \
  119.     s->ioctl_f  = prefix ## ioctl;      \
  120.     s->read_f   = prefix ## read;       \
  121.     s->mmap_f   = prefix ## mmap;       \
  122.     s->munmap_f = prefix ## munmap;     \
  123. } while (0)
  124.  
  125.     if (s->use_libv4l2) {
  126. #if CONFIG_LIBV4L2
  127.         SET_WRAPPERS(v4l2_);
  128. #else
  129.         av_log(ctx, AV_LOG_ERROR, "libavdevice is not build with libv4l2 support.\n");
  130.         return AVERROR(EINVAL);
  131. #endif
  132.     } else {
  133.         SET_WRAPPERS();
  134.     }
  135.  
  136. #define v4l2_open   s->open_f
  137. #define v4l2_close  s->close_f
  138. #define v4l2_dup    s->dup_f
  139. #define v4l2_ioctl  s->ioctl_f
  140. #define v4l2_read   s->read_f
  141. #define v4l2_mmap   s->mmap_f
  142. #define v4l2_munmap s->munmap_f
  143.  
  144.     if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
  145.         flags |= O_NONBLOCK;
  146.     }
  147.  
  148.     fd = v4l2_open(ctx->filename, flags, 0);
  149.     if (fd < 0) {
  150.         err = AVERROR(errno);
  151.         av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s: %s\n",
  152.                ctx->filename, av_err2str(err));
  153.         return err;
  154.     }
  155.  
  156.     if (v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
  157.         err = AVERROR(errno);
  158.         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n",
  159.                av_err2str(err));
  160.         goto fail;
  161.     }
  162.  
  163.     av_log(ctx, AV_LOG_VERBOSE, "fd:%d capabilities:%x\n",
  164.            fd, cap.capabilities);
  165.  
  166.     if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
  167.         av_log(ctx, AV_LOG_ERROR, "Not a video capture device.\n");
  168.         err = AVERROR(ENODEV);
  169.         goto fail;
  170.     }
  171.  
  172.     if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
  173.         av_log(ctx, AV_LOG_ERROR,
  174.                "The device does not support the streaming I/O method.\n");
  175.         err = AVERROR(ENOSYS);
  176.         goto fail;
  177.     }
  178.  
  179.     return fd;
  180.  
  181. fail:
  182.     v4l2_close(fd);
  183.     return err;
  184. }
  185.  
  186. static int device_init(AVFormatContext *ctx, int *width, int *height,
  187.                        uint32_t pixelformat)
  188. {
  189.     struct video_data *s = ctx->priv_data;
  190.     struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
  191.     int res = 0;
  192.  
  193.     fmt.fmt.pix.width = *width;
  194.     fmt.fmt.pix.height = *height;
  195.     fmt.fmt.pix.pixelformat = pixelformat;
  196.     fmt.fmt.pix.field = V4L2_FIELD_ANY;
  197.  
  198.     /* Some drivers will fail and return EINVAL when the pixelformat
  199.        is not supported (even if type field is valid and supported) */
  200.     if (v4l2_ioctl(s->fd, VIDIOC_S_FMT, &fmt) < 0)
  201.         res = AVERROR(errno);
  202.  
  203.     if ((*width != fmt.fmt.pix.width) || (*height != fmt.fmt.pix.height)) {
  204.         av_log(ctx, AV_LOG_INFO,
  205.                "The V4L2 driver changed the video from %dx%d to %dx%d\n",
  206.                *width, *height, fmt.fmt.pix.width, fmt.fmt.pix.height);
  207.         *width = fmt.fmt.pix.width;
  208.         *height = fmt.fmt.pix.height;
  209.     }
  210.  
  211.     if (pixelformat != fmt.fmt.pix.pixelformat) {
  212.         av_log(ctx, AV_LOG_DEBUG,
  213.                "The V4L2 driver changed the pixel format "
  214.                "from 0x%08X to 0x%08X\n",
  215.                pixelformat, fmt.fmt.pix.pixelformat);
  216.         res = AVERROR(EINVAL);
  217.     }
  218.  
  219.     if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED) {
  220.         av_log(ctx, AV_LOG_DEBUG,
  221.                "The V4L2 driver is using the interlaced mode\n");
  222.         s->interlaced = 1;
  223.     }
  224.  
  225.     return res;
  226. }
  227.  
  228. static int first_field(const struct video_data *s)
  229. {
  230.     int res;
  231.     v4l2_std_id std;
  232.  
  233.     res = v4l2_ioctl(s->fd, VIDIOC_G_STD, &std);
  234.     if (res < 0)
  235.         return 0;
  236.     if (std & V4L2_STD_NTSC)
  237.         return 0;
  238.  
  239.     return 1;
  240. }
  241.  
  242. #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
  243. static void list_framesizes(AVFormatContext *ctx, uint32_t pixelformat)
  244. {
  245.     const struct video_data *s = ctx->priv_data;
  246.     struct v4l2_frmsizeenum vfse = { .pixel_format = pixelformat };
  247.  
  248.     while(!v4l2_ioctl(s->fd, VIDIOC_ENUM_FRAMESIZES, &vfse)) {
  249.         switch (vfse.type) {
  250.         case V4L2_FRMSIZE_TYPE_DISCRETE:
  251.             av_log(ctx, AV_LOG_INFO, " %ux%u",
  252.                    vfse.discrete.width, vfse.discrete.height);
  253.         break;
  254.         case V4L2_FRMSIZE_TYPE_CONTINUOUS:
  255.         case V4L2_FRMSIZE_TYPE_STEPWISE:
  256.             av_log(ctx, AV_LOG_INFO, " {%u-%u, %u}x{%u-%u, %u}",
  257.                    vfse.stepwise.min_width,
  258.                    vfse.stepwise.max_width,
  259.                    vfse.stepwise.step_width,
  260.                    vfse.stepwise.min_height,
  261.                    vfse.stepwise.max_height,
  262.                    vfse.stepwise.step_height);
  263.         }
  264.         vfse.index++;
  265.     }
  266. }
  267. #endif
  268.  
  269. static void list_formats(AVFormatContext *ctx, int type)
  270. {
  271.     const struct video_data *s = ctx->priv_data;
  272.     struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
  273.  
  274.     while(!v4l2_ioctl(s->fd, VIDIOC_ENUM_FMT, &vfd)) {
  275.         enum AVCodecID codec_id = ff_fmt_v4l2codec(vfd.pixelformat);
  276.         enum AVPixelFormat pix_fmt = ff_fmt_v4l2ff(vfd.pixelformat, codec_id);
  277.  
  278.         vfd.index++;
  279.  
  280.         if (!(vfd.flags & V4L2_FMT_FLAG_COMPRESSED) &&
  281.             type & V4L_RAWFORMATS) {
  282.             const char *fmt_name = av_get_pix_fmt_name(pix_fmt);
  283.             av_log(ctx, AV_LOG_INFO, "Raw       : %11s : %20s :",
  284.                    fmt_name ? fmt_name : "Unsupported",
  285.                    vfd.description);
  286.         } else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&
  287.                    type & V4L_COMPFORMATS) {
  288.             const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
  289.             av_log(ctx, AV_LOG_INFO, "Compressed: %11s : %20s :",
  290.                    desc ? desc->name : "Unsupported",
  291.                    vfd.description);
  292.         } else {
  293.             continue;
  294.         }
  295.  
  296. #ifdef V4L2_FMT_FLAG_EMULATED
  297.         if (vfd.flags & V4L2_FMT_FLAG_EMULATED)
  298.             av_log(ctx, AV_LOG_INFO, " Emulated :");
  299. #endif
  300. #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
  301.         list_framesizes(ctx, vfd.pixelformat);
  302. #endif
  303.         av_log(ctx, AV_LOG_INFO, "\n");
  304.     }
  305. }
  306.  
  307. static void list_standards(AVFormatContext *ctx)
  308. {
  309.     int ret;
  310.     struct video_data *s = ctx->priv_data;
  311.     struct v4l2_standard standard;
  312.  
  313.     if (s->std_id == 0)
  314.         return;
  315.  
  316.     for (standard.index = 0; ; standard.index++) {
  317.         if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
  318.             ret = AVERROR(errno);
  319.             if (ret == AVERROR(EINVAL)) {
  320.                 break;
  321.             } else {
  322.                 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));
  323.                 return;
  324.             }
  325.         }
  326.         av_log(ctx, AV_LOG_INFO, "%2d, %16"PRIx64", %s\n",
  327.                standard.index, (uint64_t)standard.id, standard.name);
  328.     }
  329. }
  330.  
  331. static int mmap_init(AVFormatContext *ctx)
  332. {
  333.     int i, res;
  334.     struct video_data *s = ctx->priv_data;
  335.     struct v4l2_requestbuffers req = {
  336.         .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  337.         .count  = desired_video_buffers,
  338.         .memory = V4L2_MEMORY_MMAP
  339.     };
  340.  
  341.     if (v4l2_ioctl(s->fd, VIDIOC_REQBUFS, &req) < 0) {
  342.         res = AVERROR(errno);
  343.         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS): %s\n", av_err2str(res));
  344.         return res;
  345.     }
  346.  
  347.     if (req.count < 2) {
  348.         av_log(ctx, AV_LOG_ERROR, "Insufficient buffer memory\n");
  349.         return AVERROR(ENOMEM);
  350.     }
  351.     s->buffers = req.count;
  352.     s->buf_start = av_malloc_array(s->buffers, sizeof(void *));
  353.     if (!s->buf_start) {
  354.         av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer pointers\n");
  355.         return AVERROR(ENOMEM);
  356.     }
  357.     s->buf_len = av_malloc_array(s->buffers, sizeof(unsigned int));
  358.     if (!s->buf_len) {
  359.         av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer sizes\n");
  360.         av_freep(&s->buf_start);
  361.         return AVERROR(ENOMEM);
  362.     }
  363.  
  364.     for (i = 0; i < req.count; i++) {
  365.         struct v4l2_buffer buf = {
  366.             .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  367.             .index  = i,
  368.             .memory = V4L2_MEMORY_MMAP
  369.         };
  370.         if (v4l2_ioctl(s->fd, VIDIOC_QUERYBUF, &buf) < 0) {
  371.             res = AVERROR(errno);
  372.             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF): %s\n", av_err2str(res));
  373.             return res;
  374.         }
  375.  
  376.         s->buf_len[i] = buf.length;
  377.         if (s->frame_size > 0 && s->buf_len[i] < s->frame_size) {
  378.             av_log(ctx, AV_LOG_ERROR,
  379.                    "buf_len[%d] = %d < expected frame size %d\n",
  380.                    i, s->buf_len[i], s->frame_size);
  381.             return AVERROR(ENOMEM);
  382.         }
  383.         s->buf_start[i] = v4l2_mmap(NULL, buf.length,
  384.                                PROT_READ | PROT_WRITE, MAP_SHARED,
  385.                                s->fd, buf.m.offset);
  386.  
  387.         if (s->buf_start[i] == MAP_FAILED) {
  388.             res = AVERROR(errno);
  389.             av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", av_err2str(res));
  390.             return res;
  391.         }
  392.     }
  393.  
  394.     return 0;
  395. }
  396.  
  397. #if FF_API_DESTRUCT_PACKET
  398. static void dummy_release_buffer(AVPacket *pkt)
  399. {
  400.     av_assert0(0);
  401. }
  402. #endif
  403.  
  404. static int enqueue_buffer(struct video_data *s, struct v4l2_buffer *buf)
  405. {
  406.     int res = 0;
  407.  
  408.     if (v4l2_ioctl(s->fd, VIDIOC_QBUF, buf) < 0) {
  409.         res = AVERROR(errno);
  410.         av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", av_err2str(res));
  411.     } else {
  412.         avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);
  413.     }
  414.  
  415.     return res;
  416. }
  417.  
  418. static void mmap_release_buffer(void *opaque, uint8_t *data)
  419. {
  420.     struct v4l2_buffer buf = { 0 };
  421.     struct buff_data *buf_descriptor = opaque;
  422.     struct video_data *s = buf_descriptor->s;
  423.  
  424.     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  425.     buf.memory = V4L2_MEMORY_MMAP;
  426.     buf.index = buf_descriptor->index;
  427.     av_free(buf_descriptor);
  428.  
  429.     enqueue_buffer(s, &buf);
  430. }
  431.  
  432. #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
  433. static int64_t av_gettime_monotonic(void)
  434. {
  435.     return av_gettime_relative();
  436. }
  437. #endif
  438.  
  439. static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts)
  440. {
  441.     struct video_data *s = ctx->priv_data;
  442.     int64_t now;
  443.  
  444.     now = av_gettime();
  445.     if (s->ts_mode == V4L_TS_ABS &&
  446.         ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE) {
  447.         av_log(ctx, AV_LOG_INFO, "Detected absolute timestamps\n");
  448.         s->ts_mode = V4L_TS_CONVERT_READY;
  449.         return 0;
  450.     }
  451. #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
  452.     if (ctx->streams[0]->avg_frame_rate.num) {
  453.         now = av_gettime_monotonic();
  454.         if (s->ts_mode == V4L_TS_MONO2ABS ||
  455.             (ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE)) {
  456.             AVRational tb = {AV_TIME_BASE, 1};
  457.             int64_t period = av_rescale_q(1, tb, ctx->streams[0]->avg_frame_rate);
  458.             av_log(ctx, AV_LOG_INFO, "Detected monotonic timestamps, converting\n");
  459.             /* microseconds instead of seconds, MHz instead of Hz */
  460.             s->timefilter = ff_timefilter_new(1, period, 1.0E-6);
  461.             if (!s->timefilter)
  462.                 return AVERROR(ENOMEM);
  463.             s->ts_mode = V4L_TS_CONVERT_READY;
  464.             return 0;
  465.         }
  466.     }
  467. #endif
  468.     av_log(ctx, AV_LOG_ERROR, "Unknown timestamps\n");
  469.     return AVERROR(EIO);
  470. }
  471.  
  472. static int convert_timestamp(AVFormatContext *ctx, int64_t *ts)
  473. {
  474.     struct video_data *s = ctx->priv_data;
  475.  
  476.     if (s->ts_mode) {
  477.         int r = init_convert_timestamp(ctx, *ts);
  478.         if (r < 0)
  479.             return r;
  480.     }
  481. #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
  482.     if (s->timefilter) {
  483.         int64_t nowa = av_gettime();
  484.         int64_t nowm = av_gettime_monotonic();
  485.         ff_timefilter_update(s->timefilter, nowa, nowm - s->last_time_m);
  486.         s->last_time_m = nowm;
  487.         *ts = ff_timefilter_eval(s->timefilter, *ts - nowm);
  488.     }
  489. #endif
  490.     return 0;
  491. }
  492.  
  493. static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
  494. {
  495.     struct video_data *s = ctx->priv_data;
  496.     struct v4l2_buffer buf = {
  497.         .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  498.         .memory = V4L2_MEMORY_MMAP
  499.     };
  500.     int res;
  501.  
  502.     pkt->size = 0;
  503.  
  504.     /* FIXME: Some special treatment might be needed in case of loss of signal... */
  505.     while ((res = v4l2_ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
  506.     if (res < 0) {
  507.         if (errno == EAGAIN)
  508.             return AVERROR(EAGAIN);
  509.  
  510.         res = AVERROR(errno);
  511.         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n",
  512.                av_err2str(res));
  513.         return res;
  514.     }
  515.  
  516.     if (buf.index >= s->buffers) {
  517.         av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n");
  518.         return AVERROR(EINVAL);
  519.     }
  520.     avpriv_atomic_int_add_and_fetch(&s->buffers_queued, -1);
  521.     // always keep at least one buffer queued
  522.     av_assert0(avpriv_atomic_int_get(&s->buffers_queued) >= 1);
  523.  
  524. #ifdef V4L2_BUF_FLAG_ERROR
  525.     if (buf.flags & V4L2_BUF_FLAG_ERROR) {
  526.         av_log(ctx, AV_LOG_WARNING,
  527.                "Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",
  528.                buf.bytesused);
  529.         buf.bytesused = 0;
  530.     } else
  531. #endif
  532.     {
  533.         /* CPIA is a compressed format and we don't know the exact number of bytes
  534.          * used by a frame, so set it here as the driver announces it. */
  535.         if (ctx->video_codec_id == AV_CODEC_ID_CPIA)
  536.             s->frame_size = buf.bytesused;
  537.  
  538.         if (s->frame_size > 0 && buf.bytesused != s->frame_size) {
  539.             av_log(ctx, AV_LOG_ERROR,
  540.                    "Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",
  541.                    buf.bytesused, s->frame_size, buf.flags);
  542.             enqueue_buffer(s, &buf);
  543.             return AVERROR_INVALIDDATA;
  544.         }
  545.     }
  546.  
  547.     /* Image is at s->buff_start[buf.index] */
  548.     if (avpriv_atomic_int_get(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {
  549.         /* when we start getting low on queued buffers, fall back on copying data */
  550.         res = av_new_packet(pkt, buf.bytesused);
  551.         if (res < 0) {
  552.             av_log(ctx, AV_LOG_ERROR, "Error allocating a packet.\n");
  553.             enqueue_buffer(s, &buf);
  554.             return res;
  555.         }
  556.         memcpy(pkt->data, s->buf_start[buf.index], buf.bytesused);
  557.  
  558.         res = enqueue_buffer(s, &buf);
  559.         if (res) {
  560.             av_free_packet(pkt);
  561.             return res;
  562.         }
  563.     } else {
  564.         struct buff_data *buf_descriptor;
  565.  
  566.         pkt->data     = s->buf_start[buf.index];
  567.         pkt->size     = buf.bytesused;
  568. #if FF_API_DESTRUCT_PACKET
  569. FF_DISABLE_DEPRECATION_WARNINGS
  570.         pkt->destruct = dummy_release_buffer;
  571. FF_ENABLE_DEPRECATION_WARNINGS
  572. #endif
  573.  
  574.         buf_descriptor = av_malloc(sizeof(struct buff_data));
  575.         if (!buf_descriptor) {
  576.             /* Something went wrong... Since av_malloc() failed, we cannot even
  577.              * allocate a buffer for memcpying into it
  578.              */
  579.             av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");
  580.             enqueue_buffer(s, &buf);
  581.  
  582.             return AVERROR(ENOMEM);
  583.         }
  584.         buf_descriptor->index = buf.index;
  585.         buf_descriptor->s     = s;
  586.  
  587.         pkt->buf = av_buffer_create(pkt->data, pkt->size, mmap_release_buffer,
  588.                                     buf_descriptor, 0);
  589.         if (!pkt->buf) {
  590.             av_log(ctx, AV_LOG_ERROR, "Failed to create a buffer\n");
  591.             enqueue_buffer(s, &buf);
  592.             av_freep(&buf_descriptor);
  593.             return AVERROR(ENOMEM);
  594.         }
  595.     }
  596.     pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;
  597.     convert_timestamp(ctx, &pkt->pts);
  598.  
  599.     return pkt->size;
  600. }
  601.  
  602. static int mmap_start(AVFormatContext *ctx)
  603. {
  604.     struct video_data *s = ctx->priv_data;
  605.     enum v4l2_buf_type type;
  606.     int i, res;
  607.  
  608.     for (i = 0; i < s->buffers; i++) {
  609.         struct v4l2_buffer buf = {
  610.             .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
  611.             .index  = i,
  612.             .memory = V4L2_MEMORY_MMAP
  613.         };
  614.  
  615.         if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) < 0) {
  616.             res = AVERROR(errno);
  617.             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n",
  618.                    av_err2str(res));
  619.             return res;
  620.         }
  621.     }
  622.     s->buffers_queued = s->buffers;
  623.  
  624.     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  625.     if (v4l2_ioctl(s->fd, VIDIOC_STREAMON, &type) < 0) {
  626.         res = AVERROR(errno);
  627.         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n",
  628.                av_err2str(res));
  629.         return res;
  630.     }
  631.  
  632.     return 0;
  633. }
  634.  
  635. static void mmap_close(struct video_data *s)
  636. {
  637.     enum v4l2_buf_type type;
  638.     int i;
  639.  
  640.     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  641.     /* We do not check for the result, because we could
  642.      * not do anything about it anyway...
  643.      */
  644.     v4l2_ioctl(s->fd, VIDIOC_STREAMOFF, &type);
  645.     for (i = 0; i < s->buffers; i++) {
  646.         v4l2_munmap(s->buf_start[i], s->buf_len[i]);
  647.     }
  648.     av_freep(&s->buf_start);
  649.     av_freep(&s->buf_len);
  650. }
  651.  
  652. static int v4l2_set_parameters(AVFormatContext *ctx)
  653. {
  654.     struct video_data *s = ctx->priv_data;
  655.     struct v4l2_standard standard = { 0 };
  656.     struct v4l2_streamparm streamparm = { 0 };
  657.     struct v4l2_fract *tpf;
  658.     AVRational framerate_q = { 0 };
  659.     int i, ret;
  660.  
  661.     if (s->framerate &&
  662.         (ret = av_parse_video_rate(&framerate_q, s->framerate)) < 0) {
  663.         av_log(ctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n",
  664.                s->framerate);
  665.         return ret;
  666.     }
  667.  
  668.     if (s->standard) {
  669.         if (s->std_id) {
  670.             ret = 0;
  671.             av_log(ctx, AV_LOG_DEBUG, "Setting standard: %s\n", s->standard);
  672.             /* set tv standard */
  673.             for (i = 0; ; i++) {
  674.                 standard.index = i;
  675.                 if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
  676.                     ret = AVERROR(errno);
  677.                     break;
  678.                 }
  679.                 if (!av_strcasecmp(standard.name, s->standard))
  680.                     break;
  681.             }
  682.             if (ret < 0) {
  683.                 av_log(ctx, AV_LOG_ERROR, "Unknown or unsupported standard '%s'\n", s->standard);
  684.                 return ret;
  685.             }
  686.  
  687.             if (v4l2_ioctl(s->fd, VIDIOC_S_STD, &standard.id) < 0) {
  688.                 ret = AVERROR(errno);
  689.                 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_STD): %s\n", av_err2str(ret));
  690.                 return ret;
  691.             }
  692.         } else {
  693.             av_log(ctx, AV_LOG_WARNING,
  694.                    "This device does not support any standard\n");
  695.         }
  696.     }
  697.  
  698.     /* get standard */
  699.     if (v4l2_ioctl(s->fd, VIDIOC_G_STD, &s->std_id) == 0) {
  700.         tpf = &standard.frameperiod;
  701.         for (i = 0; ; i++) {
  702.             standard.index = i;
  703.             if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
  704.                 ret = AVERROR(errno);
  705.                 if (ret == AVERROR(EINVAL)
  706. #ifdef ENODATA
  707.                     || ret == AVERROR(ENODATA)
  708. #endif
  709.                 ) {
  710.                     tpf = &streamparm.parm.capture.timeperframe;
  711.                     break;
  712.                 }
  713.                 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));
  714.                 return ret;
  715.             }
  716.             if (standard.id == s->std_id) {
  717.                 av_log(ctx, AV_LOG_DEBUG,
  718.                        "Current standard: %s, id: %"PRIx64", frameperiod: %d/%d\n",
  719.                        standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator);
  720.                 break;
  721.             }
  722.         }
  723.     } else {
  724.         tpf = &streamparm.parm.capture.timeperframe;
  725.     }
  726.  
  727.     streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  728.     if (v4l2_ioctl(s->fd, VIDIOC_G_PARM, &streamparm) < 0) {
  729.         ret = AVERROR(errno);
  730.         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n", av_err2str(ret));
  731.         return ret;
  732.     }
  733.  
  734.     if (framerate_q.num && framerate_q.den) {
  735.         if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
  736.             tpf = &streamparm.parm.capture.timeperframe;
  737.  
  738.             av_log(ctx, AV_LOG_DEBUG, "Setting time per frame to %d/%d\n",
  739.                    framerate_q.den, framerate_q.num);
  740.             tpf->numerator   = framerate_q.den;
  741.             tpf->denominator = framerate_q.num;
  742.  
  743.             if (v4l2_ioctl(s->fd, VIDIOC_S_PARM, &streamparm) < 0) {
  744.                 ret = AVERROR(errno);
  745.                 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_PARM): %s\n",
  746.                        av_err2str(ret));
  747.                 return ret;
  748.             }
  749.  
  750.             if (framerate_q.num != tpf->denominator ||
  751.                 framerate_q.den != tpf->numerator) {
  752.                 av_log(ctx, AV_LOG_INFO,
  753.                        "The driver changed the time per frame from "
  754.                        "%d/%d to %d/%d\n",
  755.                        framerate_q.den, framerate_q.num,
  756.                        tpf->numerator, tpf->denominator);
  757.             }
  758.         } else {
  759.             av_log(ctx, AV_LOG_WARNING,
  760.                    "The driver does not permit changing the time per frame\n");
  761.         }
  762.     }
  763.     if (tpf->denominator > 0 && tpf->numerator > 0) {
  764.         ctx->streams[0]->avg_frame_rate.num = tpf->denominator;
  765.         ctx->streams[0]->avg_frame_rate.den = tpf->numerator;
  766.         ctx->streams[0]->r_frame_rate = ctx->streams[0]->avg_frame_rate;
  767.     } else
  768.         av_log(ctx, AV_LOG_WARNING, "Time per frame unknown\n");
  769.  
  770.     return 0;
  771. }
  772.  
  773. static int device_try_init(AVFormatContext *ctx,
  774.                            enum AVPixelFormat pix_fmt,
  775.                            int *width,
  776.                            int *height,
  777.                            uint32_t *desired_format,
  778.                            enum AVCodecID *codec_id)
  779. {
  780.     int ret, i;
  781.  
  782.     *desired_format = ff_fmt_ff2v4l(pix_fmt, ctx->video_codec_id);
  783.  
  784.     if (*desired_format) {
  785.         ret = device_init(ctx, width, height, *desired_format);
  786.         if (ret < 0) {
  787.             *desired_format = 0;
  788.             if (ret != AVERROR(EINVAL))
  789.                 return ret;
  790.         }
  791.     }
  792.  
  793.     if (!*desired_format) {
  794.         for (i = 0; ff_fmt_conversion_table[i].codec_id != AV_CODEC_ID_NONE; i++) {
  795.             if (ctx->video_codec_id == AV_CODEC_ID_NONE ||
  796.                 ff_fmt_conversion_table[i].codec_id == ctx->video_codec_id) {
  797.                 av_log(ctx, AV_LOG_DEBUG, "Trying to set codec:%s pix_fmt:%s\n",
  798.                        avcodec_get_name(ff_fmt_conversion_table[i].codec_id),
  799.                        (char *)av_x_if_null(av_get_pix_fmt_name(ff_fmt_conversion_table[i].ff_fmt), "none"));
  800.  
  801.                 *desired_format = ff_fmt_conversion_table[i].v4l2_fmt;
  802.                 ret = device_init(ctx, width, height, *desired_format);
  803.                 if (ret >= 0)
  804.                     break;
  805.                 else if (ret != AVERROR(EINVAL))
  806.                     return ret;
  807.                 *desired_format = 0;
  808.             }
  809.         }
  810.  
  811.         if (*desired_format == 0) {
  812.             av_log(ctx, AV_LOG_ERROR, "Cannot find a proper format for "
  813.                    "codec '%s' (id %d), pixel format '%s' (id %d)\n",
  814.                    avcodec_get_name(ctx->video_codec_id), ctx->video_codec_id,
  815.                    (char *)av_x_if_null(av_get_pix_fmt_name(pix_fmt), "none"), pix_fmt);
  816.             ret = AVERROR(EINVAL);
  817.         }
  818.     }
  819.  
  820.     *codec_id = ff_fmt_v4l2codec(*desired_format);
  821.     av_assert0(*codec_id != AV_CODEC_ID_NONE);
  822.     return ret;
  823. }
  824.  
  825. static int v4l2_read_probe(AVProbeData *p)
  826. {
  827.     if (av_strstart(p->filename, "/dev/video", NULL))
  828.         return AVPROBE_SCORE_MAX - 1;
  829.     return 0;
  830. }
  831.  
  832. static int v4l2_read_header(AVFormatContext *ctx)
  833. {
  834.     struct video_data *s = ctx->priv_data;
  835.     AVStream *st;
  836.     int res = 0;
  837.     uint32_t desired_format;
  838.     enum AVCodecID codec_id = AV_CODEC_ID_NONE;
  839.     enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
  840.     struct v4l2_input input = { 0 };
  841.  
  842.     st = avformat_new_stream(ctx, NULL);
  843.     if (!st)
  844.         return AVERROR(ENOMEM);
  845.  
  846. #if CONFIG_LIBV4L2
  847.     /* silence libv4l2 logging. if fopen() fails v4l2_log_file will be NULL
  848.        and errors will get sent to stderr */
  849.     if (s->use_libv4l2)
  850.         v4l2_log_file = fopen("/dev/null", "w");
  851. #endif
  852.  
  853.     s->fd = device_open(ctx);
  854.     if (s->fd < 0)
  855.         return s->fd;
  856.  
  857.     if (s->channel != -1) {
  858.         /* set video input */
  859.         av_log(ctx, AV_LOG_DEBUG, "Selecting input_channel: %d\n", s->channel);
  860.         if (v4l2_ioctl(s->fd, VIDIOC_S_INPUT, &s->channel) < 0) {
  861.             res = AVERROR(errno);
  862.             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_INPUT): %s\n", av_err2str(res));
  863.             goto fail;
  864.         }
  865.     } else {
  866.         /* get current video input */
  867.         if (v4l2_ioctl(s->fd, VIDIOC_G_INPUT, &s->channel) < 0) {
  868.             res = AVERROR(errno);
  869.             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_INPUT): %s\n", av_err2str(res));
  870.             goto fail;
  871.         }
  872.     }
  873.  
  874.     /* enum input */
  875.     input.index = s->channel;
  876.     if (v4l2_ioctl(s->fd, VIDIOC_ENUMINPUT, &input) < 0) {
  877.         res = AVERROR(errno);
  878.         av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMINPUT): %s\n", av_err2str(res));
  879.         goto fail;
  880.     }
  881.     s->std_id = input.std;
  882.     av_log(ctx, AV_LOG_DEBUG, "Current input_channel: %d, input_name: %s, input_std: %"PRIx64"\n",
  883.            s->channel, input.name, (uint64_t)input.std);
  884.  
  885.     if (s->list_format) {
  886.         list_formats(ctx, s->list_format);
  887.         res = AVERROR_EXIT;
  888.         goto fail;
  889.     }
  890.  
  891.     if (s->list_standard) {
  892.         list_standards(ctx);
  893.         res = AVERROR_EXIT;
  894.         goto fail;
  895.     }
  896.  
  897.     avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
  898.  
  899.     if (s->pixel_format) {
  900.         AVCodec *codec = avcodec_find_decoder_by_name(s->pixel_format);
  901.  
  902.         if (codec)
  903.             ctx->video_codec_id = codec->id;
  904.  
  905.         pix_fmt = av_get_pix_fmt(s->pixel_format);
  906.  
  907.         if (pix_fmt == AV_PIX_FMT_NONE && !codec) {
  908.             av_log(ctx, AV_LOG_ERROR, "No such input format: %s.\n",
  909.                    s->pixel_format);
  910.  
  911.             res = AVERROR(EINVAL);
  912.             goto fail;
  913.         }
  914.     }
  915.  
  916.     if (!s->width && !s->height) {
  917.         struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
  918.  
  919.         av_log(ctx, AV_LOG_VERBOSE,
  920.                "Querying the device for the current frame size\n");
  921.         if (v4l2_ioctl(s->fd, VIDIOC_G_FMT, &fmt) < 0) {
  922.             res = AVERROR(errno);
  923.             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n",
  924.                    av_err2str(res));
  925.             goto fail;
  926.         }
  927.  
  928.         s->width  = fmt.fmt.pix.width;
  929.         s->height = fmt.fmt.pix.height;
  930.         av_log(ctx, AV_LOG_VERBOSE,
  931.                "Setting frame size to %dx%d\n", s->width, s->height);
  932.     }
  933.  
  934.     res = device_try_init(ctx, pix_fmt, &s->width, &s->height, &desired_format, &codec_id);
  935.     if (res < 0)
  936.         goto fail;
  937.  
  938.     /* If no pixel_format was specified, the codec_id was not known up
  939.      * until now. Set video_codec_id in the context, as codec_id will
  940.      * not be available outside this function
  941.      */
  942.     if (codec_id != AV_CODEC_ID_NONE && ctx->video_codec_id == AV_CODEC_ID_NONE)
  943.         ctx->video_codec_id = codec_id;
  944.  
  945.     if ((res = av_image_check_size(s->width, s->height, 0, ctx)) < 0)
  946.         goto fail;
  947.  
  948.     s->pixelformat = desired_format;
  949.  
  950.     if ((res = v4l2_set_parameters(ctx)) < 0)
  951.         goto fail;
  952.  
  953.     st->codec->pix_fmt = ff_fmt_v4l2ff(desired_format, codec_id);
  954.     s->frame_size =
  955.         avpicture_get_size(st->codec->pix_fmt, s->width, s->height);
  956.  
  957.     if ((res = mmap_init(ctx)) ||
  958.         (res = mmap_start(ctx)) < 0)
  959.             goto fail;
  960.  
  961.     s->top_field_first = first_field(s);
  962.  
  963.     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  964.     st->codec->codec_id = codec_id;
  965.     if (codec_id == AV_CODEC_ID_RAWVIDEO)
  966.         st->codec->codec_tag =
  967.             avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
  968.     else if (codec_id == AV_CODEC_ID_H264) {
  969.         st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;
  970.     }
  971.     if (desired_format == V4L2_PIX_FMT_YVU420)
  972.         st->codec->codec_tag = MKTAG('Y', 'V', '1', '2');
  973.     else if (desired_format == V4L2_PIX_FMT_YVU410)
  974.         st->codec->codec_tag = MKTAG('Y', 'V', 'U', '9');
  975.     st->codec->width = s->width;
  976.     st->codec->height = s->height;
  977.     if (st->avg_frame_rate.den)
  978.         st->codec->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8;
  979.  
  980.     return 0;
  981.  
  982. fail:
  983.     v4l2_close(s->fd);
  984.     return res;
  985. }
  986.  
  987. static int v4l2_read_packet(AVFormatContext *ctx, AVPacket *pkt)
  988. {
  989.     struct video_data *s = ctx->priv_data;
  990. #if FF_API_CODED_FRAME
  991. FF_DISABLE_DEPRECATION_WARNINGS
  992.     AVFrame *frame = ctx->streams[0]->codec->coded_frame;
  993. FF_ENABLE_DEPRECATION_WARNINGS
  994. #endif
  995.     int res;
  996.  
  997.     av_init_packet(pkt);
  998.     if ((res = mmap_read_frame(ctx, pkt)) < 0) {
  999.         return res;
  1000.     }
  1001.  
  1002. #if FF_API_CODED_FRAME
  1003. FF_DISABLE_DEPRECATION_WARNINGS
  1004.     if (frame && s->interlaced) {
  1005.         frame->interlaced_frame = 1;
  1006.         frame->top_field_first = s->top_field_first;
  1007.     }
  1008. FF_ENABLE_DEPRECATION_WARNINGS
  1009. #endif
  1010.  
  1011.     return pkt->size;
  1012. }
  1013.  
  1014. static int v4l2_read_close(AVFormatContext *ctx)
  1015. {
  1016.     struct video_data *s = ctx->priv_data;
  1017.  
  1018.     if (avpriv_atomic_int_get(&s->buffers_queued) != s->buffers)
  1019.         av_log(ctx, AV_LOG_WARNING, "Some buffers are still owned by the caller on "
  1020.                "close.\n");
  1021.  
  1022.     mmap_close(s);
  1023.  
  1024.     v4l2_close(s->fd);
  1025.     return 0;
  1026. }
  1027.  
  1028. static int v4l2_is_v4l_dev(const char *name)
  1029. {
  1030.     return !strncmp(name, "video", 5) ||
  1031.            !strncmp(name, "radio", 5) ||
  1032.            !strncmp(name, "vbi", 3) ||
  1033.            !strncmp(name, "v4l-subdev", 10);
  1034. }
  1035.  
  1036. static int v4l2_get_device_list(AVFormatContext *ctx, AVDeviceInfoList *device_list)
  1037. {
  1038.     struct video_data *s = ctx->priv_data;
  1039.     DIR *dir;
  1040.     struct dirent *entry;
  1041.     AVDeviceInfo *device = NULL;
  1042.     struct v4l2_capability cap;
  1043.     int ret = 0;
  1044.  
  1045.     if (!device_list)
  1046.         return AVERROR(EINVAL);
  1047.  
  1048.     dir = opendir("/dev");
  1049.     if (!dir) {
  1050.         ret = AVERROR(errno);
  1051.         av_log(ctx, AV_LOG_ERROR, "Couldn't open the directory: %s\n", av_err2str(ret));
  1052.         return ret;
  1053.     }
  1054.     while ((entry = readdir(dir))) {
  1055.         if (!v4l2_is_v4l_dev(entry->d_name))
  1056.             continue;
  1057.  
  1058.         snprintf(ctx->filename, sizeof(ctx->filename), "/dev/%s", entry->d_name);
  1059.         if ((s->fd = device_open(ctx)) < 0)
  1060.             continue;
  1061.  
  1062.         if (v4l2_ioctl(s->fd, VIDIOC_QUERYCAP, &cap) < 0) {
  1063.             ret = AVERROR(errno);
  1064.             av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n", av_err2str(ret));
  1065.             goto fail;
  1066.         }
  1067.  
  1068.         device = av_mallocz(sizeof(AVDeviceInfo));
  1069.         if (!device) {
  1070.             ret = AVERROR(ENOMEM);
  1071.             goto fail;
  1072.         }
  1073.         device->device_name = av_strdup(ctx->filename);
  1074.         device->device_description = av_strdup(cap.card);
  1075.         if (!device->device_name || !device->device_description) {
  1076.             ret = AVERROR(ENOMEM);
  1077.             goto fail;
  1078.         }
  1079.  
  1080.         if ((ret = av_dynarray_add_nofree(&device_list->devices,
  1081.                                           &device_list->nb_devices, device)) < 0)
  1082.             goto fail;
  1083.  
  1084.         v4l2_close(s->fd);
  1085.         s->fd = -1;
  1086.         continue;
  1087.  
  1088.       fail:
  1089.         if (device) {
  1090.             av_freep(&device->device_name);
  1091.             av_freep(&device->device_description);
  1092.             av_freep(&device);
  1093.         }
  1094.         if (s->fd >= 0)
  1095.             v4l2_close(s->fd);
  1096.         s->fd = -1;
  1097.         break;
  1098.     }
  1099.     closedir(dir);
  1100.     return ret;
  1101. }
  1102.  
  1103. #define OFFSET(x) offsetof(struct video_data, x)
  1104. #define DEC AV_OPT_FLAG_DECODING_PARAM
  1105.  
  1106. static const AVOption options[] = {
  1107.     { "standard",     "set TV standard, used only by analog frame grabber",       OFFSET(standard),     AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0,       DEC },
  1108.     { "channel",      "set TV channel, used only by frame grabber",               OFFSET(channel),      AV_OPT_TYPE_INT,    {.i64 = -1 },  -1, INT_MAX, DEC },
  1109.     { "video_size",   "set frame size",                                           OFFSET(width),        AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL},  0, 0,   DEC },
  1110.     { "pixel_format", "set preferred pixel format",                               OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       DEC },
  1111.     { "input_format", "set preferred pixel format (for raw video) or codec name", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       DEC },
  1112.     { "framerate",    "set frame rate",                                           OFFSET(framerate),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       DEC },
  1113.  
  1114.     { "list_formats", "list available formats and exit",                          OFFSET(list_format),  AV_OPT_TYPE_INT,    {.i64 = 0 },  0, INT_MAX, DEC, "list_formats" },
  1115.     { "all",          "show all available formats",                               OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.i64 = V4L_ALLFORMATS  },    0, INT_MAX, DEC, "list_formats" },
  1116.     { "raw",          "show only non-compressed formats",                         OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.i64 = V4L_RAWFORMATS  },    0, INT_MAX, DEC, "list_formats" },
  1117.     { "compressed",   "show only compressed formats",                             OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.i64 = V4L_COMPFORMATS },    0, INT_MAX, DEC, "list_formats" },
  1118.  
  1119.     { "list_standards", "list supported standards and exit",                      OFFSET(list_standard), AV_OPT_TYPE_INT,   {.i64 = 0 },  0, 1, DEC, "list_standards" },
  1120.     { "all",            "show all supported standards",                           OFFSET(list_standard), AV_OPT_TYPE_CONST, {.i64 = 1 },  0, 0, DEC, "list_standards" },
  1121.  
  1122.     { "timestamps",   "set type of timestamps for grabbed frames",                OFFSET(ts_mode),      AV_OPT_TYPE_INT,    {.i64 = 0 }, 0, 2, DEC, "timestamps" },
  1123.     { "ts",           "set type of timestamps for grabbed frames",                OFFSET(ts_mode),      AV_OPT_TYPE_INT,    {.i64 = 0 }, 0, 2, DEC, "timestamps" },
  1124.     { "default",      "use timestamps from the kernel",                           OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.i64 = V4L_TS_DEFAULT  }, 0, 2, DEC, "timestamps" },
  1125.     { "abs",          "use absolute timestamps (wall clock)",                     OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.i64 = V4L_TS_ABS      }, 0, 2, DEC, "timestamps" },
  1126.     { "mono2abs",     "force conversion from monotonic to absolute timestamps",   OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.i64 = V4L_TS_MONO2ABS }, 0, 2, DEC, "timestamps" },
  1127.     { "use_libv4l2",  "use libv4l2 (v4l-utils) conversion functions",             OFFSET(use_libv4l2),  AV_OPT_TYPE_INT,    {.i64 = 0}, 0, 1, DEC },
  1128.     { NULL },
  1129. };
  1130.  
  1131. static const AVClass v4l2_class = {
  1132.     .class_name = "V4L2 indev",
  1133.     .item_name  = av_default_item_name,
  1134.     .option     = options,
  1135.     .version    = LIBAVUTIL_VERSION_INT,
  1136.     .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
  1137. };
  1138.  
  1139. AVInputFormat ff_v4l2_demuxer = {
  1140.     .name           = "video4linux2,v4l2",
  1141.     .long_name      = NULL_IF_CONFIG_SMALL("Video4Linux2 device grab"),
  1142.     .priv_data_size = sizeof(struct video_data),
  1143.     .read_probe     = v4l2_read_probe,
  1144.     .read_header    = v4l2_read_header,
  1145.     .read_packet    = v4l2_read_packet,
  1146.     .read_close     = v4l2_read_close,
  1147.     .get_device_list = v4l2_get_device_list,
  1148.     .flags          = AVFMT_NOFILE,
  1149.     .priv_class     = &v4l2_class,
  1150. };
  1151.