From patchwork Mon Dec 21 06:07:05 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Nuo Mi X-Patchwork-Id: 24600 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id EA59C449D98 for ; Mon, 21 Dec 2020 08:13:53 +0200 (EET) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id C5FD768AD15; Mon, 21 Dec 2020 08:13:53 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pg1-f177.google.com (mail-pg1-f177.google.com [209.85.215.177]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id B2B3568ACDB for ; Mon, 21 Dec 2020 08:13:46 +0200 (EET) Received: by mail-pg1-f177.google.com with SMTP id f17so5735748pge.6 for ; Sun, 20 Dec 2020 22:13:46 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=kPBCleaEYPyALo7gUKoUfXuxWS+ZPrh3e7nw/iV1YWU=; b=pKqNNIeqbRilft0F/CE8PW7WkKjOszySVb/r97iN5NNoSf0XHRp6xxKv7ZoIlF4z0L xkLMOLjZXPbqHB4sYwYw+SS1XAhJuaZdlLSd32r4V6XDVNKjvs8EbUKlRB42JWnXB7hm YezjHz91OmrvGg+5mxKrO8K42P8V8VIQvlOHk0Eti74iMBEtkRkLqgs4nuBqZUGrsSjn 6JddsZU6wg55uFAXg04vCI/0V7uUakJo8aW7xiBFJ6aPxkIWVco8DhVe5XKzplQOTlEW 8ABwLY6dNBgbT6lLpdxuuOReWlNogUCMHRrDMPw62vfpP8J6aj93Z1MktEQFJawJYkov eArA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=kPBCleaEYPyALo7gUKoUfXuxWS+ZPrh3e7nw/iV1YWU=; b=Bd7IZCyrJ/roxw+mtdn2elWsNFxpRamgBitaxAPWMLB0tExhIs3b3fdpgzbrnEJpUB x/w7gx65gl4hm+spJAe4Skyd/DkbzXQwW6F+5KAYkNTgJtL9FB0UuSX5O+arCYvlKCcz Axg8FnIr5ET24cOGaVaBcsgOB/QOGaugjBLAUOrTEK7U+I2sdd8/o8O74h37OFAxZ405 v2Lz+Rso0TiCsM43+a6IaFeF8u5c3IL5ZxpAPO0R/t9gS6vNPg8IDcKEJZGf+zZU7tzF vB9sRT1CEpH1+vPZKT3gM2iZewQYX0NW8qFeaVUq8hR9FSbri9ElHYhtWhrM2VeuTf1A mJtQ== X-Gm-Message-State: AOAM5311qigwgDZhqbMSETeBPU1S/pSrE6s//G6TjN0Kc113Pl1n7quW 9piljLrF9XaSJyVxLbsFL3z5YUed9pqvlg== X-Google-Smtp-Source: ABdhPJz/owpShcYAb2/JbJw71th3ex3O3iNswFn+0wBqLXg8sUAPz5k8K+AeH+HicYQpGQXMUduEUA== X-Received: by 2002:a63:1d59:: with SMTP id d25mr13849017pgm.259.1608530887239; Sun, 20 Dec 2020 22:08:07 -0800 (PST) Received: from Guangxin-PC.localdomain (23.83.245.51.16clouds.com. [23.83.245.51]) by smtp.gmail.com with ESMTPSA id h10sm11485061pfn.213.2020.12.20.22.08.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 20 Dec 2020 22:08:06 -0800 (PST) From: Nuo Mi To: ffmpeg-devel@ffmpeg.org Date: Mon, 21 Dec 2020 14:07:05 +0800 Message-Id: <20201221060710.12230-1-nuomi2021@gmail.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH 1/6] avcodec/h266: add shared header for h266 X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Nuo Mi Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" --- libavcodec/h266.h | 121 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 libavcodec/h266.h diff --git a/libavcodec/h266.h b/libavcodec/h266.h new file mode 100644 index 0000000000..d5793b76fc --- /dev/null +++ b/libavcodec/h266.h @@ -0,0 +1,121 @@ +/* + * H.266 shared code + * + * 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_H266_H +#define AVCODEC_H266_H + +/** + * Table 5 – NAL unit type codes and NAL unit type classes in + * T-REC-H.266-202008 + */ +enum H266NALUnitType { + H266_NAL_TRAIL = 0, + H266_NAL_STSA = 1, + H266_NAL_RADL = 2, + H266_NAL_RASL = 3, + H266_NAL_RSV_VCL_4 = 4, + H266_NAL_RSV_VCL_5 = 5, + H266_NAL_RSV_VCL_6 = 6, + H266_NAL_IDR_W_RADL = 7, + H266_NAL_IDR_N_LP = 8, + H266_NAL_CRA_NUT = 9, + H266_NAL_GDR_NUT = 10, + H266_NAL_RSV_IRAP_11 = 11, + H266_NAL_OPI = 12, + H266_NAL_DCI = 13, + H266_NAL_VPS = 14, + H266_NAL_SPS = 15, + H266_NAL_PPS = 16, + H266_NAL_PREFIX_APS = 17, + H266_NAL_SUFFIX_APS = 18, + H266_NAL_PH = 19, + H266_NAL_AUD = 20, + H266_NAL_EOS_NUT = 21, + H266_NAL_EOB_NUT = 22, + H266_NAL_PREFIX_SEI = 23, + H266_NAL_SUFFIX_SEI = 24, + H266_NAL_FD_NUT = 25, + H266_NAL_RSV_NVCL_26 = 26, + H266_NAL_RSV_NVCL_27 = 27, + H266_NAL_UNSPEC_28 = 28, + H266_NAL_UNSPEC_29 = 29, + H266_NAL_UNSPEC_30 = 30, + H266_NAL_UNSPEC_31 = 31, +}; + +enum H266SliceType { + H266_SLICE_B = 0, + H266_SLICE_P = 1, + H266_SLICE_I = 2, +}; + +enum { + H266_MAX_PLANES = 3, + //7.4.3.3 The value of vps_max_sublayers_minus1 shall be in the range of 0 to 6, inclusive + H266_MAX_SUB_LAYERS = 7, + + // 7.3.2.3: vps_video_parameter_set_id is u(4). + H266_MAX_VPS_COUNT = 16, + // 7.3.2.4: sps_seq_parameter_set_id is in [0, 15]. + H266_MAX_SPS_COUNT = 16, + // 7.3.2.5: pps_pic_parameter_set_id is in [0, 63]. + H266_MAX_PPS_COUNT = 64, + + // A.4.2: MaxDpbSize is bounded above by 16. + H266_MAX_DPB_SIZE = 16, + + //7.4.3.4 sps_num_ref_pic_lists in range [0, 64] + H266_MAX_REF_PIC_LISTS = 64, + + //7.4.3.3 sps_num_points_in_qp_table_minus1[i] in range [0, 36 − sps_qp_table_start_minus26[i]], + //sps_qp_table_start_minus26[i] in range [sps_qp_table_start_minus26[i] −26 − QpBdOffset, 36] + //for 10 bitsQpBdOffset is 12, so sps_num_points_in_qp_table_minus1[i] in range [0, 74] + H266_MAX_POINTS_IN_QP_TABLE = 75, + + // 7.4.6.1: hrd_cpb_cnt_minus1 is in [0, 31]. + H266_MAX_CPB_CNT = 32, + + // A.4.1: in table A.6 the highest level allows a MaxLumaPs of 35 651 584. + H266_MAX_LUMA_PS = 35651584, + // A.4.1: pic_width_in_luma_samples and pic_height_in_luma_samples are + // constrained to be not greater than sqrt(MaxLumaPs * 8). Hence height/ + // width are bounded above by sqrt(8 * 35651584) = 16888.2 samples. + H266_MAX_WIDTH = 16888, + H266_MAX_HEIGHT = 16888, + + // A.4.1: table A.1 allows at most 20 tile rows for any level. + H266_MAX_TILE_ROWS = 20, + // A.4.1: table A.1 allows at most 20 tile columns for any level. + H266_MAX_TILE_COLUMNS = 20, + + // A.4.1 table A.1 allows at most 600 slice for any level. + H266_MAX_SLICES = 600, + + // 7.4.8: in the worst case (tiles_enabled_flag and + // entropy_coding_sync_enabled_flag are both set), entry points can be + // placed at the beginning of every Ctb row in every tile, giving an + // upper bound of (num_tile_columns_minus1 + 1) * PicHeightInCtbsY - 1. + // Only a stream with very high resolution and perverse parameters could + // get near that, though, so set a lower limit here with the maximum + // possible value for 8K video (at most 135 32x32 Ctb rows). + H266_MAX_ENTRY_POINT_OFFSETS = H266_MAX_TILE_COLUMNS * 135, +}; + +#endif /* AVCODEC_H266_H */ From patchwork Mon Dec 21 06:07:06 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nuo Mi X-Patchwork-Id: 24598 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id BFE8444840F for ; Mon, 21 Dec 2020 08:08:19 +0200 (EET) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 92BC768AC28; Mon, 21 Dec 2020 08:08:19 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pf1-f176.google.com (mail-pf1-f176.google.com [209.85.210.176]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 03CFE68ABE8 for ; Mon, 21 Dec 2020 08:08:12 +0200 (EET) Received: by mail-pf1-f176.google.com with SMTP id h186so5892122pfe.0 for ; Sun, 20 Dec 2020 22:08:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=esOugEDHN/tmyNtfDJR3TxYuVubXkDna04UtUFq51ok=; b=Jg0IH/RdT7+N8sqKUWddOCymio3q6sweXfUVN97Sx/VQIxwnU9NwzzFqfKaO9eD20m L3cu3ZT/ug0k7/TrUhg6AWfY9wnGXjZrafYPHAZarSESZRfsI2HqvpBMEmsfdmSVQPt9 6yOG+nLiE7faX8nu2Cg3rzbcrn0h4hNxHdkoZ4qHx8UPkKV9Vjm25EWxwhfTvlYwY5Pi 974ZH2XsCVhCXyUEICHSlCeeBov3nJdHkmKUrX9bfnFOcUKgYXWK4+alangA42h6yo9g /DqjFN4qHEuykABJ0dUYuy6zh7pLPvIMDDRzEKg2LURxl1dUlQapjRGApMxZWpzlibTQ oEXQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=esOugEDHN/tmyNtfDJR3TxYuVubXkDna04UtUFq51ok=; b=RXHLC/EtEPjj4G/JQuBTJmkBSAfKLa/QZgyoJWKA9mWJvKG6ddEFshhL0xuB3MtPlC KCOW9pjBIyZn1vNbhoa1n8xcnowxXYhsNai0UBVfPJtbSe3pPbeM8RJchlr97RFT+6Qr JC80WZRt107poxHDVRdY36Zi1ahFHtvGViy4qX9KyvVz4Pr15Nb2OWyZ8zoc8fvSbzJ+ laFpsZpnsYAjtF/FJaJOG7fb5v3VVwV5Whx2HIlqOJ00wqQh4PWw6zgQOqH/B8mqAYBQ GgAEkOn7X383SkJILfmkqfpxKUTG605f+yBI86+vAfePWXnWXiFqgWOKvXKEeFRjq2dl Vu6A== X-Gm-Message-State: AOAM531qNSBiqTwWBERXyk4WTKnqunEuKbou1ZTm2yRTXypnbodIx72G yk9SaXRCbxg02LRnGvccx11S0+7s7tultw== X-Google-Smtp-Source: ABdhPJwPXyHw4EIpZ8zFGnVXitw/G+wviqXSoNjSJ6O3LMIib/XtFoHulXlMR+csdX0P0J6prGhXHA== X-Received: by 2002:a65:458e:: with SMTP id o14mr8127633pgq.444.1608530891242; Sun, 20 Dec 2020 22:08:11 -0800 (PST) Received: from Guangxin-PC.localdomain (23.83.245.51.16clouds.com. [23.83.245.51]) by smtp.gmail.com with ESMTPSA id h10sm11485061pfn.213.2020.12.20.22.08.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 20 Dec 2020 22:08:10 -0800 (PST) From: Nuo Mi To: ffmpeg-devel@ffmpeg.org Date: Mon, 21 Dec 2020 14:07:06 +0800 Message-Id: <20201221060710.12230-2-nuomi2021@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201221060710.12230-1-nuomi2021@gmail.com> References: <20201221060710.12230-1-nuomi2021@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH 2/6] avcodec: add h266 codec id and profiles X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Nuo Mi Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" --- libavcodec/avcodec.h | 2 ++ libavcodec/codec_desc.c | 8 ++++++++ libavcodec/codec_id.h | 2 ++ libavcodec/profiles.c | 5 +++++ libavcodec/profiles.h | 1 + 5 files changed, 18 insertions(+) diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h index 1d3099d50a..f7ea4d5849 100644 --- a/libavcodec/avcodec.h +++ b/libavcodec/avcodec.h @@ -1961,6 +1961,8 @@ typedef struct AVCodecContext { #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3 #define FF_PROFILE_HEVC_REXT 4 +#define FF_PROFILE_H266_MAIN_10 1 + #define FF_PROFILE_AV1_MAIN 0 #define FF_PROFILE_AV1_HIGH 1 #define FF_PROFILE_AV1_PROFESSIONAL 2 diff --git a/libavcodec/codec_desc.c b/libavcodec/codec_desc.c index 404c460f8f..62fe0f453d 100644 --- a/libavcodec/codec_desc.c +++ b/libavcodec/codec_desc.c @@ -1426,6 +1426,14 @@ static const AVCodecDescriptor codec_descriptors[] = { .long_name = NULL_IF_CONFIG_SMALL("Microsoft Paint (MSP) version 2"), .props = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS, }, + { + .id = AV_CODEC_ID_H266, + .type = AVMEDIA_TYPE_VIDEO, + .name = "h266", + .long_name = NULL_IF_CONFIG_SMALL("H.266 / VVC (Versatile Video Coding)"), + .props = AV_CODEC_PROP_LOSSY | AV_CODEC_PROP_REORDER, + .profiles = NULL_IF_CONFIG_SMALL(ff_h266_profiles), + }, { .id = AV_CODEC_ID_Y41P, .type = AVMEDIA_TYPE_VIDEO, diff --git a/libavcodec/codec_id.h b/libavcodec/codec_id.h index 6133e03bb9..7a8a896bfe 100644 --- a/libavcodec/codec_id.h +++ b/libavcodec/codec_id.h @@ -244,6 +244,8 @@ enum AVCodecID { AV_CODEC_ID_PGX, AV_CODEC_ID_AVS3, AV_CODEC_ID_MSP2, + AV_CODEC_ID_VVC, +#define AV_CODEC_ID_H266 AV_CODEC_ID_VVC AV_CODEC_ID_Y41P = 0x8000, AV_CODEC_ID_AVRP, diff --git a/libavcodec/profiles.c b/libavcodec/profiles.c index e59a3a5c12..710f2c01e2 100644 --- a/libavcodec/profiles.c +++ b/libavcodec/profiles.c @@ -74,6 +74,11 @@ const AVProfile ff_h264_profiles[] = { { FF_PROFILE_UNKNOWN }, }; +const AVProfile ff_h266_profiles[] = { + { FF_PROFILE_H266_MAIN_10, "Main 10" }, + { FF_PROFILE_UNKNOWN }, +}; + const AVProfile ff_hevc_profiles[] = { { FF_PROFILE_HEVC_MAIN, "Main" }, { FF_PROFILE_HEVC_MAIN_10, "Main 10" }, diff --git a/libavcodec/profiles.h b/libavcodec/profiles.h index 6baaba5701..7a353dbf3d 100644 --- a/libavcodec/profiles.h +++ b/libavcodec/profiles.h @@ -60,6 +60,7 @@ extern const AVProfile ff_aac_profiles[]; extern const AVProfile ff_dca_profiles[]; extern const AVProfile ff_dnxhd_profiles[]; extern const AVProfile ff_h264_profiles[]; +extern const AVProfile ff_h266_profiles[]; extern const AVProfile ff_hevc_profiles[]; extern const AVProfile ff_jpeg2000_profiles[]; extern const AVProfile ff_mpeg2_video_profiles[]; From patchwork Mon Dec 21 06:07:07 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nuo Mi X-Patchwork-Id: 24604 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 31AA044B22C for ; Mon, 21 Dec 2020 08:34:48 +0200 (EET) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 0B4B468ACF4; Mon, 21 Dec 2020 08:34:48 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-oi1-f177.google.com (mail-oi1-f177.google.com [209.85.167.177]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 5B0EB68ACF0 for ; Mon, 21 Dec 2020 08:34:41 +0200 (EET) Received: by mail-oi1-f177.google.com with SMTP id f132so10258912oib.12 for ; Sun, 20 Dec 2020 22:34:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=47nJbkcfWZd90tKIdlKjby1QmUqfVOKfoXzsIRN74DU=; b=BC8O3+z3BFYUg4oQLGxRI/K3F9MopP56/VK0aslvfbLf1HL6AEdoowFcQKEF/qEQXO hpxRaZkWLAPP7Z2gaY0XgeYWoqiSxfuKecNB8WAlPRvbGQrbA1JaHLsEvYDXXuiqJDl1 gjDzxFIiB45O9a87ekirjcBJfSh89tH98LN6Q+PiwBmc8KGJ0rOk4z0yH0nAmZX040XV GypTRn+MBxA2hAwYhWgs269zGVuL+E8gtX0X3ruIkAvPWBYdYq39oiMt6saXe0dluKFi Xwp7aT1GIKZ0oIqqr9t7mDvvi+LpBrqbgH63oGfYC01czpCIr8hX9K+v0du2/HcnK1gU h1ag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=47nJbkcfWZd90tKIdlKjby1QmUqfVOKfoXzsIRN74DU=; b=SLSaJA+JIDeJIUJmTjZwYNtH8Pq0awTZMuzH7epJFxfvrNveJ81/FWimifGic+59oy k2SPSDiKCgxzCEuVbfB5LWcjx00OrvAnNCEw5XEYwHuGj9VIhq7jWXU9R4ssV57K5wrR 6FqgDKZxLJfKq5vPgwyWnm8xBM//796YefdJTe724lakBI1A8TeqNR+pKimtst9k2BiJ IWfqD3mm95P3db77K9gr2m6seL+R9xg5AshsaIHwJ6IKsa0FJbPDwl6aIJSjLSNCK8jw mq93D4byuwHXR9P4lcejIn3mrpwi+OWd9RQ/rXmlkD5mqvkFbnraKX6XUM5v/vej93Vr ZKlg== X-Gm-Message-State: AOAM531+hnAHN6+8Epy6/XYfkEGN6VbrUDcZ6CFORu7iLcoidNbOmW7a 47QiZpds/XK3GHsZIm3eT4J/Ks1Dt3ZhoA== X-Google-Smtp-Source: ABdhPJyfLakEJoRiLER7hMgP1Sab7KbI6LARdiOwm2xRJ794zPjodnSy2CSZ6TTnOpFsFppYkQkPlg== X-Received: by 2002:a17:90a:2a42:: with SMTP id d2mr15540437pjg.42.1608530895589; Sun, 20 Dec 2020 22:08:15 -0800 (PST) Received: from Guangxin-PC.localdomain (23.83.245.51.16clouds.com. [23.83.245.51]) by smtp.gmail.com with ESMTPSA id h10sm11485061pfn.213.2020.12.20.22.08.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 20 Dec 2020 22:08:15 -0800 (PST) From: Nuo Mi To: ffmpeg-devel@ffmpeg.org Date: Mon, 21 Dec 2020 14:07:07 +0800 Message-Id: <20201221060710.12230-3-nuomi2021@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201221060710.12230-1-nuomi2021@gmail.com> References: <20201221060710.12230-1-nuomi2021@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH 3/6] avformat: add h266 raw demux X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Nuo Mi Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" --- libavformat/Makefile | 1 + libavformat/allformats.c | 1 + libavformat/h266dec.c | 61 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+) create mode 100644 libavformat/h266dec.c diff --git a/libavformat/Makefile b/libavformat/Makefile index 97d868081b..c685aad66e 100644 --- a/libavformat/Makefile +++ b/libavformat/Makefile @@ -231,6 +231,7 @@ OBJS-$(CONFIG_H263_DEMUXER) += h263dec.o rawdec.o OBJS-$(CONFIG_H263_MUXER) += rawenc.o OBJS-$(CONFIG_H264_DEMUXER) += h264dec.o rawdec.o OBJS-$(CONFIG_H264_MUXER) += rawenc.o +OBJS-$(CONFIG_H266_DEMUXER) += h266dec.o rawdec.o OBJS-$(CONFIG_HASH_MUXER) += hashenc.o OBJS-$(CONFIG_HCA_DEMUXER) += hca.o OBJS-$(CONFIG_HCOM_DEMUXER) += hcom.o pcm.o diff --git a/libavformat/allformats.c b/libavformat/allformats.c index 0e0caaad39..8b64b4eb4b 100644 --- a/libavformat/allformats.c +++ b/libavformat/allformats.c @@ -189,6 +189,7 @@ extern AVInputFormat ff_h263_demuxer; extern AVOutputFormat ff_h263_muxer; extern AVInputFormat ff_h264_demuxer; extern AVOutputFormat ff_h264_muxer; +extern AVInputFormat ff_h266_demuxer; extern AVOutputFormat ff_hash_muxer; extern AVInputFormat ff_hca_demuxer; extern AVInputFormat ff_hcom_demuxer; diff --git a/libavformat/h266dec.c b/libavformat/h266dec.c new file mode 100644 index 0000000000..bf0de5b829 --- /dev/null +++ b/libavformat/h266dec.c @@ -0,0 +1,61 @@ +/* + * RAW H266 video demuxer + * Copyright (c) 2020 Nuo Mi + * + * 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 "libavcodec/h266.h" + +#include "avformat.h" +#include "rawdec.h" + +static int h266_probe(const AVProbeData *p) +{ + uint32_t code = -1; + int sps = 0, pps = 0, irap = 0; + int i; + + for (i = 0; i < p->buf_size - 1; i++) { + code = (code << 8) + p->buf[i]; + if ((code & 0xffffff00) == 0x100) { + uint8_t nal2 = p->buf[i + 1]; + int type = (nal2 & 0xF8) >> 3; + + if (code & 0xc0) // forbidden_zero_bit and nuh_reserved_zero_bit + return 0; + + if ((nal2 & 0x7) == 0) // nuh_temporal_id_plus1 + return 0; + + switch (type) { + case H266_NAL_SPS: sps++; break; + case H266_NAL_PPS: pps++; break; + case H266_NAL_IDR_N_LP: + case H266_NAL_IDR_W_RADL: + case H266_NAL_CRA_NUT: + case H266_NAL_GDR_NUT: irap++; break; + } + } + } + + if (sps && pps && irap) + return AVPROBE_SCORE_EXTENSION + 1; // 1 more than .mpg + return 0; +} + +FF_DEF_RAWVIDEO_DEMUXER(h266, "raw H266 video", h266_probe, "h266,266,vvc", AV_CODEC_ID_H266) From patchwork Mon Dec 21 06:07:08 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nuo Mi X-Patchwork-Id: 24605 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 519C644B37B for ; Mon, 21 Dec 2020 08:35:17 +0200 (EET) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 2C24B68AD50; Mon, 21 Dec 2020 08:35:17 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-vs1-f51.google.com (mail-vs1-f51.google.com [209.85.217.51]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 2EAB468A552 for ; Mon, 21 Dec 2020 08:35:10 +0200 (EET) Received: by mail-vs1-f51.google.com with SMTP id b23so4769073vsp.9 for ; Sun, 20 Dec 2020 22:35:10 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0H08BAQeQHLHjf8F0tjtPNWU6D8ED4aBAfq0PYAft9s=; b=kGECitB1dQk5OGDws9pdTdLW4dmPoW7ACwBdCnJ+PldVBt1SlxgjH0ZvHMSSmkLxSb ToinsL3YpiOUt1OxAbpsobC5HZCLpvyEt+aJvGgiUmhR8j3H3T3+UNLIV6vupJMlHEKZ ZYjkXNFrFmuZBopwQXhhAFcGcdEbyrH2DBp/D6PVXCqBjl7bUwU7LK08d5szio0zD74n c0pFZyo1HEVe7T7iCRqrLUWWwk61HFLC+ly3vEha3hywzxyS89vGV54tL089ZPj8whip OLbHZ/zYWfANJGP3v/7Npb152fIw3ce8rSDmuEEroPMgLFG6Ebywj2bObNEVmJzpa3kD CAdw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0H08BAQeQHLHjf8F0tjtPNWU6D8ED4aBAfq0PYAft9s=; b=e76ay47g1ae+9P8kgvfNR1vphxdH/U3krjD0i1k3BilRKlzK2Jss5gY0u4gfCABzDo SGH0CEo7uRhiks35xgbTIpOsLiugWiQkqVjkErjbkbz0NDssC7eE1Z8yv3wS3Wax3EE/ cVJNLLJtetjDUDqzmRBwugvnYku379szlgeCMsloXTzjDhovdSIkswQ4S6xtUKsawiuK aaeV2rjNBYoNKWqJ/XlIDDvsL2c+6RrReD0jr5c95w0NSUglbc5ylnEa0T35SK1hFTor M+xSds/adRZYhlbMbwd9kpm/u3xzazDdabH70Vvj47wRFsdo7fEDSba8jL1PDVw3+cAY AHFg== X-Gm-Message-State: AOAM532RApt26dUy1eFz0PYHeK7JExg97RUnqIO1f35aLfsMAmaVs0zM hxtEM9Og3HENX0qsD0QQuu5TB1iYfnEmcw== X-Google-Smtp-Source: ABdhPJyNdG1NmwkzEi4h3r0jvjlUrAlm3YfM/ytFDIJ/+QcftilvcOzLU8nKPH4xsnfpqMBubHpUJQ== X-Received: by 2002:a17:902:59dc:b029:da:84c7:f175 with SMTP id d28-20020a17090259dcb02900da84c7f175mr14831978plj.75.1608530901600; Sun, 20 Dec 2020 22:08:21 -0800 (PST) Received: from Guangxin-PC.localdomain (23.83.245.51.16clouds.com. [23.83.245.51]) by smtp.gmail.com with ESMTPSA id h10sm11485061pfn.213.2020.12.20.22.08.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 20 Dec 2020 22:08:21 -0800 (PST) From: Nuo Mi To: ffmpeg-devel@ffmpeg.org Date: Mon, 21 Dec 2020 14:07:08 +0800 Message-Id: <20201221060710.12230-4-nuomi2021@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201221060710.12230-1-nuomi2021@gmail.com> References: <20201221060710.12230-1-nuomi2021@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH 4/6] avcodec: add cbs for h266 X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Nuo Mi Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" --- libavcodec/Makefile | 1 + libavcodec/cbs.c | 6 + libavcodec/cbs_h2645.c | 337 ++++++ libavcodec/cbs_h266.h | 711 ++++++++++++ libavcodec/cbs_h266_syntax_template.c | 1493 +++++++++++++++++++++++++ libavcodec/cbs_internal.h | 1 + 6 files changed, 2549 insertions(+) create mode 100644 libavcodec/cbs_h266.h create mode 100644 libavcodec/cbs_h266_syntax_template.c diff --git a/libavcodec/Makefile b/libavcodec/Makefile index 450781886d..4045c002b7 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -73,6 +73,7 @@ OBJS-$(CONFIG_CBS) += cbs.o OBJS-$(CONFIG_CBS_AV1) += cbs_av1.o OBJS-$(CONFIG_CBS_H264) += cbs_h2645.o h2645_parse.o OBJS-$(CONFIG_CBS_H265) += cbs_h2645.o h2645_parse.o +OBJS-$(CONFIG_CBS_H266) += cbs_h2645.o h2645_parse.o OBJS-$(CONFIG_CBS_JPEG) += cbs_jpeg.o OBJS-$(CONFIG_CBS_MPEG2) += cbs_mpeg2.o OBJS-$(CONFIG_CBS_VP9) += cbs_vp9.o diff --git a/libavcodec/cbs.c b/libavcodec/cbs.c index f98531e131..2b4f3b2bea 100644 --- a/libavcodec/cbs.c +++ b/libavcodec/cbs.c @@ -38,6 +38,9 @@ static const CodedBitstreamType *cbs_type_table[] = { #if CONFIG_CBS_H265 &ff_cbs_type_h265, #endif +#if CONFIG_CBS_H266 + &ff_cbs_type_h266, +#endif #if CONFIG_CBS_JPEG &ff_cbs_type_jpeg, #endif @@ -59,6 +62,9 @@ const enum AVCodecID ff_cbs_all_codec_ids[] = { #if CONFIG_CBS_H265 AV_CODEC_ID_H265, #endif +#if CONFIG_CBS_H266 + AV_CODEC_ID_H266, +#endif #if CONFIG_CBS_JPEG AV_CODEC_ID_MJPEG, #endif diff --git a/libavcodec/cbs_h2645.c b/libavcodec/cbs_h2645.c index 434322492c..0b884c1ed0 100644 --- a/libavcodec/cbs_h2645.c +++ b/libavcodec/cbs_h2645.c @@ -24,11 +24,13 @@ #include "cbs_internal.h" #include "cbs_h264.h" #include "cbs_h265.h" +#include "cbs_h266.h" #include "h264.h" #include "h264_sei.h" #include "h2645_parse.h" #include "hevc.h" #include "hevc_sei.h" +#include "h266.h" static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc, @@ -256,6 +258,7 @@ static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t paylo #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name #define FUNC_H264(rw, name) FUNC_NAME(rw, h264, name) #define FUNC_H265(rw, name) FUNC_NAME(rw, h265, name) +#define FUNC_H266(rw, name) FUNC_NAME(rw, h266, name) #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL) @@ -364,6 +367,10 @@ static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc) #include "cbs_h265_syntax_template.c" #undef FUNC +#define FUNC(name) FUNC_H266(READWRITE, name) +#include "cbs_h266_syntax_template.c" +#undef FUNC + #undef READ #undef READWRITE #undef RWContext @@ -679,6 +686,9 @@ cbs_h2645_replace_ps(4, PPS, pps, pic_parameter_set_id) cbs_h2645_replace_ps(5, VPS, vps, vps_video_parameter_set_id) cbs_h2645_replace_ps(5, SPS, sps, sps_seq_parameter_set_id) cbs_h2645_replace_ps(5, PPS, pps, pps_pic_parameter_set_id) +cbs_h2645_replace_ps(6, VPS, vps, vps_video_parameter_set_id) +cbs_h2645_replace_ps(6, SPS, sps, sps_seq_parameter_set_id) +cbs_h2645_replace_ps(6, PPS, pps, pps_pic_parameter_set_id) static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit) @@ -920,6 +930,117 @@ static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx, return 0; } +static int cbs_h266_read_nal_unit(CodedBitstreamContext *ctx, + CodedBitstreamUnit *unit) +{ + GetBitContext gbc; + int err; + + err = init_get_bits(&gbc, unit->data, 8 * unit->data_size); + if (err < 0) + return err; + + err = ff_cbs_alloc_unit_content2(ctx, unit); + if (err < 0) + return err; + + switch (unit->type) { + case H266_NAL_VPS: + { + H266RawVPS *vps = unit->content; + + err = cbs_h266_read_vps(ctx, &gbc, vps); + if (err < 0) + return err; + + err = cbs_h266_replace_vps(ctx, unit); + if (err < 0) + return err; + } + break; + case H266_NAL_SPS: + { + H266RawSPS *sps = unit->content; + + err = cbs_h266_read_sps(ctx, &gbc, sps); + if (err < 0) + return err; + + err = cbs_h266_replace_sps(ctx, unit); + if (err < 0) + return err; + } + break; + + case H266_NAL_PPS: + { + H266RawPPS *pps = unit->content; + + err = cbs_h266_read_pps(ctx, &gbc, pps); + if (err < 0) + return err; + + err = cbs_h266_replace_pps(ctx, unit); + if (err < 0) + return err; + } + break; + + case H266_NAL_TRAIL: + case H266_NAL_STSA: + case H266_NAL_RADL: + case H266_NAL_IDR_W_RADL: + case H266_NAL_IDR_N_LP: + case H266_NAL_CRA_NUT: + case H266_NAL_GDR_NUT: + { + H266RawSlice *slice = unit->content; + int pos, len; + + err = cbs_h266_read_slice_header(ctx, &gbc, &slice->header); + if (err < 0) + return err; + + if (!cbs_h2645_read_more_rbsp_data(&gbc)) + return AVERROR_INVALIDDATA; + + pos = get_bits_count(&gbc); + len = unit->data_size; + + slice->data_size = len - pos / 8; + slice->data_ref = av_buffer_ref(unit->data_ref); + if (!slice->data_ref) + return AVERROR(ENOMEM); + slice->data = unit->data + pos / 8; + slice->data_bit_start = pos % 8; + } + break; + + case H266_NAL_AUD: + { + err = cbs_h266_read_aud(ctx, &gbc, unit->content); + if (err < 0) + return err; + } + break; + + case H266_NAL_PREFIX_SEI: + case H266_NAL_SUFFIX_SEI: + { + err = cbs_h266_read_sei(ctx, &gbc, unit->content, + unit->type == H266_NAL_PREFIX_SEI); + + if (err < 0) + return err; + } + break; + + default: + return AVERROR(ENOSYS); + } + return 0; +} + static int cbs_h2645_write_slice_data(CodedBitstreamContext *ctx, PutBitContext *pbc, const uint8_t *data, size_t data_size, int data_bit_start) @@ -1207,6 +1328,120 @@ static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx, return 0; } +static int cbs_h266_write_nal_unit(CodedBitstreamContext *ctx, + CodedBitstreamUnit *unit, + PutBitContext *pbc) +{ + printf("TODO: cbs_h266_write_nal_unit"); +#if 0 + int err; + + switch (unit->type) { + case HEVC_NAL_VPS: + { + H265RawVPS *vps = unit->content; + + err = cbs_h265_write_vps(ctx, pbc, vps); + if (err < 0) + return err; + + err = cbs_h265_replace_vps(ctx, unit); + if (err < 0) + return err; + } + break; + + case HEVC_NAL_SPS: + { + H265RawSPS *sps = unit->content; + + err = cbs_h265_write_sps(ctx, pbc, sps); + if (err < 0) + return err; + + err = cbs_h265_replace_sps(ctx, unit); + if (err < 0) + return err; + } + break; + + case HEVC_NAL_PPS: + { + H265RawPPS *pps = unit->content; + + err = cbs_h265_write_pps(ctx, pbc, pps); + if (err < 0) + return err; + + err = cbs_h265_replace_pps(ctx, unit); + if (err < 0) + return err; + } + break; + + case HEVC_NAL_TRAIL_N: + case HEVC_NAL_TRAIL_R: + case HEVC_NAL_TSA_N: + case HEVC_NAL_TSA_R: + case HEVC_NAL_STSA_N: + case HEVC_NAL_STSA_R: + case HEVC_NAL_RADL_N: + case HEVC_NAL_RADL_R: + case HEVC_NAL_RASL_N: + case HEVC_NAL_RASL_R: + case HEVC_NAL_BLA_W_LP: + case HEVC_NAL_BLA_W_RADL: + case HEVC_NAL_BLA_N_LP: + case HEVC_NAL_IDR_W_RADL: + case HEVC_NAL_IDR_N_LP: + case HEVC_NAL_CRA_NUT: + { + H265RawSlice *slice = unit->content; + + err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->header); + if (err < 0) + return err; + + if (slice->data) { + err = cbs_h2645_write_slice_data(ctx, pbc, slice->data, + slice->data_size, + slice->data_bit_start); + if (err < 0) + return err; + } else { + // No slice data - that was just the header. + } + } + break; + + case HEVC_NAL_AUD: + { + err = cbs_h265_write_aud(ctx, pbc, unit->content); + if (err < 0) + return err; + } + break; + + case HEVC_NAL_SEI_PREFIX: + case HEVC_NAL_SEI_SUFFIX: + { + err = cbs_h265_write_sei(ctx, pbc, unit->content, + unit->type == HEVC_NAL_SEI_PREFIX); + + if (err < 0) + return err; + } + break; + + default: + av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for " + "NAL unit type %"PRIu32".\n", unit->type); + return AVERROR_PATCHWELCOME; + } +#endif + return 0; +} + static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag) { @@ -1362,6 +1597,43 @@ static void cbs_h265_close(CodedBitstreamContext *ctx) av_buffer_unref(&h265->pps_ref[i]); } +static void cbs_h266_flush(CodedBitstreamContext *ctx) +{ + CodedBitstreamH266Context *h266 = ctx->priv_data; + + for (int i = 0; i < FF_ARRAY_ELEMS(h266->vps); i++) { + av_buffer_unref(&h266->vps_ref[i]); + h266->vps[i] = NULL; + } + for (int i = 0; i < FF_ARRAY_ELEMS(h266->sps); i++) { + av_buffer_unref(&h266->sps_ref[i]); + h266->sps[i] = NULL; + } + for (int i = 0; i < FF_ARRAY_ELEMS(h266->pps); i++) { + av_buffer_unref(&h266->pps_ref[i]); + h266->pps[i] = NULL; + } + + h266->active_vps = NULL; + h266->active_sps = NULL; + h266->active_pps = NULL; +} + +static void cbs_h266_close(CodedBitstreamContext *ctx) +{ + CodedBitstreamH266Context *h266 = ctx->priv_data; + int i; + + ff_h2645_packet_uninit(&h266->common.read_packet); + + for (i = 0; i < FF_ARRAY_ELEMS(h266->vps); i++) + av_buffer_unref(&h266->vps_ref[i]); + for (i = 0; i < FF_ARRAY_ELEMS(h266->sps); i++) + av_buffer_unref(&h266->sps_ref[i]); + for (i = 0; i < FF_ARRAY_ELEMS(h266->pps); i++) + av_buffer_unref(&h266->pps_ref[i]); +} + static void cbs_h264_free_sei_payload(H264RawSEIPayload *payload) { switch (payload->payload_type) { @@ -1506,6 +1778,55 @@ static const CodedBitstreamUnitTypeDescriptor cbs_h265_unit_types[] = { CBS_UNIT_TYPE_END_OF_LIST }; +static void cbs_h266_free_sei(void *opaque, uint8_t *content) +{ +} + +static const CodedBitstreamUnitTypeDescriptor cbs_h266_unit_types[] = { + CBS_UNIT_TYPE_INTERNAL_REF(H266_NAL_VPS, H266RawVPS, extension_data.data), + CBS_UNIT_TYPE_INTERNAL_REF(H266_NAL_SPS, H266RawSPS, extension_data.data), + CBS_UNIT_TYPE_INTERNAL_REF(H266_NAL_PPS, H266RawPPS, extension_data.data), + + CBS_UNIT_TYPE_POD(H266_NAL_AUD, H266RawAUD), + + { + // Slices of non-IRAP pictures. + .nb_unit_types = CBS_UNIT_TYPE_RANGE, + .unit_type_range_start = H266_NAL_TRAIL, + .unit_type_range_end = H266_NAL_RASL, + + .content_type = CBS_CONTENT_TYPE_INTERNAL_REFS, + .content_size = sizeof(H266RawSlice), + .nb_ref_offsets = 1, + .ref_offsets = { offsetof(H266RawSlice, data) }, + }, + + { + // Slices of IRAP pictures. + .nb_unit_types = CBS_UNIT_TYPE_RANGE, + .unit_type_range_start = H266_NAL_IDR_W_RADL, + .unit_type_range_end = H266_NAL_GDR_NUT, + + .content_type = CBS_CONTENT_TYPE_INTERNAL_REFS, + .content_size = sizeof(H266RawSlice), + .nb_ref_offsets = 1, + .ref_offsets = { offsetof(H266RawSlice, data) }, + }, + + { + .nb_unit_types = 2, + .unit_types = { + H266_NAL_PREFIX_SEI, + H266_NAL_SUFFIX_SEI + }, + .content_type = CBS_CONTENT_TYPE_COMPLEX, + .content_size = sizeof(H266RawSEI), + .content_free = &cbs_h266_free_sei, + }, + + CBS_UNIT_TYPE_END_OF_LIST +}; + const CodedBitstreamType ff_cbs_type_h264 = { .codec_id = AV_CODEC_ID_H264, @@ -1538,6 +1859,22 @@ const CodedBitstreamType ff_cbs_type_h265 = { .close = &cbs_h265_close, }; +const CodedBitstreamType ff_cbs_type_h266 = { + .codec_id = AV_CODEC_ID_VVC, + + .priv_data_size = sizeof(CodedBitstreamH266Context), + + .unit_types = cbs_h266_unit_types, + + .split_fragment = &cbs_h2645_split_fragment, + .read_unit = &cbs_h266_read_nal_unit, + .write_unit = &cbs_h266_write_nal_unit, + .assemble_fragment = &cbs_h2645_assemble_fragment, + + .flush = &cbs_h266_flush, + .close = &cbs_h266_close, +}; + int ff_cbs_h264_add_sei_message(CodedBitstreamFragment *au, H264RawSEIPayload *payload) { diff --git a/libavcodec/cbs_h266.h b/libavcodec/cbs_h266.h new file mode 100644 index 0000000000..91d6ef4f9e --- /dev/null +++ b/libavcodec/cbs_h266.h @@ -0,0 +1,711 @@ +/* + * 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_CBS_H266_H +#define AVCODEC_CBS_H266_H + +#include +#include + +#include "cbs_h2645.h" +#include "h266.h" + +enum { + // This limit is arbitrary - it is sufficient for one message of each + // type plus some repeats, and will therefore easily cover all sane + // streams. However, it is possible to make technically-valid streams + // for which it will fail (for example, by including a large number of + // user-data-unregistered messages). + H266_MAX_SEI_PAYLOADS = 64, +}; + +typedef struct H266RawNALUnitHeader { + uint8_t nuh_layer_id; + uint8_t nal_unit_type; + uint8_t nuh_temporal_id_plus1; +} H266RawNALUnitHeader; + +typedef struct H266GeneralConstraintsInfo { + uint8_t gci_present_flag; +} H266GeneralConstraintsInfo; + +typedef struct H266RawProfileTierLevel { + uint8_t general_profile_idc; + uint8_t general_tier_flag; + uint8_t general_level_idc; + uint8_t ptl_frame_only_constraint_flag; + uint8_t ptl_multilayer_enabled_flag; + H266GeneralConstraintsInfo general_constraints_info; + uint8_t ptl_sublayer_level_present_flag[H266_MAX_SUB_LAYERS - 1]; + uint8_t sublayer_level_idc[H266_MAX_SUB_LAYERS - 1]; + uint8_t ptl_num_sub_profiles; + uint32_t general_sub_profile_idc[256]; +} H266RawProfileTierLevel; + +typedef struct H266RawExtensionData { + uint8_t *data; + AVBufferRef *data_ref; + size_t bit_length; +} H266RawExtensionData; + +typedef struct H266DpbParameters { + uint8_t dpb_max_dec_pic_buffering_minus1[H266_MAX_SUB_LAYERS]; + uint8_t dpb_max_num_reorder_pics[H266_MAX_SUB_LAYERS]; + uint8_t dpb_max_latency_increase_plus1[H266_MAX_SUB_LAYERS]; +} H266DpbParameters; + +typedef struct H266RawVPS { + H266RawNALUnitHeader nal_unit_header; + + uint8_t vps_video_parameter_set_id; + + uint8_t vps_max_layers_minus1; + uint8_t vps_max_sublayers_minus1; + /*TODO add more*/ + H266RawExtensionData extension_data; +} H266RawVPS; +// +typedef struct H266RefPicListStruct { + uint8_t num_ref_entries; + uint8_t ltrp_in_header_flag; + uint8_t inter_layer_ref_pic_flag[H266_MAX_DPB_SIZE + 13]; + uint8_t st_ref_pic_flag[H266_MAX_DPB_SIZE + 13]; + uint8_t abs_delta_poc_st[H266_MAX_DPB_SIZE + 13]; + uint8_t strp_entry_sign_flag[H266_MAX_DPB_SIZE + 13]; + uint8_t rpls_poc_lsb_lt[H266_MAX_DPB_SIZE + 13]; + uint8_t ilrp_idx[H266_MAX_DPB_SIZE + 13]; + + //calculated values; + uint8_t num_ltrp_entries; +} H266RefPicListStruct; + +typedef struct H266RefPicLists { + uint8_t rpl_sps_flag[2]; + uint8_t rpl_idx[2]; + H266RefPicListStruct rpl_ref_list[2]; + uint16_t poc_lsb_lt[2][H266_MAX_DPB_SIZE + 13]; + uint8_t delta_poc_msb_cycle_present_flag[2][H266_MAX_DPB_SIZE + 13]; + uint16_t delta_poc_msb_cycle_lt[2][H266_MAX_DPB_SIZE + 13]; +} H266RefPicLists; + +typedef struct H266RawGeneralTimingHrdParameters { + uint32_t num_units_in_tick; + uint32_t time_scale; + uint8_t general_nal_hrd_params_present_flag; + uint8_t general_vcl_hrd_params_present_flag; + uint8_t general_same_pic_timing_in_all_ols_flag; + uint8_t general_du_hrd_params_present_flag; + uint8_t tick_divisor_minus2; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t cpb_size_du_scale; + uint8_t hrd_cpb_cnt_minus1; +} H266RawGeneralTimingHrdParameters; + +typedef struct H266RawSubLayerHRDParameters { + uint32_t bit_rate_value_minus1[H266_MAX_CPB_CNT]; + uint32_t cpb_size_value_minus1[H266_MAX_CPB_CNT]; + uint32_t cpb_size_du_value_minus1[H266_MAX_CPB_CNT]; + uint32_t bit_rate_du_value_minus1[H266_MAX_CPB_CNT]; + uint8_t cbr_flag[H266_MAX_CPB_CNT]; +} H266RawSubLayerHRDParameters; + +typedef struct H266RawOlsTimingHrdParameters { + uint8_t fixed_pic_rate_general_flag[H266_MAX_SUB_LAYERS]; + uint8_t fixed_pic_rate_within_cvs_flag[H266_MAX_SUB_LAYERS]; + uint16_t elemental_duration_in_tc_minus1[H266_MAX_SUB_LAYERS]; + uint8_t low_delay_hrd_flag[H266_MAX_SUB_LAYERS]; + H266RawSubLayerHRDParameters nal_sub_layer_hrd_parameters[H266_MAX_SUB_LAYERS]; + H266RawSubLayerHRDParameters vcl_sub_layer_hrd_parameters[H266_MAX_SUB_LAYERS]; +} H266RawOlsTimingHrdParameters; + +typedef struct H266RawVUI { + uint8_t vui_progressive_source_flag; + uint8_t vui_interlaced_source_flag; + uint8_t vui_non_packed_constraint_flag; + uint8_t vui_non_projected_constraint_flag; + + uint8_t vui_aspect_ratio_info_present_flag; + uint8_t vui_aspect_ratio_constant_flag; + uint8_t vui_aspect_ratio_idc; + + uint16_t vui_sar_width; + uint16_t vui_sar_height;; + + uint8_t vui_overscan_info_present_flag; + uint8_t vui_overscan_appropriate_flag; + + uint8_t vui_colour_description_present_flag; + uint8_t vui_colour_primaries; + + uint8_t vui_transfer_characteristics; + uint8_t vui_matrix_coeffs; + uint8_t vui_full_range_flag; + + uint8_t vui_chroma_loc_info_present_flag; + uint8_t vui_chroma_sample_loc_type_frame; + uint8_t vui_chroma_sample_loc_type_top_field; + uint8_t vui_chroma_sample_loc_type_bottom_field; +} H266RawVUI; + +typedef struct H266RawSPS { + H266RawNALUnitHeader nal_unit_header; + + uint8_t sps_seq_parameter_set_id; + uint8_t sps_video_parameter_set_id; + uint8_t sps_max_sublayers_minus1; + uint8_t sps_chroma_format_idc; + uint8_t sps_log2_ctu_size_minus5; + uint8_t sps_ptl_dpb_hrd_params_present_flag; + H266RawProfileTierLevel profile_tier_level; + uint8_t sps_gdr_enabled_flag; + uint8_t sps_ref_pic_resampling_enabled_flag; + uint8_t sps_res_change_in_clvs_allowed_flag; + + uint16_t sps_pic_width_max_in_luma_samples; + uint16_t sps_pic_height_max_in_luma_samples; + + uint8_t sps_conformance_window_flag; + uint16_t sps_conf_win_left_offset; + uint16_t sps_conf_win_right_offset; + uint16_t sps_conf_win_top_offset; + uint16_t sps_conf_win_bottom_offset; + + uint8_t sps_subpic_info_present_flag; + uint8_t sps_num_subpics_minus1; + uint8_t sps_independent_subpics_flag; + uint8_t sps_subpic_same_size_flag; + uint8_t sps_subpic_id_len_minus1; + uint8_t sps_subpic_id_mapping_explicitly_signalled_flag; + uint8_t sps_subpic_id_mapping_present_flag; + + + uint8_t sps_bitdepth_minus8; + uint8_t sps_entropy_coding_sync_enabled_flag; + uint8_t sps_entry_point_offsets_present_flag; + + uint8_t sps_log2_max_pic_order_cnt_lsb_minus4; + uint8_t sps_poc_msb_cycle_flag; + uint8_t sps_poc_msb_cycle_len_minus1; + + uint8_t sps_num_extra_ph_bytes; + uint8_t sps_extra_ph_bit_present_flag[16]; + uint8_t num_extra_ph_bits; + + uint8_t sps_num_extra_sh_bytes; + uint8_t sps_extra_sh_bit_present_flag[16]; + uint8_t num_extra_sh_bits; + + uint8_t sps_sublayer_dpb_params_flag; + H266DpbParameters sps_dpb_params; + + uint8_t sps_log2_min_luma_coding_block_size_minus2; + uint8_t sps_partition_constraints_override_enabled_flag; + uint8_t sps_log2_diff_min_qt_min_cb_intra_slice_luma; + uint8_t sps_max_mtt_hierarchy_depth_intra_slice_luma; + uint8_t sps_log2_diff_max_bt_min_qt_intra_slice_luma; + uint8_t sps_log2_diff_max_tt_min_qt_intra_slice_luma; + + uint8_t sps_qtbtt_dual_tree_intra_flag; + uint8_t sps_log2_diff_min_qt_min_cb_intra_slice_chroma; + uint8_t sps_max_mtt_hierarchy_depth_intra_slice_chroma; + uint8_t sps_log2_diff_max_bt_min_qt_intra_slice_chroma; + uint8_t sps_log2_diff_max_tt_min_qt_intra_slice_chroma; + + uint8_t sps_log2_diff_min_qt_min_cb_inter_slice; + uint8_t sps_max_mtt_hierarchy_depth_inter_slice; + uint8_t sps_log2_diff_max_bt_min_qt_inter_slice; + uint8_t sps_log2_diff_max_tt_min_qt_inter_slice; + + uint8_t sps_max_luma_transform_size_64_flag; + + uint8_t sps_transform_skip_enabled_flag; + uint8_t sps_log2_transform_skip_max_size_minus2; + uint8_t sps_bdpcm_enabled_flag; + + uint8_t sps_mts_enabled_flag; + uint8_t sps_explicit_mts_intra_enabled_flag; + uint8_t sps_explicit_mts_inter_enabled_flag; + + uint8_t sps_lfnst_enabled_flag; + + uint8_t sps_joint_cbcr_enabled_flag; + uint8_t sps_same_qp_table_for_chroma_flag; + + int8_t sps_qp_table_start_minus26[H266_MAX_PLANES]; + uint8_t sps_num_points_in_qp_table_minus1[H266_MAX_PLANES]; + uint8_t sps_delta_qp_in_val_minus1[H266_MAX_PLANES][H266_MAX_POINTS_IN_QP_TABLE]; + uint8_t sps_delta_qp_diff_val[H266_MAX_PLANES][H266_MAX_POINTS_IN_QP_TABLE]; + + uint8_t sps_sao_enabled_flag; + uint8_t sps_alf_enabled_flag; + uint8_t sps_ccalf_enabled_flag; + uint8_t sps_lmcs_enabled_flag; + uint8_t sps_weighted_pred_flag; + uint8_t sps_weighted_bipred_flag; + uint8_t sps_long_term_ref_pics_flag; + uint8_t sps_inter_layer_prediction_enabled_flag; + uint8_t sps_idr_rpl_present_flag; + uint8_t sps_rpl1_same_as_rpl0_flag; + + uint8_t sps_num_ref_pic_lists[2]; + H266RefPicListStruct sps_ref_pic_list_struct[2][H266_MAX_REF_PIC_LISTS]; + + uint8_t sps_ref_wraparound_enabled_flag; + uint8_t sps_temporal_mvp_enabled_flag; + uint8_t sps_sbtmvp_enabled_flag; + uint8_t sps_amvr_enabled_flag; + uint8_t sps_bdof_enabled_flag; + uint8_t sps_bdof_control_present_in_ph_flag; + uint8_t sps_smvd_enabled_flag; + uint8_t sps_dmvr_enabled_flag; + uint8_t sps_dmvr_control_present_in_ph_flag; + uint8_t sps_mmvd_enabled_flag; + uint8_t sps_mmvd_fullpel_only_enabled_flag; + uint8_t sps_six_minus_max_num_merge_cand; + uint8_t sps_sbt_enabled_flag; + uint8_t sps_affine_enabled_flag; + uint8_t sps_five_minus_max_num_subblock_merge_cand; + uint8_t sps_6param_affine_enabled_flag; + uint8_t sps_affine_amvr_enabled_flag; + uint8_t sps_affine_prof_enabled_flag; + uint8_t sps_prof_control_present_in_ph_flag; + uint8_t sps_bcw_enabled_flag; + uint8_t sps_ciip_enabled_flag; + uint8_t sps_gpm_enabled_flag; + uint8_t sps_max_num_merge_cand_minus_max_num_gpm_cand; + uint8_t sps_log2_parallel_merge_level_minus2; + uint8_t sps_isp_enabled_flag; + uint8_t sps_mrl_enabled_flag; + uint8_t sps_mip_enabled_flag; + uint8_t sps_cclm_enabled_flag; + uint8_t sps_chroma_horizontal_collocated_flag; + uint8_t sps_chroma_vertical_collocated_flag; + uint8_t sps_palette_enabled_flag; + uint8_t sps_act_enabled_flag; + uint8_t sps_min_qp_prime_ts; + uint8_t sps_ibc_enabled_flag; + uint8_t sps_six_minus_max_num_ibc_merge_cand; + uint8_t sps_ladf_enabled_flag; + uint8_t sps_num_ladf_intervals_minus2; + int8_t sps_ladf_lowest_interval_qp_offset; + int8_t sps_ladf_qp_offset[4]; + uint8_t sps_ladf_delta_threshold_minus1[4]; + + uint8_t sps_explicit_scaling_list_enabled_flag; + uint8_t sps_scaling_matrix_for_lfnst_disabled_flag; + uint8_t sps_scaling_matrix_for_alternative_colour_space_disabled_flag; + uint8_t sps_scaling_matrix_designated_colour_space_flag; + uint8_t sps_dep_quant_enabled_flag; + uint8_t sps_sign_data_hiding_enabled_flag; + + uint8_t sps_virtual_boundaries_enabled_flag; + uint8_t sps_virtual_boundaries_present_flag; + uint8_t sps_num_ver_virtual_boundaries; + uint16_t sps_virtual_boundary_pos_x_minus1[3]; + uint8_t sps_num_hor_virtual_boundaries; + uint16_t sps_virtual_boundary_pos_y_minus1[3]; + + uint8_t sps_timing_hrd_params_present_flag; + uint8_t sps_sublayer_cpb_params_present_flag; + H266RawGeneralTimingHrdParameters sps_general_timing_hrd_parameters; + H266RawOlsTimingHrdParameters sps_ols_timing_hrd_parameters; + + uint8_t sps_field_seq_flag; + uint8_t sps_vui_parameters_present_flag; + uint16_t sps_vui_payload_size_minus1; + H266RawVUI vui; + + uint8_t sps_extension_flag; + + H266RawExtensionData extension_data; + + //caculated values + uint8_t qp_bd_offset; + uint8_t min_cb_log2_size_y; +} H266RawSPS; + +typedef struct H266RawPPS { + H266RawNALUnitHeader nal_unit_header; + + uint8_t pps_pic_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_mixed_nalu_types_in_pic_flag; + uint16_t pps_pic_width_in_luma_samples; + uint16_t pps_pic_height_in_luma_samples; + + uint8_t pps_conformance_window_flag; + uint16_t pps_conf_win_left_offset; + uint16_t pps_conf_win_right_offset; + uint16_t pps_conf_win_top_offset; + uint16_t pps_conf_win_bottom_offset; + + uint8_t pps_scaling_window_explicit_signalling_flag; + int16_t pps_scaling_win_left_offset; + int16_t pps_scaling_win_right_offset; + int16_t pps_scaling_win_top_offset; + int16_t pps_scaling_win_bottom_offset; + + uint8_t pps_output_flag_present_flag; + uint8_t pps_no_pic_partition_flag; + uint8_t pps_subpic_id_mapping_present_flag; + /* TODO: pps_subpic_id[ i ] */ + uint8_t pps_log2_ctu_size_minus5; + uint8_t pps_num_exp_tile_columns_minus1; + uint8_t pps_num_exp_tile_rows_minus1; + uint16_t pps_tile_column_width_minus1[H266_MAX_TILE_COLUMNS]; + uint16_t pps_tile_row_height_minus1[H266_MAX_TILE_ROWS]; + + uint8_t pps_loop_filter_across_tiles_enabled_flag; + uint8_t pps_rect_slice_flag; + uint8_t pps_single_slice_per_subpic_flag; + uint16_t pps_num_slices_in_pic_minus1; + uint8_t pps_tile_idx_delta_present_flag; + + /* TODO: + uint16_t pps_slice_width_in_tiles_minus1[H266_MAX_TILE_COLUMNS]; + uint16_t pps_slice_height_in_tiles_minus1[H266_MAX_TILE_ROWS]; + */ + uint8_t pps_loop_filter_across_slices_enabled_flag; + uint8_t pps_cabac_init_present_flag; + uint8_t pps_num_ref_idx_default_active_minus1[2]; + uint8_t pps_rpl1_idx_present_flag; + uint8_t pps_weighted_pred_flag; + uint8_t pps_weighted_bipred_flag; + uint8_t pps_ref_wraparound_enabled_flag; + uint8_t pps_pic_width_minus_wraparound_offset; + int8_t pps_init_qp_minus26; + uint8_t pps_cu_qp_delta_enabled_flag; + uint8_t pps_chroma_tool_offsets_present_flag; + uint8_t pps_cb_qp_offset; + uint8_t pps_cr_qp_offset; + uint8_t pps_joint_cbcr_qp_offset_present_flag; + uint8_t pps_joint_cbcr_qp_offset_value; + uint8_t pps_slice_chroma_qp_offsets_present_flag; + uint8_t pps_cu_chroma_qp_offset_list_enabled_flag; + uint8_t pps_chroma_qp_offset_list_len_minus1; + uint8_t pps_cb_qp_offset_list[6]; + uint8_t pps_cr_qp_offset_list[6]; + uint8_t pps_joint_cbcr_qp_offset_list[6]; + uint8_t pps_deblocking_filter_control_present_flag; + uint8_t pps_deblocking_filter_override_enabled_flag; + uint8_t pps_deblocking_filter_disabled_flag; + uint8_t pps_dbf_info_in_ph_flag; + + uint8_t pps_luma_beta_offset_div2; + uint8_t pps_luma_tc_offset_div2; + uint8_t pps_cb_beta_offset_div2; + uint8_t pps_cb_tc_offset_div2; + uint8_t pps_cr_beta_offset_div2; + uint8_t pps_cr_tc_offset_div2; + + uint8_t pps_rpl_info_in_ph_flag; + uint8_t pps_sao_info_in_ph_flag; + uint8_t pps_alf_info_in_ph_flag; + uint8_t pps_wp_info_in_ph_flag; + uint8_t pps_qp_delta_info_in_ph_flag; + + uint8_t pps_picture_header_extension_present_flag; + uint8_t pps_slice_header_extension_present_flag; + uint8_t pps_extension_flag; + H266RawExtensionData extension_data; + + //calculated value; + uint16_t num_tile_columns; + uint16_t num_tile_rows; + uint16_t num_tiles_in_pic; +} H266RawPPS; + +typedef struct H266RawAUD { + H266RawNALUnitHeader nal_unit_header; + uint8_t aud_irap_or_gdr_flag; + uint8_t aud_pic_type; +} H266RawAUD; + +typedef struct H266RawPH { + uint8_t ph_gdr_or_irap_pic_flag; + uint8_t ph_non_ref_pic_flag; + uint8_t ph_gdr_pic_flag; + uint8_t ph_inter_slice_allowed_flag; + uint8_t ph_intra_slice_allowed_flag; + uint8_t ph_pic_parameter_set_id; + uint16_t ph_pic_order_cnt_lsb; + uint8_t ph_recovery_poc_cnt; + uint8_t ph_extra_bit[16]; + uint8_t ph_poc_msb_cycle_present_flag; + uint8_t ph_poc_msb_cycle_val; + uint8_t ph_alf_enabled_flag; + uint8_t ph_num_alf_aps_ids_luma; + //uint8_t ph_alf_aps_id_luma[i] + uint8_t ph_alf_cb_enabled_flag; + uint8_t ph_alf_cr_enabled_flag; + uint8_t ph_alf_aps_id_chroma; + uint8_t ph_alf_cc_cb_enabled_flag; + uint8_t ph_alf_cc_cb_aps_id; + uint8_t ph_alf_cc_cr_enabled_flag; + uint8_t ph_alf_cc_cr_aps_id; + uint8_t ph_lmcs_enabled_flag; + uint8_t ph_lmcs_aps_id; + uint8_t ph_chroma_residual_scale_flag; + uint8_t ph_explicit_scaling_list_enabled_flag; + uint8_t ph_scaling_list_aps_id; + uint8_t ph_virtual_boundaries_present_flag; + uint8_t ph_num_ver_virtual_boundaries; + //ph_virtual_boundary_pos_x_minus1[ i ] + //ph_num_hor_virtual_boundaries + //ph_virtual_boundary_pos_y_minus1[ i ] + + uint8_t ph_pic_output_flag; + H266RefPicLists ph_ref_pic_lists; + + uint8_t ph_partition_constraints_override_flag; + + uint8_t ph_log2_diff_min_qt_min_cb_intra_slice_luma; + uint8_t ph_max_mtt_hierarchy_depth_intra_slice_luma; + uint8_t ph_log2_diff_max_bt_min_qt_intra_slice_luma; + uint8_t ph_log2_diff_max_tt_min_qt_intra_slice_luma; + uint8_t ph_log2_diff_min_qt_min_cb_intra_slice_chroma; + + uint8_t ph_max_mtt_hierarchy_depth_intra_slice_chroma; + uint8_t ph_log2_diff_max_bt_min_qt_intra_slice_chroma; + uint8_t ph_log2_diff_max_tt_min_qt_intra_slice_chroma; + + uint8_t ph_cu_qp_delta_subdiv_intra_slice; + uint8_t ph_cu_chroma_qp_offset_subdiv_intra_slice; + + uint8_t ph_log2_diff_min_qt_min_cb_inter_slice; + uint8_t ph_max_mtt_hierarchy_depth_inter_slice; + uint8_t ph_log2_diff_max_bt_min_qt_inter_slice; + uint8_t ph_log2_diff_max_tt_min_qt_inter_slice; + uint8_t ph_cu_qp_delta_subdiv_inter_slice; + uint8_t ph_cu_chroma_qp_offset_subdiv_inter_slice; + + uint8_t ph_temporal_mvp_enabled_flag; + uint8_t ph_collocated_from_l0_flag; + uint8_t ph_collocated_ref_idx; + uint8_t ph_mmvd_fullpel_only_flag; + uint8_t ph_mvd_l1_zero_flag; + uint8_t ph_bdof_disabled_flag; + uint8_t ph_dmvr_disabled_flag; + uint8_t ph_prof_disabled_flag; + //pred_weight_table( ); + uint8_t ph_qp_delta; + uint8_t ph_joint_cbcr_sign_flag; + uint8_t ph_sao_luma_enabled_flag; + uint8_t ph_sao_chroma_enabled_flag; + uint8_t ph_deblocking_params_present_flag; + uint8_t ph_deblocking_filter_disabled_flag; + uint8_t ph_luma_beta_offset_div2; + uint8_t ph_luma_tc_offset_div2; + uint8_t ph_cb_beta_offset_div2; + uint8_t ph_cb_tc_offset_div2; + uint8_t ph_cr_beta_offset_div2; + uint8_t ph_cr_tc_offset_div2; + uint8_t ph_extension_length; +} H266RawPH; + +typedef struct H266RawSliceHeader { + H266RawNALUnitHeader nal_unit_header; + uint8_t sh_picture_header_in_slice_header_flag; + H266RawPH sh_picture_header; + + uint16_t sh_subpic_id; + uint16_t sh_slice_address; + uint8_t sh_extra_bit[16]; + uint8_t sh_num_tiles_in_slice_minus1; + uint8_t sh_slice_type; + uint8_t sh_no_output_of_prior_pics_flag; + + uint8_t sh_alf_enabled_flag; + uint8_t sh_num_alf_aps_ids_luma; + uint8_t sh_alf_aps_id_luma[8]; + uint8_t sh_alf_cb_enabled_flag; + uint8_t sh_alf_cr_enabled_flag; + uint8_t sh_alf_aps_id_chroma; + uint8_t sh_alf_cc_cb_enabled_flag; + uint8_t sh_alf_cc_cb_aps_id; + uint8_t sh_alf_cc_cr_enabled_flag; + uint8_t sh_alf_cc_cr_aps_id; + + uint8_t sh_lmcs_used_flag; + uint8_t sh_explicit_scaling_list_used_flag; + + H266RefPicLists sh_ref_pic_lists; + + uint8_t sh_num_ref_idx_active_override_flag; + uint8_t sh_num_ref_idx_active_minus1[2]; + uint8_t sh_cabac_init_flag; + uint8_t sh_collocated_from_l0_flag; + uint8_t sh_collocated_ref_idx; + + int8_t sh_qp_delta; + int8_t sh_cb_qp_offset; + int8_t sh_cr_qp_offset; + int8_t sh_joint_cbcr_qp_offset; + uint8_t sh_cu_chroma_qp_offset_enabled_flag; + + uint8_t sh_sao_luma_used_flag; + uint8_t sh_sao_chroma_used_flag; + + uint8_t sh_deblocking_params_present_flag; + uint8_t sh_deblocking_filter_disabled_flag; + int8_t sh_luma_beta_offset_div2; + int8_t sh_luma_tc_offset_div2; + int8_t sh_cb_beta_offset_div2; + int8_t sh_cb_tc_offset_div2; + int8_t sh_cr_beta_offset_div2; + int8_t sh_cr_tc_offset_div2; + uint8_t sh_dep_quant_used_flag; + + uint8_t sh_sign_data_hiding_used_flag; + uint8_t sh_ts_residual_coding_disabled_flag; + uint16_t sh_slice_header_extension_length; + + uint8_t sh_entry_offset_len_minus1; + uint32_t sh_entry_point_offset_minus1[H266_MAX_ENTRY_POINT_OFFSETS]; + + //calclatecd values; + uint16_t num_entry_point_offsets; +} H266RawSliceHeader; + + +typedef struct H266RawSlice { + H266RawSliceHeader header; + + uint8_t *data; + AVBufferRef *data_ref; + size_t data_size; + int data_bit_start; +} H266RawSlice; + + +typedef struct H266RawSEIBufferingPeriod { + uint8_t bp_seq_parameter_set_id; +} H266RawSEIBufferingPeriod; + +typedef struct H266RawSEIPicTiming { +} H266RawSEIPicTiming; + +typedef struct H266RawSEIPanScanRect { +} H266RawSEIPanScanRect; + +typedef struct H266RawSEIUserDataRegistered { + +} H266RawSEIUserDataRegistered; + +typedef struct H266RawSEIUserDataUnregistered { +} H266RawSEIUserDataUnregistered; + +typedef struct H266RawSEIRecoveryPoint { +} H266RawSEIRecoveryPoint; + +typedef struct H266RawSEIDisplayOrientation { +} H266RawSEIDisplayOrientation; + +typedef struct H266RawSEIActiveParameterSets { +} H266RawSEIActiveParameterSets; + +typedef struct H266RawSEIDecodedPictureHash { +} H266RawSEIDecodedPictureHash; + +typedef struct H266RawSEITimeCode { +} H266RawSEITimeCode; + +typedef struct H266RawSEIMasteringDisplayColourVolume { +} H266RawSEIMasteringDisplayColourVolume; + +typedef struct H266RawSEIContentLightLevelInfo { + uint16_t max_content_light_level; + uint16_t max_pic_average_light_level; +} H266RawSEIContentLightLevelInfo; + +typedef struct H266RawSEIAlternativeTransferCharacteristics { + uint8_t preferred_transfer_characteristics; +} H266RawSEIAlternativeTransferCharacteristics; + +typedef struct H266RawSEIAlphaChannelInfo { + uint8_t alpha_channel_cancel_flag; + uint8_t alpha_channel_use_idc; + uint8_t alpha_channel_bit_depth_minus8; + uint16_t alpha_transparent_value; + uint16_t alpha_opaque_value; + uint8_t alpha_channel_incr_flag; + uint8_t alpha_channel_clip_flag; + uint8_t alpha_channel_clip_type_flag; +} H266RawSEIAlphaChannelInfo; + +typedef struct H266RawSEIPayload { + uint32_t payload_type; + uint32_t payload_size; + union { + H266RawSEIBufferingPeriod buffering_period; + H266RawSEIPicTiming pic_timing; + H266RawSEIPanScanRect pan_scan_rect; + H266RawSEIUserDataRegistered user_data_registered; + H266RawSEIUserDataUnregistered user_data_unregistered; + H266RawSEIRecoveryPoint recovery_point; + H266RawSEIDisplayOrientation display_orientation; + H266RawSEIActiveParameterSets active_parameter_sets; + H266RawSEIDecodedPictureHash decoded_picture_hash; + H266RawSEITimeCode time_code; + H266RawSEIMasteringDisplayColourVolume mastering_display; + H266RawSEIContentLightLevelInfo content_light_level; + H266RawSEIAlternativeTransferCharacteristics + alternative_transfer_characteristics; + H266RawSEIAlphaChannelInfo alpha_channel_info; + struct { + uint8_t *data; + AVBufferRef *data_ref; + size_t data_length; + } other; + } payload; + H266RawExtensionData extension_data; +} H266RawSEIPayload; + +typedef struct H266RawSEI { + H266RawNALUnitHeader nal_unit_header; + + H266RawSEIPayload payload[H266_MAX_SEI_PAYLOADS]; + uint8_t payload_count; +} H266RawSEI; + +typedef struct CodedBitstreamH266Context { + // Reader/writer context in common with the H.264 implementation. + CodedBitstreamH2645Context common; + + // All currently available parameter sets. These are updated when + // any parameter set NAL unit is read/written with this context. + AVBufferRef *vps_ref[H266_MAX_VPS_COUNT]; + AVBufferRef *sps_ref[H266_MAX_SPS_COUNT]; + AVBufferRef *pps_ref[H266_MAX_PPS_COUNT]; + H266RawVPS *vps[H266_MAX_VPS_COUNT]; + H266RawSPS *sps[H266_MAX_SPS_COUNT]; + H266RawPPS *pps[H266_MAX_PPS_COUNT]; + H266RawPH ph; + + // The currently active parameter sets. These are updated when any + // NAL unit refers to the relevant parameter set. These pointers + // must also be present in the arrays above. + const H266RawVPS *active_vps; + const H266RawSPS *active_sps; + const H266RawPPS *active_pps; + const H266RawPH *active_ph; +} CodedBitstreamH266Context; + + +#endif /* AVCODEC_CBS_H266_H */ diff --git a/libavcodec/cbs_h266_syntax_template.c b/libavcodec/cbs_h266_syntax_template.c new file mode 100644 index 0000000000..19fb1f8c27 --- /dev/null +++ b/libavcodec/cbs_h266_syntax_template.c @@ -0,0 +1,1493 @@ +/* + * 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 + */ + +static int FUNC(rbsp_trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw) +{ + int err; + + fixed(1, rbsp_stop_one_bit, 1); + while (byte_alignment(rw) != 0) + fixed(1, rbsp_alignment_zero_bit, 0); + return 0; +} + +static int FUNC(nal_unit_header)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawNALUnitHeader *current, + int expected_nal_unit_type) +{ + int err; + + fixed(1, forbidden_zero_bit, 0); + fixed(1, nuh_reserved_zero_bit, 0); + + u(6, nuh_layer_id, 0, 55); + + if (expected_nal_unit_type >= 0) + u(5, nal_unit_type, expected_nal_unit_type, + expected_nal_unit_type); + else + ub(5, nal_unit_type); + + u(3, nuh_temporal_id_plus1, 1, 7); + return 0; +} + +static int FUNC(byte_alignment)(CodedBitstreamContext *ctx, RWContext *rw) +{ + int err; + + fixed(1, alignment_bit_equal_to_one, 1); + while (byte_alignment(rw) != 0) + fixed(1, alignment_bit_equal_to_zero, 0); + return 0; +} + +static int FUNC(general_constraints_info)(CodedBitstreamContext *ctx, RWContext *rw, + H266GeneralConstraintsInfo *current) +{ + int err; + + flag(gci_present_flag); + if (current->gci_present_flag) { + return AVERROR_PATCHWELCOME; + } + while (byte_alignment(rw)) + fixed(1, bit_equal_to_zero, 0); + return 0; +} + +static int FUNC(profile_tier_level)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawProfileTierLevel *current, + int profile_tire_present_flag, + int max_num_sub_layers_minus1) +{ + int err, i; + + if (profile_tire_present_flag) { + ub(7, general_profile_idc); + flag(general_tier_flag); + } + ub(8, general_level_idc); + flag(ptl_frame_only_constraint_flag); + flag(ptl_multilayer_enabled_flag); + if (profile_tire_present_flag) { + CHECK(FUNC(general_constraints_info)(ctx, rw, ¤t->general_constraints_info)); + } + for( i = max_num_sub_layers_minus1 - 1; i >= 0; i--) + flags(ptl_sublayer_level_present_flag[i], 1, i); + while (byte_alignment(rw)) + fixed(1, ptl_reserved_zero_bit, 0); + for( i = max_num_sub_layers_minus1 - 1; i >= 0; i-- ) + if(current->ptl_sublayer_level_present_flag[i]) + ubs(8, sublayer_level_idc[i], 1, i); + if (profile_tire_present_flag) { + ub(8, ptl_num_sub_profiles); + for( i = 0; i < current->ptl_num_sub_profiles; i++ ) + ubs(32, general_sub_profile_idc[i], 1, i); + } + return 0; +} + +static int FUNC(vui_parameters)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawVUI *current) +{ + int err; + + flag(vui_progressive_source_flag); + flag(vui_interlaced_source_flag); + flag(vui_non_packed_constraint_flag); + flag(vui_non_projected_constraint_flag); + flag(vui_aspect_ratio_info_present_flag); + if(current->vui_aspect_ratio_info_present_flag ) { + flag(vui_aspect_ratio_constant_flag); + ub(8, vui_aspect_ratio_idc); + if(current->vui_aspect_ratio_idc == 255 ) { + ub(16, vui_sar_width); + ub(16, vui_sar_height); + } + } else { + infer(vui_aspect_ratio_constant_flag, 0); + infer(vui_aspect_ratio_idc, 0); + + } + flag(vui_overscan_info_present_flag); + if (current->vui_overscan_info_present_flag) + flag(vui_overscan_appropriate_flag); + flag(vui_colour_description_present_flag); + if(current->vui_colour_description_present_flag ) { + ub(8, vui_colour_primaries); + ub(8, vui_transfer_characteristics); + ub(8, vui_matrix_coeffs); + flag(vui_full_range_flag); + } else { + infer(vui_colour_primaries, 2); + infer(vui_transfer_characteristics, 2); + infer(vui_matrix_coeffs, 2); + infer(vui_full_range_flag, 0); + } + flag(vui_chroma_loc_info_present_flag); + if(current->vui_chroma_loc_info_present_flag ) { + if(current->vui_progressive_source_flag && !current->vui_interlaced_source_flag) { + ue(vui_chroma_sample_loc_type_frame, 0, 6); + } + else { + ue(vui_chroma_sample_loc_type_top_field, 0, 6); + ue(vui_chroma_sample_loc_type_bottom_field, 0, 6); + } + } + + return 0; +} + +static int FUNC(vui_payload)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawVUI *current, uint16_t vui_payload_size) +{ + int err; + +#ifdef READ + int start_pos, end_pos, left; + + start_pos = get_bits_count(rw); + CHECK(FUNC(vui_parameters)(ctx, rw, current)); + end_pos = get_bits_count(rw); + + left = vui_payload_size * 8 - (end_pos - start_pos); + skip_bits(rw, left); +#else + return AVERROR_PATCHWELCOME; +#endif + + + return 0; +} + +static int FUNC(vps)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawVPS *current) +{ + HEADER("Video Parameter Set"); + av_log(ctx->log_ctx, AV_LOG_ERROR, "vps is not supported yet\n"); + + return AVERROR_PATCHWELCOME; +} + +static int FUNC(dpb_parameters)(CodedBitstreamContext *ctx, RWContext *rw, + H266DpbParameters *current, uint8_t max_sublayers_minus1, uint8_t sublayer_info_flag) +{ + int err, i; + for(i = ( sublayer_info_flag ? 0 : max_sublayers_minus1 ); i <= max_sublayers_minus1; i++ ) { + ues(dpb_max_dec_pic_buffering_minus1[i], 0, H266_MAX_DPB_SIZE - 1, 1, i); + ues(dpb_max_num_reorder_pics[i], 0, current->dpb_max_dec_pic_buffering_minus1[i], 1, i); + ues(dpb_max_latency_increase_plus1[i], 0, UINT32_MAX - 1, 1, i); + } + return 0; +} + +static int FUNC(ref_pic_list_struct)(CodedBitstreamContext *ctx, RWContext *rw, + H266RefPicListStruct *current, uint8_t list_idx, uint8_t rpls_idx, + const H266RawSPS* const sps) +{ + + int err, i, j; + ue(num_ref_entries, 0, H266_MAX_DPB_SIZE + 13); + if(sps->sps_long_term_ref_pics_flag && rpls_idx < sps->sps_num_ref_pic_lists[list_idx] && current->num_ref_entries > 0) + flag(ltrp_in_header_flag); + if (sps->sps_long_term_ref_pics_flag && rpls_idx == sps->sps_num_ref_pic_lists[list_idx]) + infer(ltrp_in_header_flag, 1); + current->num_ltrp_entries = 0; + for( i = 0, j = 0; i < current->num_ref_entries; i++) { + if(sps->sps_inter_layer_prediction_enabled_flag ) + flags(inter_layer_ref_pic_flag[i], 1, i); + else + infer(inter_layer_ref_pic_flag[i], 0); + + if(!current->inter_layer_ref_pic_flag[i] ) { + if(sps->sps_long_term_ref_pics_flag ) + flags(st_ref_pic_flag[i], 1, i); + else + infer(st_ref_pic_flag[i], 1); + if(current->st_ref_pic_flag[i]) { + int abs_delta_poc_st; + ues(abs_delta_poc_st[i], 0, MAX_UINT_BITS(15), 1, i); + if( (sps->sps_weighted_pred_flag || sps->sps_weighted_bipred_flag ) && i != 0 ) + abs_delta_poc_st = current->abs_delta_poc_st[i]; + else + abs_delta_poc_st = current->abs_delta_poc_st[i] + 1; + if (abs_delta_poc_st > 0) + flags(strp_entry_sign_flag[i], 1, i); + } else { + if(!current->ltrp_in_header_flag) { + ubs(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, rpls_poc_lsb_lt[j], 1, j); + j++; + } + current->num_ltrp_entries++; + } + } else { + //todo: check range when vps parser is ready. + ues(ilrp_idx[i], 0, MAX_UINT_BITS(8), 1, i); + } + + } + return 0; +} + +static int FUNC(ref_pic_lists)(CodedBitstreamContext *ctx, RWContext *rw, + H266RefPicLists *current) +{ + CodedBitstreamH266Context *h266 = ctx->priv_data; + const H266RawSPS *sps = h266->active_sps; + const H266RawPPS *pps = h266->active_pps; + const H266RefPicListStruct* ref_list; + int err, i, j; + for (i = 0; i < 2; i++) { + if (sps->sps_num_ref_pic_lists[i] > 0 && (i == 0 || (i == 1 && pps->pps_rpl1_idx_present_flag))) { + flags(rpl_sps_flag[i], 1, i); + } else { + if (!sps->sps_num_ref_pic_lists[i]) { + infer(rpl_sps_flag[i], 0); + } else { + if (!pps->pps_rpl1_idx_present_flag && i == 1) + infer(rpl_sps_flag[1], current->rpl_sps_flag[0]); + } + } + if (current->rpl_sps_flag[i]) { + if(sps->sps_num_ref_pic_lists[i] > 1 && (i == 0 || ( i == 1 && pps->pps_rpl1_idx_present_flag))) { + us(ceil(log2(sps->sps_num_ref_pic_lists[i])), rpl_idx[i], 0, sps->sps_num_ref_pic_lists[i] - 1, 1, i); + } else if (sps->sps_num_ref_pic_lists[i] == 1) { + infer(rpl_idx[i], 0); + } else if (i == 1 && !pps->pps_rpl1_idx_present_flag){ + infer(rpl_idx[1], current->rpl_idx[0]); + } else { + //how to handle this? or never happpend? + av_log(ctx->log_ctx, AV_LOG_ERROR, "can't infer the rpl_idx[i]\n"); + return AVERROR_PATCHWELCOME; + } + memcpy(¤t->rpl_ref_list[i], &sps->sps_ref_pic_list_struct[i][current->rpl_idx[i]], sizeof(current->rpl_ref_list[i])); + } else { + CHECK(FUNC(ref_pic_list_struct)(ctx, rw, ¤t->rpl_ref_list[i], i, sps->sps_num_ref_pic_lists[i], sps)); + } + ref_list = ¤t->rpl_ref_list[i]; + + for( j = 0; j < ref_list->num_ltrp_entries; j++ ) { + if(ref_list->ltrp_in_header_flag) + ubs(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, poc_lsb_lt[i][j], 2, i, j); + flags(delta_poc_msb_cycle_present_flag[i][j], 2, i, j); + if(current->delta_poc_msb_cycle_present_flag[i][j]) + ues(delta_poc_msb_cycle_lt[i][j], 0, MAX_UINT_BITS(32 - sps->sps_log2_max_pic_order_cnt_lsb_minus4 - 4), 2, i, j); + } + } + return 0; + +} + +static int FUNC(general_timing_hrd_parameters)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawGeneralTimingHrdParameters *current) +{ + int err; + ub(32, num_units_in_tick); + u(32, time_scale, 1, MAX_UINT_BITS(32)); + flag(general_nal_hrd_params_present_flag); + flag(general_vcl_hrd_params_present_flag); + + if(current->general_nal_hrd_params_present_flag || current->general_vcl_hrd_params_present_flag ) { + flag(general_same_pic_timing_in_all_ols_flag); + flag(general_du_hrd_params_present_flag); + if(current->general_du_hrd_params_present_flag) + ub(8, tick_divisor_minus2); + ub(4, bit_rate_scale); + ub(4, cpb_size_scale); + if(current->general_du_hrd_params_present_flag) + ub(4, cpb_size_du_scale); + ue(hrd_cpb_cnt_minus1, 0, 31); + } else { + //infer general_same_pic_timing_in_all_ols_flag? + infer(general_du_hrd_params_present_flag, 0); + } + return 0; +} + +static int FUNC(sublayer_hrd_parameters)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawSubLayerHRDParameters* current, int sublayer_id, const H266RawGeneralTimingHrdParameters* const general) +{ + int err, i; + for (i = 0; i <= general->hrd_cpb_cnt_minus1; i++) { + ues(bit_rate_value_minus1[i], 0, UINT32_MAX - 1, 2, sublayer_id, i); + ues(cpb_size_value_minus1[i], 0, UINT32_MAX - 1, 2, sublayer_id, i); + if (general->general_du_hrd_params_present_flag) { + ues(cpb_size_du_value_minus1[i], 0, UINT32_MAX - 1, 2, sublayer_id, i); + ues(bit_rate_du_value_minus1[i], 0, UINT32_MAX - 1, 2, sublayer_id, i); + } + flags(cbr_flag[i], 2, sublayer_id, i); + } + return 0; +} + +static int FUNC(ols_timing_hrd_parameters)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawOlsTimingHrdParameters* current, uint8_t first_sublayer, uint8_t max_sublayers_minus1, const H266RawGeneralTimingHrdParameters * general) +{ + int err, i; + for( i = first_sublayer; i <= max_sublayers_minus1; i++ ) { + flags(fixed_pic_rate_general_flag[i], 1, i); + if (!current->fixed_pic_rate_general_flag[i]) + flags(fixed_pic_rate_within_cvs_flag[i], 1, i); + else + infer(fixed_pic_rate_within_cvs_flag[i], 1); + if(current->fixed_pic_rate_within_cvs_flag[i]) { + ues(elemental_duration_in_tc_minus1[i], 0, 2047, 1, i); + infer(low_delay_hrd_flag[i], 0); + } else if((general->general_nal_hrd_params_present_flag || general->general_vcl_hrd_params_present_flag) + && general->hrd_cpb_cnt_minus1 == 0 ) { + flags(low_delay_hrd_flag[i], 1, i); + } else { + infer(low_delay_hrd_flag[i], 0); + } + if(general->general_nal_hrd_params_present_flag) + CHECK(FUNC(sublayer_hrd_parameters)(ctx, rw, ¤t->nal_sub_layer_hrd_parameters[i], i, general)); + if(general->general_vcl_hrd_params_present_flag) + CHECK(FUNC(sublayer_hrd_parameters)(ctx, rw, ¤t->nal_sub_layer_hrd_parameters[i], i, general)); + } + return 0; +} + +static uint8_t get_extra_bits(const uint8_t* present_flags, uint8_t extra_bytes) +{ + uint8_t num_extra_bits = 0; + int i; + for (i = 0; i < extra_bytes * 8; i++) { + if (present_flags[i]) + num_extra_bits++; + } + return num_extra_bits; +} + +static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawSPS *current) +{ + CodedBitstreamH266Context *h266 = ctx->priv_data; + const H266RawVPS *vps; + int err, i, j; + unsigned int ctb_log2_size_y, min_cb_log2_size_y, + min_qt_log2_size_intra_y, min_qt_log2_size_inter_y, + ctb_size_y, max_num_merge_cand; + + HEADER("Sequence Parameter Set"); + + CHECK(FUNC(nal_unit_header)(ctx, rw, ¤t->nal_unit_header, H266_NAL_SPS)); + + ub(4, sps_seq_parameter_set_id); + ub(4, sps_video_parameter_set_id); + h266->active_vps = vps = h266->vps[current->sps_video_parameter_set_id]; + + u(3, sps_max_sublayers_minus1, 0, H266_MAX_SUB_LAYERS - 1); + u(2, sps_chroma_format_idc, 0, 3); + u(2, sps_log2_ctu_size_minus5, 0, 3); + ctb_log2_size_y = current->sps_log2_ctu_size_minus5 + 5; + ctb_size_y = 1 << ctb_log2_size_y; + + flag(sps_ptl_dpb_hrd_params_present_flag); + if (current->sps_ptl_dpb_hrd_params_present_flag) { + CHECK(FUNC(profile_tier_level)(ctx, rw, ¤t->profile_tier_level, + 1, current->sps_max_sublayers_minus1)); + } + flag(sps_gdr_enabled_flag); + flag(sps_ref_pic_resampling_enabled_flag); + if(current->sps_ref_pic_resampling_enabled_flag) + flag(sps_res_change_in_clvs_allowed_flag); + else + infer(sps_res_change_in_clvs_allowed_flag, 0); + + ue(sps_pic_width_max_in_luma_samples, 1, H266_MAX_WIDTH); + ue(sps_pic_height_max_in_luma_samples, 1, H266_MAX_HEIGHT); + + flag(sps_conformance_window_flag); + if (current->sps_conformance_window_flag) { + ue(sps_conf_win_left_offset, 0, current->sps_pic_width_max_in_luma_samples); + ue(sps_conf_win_right_offset, 0, current->sps_pic_width_max_in_luma_samples); + ue(sps_conf_win_top_offset, 0, current->sps_pic_height_max_in_luma_samples); + ue(sps_conf_win_bottom_offset, 0, current->sps_pic_height_max_in_luma_samples); + } else { + infer(sps_conf_win_left_offset, 0); + infer(sps_conf_win_right_offset, 0); + infer(sps_conf_win_top_offset, 0); + infer(sps_conf_win_bottom_offset, 0); + } + flag(sps_subpic_info_present_flag); + if (current->sps_subpic_info_present_flag) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "subpic is not supported yet\n"); + return AVERROR_PATCHWELCOME; + } else { + infer(sps_num_subpics_minus1, 0); + infer(sps_independent_subpics_flag, 1); + infer(sps_subpic_same_size_flag, 0); + //?sps_subpic_id_len_minus1; + infer(sps_subpic_id_mapping_explicitly_signalled_flag, 0); + + } + + ue(sps_bitdepth_minus8, 0, 2); + current->qp_bd_offset = 6 * current->sps_bitdepth_minus8; + + flag(sps_entropy_coding_sync_enabled_flag); + flag(sps_entry_point_offsets_present_flag); + + u(4, sps_log2_max_pic_order_cnt_lsb_minus4, 0, 12); + flag(sps_poc_msb_cycle_flag); + if (current->sps_poc_msb_cycle_flag) + ue(sps_poc_msb_cycle_len_minus1, 0, 32 - current->sps_log2_max_pic_order_cnt_lsb_minus4 - 5); + + u(2, sps_num_extra_ph_bytes, 0, 2); + for (i = 0; i < (current->sps_num_extra_ph_bytes * 8 ); i++) { + flags(sps_extra_ph_bit_present_flag[i], 1, i); + } + current->num_extra_ph_bits = get_extra_bits(current->sps_extra_ph_bit_present_flag, current->sps_num_extra_ph_bytes); + + u(2, sps_num_extra_sh_bytes, 0, 0); + for (i = 0; i < (current->sps_num_extra_sh_bytes * 8 ); i++) { + flags(sps_extra_sh_bit_present_flag[i], 1, i); + } + current->num_extra_sh_bits = get_extra_bits(current->sps_extra_sh_bit_present_flag, current->sps_num_extra_sh_bytes); + + if (current->sps_ptl_dpb_hrd_params_present_flag) { + if (current->sps_max_sublayers_minus1 > 0) + flag(sps_sublayer_dpb_params_flag); + else + infer(sps_sublayer_dpb_params_flag, 0); + CHECK(FUNC(dpb_parameters)(ctx, rw, ¤t->sps_dpb_params, current->sps_max_sublayers_minus1, + current->sps_sublayer_dpb_params_flag)); + } + + ue(sps_log2_min_luma_coding_block_size_minus2, 0, FFMIN(4, current->sps_log2_ctu_size_minus5 + 3)); + min_cb_log2_size_y = current->min_cb_log2_size_y = current->sps_log2_min_luma_coding_block_size_minus2 + 2; + + flag(sps_partition_constraints_override_enabled_flag); + + ue(sps_log2_diff_min_qt_min_cb_intra_slice_luma, 0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y); + min_qt_log2_size_intra_y = current->sps_log2_diff_min_qt_min_cb_intra_slice_luma + min_cb_log2_size_y; + + ue(sps_max_mtt_hierarchy_depth_intra_slice_luma, 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y)); + + if (current->sps_max_mtt_hierarchy_depth_intra_slice_luma) { + ue(sps_log2_diff_max_bt_min_qt_intra_slice_luma, 0, ctb_log2_size_y - min_qt_log2_size_intra_y); + ue(sps_log2_diff_max_tt_min_qt_intra_slice_luma, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y); + } else { + infer(sps_log2_diff_max_bt_min_qt_intra_slice_luma, 0); + infer(sps_log2_diff_max_tt_min_qt_intra_slice_luma, 0); + } + + if (current->sps_chroma_format_idc) { + flag(sps_qtbtt_dual_tree_intra_flag); + } else { + infer(sps_qtbtt_dual_tree_intra_flag, 0); + } + + if(current->sps_qtbtt_dual_tree_intra_flag) { + ue(sps_log2_diff_min_qt_min_cb_intra_slice_chroma, 0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y); + ue(sps_max_mtt_hierarchy_depth_intra_slice_chroma, 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y)); + if(current->sps_max_mtt_hierarchy_depth_intra_slice_chroma) { + unsigned int min_qt_log2_size_intra_c = current->sps_log2_diff_min_qt_min_cb_intra_slice_chroma + min_cb_log2_size_y; + ue(sps_log2_diff_max_bt_min_qt_intra_slice_chroma, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c); + ue(sps_log2_diff_max_tt_min_qt_intra_slice_chroma, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c); + } + } else { + infer(sps_log2_diff_min_qt_min_cb_intra_slice_chroma, 0); + infer(sps_max_mtt_hierarchy_depth_intra_slice_chroma, 0); + } + if (!current->sps_max_mtt_hierarchy_depth_intra_slice_chroma) { + infer(sps_log2_diff_max_bt_min_qt_intra_slice_chroma, 0); + infer(sps_log2_diff_max_tt_min_qt_intra_slice_chroma, 0); + } + + ue(sps_log2_diff_min_qt_min_cb_inter_slice, 0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y); + min_qt_log2_size_inter_y = current->sps_log2_diff_min_qt_min_cb_inter_slice + min_cb_log2_size_y; + + ue(sps_max_mtt_hierarchy_depth_inter_slice, 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y)); + if(current->sps_max_mtt_hierarchy_depth_inter_slice) { + ue(sps_log2_diff_max_bt_min_qt_inter_slice, 0, ctb_log2_size_y - min_qt_log2_size_inter_y); + ue(sps_log2_diff_max_tt_min_qt_inter_slice, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y); + } else { + infer(sps_log2_diff_max_bt_min_qt_inter_slice, 0); + infer(sps_log2_diff_max_tt_min_qt_inter_slice, 0); + } + + if (ctb_size_y > 32) + flag(sps_max_luma_transform_size_64_flag); + else + infer(sps_max_luma_transform_size_64_flag, 0); + + flag(sps_transform_skip_enabled_flag); + if (current->sps_transform_skip_enabled_flag) { + ue(sps_log2_transform_skip_max_size_minus2, 0, 3); + flag(sps_bdpcm_enabled_flag); + } + + flag(sps_mts_enabled_flag); + if (current->sps_mts_enabled_flag) { + flag(sps_explicit_mts_intra_enabled_flag); + flag(sps_explicit_mts_inter_enabled_flag); + } else { + infer(sps_explicit_mts_intra_enabled_flag, 0); + infer(sps_explicit_mts_inter_enabled_flag, 0); + } + + flag(sps_lfnst_enabled_flag); + + if (current->sps_chroma_format_idc) { + uint8_t num_qp_tables; + flag(sps_joint_cbcr_enabled_flag); + flag(sps_same_qp_table_for_chroma_flag); + num_qp_tables = current->sps_same_qp_table_for_chroma_flag ? 1 : ( current->sps_joint_cbcr_enabled_flag ? 3 : 2 ); + for( i = 0; i < num_qp_tables; i++ ) { + ses(sps_qp_table_start_minus26[i], -26 - current->qp_bd_offset, 36, 1, i); + ues(sps_num_points_in_qp_table_minus1[i], 0, 36 - current->sps_qp_table_start_minus26[i], 1, i); + for( j = 0; j <= current->sps_num_points_in_qp_table_minus1[ i ]; j++ ) { + ues(sps_delta_qp_in_val_minus1[i][j], 0, MAX_UINT_BITS(8), 2, i, j); + ues(sps_delta_qp_diff_val[i][j], 0, MAX_UINT_BITS(8), 2, i, j); + } + } + } else { + infer(sps_joint_cbcr_enabled_flag, 0); + infer(sps_same_qp_table_for_chroma_flag, 0); + } + + flag(sps_sao_enabled_flag); + flag(sps_alf_enabled_flag); + if(current->sps_alf_enabled_flag && current->sps_chroma_format_idc) + flag(sps_ccalf_enabled_flag); + else + infer(sps_ccalf_enabled_flag, 0); + flag(sps_lmcs_enabled_flag); + flag(sps_weighted_pred_flag); + flag(sps_weighted_bipred_flag); + flag(sps_long_term_ref_pics_flag); + if(current->sps_video_parameter_set_id > 0) + flag(sps_inter_layer_prediction_enabled_flag); + else + infer(sps_inter_layer_prediction_enabled_flag, 0); + flag(sps_idr_rpl_present_flag); + flag(sps_rpl1_same_as_rpl0_flag); + + for (i = 0; i < (current->sps_rpl1_same_as_rpl0_flag ? 1 : 2); i++) { + ues(sps_num_ref_pic_lists[i], 0, H266_MAX_REF_PIC_LISTS, 1, i); + for( j = 0; j < current->sps_num_ref_pic_lists[i]; j++) + CHECK(FUNC(ref_pic_list_struct)(ctx, rw, ¤t->sps_ref_pic_list_struct[i][j], i, j, current)); + } + + flag(sps_ref_wraparound_enabled_flag); + + flag(sps_temporal_mvp_enabled_flag); + if(current->sps_temporal_mvp_enabled_flag ) + flag(sps_sbtmvp_enabled_flag); + else + infer(sps_sbtmvp_enabled_flag, 0); + + flag(sps_amvr_enabled_flag); + flag(sps_bdof_enabled_flag); + if(current->sps_bdof_enabled_flag) + flag(sps_bdof_control_present_in_ph_flag); + else + infer(sps_bdof_control_present_in_ph_flag, 0); + + flag(sps_smvd_enabled_flag); + flag(sps_dmvr_enabled_flag); + if(current->sps_dmvr_enabled_flag) + flag(sps_dmvr_control_present_in_ph_flag); + else + infer(sps_dmvr_control_present_in_ph_flag, 0); + + flag(sps_mmvd_enabled_flag); + if(current->sps_mmvd_enabled_flag) + flag(sps_mmvd_fullpel_only_enabled_flag); + else + infer(sps_mmvd_fullpel_only_enabled_flag, 0); + + ue(sps_six_minus_max_num_merge_cand, 0, 5); + max_num_merge_cand = 6 - current->sps_six_minus_max_num_merge_cand; + + flag(sps_sbt_enabled_flag); + + flag(sps_affine_enabled_flag); + if(current->sps_affine_enabled_flag ) { + ue(sps_five_minus_max_num_subblock_merge_cand, 0, 5 - current->sps_sbtmvp_enabled_flag); + flag(sps_6param_affine_enabled_flag); + if(current->sps_amvr_enabled_flag) + flag(sps_affine_amvr_enabled_flag); + else + infer(sps_affine_amvr_enabled_flag, 0); + flag(sps_affine_prof_enabled_flag); + if(current->sps_affine_prof_enabled_flag) + flag(sps_prof_control_present_in_ph_flag); + else + infer(sps_prof_control_present_in_ph_flag, 0); + } else { + infer(sps_five_minus_max_num_subblock_merge_cand, 0); + infer(sps_6param_affine_enabled_flag, 0); + infer(sps_affine_amvr_enabled_flag, 0); + infer(sps_affine_prof_enabled_flag, 0); + infer(sps_prof_control_present_in_ph_flag, 0); + } + + flag(sps_bcw_enabled_flag); + flag(sps_ciip_enabled_flag); + + if (max_num_merge_cand >= 2) { + flag(sps_gpm_enabled_flag); + if (current->sps_gpm_enabled_flag && max_num_merge_cand >= 3) + ue(sps_max_num_merge_cand_minus_max_num_gpm_cand, 0, max_num_merge_cand - 2); + } else { + infer(sps_gpm_enabled_flag, 0); + } + + ue(sps_log2_parallel_merge_level_minus2, 0, ctb_log2_size_y - 2); + + flag(sps_isp_enabled_flag); + flag(sps_mrl_enabled_flag); + flag(sps_mip_enabled_flag); + + if(current->sps_chroma_format_idc) + flag(sps_cclm_enabled_flag); + else + infer(sps_cclm_enabled_flag, 0); + if(current->sps_chroma_format_idc == 1 ) { + flag(sps_chroma_horizontal_collocated_flag); + flag(sps_chroma_vertical_collocated_flag); + } else { + infer(sps_chroma_horizontal_collocated_flag, 1); + infer(sps_chroma_vertical_collocated_flag, 1); + } + + flag(sps_palette_enabled_flag); + if(current->sps_chroma_format_idc == 3 && !current->sps_max_luma_transform_size_64_flag) + flag(sps_act_enabled_flag); + else + infer(sps_act_enabled_flag, 0); + if(current->sps_transform_skip_enabled_flag || current->sps_palette_enabled_flag) + ue(sps_min_qp_prime_ts, 0, 8); + + flag(sps_ibc_enabled_flag); + if (current->sps_ibc_enabled_flag) { + ue(sps_six_minus_max_num_ibc_merge_cand, 0, 5); + } + + flag(sps_ladf_enabled_flag); + if (current->sps_ladf_enabled_flag) { + ub(2, sps_num_ladf_intervals_minus2); + se(sps_ladf_lowest_interval_qp_offset, -63, 63); + for( i = 0; i < current->sps_num_ladf_intervals_minus2 + 1; i++ ) { + ses(sps_ladf_qp_offset[i], -63, 63, 1, i); + ues(sps_ladf_delta_threshold_minus1[i], 0, (2 << ( 8 + current->sps_bitdepth_minus8)) - 3, 1, i); + } + } + + flag(sps_explicit_scaling_list_enabled_flag); + if(current->sps_lfnst_enabled_flag && current->sps_explicit_scaling_list_enabled_flag) + flag(sps_scaling_matrix_for_lfnst_disabled_flag); + + if(current->sps_act_enabled_flag && current->sps_explicit_scaling_list_enabled_flag) + flag(sps_scaling_matrix_for_alternative_colour_space_disabled_flag); + else + infer(sps_scaling_matrix_for_alternative_colour_space_disabled_flag, 0); + if(current->sps_scaling_matrix_for_alternative_colour_space_disabled_flag) + flag(sps_scaling_matrix_designated_colour_space_flag); + + flag(sps_dep_quant_enabled_flag); + flag(sps_sign_data_hiding_enabled_flag); + + flag(sps_virtual_boundaries_enabled_flag); + if(current->sps_virtual_boundaries_enabled_flag) { + flag(sps_virtual_boundaries_present_flag); + if(current->sps_virtual_boundaries_present_flag) { + ue(sps_num_ver_virtual_boundaries, 0, current->sps_pic_width_max_in_luma_samples <= 8 ? 0 : 3); + for( i = 0; i < current->sps_num_ver_virtual_boundaries; i++ ) + ues(sps_virtual_boundary_pos_x_minus1[i], 0, (current->sps_pic_width_max_in_luma_samples + 7) / 8 - 2, 1, i); + ue(sps_num_hor_virtual_boundaries, 0, current->sps_pic_height_max_in_luma_samples <= 8 ? 0 : 3); + for( i = 0; i < current->sps_num_hor_virtual_boundaries; i++ ) + ues(sps_virtual_boundary_pos_y_minus1[i], 0, (current->sps_pic_height_max_in_luma_samples + 7) / 8 - 2, 1, i); + } + } else { + infer(sps_virtual_boundaries_present_flag, 0); + infer(sps_num_ver_virtual_boundaries, 0); + infer(sps_num_hor_virtual_boundaries, 0); + } + + if(current->sps_ptl_dpb_hrd_params_present_flag) { + flag(sps_timing_hrd_params_present_flag); + if (current->sps_timing_hrd_params_present_flag) { + uint8_t first_sublayer; + CHECK(FUNC(general_timing_hrd_parameters)(ctx, rw, ¤t->sps_general_timing_hrd_parameters)); + if(current->sps_max_sublayers_minus1 > 0) + flag(sps_sublayer_cpb_params_present_flag); + else + infer(sps_sublayer_cpb_params_present_flag, 0); + first_sublayer = current->sps_sublayer_cpb_params_present_flag ? 0 : current->sps_max_sublayers_minus1; + CHECK(FUNC(ols_timing_hrd_parameters)(ctx, rw, ¤t->sps_ols_timing_hrd_parameters, first_sublayer, current->sps_max_sublayers_minus1, ¤t->sps_general_timing_hrd_parameters)); + } + } + + flag(sps_field_seq_flag); + flag(sps_vui_parameters_present_flag); + if (current->sps_vui_parameters_present_flag) { + ue(sps_vui_payload_size_minus1, 0, 1023); + while (!byte_alignment(rw)) + fixed(1, sps_vui_alignment_zero_bit, 0); + CHECK(FUNC(vui_payload)(ctx, rw, ¤t->vui, current->sps_vui_payload_size_minus1 + 1)); + } + + flag(sps_extension_flag); + if (current->sps_extension_flag) { + return AVERROR_PATCHWELCOME; + } + CHECK(FUNC(rbsp_trailing_bits)(ctx, rw)); + + return 0; +} + +static const uint8_t h266_sub_width_c[] = { + 1, 2, 2, 1 +}; + +static const uint8_t h266_sub_height_c[] = { + 1, 2, 1, 1 +}; + +static int get_num_tile(const uint16_t* pps_tile_size_minus1, uint16_t num_exp_tile_minus1, unsigned int pic_size_in_ctbs_y, unsigned int exp_tile_size) +{ + uint16_t uniform_size = pps_tile_size_minus1[num_exp_tile_minus1] + 1; + unsigned int left = pic_size_in_ctbs_y - exp_tile_size; + return num_exp_tile_minus1 + 1 + (left + uniform_size - 1) / uniform_size; +} + +static int FUNC(pps)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawPPS *current) +{ + + CodedBitstreamH266Context *h266 = ctx->priv_data; + const H266RawSPS *sps; + int err, i; + unsigned int min_cb_size_y, divisor, ctb_size_y, + pic_width_in_ctbs_y, pic_height_in_ctbs_y; + uint8_t sub_width_c, sub_height_c; + + HEADER("Picture Parameter Set"); + + CHECK(FUNC(nal_unit_header)(ctx, rw, ¤t->nal_unit_header, H266_NAL_PPS)); + + ub(6, pps_pic_parameter_set_id); + ub(4, pps_seq_parameter_set_id); + sps = h266->sps[current->pps_seq_parameter_set_id]; + if (!sps) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n", + current->pps_seq_parameter_set_id); + return AVERROR_INVALIDDATA; + } + h266->active_sps = sps; + + flag(pps_mixed_nalu_types_in_pic_flag); + ue(pps_pic_width_in_luma_samples, 1, sps->sps_pic_width_max_in_luma_samples); + ue(pps_pic_height_in_luma_samples, 1, sps->sps_pic_height_max_in_luma_samples); + + min_cb_size_y = 1 << (sps->sps_log2_min_luma_coding_block_size_minus2 + 2); + divisor = FFMAX(min_cb_size_y, 8); + if (current->pps_pic_width_in_luma_samples % divisor || + current->pps_pic_height_in_luma_samples % divisor) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid dimensions: %ux%u not divisible " + "by %u, MinCbSizeY = %u.\n", current->pps_pic_width_in_luma_samples, + current->pps_pic_height_in_luma_samples, divisor, min_cb_size_y); + return AVERROR_INVALIDDATA; + } + if (!sps->sps_res_change_in_clvs_allowed_flag && + (current->pps_pic_width_in_luma_samples != sps->sps_pic_width_max_in_luma_samples || + current->pps_pic_height_in_luma_samples != sps->sps_pic_height_max_in_luma_samples)) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "Resoltuion change is not allowed, in max resolution (%ux%u) mismatched with pps(%ux%u).\n", + sps->sps_pic_width_max_in_luma_samples, + sps->sps_pic_height_max_in_luma_samples, + current->pps_pic_width_in_luma_samples, + current->pps_pic_height_in_luma_samples); + return AVERROR_INVALIDDATA; + } + + ctb_size_y = 1 << (sps->sps_log2_ctu_size_minus5 + 5); + if (sps->sps_ref_wraparound_enabled_flag) { + if ((ctb_size_y / min_cb_size_y + 1) > (current->pps_pic_width_in_luma_samples / min_cb_size_y - 1)) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid width(%u), ctb_size_y = %u, min_cb_size_y = %u.\n", + current->pps_pic_width_in_luma_samples, + ctb_size_y, min_cb_size_y); + return AVERROR_INVALIDDATA; + } + } + + flag(pps_conformance_window_flag); + if (current->pps_pic_width_in_luma_samples == sps->sps_pic_width_max_in_luma_samples && + current->pps_pic_height_in_luma_samples == sps->sps_pic_height_max_in_luma_samples && + current->pps_conformance_window_flag) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "Conformance window flag should not true.\n"); + return AVERROR_INVALIDDATA; + } + + sub_width_c = h266_sub_width_c[sps->sps_chroma_format_idc]; + sub_height_c = h266_sub_height_c[sps->sps_chroma_format_idc]; + if (current->pps_conformance_window_flag) { + ue(pps_conf_win_left_offset, 0, current->pps_pic_width_in_luma_samples); + ue(pps_conf_win_right_offset, 0, current->pps_pic_width_in_luma_samples); + ue(pps_conf_win_top_offset, 0, current->pps_pic_height_in_luma_samples); + ue(pps_conf_win_bottom_offset, 0, current->pps_pic_height_in_luma_samples); + if (sub_width_c * (current->pps_conf_win_left_offset + current->pps_conf_win_right_offset) >= current->pps_pic_width_in_luma_samples || + sub_height_c * (current->pps_conf_win_top_offset + current->pps_conf_win_bottom_offset) >= current->pps_pic_height_in_luma_samples) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid pps conformance window: (%u, %u, %u, %u), resolution is %ux%u, sub wxh is %ux%u.\n", + current->pps_conf_win_left_offset, current->pps_conf_win_right_offset, + current->pps_conf_win_top_offset, current->pps_conf_win_bottom_offset, + current->pps_pic_width_in_luma_samples, current->pps_pic_height_in_luma_samples, + sub_width_c, sub_height_c); + return AVERROR_INVALIDDATA; + } + } else { + if (current->pps_pic_width_in_luma_samples == sps->sps_pic_width_max_in_luma_samples && + current->pps_pic_height_in_luma_samples == sps->sps_pic_height_max_in_luma_samples) { + infer(pps_conf_win_left_offset, sps->sps_conf_win_left_offset); + infer(pps_conf_win_right_offset, sps->sps_conf_win_right_offset); + infer(pps_conf_win_top_offset, sps->sps_conf_win_top_offset); + infer(pps_conf_win_bottom_offset, sps->sps_conf_win_bottom_offset); + } else { + infer(pps_conf_win_left_offset, 0); + infer(pps_conf_win_right_offset, 0); + infer(pps_conf_win_top_offset, 0); + infer(pps_conf_win_bottom_offset, 0); + } + + } + + flag(pps_scaling_window_explicit_signalling_flag); + if (!sps->sps_ref_pic_resampling_enabled_flag && current->pps_scaling_window_explicit_signalling_flag) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid data: sps_ref_pic_resampling_enabled_flag is false, but pps_scaling_window_explicit_signalling_flag is true.\n"); + return AVERROR_INVALIDDATA; + } + if (current->pps_scaling_window_explicit_signalling_flag) { + se(pps_scaling_win_left_offset, -current->pps_pic_width_in_luma_samples * 15 / sub_width_c, current->pps_pic_width_in_luma_samples / sub_width_c); + se(pps_scaling_win_right_offset, -current->pps_pic_width_in_luma_samples * 15 / sub_width_c, current->pps_pic_width_in_luma_samples / sub_width_c); + se(pps_scaling_win_top_offset, -current->pps_pic_height_in_luma_samples * 15 / sub_height_c, current->pps_pic_height_in_luma_samples / sub_height_c); + se(pps_scaling_win_bottom_offset, -current->pps_pic_height_in_luma_samples * 15 /sub_height_c, current->pps_pic_height_in_luma_samples / sub_height_c); + } else { + infer(pps_scaling_win_left_offset, current->pps_conf_win_left_offset); + infer(pps_scaling_win_right_offset, current->pps_conf_win_right_offset); + infer(pps_scaling_win_top_offset, current->pps_conf_win_top_offset); + infer(pps_scaling_win_bottom_offset, current->pps_conf_win_bottom_offset); + } + + flag(pps_output_flag_present_flag); + flag(pps_no_pic_partition_flag); + flag(pps_subpic_id_mapping_present_flag); + + if(current->pps_subpic_id_mapping_present_flag ) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "pps_subpic_id_mapping_present_flag is not supported.\n"); + return AVERROR_PATCHWELCOME; + } + + if(!current->pps_no_pic_partition_flag ) { + unsigned int exp_tile_width = 0, exp_tile_height = 0; + pic_width_in_ctbs_y = ceil(current->pps_pic_width_in_luma_samples / (double)ctb_size_y); + pic_height_in_ctbs_y = ceil(current->pps_pic_height_in_luma_samples / (double)ctb_size_y); + u(2, pps_log2_ctu_size_minus5, sps->sps_log2_ctu_size_minus5, sps->sps_log2_ctu_size_minus5); + + ue(pps_num_exp_tile_columns_minus1, 0, FFMIN(pic_width_in_ctbs_y - 1, H266_MAX_TILE_COLUMNS)); + ue(pps_num_exp_tile_rows_minus1, 0, FFMIN(pic_height_in_ctbs_y - 1, H266_MAX_TILE_ROWS)); + + for( i = 0; i <= current->pps_num_exp_tile_columns_minus1; i++ ) { + ues(pps_tile_column_width_minus1[i], 0, pic_width_in_ctbs_y - 1, 1, i); + exp_tile_width += current->pps_tile_column_width_minus1[i] + 1; + } + current->num_tile_columns = get_num_tile(current->pps_tile_column_width_minus1, current->pps_num_exp_tile_columns_minus1, pic_width_in_ctbs_y, exp_tile_width); + + for( i = 0; i <= current->pps_num_exp_tile_rows_minus1; i++ ) { + ues(pps_tile_row_height_minus1[i], 0, pic_height_in_ctbs_y - 1, 1, i); + exp_tile_height += current->pps_tile_row_height_minus1[i] + 1; + } + current->num_tile_rows = get_num_tile(current->pps_tile_row_height_minus1, current->pps_num_exp_tile_rows_minus1, pic_height_in_ctbs_y, exp_tile_height); + + current->num_tiles_in_pic = current->num_tile_columns * current->num_tile_rows; + if (current->num_tiles_in_pic > 1) { + flag(pps_loop_filter_across_tiles_enabled_flag); + flag(pps_rect_slice_flag); + } else { + infer(pps_loop_filter_across_tiles_enabled_flag, 0); + infer(pps_rect_slice_flag, 1); + } + if(current->pps_rect_slice_flag) + flag(pps_single_slice_per_subpic_flag); + else + infer(pps_single_slice_per_subpic_flag, 1); + if(current->pps_rect_slice_flag && !current->pps_single_slice_per_subpic_flag) { + ue(pps_num_slices_in_pic_minus1, 0, H266_MAX_SLICES); + if(current->pps_num_slices_in_pic_minus1 > 1 ) + flag(pps_tile_idx_delta_present_flag); + else + infer(pps_tile_idx_delta_present_flag, 0); + return AVERROR_PATCHWELCOME; + } + if( !current->pps_rect_slice_flag || current->pps_single_slice_per_subpic_flag || current->pps_num_slices_in_pic_minus1 > 0 ) + flag(pps_loop_filter_across_slices_enabled_flag); + else + infer(pps_loop_filter_across_slices_enabled_flag, 0); + } else { + infer(pps_num_exp_tile_columns_minus1, 0); + infer(pps_num_exp_tile_rows_minus1, 0); + infer(num_tile_columns, 1); + infer(num_tile_rows, 1); + infer(num_tiles_in_pic, 1); + } + flag(pps_cabac_init_present_flag); + for( i = 0; i < 2; i++ ) + ues(pps_num_ref_idx_default_active_minus1[i], 0, 14, 1, i); + flag(pps_rpl1_idx_present_flag); + flag(pps_weighted_pred_flag); + flag(pps_weighted_bipred_flag); + flag(pps_ref_wraparound_enabled_flag); + if(current->pps_ref_wraparound_enabled_flag) + ue(pps_pic_width_minus_wraparound_offset, 0, (current->pps_pic_width_in_luma_samples / min_cb_size_y) - (ctb_size_y / min_cb_size_y) - 2); + + se(pps_init_qp_minus26, -(26 + sps->qp_bd_offset), 37); + flag(pps_cu_qp_delta_enabled_flag); + flag(pps_chroma_tool_offsets_present_flag); + if(current->pps_chroma_tool_offsets_present_flag) { + se(pps_cb_qp_offset, -12, 12); + se(pps_cr_qp_offset, -12, 12); + flag(pps_joint_cbcr_qp_offset_present_flag); + if (current->pps_joint_cbcr_qp_offset_present_flag) + se(pps_joint_cbcr_qp_offset_value, -12, 12); + else + infer(pps_joint_cbcr_qp_offset_value, 0); + flag(pps_slice_chroma_qp_offsets_present_flag); + flag(pps_cu_chroma_qp_offset_list_enabled_flag); + if (current->pps_cu_chroma_qp_offset_list_enabled_flag) { + return AVERROR_PATCHWELCOME; + } + } else { + infer(pps_cb_qp_offset, 0); + infer(pps_cr_qp_offset, 0); + infer(pps_joint_cbcr_qp_offset_present_flag, 0); + infer(pps_joint_cbcr_qp_offset_value, 0); + infer(pps_slice_chroma_qp_offsets_present_flag, 0); + infer(pps_cu_chroma_qp_offset_list_enabled_flag, 0); + } + flag(pps_deblocking_filter_control_present_flag); + if (current->pps_deblocking_filter_control_present_flag) { + return AVERROR_PATCHWELCOME; + } + if(!current->pps_no_pic_partition_flag) { + return AVERROR_PATCHWELCOME; + } + flag(pps_picture_header_extension_present_flag); + flag(pps_slice_header_extension_present_flag); + flag(pps_extension_flag); + if(current->pps_extension_flag) { + return AVERROR_PATCHWELCOME; + } + CHECK(FUNC(rbsp_trailing_bits)(ctx, rw)); + return 0; +} + +static int FUNC(aud)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawAUD *current) +{ + int err; + + HEADER("Access Unit Delimiter"); + + CHECK(FUNC(nal_unit_header)(ctx, rw, ¤t->nal_unit_header, HEVC_NAL_AUD)); + + flag(aud_irap_or_gdr_flag); + ub(3, aud_pic_type); + + CHECK(FUNC(rbsp_trailing_bits)(ctx, rw)); + return 0; +} + +static int FUNC(picture_header)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawPH *current) +{ + CodedBitstreamH266Context *h266 = ctx->priv_data; + const H266RawSPS *sps; + const H266RawPPS *pps; + int err, i; + unsigned int ctb_log2_size_y, min_cb_log2_size_y, + min_qt_log2_size_intra_y, min_qt_log2_size_inter_y; + + flag(ph_gdr_or_irap_pic_flag); + flag(ph_non_ref_pic_flag); + if(current->ph_gdr_or_irap_pic_flag) + flag(ph_gdr_pic_flag); + else + infer(ph_gdr_pic_flag, 0); + flag(ph_inter_slice_allowed_flag); + if (current->ph_inter_slice_allowed_flag) + flag(ph_intra_slice_allowed_flag); + else + infer(ph_intra_slice_allowed_flag, 1); + ue(ph_pic_parameter_set_id, 0, 63); + pps = h266->pps[current->ph_pic_parameter_set_id]; + if (!pps) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n", + pps->pps_seq_parameter_set_id); + return AVERROR_INVALIDDATA; + } + sps = h266->sps[pps->pps_seq_parameter_set_id]; + if (!pps) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "sps id %d not available.\n", + pps->pps_seq_parameter_set_id); + return AVERROR_INVALIDDATA; + } + h266->active_sps = sps; + h266->active_pps = pps; + + ub(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, ph_pic_order_cnt_lsb); + if(current->ph_gdr_pic_flag) + ub(sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4, ph_recovery_poc_cnt); + + for( i = 0; i < sps->num_extra_sh_bits; i++) { + flags(ph_extra_bit[i], 1, i); + } + if(sps->sps_poc_msb_cycle_flag) { + return AVERROR_PATCHWELCOME; + } + if(sps->sps_alf_enabled_flag && pps->pps_alf_info_in_ph_flag) { + return AVERROR_PATCHWELCOME; + } + if(sps->sps_lmcs_enabled_flag) { + flag(ph_lmcs_enabled_flag); + if (current->ph_lmcs_enabled_flag) { + ub(2, ph_lmcs_aps_id); + if(sps->sps_chroma_format_idc != 0 ) + flag(ph_chroma_residual_scale_flag); + else + infer(ph_chroma_residual_scale_flag, 0); + } + } else { + infer(ph_lmcs_enabled_flag, 0); + infer(ph_chroma_residual_scale_flag, 0); + } + + if(sps->sps_explicit_scaling_list_enabled_flag) { + return AVERROR_PATCHWELCOME; + } + if(sps->sps_virtual_boundaries_enabled_flag && !sps->sps_virtual_boundaries_present_flag) { + return AVERROR_PATCHWELCOME; + } + if(pps->pps_output_flag_present_flag && !current->ph_non_ref_pic_flag) + flag(ph_pic_output_flag); + else + infer(ph_pic_output_flag, 1); + if(pps->pps_rpl_info_in_ph_flag) { + CHECK(FUNC(ref_pic_lists)(ctx, rw, ¤t->ph_ref_pic_lists)); + } + if(sps->sps_partition_constraints_override_enabled_flag) + flag(ph_partition_constraints_override_flag); + else + infer(ph_partition_constraints_override_flag, 0); + + ctb_log2_size_y = sps->sps_log2_ctu_size_minus5 + 5; + min_cb_log2_size_y = sps->min_cb_log2_size_y; + if(current->ph_intra_slice_allowed_flag) { + if(current->ph_partition_constraints_override_flag ) { + ue(ph_log2_diff_min_qt_min_cb_intra_slice_luma, 0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y); + ue(ph_max_mtt_hierarchy_depth_intra_slice_luma, 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y)); + if (current->ph_max_mtt_hierarchy_depth_intra_slice_luma) { + ue(ph_log2_diff_max_bt_min_qt_intra_slice_luma, 0, ctb_log2_size_y - min_qt_log2_size_intra_y); + ue(ph_log2_diff_max_tt_min_qt_intra_slice_luma, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_y); + } else { + infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma, sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma); + infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma, sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma); + } + if (sps->sps_qtbtt_dual_tree_intra_flag ) { + ue(ph_log2_diff_min_qt_min_cb_intra_slice_chroma, 0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y); + ue(ph_max_mtt_hierarchy_depth_intra_slice_chroma, 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y)); + if(sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma) { + unsigned int min_qt_log2_size_intra_c = sps->sps_log2_diff_min_qt_min_cb_intra_slice_chroma + min_cb_log2_size_y; + ue(ph_log2_diff_max_bt_min_qt_intra_slice_chroma, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c); + ue(ph_log2_diff_max_tt_min_qt_intra_slice_chroma, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_intra_c); + } else { + infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma, sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma); + infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma, sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma); + } + } + } else { + infer(ph_log2_diff_min_qt_min_cb_intra_slice_luma, sps->sps_log2_diff_min_qt_min_cb_intra_slice_luma); + infer(ph_max_mtt_hierarchy_depth_intra_slice_luma, sps->sps_max_mtt_hierarchy_depth_intra_slice_luma); + infer(ph_log2_diff_max_bt_min_qt_intra_slice_luma, sps->sps_log2_diff_max_bt_min_qt_intra_slice_luma); + infer(ph_log2_diff_max_tt_min_qt_intra_slice_luma, sps->sps_log2_diff_max_tt_min_qt_intra_slice_luma); + infer(ph_log2_diff_min_qt_min_cb_intra_slice_chroma, sps->sps_log2_diff_min_qt_min_cb_intra_slice_chroma); + infer(ph_max_mtt_hierarchy_depth_intra_slice_chroma, sps->sps_max_mtt_hierarchy_depth_intra_slice_chroma); + infer(ph_log2_diff_max_bt_min_qt_intra_slice_chroma, sps->sps_log2_diff_max_bt_min_qt_intra_slice_chroma); + infer(ph_log2_diff_max_tt_min_qt_intra_slice_chroma, sps->sps_log2_diff_max_tt_min_qt_intra_slice_chroma); + } + + min_qt_log2_size_intra_y = current->ph_log2_diff_min_qt_min_cb_intra_slice_luma + ctb_log2_size_y; + if(pps->pps_cu_qp_delta_enabled_flag) + ue(ph_cu_qp_delta_subdiv_intra_slice, 0, 2 * ( ctb_log2_size_y - min_qt_log2_size_intra_y + current->ph_max_mtt_hierarchy_depth_intra_slice_luma )); + else + infer(ph_cu_qp_delta_subdiv_intra_slice, 0); + + if(pps->pps_cu_chroma_qp_offset_list_enabled_flag) + ue(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0, 2 * (ctb_log2_size_y - min_qt_log2_size_intra_y + current->ph_max_mtt_hierarchy_depth_intra_slice_luma )); + else + infer(ph_cu_chroma_qp_offset_subdiv_intra_slice, 0); + } + if(current->ph_inter_slice_allowed_flag) { + if(current->ph_partition_constraints_override_flag) { + ue(ph_log2_diff_min_qt_min_cb_inter_slice, 0, FFMIN(6, ctb_log2_size_y) - min_cb_log2_size_y); + min_qt_log2_size_inter_y = current->ph_log2_diff_min_qt_min_cb_inter_slice + ctb_log2_size_y; + ue(ph_max_mtt_hierarchy_depth_inter_slice, 0, 2 * (ctb_log2_size_y - min_cb_log2_size_y)); + if(current->ph_max_mtt_hierarchy_depth_inter_slice) { + ue(ph_log2_diff_max_bt_min_qt_inter_slice, 0, ctb_log2_size_y - min_qt_log2_size_inter_y); + ue(ph_log2_diff_max_tt_min_qt_inter_slice, 0, FFMIN(6, ctb_log2_size_y) - min_qt_log2_size_inter_y); + } + } else { + infer(ph_log2_diff_min_qt_min_cb_inter_slice, sps->sps_log2_diff_min_qt_min_cb_inter_slice); + min_qt_log2_size_inter_y = current->ph_log2_diff_min_qt_min_cb_inter_slice + ctb_log2_size_y; + infer(ph_max_mtt_hierarchy_depth_inter_slice, sps->sps_max_mtt_hierarchy_depth_inter_slice); + infer(ph_log2_diff_max_bt_min_qt_inter_slice, sps->sps_log2_diff_max_bt_min_qt_inter_slice); + infer(ph_log2_diff_max_tt_min_qt_inter_slice, sps->sps_log2_diff_max_tt_min_qt_inter_slice); + } + + if (pps->pps_cu_qp_delta_enabled_flag) + ue(ph_cu_qp_delta_subdiv_inter_slice, 0, 2 * ( ctb_log2_size_y - min_qt_log2_size_inter_y + current->ph_max_mtt_hierarchy_depth_inter_slice)); + else + infer(ph_cu_qp_delta_subdiv_inter_slice, 0); + + if(pps->pps_cu_chroma_qp_offset_list_enabled_flag) + ue(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0, 2 * (ctb_log2_size_y - min_qt_log2_size_inter_y + current->ph_max_mtt_hierarchy_depth_inter_slice)); + else + infer(ph_cu_chroma_qp_offset_subdiv_inter_slice, 0); + if (sps->sps_temporal_mvp_enabled_flag) { + flag(ph_temporal_mvp_enabled_flag); + if (current->ph_temporal_mvp_enabled_flag && pps->pps_rpl_info_in_ph_flag) { + if (current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0) + flag(ph_collocated_from_l0_flag); + else + infer(ph_collocated_from_l0_flag, 1); + if ((current->ph_collocated_from_l0_flag && + current->ph_ref_pic_lists.rpl_ref_list[0].num_ref_entries > 1) || + (!current->ph_collocated_from_l0_flag && + current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 1)) { + unsigned int idx = current->ph_collocated_from_l0_flag ? 0 : 1; + ue(ph_collocated_ref_idx, 0, current->ph_ref_pic_lists.rpl_ref_list[idx].num_ref_entries - 1); + } else { + infer(ph_collocated_ref_idx, 0); + } + } + if(sps->sps_mmvd_fullpel_only_enabled_flag) + flag(ph_mmvd_fullpel_only_flag); + else + infer(ph_mmvd_fullpel_only_flag, 0); + if (!pps->pps_rpl_info_in_ph_flag || current->ph_ref_pic_lists.rpl_ref_list[1].num_ref_entries > 0) { + flag(ph_mvd_l1_zero_flag); + if (sps->sps_bdof_control_present_in_ph_flag) { + flag(ph_bdof_disabled_flag); + } else { + if (!sps->sps_bdof_control_present_in_ph_flag) + infer(ph_bdof_disabled_flag, 1 - sps->sps_bdof_enabled_flag); + else + infer(ph_bdof_disabled_flag, 1); + } + if (sps->sps_dmvr_control_present_in_ph_flag) { + flag(ph_dmvr_disabled_flag); + } else { + if (!sps->sps_dmvr_control_present_in_ph_flag) + infer(ph_dmvr_disabled_flag, 1 - sps->sps_dmvr_enabled_flag); + else + infer(ph_dmvr_disabled_flag, 1); + } + } else { + infer(ph_mvd_l1_zero_flag, 1); + } + if (sps->sps_prof_control_present_in_ph_flag) + flag(ph_prof_disabled_flag); + else + infer(ph_prof_disabled_flag, !sps->sps_affine_prof_enabled_flag); + if((pps->pps_weighted_pred_flag || pps->pps_weighted_bipred_flag) && + pps->pps_wp_info_in_ph_flag) { + return AVERROR_PATCHWELCOME; + } + } + } + + if (pps->pps_qp_delta_info_in_ph_flag) + se(ph_qp_delta, -sps->qp_bd_offset - (26 + pps->pps_init_qp_minus26), 63 - (26 + pps->pps_init_qp_minus26)); + + if (sps->sps_joint_cbcr_enabled_flag) + flag(ph_joint_cbcr_sign_flag); + else + infer(ph_joint_cbcr_sign_flag, 0); + if (sps->sps_sao_enabled_flag && pps->pps_sao_info_in_ph_flag ) { + flag(ph_sao_luma_enabled_flag); + if (sps->sps_chroma_format_idc) + flag(ph_sao_chroma_enabled_flag); + else + infer(ph_sao_chroma_enabled_flag, 0); + } else { + infer(ph_sao_luma_enabled_flag, 0); + infer(ph_sao_chroma_enabled_flag, 0); + } + + if(pps->pps_dbf_info_in_ph_flag) { + return AVERROR_PATCHWELCOME; + } + if(pps->pps_picture_header_extension_present_flag) { + return AVERROR_PATCHWELCOME; + } + h266->active_ph = current; + return 0; +} + +static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawSliceHeader *current) +{ + CodedBitstreamH266Context *h266 = ctx->priv_data; + const H266RawSPS *sps; + const H266RawPPS *pps; + const H266RawPH *ph; + const H266RefPicLists* ref_pic_lists; + int err, i; + uint8_t nal_unit_type; + + HEADER("Slice Header"); + + CHECK(FUNC(nal_unit_header)(ctx, rw, ¤t->nal_unit_header, -1)); + + flag(sh_picture_header_in_slice_header_flag); + if (current->sh_picture_header_in_slice_header_flag){ + CHECK(FUNC(picture_header)(ctx, rw, &h266->ph)); + } + sps = h266->active_sps; + pps = h266->active_pps; + ph = &h266->ph; + + if (!sps || !pps) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "no sps(%p) or pps(%p).\n", sps, pps); + return AVERROR_INVALIDDATA; + } + + if(sps->sps_subpic_info_present_flag) + ub(sps->sps_subpic_id_len_minus1 + 1, sh_subpic_id); + if (pps->pps_rect_slice_flag) + return AVERROR_PATCHWELCOME; + if((!pps->pps_rect_slice_flag && pps->num_tiles_in_pic > 1)) { + unsigned int bits, max; + if (!pps->pps_rect_slice_flag) { + bits = ceil(log2(pps->num_tiles_in_pic)); + max = pps->num_tiles_in_pic - 1; + } else { + return AVERROR_PATCHWELCOME; + } + u(bits, sh_slice_address, 0, max); + } else { + infer(sh_slice_address, 0); + } + + for (i = 0; i < sps->num_extra_sh_bits; i++) { + flags(sh_extra_bit[i], 1, i); + } + + if (!pps->pps_rect_slice_flag && pps->num_tiles_in_pic - current->sh_slice_address > 1) + ue(sh_num_tiles_in_slice_minus1, 0, pps->num_tiles_in_pic - 1); + else + infer(sh_num_tiles_in_slice_minus1, 0); + + if (ph->ph_inter_slice_allowed_flag) + ue(sh_slice_type, 0, 2); + else + infer(sh_slice_type, 2); + + nal_unit_type = current->nal_unit_header.nal_unit_type; + if (nal_unit_type == H266_NAL_IDR_W_RADL || + nal_unit_type == H266_NAL_IDR_N_LP || + nal_unit_type == H266_NAL_CRA_NUT || + nal_unit_type == H266_NAL_GDR_NUT) + flag(sh_no_output_of_prior_pics_flag); + if(sps->sps_alf_enabled_flag && !pps->pps_alf_info_in_ph_flag) { + flag(sh_alf_enabled_flag); + if (current->sh_alf_enabled_flag) { + ub(3, sh_num_alf_aps_ids_luma); + for (i = 0; i < current->sh_num_alf_aps_ids_luma; i++ ) + ubs(3, sh_alf_aps_id_luma[i], 1, i); + if (sps->sps_chroma_format_idc != 0) { + flag(sh_alf_cb_enabled_flag); + flag(sh_alf_cr_enabled_flag); + } else { + infer(sh_alf_cb_enabled_flag, ph->ph_alf_cb_enabled_flag); + infer(sh_alf_cr_enabled_flag, ph->ph_alf_cr_enabled_flag); + } + if(current->sh_alf_cb_enabled_flag || current->sh_alf_cr_enabled_flag) + ub(3, sh_alf_aps_id_chroma); + else + infer(sh_alf_aps_id_chroma, ph->ph_alf_aps_id_chroma); + if(sps->sps_ccalf_enabled_flag ) { + flag(sh_alf_cc_cb_enabled_flag); + if(current->sh_alf_cc_cb_enabled_flag) + ub(3, sh_alf_cc_cb_aps_id); + else + infer(sh_alf_cc_cb_aps_id, ph->ph_alf_cc_cb_aps_id); + flag(sh_alf_cc_cr_enabled_flag); + if(current->sh_alf_cc_cr_enabled_flag) + ub(3, sh_alf_cc_cr_aps_id); + else + infer(sh_alf_cc_cr_aps_id, ph->ph_alf_cc_cr_aps_id); + } else { + infer(sh_alf_cc_cb_enabled_flag, ph->ph_alf_cc_cb_enabled_flag); + infer(sh_alf_cc_cr_enabled_flag, ph->ph_alf_cc_cr_enabled_flag); + infer(sh_alf_cc_cb_aps_id, ph->ph_alf_cc_cb_aps_id); + infer(sh_alf_cc_cr_aps_id, ph->ph_alf_cc_cr_aps_id); + } + } + } else { + infer(sh_alf_enabled_flag, 0); + } + + if (ph->ph_lmcs_enabled_flag && !current->sh_picture_header_in_slice_header_flag ) + flag(sh_lmcs_used_flag); + else + infer(sh_lmcs_used_flag, 0); + + if (ph->ph_explicit_scaling_list_enabled_flag && !current->sh_picture_header_in_slice_header_flag) + flag(sh_explicit_scaling_list_used_flag); + else + infer(sh_explicit_scaling_list_used_flag, 0); + + if(!pps->pps_rpl_info_in_ph_flag && + ((nal_unit_type != H266_NAL_IDR_W_RADL && nal_unit_type != H266_NAL_IDR_N_LP) || + sps->sps_idr_rpl_present_flag)) { + CHECK(FUNC(ref_pic_lists)(ctx, rw, ¤t->sh_ref_pic_lists)); + ref_pic_lists = ¤t->sh_ref_pic_lists; + } else { + ref_pic_lists = &h266->ph.ph_ref_pic_lists; + } + if ((current->sh_slice_type != H266_SLICE_I && ref_pic_lists->rpl_ref_list[0].num_ref_entries > 1) || + (current->sh_slice_type == H266_SLICE_B && ref_pic_lists->rpl_ref_list[1].num_ref_entries > 1)) { + flag(sh_num_ref_idx_active_override_flag); + if (current->sh_num_ref_idx_active_override_flag) { + for( i = 0; i < (current->sh_slice_type == H266_SLICE_B ? 2: 1 ); i++ ) + if(ref_pic_lists->rpl_ref_list[i].num_ref_entries > 1) + ues(sh_num_ref_idx_active_minus1[i], 0, 14, 1, i); + else + infer(sh_num_ref_idx_active_minus1[i], 0); + } + } else { + infer(sh_num_ref_idx_active_override_flag, 1); + } + if (current->sh_slice_type != H266_SLICE_I) { + if (pps->pps_cabac_init_present_flag) + flag(sh_cabac_init_flag); + else + infer(sh_cabac_init_flag, 0); + if (ph->ph_temporal_mvp_enabled_flag && !pps->pps_rpl_info_in_ph_flag) { + if (current->sh_slice_type == H266_SLICE_B) + flag(sh_collocated_from_l0_flag); + else + infer(sh_collocated_from_l0_flag, 1); + if((current->sh_collocated_from_l0_flag && ref_pic_lists->rpl_ref_list[0].num_ref_entries > 1) || + (!current->sh_collocated_from_l0_flag && ref_pic_lists->rpl_ref_list[0].num_ref_entries > 1)) { + unsigned int idx = current->sh_collocated_from_l0_flag ? 0 : 1; + ue(sh_collocated_ref_idx, 0, ref_pic_lists->rpl_ref_list[idx].num_ref_entries - 1); + } else { + infer(sh_collocated_ref_idx, 0); + } + if(!pps->pps_wp_info_in_ph_flag && + ((pps->pps_weighted_pred_flag && current->sh_slice_type == H266_SLICE_P) || + (pps->pps_weighted_bipred_flag && current->sh_slice_type == H266_SLICE_B))) + return AVERROR_PATCHWELCOME; + } + + } + if(!pps->pps_qp_delta_info_in_ph_flag ) + se(sh_qp_delta, -sps->qp_bd_offset - (26 + pps->pps_init_qp_minus26), 63 - (26 + pps->pps_init_qp_minus26)); + if(pps->pps_slice_chroma_qp_offsets_present_flag) { + return AVERROR_PATCHWELCOME; + } + if(pps->pps_cu_chroma_qp_offset_list_enabled_flag) + flag(sh_cu_chroma_qp_offset_enabled_flag); + else + infer(sh_cu_chroma_qp_offset_enabled_flag, 0); + if (sps->sps_sao_enabled_flag && !pps->pps_sao_info_in_ph_flag) { + flag(sh_sao_luma_used_flag); + if (sps->sps_chroma_format_idc != 0) + flag(sh_sao_chroma_used_flag); + else + infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag); + } else { + infer(sh_sao_luma_used_flag, ph->ph_sao_luma_enabled_flag); + infer(sh_sao_chroma_used_flag, ph->ph_sao_chroma_enabled_flag); + } + + if(pps->pps_deblocking_filter_override_enabled_flag && !pps->pps_dbf_info_in_ph_flag ) + flag(sh_deblocking_params_present_flag); + else + infer(sh_deblocking_params_present_flag, 0); + if (current->sh_deblocking_params_present_flag) { + return AVERROR_PATCHWELCOME; + } + + if(sps->sps_dep_quant_enabled_flag) + flag(sh_dep_quant_used_flag); + else + infer(sh_dep_quant_used_flag, 0); + + if(sps->sps_sign_data_hiding_enabled_flag && !current->sh_dep_quant_used_flag) + flag(sh_sign_data_hiding_used_flag); + else + infer(sh_sign_data_hiding_used_flag, 0); + + if(sps->sps_transform_skip_enabled_flag && !current->sh_dep_quant_used_flag && !current->sh_sign_data_hiding_used_flag) + flag(sh_ts_residual_coding_disabled_flag); + else + infer(sh_ts_residual_coding_disabled_flag, 0); + if(pps->pps_slice_header_extension_present_flag) { + return AVERROR_PATCHWELCOME; + } + if(sps->sps_entry_point_offsets_present_flag) { + unsigned int num_entry_points = 0; + if (pps->pps_rect_slice_flag) { + return AVERROR_PATCHWELCOME; + } else { + unsigned int tile_idx; + for (tile_idx = current->sh_slice_address; tile_idx <= current->sh_slice_address + current->sh_num_tiles_in_slice_minus1; tile_idx++) { + unsigned int tile_y, height; + tile_y = tile_idx / pps->num_tile_rows; + height = pps->pps_tile_row_height_minus1[FFMIN(tile_y, pps->pps_num_exp_tile_rows_minus1)] + 1; + num_entry_points += (sps->sps_entropy_coding_sync_enabled_flag ? height : 1); + } + num_entry_points--; + } + infer(num_entry_point_offsets, num_entry_points); + if (num_entry_points > H266_MAX_ENTRY_POINT_OFFSETS) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many entry points: " + "%"PRIu16".\n", current->num_entry_point_offsets); + return AVERROR_PATCHWELCOME; + } + if (num_entry_points > 0) { + ue(sh_entry_offset_len_minus1, 0, 31); + for (i = 0; i < num_entry_points; i++) { + ubs(current->sh_entry_offset_len_minus1, sh_entry_point_offset_minus1[i], 1, i); + } + } + } + CHECK(FUNC(byte_alignment)(ctx, rw)); + + return 0; +} + +static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw, + H266RawSEI *current, int prefix) +{ + return 0; +} diff --git a/libavcodec/cbs_internal.h b/libavcodec/cbs_internal.h index faa847aad3..fadbbd702e 100644 --- a/libavcodec/cbs_internal.h +++ b/libavcodec/cbs_internal.h @@ -198,6 +198,7 @@ int ff_cbs_write_signed(CodedBitstreamContext *ctx, PutBitContext *pbc, extern const CodedBitstreamType ff_cbs_type_av1; extern const CodedBitstreamType ff_cbs_type_h264; extern const CodedBitstreamType ff_cbs_type_h265; +extern const CodedBitstreamType ff_cbs_type_h266; extern const CodedBitstreamType ff_cbs_type_jpeg; extern const CodedBitstreamType ff_cbs_type_mpeg2; extern const CodedBitstreamType ff_cbs_type_vp9; From patchwork Mon Dec 21 06:07:09 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nuo Mi X-Patchwork-Id: 24602 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 0D1EF44A752 for ; Mon, 21 Dec 2020 08:14:55 +0200 (EET) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id E595968AD3C; Mon, 21 Dec 2020 08:14:54 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pj1-f46.google.com (mail-pj1-f46.google.com [209.85.216.46]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id F016368ABC8 for ; Mon, 21 Dec 2020 08:14:47 +0200 (EET) Received: by mail-pj1-f46.google.com with SMTP id b5so5838224pjk.2 for ; Sun, 20 Dec 2020 22:14:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ACa+nAF5Hdnbao124bYP83OPXjH8vMQpgTS/UwLrckY=; b=Gl1OLxhsadQNXj6FFjLlaKe2dIqhblftgdMR2NmcKMudUDNe/PE7ORAHsvXWIV9p7A e1Gj5G7QHM1NCCeZDvTnVTZ2Hsar8dcyKub6UDa/hNlOQzopHj2h2ukKh6cj+ME2i6Wv Kroi6XRqB3E2KvZczM2Is2Vt0sc/HDRh+Csf+zweN0PlcJlA/1KuRQ7IJSEoRzlyYHJs rmOCg0GVrp6N41jqLfSxWhuiVfc1gnzieAPuvSTUuyFSEgMVBwRY/zlKM+nyMLyDW93S JkwcMFS7v7l5aajbFt2O8nAf6tuNkHRCXlpONzA3UmPXqVTvCE6fStvQmxe5DgfHS765 Jf2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ACa+nAF5Hdnbao124bYP83OPXjH8vMQpgTS/UwLrckY=; b=LWmSGnQ+deVn9jZcr/DNNtpvBFGN+PO9N52W+XoUHpYWDphiHnZTmYBPVxMAUJZNJS Kk/lK4J1bFn45b+E9Cj4gulBfkYFdsw0LXIIbXnH5pX+RyO1xQmX0P5mQ8q4itAz+8Oa aDnYcRUIK5PmeUda+6dkfk4TUoZuPZpBoDOIh+BC5O+z4fsweXUEVrvvHwbzAVYaCMKV y25IDGGITTOCb9XCHy5MHLD/cfaAAYVNyYj1p/jnu/ZoE/q0WGgTx7CtveEBI2+TdUKW vw+8w1eH2IBRh5LadKHKGqOTFfiznxwYc2KCChtdK8j8Pz/MfJ0mzBJjQqOGYiPYwZ8C veFQ== X-Gm-Message-State: AOAM5318BI0IzIrFTfcnvwTSSifR/m4UoZKGfooIP0doBY336kgscWJM oykNxTWFQg0r2duk7EbW972eHp51kTOiSg== X-Google-Smtp-Source: ABdhPJwl8vGwS+faZLJPd2cZk91Jbp3odWySdiocThqbD2xVAVTBNyLgdlY1GhwlvHhDfgHVg1/B2Q== X-Received: by 2002:aa7:9501:0:b029:155:3b11:d5c4 with SMTP id b1-20020aa795010000b02901553b11d5c4mr14029970pfp.76.1608530907505; Sun, 20 Dec 2020 22:08:27 -0800 (PST) Received: from Guangxin-PC.localdomain (23.83.245.51.16clouds.com. [23.83.245.51]) by smtp.gmail.com with ESMTPSA id h10sm11485061pfn.213.2020.12.20.22.08.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 20 Dec 2020 22:08:27 -0800 (PST) From: Nuo Mi To: ffmpeg-devel@ffmpeg.org Date: Mon, 21 Dec 2020 14:07:09 +0800 Message-Id: <20201221060710.12230-5-nuomi2021@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201221060710.12230-1-nuomi2021@gmail.com> References: <20201221060710.12230-1-nuomi2021@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH 5/6] avcodec: add h266 parser X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Nuo Mi Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" --- configure | 3 + libavcodec/Makefile | 1 + libavcodec/h2645_parse.c | 73 +++++++++- libavcodec/h266_parser.c | 284 +++++++++++++++++++++++++++++++++++++++ libavcodec/parsers.c | 1 + 5 files changed, 360 insertions(+), 2 deletions(-) create mode 100644 libavcodec/h266_parser.c diff --git a/configure b/configure index 90914752f1..77272948e3 100755 --- a/configure +++ b/configure @@ -2354,6 +2354,7 @@ CONFIG_EXTRA=" cbs_av1 cbs_h264 cbs_h265 + cbs_h266 cbs_jpeg cbs_mpeg2 cbs_vp9 @@ -2622,6 +2623,7 @@ threads_if_any="$THREADS_LIST" cbs_av1_select="cbs" cbs_h264_select="cbs" cbs_h265_select="cbs" +cbs_h266_select="cbs" cbs_jpeg_select="cbs" cbs_mpeg2_select="cbs" cbs_vp9_select="cbs" @@ -3158,6 +3160,7 @@ av1_qsv_decoder_select="qsvdec" aac_parser_select="adts_header" av1_parser_select="cbs_av1" h264_parser_select="atsc_a53 golomb h264dsp h264parse" +h266_parser_select="cbs_h266" hevc_parser_select="hevcparse" mpegaudio_parser_select="mpegaudioheader" mpegvideo_parser_select="mpegvideo" diff --git a/libavcodec/Makefile b/libavcodec/Makefile index 4045c002b7..82cc9b8b93 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -1098,6 +1098,7 @@ OBJS-$(CONFIG_GSM_PARSER) += gsm_parser.o OBJS-$(CONFIG_H261_PARSER) += h261_parser.o OBJS-$(CONFIG_H263_PARSER) += h263_parser.o OBJS-$(CONFIG_H264_PARSER) += h264_parser.o h264_sei.o h264data.o +OBJS-$(CONFIG_H266_PARSER) += h266_parser.o OBJS-$(CONFIG_HEVC_PARSER) += hevc_parser.o hevc_data.o OBJS-$(CONFIG_IPU_PARSER) += ipu_parser.o OBJS-$(CONFIG_JPEG2000_PARSER) += jpeg2000_parser.o diff --git a/libavcodec/h2645_parse.c b/libavcodec/h2645_parse.c index 0f98b49fbe..2600371d3c 100644 --- a/libavcodec/h2645_parse.c +++ b/libavcodec/h2645_parse.c @@ -29,6 +29,7 @@ #include "bytestream.h" #include "hevc.h" #include "h264.h" +#include "h266.h" #include "h2645_parse.h" int ff_h2645_extract_rbsp(const uint8_t *src, int length, @@ -146,6 +147,47 @@ nsc: return si; } +static const char *h266_nal_type_name[64] = { + "TRAIL", //H266_NAL_TRAIL + "STSA", //H266_NAL_STSA + "RADL", //H266_NAL_RADL + "RASL", //H266_NAL_RASL + "RSV_VCL_4", //H266_NAL_RSV_VCL_4 + "RSV_VCL_5", //H266_NAL_RSV_VCL_5 + "RSV_VCL_6", //H266_NAL_RSV_VCL_6 + "IDR_W_RAD", //H266_NAL_IDR_W_RADL + "IDR_N_LP", //H266_NAL_IDR_N_LP + "CRA_NUT", //H266_NAL_CRA_NUT + "GDR_NUT", //H266_NAL_GDR_NUT + "RSV_IRAP_11", //H266_NAL_RSV_IRAP_11 + "OPI", //H266_NAL_OPI + "DCI", //H266_NAL_DCI + "VPS", //H266_NAL_VPS + "SPS", //H266_NAL_SPS + "PPS", //H266_NAL_PPS + "PREFIX_AP", //H266_NAL_PREFIX_APS + "SUFFIX_AP", //H266_NAL_SUFFIX_APS + "PH", //H266_NAL_PH + "AUD", //H266_NAL_AUD + "EOS_NUT", //H266_NAL_EOS_NUT + "EOB_NUT", //H266_NAL_EOB_NUT + "PREFIX_SE", //H266_NAL_PREFIX_SEI + "SUFFIX_SE", //H266_NAL_SUFFIX_SEI + "FD_NUT", //H266_NAL_FD_NUT + "RSV_NVCL_26", //H266_NAL_RSV_NVCL_26 + "RSV_NVCL_27", //H266_NAL_RSV_NVCL_27 + "UNSPEC_28", //H266_NAL_UNSPEC_28 + "UNSPEC_29", //H266_NAL_UNSPEC_29 + "UNSPEC_30", //H266_NAL_UNSPEC_30 + "UNSPEC_31", //H266_NAL_UNSPEC_31 +}; + +static const char *h266_nal_unit_name(int nal_type) +{ + av_assert0(nal_type >= 0 && nal_type < 32); + return h266_nal_type_name[nal_type]; +} + static const char *hevc_nal_type_name[64] = { "TRAIL_N", // HEVC_NAL_TRAIL_N "TRAIL_R", // HEVC_NAL_TRAIL_R @@ -289,6 +331,32 @@ static int get_bit_length(H2645NAL *nal, int skip_trailing_zeros) * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit, * 0 otherwise */ +static int h266_parse_nal_header(H2645NAL *nal, void *logctx) +{ + GetBitContext *gb = &nal->gb; + + if (get_bits1(gb) != 0) //forbidden_zero_bit + return AVERROR_INVALIDDATA; + + if (get_bits1(gb) != 0) //nuh_reserved_zero_bit + return AVERROR_INVALIDDATA; + + nal->nuh_layer_id = get_bits(gb, 6); + nal->type = get_bits(gb, 5); + nal->temporal_id = get_bits(gb, 3) - 1; + if (nal->temporal_id < 0) + return AVERROR_INVALIDDATA; + + if ((nal->type >= H266_NAL_IDR_W_RADL && nal->type <= H266_NAL_RSV_IRAP_11) && nal->temporal_id) + return AVERROR_INVALIDDATA; + + av_log(logctx, AV_LOG_DEBUG, + "nal_unit_type: %d(%s), nuh_layer_id: %d, temporal_id: %d\n", + nal->type, h266_nal_unit_name(nal->type), nal->nuh_layer_id, nal->temporal_id); + + return 0; +} + static int hevc_parse_nal_header(H2645NAL *nal, void *logctx) { GetBitContext *gb = &nal->gb; @@ -503,8 +571,9 @@ int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, /* Reset type in case it contains a stale value from a previously parsed NAL */ nal->type = 0; - - if (codec_id == AV_CODEC_ID_HEVC) + if (codec_id == AV_CODEC_ID_H266) + ret = h266_parse_nal_header(nal, logctx); + else if (codec_id == AV_CODEC_ID_HEVC) ret = hevc_parse_nal_header(nal, logctx); else ret = h264_parse_nal_header(nal, logctx); diff --git a/libavcodec/h266_parser.c b/libavcodec/h266_parser.c new file mode 100644 index 0000000000..e472e51d59 --- /dev/null +++ b/libavcodec/h266_parser.c @@ -0,0 +1,284 @@ +/* + * h266 parser + * + * Copyright (C) 2029 Nuo Mi + * + * 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 "cbs.h" +#include "cbs_h266.h" +#include "internal.h" +#include "parser.h" + +#define START_CODE 0x000001 ///< start_code_prefix_one_3bytes + +#define IS_SLICE(nut) (nut <= H266_NAL_RASL || (nut >= H266_NAL_IDR_W_RADL && nut <= H266_NAL_GDR_NUT)) + +typedef struct H266ParserContext { + ParseContext pc; + CodedBitstreamContext *cbc; + CodedBitstreamFragment picture_unit; + int parsed_extradata; +} H266ParserContext; + +static const enum AVPixelFormat pix_fmts_8bit[] = { + AV_PIX_FMT_GRAY8, AV_PIX_FMT_YUV420P, + AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P +}; + +static const enum AVPixelFormat pix_fmts_10bit[] = { + AV_PIX_FMT_GRAY10, AV_PIX_FMT_YUV420P10, + AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10 +}; + +static int get_format(const H266RawSPS* sps) +{ + switch (sps->sps_bitdepth_minus8) { + case 0: + return pix_fmts_8bit[sps->sps_chroma_format_idc]; + case 2: + return pix_fmts_10bit[sps->sps_chroma_format_idc]; + } + return AV_PIX_FMT_NONE; +} + +/** + * Find the end of the current frame in the bitstream. + * @return the position of the first byte of the next frame, or END_NOT_FOUND + */ +static int find_frame_end(AVCodecParserContext *s, const uint8_t *buf, + int buf_size) +{ + H266ParserContext *ctx = s->priv_data; + ParseContext *pc = &ctx->pc; + int i; + + for (i = 0; i < buf_size; i++) { + int nut; + + pc->state64 = (pc->state64 << 8) | buf[i]; + + if (((pc->state64 >> 3 * 8) & 0xFFFFFF) != START_CODE) + continue; + + nut = (pc->state64 >> (8 + 3)) & 0x1F; + // Beginning of access unit + if ((nut >= H266_NAL_OPI && nut <= H266_NAL_EOB_NUT && nut != H266_NAL_PH) || + nut == H266_NAL_PREFIX_SEI || + (nut >= 26 && nut <= 31)) { + if (pc->frame_start_found) { + pc->frame_start_found = 0; + return i - 5; + } + } else if (nut == H266_NAL_PH || IS_SLICE(nut)) { + int sh_picture_header_in_slice_header_flag = buf[i] >> 7; + + if (nut == H266_NAL_PH || sh_picture_header_in_slice_header_flag) { + if (!pc->frame_start_found) { + pc->frame_start_found = 1; + } else { // First slice of next frame found + pc->frame_start_found = 0; + return i - 5; + } + } + } + } + return END_NOT_FOUND; +} + +static int get_pict_type(const CodedBitstreamFragment *pu) +{ + int has_p = 0; + for (int i = 0; i < pu->nb_units; i++) { + CodedBitstreamUnit *unit = &pu->units[i]; + if (IS_SLICE(unit->type)) { + const H266RawSlice *slice = unit->content; + uint8_t type = slice->header.sh_slice_type; + if (type == H266_SLICE_B) { + return AV_PICTURE_TYPE_B; + } + if (type == H266_SLICE_P) { + has_p = 1; + } + } + } + return has_p ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; +} + +/** + * Parse NAL units of found picture and decode some basic information. + * + * @param s parser context. + * @param avctx codec context. + * @param buf buffer with field/frame data. + * @param buf_size size of the buffer. + */ +static int parse_nal_units(AVCodecParserContext *ctx, const uint8_t *buf, + int buf_size, AVCodecContext *avctx) +{ + H266ParserContext *s = ctx->priv_data; + CodedBitstreamFragment *pu = &s->picture_unit; + CodedBitstreamH266Context *h266 = s->cbc->priv_data; + const H266RawSPS *sps; + const H266RawPPS *pps; + const H266RawPH *ph; + int ret, num = 0, den = 0; + + /* set some sane default values */ + ctx->pict_type = AV_PICTURE_TYPE_I; + ctx->key_frame = 0; + ctx->picture_structure = AV_PICTURE_STRUCTURE_FRAME; + + s->cbc->log_ctx = avctx; + + if (avctx->extradata_size && !s->parsed_extradata) { + s->parsed_extradata = 1; + + if ((ret = ff_cbs_read(s->cbc, pu, avctx->extradata, avctx->extradata_size)) < 0) + av_log(avctx, AV_LOG_WARNING, "Failed to parse extradata.\n"); + + ff_cbs_fragment_reset(pu); + } + + if ((ret = ff_cbs_read(s->cbc, pu, buf, buf_size))< 0) { + av_log(avctx, AV_LOG_ERROR, "Failed to parse picture unit.\n"); + goto end; + } + + sps = h266->active_sps; + pps = h266->active_pps; + ph = h266->active_ph; + if (!h266->active_pps || !h266->active_ph) { + av_log(avctx, AV_LOG_ERROR, "No pss or ph header available\n"); + goto end; + } + + ctx->key_frame = ph->ph_gdr_or_irap_pic_flag; + + ctx->coded_width = pps->pps_pic_width_in_luma_samples; + ctx->coded_height = pps->pps_pic_height_in_luma_samples; + ctx->width = pps->pps_pic_width_in_luma_samples - pps->pps_conf_win_left_offset - pps->pps_conf_win_right_offset; + ctx->height = pps->pps_pic_height_in_luma_samples - pps->pps_conf_win_top_offset - pps->pps_conf_win_bottom_offset; + ctx->pict_type = get_pict_type(pu); + ctx->format = get_format(sps); + avctx->profile = sps->profile_tier_level.general_profile_idc; + avctx->level = sps->profile_tier_level.general_level_idc; + + + + if(sps->sps_ptl_dpb_hrd_params_present_flag && sps->sps_timing_hrd_params_present_flag) { + num = sps->sps_general_timing_hrd_parameters.num_units_in_tick; + den = sps->sps_general_timing_hrd_parameters.time_scale; + } else { + av_log(avctx, AV_LOG_INFO, "No sps_timing_hrd_params_present_flag in sps, the fps may not right.\n"); + goto end; + } + if (num != 0 && den != 0) + av_reduce(&avctx->framerate.den, &avctx->framerate.num, + num, den, 1 << 30); +end: + + ff_cbs_fragment_reset(pu); + s->cbc->log_ctx = NULL; + return 0; +} + +static int h266_parser_parse(AVCodecParserContext *s, AVCodecContext *avctx, + const uint8_t **poutbuf, int *poutbuf_size, + const uint8_t *buf, int buf_size) +{ + int next; + H266ParserContext *ctx = s->priv_data; + ParseContext *pc = &ctx->pc; + int is_dummy_buf = !buf_size; + const uint8_t *dummy_buf = buf; + + if (avctx->extradata && !ctx->parsed_extradata) { + av_log(avctx, AV_LOG_INFO, "extra data is not supported yet.\n"); + return AVERROR_PATCHWELCOME; + } + + if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { + next = buf_size; + } else { + next = find_frame_end(s, buf, buf_size); + if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { + *poutbuf = NULL; + *poutbuf_size = 0; + return buf_size; + } + } + + is_dummy_buf &= (dummy_buf == buf); + + if (!is_dummy_buf) + parse_nal_units(s, buf, buf_size, avctx); + + *poutbuf = buf; + *poutbuf_size = buf_size; + return next; + +} + +static const CodedBitstreamUnitType decompose_unit_types[] = { + H266_NAL_TRAIL, + H266_NAL_STSA, + H266_NAL_RADL, + H266_NAL_RASL, + H266_NAL_IDR_W_RADL, + H266_NAL_IDR_N_LP, + H266_NAL_CRA_NUT, + H266_NAL_GDR_NUT, + H266_NAL_VPS, + H266_NAL_SPS, + H266_NAL_PPS, + H266_NAL_PH, + H266_NAL_AUD, +}; + +static av_cold int h266_parser_init(AVCodecParserContext *ctx) +{ + H266ParserContext *s = ctx->priv_data; + int ret; + + ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_VVC, NULL); + if (ret < 0) + return ret; + + s->cbc->decompose_unit_types = (CodedBitstreamUnitType *)decompose_unit_types; + s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types); + + return 0; +} + +static void h266_parser_close(AVCodecParserContext *ctx) +{ + H266ParserContext *s = ctx->priv_data; + + ff_cbs_fragment_free(&s->picture_unit); + ff_cbs_close(&s->cbc); + av_freep(&s->pc.buffer); +} + +AVCodecParser ff_h266_parser = { + .codec_ids = { AV_CODEC_ID_VVC }, + .priv_data_size = sizeof(H266ParserContext), + .parser_init = h266_parser_init, + .parser_close = h266_parser_close, + .parser_parse = h266_parser_parse, +}; diff --git a/libavcodec/parsers.c b/libavcodec/parsers.c index 83271d95a3..155aec71aa 100644 --- a/libavcodec/parsers.c +++ b/libavcodec/parsers.c @@ -49,6 +49,7 @@ extern AVCodecParser ff_gsm_parser; extern AVCodecParser ff_h261_parser; extern AVCodecParser ff_h263_parser; extern AVCodecParser ff_h264_parser; +extern AVCodecParser ff_h266_parser; extern AVCodecParser ff_hevc_parser; extern AVCodecParser ff_ipu_parser; extern AVCodecParser ff_jpeg2000_parser; From patchwork Mon Dec 21 06:07:10 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nuo Mi X-Patchwork-Id: 24599 Return-Path: X-Original-To: patchwork@ffaux-bg.ffmpeg.org Delivered-To: patchwork@ffaux-bg.ffmpeg.org Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100]) by ffaux.localdomain (Postfix) with ESMTP id 152D944840F for ; Mon, 21 Dec 2020 08:08:40 +0200 (EET) Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id F2DBB68ACF2; Mon, 21 Dec 2020 08:08:39 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-pg1-f170.google.com (mail-pg1-f170.google.com [209.85.215.170]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id F092568A9FA for ; Mon, 21 Dec 2020 08:08:37 +0200 (EET) Received: by mail-pg1-f170.google.com with SMTP id 15so5726139pgx.7 for ; Sun, 20 Dec 2020 22:08:37 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=FMfsZfSvYBVlblysc3Oo89h5vEQV+Wv8Q/Yn9I6dcVA=; b=DT9+73j3XfERWO/jchXRIfpWIgv+FWxrytTJm2G+t5hotw/SL3seAbcfmCfSNlz0hy SymOHAk1OvXHj+BiSkM8bakF3jTyy0XSfOrpJ0+30ZO5WGg7rgX7xI7sP0PAr5+TICOs r8J2lELZuoHn7pcYTyU6Hfcc6jJ7ibLNxNaG6EOSWIRgQ++VM87W+pe+JbLwFX1wPfgR vXPdvWwB9o84Ec4GNFRA5H+iubpErcZJhlPtbQmGjKMhYbFIt+EBkkipvgZkuOoVzn9U QSwTgzE+mXxD6cRW4vrFNAE6LBk8DIYsFnAVY7CQSUfYATorcZYrWOQWyKlOkf3835rX rcBA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=FMfsZfSvYBVlblysc3Oo89h5vEQV+Wv8Q/Yn9I6dcVA=; b=YeJdKynm+84FAQbqtOvaCM5MjV3DyHSUNiKwFTVhIXgVOK7YeM86Zt9SfFDIdbZtlS B4nVqjfrjw7IA7+JLYxK04TWGgKlzeIIcYwzz0B8v3D7nj8fI/TGAQYgV/TZRHFIUJOy gfMh+X/65eQbiC++c7q6Uo89hJVbZWhaN8R3cli7vAtAVPvxTP3PfUW0HUOxcA8BE4YZ zNGCU3GoNegUbp8724MJ/IczHo5hJ/fwyW1mQkOTd3RogPOGMCd9YySC3eXWGclgTF3w sDE3Vqpvl4PD0suee7gU1vfK/3UmAM0NgJDo+9pUAtaIqHtbtTa0Mle40CQGCjm2OBfH NWAg== X-Gm-Message-State: AOAM532JemE4reK0GzW87jLIRGP0ERiPh/TbCZRBTsu7FsEERRtZ0KV3 tIIdRmW765uLMh30b1lH9IiHT0xtrDrZoQ== X-Google-Smtp-Source: ABdhPJwoEJ82cQTVzzWF3Kc100zGCatOzx82ooOMQYnVdtt2sZfZlMG7ml8oaeFyVGaVQl4of8t/Dg== X-Received: by 2002:a62:c504:0:b029:1a5:b198:18dc with SMTP id j4-20020a62c5040000b02901a5b19818dcmr14265951pfg.79.1608530915835; Sun, 20 Dec 2020 22:08:35 -0800 (PST) Received: from Guangxin-PC.localdomain (23.83.245.51.16clouds.com. [23.83.245.51]) by smtp.gmail.com with ESMTPSA id h10sm11485061pfn.213.2020.12.20.22.08.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 20 Dec 2020 22:08:35 -0800 (PST) From: Nuo Mi To: ffmpeg-devel@ffmpeg.org Date: Mon, 21 Dec 2020 14:07:10 +0800 Message-Id: <20201221060710.12230-6-nuomi2021@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201221060710.12230-1-nuomi2021@gmail.com> References: <20201221060710.12230-1-nuomi2021@gmail.com> MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH 6/6] avcodec: add vvdec H.266/VVC decoder X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Nuo Mi Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" you can download test clips here: https://www.itu.int/wftp3/av-arch/jvet-site/bitstream_exchange/VVC/under_test/VTM-11.0/ 68.48% (163/238) clips are md5 matched with VTM 11: passed: 10b400_A_Bytedance_2.bit 10b400_B_Bytedance_2.bit 8b400_A_Bytedance_2.bit 8b400_B_Bytedance_2.bit 8b420_A_Bytedance_2.bit 8b420_B_Bytedance_2.bit ACTPIC_A_Huawei_3.bit ACTPIC_B_Huawei_3.bit ACTPIC_C_Huawei_3.bit AFF_A_HUAWEI_2.bit AFF_B_HUAWEI_2.bit ALF_A_Huawei_3.bit ALF_B_Huawei_3.bit ALF_C_KDDI_2.bit ALF_D_Qualcomm_2.bit AMVR_A_HHI_3.bit AMVR_B_HHI_3.bit APSALF_A_Qualcomm_2.bit APSLMCS_A_Dolby_3.bit APSLMCS_B_Dolby_3.bit APSLMCS_C_Dolby_2.bit APSMULT_A_MediaTek_3.bit APSMULT_B_MediaTek_3.bit AUD_A_Broadcom_3.bit BCW_A_MediaTek_3.bit BDOF_A_MediaTek_3.bit BDPCM_A_Orange_2.bit CCALF_A_Sharp_3.bit CCALF_B_Sharp_3.bit CCALF_C_Sharp_3.bit CCALF_D_Sharp_3.bit CCLM_A_KDDI_1.bit CIIP_A_MediaTek_3.bit CodingToolsSets_A_Tencent_2.bit CodingToolsSets_B_Tencent_2.bit CodingToolsSets_C_Tencent_2.bit CodingToolsSets_D_Tencent_2.bit CROP_A_Panasonic_3.bit CROP_B_Panasonic_4.bit CST_A_MediaTek_3.bit CTU_A_MediaTek_3.bit CTU_B_MediaTek_3.bit CTU_C_MediaTek_3.bit CUBEMAP_A_MediaTek_3.bit CUBEMAP_B_MediaTek_3.bit CUBEMAP_C_MediaTek_3.bit DEBLOCKING_A_Sharp_3.bit DEBLOCKING_B_Sharp_2.bit DEBLOCKING_C_Huawei_3.bit DEBLOCKING_E_Ericsson_2.bit DMVR_A_Huawei_3.bit DMVR_B_KDDI_3.bit DPB_A_Sharplabs_2.bit DPB_B_Sharplabs_2.bit DQ_A_HHI_3.bit ENT444HIGHTIER_A_Sony_3.bit ENT444HIGHTIER_B_Sony_3.bit ENT444HIGHTIER_C_Sony_3.bit ENT444HIGHTIER_D_Sony_3.bit ENT444MAINTIER_A_Sony_3.bit ENT444MAINTIER_B_Sony_3.bit ENT444MAINTIER_C_Sony_3.bit ENT444MAINTIER_D_Sony_3.bit ENTHIGHTIER_A_Sony_3.bit ENTHIGHTIER_B_Sony_3.bit ENTHIGHTIER_C_Sony_3.bit ENTHIGHTIER_D_Sony_3.bit ENTMAINTIER_A_Sony_3.bit ENTMAINTIER_B_Sony_3.bit ENTMAINTIER_C_Sony_3.bit ENTMAINTIER_D_Sony_3.bit ENTROPY_A_Chipsnmedia_2.bit ENTROPY_A_Qualcomm_2.bit ENTROPY_B_Sharp_2.bit ERP_A_MediaTek_3.bit FILLER_A_Bytedance_1.bit GPM_A_Alibaba_3.bit IBC_A_Tencent_2.bit IBC_B_Tencent_2.bit IBC_C_Tencent_2.bit IBC_D_Tencent_2.bit IP_B_Nokia_1.bit ISP_A_HHI_3.bit ISP_B_HHI_3.bit JCCR_A_Nokia_2.bit JCCR_B_Nokia_2.bit JCCR_C_HHI_3.bit JCCR_E_Nokia_1.bit JCCR_F_Nokia_1.bit LFNST_A_LGE_3.bit LFNST_B_LGE_3.bit LFNST_C_HHI_3.bit LMCS_A_Dolby_3.bit LOSSLESS_B_HHI_3.bit LTRP_A_ERICSSON_2.bit MERGE_A_Qualcomm_2.bit MERGE_B_Qualcomm_2.bit MERGE_C_Qualcomm_2.bit MERGE_D_Qualcomm_2.bit MERGE_E_Qualcomm_2.bit MERGE_F_Qualcomm_2.bit MERGE_G_Qualcomm_2.bit MERGE_H_Qualcomm_2.bit MERGE_I_Qualcomm_2.bit MERGE_J_Qualcomm_2.bit MIP_A_HHI_3.bit MIP_B_HHI_3.bit MPM_A_LGE_3.bit MRLP_A_HHI_2.bit MRLP_B_HHI_2.bit MTS_A_LGE_3.bit MTS_B_LGE_3.bit MTS_LFNST_A_LGE_3.bit MTS_LFNST_B_LGE_3.bit MVCOMP_A_Sharp_2.bit PDPC_A_Qualcomm_3.bit PDPC_B_Qualcomm_3.bit PDPC_C_Qualcomm_2.bit PHSH_B_Sharp_1.bit POC_A_Nokia_1.bit POUT_A_Sharplabs_2.bit PROF_A_Interdigital_3.bit PROF_B_Interdigital_3.bit QTBTT_A_MediaTek_3.bit QUANT_A_Huawei_2.bit QUANT_B_Huawei_2.bit QUANT_C_Huawei_2.bit RPL_A_ERICSSON_2.bit SAO_A_SAMSUNG_3.bit SAO_B_SAMSUNG_3.bit SAO_C_SAMSUNG_3.bit SbTMVP_A_Bytedance_3.bit SbTMVP_B_Bytedance_3.bit SBT_A_HUAWEI_2.bit SCALING_A_InterDigital_1.bit SCALING_B_InterDigital_1.bit SCALING_C_InterDigital_1.bit SDH_A_Dolby_2.bit SMVD_A_HUAWEI_2.bit TEMPSCAL_A_Panasonic_4.bit TEMPSCAL_C_Panasonic_3.bit TILE_A_Nokia_2.bit TILE_B_Nokia_2.bit TILE_C_Nokia_2.bit TILE_D_Nokia_2.bit TILE_E_Nokia_2.bit TILE_F_Nokia_2.bit TMVP_A_Chipsnmedia_3.bit TMVP_B_Chipsnmedia_3.bit TMVP_C_Chipsnmedia_3.bit TMVP_D_Chipsnmedia_3.bit TRANS_A_Chipsnmedia_2.bit TRANS_B_Chipsnmedia_2.bit TRANS_C_Chipsnmedia_2.bit TRANS_D_Chipsnmedia_2.bit WPP_A_Sharp_3.bit WPP_B_Sharp_2.bit WP_A_InterDigital_3.bit WP_B_InterDigital_3.bit WRAP_A_InterDigital_4.bit WRAP_B_InterDigital_4.bit WRAP_C_InterDigital_4.bit --- configure | 5 +- libavcodec/Makefile | 1 + libavcodec/allcodecs.c | 1 + libavcodec/libvvdec.cpp | 244 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 250 insertions(+), 1 deletion(-) create mode 100644 libavcodec/libvvdec.cpp diff --git a/configure b/configure index 77272948e3..1e9a44db31 100755 --- a/configure +++ b/configure @@ -285,6 +285,7 @@ External library support: --enable-libvorbis enable Vorbis en/decoding via libvorbis, native implementation exists [no] --enable-libvpx enable VP8 and VP9 de/encoding via libvpx [no] + --enable-libvvdec enable VVC video encoding via libvvdec [no] --enable-libwebp enable WebP encoding via libwebp [no] --enable-libx264 enable H.264 encoding via x264 [no] --enable-libx265 enable HEVC encoding via x265 [no] @@ -1816,6 +1817,7 @@ EXTERNAL_LIBRARY_LIST=" libvmaf libvorbis libvpx + libvvdec libwebp libxml2 libzimg @@ -3281,6 +3283,7 @@ libvpx_vp8_decoder_deps="libvpx" libvpx_vp8_encoder_deps="libvpx" libvpx_vp9_decoder_deps="libvpx" libvpx_vp9_encoder_deps="libvpx" +libvvdec_decoder_deps="libvvdec" libwebp_encoder_deps="libwebp" libwebp_anim_encoder_deps="libwebp" libx262_encoder_deps="libx262" @@ -6455,7 +6458,7 @@ enabled libvpx && { die "libvpx enabled but no supported decoders found" fi } - +enabled libvvdec && require_pkg_config libvvdec "libvvdec >= 0.1.2" vvdec/version.h VVDEC_VERSION_MAJOR enabled libwebp && { enabled libwebp_encoder && require_pkg_config libwebp "libwebp >= 0.2.0" webp/encode.h WebPGetEncoderVersion enabled libwebp_anim_encoder && check_pkg_config libwebp_anim_encoder "libwebpmux >= 0.4.0" webp/mux.h WebPAnimEncoderOptionsInit; } diff --git a/libavcodec/Makefile b/libavcodec/Makefile index 82cc9b8b93..ebd3781982 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -1059,6 +1059,7 @@ OBJS-$(CONFIG_LIBVPX_VP8_DECODER) += libvpxdec.o OBJS-$(CONFIG_LIBVPX_VP8_ENCODER) += libvpxenc.o OBJS-$(CONFIG_LIBVPX_VP9_DECODER) += libvpxdec.o libvpx.o OBJS-$(CONFIG_LIBVPX_VP9_ENCODER) += libvpxenc.o libvpx.o +OBJS-$(CONFIG_LIBVVDEC_DECODER) += libvvdec.o OBJS-$(CONFIG_LIBWEBP_ENCODER) += libwebpenc_common.o libwebpenc.o OBJS-$(CONFIG_LIBWEBP_ANIM_ENCODER) += libwebpenc_common.o libwebpenc_animencoder.o OBJS-$(CONFIG_LIBX262_ENCODER) += libx264.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index f00d524747..545c38f541 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -752,6 +752,7 @@ extern AVCodec ff_libvpx_vp8_encoder; extern AVCodec ff_libvpx_vp8_decoder; extern AVCodec ff_libvpx_vp9_encoder; extern AVCodec ff_libvpx_vp9_decoder; +extern AVCodec ff_libvvdec_decoder; /* preferred over libwebp */ extern AVCodec ff_libwebp_anim_encoder; extern AVCodec ff_libwebp_encoder; diff --git a/libavcodec/libvvdec.cpp b/libavcodec/libvvdec.cpp new file mode 100644 index 0000000000..73fe13f61e --- /dev/null +++ b/libavcodec/libvvdec.cpp @@ -0,0 +1,244 @@ +/* + * vvdec H.266/VVC decoder + * Copyright (c) 2020 Nuo Mi + * + * 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 + * AV1 decoder support via libaom + */ + +#include "vvdec/vvdec.h" + +extern "C" { + +#include "libavutil/common.h" +#include "libavutil/imgutils.h" +#include "libavutil/internal.h" + +#include "avcodec.h" +#include "h2645_parse.h" +#include "internal.h" +#include "profiles.h" + +typedef struct VVdecContext { + AVCodecContext *avctx; + vvdec::VVDec* vvdec; + + H2645Packet pkt; + int is_nalff; ///< this flag is != 0 if bitstream is encapsulated + ///< as a format defined in 14496-15 + int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) +} VVdecContext; + +} + +static int map_error(int vret) +{ + switch(vret) + { + case vvdec::VVDEC_OK : return 0; + case vvdec::VVDEC_ERR_UNSPECIFIED: return AVERROR_UNKNOWN; + case vvdec::VVDEC_ERR_INITIALIZE: return AVERROR_BUG; + case vvdec::VVDEC_ERR_ALLOCATE: return AVERROR(ENOMEM); + case vvdec::VVDEC_NOT_ENOUGH_MEM: return AVERROR(ENOMEM); + case vvdec::VVDEC_ERR_PARAMETER: return AVERROR(EINVAL); + case vvdec::VVDEC_ERR_NOT_SUPPORTED: return AVERROR(ENOSYS); + case vvdec::VVDEC_ERR_RESTART_REQUIRED: return AVERROR_BUG; + case vvdec::VVDEC_ERR_CPU: return AVERROR(ENOSYS); + case vvdec::VVDEC_TRY_AGAIN: return AVERROR(EAGAIN); + case vvdec::VVDEC_EOF: return AVERROR(EOF); + default: return AVERROR_UNKNOWN; + } +} + +static int check_vret(VVdecContext* s, int vret) { + vvdec::VVDec* vvdec = s->vvdec; + if (vret && vret != vvdec::VVDEC_EOF) { + av_log(s->avctx, AV_LOG_ERROR, "vvdec returns error: %s\n", vvdec->getErrorMsg(vret)); + } + return map_error(vret); +} + +static const enum AVPixelFormat pix_fmts_8bit[] = { + AV_PIX_FMT_GRAY8, AV_PIX_FMT_YUV420P, + AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P +}; + +static const enum AVPixelFormat pix_fmts_10bit[] = { + AV_PIX_FMT_GRAY10, AV_PIX_FMT_YUV420P10, + AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10 +}; + +static AVPixelFormat get_format(const vvdec::Frame* frame) +{ + if (frame->m_eColorFormat != vvdec::VVC_CF_INVALID) { + switch (frame->m_uiBitDepth) { + case 8: + return pix_fmts_8bit[frame->m_eColorFormat]; + case 10: + return pix_fmts_10bit[frame->m_eColorFormat]; + } + } + return AV_PIX_FMT_NONE; +} + +static int set_pix_fmt(VVdecContext* s, const vvdec::Frame* frame) +{ + AVPixelFormat format = get_format(frame); + if (format == AV_PIX_FMT_NONE) { + av_log(s->avctx, AV_LOG_ERROR, + "unsupported, depth = %d, color format = %d.\n", frame->m_uiBitDepth, frame->m_eColorFormat); + return AVERROR_INVALIDDATA; + } + s->avctx->pix_fmt = format; + return 0; +} + +static int copy_to_avframe(VVdecContext* s, const vvdec::Frame* src, AVFrame *dest) +{ + AVCodecContext* avctx = s->avctx; + int i, ret, width, height; + uint8_t *data[4]; + int linesize[4]; + + ret = set_pix_fmt(s, src); + if (ret < 0) + return ret; + width = (int)src->m_uiWidth; + height = (int)src->m_uiHeight; + if (width != avctx->width || height != avctx->height) { + av_log(avctx, AV_LOG_INFO, "dimension change! %dx%d -> %dx%d\n", + avctx->width, avctx->height, width, height); + if ((ret = ff_set_dimensions(avctx, width, height)) < 0) + return ret; + } + if ((ret = ff_get_buffer(avctx, dest, 0)) < 0) + return ret; + + for (i = 0; i < 3; i++) { + const vvdec::Component& plane = src->m_cComponent[i]; + data[i] = plane.m_pucBuffer; + linesize[i] = plane.m_iStride; + } + data[3] = 0; linesize[3] = 0; + + //TODO: conformance window? + av_image_copy(dest->data, dest->linesize, (const uint8_t **)data, linesize, + avctx->pix_fmt, width, height); + return 0; +} + +static int vvdec_decode(AVCodecContext *avctx, void *data, int *got_frame, + AVPacket *avpkt) +{ + VVdecContext *s = (VVdecContext *)avctx->priv_data; + vvdec::VVDec* vvdec = s->vvdec; + AVFrame *picture = (AVFrame*)data; + int vret, ret = 0; + vvdec::Frame* frame = NULL; + + if (!avpkt->size) { + vret = vvdec->flush(&frame); + if ((ret = check_vret(s, vret)) < 0) { + goto error_out; + } + } else { + uint8_t *new_extradata; + int new_extradata_size; + new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, + &new_extradata_size); + if (new_extradata && new_extradata_size > 0) { + return AVERROR_PATCHWELCOME; + } + + vvdec::AccessUnit au; + au.m_pucBuffer = (unsigned char*)avpkt->data; + au.m_iUsedSize = avpkt->size; + au.m_uiCts = avpkt->pts; + au.m_bCtsValid = true; + vret = vvdec->decode(au, &frame); + if (vret && vret != vvdec::VVDEC_TRY_AGAIN) { + if ((ret = check_vret(s, vret)) < 0) { + goto error_out; + } + } + + } + if (frame) { + ret = copy_to_avframe(s, frame, picture); + if (ret < 0) + goto error_out; + *got_frame = 1; + } + return 0; +error_out: + if (frame) { + vvdec->objectUnref(frame); + } + return ret; +} + +static av_cold int vvdec_free(AVCodecContext *avctx) +{ + VVdecContext *ctx = (VVdecContext *)avctx->priv_data; + vvdec::VVDec* vvdec = ctx->vvdec; + if (vvdec) { + vvdec->uninit(); + delete vvdec; + } + return 0; +} + +static av_cold int vvdec_init(AVCodecContext *avctx) +{ + VVdecContext *s = (VVdecContext *)avctx->priv_data; + vvdec::VVDecParameter param; + vvdec::VVDec* vvdec = new vvdec::VVDec; + int vret, ret = 0; + + av_log(avctx, AV_LOG_INFO, "VVDec version: %s\n", vvdec->getVersionNumber()); + + s->avctx = avctx; + s->vvdec = vvdec; + vret = vvdec->init(param); + if ((ret = check_vret(s, vret)) < 0) { + delete vvdec; + s->vvdec = NULL; + } + return ret; +} + +extern "C" { + +AVCodec ff_libvvdec_decoder = { + .name = "vvdec", + .long_name = NULL_IF_CONFIG_SMALL("vvdec vvc decoder"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_H266, + .capabilities = AV_CODEC_CAP_AUTO_THREADS | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, + .profiles = NULL_IF_CONFIG_SMALL(ff_h266_profiles), + .wrapper_name = "libvvdec", + .priv_data_size = sizeof(VVdecContext), + .init = vvdec_init, + .decode = vvdec_decode, + .close = vvdec_free, +}; + +}