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

lavc/hevc_ps: Add SPS/PPS parse support for HEVC extension syntax

Browse Source 
1. Add extension syntax according to 7.3.2.2.3/7.3.2.3.3 in T-REC-H.265-201911.
2. Keep using parsed PPS when bitstream overread for compatibility. For
example, the clip PS_A_VIDYO_3.bit in FATE test has incomplete extension
syntax which will be overread and un-decodable if without this change.
3. Format brace in pps_range_extensions().

Signed-off-by: Linjie Fu <linjie.justin.fu@gmail.com>
Signed-off-by: Haihao Xiang <haihao.xiang@intel.com>
Signed-off-by: Fei Wang <fei.w.wang@intel.com>
pull/389/head
Linjie Fu 2 years ago committed by Haihao Xiang
parent f459377543
commit 56e3cd23d4
3 changed files with 349 additions and 12 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. 3
      libavcodec/hevc.h
  2. 289
      libavcodec/hevc_ps.c
  3. 69
      libavcodec/hevc_ps.h

3
libavcodec/hevc.h
Unescape View File

@ -154,6 +154,9 @@ enum {
// get near that, though, so set a lower limit here with the maximum
// possible value for 4K video (at most 135 16x16 Ctb rows).
HEVC_MAX_ENTRY_POINT_OFFSETS = HEVC_MAX_TILE_COLUMNS * 135,
// A.3.7: Screen content coding extensions
HEVC_MAX_PALETTE_PREDICTOR_SIZE = 128,
};

289
libavcodec/hevc_ps.c
Unescape View File

