2 * Video4Linux2 grab interface
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2006 Luca Abeni.
6 * Part of this file is based on the V4L2 video capture example
7 * (http://v4l2spec.bytesex.org/v4l2spec/capture.c)
9 * Thanks to Michael Niedermayer for providing the mapping between
10 * V4L2_PIX_FMT_* and PIX_FMT_*
13 * This file is part of FFmpeg.
15 * FFmpeg is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2.1 of the License, or (at your option) any later version.
20 * FFmpeg is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with FFmpeg; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #undef __STRICT_ANSI__ //workaround due to broken kernel headers
32 #include "libavformat/avformat.h"
35 #include <sys/ioctl.h>
38 #include <asm/types.h>
39 #include <linux/videodev2.h>
43 static const int desired_video_buffers
= 256;
53 int frame_format
; /* V4L2_PIX_FMT_* */
54 enum io_method io_method
;
63 unsigned int *buf_len
;
72 enum PixelFormat ff_fmt
;
76 static struct fmt_map fmt_conversion_table
[] = {
78 .ff_fmt
= PIX_FMT_YUV420P
,
79 .v4l2_fmt
= V4L2_PIX_FMT_YUV420
,
82 .ff_fmt
= PIX_FMT_YUV422P
,
83 .v4l2_fmt
= V4L2_PIX_FMT_YUV422P
,
86 .ff_fmt
= PIX_FMT_YUYV422
,
87 .v4l2_fmt
= V4L2_PIX_FMT_YUYV
,
90 .ff_fmt
= PIX_FMT_UYVY422
,
91 .v4l2_fmt
= V4L2_PIX_FMT_UYVY
,
94 .ff_fmt
= PIX_FMT_YUV411P
,
95 .v4l2_fmt
= V4L2_PIX_FMT_YUV411P
,
98 .ff_fmt
= PIX_FMT_YUV410P
,
99 .v4l2_fmt
= V4L2_PIX_FMT_YUV410
,
102 .ff_fmt
= PIX_FMT_BGR24
,
103 .v4l2_fmt
= V4L2_PIX_FMT_BGR24
,
106 .ff_fmt
= PIX_FMT_RGB24
,
107 .v4l2_fmt
= V4L2_PIX_FMT_RGB24
,
111 .ff_fmt = PIX_FMT_RGB32,
112 .v4l2_fmt = V4L2_PIX_FMT_BGR32,
116 .ff_fmt
= PIX_FMT_GRAY8
,
117 .v4l2_fmt
= V4L2_PIX_FMT_GREY
,
121 static int device_open(AVFormatContext
*ctx
, uint32_t *capabilities
)
123 struct v4l2_capability cap
;
128 if (ctx
->flags
& AVFMT_FLAG_NONBLOCK
) {
131 fd
= open(ctx
->filename
, flags
, 0);
133 av_log(ctx
, AV_LOG_ERROR
, "Cannot open video device %s : %s\n",
134 ctx
->filename
, strerror(errno
));
139 res
= ioctl(fd
, VIDIOC_QUERYCAP
, &cap
);
140 // ENOIOCTLCMD definition only availble on __KERNEL__
141 if (res
< 0 && errno
== 515)
143 av_log(ctx
, AV_LOG_ERROR
, "QUERYCAP not implemented, probably V4L device but not supporting V4L2\n");
149 av_log(ctx
, AV_LOG_ERROR
, "ioctl(VIDIOC_QUERYCAP): %s\n",
155 if ((cap
.capabilities
& V4L2_CAP_VIDEO_CAPTURE
) == 0) {
156 av_log(ctx
, AV_LOG_ERROR
, "Not a video capture device\n");
161 *capabilities
= cap
.capabilities
;
166 static int device_init(AVFormatContext
*ctx
, int *width
, int *height
, int pix_fmt
)
168 struct video_data
*s
= ctx
->priv_data
;
170 struct v4l2_format fmt
;
173 memset(&fmt
, 0, sizeof(struct v4l2_format
));
174 fmt
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
175 fmt
.fmt
.pix
.width
= *width
;
176 fmt
.fmt
.pix
.height
= *height
;
177 fmt
.fmt
.pix
.pixelformat
= pix_fmt
;
178 fmt
.fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
179 res
= ioctl(fd
, VIDIOC_S_FMT
, &fmt
);
180 if ((*width
!= fmt
.fmt
.pix
.width
) || (*height
!= fmt
.fmt
.pix
.height
)) {
181 av_log(ctx
, AV_LOG_INFO
, "The V4L2 driver changed the video from %dx%d to %dx%d\n", *width
, *height
, fmt
.fmt
.pix
.width
, fmt
.fmt
.pix
.height
);
182 *width
= fmt
.fmt
.pix
.width
;
183 *height
= fmt
.fmt
.pix
.height
;
189 static int first_field(int fd
)
194 res
= ioctl(fd
, VIDIOC_G_STD
, &std
);
198 if (std
& V4L2_STD_NTSC
) {
205 static uint32_t fmt_ff2v4l(enum PixelFormat pix_fmt
)
209 for (i
= 0; i
< sizeof(fmt_conversion_table
) / sizeof(struct fmt_map
); i
++) {
210 if (fmt_conversion_table
[i
].ff_fmt
== pix_fmt
) {
211 return fmt_conversion_table
[i
].v4l2_fmt
;
218 static enum PixelFormat
fmt_v4l2ff(uint32_t pix_fmt
)
222 for (i
= 0; i
< sizeof(fmt_conversion_table
) / sizeof(struct fmt_map
); i
++) {
223 if (fmt_conversion_table
[i
].v4l2_fmt
== pix_fmt
) {
224 return fmt_conversion_table
[i
].ff_fmt
;
231 static int mmap_init(AVFormatContext
*ctx
)
233 struct video_data
*s
= ctx
->priv_data
;
234 struct v4l2_requestbuffers req
;
237 memset(&req
, 0, sizeof(struct v4l2_requestbuffers
));
238 req
.count
= desired_video_buffers
;
239 req
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
240 req
.memory
= V4L2_MEMORY_MMAP
;
241 res
= ioctl (s
->fd
, VIDIOC_REQBUFS
, &req
);
243 if (errno
== EINVAL
) {
244 av_log(ctx
, AV_LOG_ERROR
, "Device does not support mmap\n");
246 av_log(ctx
, AV_LOG_ERROR
, "ioctl(VIDIOC_REQBUFS)\n");
253 av_log(ctx
, AV_LOG_ERROR
, "Insufficient buffer memory\n");
257 s
->buffers
= req
.count
;
258 s
->buf_start
= av_malloc(sizeof(void *) * s
->buffers
);
259 if (s
->buf_start
== NULL
) {
260 av_log(ctx
, AV_LOG_ERROR
, "Cannot allocate buffer pointers\n");
264 s
->buf_len
= av_malloc(sizeof(unsigned int) * s
->buffers
);
265 if (s
->buf_len
== NULL
) {
266 av_log(ctx
, AV_LOG_ERROR
, "Cannot allocate buffer sizes\n");
267 av_free(s
->buf_start
);
272 for (i
= 0; i
< req
.count
; i
++) {
273 struct v4l2_buffer buf
;
275 memset(&buf
, 0, sizeof(struct v4l2_buffer
));
276 buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
277 buf
.memory
= V4L2_MEMORY_MMAP
;
279 res
= ioctl (s
->fd
, VIDIOC_QUERYBUF
, &buf
);
281 av_log(ctx
, AV_LOG_ERROR
, "ioctl(VIDIOC_QUERYBUF)\n");
286 s
->buf_len
[i
] = buf
.length
;
287 if (s
->buf_len
[i
] < s
->frame_size
) {
288 av_log(ctx
, AV_LOG_ERROR
, "Buffer len [%d] = %d != %d\n", i
, s
->buf_len
[i
], s
->frame_size
);
292 s
->buf_start
[i
] = mmap (NULL
, buf
.length
,
293 PROT_READ
| PROT_WRITE
, MAP_SHARED
, s
->fd
, buf
.m
.offset
);
294 if (s
->buf_start
[i
] == MAP_FAILED
) {
295 av_log(ctx
, AV_LOG_ERROR
, "mmap: %s\n", strerror(errno
));
304 static int read_init(AVFormatContext
*ctx
)
309 static void mmap_release_buffer(AVPacket
*pkt
)
311 struct v4l2_buffer buf
;
313 struct buff_data
*buf_descriptor
= pkt
->priv
;
315 memset(&buf
, 0, sizeof(struct v4l2_buffer
));
316 buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
317 buf
.memory
= V4L2_MEMORY_MMAP
;
318 buf
.index
= buf_descriptor
->index
;
319 fd
= buf_descriptor
->fd
;
320 av_free(buf_descriptor
);
322 res
= ioctl (fd
, VIDIOC_QBUF
, &buf
);
324 av_log(NULL
, AV_LOG_ERROR
, "ioctl(VIDIOC_QBUF)\n");
330 static int mmap_read_frame(AVFormatContext
*ctx
, AVPacket
*pkt
)
332 struct video_data
*s
= ctx
->priv_data
;
333 struct v4l2_buffer buf
;
334 struct buff_data
*buf_descriptor
;
337 memset(&buf
, 0, sizeof(struct v4l2_buffer
));
338 buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
339 buf
.memory
= V4L2_MEMORY_MMAP
;
341 /* FIXME: Some special treatment might be needed in case of loss of signal... */
342 while ((res
= ioctl(s
->fd
, VIDIOC_DQBUF
, &buf
)) < 0 && (errno
== EINTR
));
344 if (errno
== EAGAIN
) {
347 return AVERROR(EAGAIN
);
349 av_log(ctx
, AV_LOG_ERROR
, "ioctl(VIDIOC_DQBUF): %s\n", strerror(errno
));
353 assert (buf
.index
< s
->buffers
);
354 if (buf
.bytesused
!= s
->frame_size
) {
355 av_log(ctx
, AV_LOG_ERROR
, "The v4l2 frame is %d bytes, but %d bytes are expected\n", buf
.bytesused
, s
->frame_size
);
360 /* Image is at s->buff_start[buf.index] */
361 pkt
->data
= s
->buf_start
[buf
.index
];
362 pkt
->size
= buf
.bytesused
;
363 pkt
->pts
= buf
.timestamp
.tv_sec
* INT64_C(1000000) + buf
.timestamp
.tv_usec
;
364 pkt
->destruct
= mmap_release_buffer
;
365 buf_descriptor
= av_malloc(sizeof(struct buff_data
));
366 if (buf_descriptor
== NULL
) {
367 /* Something went wrong... Since av_malloc() failed, we cannot even
368 * allocate a buffer for memcopying into it
370 av_log(ctx
, AV_LOG_ERROR
, "Failed to allocate a buffer descriptor\n");
371 res
= ioctl (s
->fd
, VIDIOC_QBUF
, &buf
);
375 buf_descriptor
->fd
= s
->fd
;
376 buf_descriptor
->index
= buf
.index
;
377 pkt
->priv
= buf_descriptor
;
379 return s
->buf_len
[buf
.index
];
382 static int read_frame(AVFormatContext
*ctx
, AVPacket
*pkt
)
387 static int mmap_start(AVFormatContext
*ctx
)
389 struct video_data
*s
= ctx
->priv_data
;
390 enum v4l2_buf_type type
;
393 for (i
= 0; i
< s
->buffers
; i
++) {
394 struct v4l2_buffer buf
;
396 memset(&buf
, 0, sizeof(struct v4l2_buffer
));
397 buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
398 buf
.memory
= V4L2_MEMORY_MMAP
;
401 res
= ioctl (s
->fd
, VIDIOC_QBUF
, &buf
);
403 av_log(ctx
, AV_LOG_ERROR
, "ioctl(VIDIOC_QBUF): %s\n", strerror(errno
));
409 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
410 res
= ioctl (s
->fd
, VIDIOC_STREAMON
, &type
);
412 av_log(ctx
, AV_LOG_ERROR
, "ioctl(VIDIOC_STREAMON): %s\n", strerror(errno
));
420 static void mmap_close(struct video_data
*s
)
422 enum v4l2_buf_type type
;
425 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
426 /* We do not check for the result, because we could
427 * not do anything about it anyway...
429 ioctl(s
->fd
, VIDIOC_STREAMOFF
, &type
);
430 for (i
= 0; i
< s
->buffers
; i
++) {
431 munmap(s
->buf_start
[i
], s
->buf_len
[i
]);
433 av_free(s
->buf_start
);
437 static int v4l2_set_parameters( AVFormatContext
*s1
, AVFormatParameters
*ap
)
439 struct video_data
*s
= s1
->priv_data
;
440 struct v4l2_input input
;
441 struct v4l2_standard standard
;
445 /* set tv video input */
446 memset (&input
, 0, sizeof (input
));
447 input
.index
= ap
->channel
;
448 if(ioctl (s
->fd
, VIDIOC_ENUMINPUT
, &input
) < 0) {
449 av_log(s1
, AV_LOG_ERROR
, "The V4L2 driver ioctl enum input failed:\n");
453 av_log(s1
, AV_LOG_DEBUG
, "The V4L2 driver set input_id: %d, input: %s\n",
454 ap
->channel
, input
.name
);
455 if(ioctl (s
->fd
, VIDIOC_S_INPUT
, &input
.index
) < 0 ) {
456 av_log(s1
, AV_LOG_ERROR
, "The V4L2 driver ioctl set input(%d) failed\n",
463 av_log(s1
, AV_LOG_DEBUG
, "The V4L2 driver set standard: %s\n",
465 /* set tv standard */
466 memset (&standard
, 0, sizeof (standard
));
469 if (ioctl(s
->fd
, VIDIOC_ENUMSTD
, &standard
) < 0) {
470 av_log(s1
, AV_LOG_ERROR
, "The V4L2 driver ioctl set standard(%s) failed\n",
475 if(!strcasecmp(standard
.name
, ap
->standard
)) {
480 av_log(s1
, AV_LOG_DEBUG
, "The V4L2 driver set standard: %s, id: %"PRIu64
"\n",
481 ap
->standard
, standard
.id
);
482 if (ioctl(s
->fd
, VIDIOC_S_STD
, &standard
.id
) < 0) {
483 av_log(s1
, AV_LOG_ERROR
, "The V4L2 driver ioctl set standard(%s) failed\n",
492 static int v4l2_read_header(AVFormatContext
*s1
, AVFormatParameters
*ap
)
494 struct video_data
*s
= s1
->priv_data
;
497 int res
, frame_rate
, frame_rate_base
;
498 uint32_t desired_format
, capabilities
;
500 if (ap
->width
<= 0 || ap
->height
<= 0) {
501 av_log(s1
, AV_LOG_ERROR
, "Wrong size (%dx%d)\n", ap
->width
, ap
->height
);
504 if (ap
->time_base
.den
<= 0) {
505 av_log(s1
, AV_LOG_ERROR
, "Wrong time base (%d)\n", ap
->time_base
.den
);
511 frame_rate
= ap
->time_base
.den
;
512 frame_rate_base
= ap
->time_base
.num
;
514 if((unsigned)width
> 32767 || (unsigned)height
> 32767) {
515 av_log(s1
, AV_LOG_ERROR
, "Wrong size (%dx%d)\n", width
, height
);
520 st
= av_new_stream(s1
, 0);
522 return AVERROR(ENOMEM
);
524 av_set_pts_info(st
, 64, 1, 1000000); /* 64 bits pts in us */
528 s
->frame_rate
= frame_rate
;
529 s
->frame_rate_base
= frame_rate_base
;
532 s
->fd
= device_open(s1
, &capabilities
);
536 av_log(s1
, AV_LOG_INFO
, "[%d]Capabilities: %x\n", s
->fd
, capabilities
);
538 desired_format
= fmt_ff2v4l(ap
->pix_fmt
);
539 if (desired_format
== 0 || (device_init(s1
, &width
, &height
, desired_format
) < 0)) {
544 desired_format
= fmt_conversion_table
[i
].v4l2_fmt
;
545 if (device_init(s1
, &width
, &height
, desired_format
) < 0) {
551 if (i
== sizeof(fmt_conversion_table
) / sizeof(struct fmt_map
)) {
556 if (desired_format
== 0) {
557 av_log(s1
, AV_LOG_ERROR
, "Cannot find a proper format.\n");
562 s
->frame_format
= desired_format
;
564 if( v4l2_set_parameters( s1
, ap
) < 0 )
567 st
->codec
->pix_fmt
= fmt_v4l2ff(desired_format
);
568 s
->frame_size
= avpicture_get_size(st
->codec
->pix_fmt
, width
, height
);
569 if (capabilities
& V4L2_CAP_STREAMING
) {
570 s
->io_method
= io_mmap
;
573 res
= mmap_start(s1
);
576 s
->io_method
= io_read
;
584 s
->top_field_first
= first_field(s
->fd
);
586 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
587 st
->codec
->codec_id
= CODEC_ID_RAWVIDEO
;
588 st
->codec
->width
= width
;
589 st
->codec
->height
= height
;
590 st
->codec
->time_base
.den
= frame_rate
;
591 st
->codec
->time_base
.num
= frame_rate_base
;
592 st
->codec
->bit_rate
= s
->frame_size
* 1/av_q2d(st
->codec
->time_base
) * 8;
597 static int v4l2_read_packet(AVFormatContext
*s1
, AVPacket
*pkt
)
599 struct video_data
*s
= s1
->priv_data
;
602 if (s
->io_method
== io_mmap
) {
604 res
= mmap_read_frame(s1
, pkt
);
605 } else if (s
->io_method
== io_read
) {
606 if (av_new_packet(pkt
, s
->frame_size
) < 0)
609 res
= read_frame(s1
, pkt
);
617 if (s1
->streams
[0]->codec
->coded_frame
) {
618 s1
->streams
[0]->codec
->coded_frame
->interlaced_frame
= 1;
619 s1
->streams
[0]->codec
->coded_frame
->top_field_first
= s
->top_field_first
;
622 return s
->frame_size
;
625 static int v4l2_read_close(AVFormatContext
*s1
)
627 struct video_data
*s
= s1
->priv_data
;
629 if (s
->io_method
== io_mmap
) {
637 AVInputFormat v4l2_demuxer
= {
639 NULL_IF_CONFIG_SMALL("video grab"),
640 sizeof(struct video_data
),
645 .flags
= AVFMT_NOFILE
,