Mercurial > libavformat.hg
annotate v4l2.c @ 2300:9c8cfadff191 libavformat
correct initial timestamps which have AV_NOPTS_VALUE
author | michael |
---|---|
date | Sat, 04 Aug 2007 22:46:13 +0000 |
parents | b21c2af60bc9 |
children | 0cc87456f0ad |
rev | line source |
---|---|
921 | 1 /* |
2 * Video4Linux2 grab interface | |
3 * Copyright (c) 2000,2001 Fabrice Bellard. | |
4 * Copyright (c) 2006 Luca Abeni. | |
5 * | |
6 * Part of this file is based on the V4L2 video capture example | |
7 * (http://v4l2spec.bytesex.org/v4l2spec/capture.c) | |
8 * | |
9 * Thanks to Michael Niedermayer for providing the mapping between | |
10 * V4L2_PIX_FMT_* and PIX_FMT_* | |
11 * | |
12 * | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
13 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
14 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
15 * FFmpeg is free software; you can redistribute it and/or |
921 | 16 * modify it under the terms of the GNU Lesser General Public |
17 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
18 * version 2.1 of the License, or (at your option) any later version. |
921 | 19 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
20 * FFmpeg is distributed in the hope that it will be useful, |
921 | 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. | |
24 * | |
25 * You should have received a copy of the GNU Lesser General Public | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1169
diff
changeset
|
26 * License along with FFmpeg; if not, write to the Free Software |
921 | 27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
28 */ | |
29 #include "avformat.h" | |
30 #include <unistd.h> | |
31 #include <fcntl.h> | |
32 #include <sys/ioctl.h> | |
33 #include <sys/mman.h> | |
34 #include <sys/time.h> | |
1100 | 35 #include <asm/types.h> |
36 #include <linux/videodev2.h> | |
921 | 37 #include <time.h> |
38 | |
39 static const int desired_video_buffers = 256; | |
40 | |
41 enum io_method { | |
42 io_read, | |
43 io_mmap, | |
44 io_userptr | |
45 }; | |
46 | |
47 struct video_data { | |
48 int fd; | |
49 int frame_format; /* V4L2_PIX_FMT_* */ | |
50 enum io_method io_method; | |
51 int width, height; | |
52 int frame_rate; | |
53 int frame_rate_base; | |
54 int frame_size; | |
55 int top_field_first; | |
56 | |
57 int buffers; | |
58 void **buf_start; | |
59 unsigned int *buf_len; | |
60 }; | |
61 | |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
62 struct buff_data { |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
63 int index; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
64 int fd; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
65 }; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
66 |
921 | 67 struct fmt_map { |
68 enum PixelFormat ff_fmt; | |
69 int32_t v4l2_fmt; | |
70 }; | |
71 | |
72 static struct fmt_map fmt_conversion_table[] = { | |
73 { | |
74 .ff_fmt = PIX_FMT_YUV420P, | |
75 .v4l2_fmt = V4L2_PIX_FMT_YUV420, | |
76 }, | |
77 { | |
78 .ff_fmt = PIX_FMT_YUV422P, | |
79 .v4l2_fmt = V4L2_PIX_FMT_YUV422P, | |
80 }, | |
81 { | |
1760
8cba5672faa4
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
1556
diff
changeset
|
82 .ff_fmt = PIX_FMT_YUYV422, |
921 | 83 .v4l2_fmt = V4L2_PIX_FMT_YUYV, |
84 }, | |
85 { | |
86 .ff_fmt = PIX_FMT_UYVY422, | |
87 .v4l2_fmt = V4L2_PIX_FMT_UYVY, | |
88 }, | |
89 { | |
90 .ff_fmt = PIX_FMT_YUV411P, | |
91 .v4l2_fmt = V4L2_PIX_FMT_YUV411P, | |
92 }, | |
93 { | |
94 .ff_fmt = PIX_FMT_YUV410P, | |
95 .v4l2_fmt = V4L2_PIX_FMT_YUV410, | |
96 }, | |
97 { | |
98 .ff_fmt = PIX_FMT_BGR24, | |
99 .v4l2_fmt = V4L2_PIX_FMT_BGR24, | |
100 }, | |
101 { | |
102 .ff_fmt = PIX_FMT_RGB24, | |
103 .v4l2_fmt = V4L2_PIX_FMT_RGB24, | |
104 }, | |
105 /* | |
106 { | |
1760
8cba5672faa4
Replace deprecated PIX_FMT names by the newer variants.
diego
parents:
1556
diff
changeset
|
107 .ff_fmt = PIX_FMT_RGB32, |
921 | 108 .v4l2_fmt = V4L2_PIX_FMT_BGR32, |
109 }, | |
110 */ | |
111 { | |
112 .ff_fmt = PIX_FMT_GRAY8, | |
113 .v4l2_fmt = V4L2_PIX_FMT_GREY, | |
114 }, | |
115 }; | |
116 | |
1795
62792a60f740
implement new grabbing interface, as described here:
gpoirier
parents:
1793
diff
changeset
|
117 static int device_open(AVFormatContext *ctx, uint32_t *capabilities) |
921 | 118 { |
119 struct v4l2_capability cap; | |
120 int fd; | |
121 int res; | |
2221
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
122 int flags = O_RDWR; |
921 | 123 |
2221
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
124 if (ctx->flags & AVFMT_FLAG_NONBLOCK) { |
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
125 flags |= O_NONBLOCK; |
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
126 } |
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
127 fd = open(ctx->filename, flags, 0); |
921 | 128 if (fd < 0) { |
1780 | 129 av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s : %s\n", |
1795
62792a60f740
implement new grabbing interface, as described here:
gpoirier
parents:
1793
diff
changeset
|
130 ctx->filename, strerror(errno)); |
921 | 131 |
132 return -1; | |
133 } | |
134 | |
135 res = ioctl(fd, VIDIOC_QUERYCAP, &cap); | |
973 | 136 // ENOIOCTLCMD definition only availble on __KERNEL__ |
137 if (res < 0 && errno == 515) | |
138 { | |
1780 | 139 av_log(ctx, AV_LOG_ERROR, "QUERYCAP not implemented, probably V4L device but not supporting V4L2\n"); |
974 | 140 close(fd); |
973 | 141 |
142 return -1; | |
143 } | |
921 | 144 if (res < 0) { |
1780 | 145 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n", |
921 | 146 strerror(errno)); |
974 | 147 close(fd); |
921 | 148 |
149 return -1; | |
150 } | |
151 if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) { | |
1780 | 152 av_log(ctx, AV_LOG_ERROR, "Not a video capture device\n"); |
974 | 153 close(fd); |
921 | 154 |
155 return -1; | |
156 } | |
157 *capabilities = cap.capabilities; | |
158 | |
159 return fd; | |
160 } | |
161 | |
1780 | 162 static int device_init(AVFormatContext *ctx, int *width, int *height, int pix_fmt) |
921 | 163 { |
1780 | 164 struct video_data *s = ctx->priv_data; |
165 int fd = s->fd; | |
921 | 166 struct v4l2_format fmt; |
975
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
167 int res; |
921 | 168 |
169 memset(&fmt, 0, sizeof(struct v4l2_format)); | |
170 fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
975
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
171 fmt.fmt.pix.width = *width; |
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
172 fmt.fmt.pix.height = *height; |
921 | 173 fmt.fmt.pix.pixelformat = pix_fmt; |
174 fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; | |
975
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
175 res = ioctl(fd, VIDIOC_S_FMT, &fmt); |
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
176 if ((*width != fmt.fmt.pix.width) || (*height != fmt.fmt.pix.height)) { |
1780 | 177 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); |
975
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
178 *width = fmt.fmt.pix.width; |
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
179 *height = fmt.fmt.pix.height; |
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
180 } |
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
181 |
36a69fbabcfb
Add support for drivers that can change the capture size on VIDIOC_S_FMT
lucabe
parents:
974
diff
changeset
|
182 return res; |
921 | 183 } |
184 | |
185 static int first_field(int fd) | |
186 { | |
187 int res; | |
188 v4l2_std_id std; | |
189 | |
190 res = ioctl(fd, VIDIOC_G_STD, &std); | |
191 if (res < 0) { | |
192 return 0; | |
193 } | |
194 if (std & V4L2_STD_NTSC) { | |
195 return 0; | |
196 } | |
197 | |
198 return 1; | |
199 } | |
200 | |
201 static uint32_t fmt_ff2v4l(enum PixelFormat pix_fmt) | |
202 { | |
203 int i; | |
204 | |
205 for (i = 0; i < sizeof(fmt_conversion_table) / sizeof(struct fmt_map); i++) { | |
206 if (fmt_conversion_table[i].ff_fmt == pix_fmt) { | |
207 return fmt_conversion_table[i].v4l2_fmt; | |
208 } | |
209 } | |
210 | |
211 return 0; | |
212 } | |
213 | |
214 static enum PixelFormat fmt_v4l2ff(uint32_t pix_fmt) | |
215 { | |
216 int i; | |
217 | |
218 for (i = 0; i < sizeof(fmt_conversion_table) / sizeof(struct fmt_map); i++) { | |
219 if (fmt_conversion_table[i].v4l2_fmt == pix_fmt) { | |
220 return fmt_conversion_table[i].ff_fmt; | |
221 } | |
222 } | |
223 | |
224 return -1; | |
225 } | |
226 | |
1780 | 227 static int mmap_init(AVFormatContext *ctx) |
921 | 228 { |
1780 | 229 struct video_data *s = ctx->priv_data; |
921 | 230 struct v4l2_requestbuffers req; |
231 int i, res; | |
232 | |
233 memset(&req, 0, sizeof(struct v4l2_requestbuffers)); | |
234 req.count = desired_video_buffers; | |
235 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
236 req.memory = V4L2_MEMORY_MMAP; | |
237 res = ioctl (s->fd, VIDIOC_REQBUFS, &req); | |
238 if (res < 0) { | |
239 if (errno == EINVAL) { | |
1780 | 240 av_log(ctx, AV_LOG_ERROR, "Device does not support mmap\n"); |
921 | 241 } else { |
1780 | 242 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS)\n"); |
921 | 243 } |
244 | |
245 return -1; | |
246 } | |
247 | |
248 if (req.count < 2) { | |
1780 | 249 av_log(ctx, AV_LOG_ERROR, "Insufficient buffer memory\n"); |
921 | 250 |
251 return -1; | |
252 } | |
253 s->buffers = req.count; | |
254 s->buf_start = av_malloc(sizeof(void *) * s->buffers); | |
255 if (s->buf_start == NULL) { | |
1780 | 256 av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer pointers\n"); |
921 | 257 |
258 return -1; | |
259 } | |
260 s->buf_len = av_malloc(sizeof(unsigned int) * s->buffers); | |
261 if (s->buf_len == NULL) { | |
1780 | 262 av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer sizes\n"); |
921 | 263 av_free(s->buf_start); |
264 | |
265 return -1; | |
266 } | |
267 | |
268 for (i = 0; i < req.count; i++) { | |
269 struct v4l2_buffer buf; | |
270 | |
271 memset(&buf, 0, sizeof(struct v4l2_buffer)); | |
272 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
273 buf.memory = V4L2_MEMORY_MMAP; | |
274 buf.index = i; | |
275 res = ioctl (s->fd, VIDIOC_QUERYBUF, &buf); | |
276 if (res < 0) { | |
1780 | 277 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF)\n"); |
921 | 278 |
279 return -1; | |
280 } | |
281 | |
282 s->buf_len[i] = buf.length; | |
283 if (s->buf_len[i] < s->frame_size) { | |
1780 | 284 av_log(ctx, AV_LOG_ERROR, "Buffer len [%d] = %d != %d\n", i, s->buf_len[i], s->frame_size); |
921 | 285 |
286 return -1; | |
287 } | |
288 s->buf_start[i] = mmap (NULL, buf.length, | |
289 PROT_READ | PROT_WRITE, MAP_SHARED, s->fd, buf.m.offset); | |
290 if (s->buf_start[i] == MAP_FAILED) { | |
1780 | 291 av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", strerror(errno)); |
921 | 292 |
293 return -1; | |
294 } | |
295 } | |
296 | |
297 return 0; | |
298 } | |
299 | |
1780 | 300 static int read_init(AVFormatContext *ctx) |
921 | 301 { |
302 return -1; | |
303 } | |
304 | |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
305 static void mmap_release_buffer(AVPacket *pkt) |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
306 { |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
307 struct v4l2_buffer buf; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
308 int res, fd; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
309 struct buff_data *buf_descriptor = pkt->priv; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
310 |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
311 memset(&buf, 0, sizeof(struct v4l2_buffer)); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
312 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
313 buf.memory = V4L2_MEMORY_MMAP; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
314 buf.index = buf_descriptor->index; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
315 fd = buf_descriptor->fd; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
316 av_free(buf_descriptor); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
317 |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
318 res = ioctl (fd, VIDIOC_QBUF, &buf); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
319 if (res < 0) { |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
320 av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF)\n"); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
321 } |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
322 pkt->data = NULL; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
323 pkt->size = 0; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
324 } |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
325 |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
326 static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt) |
921 | 327 { |
1780 | 328 struct video_data *s = ctx->priv_data; |
921 | 329 struct v4l2_buffer buf; |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
330 struct buff_data *buf_descriptor; |
921 | 331 int res; |
332 | |
333 memset(&buf, 0, sizeof(struct v4l2_buffer)); | |
334 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
335 buf.memory = V4L2_MEMORY_MMAP; | |
336 | |
337 /* FIXME: Some special treatment might be needed in case of loss of signal... */ | |
2221
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
338 while ((res = ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR)); |
921 | 339 if (res < 0) { |
2221
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
340 if (errno == EAGAIN) { |
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
341 pkt->size = 0; |
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
342 |
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
343 return AVERROR(EAGAIN); |
efb7b615d57c
Support for the AVFMT_FLAG_NONBLOCK flag (non-blocking input) in v4l2.c
lucabe
parents:
2078
diff
changeset
|
344 } |
1780 | 345 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n", strerror(errno)); |
921 | 346 |
347 return -1; | |
348 } | |
349 assert (buf.index < s->buffers); | |
1407
fb4bf3858f77
Make read_packet fail is the v4l2 driver returns an unexpected frame size
lucabe
parents:
1358
diff
changeset
|
350 if (buf.bytesused != s->frame_size) { |
1780 | 351 av_log(ctx, AV_LOG_ERROR, "The v4l2 frame is %d bytes, but %d bytes are expected\n", buf.bytesused, s->frame_size); |
1407
fb4bf3858f77
Make read_packet fail is the v4l2 driver returns an unexpected frame size
lucabe
parents:
1358
diff
changeset
|
352 |
fb4bf3858f77
Make read_packet fail is the v4l2 driver returns an unexpected frame size
lucabe
parents:
1358
diff
changeset
|
353 return -1; |
fb4bf3858f77
Make read_packet fail is the v4l2 driver returns an unexpected frame size
lucabe
parents:
1358
diff
changeset
|
354 } |
fb4bf3858f77
Make read_packet fail is the v4l2 driver returns an unexpected frame size
lucabe
parents:
1358
diff
changeset
|
355 |
921 | 356 /* Image is at s->buff_start[buf.index] */ |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
357 pkt->data= s->buf_start[buf.index]; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
358 pkt->size = buf.bytesused; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
359 pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
360 pkt->destruct = mmap_release_buffer; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
361 buf_descriptor = av_malloc(sizeof(struct buff_data)); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
362 if (buf_descriptor == NULL) { |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
363 /* Something went wrong... Since av_malloc() failed, we cannot even |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
364 * allocate a buffer for memcopying into it |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
365 */ |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
366 av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n"); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
367 res = ioctl (s->fd, VIDIOC_QBUF, &buf); |
921 | 368 |
369 return -1; | |
370 } | |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
371 buf_descriptor->fd = s->fd; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
372 buf_descriptor->index = buf.index; |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
373 pkt->priv = buf_descriptor; |
921 | 374 |
375 return s->buf_len[buf.index]; | |
376 } | |
377 | |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
378 static int read_frame(AVFormatContext *ctx, AVPacket *pkt) |
921 | 379 { |
380 return -1; | |
381 } | |
382 | |
1780 | 383 static int mmap_start(AVFormatContext *ctx) |
921 | 384 { |
1780 | 385 struct video_data *s = ctx->priv_data; |
921 | 386 enum v4l2_buf_type type; |
387 int i, res; | |
388 | |
389 for (i = 0; i < s->buffers; i++) { | |
390 struct v4l2_buffer buf; | |
391 | |
392 memset(&buf, 0, sizeof(struct v4l2_buffer)); | |
393 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
394 buf.memory = V4L2_MEMORY_MMAP; | |
395 buf.index = i; | |
396 | |
397 res = ioctl (s->fd, VIDIOC_QBUF, &buf); | |
398 if (res < 0) { | |
1780 | 399 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", strerror(errno)); |
921 | 400 |
401 return -1; | |
402 } | |
403 } | |
404 | |
405 type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
406 res = ioctl (s->fd, VIDIOC_STREAMON, &type); | |
407 if (res < 0) { | |
1780 | 408 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n", strerror(errno)); |
921 | 409 |
410 return -1; | |
411 } | |
412 | |
413 return 0; | |
414 } | |
415 | |
416 static void mmap_close(struct video_data *s) | |
417 { | |
418 enum v4l2_buf_type type; | |
419 int i; | |
420 | |
421 type = V4L2_BUF_TYPE_VIDEO_CAPTURE; | |
422 /* We do not check for the result, because we could | |
423 * not do anything about it anyway... | |
424 */ | |
425 ioctl(s->fd, VIDIOC_STREAMOFF, &type); | |
426 for (i = 0; i < s->buffers; i++) { | |
427 munmap(s->buf_start[i], s->buf_len[i]); | |
428 } | |
429 av_free(s->buf_start); | |
430 av_free(s->buf_len); | |
431 } | |
432 | |
1961 | 433 static int v4l2_set_parameters( AVFormatContext *s1, AVFormatParameters *ap ) |
434 { | |
435 struct video_data *s = s1->priv_data; | |
436 struct v4l2_input input; | |
437 struct v4l2_standard standard; | |
438 int i; | |
439 | |
2077
4b07eb8709f2
Allow avoid setting the video standard and input when capturing v4l2 video.
lucabe
parents:
1961
diff
changeset
|
440 if(ap->channel>=0) { |
2078 | 441 /* set tv video input */ |
442 memset (&input, 0, sizeof (input)); | |
443 input.index = ap->channel; | |
444 if(ioctl (s->fd, VIDIOC_ENUMINPUT, &input) < 0) { | |
445 av_log(s1, AV_LOG_ERROR, "The V4L2 driver ioctl enum input failed:\n"); | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
446 return AVERROR(EIO); |
2078 | 447 } |
1961 | 448 |
2078 | 449 av_log(s1, AV_LOG_DEBUG, "The V4L2 driver set input_id: %d, input: %s\n", |
450 ap->channel, input.name); | |
451 if(ioctl (s->fd, VIDIOC_S_INPUT, &input.index) < 0 ) { | |
452 av_log(s1, AV_LOG_ERROR, "The V4L2 driver ioctl set input(%d) failed\n", | |
453 ap->channel); | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
454 return AVERROR(EIO); |
2078 | 455 } |
2077
4b07eb8709f2
Allow avoid setting the video standard and input when capturing v4l2 video.
lucabe
parents:
1961
diff
changeset
|
456 } |
1961 | 457 |
2077
4b07eb8709f2
Allow avoid setting the video standard and input when capturing v4l2 video.
lucabe
parents:
1961
diff
changeset
|
458 if(ap->standard) { |
2078 | 459 av_log(s1, AV_LOG_DEBUG, "The V4L2 driver set standard: %s\n", |
460 ap->standard ); | |
461 /* set tv standard */ | |
462 memset (&standard, 0, sizeof (standard)); | |
463 for(i=0;;i++) { | |
464 standard.index = i; | |
465 if (ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) { | |
466 av_log(s1, AV_LOG_ERROR, "The V4L2 driver ioctl set standard(%s) failed\n", | |
467 ap->standard); | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
468 return AVERROR(EIO); |
2078 | 469 } |
470 | |
471 if(!strcasecmp(standard.name, ap->standard)) { | |
472 break; | |
473 } | |
474 } | |
475 | |
476 av_log(s1, AV_LOG_DEBUG, "The V4L2 driver set standard: %s, id: %"PRIu64"\n", | |
477 ap->standard, standard.id); | |
478 if (ioctl(s->fd, VIDIOC_S_STD, &standard.id) < 0) { | |
1961 | 479 av_log(s1, AV_LOG_ERROR, "The V4L2 driver ioctl set standard(%s) failed\n", |
480 ap->standard); | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
481 return AVERROR(EIO); |
1961 | 482 } |
2077
4b07eb8709f2
Allow avoid setting the video standard and input when capturing v4l2 video.
lucabe
parents:
1961
diff
changeset
|
483 } |
1961 | 484 |
485 return 0; | |
486 } | |
487 | |
921 | 488 static int v4l2_read_header(AVFormatContext *s1, AVFormatParameters *ap) |
489 { | |
490 struct video_data *s = s1->priv_data; | |
491 AVStream *st; | |
492 int width, height; | |
493 int res, frame_rate, frame_rate_base; | |
494 uint32_t desired_format, capabilities; | |
495 | |
1003 | 496 if (ap->width <= 0 || ap->height <= 0 || ap->time_base.den <= 0) { |
921 | 497 av_log(s1, AV_LOG_ERROR, "Missing/Wrong parameters\n"); |
498 | |
499 return -1; | |
500 } | |
501 | |
502 width = ap->width; | |
503 height = ap->height; | |
504 frame_rate = ap->time_base.den; | |
505 frame_rate_base = ap->time_base.num; | |
506 | |
507 if((unsigned)width > 32767 || (unsigned)height > 32767) { | |
508 av_log(s1, AV_LOG_ERROR, "Wrong size %dx%d\n", width, height); | |
509 | |
510 return -1; | |
511 } | |
512 | |
513 st = av_new_stream(s1, 0); | |
514 if (!st) { | |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1780
diff
changeset
|
515 return AVERROR(ENOMEM); |
921 | 516 } |
517 av_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ | |
518 | |
519 s->width = width; | |
520 s->height = height; | |
521 s->frame_rate = frame_rate; | |
522 s->frame_rate_base = frame_rate_base; | |
523 | |
524 capabilities = 0; | |
1795
62792a60f740
implement new grabbing interface, as described here:
gpoirier
parents:
1793
diff
changeset
|
525 s->fd = device_open(s1, &capabilities); |
921 | 526 if (s->fd < 0) { |
527 av_free(st); | |
528 | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
529 return AVERROR(EIO); |
921 | 530 } |
1013 | 531 av_log(s1, AV_LOG_INFO, "[%d]Capabilities: %x\n", s->fd, capabilities); |
921 | 532 |
533 desired_format = fmt_ff2v4l(ap->pix_fmt); | |
1780 | 534 if (desired_format == 0 || (device_init(s1, &width, &height, desired_format) < 0)) { |
921 | 535 int i, done; |
536 | |
537 done = 0; i = 0; | |
538 while (!done) { | |
539 desired_format = fmt_conversion_table[i].v4l2_fmt; | |
1780 | 540 if (device_init(s1, &width, &height, desired_format) < 0) { |
921 | 541 desired_format = 0; |
542 i++; | |
543 } else { | |
544 done = 1; | |
545 } | |
546 if (i == sizeof(fmt_conversion_table) / sizeof(struct fmt_map)) { | |
547 done = 1; | |
548 } | |
549 } | |
550 } | |
551 if (desired_format == 0) { | |
552 av_log(s1, AV_LOG_ERROR, "Cannot find a proper format.\n"); | |
553 close(s->fd); | |
554 av_free(st); | |
555 | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
556 return AVERROR(EIO); |
921 | 557 } |
558 s->frame_format = desired_format; | |
559 | |
1961 | 560 if( v4l2_set_parameters( s1, ap ) < 0 ) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
561 return AVERROR(EIO); |
1961 | 562 |
921 | 563 st->codec->pix_fmt = fmt_v4l2ff(desired_format); |
564 s->frame_size = avpicture_get_size(st->codec->pix_fmt, width, height); | |
565 if (capabilities & V4L2_CAP_STREAMING) { | |
566 s->io_method = io_mmap; | |
1780 | 567 res = mmap_init(s1); |
1117 | 568 if (res == 0) { |
1780 | 569 res = mmap_start(s1); |
1117 | 570 } |
921 | 571 } else { |
572 s->io_method = io_read; | |
1780 | 573 res = read_init(s1); |
921 | 574 } |
575 if (res < 0) { | |
576 close(s->fd); | |
577 av_free(st); | |
578 | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
579 return AVERROR(EIO); |
921 | 580 } |
581 s->top_field_first = first_field(s->fd); | |
582 | |
583 st->codec->codec_type = CODEC_TYPE_VIDEO; | |
584 st->codec->codec_id = CODEC_ID_RAWVIDEO; | |
585 st->codec->width = width; | |
586 st->codec->height = height; | |
587 st->codec->time_base.den = frame_rate; | |
588 st->codec->time_base.num = frame_rate_base; | |
589 st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8; | |
590 | |
591 return 0; | |
592 } | |
593 | |
594 static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt) | |
595 { | |
596 struct video_data *s = s1->priv_data; | |
597 int res; | |
598 | |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
599 if (s->io_method == io_mmap) { |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
600 av_init_packet(pkt); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
601 res = mmap_read_frame(s1, pkt); |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
602 } else if (s->io_method == io_read) { |
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
603 if (av_new_packet(pkt, s->frame_size) < 0) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
604 return AVERROR(EIO); |
921 | 605 |
1793
951d219ab67b
Pass the v4l2 buffer into the AVPacket, instead of allocating a new buffer
lucabe
parents:
1787
diff
changeset
|
606 res = read_frame(s1, pkt); |
921 | 607 } else { |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
608 return AVERROR(EIO); |
921 | 609 } |
610 if (res < 0) { | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2221
diff
changeset
|
611 return AVERROR(EIO); |
921 | 612 } |
613 | |
614 if (s1->streams[0]->codec->coded_frame) { | |
615 s1->streams[0]->codec->coded_frame->interlaced_frame = 1; | |
616 s1->streams[0]->codec->coded_frame->top_field_first = s->top_field_first; | |
617 } | |
618 | |
619 return s->frame_size; | |
620 } | |
621 | |
622 static int v4l2_read_close(AVFormatContext *s1) | |
623 { | |
624 struct video_data *s = s1->priv_data; | |
625 | |
626 if (s->io_method == io_mmap) { | |
627 mmap_close(s); | |
628 } | |
629 | |
630 close(s->fd); | |
631 return 0; | |
632 } | |
633 | |
1169 | 634 AVInputFormat v4l2_demuxer = { |
921 | 635 "video4linux2", |
636 "video grab", | |
637 sizeof(struct video_data), | |
638 NULL, | |
639 v4l2_read_header, | |
640 v4l2_read_packet, | |
641 v4l2_read_close, | |
642 .flags = AVFMT_NOFILE, | |
643 }; |