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