From patchwork Tue Aug 8 16:07:08 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jorge Ramirez-Ortiz X-Patchwork-Id: 4660 Delivered-To: ffmpegpatchwork@gmail.com Received: by 10.103.46.211 with SMTP id u202csp4449376vsu; Tue, 8 Aug 2017 09:08:12 -0700 (PDT) X-Received: by 10.28.107.144 with SMTP id a16mr2837351wmi.178.1502208492115; Tue, 08 Aug 2017 09:08:12 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1502208492; cv=none; d=google.com; s=arc-20160816; b=Mqn3umLHen88N6mj+AY+8VregbE47bea5hTj2pD7QojsORU2yMLTyNK+zGeq4eHQSv wmtzIMQwytc2NH8PJFdsdOIIaAGmfWRT2rRGUEJxjraTSjEwt7jvm5xmRlZbmhRIZnVz 75FAxNBfmbIntCq2FSO6ng+HKyR8Iq9LWsPqByiQLUdWWM+XZkLg2wL6+TYD/N18ZnKj D4qlvownJU5saDzkYWjTCFsCblvZsonsp9AaKzYS4vpIjLHX1Gk63nXxBP3s/SAGwDWJ n7TTt2vK0lvoINtvw0Abyr2jQ5ZUx6alNJkElWO/Wyqr7QQS4tfykrO6AJtJ+1QB3kMz 3Mqw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:mime-version:cc:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:references:in-reply-to:message-id:date :to:from:dkim-signature:delivered-to:arc-authentication-results; bh=+WC75mlO4RtafvCVgMClj4ZdZyWxYK1ynKYPTale4W8=; b=f56PGi5IM3OSBDWuV8WXMcX8pqoqNLXt6aZwMqfsYjFBUs2bX9D6wlOOS8QXetZSTG Vd6RzNBB1pXwJmyV8IuPRcgXBTMczxQ0B74RZljO0pmrj4MGt5mZab/k7FZ9QI3VQzMh tMEWiCd9Pt8WwszDpApSsA55TPtuZJdWL1nKEbxNm3gD0fp4NGqpc8qv6kl0I4DsFj1b JYz7WxR2RKAyI3dg/nTxaJ1KDaDFfK8R299CxWApUYZlVGugU8ooI52pIlBweYAhgwIv TRg9AsIk4+P6+CZjU1LNrX0UgNx3ENyKKemuPng6Mg5gupvaGbKrMWupRDRnwM5at/Z4 DI9A== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=gpatb+61; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id u21si1430659wrb.258.2017.08.08.09.08.11; Tue, 08 Aug 2017 09:08:12 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org header.s=google header.b=gpatb+61; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id EF21C68972F; Tue, 8 Aug 2017 19:07:27 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-wr0-f180.google.com (mail-wr0-f180.google.com [209.85.128.180]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 491BA68922C for ; Tue, 8 Aug 2017 19:07:21 +0300 (EEST) Received: by mail-wr0-f180.google.com with SMTP id 33so14684217wrz.4 for ; Tue, 08 Aug 2017 09:07:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=UNltmBWFjIAgW4y82cLIbgMYO1musViqMFIDA96ducs=; b=gpatb+61bAUI+dVQ+XxrABOulfwdsnsmMLED6LclHRfXaTxz/tEBOeMRTeWiC7AXwe iM6Zv+0d+hfToZPQgvsUkcTsMuN0T5fFCFtx1zX3HKgurIQAHhUQ/gO9AKm4lZ6GMrPb sJEgMKRWtPzo76AjmCdJkZ5sapsBfKV6TPGW4= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=UNltmBWFjIAgW4y82cLIbgMYO1musViqMFIDA96ducs=; b=JmJmzSIQXWamDJtI90TVy8TDkcXWKq2r3Ej9ffVjWLi/eE/zkaz7NYL6MLaVPCRhjs B0CGWLq8Xy0opyFi18QYcBCbw5vjUG33gM6P7p255r5Rn+ykcK6WyesPWsHrRAViHIXB WSPMOh+KotEmD1qksKJHIX836tRujDYfF0vNmDHyjDX8KGLw96kM6YptO6ehCgF7W23v M7TYMDlD+MaRYRY+4D2bUqosxs/FAeal/3j3ypKuj/YVnrHNG73fVVPhu6NEBVfFFnfL C4ZjKOETohcFCuG65elK+D5NPKTNEfhh0UpdH5ih68bb7qrETysWdtOdnmf5cTeYQULm iLzQ== X-Gm-Message-State: AHYfb5jebbowsQ/fh5MtbFU1ramGq7Hz9bN9G5Er3/7/MX2QR8tOJgPY GwNRc4hHDOtxlEDN006gYw== X-Received: by 10.223.165.138 with SMTP id g10mr3107297wrc.167.1502208441814; Tue, 08 Aug 2017 09:07:21 -0700 (PDT) Received: from igloo.80.58.61.254 (39.red-81-40-130.staticip.rima-tde.net. [81.40.130.39]) by smtp.gmail.com with ESMTPSA id u30sm1477395wru.88.2017.08.08.09.07.20 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 08 Aug 2017 09:07:21 -0700 (PDT) From: Jorge Ramirez-Ortiz To: jorge.ramirez-ortiz@linaro.org, ffmpeg-devel@ffmpeg.org, sw@jkqxz.net Date: Tue, 8 Aug 2017 18:07:08 +0200 Message-Id: <1502208428-17267-5-git-send-email-jorge.ramirez-ortiz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1502208428-17267-1-git-send-email-jorge.ramirez-ortiz@linaro.org> References: <1502208428-17267-1-git-send-email-jorge.ramirez-ortiz@linaro.org> Subject: [FFmpeg-devel] [PATCHv4 4/4] libavcodec: v4l2: add support for v4l2 mem2mem codecs X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: nicolas.dechesne@linaro.org, stanimir.varbanov@linaro.org MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" 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 Tested decoders: - h264 - 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. - v4l2: vp8 and mpeg4 decoding. - 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 [1] https://lwn.net/Articles/697956/ Reviewed-by: Jorge Ramirez Reviewed-by: Alexis Ballier Tested-by: Jorge Ramirez --- Changelog | 3 +- configure | 30 ++- libavcodec/Makefile | 19 +- libavcodec/allcodecs.c | 9 + libavcodec/v4l2_buffers.c | 585 ++++++++++++++++++++++++++++++++++++++++++ libavcodec/v4l2_buffers.h | 249 ++++++++++++++++++ libavcodec/v4l2_fmt.c | 11 +- libavcodec/v4l2_m2m.c | 381 +++++++++++++++++++++++++++ libavcodec/v4l2_m2m.h | 52 ++++ libavcodec/v4l2_m2m_avcodec.h | 32 +++ libavcodec/v4l2_m2m_dec.c | 239 +++++++++++++++++ libavcodec/v4l2_m2m_enc.c | 290 +++++++++++++++++++++ 12 files changed, 1889 insertions(+), 11 deletions(-) create mode 100644 libavcodec/v4l2_buffers.c create mode 100644 libavcodec/v4l2_buffers.h create mode 100644 libavcodec/v4l2_m2m.c create mode 100644 libavcodec/v4l2_m2m.h create mode 100644 libavcodec/v4l2_m2m_avcodec.h create mode 100644 libavcodec/v4l2_m2m_dec.c create mode 100644 libavcodec/v4l2_m2m_enc.c diff --git a/Changelog b/Changelog index c797d68..b1bc7fb 100644 --- a/Changelog +++ b/Changelog @@ -32,6 +32,7 @@ version : - unpremultiply video filter - tlut2 video filter - floodfill video filter +- V4L2 mem2mem HW accelerated codecs support version 3.3: - CrystalHD decoder moved to new decode API @@ -68,7 +69,6 @@ version 3.3: - Intel QSV-accelerated VP8 video decoding - VAAPI-accelerated deinterlacing - version 3.2: - libopenmpt demuxer - tee protocol @@ -108,7 +108,6 @@ version 3.2: - Changed mapping of rtp MIME type G726 to codec g726le. - spec compliant VAAPI/DXVA2 VC-1 decoding of slices in frame-coded images - version 3.1: - DXVA2-accelerated HEVC Main10 decoding - fieldhint filter diff --git a/configure b/configure index ed94de0..6040c6f 100755 --- a/configure +++ b/configure @@ -149,6 +149,7 @@ Component options: --disable-pixelutils disable pixel utils in libavutil Individual component options: + --disable-v4l2_m2m disable V4L2 mem2mem code [autodetect] --disable-everything disable all components listed below --disable-encoder=NAME disable encoder NAME --enable-encoder=NAME enable encoder NAME @@ -1432,6 +1433,7 @@ AVCODEC_COMPONENTS=" AVDEVICE_COMPONENTS=" indevs + v4l2_m2m outdevs " AVFILTER_COMPONENTS=" @@ -2270,6 +2272,7 @@ map 'eval ${v}_inline_deps=inline_asm' $ARCH_EXT_LIST_ARM loongson2_deps="mips" loongson3_deps="mips" v4l2_deps_any="linux_videodev2_h sys_videoio_h" +v4l2_m2m_select="v4l2" mipsfpu_deps="mips" mipsdsp_deps="mips" mipsdspr2_deps="mips" @@ -2742,6 +2745,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" @@ -2760,6 +2765,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" @@ -2771,12 +2778,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" @@ -2787,6 +2797,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" @@ -2794,6 +2805,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" @@ -2804,16 +2817,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" @@ -3592,7 +3609,7 @@ done enable_weak audiotoolbox # Enable hwaccels by default. -enable_weak d3d11va dxva2 vaapi vda vdpau videotoolbox_hwaccel xvmc +enable_weak d3d11va dxva2 vaapi v4l2_m2m vda vdpau videotoolbox_hwaccel xvmc enable_weak xlib enable_weak cuda cuvid nvenc vda_framework videotoolbox videotoolbox_encoder @@ -6057,10 +6074,21 @@ 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/videodev.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 6be1b4b..615fb8e 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -101,7 +101,6 @@ OBJS-$(CONFIG_LZF) += lzf.o OBJS-$(CONFIG_MDCT) += mdct_fixed.o mdct_float.o mdct_fixed_32.o OBJS-$(CONFIG_ME_CMP) += me_cmp.o OBJS-$(CONFIG_MEDIACODEC) += mediacodecdec_common.o mediacodec_surface.o mediacodec_wrapper.o mediacodec_sw_buffer.o -OBJS-$(CONFIG_V4L2) += v4l2_fmt.o OBJS-$(CONFIG_MPEG_ER) += mpeg_er.o OBJS-$(CONFIG_MPEGAUDIO) += mpegaudio.o OBJS-$(CONFIG_MPEGAUDIODSP) += mpegaudiodsp.o \ @@ -138,6 +137,8 @@ OBJS-$(CONFIG_VIDEODSP) += videodsp.o OBJS-$(CONFIG_VP3DSP) += vp3dsp.o OBJS-$(CONFIG_VP56DSP) += vp56dsp.o OBJS-$(CONFIG_VP8DSP) += vp8dsp.o +OBJS-$(CONFIG_V4L2) += v4l2_fmt.o v4l2_buffers.o +OBJS-$(CONFIG_V4L2_M2M) += v4l2_m2m.o OBJS-$(CONFIG_WMA_FREQS) += wma_freqs.o OBJS-$(CONFIG_WMV2DSP) += wmv2dsp.o @@ -322,6 +323,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 \ @@ -339,6 +342,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 \ @@ -352,6 +357,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 @@ -421,6 +428,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 @@ -428,9 +436,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 @@ -604,6 +615,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 @@ -613,6 +625,7 @@ OBJS-$(CONFIG_VORBIS_DECODER) += vorbisdec.o vorbisdsp.o vorbis.o \ vorbis_data.o OBJS-$(CONFIG_VORBIS_ENCODER) += vorbisenc.o vorbis.o \ vorbis_data.o +OBJS-$(CONFIG_VPLAYER_DECODER) += textdec.o ass.o OBJS-$(CONFIG_VP3_DECODER) += vp3.o OBJS-$(CONFIG_VP5_DECODER) += vp5.o vp56.o vp56data.o vp56rac.o OBJS-$(CONFIG_VP6_DECODER) += vp6.o vp56.o vp56data.o \ @@ -623,13 +636,15 @@ 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 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 4712592..d154ac9 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -207,8 +207,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); @@ -219,6 +221,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); @@ -253,6 +256,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); @@ -262,8 +266,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); @@ -361,6 +367,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); @@ -372,7 +379,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..951e12f --- /dev/null +++ b/libavcodec/v4l2_buffers.c @@ -0,0 +1,585 @@ +/* + * V4L2 buffer{,context} helper functions. + * + * Copyright (C) 2017 Alexis Ballier + * Copyright (C) 2017 Jorge Ramirez + * + * 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 +#include +#include +#include +#include +#include "avcodec.h" +#include "internal.h" +#include "v4l2_buffers.h" +#include "v4l2_fmt.h" + +#define BUFFER_TYPE_SUPPORTED(ctx) \ + ((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)) + +enum V4L2Buffer_status { + V4L2BUF_AVAILABLE, + V4L2BUF_IN_DRIVER, + V4L2BUF_RET_USER, +}; + +/* buffer transform */ +typedef int (*pkt_to_buf_f)(const AVPacket *, V4L2Buffer *); +typedef int (*frm_to_buf_f)(const AVFrame *, V4L2Buffer *); +typedef int (*buf_to_pkt_f)(AVPacket *, V4L2Buffer *); +typedef int (*buf_to_frm_f)(AVFrame *, V4L2Buffer *); + +typedef int (*buf_to_bufref_f)(V4L2Buffer *in, int plane, AVBufferRef **buf); +typedef int (*bufref_to_buf_f)(V4L2Buffer *out, int plane, const uint8_t* data, int size, AVBufferRef* bref); + +struct V4L2Buffer_ops { + pkt_to_buf_f pkt_to_buf; + frm_to_buf_f frm_to_buf; + buf_to_pkt_f buf_to_pkt; + buf_to_frm_f buf_to_frm; + + bufref_to_buf_f bufref_to_buf; + buf_to_bufref_f buf_to_bufref; +}; + +struct V4L2Buffer { + /* each buffer needs to have a reference to its context */ + struct V4L2Context *context; + + struct V4L2Plane_info { + void * mm_addr; + size_t lengths; + } plane_info[VIDEO_MAX_PLANES]; + + /* some common buffer operations */ + struct V4L2Buffer_ops ops; + + /* memcpy to the v4l2_buffer planes array when needed */ + struct v4l2_plane planes[VIDEO_MAX_PLANES]; + struct v4l2_buffer buf; + + int bytesperline[4]; + int num_planes; + int num_lines; + + int flags; + struct timeval timestamp; + enum V4L2Buffer_status status; +}; + +static inline void set_pts(V4L2Buffer *out, int64_t pts) +{ + if (pts == AV_NOPTS_VALUE) { + /* invalid timestamp: not sure how to handle this case */ + out->timestamp.tv_sec = 0; + out->timestamp.tv_usec = 0; + } else { + AVRational v4l2_timebase = { 1, 1000000 }; + int64_t v4l2_pts = av_rescale_q(pts, out->context->time_base, v4l2_timebase); + out->timestamp.tv_sec = v4l2_pts / INT64_C(1000000); + out->timestamp.tv_usec = v4l2_pts % INT64_C(1000000); + } +} + +static inline uint64_t get_pts(V4L2Buffer *avbuf) +{ + if (avbuf->buf.timestamp.tv_sec || avbuf->buf.timestamp.tv_usec) { + int64_t pts = (avbuf->buf.timestamp.tv_sec) * INT64_C(1000000) + avbuf->buf.timestamp.tv_usec; + AVRational v4l2_timebase = { 1, 1000000 }; + pts = av_rescale_q(pts, v4l2_timebase, avbuf->context->time_base); + return pts; + } + + return AV_NOPTS_VALUE; +} + +static void free_v4l2buf_cb(void *opaque, uint8_t *unused) +{ + V4L2Buffer* avbuf = opaque; + + if (V4L2BUF_IN_DRIVER == avbuf->status) + return; + + if (V4L2_TYPE_IS_OUTPUT(avbuf->context->type)) + avbuf->status = V4L2BUF_AVAILABLE; + else + avbuf->context->ops.enqueue(avbuf); +} + +/*** + Buffer Operations + */ +static int buffer_ops_bufref_to_v4l2buf(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].lengths)); + + out->planes[plane].bytesused = FFMIN(size, out->plane_info[plane].lengths); + out->planes[plane].length = out->plane_info[plane].lengths; + + return 0; +} + +static inline int buffer_ops_v4l2buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf) +{ + if (plane >= in->num_planes) + return AVERROR(EINVAL); + + *buf = av_buffer_create(in->plane_info[plane].mm_addr, in->plane_info[plane].lengths, free_v4l2buf_cb, in, 0); + if (!*buf) + return AVERROR(ENOMEM); + + in->status = V4L2BUF_RET_USER; + + return 0; +} + +static int buffer_ops_v4l2buf_to_avframe(AVFrame *frame, V4L2Buffer *avbuf) +{ + int i, ret; + + av_frame_unref(frame); + + for (i = 0; i < avbuf->num_planes; i++) { + ret = avbuf->ops.buf_to_bufref(avbuf, i, &frame->buf[i]); + if (ret) + return ret; + + frame->linesize[i] = avbuf->bytesperline[i]; + frame->data[i] = frame->buf[i]->data; + + if (avbuf->num_planes == 1) { + if (avbuf->context->av_pix_fmt == AV_PIX_FMT_NV12) { + frame->linesize[1] = avbuf->bytesperline[0]; + frame->data[1] = frame->buf[0]->data + avbuf->bytesperline[0] * avbuf->num_lines; + } + } + } + + frame->key_frame = !!(avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME); + frame->format = avbuf->context->av_pix_fmt; + frame->height = avbuf->context->height; + frame->width = avbuf->context->width; + frame->pts = get_pts(avbuf); + + if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) { + av_log(avbuf->context->log_ctx, AV_LOG_ERROR, "V4L2 buffer decode error\n"); + frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM; + } + + return 0; +} + +static int buffer_ops_avpkt_to_v4l2buf(const AVPacket *pkt, V4L2Buffer *out) { + int ret; + + ret = out->ops.bufref_to_buf(out, 0, pkt->data, pkt->size, pkt->buf); + if (ret) + return ret; + + set_pts(out, pkt->pts); + + if (pkt->flags & AV_PKT_FLAG_KEY) + out->flags = V4L2_BUF_FLAG_KEYFRAME; + + if (!pkt->size) + out->flags |= V4L2_BUF_FLAG_LAST; + + return 0; +} + +static int buffer_ops_avframe_to_v4l2buf(const AVFrame *frame, V4L2Buffer* out) +{ + int i, ret; + + for(i = 0; i < out->num_planes; i++) { + ret = out->ops.bufref_to_buf(out, i, frame->buf[i]->data, frame->buf[i]->size, frame->buf[i]); + if (ret) + return ret; + } + + set_pts(out, frame->pts); + + return 0; +} + +static int buffer_ops_v4l2buf_to_avpkt(AVPacket *pkt, V4L2Buffer *avbuf) +{ + int ret; + + av_packet_unref(pkt); + ret = avbuf->ops.buf_to_bufref(avbuf, 0, &pkt->buf); + if (ret) + return ret; + + pkt->size = V4L2_TYPE_IS_MULTIPLANAR(avbuf->context->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(avbuf->context->log_ctx, AV_LOG_ERROR, "V4L2 packet decode error\n"); + pkt->flags |= AV_PKT_FLAG_CORRUPT; + } + + pkt->pts = get_pts(avbuf); + + return 0; +} + +/*** + Context Operations + */ +static int context_ops_enqueue_v4l2buf(V4L2Buffer* avbuf) +{ + int ret; + + avbuf->buf.flags = avbuf->context->default_flags | avbuf->flags; + avbuf->buf.timestamp = avbuf->timestamp; + + ret = ioctl(avbuf->context->fd, VIDIOC_QBUF, &avbuf->buf); + if (ret < 0) + return AVERROR(errno); + + avbuf->status = V4L2BUF_IN_DRIVER; + avbuf->context->num_queued++; + + return 0; +} + +static V4L2Buffer* context_ops_dequeue_v4l2buf(V4L2Context *ctx, unsigned int timeout) +{ + struct v4l2_plane planes[VIDEO_MAX_PLANES]; + struct v4l2_buffer buf = { 0 }; + V4L2Buffer* avbuf = NULL; + struct pollfd pfd = { + .events = POLLIN | POLLERR, /* default capture context */ + .fd = ctx->fd, + }; + int ret; + + if (ctx->num_queued < ctx->min_queued_buffers) + return NULL; + + if (V4L2_TYPE_IS_OUTPUT(ctx->type)) + pfd.events = POLLOUT | POLLERR | POLLWRNORM; + + for (;;) { + ret = poll(&pfd, 1, timeout); + if (ret > 0) + break; + if (errno == EINTR) + continue; + return NULL; + } + + 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->fd, VIDIOC_DQBUF, &buf); + if (ret) { + if (errno != EAGAIN) { + ctx->broken = errno; + av_log(ctx->log_ctx, AV_LOG_DEBUG, "%s: VIDIOC_DQBUF, errno (%d)\n", ctx->name, errno); + } + return NULL; + } + + avbuf = &ctx->buffers[buf.index]; + avbuf->status = V4L2BUF_AVAILABLE; + avbuf->context->num_queued--; + 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* context_ops_getfree_v4l2buf(V4L2Context *ctx) +{ + unsigned int timeout = 0; + int i; + + if (V4L2_TYPE_IS_OUTPUT(ctx->type)) { + do { + } while (ctx->ops.dequeue(ctx, timeout)); + } + + for (i = 0; i < ctx->num_buffers; i++) { + if (ctx->buffers[i].status == V4L2BUF_AVAILABLE) + return &ctx->buffers[i]; + } + + return NULL; +} + +static void context_ops_release_v4l2_buffers(V4L2Context* ctx) +{ + 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->lengths) + munmap(p->mm_addr, p->lengths); + } + } +} + +static int context_ops_initialize_v4l2buf(V4L2Context *ctx, V4L2Buffer* avbuf, int index) +{ + int ret, i; + + /* keep a reference to the context */ + avbuf->context = ctx; + + /* initalize the buffer operations */ + avbuf->ops.buf_to_frm = buffer_ops_v4l2buf_to_avframe; + avbuf->ops.frm_to_buf = buffer_ops_avframe_to_v4l2buf; + avbuf->ops.buf_to_pkt = buffer_ops_v4l2buf_to_avpkt; + avbuf->ops.pkt_to_buf = buffer_ops_avpkt_to_v4l2buf; + + avbuf->ops.bufref_to_buf = buffer_ops_bufref_to_v4l2buf; + avbuf->ops.buf_to_bufref = buffer_ops_v4l2buf_to_bufref; + + 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(ctx->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 is 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; + + avbuf->num_lines = ctx->format.fmt.pix_mp.height; + + for (i = 0; i < avbuf->num_planes; i++) { + + avbuf->bytesperline[i] = 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].lengths = 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, + ctx->fd, avbuf->buf.m.planes[i].m.mem_offset); + } else { + avbuf->plane_info[i].lengths = avbuf->buf.length; + avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.length, + PROT_READ | PROT_WRITE, MAP_SHARED, + ctx->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[index].bytesused; + avbuf->buf.length = avbuf->planes[index].length; + } + + return ctx->ops.enqueue(avbuf); +} + +int avpriv_v4l2_enqueue_frame(V4L2Context* ctx, const AVFrame* frame) +{ + V4L2Buffer* avbuf; + int ret; + + avbuf = ctx->ops.get_buffer(ctx); + if (!avbuf) + return AVERROR(ENOMEM); + + ret = avbuf->ops.frm_to_buf(frame, avbuf); + if (ret) + return ret; + + ret = ctx->ops.enqueue(avbuf); + if (ret) + return ret; + + return 0; +} + +int avpriv_v4l2_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt) +{ + V4L2Buffer* avbuf; + int ret; + + avbuf = ctx->ops.get_buffer(ctx); + if (!avbuf) + return AVERROR(ENOMEM); + + ret = avbuf->ops.pkt_to_buf(pkt, avbuf); + if (ret) + return ret; + + ret = ctx->ops.enqueue(avbuf); + if (ret) + return ret; + + return 0; +} + +int avpriv_v4l2_dequeue_frame(V4L2Context* ctx, AVFrame* frame, unsigned int timeout) +{ + + V4L2Buffer* avbuf = NULL; + + avbuf = ctx->ops.dequeue(ctx, timeout); + if (!avbuf) { + if (ctx->broken) + return AVERROR_EOF; + + return AVERROR(EAGAIN); + } + + return avbuf->ops.buf_to_frm(frame, avbuf); +} + +int avpriv_v4l2_dequeue_packet(V4L2Context* ctx, AVPacket* pkt, unsigned int timeout) +{ + V4L2Buffer* avbuf = NULL; + + avbuf = ctx->ops.dequeue(ctx, timeout); + if (!avbuf) { + if (ctx->broken) + return AVERROR_EOF; + + return AVERROR(EAGAIN); + } + + return avbuf->ops.buf_to_pkt(pkt, avbuf); +} + +int avpriv_v4l2_context_set_status(V4L2Context* ctx, int cmd) +{ + int type = ctx->type; + int ret; + + ret = ioctl(ctx->fd, cmd, &type); + if (ret < 0) + return AVERROR(errno); + + ctx->streamon = (cmd == VIDIOC_STREAMON); + + return 0; +} + +void avpriv_v4l2_context_release(V4L2Context* ctx) +{ + if (!ctx->buffers) + return; + + ctx->ops.release_buffers(ctx); + av_free(ctx->buffers); +} + +int avpriv_v4l2_context_init(V4L2Context* ctx, int lazy_init) +{ + struct v4l2_requestbuffers req; + int ret, i; + + if (!BUFFER_TYPE_SUPPORTED(ctx)) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "type %i not supported\n", ctx->type); + return AVERROR_PATCHWELCOME; + } + + ctx->ops.release_buffers = context_ops_release_v4l2_buffers; + ctx->ops.init_buffer = context_ops_initialize_v4l2buf; + ctx->ops.get_buffer = context_ops_getfree_v4l2buf; + ctx->ops.dequeue = context_ops_dequeue_v4l2buf; + ctx->ops.enqueue = context_ops_enqueue_v4l2buf; + + if (lazy_init) + return 0; + + memset(&req, 0, sizeof(req)); + req.count = ctx->num_buffers + ctx->min_queued_buffers; + req.memory = V4L2_MEMORY_MMAP; + req.type = ctx->type; + ret = ioctl(ctx->fd, VIDIOC_REQBUFS, &req); + if (ret< 0) + return AVERROR(errno); + + ctx->num_buffers = req.count; + ctx->num_queued = 0; + ctx->buffers = av_mallocz(ctx->num_buffers * sizeof(V4L2Buffer)); + if (!ctx->buffers) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "%s buffer initialization ENOMEM\n", ctx->name); + return AVERROR(ENOMEM); + } + + for (i = 0; i < req.count; i++) { + ret = ctx->ops.init_buffer(ctx, &ctx->buffers[i], i); + if (ret < 0) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "%s buffer initialization (%s)\n", ctx->name, av_err2str(ret)); + av_free(ctx->buffers); + return ret; + } + } + + return 0; +} + + diff --git a/libavcodec/v4l2_buffers.h b/libavcodec/v4l2_buffers.h new file mode 100644 index 0000000..22918dd --- /dev/null +++ b/libavcodec/v4l2_buffers.h @@ -0,0 +1,249 @@ +/* + * V4L2 buffer{,context} helper functions. + * + * Copyright (C) 2017 Alexis Ballier + * Copyright (C) 2017 Jorge Ramirez + * + * 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 + +#include "v4l2_fmt.h" +#include "avcodec.h" +#include "libavutil/pixfmt.h" +#include "libavutil/frame.h" +#include "libavutil/buffer.h" + +struct V4L2Buffer; +typedef struct V4L2Buffer V4L2Buffer; + +struct V4L2Context; +typedef struct V4L2Context V4L2Context;; + +/** + * V4L2Context_operations: + */ +typedef V4L2Buffer* (*v4l2_dequeue_buffer_f)(V4L2Context *ctx, unsigned int timeout); +typedef int (*v4l2_enqueue_buffer_f)(V4L2Buffer *buf); +typedef V4L2Buffer* (*v4l2_getfree_buffer_f)(V4L2Context *ctx); +typedef int (*v4l2_initialize_buffer_f)(V4L2Context *ctx, V4L2Buffer* avbuf, int index); +typedef void (*v4l2_release_buffers_f)(V4L2Context *ctx); + +typedef struct V4L2Context_ops { + /* unmap all buffers */ + v4l2_release_buffers_f release_buffers; + /* single buffer operations */ + v4l2_initialize_buffer_f init_buffer; + v4l2_getfree_buffer_f get_buffer; + v4l2_dequeue_buffer_f dequeue; + v4l2_enqueue_buffer_f enqueue; +} V4L2Context_ops; + +typedef struct V4L2Context { + /** + * Buffer context operations + * queue a V4L2Buffer into the context + * dequeue a V4L2Buffer into the context + * get a free V4L2Buffer from the context + * release all V4L2Buffers allocated to the context + */ + V4L2Context_ops ops; + + /** + * Log context (for av_log()). Can be NULL. + */ + void *log_ctx; + + /** + * Lazy Initialization: set to one if the context can not initialize its + * buffers until it first queries the driver for formats and sizes. + */ + int lazy_init; + + /** + * context name: must be set before calling avpriv_v4l2_context_init(). + */ + const char* name; + + /** + * File descriptor obtained from opening the associated device. + * Must be set before calling avpriv_v4l2_context_init(). + * Readonly after init. + */ + int fd; + + /** + * Type of this buffer context. + * See V4L2_BUF_TYPE_VIDEO_* in videodev2.h + * Must be set before calling avpriv_v4l2_context_init(). + * 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. + * Must be set before calling avpriv_v4l2_context_init(). + * avpriv_v4l2m2m_format() can set it. + * 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). + * + * For output context, this must must be set before calling avpriv_v4l2_context_init(). + * For capture context during decoding, it will be set after having received the + * information from the driver. at which point we can initialize the buffers. + */ + int width, height; + + /** + * Default flags to set on buffers to enqueue. + * See V4L2_BUF_FLAG_*. + */ + int default_flags; + + /** + * Time base + */ + AVRational time_base; + + /** + * Whether the stream has been started (VIDIOC_STREAMON has been sent). + */ + int streamon; + + /** + * Number of queued buffers. + */ + int num_queued; + + /** + * Minimum number of buffers that must be kept queued in this queue. + * + * E.g. for decoders, the drivers might have such requirements to produce proper output. + */ + int min_queued_buffers; + + /** + * The actual number of buffers. + * + * Before calling avpriv_v4l2_context_init() this is the number of buffers we would like to have available. + * avpriv_v4l2_context_init() asks for (min_buffers + num_buffers) and sets this value to the actual number + * of buffers the driver gave us. + * Readonly after init. + */ + int num_buffers; + + /** + * Indexed array of V4L2Buffers + */ + V4L2Buffer *buffers; + + /** + * Unrecoverable error notified by the V4L2 kernel driver + */ + int broken; + +} 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 avpriv_v4l2_context_init(V4L2Context* ctx, int lazy_init); + +/** + * 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 avpriv_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 avpriv_v4l2_context_set_status(V4L2Context* ctx, int cmd); + +/** + * Dequeues a buffer from a V4L2Context to an AVPacket. + * + * Exactly one of f or pkt must be non NULL. + * @param[in] ctx The V4L2Context to dequeue from. + * @param[inout] pkt The AVPacket to dequeue to. + * @param[ino] timeout The number of milliseconds to wait for the dequeue. + * @return 0 in case of success, AVERROR(EAGAIN) if no buffer was ready, another negative error in case of error. + */ +int avpriv_v4l2_dequeue_packet(V4L2Context* ctx, AVPacket* pkt, unsigned int timeout); + +/** + * Dequeues a buffer from a V4L2Context to an AVFrame. + * + * Exactly one of f or pkt must be non NULL. + * @param[in] ctx The V4L2Context to dequeue from. + * @param[inout] f The AVFrame to dequeue to. + * @param[ino] timeout The number of milliseconds to wait for the dequeue. + * @return 0 in case of success, AVERROR(EAGAIN) if no buffer was ready, another negative error in case of error. + */ +int avpriv_v4l2_dequeue_frame(V4L2Context* ctx, AVFrame* f, unsigned int timeout); + +/** + * Enqueues a buffer to a V4L2Context from either an AVPacket + * Exactly one of f or pkt must be non NULL. + * + * @param[in] ctx The V4L2Context to enqueue to. + * @param[in] pkt A pointer to an AVPacket to enqueue. + * @return 0 in case of success, a negative error otherwise. + */ +int avpriv_v4l2_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt); + +/** + * Enqueues a buffer to a V4L2Context from an AVFrame + * Exactly one of f or pkt 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 avpriv_v4l2_enqueue_frame(V4L2Context* ctx, const AVFrame* f); + +#endif // AVCODEC_V4L2_BUFFERS_H diff --git a/libavcodec/v4l2_fmt.c b/libavcodec/v4l2_fmt.c index 3338984..5cd7808 100644 --- a/libavcodec/v4l2_fmt.c +++ b/libavcodec/v4l2_fmt.c @@ -19,9 +19,8 @@ #include "v4l2_fmt.h" const struct v4l_fmt_map avpriv_v4l_fmt_conversion_table[] = { - /* ff_fmt codec_id v4l2_fmt pack_flags */ - { AV_PIX_FMT_YUV420P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV420 , FF_V4L_PACK_AVPACKET }, - { AV_PIX_FMT_YUV420P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YVU420 , FF_V4L_PACK_AVPACKET }, + /* ff_fmt codec_id v4l2_fmt pack_flags */ + { AV_PIX_FMT_YUV420P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV420 , FF_V4L_PACK_AVPACKET | FF_V4L_PACK_AVFRAME }, { AV_PIX_FMT_YUV422P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV422P , FF_V4L_PACK_AVPACKET }, { AV_PIX_FMT_YUYV422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUYV , FF_V4L_PACK_AVPACKET | FF_V4L_PACK_AVFRAME }, { AV_PIX_FMT_UYVY422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_UYVY , FF_V4L_PACK_AVPACKET | FF_V4L_PACK_AVFRAME }, @@ -74,7 +73,7 @@ const struct v4l_fmt_map avpriv_v4l_fmt_conversion_table[] = { { AV_PIX_FMT_NONE, AV_CODEC_ID_DVVIDEO, V4L2_PIX_FMT_DV , FF_V4L_PACK_AVPACKET }, #endif #ifdef V4L2_PIX_FMT_H263 - { AV_PIX_FMT_NONE, AV_CODEC_ID_H263, V4L2_PIX_FMT_H263 , FF_V4L_PACK_AVPACKET }, + { AV_PIX_FMT_NONE, AV_CODEC_ID_H263, V4L2_PIX_FMT_H263 , FF_V4L_PACK_AVPACKET | FF_V4L_PACK_AVFRAME }, #endif #ifdef V4L2_PIX_FMT_MPEG1 { AV_PIX_FMT_NONE, AV_CODEC_ID_MPEG1VIDEO, V4L2_PIX_FMT_MPEG1 , FF_V4L_PACK_AVPACKET }, @@ -89,12 +88,12 @@ const struct v4l_fmt_map avpriv_v4l_fmt_conversion_table[] = { { AV_PIX_FMT_NONE, AV_CODEC_ID_VP8, V4L2_PIX_FMT_VP8 , FF_V4L_PACK_AVPACKET }, #endif #ifdef V4L2_PIX_FMT_HEVC - { AV_PIX_FMT_NONE, AV_CODEC_ID_HEVC, V4L2_PIX_FMT_HEVC , FF_V4L_PACK_AVPACKET}, + { AV_PIX_FMT_NONE, AV_CODEC_ID_HEVC, V4L2_PIX_FMT_HEVC , FF_V4L_PACK_AVPACKET }, #endif #ifdef V4L2_PIX_FMT_VP9 { AV_PIX_FMT_NONE, AV_CODEC_ID_VP9, V4L2_PIX_FMT_VP9 , FF_V4L_PACK_AVPACKET }, #endif - { AV_PIX_FMT_NONE, AV_CODEC_ID_NONE, 0, , 0 }, + { AV_PIX_FMT_NONE, AV_CODEC_ID_NONE, 0 , 0 }, }; uint32_t avpriv_v4l_fmt_ff2v4l(enum AVPixelFormat pix_fmt, enum AVCodecID codec_id, int pack_flags) diff --git a/libavcodec/v4l2_m2m.c b/libavcodec/v4l2_m2m.c new file mode 100644 index 0000000..3afffbf --- /dev/null +++ b/libavcodec/v4l2_m2m.c @@ -0,0 +1,381 @@ +/* + * V4L mem2mem wrapper + * + * Copyright (C) 2017 Alexis Ballier + * Copyright (C) 2017 Jorge Ramirez + * + * 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 +#include +#include +#include +#include +#include "libavutil/imgutils.h" +#include "libavutil/pixfmt.h" +#include "libavutil/pixdesc.h" +#include "avcodec.h" +#include "v4l2_m2m_avcodec.h" +#include "v4l2_buffers.h" +#include "v4l2_fmt.h" +#include "v4l2_m2m.h" + +static inline int try_raw_format(V4L2Context* ctx, enum AVPixelFormat pixfmt) +{ + struct v4l2_format *fmt = &ctx->format; + uint32_t v4l2_fmt; + int ret; + + v4l2_fmt = avpriv_v4l_fmt_ff2v4l(pixfmt, ctx->av_codec_id, FF_V4L_PACK_AVFRAME); + 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->fd, VIDIOC_TRY_FMT, fmt); + if (ret) + return AVERROR(EINVAL); + + return 0; +} + +static int query_raw_format(V4L2Context* ctx, int set) +{ + 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 = try_raw_format(ctx, pixfmt); + if (ret) + pixfmt = AV_PIX_FMT_NONE; + else + return 0; + } + + for (;;) { + ret = ioctl(ctx->fd, VIDIOC_ENUM_FMT, &fdesc); + if (ret) + return AVERROR(EINVAL); + + pixfmt = avpriv_v4l_fmt_v4l2ff(fdesc.pixelformat, AV_CODEC_ID_RAWVIDEO); + ret = try_raw_format(ctx, pixfmt); + if (ret){ + fdesc.index++; + continue; + } + + if (set) + ctx->av_pix_fmt = pixfmt; + + return 0; + } + + return AVERROR(EINVAL); +} + +static int query_coded_format(V4L2Context* ctx, uint32_t *p) +{ + struct v4l2_fmtdesc fdesc; + uint32_t v4l2_fmt; + int ret; + + v4l2_fmt = avpriv_v4l_fmt_ff2v4l(ctx->av_pix_fmt, ctx->av_codec_id, FF_V4L_PACK_AVPACKET); + if (!v4l2_fmt) + return AVERROR(EINVAL); + + memset(&fdesc, 0, sizeof(fdesc)); + fdesc.type = ctx->type; + + for (;;) { + ret = ioctl(ctx->fd, VIDIOC_ENUM_FMT, &fdesc); + if (ret) + return AVERROR(EINVAL); + + if (fdesc.pixelformat == v4l2_fmt) { + break; + } + + fdesc.index++; + } + + *p = v4l2_fmt; + + return 0; +} + +static inline int splane_video(struct v4l2_capability *cap) +{ + if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT) & V4L2_CAP_STREAMING) + return 1; + + if (cap->capabilities & V4L2_CAP_VIDEO_M2M) + return 1; + + return 0; +} + +static inline int mplane_video(struct v4l2_capability *cap) +{ + if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_OUTPUT_MPLANE) & V4L2_CAP_STREAMING) + return 1; + + if (cap->capabilities & V4L2_CAP_VIDEO_M2M_MPLANE) + return 1; + + return 0; +} + +static int prepare_contexts(V4L2m2mContext* s, void *log_ctx) +{ + int ret; + + s->capture.log_ctx = s->output.log_ctx = log_ctx; + s->capture.broken = s->output.broken = 0; + s->capture.fd = s->output.fd = s->fd; + s->capture.name = "capture context"; + s->output.name = "output context"; + + memset(&s->cap, 0, sizeof(s->cap)); + ret = ioctl(s->fd, VIDIOC_QUERYCAP, &s->cap); + if (ret < 0) + return ret; + + if (mplane_video(&s->cap)) { + s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; + s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; + return 0; + } + + if (splane_video(&s->cap)) { + s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; + return 0; + } + + return AVERROR(EINVAL); +} + +static int probe_v4l2_driver(V4L2m2mContext* s, void *log_ctx) +{ + int ret; + + s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0); + if (s->fd < 0) + return AVERROR(errno); + + ret = prepare_contexts(s, log_ctx); + if (ret < 0) + goto done; + + ret = avpriv_v4l2m2m_format(&s->output, 0); + if (ret) { + av_log(log_ctx, AV_LOG_DEBUG, "can't set input format\n"); + goto done; + } + + ret = avpriv_v4l2m2m_format(&s->capture, 0); + if (ret) { + av_log(log_ctx, AV_LOG_DEBUG, "can't to set output format\n"); + goto done; + } + +done: + + close(s->fd); + s->fd = 0; + + return ret; +} + +static int configure_contexts(V4L2m2mContext* s, void *log_ctx) +{ + int ret; + + s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0); + if (s->fd < 0) + return AVERROR(errno); + + ret = prepare_contexts(s, log_ctx); + if (ret < 0) + goto error; + + ret = avpriv_v4l2m2m_format(&s->output, 1); + if (ret) { + av_log(log_ctx, AV_LOG_ERROR, "can't set input format\n"); + goto error; + } + + ret = avpriv_v4l2m2m_format(&s->capture, 1); + if (ret) { + av_log(log_ctx, AV_LOG_ERROR, "can't to set output format\n"); + goto error; + } + + ret = avpriv_v4l2_context_init(&s->output, s->output.lazy_init); + if (ret) { + av_log(log_ctx, AV_LOG_ERROR, "no output context's buffers\n"); + goto error; + } + + ret = avpriv_v4l2_context_init(&s->capture, s->capture.lazy_init); + if (ret) { + av_log(log_ctx, AV_LOG_ERROR, "no capture context's buffers\n"); + goto error; + } + + av_log(log_ctx, AV_LOG_INFO, "using driver '%s' on card '%s'\n", s->cap.driver, s->cap.card); + +error: + + if (ret) { + close(s->fd); + s->fd = 0; + } + + return 0; +} + +static void save_to_context(V4L2Context* ctx, uint32_t v4l2_fmt) +{ + ctx->format.type = ctx->type; + + if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) { + ctx->format.fmt.pix_mp.height = ctx->height; + ctx->format.fmt.pix_mp.width = ctx->width; + if (v4l2_fmt) + ctx->format.fmt.pix_mp.pixelformat = v4l2_fmt; + } else { + ctx->format.fmt.pix.height = ctx->height; + ctx->format.fmt.pix.width = ctx->width; + if (v4l2_fmt) + ctx->format.fmt.pix_mp.pixelformat = v4l2_fmt; + } +} + +int avpriv_v4l2m2m_format(V4L2Context* ctx, int set) +{ + uint32_t v4l2_fmt; + int ret; + + switch (ctx->av_codec_id) { + case AV_CODEC_ID_RAWVIDEO: + ret = query_raw_format(ctx, set); + if (ret) + return ret; + + save_to_context(ctx, 0); + + if (set) + return ioctl(ctx->fd, VIDIOC_S_FMT, &ctx->format); + + return ret; + default: + ret = query_coded_format(ctx, &v4l2_fmt); + if (ret) + return ret; + + save_to_context(ctx, v4l2_fmt); + + if (set) + return ioctl(ctx->fd, VIDIOC_S_FMT, &ctx->format); + + return ioctl(ctx->fd, VIDIOC_TRY_FMT, &ctx->format); + }; +} + +int avpriv_v4l2m2m_end(V4L2m2mContext* s) +{ + avpriv_v4l2_context_release(&s->output); + avpriv_v4l2_context_release(&s->capture); + + avpriv_v4l2_context_set_status(&s->output, VIDIOC_STREAMOFF); + avpriv_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF); + + close(s->fd); + + return 0; +} + +int avpriv_v4l2m2m_init(V4L2m2mContext* s, void* log_ctx) +{ + char *devname_save = s->devname; + int ret = AVERROR(EINVAL); + char node[PATH_MAX]; + struct dirent *entry; + DIR *dirp; + + if (s->devname && *s->devname) + return configure_contexts(s, log_ctx); + + 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(log_ctx, AV_LOG_DEBUG, "probing device %s\n", node); + + s->devname = node; + ret = probe_v4l2_driver(s, log_ctx); + if (!ret) + break; + } + + closedir(dirp); + + if (!ret) { + av_log(log_ctx, AV_LOG_INFO, "Using device %s\n", node); + ret = configure_contexts(s, log_ctx); + } else { + av_log(log_ctx, AV_LOG_ERROR, "Could not find a valid device\n"); + } + s->devname = devname_save; + + return ret; +} + +int ff_v4l2m2m_codec_end(AVCodecContext *avctx) +{ + V4L2m2mContext *s = avctx->priv_data; + + av_log(avctx, AV_LOG_DEBUG, "Closing context\n"); + + return avpriv_v4l2m2m_end(s); +} + +int ff_v4l2m2m_codec_init(AVCodecContext *avctx) +{ + V4L2m2mContext *s = avctx->priv_data; + + return avpriv_v4l2m2m_init(s, avctx); +} + diff --git a/libavcodec/v4l2_m2m.h b/libavcodec/v4l2_m2m.h new file mode 100644 index 0000000..99d93df --- /dev/null +++ b/libavcodec/v4l2_m2m.h @@ -0,0 +1,52 @@ +/* + * V4L2 mem2mem helper functions + * + * Copyright (C) 2017 Alexis Ballier + * Copyright (C) 2017 Jorge Ramirez + * + * 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 "v4l2_buffers.h" +#include "v4l2_fmt.h" + +#define V4L_M2M_DEFAULT_OPTS \ + { "device",\ + "Path to the device to use",\ + OFFSET(devname), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, FLAGS },\ + { "num_output_buffers",\ + "Number of buffers in the output context",\ + OFFSET(output.num_buffers), AV_OPT_TYPE_INT, { .i64 = 16 }, 4, INT_MAX, FLAGS } + +typedef struct V4L2m2mContext +{ + AVClass *class; + int fd; + char *devname; + struct v4l2_capability cap; + V4L2Context capture; + V4L2Context output; +} V4L2m2mContext; + +int avpriv_v4l2m2m_init(V4L2m2mContext* ctx, void* log_ctx); +int avpriv_v4l2m2m_format(V4L2Context* ctx, int set); +int avpriv_v4l2m2m_end(V4L2m2mContext* ctx); + +#endif /* AVCODEC_V4L2_M2M_H */ diff --git a/libavcodec/v4l2_m2m_avcodec.h b/libavcodec/v4l2_m2m_avcodec.h new file mode 100644 index 0000000..3e17ae9 --- /dev/null +++ b/libavcodec/v4l2_m2m_avcodec.h @@ -0,0 +1,32 @@ +/* + * V4L2 mem2mem avcodec helper functions + * + * Copyright (C) 2017 Alexis Ballier + * Copyright (C) 2017 Jorge Ramirez + * + * 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_AVCODEC_H +#define AVCODEC_V4L2_M2M_AVCODEC_H + +#include "avcodec.h" + +int ff_v4l2m2m_codec_init(AVCodecContext *avctx); +int ff_v4l2m2m_codec_end(AVCodecContext *avctx); + +#endif diff --git a/libavcodec/v4l2_m2m_dec.c b/libavcodec/v4l2_m2m_dec.c new file mode 100644 index 0000000..a246139 --- /dev/null +++ b/libavcodec/v4l2_m2m_dec.c @@ -0,0 +1,239 @@ +/* + * V4L2 mem2mem decoders + * + * Copyright (C) 2017 Alexis Ballier + * Copyright (C) 2017 Jorge Ramirez + * + * 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 +#include "libavutil/pixfmt.h" +#include "libavutil/pixdesc.h" +#include "libavutil/opt.h" +#include "v4l2_m2m_avcodec.h" +#include "v4l2_fmt.h" +#include "v4l2_buffers.h" +#include "v4l2_m2m.h" +#include "decode.h" +#include "avcodec.h" + +static int try_start(AVCodecContext *avctx) +{ + V4L2m2mContext *s = avctx->priv_data; + V4L2Context *const capture = &s->capture; + V4L2Context *const output = &s->output; + struct v4l2_selection selection; + struct v4l2_control ctrl; + int ret; + + if (output->streamon && capture->streamon) + return 0; + + /* 1. start the output process */ + if (!output->streamon) { + ret = avpriv_v4l2_context_set_status(output, VIDIOC_STREAMON); + if (ret < 0) { + av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON on output context\n"); + return ret; + } + } + + /* 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_ERROR, "VIDIOC_G_FMT ioctl\n"); + return ret; + } + + /* 2.1 update the AVCodecContext */ + avctx->pix_fmt = avpriv_v4l_fmt_v4l2ff(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_ERROR, "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. get the minimum number of buffers required by capture (or default)*/ + memset(&ctrl, 0, sizeof(ctrl)); + ctrl.id = V4L2_CID_MIN_BUFFERS_FOR_CAPTURE; + ret = ioctl(s->fd, VIDIOC_G_CTRL, &ctrl); + if (!ret) + capture->min_queued_buffers = ctrl.value; + + /* 5. init the capture context now that we have the capture format */ + if (!capture->buffers) { + ret = avpriv_v4l2_context_init(capture, 0); + if (ret) { + av_log(avctx, AV_LOG_DEBUG, "can't request output buffers\n"); + return ret; + } + } + + /* 6. start the capture process */ + ret = avpriv_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 av_cold int v4l2m2m_decode_init(AVCodecContext *avctx) +{ + V4L2m2mContext *s = avctx->priv_data; + V4L2Context *capture = &s->capture; + V4L2Context *output = &s->output; + + output->default_flags = capture->default_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + output->time_base = capture->time_base = avctx->framerate; + 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; + output->min_queued_buffers = 6; + + /* + * increase the number of buffers to support h.264/h.265 + * default (configurable via option) is 16 + */ + switch (avctx->codec_id) { + case AV_CODEC_ID_H264: + case AV_CODEC_ID_HEVC: + output->num_buffers += 4; + break; + } + + /* + * the buffers associated to this context cant be initialized without + * additional information available in the kernel driver, so do let's postpone it + */ + capture->lazy_init = 1; + + capture->av_codec_id = AV_CODEC_ID_RAWVIDEO; + capture->av_pix_fmt = avctx->pix_fmt; + capture->min_queued_buffers = 6; + + return ff_v4l2m2m_codec_init(avctx); +} + +static int v4l2m2m_receive_frame(AVCodecContext *avctx, AVFrame *frame) +{ + V4L2m2mContext *s = avctx->priv_data; + V4L2Context *const capture = &s->capture; + V4L2Context *const output = &s->output; + unsigned int timeout = 50; + AVPacket avpkt = {0}; + int ret; + + ret = ff_decode_get_packet(avctx, &avpkt); + if (ret < 0 && ret != AVERROR_EOF) + return ret; + + ret = avpriv_v4l2_enqueue_packet(output, &avpkt); + if (ret < 0) + return ret; + + ret = try_start(avctx); + if (ret) + return 0; + + return avpriv_v4l2_dequeue_frame(capture, frame, timeout); +} + +#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_extra_buffers","Number of extra buffers in the capture context", + OFFSET(capture.num_buffers), AV_OPT_TYPE_INT,{.i64 = 6}, 6, 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 = v4l2m2m_decode_init,\ + .receive_frame = v4l2m2m_receive_frame,\ + .close = ff_v4l2m2m_codec_end,\ + .capabilities = CODEC_CAP_DELAY,\ + .bsfs = bsf_name, \ +}; + +#if CONFIG_H263_V4L2M2M_DECODER + M2MDEC(h263, "H.263", AV_CODEC_ID_H263, NULL); +#endif + +#if CONFIG_H264_V4L2M2M_DECODER + M2MDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb"); +#endif + +#if CONFIG_MPEG1_V4L2M2M_DECODER + M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL); +#endif + +#if CONFIG_MPEG2_V4L2M2M_DECODER + M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL); +#endif + +#if CONFIG_MPEG4_V4L2M2M_DECODER + M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4, NULL); +#endif + +#if CONFIG_VC1_V4L2M2M_DECODER + M2MDEC(vc1 , "VC1", AV_CODEC_ID_VC1, NULL); +#endif + +#if CONFIG_VP8_V4L2M2M_DECODER + M2MDEC(vp8, "VP8", AV_CODEC_ID_VP8, NULL); +#endif + +#if CONFIG_VP9_V4L2M2M_DECODER + M2MDEC(vp9, "VP9", AV_CODEC_ID_VP9, NULL); +#endif + +#if CONFIG_HEVC_V4L2M2M_DECODER + M2MDEC(hevc, "HEVC", AV_CODEC_ID_HEVC, "h264_mp4toannexb"); +#endif diff --git a/libavcodec/v4l2_m2m_enc.c b/libavcodec/v4l2_m2m_enc.c new file mode 100644 index 0000000..1f6fe69 --- /dev/null +++ b/libavcodec/v4l2_m2m_enc.c @@ -0,0 +1,290 @@ +/* + * V4L2 mem2mem encoders + * + * Copyright (C) 2017 Alexis Ballier + * Copyright (C) 2017 Jorge Ramirez + * + * 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 + +#include "libavutil/pixfmt.h" +#include "libavutil/pixdesc.h" +#include "libavutil/opt.h" +#include "v4l2_m2m_avcodec.h" +#include "v4l2_buffers.h" +#include "v4l2_fmt.h" +#include "v4l2_m2m.h" +#include "avcodec.h" + +#define STR(s) AV_TOSTRING(s) +#define MPEG_CID(x) V4L2_CID_MPEG_VIDEO_##x +#define MPEG_VIDEO(x) V4L2_MPEG_VIDEO_##x + +#define SET_V4L2_EXT_CTRL(TYPE, ID, VALUE, NAME) \ +{ \ + struct v4l2_ext_control ctrl = { 0 }; \ + struct v4l2_ext_controls ctrls = { 0 }; \ + ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG; \ + ctrls.controls = &ctrl; \ + ctrl.TYPE = VALUE ; \ + ctrl.id = ID ; \ + ctrls.count = 1; \ + \ + if ((ret = ioctl(s->fd, VIDIOC_S_EXT_CTRLS, &ctrls)) < 0) \ + av_log(avctx, AV_LOG_WARNING, "Failed to set " NAME "%s\n", STR(ID)); \ +} + +#define SET_V4L2_TIME_PER_FRAME(NUM, DEN) \ +{ \ + struct v4l2_streamparm parm = { 0 }; \ + parm.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; \ + parm.parm.output.timeperframe.numerator = NUM; \ + parm.parm.output.timeperframe.denominator = DEN; \ + \ + if ((ret = ioctl(s->fd, VIDIOC_S_PARM, &parm)) < 0) \ + av_log(avctx, AV_LOG_WARNING, "Failed to set timeperframe"); \ +} + +static inline int v4l2_h264_profile_from_ff(int p) +{ + switch(p) { + case FF_PROFILE_H264_CONSTRAINED_BASELINE: + return MPEG_VIDEO(H264_PROFILE_CONSTRAINED_BASELINE); + case FF_PROFILE_H264_HIGH_444_PREDICTIVE: + return MPEG_VIDEO(H264_PROFILE_HIGH_444_PREDICTIVE); + case FF_PROFILE_H264_HIGH_422_INTRA: + return MPEG_VIDEO(H264_PROFILE_HIGH_422_INTRA); + case FF_PROFILE_H264_HIGH_444_INTRA: + return MPEG_VIDEO(H264_PROFILE_HIGH_444_INTRA); + case FF_PROFILE_H264_HIGH_10_INTRA: + return MPEG_VIDEO(H264_PROFILE_HIGH_10_INTRA); + case FF_PROFILE_H264_HIGH_422: + return MPEG_VIDEO(H264_PROFILE_HIGH_422); + case FF_PROFILE_H264_BASELINE: + return MPEG_VIDEO(H264_PROFILE_BASELINE); + case FF_PROFILE_H264_EXTENDED: + return MPEG_VIDEO(H264_PROFILE_EXTENDED); + case FF_PROFILE_H264_HIGH_10: + return MPEG_VIDEO(H264_PROFILE_HIGH_10); + case FF_PROFILE_H264_MAIN: + return MPEG_VIDEO(H264_PROFILE_MAIN); + case FF_PROFILE_H264_HIGH: + return MPEG_VIDEO(H264_PROFILE_HIGH); + } + + return -1; +} + +static inline int v4l2_mpeg4_profile_from_ff(int p) +{ + switch(p) { + case FF_PROFILE_MPEG4_ADVANCED_CODING: + return MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY); + case FF_PROFILE_MPEG4_ADVANCED_SIMPLE: + return MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_SIMPLE); + case FF_PROFILE_MPEG4_SIMPLE_SCALABLE: + return MPEG_VIDEO(MPEG4_PROFILE_SIMPLE_SCALABLE); + case FF_PROFILE_MPEG4_SIMPLE: + return MPEG_VIDEO(MPEG4_PROFILE_SIMPLE); + case FF_PROFILE_MPEG4_CORE: + return MPEG_VIDEO(MPEG4_PROFILE_CORE); + } + + return -1; +} + +static av_cold int v4l2m2m_encode_init(AVCodecContext *avctx) +{ + V4L2m2mContext *s = avctx->priv_data; + V4L2Context *capture = &s->capture; + V4L2Context *output = &s->output; + int qmin_cid, qmax_cid, ret, val; + int qmin, qmax; + + output->default_flags = capture->default_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; + output->time_base = capture->time_base = avctx->time_base; + 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; + capture->min_queued_buffers = 1; + + if (ret = ff_v4l2m2m_codec_init(avctx)) + return ret; + + SET_V4L2_TIME_PER_FRAME(avctx->framerate.num, avctx->framerate.den); + SET_V4L2_EXT_CTRL(value, MPEG_CID(HEADER_MODE), MPEG_VIDEO(HEADER_MODE_SEPARATE), "header mode"); + SET_V4L2_EXT_CTRL(value, MPEG_CID(B_FRAMES), avctx->max_b_frames, "number of B-frames"); + SET_V4L2_EXT_CTRL(value, MPEG_CID(GOP_SIZE), avctx->gop_size,"gop size"); + SET_V4L2_EXT_CTRL(value, MPEG_CID(BITRATE) , avctx->bit_rate, "bit rate"); + + av_log(avctx, AV_LOG_DEBUG, "Encoder Context: frame rate(%d/%d), number b-frames (%d)," + "gop size (%d), bit rate (%ld), qmin (%d), qmax (%d)\n", + 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) { + SET_V4L2_EXT_CTRL(value, 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) { + SET_V4L2_EXT_CTRL(value, 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) { + SET_V4L2_EXT_CTRL(value, MPEG_CID(MPEG4_QPEL), 1, "qpel"); + } + qmax = 51; + qmin = 0; + 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); + + SET_V4L2_EXT_CTRL(value, qmin_cid, qmin, "minimum video quantizer scale"); + SET_V4L2_EXT_CTRL(value, qmax_cid, qmax, "maximum video quantizer scale"); + + return 0; +} + +static int v4l2m2m_send_frame(AVCodecContext *avctx, const AVFrame *frame) +{ + V4L2m2mContext *s = avctx->priv_data; + V4L2Context *const output = &s->output; + + if (frame) + return avpriv_v4l2_enqueue_frame(output, frame); + + return 0; +} + +static int v4l2m2m_receive_packet(AVCodecContext *avctx, AVPacket *avpkt) +{ + V4L2m2mContext *s = avctx->priv_data; + V4L2Context *const capture = &s->capture; + V4L2Context *const output = &s->output; + unsigned int timeout = 50; + int ret; + + if (!output->streamon) { + ret = avpriv_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 = avpriv_v4l2_context_set_status(capture, VIDIOC_STREAMON); + if (ret) { + av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMON failed on capture context\n"); + return ret; + } + } + + return avpriv_v4l2_dequeue_packet(capture, avpkt, timeout); +} + +#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 = v4l2m2m_encode_init,\ + .send_frame = v4l2m2m_send_frame,\ + .receive_packet = v4l2m2m_receive_packet,\ + .close = ff_v4l2m2m_codec_end,\ +}; + +#if CONFIG_H263_V4L2M2M_ENCODER +M2MENC(h263, "H.263", AV_CODEC_ID_H263); +#endif + +#if CONFIG_H264_V4L2M2M_ENCODER +M2MENC(h264, "H.264", AV_CODEC_ID_H264); +#endif + +#if CONFIG_MPEG4_V4L2M2M_ENCODER +M2MENC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4); +#endif + +#if CONFIG_VP8_V4L2M2M_ENCODER +M2MENC(vp8, "VP8", AV_CODEC_ID_VP8); +#endif + +#if CONFIG_HEVC_V4L2M2M_ENCODER +M2MENC(hevc, "HEVC", AV_CODEC_ID_HEVC); +#endif +