FFmpeg
v4l2.c
Go to the documentation of this file.
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 <stdatomic.h>
34 
35 #include "libavutil/avassert.h"
36 #include "libavutil/avstring.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/mem.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/pixdesc.h"
41 #include "libavutil/time.h"
42 #include "libavcodec/avcodec.h"
43 #include "libavcodec/codec_desc.h"
44 #include "libavformat/demux.h"
45 #include "libavformat/internal.h"
46 #include "avdevice.h"
47 #include "timefilter.h"
48 #include "v4l2-common.h"
49 #include <dirent.h>
50 
51 #if CONFIG_LIBV4L2
52 #include <libv4l2.h>
53 #endif
54 
55 static const int desired_video_buffers = 256;
56 
57 #define V4L_ALLFORMATS 3
58 #define V4L_RAWFORMATS 1
59 #define V4L_COMPFORMATS 2
60 
61 /**
62  * Return timestamps to the user exactly as returned by the kernel
63  */
64 #define V4L_TS_DEFAULT 0
65 /**
66  * Autodetect the kind of timestamps returned by the kernel and convert to
67  * absolute (wall clock) timestamps.
68  */
69 #define V4L_TS_ABS 1
70 /**
71  * Assume kernel timestamps are from the monotonic clock and convert to
72  * absolute timestamps.
73  */
74 #define V4L_TS_MONO2ABS 2
75 
76 /**
77  * Once the kind of timestamps returned by the kernel have been detected,
78  * the value of the timefilter (NULL or not) determines whether a conversion
79  * takes place.
80  */
81 #define V4L_TS_CONVERT_READY V4L_TS_DEFAULT
82 
83 struct video_data {
84  AVClass *class;
85  int fd;
86  int pixelformat; /* V4L2_PIX_FMT_* */
87  int width, height;
91  int ts_mode;
93  int64_t last_time_m;
94 
95  int buffers;
97  void **buf_start;
98  unsigned int *buf_len;
99  char *standard;
100  v4l2_std_id std_id;
101  int channel;
102  char *pixel_format; /**< Set by a private option. */
103  int list_format; /**< Set by a private option. */
104  int list_standard; /**< Set by a private option. */
105  char *framerate; /**< Set by a private option. */
106 
108  int (*open_f)(const char *file, int oflag, ...);
109  int (*close_f)(int fd);
110  int (*dup_f)(int fd);
111 #if defined(__sun) || defined(__BIONIC__) || defined(__musl__) /* POSIX-like */
112  int (*ioctl_f)(int fd, int request, ...);
113 #else
114  int (*ioctl_f)(int fd, unsigned long int request, ...);
115 #endif
116  ssize_t (*read_f)(int fd, void *buffer, size_t n);
117  void *(*mmap_f)(void *start, size_t length, int prot, int flags, int fd, int64_t offset);
118  int (*munmap_f)(void *_start, size_t length);
119 };
120 
121 struct buff_data {
122  struct video_data *s;
123  int index;
124 };
125 
126 static int device_open(AVFormatContext *ctx, const char* device_path)
127 {
128  struct video_data *s = ctx->priv_data;
129  struct v4l2_capability cap;
130  int fd;
131  int err;
132  int flags = O_RDWR;
133 
134 #define SET_WRAPPERS(prefix) do { \
135  s->open_f = prefix ## open; \
136  s->close_f = prefix ## close; \
137  s->dup_f = prefix ## dup; \
138  s->ioctl_f = prefix ## ioctl; \
139  s->read_f = prefix ## read; \
140  s->mmap_f = prefix ## mmap; \
141  s->munmap_f = prefix ## munmap; \
142 } while (0)
143 
144  if (s->use_libv4l2) {
145 #if CONFIG_LIBV4L2
146  SET_WRAPPERS(v4l2_);
147 #else
148  av_log(ctx, AV_LOG_ERROR, "libavdevice is not built with libv4l2 support.\n");
149  return AVERROR(EINVAL);
150 #endif
151  } else {
152  SET_WRAPPERS();
153  }
154 
155 #define v4l2_open s->open_f
156 #define v4l2_close s->close_f
157 #define v4l2_dup s->dup_f
158 #define v4l2_ioctl s->ioctl_f
159 #define v4l2_read s->read_f
160 #define v4l2_mmap s->mmap_f
161 #define v4l2_munmap s->munmap_f
162 
163  if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
164  flags |= O_NONBLOCK;
165  }
166 
167  fd = v4l2_open(device_path, flags, 0);
168  if (fd < 0) {
169  err = AVERROR(errno);
170  av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s: %s\n",
171  device_path, av_err2str(err));
172  return err;
173  }
174 
175  if (v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
176  err = AVERROR(errno);
177  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n",
178  av_err2str(err));
179  goto fail;
180  }
181 
182  av_log(ctx, AV_LOG_VERBOSE, "fd:%d capabilities:%x\n",
183  fd, cap.capabilities);
184 
185  if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
186  av_log(ctx, AV_LOG_ERROR, "Not a video capture device.\n");
187  err = AVERROR(ENODEV);
188  goto fail;
189  }
190 
191  if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
193  "The device does not support the streaming I/O method.\n");
194  err = AVERROR(ENOSYS);
195  goto fail;
196  }
197 
198  return fd;
199 
200 fail:
201  v4l2_close(fd);
202  return err;
203 }
204 
205 static int device_init(AVFormatContext *ctx, int *width, int *height,
206  uint32_t pixelformat)
207 {
208  struct video_data *s = ctx->priv_data;
209  struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
210  int res = 0;
211 
212  fmt.fmt.pix.width = *width;
213  fmt.fmt.pix.height = *height;
214  fmt.fmt.pix.pixelformat = pixelformat;
215  fmt.fmt.pix.field = V4L2_FIELD_ANY;
216 
217  /* Some drivers will fail and return EINVAL when the pixelformat
218  is not supported (even if type field is valid and supported) */
219  if (v4l2_ioctl(s->fd, VIDIOC_S_FMT, &fmt) < 0)
220  res = AVERROR(errno);
221 
222  if ((*width != fmt.fmt.pix.width) || (*height != fmt.fmt.pix.height)) {
224  "The V4L2 driver changed the video from %dx%d to %dx%d\n",
225  *width, *height, fmt.fmt.pix.width, fmt.fmt.pix.height);
226  *width = fmt.fmt.pix.width;
227  *height = fmt.fmt.pix.height;
228  }
229 
230  if (pixelformat != fmt.fmt.pix.pixelformat) {
232  "The V4L2 driver changed the pixel format "
233  "from 0x%08X to 0x%08X\n",
234  pixelformat, fmt.fmt.pix.pixelformat);
235  res = AVERROR(EINVAL);
236  }
237 
238  if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED) {
240  "The V4L2 driver is using the interlaced mode\n");
241  s->interlaced = 1;
242  }
243 
244  return res;
245 }
246 
247 static int first_field(const struct video_data *s)
248 {
249  int res;
250  v4l2_std_id std;
251 
252  res = v4l2_ioctl(s->fd, VIDIOC_G_STD, &std);
253  if (res < 0)
254  return 0;
255  if (std & V4L2_STD_NTSC)
256  return 0;
257 
258  return 1;
259 }
260 
261 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
262 static void list_framesizes(AVFormatContext *ctx, uint32_t pixelformat)
263 {
264  const struct video_data *s = ctx->priv_data;
265  struct v4l2_frmsizeenum vfse = { .pixel_format = pixelformat };
266 
267  while(!v4l2_ioctl(s->fd, VIDIOC_ENUM_FRAMESIZES, &vfse)) {
268  switch (vfse.type) {
269  case V4L2_FRMSIZE_TYPE_DISCRETE:
270  av_log(ctx, AV_LOG_INFO, " %ux%u",
271  vfse.discrete.width, vfse.discrete.height);
272  break;
273  case V4L2_FRMSIZE_TYPE_CONTINUOUS:
274  case V4L2_FRMSIZE_TYPE_STEPWISE:
275  av_log(ctx, AV_LOG_INFO, " {%u-%u, %u}x{%u-%u, %u}",
276  vfse.stepwise.min_width,
277  vfse.stepwise.max_width,
278  vfse.stepwise.step_width,
279  vfse.stepwise.min_height,
280  vfse.stepwise.max_height,
281  vfse.stepwise.step_height);
282  }
283  vfse.index++;
284  }
285 }
286 #endif
287 
289 {
290  const struct video_data *s = ctx->priv_data;
291  struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
292 
293  while(!v4l2_ioctl(s->fd, VIDIOC_ENUM_FMT, &vfd)) {
294  enum AVCodecID codec_id = ff_fmt_v4l2codec(vfd.pixelformat);
295  enum AVPixelFormat pix_fmt = ff_fmt_v4l2ff(vfd.pixelformat, codec_id);
296 
297  vfd.index++;
298 
299  if (!(vfd.flags & V4L2_FMT_FLAG_COMPRESSED) &&
300  type & V4L_RAWFORMATS) {
301  const char *fmt_name = av_get_pix_fmt_name(pix_fmt);
302  av_log(ctx, AV_LOG_INFO, "Raw : %11s : %20s :",
303  fmt_name ? fmt_name : "Unsupported",
304  vfd.description);
305  } else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&
306  type & V4L_COMPFORMATS) {
308  av_log(ctx, AV_LOG_INFO, "Compressed: %11s : %20s :",
309  desc ? desc->name : "Unsupported",
310  vfd.description);
311  } else {
312  continue;
313  }
314 
315 #ifdef V4L2_FMT_FLAG_EMULATED
316  if (vfd.flags & V4L2_FMT_FLAG_EMULATED)
317  av_log(ctx, AV_LOG_INFO, " Emulated :");
318 #endif
319 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
320  list_framesizes(ctx, vfd.pixelformat);
321 #endif
322  av_log(ctx, AV_LOG_INFO, "\n");
323  }
324 }
325 
327 {
328  int ret;
329  struct video_data *s = ctx->priv_data;
330  struct v4l2_standard standard;
331 
332  if (s->std_id == 0)
333  return;
334 
335  for (standard.index = 0; ; standard.index++) {
336  if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
337  ret = AVERROR(errno);
338  if (ret == AVERROR(EINVAL)) {
339  break;
340  } else {
341  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));
342  return;
343  }
344  }
345  av_log(ctx, AV_LOG_INFO, "%2d, %16"PRIx64", %s\n",
346  standard.index, (uint64_t)standard.id, standard.name);
347  }
348 }
349 
351 {
352  int i, res;
353  struct video_data *s = ctx->priv_data;
354  struct v4l2_requestbuffers req = {
355  .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
356  .count = desired_video_buffers,
357  .memory = V4L2_MEMORY_MMAP
358  };
359 
360  if (v4l2_ioctl(s->fd, VIDIOC_REQBUFS, &req) < 0) {
361  res = AVERROR(errno);
362  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS): %s\n", av_err2str(res));
363  return res;
364  }
365 
366  if (req.count < 2) {
367  av_log(ctx, AV_LOG_ERROR, "Insufficient buffer memory\n");
368  return AVERROR(ENOMEM);
369  }
370  s->buffers = req.count;
371  s->buf_start = av_malloc_array(s->buffers, sizeof(void *));
372  if (!s->buf_start) {
373  av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer pointers\n");
374  return AVERROR(ENOMEM);
375  }
376  s->buf_len = av_malloc_array(s->buffers, sizeof(unsigned int));
377  if (!s->buf_len) {
378  av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer sizes\n");
379  av_freep(&s->buf_start);
380  return AVERROR(ENOMEM);
381  }
382 
383  for (i = 0; i < req.count; i++) {
384  struct v4l2_buffer buf = {
385  .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
386  .index = i,
387  .memory = V4L2_MEMORY_MMAP
388  };
389  if (v4l2_ioctl(s->fd, VIDIOC_QUERYBUF, &buf) < 0) {
390  res = AVERROR(errno);
391  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF): %s\n", av_err2str(res));
392  return res;
393  }
394 
395  s->buf_len[i] = buf.length;
396  if (s->frame_size > 0 && s->buf_len[i] < s->frame_size) {
398  "buf_len[%d] = %d < expected frame size %d\n",
399  i, s->buf_len[i], s->frame_size);
400  return AVERROR(ENOMEM);
401  }
402  s->buf_start[i] = v4l2_mmap(NULL, buf.length,
403  PROT_READ | PROT_WRITE, MAP_SHARED,
404  s->fd, buf.m.offset);
405 
406  if (s->buf_start[i] == MAP_FAILED) {
407  res = AVERROR(errno);
408  av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", av_err2str(res));
409  return res;
410  }
411  }
412 
413  return 0;
414 }
415 
416 static int enqueue_buffer(struct video_data *s, struct v4l2_buffer *buf)
417 {
418  int res = 0;
419 
420  if (v4l2_ioctl(s->fd, VIDIOC_QBUF, buf) < 0) {
421  res = AVERROR(errno);
422  av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", av_err2str(res));
423  } else {
424  atomic_fetch_add(&s->buffers_queued, 1);
425  }
426 
427  return res;
428 }
429 
430 static void mmap_release_buffer(void *opaque, uint8_t *data)
431 {
432  struct v4l2_buffer buf = { 0 };
433  struct buff_data *buf_descriptor = opaque;
434  struct video_data *s = buf_descriptor->s;
435 
436  buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
437  buf.memory = V4L2_MEMORY_MMAP;
438  buf.index = buf_descriptor->index;
439  av_free(buf_descriptor);
440 
441  enqueue_buffer(s, &buf);
442 }
443 
444 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
445 static int64_t av_gettime_monotonic(void)
446 {
447  return av_gettime_relative();
448 }
449 #endif
450 
452 {
453  struct video_data *s = ctx->priv_data;
454  int64_t now;
455 
456  now = av_gettime();
457  if (s->ts_mode == V4L_TS_ABS &&
458  ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE) {
459  av_log(ctx, AV_LOG_INFO, "Detected absolute timestamps\n");
460  s->ts_mode = V4L_TS_CONVERT_READY;
461  return 0;
462  }
463 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
464  if (ctx->streams[0]->avg_frame_rate.num) {
465  now = av_gettime_monotonic();
466  if (s->ts_mode == V4L_TS_MONO2ABS ||
467  (ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE)) {
468  AVRational tb = {AV_TIME_BASE, 1};
469  int64_t period = av_rescale_q(1, tb, ctx->streams[0]->avg_frame_rate);
470  av_log(ctx, AV_LOG_INFO, "Detected monotonic timestamps, converting\n");
471  /* microseconds instead of seconds, MHz instead of Hz */
472  s->timefilter = ff_timefilter_new(1, period, 1.0E-6);
473  if (!s->timefilter)
474  return AVERROR(ENOMEM);
475  s->ts_mode = V4L_TS_CONVERT_READY;
476  return 0;
477  }
478  }
479 #endif
480  av_log(ctx, AV_LOG_ERROR, "Unknown timestamps\n");
481  return AVERROR(EIO);
482 }
483 
484 static int convert_timestamp(AVFormatContext *ctx, int64_t *ts)
485 {
486  struct video_data *s = ctx->priv_data;
487 
488  if (s->ts_mode) {
489  int r = init_convert_timestamp(ctx, *ts);
490  if (r < 0)
491  return r;
492  }
493 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
494  if (s->timefilter) {
495  int64_t nowa = av_gettime();
496  int64_t nowm = av_gettime_monotonic();
497  ff_timefilter_update(s->timefilter, nowa, nowm - s->last_time_m);
498  s->last_time_m = nowm;
499  *ts = ff_timefilter_eval(s->timefilter, *ts - nowm);
500  }
501 #endif
502  return 0;
503 }
504 
506 {
507  struct video_data *s = ctx->priv_data;
508  struct v4l2_buffer buf = {
509  .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
510  .memory = V4L2_MEMORY_MMAP
511  };
512  struct timeval buf_ts;
513  int res;
514 
515  pkt->size = 0;
516 
517  /* FIXME: Some special treatment might be needed in case of loss of signal... */
518  while ((res = v4l2_ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
519  if (res < 0) {
520  if (errno == EAGAIN)
521  return AVERROR(EAGAIN);
522 
523  res = AVERROR(errno);
524  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n",
525  av_err2str(res));
526  return res;
527  }
528 
529  buf_ts = buf.timestamp;
530 
531  if (buf.index >= s->buffers) {
532  av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n");
533  return AVERROR(EINVAL);
534  }
535  atomic_fetch_add(&s->buffers_queued, -1);
536  // always keep at least one buffer queued
537  av_assert0(atomic_load(&s->buffers_queued) >= 1);
538 
539 #ifdef V4L2_BUF_FLAG_ERROR
540  if (buf.flags & V4L2_BUF_FLAG_ERROR) {
542  "Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",
543  buf.bytesused);
544  buf.bytesused = 0;
545  } else
546 #endif
547  {
548  /* CPIA is a compressed format and we don't know the exact number of bytes
549  * used by a frame, so set it here as the driver announces it. */
551  s->frame_size = buf.bytesused;
552 
553  if (s->frame_size > 0 && buf.bytesused != s->frame_size) {
555  "Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",
556  buf.bytesused, s->frame_size, buf.flags);
557  buf.bytesused = 0;
558  }
559  }
560 
561  /* Image is at s->buff_start[buf.index] */
562  if (atomic_load(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {
563  /* when we start getting low on queued buffers, fall back on copying data */
564  res = av_new_packet(pkt, buf.bytesused);
565  if (res < 0) {
566  av_log(ctx, AV_LOG_ERROR, "Error allocating a packet.\n");
567  enqueue_buffer(s, &buf);
568  return res;
569  }
570  memcpy(pkt->data, s->buf_start[buf.index], buf.bytesused);
571 
572  res = enqueue_buffer(s, &buf);
573  if (res) {
575  return res;
576  }
577  } else {
578  struct buff_data *buf_descriptor;
579 
580  pkt->data = s->buf_start[buf.index];
581  pkt->size = buf.bytesused;
582 
583  buf_descriptor = av_malloc(sizeof(struct buff_data));
584  if (!buf_descriptor) {
585  /* Something went wrong... Since av_malloc() failed, we cannot even
586  * allocate a buffer for memcpying into it
587  */
588  av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");
589  enqueue_buffer(s, &buf);
590 
591  return AVERROR(ENOMEM);
592  }
593  buf_descriptor->index = buf.index;
594  buf_descriptor->s = s;
595 
597  buf_descriptor, 0);
598  if (!pkt->buf) {
599  av_log(ctx, AV_LOG_ERROR, "Failed to create a buffer\n");
600  enqueue_buffer(s, &buf);
601  av_freep(&buf_descriptor);
602  return AVERROR(ENOMEM);
603  }
604  }
605  pkt->pts = buf_ts.tv_sec * INT64_C(1000000) + buf_ts.tv_usec;
607 
608  return pkt->size;
609 }
610 
612 {
613  struct video_data *s = ctx->priv_data;
614  enum v4l2_buf_type type;
615  int i, res;
616 
617  for (i = 0; i < s->buffers; i++) {
618  struct v4l2_buffer buf = {
619  .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
620  .index = i,
621  .memory = V4L2_MEMORY_MMAP
622  };
623 
624  if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) < 0) {
625  res = AVERROR(errno);
626  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n",
627  av_err2str(res));
628  return res;
629  }
630  }
631  atomic_store(&s->buffers_queued, s->buffers);
632 
633  type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
634  if (v4l2_ioctl(s->fd, VIDIOC_STREAMON, &type) < 0) {
635  res = AVERROR(errno);
636  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n",
637  av_err2str(res));
638  return res;
639  }
640 
641  return 0;
642 }
643 
644 static void mmap_close(struct video_data *s)
645 {
646  enum v4l2_buf_type type;
647  int i;
648 
649  type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
650  /* We do not check for the result, because we could
651  * not do anything about it anyway...
652  */
653  v4l2_ioctl(s->fd, VIDIOC_STREAMOFF, &type);
654  for (i = 0; i < s->buffers; i++) {
655  v4l2_munmap(s->buf_start[i], s->buf_len[i]);
656  }
657  av_freep(&s->buf_start);
658  av_freep(&s->buf_len);
659 }
660 
662 {
663  struct video_data *s = ctx->priv_data;
664  struct v4l2_standard standard = { 0 };
665  struct v4l2_streamparm streamparm = { 0 };
666  struct v4l2_fract *tpf;
667  AVRational framerate_q = { 0 };
668  int i, ret;
669 
670  if (s->framerate &&
671  (ret = av_parse_video_rate(&framerate_q, s->framerate)) < 0) {
672  av_log(ctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n",
673  s->framerate);
674  return ret;
675  }
676 
677  if (s->standard) {
678  if (s->std_id) {
679  ret = 0;
680  av_log(ctx, AV_LOG_DEBUG, "Setting standard: %s\n", s->standard);
681  /* set tv standard */
682  for (i = 0; ; i++) {
683  standard.index = i;
684  if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
685  ret = AVERROR(errno);
686  break;
687  }
688  if (!av_strcasecmp(standard.name, s->standard))
689  break;
690  }
691  if (ret < 0) {
692  av_log(ctx, AV_LOG_ERROR, "Unknown or unsupported standard '%s'\n", s->standard);
693  return ret;
694  }
695 
696  if (v4l2_ioctl(s->fd, VIDIOC_S_STD, &standard.id) < 0) {
697  ret = AVERROR(errno);
698  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_STD): %s\n", av_err2str(ret));
699  return ret;
700  }
701  } else {
703  "This device does not support any standard\n");
704  }
705  }
706 
707  /* get standard */
708  if (v4l2_ioctl(s->fd, VIDIOC_G_STD, &s->std_id) == 0) {
709  tpf = &standard.frameperiod;
710  for (i = 0; ; i++) {
711  standard.index = i;
712  if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
713  ret = AVERROR(errno);
714  if (ret == AVERROR(EINVAL)
715 #ifdef ENODATA
716  || ret == AVERROR(ENODATA)
717 #endif
718  ) {
719  tpf = &streamparm.parm.capture.timeperframe;
720  break;
721  }
722  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));
723  return ret;
724  }
725  if (standard.id == s->std_id) {
727  "Current standard: %s, id: %"PRIx64", frameperiod: %d/%d\n",
728  standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator);
729  break;
730  }
731  }
732  } else {
733  tpf = &streamparm.parm.capture.timeperframe;
734  }
735 
736  streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
737  if (v4l2_ioctl(s->fd, VIDIOC_G_PARM, &streamparm) < 0) {
738  ret = AVERROR(errno);
739  av_log(ctx, AV_LOG_WARNING, "ioctl(VIDIOC_G_PARM): %s\n", av_err2str(ret));
740  } else if (framerate_q.num && framerate_q.den) {
741  if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
742  tpf = &streamparm.parm.capture.timeperframe;
743 
744  av_log(ctx, AV_LOG_DEBUG, "Setting time per frame to %d/%d\n",
745  framerate_q.den, framerate_q.num);
746  tpf->numerator = framerate_q.den;
747  tpf->denominator = framerate_q.num;
748 
749  if (v4l2_ioctl(s->fd, VIDIOC_S_PARM, &streamparm) < 0) {
750  ret = AVERROR(errno);
751  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_PARM): %s\n",
752  av_err2str(ret));
753  return ret;
754  }
755 
756  if (framerate_q.num != tpf->denominator ||
757  framerate_q.den != tpf->numerator) {
759  "The driver changed the time per frame from "
760  "%d/%d to %d/%d\n",
761  framerate_q.den, framerate_q.num,
762  tpf->numerator, tpf->denominator);
763  }
764  } else {
766  "The driver does not permit changing the time per frame\n");
767  }
768  }
769  if (tpf->denominator > 0 && tpf->numerator > 0) {
770  ctx->streams[0]->avg_frame_rate.num = tpf->denominator;
771  ctx->streams[0]->avg_frame_rate.den = tpf->numerator;
773  } else
774  av_log(ctx, AV_LOG_WARNING, "Time per frame unknown\n");
775 
776  return 0;
777 }
778 
780  enum AVPixelFormat pix_fmt,
781  int *width,
782  int *height,
783  uint32_t *desired_format,
784  enum AVCodecID *codec_id)
785 {
786  int ret, i;
787 
788  *desired_format = ff_fmt_ff2v4l(pix_fmt, ctx->video_codec_id);
789 
790  if (*desired_format) {
791  ret = device_init(ctx, width, height, *desired_format);
792  if (ret < 0) {
793  *desired_format = 0;
794  if (ret != AVERROR(EINVAL))
795  return ret;
796  }
797  }
798 
799  if (!*desired_format) {
803  av_log(ctx, AV_LOG_DEBUG, "Trying to set codec:%s pix_fmt:%s\n",
805  (char *)av_x_if_null(av_get_pix_fmt_name(ff_fmt_conversion_table[i].ff_fmt), "none"));
806 
807  *desired_format = ff_fmt_conversion_table[i].v4l2_fmt;
808  ret = device_init(ctx, width, height, *desired_format);
809  if (ret >= 0)
810  break;
811  else if (ret != AVERROR(EINVAL))
812  return ret;
813  *desired_format = 0;
814  }
815  }
816 
817  if (*desired_format == 0) {
818  av_log(ctx, AV_LOG_ERROR, "Cannot find a proper format for "
819  "codec '%s' (id %d), pixel format '%s' (id %d)\n",
821  (char *)av_x_if_null(av_get_pix_fmt_name(pix_fmt), "none"), pix_fmt);
822  ret = AVERROR(EINVAL);
823  }
824  }
825 
826  *codec_id = ff_fmt_v4l2codec(*desired_format);
827  if (*codec_id == AV_CODEC_ID_NONE)
828  av_assert0(ret == AVERROR(EINVAL));
829  return ret;
830 }
831 
832 static int v4l2_read_probe(const AVProbeData *p)
833 {
834  if (av_strstart(p->filename, "/dev/video", NULL))
835  return AVPROBE_SCORE_MAX - 1;
836  return 0;
837 }
838 
840 {
841  struct video_data *s = ctx->priv_data;
842  AVStream *st;
843  int res = 0;
844  uint32_t desired_format;
847  struct v4l2_input input = { 0 };
848 
850  if (!st)
851  return AVERROR(ENOMEM);
852 
853 #if CONFIG_LIBV4L2
854  /* silence libv4l2 logging. if fopen() fails v4l2_log_file will be NULL
855  and errors will get sent to stderr */
856  if (s->use_libv4l2)
857  v4l2_log_file = fopen("/dev/null", "w");
858 #endif
859 
860  s->fd = device_open(ctx, ctx->url);
861  if (s->fd < 0)
862  return s->fd;
863 
864  if (s->channel != -1) {
865  /* set video input */
866  av_log(ctx, AV_LOG_DEBUG, "Selecting input_channel: %d\n", s->channel);
867  if (v4l2_ioctl(s->fd, VIDIOC_S_INPUT, &s->channel) < 0) {
868  res = AVERROR(errno);
869  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_INPUT): %s\n", av_err2str(res));
870  goto fail;
871  }
872  } else {
873  /* get current video input */
874  if (v4l2_ioctl(s->fd, VIDIOC_G_INPUT, &s->channel) < 0) {
875  res = AVERROR(errno);
876  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_INPUT): %s\n", av_err2str(res));
877  goto fail;
878  }
879  }
880 
881  /* enum input */
882  input.index = s->channel;
883  if (v4l2_ioctl(s->fd, VIDIOC_ENUMINPUT, &input) < 0) {
884  res = AVERROR(errno);
885  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMINPUT): %s\n", av_err2str(res));
886  goto fail;
887  }
888  s->std_id = input.std;
889  av_log(ctx, AV_LOG_DEBUG, "Current input_channel: %d, input_name: %s, input_std: %"PRIx64"\n",
890  s->channel, input.name, (uint64_t)input.std);
891 
892  if (s->list_format) {
893  list_formats(ctx, s->list_format);
894  res = AVERROR_EXIT;
895  goto fail;
896  }
897 
898  if (s->list_standard) {
900  res = AVERROR_EXIT;
901  goto fail;
902  }
903 
904  avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
905 
906  if (s->pixel_format) {
907  const AVCodecDescriptor *desc = avcodec_descriptor_get_by_name(s->pixel_format);
908 
909  if (desc)
910  ctx->video_codec_id = desc->id;
911 
912  pix_fmt = av_get_pix_fmt(s->pixel_format);
913 
914  if (pix_fmt == AV_PIX_FMT_NONE && !desc) {
915  av_log(ctx, AV_LOG_ERROR, "No such input format: %s.\n",
916  s->pixel_format);
917 
918  res = AVERROR(EINVAL);
919  goto fail;
920  }
921  }
922 
923  if (!s->width && !s->height) {
924  struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
925 
927  "Querying the device for the current frame size\n");
928  if (v4l2_ioctl(s->fd, VIDIOC_G_FMT, &fmt) < 0) {
929  res = AVERROR(errno);
930  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n",
931  av_err2str(res));
932  goto fail;
933  }
934 
935  s->width = fmt.fmt.pix.width;
936  s->height = fmt.fmt.pix.height;
938  "Setting frame size to %dx%d\n", s->width, s->height);
939  }
940 
941  res = device_try_init(ctx, pix_fmt, &s->width, &s->height, &desired_format, &codec_id);
942  if (res < 0)
943  goto fail;
944 
945  /* If no pixel_format was specified, the codec_id was not known up
946  * until now. Set video_codec_id in the context, as codec_id will
947  * not be available outside this function
948  */
951 
952  if ((res = av_image_check_size(s->width, s->height, 0, ctx)) < 0)
953  goto fail;
954 
955  s->pixelformat = desired_format;
956 
957  if ((res = v4l2_set_parameters(ctx)) < 0)
958  goto fail;
959 
960  st->codecpar->format = ff_fmt_v4l2ff(desired_format, codec_id);
961  if (st->codecpar->format != AV_PIX_FMT_NONE)
962  s->frame_size = av_image_get_buffer_size(st->codecpar->format,
963  s->width, s->height, 1);
964 
965  if ((res = mmap_init(ctx)) ||
966  (res = mmap_start(ctx)) < 0)
967  goto fail;
968 
969  s->top_field_first = first_field(s);
970 
972  st->codecpar->codec_id = codec_id;
974  st->codecpar->codec_tag =
976  else if (codec_id == AV_CODEC_ID_H264) {
978  }
979  if (desired_format == V4L2_PIX_FMT_YVU420)
980  st->codecpar->codec_tag = MKTAG('Y', 'V', '1', '2');
981  else if (desired_format == V4L2_PIX_FMT_YVU410)
982  st->codecpar->codec_tag = MKTAG('Y', 'V', 'U', '9');
983  st->codecpar->width = s->width;
984  st->codecpar->height = s->height;
985  if (st->avg_frame_rate.den)
986  st->codecpar->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8;
987 
988  return 0;
989 
990 fail:
991  v4l2_close(s->fd);
992  return res;
993 }
994 
996 {
997  int res;
998 
999  if ((res = mmap_read_frame(ctx, pkt)) < 0) {
1000  return res;
1001  }
1002 
1003  return pkt->size;
1004 }
1005 
1007 {
1008  struct video_data *s = ctx->priv_data;
1009 
1010  if (atomic_load(&s->buffers_queued) != s->buffers)
1011  av_log(ctx, AV_LOG_WARNING, "Some buffers are still owned by the caller on "
1012  "close.\n");
1013 
1014  mmap_close(s);
1015 
1016  ff_timefilter_destroy(s->timefilter);
1017  v4l2_close(s->fd);
1018  return 0;
1019 }
1020 
1021 static int v4l2_is_v4l_dev(const char *name)
1022 {
1023  return !strncmp(name, "video", 5) ||
1024  !strncmp(name, "radio", 5) ||
1025  !strncmp(name, "vbi", 3) ||
1026  !strncmp(name, "v4l-subdev", 10);
1027 }
1028 
1030 {
1031  struct video_data *s = ctx->priv_data;
1032  DIR *dir;
1033  struct dirent *entry;
1034  int ret = 0;
1035 
1036  if (!device_list)
1037  return AVERROR(EINVAL);
1038 
1039  dir = opendir("/dev");
1040  if (!dir) {
1041  ret = AVERROR(errno);
1042  av_log(ctx, AV_LOG_ERROR, "Couldn't open the directory: %s\n", av_err2str(ret));
1043  return ret;
1044  }
1045  while ((entry = readdir(dir))) {
1046  AVDeviceInfo *device = NULL;
1047  struct v4l2_capability cap;
1048  int fd = -1, size;
1049  char device_name[256];
1050 
1051  if (!v4l2_is_v4l_dev(entry->d_name))
1052  continue;
1053 
1054  size = snprintf(device_name, sizeof(device_name), "/dev/%s", entry->d_name);
1055  if (size >= sizeof(device_name)) {
1056  av_log(ctx, AV_LOG_ERROR, "Device name too long.\n");
1057  ret = AVERROR(ENOSYS);
1058  break;
1059  }
1060 
1061  if ((fd = device_open(ctx, device_name)) < 0)
1062  continue;
1063 
1064  if (v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
1065  ret = AVERROR(errno);
1066  av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n", av_err2str(ret));
1067  goto fail;
1068  }
1069 
1070  device = av_mallocz(sizeof(AVDeviceInfo));
1071  if (!device) {
1072  ret = AVERROR(ENOMEM);
1073  goto fail;
1074  }
1075  device->device_name = av_strdup(device_name);
1076  device->device_description = av_strdup(cap.card);
1077  if (!device->device_name || !device->device_description) {
1078  ret = AVERROR(ENOMEM);
1079  goto fail;
1080  }
1081 
1082  if ((ret = av_dynarray_add_nofree(&device_list->devices,
1083  &device_list->nb_devices, device)) < 0)
1084  goto fail;
1085 
1086  v4l2_close(fd);
1087  continue;
1088 
1089  fail:
1090  if (device) {
1091  av_freep(&device->device_name);
1092  av_freep(&device->device_description);
1093  av_freep(&device);
1094  }
1095  v4l2_close(fd);
1096  break;
1097  }
1098  closedir(dir);
1099  return ret;
1100 }
1101 
1102 #define OFFSET(x) offsetof(struct video_data, x)
1103 #define DEC AV_OPT_FLAG_DECODING_PARAM
1104 
1105 static const AVOption options[] = {
1106  { "standard", "set TV standard, used only by analog frame grabber", OFFSET(standard), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC },
1107  { "channel", "set TV channel, used only by frame grabber", OFFSET(channel), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, DEC },
1108  { "video_size", "set frame size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC },
1109  { "pixel_format", "set preferred pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
1110  { "input_format", "set preferred pixel format (for raw video) or codec name", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
1111  { "framerate", "set frame rate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
1112 
1113  { "list_formats", "list available formats and exit", OFFSET(list_format), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC, .unit = "list_formats" },
1114  { "all", "show all available formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_ALLFORMATS }, 0, INT_MAX, DEC, .unit = "list_formats" },
1115  { "raw", "show only non-compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_RAWFORMATS }, 0, INT_MAX, DEC, .unit = "list_formats" },
1116  { "compressed", "show only compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_COMPFORMATS }, 0, INT_MAX, DEC, .unit = "list_formats" },
1117 
1118  { "list_standards", "list supported standards and exit", OFFSET(list_standard), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, DEC, .unit = "list_standards" },
1119  { "all", "show all supported standards", OFFSET(list_standard), AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, DEC, .unit = "list_standards" },
1120 
1121  { "timestamps", "set type of timestamps for grabbed frames", OFFSET(ts_mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, .unit = "timestamps" },
1122  { "ts", "set type of timestamps for grabbed frames", OFFSET(ts_mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, .unit = "timestamps" },
1123  { "default", "use timestamps from the kernel", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_DEFAULT }, 0, 2, DEC, .unit = "timestamps" },
1124  { "abs", "use absolute timestamps (wall clock)", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_ABS }, 0, 2, DEC, .unit = "timestamps" },
1125  { "mono2abs", "force conversion from monotonic to absolute timestamps", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_MONO2ABS }, 0, 2, DEC, .unit = "timestamps" },
1126  { "use_libv4l2", "use libv4l2 (v4l-utils) conversion functions", OFFSET(use_libv4l2), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },
1127  { NULL },
1128 };
1129 
1130 static const AVClass v4l2_class = {
1131  .class_name = "V4L2 indev",
1132  .item_name = av_default_item_name,
1133  .option = options,
1134  .version = LIBAVUTIL_VERSION_INT,
1136 };
1137 
1139  .p.name = "video4linux2,v4l2",
1140  .p.long_name = NULL_IF_CONFIG_SMALL("Video4Linux2 device grab"),
1141  .p.flags = AVFMT_NOFILE,
1142  .p.priv_class = &v4l2_class,
1143  .priv_data_size = sizeof(struct video_data),
1145  .read_header = v4l2_read_header,
1146  .read_packet = v4l2_read_packet,
1147  .read_close = v4l2_read_close,
1148  .get_device_list = v4l2_get_device_list,
1149 };
ff_v4l2_demuxer
const FFInputFormat ff_v4l2_demuxer
Definition: v4l2.c:1138
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
TimeFilter
Opaque type representing a time filter state.
Definition: timefilter.c:34
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
entry
#define entry
Definition: aom_film_grain_template.c:66
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
video_data::channel
int channel
Definition: v4l2.c:101
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
v4l2_class
static const AVClass v4l2_class
Definition: v4l2.c:1130
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
v4l2_set_parameters
static int v4l2_set_parameters(AVFormatContext *ctx)
Definition: v4l2.c:661
AVDeviceInfo::device_name
char * device_name
device name, format depends on device
Definition: avdevice.h:334
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
AVDeviceInfoList::nb_devices
int nb_devices
number of autodetected devices
Definition: avdevice.h:345
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
AVPacket::data
uint8_t * data
Definition: packet.h:524
video_data::buffers
int buffers
Definition: v4l2.c:95
AVOption
AVOption.
Definition: opt.h:357
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
video_data::interlaced
int interlaced
Definition: v4l2.c:89
data
const char data[16]
Definition: mxf.c:148
mmap_init
static int mmap_init(AVFormatContext *ctx)
Definition: v4l2.c:350
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFormatContext::video_codec_id
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1462
video_data::ioctl_f
int(* ioctl_f)(int fd, unsigned long int request,...)
Definition: v4l2.c:114
video_data::width
int width
Definition: v4l2.c:87
ff_fmt_ff2v4l
uint32_t ff_fmt_ff2v4l(enum AVPixelFormat pix_fmt, enum AVCodecID codec_id)
Definition: v4l2-common.c:73
ff_fmt_conversion_table
const struct fmt_map ff_fmt_conversion_table[]
Definition: v4l2-common.c:21
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
avcodec_pix_fmt_to_codec_tag
unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt)
Return a value representing the fourCC code associated to the pixel format pix_fmt,...
Definition: raw.c:308
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:853
ff_timefilter_eval
double ff_timefilter_eval(TimeFilter *self, double delta)
Evaluate the filter at a specified time.
Definition: timefilter.c:92
fail
#define fail()
Definition: checkasm.h:182
AVSTREAM_PARSE_FULL_ONCE
@ AVSTREAM_PARSE_FULL_ONCE
full parsing and repack of the first frame only, only implemented for H.264 currently
Definition: avformat.h:596
ff_fmt_v4l2codec
enum AVCodecID ff_fmt_v4l2codec(uint32_t v4l2_fmt)
Definition: v4l2-common.c:103
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
video_data::framerate
char * framerate
Set by a private option.
Definition: v4l2.c:105
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_timefilter_new
TimeFilter * ff_timefilter_new(double time_base, double period, double bandwidth)
Create a new Delay Locked Loop time filter.
Definition: timefilter.c:50
video_data::use_libv4l2
int use_libv4l2
Definition: v4l2.c:107
AVDeviceInfoList::devices
AVDeviceInfo ** devices
list of autodetected devices
Definition: avdevice.h:344
video_data::close_f
int(* close_f)(int fd)
Definition: v4l2.c:109
video_data::frame_size
int frame_size
Definition: v4l2.c:88
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
device_init
static int device_init(AVFormatContext *ctx, int *width, int *height, uint32_t pixelformat)
Definition: v4l2.c:205
width
#define width
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
video_data::buffers_queued
atomic_int buffers_queued
Definition: v4l2.c:96
video_data::buf_start
void ** buf_start
Definition: v4l2.c:97
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AVProbeData::filename
const char * filename
Definition: avformat.h:452
video_data::last_time_m
int64_t last_time_m
Definition: v4l2.c:93
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:392
v4l2-common.h
atomic_load
#define atomic_load(object)
Definition: stdatomic.h:93
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
E
#define E
Definition: avdct.c:33
video_data::ts_mode
int ts_mode
Definition: v4l2.c:91
v4l2_ioctl
#define v4l2_ioctl
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:507
framerate
float framerate
Definition: av1_levels.c:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
video_data::std_id
v4l2_std_id std_id
Definition: v4l2.c:100
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
timefilter.h
video_data::fd
int fd
Definition: v4l2.c:85
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
period
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
Definition: writing_filters.txt:89
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive ints
Definition: opt.h:255
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_CODEC_ID_CPIA
@ AV_CODEC_ID_CPIA
Definition: codec_id.h:261
buff_data
Definition: v4l2.c:121
v4l2_open
#define v4l2_open
ff_fmt_v4l2ff
enum AVPixelFormat ff_fmt_v4l2ff(uint32_t v4l2_fmt, enum AVCodecID codec_id)
Definition: v4l2-common.c:89
parseutils.h
V4L_RAWFORMATS
#define V4L_RAWFORMATS
Definition: v4l2.c:58
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
fmt_map::v4l2_fmt
uint32_t v4l2_fmt
Definition: v4l2-common.h:44
video_data::height
int height
Definition: v4l2.c:87
time.h
AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
Definition: log.h:41
video_data::open_f
int(* open_f)(const char *file, int oflag,...)
Definition: v4l2.c:108
v4l2_close
#define v4l2_close
test::name
const char * name
Definition: idctdsp.c:36
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
device_open
static int device_open(AVFormatContext *ctx, const char *device_path)
Definition: v4l2.c:126
mmap_release_buffer
static void mmap_release_buffer(void *opaque, uint8_t *data)
Definition: v4l2.c:430
init_convert_timestamp
static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts)
Definition: v4l2.c:451
v4l2_read_close
static int v4l2_read_close(AVFormatContext *ctx)
Definition: v4l2.c:1006
list_formats
static void list_formats(AVFormatContext *ctx, int type)
Definition: v4l2.c:288
v4l2_read_probe
static int v4l2_read_probe(const AVProbeData *p)
Definition: v4l2.c:832
V4L_COMPFORMATS
#define V4L_COMPFORMATS
Definition: v4l2.c:59
AVPacket::size
int size
Definition: packet.h:525
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1371
size
int size
Definition: twinvq_data.h:10344
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
AVDeviceInfo
Structure describes basic parameters of the device.
Definition: avdevice.h:333
avdevice.h
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
DEC
#define DEC
Definition: v4l2.c:1103
height
#define height
av_image_get_buffer_size
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
video_data::pixelformat
int pixelformat
Definition: v4l2.c:86
v4l2_mmap
#define v4l2_mmap
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
AVDeviceInfo::device_description
char * device_description
human friendly name
Definition: avdevice.h:335
fmt_map::codec_id
enum AVCodecID codec_id
Definition: v4l2-common.h:43
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
buff_data::index
int index
Definition: v4l2.c:123
avpriv_stream_set_need_parsing
void avpriv_stream_set_need_parsing(AVStream *st, enum AVStreamParseType type)
Definition: demux_utils.c:37
video_data::timefilter
TimeFilter * timefilter
Definition: v4l2.c:92
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
av_parse_video_rate
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:181
ff_timefilter_destroy
void ff_timefilter_destroy(TimeFilter *self)
Free all resources associated with the filter.
Definition: timefilter.c:66
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
mmap_close
static void mmap_close(struct video_data *s)
Definition: v4l2.c:644
v4l2_is_v4l_dev
static int v4l2_is_v4l_dev(const char *name)
Definition: v4l2.c:1021
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
v4l2_munmap
#define v4l2_munmap
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
options
static const AVOption options[]
Definition: v4l2.c:1105
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
ff_timefilter_update
double ff_timefilter_update(TimeFilter *self, double system_time, double period)
Update the filter.
Definition: timefilter.c:76
demux.h
OFFSET
#define OFFSET(x)
Definition: v4l2.c:1102
V4L_TS_CONVERT_READY
#define V4L_TS_CONVERT_READY
Once the kind of timestamps returned by the kernel have been detected, the value of the timefilter (N...
Definition: v4l2.c:81
AVFMT_FLAG_NONBLOCK
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1409
v4l2_get_device_list
static int v4l2_get_device_list(AVFormatContext *ctx, AVDeviceInfoList *device_list)
Definition: v4l2.c:1029
avcodec.h
V4L_TS_MONO2ABS
#define V4L_TS_MONO2ABS
Assume kernel timestamps are from the monotonic clock and convert to absolute timestamps.
Definition: v4l2.c:74
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
video_data::read_f
ssize_t(* read_f)(int fd, void *buffer, size_t n)
Definition: v4l2.c:116
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
video_data
Definition: v4l2.c:83
AVDeviceInfoList
List of devices.
Definition: avdevice.h:343
video_data::top_field_first
int top_field_first
Definition: v4l2.c:90
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2897
V4L_ALLFORMATS
#define V4L_ALLFORMATS
Definition: v4l2.c:57
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:315
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
video_data::list_format
int list_format
Set by a private option.
Definition: v4l2.c:103
atomic_fetch_add
#define atomic_fetch_add(object, operand)
Definition: stdatomic.h:131
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
video_data::list_standard
int list_standard
Set by a private option.
Definition: v4l2.c:104
convert_timestamp
static int convert_timestamp(AVFormatContext *ctx, int64_t *ts)
Definition: v4l2.c:484
video_data::pixel_format
char * pixel_format
Set by a private option.
Definition: v4l2.c:102
video_data::munmap_f
int(* munmap_f)(void *_start, size_t length)
Definition: v4l2.c:118
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
video_data::buf_len
unsigned int * buf_len
Definition: v4l2.c:98
buff_data::s
struct video_data * s
Definition: v4l2.c:122
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
SET_WRAPPERS
#define SET_WRAPPERS(prefix)
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
video_data::standard
char * standard
Definition: v4l2.c:99
mem.h
v4l2_read_header
static int v4l2_read_header(AVFormatContext *ctx)
Definition: v4l2.c:839
mmap_start
static int mmap_start(AVFormatContext *ctx)
Definition: v4l2.c:611
AVCodecParameters::format
int format
Definition: codec_par.h:92
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
list_standards
static void list_standards(AVFormatContext *ctx)
Definition: v4l2.c:326
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
FFInputFormat
Definition: demux.h:37
v4l2_read_packet
static int v4l2_read_packet(AVFormatContext *ctx, AVPacket *pkt)
Definition: v4l2.c:995
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
video_data::dup_f
int(* dup_f)(int fd)
Definition: v4l2.c:110
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
V4L_TS_DEFAULT
#define V4L_TS_DEFAULT
Return timestamps to the user exactly as returned by the kernel.
Definition: v4l2.c:64
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3735
avstring.h
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:249
avcodec_descriptor_get_by_name
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3750
codec_desc.h
int
int
Definition: ffmpeg_filter.c:424
first_field
static int first_field(const struct video_data *s)
Definition: v4l2.c:247
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
snprintf
#define snprintf
Definition: snprintf.h:34
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
V4L_TS_ABS
#define V4L_TS_ABS
Autodetect the kind of timestamps returned by the kernel and convert to absolute (wall clock) timesta...
Definition: v4l2.c:69
channel
channel
Definition: ebur128.h:39
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:312
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2885
enqueue_buffer
static int enqueue_buffer(struct video_data *s, struct v4l2_buffer *buf)
Definition: v4l2.c:416
mmap_read_frame
static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
Definition: v4l2.c:505
desired_video_buffers
static const int desired_video_buffers
Definition: v4l2.c:55
device_try_init
static int device_try_init(AVFormatContext *ctx, enum AVPixelFormat pix_fmt, int *width, int *height, uint32_t *desired_format, enum AVCodecID *codec_id)
Definition: v4l2.c:779