@@ -49,6 +49,7 @@ version <next>:

 - VP9 tile threading support

 - KMS screen grabber

 - CUDA thumbnail filter

+- V4L2 mem2mem HW assisted codecs

 version 3.3:

@@ -185,6 +185,7 @@ Individual component options:

   --enable-filter=NAME     enable filter NAME

   --disable-filter=NAME    disable filter NAME

   --disable-filters        disable all filters

+  --disable-v4l2_m2m       disable V4L2 mem2mem code [autodetect]

 External library support:

@@ -1628,6 +1629,7 @@ HWACCEL_AUTODETECT_LIBRARY_LIST="

     vda

     vdpau

     videotoolbox

+    v4l2_m2m

     xvmc

 "

@@ -2755,6 +2757,7 @@ omx_rpi_select="omx"

 qsvdec_select="qsv"

 qsvenc_select="qsv"

 vaapi_encode_deps="vaapi"

+v4l2_m2m_deps_any="linux_videodev2_h"

 hwupload_cuda_filter_deps="cuda"

 scale_npp_filter_deps="cuda libnpp"

@@ -2765,6 +2768,8 @@ nvenc_deps="cuda"

 nvenc_deps_any="dlopen LoadLibrary"

 nvenc_encoder_deps="nvenc"

+h263_v4l2m2m_decoder_deps="v4l2_m2m h263_v4l2_m2m"

+h263_v4l2m2m_encoder_deps="v4l2_m2m h263_v4l2_m2m"

 h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"

 h264_cuvid_decoder_deps="cuda cuvid"

 h264_cuvid_decoder_select="h264_mp4toannexb_bsf"

@@ -2783,6 +2788,8 @@ h264_vda_decoder_deps="vda"

 h264_vda_decoder_select="h264_decoder"

 h264_vdpau_decoder_deps="vdpau"

 h264_vdpau_decoder_select="h264_decoder"

+h264_v4l2m2m_decoder_deps="v4l2_m2m h264_v4l2_m2m"

+h264_v4l2m2m_encoder_deps="v4l2_m2m h264_v4l2_m2m"

 hevc_cuvid_decoder_deps="cuda cuvid"

 hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf"

 hevc_mediacodec_decoder_deps="mediacodec"

@@ -2794,12 +2801,15 @@ hevc_qsv_encoder_deps="libmfx"

 hevc_qsv_encoder_select="hevcparse qsvenc"

 hevc_vaapi_encoder_deps="VAEncPictureParameterBufferHEVC"

 hevc_vaapi_encoder_select="vaapi_encode golomb"

+hevc_v4l2m2m_decoder_deps="v4l2_m2m hevc_v4l2_m2m"

+hevc_v4l2m2m_encoder_deps="v4l2_m2m hevc_v4l2_m2m"

 mjpeg_cuvid_decoder_deps="cuda cuvid"

 mjpeg_vaapi_encoder_deps="VAEncPictureParameterBufferJPEG"

 mjpeg_vaapi_encoder_select="vaapi_encode jpegtables"

 mpeg1_cuvid_decoder_deps="cuda cuvid"

 mpeg1_vdpau_decoder_deps="vdpau"

 mpeg1_vdpau_decoder_select="mpeg1video_decoder"

+mpeg1_v4l2m2m_decoder_deps="v4l2_m2m mpeg1_v4l2_m2m"

 mpeg2_crystalhd_decoder_select="crystalhd"

 mpeg2_cuvid_decoder_deps="cuda cuvid"

 mpeg2_mmal_decoder_deps="mmal"

@@ -2810,6 +2820,7 @@ mpeg2_qsv_encoder_deps="libmfx"

 mpeg2_qsv_encoder_select="qsvenc"

 mpeg2_vaapi_encoder_deps="VAEncPictureParameterBufferMPEG2"

 mpeg2_vaapi_encoder_select="vaapi_encode"

+mpeg2_v4l2m2m_decoder_deps="v4l2_m2m mpeg2_v4l2_m2m"

 mpeg4_crystalhd_decoder_select="crystalhd"

 mpeg4_cuvid_decoder_deps="cuda cuvid"

 mpeg4_mediacodec_decoder_deps="mediacodec"

@@ -2817,6 +2828,8 @@ mpeg4_mmal_decoder_deps="mmal"

 mpeg4_omx_encoder_deps="omx"

 mpeg4_vdpau_decoder_deps="vdpau"

 mpeg4_vdpau_decoder_select="mpeg4_decoder"

+mpeg4_v4l2m2m_decoder_deps="v4l2_m2m mpeg4_v4l2_m2m"

+mpeg4_v4l2m2m_encoder_deps="v4l2_m2m mpeg4_v4l2_m2m"

 mpeg_vdpau_decoder_deps="vdpau"

 mpeg_vdpau_decoder_select="mpeg2video_decoder"

 msmpeg4_crystalhd_decoder_select="crystalhd"

