diff mbox series

[FFmpeg-devel,v2,06/11] avcodec: add cbs for h266/vvc

Message ID 20210109073421.23721-7-nuomi2021@gmail.com
State New
Headers show
Series add vvc raw demuxer, muxer, parser, metadata bsf, vvdec decoder
Related show

Checks

Context Check Description
andriy/x86_make success Make finished
andriy/x86_make_fate success Make fate finished
andriy/PPC64_make success Make finished
andriy/PPC64_make_fate success Make fate finished

Commit Message

Nuo Mi Jan. 9, 2021, 7:34 a.m. UTC
---
 configure                             |    2 +
 libavcodec/Makefile                   |    1 +
 libavcodec/cbs.c                      |    6 +
 libavcodec/cbs_h2645.c                |  373 ++++
 libavcodec/cbs_h266.h                 |  840 ++++++++
 libavcodec/cbs_h266_syntax_template.c | 2761 +++++++++++++++++++++++++
 libavcodec/cbs_internal.h             |    3 +-
 7 files changed, 3985 insertions(+), 1 deletion(-)
 create mode 100644 libavcodec/cbs_h266.h
 create mode 100644 libavcodec/cbs_h266_syntax_template.c

Comments

Mark Thompson Jan. 9, 2021, 9:28 p.m. UTC | #1
On 09/01/2021 07:34, Nuo Mi wrote:
> ---
>   configure                             |    2 +
>   libavcodec/Makefile                   |    1 +
>   libavcodec/cbs.c                      |    6 +
>   libavcodec/cbs_h2645.c                |  373 ++++
>   libavcodec/cbs_h266.h                 |  840 ++++++++
>   libavcodec/cbs_h266_syntax_template.c | 2761 +++++++++++++++++++++++++
>   libavcodec/cbs_internal.h             |    3 +-
>   7 files changed, 3985 insertions(+), 1 deletion(-)
>   create mode 100644 libavcodec/cbs_h266.h
>   create mode 100644 libavcodec/cbs_h266_syntax_template.c
> 
> ...
> @@ -920,6 +934,135 @@ static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
>       return 0;
>   }
>   
> +static int cbs_h266_replace_ph(CodedBitstreamContext *ctx,
> +                               CodedBitstreamUnit *unit)
> +{
> +    CodedBitstreamH266Context *priv = ctx->priv_data;
> +    int err;
> +    err = ff_cbs_make_unit_refcounted(ctx, unit);
> +    if (err < 0)
> +        return err;
> +    av_buffer_unref(&priv->ph_ref);
> +    av_assert0(unit->content_ref);
> +    priv->ph_ref = av_buffer_ref(unit->content_ref);
> +    if (!priv->ph_ref)
> +        return AVERROR(ENOMEM);
> +    priv->active_ph = priv->ph = (H266RawPH *)priv->ph_ref->data;

Why are there too variables here?  They seem to always be the same.

> +    return 0;
> +}
> +
> ...
> +
>   static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>                                          CodedBitstreamFragment *frag)
>   {
> @@ -1248,6 +1494,11 @@ static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>                (unit->type == HEVC_NAL_VPS ||
>                 unit->type == HEVC_NAL_SPS ||
>                 unit->type == HEVC_NAL_PPS)) ||
> +            (ctx->codec->codec_id == AV_CODEC_ID_VVC &&
> +             (unit->type == VVC_VPS_NUT ||
> +              unit->type == VVC_SPS_NUT ||
> +              unit->type == VVC_PPS_NUT ||
> +              unit->type == VVC_PREFIX_APS_NUT)) ||

Also various other things, which might be here since passthrough does not require decomposition to be implemented.

This test is getting unwieldy - maybe it should be moved to a new function cbs_h2645_unit_requires_zero_byte().

>               i == 0 /* (Assume this is the start of an access unit.) */) {
>               // zero_byte
>               data[dp++] = 0;
> @@ -1362,6 +1613,41 @@ static void cbs_h265_close(CodedBitstreamContext *ctx)
>           av_buffer_unref(&h265->pps_ref[i]);
>   }
>   
> ...
> @@ -1506,6 +1792,77 @@ static const CodedBitstreamUnitTypeDescriptor cbs_h265_unit_types[] = {
>       CBS_UNIT_TYPE_END_OF_LIST
>   };
>   
> +static void cbs_h266_free_sei(void *opaque, uint8_t *content)
> +{
> +}

So as implemented currently it is POD?

> +
> +static const CodedBitstreamUnitTypeDescriptor cbs_h266_unit_types[] = {
> ...
> +
> +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;
> +    
> ...
> +
> +    /* loop filter */
> +    uint8_t gci_no_sao_constraint_flag;
> +    uint8_t gci_no_alf_constraint_flag;
> +    uint8_t gci_no_ccalf_constraint_flag;
> +    uint8_t gci_no_lmcs_constraint_flag;
> +    uint8_t gci_no_ladf_constraint_flag;
> +    uint8_t gci_no_virtual_boundaries_constraint_flag;
> +    uint8_t gci_num_reserved_bits;

Also needs gci_reserved_zero_bit[], so that we can handle streams with future constraints rather than just rejecting them.

"Although the value of gci_num_reserved_bits is required to be equal to 0 in this version
of this Specification, decoders conforming to this version of this Specification shall allow the value of
gci_num_reserved_bits greater than 0 to appear in the syntax and shall ignore the values of all the gci_reserved_zero_bit[ i ]
syntax elements when gci_num_reserved_bits is greater than 0."

> +} H266GeneralConstraintsInfo;
> +
> ...
> +
> +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;

You don't actually use the VPS structure at all, so given that it isn't parsed I think it would be cleaner to just not include it here at all.

> +//
> ...
> +
> +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 {
> +    uint8_t  dph_sei_hash_type;
> +    uint8_t  dph_sei_single_component_flag;
> +    uint8_t  dph_sei_picture_md5[3][16];
> +    uint16_t dph_sei_picture_crc[3];
> +    uint32_t dph_sei_picture_checksum[3];
> +} H266RawSEIDecodedPictureHash;
> +
> +typedef struct H266RawSEITimeCode {
> +} H266RawSEITimeCode;
> +
> +typedef struct H266RawSEIMasteringDisplayColourVolume {
> +} H266RawSEIMasteringDisplayColourVolume;
> +

Don't include all of these empty structures.

(Half of them are implemented in the common SEI patches on the ML now anyway.)

> ...
> +#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..6a6defc8a5
> --- /dev/null
> +++ b/libavcodec/cbs_h266_syntax_template.c
> @@ -0,0 +1,2761 @@
> +/*
> + * 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 H266_CEIL
> +#define H266_CEIL(v, a) (((v) + (a) - 1) / (a))
> +#endif

If it's useful to have this separately then put it in cbs_h2645.c rather than doubled in the template.  (See for example cbs_av1_tile_log2().)

> +
> +#ifndef H266_HAS_MULTI_SLICES_IN_TILE
> +#define H266_HAS_MULTI_SLICES_IN_TILE(pps, tile_y, slice) \
> +    (pps->pps_slice_width_in_tiles_minus1[slice] == 0 && \
> +    pps->pps_slice_height_in_tiles_minus1[slice] == 0 && \
> +    pps->pps_tile_row_height_minus1[tile_y] > 0)
> +#endif

This seems to be used exactly once and match the syntax in the standard, so I don't think it should be separate.

> +
> ...
> +
> +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);

Names aren't right.

> +    return 0;
> +}
> +
> +static int FUNC(general_constraints_info)(CodedBitstreamContext *ctx,
> +                                          RWContext *rw,
> +                                          H266GeneralConstraintsInfo *current)
> +{
> +    int err, i;
> +
> +    flag(gci_present_flag);
> +    if (current->gci_present_flag) {
> +        ...
> +
> +        /* loop filter */
> +        flag(gci_no_sao_constraint_flag);
> +        flag(gci_no_alf_constraint_flag);
> +        flag(gci_no_ccalf_constraint_flag);
> +        flag(gci_no_lmcs_constraint_flag);
> +        flag(gci_no_ladf_constraint_flag);
> +        flag(gci_no_virtual_boundaries_constraint_flag);
> +        ub(8, gci_num_reserved_bits);
> +        for (i = 0; i < current->gci_num_reserved_bits; i++) {
> +            fixed(1, gci_reserved_zero_bit, 1);

As noted above, needs to be passed through for future compatibility.

> +        }
> +    }
> +    while (byte_alignment(rw) != 0)
> +        fixed(1, gci_alignment_zero_bit, 0);
> +    return 0;
> +}
> +
> +static int FUNC(profile_tier_level)(CodedBitstreamContext *ctx, RWContext *rw,
> +                                    H266RawProfileTierLevel *current,
> +                                    int profile_tier_present_flag,
> +                                    int max_num_sub_layers_minus1)
> +{
> +    int err, i;
> +
> +    if (profile_tier_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_tier_present_flag) {
> +        CHECK(FUNC(general_constraints_info)(ctx, rw,
> +                                             &current->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) != 0)
> +        fixed(1, ptl_reserved_zero_bit, 0);

Need not be zero, has to be passed through.

> +    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_tier_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);
> +        }
> +    }

These are inferred as 6 when not present?

> +
> +    return 0;
> +}
> +
> ...
> +
> +static int FUNC(vui_payload)(CodedBitstreamContext *ctx, RWContext *rw,
> +                             H266RawVUI *current, uint16_t vui_payload_size)
> +{
> +    int err;
> +    int start_position, current_position;
> +#ifdef READ
> +    start_position = get_bits_count(rw);
> +#else
> +    start_position = put_bits_count(rw);
> +#endif
> +    CHECK(FUNC(vui_parameters)(ctx, rw, current));
> +
> +#ifdef READ
> +    current_position = get_bits_count(rw) - start_position;
> +#else
> +    current_position = put_bits_count(rw) - start_position;
> +#endif

Looks like another case for bit_position(RWContext) as in <https://lists.ffmpeg.org/pipermail/ffmpeg-devel/2021-January/274208.html>.

> +    if (current_position < 8 * vui_payload_size) {
> +        CHECK(FUNC(payload_extension)(ctx, rw, &current->extension_data,
> +                                      vui_payload_size, current_position));
> +        fixed(1, vui_payload_bit_equal_to_one, 1);
> +        while (byte_alignment(rw) != 0)
> +            fixed(1, vui_payload_bit_equal_to_zero, 0);
> +    }
> +    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 *sps)
> +{
> +
> +    int err, i, j;
> +    ue(num_ref_entries, 0, VVC_MAX_DPB_SIZE + 13);

The + 13 is appearing in the sizes too.  Can we give it a better name?

> +    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);
> +    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) {
> +                    uint8_t bits = sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4;
> +                    ubs(bits, rpls_poc_lsb_lt[j], 1, j);
> +                    j++;
> +                }
> +            }
> +        } 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(sublayer_hrd_parameters)(CodedBitstreamContext *ctx, RWContext *rw,
> +                     H266RawSubLayerHRDParameters *current, int sublayer_id,
> +                     const H266RawGeneralTimingHrdParameters *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);
> +    }

On everything here you've correctly got that there are two subscripts, but there is actually only one in the variable - perhaps the argument shouldn't be a substructure?

> +    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,
> +                                                &current->nal_sub_layer_hrd_parameters[i],
> +                                                i, general));
> +        if (general->general_vcl_hrd_params_present_flag)
> +            CHECK(FUNC(sublayer_hrd_parameters)(ctx, rw,
> +                       &current->nal_sub_layer_hrd_parameters[i], i, general));
> +    }
> +    return 0;
> +}
> +
> +static int FUNC(sps_subpic)(CodedBitstreamContext *ctx, RWContext *rw,
> +                     H266RawSPS *current)

This function doesn't actually exist, and all splitting it out seems to be doing is making the template look less like the standard?

> +{
> ...
> +}
> +
> +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;
> +    uint8_t qp_bd_offset;
> +
> +    static const uint8_t h266_sub_width_c[] = {
> +        1, 2, 2, 1
> +    };
> +    static const uint8_t h266_sub_height_c[] = {
> +        1, 2, 1, 1
> +    };
> +
> +    HEADER("Sequence Parameter Set");
> +
> +    CHECK(FUNC(nal_unit_header)(ctx, rw,
> +                                &current->nal_unit_header, VVC_SPS_NUT));
> +
> +    ub(4, sps_seq_parameter_set_id);
> +    ub(4, sps_video_parameter_set_id);
> +    if (!current->sps_video_parameter_set_id && !h266->vps[0]) {
> +        H266RawVPS *vps0;
> +        h266->vps_ref[0] = av_buffer_alloc(sizeof(H266RawVPS));
> +        if (!h266->vps_ref[0])
> +            return AVERROR(ENOMEM);
> +        vps0 = h266->vps[0] = (H266RawVPS *)h266->vps_ref[0]->data;
> +        vps0->vps_max_layers_minus1 = 0;
> +        //todo: infer all things in 7.4.3.4 sps_video_parameter_set_id paragraph
> +    }
> +    h266->active_vps = vps = h266->vps[current->sps_video_parameter_set_id];

You don't actually use the vps at all, so why bother with this?

> +
> +    u(3, sps_max_sublayers_minus1, 0, VVC_MAX_SUBLAYERS - 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;
> +
> ...
> +
> +    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);
> +    }
> +
> +    u(2, sps_num_extra_sh_bytes, 0, 0);

Between zero and zero?

> +    for (i = 0; i < (current->sps_num_extra_sh_bytes * 8); i++) {
> +        flags(sps_extra_sh_bit_present_flag[i], 1, i);
> +    }
> +
> +    ...
> +
> +    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);

This inference isn't right - there is also a temporal subblock merge candidate.

> +        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_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) != 0)
> +            fixed(1, sps_vui_alignment_zero_bit, 0);
> +        CHECK(FUNC(vui_payload)(ctx, rw, &current->vui,
> +                                current->sps_vui_payload_size_minus1 + 1));
> +    }
> +
> +    flag(sps_extension_flag);
> +    if (current->sps_extension_flag)
> +        CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
> +
> +    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
> +
> +    return 0;
> +}

(I stopped here on trying to read this in detail.  Even above, I haven't checked all of the bounds.)

> ...
> +
> +static int FUNC(aud)(CodedBitstreamContext *ctx, RWContext *rw,
> +                     H266RawAUD *current)
> +{
> +    int err;
> +
> +    HEADER("Access Unit Delimiter");
> +
> +    CHECK(FUNC(nal_unit_header)(ctx, rw,
> +                                &current->nal_unit_header, VVC_AUD_NUT));
> +
> +    flag(aud_irap_or_gdr_flag);
> +    u(3, aud_pic_type, 0, 2);

Another one for future-extension compatibility:

"Decoders conforming to this version of this Specification shall ignore reserved values of aud_pic_type."

> +
> +    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
> +    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, qp_bd_offset;
> +    uint16_t curr_subpic_idx;
> +    uint16_t num_slices_in_subpic;
> +
> +    HEADER("Slice Header");
> +
> +    CHECK(FUNC(nal_unit_header)(ctx, rw, &current->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, &current->sh_picture_header));
> +        if (!h266->ph_ref) {
> +            h266->ph_ref = av_buffer_allocz(sizeof(H266RawPH));
> +            if (!h266->ph_ref)
> +                return AVERROR(ENOMEM);
> +            h266->active_ph = h266->ph = (H266RawPH*)h266->ph_ref->data;
> +        }
> +        memcpy(h266->ph, &current->sh_picture_header, sizeof(H266RawPH));
> +    }
> +    sps = h266->active_sps;
> +    pps = h266->active_pps;
> +    ph  = h266->active_ph;

This is going to do something horrible if you have a frame where you lose the NAL unit containing the picture header but it still has other slices.

Can we detect and avoid that case?

> +
> +    if (!sps || !pps || !ph) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "no sps(%p)/pps(%p)/ph(%p).\n", sps, pps, ph);

This message is definitely user-facing - it should be clearer.

Maybe "SPS id %d not available", "PPS id %d not available", "Picture header not available"?

> +        return AVERROR_INVALIDDATA;
> +    }
> +
> ...
> +
> +    return 0;
> +}
> +
> +static int FUNC(sei_decoded_picture_hash)(CodedBitstreamContext *ctx, RWContext *rw,
> +                                          H266RawSEIDecodedPictureHash *current)
> +{
> +    int err, c, i;
> +
> +    HEADER("Decoded Picture Hash");
> +
> +    u(8, dph_sei_hash_type, 0, 2);
> +    flag(dph_sei_single_component_flag);
> +    fixed(7, ph_sei_reserved_zero_7bits, 0);

"shall ignore"

> +
> +    for (c = 0; c < (current->dph_sei_single_component_flag ? 1 : 3); c++) {

This variable is called cIdx, and it does appear in strings.

> +        if (current->dph_sei_hash_type == 0) {
> +            for (i = 0; i < 16; i++)
> +                us(8, dph_sei_picture_md5[c][i], 0x00, 0xff, 2, c, i);
> +        } else if (current->dph_sei_hash_type == 1) {
> +            us(16, dph_sei_picture_crc[c], 0x0000, 0xffff, 1, c);
> +        } else if (current->dph_sei_hash_type == 2) {
> +            us(32, dph_sei_picture_checksum[c], 0x00000000, 0xffffffff, 1, c);
> +        }
> +    }
> +    return 0;
> +}
> +
> ...

Thanks,

- Mark
Nuo Mi Jan. 10, 2021, 9:10 a.m. UTC | #2
On Sun, Jan 10, 2021 at 5:34 AM Mark Thompson <sw@jkqxz.net> wrote:

