diff options
Diffstat (limited to 'libavcodec')
| -rw-r--r-- | libavcodec/hevc.c | 245 | ||||
| -rw-r--r-- | libavcodec/hevc.h | 25 | ||||
| -rw-r--r-- | libavcodec/hevc_cabac.c | 80 | ||||
| -rw-r--r-- | libavcodec/hevc_filter.c | 20 | ||||
| -rw-r--r-- | libavcodec/hevc_ps.c | 126 |
5 files changed, 226 insertions, 270 deletions
diff --git a/libavcodec/hevc.c b/libavcodec/hevc.c index d59b4e48fe..ad82012e1b 100644 --- a/libavcodec/hevc.c +++ b/libavcodec/hevc.c @@ -318,7 +318,7 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb) uint8_t luma_weight_l1_flag[16]; uint8_t chroma_weight_l1_flag[16]; - s->sh.luma_log2_weight_denom = get_ue_golomb(gb); + s->sh.luma_log2_weight_denom = get_ue_golomb_long(gb); if (s->sps->chroma_format_idc != 0) { int delta = get_se_golomb(gb); s->sh.chroma_log2_weight_denom = av_clip_c(s->sh.luma_log2_weight_denom + delta, 0, 7); @@ -415,8 +415,8 @@ static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb) return 0; if (sps->num_long_term_ref_pics_sps > 0) - nb_sps = get_ue_golomb(gb); - nb_sh = get_ue_golomb(gb); + nb_sps = get_ue_golomb_long(gb); + nb_sh = get_ue_golomb_long(gb); if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc)) return AVERROR_INVALIDDATA; @@ -441,7 +441,7 @@ static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb) delta_poc_msb_present = get_bits1(gb); if (delta_poc_msb_present) { - int delta = get_ue_golomb(gb); + int delta = get_ue_golomb_long(gb); if (i && i != nb_sps) delta += prev_delta_msb; @@ -471,7 +471,7 @@ static int hls_slice_header(HEVCContext *s) if (s->nal_unit_type >= 16 && s->nal_unit_type <= 23) sh->no_output_of_prior_pics_flag = get_bits1(gb); - sh->pps_id = get_ue_golomb(gb); + sh->pps_id = get_ue_golomb_long(gb); if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) { av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id); return AVERROR_INVALIDDATA; @@ -552,7 +552,7 @@ static int hls_slice_header(HEVCContext *s) for (i = 0; i < s->pps->num_extra_slice_header_bits; i++) skip_bits(gb, 1); // slice_reserved_undetermined_flag[] - sh->slice_type = get_ue_golomb(gb); + sh->slice_type = get_ue_golomb_long(gb); if (!(sh->slice_type == I_SLICE || sh->slice_type == P_SLICE || sh->slice_type == B_SLICE)) { av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n", @@ -646,9 +646,9 @@ static int hls_slice_header(HEVCContext *s) sh->nb_refs[L1] = s->pps->num_ref_idx_l1_default_active; if (get_bits1(gb)) { // num_ref_idx_active_override_flag - sh->nb_refs[L0] = get_ue_golomb(gb) + 1; + sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1; if (sh->slice_type == B_SLICE) - sh->nb_refs[L1] = get_ue_golomb(gb) + 1; + sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1; } if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) { av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n", @@ -694,7 +694,7 @@ static int hls_slice_header(HEVCContext *s) sh->collocated_list = !get_bits1(gb); if (sh->nb_refs[sh->collocated_list] > 1) { - sh->collocated_ref_idx = get_ue_golomb(gb); + sh->collocated_ref_idx = get_ue_golomb_long(gb); if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) { av_log(s->avctx, AV_LOG_ERROR, "Invalid collocated_ref_idx: %d.\n", sh->collocated_ref_idx); @@ -708,7 +708,7 @@ static int hls_slice_header(HEVCContext *s) pred_weight_table(s, gb); } - sh->max_num_merge_cand = 5 - get_ue_golomb(gb); + sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb); } sh->slice_qp_delta = get_se_golomb(gb); @@ -759,9 +759,9 @@ static int hls_slice_header(HEVCContext *s) sh->num_entry_point_offsets = 0; if (s->pps->tiles_enabled_flag || s->pps->entropy_coding_sync_enabled_flag) { - sh->num_entry_point_offsets = get_ue_golomb(gb); + sh->num_entry_point_offsets = get_ue_golomb_long(gb); if (sh->num_entry_point_offsets > 0) { - int offset_len = get_ue_golomb(gb) + 1; + int offset_len = get_ue_golomb_long(gb) + 1; for (i = 0; i < sh->num_entry_point_offsets; i++) skip_bits(gb, offset_len); @@ -769,7 +769,7 @@ static int hls_slice_header(HEVCContext *s) } if (s->pps->slice_header_extension_present_flag) { - int length = get_ue_golomb(gb); + int length = get_ue_golomb_long(gb); for (i = 0; i < length; i++) skip_bits(gb, 8); // slice_header_extension_data_byte } @@ -889,6 +889,8 @@ static void hls_residual_coding(HEVCContext *s, int x0, int y0, int last_scan_pos; int n_end; int num_coeff = 0; + int greater1_ctx = 1; + int num_last_subset; int x_cg_last_sig, y_cg_last_sig; @@ -899,7 +901,8 @@ static void hls_residual_coding(HEVCContext *s, int x0, int y0, int vshift = s->sps->vshift[c_idx]; uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride + ((x0 >> hshift) << s->sps->pixel_shift)]; - DECLARE_ALIGNED( 16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE] ) = {0}; + DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = {0}; + DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = {{0}}; int trafo_size = 1 << log2_trafo_size; int i; @@ -911,6 +914,17 @@ static void hls_residual_coding(HEVCContext *s, int x0, int y0, // Derive QP for dequant if (!lc->cu.cu_transquant_bypass_flag) { static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 }; + static const uint8_t rem6[51 + 2 * 6 + 1] = { + 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, + 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, + 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, + }; + + static const uint8_t div6[51 + 2 * 6 + 1] = { + 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, + 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, + 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, + }; int qp_y = lc->qp_y; if (c_idx == 0) { @@ -936,7 +950,7 @@ static void hls_residual_coding(HEVCContext *s, int x0, int y0, shift = s->sps->bit_depth + log2_trafo_size - 5; add = 1 << (shift-1); - scale = level_scale[qp%6] << (qp/6); + scale = level_scale[rem6[qp]] << (div6[qp]); scale_m = 16; // default when no custom scaling lists. dc_scale = 16; @@ -954,8 +968,6 @@ static void hls_residual_coding(HEVCContext *s, int x0, int y0, } } - memset(lc->rc.significant_coeff_group_flag, 0, 8 * 8); - if (s->pps->transform_skip_enabled_flag && !lc->cu.cu_transquant_bypass_flag && log2_trafo_size == 2) { transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx); @@ -1028,38 +1040,34 @@ static void hls_residual_coding(HEVCContext *s, int x0, int y0, break; } num_coeff++; - num_last_subset = (num_coeff - 1) >> 4; for (i = num_last_subset; i >= 0; i--) { int n, m; - int first_nz_pos_in_cg, last_nz_pos_in_cg, num_sig_coeff, first_greater1_coeff_idx; - int sign_hidden; - int sum_abs; int x_cg, y_cg, x_c, y_c, pos; int implicit_non_zero_coeff = 0; int64_t trans_coeff_level; - + int prev_sig = 0; int offset = i << 4; - uint8_t significant_coeff_flag_idx[16] = {0}; - uint8_t coeff_abs_level_greater1_flag[16] = {0}; - uint8_t coeff_abs_level_greater2_flag[16] = {0}; - uint16_t coeff_sign_flag; + uint8_t significant_coeff_flag_idx[16]; uint8_t nb_significant_coeff_flag = 0; - int first_elem; - x_cg = scan_x_cg[i]; y_cg = scan_y_cg[i]; if ((i < num_last_subset) && (i > 0)) { - lc->rc.significant_coeff_group_flag[x_cg][y_cg] = - ff_hevc_significant_coeff_group_flag_decode(s, c_idx, x_cg, y_cg, - log2_trafo_size); + int ctx_cg = 0; + if (x_cg < (1 << (log2_trafo_size - 2)) - 1) + ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg]; + if (y_cg < (1 << (log2_trafo_size - 2)) - 1) + ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1]; + + significant_coeff_group_flag[x_cg][y_cg] = + ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg); implicit_non_zero_coeff = 1; } else { - lc->rc.significant_coeff_group_flag[x_cg][y_cg] = + significant_coeff_group_flag[x_cg][y_cg] = ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) || (x_cg == 0 && y_cg == 0)); } @@ -1073,107 +1081,126 @@ static void hls_residual_coding(HEVCContext *s, int x0, int y0, } else { n_end = 15; } + + if (x_cg < ((1 << log2_trafo_size) - 1) >> 2) + prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg]; + if (y_cg < ((1 << log2_trafo_size) - 1) >> 2) + prev_sig += (significant_coeff_group_flag[x_cg][y_cg + 1] << 1); + for (n = n_end; n >= 0; n--) { GET_COORD(offset, n); - if (lc->rc.significant_coeff_group_flag[x_cg][y_cg] && + if (significant_coeff_group_flag[x_cg][y_cg] && (n > 0 || implicit_non_zero_coeff == 0)) { - if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c, log2_trafo_size, scan_idx) == 1) { + if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c, log2_trafo_size, scan_idx, prev_sig) == 1) { significant_coeff_flag_idx[nb_significant_coeff_flag] = n; - nb_significant_coeff_flag = nb_significant_coeff_flag + 1; + nb_significant_coeff_flag++; implicit_non_zero_coeff = 0; } } else { int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2)); - if (last_cg && implicit_non_zero_coeff && lc->rc.significant_coeff_group_flag[x_cg][y_cg]) { + if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) { significant_coeff_flag_idx[nb_significant_coeff_flag] = n; - nb_significant_coeff_flag = nb_significant_coeff_flag + 1; + nb_significant_coeff_flag++; } } } n_end = nb_significant_coeff_flag; - first_nz_pos_in_cg = 16; - last_nz_pos_in_cg = -1; - num_sig_coeff = 0; - first_greater1_coeff_idx = -1; - for (m = 0; m < n_end; m++) { - n = significant_coeff_flag_idx[m]; - if (num_sig_coeff < 8) { - coeff_abs_level_greater1_flag[n] = - ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, i, n, - (num_sig_coeff == 0), - (i == num_last_subset)); - num_sig_coeff++; - if (coeff_abs_level_greater1_flag[n] && + + if (n_end) { + int first_nz_pos_in_cg = 16; + int last_nz_pos_in_cg = -1; + int c_rice_param = 0; + int first_greater1_coeff_idx = -1; + uint8_t coeff_abs_level_greater1_flag[16] = {0}; + uint16_t coeff_sign_flag; + int sum_abs = 0; + int sign_hidden = 0; + + // initialize first elem of coeff_bas_level_greater1_flag + int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0; + + if (!(i == num_last_subset) && greater1_ctx == 0) + ctx_set++; + greater1_ctx = 1; + last_nz_pos_in_cg = significant_coeff_flag_idx[0]; + + for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) { + int n_idx = significant_coeff_flag_idx[m]; + int inc = (ctx_set << 2) + greater1_ctx; + coeff_abs_level_greater1_flag[n_idx] = + ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc); + if (coeff_abs_level_greater1_flag[n_idx]) { + greater1_ctx = 0; + } else if (greater1_ctx > 0 && greater1_ctx < 3) { + greater1_ctx++; + } + + if (coeff_abs_level_greater1_flag[n_idx] && first_greater1_coeff_idx == -1) - first_greater1_coeff_idx = n; + first_greater1_coeff_idx = n_idx; } - if (last_nz_pos_in_cg == -1) - last_nz_pos_in_cg = n; - first_nz_pos_in_cg = n; - } - - sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 && - !lc->cu.cu_transquant_bypass_flag); - if (first_greater1_coeff_idx != -1) { - coeff_abs_level_greater2_flag[first_greater1_coeff_idx] = - ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, i, first_greater1_coeff_idx); - } - if (!s->pps->sign_data_hiding_flag || !sign_hidden ) { - coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag); - } else { - coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag-1) << (16 - (nb_significant_coeff_flag - 1)); - } + first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1]; + sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 && + !lc->cu.cu_transquant_bypass_flag); - num_sig_coeff = 0; - sum_abs = 0; - first_elem = 1; - for (m = 0; m < n_end; m++) { - n = significant_coeff_flag_idx[m]; - GET_COORD(offset, n); - trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n] + - coeff_abs_level_greater2_flag[n]; - if (trans_coeff_level == ((num_sig_coeff < 8) ? - ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) { - trans_coeff_level += ff_hevc_coeff_abs_level_remaining(s, first_elem, trans_coeff_level); - first_elem = 0; + if (first_greater1_coeff_idx != -1) { + coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set); } - if (s->pps->sign_data_hiding_flag && sign_hidden) { - sum_abs += trans_coeff_level; - if (n == first_nz_pos_in_cg && ((sum_abs&1) == 1)) - trans_coeff_level = -trans_coeff_level; + if (!s->pps->sign_data_hiding_flag || !sign_hidden ) { + coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag); + } else { + coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1)); } - if (coeff_sign_flag >> 15) - trans_coeff_level = -trans_coeff_level; - coeff_sign_flag <<= 1; - num_sig_coeff++; - - if (!lc->cu.cu_transquant_bypass_flag) { - if(s->sps->scaling_list_enable_flag) { - if(y_c || x_c || log2_trafo_size < 4) { - switch(log2_trafo_size) { - case 3: pos = (y_c << 3) + x_c; break; - case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break; - case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break; - default: pos = (y_c << 2) + x_c; - } - scale_m = scale_matrix[pos]; - } else - scale_m = dc_scale; + + for (m = 0; m < n_end; m++) { + n = significant_coeff_flag_idx[m]; + GET_COORD(offset, n); + trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n]; + if (trans_coeff_level == ((m < 8) ? + ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) { + int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param); + + trans_coeff_level += last_coeff_abs_level_remaining; + if ((trans_coeff_level) > (3 * (1 << c_rice_param))) + c_rice_param = FFMIN(c_rice_param + 1, 4); + } - trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift; - if (trans_coeff_level < 0) { - if((~trans_coeff_level) & 0xFffffffffff8000) - trans_coeff_level = -32768; - } else { - if(trans_coeff_level & 0xffffffffffff8000) - trans_coeff_level = 32767; + if (s->pps->sign_data_hiding_flag && sign_hidden) { + sum_abs += trans_coeff_level; + if (n == first_nz_pos_in_cg && ((sum_abs&1) == 1)) + trans_coeff_level = -trans_coeff_level; } + if (coeff_sign_flag >> 15) + trans_coeff_level = -trans_coeff_level; + coeff_sign_flag <<= 1; + if(!lc->cu.cu_transquant_bypass_flag) { + if(s->sps->scaling_list_enable_flag) { + if(y_c || x_c || log2_trafo_size < 4) { + switch(log2_trafo_size) { + case 3: pos = (y_c << 3) + x_c; break; + case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break; + case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break; + default: pos = (y_c << 2) + x_c; + } + scale_m = scale_matrix[pos]; + } else { + scale_m = dc_scale; + } + } + trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift; + if(trans_coeff_level < 0) { + if((~trans_coeff_level) & 0xFffffffffff8000) + trans_coeff_level = -32768; + } else { + if(trans_coeff_level & 0xffffffffffff8000) + trans_coeff_level = 32767; + } + } + coeffs[y_c * trafo_size + x_c] = trans_coeff_level; } - - coeffs[y_c * trafo_size + x_c] = trans_coeff_level; } } diff --git a/libavcodec/hevc.h b/libavcodec/hevc.h index 1aaf584260..9e91c3b59d 100644 --- a/libavcodec/hevc.h +++ b/libavcodec/hevc.h @@ -653,10 +653,6 @@ typedef struct TransformUnit { int cur_intra_pred_mode; } TransformUnit; -typedef struct ResidualCoding { - uint8_t significant_coeff_group_flag[8][8]; -} ResidualCoding; - typedef struct SAOParams { uint8_t type_idx[3]; ///< sao_type_idx @@ -726,16 +722,10 @@ typedef struct HEVCNAL { typedef struct HEVCLocalContext { uint8_t cabac_state[HEVC_CONTEXTS]; - int ctx_set; - int greater1_ctx; - int last_coeff_abs_level_greater1_flag; - int c_rice_param; - int last_coeff_abs_level_remaining; GetBitContext gb; CABACContext cc; TransformTree tt; TransformUnit tu; - ResidualCoding rc; uint8_t first_qp_group; int8_t qp_y; int8_t curr_qp_y; @@ -935,17 +925,12 @@ int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx, int log2_size); int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s, int last_significant_coeff_prefix); -int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int x_cg, - int y_cg, int log2_trafo_size); +int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg); int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c, - int log2_trafo_size, int scan_idx); -int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, - int i, int n, - int first_greater1_coeff_idx, - int first_subset); -int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, - int i, int n); -int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int n, int base_level); + int log2_trafo_size, int scan_idx, int prev_sig); +int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int ctx_set); +int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc); +int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param); int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb); /** diff --git a/libavcodec/hevc_cabac.c b/libavcodec/hevc_cabac.c index 8468d560b9..ef3a94bc3e 100644 --- a/libavcodec/hevc_cabac.c +++ b/libavcodec/hevc_cabac.c @@ -764,24 +764,17 @@ int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s, return value; } -int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int x_cg, - int y_cg, int log2_trafo_size) +int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg) { - int ctx_cg = 0; int inc; - if (x_cg < (1 << (log2_trafo_size - 2)) - 1) - ctx_cg += s->HEVClc.rc.significant_coeff_group_flag[x_cg + 1][y_cg]; - if (y_cg < (1 << (log2_trafo_size - 2)) - 1) - ctx_cg += s->HEVClc.rc.significant_coeff_group_flag[x_cg][y_cg + 1]; - inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0); return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc); } int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c, - int log2_trafo_size, int scan_idx) + int log2_trafo_size, int scan_idx, int prev_sig) { static const uint8_t ctx_idx_map[] = { 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8 @@ -796,13 +789,6 @@ int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, in } else if (log2_trafo_size == 2) { sig_ctx = ctx_idx_map[(y_c << 2) + x_c]; } else { - int prev_sig = 0; - - if (x_cg < ((1 << log2_trafo_size) - 1) >> 2) - prev_sig += s->HEVClc.rc.significant_coeff_group_flag[x_cg + 1][y_cg]; - if (y_cg < ((1 << log2_trafo_size) - 1) >> 2) - prev_sig += (s->HEVClc.rc.significant_coeff_group_flag[x_cg][y_cg + 1] << 1); - switch (prev_sig) { case 0: { int x_off = x_c & 3; @@ -839,82 +825,46 @@ int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, in return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc); } -int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, - int i, int n, - int first_elem, - int first_subset) +int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc) { - int inc; - - if (first_elem) { - s->HEVClc.ctx_set = (i > 0 && c_idx == 0) ? 2 : 0; - - if (!first_subset && s->HEVClc.greater1_ctx == 0) - s->HEVClc.ctx_set++; - s->HEVClc.greater1_ctx = 1; - } - - inc = (s->HEVClc.ctx_set << 2) + s->HEVClc.greater1_ctx; if (c_idx > 0) inc += 16; - s->HEVClc.last_coeff_abs_level_greater1_flag = - GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc); - - if (s->HEVClc.last_coeff_abs_level_greater1_flag) { - s->HEVClc.greater1_ctx = 0; - } else if (s->HEVClc.greater1_ctx > 0 && s->HEVClc.greater1_ctx < 3) { - s->HEVClc.greater1_ctx++; - } - - return s->HEVClc.last_coeff_abs_level_greater1_flag; + return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc); } -int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, - int i, int n) +int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc) { - int inc; - - inc = s->HEVClc.ctx_set; if (c_idx > 0) inc += 4; return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc); } -int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int first_elem, int base_level) +int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param) { - int i; - HEVCLocalContext *lc = &s->HEVClc; int prefix = 0; int suffix = 0; - - if (first_elem) { - lc->c_rice_param = 0; - lc->last_coeff_abs_level_remaining = 0; - } + int last_coeff_abs_level_remaining; + int i; while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) prefix++; if (prefix == CABAC_MAX_BIN) av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix); if (prefix < 3) { - for (i = 0; i < lc->c_rice_param; i++) + for (i = 0; i < rc_rice_param; i++) suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc); - lc->last_coeff_abs_level_remaining = (prefix << lc->c_rice_param) + suffix; + last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix; } else { - for (i = 0; i < prefix - 3 + lc->c_rice_param; i++) + int prefix_minus3 = prefix - 3; + for (i = 0; i < prefix_minus3 + rc_rice_param; i++) suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc); - lc->last_coeff_abs_level_remaining = (((1 << (prefix - 3)) + 3 - 1) - << lc->c_rice_param) + suffix; + last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1) + << rc_rice_param) + suffix; } - - lc->c_rice_param = FFMIN(lc->c_rice_param + - ((base_level + lc->last_coeff_abs_level_remaining) > - (3 * (1 << lc->c_rice_param))), 4); - - return lc->last_coeff_abs_level_remaining; + return last_coeff_abs_level_remaining; } int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb) diff --git a/libavcodec/hevc_filter.c b/libavcodec/hevc_filter.c index 85189a87f6..ea83795975 100644 --- a/libavcodec/hevc_filter.c +++ b/libavcodec/hevc_filter.c @@ -182,7 +182,7 @@ static void copy_CTB(uint8_t *dst, uint8_t *src, int width, int height, int stri #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)]) -static void sao_filter_CTB(HEVCContext *s, int x, int y, int c_idx_min, int c_idx_max) +static void sao_filter_CTB(HEVCContext *s, int x, int y) { // TODO: This should be easily parallelizable // TODO: skip CBs when (cu_transquant_bypass_flag || (pcm_loop_filter_disable_flag && pcm_flag)) @@ -283,8 +283,8 @@ static void sao_filter_CTB(HEVCContext *s, int x, int y, int c_idx_min, int c_id (edges[2] ? width + (x_shift >> chroma) : width) << s->sps->pixel_shift, (edges[3] ? height + (y_shift >> chroma) : height), stride); - for (class_index = 0; class_index < class && c_idx >= c_idx_min && - c_idx < c_idx_max; class_index++) { + for (class_index = 0; class_index < class; class_index++) { + switch (sao[class_index]->type_idx[c_idx]) { case SAO_BAND: s->hevcdsp.sao_band_filter[classes[class_index]](dst, src, stride, sao[class_index], edges, width, height, c_idx); @@ -334,11 +334,8 @@ static void deblocking_filter_CTB(HEVCContext *s, int x0, int y0) int pcmf = (s->sps->pcm_enabled_flag && s->sps->pcm.loop_filter_disable_flag) || s->pps->transquant_bypass_enable_flag; - if (s->deblock[ctb].disable) - return; - - if (x0) { - left_tc_offset = s->deblock[ctb-1].tc_offset; + if(x0) { + left_tc_offset = s->deblock[ctb-1].tc_offset; left_beta_offset = s->deblock[ctb-1].beta_offset; } @@ -649,7 +646,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, int l } // bs for TU internal vertical PU boundaries - if (log2_trafo_size > s->sps->log2_min_pu_size && !is_intra) + if (log2_trafo_size > log2_min_pu_size && !is_intra) for (j = 0; j < (1 << log2_trafo_size); j += 4) { int y_pu = (y0 + j) >> log2_min_pu_size; int y_tu = (y0 + j) >> log2_min_tu_size; @@ -665,7 +662,6 @@ void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, int l uint8_t curr_cbf_luma = s->cbf_luma[y_tu * pic_width_in_min_tu + xq_tu]; RefPicList* left_refPicList = ff_hevc_get_ref_list(s, s->ref, x0 + i - 1, y0 + j); - bs = boundary_strength(s, curr, curr_cbf_luma, left, left_cbf_luma, left_refPicList, 0); if (s->sh.disable_deblocking_filter_flag == 1) bs = 0; @@ -680,11 +676,9 @@ void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, int l void ff_hevc_hls_filter(HEVCContext *s, int x, int y) { - int c_idx_min = s->sh.slice_sample_adaptive_offset_flag[0] != 0 ? 0 : 1; - int c_idx_max = s->sh.slice_sample_adaptive_offset_flag[1] != 0 ? 3 : 1; deblocking_filter_CTB(s, x, y); if (s->sps->sao_enabled) - sao_filter_CTB(s, x, y, c_idx_min, c_idx_max); + sao_filter_CTB(s, x, y); } void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size) diff --git a/libavcodec/hevc_ps.c b/libavcodec/hevc_ps.c index 84d53ab9df..b9015ae025 100644 --- a/libavcodec/hevc_ps.c +++ b/libavcodec/hevc_ps.c @@ -92,7 +92,7 @@ int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, uint8_t delta_rps_sign; if (is_slice_header) { - int delta_idx = get_ue_golomb(gb) + 1; + int delta_idx = get_ue_golomb_long(gb) + 1; if (delta_idx > sps->nb_st_rps) { av_log(s->avctx, AV_LOG_ERROR, "Invalid value of delta_idx " "in slice header RPS: %d > %d.\n", delta_idx, @@ -104,7 +104,7 @@ int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, rps_ridx = &sps->st_rps[rps - sps->st_rps - 1]; delta_rps_sign = get_bits1(gb); - abs_delta_rps = get_ue_golomb(gb) + 1; + abs_delta_rps = get_ue_golomb_long(gb) + 1; delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps; for (i = 0; i <= rps_ridx->num_delta_pocs; i++) { int used = rps->used[k] = get_bits1(gb); @@ -161,8 +161,8 @@ int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, } } else { unsigned int prev, nb_positive_pics; - rps->num_negative_pics = get_ue_golomb(gb); - nb_positive_pics = get_ue_golomb(gb); + rps->num_negative_pics = get_ue_golomb_long(gb); + nb_positive_pics = get_ue_golomb_long(gb); if (rps->num_negative_pics >= MAX_REFS || nb_positive_pics >= MAX_REFS) { @@ -174,14 +174,14 @@ int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, if (rps->num_delta_pocs) { prev = 0; for (i = 0; i < rps->num_negative_pics; i++) { - delta_poc = get_ue_golomb(gb) + 1; + delta_poc = get_ue_golomb_long(gb) + 1; prev -= delta_poc; rps->delta_poc[i] = prev; rps->used[i] = get_bits1(gb); } prev = 0; for (i = 0; i < nb_positive_pics; i++) { - delta_poc = get_ue_golomb(gb) + 1; + delta_poc = get_ue_golomb_long(gb) + 1; prev += delta_poc; rps->delta_poc[rps->num_negative_pics + i] = prev; rps->used[rps->num_negative_pics + i] = get_bits1(gb); @@ -297,16 +297,16 @@ int ff_hevc_decode_nal_vps(HEVCContext *s) i = vps->vps_sub_layer_ordering_info_present_flag ? 0 : vps->vps_max_sub_layers - 1; for (; i < vps->vps_max_sub_layers; i++) { - vps->vps_max_dec_pic_buffering[i] = get_ue_golomb(gb); - vps->vps_num_reorder_pics[i] = get_ue_golomb(gb); - vps->vps_max_latency_increase[i] = get_ue_golomb(gb); + vps->vps_max_dec_pic_buffering[i] = get_ue_golomb_long(gb) + 1; + vps->vps_num_reorder_pics[i] = get_ue_golomb_long(gb); + vps->vps_max_latency_increase[i] = get_ue_golomb_long(gb) - 1; - if (vps->vps_max_dec_pic_buffering[i] >= MAX_DPB_SIZE) { + if (vps->vps_max_dec_pic_buffering[i] > MAX_DPB_SIZE) { av_log(s->avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n", vps->vps_max_dec_pic_buffering[i] - 1); goto err; } - if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i]) { + if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) { av_log(s->avctx, AV_LOG_ERROR, "vps_max_num_reorder_pics out of range: %d\n", vps->vps_num_reorder_pics[i]); goto err; @@ -314,7 +314,7 @@ int ff_hevc_decode_nal_vps(HEVCContext *s) } vps->vps_max_layer_id = get_bits(gb, 6); - vps->vps_num_layer_sets = get_ue_golomb(gb) + 1; + vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1; for (i = 1; i < vps->vps_num_layer_sets; i++) for (j = 0; j <= vps->vps_max_layer_id; j++) skip_bits(gb, 1); // layer_id_included_flag[i][j] @@ -325,8 +325,8 @@ int ff_hevc_decode_nal_vps(HEVCContext *s) vps->vps_time_scale = get_bits_long(gb, 32); vps->vps_poc_proportional_to_timing_flag = get_bits1(gb); if (vps->vps_poc_proportional_to_timing_flag) - vps->vps_num_ticks_poc_diff_one = get_ue_golomb(gb) + 1; - vps->vps_num_hrd_parameters = get_ue_golomb(gb); + vps->vps_num_ticks_poc_diff_one = get_ue_golomb_long(gb) + 1; + vps->vps_num_hrd_parameters = get_ue_golomb_long(gb); if (vps->vps_num_hrd_parameters != 0) { avpriv_report_missing_feature(s->avctx, "support for vps_num_hrd_parameters != 0"); av_free(vps); @@ -383,8 +383,8 @@ static void decode_vui(HEVCContext *s, HEVCSPS *sps) vui->chroma_loc_info_present_flag = get_bits1(gb); if (vui->chroma_loc_info_present_flag) { - vui->chroma_sample_loc_type_top_field = get_ue_golomb(gb); - vui->chroma_sample_loc_type_bottom_field = get_ue_golomb(gb); + vui->chroma_sample_loc_type_top_field = get_ue_golomb_long(gb); + vui->chroma_sample_loc_type_bottom_field = get_ue_golomb_long(gb); } vui->neutra_chroma_indication_flag = get_bits1(gb); @@ -394,10 +394,10 @@ static void decode_vui(HEVCContext *s, HEVCSPS *sps) vui->default_display_window_flag = get_bits1(gb); if (vui->default_display_window_flag) { //TODO: * 2 is only valid for 420 - vui->def_disp_win.left_offset = get_ue_golomb(gb) * 2; - vui->def_disp_win.right_offset = get_ue_golomb(gb) * 2; - vui->def_disp_win.top_offset = get_ue_golomb(gb) * 2; - vui->def_disp_win.bottom_offset = get_ue_golomb(gb) * 2; + vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * 2; + vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * 2; + vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * 2; + vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * 2; if (s->strict_def_disp_win && s->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) { @@ -422,7 +422,7 @@ static void decode_vui(HEVCContext *s, HEVCSPS *sps) vui->vui_time_scale = get_bits(gb, 32); vui->vui_poc_proportional_to_timing_flag = get_bits1(gb); if (vui->vui_poc_proportional_to_timing_flag) - vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb(gb); + vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(gb); vui->vui_hrd_parameters_present_flag = get_bits1(gb); if (vui->vui_hrd_parameters_present_flag) decode_hrd(s); @@ -433,11 +433,11 @@ static void decode_vui(HEVCContext *s, HEVCSPS *sps) vui->tiles_fixed_structure_flag = get_bits1(gb); vui->motion_vectors_over_pic_boundaries_flag = get_bits1(gb); vui->restricted_ref_pic_lists_flag = get_bits1(gb); - vui->min_spatial_segmentation_idc = get_ue_golomb(gb); - vui->max_bytes_per_pic_denom = get_ue_golomb(gb); - vui->max_bits_per_min_cu_denom = get_ue_golomb(gb); - vui->log2_max_mv_length_horizontal = get_ue_golomb(gb); - vui->log2_max_mv_length_vertical = get_ue_golomb(gb); + vui->min_spatial_segmentation_idc = get_ue_golomb_long(gb); + vui->max_bytes_per_pic_denom = get_ue_golomb_long(gb); + vui->max_bits_per_min_cu_denom = get_ue_golomb_long(gb); + vui->log2_max_mv_length_horizontal = get_ue_golomb_long(gb); + vui->log2_max_mv_length_vertical = get_ue_golomb_long(gb); } } @@ -478,7 +478,7 @@ static int scaling_list_data(HEVCContext *s, ScalingList *sl) for (matrix_id = 0; matrix_id < ((size_id == 3) ? 2 : 6); matrix_id++) { scaling_list_pred_mode_flag[size_id][matrix_id] = get_bits1(gb); if (!scaling_list_pred_mode_flag[size_id][matrix_id]) { - delta = get_ue_golomb(gb); + delta = get_ue_golomb_long(gb); // Only need to handle non-zero delta. Zero means default, which should already be in the arrays. if (delta) { // Copy from previous array. @@ -564,14 +564,14 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) ret = AVERROR_INVALIDDATA; goto err; } - sps_id = get_ue_golomb(gb); + sps_id = get_ue_golomb_long(gb); if (sps_id >= MAX_SPS_COUNT) { av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id); ret = AVERROR_INVALIDDATA; goto err; } - sps->chroma_format_idc = get_ue_golomb(gb); + sps->chroma_format_idc = get_ue_golomb_long(gb); if (sps->chroma_format_idc != 1) { avpriv_report_missing_feature(s->avctx, "chroma_format_idc != 1\n"); ret = AVERROR_INVALIDDATA; @@ -581,18 +581,18 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) if (sps->chroma_format_idc == 3) sps->separate_colour_plane_flag = get_bits1(gb); - sps->width = get_ue_golomb(gb); - sps->height = get_ue_golomb(gb); + sps->width = get_ue_golomb_long(gb); + sps->height = get_ue_golomb_long(gb); if ((ret = av_image_check_size(sps->width, sps->height, 0, s->avctx)) < 0) goto err; if (get_bits1(gb)) { // pic_conformance_flag //TODO: * 2 is only valid for 420 - sps->pic_conf_win.left_offset = get_ue_golomb(gb) * 2; - sps->pic_conf_win.right_offset = get_ue_golomb(gb) * 2; - sps->pic_conf_win.top_offset = get_ue_golomb(gb) * 2; - sps->pic_conf_win.bottom_offset = get_ue_golomb(gb) * 2; + sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * 2; + sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * 2; + sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * 2; + sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * 2; if (s->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) { av_log(s->avctx, AV_LOG_DEBUG, @@ -611,8 +611,8 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) sps->output_window = sps->pic_conf_win; } - sps->bit_depth = get_ue_golomb(gb) + 8; - bit_depth_chroma = get_ue_golomb(gb) + 8; + sps->bit_depth = get_ue_golomb_long(gb) + 8; + bit_depth_chroma = get_ue_golomb_long(gb) + 8; if (bit_depth_chroma != sps->bit_depth) { av_log(s->avctx, AV_LOG_ERROR, "Luma bit depth (%d) is different from chroma bit depth (%d), this is unsupported.\n", @@ -649,7 +649,7 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) sps->pixel_shift = sps->bit_depth > 8; - sps->log2_max_poc_lsb = get_ue_golomb(gb) + 4; + sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4; if (sps->log2_max_poc_lsb > 16) { av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n", sps->log2_max_poc_lsb - 4); @@ -660,16 +660,16 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) sublayer_ordering_info = get_bits1(gb); start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1; for (i = start; i < sps->max_sub_layers; i++) { - sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb(gb); - sps->temporal_layer[i].num_reorder_pics = get_ue_golomb(gb); - sps->temporal_layer[i].max_latency_increase = get_ue_golomb(gb); - if (sps->temporal_layer[i].max_dec_pic_buffering >= MAX_DPB_SIZE) { + sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1; + sps->temporal_layer[i].num_reorder_pics = get_ue_golomb_long(gb); + sps->temporal_layer[i].max_latency_increase = get_ue_golomb_long(gb) - 1; + if (sps->temporal_layer[i].max_dec_pic_buffering > MAX_DPB_SIZE) { av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n", sps->temporal_layer[i].max_dec_pic_buffering - 1); ret = AVERROR_INVALIDDATA; goto err; } - if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering) { + if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) { av_log(s->avctx, AV_LOG_ERROR, "sps_max_num_reorder_pics out of range: %d\n", sps->temporal_layer[i].num_reorder_pics); ret = AVERROR_INVALIDDATA; @@ -685,10 +685,10 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) } } - sps->log2_min_coding_block_size = get_ue_golomb(gb) + 3; - sps->log2_diff_max_min_coding_block_size = get_ue_golomb(gb); - sps->log2_min_transform_block_size = get_ue_golomb(gb) + 2; - log2_diff_max_min_transform_block_size = get_ue_golomb(gb); + sps->log2_min_coding_block_size = get_ue_golomb_long(gb) + 3; + sps->log2_diff_max_min_coding_block_size = get_ue_golomb_long(gb); + sps->log2_min_transform_block_size = get_ue_golomb_long(gb) + 2; + log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb); sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size + sps->log2_min_transform_block_size; if (sps->log2_min_transform_block_size >= sps->log2_min_coding_block_size) { @@ -696,8 +696,8 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) ret = AVERROR_INVALIDDATA; goto err; } - sps->max_transform_hierarchy_depth_inter = get_ue_golomb(gb); - sps->max_transform_hierarchy_depth_intra = get_ue_golomb(gb); + sps->max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb); + sps->max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb); sps->scaling_list_enable_flag = get_bits1(gb); if (sps->scaling_list_enable_flag) { @@ -727,9 +727,9 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) goto err; } - sps->pcm.log2_min_pcm_cb_size = get_ue_golomb(gb) + 3; + sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3; sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size + - get_ue_golomb(gb); + get_ue_golomb_long(gb); if (sps->pcm.bit_depth > sps->bit_depth) { av_log(s->avctx, AV_LOG_ERROR, "PCM bit depth (%d) is greater than normal bit depth (%d)\n", @@ -741,7 +741,7 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) sps->pcm.loop_filter_disable_flag = get_bits1(gb); } - sps->nb_st_rps = get_ue_golomb(gb); + sps->nb_st_rps = get_ue_golomb_long(gb); if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) { av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n", sps->nb_st_rps); @@ -756,7 +756,7 @@ int ff_hevc_decode_nal_sps(HEVCContext *s) sps->long_term_ref_pics_present_flag = get_bits1(gb); if (sps->long_term_ref_pics_present_flag) { - sps->num_long_term_ref_pics_sps = get_ue_golomb(gb); + sps->num_long_term_ref_pics_sps = get_ue_golomb_long(gb); for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) { sps->lt_ref_pic_poc_lsb_sps[i] = get_bits(gb, sps->log2_max_poc_lsb); sps->used_by_curr_pic_lt_sps_flag[i] = get_bits1(gb); @@ -929,13 +929,13 @@ int ff_hevc_decode_nal_pps(HEVCContext *s) pps->tc_offset = 0; // Coded parameters - pps_id = get_ue_golomb(gb); + pps_id = get_ue_golomb_long(gb); if (pps_id >= MAX_PPS_COUNT) { av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id); ret = AVERROR_INVALIDDATA; goto err; } - pps->sps_id = get_ue_golomb(gb); + pps->sps_id = get_ue_golomb_long(gb); if (pps->sps_id >= MAX_SPS_COUNT) { av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id); ret = AVERROR_INVALIDDATA; @@ -956,8 +956,8 @@ int ff_hevc_decode_nal_pps(HEVCContext *s) pps->cabac_init_present_flag = get_bits1(gb); - pps->num_ref_idx_l0_default_active = get_ue_golomb(gb) + 1; - pps->num_ref_idx_l1_default_active = get_ue_golomb(gb) + 1; + pps->num_ref_idx_l0_default_active = get_ue_golomb_long(gb) + 1; + pps->num_ref_idx_l1_default_active = get_ue_golomb_long(gb) + 1; pps->pic_init_qp_minus26 = get_se_golomb(gb); @@ -967,7 +967,7 @@ int ff_hevc_decode_nal_pps(HEVCContext *s) pps->cu_qp_delta_enabled_flag = get_bits1(gb); pps->diff_cu_qp_delta_depth = 0; if (pps->cu_qp_delta_enabled_flag) - pps->diff_cu_qp_delta_depth = get_ue_golomb(gb); + pps->diff_cu_qp_delta_depth = get_ue_golomb_long(gb); pps->cb_qp_offset = get_se_golomb(gb); if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) { @@ -993,8 +993,8 @@ int ff_hevc_decode_nal_pps(HEVCContext *s) pps->entropy_coding_sync_enabled_flag = get_bits1(gb); if (pps->tiles_enabled_flag) { - pps->num_tile_columns = get_ue_golomb(gb) + 1; - pps->num_tile_rows = get_ue_golomb(gb) + 1; + pps->num_tile_columns = get_ue_golomb_long(gb) + 1; + pps->num_tile_rows = get_ue_golomb_long(gb) + 1; if (pps->num_tile_columns == 0 || pps->num_tile_columns >= sps->width) { av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n", @@ -1021,7 +1021,7 @@ int ff_hevc_decode_nal_pps(HEVCContext *s) if (!pps->uniform_spacing_flag) { int sum = 0; for (i = 0; i < pps->num_tile_columns - 1; i++) { - pps->column_width[i] = get_ue_golomb(gb) + 1; + pps->column_width[i] = get_ue_golomb_long(gb) + 1; sum += pps->column_width[i]; } if (sum >= sps->ctb_width) { @@ -1033,7 +1033,7 @@ int ff_hevc_decode_nal_pps(HEVCContext *s) sum = 0; for (i = 0; i < pps->num_tile_rows - 1; i++) { - pps->row_height[i] = get_ue_golomb(gb) + 1; + pps->row_height[i] = get_ue_golomb_long(gb) + 1; sum += pps->row_height[i]; } if (sum >= sps->ctb_height) { @@ -1078,7 +1078,7 @@ int ff_hevc_decode_nal_pps(HEVCContext *s) goto err; } pps->lists_modification_present_flag = get_bits1(gb); - pps->log2_parallel_merge_level = get_ue_golomb(gb) + 2; + pps->log2_parallel_merge_level = get_ue_golomb_long(gb) + 2; if (pps->log2_parallel_merge_level > sps->log2_ctb_size) { av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n", pps->log2_parallel_merge_level - 2); |