Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

vvcdec: add parameter parser for sps, pps, ph, sh

Browse Source 
Co-authored-by: Xu Mu <toxumu@outlook.com>
Co-authored-by: Frank Plowman <post@frankplowman.com>
Co-authored-by: Shaun Loo <shaunloo10@gmail.com>
Co-authored-by: Wu Jianhua <toqsxw@outlook.com>
release/7.0
Nuo Mi 1 year ago
parent 49db9fc171
commit e97a5bbb13
4 changed files with 1628 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      libavcodec/vvc/Makefile
  2. 1150
      libavcodec/vvc/vvc_ps.c
  3. 263
      libavcodec/vvc/vvc_ps.h
  4. 214
      libavcodec/vvc/vvcdec.h

1
libavcodec/vvc/Makefile
Unescape View File

@ -2,3 +2,4 @@ clean::
$(RM) $(CLEANSUFFIXES:%=libavcodec/vvc/%)
OBJS-$(CONFIG_VVC_DECODER) += vvc/vvc_data.o \
vvc/vvc_ps.o \

1150
libavcodec/vvc/vvc_ps.c
View File

File diff suppressed because it is too large Load Diff

263
libavcodec/vvc/vvc_ps.h
Unescape View File

@ -0,0 +1,263 @@
/*
* VVC parameter set parser
*
* Copyright (C) 2023 Nuo Mi
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_VVC_VVC_PS_H
#define AVCODEC_VVC_VVC_PS_H
#include "libavcodec/cbs_h266.h"
#include "libavcodec/vvc.h"
#define IS_IDR(s) ((s)->vcl_unit_type == VVC_IDR_W_RADL || (s)->vcl_unit_type == VVC_IDR_N_LP)
#define IS_CRA(s) ((s)->vcl_unit_type == VVC_CRA_NUT)
#define IS_IRAP(s) (IS_IDR(s) || IS_CRA(s))
#define IS_GDR(s) ((s)->vcl_unit_type == VVC_GDR_NUT)
#define IS_CVSS(s) (IS_IRAP(s)|| IS_GDR(s))
#define IS_CLVSS(s) (IS_CVSS(s) && s->no_output_before_recovery_flag)
#define IS_RASL(s) ((s)->vcl_unit_type == VVC_RASL_NUT)
#define IS_RADL(s) ((s)->vcl_unit_type == VVC_RADL_NUT)
#define IS_I(rsh) ((rsh)->sh_slice_type == VVC_SLICE_TYPE_I)
#define IS_P(rsh) ((rsh)->sh_slice_type == VVC_SLICE_TYPE_P)
#define IS_B(rsh) ((rsh)->sh_slice_type == VVC_SLICE_TYPE_B)
#define INV_POC INT_MIN
#define GDR_IS_RECOVERED(s) (s->gdr_recovery_point_poc == INV_POC)
#define GDR_SET_RECOVERED(s) (s->gdr_recovery_point_poc = INV_POC)
#define LMCS_MAX_BIT_DEPTH 12
#define LMCS_MAX_LUT_SIZE (1 << LMCS_MAX_BIT_DEPTH)
#define LMCS_MAX_BIN_SIZE 16
#define LADF_MAX_INTERVAL 5
enum {
CHROMA_FORMAT_MONO,
CHROMA_FORMAT_420,
CHROMA_FORMAT_422,
CHROMA_FORMAT_444,
};
typedef struct VVCSPS {
const H266RawSPS *r; ///< RefStruct reference
//derived values
uint16_t width;
uint16_t height;
uint8_t hshift[VVC_MAX_SAMPLE_ARRAYS];
uint8_t vshift[VVC_MAX_SAMPLE_ARRAYS];
uint32_t max_pic_order_cnt_lsb; ///< MaxPicOrderCntLsb
uint8_t pixel_shift;
enum AVPixelFormat pix_fmt;
uint8_t bit_depth; ///< BitDepth
uint8_t qp_bd_offset; ///< QpBdOffset
uint8_t ctb_log2_size_y; ///< CtbLog2SizeY
uint8_t ctb_size_y; ///< CtbSizeY
uint8_t min_cb_log2_size_y; ///< MinCbLog2SizeY
uint8_t min_cb_size_y; ///< MinCbSizeY
uint8_t max_tb_size_y; ///< MaxTbSizeY
uint8_t max_ts_size; ///< MaxTsSize
uint8_t max_num_merge_cand; ///< MaxNumMergeCand
uint8_t max_num_ibc_merge_cand; ///< MaxNumIbcMergeCand
uint8_t max_num_gpm_merge_cand; ///< MaxNumGpmMergeCand
uint8_t num_ladf_intervals; ///< sps_num_ladf_intervals_minus2 + 2;
uint32_t ladf_interval_lower_bound[LADF_MAX_INTERVAL]; ///< SpsLadfIntervalLowerBound[]
uint8_t log2_parallel_merge_level; ///< sps_log2_parallel_merge_level_minus2 + 2;
uint8_t log2_transform_range; ///< Log2TransformRange
int8_t chroma_qp_table[3][VVC_MAX_POINTS_IN_QP_TABLE]; ///< ChromaQpTable
} VVCSPS;
typedef struct DBParams {
int8_t beta_offset[VVC_MAX_SAMPLE_ARRAYS];
int8_t tc_offset[VVC_MAX_SAMPLE_ARRAYS];
} DBParams;
typedef struct VVCPPS {
const H266RawPPS *r; ///< RefStruct reference
//derived value;
int8_t chroma_qp_offset[3]; ///< pps_cb_qp_offset, pps_cr_qp_offset, pps_joint_cbcr_qp_offset_value
int8_t chroma_qp_offset_list[6][3]; ///< pps_cb_qp_offset_list, pps_cr_qp_offset_list, pps_joint_cbcr_qp_offset_list
uint16_t width;
uint16_t height;
uint16_t slice_start_offset[VVC_MAX_SLICES];
uint16_t num_ctus_in_slice [VVC_MAX_SLICES];
uint16_t min_cb_width;
uint16_t min_cb_height;
uint16_t ctb_width;
uint16_t ctb_height;
uint32_t ctb_count;
uint16_t min_pu_width;
uint16_t min_pu_height;
uint16_t min_tu_width;
uint16_t min_tu_height;
uint32_t *ctb_addr_in_slice; ///< CtbAddrInCurrSlice for entire picture
uint16_t *col_bd;
uint16_t *row_bd;
uint16_t *ctb_to_col_bd;
uint16_t *ctb_to_row_bd;
uint16_t width32; ///< width in 32 pixels
uint16_t height32; ///< height in 32 pixels
uint16_t width64; ///< width in 64 pixels
uint16_t height64; ///< height in 64 pixels
uint16_t ref_wraparound_offset; ///< PpsRefWraparoundOffset
} VVCPPS;
#define MAX_WEIGHTS 15
typedef struct PredWeightTable {
uint8_t log2_denom[2]; ///< luma_log2_weight_denom, ChromaLog2WeightDenom
uint8_t nb_weights[2]; ///< num_l0_weights, num_l1_weights
uint8_t weight_flag[2][2][MAX_WEIGHTS]; ///< luma_weight_l0_flag, chroma_weight_l0_flag,
///< luma_weight_l1_flag, chroma_weight_l1_flag,
int16_t weight[2][VVC_MAX_SAMPLE_ARRAYS][MAX_WEIGHTS]; ///< LumaWeightL0, LumaWeightL1, ChromaWeightL0, ChromaWeightL1
int16_t offset[2][VVC_MAX_SAMPLE_ARRAYS][MAX_WEIGHTS]; ///< luma_offset_l0, luma_offset_l1, ChromaOffsetL0, ChromaOffsetL1
} PredWeightTable;
typedef struct VVCPH {
const H266RawPictureHeader *r;
void *rref; ///< RefStruct reference, backing ph above
//derived values
uint32_t max_num_subblock_merge_cand; ///< MaxNumSubblockMergeCand
int32_t poc; ///< PicOrderCntVal
PredWeightTable pwt;
} VVCPH;
#define ALF_NUM_FILTERS_LUMA 25
#define ALF_NUM_FILTERS_CHROMA 8
#define ALF_NUM_FILTERS_CC 5
#define ALF_NUM_COEFF_LUMA 12
#define ALF_NUM_COEFF_CHROMA 6
#define ALF_NUM_COEFF_CC 7
typedef struct VVCALF {
int16_t luma_coeff [ALF_NUM_FILTERS_LUMA][ALF_NUM_COEFF_LUMA];
uint8_t luma_clip_idx [ALF_NUM_FILTERS_LUMA][ALF_NUM_COEFF_LUMA];
uint8_t num_chroma_filters;
int16_t chroma_coeff [ALF_NUM_FILTERS_CHROMA][ALF_NUM_COEFF_CHROMA];
uint8_t chroma_clip_idx[ALF_NUM_FILTERS_CHROMA][ALF_NUM_COEFF_CHROMA];
uint8_t num_cc_filters[2]; ///< alf_cc_cb_filters_signalled_minus1 + 1, alf_cc_cr_filters_signalled_minus1 + 1
int16_t cc_coeff[2][ALF_NUM_FILTERS_CC][ALF_NUM_COEFF_CC];
} VVCALF;
enum {
SL_START_2x2 = 0,
SL_START_4x4 = 2,
SL_START_8x8 = 8,
SL_START_16x16 = 14,
SL_START_32x32 = 20,
SL_START_64x64 = 26,
SL_MAX_ID = 28,
};
#define SL_MAX_MATRIX_SIZE 8
typedef struct VVCScalingList {
uint8_t scaling_matrix_rec[SL_MAX_ID][SL_MAX_MATRIX_SIZE * SL_MAX_MATRIX_SIZE]; ///< ScalingMatrixRec
uint8_t scaling_matrix_dc_rec[SL_MAX_ID - SL_START_16x16]; ///< ScalingMatrixDcRec[refId − 14]
} VVCScalingList;
typedef struct VVCLMCS {
uint8_t min_bin_idx;
uint8_t max_bin_idx;
//*2 for high depth
uint8_t fwd_lut[LMCS_MAX_LUT_SIZE * 2];
uint8_t inv_lut[LMCS_MAX_LUT_SIZE * 2];
uint16_t pivot[LMCS_MAX_BIN_SIZE + 1];
uint16_t chroma_scale_coeff[LMCS_MAX_BIN_SIZE];
} VVCLMCS;
#define VVC_MAX_ALF_COUNT 8
#define VVC_MAX_LMCS_COUNT 4
#define VVC_MAX_SL_COUNT 8
typedef struct VVCParamSets {
const VVCSPS *sps_list[VVC_MAX_SPS_COUNT]; ///< RefStruct reference
const VVCPPS *pps_list[VVC_MAX_PPS_COUNT]; ///< RefStruct reference
const VVCALF *alf_list[VVC_MAX_ALF_COUNT]; ///< RefStruct reference
const H266RawAPS *lmcs_list[VVC_MAX_LMCS_COUNT]; ///< RefStruct reference
const VVCScalingList *scaling_list[VVC_MAX_SL_COUNT]; ///< RefStruct reference
} VVCParamSets;
typedef struct VVCFrameParamSets {
const VVCSPS *sps; ///< RefStruct reference
const VVCPPS *pps; ///< RefStruct reference
VVCPH ph;
const VVCALF *alf_list[VVC_MAX_ALF_COUNT]; ///< RefStruct reference
VVCLMCS lmcs;
const VVCScalingList *sl; ///< RefStruct reference
} VVCFrameParamSets;
typedef struct VVCSH {
const H266RawSliceHeader *r; ///< RefStruct reference
// derived values
// ctu address
uint32_t num_ctus_in_curr_slice; ///< NumCtusInCurrSlice
const uint32_t* ctb_addr_in_curr_slice; ///< CtbAddrInCurrSlice
// inter
PredWeightTable pwt;
int8_t ref_idx_sym[2]; ///< RefIdxSymL0, RefIdxSymL1
// qp_y
int8_t slice_qp_y; ///< SliceQpY
// deblock_offsets
DBParams deblock;
// partition constrains
uint8_t min_qt_size[2]; ///< MinQtSizeY, MinQtSizeC
uint8_t max_bt_size[2]; ///< MaxBtSizeY, MaxBtSizeC
uint8_t max_tt_size[2]; ///< MaxTtSizeY, MaxTtSizeC
uint8_t max_mtt_depth[2]; ///< MaxMttDepthY, MaxMttDepthC
uint8_t cu_qp_delta_subdiv; ///< CuQpDeltaSubdiv
uint8_t cu_chroma_qp_offset_subdiv; ///< CuChromaQpOffsetSubdiv
// entries
uint32_t entry_point_start_ctu[VVC_MAX_ENTRY_POINTS]; ///< entry point start in ctu_addr
} VVCSH;
struct VVCContext;
int ff_vvc_decode_frame_ps(VVCFrameParamSets *fps, struct VVCContext *s);
int ff_vvc_decode_aps(VVCParamSets *ps, const CodedBitstreamUnit *unit);
int ff_vvc_decode_sh(VVCSH *sh, const VVCFrameParamSets *ps, const CodedBitstreamUnit *unit);
void ff_vvc_frame_ps_free(VVCFrameParamSets *fps);
void ff_vvc_ps_uninit(VVCParamSets *ps);
#endif /* AVCODEC_VVC_VVC_PS_H */

