From 3106cbd32118b121b5ae3dbf1e586a41c2f0793f Mon Sep 17 00:00:00 2001 From: Mickaël Raulet Date: Sun, 27 Oct 2013 13:29:50 +0100 Subject: hevc: more cosmetic(cherry picked from commit 9697abe41daa234602915f85bf6b1c0ca0252cff) Decreases the difference to Anton Khirnovs patch v5 Signed-off-by: Michael Niedermayer --- libavcodec/hevc.c | 261 ++++++++++++++++++++++++++---------------------------- 1 file changed, 128 insertions(+), 133 deletions(-) (limited to 'libavcodec/hevc.c') diff --git a/libavcodec/hevc.c b/libavcodec/hevc.c index acf55c0f9d..4949b7a741 100644 --- a/libavcodec/hevc.c +++ b/libavcodec/hevc.c @@ -89,9 +89,9 @@ static int pic_arrays_init(HEVCContext *s) int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) * ((height >> log2_min_cb_size) + 1); int ctb_count = s->sps->ctb_width * s->sps->ctb_height; - int pic_width_in_min_pu = width >> s->sps->log2_min_pu_size; + int min_pu_width = width >> s->sps->log2_min_pu_size; int pic_height_in_min_pu = height >> s->sps->log2_min_pu_size; - int pic_size_in_min_pu = pic_width_in_min_pu * pic_height_in_min_pu; + int pic_size_in_min_pu = min_pu_width * pic_height_in_min_pu; int pic_width_in_min_tu = width >> s->sps->log2_min_tb_size; int pic_height_in_min_tu = height >> s->sps->log2_min_tb_size; @@ -116,8 +116,8 @@ static int pic_arrays_init(HEVCContext *s) goto fail; s->filter_slice_edges = av_malloc(ctb_count); - s->tab_slice_address = av_malloc(pic_size_in_ctb * sizeof(*s->tab_slice_address)); - s->qp_y_tab = av_malloc(pic_size_in_ctb * sizeof(*s->qp_y_tab)); + s->tab_slice_address = av_malloc(pic_size_in_ctb * sizeof(*s->tab_slice_address)); + s->qp_y_tab = av_malloc(pic_size_in_ctb * sizeof(*s->qp_y_tab)); if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address) goto fail; @@ -128,12 +128,9 @@ static int pic_arrays_init(HEVCContext *s) s->tab_mvf_pool = av_buffer_pool_init(pic_size_in_min_pu * sizeof(MvField), av_buffer_alloc); - if (!s->tab_mvf_pool) - goto fail; - s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab), av_buffer_allocz); - if (!s->rpl_tab_pool) + if (!s->tab_mvf_pool || !s->rpl_tab_pool) goto fail; return 0; @@ -164,14 +161,12 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb) s->sh.luma_offset_l0[i] = 0; } } - if (s->sps->chroma_format_idc != 0) { //fix me ! invert "if" and "for" - for (i = 0; i < s->sh.nb_refs[L0]; i++) { + if (s->sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for" + for (i = 0; i < s->sh.nb_refs[L0]; i++) chroma_weight_l0_flag[i] = get_bits1(gb); - } } else { - for (i = 0; i < s->sh.nb_refs[L0]; i++) { + for (i = 0; i < s->sh.nb_refs[L0]; i++) chroma_weight_l0_flag[i] = 0; - } } for (i = 0; i < s->sh.nb_refs[L0]; i++) { if (luma_weight_l0_flag[i]) { @@ -185,7 +180,7 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb) int delta_chroma_offset_l0 = get_se_golomb(gb); s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0; s->sh.chroma_offset_l0[i][j] = av_clip_c((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j]) - >> s->sh.chroma_log2_weight_denom) + 128), -128, 127); + >> s->sh.chroma_log2_weight_denom) + 128), -128, 127); } } else { s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom; @@ -203,13 +198,11 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb) } } if (s->sps->chroma_format_idc != 0) { - for (i = 0; i < s->sh.nb_refs[L1]; i++) { + for (i = 0; i < s->sh.nb_refs[L1]; i++) chroma_weight_l1_flag[i] = get_bits1(gb); - } } else { - for (i = 0; i < s->sh.nb_refs[L1]; i++) { + for (i = 0; i < s->sh.nb_refs[L1]; i++) chroma_weight_l1_flag[i] = 0; - } } for (i = 0; i < s->sh.nb_refs[L1]; i++) { if (luma_weight_l1_flag[i]) { @@ -223,7 +216,7 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb) int delta_chroma_offset_l1 = get_se_golomb(gb); s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1; s->sh.chroma_offset_l1[i][j] = av_clip_c((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j]) - >> s->sh.chroma_log2_weight_denom) + 128), -128, 127); + >> s->sh.chroma_log2_weight_denom) + 128), -128, 127); } } else { s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom; @@ -238,7 +231,7 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb) static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb) { const HEVCSPS *sps = s->sps; - int max_poc_lsb = 1 << sps->log2_max_poc_lsb; + int max_poc_lsb = 1 << sps->log2_max_poc_lsb; int prev_delta_msb = 0; int nb_sps = 0, nb_sh; int i; @@ -297,7 +290,7 @@ static int hls_slice_header(HEVCContext *s) sh->first_slice_in_pic_flag = get_bits1(gb); if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) { s->seq_decode = (s->seq_decode + 1) & 0xff; - s->max_ra = INT_MAX; + s->max_ra = INT_MAX; if (IS_IDR(s)) ff_hevc_clear_refs(s); } @@ -361,7 +354,7 @@ static int hls_slice_header(HEVCContext *s) sh->dependent_slice_segment_flag = get_bits1(gb); slice_address_length = av_ceil_log2(s->sps->ctb_width * - s->sps->ctb_height); + s->sps->ctb_height); sh->slice_segment_addr = get_bits(gb, slice_address_length); if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) { av_log(s->avctx, AV_LOG_ERROR, "Invalid slice segment address: %u.\n", @@ -375,8 +368,8 @@ static int hls_slice_header(HEVCContext *s) } } else { sh->slice_segment_addr = sh->slice_addr = 0; - s->slice_idx = 0; - s->slice_initialized = 0; + s->slice_idx = 0; + s->slice_initialized = 0; } if (!sh->dependent_slice_segment_flag) { @@ -450,6 +443,7 @@ static int hls_slice_header(HEVCContext *s) s->poc = 0; } + /* 8.3.1 */ if (s->temporal_id == 0 && s->nal_unit_type != NAL_TRAIL_N && s->nal_unit_type != NAL_TSA_N && @@ -462,8 +456,8 @@ static int hls_slice_header(HEVCContext *s) if (s->sps->sao_enabled) { sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb); - sh->slice_sample_adaptive_offset_flag[2] = - sh->slice_sample_adaptive_offset_flag[1] = get_bits1(gb); + sh->slice_sample_adaptive_offset_flag[1] = + sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb); } else { sh->slice_sample_adaptive_offset_flag[0] = 0; sh->slice_sample_adaptive_offset_flag[1] = 0; @@ -542,6 +536,12 @@ static int hls_slice_header(HEVCContext *s) } sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb); + if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) { + av_log(s->avctx, AV_LOG_ERROR, + "Invalid number of merging MVP candidates: %d.\n", + sh->max_num_merge_cand); + return AVERROR_INVALIDDATA; + } } sh->slice_qp_delta = get_se_golomb(gb); @@ -729,12 +729,12 @@ static void hls_sao_param(HEVCContext *s, int rx, int ry) #undef CTB -static void hls_transform_unit(HEVCContext *s, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, - int log2_cb_size, int log2_trafo_size, int trafo_depth, int blk_idx) +static void hls_transform_unit(HEVCContext *s, int x0, int y0, + int xBase, int yBase, int cb_xBase, int cb_yBase, + int log2_cb_size, int log2_trafo_size, + int trafo_depth, int blk_idx) { HEVCLocalContext *lc = s->HEVClc; - int scan_idx = SCAN_DIAG; - int scan_idx_c = SCAN_DIAG; if (lc->cu.pred_mode == MODE_INTRA) { int trafo_size = 1 << log2_trafo_size; @@ -742,12 +742,12 @@ static void hls_transform_unit(HEVCContext *s, int x0, int y0, int xBase, int y s->hpc.intra_pred(s, x0, y0, log2_trafo_size, 0); if (log2_trafo_size > 2) { - trafo_size = trafo_size<<(s->sps->hshift[1]-1); + trafo_size = trafo_size << (s->sps->hshift[1] - 1); ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size); s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 1); s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 2); } else if (blk_idx == 3) { - trafo_size = trafo_size<<(s->sps->hshift[1]); + trafo_size = trafo_size << (s->sps->hshift[1]); ff_hevc_set_neighbour_available(s, xBase, yBase, trafo_size, trafo_size); s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 1); s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 2); @@ -757,6 +757,9 @@ static void hls_transform_unit(HEVCContext *s, int x0, int y0, int xBase, int y if (lc->tt.cbf_luma || SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) || SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) { + int scan_idx = SCAN_DIAG; + int scan_idx_c = SCAN_DIAG; + if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) { lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s); if (lc->tu.cu_qp_delta != 0) @@ -802,17 +805,17 @@ static void hls_transform_unit(HEVCContext *s, int x0, int y0, int xBase, int y static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size) { - int cb_size = 1 << log2_cb_size; + int cb_size = 1 << log2_cb_size; int log2_min_pu_size = s->sps->log2_min_pu_size; - int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size; + int min_pu_width = s->sps->width >> s->sps->log2_min_pu_size; int x_end = FFMIN(x0 + cb_size, s->sps->width); int y_end = FFMIN(y0 + cb_size, s->sps->height); int i, j; for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++) for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++) - s->is_pcm[i + j * pic_width_in_min_pu] = 2; + s->is_pcm[i + j * min_pu_width] = 2; } static void hls_transform_tree(HEVCContext *s, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, @@ -1071,7 +1074,7 @@ static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int nPbW, int nP enum InterPredIdc inter_pred_idc = PRED_L0; struct MvField current_mv = {{{ 0 }}}; - int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size; + int min_pu_width = s->sps->width >> s->sps->log2_min_pu_size; MvField *tab_mvf = s->ref->tab_mvf; RefPicList *refPicList = s->ref->refPicList; @@ -1104,7 +1107,7 @@ static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int nPbW, int nP for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++) for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++) - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i] = current_mv; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv; } else { /* MODE_INTER */ lc->pu.merge_flag = ff_hevc_merge_flag_decode(s); if (lc->pu.merge_flag) { @@ -1120,7 +1123,7 @@ static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int nPbW, int nP for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++) for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++) - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i] = current_mv; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv; } else { ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH); if (s->sh.slice_type == B_SLICE) @@ -1166,7 +1169,7 @@ static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int nPbW, int nP for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++) for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++) - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i] = current_mv; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv; } } @@ -1319,13 +1322,13 @@ static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size, HEVCLocalContext *lc = s->HEVClc; int x_pu = x0 >> s->sps->log2_min_pu_size; int y_pu = y0 >> s->sps->log2_min_pu_size; - int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size; + int min_pu_width = s->sps->width >> s->sps->log2_min_pu_size; int size_in_pus = pu_size >> s->sps->log2_min_pu_size; int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1); int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1); - int cand_up = (lc->ctb_up_flag || y0b) ? s->tab_ipm[(y_pu-1)*pic_width_in_min_pu+x_pu] : INTRA_DC ; - int cand_left = (lc->ctb_left_flag || x0b) ? s->tab_ipm[y_pu*pic_width_in_min_pu+x_pu-1] : INTRA_DC ; + int cand_up = (lc->ctb_up_flag || y0b) ? s->tab_ipm[(y_pu-1)*min_pu_width+x_pu] : INTRA_DC ; + int cand_left = (lc->ctb_left_flag || x0b) ? s->tab_ipm[y_pu*min_pu_width+x_pu-1] : INTRA_DC ; int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size); MvField *tab_mvf = s->ref->tab_mvf; @@ -1380,19 +1383,19 @@ static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size, if(!size_in_pus) size_in_pus = 1; for (i = 0; i < size_in_pus; i++) { - memset(&s->tab_ipm[(y_pu + i) * pic_width_in_min_pu + x_pu], + memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu], intra_pred_mode, size_in_pus); for (j = 0; j < size_in_pus; j++) { - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].is_intra = 1; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].pred_flag[0] = 0; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].pred_flag[1] = 0; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].ref_idx[0] = 0; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].ref_idx[1] = 0; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].mv[0].x = 0; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].mv[0].y = 0; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].mv[1].x = 0; - tab_mvf[(y_pu + j) * pic_width_in_min_pu + x_pu + i].mv[1].y = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0; + tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0; } } @@ -1454,20 +1457,20 @@ static void intra_prediction_unit(HEVCContext *s, int x0, int y0, int log2_cb_si static void intra_prediction_unit_default_value(HEVCContext *s, int x0, int y0, int log2_cb_size) { HEVCLocalContext *lc = s->HEVClc; - int pb_size = 1 << log2_cb_size; - int size_in_pus = pb_size >> s->sps->log2_min_pu_size; - int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size; - MvField *tab_mvf = s->ref->tab_mvf; - int x_pu = x0 >> s->sps->log2_min_pu_size; - int y_pu = y0 >> s->sps->log2_min_pu_size; + int pb_size = 1 << log2_cb_size; + int size_in_pus = pb_size >> s->sps->log2_min_pu_size; + int min_pu_width = s->sps->min_pu_width; + MvField *tab_mvf = s->ref->tab_mvf; + int x_pu = x0 >> s->sps->log2_min_pu_size; + int y_pu = y0 >> s->sps->log2_min_pu_size; int j, k; if (size_in_pus == 0) size_in_pus = 1; for (j = 0; j < size_in_pus; j++) { - memset(&s->tab_ipm[(y_pu + j) * pic_width_in_min_pu + x_pu], INTRA_DC, size_in_pus); - for (k = 0; k cu.pred_mode == MODE_INTRA; + memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus); + for (k = 0; k < size_in_pus; k++) + tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA; } } @@ -1477,19 +1480,19 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) HEVCLocalContext *lc = s->HEVClc; int log2_min_cb_size = s->sps->log2_min_cb_size; int length = cb_size >> log2_min_cb_size; - int min_cb_width = s->sps->width >> log2_min_cb_size; + int min_cb_width = s->sps->min_cb_width; int x_cb = x0 >> log2_min_cb_size; int y_cb = y0 >> log2_min_cb_size; int x, y; - lc->cu.x = x0; - lc->cu.y = y0; + lc->cu.x = x0; + lc->cu.y = y0; lc->cu.rqt_root_cbf = 1; - lc->cu.pred_mode = MODE_INTRA; - lc->cu.part_mode = PART_2Nx2N; - lc->cu.intra_split_flag = 0; - lc->cu.pcm_flag = 0; + lc->cu.pred_mode = MODE_INTRA; + lc->cu.part_mode = PART_2Nx2N; + lc->cu.intra_split_flag = 0; + lc->cu.pcm_flag = 0; SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0; for (x = 0; x < 4; x++) lc->pu.intra_pred_mode[x] = 1; @@ -1525,7 +1528,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) lc->cu.pred_mode = ff_hevc_pred_mode_decode(s); if (lc->cu.pred_mode != MODE_INTRA || log2_cb_size == s->sps->log2_min_cb_size) { - lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size); + lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size); lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN && lc->cu.pred_mode == MODE_INTRA; } @@ -1540,7 +1543,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) int ret; intra_prediction_unit_default_value(s, x0, y0, log2_cb_size); ret = hls_pcm_sample(s, x0, y0, log2_cb_size); - if(s->sps->pcm.loop_filter_disable_flag) + if (s->sps->pcm.loop_filter_disable_flag) set_deblocking_bypass(s, x0, y0, log2_cb_size); if (ret < 0) @@ -1594,8 +1597,8 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) } if (lc->cu.rqt_root_cbf) { lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ? - s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag : - s->sps->max_transform_hierarchy_depth_inter; + s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag : + s->sps->max_transform_hierarchy_depth_inter; hls_transform_tree(s, x0, y0, x0, y0, x0, y0, log2_cb_size, log2_cb_size, 0, 0); } else { @@ -1621,14 +1624,16 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size) return 0; } -static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, int log2_cb_size, int cb_depth) +static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, + int log2_cb_size, int cb_depth) { HEVCLocalContext *lc = s->HEVClc; + const int cb_size = 1 << log2_cb_size; int ret; lc->ct.depth = cb_depth; - if ((x0 + (1 << log2_cb_size) <= s->sps->width) && - (y0 + (1 << log2_cb_size) <= s->sps->height) && + if ((x0 + cb_size <= s->sps->width) && + (y0 + cb_size <= s->sps->height) && log2_cb_size > s->sps->log2_min_cb_size) { SAMPLE(s->split_cu_flag, x0, y0) = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0); @@ -1643,10 +1648,10 @@ static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, int log2_cb_size, } if (SAMPLE(s->split_cu_flag, x0, y0)) { + const int cb_size_split = cb_size >> 1; + const int x1 = x0 + cb_size_split; + const int y1 = y0 + cb_size_split; int more_data = 0; - int cb_size = (1 << (log2_cb_size)) >> 1; - int x1 = x0 + cb_size; - int y1 = y0 + cb_size; more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1); if (more_data < 0) @@ -1661,20 +1666,20 @@ static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, int log2_cb_size, return hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1); } if (more_data) - return ((x1 + cb_size) < s->sps->width || - (y1 + cb_size) < s->sps->height); + return ((x1 + cb_size_split) < s->sps->width || + (y1 + cb_size_split) < s->sps->height); else return 0; } else { ret = hls_coding_unit(s, x0, y0, log2_cb_size); if (ret < 0) return ret; - if ((!((x0 + (1 << log2_cb_size)) % + if ((!((x0 + cb_size) % (1 << (s->sps->log2_ctb_size))) || - (x0 + (1 << log2_cb_size) >= s->sps->width)) && - (!((y0 + (1 << log2_cb_size)) % + (x0 + cb_size >= s->sps->width)) && + (!((y0 + cb_size) % (1 << (s->sps->log2_ctb_size))) || - (y0 + (1 << log2_cb_size) >= s->sps->height))) { + (y0 + cb_size >= s->sps->height))) { int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s); return !end_of_slice_flag; } else { @@ -1685,10 +1690,6 @@ static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, int log2_cb_size, return 0; } -/** - * 7.3.4 - */ - static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, int ctb_addr_ts) { HEVCLocalContext *lc = s->HEVClc; @@ -1703,7 +1704,6 @@ static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, int ctb_a s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr; - if (s->pps->entropy_coding_sync_enabled_flag) { if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0) lc->first_qp_group = 1; @@ -1712,7 +1712,7 @@ static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, int ctb_a if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) { int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size]; lc->start_of_tiles_x = x_ctb; - lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX]<< s->sps->log2_ctb_size); + lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size); lc->first_qp_group = 1; } } else { @@ -1722,19 +1722,19 @@ static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, int ctb_a lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height); if (s->pps->tiles_enabled_flag) { - tile_left_boundary = ((x_ctb > 0) && - (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs-1]])); + tile_left_boundary = ((x_ctb > 0) && + (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])); slice_left_boundary = ((x_ctb > 0) && (s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - 1])); - tile_up_boundary = ((y_ctb > 0) && - (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]])); + tile_up_boundary = ((y_ctb > 0) && + (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]])); slice_up_boundary = ((y_ctb > 0) && (s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])); } else { - tile_left_boundary = - tile_up_boundary = 1; + tile_left_boundary = + tile_up_boundary = 1; slice_left_boundary = ctb_addr_in_slice > 0; - slice_up_boundary = ctb_addr_in_slice >= s->sps->ctb_width; + slice_up_boundary = ctb_addr_in_slice >= s->sps->ctb_width; } lc->slice_or_tiles_left_boundary = (!slice_left_boundary) + (!tile_left_boundary << 1); lc->slice_or_tiles_up_boundary = (!slice_up_boundary + (!tile_up_boundary << 1)); @@ -1969,31 +1969,29 @@ static int hls_nal_unit(HEVCContext *s) "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n", s->nal_unit_type, nuh_layer_id, s->temporal_id); - return (nuh_layer_id == 0); + return nuh_layer_id == 0; } static void restore_tqb_pixels(HEVCContext *s) { - int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size; - int pic_height_in_min_pu = s->sps->height >> s->sps->log2_min_pu_size; - int min_pu_size = 1 << s->sps->log2_min_pu_size; + int min_pu_size = 1 << s->sps->log2_min_pu_size; int x, y, c_idx; for (c_idx = 0; c_idx < 3; c_idx++) { ptrdiff_t stride = s->frame->linesize[c_idx]; - int hshift = s->sps->hshift[c_idx]; - int vshift = s->sps->vshift[c_idx]; - for (y = 0; y < pic_height_in_min_pu; y++) { - for (x = 0; x < pic_width_in_min_pu; x++) { - if (s->is_pcm[y*pic_width_in_min_pu+x]) { + int hshift = s->sps->hshift[c_idx]; + int vshift = s->sps->vshift[c_idx]; + for (y = 0; y < s->sps->min_pu_height; y++) { + for (x = 0; x < s->sps->min_pu_width; x++) { + if (s->is_pcm[y * s->sps->min_pu_width + x]) { int n; - int len = min_pu_size >> hshift; + int len = min_pu_size >> hshift; uint8_t *src = &s->frame->data[c_idx][((y << s->sps->log2_min_pu_size) >> vshift) * stride + (((x << s->sps->log2_min_pu_size) >> hshift) << s->sps->pixel_shift)]; uint8_t *dst = &s->sao_frame->data[c_idx][((y << s->sps->log2_min_pu_size) >> vshift) * stride + (((x << s->sps->log2_min_pu_size) >> hshift) << s->sps->pixel_shift)]; - for (n = 0;n < (min_pu_size >> vshift); n++) { - memcpy(dst,src,len); - src += stride; - dst += stride; + for (n = 0; n < (min_pu_size >> vshift); n++) { + memcpy(dst, src, len); + src += stride; + dst += stride; } } } @@ -2004,22 +2002,18 @@ static void restore_tqb_pixels(HEVCContext *s) static int hevc_frame_start(HEVCContext *s) { HEVCLocalContext *lc = s->HEVClc; - int pic_width_in_min_pu = s->sps->width >> s->sps->log2_min_pu_size; - int pic_height_in_min_pu = s->sps->height >> s->sps->log2_min_pu_size; - int pic_width_in_min_tu = s->sps->width >> s->sps->log2_min_tb_size; - int pic_height_in_min_tu = s->sps->height >> s->sps->log2_min_tb_size; int ret; memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1)); memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1)); - memset(s->cbf_luma, 0, pic_width_in_min_tu * pic_height_in_min_tu); - memset(s->is_pcm, 0, pic_width_in_min_pu * pic_height_in_min_pu); + memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height); + memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height); lc->start_of_tiles_x = 0; s->is_decoded = 0; if (s->pps->tiles_enabled_flag) - lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size; + lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size; ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame, s->poc); @@ -2057,7 +2051,7 @@ fail: static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length) { HEVCLocalContext *lc = s->HEVClc; - GetBitContext *gb = &lc->gb; + GetBitContext *gb = &lc->gb; int ctb_addr_ts; int ret; @@ -2068,7 +2062,7 @@ static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length) ret = hls_nal_unit(s); if (ret < 0) { av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n", - s->nal_unit_type); + s->nal_unit_type); if (s->avctx->err_recognition & AV_EF_EXPLODE) return ret; return 0; @@ -2118,10 +2112,7 @@ static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length) return ret; if (s->max_ra == INT_MAX) { - if (s->nal_unit_type == NAL_CRA_NUT || - s->nal_unit_type == NAL_BLA_W_LP || - s->nal_unit_type == NAL_BLA_N_LP || - s->nal_unit_type == NAL_BLA_W_RADL) { + if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) { s->max_ra = s->poc; } else { if (IS_IDR(s)) @@ -2151,8 +2142,8 @@ static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length) s->sh.slice_type != I_SLICE) { ret = ff_hevc_slice_rpl(s); if (ret < 0) { - av_log(s->avctx, AV_LOG_WARNING, "Error constructing the reference " - "lists for the current slice.\n"); + av_log(s->avctx, AV_LOG_WARNING, + "Error constructing the reference lists for the current slice.\n"); if (s->avctx->err_recognition & AV_EF_EXPLODE) return ret; } @@ -2183,7 +2174,8 @@ static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length) case NAL_FD_NUT: break; default: - av_log(s->avctx, AV_LOG_INFO, "Skipping NAL unit %d\n", s->nal_unit_type); + av_log(s->avctx, AV_LOG_INFO, + "Skipping NAL unit %d\n", s->nal_unit_type); } return 0; @@ -2265,9 +2257,9 @@ int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length, dst[di++] = src[si++]; } else if (src[si] == 0 && src[si + 1] == 0) { if (src[si + 2] == 3) { // escape - dst[di++] = 0; - dst[di++] = 0; - si += 3; + dst[di++] = 0; + dst[di++] = 0; + si += 3; s->skipped_bytes++; if (s->skipped_bytes_pos_size < s->skipped_bytes) { @@ -2380,7 +2372,8 @@ static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length) goto fail; hls_nal_unit(s); - if (s->nal_unit_type == NAL_EOS_NUT || s->nal_unit_type == NAL_EOB_NUT) + if (s->nal_unit_type == NAL_EOS_NUT || + s->nal_unit_type == NAL_EOB_NUT) s->eos = 1; buf += consumed; @@ -2395,7 +2388,8 @@ static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length) ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size); if (ret < 0) { - av_log(s->avctx, AV_LOG_WARNING, "Error parsing NAL unit #%d.\n", i); + av_log(s->avctx, AV_LOG_WARNING, + "Error parsing NAL unit #%d.\n", i); if (s->avctx->err_recognition & AV_EF_EXPLODE) goto fail; } @@ -2762,7 +2756,8 @@ static int hevc_decode_extradata(HEVCContext *s) // +2 for the nal size field int nalsize = bytestream2_peek_be16(&gb) + 2; if (bytestream2_get_bytes_left(&gb) < nalsize) { - av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size in extradata.\n"); + av_log(s->avctx, AV_LOG_ERROR, + "Invalid NAL unit size in extradata.\n"); return AVERROR_INVALIDDATA; } -- cgit v1.2.3