diff mbox series

[FFmpeg-devel,v6,4/9] avcodec: add cbs for h266/vvc

Message ID 20210217015146.19724-5-nuomi2021@gmail.com
State Superseded
Headers show
Series add vvc raw demuxer, muxer, parser, metadata bsf
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 Feb. 17, 2021, 1:51 a.m. UTC
---
 configure                             |    2 +
 libavcodec/Makefile                   |    1 +
 libavcodec/cbs.c                      |    6 +
 libavcodec/cbs_h2645.c                |  541 ++++-
 libavcodec/cbs_h266.h                 |  817 +++++++
 libavcodec/cbs_h266_syntax_template.c | 3006 +++++++++++++++++++++++++
 libavcodec/cbs_internal.h             |    3 +-
 libavcodec/cbs_sei.c                  |   29 +
 8 files changed, 4397 insertions(+), 8 deletions(-)
 create mode 100644 libavcodec/cbs_h266.h
 create mode 100644 libavcodec/cbs_h266_syntax_template.c

Comments

Mark Thompson Feb. 18, 2021, 12:03 a.m. UTC | #1
On 17/02/2021 01:51, Nuo Mi wrote:
> ---
>   configure                             |    2 +
>   libavcodec/Makefile                   |    1 +
>   libavcodec/cbs.c                      |    6 +
>   libavcodec/cbs_h2645.c                |  541 ++++-
>   libavcodec/cbs_h266.h                 |  817 +++++++
>   libavcodec/cbs_h266_syntax_template.c | 3006 +++++++++++++++++++++++++
>   libavcodec/cbs_internal.h             |    3 +-
>   libavcodec/cbs_sei.c                  |   29 +
>   8 files changed, 4397 insertions(+), 8 deletions(-)
>   create mode 100644 libavcodec/cbs_h266.h
>   create mode 100644 libavcodec/cbs_h266_syntax_template.c
> 
> diff --git a/configure b/configure
> index a76c2ec4ae..11df59a229 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 3341801b97..23553e68e9 100644
> --- a/libavcodec/Makefile
> +++ b/libavcodec/Makefile
> @@ -73,6 +73,7 @@ OBJS-$(CONFIG_CBS)                     += cbs.o cbs_bsf.o
>   OBJS-$(CONFIG_CBS_AV1)                 += cbs_av1.o
>   OBJS-$(CONFIG_CBS_H264)                += cbs_h2645.o cbs_sei.o h2645_parse.o
>   OBJS-$(CONFIG_CBS_H265)                += cbs_h2645.o cbs_sei.o h2645_parse.o
> +OBJS-$(CONFIG_CBS_H266)                += cbs_h2645.o cbs_sei.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 57c419aa05..d39464ba49 100644
> --- a/libavcodec/cbs_h2645.c
> +++ b/libavcodec/cbs_h2645.c
> @@ -24,12 +24,129 @@
>   #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"
>   
> +#define H266_IS_SLICE(nut) (nut <= VVC_RASL_NUT || (nut >= VVC_IDR_W_RADL && nut <= VVC_GDR_NUT))
> +#define H266_IS_IDR(nut) (nut == VVC_IDR_W_RADL || nut == VVC_IDR_N_LP)
> +
> +static void h266_au_detector_init(H266AuDetector* d)
> +{
> +    if (!d->inited) {
> +        d->prev_layer_id = UINT8_MAX;
> +        d->prev_poc = INT_MAX;
> +        d->prev_tid0_poc = INT_MAX;
> +        d->inited = 1;
> +    }
> +}
> +
> +//8.3.1 Decoding process for picture order count.
> +//VTM did not follow the spec, and it's much simpler than spec.
> +//We follow the VTM.

To clarify, does that mean that the VTM is wrong or that the spec defines it in an equivalent way which is overly complicated?