@ -853,7 +853,7 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
HEVCWindow *ow;
int ret = 0;
int log2_diff_max_min_transform_block_size;
int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
int bit_depth_chroma, start, vui_present, sublayer_ordering_info, num_comps;
int i;
// Coded parameters
@ -1074,8 +1074,12 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
decode_vui(gb, avctx, apply_defdispwin, sps);
if (get_bits1(gb)) { // sps_extension_flag
sps->sps_range_extension_flag = get_bits1(gb);
skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
sps->sps_range_extension_flag = get_bits1(gb);
sps->sps_multilayer_extension_flag = get_bits1(gb);
sps->sps_3d_extension_flag = get_bits1(gb);
sps->sps_scc_extension_flag = get_bits1(gb);
skip_bits(gb, 4); // sps_extension_4bits
if (sps->sps_range_extension_flag) {
sps->transform_skip_rotation_enabled_flag = get_bits1(gb);
sps->transform_skip_context_enabled_flag = get_bits1(gb);
@ -1101,6 +1105,57 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
av_log(avctx, AV_LOG_WARNING,
"cabac_bypass_alignment_enabled_flag not yet implemented\n");
}
if (sps->sps_multilayer_extension_flag) {
skip_bits1(gb); // inter_view_mv_vert_constraint_flag
av_log(avctx, AV_LOG_WARNING,
"sps_multilayer_extension_flag not yet implemented\n");
}
if (sps->sps_3d_extension_flag) {
for (i = 0; i <= 1; i++) {
skip_bits1(gb); // iv_di_mc_enabled_flag
skip_bits1(gb); // iv_mv_scal_enabled_flag
if (i == 0) {
get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
skip_bits1(gb); // iv_res_pred_enabled_flag
skip_bits1(gb); // depth_ref_enabled_flag
skip_bits1(gb); // vsp_mc_enabled_flag
skip_bits1(gb); // dbbp_enabled_flag
} else {
skip_bits1(gb); // tex_mc_enabled_flag
get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
skip_bits1(gb); // intra_contour_enabled_flag
skip_bits1(gb); // intra_dc_only_wedge_enabled_flag
skip_bits1(gb); // cqt_cu_part_pred_enabled_flag
skip_bits1(gb); // inter_dc_only_enabled_flag
skip_bits1(gb); // skip_intra_enabled_flag
}
}
av_log(avctx, AV_LOG_WARNING,
"sps_3d_extension_flag not yet implemented\n");
}
if (sps->sps_scc_extension_flag) {
sps->sps_curr_pic_ref_enabled_flag = get_bits1(gb);
sps->palette_mode_enabled_flag = get_bits1(gb);
if (sps->palette_mode_enabled_flag) {
sps->palette_max_size = get_ue_golomb_long(gb);
sps->delta_palette_max_predictor_size = get_ue_golomb_long(gb);
sps->sps_palette_predictor_initializers_present_flag = get_bits1(gb);
if (sps->sps_palette_predictor_initializers_present_flag) {
sps->sps_num_palette_predictor_initializers_minus1 = get_ue_golomb_long(gb);
num_comps = !sps->chroma_format_idc ? 1 : 3;
for (int comp = 0; comp < num_comps; comp++)
for (i = 0; i <= sps->sps_num_palette_predictor_initializers_minus1; i++)
sps->sps_palette_predictor_initializer[comp][i] =
get_bits(gb, !comp ? sps->bit_depth : sps->bit_depth_chroma);
}
}
sps->motion_vector_resolution_control_idc = get_bits(gb, 2);
sps->intra_boundary_filtering_disabled_flag = get_bits1(gb);
}
}
if (apply_defdispwin) {
sps->output_window.left_offset += sps->vui.def_disp_win.left_offset;
@ -1265,10 +1320,161 @@ static void hevc_pps_free(void *opaque, uint8_t *data)
av_freep(&pps);
}
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
HEVCPPS *pps, HEVCSPS *sps) {
int i;
static void colour_mapping_octants(GetBitContext *gb, HEVCPPS *pps, int inp_depth,
int idx_y, int idx_cb, int idx_cr, int inp_length)
{
unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
int bit_depth_cm_input_y, bit_depth_cm_output_y, cm_res_bits;
part_num_y = 1 << pps->cm_y_part_num_log2;
split_octant_flag = inp_depth < pps->cm_octant_depth ? get_bits1(gb) : 0;
if (split_octant_flag)
for (int k = 0; k < 2; k++)
for (int m = 0; m < 2; m++)
for (int n = 0; n < 2; n++)
colour_mapping_octants(gb, pps, inp_depth + 1,
idx_y + part_num_y * k * inp_length / 2,
idx_cb + m * inp_length / 2,
idx_cr + n * inp_length / 2,
inp_length / 2);
else
for (int i = 0; i < part_num_y; i++) {
for (int j = 0; j < 4; j++) {
coded_res_flag = get_bits1(gb);
if (coded_res_flag)
for (int c = 0; c < 3; c++) {
res_coeff_q = get_ue_golomb_long(gb);
bit_depth_cm_input_y = 8 + pps->luma_bit_depth_cm_input_minus8;
bit_depth_cm_output_y = 8 + pps->luma_bit_depth_cm_output_minus8;
cm_res_bits = FFMAX(0, 10 + bit_depth_cm_input_y - bit_depth_cm_output_y -
pps->cm_res_quant_bits - (pps->cm_delta_flc_bits_minus1 + 1));
res_coeff_r = cm_res_bits ? get_bits(gb, cm_res_bits) : 0;
if (res_coeff_q || res_coeff_r)
skip_bits1(gb);
}
}
}
}
static void colour_mapping_table(GetBitContext *gb, HEVCPPS *pps)
{
pps->num_cm_ref_layers_minus1 = get_ue_golomb_long(gb);
for (int i = 0; i <= pps->num_cm_ref_layers_minus1; i++)
pps->cm_ref_layer_id[i] = get_bits(gb, 6);
pps->cm_octant_depth = get_bits(gb, 2);
pps->cm_y_part_num_log2 = get_bits(gb, 2);
pps->luma_bit_depth_cm_input_minus8 = get_ue_golomb_long(gb);
pps->chroma_bit_depth_cm_input_minus8 = get_ue_golomb_long(gb);
pps->luma_bit_depth_cm_output_minus8 = get_ue_golomb_long(gb);
pps->chroma_bit_depth_cm_output_minus8 = get_ue_golomb_long(gb);
pps->cm_res_quant_bits = get_bits(gb, 2);
pps->cm_delta_flc_bits_minus1 = get_bits(gb, 2);
if (pps->cm_octant_depth == 1) {
pps->cm_adapt_threshold_u_delta = get_se_golomb_long(gb);
pps->cm_adapt_threshold_v_delta = get_se_golomb_long(gb);
}
colour_mapping_octants(gb, pps, 0, 0, 0, 0, 1 << pps->cm_octant_depth);
}
static int pps_multilayer_extension(GetBitContext *gb, AVCodecContext *avctx,
HEVCPPS *pps, HEVCSPS *sps)
{
pps->poc_reset_info_present_flag = get_bits1(gb);
pps->pps_infer_scaling_list_flag = get_bits1(gb);
if (pps->pps_infer_scaling_list_flag)
pps->pps_scaling_list_ref_layer_id = get_bits(gb, 6);
pps->num_ref_loc_offsets = get_ue_golomb_long(gb);
for (int i = 0; i < pps->num_ref_loc_offsets; i++) {
pps->ref_loc_offset_layer_id[i] = get_bits(gb, 6);
pps->scaled_ref_layer_offset_present_flag[i] = get_bits1(gb);
if (pps->scaled_ref_layer_offset_present_flag[i]) {
pps->scaled_ref_layer_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
pps->scaled_ref_layer_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
pps->scaled_ref_layer_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
pps->scaled_ref_layer_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
}
pps->ref_region_offset_present_flag[i] = get_bits1(gb);
if (pps->ref_region_offset_present_flag[i]) {
pps->ref_region_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
pps->ref_region_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
pps->ref_region_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
pps->ref_region_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
}
pps->resample_phase_set_present_flag[i] = get_bits1(gb);
if (pps->resample_phase_set_present_flag[i]) {
pps->phase_hor_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_long(gb);
pps->phase_ver_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_long(gb);
pps->phase_hor_chroma_plus8[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_long(gb);
pps->phase_ver_chroma_plus8[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_long(gb);
}
}
pps->colour_mapping_enabled_flag = get_bits1(gb);
if (pps->colour_mapping_enabled_flag)
colour_mapping_table(gb, pps);
return 0;
}
static void delta_dlt(GetBitContext *gb, HEVCPPS *pps)
{
unsigned int num_val_delta_dlt, max_diff = 0;
int min_diff_minus1 = -1;
unsigned int len;
num_val_delta_dlt = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
if (num_val_delta_dlt) {
if (num_val_delta_dlt > 1)
max_diff = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
if (num_val_delta_dlt > 2 && max_diff) {
len = av_log2(max_diff) + 1;
min_diff_minus1 = get_bits(gb, len);
}
if (max_diff > (min_diff_minus1 + 1))
for (int k = 1; k < num_val_delta_dlt; k++) {
len = av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
skip_bits(gb, len); // delta_val_diff_minus_min
}
}
}
static int pps_3d_extension(GetBitContext *gb, AVCodecContext *avctx,
HEVCPPS *pps, HEVCSPS *sps)
{
unsigned int pps_depth_layers_minus1;
if (get_bits1(gb)) { // dlts_present_flag
pps_depth_layers_minus1 = get_bits(gb, 6);
pps->pps_bit_depth_for_depth_layers_minus8 = get_bits(gb, 4);
for (int i = 0; i <= pps_depth_layers_minus1; i++) {
if (get_bits1(gb)) { // dlt_flag[i]
if (!get_bits1(gb)) { // dlt_pred_flag[i]
if (get_bits1(gb)) { // dlt_val_flags_present_flag[i]
for (int j = 0; j <= ((1 << (pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
skip_bits1(gb); // dlt_value_flag[i][j]
} else
delta_dlt(gb, pps);
}
}
}
}
return 0;
}
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
HEVCPPS *pps, HEVCSPS *sps)
{
if (pps->transform_skip_enabled_flag) {
pps->log2_max_transform_skip_block_size = get_ue_golomb_long(gb) + 2;
}
@ -1282,7 +1488,7 @@ static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
"chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
return AVERROR_INVALIDDATA;
}
for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
for (int i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
if (pps->cb_qp_offset_list[i]) {
av_log(avctx, AV_LOG_WARNING,
@ -1306,6 +1512,47 @@ static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
return(0);
}
static int pps_scc_extension(GetBitContext *gb, AVCodecContext *avctx,
HEVCPPS *pps, HEVCSPS *sps)
{
int num_comps, ret;
pps->pps_curr_pic_ref_enabled_flag = get_bits1(gb);
if (pps->residual_adaptive_colour_transform_enabled_flag = get_bits1(gb)) {
pps->pps_slice_act_qp_offsets_present_flag = get_bits1(gb);
pps->pps_act_y_qp_offset = get_se_golomb_long(gb) - 5;
pps->pps_act_cb_qp_offset = get_se_golomb_long(gb) - 5;
pps->pps_act_cr_qp_offset = get_se_golomb_long(gb) - 3;
#define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
pps->pps_act_ ## name ## _qp_offset >= 12)
ret = CHECK_QP_OFFSET(y) || CHECK_QP_OFFSET(cb) || CHECK_QP_OFFSET(cr);
#undef CHECK_QP_OFFSET
if (ret) {
av_log(avctx, AV_LOG_ERROR,
"PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
return AVERROR_INVALIDDATA;
}
}
if (pps->pps_palette_predictor_initializers_present_flag = get_bits1(gb)) {
if ((pps->pps_num_palette_predictor_initializers = get_ue_golomb_long(gb)) > 0) {
pps->monochrome_palette_flag = get_bits1(gb);
pps->luma_bit_depth_entry_minus8 = get_ue_golomb_long(gb);
if (!pps->monochrome_palette_flag)
pps->chroma_bit_depth_entry_minus8 = get_ue_golomb_long(gb);
num_comps = pps->monochrome_palette_flag ? 1 : 3;
for (int comp = 0; comp < num_comps; comp++)
for (int i = 0; i < pps->pps_num_palette_predictor_initializers; i++)
pps->pps_palette_predictor_initializer[comp][i] =
get_bits(gb, 8 + (!comp ? pps->luma_bit_depth_entry_minus8 :
pps->chroma_bit_depth_entry_minus8));
}
}
return 0;
}
static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
HEVCPPS *pps, HEVCSPS *sps)
{
@ -1658,12 +1905,31 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
pps->slice_header_extension_present_flag = get_bits1(gb);
if (get_bits1(gb)) { // pps_extension_present_flag
pps->pps_range_extensions_flag = get_bits1(gb);
skip_bits(gb, 7); // pps_extension_7bits
if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps->pps_range_extensions_flag) {
pps->pps_range_extensions_flag = get_bits1(gb);
pps->pps_multilayer_extension_flag = get_bits1(gb);
pps->pps_3d_extension_flag = get_bits1(gb);
pps->pps_scc_extension_flag = get_bits1(gb);
skip_bits(gb, 4); // pps_extension_4bits
if (sps->ptl.general_ptl.profile_idc >= FF_PROFILE_HEVC_REXT && pps->pps_range_extensions_flag) {
if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
goto err;
}
if (pps->pps_multilayer_extension_flag) {
if ((ret = pps_multilayer_extension(gb, avctx, pps, sps)) < 0)
goto err;
}
if (pps->pps_3d_extension_flag) {
if ((ret = pps_3d_extension(gb, avctx, pps, sps)) < 0)
goto err;
}
if (pps->pps_scc_extension_flag) {
if ((ret = pps_scc_extension(gb, avctx, pps, sps)) < 0)
goto err;
}
}
ret = setup_pps(avctx, gb, pps, sps);
@ -1671,9 +1937,8 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
goto err;
if (get_bits_left(gb) < 0) {
av_log(avctx, AV_LOG_ERROR,
av_log(avctx, AV_LOG_WARNING,
"Overread PPS by %d bits\n", -get_bits_left(gb));
goto err;
}
remove_pps(ps, pps_id);

69
libavcodec/hevc_ps.h
Unescape View File

@ -210,6 +210,20 @@ typedef struct HEVCSPS {
int persistent_rice_adaptation_enabled_flag;
int cabac_bypass_alignment_enabled_flag;
int sps_multilayer_extension_flag;
int sps_3d_extension_flag;
int sps_scc_extension_flag;
int sps_curr_pic_ref_enabled_flag;
int palette_mode_enabled_flag;
int palette_max_size;
int delta_palette_max_predictor_size;
int sps_palette_predictor_initializers_present_flag;
int sps_num_palette_predictor_initializers_minus1;
int sps_palette_predictor_initializer[3][HEVC_MAX_PALETTE_PREDICTOR_SIZE];
int motion_vector_resolution_control_idc;
int intra_boundary_filtering_disabled_flag;
///< coded frame dimension in various units
int width;
int height;
@ -284,6 +298,9 @@ typedef struct HEVCPPS {
uint8_t slice_header_extension_present_flag;
uint8_t log2_max_transform_skip_block_size;
uint8_t pps_range_extensions_flag;
uint8_t pps_multilayer_extension_flag;
uint8_t pps_3d_extension_flag;
uint8_t pps_scc_extension_flag;
uint8_t cross_component_prediction_enabled_flag;
uint8_t chroma_qp_offset_list_enabled_flag;
uint8_t diff_cu_chroma_qp_offset_depth;
@ -293,6 +310,58 @@ typedef struct HEVCPPS {
uint8_t log2_sao_offset_scale_luma;
uint8_t log2_sao_offset_scale_chroma;
// Multilayer extension parameters
uint8_t poc_reset_info_present_flag;
uint8_t pps_infer_scaling_list_flag;
uint8_t pps_scaling_list_ref_layer_id;
uint16_t num_ref_loc_offsets;
uint8_t ref_loc_offset_layer_id[64];
uint8_t scaled_ref_layer_offset_present_flag[64];
int8_t scaled_ref_layer_left_offset[64];
int8_t scaled_ref_layer_top_offset[64];
int8_t scaled_ref_layer_right_offset[64];
int8_t scaled_ref_layer_bottom_offset[64];
uint8_t ref_region_offset_present_flag[64];
int8_t ref_region_left_offset[64];
int8_t ref_region_top_offset[64];
int8_t ref_region_right_offset[64];
int8_t ref_region_bottom_offset[64];
uint8_t resample_phase_set_present_flag[64];
uint16_t phase_hor_luma[64];
uint16_t phase_ver_luma[64];
uint16_t phase_hor_chroma_plus8[64];
uint16_t phase_ver_chroma_plus8[64];
uint8_t colour_mapping_enabled_flag;
uint16_t num_cm_ref_layers_minus1;
uint8_t cm_ref_layer_id[63];
uint8_t cm_octant_depth;
uint8_t cm_y_part_num_log2;
uint16_t luma_bit_depth_cm_input_minus8;
uint16_t chroma_bit_depth_cm_input_minus8;
uint16_t luma_bit_depth_cm_output_minus8;
uint16_t chroma_bit_depth_cm_output_minus8;
uint8_t cm_res_quant_bits;
uint8_t cm_delta_flc_bits_minus1;
int8_t cm_adapt_threshold_u_delta;
int8_t cm_adapt_threshold_v_delta;
// 3D extension parameters
uint8_t pps_bit_depth_for_depth_layers_minus8;
// SCC extension parameters
uint8_t pps_curr_pic_ref_enabled_flag;
uint8_t residual_adaptive_colour_transform_enabled_flag;
uint8_t pps_slice_act_qp_offsets_present_flag;
int8_t pps_act_y_qp_offset; // _plus5
int8_t pps_act_cb_qp_offset; // _plus5
int8_t pps_act_cr_qp_offset; // _plus3
uint8_t pps_palette_predictor_initializers_present_flag;
uint8_t pps_num_palette_predictor_initializers;
uint8_t monochrome_palette_flag;
uint8_t luma_bit_depth_entry_minus8;
uint8_t chroma_bit_depth_entry_minus8;
uint8_t pps_palette_predictor_initializer[3][HEVC_MAX_PALETTE_PREDICTOR_SIZE];
// Inferred parameters
unsigned int *column_width; ///< ColumnWidth
unsigned int *row_height; ///< RowHeight

Write Preview
Loading…
Cancel
Save