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