@@ -2827,16 +2840,20 @@ vc1_cuvid_decoder_deps="cuda cuvid"

 vc1_mmal_decoder_deps="mmal"

 vc1_vdpau_decoder_deps="vdpau"

 vc1_vdpau_decoder_select="vc1_decoder"

+vc1_v4l2m2m_decoder_deps="v4l2_m2m vc1_v4l2_m2m"

 vp8_cuvid_decoder_deps="cuda cuvid"

 vp8_mediacodec_decoder_deps="mediacodec"

 vp8_qsv_decoder_deps="libmfx"

 vp8_qsv_decoder_select="qsvdec vp8_qsv_hwaccel vp8_parser"

 vp8_vaapi_encoder_deps="VAEncPictureParameterBufferVP8"

 vp8_vaapi_encoder_select="vaapi_encode"

+vp8_v4l2m2m_decoder_deps="v4l2_m2m vp8_v4l2_m2m"

+vp8_v4l2m2m_encoder_deps="v4l2_m2m vp8_v4l2_m2m"

 vp9_cuvid_decoder_deps="cuda cuvid"

 vp9_mediacodec_decoder_deps="mediacodec"

 vp9_vaapi_encoder_deps="VAEncPictureParameterBufferVP9"

 vp9_vaapi_encoder_select="vaapi_encode"

+vp9_v4l2m2m_decoder_deps="v4l2_m2m vp9_v4l2_m2m"

 wmv3_crystalhd_decoder_select="crystalhd"

 wmv3_vdpau_decoder_select="vc1_vdpau_decoder"

@@ -6109,9 +6126,20 @@ perl -v            > /dev/null 2>&1 && enable perl      || disable perl

 pod2man --help     > /dev/null 2>&1 && enable pod2man   || disable pod2man

 rsync --help 2> /dev/null | grep -q 'contimeout' && enable rsync_contimeout || disable rsync_contimeout

+# check V4L2 codecs available in the API

 check_header linux/fb.h

 check_header linux/videodev2.h

 check_code cc linux/videodev2.h "struct v4l2_frmsizeenum vfse; vfse.discrete.width = 0;" && enable_safe struct_v4l2_frmivalenum_discrete

+check_code cc linux/videodev2.h "int i = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_VIDEO_M2M | V4L2_BUF_FLAG_LAST;" || disable v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VC1_ANNEX_G;" && enable vc1_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG1;" && enable mpeg1_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG2;" && enable mpeg2_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG4;" && enable mpeg4_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_HEVC;" && enable hevc_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_H263;" && enable h263_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_H264;" && enable h264_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VP8;" && enable vp8_v4l2_m2m

+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VP9;" && enable vp9_v4l2_m2m

 check_header sys/videoio.h

 check_code cc sys/videoio.h "struct v4l2_frmsizeenum vfse; vfse.discrete.width = 0;" && enable_safe struct_v4l2_frmivalenum_discrete

@@ -137,6 +137,7 @@ OBJS-$(CONFIG_VIDEODSP)                += videodsp.o

 OBJS-$(CONFIG_VP3DSP)                  += vp3dsp.o

 OBJS-$(CONFIG_VP56DSP)                 += vp56dsp.o

 OBJS-$(CONFIG_VP8DSP)                  += vp8dsp.o

+OBJS-$(CONFIG_V4L2_M2M)                += v4l2_m2m.o v4l2_context.o v4l2_buffers.o v4l2_fmt.o

 OBJS-$(CONFIG_WMA_FREQS)               += wma_freqs.o

 OBJS-$(CONFIG_WMV2DSP)                 += wmv2dsp.o

@@ -323,6 +324,8 @@ OBJS-$(CONFIG_H263_DECODER)            += h263dec.o h263.o ituh263dec.o        \

                                           intelh263dec.o h263data.o

 OBJS-$(CONFIG_H263_ENCODER)            += mpeg4videoenc.o mpeg4video.o  \

                                           h263.o ituh263enc.o flvenc.o h263data.o

+OBJS-$(CONFIG_H263_V4L2M2M_DECODER)    += v4l2_m2m_dec.o

+OBJS-$(CONFIG_H263_V4L2M2M_ENCODER)    += v4l2_m2m_enc.o

 OBJS-$(CONFIG_H264_DECODER)            += h264dec.o h264_cabac.o h264_cavlc.o \

                                           h264_direct.o h264_loopfilter.o  \

                                           h264_mb.o h264_picture.o \

@@ -340,6 +343,8 @@ OBJS-$(CONFIG_H264_QSV_DECODER)        += qsvdec_h2645.o

 OBJS-$(CONFIG_H264_QSV_ENCODER)        += qsvenc_h264.o

 OBJS-$(CONFIG_H264_VAAPI_ENCODER)      += vaapi_encode_h264.o vaapi_encode_h26x.o

 OBJS-$(CONFIG_H264_VIDEOTOOLBOX_ENCODER) += videotoolboxenc.o

