ffmpeg | branch: master | James Almer <[email protected]> | Sun Jul 14 09:48:25 2024 -0300| [64807ccc919194d0c08aa69c14f86085505594ff] | committer: James Almer
avcodec/cbs_h265: add support for PPS Multilayer extension fields Signed-off-by: James Almer <[email protected]> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=64807ccc919194d0c08aa69c14f86085505594ff --- libavcodec/cbs_h265.h | 40 +++++++++ libavcodec/cbs_h265_syntax_template.c | 163 +++++++++++++++++++++++++++++++++- 2 files changed, 202 insertions(+), 1 deletion(-) diff --git a/libavcodec/cbs_h265.h b/libavcodec/cbs_h265.h index 0f0541b2ef..586864f6bb 100644 --- a/libavcodec/cbs_h265.h +++ b/libavcodec/cbs_h265.h @@ -442,6 +442,46 @@ typedef struct H265RawPPS { uint8_t luma_bit_depth_entry_minus8; uint8_t chroma_bit_depth_entry_minus8; uint16_t pps_palette_predictor_initializers[3][128]; + + // Multilayer extension. + uint8_t poc_reset_info_present_flag; + uint8_t pps_infer_scaling_list_flag; + uint8_t pps_scaling_list_ref_layer_id; + uint8_t num_ref_loc_offsets; + uint8_t ref_loc_offset_layer_id[64]; + uint8_t scaled_ref_layer_offset_present_flag[64]; + int16_t scaled_ref_layer_left_offset[64]; + int16_t scaled_ref_layer_top_offset[64]; + int16_t scaled_ref_layer_right_offset[64]; + int16_t scaled_ref_layer_bottom_offset[64]; + uint8_t ref_region_offset_present_flag[64]; + int16_t ref_region_left_offset[64]; + int16_t ref_region_top_offset[64]; + int16_t ref_region_right_offset[64]; + int16_t ref_region_bottom_offset[64]; + uint8_t resample_phase_set_present_flag[64]; + uint8_t phase_hor_luma[64]; + uint8_t phase_ver_luma[64]; + uint8_t phase_hor_chroma_plus8[64]; + uint8_t phase_ver_chroma_plus8[64]; + uint8_t colour_mapping_enabled_flag; + uint8_t num_cm_ref_layers_minus1; + uint8_t cm_ref_layer_id[62]; + uint8_t cm_octant_depth; + uint8_t cm_y_part_num_log2; + uint8_t luma_bit_depth_cm_input_minus8; + uint8_t chroma_bit_depth_cm_input_minus8; + uint8_t luma_bit_depth_cm_output_minus8; + uint8_t chroma_bit_depth_cm_output_minus8; + uint8_t cm_res_quant_bits; + uint8_t cm_delta_flc_bits_minus1; + int16_t cm_adapt_threshold_u_delta; + int16_t cm_adapt_threshold_v_delta; + uint8_t split_octant_flag[2]; + uint8_t coded_res_flag[12][2][2][4]; + uint8_t res_coeff_q[12][2][2][4][3]; + uint32_t res_coeff_s[12][2][2][4][3]; + uint8_t res_coeff_r[12][2][2][4][3]; } H265RawPPS; typedef struct H265RawAUD { diff --git a/libavcodec/cbs_h265_syntax_template.c b/libavcodec/cbs_h265_syntax_template.c index b9ca507a46..75eb361aff 100644 --- a/libavcodec/cbs_h265_syntax_template.c +++ b/libavcodec/cbs_h265_syntax_template.c @@ -1039,6 +1039,167 @@ static int FUNC(pps_range_extension)(CodedBitstreamContext *ctx, RWContext *rw, return 0; } +static int FUNC(colour_mapping_octants)(CodedBitstreamContext *ctx, RWContext *rw, + H265RawPPS *current, unsigned int inp_depth, + unsigned int idx_y, unsigned int idx_cb, + unsigned int idx_cr, unsigned int inp_length) +{ + int part_num_y, cm_res_bits; + int err; + + part_num_y = 1 << current->cm_y_part_num_log2; + + av_assert0(inp_depth <= 1); + if (inp_depth < current->cm_octant_depth) + flags(split_octant_flag[inp_depth], 1, inp_depth); + else + infer(split_octant_flag[inp_depth], 0); + + if (current->split_octant_flag[inp_depth]) + for (int k = 0; k < 2; k++) + for (int m = 0; m < 2; m++) + for (int n = 0; n < 2; n++) + CHECK(FUNC(colour_mapping_octants)(ctx, rw, current, 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++) { + int idx_shift_y = idx_y + (i << (current->cm_octant_depth - inp_depth)); + for (int j = 0; j < 4; j++) { + flags(coded_res_flag[idx_shift_y][idx_cb][idx_cr][j], + 4, idx_shift_y, idx_cb, idx_cr, j); + if (current->coded_res_flag[idx_shift_y][idx_cb][idx_cr][j]) { + for (int c = 0; c < 3; c++) { + ues(res_coeff_q[idx_shift_y][idx_cb][idx_cr][j][c], 0, 3, + 5, idx_shift_y, idx_cb, idx_cr, j, c); + cm_res_bits = FFMAX(0, 10 + (current->luma_bit_depth_cm_input_minus8 + 8) - + (current->luma_bit_depth_cm_output_minus8 + 8) - + current->cm_res_quant_bits - (current->cm_delta_flc_bits_minus1 + 1)); + if (cm_res_bits) + ubs(cm_res_bits, res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][c], + 5, idx_shift_y, idx_cb, idx_cr, j, c); + else + infer(res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][c], 0); + if (current->res_coeff_q[idx_shift_y][idx_cb][idx_cr][j][c] || + current->res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][c]) + ub(1, res_coeff_s[idx_shift_y][idx_cb][idx_cr][j][c]); + else + infer(res_coeff_s[idx_shift_y][idx_cb][idx_cr][j][c], 0); + } + } else { + for (int c = 0; c < 3; c++) { + infer(res_coeff_q[idx_shift_y][idx_cb][idx_cr][j][c], 0); + infer(res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][c], 0); + infer(res_coeff_s[idx_shift_y][idx_cb][idx_cr][j][c], 0); + } + } + } + } + + return 0; +} + +static int FUNC(colour_mapping_table)(CodedBitstreamContext *ctx, RWContext *rw, + H265RawPPS *current) +{ + int err; + + ue(num_cm_ref_layers_minus1, 0, 61); + for (int i = 0; i <= current->num_cm_ref_layers_minus1; i++) + ubs(6, cm_ref_layer_id[i], 1, i); + + u(2, cm_octant_depth, 0, 1); + u(2, cm_y_part_num_log2, 0, 3 - current->cm_octant_depth); + + ue(luma_bit_depth_cm_input_minus8, 0, 8); + ue(chroma_bit_depth_cm_input_minus8, 0, 8); + ue(luma_bit_depth_cm_output_minus8, 0, 8); + ue(chroma_bit_depth_cm_output_minus8, 0, 8); + + ub(2, cm_res_quant_bits); + ub(2, cm_delta_flc_bits_minus1); + + if (current->cm_octant_depth == 1) { + se(cm_adapt_threshold_u_delta, -32768, 32767); + se(cm_adapt_threshold_v_delta, -32768, 32767); + } else { + infer(cm_adapt_threshold_u_delta, 0); + infer(cm_adapt_threshold_v_delta, 0); + } + + CHECK(FUNC(colour_mapping_octants)(ctx, rw, current, 0, 0, 0, 0, 1 << current->cm_octant_depth)); + + return 0; +} + +static int FUNC(pps_multilayer_extension)(CodedBitstreamContext *ctx, RWContext *rw, + H265RawPPS *current) +{ + CodedBitstreamH265Context *h265 = ctx->priv_data; + const H265RawVPS *vps = h265->active_vps; + int offset; + int err, i; + + flag(poc_reset_info_present_flag); + flag(pps_infer_scaling_list_flag); + if (current->pps_infer_scaling_list_flag) + ub(6, pps_scaling_list_ref_layer_id); + + if (!vps) { + av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS missing for PPS Multilayer Extension.\n"); + return AVERROR_INVALIDDATA; + } + + ue(num_ref_loc_offsets, 0, vps->vps_max_layers_minus1); + for (i = 0; i < current->num_ref_loc_offsets; i++) { + ubs(6, ref_loc_offset_layer_id[i], 1, i); + offset = current->ref_loc_offset_layer_id[i]; + flags(scaled_ref_layer_offset_present_flag[i], 1, i); + if (current->scaled_ref_layer_offset_present_flag[i]) { + ses(scaled_ref_layer_left_offset[offset], -16384, 16383, 1, offset); + ses(scaled_ref_layer_top_offset[offset], -16384, 16383, 1, offset); + ses(scaled_ref_layer_right_offset[offset], -16384, 16383, 1, offset); + ses(scaled_ref_layer_bottom_offset[offset], -16384, 16383, 1, offset); + } else { + infer(scaled_ref_layer_left_offset[offset], 0); + infer(scaled_ref_layer_top_offset[offset], 0); + infer(scaled_ref_layer_right_offset[offset], 0); + infer(scaled_ref_layer_bottom_offset[offset], 0); + } + flags(ref_region_offset_present_flag[i], 1, i); + if (current->ref_region_offset_present_flag[i]) { + ses(ref_region_left_offset[offset], -16384, 16383, 1, offset); + ses(ref_region_top_offset[offset], -16384, 16383, 1, offset); + ses(ref_region_right_offset[offset], -16384, 16383, 1, offset); + ses(ref_region_bottom_offset[offset], -16384, 16383, 1, offset); + } else { + infer(ref_region_left_offset[offset], 0); + infer(ref_region_top_offset[offset], 0); + infer(ref_region_right_offset[offset], 0); + infer(ref_region_bottom_offset[offset], 0); + } + flags(resample_phase_set_present_flag[i], 1, i); + if (current->resample_phase_set_present_flag[i]) { + ues(phase_hor_luma[offset], 0, 31, 1, offset); + ues(phase_ver_luma[offset], 0, 31, 1, offset); + ues(phase_hor_chroma_plus8[offset], 0, 63, 1, offset); + ues(phase_ver_chroma_plus8[offset], 0, 63, 1, offset); + } else { + infer(phase_hor_luma[offset], 0); + infer(phase_ver_luma[offset], 0); + infer(phase_hor_chroma_plus8[offset], 8); + } + } + + flag(colour_mapping_enabled_flag); + if (current->colour_mapping_enabled_flag) + CHECK(FUNC(colour_mapping_table)(ctx, rw, current)); + + return 0; +} + static int FUNC(pps_scc_extension)(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current) { @@ -1189,7 +1350,7 @@ static int FUNC(pps)(CodedBitstreamContext *ctx, RWContext *rw, if (current->pps_range_extension_flag) CHECK(FUNC(pps_range_extension)(ctx, rw, current)); if (current->pps_multilayer_extension_flag) - return AVERROR_PATCHWELCOME; + CHECK(FUNC(pps_multilayer_extension)(ctx, rw, current)); if (current->pps_3d_extension_flag) return AVERROR_PATCHWELCOME; if (current->pps_scc_extension_flag) _______________________________________________ ffmpeg-cvslog mailing list [email protected] https://ffmpeg.org/mailman/listinfo/ffmpeg-cvslog To unsubscribe, visit link above, or email [email protected] with subject "unsubscribe".
