FFmpeg coverage

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