+OBJS-$(CONFIG_H264_V4L2M2M_DECODER)    += v4l2_m2m_dec.o

+OBJS-$(CONFIG_H264_V4L2M2M_ENCODER)    += v4l2_m2m_enc.o

 OBJS-$(CONFIG_HAP_DECODER)             += hapdec.o hap.o

 OBJS-$(CONFIG_HAP_ENCODER)             += hapenc.o hap.o

 OBJS-$(CONFIG_HEVC_DECODER)            += hevcdec.o hevc_mvs.o \

@@ -353,6 +358,8 @@ OBJS-$(CONFIG_HEVC_QSV_DECODER)        += qsvdec_h2645.o

 OBJS-$(CONFIG_HEVC_QSV_ENCODER)        += qsvenc_hevc.o hevc_ps_enc.o       \

                                           hevc_data.o

 OBJS-$(CONFIG_HEVC_VAAPI_ENCODER)      += vaapi_encode_h265.o vaapi_encode_h26x.o

+OBJS-$(CONFIG_HEVC_V4L2M2M_DECODER)    += v4l2_m2m_dec.o

+OBJS-$(CONFIG_HEVC_V4L2M2M_ENCODER)    += v4l2_m2m_enc.o

 OBJS-$(CONFIG_HNM4_VIDEO_DECODER)      += hnm4video.o

 OBJS-$(CONFIG_HQ_HQA_DECODER)          += hq_hqa.o hq_hqadata.o hq_hqadsp.o \

                                           canopus.o

@@ -422,6 +429,7 @@ OBJS-$(CONFIG_MPC8_DECODER)            += mpc8.o mpc.o

 OBJS-$(CONFIG_MPEGVIDEO_DECODER)       += mpeg12dec.o mpeg12.o mpeg12data.o

 OBJS-$(CONFIG_MPEG1VIDEO_DECODER)      += mpeg12dec.o mpeg12.o mpeg12data.o

 OBJS-$(CONFIG_MPEG1VIDEO_ENCODER)      += mpeg12enc.o mpeg12.o

+OBJS-$(CONFIG_MPEG1_V4L2M2M_DECODER)   += v4l2_m2m_dec.o

 OBJS-$(CONFIG_MPEG2_MMAL_DECODER)      += mmaldec.o

 OBJS-$(CONFIG_MPEG2_QSV_DECODER)       += qsvdec_other.o

 OBJS-$(CONFIG_MPEG2_QSV_ENCODER)       += qsvenc_mpeg2.o

@@ -429,9 +437,12 @@ OBJS-$(CONFIG_MPEG2VIDEO_DECODER)      += mpeg12dec.o mpeg12.o mpeg12data.o

 OBJS-$(CONFIG_MPEG2VIDEO_ENCODER)      += mpeg12enc.o mpeg12.o

 OBJS-$(CONFIG_MPEG2_MEDIACODEC_DECODER) += mediacodecdec.o

 OBJS-$(CONFIG_MPEG2_VAAPI_ENCODER)     += vaapi_encode_mpeg2.o

+OBJS-$(CONFIG_MPEG2_V4L2M2M_DECODER)   += v4l2_m2m_dec.o

 OBJS-$(CONFIG_MPEG4_DECODER)           += xvididct.o

 OBJS-$(CONFIG_MPEG4_MEDIACODEC_DECODER) += mediacodecdec.o

 OBJS-$(CONFIG_MPEG4_OMX_ENCODER)       += omx.o

+OBJS-$(CONFIG_MPEG4_V4L2M2M_DECODER)   += v4l2_m2m_dec.o

+OBJS-$(CONFIG_MPEG4_V4L2M2M_ENCODER)   += v4l2_m2m_enc.o

 OBJS-$(CONFIG_MPL2_DECODER)            += mpl2dec.o ass.o

 OBJS-$(CONFIG_MSA1_DECODER)            += mss3.o

 OBJS-$(CONFIG_MSCC_DECODER)            += mscc.o

@@ -605,6 +616,7 @@ OBJS-$(CONFIG_VC1_DECODER)             += vc1dec.o vc1_block.o vc1_loopfilter.o

 OBJS-$(CONFIG_VC1_CUVID_DECODER)       += cuvid.o

 OBJS-$(CONFIG_VC1_MMAL_DECODER)        += mmaldec.o

 OBJS-$(CONFIG_VC1_QSV_DECODER)         += qsvdec_other.o

+OBJS-$(CONFIG_VC1_V4L2M2M_DECODER)     += v4l2_m2m_dec.o

 OBJS-$(CONFIG_VC2_ENCODER)             += vc2enc.o vc2enc_dwt.o diractab.o

 OBJS-$(CONFIG_VCR1_DECODER)            += vcr1.o

 OBJS-$(CONFIG_VMDAUDIO_DECODER)        += vmdaudio.o