> On 09/01/2021 07:34, Nuo Mi wrote:
> > ---
> >   configure                             |    2 +
> >   libavcodec/Makefile                   |    1 +
> >   libavcodec/cbs.c                      |    6 +
> >   libavcodec/cbs_h2645.c                |  373 ++++
> >   libavcodec/cbs_h266.h                 |  840 ++++++++
> >   libavcodec/cbs_h266_syntax_template.c | 2761 +++++++++++++++++++++++++
> >   libavcodec/cbs_internal.h             |    3 +-
> >   7 files changed, 3985 insertions(+), 1 deletion(-)
> >   create mode 100644 libavcodec/cbs_h266.h
> >   create mode 100644 libavcodec/cbs_h266_syntax_template.c
> >
> > ...
> > @@ -920,6 +934,135 @@ static int
> cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
> >       return 0;
> >   }
> >
> > +static int cbs_h266_replace_ph(CodedBitstreamContext *ctx,
> > +                               CodedBitstreamUnit *unit)
> > +{
> > +    CodedBitstreamH266Context *priv = ctx->priv_data;
> > +    int err;
> > +    err = ff_cbs_make_unit_refcounted(ctx, unit);
> > +    if (err < 0)
> > +        return err;
> > +    av_buffer_unref(&priv->ph_ref);
> > +    av_assert0(unit->content_ref);
> > +    priv->ph_ref = av_buffer_ref(unit->content_ref);
> > +    if (!priv->ph_ref)
> > +        return AVERROR(ENOMEM);
> > +    priv->active_ph = priv->ph = (H266RawPH *)priv->ph_ref->data;
>
> Why are there too variables here?  They seem to always be the same.
>
  priv->active_ph is read-only, priv->ph is writeable pointer. I can change
to priv->ph only if you prefer.

>
> > +    return 0;
> > +}
> > +
> > ...
> > +
> >   static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
> >                                          CodedBitstreamFragment *frag)
> >   {
> > @@ -1248,6 +1494,11 @@ static int
> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
> >                (unit->type == HEVC_NAL_VPS ||
> >                 unit->type == HEVC_NAL_SPS ||
> >                 unit->type == HEVC_NAL_PPS)) ||
> > +            (ctx->codec->codec_id == AV_CODEC_ID_VVC &&
> > +             (unit->type == VVC_VPS_NUT ||
> > +              unit->type == VVC_SPS_NUT ||
> > +              unit->type == VVC_PPS_NUT ||
> > +              unit->type == VVC_PREFIX_APS_NUT)) ||
>
> Also various other things, which might be here since passthrough does not
> require decomposition to be implemented.
>
> This test is getting unwieldy - maybe it should be moved to a new function
> cbs_h2645_unit_requires_zero_byte().
>
done

> >               i == 0 /* (Assume this is the start of an access unit.)
> */) {
> >               // zero_byte
> >               data[dp++] = 0;
> > @@ -1362,6 +1613,41 @@ static void cbs_h265_close(CodedBitstreamContext
> *ctx)
> >           av_buffer_unref(&h265->pps_ref[i]);
> >   }
> >
> > ...
> > @@ -1506,6 +1792,77 @@ static const CodedBitstreamUnitTypeDescriptor
> cbs_h265_unit_types[] = {
> >       CBS_UNIT_TYPE_END_OF_LIST
> >   };
> >
> > +static void cbs_h266_free_sei(void *opaque, uint8_t *content)
> > +{
> > +}
>
> So as implemented currently it is POD?
>
Yes, currently only md5 sei implemented. We can do more after your react
patch merged.

>
> > +
> > +static const CodedBitstreamUnitTypeDescriptor cbs_h266_unit_types[] = {
> > ...
> > +
> > +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;
> > +
> > ...
> > +
> > +    /* loop filter */
> > +    uint8_t gci_no_sao_constraint_flag;
> > +    uint8_t gci_no_alf_constraint_flag;
> > +    uint8_t gci_no_ccalf_constraint_flag;
> > +    uint8_t gci_no_lmcs_constraint_flag;
> > +    uint8_t gci_no_ladf_constraint_flag;
> > +    uint8_t gci_no_virtual_boundaries_constraint_flag;
> > +    uint8_t gci_num_reserved_bits;
>
> Also needs gci_reserved_zero_bit[], so that we can handle streams with
> future constraints rather than just rejecting them.
>
> "Although the value of gci_num_reserved_bits is required to be equal to 0
> in this version
> of this Specification, decoders conforming to this version of this
> Specification shall allow the value of
> gci_num_reserved_bits greater than 0 to appear in the syntax and shall
> ignore the values of all the gci_reserved_zero_bit[ i ]
> syntax elements when gci_num_reserved_bits is greater than 0."
>

This just follows the same pattern as h265.
How about we create a separate patch set for this, fix h265 as well.


> > +} H266GeneralConstraintsInfo;
> > +
> > ...
> > +
> > +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;
>
> You don't actually use the VPS structure at all, so given that it isn't
> parsed I think it would be cleaner to just not include it here at all.
>
Done. The current conformance stream has no VPS.

>
> > +//
> > ...
> > +
> > +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 {
> > +    uint8_t  dph_sei_hash_type;
> > +    uint8_t  dph_sei_single_component_flag;
> > +    uint8_t  dph_sei_picture_md5[3][16];
> > +    uint16_t dph_sei_picture_crc[3];
> > +    uint32_t dph_sei_picture_checksum[3];
> > +} H266RawSEIDecodedPictureHash;
> > +
> > +typedef struct H266RawSEITimeCode {
> > +} H266RawSEITimeCode;
> > +
> > +typedef struct H266RawSEIMasteringDisplayColourVolume {
> > +} H266RawSEIMasteringDisplayColourVolume;
> > +
>
> Don't include all of these empty structures.
>
> (Half of them are implemented in the common SEI patches on the ML now
> anyway.)
>
Fixed

>
> > ...
> > +#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..6a6defc8a5
> > --- /dev/null
> > +++ b/libavcodec/cbs_h266_syntax_template.c
> > @@ -0,0 +1,2761 @@
> > +/*
> > + * 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 H266_CEIL
> > +#define H266_CEIL(v, a) (((v) + (a) - 1) / (a))
> > +#endif
>
> If it's useful to have this separately then put it in cbs_h2645.c rather
> than doubled in the template.  (See for example cbs_av1_tile_log2().)
>
It's protected by ifdef, not doubled.


> > +
> > +#ifndef H266_HAS_MULTI_SLICES_IN_TILE
> > +#define H266_HAS_MULTI_SLICES_IN_TILE(pps, tile_y, slice) \
> > +    (pps->pps_slice_width_in_tiles_minus1[slice] == 0 && \
> > +    pps->pps_slice_height_in_tiles_minus1[slice] == 0 && \
> > +    pps->pps_tile_row_height_minus1[tile_y] > 0)
> > +#endif
>
> This seems to be used exactly once and match the syntax in the standard,
> so I don't think it should be separate.
>
Done

>
> > +
> > ...
> > +
> > +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);
>
> Names aren't right.
>
Fixed.

>
> > +    return 0;
> > +}
> > +
> > +static int FUNC(general_constraints_info)(CodedBitstreamContext *ctx,
> > +                                          RWContext *rw,
> > +                                          H266GeneralConstraintsInfo
> *current)
> > +{
> > +    int err, i;
> > +
> > +    flag(gci_present_flag);
> > +    if (current->gci_present_flag) {
> > +        ...
> > +
> > +        /* loop filter */
> > +        flag(gci_no_sao_constraint_flag);
> > +        flag(gci_no_alf_constraint_flag);
> > +        flag(gci_no_ccalf_constraint_flag);
> > +        flag(gci_no_lmcs_constraint_flag);
> > +        flag(gci_no_ladf_constraint_flag);
> > +        flag(gci_no_virtual_boundaries_constraint_flag);
> > +        ub(8, gci_num_reserved_bits);
> > +        for (i = 0; i < current->gci_num_reserved_bits; i++) {
> > +            fixed(1, gci_reserved_zero_bit, 1);
>
> As noted above, needs to be passed through for future compatibility.
>
Yes, but it just follows h265 cbs, how about we handle it in a separate
patch set.

>
> > +        }
> > +    }
> > +    while (byte_alignment(rw) != 0)
> > +        fixed(1, gci_alignment_zero_bit, 0);
> > +    return 0;
> > +}
> > +
> > +static int FUNC(profile_tier_level)(CodedBitstreamContext *ctx,
> RWContext *rw,
> > +                                    H266RawProfileTierLevel *current,
> > +                                    int profile_tier_present_flag,
> > +                                    int max_num_sub_layers_minus1)
> > +{
> > +    int err, i;
> > +
> > +    if (profile_tier_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_tier_present_flag) {
> > +        CHECK(FUNC(general_constraints_info)(ctx, rw,
> > +
>  &current->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) != 0)
> > +        fixed(1, ptl_reserved_zero_bit, 0);
>
> Need not be zero, has to be passed through.
>
Ditto

>
> > +    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_tier_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);
> > +        }
> > +    }
>
> These are inferred as 6 when not present?
>
6 only happened when ChromaFormatIdc = 1, others are not defined.
and 6 is the unspecific value in the spec...
Do we really need to infer it :)

>
> > +
> > +    return 0;
> > +}
> > +
> > ...
> > +
> > +static int FUNC(vui_payload)(CodedBitstreamContext *ctx, RWContext *rw,
> > +                             H266RawVUI *current, uint16_t
> vui_payload_size)
> > +{
> > +    int err;
> > +    int start_position, current_position;
> > +#ifdef READ
> > +    start_position = get_bits_count(rw);
> > +#else
> > +    start_position = put_bits_count(rw);
> > +#endif
> > +    CHECK(FUNC(vui_parameters)(ctx, rw, current));
> > +
> > +#ifdef READ
> > +    current_position = get_bits_count(rw) - start_position;
> > +#else
> > +    current_position = put_bits_count(rw) - start_position;
> > +#endif
>
> Looks like another case for bit_position(RWContext) as in <
> https://lists.ffmpeg.org/pipermail/ffmpeg-devel/2021-January/274208.html>.
>
yeah, we can change it after your patch merged.

>
> > +    if (current_position < 8 * vui_payload_size) {
> > +        CHECK(FUNC(payload_extension)(ctx, rw, &current->extension_data,
> > +                                      vui_payload_size,
> current_position));
> > +        fixed(1, vui_payload_bit_equal_to_one, 1);
> > +        while (byte_alignment(rw) != 0)
> > +            fixed(1, vui_payload_bit_equal_to_zero, 0);
> > +    }
> > +    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 *sps)
> > +{
> > +
> > +    int err, i, j;
> > +    ue(num_ref_entries, 0, VVC_MAX_DPB_SIZE + 13);
>
> The + 13 is appearing in the sizes too.  Can we give it a better name?
>
fixed with VVC_MAX_REF_ENTRIES

>
> > +    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);
> > +    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) {
> > +                    uint8_t bits =
> sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4;
> > +                    ubs(bits, rpls_poc_lsb_lt[j], 1, j);
> > +                    j++;
> > +                }
> > +            }
> > +        } 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(sublayer_hrd_parameters)(CodedBitstreamContext *ctx,
> RWContext *rw,
> > +                     H266RawSubLayerHRDParameters *current, int
> sublayer_id,
> > +                     const H266RawGeneralTimingHrdParameters *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);
> > +    }
>
> On everything here you've correctly got that there are two subscripts, but
> there is actually only one in the variable - perhaps the argument shouldn't
> be a substructure?
>
fixed

>
> > +    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,
> > +
> &current->nal_sub_layer_hrd_parameters[i],
> > +                                                i, general));
> > +        if (general->general_vcl_hrd_params_present_flag)
> > +            CHECK(FUNC(sublayer_hrd_parameters)(ctx, rw,
> > +                       &current->nal_sub_layer_hrd_parameters[i], i,
> general));
> > +    }
> > +    return 0;
> > +}
> > +
> > +static int FUNC(sps_subpic)(CodedBitstreamContext *ctx, RWContext *rw,
> > +                     H266RawSPS *current)
>
> This function doesn't actually exist, and all splitting it out seems to be
> doing is making the template look less like the standard?
>
VVC is more complex than hevc. If we do not use some sub-functions. It will
be too large. not friendly for reader and indent.

>
> > +{
> > ...
> > +}
> > +
> > +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;
> > +    uint8_t qp_bd_offset;
> > +
> > +    static const uint8_t h266_sub_width_c[] = {
> > +        1, 2, 2, 1
> > +    };
> > +    static const uint8_t h266_sub_height_c[] = {
> > +        1, 2, 1, 1
> > +    };
> > +
> > +    HEADER("Sequence Parameter Set");
> > +
> > +    CHECK(FUNC(nal_unit_header)(ctx, rw,
> > +                                &current->nal_unit_header,
> VVC_SPS_NUT));
> > +
> > +    ub(4, sps_seq_parameter_set_id);
> > +    ub(4, sps_video_parameter_set_id);
> > +    if (!current->sps_video_parameter_set_id && !h266->vps[0]) {
> > +        H266RawVPS *vps0;
> > +        h266->vps_ref[0] = av_buffer_alloc(sizeof(H266RawVPS));
> > +        if (!h266->vps_ref[0])
> > +            return AVERROR(ENOMEM);
> > +        vps0 = h266->vps[0] = (H266RawVPS *)h266->vps_ref[0]->data;
> > +        vps0->vps_max_layers_minus1 = 0;
> > +        //todo: infer all things in 7.4.3.4 sps_video_parameter_set_id
> paragraph
> > +    }
> > +    h266->active_vps = vps =
> h266->vps[current->sps_video_parameter_set_id];
>
> You don't actually use the vps at all, so why bother with this?
>
> > +
> > +    u(3, sps_max_sublayers_minus1, 0, VVC_MAX_SUBLAYERS - 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;
> > +
> > ...
> > +
> > +    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);
> > +    }
> > +
> > +    u(2, sps_num_extra_sh_bytes, 0, 0);
>
> Between zero and zero?
>
For the current version of spec, yes.
Spec always says we need to open for some bits/values.
But, from my personal experience, when we have other values in the reserved
one. We usually cant correctly decode a stream.
So, instead of ignoring the value, another approach is to report the error
for it, so we can get the bitstream earlier and fix it.


>
> > +    for (i = 0; i < (current->sps_num_extra_sh_bytes * 8); i++) {
> > +        flags(sps_extra_sh_bit_present_flag[i], 1, i);
> > +    }
> > +
> > +    ...
> > +
> > +    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);
>
> This inference isn't right - there is also a temporal subblock merge
> candidate.
>
How to get it? Spec did not define how to infer
sps_five_minus_max_num_subblock_merge_cand,
I just guess it from sps_6param_affine_enabled_flag


>
> > +        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_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) != 0)
> > +            fixed(1, sps_vui_alignment_zero_bit, 0);
> > +        CHECK(FUNC(vui_payload)(ctx, rw, &current->vui,
> > +                                current->sps_vui_payload_size_minus1 +
> 1));
> > +    }
> > +
> > +    flag(sps_extension_flag);
> > +    if (current->sps_extension_flag)
> > +        CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
> > +
> > +    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
> > +
> > +    return 0;
> > +}
>
> (I stopped here on trying to read this in detail.  Even above, I haven't
> checked all of the bounds.)
>
> > ...
> > +
> > +static int FUNC(aud)(CodedBitstreamContext *ctx, RWContext *rw,
> > +                     H266RawAUD *current)
> > +{
> > +    int err;
> > +
> > +    HEADER("Access Unit Delimiter");
> > +
> > +    CHECK(FUNC(nal_unit_header)(ctx, rw,
> > +                                &current->nal_unit_header,
> VVC_AUD_NUT));
> > +
> > +    flag(aud_irap_or_gdr_flag);
> > +    u(3, aud_pic_type, 0, 2);
>
> Another one for future-extension compatibility:
>
> "Decoders conforming to this version of this Specification shall ignore
> reserved values of aud_pic_type."
>
yeah, we may need a separate patch to define a common macro, and fix
h265/h266 together.

>
> > +
> > +    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
> > +    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, qp_bd_offset;
> > +    uint16_t curr_subpic_idx;
> > +    uint16_t num_slices_in_subpic;
> > +
> > +    HEADER("Slice Header");
> > +
> > +    CHECK(FUNC(nal_unit_header)(ctx, rw, &current->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,
> &current->sh_picture_header));
> > +        if (!h266->ph_ref) {
> > +            h266->ph_ref = av_buffer_allocz(sizeof(H266RawPH));
> > +            if (!h266->ph_ref)
> > +                return AVERROR(ENOMEM);
> > +            h266->active_ph = h266->ph = (H266RawPH*)h266->ph_ref->data;
> > +        }
> > +        memcpy(h266->ph, &current->sh_picture_header,
> sizeof(H266RawPH));
> > +    }
> > +    sps = h266->active_sps;
> > +    pps = h266->active_pps;
> > +    ph  = h266->active_ph;
>
> This is going to do something horrible if you have a frame where you lose
> the NAL unit containing the picture header but it still has other slices.
>
> Can we detect and avoid that case?
>
In this case, we will have a parser to split the frames, the parser code
will make sure it always has a picture header in every frame.


