if (x->skip_encode && !is_inter_block(xd->mi[0])) {
// TODO(jingning): tune the model to better capture the distortion.
- const int64_t p =
+ const int64_t mean_quant_error =
(pd->dequant[1] * pd->dequant[1] * (1 << ss_txfrm_size)) >>
#if CONFIG_VP9_HIGHBITDEPTH
(shift + 2 + (bd - 8) * 2);
#else
(shift + 2);
#endif // CONFIG_VP9_HIGHBITDEPTH
- *out_dist += (p >> 4);
- *out_sse += p;
+ *out_dist += (mean_quant_error >> 4);
+ *out_sse += mean_quant_error;
}
} else {
const BLOCK_SIZE tx_bsize = txsize_to_bsize[tx_size];
const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
const int16_t *const diff =
&p->src_diff[4 * (blk_row * diff_stride + blk_col)];
- const int enable_trellis_opt =
+ const int use_trellis_opt =
do_trellis_opt(pd, diff, diff_stride, blk_row, blk_col, plane_bsize,
tx_size, &encode_b_arg);
// full forward transform and quantization
vp9_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, tx_size);
- if (enable_trellis_opt)
- vp9_optimize_b(x, plane, block, tx_size, coeff_ctx);
+ if (use_trellis_opt) vp9_optimize_b(x, plane, block, tx_size, coeff_ctx);
dist_block(args->cpi, x, plane, plane_bsize, block, blk_row, blk_col,
tx_size, &dist, &sse, recon, sse_calc_done);
} else if (skip_txfm_flag == SKIP_TXFM_AC_ONLY) {
if (ref_best_rd < 0) is_cost_valid = 0;
if (is_inter_block(mi) && is_cost_valid) {
- int plane;
for (plane = 1; plane < MAX_MB_PLANE; ++plane)
vp9_subtract_plane(x, bsize, plane);
}
static int64_t rd_pick_best_sub8x8_mode(
VP9_COMP *cpi, MACROBLOCK *x, int_mv *best_ref_mv,
- int_mv *second_best_ref_mv, int64_t best_rd, int *returntotrate,
+ int_mv *second_best_ref_mv, int64_t best_rd_so_far, int *returntotrate,
int *returnyrate, int64_t *returndistortion, int *skippable, int64_t *psse,
int mvthresh, int_mv seg_mvs[4][MAX_REF_FRAMES], BEST_SEG_INFO *bsi_buf,
int filter_idx, int mi_row, int mi_col) {
vp9_zero(*bsi);
- bsi->segment_rd = best_rd;
+ bsi->segment_rd = best_rd_so_far;
bsi->ref_mv[0] = best_ref_mv;
bsi->ref_mv[1] = second_best_ref_mv;
bsi->mvp.as_int = best_ref_mv->as_int;
int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES];
PREDICTION_MODE mode_selected = ZEROMV;
int64_t best_rd = INT64_MAX;
- const int i = idy * 2 + idx;
+ const int block = idy * 2 + idx;
int ref;
for (ref = 0; ref < 1 + has_second_rf; ++ref) {
const MV_REFERENCE_FRAME frame = mi->ref_frame[ref];
frame_mv[ZEROMV][frame].as_int = 0;
vp9_append_sub8x8_mvs_for_idx(
- cm, xd, i, ref, mi_row, mi_col, &frame_mv[NEARESTMV][frame],
+ cm, xd, block, ref, mi_row, mi_col, &frame_mv[NEARESTMV][frame],
&frame_mv[NEARMV][frame], mbmi_ext->mode_context);
}
struct buf_2d orig_pre[2];
mode_idx = INTER_OFFSET(this_mode);
- bsi->rdstat[i][mode_idx].brdcost = INT64_MAX;
+ bsi->rdstat[block][mode_idx].brdcost = INT64_MAX;
if (!(inter_mode_mask & (1 << this_mode))) continue;
if (!check_best_zero_mv(cpi, mbmi_ext->mode_context, frame_mv,
continue;
memcpy(orig_pre, pd->pre, sizeof(orig_pre));
- memcpy(bsi->rdstat[i][mode_idx].ta, t_above,
- sizeof(bsi->rdstat[i][mode_idx].ta));
- memcpy(bsi->rdstat[i][mode_idx].tl, t_left,
- sizeof(bsi->rdstat[i][mode_idx].tl));
+ memcpy(bsi->rdstat[block][mode_idx].ta, t_above,
+ sizeof(bsi->rdstat[block][mode_idx].ta));
+ memcpy(bsi->rdstat[block][mode_idx].tl, t_left,
+ sizeof(bsi->rdstat[block][mode_idx].tl));
// motion search for newmv (single predictor case only)
if (!has_second_rf && this_mode == NEWMV &&
- seg_mvs[i][mi->ref_frame[0]].as_int == INVALID_MV) {
+ seg_mvs[block][mi->ref_frame[0]].as_int == INVALID_MV) {
MV *const new_mv = &mode_mv[NEWMV][0].as_mv;
int step_param = 0;
uint32_t bestsme = UINT_MAX;
if (cpi->oxcf.mode != BEST) {
// use previous block's result as next block's MV predictor.
- if (i > 0) {
- bsi->mvp.as_int = mi->bmi[i - 1].as_mv[0].as_int;
- if (i == 2) bsi->mvp.as_int = mi->bmi[i - 2].as_mv[0].as_int;
+ if (block > 0) {
+ bsi->mvp.as_int = mi->bmi[block - 1].as_mv[0].as_int;
+ if (block == 2)
+ bsi->mvp.as_int = mi->bmi[block - 2].as_mv[0].as_int;
}
}
- if (i == 0)
+ if (block == 0)
max_mv = x->max_mv_context[mi->ref_frame[0]];
else
max_mv =
}
// adjust src pointer for this block
- mi_buf_shift(x, i);
+ mi_buf_shift(x, block);
vp9_set_mv_search_range(&x->mv_limits, &bsi->ref_mv[0]->as_mv);
cpi->sf.use_accurate_subpel_search);
// save motion search result for use in compound prediction
- seg_mvs[i][mi->ref_frame[0]].as_mv = *new_mv;
+ seg_mvs[block][mi->ref_frame[0]].as_mv = *new_mv;
}
x->pred_mv[mi->ref_frame[0]] = *new_mv;
}
if (has_second_rf) {
- if (seg_mvs[i][mi->ref_frame[1]].as_int == INVALID_MV ||
- seg_mvs[i][mi->ref_frame[0]].as_int == INVALID_MV)
+ if (seg_mvs[block][mi->ref_frame[1]].as_int == INVALID_MV ||
+ seg_mvs[block][mi->ref_frame[0]].as_int == INVALID_MV)
continue;
}
if (has_second_rf && this_mode == NEWMV &&
mi->interp_filter == EIGHTTAP) {
// adjust src pointers
- mi_buf_shift(x, i);
+ mi_buf_shift(x, block);
if (sf->comp_inter_joint_search_thresh <= bsize) {
int rate_mv;
joint_motion_search(cpi, x, bsize, frame_mv[this_mode], mi_row,
- mi_col, seg_mvs[i], &rate_mv);
- seg_mvs[i][mi->ref_frame[0]].as_int =
+ mi_col, seg_mvs[block], &rate_mv);
+ seg_mvs[block][mi->ref_frame[0]].as_int =
frame_mv[this_mode][mi->ref_frame[0]].as_int;
- seg_mvs[i][mi->ref_frame[1]].as_int =
+ seg_mvs[block][mi->ref_frame[1]].as_int =
frame_mv[this_mode][mi->ref_frame[1]].as_int;
}
// restore src pointers
mi_buf_restore(x, orig_src, orig_pre);
}
- bsi->rdstat[i][mode_idx].brate = set_and_cost_bmi_mvs(
- cpi, x, xd, i, this_mode, mode_mv[this_mode], frame_mv, seg_mvs[i],
- bsi->ref_mv, x->nmvjointcost, x->mvcost);
+ bsi->rdstat[block][mode_idx].brate = set_and_cost_bmi_mvs(
+ cpi, x, xd, block, this_mode, mode_mv[this_mode], frame_mv,
+ seg_mvs[block], bsi->ref_mv, x->nmvjointcost, x->mvcost);
for (ref = 0; ref < 1 + has_second_rf; ++ref) {
- bsi->rdstat[i][mode_idx].mvs[ref].as_int =
+ bsi->rdstat[block][mode_idx].mvs[ref].as_int =
mode_mv[this_mode][ref].as_int;
if (num_4x4_blocks_wide > 1)
- bsi->rdstat[i + 1][mode_idx].mvs[ref].as_int =
+ bsi->rdstat[block + 1][mode_idx].mvs[ref].as_int =
mode_mv[this_mode][ref].as_int;
if (num_4x4_blocks_high > 1)
- bsi->rdstat[i + 2][mode_idx].mvs[ref].as_int =
+ bsi->rdstat[block + 2][mode_idx].mvs[ref].as_int =
mode_mv[this_mode][ref].as_int;
}
for (ref = 0; ref < 1 + has_second_rf; ++ref) {
subpelmv |= mv_has_subpel(&mode_mv[this_mode][ref].as_mv);
have_ref &= mode_mv[this_mode][ref].as_int ==
- ref_bsi->rdstat[i][mode_idx].mvs[ref].as_int;
+ ref_bsi->rdstat[block][mode_idx].mvs[ref].as_int;
}
if (filter_idx > 1 && !subpelmv && !have_ref) {
have_ref = 1;
for (ref = 0; ref < 1 + has_second_rf; ++ref)
have_ref &= mode_mv[this_mode][ref].as_int ==
- ref_bsi->rdstat[i][mode_idx].mvs[ref].as_int;
+ ref_bsi->rdstat[block][mode_idx].mvs[ref].as_int;
}
if (!subpelmv && have_ref &&
- ref_bsi->rdstat[i][mode_idx].brdcost < INT64_MAX) {
- memcpy(&bsi->rdstat[i][mode_idx], &ref_bsi->rdstat[i][mode_idx],
- sizeof(SEG_RDSTAT));
+ ref_bsi->rdstat[block][mode_idx].brdcost < INT64_MAX) {
+ memcpy(&bsi->rdstat[block][mode_idx],
+ &ref_bsi->rdstat[block][mode_idx], sizeof(SEG_RDSTAT));
if (num_4x4_blocks_wide > 1)
- bsi->rdstat[i + 1][mode_idx].eobs =
- ref_bsi->rdstat[i + 1][mode_idx].eobs;
+ bsi->rdstat[block + 1][mode_idx].eobs =
+ ref_bsi->rdstat[block + 1][mode_idx].eobs;
if (num_4x4_blocks_high > 1)
- bsi->rdstat[i + 2][mode_idx].eobs =
- ref_bsi->rdstat[i + 2][mode_idx].eobs;
+ bsi->rdstat[block + 2][mode_idx].eobs =
+ ref_bsi->rdstat[block + 2][mode_idx].eobs;
- if (bsi->rdstat[i][mode_idx].brdcost < best_rd) {
+ if (bsi->rdstat[block][mode_idx].brdcost < best_rd) {
mode_selected = this_mode;
- best_rd = bsi->rdstat[i][mode_idx].brdcost;
+ best_rd = bsi->rdstat[block][mode_idx].brdcost;
}
continue;
}
}
- bsi->rdstat[i][mode_idx].brdcost = encode_inter_mb_segment(
- cpi, x, bsi->segment_rd - this_segment_rd, i,
- &bsi->rdstat[i][mode_idx].byrate, &bsi->rdstat[i][mode_idx].bdist,
- &bsi->rdstat[i][mode_idx].bsse, bsi->rdstat[i][mode_idx].ta,
- bsi->rdstat[i][mode_idx].tl, mi_row, mi_col);
- if (bsi->rdstat[i][mode_idx].brdcost < INT64_MAX) {
- bsi->rdstat[i][mode_idx].brdcost +=
- RDCOST(x->rdmult, x->rddiv, bsi->rdstat[i][mode_idx].brate, 0);
- bsi->rdstat[i][mode_idx].brate += bsi->rdstat[i][mode_idx].byrate;
- bsi->rdstat[i][mode_idx].eobs = p->eobs[i];
+ bsi->rdstat[block][mode_idx].brdcost = encode_inter_mb_segment(
+ cpi, x, bsi->segment_rd - this_segment_rd, block,
+ &bsi->rdstat[block][mode_idx].byrate,
+ &bsi->rdstat[block][mode_idx].bdist,
+ &bsi->rdstat[block][mode_idx].bsse, bsi->rdstat[block][mode_idx].ta,
+ bsi->rdstat[block][mode_idx].tl, mi_row, mi_col);
+ if (bsi->rdstat[block][mode_idx].brdcost < INT64_MAX) {
+ bsi->rdstat[block][mode_idx].brdcost += RDCOST(
+ x->rdmult, x->rddiv, bsi->rdstat[block][mode_idx].brate, 0);
+ bsi->rdstat[block][mode_idx].brate +=
+ bsi->rdstat[block][mode_idx].byrate;
+ bsi->rdstat[block][mode_idx].eobs = p->eobs[block];
if (num_4x4_blocks_wide > 1)
- bsi->rdstat[i + 1][mode_idx].eobs = p->eobs[i + 1];
+ bsi->rdstat[block + 1][mode_idx].eobs = p->eobs[block + 1];
if (num_4x4_blocks_high > 1)
- bsi->rdstat[i + 2][mode_idx].eobs = p->eobs[i + 2];
+ bsi->rdstat[block + 2][mode_idx].eobs = p->eobs[block + 2];
}
- if (bsi->rdstat[i][mode_idx].brdcost < best_rd) {
+ if (bsi->rdstat[block][mode_idx].brdcost < best_rd) {
mode_selected = this_mode;
- best_rd = bsi->rdstat[i][mode_idx].brdcost;
+ best_rd = bsi->rdstat[block][mode_idx].brdcost;
}
} /*for each 4x4 mode*/
if (best_rd == INT64_MAX) {
int iy, midx;
- for (iy = i + 1; iy < 4; ++iy)
+ for (iy = block + 1; iy < 4; ++iy)
for (midx = 0; midx < INTER_MODES; ++midx)
bsi->rdstat[iy][midx].brdcost = INT64_MAX;
bsi->segment_rd = INT64_MAX;
}
mode_idx = INTER_OFFSET(mode_selected);
- memcpy(t_above, bsi->rdstat[i][mode_idx].ta, sizeof(t_above));
- memcpy(t_left, bsi->rdstat[i][mode_idx].tl, sizeof(t_left));
+ memcpy(t_above, bsi->rdstat[block][mode_idx].ta, sizeof(t_above));
+ memcpy(t_left, bsi->rdstat[block][mode_idx].tl, sizeof(t_left));
- set_and_cost_bmi_mvs(cpi, x, xd, i, mode_selected, mode_mv[mode_selected],
- frame_mv, seg_mvs[i], bsi->ref_mv, x->nmvjointcost,
- x->mvcost);
+ set_and_cost_bmi_mvs(cpi, x, xd, block, mode_selected,
+ mode_mv[mode_selected], frame_mv, seg_mvs[block],
+ bsi->ref_mv, x->nmvjointcost, x->mvcost);
- br += bsi->rdstat[i][mode_idx].brate;
- bd += bsi->rdstat[i][mode_idx].bdist;
- block_sse += bsi->rdstat[i][mode_idx].bsse;
- segmentyrate += bsi->rdstat[i][mode_idx].byrate;
- this_segment_rd += bsi->rdstat[i][mode_idx].brdcost;
+ br += bsi->rdstat[block][mode_idx].brate;
+ bd += bsi->rdstat[block][mode_idx].bdist;
+ block_sse += bsi->rdstat[block][mode_idx].bsse;
+ segmentyrate += bsi->rdstat[block][mode_idx].byrate;
+ this_segment_rd += bsi->rdstat[block][mode_idx].brdcost;
if (this_segment_rd > bsi->segment_rd) {
int iy, midx;
- for (iy = i + 1; iy < 4; ++iy)
+ for (iy = block + 1; iy < 4; ++iy)
for (midx = 0; midx < INTER_MODES; ++midx)
bsi->rdstat[iy][midx].brdcost = INT64_MAX;
bsi->segment_rd = INT64_MAX;
// update the coding decisions
for (k = 0; k < 4; ++k) bsi->modes[k] = mi->bmi[k].as_mode;
- if (bsi->segment_rd > best_rd) return INT64_MAX;
+ if (bsi->segment_rd > best_rd_so_far) return INT64_MAX;
/* set it to the best */
for (i = 0; i < 4; i++) {
mode_idx = INTER_OFFSET(bsi->modes[i]);
tmp_mv->as_int = INVALID_MV;
if (scaled_ref_frame) {
- int i;
- for (i = 0; i < MAX_MB_PLANE; ++i)
- xd->plane[i].pre[0] = backup_yv12[i];
+ int j;
+ for (j = 0; j < MAX_MB_PLANE; ++j)
+ xd->plane[j].pre[0] = backup_yv12[j];
}
return;
}
int rate2 = 0, rate_y = 0, rate_uv = 0;
int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0;
int skippable = 0;
- int i;
int this_skip2 = 0;
int64_t total_sse = INT_MAX;
int early_term = 0;
: NULL;
if (scaled_ref_frame[ref]) {
- int i;
// Swap out the reference frame for a version that's been scaled to
// match the resolution of the current frame, allowing the existing
// motion search code to be used without additional modifications.
&uv_sse, BLOCK_8X8, tmp_best_rdu)) {
for (ref = 0; ref < 2; ++ref) {
if (scaled_ref_frame[ref]) {
- int i;
for (i = 0; i < MAX_MB_PLANE; ++i)
xd->plane[i].pre[ref] = backup_yv12[ref][i];
}
for (ref = 0; ref < 2; ++ref) {
if (scaled_ref_frame[ref]) {
// Restore the prediction frame pointers to their unscaled versions.
- int i;
for (i = 0; i < MAX_MB_PLANE; ++i)
xd->plane[i].pre[ref] = backup_yv12[ref][i];
}
projects / platform / upstream / libvpx.git / commitdiff