@@ -624,6 +636,8 @@ OBJS-$(CONFIG_VP8_CUVID_DECODER)       += cuvid.o

 OBJS-$(CONFIG_VP8_MEDIACODEC_DECODER)  += mediacodecdec.o

 OBJS-$(CONFIG_VP8_QSV_DECODER)         += qsvdec_other.o

 OBJS-$(CONFIG_VP8_VAAPI_ENCODER)       += vaapi_encode_vp8.o

+OBJS-$(CONFIG_VP8_V4L2M2M_DECODER)     += v4l2_m2m_dec.o

+OBJS-$(CONFIG_VP8_V4L2M2M_ENCODER)     += v4l2_m2m_enc.o

 OBJS-$(CONFIG_VP9_DECODER)             += vp9.o vp9data.o vp9dsp.o vp9lpf.o vp9recon.o \

                                           vp9block.o vp9prob.o vp9mvs.o vp56rac.o \

                                           vp9dsp_8bpp.o vp9dsp_10bpp.o vp9dsp_12bpp.o

@@ -631,6 +645,7 @@ OBJS-$(CONFIG_VP9_CUVID_DECODER)       += cuvid.o

 OBJS-$(CONFIG_VP9_MEDIACODEC_DECODER)  += mediacodecdec.o

 OBJS-$(CONFIG_VP9_VAAPI_ENCODER)       += vaapi_encode_vp9.o

 OBJS-$(CONFIG_VPLAYER_DECODER)         += textdec.o ass.o

+OBJS-$(CONFIG_VP9_V4L2M2M_DECODER)     += v4l2_m2m_dec.o

 OBJS-$(CONFIG_VQA_DECODER)             += vqavideo.o

 OBJS-$(CONFIG_WAVPACK_DECODER)         += wavpack.o

 OBJS-$(CONFIG_WAVPACK_ENCODER)         += wavpackenc.o

@@ -208,8 +208,10 @@ static void register_all(void)

     REGISTER_ENCDEC (H263,              h263);

     REGISTER_DECODER(H263I,             h263i);

     REGISTER_ENCDEC (H263P,             h263p);

+    REGISTER_ENCDEC (H263_V4L2M2M,      h263_v4l2m2m);

     REGISTER_DECODER(H264,              h264);

     REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);

+    REGISTER_ENCDEC (H264_V4L2M2M,      h264_v4l2m2m);

     REGISTER_DECODER(H264_MEDIACODEC,   h264_mediacodec);

     REGISTER_DECODER(H264_MMAL,         h264_mmal);

     REGISTER_DECODER(H264_QSV,          h264_qsv);

@@ -220,6 +222,7 @@ static void register_all(void)

     REGISTER_ENCDEC (HAP,               hap);

     REGISTER_DECODER(HEVC,              hevc);

     REGISTER_DECODER(HEVC_QSV,          hevc_qsv);

+    REGISTER_ENCDEC (HEVC_V4L2M2M,      hevc_v4l2m2m);

     REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);

     REGISTER_DECODER(HQ_HQA,            hq_hqa);

     REGISTER_DECODER(HQX,               hqx);

@@ -254,6 +257,7 @@ static void register_all(void)

     REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);

     REGISTER_ENCDEC (MPEG4,             mpeg4);

     REGISTER_DECODER(MPEG4_CRYSTALHD,   mpeg4_crystalhd);

+    REGISTER_ENCDEC (MPEG4_V4L2M2M,     mpeg4_v4l2m2m);

     REGISTER_DECODER(MPEG4_MMAL,        mpeg4_mmal);

 #if FF_API_VDPAU

     REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);

@@ -263,8 +267,10 @@ static void register_all(void)

     REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);

     REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);

 #endif

+    REGISTER_DECODER(MPEG1_V4L2M2M,     mpeg1_v4l2m2m);

     REGISTER_DECODER(MPEG2_MMAL,        mpeg2_mmal);

     REGISTER_DECODER(MPEG2_CRYSTALHD,   mpeg2_crystalhd);

+    REGISTER_DECODER(MPEG2_V4L2M2M,     mpeg2_v4l2m2m);

     REGISTER_DECODER(MPEG2_QSV,         mpeg2_qsv);

     REGISTER_DECODER(MPEG2_MEDIACODEC,  mpeg2_mediacodec);

     REGISTER_DECODER(MSA1,              msa1);

@@ -362,6 +368,7 @@ static void register_all(void)

     REGISTER_DECODER(VC1IMAGE,          vc1image);

     REGISTER_DECODER(VC1_MMAL,          vc1_mmal);

     REGISTER_DECODER(VC1_QSV,           vc1_qsv);

+    REGISTER_DECODER(VC1_V4L2M2M,       vc1_v4l2m2m);

     REGISTER_ENCODER(VC2,               vc2);

     REGISTER_DECODER(VCR1,              vcr1);

     REGISTER_DECODER(VMDVIDEO,          vmdvideo);

