From e9fd1eace1c9b35733fa988d2f661fb16548e899 Mon Sep 17 00:00:00 2001 From: John Koleszar Date: Wed, 17 Oct 2012 16:47:38 -0700 Subject: [PATCH] Remove bc, bc2 from pbi,cpi,xd Pass the bool coder to be used explicitly. This avoids cases where two different bool coders can be addressed from the same function. Also be more consistent with bool coder variable naming, start to standardize on 'bc'. Change-Id: I1c95e2fdbe24ebe8c0f84924daa1728e3b054a31 --- vp8/common/blockd.h | 2 - vp8/decoder/asm_dec_offsets.c | 1 - vp8/decoder/decodemv.c | 41 +-- vp8/decoder/decodemv.h | 9 +- vp8/decoder/decodframe.c | 173 ++++++------ vp8/decoder/detokenize.c | 81 +++--- vp8/decoder/detokenize.h | 11 +- vp8/decoder/onyxd_int.h | 3 - vp8/encoder/asm_enc_offsets.c | 1 - vp8/encoder/bitstream.c | 506 +++++++++++++++++----------------- vp8/encoder/encodemv.c | 190 ++++++------- vp8/encoder/encodemv.h | 31 ++- vp8/encoder/onyx_int.h | 3 - 13 files changed, 530 insertions(+), 522 deletions(-) diff --git a/vp8/common/blockd.h b/vp8/common/blockd.h index 10e7d6d0c..511fe9e2a 100644 --- a/vp8/common/blockd.h +++ b/vp8/common/blockd.h @@ -364,8 +364,6 @@ typedef struct MacroBlockD { vp8_subpix_fn_t subpixel_predict_avg16x16; int allow_high_precision_mv; - void *current_bc; - int corrupted; #if !CONFIG_SUPERBLOCKS && (ARCH_X86 || ARCH_X86_64) diff --git a/vp8/decoder/asm_dec_offsets.c b/vp8/decoder/asm_dec_offsets.c index 1a6090b2b..8551bab10 100644 --- a/vp8/decoder/asm_dec_offsets.c +++ b/vp8/decoder/asm_dec_offsets.c @@ -24,7 +24,6 @@ DEFINE(detok_A, offsetof(DETOK, A)); DEFINE(detok_L, offsetof(DETOK, L)); DEFINE(detok_qcoeff_start_ptr, offsetof(DETOK, qcoeff_start_ptr)); -DEFINE(detok_current_bc, offsetof(DETOK, current_bc)); DEFINE(detok_coef_probs, offsetof(DETOK, coef_probs)); DEFINE(detok_eob, offsetof(DETOK, eob)); diff --git a/vp8/decoder/decodemv.c b/vp8/decoder/decodemv.c index 7006c0c80..72ff126f2 100644 --- a/vp8/decoder/decodemv.c +++ b/vp8/decoder/decodemv.c @@ -18,7 +18,7 @@ #include "vp8/common/seg_common.h" #include "vp8/common/pred_common.h" #include "vp8/common/entropy.h" - +#include "vp8/decoder/decodemv.h" #if CONFIG_DEBUG #include #endif @@ -73,12 +73,12 @@ static void vp8_read_mb_segid(vp8_reader *r, MB_MODE_INFO *mi, } extern const int vp8_i8x8_block[4]; -static void vp8_kfread_modes(VP8D_COMP *pbi, - MODE_INFO *m, - int mb_row, - int mb_col) { +static void kfread_modes(VP8D_COMP *pbi, + MODE_INFO *m, + int mb_row, + int mb_col, + BOOL_DECODER* const bc) { VP8_COMMON *const cm = &pbi->common; - vp8_reader *const bc = pbi->mb.current_bc; const int mis = pbi->common.mode_info_stride; int map_index = mb_row * pbi->common.mb_cols + mb_col; MB_PREDICTION_MODE y_mode; @@ -597,9 +597,9 @@ static const unsigned char mbsplit_fill_offset[4][16] = { }; #if CONFIG_SWITCHABLE_INTERP -static void read_switchable_interp_probs(VP8D_COMP *pbi) { +static void read_switchable_interp_probs(VP8D_COMP* const pbi, + BOOL_DECODER* const bc) { VP8_COMMON *const cm = &pbi->common; - vp8_reader *const bc = &pbi->bc; int i, j; for (j = 0; j <= VP8_SWITCHABLE_FILTERS; ++j) { //for (j = 0; j <= 0; ++j) { @@ -634,7 +634,7 @@ static void mb_mode_mv_init(VP8D_COMP *pbi, vp8_reader *bc) { #endif #if CONFIG_SWITCHABLE_INTERP if (cm->mcomp_filter_type == SWITCHABLE) - read_switchable_interp_probs(pbi); + read_switchable_interp_probs(pbi, bc); #endif // Decode the baseline probabilities for decoding reference frame cm->prob_intra_coded = (vp8_prob)vp8_read_literal(bc, 8); @@ -676,10 +676,10 @@ static void mb_mode_mv_init(VP8D_COMP *pbi, vp8_reader *bc) { // the bitstream or if the value is temporally predicted asserts the predicted // value static void read_mb_segment_id(VP8D_COMP *pbi, - int mb_row, int mb_col) { + int mb_row, int mb_col, + BOOL_DECODER* const bc) { VP8_COMMON *const cm = &pbi->common; MACROBLOCKD *const xd = &pbi->mb; - vp8_reader *const bc = xd->current_bc; MODE_INFO *mi = xd->mode_info_context; MB_MODE_INFO *mbmi = &mi->mbmi; int index = mb_row * pbi->common.mb_cols + mb_col; @@ -748,7 +748,8 @@ static void read_mb_segment_id(VP8D_COMP *pbi, static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, MODE_INFO *prev_mi, - int mb_row, int mb_col) { + int mb_row, int mb_col, + BOOL_DECODER* const bc) { VP8_COMMON *const cm = &pbi->common; #if CONFIG_NEWMVENTROPY nmv_context *const nmvc = &pbi->common.fc.nmvc; @@ -758,7 +759,6 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, #endif const int mis = pbi->common.mode_info_stride; MACROBLOCKD *const xd = &pbi->mb; - vp8_reader *const bc = xd->current_bc; int_mv *const mv = &mbmi->mv; int mb_to_left_edge; @@ -790,7 +790,7 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, xd->prev_mode_info_context = prev_mi; // Read the macroblock segment id. - read_mb_segment_id(pbi, mb_row, mb_col); + read_mb_segment_id(pbi, mb_row, mb_col, bc); if (pbi->common.mb_no_coeff_skip && (!segfeature_active(xd, @@ -1305,27 +1305,28 @@ static void read_mb_modes_mv(VP8D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi, } } -void vpx_decode_mode_mvs_init(VP8D_COMP *pbi){ +void vpx_decode_mode_mvs_init(VP8D_COMP *pbi, BOOL_DECODER* const bc) { VP8_COMMON *cm = &pbi->common; vpx_memset(cm->mbskip_pred_probs, 0, sizeof(cm->mbskip_pred_probs)); if (pbi->common.mb_no_coeff_skip) { int k; for (k = 0; k < MBSKIP_CONTEXTS; ++k) - cm->mbskip_pred_probs[k] = (vp8_prob)vp8_read_literal(&pbi->bc, 8); + cm->mbskip_pred_probs[k] = (vp8_prob)vp8_read_literal(bc, 8); } - mb_mode_mv_init(pbi, &pbi->bc); + mb_mode_mv_init(pbi, bc); } void vpx_decode_mb_mode_mv(VP8D_COMP *pbi, MACROBLOCKD *xd, int mb_row, - int mb_col){ + int mb_col, + BOOL_DECODER* const bc) { MODE_INFO *mi = xd->mode_info_context; MODE_INFO *prev_mi = xd->prev_mode_info_context; if (pbi->common.frame_type == KEY_FRAME) - vp8_kfread_modes(pbi, mi, mb_row, mb_col); + kfread_modes(pbi, mi, mb_row, mb_col, bc); else - read_mb_modes_mv(pbi, mi, &mi->mbmi, prev_mi, mb_row, mb_col); + read_mb_modes_mv(pbi, mi, &mi->mbmi, prev_mi, mb_row, mb_col, bc); } diff --git a/vp8/decoder/decodemv.h b/vp8/decoder/decodemv.h index 9629f952b..bfb815f6f 100644 --- a/vp8/decoder/decodemv.h +++ b/vp8/decoder/decodemv.h @@ -11,8 +11,9 @@ #include "onyxd_int.h" -void vpx_decode_mb_mode_mv(VP8D_COMP *pbi, - MACROBLOCKD *xd, +void vpx_decode_mb_mode_mv(VP8D_COMP* const pbi, + MACROBLOCKD* const xd, int mb_row, - int mb_col); -void vpx_decode_mode_mvs_init(VP8D_COMP *pbi); + int mb_col, + BOOL_DECODER* const bc); +void vpx_decode_mode_mvs_init(VP8D_COMP* const pbi, BOOL_DECODER* const bc); diff --git a/vp8/decoder/decodframe.c b/vp8/decoder/decodframe.c index 049cac7c7..197ca4243 100644 --- a/vp8/decoder/decodframe.c +++ b/vp8/decoder/decodframe.c @@ -202,7 +202,8 @@ static void skip_recon_mb(VP8D_COMP *pbi, MACROBLOCKD *xd) { } static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, - unsigned int mb_col) { + unsigned int mb_col, + BOOL_DECODER* const bc) { int eobtotal = 0; MB_PREDICTION_MODE mode; int i; @@ -240,17 +241,17 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, xd->left_context--; } #endif - } else if (!vp8dx_bool_error(xd->current_bc)) { + } else if (!vp8dx_bool_error(bc)) { for (i = 0; i < 25; i++) { xd->block[i].eob = 0; xd->eobs[i] = 0; } if (tx_size == TX_16X16) { - eobtotal = vp8_decode_mb_tokens_16x16(pbi, xd); + eobtotal = vp8_decode_mb_tokens_16x16(pbi, xd, bc); } else if (tx_size == TX_8X8) { - eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd); + eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd, bc); } else { - eobtotal = vp8_decode_mb_tokens(pbi, xd); + eobtotal = vp8_decode_mb_tokens(pbi, xd, bc); } } @@ -263,8 +264,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV && mode != I8X8_PRED - && !vp8dx_bool_error(xd->current_bc) - ) { + && !vp8dx_bool_error(bc)) { /* Special case: Force the loopfilter to skip when eobtotal and * mb_skip_coeff are zero. * */ @@ -451,7 +451,7 @@ static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, xd->mode_info_context += (n & 1); xd->mode_info_context += (n >> 1) * pc->mode_info_stride; if (!orig_skip_flag) { - eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd); + eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd, bc); if (eobtotal == 0) // skip loopfilter xd->mode_info_context->mbmi.mb_skip_coeff = 1; } else { @@ -562,7 +562,8 @@ FILE *vpxlog = 0; /* Decode a row of Superblocks (2x2 region of MBs) */ static void -decode_sb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mbrow, MACROBLOCKD *xd) { +decode_sb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mbrow, MACROBLOCKD *xd, + BOOL_DECODER* const bc) { int i; int sb_col; int mb_row, mb_col; @@ -585,7 +586,7 @@ decode_sb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mbrow, MACROBLOCKD *xd) { MODE_INFO *mi = xd->mode_info_context; #if CONFIG_SUPERBLOCKS - mi->mbmi.encoded_as_sb = vp8_read(&pbi->bc, pc->sb_coded); + mi->mbmi.encoded_as_sb = vp8_read(bc, pc->sb_coded); #endif // Process the 4 MBs within the SB in the order: @@ -634,7 +635,7 @@ decode_sb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mbrow, MACROBLOCKD *xd) { if (i) mi->mbmi.encoded_as_sb = 0; #endif - vpx_decode_mb_mode_mv(pbi, xd, mb_row, mb_col); + vpx_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, bc); update_blockd_bmi(xd); @@ -682,7 +683,7 @@ decode_sb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mbrow, MACROBLOCKD *xd) { mi[pc->mode_info_stride + 1] = mi[0]; } #endif - decode_macroblock(pbi, xd, mb_col); + decode_macroblock(pbi, xd, mb_col, bc); #if CONFIG_SUPERBLOCKS if (xd->mode_info_context->mbmi.encoded_as_sb) { mi[1].mbmi.txfm_size = mi[0].mbmi.txfm_size; @@ -692,7 +693,7 @@ decode_sb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mbrow, MACROBLOCKD *xd) { #endif /* check if the boolean decoder has suffered an error */ - xd->corrupted |= vp8dx_bool_error(xd->current_bc); + xd->corrupted |= vp8dx_bool_error(bc); #if CONFIG_SUPERBLOCKS if (mi->mbmi.encoded_as_sb) { @@ -731,21 +732,17 @@ static int read_is_valid(const unsigned char *start, static void setup_token_decoder(VP8D_COMP *pbi, - const unsigned char *cx_data) { + const unsigned char *cx_data, + BOOL_DECODER* const bool_decoder) { VP8_COMMON *pc = &pbi->common; const unsigned char *user_data_end = pbi->Source + pbi->source_sz; - vp8_reader *bool_decoder; const unsigned char *partition; ptrdiff_t partition_size; ptrdiff_t bytes_left; - // Dummy read for now - vp8_read_literal(&pbi->bc, 2); - // Set up pointers to token partition partition = cx_data; - bool_decoder = &pbi->bc2; bytes_left = user_data_end - partition; partition_size = bytes_left; @@ -884,9 +881,8 @@ static void read_coef_probs2(VP8D_COMP *pbi) { } #endif -static void read_coef_probs(VP8D_COMP *pbi) { +static void read_coef_probs(VP8D_COMP *pbi, BOOL_DECODER* const bc) { int i, j, k, l; - vp8_reader *const bc = &pbi->bc; VP8_COMMON *const pc = &pbi->common; { @@ -1011,7 +1007,7 @@ static void read_coef_probs(VP8D_COMP *pbi) { } int vp8_decode_frame(VP8D_COMP *pbi) { - vp8_reader *const bc = &pbi->bc; + BOOL_DECODER header_bc, residual_bc; VP8_COMMON *const pc = &pbi->common; MACROBLOCKD *const xd = &pbi->mb; const unsigned char *data = (const unsigned char *)pbi->Source; @@ -1099,21 +1095,21 @@ int vp8_decode_frame(VP8D_COMP *pbi) { init_frame(pbi); - if (vp8dx_start_decode(bc, data, first_partition_length_in_bytes)) + if (vp8dx_start_decode(&header_bc, data, first_partition_length_in_bytes)) vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR, "Failed to allocate bool decoder 0"); if (pc->frame_type == KEY_FRAME) { - pc->clr_type = (YUV_TYPE)vp8_read_bit(bc); - pc->clamp_type = (CLAMP_TYPE)vp8_read_bit(bc); + pc->clr_type = (YUV_TYPE)vp8_read_bit(&header_bc); + pc->clamp_type = (CLAMP_TYPE)vp8_read_bit(&header_bc); } /* Is segmentation enabled */ - xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc); + xd->segmentation_enabled = (unsigned char)vp8_read_bit(&header_bc); if (xd->segmentation_enabled) { // Read whether or not the segmentation map is being explicitly // updated this frame. - xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc); + xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(&header_bc); // If so what method will be used. if (xd->update_mb_segmentation_map) { @@ -1122,28 +1118,28 @@ int vp8_decode_frame(VP8D_COMP *pbi) { // Read the probs used to decode the segment id for each macro // block. for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) { - xd->mb_segment_tree_probs[i] = vp8_read_bit(bc) ? - (vp8_prob)vp8_read_literal(bc, 8) : 255; + xd->mb_segment_tree_probs[i] = vp8_read_bit(&header_bc) ? + (vp8_prob)vp8_read_literal(&header_bc, 8) : 255; } // Read the prediction probs needed to decode the segment id - pc->temporal_update = (unsigned char)vp8_read_bit(bc); + pc->temporal_update = (unsigned char)vp8_read_bit(&header_bc); for (i = 0; i < PREDICTION_PROBS; i++) { if (pc->temporal_update) { - pc->segment_pred_probs[i] = vp8_read_bit(bc) ? - (vp8_prob)vp8_read_literal(bc, 8) : 255; + pc->segment_pred_probs[i] = vp8_read_bit(&header_bc) ? + (vp8_prob)vp8_read_literal(&header_bc, 8) : 255; } else { pc->segment_pred_probs[i] = 255; } } } // Is the segment data being updated - xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc); + xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(&header_bc); if (xd->update_mb_segmentation_data) { int data; - xd->mb_segment_abs_delta = (unsigned char)vp8_read_bit(bc); + xd->mb_segment_abs_delta = (unsigned char)vp8_read_bit(&header_bc); clearall_segfeatures(xd); @@ -1154,11 +1150,11 @@ int vp8_decode_frame(VP8D_COMP *pbi) { #if CONFIG_FEATUREUPDATES // feature updated? - if (vp8_read_bit(bc)) { + if (vp8_read_bit(&header_bc)) { int active = 1; if (segfeature_active(xd, i, j)) - active = vp8_read_bit(bc); + active = vp8_read_bit(&header_bc); // Is the feature enabled if (active) { @@ -1166,11 +1162,11 @@ int vp8_decode_frame(VP8D_COMP *pbi) { enable_segfeature(xd, i, j); data = (signed char)vp8_read_literal( - bc, seg_feature_data_bits(j)); + &header_bc, seg_feature_data_bits(j)); // Is the segment data signed.. if (is_segfeature_signed(j)) { - if (vp8_read_bit(bc)) + if (vp8_read_bit(&header_bc)) data = - data; } } else @@ -1181,16 +1177,16 @@ int vp8_decode_frame(VP8D_COMP *pbi) { #else // Is the feature enabled - if (vp8_read_bit(bc)) { + if (vp8_read_bit(&header_bc)) { // Update the feature data and mask enable_segfeature(xd, i, j); data = (signed char)vp8_read_literal( - bc, seg_feature_data_bits(j)); + &header_bc, seg_feature_data_bits(j)); // Is the segment data signed.. if (is_segfeature_signed(j)) { - if (vp8_read_bit(bc)) + if (vp8_read_bit(&header_bc)) data = - data; } } else @@ -1212,81 +1208,84 @@ int vp8_decode_frame(VP8D_COMP *pbi) { pc->ref_pred_probs[2] = 40; } else { for (i = 0; i < PREDICTION_PROBS; i++) { - if (vp8_read_bit(bc)) - pc->ref_pred_probs[i] = (vp8_prob)vp8_read_literal(bc, 8); + if (vp8_read_bit(&header_bc)) + pc->ref_pred_probs[i] = (vp8_prob)vp8_read_literal(&header_bc, 8); } } #if CONFIG_SUPERBLOCKS - pc->sb_coded = vp8_read_literal(bc, 8); + pc->sb_coded = vp8_read_literal(&header_bc, 8); #endif /* Read the loop filter level and type */ #if CONFIG_TX_SELECT - pc->txfm_mode = vp8_read_literal(bc, 2); + pc->txfm_mode = vp8_read_literal(&header_bc, 2); if (pc->txfm_mode == TX_MODE_SELECT) { - pc->prob_tx[0] = vp8_read_literal(bc, 8); - pc->prob_tx[1] = vp8_read_literal(bc, 8); + pc->prob_tx[0] = vp8_read_literal(&header_bc, 8); + pc->prob_tx[1] = vp8_read_literal(&header_bc, 8); } #else - pc->txfm_mode = (TXFM_MODE) vp8_read_bit(bc); + pc->txfm_mode = (TXFM_MODE) vp8_read_bit(&header_bc); if (pc->txfm_mode == ALLOW_8X8) pc->txfm_mode = ALLOW_16X16; #endif - pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc); - pc->filter_level = vp8_read_literal(bc, 6); - pc->sharpness_level = vp8_read_literal(bc, 3); + pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(&header_bc); + pc->filter_level = vp8_read_literal(&header_bc, 6); + pc->sharpness_level = vp8_read_literal(&header_bc, 3); /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */ xd->mode_ref_lf_delta_update = 0; - xd->mode_ref_lf_delta_enabled = (unsigned char)vp8_read_bit(bc); + xd->mode_ref_lf_delta_enabled = (unsigned char)vp8_read_bit(&header_bc); if (xd->mode_ref_lf_delta_enabled) { /* Do the deltas need to be updated */ - xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc); + xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(&header_bc); if (xd->mode_ref_lf_delta_update) { /* Send update */ for (i = 0; i < MAX_REF_LF_DELTAS; i++) { - if (vp8_read_bit(bc)) { - /*sign = vp8_read_bit( bc );*/ - xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6); + if (vp8_read_bit(&header_bc)) { + /*sign = vp8_read_bit( &header_bc );*/ + xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(&header_bc, 6); - if (vp8_read_bit(bc)) /* Apply sign */ + if (vp8_read_bit(&header_bc)) /* Apply sign */ xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1; } } /* Send update */ for (i = 0; i < MAX_MODE_LF_DELTAS; i++) { - if (vp8_read_bit(bc)) { - /*sign = vp8_read_bit( bc );*/ - xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6); + if (vp8_read_bit(&header_bc)) { + /*sign = vp8_read_bit( &header_bc );*/ + xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(&header_bc, 6); - if (vp8_read_bit(bc)) /* Apply sign */ + if (vp8_read_bit(&header_bc)) /* Apply sign */ xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1; } } } } - setup_token_decoder(pbi, data + first_partition_length_in_bytes); + // Dummy read for now + vp8_read_literal(&header_bc, 2); - xd->current_bc = &pbi->bc2; + setup_token_decoder(pbi, data + first_partition_length_in_bytes, + &residual_bc); /* Read the default quantizers. */ { int Q, q_update; - Q = vp8_read_literal(bc, QINDEX_BITS); /* AC 1st order Q = default */ + Q = vp8_read_literal(&header_bc, QINDEX_BITS); pc->base_qindex = Q; q_update = 0; - pc->y1dc_delta_q = get_delta_q(bc, pc->y1dc_delta_q, &q_update); - pc->y2dc_delta_q = get_delta_q(bc, pc->y2dc_delta_q, &q_update); - pc->y2ac_delta_q = get_delta_q(bc, pc->y2ac_delta_q, &q_update); - pc->uvdc_delta_q = get_delta_q(bc, pc->uvdc_delta_q, &q_update); - pc->uvac_delta_q = get_delta_q(bc, pc->uvac_delta_q, &q_update); + /* AC 1st order Q = default */ + pc->y1dc_delta_q = get_delta_q(&header_bc, pc->y1dc_delta_q, &q_update); + pc->y2dc_delta_q = get_delta_q(&header_bc, pc->y2dc_delta_q, &q_update); + pc->y2ac_delta_q = get_delta_q(&header_bc, pc->y2ac_delta_q, &q_update); + pc->uvdc_delta_q = get_delta_q(&header_bc, pc->uvdc_delta_q, &q_update); + pc->uvac_delta_q = get_delta_q(&header_bc, pc->uvac_delta_q, &q_update); if (q_update) vp8cx_init_de_quantizer(pbi); @@ -1301,8 +1300,8 @@ int vp8_decode_frame(VP8D_COMP *pbi) { */ if (pc->frame_type != KEY_FRAME) { /* Should the GF or ARF be updated from the current frame */ - pc->refresh_golden_frame = vp8_read_bit(bc); - pc->refresh_alt_ref_frame = vp8_read_bit(bc); + pc->refresh_golden_frame = vp8_read_bit(&header_bc); + pc->refresh_alt_ref_frame = vp8_read_bit(&header_bc); if (pc->refresh_alt_ref_frame) { vpx_memcpy(&pc->fc, &pc->lfc_a, sizeof(pc->fc)); @@ -1320,37 +1319,38 @@ int vp8_decode_frame(VP8D_COMP *pbi) { pc->copy_buffer_to_gf = 0; if (!pc->refresh_golden_frame) - pc->copy_buffer_to_gf = vp8_read_literal(bc, 2); + pc->copy_buffer_to_gf = vp8_read_literal(&header_bc, 2); pc->copy_buffer_to_arf = 0; if (!pc->refresh_alt_ref_frame) - pc->copy_buffer_to_arf = vp8_read_literal(bc, 2); + pc->copy_buffer_to_arf = vp8_read_literal(&header_bc, 2); - pc->ref_frame_sign_bias[GOLDEN_FRAME] = vp8_read_bit(bc); - pc->ref_frame_sign_bias[ALTREF_FRAME] = vp8_read_bit(bc); + pc->ref_frame_sign_bias[GOLDEN_FRAME] = vp8_read_bit(&header_bc); + pc->ref_frame_sign_bias[ALTREF_FRAME] = vp8_read_bit(&header_bc); /* Is high precision mv allowed */ - xd->allow_high_precision_mv = (unsigned char)vp8_read_bit(bc); + xd->allow_high_precision_mv = (unsigned char)vp8_read_bit(&header_bc); // Read the type of subpel filter to use #if CONFIG_SWITCHABLE_INTERP - if (vp8_read_bit(bc)) { + if (vp8_read_bit(&header_bc)) { pc->mcomp_filter_type = SWITCHABLE; } else #endif { - pc->mcomp_filter_type = vp8_read_literal(bc, 2); + pc->mcomp_filter_type = vp8_read_literal(&header_bc, 2); } /* To enable choice of different interploation filters */ vp8_setup_interp_filters(xd, pc->mcomp_filter_type, pc); } - pc->refresh_entropy_probs = vp8_read_bit(bc); + pc->refresh_entropy_probs = vp8_read_bit(&header_bc); if (pc->refresh_entropy_probs == 0) { vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc)); } - pc->refresh_last_frame = pc->frame_type == KEY_FRAME || vp8_read_bit(bc); + pc->refresh_last_frame = (pc->frame_type == KEY_FRAME) + || vp8_read_bit(&header_bc); if (0) { FILE *z = fopen("decodestats.stt", "a"); @@ -1421,7 +1421,7 @@ int vp8_decode_frame(VP8D_COMP *pbi) { vp8_zero(pbi->common.fc.mv_ref_ct); vp8_zero(pbi->common.fc.mv_ref_ct_a); - read_coef_probs(pbi); + read_coef_probs(pbi, &header_bc); vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG)); vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG)); @@ -1442,9 +1442,9 @@ int vp8_decode_frame(VP8D_COMP *pbi) { vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff)); /* Read the mb_no_coeff_skip flag */ - pc->mb_no_coeff_skip = (int)vp8_read_bit(bc); + pc->mb_no_coeff_skip = (int)vp8_read_bit(&header_bc); - vpx_decode_mode_mvs_init(pbi); + vpx_decode_mode_mvs_init(pbi, &header_bc); vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols); @@ -1454,13 +1454,13 @@ int vp8_decode_frame(VP8D_COMP *pbi) { /* Decode a row of superblocks */ for (mb_row = 0; mb_row < pc->mb_rows; mb_row += 2) { - decode_sb_row(pbi, pc, mb_row, xd); + decode_sb_row(pbi, pc, mb_row, xd, &residual_bc); } corrupt_tokens |= xd->corrupted; /* Collect information about decoder corruption. */ /* 1. Check first boolean decoder for errors. */ - pc->yv12_fb[pc->new_fb_idx].corrupted = vp8dx_bool_error(bc); + pc->yv12_fb[pc->new_fb_idx].corrupted = vp8dx_bool_error(&header_bc); /* 2. Check the macroblock information */ pc->yv12_fb[pc->new_fb_idx].corrupted |= corrupt_tokens; @@ -1473,7 +1473,6 @@ int vp8_decode_frame(VP8D_COMP *pbi) { "A stream must start with a complete key frame"); } - /* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes \n",bc->pos+pbi->bc2.pos); */ vp8_adapt_coef_probs(pc); if (pc->frame_type != KEY_FRAME) { vp8_adapt_mode_probs(pc); @@ -1500,7 +1499,7 @@ int vp8_decode_frame(VP8D_COMP *pbi) { #ifdef PACKET_TESTING { FILE *f = fopen("decompressor.VP8", "ab"); - unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8; + unsigned int size = residual_bc.pos + header_bc.pos + 8; fwrite((void *) &size, 4, 1, f); fwrite((void *) pbi->Source, size, 1, f); fclose(f); diff --git a/vp8/decoder/detokenize.c b/vp8/decoder/detokenize.c index 4ca7d8648..85f213470 100644 --- a/vp8/decoder/detokenize.c +++ b/vp8/decoder/detokenize.c @@ -302,17 +302,17 @@ static int vp8_get_signed(BOOL_DECODER *br, int value_to_sign) { val += (UINT16)(1 << bits_count);\ } while (0); -static int vp8_decode_coefs(VP8D_COMP *dx, const MACROBLOCKD *xd, - ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l, - PLANE_TYPE type, +static int decode_coefs(VP8D_COMP *dx, const MACROBLOCKD *xd, + BOOL_DECODER* const br, + ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l, + PLANE_TYPE type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - TX_TYPE tx_type, + TX_TYPE tx_type, #endif - int seg_eob, INT16 *qcoeff_ptr, int i, - const int *const scan, int block_type, - const int *coef_bands) { + int seg_eob, INT16 *qcoeff_ptr, int i, + const int *const scan, int block_type, + const int *coef_bands) { FRAME_CONTEXT *const fc = &dx->common.fc; - BOOL_DECODER *br = xd->current_bc; int tmp, c = (type == PLANE_TYPE_Y_NO_DC); const vp8_prob *prob, *coef_probs; @@ -446,7 +446,8 @@ SKIP_START: return c; } -int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) { +int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd, + BOOL_DECODER* const bc) { ENTROPY_CONTEXT* const A = (ENTROPY_CONTEXT *)xd->above_context; ENTROPY_CONTEXT* const L = (ENTROPY_CONTEXT *)xd->left_context; @@ -473,12 +474,12 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) { // Luma block { const int* const scan = vp8_default_zig_zag1d_16x16; - c = vp8_decode_coefs(pbi, xd, A, L, type, + c = decode_coefs(pbi, xd, bc, A, L, type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - tx_type, + tx_type, #endif - seg_eob, qcoeff_ptr, - 0, scan, TX_16X16, coef_bands_x_16x16); + seg_eob, qcoeff_ptr, + 0, scan, TX_16X16, coef_bands_x_16x16); eobs[0] = c; *A = *L = (c != !type); for (i = 1; i < 16; i++) { @@ -503,12 +504,12 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) { ENTROPY_CONTEXT* const l = L + vp8_block2left_8x8[i]; const int* const scan = vp8_default_zig_zag1d_8x8; - c = vp8_decode_coefs(pbi, xd, a, l, type, + c = decode_coefs(pbi, xd, bc, a, l, type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - tx_type, + tx_type, #endif - seg_eob, qcoeff_ptr, - i, scan, TX_8X8, coef_bands_x_8x8); + seg_eob, qcoeff_ptr, + i, scan, TX_8X8, coef_bands_x_8x8); a[0] = l[0] = ((eobs[i] = c) != !type); a[1] = a[0]; l[1] = l[0]; @@ -521,7 +522,8 @@ int vp8_decode_mb_tokens_16x16(VP8D_COMP *pbi, MACROBLOCKD *xd) { return eobtotal; } -int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) { +int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd, + BOOL_DECODER* const bc) { ENTROPY_CONTEXT *const A = (ENTROPY_CONTEXT *)xd->above_context; ENTROPY_CONTEXT *const L = (ENTROPY_CONTEXT *)xd->left_context; @@ -548,12 +550,12 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) { seg_eob = get_segdata(xd, segment_id, SEG_LVL_EOB); else seg_eob = 4; - c = vp8_decode_coefs(pbi, xd, a, l, type, + c = decode_coefs(pbi, xd, bc, a, l, type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - tx_type, + tx_type, #endif - seg_eob, qcoeff_ptr + 24 * 16, - 24, scan, TX_8X8, coef_bands_x); + seg_eob, qcoeff_ptr + 24 * 16, + 24, scan, TX_8X8, coef_bands_x); a[0] = l[0] = ((eobs[24] = c) != !type); eobtotal += c - 4; @@ -583,12 +585,12 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) { } #endif - c = vp8_decode_coefs(pbi, xd, a, l, type, + c = decode_coefs(pbi, xd, bc, a, l, type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - tx_type, + tx_type, #endif - seg_eob, qcoeff_ptr, - i, scan, TX_8X8, coef_bands_x_8x8); + seg_eob, qcoeff_ptr, + i, scan, TX_8X8, coef_bands_x_8x8); a[0] = l[0] = ((eobs[i] = c) != !type); a[1] = a[0]; l[1] = l[0]; @@ -610,12 +612,12 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) { ENTROPY_CONTEXT *const l = L + vp8_block2left[i]; const int *scan = vp8_default_zig_zag1d; - c = vp8_decode_coefs(pbi, xd, a, l, type, + c = decode_coefs(pbi, xd, bc, a, l, type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - tx_type, + tx_type, #endif - seg_eob, qcoeff_ptr, - i, scan, TX_4X4, coef_bands_x); + seg_eob, qcoeff_ptr, + i, scan, TX_4X4, coef_bands_x); a[0] = l[0] = ((eobs[i] = c) != !type); eobtotal += c; @@ -627,7 +629,8 @@ int vp8_decode_mb_tokens_8x8(VP8D_COMP *pbi, MACROBLOCKD *xd) { } -int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd) { +int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd, + BOOL_DECODER* const bc) { ENTROPY_CONTEXT *const A = (ENTROPY_CONTEXT *)xd->above_context; ENTROPY_CONTEXT *const L = (ENTROPY_CONTEXT *)xd->left_context; @@ -648,12 +651,12 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd) { ENTROPY_CONTEXT *const l = L + vp8_block2left[24]; type = PLANE_TYPE_Y2; - c = vp8_decode_coefs(dx, xd, a, l, type, + c = decode_coefs(dx, xd, bc, a, l, type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - DCT_DCT, + DCT_DCT, #endif - seg_eob, qcoeff_ptr + 24 * 16, 24, - scan, TX_4X4, coef_bands_x); + seg_eob, qcoeff_ptr + 24 * 16, 24, + scan, TX_4X4, coef_bands_x); a[0] = l[0] = ((eobs[24] = c) != !type); eobtotal += c - 16; @@ -688,12 +691,12 @@ int vp8_decode_mb_tokens(VP8D_COMP *dx, MACROBLOCKD *xd) { } #endif - c = vp8_decode_coefs(dx, xd, a, l, type, + c = decode_coefs(dx, xd, bc, a, l, type, #if CONFIG_HYBRIDTRANSFORM8X8 || CONFIG_HYBRIDTRANSFORM || CONFIG_HYBRIDTRANSFORM16X16 - tx_type, + tx_type, #endif - seg_eob, qcoeff_ptr, - i, scan, TX_4X4, coef_bands_x); + seg_eob, qcoeff_ptr, + i, scan, TX_4X4, coef_bands_x); a[0] = l[0] = ((eobs[i] = c) != !type); eobtotal += c; diff --git a/vp8/decoder/detokenize.h b/vp8/decoder/detokenize.h index d02d4cae1..df36efed5 100644 --- a/vp8/decoder/detokenize.h +++ b/vp8/decoder/detokenize.h @@ -14,9 +14,12 @@ #include "onyxd_int.h" -void vp8_reset_mb_tokens_context(MACROBLOCKD *xd); -int vp8_decode_mb_tokens(VP8D_COMP *, MACROBLOCKD *); -int vp8_decode_mb_tokens_8x8(VP8D_COMP *, MACROBLOCKD *); -int vp8_decode_mb_tokens_16x16(VP8D_COMP *, MACROBLOCKD *); +void vp8_reset_mb_tokens_context(MACROBLOCKD* const); +int vp8_decode_mb_tokens(VP8D_COMP* const, MACROBLOCKD* const, + BOOL_DECODER* const); +int vp8_decode_mb_tokens_8x8(VP8D_COMP* const, MACROBLOCKD* const, + BOOL_DECODER* const); +int vp8_decode_mb_tokens_16x16(VP8D_COMP* const, MACROBLOCKD* const, + BOOL_DECODER* const); #endif /* DETOKENIZE_H */ diff --git a/vp8/decoder/onyxd_int.h b/vp8/decoder/onyxd_int.h index b757f7764..0a84256e2 100644 --- a/vp8/decoder/onyxd_int.h +++ b/vp8/decoder/onyxd_int.h @@ -45,7 +45,6 @@ typedef struct { ENTROPY_CONTEXT_PLANES *L; INT16 *qcoeff_start_ptr; - BOOL_DECODER *current_bc; vp8_prob const *coef_probs[BLOCK_TYPES]; vp8_prob const *coef_probs_8x8[BLOCK_TYPES_8X8]; @@ -60,8 +59,6 @@ typedef struct VP8Decompressor { DECLARE_ALIGNED(16, VP8_COMMON, common); - vp8_reader bc, bc2; - VP8D_CONFIG oxcf; diff --git a/vp8/encoder/asm_enc_offsets.c b/vp8/encoder/asm_enc_offsets.c index c79e915f8..8e74901b3 100644 --- a/vp8/encoder/asm_enc_offsets.c +++ b/vp8/encoder/asm_enc_offsets.c @@ -68,7 +68,6 @@ DEFINE(vp8_extra_bit_struct_base_val, offsetof(vp8_extra_bit_struct, b DEFINE(vp8_comp_tplist, offsetof(VP8_COMP, tplist)); DEFINE(vp8_comp_common, offsetof(VP8_COMP, common)); -DEFINE(vp8_comp_bc2, offsetof(VP8_COMP, bc2)); DEFINE(tokenlist_start, offsetof(TOKENLIST, start)); DEFINE(tokenlist_stop, offsetof(TOKENLIST, stop)); diff --git a/vp8/encoder/bitstream.c b/vp8/encoder/bitstream.c index bd5def689..6310d021f 100644 --- a/vp8/encoder/bitstream.c +++ b/vp8/encoder/bitstream.c @@ -111,10 +111,10 @@ static int remap_prob(int v, int m) { return i; } -static void write_prob_diff_update(vp8_writer *const w, +static void write_prob_diff_update(vp8_writer *const bc, vp8_prob newp, vp8_prob oldp) { int delp = remap_prob(newp, oldp); - vp8_encode_term_subexp(w, delp, SUBEXP_PARAM, 255); + vp8_encode_term_subexp(bc, delp, SUBEXP_PARAM, 255); } static int prob_diff_update_cost(vp8_prob newp, vp8_prob oldp) { @@ -186,7 +186,7 @@ unsigned int pick_best_mv_ref( MACROBLOCK *x, #endif static void update_mode( - vp8_writer *const w, + vp8_writer *const bc, int n, vp8_token tok [/* n */], vp8_tree tree, @@ -212,28 +212,27 @@ static void update_mode( if (new_b + (n << 8) < old_b) { int i = 0; - vp8_write_bit(w, 1); + vp8_write_bit(bc, 1); do { const vp8_prob p = Pnew[i]; - vp8_write_literal(w, Pcur[i] = p ? p : 1, 8); + vp8_write_literal(bc, Pcur[i] = p ? p : 1, 8); } while (++i < n); } else - vp8_write_bit(w, 0); + vp8_write_bit(bc, 0); } -static void update_mbintra_mode_probs(VP8_COMP *cpi) { +static void update_mbintra_mode_probs(VP8_COMP* const cpi, + vp8_writer* const bc) { VP8_COMMON *const cm = &cpi->common; - vp8_writer *const w = &cpi->bc; - { vp8_prob Pnew [VP8_YMODES - 1]; unsigned int bct [VP8_YMODES - 1] [2]; update_mode( - w, VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree, + bc, VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree, Pnew, cm->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count ); } @@ -275,9 +274,8 @@ void update_skip_probs(VP8_COMP *cpi) { } #if CONFIG_SWITCHABLE_INTERP -void update_switchable_interp_probs(VP8_COMP *cpi) { +void update_switchable_interp_probs(VP8_COMP *cpi, vp8_writer* const bc) { VP8_COMMON *const pc = &cpi->common; - vp8_writer *const w = &cpi->bc; unsigned int branch_ct[32][2]; int i, j; for (j = 0; j <= VP8_SWITCHABLE_FILTERS; ++j) { @@ -301,7 +299,7 @@ void update_switchable_interp_probs(VP8_COMP *cpi) { for (i = 0; i < VP8_SWITCHABLE_FILTERS - 1; ++i) { if (pc->fc.switchable_interp_prob[j][i] < 1) pc->fc.switchable_interp_prob[j][i] = 1; - vp8_write_literal(w, pc->fc.switchable_interp_prob[j][i], 8); + vp8_write_literal(bc, pc->fc.switchable_interp_prob[j][i], 8); /* if (!cpi->dummy_packing) #if VP8_SWITCHABLE_FILTERS == 3 @@ -454,14 +452,14 @@ static int prob_diff_update_savings_search(const unsigned int *ct, return bestsavings; } -static void pack_mb_tokens(vp8_writer *w, +static void pack_mb_tokens(vp8_writer* const bc, TOKENEXTRA **tp, const TOKENEXTRA *const stop) { unsigned int split; unsigned int shift; - int count = w->count; - unsigned int range = w->range; - unsigned int lowvalue = w->lowvalue; + int count = bc->count; + unsigned int range = bc->range; + unsigned int lowvalue = bc->lowvalue; TOKENEXTRA *p = *tp; while (p < stop) { @@ -505,17 +503,17 @@ static void pack_mb_tokens(vp8_writer *w, int offset = shift - count; if ((lowvalue << (offset - 1)) & 0x80000000) { - int x = w->pos - 1; + int x = bc->pos - 1; - while (x >= 0 && w->buffer[x] == 0xff) { - w->buffer[x] = (unsigned char)0; + while (x >= 0 && bc->buffer[x] == 0xff) { + bc->buffer[x] = (unsigned char)0; x--; } - w->buffer[x] += 1; + bc->buffer[x] += 1; } - w->buffer[w->pos++] = (lowvalue >> (24 - offset)); + bc->buffer[bc->pos++] = (lowvalue >> (24 - offset)); lowvalue <<= offset; shift = count; lowvalue &= 0xffffff; @@ -555,17 +553,17 @@ static void pack_mb_tokens(vp8_writer *w, int offset = shift - count; if ((lowvalue << (offset - 1)) & 0x80000000) { - int x = w->pos - 1; + int x = bc->pos - 1; - while (x >= 0 && w->buffer[x] == 0xff) { - w->buffer[x] = (unsigned char)0; + while (x >= 0 && bc->buffer[x] == 0xff) { + bc->buffer[x] = (unsigned char)0; x--; } - w->buffer[x] += 1; + bc->buffer[x] += 1; } - w->buffer[w->pos++] = (lowvalue >> (24 - offset)); + bc->buffer[bc->pos++] = (lowvalue >> (24 - offset)); lowvalue <<= offset; shift = count; lowvalue &= 0xffffff; @@ -591,14 +589,14 @@ static void pack_mb_tokens(vp8_writer *w, range <<= 1; if ((lowvalue & 0x80000000)) { - int x = w->pos - 1; + int x = bc->pos - 1; - while (x >= 0 && w->buffer[x] == 0xff) { - w->buffer[x] = (unsigned char)0; + while (x >= 0 && bc->buffer[x] == 0xff) { + bc->buffer[x] = (unsigned char)0; x--; } - w->buffer[x] += 1; + bc->buffer[x] += 1; } @@ -606,7 +604,7 @@ static void pack_mb_tokens(vp8_writer *w, if (!++count) { count = -8; - w->buffer[w->pos++] = (lowvalue >> 24); + bc->buffer[bc->pos++] = (lowvalue >> 24); lowvalue &= 0xffffff; } } @@ -615,9 +613,9 @@ static void pack_mb_tokens(vp8_writer *w, ++p; } - w->count = count; - w->lowvalue = lowvalue; - w->range = range; + bc->count = count; + bc->lowvalue = lowvalue; + bc->range = range; *tp = p; } @@ -635,107 +633,108 @@ static void write_partition_size(unsigned char *cx_data, int size) { static void write_mv_ref ( - vp8_writer *w, MB_PREDICTION_MODE m, const vp8_prob *p + vp8_writer *bc, MB_PREDICTION_MODE m, const vp8_prob *p ) { #if CONFIG_DEBUG assert(NEARESTMV <= m && m <= SPLITMV); #endif - vp8_write_token(w, vp8_mv_ref_tree, p, + vp8_write_token(bc, vp8_mv_ref_tree, p, vp8_mv_ref_encoding_array - NEARESTMV + m); } #if CONFIG_SUPERBLOCKS -static void write_sb_mv_ref(vp8_writer *w, MB_PREDICTION_MODE m, const vp8_prob *p) { +static void write_sb_mv_ref(vp8_writer *bc, MB_PREDICTION_MODE m, + const vp8_prob *p) { #if CONFIG_DEBUG assert(NEARESTMV <= m && m < SPLITMV); #endif - vp8_write_token(w, vp8_sb_mv_ref_tree, p, + vp8_write_token(bc, vp8_sb_mv_ref_tree, p, vp8_sb_mv_ref_encoding_array - NEARESTMV + m); } #endif static void write_sub_mv_ref ( - vp8_writer *w, B_PREDICTION_MODE m, const vp8_prob *p + vp8_writer *bc, B_PREDICTION_MODE m, const vp8_prob *p ) { #if CONFIG_DEBUG assert(LEFT4X4 <= m && m <= NEW4X4); #endif - vp8_write_token(w, vp8_sub_mv_ref_tree, p, + vp8_write_token(bc, vp8_sub_mv_ref_tree, p, vp8_sub_mv_ref_encoding_array - LEFT4X4 + m); } #if CONFIG_NEWMVENTROPY -static void write_nmv (vp8_writer *w, const MV *mv, const int_mv *ref, - const nmv_context *nmvc, int usehp) { +static void write_nmv(vp8_writer *bc, const MV *mv, const int_mv *ref, + const nmv_context *nmvc, int usehp) { MV e; e.row = mv->row - ref->as_mv.row; e.col = mv->col - ref->as_mv.col; - vp8_encode_nmv(w, &e, &ref->as_mv, nmvc); - vp8_encode_nmv_fp(w, &e, &ref->as_mv, nmvc, usehp); + vp8_encode_nmv(bc, &e, &ref->as_mv, nmvc); + vp8_encode_nmv_fp(bc, &e, &ref->as_mv, nmvc, usehp); } #else static void write_mv ( - vp8_writer *w, const MV *mv, const int_mv *ref, const MV_CONTEXT *mvc + vp8_writer *bc, const MV *mv, const int_mv *ref, const MV_CONTEXT *mvc ) { MV e; e.row = mv->row - ref->as_mv.row; e.col = mv->col - ref->as_mv.col; - vp8_encode_motion_vector(w, &e, mvc); + vp8_encode_motion_vector(bc, &e, mvc); } static void write_mv_hp ( - vp8_writer *w, const MV *mv, const int_mv *ref, const MV_CONTEXT_HP *mvc + vp8_writer *bc, const MV *mv, const int_mv *ref, const MV_CONTEXT_HP *mvc ) { MV e; e.row = mv->row - ref->as_mv.row; e.col = mv->col - ref->as_mv.col; - vp8_encode_motion_vector_hp(w, &e, mvc); + vp8_encode_motion_vector_hp(bc, &e, mvc); } #endif /* CONFIG_NEWMVENTROPY */ // This function writes the current macro block's segnment id to the bitstream // It should only be called if a segment map update is indicated. -static void write_mb_segid(vp8_writer *w, +static void write_mb_segid(vp8_writer *bc, const MB_MODE_INFO *mi, const MACROBLOCKD *xd) { // Encode the MB segment id. if (xd->segmentation_enabled && xd->update_mb_segmentation_map) { switch (mi->segment_id) { case 0: - vp8_write(w, 0, xd->mb_segment_tree_probs[0]); - vp8_write(w, 0, xd->mb_segment_tree_probs[1]); + vp8_write(bc, 0, xd->mb_segment_tree_probs[0]); + vp8_write(bc, 0, xd->mb_segment_tree_probs[1]); break; case 1: - vp8_write(w, 0, xd->mb_segment_tree_probs[0]); - vp8_write(w, 1, xd->mb_segment_tree_probs[1]); + vp8_write(bc, 0, xd->mb_segment_tree_probs[0]); + vp8_write(bc, 1, xd->mb_segment_tree_probs[1]); break; case 2: - vp8_write(w, 1, xd->mb_segment_tree_probs[0]); - vp8_write(w, 0, xd->mb_segment_tree_probs[2]); + vp8_write(bc, 1, xd->mb_segment_tree_probs[0]); + vp8_write(bc, 0, xd->mb_segment_tree_probs[2]); break; case 3: - vp8_write(w, 1, xd->mb_segment_tree_probs[0]); - vp8_write(w, 1, xd->mb_segment_tree_probs[2]); + vp8_write(bc, 1, xd->mb_segment_tree_probs[0]); + vp8_write(bc, 1, xd->mb_segment_tree_probs[2]); break; // TRAP.. This should not happen default: - vp8_write(w, 0, xd->mb_segment_tree_probs[0]); - vp8_write(w, 0, xd->mb_segment_tree_probs[1]); + vp8_write(bc, 0, xd->mb_segment_tree_probs[0]); + vp8_write(bc, 0, xd->mb_segment_tree_probs[1]); break; } } } // This function encodes the reference frame -static void encode_ref_frame(vp8_writer *const w, +static void encode_ref_frame(vp8_writer *const bc, VP8_COMMON *const cm, MACROBLOCKD *xd, int segment_id, @@ -772,7 +771,7 @@ static void encode_ref_frame(vp8_writer *const w, (xd->mode_info_context->mbmi.ref_frame == pred_rf); set_pred_flag(xd, PRED_REF, prediction_flag); - vp8_write(w, prediction_flag, pred_prob); + vp8_write(bc, prediction_flag, pred_prob); // If not predicted correctly then code value explicitly if (!prediction_flag) { @@ -794,18 +793,18 @@ static void encode_ref_frame(vp8_writer *const w, } if (mod_refprobs[0]) { - vp8_write(w, (rf != INTRA_FRAME), mod_refprobs[0]); + vp8_write(bc, (rf != INTRA_FRAME), mod_refprobs[0]); } // Inter coded if (rf != INTRA_FRAME) { if (mod_refprobs[1]) { - vp8_write(w, (rf != LAST_FRAME), mod_refprobs[1]); + vp8_write(bc, (rf != LAST_FRAME), mod_refprobs[1]); } if (rf != LAST_FRAME) { if (mod_refprobs[2]) { - vp8_write(w, (rf != GOLDEN_FRAME), mod_refprobs[2]); + vp8_write(bc, (rf != GOLDEN_FRAME), mod_refprobs[2]); } } } @@ -848,10 +847,9 @@ static void update_ref_probs(VP8_COMP *const cpi) { compute_mod_refprobs(cm); } -static void pack_inter_mode_mvs(VP8_COMP *const cpi) { +static void pack_inter_mode_mvs(VP8_COMP *const cpi, vp8_writer *const bc) { int i; VP8_COMMON *const pc = &cpi->common; - vp8_writer *const w = &cpi->bc2; #if CONFIG_NEWMVENTROPY const nmv_context *nmvc = &pc->fc.nmvc; #else @@ -892,7 +890,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { // Process the 4 MBs in the order: // top-left, top-right, bottom-left, bottom-right #if CONFIG_SUPERBLOCKS - vp8_write(w, m->mbmi.encoded_as_sb, pc->sb_coded); + vp8_write(bc, m->mbmi.encoded_as_sb, pc->sb_coded); #endif for (i = 0; i < 4; i++) { MB_MODE_INFO *mi; @@ -942,14 +940,14 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { pred_prob = get_pred_prob(pc, xd, PRED_SEG_ID); // Code the segment id prediction flag for this mb - vp8_write(w, prediction_flag, pred_prob); + vp8_write(bc, prediction_flag, pred_prob); // If the mb segment id wasn't predicted code explicitly if (!prediction_flag) - write_mb_segid(w, mi, &cpi->mb.e_mbd); + write_mb_segid(bc, mi, &cpi->mb.e_mbd); } else { // Normal unpredicted coding - write_mb_segid(w, mi, &cpi->mb.e_mbd); + write_mb_segid(bc, mi, &cpi->mb.e_mbd); } } @@ -964,12 +962,12 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { skip_coeff &= m[mis + 1].mbmi.mb_skip_coeff; } #endif - vp8_encode_bool(w, skip_coeff, + vp8_encode_bool(bc, skip_coeff, get_pred_prob(pc, xd, PRED_MBSKIP)); } // Encode the reference frame. - encode_ref_frame(w, pc, xd, segment_id, rf); + encode_ref_frame(bc, pc, xd, segment_id, rf); if (rf == INTRA_FRAME) { #ifdef ENTROPY_STATS @@ -979,7 +977,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { // TODO(rbultje) write using SB tree structure if (!segfeature_active(xd, segment_id, SEG_LVL_MODE)) { - write_ymode(w, mode, pc->fc.ymode_prob); + write_ymode(bc, mode, pc->fc.ymode_prob); } if (mode == B_PRED) { @@ -988,13 +986,13 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { int uses_second = m->bmi[0].as_mode.second != (B_PREDICTION_MODE)(B_DC_PRED - 1); - vp8_write(w, uses_second, 128); + vp8_write(bc, uses_second, 128); #endif do { #if CONFIG_COMP_INTRA_PRED B_PREDICTION_MODE mode2 = m->bmi[j].as_mode.second; #endif - write_bmode(w, m->bmi[j].as_mode.first, + write_bmode(bc, m->bmi[j].as_mode.first, pc->fc.bmode_prob); /* if (!cpi->dummy_packing) { @@ -1006,22 +1004,22 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { */ #if CONFIG_COMP_INTRA_PRED if (uses_second) { - write_bmode(w, mode2, pc->fc.bmode_prob); + write_bmode(bc, mode2, pc->fc.bmode_prob); } #endif } while (++j < 16); } if (mode == I8X8_PRED) { - write_i8x8_mode(w, m->bmi[0].as_mode.first, + write_i8x8_mode(bc, m->bmi[0].as_mode.first, pc->fc.i8x8_mode_prob); - write_i8x8_mode(w, m->bmi[2].as_mode.first, + write_i8x8_mode(bc, m->bmi[2].as_mode.first, pc->fc.i8x8_mode_prob); - write_i8x8_mode(w, m->bmi[8].as_mode.first, + write_i8x8_mode(bc, m->bmi[8].as_mode.first, pc->fc.i8x8_mode_prob); - write_i8x8_mode(w, m->bmi[10].as_mode.first, + write_i8x8_mode(bc, m->bmi[10].as_mode.first, pc->fc.i8x8_mode_prob); } else { - write_uv_mode(w, mi->uv_mode, + write_uv_mode(bc, mi->uv_mode, pc->fc.uv_mode_prob[mode]); } } else { @@ -1053,11 +1051,11 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { if (!segfeature_active(xd, segment_id, SEG_LVL_MODE)) { #if CONFIG_SUPERBLOCKS if (mi->encoded_as_sb) { - write_sb_mv_ref(w, mode, mv_ref_p); + write_sb_mv_ref(bc, mode, mv_ref_p); } else #endif { - write_mv_ref(w, mode, mv_ref_p); + write_mv_ref(bc, mode, mv_ref_p); } vp8_accum_mv_refs(&cpi->common, mode, ct); } @@ -1066,7 +1064,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { // Is the prediction filter enabled if (mode >= NEARESTMV && mode < SPLITMV) { if (cpi->common.pred_filter_mode == 2) - vp8_write(w, mi->pred_filter_enabled, + vp8_write(bc, mi->pred_filter_enabled, pc->prob_pred_filter_off); else assert(mi->pred_filter_enabled == @@ -1077,7 +1075,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { if (mode >= NEARESTMV && mode <= SPLITMV) { if (cpi->common.mcomp_filter_type == SWITCHABLE) { - vp8_write_token(w, vp8_switchable_interp_tree, + vp8_write_token(bc, vp8_switchable_interp_tree, get_pred_probs(&cpi->common, xd, PRED_SWITCHABLE_INTERP), vp8_switchable_interp_encodings + vp8_switchable_interp_map[mi->interp_filter]); @@ -1105,7 +1103,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { // does the feature use compound prediction or not // (if not specified at the frame/segment level) if (cpi->common.comp_pred_mode == HYBRID_PREDICTION) { - vp8_write(w, mi->second_ref_frame != INTRA_FRAME, + vp8_write(bc, mi->second_ref_frame != INTRA_FRAME, get_pred_prob(pc, xd, PRED_COMP)); } @@ -1131,14 +1129,14 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { } #endif #if CONFIG_NEWMVENTROPY - write_nmv(w, &mi->mv[0].as_mv, &best_mv, + write_nmv(bc, &mi->mv[0].as_mv, &best_mv, (const nmv_context*) nmvc, xd->allow_high_precision_mv); #else if (xd->allow_high_precision_mv) { - write_mv_hp(w, &mi->mv[0].as_mv, &best_mv, mvc_hp); + write_mv_hp(bc, &mi->mv[0].as_mv, &best_mv, mvc_hp); } else { - write_mv(w, &mi->mv[0].as_mv, &best_mv, mvc); + write_mv(bc, &mi->mv[0].as_mv, &best_mv, mvc); } #endif @@ -1158,14 +1156,14 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { cpi->best_ref_index_counts[best_index]++; #endif #if CONFIG_NEWMVENTROPY - write_nmv(w, &mi->mv[1].as_mv, &best_second_mv, + write_nmv(bc, &mi->mv[1].as_mv, &best_second_mv, (const nmv_context*) nmvc, xd->allow_high_precision_mv); #else if (xd->allow_high_precision_mv) { - write_mv_hp(w, &mi->mv[1].as_mv, &best_second_mv, mvc_hp); + write_mv_hp(bc, &mi->mv[1].as_mv, &best_second_mv, mvc_hp); } else { - write_mv(w, &mi->mv[1].as_mv, &best_second_mv, mvc); + write_mv(bc, &mi->mv[1].as_mv, &best_second_mv, mvc); } #endif } @@ -1177,7 +1175,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { ++count_mb_seg [mi->partitioning]; #endif - write_split(w, mi->partitioning, cpi->common.fc.mbsplit_prob); + write_split(bc, mi->partitioning, cpi->common.fc.mbsplit_prob); cpi->mbsplit_count[mi->partitioning]++; do { @@ -1202,7 +1200,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { abovemv.as_int = above_block_mv(m, k, mis); mv_contz = vp8_mv_cont(&leftmv, &abovemv); - write_sub_mv_ref(w, blockmode, + write_sub_mv_ref(bc, blockmode, cpi->common.fc.sub_mv_ref_prob [mv_contz]); cpi->sub_mv_ref_count[mv_contz][blockmode - LEFT4X4]++; if (blockmode == NEW4X4) { @@ -1210,33 +1208,37 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { active_section = 11; #endif #if CONFIG_NEWMVENTROPY - write_nmv(w, &blockmv.as_mv, &best_mv, + write_nmv(bc, &blockmv.as_mv, &best_mv, (const nmv_context*) nmvc, xd->allow_high_precision_mv); #else if (xd->allow_high_precision_mv) { - write_mv_hp(w, &blockmv.as_mv, &best_mv, + write_mv_hp(bc, &blockmv.as_mv, &best_mv, (const MV_CONTEXT_HP *) mvc_hp); } else { - write_mv(w, &blockmv.as_mv, &best_mv, + write_mv(bc, &blockmv.as_mv, &best_mv, (const MV_CONTEXT *) mvc); } #endif if (mi->second_ref_frame) { #if CONFIG_NEWMVENTROPY - write_nmv(w, + write_nmv(bc, &cpi->mb.partition_info->bmi[j].second_mv.as_mv, &best_second_mv, (const nmv_context*) nmvc, xd->allow_high_precision_mv); #else if (xd->allow_high_precision_mv) { - write_mv_hp(w, &cpi->mb.partition_info->bmi[j].second_mv.as_mv, - &best_second_mv, (const MV_CONTEXT_HP *) mvc_hp); + write_mv_hp( + bc, + &cpi->mb.partition_info->bmi[j].second_mv.as_mv, + &best_second_mv, (const MV_CONTEXT_HP *)mvc_hp); } else { - write_mv(w, &cpi->mb.partition_info->bmi[j].second_mv.as_mv, - &best_second_mv, (const MV_CONTEXT *) mvc); + write_mv( + bc, + &cpi->mb.partition_info->bmi[j].second_mv.as_mv, + &best_second_mv, (const MV_CONTEXT *) mvc); } #endif } @@ -1259,9 +1261,9 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { get_segdata(xd, segment_id, SEG_LVL_EOB) == 0))) { TX_SIZE sz = mi->txfm_size; // FIXME(rbultje) code ternary symbol once all experiments are merged - vp8_write(w, sz != TX_4X4, pc->prob_tx[0]); + vp8_write(bc, sz != TX_4X4, pc->prob_tx[0]); if (sz != TX_4X4 && mode != I8X8_PRED) - vp8_write(w, sz != TX_8X8, pc->prob_tx[1]); + vp8_write(bc, sz != TX_8X8, pc->prob_tx[1]); } #endif @@ -1269,7 +1271,7 @@ static void pack_inter_mode_mvs(VP8_COMP *const cpi) { active_section = 1; #endif assert(tok < tok_end); - pack_mb_tokens(w, &tok, tok_end); + pack_mb_tokens(bc, &tok, tok_end); #if CONFIG_SUPERBLOCKS if (m->mbmi.encoded_as_sb) { @@ -1406,8 +1408,7 @@ static void write_mb_modes_kf(const VP8_COMMON *c, #endif } -static void write_kfmodes(VP8_COMP *cpi) { - vp8_writer *const bc = &cpi->bc2; +static void write_kfmodes(VP8_COMP* const cpi, vp8_writer* const bc) { VP8_COMMON *const c = &cpi->common; const int mis = c->mode_info_stride; MACROBLOCKD *xd = &cpi->mb.e_mbd; @@ -1814,9 +1815,8 @@ static void update_coef_probs2(VP8_COMP *cpi) { } #endif -static void update_coef_probs(VP8_COMP *cpi) { +static void update_coef_probs(VP8_COMP* const cpi, vp8_writer* const bc) { int i, j, k, t; - vp8_writer *const w = &cpi->bc; int update[2] = {0, 0}; int savings; @@ -1869,10 +1869,10 @@ static void update_coef_probs(VP8_COMP *cpi) { // printf("Update %d %d, savings %d\n", update[0], update[1], savings); /* Is coef updated at all */ - if (update[1] == 0 || savings < 0) - vp8_write_bit(w, 0); - else { - vp8_write_bit(w, 1); + if (update[1] == 0 || savings < 0) { + vp8_write_bit(bc, 0); + } else { + vp8_write_bit(bc, 1); for (i = 0; i < BLOCK_TYPES; ++i) { for (j = !i; j < COEF_BANDS; ++j) { int prev_coef_savings[ENTROPY_NODES] = {0}; @@ -1900,14 +1900,14 @@ static void update_coef_probs(VP8_COMP *cpi) { if (s > 0) u = 1; #endif - vp8_write(w, u, upd); + vp8_write(bc, u, upd); #ifdef ENTROPY_STATS if (!cpi->dummy_packing) ++ tree_update_hist [i][j][k][t] [u]; #endif if (u) { /* send/use new probability */ - write_prob_diff_update(w, newp, *Pold); + write_prob_diff_update(bc, newp, *Pold); *Pold = newp; } } @@ -1959,10 +1959,10 @@ static void update_coef_probs(VP8_COMP *cpi) { // printf("Update %d %d, savings %d\n", update[0], update[1], savings); /* Is coef updated at all */ - if (update[1] == 0 || savings < 0) - vp8_write_bit(w, 0); - else { - vp8_write_bit(w, 1); + if (update[1] == 0 || savings < 0) { + vp8_write_bit(bc, 0); + } else { + vp8_write_bit(bc, 1); for (i = 0; i < BLOCK_TYPES; ++i) { for (j = !i; j < COEF_BANDS; ++j) { int prev_coef_savings[ENTROPY_NODES] = {0}; @@ -1990,14 +1990,14 @@ static void update_coef_probs(VP8_COMP *cpi) { if (s > 0) u = 1; #endif - vp8_write(w, u, upd); + vp8_write(bc, u, upd); #ifdef ENTROPY_STATS if (!cpi->dummy_packing) ++ hybrid_tree_update_hist [i][j][k][t] [u]; #endif if (u) { /* send/use new probability */ - write_prob_diff_update(w, newp, *Pold); + write_prob_diff_update(bc, newp, *Pold); *Pold = newp; } } @@ -2044,10 +2044,10 @@ static void update_coef_probs(VP8_COMP *cpi) { } } - if (update[1] == 0 || savings < 0) - vp8_write_bit(w, 0); - else { - vp8_write_bit(w, 1); + if (update[1] == 0 || savings < 0) { + vp8_write_bit(bc, 0); + } else { + vp8_write_bit(bc, 1); for (i = 0; i < BLOCK_TYPES_8X8; ++i) { for (j = !i; j < COEF_BANDS; ++j) { for (k = 0; k < PREV_COEF_CONTEXTS; ++k) { @@ -2068,14 +2068,14 @@ static void update_coef_probs(VP8_COMP *cpi) { s = prob_update_savings(ct, oldp, newp, upd); u = s > 0 ? 1 : 0; #endif - vp8_write(w, u, upd); + vp8_write(bc, u, upd); #ifdef ENTROPY_STATS if (!cpi->dummy_packing) ++ tree_update_hist_8x8 [i][j][k][t] [u]; #endif if (u) { /* send/use new probability */ - write_prob_diff_update(w, newp, oldp); + write_prob_diff_update(bc, newp, oldp); *Pold = newp; } } @@ -2118,10 +2118,10 @@ static void update_coef_probs(VP8_COMP *cpi) { } } - if (update[1] == 0 || savings < 0) - vp8_write_bit(w, 0); - else { - vp8_write_bit(w, 1); + if (update[1] == 0 || savings < 0) { + vp8_write_bit(bc, 0); + } else { + vp8_write_bit(bc, 1); for (i = 0; i < BLOCK_TYPES_8X8; ++i) { for (j = !i; j < COEF_BANDS; ++j) { for (k = 0; k < PREV_COEF_CONTEXTS; ++k) { @@ -2142,14 +2142,14 @@ static void update_coef_probs(VP8_COMP *cpi) { s = prob_update_savings(ct, oldp, newp, upd); u = s > 0 ? 1 : 0; #endif - vp8_write(w, u, upd); + vp8_write(bc, u, upd); #ifdef ENTROPY_STATS if (!cpi->dummy_packing) ++ hybrid_tree_update_hist_8x8 [i][j][k][t] [u]; #endif if (u) { /* send/use new probability */ - write_prob_diff_update(w, newp, oldp); + write_prob_diff_update(bc, newp, oldp); *Pold = newp; } } @@ -2196,10 +2196,10 @@ static void update_coef_probs(VP8_COMP *cpi) { } } - if (update[1] == 0 || savings < 0) - vp8_write_bit(w, 0); - else { - vp8_write_bit(w, 1); + if (update[1] == 0 || savings < 0) { + vp8_write_bit(bc, 0); + } else { + vp8_write_bit(bc, 1); for (i = 0; i < BLOCK_TYPES_16X16; ++i) { for (j = !i; j < COEF_BANDS; ++j) { for (k = 0; k < PREV_COEF_CONTEXTS; ++k) { @@ -2220,14 +2220,14 @@ static void update_coef_probs(VP8_COMP *cpi) { s = prob_update_savings(ct, oldp, newp, upd); u = s > 0 ? 1 : 0; #endif - vp8_write(w, u, upd); + vp8_write(bc, u, upd); #ifdef ENTROPY_STATS if (!cpi->dummy_packing) ++tree_update_hist_16x16[i][j][k][t][u]; #endif if (u) { /* send/use new probability */ - write_prob_diff_update(w, newp, oldp); + write_prob_diff_update(bc, newp, oldp); *Pold = newp; } } @@ -2270,10 +2270,10 @@ static void update_coef_probs(VP8_COMP *cpi) { } } - if (update[1] == 0 || savings < 0) - vp8_write_bit(w, 0); - else { - vp8_write_bit(w, 1); + if (update[1] == 0 || savings < 0) { + vp8_write_bit(bc, 0); + } else { + vp8_write_bit(bc, 1); for (i = 0; i < BLOCK_TYPES_16X16; ++i) { for (j = !i; j < COEF_BANDS; ++j) { for (k = 0; k < PREV_COEF_CONTEXTS; ++k) { @@ -2294,14 +2294,14 @@ static void update_coef_probs(VP8_COMP *cpi) { s = prob_update_savings(ct, oldp, newp, upd); u = s > 0 ? 1 : 0; #endif - vp8_write(w, u, upd); + vp8_write(bc, u, upd); #ifdef ENTROPY_STATS if (!cpi->dummy_packing) ++hybrid_tree_update_hist_16x16[i][j][k][t][u]; #endif if (u) { /* send/use new probability */ - write_prob_diff_update(w, newp, oldp); + write_prob_diff_update(bc, newp, oldp); *Pold = newp; } } @@ -2383,7 +2383,7 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) int i, j; VP8_HEADER oh; VP8_COMMON *const pc = &cpi->common; - vp8_writer *const bc = &cpi->bc; + vp8_writer header_bc, residual_bc; MACROBLOCKD *const xd = &cpi->mb.e_mbd; int extra_bytes_packed = 0; @@ -2427,22 +2427,23 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) extra_bytes_packed = 7; cx_data += extra_bytes_packed; - vp8_start_encode(bc, cx_data); + vp8_start_encode(&header_bc, cx_data); // signal clr type - vp8_write_bit(bc, pc->clr_type); - vp8_write_bit(bc, pc->clamp_type); + vp8_write_bit(&header_bc, pc->clr_type); + vp8_write_bit(&header_bc, pc->clamp_type); - } else - vp8_start_encode(bc, cx_data); + } else { + vp8_start_encode(&header_bc, cx_data); + } // Signal whether or not Segmentation is enabled - vp8_write_bit(bc, (xd->segmentation_enabled) ? 1 : 0); + vp8_write_bit(&header_bc, (xd->segmentation_enabled) ? 1 : 0); // Indicate which features are enabled if (xd->segmentation_enabled) { // Indicate whether or not the segmentation map is being updated. - vp8_write_bit(bc, (xd->update_mb_segmentation_map) ? 1 : 0); + vp8_write_bit(&header_bc, (xd->update_mb_segmentation_map) ? 1 : 0); // If it is, then indicate the method that will be used. if (xd->update_mb_segmentation_map) { @@ -2454,37 +2455,37 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) int data = xd->mb_segment_tree_probs[i]; if (data != 255) { - vp8_write_bit(bc, 1); - vp8_write_literal(bc, data, 8); + vp8_write_bit(&header_bc, 1); + vp8_write_literal(&header_bc, data, 8); } else { - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 0); } } // Write out the chosen coding method. - vp8_write_bit(bc, (pc->temporal_update) ? 1 : 0); + vp8_write_bit(&header_bc, (pc->temporal_update) ? 1 : 0); if (pc->temporal_update) { for (i = 0; i < PREDICTION_PROBS; i++) { int data = pc->segment_pred_probs[i]; if (data != 255) { - vp8_write_bit(bc, 1); - vp8_write_literal(bc, data, 8); + vp8_write_bit(&header_bc, 1); + vp8_write_literal(&header_bc, data, 8); } else { - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 0); } } } } - vp8_write_bit(bc, (xd->update_mb_segmentation_data) ? 1 : 0); + vp8_write_bit(&header_bc, (xd->update_mb_segmentation_data) ? 1 : 0); // segment_reference_frames(cpi); if (xd->update_mb_segmentation_data) { signed char Data; - vp8_write_bit(bc, (xd->mb_segment_abs_delta) ? 1 : 0); + vp8_write_bit(&header_bc, (xd->mb_segment_abs_delta) ? 1 : 0); // For each segments id... for (i = 0; i < MAX_MB_SEGMENTS; i++) { @@ -2497,67 +2498,67 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) // check if there's an update if (segfeature_changed(xd, i, j)) { - vp8_write_bit(bc, 1); + vp8_write_bit(&header_bc, 1); if (segfeature_active(xd, i, j)) { // this bit is to say we are still // active/ if we were inactive // this is unnecessary if (old_segfeature_active(xd, i, j)) { - vp8_write_bit(bc, 1); + vp8_write_bit(&header_bc, 1); } // Is the segment data signed.. if (is_segfeature_signed(j)) { // Encode the relevant feature data if (Data < 0) { Data = - Data; - vp8_write_literal(bc, Data, + vp8_write_literal(&header_bc, Data, seg_feature_data_bits(j)); - vp8_write_bit(bc, 1); + vp8_write_bit(&header_bc, 1); } else { - vp8_write_literal(bc, Data, + vp8_write_literal(&header_bc, Data, seg_feature_data_bits(j)); - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 0); } } // Unsigned data element so no sign bit needed else - vp8_write_literal(bc, Data, + vp8_write_literal(&header_bc, Data, seg_feature_data_bits(j)); } // feature is inactive now else if (old_segfeature_active(xd, i, j)) { - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 0); } } else { - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 0); } #else // If the feature is enabled... if (segfeature_active(xd, i, j)) { - vp8_write_bit(bc, 1); + vp8_write_bit(&header_bc, 1); // Is the segment data signed.. if (is_segfeature_signed(j)) { // Encode the relevant feature data if (Data < 0) { Data = - Data; - vp8_write_literal(bc, Data, + vp8_write_literal(&header_bc, Data, seg_feature_data_bits(j)); - vp8_write_bit(bc, 1); + vp8_write_bit(&header_bc, 1); } else { - vp8_write_literal(bc, Data, + vp8_write_literal(&header_bc, Data, seg_feature_data_bits(j)); - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 0); } } // Unsigned data element so no sign bit needed else - vp8_write_literal(bc, Data, + vp8_write_literal(&header_bc, Data, seg_feature_data_bits(j)); } else - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 0); #endif } } @@ -2576,10 +2577,11 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) if (pc->frame_type != KEY_FRAME) { for (i = 0; i < PREDICTION_PROBS; i++) { if (cpi->ref_pred_probs_update[i]) { - vp8_write_bit(bc, 1); - vp8_write_literal(bc, pc->ref_pred_probs[i], 8); - } else - vp8_write_bit(bc, 0); + vp8_write_bit(&header_bc, 1); + vp8_write_literal(&header_bc, pc->ref_pred_probs[i], 8); + } else { + vp8_write_bit(&header_bc, 0); + } } } @@ -2592,7 +2594,7 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) else if (sb_coded >= 256) sb_coded = 255; pc->sb_coded = sb_coded; - vp8_write_literal(bc, pc->sb_coded, 8); + vp8_write_literal(&header_bc, pc->sb_coded, 8); } #endif @@ -2607,29 +2609,29 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) pc->prob_tx[0] = 128; pc->prob_tx[1] = 128; } - vp8_write_literal(bc, pc->txfm_mode, 2); + vp8_write_literal(&header_bc, pc->txfm_mode, 2); if (pc->txfm_mode == TX_MODE_SELECT) { - vp8_write_literal(bc, pc->prob_tx[0], 8); - vp8_write_literal(bc, pc->prob_tx[1], 8); + vp8_write_literal(&header_bc, pc->prob_tx[0], 8); + vp8_write_literal(&header_bc, pc->prob_tx[1], 8); } } #else - vp8_write_bit(bc, !!pc->txfm_mode); + vp8_write_bit(&header_bc, !!pc->txfm_mode); #endif // Encode the loop filter level and type - vp8_write_bit(bc, pc->filter_type); - vp8_write_literal(bc, pc->filter_level, 6); - vp8_write_literal(bc, pc->sharpness_level, 3); + vp8_write_bit(&header_bc, pc->filter_type); + vp8_write_literal(&header_bc, pc->filter_level, 6); + vp8_write_literal(&header_bc, pc->sharpness_level, 3); // Write out loop filter deltas applied at the MB level based on mode or ref frame (if they are enabled). - vp8_write_bit(bc, (xd->mode_ref_lf_delta_enabled) ? 1 : 0); + vp8_write_bit(&header_bc, (xd->mode_ref_lf_delta_enabled) ? 1 : 0); if (xd->mode_ref_lf_delta_enabled) { // Do the deltas need to be updated int send_update = xd->mode_ref_lf_delta_update; - vp8_write_bit(bc, send_update); + vp8_write_bit(&header_bc, send_update); if (send_update) { int Data; @@ -2640,18 +2642,19 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) // Frame level data if (xd->ref_lf_deltas[i] != xd->last_ref_lf_deltas[i]) { xd->last_ref_lf_deltas[i] = xd->ref_lf_deltas[i]; - vp8_write_bit(bc, 1); + vp8_write_bit(&header_bc, 1); if (Data > 0) { - vp8_write_literal(bc, (Data & 0x3F), 6); - vp8_write_bit(bc, 0); // sign + vp8_write_literal(&header_bc, (Data & 0x3F), 6); + vp8_write_bit(&header_bc, 0); // sign } else { Data = -Data; - vp8_write_literal(bc, (Data & 0x3F), 6); - vp8_write_bit(bc, 1); // sign + vp8_write_literal(&header_bc, (Data & 0x3F), 6); + vp8_write_bit(&header_bc, 1); // sign } - } else - vp8_write_bit(bc, 0); + } else { + vp8_write_bit(&header_bc, 0); + } } // Send update @@ -2660,41 +2663,42 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) if (xd->mode_lf_deltas[i] != xd->last_mode_lf_deltas[i]) { xd->last_mode_lf_deltas[i] = xd->mode_lf_deltas[i]; - vp8_write_bit(bc, 1); + vp8_write_bit(&header_bc, 1); if (Data > 0) { - vp8_write_literal(bc, (Data & 0x3F), 6); - vp8_write_bit(bc, 0); // sign + vp8_write_literal(&header_bc, (Data & 0x3F), 6); + vp8_write_bit(&header_bc, 0); // sign } else { Data = -Data; - vp8_write_literal(bc, (Data & 0x3F), 6); - vp8_write_bit(bc, 1); // sign + vp8_write_literal(&header_bc, (Data & 0x3F), 6); + vp8_write_bit(&header_bc, 1); // sign } - } else - vp8_write_bit(bc, 0); + } else { + vp8_write_bit(&header_bc, 0); + } } } } // signal here is multi token partition is enabled - // vp8_write_literal(bc, pc->multi_token_partition, 2); - vp8_write_literal(bc, 0, 2); + // vp8_write_literal(&header_bc, pc->multi_token_partition, 2); + vp8_write_literal(&header_bc, 0, 2); // Frame Q baseline quantizer index - vp8_write_literal(bc, pc->base_qindex, QINDEX_BITS); + vp8_write_literal(&header_bc, pc->base_qindex, QINDEX_BITS); // Transmit Dc, Second order and Uv quantizer delta information - put_delta_q(bc, pc->y1dc_delta_q); - put_delta_q(bc, pc->y2dc_delta_q); - put_delta_q(bc, pc->y2ac_delta_q); - put_delta_q(bc, pc->uvdc_delta_q); - put_delta_q(bc, pc->uvac_delta_q); + put_delta_q(&header_bc, pc->y1dc_delta_q); + put_delta_q(&header_bc, pc->y2dc_delta_q); + put_delta_q(&header_bc, pc->y2ac_delta_q); + put_delta_q(&header_bc, pc->uvdc_delta_q); + put_delta_q(&header_bc, pc->uvac_delta_q); // When there is a key frame all reference buffers are updated using the new key frame if (pc->frame_type != KEY_FRAME) { // Should the GF or ARF be updated using the transmitted frame or buffer - vp8_write_bit(bc, pc->refresh_golden_frame); - vp8_write_bit(bc, pc->refresh_alt_ref_frame); + vp8_write_bit(&header_bc, pc->refresh_golden_frame); + vp8_write_bit(&header_bc, pc->refresh_alt_ref_frame); // For inter frames the current default behavior is that when // cm->refresh_golden_frame is set we copy the old GF over to @@ -2704,17 +2708,17 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) // If not being updated from current frame should either GF or ARF be updated from another buffer if (!pc->refresh_golden_frame) - vp8_write_literal(bc, pc->copy_buffer_to_gf, 2); + vp8_write_literal(&header_bc, pc->copy_buffer_to_gf, 2); if (!pc->refresh_alt_ref_frame) - vp8_write_literal(bc, pc->copy_buffer_to_arf, 2); + vp8_write_literal(&header_bc, pc->copy_buffer_to_arf, 2); // Indicate reference frame sign bias for Golden and ARF frames (always 0 for last frame buffer) - vp8_write_bit(bc, pc->ref_frame_sign_bias[GOLDEN_FRAME]); - vp8_write_bit(bc, pc->ref_frame_sign_bias[ALTREF_FRAME]); + vp8_write_bit(&header_bc, pc->ref_frame_sign_bias[GOLDEN_FRAME]); + vp8_write_bit(&header_bc, pc->ref_frame_sign_bias[ALTREF_FRAME]); // Signal whether to allow high MV precision - vp8_write_bit(bc, (xd->allow_high_precision_mv) ? 1 : 0); + vp8_write_bit(&header_bc, (xd->allow_high_precision_mv) ? 1 : 0); #if CONFIG_SWITCHABLE_INTERP if (pc->mcomp_filter_type == SWITCHABLE) { /* Check to see if only one of the filters is actually used */ @@ -2738,16 +2742,16 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) } } // Signal the type of subpel filter to use - vp8_write_bit(bc, (pc->mcomp_filter_type == SWITCHABLE)); + vp8_write_bit(&header_bc, (pc->mcomp_filter_type == SWITCHABLE)); if (pc->mcomp_filter_type != SWITCHABLE) #endif /* CONFIG_SWITCHABLE_INTERP */ - vp8_write_literal(bc, (pc->mcomp_filter_type), 2); + vp8_write_literal(&header_bc, (pc->mcomp_filter_type), 2); } - vp8_write_bit(bc, pc->refresh_entropy_probs); + vp8_write_bit(&header_bc, pc->refresh_entropy_probs); if (pc->frame_type != KEY_FRAME) - vp8_write_bit(bc, pc->refresh_last_frame); + vp8_write_bit(&header_bc, pc->refresh_last_frame); #ifdef ENTROPY_STATS if (pc->frame_type == INTER_FRAME) @@ -2787,25 +2791,25 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) vp8_zero(cpi->common.fc.mv_ref_ct) vp8_zero(cpi->common.fc.mv_ref_ct_a) - update_coef_probs(cpi); + update_coef_probs(cpi, &header_bc); #ifdef ENTROPY_STATS active_section = 2; #endif // Write out the mb_no_coeff_skip flag - vp8_write_bit(bc, pc->mb_no_coeff_skip); + vp8_write_bit(&header_bc, pc->mb_no_coeff_skip); if (pc->mb_no_coeff_skip) { int k; update_skip_probs(cpi); for (k = 0; k < MBSKIP_CONTEXTS; ++k) - vp8_write_literal(bc, pc->mbskip_pred_probs[k], 8); + vp8_write_literal(&header_bc, pc->mbskip_pred_probs[k], 8); } if (pc->frame_type == KEY_FRAME) { if (!pc->kf_ymode_probs_update) { - vp8_write_literal(bc, pc->kf_ymode_probs_index, 3); + vp8_write_literal(&header_bc, pc->kf_ymode_probs_index, 3); } } else { // Update the probabilities used to encode reference frame data @@ -2817,30 +2821,30 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) #if CONFIG_PRED_FILTER // Write the prediction filter mode used for this frame - vp8_write_literal(bc, pc->pred_filter_mode, 2); + vp8_write_literal(&header_bc, pc->pred_filter_mode, 2); // Write prediction filter on/off probability if signaling at MB level if (pc->pred_filter_mode == 2) - vp8_write_literal(bc, pc->prob_pred_filter_off, 8); + vp8_write_literal(&header_bc, pc->prob_pred_filter_off, 8); #endif #if CONFIG_SWITCHABLE_INTERP if (pc->mcomp_filter_type == SWITCHABLE) - update_switchable_interp_probs(cpi); + update_switchable_interp_probs(cpi, &header_bc); #endif - vp8_write_literal(bc, pc->prob_intra_coded, 8); - vp8_write_literal(bc, pc->prob_last_coded, 8); - vp8_write_literal(bc, pc->prob_gf_coded, 8); + vp8_write_literal(&header_bc, pc->prob_intra_coded, 8); + vp8_write_literal(&header_bc, pc->prob_last_coded, 8); + vp8_write_literal(&header_bc, pc->prob_gf_coded, 8); { const int comp_pred_mode = cpi->common.comp_pred_mode; const int use_compound_pred = (comp_pred_mode != SINGLE_PREDICTION_ONLY); const int use_hybrid_pred = (comp_pred_mode == HYBRID_PREDICTION); - vp8_write(bc, use_compound_pred, 128); + vp8_write(&header_bc, use_compound_pred, 128); if (use_compound_pred) { - vp8_write(bc, use_hybrid_pred, 128); + vp8_write(&header_bc, use_hybrid_pred, 128); if (use_hybrid_pred) { for (i = 0; i < COMP_PRED_CONTEXTS; i++) { if (cpi->single_pred_count[i] + cpi->comp_pred_count[i]) { @@ -2852,28 +2856,28 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) } else { pc->prob_comppred[i] = 128; } - vp8_write_literal(bc, pc->prob_comppred[i], 8); + vp8_write_literal(&header_bc, pc->prob_comppred[i], 8); } } } } - update_mbintra_mode_probs(cpi); + update_mbintra_mode_probs(cpi, &header_bc); #if CONFIG_NEWMVENTROPY - vp8_write_nmvprobs(cpi, xd->allow_high_precision_mv); + vp8_write_nmvprobs(cpi, xd->allow_high_precision_mv, &header_bc); #else if (xd->allow_high_precision_mv) { - vp8_write_mvprobs_hp(cpi); + vp8_write_mvprobs_hp(cpi, &header_bc); } else { - vp8_write_mvprobs(cpi); + vp8_write_mvprobs(cpi, &header_bc); } #endif } - vp8_stop_encode(bc); + vp8_stop_encode(&header_bc); - oh.first_partition_length_in_bytes = cpi->bc.pos; + oh.first_partition_length_in_bytes = header_bc.pos; /* update frame tag */ { @@ -2887,21 +2891,21 @@ void vp8_pack_bitstream(VP8_COMP *cpi, unsigned char *dest, unsigned long *size) dest[2] = v >> 16; } - *size = VP8_HEADER_SIZE + extra_bytes_packed + cpi->bc.pos; - vp8_start_encode(&cpi->bc2, cx_data + bc->pos); + *size = VP8_HEADER_SIZE + extra_bytes_packed + header_bc.pos; + vp8_start_encode(&residual_bc, cx_data + header_bc.pos); if (pc->frame_type == KEY_FRAME) { decide_kf_ymode_entropy(cpi); - write_kfmodes(cpi); + write_kfmodes(cpi, &residual_bc); } else { - pack_inter_mode_mvs(cpi); + pack_inter_mode_mvs(cpi, &residual_bc); vp8_update_mode_context(&cpi->common); } - vp8_stop_encode(&cpi->bc2); + vp8_stop_encode(&residual_bc); - *size += cpi->bc2.pos; + *size += residual_bc.pos; } diff --git a/vp8/encoder/encodemv.c b/vp8/encoder/encodemv.c index 4f7e9f1de..d520d995a 100644 --- a/vp8/encoder/encodemv.c +++ b/vp8/encoder/encodemv.c @@ -28,38 +28,38 @@ extern unsigned int active_section; nmv_context_counts tnmvcounts; #endif -static void encode_nmv_component(vp8_writer *w, +static void encode_nmv_component(vp8_writer* const bc, int v, int r, - const nmv_component *mvcomp) { + const nmv_component* const mvcomp) { int s, z, c, o, d; assert (v != 0); /* should not be zero */ s = v < 0; - vp8_write(w, s, mvcomp->sign); + vp8_write(bc, s, mvcomp->sign); z = (s ? -v : v) - 1; /* magnitude - 1 */ c = vp8_get_mv_class(z, &o); - vp8_write_token(w, vp8_mv_class_tree, mvcomp->classes, + vp8_write_token(bc, vp8_mv_class_tree, mvcomp->classes, vp8_mv_class_encodings + c); d = (o >> 3); /* int mv data */ if (c == MV_CLASS_0) { - vp8_write_token(w, vp8_mv_class0_tree, mvcomp->class0, + vp8_write_token(bc, vp8_mv_class0_tree, mvcomp->class0, vp8_mv_class0_encodings + d); } else { int i, b; b = c + CLASS0_BITS - 1; /* number of bits */ for (i = 0; i < b; ++i) - vp8_write(w, ((d >> i) & 1), mvcomp->bits[i]); + vp8_write(bc, ((d >> i) & 1), mvcomp->bits[i]); } } -static void encode_nmv_component_fp(vp8_writer *w, +static void encode_nmv_component_fp(vp8_writer *bc, int v, int r, - const nmv_component *mvcomp, + const nmv_component* const mvcomp, int usehp) { int s, z, c, o, d, f, e; assert (v != 0); /* should not be zero */ @@ -74,24 +74,24 @@ static void encode_nmv_component_fp(vp8_writer *w, /* Code the fractional pel bits */ if (c == MV_CLASS_0) { - vp8_write_token(w, vp8_mv_fp_tree, mvcomp->class0_fp[d], + vp8_write_token(bc, vp8_mv_fp_tree, mvcomp->class0_fp[d], vp8_mv_fp_encodings + f); } else { - vp8_write_token(w, vp8_mv_fp_tree, mvcomp->fp, + vp8_write_token(bc, vp8_mv_fp_tree, mvcomp->fp, vp8_mv_fp_encodings + f); } /* Code the high precision bit */ if (usehp) { if (c == MV_CLASS_0) { - vp8_write(w, e, mvcomp->class0_hp); + vp8_write(bc, e, mvcomp->class0_hp); } else { - vp8_write(w, e, mvcomp->hp); + vp8_write(bc, e, mvcomp->hp); } } } static void build_nmv_component_cost_table(int *mvcost, - const nmv_component *mvcomp, + const nmv_component* const mvcomp, int usehp) { int i, v; int sign_cost[2], class_cost[MV_CLASSES], class0_cost[CLASS0_SIZE]; @@ -177,7 +177,7 @@ static int update_nmv_savings(const unsigned int ct[2], } static int update_nmv( - vp8_writer *const w, + vp8_writer *const bc, const unsigned int ct[2], vp8_prob *const cur_p, const vp8_prob new_p, @@ -199,15 +199,15 @@ static int update_nmv( if (cur_b - mod_b > cost) { *cur_p = mod_p; - vp8_write(w, 1, upd_p); + vp8_write(bc, 1, upd_p); #ifdef LOW_PRECISION_MV_UPDATE - vp8_write_literal(w, mod_p >> 1, 7); + vp8_write_literal(bc, mod_p >> 1, 7); #else - vp8_write_literal(w, mod_p, 8); + vp8_write_literal(bc, mod_p, 8); #endif return 1; } else { - vp8_write(w, 0, upd_p); + vp8_write(bc, 0, upd_p); return 0; } } @@ -318,7 +318,8 @@ void print_nmvstats() { } } -static void add_nmvcount(nmv_context_counts *dst, nmv_context_counts *src) { +static void add_nmvcount(nmv_context_counts* const dst, + const nmv_context_counts* const src) { int i, j, k; for (j = 0; j < MV_JOINTS; ++j) { dst->joints[j] += src->joints[j]; @@ -357,8 +358,7 @@ static void add_nmvcount(nmv_context_counts *dst, nmv_context_counts *src) { } #endif -void vp8_write_nmvprobs(VP8_COMP * cpi, int usehp) { - vp8_writer *const w = &cpi->bc; +void vp8_write_nmvprobs(VP8_COMP* const cpi, int usehp, vp8_writer* const bc) { int i, j; nmv_context prob; unsigned int branch_ct_joint[MV_JOINTS - 1][2]; @@ -443,37 +443,37 @@ void vp8_write_nmvprobs(VP8_COMP * cpi, int usehp) { } } if (savings <= 0) { - vp8_write_bit(w, 0); + vp8_write_bit(bc, 0); return; } - vp8_write_bit(w, 1); + vp8_write_bit(bc, 1); #endif for (j = 0; j < MV_JOINTS - 1; ++j) { - update_nmv(w, branch_ct_joint[j], + update_nmv(bc, branch_ct_joint[j], &cpi->common.fc.nmvc.joints[j], prob.joints[j], VP8_NMV_UPDATE_PROB); } for (i = 0; i < 2; ++i) { - update_nmv(w, branch_ct_sign[i], + update_nmv(bc, branch_ct_sign[i], &cpi->common.fc.nmvc.comps[i].sign, prob.comps[i].sign, VP8_NMV_UPDATE_PROB); for (j = 0; j < MV_CLASSES - 1; ++j) { - update_nmv(w, branch_ct_classes[i][j], + update_nmv(bc, branch_ct_classes[i][j], &cpi->common.fc.nmvc.comps[i].classes[j], prob.comps[i].classes[j], VP8_NMV_UPDATE_PROB); } for (j = 0; j < CLASS0_SIZE - 1; ++j) { - update_nmv(w, branch_ct_class0[i][j], + update_nmv(bc, branch_ct_class0[i][j], &cpi->common.fc.nmvc.comps[i].class0[j], prob.comps[i].class0[j], VP8_NMV_UPDATE_PROB); } for (j = 0; j < MV_OFFSET_BITS; ++j) { - update_nmv(w, branch_ct_bits[i][j], + update_nmv(bc, branch_ct_bits[i][j], &cpi->common.fc.nmvc.comps[i].bits[j], prob.comps[i].bits[j], VP8_NMV_UPDATE_PROB); @@ -483,14 +483,14 @@ void vp8_write_nmvprobs(VP8_COMP * cpi, int usehp) { for (j = 0; j < CLASS0_SIZE; ++j) { int k; for (k = 0; k < 3; ++k) { - update_nmv(w, branch_ct_class0_fp[i][j][k], + update_nmv(bc, branch_ct_class0_fp[i][j][k], &cpi->common.fc.nmvc.comps[i].class0_fp[j][k], prob.comps[i].class0_fp[j][k], VP8_NMV_UPDATE_PROB); } } for (j = 0; j < 3; ++j) { - update_nmv(w, branch_ct_fp[i][j], + update_nmv(bc, branch_ct_fp[i][j], &cpi->common.fc.nmvc.comps[i].fp[j], prob.comps[i].fp[j], VP8_NMV_UPDATE_PROB); @@ -498,11 +498,11 @@ void vp8_write_nmvprobs(VP8_COMP * cpi, int usehp) { } if (usehp) { for (i = 0; i < 2; ++i) { - update_nmv(w, branch_ct_class0_hp[i], + update_nmv(bc, branch_ct_class0_hp[i], &cpi->common.fc.nmvc.comps[i].class0_hp, prob.comps[i].class0_hp, VP8_NMV_UPDATE_PROB); - update_nmv(w, branch_ct_hp[i], + update_nmv(bc, branch_ct_hp[i], &cpi->common.fc.nmvc.comps[i].hp, prob.comps[i].hp, VP8_NMV_UPDATE_PROB); @@ -510,34 +510,35 @@ void vp8_write_nmvprobs(VP8_COMP * cpi, int usehp) { } } -void vp8_encode_nmv(vp8_writer *w, const MV *mv, const MV *ref, - const nmv_context *mvctx) { +void vp8_encode_nmv(vp8_writer* const bc, const MV* const mv, + const MV* const ref, const nmv_context* const mvctx) { MV_JOINT_TYPE j = vp8_get_mv_joint(*mv); - vp8_write_token(w, vp8_mv_joint_tree, mvctx->joints, + vp8_write_token(bc, vp8_mv_joint_tree, mvctx->joints, vp8_mv_joint_encodings + j); if (j == MV_JOINT_HZVNZ || j == MV_JOINT_HNZVNZ) { - encode_nmv_component(w, mv->row, ref->col, &mvctx->comps[0]); + encode_nmv_component(bc, mv->row, ref->col, &mvctx->comps[0]); } if (j == MV_JOINT_HNZVZ || j == MV_JOINT_HNZVNZ) { - encode_nmv_component(w, mv->col, ref->col, &mvctx->comps[1]); + encode_nmv_component(bc, mv->col, ref->col, &mvctx->comps[1]); } } -void vp8_encode_nmv_fp(vp8_writer *w, const MV *mv, const MV *ref, - const nmv_context *mvctx, int usehp) { +void vp8_encode_nmv_fp(vp8_writer* const bc, const MV* const mv, + const MV* const ref, const nmv_context* const mvctx, + int usehp) { MV_JOINT_TYPE j = vp8_get_mv_joint(*mv); usehp = usehp && vp8_use_nmv_hp(ref); if (j == MV_JOINT_HZVNZ || j == MV_JOINT_HNZVNZ) { - encode_nmv_component_fp(w, mv->row, ref->row, &mvctx->comps[0], usehp); + encode_nmv_component_fp(bc, mv->row, ref->row, &mvctx->comps[0], usehp); } if (j == MV_JOINT_HNZVZ || j == MV_JOINT_HNZVNZ) { - encode_nmv_component_fp(w, mv->col, ref->col, &mvctx->comps[1], usehp); + encode_nmv_component_fp(bc, mv->col, ref->col, &mvctx->comps[1], usehp); } } void vp8_build_nmv_cost_table(int *mvjoint, int *mvcost[2], - const nmv_context *mvctx, + const nmv_context* const mvctx, int usehp, int mvc_flag_v, int mvc_flag_h) { @@ -552,7 +553,7 @@ void vp8_build_nmv_cost_table(int *mvjoint, #else /* CONFIG_NEWMVENTROPY */ static void encode_mvcomponent( - vp8_writer *const w, + vp8_writer *const bc, const int v, const struct mv_context *mvc ) { @@ -560,41 +561,44 @@ static void encode_mvcomponent( const int x = v < 0 ? -v : v; if (x < mvnum_short) { // Small - vp8_write(w, 0, p [mvpis_short]); - vp8_treed_write(w, vp8_small_mvtree, p + MVPshort, x, mvnum_short_bits); + vp8_write(bc, 0, p[mvpis_short]); + vp8_treed_write(bc, vp8_small_mvtree, p + MVPshort, x, mvnum_short_bits); if (!x) return; // no sign bit } else { // Large int i = 0; - vp8_write(w, 1, p [mvpis_short]); + vp8_write(bc, 1, p[mvpis_short]); do - vp8_write(w, (x >> i) & 1, p [MVPbits + i]); + vp8_write(bc, (x >> i) & 1, p[MVPbits + i]); while (++i < mvnum_short_bits); i = mvlong_width - 1; /* Skip bit 3, which is sometimes implicit */ do - vp8_write(w, (x >> i) & 1, p [MVPbits + i]); + vp8_write(bc, (x >> i) & 1, p[MVPbits + i]); while (--i > mvnum_short_bits); if (x & ~((2 << mvnum_short_bits) - 1)) - vp8_write(w, (x >> mvnum_short_bits) & 1, p [MVPbits + mvnum_short_bits]); + vp8_write(bc, (x >> mvnum_short_bits) & 1, p[MVPbits + mvnum_short_bits]); } - vp8_write(w, v < 0, p [MVPsign]); + vp8_write(bc, v < 0, p[MVPsign]); } -void vp8_encode_motion_vector(vp8_writer *w, const MV *mv, const MV_CONTEXT *mvc) { - encode_mvcomponent(w, mv->row >> 1, &mvc[0]); - encode_mvcomponent(w, mv->col >> 1, &mvc[1]); +void vp8_encode_motion_vector(vp8_writer* const bc, + const MV* const mv, + const MV_CONTEXT* const mvc) { + encode_mvcomponent(bc, mv->row >> 1, &mvc[0]); + encode_mvcomponent(bc, mv->col >> 1, &mvc[1]); } -static unsigned int cost_mvcomponent(const int v, const struct mv_context *mvc) { +static unsigned int cost_mvcomponent(const int v, + const struct mv_context* const mvc) { const vp8_prob *p = mvc->prob; const int x = v; // v<0? -v:v; unsigned int cost; @@ -628,7 +632,8 @@ static unsigned int cost_mvcomponent(const int v, const struct mv_context *mvc) return cost; // + vp8_cost_bit( p [MVPsign], v < 0); } -void vp8_build_component_cost_table(int *mvcost[2], const MV_CONTEXT *mvc, int mvc_flag[2]) { +void vp8_build_component_cost_table(int *mvcost[2], const MV_CONTEXT *mvc, + const int mvc_flag[2]) { int i = 1; // -mv_max; unsigned int cost0 = 0; unsigned int cost1 = 0; @@ -682,7 +687,7 @@ __inline static void calc_prob(vp8_prob *p, const unsigned int ct[2]) { } static void update( - vp8_writer *const w, + vp8_writer *const bc, const unsigned int ct[2], vp8_prob *const cur_p, const vp8_prob new_p, @@ -695,16 +700,16 @@ static void update( if (cur_b - new_b > cost) { *cur_p = new_p; - vp8_write(w, 1, update_p); - vp8_write_literal(w, new_p >> 1, 7); + vp8_write(bc, 1, update_p); + vp8_write_literal(bc, new_p >> 1, 7); *updated = 1; } else - vp8_write(w, 0, update_p); + vp8_write(bc, 0, update_p); } static void write_component_probs( - vp8_writer *const w, + vp8_writer *const bc, struct mv_context *cur_mvc, const struct mv_context *default_mvc_, const struct mv_context *update_mvc, @@ -800,9 +805,11 @@ static void write_component_probs( while (++j < mvlong_width); } - update(w, is_short_ct, Pcur + mvpis_short, Pnew[mvpis_short], *Pupdate++, updated); + update(bc, is_short_ct, Pcur + mvpis_short, Pnew[mvpis_short], + *Pupdate++, updated); - update(w, sign_ct, Pcur + MVPsign, Pnew[MVPsign], *Pupdate++, updated); + update(bc, sign_ct, Pcur + MVPsign, Pnew[MVPsign], + *Pupdate++, updated); { const vp8_prob *const new_p = Pnew + MVPshort; @@ -812,7 +819,7 @@ static void write_component_probs( do - update(w, short_bct[j], cur_p + j, new_p[j], *Pupdate++, updated); + update(bc, short_bct[j], cur_p + j, new_p[j], *Pupdate++, updated); while (++j < mvnum_short - 1); } @@ -825,25 +832,25 @@ static void write_component_probs( do - update(w, bit_ct[j], cur_p + j, new_p[j], *Pupdate++, updated); + update(bc, bit_ct[j], cur_p + j, new_p[j], *Pupdate++, updated); while (++j < mvlong_width); } } -void vp8_write_mvprobs(VP8_COMP *cpi) { - vp8_writer *const w = &cpi->bc; +void vp8_write_mvprobs(VP8_COMP* const cpi, vp8_writer* const bc) { MV_CONTEXT *mvc = cpi->common.fc.mvc; int flags[2] = {0, 0}; #ifdef ENTROPY_STATS active_section = 4; #endif write_component_probs( - w, &mvc[0], &vp8_default_mv_context[0], &vp8_mv_update_probs[0], cpi->MVcount[0], 0, &flags[0] - ); + bc, &mvc[0], &vp8_default_mv_context[0], &vp8_mv_update_probs[0], + cpi->MVcount[0], 0, &flags[0]); + write_component_probs( - w, &mvc[1], &vp8_default_mv_context[1], &vp8_mv_update_probs[1], cpi->MVcount[1], 1, &flags[1] - ); + bc, &mvc[1], &vp8_default_mv_context[1], &vp8_mv_update_probs[1], + cpi->MVcount[1], 1, &flags[1]); if (flags[0] || flags[1]) vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flags); @@ -855,7 +862,7 @@ void vp8_write_mvprobs(VP8_COMP *cpi) { static void encode_mvcomponent_hp( - vp8_writer *const w, + vp8_writer *const bc, const int v, const struct mv_context_hp *mvc ) { @@ -863,41 +870,41 @@ static void encode_mvcomponent_hp( const int x = v < 0 ? -v : v; if (x < mvnum_short_hp) { // Small - vp8_write(w, 0, p [mvpis_short_hp]); - vp8_treed_write(w, vp8_small_mvtree_hp, p + MVPshort_hp, x, + vp8_write(bc, 0, p[mvpis_short_hp]); + vp8_treed_write(bc, vp8_small_mvtree_hp, p + MVPshort_hp, x, mvnum_short_bits_hp); if (!x) return; // no sign bit } else { // Large int i = 0; - vp8_write(w, 1, p [mvpis_short_hp]); + vp8_write(bc, 1, p[mvpis_short_hp]); do - vp8_write(w, (x >> i) & 1, p [MVPbits_hp + i]); + vp8_write(bc, (x >> i) & 1, p[MVPbits_hp + i]); while (++i < mvnum_short_bits_hp); i = mvlong_width_hp - 1; /* Skip bit 3, which is sometimes implicit */ do - vp8_write(w, (x >> i) & 1, p [MVPbits_hp + i]); + vp8_write(bc, (x >> i) & 1, p[MVPbits_hp + i]); while (--i > mvnum_short_bits_hp); if (x & ~((2 << mvnum_short_bits_hp) - 1)) - vp8_write(w, (x >> mvnum_short_bits_hp) & 1, - p [MVPbits_hp + mvnum_short_bits_hp]); + vp8_write(bc, (x >> mvnum_short_bits_hp) & 1, + p[MVPbits_hp + mvnum_short_bits_hp]); } - vp8_write(w, v < 0, p [MVPsign_hp]); + vp8_write(bc, v < 0, p[MVPsign_hp]); } -void vp8_encode_motion_vector_hp(vp8_writer *w, const MV *mv, +void vp8_encode_motion_vector_hp(vp8_writer *bc, const MV *mv, const MV_CONTEXT_HP *mvc) { - encode_mvcomponent_hp(w, mv->row, &mvc[0]); - encode_mvcomponent_hp(w, mv->col, &mvc[1]); + encode_mvcomponent_hp(bc, mv->row, &mvc[0]); + encode_mvcomponent_hp(bc, mv->col, &mvc[1]); } @@ -940,7 +947,7 @@ static unsigned int cost_mvcomponent_hp(const int v, void vp8_build_component_cost_table_hp(int *mvcost[2], const MV_CONTEXT_HP *mvc, - int mvc_flag[2]) { + const int mvc_flag[2]) { int i = 1; // -mv_max; unsigned int cost0 = 0; unsigned int cost1 = 0; @@ -978,7 +985,7 @@ void vp8_build_component_cost_table_hp(int *mvcost[2], static void write_component_probs_hp( - vp8_writer *const w, + vp8_writer *const bc, struct mv_context_hp *cur_mvc, const struct mv_context_hp *default_mvc_, const struct mv_context_hp *update_mvc, @@ -1074,10 +1081,10 @@ static void write_component_probs_hp( while (++j < mvlong_width_hp); } - update(w, is_short_ct, Pcur + mvpis_short_hp, Pnew[mvpis_short_hp], + update(bc, is_short_ct, Pcur + mvpis_short_hp, Pnew[mvpis_short_hp], *Pupdate++, updated); - update(w, sign_ct, Pcur + MVPsign_hp, Pnew[MVPsign_hp], *Pupdate++, + update(bc, sign_ct, Pcur + MVPsign_hp, Pnew[MVPsign_hp], *Pupdate++, updated); { @@ -1088,7 +1095,7 @@ static void write_component_probs_hp( do - update(w, short_bct[j], cur_p + j, new_p[j], *Pupdate++, updated); + update(bc, short_bct[j], cur_p + j, new_p[j], *Pupdate++, updated); while (++j < mvnum_short_hp - 1); } @@ -1101,25 +1108,24 @@ static void write_component_probs_hp( do - update(w, bit_ct[j], cur_p + j, new_p[j], *Pupdate++, updated); + update(bc, bit_ct[j], cur_p + j, new_p[j], *Pupdate++, updated); while (++j < mvlong_width_hp); } } -void vp8_write_mvprobs_hp(VP8_COMP *cpi) { - vp8_writer *const w = &cpi->bc; +void vp8_write_mvprobs_hp(VP8_COMP* const cpi, vp8_writer* const bc) { MV_CONTEXT_HP *mvc = cpi->common.fc.mvc_hp; int flags[2] = {0, 0}; #ifdef ENTROPY_STATS active_section = 4; #endif write_component_probs_hp( - w, &mvc[0], &vp8_default_mv_context_hp[0], &vp8_mv_update_probs_hp[0], + bc, &mvc[0], &vp8_default_mv_context_hp[0], &vp8_mv_update_probs_hp[0], cpi->MVcount_hp[0], 0, &flags[0] ); write_component_probs_hp( - w, &mvc[1], &vp8_default_mv_context_hp[1], &vp8_mv_update_probs_hp[1], + bc, &mvc[1], &vp8_default_mv_context_hp[1], &vp8_mv_update_probs_hp[1], cpi->MVcount_hp[1], 1, &flags[1] ); diff --git a/vp8/encoder/encodemv.h b/vp8/encoder/encodemv.h index e675fe058..c06831cb2 100644 --- a/vp8/encoder/encodemv.h +++ b/vp8/encoder/encodemv.h @@ -15,11 +15,12 @@ #include "onyx_int.h" #if CONFIG_NEWMVENTROPY -void vp8_write_nmvprobs(VP8_COMP *, int usehp); -void vp8_encode_nmv(vp8_writer *w, const MV *mv, const MV *ref, - const nmv_context *mvctx); -void vp8_encode_nmv_fp(vp8_writer *w, const MV *mv, const MV *ref, - const nmv_context *mvctx, int usehp); +void vp8_write_nmvprobs(VP8_COMP* const, int usehp, vp8_writer* const); +void vp8_encode_nmv(vp8_writer* const w, const MV* const mv, + const MV* const ref, const nmv_context* const mvctx); +void vp8_encode_nmv_fp(vp8_writer* const w, const MV* const mv, + const MV* const ref, const nmv_context *mvctx, + int usehp); void vp8_build_nmv_cost_table(int *mvjoint, int *mvcost[2], const nmv_context *mvctx, @@ -27,18 +28,18 @@ void vp8_build_nmv_cost_table(int *mvjoint, int mvc_flag_v, int mvc_flag_h); #else /* CONFIG_NEWMVENTROPY */ -void vp8_write_mvprobs(VP8_COMP *); -void vp8_encode_motion_vector(vp8_writer *, const MV *, - const MV_CONTEXT *); +void vp8_write_mvprobs(VP8_COMP* const, vp8_writer* const); +void vp8_encode_motion_vector(vp8_writer* const, const MV* const, + const MV_CONTEXT* const); void vp8_build_component_cost_table(int *mvcost[2], - const MV_CONTEXT *mvc, - int mvc_flag[2]); -void vp8_write_mvprobs_hp(VP8_COMP *); -void vp8_encode_motion_vector_hp(vp8_writer *, const MV *, - const MV_CONTEXT_HP *); + const MV_CONTEXT*, + const int mvc_flag[2]); +void vp8_write_mvprobs_hp(VP8_COMP* const, vp8_writer* const); +void vp8_encode_motion_vector_hp(vp8_writer* const, const MV* const, + const MV_CONTEXT_HP* const); void vp8_build_component_cost_table_hp(int *mvcost[2], - const MV_CONTEXT_HP *mvc, - int mvc_flag[2]); + const MV_CONTEXT_HP*, + const int mvc_flag[2]); #endif /* CONFIG_NEWMVENTROPY */ #endif diff --git a/vp8/encoder/onyx_int.h b/vp8/encoder/onyx_int.h index 1e7494039..01151280c 100644 --- a/vp8/encoder/onyx_int.h +++ b/vp8/encoder/onyx_int.h @@ -420,9 +420,6 @@ typedef struct VP8_COMP { MACROBLOCK mb; VP8_COMMON common; - vp8_writer bc, bc2; - // bool_writer *bc2; - VP8_CONFIG oxcf; struct lookahead_ctx *lookahead; -- 2.40.0