214
libavcodec/vvc/vvcdec.h
Unescape View File

@ -0,0 +1,214 @@
/*
* VVC video decoder
*
* Copyright (C) 2021 Nuo Mi
* Copyright (C) 2022 Xu Mu
*
* 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_VVC_VVCDEC_H
#define AVCODEC_VVC_VVCDEC_H
#include "libavcodec/vvc.h"
#include "vvc_ps.h"
#define LUMA 0
#define CHROMA 1
#define CB 1
#define CR 2
#define JCBCR 3
#define MIN_TU_LOG2 2 ///< MinTbLog2SizeY
#define MIN_PU_LOG2 2
#define L0 0
#define L1 1
typedef struct RefPicList {
struct VVCFrame *ref[VVC_MAX_REF_ENTRIES];
int list[VVC_MAX_REF_ENTRIES];
int isLongTerm[VVC_MAX_REF_ENTRIES];
int nb_refs;
} RefPicList;
typedef struct RefPicListTab {
RefPicList refPicList[2];
} RefPicListTab;
typedef struct VVCFrame {
struct AVFrame *frame;
struct MvField *tab_dmvr_mvf; ///< RefStruct reference
RefPicListTab **rpl_tab; ///< RefStruct reference
RefPicListTab *rpl; ///< RefStruct reference
int nb_rpl_elems;
int ctb_count;
int poc;
struct VVCFrame *collocated_ref;
struct FrameProgress *progress; ///< RefStruct reference
/**
* A sequence counter, so that old frames are output first
* after a POC reset
*/
uint16_t sequence;
/**
* A combination of VVC_FRAME_FLAG_*
*/
uint8_t flags;
} VVCFrame;
typedef struct SliceContext {
int slice_idx;
struct EntryPoint *eps;
int nb_eps;
RefPicList *rpl;
void *ref; ///< RefStruct reference, backing slice data
} SliceContext;
typedef struct VVCFrameContext {
void *log_ctx;
// +1 for the current frame
VVCFrame DPB[VVC_MAX_DPB_SIZE + 1];
struct AVFrame *frame;
struct AVFrame *output_frame;
SliceContext **slices;
int nb_slices;
int nb_slices_allocated;
VVCFrame *ref;
struct VVCFrameThread *ft;
uint64_t decode_order;
struct FFRefStructPool *tab_dmvr_mvf_pool;
struct FFRefStructPool *rpl_tab_pool;
struct FFRefStructPool *cu_pool;
struct FFRefStructPool *tu_pool;
struct {
int16_t *slice_idx;
int *cb_pos_x[2]; ///< CbPosX[][][]
int *cb_pos_y[2]; ///< CbPosY[][][]
uint8_t *cb_width[2]; ///< CbWidth[][][]
uint8_t *cb_height[2]; ///< CbHeight[][][]
uint8_t *cqt_depth[2]; ///< CqtDepth[][][]
int8_t *qp[VVC_MAX_SAMPLE_ARRAYS];
uint8_t *skip; ///< CuSkipFlag[][]
uint8_t *ispmf; ///< intra_sub_partitions_mode_flag
uint8_t *msm[2]; ///< MttSplitMode[][][] in 32 pixels
uint8_t *imf; ///< IntraMipFlag[][]
uint8_t *imtf; ///< intra_mip_transposed_flag[][]
uint8_t *imm; ///< intra_mip_mode[][]
uint8_t *ipm; ///< IntraPredModeY[][]
uint8_t *cpm[2]; ///< CuPredMode[][][]
uint8_t *msf; ///< MergeSubblockFlag[][]
uint8_t *iaf; ///< InterAffineFlag[][]
uint8_t *mmi; ///< MotionModelIdc[][]
struct Mv *cp_mv[2]; ///< CpMvLX[][][][MAX_CONTROL_POINTS];
struct MvField *mvf; ///< MvDmvrL0, MvDmvrL1
uint8_t *tu_coded_flag[VVC_MAX_SAMPLE_ARRAYS]; ///< tu_y_coded_flag[][], tu_cb_coded_flag[][], tu_cr_coded_flag[][]
uint8_t *tu_joint_cbcr_residual_flag; ///< tu_joint_cbcr_residual_flag[][]
int *tb_pos_x0[2];
int *tb_pos_y0[2];
uint8_t *tb_width[2];
uint8_t *tb_height[2];
uint8_t *pcmf[2];
uint8_t *horizontal_bs[VVC_MAX_SAMPLE_ARRAYS];
uint8_t *vertical_bs[VVC_MAX_SAMPLE_ARRAYS];
uint8_t *horizontal_p; ///< horizontal maxFilterLengthPs for luma
uint8_t *horizontal_q; ///< horizontal maxFilterLengthQs for luma
uint8_t *vertical_p; ///< vertical maxFilterLengthPs for luma
uint8_t *vertical_q; ///< vertical maxFilterLengthQs for luma
uint8_t *sao_pixel_buffer_h[VVC_MAX_SAMPLE_ARRAYS];
uint8_t *sao_pixel_buffer_v[VVC_MAX_SAMPLE_ARRAYS];
uint8_t *alf_pixel_buffer_h[VVC_MAX_SAMPLE_ARRAYS][2];
uint8_t *alf_pixel_buffer_v[VVC_MAX_SAMPLE_ARRAYS][2];
int *coeffs;
struct CTU *ctus;
//used in arrays_init only
struct {
int ctu_count;
int ctu_size;
int pic_size_in_min_cb;
int pic_size_in_min_pu;
int pic_size_in_min_tu;
int ctu_width;
int ctu_height;
int width;
int height;
int chroma_format_idc;
int pixel_shift;
int bs_width;
int bs_height;
} sz;
} tab;
} VVCFrameContext;
typedef struct VVCContext {
struct AVCodecContext *avctx;
CodedBitstreamContext *cbc;
CodedBitstreamFragment current_frame;
VVCParamSets ps;
int temporal_id; ///< temporal_id_plus1 - 1
int poc_tid0;
int eos; ///< current packet contains an EOS/EOB NAL
int last_eos; ///< last packet contains an EOS/EOB NAL
enum VVCNALUnitType vcl_unit_type;
int no_output_before_recovery_flag; ///< NoOutputBeforeRecoveryFlag
int gdr_recovery_point_poc; ///< recoveryPointPocVal
/**
* Sequence counters for decoded and output frames, so that old
* frames are output first after a POC reset
*/
uint16_t seq_decode;
uint16_t seq_output;
struct AVExecutor *executor;
VVCFrameContext *fcs;
int nb_fcs;
uint64_t nb_frames; ///< processed frames
int nb_delayed; ///< delayed frames
} VVCContext ;
#endif /* AVCODEC_VVC_VVCDEC_H */
Write Preview
Loading…
Cancel
Save