@@ -373,7 +380,9 @@ static void register_all(void)

     REGISTER_DECODER(VP6F,              vp6f);

     REGISTER_DECODER(VP7,               vp7);

     REGISTER_DECODER(VP8,               vp8);

+    REGISTER_ENCDEC (VP8_V4L2M2M,       vp8_v4l2m2m);

     REGISTER_DECODER(VP9,               vp9);

+    REGISTER_DECODER(VP9_V4L2M2M,       vp9_v4l2m2m);

     REGISTER_DECODER(VQA,               vqa);

     REGISTER_DECODER(BITPACKED,         bitpacked);

     REGISTER_DECODER(WEBP,              webp);

new file mode 100644

@@ -0,0 +1,453 @@

+/*

+ * V4L2 buffer 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_context.h"

+#include "v4l2_buffers.h"

+#include "v4l2_m2m.h"

+

+#define USEC_PER_SEC 1000000

+

+static inline V4L2m2mContext *buf_to_m2mctx(V4L2Buffer *buf)

+{

+    return V4L2_TYPE_IS_OUTPUT(buf->context->type) ?

+        container_of(buf->context, V4L2m2mContext, output) :

+        container_of(buf->context, V4L2m2mContext, capture);

+}

+

+static inline AVCodecContext *logger(V4L2Buffer *buf)

+{

+    return buf_to_m2mctx(buf)->avctx;

+}

+

+static inline void v4l2_set_pts(V4L2Buffer *out, int64_t pts)

+{

+    V4L2m2mContext *s = buf_to_m2mctx(out);

+    AVRational v4l2_timebase = { 1, USEC_PER_SEC };

+    int64_t v4l2_pts;

+

+    if (pts == AV_NOPTS_VALUE)

+        pts = 0;

+

+    /* convert pts to v4l2 timebase */

+    v4l2_pts = av_rescale_q(pts, s->avctx->time_base, v4l2_timebase);

+    out->buf.timestamp.tv_usec = v4l2_pts % USEC_PER_SEC;

+    out->buf.timestamp.tv_sec = v4l2_pts / USEC_PER_SEC;

+}

+

+static inline uint64_t v4l2_get_pts(V4L2Buffer *avbuf)

+{

+    V4L2m2mContext *s = buf_to_m2mctx(avbuf);

+    AVRational v4l2_timebase = { 1, USEC_PER_SEC };

+    int64_t v4l2_pts;

+

+    /* convert pts back to encoder timebase */

+    v4l2_pts = avbuf->buf.timestamp.tv_sec * USEC_PER_SEC + avbuf->buf.timestamp.tv_usec;

+

+    return av_rescale_q(v4l2_pts, v4l2_timebase, s->avctx->time_base);

+}

+

+static enum AVColorPrimaries v4l2_get_color_primaries(V4L2Buffer *buf)

+{

+    enum v4l2_ycbcr_encoding ycbcr;

+    enum v4l2_colorspace cs;

+

+    cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.colorspace :

+        buf->context->format.fmt.pix.colorspace;

+

+    ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.ycbcr_enc:

+        buf->context->format.fmt.pix.ycbcr_enc;

+

+    switch(ycbcr) {

+    case V4L2_YCBCR_ENC_XV709:

+    case V4L2_YCBCR_ENC_709: return AVCOL_PRI_BT709;

+    case V4L2_YCBCR_ENC_XV601:

+    case V4L2_YCBCR_ENC_601:return AVCOL_PRI_BT470M;

+    default:

+        break;

+    }

+

+    switch(cs) {

+    case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_PRI_BT470BG;

+    case V4L2_COLORSPACE_SMPTE170M: return AVCOL_PRI_SMPTE170M;

+    case V4L2_COLORSPACE_SMPTE240M: return AVCOL_PRI_SMPTE240M;

+    case V4L2_COLORSPACE_BT2020: return AVCOL_PRI_BT2020;

+    default:

+        break;

+    }

+

+    return AVCOL_PRI_UNSPECIFIED;

+}

+

+static enum AVColorRange v4l2_get_color_range(V4L2Buffer *buf)

+{

+    enum v4l2_quantization qt;

+

+    qt = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.quantization :

+        buf->context->format.fmt.pix.quantization;

+

+    switch (qt) {

+    case V4L2_QUANTIZATION_LIM_RANGE: return AVCOL_RANGE_MPEG;

+    case V4L2_QUANTIZATION_FULL_RANGE: return AVCOL_RANGE_JPEG;

+    default:

+        break;

+    }

+

+     return AVCOL_RANGE_UNSPECIFIED;

+}

+

+static enum AVColorSpace v4l2_get_color_space(V4L2Buffer *buf)

