From dd150e8ea9768aa31df4169411f4f71adc813ada Mon Sep 17 00:00:00 2001
From: Dmitry Kovalev <dkovalev@google.com>
Date: Thu, 11 Jul 2013 18:39:10 -0700
Subject: [PATCH] Removing redundant code mostly from vp9_pred_common.{h, c}.
Removing redundant function arguments and curly braces.
Change-Id: I46e02561f33fe02e84a3b19756f03b9504bd6a1b
---
vp9/common/vp9_pred_common.c | 108 +++++++++++++++------------------
vp9/common/vp9_pred_common.h | 62 ++++++++-----------
vp9/decoder/vp9_decodemv.c | 28 +--------
vp9/encoder/vp9_bitstream.c | 23 ++++---
vp9/encoder/vp9_encodeframe.c | 4 +-
vp9/encoder/vp9_segmentation.c | 2 +-
vp9/encoder/vp9_tokenize.c | 14 ++---
vp9/encoder/vp9_tokenize.h | 4 +-
8 files changed, 98 insertions(+), 147 deletions(-)
diff --git a/vp9/common/vp9_pred_common.c b/vp9/common/vp9_pred_common.c
index 9517cfe773..b7abf7cd72 100644
--- a/vp9/common/vp9_pred_common.c
+++ b/vp9/common/vp9_pred_common.c
@@ -17,7 +17,7 @@
#include "vp9/common/vp9_treecoder.h"
void vp9_set_pred_flag_seg_id(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
- unsigned char pred_flag) {
+ unsigned char pred_flag) {
const int mis = xd->mode_info_stride;
const int bh = 1 << mi_height_log2(bsize);
const int bw = 1 << mi_width_log2(bsize);
@@ -34,45 +34,40 @@ void vp9_set_pred_flag_seg_id(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context_switchable_interp(const VP9_COMMON *cm,
const MACROBLOCKD *xd) {
- int pred_context;
- const MODE_INFO * const mi = xd->mode_info_context;
- const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
- const MODE_INFO * const left_mi = mi - 1;
- const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
- const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MB_MODE_INFO *const above_mbmi = &mi[-cm->mode_info_stride].mbmi;
+ const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
+ const int left_in_image = xd->left_available && left_mbmi->mb_in_image;
+ const int above_in_image = xd->up_available && above_mbmi->mb_in_image;
// Note:
// The mode info data structure has a one element border above and to the
// left of the entries correpsonding to real macroblocks.
// The prediction flags in these dummy entries are initialised to 0.
// left
- const int left_mv_pred = is_inter_mode(left_mi->mbmi.mode);
- const int left_interp =
- left_in_image && left_mv_pred ?
- vp9_switchable_interp_map[left_mi->mbmi.interp_filter] :
+ const int left_mv_pred = is_inter_mode(left_mbmi->mode);
+ const int left_interp = left_in_image && left_mv_pred ?
+ vp9_switchable_interp_map[left_mbmi->interp_filter] :
VP9_SWITCHABLE_FILTERS;
// above
- const int above_mv_pred = is_inter_mode(above_mi->mbmi.mode);
- const int above_interp =
- above_in_image && above_mv_pred ?
- vp9_switchable_interp_map[above_mi->mbmi.interp_filter] :
+ const int above_mv_pred = is_inter_mode(above_mbmi->mode);
+ const int above_interp = above_in_image && above_mv_pred ?
+ vp9_switchable_interp_map[above_mbmi->interp_filter] :
VP9_SWITCHABLE_FILTERS;
assert(left_interp != -1);
assert(above_interp != -1);
if (left_interp == above_interp)
- pred_context = left_interp;
- else if (left_interp == VP9_SWITCHABLE_FILTERS
- && above_interp != VP9_SWITCHABLE_FILTERS)
- pred_context = above_interp;
- else if (left_interp != VP9_SWITCHABLE_FILTERS
- && above_interp == VP9_SWITCHABLE_FILTERS)
- pred_context = left_interp;
+ return left_interp;
+ else if (left_interp == VP9_SWITCHABLE_FILTERS &&
+ above_interp != VP9_SWITCHABLE_FILTERS)
+ return above_interp;
+ else if (left_interp != VP9_SWITCHABLE_FILTERS &&
+ above_interp == VP9_SWITCHABLE_FILTERS)
+ return left_interp;
else
- pred_context = VP9_SWITCHABLE_FILTERS;
-
- return pred_context;
+ return VP9_SWITCHABLE_FILTERS;
}
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context_intra_inter(const VP9_COMMON *cm,
@@ -188,36 +183,30 @@ unsigned char vp9_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
} else { // inter/inter
int l_sg = left_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
int a_sg = above_mi->mbmi.ref_frame[1] <= INTRA_FRAME;
- MV_REFERENCE_FRAME vrfa =
- a_sg ?
- above_mi->mbmi.ref_frame[0] :
- above_mi->mbmi.ref_frame[var_ref_idx];
- MV_REFERENCE_FRAME vrfl =
- l_sg ?
- left_mi->mbmi.ref_frame[0] : left_mi->mbmi.ref_frame[var_ref_idx];
+ MV_REFERENCE_FRAME vrfa = a_sg ? above_mi->mbmi.ref_frame[0]
+ : above_mi->mbmi.ref_frame[var_ref_idx];
+ MV_REFERENCE_FRAME vrfl = l_sg ? left_mi->mbmi.ref_frame[0]
+ : left_mi->mbmi.ref_frame[var_ref_idx];
if (vrfa == vrfl && cm->comp_var_ref[1] == vrfa) {
pred_context = 0;
} else if (l_sg && a_sg) { // single/single
if ((vrfa == cm->comp_fixed_ref && vrfl == cm->comp_var_ref[0])
- || (vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0])) {
+ || (vrfl == cm->comp_fixed_ref && vrfa == cm->comp_var_ref[0]))
pred_context = 4;
- } else if (vrfa == vrfl) {
+ else if (vrfa == vrfl)
pred_context = 3;
- } else {
+ else
pred_context = 1;
- }
} else if (l_sg || a_sg) { // single/comp
MV_REFERENCE_FRAME vrfc = l_sg ? vrfa : vrfl;
MV_REFERENCE_FRAME rfs = a_sg ? vrfa : vrfl;
-
- if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1]) {
+ if (vrfc == cm->comp_var_ref[1] && rfs != cm->comp_var_ref[1])
pred_context = 1;
- } else if (rfs == cm->comp_var_ref[1] && vrfc != cm->comp_var_ref[1]) {
+ else if (rfs == cm->comp_var_ref[1] && vrfc != cm->comp_var_ref[1])
pred_context = 2;
- } else {
+ else
pred_context = 4;
- }
} else if (vrfa == vrfl) { // comp/comp
pred_context = 4;
} else {
@@ -419,10 +408,9 @@ unsigned char vp9_get_pred_context_single_ref_p2(const VP9_COMMON *cm,
// Returns a context number for the given MB prediction signal
unsigned char vp9_get_pred_context_tx_size(const VP9_COMMON *cm,
const MACROBLOCKD *xd) {
- int pred_context;
- const MODE_INFO * const mi = xd->mode_info_context;
- const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
- const MODE_INFO * const left_mi = mi - 1;
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MODE_INFO *const above_mi = mi - cm->mode_info_stride;
+ const MODE_INFO *const left_mi = mi - 1;
const int left_in_image = xd->left_available && left_mi->mbmi.mb_in_image;
const int above_in_image = xd->up_available && above_mi->mbmi.mb_in_image;
// Note:
@@ -439,30 +427,30 @@ unsigned char vp9_get_pred_context_tx_size(const VP9_COMMON *cm,
max_tx_size = TX_16X16;
else
max_tx_size = TX_32X32;
+
above_context = left_context = max_tx_size;
- if (above_in_image) {
- above_context = (
- above_mi->mbmi.mb_skip_coeff ? max_tx_size : above_mi->mbmi.txfm_size);
- }
- if (left_in_image) {
- left_context = (
- left_mi->mbmi.mb_skip_coeff ? max_tx_size : left_mi->mbmi.txfm_size);
- }
- if (!left_in_image) {
+
+ if (above_in_image)
+ above_context = above_mi->mbmi.mb_skip_coeff ? max_tx_size
+ : above_mi->mbmi.txfm_size;
+
+ if (left_in_image)
+ left_context = left_mi->mbmi.mb_skip_coeff ? max_tx_size
+ : left_mi->mbmi.txfm_size;
+
+ if (!left_in_image)
left_context = above_context;
- }
- if (!above_in_image) {
+
+ if (!above_in_image)
above_context = left_context;
- }
- pred_context = (above_context + left_context > max_tx_size);
- return pred_context;
+ return above_context + left_context > max_tx_size;
}
// This function sets the status of the given prediction signal.
// I.e. is the predicted value for the given signal correct.
void vp9_set_pred_flag_mbskip(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
- unsigned char pred_flag) {
+ unsigned char pred_flag) {
const int mis = xd->mode_info_stride;
const int bh = 1 << mi_height_log2(bsize);
const int bw = 1 << mi_width_log2(bsize);
diff --git a/vp9/common/vp9_pred_common.h b/vp9/common/vp9_pred_common.h
index 21a7d809e3..fa0ced4c61 100644
--- a/vp9/common/vp9_pred_common.h
+++ b/vp9/common/vp9_pred_common.h
@@ -18,50 +18,40 @@ int vp9_get_segment_id(VP9_COMMON *cm, const uint8_t *segment_ids,
BLOCK_SIZE_TYPE bsize, int mi_row, int mi_col);
-static INLINE unsigned char vp9_get_pred_context_seg_id(const VP9_COMMON *cm,
- const MACROBLOCKD *xd) {
- int pred_context;
- const MODE_INFO * const mi = xd->mode_info_context;
- const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
- const MODE_INFO * const left_mi = mi - 1;
- pred_context = above_mi->mbmi.seg_id_predicted;
- if (xd->left_available)
- pred_context += left_mi->mbmi.seg_id_predicted;
- return pred_context;
-}
-static INLINE vp9_prob vp9_get_pred_prob_seg_id(const VP9_COMMON *cm,
- const MACROBLOCKD *xd) {
- const int pred_context = vp9_get_pred_context_seg_id(cm, xd);
- return xd->seg.pred_probs[pred_context];
+static INLINE int vp9_get_pred_context_seg_id(const MACROBLOCKD *xd) {
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
+ const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
+
+ return above_mbmi->seg_id_predicted +
+ (xd->left_available ? left_mbmi->seg_id_predicted : 0);
}
-static INLINE unsigned char vp9_get_pred_flag_seg_id(
- const MACROBLOCKD * const xd) {
- return xd->mode_info_context->mbmi.seg_id_predicted;
+
+static INLINE vp9_prob vp9_get_pred_prob_seg_id(const MACROBLOCKD *xd) {
+ return xd->seg.pred_probs[vp9_get_pred_context_seg_id(xd)];
}
void vp9_set_pred_flag_seg_id(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
- unsigned char pred_flag);
-
-static INLINE unsigned char vp9_get_pred_context_mbskip(const VP9_COMMON *cm,
- const MACROBLOCKD *xd) {
- int pred_context;
- const MODE_INFO * const mi = xd->mode_info_context;
- const MODE_INFO * const above_mi = mi - cm->mode_info_stride;
- const MODE_INFO * const left_mi = mi - 1;
- pred_context = above_mi->mbmi.mb_skip_coeff;
- if (xd->left_available)
- pred_context += left_mi->mbmi.mb_skip_coeff;
- return pred_context;
+ unsigned char pred_flag);
+
+static INLINE int vp9_get_pred_context_mbskip(const MACROBLOCKD *xd) {
+ const MODE_INFO *const mi = xd->mode_info_context;
+ const MB_MODE_INFO *const above_mbmi = &mi[-xd->mode_info_stride].mbmi;
+ const MB_MODE_INFO *const left_mbmi = &mi[-1].mbmi;
+
+ return above_mbmi->mb_skip_coeff +
+ (xd->left_available ? left_mbmi->mb_skip_coeff : 0);
}
+
static INLINE vp9_prob vp9_get_pred_prob_mbskip(const VP9_COMMON *cm,
const MACROBLOCKD *xd) {
- const int pred_context = vp9_get_pred_context_mbskip(cm, xd);
- return cm->fc.mbskip_probs[pred_context];
+ return cm->fc.mbskip_probs[vp9_get_pred_context_mbskip(xd)];
}
-static INLINE unsigned char vp9_get_pred_flag_mbskip(
- const MACROBLOCKD * const xd) {
+
+static INLINE unsigned char vp9_get_pred_flag_mbskip(const MACROBLOCKD *xd) {
return xd->mode_info_context->mbmi.mb_skip_coeff;
}
+
void vp9_set_pred_flag_mbskip(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
unsigned char pred_flag);
@@ -69,17 +59,17 @@ unsigned char vp9_get_pred_context_switchable_interp(const VP9_COMMON *cm,
const MACROBLOCKD *xd);
static INLINE const vp9_prob *vp9_get_pred_probs_switchable_interp(
- const VP9_COMMON *cm, const MACROBLOCKD * xd) {
+ const VP9_COMMON *cm, const MACROBLOCKD *xd) {
const int pred_context = vp9_get_pred_context_switchable_interp(cm, xd);
return &cm->fc.switchable_interp_prob[pred_context][0];
}
unsigned char vp9_get_pred_context_intra_inter(const VP9_COMMON *cm,
const MACROBLOCKD *xd);
+
static INLINE vp9_prob vp9_get_pred_prob_intra_inter(const VP9_COMMON *cm,
const MACROBLOCKD *xd) {
const int pred_context = vp9_get_pred_context_intra_inter(cm, xd);
-
return cm->fc.intra_inter_prob[pred_context];
}
diff --git a/vp9/decoder/vp9_decodemv.c b/vp9/decoder/vp9_decodemv.c
index 3fc62c3655..22be55f23b 100644
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -123,7 +123,7 @@ static uint8_t read_skip_coeff(VP9D_COMP *pbi, int segment_id, vp9_reader *r) {
MACROBLOCKD *const xd = &pbi->mb;
int skip_coeff = vp9_segfeature_active(&xd->seg, segment_id, SEG_LVL_SKIP);
if (!skip_coeff) {
- const uint8_t ctx = vp9_get_pred_context_mbskip(cm, xd);
+ const int ctx = vp9_get_pred_context_mbskip(xd);
skip_coeff = vp9_read(r, vp9_get_pred_prob_mbskip(cm, xd));
cm->fc.mbskip_count[ctx][skip_coeff]++;
}
@@ -329,16 +329,6 @@ static void read_ref_frame(VP9D_COMP *pbi, vp9_reader *r,
}
}
-#ifdef VPX_MODE_COUNT
-unsigned int vp9_mv_cont_count[5][4] = {
- { 0, 0, 0, 0 },
- { 0, 0, 0, 0 },
- { 0, 0, 0, 0 },
- { 0, 0, 0, 0 },
- { 0, 0, 0, 0 }
-};
-#endif
-
static void read_switchable_interp_probs(FRAME_CONTEXT *fc, vp9_reader *r) {
int i, j;
for (j = 0; j < VP9_SWITCHABLE_FILTERS + 1; ++j)
@@ -379,9 +369,8 @@ static int read_inter_segment_id(VP9D_COMP *pbi, int mi_row, int mi_col,
if (!seg->update_map)
return pred_segment_id;
-
if (seg->temporal_update) {
- const vp9_prob pred_prob = vp9_get_pred_prob_seg_id(cm, xd);
+ const vp9_prob pred_prob = vp9_get_pred_prob_seg_id(xd);
const int pred_flag = vp9_read(r, pred_prob);
vp9_set_pred_flag_seg_id(xd, bsize, pred_flag);
segment_id = pred_flag ? pred_segment_id
@@ -577,34 +566,21 @@ static void read_inter_mode_info(VP9D_COMP *pbi, MODE_INFO *mi,
if (ref1 > 0)
read_mv(r, &secondmv.as_mv, &best_mv_second.as_mv, nmvc,
&cm->fc.NMVcount, xd->allow_high_precision_mv);
-
-#ifdef VPX_MODE_COUNT
- vp9_mv_cont_count[mv_contz][3]++;
-#endif
break;
case NEARESTMV:
blockmv.as_int = nearest.as_int;
if (ref1 > 0)
secondmv.as_int = nearest_second.as_int;
-#ifdef VPX_MODE_COUNT
- vp9_mv_cont_count[mv_contz][0]++;
-#endif
break;
case NEARMV:
blockmv.as_int = nearby.as_int;
if (ref1 > 0)
secondmv.as_int = nearby_second.as_int;
-#ifdef VPX_MODE_COUNT
- vp9_mv_cont_count[mv_contz][1]++;
-#endif
break;
case ZEROMV:
blockmv.as_int = 0;
if (ref1 > 0)
secondmv.as_int = 0;
-#ifdef VPX_MODE_COUNT
- vp9_mv_cont_count[mv_contz][2]++;
-#endif
break;
default:
assert(!"Invalid inter mode value");
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index adeff102fa..98242db3d0 100644
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -225,14 +225,13 @@ static int write_skip_coeff(const VP9_COMP *cpi, int segment_id, MODE_INFO *m,
}
}
-void vp9_update_skip_probs(VP9_COMP *cpi, vp9_writer *bc) {
- VP9_COMMON *const pc = &cpi->common;
+void vp9_update_skip_probs(VP9_COMP *cpi, vp9_writer *w) {
+ FRAME_CONTEXT *const fc = &cpi->common.fc;
int k;
- for (k = 0; k < MBSKIP_CONTEXTS; ++k) {
- vp9_cond_prob_diff_update(bc, &pc->fc.mbskip_probs[k],
- VP9_MODE_UPDATE_PROB, pc->fc.mbskip_count[k]);
- }
+ for (k = 0; k < MBSKIP_CONTEXTS; ++k)
+ vp9_cond_prob_diff_update(w, &fc->mbskip_probs[k],
+ VP9_MODE_UPDATE_PROB, fc->mbskip_count[k]);
}
static void write_intra_mode(vp9_writer *bc, int m, const vp9_prob *p) {
@@ -426,13 +425,13 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
if (seg->update_map) {
if (seg->temporal_update) {
- unsigned char prediction_flag = vp9_get_pred_flag_seg_id(xd);
- vp9_prob pred_prob = vp9_get_pred_prob_seg_id(pc, xd);
- vp9_write(bc, prediction_flag, pred_prob);
- if (!prediction_flag)
- write_segment_id(bc, seg, mi->segment_id);
+ const int pred_flag = xd->mode_info_context->mbmi.seg_id_predicted;
+ vp9_prob pred_prob = vp9_get_pred_prob_seg_id(xd);
+ vp9_write(bc, pred_flag, pred_prob);
+ if (!pred_flag)
+ write_segment_id(bc, seg, segment_id);
} else {
- write_segment_id(bc, seg, mi->segment_id);
+ write_segment_id(bc, seg, segment_id);
}
}
diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index a3e116bbf7..d0827afca2 100644
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -2345,11 +2345,11 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
}
if (xd->mode_info_context->mbmi.ref_frame[0] == INTRA_FRAME) {
- vp9_tokenize_sb(cpi, xd, t, !output_enabled,
+ vp9_tokenize_sb(cpi, t, !output_enabled,
(bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
} else if (!x->skip) {
vp9_encode_sb(cm, x, (bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
- vp9_tokenize_sb(cpi, xd, t, !output_enabled,
+ vp9_tokenize_sb(cpi, t, !output_enabled,
(bsize < BLOCK_SIZE_SB8X8) ? BLOCK_SIZE_SB8X8 : bsize);
} else {
int mb_skip_context = xd->left_available ? (mi - 1)->mbmi.mb_skip_coeff : 0;
diff --git a/vp9/encoder/vp9_segmentation.c b/vp9/encoder/vp9_segmentation.c
index 6a22df86c1..f3b2ea8e51 100644
--- a/vp9/encoder/vp9_segmentation.c
+++ b/vp9/encoder/vp9_segmentation.c
@@ -141,7 +141,7 @@ static void count_segs(VP9_COMP *cpi, MODE_INFO *mi,
const int pred_segment_id = vp9_get_segment_id(cm, cm->last_frame_seg_map,
bsize, mi_row, mi_col);
const int pred_flag = pred_segment_id == segment_id;
- const int pred_context = vp9_get_pred_context_seg_id(cm, xd);
+ const int pred_context = vp9_get_pred_context_seg_id(xd);
// Store the prediction status for this mb and update counts
// as appropriate
diff --git a/vp9/encoder/vp9_tokenize.c b/vp9/encoder/vp9_tokenize.c
index d526990df0..4403f9527d 100644
--- a/vp9/encoder/vp9_tokenize.c
+++ b/vp9/encoder/vp9_tokenize.c
@@ -266,21 +266,19 @@ int vp9_sbuv_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
return result;
}
-void vp9_tokenize_sb(VP9_COMP *cpi,
- MACROBLOCKD *xd,
- TOKENEXTRA **t,
- int dry_run, BLOCK_SIZE_TYPE bsize) {
- VP9_COMMON * const cm = &cpi->common;
- MB_MODE_INFO * const mbmi = &xd->mode_info_context->mbmi;
+void vp9_tokenize_sb(VP9_COMP *cpi, TOKENEXTRA **t, int dry_run,
+ BLOCK_SIZE_TYPE bsize) {
+ VP9_COMMON *const cm = &cpi->common;
+ MACROBLOCKD *const xd = &cpi->mb.e_mbd;
+ MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
TOKENEXTRA *t_backup = *t;
- const int mb_skip_context = vp9_get_pred_context_mbskip(cm, xd);
+ const int mb_skip_context = vp9_get_pred_context_mbskip(xd);
const int skip_inc = !vp9_segfeature_active(&xd->seg, mbmi->segment_id,
SEG_LVL_SKIP);
const TX_SIZE txfm_size = mbmi->txfm_size;
struct tokenize_b_args arg = { cpi, xd, t, txfm_size, dry_run };
mbmi->mb_skip_coeff = vp9_sb_is_skippable(xd, bsize);
-
if (mbmi->mb_skip_coeff) {
if (!dry_run)
cm->fc.mbskip_count[mb_skip_context][1] += skip_inc;
diff --git a/vp9/encoder/vp9_tokenize.h b/vp9/encoder/vp9_tokenize.h
index e7f90c96cf..bc7d9352ee 100644
--- a/vp9/encoder/vp9_tokenize.h
+++ b/vp9/encoder/vp9_tokenize.h
@@ -36,8 +36,8 @@ int vp9_sby_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize);
int vp9_sbuv_is_skippable(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize);
struct VP9_COMP;
-void vp9_tokenize_sb(struct VP9_COMP *cpi, MACROBLOCKD *xd,
- TOKENEXTRA **t, int dry_run, BLOCK_SIZE_TYPE bsize);
+void vp9_tokenize_sb(struct VP9_COMP *cpi, TOKENEXTRA **t, int dry_run,
+ BLOCK_SIZE_TYPE bsize);
#ifdef ENTROPY_STATS
void init_context_counters();
--
GitLab