> +static int h266_get_slice_poc(CodedBitstreamH266Context *h266, void* log_ctx,
> +                              const H266RawPH *ph, const H266RawSliceHeader *slice,
> +                              int *poc)
> +{
> +    int poc_msb, max_poc_lsb, poc_lsb;
> +    H266AuDetector* d = &h266->priv.au_detector;
> +    const H266RawSPS* sps;
> +    const H266RawPPS* pps;

Please keep the '*'s as part of the declarator, not the declaration-specifiers (in lots of places in these functions).

> +
> +    pps = h266->pps[ph->ph_pic_parameter_set_id];
> +    if (!pps) {
> +        av_log(log_ctx, AV_LOG_ERROR, "PPS id %d is not avaliable.\n",
> +               ph->ph_pic_parameter_set_id);
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    sps = h266->sps[pps->pps_seq_parameter_set_id];
> +    if (!sps) {
> +        av_log(log_ctx, AV_LOG_ERROR, "SPS id %d is not avaliable.\n",
> +               pps->pps_seq_parameter_set_id);
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
> +    poc_lsb = ph->ph_pic_order_cnt_lsb;
> +    if (H266_IS_IDR(slice->nal_unit_header.nal_unit_type)) {
> +        if (ph->ph_poc_msb_cycle_present_flag)
> +            poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
> +        else
> +            poc_msb = 0;
> +    } else {
> +        int prev_poc = d->prev_tid0_poc;
> +        int prev_poc_lsb = prev_poc & (max_poc_lsb - 1);
> +        int prev_poc_msb = prev_poc - prev_poc_lsb;
> +        if (ph->ph_poc_msb_cycle_present_flag) {
> +             poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
> +        } else {
> +            if ((poc_lsb < prev_poc_lsb) && ((prev_poc_lsb - poc_lsb) >= (max_poc_lsb / 2)))
> +                poc_msb = prev_poc_msb + max_poc_lsb;
> +            else if ((poc_lsb > prev_poc_lsb) && ((poc_lsb - prev_poc_lsb) > (max_poc_lsb / 2)))
> +                poc_msb = prev_poc_msb - max_poc_lsb;
> +            else
> +                poc_msb = prev_poc_msb;
> +        }
> +    }
> +
> +    *poc = poc_msb + poc_lsb;
> +    return 0;
> +}
> +
> +int h266_is_au_start(CodedBitstreamH266Context *h266, CodedBitstreamFragment *pu, void* log_ctx)

As an unexported global, this needs an "ff_" prefix.

> +{
> +    //7.4.2.4.3
> +    H266AuDetector *d = &h266->priv.au_detector;
> +    int i, ret;
> +    const H266RawNALUnitHeader *nal;
> +    const H266RawPH *ph = h266->ph;
> +    const H266RawSlice *slice = NULL;
> +    int poc, nut;
> +
> +    if (!ph) {
> +        av_log(log_ctx, AV_LOG_ERROR, "can't find picture header in picutre unit.\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> +    for (i = 0; i < pu->nb_units; i++) {
> +        nal = pu->units[i].content;
> +        if (!nal)
> +            continue;
> +        if (H266_IS_SLICE(nal->nal_unit_type)) {
> +            slice = pu->units[i].content;
> +            break;
> +        }
> +    }
> +    if (!slice) {
> +        av_log(log_ctx, AV_LOG_ERROR, "can't find first slice.\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> +
> +    h266_au_detector_init(&h266->priv.au_detector);
> +
> +    if ((ret = h266_get_slice_poc(h266, log_ctx, ph, &slice->header, &poc)) < 0)
> +        return ret;
> +
> +    ret = (nal->nuh_layer_id <= d->prev_layer_id) || (poc != d->prev_poc);
> +
> +    nut = nal->nal_unit_type;
> +    d->prev_layer_id = nal->nuh_layer_id;
> +    d->prev_poc = poc;
> +    if (nal->nuh_temporal_id_plus1 == 1 &&
> +        !ph->ph_non_ref_pic_flag && nut != VVC_RADL_NUT && nut != VVC_RASL_NUT) {
> +        d->prev_tid0_poc = poc;
> +    }
> +    return ret;
> +}

None of this logic is used by the syntax tables, so I think move it down below them.

> +
> +static av_always_inline unsigned int h266_ceil(unsigned int v, unsigned int align)
> +{
> +    return (((v) + (align) - 1) / (align));
> +}
>   
>   static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,
>                                 const char *name, const int *subscripts,
> ...
> @@ -515,6 +641,12 @@ static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx,
>       if (frag->data_size == 0)
>           return 0;
>   
> +    if (codec_id == AV_CODEC_ID_VVC) {
> +        //we deactive picture header here to avoid reuse previous frame's ph.
> +        CodedBitstreamH266Context* h266 = ctx->priv_data;
> +        h266->ph = NULL;
> +    }
> +
>       if (header && frag->data[0] && codec_id == AV_CODEC_ID_H264) {
>           // AVCC header.
>           size_t size, start, end;
> @@ -716,6 +848,12 @@ static int cbs_h2645_replace_ps(CodedBitstreamContext *ctx,
>       H2645_PS_TYPE(H265, HEVC_NAL_ ## cname, cname, uname, \
>                     HEVC_MAX_ ## cname ## _COUNT, \
>                     uname ## _ ## id_name, active_ ## uname)
> +#define H266_PS_TYPE(cname, uname, id_name) \
> +        H26456_PS_TYPE(H266, VVC_ ## cname ## _NUT, cname, uname, \
> +            VVC_MAX_ ## cname ## _COUNT, \
> +            offsetof(H266 ## Raw ## cname, uname ## _ ## id_name ## _parameter_set_id), \
> +            0)

As I said in the comment on the previous patch, offsetof(common) is zero so there is no need to mess around with adding more offsetof()s.

> +#define H266_PH_TYPE  H26456_PS_TYPE(H266, VVC_PH_NUT, PH, ph, 1, 0, 0)

I'm not convinced that reusing the replace-PS function for the PH is making this nicer (including the name).  Expanding the unref/ref inline looks simpler than adding extra special cases here.

>   
>       static const PSType ps_types[] = {
>           H264_PS_TYPE(SPS, sps, seq),
> @@ -723,6 +861,10 @@ static int cbs_h2645_replace_ps(CodedBitstreamContext *ctx,
>           H265_PS_TYPE(VPS, vps, video),
>           H265_PS_TYPE(SPS, sps, seq),
>           H265_PS_TYPE(PPS, pps, pic),
> +        H266_PS_TYPE(VPS, vps, video),
> +        H266_PS_TYPE(SPS, sps, seq),
> +        H266_PS_TYPE(PPS, pps, pic),
> +        H266_PH_TYPE,
>       };
>   
>       const PSType *ps_type;
> @@ -1019,6 +1161,131 @@ static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
>       return 0;
>   }
>   
> ...
>   static int cbs_h2645_unit_requires_zero_byte(enum AVCodecID codec_id,
>                                                CodedBitstreamUnitType type,
> -                                             int nal_unit_index)
> +                                             int nal_unit_index, int h266_au_start)
>   {
> -    // Section B.1.2 in H.264, section B.2.2 in H.265.
> +    // Section B.1.2 in H.264, section B.2.2 in H.265, H.266.
>       if (nal_unit_index == 0) {
> -        // Assume that this is the first NAL unit in an access unit.
> -        return 1;
> +        if (codec_id == AV_CODEC_ID_VVC) {
> +            if (h266_au_start)
> +                return 1;
> +        } else {
> +            // Assume that this is the first NAL unit in an access unit.
> +            return 1;
> +        }
>       }
>       if (codec_id == AV_CODEC_ID_H264)
>           return type == H264_NAL_SPS || type == H264_NAL_PPS;
>       if (codec_id == AV_CODEC_ID_HEVC)
>           return type == HEVC_NAL_VPS || type == HEVC_NAL_SPS || type == HEVC_NAL_PPS;
> +    if (codec_id == AV_CODEC_ID_VVC)
> +        return type >= VVC_OPI_NUT && type <= VVC_SUFFIX_APS_NUT; >       return 0;
>   }
>   
> @@ -1327,7 +1717,7 @@ static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>   {
>       uint8_t *data;
>       size_t max_size, dp, sp;
> -    int err, i, zero_run;
> +    int err, i, zero_run, h266_au_start = 0;
>   
>       for (i = 0; i < frag->nb_units; i++) {
>           // Data should already all have been written when we get here.
> @@ -1343,7 +1733,10 @@ static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>       data = av_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);
>       if (!data)
>           return AVERROR(ENOMEM);
> -
> +    if (ctx->codec->codec_id == AV_CODEC_ID_VVC) {
> +        CodedBitstreamH266Context *h266 = ctx->priv_data;
> +        h266_au_start = h266_is_au_start(h266, frag, ctx->log_ctx) > 0;
> +    }

It is unclear to me why this wants a special case.

The current logic is that we are writing an AU, so the first NAL unit in it is necessarily an AU start and subsequent NAL units are not?

>       dp = 0;
>       for (i = 0; i < frag->nb_units; i++) {
>           CodedBitstreamUnit *unit = &frag->units[i];
> @@ -1356,7 +1749,7 @@ static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>                   frag->data_bit_padding = unit->data_bit_padding;
>           }
>   
> -        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id, unit->type, i)) {
> +        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id, unit->type, i, h266_au_start)) {
>               // zero_byte
>               data[dp++] = 0;
>           }
> @@ -1470,6 +1863,37 @@ static void cbs_h265_close(CodedBitstreamContext *ctx)
>           av_buffer_unref(&h265->pps_ref[i]);
>   }
>   
> ...
> diff --git a/libavcodec/cbs_h266.h b/libavcodec/cbs_h266.h
> new file mode 100644
> index 0000000000..20d547a26d
> --- /dev/null
> +++ b/libavcodec/cbs_h266.h
> @@ -0,0 +1,817 @@
> +/*
> + * 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 "cbs_sei.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,

Not used anywhere.

> +};
> +
> +typedef struct H266RawNALUnitHeader {
> +    uint8_t nuh_layer_id;
> +    uint8_t nal_unit_type;
> +    uint8_t nuh_temporal_id_plus1;
> +    uint8_t nuh_reserved_zero_bit;
> +} H266RawNALUnitHeader;
> +
> ...
> +
> +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];
> +
> +    uint8_t  ph_sei_reserved_zero_7bits;

"dph"

> +} H266RawSEIDecodedPictureHash;
> +
> +typedef struct H266RawSEIPayload {
> +    uint32_t payload_type;
> +    uint32_t payload_size;
> +    union {
> +        H266RawSEIDecodedPictureHash decoded_picture_hash;
> +        struct {
> +            uint8_t     *data;
> +            AVBufferRef *data_ref;
> +            size_t       data_length;
> +        } other;
> +    } payload;
> +    H266RawExtensionData extension_data;
> +} H266RawSEIPayload;

Not used.

> +
> +typedef struct H266RawSEI {
> +    H266RawNALUnitHeader nal_unit_header;
> +    SEIRawMessageList    message_list;
> +} H266RawSEI;
> +
> +typedef struct H266AuDetector {
> +    uint8_t inited;
> +    uint8_t prev_layer_id;
> +    int prev_tid0_poc;
> +    int prev_poc;
> +} H266AuDetector;
> +
> +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_SPS_COUNT];
> +    H266RawSPS  *sps[VVC_MAX_SPS_COUNT];
> +    H266RawPPS  *pps[VVC_MAX_PPS_COUNT];
> +    H266RawPH   *ph;
> +
> +    struct {
> +        H266AuDetector au_detector;
> +    } priv;

What is the extra struct layer doing?  This is already the private context for an H.266 CBS instance.

> +
> +} CodedBitstreamH266Context;
> +
> ... > +
> +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->ph = (H266RawPH*)h266->ph_ref->data;
> +        memcpy(h266->ph, &current->sh_picture_header, sizeof(H266RawPH));

This memcpy() is naughty - if that was a ref to a previous picture header then you've just overwritten the reference while the other unit still holds it.

If the slice is unit->content then unit->content_ref is a reference to a superstructure of the picture header, avoiding the copy, but I'm not sure it's the right way to do it.

Is it right that the two possible options here are:
* Store a ref, which might be to a newly-allocated buffer or might be to a previous unit.
* Store the whole structure in the private context.
?

If the structure isn't too large, then the second option feels much simpler.

If it is large such that holding references and avoiding copies is beneficial (which is quite large, every ref entails a malloc/free call-pair), then we probably want that ref to always be to the unit?

> +    }
> +
> +    ph = h266->ph;
> +    if (!ph) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Picture header not available.\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> ...
> 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,

Heh, fair :)

>         // 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;
> diff --git a/libavcodec/cbs_sei.c b/libavcodec/cbs_sei.c
> index c49830ad77..96c60259ce 100644
> --- a/libavcodec/cbs_sei.c
> +++ b/libavcodec/cbs_sei.c
> @@ -20,6 +20,7 @@
>   #include "cbs_internal.h"
>   #include "cbs_h264.h"
>   #include "cbs_h265.h"
> +#include "cbs_h266.h"
>   #include "cbs_sei.h"
>   
>   static void cbs_free_user_data_registered(void *opaque, uint8_t *data)
> @@ -132,6 +133,13 @@ static int cbs_sei_get_unit(CodedBitstreamContext *ctx,
>           else
>               sei_type = HEVC_NAL_SEI_SUFFIX;
>           break;
> +    case AV_CODEC_ID_H266:
> +        highest_vcl_type = VVC_RSV_IRAP_11;
> +        if (prefix)
> +            sei_type = VVC_PREFIX_SEI_NUT;
> +        else
> +            sei_type = VVC_SUFFIX_SEI_NUT;
> +        break;
>       default:
>           return AVERROR(EINVAL);
>       }
> @@ -207,6 +215,18 @@ static int cbs_sei_get_unit(CodedBitstreamContext *ctx,
>               memcpy(unit->content, &sei, sizeof(sei));
>           }
>           break;
> +    case AV_CODEC_ID_H266:
> +        {
> +            H266RawSEI sei = {
> +                .nal_unit_header = {
> +                    .nal_unit_type         = sei_type,
> +                    .nuh_layer_id          = 0,
> +                    .nuh_temporal_id_plus1 = 1,
> +                },
> +            };
> +            memcpy(unit->content, &sei, sizeof(sei));
> +        }
> +        break;
>       default:
>           av_assert0(0);
>       }
> @@ -237,6 +257,15 @@ static int cbs_sei_get_message_list(CodedBitstreamContext *ctx,
>               *list = &sei->message_list;
>           }
>           break;
> +    case AV_CODEC_ID_H266:
> +        {
> +            H266RawSEI *sei = unit->content;
> +            if (unit->type != VVC_PREFIX_SEI_NUT &&
> +                unit->type != VVC_SUFFIX_SEI_NUT)
> +                return AVERROR(EINVAL);
> +            *list = &sei->message_list;
> +        }
> +        break;

Yay, I'm glad the SEI stuff fitted in nicely with no extra weird cases.

>       default:
>           return AVERROR(EINVAL);
>       }
> 
Thanks,

- Mark
Nuo Mi Feb. 18, 2021, 3:14 p.m. UTC | #2
On Thu, Feb 18, 2021 at 8:04 AM Mark Thompson <sw@jkqxz.net> wrote:

> On 17/02/2021 01:51, Nuo Mi wrote:
> > ---
> >   configure                             |    2 +
> >   libavcodec/Makefile                   |    1 +
> >   libavcodec/cbs.c                      |    6 +
> >   libavcodec/cbs_h2645.c                |  541 ++++-
> >   libavcodec/cbs_h266.h                 |  817 +++++++
> >   libavcodec/cbs_h266_syntax_template.c | 3006 +++++++++++++++++++++++++
> >   libavcodec/cbs_internal.h             |    3 +-
> >   libavcodec/cbs_sei.c                  |   29 +
> >   8 files changed, 4397 insertions(+), 8 deletions(-)
> >   create mode 100644 libavcodec/cbs_h266.h
> >   create mode 100644 libavcodec/cbs_h266_syntax_template.c
> >
> > diff --git a/configure b/configure
> > index a76c2ec4ae..11df59a229 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 3341801b97..23553e68e9 100644
> > --- a/libavcodec/Makefile
> > +++ b/libavcodec/Makefile
> > @@ -73,6 +73,7 @@ OBJS-$(CONFIG_CBS)                     += cbs.o
> cbs_bsf.o
> >   OBJS-$(CONFIG_CBS_AV1)                 += cbs_av1.o
> >   OBJS-$(CONFIG_CBS_H264)                += cbs_h2645.o cbs_sei.o
> h2645_parse.o
> >   OBJS-$(CONFIG_CBS_H265)                += cbs_h2645.o cbs_sei.o
> h2645_parse.o
> > +OBJS-$(CONFIG_CBS_H266)                += cbs_h2645.o cbs_sei.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 57c419aa05..d39464ba49 100644
> > --- a/libavcodec/cbs_h2645.c
> > +++ b/libavcodec/cbs_h2645.c
> > @@ -24,12 +24,129 @@
> >   #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"
> >
> > +#define H266_IS_SLICE(nut) (nut <= VVC_RASL_NUT || (nut >=
> VVC_IDR_W_RADL && nut <= VVC_GDR_NUT))
> > +#define H266_IS_IDR(nut) (nut == VVC_IDR_W_RADL || nut == VVC_IDR_N_LP)
> > +
> > +static void h266_au_detector_init(H266AuDetector* d)
> > +{
> > +    if (!d->inited) {
> > +        d->prev_layer_id = UINT8_MAX;
> > +        d->prev_poc = INT_MAX;
> > +        d->prev_tid0_poc = INT_MAX;
> > +        d->inited = 1;
> > +    }
> > +}
> > +
> > +//8.3.1 Decoding process for picture order count.
> > +//VTM did not follow the spec, and it's much simpler than spec.
> > +//We follow the VTM.
>
> To clarify, does that mean that the VTM is wrong or that the spec defines
> it in an equivalent way which is overly complicated?
>
Yes, It equals, Spec is over complicated. Spec defined many constrain for
encoder, decoder does not need  care about it.

>
> > +static int h266_get_slice_poc(CodedBitstreamH266Context *h266, void*
> log_ctx,
> > +                              const H266RawPH *ph, const
> H266RawSliceHeader *slice,
> > +                              int *poc)
> > +{
> > +    int poc_msb, max_poc_lsb, poc_lsb;
> > +    H266AuDetector* d = &h266->priv.au_detector;
> > +    const H266RawSPS* sps;
> > +    const H266RawPPS* pps;
>
> Please keep the '*'s as part of the declarator, not the
> declaration-specifiers (in lots of places in these functions).
>
Used a regex to search and replace. should be done now

>
> > +
> > +    pps = h266->pps[ph->ph_pic_parameter_set_id];
> > +    if (!pps) {
> > +        av_log(log_ctx, AV_LOG_ERROR, "PPS id %d is not avaliable.\n",
> > +               ph->ph_pic_parameter_set_id);
> > +        return AVERROR_INVALIDDATA;
> > +    }
> > +
> > +    sps = h266->sps[pps->pps_seq_parameter_set_id];
> > +    if (!sps) {
> > +        av_log(log_ctx, AV_LOG_ERROR, "SPS id %d is not avaliable.\n",
> > +               pps->pps_seq_parameter_set_id);
> > +        return AVERROR_INVALIDDATA;
> > +    }
> > +
> > +    max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
> > +    poc_lsb = ph->ph_pic_order_cnt_lsb;
> > +    if (H266_IS_IDR(slice->nal_unit_header.nal_unit_type)) {
> > +        if (ph->ph_poc_msb_cycle_present_flag)
> > +            poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
> > +        else
> > +            poc_msb = 0;
> > +    } else {
> > +        int prev_poc = d->prev_tid0_poc;
> > +        int prev_poc_lsb = prev_poc & (max_poc_lsb - 1);
> > +        int prev_poc_msb = prev_poc - prev_poc_lsb;
> > +        if (ph->ph_poc_msb_cycle_present_flag) {
> > +             poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
> > +        } else {
> > +            if ((poc_lsb < prev_poc_lsb) && ((prev_poc_lsb - poc_lsb)
> >= (max_poc_lsb / 2)))
> > +                poc_msb = prev_poc_msb + max_poc_lsb;
> > +            else if ((poc_lsb > prev_poc_lsb) && ((poc_lsb -
> prev_poc_lsb) > (max_poc_lsb / 2)))
> > +                poc_msb = prev_poc_msb - max_poc_lsb;
> > +            else
> > +                poc_msb = prev_poc_msb;
> > +        }
> > +    }
> > +
> > +    *poc = poc_msb + poc_lsb;
> > +    return 0;
> > +}
> > +
> > +int h266_is_au_start(CodedBitstreamH266Context *h266,
> CodedBitstreamFragment *pu, void* log_ctx)
>
> As an unexported global, this needs an "ff_" prefix.
>
fixed

>
> > +{
> > +    //7.4.2.4.3
> > +    H266AuDetector *d = &h266->priv.au_detector;
> > +    int i, ret;
> > +    const H266RawNALUnitHeader *nal;
> > +    const H266RawPH *ph = h266->ph;
> > +    const H266RawSlice *slice = NULL;
> > +    int poc, nut;
> > +
> > +    if (!ph) {
> > +        av_log(log_ctx, AV_LOG_ERROR, "can't find picture header in
> picutre unit.\n");
> > +        return AVERROR_INVALIDDATA;
> > +    }
> > +    for (i = 0; i < pu->nb_units; i++) {
> > +        nal = pu->units[i].content;
> > +        if (!nal)
> > +            continue;
> > +        if (H266_IS_SLICE(nal->nal_unit_type)) {
> > +            slice = pu->units[i].content;
> > +            break;
> > +        }
> > +    }
> > +    if (!slice) {
> > +        av_log(log_ctx, AV_LOG_ERROR, "can't find first slice.\n");
> > +        return AVERROR_INVALIDDATA;
> > +    }
> > +
> > +    h266_au_detector_init(&h266->priv.au_detector);
> > +
> > +    if ((ret = h266_get_slice_poc(h266, log_ctx, ph, &slice->header,
> &poc)) < 0)
> > +        return ret;
> > +
> > +    ret = (nal->nuh_layer_id <= d->prev_layer_id) || (poc !=
> d->prev_poc);
> > +
> > +    nut = nal->nal_unit_type;
> > +    d->prev_layer_id = nal->nuh_layer_id;
> > +    d->prev_poc = poc;
> > +    if (nal->nuh_temporal_id_plus1 == 1 &&
> > +        !ph->ph_non_ref_pic_flag && nut != VVC_RADL_NUT && nut !=
> VVC_RASL_NUT) {
> > +        d->prev_tid0_poc = poc;
> > +    }
> > +    return ret;
> > +}
>
> None of this logic is used by the syntax tables, so I think move it down
> below them.
>
Done

>
> > +
> > +static av_always_inline unsigned int h266_ceil(unsigned int v, unsigned
> int align)
> > +{
> > +    return (((v) + (align) - 1) / (align));
> > +}
> >
> >   static int cbs_read_ue_golomb(CodedBitstreamContext *ctx,
> GetBitContext *gbc,
> >                                 const char *name, const int *subscripts,
> > ...
> > @@ -515,6 +641,12 @@ static int
> cbs_h2645_split_fragment(CodedBitstreamContext *ctx,
> >       if (frag->data_size == 0)
> >           return 0;
> >
> > +    if (codec_id == AV_CODEC_ID_VVC) {
> > +        //we deactive picture header here to avoid reuse previous
> frame's ph.
> > +        CodedBitstreamH266Context* h266 = ctx->priv_data;
> > +        h266->ph = NULL;
> > +    }
> > +
> >       if (header && frag->data[0] && codec_id == AV_CODEC_ID_H264) {
> >           // AVCC header.
> >           size_t size, start, end;
> > @@ -716,6 +848,12 @@ static int
> cbs_h2645_replace_ps(CodedBitstreamContext *ctx,
> >       H2645_PS_TYPE(H265, HEVC_NAL_ ## cname, cname, uname, \
> >                     HEVC_MAX_ ## cname ## _COUNT, \
> >                     uname ## _ ## id_name, active_ ## uname)
> > +#define H266_PS_TYPE(cname, uname, id_name) \
> > +        H26456_PS_TYPE(H266, VVC_ ## cname ## _NUT, cname, uname, \
> > +            VVC_MAX_ ## cname ## _COUNT, \
> > +            offsetof(H266 ## Raw ## cname, uname ## _ ## id_name ##
> _parameter_set_id), \
> > +            0)
>
> As I said in the comment on the previous patch, offsetof(common) is zero
> so there is no need to mess around with adding more offsetof()s.
>
> > +#define H266_PH_TYPE  H26456_PS_TYPE(H266, VVC_PH_NUT, PH, ph, 1, 0, 0)
>
> I'm not convinced that reusing the replace-PS function for the PH is
> making this nicer (including the name).  Expanding the unref/ref inline
> looks simpler than adding extra special cases here.
>
I will change it

>
> >
> >       static const PSType ps_types[] = {
> >           H264_PS_TYPE(SPS, sps, seq),
> > @@ -723,6 +861,10 @@ static int
> cbs_h2645_replace_ps(CodedBitstreamContext *ctx,
> >           H265_PS_TYPE(VPS, vps, video),
> >           H265_PS_TYPE(SPS, sps, seq),
> >           H265_PS_TYPE(PPS, pps, pic),
> > +        H266_PS_TYPE(VPS, vps, video),
> > +        H266_PS_TYPE(SPS, sps, seq),
> > +        H266_PS_TYPE(PPS, pps, pic),
> > +        H266_PH_TYPE,
> >       };
> >
> >       const PSType *ps_type;
> > @@ -1019,6 +1161,131 @@ static int
> cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
> >       return 0;
> >   }
> >
> > ...
> >   static int cbs_h2645_unit_requires_zero_byte(enum AVCodecID codec_id,
> >                                                CodedBitstreamUnitType
> type,
> > -                                             int nal_unit_index)
> > +                                             int nal_unit_index, int
> h266_au_start)
> >   {
> > -    // Section B.1.2 in H.264, section B.2.2 in H.265.
> > +    // Section B.1.2 in H.264, section B.2.2 in H.265, H.266.
> >       if (nal_unit_index == 0) {
> > -        // Assume that this is the first NAL unit in an access unit.
> > -        return 1;
> > +        if (codec_id == AV_CODEC_ID_VVC) {
> > +            if (h266_au_start)
> > +                return 1;
> > +        } else {
> > +            // Assume that this is the first NAL unit in an access unit.
> > +            return 1;
> > +        }
> >       }
> >       if (codec_id == AV_CODEC_ID_H264)
> >           return type == H264_NAL_SPS || type == H264_NAL_PPS;
> >       if (codec_id == AV_CODEC_ID_HEVC)
> >           return type == HEVC_NAL_VPS || type == HEVC_NAL_SPS || type ==
> HEVC_NAL_PPS;
> > +    if (codec_id == AV_CODEC_ID_VVC)
> > +        return type >= VVC_OPI_NUT && type <= VVC_SUFFIX_APS_NUT; >
>    return 0;
> >   }
> >
> > @@ -1327,7 +1717,7 @@ static int
> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
> >   {
> >       uint8_t *data;
> >       size_t max_size, dp, sp;
> > -    int err, i, zero_run;
> > +    int err, i, zero_run, h266_au_start = 0;
> >
> >       for (i = 0; i < frag->nb_units; i++) {
> >           // Data should already all have been written when we get here.
> > @@ -1343,7 +1733,10 @@ static int
> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
> >       data = av_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);
> >       if (!data)
> >           return AVERROR(ENOMEM);
> > -
> > +    if (ctx->codec->codec_id == AV_CODEC_ID_VVC) {
> > +        CodedBitstreamH266Context *h266 = ctx->priv_data;
> > +        h266_au_start = h266_is_au_start(h266, frag, ctx->log_ctx) > 0;
> > +    }
>
> It is unclear to me why this wants a special case.
>
> The current logic is that we are writing an AU, so the first NAL unit in
> it is necessarily an AU start and subsequent NAL units are not?
>
H.266 AU contains one or more PU(3.105). One PU contains one coded picture.
Only the first NAL unit of an AU needs the zero_byte(B.2.2)
H.265 has no PU, each AU has one coded picture(3.1)
H.266's PU is the H.265's AU. In vvc_parser, we split bitstream to PU.

>
> >       dp = 0;
> >       for (i = 0; i < frag->nb_units; i++) {
> >           CodedBitstreamUnit *unit = &frag->units[i];
> > @@ -1356,7 +1749,7 @@ static int
> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
> >                   frag->data_bit_padding = unit->data_bit_padding;
> >           }
> >
> > -        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id,
> unit->type, i)) {
> > +        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id,
> unit->type, i, h266_au_start)) {
> >               // zero_byte
> >               data[dp++] = 0;
> >           }
> > @@ -1470,6 +1863,37 @@ static void cbs_h265_close(CodedBitstreamContext
> *ctx)
> >           av_buffer_unref(&h265->pps_ref[i]);
> >   }
> >
> > ...
> > diff --git a/libavcodec/cbs_h266.h b/libavcodec/cbs_h266.h
> > new file mode 100644
> > index 0000000000..20d547a26d
> > --- /dev/null
> > +++ b/libavcodec/cbs_h266.h
> > @@ -0,0 +1,817 @@
> > +/*
> > + * 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 "cbs_sei.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,
>
> Not used anywhere.
>
removed

>
> > +};
> > +
> > +typedef struct H266RawNALUnitHeader {
> > +    uint8_t nuh_layer_id;
> > +    uint8_t nal_unit_type;
> > +    uint8_t nuh_temporal_id_plus1;
> > +    uint8_t nuh_reserved_zero_bit;
> > +} H266RawNALUnitHeader;
> > +
> > ...
> > +
> > +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];
> > +
> > +    uint8_t  ph_sei_reserved_zero_7bits;
>
> "dph"
>
fixed

>
> > +} H266RawSEIDecodedPictureHash;
> > +
> > +typedef struct H266RawSEIPayload {
> > +    uint32_t payload_type;
> > +    uint32_t payload_size;
> > +    union {
> > +        H266RawSEIDecodedPictureHash decoded_picture_hash;
> > +        struct {
> > +            uint8_t     *data;
> > +            AVBufferRef *data_ref;
> > +            size_t       data_length;
> > +        } other;
> > +    } payload;
> > +    H266RawExtensionData extension_data;
> > +} H266RawSEIPayload;
>
> Not used.
>
removed

>
> > +
> > +typedef struct H266RawSEI {
> > +    H266RawNALUnitHeader nal_unit_header;
> > +    SEIRawMessageList    message_list;
> > +} H266RawSEI;
> > +
> > +typedef struct H266AuDetector {
> > +    uint8_t inited;
> > +    uint8_t prev_layer_id;
> > +    int prev_tid0_poc;
> > +    int prev_poc;
> > +} H266AuDetector;
> > +
> > +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_SPS_COUNT];
> > +    H266RawSPS  *sps[VVC_MAX_SPS_COUNT];
> > +    H266RawPPS  *pps[VVC_MAX_PPS_COUNT];
> > +    H266RawPH   *ph;
> > +
> > +    struct {
> > +        H266AuDetector au_detector;
> > +    } priv;
>
> What is the extra struct layer doing?  This is already the private context
> for an H.266 CBS instance.
>
The caller can touch the sps and pps. But, for au_detector, it's should not
use by the caller, it can only be used by the ff_h266_is_au_start function

>
> > +
> > +} CodedBitstreamH266Context;
> > +
> > ... > +
> > +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->ph = (H266RawPH*)h266->ph_ref->data;
> > +        memcpy(h266->ph, &current->sh_picture_header,
> sizeof(H266RawPH));
>
> This memcpy() is naughty - if that was a ref to a previous picture header
> then you've just overwritten the reference while the other unit still holds
> it.
>
> If the slice is unit->content then unit->content_ref is a reference to a
> superstructure of the picture header, avoiding the copy, but I'm not sure
> it's the right way to do it.
>
> Is it right that the two possible options here are:
> * Store a ref, which might be to a newly-allocated buffer or might be to a
> previous unit.
>
* Store the whole structure in the private context.
>
?
>
> If the structure isn't too large, then the second option feels much
> simpler.
>
> If it is large such that holding references and avoiding copies is
> beneficial (which is quite large, every ref entails a malloc/free
> call-pair), then we probably want that ref to always be to the unit?
>
If we store the whole structure, it's hard to detect the picture header
missing case.

>
> > +    }
> > +
> > +    ph = h266->ph;
> > +    if (!ph) {
> > +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Picture header not
> available.\n");
> > +        return AVERROR_INVALIDDATA;
> > +    }
> > ...
> > 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,
>
> Heh, fair :)
>
> >         // 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;
> > diff --git a/libavcodec/cbs_sei.c b/libavcodec/cbs_sei.c
> > index c49830ad77..96c60259ce 100644
> > --- a/libavcodec/cbs_sei.c
> > +++ b/libavcodec/cbs_sei.c
> > @@ -20,6 +20,7 @@
> >   #include "cbs_internal.h"
> >   #include "cbs_h264.h"
> >   #include "cbs_h265.h"
> > +#include "cbs_h266.h"
> >   #include "cbs_sei.h"
> >
> >   static void cbs_free_user_data_registered(void *opaque, uint8_t *data)
> > @@ -132,6 +133,13 @@ static int cbs_sei_get_unit(CodedBitstreamContext
> *ctx,
> >           else
> >               sei_type = HEVC_NAL_SEI_SUFFIX;
> >           break;
> > +    case AV_CODEC_ID_H266:
> > +        highest_vcl_type = VVC_RSV_IRAP_11;
> > +        if (prefix)
> > +            sei_type = VVC_PREFIX_SEI_NUT;
> > +        else
> > +            sei_type = VVC_SUFFIX_SEI_NUT;
> > +        break;
> >       default:
> >           return AVERROR(EINVAL);
> >       }
> > @@ -207,6 +215,18 @@ static int cbs_sei_get_unit(CodedBitstreamContext
> *ctx,
> >               memcpy(unit->content, &sei, sizeof(sei));
> >           }
> >           break;
> > +    case AV_CODEC_ID_H266:
> > +        {
> > +            H266RawSEI sei = {
> > +                .nal_unit_header = {
> > +                    .nal_unit_type         = sei_type,
> > +                    .nuh_layer_id          = 0,
> > +                    .nuh_temporal_id_plus1 = 1,
> > +                },
> > +            };
> > +            memcpy(unit->content, &sei, sizeof(sei));
> > +        }
> > +        break;
> >       default:
> >           av_assert0(0);
> >       }
> > @@ -237,6 +257,15 @@ static int
> cbs_sei_get_message_list(CodedBitstreamContext *ctx,
> >               *list = &sei->message_list;
> >           }
> >           break;
> > +    case AV_CODEC_ID_H266:
> > +        {
> > +            H266RawSEI *sei = unit->content;
> > +            if (unit->type != VVC_PREFIX_SEI_NUT &&
> > +                unit->type != VVC_SUFFIX_SEI_NUT)
> > +                return AVERROR(EINVAL);
> > +            *list = &sei->message_list;
> > +        }
> > +        break;
>
> Yay, I'm glad the SEI stuff fitted in nicely with no extra weird cases.
>
> >       default:
> >           return AVERROR(EINVAL);
> >       }
> >
> 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".
Nuo Mi Feb. 18, 2021, 3:20 p.m. UTC | #3
>
>> > +                return AVERROR(ENOMEM);
>> > +        }
>> > +        h266->ph = (H266RawPH*)h266->ph_ref->data;
>> > +        memcpy(h266->ph, &current->sh_picture_header,
>> sizeof(H266RawPH));
>>
>> This memcpy() is naughty - if that was a ref to a previous picture header
>> then you've just overwritten the reference while the other unit still holds
>> it.
>>
>> If the slice is unit->content then unit->content_ref is a reference to a
>> superstructure of the picture header, avoiding the copy, but I'm not sure
>> it's the right way to do it.
>>
>> Is it right that the two possible options here are:
>> * Store a ref, which might be to a newly-allocated buffer or might be to
>> a previous unit.
>>
> * Store the whole structure in the private context.
>>
> ?
>>
>> If the structure isn't too large, then the second option feels much
>> simpler.
>>
>> If it is large such that holding references and avoiding copies is
>> beneficial (which is quite large, every ref entails a malloc/free
>> call-pair), then we probably want that ref to always be to the unit?
>>
> If we store the whole structure, it's hard to detect the picture header
> missing case.
>
Also, if we use this as start point of the native decoder, the native
decoder may need ref the picture header for multi-thread decoding.

>
>> > +    }
>> > +
>> > +    ph = h266->ph;
>> > +    if (!ph) {
>> > +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Picture header not
>> available.\n");
>> > +        return AVERROR_INVALIDDATA;
>> > +    }
>> > ...
>> > 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,
>>
>> Heh, fair :)
>>
>> >         // 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;
>> > diff --git a/libavcodec/cbs_sei.c b/libavcodec/cbs_sei.c
>> > index c49830ad77..96c60259ce 100644
>> > --- a/libavcodec/cbs_sei.c
>> > +++ b/libavcodec/cbs_sei.c
>> > @@ -20,6 +20,7 @@
>> >   #include "cbs_internal.h"
>> >   #include "cbs_h264.h"
>> >   #include "cbs_h265.h"
>> > +#include "cbs_h266.h"
>> >   #include "cbs_sei.h"
>> >
>> >   static void cbs_free_user_data_registered(void *opaque, uint8_t *data)
>> > @@ -132,6 +133,13 @@ static int cbs_sei_get_unit(CodedBitstreamContext
>> *ctx,
>> >           else
>> >               sei_type = HEVC_NAL_SEI_SUFFIX;
>> >           break;
>> > +    case AV_CODEC_ID_H266:
>> > +        highest_vcl_type = VVC_RSV_IRAP_11;
>> > +        if (prefix)
>> > +            sei_type = VVC_PREFIX_SEI_NUT;
>> > +        else
>> > +            sei_type = VVC_SUFFIX_SEI_NUT;
>> > +        break;
>> >       default:
>> >           return AVERROR(EINVAL);
>> >       }
>> > @@ -207,6 +215,18 @@ static int cbs_sei_get_unit(CodedBitstreamContext
>> *ctx,
>> >               memcpy(unit->content, &sei, sizeof(sei));
>> >           }
>> >           break;
>> > +    case AV_CODEC_ID_H266:
>> > +        {
>> > +            H266RawSEI sei = {
>> > +                .nal_unit_header = {
>> > +                    .nal_unit_type         = sei_type,
>> > +                    .nuh_layer_id          = 0,
>> > +                    .nuh_temporal_id_plus1 = 1,
>> > +                },
>> > +            };
>> > +            memcpy(unit->content, &sei, sizeof(sei));
>> > +        }
>> > +        break;
>> >       default:
>> >           av_assert0(0);
>> >       }
>> > @@ -237,6 +257,15 @@ static int
>> cbs_sei_get_message_list(CodedBitstreamContext *ctx,
>> >               *list = &sei->message_list;
>> >           }
>> >           break;
>> > +    case AV_CODEC_ID_H266:
>> > +        {
>> > +            H266RawSEI *sei = unit->content;
>> > +            if (unit->type != VVC_PREFIX_SEI_NUT &&
>> > +                unit->type != VVC_SUFFIX_SEI_NUT)
>> > +                return AVERROR(EINVAL);
>> > +            *list = &sei->message_list;
>> > +        }
>> > +        break;
>>
>> Yay, I'm glad the SEI stuff fitted in nicely with no extra weird cases.
>>
> Yes. It's a good solution to remove duplicate things

>
>> >       default:
>> >           return AVERROR(EINVAL);
>> >       }
>> >
>> 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 Feb. 18, 2021, 9:53 p.m. UTC | #4
On 18/02/2021 15:14, Nuo Mi wrote:
> On Thu, Feb 18, 2021 at 8:04 AM Mark Thompson <sw@jkqxz.net> wrote:
> 
>> On 17/02/2021 01:51, Nuo Mi wrote:
>>> ---
>>>    configure                             |    2 +
>>>    libavcodec/Makefile                   |    1 +
>>>    libavcodec/cbs.c                      |    6 +
>>>    libavcodec/cbs_h2645.c                |  541 ++++-
>>>    libavcodec/cbs_h266.h                 |  817 +++++++
>>>    libavcodec/cbs_h266_syntax_template.c | 3006 +++++++++++++++++++++++++
>>>    libavcodec/cbs_internal.h             |    3 +-
>>>    libavcodec/cbs_sei.c                  |   29 +
>>>    8 files changed, 4397 insertions(+), 8 deletions(-)
>>>    create mode 100644 libavcodec/cbs_h266.h
>>>    create mode 100644 libavcodec/cbs_h266_syntax_template.c
>>>
>>> ...
>>> @@ -1327,7 +1717,7 @@ static int
>> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>>>    {
>>>        uint8_t *data;
>>>        size_t max_size, dp, sp;
>>> -    int err, i, zero_run;
>>> +    int err, i, zero_run, h266_au_start = 0;
>>>
>>>        for (i = 0; i < frag->nb_units; i++) {
>>>            // Data should already all have been written when we get here.
>>> @@ -1343,7 +1733,10 @@ static int
>> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>>>        data = av_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);
>>>        if (!data)
>>>            return AVERROR(ENOMEM);
>>> -
>>> +    if (ctx->codec->codec_id == AV_CODEC_ID_VVC) {
>>> +        CodedBitstreamH266Context *h266 = ctx->priv_data;
>>> +        h266_au_start = h266_is_au_start(h266, frag, ctx->log_ctx) > 0;
>>> +    }
>>
>> It is unclear to me why this wants a special case.
>>
>> The current logic is that we are writing an AU, so the first NAL unit in
>> it is necessarily an AU start and subsequent NAL units are not?
>>
> H.266 AU contains one or more PU(3.105). One PU contains one coded picture.
> Only the first NAL unit of an AU needs the zero_byte(B.2.2)
> H.265 has no PU, each AU has one coded picture(3.1)
> H.266's PU is the H.265's AU. In vvc_parser, we split bitstream to PU.

Er, I don't think this is right: an AVPacket should contain all of the pictures for a single timestamp - a decoder can then output at most one picture from it, for the selected spatial layer.

Though I don't know how the container formats are defined here, for other codecs having multiple packets with the same timestamps causes ugly problems in muxing/demuxing which we avoid by saying you aren't allowed to do that.

(See AV1, which has the same features.)

>>>        dp = 0;
>>>        for (i = 0; i < frag->nb_units; i++) {
>>>            CodedBitstreamUnit *unit = &frag->units[i];
>>> @@ -1356,7 +1749,7 @@ static int
>> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
>>>                    frag->data_bit_padding = unit->data_bit_padding;
>>>            }
>>>
>>> -        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id,
>> unit->type, i)) {
>>> +        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id,
>> unit->type, i, h266_au_start)) {
>>>                // zero_byte
>>>                data[dp++] = 0;
>>>            }
>>> @@ -1470,6 +1863,37 @@ static void cbs_h265_close(CodedBitstreamContext
>> *ctx)
>>>            av_buffer_unref(&h265->pps_ref[i]);
>>>    }
>>>
>>> ...
>>> +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->ph = (H266RawPH*)h266->ph_ref->data;
>>> +        memcpy(h266->ph, &current->sh_picture_header,
>> sizeof(H266RawPH));
>>
>> This memcpy() is naughty - if that was a ref to a previous picture header
>> then you've just overwritten the reference while the other unit still holds
>> it.
>>
>> If the slice is unit->content then unit->content_ref is a reference to a
>> superstructure of the picture header, avoiding the copy, but I'm not sure
>> it's the right way to do it.
>>
>> Is it right that the two possible options here are:
>> * Store a ref, which might be to a newly-allocated buffer or might be to a
>> previous unit.
>>
> * Store the whole structure in the private context.
>>
> ?
>>
>> If the structure isn't too large, then the second option feels much
>> simpler.
>>
>> If it is large such that holding references and avoiding copies is
>> beneficial (which is quite large, every ref entails a malloc/free
>> call-pair), then we probably want that ref to always be to the unit?
>>
> If we store the whole structure, it's hard to detect the picture header
> missing case.

I don't see how it's different?  You test a pointer here, you would have a flag if the structure is stored.

>>> +    }
>>> +
>>> +    ph = h266->ph;
>>> +    if (!ph) {
>>> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Picture header not
>> available.\n");
>>> +        return AVERROR_INVALIDDATA;
>>> +    }
>>> ...

- Mark
Mark Thompson Feb. 18, 2021, 9:53 p.m. UTC | #5
On 18/02/2021 15:20, Nuo Mi wrote:
>>
>>>> +                return AVERROR(ENOMEM);
>>>> +        }
>>>> +        h266->ph = (H266RawPH*)h266->ph_ref->data;
>>>> +        memcpy(h266->ph, &current->sh_picture_header,
>>> sizeof(H266RawPH));
>>>
>>> This memcpy() is naughty - if that was a ref to a previous picture header
>>> then you've just overwritten the reference while the other unit still holds
>>> it.
>>>
>>> If the slice is unit->content then unit->content_ref is a reference to a
>>> superstructure of the picture header, avoiding the copy, but I'm not sure
>>> it's the right way to do it.
>>>
>>> Is it right that the two possible options here are:
>>> * Store a ref, which might be to a newly-allocated buffer or might be to
>>> a previous unit.
>>>
>> * Store the whole structure in the private context.
>>>
>> ?
>>>
>>> If the structure isn't too large, then the second option feels much
>>> simpler.
>>>
>>> If it is large such that holding references and avoiding copies is
>>> beneficial (which is quite large, every ref entails a malloc/free
>>> call-pair), then we probably want that ref to always be to the unit?
>>>
>> If we store the whole structure, it's hard to detect the picture header
>> missing case.
>>
> Also, if we use this as start point of the native decoder, the native
> decoder may need ref the picture header for multi-thread decoding.

I think it would be reffing all of the units of the picture, which would include the picture header.

- Mark
Nuo Mi Feb. 19, 2021, 1:52 p.m. UTC | #6
>
>
>
> >>
> >> The current logic is that we are writing an AU, so the first NAL unit in
> >> it is necessarily an AU start and subsequent NAL units are not?
> >>
> > H.266 AU contains one or more PU(3.105). One PU contains one coded
> picture.
> > Only the first NAL unit of an AU needs the zero_byte(B.2.2)
> > H.265 has no PU, each AU has one coded picture(3.1)
> > H.266's PU is the H.265's AU. In vvc_parser, we split bitstream to PU.
>
> Er, I don't think this is right: an AVPacket should contain all of the
> pictures for a single timestamp - a decoder can then output at most one
> picture from it, for the selected spatial layer.
>
This will make parser code very complicate :).


> Though I don't know how the container formats are defined here, for other
> codecs having multiple packets with the same timestamps causes ugly
> problems in muxing/demuxing which we avoid by saying you aren't allowed to
> do that.
>
We do not have container format spec for vvc yet. The codec is not register
on http://mp4ra.org/#/codecs. How we handle svc in H.265? It will have same
timestamp for diffrent AU.

>
> (See AV1, which has the same features.)
>
Av1's annex B is better than vvc's. It has the temporal unit  (similar to
AU) size and frame (similar to PU) sizes in the bitstream. It does not need
to search bitstream.

>>>        dp = 0;
> >>>        for (i = 0; i < frag->nb_units; i++) {
> >>>            CodedBitstreamUnit *unit = &frag->units[i];
> >>> @@ -1356,7 +1749,7 @@ static int
> >> cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
> >>>                    frag->data_bit_padding = unit->data_bit_padding;
> >>>            }
> >>>
> >>> -        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id,
> >> unit->type, i)) {
> >>> +        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id,
> >> unit->type, i, h266_au_start)) {
> >>>                // zero_byte
> >>>                data[dp++] = 0;
> >>>            }
> >>> @@ -1470,6 +1863,37 @@ static void cbs_h265_close(CodedBitstreamContext
> >> *ctx)
> >>>            av_buffer_unref(&h265->pps_ref[i]);
> >>>    }
> >>>
> >>> ...
> >>> +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->ph = (H266RawPH*)h266->ph_ref->data;
> >>> +        memcpy(h266->ph, &current->sh_picture_header,
> >> sizeof(H266RawPH));
> >>
> >> This memcpy() is naughty - if that was a ref to a previous picture
> header
> >> then you've just overwritten the reference while the other unit still
> holds
> >> it.
> >>
> >> If the slice is unit->content then unit->content_ref is a reference to a
> >> superstructure of the picture header, avoiding the copy, but I'm not
> sure
> >> it's the right way to do it.
> >>
> >> Is it right that the two possible options here are:
> >> * Store a ref, which might be to a newly-allocated buffer or might be
> to a
> >> previous unit.
> >>
> > * Store the whole structure in the private context.
> >>
> > ?
> >>
> >> If the structure isn't too large, then the second option feels much
> >> simpler.
> >>
> >> If it is large such that holding references and avoiding copies is
> >> beneficial (which is quite large, every ref entails a malloc/free
> >> call-pair), then we probably want that ref to always be to the unit?
> >>
> > If we store the whole structure, it's hard to detect the picture header
> > missing case.
>
> I don't see how it's different?  You test a pointer here, you would have a
> flag if the structure is stored.
>
The structure is not ref able, it may not shareable between slices.
I found a way to do avoid the copy, will send the new patch after the PU/AU
things finalized.

>
> >>> +    }
> >>> +
> >>> +    ph = h266->ph;
> >>> +    if (!ph) {
> >>> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Picture header not
> >> available.\n");
> >>> +        return AVERROR_INVALIDDATA;
> >>> +    }
> >>> ...
>
> - 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".
Jan Ekström Feb. 19, 2021, 6:16 p.m. UTC | #7
On Fri, Feb 19, 2021 at 3:52 PM Nuo Mi <nuomi2021@gmail.com> wrote:
> > >>
> > >> The current logic is that we are writing an AU, so the first NAL unit in
> > >> it is necessarily an AU start and subsequent NAL units are not?
> > >>
> > > H.266 AU contains one or more PU(3.105). One PU contains one coded
> > picture.
> > > Only the first NAL unit of an AU needs the zero_byte(B.2.2)
> > > H.265 has no PU, each AU has one coded picture(3.1)
> > > H.266's PU is the H.265's AU. In vvc_parser, we split bitstream to PU.
> >
> > Er, I don't think this is right: an AVPacket should contain all of the
> > pictures for a single timestamp - a decoder can then output at most one
> > picture from it, for the selected spatial layer.
> >
> This will make parser code very complicate :).
>
>
> > Though I don't know how the container formats are defined here, for other
> > codecs having multiple packets with the same timestamps causes ugly
> > problems in muxing/demuxing which we avoid by saying you aren't allowed to
> > do that.
> >
> We do not have container format spec for vvc yet. The codec is not register
> on http://mp4ra.org/#/codecs. How we handle svc in H.265? It will have same
> timestamp for diffrent AU.
>

FYI, there are already drafts for 14496-15 (Carriage of NAL unit based
video in ISOBMFF aka MP4) with VVC such as document N18825 .
https://isotc.iso.org/livelink/livelink?func=ll&objId=21196449&objAction=Open&viewType=1

Jan
Nuo Mi Feb. 21, 2021, 3:44 a.m. UTC | #8
On Sat, Feb 20, 2021 at 2:17 AM Jan Ekström <jeebjp@gmail.com> wrote:

> On Fri, Feb 19, 2021 at 3:52 PM Nuo Mi <nuomi2021@gmail.com> wrote:
> > > >>
> > > >> The current logic is that we are writing an AU, so the first NAL
> unit in
> > > >> it is necessarily an AU start and subsequent NAL units are not?
> > > >>
> > > > H.266 AU contains one or more PU(3.105). One PU contains one coded
> > > picture.
> > > > Only the first NAL unit of an AU needs the zero_byte(B.2.2)
> > > > H.265 has no PU, each AU has one coded picture(3.1)
> > > > H.266's PU is the H.265's AU. In vvc_parser, we split bitstream to
> PU.
> > >
> > > Er, I don't think this is right: an AVPacket should contain all of the
> > > pictures for a single timestamp - a decoder can then output at most one
> > > picture from it, for the selected spatial layer.
> > >
> > This will make parser code very complicate :).
> >
> >
> > > Though I don't know how the container formats are defined here, for
> other
> > > codecs having multiple packets with the same timestamps causes ugly
> > > problems in muxing/demuxing which we avoid by saying you aren't
> allowed to
> > > do that.
> > >
> > We do not have container format spec for vvc yet. The codec is not
> register
> > on http://mp4ra.org/#/codecs. How we handle svc in H.265? It will have
> same
> > timestamp for diffrent AU.
> >
>
> FYI, there are already drafts for 14496-15 (Carriage of NAL unit based
> video in ISOBMFF aka MP4) with VVC such as document N18825 .
>
> https://isotc.iso.org/livelink/livelink?func=ll&objId=21196449&objAction=Open&viewType=1

thanks, Jan, it's very informative.

Hi Mark,
You are right, let me spend time adjusting the code.
>each sample in the track contains an access unit. The access unit contains
NAL units from all the layers and sub-layers that are part of the operating
point.(11.3.4)

>
>
> Jan
> _______________________________________________
> 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 a76c2ec4ae..11df59a229 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 3341801b97..23553e68e9 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -73,6 +73,7 @@  OBJS-$(CONFIG_CBS)                     += cbs.o cbs_bsf.o
 OBJS-$(CONFIG_CBS_AV1)                 += cbs_av1.o
 OBJS-$(CONFIG_CBS_H264)                += cbs_h2645.o cbs_sei.o h2645_parse.o
 OBJS-$(CONFIG_CBS_H265)                += cbs_h2645.o cbs_sei.o h2645_parse.o
+OBJS-$(CONFIG_CBS_H266)                += cbs_h2645.o cbs_sei.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 57c419aa05..d39464ba49 100644
--- a/libavcodec/cbs_h2645.c
+++ b/libavcodec/cbs_h2645.c
@@ -24,12 +24,129 @@ 
 #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"
 
+#define H266_IS_SLICE(nut) (nut <= VVC_RASL_NUT || (nut >= VVC_IDR_W_RADL && nut <= VVC_GDR_NUT))
+#define H266_IS_IDR(nut) (nut == VVC_IDR_W_RADL || nut == VVC_IDR_N_LP)
+
+static void h266_au_detector_init(H266AuDetector* d)
+{
+    if (!d->inited) {
+        d->prev_layer_id = UINT8_MAX;
+        d->prev_poc = INT_MAX;
+        d->prev_tid0_poc = INT_MAX;
+        d->inited = 1;
+    }
+}
+
+//8.3.1 Decoding process for picture order count.
+//VTM did not follow the spec, and it's much simpler than spec.
+//We follow the VTM.
+static int h266_get_slice_poc(CodedBitstreamH266Context *h266, void* log_ctx,
+                              const H266RawPH *ph, const H266RawSliceHeader *slice,
+                              int *poc)
+{
+    int poc_msb, max_poc_lsb, poc_lsb;
+    H266AuDetector* d = &h266->priv.au_detector;
+    const H266RawSPS* sps;
+    const H266RawPPS* pps;
+
+    pps = h266->pps[ph->ph_pic_parameter_set_id];
+    if (!pps) {
+        av_log(log_ctx, AV_LOG_ERROR, "PPS id %d is not avaliable.\n",
+               ph->ph_pic_parameter_set_id);
+        return AVERROR_INVALIDDATA;
+    }
+
+    sps = h266->sps[pps->pps_seq_parameter_set_id];
+    if (!sps) {
+        av_log(log_ctx, AV_LOG_ERROR, "SPS id %d is not avaliable.\n",
+               pps->pps_seq_parameter_set_id);
+        return AVERROR_INVALIDDATA;
+    }
+
+    max_poc_lsb = 1 << (sps->sps_log2_max_pic_order_cnt_lsb_minus4 + 4);
+    poc_lsb = ph->ph_pic_order_cnt_lsb;
+    if (H266_IS_IDR(slice->nal_unit_header.nal_unit_type)) {
+        if (ph->ph_poc_msb_cycle_present_flag)
+            poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
+        else
+            poc_msb = 0;
+    } else {
+        int prev_poc = d->prev_tid0_poc;
+        int prev_poc_lsb = prev_poc & (max_poc_lsb - 1);
+        int prev_poc_msb = prev_poc - prev_poc_lsb;
+        if (ph->ph_poc_msb_cycle_present_flag) {
+             poc_msb = ph->ph_poc_msb_cycle_val * max_poc_lsb;
+        } else {
+            if ((poc_lsb < prev_poc_lsb) && ((prev_poc_lsb - poc_lsb) >= (max_poc_lsb / 2)))
+                poc_msb = prev_poc_msb + max_poc_lsb;
+            else if ((poc_lsb > prev_poc_lsb) && ((poc_lsb - prev_poc_lsb) > (max_poc_lsb / 2)))
+                poc_msb = prev_poc_msb - max_poc_lsb;
+            else
+                poc_msb = prev_poc_msb;
+        }
+    }
+
+    *poc = poc_msb + poc_lsb;
+    return 0;
+}
+
+int h266_is_au_start(CodedBitstreamH266Context *h266, CodedBitstreamFragment *pu, void* log_ctx)
+{
+    //7.4.2.4.3
+    H266AuDetector *d = &h266->priv.au_detector;
+    int i, ret;
+    const H266RawNALUnitHeader *nal;
+    const H266RawPH *ph = h266->ph;
+    const H266RawSlice *slice = NULL;
+    int poc, nut;
+
+    if (!ph) {
+        av_log(log_ctx, AV_LOG_ERROR, "can't find picture header in picutre unit.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    for (i = 0; i < pu->nb_units; i++) {
+        nal = pu->units[i].content;
+        if (!nal)
+            continue;
+        if (H266_IS_SLICE(nal->nal_unit_type)) {
+            slice = pu->units[i].content;
+            break;
+        }
+    }
+    if (!slice) {
+        av_log(log_ctx, AV_LOG_ERROR, "can't find first slice.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    h266_au_detector_init(&h266->priv.au_detector);
+
+    if ((ret = h266_get_slice_poc(h266, log_ctx, ph, &slice->header, &poc)) < 0)
+        return ret;
+
+    ret = (nal->nuh_layer_id <= d->prev_layer_id) || (poc != d->prev_poc);
+
+    nut = nal->nal_unit_type;
+    d->prev_layer_id = nal->nuh_layer_id;
+    d->prev_poc = poc;
+    if (nal->nuh_temporal_id_plus1 == 1 &&
+        !ph->ph_non_ref_pic_flag && nut != VVC_RADL_NUT && nut != VVC_RASL_NUT) {
+        d->prev_tid0_poc = poc;
+    }
+    return ret;
+}
+
+static av_always_inline unsigned int h266_ceil(unsigned int v, unsigned int align)
+{
+    return (((v) + (align) - 1) / (align));
+}
 
 static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,
                               const char *name, const int *subscripts,
@@ -257,6 +374,7 @@  static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t paylo
 #define FUNC_NAME1(rw, codec, name) FUNC_NAME2(rw, codec, name)
 #define FUNC_H264(name) FUNC_NAME1(READWRITE, h264, name)
 #define FUNC_H265(name) FUNC_NAME1(READWRITE, h265, name)
+#define FUNC_H266(name) FUNC_NAME1(READWRITE, h266, name)
 #define FUNC_SEI(name)  FUNC_NAME1(READWRITE, sei,  name)
 
 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
@@ -371,6 +489,10 @@  static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
 #include "cbs_h265_syntax_template.c"
 #undef FUNC
 
+#define FUNC(name) FUNC_H266(name)
+#include "cbs_h266_syntax_template.c"
+#undef FUNC
+
 #undef READ
 #undef READWRITE
 #undef RWContext
@@ -449,6 +571,10 @@  static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
 #include "cbs_h265_syntax_template.c"
 #undef FUNC
 
+#define FUNC(name) FUNC_H266(name)
+#include "cbs_h266_syntax_template.c"
+#undef FUNC
+
 #undef WRITE
 #undef READWRITE
 #undef RWContext
@@ -515,6 +641,12 @@  static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx,
     if (frag->data_size == 0)
         return 0;
 
+    if (codec_id == AV_CODEC_ID_VVC) {
+        //we deactive picture header here to avoid reuse previous frame's ph.
+        CodedBitstreamH266Context* h266 = ctx->priv_data;
+        h266->ph = NULL;
+    }
+
     if (header && frag->data[0] && codec_id == AV_CODEC_ID_H264) {
         // AVCC header.
         size_t size, start, end;
@@ -716,6 +848,12 @@  static int cbs_h2645_replace_ps(CodedBitstreamContext *ctx,
     H2645_PS_TYPE(H265, HEVC_NAL_ ## cname, cname, uname, \
                   HEVC_MAX_ ## cname ## _COUNT, \
                   uname ## _ ## id_name, active_ ## uname)
+#define H266_PS_TYPE(cname, uname, id_name) \
+        H26456_PS_TYPE(H266, VVC_ ## cname ## _NUT, cname, uname, \
+            VVC_MAX_ ## cname ## _COUNT, \
+            offsetof(H266 ## Raw ## cname, uname ## _ ## id_name ## _parameter_set_id), \
+            0)
+#define H266_PH_TYPE  H26456_PS_TYPE(H266, VVC_PH_NUT, PH, ph, 1, 0, 0)
 
     static const PSType ps_types[] = {
         H264_PS_TYPE(SPS, sps, seq),
@@ -723,6 +861,10 @@  static int cbs_h2645_replace_ps(CodedBitstreamContext *ctx,
         H265_PS_TYPE(VPS, vps, video),
         H265_PS_TYPE(SPS, sps, seq),
         H265_PS_TYPE(PPS, pps, pic),
+        H266_PS_TYPE(VPS, vps, video),
+        H266_PS_TYPE(SPS, sps, seq),
+        H266_PS_TYPE(PPS, pps, pic),
+        H266_PH_TYPE,
     };
 
     const PSType *ps_type;
@@ -1019,6 +1161,131 @@  static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
     return 0;
 }
 
+static int cbs_h266_read_nal_unit(CodedBitstreamContext *ctx,
+                                  CodedBitstreamUnit *unit)
+{
+    GetBitContext gbc;
+    int err;
+
+    err = init_get_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_VPS_NUT:
+        {
+            H266RawVPS *vps = unit->content;
+
+            err = cbs_h266_read_vps(ctx, &gbc, vps);
+            if (err < 0)
+                return err;
+
+            err = cbs_h2645_replace_ps(ctx, unit);
+            if (err < 0)
+                return err;
+        }
+        break;
+    case VVC_SPS_NUT:
+        {
+            H266RawSPS *sps = unit->content;
+
+            err = cbs_h266_read_sps(ctx, &gbc, sps);
+            if (err < 0)
+                return err;
+
+            err = cbs_h2645_replace_ps(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_h2645_replace_ps(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_h2645_replace_ps(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)
@@ -1306,19 +1573,142 @@  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_VPS_NUT:
+        {
+            H266RawVPS *vps = unit->content;
+
+            err = cbs_h266_write_vps(ctx, pbc, vps);
+            if (err < 0)
+                return err;
+
+            err = cbs_h2645_replace_ps(ctx, unit);
+            if (err < 0)
+                return err;
+        }
+        break;
+    case VVC_SPS_NUT:
+        {
+            H266RawSPS *sps = unit->content;
+
+            err = cbs_h266_write_sps(ctx, pbc, sps);
+            if (err < 0)
+                return err;
+
+            err = cbs_h2645_replace_ps(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_h2645_replace_ps(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_h2645_replace_ps(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_unit_requires_zero_byte(enum AVCodecID codec_id,
                                              CodedBitstreamUnitType type,
-                                             int nal_unit_index)
+                                             int nal_unit_index, int h266_au_start)
 {
-    // Section B.1.2 in H.264, section B.2.2 in H.265.
+    // Section B.1.2 in H.264, section B.2.2 in H.265, H.266.
     if (nal_unit_index == 0) {
-        // Assume that this is the first NAL unit in an access unit.
-        return 1;
+        if (codec_id == AV_CODEC_ID_VVC) {
+            if (h266_au_start)
+                return 1;
+        } else {
+            // Assume that this is the first NAL unit in an access unit.
+            return 1;
+        }
     }
     if (codec_id == AV_CODEC_ID_H264)
         return type == H264_NAL_SPS || type == H264_NAL_PPS;
     if (codec_id == AV_CODEC_ID_HEVC)
         return type == HEVC_NAL_VPS || type == HEVC_NAL_SPS || type == HEVC_NAL_PPS;
+    if (codec_id == AV_CODEC_ID_VVC)
+        return type >= VVC_OPI_NUT && type <= VVC_SUFFIX_APS_NUT;
     return 0;
 }
 
@@ -1327,7 +1717,7 @@  static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
 {
     uint8_t *data;
     size_t max_size, dp, sp;
-    int err, i, zero_run;
+    int err, i, zero_run, h266_au_start = 0;
 
     for (i = 0; i < frag->nb_units; i++) {
         // Data should already all have been written when we get here.
@@ -1343,7 +1733,10 @@  static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
     data = av_realloc(NULL, max_size + AV_INPUT_BUFFER_PADDING_SIZE);
     if (!data)
         return AVERROR(ENOMEM);
-
+    if (ctx->codec->codec_id == AV_CODEC_ID_VVC) {
+        CodedBitstreamH266Context *h266 = ctx->priv_data;
+        h266_au_start = h266_is_au_start(h266, frag, ctx->log_ctx) > 0;
+    }
     dp = 0;
     for (i = 0; i < frag->nb_units; i++) {
         CodedBitstreamUnit *unit = &frag->units[i];
@@ -1356,7 +1749,7 @@  static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,
                 frag->data_bit_padding = unit->data_bit_padding;
         }
 
-        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id, unit->type, i)) {
+        if (cbs_h2645_unit_requires_zero_byte(ctx->codec->codec_id, unit->type, i, h266_au_start)) {
             // zero_byte
             data[dp++] = 0;
         }
@@ -1470,6 +1863,37 @@  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;
+}
+
+
+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(void *opaque, uint8_t *content)
 {
     H264RawSEI *sei = (H264RawSEI*)content;
@@ -1558,6 +1982,80 @@  static const CodedBitstreamUnitTypeDescriptor cbs_h265_unit_types[] = {
     CBS_UNIT_TYPE_END_OF_LIST
 };
 
+static void cbs_h266_free_sei(void *opaque, uint8_t *content)
+{
+    H265RawSEI *sei = (H265RawSEI*)content;
+    ff_cbs_sei_free_message_list(&sei->message_list);
+    av_free(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,
 
@@ -1590,6 +2088,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,
+};
+
 static const SEIMessageTypeDescriptor cbs_sei_common_types[] = {
     {
         SEI_TYPE_FILLER_PAYLOAD,
@@ -1722,6 +2236,16 @@  static const SEIMessageTypeDescriptor cbs_sei_h265_types[] = {
     SEI_MESSAGE_TYPE_END
 };
 
+static const SEIMessageTypeDescriptor cbs_sei_h266_types[] = {
+    {
+        SEI_TYPE_DECODED_PICTURE_HASH,
+        0, 1,
+        sizeof(H266RawSEIDecodedPictureHash),
+        SEI_MESSAGE_RW(h266, sei_decoded_picture_hash),
+    },
+    SEI_MESSAGE_TYPE_END
+};
+
 const SEIMessageTypeDescriptor *ff_cbs_sei_find_type(CodedBitstreamContext *ctx,
                                                      int payload_type)
 {
@@ -1740,6 +2264,9 @@  const SEIMessageTypeDescriptor *ff_cbs_sei_find_type(CodedBitstreamContext *ctx,
     case AV_CODEC_ID_H265:
         codec_list = cbs_sei_h265_types;
         break;
+    case AV_CODEC_ID_H266:
+        codec_list = cbs_sei_h266_types;
+        break;
     default:
         return NULL;
     }
diff --git a/libavcodec/cbs_h266.h b/libavcodec/cbs_h266.h
new file mode 100644
index 0000000000..20d547a26d
--- /dev/null
+++ b/libavcodec/cbs_h266.h
@@ -0,0 +1,817 @@ 
+/*
+ * 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 "cbs_sei.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;
+    uint8_t nuh_reserved_zero_bit;
+} 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;
+    uint8_t gci_reserved_zero_bit[255];
+} 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];
+
+    uint8_t  ptl_reserved_zero_bit;
+} 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 H266RefPicListStruct {
+    uint8_t num_ref_entries;
+    uint8_t ltrp_in_header_flag;
+    uint8_t inter_layer_ref_pic_flag[VVC_MAX_REF_ENTRIES];
+    uint8_t st_ref_pic_flag[VVC_MAX_REF_ENTRIES];
+    uint8_t abs_delta_poc_st[VVC_MAX_REF_ENTRIES];
+    uint8_t strp_entry_sign_flag[VVC_MAX_REF_ENTRIES];
+    uint8_t rpls_poc_lsb_lt[VVC_MAX_REF_ENTRIES];
+    uint8_t ilrp_idx[VVC_MAX_REF_ENTRIES];
+} H266RefPicListStruct;
+
+typedef struct H266RefPicLists {
+    uint8_t  rpl_sps_flag[2];
+    uint8_t  rpl_idx[2];
+    H266RefPicListStruct rpl_ref_list[2];
+    uint16_t poc_lsb_lt[2][VVC_MAX_REF_ENTRIES];
+    uint8_t  delta_poc_msb_cycle_present_flag[2][VVC_MAX_REF_ENTRIES];
+    uint16_t delta_poc_msb_cycle_lt[2][VVC_MAX_REF_ENTRIES];
+} 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_SUBLAYERS][VVC_MAX_CPB_CNT];
+    uint32_t cpb_size_value_minus1[VVC_MAX_SUBLAYERS][VVC_MAX_CPB_CNT];
+    uint32_t cpb_size_du_value_minus1[VVC_MAX_SUBLAYERS][VVC_MAX_CPB_CNT];
+    uint32_t bit_rate_du_value_minus1[VVC_MAX_SUBLAYERS][VVC_MAX_CPB_CNT];
+    uint8_t  cbr_flag[VVC_MAX_SUBLAYERS][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;
+    H266RawSubLayerHRDParameters vcl_sub_layer_hrd_parameters;
+} 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 H266RawVPS {
+    H266RawNALUnitHeader nal_unit_header;
+
+    uint8_t  vps_video_parameter_set_id;
+    uint8_t  vps_max_layers_minus1;
+    uint8_t  vps_max_sublayers_minus1;
+    uint8_t  vps_default_ptl_dpb_hrd_max_tid_flag;
+    uint8_t  vps_all_independent_layers_flag;
+    uint8_t  vps_layer_id[VVC_MAX_LAYERS];
+    uint8_t  vps_independent_layer_flag[VVC_MAX_LAYERS];
+    uint8_t  vps_max_tid_ref_present_flag[VVC_MAX_LAYERS];
+    uint8_t  vps_direct_ref_layer_flag[VVC_MAX_LAYERS][VVC_MAX_LAYERS - 1];
+    uint8_t  vps_max_tid_il_ref_pics_plus1[VVC_MAX_LAYERS][VVC_MAX_LAYERS - 1];
+    uint8_t  vps_each_layer_is_an_ols_flag;
+    uint8_t  vps_ols_mode_idc;
+    uint8_t  vps_num_output_layer_sets_minus2;
+    uint8_t  vps_ols_output_layer_flag[VVC_MAX_TOTAL_NUM_OLSS][VVC_MAX_LAYERS];
+
+    uint8_t  vps_num_ptls_minus1;
+    uint8_t  vps_pt_present_flag[VVC_MAX_PTLS];
+    uint8_t  vps_ptl_max_tid[VVC_MAX_PTLS];
+    H266RawProfileTierLevel vps_profile_tier_level[VVC_MAX_PTLS];
+    uint8_t  vps_ols_ptl_idx[VVC_MAX_TOTAL_NUM_OLSS];
+
+    uint16_t vps_num_dpb_params_minus1;
+    uint8_t  vps_sublayer_dpb_params_present_flag;
+    uint8_t  vps_dpb_max_tid[VVC_MAX_TOTAL_NUM_OLSS];
+    H266DpbParameters vps_dpb_params[VVC_MAX_TOTAL_NUM_OLSS];
+    uint16_t vps_ols_dpb_pic_width[VVC_MAX_TOTAL_NUM_OLSS];
+    uint16_t vps_ols_dpb_pic_height[VVC_MAX_TOTAL_NUM_OLSS];
+    uint8_t  vps_ols_dpb_chroma_format[VVC_MAX_TOTAL_NUM_OLSS];
+    uint8_t  vps_ols_dpb_bitdepth_minus8[VVC_MAX_TOTAL_NUM_OLSS];
+    uint16_t vps_ols_dpb_params_idx[VVC_MAX_TOTAL_NUM_OLSS];
+
+    uint8_t  vps_timing_hrd_params_present_flag;
+    H266RawGeneralTimingHrdParameters vps_general_timing_hrd_parameters;
+    uint8_t  vps_sublayer_cpb_params_present_flag;
+    uint16_t vps_num_ols_timing_hrd_params_minus1;
+    uint8_t  vps_hrd_max_tid[VVC_MAX_TOTAL_NUM_OLSS];
+    H266RawOlsTimingHrdParameters vps_ols_timing_hrd_parameters;
+    uint8_t  vps_ols_timing_hrd_idx[VVC_MAX_TOTAL_NUM_OLSS];
+
+    uint8_t  vps_extension_flag;
+    H266RawExtensionData extension_data;
+} H266RawVPS;
+
+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[MAX_SAMPLE_ARRAYS];
+    uint8_t  sps_num_points_in_qp_table_minus1[MAX_SAMPLE_ARRAYS];
+    uint8_t  sps_delta_qp_in_val_minus1[MAX_SAMPLE_ARRAYS][VVC_MAX_POINTS_IN_QP_TABLE];
+    uint8_t  sps_delta_qp_diff_val[MAX_SAMPLE_ARRAYS][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;
+    uint16_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 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];
+
+    uint8_t  ph_sei_reserved_zero_7bits;
+} H266RawSEIDecodedPictureHash;
+
+typedef struct H266RawSEIPayload {
+    uint32_t payload_type;
+    uint32_t payload_size;
+    union {
+        H266RawSEIDecodedPictureHash decoded_picture_hash;
+        struct {
+            uint8_t     *data;
+            AVBufferRef *data_ref;
+            size_t       data_length;
+        } other;
+    } payload;
+    H266RawExtensionData extension_data;
+} H266RawSEIPayload;
+
+typedef struct H266RawSEI {
+    H266RawNALUnitHeader nal_unit_header;
+    SEIRawMessageList    message_list;
+} H266RawSEI;
+
+typedef struct H266AuDetector {
+    uint8_t inited;
+    uint8_t prev_layer_id;
+    int prev_tid0_poc;
+    int prev_poc;
+} H266AuDetector;
+
+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_SPS_COUNT];
+    H266RawSPS  *sps[VVC_MAX_SPS_COUNT];
+    H266RawPPS  *pps[VVC_MAX_PPS_COUNT];
+    H266RawPH   *ph;
+
+    struct {
+        H266AuDetector au_detector;
+    } priv;
+
+} CodedBitstreamH266Context;
+
+int h266_is_au_start(CodedBitstreamH266Context* ctx, CodedBitstreamFragment *pu, void* log_ctx);
+
+#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..702c558596
--- /dev/null
+++ b/libavcodec/cbs_h266_syntax_template.c
@@ -0,0 +1,3006 @@ 
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+static int FUNC(rbsp_trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw)
+{
+    int err;
+
+    fixed(1, rbsp_stop_one_bit, 1);
+    while (byte_alignment(rw) != 0)
+        fixed(1, rbsp_alignment_zero_bit, 0);
+    return 0;
+}
+
+static int FUNC(nal_unit_header)(CodedBitstreamContext *ctx, RWContext *rw,
+                                 H266RawNALUnitHeader *current,
+                                 int expected_nal_unit_type)
+{
+    int err;
+
+    fixed(1, forbidden_zero_bit, 0);
+    flag(nuh_reserved_zero_bit);
+
+    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, byte_alignment_bit_equal_to_one, 1);
+    while (byte_alignment(rw) != 0)
+        fixed(1, byte_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++) {
+            flags(gci_reserved_zero_bit[i], 1, i);
+        }
+    }
+    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)
+        flag(ptl_reserved_zero_bit);
+    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_default)(CodedBitstreamContext *ctx,
+                                        RWContext *rw, H266RawVUI *current)
+{
+    //defined in D.8
+    infer(vui_progressive_source_flag, 0);
+    infer(vui_interlaced_source_flag, 0);
+
+    infer(vui_non_packed_constraint_flag, 0);
+    infer(vui_non_projected_constraint_flag, 0);
+
+    infer(vui_aspect_ratio_constant_flag, 0);
+    infer(vui_aspect_ratio_idc, 0);
+
+    infer(vui_overscan_info_present_flag, 0);
+
+    infer(vui_colour_primaries, 2);
+    infer(vui_transfer_characteristics, 2);
+    infer(vui_matrix_coeffs, 2);
+    infer(vui_full_range_flag, 0);
+
+    infer(vui_chroma_sample_loc_type_frame, 6);
+    infer(vui_chroma_sample_loc_type_top_field, 6);
+    infer(vui_chroma_sample_loc_type_bottom_field, 6);
+    return 0;
+}
+
+static int FUNC(vui_parameters)(CodedBitstreamContext *ctx, RWContext *rw,
+                                H266RawVUI *current, uint8_t chroma_format_idc)
+{
+    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 (chroma_format_idc != 1 && current->vui_chroma_loc_info_present_flag) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "chroma_format_idc == %d,"
+               "vui_chroma_loc_info_present_flag can't not be true", chroma_format_idc);
+        return AVERROR_INVALIDDATA;
+    }
+    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);
+        }
+    } else {
+        if (chroma_format_idc == 1) {
+            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);
+        }
+    }
+    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,
+                             uint8_t chroma_format_idc)
+{
+    int err;
+    int start_position, current_position;
+
+    start_position = bit_position(rw);
+    CHECK(FUNC(vui_parameters)(ctx, rw, current, chroma_format_idc));
+    current_position = bit_position(rw) - start_position;
+
+    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)
+{
+    CodedBitstreamH266Context *h266 = ctx->priv_data;
+    int err, i, j, general_layer_idx = -1, num_direct_ref_layers = 0;
+    const H266RawVPS *vps = h266->vps[sps->sps_video_parameter_set_id];
+
+    if (!vps) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR,
+               "VPS id %d not available.\n", sps->sps_video_parameter_set_id);
+        return AVERROR_INVALIDDATA;
+    }
+
+    //7.4.3.3 (29)
+    for (i = 0; i <= vps->vps_max_layers_minus1; i++) {
+        if (sps->nal_unit_header.nuh_layer_id == vps->vps_layer_id[i]) {
+            general_layer_idx = i;
+            break;
+        }
+    }
+    if (general_layer_idx < 0) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR,
+               "vps_layer_id %d not available.\n", sps->nal_unit_header.nuh_layer_id);
+        return AVERROR_INVALIDDATA;
+    }
+
+    //7.4.3.3 (28)
+    for (j = 0; j <= vps->vps_max_layers_minus1; j++) {
+        if (vps->vps_direct_ref_layer_flag[general_layer_idx][j])
+            num_direct_ref_layers++;
+    }
+
+    ue(num_ref_entries, 0, 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 {
+            if (num_direct_ref_layers == 0) {
+                av_log(ctx->log_ctx, AV_LOG_ERROR,
+                       "num_direct_ref_layers needs > 0.\n");
+                return AVERROR_INVALIDDATA;
+            }
+            ues(ilrp_idx[i], 0, num_direct_ref_layers - 1, 1, i);
+        }
+    }
+    return 0;
+}
+
+static int FUNC(ref_pic_lists)(CodedBitstreamContext *ctx, RWContext *rw,
+                               const H266RawSPS *sps, const H266RawPPS *pps,
+                               H266RefPicLists *current)
+{
+    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[sublayer_id][i], 0, UINT32_MAX - 1, 2, sublayer_id, i);
+        ues(cpb_size_value_minus1[sublayer_id][i], 0, UINT32_MAX - 1, 2, sublayer_id, i);
+        if (general->general_du_hrd_params_present_flag) {
+            ues(cpb_size_du_value_minus1[sublayer_id][i],
+                0, UINT32_MAX - 1, 2, sublayer_id, i);
+            ues(bit_rate_du_value_minus1[sublayer_id][i],
+                0, UINT32_MAX - 1, 2, sublayer_id, i);
+        }
+        flags(cbr_flag[sublayer_id][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, general));
+        if (general->general_vcl_hrd_params_present_flag)
+            CHECK(FUNC(sublayer_hrd_parameters)(ctx, rw,
+                       &current->nal_sub_layer_hrd_parameters, i, general));
+    }
+    return 0;
+}
+
+static int FUNC(vps)(CodedBitstreamContext *ctx, RWContext *rw,
+                     H266RawVPS *current)
+{
+    int err, i, j, k;
+    uint16_t total_num_olss = 0;
+    uint8_t  ols_mode_idc = 0;
+    uint16_t num_multi_layer_olss = 0;
+    uint8_t  layer_included_in_ols_flag[VVC_MAX_TOTAL_NUM_OLSS][VVC_MAX_LAYERS];
+    uint8_t  num_ref_layers[VVC_MAX_LAYERS];
+    uint8_t  reference_layer_idx[VVC_MAX_LAYERS][VVC_MAX_LAYERS];
+
+    HEADER("Video Parameter Set");
+
+    CHECK(FUNC(nal_unit_header)(ctx, rw,
+                                &current->nal_unit_header, VVC_VPS_NUT));
+
+    ub(4, vps_video_parameter_set_id);
+    if (current->vps_video_parameter_set_id == 0) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR,
+               "vps_video_parameter_set_id should > 0.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    ub(6, vps_max_layers_minus1);
+    u(3, vps_max_sublayers_minus1, 0, 6);
+    if (current->vps_max_layers_minus1 > 0 && current->vps_max_sublayers_minus1 > 0)
+        flag(vps_default_ptl_dpb_hrd_max_tid_flag);
+    else
+        infer(vps_default_ptl_dpb_hrd_max_tid_flag, 1);
+
+    if (current->vps_max_layers_minus1 > 0)
+        flag(vps_all_independent_layers_flag);
+    else
+        infer(vps_all_independent_layers_flag, 1);
+
+    for (i = 0; i <= current->vps_max_layers_minus1; i++) {
+        ubs(6, vps_layer_id[i], 1, i);
+        if (i > 0 && current->vps_layer_id[i] <= current->vps_layer_id[i - 1]) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR,
+                   "vps_layer_id[%d](%d) should > vps_layer_id[%d](%d).\n",
+                   i, current->vps_layer_id[i], i - 1, current->vps_layer_id[i - 1]);
+            return AVERROR_INVALIDDATA;
+        }
+        if (i > 0 && !current->vps_all_independent_layers_flag) {
+            flags(vps_independent_layer_flag[i], 1, i);
+            if (!current->vps_independent_layer_flag[i]) {
+                flags(vps_max_tid_ref_present_flag[i], 1, i);
+                for (j = 0; j < i; j++) {
+                    flags(vps_direct_ref_layer_flag[i][j], 2, i, j);
+                    if (current->vps_max_tid_ref_present_flag[i] &&
+                        current->vps_direct_ref_layer_flag[i][j]) {
+                        ubs(3, vps_max_tid_il_ref_pics_plus1[i][j], 2, i, j);
+                    } else {
+                        infer(vps_max_tid_il_ref_pics_plus1[i][j],
+                              current->vps_max_sublayers_minus1 + 1);
+                    }
+                }
+            } else {
+                for (j = 0; j < i; j++) {
+                    infer(vps_direct_ref_layer_flag[i][j], 0);
+                }
+            }
+        } else {
+            infer(vps_independent_layer_flag[i], 1);
+            for (j = 0; j < i; j++) {
+                infer(vps_direct_ref_layer_flag[i][j], 0);
+            }
+        }
+    }
+
+    if (current->vps_max_layers_minus1 > 0) {
+        if (current->vps_all_independent_layers_flag)
+            flag(vps_each_layer_is_an_ols_flag);
+        else
+            infer(vps_each_layer_is_an_ols_flag, 0);
+        if (!current->vps_each_layer_is_an_ols_flag) {
+            if (!current->vps_all_independent_layers_flag)
+                ub(2, vps_ols_mode_idc);
+            else
+                infer(vps_ols_mode_idc, 2);
+            if (current->vps_ols_mode_idc == 2) {
+                ub(8, vps_num_output_layer_sets_minus2);
+                for (i = 1; i <= current->vps_num_output_layer_sets_minus2 + 1; i++)
+                    for (j = 0; j <= current->vps_max_layers_minus1; j++)
+                        flags(vps_ols_output_layer_flag[i][j], 2, i, j);
+            }
+            ols_mode_idc = current->vps_ols_mode_idc;
+        } else {
+            ols_mode_idc = 4;
+        }
+        if (ols_mode_idc == 4 || ols_mode_idc == 0 || ols_mode_idc == 1)
+            total_num_olss = current->vps_max_layers_minus1 + 1;
+        else if (ols_mode_idc = 2)
+            total_num_olss = current->vps_num_output_layer_sets_minus2 + 2;
+        else
+             av_log(ctx->log_ctx, AV_LOG_ERROR, "ols_mode_idc == 3, patch welcome");
+        u(8, vps_num_ptls_minus1, 0, total_num_olss - 1);
+    } else {
+        infer(vps_each_layer_is_an_ols_flag, 1);
+        infer(vps_num_ptls_minus1, 0);
+    }
+    {
+        //let's get calc NumMultiLayerOlss
+        int m;
+        uint8_t dependency_flag[VVC_MAX_LAYERS][VVC_MAX_LAYERS];
+        uint16_t num_output_layers_in_ols[VVC_MAX_TOTAL_NUM_OLSS];
+        uint8_t  num_sub_layers_in_layer_in_ols[VVC_MAX_TOTAL_NUM_OLSS][VVC_MAX_TOTAL_NUM_OLSS];
+        uint8_t  output_layer_idx[VVC_MAX_TOTAL_NUM_OLSS][VVC_MAX_LAYERS];
+
+        //7.4.3.3 vps_direct_ref_layer_flag section
+        for (i = 0; i <= current->vps_max_layers_minus1; i++) {
+            for (j = 0; j <= current->vps_max_layers_minus1; j++) {
+                dependency_flag[i][j] = current->vps_direct_ref_layer_flag[i][j];
+                for (k = 0; k < i; k++) {
+                    if (current->vps_direct_ref_layer_flag[i][k] && dependency_flag[k][j])
+                        dependency_flag[i][j] = 1;
+                }
+            }
+        }
+        for (i = 0; i <= current->vps_max_layers_minus1; i++) {
+            int r;
+            for (j = 0, r = 0; j <= current->vps_max_layers_minus1; j++) {
+                if (dependency_flag[i][j])
+                    reference_layer_idx[i][r++] = j;
+            }
+            num_ref_layers[i] = r;
+        }
+
+        //7.4.3.3 vps_ols_output_layer_flag section
+        num_output_layers_in_ols[0] = 1;
+        num_sub_layers_in_layer_in_ols[0][0] = current->vps_ptl_max_tid[current->vps_ols_ptl_idx[0]] + 1;
+        for (i = 1; i < total_num_olss; i++) {
+            if (ols_mode_idc == 4 || ols_mode_idc == 0) {
+                num_output_layers_in_ols[i] = 1;
+                if (current->vps_each_layer_is_an_ols_flag) {
+                    num_sub_layers_in_layer_in_ols[i][0] =
+                        current->vps_ptl_max_tid[current->vps_ols_ptl_idx[i]] + 1;
+                } else {
+                    num_sub_layers_in_layer_in_ols[i][i] =
+                        current->vps_ptl_max_tid[current->vps_ols_ptl_idx[i]] + 1;
+                    for (k = i - 1; k >= 0; k--) {
+                        num_sub_layers_in_layer_in_ols[i][k] = 0;
+                        for (m = k + 1; m <= i; m++) {
+                            uint8_t max_sublayer_needed =
+                                FFMIN(num_sub_layers_in_layer_in_ols[i][m],
+                                      current->vps_max_tid_il_ref_pics_plus1[m][k]);
+                            if (current->vps_direct_ref_layer_flag[m][k] &&
+                                num_sub_layers_in_layer_in_ols[i][k] < max_sublayer_needed)
+                                num_sub_layers_in_layer_in_ols[i][k] = max_sublayer_needed;
+                        }
+                    }
+                }
+            } else if (current->vps_ols_mode_idc == 1) {
+                num_output_layers_in_ols[i] = i + 1;
+                for (j = 0; j < num_output_layers_in_ols[i]; j++) {
+                    num_sub_layers_in_layer_in_ols[i][j] =
+                        current->vps_ptl_max_tid[current->vps_ols_ptl_idx[i]] + 1;
+                }
+            } else if (current->vps_ols_mode_idc == 2) {
+                uint8_t highest_included_layer = 0;
+                for (j = 0; j <= current->vps_max_layers_minus1; j++) {
+                    layer_included_in_ols_flag[i][j] = 0;
+                    num_sub_layers_in_layer_in_ols[i][j] = 0;
+                }
+                for (k = 0, j = 0; k <= current->vps_max_layers_minus1; k++) {
+                    if (current->vps_ols_output_layer_flag[i][k]) {
+                        layer_included_in_ols_flag[i][k] = 1;
+                        highest_included_layer = k;
+                        output_layer_idx[i][j] = k;
+                        num_sub_layers_in_layer_in_ols[i][k] =
+                            current->vps_ptl_max_tid[current->vps_ols_ptl_idx[i]] + 1;
+                    }
+                }
+                num_output_layers_in_ols[i] = j;
+                for (j = 0; j < num_output_layers_in_ols[i]; j++) {
+                    int idx = output_layer_idx[i][j];
+                    for (k = 0; k < num_ref_layers[idx]; k++) {
+                        if (!layer_included_in_ols_flag[i][reference_layer_idx[idx][k]])
+                            layer_included_in_ols_flag[i][reference_layer_idx[idx][k]] = 1;
+                    }
+                }
+                for (k = highest_included_layer - 1; k >= 0; k--) {
+                    if (layer_included_in_ols_flag[i][k] && !current->vps_ols_output_layer_flag[i][k]) {
+                        for (m = k + 1; m <= highest_included_layer; m++) {
+                            uint8_t max_sublayer_needed =
+                                FFMIN(num_sub_layers_in_layer_in_ols[i][m],
+                                      current->vps_max_tid_il_ref_pics_plus1[m][k]);
+                            if (current->vps_direct_ref_layer_flag[m][k] &&
+                                layer_included_in_ols_flag[i][m] &&
+                                num_sub_layers_in_layer_in_ols[i][k] < max_sublayer_needed)
+                                num_sub_layers_in_layer_in_ols[i][k] = max_sublayer_needed;
+                        }
+                    }
+                }
+            }
+        }
+        for (i = 1; i < total_num_olss; i++) {
+            int num_layers_in_ols = 0;
+            if (current->vps_each_layer_is_an_ols_flag) {
+                num_layers_in_ols = 1;
+            } else if (current->vps_ols_mode_idc == 0 || current->vps_ols_mode_idc == 1) {
+                num_layers_in_ols = i + 1;
+            } else if (current->vps_ols_mode_idc == 2) {
+                for (k = 0, j = 0; k <= current->vps_max_layers_minus1; k++) {
+                    if (layer_included_in_ols_flag[i][k])
+                        j++;
+                    num_layers_in_ols = j;
+                }
+            }
+            if (num_layers_in_ols > 1) {
+                num_multi_layer_olss++;
+            }
+        }
+    }
+
+    for (i = 0; i <= current->vps_num_ptls_minus1; i++) {
+        if (i > 0)
+            flags(vps_pt_present_flag[i], 1, i);
+        else
+            infer(vps_pt_present_flag[i], 1);
+
+        if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
+            us(3, vps_ptl_max_tid[i], 0, current->vps_max_sublayers_minus1, 1, i);
+        else
+            infer(vps_ptl_max_tid[i], current->vps_max_sublayers_minus1);
+    }
+    while (byte_alignment(rw) != 0)
+        fixed(1, vps_ptl_alignment_zero_bit, 0);
+    for (i = 0; i <= current->vps_num_ptls_minus1; i++) {
+        CHECK(FUNC(profile_tier_level)(ctx, rw,
+                                       current->vps_profile_tier_level + i,
+                                       current->vps_pt_present_flag[i],
+                                       current->vps_ptl_max_tid[i]));
+    }
+    for (i = 0; i < total_num_olss; i++) {
+        if (current->vps_num_ptls_minus1 > 0 &&
+            current->vps_num_ptls_minus1 + 1 != total_num_olss) {
+            us(8, vps_ols_ptl_idx[i], 0, current->vps_num_ptls_minus1, 1, i);
+        }
+        else if (current->vps_num_ptls_minus1 == 0) {
+            infer(vps_ols_ptl_idx[i], 0);
+        } else {
+            infer(vps_ols_ptl_idx[i], i);
+        }
+    }
+
+    if (!current->vps_each_layer_is_an_ols_flag) {
+        uint16_t vps_num_dpb_params;
+        ue(vps_num_dpb_params_minus1, 0, num_multi_layer_olss - 1);
+        if (current->vps_each_layer_is_an_ols_flag)
+            vps_num_dpb_params = 0;
+        else
+            vps_num_dpb_params = current->vps_num_dpb_params_minus1 + 1;
+
+        if (current->vps_max_sublayers_minus1 > 0)
+            flag(vps_sublayer_dpb_params_present_flag);
+        else
+            infer(vps_sublayer_dpb_params_present_flag, 0);
+
+        for (i = 0; i < vps_num_dpb_params; i++) {
+            if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
+                us(3, vps_dpb_max_tid[i], 0, current->vps_max_sublayers_minus1, 1, i);
+            else
+                infer(vps_dpb_max_tid[i], current->vps_max_sublayers_minus1);
+            CHECK(FUNC(dpb_parameters)(ctx, rw, current->vps_dpb_params + i,
+                                       current->vps_dpb_max_tid[i],
+                                       current->vps_sublayer_dpb_params_present_flag));
+        }
+        for (i = 0; i < num_multi_layer_olss; i++) {
+            ues(vps_ols_dpb_pic_width[i], 0, UINT16_MAX, 1, i);
+            ues(vps_ols_dpb_pic_height[i], 0, UINT16_MAX, 1, i);
+            ubs(2, vps_ols_dpb_chroma_format[i], 1, i);
+            ues(vps_ols_dpb_bitdepth_minus8[i], 0, 2, 1, i);
+            if (vps_num_dpb_params > 1 && vps_num_dpb_params != num_multi_layer_olss)
+                ues(vps_ols_dpb_params_idx[i], 0, vps_num_dpb_params - 1, 1, i);
+            else if (vps_num_dpb_params == 1)
+                infer(vps_ols_dpb_params_idx[i], 0);
+            else
+                infer(vps_ols_dpb_params_idx[i], i);
+        }
+        flag(vps_timing_hrd_params_present_flag);
+        if (current->vps_timing_hrd_params_present_flag) {
+            CHECK(FUNC(general_timing_hrd_parameters)(ctx, rw,
+                &current->vps_general_timing_hrd_parameters));
+            if (current->vps_max_sublayers_minus1 > 0)
+                flag(vps_sublayer_cpb_params_present_flag);
+            else
+                infer(vps_sublayer_cpb_params_present_flag, 0);
+            ue(vps_num_ols_timing_hrd_params_minus1, 0, num_multi_layer_olss - 1);
+            for (i = 0; i <= current->vps_num_ols_timing_hrd_params_minus1; i++) {
+                uint8_t first_sublayer;
+                if (!current->vps_default_ptl_dpb_hrd_max_tid_flag)
+                    us(3, vps_hrd_max_tid[i], 0, current->vps_max_sublayers_minus1, 1, i);
+                else
+                    infer(vps_hrd_max_tid[i], current->vps_max_sublayers_minus1);
+                first_sublayer = current->vps_sublayer_cpb_params_present_flag ?
+                    0 : current->vps_hrd_max_tid[i];
+                CHECK(FUNC(ols_timing_hrd_parameters)(ctx, rw,
+                    &current->vps_ols_timing_hrd_parameters, first_sublayer,
+                    current->vps_max_sublayers_minus1,
+                    &current->vps_general_timing_hrd_parameters));
+
+            }
+            if (current->vps_num_ols_timing_hrd_params_minus1 > 0 &&
+                current-> vps_num_ols_timing_hrd_params_minus1 + 1 != num_multi_layer_olss) {
+                for (i = 0; i < num_multi_layer_olss; i++) {
+                    ues(vps_ols_timing_hrd_idx[i], 0,
+                        current->vps_num_ols_timing_hrd_params_minus1, 1, i);
+                }
+            } else if (current->vps_num_ols_timing_hrd_params_minus1 == 0) {
+                for (i = 0; i < num_multi_layer_olss; i++)
+                    infer(vps_ols_timing_hrd_idx[i], 0);
+            } else {
+                for (i = 0; i < num_multi_layer_olss; i++)
+                    infer(vps_ols_timing_hrd_idx[i], i);
+            }
+        }
+    }
+
+    flag(vps_extension_flag);
+    if (current->vps_extension_flag)
+        CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
+    CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+
+    return 0;
+}
+
+
+static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
+                     H266RawSPS *current)
+{
+    CodedBitstreamH266Context *h266 = ctx->priv_data;
+    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, tmp_width_val, tmp_height_val;
+    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 == 0 && !h266->vps_ref[0]) {
+        H266RawVPS* vps;
+        AVBufferRef *ref = av_buffer_allocz(sizeof(H266RawVPS));
+        if (!ref) {
+            return AVERROR(ENOMEM);
+        }
+        vps = (H266RawVPS*)ref->data;
+        vps->vps_max_layers_minus1 = 0;
+        vps->vps_independent_layer_flag[0] = 1;
+        vps->vps_layer_id[0] = current->nal_unit_header.nuh_layer_id;
+        h266->vps_ref[0] = ref;
+        h266->vps[0] = vps;
+    }
+
+    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);
+    }
+
+    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) {
+        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);
+        }
+    } else {
+        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);
+    }
+
+
+    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, 2);
+    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_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,
+                                current->sps_chroma_format_idc));
+    } else {
+        CHECK(FUNC(vui_parameters_default)(ctx, rw, &current->vui));
+    }
+    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)(CodedBitstreamContext *ctx, RWContext *rw,
+                     H266RawPPS *current)
+{
+
+    CodedBitstreamH266Context *h266 = ctx->priv_data;
+    const H266RawSPS *sps;
+    int err, i;
+    unsigned int min_cb_size_y, divisor, ctb_size_y,
+        pic_width_in_ctbs_y, pic_height_in_ctbs_y;
+    uint8_t sub_width_c, sub_height_c, 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;
+    }
+
+    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);
+        }
+    }
+
+    pic_width_in_ctbs_y =
+        h266_ceil(current->pps_pic_width_in_luma_samples, ctb_size_y);
+    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 - 1));
+        ue(pps_num_exp_tile_rows_minus1,
+           0, FFMIN(pic_height_in_ctbs_y - 1, VVC_MAX_TILE_ROWS - 1));
+
+        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 - exp_tile_width - 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));
+        current->num_tile_columns = i + h266_ceil(remaining_size, unified_size);
+        if (current->num_tile_columns > VVC_MAX_TILE_COLUMNS) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR,
+                   "NumTileColumns(%d) large than %d.\n",
+                   current->num_tile_columns, VVC_MAX_TILE_COLUMNS);
+            return AVERROR_INVALIDDATA;
+        }
+        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;
+        }
+
+        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));
+        current->num_tile_rows = i + h266_ceil(remaining_size, unified_size);
+        if (current->num_tile_rows > VVC_MAX_TILE_ROWS) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR,
+                   "NumTileRows(%d) large than %d, consider increase VVC_MAX_TILE_ROWS.\n",
+                   current->num_tile_rows, VVC_MAX_TILE_ROWS);
+            return AVERROR_INVALIDDATA;
+        }
+        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;
+        }
+
+        current->num_tiles_in_pic =
+            current->num_tile_columns * current->num_tile_rows;
+        if (current->num_tiles_in_pic > VVC_MAX_TILES_PER_AU) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR,
+                   "NumTilesInPic(%d) large than %d.\n",
+                   current->num_tiles_in_pic, VVC_MAX_TILES_PER_AU);
+            return AVERROR_INVALIDDATA;
+        }
+
+        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) {
+            int 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 (current->pps_slice_width_in_tiles_minus1[i] == 0 &&
+                    current->pps_slice_height_in_tiles_minus1[i] == 0 &&
+                    current->pps_tile_row_height_minus1[tile_y] > 0) {
+                    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]++;
+                    }
+                }
+            }
+        } 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);
+    }
+
+    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) {
+            ue(pps_chroma_qp_offset_list_len_minus1, 0, 5);
+            for (i = 0; i <= current->pps_chroma_qp_offset_list_len_minus1; i++) {
+                ses(pps_cb_qp_offset_list[i], -12, 12, 1, i);
+                ses(pps_cr_qp_offset_list[i], -12, 12, 1, i);
+                if (current->pps_joint_cbcr_qp_offset_present_flag)
+                    ses(pps_joint_cbcr_qp_offset_list[i], -12, 12, 1, i);
+                else
+                    infer(pps_joint_cbcr_qp_offset_list[i], 0);
+            }
+        }
+    } 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 H266RawVPS *vps;
+    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 (!sps) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
+               pps->pps_seq_parameter_set_id);
+        return AVERROR_INVALIDDATA;
+    }
+    vps = h266->vps[sps->sps_video_parameter_set_id];
+    if (!vps) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available.\n",
+               sps->sps_video_parameter_set_id);
+        return AVERROR_INVALIDDATA;
+    }
+
+    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, sps, pps, &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->ph = (H266RawPH*)h266->ph_ref->data;
+        memcpy(h266->ph, &current->sh_picture_header, sizeof(H266RawPH));
+    }
+
+    ph = h266->ph;
+    if (!ph) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "Picture header not available.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    pps = h266->pps[ph->ph_pic_parameter_set_id];
+    if (!pps) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
+               ph->ph_pic_parameter_set_id);
+        return AVERROR_INVALIDDATA;
+    }
+    sps = h266->sps[pps->pps_seq_parameter_set_id];
+    if (!sps) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
+               pps->pps_seq_parameter_set_id);
+        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, sps, pps, &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_idx, i;
+
+    HEADER("Decoded Picture Hash");
+
+    u(8, dph_sei_hash_type, 0, 2);
+    flag(dph_sei_single_component_flag);
+    ub(7, ph_sei_reserved_zero_7bits);
+
+    for (c_idx = 0; c_idx < (current->dph_sei_single_component_flag ? 1 : 3); c_idx++) {
+        if (current->dph_sei_hash_type == 0) {
+            for (i = 0; i < 16; i++)
+                us(8, dph_sei_picture_md5[c_idx][i], 0x00, 0xff, 2, c_idx, i);
+        } else if (current->dph_sei_hash_type == 1) {
+            us(16, dph_sei_picture_crc[c_idx], 0x0000, 0xffff, 1, c_idx);
+        } else if (current->dph_sei_hash_type == 2) {
+            us(32, dph_sei_picture_checksum[c_idx], 0x00000000, 0xffffffff, 1, c_idx);
+        }
+    }
+    return 0;
+}
+
+static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw,
+                     H266RawSEI *current, int prefix)
+{
+    int err;
+
+    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));
+
+    CHECK(FUNC_SEI(message_list)(ctx, rw, &current->message_list, prefix));
+
+    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;
diff --git a/libavcodec/cbs_sei.c b/libavcodec/cbs_sei.c
index c49830ad77..96c60259ce 100644
--- a/libavcodec/cbs_sei.c
+++ b/libavcodec/cbs_sei.c
@@ -20,6 +20,7 @@ 
 #include "cbs_internal.h"
 #include "cbs_h264.h"
 #include "cbs_h265.h"
+#include "cbs_h266.h"
 #include "cbs_sei.h"
 
 static void cbs_free_user_data_registered(void *opaque, uint8_t *data)
@@ -132,6 +133,13 @@  static int cbs_sei_get_unit(CodedBitstreamContext *ctx,
         else
             sei_type = HEVC_NAL_SEI_SUFFIX;
         break;
+    case AV_CODEC_ID_H266:
+        highest_vcl_type = VVC_RSV_IRAP_11;
+        if (prefix)
+            sei_type = VVC_PREFIX_SEI_NUT;
+        else
+            sei_type = VVC_SUFFIX_SEI_NUT;
+        break;
     default:
         return AVERROR(EINVAL);
     }
@@ -207,6 +215,18 @@  static int cbs_sei_get_unit(CodedBitstreamContext *ctx,
             memcpy(unit->content, &sei, sizeof(sei));
         }
         break;
+    case AV_CODEC_ID_H266:
+        {
+            H266RawSEI sei = {
+                .nal_unit_header = {
+                    .nal_unit_type         = sei_type,
+                    .nuh_layer_id          = 0,
+                    .nuh_temporal_id_plus1 = 1,
+                },
+            };
+            memcpy(unit->content, &sei, sizeof(sei));
+        }
+        break;
     default:
         av_assert0(0);
     }
@@ -237,6 +257,15 @@  static int cbs_sei_get_message_list(CodedBitstreamContext *ctx,
             *list = &sei->message_list;
         }
         break;
+    case AV_CODEC_ID_H266:
+        {
+            H266RawSEI *sei = unit->content;
+            if (unit->type != VVC_PREFIX_SEI_NUT &&
+                unit->type != VVC_SUFFIX_SEI_NUT)
+                return AVERROR(EINVAL);
+            *list = &sei->message_list;
+        }
+        break;
     default:
         return AVERROR(EINVAL);
     }