+{

+    enum v4l2_ycbcr_encoding ycbcr;

+    enum v4l2_colorspace cs;

+

+    cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.colorspace :

+        buf->context->format.fmt.pix.colorspace;

+

+    ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.ycbcr_enc:

+        buf->context->format.fmt.pix.ycbcr_enc;

+

+    switch(cs) {

+    case V4L2_COLORSPACE_SRGB: return AVCOL_SPC_RGB;

+    case V4L2_COLORSPACE_REC709: return AVCOL_SPC_BT709;

+    case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_SPC_FCC;

+    case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_SPC_BT470BG;

+    case V4L2_COLORSPACE_SMPTE170M: return AVCOL_SPC_SMPTE170M;

+    case V4L2_COLORSPACE_SMPTE240M: return AVCOL_SPC_SMPTE240M;

+    case V4L2_COLORSPACE_BT2020:

+        if (ycbcr == V4L2_YCBCR_ENC_BT2020_CONST_LUM)

+            return AVCOL_SPC_BT2020_CL;

+        else

+             return AVCOL_SPC_BT2020_NCL;

+    default:

+        break;

+    }

+

+    return AVCOL_SPC_UNSPECIFIED;

+}

+

+static enum AVColorTransferCharacteristic v4l2_get_color_trc(V4L2Buffer *buf)

+{

+    enum v4l2_ycbcr_encoding ycbcr;

+    enum v4l2_xfer_func xfer;

+    enum v4l2_colorspace cs;

+

+    cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.colorspace :

+        buf->context->format.fmt.pix.colorspace;

+

+    ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.ycbcr_enc:

+        buf->context->format.fmt.pix.ycbcr_enc;

+

+    xfer = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?

+        buf->context->format.fmt.pix_mp.xfer_func:

+        buf->context->format.fmt.pix.xfer_func;

+

+    switch (xfer) {

+    case V4L2_XFER_FUNC_709: return AVCOL_TRC_BT709;

+    case V4L2_XFER_FUNC_SRGB: return AVCOL_TRC_IEC61966_2_1;

+    default:

+        break;

+    }

+

+    switch (cs) {

+    case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_TRC_GAMMA22;

+    case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_TRC_GAMMA28;

+    case V4L2_COLORSPACE_SMPTE170M: return AVCOL_TRC_SMPTE170M;

+    case V4L2_COLORSPACE_SMPTE240M: return AVCOL_TRC_SMPTE240M;

+    default:

+        break;

+    }

+

+    switch (ycbcr) {

+    case V4L2_YCBCR_ENC_XV709:

+    case V4L2_YCBCR_ENC_XV601: return AVCOL_TRC_BT1361_ECG;

+    default:

+        break;

+    }

+

+    return AVCOL_TRC_UNSPECIFIED;

+}

+

+static void v4l2_free_buffer(void *opaque, uint8_t *unused)

+{

+    V4L2Buffer* avbuf = opaque;

+    V4L2m2mContext *s = buf_to_m2mctx(avbuf);

+

+    atomic_fetch_sub_explicit(&s->refcount, 1, memory_order_acq_rel);

+    if (s->reinit) {

+        if (!atomic_load(&s->refcount))

+            sem_post(&s->refsync);

+        return;

+    }

+

+    if (avbuf->context->streamon) {

+        ff_v4l2_buffer_enqueue(avbuf);

+        return;

+    }

+

+    if (!atomic_load(&s->refcount))

+        ff_v4l2_m2m_codec_end(s->avctx);

+}

+

+static int v4l2_buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf)

+{

+    V4L2m2mContext *s = buf_to_m2mctx(in);

+

+    if (plane >= in->num_planes)

+        return AVERROR(EINVAL);

+

+    /* even though most encoders return 0 in data_offset encoding vp8 does require this value */

+    *buf = av_buffer_create((char *)in->plane_info[plane].mm_addr + in->planes[plane].data_offset,

+                            in->plane_info[plane].length, v4l2_free_buffer, in, 0);

+    if (!*buf)

+        return AVERROR(ENOMEM);

+

+    in->status = V4L2BUF_RET_USER;

+    atomic_fetch_add_explicit(&s->refcount, 1, memory_order_relaxed);

+

+    return 0;

+}

+

+static int v4l2_bufref_to_buf(V4L2Buffer *out, int plane, const uint8_t* data, int size, AVBufferRef* bref)

+{

+    if (plane >= out->num_planes)

+        return AVERROR(EINVAL);

+

+    memcpy(out->plane_info[plane].mm_addr, data, FFMIN(size, out->plane_info[plane].length));

+

+    out->planes[plane].bytesused = FFMIN(size, out->plane_info[plane].length);

+    out->planes[plane].length = out->plane_info[plane].length;

+

+    return 0;

+}

+

+/******************************************************************************

+ *

+ *              V4L2uffer interface

+ *

+ ******************************************************************************/

+

+int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer* out)

