From patchwork Tue Sep 19 11:34:58 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dawid Kozinski X-Patchwork-Id: 43779 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:a886:b0:149:dfde:5c0a with SMTP id ca6csp428304pzb; Tue, 19 Sep 2023 04:35:45 -0700 (PDT) X-Google-Smtp-Source: AGHT+IH7DvVD4SXA701KTquZrMYvHUiquwwDp0zom82G1nnL4SVrZlA8Pw4dvWWUs/cJmQTWL36Y X-Received: by 2002:a17:906:cc58:b0:9ae:3772:10c3 with SMTP id mm24-20020a170906cc5800b009ae377210c3mr993954ejb.22.1695123345498; Tue, 19 Sep 2023 04:35:45 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1695123345; cv=none; d=google.com; s=arc-20160816; b=CT+lDNuDWAgg0mrSZfjPkQ53hC2FqneTO47U+bV9y7wqGI9cWL8exPSdnWWYOQsEgG uz/M3w6qtAqYcSXWLiBWCNzmDx+yAo0zgvn9sKx1ZEuO0lgCaAHqIIhAvEy3lMAcDnL/ VEe7Pd+jw0BOYz55uwOtD6792N2xMK9DcDbna251QQ6orzW3PYXgCwgAt6oTXiPsz0SJ 9iVN/neZWdB2XK5MmFZRQQBwZiLI6d5V4+yd+CCDhs23vN0CQSw6RAsrECVBmCWXs0t9 /4kHaD6xvUE0yO1CDwiXyBcJ2gTKBdif4ve35QgsK1W58I+23iv5vDXjtBFFIv3UhULh xl/w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:cc:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:references:cms-type:mime-version :message-id:date:to:from:dkim-signature:dkim-filter:delivered-to; bh=UNPZo+//t3GVovvrMVILUPvaTZLSRFIpAUlEEGGIjqA=; fh=+CoJMqcO7X76kE97Bx5T9sFRidmuqFXOXO2hAQXFslQ=; b=K20WfhGKZwRjil+CkbgC/YO71AI+vpAhLl9djlW+DC4G0f8mXf2x3XPjRCkH4WOH1o fWuxahCRp1Mwd2156GhtSvDMVsI8hiJClufroP9FVYh4rLO8kKJuk8+JrdYZgJGHkFPz 9r/birkatVlf3fyIGEKptB58JFugO3NvJNsDXmceyopViU/BI6wHx42cW+TWrQOPkjEj OybOO3X0t1JESnvcYoN1x2CAia061CJzDWD8B+vNT9HdErPgPwxJifmA8hTl33YXAlYT W47dIoNiY7KwUjOjr3ZYA3x3KYSmjAKwDM5LbSm+OHS8/kpIT4ryT5K2A1YA0eIwWnMW 0WzA== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@samsung.com header.s=mail20170921 header.b=ij5vICHJ; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=samsung.com Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id p5-20020a1709061b4500b0099cb6622adasi9103409ejg.205.2023.09.19.04.35.20; Tue, 19 Sep 2023 04:35:45 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@samsung.com header.s=mail20170921 header.b=ij5vICHJ; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=samsung.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 83B1468C8B4; Tue, 19 Sep 2023 14:35:18 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mailout1.w1.samsung.com (mailout1.w1.samsung.com [210.118.77.11]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 1FAD168AC36 for ; Tue, 19 Sep 2023 14:35:16 +0300 (EEST) Received: from eucas1p1.samsung.com (unknown [182.198.249.206]) by mailout1.w1.samsung.com (KnoxPortal) with ESMTP id 20230919113516euoutp01ca4e0a0cc2fba9cb502d08c77857b7e2~GSazIv3fh0540505405euoutp01y for ; Tue, 19 Sep 2023 11:35:16 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout1.w1.samsung.com 20230919113516euoutp01ca4e0a0cc2fba9cb502d08c77857b7e2~GSazIv3fh0540505405euoutp01y DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1695123316; bh=KYibW074S2cWo7C1Iylc3ro4kX2qVVREAMv/xkhdt94=; h=From:To:Cc:Subject:Date:References:From; b=ij5vICHJTAXk6ijD+No0GJqGwMSkBnt/zXQNtHJAitFqmcMSOB9rcMHQ4SQMoK7zJ CGP5zyEa4/N4bbbA7c+U7ubCjsTS9wJChgjVo7stNAJetwj7YrEedQIJ7CL5KsfC7X y8vr+9tXeZuVKpPG29eCvDT653Q8S9YzHDYexyyU= Received: from eusmges3new.samsung.com (unknown [203.254.199.245]) by eucas1p2.samsung.com (KnoxPortal) with ESMTP id 20230919113515eucas1p22b007f8d04c2fa7936e494efcc50dd63~GSay7zVcG0400604006eucas1p2u; Tue, 19 Sep 2023 11:35:15 +0000 (GMT) Received: from eucas1p2.samsung.com ( [182.198.249.207]) by eusmges3new.samsung.com (EUCPMTA) with SMTP id E6.00.37758.37789056; Tue, 19 Sep 2023 12:35:15 +0100 (BST) Received: from eusmtrp2.samsung.com (unknown [182.198.249.139]) by eucas1p1.samsung.com (KnoxPortal) with ESMTPA id 20230919113515eucas1p13dff57a0cbed245ecd5d38c6a477e28a~GSayf-IpB0065700657eucas1p1x; Tue, 19 Sep 2023 11:35:15 +0000 (GMT) Received: from eusmgms2.samsung.com (unknown [182.198.249.180]) by eusmtrp2.samsung.com (KnoxPortal) with ESMTP id 20230919113515eusmtrp21186adc5343501d4c28c04feee93edfc~GSayfctsO0932409324eusmtrp2q; Tue, 19 Sep 2023 11:35:15 +0000 (GMT) X-AuditID: cbfec7f5-815ff7000002937e-c1-6509877339c8 Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms2.samsung.com (EUCPMTA) with SMTP id E9.AA.14344.37789056; Tue, 19 Sep 2023 12:35:15 +0100 (BST) Received: from AMDN5164.EU.corp.samsungelectronics.net (unknown [106.210.132.171]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20230919113514eusmtip1c6df0aca13be87414065df5ac0bc0de9~GSayAr5kK2972629726eusmtip1U; Tue, 19 Sep 2023 11:35:14 +0000 (GMT) From: Dawid Kozinski To: d.frankiewic@samsung.com, ffmpeg-devel@ffmpeg.org Date: Tue, 19 Sep 2023 13:34:58 +0200 Message-Id: <20230919113458.1244-1-d.kozinski@samsung.com> X-Mailer: git-send-email 2.37.3.windows.1 MIME-Version: 1.0 X-Unsent: 1 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFnrNIsWRmVeSWpSXmKPExsWy7djP87rF7ZypBvc/m1h8ufaF2WLlt98s Ft8+nWF2YPb4s2gzi0ffllWMAUxRXDYpqTmZZalF+nYJXBl3tk9jLZh2mLGiq2cFUwPj307G LkYODgkBE4nOxYVdjFwcQgIrGCXOTtzEBuF8YZSYd/EQI4TzmVFiT9MJVpiOy4e9IOLLGSWe r2pnh3DamSSutJwFcjg52AR0JV5+eMQEYosImEqcbN7LBmIzC2hLrLv7HcwWFgiQ2HfiMFgN i4CqRGPLDTCbV8BK4sXN9WA1EgKaEhO2zIGKC0qcnPmEBSLOLbFu1iVWiJnyEs1bZzODHCEh 8Jdd4tfsBkaIIheJX13/oGxhiVfHt7BD2DIS/3fOZ4L4pljiUL8DhFkjcehHOkSFtcTbxuPg EGIGOmH9Ln2ICkeJtrNyECafxI23ghD7+SQmbZvODBHmlehoE4IwVST6OsUgxklJPF02hxnC 9pDYvmQZ2wRGxVlInpqF5JFZCFsXMDKvYhRPLS3OTU8tNs5LLdcrTswtLs1L10vOz93ECEwP p/8d/7qDccWrj3qHGJk4GA8xSnAwK4nwzjRkSxXiTUmsrEotyo8vKs1JLT7EKM3BoiTOq217 MllIID2xJDU7NbUgtQgmy8TBKdXA5K9R0e+60GtS1OIl+52Z+z83f/86vXP2ZvOTP7eHr/iw e1qh7QSWR6zlOyUPRM5rl130J1/ZZNUppYN9CVOVueYZ/Tl+4/19Y9ue1skM9hvZpd2e8XSv cr0avuBWTlB74GLbrVdSE5fJm5/Vf3buudEZRcPfSnIWChb8j5mcEibKmzq7LG6tv7fUcl1Z 35X1cxMT1jzffPly9c39jQ873X5Ps9ybpcPUqv+vQk2kOPfHpLdbE2vyvNy3C/QbXNjKIDh1 pw+rQEz8JZ39DxY5H6yuE/xwrUot4vqBLPHE8FRlhaCb0VdKu31WbPMy3v/K1F0wcWbNkxnB tRu/MdQcju569NVYubclxYg1dOcdJZbijERDLeai4kQA/e37D34DAAA= X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFrrMLMWRmVeSWpSXmKPExsVy+t/xu7rF7ZypBu8bRS2+XPvCbLHy228W i2+fzjA7MHv8WbSZxaNvyyrGAKYoPZui/NKSVIWM/OISW6VoQwsjPUNLCz0jE0s9Q2PzWCsj UyV9O5uU1JzMstQifbsEvYw726exFkw7zFjR1bOCqYHxbydjFyMHh4SAicTlw15djFwcQgJL GSWuLW9g6WLkBIpLSSxduogRwhaW+HOtiw2iqJVJ4szUm2wgCTYBXYmXHx4xgdgiAuYSF9fd AmtgFtCWWHf3O1iNsICfxK6vG9lBbBYBVYnGlhtg9bwCVhIvbq5ng1igKTFhyxyouKDEyZlP oI7gllg36xIrxEx5ieats5knMPLPQlI2C0lqASPTKkaR1NLi3PTcYiO94sTc4tK8dL3k/NxN jMDQ3Xbs55YdjCtffdQ7xMjEwXiIUYKDWUmEd6YhW6oQb0piZVVqUX58UWlOavEhRlOgWycy S4km5wOjJ68k3tDMwNTQxMzSwNTSzFhJnNezoCNRSCA9sSQ1OzW1ILUIpo+Jg1OqgSlye/9n zztfM8N0t5/fEphTsOB0/oJ3DfHZPhcK0vdKnPdmvaAXedwjruFKxbpkvrjvC7Yw/NI4MDGk 8OvqTrltfq7G+7Zt2+rzYMbT6fmX7Xbo7zjb9slWN7fTd2v5NwsNf8/UaRYiPYxCXrEsayO2 FtUneBqese/evsMw0zIk8PEs1xeFC+7bly/mDexu19ld9+rola9sBnu41B6VPTm+aVNOjFhl uMZyuyPTlr9xeM2Rqr9RZMOajltsGVtnf/0jHDg3sV/ne6GKw8e2nun1Nx4t0p+SPW2+6e3d C7c19BXqxm6LPTvv+4a1MoV+mVNrVdnKGg/efcW7+mhpJ9NpZscYn4opX5t2zT4t3qPEUpyR aKjFXFScCAB9KtIr5gIAAA== X-CMS-MailID: 20230919113515eucas1p13dff57a0cbed245ecd5d38c6a477e28a X-Msg-Generator: CA X-RootMTR: 20230919113515eucas1p13dff57a0cbed245ecd5d38c6a477e28a X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20230919113515eucas1p13dff57a0cbed245ecd5d38c6a477e28a References: Subject: [FFmpeg-devel] [PATCH v28 2/2] avcodec/evc_decoder: Provided support for EVC decoder X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Dawid Kozinski Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: bEZAr9ioep3O - Added EVC decoder wrapper - Changes in project configuration file and libavcodec Makefile - Added documentation for xevd wrapper Signed-off-by: Dawid Kozinski --- configure | 4 + doc/decoders.texi | 24 ++ doc/general_contents.texi | 10 +- libavcodec/Makefile | 1 + libavcodec/allcodecs.c | 1 + libavcodec/libxevd.c | 538 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 577 insertions(+), 1 deletion(-) create mode 100644 libavcodec/libxevd.c diff --git a/configure b/configure index a761d4879e..8a58ed2bdc 100755 --- a/configure +++ b/configure @@ -294,6 +294,7 @@ External library support: --enable-libx264 enable H.264 encoding via x264 [no] --enable-libx265 enable HEVC encoding via x265 [no] --enable-libxeve enable EVC encoding via libxeve [no] + --enable-libxevd enable EVC decoding via libxevd [no] --enable-libxavs enable AVS encoding via xavs [no] --enable-libxavs2 enable AVS2 encoding via xavs2 [no] --enable-libxcb enable X11 grabbing using XCB [autodetect] @@ -1906,6 +1907,7 @@ EXTERNAL_LIBRARY_LIST=" libvorbis libvpx libwebp + libxevd libxeve libxml2 libzimg @@ -3468,6 +3470,7 @@ libx265_encoder_deps="libx265" libx265_encoder_select="atsc_a53" libxavs_encoder_deps="libxavs" libxavs2_encoder_deps="libxavs2" +libxevd_decoder_deps="libxevd" libxeve_encoder_deps="libxeve" libxvid_encoder_deps="libxvid" libzvbi_teletext_decoder_deps="libzvbi" @@ -6852,6 +6855,7 @@ enabled libx265 && require_pkg_config libx265 x265 x265.h x265_api_get require_cpp_condition libx265 x265.h "X265_BUILD >= 89" enabled libxavs && require libxavs "stdint.h xavs.h" xavs_encoder_encode "-lxavs $pthreads_extralibs $libm_extralibs" enabled libxavs2 && require_pkg_config libxavs2 "xavs2 >= 1.3.0" "stdint.h xavs2.h" xavs2_api_get +enabled libxevd && require_pkg_config libxevd "xevd >= 0.4.1" "xevd.h" xevd_decode enabled libxeve && require_pkg_config libxeve "xeve >= 0.4.3" "xeve.h" xeve_encode enabled libxvid && require libxvid xvid.h xvid_global -lxvidcore enabled libzimg && require_pkg_config libzimg "zimg >= 2.7.0" zimg.h zimg_get_api_version diff --git a/doc/decoders.texi b/doc/decoders.texi index 09b8314dd2..6311af229f 100644 --- a/doc/decoders.texi +++ b/doc/decoders.texi @@ -130,6 +130,30 @@ Set amount of frame threads to use during decoding. The default value is 0 (auto @end table +@section libxevd + +eXtra-fast Essential Video Decoder (XEVD) MPEG-5 EVC decoder wrapper. + +This decoder requires the presence of the libxevd headers and library +during configuration. You need to explicitly configure the build with +@option{--enable-libxevd}. + +The xevd project website is at @url{https://github.com/mpeg5/xevd}. + +@subsection Options + +The following options are supported by the libxevd wrapper. +The xevd-equivalent options or values are listed in parentheses for easy migration. + +To get a more accurate and extensive documentation of the libxevd options, +invoke the command @code{xevd_app --help} or consult the libxevd documentation. + +@table @option +@item threads (@emph{threads}) +Force to use a specific number of threads + +@end table + @section QSV Decoders The family of Intel QuickSync Video decoders (VC1, MPEG-2, H.264, HEVC, diff --git a/doc/general_contents.texi b/doc/general_contents.texi index d718f55bd8..1a9b5e2622 100644 --- a/doc/general_contents.texi +++ b/doc/general_contents.texi @@ -351,6 +351,14 @@ Go to @url{https://github.com/mpeg5/xeve} and follow the instructions for installing the XEVE library. Then pass @code{--enable-libxeve} to configure to enable it. +@section eXtra-fast Essential Video Decoder (XEVD) + +FFmpeg can make use of the XEVD library for EVC video decoding. + +Go to @url{https://github.com/mpeg5/xevd} and follow the instructions for +installing the XEVD library. Then pass @code{--enable-libxevd} to configure to +enable it. + @section ZVBI ZVBI is a VBI decoding library which can be used by FFmpeg to decode DVB @@ -954,7 +962,7 @@ following image formats are supported: @item Escape 124 @tab @tab X @item Escape 130 @tab @tab X @item EVC / MPEG-5 Part 1 @tab X @tab X - @tab encoding and decoding supported through external library libxeve + @tab encoding and decoding supported through external libraries libxeve and libxevd @item FFmpeg video codec #1 @tab X @tab X @tab lossless codec (fourcc: FFV1) @item Flash Screen Video v1 @tab X @tab X diff --git a/libavcodec/Makefile b/libavcodec/Makefile index daa867f2e6..555b24e1d9 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -1147,6 +1147,7 @@ OBJS-$(CONFIG_LIBX264_ENCODER) += libx264.o OBJS-$(CONFIG_LIBX265_ENCODER) += libx265.o OBJS-$(CONFIG_LIBXAVS_ENCODER) += libxavs.o OBJS-$(CONFIG_LIBXAVS2_ENCODER) += libxavs2.o +OBJS-$(CONFIG_LIBXEVD_DECODER) += libxevd.o OBJS-$(CONFIG_LIBXEVE_ENCODER) += libxeve.o OBJS-$(CONFIG_LIBXVID_ENCODER) += libxvid.o OBJS-$(CONFIG_LIBZVBI_TELETEXT_DECODER) += libzvbi-teletextdec.o ass.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index c2c108488e..13c570e929 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -821,6 +821,7 @@ extern LIBX264_CONST FFCodec ff_libx264_encoder; extern const FFCodec ff_libx264rgb_encoder; extern FFCodec ff_libx265_encoder; extern const FFCodec ff_libxeve_encoder; +extern const FFCodec ff_libxevd_decoder; extern const FFCodec ff_libxavs_encoder; extern const FFCodec ff_libxavs2_encoder; extern const FFCodec ff_libxvid_encoder; diff --git a/libavcodec/libxevd.c b/libavcodec/libxevd.c new file mode 100644 index 0000000000..58ef90d929 --- /dev/null +++ b/libavcodec/libxevd.c @@ -0,0 +1,538 @@ +/* + * libxevd decoder + * EVC (MPEG-5 Essential Video Coding) decoding using XEVD MPEG-5 EVC decoder library + * + * Copyright (C) 2021 Dawid Kozinski + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include + +#include + +#include "libavutil/internal.h" +#include "libavutil/common.h" +#include "libavutil/opt.h" +#include "libavutil/pixdesc.h" +#include "libavutil/pixfmt.h" +#include "libavutil/imgutils.h" +#include "libavutil/cpu.h" + +#include "avcodec.h" +#include "internal.h" +#include "packet_internal.h" +#include "codec_internal.h" +#include "profiles.h" +#include "decode.h" + +#define XEVD_PARAM_BAD_NAME -1 +#define XEVD_PARAM_BAD_VALUE -2 + +#define EVC_NAL_HEADER_SIZE 2 /* byte */ + +/** + * The structure stores all the states associated with the instance of Xeve MPEG-5 EVC decoder + */ +typedef struct XevdContext { + const AVClass *class; + + XEVD id; // XEVD instance identifier @see xevd.h + XEVD_CDSC cdsc; // decoding parameters @see xevd.h + + // If end of stream occurs it is required "flushing" (aka draining) the codec, + // as the codec might buffer multiple frames or packets internally. + int draining_mode; // The flag is set if codec enters draining mode. + + AVPacket *pkt; // access unit (a set of NAL units that are consecutive in decoding order and containing exactly one encoded image) +} XevdContext; + +/** + * The function populates the XEVD_CDSC structure. + * XEVD_CDSC contains all decoder parameters that should be initialized before its use. + * + * @param[in] avctx codec context + * @param[out] cdsc contains all decoder parameters that should be initialized before its use + * + */ +static void get_conf(AVCodecContext *avctx, XEVD_CDSC *cdsc) +{ + int cpu_count = av_cpu_count(); + + /* clear XEVS_CDSC structure */ + memset(cdsc, 0, sizeof(XEVD_CDSC)); + + /* init XEVD_CDSC */ + if (avctx->thread_count <= 0) + cdsc->threads = (cpu_count < XEVD_MAX_TASK_CNT) ? cpu_count : XEVD_MAX_TASK_CNT; + else if (avctx->thread_count > XEVD_MAX_TASK_CNT) + cdsc->threads = XEVD_MAX_TASK_CNT; + else + cdsc->threads = avctx->thread_count; +} + +/** + * Read NAL unit length + * @param bs input data (bitstream) + * @return the length of NAL unit on success, 0 value on failure + */ +static uint32_t read_nal_unit_length(const uint8_t *bs, int bs_size, AVCodecContext *avctx) +{ + uint32_t len = 0; + XEVD_INFO info; + int ret; + + if (bs_size == XEVD_NAL_UNIT_LENGTH_BYTE) { + ret = xevd_info((void *)bs, XEVD_NAL_UNIT_LENGTH_BYTE, 1, &info); + if (XEVD_FAILED(ret)) { + av_log(avctx, AV_LOG_ERROR, "Cannot get bitstream information\n"); + return 0; + } + len = info.nalu_len; + if (len == 0) { + av_log(avctx, AV_LOG_ERROR, "Invalid bitstream size! [%d]\n", bs_size); + return 0; + } + } + + return len; +} + +/** + * @param[in] xectx the structure that stores all the state associated with the instance of Xeve MPEG-5 EVC decoder + * @param[out] avctx codec context + * @return 0 on success, negative value on failure + */ +static int export_stream_params(const XevdContext *xectx, AVCodecContext *avctx) +{ + int ret; + int size; + int color_space; + + avctx->pix_fmt = AV_PIX_FMT_YUV420P10; + + size = 4; + ret = xevd_config(xectx->id, XEVD_CFG_GET_CODED_WIDTH, &avctx->coded_width, &size); + if (XEVD_FAILED(ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to get coded_width\n"); + return AVERROR_EXTERNAL; + } + + ret = xevd_config(xectx->id, XEVD_CFG_GET_CODED_HEIGHT, &avctx->coded_height, &size); + if (XEVD_FAILED(ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to get coded_height\n"); + return AVERROR_EXTERNAL; + } + + ret = xevd_config(xectx->id, XEVD_CFG_GET_WIDTH, &avctx->width, &size); + if (XEVD_FAILED(ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to get width\n"); + return AVERROR_EXTERNAL; + } + + ret = xevd_config(xectx->id, XEVD_CFG_GET_HEIGHT, &avctx->height, &size); + if (XEVD_FAILED(ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to get height\n"); + return AVERROR_EXTERNAL; + } + + ret = xevd_config(xectx->id, XEVD_CFG_GET_COLOR_SPACE, &color_space, &size); + if (XEVD_FAILED(ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to get color_space\n"); + return AVERROR_EXTERNAL; + } + switch(color_space) { + case XEVD_CS_YCBCR400_10LE: + avctx->pix_fmt = AV_PIX_FMT_GRAY10LE; + break; + case XEVD_CS_YCBCR420_10LE: + avctx->pix_fmt = AV_PIX_FMT_YUV420P10LE; + break; + case XEVD_CS_YCBCR422_10LE: + avctx->pix_fmt = AV_PIX_FMT_YUV422P10LE; + break; + case XEVD_CS_YCBCR444_10LE: + avctx->pix_fmt = AV_PIX_FMT_YUV444P10LE; + break; + default: + av_log(avctx, AV_LOG_ERROR, "Unknown color space\n"); + avctx->pix_fmt = AV_PIX_FMT_NONE; + return AVERROR_INVALIDDATA; + } + + // the function returns sps->num_reorder_pics + ret = xevd_config(xectx->id, XEVD_CFG_GET_MAX_CODING_DELAY, &avctx->max_b_frames, &size); + if (XEVD_FAILED(ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to get max_coding_delay\n"); + return AVERROR_EXTERNAL; + } + + avctx->has_b_frames = (avctx->max_b_frames) ? 1 : 0; + + return 0; +} + +/** + * @brief Copy image in imgb to frame. + * + * @param avctx codec context + * @param[in] imgb + * @param[out] frame + * @return 0 on success, negative value on failure + */ +static int libxevd_image_copy(struct AVCodecContext *avctx, XEVD_IMGB *imgb, struct AVFrame *frame) +{ + int ret; + if (imgb->cs != XEVD_CS_YCBCR420_10LE) { + av_log(avctx, AV_LOG_ERROR, "Not supported pixel format: %s\n", av_get_pix_fmt_name(avctx->pix_fmt)); + return AVERROR_INVALIDDATA; + } + + if (imgb->w[0] != avctx->width || imgb->h[0] != avctx->height) { // stream resolution changed + if (ff_set_dimensions(avctx, imgb->w[0], imgb->h[0]) < 0) { + av_log(avctx, AV_LOG_ERROR, "Cannot set new dimension\n"); + return AVERROR_INVALIDDATA; + } + } + + if (ret = ff_get_buffer(avctx, frame, 0) < 0) + return ret; + + av_image_copy(frame->data, frame->linesize, (const uint8_t **)imgb->a, + imgb->s, avctx->pix_fmt, + imgb->w[0], imgb->h[0]); + + return 0; +} + +/** + * Initialize decoder + * Create a decoder instance and allocate all the needed resources + * + * @param avctx codec context + * @return 0 on success, negative error code on failure + */ +static av_cold int libxevd_init(AVCodecContext *avctx) +{ + XevdContext *xectx = avctx->priv_data; + XEVD_CDSC *cdsc = &(xectx->cdsc); + + /* read configurations and set values for created descriptor (XEVD_CDSC) */ + get_conf(avctx, cdsc); + + /* create decoder */ + xectx->id = xevd_create(&(xectx->cdsc), NULL); + if (xectx->id == NULL) { + av_log(avctx, AV_LOG_ERROR, "Cannot create XEVD encoder\n"); + return AVERROR_EXTERNAL; + } + + xectx->draining_mode = 0; + xectx->pkt = av_packet_alloc(); + if (!xectx->pkt) { + av_log(avctx, AV_LOG_ERROR, "Cannot allocate memory for AVPacket\n"); + return AVERROR(ENOMEM); + } + + return 0; +} + +/** + * Decode frame with decoupled packet/frame dataflow + * + * @param avctx codec context + * @param[out] frame decoded frame + * + * @return 0 on success, negative error code on failure + */ +static int libxevd_receive_frame(AVCodecContext *avctx, AVFrame *frame) +{ + XevdContext *xectx = avctx->priv_data; + AVPacket *pkt = xectx->pkt; + XEVD_IMGB *imgb = NULL; + + int xevd_ret = 0; + int ret = 0; + + // obtain access unit (input data) - a set of NAL units that are consecutive in decoding order and containing exactly one encoded image + ret = ff_decode_get_packet(avctx, pkt); + if (ret < 0 && ret != AVERROR_EOF) { + av_packet_unref(pkt); + + return ret; + } else if(ret == AVERROR_EOF && xectx->draining_mode == 0) { // End of stream situations. Enter draining mode + + xectx->draining_mode = 1; + av_packet_unref(pkt); + } + + if (pkt->size > 0) { + int bs_read_pos = 0; + XEVD_STAT stat; + XEVD_BITB bitb; + int nalu_size; + AVPacket* pkt_au; + imgb = NULL; + + pkt_au = av_packet_clone(pkt); + if (!pkt_au) { + av_log(avctx, AV_LOG_ERROR, "Cannot clone AVPacket\n"); + av_packet_unref(pkt); + return AVERROR(ENOMEM); + } + + av_packet_unref(pkt); + + // get all nal units from AU + while(pkt_au->size > (bs_read_pos + XEVD_NAL_UNIT_LENGTH_BYTE)) { + memset(&stat, 0, sizeof(XEVD_STAT)); + + nalu_size = read_nal_unit_length(pkt_au->data + bs_read_pos, XEVD_NAL_UNIT_LENGTH_BYTE, avctx); + if (nalu_size == 0) { + av_log(avctx, AV_LOG_ERROR, "Invalid bitstream\n"); + av_packet_free(&pkt_au); + ret = AVERROR_INVALIDDATA; + + return ret; + } + bs_read_pos += XEVD_NAL_UNIT_LENGTH_BYTE; + + bitb.addr = pkt_au->data + bs_read_pos; + bitb.ssize = nalu_size; + bitb.pdata[0] = pkt_au; + bitb.ts[XEVD_TS_DTS] = pkt_au->dts; + + /* main decoding block */ + xevd_ret = xevd_decode(xectx->id, &bitb, &stat); + if (XEVD_FAILED(xevd_ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to decode bitstream\n"); + av_packet_free(&pkt_au); + + return AVERROR_EXTERNAL; + } + + bs_read_pos += nalu_size; + + if (stat.nalu_type == XEVD_NUT_SPS) { // EVC stream parameters changed + if ((ret = export_stream_params(xectx, avctx)) != 0) { + av_log(avctx, AV_LOG_ERROR, "Failed to export stream params\n"); + av_packet_free(&pkt_au); + + return ret; + } + } + + if (stat.read != nalu_size) + av_log(avctx, AV_LOG_INFO, "Different reading of bitstream (in:%d, read:%d)\n,", nalu_size, stat.read); + + // stat.fnum - has negative value if the decoded data is not frame + if (stat.fnum >= 0) { + + xevd_ret = xevd_pull(xectx->id, &imgb); // The function returns a valid image only if the return code is XEVD_OK + + if (XEVD_FAILED(xevd_ret)) { + av_log(avctx, AV_LOG_ERROR, "Failed to pull the decoded image (xevd error code: %d, frame#=%d)\n", xevd_ret, stat.fnum); + + av_packet_free(&pkt_au); + + return AVERROR_EXTERNAL; + } else if (xevd_ret == XEVD_OK_FRM_DELAYED) { + if(bs_read_pos == pkt_au->size) { + return AVERROR(EAGAIN); + } + } else { // XEVD_OK + if (!imgb) { + if(bs_read_pos == pkt_au->size) { + av_log(avctx, AV_LOG_ERROR, "Invalid decoded image data\n"); + + av_packet_free(&pkt_au); + return AVERROR(EAGAIN); + } + } else { + // got frame + AVPacket* pkt_au_imgb = (AVPacket*)imgb->pdata[0]; + if(!pkt_au_imgb) { + av_log(avctx, AV_LOG_ERROR, "Invalid data needed to fill frame properties\n"); + + av_packet_free(&pkt_au); + av_frame_unref(frame); + + imgb->release(imgb); + imgb = NULL; + + return AVERROR_INVALIDDATA; + } + + ret = libxevd_image_copy(avctx, imgb, frame); + if(ret < 0) { + av_log(avctx, AV_LOG_ERROR, "Image copying error\n"); + + av_packet_free(&pkt_au_imgb); + av_frame_unref(frame); + + imgb->release(imgb); + imgb = NULL; + + return ret; + } + + // use ff_decode_frame_props_from_pkt() to fill frame properties + ret = ff_decode_frame_props_from_pkt(avctx, frame, pkt_au_imgb); + if (ret < 0) { + av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props_from_pkt error\n"); + + av_packet_free(&pkt_au_imgb); + av_frame_unref(frame); + + imgb->release(imgb); + imgb = NULL; + + return ret; + } + + frame->pkt_dts = imgb->ts[XEVD_TS_DTS]; + frame->pts = imgb->ts[XEVD_TS_PTS]; + + av_packet_free(&pkt_au_imgb); + + // xevd_pull uses pool of objects of type XEVD_IMGB. + // The pool size is equal MAX_PB_SIZE (26), so release object when it is no more needed + imgb->release(imgb); + imgb = NULL; + } + } + } + } + } else { // decoder draining mode handling + + xevd_ret = xevd_pull(xectx->id, &imgb); + + if (xevd_ret == XEVD_ERR_UNEXPECTED) { // draining process completed + av_log(avctx, AV_LOG_DEBUG, "Draining process completed\n"); + + return AVERROR_EOF; + } else if (XEVD_FAILED(xevd_ret)) { // handle all other errors + av_log(avctx, AV_LOG_ERROR, "Failed to pull the decoded image (xevd error code: %d)\n", xevd_ret); + + return AVERROR_EXTERNAL; + } else { // XEVD_OK + AVPacket* pkt_au_imgb; + if (!imgb) { + av_log(avctx, AV_LOG_ERROR, "Invalid decoded image data\n"); + + return AVERROR_EXTERNAL; + } + + pkt_au_imgb = (AVPacket*)imgb->pdata[0]; + if(!pkt_au_imgb) { + av_log(avctx, AV_LOG_ERROR, "Invalid data needed to fill frame properties\n"); + + imgb->release(imgb); + imgb = NULL; + + av_frame_unref(frame); + + return AVERROR_INVALIDDATA; + } + + // got frame + ret = libxevd_image_copy(avctx, imgb, frame); + if(ret < 0) { + av_packet_free(&pkt_au_imgb); + av_frame_unref(frame); + + imgb->release(imgb); + imgb = NULL; + + return ret; + } + // use ff_decode_frame_props_from_pkt() to fill frame properties + ret = ff_decode_frame_props_from_pkt(avctx, frame, pkt_au_imgb); + if (ret < 0) { + av_log(avctx, AV_LOG_ERROR, "ff_decode_frame_props_from_pkt error\n"); + + av_packet_free(&pkt_au_imgb); + av_frame_unref(frame); + + imgb->release(imgb); + imgb = NULL; + + return ret; + } + + frame->pkt_dts = imgb->ts[XEVD_TS_DTS]; + frame->pts = imgb->ts[XEVD_TS_PTS]; + + av_packet_free(&pkt_au_imgb); + + // xevd_pull uses pool of objects of type XEVD_IMGB. + // The pool size is equal MAX_PB_SIZE (26), so release object when it is no more needed + imgb->release(imgb); + imgb = NULL; + + return 0; + } + } + + return ret; +} + +/** + * Destroy decoder + * + * @param avctx codec context + * @return 0 on success + */ +static av_cold int libxevd_close(AVCodecContext *avctx) +{ + XevdContext *xectx = avctx->priv_data; + if (xectx->id) { + xevd_delete(xectx->id); + xectx->id = NULL; + } + + xectx->draining_mode = 0; + av_packet_free(&xectx->pkt); + + return 0; +} + +#define OFFSET(x) offsetof(XevdContext, x) +#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM + +static const AVClass libxevd_class = { + .class_name = "libxevd", + .item_name = av_default_item_name, + .version = LIBAVUTIL_VERSION_INT, +}; + +const FFCodec ff_libxevd_decoder = { + .p.name = "evc", + .p.long_name = NULL_IF_CONFIG_SMALL("EVC / MPEG-5 Essential Video Coding (EVC)"), + .p.type = AVMEDIA_TYPE_VIDEO, + .p.id = AV_CODEC_ID_EVC, + .init = libxevd_init, + FF_CODEC_RECEIVE_FRAME_CB(libxevd_receive_frame), + .close = libxevd_close, + .priv_data_size = sizeof(XevdContext), + .p.priv_class = &libxevd_class, + .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS | AV_CODEC_CAP_AVOID_PROBING, + .p.profiles = NULL_IF_CONFIG_SMALL(ff_evc_profiles), + .p.wrapper_name = "libxevd", + .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_NOT_INIT_THREADSAFE | FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_SETS_FRAME_PROPS +};