[FFmpeg-devel] [PATCHv13] libavcodec: v4l2: add support for v4l2 mem2mem codecs
Jorge Ramirez-Ortiz
jorge.ramirez-ortiz at linaro.org
Thu Sep 21 17:44:19 EEST 2017
On 09/20/2017 06:55 PM, Jorge Ramirez-Ortiz wrote:
> This patchset enhances Alexis Ballier's original patch and validates
> it using Qualcomm's Venus hardware (driver recently landed upstream
> [1]).
>
> This has been tested on Qualcomm's DragonBoard 410c and 820c
> Configure/make scripts have been validated on Ubuntu 10.04 and
> 16.04.
JFYI, I will do a functional demo of encoding/decoding during Linaro Connect in
SFO next week using Qualcomm's hardware
>
> Tested decoders:
> - h264
> - h263
> - mpeg4
> - vp8
> - vp9
> - hevc
>
> Tested encoders:
> - h264
> - h263
> - mpeg4
>
> Tested transcoding (concurrent encoding/decoding)
>
> Some of the changes introduced:
> - v4l2: code cleanup and abstractions added
> - v4l2: follow the new encode/decode api.
> - v4l2: fix display size for NV12 output pool.
> - v4l2: handle EOS (EPIPE and draining)
> - v4l2: vp8 and mpeg4 decoding and encoding.
> - v4l2: hevc and vp9 support.
> - v4l2: generate EOF on dequeue errors.
> - v4l2: h264_mp4toannexb filtering.
> - v4l2: fixed make install and fate issues.
> - v4l2: codecs enabled/disabled depending on pixfmt defined
> - v4l2: pass timebase/framerate to the context
> - v4l2: runtime decoder reconfiguration.
> - v4l2: add more frame information
> - v4l2: free hardware resources on last reference being released
> - v4l2: encoding: disable b-frames for upstreaming (patch required)
>
> [1] https://lwn.net/Articles/697956/
>
>
> System Level view:
> v42l_m2m_enc/dec --> v4l2_m2m --> v4l2_context --> v4l2_buffers
>
> Reviewed-by: Jorge Ramirez <jorge.ramirez-ortiz at linaro.org>
> Reviewed-by: Alexis Ballier <aballier at gentoo.org>
> Tested-by: Jorge Ramirez <jorge.ramirez-ortiz at linaro.org>
> ---
> Changelog | 1 +
> configure | 28 ++
> libavcodec/Makefile | 15 ++
> libavcodec/allcodecs.c | 9 +
> libavcodec/v4l2_buffers.c | 453 +++++++++++++++++++++++++++++++
> libavcodec/v4l2_buffers.h | 121 +++++++++
> libavcodec/v4l2_context.c | 667 ++++++++++++++++++++++++++++++++++++++++++++++
> libavcodec/v4l2_context.h | 181 +++++++++++++
> libavcodec/v4l2_fmt.c | 182 +++++++++++++
> libavcodec/v4l2_fmt.h | 34 +++
> libavcodec/v4l2_m2m.c | 383 ++++++++++++++++++++++++++
> libavcodec/v4l2_m2m.h | 103 +++++++
> libavcodec/v4l2_m2m_dec.c | 228 ++++++++++++++++
> libavcodec/v4l2_m2m_enc.c | 352 ++++++++++++++++++++++++
> 14 files changed, 2757 insertions(+)
> create mode 100644 libavcodec/v4l2_buffers.c
> create mode 100644 libavcodec/v4l2_buffers.h
> create mode 100644 libavcodec/v4l2_context.c
> create mode 100644 libavcodec/v4l2_context.h
> create mode 100644 libavcodec/v4l2_fmt.c
> create mode 100644 libavcodec/v4l2_fmt.h
> create mode 100644 libavcodec/v4l2_m2m.c
> create mode 100644 libavcodec/v4l2_m2m.h
> create mode 100644 libavcodec/v4l2_m2m_dec.c
> create mode 100644 libavcodec/v4l2_m2m_enc.c
>
> diff --git a/Changelog b/Changelog
> index ea48e81..330899e 100644
> --- a/Changelog
> +++ b/Changelog
> @@ -48,6 +48,7 @@ version <next>:
> - convolve video filter
> - VP9 tile threading support
> - KMS screen grabber
> +- V4L2 mem2mem HW assisted codecs
>
> version 3.3:
> - CrystalHD decoder moved to new decode API
> diff --git a/configure b/configure
> index 2de20a0..548d359 100755
> --- a/configure
> +++ b/configure
> @@ -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"
> @@ -2764,6 +2767,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"
> @@ -2782,6 +2787,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"
> @@ -2793,12 +2800,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"
> @@ -2809,6 +2819,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"
> @@ -2816,6 +2827,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"
> @@ -2826,16 +2839,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"
>
> @@ -6108,9 +6125,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
> diff --git a/libavcodec/Makefile b/libavcodec/Makefile
> index fad5612..fa0cb97 100644
> --- a/libavcodec/Makefile
> +++ b/libavcodec/Makefile
> @@ -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
> diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
> index 6257205..db2db15 100644
> --- a/libavcodec/allcodecs.c
> +++ b/libavcodec/allcodecs.c
> @@ -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);
> diff --git a/libavcodec/v4l2_buffers.c b/libavcodec/v4l2_buffers.c
> new file mode 100644
> index 0000000..ef7d040
> --- /dev/null
> +++ b/libavcodec/v4l2_buffers.c
> @@ -0,0 +1,453 @@
> +/*
> + * V4L2 buffer helper functions.
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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;
> +}
> diff --git a/libavcodec/v4l2_buffers.h b/libavcodec/v4l2_buffers.h
> new file mode 100644
> index 0000000..8901a09
> --- /dev/null
> +++ b/libavcodec/v4l2_buffers.h
> @@ -0,0 +1,121 @@
> +/*
> + * V4L2 buffer helper functions.
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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
> diff --git a/libavcodec/v4l2_context.c b/libavcodec/v4l2_context.c
> new file mode 100644
> index 0000000..d675c55
> --- /dev/null
> +++ b/libavcodec/v4l2_context.c
> @@ -0,0 +1,667 @@
> +/*
> + * V4L2 context helper functions.
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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 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 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;
> + } 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;
> + }
> +}
> +
> +/**
> + * returns 1 if reinit was succesful, 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_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);
> + }
> +
> + 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);
> + }
> +
> + 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 -EINVAL;
> + }
> + goto reinit_run;
> + }
> +
> + if (reinit) {
> + 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 -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,
> + };
> + 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);
> + }
> +
> + return 0;
> +}
> +
> +static int v4l2_stop_encode(V4L2Context *ctx)
> +{
> + struct v4l2_encoder_cmd cmd = {
> + .cmd = V4L2_ENC_CMD_STOP,
> + };
> + 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);
> + }
> +
> + 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 = NULL;
> + struct pollfd pfd = {
> + .events = POLLIN | POLLRDNORM | POLLPRI | POLLOUT | POLLWRNORM, /* default blocking capture */
> + .fd = ctx_to_m2mctx(ctx)->fd,
> + };
> + int ret;
> +
> + if (V4L2_TYPE_IS_OUTPUT(ctx->type))
> + pfd.events = POLLOUT | POLLWRNORM;
> +
> + for (;;) {
> + ret = poll(&pfd, 1, timeout);
> + if (ret > 0)
> + break;
> + if (errno == EINTR)
> + continue;
> +
> + /* timeout is being used to indicate last valid bufer when draining */
> + if (ctx_to_m2mctx(ctx)->draining)
> + ctx->done = 1;
> +
> + return NULL;
> + }
> +
> + /* 0. handle errors */
> + if (pfd.revents & POLLERR) {
> + 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 = EINVAL;
> + return NULL;
> + }
> + if (ret) {
> + /* if re-init was successfull 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 = errno;
> + if (errno != EPIPE)
> + av_log(logger(ctx), AV_LOG_DEBUG, "%s VIDIOC_DQBUF, errno (%s)\n",
> + ctx->name, av_err2str(AVERROR(errno)));
> + }
> + } else {
> + 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;
> +}
> +
> +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)
> + pixfmt = AV_PIX_FMT_NONE;
> + else
> + 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, int 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(ENOMEM);
> +
> + 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(ENOMEM);
> +
> + 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)
> +{
> + V4L2Buffer* avbuf = NULL;
> +
> + /* if we are draining, we are no longer inputing data, therefore enable a
> + * timeout so we can dequeue and flag the last valid buffer.
> + *
> + * blocks until:
> + * 1. decoded frame available
> + * 2. an input buffer is ready to be dequeued
> + */
> + avbuf = v4l2_dequeue_v4l2buf(ctx, ctx_to_m2mctx(ctx)->draining ? 200 : -1);
> + 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 = NULL;
> +
> + /* if we are draining, we are no longer inputing data, therefore enable a
> + * timeout so we can dequeue and flag the last valid buffer.
> + *
> + * blocks until:
> + * 1. encoded packet available
> + * 2. an input buffer ready to be dequeued
> + */
> + avbuf = v4l2_dequeue_v4l2buf(ctx, ctx_to_m2mctx(ctx)->draining ? 200 : -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)
> +{
> + 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 = 1;
> + 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_free(ctx->buffers);
> + ctx->buffers = NULL;
> +}
> +
> +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)
> + 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 initialization (%s)\n", ctx->name, av_err2str(ret));
> + av_free(ctx->buffers);
> + return ret;
> + }
> + }
> +
> + 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;
> +}
> diff --git a/libavcodec/v4l2_context.h b/libavcodec/v4l2_context.h
> new file mode 100644
> index 0000000..b6667a0
> --- /dev/null
> +++ b/libavcodec/v4l2_context.h
> @@ -0,0 +1,181 @@
> +/*
> + * V4L2 context helper functions.
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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_CONTEXT_H
> +#define AVCODEC_V4L2_CONTEXT_H
> +
> +#include <stdatomic.h>
> +#include "libavcodec/avcodec.h"
> +#include "libavutil/pixfmt.h"
> +#include "libavutil/frame.h"
> +#include "libavutil/buffer.h"
> +#include "v4l2_buffers.h"
> +
> +typedef struct V4L2Context {
> + /**
> + * context name.
> + */
> + const char* name;
> +
> + /**
> + * Type of this buffer context.
> + * See V4L2_BUF_TYPE_VIDEO_* in videodev2.h
> + * Readonly after init.
> + */
> + enum v4l2_buf_type type;
> +
> + /**
> + * AVPixelFormat corresponding to this buffer context.
> + * AV_PIX_FMT_NONE means this is an encoded stream.
> + */
> + enum AVPixelFormat av_pix_fmt;
> +
> + /**
> + * AVCodecID corresponding to this buffer context.
> + * AV_CODEC_ID_RAWVIDEO means this is a raw stream and av_pix_fmt must be set to a valid value.
> + */
> + enum AVCodecID av_codec_id;
> +
> + /**
> + * Format returned by the driver after initializing the buffer context.
> + * Readonly after init.
> + */
> + struct v4l2_format format;
> +
> + /**
> + * Width and height of the frames it produces (in case of a capture context, e.g. when decoding)
> + * or accepts (in case of an output context, e.g. when encoding).
> + */
> + int width, height;
> +
> + /**
> + * Indexed array of V4L2Buffers
> + */
> + V4L2Buffer *buffers;
> +
> + /**
> + * Readonly after init.
> + */
> + int num_buffers;
> +
> + /**
> + * Whether the stream has been started (VIDIOC_STREAMON has been sent).
> + */
> + int streamon;
> +
> + /**
> + * Either no more buffers available or an unrecoverable error was notified
> + * by the V4L2 kernel driver: once set the context has to be exited.
> + */
> + int done;
> +
> +} V4L2Context;
> +
> +/**
> + * Initializes a V4L2Context.
> + *
> + * @param[in] ctx A pointer to a V4L2Context. See V4L2Context description for required variables.
> + * @return 0 in case of success, a negative value representing the error otherwise.
> + */
> +int ff_v4l2_context_init(V4L2Context* ctx);
> +
> +/**
> + * Sets the V4L2Context format in the v4l2 driver.
> + *
> + * @param[in] ctx A pointer to a V4L2Context. See V4L2Context description for required variables.
> + * @return 0 in case of success, a negative value representing the error otherwise.
> + */
> +int ff_v4l2_context_set_format(V4L2Context* ctx);
> +
> +/**
> + * Queries the driver for a valid v4l2 format and copies it to the context.
> + *
> + * @param[in] ctx A pointer to a V4L2Context. See V4L2Context description for required variables.
> + * @return 0 in case of success, a negative value representing the error otherwise.
> + */
> +int ff_v4l2_context_get_format(V4L2Context* ctx);
> +
> +/**
> + * Releases a V4L2Context.
> + *
> + * @param[in] ctx A pointer to a V4L2Context.
> + * The caller is reponsible for freeing it.
> + * It must not be used after calling this function.
> + */
> +void ff_v4l2_context_release(V4L2Context* ctx);
> +
> +/**
> + * Sets the status of a V4L2Context.
> + *
> + * @param[in] ctx A pointer to a V4L2Context.
> + * @param[in] cmd The status to set (VIDIOC_STREAMON or VIDIOC_STREAMOFF).
> + * Warning: If VIDIOC_STREAMOFF is sent to a buffer context that still has some frames buffered,
> + * those frames will be dropped.
> + * @return 0 in case of success, a negative value representing the error otherwise.
> + */
> +int ff_v4l2_context_set_status(V4L2Context* ctx, int cmd);
> +
> +/**
> + * Dequeues a buffer from a V4L2Context to an AVPacket.
> + *
> + * The pkt must be non NULL.
> + * @param[in] ctx The V4L2Context to dequeue from.
> + * @param[inout] pkt The AVPacket to dequeue to.
> + * @return 0 in case of success, AVERROR(EAGAIN) if no buffer was ready, another negative error in case of error.
> + */
> +int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt);
> +
> +/**
> + * Dequeues a buffer from a V4L2Context to an AVFrame.
> + *
> + * The frame must be non NULL.
> + * @param[in] ctx The V4L2Context to dequeue from.
> + * @param[inout] f The AVFrame to dequeue to.
> + * @return 0 in case of success, AVERROR(EAGAIN) if no buffer was ready, another negative error in case of error.
> + */
> +int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* f);
> +
> +/**
> + * Enqueues a buffer to a V4L2Context from an AVPacket
> + *
> + * The packet must be non NULL.
> + * When the size of the pkt is null, the buffer is not queued but a V4L2_DEC_CMD_STOP command is sent instead to the driver.
> + *
> + * @param[in] ctx The V4L2Context to enqueue to.
> + * @param[in] pkt A pointer to an AVPacket.
> + * @return 0 in case of success, a negative error otherwise.
> + */
> +int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt);
> +
> +/**
> + * Enqueues a buffer to a V4L2Context from an AVFrame
> + *
> + * The frame must be non NULL.
> + *
> + * @param[in] ctx The V4L2Context to enqueue to.
> + * @param[in] f A pointer to an AVFrame to enqueue.
> + * @return 0 in case of success, a negative error otherwise.
> + */
> +int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* f);
> +
> +#endif // AVCODEC_V4L2_CONTEXT_H
> diff --git a/libavcodec/v4l2_fmt.c b/libavcodec/v4l2_fmt.c
> new file mode 100644
> index 0000000..a7ce308
> --- /dev/null
> +++ b/libavcodec/v4l2_fmt.c
> @@ -0,0 +1,182 @@
> +/*
> + * V4L2 format helper functions
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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 <search.h>
> +#include "v4l2_fmt.h"
> +
> +#define V4L2_FMT(x) V4L2_PIX_FMT_##x
> +#define AV_CODEC(x) AV_CODEC_ID_##x
> +#define AV_FMT(x) AV_PIX_FMT_##x
> +
> +static const struct fmt_conversion {
> + enum AVPixelFormat avfmt;
> + enum AVCodecID avcodec;
> + uint32_t v4l2_fmt;
> +} fmt_map[] = {
> + { AV_FMT(RGB555LE), AV_CODEC(RAWVIDEO), V4L2_FMT(RGB555) },
> + { AV_FMT(RGB555BE), AV_CODEC(RAWVIDEO), V4L2_FMT(RGB555X) },
> + { AV_FMT(RGB565LE), AV_CODEC(RAWVIDEO), V4L2_FMT(RGB565) },
> + { AV_FMT(RGB565BE), AV_CODEC(RAWVIDEO), V4L2_FMT(RGB565X) },
> + { AV_FMT(BGR24), AV_CODEC(RAWVIDEO), V4L2_FMT(BGR24) },
> + { AV_FMT(RGB24), AV_CODEC(RAWVIDEO), V4L2_FMT(RGB24) },
> + { AV_FMT(BGR0), AV_CODEC(RAWVIDEO), V4L2_FMT(BGR32) },
> + { AV_FMT(0RGB), AV_CODEC(RAWVIDEO), V4L2_FMT(RGB32) },
> + { AV_FMT(GRAY8), AV_CODEC(RAWVIDEO), V4L2_FMT(GREY) },
> + { AV_FMT(YUV420P), AV_CODEC(RAWVIDEO), V4L2_FMT(YUV420) },
> + { AV_FMT(YUYV422), AV_CODEC(RAWVIDEO), V4L2_FMT(YUYV) },
> + { AV_FMT(UYVY422), AV_CODEC(RAWVIDEO), V4L2_FMT(UYVY) },
> + { AV_FMT(YUV422P), AV_CODEC(RAWVIDEO), V4L2_FMT(YUV422P) },
> + { AV_FMT(YUV411P), AV_CODEC(RAWVIDEO), V4L2_FMT(YUV411P) },
> + { AV_FMT(YUV410P), AV_CODEC(RAWVIDEO), V4L2_FMT(YUV410) },
> + { AV_FMT(YUV410P), AV_CODEC(RAWVIDEO), V4L2_FMT(YVU410) },
> + { AV_FMT(NV12), AV_CODEC(RAWVIDEO), V4L2_FMT(NV12) },
> + { AV_FMT(NONE), AV_CODEC(MJPEG), V4L2_FMT(MJPEG) },
> + { AV_FMT(NONE), AV_CODEC(MJPEG), V4L2_FMT(JPEG) },
> +#ifdef V4L2_PIX_FMT_SRGGB8
> + { AV_FMT(BAYER_BGGR8), AV_CODEC(RAWVIDEO), V4L2_FMT(SBGGR8) },
> + { AV_FMT(BAYER_GBRG8), AV_CODEC(RAWVIDEO), V4L2_FMT(SGBRG8) },
> + { AV_FMT(BAYER_GRBG8), AV_CODEC(RAWVIDEO), V4L2_FMT(SGRBG8) },
> + { AV_FMT(BAYER_RGGB8), AV_CODEC(RAWVIDEO), V4L2_FMT(SRGGB8) },
> +#endif
> +#ifdef V4L2_PIX_FMT_Y16
> + { AV_FMT(GRAY16LE), AV_CODEC(RAWVIDEO), V4L2_FMT(Y16) },
> +#endif
> +#ifdef V4L2_PIX_FMT_NV12M
> + { AV_FMT(NV12), AV_CODEC(RAWVIDEO), V4L2_FMT(NV12M) },
> +#endif
> +#ifdef V4L2_PIX_FMT_NV21M
> + { AV_FMT(NV21), AV_CODEC(RAWVIDEO), V4L2_FMT(NV21M) },
> +#endif
> +#ifdef V4L2_PIX_FMT_YUV420M
> + { AV_FMT(YUV420P), AV_CODEC(RAWVIDEO), V4L2_FMT(YUV420M) },
> +#endif
> +#ifdef V4L2_PIX_FMT_NV16M
> + { AV_FMT(NV16), AV_CODEC(RAWVIDEO), V4L2_FMT(NV16M) },
> +#endif
> +#ifdef V4L2_PIX_FMT_H263
> + { AV_FMT(NONE), AV_CODEC(H263), V4L2_FMT(H263) },
> +#endif
> +#ifdef V4L2_PIX_FMT_H264
> + { AV_FMT(NONE), AV_CODEC(H264), V4L2_FMT(H264) },
> +#endif
> +#ifdef V4L2_PIX_FMT_MPEG4
> + { AV_FMT(NONE), AV_CODEC(MPEG4), V4L2_FMT(MPEG4) },
> +#endif
> +#ifdef V4L2_PIX_FMT_CPIA1
> + { AV_FMT(NONE), AV_CODEC(CPIA), V4L2_FMT(CPIA1) },
> +#endif
> +#ifdef V4L2_PIX_FMT_DV
> + { AV_FMT(NONE), AV_CODEC(DVVIDEO), V4L2_FMT(DV) },
> +#endif
> +#ifdef V4L2_PIX_FMT_MPEG1
> + { AV_FMT(NONE), AV_CODEC(MPEG1VIDEO), V4L2_FMT(MPEG1) },
> +#endif
> +#ifdef V4L2_PIX_FMT_MPEG2
> + { AV_FMT(NONE), AV_CODEC(MPEG2VIDEO), V4L2_FMT(MPEG2) },
> +#endif
> +#ifdef V4L2_PIX_FMT_VP8
> + { AV_FMT(NONE), AV_CODEC(VP8), V4L2_FMT(VP8) },
> +#endif
> +#ifdef V4L2_PIX_FMT_VP9
> + { AV_FMT(NONE), AV_CODEC(VP9), V4L2_FMT(VP9) },
> +#endif
> +#ifdef V4L2_PIX_FMT_HEVC
> + { AV_FMT(NONE), AV_CODEC(HEVC), V4L2_FMT(HEVC) },
> +#endif
> +#ifdef V4L2_PIX_FMT_VC1_ANNEX_G
> + { AV_FMT(NONE), AV_CODEC(VC1), V4L2_FMT(VC1_ANNEX_G) },
> +#endif
> +};
> +
> +static int match_codec(const void *a, const void *b)
> +{
> + if (*(enum AVCodecID *)a == ((struct fmt_conversion *)b)->avcodec)
> + return 0;
> +
> + return 1;
> +}
> +
> +uint32_t ff_v4l2_format_avcodec_to_v4l2(enum AVCodecID avcodec)
> +{
> + size_t len = FF_ARRAY_ELEMS(fmt_map);
> + struct fmt_conversion *item;
> +
> + item = lfind(&avcodec, fmt_map, &len, sizeof(fmt_map[0]), match_codec);
> + if (item)
> + return item->v4l2_fmt;
> +
> + return 0;
> +}
> +
> +static int match_fmt(const void *a, const void *b)
> +{
> + if ( *(enum AVPixelFormat *)a == ((struct fmt_conversion *)b)->avfmt)
> + return 0;
> +
> + return 1;
> +}
> +
> +uint32_t ff_v4l2_format_avfmt_to_v4l2(enum AVPixelFormat avfmt)
> +{
> + size_t len = FF_ARRAY_ELEMS(fmt_map);
> + struct fmt_conversion *item;
> +
> + item = lfind(&avfmt, fmt_map, &len, sizeof(fmt_map[0]), match_fmt);
> + if (item)
> + return item->v4l2_fmt;
> +
> + return 0;
> +}
> +
> +struct v4l2fmt_avcodec_pair {
> + enum AVCodecID avcodec;
> + uint32_t v4l2_fmt;
> +};
> +
> +static int match_codecfmt(const void *a, const void *b)
> +{
> + struct v4l2fmt_avcodec_pair *key = (struct v4l2fmt_avcodec_pair *) a;
> + struct fmt_conversion *item = (struct fmt_conversion *) b;
> +
> + if (key->avcodec == item->avcodec && key->v4l2_fmt == item->v4l2_fmt)
> + return 0;
> +
> + return 1;
> +}
> +
> +enum AVPixelFormat ff_v4l2_format_v4l2_to_avfmt(uint32_t v4l2_fmt, enum AVCodecID avcodec)
> +{
> + struct v4l2fmt_avcodec_pair const key = {
> + .v4l2_fmt = v4l2_fmt,
> + .avcodec = avcodec,
> + };
> + size_t len = FF_ARRAY_ELEMS(fmt_map);
> + struct fmt_conversion *item;
> +
> + item = lfind(&key, fmt_map, &len, sizeof(fmt_map[0]), match_codecfmt);
> + if (item)
> + return item->avfmt;
> +
> + return AV_PIX_FMT_NONE;
> +}
> diff --git a/libavcodec/v4l2_fmt.h b/libavcodec/v4l2_fmt.h
> new file mode 100644
> index 0000000..0136002
> --- /dev/null
> +++ b/libavcodec/v4l2_fmt.h
> @@ -0,0 +1,34 @@
> +/*
> + * V4L2 format helper functions
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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_FMT_H
> +#define AVCODEC_V4L2_FMT_H
> +
> +#include "libavcodec/avcodec.h"
> +#include "libavutil/pixfmt.h"
> +
> +enum AVPixelFormat ff_v4l2_format_v4l2_to_avfmt(uint32_t v4l2_fmt, enum AVCodecID avcodec);
> +uint32_t ff_v4l2_format_avcodec_to_v4l2(enum AVCodecID avcodec);
> +uint32_t ff_v4l2_format_avfmt_to_v4l2(enum AVPixelFormat avfmt);
> +
> +#endif /* AVCODEC_V4L2_FMT_H*/
> diff --git a/libavcodec/v4l2_m2m.c b/libavcodec/v4l2_m2m.c
> new file mode 100644
> index 0000000..1d7a852
> --- /dev/null
> +++ b/libavcodec/v4l2_m2m.c
> @@ -0,0 +1,383 @@
> +/*
> + * V4L mem2mem
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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 <dirent.h>
> +#include <fcntl.h>
> +#include "libavcodec/avcodec.h"
> +#include "libavcodec/internal.h"
> +#include "libavutil/pixdesc.h"
> +#include "libavutil/imgutils.h"
> +#include "libavutil/pixfmt.h"
> +#include "v4l2_context.h"
> +#include "v4l2_fmt.h"
> +#include "v4l2_m2m.h"
> +
> +static inline int v4l2_splane_video(struct v4l2_capability *cap)
> +{
> + if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT) &&
> + cap->capabilities & V4L2_CAP_STREAMING)
> + return 1;
> +
> + if (cap->capabilities & V4L2_CAP_VIDEO_M2M)
> + return 1;
> +
> + return 0;
> +}
> +
> +static inline int v4l2_mplane_video(struct v4l2_capability *cap)
> +{
> + if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_OUTPUT_MPLANE) &&
> + cap->capabilities & V4L2_CAP_STREAMING)
> + return 1;
> +
> + if (cap->capabilities & V4L2_CAP_VIDEO_M2M_MPLANE)
> + return 1;
> +
> + return 0;
> +}
> +
> +static int v4l2_prepare_contexts(V4L2m2mContext* s)
> +{
> + struct v4l2_capability cap;
> + int ret;
> +
> + s->capture.done = s->output.done = 0;
> + s->capture.name = "capture";
> + s->output.name = "output ";
> + atomic_init(&s->refcount, 0);
> + sem_init(&s->refsync, 0, 0);
> +
> + memset(&cap, 0, sizeof(cap));
> + ret = ioctl(s->fd, VIDIOC_QUERYCAP, &cap);
> + if (ret < 0)
> + return ret;
> +
> + av_log(s->avctx, AV_LOG_INFO, "driver '%s' on card '%s'\n", cap.driver, cap.card);
> +
> + if (v4l2_mplane_video(&cap)) {
> + s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
> + s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
> + return 0;
> + }
> +
> + if (v4l2_splane_video(&cap)) {
> + s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> + s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
> + return 0;
> + }
> +
> + return AVERROR(EINVAL);
> +}
> +
> +static int v4l2_probe_driver(V4L2m2mContext* s)
> +{
> + int ret;
> +
> + s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
> + if (s->fd < 0)
> + return AVERROR(errno);
> +
> + ret = v4l2_prepare_contexts(s);
> + if (ret < 0)
> + goto done;
> +
> + ret = ff_v4l2_context_get_format(&s->output);
> + if (ret) {
> + av_log(s->avctx, AV_LOG_DEBUG, "v4l2 output format not supported\n");
> + goto done;
> + }
> +
> + ret = ff_v4l2_context_get_format(&s->capture);
> + if (ret) {
> + av_log(s->avctx, AV_LOG_DEBUG, "v4l2 capture format not supported\n");
> + goto done;
> + }
> +
> +done:
> + if (close(s->fd) < 0) {
> + ret = AVERROR(errno);
> + av_log(s->avctx, AV_LOG_ERROR, "failure closing %s (%s)\n", s->devname, av_err2str(AVERROR(errno)));
> + }
> +
> + s->fd = -1;
> +
> + return ret;
> +}
> +
> +static int v4l2_configure_contexts(V4L2m2mContext* s)
> +{
> + void *log_ctx = s->avctx;
> + int ret;
> +
> + s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
> + if (s->fd < 0)
> + return AVERROR(errno);
> +
> + ret = v4l2_prepare_contexts(s);
> + if (ret < 0)
> + goto error;
> +
> + ret = ff_v4l2_context_set_format(&s->output);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "can't set v4l2 output format\n");
> + goto error;
> + }
> +
> + ret = ff_v4l2_context_set_format(&s->capture);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "can't to set v4l2 capture format\n");
> + goto error;
> + }
> +
> + ret = ff_v4l2_context_init(&s->output);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "no v4l2 output context's buffers\n");
> + goto error;
> + }
> +
> + /* decoder's buffers need to be updated at a later stage */
> + if (!av_codec_is_decoder(s->avctx->codec)) {
> + ret = ff_v4l2_context_init(&s->capture);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "no v4l2 capture context's buffers\n");
> + goto error;
> + }
> + }
> +
> + return 0;
> +
> +error:
> + if (close(s->fd) < 0) {
> + ret = AVERROR(errno);
> + av_log(log_ctx, AV_LOG_ERROR, "error closing %s (%s)\n",
> + s->devname, av_err2str(AVERROR(errno)));
> + }
> + s->fd = -1;
> +
> + return ret;
> +}
> +
> +/******************************************************************************
> + *
> + * V4L2 M2M Interface
> + *
> + ******************************************************************************/
> +int ff_v4l2_m2m_codec_reinit(V4L2m2mContext* s)
> +{
> + int ret;
> +
> + av_log(s->avctx, AV_LOG_DEBUG, "reinit context\n");
> +
> + /* 1. streamoff */
> + ret = ff_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF);
> + if (ret)
> + av_log(s->avctx, AV_LOG_ERROR, "capture VIDIOC_STREAMOFF\n");
> +
> + /* 2. unmap the capture buffers (v4l2 and ffmpeg):
> + * we must wait for all references to be released before being allowed
> + * to queue new buffers.
> + */
> + av_log(s->avctx, AV_LOG_DEBUG, "waiting for user to release AVBufferRefs\n");
> + if (atomic_load(&s->refcount))
> + while(sem_wait(&s->refsync) == -1 && errno == EINTR);
> +
> + ff_v4l2_context_release(&s->capture);
> +
> + /* 3. get the new capture format */
> + ret = ff_v4l2_context_get_format(&s->capture);
> + if (ret) {
> + av_log(s->avctx, AV_LOG_ERROR, "query the new capture format\n");
> + return ret;
> + }
> +
> + /* 4. set the capture format */
> + ret = ff_v4l2_context_set_format(&s->capture);
> + if (ret) {
> + av_log(s->avctx, AV_LOG_ERROR, "setting capture format\n");
> + return ret;
> + }
> +
> + /* 5. complete reinit */
> + sem_destroy(&s->refsync);
> + sem_init(&s->refsync, 0, 0);
> + s->draining = 0;
> + s->reinit = 0;
> +
> + return 0;
> +}
> +
> +int ff_v4l2_m2m_codec_full_reinit(V4L2m2mContext *s)
> +{
> + void *log_ctx = s->avctx;
> + int ret;
> +
> + av_log(log_ctx, AV_LOG_DEBUG, "%s full reinit\n", s->devname);
> +
> + /* wait for pending buffer references */
> + if (atomic_load(&s->refcount))
> + while(sem_wait(&s->refsync) == -1 && errno == EINTR);
> +
> + /* close the driver */
> + ff_v4l2_m2m_codec_end(s->avctx);
> +
> + /* start again now that we know the stream dimensions */
> + s->draining = 0;
> + s->reinit = 0;
> +
> + s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
> + if (s->fd < 0)
> + return AVERROR(errno);
> +
> + ret = v4l2_prepare_contexts(s);
> + if (ret < 0)
> + goto error;
> +
> + /* if a full re-init was requested - probe didn't run - we need to populate
> + * the format for each context
> + */
> + ret = ff_v4l2_context_get_format(&s->output);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_DEBUG, "v4l2 output format not supported\n");
> + goto error;
> + }
> +
> + ret = ff_v4l2_context_get_format(&s->capture);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_DEBUG, "v4l2 capture format not supported\n");
> + goto error;
> + }
> +
> + ret = ff_v4l2_context_set_format(&s->output);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "can't set v4l2 output format\n");
> + goto error;
> + }
> +
> + ret = ff_v4l2_context_set_format(&s->capture);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "can't to set v4l2 capture format\n");
> + goto error;
> + }
> +
> + ret = ff_v4l2_context_init(&s->output);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "no v4l2 output context's buffers\n");
> + goto error;
> + }
> +
> + /* decoder's buffers need to be updated at a later stage */
> + if (!av_codec_is_decoder(s->avctx->codec)) {
> + ret = ff_v4l2_context_init(&s->capture);
> + if (ret) {
> + av_log(log_ctx, AV_LOG_ERROR, "no v4l2 capture context's buffers\n");
> + goto error;
> + }
> + }
> +
> + return 0;
> +
> +error:
> + if (close(s->fd) < 0) {
> + ret = AVERROR(errno);
> + av_log(log_ctx, AV_LOG_ERROR, "error closing %s (%s)\n",
> + s->devname, av_err2str(AVERROR(errno)));
> + }
> + s->fd = -1;
> +
> + return ret;
> +}
> +
> +int ff_v4l2_m2m_codec_end(AVCodecContext *avctx)
> +{
> + V4L2m2mContext* s = avctx->priv_data;
> + int ret;
> +
> + ret = ff_v4l2_context_set_status(&s->output, VIDIOC_STREAMOFF);
> + if (ret)
> + av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF %s\n", s->output.name);
> +
> + ret = ff_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF);
> + if (ret)
> + av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF %s\n", s->capture.name);
> +
> + ff_v4l2_context_release(&s->output);
> +
> + if (atomic_load(&s->refcount))
> + av_log(avctx, AV_LOG_ERROR, "ff_v4l2m2m_codec_end leaving pending buffers\n");
> +
> + ff_v4l2_context_release(&s->capture);
> + sem_destroy(&s->refsync);
> +
> + /* release the hardware */
> + if (close(s->fd) < 0 )
> + av_log(avctx, AV_LOG_ERROR, "failure closing %s (%s)\n", s->devname, av_err2str(AVERROR(errno)));
> +
> + s->fd = -1;
> +
> + return 0;
> +}
> +
> +int ff_v4l2_m2m_codec_init(AVCodecContext *avctx)
> +{
> + int ret = AVERROR(EINVAL);
> + struct dirent *entry;
> + char node[PATH_MAX];
> + DIR *dirp;
> +
> + V4L2m2mContext *s = avctx->priv_data;
> + s->avctx = avctx;
> +
> + dirp = opendir("/dev");
> + if (!dirp)
> + return AVERROR(errno);
> +
> + for (entry = readdir(dirp); entry; entry = readdir(dirp)) {
> +
> + if (strncmp(entry->d_name, "video", 5))
> + continue;
> +
> + snprintf(node, sizeof(node), "/dev/%s", entry->d_name);
> + av_log(s->avctx, AV_LOG_DEBUG, "probing device %s\n", node);
> + strncpy(s->devname, node, strlen(node) + 1);
> + ret = v4l2_probe_driver(s);
> + if (!ret)
> + break;
> + }
> +
> + closedir(dirp);
> +
> + if (ret) {
> + av_log(s->avctx, AV_LOG_ERROR, "Could not find a valid device\n");
> + memset(s->devname, 0, sizeof(s->devname));
> +
> + return ret;
> + }
> +
> + av_log(s->avctx, AV_LOG_INFO, "Using device %s\n", node);
> +
> + return v4l2_configure_contexts(s);
> +}
> diff --git a/libavcodec/v4l2_m2m.h b/libavcodec/v4l2_m2m.h
> new file mode 100644
> index 0000000..13e2285
> --- /dev/null
> +++ b/libavcodec/v4l2_m2m.h
> @@ -0,0 +1,103 @@
> +/*
> + * V4L2 mem2mem helper functions
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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_M2M_H
> +#define AVCODEC_V4L2_M2M_H
> +
> +#include <semaphore.h>
> +#include <unistd.h>
> +#include <dirent.h>
> +#include "libavcodec/avcodec.h"
> +#include "v4l2_context.h"
> +
> +#define container_of(ptr, type, member) ({ \
> + const __typeof__(((type *)0)->member ) *__mptr = (ptr); \
> + (type *)((char *)__mptr - offsetof(type,member) );})
> +
> +#define V4L_M2M_DEFAULT_OPTS \
> + { "num_output_buffers", "Number of buffers in the output context",\
> + OFFSET(output.num_buffers), AV_OPT_TYPE_INT, { .i64 = 16 }, 6, INT_MAX, FLAGS }
> +
> +typedef struct V4L2m2mContext
> +{
> + AVClass *class;
> + char devname[PATH_MAX];
> + int fd;
> +
> + /* the codec context queues */
> + V4L2Context capture;
> + V4L2Context output;
> +
> + /* refcount of buffers held by the user */
> + atomic_uint refcount;
> +
> + /* dynamic stream reconfig */
> + AVCodecContext *avctx;
> + sem_t refsync;
> + int reinit;
> +
> + /* null frame/packet received */
> + int draining;
> +} V4L2m2mContext;
> +
> +/**
> + * Probes the video nodes looking for the required codec capabilities.
> + *
> + * @param[in] ctx The AVCodecContext instantiated by the encoder/decoder.
> + *
> + * @returns 0 if a driver is found, a negative number otherwise.
> + */
> +int ff_v4l2_m2m_codec_init(AVCodecContext *avctx);
> +
> +/**
> + * Releases all the codec resources if all AVBufferRefs have been returned to the
> + * ctx. Otherwise keep the driver open.
> + *
> + * @param[in] The AVCodecContext instantiated by the encoder/decoder.
> + *
> + * @returns 0
> + *
> + */
> +int ff_v4l2_m2m_codec_end(AVCodecContext *avctx);
> +
> +/**
> + * Reinitializes the V4L2m2mContext when the driver cant continue processing
> + * with the capture parameters.
> + *
> + * @param[in] ctx The V4L2m2mContext instantiated by the encoder/decoder.
> + *
> + * @returns 0 in case of success, negative number otherwise
> + */
> +int ff_v4l2_m2m_codec_reinit(V4L2m2mContext *ctx);
> +
> +/**
> + * Reinitializes the V4L2m2mContext when the driver cant continue processing
> + * with the any of the current V4L2Contexts (ie, changes in output and capture).
> + *
> + * @param[in] ctx The V4L2m2mContext instantiated by the encoder/decoder.
> + *
> + * @returns 0 in case of success, negative number otherwise
> + */
> +int ff_v4l2_m2m_codec_full_reinit(V4L2m2mContext *ctx);
> +
> +#endif /* AVCODEC_V4L2_M2M_H */
> diff --git a/libavcodec/v4l2_m2m_dec.c b/libavcodec/v4l2_m2m_dec.c
> new file mode 100644
> index 0000000..958cdc5
> --- /dev/null
> +++ b/libavcodec/v4l2_m2m_dec.c
> @@ -0,0 +1,228 @@
> +/*
> + * V4L2 mem2mem decoders
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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 "libavutil/pixfmt.h"
> +#include "libavutil/pixdesc.h"
> +#include "libavutil/opt.h"
> +#include "libavcodec/avcodec.h"
> +#include "libavcodec/decode.h"
> +
> +#include "v4l2_context.h"
> +#include "v4l2_m2m.h"
> +#include "v4l2_fmt.h"
> +
> +static int v4l2_try_start(AVCodecContext *avctx)
> +{
> + V4L2m2mContext *s = avctx->priv_data;
> + V4L2Context *const capture = &s->capture;
> + V4L2Context *const output = &s->output;
> + struct v4l2_selection selection;
> + int ret;
> +
> + /* 1. start the output process */
> + if (!output->streamon) {
> + ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
> + if (ret < 0) {
> + av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON on output context\n");
> + return ret;
> + }
> + }
> +
> + if (capture->streamon)
> + return 0;
> +
> + /* 2. get the capture format */
> + capture->format.type = capture->type;
> + ret = ioctl(s->fd, VIDIOC_G_FMT, &capture->format);
> + if (ret) {
> + av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_FMT ioctl\n");
> + return ret;
> + }
> +
> + /* 2.1 update the AVCodecContext */
> + avctx->pix_fmt = ff_v4l2_format_v4l2_to_avfmt(capture->format.fmt.pix_mp.pixelformat, AV_CODEC_ID_RAWVIDEO);
> + capture->av_pix_fmt = avctx->pix_fmt;
> +
> + /* 3. set the crop parameters */
> + selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
> + selection.r.height = avctx->coded_height;
> + selection.r.width = avctx->coded_width;
> + ret = ioctl(s->fd, VIDIOC_S_SELECTION, &selection);
> + if (!ret) {
> + ret = ioctl(s->fd, VIDIOC_G_SELECTION, &selection);
> + if (ret) {
> + av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_SELECTION ioctl\n");
> + } else {
> + av_log(avctx, AV_LOG_DEBUG, "crop output %dx%d\n", selection.r.width, selection.r.height);
> + /* update the size of the resulting frame */
> + capture->height = selection.r.height;
> + capture->width = selection.r.width;
> + }
> + }
> +
> + /* 4. init the capture context now that we have the capture format */
> + if (!capture->buffers) {
> + ret = ff_v4l2_context_init(capture);
> + if (ret) {
> + av_log(avctx, AV_LOG_DEBUG, "can't request output buffers\n");
> + return ret;
> + }
> + }
> +
> + /* 5. start the capture process */
> + ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
> + if (ret) {
> + av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON, on capture context\n");
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int v4l2_prepare_decoder(V4L2m2mContext *s)
> +{
> + struct v4l2_event_subscription sub;
> + V4L2Context *output = &s->output;
> + int ret;
> +
> + /**
> + * requirements
> + */
> + memset(&sub, 0, sizeof(sub));
> + sub.type = V4L2_EVENT_SOURCE_CHANGE;
> + ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
> + if ( ret < 0) {
> + if (output->height == 0 || output->width == 0) {
> + av_log(s->avctx, AV_LOG_ERROR,
> + "the v4l2 driver does not support VIDIOC_SUBSCRIBE_EVENT\n"
> + "you must provide codec_height and codec_width on input\n");
> + return ret;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int v4l2_receive_frame(AVCodecContext *avctx, AVFrame *frame)
> +{
> + V4L2m2mContext *s = avctx->priv_data;
> + V4L2Context *const capture = &s->capture;
> + V4L2Context *const output = &s->output;
> + AVPacket avpkt = {0};
> + int ret;
> +
> + ret = ff_decode_get_packet(avctx, &avpkt);
> + if (ret < 0 && ret != AVERROR_EOF)
> + return ret;
> +
> + if (s->draining)
> + goto dequeue;
> +
> + ret = ff_v4l2_context_enqueue_packet(output, &avpkt);
> + if (ret < 0) {
> + if (ret != AVERROR(ENOMEM))
> + return ret;
> + /* no input buffers available, continue dequeing */
> + }
> +
> + if (avpkt.size) {
> + ret = v4l2_try_start(avctx);
> + if (ret)
> + return 0;
> + }
> +
> +dequeue:
> + return ff_v4l2_context_dequeue_frame(capture, frame);
> +}
> +
> +static av_cold int v4l2_decode_init(AVCodecContext *avctx)
> +{
> + V4L2m2mContext *s = avctx->priv_data;
> + V4L2Context *capture = &s->capture;
> + V4L2Context *output = &s->output;
> + int ret;
> +
> + /* if these dimensions are invalid (ie, 0 or too small) an event will be raised
> + * by the v4l2 driver; this event will trigger a full pipeline reconfig and
> + * the proper values will be retrieved from the kernel driver.
> + */
> + output->height = capture->height = avctx->coded_height;
> + output->width = capture->width = avctx->coded_width;
> +
> + output->av_codec_id = avctx->codec_id;
> + output->av_pix_fmt = AV_PIX_FMT_NONE;
> +
> + capture->av_codec_id = AV_CODEC_ID_RAWVIDEO;
> + capture->av_pix_fmt = avctx->pix_fmt;
> +
> + ret = ff_v4l2_m2m_codec_init(avctx);
> + if (ret) {
> + av_log(avctx, AV_LOG_ERROR, "can't configure decoder\n");
> + return ret;
> + }
> +
> + return v4l2_prepare_decoder(s);
> +}
> +
> +#define OFFSET(x) offsetof(V4L2m2mContext, x)
> +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
> +
> +static const AVOption options[] = {
> + V4L_M2M_DEFAULT_OPTS,
> + { "num_capture_buffers", "Number of buffers in the capture context",
> + OFFSET(capture.num_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 20, INT_MAX, FLAGS },
> + { NULL},
> +};
> +
> +#define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \
> +static const AVClass v4l2_m2m_ ## NAME ## _dec_class = {\
> + .class_name = #NAME "_v4l2_m2m_decoder",\
> + .item_name = av_default_item_name,\
> + .option = options,\
> + .version = LIBAVUTIL_VERSION_INT,\
> +};\
> +\
> +AVCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
> + .name = #NAME "_v4l2m2m" ,\
> + .long_name = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " decoder wrapper"),\
> + .type = AVMEDIA_TYPE_VIDEO,\
> + .id = CODEC ,\
> + .priv_data_size = sizeof(V4L2m2mContext),\
> + .priv_class = &v4l2_m2m_ ## NAME ## _dec_class,\
> + .init = v4l2_decode_init,\
> + .receive_frame = v4l2_receive_frame,\
> + .close = ff_v4l2_m2m_codec_end,\
> + .bsfs = bsf_name, \
> +};
> +
> +M2MDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb");
> +M2MDEC(hevc, "HEVC", AV_CODEC_ID_HEVC, "hevc_mp4toannexb");
> +M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);
> +M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);
> +M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4, NULL);
> +M2MDEC(h263, "H.263", AV_CODEC_ID_H263, NULL);
> +M2MDEC(vc1 , "VC1", AV_CODEC_ID_VC1, NULL);
> +M2MDEC(vp8, "VP8", AV_CODEC_ID_VP8, NULL);
> +M2MDEC(vp9, "VP9", AV_CODEC_ID_VP9, NULL);
> diff --git a/libavcodec/v4l2_m2m_enc.c b/libavcodec/v4l2_m2m_enc.c
> new file mode 100644
> index 0000000..e40a120
> --- /dev/null
> +++ b/libavcodec/v4l2_m2m_enc.c
> @@ -0,0 +1,352 @@
> +/*
> + * V4L2 mem2mem encoders
> + *
> + * Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org>
> + * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz at 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 <search.h>
> +#include "libavcodec/avcodec.h"
> +#include "libavutil/pixdesc.h"
> +#include "libavutil/pixfmt.h"
> +#include "libavutil/opt.h"
> +#include "v4l2_context.h"
> +#include "v4l2_m2m.h"
> +
> +#define MPEG_CID(x) V4L2_CID_MPEG_VIDEO_##x
> +#define MPEG_VIDEO(x) V4L2_MPEG_VIDEO_##x
> +
> +static inline void v4l2_set_timeperframe(V4L2m2mContext *s, unsigned int num, unsigned int den)
> +{
> + struct v4l2_streamparm parm = { 0 };
> +
> + parm.type = V4L2_TYPE_IS_MULTIPLANAR(s->output.type) ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : V4L2_BUF_TYPE_VIDEO_OUTPUT;
> + parm.parm.output.timeperframe.denominator = den;
> + parm.parm.output.timeperframe.numerator = num;
> +
> + if (ioctl(s->fd, VIDIOC_S_PARM, &parm) < 0)
> + av_log(s->avctx, AV_LOG_WARNING, "Failed to set timeperframe");
> +}
> +
> +static inline void v4l2_set_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int value, const char *name)
> +{
> + struct v4l2_ext_controls ctrls = { 0 };
> + struct v4l2_ext_control ctrl = { 0 };
> +
> + /* set ctrls */
> + ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
> + ctrls.controls = &ctrl;
> + ctrls.count = 1;
> +
> + /* set ctrl*/
> + ctrl.value = value;
> + ctrl.id = id ;
> +
> + if (ioctl(s->fd, VIDIOC_S_EXT_CTRLS, &ctrls) < 0)
> + av_log(s->avctx, AV_LOG_WARNING, "Failed to set %s\n", name);
> + else
> + av_log(s->avctx, AV_LOG_DEBUG, "Encoder: %s = %d\n", name, value);
> +}
> +
> +static inline int v4l2_get_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int *value, const char *name)
> +{
> + struct v4l2_ext_controls ctrls = { 0 };
> + struct v4l2_ext_control ctrl = { 0 };
> + int ret;
> +
> + /* set ctrls */
> + ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
> + ctrls.controls = &ctrl;
> + ctrls.count = 1;
> +
> + /* set ctrl*/
> + ctrl.id = id ;
> +
> + ret = ioctl(s->fd, VIDIOC_G_EXT_CTRLS, &ctrls);
> + if (ret < 0) {
> + av_log(s->avctx, AV_LOG_WARNING, "Failed to set %s\n", name);
> + return ret;
> + }
> +
> + *value = ctrl.value;
> +
> + return 0;
> +}
> +
> +static int match_profile(const void *a, const void *b)
> +{
> + if (*(unsigned int *)a == *(unsigned int *)b)
> + return 0;
> +
> + return 1;
> +}
> +
> +static inline unsigned int v4l2_h264_profile_from_ff(int p)
> +{
> + struct h264_profile {
> + unsigned int ffmpeg_val;
> + unsigned int v4l2_val;
> + } *val, profile[] = {
> + { FF_PROFILE_H264_CONSTRAINED_BASELINE, MPEG_VIDEO(H264_PROFILE_CONSTRAINED_BASELINE) },
> + { FF_PROFILE_H264_HIGH_444_PREDICTIVE, MPEG_VIDEO(H264_PROFILE_HIGH_444_PREDICTIVE) },
> + { FF_PROFILE_H264_HIGH_422_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_422_INTRA) },
> + { FF_PROFILE_H264_HIGH_444_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_444_INTRA) },
> + { FF_PROFILE_H264_HIGH_10_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_10_INTRA) },
> + { FF_PROFILE_H264_HIGH_422, MPEG_VIDEO(H264_PROFILE_HIGH_422) },
> + { FF_PROFILE_H264_BASELINE, MPEG_VIDEO(H264_PROFILE_BASELINE) },
> + { FF_PROFILE_H264_EXTENDED, MPEG_VIDEO(H264_PROFILE_EXTENDED) },
> + { FF_PROFILE_H264_HIGH_10, MPEG_VIDEO(H264_PROFILE_HIGH_10) },
> + { FF_PROFILE_H264_MAIN, MPEG_VIDEO(H264_PROFILE_MAIN) },
> + { FF_PROFILE_H264_HIGH, MPEG_VIDEO(H264_PROFILE_HIGH) },
> + };
> + size_t len = FF_ARRAY_ELEMS(profile);
> +
> + val = lfind(&p, profile, &len, sizeof(profile[0]), match_profile);
> + if (val)
> + return val->v4l2_val;
> +
> + return AVERROR(ENOENT);
> +}
> +
> +static inline int v4l2_mpeg4_profile_from_ff(int p)
> +{
> + struct mpeg4_profile {
> + unsigned int ffmpeg_val;
> + unsigned int v4l2_val;
> + } *val, profile[] = {
> + { FF_PROFILE_MPEG4_ADVANCED_CODING, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY) },
> + { FF_PROFILE_MPEG4_ADVANCED_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_SIMPLE) },
> + { FF_PROFILE_MPEG4_SIMPLE_SCALABLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE_SCALABLE) },
> + { FF_PROFILE_MPEG4_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE) },
> + { FF_PROFILE_MPEG4_CORE, MPEG_VIDEO(MPEG4_PROFILE_CORE) },
> + };
> + size_t len = FF_ARRAY_ELEMS(profile);
> +
> + val = lfind(&p, profile, &len, sizeof(profile[0]), match_profile);
> + if (val)
> + return val->v4l2_val;
> +
> + return AVERROR(ENOENT);
> +}
> +
> +static int v4l2_check_b_frame_support(V4L2m2mContext *s)
> +{
> + if (s->avctx->max_b_frames)
> + av_log(s->avctx, AV_LOG_WARNING, "Encoder does not support b-frames yet\n");
> +
> + v4l2_set_ext_ctrl(s, MPEG_CID(B_FRAMES), 0, "number of B-frames");
> + v4l2_get_ext_ctrl(s, MPEG_CID(B_FRAMES), &s->avctx->max_b_frames, "number of B-frames");
> + if (s->avctx->max_b_frames == 0)
> + return 0;
> +
> + avpriv_report_missing_feature(s->avctx, "DTS/PTS calculation for V4L2 encoding");
> +
> + return AVERROR_PATCHWELCOME;
> +}
> +
> +static int v4l2_prepare_encoder(V4L2m2mContext *s)
> +{
> + AVCodecContext *avctx = s->avctx;
> + int qmin_cid, qmax_cid, qmin, qmax;
> + int ret, val;
> +
> + /**
> + * requirements
> + */
> + ret = v4l2_check_b_frame_support(s);
> + if (ret)
> + return ret;
> +
> + /**
> + * settingss
> + */
> + if (avctx->framerate.num || avctx->framerate.den)
> + v4l2_set_timeperframe(s, avctx->framerate.num, avctx->framerate.den);
> +
> + /* set ext ctrls */
> + v4l2_set_ext_ctrl(s, MPEG_CID(HEADER_MODE), MPEG_VIDEO(HEADER_MODE_SEPARATE), "header mode");
> + v4l2_set_ext_ctrl(s, MPEG_CID(BITRATE) , avctx->bit_rate, "bit rate");
> + v4l2_set_ext_ctrl(s, MPEG_CID(GOP_SIZE), avctx->gop_size,"gop size");
> +
> + av_log(avctx, AV_LOG_DEBUG,
> + "Encoder Context: id (%d), profile (%d), frame rate(%d/%d), number b-frames (%d), "
> + "gop size (%d), bit rate (%ld), qmin (%d), qmax (%d)\n",
> + avctx->codec_id, avctx->profile, avctx->framerate.num, avctx->framerate.den,
> + avctx->max_b_frames, avctx->gop_size, avctx->bit_rate, avctx->qmin, avctx->qmax);
> +
> + switch (avctx->codec_id) {
> + case AV_CODEC_ID_H264:
> + val = v4l2_h264_profile_from_ff(avctx->profile);
> + if (val < 0)
> + av_log(avctx, AV_LOG_WARNING, "h264 profile not found\n");
> + else
> + v4l2_set_ext_ctrl(s, MPEG_CID(H264_PROFILE), val, "h264 profile");
> + qmin_cid = MPEG_CID(H264_MIN_QP);
> + qmax_cid = MPEG_CID(H264_MAX_QP);
> + qmin = 0;
> + qmax = 51;
> + break;
> + case AV_CODEC_ID_MPEG4:
> + val = v4l2_mpeg4_profile_from_ff(avctx->profile);
> + if (val < 0)
> + av_log(avctx, AV_LOG_WARNING, "mpeg4 profile not found\n");
> + else
> + v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_PROFILE), val, "mpeg4 profile");
> + qmin_cid = MPEG_CID(MPEG4_MIN_QP);
> + qmax_cid = MPEG_CID(MPEG4_MAX_QP);
> + if (avctx->flags & CODEC_FLAG_QPEL)
> + v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_QPEL), 1, "qpel");
> + qmin = 1;
> + qmax = 31;
> + break;
> + case AV_CODEC_ID_H263:
> + qmin_cid = MPEG_CID(H263_MIN_QP);
> + qmax_cid = MPEG_CID(H263_MAX_QP);
> + qmin = 1;
> + qmax = 31;
> + break;
> + case AV_CODEC_ID_VP8:
> + qmin_cid = MPEG_CID(VPX_MIN_QP);
> + qmax_cid = MPEG_CID(VPX_MAX_QP);
> + qmin = 0;
> + qmax = 127;
> + break;
> + case AV_CODEC_ID_VP9:
> + qmin_cid = MPEG_CID(VPX_MIN_QP);
> + qmax_cid = MPEG_CID(VPX_MAX_QP);
> + qmin = 0;
> + qmax = 255;
> + break;
> + default:
> + return 0;
> + }
> +
> + if (qmin != avctx->qmin || qmax != avctx->qmax)
> + av_log(avctx, AV_LOG_WARNING, "Encoder adjusted: qmin (%d), qmax (%d)\n", qmin, qmax);
> +
> + v4l2_set_ext_ctrl(s, qmin_cid, qmin, "minimum video quantizer scale");
> + v4l2_set_ext_ctrl(s, qmax_cid, qmax, "maximum video quantizer scale");
> +
> + return 0;
> +}
> +
> +static int v4l2_send_frame(AVCodecContext *avctx, const AVFrame *frame)
> +{
> + V4L2m2mContext *s = avctx->priv_data;
> + V4L2Context *const output = &s->output;
> +
> + return ff_v4l2_context_enqueue_frame(output, frame);
> +}
> +
> +static int v4l2_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
> +{
> + V4L2m2mContext *s = avctx->priv_data;
> + V4L2Context *const capture = &s->capture;
> + V4L2Context *const output = &s->output;
> + int ret;
> +
> + if (s->draining)
> + goto dequeue;
> +
> + if (!output->streamon) {
> + ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
> + if (ret) {
> + av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF failed on output context\n");
> + return ret;
> + }
> + }
> +
> + if (!capture->streamon) {
> + ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
> + if (ret) {
> + av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMON failed on capture context\n");
> + return ret;
> + }
> + }
> +
> +dequeue:
> + return ff_v4l2_context_dequeue_packet(capture, avpkt);
> +}
> +
> +static av_cold int v4l2_encode_init(AVCodecContext *avctx)
> +{
> + V4L2m2mContext *s = avctx->priv_data;
> + V4L2Context *capture = &s->capture;
> + V4L2Context *output = &s->output;
> + int ret;
> +
> + /* common settings output/capture */
> + output->height = capture->height = avctx->height;
> + output->width = capture->width = avctx->width;
> +
> + /* output context */
> + output->av_codec_id = AV_CODEC_ID_RAWVIDEO;
> + output->av_pix_fmt = avctx->pix_fmt;
> +
> + /* capture context */
> + capture->av_codec_id = avctx->codec_id;
> + capture->av_pix_fmt = AV_PIX_FMT_NONE;
> +
> + ret = ff_v4l2_m2m_codec_init(avctx);
> + if (ret) {
> + av_log(avctx, AV_LOG_ERROR, "can't configure encoder\n");
> + return ret;
> + }
> +
> + return v4l2_prepare_encoder(s);
> +}
> +
> +#define OFFSET(x) offsetof(V4L2m2mContext, x)
> +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
> +
> +static const AVOption options[] = {
> + V4L_M2M_DEFAULT_OPTS,
> + { "num_capture_buffers", "Number of buffers in the capture context",
> + OFFSET(capture.num_buffers), AV_OPT_TYPE_INT, {.i64 = 4 }, 4, INT_MAX, FLAGS },
> + { NULL },
> +};
> +
> +#define M2MENC(NAME, LONGNAME, CODEC) \
> +static const AVClass v4l2_m2m_ ## NAME ## _enc_class = {\
> + .class_name = #NAME "_v4l2_m2m_encoder",\
> + .item_name = av_default_item_name,\
> + .option = options,\
> + .version = LIBAVUTIL_VERSION_INT,\
> +};\
> +\
> +AVCodec ff_ ## NAME ## _v4l2m2m_encoder = { \
> + .name = #NAME "_v4l2m2m" ,\
> + .long_name = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " encoder wrapper"),\
> + .type = AVMEDIA_TYPE_VIDEO,\
> + .id = CODEC ,\
> + .priv_data_size = sizeof(V4L2m2mContext),\
> + .priv_class = &v4l2_m2m_ ## NAME ##_enc_class,\
> + .init = v4l2_encode_init,\
> + .send_frame = v4l2_send_frame,\
> + .receive_packet = v4l2_receive_packet,\
> + .close = ff_v4l2_m2m_codec_end,\
> +};
> +
> +M2MENC(mpeg4,"MPEG4", AV_CODEC_ID_MPEG4);
> +M2MENC(h263, "H.263", AV_CODEC_ID_H263);
> +M2MENC(h264, "H.264", AV_CODEC_ID_H264);
> +M2MENC(hevc, "HEVC", AV_CODEC_ID_HEVC);
> +M2MENC(vp8, "VP8", AV_CODEC_ID_VP8);
More information about the ffmpeg-devel
mailing list