+{

+    int i, ret;

+

+    for(i = 0; i < out->num_planes; i++) {

+        ret = v4l2_bufref_to_buf(out, i, frame->buf[i]->data, frame->buf[i]->size, frame->buf[i]);

+        if (ret)

+            return ret;

+    }

+

+    v4l2_set_pts(out, frame->pts);

+

+    return 0;

+}

+

+int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *avbuf)

+{

+    V4L2m2mContext *s = buf_to_m2mctx(avbuf);

+    int i, ret;

+

+    av_frame_unref(frame);

+

+    /* 1. get references to the actual data */

+    for (i = 0; i < avbuf->num_planes; i++) {

+        ret = v4l2_buf_to_bufref(avbuf, i, &frame->buf[i]);

+        if (ret)

+            return ret;

+

+        frame->linesize[i] = avbuf->plane_info[i].bytesperline;

+        frame->data[i] = frame->buf[i]->data;

+    }

+

+    /* 1.1 fixup special cases */

+    switch (avbuf->context->av_pix_fmt) {

+    case AV_PIX_FMT_NV12:

+        if (avbuf->num_planes > 1)

+            break;

+        frame->linesize[1] = avbuf->plane_info[0].bytesperline;

+        frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;

+        break;

+    default:

+        break;

+    }

+

+    /* 2. get frame information */

+    frame->key_frame = !!(avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME);

+    frame->format = avbuf->context->av_pix_fmt;

+    frame->color_primaries = v4l2_get_color_primaries(avbuf);

+    frame->colorspace = v4l2_get_color_space(avbuf);

+    frame->color_range = v4l2_get_color_range(avbuf);

+    frame->color_trc = v4l2_get_color_trc(avbuf);

+    frame->pts = v4l2_get_pts(avbuf);

+

+    /* these two values are updated also during re-init in v4l2_process_driver_event */

+    frame->height = s->output.height;

+    frame->width = s->output.width;

+

+    /* 3. report errors upstream */

+    if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {

+        av_log(logger(avbuf), AV_LOG_ERROR, "%s: driver decode error\n", avbuf->context->name);

+        frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM;

+    }

+

+    return 0;

+}

+

+int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *avbuf)

+{

+    int ret;

+

+    av_packet_unref(pkt);

+    ret = v4l2_buf_to_bufref(avbuf, 0, &pkt->buf);

+    if (ret)

+        return ret;

+

+    pkt->size = V4L2_TYPE_IS_MULTIPLANAR(avbuf->buf.type) ? avbuf->buf.m.planes[0].bytesused : avbuf->buf.bytesused;

+    pkt->data = pkt->buf->data;

+

+    if (avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME)

+        pkt->flags |= AV_PKT_FLAG_KEY;

+

+    if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {

+        av_log(logger(avbuf), AV_LOG_ERROR, "%s driver encode error\n", avbuf->context->name);

+        pkt->flags |= AV_PKT_FLAG_CORRUPT;

+    }

+

+    pkt->dts = pkt->pts = v4l2_get_pts(avbuf);

+

+    return 0;

+}

+

+int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out)

+{

+    int ret;

+

+    ret = v4l2_bufref_to_buf(out, 0, pkt->data, pkt->size, pkt->buf);

+    if (ret)

+        return ret;

+

+    v4l2_set_pts(out, pkt->pts);

+

+    if (pkt->flags & AV_PKT_FLAG_KEY)

+        out->flags = V4L2_BUF_FLAG_KEYFRAME;

+

+    return 0;

+}

+

+int ff_v4l2_buffer_initialize(V4L2Buffer* avbuf, int index)

+{

+    V4L2Context *ctx = avbuf->context;

+    int ret, i;

+

+    avbuf->buf.memory = V4L2_MEMORY_MMAP;

+    avbuf->buf.type = ctx->type;

+    avbuf->buf.index = index;

+

+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {

+        avbuf->buf.length = VIDEO_MAX_PLANES;

+        avbuf->buf.m.planes = avbuf->planes;

+    }

+

+    ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QUERYBUF, &avbuf->buf);

+    if (ret < 0)

+        return AVERROR(errno);

+

+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {

+        avbuf->num_planes = 0;

+        for (;;) {

+            /* in MP, the V4L2 API states that buf.length means num_planes */

+            if (avbuf->num_planes >= avbuf->buf.length)

+                break;

+            if (avbuf->buf.m.planes[avbuf->num_planes].length)

+                avbuf->num_planes++;

+        }

+    } else

+        avbuf->num_planes = 1;

+

+    for (i = 0; i < avbuf->num_planes; i++) {

+

+        avbuf->plane_info[i].bytesperline = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?

+            ctx->format.fmt.pix_mp.plane_fmt[i].bytesperline :

+            ctx->format.fmt.pix.bytesperline;

+

+        if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {

+            avbuf->plane_info[i].length = avbuf->buf.m.planes[i].length;

+            avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.m.planes[i].length,

+                                           PROT_READ | PROT_WRITE, MAP_SHARED,

+                                           buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.planes[i].m.mem_offset);

+        } else {

+            avbuf->plane_info[i].length = avbuf->buf.length;

+            avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.length,

+                                          PROT_READ | PROT_WRITE, MAP_SHARED,

+                                          buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.offset);

