libavcodec/v4l2_context.c - manifest_repos/ffmpeg - Git at Google

 /*
  * V4L2 context helper functions.
  *
  * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
  * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 #include <linux/videodev2.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <poll.h>
 #include "libavcodec/avcodec.h"
 #include "libavcodec/internal.h"
 #include "v4l2_buffers.h"
 #include "v4l2_fmt.h"
 #include "v4l2_m2m.h"

 struct v4l2_format_update {
     uint32_t v4l2_fmt;
     int update_v4l2;

     enum AVPixelFormat av_fmt;
     int update_avfmt;
 };

 static inline V4L2m2mContext *ctx_to_m2mctx(V4L2Context *ctx)
 {
     return V4L2_TYPE_IS_OUTPUT(ctx->type) ?
         container_of(ctx, V4L2m2mContext, output) :
         container_of(ctx, V4L2m2mContext, capture);
 }

 static inline AVCodecContext *logger(V4L2Context *ctx)
 {
     return ctx_to_m2mctx(ctx)->avctx;
 }

 static inline unsigned int v4l2_get_width(struct v4l2_format *fmt)
 {
     return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.width : fmt->fmt.pix.width;
 }

 static inline unsigned int v4l2_get_height(struct v4l2_format *fmt)
 {
     return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.height : fmt->fmt.pix.height;
 }

 static AVRational v4l2_get_sar(V4L2Context *ctx)
 {
     struct AVRational sar = { 0, 1 };
     struct v4l2_cropcap cropcap;
     int ret;

     memset(&cropcap, 0, sizeof(cropcap));
     cropcap.type = ctx->type;

     ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_CROPCAP, &cropcap);
     if (ret)
         return sar;

     sar.num = cropcap.pixelaspect.numerator;
     sar.den = cropcap.pixelaspect.denominator;
     return sar;
 }

 static inline unsigned int v4l2_resolution_changed(V4L2Context *ctx, struct v4l2_format *fmt2)
 {
     struct v4l2_format *fmt1 = &ctx->format;
     int ret =  V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
         fmt1->fmt.pix_mp.width != fmt2->fmt.pix_mp.width ||
         fmt1->fmt.pix_mp.height != fmt2->fmt.pix_mp.height
         :
         fmt1->fmt.pix.width != fmt2->fmt.pix.width ||
         fmt1->fmt.pix.height != fmt2->fmt.pix.height;

     if (ret)
         av_log(logger(ctx), AV_LOG_DEBUG, "%s changed (%dx%d) -> (%dx%d)\n",
             ctx->name,
             v4l2_get_width(fmt1), v4l2_get_height(fmt1),
             v4l2_get_width(fmt2), v4l2_get_height(fmt2));

     return ret;
 }

 static inline int v4l2_type_supported(V4L2Context *ctx)
 {
     return ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
         ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
         ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
         ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT;
 }

 static inline int v4l2_get_framesize_compressed(V4L2Context* ctx, int width, int height)
 {
     V4L2m2mContext *s = ctx_to_m2mctx(ctx);
     const int SZ_4K = 0x1000;
     int size;

     if (s->avctx && av_codec_is_decoder(s->avctx->codec))
         return ((width * height * 3 / 2) / 2) + 128;

     /* encoder */
     size = FFALIGN(height, 32) * FFALIGN(width, 32) * 3 / 2 / 2;
     return FFALIGN(size, SZ_4K);
 }

 static inline void v4l2_save_to_context(V4L2Context* ctx, struct v4l2_format_update *fmt)
 {
     ctx->format.type = ctx->type;

     if (fmt->update_avfmt)
         ctx->av_pix_fmt = fmt->av_fmt;

     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
         /* update the sizes to handle the reconfiguration of the capture stream at runtime */
         ctx->format.fmt.pix_mp.height = ctx->height;
         ctx->format.fmt.pix_mp.width = ctx->width;
         if (fmt->update_v4l2) {
             ctx->format.fmt.pix_mp.pixelformat = fmt->v4l2_fmt;

             /* s5p-mfc requires the user to specify a buffer size */
             ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage =
                 v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
         }
     } else {
         ctx->format.fmt.pix.height = ctx->height;
         ctx->format.fmt.pix.width = ctx->width;
         if (fmt->update_v4l2) {
             ctx->format.fmt.pix.pixelformat = fmt->v4l2_fmt;

             /* s5p-mfc requires the user to specify a buffer size */
             ctx->format.fmt.pix.sizeimage =
                 v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
         }
     }
 }

 /**
  * handle resolution change event and end of stream event
  * returns 1 if reinit was successful, negative if it failed
  * returns 0 if reinit was not executed
  */
 static int v4l2_handle_event(V4L2Context *ctx)
 {
     V4L2m2mContext *s = ctx_to_m2mctx(ctx);
     struct v4l2_format cap_fmt = s->capture.format;
     struct v4l2_format out_fmt = s->output.format;
     struct v4l2_event evt = { 0 };
     int full_reinit, reinit, ret;

     ret = ioctl(s->fd, VIDIOC_DQEVENT, &evt);
     if (ret < 0) {
         av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_DQEVENT\n", ctx->name);
         return 0;
     }

     if (evt.type == V4L2_EVENT_EOS) {
         ctx->done = 1;
         return 0;
     }

     if (evt.type != V4L2_EVENT_SOURCE_CHANGE)
         return 0;

     ret = ioctl(s->fd, VIDIOC_G_FMT, &out_fmt);
     if (ret) {
         av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->output.name);
         return 0;
     }

     ret = ioctl(s->fd, VIDIOC_G_FMT, &cap_fmt);
     if (ret) {
         av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->capture.name);
         return 0;
     }

     full_reinit = v4l2_resolution_changed(&s->output, &out_fmt);
     if (full_reinit) {
         s->output.height = v4l2_get_height(&out_fmt);
         s->output.width = v4l2_get_width(&out_fmt);
         s->output.sample_aspect_ratio = v4l2_get_sar(&s->output);
     }

     reinit = v4l2_resolution_changed(&s->capture, &cap_fmt);
     if (reinit) {
         s->capture.height = v4l2_get_height(&cap_fmt);
         s->capture.width = v4l2_get_width(&cap_fmt);
         s->capture.sample_aspect_ratio = v4l2_get_sar(&s->capture);
     }

     if (full_reinit || reinit)
         s->reinit = 1;

     if (full_reinit) {
         ret = ff_v4l2_m2m_codec_full_reinit(s);
         if (ret) {
             av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_full_reinit\n");
             return AVERROR(EINVAL);
         }
         goto reinit_run;
     }

     if (reinit) {
         if (s->avctx)
             ret = ff_set_dimensions(s->avctx, s->capture.width, s->capture.height);
         if (ret < 0)
             av_log(logger(ctx), AV_LOG_WARNING, "update avcodec height and width\n");

         ret = ff_v4l2_m2m_codec_reinit(s);
         if (ret) {
             av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_reinit\n");
             return AVERROR(EINVAL);
         }
         goto reinit_run;
     }

     /* dummy event received */
     return 0;

     /* reinit executed */
 reinit_run:
     return 1;
 }

 static int v4l2_stop_decode(V4L2Context *ctx)
 {
     struct v4l2_decoder_cmd cmd = {
         .cmd = V4L2_DEC_CMD_STOP,
         .flags = 0,
     };
     int ret;

     ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DECODER_CMD, &cmd);
     if (ret) {
         /* DECODER_CMD is optional */
         if (errno == ENOTTY)
             return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
         else
             return AVERROR(errno);
     }

     return 0;
 }

 static int v4l2_stop_encode(V4L2Context *ctx)
 {
     struct v4l2_encoder_cmd cmd = {
         .cmd = V4L2_ENC_CMD_STOP,
         .flags = 0,
     };
     int ret;

     ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENCODER_CMD, &cmd);
     if (ret) {
         /* ENCODER_CMD is optional */
         if (errno == ENOTTY)
             return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
         else
             return AVERROR(errno);
     }

     return 0;
 }

 static V4L2Buffer* v4l2_dequeue_v4l2buf(V4L2Context *ctx, int timeout)
 {
     struct v4l2_plane planes[VIDEO_MAX_PLANES];
     struct v4l2_buffer buf = { 0 };
     V4L2Buffer *avbuf;
     struct pollfd pfd = {
         .events =  POLLIN | POLLRDNORM | POLLPRI | POLLOUT | POLLWRNORM, /* default blocking capture */
         .fd = ctx_to_m2mctx(ctx)->fd,
     };
     int i, ret;

     if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx->buffers) {
         for (i = 0; i < ctx->num_buffers; i++) {
             if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
                 break;
         }
         if (i == ctx->num_buffers)
             av_log(logger(ctx), AV_LOG_WARNING, "All capture buffers returned to "
                                                 "userspace. Increase num_capture_buffers "
                                                 "to prevent device deadlock or dropped "
                                                 "packets/frames.\n");
     }

     /* if we are draining and there are no more capture buffers queued in the driver we are done */
     if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx_to_m2mctx(ctx)->draining) {
         for (i = 0; i < ctx->num_buffers; i++) {
             /* capture buffer initialization happens during decode hence
              * detection happens at runtime
              */
             if (!ctx->buffers)
                 break;

             if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
                 goto start;
         }
         ctx->done = 1;
         return NULL;
     }

 start:
     if (V4L2_TYPE_IS_OUTPUT(ctx->type))
         pfd.events =  POLLOUT | POLLWRNORM;
     else {
         /* no need to listen to requests for more input while draining */
         if (ctx_to_m2mctx(ctx)->draining)
             pfd.events =  POLLIN | POLLRDNORM | POLLPRI;
     }

     for (;;) {
         ret = poll(&pfd, 1, timeout);
         if (ret > 0)
             break;
         if (errno == EINTR)
             continue;
         return NULL;
     }

     /* 0. handle errors */
     if (pfd.revents & POLLERR) {
         /* if we are trying to get free buffers but none have been queued yet
            no need to raise a warning */
         if (timeout == 0) {
             for (i = 0; i < ctx->num_buffers; i++) {
                 if (ctx->buffers[i].status != V4L2BUF_AVAILABLE)
                     av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
             }
         }
         else
             av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);

         return NULL;
     }

     /* 1. handle resolution changes */
     if (pfd.revents & POLLPRI) {
         ret = v4l2_handle_event(ctx);
         if (ret < 0) {
             /* if re-init failed, abort */
             ctx->done = 1;
             return NULL;
         }
         if (ret) {
             /* if re-init was successful drop the buffer (if there was one)
              * since we had to reconfigure capture (unmap all buffers)
              */
             return NULL;
         }
     }

     /* 2. dequeue the buffer */
     if (pfd.revents & (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)) {

         if (!V4L2_TYPE_IS_OUTPUT(ctx->type)) {
             /* there is a capture buffer ready */
             if (pfd.revents & (POLLIN | POLLRDNORM))
                 goto dequeue;

             /* the driver is ready to accept more input; instead of waiting for the capture
              * buffer to complete we return NULL so input can proceed (we are single threaded)
              */
             if (pfd.revents & (POLLOUT | POLLWRNORM))
                 return NULL;
         }

 dequeue:
         memset(&buf, 0, sizeof(buf));
         buf.memory = V4L2_MEMORY_MMAP;
         buf.type = ctx->type;
         if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
             memset(planes, 0, sizeof(planes));
             buf.length = VIDEO_MAX_PLANES;
             buf.m.planes = planes;
         }

         ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DQBUF, &buf);
         if (ret) {
             if (errno != EAGAIN) {
                 ctx->done = 1;
                 if (errno != EPIPE)
                     av_log(logger(ctx), AV_LOG_DEBUG, "%s VIDIOC_DQBUF, errno (%s)\n",
                         ctx->name, av_err2str(AVERROR(errno)));
             }
             return NULL;
         }

         if (ctx_to_m2mctx(ctx)->draining && !V4L2_TYPE_IS_OUTPUT(ctx->type)) {
             int bytesused = V4L2_TYPE_IS_MULTIPLANAR(buf.type) ?
                             buf.m.planes[0].bytesused : buf.bytesused;
             if (bytesused == 0) {
                 ctx->done = 1;
                 return NULL;
             }
 #ifdef V4L2_BUF_FLAG_LAST
             if (buf.flags & V4L2_BUF_FLAG_LAST)
                 ctx->done = 1;
 #endif
         }

         avbuf = &ctx->buffers[buf.index];
         avbuf->status = V4L2BUF_AVAILABLE;
         avbuf->buf = buf;
         if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
             memcpy(avbuf->planes, planes, sizeof(planes));
             avbuf->buf.m.planes = avbuf->planes;
         }
         return avbuf;
     }

     return NULL;
 }

 static V4L2Buffer* v4l2_getfree_v4l2buf(V4L2Context *ctx)
 {
     int timeout = 0; /* return when no more buffers to dequeue */
     int i;

     /* get back as many output buffers as possible */
     if (V4L2_TYPE_IS_OUTPUT(ctx->type)) {
           do {
           } while (v4l2_dequeue_v4l2buf(ctx, timeout));
     }

     for (i = 0; i < ctx->num_buffers; i++) {
         if (ctx->buffers[i].status == V4L2BUF_AVAILABLE)
             return &ctx->buffers[i];
     }

     return NULL;
 }

 static int v4l2_release_buffers(V4L2Context* ctx)
 {
     struct v4l2_requestbuffers req = {
         .memory = V4L2_MEMORY_MMAP,
         .type = ctx->type,
         .count = 0, /* 0 -> unmaps buffers from the driver */
     };
     int i, j;

     for (i = 0; i < ctx->num_buffers; i++) {
         V4L2Buffer *buffer = &ctx->buffers[i];

         for (j = 0; j < buffer->num_planes; j++) {
             struct V4L2Plane_info *p = &buffer->plane_info[j];
             if (p->mm_addr && p->length)
                 if (munmap(p->mm_addr, p->length) < 0)
                     av_log(logger(ctx), AV_LOG_ERROR, "%s unmap plane (%s))\n", ctx->name, av_err2str(AVERROR(errno)));
         }
     }

     return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_REQBUFS, &req);
 }

 static inline int v4l2_try_raw_format(V4L2Context* ctx, enum AVPixelFormat pixfmt)
 {
     struct v4l2_format *fmt = &ctx->format;
     uint32_t v4l2_fmt;
     int ret;

     v4l2_fmt = ff_v4l2_format_avfmt_to_v4l2(pixfmt);
     if (!v4l2_fmt)
         return AVERROR(EINVAL);

     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type))
         fmt->fmt.pix_mp.pixelformat = v4l2_fmt;
     else
         fmt->fmt.pix.pixelformat = v4l2_fmt;

     fmt->type = ctx->type;

     ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, fmt);
     if (ret)
         return AVERROR(EINVAL);

     return 0;
 }

 static int v4l2_get_raw_format(V4L2Context* ctx, enum AVPixelFormat *p)
 {
     enum AVPixelFormat pixfmt = ctx->av_pix_fmt;
     struct v4l2_fmtdesc fdesc;
     int ret;

     memset(&fdesc, 0, sizeof(fdesc));
     fdesc.type = ctx->type;

     if (pixfmt != AV_PIX_FMT_NONE) {
         ret = v4l2_try_raw_format(ctx, pixfmt);
         if (!ret)
             return 0;
     }

     for (;;) {
         ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
         if (ret)
             return AVERROR(EINVAL);

         pixfmt = ff_v4l2_format_v4l2_to_avfmt(fdesc.pixelformat, AV_CODEC_ID_RAWVIDEO);
         ret = v4l2_try_raw_format(ctx, pixfmt);
         if (ret){
             fdesc.index++;
             continue;
         }

         *p = pixfmt;

         return 0;
     }

     return AVERROR(EINVAL);
 }

 static int v4l2_get_coded_format(V4L2Context* ctx, uint32_t *p)
 {
     struct v4l2_fmtdesc fdesc;
     uint32_t v4l2_fmt;
     int ret;

     /* translate to a valid v4l2 format */
     v4l2_fmt = ff_v4l2_format_avcodec_to_v4l2(ctx->av_codec_id);
     if (!v4l2_fmt)
         return AVERROR(EINVAL);

     /* check if the driver supports this format */
     memset(&fdesc, 0, sizeof(fdesc));
     fdesc.type = ctx->type;

     for (;;) {
         ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
         if (ret)
             return AVERROR(EINVAL);

         if (fdesc.pixelformat == v4l2_fmt)
             break;

         fdesc.index++;
     }

     *p = v4l2_fmt;

     return 0;
 }

  /*****************************************************************************
   *
   *             V4L2 Context Interface
   *
   *****************************************************************************/

 int ff_v4l2_context_set_status(V4L2Context* ctx, uint32_t cmd)
 {
     int type = ctx->type;
     int ret;

     ret = ioctl(ctx_to_m2mctx(ctx)->fd, cmd, &type);
     if (ret < 0)
         return AVERROR(errno);

     ctx->streamon = (cmd == VIDIOC_STREAMON);

     return 0;
 }

 int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* frame)
 {
     V4L2m2mContext *s = ctx_to_m2mctx(ctx);
     V4L2Buffer* avbuf;
     int ret;

     if (!frame) {
         ret = v4l2_stop_encode(ctx);
         if (ret)
             av_log(logger(ctx), AV_LOG_ERROR, "%s stop_encode\n", ctx->name);
         s->draining= 1;
         return 0;
     }

     avbuf = v4l2_getfree_v4l2buf(ctx);
     if (!avbuf)
         return AVERROR(EAGAIN);

     ret = ff_v4l2_buffer_avframe_to_buf(frame, avbuf);
     if (ret)
         return ret;

     return ff_v4l2_buffer_enqueue(avbuf);
 }

 int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt)
 {
     V4L2m2mContext *s = ctx_to_m2mctx(ctx);
     V4L2Buffer* avbuf;
     int ret;

     if (!pkt->size) {
         ret = v4l2_stop_decode(ctx);
         if (ret)
             av_log(logger(ctx), AV_LOG_ERROR, "%s stop_decode\n", ctx->name);
         s->draining = 1;
         return 0;
     }

     avbuf = v4l2_getfree_v4l2buf(ctx);
     if (!avbuf)
         return AVERROR(EAGAIN);

     ret = ff_v4l2_buffer_avpkt_to_buf(pkt, avbuf);
     if (ret)
         return ret;

     return ff_v4l2_buffer_enqueue(avbuf);
 }

 int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* frame, int timeout)
 {
     V4L2Buffer *avbuf;

     /*
      * timeout=-1 blocks until:
      *  1. decoded frame available
      *  2. an input buffer is ready to be dequeued
      */
     avbuf = v4l2_dequeue_v4l2buf(ctx, timeout);
     if (!avbuf) {
         if (ctx->done)
             return AVERROR_EOF;

         return AVERROR(EAGAIN);
     }

     return ff_v4l2_buffer_buf_to_avframe(frame, avbuf);
 }

 int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt)
 {
     V4L2Buffer *avbuf;

     /*
      * blocks until:
      *  1. encoded packet available
      *  2. an input buffer ready to be dequeued
      */
     avbuf = v4l2_dequeue_v4l2buf(ctx, -1);
     if (!avbuf) {
         if (ctx->done)
             return AVERROR_EOF;

         return AVERROR(EAGAIN);
     }

     return ff_v4l2_buffer_buf_to_avpkt(pkt, avbuf);
 }

 int ff_v4l2_context_get_format(V4L2Context* ctx, int probe)
 {
     struct v4l2_format_update fmt = { 0 };
     int ret;

     if  (ctx->av_codec_id == AV_CODEC_ID_RAWVIDEO) {
         ret = v4l2_get_raw_format(ctx, &fmt.av_fmt);
         if (ret)
             return ret;

         fmt.update_avfmt = !probe;
         v4l2_save_to_context(ctx, &fmt);

         /* format has been tried already */
         return ret;
     }

     ret = v4l2_get_coded_format(ctx, &fmt.v4l2_fmt);
     if (ret)
         return ret;

     fmt.update_v4l2 = 1;
     v4l2_save_to_context(ctx, &fmt);

     return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, &ctx->format);
 }

 int ff_v4l2_context_set_format(V4L2Context* ctx)
 {
     return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_S_FMT, &ctx->format);
 }

 void ff_v4l2_context_release(V4L2Context* ctx)
 {
     int ret;

     if (!ctx->buffers)
         return;

     ret = v4l2_release_buffers(ctx);
     if (ret)
         av_log(logger(ctx), AV_LOG_WARNING, "V4L2 failed to unmap the %s buffers\n", ctx->name);

     av_freep(&ctx->buffers);
 }

 int ff_v4l2_context_init(V4L2Context* ctx)
 {
     V4L2m2mContext *s = ctx_to_m2mctx(ctx);
     struct v4l2_requestbuffers req;
     int ret, i;

     if (!v4l2_type_supported(ctx)) {
         av_log(logger(ctx), AV_LOG_ERROR, "type %i not supported\n", ctx->type);
         return AVERROR_PATCHWELCOME;
     }

     ret = ioctl(s->fd, VIDIOC_G_FMT, &ctx->format);
     if (ret)
         av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT failed\n", ctx->name);

     memset(&req, 0, sizeof(req));
     req.count = ctx->num_buffers;
     req.memory = V4L2_MEMORY_MMAP;
     req.type = ctx->type;
     ret = ioctl(s->fd, VIDIOC_REQBUFS, &req);
     if (ret < 0) {
         av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_REQBUFS failed: %s\n", ctx->name, strerror(errno));
         return AVERROR(errno);
     }

     ctx->num_buffers = req.count;
     ctx->buffers = av_mallocz(ctx->num_buffers * sizeof(V4L2Buffer));
     if (!ctx->buffers) {
         av_log(logger(ctx), AV_LOG_ERROR, "%s malloc enomem\n", ctx->name);
         return AVERROR(ENOMEM);
     }

     for (i = 0; i < req.count; i++) {
         ctx->buffers[i].context = ctx;
         ret = ff_v4l2_buffer_initialize(&ctx->buffers[i], i);
         if (ret < 0) {
             av_log(logger(ctx), AV_LOG_ERROR, "%s buffer[%d] initialization (%s)\n", ctx->name, i, av_err2str(ret));
             goto error;
         }
     }

     av_log(logger(ctx), AV_LOG_DEBUG, "%s: %s %02d buffers initialized: %04ux%04u, sizeimage %08u, bytesperline %08u\n", ctx->name,
         V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? av_fourcc2str(ctx->format.fmt.pix_mp.pixelformat) : av_fourcc2str(ctx->format.fmt.pix.pixelformat),
         req.count,
         v4l2_get_width(&ctx->format),
         v4l2_get_height(&ctx->format),
         V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage : ctx->format.fmt.pix.sizeimage,
         V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].bytesperline : ctx->format.fmt.pix.bytesperline);

     return 0;

 error:
     v4l2_release_buffers(ctx);

     av_freep(&ctx->buffers);

     return ret;
 }
	/*
	* V4L2 context helper functions.
	*
	* Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
	* Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
	*
	* This file is part of FFmpeg.
	*
	* FFmpeg is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* FFmpeg is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <linux/videodev2.h>
	#include <sys/ioctl.h>
	#include <sys/mman.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <poll.h>
	#include "libavcodec/avcodec.h"
	#include "libavcodec/internal.h"
	#include "v4l2_buffers.h"
	#include "v4l2_fmt.h"
	#include "v4l2_m2m.h"

	struct v4l2_format_update {
	uint32_t v4l2_fmt;
	int update_v4l2;

	enum AVPixelFormat av_fmt;
	int update_avfmt;
	};

	static inline V4L2m2mContext ctx_to_m2mctx(V4L2Context ctx)
	{
	return V4L2_TYPE_IS_OUTPUT(ctx->type) ?
	container_of(ctx, V4L2m2mContext, output) :
	container_of(ctx, V4L2m2mContext, capture);
	}

	static inline AVCodecContext logger(V4L2Context ctx)
	{
	return ctx_to_m2mctx(ctx)->avctx;
	}

	static inline unsigned int v4l2_get_width(struct v4l2_format *fmt)
	{
	return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.width : fmt->fmt.pix.width;
	}

	static inline unsigned int v4l2_get_height(struct v4l2_format *fmt)
	{
	return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.height : fmt->fmt.pix.height;
	}

	static AVRational v4l2_get_sar(V4L2Context *ctx)
	{
	struct AVRational sar = { 0, 1 };
	struct v4l2_cropcap cropcap;
	int ret;

	memset(&cropcap, 0, sizeof(cropcap));
	cropcap.type = ctx->type;

	ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_CROPCAP, &cropcap);
	if (ret)
	return sar;

	sar.num = cropcap.pixelaspect.numerator;
	sar.den = cropcap.pixelaspect.denominator;
	return sar;
	}

	static inline unsigned int v4l2_resolution_changed(V4L2Context ctx, struct v4l2_format fmt2)
	{
	struct v4l2_format *fmt1 = &ctx->format;
	int ret = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
	fmt1->fmt.pix_mp.width != fmt2->fmt.pix_mp.width \|\|
	fmt1->fmt.pix_mp.height != fmt2->fmt.pix_mp.height
	:
	fmt1->fmt.pix.width != fmt2->fmt.pix.width \|\|
	fmt1->fmt.pix.height != fmt2->fmt.pix.height;

	if (ret)
	av_log(logger(ctx), AV_LOG_DEBUG, "%s changed (%dx%d) -> (%dx%d)\n",
	ctx->name,
	v4l2_get_width(fmt1), v4l2_get_height(fmt1),
	v4l2_get_width(fmt2), v4l2_get_height(fmt2));

	return ret;
	}

	static inline int v4l2_type_supported(V4L2Context *ctx)
	{
	return ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE \|\|
	ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE \|\|
	ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE \|\|
	ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT;
	}

	static inline int v4l2_get_framesize_compressed(V4L2Context* ctx, int width, int height)
	{
	V4L2m2mContext *s = ctx_to_m2mctx(ctx);
	const int SZ_4K = 0x1000;
	int size;

	if (s->avctx && av_codec_is_decoder(s->avctx->codec))
	return ((width * height * 3 / 2) / 2) + 128;

	/* encoder */
	size = FFALIGN(height, 32) * FFALIGN(width, 32) * 3 / 2 / 2;
	return FFALIGN(size, SZ_4K);
	}

	static inline void v4l2_save_to_context(V4L2Context* ctx, struct v4l2_format_update *fmt)
	{
	ctx->format.type = ctx->type;

	if (fmt->update_avfmt)
	ctx->av_pix_fmt = fmt->av_fmt;

	if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
	/* update the sizes to handle the reconfiguration of the capture stream at runtime */
	ctx->format.fmt.pix_mp.height = ctx->height;
	ctx->format.fmt.pix_mp.width = ctx->width;
	if (fmt->update_v4l2) {
	ctx->format.fmt.pix_mp.pixelformat = fmt->v4l2_fmt;

	/* s5p-mfc requires the user to specify a buffer size */
	ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage =
	v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
	}
	} else {
	ctx->format.fmt.pix.height = ctx->height;
	ctx->format.fmt.pix.width = ctx->width;
	if (fmt->update_v4l2) {
	ctx->format.fmt.pix.pixelformat = fmt->v4l2_fmt;

	/* s5p-mfc requires the user to specify a buffer size */
	ctx->format.fmt.pix.sizeimage =
	v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
	}
	}
	}

	/**
	* handle resolution change event and end of stream event
	* returns 1 if reinit was successful, negative if it failed
	* returns 0 if reinit was not executed
	*/
	static int v4l2_handle_event(V4L2Context *ctx)
	{
	V4L2m2mContext *s = ctx_to_m2mctx(ctx);
	struct v4l2_format cap_fmt = s->capture.format;
	struct v4l2_format out_fmt = s->output.format;
	struct v4l2_event evt = { 0 };
	int full_reinit, reinit, ret;

	ret = ioctl(s->fd, VIDIOC_DQEVENT, &evt);
	if (ret < 0) {
	av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_DQEVENT\n", ctx->name);
	return 0;
	}

	if (evt.type == V4L2_EVENT_EOS) {
	ctx->done = 1;
	return 0;
	}

	if (evt.type != V4L2_EVENT_SOURCE_CHANGE)
	return 0;

	ret = ioctl(s->fd, VIDIOC_G_FMT, &out_fmt);
	if (ret) {
	av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->output.name);
	return 0;
	}

	ret = ioctl(s->fd, VIDIOC_G_FMT, &cap_fmt);
	if (ret) {
	av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->capture.name);
	return 0;
	}

	full_reinit = v4l2_resolution_changed(&s->output, &out_fmt);
	if (full_reinit) {
	s->output.height = v4l2_get_height(&out_fmt);
	s->output.width = v4l2_get_width(&out_fmt);
	s->output.sample_aspect_ratio = v4l2_get_sar(&s->output);
	}

	reinit = v4l2_resolution_changed(&s->capture, &cap_fmt);
	if (reinit) {
	s->capture.height = v4l2_get_height(&cap_fmt);
	s->capture.width = v4l2_get_width(&cap_fmt);
	s->capture.sample_aspect_ratio = v4l2_get_sar(&s->capture);
	}

	if (full_reinit \|\| reinit)
	s->reinit = 1;

	if (full_reinit) {
	ret = ff_v4l2_m2m_codec_full_reinit(s);
	if (ret) {
	av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_full_reinit\n");
	return AVERROR(EINVAL);
	}
	goto reinit_run;
	}

	if (reinit) {
	if (s->avctx)
	ret = ff_set_dimensions(s->avctx, s->capture.width, s->capture.height);
	if (ret < 0)
	av_log(logger(ctx), AV_LOG_WARNING, "update avcodec height and width\n");

	ret = ff_v4l2_m2m_codec_reinit(s);
	if (ret) {
	av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_reinit\n");
	return AVERROR(EINVAL);
	}
	goto reinit_run;
	}

	/* dummy event received */
	return 0;

	/* reinit executed */
	reinit_run:
	return 1;
	}

	static int v4l2_stop_decode(V4L2Context *ctx)
	{
	struct v4l2_decoder_cmd cmd = {
	.cmd = V4L2_DEC_CMD_STOP,
	.flags = 0,
	};
	int ret;

	ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DECODER_CMD, &cmd);
	if (ret) {
	/* DECODER_CMD is optional */
	if (errno == ENOTTY)
	return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
	else
	return AVERROR(errno);
	}

	return 0;
	}

	static int v4l2_stop_encode(V4L2Context *ctx)
	{
	struct v4l2_encoder_cmd cmd = {
	.cmd = V4L2_ENC_CMD_STOP,
	.flags = 0,
	};
	int ret;

	ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENCODER_CMD, &cmd);
	if (ret) {
	/* ENCODER_CMD is optional */
	if (errno == ENOTTY)
	return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
	else
	return AVERROR(errno);
	}

	return 0;
	}

	static V4L2Buffer* v4l2_dequeue_v4l2buf(V4L2Context *ctx, int timeout)
	{
	struct v4l2_plane planes[VIDEO_MAX_PLANES];
	struct v4l2_buffer buf = { 0 };
	V4L2Buffer *avbuf;
	struct pollfd pfd = {
	.events = POLLIN \| POLLRDNORM \| POLLPRI \| POLLOUT \| POLLWRNORM, /* default blocking capture */
	.fd = ctx_to_m2mctx(ctx)->fd,
	};
	int i, ret;

	if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx->buffers) {
	for (i = 0; i < ctx->num_buffers; i++) {
	if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
	break;
	}
	if (i == ctx->num_buffers)
	av_log(logger(ctx), AV_LOG_WARNING, "All capture buffers returned to "
	"userspace. Increase num_capture_buffers "
	"to prevent device deadlock or dropped "
	"packets/frames.\n");
	}

	/* if we are draining and there are no more capture buffers queued in the driver we are done */
	if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx_to_m2mctx(ctx)->draining) {
	for (i = 0; i < ctx->num_buffers; i++) {
	/* capture buffer initialization happens during decode hence
	* detection happens at runtime
	*/
	if (!ctx->buffers)
	break;

	if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
	goto start;
	}
	ctx->done = 1;
	return NULL;
	}

	start:
	if (V4L2_TYPE_IS_OUTPUT(ctx->type))
	pfd.events = POLLOUT \| POLLWRNORM;
	else {
	/* no need to listen to requests for more input while draining */
	if (ctx_to_m2mctx(ctx)->draining)
	pfd.events = POLLIN \| POLLRDNORM \| POLLPRI;
	}

	for (;;) {
	ret = poll(&pfd, 1, timeout);
	if (ret > 0)
	break;
	if (errno == EINTR)
	continue;
	return NULL;
	}

	/* 0. handle errors */
	if (pfd.revents & POLLERR) {
	/* if we are trying to get free buffers but none have been queued yet
	no need to raise a warning */
	if (timeout == 0) {
	for (i = 0; i < ctx->num_buffers; i++) {
	if (ctx->buffers[i].status != V4L2BUF_AVAILABLE)
	av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
	}
	}
	else
	av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);

	return NULL;
	}

	/* 1. handle resolution changes */
	if (pfd.revents & POLLPRI) {
	ret = v4l2_handle_event(ctx);
	if (ret < 0) {
	/* if re-init failed, abort */
	ctx->done = 1;
	return NULL;
	}
	if (ret) {
	/* if re-init was successful drop the buffer (if there was one)
	* since we had to reconfigure capture (unmap all buffers)
	*/
	return NULL;
	}
	}

	/* 2. dequeue the buffer */
	if (pfd.revents & (POLLIN \| POLLRDNORM \| POLLOUT \| POLLWRNORM)) {

	if (!V4L2_TYPE_IS_OUTPUT(ctx->type)) {
	/* there is a capture buffer ready */
	if (pfd.revents & (POLLIN \| POLLRDNORM))
	goto dequeue;

	/* the driver is ready to accept more input; instead of waiting for the capture
	* buffer to complete we return NULL so input can proceed (we are single threaded)
	*/
	if (pfd.revents & (POLLOUT \| POLLWRNORM))
	return NULL;
	}

	dequeue:
	memset(&buf, 0, sizeof(buf));
	buf.memory = V4L2_MEMORY_MMAP;
	buf.type = ctx->type;
	if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
	memset(planes, 0, sizeof(planes));
	buf.length = VIDEO_MAX_PLANES;
	buf.m.planes = planes;
	}

	ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DQBUF, &buf);
	if (ret) {
	if (errno != EAGAIN) {
	ctx->done = 1;
	if (errno != EPIPE)
	av_log(logger(ctx), AV_LOG_DEBUG, "%s VIDIOC_DQBUF, errno (%s)\n",
	ctx->name, av_err2str(AVERROR(errno)));
	}
	return NULL;
	}

	if (ctx_to_m2mctx(ctx)->draining && !V4L2_TYPE_IS_OUTPUT(ctx->type)) {
	int bytesused = V4L2_TYPE_IS_MULTIPLANAR(buf.type) ?
	buf.m.planes[0].bytesused : buf.bytesused;
	if (bytesused == 0) {
	ctx->done = 1;
	return NULL;
	}
	#ifdef V4L2_BUF_FLAG_LAST
	if (buf.flags & V4L2_BUF_FLAG_LAST)
	ctx->done = 1;
	#endif
	}

	avbuf = &ctx->buffers[buf.index];
	avbuf->status = V4L2BUF_AVAILABLE;
	avbuf->buf = buf;
	if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
	memcpy(avbuf->planes, planes, sizeof(planes));
	avbuf->buf.m.planes = avbuf->planes;
	}
	return avbuf;
	}

	return NULL;
	}

	static V4L2Buffer* v4l2_getfree_v4l2buf(V4L2Context *ctx)
	{
	int timeout = 0; /* return when no more buffers to dequeue */
	int i;

	/* get back as many output buffers as possible */
	if (V4L2_TYPE_IS_OUTPUT(ctx->type)) {
	do {
	} while (v4l2_dequeue_v4l2buf(ctx, timeout));
	}

	for (i = 0; i < ctx->num_buffers; i++) {
	if (ctx->buffers[i].status == V4L2BUF_AVAILABLE)
	return &ctx->buffers[i];
	}

	return NULL;
	}

	static int v4l2_release_buffers(V4L2Context* ctx)
	{
	struct v4l2_requestbuffers req = {
	.memory = V4L2_MEMORY_MMAP,
	.type = ctx->type,
	.count = 0, /* 0 -> unmaps buffers from the driver */
	};
	int i, j;

	for (i = 0; i < ctx->num_buffers; i++) {
	V4L2Buffer *buffer = &ctx->buffers[i];

	for (j = 0; j < buffer->num_planes; j++) {
	struct V4L2Plane_info *p = &buffer->plane_info[j];
	if (p->mm_addr && p->length)
	if (munmap(p->mm_addr, p->length) < 0)
	av_log(logger(ctx), AV_LOG_ERROR, "%s unmap plane (%s))\n", ctx->name, av_err2str(AVERROR(errno)));
	}
	}

	return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_REQBUFS, &req);
	}

	static inline int v4l2_try_raw_format(V4L2Context* ctx, enum AVPixelFormat pixfmt)
	{
	struct v4l2_format *fmt = &ctx->format;
	uint32_t v4l2_fmt;
	int ret;

	v4l2_fmt = ff_v4l2_format_avfmt_to_v4l2(pixfmt);
	if (!v4l2_fmt)
	return AVERROR(EINVAL);

	if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type))
	fmt->fmt.pix_mp.pixelformat = v4l2_fmt;
	else
	fmt->fmt.pix.pixelformat = v4l2_fmt;

	fmt->type = ctx->type;

	ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, fmt);
	if (ret)
	return AVERROR(EINVAL);

	return 0;
	}

	static int v4l2_get_raw_format(V4L2Context* ctx, enum AVPixelFormat *p)
	{
	enum AVPixelFormat pixfmt = ctx->av_pix_fmt;
	struct v4l2_fmtdesc fdesc;
	int ret;

	memset(&fdesc, 0, sizeof(fdesc));
	fdesc.type = ctx->type;

	if (pixfmt != AV_PIX_FMT_NONE) {
	ret = v4l2_try_raw_format(ctx, pixfmt);
	if (!ret)
	return 0;
	}

	for (;;) {
	ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
	if (ret)
	return AVERROR(EINVAL);

	pixfmt = ff_v4l2_format_v4l2_to_avfmt(fdesc.pixelformat, AV_CODEC_ID_RAWVIDEO);
	ret = v4l2_try_raw_format(ctx, pixfmt);
	if (ret){
	fdesc.index++;
	continue;
	}

	*p = pixfmt;

	return 0;
	}

	return AVERROR(EINVAL);
	}

	static int v4l2_get_coded_format(V4L2Context* ctx, uint32_t *p)
	{
	struct v4l2_fmtdesc fdesc;
	uint32_t v4l2_fmt;
	int ret;

	/* translate to a valid v4l2 format */
	v4l2_fmt = ff_v4l2_format_avcodec_to_v4l2(ctx->av_codec_id);
	if (!v4l2_fmt)
	return AVERROR(EINVAL);

	/* check if the driver supports this format */
	memset(&fdesc, 0, sizeof(fdesc));
	fdesc.type = ctx->type;

	for (;;) {
	ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
	if (ret)
	return AVERROR(EINVAL);

	if (fdesc.pixelformat == v4l2_fmt)
	break;

	fdesc.index++;
	}

	*p = v4l2_fmt;

	return 0;
	}

	/*****************************************************************************
	*
	* V4L2 Context Interface
	*
	*****************************************************************************/

	int ff_v4l2_context_set_status(V4L2Context* ctx, uint32_t cmd)
	{
	int type = ctx->type;
	int ret;

	ret = ioctl(ctx_to_m2mctx(ctx)->fd, cmd, &type);
	if (ret < 0)
	return AVERROR(errno);

	ctx->streamon = (cmd == VIDIOC_STREAMON);

	return 0;
	}

	int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* frame)
	{
	V4L2m2mContext *s = ctx_to_m2mctx(ctx);
	V4L2Buffer* avbuf;
	int ret;

	if (!frame) {
	ret = v4l2_stop_encode(ctx);
	if (ret)
	av_log(logger(ctx), AV_LOG_ERROR, "%s stop_encode\n", ctx->name);
	s->draining= 1;
	return 0;
	}

	avbuf = v4l2_getfree_v4l2buf(ctx);
	if (!avbuf)
	return AVERROR(EAGAIN);

	ret = ff_v4l2_buffer_avframe_to_buf(frame, avbuf);
	if (ret)
	return ret;

	return ff_v4l2_buffer_enqueue(avbuf);
	}

	int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt)
	{
	V4L2m2mContext *s = ctx_to_m2mctx(ctx);
	V4L2Buffer* avbuf;
	int ret;

	if (!pkt->size) {
	ret = v4l2_stop_decode(ctx);
	if (ret)
	av_log(logger(ctx), AV_LOG_ERROR, "%s stop_decode\n", ctx->name);
	s->draining = 1;
	return 0;
	}

	avbuf = v4l2_getfree_v4l2buf(ctx);
	if (!avbuf)
	return AVERROR(EAGAIN);

	ret = ff_v4l2_buffer_avpkt_to_buf(pkt, avbuf);
	if (ret)
	return ret;

	return ff_v4l2_buffer_enqueue(avbuf);
	}

	int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* frame, int timeout)
	{
	V4L2Buffer *avbuf;

	/*
	* timeout=-1 blocks until:
	* 1. decoded frame available
	* 2. an input buffer is ready to be dequeued
	*/
	avbuf = v4l2_dequeue_v4l2buf(ctx, timeout);
	if (!avbuf) {
	if (ctx->done)
	return AVERROR_EOF;

	return AVERROR(EAGAIN);
	}

	return ff_v4l2_buffer_buf_to_avframe(frame, avbuf);
	}

	int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt)
	{
	V4L2Buffer *avbuf;

	/*
	* blocks until:
	* 1. encoded packet available
	* 2. an input buffer ready to be dequeued
	*/
	avbuf = v4l2_dequeue_v4l2buf(ctx, -1);
	if (!avbuf) {
	if (ctx->done)
	return AVERROR_EOF;

	return AVERROR(EAGAIN);
	}

	return ff_v4l2_buffer_buf_to_avpkt(pkt, avbuf);
	}

	int ff_v4l2_context_get_format(V4L2Context* ctx, int probe)
	{
	struct v4l2_format_update fmt = { 0 };
	int ret;

	if (ctx->av_codec_id == AV_CODEC_ID_RAWVIDEO) {
	ret = v4l2_get_raw_format(ctx, &fmt.av_fmt);
	if (ret)
	return ret;

	fmt.update_avfmt = !probe;
	v4l2_save_to_context(ctx, &fmt);

	/* format has been tried already */
	return ret;
	}

	ret = v4l2_get_coded_format(ctx, &fmt.v4l2_fmt);
	if (ret)
	return ret;

	fmt.update_v4l2 = 1;
	v4l2_save_to_context(ctx, &fmt);

	return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, &ctx->format);
	}

	int ff_v4l2_context_set_format(V4L2Context* ctx)
	{
	return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_S_FMT, &ctx->format);
	}

	void ff_v4l2_context_release(V4L2Context* ctx)
	{
	int ret;

	if (!ctx->buffers)
	return;

	ret = v4l2_release_buffers(ctx);
	if (ret)
	av_log(logger(ctx), AV_LOG_WARNING, "V4L2 failed to unmap the %s buffers\n", ctx->name);

	av_freep(&ctx->buffers);
	}

	int ff_v4l2_context_init(V4L2Context* ctx)
	{
	V4L2m2mContext *s = ctx_to_m2mctx(ctx);
	struct v4l2_requestbuffers req;
	int ret, i;

	if (!v4l2_type_supported(ctx)) {
	av_log(logger(ctx), AV_LOG_ERROR, "type %i not supported\n", ctx->type);
	return AVERROR_PATCHWELCOME;
	}

	ret = ioctl(s->fd, VIDIOC_G_FMT, &ctx->format);
	if (ret)
	av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT failed\n", ctx->name);

	memset(&req, 0, sizeof(req));
	req.count = ctx->num_buffers;
	req.memory = V4L2_MEMORY_MMAP;
	req.type = ctx->type;
	ret = ioctl(s->fd, VIDIOC_REQBUFS, &req);
	if (ret < 0) {
	av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_REQBUFS failed: %s\n", ctx->name, strerror(errno));
	return AVERROR(errno);
	}

	ctx->num_buffers = req.count;
	ctx->buffers = av_mallocz(ctx->num_buffers * sizeof(V4L2Buffer));
	if (!ctx->buffers) {
	av_log(logger(ctx), AV_LOG_ERROR, "%s malloc enomem\n", ctx->name);
	return AVERROR(ENOMEM);
	}

	for (i = 0; i < req.count; i++) {
	ctx->buffers[i].context = ctx;
	ret = ff_v4l2_buffer_initialize(&ctx->buffers[i], i);
	if (ret < 0) {
	av_log(logger(ctx), AV_LOG_ERROR, "%s buffer[%d] initialization (%s)\n", ctx->name, i, av_err2str(ret));
	goto error;
	}
	}

	av_log(logger(ctx), AV_LOG_DEBUG, "%s: %s %02d buffers initialized: %04ux%04u, sizeimage %08u, bytesperline %08u\n", ctx->name,
	V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? av_fourcc2str(ctx->format.fmt.pix_mp.pixelformat) : av_fourcc2str(ctx->format.fmt.pix.pixelformat),
	req.count,
	v4l2_get_width(&ctx->format),
	v4l2_get_height(&ctx->format),
	V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage : ctx->format.fmt.pix.sizeimage,
	V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].bytesperline : ctx->format.fmt.pix.bytesperline);

	return 0;

	error:
	v4l2_release_buffers(ctx);

	av_freep(&ctx->buffers);

	return ret;
	}