> > +
> > +    if (!sps || !pps || !ph) {
> > +        av_log(ctx->log_ctx, AV_LOG_ERROR, "no
> sps(%p)/pps(%p)/ph(%p).\n", sps, pps, ph);
>
> This message is definitely user-facing - it should be clearer.
>
> Maybe "SPS id %d not available", "PPS id %d not available", "Picture
> header not available"?
>
actually, it's checked by picture_header(), once we got ph, we always got
the sps and pps.
will check ph and assert sps, pps.

>
> > +        return AVERROR_INVALIDDATA;
> > +    }
> > +
> > ...
> > +
> > +    return 0;
> > +}
> > +
> > +static int FUNC(sei_decoded_picture_hash)(CodedBitstreamContext *ctx,
> RWContext *rw,
> > +                                          H266RawSEIDecodedPictureHash
> *current)
> > +{
> > +    int err, c, i;
> > +
> > +    HEADER("Decoded Picture Hash");
> > +
> > +    u(8, dph_sei_hash_type, 0, 2);
> > +    flag(dph_sei_single_component_flag);
> > +    fixed(7, ph_sei_reserved_zero_7bits, 0);
>
> "shall ignore"
>
> > +
> > +    for (c = 0; c < (current->dph_sei_single_component_flag ? 1 : 3);
> c++) {
>
> This variable is called cIdx, and it does appear in strings.
>
> > +        if (current->dph_sei_hash_type == 0) {
> > +            for (i = 0; i < 16; i++)
> > +                us(8, dph_sei_picture_md5[c][i], 0x00, 0xff, 2, c, i);
> > +        } else if (current->dph_sei_hash_type == 1) {
> > +            us(16, dph_sei_picture_crc[c], 0x0000, 0xffff, 1, c);
> > +        } else if (current->dph_sei_hash_type == 2) {
> > +            us(32, dph_sei_picture_checksum[c], 0x00000000, 0xffffffff,
> 1, c);
> > +        }
> > +    }
> > +    return 0;
> > +}
> > +
> > ...
>
> Thanks,
>
> - Mark
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
Mark Thompson Jan. 11, 2021, 8:45 p.m. UTC | #3
On 10/01/2021 09:10, Nuo Mi wrote:
> On Sun, Jan 10, 2021 at 5:34 AM Mark Thompson <sw@jkqxz.net> wrote:
>> On 09/01/2021 07:34, Nuo Mi wrote:
>>> ---
>>>    configure                             |    2 +
>>>    libavcodec/Makefile                   |    1 +
>>>    libavcodec/cbs.c                      |    6 +
>>>    libavcodec/cbs_h2645.c                |  373 ++++
>>>    libavcodec/cbs_h266.h                 |  840 ++++++++
>>>    libavcodec/cbs_h266_syntax_template.c | 2761 +++++++++++++++++++++++++
>>>    libavcodec/cbs_internal.h             |    3 +-
>>>    7 files changed, 3985 insertions(+), 1 deletion(-)
>>>    create mode 100644 libavcodec/cbs_h266.h
>>>    create mode 100644 libavcodec/cbs_h266_syntax_template.c
>>>
>>> ...
>>> @@ -920,6 +934,135 @@ static int
>> cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
>>>        return 0;
>>>    }
>>>
>>> +static int cbs_h266_replace_ph(CodedBitstreamContext *ctx,
>>> +                               CodedBitstreamUnit *unit)
>>> +{
>>> +    CodedBitstreamH266Context *priv = ctx->priv_data;
>>> +    int err;
>>> +    err = ff_cbs_make_unit_refcounted(ctx, unit);
>>> +    if (err < 0)
>>> +        return err;
>>> +    av_buffer_unref(&priv->ph_ref);
>>> +    av_assert0(unit->content_ref);
>>> +    priv->ph_ref = av_buffer_ref(unit->content_ref);
>>> +    if (!priv->ph_ref)
>>> +        return AVERROR(ENOMEM);
>>> +    priv->active_ph = priv->ph = (H266RawPH *)priv->ph_ref->data;
>>
>> Why are there too variables here?  They seem to always be the same.
>>
>    priv->active_ph is read-only, priv->ph is writeable pointer. I can change
> to priv->ph only if you prefer.

Reading more carefully, H.266 doesn't appear to have the concept of a parameter set being "active" any more (the term never appears).

Does it actually follow the same rules as H.26[45]?  Is there some newer terminology which we should be using in all of this?

>>> +    return 0;
>>> +}
>>> +
>>> ...
>>> diff --git a/libavcodec/cbs_h266_syntax_template.c
>> b/libavcodec/cbs_h266_syntax_template.c
>>> new file mode 100644
>>> index 0000000000..6a6defc8a5
>>> --- /dev/null
>>> +++ b/libavcodec/cbs_h266_syntax_template.c
>>> @@ -0,0 +1,2761 @@
>>> +/*
>>> + * 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 H266_CEIL
>>> +#define H266_CEIL(v, a) (((v) + (a) - 1) / (a))
>>> +#endif
>>
>> If it's useful to have this separately then put it in cbs_h2645.c rather
>> than doubled in the template.  (See for example cbs_av1_tile_log2().)
>>
> It's protected by ifdef, not doubled.

It would still make more sense to make it a(n inline?) function in cbs_h2645.c.  The template file is intended to contain the standard template code and not other stuff.

>>> +
>>> ...
>>> +
>>> +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);
>>> +        }
>>> +    }
>>
>> These are inferred as 6 when not present?
>>
> 6 only happened when ChromaFormatIdc = 1, others are not defined.
> and 6 is the unspecific value in the spec...
> Do we really need to infer it :)

To match the colour description cases probably yes?

>>> +
>>> +    return 0;
>>> +}
>>> +
>>> ...
>>> +
>>> +static int FUNC(sps_subpic)(CodedBitstreamContext *ctx, RWContext *rw,
>>> +                     H266RawSPS *current)
>>
>> This function doesn't actually exist, and all splitting it out seems to be
>> doing is making the template look less like the standard?
>>
> VVC is more complex than hevc. If we do not use some sub-functions. It will
> be too large. not friendly for reader and indent.

Feel free to ask the standard committee to split up their large functions.

Until that happens, please keep the functions the same as they are in the current standard.

>>> +{
>>> ...
>>> +}
>>> +
>>> +static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
>>> +                     H266RawSPS *current)
>>> +{
>>> ...
>>> +
>>> +    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);
>>> +    }
>>> +
>>> +    u(2, sps_num_extra_sh_bytes, 0, 0);
>>
>> Between zero and zero?
>>
> For the current version of spec, yes.
> Spec always says we need to open for some bits/values.
> But, from my personal experience, when we have other values in the reserved
> one. We usually cant correctly decode a stream.
> So, instead of ignoring the value, another approach is to report the error
> for it, so we can get the bitstream earlier and fix it.

If that's always the case then the standard people would have failed at their jobs.  What would the point of including these blocks even be if it were going to be incompatible anyway?  They could just introduce new syntax elements wherever they like in that case.

(Also the text for this is identical to sps_num_extra_ph_bytes, which is [0, 2].)

>>> +    for (i = 0; i < (current->sps_num_extra_sh_bytes * 8); i++) {
>>> +        flags(sps_extra_sh_bit_present_flag[i], 1, i);
>>> +    }
>>> +
>>> +    ...
>>> +
>>> +    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);
>>
>> This inference isn't right - there is also a temporal subblock merge
>> candidate.
>>
> How to get it? Spec did not define how to infer
> sps_five_minus_max_num_subblock_merge_cand,
> I just guess it from sps_6param_affine_enabled_flag

The text doesn't offer an inference, and MaxNumSubblockMergeCand is defined without needing any inferred value in 7.4.3.8 (85).

>>> +        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);
>>> +    }
>>> +
>>> ...
>>> +
>>> +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, qp_bd_offset;
>>> +    uint16_t curr_subpic_idx;
>>> +    uint16_t num_slices_in_subpic;
>>> +
>>> +    HEADER("Slice Header");
>>> +
>>> +    CHECK(FUNC(nal_unit_header)(ctx, rw, &current->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,
>> &current->sh_picture_header));
>>> +        if (!h266->ph_ref) {
>>> +            h266->ph_ref = av_buffer_allocz(sizeof(H266RawPH));
>>> +            if (!h266->ph_ref)
>>> +                return AVERROR(ENOMEM);
>>> +            h266->active_ph = h266->ph = (H266RawPH*)h266->ph_ref->data;
>>> +        }
>>> +        memcpy(h266->ph, &current->sh_picture_header,
>> sizeof(H266RawPH));
>>> +    }
>>> +    sps = h266->active_sps;
>>> +    pps = h266->active_pps;
>>> +    ph  = h266->active_ph;
>>
>> This is going to do something horrible if you have a frame where you lose
>> the NAL unit containing the picture header but it still has other slices.
>>
>> Can we detect and avoid that case?
>>
> In this case, we will have a parser to split the frames, the parser code
> will make sure it always has a picture header in every frame.

It has to work anyway, though.  The parser need not be run by the user, and indeed they won't if the input comes from something like RTP.

>>> +
>>> ...

- Mark
James Almer Jan. 12, 2021, 1:28 a.m. UTC | #4
On 1/11/2021 5:45 PM, Mark Thompson wrote:
>>>> +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);
>>>> +        }
>>>> +    }
>>>
>>> These are inferred as 6 when not present?
>>>
>> 6 only happened when ChromaFormatIdc = 1, others are not defined.
>> and 6 is the unspecific value in the spec...
>> Do we really need to infer it :)
> 
> To match the colour description cases probably yes?

"When vui_chroma_loc_info_present_flag is equal to 0, 
vui_chroma_sample_loc_type_frame is not present and is inferred to be 
equal to 6, which indicates that the location of the chroma samples is 
unknown or unspecified or specified by other means not specified in this 
Specification. When vui_chroma_sample_loc_type_top_field and 
vui_chroma_sample_loc_type_bottom_field are not present, the values of 
vui_chroma_sample_loc_type_top_field and 
vui_chroma_sample_loc_type_bottom_field are inferred to be equal to 
vui_chroma_sample_loc_type_frame."

So the correct implementation i think would be

     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);
             infer(vui_chroma_sample_loc_type_top_field,
                   current->vui_chroma_sample_loc_type_frame);
             infer(vui_chroma_sample_loc_type_bottom_field,
                   current->vui_chroma_sample_loc_type_frame);
         } else {
             infer(vui_chroma_sample_loc_type_frame, 6);
             ue(vui_chroma_sample_loc_type_top_field, 0, 6);
             ue(vui_chroma_sample_loc_type_bottom_field,  0, 6);
         }
     } else {
         infer(vui_chroma_sample_loc_type_frame, 6);
         infer(vui_chroma_sample_loc_type_top_field,
               current->vui_chroma_sample_loc_type_frame);
         infer(vui_chroma_sample_loc_type_bottom_field,
               current->vui_chroma_sample_loc_type_frame);
     }

Also, you also need to infer the default value of almost everything when 
sps_vui_parameters_present_flag is 0. See section D.8 and how h265 does 
it with the vui_parameters_default() custom function.
Nuo Mi Jan. 17, 2021, 4:08 a.m. UTC | #5
On Tue, Jan 12, 2021 at 4:45 AM Mark Thompson <sw@jkqxz.net> wrote:

> On 10/01/2021 09:10, Nuo Mi wrote:
> > On Sun, Jan 10, 2021 at 5:34 AM Mark Thompson <sw@jkqxz.net> wrote:
> >> On 09/01/2021 07:34, Nuo Mi wrote:
> >>> ---
> >>>    configure                             |    2 +
> >>>    libavcodec/Makefile                   |    1 +
> >>>    libavcodec/cbs.c                      |    6 +
> >>>    libavcodec/cbs_h2645.c                |  373 ++++
> >>>    libavcodec/cbs_h266.h                 |  840 ++++++++
> >>>    libavcodec/cbs_h266_syntax_template.c | 2761
> +++++++++++++++++++++++++
> >>>    libavcodec/cbs_internal.h             |    3 +-
> >>>    7 files changed, 3985 insertions(+), 1 deletion(-)
> >>>    create mode 100644 libavcodec/cbs_h266.h
> >>>    create mode 100644 libavcodec/cbs_h266_syntax_template.c
> >>>
> >>> ...
> >>> @@ -920,6 +934,135 @@ static int
> >> cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
> >>>        return 0;
> >>>    }
> >>>
> >>> +static int cbs_h266_replace_ph(CodedBitstreamContext *ctx,
> >>> +                               CodedBitstreamUnit *unit)
> >>> +{
> >>> +    CodedBitstreamH266Context *priv = ctx->priv_data;
> >>> +    int err;
> >>> +    err = ff_cbs_make_unit_refcounted(ctx, unit);
> >>> +    if (err < 0)
> >>> +        return err;
> >>> +    av_buffer_unref(&priv->ph_ref);
> >>> +    av_assert0(unit->content_ref);
> >>> +    priv->ph_ref = av_buffer_ref(unit->content_ref);
> >>> +    if (!priv->ph_ref)
> >>> +        return AVERROR(ENOMEM);
> >>> +    priv->active_ph = priv->ph = (H266RawPH *)priv->ph_ref->data;
> >>
> >> Why are there too variables here?  They seem to always be the same.
> >>
> >    priv->active_ph is read-only, priv->ph is writeable pointer. I can
> change
> > to priv->ph only if you prefer.
>
> Reading more carefully, H.266 doesn't appear to have the concept of a
> parameter set being "active" any more (the term never appears).
>
> Does it actually follow the same rules as H.26[45]?  Is there some newer
> terminology which we should be using in all of this?
>
No, I guess not, two evidences:
1. buffering_period has no bp_seq_parameter_set_id any more
2. sei payload type 129 is not active_parameter_sets any more.
Not sure in which cases we need the papram activication, h264,h265 slice
header always has pps id.


>
> >>> +    return 0;
> >>> +}
> >>> +
> >>> ...
> >>> diff --git a/libavcodec/cbs_h266_syntax_template.c
> >> b/libavcodec/cbs_h266_syntax_template.c
> >>> new file mode 100644
> >>> index 0000000000..6a6defc8a5
> >>> --- /dev/null
> >>> +++ b/libavcodec/cbs_h266_syntax_template.c
> >>> @@ -0,0 +1,2761 @@
> >>> +/*
> >>> + * 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 H266_CEIL
> >>> +#define H266_CEIL(v, a) (((v) + (a) - 1) / (a))
> >>> +#endif
> >>
> >> If it's useful to have this separately then put it in cbs_h2645.c rather
> >> than doubled in the template.  (See for example cbs_av1_tile_log2().)
> >>
> > It's protected by ifdef, not doubled.
>
> It would still make more sense to make it a(n inline?) function in
> cbs_h2645.c.  The template file is intended to contain the standard
> template code and not other stuff.
>
sure, fixed with h266_ceil in cbs_h2645.c

>
> >>> +
> >>> ...
> >>> +
> >>> +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);
> >>> +        }
> >>> +    }
> >>
> >> These are inferred as 6 when not present?
> >>
> > 6 only happened when ChromaFormatIdc = 1, others are not defined.
> > and 6 is the unspecific value in the spec...
> > Do we really need to infer it :)
>
> To match the colour description cases probably yes?
>
Fixed


>
> >>> +
> >>> +    return 0;
> >>> +}
> >>> +
> >>> ...
> >>> +
> >>> +static int FUNC(sps_subpic)(CodedBitstreamContext *ctx, RWContext *rw,
> >>> +                     H266RawSPS *current)
> >>
> >> This function doesn't actually exist, and all splitting it out seems to
> be
> >> doing is making the template look less like the standard?
> >>
> > VVC is more complex than hevc. If we do not use some sub-functions. It
> will
> > be too large. not friendly for reader and indent.
>
> Feel free to ask the standard committee to split up their large functions.
>
> Until that happens, please keep the functions the same as they are in the
> current standard.
>
Sure, fixed

>
> >>> +{
> >>> ...
> >>> +}
> >>> +
> >>> +static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
> >>> +                     H266RawSPS *current)
> >>> +{
> >>> ...
> >>> +
> >>> +    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);
> >>> +    }
> >>> +
> >>> +    u(2, sps_num_extra_sh_bytes, 0, 0);
> >>
> >> Between zero and zero?
> >>
> > For the current version of spec, yes.
> > Spec always says we need to open for some bits/values.
> > But, from my personal experience, when we have other values in the
> reserved
> > one. We usually cant correctly decode a stream.
> > So, instead of ignoring the value, another approach is to report the
> error
> > for it, so we can get the bitstream earlier and fix it.
>
> If that's always the case then the standard people would have failed at
> their jobs.  What would the point of including these blocks even be if it
> were going to be incompatible anyway?  They could just introduce new syntax
> elements wherever they like in that case.

 It's normal, it's hard to foresee the future.
Hevc sps_scc_extension_flag is a good example. The first version spec said
you need to ignore all data after sps_extension_present_flag.
Even a decoder strictly follows the suggestion from the spec, it still
can't decode an SCC clip.

Fixed
sps_num_extra_ph_bytes, nuh_reserved_zero_bit, gci_reserved_zero_bit,
ptl_reserved_zero_bit, ph_sei_reserved_zero_7bits


> (Also the text for this is identical to sps_num_extra_ph_bytes, which is
> [0, 2].)
>
> >>> +    for (i = 0; i < (current->sps_num_extra_sh_bytes * 8); i++) {
> >>> +        flags(sps_extra_sh_bit_present_flag[i], 1, i);
> >>> +    }
> >>> +
> >>> +    ...
> >>> +
> >>> +    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);
> >>
> >> This inference isn't right - there is also a temporal subblock merge
> >> candidate.
> >>
> > How to get it? Spec did not define how to infer
> > sps_five_minus_max_num_subblock_merge_cand,
> > I just guess it from sps_6param_affine_enabled_flag
>
> The text doesn't offer an inference, and MaxNumSubblockMergeCand is
> defined without needing any inferred value in 7.4.3.8 (85).
>
 fixed

>
> >>> +        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);
> >>> +    }
> >>> +
> >>> ...
> >>> +
> >>> +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, qp_bd_offset;
> >>> +    uint16_t curr_subpic_idx;
> >>> +    uint16_t num_slices_in_subpic;
> >>> +
> >>> +    HEADER("Slice Header");
> >>> +
> >>> +    CHECK(FUNC(nal_unit_header)(ctx, rw, &current->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,
> >> &current->sh_picture_header));
> >>> +        if (!h266->ph_ref) {
> >>> +            h266->ph_ref = av_buffer_allocz(sizeof(H266RawPH));
> >>> +            if (!h266->ph_ref)
> >>> +                return AVERROR(ENOMEM);
> >>> +            h266->active_ph = h266->ph =
> (H266RawPH*)h266->ph_ref->data;
> >>> +        }
> >>> +        memcpy(h266->ph, &current->sh_picture_header,
> >> sizeof(H266RawPH));
> >>> +    }
> >>> +    sps = h266->active_sps;
> >>> +    pps = h266->active_pps;
> >>> +    ph  = h266->active_ph;
> >>
> >> This is going to do something horrible if you have a frame where you
> lose
> >> the NAL unit containing the picture header but it still has other
> slices.
> >>
> >> Can we detect and avoid that case?
> >>
> > In this case, we will have a parser to split the frames, the parser code
> > will make sure it always has a picture header in every frame.
>
> It has to work anyway, though.  The parser need not be run by the user,
> and indeed they won't if the input comes from something like RTP.
>
Acordding to 7.4.2.4.4 "A PU consists of zero or one PH NAL unit" and "When
a picture consists of more than one VCL NAL unit, a PH NAL unit shall be
present in the PU.".
This mean a PU can only have one picture header, it in PH NAL or in the
only slice header.
 If we can make sure cbs_h2645_split_fragment always got one PU at each
time.  We can deactive the ph at start of the function.
Do you think it's possible?


> >>> +
> >>> ...
>
> - Mark
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
Nuo Mi Jan. 17, 2021, 4:09 a.m. UTC | #6
On Tue, Jan 12, 2021 at 9:28 AM James Almer <jamrial@gmail.com> wrote:

> On 1/11/2021 5:45 PM, Mark Thompson wrote:
> >>>> +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);
> >>>> +        }
> >>>> +    }
> >>>
> >>> These are inferred as 6 when not present?
> >>>
> >> 6 only happened when ChromaFormatIdc = 1, others are not defined.
> >> and 6 is the unspecific value in the spec...
> >> Do we really need to infer it :)
> >
> > To match the colour description cases probably yes?
>
> "When vui_chroma_loc_info_present_flag is equal to 0,
> vui_chroma_sample_loc_type_frame is not present and is inferred to be
> equal to 6, which indicates that the location of the chroma samples is
> unknown or unspecified or specified by other means not specified in this
> Specification. When vui_chroma_sample_loc_type_top_field and
> vui_chroma_sample_loc_type_bottom_field are not present, the values of
> vui_chroma_sample_loc_type_top_field and
> vui_chroma_sample_loc_type_bottom_field are inferred to be equal to
> vui_chroma_sample_loc_type_frame."
>
> So the correct implementation i think would be
>
>      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);
>              infer(vui_chroma_sample_loc_type_top_field,
>                    current->vui_chroma_sample_loc_type_frame);
>              infer(vui_chroma_sample_loc_type_bottom_field,
>                    current->vui_chroma_sample_loc_type_frame);
>          } else {
>              infer(vui_chroma_sample_loc_type_frame, 6);
>              ue(vui_chroma_sample_loc_type_top_field, 0, 6);
>              ue(vui_chroma_sample_loc_type_bottom_field,  0, 6);
>          }
>      } else {
>          infer(vui_chroma_sample_loc_type_frame, 6);
>          infer(vui_chroma_sample_loc_type_top_field,
>                current->vui_chroma_sample_loc_type_frame);
>          infer(vui_chroma_sample_loc_type_bottom_field,
>                current->vui_chroma_sample_loc_type_frame);
>      }
>

Thanks for the suggestion. But, according to spec, the infer is only work
for  ChromaFormatIdc == 1.
I have followed spec to fix it.

>
> Also, you also need to infer the default value of almost everything when
> sps_vui_parameters_present_flag is 0. See section D.8 and how h265 does
> it with the vui_parameters_default() custom function.
>
fixed with   vui_parameters_default

> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
diff mbox series

Patch

diff --git a/configure b/configure
index 900505756b..4935625260 100755
--- a/configure
+++ b/configure
@@ -2355,6 +2355,7 @@  CONFIG_EXTRA="
     cbs_av1
     cbs_h264
     cbs_h265
+    cbs_h266
     cbs_jpeg
     cbs_mpeg2
     cbs_vp9
@@ -2623,6 +2624,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"
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 35318f4f4d..4b406adfce 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 ecf22b3fdb..6baf21d62b 100644
--- a/libavcodec/cbs.c
+++ b/libavcodec/cbs.c
@@ -39,6 +39,9 @@  static const CodedBitstreamType *const 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
@@ -60,6 +63,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..2be46adda3 100644
--- a/libavcodec/cbs_h2645.c
+++ b/libavcodec/cbs_h2645.c
@@ -24,11 +24,14 @@ 
 #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 "vvc.h"
+#include "vvc_sei.h"
 
 
 static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,
@@ -256,6 +259,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 +368,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
@@ -436,6 +444,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 WRITE
 #undef READWRITE
 #undef RWContext
@@ -679,6 +691,8 @@  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, 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 +934,135 @@  static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
     return 0;
 }
 
+static int cbs_h266_replace_ph(CodedBitstreamContext *ctx,
+                               CodedBitstreamUnit *unit)
+{
+    CodedBitstreamH266Context *priv = ctx->priv_data;
+    int err;
+    err = ff_cbs_make_unit_refcounted(ctx, unit);
+    if (err < 0)
+        return err;
+    av_buffer_unref(&priv->ph_ref);
+    av_assert0(unit->content_ref);
+    priv->ph_ref = av_buffer_ref(unit->content_ref);
+    if (!priv->ph_ref)
+        return AVERROR(ENOMEM);
+    priv->active_ph = priv->ph = (H266RawPH *)priv->ph_ref->data;
+    return 0;
+}
+
+static int cbs_h266_read_nal_unit(CodedBitstreamContext *ctx,
+                                  CodedBitstreamUnit *unit)
+{
+    GetBitContext gbc;
+    int err;
+
+    err = init_get_bits8(&gbc, unit->data, 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 VVC_SPS_NUT:
+        {
+            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 VVC_PPS_NUT:
+        {
+            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 VVC_PH_NUT:
+        {
+            H266RawPH *ph = unit->content;
+            err = cbs_h266_read_ph(ctx, &gbc, ph);
+            if (err < 0)
+                return err;
+
+            err = cbs_h266_replace_ph(ctx, unit);
+            if (err < 0)
+                return err;
+        }
+        break;
+
+    case VVC_TRAIL_NUT:
+    case VVC_STSA_NUT:
+    case VVC_RADL_NUT:
+    case VVC_RASL_NUT:
+    case VVC_IDR_W_RADL:
+    case VVC_IDR_N_LP:
+    case VVC_CRA_NUT:
+    case VVC_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 VVC_AUD_NUT:
+        {
+            err = cbs_h266_read_aud(ctx, &gbc, unit->content);
+            if (err < 0)
+                return err;
+        }
+        break;
+
+    case VVC_PREFIX_SEI_NUT:
+    case VVC_SUFFIX_SEI_NUT:
+        {
+            err = cbs_h266_read_sei(ctx, &gbc, unit->content,
+                                    unit->type == VVC_PREFIX_SEI_NUT);
+
+            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 +1350,109 @@  static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx,
     return 0;
 }
 
+static int cbs_h266_write_nal_unit(CodedBitstreamContext *ctx,
+                                   CodedBitstreamUnit *unit,
+                                   PutBitContext *pbc)
+{
+    int err;
+
+    switch (unit->type) {
+    case VVC_SPS_NUT:
+        {
+            H266RawSPS *sps = unit->content;
+
+            err = cbs_h266_write_sps(ctx, pbc, sps);
+            if (err < 0)
+                return err;
+
+            err = cbs_h266_replace_sps(ctx, unit);
+            if (err < 0)
+                return err;
+        }
+        break;
+
+    case VVC_PPS_NUT:
+        {
+            H266RawPPS *pps = unit->content;
+
+            err = cbs_h266_write_pps(ctx, pbc, pps);
+            if (err < 0)
+                return err;
+
+            err = cbs_h266_replace_pps(ctx, unit);
+            if (err < 0)
+                return err;
+        }
+        break;
+
+    case VVC_PH_NUT:
+        {
+            H266RawPH *ph = unit->content;
+            err = cbs_h266_write_ph(ctx, pbc, ph);
+            if (err < 0)
+                return err;
+
+            err = cbs_h266_replace_ph(ctx, unit);
+            if (err < 0)
+                return err;
+        }
+        break;
+
+    case VVC_TRAIL_NUT:
+    case VVC_STSA_NUT:
+    case VVC_RADL_NUT:
+    case VVC_RASL_NUT:
+    case VVC_IDR_W_RADL:
+    case VVC_IDR_N_LP:
+    case VVC_CRA_NUT:
+    case VVC_GDR_NUT:
+        {
+            H266RawSlice *slice = unit->content;
+
+            err = cbs_h266_write_slice_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 VVC_AUD_NUT:
+        {
+            err = cbs_h266_write_aud(ctx, pbc, unit->content);
+            if (err < 0)
+                return err;
+        }
+        break;
+
+    case VVC_PREFIX_SEI_NUT:
+    case VVC_SUFFIX_SEI_NUT:
+        {
+            err = cbs_h266_write_sei(ctx, pbc, unit->content,
+                                     unit->type == VVC_PREFIX_SEI_NUT);
+
+            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;
+    }
+
+    return 0;
+}
+
 static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
                                        CodedBitstreamFragment *frag)
 {
@@ -1248,6 +1494,11 @@  static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
              (unit->type == HEVC_NAL_VPS ||
               unit->type == HEVC_NAL_SPS ||
               unit->type == HEVC_NAL_PPS)) ||
+            (ctx->codec->codec_id == AV_CODEC_ID_VVC &&
+             (unit->type == VVC_VPS_NUT ||
+              unit->type == VVC_SPS_NUT ||
+              unit->type == VVC_PPS_NUT ||
+              unit->type == VVC_PREFIX_APS_NUT)) ||
             i == 0 /* (Assume this is the start of an access unit.) */) {
             // zero_byte
             data[dp++] = 0;
@@ -1362,6 +1613,41 @@  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;
+    }
+    av_buffer_unref(&h266->ph_ref);
+    h266->ph = NULL;
+
+    h266->active_vps = NULL;
+    h266->active_sps = NULL;
+    h266->active_pps = NULL;
+    h266->active_ph  = NULL;
+
+}
+
+static void cbs_h266_close(CodedBitstreamContext *ctx)
+{
+    CodedBitstreamH266Context *h266 = ctx->priv_data;
+
+    cbs_h266_flush(ctx);
+    ff_h2645_packet_uninit(&h266->common.read_packet);
+
+ }
+
 static void cbs_h264_free_sei_payload(H264RawSEIPayload *payload)
 {
     switch (payload->payload_type) {
@@ -1506,6 +1792,77 @@  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(VVC_VPS_NUT, H266RawVPS, extension_data.data),
+    CBS_UNIT_TYPE_INTERNAL_REF(VVC_PPS_NUT, H266RawPPS, extension_data.data),
+
+    CBS_UNIT_TYPE_POD(VVC_PH_NUT, H266RawPH),
+    CBS_UNIT_TYPE_POD(VVC_AUD_NUT, H266RawAUD),
+
+    {
+        .nb_unit_types = 1,
+        .unit_types = {
+            VVC_SPS_NUT
+        },
+        .content_type   = CBS_CONTENT_TYPE_INTERNAL_REFS,
+        .content_size   = sizeof(H266RawSPS),
+        .nb_ref_offsets = 2,
+        .ref_offsets    = {
+            offsetof(H266RawSPS, extension_data.data),
+            offsetof(H266RawSPS, vui.extension_data.data),
+        },
+    },
+
+    {
+        // Slices of non-IRAP pictures.
+        .nb_unit_types = 4,
+        .unit_types = {
+            VVC_TRAIL_NUT,
+            VVC_STSA_NUT,
+            VVC_RADL_NUT,
+            VVC_RASL_NUT
+        },
+
+        .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  = 4,
+        .unit_types = {
+            VVC_IDR_W_RADL,
+            VVC_IDR_N_LP,
+            VVC_CRA_NUT,
+            VVC_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     = {
+            VVC_PREFIX_SEI_NUT,
+            VVC_SUFFIX_SEI_NUT
+        },
+        .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 +1895,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..90a57c05bd
--- /dev/null
+++ b/libavcodec/cbs_h266.h
@@ -0,0 +1,840 @@ 
+/*
+ * 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 <stddef.h>
+#include <stdint.h>
+
+#include "cbs_h2645.h"
+#include "vvc.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).
+    VVC_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;
+    /* general */
+    uint8_t gci_intra_only_constraint_flag;
+    uint8_t gci_all_layers_independent_constraint_flag;
+    uint8_t gci_one_au_only_constraint_flag;
+
+    /* picture format */
+    uint8_t gci_sixteen_minus_max_bitdepth_constraint_idc;
+    uint8_t gci_three_minus_max_chroma_format_constraint_idc;
+
+    /* NAL unit type related */
+    uint8_t gci_no_mixed_nalu_types_in_pic_constraint_flag;
+    uint8_t gci_no_trail_constraint_flag;
+    uint8_t gci_no_stsa_constraint_flag;
+    uint8_t gci_no_rasl_constraint_flag;
+    uint8_t gci_no_radl_constraint_flag;
+    uint8_t gci_no_idr_constraint_flag;
+    uint8_t gci_no_cra_constraint_flag;
+    uint8_t gci_no_gdr_constraint_flag;
+    uint8_t gci_no_aps_constraint_flag;
+    uint8_t gci_no_idr_rpl_constraint_flag;
+
+    /* tile, slice, subpicture partitioning */
+    uint8_t gci_one_tile_per_pic_constraint_flag;
+    uint8_t gci_pic_header_in_slice_header_constraint_flag;
+    uint8_t gci_one_slice_per_pic_constraint_flag;
+    uint8_t gci_no_rectangular_slice_constraint_flag;
+    uint8_t gci_one_slice_per_subpic_constraint_flag;
+    uint8_t gci_no_subpic_info_constraint_flag;
+
+    /* CTU and block partitioning */
+    uint8_t gci_three_minus_max_log2_ctu_size_constraint_idc;
+    uint8_t gci_no_partition_constraints_override_constraint_flag;
+    uint8_t gci_no_mtt_constraint_flag;
+    uint8_t gci_no_qtbtt_dual_tree_intra_constraint_flag;
+
+    /* intra */
+    uint8_t gci_no_palette_constraint_flag;
+    uint8_t gci_no_ibc_constraint_flag;
+    uint8_t gci_no_isp_constraint_flag;
+    uint8_t gci_no_mrl_constraint_flag;
+    uint8_t gci_no_mip_constraint_flag;
+    uint8_t gci_no_cclm_constraint_flag;
+
+    /* inter */
+    uint8_t gci_no_ref_pic_resampling_constraint_flag;
+    uint8_t gci_no_res_change_in_clvs_constraint_flag;;
+    uint8_t gci_no_weighted_prediction_constraint_flag;
+    uint8_t gci_no_ref_wraparound_constraint_flag;
+    uint8_t gci_no_temporal_mvp_constraint_flag;
+    uint8_t gci_no_sbtmvp_constraint_flag;
+    uint8_t gci_no_amvr_constraint_flag;
+    uint8_t gci_no_bdof_constraint_flag;
+    uint8_t gci_no_smvd_constraint_flag;
+    uint8_t gci_no_dmvr_constraint_flag;
+    uint8_t gci_no_mmvd_constraint_flag;
+    uint8_t gci_no_affine_motion_constraint_flag;
+    uint8_t gci_no_prof_constraint_flag;
+    uint8_t gci_no_bcw_constraint_flag;
+    uint8_t gci_no_ciip_constraint_flag;
+    uint8_t gci_no_gpm_constraint_flag;
+
+    /* transform, quantization, residual */
+    uint8_t gci_no_luma_transform_size_64_constraint_flag;
+    uint8_t gci_no_transform_skip_constraint_flag;
+    uint8_t gci_no_bdpcm_constraint_flag;
+    uint8_t gci_no_mts_constraint_flag;
+    uint8_t gci_no_lfnst_constraint_flag;
+    uint8_t gci_no_joint_cbcr_constraint_flag;
+    uint8_t gci_no_sbt_constraint_flag;
+    uint8_t gci_no_act_constraint_flag;
+    uint8_t gci_no_explicit_scaling_list_constraint_flag;
+    uint8_t gci_no_dep_quant_constraint_flag;
+    uint8_t gci_no_sign_data_hiding_constraint_flag;
+    uint8_t gci_no_cu_qp_delta_constraint_flag;
+    uint8_t gci_no_chroma_qp_offset_constraint_flag;
+
+    /* loop filter */
+    uint8_t gci_no_sao_constraint_flag;
+    uint8_t gci_no_alf_constraint_flag;
+    uint8_t gci_no_ccalf_constraint_flag;
+    uint8_t gci_no_lmcs_constraint_flag;
+    uint8_t gci_no_ladf_constraint_flag;
+    uint8_t gci_no_virtual_boundaries_constraint_flag;
+    uint8_t gci_num_reserved_bits;
+} 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[VVC_MAX_SUBLAYERS - 1];
+    uint8_t  sublayer_level_idc[VVC_MAX_SUBLAYERS - 1];
+    uint8_t  ptl_num_sub_profiles;
+    uint32_t general_sub_profile_idc[VVC_MAX_SUB_PROFILES];
+} 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[VVC_MAX_SUBLAYERS];
+    uint8_t dpb_max_num_reorder_pics[VVC_MAX_SUBLAYERS];
+    uint8_t dpb_max_latency_increase_plus1[VVC_MAX_SUBLAYERS];
+} 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[VVC_MAX_DPB_SIZE + 13];
+    uint8_t st_ref_pic_flag[VVC_MAX_DPB_SIZE + 13];
+    uint8_t abs_delta_poc_st[VVC_MAX_DPB_SIZE + 13];
+    uint8_t strp_entry_sign_flag[VVC_MAX_DPB_SIZE + 13];
+    uint8_t rpls_poc_lsb_lt[VVC_MAX_DPB_SIZE + 13];
+    uint8_t ilrp_idx[VVC_MAX_DPB_SIZE + 13];
+} 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][VVC_MAX_DPB_SIZE + 13];
+    uint8_t  delta_poc_msb_cycle_present_flag[2][VVC_MAX_DPB_SIZE + 13];
+    uint16_t delta_poc_msb_cycle_lt[2][VVC_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[VVC_MAX_CPB_CNT];
+    uint32_t cpb_size_value_minus1[VVC_MAX_CPB_CNT];
+    uint32_t cpb_size_du_value_minus1[VVC_MAX_CPB_CNT];
+    uint32_t bit_rate_du_value_minus1[VVC_MAX_CPB_CNT];
+    uint8_t  cbr_flag[VVC_MAX_CPB_CNT];
+} H266RawSubLayerHRDParameters;
+
+typedef struct H266RawOlsTimingHrdParameters {
+    uint8_t  fixed_pic_rate_general_flag[VVC_MAX_SUBLAYERS];
+    uint8_t  fixed_pic_rate_within_cvs_flag[VVC_MAX_SUBLAYERS];
+    uint16_t elemental_duration_in_tc_minus1[VVC_MAX_SUBLAYERS];
+    uint8_t  low_delay_hrd_flag[VVC_MAX_SUBLAYERS];
+    H266RawSubLayerHRDParameters nal_sub_layer_hrd_parameters[VVC_MAX_SUBLAYERS];
+    H266RawSubLayerHRDParameters vcl_sub_layer_hrd_parameters[VVC_MAX_SUBLAYERS];
+} 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;
+    H266RawExtensionData extension_data;
+} 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;
+    uint16_t sps_num_subpics_minus1;
+    uint8_t  sps_independent_subpics_flag;
+    uint8_t  sps_subpic_same_size_flag;
+    uint16_t sps_subpic_ctu_top_left_x[VVC_MAX_SLICES];
+    uint16_t sps_subpic_ctu_top_left_y[VVC_MAX_SLICES];
+    uint16_t sps_subpic_width_minus1[VVC_MAX_SLICES];
+    uint16_t sps_subpic_height_minus1[VVC_MAX_SLICES];
+    uint8_t  sps_subpic_treated_as_pic_flag[VVC_MAX_SLICES];
+    uint8_t  sps_loop_filter_across_subpic_enabled_flag[VVC_MAX_SLICES];
+    uint8_t  sps_subpic_id_len_minus1;
+    uint8_t  sps_subpic_id_mapping_explicitly_signalled_flag;
+    uint8_t  sps_subpic_id_mapping_present_flag;
+    uint32_t sps_subpic_id[VVC_MAX_SLICES];
+
+
+    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  sps_num_extra_sh_bytes;
+    uint8_t  sps_extra_sh_bit_present_flag[16];
+
+    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[VVC_MAX_PLANES];
+    uint8_t  sps_num_points_in_qp_table_minus1[VVC_MAX_PLANES];
+    uint8_t  sps_delta_qp_in_val_minus1[VVC_MAX_PLANES][VVC_MAX_POINTS_IN_QP_TABLE];
+    uint8_t  sps_delta_qp_diff_val[VVC_MAX_PLANES][VVC_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][VVC_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];
+    uint16_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;
+
+} 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;
+    uint16_t pps_num_subpics_minus1;
+    uint8_t  pps_subpic_id_len_minus1;
+    uint16_t pps_subpic_id[VVC_MAX_SLICES];
+
+    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[VVC_MAX_TILE_COLUMNS];
+    uint16_t pps_tile_row_height_minus1[VVC_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;
+    uint16_t pps_slice_width_in_tiles_minus1[VVC_MAX_SLICES];
+    uint16_t pps_slice_height_in_tiles_minus1[VVC_MAX_SLICES];
+    uint16_t pps_num_exp_slices_in_tile[VVC_MAX_SLICES];
+    uint16_t pps_exp_slice_height_in_ctus_minus1[VVC_MAX_SLICES][VVC_MAX_TILE_ROWS];
+    int16_t  pps_tile_idx_delta_val[VVC_MAX_SLICES];
+
+    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;
+    int8_t   pps_cb_qp_offset;
+    int8_t   pps_cr_qp_offset;
+    uint8_t  pps_joint_cbcr_qp_offset_present_flag;
+    int8_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;
+
+    int8_t   pps_luma_beta_offset_div2;
+    int8_t   pps_luma_tc_offset_div2;
+    int8_t   pps_cb_beta_offset_div2;
+    int8_t   pps_cb_tc_offset_div2;
+    int8_t   pps_cr_beta_offset_div2;
+    int8_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;
+    uint16_t slice_height_in_ctus[VVC_MAX_SLICES];
+    uint16_t num_slices_in_subpic[VVC_MAX_SLICES];
+} H266RawPPS;
+
+typedef struct H266RawAUD {
+    H266RawNALUnitHeader nal_unit_header;
+    uint8_t aud_irap_or_gdr_flag;
+    uint8_t aud_pic_type;
+} H266RawAUD;
+
+typedef struct H266RawPredWeightTable {
+    uint8_t  luma_log2_weight_denom;
+    int8_t   delta_chroma_log2_weight_denom;
+
+    uint8_t  num_l0_weights;
+    uint8_t  luma_weight_l0_flag[15];
+    uint8_t  chroma_weight_l0_flag[15];
+    int8_t   delta_luma_weight_l0[15];
+    int8_t   luma_offset_l0[15];
+    int8_t   delta_chroma_weight_l0[15][2];
+    int16_t  delta_chroma_offset_l0[15][2];
+
+    uint8_t  num_l1_weights;
+    uint8_t  luma_weight_l1_flag[15];
+    uint8_t  chroma_weight_l1_flag[15];
+    int8_t   delta_luma_weight_l1[15];
+    int8_t   luma_offset_l1[15];
+    int8_t   delta_chroma_weight_l1[15][2];
+    int16_t  delta_chroma_offset_l1[15][2];
+} H266RawPredWeightTable;
+
+typedef struct  H266RawPH {
+    H266RawNALUnitHeader nal_unit_header;
+    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[8];
+    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;
+    uint16_t ph_virtual_boundary_pos_x_minus1[3];
+    uint8_t  ph_num_hor_virtual_boundaries;
+    uint16_t ph_virtual_boundary_pos_y_minus1[3];
+
+    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;
+
+    H266RawPredWeightTable ph_pred_weight_table;
+
+    int8_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;
+    int8_t   ph_luma_beta_offset_div2;
+    int8_t   ph_luma_tc_offset_div2;
+    int8_t   ph_cb_beta_offset_div2;
+    int8_t   ph_cb_tc_offset_div2;
+    int8_t   ph_cr_beta_offset_div2;
+    int8_t   ph_cr_tc_offset_div2;
+
+    uint8_t  ph_extension_length;
+    uint8_t  ph_extension_data_byte[256];
+} 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;
+
+    H266RawPredWeightTable sh_pred_weight_table;
+
+    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_slice_header_extension_data_byte[256];
+
+    uint8_t  sh_entry_offset_len_minus1;
+    uint32_t sh_entry_point_offset_minus1[VVC_MAX_ENTRY_POINTS];
+
+} 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 {
+    uint8_t  dph_sei_hash_type;
+    uint8_t  dph_sei_single_component_flag;
+    uint8_t  dph_sei_picture_md5[3][16];
+    uint16_t dph_sei_picture_crc[3];
+    uint32_t dph_sei_picture_checksum[3];
+} 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[VVC_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[VVC_MAX_VPS_COUNT];
+    AVBufferRef *sps_ref[VVC_MAX_SPS_COUNT];
+    AVBufferRef *pps_ref[VVC_MAX_PPS_COUNT];
+    AVBufferRef *ph_ref;
+    H266RawVPS  *vps[VVC_MAX_VPS_COUNT];
+    H266RawSPS  *sps[VVC_MAX_SPS_COUNT];
+    H266RawPPS  *pps[VVC_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..6a6defc8a5
--- /dev/null
+++ b/libavcodec/cbs_h266_syntax_template.c
@@ -0,0 +1,2761 @@ 
+/*
+ * 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 H266_CEIL
+#define H266_CEIL(v, a) (((v) + (a) - 1) / (a))
+#endif
+
+#ifndef H266_HAS_MULTI_SLICES_IN_TILE
+#define H266_HAS_MULTI_SLICES_IN_TILE(pps, tile_y, slice) \
+    (pps->pps_slice_width_in_tiles_minus1[slice] == 0 && \
+    pps->pps_slice_height_in_tiles_minus1[slice] == 0 && \
+    pps->pps_tile_row_height_minus1[tile_y] > 0)
+#endif
+
+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, i;
+
+    flag(gci_present_flag);
+    if (current->gci_present_flag) {
+        /* general */
+        flag(gci_intra_only_constraint_flag);
+        flag(gci_all_layers_independent_constraint_flag);
+        flag(gci_one_au_only_constraint_flag);
+
+        /* picture format */
+        u(4, gci_sixteen_minus_max_bitdepth_constraint_idc, 0, 8);
+        ub(2, gci_three_minus_max_chroma_format_constraint_idc);
+
+        /* NAL unit type related */
+        flag(gci_no_mixed_nalu_types_in_pic_constraint_flag);
+        flag(gci_no_trail_constraint_flag);
+        flag(gci_no_stsa_constraint_flag);
+        flag(gci_no_rasl_constraint_flag);
+        flag(gci_no_radl_constraint_flag);
+        flag(gci_no_idr_constraint_flag);
+        flag(gci_no_cra_constraint_flag);
+        flag(gci_no_gdr_constraint_flag);
+        flag(gci_no_aps_constraint_flag);
+        flag(gci_no_idr_rpl_constraint_flag);
+
+        /* tile, slice, subpicture partitioning */
+        flag(gci_one_tile_per_pic_constraint_flag);
+        flag(gci_pic_header_in_slice_header_constraint_flag);
+        flag(gci_one_slice_per_pic_constraint_flag);
+        flag(gci_no_rectangular_slice_constraint_flag);
+        flag(gci_one_slice_per_subpic_constraint_flag);
+        flag(gci_no_subpic_info_constraint_flag);
+
+        /* CTU and block partitioning */
+        ub(2, gci_three_minus_max_log2_ctu_size_constraint_idc);
+        flag(gci_no_partition_constraints_override_constraint_flag);
+        flag(gci_no_mtt_constraint_flag);
+        flag(gci_no_qtbtt_dual_tree_intra_constraint_flag);
+
+        /* intra */
+        flag(gci_no_palette_constraint_flag);
+        flag(gci_no_ibc_constraint_flag);
+        flag(gci_no_isp_constraint_flag);
+        flag(gci_no_mrl_constraint_flag);
+        flag(gci_no_mip_constraint_flag);
+        flag(gci_no_cclm_constraint_flag);
+
+        /* inter */
+        flag(gci_no_ref_pic_resampling_constraint_flag);
+        flag(gci_no_res_change_in_clvs_constraint_flag);
+        flag(gci_no_weighted_prediction_constraint_flag);
+        flag(gci_no_ref_wraparound_constraint_flag);
+        flag(gci_no_temporal_mvp_constraint_flag);
+        flag(gci_no_sbtmvp_constraint_flag);
+        flag(gci_no_amvr_constraint_flag);
+        flag(gci_no_bdof_constraint_flag);
+        flag(gci_no_smvd_constraint_flag);
+        flag(gci_no_dmvr_constraint_flag);
+        flag(gci_no_mmvd_constraint_flag);
+        flag(gci_no_affine_motion_constraint_flag);
+        flag(gci_no_prof_constraint_flag);
+        flag(gci_no_bcw_constraint_flag);
+        flag(gci_no_ciip_constraint_flag);
+        flag(gci_no_gpm_constraint_flag);
+
+        /* transform, quantization, residual */
+        flag(gci_no_luma_transform_size_64_constraint_flag);
+        flag(gci_no_transform_skip_constraint_flag);
+        flag(gci_no_bdpcm_constraint_flag);
+        flag(gci_no_mts_constraint_flag);
+        flag(gci_no_lfnst_constraint_flag);
+        flag(gci_no_joint_cbcr_constraint_flag);
+        flag(gci_no_sbt_constraint_flag);
+        flag(gci_no_act_constraint_flag);
+        flag(gci_no_explicit_scaling_list_constraint_flag);
+        flag(gci_no_dep_quant_constraint_flag);
+        flag(gci_no_sign_data_hiding_constraint_flag);
+        flag(gci_no_cu_qp_delta_constraint_flag);
+        flag(gci_no_chroma_qp_offset_constraint_flag);
+
+        /* loop filter */
+        flag(gci_no_sao_constraint_flag);
+        flag(gci_no_alf_constraint_flag);
+        flag(gci_no_ccalf_constraint_flag);
+        flag(gci_no_lmcs_constraint_flag);
+        flag(gci_no_ladf_constraint_flag);
+        flag(gci_no_virtual_boundaries_constraint_flag);
+        ub(8, gci_num_reserved_bits);
+        for (i = 0; i < current->gci_num_reserved_bits; i++) {
+            fixed(1, gci_reserved_zero_bit, 1);
+        }
+    }
+    while (byte_alignment(rw) != 0)
+        fixed(1, gci_alignment_zero_bit, 0);
+    return 0;
+}
+
+static int FUNC(profile_tier_level)(CodedBitstreamContext *ctx, RWContext *rw,
+                                    H266RawProfileTierLevel *current,
+                                    int profile_tier_present_flag,
+                                    int max_num_sub_layers_minus1)
+{
+    int err, i;
+
+    if (profile_tier_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_tier_present_flag) {
+        CHECK(FUNC(general_constraints_info)(ctx, rw,
+                                             &current->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) != 0)
+        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_tier_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(payload_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+                                   H266RawExtensionData *current,
+                                   uint32_t payload_size, int cur_pos)
+{
+    int err;
+    size_t byte_length, k;
+
+#ifdef READ
+    GetBitContext tmp;
+    int bits_left, payload_zero_bits;
+
+    if (!cbs_h265_payload_extension_present(rw, payload_size, cur_pos))
+        return 0;
+
+    bits_left = 8 * payload_size - cur_pos;
+    tmp = *rw;
+    if (bits_left > 8)
+        skip_bits_long(&tmp, bits_left - 8);
+    payload_zero_bits = get_bits(&tmp, FFMIN(bits_left, 8));
+    if (!payload_zero_bits)
+        return AVERROR_INVALIDDATA;
+    payload_zero_bits = ff_ctz(payload_zero_bits);
+    current->bit_length = bits_left - payload_zero_bits - 1;
+    allocate(current->data, (current->bit_length + 7) / 8);
+#endif
+
+    byte_length = (current->bit_length + 7) / 8;
+    for (k = 0; k < byte_length; k++) {
+        int length = FFMIN(current->bit_length - k * 8, 8);
+        xu(length, reserved_payload_extension_data, current->data[k],
+           0, MAX_UINT_BITS(length), 0);
+    }
+
+    return 0;
+}
+
+static int FUNC(vui_payload)(CodedBitstreamContext *ctx, RWContext *rw,
+                             H266RawVUI *current, uint16_t vui_payload_size)
+{
+    int err;
+    int start_position, current_position;
+#ifdef READ
+    start_position = get_bits_count(rw);
+#else
+    start_position = put_bits_count(rw);
+#endif
+    CHECK(FUNC(vui_parameters)(ctx, rw, current));
+
+#ifdef READ
+    current_position = get_bits_count(rw) - start_position;
+#else
+    current_position = put_bits_count(rw) - start_position;
+#endif
+    if (current_position < 8 * vui_payload_size) {
+        CHECK(FUNC(payload_extension)(ctx, rw, &current->extension_data,
+                                      vui_payload_size, current_position));
+        fixed(1, vui_payload_bit_equal_to_one, 1);
+        while (byte_alignment(rw) != 0)
+            fixed(1, vui_payload_bit_equal_to_zero, 0);
+    }
+    return 0;
+}
+
+static int FUNC(extension_data)(CodedBitstreamContext *ctx, RWContext *rw,
+                                H266RawExtensionData *current)
+{
+    int err;
+    size_t k;
+#ifdef READ
+    GetBitContext start;
+    uint8_t bit;
+    start = *rw;
+    for (k = 0; cbs_h2645_read_more_rbsp_data(rw); k++)
+        skip_bits(rw, 1);
+    current->bit_length = k;
+    if (k > 0) {
+        *rw = start;
+        allocate(current->data, (current->bit_length + 7) / 8);
+        for (k = 0; k < current->bit_length; k++) {
+            xu(1, extension_data, bit, 0, 1, 0);
+            current->data[k / 8] |= bit << (7 - k % 8);
+        }
+    }
+#else
+    for (k = 0; k < current->bit_length; k++)
+        xu(1, extension_data, current->data[k / 8] >> (7 - k % 8) & 1, 0, 1, 0);
+#endif
+    return 0;
+}
+
+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, VVC_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 *sps)
+{
+
+    int err, i, j;
+    ue(num_ref_entries, 0, VVC_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);
+    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) {
+                    uint8_t bits = sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4;
+                    ubs(bits, rpls_poc_lsb_lt[j], 1, j);
+                    j++;
+                }
+            }
+        } 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, num_ltrp_entries;
+    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] == 0) {
+                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))) {
+                uint8_t bits = av_ceil_log2(sps->sps_num_ref_pic_lists[i]);
+                us(bits, 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(&current->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, &current->rpl_ref_list[i],
+                                            i, sps->sps_num_ref_pic_lists[i], sps));
+        }
+        ref_list = &current->rpl_ref_list[i];
+
+        num_ltrp_entries = 0;
+        for (int i = 0; i < ref_list->num_ref_entries; i++) {
+            if (!ref_list->inter_layer_ref_pic_flag[i]) {
+                if (!ref_list->st_ref_pic_flag[i]) {
+                    num_ltrp_entries++;
+                }
+            }
+        }
+
+        for (j = 0; j < 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]) {
+                uint32_t max = 1 << (32 - sps->sps_log2_max_pic_order_cnt_lsb_minus4 - 4);
+                ues(delta_poc_msb_cycle_lt[i][j], 0, max, 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 *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,
+                                                &current->nal_sub_layer_hrd_parameters[i],
+                                                i, general));
+        if (general->general_vcl_hrd_params_present_flag)
+            CHECK(FUNC(sublayer_hrd_parameters)(ctx, rw,
+                       &current->nal_sub_layer_hrd_parameters[i], i, general));
+    }
+    return 0;
+}
+
+static int FUNC(sps_subpic)(CodedBitstreamContext *ctx, RWContext *rw,
+                     H266RawSPS *current)
+{
+    int err, i;
+    unsigned int ctb_size_y = 1 << (current->sps_log2_ctu_size_minus5 + 5);
+    int tmp_width_val, tmp_height_val;
+
+    tmp_width_val =
+            H266_CEIL(current->sps_pic_width_max_in_luma_samples, ctb_size_y);
+    tmp_height_val =
+            H266_CEIL(current->sps_pic_height_max_in_luma_samples, ctb_size_y);
+
+    flag(sps_subpic_info_present_flag);
+    if (!current->sps_subpic_info_present_flag) {
+        infer(sps_num_subpics_minus1, 0);
+        infer(sps_independent_subpics_flag, 1);
+        infer(sps_subpic_same_size_flag, 0);
+        infer(sps_subpic_id_mapping_explicitly_signalled_flag, 0);
+        infer(sps_subpic_ctu_top_left_x[0], 0);
+        infer(sps_subpic_ctu_top_left_y[0], 0);
+        infer(sps_subpic_width_minus1[0], tmp_width_val - 1);
+        infer(sps_subpic_height_minus1[0], tmp_height_val - 1);
+        return 0;
+    }
+    ue(sps_num_subpics_minus1, 1, VVC_MAX_SLICES - 1);
+    if (current->sps_num_subpics_minus1 > 0) {
+        flag(sps_independent_subpics_flag);
+        flag(sps_subpic_same_size_flag);
+    }
+
+    if (current->sps_num_subpics_minus1 > 0) {
+        int wlen = av_ceil_log2(tmp_width_val);
+        int hlen = av_ceil_log2(tmp_height_val);
+        if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
+            ubs(wlen, sps_subpic_width_minus1[0], 1, 0);
+        else
+            infer(sps_subpic_width_minus1[i], tmp_width_val - 1);
+        if (current->sps_pic_height_max_in_luma_samples > ctb_size_y)
+            ubs(hlen, sps_subpic_height_minus1[0], 1, 0);
+        else
+            infer(sps_subpic_height_minus1[0], tmp_height_val);
+        if (!current->sps_independent_subpics_flag) {
+            flags(sps_subpic_treated_as_pic_flag[0], 1, 0);
+            flags(sps_loop_filter_across_subpic_enabled_flag[0], 1, 0);
+        } else {
+            infer(sps_subpic_treated_as_pic_flag[0], 1);
+            infer(sps_loop_filter_across_subpic_enabled_flag[0], 1);
+        }
+        for (i = 1; i <= current->sps_num_subpics_minus1; i++) {
+            if (!current->sps_subpic_same_size_flag) {
+                if (current->sps_pic_width_max_in_luma_samples > ctb_size_y)
+                    ubs(wlen, sps_subpic_ctu_top_left_x[i], 1, i);
+                else
+                    infer(sps_subpic_ctu_top_left_x[i], 0);
+                if (current->sps_pic_height_max_in_luma_samples > ctb_size_y)
+                    ubs(hlen, sps_subpic_ctu_top_left_y[i], 1, i);
+                else
+                    infer(sps_subpic_ctu_top_left_y[i], 0);
+                if (i < current->sps_num_subpics_minus1 &&
+                    current->sps_pic_width_max_in_luma_samples > ctb_size_y) {
+                    ubs(wlen, sps_subpic_width_minus1[i], 1, i);
+                } else {
+                    infer(sps_subpic_width_minus1[i],
+                            tmp_width_val - current->sps_subpic_ctu_top_left_x[i] - 1);
+                }
+                if (i < current->sps_num_subpics_minus1 &&
+                    current->sps_pic_height_max_in_luma_samples > ctb_size_y) {
+                    ubs(hlen, sps_subpic_height_minus1[i], 1, i);
+                } else   {
+                    infer(sps_subpic_height_minus1[i],
+                        tmp_height_val - current->sps_subpic_ctu_top_left_y[i] - 1);
+                }
+            } else {
+                int num_subpic_cols =
+                    tmp_width_val / (current->sps_subpic_width_minus1[0] + 1);
+                infer(sps_subpic_ctu_top_left_x[i],
+                     (i % num_subpic_cols) *
+                     (current->sps_subpic_width_minus1[0] + 1));
+                infer(sps_subpic_ctu_top_left_y[i],
+                     (i / num_subpic_cols) *
+                     (current->sps_subpic_height_minus1[0] + 1));
+                infer(sps_subpic_width_minus1[i],
+                    current->sps_subpic_width_minus1[0]);
+                infer(sps_subpic_height_minus1[i],
+                    current->sps_subpic_height_minus1[0]);
+            }
+            if (!current->sps_independent_subpics_flag) {
+                flags(sps_subpic_treated_as_pic_flag[i], 1, i);
+                flags(sps_loop_filter_across_subpic_enabled_flag[i], 1, i);
+            } else {
+                infer(sps_subpic_treated_as_pic_flag[i], 1);
+                infer(sps_loop_filter_across_subpic_enabled_flag[i], 0);
+            }
+        }
+        ue(sps_subpic_id_len_minus1, 0, 15);
+        if ((1 << (current->sps_subpic_id_len_minus1 + 1)) <
+            current->sps_num_subpics_minus1 + 1) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR,
+                   "sps_subpic_id_len_minus1(%d) is too small\n",
+                   current->sps_subpic_id_len_minus1);
+            return AVERROR_INVALIDDATA;
+        }
+        flag(sps_subpic_id_mapping_explicitly_signalled_flag);
+        if (current->sps_subpic_id_mapping_explicitly_signalled_flag) {
+            flag(sps_subpic_id_mapping_present_flag);
+            if (current->sps_subpic_id_mapping_present_flag) {
+                for (i = 0; i <= current->sps_num_subpics_minus1; i++) {
+                    ubs(current->sps_subpic_id_len_minus1 + 1,
+                        sps_subpic_id[i], 1, i);
+                }
+            }
+        }
+    } else {
+        infer(sps_subpic_ctu_top_left_x[0], 0);
+        infer(sps_subpic_ctu_top_left_y[0], 0);
+        infer(sps_subpic_width_minus1[0], tmp_width_val - 1);
+        infer(sps_subpic_height_minus1[0], tmp_height_val - 1);
+    }
+    return 0;
+}
+
+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;
+    uint8_t qp_bd_offset;
+
+    static const uint8_t h266_sub_width_c[] = {
+        1, 2, 2, 1
+    };
+    static const uint8_t h266_sub_height_c[] = {
+        1, 2, 1, 1
+    };
+
+    HEADER("Sequence Parameter Set");
+
+    CHECK(FUNC(nal_unit_header)(ctx, rw,
+                                &current->nal_unit_header, VVC_SPS_NUT));
+
+    ub(4, sps_seq_parameter_set_id);
+    ub(4, sps_video_parameter_set_id);
+    if (!current->sps_video_parameter_set_id && !h266->vps[0]) {
+        H266RawVPS *vps0;
+        h266->vps_ref[0] = av_buffer_alloc(sizeof(H266RawVPS));
+        if (!h266->vps_ref[0])
+            return AVERROR(ENOMEM);
+        vps0 = h266->vps[0] = (H266RawVPS *)h266->vps_ref[0]->data;
+        vps0->vps_max_layers_minus1 = 0;
+        //todo: infer all things in 7.4.3.4 sps_video_parameter_set_id paragraph
+    }
+    h266->active_vps = vps = h266->vps[current->sps_video_parameter_set_id];
+
+    u(3, sps_max_sublayers_minus1, 0, VVC_MAX_SUBLAYERS - 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, &current->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, VVC_MAX_WIDTH);
+    ue(sps_pic_height_max_in_luma_samples, 1, VVC_MAX_HEIGHT);
+
+    flag(sps_conformance_window_flag);
+    if (current->sps_conformance_window_flag) {
+        uint8_t sub_width_c = h266_sub_width_c[current->sps_chroma_format_idc];
+        uint8_t sub_height_c = h266_sub_height_c[current->sps_chroma_format_idc];
+        uint16_t width = current->sps_pic_width_max_in_luma_samples / sub_width_c;
+        uint16_t height = current->sps_pic_height_max_in_luma_samples / sub_height_c;
+        ue(sps_conf_win_left_offset, 0, width);
+        ue(sps_conf_win_right_offset, 0, width - current->sps_conf_win_left_offset);
+        ue(sps_conf_win_top_offset, 0, height);
+        ue(sps_conf_win_bottom_offset, 0, height - current->sps_conf_win_top_offset);
+    } 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);
+    }
+
+    CHECK(FUNC(sps_subpic)(ctx, rw, current));
+
+    ue(sps_bitdepth_minus8,   0, 2);
+    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);
+    }
+
+    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);
+    }
+
+    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, &current->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->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 != 0) {
+        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 != 0) {
+        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 != 0) {
+            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 == 0) {
+        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 != 0) {
+        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 != 0) {
+        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 - 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++) {
+                uint8_t max = MAX_UINT_BITS(8);
+                ues(sps_delta_qp_in_val_minus1[i][j], 0, max, 2, i, j);
+                ues(sps_delta_qp_diff_val[i][j], 0, max, 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, VVC_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,
+                                            &current->sps_ref_pic_list_struct[i][j],
+                                            i, j, current));
+    }
+
+    if (current->sps_rpl1_same_as_rpl0_flag) {
+        current->sps_num_ref_pic_lists[1] = current->sps_num_ref_pic_lists[0];
+        for (j = 0; j < current->sps_num_ref_pic_lists[0]; j++)
+            memcpy(&current->sps_ref_pic_list_struct[1][j],
+                   &current->sps_ref_pic_list_struct[0][j],
+                   sizeof(current->sps_ref_pic_list_struct[0][j]));
+    }
+
+    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 != 0)
+        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,
+                &current->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,
+                &current->sps_ols_timing_hrd_parameters, first_sublayer,
+                current->sps_max_sublayers_minus1,
+                &current->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) != 0)
+            fixed(1, sps_vui_alignment_zero_bit, 0);
+        CHECK(FUNC(vui_payload)(ctx, rw, &current->vui,
+                                current->sps_vui_payload_size_minus1 + 1));
+    }
+
+    flag(sps_extension_flag);
+    if (current->sps_extension_flag)
+        CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
+
+    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+
+    return 0;
+}
+
+static int FUNC(pps_slice_info)(CodedBitstreamContext *ctx, RWContext *rw,
+                                const H266RawSPS *sps, H266RawPPS *current)
+{
+    int err, i, j;
+    uint16_t tile_idx = 0, tile_x, tile_y, ctu_x, ctu_y;
+    uint16_t slice_top_left_ctu_x[VVC_MAX_SLICES];
+    uint16_t slice_top_left_ctu_y[VVC_MAX_SLICES];
+    ue(pps_num_slices_in_pic_minus1, 0, VVC_MAX_SLICES - 1);
+    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);
+    for (i = 0; i < current->pps_num_slices_in_pic_minus1; i++) {
+        tile_x = tile_idx % current->num_tile_columns;
+        tile_y = tile_idx / current->num_tile_columns;
+        if (tile_x != current->num_tile_columns - 1) {
+            ues(pps_slice_width_in_tiles_minus1[i],
+                0, current->num_tile_columns - 1, 1, i);
+        } else {
+            infer(pps_slice_width_in_tiles_minus1[i], 0);
+        }
+        if (tile_y != current->num_tile_rows - 1 &&
+            (current->pps_tile_idx_delta_present_flag || tile_x == 0)) {
+            ues(pps_slice_height_in_tiles_minus1[i],
+                0, current->num_tile_rows - 1, 1, i);
+        } else {
+            if (tile_y == current->num_tile_rows - 1)
+                infer(pps_slice_height_in_tiles_minus1[i], 0);
+            else
+                infer(pps_slice_height_in_tiles_minus1[i],
+                      current->pps_slice_height_in_tiles_minus1[i-1]);
+        }
+
+        ctu_x = ctu_y = 0;
+        for (j = 0; j < tile_x; j++) {
+            ctu_x += current->pps_tile_column_width_minus1[j] + 1;
+        }
+        for (j = 0; j < tile_y; j++) {
+            ctu_y += current->pps_tile_row_height_minus1[j] + 1;
+        }
+        if (H266_HAS_MULTI_SLICES_IN_TILE(current, tile_y, i)) {
+            int num_slices_in_tile,
+                uniform_slice_height, remaining_height_in_ctbs_y;
+            remaining_height_in_ctbs_y =
+                current->pps_tile_row_height_minus1[tile_y] + 1;
+            ues(pps_num_exp_slices_in_tile[i],
+                0, current->pps_tile_row_height_minus1[tile_y], 1, i);
+            if (current->pps_num_exp_slices_in_tile[i] == 0) {
+                num_slices_in_tile = 1;
+                slice_top_left_ctu_x[i] = ctu_x;
+                slice_top_left_ctu_y[i] = ctu_y;
+            } else {
+                uint16_t slice_height_in_ctus;
+                for (j = 0; j < current->pps_num_exp_slices_in_tile[i]; j++) {
+                    ues(pps_exp_slice_height_in_ctus_minus1[i][j],
+                        0,  current->pps_tile_row_height_minus1[tile_y], 2, i, j);
+                    slice_height_in_ctus =
+                        current->pps_exp_slice_height_in_ctus_minus1[i][j] + 1;
+
+                    current->slice_height_in_ctus[i + j] = slice_height_in_ctus;
+                    slice_top_left_ctu_x[i + j] = ctu_x;
+                    slice_top_left_ctu_y[i + j] = ctu_y;
+                    ctu_y += slice_height_in_ctus;
+
+                    remaining_height_in_ctbs_y -= slice_height_in_ctus;
+                }
+                uniform_slice_height = 1 +
+                    (j == 0 ? current->pps_tile_row_height_minus1[tile_y] :
+                    current->pps_exp_slice_height_in_ctus_minus1[i][j-1]);
+                while (remaining_height_in_ctbs_y > uniform_slice_height) {
+                    current->slice_height_in_ctus[i + j] = uniform_slice_height;
+                    slice_top_left_ctu_x[i + j] = ctu_x;
+                    slice_top_left_ctu_y[i + j] = ctu_y;
+                    ctu_y += uniform_slice_height;
+
+                    remaining_height_in_ctbs_y -= uniform_slice_height;
+                    j++;
+                }
+                if (remaining_height_in_ctbs_y > 0) {
+                    current->slice_height_in_ctus[i + j] = remaining_height_in_ctbs_y;
+                    slice_top_left_ctu_x[i + j] = ctu_x;
+                    slice_top_left_ctu_y[i + j] = ctu_y;
+                    j++;
+                }
+                num_slices_in_tile = j;
+            }
+            i += num_slices_in_tile - 1;
+        } else {
+            uint16_t height= 0;
+            infer(pps_num_exp_slices_in_tile[i], 0);
+            for (j = 0; j <= current->pps_slice_height_in_tiles_minus1[i]; j++) {
+                height += current->pps_tile_row_height_minus1[tile_y + j] + 1;
+            }
+            current->slice_height_in_ctus[i] = height;
+
+            slice_top_left_ctu_x[i] = ctu_x;
+            slice_top_left_ctu_y[i] = ctu_y;
+        }
+        if (i < current->pps_num_slices_in_pic_minus1) {
+            if (current->pps_tile_idx_delta_present_flag) {
+                ses(pps_tile_idx_delta_val[i],
+                    -current->num_tiles_in_pic + 1, current->num_tiles_in_pic - 1,
+                    1, i);
+                if (current->pps_tile_idx_delta_val[i] == 0) {
+                    av_log(ctx->log_ctx, AV_LOG_ERROR,
+                           "pps_tile_idx_delta_val[i] shall not be equal to 0.\n");
+                }
+                tile_idx += current->pps_tile_idx_delta_val[i];
+            } else {
+                infer(pps_tile_idx_delta_val[i], 0);
+                tile_idx += current->pps_slice_width_in_tiles_minus1[i] + 1;
+                if (tile_idx % current->num_tile_columns == 0) {
+                    tile_idx += current->pps_slice_height_in_tiles_minus1[i] *
+                        current->num_tile_columns;
+                }
+            }
+        }
+    }
+    if (i == current->pps_num_slices_in_pic_minus1) {
+        uint16_t height= 0;
+
+        tile_x = tile_idx % current->num_tile_columns;
+        tile_y = tile_idx / current->num_tile_columns;
+
+        ctu_x = 0, ctu_y = 0;
+        for (j = 0; j < tile_x; j++) {
+            ctu_x += current->pps_tile_column_width_minus1[j] + 1;
+        }
+        for (j = 0; j < tile_y; j++) {
+            ctu_y += current->pps_tile_row_height_minus1[j] + 1;
+        }
+        slice_top_left_ctu_x[i] = ctu_x;
+        slice_top_left_ctu_y[i] = ctu_y;
+
+        current->pps_slice_width_in_tiles_minus1[i] =
+            current->num_tile_columns - tile_x - 1;
+        current->pps_slice_height_in_tiles_minus1[i] =
+            current->num_tile_rows - tile_y - 1;
+
+        for (j = 0; j <= current->pps_slice_height_in_tiles_minus1[i]; j++) {
+            height += current->pps_tile_row_height_minus1[tile_y + j] + 1;
+        }
+        current->slice_height_in_ctus[i] = height;
+
+        infer(pps_num_exp_slices_in_tile[i], 0);
+    }
+
+    //now, we got all slice information, let's resolve NumSlicesInSubpic
+    for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
+        current->num_slices_in_subpic[i] = 0;
+        for (j = 0; j <= current->pps_num_slices_in_pic_minus1; j++) {
+            uint16_t pos_x = 0, pos_y = 0;
+            pos_x = slice_top_left_ctu_x[j];
+            pos_y = slice_top_left_ctu_y[j];
+            if ((pos_x >= sps->sps_subpic_ctu_top_left_x[i]) &&
+                (pos_x < sps->sps_subpic_ctu_top_left_x[i] + sps->sps_subpic_width_minus1[i] + 1) &&
+                (pos_y >= sps->sps_subpic_ctu_top_left_y[i]) &&
+                (pos_y < sps->sps_subpic_ctu_top_left_y[i] + sps->sps_subpic_height_minus1[i] + 1)) {
+                current->num_slices_in_subpic[i]++;
+            }
+        }
+    }
+    return 0;
+}
+
+static int FUNC(pps_tile_info)(CodedBitstreamContext *ctx, RWContext *rw,
+                               const H266RawSPS *sps, H266RawPPS *current)
+{
+    int err, i;
+    uint8_t ctb_size_y = 1 << (sps->sps_log2_ctu_size_minus5 + 5);
+    uint16_t pic_width_in_ctbs_y =
+        H266_CEIL(current->pps_pic_width_in_luma_samples, ctb_size_y);
+    uint16_t pic_height_in_ctbs_y =
+        H266_CEIL(current->pps_pic_height_in_luma_samples, ctb_size_y);
+    if (!current->pps_no_pic_partition_flag) {
+        unsigned int exp_tile_width = 0, exp_tile_height = 0;
+        unsigned int unified_size, remaining_size;
+        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, VVC_MAX_TILE_COLUMNS));
+        ue(pps_num_exp_tile_rows_minus1,
+           0, FFMIN(pic_height_in_ctbs_y - 1, VVC_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;
+        }
+        remaining_size = pic_width_in_ctbs_y - exp_tile_width;
+        unified_size = (i == 0 ? pic_width_in_ctbs_y :
+            (current->pps_tile_column_width_minus1[i - 1] + 1));
+        while (remaining_size > unified_size) {
+            current->pps_tile_column_width_minus1[i] = unified_size - 1;
+            remaining_size -= unified_size;
+            i++;
+        }
+        if (remaining_size > 0) {
+            current->pps_tile_column_width_minus1[i] = remaining_size - 1;
+            i++;
+        }
+        current->num_tile_columns = i;
+
+        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;
+        }
+
+        remaining_size = pic_height_in_ctbs_y - exp_tile_height;
+        unified_size = (i == 0 ? pic_height_in_ctbs_y :
+            (current->pps_tile_row_height_minus1[i - 1] + 1));
+        while (remaining_size > unified_size) {
+            current->pps_tile_row_height_minus1[i] = unified_size - 1;
+            remaining_size -= unified_size;
+            i++;
+        }
+        if (remaining_size > 0) {
+            current->pps_tile_row_height_minus1[i] = remaining_size - 1;
+            i++;
+        }
+        current->num_tile_rows = i;
+
+        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) {
+            CHECK(FUNC(pps_slice_info)(ctx, rw, sps, current));
+        } else {
+            if (current->pps_no_pic_partition_flag)
+                infer(pps_num_slices_in_pic_minus1, 0);
+            else if (current->pps_single_slice_per_subpic_flag)
+                infer(pps_num_slices_in_pic_minus1, sps->sps_num_subpics_minus1);
+            // else?
+        }
+        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_tile_column_width_minus1[0], pic_width_in_ctbs_y - 1);
+        infer(pps_num_exp_tile_rows_minus1, 0);
+        infer(pps_tile_row_height_minus1[0], pic_height_in_ctbs_y - 1);
+        infer(num_tile_columns, 1);
+        infer(num_tile_rows, 1);
+        infer(num_tiles_in_pic, 1);
+    }
+    return 0;
+}
+
+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;
+    uint8_t sub_width_c, sub_height_c, qp_bd_offset;
+
+    static const uint8_t h266_sub_width_c[] = {
+        1, 2, 2, 1
+    };
+    static const uint8_t h266_sub_height_c[] = {
+        1, 2, 1, 1
+    };
+
+    HEADER("Picture Parameter Set");
+
+    CHECK(FUNC(nal_unit_header)(ctx, rw,
+                                &current->nal_unit_header, VVC_PPS_NUT));
+
+    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) {
+        if (!current->pps_no_pic_partition_flag) {
+            ue(pps_num_subpics_minus1,
+               sps->sps_num_subpics_minus1, sps->sps_num_subpics_minus1);
+        } else {
+            infer(pps_num_subpics_minus1, 0);
+        }
+        ue(pps_subpic_id_len_minus1, sps->sps_subpic_id_len_minus1, sps->sps_subpic_id_len_minus1);
+        for (i = 0; i <= current->pps_num_subpics_minus1; i++) {
+            ubs(sps->sps_subpic_id_len_minus1 + 1, pps_subpic_id[i], 1, i);
+        }
+    }
+    CHECK(FUNC(pps_tile_info)(ctx, rw, sps, current));
+
+    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);
+    }
+
+    qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
+    se(pps_init_qp_minus26, -(26 + 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) {
+        flag(pps_deblocking_filter_override_enabled_flag);
+        flag(pps_deblocking_filter_disabled_flag);
+        if (!current->pps_no_pic_partition_flag &&
+            current->pps_deblocking_filter_override_enabled_flag)
+            flag(pps_dbf_info_in_ph_flag);
+        else
+            infer(pps_dbf_info_in_ph_flag, 0);
+        if (!current->pps_deblocking_filter_disabled_flag) {
+            se(pps_luma_beta_offset_div2, -12, 12);
+            se(pps_luma_tc_offset_div2, -12, 12);
+        } else {
+            infer(pps_luma_beta_offset_div2, 0);
+            infer(pps_luma_tc_offset_div2, 0);
+        }
+        if (current->pps_chroma_tool_offsets_present_flag) {
+            se(pps_cb_beta_offset_div2, -12, 12);
+            se(pps_cb_tc_offset_div2, -12, 12);
+            se(pps_cr_beta_offset_div2, -12, 12);
+            se(pps_cr_tc_offset_div2, -12, 12);
+        } else {
+            infer(pps_cb_beta_offset_div2, 0);
+            infer(pps_cb_tc_offset_div2, 0);
+            infer(pps_cr_beta_offset_div2, current->pps_luma_beta_offset_div2);
+            infer(pps_cr_tc_offset_div2, current->pps_luma_tc_offset_div2);
+        }
+    } else {
+        infer(pps_deblocking_filter_override_enabled_flag, 0);
+        infer(pps_deblocking_filter_disabled_flag, 0);
+        infer(pps_dbf_info_in_ph_flag, 0);
+        infer(pps_luma_beta_offset_div2, 0);
+        infer(pps_luma_tc_offset_div2, 0);
+        infer(pps_cb_beta_offset_div2, 0);
+        infer(pps_cb_tc_offset_div2, 0);
+        infer(pps_cr_beta_offset_div2, 0);
+        infer(pps_cr_tc_offset_div2, 0);
+    }
+
+    if (!current->pps_no_pic_partition_flag) {
+        flag(pps_rpl_info_in_ph_flag);
+        flag(pps_sao_info_in_ph_flag);
+        flag(pps_alf_info_in_ph_flag);
+        if ((current->pps_weighted_pred_flag || current->pps_weighted_bipred_flag) &&
+            current->pps_rpl_info_in_ph_flag)
+            flag(pps_wp_info_in_ph_flag);
+        flag(pps_qp_delta_info_in_ph_flag);
+    }
+    flag(pps_picture_header_extension_present_flag);
+    flag(pps_slice_header_extension_present_flag);
+
+    flag(pps_extension_flag);
+    if (current->pps_extension_flag)
+        CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
+
+    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,
+                                &current->nal_unit_header, VVC_AUD_NUT));
+
+    flag(aud_irap_or_gdr_flag);
+    u(3, aud_pic_type, 0, 2);
+
+    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+    return 0;
+}
+
+static int FUNC(pred_weight_table)(CodedBitstreamContext *ctx, RWContext *rw,
+                                   const H266RawSPS *sps,
+                                   const H266RawPPS *pps,
+                                   const H266RefPicLists *ref_lists,
+                                   uint8_t num_ref_idx_active[2],
+                                   H266RawPredWeightTable *current)
+{
+    int err, i, j;
+    uint8_t num_weights_l0, num_weights_l1;
+    ue(luma_log2_weight_denom, 0, 7);
+    if (sps->sps_chroma_format_idc != 0) {
+        se(delta_chroma_log2_weight_denom,
+           -current->luma_log2_weight_denom, 7 - current->luma_log2_weight_denom);
+    } else {
+        infer(delta_chroma_log2_weight_denom, 0);
+    }
+    if (pps->pps_wp_info_in_ph_flag)
+        ue(num_l0_weights, 0, FFMIN(15, ref_lists->rpl_ref_list[0].num_ref_entries));
+    else
+        infer(num_l0_weights, 0);
+    num_weights_l0 = pps->pps_wp_info_in_ph_flag ?
+        current->num_l0_weights : num_ref_idx_active[0];
+    for (i = 0; i < num_weights_l0; i++) {
+        flags(luma_weight_l0_flag[i], 1, i);
+    }
+    if (sps->sps_chroma_format_idc != 0) {
+        for (i = 0; i < num_weights_l0; i++)
+            flags(chroma_weight_l0_flag[i], 1, i);
+    }
+    for (i = 0; i < num_weights_l0; i++) {
+        if (current->luma_weight_l0_flag[i]){
+            ses(delta_luma_weight_l0[i], -128, 127, 1, i);
+            ses(luma_offset_l0[i], -128, 127, 1, i);
+        } else {
+            infer(delta_luma_weight_l0[i], 0);
+            infer(luma_offset_l0[i], 0);
+        }
+        if (current->chroma_weight_l0_flag[i]) {
+            for (j = 0; j < 2; j++) {
+                ses(delta_chroma_weight_l0[i][j], -128, 127, 2, i, j);
+                ses(delta_chroma_offset_l0[i][j], -4 * 128, 4 * 127, 2, i, j);
+            }
+        }
+    }
+
+    if (pps->pps_weighted_bipred_flag && pps->pps_wp_info_in_ph_flag &&
+        ref_lists->rpl_ref_list[1].num_ref_entries > 0) {
+        ue(num_l1_weights, 0, FFMIN(15, ref_lists->rpl_ref_list[1].num_ref_entries));
+    }
+    if (!pps->pps_weighted_bipred_flag ||
+        (pps->pps_wp_info_in_ph_flag &&
+        ref_lists->rpl_ref_list[1].num_ref_entries == 0)) {
+        num_weights_l1 = 0;
+    } else if (pps->pps_wp_info_in_ph_flag) {
+        num_weights_l1 = current->num_l1_weights;
+    } else {
+        num_weights_l1 = num_ref_idx_active[1];
+    }
+
+    for (i = 0; i < num_weights_l1; i++)
+        flags(luma_weight_l1_flag[i], 1, i);
+    if (sps->sps_chroma_format_idc != 0) {
+        for (i = 0; i < num_weights_l1; i++)
+            flags(chroma_weight_l1_flag[i], 1, i);
+    }
+    for (i = 0; i < num_weights_l1; i++) {
+        if (current->luma_weight_l1_flag[i]){
+            ses(delta_luma_weight_l1[i], -128, 127, 1, i);
+            ses(luma_offset_l1[i], -128, 127, 1, i);
+        } else {
+            infer(delta_luma_weight_l1[i], 0);
+            infer(luma_offset_l1[i], 0);
+        }
+        if (current->chroma_weight_l1_flag[i]) {
+            for (j = 0; j < 2; j++) {
+                ses(delta_chroma_weight_l1[i][j], -128, 127, 2, i, j);
+                ses(delta_chroma_offset_l1[i][j], -4 * 128, 4 * 127, 2, i, j);
+            }
+        }
+    }
+    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;
+    uint8_t qp_bd_offset;
+
+    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, VVC_MAX_PPS_COUNT - 1);
+    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",
+               current->ph_pic_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)
+        ue(ph_recovery_poc_cnt, 0, 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4));
+
+    for (i = 0; i < sps->sps_num_extra_ph_bytes * 8; i++) {
+        if (sps->sps_extra_ph_bit_present_flag[i])
+            flags(ph_extra_bit[i], 1, i);
+    }
+    if (sps->sps_poc_msb_cycle_flag) {
+        flag(ph_poc_msb_cycle_present_flag);
+        if (current->ph_poc_msb_cycle_present_flag)
+            ub(sps->sps_poc_msb_cycle_len_minus1 + 1, ph_poc_msb_cycle_val);
+    }
+    if (sps->sps_alf_enabled_flag && pps->pps_alf_info_in_ph_flag) {
+        flag(ph_alf_enabled_flag);
+        if (current->ph_alf_enabled_flag) {
+
+            ub(3, ph_num_alf_aps_ids_luma);
+            for (i = 0; i < current->ph_num_alf_aps_ids_luma; i++)
+                ubs(3, ph_alf_aps_id_luma[i], 1, i);
+
+            if (sps->sps_chroma_format_idc != 0) {
+                flag(ph_alf_cb_enabled_flag);
+                flag(ph_alf_cr_enabled_flag);
+            } else {
+                infer(ph_alf_cb_enabled_flag, 0);
+                infer(ph_alf_cr_enabled_flag, 0);
+            }
+
+            if (current->ph_alf_cb_enabled_flag || current->ph_alf_cr_enabled_flag) {
+                ub(3, ph_alf_aps_id_chroma);
+            }
+
+            if (sps->sps_ccalf_enabled_flag) {
+                flag(ph_alf_cc_cb_enabled_flag);
+                if (current->ph_alf_cc_cb_enabled_flag)
+                    ub(3, ph_alf_cc_cb_aps_id);
+                flag(ph_alf_cc_cr_enabled_flag);
+                if (current->ph_alf_cc_cr_enabled_flag)
+                    ub(3, ph_alf_cc_cr_aps_id);
+            }
+        }
+    } else {
+        infer(ph_alf_enabled_flag, 0);
+    }
+    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) {
+        flag(ph_explicit_scaling_list_enabled_flag);
+        if (current->ph_explicit_scaling_list_enabled_flag) {
+            //todo: check the ph_scaling_list_aps_id range, when aps ready
+            ub(3, ph_scaling_list_aps_id);
+        }
+    } else {
+        infer(ph_explicit_scaling_list_enabled_flag, 0);
+    }
+    if (sps->sps_virtual_boundaries_enabled_flag &&
+        !sps->sps_virtual_boundaries_present_flag) {
+        flag(ph_virtual_boundaries_present_flag);
+        if (current->ph_virtual_boundaries_present_flag) {
+            ue(ph_num_ver_virtual_boundaries,
+               0, pps->pps_pic_width_in_luma_samples <= 8 ? 0 : 3);
+            for (i = 0; i < current->ph_num_ver_virtual_boundaries; i++) {
+                ues(ph_virtual_boundary_pos_x_minus1[i],
+                    0, (pps->pps_pic_width_in_luma_samples + 7) / 8 - 2, 1, i);
+            }
+            ue(ph_num_hor_virtual_boundaries,
+               0, pps->pps_pic_height_in_luma_samples <= 8 ? 0 : 3);
+            for (i = 0; i < current->ph_num_hor_virtual_boundaries; i++) {
+                ues(ph_virtual_boundary_pos_y_minus1[i],
+                    0, (pps->pps_pic_height_in_luma_samples + 7) / 8 - 2, 1, i);
+            }
+        } else {
+            infer(ph_num_ver_virtual_boundaries, 0);
+            infer(ph_num_hor_virtual_boundaries, 0);
+        }
+    }
+    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, &current->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->sps_log2_min_luma_coding_block_size_minus2 + 2;
+    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 != 0) {
+                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 != 0) {
+                    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 + min_cb_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 != 0) {
+                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 + min_cb_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) {
+
+            // if pps->pps_wp_info_in_ph_fla == 1
+            // pred_weight_table will not use num_ref_idx_active
+            uint8_t num_ref_idx_active[2] = {0, 0};
+            CHECK(FUNC(pred_weight_table)(ctx, rw, sps, pps, &current->ph_ref_pic_lists,
+                                          num_ref_idx_active,
+                                          &current->ph_pred_weight_table));
+        }
+    }
+
+    qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
+    if (pps->pps_qp_delta_info_in_ph_flag)
+        se(ph_qp_delta, -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 != 0)
+            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) {
+        flag(ph_deblocking_params_present_flag);
+        if (current->ph_deblocking_params_present_flag) {
+            if (!pps->pps_deblocking_filter_disabled_flag) {
+                flag(ph_deblocking_filter_disabled_flag);
+            } else {
+                if (pps->pps_deblocking_filter_disabled_flag &&
+                    current->ph_deblocking_params_present_flag) {
+                    infer(ph_deblocking_filter_disabled_flag, 0);
+                } else {
+                    infer(ph_deblocking_filter_disabled_flag,
+                          pps->pps_deblocking_filter_disabled_flag);
+                }
+            }
+            if (!current->ph_deblocking_filter_disabled_flag) {
+                se(ph_luma_beta_offset_div2, -12, 12);
+                se(ph_luma_tc_offset_div2, -12, 12);
+                if (pps->pps_chroma_tool_offsets_present_flag) {
+                    se(ph_cb_beta_offset_div2, -12, 12);
+                    se(ph_cb_tc_offset_div2, -12, 12);
+                    se(ph_cr_beta_offset_div2, -12, 12);
+                    se(ph_cr_tc_offset_div2, -12, 12);
+                } else {
+                    infer(ph_cb_beta_offset_div2, current->ph_luma_beta_offset_div2);
+                    infer(ph_cb_tc_offset_div2, current->ph_luma_tc_offset_div2);
+                    infer(ph_cr_beta_offset_div2, current->ph_luma_beta_offset_div2);
+                    infer(ph_cr_tc_offset_div2, current->ph_luma_tc_offset_div2);
+                }
+            } else {
+                infer(ph_luma_beta_offset_div2, pps->pps_luma_beta_offset_div2);
+                infer(ph_luma_tc_offset_div2, pps->pps_luma_tc_offset_div2);
+                if (pps->pps_chroma_tool_offsets_present_flag) {
+                    infer(ph_cb_beta_offset_div2, pps->pps_cb_beta_offset_div2);
+                    infer(ph_cb_tc_offset_div2, pps->pps_cb_tc_offset_div2);
+                    infer(ph_cr_beta_offset_div2, pps->pps_cr_beta_offset_div2);
+                    infer(ph_cr_tc_offset_div2, pps->pps_cr_tc_offset_div2);
+                } else {
+                    infer(ph_cb_beta_offset_div2, current->ph_luma_beta_offset_div2);
+                    infer(ph_cb_tc_offset_div2, current->ph_luma_tc_offset_div2);
+                    infer(ph_cr_beta_offset_div2, current->ph_luma_beta_offset_div2);
+                    infer(ph_cr_tc_offset_div2, current->ph_luma_tc_offset_div2);
+                }
+            }
+        }
+    }
+
+    if (pps->pps_picture_header_extension_present_flag) {
+        ue(ph_extension_length, 0, 256);
+        for (i = 0; i < current->ph_extension_length; i++)
+            us(8, ph_extension_data_byte[i], 0x00, 0xff, 1, i);
+    }
+
+    return 0;
+}
+
+static int FUNC(ph)(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
+{
+    int err;
+
+    HEADER("Picture Header");
+
+    CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, VVC_PH_NUT));
+    CHECK(FUNC(picture_header)(ctx, rw, current));
+    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+    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, qp_bd_offset;
+    uint16_t curr_subpic_idx;
+    uint16_t num_slices_in_subpic;
+
+    HEADER("Slice Header");
+
+    CHECK(FUNC(nal_unit_header)(ctx, rw, &current->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, &current->sh_picture_header));
+        if (!h266->ph_ref) {
+            h266->ph_ref = av_buffer_allocz(sizeof(H266RawPH));
+            if (!h266->ph_ref)
+                return AVERROR(ENOMEM);
+            h266->active_ph = h266->ph = (H266RawPH*)h266->ph_ref->data;
+        }
+        memcpy(h266->ph, &current->sh_picture_header, sizeof(H266RawPH));
+    }
+    sps = h266->active_sps;
+    pps = h266->active_pps;
+    ph  = h266->active_ph;
+
+    if (!sps || !pps || !ph) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "no sps(%p)/pps(%p)/ph(%p).\n", sps, pps, ph);
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (sps->sps_subpic_info_present_flag) {
+        ub(sps->sps_subpic_id_len_minus1 + 1, sh_subpic_id);
+        if (sps->sps_subpic_id_mapping_explicitly_signalled_flag) {
+            for (i = 0; i <= sps->sps_num_subpics_minus1; i++) {
+                uint16_t subpic_id_val = pps->pps_subpic_id_mapping_present_flag ?
+                    pps->pps_subpic_id[i] : sps->sps_subpic_id[i];
+                if (subpic_id_val == current->sh_subpic_id) {
+                    curr_subpic_idx = i;
+                    break;
+                }
+            }
+        } else {
+            curr_subpic_idx = current->sh_subpic_id;
+            if (curr_subpic_idx > sps->sps_num_subpics_minus1) {
+                av_log(ctx->log_ctx, AV_LOG_ERROR,
+                       "sh_subpic_id(%d) should in range [0, %d]\n",
+                       curr_subpic_idx, sps->sps_num_subpics_minus1);
+                return AVERROR_INVALIDDATA;
+            }
+        }
+    } else {
+        curr_subpic_idx = 0;
+    }
+
+    num_slices_in_subpic = pps->num_slices_in_subpic[curr_subpic_idx];
+
+    if ((pps->pps_rect_slice_flag && num_slices_in_subpic > 1) ||
+        (!pps->pps_rect_slice_flag && pps->num_tiles_in_pic > 1)) {
+        unsigned int bits, max;
+        if (!pps->pps_rect_slice_flag) {
+            bits = av_ceil_log2(pps->num_tiles_in_pic);
+            max = pps->num_tiles_in_pic - 1;
+        } else {
+            bits = av_ceil_log2(num_slices_in_subpic);
+            max = num_slices_in_subpic - 1;
+        }
+        u(bits, sh_slice_address, 0, max);
+    } else {
+        infer(sh_slice_address, 0);
+    }
+
+    for (i = 0; i < sps->sps_num_extra_sh_bytes * 8; i++) {
+        if (sps->sps_extra_sh_bit_present_flag[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 == VVC_IDR_W_RADL ||
+        nal_unit_type == VVC_IDR_N_LP ||
+        nal_unit_type == VVC_CRA_NUT ||
+        nal_unit_type == VVC_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 != VVC_IDR_W_RADL &&
+        nal_unit_type != VVC_IDR_N_LP) ||
+        sps->sps_idr_rpl_present_flag)) {
+        CHECK(FUNC(ref_pic_lists)(ctx, rw, &current->sh_ref_pic_lists));
+        ref_pic_lists = &current->sh_ref_pic_lists;
+    } else {
+        ref_pic_lists = &h266->ph->ph_ref_pic_lists;
+    }
+    if ((current->sh_slice_type != VVC_SLICE_TYPE_I &&
+        ref_pic_lists->rpl_ref_list[0].num_ref_entries > 1) ||
+        (current->sh_slice_type == VVC_SLICE_TYPE_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 == VVC_SLICE_TYPE_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 != VVC_SLICE_TYPE_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) {
+            uint8_t num_ref_idx_active[2];
+            for (i = 0; i < 2; i++) {
+                if (current->sh_slice_type == VVC_SLICE_TYPE_B ||
+                    (current->sh_slice_type == VVC_SLICE_TYPE_P && i == 0)) {
+                    if (current->sh_num_ref_idx_active_override_flag) {
+                        num_ref_idx_active[i] = current->sh_num_ref_idx_active_minus1[i] + 1;
+                    }
+                    else {
+                        num_ref_idx_active[i] =
+                            FFMIN(ref_pic_lists->rpl_ref_list[i].num_ref_entries,
+                                  pps->pps_num_ref_idx_default_active_minus1[i] + 1);
+                    }
+                } else {
+                    num_ref_idx_active[i] = 0;
+                }
+            }
+
+            if (current->sh_slice_type == VVC_SLICE_TYPE_B)
+                flag(sh_collocated_from_l0_flag);
+            else
+                infer(sh_collocated_from_l0_flag, 1);
+            if ((current->sh_collocated_from_l0_flag && num_ref_idx_active[0] > 1) ||
+                (!current->sh_collocated_from_l0_flag && num_ref_idx_active[1] > 1)) {
+                unsigned int idx = current->sh_collocated_from_l0_flag ? 0 : 1;
+                ue(sh_collocated_ref_idx, 0, num_ref_idx_active[idx] - 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 == VVC_SLICE_TYPE_P) ||
+                (pps->pps_weighted_bipred_flag &&
+                current->sh_slice_type == VVC_SLICE_TYPE_B))) {
+                CHECK(FUNC(pred_weight_table)(ctx, rw, sps, pps, ref_pic_lists,
+                                              num_ref_idx_active,
+                                              &current->sh_pred_weight_table));
+                }
+        }
+
+    }
+    qp_bd_offset = 6 * sps->sps_bitdepth_minus8;
+    if (!pps->pps_qp_delta_info_in_ph_flag)
+        se(sh_qp_delta, -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) {
+        int8_t off;
+
+        se(sh_cb_qp_offset, -12, 12);
+        off = pps->pps_cb_qp_offset + current->sh_cb_qp_offset;
+        if (off < -12 || off > 12) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR,
+                   "pps_cb_qp_offset + sh_cb_qp_offset (%d) not in range [-12, 12].\n",
+                   off);
+            return AVERROR_INVALIDDATA;
+        }
+
+        se(sh_cr_qp_offset, -12, 12);
+        off = pps->pps_cr_qp_offset + current->sh_cr_qp_offset;
+        if (off < -12 || off > 12) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR,
+                   "pps_cr_qp_offset + sh_cr_qp_offset (%d) not in range [-12, 12].\n",
+                   off);
+            return AVERROR_INVALIDDATA;
+        }
+
+        if (sps->sps_joint_cbcr_enabled_flag) {
+            se(sh_joint_cbcr_qp_offset, -12, 12);
+            off = pps->pps_joint_cbcr_qp_offset_value + current->sh_joint_cbcr_qp_offset;
+            if (off < -12 || off > 12) {
+                av_log(ctx->log_ctx, AV_LOG_ERROR,
+                       "pps_joint_cbcr_qp_offset_value + sh_joint_cbcr_qp_offset (%d)"
+                       "not in range [-12, 12]. \n",
+                       off);
+                return AVERROR_INVALIDDATA;
+            }
+        } else {
+            infer(sh_joint_cbcr_qp_offset, 0);
+        }
+    } else {
+        infer(sh_cb_qp_offset, 0);
+        infer(sh_cr_qp_offset, 0);
+        infer(sh_joint_cbcr_qp_offset, 0);
+    }
+    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) {
+        if (!pps->pps_deblocking_filter_disabled_flag)
+            flag(sh_deblocking_filter_disabled_flag);
+        else
+            infer(sh_deblocking_filter_disabled_flag,
+                !(pps->pps_deblocking_filter_disabled_flag &&
+                current->sh_deblocking_params_present_flag));
+        if (!current->sh_deblocking_filter_disabled_flag) {
+            se(sh_luma_beta_offset_div2, -12, 12);
+            se(sh_luma_tc_offset_div2, -12, 12);
+            if (pps->pps_chroma_tool_offsets_present_flag) {
+                se(sh_cb_beta_offset_div2, -12, 12);
+                se(sh_cb_tc_offset_div2, -12, 12);
+                se(sh_cr_beta_offset_div2, -12, 12);
+                se(sh_cr_tc_offset_div2, -12, 12);
+            } else {
+                infer(sh_cb_beta_offset_div2, current->sh_luma_beta_offset_div2);
+                infer(sh_cb_tc_offset_div2, current->sh_luma_tc_offset_div2);
+                infer(sh_cr_beta_offset_div2, current->sh_luma_beta_offset_div2);
+                infer(sh_cr_tc_offset_div2, current->sh_luma_tc_offset_div2);
+            }
+        } else {
+            infer(sh_luma_beta_offset_div2, ph->ph_luma_beta_offset_div2);
+            infer(sh_luma_tc_offset_div2, ph->ph_luma_tc_offset_div2);
+            if (pps->pps_chroma_tool_offsets_present_flag) {
+                infer(sh_cb_beta_offset_div2, ph->ph_cb_beta_offset_div2);
+                infer(sh_cb_tc_offset_div2, ph->ph_cb_tc_offset_div2);
+                infer(sh_cr_beta_offset_div2, ph->ph_cr_beta_offset_div2);
+                infer(sh_cr_tc_offset_div2, ph->ph_cr_beta_offset_div2);
+            } else {
+                infer(sh_cb_beta_offset_div2, current->sh_luma_beta_offset_div2);
+                infer(sh_cb_tc_offset_div2, current->sh_luma_tc_offset_div2);
+                infer(sh_cr_beta_offset_div2, current->sh_luma_beta_offset_div2);
+                infer(sh_cr_tc_offset_div2, current->sh_luma_tc_offset_div2);
+            }
+        }
+    }
+
+    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) {
+        ue(sh_slice_header_extension_length, 0, 256);
+        for (i = 0; i < current->sh_slice_header_extension_length; i++)
+            us(8, sh_slice_header_extension_data_byte[i], 0x00, 0xff, 1, i);
+    }
+    if (sps->sps_entry_point_offsets_present_flag)  {
+        int num_entry_points = 0;
+        uint8_t entropy_sync = sps->sps_entropy_coding_sync_enabled_flag;
+        int height;
+        if (pps->pps_rect_slice_flag) {
+            int width_in_tiles;
+            int slice_idx = current->sh_slice_address;
+            for (i = 0; i < curr_subpic_idx; i++) {
+                slice_idx += pps->num_slices_in_subpic[i];
+            }
+            width_in_tiles =
+                pps->pps_slice_width_in_tiles_minus1[slice_idx] + 1;
+
+            if (entropy_sync)
+                height = pps->slice_height_in_ctus[slice_idx];
+            else
+                height = pps->pps_slice_height_in_tiles_minus1[slice_idx] + 1;
+
+            num_entry_points = width_in_tiles * height;
+        } else {
+            int tile_idx;
+            int tile_y;
+            for (tile_idx = current->sh_slice_address;
+                tile_idx <= current->sh_slice_address + current->sh_num_tiles_in_slice_minus1;
+                tile_idx++) {
+                tile_y = tile_idx / pps->num_tile_rows;
+                height = pps->pps_tile_row_height_minus1[tile_y] + 1;
+                num_entry_points += (entropy_sync ? height : 1);
+            }
+        }
+        num_entry_points--;
+        if (num_entry_points > VVC_MAX_ENTRY_POINTS) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many entry points: "
+                   "%"PRIu16".\n", num_entry_points);
+            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 + 1,
+                    sh_entry_point_offset_minus1[i], 1, i);
+            }
+        }
+    }
+    CHECK(FUNC(byte_alignment)(ctx, rw));
+
+    return 0;
+}
+
+static int FUNC(sei_decoded_picture_hash)(CodedBitstreamContext *ctx, RWContext *rw,
+                                          H266RawSEIDecodedPictureHash *current)
+{
+    int err, c, i;
+
+    HEADER("Decoded Picture Hash");
+
+    u(8, dph_sei_hash_type, 0, 2);
+    flag(dph_sei_single_component_flag);
+    fixed(7, ph_sei_reserved_zero_7bits, 0);
+
+    for (c = 0; c < (current->dph_sei_single_component_flag ? 1 : 3); c++) {
+        if (current->dph_sei_hash_type == 0) {
+            for (i = 0; i < 16; i++)
+                us(8, dph_sei_picture_md5[c][i], 0x00, 0xff, 2, c, i);
+        } else if (current->dph_sei_hash_type == 1) {
+            us(16, dph_sei_picture_crc[c], 0x0000, 0xffff, 1, c);
+        } else if (current->dph_sei_hash_type == 2) {
+            us(32, dph_sei_picture_checksum[c], 0x00000000, 0xffffffff, 1, c);
+        }
+    }
+    return 0;
+}
+
+
+static int FUNC(sei_payload)(CodedBitstreamContext *ctx, RWContext *rw,
+                             H266RawSEIPayload *current, int prefix)
+{
+    int err, i;
+    int start_position, current_position;
+#ifdef WRITE
+    int more_data = !!current->extension_data.bit_length;
+#endif
+
+#ifdef READ
+    start_position = get_bits_count(rw);
+#else
+    start_position = put_bits_count(rw);
+#endif
+
+    switch (current->payload_type) {
+#define SEI_TYPE_CHECK_VALID(name, prefix_valid, suffix_valid) do { \
+            if (prefix && !prefix_valid) { \
+                av_log(ctx->log_ctx, AV_LOG_ERROR, "SEI type %s invalid " \
+                       "as prefix SEI!\n", #name); \
+                return AVERROR_INVALIDDATA; \
+            } \
+            if (!prefix && !suffix_valid) { \
+                av_log(ctx->log_ctx, AV_LOG_ERROR, "SEI type %s invalid " \
+                       "as suffix SEI!\n", #name); \
+                return AVERROR_INVALIDDATA; \
+            } \
+        } while (0)
+#define SEI_TYPE_N(type, prefix_valid, suffix_valid, name) \
+    case VVC_SEI_TYPE_ ## type: \
+        SEI_TYPE_CHECK_VALID(name, prefix_valid, suffix_valid); \
+        CHECK(FUNC(sei_ ## name)(ctx, rw, &current->payload.name)); \
+        break
+#define SEI_TYPE_S(type, prefix_valid, suffix_valid, name) \
+    case VVC_SEI_TYPE_ ## type: \
+        SEI_TYPE_CHECK_VALID(name, prefix_valid, suffix_valid); \
+        CHECK(FUNC(sei_ ## name)(ctx, rw, &current->payload.name, \
+                                 &current->payload_size)); \
+        break
+#define SEI_TYPE_E(type, prefix_valid, suffix_valid, name) \
+    case VVC_SEI_TYPE_ ## type: \
+        SEI_TYPE_CHECK_VALID(name, prefix_valid, suffix_valid); \
+        CHECK(FUNC(sei_ ## name)(ctx, rw, &current->payload.name, \
+                                 &current->payload_size, \
+                                 &more_data)); \
+        break
+
+        SEI_TYPE_N(DECODED_PICTURE_HASH,     0, 1, decoded_picture_hash);
+#undef SEI_TYPE_N
+#undef SEI_TYPE_S
+#undef SEI_TYPE_E
+    default:
+        {
+#ifdef READ
+            current->payload.other.data_length = current->payload_size;
+#endif
+            allocate(current->payload.other.data, current->payload.other.data_length);
+
+            for (i = 0; i < current->payload_size; i++)
+                xu(8, payload_byte[i], current->payload.other.data[i], 0, 255,
+                   1, i);
+        }
+    }
+
+    // more_data_in_payload()
+#ifdef READ
+    current_position = get_bits_count(rw) - start_position;
+    if (current_position < 8 * current->payload_size) {
+#else
+    current_position = put_bits_count(rw) - start_position;
+    if (byte_alignment(rw) || more_data) {
+#endif
+        CHECK(FUNC(payload_extension)(ctx, rw, &current->extension_data,
+                                      current->payload_size, current_position));
+        fixed(1, bit_equal_to_one, 1);
+        while (byte_alignment(rw))
+            fixed(1, bit_equal_to_zero, 0);
+    }
+
+#ifdef WRITE
+    current->payload_size = (put_bits_count(rw) - start_position) >> 3;
+#endif
+
+    return 0;
+}
+
+static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw,
+                     H266RawSEI *current, int prefix)
+{
+    int err, k;
+
+    if (prefix)
+        HEADER("Prefix Supplemental Enhancement Information");
+    else
+        HEADER("Suffix Supplemental Enhancement Information");
+
+    CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
+                                prefix ? VVC_PREFIX_SEI_NUT
+                                       : VVC_SUFFIX_SEI_NUT));
+
+#ifdef READ
+    for (k = 0; k < VVC_MAX_SEI_PAYLOADS; k++) {
+        uint32_t payload_type = 0;
+        uint32_t payload_size = 0;
+        uint32_t tmp;
+
+        while (show_bits(rw, 8) == 0xff) {
+            fixed(8, payload_type_byte, 0xff);
+            payload_type += 255;
+        }
+        xu(8, payload_type_byte, tmp, 0, 254, 0);
+        payload_type += tmp;
+
+        while (show_bits(rw, 8) == 0xff) {
+            fixed(8, payload_size_byte, 0xff);
+            payload_size += 255;
+        }
+        xu(8, payload_size_byte, tmp, 0, 254, 0);
+        payload_size += tmp;
+
+        current->payload[k].payload_type = payload_type;
+        current->payload[k].payload_size = payload_size;
+
+        current->payload_count++;
+        CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k], prefix));
+
+        if (!cbs_h2645_read_more_rbsp_data(rw))
+            break;
+    }
+    if (k >= VVC_MAX_SEI_PAYLOADS) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many payloads in "
+               "SEI message: found %d.\n", k);
+        return AVERROR_INVALIDDATA;
+    }
+#else
+    for (k = 0; k < current->payload_count; k++) {
+        PutBitContext start_state;
+        uint32_t tmp;
+        int need_size, i;
+
+        // Somewhat clumsy: we write the payload twice when
+        // we don't know the size in advance.  This will mess
+        // with trace output, but is otherwise harmless.
+        start_state = *rw;
+        need_size = !current->payload[k].payload_size;
+        for (i = 0; i < 1 + need_size; i++) {
+            *rw = start_state;
+
+            tmp = current->payload[k].payload_type;
+            while (tmp >= 255) {
+                fixed(8, payload_type_byte, 0xff);
+                tmp -= 255;
+            }
+            xu(8, payload_type_byte, tmp, 0, 254, 0);
+
+            tmp = current->payload[k].payload_size;
+            while (tmp >= 255) {
+                fixed(8, payload_type_byte, 0xff);
+                tmp -= 255;
+            }
+            xu(8, payload_type_byte, tmp, 0, 254, 0);
+
+            CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k], prefix));
+        }
+    }
+#endif
+
+    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+
+    return 0;
+}
diff --git a/libavcodec/cbs_internal.h b/libavcodec/cbs_internal.h
index a392880036..118b1052d4 100644
--- a/libavcodec/cbs_internal.h
+++ b/libavcodec/cbs_internal.h
@@ -40,7 +40,7 @@  enum CBSContentType {
 enum {
       // Maximum number of unit types described by the same unit type
       // descriptor.
-      CBS_MAX_UNIT_TYPES  = 3,
+      CBS_MAX_UNIT_TYPES  = 4,
       // Maximum number of reference buffer offsets in any one unit.
       CBS_MAX_REF_OFFSETS = 2,
       // Special value used in a unit type descriptor to indicate that it
@@ -204,6 +204,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;