2014-01-10 20:51:20 +01:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2014 The WebM project authors. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license
|
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
|
|
|
* in the file PATENTS. All contributing project authors may
|
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <assert.h>
|
2014-02-28 20:28:34 +01:00
|
|
|
#include <limits.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <stdio.h>
|
2014-01-10 20:51:20 +01:00
|
|
|
|
2014-02-28 20:28:34 +01:00
|
|
|
#include "./vp9_rtcd.h"
|
2015-05-15 20:52:03 +02:00
|
|
|
#include "./vpx_dsp_rtcd.h"
|
2014-02-28 20:28:34 +01:00
|
|
|
|
2015-08-31 23:36:35 +02:00
|
|
|
#include "vpx_dsp/vpx_dsp_common.h"
|
2014-02-28 20:28:34 +01:00
|
|
|
#include "vpx_mem/vpx_mem.h"
|
2015-05-12 04:09:22 +02:00
|
|
|
#include "vpx_ports/mem.h"
|
2014-02-28 20:28:34 +01:00
|
|
|
|
2014-08-19 23:09:57 +02:00
|
|
|
#include "vp9/common/vp9_blockd.h"
|
2014-02-28 20:28:34 +01:00
|
|
|
#include "vp9/common/vp9_common.h"
|
|
|
|
#include "vp9/common/vp9_mvref_common.h"
|
2015-03-23 18:02:42 +01:00
|
|
|
#include "vp9/common/vp9_pred_common.h"
|
2014-01-10 20:51:20 +01:00
|
|
|
#include "vp9/common/vp9_reconinter.h"
|
|
|
|
#include "vp9/common/vp9_reconintra.h"
|
2015-05-22 20:19:51 +02:00
|
|
|
#include "vp9/common/vp9_scan.h"
|
2014-02-28 20:28:34 +01:00
|
|
|
|
2015-03-23 18:02:42 +01:00
|
|
|
#include "vp9/encoder/vp9_cost.h"
|
2014-04-19 03:27:47 +02:00
|
|
|
#include "vp9/encoder/vp9_encoder.h"
|
2014-06-20 19:11:34 +02:00
|
|
|
#include "vp9/encoder/vp9_pickmode.h"
|
2014-01-10 20:51:20 +01:00
|
|
|
#include "vp9/encoder/vp9_ratectrl.h"
|
2014-07-02 21:36:48 +02:00
|
|
|
#include "vp9/encoder/vp9_rd.h"
|
2014-01-10 20:51:20 +01:00
|
|
|
|
2014-08-17 02:15:27 +02:00
|
|
|
typedef struct {
|
|
|
|
uint8_t *data;
|
|
|
|
int stride;
|
|
|
|
int in_use;
|
|
|
|
} PRED_BUFFER;
|
|
|
|
|
2016-01-15 18:35:41 +01:00
|
|
|
static int mv_refs_rt(VP9_COMP *cpi, const VP9_COMMON *cm,
|
|
|
|
const MACROBLOCK *x,
|
2015-06-29 18:27:11 +02:00
|
|
|
const MACROBLOCKD *xd,
|
2014-08-17 02:03:59 +02:00
|
|
|
const TileInfo *const tile,
|
|
|
|
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
|
2016-01-15 18:35:41 +01:00
|
|
|
int_mv *mv_ref_list, int_mv *base_mv,
|
|
|
|
int mi_row, int mi_col, int use_base_mv) {
|
2014-06-24 19:45:31 +02:00
|
|
|
const int *ref_sign_bias = cm->ref_frame_sign_bias;
|
|
|
|
int i, refmv_count = 0;
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
const POSITION *const mv_ref_search = mv_ref_blocks[mi->sb_type];
|
2014-06-24 19:45:31 +02:00
|
|
|
|
|
|
|
int different_ref_found = 0;
|
|
|
|
int context_counter = 0;
|
|
|
|
int const_motion = 0;
|
|
|
|
|
|
|
|
// Blank the reference vector list
|
2015-04-24 05:47:40 +02:00
|
|
|
memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES);
|
2014-06-24 19:45:31 +02:00
|
|
|
|
|
|
|
// The nearest 2 blocks are treated differently
|
|
|
|
// if the size < 8x8 we get the mv from the bmi substructure,
|
|
|
|
// and we also need to keep a mode count.
|
|
|
|
for (i = 0; i < 2; ++i) {
|
|
|
|
const POSITION *const mv_ref = &mv_ref_search[i];
|
|
|
|
if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) {
|
|
|
|
const MODE_INFO *const candidate_mi = xd->mi[mv_ref->col + mv_ref->row *
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi_stride];
|
2014-06-24 19:45:31 +02:00
|
|
|
// Keep counts for entropy encoding.
|
2016-01-20 01:40:20 +01:00
|
|
|
context_counter += mode_2_counter[candidate_mi->mode];
|
2014-06-24 19:45:31 +02:00
|
|
|
different_ref_found = 1;
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
if (candidate_mi->ref_frame[0] == ref_frame)
|
2014-10-21 20:04:52 +02:00
|
|
|
ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 0, mv_ref->col, -1),
|
|
|
|
refmv_count, mv_ref_list, Done);
|
2014-06-24 19:45:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const_motion = 1;
|
|
|
|
|
|
|
|
// Check the rest of the neighbors in much the same way
|
|
|
|
// as before except we don't need to keep track of sub blocks or
|
|
|
|
// mode counts.
|
|
|
|
for (; i < MVREF_NEIGHBOURS && !refmv_count; ++i) {
|
|
|
|
const POSITION *const mv_ref = &mv_ref_search[i];
|
|
|
|
if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) {
|
2016-01-20 01:40:20 +01:00
|
|
|
const MODE_INFO *const candidate_mi = xd->mi[mv_ref->col + mv_ref->row *
|
|
|
|
xd->mi_stride];
|
2014-06-24 19:45:31 +02:00
|
|
|
different_ref_found = 1;
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
if (candidate_mi->ref_frame[0] == ref_frame)
|
|
|
|
ADD_MV_REF_LIST(candidate_mi->mv[0], refmv_count, mv_ref_list, Done);
|
2014-06-24 19:45:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Since we couldn't find 2 mvs from the same reference frame
|
|
|
|
// go back through the neighbors and find motion vectors from
|
|
|
|
// different reference frames.
|
|
|
|
if (different_ref_found && !refmv_count) {
|
|
|
|
for (i = 0; i < MVREF_NEIGHBOURS; ++i) {
|
|
|
|
const POSITION *mv_ref = &mv_ref_search[i];
|
|
|
|
if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) {
|
2016-01-20 01:40:20 +01:00
|
|
|
const MODE_INFO *const candidate_mi = xd->mi[mv_ref->col + mv_ref->row
|
|
|
|
* xd->mi_stride];
|
2014-06-24 19:45:31 +02:00
|
|
|
|
|
|
|
// If the candidate is INTRA we don't want to consider its mv.
|
2016-01-20 01:40:20 +01:00
|
|
|
IF_DIFF_REF_FRAME_ADD_MV(candidate_mi, ref_frame, ref_sign_bias,
|
2014-10-21 20:04:52 +02:00
|
|
|
refmv_count, mv_ref_list, Done);
|
2014-06-24 19:45:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-01-15 18:35:41 +01:00
|
|
|
if (use_base_mv &&
|
|
|
|
!cpi->svc.layer_context[cpi->svc.temporal_layer_id].is_key_frame &&
|
|
|
|
ref_frame == LAST_FRAME) {
|
|
|
|
// Get base layer mv.
|
|
|
|
MV_REF *candidate =
|
|
|
|
&cm->prev_frame->mvs[(mi_col>>1) + (mi_row>>1) * (cm->mi_cols>>1)];
|
|
|
|
if (candidate->mv[0].as_int != INVALID_MV) {
|
2016-01-22 00:13:10 +01:00
|
|
|
base_mv->as_mv.row = (candidate->mv[0].as_mv.row * 2);
|
|
|
|
base_mv->as_mv.col = (candidate->mv[0].as_mv.col * 2);
|
2016-01-15 18:35:41 +01:00
|
|
|
clamp_mv_ref(&base_mv->as_mv, xd);
|
|
|
|
} else {
|
|
|
|
base_mv->as_int = INVALID_MV;
|
|
|
|
}
|
|
|
|
}
|
2014-06-24 19:45:31 +02:00
|
|
|
|
|
|
|
Done:
|
|
|
|
|
2015-06-29 18:27:11 +02:00
|
|
|
x->mbmi_ext->mode_context[ref_frame] = counter_to_context[context_counter];
|
2014-06-24 19:45:31 +02:00
|
|
|
|
|
|
|
// Clamp vectors
|
|
|
|
for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i)
|
|
|
|
clamp_mv_ref(&mv_ref_list[i].as_mv, xd);
|
|
|
|
|
|
|
|
return const_motion;
|
|
|
|
}
|
|
|
|
|
2014-07-03 01:54:53 +02:00
|
|
|
static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE bsize, int mi_row, int mi_col,
|
|
|
|
int_mv *tmp_mv, int *rate_mv,
|
2016-01-15 18:35:41 +01:00
|
|
|
int64_t best_rd_sofar, int use_base_mv) {
|
2014-01-10 20:51:20 +01:00
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
2016-01-20 01:40:20 +01:00
|
|
|
MODE_INFO *mi = xd->mi[0];
|
2014-05-13 18:39:25 +02:00
|
|
|
struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0, 0}};
|
2014-07-03 01:54:53 +02:00
|
|
|
const int step_param = cpi->sf.mv.fullpel_search_step_param;
|
|
|
|
const int sadpb = x->sadperbit16;
|
2014-01-10 20:51:20 +01:00
|
|
|
MV mvp_full;
|
2016-01-20 01:40:20 +01:00
|
|
|
const int ref = mi->ref_frame[0];
|
2015-06-29 18:27:11 +02:00
|
|
|
const MV ref_mv = x->mbmi_ext->ref_mvs[ref][0].as_mv;
|
2016-01-15 18:35:41 +01:00
|
|
|
MV center_mv;
|
2014-07-03 01:54:53 +02:00
|
|
|
int dis;
|
|
|
|
int rate_mode;
|
|
|
|
const int tmp_col_min = x->mv_col_min;
|
|
|
|
const int tmp_col_max = x->mv_col_max;
|
|
|
|
const int tmp_row_min = x->mv_row_min;
|
|
|
|
const int tmp_row_max = x->mv_row_max;
|
|
|
|
int rv = 0;
|
2014-10-07 11:48:08 +02:00
|
|
|
int cost_list[5];
|
2014-01-23 02:10:37 +01:00
|
|
|
const YV12_BUFFER_CONFIG *scaled_ref_frame = vp9_get_scaled_ref_frame(cpi,
|
|
|
|
ref);
|
2014-01-10 20:51:20 +01:00
|
|
|
if (scaled_ref_frame) {
|
|
|
|
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.
|
|
|
|
for (i = 0; i < MAX_MB_PLANE; i++)
|
|
|
|
backup_yv12[i] = xd->plane[i].pre[0];
|
2014-03-03 23:58:43 +01:00
|
|
|
vp9_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL);
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
2014-03-03 23:43:06 +01:00
|
|
|
vp9_set_mv_search_range(x, &ref_mv);
|
2014-01-10 20:51:20 +01:00
|
|
|
|
2014-03-21 04:02:08 +01:00
|
|
|
assert(x->mv_best_ref_index[ref] <= 2);
|
|
|
|
if (x->mv_best_ref_index[ref] < 2)
|
2015-06-29 18:27:11 +02:00
|
|
|
mvp_full = x->mbmi_ext->ref_mvs[ref][x->mv_best_ref_index[ref]].as_mv;
|
2014-03-21 04:02:08 +01:00
|
|
|
else
|
2014-05-19 20:43:07 +02:00
|
|
|
mvp_full = x->pred_mv[ref];
|
2014-01-10 20:51:20 +01:00
|
|
|
|
|
|
|
mvp_full.col >>= 3;
|
|
|
|
mvp_full.row >>= 3;
|
|
|
|
|
2016-01-15 18:35:41 +01:00
|
|
|
if (!use_base_mv)
|
|
|
|
center_mv = ref_mv;
|
|
|
|
else
|
|
|
|
center_mv = tmp_mv->as_mv;
|
|
|
|
|
2014-08-27 23:06:30 +02:00
|
|
|
vp9_full_pixel_search(cpi, x, bsize, &mvp_full, step_param, sadpb,
|
2014-10-07 11:48:08 +02:00
|
|
|
cond_cost_list(cpi, cost_list),
|
2016-01-15 18:35:41 +01:00
|
|
|
¢er_mv, &tmp_mv->as_mv, INT_MAX, 0);
|
2014-05-06 02:35:54 +02:00
|
|
|
|
2014-01-10 20:51:20 +01:00
|
|
|
x->mv_col_min = tmp_col_min;
|
|
|
|
x->mv_col_max = tmp_col_max;
|
|
|
|
x->mv_row_min = tmp_row_min;
|
|
|
|
x->mv_row_max = tmp_row_max;
|
|
|
|
|
2014-04-04 03:04:04 +02:00
|
|
|
// calculate the bit cost on motion vector
|
|
|
|
mvp_full.row = tmp_mv->as_mv.row * 8;
|
|
|
|
mvp_full.col = tmp_mv->as_mv.col * 8;
|
2014-07-03 01:54:53 +02:00
|
|
|
|
2014-04-04 03:04:04 +02:00
|
|
|
*rate_mv = vp9_mv_bit_cost(&mvp_full, &ref_mv,
|
|
|
|
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
|
2014-01-10 20:51:20 +01:00
|
|
|
|
2015-06-29 18:27:11 +02:00
|
|
|
rate_mode = cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref]]
|
2014-07-03 01:54:53 +02:00
|
|
|
[INTER_OFFSET(NEWMV)];
|
|
|
|
rv = !(RDCOST(x->rdmult, x->rddiv, (*rate_mv + rate_mode), 0) >
|
|
|
|
best_rd_sofar);
|
|
|
|
|
|
|
|
if (rv) {
|
|
|
|
cpi->find_fractional_mv_step(x, &tmp_mv->as_mv, &ref_mv,
|
|
|
|
cpi->common.allow_high_precision_mv,
|
|
|
|
x->errorperbit,
|
|
|
|
&cpi->fn_ptr[bsize],
|
|
|
|
cpi->sf.mv.subpel_force_stop,
|
|
|
|
cpi->sf.mv.subpel_iters_per_step,
|
2014-10-07 11:48:08 +02:00
|
|
|
cond_cost_list(cpi, cost_list),
|
2014-07-03 01:54:53 +02:00
|
|
|
x->nmvjointcost, x->mvcost,
|
2014-07-09 23:50:50 +02:00
|
|
|
&dis, &x->pred_sse[ref], NULL, 0, 0);
|
2015-03-23 18:02:42 +01:00
|
|
|
*rate_mv = vp9_mv_bit_cost(&tmp_mv->as_mv, &ref_mv,
|
|
|
|
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
|
2014-02-14 23:41:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (scaled_ref_frame) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_MB_PLANE; i++)
|
|
|
|
xd->plane[i].pre[0] = backup_yv12[i];
|
|
|
|
}
|
2014-07-03 01:54:53 +02:00
|
|
|
return rv;
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
|
|
|
|
2015-03-25 22:19:29 +01:00
|
|
|
static void block_variance(const uint8_t *src, int src_stride,
|
|
|
|
const uint8_t *ref, int ref_stride,
|
|
|
|
int w, int h, unsigned int *sse, int *sum,
|
|
|
|
int block_size, unsigned int *sse8x8,
|
|
|
|
int *sum8x8, unsigned int *var8x8) {
|
|
|
|
int i, j, k = 0;
|
|
|
|
|
|
|
|
*sse = 0;
|
|
|
|
*sum = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < h; i += block_size) {
|
|
|
|
for (j = 0; j < w; j += block_size) {
|
2015-05-15 20:52:03 +02:00
|
|
|
vpx_get8x8var(src + src_stride * i + j, src_stride,
|
2015-03-25 22:19:29 +01:00
|
|
|
ref + ref_stride * i + j, ref_stride,
|
|
|
|
&sse8x8[k], &sum8x8[k]);
|
|
|
|
*sse += sse8x8[k];
|
|
|
|
*sum += sum8x8[k];
|
|
|
|
var8x8[k] = sse8x8[k] - (((unsigned int)sum8x8[k] * sum8x8[k]) >> 6);
|
|
|
|
k++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void calculate_variance(int bw, int bh, TX_SIZE tx_size,
|
|
|
|
unsigned int *sse_i, int *sum_i,
|
|
|
|
unsigned int *var_o, unsigned int *sse_o,
|
|
|
|
int *sum_o) {
|
|
|
|
const BLOCK_SIZE unit_size = txsize_to_bsize[tx_size];
|
|
|
|
const int nw = 1 << (bw - b_width_log2_lookup[unit_size]);
|
|
|
|
const int nh = 1 << (bh - b_height_log2_lookup[unit_size]);
|
|
|
|
int i, j, k = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < nh; i += 2) {
|
|
|
|
for (j = 0; j < nw; j += 2) {
|
|
|
|
sse_o[k] = sse_i[i * nw + j] + sse_i[i * nw + j + 1] +
|
|
|
|
sse_i[(i + 1) * nw + j] + sse_i[(i + 1) * nw + j + 1];
|
|
|
|
sum_o[k] = sum_i[i * nw + j] + sum_i[i * nw + j + 1] +
|
|
|
|
sum_i[(i + 1) * nw + j] + sum_i[(i + 1) * nw + j + 1];
|
|
|
|
var_o[k] = sse_o[k] - (((unsigned int)sum_o[k] * sum_o[k]) >>
|
|
|
|
(b_width_log2_lookup[unit_size] +
|
|
|
|
b_height_log2_lookup[unit_size] + 6));
|
|
|
|
k++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void model_rd_for_sb_y_large(VP9_COMP *cpi, BLOCK_SIZE bsize,
|
|
|
|
MACROBLOCK *x, MACROBLOCKD *xd,
|
|
|
|
int *out_rate_sum, int64_t *out_dist_sum,
|
|
|
|
unsigned int *var_y, unsigned int *sse_y,
|
|
|
|
int mi_row, int mi_col, int *early_term) {
|
|
|
|
// Note our transform coeffs are 8 times an orthogonal transform.
|
|
|
|
// Hence quantizer step is also 8 times. To get effective quantizer
|
|
|
|
// we need to divide by 8 before sending to modeling function.
|
|
|
|
unsigned int sse;
|
|
|
|
int rate;
|
|
|
|
int64_t dist;
|
|
|
|
struct macroblock_plane *const p = &x->plane[0];
|
|
|
|
struct macroblockd_plane *const pd = &xd->plane[0];
|
|
|
|
const uint32_t dc_quant = pd->dequant[0];
|
|
|
|
const uint32_t ac_quant = pd->dequant[1];
|
|
|
|
const int64_t dc_thr = dc_quant * dc_quant >> 6;
|
|
|
|
const int64_t ac_thr = ac_quant * ac_quant >> 6;
|
|
|
|
unsigned int var;
|
|
|
|
int sum;
|
|
|
|
int skip_dc = 0;
|
|
|
|
|
|
|
|
const int bw = b_width_log2_lookup[bsize];
|
|
|
|
const int bh = b_height_log2_lookup[bsize];
|
|
|
|
const int num8x8 = 1 << (bw + bh - 2);
|
|
|
|
unsigned int sse8x8[64] = {0};
|
|
|
|
int sum8x8[64] = {0};
|
|
|
|
unsigned int var8x8[64] = {0};
|
|
|
|
TX_SIZE tx_size;
|
|
|
|
int i, k;
|
|
|
|
|
|
|
|
// Calculate variance for whole partition, and also save 8x8 blocks' variance
|
|
|
|
// to be used in following transform skipping test.
|
|
|
|
block_variance(p->src.buf, p->src.stride, pd->dst.buf, pd->dst.stride,
|
|
|
|
4 << bw, 4 << bh, &sse, &sum, 8, sse8x8, sum8x8, var8x8);
|
|
|
|
var = sse - (((int64_t)sum * sum) >> (bw + bh + 4));
|
|
|
|
|
|
|
|
*var_y = var;
|
|
|
|
*sse_y = sse;
|
|
|
|
|
|
|
|
if (cpi->common.tx_mode == TX_MODE_SELECT) {
|
|
|
|
if (sse > (var << 2))
|
2015-08-18 03:19:22 +02:00
|
|
|
tx_size = VPXMIN(max_txsize_lookup[bsize],
|
|
|
|
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
|
2015-03-25 22:19:29 +01:00
|
|
|
else
|
|
|
|
tx_size = TX_8X8;
|
|
|
|
|
2015-05-29 02:21:00 +02:00
|
|
|
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ &&
|
2016-01-20 01:40:20 +01:00
|
|
|
cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id))
|
2015-05-29 02:21:00 +02:00
|
|
|
tx_size = TX_8X8;
|
|
|
|
else if (tx_size > TX_16X16)
|
|
|
|
tx_size = TX_16X16;
|
2015-03-25 22:19:29 +01:00
|
|
|
} else {
|
2015-08-18 03:19:22 +02:00
|
|
|
tx_size = VPXMIN(max_txsize_lookup[bsize],
|
|
|
|
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
|
2015-03-25 22:19:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(tx_size >= TX_8X8);
|
2016-01-20 01:40:20 +01:00
|
|
|
xd->mi[0]->tx_size = tx_size;
|
2015-03-25 22:19:29 +01:00
|
|
|
|
|
|
|
// Evaluate if the partition block is a skippable block in Y plane.
|
|
|
|
{
|
|
|
|
unsigned int sse16x16[16] = {0};
|
|
|
|
int sum16x16[16] = {0};
|
|
|
|
unsigned int var16x16[16] = {0};
|
|
|
|
const int num16x16 = num8x8 >> 2;
|
|
|
|
|
|
|
|
unsigned int sse32x32[4] = {0};
|
|
|
|
int sum32x32[4] = {0};
|
|
|
|
unsigned int var32x32[4] = {0};
|
|
|
|
const int num32x32 = num8x8 >> 4;
|
|
|
|
|
|
|
|
int ac_test = 1;
|
|
|
|
int dc_test = 1;
|
|
|
|
const int num = (tx_size == TX_8X8) ? num8x8 :
|
|
|
|
((tx_size == TX_16X16) ? num16x16 : num32x32);
|
|
|
|
const unsigned int *sse_tx = (tx_size == TX_8X8) ? sse8x8 :
|
|
|
|
((tx_size == TX_16X16) ? sse16x16 : sse32x32);
|
|
|
|
const unsigned int *var_tx = (tx_size == TX_8X8) ? var8x8 :
|
|
|
|
((tx_size == TX_16X16) ? var16x16 : var32x32);
|
|
|
|
|
|
|
|
// Calculate variance if tx_size > TX_8X8
|
|
|
|
if (tx_size >= TX_16X16)
|
|
|
|
calculate_variance(bw, bh, TX_8X8, sse8x8, sum8x8, var16x16, sse16x16,
|
|
|
|
sum16x16);
|
|
|
|
if (tx_size == TX_32X32)
|
|
|
|
calculate_variance(bw, bh, TX_16X16, sse16x16, sum16x16, var32x32,
|
|
|
|
sse32x32, sum32x32);
|
|
|
|
|
|
|
|
// Skipping test
|
2015-07-30 20:52:28 +02:00
|
|
|
x->skip_txfm[0] = SKIP_TXFM_NONE;
|
2015-03-25 22:19:29 +01:00
|
|
|
for (k = 0; k < num; k++)
|
|
|
|
// Check if all ac coefficients can be quantized to zero.
|
|
|
|
if (!(var_tx[k] < ac_thr || var == 0)) {
|
|
|
|
ac_test = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (k = 0; k < num; k++)
|
|
|
|
// Check if dc coefficient can be quantized to zero.
|
|
|
|
if (!(sse_tx[k] - var_tx[k] < dc_thr || sse == var)) {
|
|
|
|
dc_test = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ac_test) {
|
2015-07-30 20:52:28 +02:00
|
|
|
x->skip_txfm[0] = SKIP_TXFM_AC_ONLY;
|
2015-03-25 22:19:29 +01:00
|
|
|
|
|
|
|
if (dc_test)
|
2015-07-30 20:52:28 +02:00
|
|
|
x->skip_txfm[0] = SKIP_TXFM_AC_DC;
|
2015-03-25 22:19:29 +01:00
|
|
|
} else if (dc_test) {
|
|
|
|
skip_dc = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-30 20:52:28 +02:00
|
|
|
if (x->skip_txfm[0] == SKIP_TXFM_AC_DC) {
|
2015-03-25 22:19:29 +01:00
|
|
|
int skip_uv[2] = {0};
|
|
|
|
unsigned int var_uv[2];
|
|
|
|
unsigned int sse_uv[2];
|
|
|
|
|
|
|
|
*out_rate_sum = 0;
|
|
|
|
*out_dist_sum = sse << 4;
|
|
|
|
|
|
|
|
// Transform skipping test in UV planes.
|
|
|
|
for (i = 1; i <= 2; i++) {
|
|
|
|
struct macroblock_plane *const p = &x->plane[i];
|
|
|
|
struct macroblockd_plane *const pd = &xd->plane[i];
|
2016-01-20 01:40:20 +01:00
|
|
|
const TX_SIZE uv_tx_size = get_uv_tx_size(xd->mi[0], pd);
|
2015-03-25 22:19:29 +01:00
|
|
|
const BLOCK_SIZE unit_size = txsize_to_bsize[uv_tx_size];
|
2015-04-04 00:35:31 +02:00
|
|
|
const BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, pd);
|
|
|
|
const int uv_bw = b_width_log2_lookup[uv_bsize];
|
|
|
|
const int uv_bh = b_height_log2_lookup[uv_bsize];
|
|
|
|
const int sf = (uv_bw - b_width_log2_lookup[unit_size]) +
|
|
|
|
(uv_bh - b_height_log2_lookup[unit_size]);
|
2015-03-25 22:19:29 +01:00
|
|
|
const uint32_t uv_dc_thr = pd->dequant[0] * pd->dequant[0] >> (6 - sf);
|
|
|
|
const uint32_t uv_ac_thr = pd->dequant[1] * pd->dequant[1] >> (6 - sf);
|
|
|
|
int j = i - 1;
|
|
|
|
|
|
|
|
vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, i);
|
2015-04-04 00:35:31 +02:00
|
|
|
var_uv[j] = cpi->fn_ptr[uv_bsize].vf(p->src.buf, p->src.stride,
|
|
|
|
pd->dst.buf, pd->dst.stride, &sse_uv[j]);
|
2015-03-25 22:19:29 +01:00
|
|
|
|
2015-04-07 02:53:55 +02:00
|
|
|
if ((var_uv[j] < uv_ac_thr || var_uv[j] == 0) &&
|
|
|
|
(sse_uv[j] - var_uv[j] < uv_dc_thr || sse_uv[j] == var_uv[j]))
|
|
|
|
skip_uv[j] = 1;
|
|
|
|
else
|
|
|
|
break;
|
2015-03-25 22:19:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// If the transform in YUV planes are skippable, the mode search checks
|
|
|
|
// fewer inter modes and doesn't check intra modes.
|
|
|
|
if (skip_uv[0] & skip_uv[1]) {
|
|
|
|
*early_term = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!skip_dc) {
|
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize],
|
|
|
|
dc_quant >> (xd->bd - 5), &rate, &dist);
|
|
|
|
} else {
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize],
|
|
|
|
dc_quant >> 3, &rate, &dist);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize],
|
|
|
|
dc_quant >> 3, &rate, &dist);
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!skip_dc) {
|
|
|
|
*out_rate_sum = rate >> 1;
|
|
|
|
*out_dist_sum = dist << 3;
|
|
|
|
} else {
|
|
|
|
*out_rate_sum = 0;
|
|
|
|
*out_dist_sum = (sse - var) << 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
|
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize],
|
|
|
|
ac_quant >> (xd->bd - 5), &rate, &dist);
|
|
|
|
} else {
|
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize],
|
|
|
|
ac_quant >> 3, &rate, &dist);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize],
|
|
|
|
ac_quant >> 3, &rate, &dist);
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
|
|
|
|
*out_rate_sum += rate;
|
|
|
|
*out_dist_sum += dist << 4;
|
|
|
|
}
|
|
|
|
|
2014-03-07 03:56:50 +01:00
|
|
|
static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize,
|
|
|
|
MACROBLOCK *x, MACROBLOCKD *xd,
|
2014-05-07 19:39:00 +02:00
|
|
|
int *out_rate_sum, int64_t *out_dist_sum,
|
|
|
|
unsigned int *var_y, unsigned int *sse_y) {
|
2014-03-07 03:56:50 +01:00
|
|
|
// Note our transform coeffs are 8 times an orthogonal transform.
|
|
|
|
// Hence quantizer step is also 8 times. To get effective quantizer
|
|
|
|
// we need to divide by 8 before sending to modeling function.
|
|
|
|
unsigned int sse;
|
2014-03-07 19:34:34 +01:00
|
|
|
int rate;
|
|
|
|
int64_t dist;
|
2014-03-07 03:56:50 +01:00
|
|
|
struct macroblock_plane *const p = &x->plane[0];
|
|
|
|
struct macroblockd_plane *const pd = &xd->plane[0];
|
2015-02-19 01:38:08 +01:00
|
|
|
const int64_t dc_thr = p->quant_thred[0] >> 6;
|
|
|
|
const int64_t ac_thr = p->quant_thred[1] >> 6;
|
2014-06-15 21:40:16 +02:00
|
|
|
const uint32_t dc_quant = pd->dequant[0];
|
|
|
|
const uint32_t ac_quant = pd->dequant[1];
|
2014-05-08 03:20:29 +02:00
|
|
|
unsigned int var = cpi->fn_ptr[bsize].vf(p->src.buf, p->src.stride,
|
|
|
|
pd->dst.buf, pd->dst.stride, &sse);
|
2015-03-11 19:31:47 +01:00
|
|
|
int skip_dc = 0;
|
|
|
|
|
2014-05-07 19:39:00 +02:00
|
|
|
*var_y = var;
|
|
|
|
*sse_y = sse;
|
|
|
|
|
2014-06-26 01:53:07 +02:00
|
|
|
if (cpi->common.tx_mode == TX_MODE_SELECT) {
|
|
|
|
if (sse > (var << 2))
|
2016-01-20 01:40:20 +01:00
|
|
|
xd->mi[0]->tx_size =
|
2015-08-18 03:19:22 +02:00
|
|
|
VPXMIN(max_txsize_lookup[bsize],
|
|
|
|
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
|
2014-06-26 01:53:07 +02:00
|
|
|
else
|
2016-01-20 01:40:20 +01:00
|
|
|
xd->mi[0]->tx_size = TX_8X8;
|
2014-10-08 01:36:14 +02:00
|
|
|
|
2015-05-29 02:21:00 +02:00
|
|
|
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ &&
|
2016-01-20 01:40:20 +01:00
|
|
|
cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id))
|
|
|
|
xd->mi[0]->tx_size = TX_8X8;
|
|
|
|
else if (xd->mi[0]->tx_size > TX_16X16)
|
|
|
|
xd->mi[0]->tx_size = TX_16X16;
|
2014-06-26 01:53:07 +02:00
|
|
|
} else {
|
2016-01-20 01:40:20 +01:00
|
|
|
xd->mi[0]->tx_size =
|
2015-08-18 03:19:22 +02:00
|
|
|
VPXMIN(max_txsize_lookup[bsize],
|
|
|
|
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
|
2014-06-26 01:53:07 +02:00
|
|
|
}
|
|
|
|
|
2015-03-05 18:44:18 +01:00
|
|
|
// Evaluate if the partition block is a skippable block in Y plane.
|
|
|
|
{
|
|
|
|
const BLOCK_SIZE unit_size =
|
2016-01-20 01:40:20 +01:00
|
|
|
txsize_to_bsize[xd->mi[0]->tx_size];
|
2015-03-05 18:44:18 +01:00
|
|
|
const unsigned int num_blk_log2 =
|
|
|
|
(b_width_log2_lookup[bsize] - b_width_log2_lookup[unit_size]) +
|
|
|
|
(b_height_log2_lookup[bsize] - b_height_log2_lookup[unit_size]);
|
|
|
|
const unsigned int sse_tx = sse >> num_blk_log2;
|
|
|
|
const unsigned int var_tx = var >> num_blk_log2;
|
|
|
|
|
2015-07-30 20:52:28 +02:00
|
|
|
x->skip_txfm[0] = SKIP_TXFM_NONE;
|
2015-03-05 18:44:18 +01:00
|
|
|
// Check if all ac coefficients can be quantized to zero.
|
|
|
|
if (var_tx < ac_thr || var == 0) {
|
2015-07-30 20:52:28 +02:00
|
|
|
x->skip_txfm[0] = SKIP_TXFM_AC_ONLY;
|
2015-03-05 18:44:18 +01:00
|
|
|
// Check if dc coefficient can be quantized to zero.
|
|
|
|
if (sse_tx - var_tx < dc_thr || sse == var)
|
2015-07-30 20:52:28 +02:00
|
|
|
x->skip_txfm[0] = SKIP_TXFM_AC_DC;
|
2015-03-11 19:31:47 +01:00
|
|
|
} else {
|
|
|
|
if (sse_tx - var_tx < dc_thr || sse == var)
|
|
|
|
skip_dc = 1;
|
2015-03-05 18:44:18 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-30 20:52:28 +02:00
|
|
|
if (x->skip_txfm[0] == SKIP_TXFM_AC_DC) {
|
2015-03-05 18:44:18 +01:00
|
|
|
*out_rate_sum = 0;
|
|
|
|
*out_dist_sum = sse << 4;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-03-11 19:31:47 +01:00
|
|
|
if (!skip_dc) {
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
2015-03-11 19:31:47 +01:00
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize],
|
|
|
|
dc_quant >> (xd->bd - 5), &rate, &dist);
|
|
|
|
} else {
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize],
|
|
|
|
dc_quant >> 3, &rate, &dist);
|
|
|
|
}
|
|
|
|
#else
|
2014-12-12 23:33:52 +01:00
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bsize],
|
2014-09-24 15:36:34 +02:00
|
|
|
dc_quant >> 3, &rate, &dist);
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2015-03-11 19:31:47 +01:00
|
|
|
}
|
2014-09-24 15:36:34 +02:00
|
|
|
|
2015-03-11 19:31:47 +01:00
|
|
|
if (!skip_dc) {
|
|
|
|
*out_rate_sum = rate >> 1;
|
|
|
|
*out_dist_sum = dist << 3;
|
|
|
|
} else {
|
|
|
|
*out_rate_sum = 0;
|
|
|
|
*out_dist_sum = (sse - var) << 4;
|
|
|
|
}
|
2014-06-18 19:50:38 +02:00
|
|
|
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
|
2014-12-12 23:33:52 +01:00
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize],
|
Rework forward txfm/quantization skip system in RTC coding mode
This commit allows more aggressive decision to skip forward
transform and quantization for luma component in RTC coding mode.
The chroma components remains going through the normal coding
routine, since they are not included in the non-RD mode search
process.
It reduces the runtime cost by 2% - 10%. In speed -6,
vidyo1 1000 kbps
16576 b/f, 40.281 dB, 8402 ms -> 16576 b/f, 40.323 dB, 7764 ms
nik720p 1000 kbps
33337 b/f, 38.622 dB, 7473 ms -> 33299 b/f, 38.660 dB, 7314 ms
dark720p 1000 kbps
33330 b/f, 39.785 dB, 13505 ms -> 33325 b/f, 39.714 dB, 13105 ms
The compression performance of speed -6 is improved by 0.44% in
PSNR and 1.31% in SSIM.
Change-Id: Iae9e3738de6255babea734e5897f29118bebc6d7
2014-11-21 21:18:53 +01:00
|
|
|
ac_quant >> (xd->bd - 5), &rate, &dist);
|
2014-09-24 15:36:34 +02:00
|
|
|
} else {
|
2014-12-12 23:33:52 +01:00
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize],
|
Rework forward txfm/quantization skip system in RTC coding mode
This commit allows more aggressive decision to skip forward
transform and quantization for luma component in RTC coding mode.
The chroma components remains going through the normal coding
routine, since they are not included in the non-RD mode search
process.
It reduces the runtime cost by 2% - 10%. In speed -6,
vidyo1 1000 kbps
16576 b/f, 40.281 dB, 8402 ms -> 16576 b/f, 40.323 dB, 7764 ms
nik720p 1000 kbps
33337 b/f, 38.622 dB, 7473 ms -> 33299 b/f, 38.660 dB, 7314 ms
dark720p 1000 kbps
33330 b/f, 39.785 dB, 13505 ms -> 33325 b/f, 39.714 dB, 13105 ms
The compression performance of speed -6 is improved by 0.44% in
PSNR and 1.31% in SSIM.
Change-Id: Iae9e3738de6255babea734e5897f29118bebc6d7
2014-11-21 21:18:53 +01:00
|
|
|
ac_quant >> 3, &rate, &dist);
|
2014-09-24 15:36:34 +02:00
|
|
|
}
|
|
|
|
#else
|
2014-12-12 23:33:52 +01:00
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bsize],
|
Rework forward txfm/quantization skip system in RTC coding mode
This commit allows more aggressive decision to skip forward
transform and quantization for luma component in RTC coding mode.
The chroma components remains going through the normal coding
routine, since they are not included in the non-RD mode search
process.
It reduces the runtime cost by 2% - 10%. In speed -6,
vidyo1 1000 kbps
16576 b/f, 40.281 dB, 8402 ms -> 16576 b/f, 40.323 dB, 7764 ms
nik720p 1000 kbps
33337 b/f, 38.622 dB, 7473 ms -> 33299 b/f, 38.660 dB, 7314 ms
dark720p 1000 kbps
33330 b/f, 39.785 dB, 13505 ms -> 33325 b/f, 39.714 dB, 13105 ms
The compression performance of speed -6 is improved by 0.44% in
PSNR and 1.31% in SSIM.
Change-Id: Iae9e3738de6255babea734e5897f29118bebc6d7
2014-11-21 21:18:53 +01:00
|
|
|
ac_quant >> 3, &rate, &dist);
|
2014-09-24 15:36:34 +02:00
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
|
2014-06-18 19:50:38 +02:00
|
|
|
*out_rate_sum += rate;
|
|
|
|
*out_dist_sum += dist << 4;
|
2014-03-07 03:56:50 +01:00
|
|
|
}
|
|
|
|
|
2015-04-01 02:46:41 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
static void block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist,
|
|
|
|
int *skippable, int64_t *sse, int plane,
|
|
|
|
BLOCK_SIZE bsize, TX_SIZE tx_size) {
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
|
|
|
unsigned int var_y, sse_y;
|
|
|
|
(void)plane;
|
|
|
|
(void)tx_size;
|
|
|
|
model_rd_for_sb_y(cpi, bsize, x, xd, rate, dist, &var_y, &sse_y);
|
|
|
|
*sse = INT_MAX;
|
|
|
|
*skippable = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#else
|
2015-03-23 18:02:42 +01:00
|
|
|
static void block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist,
|
|
|
|
int *skippable, int64_t *sse, int plane,
|
|
|
|
BLOCK_SIZE bsize, TX_SIZE tx_size) {
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
|
|
|
const struct macroblockd_plane *pd = &xd->plane[plane];
|
|
|
|
const struct macroblock_plane *const p = &x->plane[plane];
|
|
|
|
const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
|
|
|
|
const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
|
|
|
|
const int step = 1 << (tx_size << 1);
|
|
|
|
const int block_step = (1 << tx_size);
|
|
|
|
int block = 0, r, c;
|
|
|
|
int shift = tx_size == TX_32X32 ? 0 : 2;
|
|
|
|
const int max_blocks_wide = num_4x4_w + (xd->mb_to_right_edge >= 0 ? 0 :
|
|
|
|
xd->mb_to_right_edge >> (5 + pd->subsampling_x));
|
|
|
|
const int max_blocks_high = num_4x4_h + (xd->mb_to_bottom_edge >= 0 ? 0 :
|
|
|
|
xd->mb_to_bottom_edge >> (5 + pd->subsampling_y));
|
2015-04-03 18:20:25 +02:00
|
|
|
int eob_cost = 0;
|
2015-03-23 18:02:42 +01:00
|
|
|
|
|
|
|
(void)cpi;
|
|
|
|
vp9_subtract_plane(x, bsize, plane);
|
|
|
|
*skippable = 1;
|
|
|
|
// Keep track of the row and column of the blocks we use so that we know
|
|
|
|
// if we are in the unrestricted motion border.
|
|
|
|
for (r = 0; r < max_blocks_high; r += block_step) {
|
|
|
|
for (c = 0; c < num_4x4_w; c += block_step) {
|
|
|
|
if (c < max_blocks_wide) {
|
|
|
|
const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
|
|
|
|
tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
|
|
|
|
tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
|
|
|
|
tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
|
|
|
|
uint16_t *const eob = &p->eobs[block];
|
|
|
|
const int diff_stride = 4 * num_4x4_blocks_wide_lookup[bsize];
|
|
|
|
const int16_t *src_diff;
|
2015-04-01 03:04:45 +02:00
|
|
|
src_diff = &p->src_diff[(r * diff_stride + c) << 2];
|
2015-03-23 18:02:42 +01:00
|
|
|
|
|
|
|
switch (tx_size) {
|
|
|
|
case TX_32X32:
|
2015-07-29 00:57:40 +02:00
|
|
|
vpx_fdct32x32_rd(src_diff, coeff, diff_stride);
|
2015-03-23 18:02:42 +01:00
|
|
|
vp9_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin,
|
|
|
|
p->round_fp, p->quant_fp, p->quant_shift,
|
|
|
|
qcoeff, dqcoeff, pd->dequant, eob,
|
|
|
|
scan_order->scan, scan_order->iscan);
|
|
|
|
break;
|
|
|
|
case TX_16X16:
|
2015-12-11 21:40:53 +01:00
|
|
|
vpx_hadamard_16x16(src_diff, diff_stride, (int16_t *)coeff);
|
2015-03-23 18:02:42 +01:00
|
|
|
vp9_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp,
|
|
|
|
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
|
|
|
|
pd->dequant, eob,
|
|
|
|
scan_order->scan, scan_order->iscan);
|
|
|
|
break;
|
|
|
|
case TX_8X8:
|
2015-12-11 21:40:53 +01:00
|
|
|
vpx_hadamard_8x8(src_diff, diff_stride, (int16_t *)coeff);
|
2015-03-23 18:02:42 +01:00
|
|
|
vp9_quantize_fp(coeff, 64, x->skip_block, p->zbin, p->round_fp,
|
|
|
|
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
|
|
|
|
pd->dequant, eob,
|
|
|
|
scan_order->scan, scan_order->iscan);
|
|
|
|
break;
|
|
|
|
case TX_4X4:
|
|
|
|
x->fwd_txm4x4(src_diff, coeff, diff_stride);
|
|
|
|
vp9_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp,
|
|
|
|
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
|
|
|
|
pd->dequant, eob,
|
|
|
|
scan_order->scan, scan_order->iscan);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
break;
|
|
|
|
}
|
2015-04-01 02:46:41 +02:00
|
|
|
*skippable &= (*eob == 0);
|
2015-04-03 18:20:25 +02:00
|
|
|
eob_cost += 1;
|
2015-04-01 02:46:41 +02:00
|
|
|
}
|
|
|
|
block += step;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*skippable && *sse < INT64_MAX) {
|
2015-04-03 18:20:25 +02:00
|
|
|
*rate = 0;
|
2015-04-01 02:46:41 +02:00
|
|
|
*dist = (*sse << 6) >> shift;
|
|
|
|
*sse = *dist;
|
|
|
|
return;
|
|
|
|
}
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2015-04-01 02:46:41 +02:00
|
|
|
block = 0;
|
|
|
|
*rate = 0;
|
|
|
|
*dist = 0;
|
2015-06-16 21:00:50 +02:00
|
|
|
if (*sse < INT64_MAX)
|
|
|
|
*sse = (*sse << 6) >> shift;
|
2015-04-01 02:46:41 +02:00
|
|
|
for (r = 0; r < max_blocks_high; r += block_step) {
|
|
|
|
for (c = 0; c < num_4x4_w; c += block_step) {
|
|
|
|
if (c < max_blocks_wide) {
|
|
|
|
tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
|
|
|
|
tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
|
|
|
|
tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
|
|
|
|
uint16_t *const eob = &p->eobs[block];
|
2015-03-31 19:57:41 +02:00
|
|
|
|
|
|
|
if (*eob == 1)
|
|
|
|
*rate += (int)abs(qcoeff[0]);
|
|
|
|
else if (*eob > 1)
|
2015-12-11 21:40:53 +01:00
|
|
|
*rate += vpx_satd((const int16_t *)qcoeff, step << 4);
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2015-04-01 02:46:41 +02:00
|
|
|
*dist += vp9_block_error_fp(coeff, dqcoeff, step << 4) >> shift;
|
2015-03-23 18:02:42 +01:00
|
|
|
}
|
|
|
|
block += step;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-11 23:02:34 +02:00
|
|
|
// If skippable is set, rate gets clobbered later.
|
|
|
|
*rate <<= (2 + VP9_PROB_COST_SHIFT);
|
|
|
|
*rate += (eob_cost << VP9_PROB_COST_SHIFT);
|
2015-03-23 18:02:42 +01:00
|
|
|
}
|
2015-04-01 02:46:41 +02:00
|
|
|
#endif
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2015-09-03 23:52:39 +02:00
|
|
|
static void model_rd_for_sb_uv(VP9_COMP *cpi, BLOCK_SIZE plane_bsize,
|
2015-01-21 18:32:23 +01:00
|
|
|
MACROBLOCK *x, MACROBLOCKD *xd,
|
|
|
|
int *out_rate_sum, int64_t *out_dist_sum,
|
2015-09-03 23:52:39 +02:00
|
|
|
unsigned int *var_y, unsigned int *sse_y,
|
|
|
|
int start_plane, int stop_plane) {
|
2015-01-21 18:32:23 +01:00
|
|
|
// Note our transform coeffs are 8 times an orthogonal transform.
|
|
|
|
// Hence quantizer step is also 8 times. To get effective quantizer
|
|
|
|
// we need to divide by 8 before sending to modeling function.
|
|
|
|
unsigned int sse;
|
|
|
|
int rate;
|
|
|
|
int64_t dist;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*out_rate_sum = 0;
|
|
|
|
*out_dist_sum = 0;
|
|
|
|
|
2015-09-03 23:52:39 +02:00
|
|
|
for (i = start_plane; i <= stop_plane; ++i) {
|
2015-01-21 18:32:23 +01:00
|
|
|
struct macroblock_plane *const p = &x->plane[i];
|
|
|
|
struct macroblockd_plane *const pd = &xd->plane[i];
|
|
|
|
const uint32_t dc_quant = pd->dequant[0];
|
|
|
|
const uint32_t ac_quant = pd->dequant[1];
|
2015-09-03 23:52:39 +02:00
|
|
|
const BLOCK_SIZE bs = plane_bsize;
|
2015-01-21 18:32:23 +01:00
|
|
|
unsigned int var;
|
|
|
|
|
|
|
|
if (!x->color_sensitivity[i - 1])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
var = cpi->fn_ptr[bs].vf(p->src.buf, p->src.stride,
|
|
|
|
pd->dst.buf, pd->dst.stride, &sse);
|
|
|
|
*var_y += var;
|
|
|
|
*sse_y += sse;
|
|
|
|
|
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bs],
|
|
|
|
dc_quant >> (xd->bd - 5), &rate, &dist);
|
|
|
|
} else {
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bs],
|
|
|
|
dc_quant >> 3, &rate, &dist);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
vp9_model_rd_from_var_lapndz(sse - var, num_pels_log2_lookup[bs],
|
|
|
|
dc_quant >> 3, &rate, &dist);
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
|
|
|
|
*out_rate_sum += rate >> 1;
|
|
|
|
*out_dist_sum += dist << 3;
|
|
|
|
|
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
|
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bs],
|
|
|
|
ac_quant >> (xd->bd - 5), &rate, &dist);
|
|
|
|
} else {
|
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bs],
|
|
|
|
ac_quant >> 3, &rate, &dist);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
vp9_model_rd_from_var_lapndz(var, num_pels_log2_lookup[bs],
|
|
|
|
ac_quant >> 3, &rate, &dist);
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
|
|
|
|
*out_rate_sum += rate;
|
|
|
|
*out_dist_sum += dist << 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-20 19:11:34 +02:00
|
|
|
static int get_pred_buffer(PRED_BUFFER *p, int len) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (!p[i].in_use) {
|
|
|
|
p[i].in_use = 1;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_pred_buffer(PRED_BUFFER *p) {
|
2014-08-19 00:41:58 +02:00
|
|
|
if (p != NULL)
|
|
|
|
p->in_use = 0;
|
2014-06-20 19:11:34 +02:00
|
|
|
}
|
|
|
|
|
2014-06-30 20:16:48 +02:00
|
|
|
static void encode_breakout_test(VP9_COMP *cpi, MACROBLOCK *x,
|
|
|
|
BLOCK_SIZE bsize, int mi_row, int mi_col,
|
|
|
|
MV_REFERENCE_FRAME ref_frame,
|
|
|
|
PREDICTION_MODE this_mode,
|
|
|
|
unsigned int var_y, unsigned int sse_y,
|
|
|
|
struct buf_2d yv12_mb[][MAX_MB_PLANE],
|
|
|
|
int *rate, int64_t *dist) {
|
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
2016-01-20 01:40:20 +01:00
|
|
|
MODE_INFO *const mi = xd->mi[0];
|
2014-06-30 20:16:48 +02:00
|
|
|
const BLOCK_SIZE uv_size = get_plane_block_size(bsize, &xd->plane[1]);
|
|
|
|
unsigned int var = var_y, sse = sse_y;
|
|
|
|
// Skipping threshold for ac.
|
|
|
|
unsigned int thresh_ac;
|
|
|
|
// Skipping threshold for dc.
|
|
|
|
unsigned int thresh_dc;
|
2015-11-03 20:47:23 +01:00
|
|
|
int motion_low = 1;
|
2016-01-20 01:40:20 +01:00
|
|
|
if (mi->mv[0].as_mv.row > 64 ||
|
|
|
|
mi->mv[0].as_mv.row < -64 ||
|
|
|
|
mi->mv[0].as_mv.col > 64 ||
|
|
|
|
mi->mv[0].as_mv.col < -64)
|
2015-11-03 20:47:23 +01:00
|
|
|
motion_low = 0;
|
2016-01-28 21:10:38 +01:00
|
|
|
if (x->encode_breakout > 0 && motion_low == 1) {
|
2014-06-30 20:16:48 +02:00
|
|
|
// Set a maximum for threshold to avoid big PSNR loss in low bit rate
|
|
|
|
// case. Use extreme low threshold for static frames to limit
|
|
|
|
// skipping.
|
|
|
|
const unsigned int max_thresh = 36000;
|
|
|
|
// The encode_breakout input
|
|
|
|
const unsigned int min_thresh =
|
2015-08-18 03:19:22 +02:00
|
|
|
VPXMIN(((unsigned int)x->encode_breakout << 4), max_thresh);
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
2015-02-13 19:42:57 +01:00
|
|
|
const int shift = (xd->bd << 1) - 16;
|
2014-09-24 15:36:34 +02:00
|
|
|
#endif
|
2014-06-30 20:16:48 +02:00
|
|
|
|
|
|
|
// Calculate threshold according to dequant value.
|
2015-02-13 19:42:57 +01:00
|
|
|
thresh_ac = (xd->plane[0].dequant[1] * xd->plane[0].dequant[1]) >> 3;
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if ((xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) && shift > 0) {
|
|
|
|
thresh_ac = ROUND_POWER_OF_TWO(thresh_ac, shift);
|
|
|
|
}
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2014-06-30 20:16:48 +02:00
|
|
|
thresh_ac = clamp(thresh_ac, min_thresh, max_thresh);
|
|
|
|
|
|
|
|
// Adjust ac threshold according to partition size.
|
|
|
|
thresh_ac >>=
|
2014-10-07 21:30:33 +02:00
|
|
|
8 - (b_width_log2_lookup[bsize] + b_height_log2_lookup[bsize]);
|
2014-06-30 20:16:48 +02:00
|
|
|
|
|
|
|
thresh_dc = (xd->plane[0].dequant[0] * xd->plane[0].dequant[0] >> 6);
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if ((xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) && shift > 0) {
|
|
|
|
thresh_dc = ROUND_POWER_OF_TWO(thresh_dc, shift);
|
|
|
|
}
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2014-06-30 20:16:48 +02:00
|
|
|
} else {
|
|
|
|
thresh_ac = 0;
|
|
|
|
thresh_dc = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Y skipping condition checking for ac and dc.
|
|
|
|
if (var <= thresh_ac && (sse - var) <= thresh_dc) {
|
|
|
|
unsigned int sse_u, sse_v;
|
|
|
|
unsigned int var_u, var_v;
|
2016-01-28 21:10:38 +01:00
|
|
|
unsigned int thresh_ac_uv = thresh_ac;
|
|
|
|
unsigned int thresh_dc_uv = thresh_dc;
|
|
|
|
if (x->sb_is_skin) {
|
|
|
|
thresh_ac_uv = 0;
|
|
|
|
thresh_dc_uv = 0;
|
|
|
|
}
|
2014-06-30 20:16:48 +02:00
|
|
|
|
|
|
|
// Skip UV prediction unless breakout is zero (lossless) to save
|
|
|
|
// computation with low impact on the result
|
|
|
|
if (x->encode_breakout == 0) {
|
|
|
|
xd->plane[1].pre[0] = yv12_mb[ref_frame][1];
|
|
|
|
xd->plane[2].pre[0] = yv12_mb[ref_frame][2];
|
|
|
|
vp9_build_inter_predictors_sbuv(xd, mi_row, mi_col, bsize);
|
|
|
|
}
|
|
|
|
|
|
|
|
var_u = cpi->fn_ptr[uv_size].vf(x->plane[1].src.buf,
|
|
|
|
x->plane[1].src.stride,
|
|
|
|
xd->plane[1].dst.buf,
|
|
|
|
xd->plane[1].dst.stride, &sse_u);
|
|
|
|
|
|
|
|
// U skipping condition checking
|
2016-01-28 21:10:38 +01:00
|
|
|
if (((var_u << 2) <= thresh_ac_uv) && (sse_u - var_u <= thresh_dc_uv)) {
|
2014-06-30 20:16:48 +02:00
|
|
|
var_v = cpi->fn_ptr[uv_size].vf(x->plane[2].src.buf,
|
|
|
|
x->plane[2].src.stride,
|
|
|
|
xd->plane[2].dst.buf,
|
|
|
|
xd->plane[2].dst.stride, &sse_v);
|
|
|
|
|
|
|
|
// V skipping condition checking
|
2016-01-28 21:10:38 +01:00
|
|
|
if (((var_v << 2) <= thresh_ac_uv) && (sse_v - var_v <= thresh_dc_uv)) {
|
2014-06-30 20:16:48 +02:00
|
|
|
x->skip = 1;
|
|
|
|
|
|
|
|
// The cost of skip bit needs to be added.
|
2015-06-29 18:27:11 +02:00
|
|
|
*rate = cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]]
|
2014-08-17 02:03:59 +02:00
|
|
|
[INTER_OFFSET(this_mode)];
|
2014-06-30 20:16:48 +02:00
|
|
|
|
|
|
|
// More on this part of rate
|
|
|
|
// rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
|
|
|
|
|
|
|
|
// Scaling factor for SSE from spatial domain to frequency
|
|
|
|
// domain is 16. Adjust distortion accordingly.
|
|
|
|
// TODO(yunqingwang): In this function, only y-plane dist is
|
|
|
|
// calculated.
|
|
|
|
*dist = (sse << 4); // + ((sse_u + sse_v) << 4);
|
|
|
|
|
|
|
|
// *disable_skip = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 23:09:57 +02:00
|
|
|
struct estimate_block_intra_args {
|
|
|
|
VP9_COMP *cpi;
|
|
|
|
MACROBLOCK *x;
|
|
|
|
PREDICTION_MODE mode;
|
2016-04-11 23:02:34 +02:00
|
|
|
int skippable;
|
2014-08-19 23:09:57 +02:00
|
|
|
int rate;
|
|
|
|
int64_t dist;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void estimate_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
|
|
|
|
TX_SIZE tx_size, void *arg) {
|
|
|
|
struct estimate_block_intra_args* const args = arg;
|
|
|
|
VP9_COMP *const cpi = args->cpi;
|
|
|
|
MACROBLOCK *const x = args->x;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
struct macroblock_plane *const p = &x->plane[0];
|
|
|
|
struct macroblockd_plane *const pd = &xd->plane[0];
|
|
|
|
const BLOCK_SIZE bsize_tx = txsize_to_bsize[tx_size];
|
|
|
|
uint8_t *const src_buf_base = p->src.buf;
|
|
|
|
uint8_t *const dst_buf_base = pd->dst.buf;
|
|
|
|
const int src_stride = p->src.stride;
|
|
|
|
const int dst_stride = pd->dst.stride;
|
|
|
|
int i, j;
|
|
|
|
int rate;
|
|
|
|
int64_t dist;
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2014-08-19 23:09:57 +02:00
|
|
|
txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
|
|
|
|
|
|
|
|
p->src.buf = &src_buf_base[4 * (j * src_stride + i)];
|
|
|
|
pd->dst.buf = &dst_buf_base[4 * (j * dst_stride + i)];
|
|
|
|
// Use source buffer as an approximation for the fully reconstructed buffer.
|
2015-07-13 19:40:01 +02:00
|
|
|
vp9_predict_intra_block(xd, b_width_log2_lookup[plane_bsize],
|
2014-08-19 23:09:57 +02:00
|
|
|
tx_size, args->mode,
|
2014-11-08 02:50:55 +01:00
|
|
|
x->skip_encode ? p->src.buf : pd->dst.buf,
|
|
|
|
x->skip_encode ? src_stride : dst_stride,
|
2014-08-19 23:09:57 +02:00
|
|
|
pd->dst.buf, dst_stride,
|
2015-09-03 23:52:39 +02:00
|
|
|
i, j, plane);
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2015-09-03 23:52:39 +02:00
|
|
|
if (plane == 0) {
|
|
|
|
int64_t this_sse = INT64_MAX;
|
|
|
|
// TODO(jingning): This needs further refactoring.
|
2016-04-11 23:02:34 +02:00
|
|
|
block_yrd(cpi, x, &rate, &dist, &args->skippable, &this_sse, 0,
|
2015-09-03 23:52:39 +02:00
|
|
|
bsize_tx, VPXMIN(tx_size, TX_16X16));
|
|
|
|
} else {
|
2016-02-05 18:52:53 +01:00
|
|
|
unsigned int var = 0;
|
|
|
|
unsigned int sse = 0;
|
2015-09-03 23:52:39 +02:00
|
|
|
model_rd_for_sb_uv(cpi, plane_bsize, x, xd, &rate, &dist, &var, &sse,
|
|
|
|
plane, plane);
|
|
|
|
}
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2014-08-19 23:09:57 +02:00
|
|
|
p->src.buf = src_buf_base;
|
|
|
|
pd->dst.buf = dst_buf_base;
|
|
|
|
args->rate += rate;
|
|
|
|
args->dist += dist;
|
|
|
|
}
|
|
|
|
|
2014-12-18 02:11:39 +01:00
|
|
|
static const THR_MODES mode_idx[MAX_REF_FRAMES - 1][4] = {
|
2015-05-01 22:20:50 +02:00
|
|
|
{THR_DC, THR_V_PRED, THR_H_PRED, THR_TM},
|
2014-07-14 23:51:33 +02:00
|
|
|
{THR_NEARESTMV, THR_NEARMV, THR_ZEROMV, THR_NEWMV},
|
|
|
|
{THR_NEARESTG, THR_NEARG, THR_ZEROG, THR_NEWG},
|
|
|
|
};
|
|
|
|
|
2014-10-25 00:57:48 +02:00
|
|
|
static const PREDICTION_MODE intra_mode_list[] = {
|
|
|
|
DC_PRED, V_PRED, H_PRED, TM_PRED
|
|
|
|
};
|
|
|
|
|
2015-05-01 22:20:50 +02:00
|
|
|
static int mode_offset(const PREDICTION_MODE mode) {
|
|
|
|
if (mode >= NEARESTMV) {
|
|
|
|
return INTER_OFFSET(mode);
|
|
|
|
} else {
|
|
|
|
switch (mode) {
|
|
|
|
case DC_PRED:
|
|
|
|
return 0;
|
|
|
|
case V_PRED:
|
|
|
|
return 1;
|
|
|
|
case H_PRED:
|
|
|
|
return 2;
|
|
|
|
case TM_PRED:
|
|
|
|
return 3;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static INLINE void update_thresh_freq_fact(VP9_COMP *cpi,
|
|
|
|
TileDataEnc *tile_data,
|
|
|
|
BLOCK_SIZE bsize,
|
|
|
|
MV_REFERENCE_FRAME ref_frame,
|
|
|
|
THR_MODES best_mode_idx,
|
|
|
|
PREDICTION_MODE mode) {
|
|
|
|
THR_MODES thr_mode_idx = mode_idx[ref_frame][mode_offset(mode)];
|
|
|
|
int *freq_fact = &tile_data->thresh_freq_fact[bsize][thr_mode_idx];
|
|
|
|
if (thr_mode_idx == best_mode_idx)
|
|
|
|
*freq_fact -= (*freq_fact >> 4);
|
|
|
|
else
|
2015-08-18 03:19:22 +02:00
|
|
|
*freq_fact = VPXMIN(*freq_fact + RD_THRESH_INC,
|
|
|
|
cpi->sf.adaptive_rd_thresh * RD_THRESH_MAX_FACT);
|
2015-05-01 22:20:50 +02:00
|
|
|
}
|
|
|
|
|
2014-11-20 20:28:00 +01:00
|
|
|
void vp9_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost,
|
|
|
|
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2016-01-20 01:40:20 +01:00
|
|
|
MODE_INFO *const mi = xd->mi[0];
|
2014-11-20 20:28:00 +01:00
|
|
|
RD_COST this_rdc, best_rdc;
|
|
|
|
PREDICTION_MODE this_mode;
|
2016-04-11 23:02:34 +02:00
|
|
|
struct estimate_block_intra_args args = { cpi, x, DC_PRED, 1, 0, 0 };
|
2014-11-20 20:28:00 +01:00
|
|
|
const TX_SIZE intra_tx_size =
|
2015-08-18 03:19:22 +02:00
|
|
|
VPXMIN(max_txsize_lookup[bsize],
|
|
|
|
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
|
2015-04-21 14:36:58 +02:00
|
|
|
MODE_INFO *const mic = xd->mi[0];
|
2014-11-20 20:28:00 +01:00
|
|
|
int *bmode_costs;
|
2016-03-30 13:47:39 +02:00
|
|
|
const MODE_INFO *above_mi = xd->above_mi;
|
|
|
|
const MODE_INFO *left_mi = xd->left_mi;
|
2014-11-20 20:28:00 +01:00
|
|
|
const PREDICTION_MODE A = vp9_above_block_mode(mic, above_mi, 0);
|
|
|
|
const PREDICTION_MODE L = vp9_left_block_mode(mic, left_mi, 0);
|
|
|
|
bmode_costs = cpi->y_mode_costs[A][L];
|
|
|
|
|
|
|
|
(void) ctx;
|
|
|
|
vp9_rd_cost_reset(&best_rdc);
|
|
|
|
vp9_rd_cost_reset(&this_rdc);
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->ref_frame[0] = INTRA_FRAME;
|
|
|
|
mi->mv[0].as_int = INVALID_MV;
|
|
|
|
mi->uv_mode = DC_PRED;
|
2015-04-24 05:47:40 +02:00
|
|
|
memset(x->skip_txfm, 0, sizeof(x->skip_txfm));
|
2014-11-20 20:28:00 +01:00
|
|
|
|
|
|
|
// Change the limit of this loop to add other intra prediction
|
|
|
|
// mode tests.
|
|
|
|
for (this_mode = DC_PRED; this_mode <= H_PRED; ++this_mode) {
|
|
|
|
args.mode = this_mode;
|
2016-04-11 23:02:34 +02:00
|
|
|
args.skippable = 1;
|
2014-11-20 20:28:00 +01:00
|
|
|
args.rate = 0;
|
|
|
|
args.dist = 0;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->tx_size = intra_tx_size;
|
2014-11-20 20:28:00 +01:00
|
|
|
vp9_foreach_transformed_block_in_plane(xd, bsize, 0,
|
|
|
|
estimate_block_intra, &args);
|
2016-04-11 23:02:34 +02:00
|
|
|
if (args.skippable) {
|
|
|
|
x->skip_txfm[0] = SKIP_TXFM_AC_DC;
|
|
|
|
args.rate = vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 1);
|
|
|
|
} else {
|
|
|
|
x->skip_txfm[0] = SKIP_TXFM_NONE;
|
|
|
|
args.rate += vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 0);
|
|
|
|
}
|
2014-11-20 20:28:00 +01:00
|
|
|
this_rdc.rate = args.rate;
|
|
|
|
this_rdc.dist = args.dist;
|
|
|
|
this_rdc.rate += bmode_costs[this_mode];
|
|
|
|
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv,
|
|
|
|
this_rdc.rate, this_rdc.dist);
|
|
|
|
|
|
|
|
if (this_rdc.rdcost < best_rdc.rdcost) {
|
|
|
|
best_rdc = this_rdc;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = this_mode;
|
2014-11-20 20:28:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*rd_cost = best_rdc;
|
|
|
|
}
|
|
|
|
|
2015-04-03 00:31:06 +02:00
|
|
|
static void init_ref_frame_cost(VP9_COMMON *const cm,
|
|
|
|
MACROBLOCKD *const xd,
|
|
|
|
int ref_frame_cost[MAX_REF_FRAMES]) {
|
2015-07-20 22:49:15 +02:00
|
|
|
vpx_prob intra_inter_p = vp9_get_intra_inter_prob(cm, xd);
|
|
|
|
vpx_prob ref_single_p1 = vp9_get_pred_prob_single_ref_p1(cm, xd);
|
|
|
|
vpx_prob ref_single_p2 = vp9_get_pred_prob_single_ref_p2(cm, xd);
|
2015-04-03 00:31:06 +02:00
|
|
|
|
|
|
|
ref_frame_cost[INTRA_FRAME] = vp9_cost_bit(intra_inter_p, 0);
|
|
|
|
ref_frame_cost[LAST_FRAME] = ref_frame_cost[GOLDEN_FRAME] =
|
|
|
|
ref_frame_cost[ALTREF_FRAME] = vp9_cost_bit(intra_inter_p, 1);
|
|
|
|
|
|
|
|
ref_frame_cost[LAST_FRAME] += vp9_cost_bit(ref_single_p1, 0);
|
|
|
|
ref_frame_cost[GOLDEN_FRAME] += vp9_cost_bit(ref_single_p1, 1);
|
|
|
|
ref_frame_cost[ALTREF_FRAME] += vp9_cost_bit(ref_single_p1, 1);
|
|
|
|
ref_frame_cost[GOLDEN_FRAME] += vp9_cost_bit(ref_single_p2, 0);
|
|
|
|
ref_frame_cost[ALTREF_FRAME] += vp9_cost_bit(ref_single_p2, 1);
|
|
|
|
}
|
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
typedef struct {
|
|
|
|
MV_REFERENCE_FRAME ref_frame;
|
|
|
|
PREDICTION_MODE pred_mode;
|
|
|
|
} REF_MODE;
|
|
|
|
|
|
|
|
#define RT_INTER_MODES 8
|
|
|
|
static const REF_MODE ref_mode_set[RT_INTER_MODES] = {
|
|
|
|
{LAST_FRAME, ZEROMV},
|
|
|
|
{LAST_FRAME, NEARESTMV},
|
2015-03-16 20:49:30 +01:00
|
|
|
{GOLDEN_FRAME, ZEROMV},
|
2015-03-11 18:16:39 +01:00
|
|
|
{LAST_FRAME, NEARMV},
|
|
|
|
{LAST_FRAME, NEWMV},
|
|
|
|
{GOLDEN_FRAME, NEARESTMV},
|
|
|
|
{GOLDEN_FRAME, NEARMV},
|
|
|
|
{GOLDEN_FRAME, NEWMV}
|
|
|
|
};
|
2015-08-05 01:12:27 +02:00
|
|
|
static const REF_MODE ref_mode_set_svc[RT_INTER_MODES] = {
|
|
|
|
{LAST_FRAME, ZEROMV},
|
|
|
|
{GOLDEN_FRAME, ZEROMV},
|
|
|
|
{LAST_FRAME, NEARESTMV},
|
|
|
|
{LAST_FRAME, NEARMV},
|
|
|
|
{GOLDEN_FRAME, NEARESTMV},
|
|
|
|
{GOLDEN_FRAME, NEARMV},
|
|
|
|
{LAST_FRAME, NEWMV},
|
|
|
|
{GOLDEN_FRAME, NEWMV}
|
|
|
|
};
|
2015-03-11 18:16:39 +01:00
|
|
|
|
2015-10-26 22:56:46 +01:00
|
|
|
int set_intra_cost_penalty(const VP9_COMP *const cpi, BLOCK_SIZE bsize) {
|
|
|
|
const VP9_COMMON *const cm = &cpi->common;
|
|
|
|
// Reduce the intra cost penalty for small blocks (<=16x16).
|
|
|
|
int reduction_fac =
|
|
|
|
(bsize <= BLOCK_16X16) ? ((bsize <= BLOCK_8X8) ? 4 : 2) : 0;
|
2015-11-01 23:40:05 +01:00
|
|
|
if (cpi->noise_estimate.enabled && cpi->noise_estimate.level == kHigh)
|
2015-10-26 22:56:46 +01:00
|
|
|
// Don't reduce intra cost penalty if estimated noise level is high.
|
|
|
|
reduction_fac = 0;
|
|
|
|
return vp9_get_intra_cost_penalty(
|
|
|
|
cm->base_qindex, cm->y_dc_delta_q, cm->bit_depth) >> reduction_fac;
|
|
|
|
}
|
|
|
|
|
2016-01-15 18:35:41 +01:00
|
|
|
static INLINE void find_predictors(VP9_COMP *cpi, MACROBLOCK *x,
|
|
|
|
MV_REFERENCE_FRAME ref_frame,
|
|
|
|
int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES],
|
|
|
|
int const_motion[MAX_REF_FRAMES],
|
|
|
|
int *ref_frame_skip_mask,
|
|
|
|
const int flag_list[4],
|
|
|
|
TileDataEnc *tile_data,
|
|
|
|
int mi_row, int mi_col,
|
|
|
|
struct buf_2d yv12_mb[4][MAX_MB_PLANE],
|
|
|
|
BLOCK_SIZE bsize) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
|
|
|
|
TileInfo *const tile_info = &tile_data->tile_info;
|
2014-01-10 20:51:20 +01:00
|
|
|
// TODO(jingning) placeholder for inter-frame non-RD mode decision.
|
2016-01-15 18:35:41 +01:00
|
|
|
x->pred_mv_sad[ref_frame] = INT_MAX;
|
|
|
|
frame_mv[NEWMV][ref_frame].as_int = INVALID_MV;
|
|
|
|
frame_mv[ZEROMV][ref_frame].as_int = 0;
|
2014-01-10 20:51:20 +01:00
|
|
|
// this needs various further optimizations. to be continued..
|
2016-01-15 18:35:41 +01:00
|
|
|
if ((cpi->ref_frame_flags & flag_list[ref_frame]) && (yv12 != NULL)) {
|
|
|
|
int_mv *const candidates = x->mbmi_ext->ref_mvs[ref_frame];
|
|
|
|
const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf;
|
|
|
|
vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col,
|
|
|
|
sf, sf);
|
|
|
|
if (cm->use_prev_frame_mvs)
|
|
|
|
vp9_find_mv_refs(cm, xd, xd->mi[0], ref_frame,
|
|
|
|
candidates, mi_row, mi_col,
|
|
|
|
x->mbmi_ext->mode_context);
|
|
|
|
else
|
|
|
|
const_motion[ref_frame] =
|
|
|
|
mv_refs_rt(cpi, cm, x, xd, tile_info, xd->mi[0], ref_frame,
|
|
|
|
candidates, &frame_mv[NEWMV][ref_frame], mi_row, mi_col,
|
|
|
|
(int)(cpi->svc.use_base_mv && cpi->svc.spatial_layer_id));
|
|
|
|
vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates,
|
|
|
|
&frame_mv[NEARESTMV][ref_frame],
|
|
|
|
&frame_mv[NEARMV][ref_frame]);
|
|
|
|
if (!vp9_is_scaled(sf) && bsize >= BLOCK_8X8) {
|
|
|
|
vp9_mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride,
|
|
|
|
ref_frame, bsize);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*ref_frame_skip_mask |= (1 << ref_frame);
|
|
|
|
}
|
|
|
|
}
|
2014-08-17 01:47:44 +02:00
|
|
|
void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
|
2014-10-27 19:11:50 +01:00
|
|
|
TileDataEnc *tile_data,
|
2014-10-22 01:31:37 +02:00
|
|
|
int mi_row, int mi_col, RD_COST *rd_cost,
|
|
|
|
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
|
2014-08-17 01:55:25 +02:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2015-06-05 02:05:11 +02:00
|
|
|
SPEED_FEATURES *const sf = &cpi->sf;
|
2015-12-07 21:23:56 +01:00
|
|
|
const SVC *const svc = &cpi->svc;
|
2014-08-17 01:55:25 +02:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2016-01-20 01:40:20 +01:00
|
|
|
MODE_INFO *const mi = xd->mi[0];
|
2014-02-26 01:12:35 +01:00
|
|
|
struct macroblockd_plane *const pd = &xd->plane[0];
|
2014-08-17 01:58:31 +02:00
|
|
|
PREDICTION_MODE best_mode = ZEROMV;
|
2014-02-25 22:50:32 +01:00
|
|
|
MV_REFERENCE_FRAME ref_frame, best_ref_frame = LAST_FRAME;
|
2015-03-16 17:42:33 +01:00
|
|
|
MV_REFERENCE_FRAME usable_ref_frame;
|
2014-12-15 21:54:02 +01:00
|
|
|
TX_SIZE best_tx_size = TX_SIZES;
|
2014-04-05 00:59:10 +02:00
|
|
|
INTERP_FILTER best_pred_filter = EIGHTTAP;
|
2014-01-10 20:51:20 +01:00
|
|
|
int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES];
|
|
|
|
struct buf_2d yv12_mb[4][MAX_MB_PLANE];
|
|
|
|
static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
|
|
|
|
VP9_ALT_FLAG };
|
2014-10-22 01:31:37 +02:00
|
|
|
RD_COST this_rdc, best_rdc;
|
2015-07-30 20:52:28 +02:00
|
|
|
uint8_t skip_txfm = SKIP_TXFM_NONE, best_mode_skip_txfm = SKIP_TXFM_NONE;
|
2014-05-07 19:39:00 +02:00
|
|
|
// var_y and sse_y are saved to be used in skipping checking
|
|
|
|
unsigned int var_y = UINT_MAX;
|
|
|
|
unsigned int sse_y = UINT_MAX;
|
2015-10-26 22:56:46 +01:00
|
|
|
const int intra_cost_penalty = set_intra_cost_penalty(cpi, bsize);
|
2016-01-15 18:35:41 +01:00
|
|
|
int64_t inter_mode_thresh = RDCOST(x->rdmult, x->rddiv,
|
2014-03-19 19:25:40 +01:00
|
|
|
intra_cost_penalty, 0);
|
2016-01-20 01:40:20 +01:00
|
|
|
const int *const rd_threshes = cpi->rd.threshes[mi->segment_id][bsize];
|
2014-10-27 17:52:14 +01:00
|
|
|
const int *const rd_thresh_freq_fact = tile_data->thresh_freq_fact[bsize];
|
2014-10-23 17:27:25 +02:00
|
|
|
INTERP_FILTER filter_ref;
|
2014-10-07 21:45:25 +02:00
|
|
|
const int bsl = mi_width_log2_lookup[bsize];
|
2014-06-30 21:48:21 +02:00
|
|
|
const int pred_filter_search = cm->interp_filter == SWITCHABLE ?
|
2014-07-26 01:43:27 +02:00
|
|
|
(((mi_row + mi_col) >> bsl) +
|
|
|
|
get_chessboard_index(cm->current_video_frame)) & 0x1 : 0;
|
2014-06-24 19:45:31 +02:00
|
|
|
int const_motion[MAX_REF_FRAMES] = { 0 };
|
2014-08-19 23:09:57 +02:00
|
|
|
const int bh = num_4x4_blocks_high_lookup[bsize] << 2;
|
|
|
|
const int bw = num_4x4_blocks_wide_lookup[bsize] << 2;
|
2014-07-14 23:51:33 +02:00
|
|
|
// For speed 6, the result of interp filter is reused later in actual encoding
|
|
|
|
// process.
|
2014-06-20 19:11:34 +02:00
|
|
|
// tmp[3] points to dst buffer, and the other 3 point to allocated buffers.
|
|
|
|
PRED_BUFFER tmp[4];
|
2015-05-02 22:24:16 +02:00
|
|
|
DECLARE_ALIGNED(16, uint8_t, pred_buf[3 * 64 * 64]);
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
2015-05-02 22:24:16 +02:00
|
|
|
DECLARE_ALIGNED(16, uint16_t, pred_buf_16[3 * 64 * 64]);
|
2014-09-24 15:36:34 +02:00
|
|
|
#endif
|
2014-06-20 19:11:34 +02:00
|
|
|
struct buf_2d orig_dst = pd->dst;
|
|
|
|
PRED_BUFFER *best_pred = NULL;
|
|
|
|
PRED_BUFFER *this_mode_pred = NULL;
|
2014-09-24 15:36:34 +02:00
|
|
|
const int pixels_in_block = bh * bw;
|
2014-10-30 00:37:16 +01:00
|
|
|
int reuse_inter_pred = cpi->sf.reuse_inter_pred_sby && ctx->pred_pixel_ready;
|
Skip ref frame mode search conditioned on predicted mv residuals
This commit makes the RTC coding mode to conditionally skip the
reference frame mode search, when the predicted motion vector of
the current reference frame gives more than two times sum of
absolute difference compared to that of other reference frames.
It reduces the runtim by 1% - 4% for speed -5 and -6. The average
compression performance is improved by about 0.1% in both settings.
It is of particular benefit to light change scenarios. The
compression performance of test clip mmmovingvga.y4m is improved by
6.39% and 15.69% at high bit rates for speed -5 and -6, respectively.
Speed -5
vidyo1 16555 b/f, 40.818 dB, 12422 ms ->
16552 b/f, 40.804 dB, 12100 ms
nik 33211 b/f, 39.138 dB, 11341 ms ->
33228 b/f, 39.139 dB, 11023 ms
mmmoving 33263 b/f, 40.935 dB, 13508 ms ->
33256 b/f, 41.068 dB, 12861 ms
Speed -6
vidyo1 16541 b/f, 40.227 dB, 8437 ms ->
16540 b/f, 40.220 dB, 8216 ms
nik 33272 b/f, 38.399 dB, 7610 ms ->
33267 b/f, 38.414 dB, 7490 ms
mmmoving 33255 b/f, 40.555 dB, 7523 ms ->
33257 b/f, 40.975 dB, 7493 ms
Change-Id: Id2aef76ef74a3cba5e9a82a83b792144948c6a91
2014-11-03 20:36:34 +01:00
|
|
|
int ref_frame_skip_mask = 0;
|
2015-03-11 18:16:39 +01:00
|
|
|
int idx;
|
2015-03-18 02:40:40 +01:00
|
|
|
int best_pred_sad = INT_MAX;
|
2015-03-25 22:19:29 +01:00
|
|
|
int best_early_term = 0;
|
2015-03-23 18:02:42 +01:00
|
|
|
int ref_frame_cost[MAX_REF_FRAMES];
|
2015-12-07 21:23:56 +01:00
|
|
|
int svc_force_zero_mode[3] = {0};
|
2016-01-15 18:35:41 +01:00
|
|
|
int perform_intra_pred = 1;
|
2015-11-14 00:58:42 +01:00
|
|
|
#if CONFIG_VP9_TEMPORAL_DENOISING
|
|
|
|
int64_t zero_last_cost_orig = INT64_MAX;
|
|
|
|
#endif
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2015-04-03 00:31:06 +02:00
|
|
|
init_ref_frame_cost(cm, xd, ref_frame_cost);
|
2014-06-20 19:11:34 +02:00
|
|
|
|
2014-10-30 00:37:16 +01:00
|
|
|
if (reuse_inter_pred) {
|
2014-08-17 01:58:31 +02:00
|
|
|
int i;
|
2014-06-20 19:11:34 +02:00
|
|
|
for (i = 0; i < 3; i++) {
|
2014-09-24 15:36:34 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (cm->use_highbitdepth)
|
|
|
|
tmp[i].data = CONVERT_TO_BYTEPTR(&pred_buf_16[pixels_in_block * i]);
|
|
|
|
else
|
|
|
|
tmp[i].data = &pred_buf[pixels_in_block * i];
|
|
|
|
#else
|
|
|
|
tmp[i].data = &pred_buf[pixels_in_block * i];
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2014-06-20 19:11:34 +02:00
|
|
|
tmp[i].stride = bw;
|
|
|
|
tmp[i].in_use = 0;
|
|
|
|
}
|
|
|
|
tmp[3].data = pd->dst.buf;
|
|
|
|
tmp[3].stride = pd->dst.stride;
|
|
|
|
tmp[3].in_use = 0;
|
|
|
|
}
|
|
|
|
|
2014-01-10 20:51:20 +01:00
|
|
|
x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
|
|
|
|
x->skip = 0;
|
2014-05-07 19:39:00 +02:00
|
|
|
|
2016-03-30 13:47:39 +02:00
|
|
|
if (xd->above_mi)
|
|
|
|
filter_ref = xd->above_mi->interp_filter;
|
|
|
|
else if (xd->left_mi)
|
|
|
|
filter_ref = xd->left_mi->interp_filter;
|
2014-10-23 17:27:25 +02:00
|
|
|
else
|
|
|
|
filter_ref = cm->interp_filter;
|
|
|
|
|
2014-01-10 20:51:20 +01:00
|
|
|
// initialize mode decisions
|
2014-10-22 01:31:37 +02:00
|
|
|
vp9_rd_cost_reset(&best_rdc);
|
|
|
|
vp9_rd_cost_reset(rd_cost);
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->sb_type = bsize;
|
|
|
|
mi->ref_frame[0] = NONE;
|
|
|
|
mi->ref_frame[1] = NONE;
|
|
|
|
mi->tx_size = VPXMIN(max_txsize_lookup[bsize],
|
|
|
|
tx_mode_to_biggest_tx_size[cm->tx_mode]);
|
2014-01-10 20:51:20 +01:00
|
|
|
|
2016-01-20 23:28:09 +01:00
|
|
|
if (sf->short_circuit_flat_blocks) {
|
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH)
|
|
|
|
x->source_variance = vp9_high_get_sby_perpixel_variance(
|
|
|
|
cpi, &x->plane[0].src, bsize, xd->bd);
|
|
|
|
else
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
x->source_variance =
|
|
|
|
vp9_get_sby_perpixel_variance(cpi, &x->plane[0].src, bsize);
|
|
|
|
}
|
|
|
|
|
2015-01-07 20:41:56 +01:00
|
|
|
#if CONFIG_VP9_TEMPORAL_DENOISING
|
2016-04-04 20:05:21 +02:00
|
|
|
if (cpi->oxcf.noise_sensitivity > 0 &&
|
|
|
|
cpi->denoiser.denoising_level > kDenLowLow) {
|
|
|
|
vp9_denoiser_reset_frame_stats(ctx);
|
|
|
|
}
|
2015-01-07 20:41:56 +01:00
|
|
|
#endif
|
2015-03-17 18:12:00 +01:00
|
|
|
|
2015-08-05 22:53:26 +02:00
|
|
|
if (cpi->rc.frames_since_golden == 0 && !cpi->use_svc) {
|
2015-03-16 17:42:33 +01:00
|
|
|
usable_ref_frame = LAST_FRAME;
|
|
|
|
} else {
|
|
|
|
usable_ref_frame = GOLDEN_FRAME;
|
|
|
|
}
|
2015-12-07 21:23:56 +01:00
|
|
|
|
2016-03-07 18:50:36 +01:00
|
|
|
// For svc mode, on spatial_layer_id > 0: if the reference has different scale
|
|
|
|
// constrain the inter mode to only test zero motion.
|
|
|
|
if (cpi->use_svc &&
|
|
|
|
svc ->force_zero_mode_spatial_ref &&
|
|
|
|
cpi->svc.spatial_layer_id > 0) {
|
|
|
|
if (cpi->ref_frame_flags & flag_list[LAST_FRAME]) {
|
|
|
|
struct scale_factors *const sf = &cm->frame_refs[LAST_FRAME - 1].sf;
|
|
|
|
if (vp9_is_scaled(sf))
|
|
|
|
svc_force_zero_mode[LAST_FRAME - 1] = 1;
|
|
|
|
}
|
|
|
|
if (cpi->ref_frame_flags & flag_list[GOLDEN_FRAME]) {
|
|
|
|
struct scale_factors *const sf = &cm->frame_refs[GOLDEN_FRAME - 1].sf;
|
|
|
|
if (vp9_is_scaled(sf))
|
|
|
|
svc_force_zero_mode[GOLDEN_FRAME - 1] = 1;
|
|
|
|
}
|
2015-12-07 21:23:56 +01:00
|
|
|
}
|
|
|
|
|
2015-03-16 17:42:33 +01:00
|
|
|
for (ref_frame = LAST_FRAME; ref_frame <= usable_ref_frame; ++ref_frame) {
|
2016-01-15 18:35:41 +01:00
|
|
|
find_predictors(cpi, x, ref_frame, frame_mv, const_motion,
|
|
|
|
&ref_frame_skip_mask, flag_list, tile_data, mi_row, mi_col,
|
|
|
|
yv12_mb, bsize);
|
Skip ref frame mode search conditioned on predicted mv residuals
This commit makes the RTC coding mode to conditionally skip the
reference frame mode search, when the predicted motion vector of
the current reference frame gives more than two times sum of
absolute difference compared to that of other reference frames.
It reduces the runtim by 1% - 4% for speed -5 and -6. The average
compression performance is improved by about 0.1% in both settings.
It is of particular benefit to light change scenarios. The
compression performance of test clip mmmovingvga.y4m is improved by
6.39% and 15.69% at high bit rates for speed -5 and -6, respectively.
Speed -5
vidyo1 16555 b/f, 40.818 dB, 12422 ms ->
16552 b/f, 40.804 dB, 12100 ms
nik 33211 b/f, 39.138 dB, 11341 ms ->
33228 b/f, 39.139 dB, 11023 ms
mmmoving 33263 b/f, 40.935 dB, 13508 ms ->
33256 b/f, 41.068 dB, 12861 ms
Speed -6
vidyo1 16541 b/f, 40.227 dB, 8437 ms ->
16540 b/f, 40.220 dB, 8216 ms
nik 33272 b/f, 38.399 dB, 7610 ms ->
33267 b/f, 38.414 dB, 7490 ms
mmmoving 33255 b/f, 40.555 dB, 7523 ms ->
33257 b/f, 40.975 dB, 7493 ms
Change-Id: Id2aef76ef74a3cba5e9a82a83b792144948c6a91
2014-11-03 20:36:34 +01:00
|
|
|
}
|
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
for (idx = 0; idx < RT_INTER_MODES; ++idx) {
|
|
|
|
int rate_mv = 0;
|
|
|
|
int mode_rd_thresh;
|
|
|
|
int mode_index;
|
|
|
|
int i;
|
2015-03-23 18:02:42 +01:00
|
|
|
int64_t this_sse;
|
|
|
|
int is_skippable;
|
2015-03-25 22:19:29 +01:00
|
|
|
int this_early_term = 0;
|
2015-08-05 01:12:27 +02:00
|
|
|
PREDICTION_MODE this_mode = ref_mode_set[idx].pred_mode;
|
|
|
|
if (cpi->use_svc)
|
|
|
|
this_mode = ref_mode_set_svc[idx].pred_mode;
|
2015-03-23 18:02:42 +01:00
|
|
|
|
2016-01-20 23:28:09 +01:00
|
|
|
if (sf->short_circuit_flat_blocks && x->source_variance == 0 &&
|
|
|
|
this_mode != NEARESTMV) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-03-16 17:42:33 +01:00
|
|
|
if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode)))
|
|
|
|
continue;
|
2015-03-11 18:16:39 +01:00
|
|
|
|
|
|
|
ref_frame = ref_mode_set[idx].ref_frame;
|
2015-12-07 21:23:56 +01:00
|
|
|
if (cpi->use_svc) {
|
2015-08-05 01:12:27 +02:00
|
|
|
ref_frame = ref_mode_set_svc[idx].ref_frame;
|
2015-12-07 21:23:56 +01:00
|
|
|
}
|
|
|
|
|
Skip ref frame mode search conditioned on predicted mv residuals
This commit makes the RTC coding mode to conditionally skip the
reference frame mode search, when the predicted motion vector of
the current reference frame gives more than two times sum of
absolute difference compared to that of other reference frames.
It reduces the runtim by 1% - 4% for speed -5 and -6. The average
compression performance is improved by about 0.1% in both settings.
It is of particular benefit to light change scenarios. The
compression performance of test clip mmmovingvga.y4m is improved by
6.39% and 15.69% at high bit rates for speed -5 and -6, respectively.
Speed -5
vidyo1 16555 b/f, 40.818 dB, 12422 ms ->
16552 b/f, 40.804 dB, 12100 ms
nik 33211 b/f, 39.138 dB, 11341 ms ->
33228 b/f, 39.139 dB, 11023 ms
mmmoving 33263 b/f, 40.935 dB, 13508 ms ->
33256 b/f, 41.068 dB, 12861 ms
Speed -6
vidyo1 16541 b/f, 40.227 dB, 8437 ms ->
16540 b/f, 40.220 dB, 8216 ms
nik 33272 b/f, 38.399 dB, 7610 ms ->
33267 b/f, 38.414 dB, 7490 ms
mmmoving 33255 b/f, 40.555 dB, 7523 ms ->
33257 b/f, 40.975 dB, 7493 ms
Change-Id: Id2aef76ef74a3cba5e9a82a83b792144948c6a91
2014-11-03 20:36:34 +01:00
|
|
|
if (!(cpi->ref_frame_flags & flag_list[ref_frame]))
|
|
|
|
continue;
|
2015-03-16 17:42:33 +01:00
|
|
|
if (const_motion[ref_frame] && this_mode == NEARMV)
|
|
|
|
continue;
|
Skip ref frame mode search conditioned on predicted mv residuals
This commit makes the RTC coding mode to conditionally skip the
reference frame mode search, when the predicted motion vector of
the current reference frame gives more than two times sum of
absolute difference compared to that of other reference frames.
It reduces the runtim by 1% - 4% for speed -5 and -6. The average
compression performance is improved by about 0.1% in both settings.
It is of particular benefit to light change scenarios. The
compression performance of test clip mmmovingvga.y4m is improved by
6.39% and 15.69% at high bit rates for speed -5 and -6, respectively.
Speed -5
vidyo1 16555 b/f, 40.818 dB, 12422 ms ->
16552 b/f, 40.804 dB, 12100 ms
nik 33211 b/f, 39.138 dB, 11341 ms ->
33228 b/f, 39.139 dB, 11023 ms
mmmoving 33263 b/f, 40.935 dB, 13508 ms ->
33256 b/f, 41.068 dB, 12861 ms
Speed -6
vidyo1 16541 b/f, 40.227 dB, 8437 ms ->
16540 b/f, 40.220 dB, 8216 ms
nik 33272 b/f, 38.399 dB, 7610 ms ->
33267 b/f, 38.414 dB, 7490 ms
mmmoving 33255 b/f, 40.555 dB, 7523 ms ->
33257 b/f, 40.975 dB, 7493 ms
Change-Id: Id2aef76ef74a3cba5e9a82a83b792144948c6a91
2014-11-03 20:36:34 +01:00
|
|
|
|
2016-01-06 20:30:02 +01:00
|
|
|
if (cpi->use_svc) {
|
|
|
|
if (svc_force_zero_mode[ref_frame - 1] &&
|
|
|
|
frame_mv[this_mode][ref_frame].as_int != 0)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-11-24 01:37:12 +01:00
|
|
|
if (!(frame_mv[this_mode][ref_frame].as_int == 0 &&
|
|
|
|
ref_frame == LAST_FRAME)) {
|
2015-09-21 19:20:14 +02:00
|
|
|
i = (ref_frame == LAST_FRAME) ? GOLDEN_FRAME : LAST_FRAME;
|
|
|
|
if ((cpi->ref_frame_flags & flag_list[i]) && sf->reference_masking)
|
|
|
|
if (x->pred_mv_sad[ref_frame] > (x->pred_mv_sad[i] << 1))
|
|
|
|
ref_frame_skip_mask |= (1 << ref_frame);
|
|
|
|
}
|
Skip ref frame mode search conditioned on predicted mv residuals
This commit makes the RTC coding mode to conditionally skip the
reference frame mode search, when the predicted motion vector of
the current reference frame gives more than two times sum of
absolute difference compared to that of other reference frames.
It reduces the runtim by 1% - 4% for speed -5 and -6. The average
compression performance is improved by about 0.1% in both settings.
It is of particular benefit to light change scenarios. The
compression performance of test clip mmmovingvga.y4m is improved by
6.39% and 15.69% at high bit rates for speed -5 and -6, respectively.
Speed -5
vidyo1 16555 b/f, 40.818 dB, 12422 ms ->
16552 b/f, 40.804 dB, 12100 ms
nik 33211 b/f, 39.138 dB, 11341 ms ->
33228 b/f, 39.139 dB, 11023 ms
mmmoving 33263 b/f, 40.935 dB, 13508 ms ->
33256 b/f, 41.068 dB, 12861 ms
Speed -6
vidyo1 16541 b/f, 40.227 dB, 8437 ms ->
16540 b/f, 40.220 dB, 8216 ms
nik 33272 b/f, 38.399 dB, 7610 ms ->
33267 b/f, 38.414 dB, 7490 ms
mmmoving 33255 b/f, 40.555 dB, 7523 ms ->
33257 b/f, 40.975 dB, 7493 ms
Change-Id: Id2aef76ef74a3cba5e9a82a83b792144948c6a91
2014-11-03 20:36:34 +01:00
|
|
|
if (ref_frame_skip_mask & (1 << ref_frame))
|
|
|
|
continue;
|
2014-01-10 20:51:20 +01:00
|
|
|
|
|
|
|
// Select prediction reference frames.
|
2015-02-04 00:56:36 +01:00
|
|
|
for (i = 0; i < MAX_MB_PLANE; i++)
|
|
|
|
xd->plane[i].pre[0] = yv12_mb[ref_frame][i];
|
2015-01-21 18:32:23 +01:00
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->ref_frame[0] = ref_frame;
|
2014-12-23 18:30:24 +01:00
|
|
|
set_ref_ptrs(cm, xd, ref_frame, NONE);
|
2014-02-25 22:50:32 +01:00
|
|
|
|
2015-03-16 17:42:33 +01:00
|
|
|
mode_index = mode_idx[ref_frame][INTER_OFFSET(this_mode)];
|
2015-03-11 18:16:39 +01:00
|
|
|
mode_rd_thresh = best_mode_skip_txfm ?
|
|
|
|
rd_threshes[mode_index] << 1 : rd_threshes[mode_index];
|
|
|
|
if (rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh,
|
|
|
|
rd_thresh_freq_fact[mode_index]))
|
|
|
|
continue;
|
2014-01-29 17:39:39 +01:00
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
if (this_mode == NEWMV) {
|
2016-02-25 01:16:44 +01:00
|
|
|
if (ref_frame > LAST_FRAME &&
|
|
|
|
!cpi->use_svc &&
|
|
|
|
cpi->oxcf.rc_mode == VPX_CBR) {
|
2015-03-11 18:16:39 +01:00
|
|
|
int tmp_sad;
|
|
|
|
int dis, cost_list[5];
|
2014-03-19 19:52:13 +01:00
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
if (bsize < BLOCK_16X16)
|
2014-02-26 18:52:23 +01:00
|
|
|
continue;
|
2015-03-10 02:55:38 +01:00
|
|
|
|
2015-05-22 21:03:58 +02:00
|
|
|
tmp_sad = vp9_int_pro_motion_estimation(cpi, x, bsize, mi_row, mi_col);
|
2015-03-18 02:40:40 +01:00
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
if (tmp_sad > x->pred_mv_sad[LAST_FRAME])
|
2014-01-29 17:39:39 +01:00
|
|
|
continue;
|
2015-03-18 02:40:40 +01:00
|
|
|
if (tmp_sad + (num_pels_log2_lookup[bsize] << 4) > best_pred_sad)
|
|
|
|
continue;
|
2014-01-29 17:39:39 +01:00
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
frame_mv[NEWMV][ref_frame].as_int = mi->mv[0].as_int;
|
2015-03-11 18:16:39 +01:00
|
|
|
rate_mv = vp9_mv_bit_cost(&frame_mv[NEWMV][ref_frame].as_mv,
|
2015-06-29 18:27:11 +02:00
|
|
|
&x->mbmi_ext->ref_mvs[ref_frame][0].as_mv,
|
2015-03-11 18:16:39 +01:00
|
|
|
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
|
|
|
|
frame_mv[NEWMV][ref_frame].as_mv.row >>= 3;
|
|
|
|
frame_mv[NEWMV][ref_frame].as_mv.col >>= 3;
|
|
|
|
|
|
|
|
cpi->find_fractional_mv_step(x, &frame_mv[NEWMV][ref_frame].as_mv,
|
2015-06-29 18:27:11 +02:00
|
|
|
&x->mbmi_ext->ref_mvs[ref_frame][0].as_mv,
|
2015-03-11 18:16:39 +01:00
|
|
|
cpi->common.allow_high_precision_mv,
|
|
|
|
x->errorperbit,
|
|
|
|
&cpi->fn_ptr[bsize],
|
|
|
|
cpi->sf.mv.subpel_force_stop,
|
|
|
|
cpi->sf.mv.subpel_iters_per_step,
|
|
|
|
cond_cost_list(cpi, cost_list),
|
|
|
|
x->nmvjointcost, x->mvcost, &dis,
|
|
|
|
&x->pred_sse[ref_frame], NULL, 0, 0);
|
2016-01-15 18:35:41 +01:00
|
|
|
} else if (svc->use_base_mv && svc->spatial_layer_id) {
|
|
|
|
if (frame_mv[NEWMV][ref_frame].as_int != INVALID_MV &&
|
|
|
|
frame_mv[NEWMV][ref_frame].as_int != 0) {
|
|
|
|
const int pre_stride = xd->plane[0].pre[0].stride;
|
|
|
|
int base_mv_sad = INT_MAX;
|
|
|
|
const uint8_t * const pre_buf = xd->plane[0].pre[0].buf +
|
|
|
|
(frame_mv[NEWMV][ref_frame].as_mv.row >> 3) * pre_stride +
|
|
|
|
(frame_mv[NEWMV][ref_frame].as_mv.col >> 3);
|
|
|
|
base_mv_sad = cpi->fn_ptr[bsize].sdf(x->plane[0].src.buf,
|
|
|
|
x->plane[0].src.stride,
|
|
|
|
pre_buf, pre_stride);
|
|
|
|
|
|
|
|
// TODO(wonkap): make the decision to use base layer mv on RD;
|
|
|
|
// not just SAD.
|
|
|
|
if (base_mv_sad < x->pred_mv_sad[ref_frame]) {
|
|
|
|
// Base layer mv is good.
|
|
|
|
if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col,
|
|
|
|
&frame_mv[NEWMV][ref_frame], &rate_mv, best_rdc.rdcost, 1)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col,
|
|
|
|
&frame_mv[NEWMV][ref_frame], &rate_mv, best_rdc.rdcost, 0)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col,
|
|
|
|
&frame_mv[NEWMV][ref_frame], &rate_mv, best_rdc.rdcost, 0)) {
|
|
|
|
continue;
|
|
|
|
}
|
2015-03-11 18:16:39 +01:00
|
|
|
} else if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col,
|
2016-01-15 18:35:41 +01:00
|
|
|
&frame_mv[NEWMV][ref_frame], &rate_mv, best_rdc.rdcost, 0)) {
|
2014-08-17 02:03:59 +02:00
|
|
|
continue;
|
2015-03-11 18:16:39 +01:00
|
|
|
}
|
|
|
|
}
|
2014-03-07 23:06:20 +01:00
|
|
|
|
2015-03-18 02:40:40 +01:00
|
|
|
if (this_mode == NEWMV && ref_frame == LAST_FRAME &&
|
|
|
|
frame_mv[NEWMV][LAST_FRAME].as_int != INVALID_MV) {
|
|
|
|
const int pre_stride = xd->plane[0].pre[0].stride;
|
|
|
|
const uint8_t * const pre_buf = xd->plane[0].pre[0].buf +
|
|
|
|
(frame_mv[NEWMV][LAST_FRAME].as_mv.row >> 3) * pre_stride +
|
|
|
|
(frame_mv[NEWMV][LAST_FRAME].as_mv.col >> 3);
|
|
|
|
best_pred_sad = cpi->fn_ptr[bsize].sdf(x->plane[0].src.buf,
|
|
|
|
x->plane[0].src.stride,
|
|
|
|
pre_buf, pre_stride);
|
2015-03-21 01:13:13 +01:00
|
|
|
x->pred_mv_sad[LAST_FRAME] = best_pred_sad;
|
2015-03-18 02:40:40 +01:00
|
|
|
}
|
|
|
|
|
2015-08-05 01:12:27 +02:00
|
|
|
if (cpi->use_svc) {
|
|
|
|
if (this_mode == NEWMV && ref_frame == GOLDEN_FRAME &&
|
|
|
|
frame_mv[NEWMV][GOLDEN_FRAME].as_int != INVALID_MV) {
|
|
|
|
const int pre_stride = xd->plane[0].pre[0].stride;
|
|
|
|
const uint8_t * const pre_buf = xd->plane[0].pre[0].buf +
|
|
|
|
(frame_mv[NEWMV][GOLDEN_FRAME].as_mv.row >> 3) * pre_stride +
|
|
|
|
(frame_mv[NEWMV][GOLDEN_FRAME].as_mv.col >> 3);
|
|
|
|
best_pred_sad = cpi->fn_ptr[bsize].sdf(x->plane[0].src.buf,
|
|
|
|
x->plane[0].src.stride,
|
|
|
|
pre_buf, pre_stride);
|
|
|
|
x->pred_mv_sad[GOLDEN_FRAME] = best_pred_sad;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-03-16 23:05:01 +01:00
|
|
|
if (this_mode != NEARESTMV &&
|
|
|
|
frame_mv[this_mode][ref_frame].as_int ==
|
|
|
|
frame_mv[NEARESTMV][ref_frame].as_int)
|
2015-03-11 18:16:39 +01:00
|
|
|
continue;
|
2014-02-26 01:12:35 +01:00
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = this_mode;
|
|
|
|
mi->mv[0].as_int = frame_mv[this_mode][ref_frame].as_int;
|
2015-03-11 18:16:39 +01:00
|
|
|
|
|
|
|
// Search for the best prediction filter type, when the resulting
|
|
|
|
// motion vector is at sub-pixel accuracy level for luma component, i.e.,
|
|
|
|
// the last three bits are all zeros.
|
|
|
|
if (reuse_inter_pred) {
|
|
|
|
if (!this_mode_pred) {
|
|
|
|
this_mode_pred = &tmp[3];
|
|
|
|
} else {
|
|
|
|
this_mode_pred = &tmp[get_pred_buffer(tmp, 3)];
|
|
|
|
pd->dst.buf = this_mode_pred->data;
|
|
|
|
pd->dst.stride = bw;
|
2014-06-20 19:11:34 +02:00
|
|
|
}
|
2015-03-11 18:16:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((this_mode == NEWMV || filter_ref == SWITCHABLE) && pred_filter_search
|
2015-08-05 01:12:27 +02:00
|
|
|
&& (ref_frame == LAST_FRAME ||
|
|
|
|
(ref_frame == GOLDEN_FRAME && cpi->use_svc))
|
2016-01-20 01:40:20 +01:00
|
|
|
&& (((mi->mv[0].as_mv.row | mi->mv[0].as_mv.col) & 0x07) != 0)) {
|
2015-03-11 18:16:39 +01:00
|
|
|
int pf_rate[3];
|
|
|
|
int64_t pf_dist[3];
|
|
|
|
unsigned int pf_var[3];
|
|
|
|
unsigned int pf_sse[3];
|
|
|
|
TX_SIZE pf_tx_size[3];
|
|
|
|
int64_t best_cost = INT64_MAX;
|
|
|
|
INTERP_FILTER best_filter = SWITCHABLE, filter;
|
|
|
|
PRED_BUFFER *current_pred = this_mode_pred;
|
|
|
|
|
2015-05-05 01:54:12 +02:00
|
|
|
for (filter = EIGHTTAP; filter <= EIGHTTAP_SMOOTH; ++filter) {
|
2015-03-11 18:16:39 +01:00
|
|
|
int64_t cost;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->interp_filter = filter;
|
2015-03-11 18:16:39 +01:00
|
|
|
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
|
|
|
|
model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[filter], &pf_dist[filter],
|
|
|
|
&pf_var[filter], &pf_sse[filter]);
|
|
|
|
pf_rate[filter] += vp9_get_switchable_rate(cpi, xd);
|
|
|
|
cost = RDCOST(x->rdmult, x->rddiv, pf_rate[filter], pf_dist[filter]);
|
2016-01-20 01:40:20 +01:00
|
|
|
pf_tx_size[filter] = mi->tx_size;
|
2015-03-11 18:16:39 +01:00
|
|
|
if (cost < best_cost) {
|
|
|
|
best_filter = filter;
|
|
|
|
best_cost = cost;
|
|
|
|
skip_txfm = x->skip_txfm[0];
|
|
|
|
|
|
|
|
if (reuse_inter_pred) {
|
|
|
|
if (this_mode_pred != current_pred) {
|
|
|
|
free_pred_buffer(this_mode_pred);
|
|
|
|
this_mode_pred = current_pred;
|
|
|
|
}
|
2014-06-20 19:11:34 +02:00
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
if (filter < EIGHTTAP_SHARP) {
|
|
|
|
current_pred = &tmp[get_pred_buffer(tmp, 3)];
|
|
|
|
pd->dst.buf = current_pred->data;
|
|
|
|
pd->dst.stride = bw;
|
2014-06-20 19:11:34 +02:00
|
|
|
}
|
2014-05-15 20:10:13 +02:00
|
|
|
}
|
2014-04-05 00:59:10 +02:00
|
|
|
}
|
2015-03-11 18:16:39 +01:00
|
|
|
}
|
2014-04-05 00:59:10 +02:00
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
if (reuse_inter_pred && this_mode_pred != current_pred)
|
|
|
|
free_pred_buffer(current_pred);
|
2014-06-20 19:11:34 +02:00
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->interp_filter = best_filter;
|
|
|
|
mi->tx_size = pf_tx_size[best_filter];
|
2015-03-16 22:53:08 +01:00
|
|
|
this_rdc.rate = pf_rate[best_filter];
|
|
|
|
this_rdc.dist = pf_dist[best_filter];
|
|
|
|
var_y = pf_var[best_filter];
|
|
|
|
sse_y = pf_sse[best_filter];
|
2015-03-11 18:16:39 +01:00
|
|
|
x->skip_txfm[0] = skip_txfm;
|
2015-03-27 01:08:35 +01:00
|
|
|
if (reuse_inter_pred) {
|
|
|
|
pd->dst.buf = this_mode_pred->data;
|
|
|
|
pd->dst.stride = this_mode_pred->stride;
|
|
|
|
}
|
2015-03-11 18:16:39 +01:00
|
|
|
} else {
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->interp_filter = (filter_ref == SWITCHABLE) ? EIGHTTAP : filter_ref;
|
2015-03-11 18:16:39 +01:00
|
|
|
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
|
2015-03-25 22:19:29 +01:00
|
|
|
|
|
|
|
// For large partition blocks, extra testing is done.
|
2015-04-02 18:50:44 +02:00
|
|
|
if (bsize > BLOCK_32X32 &&
|
2016-01-20 01:40:20 +01:00
|
|
|
!cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id) &&
|
2015-04-02 18:50:44 +02:00
|
|
|
cm->base_qindex) {
|
2015-03-25 22:19:29 +01:00
|
|
|
model_rd_for_sb_y_large(cpi, bsize, x, xd, &this_rdc.rate,
|
|
|
|
&this_rdc.dist, &var_y, &sse_y, mi_row, mi_col,
|
|
|
|
&this_early_term);
|
|
|
|
} else {
|
|
|
|
model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist,
|
|
|
|
&var_y, &sse_y);
|
|
|
|
}
|
2015-03-11 18:16:39 +01:00
|
|
|
}
|
2014-04-05 00:59:10 +02:00
|
|
|
|
2015-04-03 20:33:24 +02:00
|
|
|
if (!this_early_term) {
|
2015-04-01 02:46:41 +02:00
|
|
|
this_sse = (int64_t)sse_y;
|
2015-03-30 20:09:29 +02:00
|
|
|
block_yrd(cpi, x, &this_rdc.rate, &this_rdc.dist, &is_skippable,
|
2016-01-20 01:40:20 +01:00
|
|
|
&this_sse, 0, bsize, VPXMIN(mi->tx_size, TX_16X16));
|
2015-03-30 20:09:29 +02:00
|
|
|
x->skip_txfm[0] = is_skippable;
|
|
|
|
if (is_skippable) {
|
2015-03-23 18:02:42 +01:00
|
|
|
this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
|
2015-03-30 20:09:29 +02:00
|
|
|
} else {
|
|
|
|
if (RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist) <
|
|
|
|
RDCOST(x->rdmult, x->rddiv, 0, this_sse)) {
|
|
|
|
this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0);
|
|
|
|
} else {
|
|
|
|
this_rdc.rate = vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
|
|
|
|
this_rdc.dist = this_sse;
|
2015-07-30 20:52:28 +02:00
|
|
|
x->skip_txfm[0] = SKIP_TXFM_AC_DC;
|
2015-03-30 20:09:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cm->interp_filter == SWITCHABLE) {
|
2016-01-20 01:40:20 +01:00
|
|
|
if ((mi->mv[0].as_mv.row | mi->mv[0].as_mv.col) & 0x07)
|
2015-03-30 20:09:29 +02:00
|
|
|
this_rdc.rate += vp9_get_switchable_rate(cpi, xd);
|
2015-03-23 18:02:42 +01:00
|
|
|
}
|
2015-04-03 20:33:24 +02:00
|
|
|
} else {
|
2015-04-07 21:39:54 +02:00
|
|
|
this_rdc.rate += cm->interp_filter == SWITCHABLE ?
|
|
|
|
vp9_get_switchable_rate(cpi, xd) : 0;
|
2015-04-03 20:33:24 +02:00
|
|
|
this_rdc.rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
|
2015-03-23 18:02:42 +01:00
|
|
|
}
|
|
|
|
|
2015-03-30 20:09:29 +02:00
|
|
|
if (x->color_sensitivity[0] || x->color_sensitivity[1]) {
|
|
|
|
int uv_rate = 0;
|
|
|
|
int64_t uv_dist = 0;
|
2015-09-03 23:52:39 +02:00
|
|
|
const BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
|
2015-03-30 20:09:29 +02:00
|
|
|
if (x->color_sensitivity[0])
|
|
|
|
vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, 1);
|
|
|
|
if (x->color_sensitivity[1])
|
|
|
|
vp9_build_inter_predictors_sbp(xd, mi_row, mi_col, bsize, 2);
|
2015-09-03 23:52:39 +02:00
|
|
|
model_rd_for_sb_uv(cpi, uv_bsize, x, xd, &uv_rate, &uv_dist,
|
|
|
|
&var_y, &sse_y, 1, 2);
|
2015-03-30 20:09:29 +02:00
|
|
|
this_rdc.rate += uv_rate;
|
|
|
|
this_rdc.dist += uv_dist;
|
2015-03-11 18:16:39 +01:00
|
|
|
}
|
2015-01-21 18:32:23 +01:00
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
this_rdc.rate += rate_mv;
|
|
|
|
this_rdc.rate +=
|
2015-06-29 18:27:11 +02:00
|
|
|
cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]][INTER_OFFSET(
|
2015-03-11 18:16:39 +01:00
|
|
|
this_mode)];
|
|
|
|
this_rdc.rate += ref_frame_cost[ref_frame];
|
|
|
|
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, this_rdc.rate, this_rdc.dist);
|
|
|
|
|
2016-02-25 01:16:44 +01:00
|
|
|
if (cpi->oxcf.rc_mode == VPX_CBR &&
|
|
|
|
cpi->oxcf.speed >= 5 &&
|
2016-01-22 20:45:31 +01:00
|
|
|
cpi->oxcf.content != VP9E_CONTENT_SCREEN &&
|
|
|
|
!x->sb_is_skin) {
|
2015-11-09 22:36:56 +01:00
|
|
|
// Bias against non-zero (above some threshold) motion for large blocks.
|
|
|
|
// This is temporary fix to avoid selection of large mv for big blocks.
|
|
|
|
if (frame_mv[this_mode][ref_frame].as_mv.row > 64 ||
|
|
|
|
frame_mv[this_mode][ref_frame].as_mv.row < -64 ||
|
|
|
|
frame_mv[this_mode][ref_frame].as_mv.col > 64 ||
|
|
|
|
frame_mv[this_mode][ref_frame].as_mv.col < -64) {
|
|
|
|
if (bsize == BLOCK_64X64)
|
|
|
|
this_rdc.rdcost = this_rdc.rdcost << 1;
|
|
|
|
else if (bsize >= BLOCK_32X32)
|
|
|
|
this_rdc.rdcost = 3 * this_rdc.rdcost >> 1;
|
|
|
|
}
|
|
|
|
// If noise estimation is enabled, and estimated level is above threshold,
|
|
|
|
// add a bias to LAST reference with small motion, for large blocks.
|
|
|
|
if (cpi->noise_estimate.enabled &&
|
|
|
|
cpi->noise_estimate.level >= kMedium &&
|
|
|
|
bsize >= BLOCK_32X32 &&
|
|
|
|
ref_frame == LAST_FRAME &&
|
|
|
|
frame_mv[this_mode][ref_frame].as_mv.row < 8 &&
|
|
|
|
frame_mv[this_mode][ref_frame].as_mv.row > -8 &&
|
|
|
|
frame_mv[this_mode][ref_frame].as_mv.col < 8 &&
|
|
|
|
frame_mv[this_mode][ref_frame].as_mv.col > -8)
|
|
|
|
this_rdc.rdcost = 7 * this_rdc.rdcost >> 3;
|
2015-10-30 19:51:06 +01:00
|
|
|
}
|
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
// Skipping checking: test to see if this block can be reconstructed by
|
|
|
|
// prediction only.
|
|
|
|
if (cpi->allow_encode_breakout) {
|
|
|
|
encode_breakout_test(cpi, x, bsize, mi_row, mi_col, ref_frame, this_mode,
|
|
|
|
var_y, sse_y, yv12_mb, &this_rdc.rate,
|
|
|
|
&this_rdc.dist);
|
|
|
|
if (x->skip) {
|
|
|
|
this_rdc.rate += rate_mv;
|
|
|
|
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, this_rdc.rate,
|
|
|
|
this_rdc.dist);
|
2014-05-07 19:39:00 +02:00
|
|
|
}
|
2015-03-11 18:16:39 +01:00
|
|
|
}
|
2014-05-07 19:39:00 +02:00
|
|
|
|
2014-07-24 22:30:00 +02:00
|
|
|
#if CONFIG_VP9_TEMPORAL_DENOISING
|
2016-04-04 20:05:21 +02:00
|
|
|
if (cpi->oxcf.noise_sensitivity > 0 &&
|
|
|
|
cpi->denoiser.denoising_level > kDenLowLow) {
|
2016-01-20 01:40:20 +01:00
|
|
|
vp9_denoiser_update_frame_stats(mi, sse_y, this_mode, ctx);
|
2015-11-14 00:58:42 +01:00
|
|
|
// Keep track of zero_last cost.
|
|
|
|
if (ref_frame == LAST_FRAME && frame_mv[this_mode][ref_frame].as_int == 0)
|
|
|
|
zero_last_cost_orig = this_rdc.rdcost;
|
|
|
|
}
|
2014-08-17 01:58:31 +02:00
|
|
|
#else
|
2015-03-11 18:16:39 +01:00
|
|
|
(void)ctx;
|
2014-06-05 23:00:08 +02:00
|
|
|
#endif
|
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
if (this_rdc.rdcost < best_rdc.rdcost || x->skip) {
|
|
|
|
best_rdc = this_rdc;
|
|
|
|
best_mode = this_mode;
|
2016-01-20 01:40:20 +01:00
|
|
|
best_pred_filter = mi->interp_filter;
|
|
|
|
best_tx_size = mi->tx_size;
|
2015-03-11 18:16:39 +01:00
|
|
|
best_ref_frame = ref_frame;
|
|
|
|
best_mode_skip_txfm = x->skip_txfm[0];
|
2015-03-25 22:19:29 +01:00
|
|
|
best_early_term = this_early_term;
|
2014-05-07 19:39:00 +02:00
|
|
|
|
2015-03-11 18:16:39 +01:00
|
|
|
if (reuse_inter_pred) {
|
|
|
|
free_pred_buffer(best_pred);
|
|
|
|
best_pred = this_mode_pred;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (reuse_inter_pred)
|
|
|
|
free_pred_buffer(this_mode_pred);
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
Enable mode search threshold update in non-RD coding mode
Adaptively adjust the mode thresholds after each mode search round
to skip checking less likely selected modes. Local tests indicate
5% - 10% speed-up in speed -5 and -6. Average coding performance
loss is -1.055%.
speed -5
vidyo1 720p 1000 kbps
16533 b/f, 40.851 dB, 12607 ms -> 16556 b/f, 40.796 dB, 11831 ms
nik 720p 1000 kbps
33229 b/f, 39.127 dB, 11468 ms -> 33235 b/f, 39.131 dB, 10919 ms
speed -6
vidyo1 720p 1000 kbps
16549 b/f, 40.268 dB, 10138 ms -> 16538 b/f, 40.212 dB, 8456 ms
nik 720p 1000 kbps
33271 b/f, 38.433 dB, 7886 ms -> 33279 b/f, 38.416 dB, 7843 ms
Change-Id: I2c2963f1ce4ed9c1cf233b5b2c880b682e1c1e8b
2014-10-28 22:50:10 +01:00
|
|
|
|
2014-11-07 22:44:17 +01:00
|
|
|
if (x->skip)
|
|
|
|
break;
|
2015-03-25 22:19:29 +01:00
|
|
|
|
|
|
|
// If early termination flag is 1 and at least 2 modes are checked,
|
|
|
|
// the mode search is terminated.
|
|
|
|
if (best_early_term && idx > 0) {
|
|
|
|
x->skip = 1;
|
|
|
|
break;
|
|
|
|
}
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = best_mode;
|
|
|
|
mi->interp_filter = best_pred_filter;
|
|
|
|
mi->tx_size = best_tx_size;
|
|
|
|
mi->ref_frame[0] = best_ref_frame;
|
|
|
|
mi->mv[0].as_int = frame_mv[best_mode][best_ref_frame].as_int;
|
|
|
|
xd->mi[0]->bmi[0].as_mv[0].as_int = mi->mv[0].as_int;
|
Adaptively adjust mode test kick-off thresholds in RTC coding
This commit allows the encoder to increase the mode test kick-off
thresholds if the previous best mode renders all zero quantized
coefficients, thereby saving motion search runs when possible.
The compression performance of speed -5 and -6 is down by -0.446%
and 0.591%, respectively. The runtime of speed -6 is improved by
10% for many test clips.
vidyo1, 1000 kbps
16578 b/f, 40.316 dB, 7873 ms -> 16575 b/f, 40.262 dB, 7126 ms
nik720p, 1000 kbps
33311 b/f, 38.651 dB, 7263 ms -> 33304 b/f, 38.629 dB, 6865 ms
dark720p, 1000 kbps
33331 b/f, 39.718 dB, 13596 ms -> 33324 b/f, 39.651 dB, 12000 ms
mmoving, 1000 kbps
33263 b/f, 40.983 dB, 7566 ms -> 33259 b/f, 40.978 dB, 7531 ms
Change-Id: I7591617ff113e91125ec32c9b853e257fbc41d90
2014-11-24 23:40:42 +01:00
|
|
|
x->skip_txfm[0] = best_mode_skip_txfm;
|
2014-02-25 22:50:32 +01:00
|
|
|
|
2016-03-16 19:53:43 +01:00
|
|
|
// For spatial enhancemanent layer: perform intra prediction only if base
|
|
|
|
// layer is chosen as the reference. Always perform intra prediction if
|
|
|
|
// LAST is the only reference or is_key_frame is set.
|
2016-01-15 18:35:41 +01:00
|
|
|
if (cpi->svc.spatial_layer_id) {
|
|
|
|
perform_intra_pred =
|
|
|
|
cpi->svc.layer_context[cpi->svc.temporal_layer_id].is_key_frame ||
|
2016-03-16 19:53:43 +01:00
|
|
|
!(cpi->ref_frame_flags & flag_list[GOLDEN_FRAME]) ||
|
2016-01-15 18:35:41 +01:00
|
|
|
(!cpi->svc.layer_context[cpi->svc.temporal_layer_id].is_key_frame
|
2016-03-16 19:53:43 +01:00
|
|
|
&& svc_force_zero_mode[best_ref_frame - 1]);
|
2016-01-15 18:35:41 +01:00
|
|
|
inter_mode_thresh = (inter_mode_thresh << 1) + inter_mode_thresh;
|
|
|
|
}
|
2014-02-20 00:30:09 +01:00
|
|
|
// Perform intra prediction search, if the best SAD is above a certain
|
|
|
|
// threshold.
|
2016-01-15 18:35:41 +01:00
|
|
|
if (perform_intra_pred &&
|
|
|
|
((best_rdc.rdcost == INT64_MAX ||
|
2014-12-18 20:54:13 +01:00
|
|
|
(!x->skip && best_rdc.rdcost > inter_mode_thresh &&
|
2016-01-15 18:35:41 +01:00
|
|
|
bsize <= cpi->sf.max_intra_bsize)))) {
|
2016-04-11 23:02:34 +02:00
|
|
|
struct estimate_block_intra_args args = { cpi, x, DC_PRED, 1, 0, 0 };
|
2014-10-25 00:57:48 +02:00
|
|
|
int i;
|
2014-12-17 01:02:58 +01:00
|
|
|
TX_SIZE best_intra_tx_size = TX_SIZES;
|
2015-09-22 19:42:55 +02:00
|
|
|
TX_SIZE intra_tx_size =
|
|
|
|
VPXMIN(max_txsize_lookup[bsize],
|
|
|
|
tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
|
|
|
|
if (cpi->oxcf.content != VP9E_CONTENT_SCREEN && intra_tx_size > TX_16X16)
|
|
|
|
intra_tx_size = TX_16X16;
|
2014-06-26 01:53:07 +02:00
|
|
|
|
2014-11-17 20:21:42 +01:00
|
|
|
if (reuse_inter_pred && best_pred != NULL) {
|
|
|
|
if (best_pred->data == orig_dst.buf) {
|
|
|
|
this_mode_pred = &tmp[get_pred_buffer(tmp, 3)];
|
2014-12-04 02:48:50 +01:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (cm->use_highbitdepth)
|
2015-07-22 19:40:42 +02:00
|
|
|
vpx_highbd_convolve_copy(best_pred->data, best_pred->stride,
|
2014-12-04 02:48:50 +01:00
|
|
|
this_mode_pred->data, this_mode_pred->stride,
|
|
|
|
NULL, 0, NULL, 0, bw, bh, xd->bd);
|
|
|
|
else
|
2015-07-22 19:40:42 +02:00
|
|
|
vpx_convolve_copy(best_pred->data, best_pred->stride,
|
2014-12-04 02:48:50 +01:00
|
|
|
this_mode_pred->data, this_mode_pred->stride,
|
|
|
|
NULL, 0, NULL, 0, bw, bh);
|
|
|
|
#else
|
2015-07-22 19:40:42 +02:00
|
|
|
vpx_convolve_copy(best_pred->data, best_pred->stride,
|
2014-11-17 20:21:42 +01:00
|
|
|
this_mode_pred->data, this_mode_pred->stride,
|
|
|
|
NULL, 0, NULL, 0, bw, bh);
|
2014-12-04 02:48:50 +01:00
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2014-11-17 20:21:42 +01:00
|
|
|
best_pred = this_mode_pred;
|
|
|
|
}
|
2014-08-12 01:58:45 +02:00
|
|
|
}
|
2014-11-08 02:50:55 +01:00
|
|
|
pd->dst = orig_dst;
|
2014-06-20 19:11:34 +02:00
|
|
|
|
2014-10-25 00:57:48 +02:00
|
|
|
for (i = 0; i < 4; ++i) {
|
|
|
|
const PREDICTION_MODE this_mode = intra_mode_list[i];
|
2015-05-01 22:20:50 +02:00
|
|
|
THR_MODES mode_index = mode_idx[INTRA_FRAME][mode_offset(this_mode)];
|
|
|
|
int mode_rd_thresh = rd_threshes[mode_index];
|
2016-01-20 23:28:09 +01:00
|
|
|
if (sf->short_circuit_flat_blocks && x->source_variance == 0 &&
|
|
|
|
this_mode != DC_PRED) {
|
|
|
|
continue;
|
|
|
|
}
|
2015-05-01 22:20:50 +02:00
|
|
|
|
2015-04-30 20:39:02 +02:00
|
|
|
if (!((1 << this_mode) & cpi->sf.intra_y_mode_bsize_mask[bsize]))
|
2014-10-25 00:57:48 +02:00
|
|
|
continue;
|
2015-05-01 22:20:50 +02:00
|
|
|
|
|
|
|
if (rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh,
|
|
|
|
rd_thresh_freq_fact[mode_index]))
|
|
|
|
continue;
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = this_mode;
|
|
|
|
mi->ref_frame[0] = INTRA_FRAME;
|
2014-08-19 23:09:57 +02:00
|
|
|
args.mode = this_mode;
|
2016-04-11 23:02:34 +02:00
|
|
|
args.skippable = 1;
|
2014-08-19 23:09:57 +02:00
|
|
|
args.rate = 0;
|
|
|
|
args.dist = 0;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->tx_size = intra_tx_size;
|
2014-08-19 23:09:57 +02:00
|
|
|
vp9_foreach_transformed_block_in_plane(xd, bsize, 0,
|
|
|
|
estimate_block_intra, &args);
|
2016-04-11 23:02:34 +02:00
|
|
|
// Check skip cost here since skippable is not set for for uv, this
|
|
|
|
// mirrors the behavior used by inter
|
|
|
|
if (args.skippable) {
|
|
|
|
x->skip_txfm[0] = SKIP_TXFM_AC_DC;
|
|
|
|
args.rate = vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 1);
|
|
|
|
} else {
|
|
|
|
x->skip_txfm[0] = SKIP_TXFM_NONE;
|
|
|
|
args.rate += vp9_cost_bit(vp9_get_skip_prob(&cpi->common, xd), 0);
|
|
|
|
}
|
2015-09-03 23:52:39 +02:00
|
|
|
// Inter and intra RD will mismatch in scale for non-screen content.
|
|
|
|
if (cpi->oxcf.content == VP9E_CONTENT_SCREEN) {
|
|
|
|
if (x->color_sensitivity[0])
|
|
|
|
vp9_foreach_transformed_block_in_plane(xd, bsize, 1,
|
|
|
|
estimate_block_intra, &args);
|
|
|
|
if (x->color_sensitivity[1])
|
|
|
|
vp9_foreach_transformed_block_in_plane(xd, bsize, 2,
|
|
|
|
estimate_block_intra, &args);
|
|
|
|
}
|
2014-10-22 01:31:37 +02:00
|
|
|
this_rdc.rate = args.rate;
|
|
|
|
this_rdc.dist = args.dist;
|
|
|
|
this_rdc.rate += cpi->mbmode_cost[this_mode];
|
2015-02-11 19:51:50 +01:00
|
|
|
this_rdc.rate += ref_frame_cost[INTRA_FRAME];
|
2014-10-22 01:31:37 +02:00
|
|
|
this_rdc.rate += intra_cost_penalty;
|
|
|
|
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv,
|
|
|
|
this_rdc.rate, this_rdc.dist);
|
|
|
|
|
2014-11-24 18:31:10 +01:00
|
|
|
if (this_rdc.rdcost < best_rdc.rdcost) {
|
2014-10-22 01:31:37 +02:00
|
|
|
best_rdc = this_rdc;
|
2015-03-23 18:02:42 +01:00
|
|
|
best_mode = this_mode;
|
2016-01-20 01:40:20 +01:00
|
|
|
best_intra_tx_size = mi->tx_size;
|
2015-03-23 18:02:42 +01:00
|
|
|
best_ref_frame = INTRA_FRAME;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->uv_mode = this_mode;
|
|
|
|
mi->mv[0].as_int = INVALID_MV;
|
2015-03-23 18:02:42 +01:00
|
|
|
best_mode_skip_txfm = x->skip_txfm[0];
|
2014-02-20 00:30:09 +01:00
|
|
|
}
|
|
|
|
}
|
2014-12-15 23:43:07 +01:00
|
|
|
|
|
|
|
// Reset mb_mode_info to the best inter mode.
|
2015-03-23 18:02:42 +01:00
|
|
|
if (best_ref_frame != INTRA_FRAME) {
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->tx_size = best_tx_size;
|
2014-12-17 01:02:58 +01:00
|
|
|
} else {
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->tx_size = best_intra_tx_size;
|
2014-12-15 23:43:07 +01:00
|
|
|
}
|
2014-11-08 02:50:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pd->dst = orig_dst;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = best_mode;
|
|
|
|
mi->ref_frame[0] = best_ref_frame;
|
2015-03-23 18:02:42 +01:00
|
|
|
x->skip_txfm[0] = best_mode_skip_txfm;
|
2014-11-17 20:21:42 +01:00
|
|
|
|
|
|
|
if (reuse_inter_pred && best_pred != NULL) {
|
2016-01-20 01:40:20 +01:00
|
|
|
if (best_pred->data != orig_dst.buf && is_inter_mode(mi->mode)) {
|
2014-11-08 02:50:55 +01:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
2014-11-17 20:21:42 +01:00
|
|
|
if (cm->use_highbitdepth)
|
2015-07-22 19:40:42 +02:00
|
|
|
vpx_highbd_convolve_copy(best_pred->data, best_pred->stride,
|
2014-11-17 20:21:42 +01:00
|
|
|
pd->dst.buf, pd->dst.stride, NULL, 0,
|
|
|
|
NULL, 0, bw, bh, xd->bd);
|
|
|
|
else
|
2015-07-22 19:40:42 +02:00
|
|
|
vpx_convolve_copy(best_pred->data, best_pred->stride,
|
2014-11-17 20:21:42 +01:00
|
|
|
pd->dst.buf, pd->dst.stride, NULL, 0,
|
|
|
|
NULL, 0, bw, bh);
|
|
|
|
#else
|
2015-07-22 19:40:42 +02:00
|
|
|
vpx_convolve_copy(best_pred->data, best_pred->stride,
|
2014-11-08 02:50:55 +01:00
|
|
|
pd->dst.buf, pd->dst.stride, NULL, 0,
|
|
|
|
NULL, 0, bw, bh);
|
2014-12-04 02:48:50 +01:00
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2014-11-17 20:21:42 +01:00
|
|
|
}
|
2014-02-20 00:30:09 +01:00
|
|
|
}
|
2014-10-22 01:31:37 +02:00
|
|
|
|
2015-11-14 00:58:42 +01:00
|
|
|
#if CONFIG_VP9_TEMPORAL_DENOISING
|
|
|
|
if (cpi->oxcf.noise_sensitivity > 0 &&
|
2016-04-04 20:05:21 +02:00
|
|
|
cpi->resize_pending == 0 &&
|
|
|
|
cpi->denoiser.denoising_level > kDenLowLow &&
|
|
|
|
cpi->denoiser.reset == 0) {
|
2015-11-14 00:58:42 +01:00
|
|
|
VP9_DENOISER_DECISION decision = COPY_BLOCK;
|
2016-04-28 07:18:11 +02:00
|
|
|
vp9_denoiser_denoise(cpi, x, mi_row, mi_col, bsize, ctx, &decision);
|
2015-12-01 18:30:35 +01:00
|
|
|
// If INTRA or GOLDEN reference was selected, re-evaluate ZEROMV on denoised
|
|
|
|
// result. Only do this under noise conditions, and if rdcost of ZEROMV on
|
|
|
|
// original source is not significantly higher than rdcost of best mode.
|
|
|
|
if (((best_ref_frame == INTRA_FRAME && decision >= FILTER_BLOCK) ||
|
|
|
|
(best_ref_frame == GOLDEN_FRAME && decision == FILTER_ZEROMV_BLOCK)) &&
|
2015-11-14 00:58:42 +01:00
|
|
|
cpi->noise_estimate.enabled &&
|
|
|
|
cpi->noise_estimate.level > kLow &&
|
2015-12-03 22:47:27 +01:00
|
|
|
zero_last_cost_orig < (best_rdc.rdcost << 3)) {
|
2015-11-14 00:58:42 +01:00
|
|
|
// Check if we should pick ZEROMV on denoised signal.
|
|
|
|
int rate = 0;
|
|
|
|
int64_t dist = 0;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = ZEROMV;
|
|
|
|
mi->ref_frame[0] = LAST_FRAME;
|
|
|
|
mi->ref_frame[1] = NONE;
|
|
|
|
mi->mv[0].as_int = 0;
|
|
|
|
mi->interp_filter = EIGHTTAP;
|
2015-11-30 17:57:49 +01:00
|
|
|
xd->plane[0].pre[0] = yv12_mb[LAST_FRAME][0];
|
2015-11-14 00:58:42 +01:00
|
|
|
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
|
|
|
|
model_rd_for_sb_y(cpi, bsize, x, xd, &rate, &dist, &var_y, &sse_y);
|
|
|
|
this_rdc.rate = rate + ref_frame_cost[LAST_FRAME] +
|
|
|
|
cpi->inter_mode_cost[x->mbmi_ext->mode_context[LAST_FRAME]]
|
|
|
|
[INTER_OFFSET(ZEROMV)];
|
|
|
|
this_rdc.dist = dist;
|
|
|
|
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, rate, dist);
|
|
|
|
// Switch to ZEROMV if the rdcost for ZEROMV on denoised source
|
2015-12-01 18:30:35 +01:00
|
|
|
// is lower than best_ref mode (on original source).
|
2015-11-14 00:58:42 +01:00
|
|
|
if (this_rdc.rdcost > best_rdc.rdcost) {
|
|
|
|
this_rdc = best_rdc;
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = best_mode;
|
|
|
|
mi->ref_frame[0] = best_ref_frame;
|
|
|
|
mi->interp_filter = best_pred_filter;
|
2015-12-01 18:30:35 +01:00
|
|
|
if (best_ref_frame == INTRA_FRAME)
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mv[0].as_int = INVALID_MV;
|
2015-12-01 18:30:35 +01:00
|
|
|
else if (best_ref_frame == GOLDEN_FRAME) {
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mv[0].as_int = frame_mv[best_mode][best_ref_frame].as_int;
|
2015-12-01 18:30:35 +01:00
|
|
|
if (reuse_inter_pred) {
|
|
|
|
xd->plane[0].pre[0] = yv12_mb[GOLDEN_FRAME][0];
|
|
|
|
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
|
|
|
|
}
|
|
|
|
}
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->tx_size = best_tx_size;
|
2015-11-14 00:58:42 +01:00
|
|
|
x->skip_txfm[0] = best_mode_skip_txfm;
|
|
|
|
} else {
|
|
|
|
best_ref_frame = LAST_FRAME;
|
|
|
|
best_rdc = this_rdc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
Rework mode search threshold update for RTC coding mode
In RTC coding mode, the alternate reference frame modes and compound
inter prediction modes are disabled. This commit reworks the
related mode search threshold update process to skip interacting
with these coding modes. It provides about 1.5% speed-up for speed
-6 on average.
vidyo1
16551 b/f, 40.451 dB, 6261 ms -> 16550 b/f, 40.459 dB, 6190 ms
nik720p
33316 b/f, 38.795 dB, 6335 ms -> 33310 b/f, 38.798 dB, 6237 ms
mmmoving
33265 b/f, 41.055 dB, 7176 ms -> 33267 b/f, 41.064 dB, 7084 ms
dark720
33329 b/f, 39.729 dB, 11235 ms -> 33331 b/f, 39.733 dB, 10731 ms
Change-Id: If2a4090a371cd28f579be219c013b972d7d9b97f
2014-12-17 23:26:00 +01:00
|
|
|
if (cpi->sf.adaptive_rd_thresh) {
|
2016-01-20 01:40:20 +01:00
|
|
|
THR_MODES best_mode_idx = mode_idx[best_ref_frame][mode_offset(mi->mode)];
|
2015-05-01 22:20:50 +02:00
|
|
|
|
|
|
|
if (best_ref_frame == INTRA_FRAME) {
|
|
|
|
// Only consider the modes that are included in the intra_mode_list.
|
|
|
|
int intra_modes = sizeof(intra_mode_list)/sizeof(PREDICTION_MODE);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
// TODO(yunqingwang): Check intra mode mask and only update freq_fact
|
|
|
|
// for those valid modes.
|
|
|
|
for (i = 0; i < intra_modes; i++) {
|
|
|
|
update_thresh_freq_fact(cpi, tile_data, bsize, INTRA_FRAME,
|
2015-05-12 23:36:46 +02:00
|
|
|
best_mode_idx, intra_mode_list[i]);
|
2015-05-01 22:20:50 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (ref_frame = LAST_FRAME; ref_frame <= GOLDEN_FRAME; ++ref_frame) {
|
2015-05-12 23:36:46 +02:00
|
|
|
PREDICTION_MODE this_mode;
|
2015-05-01 22:20:50 +02:00
|
|
|
if (best_ref_frame != ref_frame) continue;
|
|
|
|
for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) {
|
|
|
|
update_thresh_freq_fact(cpi, tile_data, bsize, ref_frame,
|
|
|
|
best_mode_idx, this_mode);
|
|
|
|
}
|
Rework mode search threshold update for RTC coding mode
In RTC coding mode, the alternate reference frame modes and compound
inter prediction modes are disabled. This commit reworks the
related mode search threshold update process to skip interacting
with these coding modes. It provides about 1.5% speed-up for speed
-6 on average.
vidyo1
16551 b/f, 40.451 dB, 6261 ms -> 16550 b/f, 40.459 dB, 6190 ms
nik720p
33316 b/f, 38.795 dB, 6335 ms -> 33310 b/f, 38.798 dB, 6237 ms
mmmoving
33265 b/f, 41.055 dB, 7176 ms -> 33267 b/f, 41.064 dB, 7084 ms
dark720
33329 b/f, 39.729 dB, 11235 ms -> 33331 b/f, 39.733 dB, 10731 ms
Change-Id: If2a4090a371cd28f579be219c013b972d7d9b97f
2014-12-17 23:26:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
Enable mode search threshold update in non-RD coding mode
Adaptively adjust the mode thresholds after each mode search round
to skip checking less likely selected modes. Local tests indicate
5% - 10% speed-up in speed -5 and -6. Average coding performance
loss is -1.055%.
speed -5
vidyo1 720p 1000 kbps
16533 b/f, 40.851 dB, 12607 ms -> 16556 b/f, 40.796 dB, 11831 ms
nik 720p 1000 kbps
33229 b/f, 39.127 dB, 11468 ms -> 33235 b/f, 39.131 dB, 10919 ms
speed -6
vidyo1 720p 1000 kbps
16549 b/f, 40.268 dB, 10138 ms -> 16538 b/f, 40.212 dB, 8456 ms
nik 720p 1000 kbps
33271 b/f, 38.433 dB, 7886 ms -> 33279 b/f, 38.416 dB, 7843 ms
Change-Id: I2c2963f1ce4ed9c1cf233b5b2c880b682e1c1e8b
2014-10-28 22:50:10 +01:00
|
|
|
|
2014-10-22 01:31:37 +02:00
|
|
|
*rd_cost = best_rdc;
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
2014-12-22 22:38:34 +01:00
|
|
|
|
|
|
|
void vp9_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
|
|
|
|
int mi_row, int mi_col, RD_COST *rd_cost,
|
|
|
|
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
SPEED_FEATURES *const sf = &cpi->sf;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2016-01-20 01:40:20 +01:00
|
|
|
MODE_INFO *const mi = xd->mi[0];
|
2015-06-29 18:27:11 +02:00
|
|
|
MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
|
2014-12-22 22:38:34 +01:00
|
|
|
const struct segmentation *const seg = &cm->seg;
|
|
|
|
MV_REFERENCE_FRAME ref_frame, second_ref_frame = NONE;
|
|
|
|
MV_REFERENCE_FRAME best_ref_frame = NONE;
|
2016-01-20 01:40:20 +01:00
|
|
|
unsigned char segment_id = mi->segment_id;
|
2014-12-22 22:38:34 +01:00
|
|
|
struct buf_2d yv12_mb[4][MAX_MB_PLANE];
|
|
|
|
static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
|
|
|
|
VP9_ALT_FLAG };
|
|
|
|
int64_t best_rd = INT64_MAX;
|
|
|
|
b_mode_info bsi[MAX_REF_FRAMES][4];
|
|
|
|
int ref_frame_skip_mask = 0;
|
|
|
|
const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
|
|
|
|
const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
|
|
|
|
int idx, idy;
|
|
|
|
|
|
|
|
x->skip_encode = sf->skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
|
|
|
|
ctx->pred_pixel_ready = 0;
|
|
|
|
|
2015-01-07 20:49:07 +01:00
|
|
|
for (ref_frame = LAST_FRAME; ref_frame <= GOLDEN_FRAME; ++ref_frame) {
|
2015-02-18 18:40:34 +01:00
|
|
|
const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
|
2014-12-30 22:13:42 +01:00
|
|
|
int_mv dummy_mv[2];
|
|
|
|
x->pred_mv_sad[ref_frame] = INT_MAX;
|
|
|
|
|
2015-02-18 18:40:34 +01:00
|
|
|
if ((cpi->ref_frame_flags & flag_list[ref_frame]) && (yv12 != NULL)) {
|
2015-06-29 18:27:11 +02:00
|
|
|
int_mv *const candidates = mbmi_ext->ref_mvs[ref_frame];
|
2014-12-30 22:13:42 +01:00
|
|
|
const struct scale_factors *const sf =
|
2014-12-22 22:38:34 +01:00
|
|
|
&cm->frame_refs[ref_frame - 1].sf;
|
2014-12-30 22:13:42 +01:00
|
|
|
vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col,
|
|
|
|
sf, sf);
|
2015-06-16 15:38:34 +02:00
|
|
|
vp9_find_mv_refs(cm, xd, xd->mi[0], ref_frame,
|
2016-01-13 22:30:40 +01:00
|
|
|
candidates, mi_row, mi_col, mbmi_ext->mode_context);
|
2014-12-22 22:38:34 +01:00
|
|
|
|
2014-12-30 22:13:42 +01:00
|
|
|
vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates,
|
|
|
|
&dummy_mv[0], &dummy_mv[1]);
|
|
|
|
} else {
|
|
|
|
ref_frame_skip_mask |= (1 << ref_frame);
|
|
|
|
}
|
2014-12-22 22:38:34 +01:00
|
|
|
}
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->sb_type = bsize;
|
|
|
|
mi->tx_size = TX_4X4;
|
|
|
|
mi->uv_mode = DC_PRED;
|
|
|
|
mi->ref_frame[0] = LAST_FRAME;
|
|
|
|
mi->ref_frame[1] = NONE;
|
|
|
|
mi->interp_filter = cm->interp_filter == SWITCHABLE ? EIGHTTAP
|
|
|
|
: cm->interp_filter;
|
2014-12-22 22:38:34 +01:00
|
|
|
|
|
|
|
for (ref_frame = LAST_FRAME; ref_frame <= GOLDEN_FRAME; ++ref_frame) {
|
|
|
|
int64_t this_rd = 0;
|
|
|
|
int plane;
|
|
|
|
|
|
|
|
if (ref_frame_skip_mask & (1 << ref_frame))
|
|
|
|
continue;
|
|
|
|
|
2016-01-07 18:43:26 +01:00
|
|
|
#if CONFIG_BETTER_HW_COMPATIBILITY
|
|
|
|
if ((bsize == BLOCK_8X4 || bsize == BLOCK_4X8) &&
|
|
|
|
ref_frame > INTRA_FRAME &&
|
|
|
|
vp9_is_scaled(&cm->frame_refs[ref_frame - 1].sf))
|
|
|
|
continue;
|
|
|
|
#endif
|
|
|
|
|
2014-12-22 22:38:34 +01:00
|
|
|
// TODO(jingning, agrange): Scaling reference frame not supported for
|
|
|
|
// sub8x8 blocks. Is this supported now?
|
|
|
|
if (ref_frame > INTRA_FRAME &&
|
|
|
|
vp9_is_scaled(&cm->frame_refs[ref_frame - 1].sf))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If the segment reference frame feature is enabled....
|
|
|
|
// then do nothing if the current ref frame is not allowed..
|
2015-06-11 13:20:55 +02:00
|
|
|
if (segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) &&
|
2015-06-11 18:52:00 +02:00
|
|
|
get_segdata(seg, segment_id, SEG_LVL_REF_FRAME) != (int)ref_frame)
|
2014-12-22 22:38:34 +01:00
|
|
|
continue;
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->ref_frame[0] = ref_frame;
|
2014-12-22 22:38:34 +01:00
|
|
|
x->skip = 0;
|
|
|
|
set_ref_ptrs(cm, xd, ref_frame, second_ref_frame);
|
|
|
|
|
|
|
|
// Select prediction reference frames.
|
|
|
|
for (plane = 0; plane < MAX_MB_PLANE; plane++)
|
|
|
|
xd->plane[plane].pre[0] = yv12_mb[ref_frame][plane];
|
|
|
|
|
|
|
|
for (idy = 0; idy < 2; idy += num_4x4_blocks_high) {
|
|
|
|
for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
|
2014-12-30 22:13:42 +01:00
|
|
|
int_mv b_mv[MB_MODE_COUNT];
|
2014-12-22 22:38:34 +01:00
|
|
|
int64_t b_best_rd = INT64_MAX;
|
|
|
|
const int i = idy * 2 + idx;
|
|
|
|
PREDICTION_MODE this_mode;
|
|
|
|
RD_COST this_rdc;
|
|
|
|
unsigned int var_y, sse_y;
|
|
|
|
|
|
|
|
struct macroblock_plane *p = &x->plane[0];
|
|
|
|
struct macroblockd_plane *pd = &xd->plane[0];
|
|
|
|
|
|
|
|
const struct buf_2d orig_src = p->src;
|
|
|
|
const struct buf_2d orig_dst = pd->dst;
|
|
|
|
struct buf_2d orig_pre[2];
|
2015-04-24 05:42:19 +02:00
|
|
|
memcpy(orig_pre, xd->plane[0].pre, sizeof(orig_pre));
|
2014-12-22 22:38:34 +01:00
|
|
|
|
|
|
|
// set buffer pointers for sub8x8 motion search.
|
|
|
|
p->src.buf =
|
|
|
|
&p->src.buf[vp9_raster_block_offset(BLOCK_8X8, i, p->src.stride)];
|
|
|
|
pd->dst.buf =
|
|
|
|
&pd->dst.buf[vp9_raster_block_offset(BLOCK_8X8, i, pd->dst.stride)];
|
|
|
|
pd->pre[0].buf =
|
|
|
|
&pd->pre[0].buf[vp9_raster_block_offset(BLOCK_8X8,
|
|
|
|
i, pd->pre[0].stride)];
|
|
|
|
|
2014-12-30 22:13:42 +01:00
|
|
|
b_mv[ZEROMV].as_int = 0;
|
|
|
|
b_mv[NEWMV].as_int = INVALID_MV;
|
2015-06-16 15:38:34 +02:00
|
|
|
vp9_append_sub8x8_mvs_for_idx(cm, xd, i, 0, mi_row, mi_col,
|
2014-12-30 22:13:42 +01:00
|
|
|
&b_mv[NEARESTMV],
|
2015-06-02 14:18:21 +02:00
|
|
|
&b_mv[NEARMV],
|
2015-06-29 18:27:11 +02:00
|
|
|
mbmi_ext->mode_context);
|
2014-12-22 22:38:34 +01:00
|
|
|
|
|
|
|
for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) {
|
2015-02-11 00:32:38 +01:00
|
|
|
int b_rate = 0;
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[i].as_mv[0].as_int = b_mv[this_mode].as_int;
|
2014-12-22 22:38:34 +01:00
|
|
|
|
|
|
|
if (this_mode == NEWMV) {
|
|
|
|
const int step_param = cpi->sf.mv.fullpel_search_step_param;
|
|
|
|
MV mvp_full;
|
|
|
|
MV tmp_mv;
|
|
|
|
int cost_list[5];
|
|
|
|
const int tmp_col_min = x->mv_col_min;
|
|
|
|
const int tmp_col_max = x->mv_col_max;
|
|
|
|
const int tmp_row_min = x->mv_row_min;
|
|
|
|
const int tmp_row_max = x->mv_row_max;
|
|
|
|
int dummy_dist;
|
|
|
|
|
|
|
|
if (i == 0) {
|
2014-12-30 22:13:42 +01:00
|
|
|
mvp_full.row = b_mv[NEARESTMV].as_mv.row >> 3;
|
|
|
|
mvp_full.col = b_mv[NEARESTMV].as_mv.col >> 3;
|
2014-12-22 22:38:34 +01:00
|
|
|
} else {
|
2015-04-21 14:36:58 +02:00
|
|
|
mvp_full.row = xd->mi[0]->bmi[0].as_mv[0].as_mv.row >> 3;
|
|
|
|
mvp_full.col = xd->mi[0]->bmi[0].as_mv[0].as_mv.col >> 3;
|
2014-12-22 22:38:34 +01:00
|
|
|
}
|
|
|
|
|
2015-06-29 18:27:11 +02:00
|
|
|
vp9_set_mv_search_range(x, &mbmi_ext->ref_mvs[0]->as_mv);
|
2014-12-22 22:38:34 +01:00
|
|
|
|
|
|
|
vp9_full_pixel_search(
|
|
|
|
cpi, x, bsize, &mvp_full, step_param, x->sadperbit4,
|
|
|
|
cond_cost_list(cpi, cost_list),
|
2015-06-29 18:27:11 +02:00
|
|
|
&mbmi_ext->ref_mvs[ref_frame][0].as_mv, &tmp_mv,
|
2014-12-22 22:38:34 +01:00
|
|
|
INT_MAX, 0);
|
|
|
|
|
|
|
|
x->mv_col_min = tmp_col_min;
|
|
|
|
x->mv_col_max = tmp_col_max;
|
|
|
|
x->mv_row_min = tmp_row_min;
|
|
|
|
x->mv_row_max = tmp_row_max;
|
|
|
|
|
|
|
|
// calculate the bit cost on motion vector
|
|
|
|
mvp_full.row = tmp_mv.row * 8;
|
|
|
|
mvp_full.col = tmp_mv.col * 8;
|
|
|
|
|
|
|
|
b_rate += vp9_mv_bit_cost(&mvp_full,
|
2015-06-29 18:27:11 +02:00
|
|
|
&mbmi_ext->ref_mvs[ref_frame][0].as_mv,
|
2014-12-22 22:38:34 +01:00
|
|
|
x->nmvjointcost, x->mvcost,
|
|
|
|
MV_COST_WEIGHT);
|
|
|
|
|
2015-06-29 18:27:11 +02:00
|
|
|
b_rate += cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]]
|
2014-12-22 22:38:34 +01:00
|
|
|
[INTER_OFFSET(NEWMV)];
|
|
|
|
if (RDCOST(x->rdmult, x->rddiv, b_rate, 0) > b_best_rd)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cpi->find_fractional_mv_step(x, &tmp_mv,
|
2015-06-29 18:27:11 +02:00
|
|
|
&mbmi_ext->ref_mvs[ref_frame][0].as_mv,
|
2014-12-22 22:38:34 +01:00
|
|
|
cpi->common.allow_high_precision_mv,
|
|
|
|
x->errorperbit,
|
|
|
|
&cpi->fn_ptr[bsize],
|
|
|
|
cpi->sf.mv.subpel_force_stop,
|
|
|
|
cpi->sf.mv.subpel_iters_per_step,
|
|
|
|
cond_cost_list(cpi, cost_list),
|
|
|
|
x->nmvjointcost, x->mvcost,
|
|
|
|
&dummy_dist,
|
|
|
|
&x->pred_sse[ref_frame], NULL, 0, 0);
|
|
|
|
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[i].as_mv[0].as_mv = tmp_mv;
|
2015-02-11 00:32:38 +01:00
|
|
|
} else {
|
2015-06-29 18:27:11 +02:00
|
|
|
b_rate += cpi->inter_mode_cost[x->mbmi_ext->mode_context[ref_frame]]
|
2015-02-11 00:32:38 +01:00
|
|
|
[INTER_OFFSET(this_mode)];
|
2014-12-22 22:38:34 +01:00
|
|
|
}
|
|
|
|
|
2015-02-19 00:48:40 +01:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
|
|
|
|
vp9_highbd_build_inter_predictor(pd->pre[0].buf, pd->pre[0].stride,
|
2014-12-22 22:38:34 +01:00
|
|
|
pd->dst.buf, pd->dst.stride,
|
2015-04-21 14:36:58 +02:00
|
|
|
&xd->mi[0]->bmi[i].as_mv[0].as_mv,
|
2014-12-22 22:38:34 +01:00
|
|
|
&xd->block_refs[0]->sf,
|
|
|
|
4 * num_4x4_blocks_wide,
|
|
|
|
4 * num_4x4_blocks_high, 0,
|
2016-01-20 01:40:20 +01:00
|
|
|
vp9_filter_kernels[mi->interp_filter],
|
2014-12-22 22:38:34 +01:00
|
|
|
MV_PRECISION_Q3,
|
|
|
|
mi_col * MI_SIZE + 4 * (i & 0x01),
|
2015-02-19 00:48:40 +01:00
|
|
|
mi_row * MI_SIZE + 4 * (i >> 1), xd->bd);
|
|
|
|
} else {
|
|
|
|
#endif
|
|
|
|
vp9_build_inter_predictor(pd->pre[0].buf, pd->pre[0].stride,
|
|
|
|
pd->dst.buf, pd->dst.stride,
|
2015-04-21 14:36:58 +02:00
|
|
|
&xd->mi[0]->bmi[i].as_mv[0].as_mv,
|
2015-02-19 00:48:40 +01:00
|
|
|
&xd->block_refs[0]->sf,
|
|
|
|
4 * num_4x4_blocks_wide,
|
|
|
|
4 * num_4x4_blocks_high, 0,
|
2016-01-20 01:40:20 +01:00
|
|
|
vp9_filter_kernels[mi->interp_filter],
|
2015-02-19 00:48:40 +01:00
|
|
|
MV_PRECISION_Q3,
|
|
|
|
mi_col * MI_SIZE + 4 * (i & 0x01),
|
|
|
|
mi_row * MI_SIZE + 4 * (i >> 1));
|
|
|
|
|
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-12-22 22:38:34 +01:00
|
|
|
model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist,
|
|
|
|
&var_y, &sse_y);
|
|
|
|
|
|
|
|
this_rdc.rate += b_rate;
|
|
|
|
this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv,
|
|
|
|
this_rdc.rate, this_rdc.dist);
|
|
|
|
if (this_rdc.rdcost < b_best_rd) {
|
|
|
|
b_best_rd = this_rdc.rdcost;
|
|
|
|
bsi[ref_frame][i].as_mode = this_mode;
|
2015-04-21 14:36:58 +02:00
|
|
|
bsi[ref_frame][i].as_mv[0].as_mv = xd->mi[0]->bmi[i].as_mv[0].as_mv;
|
2014-12-22 22:38:34 +01:00
|
|
|
}
|
|
|
|
} // mode search
|
|
|
|
|
|
|
|
// restore source and prediction buffer pointers.
|
|
|
|
p->src = orig_src;
|
|
|
|
pd->pre[0] = orig_pre[0];
|
|
|
|
pd->dst = orig_dst;
|
|
|
|
this_rd += b_best_rd;
|
|
|
|
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[i] = bsi[ref_frame][i];
|
2014-12-22 22:38:34 +01:00
|
|
|
if (num_4x4_blocks_wide > 1)
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[i + 1] = xd->mi[0]->bmi[i];
|
2014-12-22 22:38:34 +01:00
|
|
|
if (num_4x4_blocks_high > 1)
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[i + 2] = xd->mi[0]->bmi[i];
|
2014-12-22 22:38:34 +01:00
|
|
|
}
|
|
|
|
} // loop through sub8x8 blocks
|
|
|
|
|
|
|
|
if (this_rd < best_rd) {
|
2015-01-07 20:57:36 +01:00
|
|
|
best_rd = this_rd;
|
2014-12-22 22:38:34 +01:00
|
|
|
best_ref_frame = ref_frame;
|
|
|
|
}
|
|
|
|
} // reference frames
|
|
|
|
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->tx_size = TX_4X4;
|
|
|
|
mi->ref_frame[0] = best_ref_frame;
|
2014-12-22 22:38:34 +01:00
|
|
|
for (idy = 0; idy < 2; idy += num_4x4_blocks_high) {
|
|
|
|
for (idx = 0; idx < 2; idx += num_4x4_blocks_wide) {
|
|
|
|
const int block = idy * 2 + idx;
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[block] = bsi[best_ref_frame][block];
|
2014-12-22 22:38:34 +01:00
|
|
|
if (num_4x4_blocks_wide > 1)
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[block + 1] = bsi[best_ref_frame][block];
|
2014-12-22 22:38:34 +01:00
|
|
|
if (num_4x4_blocks_high > 1)
|
2015-04-21 14:36:58 +02:00
|
|
|
xd->mi[0]->bmi[block + 2] = bsi[best_ref_frame][block];
|
2014-12-22 22:38:34 +01:00
|
|
|
}
|
|
|
|
}
|
2016-01-20 01:40:20 +01:00
|
|
|
mi->mode = xd->mi[0]->bmi[3].as_mode;
|
2015-04-21 14:36:58 +02:00
|
|
|
ctx->mic = *(xd->mi[0]);
|
2015-06-29 18:27:11 +02:00
|
|
|
ctx->mbmi_ext = *x->mbmi_ext;
|
2015-07-30 20:52:28 +02:00
|
|
|
ctx->skip_txfm[0] = SKIP_TXFM_NONE;
|
2014-12-22 22:38:34 +01:00
|
|
|
ctx->skip = 0;
|
|
|
|
// Dummy assignment for speed -5. No effect in speed -6.
|
|
|
|
rd_cost->rdcost = best_rd;
|
|
|
|
}
|