ref: e9fd1eace1c9b35733fa988d2f661fb16548e899
parent: f3208f362b0a08b815a3439c7d71890eef49f174
author: John Koleszar <jkoleszar@google.com>
date: Wed Oct 17 12:47:38 EDT 2012
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
--- a/vp8/common/blockd.h
+++ b/vp8/common/blockd.h
@@ -364,8 +364,6 @@
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)
--- a/vp8/decoder/asm_dec_offsets.c
+++ b/vp8/decoder/asm_dec_offsets.c
@@ -24,7 +24,6 @@
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));
--- 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 <assert.h>
#endif
@@ -73,12 +73,12 @@
}
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 @@
};
#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 @@
#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 @@
// 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_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 @@
#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 @@
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,7 +1305,7 @@
}
}
-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));
@@ -1312,20 +1312,21 @@
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);
}
--- 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);
--- a/vp8/decoder/decodframe.c
+++ b/vp8/decoder/decodframe.c
@@ -202,7 +202,8 @@
}
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
#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 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 @@
}
#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 @@
}
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 @@
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,16 +1118,16 @@
// 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;
}
@@ -1138,12 +1134,12 @@
}
}
// 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 @@
#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 @@
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 @@
#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,48 +1208,48 @@
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;
}
}
@@ -1260,11 +1256,11 @@
/* 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;
}
}
@@ -1271,22 +1267,25 @@
}
}
- 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 @@
*/
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 @@
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 @@
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 @@
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 @@
/* 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 @@
"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 @@
#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);
--- a/vp8/decoder/detokenize.c
+++ b/vp8/decoder/detokenize.c
@@ -302,17 +302,17 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
}
#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 @@
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(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 @@
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 @@
}
#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;
--- 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 */
--- a/vp8/decoder/onyxd_int.h
+++ b/vp8/decoder/onyxd_int.h
@@ -45,7 +45,6 @@
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];
@@ -59,8 +58,6 @@
DECLARE_ALIGNED(16, MACROBLOCKD, mb);
DECLARE_ALIGNED(16, VP8_COMMON, common);
-
- vp8_reader bc, bc2;
VP8D_CONFIG oxcf;
--- a/vp8/encoder/asm_enc_offsets.c
+++ b/vp8/encoder/asm_enc_offsets.c
@@ -68,7 +68,6 @@
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));
--- a/vp8/encoder/bitstream.c
+++ b/vp8/encoder/bitstream.c
@@ -111,10 +111,10 @@
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 @@
#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 @@
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 @@
}
#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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
if (!++count) {count = -8;
- w->buffer[w->pos++] = (lowvalue >> 24);
+ bc->buffer[bc->pos++] = (lowvalue >> 24);
lowvalue &= 0xffffff;
}
}
@@ -615,9 +613,9 @@
++p;
}
- w->count = count;
- w->lowvalue = lowvalue;
- w->range = range;
+ bc->count = count;
+ bc->lowvalue = lowvalue;
+ bc->range = range;
*tp = p;
}
@@ -635,21 +633,22 @@
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
@@ -656,24 +655,24 @@
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
@@ -680,55 +679,55 @@
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;
}
}
@@ -735,7 +734,7 @@
}
// 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 @@
(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 @@
}
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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
*/
#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 @@
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 @@
// 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 @@
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 @@
// 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 @@
}
#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 @@
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 @@
++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 @@
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,15 +1208,15 @@
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
@@ -1225,7 +1223,7 @@
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,
@@ -1232,11 +1230,15 @@
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 @@
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 @@
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 @@
#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 @@
}
#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 @@
// 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,7 +1900,7 @@
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];
@@ -1907,7 +1907,7 @@
#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 @@
// 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,7 +1990,7 @@
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];
@@ -1997,7 +1997,7 @@
#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 @@
}
}
- 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,7 +2068,7 @@
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];
@@ -2075,7 +2075,7 @@
#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 @@
}
}
- 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,7 +2142,7 @@
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];
@@ -2149,7 +2149,7 @@
#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 @@
}
}
- 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,7 +2220,7 @@
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];
@@ -2227,7 +2227,7 @@
#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 @@
}
}
- 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,7 +2294,7 @@
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];
@@ -2301,7 +2301,7 @@
#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 @@
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 @@
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,30 +2455,30 @@
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);
@@ -2484,7 +2485,7 @@
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,7 +2498,7 @@
// 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
@@ -2504,7 +2505,7 @@
// 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)) {@@ -2511,32 +2512,32 @@
// 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)) {@@ -2543,21 +2544,21 @@
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
}
}
// 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,7 +2791,7 @@
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;
@@ -2794,18 +2798,18 @@
#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,21 +2821,21 @@
#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;
@@ -2838,9 +2842,9 @@
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 @@
} 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 @@
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;
}
--- a/vp8/encoder/encodemv.c
+++ b/vp8/encoder/encodemv.c
@@ -28,38 +28,38 @@
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 @@
/* 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(
- 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 @@
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 @@
}
}
-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 @@
}
#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 @@
}
}
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,7 +483,7 @@
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);
@@ -490,7 +490,7 @@
}
}
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 @@
}
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_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 @@
#else /* CONFIG_NEWMVENTROPY */
static void encode_mvcomponent(
- vp8_writer *const w,
+ vp8_writer *const bc,
const int v,
const struct mv_context *mvc
) {@@ -560,17 +561,17 @@
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 { // Largeint 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);
@@ -577,24 +578,27 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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,14 +832,13 @@
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
@@ -839,11 +845,12 @@
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 @@
static void encode_mvcomponent_hp(
- vp8_writer *const w,
+ vp8_writer *const bc,
const int v,
const struct mv_context_hp *mvc
) {@@ -863,8 +870,8 @@
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
@@ -871,10 +878,10 @@
} else { // Largeint 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);
@@ -881,23 +888,23 @@
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 @@
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 @@
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 @@
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 @@
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,14 +1108,13 @@
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
@@ -1115,11 +1121,11 @@
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]
);
--- 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 @@
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
--- a/vp8/encoder/onyx_int.h
+++ b/vp8/encoder/onyx_int.h
@@ -420,9 +420,6 @@
MACROBLOCK mb;
VP8_COMMON common;
- vp8_writer bc, bc2;
- // bool_writer *bc2;
-
VP8_CONFIG oxcf;
struct lookahead_ctx *lookahead;
--
⑨