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