summaryrefslogtreecommitdiff
path: root/vp9
diff options
context:
space:
mode:
Diffstat (limited to 'vp9')
-rw-r--r--vp9/common/vp9_alloccommon.c6
-rw-r--r--vp9/common/vp9_mvref_common.h6
-rw-r--r--vp9/decoder/vp9_decodeframe.c7
-rw-r--r--vp9/encoder/vp9_bitstream.c3
-rw-r--r--vp9/encoder/vp9_encodemv.c8
-rw-r--r--vp9/encoder/vp9_firstpass.c195
-rw-r--r--vp9/encoder/vp9_lookahead.c2
-rw-r--r--vp9/encoder/vp9_onyx_if.c14
-rw-r--r--vp9/encoder/vp9_pickmode.c2
-rw-r--r--vp9/encoder/vp9_ratectrl.c95
-rw-r--r--vp9/encoder/vp9_rdopt.c43
-rw-r--r--vp9/encoder/vp9_rdopt.h2
-rw-r--r--vp9/encoder/vp9_temporal_filter.c2
-rw-r--r--vp9/vp9_iface_common.h2
14 files changed, 176 insertions, 211 deletions
diff --git a/vp9/common/vp9_alloccommon.c b/vp9/common/vp9_alloccommon.c
index ff20553d6..ca42090c1 100644
--- a/vp9/common/vp9_alloccommon.c
+++ b/vp9/common/vp9_alloccommon.c
@@ -85,7 +85,7 @@ int vp9_resize_frame_buffers(VP9_COMMON *cm, int width, int height) {
int mi_size;
if (vp9_realloc_frame_buffer(&cm->post_proc_buffer, width, height, ss_x, ss_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL) < 0)
+ VP9_DEC_BORDER_IN_PIXELS, NULL, NULL, NULL) < 0)
goto fail;
set_mb_mi(cm, aligned_width, aligned_height);
@@ -154,7 +154,7 @@ int vp9_alloc_frame_buffers(VP9_COMMON *cm, int width, int height) {
for (i = 0; i < cm->fb_count; i++) {
cm->fb_idx_ref_cnt[i] = 0;
if (vp9_alloc_frame_buffer(&cm->yv12_fb[i], width, height, ss_x, ss_y,
- VP9BORDERINPIXELS) < 0)
+ VP9_ENC_BORDER_IN_PIXELS) < 0)
goto fail;
}
@@ -167,7 +167,7 @@ int vp9_alloc_frame_buffers(VP9_COMMON *cm, int width, int height) {
}
if (vp9_alloc_frame_buffer(&cm->post_proc_buffer, width, height, ss_x, ss_y,
- VP9BORDERINPIXELS) < 0)
+ VP9_ENC_BORDER_IN_PIXELS) < 0)
goto fail;
set_mb_mi(cm, aligned_width, aligned_height);
diff --git a/vp9/common/vp9_mvref_common.h b/vp9/common/vp9_mvref_common.h
index 06adbabaa..cd89390d5 100644
--- a/vp9/common/vp9_mvref_common.h
+++ b/vp9/common/vp9_mvref_common.h
@@ -32,8 +32,10 @@ static INLINE void vp9_find_mv_refs(const VP9_COMMON *cm, const MACROBLOCKD *xd,
mv_ref_list, -1, mi_row, mi_col);
}
-#define LEFT_TOP_MARGIN ((VP9BORDERINPIXELS - VP9_INTERP_EXTEND) << 3)
-#define RIGHT_BOTTOM_MARGIN ((VP9BORDERINPIXELS - VP9_INTERP_EXTEND) << 3)
+#define LEFT_TOP_MARGIN ((VP9_ENC_BORDER_IN_PIXELS \
+ - VP9_INTERP_EXTEND) << 3)
+#define RIGHT_BOTTOM_MARGIN ((VP9_ENC_BORDER_IN_PIXELS \
+ - VP9_INTERP_EXTEND) << 3)
// check a list of motion vectors by sad score using a number rows of pixels
// above and a number cols of pixels in the left to select the one with best
diff --git a/vp9/decoder/vp9_decodeframe.c b/vp9/decoder/vp9_decodeframe.c
index 59faccdf7..d66ee2730 100644
--- a/vp9/decoder/vp9_decodeframe.c
+++ b/vp9/decoder/vp9_decodeframe.c
@@ -704,7 +704,7 @@ static void apply_frame_size(VP9D_COMP *pbi, int width, int height) {
if (vp9_realloc_frame_buffer(get_frame_new_buffer(cm),
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, ext_fb,
+ VP9_DEC_BORDER_IN_PIXELS, ext_fb,
cm->realloc_fb_cb, cm->user_priv)) {
vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate external frame buffer");
@@ -712,7 +712,7 @@ static void apply_frame_size(VP9D_COMP *pbi, int width, int height) {
} else {
vp9_realloc_frame_buffer(get_frame_new_buffer(cm), cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL);
+ VP9_DEC_BORDER_IN_PIXELS, NULL, NULL, NULL);
}
}
@@ -1129,11 +1129,12 @@ static size_t read_uncompressed_header(VP9D_COMP *pbi,
cm->show_existing_frame = vp9_rb_read_bit(rb);
if (cm->show_existing_frame) {
- // show an existing frame directly
+ // Show an existing frame directly.
int frame_to_show = cm->ref_frame_map[vp9_rb_read_literal(rb, 3)];
ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->new_fb_idx, frame_to_show);
pbi->refresh_frame_flags = 0;
cm->lf.filter_level = 0;
+ cm->show_frame = 1;
return 0;
}
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index 2ab4c7907..7188d7674 100644
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -746,7 +746,6 @@ static void update_coef_probs(VP9_COMP* cpi, vp9_writer* w) {
const TX_MODE tx_mode = cpi->common.tx_mode;
const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
TX_SIZE tx_size;
- vp9_clear_system_state();
for (tx_size = TX_4X4; tx_size <= TX_32X32; ++tx_size)
build_tree_distribution(cpi, tx_size);
@@ -1296,8 +1295,6 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, size_t *size) {
active_section = 7;
#endif
- vp9_clear_system_state(); // __asm emms;
-
first_part_size = write_compressed_header(cpi, data);
data += first_part_size;
vp9_wb_write_literal(&saved_wb, first_part_size, 16);
diff --git a/vp9/encoder/vp9_encodemv.c b/vp9/encoder/vp9_encodemv.c
index af710a8f4..853094b29 100644
--- a/vp9/encoder/vp9_encodemv.c
+++ b/vp9/encoder/vp9_encodemv.c
@@ -224,13 +224,9 @@ void vp9_encode_mv(VP9_COMP* cpi, vp9_writer* w,
}
}
-void vp9_build_nmv_cost_table(int *mvjoint,
- int *mvcost[2],
+void vp9_build_nmv_cost_table(int *mvjoint, int *mvcost[2],
const nmv_context* const mvctx,
- int usehp,
- int mvc_flag_v,
- int mvc_flag_h) {
- vp9_clear_system_state();
+ int usehp, int mvc_flag_v, int mvc_flag_h) {
vp9_cost_tokens(mvjoint, mvctx->joints, vp9_mv_joint_tree);
if (mvc_flag_v)
build_nmv_component_cost_table(mvcost[0], &mvctx->comps[0], usehp);
diff --git a/vp9/encoder/vp9_firstpass.c b/vp9/encoder/vp9_firstpass.c
index fe57af284..5cb8b5327 100644
--- a/vp9/encoder/vp9_firstpass.c
+++ b/vp9/encoder/vp9_firstpass.c
@@ -394,42 +394,35 @@ static unsigned int zz_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
}
static void first_pass_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
- MV *ref_mv, MV *best_mv,
+ const MV *ref_mv, MV *best_mv,
YV12_BUFFER_CONFIG *recon_buffer,
int *best_motion_err, int recon_yoffset) {
MACROBLOCKD *const xd = &x->e_mbd;
- int num00;
-
MV tmp_mv = {0, 0};
- MV ref_mv_full;
-
- int tmp_err;
+ MV ref_mv_full = {ref_mv->row >> 3, ref_mv->col >> 3};
+ int num00, tmp_err, n, sr = 0;
int step_param = 3;
int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
- int n;
- vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[xd->mi_8x8[0]->mbmi.sb_type];
+ const BLOCK_SIZE bsize = xd->mi_8x8[0]->mbmi.sb_type;
+ vp9_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize];
int new_mv_mode_penalty = 256;
-
- int sr = 0;
- int quart_frm = MIN(cpi->common.width, cpi->common.height);
+ const int quart_frm = MIN(cpi->common.width, cpi->common.height);
// refine the motion search range accroding to the frame dimension
// for first pass test
while ((quart_frm << sr) < MAX_FULL_PEL_VAL)
sr++;
- step_param += sr;
+ step_param += sr;
further_steps -= sr;
// override the default variance function to use MSE
- v_fn_ptr.vf = get_block_variance_fn(xd->mi_8x8[0]->mbmi.sb_type);
+ v_fn_ptr.vf = get_block_variance_fn(bsize);
// Set up pointers for this macro block recon buffer
xd->plane[0].pre[0].buf = recon_buffer->y_buffer + recon_yoffset;
// Initial step/diamond search centred on best mv
- ref_mv_full.col = ref_mv->col >> 3;
- ref_mv_full.row = ref_mv->row >> 3;
tmp_err = cpi->diamond_search_sad(x, &ref_mv_full, &tmp_mv,
step_param,
x->sadperbit16, &num00, &v_fn_ptr,
@@ -504,6 +497,7 @@ void vp9_first_pass(VP9_COMP *cpi) {
int new_mv_count = 0;
int sum_in_vectors = 0;
uint32_t lastmv_as_int = 0;
+ struct twopass_rc *const twopass = &cpi->twopass;
int_mv zero_ref_mv;
@@ -830,23 +824,22 @@ void vp9_first_pass(VP9_COMP *cpi) {
fps.duration = (double)(cpi->source->ts_end - cpi->source->ts_start);
// don't want to do output stats with a stack variable!
- cpi->twopass.this_frame_stats = fps;
- output_stats(cpi, cpi->output_pkt_list, &cpi->twopass.this_frame_stats);
- accumulate_stats(&cpi->twopass.total_stats, &fps);
+ twopass->this_frame_stats = fps;
+ output_stats(cpi, cpi->output_pkt_list, &twopass->this_frame_stats);
+ accumulate_stats(&twopass->total_stats, &fps);
}
// Copy the previous Last Frame back into gf and and arf buffers if
// the prediction is good enough... but also dont allow it to lag too far
- if ((cpi->twopass.sr_update_lag > 3) ||
+ if ((twopass->sr_update_lag > 3) ||
((cm->current_video_frame > 0) &&
- (cpi->twopass.this_frame_stats.pcnt_inter > 0.20) &&
- ((cpi->twopass.this_frame_stats.intra_error /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.this_frame_stats.coded_error)) >
- 2.0))) {
+ (twopass->this_frame_stats.pcnt_inter > 0.20) &&
+ ((twopass->this_frame_stats.intra_error /
+ DOUBLE_DIVIDE_CHECK(twopass->this_frame_stats.coded_error)) > 2.0))) {
vp8_yv12_copy_frame(lst_yv12, gld_yv12);
- cpi->twopass.sr_update_lag = 1;
+ twopass->sr_update_lag = 1;
} else {
- cpi->twopass.sr_update_lag++;
+ twopass->sr_update_lag++;
}
// swap frame pointers so last frame refers to the frame we just compressed
swap_yv12(lst_yv12, new_yv12);
@@ -1034,37 +1027,38 @@ extern void vp9_new_framerate(VP9_COMP *cpi, double framerate);
void vp9_init_second_pass(VP9_COMP *cpi) {
FIRSTPASS_STATS this_frame;
FIRSTPASS_STATS *start_pos;
+ struct twopass_rc *const twopass = &cpi->twopass;
- zero_stats(&cpi->twopass.total_stats);
- zero_stats(&cpi->twopass.total_left_stats);
+ zero_stats(&twopass->total_stats);
+ zero_stats(&twopass->total_left_stats);
- if (!cpi->twopass.stats_in_end)
+ if (!twopass->stats_in_end)
return;
- cpi->twopass.total_stats = *cpi->twopass.stats_in_end;
- cpi->twopass.total_left_stats = cpi->twopass.total_stats;
+ twopass->total_stats = *twopass->stats_in_end;
+ twopass->total_left_stats = twopass->total_stats;
// each frame can have a different duration, as the frame rate in the source
// isn't guaranteed to be constant. The frame rate prior to the first frame
// encoded in the second pass is a guess. However the sum duration is not.
// Its calculated based on the actual durations of all frames from the first
// pass.
- vp9_new_framerate(cpi, 10000000.0 * cpi->twopass.total_stats.count /
- cpi->twopass.total_stats.duration);
+ vp9_new_framerate(cpi, 10000000.0 * twopass->total_stats.count /
+ twopass->total_stats.duration);
cpi->output_framerate = cpi->oxcf.framerate;
- cpi->twopass.bits_left = (int64_t)(cpi->twopass.total_stats.duration *
- cpi->oxcf.target_bandwidth / 10000000.0);
+ twopass->bits_left = (int64_t)(twopass->total_stats.duration *
+ cpi->oxcf.target_bandwidth / 10000000.0);
// Calculate a minimum intra value to be used in determining the IIratio
// scores used in the second pass. We have this minimum to make sure
// that clips that are static but "low complexity" in the intra domain
// are still boosted appropriately for KF/GF/ARF
- cpi->twopass.kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
- cpi->twopass.gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
+ twopass->kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
+ twopass->gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
// This variable monitors how far behind the second ref update is lagging
- cpi->twopass.sr_update_lag = 1;
+ twopass->sr_update_lag = 1;
// Scan the first pass file and calculate an average Intra / Inter error score
// ratio for the sequence.
@@ -1072,43 +1066,43 @@ void vp9_init_second_pass(VP9_COMP *cpi) {
double sum_iiratio = 0.0;
double IIRatio;
- start_pos = cpi->twopass.stats_in; // Note the starting "file" position.
+ start_pos = twopass->stats_in; // Note the starting "file" position.
- while (input_stats(&cpi->twopass, &this_frame) != EOF) {
+ while (input_stats(twopass, &this_frame) != EOF) {
IIRatio = this_frame.intra_error
/ DOUBLE_DIVIDE_CHECK(this_frame.coded_error);
IIRatio = (IIRatio < 1.0) ? 1.0 : (IIRatio > 20.0) ? 20.0 : IIRatio;
sum_iiratio += IIRatio;
}
- cpi->twopass.avg_iiratio = sum_iiratio /
- DOUBLE_DIVIDE_CHECK((double)cpi->twopass.total_stats.count);
+ twopass->avg_iiratio = sum_iiratio /
+ DOUBLE_DIVIDE_CHECK((double)twopass->total_stats.count);
// Reset file position
- reset_fpf_position(&cpi->twopass, start_pos);
+ reset_fpf_position(twopass, start_pos);
}
// Scan the first pass file and calculate a modified total error based upon
// the bias/power function used to allocate bits.
{
- double av_error = cpi->twopass.total_stats.ssim_weighted_pred_err /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.total_stats.count);
+ double av_error = twopass->total_stats.ssim_weighted_pred_err /
+ DOUBLE_DIVIDE_CHECK(twopass->total_stats.count);
- start_pos = cpi->twopass.stats_in; // Note starting "file" position
+ start_pos = twopass->stats_in; // Note starting "file" position
- cpi->twopass.modified_error_total = 0.0;
- cpi->twopass.modified_error_min =
+ twopass->modified_error_total = 0.0;
+ twopass->modified_error_min =
(av_error * cpi->oxcf.two_pass_vbrmin_section) / 100;
- cpi->twopass.modified_error_max =
+ twopass->modified_error_max =
(av_error * cpi->oxcf.two_pass_vbrmax_section) / 100;
- while (input_stats(&cpi->twopass, &this_frame) != EOF) {
- cpi->twopass.modified_error_total +=
+ while (input_stats(twopass, &this_frame) != EOF) {
+ twopass->modified_error_total +=
calculate_modified_err(cpi, &this_frame);
}
- cpi->twopass.modified_error_left = cpi->twopass.modified_error_total;
+ twopass->modified_error_left = twopass->modified_error_total;
- reset_fpf_position(&cpi->twopass, start_pos); // Reset file position
+ reset_fpf_position(twopass, start_pos);
}
}
@@ -2232,12 +2226,13 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
double recent_loop_decay[8] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
RATE_CONTROL *const rc = &cpi->rc;
+ struct twopass_rc *const twopass = &cpi->twopass;
vp9_zero(next_frame);
vp9_clear_system_state(); // __asm emms;
- start_position = cpi->twopass.stats_in;
+ start_position = twopass->stats_in;
cpi->common.frame_type = KEY_FRAME;
// is this a forced key frame by interval
@@ -2254,14 +2249,14 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
// Take a copy of the initial frame details
first_frame = *this_frame;
- cpi->twopass.kf_group_bits = 0; // Total bits available to kf group
- cpi->twopass.kf_group_error_left = 0; // Group modified error score.
+ twopass->kf_group_bits = 0; // Total bits available to kf group
+ twopass->kf_group_error_left = 0; // Group modified error score.
kf_mod_err = calculate_modified_err(cpi, this_frame);
// find the next keyframe
i = 0;
- while (cpi->twopass.stats_in < cpi->twopass.stats_in_end) {
+ while (twopass->stats_in < twopass->stats_in_end) {
// Accumulate kf group error
kf_group_err += calculate_modified_err(cpi, this_frame);
@@ -2273,11 +2268,11 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
// load a the next frame's stats
last_frame = *this_frame;
- input_stats(&cpi->twopass, this_frame);
+ input_stats(twopass, this_frame);
// Provided that we are not at the end of the file...
if (cpi->oxcf.auto_key &&
- lookup_next_frame_stats(&cpi->twopass, &next_frame) != EOF) {
+ lookup_next_frame_stats(twopass, &next_frame) != EOF) {
// Normal scene cut check
if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
break;
@@ -2327,7 +2322,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
tmp_frame = first_frame;
// Reset to the start of the group
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
kf_group_err = 0;
kf_group_intra_err = 0;
@@ -2341,17 +2336,17 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
kf_group_coded_err += tmp_frame.coded_error;
// Load a the next frame's stats
- input_stats(&cpi->twopass, &tmp_frame);
+ input_stats(twopass, &tmp_frame);
}
rc->next_key_frame_forced = 1;
- } else if (cpi->twopass.stats_in == cpi->twopass.stats_in_end) {
+ } else if (twopass->stats_in == twopass->stats_in_end) {
rc->next_key_frame_forced = 1;
} else {
rc->next_key_frame_forced = 0;
}
// Special case for the last key frame of the file
- if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) {
+ if (twopass->stats_in >= twopass->stats_in_end) {
// Accumulate kf group error
kf_group_err += calculate_modified_err(cpi, this_frame);
@@ -2363,8 +2358,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
}
// Calculate the number of bits that should be assigned to the kf group.
- if ((cpi->twopass.bits_left > 0) &&
- (cpi->twopass.modified_error_left > 0.0)) {
+ if (twopass->bits_left > 0 && twopass->modified_error_left > 0.0) {
// Max for a single normal frame (not key frame)
int max_bits = frame_max_bits(cpi);
@@ -2373,19 +2367,18 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
// Default allocation based on bits left and relative
// complexity of the section
- cpi->twopass.kf_group_bits = (int64_t)(cpi->twopass.bits_left *
- (kf_group_err /
- cpi->twopass.modified_error_left));
+ twopass->kf_group_bits = (int64_t)(twopass->bits_left *
+ (kf_group_err / twopass->modified_error_left));
// Clip based on maximum per frame rate defined by the user.
max_grp_bits = (int64_t)max_bits * (int64_t)rc->frames_to_key;
- if (cpi->twopass.kf_group_bits > max_grp_bits)
- cpi->twopass.kf_group_bits = max_grp_bits;
+ if (twopass->kf_group_bits > max_grp_bits)
+ twopass->kf_group_bits = max_grp_bits;
} else {
- cpi->twopass.kf_group_bits = 0;
+ twopass->kf_group_bits = 0;
}
// Reset the first pass file position
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
// Determine how big to make this keyframe based on how well the subsequent
// frames use inter blocks.
@@ -2397,7 +2390,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
for (i = 0; i < rc->frames_to_key; i++) {
double r;
- if (EOF == input_stats(&cpi->twopass, &next_frame))
+ if (EOF == input_stats(twopass, &next_frame))
break;
// Monitor for static sections.
@@ -2409,11 +2402,11 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
// For the first few frames collect data to decide kf boost.
if (i <= (rc->max_gf_interval * 2)) {
- if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
+ if (next_frame.intra_error > twopass->kf_intra_err_min)
r = (IIKFACTOR2 * next_frame.intra_error /
DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
else
- r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
+ r = (IIKFACTOR2 * twopass->kf_intra_err_min /
DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
if (r > RMAX)
@@ -2435,21 +2428,21 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
FIRSTPASS_STATS sectionstats;
zero_stats(&sectionstats);
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
for (i = 0; i < rc->frames_to_key; i++) {
- input_stats(&cpi->twopass, &next_frame);
+ input_stats(twopass, &next_frame);
accumulate_stats(&sectionstats, &next_frame);
}
avg_stats(&sectionstats);
- cpi->twopass.section_intra_rating = (int) (sectionstats.intra_error /
+ twopass->section_intra_rating = (int) (sectionstats.intra_error /
DOUBLE_DIVIDE_CHECK(sectionstats.coded_error));
}
// Reset the first pass file position
- reset_fpf_position(&cpi->twopass, start_position);
+ reset_fpf_position(twopass, start_position);
// Work out how many bits to allocate for the key frame itself
if (1) {
@@ -2466,7 +2459,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
// Make a note of baseline boost and the zero motion
// accumulator value for use elsewhere.
rc->kf_boost = kf_boost;
- cpi->twopass.kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
+ twopass->kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
// We do three calculations for kf size.
// The first is based on the error score for the whole kf group.
@@ -2481,11 +2474,9 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
// cpi->rc.frames_to_key-1 because key frame itself is taken
// care of by kf_boost.
if (zero_motion_accumulator >= 0.99) {
- allocation_chunks =
- ((rc->frames_to_key - 1) * 10) + kf_boost;
+ allocation_chunks = ((rc->frames_to_key - 1) * 10) + kf_boost;
} else {
- allocation_chunks =
- ((rc->frames_to_key - 1) * 100) + kf_boost;
+ allocation_chunks = ((rc->frames_to_key - 1) * 100) + kf_boost;
}
// Prevent overflow
@@ -2495,58 +2486,54 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
allocation_chunks /= divisor;
}
- cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0
- : cpi->twopass.kf_group_bits;
+ twopass->kf_group_bits = (twopass->kf_group_bits < 0) ? 0
+ : twopass->kf_group_bits;
// Calculate the number of bits to be spent on the key frame
- cpi->twopass.kf_bits = (int)((double)kf_boost *
- ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks));
+ twopass->kf_bits = (int)((double)kf_boost *
+ ((double)twopass->kf_group_bits / allocation_chunks));
// If the key frame is actually easier than the average for the
// kf group (which does sometimes happen... eg a blank intro frame)
// Then use an alternate calculation based on the kf error score
// which should give a smaller key frame.
if (kf_mod_err < kf_group_err / rc->frames_to_key) {
- double alt_kf_grp_bits =
- ((double)cpi->twopass.bits_left *
+ double alt_kf_grp_bits = ((double)twopass->bits_left *
(kf_mod_err * (double)rc->frames_to_key) /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left));
+ DOUBLE_DIVIDE_CHECK(twopass->modified_error_left));
alt_kf_bits = (int)((double)kf_boost *
(alt_kf_grp_bits / (double)allocation_chunks));
- if (cpi->twopass.kf_bits > alt_kf_bits) {
- cpi->twopass.kf_bits = alt_kf_bits;
- }
+ if (twopass->kf_bits > alt_kf_bits)
+ twopass->kf_bits = alt_kf_bits;
} else {
// Else if it is much harder than other frames in the group make sure
// it at least receives an allocation in keeping with its relative
// error score
- alt_kf_bits = (int)((double)cpi->twopass.bits_left *
- (kf_mod_err /
- DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)));
+ alt_kf_bits = (int)((double)twopass->bits_left * (kf_mod_err /
+ DOUBLE_DIVIDE_CHECK(twopass->modified_error_left)));
- if (alt_kf_bits > cpi->twopass.kf_bits) {
- cpi->twopass.kf_bits = alt_kf_bits;
+ if (alt_kf_bits > twopass->kf_bits) {
+ twopass->kf_bits = alt_kf_bits;
}
}
- cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
+ twopass->kf_group_bits -= twopass->kf_bits;
// Peer frame bit target for this frame
- rc->per_frame_bandwidth = cpi->twopass.kf_bits;
+ rc->per_frame_bandwidth = twopass->kf_bits;
// Convert to a per second bitrate
- cpi->target_bandwidth = (int)(cpi->twopass.kf_bits *
- cpi->output_framerate);
+ cpi->target_bandwidth = (int)(twopass->kf_bits * cpi->output_framerate);
}
// Note the total error score of the kf group minus the key frame itself
- cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
+ twopass->kf_group_error_left = (int)(kf_group_err - kf_mod_err);
// Adjust the count of total modified error left.
// The count of bits left is adjusted elsewhere based on real coded frame
// sizes.
- cpi->twopass.modified_error_left -= kf_group_err;
+ twopass->modified_error_left -= kf_group_err;
}
void vp9_twopass_postencode_update(VP9_COMP *cpi, uint64_t bytes_used) {
diff --git a/vp9/encoder/vp9_lookahead.c b/vp9/encoder/vp9_lookahead.c
index 277bd7db1..ee73ff15a 100644
--- a/vp9/encoder/vp9_lookahead.c
+++ b/vp9/encoder/vp9_lookahead.c
@@ -73,7 +73,7 @@ struct lookahead_ctx * vp9_lookahead_init(unsigned int width,
for (i = 0; i < depth; i++)
if (vp9_alloc_frame_buffer(&ctx->buf[i].img,
width, height, subsampling_x, subsampling_y,
- VP9BORDERINPIXELS))
+ VP9_ENC_BORDER_IN_PIXELS))
goto bail;
}
return ctx;
diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c
index 3e1daca28..e6a60fbf3 100644
--- a/vp9/encoder/vp9_onyx_if.c
+++ b/vp9/encoder/vp9_onyx_if.c
@@ -968,7 +968,7 @@ static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
if (vp9_realloc_frame_buffer(&cpi->alt_ref_buffer,
cpi->oxcf.width, cpi->oxcf.height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL))
+ VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate altref buffer");
}
@@ -983,14 +983,14 @@ void vp9_alloc_compressor_data(VP9_COMP *cpi) {
if (vp9_alloc_frame_buffer(&cpi->last_frame_uf,
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS))
+ VP9_ENC_BORDER_IN_PIXELS))
vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate last frame buffer");
if (vp9_alloc_frame_buffer(&cpi->scaled_source,
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS))
+ VP9_ENC_BORDER_IN_PIXELS))
vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate scaled source buffer");
@@ -1036,14 +1036,14 @@ static void update_frame_size(VP9_COMP *cpi) {
if (vp9_realloc_frame_buffer(&cpi->last_frame_uf,
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL))
+ VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
"Failed to reallocate last frame buffer");
if (vp9_realloc_frame_buffer(&cpi->scaled_source,
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL))
+ VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL))
vpx_internal_error(&cm->error, VPX_CODEC_MEM_ERROR,
"Failed to reallocate scaled source buffer");
@@ -2552,7 +2552,7 @@ static void scale_references(VP9_COMP *cpi) {
vp9_realloc_frame_buffer(&cm->yv12_fb[new_fb],
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL);
+ VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL);
scale_and_extend_frame(ref, &cm->yv12_fb[new_fb]);
cpi->scaled_ref_idx[ref_frame - 1] = new_fb;
} else {
@@ -3545,7 +3545,7 @@ int vp9_get_compressed_data(VP9_PTR ptr, unsigned int *frame_flags,
vp9_realloc_frame_buffer(get_frame_new_buffer(cm),
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
- VP9BORDERINPIXELS, NULL, NULL, NULL);
+ VP9_ENC_BORDER_IN_PIXELS, NULL, NULL, NULL);
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
diff --git a/vp9/encoder/vp9_pickmode.c b/vp9/encoder/vp9_pickmode.c
index 17d1f5984..f317f2a0d 100644
--- a/vp9/encoder/vp9_pickmode.c
+++ b/vp9/encoder/vp9_pickmode.c
@@ -174,7 +174,7 @@ int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
x->pred_mv_sad[ref_frame] = INT_MAX;
if (cpi->ref_frame_flags & flag_list[ref_frame]) {
- vp9_setup_buffer_inter(cpi, x, tile, get_ref_frame_idx(cpi, ref_frame),
+ vp9_setup_buffer_inter(cpi, x, tile,
ref_frame, block_size, mi_row, mi_col,
frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb);
}
diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c
index 4d2d43a11..3ebf98c0f 100644
--- a/vp9/encoder/vp9_ratectrl.c
+++ b/vp9/encoder/vp9_ratectrl.c
@@ -211,19 +211,16 @@ static int estimate_bits_at_q(int frame_kind, int q, int mbs,
static void calc_iframe_target_size(VP9_COMP *cpi) {
- // boost defaults to half second
+ const VP9_CONFIG *oxcf = &cpi->oxcf;
+ RATE_CONTROL *const rc = &cpi->rc;
int target;
- // Clear down mmx registers to allow floating point in what follows
vp9_clear_system_state(); // __asm emms;
- // New Two pass RC
- target = cpi->rc.per_frame_bandwidth;
-
// For 1-pass.
if (cpi->pass == 0) {
if (cpi->common.current_video_frame == 0) {
- target = cpi->oxcf.starting_buffer_level / 2;
+ target = oxcf->starting_buffer_level / 2;
} else {
// TODO(marpan): Add in adjustment based on Q.
// If this keyframe was forced, use a more recent Q estimate.
@@ -235,47 +232,49 @@ static void calc_iframe_target_size(VP9_COMP *cpi) {
// Adjustment up based on q: need to fix.
// kf_boost = kf_boost * kfboost_qadjust(Q) / 100;
// Frame separation adjustment (down).
- if (cpi->rc.frames_since_key < cpi->output_framerate / 2) {
- kf_boost = (int)(kf_boost * cpi->rc.frames_since_key /
- (cpi->output_framerate / 2));
+ if (rc->frames_since_key < cpi->output_framerate / 2) {
+ kf_boost = (int)(kf_boost * rc->frames_since_key /
+ (cpi->output_framerate / 2));
}
kf_boost = (kf_boost < 16) ? 16 : kf_boost;
- target = ((16 + kf_boost) * cpi->rc.per_frame_bandwidth) >> 4;
+ target = ((16 + kf_boost) * rc->per_frame_bandwidth) >> 4;
}
- cpi->rc.active_worst_quality = cpi->rc.worst_quality;
+ rc->active_worst_quality = rc->worst_quality;
+ } else {
+ target = rc->per_frame_bandwidth;
}
- if (cpi->oxcf.rc_max_intra_bitrate_pct) {
- int max_rate = cpi->rc.per_frame_bandwidth
- * cpi->oxcf.rc_max_intra_bitrate_pct / 100;
-
- if (target > max_rate)
- target = max_rate;
+ if (oxcf->rc_max_intra_bitrate_pct) {
+ const int max_rate = rc->per_frame_bandwidth *
+ oxcf->rc_max_intra_bitrate_pct / 100;
+ target = MIN(target, max_rate);
}
- cpi->rc.this_frame_target = target;
+ rc->this_frame_target = target;
}
// Update the buffer level: leaky bucket model.
void vp9_update_buffer_level(VP9_COMP *const cpi, int encoded_frame_size) {
- VP9_COMMON *const cm = &cpi->common;
+ const VP9_COMMON *const cm = &cpi->common;
+ const VP9_CONFIG *oxcf = &cpi->oxcf;
RATE_CONTROL *const rc = &cpi->rc;
+
// Non-viewable frames are a special case and are treated as pure overhead.
if (!cm->show_frame) {
rc->bits_off_target -= encoded_frame_size;
} else {
rc->bits_off_target += rc->av_per_frame_bandwidth - encoded_frame_size;
}
+
// Clip the buffer level to the maximum specified buffer size.
- if (rc->bits_off_target > cpi->oxcf.maximum_buffer_size) {
- rc->bits_off_target = cpi->oxcf.maximum_buffer_size;
- }
- rc->buffer_level = rc->bits_off_target;
+ rc->buffer_level = MIN(rc->bits_off_target, oxcf->maximum_buffer_size);
}
int vp9_drop_frame(VP9_COMP *const cpi) {
+ const VP9_CONFIG *oxcf = &cpi->oxcf;
RATE_CONTROL *const rc = &cpi->rc;
- if (!cpi->oxcf.drop_frames_water_mark) {
+
+ if (!oxcf->drop_frames_water_mark) {
return 0;
} else {
if (rc->buffer_level < 0) {
@@ -284,8 +283,8 @@ int vp9_drop_frame(VP9_COMP *const cpi) {
} else {
// If buffer is below drop_mark, for now just drop every other frame
// (starting with the next frame) until it increases back over drop_mark.
- int drop_mark = (int)(cpi->oxcf.drop_frames_water_mark *
- cpi->oxcf.optimal_buffer_level / 100);
+ int drop_mark = (int)(oxcf->drop_frames_water_mark *
+ oxcf->optimal_buffer_level / 100);
if ((rc->buffer_level > drop_mark) &&
(rc->decimation_factor > 0)) {
--rc->decimation_factor;
@@ -310,14 +309,14 @@ int vp9_drop_frame(VP9_COMP *const cpi) {
}
// Adjust active_worst_quality level based on buffer level.
-static int adjust_active_worst_quality_from_buffer_level(const VP9_COMP *cpi) {
+static int adjust_active_worst_quality_from_buffer_level(const VP9_CONFIG *oxcf,
+ const RATE_CONTROL *rc) {
// Adjust active_worst_quality: If buffer is above the optimal/target level,
// bring active_worst_quality down depending on fullness over buffer.
// If buffer is below the optimal level, let the active_worst_quality go from
// ambient Q (at buffer = optimal level) to worst_quality level
// (at buffer = critical level).
- const RATE_CONTROL *const rc = &cpi->rc;
- const VP9_CONFIG *const oxcf = &cpi->oxcf;
+
int active_worst_quality = rc->active_worst_quality;
// Maximum limit for down adjustment, ~20%.
int max_adjustment_down = active_worst_quality / 5;
@@ -354,31 +353,23 @@ static int adjust_active_worst_quality_from_buffer_level(const VP9_COMP *cpi) {
}
// Adjust target frame size with respect to the buffering constraints:
-static int target_size_from_buffer_level(const VP9_COMP *cpi) {
- const RATE_CONTROL *const rc = &cpi->rc;
- const VP9_CONFIG *const oxcf = &cpi->oxcf;
- int this_frame_target = cpi->rc.this_frame_target;
- int percent_low = 0;
- int percent_high = 0;
- int one_percent_bits = (int)(1 + oxcf->optimal_buffer_level / 100);
- if (rc->buffer_level < oxcf->optimal_buffer_level) {
- percent_low = (int)((oxcf->optimal_buffer_level - rc->buffer_level) /
- one_percent_bits);
- if (percent_low > oxcf->under_shoot_pct)
- percent_low = oxcf->under_shoot_pct;
+static int target_size_from_buffer_level(const VP9_CONFIG *oxcf,
+ const RATE_CONTROL *rc) {
+ int target = rc->this_frame_target;
+ const int64_t diff = oxcf->optimal_buffer_level - rc->buffer_level;
+ const int one_pct_bits = 1 + oxcf->optimal_buffer_level / 100;
+ if (diff > 0) {
// Lower the target bandwidth for this frame.
- this_frame_target -= (this_frame_target * percent_low) / 200;
- } else if (rc->buffer_level > oxcf->optimal_buffer_level) {
- percent_high = (int)((rc->buffer_level - oxcf->optimal_buffer_level) /
- one_percent_bits);
- if (percent_high > oxcf->over_shoot_pct)
- percent_high = oxcf->over_shoot_pct;
-
+ const int pct_low = MIN(diff / one_pct_bits, oxcf->under_shoot_pct);
+ target -= (target * pct_low) / 200;
+ } else if (diff < 0) {
// Increase the target bandwidth for this frame.
- this_frame_target += (this_frame_target * percent_high) / 200;
+ const int pct_high = MIN(-diff / one_pct_bits, oxcf->over_shoot_pct);
+ target += (target * pct_high) / 200;
}
- return this_frame_target;
+
+ return target;
}
static void calc_pframe_target_size(VP9_COMP *const cpi) {
@@ -400,10 +391,10 @@ static void calc_pframe_target_size(VP9_COMP *const cpi) {
// For now, use: cpi->rc.av_per_frame_bandwidth / 16:
min_frame_target = MAX(rc->av_per_frame_bandwidth >> 4,
FRAME_OVERHEAD_BITS);
- rc->this_frame_target = target_size_from_buffer_level(cpi);
+ rc->this_frame_target = target_size_from_buffer_level(oxcf, rc);
// Adjust qp-max based on buffer level.
rc->active_worst_quality =
- adjust_active_worst_quality_from_buffer_level(cpi);
+ adjust_active_worst_quality_from_buffer_level(oxcf, rc);
}
}
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index fa6b362d4..3c1bd392d 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -419,18 +419,12 @@ static void model_rd_for_sb(VP9_COMP *cpi, BLOCK_SIZE bsize,
struct macroblock_plane *const p = &x->plane[i];
struct macroblockd_plane *const pd = &xd->plane[i];
const BLOCK_SIZE bs = get_plane_block_size(bsize, pd);
- int rate;
- int64_t dist;
(void) cpi->fn_ptr[bs].vf(p->src.buf, p->src.stride,
pd->dst.buf, pd->dst.stride, &sse);
if (i == 0)
x->pred_sse[ref] = sse;
- // sse works better than var, since there is no dc prediction used
- model_rd_from_var_lapndz(sse, 1 << num_pels_log2_lookup[bs],
- pd->dequant[1] >> 3, &rate, &dist);
- rate_sum += rate;
- dist_sum += (int)dist;
+ dist_sum += (int)sse;
}
*out_rate_sum = rate_sum;
@@ -2276,41 +2270,38 @@ static void setup_pred_block(const MACROBLOCKD *xd,
void vp9_setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x,
const TileInfo *const tile,
- int idx, MV_REFERENCE_FRAME frame_type,
+ MV_REFERENCE_FRAME ref_frame,
BLOCK_SIZE block_size,
int mi_row, int mi_col,
int_mv frame_nearest_mv[MAX_REF_FRAMES],
int_mv frame_near_mv[MAX_REF_FRAMES],
struct buf_2d yv12_mb[4][MAX_MB_PLANE]) {
- VP9_COMMON *cm = &cpi->common;
- YV12_BUFFER_CONFIG *yv12 = &cm->yv12_fb[cpi->common.ref_frame_map[idx]];
+ const VP9_COMMON *cm = &cpi->common;
+ const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = &xd->mi_8x8[0]->mbmi;
- const struct scale_factors *const sf = &cm->frame_refs[frame_type - 1].sf;
-
+ MODE_INFO *const mi = xd->mi_8x8[0];
+ int_mv *const candidates = mi->mbmi.ref_mvs[ref_frame];
+ const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf;
// TODO(jkoleszar): Is the UV buffer ever used here? If so, need to make this
// use the UV scaling factors.
- setup_pred_block(xd, yv12_mb[frame_type], yv12, mi_row, mi_col, sf, sf);
+ setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, sf, sf);
// Gets an initial list of candidate vectors from neighbours and orders them
- vp9_find_mv_refs(cm, xd, tile, xd->mi_8x8[0],
- xd->last_mi,
- frame_type,
- mbmi->ref_mvs[frame_type], mi_row, mi_col);
+ vp9_find_mv_refs(cm, xd, tile, mi, xd->last_mi, ref_frame, candidates,
+ mi_row, mi_col);
// Candidate refinement carried out at encoder and decoder
- vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv,
- mbmi->ref_mvs[frame_type],
- &frame_nearest_mv[frame_type],
- &frame_near_mv[frame_type]);
+ vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates,
+ &frame_nearest_mv[ref_frame],
+ &frame_near_mv[ref_frame]);
// Further refinement that is encode side only to test the top few candidates
// in full and choose the best as the centre point for subsequent searches.
// The current implementation doesn't support scaling.
if (!vp9_is_scaled(sf) && block_size >= BLOCK_8X8)
- mv_pred(cpi, x, yv12_mb[frame_type][0].buf, yv12->y_stride,
- frame_type, block_size);
+ mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride,
+ ref_frame, block_size);
}
YV12_BUFFER_CONFIG *vp9_get_scaled_ref_frame(VP9_COMP *cpi, int ref_frame) {
@@ -3173,7 +3164,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
x->pred_mv_sad[ref_frame] = INT_MAX;
if (cpi->ref_frame_flags & flag_list[ref_frame]) {
- vp9_setup_buffer_inter(cpi, x, tile, get_ref_frame_idx(cpi, ref_frame),
+ vp9_setup_buffer_inter(cpi, x, tile,
ref_frame, block_size, mi_row, mi_col,
frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb);
}
@@ -3798,7 +3789,7 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) {
if (cpi->ref_frame_flags & flag_list[ref_frame]) {
- vp9_setup_buffer_inter(cpi, x, tile, get_ref_frame_idx(cpi, ref_frame),
+ vp9_setup_buffer_inter(cpi, x, tile,
ref_frame, block_size, mi_row, mi_col,
frame_mv[NEARESTMV], frame_mv[NEARMV],
yv12_mb);
diff --git a/vp9/encoder/vp9_rdopt.h b/vp9/encoder/vp9_rdopt.h
index 696cf6b11..9ac1f5404 100644
--- a/vp9/encoder/vp9_rdopt.h
+++ b/vp9/encoder/vp9_rdopt.h
@@ -39,7 +39,7 @@ void vp9_initialize_me_consts(VP9_COMP *cpi, int qindex);
void vp9_setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x,
const TileInfo *const tile,
- int idx, MV_REFERENCE_FRAME frame_type,
+ MV_REFERENCE_FRAME ref_frame,
BLOCK_SIZE block_size,
int mi_row, int mi_col,
int_mv frame_nearest_mv[MAX_REF_FRAMES],
diff --git a/vp9/encoder/vp9_temporal_filter.c b/vp9/encoder/vp9_temporal_filter.c
index 876219268..c2eea0aaa 100644
--- a/vp9/encoder/vp9_temporal_filter.c
+++ b/vp9/encoder/vp9_temporal_filter.c
@@ -227,7 +227,7 @@ static void temporal_filter_iterate_c(VP9_COMP *cpi,
for (mb_row = 0; mb_row < mb_rows; mb_row++) {
#if ALT_REF_MC_ENABLED
// Source frames are extended to 16 pixels. This is different than
- // L/A/G reference frames that have a border of 32 (VP9BORDERINPIXELS)
+ // L/A/G reference frames that have a border of 32 (VP9ENCBORDERINPIXELS)
// A 6/8 tap filter is used for motion search. This requires 2 pixels
// before and 3 pixels after. So the largest Y mv on a border would
// then be 16 - VP9_INTERP_EXTEND. The UV blocks are half the size of the
diff --git a/vp9/vp9_iface_common.h b/vp9/vp9_iface_common.h
index ed0122c1b..c50f9a490 100644
--- a/vp9/vp9_iface_common.h
+++ b/vp9/vp9_iface_common.h
@@ -29,7 +29,7 @@ static void yuvconfig2image(vpx_image_t *img, const YV12_BUFFER_CONFIG *yv12,
img->fmt = VPX_IMG_FMT_I420;
}
img->w = yv12->y_stride;
- img->h = ALIGN_POWER_OF_TWO(yv12->y_height + 2 * VP9BORDERINPIXELS, 3);
+ img->h = ALIGN_POWER_OF_TWO(yv12->y_height + 2 * VP9_ENC_BORDER_IN_PIXELS, 3);
img->d_w = yv12->y_crop_width;
img->d_h = yv12->y_crop_height;
img->x_chroma_shift = yv12->uv_width < yv12->y_width;
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-12 09:25:25 +0000