From 8a061d421e8046cafc3cbaf24e279f7635ac1fa2 Mon Sep 17 00:00:00 2001 From: clang-format Date: Thu, 11 Aug 2016 18:53:26 -0700 Subject: [PATCH] vp10/decoder,vp10/*.[hc]: apply clang-format Change-Id: Ie4d7ecb2f692c1c43eff1242e1f00e7fbae00e57 --- vp10/decoder/decodeframe.c | 1368 ++++++++++++++++-------------------- vp10/decoder/decodeframe.h | 10 +- vp10/decoder/decodemv.c | 562 +++++++-------- vp10/decoder/decodemv.h | 4 +- vp10/decoder/decoder.c | 97 +-- vp10/decoder/decoder.h | 35 +- vp10/decoder/detokenize.c | 167 ++--- vp10/decoder/detokenize.h | 9 +- vp10/decoder/dsubexp.c | 32 +- vp10/decoder/dsubexp.h | 3 +- vp10/decoder/dthread.c | 37 +- vp10/decoder/dthread.h | 6 +- vp10/vp10_cx_iface.c | 664 +++++++++-------- vp10/vp10_dx_iface.c | 327 ++++----- vp10/vp10_iface_common.h | 35 +- 15 files changed, 1486 insertions(+), 1870 deletions(-) diff --git a/vp10/decoder/decodeframe.c b/vp10/decoder/decodeframe.c index 44b802b96..6a8475ee2 100644 --- a/vp10/decoder/decodeframe.c +++ b/vp10/decoder/decodeframe.c @@ -47,11 +47,9 @@ static int is_compound_reference_allowed(const VP10_COMMON *cm) { int i; - if (frame_is_intra_only(cm)) - return 0; + if (frame_is_intra_only(cm)) return 0; for (i = 1; i < INTER_REFS_PER_FRAME; ++i) - if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1]) - return 1; + if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1]) return 1; return 0; } @@ -67,12 +65,12 @@ static void setup_compound_reference_mode(VP10_COMMON *cm) { cm->comp_bwd_ref[1] = ALTREF_FRAME; #else if (cm->ref_frame_sign_bias[LAST_FRAME] == - cm->ref_frame_sign_bias[GOLDEN_FRAME]) { + cm->ref_frame_sign_bias[GOLDEN_FRAME]) { cm->comp_fixed_ref = ALTREF_FRAME; cm->comp_var_ref[0] = LAST_FRAME; cm->comp_var_ref[1] = GOLDEN_FRAME; } else if (cm->ref_frame_sign_bias[LAST_FRAME] == - cm->ref_frame_sign_bias[ALTREF_FRAME]) { + cm->ref_frame_sign_bias[ALTREF_FRAME]) { cm->comp_fixed_ref = GOLDEN_FRAME; cm->comp_var_ref[0] = LAST_FRAME; cm->comp_var_ref[1] = ALTREF_FRAME; @@ -139,12 +137,12 @@ static void read_inter_compound_mode_probs(FRAME_CONTEXT *fc, vp10_reader *r) { } #endif // CONFIG_EXT_INTER -static REFERENCE_MODE read_frame_reference_mode(const VP10_COMMON *cm, - struct vpx_read_bit_buffer *rb) { +static REFERENCE_MODE read_frame_reference_mode( + const VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) { if (is_compound_reference_allowed(cm)) { - return vpx_rb_read_bit(rb) ? REFERENCE_MODE_SELECT - : (vpx_rb_read_bit(rb) ? COMPOUND_REFERENCE - : SINGLE_REFERENCE); + return vpx_rb_read_bit(rb) + ? REFERENCE_MODE_SELECT + : (vpx_rb_read_bit(rb) ? COMPOUND_REFERENCE : SINGLE_REFERENCE); } else { return SINGLE_REFERENCE; } @@ -183,8 +181,7 @@ static void read_frame_reference_mode_probs(VP10_COMMON *cm, vp10_reader *r) { static void update_mv_probs(vpx_prob *p, int n, vp10_reader *r) { int i; - for (i = 0; i < n; ++i) - vp10_diff_update_prob(r, &p[i]); + for (i = 0; i < n; ++i) vp10_diff_update_prob(r, &p[i]); } static void read_mv_probs(nmv_context *ctx, int allow_hp, vp10_reader *r) { @@ -220,11 +217,10 @@ static void read_mv_probs(nmv_context *ctx, int allow_hp, vp10_reader *r) { } } -static void inverse_transform_block(MACROBLOCKD* xd, int plane, +static void inverse_transform_block(MACROBLOCKD *xd, int plane, const TX_TYPE tx_type, - const TX_SIZE tx_size, - uint8_t *dst, int stride, - int eob) { + const TX_SIZE tx_size, uint8_t *dst, + int stride, int eob) { struct macroblockd_plane *const pd = &xd->plane[plane]; if (eob > 0) { tran_low_t *const dqcoeff = pd->dqcoeff; @@ -250,7 +246,7 @@ static void inverse_transform_block(MACROBLOCKD* xd, int plane, } else { if (tx_type == DCT_DCT && tx_size <= TX_16X16 && eob <= 10) memset(dqcoeff, 0, 4 * 4 * num_4x4_blocks_wide_txsize_lookup[tx_size] * - sizeof(dqcoeff[0])); + sizeof(dqcoeff[0])); #if CONFIG_EXT_TX else memset(dqcoeff, 0, get_tx2d_size(tx_size) * sizeof(dqcoeff[0])); @@ -271,8 +267,7 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd, vp10_reader *r, #endif // CONFIG_ANS MB_MODE_INFO *const mbmi, - int plane, - int row, int col, + int plane, int row, int col, TX_SIZE tx_size) { struct macroblockd_plane *const pd = &xd->plane[plane]; PREDICTION_MODE mode = (plane == 0) ? mbmi->mode : mbmi->uv_mode; @@ -282,37 +277,36 @@ static void predict_and_reconstruct_intra_block(MACROBLOCKD *const xd, dst = &pd->dst.buf[4 * row * pd->dst.stride + 4 * col]; if (mbmi->sb_type < BLOCK_8X8) - if (plane == 0) - mode = xd->mi[0]->bmi[(row << 1) + col].as_mode; + if (plane == 0) mode = xd->mi[0]->bmi[(row << 1) + col].as_mode; - vp10_predict_intra_block(xd, pd->n4_wl, pd->n4_hl, tx_size, mode, - dst, pd->dst.stride, dst, pd->dst.stride, - col, row, plane); + vp10_predict_intra_block(xd, pd->n4_wl, pd->n4_hl, tx_size, mode, dst, + pd->dst.stride, dst, pd->dst.stride, col, row, + plane); if (!mbmi->skip) { TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size); const scan_order *sc = get_scan(tx_size, tx_type, 0); - const int eob = vp10_decode_block_tokens(xd, - plane, sc, col, row, tx_size, + const int eob = vp10_decode_block_tokens(xd, plane, sc, col, row, tx_size, tx_type, r, mbmi->segment_id); - inverse_transform_block(xd, plane, tx_type, tx_size, - dst, pd->dst.stride, eob); + inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride, + eob); } } #if CONFIG_VAR_TX static void decode_reconstruct_tx(MACROBLOCKD *const xd, vp10_reader *r, - MB_MODE_INFO *const mbmi, - int plane, BLOCK_SIZE plane_bsize, - int block, int blk_row, int blk_col, - TX_SIZE tx_size, int *eob_total) { + MB_MODE_INFO *const mbmi, int plane, + BLOCK_SIZE plane_bsize, int block, + int blk_row, int blk_col, TX_SIZE tx_size, + int *eob_total) { const struct macroblockd_plane *const pd = &xd->plane[plane]; const BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; const int tx_row = blk_row >> (1 - pd->subsampling_y); const int tx_col = blk_col >> (1 - pd->subsampling_x); - const TX_SIZE plane_tx_size = plane ? - get_uv_tx_size_impl(mbmi->inter_tx_size[tx_row][tx_col], bsize, 0, 0) : - mbmi->inter_tx_size[tx_row][tx_col]; + const TX_SIZE plane_tx_size = + plane ? get_uv_tx_size_impl(mbmi->inter_tx_size[tx_row][tx_col], bsize, 0, + 0) + : mbmi->inter_tx_size[tx_row][tx_col]; int max_blocks_high = num_4x4_blocks_high_lookup[plane_bsize]; int max_blocks_wide = num_4x4_blocks_wide_lookup[plane_bsize]; @@ -321,8 +315,7 @@ static void decode_reconstruct_tx(MACROBLOCKD *const xd, vp10_reader *r, if (xd->mb_to_right_edge < 0) max_blocks_wide += xd->mb_to_right_edge >> (5 + pd->subsampling_x); - if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) - return; + if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; if (tx_size == plane_tx_size #if CONFIG_EXT_TX && CONFIG_RECT_TX @@ -332,10 +325,11 @@ static void decode_reconstruct_tx(MACROBLOCKD *const xd, vp10_reader *r, PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV; TX_TYPE tx_type = get_tx_type(plane_type, xd, block, plane_tx_size); const scan_order *sc = get_scan(plane_tx_size, tx_type, 1); - const int eob = vp10_decode_block_tokens(xd, plane, sc, - blk_col, blk_row, plane_tx_size, - tx_type, r, mbmi->segment_id); - inverse_transform_block(xd, plane, tx_type, plane_tx_size, + const int eob = + vp10_decode_block_tokens(xd, plane, sc, blk_col, blk_row, plane_tx_size, + tx_type, r, mbmi->segment_id); + inverse_transform_block( + xd, plane, tx_type, plane_tx_size, &pd->dst.buf[4 * blk_row * pd->dst.stride + 4 * blk_col], pd->dst.stride, eob); *eob_total += eob; @@ -351,8 +345,7 @@ static void decode_reconstruct_tx(MACROBLOCKD *const xd, vp10_reader *r, const int offsetc = blk_col + ((i & 0x01) << bsl); int step = num_4x4_blocks_txsize_lookup[tx_size - 1]; - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) - continue; + if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; decode_reconstruct_tx(xd, r, mbmi, plane, plane_bsize, block + i * step, offsetr, offsetc, tx_size - 1, eob_total); @@ -368,17 +361,15 @@ static int reconstruct_inter_block(MACROBLOCKD *const xd, #else vp10_reader *r, #endif - int segment_id, int plane, - int row, int col, TX_SIZE tx_size) { + int segment_id, int plane, int row, int col, + TX_SIZE tx_size) { struct macroblockd_plane *const pd = &xd->plane[plane]; PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV; int block_idx = (row << 1) + col; TX_TYPE tx_type = get_tx_type(plane_type, xd, block_idx, tx_size); const scan_order *sc = get_scan(tx_size, tx_type, 1); - const int eob = vp10_decode_block_tokens(xd, - plane, sc, col, row, - tx_size, tx_type, r, - segment_id); + const int eob = vp10_decode_block_tokens(xd, plane, sc, col, row, tx_size, + tx_type, r, segment_id); inverse_transform_block(xd, plane, tx_type, tx_size, &pd->dst.buf[4 * row * pd->dst.stride + 4 * col], @@ -387,11 +378,11 @@ static int reconstruct_inter_block(MACROBLOCKD *const xd, } #endif // !CONFIG_VAR_TX || CONFIG_SUPER_TX -static INLINE TX_SIZE dec_get_uv_tx_size(const MB_MODE_INFO *mbmi, - int n4_wl, int n4_hl) { +static INLINE TX_SIZE dec_get_uv_tx_size(const MB_MODE_INFO *mbmi, int n4_wl, + int n4_hl) { // get minimum log2 num4x4s dimension const int x = VPXMIN(n4_wl, n4_hl); - return VPXMIN(mbmi->tx_size, x); + return VPXMIN(mbmi->tx_size, x); } static INLINE void dec_reset_skip_context(MACROBLOCKD *xd) { @@ -416,8 +407,8 @@ static void set_plane_n4(MACROBLOCKD *const xd, int bw, int bh, int bwl, static MB_MODE_INFO *set_offsets(VP10_COMMON *const cm, MACROBLOCKD *const xd, BLOCK_SIZE bsize, int mi_row, int mi_col, - int bw, int bh, int x_mis, int y_mis, - int bwl, int bhl) { + int bw, int bh, int x_mis, int y_mis, int bwl, + int bhl) { const int offset = mi_row * cm->mi_stride + mi_col; int x, y; const TileInfo *const tile = &xd->tile; @@ -452,9 +443,9 @@ static MB_MODE_INFO *set_offsets(VP10_COMMON *const cm, MACROBLOCKD *const xd, static MB_MODE_INFO *set_offsets_extend(VP10_COMMON *const cm, MACROBLOCKD *const xd, const TileInfo *const tile, - BLOCK_SIZE bsize_pred, - int mi_row_pred, int mi_col_pred, - int mi_row_ori, int mi_col_ori) { + BLOCK_SIZE bsize_pred, int mi_row_pred, + int mi_col_pred, int mi_row_ori, + int mi_col_ori) { // Used in supertx // (mi_row_ori, mi_col_ori): location for mv // (mi_row_pred, mi_col_pred, bsize_pred): region to predict @@ -465,11 +456,11 @@ static MB_MODE_INFO *set_offsets_extend(VP10_COMMON *const cm, const int bhl = b_height_log2_lookup[bsize_pred]; xd->mi = cm->mi_grid_visible + offset; xd->mi[0] = cm->mi + offset; - set_mi_row_col(xd, tile, mi_row_pred, bh, mi_col_pred, bw, - cm->mi_rows, cm->mi_cols); + set_mi_row_col(xd, tile, mi_row_pred, bh, mi_col_pred, bw, cm->mi_rows, + cm->mi_cols); - xd->up_available = (mi_row_ori > tile->mi_row_start); - xd->left_available = (mi_col_ori > tile->mi_col_start); + xd->up_available = (mi_row_ori > tile->mi_row_start); + xd->left_available = (mi_col_ori > tile->mi_col_start); set_plane_n4(xd, bw, bh, bwl, bhl); @@ -477,10 +468,8 @@ static MB_MODE_INFO *set_offsets_extend(VP10_COMMON *const cm, } static MB_MODE_INFO *set_mb_offsets(VP10_COMMON *const cm, - MACROBLOCKD *const xd, - BLOCK_SIZE bsize, - int mi_row, int mi_col, - int bw, int bh, + MACROBLOCKD *const xd, BLOCK_SIZE bsize, + int mi_row, int mi_col, int bw, int bh, int x_mis, int y_mis) { const int offset = mi_row * cm->mi_stride + mi_col; const TileInfo *const tile = &xd->tile; @@ -490,16 +479,15 @@ static MB_MODE_INFO *set_mb_offsets(VP10_COMMON *const cm, xd->mi[0] = cm->mi + offset; xd->mi[0]->mbmi.sb_type = bsize; for (y = 0; y < y_mis; ++y) - for (x = !y; x < x_mis; ++x) - xd->mi[y * cm->mi_stride + x] = xd->mi[0]; + for (x = !y; x < x_mis; ++x) xd->mi[y * cm->mi_stride + x] = xd->mi[0]; set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols); return &xd->mi[0]->mbmi; } static void set_offsets_topblock(VP10_COMMON *const cm, MACROBLOCKD *const xd, - const TileInfo *const tile, - BLOCK_SIZE bsize, int mi_row, int mi_col) { + const TileInfo *const tile, BLOCK_SIZE bsize, + int mi_row, int mi_col) { const int bw = num_8x8_blocks_wide_lookup[bsize]; const int bh = num_8x8_blocks_high_lookup[bsize]; const int offset = mi_row * cm->mi_stride + mi_col; @@ -516,7 +504,7 @@ static void set_offsets_topblock(VP10_COMMON *const cm, MACROBLOCKD *const xd, vp10_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col); } -static void set_param_topblock(VP10_COMMON *const cm, MACROBLOCKD *const xd, +static void set_param_topblock(VP10_COMMON *const cm, MACROBLOCKD *const xd, BLOCK_SIZE bsize, int mi_row, int mi_col, int txfm, int skip) { const int bw = num_8x8_blocks_wide_lookup[bsize]; @@ -537,14 +525,14 @@ static void set_param_topblock(VP10_COMMON *const cm, MACROBLOCKD *const xd, #if CONFIG_VAR_TX xd->above_txfm_context = cm->above_txfm_context + mi_col; xd->left_txfm_context = - xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); + xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); set_txfm_ctx(xd->left_txfm_context, xd->mi[0]->mbmi.tx_size, bh); set_txfm_ctx(xd->above_txfm_context, xd->mi[0]->mbmi.tx_size, bw); #endif } -static void set_ref(VP10_COMMON *const cm, MACROBLOCKD *const xd, - int idx, int mi_row, int mi_col) { +static void set_ref(VP10_COMMON *const cm, MACROBLOCKD *const xd, int idx, + int mi_row, int mi_col) { MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; RefBuffer *ref_buffer = &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME]; xd->block_refs[idx] = ref_buffer; @@ -557,15 +545,10 @@ static void set_ref(VP10_COMMON *const cm, MACROBLOCKD *const xd, } static void dec_predict_b_extend( - VP10Decoder *const pbi, MACROBLOCKD *const xd, - const TileInfo *const tile, int block, - int mi_row_ori, int mi_col_ori, - int mi_row_pred, int mi_col_pred, - int mi_row_top, int mi_col_top, - uint8_t * dst_buf[3], int dst_stride[3], - BLOCK_SIZE bsize_top, - BLOCK_SIZE bsize_pred, - int b_sub8x8, int bextend) { + VP10Decoder *const pbi, MACROBLOCKD *const xd, const TileInfo *const tile, + int block, int mi_row_ori, int mi_col_ori, int mi_row_pred, int mi_col_pred, + int mi_row_top, int mi_col_top, uint8_t *dst_buf[3], int dst_stride[3], + BLOCK_SIZE bsize_top, BLOCK_SIZE bsize_pred, int b_sub8x8, int bextend) { // Used in supertx // (mi_row_ori, mi_col_ori): location for mv // (mi_row_pred, mi_col_pred, bsize_pred): region to predict @@ -582,12 +565,11 @@ static void dec_predict_b_extend( if (mi_row_pred < mi_row_top || mi_col_pred < mi_col_top || mi_row_pred >= mi_row_top + mi_height_top || - mi_col_pred >= mi_col_top + mi_width_top || - mi_row_pred >= cm->mi_rows || mi_col_pred >= cm->mi_cols) + mi_col_pred >= mi_col_top + mi_width_top || mi_row_pred >= cm->mi_rows || + mi_col_pred >= cm->mi_cols) return; - mbmi = set_offsets_extend(cm, xd, tile, bsize_pred, - mi_row_pred, mi_col_pred, + mbmi = set_offsets_extend(cm, xd, tile, bsize_pred, mi_row_pred, mi_col_pred, mi_row_ori, mi_col_ori); set_ref(cm, xd, 0, mi_row_pred, mi_col_pred); if (has_second_ref(&xd->mi[0]->mbmi)) @@ -611,27 +593,25 @@ static void dec_predict_b_extend( (c >> xd->plane[2].subsampling_x); if (!b_sub8x8) - vp10_build_inter_predictors_sb_extend( - xd, + vp10_build_inter_predictors_sb_extend(xd, #if CONFIG_EXT_INTER - mi_row_ori, mi_col_ori, + mi_row_ori, mi_col_ori, #endif // CONFIG_EXT_INTER - mi_row_pred, mi_col_pred, bsize_pred); + mi_row_pred, mi_col_pred, bsize_pred); else - vp10_build_inter_predictors_sb_sub8x8_extend( - xd, + vp10_build_inter_predictors_sb_sub8x8_extend(xd, #if CONFIG_EXT_INTER - mi_row_ori, mi_col_ori, + mi_row_ori, mi_col_ori, #endif // CONFIG_EXT_INTER - mi_row_pred, mi_col_pred, bsize_pred, block); + mi_row_pred, mi_col_pred, + bsize_pred, block); } static void dec_extend_dir(VP10Decoder *const pbi, MACROBLOCKD *const xd, const TileInfo *const tile, int block, - BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, - int mi_row, int mi_col, - int mi_row_top, int mi_col_top, - uint8_t * dst_buf[3], int dst_stride[3], int dir) { + BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, int mi_row, + int mi_col, int mi_row_top, int mi_col_top, + uint8_t *dst_buf[3], int dst_stride[3], int dir) { // dir: 0-lower, 1-upper, 2-left, 3-right // 4-lowerleft, 5-upperleft, 6-lowerright, 7-upperright const int mi_width = num_8x8_blocks_wide_lookup[bsize]; @@ -643,72 +623,63 @@ static void dec_extend_dir(VP10Decoder *const pbi, MACROBLOCKD *const xd, int unit, mi_row_pred, mi_col_pred; if (dir == 0 || dir == 1) { - extend_bsize = (mi_width == 1 || bsize < BLOCK_8X8 || xss < yss) ? - BLOCK_8X8 : BLOCK_16X8; + extend_bsize = (mi_width == 1 || bsize < BLOCK_8X8 || xss < yss) + ? BLOCK_8X8 + : BLOCK_16X8; unit = num_8x8_blocks_wide_lookup[extend_bsize]; mi_row_pred = mi_row + ((dir == 0) ? mi_height : -1); mi_col_pred = mi_col; - dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, - mi_row_pred, mi_col_pred, - mi_row_top, mi_col_top, - dst_buf, dst_stride, - top_bsize, extend_bsize, b_sub8x8, 1); + dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred, + mi_col_pred, mi_row_top, mi_col_top, dst_buf, + dst_stride, top_bsize, extend_bsize, b_sub8x8, 1); if (mi_width > unit) { int i; assert(!b_sub8x8); - for (i = 0; i < mi_width/unit - 1; i++) { + for (i = 0; i < mi_width / unit - 1; i++) { mi_col_pred += unit; - dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, - mi_row_pred, mi_col_pred, - mi_row_top, mi_col_top, - dst_buf, dst_stride, - top_bsize, extend_bsize, b_sub8x8, 1); + dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred, + mi_col_pred, mi_row_top, mi_col_top, dst_buf, + dst_stride, top_bsize, extend_bsize, b_sub8x8, 1); } } } else if (dir == 2 || dir == 3) { - extend_bsize = (mi_height == 1 || bsize < BLOCK_8X8 || yss < xss) ? - BLOCK_8X8 : BLOCK_8X16; + extend_bsize = (mi_height == 1 || bsize < BLOCK_8X8 || yss < xss) + ? BLOCK_8X8 + : BLOCK_8X16; unit = num_8x8_blocks_high_lookup[extend_bsize]; mi_row_pred = mi_row; mi_col_pred = mi_col + ((dir == 3) ? mi_width : -1); - dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, - mi_row_pred, mi_col_pred, - mi_row_top, mi_col_top, - dst_buf, dst_stride, - top_bsize, extend_bsize, b_sub8x8, 1); + dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred, + mi_col_pred, mi_row_top, mi_col_top, dst_buf, + dst_stride, top_bsize, extend_bsize, b_sub8x8, 1); if (mi_height > unit) { int i; - for (i = 0; i < mi_height/unit - 1; i++) { + for (i = 0; i < mi_height / unit - 1; i++) { mi_row_pred += unit; - dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, - mi_row_pred, mi_col_pred, - mi_row_top, mi_col_top, - dst_buf, dst_stride, - top_bsize, extend_bsize, b_sub8x8, 1); + dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred, + mi_col_pred, mi_row_top, mi_col_top, dst_buf, + dst_stride, top_bsize, extend_bsize, b_sub8x8, 1); } } } else { extend_bsize = BLOCK_8X8; mi_row_pred = mi_row + ((dir == 4 || dir == 6) ? mi_height : -1); mi_col_pred = mi_col + ((dir == 6 || dir == 7) ? mi_width : -1); - dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, - mi_row_pred, mi_col_pred, - mi_row_top, mi_col_top, - dst_buf, dst_stride, - top_bsize, extend_bsize, b_sub8x8, 1); + dec_predict_b_extend(pbi, xd, tile, block, mi_row, mi_col, mi_row_pred, + mi_col_pred, mi_row_top, mi_col_top, dst_buf, + dst_stride, top_bsize, extend_bsize, b_sub8x8, 1); } } static void dec_extend_all(VP10Decoder *const pbi, MACROBLOCKD *const xd, const TileInfo *const tile, int block, - BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, - int mi_row, int mi_col, - int mi_row_top, int mi_col_top, - uint8_t * dst_buf[3], int dst_stride[3]) { + BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, int mi_row, + int mi_col, int mi_row_top, int mi_col_top, + uint8_t *dst_buf[3], int dst_stride[3]) { dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col, mi_row_top, mi_col_top, dst_buf, dst_stride, 0); dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row, mi_col, @@ -729,9 +700,8 @@ static void dec_extend_all(VP10Decoder *const pbi, MACROBLOCKD *const xd, static void dec_predict_sb_complex(VP10Decoder *const pbi, MACROBLOCKD *const xd, - const TileInfo *const tile, - int mi_row, int mi_col, - int mi_row_top, int mi_col_top, + const TileInfo *const tile, int mi_row, + int mi_col, int mi_row_top, int mi_col_top, BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, uint8_t *dst_buf[3], int dst_stride[3]) { const VP10_COMMON *const cm = &pbi->common; @@ -745,15 +715,12 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, const int mi_offset = mi_row * cm->mi_stride + mi_col; uint8_t *dst_buf1[3], *dst_buf2[3], *dst_buf3[3]; - DECLARE_ALIGNED(16, uint8_t, - tmp_buf1[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); - DECLARE_ALIGNED(16, uint8_t, - tmp_buf2[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); - DECLARE_ALIGNED(16, uint8_t, - tmp_buf3[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); - int dst_stride1[3] = {MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE}; - int dst_stride2[3] = {MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE}; - int dst_stride3[3] = {MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE}; + DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); + DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); + DECLARE_ALIGNED(16, uint8_t, tmp_buf3[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); + int dst_stride1[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE }; + int dst_stride2[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE }; + int dst_stride3[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE }; #if CONFIG_VP9_HIGHBITDEPTH if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { @@ -782,8 +749,7 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, } #endif - if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) - return; + if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return; xd->mi = cm->mi_grid_visible + mi_offset; xd->mi[0] = cm->mi + mi_offset; @@ -824,13 +790,10 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, // weighted average to smooth the boundary xd->plane[0].dst.buf = dst_buf[0]; xd->plane[0].dst.stride = dst_stride[0]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[0], dst_stride[0], - dst_buf1[0], dst_stride1[0], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_HORZ, 0); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[0], dst_stride[0], dst_buf1[0], dst_stride1[0], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, + 0); } else { // First half dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, @@ -846,20 +809,16 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, if (mi_row + hbs < cm->mi_rows) { // Second half dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, - mi_row + hbs, mi_col, - mi_row_top, mi_col_top, - dst_buf1, dst_stride1, - top_bsize, subsize, 0, 0); + mi_row + hbs, mi_col, mi_row_top, mi_col_top, + dst_buf1, dst_stride1, top_bsize, subsize, 0, 0); if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col, - mi_row_top, mi_col_top, - dst_buf1, dst_stride1); + dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row + hbs, + mi_col, mi_row_top, mi_col_top, dst_buf1, + dst_stride1); else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col, - mi_row_top, mi_col_top, - dst_buf1, dst_stride1, 1); + dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row + hbs, + mi_col, mi_row_top, mi_col_top, dst_buf1, + dst_stride1, 1); // weighted average to smooth the boundary for (i = 0; i < MAX_MB_PLANE; i++) { @@ -867,8 +826,8 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, xd->plane[i].dst.stride = dst_stride[i]; vp10_build_masked_inter_predictor_complex( xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], - mi_row, mi_col, mi_row_top, mi_col_top, - bsize, top_bsize, PARTITION_HORZ, i); + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_HORZ, i); } } } @@ -894,13 +853,10 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, // Smooth xd->plane[0].dst.buf = dst_buf[0]; xd->plane[0].dst.stride = dst_stride[0]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[0], dst_stride[0], - dst_buf1[0], dst_stride1[0], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_VERT, 0); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[0], dst_stride[0], dst_buf1[0], dst_stride1[0], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, + 0); } else { // First half dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, @@ -915,17 +871,17 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, // Second half if (mi_col + hbs < cm->mi_cols) { - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf1, dst_stride1, top_bsize, subsize, 0, 0); + dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, mi_row, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, + dst_stride1, top_bsize, subsize, 0, 0); if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf1, dst_stride1); + dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, + dst_stride1); else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf1, dst_stride1, 2); + dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, + dst_stride1, 2); // Smooth for (i = 0; i < MAX_MB_PLANE; i++) { @@ -933,8 +889,8 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, xd->plane[i].dst.stride = dst_stride[i]; vp10_build_masked_inter_predictor_complex( xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], - mi_row, mi_col, mi_row_top, mi_col_top, - bsize, top_bsize, PARTITION_VERT, i); + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_VERT, i); } } } @@ -964,9 +920,9 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, mi_row_top, mi_col_top, dst_buf3, dst_stride3); } } else { - dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col, - mi_row_top, mi_col_top, subsize, top_bsize, - dst_buf, dst_stride); + dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col, mi_row_top, + mi_col_top, subsize, top_bsize, dst_buf, + dst_stride); if (mi_row < cm->mi_rows && mi_col + hbs < cm->mi_cols) dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col + hbs, mi_row_top, mi_col_top, subsize, top_bsize, @@ -980,50 +936,31 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, mi_row_top, mi_col_top, subsize, top_bsize, dst_buf3, dst_stride3); } - for (i = 0; i < MAX_MB_PLANE; i++) { - if (bsize == BLOCK_8X8 && i != 0) - continue; // Skip <4x4 chroma smoothing - if (mi_row < cm->mi_rows && mi_col + hbs < cm->mi_cols) { - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], dst_stride[i], - dst_buf1[i], - dst_stride1[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_VERT, i); - if (mi_row + hbs < cm->mi_rows) { - vp10_build_masked_inter_predictor_complex(xd, - dst_buf2[i], - dst_stride2[i], - dst_buf3[i], - dst_stride3[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_VERT, i); - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], - dst_stride[i], - dst_buf2[i], - dst_stride2[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_HORZ, i); - } - } else if (mi_row + hbs < cm->mi_rows && mi_col < cm->mi_cols) { - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], - dst_stride[i], - dst_buf2[i], - dst_stride2[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_HORZ, i); + for (i = 0; i < MAX_MB_PLANE; i++) { + if (bsize == BLOCK_8X8 && i != 0) + continue; // Skip <4x4 chroma smoothing + if (mi_row < cm->mi_rows && mi_col + hbs < cm->mi_cols) { + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_VERT, i); + if (mi_row + hbs < cm->mi_rows) { + vp10_build_masked_inter_predictor_complex( + xd, dst_buf2[i], dst_stride2[i], dst_buf3[i], dst_stride3[i], + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_VERT, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_HORZ, i); } + } else if (mi_row + hbs < cm->mi_rows && mi_col < cm->mi_cols) { + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_HORZ, i); } + } break; #if CONFIG_EXT_PARTITION_TYPES case PARTITION_HORZ_A: @@ -1034,42 +971,35 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, mi_row_top, mi_col_top, dst_buf, dst_stride); dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, mi_row, - mi_col + hbs, mi_row_top, mi_col_top, - dst_buf1, dst_stride1, top_bsize, bsize2, 0, 0); + mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, + dst_stride1, top_bsize, bsize2, 0, 0); dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row, mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, dst_stride1); - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, - mi_row + hbs, mi_col, mi_row_top, mi_col_top, - dst_buf2, dst_stride2, top_bsize, subsize, 0, 0); + dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, mi_row + hbs, + mi_col, mi_row_top, mi_col_top, dst_buf2, + dst_stride2, top_bsize, subsize, 0, 0); if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col, mi_row_top, mi_col_top, - dst_buf2, dst_stride2); + dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row + hbs, + mi_col, mi_row_top, mi_col_top, dst_buf2, dst_stride2); else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col, mi_row_top, mi_col_top, - dst_buf2, dst_stride2, 1); + dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row + hbs, + mi_col, mi_row_top, mi_col_top, dst_buf2, dst_stride2, + 1); for (i = 0; i < MAX_MB_PLANE; i++) { xd->plane[i].dst.buf = dst_buf[i]; xd->plane[i].dst.stride = dst_stride[i]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], dst_stride[i], - dst_buf1[i], dst_stride1[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_VERT, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, + i); } for (i = 0; i < MAX_MB_PLANE; i++) { - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], dst_stride[i], - dst_buf2[i], dst_stride2[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_HORZ, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, + i); } break; case PARTITION_VERT_A: @@ -1080,44 +1010,37 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row, mi_col, mi_row_top, mi_col_top, dst_buf, dst_stride); - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, - mi_row + hbs, mi_col, mi_row_top, mi_col_top, - dst_buf1, dst_stride1, top_bsize, bsize2, 0, 0); + dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, mi_row + hbs, + mi_col, mi_row_top, mi_col_top, dst_buf1, + dst_stride1, top_bsize, bsize2, 0, 0); dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, mi_col, mi_row_top, mi_col_top, dst_buf1, dst_stride1); - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf2, dst_stride2, - top_bsize, subsize, 0, 0); + dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, mi_row, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, + dst_stride2, top_bsize, subsize, 0, 0); if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf2, dst_stride2); + dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, + dst_stride2); else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf2, dst_stride2, 2); + dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, + dst_stride2, 2); for (i = 0; i < MAX_MB_PLANE; i++) { xd->plane[i].dst.buf = dst_buf[i]; xd->plane[i].dst.stride = dst_stride[i]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], dst_stride[i], - dst_buf1[i], dst_stride1[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_HORZ, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, + i); } for (i = 0; i < MAX_MB_PLANE; i++) { - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], dst_stride[i], - dst_buf2[i], dst_stride2[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_VERT, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, + i); } break; case PARTITION_HORZ_B: @@ -1132,39 +1055,33 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, mi_row_top, mi_col_top, dst_buf, dst_stride, 0); dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, mi_row + hbs, - mi_col, mi_row_top, mi_col_top, - dst_buf1, dst_stride1, top_bsize, bsize2, 0, 0); + mi_col, mi_row_top, mi_col_top, dst_buf1, + dst_stride1, top_bsize, bsize2, 0, 0); dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, mi_col, mi_row_top, mi_col_top, dst_buf1, dst_stride1); dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col + hbs, mi_row + hbs, mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, dst_stride2, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, - mi_row + hbs, mi_col + hbs, - mi_row_top, mi_col_top, dst_buf2, dst_stride2); + dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, + dst_stride2); for (i = 0; i < MAX_MB_PLANE; i++) { xd->plane[i].dst.buf = dst_buf1[i]; xd->plane[i].dst.stride = dst_stride1[i]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf1[i], dst_stride1[i], - dst_buf2[i], dst_stride2[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_VERT, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf1[i], dst_stride1[i], dst_buf2[i], dst_stride2[i], + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_VERT, i); } for (i = 0; i < MAX_MB_PLANE; i++) { xd->plane[i].dst.buf = dst_buf[i]; xd->plane[i].dst.stride = dst_stride[i]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], dst_stride[i], - dst_buf1[i], dst_stride1[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_HORZ, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, + i); } break; case PARTITION_VERT_B: @@ -1178,45 +1095,38 @@ static void dec_predict_sb_complex(VP10Decoder *const pbi, dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, mi_row_top, mi_col_top, dst_buf, dst_stride, 3); - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf1, dst_stride1, top_bsize, bsize2, 0, 0); + dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, mi_row, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, + dst_stride1, top_bsize, bsize2, 0, 0); dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row, mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, dst_stride1); dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col + hbs, mi_row + hbs, mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, dst_stride2, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, - mi_row + hbs, mi_col + hbs, - mi_row_top, mi_col_top, dst_buf2, dst_stride2); + dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, + mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, + dst_stride2); for (i = 0; i < MAX_MB_PLANE; i++) { xd->plane[i].dst.buf = dst_buf1[i]; xd->plane[i].dst.stride = dst_stride1[i]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf1[i], dst_stride1[i], - dst_buf2[i], dst_stride2[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_HORZ, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf1[i], dst_stride1[i], dst_buf2[i], dst_stride2[i], + mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, + PARTITION_HORZ, i); } for (i = 0; i < MAX_MB_PLANE; i++) { xd->plane[i].dst.buf = dst_buf[i]; xd->plane[i].dst.stride = dst_stride[i]; - vp10_build_masked_inter_predictor_complex(xd, - dst_buf[i], dst_stride[i], - dst_buf1[i], dst_stride1[i], - mi_row, mi_col, - mi_row_top, mi_col_top, - bsize, top_bsize, - PARTITION_VERT, i); + vp10_build_masked_inter_predictor_complex( + xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, + mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, + i); } break; #endif // CONFIG_EXT_PARTITION_TYPES - default: - assert(0); + default: assert(0); } } @@ -1237,16 +1147,16 @@ static void set_segment_id_supertx(const VP10_COMMON *const cm, seg_id_supertx = 0; } else { // Find the minimum segment_id - for (r = 0 ; r < mih ; r++) - for (c = 0 ; c < miw ; c++) - seg_id_supertx = VPXMIN(mip[r * cm->mi_stride + c]->mbmi.segment_id, - seg_id_supertx); + for (r = 0; r < mih; r++) + for (c = 0; c < miw; c++) + seg_id_supertx = + VPXMIN(mip[r * cm->mi_stride + c]->mbmi.segment_id, seg_id_supertx); assert(0 <= seg_id_supertx && seg_id_supertx < MAX_SEGMENTS); } // Assign the the segment_id back to segment_id_supertx - for (r = 0 ; r < mih ; r++) - for (c = 0 ; c < miw ; c++) + for (r = 0; r < mih; r++) + for (c = 0; c < miw; c++) mip[r * cm->mi_stride + c]->mbmi.segment_id_supertx = seg_id_supertx; } #endif // CONFIG_SUPERTX @@ -1255,13 +1165,11 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, #if CONFIG_SUPERTX int supertx_enabled, #endif // CONFIG_SUPERTX - int mi_row, int mi_col, - vp10_reader *r, + int mi_row, int mi_col, vp10_reader *r, #if CONFIG_EXT_PARTITION_TYPES PARTITION_TYPE partition, #endif // CONFIG_EXT_PARTITION_TYPES - BLOCK_SIZE bsize, - int bwl, int bhl) { + BLOCK_SIZE bsize, int bwl, int bhl) { VP10_COMMON *const cm = &pbi->common; const int less8x8 = bsize < BLOCK_8X8; const int bw = 1 << (bwl - 1); @@ -1272,20 +1180,19 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, #if CONFIG_SUPERTX MB_MODE_INFO *mbmi; if (supertx_enabled) { - mbmi = set_mb_offsets(cm, xd, bsize, mi_row, mi_col, - bw, bh, x_mis, y_mis); + mbmi = set_mb_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis); } else { - mbmi = set_offsets(cm, xd, bsize, mi_row, mi_col, - bw, bh, x_mis, y_mis, bwl, bhl); + mbmi = set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis, bwl, + bhl); } #if CONFIG_EXT_PARTITION_TYPES xd->mi[0]->mbmi.partition = partition; #endif - vp10_read_mode_info(pbi, xd, supertx_enabled, - mi_row, mi_col, r, x_mis, y_mis); + vp10_read_mode_info(pbi, xd, supertx_enabled, mi_row, mi_col, r, x_mis, + y_mis); #else - MB_MODE_INFO *mbmi = set_offsets(cm, xd, bsize, mi_row, mi_col, - bw, bh, x_mis, y_mis, bwl, bhl); + MB_MODE_INFO *mbmi = set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, + y_mis, bwl, bhl); #if CONFIG_EXT_PARTITION_TYPES xd->mi[0]->mbmi.partition = partition; #endif @@ -1296,8 +1203,8 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, const BLOCK_SIZE uv_subsize = ss_size_lookup[bsize][cm->subsampling_x][cm->subsampling_y]; if (uv_subsize == BLOCK_INVALID) - vpx_internal_error(xd->error_info, - VPX_CODEC_CORRUPT_FRAME, "Invalid block size."); + vpx_internal_error(xd->error_info, VPX_CODEC_CORRUPT_FRAME, + "Invalid block size."); } #if CONFIG_SUPERTX @@ -1322,25 +1229,25 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, const struct macroblockd_plane *const pd = &xd->plane[plane]; const TX_SIZE tx_size = plane ? dec_get_uv_tx_size(mbmi, pd->n4_wl, pd->n4_hl) - : mbmi->tx_size; + : mbmi->tx_size; const int num_4x4_w = pd->n4_w; const int num_4x4_h = pd->n4_h; const int stepr = num_4x4_blocks_high_txsize_lookup[tx_size]; const int stepc = num_4x4_blocks_wide_txsize_lookup[tx_size]; int row, col; - const int max_blocks_wide = num_4x4_w + - (xd->mb_to_right_edge >= 0 ? - 0 : xd->mb_to_right_edge >> (5 + pd->subsampling_x)); - const int max_blocks_high = num_4x4_h + - (xd->mb_to_bottom_edge >= 0 ? - 0 : xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); + const int max_blocks_wide = + num_4x4_w + (xd->mb_to_right_edge >= 0 + ? 0 + : xd->mb_to_right_edge >> (5 + pd->subsampling_x)); + const int max_blocks_high = + num_4x4_h + (xd->mb_to_bottom_edge >= 0 + ? 0 + : xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); for (row = 0; row < max_blocks_high; row += stepr) for (col = 0; col < max_blocks_wide; col += stepc) - predict_and_reconstruct_intra_block(xd, - r, - mbmi, plane, - row, col, tx_size); + predict_and_reconstruct_intra_block(xd, r, mbmi, plane, row, col, + tx_size); } } else { // Prediction @@ -1349,23 +1256,19 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, #if CONFIG_OBMC if (mbmi->motion_variation == OBMC_CAUSAL) { #if CONFIG_VP9_HIGHBITDEPTH - DECLARE_ALIGNED(16, uint8_t, - tmp_buf1[2 * MAX_MB_PLANE * MAX_SB_SQUARE]); - DECLARE_ALIGNED(16, uint8_t, - tmp_buf2[2 * MAX_MB_PLANE * MAX_SB_SQUARE]); + DECLARE_ALIGNED(16, uint8_t, tmp_buf1[2 * MAX_MB_PLANE * MAX_SB_SQUARE]); + DECLARE_ALIGNED(16, uint8_t, tmp_buf2[2 * MAX_MB_PLANE * MAX_SB_SQUARE]); #else - DECLARE_ALIGNED(16, uint8_t, - tmp_buf1[MAX_MB_PLANE * MAX_SB_SQUARE]); - DECLARE_ALIGNED(16, uint8_t, - tmp_buf2[MAX_MB_PLANE * MAX_SB_SQUARE]); + DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * MAX_SB_SQUARE]); + DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * MAX_SB_SQUARE]); #endif // CONFIG_VP9_HIGHBITDEPTH uint8_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE]; - int dst_width1[MAX_MB_PLANE] = {MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE}; - int dst_width2[MAX_MB_PLANE] = {MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE}; - int dst_height1[MAX_MB_PLANE] = {MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE}; - int dst_height2[MAX_MB_PLANE] = {MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE}; - int dst_stride1[MAX_MB_PLANE] = {MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE}; - int dst_stride2[MAX_MB_PLANE] = {MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE}; + int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; + int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; + int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; + int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; + int dst_stride1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; + int dst_stride2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; assert(mbmi->sb_type >= BLOCK_8X8); #if CONFIG_VP9_HIGHBITDEPTH @@ -1388,17 +1291,15 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, #if CONFIG_VP9_HIGHBITDEPTH } #endif // CONFIG_VP9_HIGHBITDEPTH - vp10_build_prediction_by_above_preds(cm, xd, mi_row, mi_col, - dst_buf1, dst_width1, - dst_height1, dst_stride1); - vp10_build_prediction_by_left_preds(cm, xd, mi_row, mi_col, - dst_buf2, dst_width2, - dst_height2, dst_stride2); - vp10_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), - mi_row, mi_col); - vp10_build_obmc_inter_prediction(cm, xd, mi_row, mi_col, - dst_buf1, dst_stride1, - dst_buf2, dst_stride2); + vp10_build_prediction_by_above_preds(cm, xd, mi_row, mi_col, dst_buf1, + dst_width1, dst_height1, + dst_stride1); + vp10_build_prediction_by_left_preds(cm, xd, mi_row, mi_col, dst_buf2, + dst_width2, dst_height2, dst_stride2); + vp10_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, + mi_col); + vp10_build_obmc_inter_prediction(cm, xd, mi_row, mi_col, dst_buf1, + dst_stride1, dst_buf2, dst_stride2); } #endif // CONFIG_OBMC @@ -1414,11 +1315,11 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, int row, col; #if CONFIG_VAR_TX // TODO(jingning): This can be simplified for decoder performance. - const BLOCK_SIZE plane_bsize = get_plane_block_size( - VPXMAX(bsize, BLOCK_8X8), pd); + const BLOCK_SIZE plane_bsize = + get_plane_block_size(VPXMAX(bsize, BLOCK_8X8), pd); #if CONFIG_EXT_TX && CONFIG_RECT_TX - const TX_SIZE max_tx_size = plane ? - max_txsize_lookup[plane_bsize] : max_txsize_rect_lookup[plane_bsize]; + const TX_SIZE max_tx_size = plane ? max_txsize_lookup[plane_bsize] + : max_txsize_rect_lookup[plane_bsize]; #else const TX_SIZE max_tx_size = max_txsize_lookup[plane_bsize]; #endif // CONFIG_EXT_TX && CONFIG_RECT_TX @@ -1429,31 +1330,30 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, for (row = 0; row < num_4x4_h; row += bh) { for (col = 0; col < num_4x4_w; col += bw) { - decode_reconstruct_tx(xd, r, mbmi, plane, plane_bsize, - block, row, col, max_tx_size, &eobtotal); + decode_reconstruct_tx(xd, r, mbmi, plane, plane_bsize, block, row, + col, max_tx_size, &eobtotal); block += step; } } #else const TX_SIZE tx_size = plane ? dec_get_uv_tx_size(mbmi, pd->n4_wl, pd->n4_hl) - : mbmi->tx_size; + : mbmi->tx_size; const int stepr = num_4x4_blocks_high_txsize_lookup[tx_size]; const int stepc = num_4x4_blocks_wide_txsize_lookup[tx_size]; - const int max_blocks_wide = num_4x4_w + - (xd->mb_to_right_edge >= 0 ? - 0 : xd->mb_to_right_edge >> (5 + pd->subsampling_x)); - const int max_blocks_high = num_4x4_h + - (xd->mb_to_bottom_edge >= 0 ? - 0 : xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); + const int max_blocks_wide = + num_4x4_w + (xd->mb_to_right_edge >= 0 + ? 0 + : xd->mb_to_right_edge >> (5 + pd->subsampling_x)); + const int max_blocks_high = + num_4x4_h + + (xd->mb_to_bottom_edge >= 0 ? 0 : xd->mb_to_bottom_edge >> + (5 + pd->subsampling_y)); for (row = 0; row < max_blocks_high; row += stepr) for (col = 0; col < max_blocks_wide; col += stepc) - eobtotal += reconstruct_inter_block(xd, - r, - mbmi->segment_id, - plane, row, col, - tx_size); + eobtotal += reconstruct_inter_block(xd, r, mbmi->segment_id, plane, + row, col, tx_size); #endif } @@ -1465,27 +1365,25 @@ static void decode_block(VP10Decoder *const pbi, MACROBLOCKD *const xd, xd->corrupted |= vp10_reader_has_error(r); } -static INLINE int dec_partition_plane_context(const MACROBLOCKD *xd, - int mi_row, int mi_col, - int bsl) { +static INLINE int dec_partition_plane_context(const MACROBLOCKD *xd, int mi_row, + int mi_col, int bsl) { const PARTITION_CONTEXT *above_ctx = xd->above_seg_context + mi_col; const PARTITION_CONTEXT *left_ctx = - xd->left_seg_context + (mi_row & MAX_MIB_MASK); - int above = (*above_ctx >> bsl) & 1 , left = (*left_ctx >> bsl) & 1; + xd->left_seg_context + (mi_row & MAX_MIB_MASK); + int above = (*above_ctx >> bsl) & 1, left = (*left_ctx >> bsl) & 1; -// assert(bsl >= 0); + // assert(bsl >= 0); return (left * 2 + above) + bsl * PARTITION_PLOFFSET; } #if !CONFIG_EXT_PARTITION_TYPES -static INLINE void dec_update_partition_context(MACROBLOCKD *xd, - int mi_row, int mi_col, - BLOCK_SIZE subsize, +static INLINE void dec_update_partition_context(MACROBLOCKD *xd, int mi_row, + int mi_col, BLOCK_SIZE subsize, int bw) { PARTITION_CONTEXT *const above_ctx = xd->above_seg_context + mi_col; PARTITION_CONTEXT *const left_ctx = - xd->left_seg_context + (mi_row & MAX_MIB_MASK); + xd->left_seg_context + (mi_row & MAX_MIB_MASK); // update the partition context at the end notes. set partition bits // of block sizes larger than the current one to be one, and partition @@ -1523,23 +1421,21 @@ static PARTITION_TYPE read_partition(VP10_COMMON *cm, MACROBLOCKD *xd, else p = PARTITION_SPLIT; - if (counts) - ++counts->partition[ctx][p]; + if (counts) ++counts->partition[ctx][p]; return p; } #if CONFIG_SUPERTX -static int read_skip(VP10_COMMON *cm, const MACROBLOCKD *xd, - int segment_id, vp10_reader *r) { +static int read_skip(VP10_COMMON *cm, const MACROBLOCKD *xd, int segment_id, + vp10_reader *r) { if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) { return 1; } else { const int ctx = vp10_get_skip_context(xd); const int skip = vp10_read(r, cm->fc->skip_probs[ctx]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->skip[ctx][skip]; + if (counts) ++counts->skip[ctx][skip]; return skip; } } @@ -1550,8 +1446,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #if CONFIG_SUPERTX int supertx_enabled, #endif - int mi_row, int mi_col, - vp10_reader* r, + int mi_row, int mi_col, vp10_reader *r, BLOCK_SIZE bsize, int n4x4_l2) { VP10_COMMON *const cm = &pbi->common; const int n8x8_l2 = n4x4_l2 - 1; @@ -1572,8 +1467,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, int txfm = DCT_DCT; #endif // CONFIG_SUPERTX - if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) - return; + if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return; partition = read_partition(cm, xd, mi_row, mi_col, r, has_rows, has_cols, #if CONFIG_EXT_PARTITION_TYPES @@ -1582,20 +1476,15 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, n8x8_l2); subsize = subsize_lookup[partition][bsize]; // get_subsize(bsize, partition); #if CONFIG_SUPERTX - if (!frame_is_intra_only(cm) && - partition != PARTITION_NONE && - bsize <= MAX_SUPERTX_BLOCK_SIZE && - !supertx_enabled && - !xd->lossless[0]) { - const int supertx_context = - partition_supertx_context_lookup[partition]; - supertx_enabled = vp10_read( - r, cm->fc->supertx_prob[supertx_context][supertx_size]); + if (!frame_is_intra_only(cm) && partition != PARTITION_NONE && + bsize <= MAX_SUPERTX_BLOCK_SIZE && !supertx_enabled && !xd->lossless[0]) { + const int supertx_context = partition_supertx_context_lookup[partition]; + supertx_enabled = + vp10_read(r, cm->fc->supertx_prob[supertx_context][supertx_size]); if (xd->counts) xd->counts->supertx[supertx_context][supertx_size][supertx_enabled]++; #if CONFIG_VAR_TX - if (supertx_enabled) - xd->supertx_size = supertx_size; + if (supertx_enabled) xd->supertx_size = supertx_size; #endif } #endif // CONFIG_SUPERTX @@ -1621,7 +1510,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #endif // CONFIG_SUPERTX mi_row, mi_col, r, #if CONFIG_EXT_PARTITION_TYPES - partition, + partition, #endif // CONFIG_EXT_PARTITION_TYPES subsize, n4x4_l2, n4x4_l2); break; @@ -1632,7 +1521,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #endif // CONFIG_SUPERTX mi_row, mi_col, r, #if CONFIG_EXT_PARTITION_TYPES - partition, + partition, #endif // CONFIG_EXT_PARTITION_TYPES subsize, n4x4_l2, n8x8_l2); if (has_rows) @@ -1642,7 +1531,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #endif // CONFIG_SUPERTX mi_row + hbs, mi_col, r, #if CONFIG_EXT_PARTITION_TYPES - partition, + partition, #endif // CONFIG_EXT_PARTITION_TYPES subsize, n4x4_l2, n8x8_l2); break; @@ -1653,7 +1542,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #endif // CONFIG_SUPERTX mi_row, mi_col, r, #if CONFIG_EXT_PARTITION_TYPES - partition, + partition, #endif // CONFIG_EXT_PARTITION_TYPES subsize, n8x8_l2, n4x4_l2); if (has_cols) @@ -1663,7 +1552,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #endif // CONFIG_SUPERTX mi_row, mi_col + hbs, r, #if CONFIG_EXT_PARTITION_TYPES - partition, + partition, #endif // CONFIG_EXT_PARTITION_TYPES subsize, n8x8_l2, n4x4_l2); break; @@ -1672,26 +1561,22 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #if CONFIG_SUPERTX supertx_enabled, #endif // CONFIG_SUPERTX - mi_row, mi_col, r, - subsize, n8x8_l2); + mi_row, mi_col, r, subsize, n8x8_l2); decode_partition(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif // CONFIG_SUPERTX - mi_row, mi_col + hbs, r, - subsize, n8x8_l2); + mi_row, mi_col + hbs, r, subsize, n8x8_l2); decode_partition(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif // CONFIG_SUPERTX - mi_row + hbs, mi_col, r, - subsize, n8x8_l2); + mi_row + hbs, mi_col, r, subsize, n8x8_l2); decode_partition(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif // CONFIG_SUPERTX - mi_row + hbs, mi_col + hbs, r, - subsize, n8x8_l2); + mi_row + hbs, mi_col + hbs, r, subsize, n8x8_l2); break; #if CONFIG_EXT_PARTITION_TYPES case PARTITION_HORZ_A: @@ -1699,84 +1584,79 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row, mi_col, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row, mi_col, r, partition, bsize2, n8x8_l2, n8x8_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row, mi_col + hbs, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row, mi_col + hbs, r, partition, bsize2, n8x8_l2, + n8x8_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row + hbs, mi_col, r, - partition, subsize, n4x4_l2, n8x8_l2); + mi_row + hbs, mi_col, r, partition, subsize, n4x4_l2, + n8x8_l2); break; case PARTITION_HORZ_B: decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row, mi_col, r, - partition, subsize, n4x4_l2, n8x8_l2); + mi_row, mi_col, r, partition, subsize, n4x4_l2, n8x8_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row + hbs, mi_col, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row + hbs, mi_col, r, partition, bsize2, n8x8_l2, + n8x8_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row + hbs, mi_col + hbs, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row + hbs, mi_col + hbs, r, partition, bsize2, n8x8_l2, + n8x8_l2); break; case PARTITION_VERT_A: decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row, mi_col, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row, mi_col, r, partition, bsize2, n8x8_l2, n8x8_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row + hbs, mi_col, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row + hbs, mi_col, r, partition, bsize2, n8x8_l2, + n8x8_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row, mi_col + hbs, r, - partition, subsize, n8x8_l2, n4x4_l2); + mi_row, mi_col + hbs, r, partition, subsize, n8x8_l2, + n4x4_l2); break; case PARTITION_VERT_B: decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row, mi_col, r, - partition, subsize, n8x8_l2, n4x4_l2); + mi_row, mi_col, r, partition, subsize, n8x8_l2, n4x4_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row, mi_col + hbs, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row, mi_col + hbs, r, partition, bsize2, n8x8_l2, + n8x8_l2); decode_block(pbi, xd, #if CONFIG_SUPERTX supertx_enabled, #endif - mi_row + hbs, mi_col + hbs, r, - partition, bsize2, n8x8_l2, n8x8_l2); + mi_row + hbs, mi_col + hbs, r, partition, bsize2, n8x8_l2, + n8x8_l2); break; #endif - default: - assert(0 && "Invalid partition type"); + default: assert(0 && "Invalid partition type"); } } @@ -1790,9 +1670,8 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, xd->mi = cm->mi_grid_visible + offset; xd->mi[0] = cm->mi + offset; - set_mi_row_col(xd, tile, mi_row, num_8x8_blocks_high_lookup[bsize], - mi_col, num_8x8_blocks_wide_lookup[bsize], - cm->mi_rows, cm->mi_cols); + set_mi_row_col(xd, tile, mi_row, num_8x8_blocks_high_lookup[bsize], mi_col, + num_8x8_blocks_wide_lookup[bsize], cm->mi_rows, cm->mi_cols); set_skip_context(xd, mi_row, mi_col); skip = read_skip(cm, xd, xd->mi[0]->mbmi.segment_id_supertx, r); if (skip) { @@ -1803,29 +1682,26 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, int eset = get_ext_tx_set(supertx_size, bsize, 1); if (eset > 0) { txfm = vp10_read_tree(r, vp10_ext_tx_inter_tree[eset], - cm->fc->inter_ext_tx_prob[eset][supertx_size]); - if (xd->counts) - ++xd->counts->inter_ext_tx[eset][supertx_size][txfm]; + cm->fc->inter_ext_tx_prob[eset][supertx_size]); + if (xd->counts) ++xd->counts->inter_ext_tx[eset][supertx_size][txfm]; } } #else if (supertx_size < TX_32X32) { txfm = vp10_read_tree(r, vp10_ext_tx_tree, - cm->fc->inter_ext_tx_prob[supertx_size]); - if (xd->counts) - ++xd->counts->inter_ext_tx[supertx_size][txfm]; + cm->fc->inter_ext_tx_prob[supertx_size]); + if (xd->counts) ++xd->counts->inter_ext_tx[supertx_size][txfm]; } #endif // CONFIG_EXT_TX } - vp10_setup_dst_planes(xd->plane, get_frame_new_buffer(cm), mi_row, mi_col); for (i = 0; i < MAX_MB_PLANE; i++) { dst_buf[i] = xd->plane[i].dst.buf; dst_stride[i] = xd->plane[i].dst.stride; } - dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col, mi_row, mi_col, - bsize, bsize, dst_buf, dst_stride); + dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col, mi_row, mi_col, bsize, + bsize, dst_buf, dst_stride); if (!skip) { int eobtotal = 0; @@ -1840,27 +1716,24 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, const int num_4x4_h = pd->n4_h; int row, col; const TX_SIZE tx_size = - i ? dec_get_uv_tx_size(mbmi, pd->n4_wl, pd->n4_hl) - : mbmi->tx_size; + i ? dec_get_uv_tx_size(mbmi, pd->n4_wl, pd->n4_hl) : mbmi->tx_size; const int stepr = num_4x4_blocks_high_txsize_lookup[tx_size]; const int stepc = num_4x4_blocks_wide_txsize_lookup[tx_size]; - const int max_blocks_wide = num_4x4_w + - (xd->mb_to_right_edge >= 0 ? - 0 : xd->mb_to_right_edge >> (5 + pd->subsampling_x)); - const int max_blocks_high = num_4x4_h + - (xd->mb_to_bottom_edge >= 0 ? - 0 : xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); + const int max_blocks_wide = + num_4x4_w + (xd->mb_to_right_edge >= 0 + ? 0 + : xd->mb_to_right_edge >> (5 + pd->subsampling_x)); + const int max_blocks_high = + num_4x4_h + + (xd->mb_to_bottom_edge >= 0 ? 0 : xd->mb_to_bottom_edge >> + (5 + pd->subsampling_y)); for (row = 0; row < max_blocks_high; row += stepr) for (col = 0; col < max_blocks_wide; col += stepc) - eobtotal += reconstruct_inter_block(xd, - r, - mbmi->segment_id_supertx, - i, row, col, - tx_size); + eobtotal += reconstruct_inter_block(xd, r, mbmi->segment_id_supertx, + i, row, col, tx_size); } - if (!(subsize < BLOCK_8X8) && eobtotal == 0) - skip = 1; + if (!(subsize < BLOCK_8X8) && eobtotal == 0) skip = 1; } set_param_topblock(cm, xd, bsize, mi_row, mi_col, txfm, skip); } @@ -1870,8 +1743,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, if (bsize >= BLOCK_8X8) { switch (partition) { case PARTITION_SPLIT: - if (bsize > BLOCK_8X8) - break; + if (bsize > BLOCK_8X8) break; case PARTITION_NONE: case PARTITION_HORZ: case PARTITION_VERT: @@ -1893,8 +1765,7 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, update_partition_context(xd, mi_row, mi_col, subsize, subsize); update_partition_context(xd, mi_row, mi_col + hbs, bsize2, subsize); break; - default: - assert(0 && "Invalid partition type"); + default: assert(0 && "Invalid partition type"); } } #else @@ -1906,12 +1777,10 @@ static void decode_partition(VP10Decoder *const pbi, MACROBLOCKD *const xd, } #if !CONFIG_ANS -static void setup_bool_decoder(const uint8_t *data, - const uint8_t *data_end, +static void setup_bool_decoder(const uint8_t *data, const uint8_t *data_end, const size_t read_size, struct vpx_internal_error_info *error_info, - vp10_reader *r, - vpx_decrypt_cb decrypt_cb, + vp10_reader *r, vpx_decrypt_cb decrypt_cb, void *decrypt_state) { // Validate the calculated partition length. If the buffer // described by the partition can't be fully read, then restrict @@ -1925,15 +1794,14 @@ static void setup_bool_decoder(const uint8_t *data, "Failed to allocate bool decoder %d", 1); } #else -static void setup_token_decoder(const uint8_t *data, - const uint8_t *data_end, +static void setup_token_decoder(const uint8_t *data, const uint8_t *data_end, const size_t read_size, struct vpx_internal_error_info *error_info, struct AnsDecoder *const ans, vpx_decrypt_cb decrypt_cb, void *decrypt_state) { - (void) decrypt_cb; - (void) decrypt_state; + (void)decrypt_cb; + (void)decrypt_state; // Validate the calculated partition length. If the buffer // described by the partition can't be fully read, then restrict // it to the portion that can be (for EC mode) or throw an error. @@ -1962,12 +1830,12 @@ static void read_coef_probs_common(vp10_coeff_probs_model *coef_probs, static void read_coef_probs(FRAME_CONTEXT *fc, TX_MODE tx_mode, vp10_reader *r) { - const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode]; - TX_SIZE tx_size; - for (tx_size = TX_4X4; tx_size <= max_tx_size; ++tx_size) - read_coef_probs_common(fc->coef_probs[tx_size], r); + const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode]; + TX_SIZE tx_size; + for (tx_size = TX_4X4; tx_size <= max_tx_size; ++tx_size) + read_coef_probs_common(fc->coef_probs[tx_size], r); #if CONFIG_ANS - vp10_coef_pareto_cdfs(fc); + vp10_coef_pareto_cdfs(fc); #endif // CONFIG_ANS } @@ -1980,8 +1848,7 @@ static void setup_segmentation(VP10_COMMON *const cm, seg->update_data = 0; seg->enabled = vpx_rb_read_bit(rb); - if (!seg->enabled) - return; + if (!seg->enabled) return; // Segmentation map update if (frame_is_intra_only(cm) || cm->error_resilient_mode) { @@ -2021,8 +1888,7 @@ static void setup_segmentation(VP10_COMMON *const cm, } #if CONFIG_LOOP_RESTORATION -static void setup_restoration(VP10_COMMON *cm, - struct vpx_read_bit_buffer *rb) { +static void setup_restoration(VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) { RestorationInfo *rst = &cm->rst_info; if (vpx_rb_read_bit(rb)) { if (vpx_rb_read_bit(rb)) { @@ -2032,17 +1898,17 @@ static void setup_restoration(VP10_COMMON *cm, } else { rst->restoration_type = RESTORE_WIENER; rst->vfilter[0] = vpx_rb_read_literal(rb, WIENER_FILT_TAP0_BITS) + - WIENER_FILT_TAP0_MINV; + WIENER_FILT_TAP0_MINV; rst->vfilter[1] = vpx_rb_read_literal(rb, WIENER_FILT_TAP1_BITS) + - WIENER_FILT_TAP1_MINV; + WIENER_FILT_TAP1_MINV; rst->vfilter[2] = vpx_rb_read_literal(rb, WIENER_FILT_TAP2_BITS) + - WIENER_FILT_TAP2_MINV; + WIENER_FILT_TAP2_MINV; rst->hfilter[0] = vpx_rb_read_literal(rb, WIENER_FILT_TAP0_BITS) + - WIENER_FILT_TAP0_MINV; + WIENER_FILT_TAP0_MINV; rst->hfilter[1] = vpx_rb_read_literal(rb, WIENER_FILT_TAP1_BITS) + - WIENER_FILT_TAP1_MINV; + WIENER_FILT_TAP1_MINV; rst->hfilter[2] = vpx_rb_read_literal(rb, WIENER_FILT_TAP2_BITS) + - WIENER_FILT_TAP2_MINV; + WIENER_FILT_TAP2_MINV; } } else { rst->restoration_type = RESTORE_NONE; @@ -2050,8 +1916,7 @@ static void setup_restoration(VP10_COMMON *cm, } #endif // CONFIG_LOOP_RESTORATION -static void setup_loopfilter(VP10_COMMON *cm, - struct vpx_read_bit_buffer *rb) { +static void setup_loopfilter(VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) { struct loopfilter *lf = &cm->lf; lf->filter_level = vpx_rb_read_literal(rb, 6); lf->sharpness_level = vpx_rb_read_literal(rb, 3); @@ -2078,8 +1943,7 @@ static void setup_loopfilter(VP10_COMMON *cm, } static INLINE int read_delta_q(struct vpx_read_bit_buffer *rb) { - return vpx_rb_read_bit(rb) ? - vpx_rb_read_inv_signed_literal(rb, 6) : 0; + return vpx_rb_read_bit(rb) ? vpx_rb_read_inv_signed_literal(rb, 6) : 0; } static void setup_quantization(VP10_COMMON *const cm, @@ -2092,7 +1956,7 @@ static void setup_quantization(VP10_COMMON *const cm, } static void setup_segmentation_dequant(VP10_COMMON *const cm) { - // Build y/uv dequant values based on segmentation. +// Build y/uv dequant values based on segmentation. #if CONFIG_NEW_QUANT int b; int dq; @@ -2101,22 +1965,20 @@ static void setup_segmentation_dequant(VP10_COMMON *const cm) { int i; for (i = 0; i < MAX_SEGMENTS; ++i) { const int qindex = vp10_get_qindex(&cm->seg, i, cm->base_qindex); - cm->y_dequant[i][0] = vp10_dc_quant(qindex, cm->y_dc_delta_q, - cm->bit_depth); + cm->y_dequant[i][0] = + vp10_dc_quant(qindex, cm->y_dc_delta_q, cm->bit_depth); cm->y_dequant[i][1] = vp10_ac_quant(qindex, 0, cm->bit_depth); - cm->uv_dequant[i][0] = vp10_dc_quant(qindex, cm->uv_dc_delta_q, - cm->bit_depth); - cm->uv_dequant[i][1] = vp10_ac_quant(qindex, cm->uv_ac_delta_q, - cm->bit_depth); + cm->uv_dequant[i][0] = + vp10_dc_quant(qindex, cm->uv_dc_delta_q, cm->bit_depth); + cm->uv_dequant[i][1] = + vp10_ac_quant(qindex, cm->uv_ac_delta_q, cm->bit_depth); #if CONFIG_NEW_QUANT - for (dq = 0; dq < QUANT_PROFILES; dq ++) { + for (dq = 0; dq < QUANT_PROFILES; dq++) { for (b = 0; b < COEF_BANDS; ++b) { - vp10_get_dequant_val_nuq( - cm->y_dequant[i][b != 0], qindex, b, - cm->y_dequant_nuq[i][dq][b], NULL, dq); - vp10_get_dequant_val_nuq( - cm->uv_dequant[i][b != 0], qindex, b, - cm->uv_dequant_nuq[i][dq][b], NULL, dq); + vp10_get_dequant_val_nuq(cm->y_dequant[i][b != 0], qindex, b, + cm->y_dequant_nuq[i][dq][b], NULL, dq); + vp10_get_dequant_val_nuq(cm->uv_dequant[i][b != 0], qindex, b, + cm->uv_dequant_nuq[i][dq][b], NULL, dq); } } #endif // CONFIG_NEW_QUANT @@ -2125,21 +1987,20 @@ static void setup_segmentation_dequant(VP10_COMMON *const cm) { const int qindex = cm->base_qindex; // When segmentation is disabled, only the first value is used. The // remaining are don't cares. - cm->y_dequant[0][0] = vp10_dc_quant(qindex, cm->y_dc_delta_q, cm->bit_depth); + cm->y_dequant[0][0] = + vp10_dc_quant(qindex, cm->y_dc_delta_q, cm->bit_depth); cm->y_dequant[0][1] = vp10_ac_quant(qindex, 0, cm->bit_depth); - cm->uv_dequant[0][0] = vp10_dc_quant(qindex, cm->uv_dc_delta_q, - cm->bit_depth); - cm->uv_dequant[0][1] = vp10_ac_quant(qindex, cm->uv_ac_delta_q, - cm->bit_depth); + cm->uv_dequant[0][0] = + vp10_dc_quant(qindex, cm->uv_dc_delta_q, cm->bit_depth); + cm->uv_dequant[0][1] = + vp10_ac_quant(qindex, cm->uv_ac_delta_q, cm->bit_depth); #if CONFIG_NEW_QUANT - for (dq = 0; dq < QUANT_PROFILES; dq ++) { + for (dq = 0; dq < QUANT_PROFILES; dq++) { for (b = 0; b < COEF_BANDS; ++b) { - vp10_get_dequant_val_nuq( - cm->y_dequant[0][b != 0], qindex, b, - cm->y_dequant_nuq[0][dq][b], NULL, dq); - vp10_get_dequant_val_nuq( - cm->uv_dequant[0][b != 0], qindex, b, - cm->uv_dequant_nuq[0][dq][b], NULL, dq); + vp10_get_dequant_val_nuq(cm->y_dequant[0][b != 0], qindex, b, + cm->y_dequant_nuq[0][dq][b], NULL, dq); + vp10_get_dequant_val_nuq(cm->uv_dequant[0][b != 0], qindex, b, + cm->uv_dequant_nuq[0][dq][b], NULL, dq); } } #endif // CONFIG_NEW_QUANT @@ -2147,12 +2008,11 @@ static void setup_segmentation_dequant(VP10_COMMON *const cm) { } static INTERP_FILTER read_interp_filter(struct vpx_read_bit_buffer *rb) { - return vpx_rb_read_bit(rb) ? - SWITCHABLE : vpx_rb_read_literal(rb, 2 + CONFIG_EXT_INTERP); + return vpx_rb_read_bit(rb) ? SWITCHABLE + : vpx_rb_read_literal(rb, 2 + CONFIG_EXT_INTERP); } -static void setup_render_size(VP10_COMMON *cm, - struct vpx_read_bit_buffer *rb) { +static void setup_render_size(VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) { cm->render_width = cm->width; cm->render_height = cm->height; if (vpx_rb_read_bit(rb)) @@ -2179,7 +2039,7 @@ static void resize_context_buffers(VP10_COMMON *cm, int width, int height) { const int new_mi_rows = ALIGN_POWER_OF_TWO(height, MI_SIZE_LOG2) >> MI_SIZE_LOG2; const int new_mi_cols = - ALIGN_POWER_OF_TWO(width, MI_SIZE_LOG2) >> MI_SIZE_LOG2; + ALIGN_POWER_OF_TWO(width, MI_SIZE_LOG2) >> MI_SIZE_LOG2; // Allocations in vp10_alloc_context_buffers() depend on individual // dimensions as well as the overall size. @@ -2209,13 +2069,12 @@ static void setup_frame_size(VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) { lock_buffer_pool(pool); if (vpx_realloc_frame_buffer( - get_frame_new_buffer(cm), cm->width, cm->height, - cm->subsampling_x, cm->subsampling_y, + get_frame_new_buffer(cm), cm->width, cm->height, cm->subsampling_x, + cm->subsampling_y, #if CONFIG_VP9_HIGHBITDEPTH cm->use_highbitdepth, #endif - VPX_DEC_BORDER_IN_PIXELS, - cm->byte_alignment, + VPX_DEC_BORDER_IN_PIXELS, cm->byte_alignment, &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { unlock_buffer_pool(pool); @@ -2229,7 +2088,7 @@ static void setup_frame_size(VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) { pool->frame_bufs[cm->new_fb_idx].buf.bit_depth = (unsigned int)cm->bit_depth; pool->frame_bufs[cm->new_fb_idx].buf.color_space = cm->color_space; pool->frame_bufs[cm->new_fb_idx].buf.color_range = cm->color_range; - pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width; + pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width; pool->frame_bufs[cm->new_fb_idx].buf.render_height = cm->render_height; } @@ -2272,22 +2131,19 @@ static void setup_frame_size_with_refs(VP10_COMMON *cm, // has valid dimensions. for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { RefBuffer *const ref_frame = &cm->frame_refs[i]; - has_valid_ref_frame |= valid_ref_frame_size(ref_frame->buf->y_crop_width, - ref_frame->buf->y_crop_height, - width, height); + has_valid_ref_frame |= + valid_ref_frame_size(ref_frame->buf->y_crop_width, + ref_frame->buf->y_crop_height, width, height); } if (!has_valid_ref_frame) vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Referenced frame has invalid size"); for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { RefBuffer *const ref_frame = &cm->frame_refs[i]; - if (!valid_ref_frame_img_fmt( - ref_frame->buf->bit_depth, - ref_frame->buf->subsampling_x, - ref_frame->buf->subsampling_y, - cm->bit_depth, - cm->subsampling_x, - cm->subsampling_y)) + if (!valid_ref_frame_img_fmt(ref_frame->buf->bit_depth, + ref_frame->buf->subsampling_x, + ref_frame->buf->subsampling_y, cm->bit_depth, + cm->subsampling_x, cm->subsampling_y)) vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Referenced frame has incompatible color format"); } @@ -2296,13 +2152,12 @@ static void setup_frame_size_with_refs(VP10_COMMON *cm, lock_buffer_pool(pool); if (vpx_realloc_frame_buffer( - get_frame_new_buffer(cm), cm->width, cm->height, - cm->subsampling_x, cm->subsampling_y, + get_frame_new_buffer(cm), cm->width, cm->height, cm->subsampling_x, + cm->subsampling_y, #if CONFIG_VP9_HIGHBITDEPTH cm->use_highbitdepth, #endif - VPX_DEC_BORDER_IN_PIXELS, - cm->byte_alignment, + VPX_DEC_BORDER_IN_PIXELS, cm->byte_alignment, &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { unlock_buffer_pool(pool); @@ -2316,44 +2171,42 @@ static void setup_frame_size_with_refs(VP10_COMMON *cm, pool->frame_bufs[cm->new_fb_idx].buf.bit_depth = (unsigned int)cm->bit_depth; pool->frame_bufs[cm->new_fb_idx].buf.color_space = cm->color_space; pool->frame_bufs[cm->new_fb_idx].buf.color_range = cm->color_range; - pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width; + pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width; pool->frame_bufs[cm->new_fb_idx].buf.render_height = cm->render_height; } static void read_tile_info(VP10Decoder *const pbi, - struct vpx_read_bit_buffer *const rb) { + struct vpx_read_bit_buffer *const rb) { VP10_COMMON *const cm = &pbi->common; #if CONFIG_EXT_TILE - // Read the tile width/height +// Read the tile width/height #if CONFIG_EXT_PARTITION if (cm->sb_size == BLOCK_128X128) { - cm->tile_width = vpx_rb_read_literal(rb, 5) + 1; + cm->tile_width = vpx_rb_read_literal(rb, 5) + 1; cm->tile_height = vpx_rb_read_literal(rb, 5) + 1; } else #endif // CONFIG_EXT_PARTITION { - cm->tile_width = vpx_rb_read_literal(rb, 6) + 1; + cm->tile_width = vpx_rb_read_literal(rb, 6) + 1; cm->tile_height = vpx_rb_read_literal(rb, 6) + 1; } - cm->tile_width <<= cm->mib_size_log2; + cm->tile_width <<= cm->mib_size_log2; cm->tile_height <<= cm->mib_size_log2; - cm->tile_width = VPXMIN(cm->tile_width, cm->mi_cols); + cm->tile_width = VPXMIN(cm->tile_width, cm->mi_cols); cm->tile_height = VPXMIN(cm->tile_height, cm->mi_rows); // Get the number of tiles cm->tile_cols = 1; - while (cm->tile_cols * cm->tile_width < cm->mi_cols) - ++cm->tile_cols; + while (cm->tile_cols * cm->tile_width < cm->mi_cols) ++cm->tile_cols; cm->tile_rows = 1; - while (cm->tile_rows * cm->tile_height < cm->mi_rows) - ++cm->tile_rows; + while (cm->tile_rows * cm->tile_height < cm->mi_rows) ++cm->tile_rows; if (cm->tile_cols * cm->tile_rows > 1) { // Read the number of bytes used to store tile size - pbi->tile_col_size_bytes = vpx_rb_read_literal(rb, 2) + 1; + pbi->tile_col_size_bytes = vpx_rb_read_literal(rb, 2) + 1; pbi->tile_size_bytes = vpx_rb_read_literal(rb, 2) + 1; } #else @@ -2363,8 +2216,7 @@ static void read_tile_info(VP10Decoder *const pbi, // columns max_ones = max_log2_tile_cols - min_log2_tile_cols; cm->log2_tile_cols = min_log2_tile_cols; - while (max_ones-- && vpx_rb_read_bit(rb)) - cm->log2_tile_cols++; + while (max_ones-- && vpx_rb_read_bit(rb)) cm->log2_tile_cols++; if (cm->log2_tile_cols > 6) vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, @@ -2372,8 +2224,7 @@ static void read_tile_info(VP10Decoder *const pbi, // rows cm->log2_tile_rows = vpx_rb_read_bit(rb); - if (cm->log2_tile_rows) - cm->log2_tile_rows += vpx_rb_read_bit(rb); + if (cm->log2_tile_rows) cm->log2_tile_rows += vpx_rb_read_bit(rb); cm->tile_cols = 1 << cm->log2_tile_cols; cm->tile_rows = 1 << cm->log2_tile_rows; @@ -2384,7 +2235,7 @@ static void read_tile_info(VP10Decoder *const pbi, cm->tile_height >>= cm->log2_tile_rows; // round to integer multiples of superblock size - cm->tile_width = ALIGN_POWER_OF_TWO(cm->tile_width, MAX_MIB_SIZE_LOG2); + cm->tile_width = ALIGN_POWER_OF_TWO(cm->tile_width, MAX_MIB_SIZE_LOG2); cm->tile_height = ALIGN_POWER_OF_TWO(cm->tile_height, MAX_MIB_SIZE_LOG2); // tile size magnitude @@ -2396,17 +2247,11 @@ static void read_tile_info(VP10Decoder *const pbi, static int mem_get_varsize(const uint8_t *src, const int sz) { switch (sz) { - case 1: - return src[0]; - case 2: - return mem_get_le16(src); - case 3: - return mem_get_le24(src); - case 4: - return mem_get_le32(src); - default: - assert("Invalid size" && 0); - return -1; + case 1: return src[0]; + case 2: return mem_get_le16(src); + case 3: return mem_get_le24(src); + case 4: return mem_get_le32(src); + default: assert("Invalid size" && 0); return -1; } } @@ -2415,13 +2260,13 @@ static int mem_get_varsize(const uint8_t *src, const int sz) { // based on 'is_last'. static void get_tile_buffer(const uint8_t *const data_end, struct vpx_internal_error_info *error_info, - const uint8_t **data, - vpx_decrypt_cb decrypt_cb, void *decrypt_state, + const uint8_t **data, vpx_decrypt_cb decrypt_cb, + void *decrypt_state, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], int tile_size_bytes, int col, int row) { size_t size; - size_t copy_size = 0; + size_t copy_size = 0; const uint8_t *copy_data = NULL; if (!read_is_valid(*data, tile_size_bytes, data_end)) @@ -2468,15 +2313,14 @@ static void get_tile_buffer(const uint8_t *const data_end, } static void get_tile_buffers( - VP10Decoder *pbi, - const uint8_t *data, const uint8_t *data_end, + VP10Decoder *pbi, const uint8_t *data, const uint8_t *data_end, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) { VP10_COMMON *const cm = &pbi->common; const int tile_cols = cm->tile_cols; const int tile_rows = cm->tile_rows; const int have_tiles = tile_cols * tile_rows > 1; - if (!have_tiles) { + if (!have_tiles) { const uint32_t tile_size = data_end - data; tile_buffers[0][0].data = data; tile_buffers[0][0].size = tile_size; @@ -2525,20 +2369,17 @@ static void get_tile_buffers( for (c = tile_cols_start; c < tile_cols_end; ++c) { const int is_last = c == tile_cols - 1; - if (c > 0) - data = tile_col_data_end[c - 1]; + if (c > 0) data = tile_col_data_end[c - 1]; - if (!is_last) - data += tile_col_size_bytes; + if (!is_last) data += tile_col_size_bytes; // Get the whole of the last column, otherwise stop at the required tile. for (r = 0; r < (is_last ? tile_rows : tile_rows_end); ++r) { tile_buffers[r][c].col = c; - get_tile_buffer(tile_col_data_end[c], - &pbi->common.error, &data, - pbi->decrypt_cb, pbi->decrypt_state, - tile_buffers, tile_size_bytes, c, r); + get_tile_buffer(tile_col_data_end[c], &pbi->common.error, &data, + pbi->decrypt_cb, pbi->decrypt_state, tile_buffers, + tile_size_bytes, c, r); } } @@ -2551,10 +2392,9 @@ static void get_tile_buffers( for (r = 0; r < tile_rows; ++r) { tile_buffers[r][c].col = c; - get_tile_buffer(tile_col_data_end[c], - &pbi->common.error, &data, - pbi->decrypt_cb, pbi->decrypt_state, - tile_buffers, tile_size_bytes, c, r); + get_tile_buffer(tile_col_data_end[c], &pbi->common.error, &data, + pbi->decrypt_cb, pbi->decrypt_state, tile_buffers, + tile_size_bytes, c, r); } } } @@ -2565,9 +2405,8 @@ static void get_tile_buffers( static void get_tile_buffer(const uint8_t *const data_end, const int tile_size_bytes, int is_last, struct vpx_internal_error_info *error_info, - const uint8_t **data, - vpx_decrypt_cb decrypt_cb, void *decrypt_state, - TileBufferDec *const buf) { + const uint8_t **data, vpx_decrypt_cb decrypt_cb, + void *decrypt_state, TileBufferDec *const buf) { size_t size; if (!is_last) { @@ -2598,8 +2437,7 @@ static void get_tile_buffer(const uint8_t *const data_end, } static void get_tile_buffers( - VP10Decoder *pbi, - const uint8_t *data, const uint8_t *data_end, + VP10Decoder *pbi, const uint8_t *data, const uint8_t *data_end, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) { VP10_COMMON *const cm = &pbi->common; int r, c; @@ -2611,16 +2449,14 @@ static void get_tile_buffers( const int is_last = (r == tile_rows - 1) && (c == tile_cols - 1); TileBufferDec *const buf = &tile_buffers[r][c]; buf->col = c; - get_tile_buffer(data_end, pbi->tile_size_bytes, - is_last, &cm->error, &data, - pbi->decrypt_cb, pbi->decrypt_state, buf); + get_tile_buffer(data_end, pbi->tile_size_bytes, is_last, &cm->error, + &data, pbi->decrypt_cb, pbi->decrypt_state, buf); } } } #endif // CONFIG_EXT_TILE -static const uint8_t *decode_tiles(VP10Decoder *pbi, - const uint8_t *data, +static const uint8_t *decode_tiles(VP10Decoder *pbi, const uint8_t *data, const uint8_t *data_end) { VP10_COMMON *const cm = &pbi->common; const VPxWorkerInterface *const winterface = vpx_get_worker_interface(); @@ -2665,11 +2501,11 @@ static const uint8_t *decode_tiles(VP10Decoder *pbi, } if (cm->lf.filter_level && !cm->skip_loop_filter) { - LFWorkerData *const lf_data = (LFWorkerData*)pbi->lf_worker.data1; + LFWorkerData *const lf_data = (LFWorkerData *)pbi->lf_worker.data1; // Be sure to sync as we might be resuming after a failed frame decode. winterface->sync(&pbi->lf_worker); vp10_loop_filter_data_reset(lf_data, get_frame_new_buffer(cm), cm, - pbi->mb.plane); + pbi->mb.plane); } assert(tile_rows <= MAX_TILE_ROWS); @@ -2679,10 +2515,8 @@ static const uint8_t *decode_tiles(VP10Decoder *pbi, if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) { vpx_free(pbi->tile_data); - CHECK_MEM_ERROR( - cm, - pbi->tile_data, - vpx_memalign(32, n_tiles * (sizeof(*pbi->tile_data)))); + CHECK_MEM_ERROR(cm, pbi->tile_data, + vpx_memalign(32, n_tiles * (sizeof(*pbi->tile_data)))); pbi->allocated_tiles = n_tiles; } @@ -2696,18 +2530,17 @@ static const uint8_t *decode_tiles(VP10Decoder *pbi, td->xd = pbi->mb; td->xd.corrupted = 0; td->xd.counts = - cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD ? - &cm->counts : NULL; + cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD + ? &cm->counts + : NULL; vp10_zero(td->dqcoeff); vp10_tile_init(&td->xd.tile, td->cm, tile_row, tile_col); #if !CONFIG_ANS setup_bool_decoder(buf->data, data_end, buf->size, &cm->error, - &td->bit_reader, pbi->decrypt_cb, - pbi->decrypt_state); + &td->bit_reader, pbi->decrypt_cb, pbi->decrypt_state); #else setup_token_decoder(buf->data, data_end, buf->size, &cm->error, - &td->bit_reader, pbi->decrypt_cb, - pbi->decrypt_state); + &td->bit_reader, pbi->decrypt_cb, pbi->decrypt_state); #endif vp10_init_macroblockd(cm, &td->xd, td->dqcoeff); td->xd.plane[0].color_index_map = td->color_index_map[0]; @@ -2742,18 +2575,20 @@ static const uint8_t *decode_tiles(VP10Decoder *pbi, #if CONFIG_SUPERTX 0, #endif // CONFIG_SUPERTX - mi_row, mi_col, &td->bit_reader, - cm->sb_size, b_width_log2_lookup[cm->sb_size]); + mi_row, mi_col, &td->bit_reader, cm->sb_size, + b_width_log2_lookup[cm->sb_size]); } pbi->mb.corrupted |= td->xd.corrupted; if (pbi->mb.corrupted) - vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, - "Failed to decode tile data"); + vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, + "Failed to decode tile data"); #if CONFIG_ENTROPY if (cm->do_subframe_update && cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { - if ((mi_row + MI_SIZE) % (MI_SIZE * - VPXMAX(cm->mi_rows / MI_SIZE / COEF_PROBS_BUFS, 1)) == 0 && + if ((mi_row + MI_SIZE) % + (MI_SIZE * + VPXMAX(cm->mi_rows / MI_SIZE / COEF_PROBS_BUFS, 1)) == + 0 && mi_row + MI_SIZE < cm->mi_rows && cm->coef_probs_update_idx < COEF_PROBS_BUFS - 1) { vp10_partial_adapt_probs(cm, mi_row, mi_col); @@ -2769,18 +2604,16 @@ static const uint8_t *decode_tiles(VP10Decoder *pbi, #if !CONFIG_VAR_TX // Loopfilter one tile row. if (cm->lf.filter_level && !cm->skip_loop_filter) { - LFWorkerData *const lf_data = (LFWorkerData*)pbi->lf_worker.data1; + LFWorkerData *const lf_data = (LFWorkerData *)pbi->lf_worker.data1; const int lf_start = VPXMAX(0, tile_info.mi_row_start - cm->mib_size); const int lf_end = tile_info.mi_row_end - cm->mib_size; // Delay the loopfilter if the first tile row is only // a single superblock high. - if (lf_end <= 0) - continue; + if (lf_end <= 0) continue; // Decoding has completed. Finish up the loop filter in this thread. - if (tile_info.mi_row_end >= cm->mi_rows) - continue; + if (tile_info.mi_row_end >= cm->mi_rows) continue; winterface->sync(&pbi->lf_worker); lf_data->start = lf_start; @@ -2806,7 +2639,7 @@ static const uint8_t *decode_tiles(VP10Decoder *pbi, #else // Loopfilter remaining rows in the frame. if (cm->lf.filter_level && !cm->skip_loop_filter) { - LFWorkerData *const lf_data = (LFWorkerData*)pbi->lf_worker.data1; + LFWorkerData *const lf_data = (LFWorkerData *)pbi->lf_worker.data1; winterface->sync(&pbi->lf_worker); lf_data->start = lf_data->stop; lf_data->stop = cm->mi_rows; @@ -2869,8 +2702,8 @@ static int tile_worker_hook(TileWorkerData *const tile_data, #if CONFIG_SUPERTX 0, #endif - mi_row, mi_col, &tile_data->bit_reader, - cm->sb_size, b_width_log2_lookup[cm->sb_size]); + mi_row, mi_col, &tile_data->bit_reader, cm->sb_size, + b_width_log2_lookup[cm->sb_size]); } } return !tile_data->xd.corrupted; @@ -2878,13 +2711,12 @@ static int tile_worker_hook(TileWorkerData *const tile_data, // sorts in descending order static int compare_tile_buffers(const void *a, const void *b) { - const TileBufferDec *const buf1 = (const TileBufferDec*)a; - const TileBufferDec *const buf2 = (const TileBufferDec*)b; + const TileBufferDec *const buf1 = (const TileBufferDec *)a; + const TileBufferDec *const buf2 = (const TileBufferDec *)b; return (int)(buf2->size - buf1->size); } -static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, - const uint8_t *data, +static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, const uint8_t *data, const uint8_t *data_end) { VP10_COMMON *const cm = &pbi->common; const VPxWorkerInterface *const winterface = vpx_get_worker_interface(); @@ -2922,7 +2754,7 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, #if CONFIG_ANS // TODO(any): This might just work now. Needs to be tested. abort(); // FIXME: Tile parsing broken -#endif // CONFIG_ANS +#endif // CONFIG_ANS // TODO(jzern): See if we can remove the restriction of passing in max // threads to the decoder. @@ -2933,9 +2765,9 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, // Ensure tile data offsets will be properly aligned. This may fail on // platforms without DECLARE_ALIGNED(). assert((sizeof(*pbi->tile_worker_data) % 16) == 0); - CHECK_MEM_ERROR(cm, pbi->tile_worker_data, - vpx_memalign(32, num_threads * - sizeof(*pbi->tile_worker_data))); + CHECK_MEM_ERROR( + cm, pbi->tile_worker_data, + vpx_memalign(32, num_threads * sizeof(*pbi->tile_worker_data))); CHECK_MEM_ERROR(cm, pbi->tile_worker_info, vpx_malloc(num_threads * sizeof(*pbi->tile_worker_info))); for (i = 0; i < num_threads; ++i) { @@ -2962,7 +2794,7 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, // Initialize thread frame counts. if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { for (i = 0; i < num_workers; ++i) { - TileWorkerData *const twd = (TileWorkerData*)pbi->tile_workers[i].data1; + TileWorkerData *const twd = (TileWorkerData *)pbi->tile_workers[i].data1; vp10_zero(twd->counts); } } @@ -2970,7 +2802,7 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, // Load tile data into tile_buffers get_tile_buffers(pbi, data, data_end, tile_buffers); - for (tile_row = tile_rows_start ; tile_row < tile_rows_end ; ++tile_row) { + for (tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) { // Sort the buffers in this tile row based on size in descending order. qsort(&tile_buffers[tile_row][tile_cols_start], tile_cols_end - tile_cols_start, sizeof(tile_buffers[0][0]), @@ -2982,7 +2814,7 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, // where the main thread is waiting for a worker to complete. { int group_start; - for (group_start = tile_cols_start ; group_start < tile_cols_end ; + for (group_start = tile_cols_start; group_start < tile_cols_end; group_start += num_workers) { const int group_end = VPXMIN(group_start + num_workers, tile_cols); const TileBufferDec largest = tile_buffers[tile_row][group_start]; @@ -2993,28 +2825,29 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, } } - for (tile_col = tile_cols_start ; tile_col < tile_cols_end ; ) { + for (tile_col = tile_cols_start; tile_col < tile_cols_end;) { // Launch workers for individual columns for (i = 0; i < num_workers && tile_col < tile_cols_end; ++i, ++tile_col) { TileBufferDec *const buf = &tile_buffers[tile_row][tile_col]; VPxWorker *const worker = &pbi->tile_workers[i]; - TileWorkerData *const twd = (TileWorkerData*)worker->data1; - TileInfo *const tile_info = (TileInfo*)worker->data2; + TileWorkerData *const twd = (TileWorkerData *)worker->data1; + TileInfo *const tile_info = (TileInfo *)worker->data2; twd->pbi = pbi; twd->xd = pbi->mb; twd->xd.corrupted = 0; twd->xd.counts = - cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD ? - &twd->counts : NULL; + cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD + ? &twd->counts + : NULL; vp10_zero(twd->dqcoeff); vp10_tile_init(tile_info, cm, tile_row, buf->col); vp10_tile_init(&twd->xd.tile, cm, tile_row, buf->col); #if !CONFIG_ANS setup_bool_decoder(buf->data, data_end, buf->size, &cm->error, - &twd->bit_reader, - pbi->decrypt_cb, pbi->decrypt_state); + &twd->bit_reader, pbi->decrypt_cb, + pbi->decrypt_state); #else setup_token_decoder(buf->data, data_end, buf->size, &cm->error, &twd->bit_reader, pbi->decrypt_cb, @@ -3053,7 +2886,7 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, // Accumulate thread frame counts. if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { for (i = 0; i < num_workers; ++i) { - TileWorkerData *const twd = (TileWorkerData*)pbi->tile_workers[i].data1; + TileWorkerData *const twd = (TileWorkerData *)pbi->tile_workers[i].data1; vp10_accumulate_frame_counts(cm, &twd->counts); } } @@ -3068,7 +2901,7 @@ static const uint8_t *decode_tiles_mt(VP10Decoder *pbi, assert(final_worker != -1); { TileWorkerData *const twd = - (TileWorkerData*)pbi->tile_workers[final_worker].data1; + (TileWorkerData *)pbi->tile_workers[final_worker].data1; return vpx_reader_find_end(&twd->bit_reader); } #endif // CONFIG_ANS @@ -3080,8 +2913,8 @@ static void error_handler(void *data) { vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet"); } -static void read_bitdepth_colorspace_sampling( - VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) { +static void read_bitdepth_colorspace_sampling(VP10_COMMON *cm, + struct vpx_read_bit_buffer *rb) { if (cm->profile >= PROFILE_2) { cm->bit_depth = vpx_rb_read_bit(rb) ? VPX_BITS_12 : VPX_BITS_10; #if CONFIG_VP9_HIGHBITDEPTH @@ -3145,8 +2978,8 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, #endif // CONFIG_EXT_REFS if (vpx_rb_read_literal(rb, 2) != VPX_FRAME_MARKER) - vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM, - "Invalid frame marker"); + vpx_internal_error(&cm->error, VPX_CODEC_UNSUP_BITSTREAM, + "Invalid frame marker"); cm->profile = vp10_read_profile(rb); #if CONFIG_VP9_HIGHBITDEPTH @@ -3187,7 +3020,7 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, return 0; } - cm->frame_type = (FRAME_TYPE) vpx_rb_read_bit(rb); + cm->frame_type = (FRAME_TYPE)vpx_rb_read_bit(rb); cm->show_frame = vpx_rb_read_bit(rb); cm->error_resilient_mode = vpx_rb_read_bit(rb); @@ -3215,20 +3048,20 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, cm->intra_only = cm->show_frame ? 0 : vpx_rb_read_bit(rb); if (cm->error_resilient_mode) { - cm->reset_frame_context = RESET_FRAME_CONTEXT_ALL; + cm->reset_frame_context = RESET_FRAME_CONTEXT_ALL; } else { if (cm->intra_only) { - cm->reset_frame_context = - vpx_rb_read_bit(rb) ? RESET_FRAME_CONTEXT_ALL - : RESET_FRAME_CONTEXT_CURRENT; - } else { - cm->reset_frame_context = - vpx_rb_read_bit(rb) ? RESET_FRAME_CONTEXT_CURRENT - : RESET_FRAME_CONTEXT_NONE; - if (cm->reset_frame_context == RESET_FRAME_CONTEXT_CURRENT) - cm->reset_frame_context = - vpx_rb_read_bit(rb) ? RESET_FRAME_CONTEXT_ALL + cm->reset_frame_context = vpx_rb_read_bit(rb) + ? RESET_FRAME_CONTEXT_ALL : RESET_FRAME_CONTEXT_CURRENT; + } else { + cm->reset_frame_context = vpx_rb_read_bit(rb) + ? RESET_FRAME_CONTEXT_CURRENT + : RESET_FRAME_CONTEXT_NONE; + if (cm->reset_frame_context == RESET_FRAME_CONTEXT_CURRENT) + cm->reset_frame_context = vpx_rb_read_bit(rb) + ? RESET_FRAME_CONTEXT_ALL + : RESET_FRAME_CONTEXT_CURRENT; } } @@ -3245,7 +3078,7 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); pbi->need_resync = 0; } - } else if (pbi->need_resync != 1) { /* Skip if need resync */ + } else if (pbi->need_resync != 1) { /* Skip if need resync */ pbi->refresh_frame_flags = vpx_rb_read_literal(rb, REF_FRAMES); #if CONFIG_EXT_REFS @@ -3273,16 +3106,14 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { RefBuffer *const ref_buf = &cm->frame_refs[i]; #if CONFIG_VP9_HIGHBITDEPTH - vp10_setup_scale_factors_for_frame(&ref_buf->sf, - ref_buf->buf->y_crop_width, - ref_buf->buf->y_crop_height, - cm->width, cm->height, - cm->use_highbitdepth); + vp10_setup_scale_factors_for_frame( + &ref_buf->sf, ref_buf->buf->y_crop_width, + ref_buf->buf->y_crop_height, cm->width, cm->height, + cm->use_highbitdepth); #else - vp10_setup_scale_factors_for_frame(&ref_buf->sf, - ref_buf->buf->y_crop_width, - ref_buf->buf->y_crop_height, - cm->width, cm->height); + vp10_setup_scale_factors_for_frame( + &ref_buf->sf, ref_buf->buf->y_crop_width, + ref_buf->buf->y_crop_height, cm->width, cm->height); #endif } } @@ -3292,7 +3123,7 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, #endif get_frame_new_buffer(cm)->color_space = cm->color_space; get_frame_new_buffer(cm)->color_range = cm->color_range; - get_frame_new_buffer(cm)->render_width = cm->render_width; + get_frame_new_buffer(cm)->render_width = cm->render_width; get_frame_new_buffer(cm)->render_height = cm->render_height; if (pbi->need_resync) { @@ -3302,9 +3133,9 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, } if (!cm->error_resilient_mode) { - cm->refresh_frame_context = - vpx_rb_read_bit(rb) ? REFRESH_FRAME_CONTEXT_FORWARD - : REFRESH_FRAME_CONTEXT_BACKWARD; + cm->refresh_frame_context = vpx_rb_read_bit(rb) + ? REFRESH_FRAME_CONTEXT_FORWARD + : REFRESH_FRAME_CONTEXT_BACKWARD; } else { cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_FORWARD; } @@ -3360,8 +3191,7 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, vp10_default_coef_probs(cm); if (cm->frame_type == KEY_FRAME || cm->error_resilient_mode || cm->reset_frame_context == RESET_FRAME_CONTEXT_ALL) { - for (i = 0; i < FRAME_CONTEXTS; ++i) - cm->frame_contexts[i] = *cm->fc; + for (i = 0; i < FRAME_CONTEXTS; ++i) cm->frame_contexts[i] = *cm->fc; } else if (cm->reset_frame_context == RESET_FRAME_CONTEXT_CURRENT) { cm->frame_contexts[cm->frame_context_idx] = *cm->fc; } @@ -3372,18 +3202,17 @@ static size_t read_uncompressed_header(VP10Decoder *pbi, { int i; for (i = 0; i < MAX_SEGMENTS; ++i) { - const int qindex = cm->seg.enabled ? - vp10_get_qindex(&cm->seg, i, cm->base_qindex) : cm->base_qindex; - xd->lossless[i] = qindex == 0 && - cm->y_dc_delta_q == 0 && - cm->uv_dc_delta_q == 0 && - cm->uv_ac_delta_q == 0; + const int qindex = cm->seg.enabled + ? vp10_get_qindex(&cm->seg, i, cm->base_qindex) + : cm->base_qindex; + xd->lossless[i] = qindex == 0 && cm->y_dc_delta_q == 0 && + cm->uv_dc_delta_q == 0 && cm->uv_ac_delta_q == 0; } } setup_segmentation_dequant(cm); - cm->tx_mode = (!cm->seg.enabled && xd->lossless[0]) ? ONLY_4X4 - : read_tx_mode(rb); + cm->tx_mode = + (!cm->seg.enabled && xd->lossless[0]) ? ONLY_4X4 : read_tx_mode(rb); cm->reference_mode = read_frame_reference_mode(cm, rb); read_tile_info(pbi, rb); @@ -3457,31 +3286,31 @@ static void read_supertx_probs(FRAME_CONTEXT *fc, vp10_reader *r) { #if CONFIG_GLOBAL_MOTION static void read_global_motion_params(Global_Motion_Params *params, - vpx_prob *probs, - vp10_reader *r) { - GLOBAL_MOTION_TYPE gmtype = vp10_read_tree(r, vp10_global_motion_types_tree, - probs); + vpx_prob *probs, vp10_reader *r) { + GLOBAL_MOTION_TYPE gmtype = + vp10_read_tree(r, vp10_global_motion_types_tree, probs); params->gmtype = gmtype; params->motion_params.wmtype = gm_to_trans_type(gmtype); switch (gmtype) { - case GLOBAL_ZERO: - break; + case GLOBAL_ZERO: break; case GLOBAL_AFFINE: params->motion_params.wmmat[4] = (vp10_read_primitive_symmetric(r, GM_ABS_ALPHA_BITS) * - GM_ALPHA_DECODE_FACTOR) + (1 << WARPEDMODEL_PREC_BITS); + GM_ALPHA_DECODE_FACTOR) + + (1 << WARPEDMODEL_PREC_BITS); params->motion_params.wmmat[5] = vp10_read_primitive_symmetric(r, GM_ABS_ALPHA_BITS) * GM_ALPHA_DECODE_FACTOR; - // fallthrough intended + // fallthrough intended case GLOBAL_ROTZOOM: params->motion_params.wmmat[2] = (vp10_read_primitive_symmetric(r, GM_ABS_ALPHA_BITS) * - GM_ALPHA_DECODE_FACTOR) + (1 << WARPEDMODEL_PREC_BITS); + GM_ALPHA_DECODE_FACTOR) + + (1 << WARPEDMODEL_PREC_BITS); params->motion_params.wmmat[3] = vp10_read_primitive_symmetric(r, GM_ABS_ALPHA_BITS) * GM_ALPHA_DECODE_FACTOR; - // fallthrough intended + // fallthrough intended case GLOBAL_TRANSLATION: params->motion_params.wmmat[0] = vp10_read_primitive_symmetric(r, GM_ABS_TRANS_BITS) * @@ -3490,8 +3319,7 @@ static void read_global_motion_params(Global_Motion_Params *params, vp10_read_primitive_symmetric(r, GM_ABS_TRANS_BITS) * GM_TRANS_DECODE_FACTOR; break; - default: - assert(0); + default: assert(0); } } @@ -3499,8 +3327,8 @@ static void read_global_motion(VP10_COMMON *cm, vp10_reader *r) { int frame; memset(cm->global_motion, 0, sizeof(cm->global_motion)); for (frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) { - read_global_motion_params( - &cm->global_motion[frame], cm->fc->global_motion_types_prob, r); + read_global_motion_params(&cm->global_motion[frame], + cm->fc->global_motion_types_prob, r); } } #endif // CONFIG_GLOBAL_MOTION @@ -3557,11 +3385,11 @@ static int read_compressed_header(VP10Decoder *pbi, const uint8_t *data, vp10_diff_update_prob(&r, &fc->uv_mode_prob[j][i]); #if CONFIG_EXT_PARTITION_TYPES - for (i = 0; i < PARTITION_TYPES - 1; ++i) - vp10_diff_update_prob(&r, &fc->partition_prob[0][i]); - for (j = 1; j < PARTITION_CONTEXTS; ++j) - for (i = 0; i < EXT_PARTITION_TYPES - 1; ++i) - vp10_diff_update_prob(&r, &fc->partition_prob[j][i]); + for (i = 0; i < PARTITION_TYPES - 1; ++i) + vp10_diff_update_prob(&r, &fc->partition_prob[0][i]); + for (j = 1; j < PARTITION_CONTEXTS; ++j) + for (i = 0; i < EXT_PARTITION_TYPES - 1; ++i) + vp10_diff_update_prob(&r, &fc->partition_prob[j][i]); #else for (j = 0; j < PARTITION_CONTEXTS; ++j) for (i = 0; i < PARTITION_TYPES - 1; ++i) @@ -3621,8 +3449,7 @@ static int read_compressed_header(VP10Decoder *pbi, const uint8_t *data, } #endif // CONFIG_OBMC || CONFIG_WARPED_MOTION - if (cm->interp_filter == SWITCHABLE) - read_switchable_interp_probs(fc, &r); + if (cm->interp_filter == SWITCHABLE) read_switchable_interp_probs(fc, &r); for (i = 0; i < INTRA_INTER_CONTEXTS; i++) vp10_diff_update_prob(&r, &fc->intra_inter_prob[i]); @@ -3644,8 +3471,7 @@ static int read_compressed_header(VP10Decoder *pbi, const uint8_t *data, #endif read_ext_tx_probs(fc, &r); #if CONFIG_SUPERTX - if (!xd->lossless[0]) - read_supertx_probs(fc, &r); + if (!xd->lossless[0]) read_supertx_probs(fc, &r); #endif #if CONFIG_GLOBAL_MOTION read_global_motion(cm, &r); @@ -3671,8 +3497,7 @@ static void debug_check_frame_counts(const VP10_COMMON *const cm) { sizeof(cm->counts.uv_mode))); assert(!memcmp(cm->counts.partition, zero_counts.partition, sizeof(cm->counts.partition))); - assert(!memcmp(cm->counts.coef, zero_counts.coef, - sizeof(cm->counts.coef))); + assert(!memcmp(cm->counts.coef, zero_counts.coef, sizeof(cm->counts.coef))); assert(!memcmp(cm->counts.eob_branch, zero_counts.eob_branch, sizeof(cm->counts.eob_branch))); assert(!memcmp(cm->counts.switchable_interp, zero_counts.switchable_interp, @@ -3710,10 +3535,10 @@ static void debug_check_frame_counts(const VP10_COMMON *const cm) { sizeof(cm->counts.tx_size))); assert(!memcmp(cm->counts.skip, zero_counts.skip, sizeof(cm->counts.skip))); #if CONFIG_REF_MV - assert(!memcmp(&cm->counts.mv[0], &zero_counts.mv[0], - sizeof(cm->counts.mv[0]))); - assert(!memcmp(&cm->counts.mv[1], &zero_counts.mv[1], - sizeof(cm->counts.mv[0]))); + assert( + !memcmp(&cm->counts.mv[0], &zero_counts.mv[0], sizeof(cm->counts.mv[0]))); + assert( + !memcmp(&cm->counts.mv[1], &zero_counts.mv[1], sizeof(cm->counts.mv[0]))); #else assert(!memcmp(&cm->counts.mv, &zero_counts.mv, sizeof(cm->counts.mv))); #endif @@ -3725,11 +3550,8 @@ static void debug_check_frame_counts(const VP10_COMMON *const cm) { #endif // NDEBUG static struct vpx_read_bit_buffer *init_read_bit_buffer( - VP10Decoder *pbi, - struct vpx_read_bit_buffer *rb, - const uint8_t *data, - const uint8_t *data_end, - uint8_t clear_data[MAX_VPX_HEADER_SIZE]) { + VP10Decoder *pbi, struct vpx_read_bit_buffer *rb, const uint8_t *data, + const uint8_t *data_end, uint8_t clear_data[MAX_VPX_HEADER_SIZE]) { rb->bit_offset = 0; rb->error_handler = error_handler; rb->error_handler_data = &pbi->common; @@ -3753,8 +3575,8 @@ int vp10_read_sync_code(struct vpx_read_bit_buffer *const rb) { vpx_rb_read_literal(rb, 8) == VP10_SYNC_CODE_2; } -void vp10_read_frame_size(struct vpx_read_bit_buffer *rb, - int *width, int *height) { +void vp10_read_frame_size(struct vpx_read_bit_buffer *rb, int *width, + int *height) { *width = vpx_rb_read_literal(rb, 16) + 1; *height = vpx_rb_read_literal(rb, 16) + 1; } @@ -3762,21 +3584,19 @@ void vp10_read_frame_size(struct vpx_read_bit_buffer *rb, BITSTREAM_PROFILE vp10_read_profile(struct vpx_read_bit_buffer *rb) { int profile = vpx_rb_read_bit(rb); profile |= vpx_rb_read_bit(rb) << 1; - if (profile > 2) - profile += vpx_rb_read_bit(rb); - return (BITSTREAM_PROFILE) profile; + if (profile > 2) profile += vpx_rb_read_bit(rb); + return (BITSTREAM_PROFILE)profile; } -void vp10_decode_frame(VP10Decoder *pbi, - const uint8_t *data, const uint8_t *data_end, - const uint8_t **p_data_end) { +void vp10_decode_frame(VP10Decoder *pbi, const uint8_t *data, + const uint8_t *data_end, const uint8_t **p_data_end) { VP10_COMMON *const cm = &pbi->common; MACROBLOCKD *const xd = &pbi->mb; struct vpx_read_bit_buffer rb; int context_updated = 0; uint8_t clear_data[MAX_VPX_HEADER_SIZE]; - const size_t first_partition_size = read_uncompressed_header(pbi, - init_read_bit_buffer(pbi, &rb, data, data_end, clear_data)); + const size_t first_partition_size = read_uncompressed_header( + pbi, init_read_bit_buffer(pbi, &rb, data, data_end, clear_data)); YV12_BUFFER_CONFIG *const new_fb = get_frame_new_buffer(cm); xd->cur_buf = new_fb; #if CONFIG_GLOBAL_MOTION @@ -3784,7 +3604,7 @@ void vp10_decode_frame(VP10Decoder *pbi, #endif // CONFIG_GLOBAL_MOTION if (!first_partition_size) { - // showing a frame directly +// showing a frame directly #if CONFIG_EXT_REFS if (cm->show_existing_frame) *p_data_end = data + vpx_rb_bytes_read(&rb); @@ -3800,12 +3620,10 @@ void vp10_decode_frame(VP10Decoder *pbi, vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet or corrupt header length"); - cm->use_prev_frame_mvs = !cm->error_resilient_mode && - cm->width == cm->last_width && - cm->height == cm->last_height && - !cm->last_intra_only && - cm->last_show_frame && - (cm->last_frame_type != KEY_FRAME); + cm->use_prev_frame_mvs = + !cm->error_resilient_mode && cm->width == cm->last_width && + cm->height == cm->last_height && !cm->last_intra_only && + cm->last_show_frame && (cm->last_frame_type != KEY_FRAME); #if CONFIG_EXT_REFS // NOTE(zoeliu): As cm->prev_frame can take neither a frame of // show_exisiting_frame=1, nor can it take a frame not used as @@ -3870,7 +3688,7 @@ void vp10_decode_frame(VP10Decoder *pbi, if (pbi->max_threads > 1 #if CONFIG_EXT_TILE && pbi->dec_tile_col < 0 // Decoding all columns -#endif // CONFIG_EXT_TILE +#endif // CONFIG_EXT_TILE && cm->tile_cols > 1) { // Multi-threaded tile decoder *p_data_end = decode_tiles_mt(pbi, data + first_partition_size, data_end); @@ -3879,21 +3697,19 @@ void vp10_decode_frame(VP10Decoder *pbi, // If multiple threads are used to decode tiles, then we use those // threads to do parallel loopfiltering. vp10_loop_filter_frame_mt(new_fb, cm, pbi->mb.plane, - cm->lf.filter_level, 0, 0, pbi->tile_workers, - pbi->num_tile_workers, &pbi->lf_row_sync); + cm->lf.filter_level, 0, 0, pbi->tile_workers, + pbi->num_tile_workers, &pbi->lf_row_sync); } } else { vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Decode failed. Frame data is corrupted."); - } } else { *p_data_end = decode_tiles(pbi, data + first_partition_size, data_end); } #if CONFIG_LOOP_RESTORATION if (cm->rst_info.restoration_type != RESTORE_NONE) { - vp10_loop_restoration_init(&cm->rst_internal, - &cm->rst_info, + vp10_loop_restoration_init(&cm->rst_internal, &cm->rst_info, cm->frame_type == KEY_FRAME); vp10_loop_restoration_rows(new_fb, cm, 0, cm->mi_rows, 0); } diff --git a/vp10/decoder/decodeframe.h b/vp10/decoder/decodeframe.h index 770ae154e..7fdff0b29 100644 --- a/vp10/decoder/decodeframe.h +++ b/vp10/decoder/decodeframe.h @@ -8,7 +8,6 @@ * be found in the AUTHORS file in the root of the source tree. */ - #ifndef VP10_DECODER_DECODEFRAME_H_ #define VP10_DECODER_DECODEFRAME_H_ @@ -20,13 +19,12 @@ struct VP10Decoder; struct vpx_read_bit_buffer; int vp10_read_sync_code(struct vpx_read_bit_buffer *const rb); -void vp10_read_frame_size(struct vpx_read_bit_buffer *rb, - int *width, int *height); +void vp10_read_frame_size(struct vpx_read_bit_buffer *rb, int *width, + int *height); BITSTREAM_PROFILE vp10_read_profile(struct vpx_read_bit_buffer *rb); -void vp10_decode_frame(struct VP10Decoder *pbi, - const uint8_t *data, const uint8_t *data_end, - const uint8_t **p_data_end); +void vp10_decode_frame(struct VP10Decoder *pbi, const uint8_t *data, + const uint8_t *data_end, const uint8_t **p_data_end); #ifdef __cplusplus } // extern "C" diff --git a/vp10/decoder/decodemv.c b/vp10/decoder/decodemv.c index e036cebef..26e8a11a3 100644 --- a/vp10/decoder/decodemv.c +++ b/vp10/decoder/decodemv.c @@ -27,7 +27,7 @@ static INLINE int read_uniform(vp10_reader *r, int n) { int l = get_unsigned_bits(n); int m = (1 << l) - n; - int v = vp10_read_literal(r, l-1); + int v = vp10_read_literal(r, l - 1); assert(l != 0); @@ -46,31 +46,27 @@ static PREDICTION_MODE read_intra_mode_y(VP10_COMMON *cm, MACROBLOCKD *xd, const PREDICTION_MODE y_mode = read_intra_mode(r, cm->fc->y_mode_prob[size_group]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->y_mode[size_group][y_mode]; + if (counts) ++counts->y_mode[size_group][y_mode]; return y_mode; } static PREDICTION_MODE read_intra_mode_uv(VP10_COMMON *cm, MACROBLOCKD *xd, vp10_reader *r, PREDICTION_MODE y_mode) { - const PREDICTION_MODE uv_mode = read_intra_mode(r, - cm->fc->uv_mode_prob[y_mode]); + const PREDICTION_MODE uv_mode = + read_intra_mode(r, cm->fc->uv_mode_prob[y_mode]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->uv_mode[y_mode][uv_mode]; + if (counts) ++counts->uv_mode[y_mode][uv_mode]; return uv_mode; } #if CONFIG_EXT_INTER static INTERINTRA_MODE read_interintra_mode(VP10_COMMON *cm, MACROBLOCKD *xd, vp10_reader *r, int size_group) { - const INTERINTRA_MODE ii_mode = - (INTERINTRA_MODE)vp10_read_tree(r, vp10_interintra_mode_tree, - cm->fc->interintra_mode_prob[size_group]); + const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)vp10_read_tree( + r, vp10_interintra_mode_tree, cm->fc->interintra_mode_prob[size_group]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->interintra_mode[size_group][ii_mode]; + if (counts) ++counts->interintra_mode[size_group][ii_mode]; return ii_mode; } #endif // CONFIG_EXT_INTER @@ -86,85 +82,70 @@ static PREDICTION_MODE read_inter_mode(VP10_COMMON *cm, MACROBLOCKD *xd, vpx_prob mode_prob = cm->fc->newmv_prob[mode_ctx]; if (vp10_read(r, mode_prob) == 0) { - if (counts) - ++counts->newmv_mode[mode_ctx][0]; + if (counts) ++counts->newmv_mode[mode_ctx][0]; #if CONFIG_EXT_INTER if (has_second_ref(mbmi)) { #endif // CONFIG_EXT_INTER - return NEWMV; + return NEWMV; #if CONFIG_EXT_INTER } else { mode_prob = cm->fc->new2mv_prob; if (vp10_read(r, mode_prob) == 0) { - if (counts) - ++counts->new2mv_mode[0]; + if (counts) ++counts->new2mv_mode[0]; return NEWMV; } else { - if (counts) - ++counts->new2mv_mode[1]; + if (counts) ++counts->new2mv_mode[1]; return NEWFROMNEARMV; } } #endif // CONFIG_EXT_INTER } - if (counts) - ++counts->newmv_mode[mode_ctx][1]; + if (counts) ++counts->newmv_mode[mode_ctx][1]; - if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) - return ZEROMV; + if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return ZEROMV; mode_ctx = (ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK; mode_prob = cm->fc->zeromv_prob[mode_ctx]; if (vp10_read(r, mode_prob) == 0) { - if (counts) - ++counts->zeromv_mode[mode_ctx][0]; + if (counts) ++counts->zeromv_mode[mode_ctx][0]; return ZEROMV; } - if (counts) - ++counts->zeromv_mode[mode_ctx][1]; + if (counts) ++counts->zeromv_mode[mode_ctx][1]; mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK; - if (ctx & (1 << SKIP_NEARESTMV_OFFSET)) - mode_ctx = 6; - if (ctx & (1 << SKIP_NEARMV_OFFSET)) - mode_ctx = 7; - if (ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) - mode_ctx = 8; + if (ctx & (1 << SKIP_NEARESTMV_OFFSET)) mode_ctx = 6; + if (ctx & (1 << SKIP_NEARMV_OFFSET)) mode_ctx = 7; + if (ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) mode_ctx = 8; mode_prob = cm->fc->refmv_prob[mode_ctx]; if (vp10_read(r, mode_prob) == 0) { - if (counts) - ++counts->refmv_mode[mode_ctx][0]; + if (counts) ++counts->refmv_mode[mode_ctx][0]; return NEARESTMV; } else { - if (counts) - ++counts->refmv_mode[mode_ctx][1]; + if (counts) ++counts->refmv_mode[mode_ctx][1]; return NEARMV; } // Invalid prediction mode. assert(0); #else - const int mode = vp10_read_tree(r, vp10_inter_mode_tree, - cm->fc->inter_mode_probs[ctx]); + const int mode = + vp10_read_tree(r, vp10_inter_mode_tree, cm->fc->inter_mode_probs[ctx]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->inter_mode[ctx][mode]; + if (counts) ++counts->inter_mode[ctx][mode]; return NEARESTMV + mode; #endif } #if CONFIG_REF_MV -static void read_drl_idx(const VP10_COMMON *cm, - MACROBLOCKD *xd, - MB_MODE_INFO *mbmi, - vp10_reader *r) { +static void read_drl_idx(const VP10_COMMON *cm, MACROBLOCKD *xd, + MB_MODE_INFO *mbmi, vp10_reader *r) { uint8_t ref_frame_type = vp10_ref_frame_type(mbmi->ref_frame); mbmi->ref_mv_idx = 0; @@ -176,13 +157,11 @@ static void read_drl_idx(const VP10_COMMON *cm, vpx_prob drl_prob = cm->fc->drl_prob[drl_ctx]; if (!vp10_read(r, drl_prob)) { mbmi->ref_mv_idx = idx; - if (xd->counts) - ++xd->counts->drl_mode[drl_ctx][0]; + if (xd->counts) ++xd->counts->drl_mode[drl_ctx][0]; return; } mbmi->ref_mv_idx = idx + 1; - if (xd->counts) - ++xd->counts->drl_mode[drl_ctx][1]; + if (xd->counts) ++xd->counts->drl_mode[drl_ctx][1]; } } } @@ -198,13 +177,11 @@ static void read_drl_idx(const VP10_COMMON *cm, vpx_prob drl_prob = cm->fc->drl_prob[drl_ctx]; if (!vp10_read(r, drl_prob)) { mbmi->ref_mv_idx = idx - 1; - if (xd->counts) - ++xd->counts->drl_mode[drl_ctx][0]; + if (xd->counts) ++xd->counts->drl_mode[drl_ctx][0]; return; } mbmi->ref_mv_idx = idx; - if (xd->counts) - ++xd->counts->drl_mode[drl_ctx][1]; + if (xd->counts) ++xd->counts->drl_mode[drl_ctx][1]; } } } @@ -213,14 +190,13 @@ static void read_drl_idx(const VP10_COMMON *cm, #if CONFIG_EXT_INTER static PREDICTION_MODE read_inter_compound_mode(VP10_COMMON *cm, - MACROBLOCKD *xd, - vp10_reader *r, int16_t ctx) { + MACROBLOCKD *xd, vp10_reader *r, + int16_t ctx) { const int mode = vp10_read_tree(r, vp10_inter_compound_mode_tree, - cm->fc->inter_compound_mode_probs[ctx]); + cm->fc->inter_compound_mode_probs[ctx]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->inter_compound_mode[ctx][mode]; + if (counts) ++counts->inter_compound_mode[ctx][mode]; assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode)); return NEAREST_NEARESTMV + mode; @@ -228,7 +204,7 @@ static PREDICTION_MODE read_inter_compound_mode(VP10_COMMON *cm, #endif // CONFIG_EXT_INTER static int read_segment_id(vp10_reader *r, - const struct segmentation_probs *segp) { + const struct segmentation_probs *segp) { return vp10_read_tree(r, vp10_segment_tree, segp->tree_probs); } @@ -243,18 +219,15 @@ static void read_tx_size_vartx(VP10_COMMON *cm, MACROBLOCKD *xd, int max_blocks_high = num_4x4_blocks_high_lookup[mbmi->sb_type]; int max_blocks_wide = num_4x4_blocks_wide_lookup[mbmi->sb_type]; int ctx = txfm_partition_context(xd->above_txfm_context + tx_col, - xd->left_txfm_context + tx_row, - tx_size); - TX_SIZE (*const inter_tx_size)[MAX_MIB_SIZE] = - (TX_SIZE (*)[MAX_MIB_SIZE])&mbmi->inter_tx_size[tx_row][tx_col]; + xd->left_txfm_context + tx_row, tx_size); + TX_SIZE (*const inter_tx_size) + [MAX_MIB_SIZE] = + (TX_SIZE(*)[MAX_MIB_SIZE]) & mbmi->inter_tx_size[tx_row][tx_col]; - if (xd->mb_to_bottom_edge < 0) - max_blocks_high += xd->mb_to_bottom_edge >> 5; - if (xd->mb_to_right_edge < 0) - max_blocks_wide += xd->mb_to_right_edge >> 5; + if (xd->mb_to_bottom_edge < 0) max_blocks_high += xd->mb_to_bottom_edge >> 5; + if (xd->mb_to_right_edge < 0) max_blocks_wide += xd->mb_to_right_edge >> 5; - if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) - return; + if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; is_split = vp10_read(r, cm->fc->txfm_partition_prob[ctx]); @@ -263,8 +236,7 @@ static void read_tx_size_vartx(VP10_COMMON *cm, MACROBLOCKD *xd, int bsl = b_width_log2_lookup[bsize]; int i; - if (counts) - ++counts->txfm_partition[ctx][1]; + if (counts) ++counts->txfm_partition[ctx][1]; if (tx_size == TX_8X8) { inter_tx_size[0][0] = TX_4X4; @@ -279,8 +251,8 @@ static void read_tx_size_vartx(VP10_COMMON *cm, MACROBLOCKD *xd, for (i = 0; i < 4; ++i) { int offsetr = blk_row + ((i >> 1) << bsl); int offsetc = blk_col + ((i & 0x01) << bsl); - read_tx_size_vartx(cm, xd, mbmi, counts, - tx_size - 1, offsetr, offsetc, r); + read_tx_size_vartx(cm, xd, mbmi, counts, tx_size - 1, offsetr, offsetc, + r); } } else { int idx, idy; @@ -289,8 +261,7 @@ static void read_tx_size_vartx(VP10_COMMON *cm, MACROBLOCKD *xd, for (idx = 0; idx < num_4x4_blocks_wide_txsize_lookup[tx_size] / 2; ++idx) inter_tx_size[idy][idx] = tx_size; mbmi->tx_size = tx_size; - if (counts) - ++counts->txfm_partition[ctx][0]; + if (counts) ++counts->txfm_partition[ctx][0]; txfm_partition_update(xd->above_txfm_context + tx_col, xd->left_txfm_context + tx_row, tx_size); } @@ -303,9 +274,8 @@ static TX_SIZE read_selected_tx_size(VP10_COMMON *cm, MACROBLOCKD *xd, const int ctx = get_tx_size_context(xd); const int tx_size_cat = max_tx_size - TX_8X8; int tx_size = vp10_read_tree(r, vp10_tx_size_tree[tx_size_cat], - cm->fc->tx_size_probs[tx_size_cat][ctx]); - if (counts) - ++counts->tx_size[tx_size_cat][ctx][tx_size]; + cm->fc->tx_size_probs[tx_size_cat][ctx]); + if (counts) ++counts->tx_size[tx_size_cat][ctx][tx_size]; return (TX_SIZE)tx_size; } @@ -313,8 +283,7 @@ static TX_SIZE read_tx_size_intra(VP10_COMMON *cm, MACROBLOCKD *xd, vp10_reader *r) { TX_MODE tx_mode = cm->tx_mode; BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type; - if (xd->lossless[xd->mi[0]->mbmi.segment_id]) - return TX_4X4; + if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4; if (bsize >= BLOCK_8X8) { const TX_SIZE max_tx_size = max_txsize_lookup[bsize]; if (tx_mode == TX_MODE_SELECT) { @@ -331,8 +300,7 @@ static TX_SIZE read_tx_size_inter(VP10_COMMON *cm, MACROBLOCKD *xd, int allow_select, vp10_reader *r) { TX_MODE tx_mode = cm->tx_mode; BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type; - if (xd->lossless[xd->mi[0]->mbmi.segment_id]) - return TX_4X4; + if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4; if (bsize >= BLOCK_8X8) { const TX_SIZE max_tx_size = max_txsize_lookup[bsize]; if (allow_select && tx_mode == TX_MODE_SELECT) { @@ -362,8 +330,8 @@ static int dec_get_segment_id(const VP10_COMMON *cm, const uint8_t *segment_ids, return segment_id; } -static void set_segment_id(VP10_COMMON *cm, int mi_offset, - int x_mis, int y_mis, int segment_id) { +static void set_segment_id(VP10_COMMON *cm, int mi_offset, int x_mis, int y_mis, + int segment_id) { int x, y; assert(segment_id >= 0 && segment_id < MAX_SEGMENTS); @@ -381,28 +349,27 @@ static int read_intra_segment_id(VP10_COMMON *const cm, MACROBLOCKD *const xd, struct segmentation_probs *const segp = &cm->fc->seg; int segment_id; - if (!seg->enabled) - return 0; // Default for disabled segmentation + if (!seg->enabled) return 0; // Default for disabled segmentation assert(seg->update_map && !seg->temporal_update); segment_id = read_segment_id(r, segp); - if (counts) - ++counts->seg.tree_total[segment_id]; + if (counts) ++counts->seg.tree_total[segment_id]; set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); return segment_id; } static void copy_segment_id(const VP10_COMMON *cm, - const uint8_t *last_segment_ids, - uint8_t *current_segment_ids, - int mi_offset, int x_mis, int y_mis) { + const uint8_t *last_segment_ids, + uint8_t *current_segment_ids, int mi_offset, + int x_mis, int y_mis) { int x, y; for (y = 0; y < y_mis; y++) for (x = 0; x < x_mis; x++) - current_segment_ids[mi_offset + y * cm->mi_cols + x] = last_segment_ids ? - last_segment_ids[mi_offset + y * cm->mi_cols + x] : 0; + current_segment_ids[mi_offset + y * cm->mi_cols + x] = + last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x] + : 0; } static int read_inter_segment_id(VP10_COMMON *const cm, MACROBLOCKD *const xd, @@ -420,12 +387,12 @@ static int read_inter_segment_id(VP10_COMMON *const cm, MACROBLOCKD *const xd, const int x_mis = VPXMIN(cm->mi_cols - mi_col, bw); const int y_mis = VPXMIN(cm->mi_rows - mi_row, bh); - if (!seg->enabled) - return 0; // Default for disabled segmentation + if (!seg->enabled) return 0; // Default for disabled segmentation - predicted_segment_id = cm->last_frame_seg_map ? - dec_get_segment_id(cm, cm->last_frame_seg_map, mi_offset, x_mis, y_mis) : - 0; + predicted_segment_id = cm->last_frame_seg_map + ? dec_get_segment_id(cm, cm->last_frame_seg_map, + mi_offset, x_mis, y_mis) + : 0; if (!seg->update_map) { copy_segment_id(cm, cm->last_frame_seg_map, cm->current_frame_seg_map, @@ -437,45 +404,40 @@ static int read_inter_segment_id(VP10_COMMON *const cm, MACROBLOCKD *const xd, const int ctx = vp10_get_pred_context_seg_id(xd); const vpx_prob pred_prob = segp->pred_probs[ctx]; mbmi->seg_id_predicted = vp10_read(r, pred_prob); - if (counts) - ++counts->seg.pred[ctx][mbmi->seg_id_predicted]; + if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted]; if (mbmi->seg_id_predicted) { segment_id = predicted_segment_id; } else { segment_id = read_segment_id(r, segp); - if (counts) - ++counts->seg.tree_mispred[segment_id]; + if (counts) ++counts->seg.tree_mispred[segment_id]; } } else { segment_id = read_segment_id(r, segp); - if (counts) - ++counts->seg.tree_total[segment_id]; + if (counts) ++counts->seg.tree_total[segment_id]; } set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); return segment_id; } -static int read_skip(VP10_COMMON *cm, const MACROBLOCKD *xd, - int segment_id, vp10_reader *r) { +static int read_skip(VP10_COMMON *cm, const MACROBLOCKD *xd, int segment_id, + vp10_reader *r) { if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) { return 1; } else { const int ctx = vp10_get_skip_context(xd); const int skip = vp10_read(r, cm->fc->skip_probs[ctx]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->skip[ctx][skip]; + if (counts) ++counts->skip[ctx][skip]; return skip; } } -static void read_palette_mode_info(VP10_COMMON *const cm, - MACROBLOCKD *const xd, +static void read_palette_mode_info(VP10_COMMON *const cm, MACROBLOCKD *const xd, vp10_reader *r) { MODE_INFO *const mi = xd->mi[0]; MB_MODE_INFO *const mbmi = &mi->mbmi; const MODE_INFO *const above_mi = xd->above_mi; - const MODE_INFO *const left_mi = xd->left_mi; + const MODE_INFO *const left_mi = xd->left_mi; const BLOCK_SIZE bsize = mbmi->sb_type; int i, n, palette_ctx = 0; PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info; @@ -485,11 +447,13 @@ static void read_palette_mode_info(VP10_COMMON *const cm, palette_ctx += (above_mi->mbmi.palette_mode_info.palette_size[0] > 0); if (left_mi) palette_ctx += (left_mi->mbmi.palette_mode_info.palette_size[0] > 0); - if (vp10_read(r, vp10_default_palette_y_mode_prob[bsize - BLOCK_8X8] - [palette_ctx])) { + if (vp10_read( + r, + vp10_default_palette_y_mode_prob[bsize - BLOCK_8X8][palette_ctx])) { pmi->palette_size[0] = - vp10_read_tree(r, vp10_palette_size_tree, - vp10_default_palette_y_size_prob[bsize - BLOCK_8X8]) + 2; + vp10_read_tree(r, vp10_palette_size_tree, + vp10_default_palette_y_size_prob[bsize - BLOCK_8X8]) + + 2; n = pmi->palette_size[0]; for (i = 0; i < n; ++i) pmi->palette_colors[i] = vp10_read_literal(r, cm->bit_depth); @@ -500,12 +464,12 @@ static void read_palette_mode_info(VP10_COMMON *const cm, } if (mbmi->uv_mode == DC_PRED) { - if (vp10_read(r, - vp10_default_palette_uv_mode_prob[pmi->palette_size[0] > 0])) { + if (vp10_read( + r, vp10_default_palette_uv_mode_prob[pmi->palette_size[0] > 0])) { pmi->palette_size[1] = vp10_read_tree(r, vp10_palette_size_tree, - vp10_default_palette_uv_size_prob[bsize - BLOCK_8X8]) - + 2; + vp10_default_palette_uv_size_prob[bsize - BLOCK_8X8]) + + 2; n = pmi->palette_size[1]; for (i = 0; i < n; ++i) { pmi->palette_colors[PALETTE_MAX_SIZE + i] = @@ -529,8 +493,7 @@ static void read_ext_intra_mode_info(VP10_COMMON *const cm, #if !ALLOW_FILTER_INTRA_MODES return; #endif - if (mbmi->mode == DC_PRED && - mbmi->palette_mode_info.palette_size[0] == 0) { + if (mbmi->mode == DC_PRED && mbmi->palette_mode_info.palette_size[0] == 0) { mbmi->ext_intra_mode_info.use_ext_intra_mode[0] = vp10_read(r, cm->fc->ext_intra_probs[0]); if (mbmi->ext_intra_mode_info.use_ext_intra_mode[0]) { @@ -560,8 +523,7 @@ static void read_intra_angle_info(VP10_COMMON *const cm, MACROBLOCKD *const xd, const int ctx = vp10_get_pred_context_intra_interp(xd); int p_angle; - if (bsize < BLOCK_8X8) - return; + if (bsize < BLOCK_8X8) return; if (mbmi->mode != DC_PRED && mbmi->mode != TM_PRED) { mbmi->angle_delta[0] = @@ -571,8 +533,7 @@ static void read_intra_angle_info(VP10_COMMON *const cm, MACROBLOCKD *const xd, FRAME_COUNTS *counts = xd->counts; mbmi->intra_filter = vp10_read_tree(r, vp10_intra_filter_tree, cm->fc->intra_filter_probs[ctx]); - if (counts) - ++counts->intra_filter[ctx][mbmi->intra_filter]; + if (counts) ++counts->intra_filter[ctx][mbmi->intra_filter]; } else { mbmi->intra_filter = INTRA_FILTER_LINEAR; } @@ -586,12 +547,12 @@ static void read_intra_angle_info(VP10_COMMON *const cm, MACROBLOCKD *const xd, #endif // CONFIG_EXT_INTRA static void read_intra_frame_mode_info(VP10_COMMON *const cm, - MACROBLOCKD *const xd, - int mi_row, int mi_col, vp10_reader *r) { + MACROBLOCKD *const xd, int mi_row, + int mi_col, vp10_reader *r) { MODE_INFO *const mi = xd->mi[0]; MB_MODE_INFO *const mbmi = &mi->mbmi; const MODE_INFO *above_mi = xd->above_mi; - const MODE_INFO *left_mi = xd->left_mi; + const MODE_INFO *left_mi = xd->left_mi; const BLOCK_SIZE bsize = mbmi->sb_type; int i; const int mi_offset = mi_row * cm->mi_cols + mi_col; @@ -628,8 +589,8 @@ static void read_intra_frame_mode_info(VP10_COMMON *const cm, read_intra_mode(r, get_y_mode_probs(cm, mi, above_mi, left_mi, 2)); break; default: - mbmi->mode = read_intra_mode(r, - get_y_mode_probs(cm, mi, above_mi, left_mi, 0)); + mbmi->mode = + read_intra_mode(r, get_y_mode_probs(cm, mi, above_mi, left_mi, 0)); } mbmi->uv_mode = read_intra_mode_uv(cm, xd, r, mbmi->mode); @@ -641,10 +602,9 @@ static void read_intra_frame_mode_info(VP10_COMMON *const cm, if (bsize >= BLOCK_8X8 && cm->allow_screen_content_tools) read_palette_mode_info(cm, xd, r); #if CONFIG_EXT_INTRA - mbmi->ext_intra_mode_info.use_ext_intra_mode[0] = 0; - mbmi->ext_intra_mode_info.use_ext_intra_mode[1] = 0; - if (bsize >= BLOCK_8X8) - read_ext_intra_mode_info(cm, xd, r); + mbmi->ext_intra_mode_info.use_ext_intra_mode[0] = 0; + mbmi->ext_intra_mode_info.use_ext_intra_mode[1] = 0; + if (bsize >= BLOCK_8X8) read_ext_intra_mode_info(cm, xd, r); #endif // CONFIG_EXT_INTRA if (!FIXED_TX_TYPE) { @@ -660,21 +620,20 @@ static void read_intra_frame_mode_info(VP10_COMMON *const cm, r, vp10_ext_tx_intra_tree[eset], cm->fc->intra_ext_tx_prob[eset][mbmi->tx_size][mbmi->mode]); if (counts) - ++counts->intra_ext_tx[eset][mbmi->tx_size][mbmi->mode] - [mbmi->tx_type]; + ++counts + ->intra_ext_tx[eset][mbmi->tx_size][mbmi->mode][mbmi->tx_type]; } } else { mbmi->tx_type = DCT_DCT; } #else - if (mbmi->tx_size < TX_32X32 && - cm->base_qindex > 0 && !mbmi->skip && + if (mbmi->tx_size < TX_32X32 && cm->base_qindex > 0 && !mbmi->skip && !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { FRAME_COUNTS *counts = xd->counts; TX_TYPE tx_type_nom = intra_mode_to_tx_type_context[mbmi->mode]; - mbmi->tx_type = vp10_read_tree( - r, vp10_ext_tx_tree, - cm->fc->intra_ext_tx_prob[mbmi->tx_size][tx_type_nom]); + mbmi->tx_type = + vp10_read_tree(r, vp10_ext_tx_tree, + cm->fc->intra_ext_tx_prob[mbmi->tx_size][tx_type_nom]); if (counts) ++counts->intra_ext_tx[mbmi->tx_size][tx_type_nom][mbmi->tx_type]; } else { @@ -684,8 +643,8 @@ static void read_intra_frame_mode_info(VP10_COMMON *const cm, } } -static int read_mv_component(vp10_reader *r, - const nmv_component *mvcomp, int usehp) { +static int read_mv_component(vp10_reader *r, const nmv_component *mvcomp, + int usehp) { int mag, d, fr, hp; const int sign = vp10_read(r, mvcomp->sign); const int mv_class = vp10_read_tree(r, vp10_mv_class_tree, mvcomp->classes); @@ -700,18 +659,16 @@ static int read_mv_component(vp10_reader *r, const int n = mv_class + CLASS0_BITS - 1; // number of bits d = 0; - for (i = 0; i < n; ++i) - d |= vp10_read(r, mvcomp->bits[i]) << i; + for (i = 0; i < n; ++i) d |= vp10_read(r, mvcomp->bits[i]) << i; mag = CLASS0_SIZE << (mv_class + 2); } // Fractional part - fr = vp10_read_tree(r, vp10_mv_fp_tree, class0 ? mvcomp->class0_fp[d] - : mvcomp->fp); + fr = vp10_read_tree(r, vp10_mv_fp_tree, + class0 ? mvcomp->class0_fp[d] : mvcomp->fp); // High precision part (if hp is not used, the default value of the hp is 1) - hp = usehp ? vp10_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp) - : 1; + hp = usehp ? vp10_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp) : 1; // Result mag += ((d << 3) | (fr << 1) | hp) + 1; @@ -722,11 +679,11 @@ static INLINE void read_mv(vp10_reader *r, MV *mv, const MV *ref, #if CONFIG_REF_MV int is_compound, #endif - const nmv_context *ctx, - nmv_context_counts *counts, int allow_hp) { + const nmv_context *ctx, nmv_context_counts *counts, + int allow_hp) { MV_JOINT_TYPE joint_type; const int use_hp = allow_hp && vp10_use_mv_hp(ref); - MV diff = {0, 0}; + MV diff = { 0, 0 }; #if CONFIG_REF_MV && !CONFIG_EXT_INTER if (is_compound) { @@ -734,16 +691,16 @@ static INLINE void read_mv(vp10_reader *r, MV *mv, const MV *ref, if (is_zero_rmv) { joint_type = MV_JOINT_ZERO; } else { - joint_type = (MV_JOINT_TYPE)vp10_read_tree(r, vp10_mv_joint_tree, - ctx->joints); + joint_type = + (MV_JOINT_TYPE)vp10_read_tree(r, vp10_mv_joint_tree, ctx->joints); } } else { - joint_type = (MV_JOINT_TYPE)vp10_read_tree(r, vp10_mv_joint_tree, - ctx->joints); + joint_type = + (MV_JOINT_TYPE)vp10_read_tree(r, vp10_mv_joint_tree, ctx->joints); } #else - joint_type = (MV_JOINT_TYPE)vp10_read_tree(r, vp10_mv_joint_tree, - ctx->joints); + joint_type = + (MV_JOINT_TYPE)vp10_read_tree(r, vp10_mv_joint_tree, ctx->joints); #endif #if CONFIG_REF_MV && CONFIG_EXT_INTER @@ -770,8 +727,7 @@ static REFERENCE_MODE read_block_reference_mode(VP10_COMMON *cm, const REFERENCE_MODE mode = (REFERENCE_MODE)vp10_read(r, cm->fc->comp_inter_prob[ctx]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->comp_inter[ctx][mode]; + if (counts) ++counts->comp_inter[ctx][mode]; return mode; // SINGLE_REFERENCE or COMPOUND_REFERENCE } else { return cm->reference_mode; @@ -780,8 +736,8 @@ static REFERENCE_MODE read_block_reference_mode(VP10_COMMON *cm, // Read the referncence frame static void read_ref_frames(VP10_COMMON *const cm, MACROBLOCKD *const xd, - vp10_reader *r, - int segment_id, MV_REFERENCE_FRAME ref_frame[2]) { + vp10_reader *r, int segment_id, + MV_REFERENCE_FRAME ref_frame[2]) { FRAME_CONTEXT *const fc = cm->fc; FRAME_COUNTS *counts = xd->counts; @@ -801,22 +757,19 @@ static void read_ref_frames(VP10_COMMON *const cm, MACROBLOCKD *const xd, const int ctx = vp10_get_pred_context_comp_ref_p(cm, xd); const int bit = vp10_read(r, fc->comp_ref_prob[ctx][0]); - if (counts) - ++counts->comp_ref[ctx][0][bit]; + if (counts) ++counts->comp_ref[ctx][0][bit]; #if CONFIG_EXT_REFS // Decode forward references. if (!bit) { const int ctx1 = vp10_get_pred_context_comp_ref_p1(cm, xd); const int bit1 = vp10_read(r, fc->comp_ref_prob[ctx1][1]); - if (counts) - ++counts->comp_ref[ctx1][1][bit1]; + if (counts) ++counts->comp_ref[ctx1][1][bit1]; ref_frame[!idx] = cm->comp_fwd_ref[bit1 ? 0 : 1]; } else { const int ctx2 = vp10_get_pred_context_comp_ref_p2(cm, xd); const int bit2 = vp10_read(r, fc->comp_ref_prob[ctx2][2]); - if (counts) - ++counts->comp_ref[ctx2][2][bit2]; + if (counts) ++counts->comp_ref[ctx2][2][bit2]; ref_frame[!idx] = cm->comp_fwd_ref[bit2 ? 3 : 2]; } @@ -824,8 +777,7 @@ static void read_ref_frames(VP10_COMMON *const cm, MACROBLOCKD *const xd, { const int ctx_bwd = vp10_get_pred_context_comp_bwdref_p(cm, xd); const int bit_bwd = vp10_read(r, fc->comp_bwdref_prob[ctx_bwd][0]); - if (counts) - ++counts->comp_bwdref[ctx_bwd][0][bit_bwd]; + if (counts) ++counts->comp_bwdref[ctx_bwd][0][bit_bwd]; ref_frame[idx] = cm->comp_bwd_ref[bit_bwd]; } #else @@ -836,45 +788,38 @@ static void read_ref_frames(VP10_COMMON *const cm, MACROBLOCKD *const xd, #if CONFIG_EXT_REFS const int ctx0 = vp10_get_pred_context_single_ref_p1(xd); const int bit0 = vp10_read(r, fc->single_ref_prob[ctx0][0]); - if (counts) - ++counts->single_ref[ctx0][0][bit0]; + if (counts) ++counts->single_ref[ctx0][0][bit0]; if (bit0) { const int ctx1 = vp10_get_pred_context_single_ref_p2(xd); const int bit1 = vp10_read(r, fc->single_ref_prob[ctx1][1]); - if (counts) - ++counts->single_ref[ctx1][1][bit1]; + if (counts) ++counts->single_ref[ctx1][1][bit1]; ref_frame[0] = bit1 ? ALTREF_FRAME : BWDREF_FRAME; } else { const int ctx2 = vp10_get_pred_context_single_ref_p3(xd); const int bit2 = vp10_read(r, fc->single_ref_prob[ctx2][2]); - if (counts) - ++counts->single_ref[ctx2][2][bit2]; + if (counts) ++counts->single_ref[ctx2][2][bit2]; if (bit2) { const int ctx4 = vp10_get_pred_context_single_ref_p5(xd); const int bit4 = vp10_read(r, fc->single_ref_prob[ctx4][4]); - if (counts) - ++counts->single_ref[ctx4][4][bit4]; + if (counts) ++counts->single_ref[ctx4][4][bit4]; ref_frame[0] = bit4 ? GOLDEN_FRAME : LAST3_FRAME; } else { const int ctx3 = vp10_get_pred_context_single_ref_p4(xd); const int bit3 = vp10_read(r, fc->single_ref_prob[ctx3][3]); - if (counts) - ++counts->single_ref[ctx3][3][bit3]; + if (counts) ++counts->single_ref[ctx3][3][bit3]; ref_frame[0] = bit3 ? LAST2_FRAME : LAST_FRAME; } } #else const int ctx0 = vp10_get_pred_context_single_ref_p1(xd); const int bit0 = vp10_read(r, fc->single_ref_prob[ctx0][0]); - if (counts) - ++counts->single_ref[ctx0][0][bit0]; + if (counts) ++counts->single_ref[ctx0][0][bit0]; if (bit0) { const int ctx1 = vp10_get_pred_context_single_ref_p2(xd); const int bit1 = vp10_read(r, fc->single_ref_prob[ctx1][1]); - if (counts) - ++counts->single_ref[ctx1][1][bit1]; + if (counts) ++counts->single_ref[ctx1][1][bit1]; ref_frame[0] = bit1 ? ALTREF_FRAME : GOLDEN_FRAME; } else { ref_frame[0] = LAST_FRAME; @@ -888,19 +833,18 @@ static void read_ref_frames(VP10_COMMON *const cm, MACROBLOCKD *const xd, } } - #if CONFIG_OBMC || CONFIG_WARPED_MOTION -static MOTION_VARIATION read_motvar_block( - VP10_COMMON *const cm, MACROBLOCKD *const xd, vp10_reader *r) { +static MOTION_VARIATION read_motvar_block(VP10_COMMON *const cm, + MACROBLOCKD *const xd, + vp10_reader *r) { BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type; FRAME_COUNTS *counts = xd->counts; MOTION_VARIATION motvar; if (is_motvar_allowed(&xd->mi[0]->mbmi)) { - motvar = (MOTION_VARIATION) - vp10_read_tree(r, vp10_motvar_tree, cm->fc->motvar_prob[bsize]); - if (counts) - ++counts->motvar[bsize][motvar]; + motvar = (MOTION_VARIATION)vp10_read_tree(r, vp10_motvar_tree, + cm->fc->motvar_prob[bsize]); + if (counts) ++counts->motvar[bsize][motvar]; return motvar; } else { return SIMPLE_TRANSLATION; @@ -908,12 +852,12 @@ static MOTION_VARIATION read_motvar_block( } #endif // CONFIG_OBMC || CONFIG_WARPED_MOTION -static INLINE INTERP_FILTER read_interp_filter( - VP10_COMMON *const cm, MACROBLOCKD *const xd, +static INLINE INTERP_FILTER read_interp_filter(VP10_COMMON *const cm, + MACROBLOCKD *const xd, #if CONFIG_DUAL_FILTER - int dir, + int dir, #endif - vp10_reader *r) { + vp10_reader *r) { #if CONFIG_EXT_INTERP if (!vp10_is_interp_needed(xd)) return EIGHTTAP_REGULAR; #endif @@ -926,11 +870,9 @@ static INLINE INTERP_FILTER read_interp_filter( const int ctx = vp10_get_pred_context_switchable_interp(xd); #endif FRAME_COUNTS *counts = xd->counts; - const INTERP_FILTER type = - (INTERP_FILTER)vp10_read_tree(r, vp10_switchable_interp_tree, - cm->fc->switchable_interp_prob[ctx]); - if (counts) - ++counts->switchable_interp[ctx][type]; + const INTERP_FILTER type = (INTERP_FILTER)vp10_read_tree( + r, vp10_switchable_interp_tree, cm->fc->switchable_interp_prob[ctx]); + if (counts) ++counts->switchable_interp[ctx][type]; return type; } } @@ -952,14 +894,12 @@ static void read_intra_block_mode_info(VP10_COMMON *const cm, mbmi->mode = mi->bmi[3].as_mode; break; case BLOCK_4X8: - mi->bmi[0].as_mode = mi->bmi[2].as_mode = read_intra_mode_y(cm, xd, - r, 0); + mi->bmi[0].as_mode = mi->bmi[2].as_mode = read_intra_mode_y(cm, xd, r, 0); mi->bmi[1].as_mode = mi->bmi[3].as_mode = mbmi->mode = read_intra_mode_y(cm, xd, r, 0); break; case BLOCK_8X4: - mi->bmi[0].as_mode = mi->bmi[1].as_mode = read_intra_mode_y(cm, xd, - r, 0); + mi->bmi[0].as_mode = mi->bmi[1].as_mode = read_intra_mode_y(cm, xd, r, 0); mi->bmi[2].as_mode = mi->bmi[3].as_mode = mbmi->mode = read_intra_mode_y(cm, xd, r, 0); break; @@ -978,14 +918,13 @@ static void read_intra_block_mode_info(VP10_COMMON *const cm, #if CONFIG_EXT_INTRA mbmi->ext_intra_mode_info.use_ext_intra_mode[0] = 0; mbmi->ext_intra_mode_info.use_ext_intra_mode[1] = 0; - if (bsize >= BLOCK_8X8) - read_ext_intra_mode_info(cm, xd, r); + if (bsize >= BLOCK_8X8) read_ext_intra_mode_info(cm, xd, r); #endif // CONFIG_EXT_INTRA } static INLINE int is_mv_valid(const MV *mv) { - return mv->row > MV_LOW && mv->row < MV_UPP && - mv->col > MV_LOW && mv->col < MV_UPP; + return mv->row > MV_LOW && mv->row < MV_UPP && mv->col > MV_LOW && + mv->col < MV_UPP; } static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, @@ -1001,8 +940,8 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, #if CONFIG_REF_MV MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; BLOCK_SIZE bsize = mbmi->sb_type; - int_mv *pred_mv = (bsize >= BLOCK_8X8) ? - mbmi->pred_mv : xd->mi[0]->bmi[block].pred_mv_s8; + int_mv *pred_mv = + (bsize >= BLOCK_8X8) ? mbmi->pred_mv : xd->mi[0]->bmi[block].pred_mv_s8; #endif switch (mode) { @@ -1039,37 +978,31 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, } case NEARESTMV: { mv[0].as_int = nearest_mv[0].as_int; - if (is_compound) - mv[1].as_int = nearest_mv[1].as_int; + if (is_compound) mv[1].as_int = nearest_mv[1].as_int; #if CONFIG_REF_MV pred_mv[0].as_int = nearest_mv[0].as_int; - if (is_compound) - pred_mv[1].as_int = nearest_mv[1].as_int; + if (is_compound) pred_mv[1].as_int = nearest_mv[1].as_int; #endif break; } case NEARMV: { mv[0].as_int = near_mv[0].as_int; - if (is_compound) - mv[1].as_int = near_mv[1].as_int; + if (is_compound) mv[1].as_int = near_mv[1].as_int; #if CONFIG_REF_MV pred_mv[0].as_int = near_mv[0].as_int; - if (is_compound) - pred_mv[1].as_int = near_mv[1].as_int; + if (is_compound) pred_mv[1].as_int = near_mv[1].as_int; #endif break; } case ZEROMV: { mv[0].as_int = 0; - if (is_compound) - mv[1].as_int = 0; + if (is_compound) mv[1].as_int = 0; #if CONFIG_REF_MV pred_mv[0].as_int = 0; - if (is_compound) - pred_mv[1].as_int = 0; + if (is_compound) pred_mv[1].as_int = 0; #endif break; } @@ -1087,8 +1020,7 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, nmv_context_counts *const mv_counts = counts ? &counts->mv[nmv_ctx] : NULL; read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, is_compound, - &cm->fc->nmvc[nmv_ctx], mv_counts, - allow_hp); + &cm->fc->nmvc[nmv_ctx], mv_counts, allow_hp); #else read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, &cm->fc->nmvc, mv_counts, allow_hp); @@ -1129,8 +1061,7 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, nmv_context_counts *const mv_counts = counts ? &counts->mv[nmv_ctx] : NULL; read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, is_compound, - &cm->fc->nmvc[nmv_ctx], mv_counts, - allow_hp); + &cm->fc->nmvc[nmv_ctx], mv_counts, allow_hp); #else nmv_context_counts *const mv_counts = counts ? &counts->mv : NULL; read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, &cm->fc->nmvc, mv_counts, @@ -1150,8 +1081,7 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, counts ? &counts->mv[nmv_ctx] : NULL; mv[0].as_int = nearest_mv[0].as_int; read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, is_compound, - &cm->fc->nmvc[nmv_ctx], mv_counts, - allow_hp); + &cm->fc->nmvc[nmv_ctx], mv_counts, allow_hp); #else nmv_context_counts *const mv_counts = counts ? &counts->mv : NULL; mv[0].as_int = nearest_mv[0].as_int; @@ -1171,8 +1101,7 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, counts ? &counts->mv[nmv_ctx] : NULL; mv[0].as_int = near_mv[0].as_int; read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, is_compound, - &cm->fc->nmvc[nmv_ctx], mv_counts, - allow_hp); + &cm->fc->nmvc[nmv_ctx], mv_counts, allow_hp); #else nmv_context_counts *const mv_counts = counts ? &counts->mv : NULL; mv[0].as_int = near_mv[0].as_int; @@ -1192,8 +1121,7 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, nmv_context_counts *const mv_counts = counts ? &counts->mv[nmv_ctx] : NULL; read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, is_compound, - &cm->fc->nmvc[nmv_ctx], mv_counts, - allow_hp); + &cm->fc->nmvc[nmv_ctx], mv_counts, allow_hp); #else nmv_context_counts *const mv_counts = counts ? &counts->mv : NULL; read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, &cm->fc->nmvc, mv_counts, @@ -1211,9 +1139,7 @@ static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd, break; } #endif // CONFIG_EXT_INTER - default: { - return 0; - } + default: { return 0; } } return ret; } @@ -1226,8 +1152,7 @@ static int read_is_inter_block(VP10_COMMON *const cm, MACROBLOCKD *const xd, const int ctx = vp10_get_intra_inter_context(xd); const int is_inter = vp10_read(r, cm->fc->intra_inter_prob[ctx]); FRAME_COUNTS *counts = xd->counts; - if (counts) - ++counts->intra_inter[ctx][is_inter]; + if (counts) ++counts->intra_inter[ctx][is_inter]; return is_inter; } } @@ -1235,7 +1160,7 @@ static int read_is_inter_block(VP10_COMMON *const cm, MACROBLOCKD *const xd, static void fpm_sync(void *const data, int mi_row) { VP10Decoder *const pbi = (VP10Decoder *)data; vp10_frameworker_wait(pbi->frame_worker_owner, pbi->common.prev_frame, - mi_row << pbi->common.mib_size_log2); + mi_row << pbi->common.mib_size_log2); } static void read_inter_block_mode_info(VP10Decoder *const pbi, @@ -1278,21 +1203,19 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, if ((!vp10_is_valid_scale(&ref_buf->sf))) vpx_internal_error(xd->error_info, VPX_CODEC_UNSUP_BITSTREAM, "Reference frame has invalid dimensions"); - vp10_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col, - &ref_buf->sf); + vp10_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col, &ref_buf->sf); } for (ref_frame = LAST_FRAME; ref_frame < MODE_CTX_REF_FRAMES; ++ref_frame) { vp10_find_mv_refs(cm, xd, mi, ref_frame, #if CONFIG_REF_MV - &xd->ref_mv_count[ref_frame], - xd->ref_mv_stack[ref_frame], + &xd->ref_mv_count[ref_frame], xd->ref_mv_stack[ref_frame], #if CONFIG_EXT_INTER compound_inter_mode_ctx, #endif // CONFIG_EXT_INTER #endif - ref_mvs[ref_frame], - mi_row, mi_col, fpm_sync, (void *)pbi, inter_mode_ctx); + ref_mvs[ref_frame], mi_row, mi_col, fpm_sync, (void *)pbi, + inter_mode_ctx); } #if CONFIG_REF_MV @@ -1301,8 +1224,8 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, mode_ctx = compound_inter_mode_ctx[mbmi->ref_frame[0]]; else #endif // CONFIG_EXT_INTER - mode_ctx = vp10_mode_context_analyzer(inter_mode_ctx, - mbmi->ref_frame, bsize, -1); + mode_ctx = + vp10_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame, bsize, -1); mbmi->ref_mv_idx = 0; #else mode_ctx = inter_mode_ctx[mbmi->ref_frame[0]]; @@ -1311,9 +1234,9 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { mbmi->mode = ZEROMV; if (bsize < BLOCK_8X8) { - vpx_internal_error(xd->error_info, VPX_CODEC_UNSUP_BITSTREAM, - "Invalid usage of segement feature on small blocks"); - return; + vpx_internal_error(xd->error_info, VPX_CODEC_UNSUP_BITSTREAM, + "Invalid usage of segement feature on small blocks"); + return; } } else { if (bsize >= BLOCK_8X8) { @@ -1322,11 +1245,11 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, mbmi->mode = read_inter_compound_mode(cm, xd, r, mode_ctx); else #endif // CONFIG_EXT_INTER - mbmi->mode = read_inter_mode(cm, xd, + mbmi->mode = read_inter_mode(cm, xd, #if CONFIG_REF_MV && CONFIG_EXT_INTER - mbmi, + mbmi, #endif // CONFIG_REF_MV && CONFIG_EXT_INTER - r, mode_ctx); + r, mode_ctx); #if CONFIG_REF_MV if (mbmi->mode == NEARMV || mbmi->mode == NEWMV) read_drl_idx(cm, xd, mbmi, r); @@ -1386,15 +1309,13 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, #if CONFIG_EXT_INTER if (xd->ref_mv_count[ref_frame_type] > 1) { - if (mbmi->mode == NEAR_NEWMV || - mbmi->mode == NEAR_NEARESTMV || + if (mbmi->mode == NEAR_NEWMV || mbmi->mode == NEAR_NEARESTMV || mbmi->mode == NEAR_NEARMV) { nearmv[0] = xd->ref_mv_stack[ref_frame_type][1].this_mv; lower_mv_precision(&nearmv[0].as_mv, allow_hp); } - if (mbmi->mode == NEW_NEARMV || - mbmi->mode == NEAREST_NEARMV || + if (mbmi->mode == NEW_NEARMV || mbmi->mode == NEAREST_NEARMV || mbmi->mode == NEAR_NEARMV) { nearmv[1] = xd->ref_mv_stack[ref_frame_type][1].comp_mv; lower_mv_precision(&nearmv[1].as_mv, allow_hp); @@ -1434,19 +1355,19 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, #if CONFIG_EXT_INTER if (!is_compound) #endif // CONFIG_EXT_INTER - mode_ctx = vp10_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame, - bsize, j); + mode_ctx = vp10_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame, + bsize, j); #endif #if CONFIG_EXT_INTER if (is_compound) b_mode = read_inter_compound_mode(cm, xd, r, mode_ctx); else #endif // CONFIG_EXT_INTER - b_mode = read_inter_mode(cm, xd, + b_mode = read_inter_mode(cm, xd, #if CONFIG_REF_MV && CONFIG_EXT_INTER - mbmi, + mbmi, #endif // CONFIG_REF_MV && CONFIG_EXT_INTER - r, mode_ctx); + r, mode_ctx); #if CONFIG_EXT_INTER mv_idx = (b_mode == NEWFROMNEARMV) ? 1 : 0; @@ -1463,25 +1384,24 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, #if CONFIG_EXT_INTER { int_mv mv_ref_list[MAX_MV_REF_CANDIDATES]; - vp10_update_mv_context(xd, mi, mbmi->ref_frame[ref], - mv_ref_list, j, mi_row, mi_col, NULL); + vp10_update_mv_context(xd, mi, mbmi->ref_frame[ref], mv_ref_list, j, + mi_row, mi_col, NULL); #endif // CONFIG_EXT_INTER - vp10_append_sub8x8_mvs_for_idx(cm, xd, j, ref, mi_row, mi_col, + vp10_append_sub8x8_mvs_for_idx( + cm, xd, j, ref, mi_row, mi_col, #if CONFIG_REF_MV - ref_mv_stack[ref], - &ref_mv_count[ref], + ref_mv_stack[ref], &ref_mv_count[ref], #endif #if CONFIG_EXT_INTER - mv_ref_list, + mv_ref_list, #endif // CONFIG_EXT_INTER - &nearest_sub8x8[ref], - &near_sub8x8[ref]); + &nearest_sub8x8[ref], &near_sub8x8[ref]); #if CONFIG_EXT_INTER if (have_newmv_in_inter_mode(b_mode)) { mv_ref_list[0].as_int = nearest_sub8x8[ref].as_int; mv_ref_list[1].as_int = near_sub8x8[ref].as_int; - vp10_find_best_ref_mvs(allow_hp, mv_ref_list, - &ref_mv[0][ref], &ref_mv[1][ref]); + vp10_find_best_ref_mvs(allow_hp, mv_ref_list, &ref_mv[0][ref], + &ref_mv[1][ref]); } } #endif // CONFIG_EXT_INTER @@ -1509,20 +1429,16 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, #else ref_mv_s8, #endif // CONFIG_EXT_INTER - nearest_sub8x8, near_sub8x8, - is_compound, allow_hp, r)) { + nearest_sub8x8, near_sub8x8, is_compound, allow_hp, r)) { xd->corrupted |= 1; break; }; mi->bmi[j].as_mv[0].as_int = block[0].as_int; - if (is_compound) - mi->bmi[j].as_mv[1].as_int = block[1].as_int; + if (is_compound) mi->bmi[j].as_mv[1].as_int = block[1].as_int; - if (num_4x4_h == 2) - mi->bmi[j + 2] = mi->bmi[j]; - if (num_4x4_w == 2) - mi->bmi[j + 1] = mi->bmi[j]; + if (num_4x4_h == 2) mi->bmi[j + 2] = mi->bmi[j]; + if (num_4x4_w == 2) mi->bmi[j + 1] = mi->bmi[j]; } } @@ -1544,27 +1460,28 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, #if CONFIG_REF_MV uint8_t ref_frame_type = vp10_ref_frame_type(mbmi->ref_frame); if (xd->ref_mv_count[ref_frame_type] > 1) { - ref_mv[ref] = (ref == 0) ? - xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].this_mv : - xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].comp_mv; + ref_mv[ref] = + (ref == 0) + ? xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].this_mv + : xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].comp_mv; clamp_mv_ref(&ref_mv[ref].as_mv, xd->n8_w << 3, xd->n8_h << 3, xd); } #endif nearestmv[ref] = ref_mv[ref]; } - xd->corrupted |= !assign_mv(cm, xd, mbmi->mode, + xd->corrupted |= + !assign_mv(cm, xd, mbmi->mode, #if CONFIG_REF_MV - 0, + 0, #endif - mbmi->mv, + mbmi->mv, #if CONFIG_EXT_INTER - mbmi->mode == NEWFROMNEARMV ? - nearmv : nearestmv, + mbmi->mode == NEWFROMNEARMV ? nearmv : nearestmv, #else - ref_mv, + ref_mv, #endif // CONFIG_EXT_INTER - nearestmv, nearmv, is_compound, allow_hp, r); + nearestmv, nearmv, is_compound, allow_hp, r); } #if CONFIG_EXT_INTER @@ -1576,8 +1493,7 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, is_interintra_allowed(mbmi)) { const int bsize_group = size_group_lookup[bsize]; const int interintra = vp10_read(r, cm->fc->interintra_prob[bsize_group]); - if (xd->counts) - xd->counts->interintra[bsize_group][interintra]++; + if (xd->counts) xd->counts->interintra[bsize_group][interintra]++; assert(mbmi->ref_frame[1] == NONE); if (interintra) { const INTERINTRA_MODE interintra_mode = @@ -1614,7 +1530,7 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, #if CONFIG_EXT_INTER if (mbmi->ref_frame[1] != INTRA_FRAME) #endif // CONFIG_EXT_INTER - mbmi->motion_variation = read_motvar_block(cm, xd, r); + mbmi->motion_variation = read_motvar_block(cm, xd, r); #endif // CONFIG_OBMC || CONFIG_WARPED_MOTION #if CONFIG_EXT_INTER @@ -1640,8 +1556,9 @@ static void read_inter_block_mode_info(VP10Decoder *const pbi, #if CONFIG_DUAL_FILTER for (ref = 0; ref < 2; ++ref) { - mbmi->interp_filter[ref] = (cm->interp_filter == SWITCHABLE) ? - EIGHTTAP_REGULAR : cm->interp_filter; + mbmi->interp_filter[ref] = (cm->interp_filter == SWITCHABLE) + ? EIGHTTAP_REGULAR + : cm->interp_filter; if (has_subpel_mv_component(xd->mi[0], xd, ref) || (mbmi->ref_frame[1] > INTRA_FRAME && @@ -1686,19 +1603,19 @@ static void read_inter_frame_mode_info(VP10Decoder *const pbi, #if CONFIG_VAR_TX xd->above_txfm_context = cm->above_txfm_context + mi_col; xd->left_txfm_context = - xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); - if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT && - !mbmi->skip && inter_block) { + xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); + if (bsize >= BLOCK_8X8 && cm->tx_mode == TX_MODE_SELECT && !mbmi->skip && + inter_block) { const TX_SIZE max_tx_size = max_txsize_lookup[bsize]; const BLOCK_SIZE txb_size = txsize_to_bsize[max_tx_size]; const int bs = num_4x4_blocks_wide_lookup[txb_size]; - const int width = num_4x4_blocks_wide_lookup[bsize]; + const int width = num_4x4_blocks_wide_lookup[bsize]; const int height = num_4x4_blocks_high_lookup[bsize]; int idx, idy; for (idy = 0; idy < height; idy += bs) for (idx = 0; idx < width; idx += bs) - read_tx_size_vartx(cm, xd, mbmi, xd->counts, max_tx_size, - idy, idx, r); + read_tx_size_vartx(cm, xd, mbmi, xd->counts, max_tx_size, idy, idx, + r); if (xd->counts) { const int ctx = get_tx_size_context(xd); ++xd->counts->tx_size[max_tx_size - TX_8X8][ctx][mbmi->tx_size]; @@ -1710,7 +1627,7 @@ static void read_inter_frame_mode_info(VP10Decoder *const pbi, mbmi->tx_size = read_tx_size_intra(cm, xd, r); if (inter_block) { - const int width = num_4x4_blocks_wide_lookup[bsize]; + const int width = num_4x4_blocks_wide_lookup[bsize]; const int height = num_4x4_blocks_high_lookup[bsize]; int idx, idy; for (idy = 0; idy < height; ++idy) @@ -1722,23 +1639,22 @@ static void read_inter_frame_mode_info(VP10Decoder *const pbi, set_txfm_ctx(xd->above_txfm_context, mbmi->tx_size, xd->n8_w); } #else - if (inter_block) - mbmi->tx_size = read_tx_size_inter(cm, xd, !mbmi->skip, r); - else - mbmi->tx_size = read_tx_size_intra(cm, xd, r); + if (inter_block) + mbmi->tx_size = read_tx_size_inter(cm, xd, !mbmi->skip, r); + else + mbmi->tx_size = read_tx_size_intra(cm, xd, r); #endif // CONFIG_VAR_TX #if CONFIG_SUPERTX } #if CONFIG_VAR_TX else if (inter_block) { - const int width = num_4x4_blocks_wide_lookup[bsize]; + const int width = num_4x4_blocks_wide_lookup[bsize]; const int height = num_4x4_blocks_high_lookup[bsize]; int idx, idy; xd->mi[0]->mbmi.tx_size = xd->supertx_size; for (idy = 0; idy < height; ++idy) for (idx = 0; idx < width; ++idx) - xd->mi[0]->mbmi.inter_tx_size[idy >> 1][idx >> 1] = - xd->supertx_size; + xd->mi[0]->mbmi.inter_tx_size[idy >> 1][idx >> 1] = xd->supertx_size; } #endif // CONFIG_VAR_TX #endif // CONFIG_SUPERTX @@ -1762,34 +1678,32 @@ static void read_inter_frame_mode_info(VP10Decoder *const pbi, !supertx_enabled && #endif // CONFIG_SUPERTX !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { - int eset = get_ext_tx_set(mbmi->tx_size, mbmi->sb_type, - inter_block); + int eset = get_ext_tx_set(mbmi->tx_size, mbmi->sb_type, inter_block); FRAME_COUNTS *counts = xd->counts; if (inter_block) { if (eset > 0) { mbmi->tx_type = vp10_read_tree(r, vp10_ext_tx_inter_tree[eset], - cm->fc->inter_ext_tx_prob[eset][mbmi->tx_size]); + cm->fc->inter_ext_tx_prob[eset][mbmi->tx_size]); if (counts) ++counts->inter_ext_tx[eset][mbmi->tx_size][mbmi->tx_type]; } } else if (ALLOW_INTRA_EXT_TX) { if (eset > 0) { - mbmi->tx_type = vp10_read_tree(r, vp10_ext_tx_intra_tree[eset], - cm->fc->intra_ext_tx_prob[eset] - [mbmi->tx_size][mbmi->mode]); + mbmi->tx_type = vp10_read_tree( + r, vp10_ext_tx_intra_tree[eset], + cm->fc->intra_ext_tx_prob[eset][mbmi->tx_size][mbmi->mode]); if (counts) - ++counts->intra_ext_tx[eset][mbmi->tx_size] - [mbmi->mode][mbmi->tx_type]; + ++counts->intra_ext_tx[eset][mbmi->tx_size][mbmi->mode] + [mbmi->tx_type]; } } } else { mbmi->tx_type = DCT_DCT; } #else - if (mbmi->tx_size < TX_32X32 && - cm->base_qindex > 0 && !mbmi->skip && + if (mbmi->tx_size < TX_32X32 && cm->base_qindex > 0 && !mbmi->skip && #if CONFIG_SUPERTX !supertx_enabled && #endif // CONFIG_SUPERTX @@ -1797,10 +1711,8 @@ static void read_inter_frame_mode_info(VP10Decoder *const pbi, FRAME_COUNTS *counts = xd->counts; if (inter_block) { mbmi->tx_type = vp10_read_tree( - r, vp10_ext_tx_tree, - cm->fc->inter_ext_tx_prob[mbmi->tx_size]); - if (counts) - ++counts->inter_ext_tx[mbmi->tx_size][mbmi->tx_type]; + r, vp10_ext_tx_tree, cm->fc->inter_ext_tx_prob[mbmi->tx_size]); + if (counts) ++counts->inter_ext_tx[mbmi->tx_size][mbmi->tx_type]; } else { const TX_TYPE tx_type_nom = intra_mode_to_tx_type_context[mbmi->mode]; mbmi->tx_type = vp10_read_tree( @@ -1820,11 +1732,11 @@ void vp10_read_mode_info(VP10Decoder *const pbi, MACROBLOCKD *xd, #if CONFIG_SUPERTX int supertx_enabled, #endif // CONFIG_SUPERTX - int mi_row, int mi_col, vp10_reader *r, - int x_mis, int y_mis) { + int mi_row, int mi_col, vp10_reader *r, int x_mis, + int y_mis) { VP10_COMMON *const cm = &pbi->common; MODE_INFO *const mi = xd->mi[0]; - MV_REF* frame_mvs = cm->cur_frame->mvs + mi_row * cm->mi_cols + mi_col; + MV_REF *frame_mvs = cm->cur_frame->mvs + mi_row * cm->mi_cols + mi_col; int w, h; if (frame_is_intra_only(cm)) { diff --git a/vp10/decoder/decodemv.h b/vp10/decoder/decodemv.h index c10c6bf38..b99f5a5ce 100644 --- a/vp10/decoder/decodemv.h +++ b/vp10/decoder/decodemv.h @@ -24,8 +24,8 @@ void vp10_read_mode_info(VP10Decoder *const pbi, MACROBLOCKD *xd, int supertx_enabled, #endif - int mi_row, int mi_col, vp10_reader *r, - int x_mis, int y_mis); + int mi_row, int mi_col, vp10_reader *r, int x_mis, + int y_mis); #ifdef __cplusplus } // extern "C" diff --git a/vp10/decoder/decoder.c b/vp10/decoder/decoder.c index 237acab75..28e87c0b9 100644 --- a/vp10/decoder/decoder.c +++ b/vp10/decoder/decoder.c @@ -58,12 +58,10 @@ static void vp10_dec_setup_mi(VP10_COMMON *cm) { static int vp10_dec_alloc_mi(VP10_COMMON *cm, int mi_size) { cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip)); - if (!cm->mip) - return 1; + if (!cm->mip) return 1; cm->mi_alloc_size = mi_size; - cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO*)); - if (!cm->mi_grid_base) - return 1; + cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO *)); + if (!cm->mi_grid_base) return 1; return 0; } @@ -78,8 +76,7 @@ VP10Decoder *vp10_decoder_create(BufferPool *const pool) { VP10Decoder *volatile const pbi = vpx_memalign(32, sizeof(*pbi)); VP10_COMMON *volatile const cm = pbi ? &pbi->common : NULL; - if (!cm) - return NULL; + if (!cm) return NULL; vp10_zero(*pbi); @@ -91,11 +88,10 @@ VP10Decoder *vp10_decoder_create(BufferPool *const pool) { cm->error.setjmp = 1; - CHECK_MEM_ERROR(cm, cm->fc, - (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc))); - CHECK_MEM_ERROR(cm, cm->frame_contexts, - (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, - sizeof(*cm->frame_contexts))); + CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc))); + CHECK_MEM_ERROR( + cm, cm->frame_contexts, + (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, sizeof(*cm->frame_contexts))); pbi->need_resync = 1; once(initialize_dec); @@ -130,8 +126,7 @@ VP10Decoder *vp10_decoder_create(BufferPool *const pool) { void vp10_decoder_remove(VP10Decoder *pbi) { int i; - if (!pbi) - return; + if (!pbi) return; vpx_get_worker_interface()->end(&pbi->lf_worker); vpx_free(pbi->lf_worker.data1); @@ -153,13 +148,13 @@ void vp10_decoder_remove(VP10Decoder *pbi) { static int equal_dimensions(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b) { - return a->y_height == b->y_height && a->y_width == b->y_width && - a->uv_height == b->uv_height && a->uv_width == b->uv_width; + return a->y_height == b->y_height && a->y_width == b->y_width && + a->uv_height == b->uv_height && a->uv_width == b->uv_width; } vpx_codec_err_t vp10_copy_reference_dec(VP10Decoder *pbi, - VPX_REFFRAME ref_frame_flag, - YV12_BUFFER_CONFIG *sd) { + VPX_REFFRAME ref_frame_flag, + YV12_BUFFER_CONFIG *sd) { VP10_COMMON *cm = &pbi->common; /* TODO(jkoleszar): The decoder doesn't have any real knowledge of what the @@ -180,17 +175,15 @@ vpx_codec_err_t vp10_copy_reference_dec(VP10Decoder *pbi, else vpx_yv12_copy_frame(cfg, sd); } else { - vpx_internal_error(&cm->error, VPX_CODEC_ERROR, - "Invalid reference frame"); + vpx_internal_error(&cm->error, VPX_CODEC_ERROR, "Invalid reference frame"); } return cm->error.error_code; } - vpx_codec_err_t vp10_set_reference_dec(VP10_COMMON *cm, - VPX_REFFRAME ref_frame_flag, - YV12_BUFFER_CONFIG *sd) { + VPX_REFFRAME ref_frame_flag, + YV12_BUFFER_CONFIG *sd) { int idx; YV12_BUFFER_CONFIG *ref_buf = NULL; @@ -235,8 +228,7 @@ vpx_codec_err_t vp10_set_reference_dec(VP10_COMMON *cm, idx = cm->ref_frame_map[2]; #endif // CONFIG_EXT_REFS } else { - vpx_internal_error(&cm->error, VPX_CODEC_ERROR, - "Invalid reference frame"); + vpx_internal_error(&cm->error, VPX_CODEC_ERROR, "Invalid reference frame"); return cm->error.error_code; } @@ -275,8 +267,7 @@ static void swap_frame_buffers(VP10Decoder *pbi) { // Release the reference frame holding in the reference map for the decoding // of the next frame. - if (mask & 1) - decrease_ref_count(old_idx, frame_bufs, pool); + if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool); cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; ++ref_index; } @@ -307,8 +298,8 @@ static void swap_frame_buffers(VP10Decoder *pbi) { } } -int vp10_receive_compressed_data(VP10Decoder *pbi, - size_t size, const uint8_t **psource) { +int vp10_receive_compressed_data(VP10Decoder *pbi, size_t size, + const uint8_t **psource) { VP10_COMMON *volatile const cm = &pbi->common; BufferPool *volatile const pool = cm->buffer_pool; RefCntBuffer *volatile const frame_bufs = cm->buffer_pool->frame_bufs; @@ -338,15 +329,14 @@ int vp10_receive_compressed_data(VP10Decoder *pbi, // Check if the previous frame was a frame without any references to it. // Release frame buffer if not decoding in frame parallel mode. - if (!cm->frame_parallel_decode && cm->new_fb_idx >= 0 - && frame_bufs[cm->new_fb_idx].ref_count == 0) + if (!cm->frame_parallel_decode && cm->new_fb_idx >= 0 && + frame_bufs[cm->new_fb_idx].ref_count == 0) pool->release_fb_cb(pool->cb_priv, &frame_bufs[cm->new_fb_idx].raw_frame_buffer); // Find a free frame buffer. Return error if can not find any. cm->new_fb_idx = get_free_fb(cm); - if (cm->new_fb_idx == INVALID_IDX) - return VPX_CODEC_MEM_ERROR; + if (cm->new_fb_idx == INVALID_IDX) return VPX_CODEC_MEM_ERROR; // Assign a MV array to the frame buffer. cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx]; @@ -388,10 +378,9 @@ int vp10_receive_compressed_data(VP10Decoder *pbi, // Current thread releases the holding of reference frame. decrease_ref_count(old_idx, frame_bufs, pool); - // Release the reference frame holding in the reference map for the - // decoding of the next frame. - if (mask & 1) - decrease_ref_count(old_idx, frame_bufs, pool); + // Release the reference frame holding in the reference map for the + // decoding of the next frame. + if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool); ++ref_index; } @@ -468,14 +457,12 @@ int vp10_receive_compressed_data(VP10Decoder *pbi, int vp10_get_raw_frame(VP10Decoder *pbi, YV12_BUFFER_CONFIG *sd) { VP10_COMMON *const cm = &pbi->common; int ret = -1; - if (pbi->ready_for_new_data == 1) - return ret; + if (pbi->ready_for_new_data == 1) return ret; pbi->ready_for_new_data = 1; /* no raw frame to show!!! */ - if (!cm->show_frame) - return ret; + if (!cm->show_frame) return ret; pbi->ready_for_new_data = 1; *sd = *cm->frame_to_show; @@ -484,22 +471,19 @@ int vp10_get_raw_frame(VP10Decoder *pbi, YV12_BUFFER_CONFIG *sd) { return ret; } -int vp10_get_frame_to_show(VP10Decoder *pbi, - YV12_BUFFER_CONFIG *frame) { +int vp10_get_frame_to_show(VP10Decoder *pbi, YV12_BUFFER_CONFIG *frame) { VP10_COMMON *const cm = &pbi->common; - if (!cm->show_frame || !cm->frame_to_show) - return -1; + if (!cm->show_frame || !cm->frame_to_show) return -1; *frame = *cm->frame_to_show; return 0; } -vpx_codec_err_t vp10_parse_superframe_index(const uint8_t *data, - size_t data_sz, - uint32_t sizes[8], int *count, - vpx_decrypt_cb decrypt_cb, - void *decrypt_state) { +vpx_codec_err_t vp10_parse_superframe_index(const uint8_t *data, size_t data_sz, + uint32_t sizes[8], int *count, + vpx_decrypt_cb decrypt_cb, + void *decrypt_state) { // A chunk ending with a byte matching 0xc0 is an invalid chunk unless // it is a super frame index. If the last byte of real video compression // data is 0xc0 the encoder must add a 0 byte. If we have the marker but @@ -520,18 +504,16 @@ vpx_codec_err_t vp10_parse_superframe_index(const uint8_t *data, // This chunk is marked as having a superframe index but doesn't have // enough data for it, thus it's an invalid superframe index. - if (data_sz < index_sz) - return VPX_CODEC_CORRUPT_FRAME; + if (data_sz < index_sz) return VPX_CODEC_CORRUPT_FRAME; { - const uint8_t marker2 = read_marker(decrypt_cb, decrypt_state, - data + data_sz - index_sz); + const uint8_t marker2 = + read_marker(decrypt_cb, decrypt_state, data + data_sz - index_sz); // This chunk is marked as having a superframe index but doesn't have // the matching marker byte at the front of the index therefore it's an // invalid chunk. - if (marker != marker2) - return VPX_CODEC_CORRUPT_FRAME; + if (marker != marker2) return VPX_CODEC_CORRUPT_FRAME; } { @@ -550,8 +532,7 @@ vpx_codec_err_t vp10_parse_superframe_index(const uint8_t *data, for (i = 0; i < frames - 1; ++i) { uint32_t this_sz = 0; - for (j = 0; j < mag; ++j) - this_sz |= (*x++) << (j * 8); + for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8); this_sz += 1; sizes[i] = this_sz; frame_sz_sum += this_sz; diff --git a/vp10/decoder/decoder.h b/vp10/decoder/decoder.h index caf55e911..092c4a9cc 100644 --- a/vp10/decoder/decoder.h +++ b/vp10/decoder/decoder.h @@ -52,7 +52,7 @@ typedef struct TileBufferDec { size_t size; const uint8_t *raw_data_end; // The end of the raw tile buffer in the // bit stream. - int col; // only used with multi-threaded decoding + int col; // only used with multi-threaded decoding } TileBufferDec; typedef struct VP10Decoder { @@ -66,9 +66,9 @@ typedef struct VP10Decoder { // TODO(hkuang): Combine this with cur_buf in macroblockd as they are // the same. - RefCntBuffer *cur_buf; // Current decoding frame buffer. + RefCntBuffer *cur_buf; // Current decoding frame buffer. - VPxWorker *frame_worker_owner; // frame_worker that owns this pbi. + VPxWorker *frame_worker_owner; // frame_worker that owns this pbi. VPxWorker lf_worker; VPxWorker *tile_workers; TileWorkerData *tile_worker_data; @@ -87,7 +87,7 @@ typedef struct VP10Decoder { int max_threads; int inv_tile_order; - int need_resync; // wait for key/intra-only frame. + int need_resync; // wait for key/intra-only frame. int hold_ref_buf; // hold the reference buffer. int tile_size_bytes; @@ -97,24 +97,23 @@ typedef struct VP10Decoder { #endif // CONFIG_EXT_TILE } VP10Decoder; -int vp10_receive_compressed_data(struct VP10Decoder *pbi, - size_t size, const uint8_t **dest); +int vp10_receive_compressed_data(struct VP10Decoder *pbi, size_t size, + const uint8_t **dest); int vp10_get_raw_frame(struct VP10Decoder *pbi, YV12_BUFFER_CONFIG *sd); int vp10_get_frame_to_show(struct VP10Decoder *pbi, YV12_BUFFER_CONFIG *frame); vpx_codec_err_t vp10_copy_reference_dec(struct VP10Decoder *pbi, + VPX_REFFRAME ref_frame_flag, + YV12_BUFFER_CONFIG *sd); + +vpx_codec_err_t vp10_set_reference_dec(VP10_COMMON *cm, VPX_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd); -vpx_codec_err_t vp10_set_reference_dec(VP10_COMMON *cm, - VPX_REFFRAME ref_frame_flag, - YV12_BUFFER_CONFIG *sd); - static INLINE uint8_t read_marker(vpx_decrypt_cb decrypt_cb, - void *decrypt_state, - const uint8_t *data) { + void *decrypt_state, const uint8_t *data) { if (decrypt_cb) { uint8_t marker; decrypt_cb(decrypt_state, data, &marker, 1); @@ -125,11 +124,10 @@ static INLINE uint8_t read_marker(vpx_decrypt_cb decrypt_cb, // This function is exposed for use in tests, as well as the inlined function // "read_marker". -vpx_codec_err_t vp10_parse_superframe_index(const uint8_t *data, - size_t data_sz, - uint32_t sizes[8], int *count, - vpx_decrypt_cb decrypt_cb, - void *decrypt_state); +vpx_codec_err_t vp10_parse_superframe_index(const uint8_t *data, size_t data_sz, + uint32_t sizes[8], int *count, + vpx_decrypt_cb decrypt_cb, + void *decrypt_state); struct VP10Decoder *vp10_decoder_create(BufferPool *const pool); @@ -158,8 +156,7 @@ static INLINE int dec_is_ref_frame_buf(VP10Decoder *const pbi, for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { RefBuffer *const ref_frame = &cm->frame_refs[i]; if (ref_frame->idx == INVALID_IDX) continue; - if (frame_buf == &cm->buffer_pool->frame_bufs[ref_frame->idx]) - break; + if (frame_buf == &cm->buffer_pool->frame_bufs[ref_frame->idx]) break; } return (i < INTER_REFS_PER_FRAME); } diff --git a/vp10/decoder/detokenize.c b/vp10/decoder/detokenize.c index 7cbf01e56..e08d21141 100644 --- a/vp10/decoder/detokenize.c +++ b/vp10/decoder/detokenize.c @@ -19,34 +19,31 @@ #include "vp10/decoder/detokenize.h" -#define EOB_CONTEXT_NODE 0 -#define ZERO_CONTEXT_NODE 1 -#define ONE_CONTEXT_NODE 2 -#define LOW_VAL_CONTEXT_NODE 0 -#define TWO_CONTEXT_NODE 1 -#define THREE_CONTEXT_NODE 2 -#define HIGH_LOW_CONTEXT_NODE 3 -#define CAT_ONE_CONTEXT_NODE 4 -#define CAT_THREEFOUR_CONTEXT_NODE 5 -#define CAT_THREE_CONTEXT_NODE 6 -#define CAT_FIVE_CONTEXT_NODE 7 +#define EOB_CONTEXT_NODE 0 +#define ZERO_CONTEXT_NODE 1 +#define ONE_CONTEXT_NODE 2 +#define LOW_VAL_CONTEXT_NODE 0 +#define TWO_CONTEXT_NODE 1 +#define THREE_CONTEXT_NODE 2 +#define HIGH_LOW_CONTEXT_NODE 3 +#define CAT_ONE_CONTEXT_NODE 4 +#define CAT_THREEFOUR_CONTEXT_NODE 5 +#define CAT_THREE_CONTEXT_NODE 6 +#define CAT_FIVE_CONTEXT_NODE 7 -#define INCREMENT_COUNT(token) \ - do { \ - if (counts) \ - ++coef_counts[band][ctx][token]; \ +#define INCREMENT_COUNT(token) \ + do { \ + if (counts) ++coef_counts[band][ctx][token]; \ } while (0) #if !CONFIG_ANS static INLINE int read_coeff(const vpx_prob *probs, int n, vp10_reader *r) { int i, val = 0; - for (i = 0; i < n; ++i) - val = (val << 1) | vp10_read(r, probs[i]); + for (i = 0; i < n; ++i) val = (val << 1) | vp10_read(r, probs[i]); return val; } -static int decode_coefs(const MACROBLOCKD *xd, - PLANE_TYPE type, +static int decode_coefs(const MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff, TX_SIZE tx_size, TX_TYPE tx_type, const int16_t *dq, #if CONFIG_NEW_QUANT @@ -60,11 +57,11 @@ static int decode_coefs(const MACROBLOCKD *xd, const int ref = is_inter_block(&xd->mi[0]->mbmi); int band, c = 0; const int tx_size_ctx = txsize_sqr_map[tx_size]; - const vpx_prob (*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] = + const vpx_prob(*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] = fc->coef_probs[tx_size_ctx][type][ref]; const vpx_prob *prob; - unsigned int (*coef_counts)[COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1]; - unsigned int (*eob_branch_count)[COEFF_CONTEXTS]; + unsigned int(*coef_counts)[COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1]; + unsigned int(*eob_branch_count)[COEFF_CONTEXTS]; uint8_t token_cache[MAX_TX_SQUARE]; const uint8_t *band_translate = get_band_translate(tx_size); int dq_shift; @@ -125,8 +122,7 @@ static int decode_coefs(const MACROBLOCKD *xd, int val = -1; band = *band_translate++; prob = coef_probs[band][ctx]; - if (counts) - ++eob_branch_count[band][ctx]; + if (counts) ++eob_branch_count[band][ctx]; if (!vp10_read(r, prob[EOB_CONTEXT_NODE])) { INCREMENT_COUNT(EOB_MODEL_TOKEN); break; @@ -141,8 +137,7 @@ static int decode_coefs(const MACROBLOCKD *xd, dqv = dq[1]; token_cache[scan[c]] = 0; ++c; - if (c >= max_eob) - return c; // zero tokens at the end (no eob token) + if (c >= max_eob) return c; // zero tokens at the end (no eob token) ctx = get_coef_context(nb, token_cache, c); band = *band_translate++; prob = coef_probs[band][ctx]; @@ -158,13 +153,11 @@ static int decode_coefs(const MACROBLOCKD *xd, } else { INCREMENT_COUNT(TWO_TOKEN); token = vp10_read_tree(r, vp10_coef_con_tree, - vp10_pareto8_full[prob[PIVOT_NODE] - 1]); + vp10_pareto8_full[prob[PIVOT_NODE] - 1]); switch (token) { case TWO_TOKEN: case THREE_TOKEN: - case FOUR_TOKEN: - val = token; - break; + case FOUR_TOKEN: val = token; break; case CATEGORY1_TOKEN: val = CAT1_MIN_VAL + read_coeff(cat1_prob, 1, r); break; @@ -194,9 +187,7 @@ static int decode_coefs(const MACROBLOCKD *xd, case VPX_BITS_12: val = CAT6_MIN_VAL + read_coeff(cat6p, 18 - skip_bits, r); break; - default: - assert(0); - return -1; + default: assert(0); return -1; } #else val = CAT6_MIN_VAL + read_coeff(cat6p, 14 - skip_bits, r); @@ -214,8 +205,7 @@ static int decode_coefs(const MACROBLOCKD *xd, #if CONFIG_COEFFICIENT_RANGE_CHECKING #if CONFIG_VP9_HIGHBITDEPTH - dqcoeff[scan[c]] = highbd_check_range((vp10_read_bit(r) ? -v : v), - xd->bd); + dqcoeff[scan[c]] = highbd_check_range((vp10_read_bit(r) ? -v : v), xd->bd); #else dqcoeff[scan[c]] = check_range(vp10_read_bit(r) ? -v : v); #endif // CONFIG_VP9_HIGHBITDEPTH @@ -234,16 +224,13 @@ static int decode_coefs(const MACROBLOCKD *xd, static INLINE int read_coeff(const vpx_prob *const probs, int n, struct AnsDecoder *const ans) { int i, val = 0; - for (i = 0; i < n; ++i) - val = (val << 1) | uabs_read(ans, probs[i]); + for (i = 0; i < n; ++i) val = (val << 1) | uabs_read(ans, probs[i]); return val; } -static int decode_coefs_ans(const MACROBLOCKD *const xd, - PLANE_TYPE type, +static int decode_coefs_ans(const MACROBLOCKD *const xd, PLANE_TYPE type, tran_low_t *dqcoeff, TX_SIZE tx_size, - TX_TYPE tx_type, - const int16_t *dq, + TX_TYPE tx_type, const int16_t *dq, #if CONFIG_NEW_QUANT dequant_val_type_nuq *dq_val, #endif // CONFIG_NEW_QUANT @@ -256,14 +243,14 @@ static int decode_coefs_ans(const MACROBLOCKD *const xd, int band, c = 0; int skip_eob = 0; const int tx_size_ctx = txsize_sqr_map[tx_size]; - const vpx_prob (*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] = + const vpx_prob(*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] = fc->coef_probs[tx_size_ctx][type][ref]; const rans_dec_lut(*coef_cdfs)[COEFF_CONTEXTS] = fc->coef_cdfs[tx_size_ctx][type][ref]; const vpx_prob *prob; const rans_dec_lut *cdf; - unsigned int (*coef_counts)[COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1]; - unsigned int (*eob_branch_count)[COEFF_CONTEXTS]; + unsigned int(*coef_counts)[COEFF_CONTEXTS][UNCONSTRAINED_NODES + 1]; + unsigned int(*eob_branch_count)[COEFF_CONTEXTS]; uint8_t token_cache[MAX_TX_SQUARE]; const uint8_t *band_translate = get_band_translate(tx_size); int dq_shift; @@ -325,8 +312,7 @@ static int decode_coefs_ans(const MACROBLOCKD *const xd, band = *band_translate++; prob = coef_probs[band][ctx]; if (!skip_eob) { - if (counts) - ++eob_branch_count[band][ctx]; + if (counts) ++eob_branch_count[band][ctx]; if (!uabs_read(ans, prob[EOB_CONTEXT_NODE])) { INCREMENT_COUNT(EOB_MODEL_TOKEN); break; @@ -349,9 +335,7 @@ static int decode_coefs_ans(const MACROBLOCKD *const xd, case ONE_TOKEN: case TWO_TOKEN: case THREE_TOKEN: - case FOUR_TOKEN: - val = token; - break; + case FOUR_TOKEN: val = token; break; case CATEGORY1_TOKEN: val = CAT1_MIN_VAL + read_coeff(cat1_prob, 1, ans); break; @@ -381,9 +365,7 @@ static int decode_coefs_ans(const MACROBLOCKD *const xd, case VPX_BITS_12: val = CAT6_MIN_VAL + read_coeff(cat6p, 18 - skip_bits, ans); break; - default: - assert(0); - return -1; + default: assert(0); return -1; } #else val = CAT6_MIN_VAL + read_coeff(cat6p, 14 - skip_bits, ans); @@ -391,10 +373,10 @@ static int decode_coefs_ans(const MACROBLOCKD *const xd, } break; } #if CONFIG_NEW_QUANT - v = vp10_dequant_abscoeff_nuq(val, dqv, dqv_val); - v = dq_shift ? ROUND_POWER_OF_TWO(v, dq_shift) : v; + v = vp10_dequant_abscoeff_nuq(val, dqv, dqv_val); + v = dq_shift ? ROUND_POWER_OF_TWO(v, dq_shift) : v; #else - v = (val * dqv) >> dq_shift; + v = (val * dqv) >> dq_shift; #endif // CONFIG_NEW_QUANT #if CONFIG_COEFFICIENT_RANGE_CHECKING @@ -419,12 +401,12 @@ static int decode_coefs_ans(const MACROBLOCKD *const xd, } #endif // !CONFIG_ANS -// TODO(slavarnway): Decode version of vp10_set_context. Modify vp10_set_context +// TODO(slavarnway): Decode version of vp10_set_context. Modify +// vp10_set_context // after testing is complete, then delete this version. -static -void dec_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd, - TX_SIZE tx_size, int has_eob, - int aoff, int loff) { +static void dec_set_contexts(const MACROBLOCKD *xd, + struct macroblockd_plane *pd, TX_SIZE tx_size, + int has_eob, int aoff, int loff) { ENTROPY_CONTEXT *const a = pd->above_context + aoff; ENTROPY_CONTEXT *const l = pd->left_context + loff; const int tx_w_in_blocks = num_4x4_blocks_wide_txsize_lookup[tx_size]; @@ -433,16 +415,14 @@ void dec_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd, // above if (has_eob && xd->mb_to_right_edge < 0) { int i; - const int blocks_wide = pd->n4_w + - (xd->mb_to_right_edge >> (5 + pd->subsampling_x)); + const int blocks_wide = + pd->n4_w + (xd->mb_to_right_edge >> (5 + pd->subsampling_x)); int above_contexts = tx_w_in_blocks; if (above_contexts + aoff > blocks_wide) above_contexts = blocks_wide - aoff; - for (i = 0; i < above_contexts; ++i) - a[i] = has_eob; - for (i = above_contexts; i < tx_w_in_blocks; ++i) - a[i] = 0; + for (i = 0; i < above_contexts; ++i) a[i] = has_eob; + for (i = above_contexts; i < tx_w_in_blocks; ++i) a[i] = 0; } else { memset(a, has_eob, sizeof(ENTROPY_CONTEXT) * tx_w_in_blocks); } @@ -450,16 +430,13 @@ void dec_set_contexts(const MACROBLOCKD *xd, struct macroblockd_plane *pd, // left if (has_eob && xd->mb_to_bottom_edge < 0) { int i; - const int blocks_high = pd->n4_h + - (xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); + const int blocks_high = + pd->n4_h + (xd->mb_to_bottom_edge >> (5 + pd->subsampling_y)); int left_contexts = tx_h_in_blocks; - if (left_contexts + loff > blocks_high) - left_contexts = blocks_high - loff; + if (left_contexts + loff > blocks_high) left_contexts = blocks_high - loff; - for (i = 0; i < left_contexts; ++i) - l[i] = has_eob; - for (i = left_contexts; i < tx_h_in_blocks; ++i) - l[i] = 0; + for (i = 0; i < left_contexts; ++i) l[i] = has_eob; + for (i = left_contexts; i < tx_h_in_blocks; ++i) l[i] = 0; } else { memset(l, has_eob, sizeof(ENTROPY_CONTEXT) * tx_h_in_blocks); } @@ -471,34 +448,32 @@ void vp10_decode_palette_tokens(MACROBLOCKD *const xd, int plane, MB_MODE_INFO *const mbmi = &mi->mbmi; const BLOCK_SIZE bsize = mbmi->sb_type; const int rows = (4 * num_4x4_blocks_high_lookup[bsize]) >> - (xd->plane[plane != 0].subsampling_y); + (xd->plane[plane != 0].subsampling_y); const int cols = (4 * num_4x4_blocks_wide_lookup[bsize]) >> - (xd->plane[plane != 0].subsampling_x); + (xd->plane[plane != 0].subsampling_x); int color_idx, color_ctx, color_order[PALETTE_MAX_SIZE]; int n = mbmi->palette_mode_info.palette_size[plane != 0]; int i, j; uint8_t *color_map = xd->plane[plane != 0].color_index_map; - const vpx_prob (* const prob)[PALETTE_COLOR_CONTEXTS][PALETTE_COLORS - 1] = - plane ? vp10_default_palette_uv_color_prob : - vp10_default_palette_y_color_prob; + const vpx_prob (*const prob)[PALETTE_COLOR_CONTEXTS][PALETTE_COLORS - 1] = + plane ? vp10_default_palette_uv_color_prob + : vp10_default_palette_y_color_prob; for (i = 0; i < rows; ++i) { for (j = (i == 0 ? 1 : 0); j < cols; ++j) { - color_ctx = vp10_get_palette_color_context(color_map, cols, i, j, n, - color_order); + color_ctx = + vp10_get_palette_color_context(color_map, cols, i, j, n, color_order); color_idx = vp10_read_tree(r, vp10_palette_color_tree[n - 2], - prob[n - 2][color_ctx]); + prob[n - 2][color_ctx]); assert(color_idx >= 0 && color_idx < n); color_map[i * cols + j] = color_order[color_idx]; } } } -int vp10_decode_block_tokens(MACROBLOCKD *const xd, - int plane, const scan_order *sc, - int x, int y, - TX_SIZE tx_size, - TX_TYPE tx_type, +int vp10_decode_block_tokens(MACROBLOCKD *const xd, int plane, + const scan_order *sc, int x, int y, + TX_SIZE tx_size, TX_TYPE tx_type, #if CONFIG_ANS struct AnsDecoder *const r, #else @@ -507,24 +482,22 @@ int vp10_decode_block_tokens(MACROBLOCKD *const xd, int seg_id) { struct macroblockd_plane *const pd = &xd->plane[plane]; const int16_t *const dequant = pd->seg_dequant[seg_id]; - const int ctx = get_entropy_context(tx_size, pd->above_context + x, - pd->left_context + y); + const int ctx = + get_entropy_context(tx_size, pd->above_context + x, pd->left_context + y); #if CONFIG_NEW_QUANT int dq = get_dq_profile_from_ctx(ctx); #endif // CONFIG_NEW_QUANT #if !CONFIG_ANS - const int eob = decode_coefs(xd, pd->plane_type, - pd->dqcoeff, tx_size, tx_type, - dequant, + const int eob = + decode_coefs(xd, pd->plane_type, pd->dqcoeff, tx_size, tx_type, dequant, #if CONFIG_NEW_QUANT - pd->seg_dequant_nuq[seg_id][dq], + pd->seg_dequant_nuq[seg_id][dq], #endif // CONFIG_NEW_QUANT - ctx, sc->scan, sc->neighbors, r); + ctx, sc->scan, sc->neighbors, r); #else - const int eob = decode_coefs_ans(xd, pd->plane_type, - pd->dqcoeff, tx_size, tx_type, - dequant, + const int eob = decode_coefs_ans(xd, pd->plane_type, pd->dqcoeff, tx_size, + tx_type, dequant, #if CONFIG_NEW_QUANT pd->seg_dequant_nuq[seg_id][dq], #endif // CONFIG_NEW_QUANT diff --git a/vp10/decoder/detokenize.h b/vp10/decoder/detokenize.h index 7b25b41a1..5e60a4cf1 100644 --- a/vp10/decoder/detokenize.h +++ b/vp10/decoder/detokenize.h @@ -8,7 +8,6 @@ * be found in the AUTHORS file in the root of the source tree. */ - #ifndef VP10_DECODER_DETOKENIZE_H_ #define VP10_DECODER_DETOKENIZE_H_ @@ -22,11 +21,9 @@ extern "C" { void vp10_decode_palette_tokens(MACROBLOCKD *const xd, int plane, vp10_reader *r); -int vp10_decode_block_tokens(MACROBLOCKD *const xd, - int plane, const scan_order *sc, - int x, int y, - TX_SIZE tx_size, - TX_TYPE tx_type, +int vp10_decode_block_tokens(MACROBLOCKD *const xd, int plane, + const scan_order *sc, int x, int y, + TX_SIZE tx_size, TX_TYPE tx_type, #if CONFIG_ANS struct AnsDecoder *const r, #else diff --git a/vp10/decoder/dsubexp.c b/vp10/decoder/dsubexp.c index 49695cc92..8310b7af9 100644 --- a/vp10/decoder/dsubexp.c +++ b/vp10/decoder/dsubexp.c @@ -15,8 +15,7 @@ #include "vp10/decoder/dsubexp.h" static int inv_recenter_nonneg(int v, int m) { - if (v > 2 * m) - return v; + if (v > 2 * m) return v; return (v & 1) ? m - ((v + 1) >> 1) : m + (v >> 1); } @@ -25,19 +24,19 @@ static int decode_uniform(vp10_reader *r) { const int l = 8; const int m = (1 << l) - 190; const int v = vp10_read_literal(r, l - 1); - return v < m ? v : (v << 1) - m + vp10_read_bit(r); + return v < m ? v : (v << 1) - m + vp10_read_bit(r); } static int inv_remap_prob(int v, int m) { static uint8_t inv_map_table[MAX_PROB - 1] = { - 7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176, 189, - 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176, 189, + 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, @@ -59,16 +58,13 @@ static int inv_remap_prob(int v, int m) { } static int decode_term_subexp(vp10_reader *r) { - if (!vp10_read_bit(r)) - return vp10_read_literal(r, 4); - if (!vp10_read_bit(r)) - return vp10_read_literal(r, 4) + 16; - if (!vp10_read_bit(r)) - return vp10_read_literal(r, 5) + 32; + if (!vp10_read_bit(r)) return vp10_read_literal(r, 4); + if (!vp10_read_bit(r)) return vp10_read_literal(r, 4) + 16; + if (!vp10_read_bit(r)) return vp10_read_literal(r, 5) + 32; return decode_uniform(r) + 64; } -void vp10_diff_update_prob(vp10_reader *r, vpx_prob* p) { +void vp10_diff_update_prob(vp10_reader *r, vpx_prob *p) { if (vp10_read(r, DIFF_UPDATE_PROB)) { const int delp = decode_term_subexp(r); *p = (vpx_prob)inv_remap_prob(delp, *p); diff --git a/vp10/decoder/dsubexp.h b/vp10/decoder/dsubexp.h index eaccf1fb2..04aad0c0b 100644 --- a/vp10/decoder/dsubexp.h +++ b/vp10/decoder/dsubexp.h @@ -8,7 +8,6 @@ * be found in the AUTHORS file in the root of the source tree. */ - #ifndef VP10_DECODER_DSUBEXP_H_ #define VP10_DECODER_DSUBEXP_H_ @@ -18,7 +17,7 @@ extern "C" { #endif -void vp10_diff_update_prob(vp10_reader *r, vpx_prob* p); +void vp10_diff_update_prob(vp10_reader *r, vpx_prob *p); #ifdef __cplusplus } // extern "C" diff --git a/vp10/decoder/dthread.c b/vp10/decoder/dthread.c index f2c93a7c9..2df3c1cc6 100644 --- a/vp10/decoder/dthread.c +++ b/vp10/decoder/dthread.c @@ -60,10 +60,9 @@ void vp10_frameworker_signal_stats(VPxWorker *const worker) { // TODO(hkuang): Remove worker parameter as it is only used in debug code. void vp10_frameworker_wait(VPxWorker *const worker, RefCntBuffer *const ref_buf, - int row) { + int row) { #if CONFIG_MULTITHREAD - if (!ref_buf) - return; + if (!ref_buf) return; #ifndef BUILDING_WITH_TSAN // The following line of code will get harmless tsan error but it is the key @@ -135,7 +134,7 @@ void vp10_frameworker_broadcast(RefCntBuffer *const buf, int row) { } void vp10_frameworker_copy_context(VPxWorker *const dst_worker, - VPxWorker *const src_worker) { + VPxWorker *const src_worker) { #if CONFIG_MULTITHREAD FrameWorkerData *const src_worker_data = (FrameWorkerData *)src_worker->data1; FrameWorkerData *const dst_worker_data = (FrameWorkerData *)dst_worker->data1; @@ -147,11 +146,12 @@ void vp10_frameworker_copy_context(VPxWorker *const dst_worker, vp10_frameworker_lock_stats(src_worker); while (!src_worker_data->frame_context_ready) { pthread_cond_wait(&src_worker_data->stats_cond, - &src_worker_data->stats_mutex); + &src_worker_data->stats_mutex); } - dst_cm->last_frame_seg_map = src_cm->seg.enabled ? - src_cm->current_frame_seg_map : src_cm->last_frame_seg_map; + dst_cm->last_frame_seg_map = src_cm->seg.enabled + ? src_cm->current_frame_seg_map + : src_cm->last_frame_seg_map; dst_worker_data->pbi->need_resync = src_worker_data->pbi->need_resync; vp10_frameworker_unlock_stats(src_worker); @@ -160,19 +160,20 @@ void vp10_frameworker_copy_context(VPxWorker *const dst_worker, dst_cm->use_highbitdepth = src_cm->use_highbitdepth; #endif #if CONFIG_EXT_REFS - // TODO(zoeliu): To handle parallel decoding +// TODO(zoeliu): To handle parallel decoding #endif // CONFIG_EXT_REFS - dst_cm->prev_frame = src_cm->show_existing_frame ? - src_cm->prev_frame : src_cm->cur_frame; - dst_cm->last_width = !src_cm->show_existing_frame ? - src_cm->width : src_cm->last_width; - dst_cm->last_height = !src_cm->show_existing_frame ? - src_cm->height : src_cm->last_height; + dst_cm->prev_frame = + src_cm->show_existing_frame ? src_cm->prev_frame : src_cm->cur_frame; + dst_cm->last_width = + !src_cm->show_existing_frame ? src_cm->width : src_cm->last_width; + dst_cm->last_height = + !src_cm->show_existing_frame ? src_cm->height : src_cm->last_height; dst_cm->subsampling_x = src_cm->subsampling_x; dst_cm->subsampling_y = src_cm->subsampling_y; dst_cm->frame_type = src_cm->frame_type; - dst_cm->last_show_frame = !src_cm->show_existing_frame ? - src_cm->show_frame : src_cm->last_show_frame; + dst_cm->last_show_frame = !src_cm->show_existing_frame + ? src_cm->show_frame + : src_cm->last_show_frame; for (i = 0; i < REF_FRAMES; ++i) dst_cm->ref_frame_map[i] = src_cm->next_ref_frame_map[i]; @@ -186,7 +187,7 @@ void vp10_frameworker_copy_context(VPxWorker *const dst_worker, memcpy(dst_cm->frame_contexts, src_cm->frame_contexts, FRAME_CONTEXTS * sizeof(dst_cm->frame_contexts[0])); #else - (void) dst_worker; - (void) src_worker; + (void)dst_worker; + (void)src_worker; #endif // CONFIG_MULTITHREAD } diff --git a/vp10/decoder/dthread.h b/vp10/decoder/dthread.h index 1b0dc0191..cb78462ca 100644 --- a/vp10/decoder/dthread.h +++ b/vp10/decoder/dthread.h @@ -57,7 +57,7 @@ void vp10_frameworker_signal_stats(VPxWorker *const worker); // start decoding next frame. So need to check whether worker is still decoding // ref_buf. void vp10_frameworker_wait(VPxWorker *const worker, RefCntBuffer *const ref_buf, - int row); + int row); // FrameWorker broadcasts its decoding progress so other workers that are // waiting on it can resume decoding. @@ -65,10 +65,10 @@ void vp10_frameworker_broadcast(RefCntBuffer *const buf, int row); // Copy necessary decoding context from src worker to dst worker. void vp10_frameworker_copy_context(VPxWorker *const dst_worker, - VPxWorker *const src_worker); + VPxWorker *const src_worker); #ifdef __cplusplus -} // extern "C" +} // extern "C" #endif #endif // VP10_DECODER_DTHREAD_H_ diff --git a/vp10/vp10_cx_iface.c b/vp10/vp10_cx_iface.c index 6a9b9e40a..5065b4c71 100644 --- a/vp10/vp10_cx_iface.c +++ b/vp10/vp10_cx_iface.c @@ -23,99 +23,99 @@ #include "vp10/vp10_iface_common.h" struct vp10_extracfg { - int cpu_used; // available cpu percentage in 1/16 - unsigned int enable_auto_alt_ref; + int cpu_used; // available cpu percentage in 1/16 + unsigned int enable_auto_alt_ref; #if CONFIG_EXT_REFS - unsigned int enable_auto_bwd_ref; + unsigned int enable_auto_bwd_ref; #endif // CONFIG_EXT_REFS - unsigned int noise_sensitivity; - unsigned int sharpness; - unsigned int static_thresh; - unsigned int tile_columns; - unsigned int tile_rows; - unsigned int arnr_max_frames; - unsigned int arnr_strength; - unsigned int min_gf_interval; - unsigned int max_gf_interval; - vpx_tune_metric tuning; - unsigned int cq_level; // constrained quality level - unsigned int rc_max_intra_bitrate_pct; - unsigned int rc_max_inter_bitrate_pct; - unsigned int gf_cbr_boost_pct; - unsigned int lossless; - unsigned int frame_parallel_decoding_mode; - AQ_MODE aq_mode; - unsigned int frame_periodic_boost; - vpx_bit_depth_t bit_depth; - vpx_tune_content content; - vpx_color_space_t color_space; - int color_range; - int render_width; - int render_height; - vpx_superblock_size_t superblock_size; + unsigned int noise_sensitivity; + unsigned int sharpness; + unsigned int static_thresh; + unsigned int tile_columns; + unsigned int tile_rows; + unsigned int arnr_max_frames; + unsigned int arnr_strength; + unsigned int min_gf_interval; + unsigned int max_gf_interval; + vpx_tune_metric tuning; + unsigned int cq_level; // constrained quality level + unsigned int rc_max_intra_bitrate_pct; + unsigned int rc_max_inter_bitrate_pct; + unsigned int gf_cbr_boost_pct; + unsigned int lossless; + unsigned int frame_parallel_decoding_mode; + AQ_MODE aq_mode; + unsigned int frame_periodic_boost; + vpx_bit_depth_t bit_depth; + vpx_tune_content content; + vpx_color_space_t color_space; + int color_range; + int render_width; + int render_height; + vpx_superblock_size_t superblock_size; }; static struct vp10_extracfg default_extra_cfg = { - 0, // cpu_used - 1, // enable_auto_alt_ref + 0, // cpu_used + 1, // enable_auto_alt_ref #if CONFIG_EXT_REFS - 0, // enable_auto_bwd_ref + 0, // enable_auto_bwd_ref #endif // CONFIG_EXT_REFS - 0, // noise_sensitivity - 0, // sharpness - 0, // static_thresh + 0, // noise_sensitivity + 0, // sharpness + 0, // static_thresh #if CONFIG_EXT_TILE - UINT_MAX, // tile_columns - UINT_MAX, // tile_rows + UINT_MAX, // tile_columns + UINT_MAX, // tile_rows #else - 0, // tile_columns - 0, // tile_rows -#endif // CONFIG_EXT_TILE - 7, // arnr_max_frames - 5, // arnr_strength - 0, // min_gf_interval; 0 -> default decision - 0, // max_gf_interval; 0 -> default decision - VPX_TUNE_PSNR, // tuning - 10, // cq_level - 0, // rc_max_intra_bitrate_pct - 0, // rc_max_inter_bitrate_pct - 0, // gf_cbr_boost_pct - 0, // lossless - 1, // frame_parallel_decoding_mode - NO_AQ, // aq_mode - 0, // frame_periodic_delta_q - VPX_BITS_8, // Bit depth - VPX_CONTENT_DEFAULT, // content - VPX_CS_UNKNOWN, // color space - 0, // color range - 0, // render width - 0, // render height - VPX_SUPERBLOCK_SIZE_DYNAMIC // superblock_size + 0, // tile_columns + 0, // tile_rows +#endif // CONFIG_EXT_TILE + 7, // arnr_max_frames + 5, // arnr_strength + 0, // min_gf_interval; 0 -> default decision + 0, // max_gf_interval; 0 -> default decision + VPX_TUNE_PSNR, // tuning + 10, // cq_level + 0, // rc_max_intra_bitrate_pct + 0, // rc_max_inter_bitrate_pct + 0, // gf_cbr_boost_pct + 0, // lossless + 1, // frame_parallel_decoding_mode + NO_AQ, // aq_mode + 0, // frame_periodic_delta_q + VPX_BITS_8, // Bit depth + VPX_CONTENT_DEFAULT, // content + VPX_CS_UNKNOWN, // color space + 0, // color range + 0, // render width + 0, // render height + VPX_SUPERBLOCK_SIZE_DYNAMIC // superblock_size }; struct vpx_codec_alg_priv { - vpx_codec_priv_t base; - vpx_codec_enc_cfg_t cfg; - struct vp10_extracfg extra_cfg; - VP10EncoderConfig oxcf; - VP10_COMP *cpi; - unsigned char *cx_data; - size_t cx_data_sz; - unsigned char *pending_cx_data; - size_t pending_cx_data_sz; - int pending_frame_count; - size_t pending_frame_sizes[8]; - vpx_image_t preview_img; - vpx_enc_frame_flags_t next_frame_flags; - vp8_postproc_cfg_t preview_ppcfg; + vpx_codec_priv_t base; + vpx_codec_enc_cfg_t cfg; + struct vp10_extracfg extra_cfg; + VP10EncoderConfig oxcf; + VP10_COMP *cpi; + unsigned char *cx_data; + size_t cx_data_sz; + unsigned char *pending_cx_data; + size_t pending_cx_data_sz; + int pending_frame_count; + size_t pending_frame_sizes[8]; + vpx_image_t preview_img; + vpx_enc_frame_flags_t next_frame_flags; + vp8_postproc_cfg_t preview_ppcfg; vpx_codec_pkt_list_decl(256) pkt_list; - unsigned int fixed_kf_cntr; + unsigned int fixed_kf_cntr; // BufferPool that holds all reference frames. - BufferPool *buffer_pool; + BufferPool *buffer_pool; }; -static vpx_codec_err_t update_error_state(vpx_codec_alg_priv_t *ctx, - const struct vpx_internal_error_info *error) { +static vpx_codec_err_t update_error_state( + vpx_codec_alg_priv_t *ctx, const struct vpx_internal_error_info *error) { const vpx_codec_err_t res = error->error_code; if (res != VPX_CODEC_OK) @@ -124,58 +124,60 @@ static vpx_codec_err_t update_error_state(vpx_codec_alg_priv_t *ctx, return res; } - #undef ERROR -#define ERROR(str) do {\ - ctx->base.err_detail = str;\ - return VPX_CODEC_INVALID_PARAM;\ +#define ERROR(str) \ + do { \ + ctx->base.err_detail = str; \ + return VPX_CODEC_INVALID_PARAM; \ } while (0) -#define RANGE_CHECK(p, memb, lo, hi) do {\ +#define RANGE_CHECK(p, memb, lo, hi) \ + do { \ if (!(((p)->memb == lo || (p)->memb > (lo)) && (p)->memb <= hi)) \ - ERROR(#memb " out of range ["#lo".."#hi"]");\ + ERROR(#memb " out of range [" #lo ".." #hi "]"); \ } while (0) -#define RANGE_CHECK_HI(p, memb, hi) do {\ - if (!((p)->memb <= (hi))) \ - ERROR(#memb " out of range [.."#hi"]");\ +#define RANGE_CHECK_HI(p, memb, hi) \ + do { \ + if (!((p)->memb <= (hi))) ERROR(#memb " out of range [.." #hi "]"); \ } while (0) -#define RANGE_CHECK_LO(p, memb, lo) do {\ - if (!((p)->memb >= (lo))) \ - ERROR(#memb " out of range ["#lo"..]");\ +#define RANGE_CHECK_LO(p, memb, lo) \ + do { \ + if (!((p)->memb >= (lo))) ERROR(#memb " out of range [" #lo "..]"); \ } while (0) -#define RANGE_CHECK_BOOL(p, memb) do {\ - if (!!((p)->memb) != (p)->memb) ERROR(#memb " expected boolean");\ +#define RANGE_CHECK_BOOL(p, memb) \ + do { \ + if (!!((p)->memb) != (p)->memb) ERROR(#memb " expected boolean"); \ } while (0) static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, const vpx_codec_enc_cfg_t *cfg, const struct vp10_extracfg *extra_cfg) { - RANGE_CHECK(cfg, g_w, 1, 65535); // 16 bits available - RANGE_CHECK(cfg, g_h, 1, 65535); // 16 bits available - RANGE_CHECK(cfg, g_timebase.den, 1, 1000000000); - RANGE_CHECK(cfg, g_timebase.num, 1, cfg->g_timebase.den); - RANGE_CHECK_HI(cfg, g_profile, 3); + RANGE_CHECK(cfg, g_w, 1, 65535); // 16 bits available + RANGE_CHECK(cfg, g_h, 1, 65535); // 16 bits available + RANGE_CHECK(cfg, g_timebase.den, 1, 1000000000); + RANGE_CHECK(cfg, g_timebase.num, 1, cfg->g_timebase.den); + RANGE_CHECK_HI(cfg, g_profile, 3); - RANGE_CHECK_HI(cfg, rc_max_quantizer, 63); - RANGE_CHECK_HI(cfg, rc_min_quantizer, cfg->rc_max_quantizer); + RANGE_CHECK_HI(cfg, rc_max_quantizer, 63); + RANGE_CHECK_HI(cfg, rc_min_quantizer, cfg->rc_max_quantizer); RANGE_CHECK_BOOL(extra_cfg, lossless); - RANGE_CHECK(extra_cfg, aq_mode, 0, AQ_MODE_COUNT - 1); + RANGE_CHECK(extra_cfg, aq_mode, 0, AQ_MODE_COUNT - 1); RANGE_CHECK(extra_cfg, frame_periodic_boost, 0, 1); - RANGE_CHECK_HI(cfg, g_threads, 64); - RANGE_CHECK_HI(cfg, g_lag_in_frames, MAX_LAG_BUFFERS); - RANGE_CHECK(cfg, rc_end_usage, VPX_VBR, VPX_Q); - RANGE_CHECK_HI(cfg, rc_undershoot_pct, 100); - RANGE_CHECK_HI(cfg, rc_overshoot_pct, 100); + RANGE_CHECK_HI(cfg, g_threads, 64); + RANGE_CHECK_HI(cfg, g_lag_in_frames, MAX_LAG_BUFFERS); + RANGE_CHECK(cfg, rc_end_usage, VPX_VBR, VPX_Q); + RANGE_CHECK_HI(cfg, rc_undershoot_pct, 100); + RANGE_CHECK_HI(cfg, rc_overshoot_pct, 100); RANGE_CHECK_HI(cfg, rc_2pass_vbr_bias_pct, 100); - RANGE_CHECK(cfg, kf_mode, VPX_KF_DISABLED, VPX_KF_AUTO); - RANGE_CHECK_BOOL(cfg, rc_resize_allowed); - RANGE_CHECK_HI(cfg, rc_dropframe_thresh, 100); - RANGE_CHECK_HI(cfg, rc_resize_up_thresh, 100); + RANGE_CHECK(cfg, kf_mode, VPX_KF_DISABLED, VPX_KF_AUTO); + RANGE_CHECK_BOOL(cfg, rc_resize_allowed); + RANGE_CHECK_HI(cfg, rc_dropframe_thresh, 100); + RANGE_CHECK_HI(cfg, rc_resize_up_thresh, 100); RANGE_CHECK_HI(cfg, rc_resize_down_thresh, 100); - RANGE_CHECK(cfg, g_pass, VPX_RC_ONE_PASS, VPX_RC_LAST_PASS); + RANGE_CHECK(cfg, g_pass, VPX_RC_ONE_PASS, VPX_RC_LAST_PASS); RANGE_CHECK(extra_cfg, min_gf_interval, 0, (MAX_LAG_BUFFERS - 1)); RANGE_CHECK(extra_cfg, max_gf_interval, 0, (MAX_LAG_BUFFERS - 1)); if (extra_cfg->max_gf_interval > 0) { @@ -183,7 +185,7 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, } if (extra_cfg->min_gf_interval > 0 && extra_cfg->max_gf_interval > 0) { RANGE_CHECK(extra_cfg, max_gf_interval, extra_cfg->min_gf_interval, - (MAX_LAG_BUFFERS - 1)); + (MAX_LAG_BUFFERS - 1)); } if (cfg->rc_resize_allowed == 1) { @@ -193,11 +195,11 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, // VP9 does not support a lower bound on the keyframe interval in // automatic keyframe placement mode. - if (cfg->kf_mode != VPX_KF_DISABLED && - cfg->kf_min_dist != cfg->kf_max_dist && + if (cfg->kf_mode != VPX_KF_DISABLED && cfg->kf_min_dist != cfg->kf_max_dist && cfg->kf_min_dist > 0) - ERROR("kf_min_dist not supported in auto mode, use 0 " - "or kf_max_dist instead."); + ERROR( + "kf_min_dist not supported in auto mode, use 0 " + "or kf_max_dist instead."); RANGE_CHECK(extra_cfg, enable_auto_alt_ref, 0, 2); #if CONFIG_EXT_REFS @@ -205,12 +207,12 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, #endif // CONFIG_EXT_REFS RANGE_CHECK(extra_cfg, cpu_used, -8, 8); RANGE_CHECK_HI(extra_cfg, noise_sensitivity, 6); - RANGE_CHECK(extra_cfg, superblock_size, - VPX_SUPERBLOCK_SIZE_64X64, VPX_SUPERBLOCK_SIZE_DYNAMIC); + RANGE_CHECK(extra_cfg, superblock_size, VPX_SUPERBLOCK_SIZE_64X64, + VPX_SUPERBLOCK_SIZE_DYNAMIC); #if CONFIG_EXT_TILE - // TODO(any): Waring. If CONFIG_EXT_TILE is true, tile_columns really - // means tile_width, and tile_rows really means tile_hight. The interface - // should be sanitized. +// TODO(any): Waring. If CONFIG_EXT_TILE is true, tile_columns really +// means tile_width, and tile_rows really means tile_hight. The interface +// should be sanitized. #if CONFIG_EXT_PARTITION if (extra_cfg->superblock_size != VPX_SUPERBLOCK_SIZE_64X64) { if (extra_cfg->tile_columns != UINT_MAX) @@ -235,12 +237,11 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, RANGE_CHECK(extra_cfg, cq_level, 0, 63); RANGE_CHECK(cfg, g_bit_depth, VPX_BITS_8, VPX_BITS_12); RANGE_CHECK(cfg, g_input_bit_depth, 8, 12); - RANGE_CHECK(extra_cfg, content, - VPX_CONTENT_DEFAULT, VPX_CONTENT_INVALID - 1); + RANGE_CHECK(extra_cfg, content, VPX_CONTENT_DEFAULT, VPX_CONTENT_INVALID - 1); - // TODO(yaowu): remove this when ssim tuning is implemented for vp9 + // TODO(yaowu): remove this when ssim tuning is implemented for vp10 if (extra_cfg->tuning == VPX_TUNE_SSIM) - ERROR("Option --tune=ssim is not currently supported in VP9."); + ERROR("Option --tune=ssim is not currently supported in VP10."); if (cfg->g_pass == VPX_RC_LAST_PASS) { const size_t packet_sz = sizeof(FIRSTPASS_STATS); @@ -272,8 +273,7 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx, cfg->g_bit_depth > VPX_BITS_8) { ERROR("Codec high bit-depth not supported in profile < 2"); } - if (cfg->g_profile <= (unsigned int)PROFILE_1 && - cfg->g_input_bit_depth > 8) { + if (cfg->g_profile <= (unsigned int)PROFILE_1 && cfg->g_input_bit_depth > 8) { ERROR("Source high bit-depth not supported in profile < 2"); } if (cfg->g_profile > (unsigned int)PROFILE_1 && @@ -290,14 +290,14 @@ static vpx_codec_err_t validate_img(vpx_codec_alg_priv_t *ctx, switch (img->fmt) { case VPX_IMG_FMT_YV12: case VPX_IMG_FMT_I420: - case VPX_IMG_FMT_I42016: - break; + case VPX_IMG_FMT_I42016: break; case VPX_IMG_FMT_I422: case VPX_IMG_FMT_I444: case VPX_IMG_FMT_I440: if (ctx->cfg.g_profile != (unsigned int)PROFILE_1) { - ERROR("Invalid image format. I422, I444, I440 images are " - "not supported in profile."); + ERROR( + "Invalid image format. I422, I444, I440 images are " + "not supported in profile."); } break; case VPX_IMG_FMT_I42216: @@ -305,13 +305,15 @@ static vpx_codec_err_t validate_img(vpx_codec_alg_priv_t *ctx, case VPX_IMG_FMT_I44016: if (ctx->cfg.g_profile != (unsigned int)PROFILE_1 && ctx->cfg.g_profile != (unsigned int)PROFILE_3) { - ERROR("Invalid image format. 16-bit I422, I444, I440 images are " - "not supported in profile."); + ERROR( + "Invalid image format. 16-bit I422, I444, I440 images are " + "not supported in profile."); } break; default: - ERROR("Invalid image format. Only YV12, I420, I422, I444 images are " - "supported."); + ERROR( + "Invalid image format. Only YV12, I420, I422, I444 images are " + "supported."); break; } @@ -338,37 +340,29 @@ static int get_image_bps(const vpx_image_t *img) { } static vpx_codec_err_t set_encoder_config( - VP10EncoderConfig *oxcf, - const vpx_codec_enc_cfg_t *cfg, - const struct vp10_extracfg *extra_cfg) { + VP10EncoderConfig *oxcf, const vpx_codec_enc_cfg_t *cfg, + const struct vp10_extracfg *extra_cfg) { const int is_vbr = cfg->rc_end_usage == VPX_VBR; oxcf->profile = cfg->g_profile; oxcf->max_threads = (int)cfg->g_threads; - oxcf->width = cfg->g_w; - oxcf->height = cfg->g_h; + oxcf->width = cfg->g_w; + oxcf->height = cfg->g_h; oxcf->bit_depth = cfg->g_bit_depth; oxcf->input_bit_depth = cfg->g_input_bit_depth; // guess a frame rate if out of whack, use 30 oxcf->init_framerate = (double)cfg->g_timebase.den / cfg->g_timebase.num; - if (oxcf->init_framerate > 180) - oxcf->init_framerate = 30; + if (oxcf->init_framerate > 180) oxcf->init_framerate = 30; oxcf->mode = GOOD; switch (cfg->g_pass) { - case VPX_RC_ONE_PASS: - oxcf->pass = 0; - break; - case VPX_RC_FIRST_PASS: - oxcf->pass = 1; - break; - case VPX_RC_LAST_PASS: - oxcf->pass = 2; - break; + case VPX_RC_ONE_PASS: oxcf->pass = 0; break; + case VPX_RC_FIRST_PASS: oxcf->pass = 1; break; + case VPX_RC_LAST_PASS: oxcf->pass = 2; break; } - oxcf->lag_in_frames = cfg->g_pass == VPX_RC_FIRST_PASS ? 0 - : cfg->g_lag_in_frames; + oxcf->lag_in_frames = + cfg->g_pass == VPX_RC_FIRST_PASS ? 0 : cfg->g_lag_in_frames; oxcf->rc_mode = cfg->rc_end_usage; // Convert target bandwidth from Kbit/s to Bit/s @@ -381,58 +375,59 @@ static vpx_codec_err_t set_encoder_config( extra_cfg->lossless ? 0 : vp10_quantizer_to_qindex(cfg->rc_min_quantizer); oxcf->worst_allowed_q = extra_cfg->lossless ? 0 : vp10_quantizer_to_qindex(cfg->rc_max_quantizer); - oxcf->cq_level = vp10_quantizer_to_qindex(extra_cfg->cq_level); + oxcf->cq_level = vp10_quantizer_to_qindex(extra_cfg->cq_level); oxcf->fixed_q = -1; - oxcf->under_shoot_pct = cfg->rc_undershoot_pct; - oxcf->over_shoot_pct = cfg->rc_overshoot_pct; + oxcf->under_shoot_pct = cfg->rc_undershoot_pct; + oxcf->over_shoot_pct = cfg->rc_overshoot_pct; - oxcf->scaled_frame_width = cfg->rc_scaled_width; + oxcf->scaled_frame_width = cfg->rc_scaled_width; oxcf->scaled_frame_height = cfg->rc_scaled_height; if (cfg->rc_resize_allowed == 1) { oxcf->resize_mode = - (oxcf->scaled_frame_width == 0 || oxcf->scaled_frame_height == 0) ? - RESIZE_DYNAMIC : RESIZE_FIXED; + (oxcf->scaled_frame_width == 0 || oxcf->scaled_frame_height == 0) + ? RESIZE_DYNAMIC + : RESIZE_FIXED; } else { oxcf->resize_mode = RESIZE_NONE; } - oxcf->maximum_buffer_size_ms = is_vbr ? 240000 : cfg->rc_buf_sz; + oxcf->maximum_buffer_size_ms = is_vbr ? 240000 : cfg->rc_buf_sz; oxcf->starting_buffer_level_ms = is_vbr ? 60000 : cfg->rc_buf_initial_sz; - oxcf->optimal_buffer_level_ms = is_vbr ? 60000 : cfg->rc_buf_optimal_sz; + oxcf->optimal_buffer_level_ms = is_vbr ? 60000 : cfg->rc_buf_optimal_sz; - oxcf->drop_frames_water_mark = cfg->rc_dropframe_thresh; + oxcf->drop_frames_water_mark = cfg->rc_dropframe_thresh; - oxcf->two_pass_vbrbias = cfg->rc_2pass_vbr_bias_pct; - oxcf->two_pass_vbrmin_section = cfg->rc_2pass_vbr_minsection_pct; - oxcf->two_pass_vbrmax_section = cfg->rc_2pass_vbr_maxsection_pct; + oxcf->two_pass_vbrbias = cfg->rc_2pass_vbr_bias_pct; + oxcf->two_pass_vbrmin_section = cfg->rc_2pass_vbr_minsection_pct; + oxcf->two_pass_vbrmax_section = cfg->rc_2pass_vbr_maxsection_pct; - oxcf->auto_key = cfg->kf_mode == VPX_KF_AUTO && - cfg->kf_min_dist != cfg->kf_max_dist; + oxcf->auto_key = + cfg->kf_mode == VPX_KF_AUTO && cfg->kf_min_dist != cfg->kf_max_dist; - oxcf->key_freq = cfg->kf_max_dist; + oxcf->key_freq = cfg->kf_max_dist; - oxcf->speed = abs(extra_cfg->cpu_used); - oxcf->encode_breakout = extra_cfg->static_thresh; - oxcf->enable_auto_arf = extra_cfg->enable_auto_alt_ref; + oxcf->speed = abs(extra_cfg->cpu_used); + oxcf->encode_breakout = extra_cfg->static_thresh; + oxcf->enable_auto_arf = extra_cfg->enable_auto_alt_ref; #if CONFIG_EXT_REFS - oxcf->enable_auto_brf = extra_cfg->enable_auto_bwd_ref; + oxcf->enable_auto_brf = extra_cfg->enable_auto_bwd_ref; #endif // CONFIG_EXT_REFS - oxcf->noise_sensitivity = extra_cfg->noise_sensitivity; - oxcf->sharpness = extra_cfg->sharpness; + oxcf->noise_sensitivity = extra_cfg->noise_sensitivity; + oxcf->sharpness = extra_cfg->sharpness; - oxcf->two_pass_stats_in = cfg->rc_twopass_stats_in; + oxcf->two_pass_stats_in = cfg->rc_twopass_stats_in; #if CONFIG_FP_MB_STATS - oxcf->firstpass_mb_stats_in = cfg->rc_firstpass_mb_stats_in; + oxcf->firstpass_mb_stats_in = cfg->rc_firstpass_mb_stats_in; #endif oxcf->color_space = extra_cfg->color_space; oxcf->color_range = extra_cfg->color_range; - oxcf->render_width = extra_cfg->render_width; + oxcf->render_width = extra_cfg->render_width; oxcf->render_height = extra_cfg->render_height; oxcf->arnr_max_frames = extra_cfg->arnr_max_frames; - oxcf->arnr_strength = extra_cfg->arnr_strength; + oxcf->arnr_strength = extra_cfg->arnr_strength; oxcf->min_gf_interval = extra_cfg->min_gf_interval; oxcf->max_gf_interval = extra_cfg->max_gf_interval; @@ -447,24 +442,24 @@ static vpx_codec_err_t set_encoder_config( { #if CONFIG_EXT_PARTITION const unsigned int max = - extra_cfg->superblock_size == VPX_SUPERBLOCK_SIZE_64X64 ? 64 : 32; + extra_cfg->superblock_size == VPX_SUPERBLOCK_SIZE_64X64 ? 64 : 32; #else const unsigned int max = 64; #endif // CONFIG_EXT_PARTITION oxcf->tile_columns = VPXMIN(extra_cfg->tile_columns, max); - oxcf->tile_rows = VPXMIN(extra_cfg->tile_rows, max); + oxcf->tile_rows = VPXMIN(extra_cfg->tile_rows, max); } #else oxcf->tile_columns = extra_cfg->tile_columns; - oxcf->tile_rows = extra_cfg->tile_rows; + oxcf->tile_rows = extra_cfg->tile_rows; #endif // CONFIG_EXT_TILE - oxcf->error_resilient_mode = cfg->g_error_resilient; + oxcf->error_resilient_mode = cfg->g_error_resilient; oxcf->frame_parallel_decoding_mode = extra_cfg->frame_parallel_decoding_mode; oxcf->aq_mode = extra_cfg->aq_mode; - oxcf->frame_periodic_boost = extra_cfg->frame_periodic_boost; + oxcf->frame_periodic_boost = extra_cfg->frame_periodic_boost; /* printf("Current VP9 Settings: \n"); @@ -502,7 +497,7 @@ static vpx_codec_err_t set_encoder_config( } static vpx_codec_err_t encoder_set_config(vpx_codec_alg_priv_t *ctx, - const vpx_codec_enc_cfg_t *cfg) { + const vpx_codec_enc_cfg_t *cfg) { vpx_codec_err_t res; int force_key = 0; @@ -532,8 +527,7 @@ static vpx_codec_err_t encoder_set_config(vpx_codec_alg_priv_t *ctx, vp10_change_config(ctx->cpi, &ctx->oxcf); } - if (force_key) - ctx->next_frame_flags |= VPX_EFLAG_FORCE_KF; + if (force_key) ctx->next_frame_flags |= VPX_EFLAG_FORCE_KF; return res; } @@ -541,8 +535,7 @@ static vpx_codec_err_t encoder_set_config(vpx_codec_alg_priv_t *ctx, static vpx_codec_err_t ctrl_get_quantizer(vpx_codec_alg_priv_t *ctx, va_list args) { int *const arg = va_arg(args, int *); - if (arg == NULL) - return VPX_CODEC_INVALID_PARAM; + if (arg == NULL) return VPX_CODEC_INVALID_PARAM; *arg = vp10_get_quantizer(ctx->cpi); return VPX_CODEC_OK; } @@ -550,8 +543,7 @@ static vpx_codec_err_t ctrl_get_quantizer(vpx_codec_alg_priv_t *ctx, static vpx_codec_err_t ctrl_get_quantizer64(vpx_codec_alg_priv_t *ctx, va_list args) { int *const arg = va_arg(args, int *); - if (arg == NULL) - return VPX_CODEC_INVALID_PARAM; + if (arg == NULL) return VPX_CODEC_INVALID_PARAM; *arg = vp10_qindex_to_quantizer(vp10_get_quantizer(ctx->cpi)); return VPX_CODEC_OK; } @@ -676,11 +668,10 @@ static vpx_codec_err_t ctrl_set_rc_max_inter_bitrate_pct( return update_extra_cfg(ctx, &extra_cfg); } -static vpx_codec_err_t ctrl_set_rc_gf_cbr_boost_pct( - vpx_codec_alg_priv_t *ctx, va_list args) { +static vpx_codec_err_t ctrl_set_rc_gf_cbr_boost_pct(vpx_codec_alg_priv_t *ctx, + va_list args) { struct vp10_extracfg extra_cfg = ctx->extra_cfg; - extra_cfg.gf_cbr_boost_pct = - CAST(VP9E_SET_GF_CBR_BOOST_PCT, args); + extra_cfg.gf_cbr_boost_pct = CAST(VP9E_SET_GF_CBR_BOOST_PCT, args); return update_extra_cfg(ctx, &extra_cfg); } @@ -734,16 +725,13 @@ static vpx_codec_err_t encoder_init(vpx_codec_ctx_t *ctx, if (ctx->priv == NULL) { vpx_codec_alg_priv_t *const priv = vpx_calloc(1, sizeof(*priv)); - if (priv == NULL) - return VPX_CODEC_MEM_ERROR; + if (priv == NULL) return VPX_CODEC_MEM_ERROR; ctx->priv = (vpx_codec_priv_t *)priv; ctx->priv->init_flags = ctx->init_flags; ctx->priv->enc.total_encoders = 1; - priv->buffer_pool = - (BufferPool *)vpx_calloc(1, sizeof(BufferPool)); - if (priv->buffer_pool == NULL) - return VPX_CODEC_MEM_ERROR; + priv->buffer_pool = (BufferPool *)vpx_calloc(1, sizeof(BufferPool)); + if (priv->buffer_pool == NULL) return VPX_CODEC_MEM_ERROR; #if CONFIG_MULTITHREAD if (pthread_mutex_init(&priv->buffer_pool->pool_mutex, NULL)) { @@ -802,7 +790,8 @@ static void pick_quickcompress_mode(vpx_codec_alg_priv_t *ctx, // Convert duration parameter from stream timebase to microseconds. const uint64_t duration_us = (uint64_t)duration * 1000000 * - (uint64_t)cfg->g_timebase.num /(uint64_t)cfg->g_timebase.den; + (uint64_t)cfg->g_timebase.num / + (uint64_t)cfg->g_timebase.den; // If the deadline is more that the duration this frame is to be shown, // use good quality mode. Otherwise use realtime mode. @@ -811,11 +800,8 @@ static void pick_quickcompress_mode(vpx_codec_alg_priv_t *ctx, new_mode = BEST; } break; - case VPX_RC_FIRST_PASS: - break; - case VPX_RC_LAST_PASS: - new_mode = deadline > 0 ? GOOD : BEST; - break; + case VPX_RC_FIRST_PASS: break; + case VPX_RC_LAST_PASS: new_mode = deadline > 0 ? GOOD : BEST; break; } if (ctx->oxcf.mode != new_mode) { @@ -839,14 +825,13 @@ static int write_superframe_index(vpx_codec_alg_priv_t *ctx) { // Add the number of frames to the marker byte marker |= ctx->pending_frame_count - 1; for (i = 0; i < ctx->pending_frame_count - 1; i++) { - const size_t frame_sz = (unsigned int) ctx->pending_frame_sizes[i] - 1; + const size_t frame_sz = (unsigned int)ctx->pending_frame_sizes[i] - 1; max_frame_sz = frame_sz > max_frame_sz ? frame_sz : max_frame_sz; } // Choose the magnitude for (mag = 0, mask = 0xff; mag < 4; mag++) { - if (max_frame_sz <= mask) - break; + if (max_frame_sz <= mask) break; mask <<= 8; mask |= 0xff; } @@ -910,16 +895,14 @@ static vpx_codec_frame_flags_t get_frame_pkt_flags(const VP10_COMP *cpi, unsigned int lib_flags) { vpx_codec_frame_flags_t flags = lib_flags << 16; - if (lib_flags & FRAMEFLAGS_KEY) - flags |= VPX_FRAME_IS_KEY; + if (lib_flags & FRAMEFLAGS_KEY) flags |= VPX_FRAME_IS_KEY; - if (cpi->droppable) - flags |= VPX_FRAME_IS_DROPPABLE; + if (cpi->droppable) flags |= VPX_FRAME_IS_DROPPABLE; return flags; } -static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, +static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, const vpx_image_t *img, vpx_codec_pts_t pts, unsigned long duration, @@ -946,12 +929,11 @@ static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, data_sz = ctx->cfg.g_w * ctx->cfg.g_h * get_image_bps(img) / 8 * (cpi->multi_arf_allowed ? 8 : 2); #endif // CONFIG_EXT_REFS - if (data_sz < 4096) - data_sz = 4096; + if (data_sz < 4096) data_sz = 4096; if (ctx->cx_data == NULL || ctx->cx_data_sz < data_sz) { ctx->cx_data_sz = data_sz; free(ctx->cx_data); - ctx->cx_data = (unsigned char*)malloc(ctx->cx_data_sz); + ctx->cx_data = (unsigned char *)malloc(ctx->cx_data_sz); if (ctx->cx_data == NULL) { return VPX_CODEC_MEM_ERROR; } @@ -964,7 +946,7 @@ static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, // Handle Flags if (((flags & VP8_EFLAG_NO_UPD_GF) && (flags & VP8_EFLAG_FORCE_GF)) || - ((flags & VP8_EFLAG_NO_UPD_ARF) && (flags & VP8_EFLAG_FORCE_ARF))) { + ((flags & VP8_EFLAG_NO_UPD_ARF) && (flags & VP8_EFLAG_FORCE_ARF))) { ctx->base.err_detail = "Conflicting flags."; return VPX_CODEC_INVALID_PARAM; } @@ -998,16 +980,15 @@ static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, unsigned char *cx_data; // Set up internal flags - if (ctx->base.init_flags & VPX_CODEC_USE_PSNR) - cpi->b_calculate_psnr = 1; + if (ctx->base.init_flags & VPX_CODEC_USE_PSNR) cpi->b_calculate_psnr = 1; if (img != NULL) { res = image2yuvconfig(img, &sd); // Store the original flags in to the frame buffer. Will extract the // key frame flag when we actually encode this frame. - if (vp10_receive_raw_frame(cpi, flags | ctx->next_frame_flags, - &sd, dst_time_stamp, dst_end_time_stamp)) { + if (vp10_receive_raw_frame(cpi, flags | ctx->next_frame_flags, &sd, + dst_time_stamp, dst_end_time_stamp)) { res = update_error_state(ctx, &cpi->common.error); } ctx->next_frame_flags = 0; @@ -1034,16 +1015,15 @@ static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, } while (cx_data_sz >= ctx->cx_data_sz / 2 && - -1 != vp10_get_compressed_data(cpi, &lib_flags, &size, - cx_data, &dst_time_stamp, - &dst_end_time_stamp, !img)) { + -1 != vp10_get_compressed_data(cpi, &lib_flags, &size, cx_data, + &dst_time_stamp, &dst_end_time_stamp, + !img)) { if (size) { vpx_codec_cx_pkt_t pkt; // Pack invisible frames with the next visible frame if (!cpi->common.show_frame) { - if (ctx->pending_cx_data == 0) - ctx->pending_cx_data = cx_data; + if (ctx->pending_cx_data == 0) ctx->pending_cx_data = cx_data; ctx->pending_cx_data_sz += size; ctx->pending_frame_sizes[ctx->pending_frame_count++] = size; cx_data += size; @@ -1055,9 +1035,8 @@ static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, // Add the frame packet to the list of returned packets. pkt.kind = VPX_CODEC_CX_FRAME_PKT; pkt.data.frame.pts = ticks_to_timebase_units(timebase, dst_time_stamp); - pkt.data.frame.duration = - (unsigned long)ticks_to_timebase_units(timebase, - dst_end_time_stamp - dst_time_stamp); + pkt.data.frame.duration = (unsigned long)ticks_to_timebase_units( + timebase, dst_end_time_stamp - dst_time_stamp); pkt.data.frame.flags = get_frame_pkt_flags(cpi, lib_flags); if (ctx->pending_cx_data) { @@ -1065,13 +1044,13 @@ static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx, ctx->pending_cx_data_sz += size; size += write_superframe_index(ctx); pkt.data.frame.buf = ctx->pending_cx_data; - pkt.data.frame.sz = ctx->pending_cx_data_sz; + pkt.data.frame.sz = ctx->pending_cx_data_sz; ctx->pending_cx_data = NULL; ctx->pending_cx_data_sz = 0; ctx->pending_frame_count = 0; } else { pkt.data.frame.buf = cx_data; - pkt.data.frame.sz = size; + pkt.data.frame.sz = size; } pkt.data.frame.partition_id = -1; @@ -1100,8 +1079,8 @@ static vpx_codec_err_t ctrl_set_reference(vpx_codec_alg_priv_t *ctx, YV12_BUFFER_CONFIG sd; image2yuvconfig(&frame->img, &sd); - vp10_set_reference_enc(ctx->cpi, ref_frame_to_vp10_reframe(frame->frame_type), - &sd); + vp10_set_reference_enc(ctx->cpi, + ref_frame_to_vp10_reframe(frame->frame_type), &sd); return VPX_CODEC_OK; } else { return VPX_CODEC_INVALID_PARAM; @@ -1117,7 +1096,7 @@ static vpx_codec_err_t ctrl_copy_reference(vpx_codec_alg_priv_t *ctx, image2yuvconfig(&frame->img, &sd); vp10_copy_reference_enc(ctx->cpi, - ref_frame_to_vp10_reframe(frame->frame_type), &sd); + ref_frame_to_vp10_reframe(frame->frame_type), &sd); return VPX_CODEC_OK; } else { return VPX_CODEC_INVALID_PARAM; @@ -1164,7 +1143,6 @@ static vpx_codec_err_t ctrl_set_previewpp(vpx_codec_alg_priv_t *ctx, return VPX_CODEC_INCAPABLE; } - static vpx_image_t *encoder_get_preview(vpx_codec_alg_priv_t *ctx) { YV12_BUFFER_CONFIG sd; @@ -1193,14 +1171,13 @@ static vpx_codec_err_t ctrl_set_roi_map(vpx_codec_alg_priv_t *ctx, return VPX_CODEC_INVALID_PARAM; } - static vpx_codec_err_t ctrl_set_active_map(vpx_codec_alg_priv_t *ctx, va_list args) { vpx_active_map_t *const map = va_arg(args, vpx_active_map_t *); if (map) { - if (!vp10_set_active_map(ctx->cpi, map->active_map, - (int)map->rows, (int)map->cols)) + if (!vp10_set_active_map(ctx->cpi, map->active_map, (int)map->rows, + (int)map->cols)) return VPX_CODEC_OK; else return VPX_CODEC_INVALID_PARAM; @@ -1214,8 +1191,8 @@ static vpx_codec_err_t ctrl_get_active_map(vpx_codec_alg_priv_t *ctx, vpx_active_map_t *const map = va_arg(args, vpx_active_map_t *); if (map) { - if (!vp10_get_active_map(ctx->cpi, map->active_map, - (int)map->rows, (int)map->cols)) + if (!vp10_get_active_map(ctx->cpi, map->active_map, (int)map->rows, + (int)map->cols)) return VPX_CODEC_OK; else return VPX_CODEC_INVALID_PARAM; @@ -1229,9 +1206,9 @@ static vpx_codec_err_t ctrl_set_scale_mode(vpx_codec_alg_priv_t *ctx, vpx_scaling_mode_t *const mode = va_arg(args, vpx_scaling_mode_t *); if (mode) { - const int res = vp10_set_internal_size(ctx->cpi, - (VPX_SCALING)mode->h_scaling_mode, - (VPX_SCALING)mode->v_scaling_mode); + const int res = + vp10_set_internal_size(ctx->cpi, (VPX_SCALING)mode->h_scaling_mode, + (VPX_SCALING)mode->v_scaling_mode); return (res == 0) ? VPX_CODEC_OK : VPX_CODEC_INVALID_PARAM; } else { return VPX_CODEC_INVALID_PARAM; @@ -1263,119 +1240,118 @@ static vpx_codec_err_t ctrl_set_render_size(vpx_codec_alg_priv_t *ctx, va_list args) { struct vp10_extracfg extra_cfg = ctx->extra_cfg; int *const render_size = va_arg(args, int *); - extra_cfg.render_width = render_size[0]; + extra_cfg.render_width = render_size[0]; extra_cfg.render_height = render_size[1]; return update_extra_cfg(ctx, &extra_cfg); } static vpx_codec_err_t ctrl_set_superblock_size(vpx_codec_alg_priv_t *ctx, - va_list args) { + va_list args) { struct vp10_extracfg extra_cfg = ctx->extra_cfg; extra_cfg.superblock_size = CAST(VP10E_SET_SUPERBLOCK_SIZE, args); return update_extra_cfg(ctx, &extra_cfg); } static vpx_codec_ctrl_fn_map_t encoder_ctrl_maps[] = { - {VP8_COPY_REFERENCE, ctrl_copy_reference}, - {VP8E_USE_REFERENCE, ctrl_use_reference}, + { VP8_COPY_REFERENCE, ctrl_copy_reference }, + { VP8E_USE_REFERENCE, ctrl_use_reference }, // Setters - {VP8_SET_REFERENCE, ctrl_set_reference}, - {VP8_SET_POSTPROC, ctrl_set_previewpp}, - {VP8E_SET_ROI_MAP, ctrl_set_roi_map}, - {VP8E_SET_ACTIVEMAP, ctrl_set_active_map}, - {VP8E_SET_SCALEMODE, ctrl_set_scale_mode}, - {VP8E_SET_CPUUSED, ctrl_set_cpuused}, - {VP8E_SET_ENABLEAUTOALTREF, ctrl_set_enable_auto_alt_ref}, + { VP8_SET_REFERENCE, ctrl_set_reference }, + { VP8_SET_POSTPROC, ctrl_set_previewpp }, + { VP8E_SET_ROI_MAP, ctrl_set_roi_map }, + { VP8E_SET_ACTIVEMAP, ctrl_set_active_map }, + { VP8E_SET_SCALEMODE, ctrl_set_scale_mode }, + { VP8E_SET_CPUUSED, ctrl_set_cpuused }, + { VP8E_SET_ENABLEAUTOALTREF, ctrl_set_enable_auto_alt_ref }, #if CONFIG_EXT_REFS - {VP8E_SET_ENABLEAUTOBWDREF, ctrl_set_enable_auto_bwd_ref}, + { VP8E_SET_ENABLEAUTOBWDREF, ctrl_set_enable_auto_bwd_ref }, #endif // CONFIG_EXT_REFS - {VP8E_SET_SHARPNESS, ctrl_set_sharpness}, - {VP8E_SET_STATIC_THRESHOLD, ctrl_set_static_thresh}, - {VP9E_SET_TILE_COLUMNS, ctrl_set_tile_columns}, - {VP9E_SET_TILE_ROWS, ctrl_set_tile_rows}, - {VP8E_SET_ARNR_MAXFRAMES, ctrl_set_arnr_max_frames}, - {VP8E_SET_ARNR_STRENGTH, ctrl_set_arnr_strength}, - {VP8E_SET_ARNR_TYPE, ctrl_set_arnr_type}, - {VP8E_SET_TUNING, ctrl_set_tuning}, - {VP8E_SET_CQ_LEVEL, ctrl_set_cq_level}, - {VP8E_SET_MAX_INTRA_BITRATE_PCT, ctrl_set_rc_max_intra_bitrate_pct}, - {VP9E_SET_MAX_INTER_BITRATE_PCT, ctrl_set_rc_max_inter_bitrate_pct}, - {VP9E_SET_GF_CBR_BOOST_PCT, ctrl_set_rc_gf_cbr_boost_pct}, - {VP9E_SET_LOSSLESS, ctrl_set_lossless}, - {VP9E_SET_FRAME_PARALLEL_DECODING, ctrl_set_frame_parallel_decoding_mode}, - {VP9E_SET_AQ_MODE, ctrl_set_aq_mode}, - {VP9E_SET_FRAME_PERIODIC_BOOST, ctrl_set_frame_periodic_boost}, - {VP9E_SET_TUNE_CONTENT, ctrl_set_tune_content}, - {VP9E_SET_COLOR_SPACE, ctrl_set_color_space}, - {VP9E_SET_COLOR_RANGE, ctrl_set_color_range}, - {VP9E_SET_NOISE_SENSITIVITY, ctrl_set_noise_sensitivity}, - {VP9E_SET_MIN_GF_INTERVAL, ctrl_set_min_gf_interval}, - {VP9E_SET_MAX_GF_INTERVAL, ctrl_set_max_gf_interval}, - {VP9E_SET_RENDER_SIZE, ctrl_set_render_size}, - {VP10E_SET_SUPERBLOCK_SIZE, ctrl_set_superblock_size}, + { VP8E_SET_SHARPNESS, ctrl_set_sharpness }, + { VP8E_SET_STATIC_THRESHOLD, ctrl_set_static_thresh }, + { VP9E_SET_TILE_COLUMNS, ctrl_set_tile_columns }, + { VP9E_SET_TILE_ROWS, ctrl_set_tile_rows }, + { VP8E_SET_ARNR_MAXFRAMES, ctrl_set_arnr_max_frames }, + { VP8E_SET_ARNR_STRENGTH, ctrl_set_arnr_strength }, + { VP8E_SET_ARNR_TYPE, ctrl_set_arnr_type }, + { VP8E_SET_TUNING, ctrl_set_tuning }, + { VP8E_SET_CQ_LEVEL, ctrl_set_cq_level }, + { VP8E_SET_MAX_INTRA_BITRATE_PCT, ctrl_set_rc_max_intra_bitrate_pct }, + { VP9E_SET_MAX_INTER_BITRATE_PCT, ctrl_set_rc_max_inter_bitrate_pct }, + { VP9E_SET_GF_CBR_BOOST_PCT, ctrl_set_rc_gf_cbr_boost_pct }, + { VP9E_SET_LOSSLESS, ctrl_set_lossless }, + { VP9E_SET_FRAME_PARALLEL_DECODING, ctrl_set_frame_parallel_decoding_mode }, + { VP9E_SET_AQ_MODE, ctrl_set_aq_mode }, + { VP9E_SET_FRAME_PERIODIC_BOOST, ctrl_set_frame_periodic_boost }, + { VP9E_SET_TUNE_CONTENT, ctrl_set_tune_content }, + { VP9E_SET_COLOR_SPACE, ctrl_set_color_space }, + { VP9E_SET_COLOR_RANGE, ctrl_set_color_range }, + { VP9E_SET_NOISE_SENSITIVITY, ctrl_set_noise_sensitivity }, + { VP9E_SET_MIN_GF_INTERVAL, ctrl_set_min_gf_interval }, + { VP9E_SET_MAX_GF_INTERVAL, ctrl_set_max_gf_interval }, + { VP9E_SET_RENDER_SIZE, ctrl_set_render_size }, + { VP10E_SET_SUPERBLOCK_SIZE, ctrl_set_superblock_size }, // Getters - {VP8E_GET_LAST_QUANTIZER, ctrl_get_quantizer}, - {VP8E_GET_LAST_QUANTIZER_64, ctrl_get_quantizer64}, - {VP9_GET_REFERENCE, ctrl_get_reference}, - {VP9E_GET_ACTIVEMAP, ctrl_get_active_map}, - {VP10_GET_NEW_FRAME_IMAGE, ctrl_get_new_frame_image}, + { VP8E_GET_LAST_QUANTIZER, ctrl_get_quantizer }, + { VP8E_GET_LAST_QUANTIZER_64, ctrl_get_quantizer64 }, + { VP9_GET_REFERENCE, ctrl_get_reference }, + { VP9E_GET_ACTIVEMAP, ctrl_get_active_map }, + { VP10_GET_NEW_FRAME_IMAGE, ctrl_get_new_frame_image }, - { -1, NULL}, + { -1, NULL }, }; static vpx_codec_enc_cfg_map_t encoder_usage_cfg_map[] = { - { - 0, - { // NOLINT - 0, // g_usage - 8, // g_threads - 0, // g_profile + { 0, + { + // NOLINT + 0, // g_usage + 8, // g_threads + 0, // g_profile - 320, // g_width - 240, // g_height - VPX_BITS_8, // g_bit_depth - 8, // g_input_bit_depth + 320, // g_width + 240, // g_height + VPX_BITS_8, // g_bit_depth + 8, // g_input_bit_depth - {1, 30}, // g_timebase + { 1, 30 }, // g_timebase - 0, // g_error_resilient + 0, // g_error_resilient - VPX_RC_ONE_PASS, // g_pass + VPX_RC_ONE_PASS, // g_pass - 25, // g_lag_in_frames + 25, // g_lag_in_frames - 0, // rc_dropframe_thresh - 0, // rc_resize_allowed - 0, // rc_scaled_width - 0, // rc_scaled_height - 60, // rc_resize_down_thresold - 30, // rc_resize_up_thresold + 0, // rc_dropframe_thresh + 0, // rc_resize_allowed + 0, // rc_scaled_width + 0, // rc_scaled_height + 60, // rc_resize_down_thresold + 30, // rc_resize_up_thresold - VPX_VBR, // rc_end_usage - {NULL, 0}, // rc_twopass_stats_in - {NULL, 0}, // rc_firstpass_mb_stats_in - 256, // rc_target_bandwidth - 0, // rc_min_quantizer - 63, // rc_max_quantizer - 25, // rc_undershoot_pct - 25, // rc_overshoot_pct + VPX_VBR, // rc_end_usage + { NULL, 0 }, // rc_twopass_stats_in + { NULL, 0 }, // rc_firstpass_mb_stats_in + 256, // rc_target_bandwidth + 0, // rc_min_quantizer + 63, // rc_max_quantizer + 25, // rc_undershoot_pct + 25, // rc_overshoot_pct - 6000, // rc_max_buffer_size - 4000, // rc_buffer_initial_size - 5000, // rc_buffer_optimal_size + 6000, // rc_max_buffer_size + 4000, // rc_buffer_initial_size + 5000, // rc_buffer_optimal_size - 50, // rc_two_pass_vbrbias - 0, // rc_two_pass_vbrmin_section - 2000, // rc_two_pass_vbrmax_section + 50, // rc_two_pass_vbrbias + 0, // rc_two_pass_vbrmin_section + 2000, // rc_two_pass_vbrmax_section - // keyframing settings (kf) - VPX_KF_AUTO, // g_kfmode - 0, // kf_min_dist - 9999, // kf_max_dist - } - }, + // keyframing settings (kf) + VPX_KF_AUTO, // g_kfmode + 0, // kf_min_dist + 9999, // kf_max_dist + } }, }; #ifndef VERSION_STRING @@ -1387,25 +1363,27 @@ CODEC_INTERFACE(vpx_codec_vp10_cx) = { #if CONFIG_VP9_HIGHBITDEPTH VPX_CODEC_CAP_HIGHBITDEPTH | #endif - VPX_CODEC_CAP_ENCODER | VPX_CODEC_CAP_PSNR, // vpx_codec_caps_t - encoder_init, // vpx_codec_init_fn_t - encoder_destroy, // vpx_codec_destroy_fn_t - encoder_ctrl_maps, // vpx_codec_ctrl_fn_map_t - { // NOLINT - NULL, // vpx_codec_peek_si_fn_t - NULL, // vpx_codec_get_si_fn_t - NULL, // vpx_codec_decode_fn_t - NULL, // vpx_codec_frame_get_fn_t - NULL // vpx_codec_set_fb_fn_t + VPX_CODEC_CAP_ENCODER | VPX_CODEC_CAP_PSNR, // vpx_codec_caps_t + encoder_init, // vpx_codec_init_fn_t + encoder_destroy, // vpx_codec_destroy_fn_t + encoder_ctrl_maps, // vpx_codec_ctrl_fn_map_t + { + // NOLINT + NULL, // vpx_codec_peek_si_fn_t + NULL, // vpx_codec_get_si_fn_t + NULL, // vpx_codec_decode_fn_t + NULL, // vpx_codec_frame_get_fn_t + NULL // vpx_codec_set_fb_fn_t }, - { // NOLINT - 1, // 1 cfg map - encoder_usage_cfg_map, // vpx_codec_enc_cfg_map_t - encoder_encode, // vpx_codec_encode_fn_t - encoder_get_cxdata, // vpx_codec_get_cx_data_fn_t - encoder_set_config, // vpx_codec_enc_config_set_fn_t - NULL, // vpx_codec_get_global_headers_fn_t - encoder_get_preview, // vpx_codec_get_preview_frame_fn_t - NULL // vpx_codec_enc_mr_get_mem_loc_fn_t + { + // NOLINT + 1, // 1 cfg map + encoder_usage_cfg_map, // vpx_codec_enc_cfg_map_t + encoder_encode, // vpx_codec_encode_fn_t + encoder_get_cxdata, // vpx_codec_get_cx_data_fn_t + encoder_set_config, // vpx_codec_enc_config_set_fn_t + NULL, // vpx_codec_get_global_headers_fn_t + encoder_get_preview, // vpx_codec_get_preview_frame_fn_t + NULL // vpx_codec_enc_mr_get_mem_loc_fn_t } }; diff --git a/vp10/vp10_dx_iface.c b/vp10/vp10_dx_iface.c index 4ee041c74..1b8636ffe 100644 --- a/vp10/vp10_dx_iface.c +++ b/vp10/vp10_dx_iface.c @@ -34,7 +34,7 @@ typedef vpx_codec_stream_info_t vp10_stream_info_t; // This limit is due to framebuffer numbers. // TODO(hkuang): Remove this limit after implementing ondemand framebuffers. -#define FRAME_CACHE_SIZE 6 // Cache maximum 6 decoded frames. +#define FRAME_CACHE_SIZE 6 // Cache maximum 6 decoded frames. typedef struct cache_frame { int fb_idx; @@ -42,38 +42,38 @@ typedef struct cache_frame { } cache_frame; struct vpx_codec_alg_priv { - vpx_codec_priv_t base; - vpx_codec_dec_cfg_t cfg; - vp10_stream_info_t si; - int postproc_cfg_set; - vp8_postproc_cfg_t postproc_cfg; - vpx_decrypt_cb decrypt_cb; - void *decrypt_state; - vpx_image_t img; - int img_avail; - int flushed; - int invert_tile_order; - int last_show_frame; // Index of last output frame. - int byte_alignment; - int skip_loop_filter; - int decode_tile_row; - int decode_tile_col; + vpx_codec_priv_t base; + vpx_codec_dec_cfg_t cfg; + vp10_stream_info_t si; + int postproc_cfg_set; + vp8_postproc_cfg_t postproc_cfg; + vpx_decrypt_cb decrypt_cb; + void *decrypt_state; + vpx_image_t img; + int img_avail; + int flushed; + int invert_tile_order; + int last_show_frame; // Index of last output frame. + int byte_alignment; + int skip_loop_filter; + int decode_tile_row; + int decode_tile_col; // Frame parallel related. - int frame_parallel_decode; // frame-based threading. - VPxWorker *frame_workers; - int num_frame_workers; - int next_submit_worker_id; - int last_submit_worker_id; - int next_output_worker_id; - int available_threads; - cache_frame frame_cache[FRAME_CACHE_SIZE]; - int frame_cache_write; - int frame_cache_read; - int num_cache_frames; - int need_resync; // wait for key/intra-only frame + int frame_parallel_decode; // frame-based threading. + VPxWorker *frame_workers; + int num_frame_workers; + int next_submit_worker_id; + int last_submit_worker_id; + int next_output_worker_id; + int available_threads; + cache_frame frame_cache[FRAME_CACHE_SIZE]; + int frame_cache_write; + int frame_cache_read; + int num_cache_frames; + int need_resync; // wait for key/intra-only frame // BufferPool that holds all reference frames. Shared by all the FrameWorkers. - BufferPool *buffer_pool; + BufferPool *buffer_pool; // External frame buffer info to save for VP10 common. void *ext_priv; // Private data associated with the external frame buffers. @@ -91,8 +91,7 @@ static vpx_codec_err_t decoder_init(vpx_codec_ctx_t *ctx, if (!ctx->priv) { vpx_codec_alg_priv_t *const priv = (vpx_codec_alg_priv_t *)vpx_calloc(1, sizeof(*priv)); - if (priv == NULL) - return VPX_CODEC_MEM_ERROR; + if (priv == NULL) return VPX_CODEC_MEM_ERROR; ctx->priv = (vpx_codec_priv_t *)priv; ctx->priv->init_flags = ctx->init_flags; @@ -101,7 +100,9 @@ static vpx_codec_err_t decoder_init(vpx_codec_ctx_t *ctx, // Only do frame parallel decode when threads > 1. priv->frame_parallel_decode = (ctx->config.dec && (ctx->config.dec->threads > 1) && - (ctx->init_flags & VPX_CODEC_USE_FRAME_THREADING)) ? 1 : 0; + (ctx->init_flags & VPX_CODEC_USE_FRAME_THREADING)) + ? 1 + : 0; if (ctx->config.dec) { priv->cfg = *ctx->config.dec; ctx->config.dec = &priv->cfg; @@ -147,11 +148,10 @@ static vpx_codec_err_t decoder_destroy(vpx_codec_alg_priv_t *ctx) { return VPX_CODEC_OK; } -static int parse_bitdepth_colorspace_sampling( - BITSTREAM_PROFILE profile, struct vpx_read_bit_buffer *rb) { +static int parse_bitdepth_colorspace_sampling(BITSTREAM_PROFILE profile, + struct vpx_read_bit_buffer *rb) { vpx_color_space_t color_space; - if (profile >= PROFILE_2) - rb->bit_offset += 1; // Bit-depth 10 or 12. + if (profile >= PROFILE_2) rb->bit_offset += 1; // Bit-depth 10 or 12. color_space = (vpx_color_space_t)vpx_rb_read_literal(rb, 3); if (color_space != VPX_CS_SRGB) { rb->bit_offset += 1; // [16,235] (including xvycc) vs [0,255] range. @@ -170,17 +170,13 @@ static int parse_bitdepth_colorspace_sampling( return 1; } -static vpx_codec_err_t decoder_peek_si_internal(const uint8_t *data, - unsigned int data_sz, - vpx_codec_stream_info_t *si, - int *is_intra_only, - vpx_decrypt_cb decrypt_cb, - void *decrypt_state) { +static vpx_codec_err_t decoder_peek_si_internal( + const uint8_t *data, unsigned int data_sz, vpx_codec_stream_info_t *si, + int *is_intra_only, vpx_decrypt_cb decrypt_cb, void *decrypt_state) { int intra_only_flag = 0; uint8_t clear_buffer[9]; - if (data + data_sz <= data) - return VPX_CODEC_INVALID_PARAM; + if (data + data_sz <= data) return VPX_CODEC_INVALID_PARAM; si->is_kf = 0; si->w = si->h = 0; @@ -198,30 +194,26 @@ static vpx_codec_err_t decoder_peek_si_internal(const uint8_t *data, const int frame_marker = vpx_rb_read_literal(&rb, 2); const BITSTREAM_PROFILE profile = vp10_read_profile(&rb); - if (frame_marker != VPX_FRAME_MARKER) - return VPX_CODEC_UNSUP_BITSTREAM; + if (frame_marker != VPX_FRAME_MARKER) return VPX_CODEC_UNSUP_BITSTREAM; - if (profile >= MAX_PROFILES) - return VPX_CODEC_UNSUP_BITSTREAM; + if (profile >= MAX_PROFILES) return VPX_CODEC_UNSUP_BITSTREAM; if ((profile >= 2 && data_sz <= 1) || data_sz < 1) return VPX_CODEC_UNSUP_BITSTREAM; - if (vpx_rb_read_bit(&rb)) { // show an existing frame + if (vpx_rb_read_bit(&rb)) { // show an existing frame vpx_rb_read_literal(&rb, 3); // Frame buffer to show. return VPX_CODEC_OK; } - if (data_sz <= 8) - return VPX_CODEC_UNSUP_BITSTREAM; + if (data_sz <= 8) return VPX_CODEC_UNSUP_BITSTREAM; si->is_kf = !vpx_rb_read_bit(&rb); show_frame = vpx_rb_read_bit(&rb); error_resilient = vpx_rb_read_bit(&rb); if (si->is_kf) { - if (!vp10_read_sync_code(&rb)) - return VPX_CODEC_UNSUP_BITSTREAM; + if (!vp10_read_sync_code(&rb)) return VPX_CODEC_UNSUP_BITSTREAM; if (!parse_bitdepth_colorspace_sampling(profile, &rb)) return VPX_CODEC_UNSUP_BITSTREAM; @@ -232,8 +224,7 @@ static vpx_codec_err_t decoder_peek_si_internal(const uint8_t *data, rb.bit_offset += error_resilient ? 0 : 2; // reset_frame_context if (intra_only_flag) { - if (!vp10_read_sync_code(&rb)) - return VPX_CODEC_UNSUP_BITSTREAM; + if (!vp10_read_sync_code(&rb)) return VPX_CODEC_UNSUP_BITSTREAM; if (profile > PROFILE_0) { if (!parse_bitdepth_colorspace_sampling(profile, &rb)) return VPX_CODEC_UNSUP_BITSTREAM; @@ -243,8 +234,7 @@ static vpx_codec_err_t decoder_peek_si_internal(const uint8_t *data, } } } - if (is_intra_only != NULL) - *is_intra_only = intra_only_flag; + if (is_intra_only != NULL) *is_intra_only = intra_only_flag; return VPX_CODEC_OK; } @@ -257,8 +247,8 @@ static vpx_codec_err_t decoder_peek_si(const uint8_t *data, static vpx_codec_err_t decoder_get_si(vpx_codec_alg_priv_t *ctx, vpx_codec_stream_info_t *si) { const size_t sz = (si->sz >= sizeof(vp10_stream_info_t)) - ? sizeof(vp10_stream_info_t) - : sizeof(vpx_codec_stream_info_t); + ? sizeof(vp10_stream_info_t) + : sizeof(vpx_codec_stream_info_t); memcpy(si, &ctx->si, sz); si->sz = (unsigned int)sz; @@ -270,8 +260,8 @@ static void set_error_detail(vpx_codec_alg_priv_t *ctx, ctx->base.err_detail = error; } -static vpx_codec_err_t update_error_state(vpx_codec_alg_priv_t *ctx, - const struct vpx_internal_error_info *error) { +static vpx_codec_err_t update_error_state( + vpx_codec_alg_priv_t *ctx, const struct vpx_internal_error_info *error) { if (error->error_code) set_error_detail(ctx, error->has_detail ? error->detail : NULL); @@ -319,10 +309,8 @@ static int frame_worker_hook(void *arg1, void *arg2) { const uint8_t *data = frame_worker_data->data; (void)arg2; - frame_worker_data->result = - vp10_receive_compressed_data(frame_worker_data->pbi, - frame_worker_data->data_size, - &data); + frame_worker_data->result = vp10_receive_compressed_data( + frame_worker_data->pbi, frame_worker_data->data_size, &data); frame_worker_data->data_end = data; if (frame_worker_data->pbi->common.frame_parallel_decode) { @@ -364,25 +352,24 @@ static vpx_codec_err_t init_decoder(vpx_codec_alg_priv_t *ctx) { ctx->num_cache_frames = 0; ctx->need_resync = 1; ctx->num_frame_workers = - (ctx->frame_parallel_decode == 1) ? ctx->cfg.threads: 1; + (ctx->frame_parallel_decode == 1) ? ctx->cfg.threads : 1; if (ctx->num_frame_workers > MAX_DECODE_THREADS) ctx->num_frame_workers = MAX_DECODE_THREADS; ctx->available_threads = ctx->num_frame_workers; ctx->flushed = 0; ctx->buffer_pool = (BufferPool *)vpx_calloc(1, sizeof(BufferPool)); - if (ctx->buffer_pool == NULL) - return VPX_CODEC_MEM_ERROR; + if (ctx->buffer_pool == NULL) return VPX_CODEC_MEM_ERROR; #if CONFIG_MULTITHREAD - if (pthread_mutex_init(&ctx->buffer_pool->pool_mutex, NULL)) { - set_error_detail(ctx, "Failed to allocate buffer pool mutex"); - return VPX_CODEC_MEM_ERROR; - } + if (pthread_mutex_init(&ctx->buffer_pool->pool_mutex, NULL)) { + set_error_detail(ctx, "Failed to allocate buffer pool mutex"); + return VPX_CODEC_MEM_ERROR; + } #endif - ctx->frame_workers = (VPxWorker *) - vpx_malloc(ctx->num_frame_workers * sizeof(*ctx->frame_workers)); + ctx->frame_workers = (VPxWorker *)vpx_malloc(ctx->num_frame_workers * + sizeof(*ctx->frame_workers)); if (ctx->frame_workers == NULL) { set_error_detail(ctx, "Failed to allocate frame_workers"); return VPX_CODEC_MEM_ERROR; @@ -437,8 +424,7 @@ static vpx_codec_err_t init_decoder(vpx_codec_alg_priv_t *ctx) { // If postprocessing was enabled by the application and a // configuration has not been provided, default it. - if (!ctx->postproc_cfg_set && - (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC)) + if (!ctx->postproc_cfg_set && (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC)) set_default_ppflags(&ctx->postproc_cfg); init_buffer_callbacks(ctx); @@ -468,11 +454,9 @@ static vpx_codec_err_t decode_one(vpx_codec_alg_priv_t *ctx, const vpx_codec_err_t res = decoder_peek_si_internal(*data, data_sz, &ctx->si, &is_intra_only, ctx->decrypt_cb, ctx->decrypt_state); - if (res != VPX_CODEC_OK) - return res; + if (res != VPX_CODEC_OK) return res; - if (!ctx->si.is_kf && !is_intra_only) - return VPX_CODEC_ERROR; + if (!ctx->si.is_kf && !is_intra_only) return VPX_CODEC_ERROR; } if (!ctx->frame_parallel_decode) { @@ -571,8 +555,7 @@ static void wait_worker_and_cache_frame(vpx_codec_alg_priv_t *ctx) { frame_worker_data->user_priv); ctx->frame_cache[ctx->frame_cache_write].img.fb_priv = frame_bufs[cm->new_fb_idx].raw_frame_buffer.priv; - ctx->frame_cache_write = - (ctx->frame_cache_write + 1) % FRAME_CACHE_SIZE; + ctx->frame_cache_write = (ctx->frame_cache_write + 1) % FRAME_CACHE_SIZE; ++ctx->num_cache_frames; } } @@ -581,7 +564,7 @@ static vpx_codec_err_t decoder_decode(vpx_codec_alg_priv_t *ctx, const uint8_t *data, unsigned int data_sz, void *user_priv, long deadline) { const uint8_t *data_start = data; - const uint8_t * const data_end = data + data_sz; + const uint8_t *const data_end = data + data_sz; vpx_codec_err_t res; uint32_t frame_sizes[8]; int frame_count; @@ -597,14 +580,12 @@ static vpx_codec_err_t decoder_decode(vpx_codec_alg_priv_t *ctx, // Initialize the decoder workers on the first frame. if (ctx->frame_workers == NULL) { const vpx_codec_err_t res = init_decoder(ctx); - if (res != VPX_CODEC_OK) - return res; + if (res != VPX_CODEC_OK) return res; } res = vp10_parse_superframe_index(data, data_sz, frame_sizes, &frame_count, - ctx->decrypt_cb, ctx->decrypt_state); - if (res != VPX_CODEC_OK) - return res; + ctx->decrypt_cb, ctx->decrypt_state); + if (res != VPX_CODEC_OK) return res; if (ctx->frame_parallel_decode) { // Decode in frame parallel mode. When decoding in this mode, the frame @@ -617,8 +598,8 @@ static vpx_codec_err_t decoder_decode(vpx_codec_alg_priv_t *ctx, for (i = 0; i < frame_count; ++i) { const uint8_t *data_start_copy = data_start; const uint32_t frame_size = frame_sizes[i]; - if (data_start < data - || frame_size > (uint32_t) (data_end - data_start)) { + if (data_start < data || + frame_size > (uint32_t)(data_end - data_start)) { set_error_detail(ctx, "Invalid frame size in index"); return VPX_CODEC_CORRUPT_FRAME; } @@ -635,10 +616,9 @@ static vpx_codec_err_t decoder_decode(vpx_codec_alg_priv_t *ctx, } } - res = decode_one(ctx, &data_start_copy, frame_size, user_priv, - deadline); - if (res != VPX_CODEC_OK) - return res; + res = + decode_one(ctx, &data_start_copy, frame_size, user_priv, deadline); + if (res != VPX_CODEC_OK) return res; data_start += frame_size; } } else { @@ -655,8 +635,7 @@ static vpx_codec_err_t decoder_decode(vpx_codec_alg_priv_t *ctx, } res = decode_one(ctx, &data, data_sz, user_priv, deadline); - if (res != VPX_CODEC_OK) - return res; + if (res != VPX_CODEC_OK) return res; } } else { // Decode in serial mode. @@ -667,33 +646,30 @@ static vpx_codec_err_t decoder_decode(vpx_codec_alg_priv_t *ctx, const uint8_t *data_start_copy = data_start; const uint32_t frame_size = frame_sizes[i]; vpx_codec_err_t res; - if (data_start < data - || frame_size > (uint32_t) (data_end - data_start)) { + if (data_start < data || + frame_size > (uint32_t)(data_end - data_start)) { set_error_detail(ctx, "Invalid frame size in index"); return VPX_CODEC_CORRUPT_FRAME; } - res = decode_one(ctx, &data_start_copy, frame_size, user_priv, - deadline); - if (res != VPX_CODEC_OK) - return res; + res = + decode_one(ctx, &data_start_copy, frame_size, user_priv, deadline); + if (res != VPX_CODEC_OK) return res; data_start += frame_size; } } else { while (data_start < data_end) { - const uint32_t frame_size = (uint32_t) (data_end - data_start); - const vpx_codec_err_t res = decode_one(ctx, &data_start, frame_size, - user_priv, deadline); - if (res != VPX_CODEC_OK) - return res; + const uint32_t frame_size = (uint32_t)(data_end - data_start); + const vpx_codec_err_t res = + decode_one(ctx, &data_start, frame_size, user_priv, deadline); + if (res != VPX_CODEC_OK) return res; // Account for suboptimal termination by the encoder. while (data_start < data_end) { - const uint8_t marker = read_marker(ctx->decrypt_cb, - ctx->decrypt_state, data_start); - if (marker) - break; + const uint8_t marker = + read_marker(ctx->decrypt_cb, ctx->decrypt_state, data_start); + if (marker) break; ++data_start; } } @@ -728,9 +704,8 @@ static vpx_image_t *decoder_get_frame(vpx_codec_alg_priv_t *ctx, // Output the frames in the cache first. if (ctx->num_cache_frames > 0) { release_last_output_frame(ctx); - ctx->last_show_frame = ctx->frame_cache[ctx->frame_cache_read].fb_idx; - if (ctx->need_resync) - return NULL; + ctx->last_show_frame = ctx->frame_cache[ctx->frame_cache_read].fb_idx; + if (ctx->need_resync) return NULL; img = &ctx->frame_cache[ctx->frame_cache_read].img; ctx->frame_cache_read = (ctx->frame_cache_read + 1) % FRAME_CACHE_SIZE; --ctx->num_cache_frames; @@ -743,8 +718,7 @@ static vpx_image_t *decoder_get_frame(vpx_codec_alg_priv_t *ctx, do { YV12_BUFFER_CONFIG sd; const VPxWorkerInterface *const winterface = vpx_get_worker_interface(); - VPxWorker *const worker = - &ctx->frame_workers[ctx->next_output_worker_id]; + VPxWorker *const worker = &ctx->frame_workers[ctx->next_output_worker_id]; FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1; ctx->next_output_worker_id = @@ -762,30 +736,28 @@ static vpx_image_t *decoder_get_frame(vpx_codec_alg_priv_t *ctx, RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; release_last_output_frame(ctx); ctx->last_show_frame = frame_worker_data->pbi->common.new_fb_idx; - if (ctx->need_resync) - return NULL; + if (ctx->need_resync) return NULL; yuvconfig2image(&ctx->img, &sd, frame_worker_data->user_priv); - #if CONFIG_EXT_TILE if (frame_worker_data->pbi->dec_tile_row >= 0) { - const int tile_row = VPXMIN(frame_worker_data->pbi->dec_tile_row, - cm->tile_rows - 1); + const int tile_row = + VPXMIN(frame_worker_data->pbi->dec_tile_row, cm->tile_rows - 1); const int mi_row = tile_row * cm->tile_height; const int ssy = ctx->img.y_chroma_shift; int plane; ctx->img.planes[0] += mi_row * MI_SIZE * ctx->img.stride[0]; for (plane = 1; plane < MAX_MB_PLANE; ++plane) { - ctx->img.planes[plane] += mi_row * (MI_SIZE >> ssy) * - ctx->img.stride[plane]; + ctx->img.planes[plane] += + mi_row * (MI_SIZE >> ssy) * ctx->img.stride[plane]; } - ctx->img.d_h = VPXMIN(cm->tile_height, cm->mi_rows - mi_row) * - MI_SIZE; + ctx->img.d_h = + VPXMIN(cm->tile_height, cm->mi_rows - mi_row) * MI_SIZE; } if (frame_worker_data->pbi->dec_tile_col >= 0) { - const int tile_col = VPXMIN(frame_worker_data->pbi->dec_tile_col, - cm->tile_cols - 1); + const int tile_col = + VPXMIN(frame_worker_data->pbi->dec_tile_col, cm->tile_cols - 1); const int mi_col = tile_col * cm->tile_width; const int ssx = ctx->img.x_chroma_shift; int plane; @@ -793,8 +765,8 @@ static vpx_image_t *decoder_get_frame(vpx_codec_alg_priv_t *ctx, for (plane = 1; plane < MAX_MB_PLANE; ++plane) { ctx->img.planes[plane] += mi_col * (MI_SIZE >> ssx); } - ctx->img.d_w = VPXMIN(cm->tile_width, cm->mi_cols - mi_col) * - MI_SIZE; + ctx->img.d_w = + VPXMIN(cm->tile_width, cm->mi_cols - mi_col) * MI_SIZE; } #endif // CONFIG_EXT_TILE @@ -807,8 +779,7 @@ static vpx_image_t *decoder_get_frame(vpx_codec_alg_priv_t *ctx, frame_worker_data->received_frame = 0; ++ctx->available_threads; ctx->need_resync = 1; - if (ctx->flushed != 1) - return NULL; + if (ctx->flushed != 1) return NULL; } } while (ctx->next_output_worker_id != ctx->next_submit_worker_id); } @@ -816,8 +787,7 @@ static vpx_image_t *decoder_get_frame(vpx_codec_alg_priv_t *ctx, } static vpx_codec_err_t decoder_set_fb_fn( - vpx_codec_alg_priv_t *ctx, - vpx_get_frame_buffer_cb_fn_t cb_get, + vpx_codec_alg_priv_t *ctx, vpx_get_frame_buffer_cb_fn_t cb_get, vpx_release_frame_buffer_cb_fn_t cb_release, void *cb_priv) { if (cb_get == NULL || cb_release == NULL) { return VPX_CODEC_INVALID_PARAM; @@ -868,13 +838,13 @@ static vpx_codec_err_t ctrl_copy_reference(vpx_codec_alg_priv_t *ctx, } if (data) { - vpx_ref_frame_t *frame = (vpx_ref_frame_t *) data; + vpx_ref_frame_t *frame = (vpx_ref_frame_t *)data; YV12_BUFFER_CONFIG sd; VPxWorker *const worker = ctx->frame_workers; FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1; image2yuvconfig(&frame->img, &sd); return vp10_copy_reference_dec(frame_worker_data->pbi, - (VPX_REFFRAME)frame->frame_type, &sd); + (VPX_REFFRAME)frame->frame_type, &sd); } else { return VPX_CODEC_INVALID_PARAM; } @@ -891,7 +861,7 @@ static vpx_codec_err_t ctrl_get_reference(vpx_codec_alg_priv_t *ctx, } if (data) { - YV12_BUFFER_CONFIG* fb; + YV12_BUFFER_CONFIG *fb; VPxWorker *const worker = ctx->frame_workers; FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1; fb = get_ref_frame(&frame_worker_data->pbi->common, data->idx); @@ -1096,8 +1066,7 @@ static vpx_codec_err_t ctrl_set_byte_alignment(vpx_codec_alg_priv_t *ctx, ctx->byte_alignment = byte_alignment; if (ctx->frame_workers) { VPxWorker *const worker = ctx->frame_workers; - FrameWorkerData *const frame_worker_data = - (FrameWorkerData *)worker->data1; + FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1; frame_worker_data->pbi->common.byte_alignment = byte_alignment; } return VPX_CODEC_OK; @@ -1129,32 +1098,32 @@ static vpx_codec_err_t ctrl_set_decode_tile_col(vpx_codec_alg_priv_t *ctx, } static vpx_codec_ctrl_fn_map_t decoder_ctrl_maps[] = { - {VP8_COPY_REFERENCE, ctrl_copy_reference}, + { VP8_COPY_REFERENCE, ctrl_copy_reference }, // Setters - {VP8_SET_REFERENCE, ctrl_set_reference}, - {VP8_SET_POSTPROC, ctrl_set_postproc}, - {VP8_SET_DBG_COLOR_REF_FRAME, ctrl_set_dbg_options}, - {VP8_SET_DBG_COLOR_MB_MODES, ctrl_set_dbg_options}, - {VP8_SET_DBG_COLOR_B_MODES, ctrl_set_dbg_options}, - {VP8_SET_DBG_DISPLAY_MV, ctrl_set_dbg_options}, - {VP9_INVERT_TILE_DECODE_ORDER, ctrl_set_invert_tile_order}, - {VPXD_SET_DECRYPTOR, ctrl_set_decryptor}, - {VP9_SET_BYTE_ALIGNMENT, ctrl_set_byte_alignment}, - {VP9_SET_SKIP_LOOP_FILTER, ctrl_set_skip_loop_filter}, - {VP10_SET_DECODE_TILE_ROW, ctrl_set_decode_tile_row}, - {VP10_SET_DECODE_TILE_COL, ctrl_set_decode_tile_col}, + { VP8_SET_REFERENCE, ctrl_set_reference }, + { VP8_SET_POSTPROC, ctrl_set_postproc }, + { VP8_SET_DBG_COLOR_REF_FRAME, ctrl_set_dbg_options }, + { VP8_SET_DBG_COLOR_MB_MODES, ctrl_set_dbg_options }, + { VP8_SET_DBG_COLOR_B_MODES, ctrl_set_dbg_options }, + { VP8_SET_DBG_DISPLAY_MV, ctrl_set_dbg_options }, + { VP9_INVERT_TILE_DECODE_ORDER, ctrl_set_invert_tile_order }, + { VPXD_SET_DECRYPTOR, ctrl_set_decryptor }, + { VP9_SET_BYTE_ALIGNMENT, ctrl_set_byte_alignment }, + { VP9_SET_SKIP_LOOP_FILTER, ctrl_set_skip_loop_filter }, + { VP10_SET_DECODE_TILE_ROW, ctrl_set_decode_tile_row }, + { VP10_SET_DECODE_TILE_COL, ctrl_set_decode_tile_col }, // Getters - {VP8D_GET_LAST_REF_UPDATES, ctrl_get_last_ref_updates}, - {VP8D_GET_FRAME_CORRUPTED, ctrl_get_frame_corrupted}, - {VP9_GET_REFERENCE, ctrl_get_reference}, - {VP9D_GET_DISPLAY_SIZE, ctrl_get_render_size}, - {VP9D_GET_BIT_DEPTH, ctrl_get_bit_depth}, - {VP9D_GET_FRAME_SIZE, ctrl_get_frame_size}, - {VP10_GET_NEW_FRAME_IMAGE, ctrl_get_new_frame_image}, + { VP8D_GET_LAST_REF_UPDATES, ctrl_get_last_ref_updates }, + { VP8D_GET_FRAME_CORRUPTED, ctrl_get_frame_corrupted }, + { VP9_GET_REFERENCE, ctrl_get_reference }, + { VP9D_GET_DISPLAY_SIZE, ctrl_get_render_size }, + { VP9D_GET_BIT_DEPTH, ctrl_get_bit_depth }, + { VP9D_GET_FRAME_SIZE, ctrl_get_frame_size }, + { VP10_GET_NEW_FRAME_IMAGE, ctrl_get_new_frame_image }, - { -1, NULL}, + { -1, NULL }, }; #ifndef VERSION_STRING @@ -1165,24 +1134,26 @@ CODEC_INTERFACE(vpx_codec_vp10_dx) = { VPX_CODEC_INTERNAL_ABI_VERSION, VPX_CODEC_CAP_DECODER | VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER, // vpx_codec_caps_t - decoder_init, // vpx_codec_init_fn_t - decoder_destroy, // vpx_codec_destroy_fn_t - decoder_ctrl_maps, // vpx_codec_ctrl_fn_map_t - { // NOLINT - decoder_peek_si, // vpx_codec_peek_si_fn_t - decoder_get_si, // vpx_codec_get_si_fn_t - decoder_decode, // vpx_codec_decode_fn_t - decoder_get_frame, // vpx_codec_frame_get_fn_t - decoder_set_fb_fn, // vpx_codec_set_fb_fn_t + decoder_init, // vpx_codec_init_fn_t + decoder_destroy, // vpx_codec_destroy_fn_t + decoder_ctrl_maps, // vpx_codec_ctrl_fn_map_t + { + // NOLINT + decoder_peek_si, // vpx_codec_peek_si_fn_t + decoder_get_si, // vpx_codec_get_si_fn_t + decoder_decode, // vpx_codec_decode_fn_t + decoder_get_frame, // vpx_codec_frame_get_fn_t + decoder_set_fb_fn, // vpx_codec_set_fb_fn_t }, - { // NOLINT - 0, - NULL, // vpx_codec_enc_cfg_map_t - NULL, // vpx_codec_encode_fn_t - NULL, // vpx_codec_get_cx_data_fn_t - NULL, // vpx_codec_enc_config_set_fn_t - NULL, // vpx_codec_get_global_headers_fn_t - NULL, // vpx_codec_get_preview_frame_fn_t - NULL // vpx_codec_enc_mr_get_mem_loc_fn_t + { + // NOLINT + 0, + NULL, // vpx_codec_enc_cfg_map_t + NULL, // vpx_codec_encode_fn_t + NULL, // vpx_codec_get_cx_data_fn_t + NULL, // vpx_codec_enc_config_set_fn_t + NULL, // vpx_codec_get_global_headers_fn_t + NULL, // vpx_codec_get_preview_frame_fn_t + NULL // vpx_codec_enc_mr_get_mem_loc_fn_t } }; diff --git a/vp10/vp10_iface_common.h b/vp10/vp10_iface_common.h index db52b9543..d8de21e2b 100644 --- a/vp10/vp10_iface_common.h +++ b/vp10/vp10_iface_common.h @@ -12,7 +12,7 @@ #include "vpx_ports/mem.h" -static void yuvconfig2image(vpx_image_t *img, const YV12_BUFFER_CONFIG *yv12, +static void yuvconfig2image(vpx_image_t *img, const YV12_BUFFER_CONFIG *yv12, void *user_priv) { /** vpx_img_wrap() doesn't allow specifying independent strides for * the Y, U, and V planes, nor other alignment adjustments that @@ -61,9 +61,9 @@ static void yuvconfig2image(vpx_image_t *img, const YV12_BUFFER_CONFIG *yv12, // of the image. img->fmt = (vpx_img_fmt_t)(img->fmt | VPX_IMG_FMT_HIGHBITDEPTH); img->bit_depth = yv12->bit_depth; - img->planes[VPX_PLANE_Y] = (uint8_t*)CONVERT_TO_SHORTPTR(yv12->y_buffer); - img->planes[VPX_PLANE_U] = (uint8_t*)CONVERT_TO_SHORTPTR(yv12->u_buffer); - img->planes[VPX_PLANE_V] = (uint8_t*)CONVERT_TO_SHORTPTR(yv12->v_buffer); + img->planes[VPX_PLANE_Y] = (uint8_t *)CONVERT_TO_SHORTPTR(yv12->y_buffer); + img->planes[VPX_PLANE_U] = (uint8_t *)CONVERT_TO_SHORTPTR(yv12->u_buffer); + img->planes[VPX_PLANE_V] = (uint8_t *)CONVERT_TO_SHORTPTR(yv12->v_buffer); img->planes[VPX_PLANE_ALPHA] = NULL; img->stride[VPX_PLANE_Y] = 2 * yv12->y_stride; img->stride[VPX_PLANE_U] = 2 * yv12->uv_stride; @@ -84,17 +84,17 @@ static vpx_codec_err_t image2yuvconfig(const vpx_image_t *img, yv12->u_buffer = img->planes[VPX_PLANE_U]; yv12->v_buffer = img->planes[VPX_PLANE_V]; - yv12->y_crop_width = img->d_w; + yv12->y_crop_width = img->d_w; yv12->y_crop_height = img->d_h; - yv12->render_width = img->r_w; + yv12->render_width = img->r_w; yv12->render_height = img->r_h; - yv12->y_width = img->d_w; + yv12->y_width = img->d_w; yv12->y_height = img->d_h; - yv12->uv_width = img->x_chroma_shift == 1 ? (1 + yv12->y_width) / 2 - : yv12->y_width; - yv12->uv_height = img->y_chroma_shift == 1 ? (1 + yv12->y_height) / 2 - : yv12->y_height; + yv12->uv_width = + img->x_chroma_shift == 1 ? (1 + yv12->y_width) / 2 : yv12->y_width; + yv12->uv_height = + img->y_chroma_shift == 1 ? (1 + yv12->y_height) / 2 : yv12->y_height; yv12->uv_crop_width = yv12->uv_width; yv12->uv_crop_height = yv12->uv_height; @@ -124,9 +124,9 @@ static vpx_codec_err_t image2yuvconfig(const vpx_image_t *img, } else { yv12->flags = 0; } - yv12->border = (yv12->y_stride - img->w) / 2; + yv12->border = (yv12->y_stride - img->w) / 2; #else - yv12->border = (img->stride[VPX_PLANE_Y] - img->w) / 2; + yv12->border = (img->stride[VPX_PLANE_Y] - img->w) / 2; #endif // CONFIG_VP9_HIGHBITDEPTH yv12->subsampling_x = img->x_chroma_shift; yv12->subsampling_y = img->y_chroma_shift; @@ -135,12 +135,9 @@ static vpx_codec_err_t image2yuvconfig(const vpx_image_t *img, static VPX_REFFRAME ref_frame_to_vp10_reframe(vpx_ref_frame_type_t frame) { switch (frame) { - case VP8_LAST_FRAME: - return VPX_LAST_FLAG; - case VP8_GOLD_FRAME: - return VPX_GOLD_FLAG; - case VP8_ALTR_FRAME: - return VPX_ALT_FLAG; + case VP8_LAST_FRAME: return VPX_LAST_FLAG; + case VP8_GOLD_FRAME: return VPX_GOLD_FLAG; + case VP8_ALTR_FRAME: return VPX_ALT_FLAG; } assert(0 && "Invalid Reference Frame"); return VPX_LAST_FLAG;