2 * V4L2 context helper functions.
4 * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
5 * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
7 * This file is part of FFmpeg.
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.
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.
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
24 #include <linux/videodev2.h>
25 #include <sys/ioctl.h>
30 #include "libavcodec/avcodec.h"
31 #include "libavcodec/internal.h"
32 #include "v4l2_buffers.h"
36 struct v4l2_format_update {
40 enum AVPixelFormat av_fmt;
44 static inline V4L2m2mContext *ctx_to_m2mctx(V4L2Context *ctx)
46 return V4L2_TYPE_IS_OUTPUT(ctx->type) ?
47 container_of(ctx, V4L2m2mContext, output) :
48 container_of(ctx, V4L2m2mContext, capture);
51 static inline AVCodecContext *logger(V4L2Context *ctx)
53 return ctx_to_m2mctx(ctx)->avctx;
56 static inline unsigned int v4l2_get_width(struct v4l2_format *fmt)
58 return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.width : fmt->fmt.pix.width;
61 static inline unsigned int v4l2_get_height(struct v4l2_format *fmt)
63 return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.height : fmt->fmt.pix.height;
66 static AVRational v4l2_get_sar(V4L2Context *ctx)
68 struct AVRational sar = { 0, 1 };
69 struct v4l2_cropcap cropcap;
72 memset(&cropcap, 0, sizeof(cropcap));
73 cropcap.type = ctx->type;
75 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_CROPCAP, &cropcap);
79 sar.num = cropcap.pixelaspect.numerator;
80 sar.den = cropcap.pixelaspect.denominator;
84 static inline unsigned int v4l2_resolution_changed(V4L2Context *ctx, struct v4l2_format *fmt2)
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
91 fmt1->fmt.pix.width != fmt2->fmt.pix.width ||
92 fmt1->fmt.pix.height != fmt2->fmt.pix.height;
95 av_log(logger(ctx), AV_LOG_DEBUG, "%s changed (%dx%d) -> (%dx%d)\n",
97 v4l2_get_width(fmt1), v4l2_get_height(fmt1),
98 v4l2_get_width(fmt2), v4l2_get_height(fmt2));
103 static inline int v4l2_type_supported(V4L2Context *ctx)
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;
111 static inline int v4l2_get_framesize_compressed(V4L2Context* ctx, int width, int height)
113 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
114 const int SZ_4K = 0x1000;
117 if (s->avctx && av_codec_is_decoder(s->avctx->codec))
118 return ((width * height * 3 / 2) / 2) + 128;
121 size = FFALIGN(height, 32) * FFALIGN(width, 32) * 3 / 2 / 2;
122 return FFALIGN(size, SZ_4K);
125 static inline void v4l2_save_to_context(V4L2Context* ctx, struct v4l2_format_update *fmt)
127 ctx->format.type = ctx->type;
129 if (fmt->update_avfmt)
130 ctx->av_pix_fmt = fmt->av_fmt;
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;
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);
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;
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);
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
161 static int v4l2_handle_event(V4L2Context *ctx)
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;
169 ret = ioctl(s->fd, VIDIOC_DQEVENT, &evt);
171 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_DQEVENT\n", ctx->name);
175 if (evt.type == V4L2_EVENT_EOS) {
180 if (evt.type != V4L2_EVENT_SOURCE_CHANGE)
183 ret = ioctl(s->fd, VIDIOC_G_FMT, &out_fmt);
185 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->output.name);
189 ret = ioctl(s->fd, VIDIOC_G_FMT, &cap_fmt);
191 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->capture.name);
195 full_reinit = v4l2_resolution_changed(&s->output, &out_fmt);
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);
202 reinit = v4l2_resolution_changed(&s->capture, &cap_fmt);
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);
209 if (full_reinit || reinit)
213 ret = ff_v4l2_m2m_codec_full_reinit(s);
215 av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_full_reinit\n");
216 return AVERROR(EINVAL);
223 ret = ff_set_dimensions(s->avctx, s->capture.width, s->capture.height);
225 av_log(logger(ctx), AV_LOG_WARNING, "update avcodec height and width\n");
227 ret = ff_v4l2_m2m_codec_reinit(s);
229 av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_reinit\n");
230 return AVERROR(EINVAL);
235 /* dummy event received */
238 /* reinit executed */
243 static int v4l2_stop_decode(V4L2Context *ctx)
245 struct v4l2_decoder_cmd cmd = {
246 .cmd = V4L2_DEC_CMD_STOP,
251 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DECODER_CMD, &cmd);
253 /* DECODER_CMD is optional */
255 return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
257 return AVERROR(errno);
263 static int v4l2_stop_encode(V4L2Context *ctx)
265 struct v4l2_encoder_cmd cmd = {
266 .cmd = V4L2_ENC_CMD_STOP,
271 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENCODER_CMD, &cmd);
273 /* ENCODER_CMD is optional */
275 return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
277 return AVERROR(errno);
283 static V4L2Buffer* v4l2_dequeue_v4l2buf(V4L2Context *ctx, int timeout)
285 struct v4l2_plane planes[VIDEO_MAX_PLANES];
286 struct v4l2_buffer buf = { 0 };
288 struct pollfd pfd = {
289 .events = POLLIN | POLLRDNORM | POLLPRI | POLLOUT | POLLWRNORM, /* default blocking capture */
290 .fd = ctx_to_m2mctx(ctx)->fd,
294 /* if we are draining and there are no more capture buffers queued in the driver we are done */
295 if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx_to_m2mctx(ctx)->draining) {
296 for (i = 0; i < ctx->num_buffers; i++) {
297 /* capture buffer initialization happens during decode hence
298 * detection happens at runtime
303 if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
311 if (V4L2_TYPE_IS_OUTPUT(ctx->type))
312 pfd.events = POLLOUT | POLLWRNORM;
314 /* no need to listen to requests for more input while draining */
315 if (ctx_to_m2mctx(ctx)->draining)
316 pfd.events = POLLIN | POLLRDNORM | POLLPRI;
320 ret = poll(&pfd, 1, timeout);
328 /* 0. handle errors */
329 if (pfd.revents & POLLERR) {
330 /* if we are trying to get free buffers but none have been queued yet
331 no need to raise a warning */
333 for (i = 0; i < ctx->num_buffers; i++) {
334 if (ctx->buffers[i].status != V4L2BUF_AVAILABLE)
335 av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
339 av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
344 /* 1. handle resolution changes */
345 if (pfd.revents & POLLPRI) {
346 ret = v4l2_handle_event(ctx);
348 /* if re-init failed, abort */
353 /* if re-init was successful drop the buffer (if there was one)
354 * since we had to reconfigure capture (unmap all buffers)
360 /* 2. dequeue the buffer */
361 if (pfd.revents & (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)) {
363 if (!V4L2_TYPE_IS_OUTPUT(ctx->type)) {
364 /* there is a capture buffer ready */
365 if (pfd.revents & (POLLIN | POLLRDNORM))
368 /* the driver is ready to accept more input; instead of waiting for the capture
369 * buffer to complete we return NULL so input can proceed (we are single threaded)
371 if (pfd.revents & (POLLOUT | POLLWRNORM))
376 memset(&buf, 0, sizeof(buf));
377 buf.memory = V4L2_MEMORY_MMAP;
378 buf.type = ctx->type;
379 if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
380 memset(planes, 0, sizeof(planes));
381 buf.length = VIDEO_MAX_PLANES;
382 buf.m.planes = planes;
385 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DQBUF, &buf);
387 if (errno != EAGAIN) {
390 av_log(logger(ctx), AV_LOG_DEBUG, "%s VIDIOC_DQBUF, errno (%s)\n",
391 ctx->name, av_err2str(AVERROR(errno)));
396 avbuf = &ctx->buffers[buf.index];
397 avbuf->status = V4L2BUF_AVAILABLE;
399 if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
400 memcpy(avbuf->planes, planes, sizeof(planes));
401 avbuf->buf.m.planes = avbuf->planes;
409 static V4L2Buffer* v4l2_getfree_v4l2buf(V4L2Context *ctx)
411 int timeout = 0; /* return when no more buffers to dequeue */
414 /* get back as many output buffers as possible */
415 if (V4L2_TYPE_IS_OUTPUT(ctx->type)) {
417 } while (v4l2_dequeue_v4l2buf(ctx, timeout));
420 for (i = 0; i < ctx->num_buffers; i++) {
421 if (ctx->buffers[i].status == V4L2BUF_AVAILABLE)
422 return &ctx->buffers[i];
428 static int v4l2_release_buffers(V4L2Context* ctx)
430 struct v4l2_requestbuffers req = {
431 .memory = V4L2_MEMORY_MMAP,
433 .count = 0, /* 0 -> unmaps buffers from the driver */
437 for (i = 0; i < ctx->num_buffers; i++) {
438 V4L2Buffer *buffer = &ctx->buffers[i];
440 for (j = 0; j < buffer->num_planes; j++) {
441 struct V4L2Plane_info *p = &buffer->plane_info[j];
442 if (p->mm_addr && p->length)
443 if (munmap(p->mm_addr, p->length) < 0)
444 av_log(logger(ctx), AV_LOG_ERROR, "%s unmap plane (%s))\n", ctx->name, av_err2str(AVERROR(errno)));
448 return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_REQBUFS, &req);
451 static inline int v4l2_try_raw_format(V4L2Context* ctx, enum AVPixelFormat pixfmt)
453 struct v4l2_format *fmt = &ctx->format;
457 v4l2_fmt = ff_v4l2_format_avfmt_to_v4l2(pixfmt);
459 return AVERROR(EINVAL);
461 if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type))
462 fmt->fmt.pix_mp.pixelformat = v4l2_fmt;
464 fmt->fmt.pix.pixelformat = v4l2_fmt;
466 fmt->type = ctx->type;
468 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, fmt);
470 return AVERROR(EINVAL);
475 static int v4l2_get_raw_format(V4L2Context* ctx, enum AVPixelFormat *p)
477 enum AVPixelFormat pixfmt = ctx->av_pix_fmt;
478 struct v4l2_fmtdesc fdesc;
481 memset(&fdesc, 0, sizeof(fdesc));
482 fdesc.type = ctx->type;
484 if (pixfmt != AV_PIX_FMT_NONE) {
485 ret = v4l2_try_raw_format(ctx, pixfmt);
491 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
493 return AVERROR(EINVAL);
495 pixfmt = ff_v4l2_format_v4l2_to_avfmt(fdesc.pixelformat, AV_CODEC_ID_RAWVIDEO);
496 ret = v4l2_try_raw_format(ctx, pixfmt);
507 return AVERROR(EINVAL);
510 static int v4l2_get_coded_format(V4L2Context* ctx, uint32_t *p)
512 struct v4l2_fmtdesc fdesc;
516 /* translate to a valid v4l2 format */
517 v4l2_fmt = ff_v4l2_format_avcodec_to_v4l2(ctx->av_codec_id);
519 return AVERROR(EINVAL);
521 /* check if the driver supports this format */
522 memset(&fdesc, 0, sizeof(fdesc));
523 fdesc.type = ctx->type;
526 ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
528 return AVERROR(EINVAL);
530 if (fdesc.pixelformat == v4l2_fmt)
541 /*****************************************************************************
543 * V4L2 Context Interface
545 *****************************************************************************/
547 int ff_v4l2_context_set_status(V4L2Context* ctx, uint32_t cmd)
549 int type = ctx->type;
552 ret = ioctl(ctx_to_m2mctx(ctx)->fd, cmd, &type);
554 return AVERROR(errno);
556 ctx->streamon = (cmd == VIDIOC_STREAMON);
561 int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* frame)
563 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
568 ret = v4l2_stop_encode(ctx);
570 av_log(logger(ctx), AV_LOG_ERROR, "%s stop_encode\n", ctx->name);
575 avbuf = v4l2_getfree_v4l2buf(ctx);
577 return AVERROR(ENOMEM);
579 ret = ff_v4l2_buffer_avframe_to_buf(frame, avbuf);
583 return ff_v4l2_buffer_enqueue(avbuf);
586 int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt)
588 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
593 ret = v4l2_stop_decode(ctx);
595 av_log(logger(ctx), AV_LOG_ERROR, "%s stop_decode\n", ctx->name);
600 avbuf = v4l2_getfree_v4l2buf(ctx);
602 return AVERROR(EAGAIN);
604 ret = ff_v4l2_buffer_avpkt_to_buf(pkt, avbuf);
608 return ff_v4l2_buffer_enqueue(avbuf);
611 int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* frame, int timeout)
616 * timeout=-1 blocks until:
617 * 1. decoded frame available
618 * 2. an input buffer is ready to be dequeued
620 avbuf = v4l2_dequeue_v4l2buf(ctx, timeout);
625 return AVERROR(EAGAIN);
628 return ff_v4l2_buffer_buf_to_avframe(frame, avbuf);
631 int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt)
637 * 1. encoded packet available
638 * 2. an input buffer ready to be dequeued
640 avbuf = v4l2_dequeue_v4l2buf(ctx, -1);
645 return AVERROR(EAGAIN);
648 return ff_v4l2_buffer_buf_to_avpkt(pkt, avbuf);
651 int ff_v4l2_context_get_format(V4L2Context* ctx, int probe)
653 struct v4l2_format_update fmt = { 0 };
656 if (ctx->av_codec_id == AV_CODEC_ID_RAWVIDEO) {
657 ret = v4l2_get_raw_format(ctx, &fmt.av_fmt);
661 fmt.update_avfmt = !probe;
662 v4l2_save_to_context(ctx, &fmt);
664 /* format has been tried already */
668 ret = v4l2_get_coded_format(ctx, &fmt.v4l2_fmt);
673 v4l2_save_to_context(ctx, &fmt);
675 return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, &ctx->format);
678 int ff_v4l2_context_set_format(V4L2Context* ctx)
680 return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_S_FMT, &ctx->format);
683 void ff_v4l2_context_release(V4L2Context* ctx)
690 ret = v4l2_release_buffers(ctx);
692 av_log(logger(ctx), AV_LOG_WARNING, "V4L2 failed to unmap the %s buffers\n", ctx->name);
694 av_freep(&ctx->buffers);
697 int ff_v4l2_context_init(V4L2Context* ctx)
699 V4L2m2mContext *s = ctx_to_m2mctx(ctx);
700 struct v4l2_requestbuffers req;
703 if (!v4l2_type_supported(ctx)) {
704 av_log(logger(ctx), AV_LOG_ERROR, "type %i not supported\n", ctx->type);
705 return AVERROR_PATCHWELCOME;
708 ret = ioctl(s->fd, VIDIOC_G_FMT, &ctx->format);
710 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT failed\n", ctx->name);
712 memset(&req, 0, sizeof(req));
713 req.count = ctx->num_buffers;
714 req.memory = V4L2_MEMORY_MMAP;
715 req.type = ctx->type;
716 ret = ioctl(s->fd, VIDIOC_REQBUFS, &req);
718 av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_REQBUFS failed: %s\n", ctx->name, strerror(errno));
719 return AVERROR(errno);
722 ctx->num_buffers = req.count;
723 ctx->buffers = av_mallocz(ctx->num_buffers * sizeof(V4L2Buffer));
725 av_log(logger(ctx), AV_LOG_ERROR, "%s malloc enomem\n", ctx->name);
726 return AVERROR(ENOMEM);
729 for (i = 0; i < req.count; i++) {
730 ctx->buffers[i].context = ctx;
731 ret = ff_v4l2_buffer_initialize(&ctx->buffers[i], i);
733 av_log(logger(ctx), AV_LOG_ERROR, "%s buffer[%d] initialization (%s)\n", ctx->name, i, av_err2str(ret));
738 av_log(logger(ctx), AV_LOG_DEBUG, "%s: %s %02d buffers initialized: %04ux%04u, sizeimage %08u, bytesperline %08u\n", ctx->name,
739 V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? av_fourcc2str(ctx->format.fmt.pix_mp.pixelformat) : av_fourcc2str(ctx->format.fmt.pix.pixelformat),
741 v4l2_get_width(&ctx->format),
742 v4l2_get_height(&ctx->format),
743 V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage : ctx->format.fmt.pix.sizeimage,
744 V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].bytesperline : ctx->format.fmt.pix.bytesperline);
749 v4l2_release_buffers(ctx);
751 av_freep(&ctx->buffers);