41 #define V4L_ALLFORMATS 3
42 #define V4L_RAWFORMATS 1
43 #define V4L_COMPFORMATS 2
48 #define V4L_TS_DEFAULT 0
58 #define V4L_TS_MONO2ABS 2
65 #define V4L_TS_CONVERT_READY V4L_TS_DEFAULT
92 int (*
open_f)(
const char *file,
int oflag, ...);
95 int (*
ioctl_f)(
int fd,
unsigned long int request, ...);
109 struct v4l2_capability cap;
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; \
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
155 if (
v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
163 fd, cap.capabilities);
165 if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
171 if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
173 "The device does not support the streaming I/O method.\n");
189 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
190 struct v4l2_pix_format *pix = &fmt.fmt.pix;
196 pix->field = V4L2_FIELD_ANY;
201 if ((*width != fmt.fmt.pix.width) || (*height != fmt.fmt.pix.height)) {
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;
209 if (pix_fmt != fmt.fmt.pix.pixelformat) {
211 "The V4L2 driver changed the pixel format "
212 "from 0x%08X to 0x%08X\n",
213 pix_fmt, fmt.fmt.pix.pixelformat);
217 if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED) {
219 "The V4L2 driver is using the interlaced mode\n");
234 if (std & V4L2_STD_NTSC)
240 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
241 static void list_framesizes(
AVFormatContext *ctx, uint32_t pixelformat)
244 struct v4l2_frmsizeenum vfse = { .pixel_format = pixelformat };
246 while(!
v4l2_ioctl(s->
fd, VIDIOC_ENUM_FRAMESIZES, &vfse)) {
248 case V4L2_FRMSIZE_TYPE_DISCRETE:
250 vfse.discrete.width, vfse.discrete.height);
252 case V4L2_FRMSIZE_TYPE_CONTINUOUS:
253 case V4L2_FRMSIZE_TYPE_STEPWISE:
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);
270 struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
278 if (!(vfd.flags & V4L2_FMT_FLAG_COMPRESSED) &&
282 fmt_name ? fmt_name :
"Unsupported",
284 }
else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&
288 codec ? codec->
name :
"Unsupported",
294 #ifdef V4L2_FMT_FLAG_EMULATED
295 if (vfd.flags & V4L2_FMT_FLAG_EMULATED)
298 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
299 list_framesizes(ctx, vfd.pixelformat);
309 struct v4l2_standard standard;
314 for (standard.index = 0; ; standard.index++) {
325 standard.index, (uint64_t)standard.id, standard.name);
333 struct v4l2_requestbuffers req = {
334 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
336 .memory = V4L2_MEMORY_MMAP
362 for (i = 0; i < req.count; i++) {
363 struct v4l2_buffer buf = {
364 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
366 .memory = V4L2_MEMORY_MMAP
377 "buf_len[%d] = %d < expected frame size %d\n",
382 PROT_READ | PROT_WRITE, MAP_SHARED,
383 s->
fd, buf.m.offset);
395 #if FF_API_DESTRUCT_PACKET
418 struct v4l2_buffer buf = { 0 };
419 struct buff_data *buf_descriptor = opaque;
422 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
423 buf.memory = V4L2_MEMORY_MMAP;
424 buf.index = buf_descriptor->
index;
430 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
431 static int64_t av_gettime_monotonic(
void)
444 ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 *
AV_TIME_BASE) {
449 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
451 now = av_gettime_monotonic();
453 (ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 *
AV_TIME_BASE)) {
479 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
482 int64_t nowm = av_gettime_monotonic();
494 struct v4l2_buffer buf = {
495 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
496 .memory = V4L2_MEMORY_MMAP
501 while ((res =
v4l2_ioctl(s->
fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
503 if (errno == EAGAIN) {
528 "The v4l2 frame is %d bytes, but %d bytes are expected\n",
554 pkt->
size = buf.bytesused;
555 #if FF_API_DESTRUCT_PACKET
557 pkt->
destruct = dummy_release_buffer;
562 if (!buf_descriptor) {
571 buf_descriptor->index = buf.index;
572 buf_descriptor->s =
s;
583 pkt->
pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;
592 enum v4l2_buf_type
type;
595 for (i = 0; i < s->
buffers; i++) {
596 struct v4l2_buffer buf = {
597 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
599 .memory = V4L2_MEMORY_MMAP
610 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
622 enum v4l2_buf_type
type;
625 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
630 for (i = 0; i < s->
buffers; i++) {
640 struct v4l2_standard standard = { 0 };
641 struct v4l2_streamparm streamparm = { 0 };
642 struct v4l2_fract *tpf;
672 if (
v4l2_ioctl(s->
fd, VIDIOC_S_STD, &standard.id) < 0) {
679 "This device does not support any standard\n");
685 tpf = &standard.frameperiod;
695 tpf = &streamparm.parm.capture.timeperframe;
701 if (standard.id == s->
std_id) {
703 "Current standard: %s, id: %"PRIx64
", frameperiod: %d/%d\n",
704 standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator);
709 tpf = &streamparm.parm.capture.timeperframe;
712 streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
713 if (
v4l2_ioctl(s->
fd, VIDIOC_G_PARM, &streamparm) < 0) {
719 if (framerate_q.
num && framerate_q.
den) {
720 if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
721 tpf = &streamparm.parm.capture.timeperframe;
724 framerate_q.
den, framerate_q.
num);
725 tpf->numerator = framerate_q.
den;
726 tpf->denominator = framerate_q.
num;
728 if (
v4l2_ioctl(s->
fd, VIDIOC_S_PARM, &streamparm) < 0) {
734 if (framerate_q.
num != tpf->denominator ||
735 framerate_q.
den != tpf->numerator) {
737 "The driver changed the time per frame from "
739 framerate_q.
den, framerate_q.
num,
740 tpf->numerator, tpf->denominator);
744 "The driver does not allow to change time per frame\n");
747 if (tpf->denominator > 0 && tpf->numerator > 0) {
761 uint32_t *desired_format,
768 if (*desired_format) {
769 ret =
device_init(ctx, width, height, *desired_format);
777 if (!*desired_format) {
786 ret =
device_init(ctx, width, height, *desired_format);
789 else if (ret !=
AVERROR(EINVAL))
795 if (*desired_format == 0) {
797 "codec '%s' (id %d), pixel format '%s' (id %d)\n",
814 uint32_t desired_format;
817 struct v4l2_input input = { 0 };
827 v4l2_log_file = fopen(
"/dev/null",
"w");
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);
897 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
900 "Querying the device for the current frame size\n");
907 s->
width = fmt.fmt.pix.width;
908 s->
height = fmt.fmt.pix.height;
910 "Setting frame size to %dx%d\n", s->
width, s->
height);
947 if (desired_format == V4L2_PIX_FMT_YVU420)
949 else if (desired_format == V4L2_PIX_FMT_YVU410)
996 #define OFFSET(x) offsetof(struct video_data, x)
997 #define DEC AV_OPT_FLAG_DECODING_PARAM
1033 .
name =
"video4linux2,v4l2",