@@ -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,
};
@@ -910,7 +910,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
@@ -1131,8 +1131,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);
@@ -1158,6 +1162,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;
@@ -1322,8 +1377,170 @@ static void hevc_pps_free(void *opaque, uint8_t *data)
av_freep(&pps);
}
+static void colour_mapping_octants(GetBitContext *gb, HEVCPPS *pps, int inp_depth,
+ int idx_y, int idx_cb, int idx_cr, int inp_length)
+{
+ uint8_t split_octant_flag, coded_res_flag;
+ uint16_t part_num_y, res_coeff_q, res_coeff_r;
+ int bit_depth_cm_input_y, bit_depth_cm_output_y, cm_res_bits;
+ int k, m, n, c, i, j;
+
+ part_num_y = 1 << pps->cm_y_part_num_log2;
+
+ if (inp_depth < pps->cm_octant_depth)
+ split_octant_flag = get_bits1(gb);
+
+ if (split_octant_flag)
+ for (k = 0; k < 2; k++)
+ for (m = 0; m < 2; m++)
+ for (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 (i = 0; i < part_num_y; i++) {
+ for (j = 0; j < 4; j++) {
+ coded_res_flag = get_bits1(gb);
+ if (coded_res_flag)
+ for (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 = get_bits(gb, cm_res_bits);
+ if (res_coeff_q || res_coeff_r)
+ skip_bits1(gb);
+ }
+ }
+ }
+}
+
+static void colour_mapping_table(GetBitContext *gb, HEVCPPS *pps)
+{
+ int i;
+
+ pps->num_cm_ref_layers_minus1 = get_ue_golomb_long(gb);
+ for (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)
+{
+ int i;
+
+ 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 (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)
+{
+ uint8_t num_val_delta_dlt, max_diff = 0;
+ int min_diff_minus1 = -1;
+ unsigned int len;
+ int k;
+
+ 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 (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)
+{
+ uint8_t pps_depth_layers_minus1;
+ int i, j;
+
+ 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 (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 (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) {
+ HEVCPPS *pps, HEVCSPS *sps)
+{
int i;
if (pps->transform_skip_enabled_flag) {
@@ -1363,6 +1580,48 @@ 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;
+ int i, 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 (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)
{
@@ -1715,12 +1974,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
+ 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 (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);
@@ -1728,9 +2006,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);
@@ -223,6 +223,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;
@@ -297,6 +311,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;
@@ -306,6 +323,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