FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/v4l2_context.c
Date: 2024-04-12 08:31:17
Exec Total Coverage
Lines: 0 374 0.0%
Functions: 0 28 0.0%
Branches: 0 350 0.0%

Line Branch Exec Source
1 /*
2 * V4L2 context helper functions.
3 *
4 * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
5 * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
6 *
7 * This file is part of FFmpeg.
8 *
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24 #include <linux/videodev2.h>
25 #include <sys/ioctl.h>
26 #include <sys/mman.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <poll.h>
30 #include "libavutil/mem.h"
31 #include "libavcodec/avcodec.h"
32 #include "decode.h"
33 #include "v4l2_buffers.h"
34 #include "v4l2_fmt.h"
35 #include "v4l2_m2m.h"
36
37 struct v4l2_format_update {
38 uint32_t v4l2_fmt;
39 int update_v4l2;
40
41 enum AVPixelFormat av_fmt;
42 int update_avfmt;
43 };
44
45 static inline V4L2m2mContext *ctx_to_m2mctx(V4L2Context *ctx)
46 {
47 return V4L2_TYPE_IS_OUTPUT(ctx->type) ?
48 container_of(ctx, V4L2m2mContext, output) :
49 container_of(ctx, V4L2m2mContext, capture);
50 }
51
52 static inline AVCodecContext *logger(V4L2Context *ctx)
53 {
54 return ctx_to_m2mctx(ctx)->avctx;
55 }
56
57 static inline unsigned int v4l2_get_width(struct v4l2_format *fmt)
58 {
59 return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.width : fmt->fmt.pix.width;
60 }
61
62 static inline unsigned int v4l2_get_height(struct v4l2_format *fmt)
63 {
64 return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.height : fmt->fmt.pix.height;
65 }
66
67 static AVRational v4l2_get_sar(V4L2Context *ctx)
68 {
69 struct AVRational sar = { 0, 1 };
70 struct v4l2_cropcap cropcap;
71 int ret;
72
73 memset(&cropcap, 0, sizeof(cropcap));
74 cropcap.type = ctx->type;
75
76 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_CROPCAP, &cropcap);
77 if (ret)
78 return sar;
79
80 sar.num = cropcap.pixelaspect.numerator;
81 sar.den = cropcap.pixelaspect.denominator;
82 return sar;
83 }
84
85 static inline unsigned int v4l2_resolution_changed(V4L2Context *ctx, struct v4l2_format *fmt2)
86 {
87 struct v4l2_format *fmt1 = &ctx->format;
88 int ret = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
89 fmt1->fmt.pix_mp.width != fmt2->fmt.pix_mp.width ||
90 fmt1->fmt.pix_mp.height != fmt2->fmt.pix_mp.height
91 :
92 fmt1->fmt.pix.width != fmt2->fmt.pix.width ||
93 fmt1->fmt.pix.height != fmt2->fmt.pix.height;
94
95 if (ret)
96 av_log(logger(ctx), AV_LOG_DEBUG, "%s changed (%dx%d) -> (%dx%d)\n",
97 ctx->name,
98 v4l2_get_width(fmt1), v4l2_get_height(fmt1),
99 v4l2_get_width(fmt2), v4l2_get_height(fmt2));
100
101 return ret;
102 }
103
104 static inline int v4l2_type_supported(V4L2Context *ctx)
105 {
106 return ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
107 ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
108 ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
109 ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT;
110 }
111
112 static inline int v4l2_get_framesize_compressed(V4L2Context* ctx, int width, int height)
113 {
114 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
115 const int SZ_4K = 0x1000;
116 int size;
117
118 if (s->avctx && av_codec_is_decoder(s->avctx->codec))
119 return ((width * height * 3 / 2) / 2) + 128;
120
121 /* encoder */
122 size = FFALIGN(height, 32) * FFALIGN(width, 32) * 3 / 2 / 2;
123 return FFALIGN(size, SZ_4K);
124 }
125
126 static inline void v4l2_save_to_context(V4L2Context* ctx, struct v4l2_format_update *fmt)
127 {
128 ctx->format.type = ctx->type;
129
130 if (fmt->update_avfmt)
131 ctx->av_pix_fmt = fmt->av_fmt;
132
133 if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
134 /* update the sizes to handle the reconfiguration of the capture stream at runtime */
135 ctx->format.fmt.pix_mp.height = ctx->height;
136 ctx->format.fmt.pix_mp.width = ctx->width;
137 if (fmt->update_v4l2) {
138 ctx->format.fmt.pix_mp.pixelformat = fmt->v4l2_fmt;
139
140 /* s5p-mfc requires the user to specify a buffer size */
141 ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage =
142 v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
143 }
144 } else {
145 ctx->format.fmt.pix.height = ctx->height;
146 ctx->format.fmt.pix.width = ctx->width;
147 if (fmt->update_v4l2) {
148 ctx->format.fmt.pix.pixelformat = fmt->v4l2_fmt;
149
150 /* s5p-mfc requires the user to specify a buffer size */
151 ctx->format.fmt.pix.sizeimage =
152 v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
153 }
154 }
155 }
156
157 static int v4l2_start_decode(V4L2Context *ctx)
158 {
159 struct v4l2_decoder_cmd cmd = {
160 .cmd = V4L2_DEC_CMD_START,
161 .flags = 0,
162 };
163 int ret;
164
165 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DECODER_CMD, &cmd);
166 if (ret)
167 return AVERROR(errno);
168
169 return 0;
170 }
171
172 /**
173 * handle resolution change event and end of stream event
174 * returns 1 if reinit was successful, negative if it failed
175 * returns 0 if reinit was not executed
176 */
177 static int v4l2_handle_event(V4L2Context *ctx)
178 {
179 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
180 struct v4l2_format cap_fmt = s->capture.format;
181 struct v4l2_event evt = { 0 };
182 int ret;
183
184 ret = ioctl(s->fd, VIDIOC_DQEVENT, &evt);
185 if (ret < 0) {
186 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_DQEVENT\n", ctx->name);
187 return 0;
188 }
189
190 if (evt.type == V4L2_EVENT_EOS) {
191 ctx->done = 1;
192 return 0;
193 }
194
195 if (evt.type != V4L2_EVENT_SOURCE_CHANGE)
196 return 0;
197
198 ret = ioctl(s->fd, VIDIOC_G_FMT, &cap_fmt);
199 if (ret) {
200 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->capture.name);
201 return 0;
202 }
203
204 if (v4l2_resolution_changed(&s->capture, &cap_fmt)) {
205 s->capture.height = v4l2_get_height(&cap_fmt);
206 s->capture.width = v4l2_get_width(&cap_fmt);
207 s->capture.sample_aspect_ratio = v4l2_get_sar(&s->capture);
208 } else {
209 v4l2_start_decode(ctx);
210 return 0;
211 }
212
213 s->reinit = 1;
214
215 if (s->avctx)
216 ret = ff_set_dimensions(s->avctx, s->capture.width, s->capture.height);
217 if (ret < 0)
218 av_log(logger(ctx), AV_LOG_WARNING, "update avcodec height and width\n");
219
220 ret = ff_v4l2_m2m_codec_reinit(s);
221 if (ret) {
222 av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_reinit\n");
223 return AVERROR(EINVAL);
224 }
225
226 /* reinit executed */
227 return 1;
228 }
229
230 static int v4l2_stop_decode(V4L2Context *ctx)
231 {
232 struct v4l2_decoder_cmd cmd = {
233 .cmd = V4L2_DEC_CMD_STOP,
234 .flags = 0,
235 };
236 int ret;
237
238 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DECODER_CMD, &cmd);
239 if (ret) {
240 /* DECODER_CMD is optional */
241 if (errno == ENOTTY)
242 return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
243 else
244 return AVERROR(errno);
245 }
246
247 return 0;
248 }
249
250 static int v4l2_stop_encode(V4L2Context *ctx)
251 {
252 struct v4l2_encoder_cmd cmd = {
253 .cmd = V4L2_ENC_CMD_STOP,
254 .flags = 0,
255 };
256 int ret;
257
258 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENCODER_CMD, &cmd);
259 if (ret) {
260 /* ENCODER_CMD is optional */
261 if (errno == ENOTTY)
262 return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
263 else
264 return AVERROR(errno);
265 }
266
267 return 0;
268 }
269
270 static V4L2Buffer* v4l2_dequeue_v4l2buf(V4L2Context *ctx, int timeout)
271 {
272 struct v4l2_plane planes[VIDEO_MAX_PLANES];
273 struct v4l2_buffer buf = { 0 };
274 V4L2Buffer *avbuf;
275 struct pollfd pfd = {
276 .events = POLLIN | POLLRDNORM | POLLPRI | POLLOUT | POLLWRNORM, /* default blocking capture */
277 .fd = ctx_to_m2mctx(ctx)->fd,
278 };
279 int i, ret;
280
281 if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx->buffers) {
282 for (i = 0; i < ctx->num_buffers; i++) {
283 if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
284 break;
285 }
286 if (i == ctx->num_buffers)
287 av_log(logger(ctx), AV_LOG_WARNING, "All capture buffers returned to "
288 "userspace. Increase num_capture_buffers "
289 "to prevent device deadlock or dropped "
290 "packets/frames.\n");
291 }
292
293 /* if we are draining and there are no more capture buffers queued in the driver we are done */
294 if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx_to_m2mctx(ctx)->draining) {
295 for (i = 0; i < ctx->num_buffers; i++) {
296 /* capture buffer initialization happens during decode hence
297 * detection happens at runtime
298 */
299 if (!ctx->buffers)
300 break;
301
302 if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
303 goto start;
304 }
305 ctx->done = 1;
306 return NULL;
307 }
308
309 start:
310 if (V4L2_TYPE_IS_OUTPUT(ctx->type))
311 pfd.events = POLLOUT | POLLWRNORM;
312 else {
313 /* no need to listen to requests for more input while draining */
314 if (ctx_to_m2mctx(ctx)->draining)
315 pfd.events = POLLIN | POLLRDNORM | POLLPRI;
316 }
317
318 for (;;) {
319 ret = poll(&pfd, 1, timeout);
320 if (ret > 0)
321 break;
322 if (errno == EINTR)
323 continue;
324 return NULL;
325 }
326
327 /* 0. handle errors */
328 if (pfd.revents & POLLERR) {
329 /* if we are trying to get free buffers but none have been queued yet,
330 * or if no buffers have been allocated yet, no need to raise a warning
331 */
332 if (timeout == 0) {
333 if (!ctx->buffers)
334 return NULL;
335
336 for (i = 0; i < ctx->num_buffers; i++) {
337 if (ctx->buffers[i].status != V4L2BUF_AVAILABLE)
338 av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
339 }
340 }
341 else
342 av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
343
344 return NULL;
345 }
346
347 /* 1. handle resolution changes */
348 if (pfd.revents & POLLPRI) {
349 ret = v4l2_handle_event(ctx);
350 if (ret < 0) {
351 /* if re-init failed, abort */
352 ctx->done = 1;
353 return NULL;
354 }
355 if (ret) {
356 /* if re-init was successful drop the buffer (if there was one)
357 * since we had to reconfigure capture (unmap all buffers)
358 */
359 return NULL;
360 }
361 }
362
363 /* 2. dequeue the buffer */
364 if (pfd.revents & (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)) {
365
366 if (!V4L2_TYPE_IS_OUTPUT(ctx->type)) {
367 /* there is a capture buffer ready */
368 if (pfd.revents & (POLLIN | POLLRDNORM))
369 goto dequeue;
370
371 /* the driver is ready to accept more input; instead of waiting for the capture
372 * buffer to complete we return NULL so input can proceed (we are single threaded)
373 */
374 if (pfd.revents & (POLLOUT | POLLWRNORM))
375 return NULL;
376 }
377
378 dequeue:
379 memset(&buf, 0, sizeof(buf));
380 buf.memory = V4L2_MEMORY_MMAP;
381 buf.type = ctx->type;
382 if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
383 memset(planes, 0, sizeof(planes));
384 buf.length = VIDEO_MAX_PLANES;
385 buf.m.planes = planes;
386 }
387
388 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DQBUF, &buf);
389 if (ret) {
390 if (errno != EAGAIN) {
391 ctx->done = 1;
392 if (errno != EPIPE)
393 av_log(logger(ctx), AV_LOG_DEBUG, "%s VIDIOC_DQBUF, errno (%s)\n",
394 ctx->name, av_err2str(AVERROR(errno)));
395 }
396 return NULL;
397 }
398
399 if (ctx_to_m2mctx(ctx)->draining && !V4L2_TYPE_IS_OUTPUT(ctx->type)) {
400 int bytesused = V4L2_TYPE_IS_MULTIPLANAR(buf.type) ?
401 buf.m.planes[0].bytesused : buf.bytesused;
402 if (bytesused == 0) {
403 ctx->done = 1;
404 return NULL;
405 }
406 #ifdef V4L2_BUF_FLAG_LAST
407 if (buf.flags & V4L2_BUF_FLAG_LAST)
408 ctx->done = 1;
409 #endif
410 }
411
412 avbuf = &ctx->buffers[buf.index];
413 avbuf->status = V4L2BUF_AVAILABLE;
414 avbuf->buf = buf;
415 if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
416 memcpy(avbuf->planes, planes, sizeof(planes));
417 avbuf->buf.m.planes = avbuf->planes;
418 }
419 return avbuf;
420 }
421
422 return NULL;
423 }
424
425 static V4L2Buffer* v4l2_getfree_v4l2buf(V4L2Context *ctx)
426 {
427 int timeout = 0; /* return when no more buffers to dequeue */
428 int i;
429
430 /* get back as many output buffers as possible */
431 if (V4L2_TYPE_IS_OUTPUT(ctx->type)) {
432 do {
433 } while (v4l2_dequeue_v4l2buf(ctx, timeout));
434 }
435
436 for (i = 0; i < ctx->num_buffers; i++) {
437 if (ctx->buffers[i].status == V4L2BUF_AVAILABLE)
438 return &ctx->buffers[i];
439 }
440
441 return NULL;
442 }
443
444 static int v4l2_release_buffers(V4L2Context* ctx)
445 {
446 struct v4l2_requestbuffers req = {
447 .memory = V4L2_MEMORY_MMAP,
448 .type = ctx->type,
449 .count = 0, /* 0 -> unmaps buffers from the driver */
450 };
451 int i, j;
452
453 for (i = 0; i < ctx->num_buffers; i++) {
454 V4L2Buffer *buffer = &ctx->buffers[i];
455
456 for (j = 0; j < buffer->num_planes; j++) {
457 struct V4L2Plane_info *p = &buffer->plane_info[j];
458 if (p->mm_addr && p->length)
459 if (munmap(p->mm_addr, p->length) < 0)
460 av_log(logger(ctx), AV_LOG_ERROR, "%s unmap plane (%s))\n", ctx->name, av_err2str(AVERROR(errno)));
461 }
462 }
463
464 return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_REQBUFS, &req);
465 }
466
467 static inline int v4l2_try_raw_format(V4L2Context* ctx, enum AVPixelFormat pixfmt)
468 {
469 struct v4l2_format *fmt = &ctx->format;
470 uint32_t v4l2_fmt;
471 int ret;
472
473 v4l2_fmt = ff_v4l2_format_avfmt_to_v4l2(pixfmt);
474 if (!v4l2_fmt)
475 return AVERROR(EINVAL);
476
477 if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type))
478 fmt->fmt.pix_mp.pixelformat = v4l2_fmt;
479 else
480 fmt->fmt.pix.pixelformat = v4l2_fmt;
481
482 fmt->type = ctx->type;
483
484 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, fmt);
485 if (ret)
486 return AVERROR(EINVAL);
487
488 return 0;
489 }
490
491 static int v4l2_get_raw_format(V4L2Context* ctx, enum AVPixelFormat *p)
492 {
493 enum AVPixelFormat pixfmt = ctx->av_pix_fmt;
494 struct v4l2_fmtdesc fdesc;
495 int ret;
496
497 memset(&fdesc, 0, sizeof(fdesc));
498 fdesc.type = ctx->type;
499
500 if (pixfmt != AV_PIX_FMT_NONE) {
501 ret = v4l2_try_raw_format(ctx, pixfmt);
502 if (!ret)
503 return 0;
504 }
505
506 for (;;) {
507 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
508 if (ret)
509 return AVERROR(EINVAL);
510
511 pixfmt = ff_v4l2_format_v4l2_to_avfmt(fdesc.pixelformat, AV_CODEC_ID_RAWVIDEO);
512 ret = v4l2_try_raw_format(ctx, pixfmt);
513 if (ret){
514 fdesc.index++;
515 continue;
516 }
517
518 *p = pixfmt;
519
520 return 0;
521 }
522
523 return AVERROR(EINVAL);
524 }
525
526 static int v4l2_get_coded_format(V4L2Context* ctx, uint32_t *p)
527 {
528 struct v4l2_fmtdesc fdesc;
529 uint32_t v4l2_fmt;
530 int ret;
531
532 /* translate to a valid v4l2 format */
533 v4l2_fmt = ff_v4l2_format_avcodec_to_v4l2(ctx->av_codec_id);
534 if (!v4l2_fmt)
535 return AVERROR(EINVAL);
536
537 /* check if the driver supports this format */
538 memset(&fdesc, 0, sizeof(fdesc));
539 fdesc.type = ctx->type;
540
541 for (;;) {
542 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
543 if (ret)
544 return AVERROR(EINVAL);
545
546 if (fdesc.pixelformat == v4l2_fmt)
547 break;
548
549 fdesc.index++;
550 }
551
552 *p = v4l2_fmt;
553
554 return 0;
555 }
556
557 /*****************************************************************************
558 *
559 * V4L2 Context Interface
560 *
561 *****************************************************************************/
562
563 int ff_v4l2_context_set_status(V4L2Context* ctx, uint32_t cmd)
564 {
565 int type = ctx->type;
566 int ret;
567
568 ret = ioctl(ctx_to_m2mctx(ctx)->fd, cmd, &type);
569 if (ret < 0)
570 return AVERROR(errno);
571
572 ctx->streamon = (cmd == VIDIOC_STREAMON);
573
574 return 0;
575 }
576
577 int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* frame)
578 {
579 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
580 V4L2Buffer* avbuf;
581 int ret;
582
583 if (!frame) {
584 ret = v4l2_stop_encode(ctx);
585 if (ret)
586 av_log(logger(ctx), AV_LOG_ERROR, "%s stop_encode\n", ctx->name);
587 s->draining= 1;
588 return 0;
589 }
590
591 avbuf = v4l2_getfree_v4l2buf(ctx);
592 if (!avbuf)
593 return AVERROR(EAGAIN);
594
595 ret = ff_v4l2_buffer_avframe_to_buf(frame, avbuf);
596 if (ret)
597 return ret;
598
599 return ff_v4l2_buffer_enqueue(avbuf);
600 }
601
602 int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt)
603 {
604 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
605 V4L2Buffer* avbuf;
606 int ret;
607
608 if (!pkt->size) {
609 ret = v4l2_stop_decode(ctx);
610 if (ret)
611 av_log(logger(ctx), AV_LOG_ERROR, "%s stop_decode\n", ctx->name);
612 s->draining = 1;
613 return 0;
614 }
615
616 avbuf = v4l2_getfree_v4l2buf(ctx);
617 if (!avbuf)
618 return AVERROR(EAGAIN);
619
620 ret = ff_v4l2_buffer_avpkt_to_buf(pkt, avbuf);
621 if (ret)
622 return ret;
623
624 return ff_v4l2_buffer_enqueue(avbuf);
625 }
626
627 int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* frame, int timeout)
628 {
629 V4L2Buffer *avbuf;
630
631 /*
632 * timeout=-1 blocks until:
633 * 1. decoded frame available
634 * 2. an input buffer is ready to be dequeued
635 */
636 avbuf = v4l2_dequeue_v4l2buf(ctx, timeout);
637 if (!avbuf) {
638 if (ctx->done)
639 return AVERROR_EOF;
640
641 return AVERROR(EAGAIN);
642 }
643
644 return ff_v4l2_buffer_buf_to_avframe(frame, avbuf);
645 }
646
647 int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt)
648 {
649 V4L2Buffer *avbuf;
650
651 /*
652 * blocks until:
653 * 1. encoded packet available
654 * 2. an input buffer ready to be dequeued
655 */
656 avbuf = v4l2_dequeue_v4l2buf(ctx, -1);
657 if (!avbuf) {
658 if (ctx->done)
659 return AVERROR_EOF;
660
661 return AVERROR(EAGAIN);
662 }
663
664 return ff_v4l2_buffer_buf_to_avpkt(pkt, avbuf);
665 }
666
667 int ff_v4l2_context_get_format(V4L2Context* ctx, int probe)
668 {
669 struct v4l2_format_update fmt = { 0 };
670 int ret;
671
672 if (ctx->av_codec_id == AV_CODEC_ID_RAWVIDEO) {
673 ret = v4l2_get_raw_format(ctx, &fmt.av_fmt);
674 if (ret)
675 return ret;
676
677 fmt.update_avfmt = !probe;
678 v4l2_save_to_context(ctx, &fmt);
679
680 /* format has been tried already */
681 return ret;
682 }
683
684 ret = v4l2_get_coded_format(ctx, &fmt.v4l2_fmt);
685 if (ret)
686 return ret;
687
688 fmt.update_v4l2 = 1;
689 v4l2_save_to_context(ctx, &fmt);
690
691 return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, &ctx->format);
692 }
693
694 int ff_v4l2_context_set_format(V4L2Context* ctx)
695 {
696 return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_S_FMT, &ctx->format);
697 }
698
699 void ff_v4l2_context_release(V4L2Context* ctx)
700 {
701 int ret;
702
703 if (!ctx->buffers)
704 return;
705
706 ret = v4l2_release_buffers(ctx);
707 if (ret)
708 av_log(logger(ctx), AV_LOG_WARNING, "V4L2 failed to unmap the %s buffers\n", ctx->name);
709
710 av_freep(&ctx->buffers);
711 }
712
713 int ff_v4l2_context_init(V4L2Context* ctx)
714 {
715 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
716 struct v4l2_requestbuffers req;
717 int ret, i;
718
719 if (!v4l2_type_supported(ctx)) {
720 av_log(logger(ctx), AV_LOG_ERROR, "type %i not supported\n", ctx->type);
721 return AVERROR_PATCHWELCOME;
722 }
723
724 ret = ioctl(s->fd, VIDIOC_G_FMT, &ctx->format);
725 if (ret)
726 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT failed\n", ctx->name);
727
728 memset(&req, 0, sizeof(req));
729 req.count = ctx->num_buffers;
730 req.memory = V4L2_MEMORY_MMAP;
731 req.type = ctx->type;
732 ret = ioctl(s->fd, VIDIOC_REQBUFS, &req);
733 if (ret < 0) {
734 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_REQBUFS failed: %s\n", ctx->name, strerror(errno));
735 return AVERROR(errno);
736 }
737
738 ctx->num_buffers = req.count;
739 ctx->buffers = av_mallocz(ctx->num_buffers * sizeof(V4L2Buffer));
740 if (!ctx->buffers) {
741 av_log(logger(ctx), AV_LOG_ERROR, "%s malloc enomem\n", ctx->name);
742 return AVERROR(ENOMEM);
743 }
744
745 for (i = 0; i < req.count; i++) {
746 ctx->buffers[i].context = ctx;
747 ret = ff_v4l2_buffer_initialize(&ctx->buffers[i], i);
748 if (ret < 0) {
749 av_log(logger(ctx), AV_LOG_ERROR, "%s buffer[%d] initialization (%s)\n", ctx->name, i, av_err2str(ret));
750 goto error;
751 }
752 }
753
754 av_log(logger(ctx), AV_LOG_DEBUG, "%s: %s %02d buffers initialized: %04ux%04u, sizeimage %08u, bytesperline %08u\n", ctx->name,
755 V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? av_fourcc2str(ctx->format.fmt.pix_mp.pixelformat) : av_fourcc2str(ctx->format.fmt.pix.pixelformat),
756 req.count,
757 v4l2_get_width(&ctx->format),
758 v4l2_get_height(&ctx->format),
759 V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage : ctx->format.fmt.pix.sizeimage,
760 V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].bytesperline : ctx->format.fmt.pix.bytesperline);
761
762 return 0;
763
764 error:
765 v4l2_release_buffers(ctx);
766
767 av_freep(&ctx->buffers);
768
769 return ret;
770 }
771