From: Mirko Vogt Date: Tue, 8 Sep 2026 13:49:22 +0000 (+0000) Subject: ffmpeg: add V4L2 hardware decoding patches from LibreELEC X-Git-Url: http://git.99rst.org/?a=commitdiff_plain;h=e1a07d05b984d9bd14c0a4ad6c00ee617418ce6a;p=openwrt-packages.git ffmpeg: add V4L2 hardware decoding patches from LibreELEC V4L2 Request API hwaccels for stateless decoders such as Allwinner cedrus, exporting DRM_PRIME frames, and a V4L2 M2M deinterlace filter driving mem2mem deinterlacers such as Allwinner's sun8i-di on DRM_PRIME frames. The hwaccels introduce the v4l2-request and libudev configure options. Add the FFMPEG_V4L2_REQUEST option (pulls libdrm and libudev) to the libffmpeg menu, keep both new configure options explicitly off in the common block like the other autodetected ones, and re-add the *_v4l2request hwaccels under manual component selection. Patches: 120-v4l2-request-01 to -13: carried over from LibreELEC (packages/multimedia/ffmpeg/patches/v4l2-request/0001-v4l2-request.patch as of LibreELEC commit 79de202a10), one file per patch of the series: 01 avutil/hwcontext: Add hwdevice type for V4L2 Request API (Jonas Karlman) 02 avutil/hwcontext_v4l2request: Probe for a capable media and video device (Jonas Karlman) 03 avcodec: Add common V4L2 Request API code (Jonas Karlman) 04 avcodec/v4l2request: Add common decode support for hwaccels (Jonas Karlman) 05 avcodec: Add V4L2 Request API mpeg2 hwaccel (Jonas Karlman) 06 avcodec/h264dec: add ref_pic_marking and pic_order_cnt bit_size to slice context (Boris Brezillon) 07 avcodec: Add V4L2 Request API h264 hwaccel (Jernej Skrabec) 08 avcodec: Add V4L2 Request API hevc hwaccel (Jernej Skrabec) 09 avcodec: Add V4L2 Request API vp8 hwaccel (Boris Brezillon) 10 avcodec: Add V4L2 Request API vp9 hwaccel (Boris Brezillon) 11 avcodec: Add V4L2 Request API av1 hwaccel (Jonas Karlman) 12 avutil/hwcontext_v4l2request: Add support for AFBC_16X16_SPLIT pix fmts (Jernej Skrabec) 13 avutil/hwcontext_v4l2request: Add support for BROADCOM_SAND128 pix fmts (Jonas Karlman) Co-developed by Alex Bee, Benjamin Gaignard and Ezequiel Garcia. 140-vf-deinterlace-v4l2m2m: carried over from LibreELEC (packages/multimedia/ffmpeg/patches/vf-deinterlace-v4l2m2m/0001-vf-deinterlace-v4l2m2m.patch as of LibreELEC commit 9ef6c9c6f7; Jernej Skrabec): adds the deinterlace_v4l2m2m filter Headers unchanged, hunks refreshed with quilt; the patched tree is identical to the one LibreELEC's files produce. LibreELEC's v4l2-drmprime patch (stateful M2M decoders) is not carried: it needs a rebase for FFmpeg 9 which LibreELEC has not done either. The V4L2 Request API series is under review upstream as: https://code.ffmpeg.org/FFmpeg/FFmpeg/pulls/20847 The patches here are taken from LibreELEC, though, as that's the set that Kodi is built and tested against, incl. some platform specific fixes. Signed-off-by: Mirko Vogt --- diff --git a/multimedia/ffmpeg/Config.in b/multimedia/ffmpeg/Config.in index 850ecf655..571fe7648 100644 --- a/multimedia/ffmpeg/Config.in +++ b/multimedia/ffmpeg/Config.in @@ -63,6 +63,14 @@ config FFMPEG_V4L2_M2M bool "V4L2 mem2mem (stateful) decoders/encoders" default y +config FFMPEG_V4L2_REQUEST + bool "V4L2 Request API (stateless) hwaccels" + select FFMPEG_LIBDRM + default y + help + Stateless V4L2 hardware decoding (cedrus, hantro, rkvdec, ...) + exporting DRM_PRIME frames. Requires libdrm and libudev. + # VA-API support is prepared but disabled until a libva package exists in # the feeds; uncomment (and the DEPENDS line in the Makefile) once it does. #config FFMPEG_VAAPI diff --git a/multimedia/ffmpeg/Makefile b/multimedia/ffmpeg/Makefile index 4e85d57de..888f7a1c3 100644 --- a/multimedia/ffmpeg/Makefile +++ b/multimedia/ffmpeg/Makefile @@ -206,6 +206,7 @@ PKG_CONFIG_DEPENDS:= \ CONFIG_FFMPEG_PROGRAMS \ CONFIG_FFMPEG_LIBDRM \ CONFIG_FFMPEG_V4L2_M2M \ + CONFIG_FFMPEG_V4L2_REQUEST \ CONFIG_FFMPEG_VAAPI \ CONFIG_FFMPEG_LIBV4L2 \ CONFIG_FFMPEG_TLS_NONE \ @@ -299,6 +300,8 @@ $(call Package/libffmpeg/Default) +FFMPEG_BZLIB:libbz2 \ +FFMPEG_LZMA:liblzma \ +FFMPEG_LIBDRM:libdrm \ + +FFMPEG_V4L2_REQUEST:libdrm \ + +FFMPEG_V4L2_REQUEST:libudev \ +FFMPEG_LIBV4L2:libv4l \ +FFMPEG_TLS_GNUTLS:libgnutls \ +FFMPEG_TLS_OPENSSL:libopenssl \ @@ -402,12 +405,16 @@ FFMPEG_CONFIGURE:= \ --disable-vulkan \ --disable-vaapi \ --disable-libdrm \ - --disable-v4l2-m2m + --disable-v4l2-m2m \ + --disable-v4l2-request \ + --disable-libudev # Everything configure would autodetect on a Linux host is switched off # explicitly above. --disable-autodetect already implies this; the explicit # list documents the intent and is independent of changes to configure's # autodetect list. The libffmpeg variant re-enables bzlib/iconv/lzma and the # hwaccels through its FFMPEG_* options below; later flags take precedence. +# v4l2-request and libudev are introduced by patches/120-v4l2-request-*.patch, +# which also makes v4l2-request autodetected. ifeq ($(CONFIG_SOFT_FLOAT),y) FFMPEG_CONFIGURE+= \ @@ -491,6 +498,8 @@ ifeq ($(BUILD_VARIANT),default) # by patches/100-postproc.patch (LibreELEC), which also re-introduces the # --enable/--disable-postproc option; it is GPL-only, so it follows the GPL # option. Kodi requires it. + # v4l2-request/libudev: options from patches/120-v4l2-request-*.patch, see + # the common block above. # vaapi/libdav1d: literal --disable until the libva / dav1d packages exist # in the feeds; then restore $(call FFMPEG_OPT,FFMPEG_VAAPI,vaapi), # $(call FFMPEG_OPT,FFMPEG_LIBDAV1D,libdav1d) and, for manual component @@ -504,6 +513,8 @@ ifeq ($(BUILD_VARIANT),default) $(if $(CONFIG_FFMPEG_OPTIMIZE_SIZE),--disable-hardcoded-tables,--enable-hardcoded-tables) \ $(call FFMPEG_OPT,FFMPEG_LIBDRM,libdrm) \ $(call FFMPEG_OPT,FFMPEG_V4L2_M2M,v4l2-m2m) \ + $(call FFMPEG_OPT,FFMPEG_V4L2_REQUEST,v4l2-request) \ + $(call FFMPEG_OPT,FFMPEG_V4L2_REQUEST,libudev) \ --disable-vaapi \ $(call FFMPEG_OPT,FFMPEG_LIBV4L2,libv4l2) \ $(call FFMPEG_OPT,FFMPEG_TLS_GNUTLS,gnutls) \ @@ -551,6 +562,7 @@ ifeq ($(BUILD_VARIANT),default) $(if $(CONFIG_FFMPEG_DECODER_adpcm),--enable-decoder=adpcm_*) \ $(if $(CONFIG_FFMPEG_TLS_NONE),,--enable-protocol=tls --enable-protocol=https) \ $(if $(CONFIG_FFMPEG_V4L2_M2M),--enable-decoder=*_v4l2m2m --enable-encoder=*_v4l2m2m) \ + $(if $(CONFIG_FFMPEG_V4L2_REQUEST),--enable-hwaccel=*_v4l2request) \ $(if $(CONFIG_FFMPEG_LIBOPUS),--enable-decoder=libopus --enable-encoder=libopus) \ $(if $(CONFIG_FFMPEG_LIBVORBIS),--enable-encoder=libvorbis) \ $(if $(CONFIG_FFMPEG_LIBVPX),--enable-decoder=libvpx_vp8 --enable-decoder=libvpx_vp9 --enable-encoder=libvpx_vp8 --enable-encoder=libvpx_vp9) \ diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-01.patch b/multimedia/ffmpeg/patches/120-v4l2-request-01.patch new file mode 100644 index 000000000..07526086d --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-01.patch @@ -0,0 +1,904 @@ +From 900fa8e6625a0134432a1dccf87633b499af5fb1 Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Tue, 6 Aug 2024 09:06:00 +0000 +Subject: [PATCH 01/13] avutil/hwcontext: Add hwdevice type for V4L2 Request + API + +Add a hwdevice type for use with V4L2 Request API stateless decoding. + +AVV4L2RequestFramesContext is expected to be filled with a V4L2 coded +pixel format and optional codec-specific extended controls before an +AVHWFramesContext is initialized. + +Once initialized AVV4L2RequestFramesContextInternal describe the opened +V4L2 stateless decoder session, with details about media/video file +descriptors, formats of CAPTURE/OUTPUT queues and buffer pools for +creating CAPTURE/OUTPUT buffers. + +AVHWFramesContext.pool defaults to create frame descriptors around a +CAPTURE buffer, and frames are returned with AVFrame.data[0] pointing +to a AVDRMFrameDescriptor and AVFrame.data[1] the CAPTURE buffer index. + +Signed-off-by: Jonas Karlman +--- + configure | 8 + + libavutil/Makefile | 4 + + libavutil/hwcontext.c | 4 + + libavutil/hwcontext.h | 1 + + libavutil/hwcontext_internal.h | 1 + + libavutil/hwcontext_v4l2request.c | 617 +++++++++++++++++++++ + libavutil/hwcontext_v4l2request.h | 70 +++ + libavutil/hwcontext_v4l2request_internal.h | 67 +++ + 8 files changed, 772 insertions(+) + create mode 100644 libavutil/hwcontext_v4l2request.c + create mode 100644 libavutil/hwcontext_v4l2request.h + create mode 100644 libavutil/hwcontext_v4l2request_internal.h + +--- a/configure ++++ b/configure +@@ -365,6 +365,7 @@ External library support: + --disable-nvenc disable Nvidia video encoding code [autodetect] + --enable-rkmpp enable Rockchip Media Process Platform code [no] + --disable-v4l2-m2m disable V4L2 mem2mem code [autodetect] ++ --enable-v4l2-request enable V4L2 Request API code [no] + --disable-vaapi disable Video Acceleration API (mainly Unix/Intel) code [autodetect] + --disable-vdpau disable Nvidia Video Decode and Presentation API for Unix code [autodetect] + --disable-videotoolbox disable VideoToolbox code [autodetect] +@@ -2201,6 +2202,7 @@ HWACCEL_LIBRARY_LIST=" + libvpl + mmal + opencl ++ v4l2_request + " + + DOCUMENT_LIST=" +@@ -3400,6 +3402,8 @@ dxva2_deps="dxva2api_h DXVA2_ConfigPictu + ffnvcodec_deps_any="libdl LoadLibrary" + mediacodec_deps="android mediandk pthreads" + nvdec_deps="ffnvcodec" ++v4l2_request_deps="linux_media_h v4l2_timeval_to_ns libdrm" ++v4l2_request_suggest="libdrm" + vaapi_x11_deps="xlib_x11" + videotoolbox_hwaccel_deps="videotoolbox pthreads" + videotoolbox_hwaccel_extralibs="-framework QuartzCore" +@@ -7656,6 +7660,10 @@ if enabled v4l2_m2m; then + check_cc vp9_v4l2_m2m linux/videodev2.h "int i = V4L2_PIX_FMT_VP9;" + fi + ++if enabled v4l2_request; then ++ check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns ++fi ++ + check_headers sys/videoio.h + test_code cc sys/videoio.h "struct v4l2_frmsizeenum vfse; vfse.discrete.width = 0;" && enable_sanitized struct_v4l2_frmivalenum_discrete + +--- a/libavutil/Makefile ++++ b/libavutil/Makefile +@@ -52,6 +52,7 @@ HEADERS = adler32.h + hwcontext_mediacodec.h \ + hwcontext_opencl.h \ + hwcontext_oh.h \ ++ hwcontext_v4l2request.h \ + hwcontext_vaapi.h \ + hwcontext_videotoolbox.h \ + hwcontext_vdpau.h \ +@@ -216,6 +217,7 @@ OBJS-$(CONFIG_MEDIACODEC) + OBJS-$(CONFIG_OHCODEC) += hwcontext_oh.o + OBJS-$(CONFIG_OPENCL) += hwcontext_opencl.o + OBJS-$(CONFIG_QSV) += hwcontext_qsv.o ++OBJS-$(CONFIG_V4L2_REQUEST) += hwcontext_v4l2request.o + OBJS-$(CONFIG_VAAPI) += hwcontext_vaapi.o + OBJS-$(CONFIG_VIDEOTOOLBOX) += hwcontext_videotoolbox.o + OBJS-$(CONFIG_VDPAU) += hwcontext_vdpau.o +@@ -247,6 +249,8 @@ SKIPHEADERS-$(CONFIG_AMF) + + hwcontext_amf_internal.h + SKIPHEADERS-$(CONFIG_QSV) += hwcontext_qsv.h + SKIPHEADERS-$(CONFIG_OPENCL) += hwcontext_opencl.h ++SKIPHEADERS-$(CONFIG_V4L2_REQUEST) += hwcontext_v4l2request.h \ ++ hwcontext_v4l2request_internal.h + SKIPHEADERS-$(CONFIG_VAAPI) += hwcontext_vaapi.h + SKIPHEADERS-$(CONFIG_VIDEOTOOLBOX) += hwcontext_videotoolbox.h + SKIPHEADERS-$(CONFIG_VDPAU) += hwcontext_vdpau.h +--- a/libavutil/hwcontext.c ++++ b/libavutil/hwcontext.c +@@ -72,6 +72,9 @@ static const HWContextType * const hw_ta + #if CONFIG_OHCODEC + &ff_hwcontext_type_oh, + #endif ++#if CONFIG_V4L2_REQUEST ++ &ff_hwcontext_type_v4l2request, ++#endif + NULL, + }; + +@@ -83,6 +86,7 @@ static const char *const hw_type_names[] + [AV_HWDEVICE_TYPE_D3D12VA] = "d3d12va", + [AV_HWDEVICE_TYPE_OPENCL] = "opencl", + [AV_HWDEVICE_TYPE_QSV] = "qsv", ++ [AV_HWDEVICE_TYPE_V4L2REQUEST] = "v4l2request", + [AV_HWDEVICE_TYPE_VAAPI] = "vaapi", + [AV_HWDEVICE_TYPE_VDPAU] = "vdpau", + [AV_HWDEVICE_TYPE_VIDEOTOOLBOX] = "videotoolbox", +--- a/libavutil/hwcontext.h ++++ b/libavutil/hwcontext.h +@@ -41,6 +41,7 @@ enum AVHWDeviceType { + AV_HWDEVICE_TYPE_AMF, + /* OpenHarmony Codec device */ + AV_HWDEVICE_TYPE_OHCODEC, ++ AV_HWDEVICE_TYPE_V4L2REQUEST, + }; + + /** +--- a/libavutil/hwcontext_internal.h ++++ b/libavutil/hwcontext_internal.h +@@ -158,6 +158,7 @@ extern const HWContextType ff_hwcontext_ + extern const HWContextType ff_hwcontext_type_dxva2; + extern const HWContextType ff_hwcontext_type_opencl; + extern const HWContextType ff_hwcontext_type_qsv; ++extern const HWContextType ff_hwcontext_type_v4l2request; + extern const HWContextType ff_hwcontext_type_vaapi; + extern const HWContextType ff_hwcontext_type_vdpau; + extern const HWContextType ff_hwcontext_type_videotoolbox; +--- /dev/null ++++ b/libavutil/hwcontext_v4l2request.c +@@ -0,0 +1,617 @@ ++/* ++ * 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 "config.h" ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++ ++#include "avassert.h" ++#include "hwcontext_drm.h" ++#include "hwcontext_internal.h" ++#include "hwcontext_v4l2request_internal.h" ++#include "mem.h" ++ ++typedef struct V4L2RequestDeviceContext { ++} V4L2RequestDeviceContext; ++ ++typedef struct V4L2RequestFramesContext { ++ AVV4L2RequestFramesContext p; ++ AVV4L2RequestFramesContextInternal internal; ++} V4L2RequestFramesContext; ++ ++typedef struct V4L2RequestFrameDescriptor { ++ AVDRMFrameDescriptor base; ++ AVBufferRef *ref; ++ uint32_t index; ++ int fd[AV_DRM_MAX_PLANES]; ++} V4L2RequestFrameDescriptor; ++ ++static const struct { ++ uint32_t pixelformat; ++ enum AVPixelFormat sw_format; ++ uint32_t drm_format; ++ uint64_t format_modifier; ++ uint32_t bit_depth; ++} v4l2request_capture_pixelformats[] = { ++ { V4L2_PIX_FMT_NV12, AV_PIX_FMT_NV12, DRM_FORMAT_NV12, DRM_FORMAT_MOD_LINEAR, 8 }, ++#if defined(V4L2_PIX_FMT_NV12_32L32) ++ { V4L2_PIX_FMT_NV12_32L32, AV_PIX_FMT_YUV420P, DRM_FORMAT_NV12, DRM_FORMAT_MOD_ALLWINNER_TILED, 8 }, ++#endif ++#if defined(V4L2_PIX_FMT_NV15) && defined(DRM_FORMAT_NV15) ++ { V4L2_PIX_FMT_NV15, AV_PIX_FMT_YUV420P10, DRM_FORMAT_NV15, DRM_FORMAT_MOD_LINEAR, 10 }, ++#endif ++ { V4L2_PIX_FMT_NV16, AV_PIX_FMT_NV16, DRM_FORMAT_NV16, DRM_FORMAT_MOD_LINEAR, 8 }, ++#if defined(V4L2_PIX_FMT_NV20) && defined(DRM_FORMAT_NV20) ++ { V4L2_PIX_FMT_NV20, AV_PIX_FMT_YUV422P10, DRM_FORMAT_NV20, DRM_FORMAT_MOD_LINEAR, 10 }, ++#endif ++#if defined(V4L2_PIX_FMT_P010) && defined(DRM_FORMAT_P010) ++ { V4L2_PIX_FMT_P010, AV_PIX_FMT_P010, DRM_FORMAT_P010, DRM_FORMAT_MOD_LINEAR, 10 }, ++#endif ++#if defined(V4L2_PIX_FMT_NV12MT_COL128) && defined(V4L2_PIX_FMT_NV12MT_10_COL128) ++ { V4L2_PIX_FMT_NV12MT_COL128, AV_PIX_FMT_YUV420P, DRM_FORMAT_NV12, DRM_FORMAT_MOD_BROADCOM_SAND128, 8 }, ++#if defined(DRM_FORMAT_P030) ++ { V4L2_PIX_FMT_NV12MT_10_COL128, AV_PIX_FMT_YUV420P10, DRM_FORMAT_P030, DRM_FORMAT_MOD_BROADCOM_SAND128, 10 }, ++#endif ++#endif ++}; ++ ++static int v4l2request_set_drm_descriptor(AVDRMFrameDescriptor *desc, ++ struct v4l2_format *format) ++{ ++ AVDRMLayerDescriptor *layer = &desc->layers[0]; ++ uint32_t pixelformat = V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.pixelformat : ++ format->fmt.pix.pixelformat; ++ uint64_t format_modifier; ++ ++ layer->format = 0; ++ for (int i = 0; i < FF_ARRAY_ELEMS(v4l2request_capture_pixelformats); i++) { ++ if (pixelformat == v4l2request_capture_pixelformats[i].pixelformat) { ++ layer->format = v4l2request_capture_pixelformats[i].drm_format; ++ format_modifier = v4l2request_capture_pixelformats[i].format_modifier; ++ break; ++ } ++ } ++ if (!layer->format) ++ return AVERROR(ENOENT); ++ ++ for (int i = 0; i < desc->nb_objects; i++) { ++ desc->objects[i].format_modifier = format_modifier; ++ desc->objects[i].size = V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.plane_fmt[i].sizeimage : ++ format->fmt.pix.sizeimage; ++ } ++ ++ desc->nb_layers = 1; ++ layer->nb_planes = 2; ++ ++ layer->planes[0].object_index = 0; ++ layer->planes[0].offset = 0; ++ layer->planes[0].pitch = V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.plane_fmt[0].bytesperline : ++ format->fmt.pix.bytesperline; ++ ++ layer->planes[1].object_index = 0; ++ layer->planes[1].offset = layer->planes[0].pitch * ++ (V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.height : ++ format->fmt.pix.height); ++ layer->planes[1].pitch = layer->planes[0].pitch; ++ ++#if defined(V4L2_PIX_FMT_NV12MT_COL128) && defined(V4L2_PIX_FMT_NV12MT_10_COL128) ++ // Raspberry Pi formats need special handling ++ if (pixelformat == V4L2_PIX_FMT_NV12MT_COL128 || ++ pixelformat == V4L2_PIX_FMT_NV12MT_10_COL128) { ++ layer->planes[1].object_index = 1; ++ layer->planes[1].offset = 0; ++ layer->planes[0].pitch = (V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.height : ++ format->fmt.pix.height); ++ layer->planes[1].pitch = layer->planes[0].pitch / 2; ++ } ++#endif ++ ++ return 0; ++} ++ ++static void v4l2request_device_uninit(AVHWDeviceContext *hwdev) ++{ ++} ++ ++static int v4l2request_device_create(AVHWDeviceContext *hwdev, const char *device, ++ AVDictionary *opts, int flags) ++{ ++ return 0; ++} ++ ++static int v4l2request_open_decoder(AVHWFramesContext *hwfc) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ ++ // Ensure codec pixelformat is set ++ if (!fctx->pixelformat) ++ return AVERROR(EINVAL); ++ ++ // TODO: locate a decoder supporting the requested pixelformat ++ ++ return AVERROR(ENOSYS); ++} ++ ++static AVBufferRef *v4l2request_v4l2_buffer_alloc(AVHWFramesContext *hwfc, ++ struct v4l2_format *format) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct v4l2_create_buffers buffers = { ++ .count = 1, ++ .memory = V4L2_MEMORY_MMAP, ++ .format = *format, ++ }; ++ struct v4l2_buffer *buffer; ++ uint8_t num_planes; ++ AVBufferRef *ref; ++ ++ num_planes = V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.num_planes : 0; ++ ++ ref = av_buffer_allocz(sizeof(struct v4l2_buffer) + ++ (sizeof(struct v4l2_plane) * num_planes)); ++ if (!ref) ++ return NULL; ++ ++ buffer = (struct v4l2_buffer *)ref->data; ++ buffer->type = format->type; ++ ++ if (num_planes) { ++ buffer->length = num_planes; ++ buffer->m.planes = (struct v4l2_plane *)(buffer + 1); ++ } ++ ++ // Create the buffer ++ if (ioctl(fctxi->video_fd, VIDIOC_CREATE_BUFS, &buffers) < 0) { ++ av_log(hwfc, AV_LOG_ERROR, "Failed to create buffer of type %d: %s (%d)\n", ++ buffer->type, strerror(errno), errno); ++ goto fail; ++ } ++ ++ buffer->memory = buffers.memory; ++ buffer->index = buffers.index; ++ ++ // Query more details of the created buffer ++ if (ioctl(fctxi->video_fd, VIDIOC_QUERYBUF, buffer) < 0) { ++ av_log(hwfc, AV_LOG_ERROR, "Failed to query buffer %d of type %d: %s (%d)\n", ++ buffer->index, buffer->type, strerror(errno), errno); ++ goto fail; ++ } ++ ++ return ref; ++ ++fail: ++ av_buffer_unref(&ref); ++ return NULL; ++} ++ ++static AVBufferRef *v4l2request_capture_buffer_alloc(void *opaque, size_t size) ++{ ++ AVHWFramesContext *hwfc = opaque; ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ ++ return v4l2request_v4l2_buffer_alloc(hwfc, &fctxi->capture.format); ++} ++ ++static AVBufferRef *v4l2request_output_buffer_alloc(void *opaque, size_t size) ++{ ++ AVHWFramesContext *hwfc = opaque; ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ ++ return v4l2request_v4l2_buffer_alloc(hwfc, &fctxi->output.format); ++} ++ ++static void v4l2request_frame_free(void *opaque, uint8_t *data) ++{ ++ V4L2RequestFrameDescriptor *desc = (V4L2RequestFrameDescriptor *)data; ++ ++ // Close the exported CAPTURE buffer memory planes ++ for (int i = 0; i < FF_ARRAY_ELEMS(desc->fd); i++) { ++ if (desc->fd[i] >= 0) { ++ close(desc->fd[i]); ++ desc->fd[i] = -1; ++ } ++ } ++ ++ // Return the CAPTURE buffer to the frames context CAPTURE pool ++ av_buffer_unref(&desc->ref); ++ ++ av_free(data); ++} ++ ++static AVBufferRef *v4l2request_frame_alloc(void *opaque, size_t size) ++{ ++ AVHWFramesContext *hwfc = opaque; ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct v4l2_format *format = &fctxi->capture.format; ++ V4L2RequestFrameDescriptor *desc; ++ struct v4l2_buffer *buffer; ++ AVBufferRef *ref; ++ uint8_t *data; ++ ++ data = av_mallocz(size); ++ if (!data) ++ return NULL; ++ ++ ref = av_buffer_create(data, size, v4l2request_frame_free, ++ hwfc, AV_BUFFER_FLAG_READONLY); ++ if (!ref) { ++ av_free(data); ++ return NULL; ++ } ++ ++ // Set initial default values ++ desc = (V4L2RequestFrameDescriptor *)data; ++ for (int i = 0; i < FF_ARRAY_ELEMS(desc->fd); i++) ++ desc->fd[i] = -1; ++ ++ // Get a CAPTURE buffer from frames context CAPTURE pool ++ desc->ref = av_buffer_pool_get(fctxi->capture.pool); ++ if (!desc->ref) ++ goto fail; ++ ++ buffer = (struct v4l2_buffer *)desc->ref->data; ++ desc->index = buffer->index; ++ ++ // Export CAPTURE buffer memory planes ++ desc->base.nb_objects = V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.num_planes : 1; ++ av_assert0(desc->base.nb_objects <= AV_DRM_MAX_PLANES); ++ for (int i = 0; i < desc->base.nb_objects; i++) { ++ struct v4l2_exportbuffer exportbuffer = { ++ .type = buffer->type, ++ .index = buffer->index, ++ .plane = i, ++ .flags = O_RDONLY, ++ }; ++ if (ioctl(fctxi->video_fd, VIDIOC_EXPBUF, &exportbuffer) < 0) { ++ av_log(hwfc, AV_LOG_ERROR, "Failed to export memory plane %d (%d): %s (%d)\n", ++ i, buffer->index, strerror(errno), errno); ++ goto fail; ++ } ++ desc->base.objects[i].fd = desc->fd[i] = exportbuffer.fd; ++ } ++ ++ // Set AVDRMFrameDescriptor based on CAPTURE buffer format ++ if (v4l2request_set_drm_descriptor(&desc->base, format) < 0) ++ goto fail; ++ ++ return ref; ++ ++fail: ++ av_buffer_unref(&ref); ++ return NULL; ++} ++ ++static int v4l2request_frames_init(AVHWFramesContext *hwfc) ++{ ++ V4L2RequestFramesContext *hwctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi; ++ uint32_t pixelformat; ++ int ret; ++ ++ // Set initial default values ++ fctxi = &hwctx->internal; ++ hwctx->p.internal = fctxi; ++ fctxi->media_fd = -1; ++ fctxi->video_fd = -1; ++ ++ // Locate and open a capable video decoder device ++ ret = v4l2request_open_decoder(hwfc); ++ if (ret < 0) ++ return ret; ++ ++ // Reset init controls after video device is opened ++ hwctx->p.init_controls = NULL; ++ hwctx->p.nb_init_controls = 0; ++ ++ // Update frames context with CAPTURE format details ++ if (V4L2_TYPE_IS_MULTIPLANAR(fctxi->capture.format.type)) { ++ hwfc->width = fctxi->capture.format.fmt.pix_mp.width; ++ hwfc->height = fctxi->capture.format.fmt.pix_mp.height; ++ pixelformat = fctxi->capture.format.fmt.pix_mp.pixelformat; ++ } else { ++ hwfc->width = fctxi->capture.format.fmt.pix.width; ++ hwfc->height = fctxi->capture.format.fmt.pix.height; ++ pixelformat = fctxi->capture.format.fmt.pix.pixelformat; ++ } ++ ++ hwfc->sw_format = AV_PIX_FMT_NONE; ++ for (int i = 0; i < FF_ARRAY_ELEMS(v4l2request_capture_pixelformats); i++) { ++ if (pixelformat == v4l2request_capture_pixelformats[i].pixelformat) { ++ hwctx->p.bit_depth = v4l2request_capture_pixelformats[i].bit_depth; ++ hwfc->sw_format = v4l2request_capture_pixelformats[i].sw_format; ++ break; ++ } ++ } ++ ++ // Initialize buffer pool for CAPTURE buffers ++ fctxi->capture.pool = av_buffer_pool_init2(sizeof(struct v4l2_buffer), hwfc, ++ v4l2request_capture_buffer_alloc, NULL); ++ if (!fctxi->capture.pool) ++ return AVERROR(ENOMEM); ++ ++ // Initialize buffer pool for OUTPUT buffers ++ fctxi->output.pool = av_buffer_pool_init2(sizeof(struct v4l2_buffer), hwfc, ++ v4l2request_output_buffer_alloc, NULL); ++ if (!fctxi->output.pool) ++ return AVERROR(ENOMEM); ++ ++ // Initialize buffer pool for frame descriptors ++ ffhwframesctx(hwfc)->pool_internal = ++ av_buffer_pool_init2(sizeof(V4L2RequestFrameDescriptor), hwfc, ++ v4l2request_frame_alloc, NULL); ++ if (!ffhwframesctx(hwfc)->pool_internal) ++ return AVERROR(ENOMEM); ++ ++ av_log(hwfc, AV_LOG_VERBOSE, "Using CAPTURE buffer format %s (%dx%d)\n", ++ av_fourcc2str(pixelformat), hwfc->width, hwfc->height); ++ ++ return 0; ++} ++ ++static void v4l2request_frames_uninit(AVHWFramesContext *hwfc) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ ++ av_buffer_pool_uninit(&fctxi->capture.pool); ++ av_buffer_pool_uninit(&fctxi->output.pool); ++ ++ if (fctxi->video_fd >= 0) { ++ close(fctxi->video_fd); ++ fctxi->video_fd = -1; ++ } ++ ++ if (fctxi->media_fd) { ++ close(fctxi->media_fd); ++ fctxi->media_fd = -1; ++ } ++} ++ ++static int v4l2request_get_buffer(AVHWFramesContext *hwfc, AVFrame *frame) ++{ ++ V4L2RequestFrameDescriptor *desc; ++ ++ frame->buf[0] = av_buffer_pool_get(hwfc->pool); ++ if (!frame->buf[0]) ++ return AVERROR(ENOMEM); ++ ++ desc = (V4L2RequestFrameDescriptor *)frame->buf[0]->data; ++ frame->data[0] = (uint8_t *)&desc->base; ++ frame->data[1] = (uint8_t *)(uintptr_t)desc->index; ++ ++ frame->format = AV_PIX_FMT_DRM_PRIME; ++ frame->width = hwfc->width; ++ frame->height = hwfc->height; ++ ++ return 0; ++} ++ ++typedef struct V4L2RequestMapping { ++ // Address and length of each mmap()ed region. ++ int nb_regions; ++ int object[AV_DRM_MAX_PLANES]; ++ void *address[AV_DRM_MAX_PLANES]; ++ size_t length[AV_DRM_MAX_PLANES]; ++} V4L2RequestMapping; ++ ++static void v4l2request_unmap_frame(AVHWFramesContext *hwfc, ++ HWMapDescriptor *hwmap) ++{ ++ V4L2RequestMapping *map = hwmap->priv; ++ ++ for (int i = 0; i < map->nb_regions; i++) { ++ struct dma_buf_sync sync = { ++ .flags = DMA_BUF_SYNC_END | DMA_BUF_SYNC_READ, ++ }; ++ ioctl(map->object[i], DMA_BUF_IOCTL_SYNC, &sync); ++ munmap(map->address[i], map->length[i]); ++ } ++ ++ av_free(map); ++} ++ ++static int v4l2request_map_frame(AVHWFramesContext *hwfc, ++ AVFrame *dst, const AVFrame *src) ++{ ++ const AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor *)src->data[0]; ++ struct dma_buf_sync sync = { ++ .flags = DMA_BUF_SYNC_START | DMA_BUF_SYNC_READ, ++ }; ++ V4L2RequestMapping *map; ++ int ret, i, p, plane; ++ void *addr; ++ ++ map = av_mallocz(sizeof(*map)); ++ if (!map) ++ return AVERROR(ENOMEM); ++ ++ av_assert0(desc->nb_objects <= AV_DRM_MAX_PLANES); ++ for (i = 0; i < desc->nb_objects; i++) { ++ addr = mmap(NULL, desc->objects[i].size, PROT_READ, MAP_SHARED, ++ desc->objects[i].fd, 0); ++ if (addr == MAP_FAILED) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to map DRM object %d to memory: %s (%d)\n", ++ desc->objects[i].fd, strerror(errno), errno); ++ goto fail; ++ } ++ ++ map->address[i] = addr; ++ map->length[i] = desc->objects[i].size; ++ map->object[i] = desc->objects[i].fd; ++ ++ /* ++ * We're not checking for errors here because the kernel may not ++ * support the ioctl, in which case its okay to carry on ++ */ ++ ioctl(desc->objects[i].fd, DMA_BUF_IOCTL_SYNC, &sync); ++ } ++ map->nb_regions = i; ++ ++ plane = 0; ++ for (i = 0; i < desc->nb_layers; i++) { ++ const AVDRMLayerDescriptor *layer = &desc->layers[i]; ++ for (p = 0; p < layer->nb_planes; p++) { ++ dst->data[plane] = ++ (uint8_t *)map->address[layer->planes[p].object_index] + ++ layer->planes[p].offset; ++ dst->linesize[plane] = layer->planes[p].pitch; ++ ++plane; ++ } ++ } ++ av_assert0(plane <= AV_DRM_MAX_PLANES); ++ ++ dst->width = src->width; ++ dst->height = src->height; ++ ++ ret = ff_hwframe_map_create(src->hw_frames_ctx, dst, src, ++ v4l2request_unmap_frame, map); ++ if (ret < 0) ++ goto fail; ++ ++ return 0; ++ ++fail: ++ for (i = 0; i < desc->nb_objects; i++) { ++ if (map->address[i]) ++ munmap(map->address[i], map->length[i]); ++ } ++ av_free(map); ++ return ret; ++} ++ ++static int v4l2request_transfer_get_formats(AVHWFramesContext *hwfc, ++ enum AVHWFrameTransferDirection dir, ++ enum AVPixelFormat **formats) ++{ ++ enum AVPixelFormat *fmts; ++ ++ if (dir == AV_HWFRAME_TRANSFER_DIRECTION_TO) ++ return AVERROR(ENOSYS); ++ ++ fmts = av_malloc_array(2, sizeof(*fmts)); ++ if (!fmts) ++ return AVERROR(ENOMEM); ++ ++ fmts[0] = hwfc->sw_format; ++ fmts[1] = AV_PIX_FMT_NONE; ++ ++ if (hwfc->sw_format == AV_PIX_FMT_YUV420P || ++ hwfc->sw_format == AV_PIX_FMT_YUV420P10 || ++ hwfc->sw_format == AV_PIX_FMT_YUV422P10) ++ fmts[0] = AV_PIX_FMT_NONE; ++ ++ *formats = fmts; ++ return 0; ++} ++ ++static int v4l2request_transfer_data_from(AVHWFramesContext *hwfc, ++ AVFrame *dst, const AVFrame *src) ++{ ++ AVFrame *map; ++ int ret; ++ ++ if (dst->width > hwfc->width || dst->height > hwfc->height) ++ return AVERROR(EINVAL); ++ ++ map = av_frame_alloc(); ++ if (!map) ++ return AVERROR(ENOMEM); ++ map->format = dst->format; ++ ++ ret = v4l2request_map_frame(hwfc, map, src); ++ if (ret) ++ goto fail; ++ ++ map->width = dst->width; ++ map->height = dst->height; ++ ++ ret = av_frame_copy(dst, map); ++ if (ret) ++ goto fail; ++ ++ ret = 0; ++fail: ++ av_frame_free(&map); ++ return ret; ++} ++ ++static int v4l2request_map_from(AVHWFramesContext *hwfc, AVFrame *dst, ++ const AVFrame *src, int flags) ++{ ++ int ret; ++ ++ if (!(flags & AV_HWFRAME_MAP_READ)) ++ return AVERROR(ENOSYS); ++ ++ if (hwfc->sw_format == AV_PIX_FMT_NONE || ++ hwfc->sw_format == AV_PIX_FMT_YUV420P || ++ hwfc->sw_format == AV_PIX_FMT_YUV420P10 || ++ hwfc->sw_format == AV_PIX_FMT_YUV422P10) ++ return AVERROR(ENOSYS); ++ else if (dst->format == AV_PIX_FMT_NONE) ++ dst->format = hwfc->sw_format; ++ else if (hwfc->sw_format != dst->format) ++ return AVERROR(ENOSYS); ++ ++ ret = v4l2request_map_frame(hwfc, dst, src); ++ if (ret) ++ return ret; ++ ++ return av_frame_copy_props(dst, src); ++} ++ ++const HWContextType ff_hwcontext_type_v4l2request = { ++ .type = AV_HWDEVICE_TYPE_V4L2REQUEST, ++ .name = "V4L2 Request API", ++ ++ .device_hwctx_size = sizeof(V4L2RequestDeviceContext), ++ .device_create = v4l2request_device_create, ++ .device_uninit = v4l2request_device_uninit, ++ ++ .frames_hwctx_size = sizeof(V4L2RequestFramesContext), ++ .frames_init = v4l2request_frames_init, ++ .frames_uninit = v4l2request_frames_uninit, ++ .frames_get_buffer = v4l2request_get_buffer, ++ .transfer_get_formats = v4l2request_transfer_get_formats, ++ .transfer_data_from = v4l2request_transfer_data_from, ++ .map_from = v4l2request_map_from, ++ ++ .pix_fmts = (const enum AVPixelFormat[]) { ++ AV_PIX_FMT_DRM_PRIME, ++ AV_PIX_FMT_NONE ++ }, ++}; +--- /dev/null ++++ b/libavutil/hwcontext_v4l2request.h +@@ -0,0 +1,70 @@ ++/* ++ * 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 AVUTIL_HWCONTEXT_V4L2REQUEST_H ++#define AVUTIL_HWCONTEXT_V4L2REQUEST_H ++ ++#include ++#include ++ ++/** ++ * @file ++ * An API-specific header for AV_HWDEVICE_TYPE_V4L2REQUEST. ++ */ ++ ++typedef struct AVV4L2RequestFramesContextInternal AVV4L2RequestFramesContextInternal; ++ ++/** ++ * V4L2 Request API frames context. ++ * ++ * This struct is allocated as AVHWFramesContext.hwctx ++ */ ++typedef struct AVV4L2RequestFramesContext { ++ /** ++ * Internal context for the initialized V4L2 stateless decoder/encoder session. ++ */ ++ AVV4L2RequestFramesContextInternal *internal; ++ ++ /** ++ * V4L2_PIX_FMT_* coded pixel format to set on the OUTPUT queue (decoders) ++ * or the CAPTURE queue (encoders) during initialization. ++ * ++ * This field must be set by caller before av_hwframe_ctx_init() is called. ++ */ ++ uint32_t pixelformat; ++ ++ /** ++ * Optional bit depth of the frame pixel format, e.g. 8 or 10. ++ * ++ * This field should be set by caller before av_hwframe_ctx_init() is called, ++ * the field will be updated to match the selected frame pixel format after ++ * successful initialization. ++ */ ++ uint32_t bit_depth; ++ ++ /** ++ * Optional codec-specific extended controls to be set during initialization. ++ * ++ * These fields should be set by caller before av_hwframe_ctx_init() is called, ++ * fields are reset to NULL and 0 after successful initialization. ++ */ ++ struct v4l2_ext_control *init_controls; ++ int nb_init_controls; ++} AVV4L2RequestFramesContext; ++ ++#endif /* AVUTIL_HWCONTEXT_V4L2REQUEST_H */ +--- /dev/null ++++ b/libavutil/hwcontext_v4l2request_internal.h +@@ -0,0 +1,67 @@ ++/* ++ * 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 AVUTIL_HWCONTEXT_V4L2REQUEST_INTERNAL_H ++#define AVUTIL_HWCONTEXT_V4L2REQUEST_INTERNAL_H ++ ++#include "buffer.h" ++#include "hwcontext_v4l2request.h" ++ ++/** ++ * @file ++ * FFmpeg internal API-specific header for AV_HWDEVICE_TYPE_V4L2REQUEST. ++ */ ++ ++/** ++ * Internal context for the initialized V4L2 stateless decoder/encoder session. ++ */ ++struct AVV4L2RequestFramesContextInternal { ++ /** ++ * Media device file descriptor of the initialized session. ++ */ ++ int media_fd; ++ ++ /** ++ * Video device file descriptor of the initialized session. ++ */ ++ int video_fd; ++ ++ /** ++ * Details of the initialized CAPTURE and OUTPUT queues. ++ */ ++ struct { ++ /** ++ * V4L2 buffer format. ++ */ ++ struct v4l2_format format; ++ ++ /** ++ * V4L2 buffer capabilities flags. ++ */ ++ uint32_t capabilities; ++ ++ /** ++ * Buffer pool of allocated V4L2 buffers. ++ * ++ * AVBufferRef.data points to a struct v4l2_buffer for the created buffer. ++ */ ++ AVBufferPool *pool; ++ } capture, output; ++}; ++ ++#endif /* AVUTIL_HWCONTEXT_V4L2REQUEST_INTERNAL_H */ diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-02.patch b/multimedia/ffmpeg/patches/120-v4l2-request-02.patch new file mode 100644 index 000000000..96acf5f20 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-02.patch @@ -0,0 +1,621 @@ +From 2d317790a8e86fe5451c48d28f4925f3372591e3 Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Tue, 6 Aug 2024 09:06:02 +0000 +Subject: [PATCH 02/13] avutil/hwcontext_v4l2request: Probe for a capable media + and video device + +Probe all media devices and its linked video devices to locate a video +device that support stateless decoding of the specific codec using the +V4L2 Request API. + +A video device is deemed capable when all tests pass, e.g. kernel +drivers support the coded pixel format and the frame size is supported. + +Basic flow for initialization follows the kernel Memory-to-memory +Stateless Video Decoder Interface > Initialization [1]. + +[1] https://www.kernel.org/doc/html/latest/userspace-api/media/v4l/dev-stateless-decoder.html#initialization + +Co-developed-by: Jernej Skrabec +Signed-off-by: Jernej Skrabec +Co-developed-by: Alex Bee +Signed-off-by: Alex Bee +Signed-off-by: Jonas Karlman +--- + configure | 9 +- + libavutil/hwcontext_v4l2request.c | 513 +++++++++++++++++++++++++++++- + 2 files changed, 517 insertions(+), 5 deletions(-) + +--- a/configure ++++ b/configure +@@ -2138,6 +2138,7 @@ EXTERNAL_LIBRARY_LIST=" + libtorch + libtwolame + libuavs3d ++ libudev + libv4l2 + libvmaf + libvorbis +@@ -3402,8 +3403,8 @@ dxva2_deps="dxva2api_h DXVA2_ConfigPictu + ffnvcodec_deps_any="libdl LoadLibrary" + mediacodec_deps="android mediandk pthreads" + nvdec_deps="ffnvcodec" +-v4l2_request_deps="linux_media_h v4l2_timeval_to_ns libdrm" +-v4l2_request_suggest="libdrm" ++v4l2_request_deps="linux_media_h v4l2_timeval_to_ns libdrm libudev" ++v4l2_request_suggest="libdrm libudev" + vaapi_x11_deps="xlib_x11" + videotoolbox_hwaccel_deps="videotoolbox pthreads" + videotoolbox_hwaccel_extralibs="-framework QuartzCore" +@@ -4380,7 +4381,7 @@ shader_compression_suggest="zlib" + + avcodec_extralibs="pthreads_extralibs iconv_extralibs dxva2_extralibs liblcevc_dec_extralibs lcms2_extralibs" + avfilter_extralibs="pthreads_extralibs" +-avutil_extralibs="d3d11va_extralibs d3d12va_extralibs mediacodec_extralibs nanosleep_extralibs pthreads_extralibs vaapi_drm_extralibs vaapi_x11_extralibs vaapi_win32_extralibs vdpau_x11_extralibs" ++avutil_extralibs="d3d11va_extralibs d3d12va_extralibs mediacodec_extralibs nanosleep_extralibs pthreads_extralibs v4l2_request_extralibs vaapi_drm_extralibs vaapi_x11_extralibs vaapi_win32_extralibs vdpau_x11_extralibs" + + # programs + ffmpeg_deps="avcodec avfilter avformat threads" +@@ -7662,6 +7663,8 @@ fi + + if enabled v4l2_request; then + check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns ++ check_pkg_config libudev libudev libudev.h udev_new ++ v4l2_request_extralibs="$libudev_extralibs" + fi + + check_headers sys/videoio.h +--- a/libavutil/hwcontext_v4l2request.c ++++ b/libavutil/hwcontext_v4l2request.c +@@ -26,6 +26,7 @@ + #include + + #include ++#include + + #include "avassert.h" + #include "hwcontext_drm.h" +@@ -33,7 +34,16 @@ + #include "hwcontext_v4l2request_internal.h" + #include "mem.h" + ++typedef struct V4L2RequestVideoDecoder { ++ dev_t media_dev; ++ dev_t video_dev; ++ uint32_t *pixelformats; ++ int nb_pixelformats; ++} V4L2RequestVideoDecoder; ++ + typedef struct V4L2RequestDeviceContext { ++ V4L2RequestVideoDecoder *decoders; ++ int nb_decoders; + } V4L2RequestDeviceContext; + + typedef struct V4L2RequestFramesContext { +@@ -138,25 +148,524 @@ static int v4l2request_set_drm_descripto + + static void v4l2request_device_uninit(AVHWDeviceContext *hwdev) + { ++ V4L2RequestDeviceContext *hwctx = hwdev->hwctx; ++ ++ av_freep(&hwctx->decoders); ++ hwctx->nb_decoders = 0; + } + + static int v4l2request_device_create(AVHWDeviceContext *hwdev, const char *device, + AVDictionary *opts, int flags) + { ++ V4L2RequestDeviceContext *hwctx = hwdev->hwctx; ++ ++ hwctx->decoders = NULL; ++ hwctx->nb_decoders = 0; ++ ++ // TODO: enumerate V4L2 Request API capable video decoders ++ // and fill hwctx->decoders and hwctx->nb_decoders, ++ // limit to decoders for the media 'device' when specified ++ ++ return 0; ++} ++ ++static int v4l2request_set_format(AVHWFramesContext *hwfc, ++ enum v4l2_buf_type type, ++ uint32_t pixelformat, ++ uint32_t buffersize) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct v4l2_format format = { ++ .type = type, ++ }; ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(type)) { ++ format.fmt.pix_mp.width = hwfc->width; ++ format.fmt.pix_mp.height = hwfc->height; ++ format.fmt.pix_mp.pixelformat = pixelformat; ++ format.fmt.pix_mp.plane_fmt[0].sizeimage = buffersize; ++ format.fmt.pix_mp.num_planes = 1; ++ } else { ++ format.fmt.pix.width = hwfc->width; ++ format.fmt.pix.height = hwfc->height; ++ format.fmt.pix.pixelformat = pixelformat; ++ format.fmt.pix.sizeimage = buffersize; ++ } ++ ++ if (ioctl(fctxi->video_fd, VIDIOC_S_FMT, &format) < 0) ++ return AVERROR(errno); ++ ++ return 0; ++} ++ ++static int v4l2request_select_capture_format(AVHWFramesContext *hwfc) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ enum v4l2_buf_type type = fctxi->capture.format.type; ++ uint32_t pixelformat, fallback = 0; ++ struct v4l2_format format = { ++ .type = type, ++ }; ++ struct v4l2_fmtdesc fmtdesc = { ++ .index = 0, ++ .type = type, ++ }; ++ ++ // Get the driver preferred (or default) format ++ if (ioctl(fctxi->video_fd, VIDIOC_G_FMT, &format) < 0) ++ return AVERROR(errno); ++ ++ pixelformat = V4L2_TYPE_IS_MULTIPLANAR(type) ? ++ format.fmt.pix_mp.pixelformat : ++ format.fmt.pix.pixelformat; ++ ++ // Try to use the driver preferred format when it is a known format ++ for (int i = 0; i < FF_ARRAY_ELEMS(v4l2request_capture_pixelformats); i++) { ++ if (pixelformat == v4l2request_capture_pixelformats[i].pixelformat && ++ (fctx->bit_depth == v4l2request_capture_pixelformats[i].bit_depth || ++ !fctx->bit_depth)) ++ return v4l2request_set_format(hwfc, type, pixelformat, 0); ++ } ++ ++ // Next try to use the first known format with matching bit depth ++ while (ioctl(fctxi->video_fd, VIDIOC_ENUM_FMT, &fmtdesc) >= 0) { ++ for (int i = 0; i < FF_ARRAY_ELEMS(v4l2request_capture_pixelformats); i++) { ++ if (fmtdesc.pixelformat == v4l2request_capture_pixelformats[i].pixelformat) { ++ if (fctx->bit_depth == v4l2request_capture_pixelformats[i].bit_depth || ++ !fctx->bit_depth) ++ return v4l2request_set_format(hwfc, type, fmtdesc.pixelformat, 0); ++ else if (!fallback) ++ fallback = fmtdesc.pixelformat; ++ } ++ } ++ ++ fmtdesc.index++; ++ } ++ ++ // Fallback to use the first known format ++ if (fallback) ++ return v4l2request_set_format(hwfc, type, fallback, 0); ++ ++ return AVERROR(errno); ++} ++ ++static int v4l2request_try_framesize(AVHWFramesContext *hwfc, ++ uint32_t pixelformat) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct v4l2_frmsizeenum frmsize = { ++ .index = 0, ++ .pixel_format = pixelformat, ++ }; ++ ++ // Enumerate and check if frame size is supported ++ while (ioctl(fctxi->video_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) >= 0) { ++ if (frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE && ++ hwfc->width == frmsize.discrete.width && ++ hwfc->height == frmsize.discrete.height) { ++ return 0; ++ } else if ((frmsize.type == V4L2_FRMSIZE_TYPE_STEPWISE || ++ frmsize.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) && ++ hwfc->width >= frmsize.stepwise.min_width && ++ hwfc->height >= frmsize.stepwise.min_height && ++ hwfc->width <= frmsize.stepwise.max_width && ++ hwfc->height <= frmsize.stepwise.max_height) { ++ return 0; ++ } ++ ++ frmsize.index++; ++ } ++ ++ return AVERROR(errno); ++} ++ ++static int v4l2request_try_format(AVHWFramesContext *hwfc, ++ enum v4l2_buf_type type, ++ uint32_t pixelformat) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct v4l2_fmtdesc fmtdesc = { ++ .index = 0, ++ .type = type, ++ }; ++ ++ // Enumerate and check if format is supported ++ while (ioctl(fctxi->video_fd, VIDIOC_ENUM_FMT, &fmtdesc) >= 0) { ++ if (fmtdesc.pixelformat == pixelformat) ++ return 0; ++ ++ fmtdesc.index++; ++ } ++ ++ return AVERROR(errno); ++} ++ ++static int v4l2request_set_controls(AVHWFramesContext *hwfc, ++ struct v4l2_ext_control *control, int count) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct v4l2_ext_controls controls = { ++ .controls = control, ++ .count = count, ++ }; ++ ++ if (!control || !count) ++ return 0; ++ ++ if (ioctl(fctxi->video_fd, VIDIOC_S_EXT_CTRLS, &controls) < 0) ++ return AVERROR(errno); ++ ++ return 0; ++} ++ ++static int v4l2request_probe_video_device(AVHWFramesContext *hwfc, ++ const char *path, ++ uint32_t pixelformat, ++ uint32_t buffersize) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct v4l2_capability capability; ++ struct v4l2_create_buffers buffers; ++ unsigned int capabilities; ++ int ret; ++ ++ /* ++ * Open video device in non-blocking mode to support decoding using ++ * multiple queued requests, required for e.g. multi stage decoding. ++ */ ++ fctxi->video_fd = open(path, O_RDWR | O_NONBLOCK); ++ if (fctxi->video_fd < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to open video device %s: %s (%d)\n", ++ path, strerror(errno), errno); ++ return ret; ++ } ++ ++ // Query capabilities of the video device ++ if (ioctl(fctxi->video_fd, VIDIOC_QUERYCAP, &capability) < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to query capabilities of %s: %s (%d)\n", ++ path, strerror(errno), errno); ++ goto fail; ++ } ++ ++ // Use device capabilities of the opened device when supported ++ capabilities = (capability.capabilities & V4L2_CAP_DEVICE_CAPS) ? ++ capability.device_caps : capability.capabilities; ++ ++ // Ensure streaming is supported on the video device ++ if ((capabilities & V4L2_CAP_STREAMING) != V4L2_CAP_STREAMING) { ++ ret = AVERROR(EINVAL); ++ av_log(hwfc, AV_LOG_VERBOSE, "Device %s is missing streaming capability\n", path); ++ goto fail; ++ } ++ ++ // Ensure multi- or single-planar API can be used ++ if ((capabilities & V4L2_CAP_VIDEO_M2M_MPLANE) == V4L2_CAP_VIDEO_M2M_MPLANE) { ++ fctxi->output.format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; ++ fctxi->capture.format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; ++ } else if ((capabilities & V4L2_CAP_VIDEO_M2M) == V4L2_CAP_VIDEO_M2M) { ++ fctxi->output.format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; ++ fctxi->capture.format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; ++ } else { ++ ret = AVERROR(EINVAL); ++ av_log(hwfc, AV_LOG_VERBOSE, "Device %s is missing mem2mem capability\n", path); ++ goto fail; ++ } ++ ++ // Query OUTPUT buffer capabilities ++ buffers = (struct v4l2_create_buffers) { ++ .count = 0, ++ .memory = V4L2_MEMORY_MMAP, ++ .format.type = fctxi->output.format.type, ++ }; ++ if (ioctl(fctxi->video_fd, VIDIOC_CREATE_BUFS, &buffers) < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, ++ "Failed to query OUTPUT buffer capabilities of %s: %s (%d)\n", ++ path, strerror(errno), errno); ++ goto fail; ++ } ++ fctxi->output.capabilities = buffers.capabilities; ++ ++ // Ensure requests can be used ++ if ((buffers.capabilities & V4L2_BUF_CAP_SUPPORTS_REQUESTS) != ++ V4L2_BUF_CAP_SUPPORTS_REQUESTS) { ++ ret = AVERROR(EINVAL); ++ av_log(hwfc, AV_LOG_VERBOSE, "Device %s is missing support for requests\n", path); ++ goto fail; ++ } ++ ++ // Ensure the codec pixelformat can be used ++ ret = v4l2request_try_format(hwfc, fctxi->output.format.type, pixelformat); ++ if (ret < 0) { ++ av_log(hwfc, AV_LOG_VERBOSE, "Device %s is missing support for pixelformat %s\n", ++ path, av_fourcc2str(pixelformat)); ++ goto fail; ++ } ++ ++ // Ensure frame size is supported, when driver support ENUM_FRAMESIZES ++ ret = v4l2request_try_framesize(hwfc, pixelformat); ++ if (ret < 0 && ret != AVERROR(ENOTTY)) { ++ av_log(hwfc, AV_LOG_VERBOSE, ++ "Device %s is missing support for frame size %dx%d of pixelformat %s\n", ++ path, hwfc->width, hwfc->height, av_fourcc2str(pixelformat)); ++ goto fail; ++ } ++ ++ // Set the codec pixelformat and OUTPUT buffersize to be used ++ ret = v4l2request_set_format(hwfc, fctxi->output.format.type, pixelformat, buffersize); ++ if (ret < 0) { ++ av_log(hwfc, AV_LOG_ERROR, ++ "Failed to set OUTPUT pixelformat %s of %s: %s (%d)\n", ++ av_fourcc2str(pixelformat), path, strerror(errno), errno); ++ goto fail; ++ } ++ ++ // Get format details for OUTPUT buffers ++ if (ioctl(fctxi->video_fd, VIDIOC_G_FMT, &fctxi->output.format) < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to get OUTPUT format: %s (%d)\n", ++ strerror(errno), errno); ++ goto fail; ++ } ++ ++ /* ++ * Set any codec specific controls that can help assist the driver ++ * make a decision on what CAPTURE buffer format can be used. ++ */ ++ ret = v4l2request_set_controls(hwfc, fctx->init_controls, fctx->nb_init_controls); ++ if (ret < 0) { ++ av_log(hwfc, AV_LOG_VERBOSE, ++ "Failed to set %d control(s): %s (%d)\n", ++ fctx->nb_init_controls, strerror(errno), errno); ++ goto fail; ++ } ++ ++ // Select a supported CAPTURE buffer format ++ ret = v4l2request_select_capture_format(hwfc); ++ if (ret < 0) { ++ av_log(hwfc, AV_LOG_VERBOSE, ++ "Failed to select a CAPTURE format %s of %s: %s (%d)\n", ++ av_fourcc2str(pixelformat), path, strerror(errno), errno); ++ goto fail; ++ } ++ ++ // Query CAPTURE buffer capabilities ++ buffers = (struct v4l2_create_buffers) { ++ .count = 0, ++ .memory = V4L2_MEMORY_MMAP, ++ .format.type = fctxi->capture.format.type, ++ }; ++ if (ioctl(fctxi->video_fd, VIDIOC_CREATE_BUFS, &buffers) < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, ++ "Failed to query CAPTURE buffer capabilities of %s: %s (%d)\n", ++ path, strerror(errno), errno); ++ goto fail; ++ } ++ fctxi->capture.capabilities = buffers.capabilities; ++ ++ // Get format details for CAPTURE buffers ++ if (ioctl(fctxi->video_fd, VIDIOC_G_FMT, &fctxi->capture.format) < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to get CAPTURE format: %s (%d)\n", ++ strerror(errno), errno); ++ goto fail; ++ } ++ ++ // All tests passed, video device should be capable + return 0; ++ ++fail: ++ if (fctxi->video_fd >= 0) { ++ close(fctxi->video_fd); ++ fctxi->video_fd = -1; ++ } ++ return ret; ++} ++ ++static int v4l2request_probe_video_devices(AVHWFramesContext *hwfc, ++ struct udev *udev, ++ uint32_t pixelformat, ++ uint32_t buffersize) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ struct media_device_info device_info; ++ struct media_v2_topology topology = {0}; ++ struct media_v2_interface *interfaces; ++ struct udev_device *device; ++ const char *path; ++ dev_t devnum; ++ int ret; ++ ++ if (ioctl(fctxi->media_fd, MEDIA_IOC_DEVICE_INFO, &device_info) < 0) ++ return AVERROR(errno); ++ ++ if (ioctl(fctxi->media_fd, MEDIA_IOC_G_TOPOLOGY, &topology) < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to get media topology: %s (%d)\n", ++ strerror(errno), errno); ++ return ret; ++ } ++ ++ if (!topology.num_interfaces) ++ return AVERROR(ENOENT); ++ ++ interfaces = av_calloc(topology.num_interfaces, sizeof(struct media_v2_interface)); ++ if (!interfaces) ++ return AVERROR(ENOMEM); ++ ++ topology.ptr_interfaces = (__u64)(uintptr_t)interfaces; ++ if (ioctl(fctxi->media_fd, MEDIA_IOC_G_TOPOLOGY, &topology) < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to get media topology: %s (%d)\n", ++ strerror(errno), errno); ++ goto fail; ++ } ++ ++ ret = AVERROR(ENOENT); ++ for (int i = 0; i < topology.num_interfaces; i++) { ++ if (interfaces[i].intf_type != MEDIA_INTF_T_V4L_VIDEO) ++ continue; ++ ++ devnum = makedev(interfaces[i].devnode.major, interfaces[i].devnode.minor); ++ device = udev_device_new_from_devnum(udev, 'c', devnum); ++ if (!device) ++ continue; ++ ++ path = udev_device_get_devnode(device); ++ if (path) ++ ret = v4l2request_probe_video_device(hwfc, path, pixelformat, buffersize); ++ udev_device_unref(device); ++ ++ // Stop when we have found a capable video device ++ if (!ret) { ++ av_log(hwfc, AV_LOG_INFO, ++ "Using V4L2 media driver %s (%u.%u.%u) for %s\n", ++ device_info.driver, ++ device_info.driver_version >> 16, ++ (device_info.driver_version >> 8) & 0xff, ++ device_info.driver_version & 0xff, ++ av_fourcc2str(pixelformat)); ++ break; ++ } ++ } ++ ++fail: ++ av_free(interfaces); ++ return ret; ++} ++ ++static int v4l2request_probe_media_device(AVHWFramesContext *hwfc, ++ struct udev_device *device, ++ uint32_t pixelformat, ++ uint32_t buffersize) ++{ ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ AVV4L2RequestFramesContextInternal *fctxi = fctx->internal; ++ const char *path; ++ int ret; ++ ++ path = udev_device_get_devnode(device); ++ if (!path) ++ return AVERROR(ENODEV); ++ ++ // Open enumerated media device ++ fctxi->media_fd = open(path, O_RDWR); ++ if (fctxi->media_fd < 0) { ++ ret = AVERROR(errno); ++ av_log(hwfc, AV_LOG_ERROR, "Failed to open media device %s: %s (%d)\n", ++ path, strerror(errno), errno); ++ return ret; ++ } ++ ++ // Probe video devices of current media device ++ ret = v4l2request_probe_video_devices(hwfc, udev_device_get_udev(device), ++ pixelformat, buffersize); ++ ++ // Cleanup when no capable video device was found ++ if (ret < 0) { ++ close(fctxi->media_fd); ++ fctxi->media_fd = -1; ++ } ++ ++ return ret; ++} ++ ++static int v4l2request_probe_media_devices(AVHWFramesContext *hwfc, ++ struct udev *udev, ++ uint32_t pixelformat, ++ uint32_t buffersize) ++{ ++ struct udev_enumerate *enumerate; ++ struct udev_list_entry *devices; ++ struct udev_list_entry *entry; ++ struct udev_device *device; ++ int ret; ++ ++ enumerate = udev_enumerate_new(udev); ++ if (!enumerate) ++ return AVERROR(ENOMEM); ++ ++ udev_enumerate_add_match_subsystem(enumerate, "media"); ++ udev_enumerate_scan_devices(enumerate); ++ devices = udev_enumerate_get_list_entry(enumerate); ++ ++ ret = AVERROR(ENOENT); ++ udev_list_entry_foreach(entry, devices) { ++ const char *path = udev_list_entry_get_name(entry); ++ if (!path) ++ continue; ++ ++ device = udev_device_new_from_syspath(udev, path); ++ if (!device) ++ continue; ++ ++ // Probe media device for a capable video device ++ ret = v4l2request_probe_media_device(hwfc, device, pixelformat, buffersize); ++ udev_device_unref(device); ++ ++ // Stop when we have found a capable media and video device ++ if (!ret) ++ break; ++ } ++ ++ udev_enumerate_unref(enumerate); ++ return ret; + } + + static int v4l2request_open_decoder(AVHWFramesContext *hwfc) + { + AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ uint32_t buffersize; ++ struct udev *udev; ++ int ret; + + // Ensure codec pixelformat is set + if (!fctx->pixelformat) + return AVERROR(EINVAL); + +- // TODO: locate a decoder supporting the requested pixelformat ++ // FIXME: locate a decoder using hwdevice context decoders ++ ++ udev = udev_new(); ++ if (!udev) ++ return AVERROR(ENOMEM); ++ ++ buffersize = FFMAX(hwfc->width * hwfc->height * 3 / 2, 256 * 1024); ++ ++ // Probe all media devices (auto-detection) ++ ret = v4l2request_probe_media_devices(hwfc, udev, fctx->pixelformat, buffersize); + +- return AVERROR(ENOSYS); ++ udev_unref(udev); ++ return ret; + } + + static AVBufferRef *v4l2request_v4l2_buffer_alloc(AVHWFramesContext *hwfc, diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-03.patch b/multimedia/ffmpeg/patches/120-v4l2-request-03.patch new file mode 100644 index 000000000..20c086e63 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-03.patch @@ -0,0 +1,371 @@ +From 9a5d025a873145afc16fea3078ae3410d2291280 Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Tue, 6 Aug 2024 09:06:01 +0000 +Subject: [PATCH 03/13] avcodec: Add common V4L2 Request API code + +Add initial helpers for supporting V4L2 Request API hwaccels. + +Basic flow for initialization follows the kernel Memory-to-memory +Stateless Video Decoder Interface > Initialization [1]. + +In init a hw frame ctx is created and initialized to start a new V4L2 +video decoding session, initial CAPTURE buffers is pre-allocated, +OUTPUT buffers and request objects are allocated for a circular queue. + +In frame_params the codec pixel format and optional codec-specific +extended controls is configured before the hw frame ctx is initialized. + +In uninit any pending request is flushed before resources are released. + +[1] https://www.kernel.org/doc/html/latest/userspace-api/media/v4l/dev-stateless-decoder.html#initialization + +Co-developed-by: Jernej Skrabec +Signed-off-by: Jernej Skrabec +Co-developed-by: Alex Bee +Signed-off-by: Alex Bee +Signed-off-by: Jonas Karlman +--- + libavcodec/Makefile | 2 + + libavcodec/v4l2_request.c | 249 ++++++++++++++++++++++++++++++++++++++ + libavcodec/v4l2_request.h | 64 ++++++++++ + 3 files changed, 315 insertions(+) + create mode 100644 libavcodec/v4l2_request.c + create mode 100644 libavcodec/v4l2_request.h + +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -185,6 +185,7 @@ OBJS-$(CONFIG_VIDEODSP) + + OBJS-$(CONFIG_VP3DSP) += vp3dsp.o + OBJS-$(CONFIG_VP8DSP) += vp8dsp.o + OBJS-$(CONFIG_V4L2_M2M) += v4l2_m2m.o v4l2_context.o v4l2_buffers.o v4l2_fmt.o ++OBJS-$(CONFIG_V4L2_REQUEST) += v4l2_request.o + OBJS-$(CONFIG_WMA_FREQS) += wma_freqs.o + OBJS-$(CONFIG_WMV2DSP) += wmv2dsp.o + +@@ -1357,6 +1358,7 @@ SKIPHEADERS-$(CONFIG_VIDEOTOOLBOX) + + SKIPHEADERS-$(CONFIG_VULKAN) += ffv1_vulkan.h prores_vulkan.h vulkan_video.h \ + vulkan_encode.h vulkan_decode.h + SKIPHEADERS-$(CONFIG_V4L2_M2M) += v4l2_buffers.h v4l2_context.h v4l2_m2m.h ++SKIPHEADERS-$(CONFIG_V4L2_REQUEST) += v4l2_request.h + SKIPHEADERS-$(CONFIG_ZLIB) += zlib_wrapper.h + + TESTPROGS = avcodec \ +--- /dev/null ++++ b/libavcodec/v4l2_request.c +@@ -0,0 +1,249 @@ ++/* ++ * 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 "config.h" ++ ++#include ++#include ++#include ++#include ++ ++#include "libavutil/hwcontext_v4l2request_internal.h" ++#include "libavutil/mem.h" ++#include "decode.h" ++#include "internal.h" ++#include "v4l2_request.h" ++ ++static const AVClass v4l2_request_context_class = { ++ .class_name = "V4L2RequestContext", ++ .item_name = av_default_item_name, ++ .version = LIBAVUTIL_VERSION_INT, ++}; ++ ++static inline V4L2RequestContext *v4l2_request_context(AVCodecContext *avctx) ++{ ++ return (V4L2RequestContext *)avctx->internal->hwaccel_priv_data; ++} ++ ++static void v4l2_request_output_buffer_uninit(V4L2RequestOutputBuffer *output) ++{ ++ // Close the request associated with the OUTPUT buffer ++ if (output->request_fd >= 0) { ++ close(output->request_fd); ++ output->request_fd = -1; ++ } ++ ++ // Umap the OUTPUT buffer memory ++ if (output->addr) { ++ munmap(output->addr, output->size); ++ output->addr = NULL; ++ } ++ ++ // Return the OUTPUT buffer to the frames context OUTPUT pool ++ av_buffer_unref(&output->ref); ++} ++ ++static int v4l2_request_output_buffer_init(V4L2RequestContext *ctx, ++ V4L2RequestOutputBuffer *output) ++{ ++ struct v4l2_format *format = &ctx->fctxi->output.format; ++ struct v4l2_buffer *buffer; ++ off_t offset; ++ void *addr; ++ int ret; ++ ++ // Get an OUTPUT buffer from frames context OUTPUT pool ++ output->ref = av_buffer_pool_get(ctx->fctxi->output.pool); ++ if (!output->ref) ++ return AVERROR(ENOMEM); ++ ++ buffer = (struct v4l2_buffer *)output->ref->data; ++ output->index = buffer->index; ++ output->size = V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.plane_fmt[0].sizeimage : ++ format->fmt.pix.sizeimage; ++ output->bytesused = 0; ++ ++ // Map the OUTPUT buffer memory, raw bitstream data is written into it ++ offset = V4L2_TYPE_IS_MULTIPLANAR(buffer->type) ? ++ buffer->m.planes[0].m.mem_offset : ++ buffer->m.offset; ++ addr = mmap(NULL, output->size, PROT_READ | PROT_WRITE, MAP_SHARED, ++ ctx->fctxi->video_fd, offset); ++ if (addr == MAP_FAILED) { ++ ret = AVERROR(errno); ++ av_log(ctx, AV_LOG_ERROR, "Failed to map OUTPUT buffer %d: %s (%d)\n", ++ output->index, strerror(errno), errno); ++ goto fail; ++ } ++ output->addr = addr; ++ ++ // Allocate and associated a request for the OUTPUT buffer ++ if (ioctl(ctx->fctxi->media_fd, MEDIA_IOC_REQUEST_ALLOC, &output->request_fd) < 0) { ++ ret = AVERROR(errno); ++ av_log(ctx, AV_LOG_ERROR, "Failed to allocate request for OUTPUT buffer %d: %s (%d)\n", ++ output->index, strerror(errno), errno); ++ goto fail; ++ } ++ ++ return 0; ++ ++fail: ++ v4l2_request_output_buffer_uninit(output); ++ return ret; ++} ++ ++int ff_v4l2_request_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx, ++ uint32_t pixelformat, ++ uint8_t bit_depth) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ AVHWFramesContext *hwfc = (AVHWFramesContext *)hw_frames_ctx->data; ++ AVV4L2RequestFramesContext *fctx = hwfc->hwctx; ++ ++ // Set parameters used during frames context initialization ++ fctx->pixelformat = pixelformat; ++ fctx->bit_depth = bit_depth; ++ if (ctx) { ++ fctx->init_controls = ctx->init_controls; ++ fctx->nb_init_controls = ctx->nb_init_controls; ++ } ++ ++ hwfc->format = AV_PIX_FMT_DRM_PRIME; ++ hwfc->sw_format = AV_PIX_FMT_NONE; ++ hwfc->width = avctx->coded_width; ++ hwfc->height = avctx->coded_height; ++ ++ // Pre-allocate CAPTURE buffers to ensure CAPTURE queue can be started ++ hwfc->initial_pool_size = 1; ++ ++ return 0; ++} ++ ++int ff_v4l2_request_uninit(AVCodecContext *avctx) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ enum v4l2_buf_type type; ++ ++ if (ctx->fctxi) { ++ // TODO: Flush and wait on all pending requests ++ ++ // Stop streaming on OUTPUT queue ++ type = ctx->fctxi->output.format.type; ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_STREAMOFF, &type) < 0) ++ av_log(ctx, AV_LOG_WARNING, "Failed to stop OUTPUT streaming: %s (%d)\n", ++ strerror(errno), errno); ++ ++ // Stop streaming on CAPTURE queue ++ type = ctx->fctxi->capture.format.type; ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_STREAMOFF, &type) < 0) ++ av_log(ctx, AV_LOG_WARNING, "Failed to stop CAPTURE streaming: %s (%d)\n", ++ strerror(errno), errno); ++ ++ // Release OUTPUT buffers and requests ++ for (int i = 0; i < FF_ARRAY_ELEMS(ctx->output); i++) ++ v4l2_request_output_buffer_uninit(&ctx->output[i]); ++ ++ ctx->fctxi = NULL; ++ } ++ ++ av_buffer_unref(&ctx->frames_ref); ++ ff_mutex_destroy(&ctx->mutex); ++ ++ return 0; ++} ++ ++int ff_v4l2_request_init(AVCodecContext *avctx, ++ struct v4l2_ext_control *control, int count, ++ int (*post_frames_ctx)(AVCodecContext *avctx)) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ AVHWFramesContext *hwfc; ++ AVV4L2RequestFramesContext *fctx; ++ enum v4l2_buf_type type; ++ int ret; ++ ++ // Set initial default values ++ ctx->av_class = &v4l2_request_context_class; ++ ctx->init_controls = control; ++ ctx->nb_init_controls = count; ++ ff_mutex_init(&ctx->mutex, NULL); ++ for (int i = 0; i < FF_ARRAY_ELEMS(ctx->output); i++) { ++ ctx->output[i].index = i; ++ ctx->output[i].request_fd = -1; ++ } ++ ++ // Create frames context and allocate initial CAPTURE buffers ++ ret = ff_decode_get_hw_frames_ctx(avctx, AV_HWDEVICE_TYPE_V4L2REQUEST); ++ if (ret < 0) ++ goto fail; ++ ++ ctx->frames_ref = av_buffer_ref(avctx->hw_frames_ctx); ++ if (!ctx->frames_ref) { ++ ret = AVERROR(ENOMEM); ++ goto fail; ++ } ++ ++ // Get internal hwctx from frames context ++ hwfc = (AVHWFramesContext *)ctx->frames_ref->data; ++ fctx = hwfc->hwctx; ++ ctx->fctxi = fctx->internal; ++ ++ // Reset init controls after successful frames context initialization ++ ctx->init_controls = NULL; ++ ctx->nb_init_controls = 0; ++ ++ // Check codec-specific controls, e.g. profile and level ++ if (post_frames_ctx) { ++ ret = post_frames_ctx(avctx); ++ if (ret < 0) ++ goto fail; ++ } ++ ++ // Allocate OUTPUT buffers and requests for circular queue ++ for (int i = 0; i < FF_ARRAY_ELEMS(ctx->output); i++) { ++ ret = v4l2_request_output_buffer_init(ctx, &ctx->output[i]); ++ if (ret < 0) ++ goto fail; ++ } ++ ++ // Start streaming on OUTPUT queue ++ type = ctx->fctxi->output.format.type; ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_STREAMON, &type) < 0) { ++ ret = AVERROR(errno); ++ av_log(ctx, AV_LOG_ERROR, "Failed to start OUTPUT streaming: %s (%d)\n", ++ strerror(errno), errno); ++ goto fail; ++ } ++ ++ // Start streaming on CAPTURE queue ++ type = ctx->fctxi->capture.format.type; ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_STREAMON, &type) < 0) { ++ ret = AVERROR(errno); ++ av_log(ctx, AV_LOG_ERROR, "Failed to start CAPTURE streaming: %s (%d)\n", ++ strerror(errno), errno); ++ goto fail; ++ } ++ ++ return 0; ++ ++fail: ++ ff_v4l2_request_uninit(avctx); ++ return ret; ++} +--- /dev/null ++++ b/libavcodec/v4l2_request.h +@@ -0,0 +1,64 @@ ++/* ++ * 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_REQUEST_H ++#define AVCODEC_V4L2_REQUEST_H ++ ++#include ++#include ++#include ++ ++#include "libavutil/buffer.h" ++#include "libavutil/log.h" ++#include "libavutil/thread.h" ++#include "avcodec.h" ++ ++typedef struct AVV4L2RequestFramesContextInternal AVV4L2RequestFramesContextInternal; ++ ++typedef struct V4L2RequestOutputBuffer { ++ AVBufferRef *ref; ++ uint32_t index; ++ int request_fd; ++ uint8_t *addr; ++ uint32_t size; ++ uint32_t bytesused; ++ struct timeval timestamp; ++} V4L2RequestOutputBuffer; ++ ++typedef struct V4L2RequestContext { ++ const AVClass *av_class; ++ AVBufferRef *frames_ref; ++ AVV4L2RequestFramesContextInternal *fctxi; ++ AVMutex mutex; ++ V4L2RequestOutputBuffer output[4]; ++ struct v4l2_ext_control *init_controls; ++ int nb_init_controls; ++} V4L2RequestContext; ++ ++int ff_v4l2_request_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx, ++ uint32_t pixelformat, ++ uint8_t bit_depth); ++ ++int ff_v4l2_request_uninit(AVCodecContext *avctx); ++ ++int ff_v4l2_request_init(AVCodecContext *avctx, ++ struct v4l2_ext_control *control, int count, ++ int (*post_frames_ctx)(AVCodecContext *avctx)); ++ ++#endif /* AVCODEC_V4L2_REQUEST_H */ diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-04.patch b/multimedia/ffmpeg/patches/120-v4l2-request-04.patch new file mode 100644 index 000000000..986495d63 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-04.patch @@ -0,0 +1,696 @@ +From f227da5a137d45d44d37e1d2be6427e9f7c247b3 Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Tue, 6 Aug 2024 09:06:03 +0000 +Subject: [PATCH 04/13] avcodec/v4l2request: Add common decode support for + hwaccels + +Add common support for decoding using the V4L2 Request API. + +Basic flow for decoding follows the kernel Memory-to-memory Stateless +Video Decoder Interface > Decoding [1]. + +A codec hwaccel typically handle decoding as follow: + +In start_frame next OUTPUT buffer and its related request object is +picked from a circular queue and any codec specific CONTROLs are +prepared. + +In decode_slice the slice bitstream data is appended to the OUTPUT +buffer. + +In end_frame a CAPTURE buffer tied to the AVFrame is queued, it will be +used as the decoding target by the driver / hw decoder. The prepared +codec specific CONTROLs are queued as part of the request object. +Finally, the request object is submitted for decoding. + +In post_process the AVFrame is only returned once the CAPTURE buffer +tied to the AVFrame has been made available for dequeuing by the driver. + +For slice based hw decoders only the request for the final slice of the +frame is submitted in end_frame, remaining is submitted in decode_slice. + +[1] https://www.kernel.org/doc/html/latest/userspace-api/media/v4l/dev-stateless-decoder.html#decoding + +Co-developed-by: Jernej Skrabec +Signed-off-by: Jernej Skrabec +Co-developed-by: Alex Bee +Signed-off-by: Alex Bee +Signed-off-by: Jonas Karlman +--- + configure | 3 +- + libavcodec/hwconfig.h | 2 + + libavcodec/v4l2_request.c | 537 +++++++++++++++++++++++++++++++++++++- + libavcodec/v4l2_request.h | 41 +++ + 4 files changed, 581 insertions(+), 2 deletions(-) + +--- a/configure ++++ b/configure +@@ -3403,7 +3403,7 @@ dxva2_deps="dxva2api_h DXVA2_ConfigPictu + ffnvcodec_deps_any="libdl LoadLibrary" + mediacodec_deps="android mediandk pthreads" + nvdec_deps="ffnvcodec" +-v4l2_request_deps="linux_media_h v4l2_timeval_to_ns libdrm libudev" ++v4l2_request_deps="linux_media_h v4l2_timeval_to_ns v4l2_m2m_hold_capture_buf libdrm libudev" + v4l2_request_suggest="libdrm libudev" + vaapi_x11_deps="xlib_x11" + videotoolbox_hwaccel_deps="videotoolbox pthreads" +@@ -7662,6 +7662,7 @@ if enabled v4l2_m2m; then + fi + + if enabled v4l2_request; then ++ check_cc v4l2_m2m_hold_capture_buf linux/videodev2.h "int i = V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF" + check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns + check_pkg_config libudev libudev libudev.h udev_new + v4l2_request_extralibs="$libudev_extralibs" +--- a/libavcodec/hwconfig.h ++++ b/libavcodec/hwconfig.h +@@ -79,6 +79,8 @@ void ff_hwaccel_uninit(AVCodecContext *a + HW_CONFIG_HWACCEL(0, 0, 1, D3D11VA_VLD, NONE, ff_ ## codec ## _d3d11va_hwaccel) + #define HWACCEL_D3D12VA(codec) \ + HW_CONFIG_HWACCEL(1, 1, 0, D3D12, D3D12VA, ff_ ## codec ## _d3d12va_hwaccel) ++#define HWACCEL_V4L2REQUEST(codec) \ ++ HW_CONFIG_HWACCEL(1, 0, 0, DRM_PRIME, V4L2REQUEST, ff_ ## codec ## _v4l2request_hwaccel) + + #define HW_CONFIG_ENCODER(device, frames, ad_hoc, format, device_type_) \ + &(const AVCodecHWConfigInternal) { \ +--- a/libavcodec/v4l2_request.c ++++ b/libavcodec/v4l2_request.c +@@ -19,6 +19,7 @@ + #include "config.h" + + #include ++#include + #include + #include + #include +@@ -29,6 +30,8 @@ + #include "internal.h" + #include "v4l2_request.h" + ++#define V4L2_PLANES_MAX 2 ++ + static const AVClass v4l2_request_context_class = { + .class_name = "V4L2RequestContext", + .item_name = av_default_item_name, +@@ -40,6 +43,537 @@ static inline V4L2RequestContext *v4l2_r + return (V4L2RequestContext *)avctx->internal->hwaccel_priv_data; + } + ++static inline uint32_t v4l2_request_frameindex(AVFrame *frame) ++{ ++ return (uint32_t)(uintptr_t)frame->data[1]; ++} ++ ++uint64_t ff_v4l2_request_get_capture_timestamp(AVFrame *frame) ++{ ++ /* ++ * The CAPTURE buffer index is used as a base for V4L2 frame reference. ++ * This works because frames are decoded into a CAPTURE buffer that is ++ * closely tied to an AVFrame. ++ */ ++ struct timeval timestamp = { ++ .tv_sec = 0, ++ .tv_usec = v4l2_request_frameindex(frame) + 1, ++ }; ++ return v4l2_timeval_to_ns(×tamp); ++} ++ ++int ff_v4l2_request_query_control(AVCodecContext *avctx, ++ struct v4l2_query_ext_ctrl *control) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_QUERY_EXT_CTRL, control) < 0) { ++ int ret = AVERROR(errno); ++ // Skip error logging when driver does not support control id (EINVAL) ++ if (errno != EINVAL) ++ av_log(ctx, AV_LOG_ERROR, "Failed to query control %u: %s (%d)\n", ++ control->id, strerror(errno), errno); ++ return ret; ++ } ++ ++ return 0; ++} ++ ++int ff_v4l2_request_query_control_default_value(AVCodecContext *avctx, ++ uint32_t id) ++{ ++ struct v4l2_query_ext_ctrl control = { ++ .id = id, ++ }; ++ int ret; ++ ++ ret = ff_v4l2_request_query_control(avctx, &control); ++ if (ret < 0) ++ return ret; ++ ++ return control.default_value; ++} ++ ++static int v4l2_request_set_controls(V4L2RequestContext *ctx, int request_fd, ++ struct v4l2_ext_control *control, int count) ++{ ++ struct v4l2_ext_controls controls = { ++ .controls = control, ++ .count = count, ++ .request_fd = request_fd, ++ .which = (request_fd >= 0) ? V4L2_CTRL_WHICH_REQUEST_VAL : 0, ++ }; ++ ++ if (!control || !count) ++ return 0; ++ ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_S_EXT_CTRLS, &controls) < 0) ++ return AVERROR(errno); ++ ++ return 0; ++} ++ ++int ff_v4l2_request_set_controls(AVCodecContext *avctx, ++ struct v4l2_ext_control *control, int count) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ int ret; ++ ++ ret = v4l2_request_set_controls(ctx, -1, control, count); ++ if (ret < 0) ++ av_log(ctx, AV_LOG_ERROR, "Failed to set %d control(s): %s (%d)\n", ++ count, strerror(errno), errno); ++ ++ return ret; ++} ++ ++static int v4l2_request_queue_buffer(V4L2RequestContext *ctx, ++ struct v4l2_buffer *buffer) ++{ ++ struct v4l2_plane planes[V4L2_PLANES_MAX] = {}; ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(buffer->type)) { ++ planes[0].bytesused = buffer->bytesused; ++ buffer->bytesused = 0; ++ buffer->length = FF_ARRAY_ELEMS(planes); ++ buffer->m.planes = planes; ++ } ++ ++ // Queue the buffer ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_QBUF, buffer) < 0) ++ return AVERROR(errno); ++ ++ // Mark the buffer as queued ++ if (V4L2_TYPE_IS_OUTPUT(buffer->type)) ++ ctx->queued_output |= 1 << buffer->index; ++ else ++ ctx->queued_capture |= 1 << buffer->index; ++ ++ return 0; ++} ++ ++static int v4l2_request_queue_capture_buffer(V4L2RequestContext *ctx, ++ uint32_t index) ++{ ++ struct v4l2_buffer buffer = { ++ .index = index, ++ .type = ctx->fctxi->capture.format.type, ++ .memory = V4L2_MEMORY_MMAP, ++ }; ++ return v4l2_request_queue_buffer(ctx, &buffer); ++} ++ ++static int v4l2_request_queue_output_buffer(V4L2RequestContext *ctx, ++ V4L2RequestOutputBuffer *output, ++ uint32_t flags) ++{ ++ struct v4l2_buffer buffer = { ++ .index = output->index, ++ .type = ctx->fctxi->output.format.type, ++ .memory = V4L2_MEMORY_MMAP, ++ .timestamp = output->timestamp, ++ .bytesused = output->bytesused, ++ .request_fd = output->request_fd, ++ .flags = V4L2_BUF_FLAG_REQUEST_FD | flags, ++ }; ++ return v4l2_request_queue_buffer(ctx, &buffer); ++} ++ ++static int v4l2_request_dequeue_buffer(V4L2RequestContext *ctx, ++ enum v4l2_buf_type type) ++{ ++ struct v4l2_plane planes[V4L2_PLANES_MAX] = {}; ++ struct v4l2_buffer buffer = { ++ .type = type, ++ .memory = V4L2_MEMORY_MMAP, ++ }; ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(buffer.type)) { ++ buffer.length = FF_ARRAY_ELEMS(planes); ++ buffer.m.planes = planes; ++ } ++ ++ // Dequeue next completed buffer ++ if (ioctl(ctx->fctxi->video_fd, VIDIOC_DQBUF, &buffer) < 0) ++ return AVERROR(errno); ++ ++ // Mark the buffer as dequeued ++ if (V4L2_TYPE_IS_OUTPUT(buffer.type)) ++ ctx->queued_output &= ~(1 << buffer.index); ++ else ++ ctx->queued_capture &= ~(1 << buffer.index); ++ ++ return 0; ++} ++ ++static inline int v4l2_request_dequeue_completed_buffers(V4L2RequestContext *ctx, ++ enum v4l2_buf_type type) ++{ ++ int ret; ++ ++ do { ++ ret = v4l2_request_dequeue_buffer(ctx, type); ++ } while (!ret); ++ ++ return ret; ++} ++ ++static int v4l2_request_wait_on_capture(V4L2RequestContext *ctx, uint32_t index) ++{ ++ enum v4l2_buf_type type = ctx->fctxi->capture.format.type; ++ struct pollfd pollfd = { ++ .fd = ctx->fctxi->video_fd, ++ .events = POLLIN, ++ }; ++ ++ ff_mutex_lock(&ctx->mutex); ++ ++ // Dequeue all completed CAPTURE buffers ++ if (ctx->queued_capture) ++ v4l2_request_dequeue_completed_buffers(ctx, type); ++ ++ // Wait on the specific CAPTURE buffer ++ while (ctx->queued_capture & (1 << index)) { ++ int ret = poll(&pollfd, 1, 2000); ++ if (ret <= 0) ++ goto fail; ++ ++ ret = v4l2_request_dequeue_buffer(ctx, type); ++ if (ret < 0 && ret != AVERROR(EAGAIN)) ++ goto fail; ++ } ++ ++ ff_mutex_unlock(&ctx->mutex); ++ return 0; ++ ++fail: ++ ff_mutex_unlock(&ctx->mutex); ++ av_log(ctx, AV_LOG_ERROR, "Failed waiting on CAPTURE buffer %d\n", index); ++ return AVERROR(EINVAL); ++} ++ ++static V4L2RequestOutputBuffer *v4l2_request_next_output(V4L2RequestContext *ctx) ++{ ++ enum v4l2_buf_type type = ctx->fctxi->output.format.type; ++ V4L2RequestOutputBuffer *output; ++ struct pollfd pollfd = { ++ .fd = ctx->fctxi->video_fd, ++ .events = POLLOUT, ++ }; ++ uint8_t index; ++ ++ ff_mutex_lock(&ctx->mutex); ++ ++ // Use next OUTPUT buffer in the circular queue ++ index = ctx->next_output; ++ output = &ctx->output[index]; ++ ctx->next_output = (index + 1) % FF_ARRAY_ELEMS(ctx->output); ++ ++ // Dequeue all completed OUTPUT buffers ++ if (ctx->queued_output) ++ v4l2_request_dequeue_completed_buffers(ctx, type); ++ ++ // Wait on the specific OUTPUT buffer ++ while (ctx->queued_output & (1 << output->index)) { ++ int ret = poll(&pollfd, 1, 2000); ++ if (ret <= 0) ++ goto fail; ++ ++ ret = v4l2_request_dequeue_buffer(ctx, type); ++ if (ret < 0 && ret != AVERROR(EAGAIN)) ++ goto fail; ++ } ++ ++ ff_mutex_unlock(&ctx->mutex); ++ ++ // Reset bytesused state ++ output->bytesused = 0; ++ ++ return output; ++ ++fail: ++ ff_mutex_unlock(&ctx->mutex); ++ av_log(ctx, AV_LOG_ERROR, "Failed waiting on OUTPUT buffer %d\n", ++ output->index); ++ return NULL; ++} ++ ++static int v4l2_request_wait_on_request(V4L2RequestContext *ctx, ++ V4L2RequestOutputBuffer *output) ++{ ++ struct pollfd pollfd = { ++ .fd = output->request_fd, ++ .events = POLLPRI, ++ }; ++ ++ // Wait on the specific request to complete ++ while (ctx->queued_request & (1 << output->index)) { ++ int ret = poll(&pollfd, 1, 2000); ++ if (ret <= 0) ++ break; ++ ++ // Mark request as dequeued ++ if (pollfd.revents & (POLLPRI | POLLERR)) { ++ ctx->queued_request &= ~(1 << output->index); ++ break; ++ } ++ } ++ ++ // Reinit the request object ++ if (ioctl(output->request_fd, MEDIA_REQUEST_IOC_REINIT) < 0) { ++ int ret = AVERROR(errno); ++ av_log(ctx, AV_LOG_ERROR, "Failed to reinit request object %d: %s (%d)\n", ++ output->request_fd, strerror(errno), errno); ++ return ret; ++ } ++ ++ // Ensure request is marked as dequeued ++ ctx->queued_request &= ~(1 << output->index); ++ ++ return 0; ++} ++ ++int ff_v4l2_request_append_output(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ const uint8_t *data, uint32_t size) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ ++ // Append data to OUTPUT buffer and ensure there is enough space for padding ++ if (pic->output->bytesused + size + AV_INPUT_BUFFER_PADDING_SIZE <= pic->output->size) { ++ memcpy(pic->output->addr + pic->output->bytesused, data, size); ++ pic->output->bytesused += size; ++ return 0; ++ } else { ++ av_log(ctx, AV_LOG_ERROR, ++ "Failed to append %u bytes data to OUTPUT buffer %d (%u of %u used)\n", ++ size, pic->output->index, pic->output->bytesused, pic->output->size); ++ return AVERROR(ENOMEM); ++ } ++} ++ ++static int v4l2_request_queue_decode(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ struct v4l2_ext_control *control, int count, ++ bool first_slice, bool last_slice) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ uint32_t flags; ++ int ret; ++ ++ if (first_slice) { ++ /* ++ * Wait on dequeue of the target CAPTURE buffer. Otherwise V4L2 decoder ++ * may use a different CAPTURE buffer than hwaccel expects. ++ * ++ * Normally decoding has already completed when a CAPTURE buffer is ++ * reused so this is more or less a no-op, however in some situations ++ * FFmpeg may reuse an AVFrame early, i.e. when no output frame was ++ * produced prior time, and a synchronization is necessary. ++ */ ++ ret = v4l2_request_wait_on_capture(ctx, pic->capture_index); ++ if (ret < 0) ++ return ret; ++ } ++ ++ ff_mutex_lock(&ctx->mutex); ++ ++ /* ++ * The OUTPUT buffer tied to prior use of current request object can ++ * independently be dequeued before the full decode request has been ++ * completed. This may happen when a decoder use multi stage decoding, ++ * e.g. rpi-hevc-dec. In such case we can start reusing the OUTPUT buffer, ++ * however we must wait on the prior request to fully complete before we ++ * can reuse the request object, and a synchronization is necessary. ++ */ ++ ret = v4l2_request_wait_on_request(ctx, pic->output); ++ if (ret < 0) ++ goto fail; ++ ++ /* ++ * Dequeue any completed OUTPUT buffers, this is strictly not necessary, ++ * however if a synchronization was necessary for the CAPTURE and/or request ++ * there is more than likely one or more OUTPUT buffers that can be dequeued. ++ */ ++ if (ctx->queued_output) ++ v4l2_request_dequeue_completed_buffers(ctx, ctx->fctxi->output.format.type); ++ ++ // Set codec controls for current request ++ ret = v4l2_request_set_controls(ctx, pic->output->request_fd, control, count); ++ if (ret < 0) { ++ av_log(ctx, AV_LOG_ERROR, "Failed to set %d control(s) for request %d: %s (%d)\n", ++ count, pic->output->request_fd, strerror(errno), errno); ++ goto fail; ++ } ++ ++ // Ensure there is zero padding at the end of bitstream data ++ memset(pic->output->addr + pic->output->bytesused, 0, AV_INPUT_BUFFER_PADDING_SIZE); ++ ++ /* ++ * Use CAPTURE buffer index as base for V4L2 frame reference. ++ * This works because a CAPTURE buffer is closely tied to a AVFrame ++ * and FFmpeg handle all frame reference tracking for us. ++ */ ++ pic->output->timestamp = (struct timeval) { ++ .tv_sec = 0, ++ .tv_usec = pic->capture_index + 1, ++ }; ++ ++ /* ++ * Queue the OUTPUT buffer of current request. The CAPTURE buffer may be ++ * hold by the V4L2 decoder unless this is the last slice of a frame. ++ */ ++ flags = last_slice ? 0 : V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF; ++ ret = v4l2_request_queue_output_buffer(ctx, pic->output, flags); ++ if (ret < 0) { ++ av_log(ctx, AV_LOG_ERROR, "Failed to queue OUTPUT buffer %d for request %d: %s (%d)\n", ++ pic->output->index, pic->output->request_fd, strerror(errno), errno); ++ goto fail; ++ } ++ ++ if (first_slice) { ++ /* ++ * Queue the target CAPTURE buffer, hwaccel expect and depend on that ++ * this specific CAPTURE buffer will be used as decode target for ++ * current request, otherwise frames may be output in wrong order or ++ * wrong CAPTURE buffer could get used as a reference frame. ++ */ ++ ret = v4l2_request_queue_capture_buffer(ctx, pic->capture_index); ++ if (ret < 0) { ++ av_log(ctx, AV_LOG_ERROR, "Failed to queue CAPTURE buffer %d for request %d: %s (%d)\n", ++ pic->capture_index, pic->output->request_fd, strerror(errno), errno); ++ goto fail; ++ } ++ } ++ ++ // Queue current request ++ ret = ioctl(pic->output->request_fd, MEDIA_REQUEST_IOC_QUEUE); ++ if (ret < 0) { ++ ret = AVERROR(errno); ++ av_log(ctx, AV_LOG_ERROR, "Failed to queue request object %d: %s (%d)\n", ++ pic->output->request_fd, strerror(errno), errno); ++ goto fail; ++ } ++ ++ // Mark current request as queued ++ ctx->queued_request |= 1 << pic->output->index; ++ ++ ret = 0; ++fail: ++ ff_mutex_unlock(&ctx->mutex); ++ return ret; ++} ++ ++int ff_v4l2_request_decode_slice(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ struct v4l2_ext_control *control, int count, ++ bool first_slice, bool last_slice) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ ++ /* ++ * Fallback to queue each slice as a full frame when holding CAPTURE ++ * buffers is not supported by the driver. ++ */ ++ if ((ctx->fctxi->output.capabilities & V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF) != ++ V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF) ++ return v4l2_request_queue_decode(avctx, pic, control, count, true, true); ++ ++ return v4l2_request_queue_decode(avctx, pic, control, count, ++ first_slice, last_slice); ++} ++ ++int ff_v4l2_request_decode_frame(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ struct v4l2_ext_control *control, int count) ++{ ++ return v4l2_request_queue_decode(avctx, pic, control, count, true, true); ++} ++ ++static int v4l2_request_post_process(void *logctx, AVFrame *frame) ++{ ++ uint32_t index = v4l2_request_frameindex(frame); ++ FrameDecodeData *fdd = frame->private_ref; ++ V4L2RequestContext *ctx = fdd->hwaccel_priv; ++ ++ // Wait on CAPTURE buffer before returning the frame to application ++ return v4l2_request_wait_on_capture(ctx, index); ++} ++ ++int ff_v4l2_request_reset_picture(AVCodecContext *avctx, V4L2RequestPictureContext *pic) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ ++ // Get and wait on next OUTPUT buffer from circular queue ++ pic->output = v4l2_request_next_output(ctx); ++ if (!pic->output) ++ return AVERROR(EINVAL); ++ ++ return 0; ++} ++ ++int ff_v4l2_request_start_frame(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ AVFrame *frame) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ uint32_t index = v4l2_request_frameindex(frame); ++ FrameDecodeData *fdd = frame->private_ref; ++ int ret; ++ ++ // Get next OUTPUT buffer from circular queue ++ ret = ff_v4l2_request_reset_picture(avctx, pic); ++ if (ret) ++ return ret; ++ ++ // Ensure CAPTURE buffer is dequeued before reuse ++ ret = v4l2_request_wait_on_capture(ctx, index); ++ if (ret) ++ return ret; ++ ++ // Wait on CAPTURE buffer in post_process() before returning to application ++ fdd->hwaccel_priv = ctx; ++ fdd->post_process = v4l2_request_post_process; ++ ++ // CAPTURE buffer used for current frame ++ pic->capture_index = index; ++ ++ return 0; ++} ++ ++void ff_v4l2_request_flush(AVCodecContext *avctx) ++{ ++ V4L2RequestContext *ctx = v4l2_request_context(avctx); ++ enum v4l2_buf_type type = ctx->fctxi->output.format.type; ++ struct pollfd pollfd = { ++ .fd = ctx->fctxi->video_fd, ++ .events = POLLOUT, ++ }; ++ ++ ff_mutex_lock(&ctx->mutex); ++ ++ // Dequeue all completed OUTPUT buffers ++ if (ctx->queued_output) ++ v4l2_request_dequeue_completed_buffers(ctx, type); ++ ++ // Wait on any remaining OUTPUT buffer ++ while (ctx->queued_output) { ++ int ret = poll(&pollfd, 1, 2000); ++ if (ret <= 0) ++ break; ++ ++ ret = v4l2_request_dequeue_buffer(ctx, type); ++ if (ret < 0 && ret != AVERROR(EAGAIN)) ++ break; ++ } ++ ++ // Dequeue all completed CAPTURE buffers ++ if (ctx->queued_capture) ++ v4l2_request_dequeue_completed_buffers(ctx, ctx->fctxi->capture.format.type); ++ ++ ff_mutex_unlock(&ctx->mutex); ++} ++ + static void v4l2_request_output_buffer_uninit(V4L2RequestOutputBuffer *output) + { + // Close the request associated with the OUTPUT buffer +@@ -142,7 +676,8 @@ int ff_v4l2_request_uninit(AVCodecContex + enum v4l2_buf_type type; + + if (ctx->fctxi) { +- // TODO: Flush and wait on all pending requests ++ // Flush and wait on all pending requests ++ ff_v4l2_request_flush(avctx); + + // Stop streaming on OUTPUT queue + type = ctx->fctxi->output.format.type; +--- a/libavcodec/v4l2_request.h ++++ b/libavcodec/v4l2_request.h +@@ -46,10 +46,51 @@ typedef struct V4L2RequestContext { + AVV4L2RequestFramesContextInternal *fctxi; + AVMutex mutex; + V4L2RequestOutputBuffer output[4]; ++ uint8_t next_output; ++ uint32_t queued_output; ++ uint32_t queued_request; ++ uint64_t queued_capture; + struct v4l2_ext_control *init_controls; + int nb_init_controls; + } V4L2RequestContext; + ++typedef struct V4L2RequestPictureContext { ++ V4L2RequestOutputBuffer *output; ++ uint32_t capture_index; ++} V4L2RequestPictureContext; ++ ++uint64_t ff_v4l2_request_get_capture_timestamp(AVFrame *frame); ++ ++int ff_v4l2_request_query_control(AVCodecContext *avctx, ++ struct v4l2_query_ext_ctrl *control); ++ ++int ff_v4l2_request_query_control_default_value(AVCodecContext *avctx, ++ uint32_t id); ++ ++int ff_v4l2_request_set_controls(AVCodecContext *avctx, ++ struct v4l2_ext_control *control, int count); ++ ++int ff_v4l2_request_append_output(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ const uint8_t *data, uint32_t size); ++ ++int ff_v4l2_request_decode_slice(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ struct v4l2_ext_control *control, int count, ++ bool first_slice, bool last_slice); ++ ++int ff_v4l2_request_decode_frame(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, ++ struct v4l2_ext_control *control, int count); ++ ++int ff_v4l2_request_reset_picture(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic); ++ ++int ff_v4l2_request_start_frame(AVCodecContext *avctx, ++ V4L2RequestPictureContext *pic, AVFrame *frame); ++ ++void ff_v4l2_request_flush(AVCodecContext *avctx); ++ + int ff_v4l2_request_frame_params(AVCodecContext *avctx, + AVBufferRef *hw_frames_ctx, + uint32_t pixelformat, diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-05.patch b/multimedia/ffmpeg/patches/120-v4l2-request-05.patch new file mode 100644 index 000000000..d8506a4c3 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-05.patch @@ -0,0 +1,295 @@ +From 51a441640119ef3359a38dae67290a96ed77e6a0 Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Tue, 6 Aug 2024 09:06:04 +0000 +Subject: [PATCH 05/13] avcodec: Add V4L2 Request API mpeg2 hwaccel + +Add a V4L2 Request API hwaccel for MPEG2. + +Support for MPEG2 is enabled when Linux kernel headers declare the +control id V4L2_CID_STATELESS_MPEG2_SEQUENCE, added in v5.14. + +This also change v4l2_request hwaccel to use autodetect in configure. + +Signed-off-by: Jonas Karlman +--- + configure | 7 +- + libavcodec/Makefile | 1 + + libavcodec/hwaccels.h | 1 + + libavcodec/mpeg12dec.c | 6 ++ + libavcodec/v4l2_request_mpeg2.c | 184 ++++++++++++++++++++++++++++++++ + 5 files changed, 197 insertions(+), 2 deletions(-) + create mode 100644 libavcodec/v4l2_request_mpeg2.c + +--- a/configure ++++ b/configure +@@ -365,7 +365,7 @@ External library support: + --disable-nvenc disable Nvidia video encoding code [autodetect] + --enable-rkmpp enable Rockchip Media Process Platform code [no] + --disable-v4l2-m2m disable V4L2 mem2mem code [autodetect] +- --enable-v4l2-request enable V4L2 Request API code [no] ++ --disable-v4l2-request disable V4L2 Request API code [autodetect] + --disable-vaapi disable Video Acceleration API (mainly Unix/Intel) code [autodetect] + --disable-vdpau disable Nvidia Video Decode and Presentation API for Unix code [autodetect] + --disable-videotoolbox disable VideoToolbox code [autodetect] +@@ -2183,6 +2183,7 @@ HWACCEL_AUTODETECT_LIBRARY_LIST=" + videotoolbox + vulkan + v4l2_m2m ++ v4l2_request + " + + # catchall list of things that require external libs to link +@@ -2203,7 +2204,6 @@ HWACCEL_LIBRARY_LIST=" + libvpl + mmal + opencl +- v4l2_request + " + + DOCUMENT_LIST=" +@@ -3495,6 +3495,8 @@ mpeg2_dxva2_hwaccel_deps="dxva2" + mpeg2_dxva2_hwaccel_select="mpeg2video_decoder" + mpeg2_nvdec_hwaccel_deps="nvdec" + mpeg2_nvdec_hwaccel_select="mpeg2video_decoder" ++mpeg2_v4l2request_hwaccel_deps="v4l2_request mpeg2_v4l2_request" ++mpeg2_v4l2request_hwaccel_select="mpeg2video_decoder" + mpeg2_vaapi_hwaccel_deps="vaapi" + mpeg2_vaapi_hwaccel_select="mpeg2video_decoder" + mpeg2_vdpau_hwaccel_deps="vdpau" +@@ -7662,6 +7664,7 @@ if enabled v4l2_m2m; then + fi + + if enabled v4l2_request; then ++ check_cc mpeg2_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_MPEG2_SEQUENCE" + check_cc v4l2_m2m_hold_capture_buf linux/videodev2.h "int i = V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF" + check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns + check_pkg_config libudev libudev libudev.h udev_new +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -1084,6 +1084,7 @@ OBJS-$(CONFIG_MPEG2_DXVA2_HWACCEL) + OBJS-$(CONFIG_MPEG2_D3D12VA_HWACCEL) += dxva2_mpeg2.o d3d12va_mpeg2.o + OBJS-$(CONFIG_MPEG2_NVDEC_HWACCEL) += nvdec_mpeg12.o + OBJS-$(CONFIG_MPEG2_QSV_HWACCEL) += qsvdec.o ++OBJS-$(CONFIG_MPEG2_V4L2REQUEST_HWACCEL) += v4l2_request_mpeg2.o + OBJS-$(CONFIG_MPEG2_VAAPI_HWACCEL) += vaapi_mpeg2.o + OBJS-$(CONFIG_MPEG2_VDPAU_HWACCEL) += vdpau_mpeg12.o + OBJS-$(CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o +--- a/libavcodec/hwaccels.h ++++ b/libavcodec/hwaccels.h +@@ -61,6 +61,7 @@ extern const struct FFHWAccel ff_mpeg2_d + extern const struct FFHWAccel ff_mpeg2_d3d12va_hwaccel; + extern const struct FFHWAccel ff_mpeg2_dxva2_hwaccel; + extern const struct FFHWAccel ff_mpeg2_nvdec_hwaccel; ++extern const struct FFHWAccel ff_mpeg2_v4l2request_hwaccel; + extern const struct FFHWAccel ff_mpeg2_vaapi_hwaccel; + extern const struct FFHWAccel ff_mpeg2_vdpau_hwaccel; + extern const struct FFHWAccel ff_mpeg2_videotoolbox_hwaccel; +--- a/libavcodec/mpeg12dec.c ++++ b/libavcodec/mpeg12dec.c +@@ -821,6 +821,9 @@ static const enum AVPixelFormat mpeg2_hw + #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL + AV_PIX_FMT_VIDEOTOOLBOX, + #endif ++#if CONFIG_MPEG2_V4L2REQUEST_HWACCEL ++ AV_PIX_FMT_DRM_PRIME, ++#endif + AV_PIX_FMT_YUV420P, + AV_PIX_FMT_NONE + }; +@@ -2728,6 +2731,9 @@ const FFCodec ff_mpeg2video_decoder = { + #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL + HWACCEL_VIDEOTOOLBOX(mpeg2), + #endif ++#if CONFIG_MPEG2_V4L2REQUEST_HWACCEL ++ HWACCEL_V4L2REQUEST(mpeg2), ++#endif + NULL + }, + }; +--- /dev/null ++++ b/libavcodec/v4l2_request_mpeg2.c +@@ -0,0 +1,184 @@ ++/* ++ * 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 "config.h" ++ ++#include "hwaccel_internal.h" ++#include "hwconfig.h" ++#include "mathops.h" ++#include "mpegvideo.h" ++#include "v4l2_request.h" ++ ++typedef struct V4L2RequestControlsMPEG2 { ++ V4L2RequestPictureContext pic; ++ struct v4l2_ctrl_mpeg2_sequence sequence; ++ struct v4l2_ctrl_mpeg2_picture picture; ++ struct v4l2_ctrl_mpeg2_quantisation quantisation; ++} V4L2RequestControlsMPEG2; ++ ++static int v4l2_request_mpeg2_start_frame(AVCodecContext *avctx, ++ av_unused const AVBufferRef *buf_ref, ++ av_unused const uint8_t *buffer, ++ av_unused uint32_t size) ++{ ++ const MpegEncContext *s = avctx->priv_data; ++ V4L2RequestControlsMPEG2 *controls = s->cur_pic.ptr->hwaccel_picture_private; ++ int ret; ++ ++ ret = ff_v4l2_request_start_frame(avctx, &controls->pic, s->cur_pic.ptr->f); ++ if (ret) ++ return ret; ++ ++ controls->sequence = (struct v4l2_ctrl_mpeg2_sequence) { ++ /* ISO/IEC 13818-2, ITU-T Rec. H.262: Sequence header */ ++ .horizontal_size = s->width, ++ .vertical_size = s->height, ++ .vbv_buffer_size = controls->pic.output->size, ++ ++ /* ISO/IEC 13818-2, ITU-T Rec. H.262: Sequence extension */ ++ .profile_and_level_indication = 0, ++ .chroma_format = s->chroma_format, ++ }; ++ ++ if (s->progressive_sequence) ++ controls->sequence.flags |= V4L2_MPEG2_SEQ_FLAG_PROGRESSIVE; ++ ++ controls->picture = (struct v4l2_ctrl_mpeg2_picture) { ++ /* ISO/IEC 13818-2, ITU-T Rec. H.262: Picture header */ ++ .picture_coding_type = s->pict_type, ++ ++ /* ISO/IEC 13818-2, ITU-T Rec. H.262: Picture coding extension */ ++ .f_code[0][0] = s->mpeg_f_code[0][0], ++ .f_code[0][1] = s->mpeg_f_code[0][1], ++ .f_code[1][0] = s->mpeg_f_code[1][0], ++ .f_code[1][1] = s->mpeg_f_code[1][1], ++ .picture_structure = s->picture_structure, ++ .intra_dc_precision = s->intra_dc_precision, ++ }; ++ ++ if (s->top_field_first) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRST; ++ ++ if (s->frame_pred_frame_dct) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCT; ++ ++ if (s->concealment_motion_vectors) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_CONCEALMENT_MV; ++ ++ if (s->intra_vlc_format) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_INTRA_VLC; ++ ++ if (s->q_scale_type) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_Q_SCALE_TYPE; ++ ++ if (s->alternate_scan) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_ALT_SCAN; ++ ++ if (s->repeat_first_field) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_REPEAT_FIRST; ++ ++ if (s->progressive_frame) ++ controls->picture.flags |= V4L2_MPEG2_PIC_FLAG_PROGRESSIVE; ++ ++ switch (s->pict_type) { ++ case AV_PICTURE_TYPE_B: ++ if (s->next_pic.ptr) ++ controls->picture.backward_ref_ts = ++ ff_v4l2_request_get_capture_timestamp(s->next_pic.ptr->f); ++ // fall-through ++ case AV_PICTURE_TYPE_P: ++ if (s->last_pic.ptr) ++ controls->picture.forward_ref_ts = ++ ff_v4l2_request_get_capture_timestamp(s->last_pic.ptr->f); ++ } ++ ++ for (int i = 0; i < 64; i++) { ++ int n = s->idsp.idct_permutation[ff_zigzag_direct[i]]; ++ controls->quantisation.intra_quantiser_matrix[i] = s->intra_matrix[n]; ++ controls->quantisation.non_intra_quantiser_matrix[i] = s->inter_matrix[n]; ++ controls->quantisation.chroma_intra_quantiser_matrix[i] = s->chroma_intra_matrix[n]; ++ controls->quantisation.chroma_non_intra_quantiser_matrix[i] = s->chroma_inter_matrix[n]; ++ } ++ ++ return 0; ++} ++ ++static int v4l2_request_mpeg2_decode_slice(AVCodecContext *avctx, ++ const uint8_t *buffer, uint32_t size) ++{ ++ const MpegEncContext *s = avctx->priv_data; ++ V4L2RequestControlsMPEG2 *controls = s->cur_pic.ptr->hwaccel_picture_private; ++ ++ return ff_v4l2_request_append_output(avctx, &controls->pic, buffer, size); ++} ++ ++static int v4l2_request_mpeg2_end_frame(AVCodecContext *avctx) ++{ ++ const MpegEncContext *s = avctx->priv_data; ++ V4L2RequestControlsMPEG2 *controls = s->cur_pic.ptr->hwaccel_picture_private; ++ ++ struct v4l2_ext_control control[] = { ++ { ++ .id = V4L2_CID_STATELESS_MPEG2_SEQUENCE, ++ .ptr = &controls->sequence, ++ .size = sizeof(controls->sequence), ++ }, ++ { ++ .id = V4L2_CID_STATELESS_MPEG2_PICTURE, ++ .ptr = &controls->picture, ++ .size = sizeof(controls->picture), ++ }, ++ { ++ .id = V4L2_CID_STATELESS_MPEG2_QUANTISATION, ++ .ptr = &controls->quantisation, ++ .size = sizeof(controls->quantisation), ++ }, ++ }; ++ ++ return ff_v4l2_request_decode_frame(avctx, &controls->pic, ++ control, FF_ARRAY_ELEMS(control)); ++} ++ ++static int v4l2_request_mpeg2_init(AVCodecContext *avctx) ++{ ++ return ff_v4l2_request_init(avctx, NULL, 0, NULL); ++} ++ ++static int v4l2_request_mpeg2_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx) ++{ ++ return ff_v4l2_request_frame_params(avctx, hw_frames_ctx, ++ V4L2_PIX_FMT_MPEG2_SLICE, 8); ++} ++ ++const FFHWAccel ff_mpeg2_v4l2request_hwaccel = { ++ .p.name = "mpeg2_v4l2request", ++ .p.type = AVMEDIA_TYPE_VIDEO, ++ .p.id = AV_CODEC_ID_MPEG2VIDEO, ++ .p.pix_fmt = AV_PIX_FMT_DRM_PRIME, ++ .start_frame = v4l2_request_mpeg2_start_frame, ++ .decode_slice = v4l2_request_mpeg2_decode_slice, ++ .end_frame = v4l2_request_mpeg2_end_frame, ++ .flush = ff_v4l2_request_flush, ++ .frame_priv_data_size = sizeof(V4L2RequestControlsMPEG2), ++ .init = v4l2_request_mpeg2_init, ++ .uninit = ff_v4l2_request_uninit, ++ .priv_data_size = sizeof(V4L2RequestContext), ++ .frame_params = v4l2_request_mpeg2_frame_params, ++ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, ++}; diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-06.patch b/multimedia/ffmpeg/patches/120-v4l2-request-06.patch new file mode 100644 index 000000000..90d2c631d --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-06.patch @@ -0,0 +1,83 @@ +From 55d176a32f6e55543261889e172270df833ce19b Mon Sep 17 00:00:00 2001 +From: Boris Brezillon +Date: Tue, 6 Aug 2024 09:06:05 +0000 +Subject: [PATCH 06/13] avcodec/h264dec: add ref_pic_marking and pic_order_cnt + bit_size to slice context + +The V4L2_CID_STATELESS_H264_DECODE_PARAMS control require following: + +- dec_ref_pic_marking_bit_size + Size in bits of the dec_ref_pic_marking() syntax element. + +- pic_order_cnt_bit_size + Combined size in bits of the picture order count related syntax + elements: pic_order_cnt_lsb, delta_pic_order_cnt_bottom, + delta_pic_order_cnt0, and delta_pic_order_cnt1. + +Save the bit sizes while parsing for later use in hwaccel, similar to +short/long_term_ref_pic_set_size in hevcdec. + +Signed-off-by: Boris Brezillon +Signed-off-by: Jonas Karlman +--- + libavcodec/h264_slice.c | 6 +++++- + libavcodec/h264dec.h | 2 ++ + 2 files changed, 7 insertions(+), 1 deletion(-) + +--- a/libavcodec/h264_slice.c ++++ b/libavcodec/h264_slice.c +@@ -1702,7 +1702,7 @@ static int h264_slice_header_parse(const + unsigned int slice_type, tmp, i; + int field_pic_flag, bottom_field_flag; + int first_slice = sl == h->slice_ctx && !h->current_slice; +- int picture_structure; ++ int picture_structure, pos; + + if (first_slice) + av_assert0(!h->setup_finished); +@@ -1793,6 +1793,7 @@ static int h264_slice_header_parse(const + + sl->poc_lsb = 0; + sl->delta_poc_bottom = 0; ++ pos = get_bits_left(&sl->gb); + if (sps->poc_type == 0) { + sl->poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb); + +@@ -1807,6 +1808,7 @@ static int h264_slice_header_parse(const + if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME) + sl->delta_poc[1] = get_se_golomb(&sl->gb); + } ++ sl->pic_order_cnt_bit_size = pos - get_bits_left(&sl->gb); + + sl->redundant_pic_count = 0; + if (pps->redundant_pic_cnt_present) +@@ -1846,9 +1848,11 @@ static int h264_slice_header_parse(const + + sl->explicit_ref_marking = 0; + if (nal->ref_idc) { ++ pos = get_bits_left(&sl->gb); + ret = ff_h264_decode_ref_pic_marking(sl, &sl->gb, nal, h->avctx); + if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) + return AVERROR_INVALIDDATA; ++ sl->ref_pic_marking_bit_size = pos - get_bits_left(&sl->gb); + } + + if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) { +--- a/libavcodec/h264dec.h ++++ b/libavcodec/h264dec.h +@@ -322,6 +322,7 @@ typedef struct H264SliceContext { + MMCO mmco[H264_MAX_MMCO_COUNT]; + int nb_mmco; + int explicit_ref_marking; ++ int ref_pic_marking_bit_size; + + int frame_num; + int idr_pic_id; +@@ -330,6 +331,7 @@ typedef struct H264SliceContext { + int delta_poc[2]; + int curr_pic_num; + int max_pic_num; ++ int pic_order_cnt_bit_size; + } H264SliceContext; + + /** diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-07.patch b/multimedia/ffmpeg/patches/120-v4l2-request-07.patch new file mode 100644 index 000000000..2b451b414 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-07.patch @@ -0,0 +1,640 @@ +From 84bb22c3eba4b8ed70322f65882dd52cdeec31ed Mon Sep 17 00:00:00 2001 +From: Jernej Skrabec +Date: Tue, 6 Aug 2024 09:06:06 +0000 +Subject: [PATCH 07/13] avcodec: Add V4L2 Request API h264 hwaccel + +Add a V4L2 Request API hwaccel for H.264, supporting both slice and +frame decoding modes. + +Support for H.264 is enabled when Linux kernel headers declare the +control id V4L2_CID_STATELESS_H264_DECODE_MODE, added in v5.11. + +Signed-off-by: Jernej Skrabec +Co-developed-by: Jonas Karlman +Signed-off-by: Jonas Karlman +--- + configure | 3 + + libavcodec/Makefile | 1 + + libavcodec/h264_slice.c | 7 + + libavcodec/h264dec.c | 3 + + libavcodec/hwaccels.h | 1 + + libavcodec/v4l2_request_h264.c | 532 +++++++++++++++++++++++++++++++++ + 6 files changed, 547 insertions(+) + create mode 100644 libavcodec/v4l2_request_h264.c + +--- a/configure ++++ b/configure +@@ -3449,6 +3449,8 @@ h264_dxva2_hwaccel_deps="dxva2" + h264_dxva2_hwaccel_select="h264_decoder" + h264_nvdec_hwaccel_deps="nvdec" + h264_nvdec_hwaccel_select="h264_decoder" ++h264_v4l2request_hwaccel_deps="v4l2_request h264_v4l2_request" ++h264_v4l2request_hwaccel_select="h264_decoder" + h264_vaapi_hwaccel_deps="vaapi" + h264_vaapi_hwaccel_select="h264_decoder" + h264_vdpau_hwaccel_deps="vdpau" +@@ -7664,6 +7666,7 @@ if enabled v4l2_m2m; then + fi + + if enabled v4l2_request; then ++ check_cc h264_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_H264_DECODE_MODE" + check_cc mpeg2_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_MPEG2_SEQUENCE" + check_cc v4l2_m2m_hold_capture_buf linux/videodev2.h "int i = V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF" + check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -1062,6 +1062,7 @@ OBJS-$(CONFIG_H264_DXVA2_HWACCEL) + OBJS-$(CONFIG_H264_D3D12VA_HWACCEL) += dxva2_h264.o d3d12va_h264.o + OBJS-$(CONFIG_H264_NVDEC_HWACCEL) += nvdec_h264.o + OBJS-$(CONFIG_H264_QSV_HWACCEL) += qsvdec.o ++OBJS-$(CONFIG_H264_V4L2REQUEST_HWACCEL) += v4l2_request_h264.o + OBJS-$(CONFIG_H264_VAAPI_HWACCEL) += vaapi_h264.o + OBJS-$(CONFIG_H264_VDPAU_HWACCEL) += vdpau_h264.o + OBJS-$(CONFIG_H264_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o +--- a/libavcodec/h264_slice.c ++++ b/libavcodec/h264_slice.c +@@ -790,6 +790,7 @@ static enum AVPixelFormat get_pixel_form + (CONFIG_H264_D3D11VA_HWACCEL * 2) + \ + CONFIG_H264_D3D12VA_HWACCEL + \ + CONFIG_H264_NVDEC_HWACCEL + \ ++ CONFIG_H264_V4L2REQUEST_HWACCEL + \ + CONFIG_H264_VAAPI_HWACCEL + \ + CONFIG_H264_VIDEOTOOLBOX_HWACCEL + \ + CONFIG_H264_VDPAU_HWACCEL + \ +@@ -819,6 +820,9 @@ static enum AVPixelFormat get_pixel_form + #if CONFIG_H264_NVDEC_HWACCEL + *fmt++ = AV_PIX_FMT_CUDA; + #endif ++#if CONFIG_H264_V4L2REQUEST_HWACCEL ++ *fmt++ = AV_PIX_FMT_DRM_PRIME; ++#endif + if (CHROMA444(h)) { + if (h->avctx->colorspace == AVCOL_SPC_RGB) { + *fmt++ = AV_PIX_FMT_GBRP10; +@@ -875,6 +879,9 @@ static enum AVPixelFormat get_pixel_form + if (h->avctx->colorspace != AVCOL_SPC_RGB) + *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX; + #endif ++#if CONFIG_H264_V4L2REQUEST_HWACCEL ++ *fmt++ = AV_PIX_FMT_DRM_PRIME; ++#endif + if (CHROMA444(h)) { + if (h->avctx->colorspace == AVCOL_SPC_RGB) + *fmt++ = AV_PIX_FMT_GBRP; +--- a/libavcodec/h264dec.c ++++ b/libavcodec/h264dec.c +@@ -1146,6 +1146,9 @@ const FFCodec ff_h264_decoder = { + #if CONFIG_H264_VULKAN_HWACCEL + HWACCEL_VULKAN(h264), + #endif ++#if CONFIG_H264_V4L2REQUEST_HWACCEL ++ HWACCEL_V4L2REQUEST(h264), ++#endif + NULL + }, + .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING | +--- a/libavcodec/hwaccels.h ++++ b/libavcodec/hwaccels.h +@@ -38,6 +38,7 @@ extern const struct FFHWAccel ff_h264_d3 + extern const struct FFHWAccel ff_h264_d3d12va_hwaccel; + extern const struct FFHWAccel ff_h264_dxva2_hwaccel; + extern const struct FFHWAccel ff_h264_nvdec_hwaccel; ++extern const struct FFHWAccel ff_h264_v4l2request_hwaccel; + extern const struct FFHWAccel ff_h264_vaapi_hwaccel; + extern const struct FFHWAccel ff_h264_vdpau_hwaccel; + extern const struct FFHWAccel ff_h264_videotoolbox_hwaccel; +--- /dev/null ++++ b/libavcodec/v4l2_request_h264.c +@@ -0,0 +1,532 @@ ++/* ++ * 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 "config.h" ++ ++#include "h264dec.h" ++#include "hwaccel_internal.h" ++#include "hwconfig.h" ++#include "internal.h" ++#include "v4l2_request.h" ++ ++typedef struct V4L2RequestContextH264 { ++ V4L2RequestContext base; ++ enum v4l2_stateless_h264_decode_mode decode_mode; ++ enum v4l2_stateless_h264_start_code start_code; ++} V4L2RequestContextH264; ++ ++typedef struct V4L2RequestControlsH264 { ++ V4L2RequestPictureContext pic; ++ struct v4l2_ctrl_h264_sps sps; ++ struct v4l2_ctrl_h264_pps pps; ++ struct v4l2_ctrl_h264_scaling_matrix scaling_matrix; ++ struct v4l2_ctrl_h264_decode_params decode_params; ++ struct v4l2_ctrl_h264_slice_params slice_params; ++ struct v4l2_ctrl_h264_pred_weights pred_weights; ++ bool pred_weights_required; ++ bool first_slice; ++ int num_slices; ++} V4L2RequestControlsH264; ++ ++static uint8_t nalu_slice_start_code[] = { 0x00, 0x00, 0x01 }; ++ ++static void fill_weight_factors(struct v4l2_h264_weight_factors *weight_factors, ++ int list, const H264SliceContext *sl) ++{ ++ for (int i = 0; i < sl->ref_count[list]; i++) { ++ if (sl->pwt.luma_weight_flag[list]) { ++ weight_factors->luma_weight[i] = sl->pwt.luma_weight[i][list][0]; ++ weight_factors->luma_offset[i] = sl->pwt.luma_weight[i][list][1]; ++ } else { ++ weight_factors->luma_weight[i] = 1 << sl->pwt.luma_log2_weight_denom; ++ weight_factors->luma_offset[i] = 0; ++ } ++ for (int j = 0; j < 2; j++) { ++ if (sl->pwt.chroma_weight_flag[list]) { ++ weight_factors->chroma_weight[i][j] = sl->pwt.chroma_weight[i][list][j][0]; ++ weight_factors->chroma_offset[i][j] = sl->pwt.chroma_weight[i][list][j][1]; ++ } else { ++ weight_factors->chroma_weight[i][j] = 1 << sl->pwt.chroma_log2_weight_denom; ++ weight_factors->chroma_offset[i][j] = 0; ++ } ++ } ++ } ++} ++ ++static void fill_dpb_entry(struct v4l2_h264_dpb_entry *entry, ++ const H264Picture *pic, int long_idx) ++{ ++ entry->reference_ts = ff_v4l2_request_get_capture_timestamp(pic->f); ++ entry->pic_num = pic->pic_id; ++ entry->frame_num = pic->long_ref ? long_idx : pic->frame_num; ++ entry->fields = pic->reference & V4L2_H264_FRAME_REF; ++ entry->flags = V4L2_H264_DPB_ENTRY_FLAG_VALID; ++ if (entry->fields) ++ entry->flags |= V4L2_H264_DPB_ENTRY_FLAG_ACTIVE; ++ if (pic->long_ref) ++ entry->flags |= V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM; ++ if (pic->field_picture) ++ entry->flags |= V4L2_H264_DPB_ENTRY_FLAG_FIELD; ++ if (pic->field_poc[0] != INT_MAX) ++ entry->top_field_order_cnt = pic->field_poc[0]; ++ if (pic->field_poc[1] != INT_MAX) ++ entry->bottom_field_order_cnt = pic->field_poc[1]; ++} ++ ++static void fill_dpb(struct v4l2_ctrl_h264_decode_params *decode_params, ++ const H264Context *h) ++{ ++ int entries = 0; ++ ++ for (int i = 0; i < h->short_ref_count; i++) { ++ const H264Picture *pic = h->short_ref[i]; ++ if (pic && (pic->field_poc[0] != INT_MAX || pic->field_poc[1] != INT_MAX)) ++ fill_dpb_entry(&decode_params->dpb[entries++], pic, pic->pic_id); ++ } ++ ++ if (!h->long_ref_count) ++ return; ++ ++ for (int i = 0; i < FF_ARRAY_ELEMS(h->long_ref); i++) { ++ const H264Picture *pic = h->long_ref[i]; ++ if (pic && (pic->field_poc[0] != INT_MAX || pic->field_poc[1] != INT_MAX)) ++ fill_dpb_entry(&decode_params->dpb[entries++], pic, i); ++ } ++} ++ ++static void fill_ref_list(struct v4l2_h264_reference *reference, ++ struct v4l2_ctrl_h264_decode_params *decode_params, ++ const H264Ref *ref) ++{ ++ uint64_t timestamp; ++ ++ if (!ref->parent) ++ return; ++ ++ timestamp = ff_v4l2_request_get_capture_timestamp(ref->parent->f); ++ ++ for (uint8_t i = 0; i < FF_ARRAY_ELEMS(decode_params->dpb); i++) { ++ struct v4l2_h264_dpb_entry *entry = &decode_params->dpb[i]; ++ if ((entry->flags & V4L2_H264_DPB_ENTRY_FLAG_VALID) && ++ entry->reference_ts == timestamp) { ++ reference->fields = ref->reference & V4L2_H264_FRAME_REF; ++ reference->index = i; ++ return; ++ } ++ } ++} ++ ++static void fill_sps(struct v4l2_ctrl_h264_sps *ctrl, const H264Context *h) ++{ ++ const SPS *sps = h->ps.sps; ++ ++ *ctrl = (struct v4l2_ctrl_h264_sps) { ++ .profile_idc = sps->profile_idc, ++ .constraint_set_flags = sps->constraint_set_flags, ++ .level_idc = sps->level_idc, ++ .seq_parameter_set_id = sps->sps_id, ++ .chroma_format_idc = sps->chroma_format_idc, ++ .bit_depth_luma_minus8 = sps->bit_depth_luma - 8, ++ .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8, ++ .log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4, ++ .pic_order_cnt_type = sps->poc_type, ++ .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4, ++ .max_num_ref_frames = sps->ref_frame_count, ++ .num_ref_frames_in_pic_order_cnt_cycle = sps->poc_cycle_length, ++ .offset_for_non_ref_pic = sps->offset_for_non_ref_pic, ++ .offset_for_top_to_bottom_field = sps->offset_for_top_to_bottom_field, ++ .pic_width_in_mbs_minus1 = h->mb_width - 1, ++ .pic_height_in_map_units_minus1 = sps->frame_mbs_only_flag ? ++ h->mb_height - 1 : h->mb_height / 2 - 1, ++ }; ++ ++ if (sps->poc_cycle_length > 0 && sps->poc_cycle_length <= 255) ++ memcpy(ctrl->offset_for_ref_frame, sps->offset_for_ref_frame, ++ sps->poc_cycle_length * sizeof(ctrl->offset_for_ref_frame[0])); ++ ++ if (sps->residual_color_transform_flag) ++ ctrl->flags |= V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE; ++ ++ if (sps->transform_bypass) ++ ctrl->flags |= V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS; ++ ++ if (sps->delta_pic_order_always_zero_flag) ++ ctrl->flags |= V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO; ++ ++ if (sps->gaps_in_frame_num_allowed_flag) ++ ctrl->flags |= V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED; ++ ++ if (sps->frame_mbs_only_flag) ++ ctrl->flags |= V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY; ++ ++ if (sps->mb_aff) ++ ctrl->flags |= V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD; ++ ++ if (sps->direct_8x8_inference_flag) ++ ctrl->flags |= V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE; ++} ++ ++static void fill_pps(struct v4l2_ctrl_h264_pps *ctrl, const H264Context *h) ++{ ++ const SPS *sps = h->ps.sps; ++ const PPS *pps = h->ps.pps; ++ const H264SliceContext *sl = &h->slice_ctx[0]; ++ int qp_bd_offset = 6 * (sps->bit_depth_luma - 8); ++ ++ *ctrl = (struct v4l2_ctrl_h264_pps) { ++ .pic_parameter_set_id = sl->pps_id, ++ .seq_parameter_set_id = pps->sps_id, ++ .num_slice_groups_minus1 = pps->slice_group_count - 1, ++ .num_ref_idx_l0_default_active_minus1 = pps->ref_count[0] - 1, ++ .num_ref_idx_l1_default_active_minus1 = pps->ref_count[1] - 1, ++ .weighted_bipred_idc = pps->weighted_bipred_idc, ++ .pic_init_qp_minus26 = pps->init_qp - 26 - qp_bd_offset, ++ .pic_init_qs_minus26 = pps->init_qs - 26 - qp_bd_offset, ++ .chroma_qp_index_offset = pps->chroma_qp_index_offset[0], ++ .second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1], ++ }; ++ ++ if (pps->cabac) ++ ctrl->flags |= V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE; ++ ++ if (pps->pic_order_present) ++ ctrl->flags |= V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT; ++ ++ if (pps->weighted_pred) ++ ctrl->flags |= V4L2_H264_PPS_FLAG_WEIGHTED_PRED; ++ ++ if (pps->deblocking_filter_parameters_present) ++ ctrl->flags |= V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT; ++ ++ if (pps->constrained_intra_pred) ++ ctrl->flags |= V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED; ++ ++ if (pps->redundant_pic_cnt_present) ++ ctrl->flags |= V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT; ++ ++ if (pps->transform_8x8_mode) ++ ctrl->flags |= V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE; ++ ++ /* FFmpeg always provide a scaling matrix */ ++ ctrl->flags |= V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT; ++} ++ ++static int v4l2_request_h264_start_frame(AVCodecContext *avctx, ++ av_unused const AVBufferRef *buf_ref, ++ av_unused const uint8_t *buffer, ++ av_unused uint32_t size) ++{ ++ const H264Context *h = avctx->priv_data; ++ const PPS *pps = h->ps.pps; ++ const SPS *sps = h->ps.sps; ++ const H264SliceContext *sl = &h->slice_ctx[0]; ++ V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private; ++ int ret; ++ ++ ret = ff_v4l2_request_start_frame(avctx, &controls->pic, h->cur_pic_ptr->f); ++ if (ret) ++ return ret; ++ ++ fill_sps(&controls->sps, h); ++ fill_pps(&controls->pps, h); ++ ++ memcpy(controls->scaling_matrix.scaling_list_4x4, pps->scaling_matrix4, ++ sizeof(controls->scaling_matrix.scaling_list_4x4)); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[0], pps->scaling_matrix8[0], ++ sizeof(controls->scaling_matrix.scaling_list_8x8[0])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[1], pps->scaling_matrix8[3], ++ sizeof(controls->scaling_matrix.scaling_list_8x8[1])); ++ ++ if (sps->chroma_format_idc == 3) { ++ memcpy(controls->scaling_matrix.scaling_list_8x8[2], pps->scaling_matrix8[1], ++ sizeof(controls->scaling_matrix.scaling_list_8x8[2])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[3], pps->scaling_matrix8[4], ++ sizeof(controls->scaling_matrix.scaling_list_8x8[3])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[4], pps->scaling_matrix8[2], ++ sizeof(controls->scaling_matrix.scaling_list_8x8[4])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[5], pps->scaling_matrix8[5], ++ sizeof(controls->scaling_matrix.scaling_list_8x8[5])); ++ } ++ ++ controls->decode_params = (struct v4l2_ctrl_h264_decode_params) { ++ .nal_ref_idc = h->nal_ref_idc, ++ .frame_num = h->poc.frame_num, ++ .top_field_order_cnt = h->cur_pic_ptr->field_poc[0] != INT_MAX ? ++ h->cur_pic_ptr->field_poc[0] : 0, ++ .bottom_field_order_cnt = h->cur_pic_ptr->field_poc[1] != INT_MAX ? ++ h->cur_pic_ptr->field_poc[1] : 0, ++ .idr_pic_id = sl->idr_pic_id, ++ .pic_order_cnt_lsb = sl->poc_lsb, ++ .delta_pic_order_cnt_bottom = sl->delta_poc_bottom, ++ .delta_pic_order_cnt0 = sl->delta_poc[0], ++ .delta_pic_order_cnt1 = sl->delta_poc[1], ++ /* Size in bits of dec_ref_pic_marking() syntax element. */ ++ .dec_ref_pic_marking_bit_size = sl->ref_pic_marking_bit_size, ++ /* Size in bits of pic order count syntax. */ ++ .pic_order_cnt_bit_size = sl->pic_order_cnt_bit_size, ++ .slice_group_change_cycle = 0, /* slice group not supported by FFmpeg */ ++ }; ++ ++ if (h->picture_idr) ++ controls->decode_params.flags |= V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC; ++ ++ if (FIELD_PICTURE(h)) ++ controls->decode_params.flags |= V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC; ++ ++ if (h->picture_structure == PICT_BOTTOM_FIELD) ++ controls->decode_params.flags |= V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD; ++ ++#if defined(V4L2_H264_DECODE_PARAM_FLAG_PFRAME) ++ if (sl->slice_type_nos == AV_PICTURE_TYPE_P) ++ controls->decode_params.flags |= V4L2_H264_DECODE_PARAM_FLAG_PFRAME; ++#endif ++ ++#if defined(V4L2_H264_DECODE_PARAM_FLAG_BFRAME) ++ if (sl->slice_type_nos == AV_PICTURE_TYPE_B) ++ controls->decode_params.flags |= V4L2_H264_DECODE_PARAM_FLAG_BFRAME; ++#endif ++ ++ fill_dpb(&controls->decode_params, h); ++ ++ controls->first_slice = true; ++ controls->num_slices = 0; ++ ++ return 0; ++} ++ ++static int v4l2_request_h264_queue_decode(AVCodecContext *avctx, bool last_slice) ++{ ++ const H264Context *h = avctx->priv_data; ++ V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private; ++ ++ struct v4l2_ext_control control[] = { ++ { ++ .id = V4L2_CID_STATELESS_H264_SPS, ++ .ptr = &controls->sps, ++ .size = sizeof(controls->sps), ++ }, ++ { ++ .id = V4L2_CID_STATELESS_H264_PPS, ++ .ptr = &controls->pps, ++ .size = sizeof(controls->pps), ++ }, ++ { ++ .id = V4L2_CID_STATELESS_H264_SCALING_MATRIX, ++ .ptr = &controls->scaling_matrix, ++ .size = sizeof(controls->scaling_matrix), ++ }, ++ { ++ .id = V4L2_CID_STATELESS_H264_DECODE_PARAMS, ++ .ptr = &controls->decode_params, ++ .size = sizeof(controls->decode_params), ++ }, ++ { ++ .id = V4L2_CID_STATELESS_H264_SLICE_PARAMS, ++ .ptr = &controls->slice_params, ++ .size = sizeof(controls->slice_params), ++ }, ++ { ++ .id = V4L2_CID_STATELESS_H264_PRED_WEIGHTS, ++ .ptr = &controls->pred_weights, ++ .size = sizeof(controls->pred_weights), ++ }, ++ }; ++ ++ if (ctx->decode_mode == V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED) { ++ int count = FF_ARRAY_ELEMS(control) - (controls->pred_weights_required ? 0 : 1); ++ return ff_v4l2_request_decode_slice(avctx, &controls->pic, control, count, ++ controls->first_slice, last_slice); ++ } ++ ++ return ff_v4l2_request_decode_frame(avctx, &controls->pic, ++ control, FF_ARRAY_ELEMS(control) - 2); ++} ++ ++static int v4l2_request_h264_decode_slice(AVCodecContext *avctx, ++ const uint8_t *buffer, uint32_t size) ++{ ++ const H264Context *h = avctx->priv_data; ++ const PPS *pps = h->ps.pps; ++ const H264SliceContext *sl = &h->slice_ctx[0]; ++ V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private; ++ int i, ret, count; ++ ++ if (ctx->decode_mode == V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED && ++ controls->num_slices) { ++ ret = v4l2_request_h264_queue_decode(avctx, false); ++ if (ret) ++ return ret; ++ ++ ff_v4l2_request_reset_picture(avctx, &controls->pic); ++ controls->first_slice = 0; ++ } ++ ++ if (ctx->start_code == V4L2_STATELESS_H264_START_CODE_ANNEX_B) { ++ ret = ff_v4l2_request_append_output(avctx, &controls->pic, ++ nalu_slice_start_code, 3); ++ if (ret) ++ return ret; ++ } ++ ++ ret = ff_v4l2_request_append_output(avctx, &controls->pic, buffer, size); ++ if (ret) ++ return ret; ++ ++ if (ctx->decode_mode != V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED) ++ return 0; ++ ++ controls->slice_params = (struct v4l2_ctrl_h264_slice_params) { ++ /* Offset in bits to slice_data() from the beginning of this slice. */ ++ .header_bit_size = get_bits_count(&sl->gb), ++ ++ .first_mb_in_slice = sl->first_mb_addr, ++ ++ .slice_type = ff_h264_get_slice_type(sl), ++ .colour_plane_id = 0, /* separate colour plane not supported by FFmpeg */ ++ .redundant_pic_cnt = sl->redundant_pic_count, ++ .cabac_init_idc = sl->cabac_init_idc, ++ .slice_qp_delta = sl->qscale - pps->init_qp, ++ .slice_qs_delta = 0, /* not implemented by FFmpeg */ ++ .disable_deblocking_filter_idc = sl->deblocking_filter < 2 ? ++ !sl->deblocking_filter : ++ sl->deblocking_filter, ++ .slice_alpha_c0_offset_div2 = sl->slice_alpha_c0_offset / 2, ++ .slice_beta_offset_div2 = sl->slice_beta_offset / 2, ++ .num_ref_idx_l0_active_minus1 = sl->list_count > 0 ? sl->ref_count[0] - 1 : 0, ++ .num_ref_idx_l1_active_minus1 = sl->list_count > 1 ? sl->ref_count[1] - 1 : 0, ++ }; ++ ++ if (sl->slice_type == AV_PICTURE_TYPE_B && sl->direct_spatial_mv_pred) ++ controls->slice_params.flags |= V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED; ++ ++ /* V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH: not implemented by FFmpeg */ ++ ++ controls->pred_weights_required = ++ V4L2_H264_CTRL_PRED_WEIGHTS_REQUIRED(&controls->pps, &controls->slice_params); ++ if (controls->pred_weights_required) { ++ controls->pred_weights.chroma_log2_weight_denom = sl->pwt.chroma_log2_weight_denom; ++ controls->pred_weights.luma_log2_weight_denom = sl->pwt.luma_log2_weight_denom; ++ } ++ ++ count = sl->list_count > 0 ? sl->ref_count[0] : 0; ++ for (i = 0; i < count; i++) ++ fill_ref_list(&controls->slice_params.ref_pic_list0[i], ++ &controls->decode_params, &sl->ref_list[0][i]); ++ if (count && controls->pred_weights_required) ++ fill_weight_factors(&controls->pred_weights.weight_factors[0], 0, sl); ++ ++ count = sl->list_count > 1 ? sl->ref_count[1] : 0; ++ for (i = 0; i < count; i++) ++ fill_ref_list(&controls->slice_params.ref_pic_list1[i], ++ &controls->decode_params, &sl->ref_list[1][i]); ++ if (count && controls->pred_weights_required) ++ fill_weight_factors(&controls->pred_weights.weight_factors[1], 1, sl); ++ ++ controls->num_slices++; ++ return 0; ++} ++ ++static int v4l2_request_h264_end_frame(AVCodecContext *avctx) ++{ ++ return v4l2_request_h264_queue_decode(avctx, true); ++} ++ ++static int v4l2_request_h264_post_frames_ctx(AVCodecContext *avctx) ++{ ++ V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data; ++ ++ struct v4l2_ext_control control[] = { ++ { .id = V4L2_CID_STATELESS_H264_DECODE_MODE, }, ++ { .id = V4L2_CID_STATELESS_H264_START_CODE, }, ++ }; ++ ++ ctx->decode_mode = ff_v4l2_request_query_control_default_value(avctx, ++ V4L2_CID_STATELESS_H264_DECODE_MODE); ++ if (ctx->decode_mode != V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED && ++ ctx->decode_mode != V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED) { ++ av_log(ctx, AV_LOG_VERBOSE, "Unsupported decode mode: %d\n", ++ ctx->decode_mode); ++ return AVERROR(EINVAL); ++ } ++ ++ ctx->start_code = ff_v4l2_request_query_control_default_value(avctx, ++ V4L2_CID_STATELESS_H264_START_CODE); ++ if (ctx->start_code != V4L2_STATELESS_H264_START_CODE_NONE && ++ ctx->start_code != V4L2_STATELESS_H264_START_CODE_ANNEX_B) { ++ av_log(ctx, AV_LOG_VERBOSE, "Unsupported start code: %d\n", ++ ctx->start_code); ++ return AVERROR(EINVAL); ++ } ++ ++ // TODO: check V4L2_CID_MPEG_VIDEO_H264_PROFILE control ++ // TODO: check V4L2_CID_MPEG_VIDEO_H264_LEVEL control ++ ++ control[0].value = ctx->decode_mode; ++ control[1].value = ctx->start_code; ++ ++ return ff_v4l2_request_set_controls(avctx, control, FF_ARRAY_ELEMS(control)); ++} ++ ++static int v4l2_request_h264_init(AVCodecContext *avctx) ++{ ++ const H264Context *h = avctx->priv_data; ++ struct v4l2_ctrl_h264_sps sps; ++ ++ struct v4l2_ext_control control[] = { ++ { ++ .id = V4L2_CID_STATELESS_H264_SPS, ++ .ptr = &sps, ++ .size = sizeof(sps), ++ }, ++ }; ++ ++ fill_sps(&sps, h); ++ ++ return ff_v4l2_request_init(avctx, control, FF_ARRAY_ELEMS(control), ++ v4l2_request_h264_post_frames_ctx); ++} ++ ++static int v4l2_request_h264_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx) ++{ ++ const H264Context *h = avctx->priv_data; ++ const SPS *sps = h ? h->ps.sps : NULL; ++ uint8_t bit_depth = sps ? sps->bit_depth_luma : 0; ++ ++ return ff_v4l2_request_frame_params(avctx, hw_frames_ctx, ++ V4L2_PIX_FMT_H264_SLICE, bit_depth); ++} ++ ++const FFHWAccel ff_h264_v4l2request_hwaccel = { ++ .p.name = "h264_v4l2request", ++ .p.type = AVMEDIA_TYPE_VIDEO, ++ .p.id = AV_CODEC_ID_H264, ++ .p.pix_fmt = AV_PIX_FMT_DRM_PRIME, ++ .start_frame = v4l2_request_h264_start_frame, ++ .decode_slice = v4l2_request_h264_decode_slice, ++ .end_frame = v4l2_request_h264_end_frame, ++ .flush = ff_v4l2_request_flush, ++ .frame_priv_data_size = sizeof(V4L2RequestControlsH264), ++ .init = v4l2_request_h264_init, ++ .uninit = ff_v4l2_request_uninit, ++ .priv_data_size = sizeof(V4L2RequestContextH264), ++ .frame_params = v4l2_request_h264_frame_params, ++ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, ++}; diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-08.patch b/multimedia/ffmpeg/patches/120-v4l2-request-08.patch new file mode 100644 index 000000000..c93695848 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-08.patch @@ -0,0 +1,874 @@ +From adab6e2bb9472e9e8f9716569d54aeede50c1aa3 Mon Sep 17 00:00:00 2001 +From: Jernej Skrabec +Date: Tue, 6 Aug 2024 09:06:07 +0000 +Subject: [PATCH 08/13] avcodec: Add V4L2 Request API hevc hwaccel + +Add a V4L2 Request API hwaccel for HEVC, supporting both slice and +frame decoding modes. + +Support for HEVC is enabled when Linux kernel headers declare the +control id V4L2_CID_STATELESS_HEVC_SPS, added in v6.0. + +Co-developed-by: Benjamin Gaignard +Signed-off-by: Benjamin Gaignard +Co-developed-by: Alex Bee +Signed-off-by: Alex Bee +Signed-off-by: Jernej Skrabec +Co-developed-by: Jonas Karlman +Signed-off-by: Jonas Karlman +--- + configure | 5 + + libavcodec/Makefile | 1 + + libavcodec/hevc/hevcdec.c | 10 + + libavcodec/hwaccels.h | 1 + + libavcodec/v4l2_request_hevc.c | 752 +++++++++++++++++++++++++++++++++ + 5 files changed, 769 insertions(+) + create mode 100644 libavcodec/v4l2_request_hevc.c + +--- a/configure ++++ b/configure +@@ -2698,6 +2698,7 @@ TYPES_LIST=" + struct_sockaddr_sa_len + struct_sockaddr_storage + struct_stat_st_mtim_tv_nsec ++ struct_v4l2_ctrl_hevc_decode_params_num_delta_pocs_of_ref_rps_idx + struct_v4l2_frmivalenum_discrete + struct_mfxConfigInterface + " +@@ -3469,6 +3470,8 @@ hevc_dxva2_hwaccel_deps="dxva2 DXVA_PicP + hevc_dxva2_hwaccel_select="hevc_decoder" + hevc_nvdec_hwaccel_deps="nvdec" + hevc_nvdec_hwaccel_select="hevc_decoder" ++hevc_v4l2request_hwaccel_deps="v4l2_request hevc_v4l2_request" ++hevc_v4l2request_hwaccel_select="hevc_decoder" + hevc_vaapi_hwaccel_deps="vaapi VAPictureParameterBufferHEVC" + hevc_vaapi_hwaccel_select="hevc_decoder" + hevc_vdpau_hwaccel_deps="vdpau VdpPictureInfoHEVC" +@@ -7667,10 +7670,12 @@ fi + + if enabled v4l2_request; then + check_cc h264_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_H264_DECODE_MODE" ++ check_cc hevc_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_HEVC_SPS" + check_cc mpeg2_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_MPEG2_SEQUENCE" + check_cc v4l2_m2m_hold_capture_buf linux/videodev2.h "int i = V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF" + check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns + check_pkg_config libudev libudev libudev.h udev_new ++ check_struct linux/videodev2.h "struct v4l2_ctrl_hevc_decode_params" num_delta_pocs_of_ref_rps_idx + v4l2_request_extralibs="$libudev_extralibs" + fi + +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -1072,6 +1072,7 @@ OBJS-$(CONFIG_HEVC_DXVA2_HWACCEL) + OBJS-$(CONFIG_HEVC_D3D12VA_HWACCEL) += dxva2_hevc.o d3d12va_hevc.o + OBJS-$(CONFIG_HEVC_NVDEC_HWACCEL) += nvdec_hevc.o + OBJS-$(CONFIG_HEVC_QSV_HWACCEL) += qsvdec.o ++OBJS-$(CONFIG_HEVC_V4L2REQUEST_HWACCEL) += v4l2_request_hevc.o + OBJS-$(CONFIG_HEVC_VAAPI_HWACCEL) += vaapi_hevc.o h265_profile_level.o + OBJS-$(CONFIG_HEVC_VDPAU_HWACCEL) += vdpau_hevc.o h265_profile_level.o + OBJS-$(CONFIG_HEVC_VULKAN_HWACCEL) += vulkan_decode.o vulkan_hevc.o +--- a/libavcodec/hevc/hevcdec.c ++++ b/libavcodec/hevc/hevcdec.c +@@ -566,6 +566,7 @@ static enum AVPixelFormat get_format(HEV + CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \ + CONFIG_HEVC_D3D12VA_HWACCEL + \ + CONFIG_HEVC_NVDEC_HWACCEL + \ ++ CONFIG_HEVC_V4L2REQUEST_HWACCEL + \ + CONFIG_HEVC_VAAPI_HWACCEL + \ + CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \ + CONFIG_HEVC_VDPAU_HWACCEL + \ +@@ -605,6 +606,9 @@ static enum AVPixelFormat get_format(HEV + #if CONFIG_HEVC_VULKAN_HWACCEL + *fmt++ = AV_PIX_FMT_VULKAN; + #endif ++#if CONFIG_HEVC_V4L2REQUEST_HWACCEL ++ *fmt++ = AV_PIX_FMT_DRM_PRIME; ++#endif + break; + case AV_PIX_FMT_YUV420P10: + #if CONFIG_HEVC_DXVA2_HWACCEL +@@ -632,6 +636,9 @@ static enum AVPixelFormat get_format(HEV + #if CONFIG_HEVC_NVDEC_HWACCEL + *fmt++ = AV_PIX_FMT_CUDA; + #endif ++#if CONFIG_HEVC_V4L2REQUEST_HWACCEL ++ *fmt++ = AV_PIX_FMT_DRM_PRIME; ++#endif + break; + case AV_PIX_FMT_YUV444P: + #if CONFIG_HEVC_VAAPI_HWACCEL +@@ -4274,6 +4281,9 @@ const FFCodec ff_hevc_decoder = { + #if CONFIG_HEVC_VULKAN_HWACCEL + HWACCEL_VULKAN(hevc), + #endif ++#if CONFIG_HEVC_V4L2REQUEST_HWACCEL ++ HWACCEL_V4L2REQUEST(hevc), ++#endif + NULL + }, + }; +--- a/libavcodec/hwaccels.h ++++ b/libavcodec/hwaccels.h +@@ -48,6 +48,7 @@ extern const struct FFHWAccel ff_hevc_d3 + extern const struct FFHWAccel ff_hevc_d3d12va_hwaccel; + extern const struct FFHWAccel ff_hevc_dxva2_hwaccel; + extern const struct FFHWAccel ff_hevc_nvdec_hwaccel; ++extern const struct FFHWAccel ff_hevc_v4l2request_hwaccel; + extern const struct FFHWAccel ff_hevc_vaapi_hwaccel; + extern const struct FFHWAccel ff_hevc_vdpau_hwaccel; + extern const struct FFHWAccel ff_hevc_videotoolbox_hwaccel; +--- /dev/null ++++ b/libavcodec/v4l2_request_hevc.c +@@ -0,0 +1,752 @@ ++/* ++ * 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 "config.h" ++ ++#include "libavutil/mem.h" ++#include "hevc/hevcdec.h" ++#include "hwaccel_internal.h" ++#include "hwconfig.h" ++#include "internal.h" ++#include "v4l2_request.h" ++ ++#define V4L2_HEVC_CONTROLS_MAX 6 ++ ++typedef struct V4L2RequestContextHEVC { ++ V4L2RequestContext base; ++ enum v4l2_stateless_hevc_decode_mode decode_mode; ++ enum v4l2_stateless_hevc_start_code start_code; ++ unsigned int max_slice_params; ++ unsigned int max_entry_point_offsets; ++ bool has_scaling_matrix; ++} V4L2RequestContextHEVC; ++ ++typedef struct V4L2RequestControlsHEVC { ++ V4L2RequestPictureContext pic; ++ struct v4l2_ctrl_hevc_sps sps; ++ struct v4l2_ctrl_hevc_pps pps; ++ struct v4l2_ctrl_hevc_decode_params decode_params; ++ struct v4l2_ctrl_hevc_scaling_matrix scaling_matrix; ++ struct v4l2_ctrl_hevc_slice_params slice_params; ++ struct v4l2_ctrl_hevc_slice_params *frame_slice_params; ++ unsigned int allocated_slice_params; ++ unsigned int num_slice_params; ++ uint32_t *entry_point_offsets; ++ unsigned int allocated_entry_point_offsets; ++ unsigned int num_entry_point_offsets; ++ bool first_slice; ++} V4L2RequestControlsHEVC; ++ ++static uint8_t nalu_slice_start_code[] = { 0x00, 0x00, 0x01 }; ++ ++static void fill_pred_weight_table(struct v4l2_hevc_pred_weight_table *table, ++ const HEVCContext *h) ++{ ++ int32_t luma_weight_denom, chroma_weight_denom; ++ const SliceHeader *sh = &h->sh; ++ ++ if (sh->slice_type == HEVC_SLICE_I || ++ (sh->slice_type == HEVC_SLICE_P && !h->pps->weighted_pred_flag) || ++ (sh->slice_type == HEVC_SLICE_B && !h->pps->weighted_bipred_flag)) ++ return; ++ ++ table->luma_log2_weight_denom = sh->luma_log2_weight_denom; ++ ++ if (h->pps->sps->chroma_format_idc) ++ table->delta_chroma_log2_weight_denom = sh->chroma_log2_weight_denom - ++ sh->luma_log2_weight_denom; ++ ++ luma_weight_denom = (1 << sh->luma_log2_weight_denom); ++ chroma_weight_denom = (1 << sh->chroma_log2_weight_denom); ++ ++ for (int i = 0; i < 15 && i < sh->nb_refs[L0]; i++) { ++ table->delta_luma_weight_l0[i] = sh->luma_weight_l0[i] - luma_weight_denom; ++ table->luma_offset_l0[i] = sh->luma_offset_l0[i]; ++ table->delta_chroma_weight_l0[i][0] = sh->chroma_weight_l0[i][0] - chroma_weight_denom; ++ table->delta_chroma_weight_l0[i][1] = sh->chroma_weight_l0[i][1] - chroma_weight_denom; ++ table->chroma_offset_l0[i][0] = sh->chroma_offset_l0[i][0]; ++ table->chroma_offset_l0[i][1] = sh->chroma_offset_l0[i][1]; ++ } ++ ++ if (sh->slice_type != HEVC_SLICE_B) ++ return; ++ ++ for (int i = 0; i < 15 && i < sh->nb_refs[L1]; i++) { ++ table->delta_luma_weight_l1[i] = sh->luma_weight_l1[i] - luma_weight_denom; ++ table->luma_offset_l1[i] = sh->luma_offset_l1[i]; ++ table->delta_chroma_weight_l1[i][0] = sh->chroma_weight_l1[i][0] - chroma_weight_denom; ++ table->delta_chroma_weight_l1[i][1] = sh->chroma_weight_l1[i][1] - chroma_weight_denom; ++ table->chroma_offset_l1[i][0] = sh->chroma_offset_l1[i][0]; ++ table->chroma_offset_l1[i][1] = sh->chroma_offset_l1[i][1]; ++ } ++} ++ ++static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame, ++ struct v4l2_ctrl_hevc_decode_params *decode_params) ++{ ++ uint64_t timestamp; ++ ++ if (!frame || !frame->f) ++ return 0; ++ ++ timestamp = ff_v4l2_request_get_capture_timestamp(frame->f); ++ ++ for (uint8_t i = 0; i < decode_params->num_active_dpb_entries; i++) { ++ struct v4l2_hevc_dpb_entry *entry = &decode_params->dpb[i]; ++ if (entry->timestamp == timestamp) ++ return i; ++ } ++ ++ return 0; ++} ++ ++static void fill_decode_params(struct v4l2_ctrl_hevc_decode_params *decode_params, ++ const HEVCContext *h) ++{ ++ const HEVCFrame *pic = h->cur_frame; ++ const HEVCLayerContext *l = &h->layers[h->cur_layer]; ++ const SliceHeader *sh = &h->sh; ++ int i, entries = 0; ++ ++ *decode_params = (struct v4l2_ctrl_hevc_decode_params) { ++ .pic_order_cnt_val = h->poc, ++ .short_term_ref_pic_set_size = sh->short_term_ref_pic_set_size, ++ .long_term_ref_pic_set_size = sh->long_term_ref_pic_set_size, ++ .num_poc_st_curr_before = h->rps[ST_CURR_BEF].nb_refs, ++ .num_poc_st_curr_after = h->rps[ST_CURR_AFT].nb_refs, ++ .num_poc_lt_curr = h->rps[LT_CURR].nb_refs, ++ }; ++ ++#if HAVE_STRUCT_V4L2_CTRL_HEVC_DECODE_PARAMS_NUM_DELTA_POCS_OF_REF_RPS_IDX ++ if (h->sh.short_term_ref_pic_set_sps_flag == 0 && h->sh.short_term_rps) ++ decode_params->num_delta_pocs_of_ref_rps_idx = ++ h->sh.short_term_rps->rps_idx_num_delta_pocs; ++#endif ++ ++ for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) { ++ const HEVCFrame *frame = &l->DPB[i]; ++ if (frame != pic && ++ (frame->flags & (HEVC_FRAME_FLAG_LONG_REF | HEVC_FRAME_FLAG_SHORT_REF))) { ++ struct v4l2_hevc_dpb_entry *entry = &decode_params->dpb[entries++]; ++ ++ entry->timestamp = ff_v4l2_request_get_capture_timestamp(frame->f); ++ entry->field_pic = !!(frame->f->flags & AV_FRAME_FLAG_INTERLACED); ++ entry->flags = 0; ++ if (frame->flags & HEVC_FRAME_FLAG_LONG_REF) ++ entry->flags |= V4L2_HEVC_DPB_ENTRY_LONG_TERM_REFERENCE; ++ ++ entry->pic_order_cnt_val = frame->poc; ++ } ++ } ++ ++ decode_params->num_active_dpb_entries = entries; ++ ++ if (IS_IRAP(h)) ++ decode_params->flags |= V4L2_HEVC_DECODE_PARAM_FLAG_IRAP_PIC; ++ ++ if (IS_IDR(h)) ++ decode_params->flags |= V4L2_HEVC_DECODE_PARAM_FLAG_IDR_PIC; ++ ++ if (sh->no_output_of_prior_pics_flag) ++ decode_params->flags |= V4L2_HEVC_DECODE_PARAM_FLAG_NO_OUTPUT_OF_PRIOR; ++ ++ for (i = 0; i < V4L2_HEVC_DPB_ENTRIES_NUM_MAX; i++) { ++ decode_params->poc_st_curr_before[i] = ++ get_ref_pic_index(h, h->rps[ST_CURR_BEF].ref[i], decode_params); ++ decode_params->poc_st_curr_after[i] = ++ get_ref_pic_index(h, h->rps[ST_CURR_AFT].ref[i], decode_params); ++ decode_params->poc_lt_curr[i] = ++ get_ref_pic_index(h, h->rps[LT_CURR].ref[i], decode_params); ++ } ++} ++ ++static int fill_slice_params(V4L2RequestControlsHEVC *controls, int slice, ++ uint32_t size, bool max_entry_point_offsets, ++ const HEVCContext *h) ++{ ++ struct v4l2_ctrl_hevc_slice_params *slice_params = &controls->frame_slice_params[slice]; ++ struct v4l2_ctrl_hevc_decode_params *decode_params = &controls->decode_params; ++ const SliceHeader *sh = &h->sh; ++ RefPicList *rpl; ++ int i, offsets; ++ ++ *slice_params = (struct v4l2_ctrl_hevc_slice_params) { ++ .bit_size = (size - sh->data_offset) * 8, ++ .data_byte_offset = controls->pic.output->bytesused + sh->data_offset, ++ .num_entry_point_offsets = sh->num_entry_point_offsets, ++ ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: NAL unit header */ ++ .nal_unit_type = h->nal_unit_type, ++ .nuh_temporal_id_plus1 = h->temporal_id + 1, ++ ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */ ++ .slice_type = sh->slice_type, ++ .colour_plane_id = sh->colour_plane_id, ++ .slice_pic_order_cnt = sh->poc, ++ .num_ref_idx_l0_active_minus1 = sh->nb_refs[L0] ? sh->nb_refs[L0] - 1 : 0, ++ .num_ref_idx_l1_active_minus1 = sh->nb_refs[L1] ? sh->nb_refs[L1] - 1 : 0, ++ .collocated_ref_idx = sh->slice_temporal_mvp_enabled_flag ? ++ sh->collocated_ref_idx : 0, ++ .five_minus_max_num_merge_cand = sh->slice_type == HEVC_SLICE_I ? ++ 0 : 5 - sh->max_num_merge_cand, ++ .slice_qp_delta = sh->slice_qp_delta, ++ .slice_cb_qp_offset = sh->slice_cb_qp_offset, ++ .slice_cr_qp_offset = sh->slice_cr_qp_offset, ++ .slice_act_y_qp_offset = 0, ++ .slice_act_cb_qp_offset = 0, ++ .slice_act_cr_qp_offset = 0, ++ .slice_beta_offset_div2 = sh->beta_offset / 2, ++ .slice_tc_offset_div2 = sh->tc_offset / 2, ++ ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture timing SEI message */ ++ .pic_struct = h->sei.picture_timing.picture_struct, ++ ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */ ++ .slice_segment_addr = sh->slice_segment_addr, ++ .short_term_ref_pic_set_size = sh->short_term_ref_pic_set_size, ++ .long_term_ref_pic_set_size = sh->long_term_ref_pic_set_size, ++ }; ++ ++ if (h->pps->pps_slice_act_qp_offsets_present_flag) { ++ slice_params->slice_act_y_qp_offset = sh->slice_act_y_qp_offset; ++ slice_params->slice_act_cb_qp_offset = sh->slice_act_cb_qp_offset; ++ slice_params->slice_act_cr_qp_offset = sh->slice_act_cr_qp_offset; ++ } ++ ++ if (sh->slice_sample_adaptive_offset_flag[0]) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA; ++ ++ if (sh->slice_sample_adaptive_offset_flag[1]) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA; ++ ++ if (sh->slice_temporal_mvp_enabled_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED; ++ ++ if (sh->mvd_l1_zero_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO; ++ ++ if (sh->cabac_init_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT; ++ ++ if (sh->collocated_list == L0) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0; ++ ++ if (sh->use_integer_mv_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV; ++ ++ if (sh->disable_deblocking_filter_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED; ++ ++ if (sh->slice_loop_filter_across_slices_enabled_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED; ++ ++ if (sh->dependent_slice_segment_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_DEPENDENT_SLICE_SEGMENT; ++ ++ if (sh->slice_type != HEVC_SLICE_I) { ++ rpl = &h->cur_frame->refPicList[0]; ++ for (i = 0; i < rpl->nb_refs; i++) ++ slice_params->ref_idx_l0[i] = get_ref_pic_index(h, rpl->ref[i], decode_params); ++ } ++ ++ if (sh->slice_type == HEVC_SLICE_B) { ++ rpl = &h->cur_frame->refPicList[1]; ++ for (i = 0; i < rpl->nb_refs; i++) ++ slice_params->ref_idx_l1[i] = get_ref_pic_index(h, rpl->ref[i], decode_params); ++ } ++ ++ fill_pred_weight_table(&slice_params->pred_weight_table, h); ++ ++ if (!max_entry_point_offsets) ++ return 0; ++ ++ if (controls->allocated_entry_point_offsets < controls->num_entry_point_offsets + sh->num_entry_point_offsets) { ++ void *entry_point_offsets = controls->entry_point_offsets; ++ offsets = controls->allocated_entry_point_offsets == 0 ? 128 : controls->allocated_entry_point_offsets * 2; ++ while (controls->num_entry_point_offsets + sh->num_entry_point_offsets > offsets) ++ offsets *= 2; ++ entry_point_offsets = av_realloc_array(entry_point_offsets, offsets, sizeof(*controls->entry_point_offsets)); ++ if (!entry_point_offsets) ++ return AVERROR(ENOMEM); ++ controls->entry_point_offsets = entry_point_offsets; ++ controls->allocated_entry_point_offsets = offsets; ++ } ++ ++ for (i = 0, offsets = controls->num_entry_point_offsets; i < sh->num_entry_point_offsets; i++) ++ controls->entry_point_offsets[offsets + i] = sh->entry_point_offset[i]; ++ controls->num_entry_point_offsets += sh->num_entry_point_offsets; ++ ++ return 0; ++} ++ ++static void fill_sps(struct v4l2_ctrl_hevc_sps *ctrl, const HEVCContext *h) ++{ ++ const HEVCPPS *pps = h->pps; ++ const HEVCSPS *sps = pps->sps; ++ ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: Sequence parameter set */ ++ *ctrl = (struct v4l2_ctrl_hevc_sps) { ++ .video_parameter_set_id = sps->vps_id, ++ .seq_parameter_set_id = pps->sps_id, ++ .pic_width_in_luma_samples = sps->width, ++ .pic_height_in_luma_samples = sps->height, ++ .bit_depth_luma_minus8 = sps->bit_depth - 8, ++ .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8, ++ .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4, ++ .sps_max_dec_pic_buffering_minus1 = ++ sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering - 1, ++ .sps_max_num_reorder_pics = ++ sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics, ++ .sps_max_latency_increase_plus1 = ++ sps->temporal_layer[sps->max_sub_layers - 1].max_latency_increase + 1, ++ .log2_min_luma_coding_block_size_minus3 = sps->log2_min_cb_size - 3, ++ .log2_diff_max_min_luma_coding_block_size = ++ sps->log2_diff_max_min_coding_block_size, ++ .log2_min_luma_transform_block_size_minus2 = sps->log2_min_tb_size - 2, ++ .log2_diff_max_min_luma_transform_block_size = ++ sps->log2_max_trafo_size - sps->log2_min_tb_size, ++ .max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter, ++ .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra, ++ .pcm_sample_bit_depth_luma_minus1 = sps->pcm.bit_depth - 1, ++ .pcm_sample_bit_depth_chroma_minus1 = sps->pcm.bit_depth_chroma - 1, ++ .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm.log2_min_pcm_cb_size - 3, ++ .log2_diff_max_min_pcm_luma_coding_block_size = ++ sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size, ++ .num_short_term_ref_pic_sets = sps->nb_st_rps, ++ .num_long_term_ref_pics_sps = sps->num_long_term_ref_pics_sps, ++ .chroma_format_idc = sps->chroma_format_idc, ++ .sps_max_sub_layers_minus1 = sps->max_sub_layers - 1, ++ }; ++ ++ if (sps->separate_colour_plane) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE; ++ ++ if (sps->scaling_list_enabled) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED; ++ ++ if (sps->amp_enabled) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_AMP_ENABLED; ++ ++ if (sps->sao_enabled) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET; ++ ++ if (sps->pcm_enabled) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_PCM_ENABLED; ++ ++ if (sps->pcm_loop_filter_disabled) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED; ++ ++ if (sps->long_term_ref_pics_present) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT; ++ ++ if (sps->temporal_mvp_enabled) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED; ++ ++ if (sps->strong_intra_smoothing_enabled) ++ ctrl->flags |= V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED; ++} ++ ++static int v4l2_request_hevc_start_frame(AVCodecContext *avctx, ++ av_unused const AVBufferRef *buf_ref, ++ av_unused const uint8_t *buffer, ++ av_unused uint32_t size) ++{ ++ const HEVCContext *h = avctx->priv_data; ++ const HEVCPPS *pps = h->pps; ++ const HEVCSPS *sps = pps->sps; ++ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsHEVC *controls = h->cur_frame->hwaccel_picture_private; ++ const SliceHeader *sh = &h->sh; ++ int ret; ++ ++ ret = ff_v4l2_request_start_frame(avctx, &controls->pic, h->cur_frame->f); ++ if (ret) ++ return ret; ++ ++ fill_sps(&controls->sps, h); ++ fill_decode_params(&controls->decode_params, h); ++ ++ if (ctx->has_scaling_matrix) { ++ const ScalingList *sl = pps->scaling_list_data_present_flag ? ++ &pps->scaling_list : ++ sps->scaling_list_enabled ? ++ &sps->scaling_list : NULL; ++ if (sl) { ++ for (int i = 0; i < 6; i++) { ++ for (int j = 0; j < 16; j++) ++ controls->scaling_matrix.scaling_list_4x4[i][j] = sl->sl[0][i][j]; ++ for (int j = 0; j < 64; j++) { ++ controls->scaling_matrix.scaling_list_8x8[i][j] = sl->sl[1][i][j]; ++ controls->scaling_matrix.scaling_list_16x16[i][j] = sl->sl[2][i][j]; ++ if (i < 2) ++ controls->scaling_matrix.scaling_list_32x32[i][j] = sl->sl[3][i * 3][j]; ++ } ++ controls->scaling_matrix.scaling_list_dc_coef_16x16[i] = sl->sl_dc[0][i]; ++ if (i < 2) ++ controls->scaling_matrix.scaling_list_dc_coef_32x32[i] = sl->sl_dc[1][i * 3]; ++ } ++ } ++ } ++ ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture parameter set */ ++ controls->pps = (struct v4l2_ctrl_hevc_pps) { ++ .pic_parameter_set_id = sh->pps_id, ++ .num_extra_slice_header_bits = pps->num_extra_slice_header_bits, ++ .num_ref_idx_l0_default_active_minus1 = pps->num_ref_idx_l0_default_active - 1, ++ .num_ref_idx_l1_default_active_minus1 = pps->num_ref_idx_l1_default_active - 1, ++ .init_qp_minus26 = pps->pic_init_qp_minus26, ++ .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth, ++ .pps_cb_qp_offset = pps->cb_qp_offset, ++ .pps_cr_qp_offset = pps->cr_qp_offset, ++ .pps_beta_offset_div2 = pps->beta_offset / 2, ++ .pps_tc_offset_div2 = pps->tc_offset / 2, ++ .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level - 2, ++ }; ++ ++ if (pps->dependent_slice_segments_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT_ENABLED; ++ ++ if (pps->output_flag_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT; ++ ++ if (pps->sign_data_hiding_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED; ++ ++ if (pps->cabac_init_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT; ++ ++ if (pps->constrained_intra_pred_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED; ++ ++ if (pps->transform_skip_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_TRANSFORM_SKIP_ENABLED; ++ ++ if (pps->cu_qp_delta_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED; ++ ++ if (pps->pic_slice_level_chroma_qp_offsets_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT; ++ ++ if (pps->weighted_pred_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED; ++ ++ if (pps->weighted_bipred_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED; ++ ++ if (pps->transquant_bypass_enable_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED; ++ ++ if (pps->tiles_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_TILES_ENABLED; ++ ++ if (pps->entropy_coding_sync_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED; ++ ++ if (pps->loop_filter_across_tiles_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED; ++ ++ if (pps->seq_loop_filter_across_slices_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED; ++ ++ if (pps->deblocking_filter_override_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED; ++ ++ if (pps->disable_dbf) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER; ++ ++ if (pps->lists_modification_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT; ++ ++ if (pps->slice_header_extension_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT; ++ ++ if (pps->deblocking_filter_control_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT; ++ ++ if (pps->uniform_spacing_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_UNIFORM_SPACING; ++ ++ if (pps->tiles_enabled_flag) { ++ controls->pps.num_tile_columns_minus1 = pps->num_tile_columns - 1; ++ controls->pps.num_tile_rows_minus1 = pps->num_tile_rows - 1; ++ ++ for (int i = 0; i < pps->num_tile_columns; i++) ++ controls->pps.column_width_minus1[i] = pps->column_width[i] - 1; ++ ++ for (int i = 0; i < pps->num_tile_rows; i++) ++ controls->pps.row_height_minus1[i] = pps->row_height[i] - 1; ++ } ++ ++ controls->first_slice = true; ++ controls->frame_slice_params = &controls->slice_params; ++ controls->allocated_slice_params = 0; ++ controls->num_slice_params = 0; ++ controls->allocated_entry_point_offsets = 0; ++ controls->num_entry_point_offsets = 0; ++ ++ return 0; ++} ++ ++static int v4l2_request_hevc_queue_decode(AVCodecContext *avctx, bool last_slice) ++{ ++ const HEVCContext *h = avctx->priv_data; ++ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsHEVC *controls = h->cur_frame->hwaccel_picture_private; ++ int count = 0; ++ ++ struct v4l2_ext_control control[V4L2_HEVC_CONTROLS_MAX] = {}; ++ ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_HEVC_SPS, ++ .ptr = &controls->sps, ++ .size = sizeof(controls->sps), ++ }; ++ ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_HEVC_PPS, ++ .ptr = &controls->pps, ++ .size = sizeof(controls->pps), ++ }; ++ ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_HEVC_DECODE_PARAMS, ++ .ptr = &controls->decode_params, ++ .size = sizeof(controls->decode_params), ++ }; ++ ++ if (ctx->has_scaling_matrix) { ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_HEVC_SCALING_MATRIX, ++ .ptr = &controls->scaling_matrix, ++ .size = sizeof(controls->scaling_matrix), ++ }; ++ } ++ ++ if (ctx->max_slice_params && controls->num_slice_params) { ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_HEVC_SLICE_PARAMS, ++ .ptr = controls->frame_slice_params, ++ .size = sizeof(*controls->frame_slice_params) * ++ FFMIN(controls->num_slice_params, ctx->max_slice_params), ++ }; ++ } ++ ++ if (ctx->max_entry_point_offsets && controls->num_entry_point_offsets) { ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETS, ++ .ptr = controls->entry_point_offsets, ++ .size = sizeof(*controls->entry_point_offsets) * ++ FFMIN(controls->num_entry_point_offsets, ++ ctx->max_entry_point_offsets), ++ }; ++ } ++ ++ if (ctx->decode_mode == V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED) ++ return ff_v4l2_request_decode_slice(avctx, &controls->pic, control, count, ++ controls->first_slice, last_slice); ++ ++ return ff_v4l2_request_decode_frame(avctx, &controls->pic, control, count); ++} ++ ++static int v4l2_request_hevc_decode_slice(AVCodecContext *avctx, ++ const uint8_t *buffer, uint32_t size) ++{ ++ const HEVCContext *h = avctx->priv_data; ++ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsHEVC *controls = h->cur_frame->hwaccel_picture_private; ++ const SliceHeader *sh = &h->sh; ++ int ret, slice = controls->num_slice_params; ++ ++ if (ctx->decode_mode == V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED && ++ (slice >= ctx->max_slice_params || (ctx->max_entry_point_offsets && ++ (controls->num_entry_point_offsets + sh->num_entry_point_offsets > ctx->max_entry_point_offsets)))) { ++ ret = v4l2_request_hevc_queue_decode(avctx, false); ++ if (ret) ++ return ret; ++ ++ ff_v4l2_request_reset_picture(avctx, &controls->pic); ++ slice = controls->num_slice_params = 0; ++ controls->num_entry_point_offsets = 0; ++ controls->first_slice = false; ++ } ++ ++ if (ctx->start_code == V4L2_STATELESS_HEVC_START_CODE_ANNEX_B) { ++ ret = ff_v4l2_request_append_output(avctx, &controls->pic, ++ nalu_slice_start_code, 3); ++ if (ret) ++ return ret; ++ } ++ ++ if (ctx->max_slice_params) { ++ if (slice && controls->allocated_slice_params < slice + 1) { ++ void *slice_params = controls->allocated_slice_params == 0 ? NULL : controls->frame_slice_params; ++ int slices = controls->allocated_slice_params == 0 ? 8 : controls->allocated_slice_params * 2; ++ slice_params = av_realloc_array(slice_params, slices, sizeof(*controls->frame_slice_params)); ++ if (!slice_params) ++ return AVERROR(ENOMEM); ++ if (controls->allocated_slice_params == 0) ++ memcpy(slice_params, controls->frame_slice_params, sizeof(*controls->frame_slice_params)); ++ controls->frame_slice_params = slice_params; ++ controls->allocated_slice_params = slices; ++ } ++ ++ ret = fill_slice_params(controls, slice, size, ++ !!ctx->max_entry_point_offsets, h); ++ if (ret) ++ return ret; ++ } ++ ++ ret = ff_v4l2_request_append_output(avctx, &controls->pic, buffer, size); ++ if (ret) ++ return ret; ++ ++ controls->num_slice_params++; ++ return 0; ++} ++ ++static int v4l2_request_hevc_end_frame(AVCodecContext *avctx) ++{ ++ return v4l2_request_hevc_queue_decode(avctx, true); ++} ++ ++static void v4l2_request_hevc_free_frame_priv(AVRefStructOpaque hwctx, void *data) ++{ ++ V4L2RequestControlsHEVC *controls = data; ++ ++ if (controls->allocated_slice_params) ++ av_freep(&controls->frame_slice_params); ++ ++ av_freep(&controls->entry_point_offsets); ++} ++ ++static int v4l2_request_hevc_post_frames_ctx(AVCodecContext *avctx) ++{ ++ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data; ++ int ret; ++ ++ struct v4l2_ext_control control[] = { ++ { .id = V4L2_CID_STATELESS_HEVC_DECODE_MODE, }, ++ { .id = V4L2_CID_STATELESS_HEVC_START_CODE, }, ++ }; ++ struct v4l2_query_ext_ctrl scaling_matrix = { ++ .id = V4L2_CID_STATELESS_HEVC_SCALING_MATRIX, ++ }; ++ struct v4l2_query_ext_ctrl entry_point_offsets = { ++ .id = V4L2_CID_STATELESS_HEVC_ENTRY_POINT_OFFSETS, ++ }; ++ struct v4l2_query_ext_ctrl slice_params = { ++ .id = V4L2_CID_STATELESS_HEVC_SLICE_PARAMS, ++ }; ++ ++ ctx->decode_mode = ff_v4l2_request_query_control_default_value(avctx, ++ V4L2_CID_STATELESS_HEVC_DECODE_MODE); ++ if (ctx->decode_mode != V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED && ++ ctx->decode_mode != V4L2_STATELESS_HEVC_DECODE_MODE_FRAME_BASED) { ++ av_log(ctx, AV_LOG_VERBOSE, "Unsupported decode mode: %d\n", ++ ctx->decode_mode); ++ return AVERROR(EINVAL); ++ } ++ ++ ctx->start_code = ff_v4l2_request_query_control_default_value(avctx, ++ V4L2_CID_STATELESS_HEVC_START_CODE); ++ if (ctx->start_code != V4L2_STATELESS_HEVC_START_CODE_NONE && ++ ctx->start_code != V4L2_STATELESS_HEVC_START_CODE_ANNEX_B) { ++ av_log(ctx, AV_LOG_VERBOSE, "Unsupported start code: %d\n", ++ ctx->start_code); ++ return AVERROR(EINVAL); ++ } ++ ++ // TODO: check V4L2_CID_MPEG_VIDEO_HEVC_PROFILE control ++ // TODO: check V4L2_CID_MPEG_VIDEO_HEVC_LEVEL control ++ ++ ret = ff_v4l2_request_query_control(avctx, &scaling_matrix); ++ if (!ret) ++ ctx->has_scaling_matrix = true; ++ else ++ ctx->has_scaling_matrix = false; ++ ++ ret = ff_v4l2_request_query_control(avctx, &entry_point_offsets); ++ if (!ret) ++ ctx->max_entry_point_offsets = FFMAX(entry_point_offsets.dims[0], 1); ++ else ++ ctx->max_entry_point_offsets = 0; ++ ++ ret = ff_v4l2_request_query_control(avctx, &slice_params); ++ if (!ret) ++ ctx->max_slice_params = FFMAX(slice_params.dims[0], 1); ++ else ++ ctx->max_slice_params = 0; ++ ++ av_log(ctx, AV_LOG_VERBOSE, "%s-based decoder with SLICE_PARAMS=%u, " ++ "ENTRY_POINT_OFFSETS=%u and SCALING_MATRIX=%d controls\n", ++ ctx->decode_mode == V4L2_STATELESS_HEVC_DECODE_MODE_SLICE_BASED ? "slice" : "frame", ++ ctx->max_slice_params, ctx->max_entry_point_offsets, ctx->has_scaling_matrix); ++ ++ control[0].value = ctx->decode_mode; ++ control[1].value = ctx->start_code; ++ ++ return ff_v4l2_request_set_controls(avctx, control, FF_ARRAY_ELEMS(control)); ++} ++ ++static int v4l2_request_hevc_init(AVCodecContext *avctx) ++{ ++ const HEVCContext *h = avctx->priv_data; ++ struct v4l2_ctrl_hevc_sps sps; ++ ++ struct v4l2_ext_control control[] = { ++ { ++ .id = V4L2_CID_STATELESS_HEVC_SPS, ++ .ptr = &sps, ++ .size = sizeof(sps), ++ }, ++ }; ++ ++ fill_sps(&sps, h); ++ ++ return ff_v4l2_request_init(avctx, control, FF_ARRAY_ELEMS(control), ++ v4l2_request_hevc_post_frames_ctx); ++} ++ ++static int v4l2_request_hevc_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx) ++{ ++ const HEVCContext *h = avctx->priv_data; ++ const HEVCSPS *sps = h && h->pps ? h->pps->sps : NULL; ++ uint8_t bit_depth = sps ? sps->bit_depth : 0; ++ ++ return ff_v4l2_request_frame_params(avctx, hw_frames_ctx, ++ V4L2_PIX_FMT_HEVC_SLICE, bit_depth); ++} ++ ++const FFHWAccel ff_hevc_v4l2request_hwaccel = { ++ .p.name = "hevc_v4l2request", ++ .p.type = AVMEDIA_TYPE_VIDEO, ++ .p.id = AV_CODEC_ID_HEVC, ++ .p.pix_fmt = AV_PIX_FMT_DRM_PRIME, ++ .start_frame = v4l2_request_hevc_start_frame, ++ .decode_slice = v4l2_request_hevc_decode_slice, ++ .end_frame = v4l2_request_hevc_end_frame, ++ .flush = ff_v4l2_request_flush, ++ .free_frame_priv = v4l2_request_hevc_free_frame_priv, ++ .frame_priv_data_size = sizeof(V4L2RequestControlsHEVC), ++ .init = v4l2_request_hevc_init, ++ .uninit = ff_v4l2_request_uninit, ++ .priv_data_size = sizeof(V4L2RequestContextHEVC), ++ .frame_params = v4l2_request_hevc_frame_params, ++ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, ++}; diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-09.patch b/multimedia/ffmpeg/patches/120-v4l2-request-09.patch new file mode 100644 index 000000000..cf811a093 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-09.patch @@ -0,0 +1,330 @@ +From 6724bfac7fd7c8b3fa31233983ac6979d0c3954d Mon Sep 17 00:00:00 2001 +From: Boris Brezillon +Date: Wed, 22 May 2019 14:46:58 +0200 +Subject: [PATCH 09/13] avcodec: Add V4L2 Request API vp8 hwaccel + +Add a V4L2 Request API hwaccel for VP8. + +Support for VP8 is enabled when Linux kernel headers declare the +control id V4L2_CID_STATELESS_VP8_FRAME, added in v5.13. + +Co-developed-by: Ezequiel Garcia +Signed-off-by: Ezequiel Garcia +Signed-off-by: Boris Brezillon +Co-developed-by: Jonas Karlman +Signed-off-by: Jonas Karlman +--- + configure | 3 + + libavcodec/Makefile | 1 + + libavcodec/hwaccels.h | 1 + + libavcodec/v4l2_request_vp8.c | 242 ++++++++++++++++++++++++++++++++++ + libavcodec/vp8.c | 6 + + 5 files changed, 253 insertions(+) + create mode 100644 libavcodec/v4l2_request_vp8.c + +--- a/configure ++++ b/configure +@@ -3540,6 +3540,8 @@ vc1_vdpau_hwaccel_deps="vdpau" + vc1_vdpau_hwaccel_select="vc1_decoder" + vp8_nvdec_hwaccel_deps="nvdec" + vp8_nvdec_hwaccel_select="vp8_decoder" ++vp8_v4l2request_hwaccel_deps="v4l2_request vp8_v4l2_request" ++vp8_v4l2request_hwaccel_select="vp8_decoder" + vp8_vaapi_hwaccel_deps="vaapi" + vp8_vaapi_hwaccel_select="vp8_decoder" + vp9_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_VP9" +@@ -7673,6 +7675,7 @@ if enabled v4l2_request; then + check_cc hevc_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_HEVC_SPS" + check_cc mpeg2_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_MPEG2_SEQUENCE" + check_cc v4l2_m2m_hold_capture_buf linux/videodev2.h "int i = V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF" ++ check_cc vp8_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_VP8_FRAME" + check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns + check_pkg_config libudev libudev libudev.h udev_new + check_struct linux/videodev2.h "struct v4l2_ctrl_hevc_decode_params" num_delta_pocs_of_ref_rps_idx +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -1102,6 +1102,7 @@ OBJS-$(CONFIG_VC1_QSV_HWACCEL) + OBJS-$(CONFIG_VC1_VAAPI_HWACCEL) += vaapi_vc1.o + OBJS-$(CONFIG_VC1_VDPAU_HWACCEL) += vdpau_vc1.o + OBJS-$(CONFIG_VP8_NVDEC_HWACCEL) += nvdec_vp8.o ++OBJS-$(CONFIG_VP8_V4L2REQUEST_HWACCEL) += v4l2_request_vp8.o + OBJS-$(CONFIG_VP8_VAAPI_HWACCEL) += vaapi_vp8.o + OBJS-$(CONFIG_VP9_D3D11VA_HWACCEL) += dxva2_vp9.o + OBJS-$(CONFIG_VP9_DXVA2_HWACCEL) += dxva2_vp9.o +--- a/libavcodec/hwaccels.h ++++ b/libavcodec/hwaccels.h +@@ -83,6 +83,7 @@ extern const struct FFHWAccel ff_vc1_nvd + extern const struct FFHWAccel ff_vc1_vaapi_hwaccel; + extern const struct FFHWAccel ff_vc1_vdpau_hwaccel; + extern const struct FFHWAccel ff_vp8_nvdec_hwaccel; ++extern const struct FFHWAccel ff_vp8_v4l2request_hwaccel; + extern const struct FFHWAccel ff_vp8_vaapi_hwaccel; + extern const struct FFHWAccel ff_vp9_d3d11va_hwaccel; + extern const struct FFHWAccel ff_vp9_d3d11va2_hwaccel; +--- /dev/null ++++ b/libavcodec/v4l2_request_vp8.c +@@ -0,0 +1,242 @@ ++/* ++ * 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 "config.h" ++ ++#include "hwaccel_internal.h" ++#include "hwconfig.h" ++#include "v4l2_request.h" ++#include "vp8.h" ++ ++typedef struct V4L2RequestControlsVP8 { ++ V4L2RequestPictureContext pic; ++ struct v4l2_ctrl_vp8_frame frame; ++} V4L2RequestControlsVP8; ++ ++static int v4l2_request_vp8_start_frame(AVCodecContext *avctx, ++ av_unused const AVBufferRef *buf_ref, ++ const uint8_t *buffer, ++ av_unused uint32_t size) ++{ ++ const VP8Context *s = avctx->priv_data; ++ V4L2RequestControlsVP8 *controls = s->framep[VP8_FRAME_CURRENT]->hwaccel_picture_private; ++ struct v4l2_ctrl_vp8_frame *ctrl = &controls->frame; ++ unsigned int header_size = 3 + 7 * s->keyframe; ++ const uint8_t *data = buffer + header_size; ++ int ret, i, j, k; ++ ++ ret = ff_v4l2_request_start_frame(avctx, &controls->pic, ++ s->framep[VP8_FRAME_CURRENT]->tf.f); ++ if (ret) ++ return ret; ++ ++ *ctrl = (struct v4l2_ctrl_vp8_frame) { ++ .lf = { ++ .sharpness_level = s->filter.sharpness, ++ .level = s->filter.level, ++ }, ++ ++ .quant = { ++ .y_ac_qi = s->quant.yac_qi, ++ .y_dc_delta = s->quant.ydc_delta, ++ .y2_dc_delta = s->quant.y2dc_delta, ++ .y2_ac_delta = s->quant.y2ac_delta, ++ .uv_dc_delta = s->quant.uvdc_delta, ++ .uv_ac_delta = s->quant.uvac_delta, ++ }, ++ ++ .coder_state = { ++ .range = s->coder_state_at_header_end.range, ++ .value = s->coder_state_at_header_end.value, ++ .bit_count = s->coder_state_at_header_end.bit_count, ++ }, ++ ++ .width = avctx->width, ++ .height = avctx->height, ++ ++ .horizontal_scale = 0, /* scale not supported by FFmpeg */ ++ .vertical_scale = 0, /* scale not supported by FFmpeg */ ++ ++ .version = s->profile & 0x3, ++ .prob_skip_false = s->prob->mbskip, ++ .prob_intra = s->prob->intra, ++ .prob_last = s->prob->last, ++ .prob_gf = s->prob->golden, ++ .num_dct_parts = s->num_coeff_partitions, ++ ++ .first_part_size = s->header_partition_size, ++ .first_part_header_bits = (8 * (s->coder_state_at_header_end.input - data) - ++ s->coder_state_at_header_end.bit_count - 8), ++ }; ++ ++ for (i = 0; i < 4; i++) { ++ ctrl->segment.quant_update[i] = s->segmentation.base_quant[i]; ++ ctrl->segment.lf_update[i] = s->segmentation.filter_level[i]; ++ } ++ ++ for (i = 0; i < 3; i++) ++ ctrl->segment.segment_probs[i] = s->prob->segmentid[i]; ++ ++ if (s->segmentation.enabled) ++ ctrl->segment.flags |= V4L2_VP8_SEGMENT_FLAG_ENABLED; ++ ++ if (s->segmentation.update_map) ++ ctrl->segment.flags |= V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP; ++ ++ if (s->segmentation.update_feature_data) ++ ctrl->segment.flags |= V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA; ++ ++ if (!s->segmentation.absolute_vals) ++ ctrl->segment.flags |= V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE; ++ ++ for (i = 0; i < 4; i++) { ++ ctrl->lf.ref_frm_delta[i] = s->lf_delta.ref[i]; ++ ctrl->lf.mb_mode_delta[i] = s->lf_delta.mode[i + MODE_I4x4]; ++ } ++ ++ if (s->lf_delta.enabled) ++ ctrl->lf.flags |= V4L2_VP8_LF_ADJ_ENABLE; ++ ++ if (s->lf_delta.update) ++ ctrl->lf.flags |= V4L2_VP8_LF_DELTA_UPDATE; ++ ++ if (s->filter.simple) ++ ctrl->lf.flags |= V4L2_VP8_LF_FILTER_TYPE_SIMPLE; ++ ++ if (s->keyframe) { ++ static const uint8_t keyframe_y_mode_probs[4] = { ++ 145, 156, 163, 128 ++ }; ++ static const uint8_t keyframe_uv_mode_probs[3] = { ++ 142, 114, 183 ++ }; ++ ++ memcpy(ctrl->entropy.y_mode_probs, keyframe_y_mode_probs, 4); ++ memcpy(ctrl->entropy.uv_mode_probs, keyframe_uv_mode_probs, 3); ++ } else { ++ for (i = 0; i < 4; i++) ++ ctrl->entropy.y_mode_probs[i] = s->prob->pred16x16[i]; ++ for (i = 0; i < 3; i++) ++ ctrl->entropy.uv_mode_probs[i] = s->prob->pred8x8c[i]; ++ } ++ for (i = 0; i < 2; i++) ++ for (j = 0; j < 19; j++) ++ ctrl->entropy.mv_probs[i][j] = s->prob->mvc[i][j]; ++ ++ for (i = 0; i < 4; i++) { ++ for (j = 0; j < 8; j++) { ++ static const int coeff_bands_inverse[8] = { ++ 0, 1, 2, 3, 5, 6, 4, 15 ++ }; ++ int coeff_pos = coeff_bands_inverse[j]; ++ ++ for (k = 0; k < 3; k++) { ++ memcpy(ctrl->entropy.coeff_probs[i][j][k], ++ s->prob->token[i][coeff_pos][k], 11); ++ } ++ } ++ } ++ ++ for (i = 0; i < 8; i++) ++ ctrl->dct_part_sizes[i] = s->coeff_partition_size[i]; ++ ++ if (s->framep[VP8_FRAME_PREVIOUS]) ++ ctrl->last_frame_ts = ++ ff_v4l2_request_get_capture_timestamp(s->framep[VP8_FRAME_PREVIOUS]->tf.f); ++ if (s->framep[VP8_FRAME_GOLDEN]) ++ ctrl->golden_frame_ts = ++ ff_v4l2_request_get_capture_timestamp(s->framep[VP8_FRAME_GOLDEN]->tf.f); ++ if (s->framep[VP8_FRAME_ALTREF]) ++ ctrl->alt_frame_ts = ++ ff_v4l2_request_get_capture_timestamp(s->framep[VP8_FRAME_ALTREF]->tf.f); ++ ++ if (s->keyframe) ++ ctrl->flags |= V4L2_VP8_FRAME_FLAG_KEY_FRAME; ++ ++ if (s->profile & 0x4) ++ ctrl->flags |= V4L2_VP8_FRAME_FLAG_EXPERIMENTAL; ++ ++ if (!s->invisible) ++ ctrl->flags |= V4L2_VP8_FRAME_FLAG_SHOW_FRAME; ++ ++ if (s->mbskip_enabled) ++ ctrl->flags |= V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF; ++ ++ if (s->sign_bias[VP8_FRAME_GOLDEN]) ++ ctrl->flags |= V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN; ++ ++ if (s->sign_bias[VP8_FRAME_ALTREF]) ++ ctrl->flags |= V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT; ++ ++ return 0; ++} ++ ++static int v4l2_request_vp8_decode_slice(AVCodecContext *avctx, ++ const uint8_t *buffer, uint32_t size) ++{ ++ const VP8Context *s = avctx->priv_data; ++ V4L2RequestControlsVP8 *controls = s->framep[VP8_FRAME_CURRENT]->hwaccel_picture_private; ++ ++ return ff_v4l2_request_append_output(avctx, &controls->pic, buffer, size); ++} ++ ++static int v4l2_request_vp8_end_frame(AVCodecContext *avctx) ++{ ++ const VP8Context *s = avctx->priv_data; ++ V4L2RequestControlsVP8 *controls = s->framep[VP8_FRAME_CURRENT]->hwaccel_picture_private; ++ ++ struct v4l2_ext_control control[] = { ++ { ++ .id = V4L2_CID_STATELESS_VP8_FRAME, ++ .ptr = &controls->frame, ++ .size = sizeof(controls->frame), ++ }, ++ }; ++ ++ return ff_v4l2_request_decode_frame(avctx, &controls->pic, ++ control, FF_ARRAY_ELEMS(control)); ++} ++ ++static int v4l2_request_vp8_init(AVCodecContext *avctx) ++{ ++ return ff_v4l2_request_init(avctx, NULL, 0, NULL); ++} ++ ++static int v4l2_request_vp8_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx) ++{ ++ return ff_v4l2_request_frame_params(avctx, hw_frames_ctx, ++ V4L2_PIX_FMT_VP8_FRAME, 8); ++} ++ ++const FFHWAccel ff_vp8_v4l2request_hwaccel = { ++ .p.name = "vp8_v4l2request", ++ .p.type = AVMEDIA_TYPE_VIDEO, ++ .p.id = AV_CODEC_ID_VP8, ++ .p.pix_fmt = AV_PIX_FMT_DRM_PRIME, ++ .start_frame = v4l2_request_vp8_start_frame, ++ .decode_slice = v4l2_request_vp8_decode_slice, ++ .end_frame = v4l2_request_vp8_end_frame, ++ .flush = ff_v4l2_request_flush, ++ .frame_priv_data_size = sizeof(V4L2RequestControlsVP8), ++ .init = v4l2_request_vp8_init, ++ .uninit = ff_v4l2_request_uninit, ++ .priv_data_size = sizeof(V4L2RequestContext), ++ .frame_params = v4l2_request_vp8_frame_params, ++ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, ++}; +--- a/libavcodec/vp8.c ++++ b/libavcodec/vp8.c +@@ -186,6 +186,9 @@ static enum AVPixelFormat get_pixel_form + #if CONFIG_VP8_NVDEC_HWACCEL + AV_PIX_FMT_CUDA, + #endif ++#if CONFIG_VP8_V4L2REQUEST_HWACCEL ++ AV_PIX_FMT_DRM_PRIME, ++#endif + AV_PIX_FMT_YUV420P, + AV_PIX_FMT_NONE, + }; +@@ -2977,6 +2980,9 @@ const FFCodec ff_vp8_decoder = { + #if CONFIG_VP8_NVDEC_HWACCEL + HWACCEL_NVDEC(vp8), + #endif ++#if CONFIG_VP8_V4L2REQUEST_HWACCEL ++ HWACCEL_V4L2REQUEST(vp8), ++#endif + NULL + }, + }; diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-10.patch b/multimedia/ffmpeg/patches/120-v4l2-request-10.patch new file mode 100644 index 000000000..619fec864 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-10.patch @@ -0,0 +1,626 @@ +From 523f6c9fa1a3b5acbc70d841ba0e8444f5d2400b Mon Sep 17 00:00:00 2001 +From: Boris Brezillon +Date: Tue, 9 Dec 2025 20:30:05 +0100 +Subject: [PATCH 10/13] avcodec: Add V4L2 Request API vp9 hwaccel + +Add a V4L2 Request API hwaccel for VP9. + +Support for VP9 is enabled when Linux kernel headers declare the +control id V4L2_CID_STATELESS_VP9_FRAME, added in v5.17. + +Signed-off-by: Boris Brezillon +Co-developed-by: Jernej Skrabec +Signed-off-by: Jernej Skrabec +Co-developed-by: Jonas Karlman +Signed-off-by: Jonas Karlman +--- + configure | 3 + + libavcodec/Makefile | 1 + + libavcodec/hwaccels.h | 1 + + libavcodec/v4l2_request_vp9.c | 530 ++++++++++++++++++++++++++++++++++ + libavcodec/vp9.c | 7 + + 5 files changed, 542 insertions(+) + create mode 100644 libavcodec/v4l2_request_vp9.c + +--- a/configure ++++ b/configure +@@ -3554,6 +3554,8 @@ vp9_dxva2_hwaccel_deps="dxva2 DXVA_PicPa + vp9_dxva2_hwaccel_select="vp9_decoder" + vp9_nvdec_hwaccel_deps="nvdec" + vp9_nvdec_hwaccel_select="vp9_decoder" ++vp9_v4l2request_hwaccel_deps="v4l2_request vp9_v4l2_request" ++vp9_v4l2request_hwaccel_select="vp9_decoder" + vp9_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferVP9_bit_depth" + vp9_vaapi_hwaccel_select="vp9_decoder" + vp9_vdpau_hwaccel_deps="vdpau VdpPictureInfoVP9" +@@ -7676,6 +7678,7 @@ if enabled v4l2_request; then + check_cc mpeg2_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_MPEG2_SEQUENCE" + check_cc v4l2_m2m_hold_capture_buf linux/videodev2.h "int i = V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF" + check_cc vp8_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_VP8_FRAME" ++ check_cc vp9_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_VP9_FRAME" + check_func_headers "linux/media.h linux/videodev2.h" v4l2_timeval_to_ns + check_pkg_config libudev libudev libudev.h udev_new + check_struct linux/videodev2.h "struct v4l2_ctrl_hevc_decode_params" num_delta_pocs_of_ref_rps_idx +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -1108,6 +1108,7 @@ OBJS-$(CONFIG_VP9_D3D11VA_HWACCEL) + OBJS-$(CONFIG_VP9_DXVA2_HWACCEL) += dxva2_vp9.o + OBJS-$(CONFIG_VP9_D3D12VA_HWACCEL) += dxva2_vp9.o d3d12va_vp9.o + OBJS-$(CONFIG_VP9_NVDEC_HWACCEL) += nvdec_vp9.o ++OBJS-$(CONFIG_VP9_V4L2REQUEST_HWACCEL) += v4l2_request_vp9.o + OBJS-$(CONFIG_VP9_VAAPI_HWACCEL) += vaapi_vp9.o + OBJS-$(CONFIG_VP9_VDPAU_HWACCEL) += vdpau_vp9.o + OBJS-$(CONFIG_VP9_VIDEOTOOLBOX_HWACCEL) += videotoolbox_vp9.o +--- a/libavcodec/hwaccels.h ++++ b/libavcodec/hwaccels.h +@@ -90,6 +90,7 @@ extern const struct FFHWAccel ff_vp9_d3d + extern const struct FFHWAccel ff_vp9_d3d12va_hwaccel; + extern const struct FFHWAccel ff_vp9_dxva2_hwaccel; + extern const struct FFHWAccel ff_vp9_nvdec_hwaccel; ++extern const struct FFHWAccel ff_vp9_v4l2request_hwaccel; + extern const struct FFHWAccel ff_vp9_vaapi_hwaccel; + extern const struct FFHWAccel ff_vp9_vdpau_hwaccel; + extern const struct FFHWAccel ff_vp9_videotoolbox_hwaccel; +--- /dev/null ++++ b/libavcodec/v4l2_request_vp9.c +@@ -0,0 +1,530 @@ ++/* ++ * 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 "config.h" ++ ++#include "hwaccel_internal.h" ++#include "hwconfig.h" ++#include "internal.h" ++#include "v4l2_request.h" ++#include "vp89_rac.h" ++#include "vp9dec.h" ++ ++#define V4L2_VP9_CONTROLS_MAX 2 ++ ++typedef struct V4L2RequestContextVP9 { ++ V4L2RequestContext base; ++ bool has_compressed_hdr; ++} V4L2RequestContextVP9; ++ ++typedef struct V4L2RequestControlsVP9 { ++ V4L2RequestPictureContext pic; ++ struct v4l2_ctrl_vp9_frame frame; ++ struct v4l2_ctrl_vp9_compressed_hdr compressed_hdr; ++} V4L2RequestControlsVP9; ++ ++// differential forward probability updates ++static int read_prob_delta(VPXRangeCoder *c) ++{ ++ static const uint8_t inv_map_table[255] = { ++ 7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176, ++ 189, 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9, ++ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, ++ 25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, ++ 40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, ++ 55, 56, 57, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, ++ 70, 71, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, ++ 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 99, 100, ++ 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115, ++ 116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130, ++ 131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145, ++ 146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, ++ 161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, ++ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, 191, ++ 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206, ++ 207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221, ++ 222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236, ++ 237, 238, 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, ++ 252, 253, 253, ++ }; ++ int d; ++ ++ /* This code is trying to do a differential probability update. For a ++ * current probability A in the range [1, 255], the difference to a new ++ * probability of any value can be expressed differentially as 1-A, 255-A ++ * where some part of this (absolute range) exists both in positive as ++ * well as the negative part, whereas another part only exists in one ++ * half. We're trying to code this shared part differentially, i.e. ++ * times two where the value of the lowest bit specifies the sign, and ++ * the single part is then coded on top of this. This absolute difference ++ * then again has a value of [0, 254], but a bigger value in this range ++ * indicates that we're further away from the original value A, so we ++ * can code this as a VLC code, since higher values are increasingly ++ * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough' ++ * updates vs. the 'fine, exact' updates further down the range, which ++ * adds one extra dimension to this differential update model. */ ++ ++ if (!vp89_rac_get(c)) { ++ d = vp89_rac_get_uint(c, 4) + 0; ++ } else if (!vp89_rac_get(c)) { ++ d = vp89_rac_get_uint(c, 4) + 16; ++ } else if (!vp89_rac_get(c)) { ++ d = vp89_rac_get_uint(c, 5) + 32; ++ } else { ++ d = vp89_rac_get_uint(c, 7); ++ if (d >= 65) ++ d = (d << 1) - 65 + vp89_rac_get(c); ++ d += 64; ++ av_assert2(d < FF_ARRAY_ELEMS(inv_map_table)); ++ } ++ ++ return inv_map_table[d]; ++} ++ ++static void fill_compressed_hdr(struct v4l2_ctrl_vp9_compressed_hdr *ctrl, ++ const uint8_t *buffer, uint32_t size, ++ AVCodecContext *avctx) ++{ ++ const VP9Context *s = avctx->priv_data; ++ enum CompPredMode comppredmode; ++ int ret, i, j, k, l, m, n; ++ VPXRangeCoder c; ++ ++ ret = ff_vpx_init_range_decoder(&c, buffer + s->s.h.uncompressed_header_size, ++ s->s.h.compressed_header_size); ++ if (ret < 0) ++ return; ++ ++ if (vpx_rac_get_prob_branchy(&c, 128)) // marker bit ++ return; ++ ++ // txfm updates ++ if (s->s.h.lossless) { ++ ctrl->tx_mode = V4L2_VP9_TX_MODE_ONLY_4X4; ++ } else { ++ ctrl->tx_mode = vp89_rac_get_uint(&c, 2); ++ if (ctrl->tx_mode == V4L2_VP9_TX_MODE_ALLOW_32X32) ++ ctrl->tx_mode += vp89_rac_get(&c); ++ ++ if (ctrl->tx_mode == V4L2_VP9_TX_MODE_SELECT) { ++ for (i = 0; i < 2; i++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->tx8[i][0] = read_prob_delta(&c); ++ for (i = 0; i < 2; i++) ++ for (j = 0; j < 2; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->tx16[i][j] = read_prob_delta(&c); ++ for (i = 0; i < 2; i++) ++ for (j = 0; j < 3; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->tx32[i][j] = read_prob_delta(&c); ++ } ++ } ++ ++ // coef updates ++ for (i = 0; i < 4; i++) { ++ if (vp89_rac_get(&c)) { ++ for (j = 0; j < 2; j++) ++ for (k = 0; k < 2; k++) ++ for (l = 0; l < 6; l++) ++ for (m = 0; m < 6; m++) { ++ if (m >= 3 && l == 0) // dc only has 3 pt ++ break; ++ for (n = 0; n < 3; n++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->coef[i][j][k][l][m][n] = ++ read_prob_delta(&c); ++ } ++ } ++ if (ctrl->tx_mode == i) ++ break; ++ } ++ ++ // mode updates ++ for (i = 0; i < 3; i++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->skip[i] = read_prob_delta(&c); ++ if (!s->s.h.keyframe && !s->s.h.intraonly) { ++ for (i = 0; i < 7; i++) ++ for (j = 0; j < 3; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->inter_mode[i][j] = read_prob_delta(&c); ++ ++ if (s->s.h.filtermode == FILTER_SWITCHABLE) ++ for (i = 0; i < 4; i++) ++ for (j = 0; j < 2; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->interp_filter[i][j] = read_prob_delta(&c); ++ ++ for (i = 0; i < 4; i++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->is_inter[i] = read_prob_delta(&c); ++ ++ if (s->s.h.allowcompinter) { ++ comppredmode = vp89_rac_get(&c); ++ if (comppredmode) ++ comppredmode += vp89_rac_get(&c); ++ if (comppredmode == PRED_SWITCHABLE) ++ for (i = 0; i < 5; i++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->comp_mode[i] = read_prob_delta(&c); ++ } else { ++ comppredmode = PRED_SINGLEREF; ++ } ++ ++ if (comppredmode != PRED_COMPREF) { ++ for (i = 0; i < 5; i++) { ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->single_ref[i][0] = read_prob_delta(&c); ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->single_ref[i][1] = read_prob_delta(&c); ++ } ++ } ++ ++ if (comppredmode != PRED_SINGLEREF) { ++ for (i = 0; i < 5; i++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->comp_ref[i] = read_prob_delta(&c); ++ } ++ ++ for (i = 0; i < 4; i++) ++ for (j = 0; j < 9; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->y_mode[i][j] = read_prob_delta(&c); ++ ++ for (i = 0; i < 4; i++) ++ for (j = 0; j < 4; j++) ++ for (k = 0; k < 3; k++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->partition[(i * 4) + j][k] = read_prob_delta(&c); ++ ++ // mv fields ++ for (i = 0; i < 3; i++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.joint[i] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ ++ for (i = 0; i < 2; i++) { ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.sign[i] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ ++ for (j = 0; j < 10; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.classes[i][j] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.class0_bit[i] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ ++ for (j = 0; j < 10; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.bits[i][j] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ } ++ ++ for (i = 0; i < 2; i++) { ++ for (j = 0; j < 2; j++) ++ for (k = 0; k < 3; k++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.class0_fr[i][j][k] = ++ (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ ++ for (j = 0; j < 3; j++) ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.fr[i][j] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ } ++ ++ if (s->s.h.highprecisionmvs) { ++ for (i = 0; i < 2; i++) { ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.class0_hp[i] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ ++ if (vpx_rac_get_prob_branchy(&c, 252)) ++ ctrl->mv.hp[i] = (vp89_rac_get_uint(&c, 7) << 1) | 1; ++ } ++ } ++ } ++ ++ memcpy(ctrl->uv_mode, s->prob.p.uv_mode, sizeof(ctrl->uv_mode)); ++} ++ ++static void fill_frame(struct v4l2_ctrl_vp9_frame *ctrl, AVCodecContext *avctx) ++{ ++ const VP9Context *s = avctx->priv_data; ++ AVFrame *ref; ++ int i; ++ ++ *ctrl = (struct v4l2_ctrl_vp9_frame) { ++ .lf = { ++ .level = s->s.h.filter.level, ++ .sharpness = s->s.h.filter.sharpness, ++ }, ++ ++ .quant = { ++ .base_q_idx = s->s.h.yac_qi, ++ .delta_q_y_dc = s->s.h.ydc_qdelta, ++ .delta_q_uv_dc = s->s.h.uvdc_qdelta, ++ .delta_q_uv_ac = s->s.h.uvac_qdelta, ++ }, ++ ++ .compressed_header_size = s->s.h.compressed_header_size, ++ .uncompressed_header_size = s->s.h.uncompressed_header_size, ++ .frame_width_minus_1 = avctx->width - 1, ++ .frame_height_minus_1 = avctx->height - 1, ++ .render_width_minus_1 = s->w - 1, ++ .render_height_minus_1 = s->h - 1, ++ .reset_frame_context = s->s.h.resetctx > 0 ? s->s.h.resetctx - 1 : 0, ++ .frame_context_idx = s->s.h.framectxid, ++ .profile = s->s.h.profile, ++ .bit_depth = s->s.h.bpp, ++ .interpolation_filter = s->s.h.filtermode ^ (s->s.h.filtermode <= 1), ++ .tile_cols_log2 = s->s.h.tiling.log2_tile_cols, ++ .tile_rows_log2 = s->s.h.tiling.log2_tile_rows, ++ .reference_mode = s->s.h.comppredmode, ++ }; ++ ++ for (i = 0; i < 4; i++) ++ ctrl->lf.ref_deltas[i] = s->s.h.lf_delta.ref[i]; ++ ++ for (i = 0; i < 2; i++) ++ ctrl->lf.mode_deltas[i] = s->s.h.lf_delta.mode[i]; ++ ++ if (s->s.h.lf_delta.enabled) ++ ctrl->lf.flags |= V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED; ++ ++ if (s->s.h.lf_delta.updated) ++ ctrl->lf.flags |= V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE; ++ ++ for (i = 0; i < 8; i++) { ++ if (s->s.h.segmentation.feat[i].q_enabled) { ++ ctrl->seg.feature_data[i][V4L2_VP9_SEG_LVL_ALT_Q] = ++ s->s.h.segmentation.feat[i].q_val; ++ ctrl->seg.feature_enabled[i] |= 1 << V4L2_VP9_SEG_LVL_ALT_Q; ++ } ++ ++ if (s->s.h.segmentation.feat[i].lf_enabled) { ++ ctrl->seg.feature_data[i][V4L2_VP9_SEG_LVL_ALT_L] = ++ s->s.h.segmentation.feat[i].lf_val; ++ ctrl->seg.feature_enabled[i] |= 1 << V4L2_VP9_SEG_LVL_ALT_L; ++ } ++ ++ if (s->s.h.segmentation.feat[i].ref_enabled) { ++ ctrl->seg.feature_data[i][V4L2_VP9_SEG_LVL_REF_FRAME] = ++ s->s.h.segmentation.feat[i].ref_val; ++ ctrl->seg.feature_enabled[i] |= 1 << V4L2_VP9_SEG_LVL_REF_FRAME; ++ } ++ ++ if (s->s.h.segmentation.feat[i].skip_enabled) ++ ctrl->seg.feature_enabled[i] |= 1 << V4L2_VP9_SEG_LVL_SKIP; ++ } ++ ++ for (i = 0; i < 7; i++) ++ ctrl->seg.tree_probs[i] = s->s.h.segmentation.prob[i]; ++ ++ if (s->s.h.segmentation.temporal) { ++ for (i = 0; i < 3; i++) ++ ctrl->seg.pred_probs[i] = s->s.h.segmentation.pred_prob[i]; ++ } else { ++ memset(ctrl->seg.pred_probs, 255, sizeof(ctrl->seg.pred_probs)); ++ } ++ ++ if (s->s.h.segmentation.enabled) ++ ctrl->seg.flags |= V4L2_VP9_SEGMENTATION_FLAG_ENABLED; ++ ++ if (s->s.h.segmentation.update_map) ++ ctrl->seg.flags |= V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP; ++ ++ if (s->s.h.segmentation.temporal) ++ ctrl->seg.flags |= V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE; ++ ++ if (s->frame_header->segmentation_update_data) ++ ctrl->seg.flags |= V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA; ++ ++ if (s->s.h.segmentation.absolute_vals) ++ ctrl->seg.flags |= V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE; ++ ++ if (s->s.h.keyframe) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_KEY_FRAME; ++ ++ if (!s->s.h.invisible) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_SHOW_FRAME; ++ ++ if (s->s.h.errorres) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT; ++ ++ if (s->s.h.intraonly) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_INTRA_ONLY; ++ ++ if (!s->s.h.keyframe && s->s.h.highprecisionmvs) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV; ++ ++ if (s->s.h.refreshctx) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX; ++ ++ if (s->s.h.parallelmode) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE; ++ ++ if (s->ss_h) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING; ++ ++ if (s->ss_v) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING; ++ ++ if (avctx->color_range == AVCOL_RANGE_JPEG) ++ ctrl->flags |= V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING; ++ ++ ref = s->s.refs[s->s.h.refidx[0]].f; ++ if (ref && ref->private_ref) ++ ctrl->last_frame_ts = ff_v4l2_request_get_capture_timestamp(ref); ++ ++ ref = s->s.refs[s->s.h.refidx[1]].f; ++ if (ref && ref->private_ref) ++ ctrl->golden_frame_ts = ff_v4l2_request_get_capture_timestamp(ref); ++ ++ ref = s->s.refs[s->s.h.refidx[2]].f; ++ if (ref && ref->private_ref) ++ ctrl->alt_frame_ts = ff_v4l2_request_get_capture_timestamp(ref); ++ ++ if (s->s.h.signbias[0]) ++ ctrl->ref_frame_sign_bias |= V4L2_VP9_SIGN_BIAS_LAST; ++ ++ if (s->s.h.signbias[1]) ++ ctrl->ref_frame_sign_bias |= V4L2_VP9_SIGN_BIAS_GOLDEN; ++ ++ if (s->s.h.signbias[2]) ++ ctrl->ref_frame_sign_bias |= V4L2_VP9_SIGN_BIAS_ALT; ++} ++ ++static int v4l2_request_vp9_start_frame(AVCodecContext *avctx, ++ av_unused const AVBufferRef *buf_ref, ++ const uint8_t *buffer, ++ uint32_t size) ++{ ++ const VP9SharedContext *h = avctx->priv_data; ++ const VP9Frame *f = &h->frames[CUR_FRAME]; ++ V4L2RequestContextVP9 *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsVP9 *controls = f->hwaccel_picture_private; ++ int ret; ++ ++ ret = ff_v4l2_request_start_frame(avctx, &controls->pic, f->tf.f); ++ if (ret) ++ return ret; ++ ++ fill_frame(&controls->frame, avctx); ++ ++ if (ctx->has_compressed_hdr) ++ fill_compressed_hdr(&controls->compressed_hdr, buffer, size, avctx); ++ ++ return 0; ++} ++ ++static int v4l2_request_vp9_decode_slice(AVCodecContext *avctx, ++ const uint8_t *buffer, uint32_t size) ++{ ++ const VP9SharedContext *h = avctx->priv_data; ++ V4L2RequestControlsVP9 *controls = h->frames[CUR_FRAME].hwaccel_picture_private; ++ ++ return ff_v4l2_request_append_output(avctx, &controls->pic, buffer, size); ++} ++ ++static int v4l2_request_vp9_end_frame(AVCodecContext *avctx) ++{ ++ const VP9SharedContext *h = avctx->priv_data; ++ V4L2RequestContextVP9 *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsVP9 *controls = h->frames[CUR_FRAME].hwaccel_picture_private; ++ int count = 0; ++ ++ struct v4l2_ext_control control[V4L2_VP9_CONTROLS_MAX] = {}; ++ ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_VP9_FRAME, ++ .ptr = &controls->frame, ++ .size = sizeof(controls->frame), ++ }; ++ ++ if (ctx->has_compressed_hdr) { ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_VP9_COMPRESSED_HDR, ++ .ptr = &controls->compressed_hdr, ++ .size = sizeof(controls->compressed_hdr), ++ }; ++ } ++ ++ return ff_v4l2_request_decode_frame(avctx, &controls->pic, control, count); ++} ++ ++static int v4l2_request_vp9_post_frames_ctx(AVCodecContext *avctx) ++{ ++ V4L2RequestContextVP9 *ctx = avctx->internal->hwaccel_priv_data; ++ ++ struct v4l2_query_ext_ctrl compressed_hdr = { ++ .id = V4L2_CID_STATELESS_VP9_COMPRESSED_HDR, ++ }; ++ ++ // TODO: check V4L2_CID_MPEG_VIDEO_VP9_PROFILE ++ // TODO: check V4L2_CID_MPEG_VIDEO_VP9_LEVEL ++ ++ if (!ff_v4l2_request_query_control(avctx, &compressed_hdr)) ++ ctx->has_compressed_hdr = true; ++ else ++ ctx->has_compressed_hdr = false; ++ ++ return 0; ++} ++ ++static int v4l2_request_vp9_init(AVCodecContext *avctx) ++{ ++ struct v4l2_ctrl_vp9_frame frame; ++ ++ struct v4l2_ext_control control[] = { ++ { ++ .id = V4L2_CID_STATELESS_VP9_FRAME, ++ .ptr = &frame, ++ .size = sizeof(frame), ++ }, ++ }; ++ ++ fill_frame(&frame, avctx); ++ ++ return ff_v4l2_request_init(avctx, control, FF_ARRAY_ELEMS(control), ++ v4l2_request_vp9_post_frames_ctx); ++} ++ ++static int v4l2_request_vp9_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx) ++{ ++ const VP9Context *s = avctx->priv_data; ++ uint8_t bit_depth = s ? s->s.h.bpp : 0; ++ ++ return ff_v4l2_request_frame_params(avctx, hw_frames_ctx, ++ V4L2_PIX_FMT_VP9_FRAME, bit_depth); ++} ++ ++const FFHWAccel ff_vp9_v4l2request_hwaccel = { ++ .p.name = "vp9_v4l2request", ++ .p.type = AVMEDIA_TYPE_VIDEO, ++ .p.id = AV_CODEC_ID_VP9, ++ .p.pix_fmt = AV_PIX_FMT_DRM_PRIME, ++ .start_frame = v4l2_request_vp9_start_frame, ++ .decode_slice = v4l2_request_vp9_decode_slice, ++ .end_frame = v4l2_request_vp9_end_frame, ++ .flush = ff_v4l2_request_flush, ++ .frame_priv_data_size = sizeof(V4L2RequestControlsVP9), ++ .init = v4l2_request_vp9_init, ++ .uninit = ff_v4l2_request_uninit, ++ .priv_data_size = sizeof(V4L2RequestContextVP9), ++ .frame_params = v4l2_request_vp9_frame_params, ++ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, ++}; +--- a/libavcodec/vp9.c ++++ b/libavcodec/vp9.c +@@ -168,6 +168,7 @@ static int update_size(AVCodecContext *a + CONFIG_VP9_D3D11VA_HWACCEL * 2 + \ + CONFIG_VP9_D3D12VA_HWACCEL + \ + CONFIG_VP9_NVDEC_HWACCEL + \ ++ CONFIG_VP9_V4L2REQUEST_HWACCEL + \ + CONFIG_VP9_VAAPI_HWACCEL + \ + CONFIG_VP9_VDPAU_HWACCEL + \ + CONFIG_VP9_VIDEOTOOLBOX_HWACCEL + \ +@@ -214,6 +215,9 @@ static int update_size(AVCodecContext *a + #if CONFIG_VP9_VULKAN_HWACCEL + *fmtp++ = AV_PIX_FMT_VULKAN; + #endif ++#if CONFIG_VP9_V4L2REQUEST_HWACCEL ++ *fmtp++ = AV_PIX_FMT_DRM_PRIME; ++#endif + break; + case AV_PIX_FMT_YUV420P12: + #if CONFIG_VP9_NVDEC_HWACCEL +@@ -1959,6 +1963,9 @@ const FFCodec ff_vp9_decoder = { + #if CONFIG_VP9_VULKAN_HWACCEL + HWACCEL_VULKAN(vp9), + #endif ++#if CONFIG_VP9_V4L2REQUEST_HWACCEL ++ HWACCEL_V4L2REQUEST(vp9), ++#endif + NULL + }, + }; diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-11.patch b/multimedia/ffmpeg/patches/120-v4l2-request-11.patch new file mode 100644 index 000000000..276e60d1d --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-11.patch @@ -0,0 +1,738 @@ +From 6b67aa32fc3b9cad3e2487875e058ba726e0513d Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Sat, 6 Jul 2024 08:41:30 +0000 +Subject: [PATCH 11/13] avcodec: Add V4L2 Request API av1 hwaccel + +Add a V4L2 Request API hwaccel for AV1. + +Support for AV1 is enabled when Linux kernel headers declare the +control id V4L2_CID_STATELESS_AV1_FRAME, added in v6.5. + +Signed-off-by: Jonas Karlman +--- + configure | 3 + + libavcodec/Makefile | 1 + + libavcodec/av1dec.c | 10 + + libavcodec/hwaccels.h | 1 + + libavcodec/v4l2_request_av1.c | 636 ++++++++++++++++++++++++++++++++++ + 5 files changed, 651 insertions(+) + create mode 100644 libavcodec/v4l2_request_av1.c + +--- a/configure ++++ b/configure +@@ -3424,6 +3424,8 @@ av1_dxva2_hwaccel_deps="dxva2 DXVA_PicPa + av1_dxva2_hwaccel_select="av1_decoder" + av1_nvdec_hwaccel_deps="nvdec CUVIDAV1PICPARAMS" + av1_nvdec_hwaccel_select="av1_decoder" ++av1_v4l2request_hwaccel_deps="v4l2_request av1_v4l2_request" ++av1_v4l2request_hwaccel_select="av1_decoder" + av1_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferAV1_bit_depth_idx" + av1_vaapi_hwaccel_select="av1_decoder" + av1_vdpau_hwaccel_deps="vdpau VdpPictureInfoAV1" +@@ -7673,6 +7675,7 @@ if enabled v4l2_m2m; then + fi + + if enabled v4l2_request; then ++ check_cc av1_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_AV1_SEQUENCE" + check_cc h264_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_H264_DECODE_MODE" + check_cc hevc_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_HEVC_SPS" + check_cc mpeg2_v4l2_request linux/videodev2.h "int i = V4L2_CID_STATELESS_MPEG2_SEQUENCE" +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -1049,6 +1049,7 @@ OBJS-$(CONFIG_AV1_D3D11VA_HWACCEL) + OBJS-$(CONFIG_AV1_DXVA2_HWACCEL) += dxva2_av1.o + OBJS-$(CONFIG_AV1_D3D12VA_HWACCEL) += dxva2_av1.o d3d12va_av1.o + OBJS-$(CONFIG_AV1_NVDEC_HWACCEL) += nvdec_av1.o ++OBJS-$(CONFIG_AV1_V4L2REQUEST_HWACCEL) += v4l2_request_av1.o + OBJS-$(CONFIG_AV1_VAAPI_HWACCEL) += vaapi_av1.o + OBJS-$(CONFIG_AV1_VDPAU_HWACCEL) += vdpau_av1.o + OBJS-$(CONFIG_AV1_VIDEOTOOLBOX_HWACCEL) += videotoolbox_av1.o +--- a/libavcodec/av1dec.c ++++ b/libavcodec/av1dec.c +@@ -543,6 +543,7 @@ static int get_pixel_format(AVCodecConte + CONFIG_AV1_D3D11VA_HWACCEL * 2 + \ + CONFIG_AV1_D3D12VA_HWACCEL + \ + CONFIG_AV1_NVDEC_HWACCEL + \ ++ CONFIG_AV1_V4L2REQUEST_HWACCEL + \ + CONFIG_AV1_VAAPI_HWACCEL + \ + CONFIG_AV1_VDPAU_HWACCEL + \ + CONFIG_AV1_VIDEOTOOLBOX_HWACCEL + \ +@@ -579,6 +580,9 @@ static int get_pixel_format(AVCodecConte + #if CONFIG_AV1_VULKAN_HWACCEL + *fmtp++ = AV_PIX_FMT_VULKAN; + #endif ++#if CONFIG_AV1_V4L2REQUEST_HWACCEL ++ *fmtp++ = AV_PIX_FMT_DRM_PRIME; ++#endif + break; + case AV_PIX_FMT_YUV420P10: + #if CONFIG_AV1_DXVA2_HWACCEL +@@ -606,6 +610,9 @@ static int get_pixel_format(AVCodecConte + #if CONFIG_AV1_VULKAN_HWACCEL + *fmtp++ = AV_PIX_FMT_VULKAN; + #endif ++#if CONFIG_AV1_V4L2REQUEST_HWACCEL ++ *fmtp++ = AV_PIX_FMT_DRM_PRIME; ++#endif + break; + case AV_PIX_FMT_YUV420P12: + #if CONFIG_AV1_VULKAN_HWACCEL +@@ -1567,6 +1574,9 @@ const FFCodec ff_av1_decoder = { + #if CONFIG_AV1_VULKAN_HWACCEL + HWACCEL_VULKAN(av1), + #endif ++#if CONFIG_AV1_V4L2REQUEST_HWACCEL ++ HWACCEL_V4L2REQUEST(av1), ++#endif + + NULL + }, +--- a/libavcodec/hwaccels.h ++++ b/libavcodec/hwaccels.h +@@ -25,6 +25,7 @@ extern const struct FFHWAccel ff_av1_d3d + extern const struct FFHWAccel ff_av1_d3d12va_hwaccel; + extern const struct FFHWAccel ff_av1_dxva2_hwaccel; + extern const struct FFHWAccel ff_av1_nvdec_hwaccel; ++extern const struct FFHWAccel ff_av1_v4l2request_hwaccel; + extern const struct FFHWAccel ff_av1_vaapi_hwaccel; + extern const struct FFHWAccel ff_av1_vdpau_hwaccel; + extern const struct FFHWAccel ff_av1_videotoolbox_hwaccel; +--- /dev/null ++++ b/libavcodec/v4l2_request_av1.c +@@ -0,0 +1,636 @@ ++/* ++ * 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 "config.h" ++ ++#include "libavutil/mem.h" ++#include "hwaccel_internal.h" ++#include "hwconfig.h" ++#include "av1dec.h" ++#include "internal.h" ++#include "v4l2_request.h" ++ ++#define V4L2_AV1_CONTROLS_MAX 4 ++ ++typedef struct V4L2RequestContextAV1 { ++ V4L2RequestContext base; ++ bool has_film_grain; ++} V4L2RequestContextAV1; ++ ++typedef struct V4L2RequestControlsAV1 { ++ V4L2RequestPictureContext pic; ++ struct v4l2_ctrl_av1_sequence sequence; ++ struct v4l2_ctrl_av1_frame frame; ++ struct v4l2_ctrl_av1_film_grain film_grain; ++ struct v4l2_ctrl_av1_tile_group_entry tile_group_entry; ++ struct v4l2_ctrl_av1_tile_group_entry *tile_group_entries; ++ unsigned int allocated_tile_group_entries; ++ unsigned int num_tile_group_entries; ++} V4L2RequestControlsAV1; ++ ++static int get_bit_depth_from_seq(const AV1RawSequenceHeader *seq) ++{ ++ if (seq->seq_profile == AV_PROFILE_AV1_PROFESSIONAL && ++ seq->color_config.high_bitdepth) ++ return seq->color_config.twelve_bit ? 12 : 10; ++ else ++ return seq->color_config.high_bitdepth ? 10 : 8; ++} ++ ++static void fill_sequence(struct v4l2_ctrl_av1_sequence *ctrl, ++ const AV1DecContext *s) ++{ ++ const AV1RawSequenceHeader *seq = s->raw_seq; ++ ++ *ctrl = (struct v4l2_ctrl_av1_sequence) { ++ .seq_profile = seq->seq_profile, ++ .order_hint_bits = seq->enable_order_hint ? ++ seq->order_hint_bits_minus_1 + 1 : 0, ++ .bit_depth = get_bit_depth_from_seq(seq), ++ .max_frame_width_minus_1 = seq->max_frame_width_minus_1, ++ .max_frame_height_minus_1 = seq->max_frame_height_minus_1, ++ }; ++ ++ if (seq->still_picture) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE; ++ ++ if (seq->use_128x128_superblock) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK; ++ ++ if (seq->enable_filter_intra) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA; ++ ++ if (seq->enable_intra_edge_filter) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER; ++ ++ if (seq->enable_interintra_compound) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND; ++ ++ if (seq->enable_masked_compound) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND; ++ ++ if (seq->enable_warped_motion) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION; ++ ++ if (seq->enable_dual_filter) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER; ++ ++ if (seq->enable_order_hint) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT; ++ ++ if (seq->enable_jnt_comp) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP; ++ ++ if (seq->enable_ref_frame_mvs) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS; ++ ++ if (seq->enable_superres) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES; ++ ++ if (seq->enable_cdef) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF; ++ ++ if (seq->enable_restoration) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION; ++ ++ if (seq->color_config.mono_chrome) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME; ++ ++ if (seq->color_config.color_range) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE; ++ ++ if (seq->color_config.subsampling_x) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X; ++ ++ if (seq->color_config.subsampling_y) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y; ++ ++ if (seq->film_grain_params_present) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT; ++ ++ if (seq->color_config.separate_uv_delta_q) ++ ctrl->flags |= V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q; ++} ++ ++static void fill_frame(struct v4l2_ctrl_av1_frame *ctrl, const AV1DecContext *s) ++{ ++ const AV1RawFrameHeader *frame_header = s->raw_frame_header; ++ const CodedBitstreamAV1Context *cbctx = s->cbc->priv_data; ++ uint8_t remap_lr_type[4] = { ++ V4L2_AV1_FRAME_RESTORE_NONE, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE, ++ V4L2_AV1_FRAME_RESTORE_WIENER, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ, ++ }; ++ int i, j; ++ ++ *ctrl = (struct v4l2_ctrl_av1_frame) { ++ .tile_info = { ++ .context_update_tile_id = frame_header->context_update_tile_id, ++ .tile_cols = frame_header->tile_cols, ++ .tile_rows = frame_header->tile_rows, ++ .tile_size_bytes = frame_header->tile_cols_log2 > 0 || ++ frame_header->tile_rows_log2 > 0 ? ++ frame_header->tile_size_bytes_minus1 + 1 : 0, ++ }, ++ ++ .quantization = { ++ .base_q_idx = frame_header->base_q_idx, ++ .delta_q_y_dc = frame_header->delta_q_y_dc, ++ .delta_q_u_dc = frame_header->delta_q_u_dc, ++ .delta_q_u_ac = frame_header->delta_q_u_ac, ++ .delta_q_v_dc = frame_header->delta_q_v_dc, ++ .delta_q_v_ac = frame_header->delta_q_v_ac, ++ .qm_y = frame_header->qm_y, ++ .qm_u = frame_header->qm_u, ++ .qm_v = frame_header->qm_v, ++ .delta_q_res = frame_header->delta_q_res, ++ }, ++ ++ .loop_filter = { ++ .level[0] = frame_header->loop_filter_level[0], ++ .level[1] = frame_header->loop_filter_level[1], ++ .level[2] = frame_header->loop_filter_level[2], ++ .level[3] = frame_header->loop_filter_level[3], ++ .sharpness = frame_header->loop_filter_sharpness, ++ .mode_deltas[0] = frame_header->loop_filter_mode_deltas[0], ++ .mode_deltas[1] = frame_header->loop_filter_mode_deltas[1], ++ .delta_lf_res = frame_header->delta_lf_res, ++ }, ++ ++ .cdef = { ++ .damping_minus_3 = frame_header->cdef_damping_minus_3, ++ .bits = frame_header->cdef_bits, ++ }, ++ ++ .loop_restoration = { ++ .lr_unit_shift = frame_header->lr_unit_shift, ++ .lr_uv_shift = frame_header->lr_uv_shift, ++ }, ++ ++ .superres_denom = frame_header->use_superres ? ++ frame_header->coded_denom + AV1_SUPERRES_DENOM_MIN : ++ AV1_SUPERRES_NUM, ++ .skip_mode_frame[0] = frame_header->skip_mode_present ? ++ s->cur_frame.skip_mode_frame_idx[0] : 0, ++ .skip_mode_frame[1] = frame_header->skip_mode_present ? ++ s->cur_frame.skip_mode_frame_idx[1] : 0, ++ .primary_ref_frame = frame_header->primary_ref_frame, ++ .frame_type = frame_header->frame_type, ++ .order_hint = frame_header->order_hint, ++ .upscaled_width = cbctx->upscaled_width, ++ .interpolation_filter = frame_header->interpolation_filter, ++ .tx_mode = frame_header->tx_mode, ++ .frame_width_minus_1 = cbctx->frame_width - 1, ++ .frame_height_minus_1 = cbctx->frame_height - 1, ++ .render_width_minus_1 = cbctx->render_width - 1, ++ .render_height_minus_1 = cbctx->render_height - 1, ++ .current_frame_id = frame_header->current_frame_id, ++ .refresh_frame_flags = frame_header->refresh_frame_flags, ++ }; ++ ++ if (frame_header->segmentation_enabled) ++ ctrl->segmentation.flags |= V4L2_AV1_SEGMENTATION_FLAG_ENABLED; ++ ++ if (frame_header->segmentation_update_map) ++ ctrl->segmentation.flags |= V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP; ++ ++ if (frame_header->segmentation_temporal_update) ++ ctrl->segmentation.flags |= V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE; ++ ++ if (frame_header->segmentation_update_data) ++ ctrl->segmentation.flags |= V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA; ++ ++ for (i = 0; i < AV1_MAX_SEGMENTS; i++) { ++ for (j = 0; j < AV1_SEG_LVL_MAX; j++) { ++ if (frame_header->feature_enabled[i][j]) { ++ ctrl->segmentation.feature_enabled[i] |= V4L2_AV1_SEGMENT_FEATURE_ENABLED(j); ++ ctrl->segmentation.last_active_seg_id = i; ++ if (j >= AV1_SEG_LVL_REF_FRAME) ++ ctrl->segmentation.flags |= V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP; ++ } ++ ctrl->segmentation.feature_data[i][j] = frame_header->feature_value[i][j]; ++ } ++ } ++ ++ if (frame_header->uniform_tile_spacing_flag) ++ ctrl->tile_info.flags |= V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING; ++ ++ for (i = 0; i < frame_header->tile_cols; i++) { ++ ctrl->tile_info.mi_col_starts[i] = frame_header->tile_start_col_sb[i]; ++ ctrl->tile_info.width_in_sbs_minus_1[i] = frame_header->width_in_sbs_minus_1[i]; ++ } ++ ctrl->tile_info.mi_col_starts[i] = 2 * ((cbctx->frame_width + 7) >> 3); ++ ++ for (i = 0; i < frame_header->tile_rows; i++) { ++ ctrl->tile_info.mi_row_starts[i] = frame_header->tile_start_row_sb[i]; ++ ctrl->tile_info.height_in_sbs_minus_1[i] = frame_header->height_in_sbs_minus_1[i]; ++ } ++ ctrl->tile_info.mi_row_starts[i] = 2 * ((cbctx->frame_height + 7) >> 3); ++ ++ if (frame_header->diff_uv_delta) ++ ctrl->quantization.flags |= V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA; ++ ++ if (frame_header->using_qmatrix) ++ ctrl->quantization.flags |= V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX; ++ ++ if (frame_header->delta_q_present) ++ ctrl->quantization.flags |= V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT; ++ ++ if (frame_header->loop_filter_delta_enabled) ++ ctrl->loop_filter.flags |= V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED; ++ ++ if (frame_header->loop_filter_delta_update) ++ ctrl->loop_filter.flags |= V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE; ++ ++ if (frame_header->delta_lf_present) ++ ctrl->loop_filter.flags |= V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT; ++ ++ if (frame_header->delta_lf_multi) ++ ctrl->loop_filter.flags |= V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI; ++ ++ for (i = 0; i < AV1_NUM_REF_FRAMES; i++) { ++ ctrl->loop_filter.ref_deltas[i] = frame_header->loop_filter_ref_deltas[i]; ++ } ++ ++ for (i = 0; i < cbctx->num_planes; i++) { ++ ctrl->loop_restoration.frame_restoration_type[i] = ++ remap_lr_type[frame_header->lr_type[i]]; ++ if (frame_header->lr_type[i] != AV1_RESTORE_NONE) { ++ ctrl->loop_restoration.flags |= V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR; ++ if (i > 0) ++ ctrl->loop_restoration.flags |= V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR; ++ } ++ } ++ if (ctrl->loop_restoration.flags & V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR) { ++ ctrl->loop_restoration.loop_restoration_size[0] = ++ 1 << (6 + frame_header->lr_unit_shift); ++ ctrl->loop_restoration.loop_restoration_size[1] = ++ 1 << (6 + frame_header->lr_unit_shift - frame_header->lr_uv_shift); ++ ctrl->loop_restoration.loop_restoration_size[2] = ++ 1 << (6 + frame_header->lr_unit_shift - frame_header->lr_uv_shift); ++ } ++ ++ for (i = 0; i < AV1_TOTAL_REFS_PER_FRAME; i++) { ++ ctrl->global_motion.type[i] = s->cur_frame.gm_type[i]; ++ for (j = 0; j < 6; ++j) { ++ ctrl->global_motion.params[i][j] = s->cur_frame.gm_params[i][j]; ++ if (s->cur_frame.gm_invalid[i]) ++ ctrl->global_motion.invalid |= V4L2_AV1_GLOBAL_MOTION_IS_INVALID(i); ++ } ++ ++ if (frame_header->is_global[i]) ++ ctrl->global_motion.flags[i] |= V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL; ++ ++ if (frame_header->is_rot_zoom[i]) ++ ctrl->global_motion.flags[i] |= V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM; ++ ++ if (frame_header->is_translation[i]) ++ ctrl->global_motion.flags[i] |= V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION; ++ } ++ ++ for (i = 0; i < AV1_TOTAL_REFS_PER_FRAME; i++) { ++ AVFrame *ref = s->ref[i].f; ++ ++ ctrl->order_hints[i] = s->cur_frame.order_hints[i]; ++ if (ref) ++ ctrl->reference_frame_ts[i] = ff_v4l2_request_get_capture_timestamp(ref); ++ if (i < AV1_REFS_PER_FRAME) ++ ctrl->ref_frame_idx[i] = frame_header->ref_frame_idx[i]; ++ } ++ ++ for (i = 0; i < (1 << frame_header->cdef_bits); i++) { ++ ctrl->cdef.y_pri_strength[i] = frame_header->cdef_y_pri_strength[i]; ++ ctrl->cdef.y_sec_strength[i] = frame_header->cdef_y_sec_strength[i]; ++ ctrl->cdef.uv_pri_strength[i] = frame_header->cdef_uv_pri_strength[i]; ++ ctrl->cdef.uv_sec_strength[i] = frame_header->cdef_uv_sec_strength[i]; ++ } ++ ++ if (frame_header->show_frame) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_SHOW_FRAME; ++ ++ if (frame_header->showable_frame) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME; ++ ++ if (frame_header->error_resilient_mode) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE; ++ ++ if (frame_header->disable_cdf_update) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE; ++ ++ if (frame_header->allow_screen_content_tools) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS; ++ ++ if (s->cur_frame.force_integer_mv) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV; ++ ++ if (frame_header->allow_intrabc) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC; ++ ++ if (frame_header->use_superres) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_USE_SUPERRES; ++ ++ if (frame_header->allow_high_precision_mv) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV; ++ ++ if (frame_header->is_motion_mode_switchable) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE; ++ ++ if (frame_header->use_ref_frame_mvs) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS; ++ ++ if (frame_header->disable_frame_end_update_cdf) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF; ++ ++ if (frame_header->allow_warped_motion) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION; ++ ++ if (frame_header->reference_select) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT; ++ ++ if (frame_header->reduced_tx_set) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET; ++ ++ if (frame_header->skip_mode_present) { ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED; // FIXME ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT; ++ } ++ ++ if (frame_header->frame_size_override_flag) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE; ++ ++ if (frame_header->buffer_removal_time_present_flag) { ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT; ++ for (i = 0; i < AV1_MAX_OPERATING_POINTS; i++) ++ ctrl->buffer_removal_time[i] = frame_header->buffer_removal_time[i]; ++ } ++ ++ if (frame_header->frame_refs_short_signaling) ++ ctrl->flags |= V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING; ++} ++ ++static void fill_film_grain(struct v4l2_ctrl_av1_film_grain *ctrl, ++ const AV1DecContext *s) ++{ ++ const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain; ++ int i; ++ ++ *ctrl = (struct v4l2_ctrl_av1_film_grain) { ++ .cr_mult = film_grain->cr_mult, ++ .grain_seed = film_grain->grain_seed, ++ .film_grain_params_ref_idx = film_grain->film_grain_params_ref_idx, ++ .num_y_points = film_grain->num_y_points, ++ .num_cb_points = film_grain->num_cb_points, ++ .num_cr_points = film_grain->num_cr_points, ++ .grain_scaling_minus_8 = film_grain->grain_scaling_minus_8, ++ .ar_coeff_lag = film_grain->ar_coeff_lag, ++ .ar_coeff_shift_minus_6 = film_grain->ar_coeff_shift_minus_6, ++ .grain_scale_shift = film_grain->grain_scale_shift, ++ .cb_mult = film_grain->cb_mult, ++ .cb_luma_mult = film_grain->cb_luma_mult, ++ .cr_luma_mult = film_grain->cr_luma_mult, ++ .cb_offset = film_grain->cb_offset, ++ .cr_offset = film_grain->cr_offset, ++ }; ++ ++ if (film_grain->apply_grain) ++ ctrl->flags |= V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN; ++ ++ if (film_grain->update_grain) ++ ctrl->flags |= V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN; ++ ++ if (film_grain->chroma_scaling_from_luma) ++ ctrl->flags |= V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA; ++ ++ if (film_grain->overlap_flag) ++ ctrl->flags |= V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP; ++ ++ if (film_grain->clip_to_restricted_range) ++ ctrl->flags |= V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE; ++ ++ if (!film_grain->apply_grain) ++ return; ++ ++ for (i = 0; i < film_grain->num_y_points; i++) { ++ ctrl->point_y_value[i] = film_grain->point_y_value[i]; ++ ctrl->point_y_scaling[i] = film_grain->point_y_scaling[i]; ++ } ++ ++ for (i = 0; i < film_grain->num_cb_points; i++) { ++ ctrl->point_cb_value[i] = film_grain->point_cb_value[i]; ++ ctrl->point_cb_scaling[i] = film_grain->point_cb_scaling[i]; ++ } ++ ++ for (i = 0; i < film_grain->num_cr_points; i++) { ++ ctrl->point_cr_value[i] = film_grain->point_cr_value[i]; ++ ctrl->point_cr_scaling[i] = film_grain->point_cr_scaling[i]; ++ } ++ ++ for (i = 0; i < 24; i++) { ++ ctrl->ar_coeffs_y_plus_128[i] = film_grain->ar_coeffs_y_plus_128[i]; ++ } ++ ++ for (i = 0; i < 25; i++) { ++ ctrl->ar_coeffs_cb_plus_128[i] = film_grain->ar_coeffs_cb_plus_128[i]; ++ ctrl->ar_coeffs_cr_plus_128[i] = film_grain->ar_coeffs_cr_plus_128[i]; ++ } ++} ++ ++static int v4l2_request_av1_start_frame(AVCodecContext *avctx, ++ av_unused const AVBufferRef *buf_ref, ++ av_unused const uint8_t *buffer, ++ av_unused uint32_t size) ++{ ++ const AV1DecContext *s = avctx->priv_data; ++ V4L2RequestContextAV1 *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsAV1 *controls = s->cur_frame.hwaccel_picture_private; ++ int ret; ++ ++ ret = ff_v4l2_request_start_frame(avctx, &controls->pic, s->cur_frame.f); ++ if (ret) ++ return ret; ++ ++ fill_sequence(&controls->sequence, s); ++ fill_frame(&controls->frame, s); ++ ++ if (ctx->has_film_grain) ++ fill_film_grain(&controls->film_grain, s); ++ ++ controls->tile_group_entries = &controls->tile_group_entry; ++ controls->allocated_tile_group_entries = 0; ++ controls->num_tile_group_entries = 0; ++ ++ return 0; ++} ++ ++static int v4l2_request_av1_decode_slice(AVCodecContext *avctx, ++ const uint8_t *buffer, uint32_t size) ++{ ++ const AV1DecContext *s = avctx->priv_data; ++ const AV1RawFrameHeader *fh = s->raw_frame_header; ++ V4L2RequestControlsAV1 *controls = s->cur_frame.hwaccel_picture_private; ++ ++ controls->num_tile_group_entries = fh->tile_cols * fh->tile_rows; ++ if (controls->num_tile_group_entries > V4L2_AV1_MAX_TILE_COUNT) ++ return AVERROR(EINVAL); ++ ++ if (controls->num_tile_group_entries > 1 && ++ controls->num_tile_group_entries > controls->allocated_tile_group_entries) { ++ struct v4l2_ctrl_av1_tile_group_entry *tile_group_entries; ++ ++ tile_group_entries = av_realloc_array(controls->allocated_tile_group_entries ? ++ controls->tile_group_entries : NULL, ++ controls->num_tile_group_entries, ++ sizeof(*controls->tile_group_entries)); ++ if (!tile_group_entries) ++ return AVERROR(ENOMEM); ++ ++ if (!controls->allocated_tile_group_entries) ++ memcpy(tile_group_entries, controls->tile_group_entries, ++ sizeof(*controls->tile_group_entries)); ++ ++ controls->tile_group_entries = tile_group_entries; ++ controls->allocated_tile_group_entries = controls->num_tile_group_entries; ++ } ++ ++ for (int i = 0; i < controls->num_tile_group_entries; i++) { ++ controls->tile_group_entries[i] = (struct v4l2_ctrl_av1_tile_group_entry) { ++ .tile_offset = controls->pic.output->bytesused + ++ s->tile_group_info[i].tile_offset, ++ .tile_size = s->tile_group_info[i].tile_size, ++ .tile_row = s->tile_group_info[i].tile_row, ++ .tile_col = s->tile_group_info[i].tile_column, ++ }; ++ } ++ ++ return ff_v4l2_request_append_output(avctx, &controls->pic, buffer, size); ++} ++ ++static int v4l2_request_av1_end_frame(AVCodecContext *avctx) ++{ ++ const AV1DecContext *s = avctx->priv_data; ++ V4L2RequestContextAV1 *ctx = avctx->internal->hwaccel_priv_data; ++ V4L2RequestControlsAV1 *controls = s->cur_frame.hwaccel_picture_private; ++ int count = 0; ++ ++ struct v4l2_ext_control control[V4L2_AV1_CONTROLS_MAX] = {}; ++ ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_AV1_SEQUENCE, ++ .ptr = &controls->sequence, ++ .size = sizeof(controls->sequence), ++ }; ++ ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_AV1_FRAME, ++ .ptr = &controls->frame, ++ .size = sizeof(controls->frame), ++ }; ++ ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY, ++ .ptr = controls->tile_group_entries, ++ .size = sizeof(*controls->tile_group_entries) * ++ FFMAX(controls->num_tile_group_entries, 1), ++ }; ++ ++ if (ctx->has_film_grain) { ++ control[count++] = (struct v4l2_ext_control) { ++ .id = V4L2_CID_STATELESS_AV1_FILM_GRAIN, ++ .ptr = &controls->film_grain, ++ .size = sizeof(controls->film_grain), ++ }; ++ } ++ ++ return ff_v4l2_request_decode_frame(avctx, &controls->pic, control, count); ++} ++ ++static void v4l2_request_av1_free_frame_priv(AVRefStructOpaque hwctx, void *data) ++{ ++ V4L2RequestControlsAV1 *controls = data; ++ ++ if (controls->allocated_tile_group_entries) ++ av_freep(&controls->tile_group_entries); ++} ++ ++static int v4l2_request_av1_post_frames_ctx(AVCodecContext *avctx) ++{ ++ V4L2RequestContextAV1 *ctx = avctx->internal->hwaccel_priv_data; ++ ++ struct v4l2_query_ext_ctrl film_grain = { ++ .id = V4L2_CID_STATELESS_AV1_FILM_GRAIN, ++ }; ++ ++ // TODO: check V4L2_CID_MPEG_VIDEO_AV1_PROFILE ++ // TODO: check V4L2_CID_MPEG_VIDEO_AV1_LEVEL ++ ++ if (!ff_v4l2_request_query_control(avctx, &film_grain)) ++ ctx->has_film_grain = true; ++ else ++ ctx->has_film_grain = false; ++ ++ return 0; ++} ++ ++static int v4l2_request_av1_init(AVCodecContext *avctx) ++{ ++ const AV1DecContext *s = avctx->priv_data; ++ struct v4l2_ctrl_av1_sequence sequence; ++ ++ struct v4l2_ext_control control[] = { ++ { ++ .id = V4L2_CID_STATELESS_AV1_SEQUENCE, ++ .ptr = &sequence, ++ .size = sizeof(sequence), ++ }, ++ }; ++ ++ fill_sequence(&sequence, s); ++ ++ return ff_v4l2_request_init(avctx, control, FF_ARRAY_ELEMS(control), ++ v4l2_request_av1_post_frames_ctx); ++} ++ ++static int v4l2_request_av1_frame_params(AVCodecContext *avctx, ++ AVBufferRef *hw_frames_ctx) ++{ ++ const AV1DecContext *s = avctx->priv_data; ++ const AV1RawSequenceHeader *seq = s ? s->raw_seq : NULL; ++ uint8_t bit_depth = seq ? get_bit_depth_from_seq(seq) : 0; ++ ++ return ff_v4l2_request_frame_params(avctx, hw_frames_ctx, ++ V4L2_PIX_FMT_AV1_FRAME, bit_depth); ++} ++ ++const FFHWAccel ff_av1_v4l2request_hwaccel = { ++ .p.name = "av1_v4l2request", ++ .p.type = AVMEDIA_TYPE_VIDEO, ++ .p.id = AV_CODEC_ID_AV1, ++ .p.pix_fmt = AV_PIX_FMT_DRM_PRIME, ++ .start_frame = v4l2_request_av1_start_frame, ++ .decode_slice = v4l2_request_av1_decode_slice, ++ .end_frame = v4l2_request_av1_end_frame, ++ .flush = ff_v4l2_request_flush, ++ .free_frame_priv = v4l2_request_av1_free_frame_priv, ++ .frame_priv_data_size = sizeof(V4L2RequestControlsAV1), ++ .init = v4l2_request_av1_init, ++ .uninit = ff_v4l2_request_uninit, ++ .priv_data_size = sizeof(V4L2RequestContextAV1), ++ .frame_params = v4l2_request_av1_frame_params, ++ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, ++}; diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-12.patch b/multimedia/ffmpeg/patches/120-v4l2-request-12.patch new file mode 100644 index 000000000..6321698df --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-12.patch @@ -0,0 +1,78 @@ +From 6d218019f1d8294ab17648358a3259082d9b64a4 Mon Sep 17 00:00:00 2001 +From: Jernej Skrabec +Date: Sun, 14 Dec 2025 01:12:06 +0000 +Subject: [PATCH 12/13] avutil/hwcontext_v4l2request: Add support for + AFBC_16X16_SPLIT pix fmts + +Add support for YUV420_8_AFBC_16X16_SPLIT and YUV420_10_AFBC_16X16_SPLIT +used by Cedrus decoder. + +Signed-off-by: Jernej Skrabec +Signed-off-by: Jonas Karlman +--- + libavutil/hwcontext_v4l2request.c | 40 +++++++++++++++++++++++++------ + 1 file changed, 33 insertions(+), 7 deletions(-) + +--- a/libavutil/hwcontext_v4l2request.c ++++ b/libavutil/hwcontext_v4l2request.c +@@ -85,6 +85,28 @@ static const struct { + { V4L2_PIX_FMT_NV12MT_10_COL128, AV_PIX_FMT_YUV420P10, DRM_FORMAT_P030, DRM_FORMAT_MOD_BROADCOM_SAND128, 10 }, + #endif + #endif ++#if defined(V4L2_PIX_FMT_YUV420_8_AFBC_16X16_SPLIT) ++ { ++ .pixelformat = V4L2_PIX_FMT_YUV420_8_AFBC_16X16_SPLIT, ++ .sw_format = AV_PIX_FMT_YUV420P, ++ .drm_format = DRM_FORMAT_YUV420_8BIT, ++ .format_modifier = DRM_FORMAT_MOD_ARM_AFBC(AFBC_FORMAT_MOD_BLOCK_SIZE_16x16 | ++ AFBC_FORMAT_MOD_SPARSE | ++ AFBC_FORMAT_MOD_SPLIT), ++ .bit_depth = 8, ++ }, ++#endif ++#if defined(V4L2_PIX_FMT_YUV420_10_AFBC_16X16_SPLIT) ++ { ++ .pixelformat = V4L2_PIX_FMT_YUV420_10_AFBC_16X16_SPLIT, ++ .sw_format = AV_PIX_FMT_YUV420P10, ++ .drm_format = DRM_FORMAT_YUV420_10BIT, ++ .format_modifier = DRM_FORMAT_MOD_ARM_AFBC(AFBC_FORMAT_MOD_BLOCK_SIZE_16x16 | ++ AFBC_FORMAT_MOD_SPARSE | ++ AFBC_FORMAT_MOD_SPLIT), ++ .bit_depth = 10, ++ }, ++#endif + }; + + static int v4l2request_set_drm_descriptor(AVDRMFrameDescriptor *desc, +@@ -115,7 +137,7 @@ static int v4l2request_set_drm_descripto + } + + desc->nb_layers = 1; +- layer->nb_planes = 2; ++ layer->nb_planes = 1; + + layer->planes[0].object_index = 0; + layer->planes[0].offset = 0; +@@ -123,12 +145,16 @@ static int v4l2request_set_drm_descripto + format->fmt.pix_mp.plane_fmt[0].bytesperline : + format->fmt.pix.bytesperline; + +- layer->planes[1].object_index = 0; +- layer->planes[1].offset = layer->planes[0].pitch * +- (V4L2_TYPE_IS_MULTIPLANAR(format->type) ? +- format->fmt.pix_mp.height : +- format->fmt.pix.height); +- layer->planes[1].pitch = layer->planes[0].pitch; ++ // AFBC formats only use 1 plane, remaining use 2 planes ++ if ((desc->objects[0].format_modifier >> 56) != DRM_FORMAT_MOD_VENDOR_ARM) { ++ layer->nb_planes = 2; ++ layer->planes[1].object_index = 0; ++ layer->planes[1].offset = layer->planes[0].pitch * ++ (V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.height : ++ format->fmt.pix.height); ++ layer->planes[1].pitch = layer->planes[0].pitch; ++ } + + #if defined(V4L2_PIX_FMT_NV12MT_COL128) && defined(V4L2_PIX_FMT_NV12MT_10_COL128) + // Raspberry Pi formats need special handling diff --git a/multimedia/ffmpeg/patches/120-v4l2-request-13.patch b/multimedia/ffmpeg/patches/120-v4l2-request-13.patch new file mode 100644 index 000000000..d88592258 --- /dev/null +++ b/multimedia/ffmpeg/patches/120-v4l2-request-13.patch @@ -0,0 +1,55 @@ +From b57fbbe50c9b2656fad86a1a7eeabfd2b2a50935 Mon Sep 17 00:00:00 2001 +From: Jonas Karlman +Date: Sun, 14 Dec 2025 01:14:17 +0000 +Subject: [PATCH 13/13] avutil/hwcontext_v4l2request: Add support for + BROADCOM_SAND128 pix fmts + +Add support for NV12_COL128 and NV12_10_COL128 used by downstream +Raspberry Pi HEVC decoder. + +Signed-off-by: Jonas Karlman +--- + libavutil/hwcontext_v4l2request.c | 25 +++++++++++++++++++++++++ + 1 file changed, 25 insertions(+) + +--- a/libavutil/hwcontext_v4l2request.c ++++ b/libavutil/hwcontext_v4l2request.c +@@ -107,6 +107,12 @@ static const struct { + .bit_depth = 10, + }, + #endif ++#if defined(V4L2_PIX_FMT_NV12_COL128) && defined(V4L2_PIX_FMT_NV12_10_COL128) ++ { V4L2_PIX_FMT_NV12_COL128, AV_PIX_FMT_YUV420P, DRM_FORMAT_NV12, DRM_FORMAT_MOD_BROADCOM_SAND128, 8 }, ++#if defined(DRM_FORMAT_P030) ++ { V4L2_PIX_FMT_NV12_10_COL128, AV_PIX_FMT_YUV420P10, DRM_FORMAT_P030, DRM_FORMAT_MOD_BROADCOM_SAND128, 10 }, ++#endif ++#endif + }; + + static int v4l2request_set_drm_descriptor(AVDRMFrameDescriptor *desc, +@@ -169,6 +175,25 @@ static int v4l2request_set_drm_descripto + } + #endif + ++#if defined(V4L2_PIX_FMT_NV12_COL128) && defined(V4L2_PIX_FMT_NV12_10_COL128) ++ // Raspberry Pi formats need special handling ++ if (pixelformat == V4L2_PIX_FMT_NV12_COL128 || ++ pixelformat == V4L2_PIX_FMT_NV12_10_COL128) { ++ desc->objects[0].format_modifier = ++ DRM_FORMAT_MOD_BROADCOM_SAND128_COL_HEIGHT(layer->planes[0].pitch); ++ layer->planes[1].offset = 128 * ++ (V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.height : ++ format->fmt.pix.height); ++ layer->planes[0].pitch = (V4L2_TYPE_IS_MULTIPLANAR(format->type) ? ++ format->fmt.pix_mp.width : ++ format->fmt.pix.width); ++ if (pixelformat == V4L2_PIX_FMT_NV12_10_COL128) ++ layer->planes[0].pitch *= 2; ++ layer->planes[1].pitch = layer->planes[0].pitch; ++ } ++#endif ++ + return 0; + } + diff --git a/multimedia/ffmpeg/patches/140-vf-deinterlace-v4l2m2m.patch b/multimedia/ffmpeg/patches/140-vf-deinterlace-v4l2m2m.patch new file mode 100644 index 000000000..c2d9e4c9d --- /dev/null +++ b/multimedia/ffmpeg/patches/140-vf-deinterlace-v4l2m2m.patch @@ -0,0 +1,1051 @@ +From 69dd718a8b4b00cefbc108589895650f35bbc13b Mon Sep 17 00:00:00 2001 +From: Jernej Skrabec +Date: Tue, 3 Dec 2019 21:01:18 +0100 +Subject: [PATCH] Add V4L2 m2m deinterlace filter + +Signed-off-by: Alex Bee +--- + libavfilter/Makefile | 1 + + libavfilter/allfilters.c | 1 + + libavfilter/vf_deinterlace_v4l2m2m.c | 1015 ++++++++++++++++++++++++++ + 3 files changed, 1017 insertions(+) + create mode 100644 libavfilter/vf_deinterlace_v4l2m2m.c + +--- a/libavfilter/Makefile ++++ b/libavfilter/Makefile +@@ -279,6 +279,7 @@ OBJS-$(CONFIG_DEFLICKER_FILTER) + OBJS-$(CONFIG_DEINTERLACE_D3D12_FILTER) += vf_deinterlace_d3d12.o + OBJS-$(CONFIG_DEINTERLACE_QSV_FILTER) += vf_vpp_qsv.o + OBJS-$(CONFIG_DEINTERLACE_VAAPI_FILTER) += vf_deinterlace_vaapi.o vaapi_vpp.o ++OBJS-$(CONFIG_DEINTERLACE_V4L2M2M_FILTER) += vf_deinterlace_v4l2m2m.o + OBJS-$(CONFIG_DEJUDDER_FILTER) += vf_dejudder.o + OBJS-$(CONFIG_DELOGO_FILTER) += vf_delogo.o + OBJS-$(CONFIG_DENOISE_VAAPI_FILTER) += vf_misc_vaapi.o vaapi_vpp.o +--- a/libavfilter/allfilters.c ++++ b/libavfilter/allfilters.c +@@ -253,6 +253,7 @@ extern const FFFilter ff_vf_deflate; + extern const FFFilter ff_vf_deflicker; + extern const FFFilter ff_vf_deinterlace_qsv; + extern const FFFilter ff_vf_deinterlace_d3d12; ++extern const FFFilter ff_vf_deinterlace_v4l2m2m; + extern const FFFilter ff_vf_deinterlace_vaapi; + extern const FFFilter ff_vf_dejudder; + extern const FFFilter ff_vf_delogo; +--- /dev/null ++++ b/libavfilter/vf_deinterlace_v4l2m2m.c +@@ -0,0 +1,1015 @@ ++/* ++ * 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 ++ */ ++ ++/** ++ * @file ++ * deinterlace video filter - V4L2 M2M ++ */ ++ ++#include ++ ++#include ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "libavutil/avassert.h" ++#include "libavutil/avstring.h" ++#include "libavutil/common.h" ++#include "libavutil/hwcontext.h" ++#include "libavutil/hwcontext_drm.h" ++#include "libavutil/internal.h" ++#include "libavutil/mathematics.h" ++#include "libavutil/mem.h" ++#include "libavutil/opt.h" ++#include "libavutil/pixdesc.h" ++#include "libavutil/time.h" ++ ++#include "avfilter.h" ++#include "formats.h" ++#include "video.h" ++ ++typedef struct V4L2Queue V4L2Queue; ++typedef struct DeintV4L2M2MContextShared DeintV4L2M2MContextShared; ++ ++typedef struct V4L2PlaneInfo { ++ int bytesperline; ++ size_t length; ++} V4L2PlaneInfo; ++ ++typedef struct V4L2Buffer { ++ int enqueued; ++ int reenqueue; ++ int fd; ++ struct v4l2_buffer buffer; ++ struct v4l2_plane planes[VIDEO_MAX_PLANES]; ++ int num_planes; ++ V4L2PlaneInfo plane_info[VIDEO_MAX_PLANES]; ++ AVDRMFrameDescriptor drm_frame; ++ V4L2Queue *q; ++} V4L2Buffer; ++ ++typedef struct V4L2Queue { ++ struct v4l2_format format; ++ int num_buffers; ++ V4L2Buffer *buffers; ++ DeintV4L2M2MContextShared *ctx; ++} V4L2Queue; ++ ++typedef struct DeintV4L2M2MContextShared { ++ int fd; ++ int done; ++ int width; ++ int height; ++ int orig_width; ++ int orig_height; ++ uint64_t drm_in_format; ++ uint64_t drm_out_format; ++ ++ atomic_uint refcount; ++ ++ AVBufferRef *hw_frames_ctx; ++ ++ /* ++ * TODO: check if its really neccessary to hold this ++ * ref, it's only used for freeing av_frame on decoding ++ * end/abort ++ */ ++ AVFrame *cur_in_frame; ++ AVFrame *prev_in_frame; ++ unsigned int field_order; ++ ++ V4L2Queue output; ++ V4L2Queue capture; ++} DeintV4L2M2MContextShared; ++ ++typedef struct DeintV4L2M2MContext { ++ const AVClass *class; ++ ++ DeintV4L2M2MContextShared *shared; ++} DeintV4L2M2MContext; ++ ++static inline uint32_t v4l2_pix_fmt_from_drm_format(uint64_t drm_format) ++{ ++ switch(drm_format) { ++#if defined(V4L2_PIX_FMT_SUNXI_TILED_NV12) && defined(DRM_FORMAT_MOD_ALLWINNER_TILED) ++ case DRM_FORMAT_MOD_ALLWINNER_TILED: ++ return V4L2_PIX_FMT_SUNXI_TILED_NV12; ++#endif ++ case DRM_FORMAT_NV12: ++ return V4L2_PIX_FMT_NV12; ++#if defined(V4L2_PIX_FMT_NV15) && defined(DRM_FORMAT_NV15) ++ case DRM_FORMAT_NV15: ++ return V4L2_PIX_FMT_NV15; ++#endif ++ case DRM_FORMAT_NV16: ++ return V4L2_PIX_FMT_NV16; ++#if defined(V4L2_PIX_FMT_NV20) && defined(DRM_FORMAT_NV20) ++ case DRM_FORMAT_NV20: ++ return V4L2_PIX_FMT_NV20; ++#endif ++ case DRM_FORMAT_NV21: ++ return V4L2_PIX_FMT_NV21; ++ case DRM_FORMAT_NV61: ++ return V4L2_PIX_FMT_NV61; ++ default: ++ av_log(NULL, AV_LOG_WARNING, "%s unknown drm format %s using default v4l2_pix_fmt %s\n", ++ __func__ , av_fourcc2str(drm_format), av_fourcc2str(V4L2_PIX_FMT_NV12)); ++ return V4L2_PIX_FMT_NV12; ++ } ++} ++ ++static inline uint64_t drm_format_from_v4l2_pix_fmt(uint32_t v4l2_pix_fmt) ++{ ++ switch(v4l2_pix_fmt) { ++ case V4L2_PIX_FMT_NV12: ++ return DRM_FORMAT_NV12; ++#if defined(V4L2_PIX_FMT_NV15) && defined(DRM_FORMAT_NV15) ++ case V4L2_PIX_FMT_NV15: ++ return DRM_FORMAT_NV15; ++#endif ++ case V4L2_PIX_FMT_NV16: ++ return DRM_FORMAT_NV16; ++#if defined(V4L2_PIX_FMT_NV20) && defined(DRM_FORMAT_NV20) ++ case V4L2_PIX_FMT_NV20: ++ return DRM_FORMAT_NV20; ++#endif ++ case V4L2_PIX_FMT_NV21: ++ return DRM_FORMAT_NV21; ++ case V4L2_PIX_FMT_NV61: ++ return DRM_FORMAT_NV61; ++#if defined(V4L2_PIX_FMT_SUNXI_TILED_NV12) && defined(DRM_FORMAT_MOD_ALLWINNER_TILED) ++ case V4L2_PIX_FMT_SUNXI_TILED_NV12: ++ return DRM_FORMAT_MOD_ALLWINNER_TILED; ++#endif ++ default: ++ av_log(NULL, AV_LOG_WARNING, "%s unknown v4l2_pix_fmt format 0x%x using default drm_format 0x%x\n", ++ __func__ , v4l2_pix_fmt, DRM_FORMAT_NV12); ++ return DRM_FORMAT_NV12; ++ } ++} ++ ++static inline uint64_t drm_format_modifier(uint64_t drm_format) ++{ ++#ifdef DRM_FORMAT_MOD_ALLWINNER_TILED ++ if (drm_format == DRM_FORMAT_MOD_ALLWINNER_TILED) ++ return DRM_FORMAT_MOD_ALLWINNER_TILED; ++#endif ++ return DRM_FORMAT_MOD_LINEAR; ++ ++} ++ ++static int deint_v4l2m2m_prepare_context(DeintV4L2M2MContextShared *ctx) ++{ ++ struct v4l2_capability cap; ++ int ret; ++ ++ memset(&cap, 0, sizeof(cap)); ++ ret = ioctl(ctx->fd, VIDIOC_QUERYCAP, &cap); ++ if (ret < 0) ++ return ret; ++ ++ if (!(cap.capabilities & V4L2_CAP_STREAMING)) ++ return AVERROR(EINVAL); ++ ++ if (cap.capabilities & V4L2_CAP_VIDEO_M2M) { ++ ctx->capture.format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; ++ ctx->output.format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; ++ ++ return 0; ++ } ++ ++ if (cap.capabilities & V4L2_CAP_VIDEO_M2M_MPLANE) { ++ ctx->capture.format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; ++ ctx->output.format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; ++ ++ return 0; ++ } ++ ++ return AVERROR(EINVAL); ++} ++ ++static int deint_v4l2m2m_try_format(V4L2Queue *queue, uint64_t drm_format) ++{ ++ struct v4l2_format *fmt = &queue->format; ++ DeintV4L2M2MContextShared *ctx = queue->ctx; ++ int ret, field; ++ uint32_t v4l2_pix_fmt = v4l2_pix_fmt_from_drm_format(drm_format); ++ ++ ret = ioctl(ctx->fd, VIDIOC_G_FMT, fmt); ++ if (ret) ++ av_log(NULL, AV_LOG_ERROR, "VIDIOC_G_FMT failed: %d\n", ret); ++ ++ if (V4L2_TYPE_IS_OUTPUT(fmt->type)) ++ field = V4L2_FIELD_INTERLACED_TB; ++ else ++ field = V4L2_FIELD_NONE; ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(fmt->type)) { ++ fmt->fmt.pix_mp.pixelformat = v4l2_pix_fmt; ++ fmt->fmt.pix_mp.field = field; ++ fmt->fmt.pix_mp.width = ctx->width; ++ fmt->fmt.pix_mp.height = ctx->height; ++ } else { ++ fmt->fmt.pix.pixelformat = v4l2_pix_fmt; ++ fmt->fmt.pix.field = field; ++ fmt->fmt.pix.width = ctx->width; ++ fmt->fmt.pix.height = ctx->height; ++ } ++ ++ ret = ioctl(ctx->fd, VIDIOC_TRY_FMT, fmt); ++ if (ret) ++ return AVERROR(EINVAL); ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(fmt->type)) { ++ if (fmt->fmt.pix_mp.pixelformat != v4l2_pix_fmt || ++ fmt->fmt.pix_mp.field != field) { ++ av_log(NULL, AV_LOG_DEBUG, "format not supported for type %d\n", fmt->type); ++ ++ return AVERROR(EINVAL); ++ } ++ } else { ++ if (fmt->fmt.pix.pixelformat != v4l2_pix_fmt || ++ fmt->fmt.pix.field != field) { ++ av_log(NULL, AV_LOG_DEBUG, "format not supported for type %d\n", fmt->type); ++ ++ return AVERROR(EINVAL); ++ } ++ } ++ ++ return 0; ++} ++static int deint_v4l2m2m_set_format(V4L2Queue *queue, uint32_t field, int width, int height, uint64_t drm_format) ++{ ++ struct v4l2_format *fmt = &queue->format; ++ DeintV4L2M2MContextShared *ctx = queue->ctx; ++ int ret; ++ uint32_t v4l2_pix_fmt = v4l2_pix_fmt_from_drm_format(drm_format); ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(fmt->type)) { ++ fmt->fmt.pix_mp.pixelformat = v4l2_pix_fmt; ++ fmt->fmt.pix_mp.field = field; ++ fmt->fmt.pix_mp.width = width; ++ fmt->fmt.pix_mp.height = height; ++ /* TODO: bytesperline and imagesize */ ++ } else { ++ fmt->fmt.pix.pixelformat = v4l2_pix_fmt; ++ fmt->fmt.pix.field = field; ++ fmt->fmt.pix.width = width; ++ fmt->fmt.pix.height = height; ++ fmt->fmt.pix.sizeimage = 0; ++ fmt->fmt.pix.bytesperline = 0; ++ } ++ ++ ret = ioctl(ctx->fd, VIDIOC_S_FMT, fmt); ++ if (ret) ++ av_log(NULL, AV_LOG_ERROR, "VIDIOC_S_FMT failed: %d\n", ret); ++ ++ else if (!V4L2_TYPE_IS_OUTPUT(queue->format.type)) { ++ if (V4L2_TYPE_IS_MULTIPLANAR(fmt->type) && fmt->fmt.pix_mp.pixelformat != v4l2_pix_fmt) { ++ ctx->drm_out_format = drm_format_from_v4l2_pix_fmt(fmt->fmt.pix_mp.pixelformat); ++ av_log(NULL, AV_LOG_DEBUG, "%s driver updated v4l2_pixfmt from: %s to %s, so now using %s as drm output format\n", ++ __func__, av_fourcc2str(v4l2_pix_fmt), av_fourcc2str(fmt->fmt.pix_mp.pixelformat), av_fourcc2str(ctx->drm_out_format)); ++ } else if (fmt->fmt.pix.pixelformat != v4l2_pix_fmt) { ++ ctx->drm_out_format = drm_format_from_v4l2_pix_fmt(fmt->fmt.pix.pixelformat); ++ av_log(NULL, AV_LOG_DEBUG, "%s driver updated v4l2_pixfmt from: %s to %s, so now using %s as drm output format\n", ++ __func__, av_fourcc2str(v4l2_pix_fmt), av_fourcc2str(fmt->fmt.pix.pixelformat), av_fourcc2str(ctx->drm_out_format)); ++ } ++ } ++ ++ return ret; ++} ++ ++static int deint_v4l2m2m_probe_device(DeintV4L2M2MContextShared *ctx, char *node) ++{ ++ int ret; ++ ++ ctx->fd = open(node, O_RDWR | O_NONBLOCK, 0); ++ if (ctx->fd < 0) ++ return AVERROR(errno); ++ ++ ret = deint_v4l2m2m_prepare_context(ctx); ++ if (ret) ++ goto fail; ++ ++ ret = deint_v4l2m2m_try_format(&ctx->capture, ctx->drm_out_format); ++ if (ret) ++ goto fail; ++ ++ ret = deint_v4l2m2m_try_format(&ctx->output, ctx->drm_in_format); ++ if (ret) ++ goto fail; ++ ++ return 0; ++ ++fail: ++ close(ctx->fd); ++ ctx->fd = -1; ++ ++ return ret; ++} ++ ++static int deint_v4l2m2m_find_device(DeintV4L2M2MContextShared *ctx) ++{ ++ int ret = AVERROR(EINVAL); ++ struct dirent *entry; ++ char node[PATH_MAX]; ++ DIR *dirp; ++ ++ 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(NULL, AV_LOG_DEBUG, "probing device %s\n", node); ++ ret = deint_v4l2m2m_probe_device(ctx, node); ++ if (!ret) ++ break; ++ } ++ ++ closedir(dirp); ++ ++ if (ret) { ++ av_log(NULL, AV_LOG_ERROR, "Could not find a valid device\n"); ++ ctx->fd = -1; ++ ++ return ret; ++ } ++ ++ av_log(NULL, AV_LOG_INFO, "Using device %s\n", node); ++ ++ return 0; ++} ++ ++static int deint_v4l2m2m_enqueue_buffer(V4L2Buffer *buf) ++{ ++ int ret; ++ ++ ret = ioctl(buf->q->ctx->fd, VIDIOC_QBUF, &buf->buffer); ++ if (ret < 0) ++ return AVERROR(errno); ++ ++ buf->enqueued = 1; ++ ++ return 0; ++} ++ ++static int v4l2_buffer_export_drm(V4L2Buffer* avbuf, uint64_t drm_format) ++{ ++ struct v4l2_exportbuffer expbuf; ++ int i, ret; ++ ++ for (i = 0; i < avbuf->num_planes; i++) { ++ memset(&expbuf, 0, sizeof(expbuf)); ++ ++ expbuf.index = avbuf->buffer.index; ++ expbuf.type = avbuf->buffer.type; ++ expbuf.plane = i; ++ ++ ret = ioctl(avbuf->q->ctx->fd, VIDIOC_EXPBUF, &expbuf); ++ if (ret < 0) ++ return AVERROR(errno); ++ ++ avbuf->fd = expbuf.fd; ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(avbuf->buffer.type)) { ++ /* drm frame */ ++ avbuf->drm_frame.objects[i].size = avbuf->buffer.m.planes[i].length; ++ avbuf->drm_frame.objects[i].fd = expbuf.fd; ++ avbuf->drm_frame.objects[i].format_modifier = drm_format_modifier(drm_format); ++ } else { ++ /* drm frame */ ++ avbuf->drm_frame.objects[0].size = avbuf->buffer.length; ++ avbuf->drm_frame.objects[0].fd = expbuf.fd; ++ avbuf->drm_frame.objects[0].format_modifier = drm_format_modifier(drm_format); ++ } ++ } ++ ++ return 0; ++} ++ ++static int deint_v4l2m2m_allocate_buffers(V4L2Queue *queue) ++{ ++ struct v4l2_format *fmt = &queue->format; ++ DeintV4L2M2MContextShared *ctx = queue->ctx; ++ struct v4l2_requestbuffers req; ++ int ret, i, j, multiplanar; ++ uint32_t memory; ++ ++ memory = V4L2_TYPE_IS_OUTPUT(fmt->type) ? ++ V4L2_MEMORY_DMABUF : V4L2_MEMORY_MMAP; ++ ++ multiplanar = V4L2_TYPE_IS_MULTIPLANAR(fmt->type); ++ ++ memset(&req, 0, sizeof(req)); ++ req.count = queue->num_buffers; ++ req.memory = memory; ++ req.type = fmt->type; ++ ++ ret = ioctl(ctx->fd, VIDIOC_REQBUFS, &req); ++ if (ret < 0) { ++ av_log(NULL, AV_LOG_ERROR, "VIDIOC_REQBUFS failed: %s\n", strerror(errno)); ++ ++ return AVERROR(errno); ++ } ++ ++ queue->num_buffers = req.count; ++ queue->buffers = av_mallocz(queue->num_buffers * sizeof(V4L2Buffer)); ++ if (!queue->buffers) { ++ av_log(NULL, AV_LOG_ERROR, "malloc enomem\n"); ++ ++ return AVERROR(ENOMEM); ++ } ++ ++ for (i = 0; i < queue->num_buffers; i++) { ++ V4L2Buffer *buf = &queue->buffers[i]; ++ ++ buf->enqueued = 0; ++ buf->fd = -1; ++ buf->q = queue; ++ ++ buf->buffer.type = fmt->type; ++ buf->buffer.memory = memory; ++ buf->buffer.index = i; ++ ++ if (multiplanar) { ++ buf->buffer.length = VIDEO_MAX_PLANES; ++ buf->buffer.m.planes = buf->planes; ++ } ++ ++ ret = ioctl(ctx->fd, VIDIOC_QUERYBUF, &buf->buffer); ++ if (ret < 0) { ++ ret = AVERROR(errno); ++ ++ goto fail; ++ } ++ ++ if (multiplanar) ++ buf->num_planes = buf->buffer.length; ++ else ++ buf->num_planes = 1; ++ ++ for (j = 0; j < buf->num_planes; j++) { ++ V4L2PlaneInfo *info = &buf->plane_info[j]; ++ ++ if (multiplanar) { ++ info->bytesperline = fmt->fmt.pix_mp.plane_fmt[j].bytesperline; ++ info->length = buf->buffer.m.planes[j].length; ++ } else { ++ info->bytesperline = fmt->fmt.pix.bytesperline; ++ info->length = buf->buffer.length; ++ } ++ } ++ ++ if (!V4L2_TYPE_IS_OUTPUT(fmt->type)) { ++ ret = deint_v4l2m2m_enqueue_buffer(buf); ++ if (ret) ++ goto fail; ++ ++ ret = v4l2_buffer_export_drm(buf, ctx->drm_out_format); ++ if (ret) ++ goto fail; ++ } ++ } ++ ++ return 0; ++ ++fail: ++ for (i = 0; i < queue->num_buffers; i++) ++ if (queue->buffers[i].fd >= 0) ++ close(queue->buffers[i].fd); ++ av_free(queue->buffers); ++ queue->buffers = NULL; ++ ++ return ret; ++} ++ ++static int deint_v4l2m2m_streamon(V4L2Queue *queue) ++{ ++ int type = queue->format.type; ++ int ret; ++ ++ ret = ioctl(queue->ctx->fd, VIDIOC_STREAMON, &type); ++ if (ret < 0) ++ return AVERROR(errno); ++ ++ return 0; ++} ++ ++static int deint_v4l2m2m_streamoff(V4L2Queue *queue) ++{ ++ int type = queue->format.type; ++ int ret; ++ ++ ret = ioctl(queue->ctx->fd, VIDIOC_STREAMOFF, &type); ++ if (ret < 0) ++ return AVERROR(errno); ++ ++ return 0; ++} ++ ++static V4L2Buffer* deint_v4l2m2m_dequeue_buffer(V4L2Queue *queue, int timeout) ++{ ++ struct v4l2_plane planes[VIDEO_MAX_PLANES]; ++ DeintV4L2M2MContextShared *ctx = queue->ctx; ++ struct v4l2_buffer buf = { 0 }; ++ V4L2Buffer* avbuf = NULL; ++ struct pollfd pfd; ++ short events; ++ int ret; ++ ++ if (V4L2_TYPE_IS_OUTPUT(queue->format.type)) ++ events = POLLOUT | POLLWRNORM; ++ else ++ events = POLLIN | POLLRDNORM; ++ ++ pfd.events = events; ++ pfd.fd = ctx->fd; ++ ++ for (;;) { ++ ret = poll(&pfd, 1, timeout); ++ if (ret > 0) ++ break; ++ if (errno == EINTR) ++ continue; ++ return NULL; ++ } ++ ++ if (pfd.revents & POLLERR) ++ return NULL; ++ ++ if (pfd.revents & events) { ++ memset(&buf, 0, sizeof(buf)); ++ buf.memory = V4L2_MEMORY_MMAP; ++ buf.type = queue->format.type; ++ if (V4L2_TYPE_IS_MULTIPLANAR(queue->format.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) ++ av_log(NULL, AV_LOG_DEBUG, "VIDIOC_DQBUF, errno (%s)\n", ++ av_err2str(AVERROR(errno))); ++ return NULL; ++ } ++ ++ avbuf = &queue->buffers[buf.index]; ++ avbuf->enqueued = 0; ++ avbuf->buffer = buf; ++ if (V4L2_TYPE_IS_MULTIPLANAR(queue->format.type)) { ++ memcpy(avbuf->planes, planes, sizeof(planes)); ++ avbuf->buffer.m.planes = avbuf->planes; ++ } ++ ++ return avbuf; ++ } ++ ++ return NULL; ++} ++ ++static V4L2Buffer *deint_v4l2m2m_find_free_buf(V4L2Queue *queue) ++{ ++ int i; ++ ++ for (i = 0; i < queue->num_buffers; i++) ++ if (!queue->buffers[i].enqueued) ++ return &queue->buffers[i]; ++ ++ return NULL; ++} ++ ++static int deint_v4l2m2m_enqueue(V4L2Queue *queue, const AVFrame* frame) ++{ ++ AVDRMFrameDescriptor *drm_desc = (AVDRMFrameDescriptor *)frame->data[0]; ++ V4L2Buffer *buf; ++ int i; ++ ++ if (V4L2_TYPE_IS_OUTPUT(queue->format.type)) ++ while (deint_v4l2m2m_dequeue_buffer(queue, 0)); ++ ++ buf = deint_v4l2m2m_find_free_buf(queue); ++ if (!buf) ++ return AVERROR(ENOMEM); ++ ++ if (V4L2_TYPE_IS_MULTIPLANAR(buf->buffer.type)) { ++ for (i = 0; i < drm_desc->nb_objects; i++) { ++ buf->buffer.m.planes[i].m.fd = drm_desc->objects[i].fd; ++ buf->buffer.m.planes[i].bytesused = buf->plane_info[i].length; ++ } ++ } else { ++ buf->buffer.m.fd = drm_desc->objects[0].fd; ++ buf->buffer.bytesused = buf->plane_info[0].length; ++ } ++ ++ return deint_v4l2m2m_enqueue_buffer(buf); ++} ++ ++static void deint_v4l2m2m_destroy_context(DeintV4L2M2MContextShared *ctx) ++{ ++ if (atomic_fetch_sub(&ctx->refcount, 1) == 1) { ++ V4L2Queue *capture = &ctx->capture; ++ V4L2Queue *output = &ctx->output; ++ int i; ++ ++ av_log(NULL, AV_LOG_DEBUG, "%s - destroying context\n", __func__); ++ ++ if (ctx->fd >= 0) { ++ deint_v4l2m2m_streamoff(capture); ++ deint_v4l2m2m_streamoff(output); ++ } ++ ++ if (capture->buffers) ++ for (i = 0; i < capture->num_buffers; i++) { ++ capture->buffers[i].q = NULL; ++ if (capture->buffers[i].fd >= 0) ++ close(capture->buffers[i].fd); ++ } ++ ++ if (ctx->cur_in_frame) ++ av_frame_free(&ctx->cur_in_frame); ++ ++ if (ctx->prev_in_frame) ++ av_frame_free(&ctx->prev_in_frame); ++ ++ av_buffer_unref(&ctx->hw_frames_ctx); ++ ++ if (capture->buffers) ++ av_free(capture->buffers); ++ ++ if (output->buffers) ++ av_free(output->buffers); ++ ++ if (ctx->fd >= 0) { ++ close(ctx->fd); ++ ctx->fd = -1; ++ } ++ ++ av_free(ctx); ++ } ++} ++ ++static void v4l2_free_buffer(void *opaque, uint8_t *unused) ++{ ++ V4L2Buffer *buf = opaque; ++ DeintV4L2M2MContextShared *ctx = buf->q->ctx; ++ ++ if (!ctx->done) ++ deint_v4l2m2m_enqueue_buffer(buf); ++ ++ deint_v4l2m2m_destroy_context(ctx); ++} ++ ++static uint8_t *v4l2_get_drm_frame(V4L2Buffer *avbuf, int height, uint64_t drm_format) ++{ ++ AVDRMFrameDescriptor *drm_desc = &avbuf->drm_frame; ++ AVDRMLayerDescriptor *layer; ++ ++ /* fill the DRM frame descriptor */ ++ drm_desc->nb_objects = avbuf->num_planes; ++ drm_desc->nb_layers = 1; ++ ++ layer = &drm_desc->layers[0]; ++ layer->nb_planes = avbuf->num_planes; ++ ++ for (int i = 0; i < avbuf->num_planes; i++) { ++ layer->planes[i].object_index = i; ++ layer->planes[i].offset = 0; ++ layer->planes[i].pitch = avbuf->plane_info[i].bytesperline; ++ } ++ ++ layer->format = drm_format; ++ ++ if (avbuf->num_planes == 1) { ++ layer->nb_planes = 2; ++ ++ layer->planes[1].object_index = 0; ++ layer->planes[1].offset = avbuf->plane_info[0].bytesperline * height; ++ layer->planes[1].pitch = avbuf->plane_info[0].bytesperline; ++ } ++ ++ return (uint8_t *)drm_desc; ++} ++ ++static int deint_v4l2m2m_dequeue_frame(V4L2Queue *queue, AVFrame* frame, int timeout) ++{ ++ DeintV4L2M2MContextShared *ctx = queue->ctx; ++ V4L2Buffer* avbuf; ++ ++ avbuf = deint_v4l2m2m_dequeue_buffer(queue, timeout); ++ if (!avbuf) { ++ av_log(NULL, AV_LOG_ERROR, "dequeueing failed\n"); ++ return AVERROR(EINVAL); ++ } ++ ++ frame->buf[0] = av_buffer_create((uint8_t *) &avbuf->drm_frame, ++ sizeof(avbuf->drm_frame), v4l2_free_buffer, ++ avbuf, AV_BUFFER_FLAG_READONLY); ++ if (!frame->buf[0]) ++ return AVERROR(ENOMEM); ++ ++ atomic_fetch_add(&ctx->refcount, 1); ++ ++ frame->data[0] = (uint8_t *)v4l2_get_drm_frame(avbuf, ctx->orig_height, ctx->drm_out_format); ++ frame->format = AV_PIX_FMT_DRM_PRIME; ++ frame->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx); ++ frame->height = ctx->height; ++ frame->width = ctx->width; ++ ++ if (avbuf->buffer.flags & V4L2_BUF_FLAG_ERROR) { ++ av_log(NULL, AV_LOG_ERROR, "driver decode error\n"); ++ frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM; ++ } ++ ++ return 0; ++} ++ ++static int deint_v4l2m2m_dequeue(AVFilterContext *avctx, AVFrame *input_frame) ++{ ++ DeintV4L2M2MContext *priv = avctx->priv; ++ DeintV4L2M2MContextShared *ctx = priv->shared; ++ AVFilterLink *outlink = avctx->outputs[0]; ++ AVFrame *output_frame_1, *output_frame_2; ++ int64_t first_pts = AV_NOPTS_VALUE; ++ int err; ++ ++ av_log(priv, AV_LOG_DEBUG, "input pts: %"PRId64" (field %d)\n", ++ input_frame->pts, ctx->field_order); ++ ++ output_frame_1 = av_frame_alloc(); ++ if (!output_frame_1) ++ return AVERROR(ENOMEM); ++ ++ err = deint_v4l2m2m_dequeue_frame(&ctx->capture, output_frame_1, 500); ++ if (err < 0) { ++ av_log(priv, AV_LOG_ERROR, "no 1st frame (field %d)\n", ctx->field_order); ++ goto fail_out1; ++ } ++ ++ err = av_frame_copy_props(output_frame_1, input_frame); ++ if (err < 0) ++ goto fail_out1; ++ ++ output_frame_1->flags &= ~AV_FRAME_FLAG_INTERLACED; ++ ++ output_frame_2 = av_frame_alloc(); ++ if (!output_frame_2) { ++ err = AVERROR(ENOMEM); ++ goto fail_out1; ++ } ++ ++ err = deint_v4l2m2m_dequeue_frame(&ctx->capture, output_frame_2, 500); ++ if (err < 0) { ++ av_log(priv, AV_LOG_ERROR, "no 2nd frame (field %d)\n", ctx->field_order); ++ goto fail_out2; ++ } ++ ++ err = av_frame_copy_props(output_frame_2, input_frame); ++ if (err < 0) ++ goto fail_out2; ++ ++ output_frame_2->flags &= ~AV_FRAME_FLAG_INTERLACED; ++ ++ if (ctx->prev_in_frame && ctx->prev_in_frame->pts != AV_NOPTS_VALUE ++ && input_frame->pts != AV_NOPTS_VALUE) { ++ first_pts = (ctx->prev_in_frame->pts + input_frame->pts) / 2; ++ av_log(priv, AV_LOG_DEBUG, "calculated first pts %"PRId64"\n", first_pts); ++ } ++ ++ output_frame_1->pts = first_pts; ++ ++ err = ff_filter_frame(outlink, output_frame_1); ++ if (err < 0) { ++ av_frame_free(&output_frame_2); ++ return err; ++ } ++ err = ff_filter_frame(outlink, output_frame_2); ++ ++ if (err < 0) ++ return err; ++ ++ av_log(priv, AV_LOG_DEBUG, "1st frame pts: %"PRId64" 2nd frame pts: %"PRId64" first pts: %"PRId64" (field %d)\n", ++ output_frame_1->pts, output_frame_2->pts, first_pts, ctx->field_order); ++ ++ return 0; ++ ++fail_out2: ++ av_frame_free(&output_frame_2); ++fail_out1: ++ av_frame_free(&output_frame_1); ++ return err; ++} ++ ++static int deint_v4l2m2m_config_props(AVFilterLink *outlink) ++{ ++ AVFilterLink *inlink = outlink->src->inputs[0]; ++ AVFilterContext *avctx = outlink->src; ++ DeintV4L2M2MContext *priv = avctx->priv; ++ DeintV4L2M2MContextShared *ctx = priv->shared; ++ FilterLink *fl_inlink = ff_filter_link(inlink); ++ FilterLink *fl_outlink = ff_filter_link(outlink); ++ int ret; ++ ++ ctx->height = avctx->inputs[0]->h; ++ ctx->width = avctx->inputs[0]->w; ++ ++ fl_outlink->frame_rate = av_mul_q(fl_inlink->frame_rate, ++ (AVRational){ 2, 1 }); ++ outlink->time_base = av_mul_q(inlink->time_base, ++ (AVRational){ 1, 2 }); ++ ++ ret = deint_v4l2m2m_find_device(ctx); ++ if (ret) ++ return ret; ++ ++ if (!fl_inlink->hw_frames_ctx) { ++ av_log(priv, AV_LOG_ERROR, "No hw context provided on input\n"); ++ return AVERROR(EINVAL); ++ } ++ ++ ctx->hw_frames_ctx = av_buffer_ref(fl_inlink->hw_frames_ctx); ++ if (!ctx->hw_frames_ctx) ++ return AVERROR(ENOMEM); ++ ++ return 0; ++} ++ ++static int deint_v4l2m2m_query_formats(AVFilterContext *avctx) ++{ ++ static const enum AVPixelFormat pixel_formats[] = { ++ AV_PIX_FMT_DRM_PRIME, ++ AV_PIX_FMT_NONE, ++ }; ++ ++ return ff_set_common_formats(avctx, ff_make_format_list(pixel_formats)); ++} ++ ++static int deint_v4l2m2m_filter_frame(AVFilterLink *link, AVFrame *in) ++{ ++ AVFilterContext *avctx = link->dst; ++ DeintV4L2M2MContext *priv = avctx->priv; ++ DeintV4L2M2MContextShared *ctx = priv->shared; ++ V4L2Queue *capture = &ctx->capture; ++ V4L2Queue *output = &ctx->output; ++ int ret; ++ ++ av_log(priv, AV_LOG_DEBUG, "input pts: %"PRId64" field :%d interlaced: %d\n", ++ in->pts, !!(in->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST), !!(in->flags & AV_FRAME_FLAG_INTERLACED)); ++ ++ ctx->cur_in_frame = in; ++ ++ if (ctx->field_order == V4L2_FIELD_ANY) { ++ AVDRMFrameDescriptor *drm_desc = (AVDRMFrameDescriptor *)in->data[0]; ++ ctx->orig_width = drm_desc->layers[0].planes[0].pitch; ++ ctx->orig_height = drm_desc->layers[0].planes[1].offset / ctx->orig_width; ++ ctx->drm_in_format = drm_desc->layers->format; ++ ctx->drm_out_format = drm_desc->layers->format; ++ ++ if (!!(in->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST)) ++ ctx->field_order = V4L2_FIELD_INTERLACED_TB; ++ else ++ ctx->field_order = V4L2_FIELD_INTERLACED_BT; ++ ++ ret = deint_v4l2m2m_set_format(output, ctx->field_order, ++ ctx->orig_width, ctx->orig_height, ++ ctx->drm_in_format); ++ if (ret) ++ return ret; ++ ++ ret = deint_v4l2m2m_set_format(capture, V4L2_FIELD_NONE, ++ ctx->orig_width, ctx->orig_height, ++ ctx->drm_out_format); ++ if (ret) ++ return ret; ++ ++ ret = deint_v4l2m2m_allocate_buffers(capture); ++ if (ret) ++ return ret; ++ ++ ret = deint_v4l2m2m_streamon(capture); ++ if (ret) ++ return ret; ++ ++ ret = deint_v4l2m2m_allocate_buffers(output); ++ if (ret) ++ return ret; ++ ++ ret = deint_v4l2m2m_streamon(output); ++ if (ret) ++ return ret; ++ } ++ ++ ret = deint_v4l2m2m_enqueue(output, in); ++ if (ret) ++ return ret; ++ ++ ret = deint_v4l2m2m_dequeue(avctx, in); ++ if (ret) ++ return ret; ++ ++ if (ctx->prev_in_frame) ++ av_frame_free(&ctx->prev_in_frame); ++ ++ ctx->prev_in_frame = in; ++ ctx->cur_in_frame = NULL; ++ ++ return 0; ++} ++ ++static av_cold int deint_v4l2m2m_init(AVFilterContext *avctx) ++{ ++ DeintV4L2M2MContext *priv = avctx->priv; ++ DeintV4L2M2MContextShared *ctx; ++ ++ ctx = av_mallocz(sizeof(DeintV4L2M2MContextShared)); ++ if (!ctx) ++ return AVERROR(ENOMEM); ++ ++ priv->shared = ctx; ++ ctx->fd = -1; ++ ctx->output.ctx = ctx; ++ ctx->output.num_buffers = 6; ++ ctx->capture.ctx = ctx; ++ ctx->capture.num_buffers = 6; ++ ctx->done = 0; ++ ctx->field_order = V4L2_FIELD_ANY; ++ ctx->cur_in_frame = NULL; ++ ctx->prev_in_frame = NULL; ++ ctx->drm_in_format = DRM_FORMAT_NV12; ++ ctx->drm_out_format = DRM_FORMAT_NV12; ++ atomic_init(&ctx->refcount, 1); ++ ++ return 0; ++} ++ ++static void deint_v4l2m2m_uninit(AVFilterContext *avctx) ++{ ++ DeintV4L2M2MContext *priv = avctx->priv; ++ DeintV4L2M2MContextShared *ctx = priv->shared; ++ ++ ctx->done = 1; ++ deint_v4l2m2m_destroy_context(ctx); ++} ++ ++static const AVOption deinterlace_v4l2m2m_options[] = { ++ { NULL }, ++}; ++ ++AVFILTER_DEFINE_CLASS(deinterlace_v4l2m2m); ++ ++static const AVFilterPad deint_v4l2m2m_inputs[] = { ++ { ++ .name = "default", ++ .type = AVMEDIA_TYPE_VIDEO, ++ .filter_frame = deint_v4l2m2m_filter_frame, ++ }, ++}; ++ ++static const AVFilterPad deint_v4l2m2m_outputs[] = { ++ { ++ .name = "default", ++ .type = AVMEDIA_TYPE_VIDEO, ++ .config_props = deint_v4l2m2m_config_props, ++ }, ++}; ++ ++const FFFilter ff_vf_deinterlace_v4l2m2m = { ++ .p.name = "deinterlace_v4l2m2m", ++ .p.description = NULL_IF_CONFIG_SMALL("V4L2 M2M deinterlacer"), ++ .p.priv_class = &deinterlace_v4l2m2m_class, ++ .priv_size = sizeof(DeintV4L2M2MContext), ++ .init = &deint_v4l2m2m_init, ++ .uninit = &deint_v4l2m2m_uninit, ++ FILTER_QUERY_FUNC(&deint_v4l2m2m_query_formats), ++ FILTER_INPUTS(deint_v4l2m2m_inputs), ++ FILTER_OUTPUTS(deint_v4l2m2m_outputs), ++};