+        }

+

+        if (avbuf->plane_info[i].mm_addr == MAP_FAILED)

+            return AVERROR(ENOMEM);

+    }

+

+    avbuf->status = V4L2BUF_AVAILABLE;

+

+    if (V4L2_TYPE_IS_OUTPUT(ctx->type))

+        return 0;

+

+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {

+        avbuf->buf.m.planes = avbuf->planes;

+        avbuf->buf.length   = avbuf->num_planes;

+

+    } else {

+        avbuf->buf.bytesused = avbuf->planes[0].bytesused;

+        avbuf->buf.length    = avbuf->planes[0].length;

+    }

+

+    return ff_v4l2_buffer_enqueue(avbuf);

+}

+

+int ff_v4l2_buffer_enqueue(V4L2Buffer* avbuf)

+{

+    int ret;

+

+    avbuf->buf.flags = avbuf->flags;

+

+    ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QBUF, &avbuf->buf);

+    if (ret < 0)

+        return AVERROR(errno);

+

+    avbuf->status = V4L2BUF_IN_DRIVER;

+

+    return 0;

+}

new file mode 100644

@@ -0,0 +1,121 @@

+/*

+ * V4L2 buffer 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

+ */

+

+#ifndef AVCODEC_V4L2_BUFFERS_H

+#define AVCODEC_V4L2_BUFFERS_H

+

+enum V4L2Buffer_status {

+    V4L2BUF_AVAILABLE,

+    V4L2BUF_IN_DRIVER,

+    V4L2BUF_RET_USER,

+};

+

+/**

+ * V4L2Buffer (wrapper for v4l2_buffer management)

+ */

+typedef struct V4L2Buffer {

+    /* each buffer needs to have a reference to its context */

+    struct V4L2Context *context;

+

+    /* keep track of the mmap address and mmap length */

+    struct V4L2Plane_info {

+        int bytesperline;

+        void * mm_addr;

+        size_t length;

+    } plane_info[VIDEO_MAX_PLANES];

+

+    int num_planes;

+

+    /* the v4l2_buffer buf.m.planes pointer uses the planes[] mem */

+    struct v4l2_buffer buf;

+    struct v4l2_plane planes[VIDEO_MAX_PLANES];

+

+    int flags;

+    enum V4L2Buffer_status status;

+

+} V4L2Buffer;

+

+/**

+ * Extracts the data from a V4L2Buffer to an AVFrame

+ *

+ * @param[in] frame The AVFRame to push the information to

+ * @param[in] buf The V4L2Buffer to get the information from

+ *

+ * @returns 0 in case of success, EINVAL if the number of planes is incorrect,

+ * ENOMEM if the AVBufferRef cant be created.

+ */

+int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *buf);

+

+/**

+ * Extracts the data from a V4L2Buffer to an AVPacket

+ *

+ * @param[in] pkt The AVPacket to push the information to

+ * @param[in] buf The V4L2Buffer to get the information from

+ *

+ * @returns 0 in case of success, EINVAL if the number of planes is incorrect,

+ * ENOMEM if the AVBufferRef cant be created.

+ *

+ */

+int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *buf);

+

+/**

+ * Extracts the data from an AVPacket to a V4L2Buffer

+ *

+ * @param[in]  frame AVPacket to get the data from

+ * @param[in]  avbuf V4L2Bfuffer to push the information to

+ *

+ * @returns 0 in case of success, negative otherwise

+ */

+int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out);

+

+/**

+ * Extracts the data from an AVFrame to a V4L2Buffer

+ *

+ * @param[in]  frame AVFrame to get the data from

+ * @param[in]  avbuf V4L2Bfuffer to push the information to

+ *

+ * @returns 0 in case of success, negative otherwise

+ */

+int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer* out);

+

+/**

+ * Initializes a V4L2Buffer

+ *

+ * @param[in]  avbuf V4L2Bfuffer to initialize

+ * @param[in]  index v4l2 buffer id

+ *

+ * @returns 0 in case of success, negative otherwise

+ */

+int ff_v4l2_buffer_initialize(V4L2Buffer* avbuf, int index);

+

+/**

+ * Enqueues a V4L2Buffer

+ *

+ * @param[in] avbuf V4L2Bfuffer to push to the driver

+ *

+ * @returns 0 in case of success, negative otherwise

+ */

+int ff_v4l2_buffer_enqueue(V4L2Buffer* avbuf);

+

+

+#endif // AVCODEC_V4L2_BUFFERS_H

new file mode 100644

@@ -0,0 +1,667 @@

+/*

+ * 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"