2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
2013-08-23 00:50:51 +02:00
|
|
|
#include <limits.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
#include "./vp9_rtcd.h"
|
2013-08-23 00:50:51 +02:00
|
|
|
#include "./vpx_config.h"
|
|
|
|
|
|
|
|
#include "vpx_ports/vpx_timer.h"
|
|
|
|
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_common.h"
|
2012-11-29 00:15:51 +01:00
|
|
|
#include "vp9/common/vp9_entropy.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_entropymode.h"
|
2013-10-08 20:27:56 +02:00
|
|
|
#include "vp9/common/vp9_idct.h"
|
2013-08-23 00:50:51 +02:00
|
|
|
#include "vp9/common/vp9_mvref_common.h"
|
|
|
|
#include "vp9/common/vp9_pred_common.h"
|
|
|
|
#include "vp9/common/vp9_quant_common.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_reconintra.h"
|
2013-08-23 00:50:51 +02:00
|
|
|
#include "vp9/common/vp9_reconinter.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_seg_common.h"
|
2014-01-10 22:48:44 +01:00
|
|
|
#include "vp9/common/vp9_systemdependent.h"
|
2013-02-07 00:30:21 +01:00
|
|
|
#include "vp9/common/vp9_tile_common.h"
|
2014-03-07 19:56:20 +01:00
|
|
|
|
2014-03-27 00:05:45 +01:00
|
|
|
#include "vp9/encoder/vp9_aq_complexity.h"
|
2014-03-21 22:31:53 +01:00
|
|
|
#include "vp9/encoder/vp9_aq_cyclicrefresh.h"
|
|
|
|
#include "vp9/encoder/vp9_aq_variance.h"
|
2013-08-23 00:50:51 +02:00
|
|
|
#include "vp9/encoder/vp9_encodeframe.h"
|
|
|
|
#include "vp9/encoder/vp9_encodemb.h"
|
|
|
|
#include "vp9/encoder/vp9_encodemv.h"
|
2013-11-18 21:36:55 +01:00
|
|
|
#include "vp9/encoder/vp9_extend.h"
|
2014-01-10 20:51:20 +01:00
|
|
|
#include "vp9/encoder/vp9_pickmode.h"
|
2013-08-23 00:50:51 +02:00
|
|
|
#include "vp9/encoder/vp9_rdopt.h"
|
|
|
|
#include "vp9/encoder/vp9_segmentation.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/encoder/vp9_tokenize.h"
|
2013-10-07 20:20:10 +02:00
|
|
|
|
2014-03-17 20:54:51 +01:00
|
|
|
#define GF_ZEROMV_ZBIN_BOOST 0
|
|
|
|
#define LF_ZEROMV_ZBIN_BOOST 0
|
|
|
|
#define MV_ZBIN_BOOST 0
|
|
|
|
#define SPLIT_MV_ZBIN_BOOST 0
|
|
|
|
#define INTRA_ZBIN_BOOST 0
|
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
static INLINE uint8_t *get_sb_index(MACROBLOCK *x, BLOCK_SIZE subsize) {
|
2013-10-16 21:35:07 +02:00
|
|
|
switch (subsize) {
|
|
|
|
case BLOCK_64X64:
|
|
|
|
case BLOCK_64X32:
|
|
|
|
case BLOCK_32X64:
|
|
|
|
case BLOCK_32X32:
|
2013-11-12 00:58:57 +01:00
|
|
|
return &x->sb_index;
|
2013-10-16 21:35:07 +02:00
|
|
|
case BLOCK_32X16:
|
|
|
|
case BLOCK_16X32:
|
|
|
|
case BLOCK_16X16:
|
2013-11-12 00:58:57 +01:00
|
|
|
return &x->mb_index;
|
2013-10-16 21:35:07 +02:00
|
|
|
case BLOCK_16X8:
|
|
|
|
case BLOCK_8X16:
|
|
|
|
case BLOCK_8X8:
|
2013-11-12 00:58:57 +01:00
|
|
|
return &x->b_index;
|
2013-10-16 21:35:07 +02:00
|
|
|
case BLOCK_8X4:
|
|
|
|
case BLOCK_4X8:
|
|
|
|
case BLOCK_4X4:
|
2013-11-12 00:58:57 +01:00
|
|
|
return &x->ab_index;
|
2013-10-16 21:35:07 +02:00
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-19 23:26:49 +02:00
|
|
|
static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
|
2013-08-27 20:05:08 +02:00
|
|
|
int mi_row, int mi_col, BLOCK_SIZE bsize);
|
2012-10-30 22:25:33 +01:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x);
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2014-01-10 22:48:44 +01:00
|
|
|
// activity_avg must be positive, or flat regions could get a zero weight
|
|
|
|
// (infinite lambda), which confounds analysis.
|
|
|
|
// This also avoids the need for divide by zero checks in
|
|
|
|
// vp9_activity_masking().
|
2014-03-07 19:56:20 +01:00
|
|
|
#define ACTIVITY_AVG_MIN 64
|
2010-10-11 23:37:27 +02:00
|
|
|
|
2014-01-10 22:48:44 +01:00
|
|
|
// Motion vector component magnitude threshold for defining fast motion.
|
2014-03-07 19:56:20 +01:00
|
|
|
#define FAST_MOTION_MV_THRESH 24
|
2013-08-03 02:19:29 +02:00
|
|
|
|
2014-01-10 22:48:44 +01:00
|
|
|
// This is used as a reference when computing the source variance for the
|
|
|
|
// purposes of activity masking.
|
|
|
|
// Eventually this should be replaced by custom no-reference routines,
|
|
|
|
// which will be faster.
|
2013-08-01 21:56:12 +02:00
|
|
|
static const uint8_t VP9_VAR_OFFS[64] = {
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128,
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128,
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128,
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128,
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128,
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128,
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128,
|
|
|
|
128, 128, 128, 128, 128, 128, 128, 128
|
|
|
|
};
|
|
|
|
|
2014-02-26 02:22:34 +01:00
|
|
|
static unsigned int get_sby_perpixel_variance(VP9_COMP *cpi,
|
|
|
|
MACROBLOCK *x,
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE bs) {
|
2013-08-01 21:56:12 +02:00
|
|
|
unsigned int var, sse;
|
2014-01-07 02:38:57 +01:00
|
|
|
var = cpi->fn_ptr[bs].vf(x->plane[0].src.buf, x->plane[0].src.stride,
|
2013-08-01 21:56:12 +02:00
|
|
|
VP9_VAR_OFFS, 0, &sse);
|
2014-01-07 02:38:57 +01:00
|
|
|
return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]);
|
Speed feature to skip split partition based on var
Adds a speed feature to disable split partition search based on a
given threshold on the source variance. A tighter threshold derived
from the threshold provided is used to also disable horizontal and
vertical partitions.
Results on derfraw300:
threshold = 16, psnr = -0.057%, speedup ~1% (football)
threshold = 32, psnr = -0.150%, speedup ~4-5% (football)
threshold = 64, psnr = -0.570%, speedup ~10-12% (football)
Results on stdhdraw250:
threshold = 32, psnr = -0.18%, speedup is somewhat more than derf
because of a larger number of smoother blocks at higher resolution.
Based on these results, a threshold of 32 is chosen for speed 1,
and a threshold of 64 is chosen for speeds 2 and above.
Change-Id: If08912fb6c67fd4242d12a0d094783a99f52f6c6
2013-08-03 02:15:38 +02:00
|
|
|
}
|
|
|
|
|
2014-02-26 02:22:34 +01:00
|
|
|
static unsigned int get_sby_perpixel_diff_variance(VP9_COMP *cpi,
|
|
|
|
MACROBLOCK *x,
|
|
|
|
int mi_row,
|
|
|
|
int mi_col,
|
|
|
|
BLOCK_SIZE bs) {
|
|
|
|
const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, LAST_FRAME);
|
|
|
|
int offset = (mi_row * MI_SIZE) * yv12->y_stride + (mi_col * MI_SIZE);
|
|
|
|
unsigned int var, sse;
|
|
|
|
var = cpi->fn_ptr[bs].vf(x->plane[0].src.buf,
|
|
|
|
x->plane[0].src.stride,
|
|
|
|
yv12->y_buffer + offset,
|
|
|
|
yv12->y_stride,
|
|
|
|
&sse);
|
|
|
|
return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static BLOCK_SIZE get_rd_var_based_fixed_partition(VP9_COMP *cpi,
|
|
|
|
int mi_row,
|
|
|
|
int mi_col) {
|
|
|
|
unsigned int var = get_sby_perpixel_diff_variance(cpi, &cpi->mb,
|
|
|
|
mi_row, mi_col,
|
|
|
|
BLOCK_64X64);
|
|
|
|
if (var < 8)
|
2014-02-25 00:21:13 +01:00
|
|
|
return BLOCK_64X64;
|
2014-02-26 02:22:34 +01:00
|
|
|
else if (var < 128)
|
2014-02-25 00:21:13 +01:00
|
|
|
return BLOCK_32X32;
|
2014-02-26 02:22:34 +01:00
|
|
|
else if (var < 2048)
|
|
|
|
return BLOCK_16X16;
|
|
|
|
else
|
|
|
|
return BLOCK_8X8;
|
2014-02-25 00:21:13 +01:00
|
|
|
}
|
|
|
|
|
2014-02-26 02:22:34 +01:00
|
|
|
static BLOCK_SIZE get_nonrd_var_based_fixed_partition(VP9_COMP *cpi,
|
|
|
|
int mi_row,
|
|
|
|
int mi_col) {
|
|
|
|
unsigned int var = get_sby_perpixel_diff_variance(cpi, &cpi->mb,
|
|
|
|
mi_row, mi_col,
|
|
|
|
BLOCK_64X64);
|
2014-02-27 21:09:12 +01:00
|
|
|
if (var < 4)
|
2014-02-26 02:22:34 +01:00
|
|
|
return BLOCK_64X64;
|
2014-02-27 21:09:12 +01:00
|
|
|
else if (var < 10)
|
2014-02-25 00:21:13 +01:00
|
|
|
return BLOCK_32X32;
|
|
|
|
else
|
2014-02-27 21:09:12 +01:00
|
|
|
return BLOCK_16X16;
|
2014-02-25 00:21:13 +01:00
|
|
|
}
|
|
|
|
|
2014-03-04 20:15:35 +01:00
|
|
|
// Lighter version of set_offsets that only sets the mode info
|
|
|
|
// pointers.
|
2014-03-14 12:36:06 +01:00
|
|
|
static INLINE void set_modeinfo_offsets(VP9_COMMON *const cm,
|
2014-03-04 20:15:35 +01:00
|
|
|
MACROBLOCKD *const xd,
|
|
|
|
int mi_row,
|
|
|
|
int mi_col) {
|
2014-04-02 01:18:47 +02:00
|
|
|
const int idx_str = xd->mi_stride * mi_row + mi_col;
|
|
|
|
xd->mi = cm->mi_grid_visible + idx_str;
|
|
|
|
xd->mi[0] = cm->mi + idx_str;
|
2014-03-04 20:15:35 +01:00
|
|
|
}
|
|
|
|
|
2014-04-01 01:54:33 +02:00
|
|
|
static int is_block_in_mb_map(const VP9_COMP *cpi, int mi_row, int mi_col,
|
2014-03-04 20:15:35 +01:00
|
|
|
BLOCK_SIZE bsize) {
|
2014-04-01 01:54:33 +02:00
|
|
|
const VP9_COMMON *const cm = &cpi->common;
|
2014-03-04 20:15:35 +01:00
|
|
|
const int mb_rows = cm->mb_rows;
|
|
|
|
const int mb_cols = cm->mb_cols;
|
|
|
|
const int mb_row = mi_row >> 1;
|
|
|
|
const int mb_col = mi_col >> 1;
|
|
|
|
const int mb_width = num_8x8_blocks_wide_lookup[bsize] >> 1;
|
|
|
|
const int mb_height = num_8x8_blocks_high_lookup[bsize] >> 1;
|
|
|
|
int r, c;
|
|
|
|
if (bsize <= BLOCK_16X16) {
|
|
|
|
return cpi->active_map[mb_row * mb_cols + mb_col];
|
|
|
|
}
|
|
|
|
for (r = 0; r < mb_height; ++r) {
|
|
|
|
for (c = 0; c < mb_width; ++c) {
|
|
|
|
int row = mb_row + r;
|
|
|
|
int col = mb_col + c;
|
|
|
|
if (row >= mb_rows || col >= mb_cols)
|
|
|
|
continue;
|
|
|
|
if (cpi->active_map[row * mb_cols + col])
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-01 01:54:33 +02:00
|
|
|
static int check_active_map(const VP9_COMP *cpi, const MACROBLOCK *x,
|
|
|
|
int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE bsize) {
|
|
|
|
if (cpi->active_map_enabled && !x->e_mbd.lossless) {
|
|
|
|
return is_block_in_mb_map(cpi, mi_row, mi_col, bsize);
|
|
|
|
} else {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-04 20:15:35 +01:00
|
|
|
static void set_offsets(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
int mi_row, int mi_col, BLOCK_SIZE bsize) {
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
MB_MODE_INFO *mbmi;
|
|
|
|
const int mi_width = num_8x8_blocks_wide_lookup[bsize];
|
|
|
|
const int mi_height = num_8x8_blocks_high_lookup[bsize];
|
|
|
|
const int mb_row = mi_row >> 1;
|
|
|
|
const int mb_col = mi_col >> 1;
|
|
|
|
const int idx_map = mb_row * cm->mb_cols + mb_col;
|
|
|
|
const struct segmentation *const seg = &cm->seg;
|
|
|
|
|
2014-04-01 19:57:59 +02:00
|
|
|
set_skip_context(xd, mi_row, mi_col);
|
2014-03-04 20:15:35 +01:00
|
|
|
|
|
|
|
// Activity map pointer
|
|
|
|
x->mb_activity_ptr = &cpi->mb_activity_map[idx_map];
|
2014-04-01 01:54:33 +02:00
|
|
|
x->in_active_map = check_active_map(cpi, x, mi_row, mi_col, bsize);
|
2014-03-04 20:15:35 +01:00
|
|
|
|
|
|
|
set_modeinfo_offsets(cm, xd, mi_row, mi_col);
|
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
mbmi = &xd->mi[0]->mbmi;
|
2014-03-04 20:15:35 +01:00
|
|
|
|
|
|
|
// Set up destination pointers.
|
|
|
|
vp9_setup_dst_planes(xd, get_frame_new_buffer(cm), mi_row, mi_col);
|
|
|
|
|
|
|
|
// Set up limit values for MV components.
|
|
|
|
// Mv beyond the range do not produce new/different prediction block.
|
|
|
|
x->mv_row_min = -(((mi_row + mi_height) * MI_SIZE) + VP9_INTERP_EXTEND);
|
|
|
|
x->mv_col_min = -(((mi_col + mi_width) * MI_SIZE) + VP9_INTERP_EXTEND);
|
|
|
|
x->mv_row_max = (cm->mi_rows - mi_row) * MI_SIZE + VP9_INTERP_EXTEND;
|
|
|
|
x->mv_col_max = (cm->mi_cols - mi_col) * MI_SIZE + VP9_INTERP_EXTEND;
|
|
|
|
|
|
|
|
// Set up distance of MB to edge of frame in 1/8th pel units.
|
|
|
|
assert(!(mi_col & (mi_width - 1)) && !(mi_row & (mi_height - 1)));
|
|
|
|
set_mi_row_col(xd, tile, mi_row, mi_height, mi_col, mi_width,
|
|
|
|
cm->mi_rows, cm->mi_cols);
|
|
|
|
|
|
|
|
// Set up source buffers.
|
|
|
|
vp9_setup_src_planes(x, cpi->Source, mi_row, mi_col);
|
|
|
|
|
|
|
|
// R/D setup.
|
|
|
|
x->rddiv = cpi->RDDIV;
|
|
|
|
x->rdmult = cpi->RDMULT;
|
|
|
|
|
|
|
|
// Setup segment ID.
|
|
|
|
if (seg->enabled) {
|
|
|
|
if (cpi->oxcf.aq_mode != VARIANCE_AQ) {
|
|
|
|
const uint8_t *const map = seg->update_map ? cpi->segmentation_map
|
|
|
|
: cm->last_frame_seg_map;
|
|
|
|
mbmi->segment_id = vp9_get_segment_id(cm, map, bsize, mi_row, mi_col);
|
|
|
|
}
|
|
|
|
vp9_init_plane_quantizers(cpi, x);
|
|
|
|
|
|
|
|
if (seg->enabled && cpi->seg0_cnt > 0 &&
|
|
|
|
!vp9_segfeature_active(seg, 0, SEG_LVL_REF_FRAME) &&
|
|
|
|
vp9_segfeature_active(seg, 1, SEG_LVL_REF_FRAME)) {
|
|
|
|
cpi->seg0_progress = (cpi->seg0_idx << 16) / cpi->seg0_cnt;
|
|
|
|
} else {
|
|
|
|
const int y = mb_row & ~3;
|
|
|
|
const int x = mb_col & ~3;
|
|
|
|
const int p16 = ((mb_row & 1) << 1) + (mb_col & 1);
|
|
|
|
const int p32 = ((mb_row & 2) << 2) + ((mb_col & 2) << 1);
|
|
|
|
const int tile_progress = tile->mi_col_start * cm->mb_rows >> 1;
|
|
|
|
const int mb_cols = (tile->mi_col_end - tile->mi_col_start) >> 1;
|
|
|
|
|
|
|
|
cpi->seg0_progress = ((y * mb_cols + x * 4 + p32 + p16 + tile_progress)
|
|
|
|
<< 16) / cm->MBs;
|
|
|
|
}
|
|
|
|
|
|
|
|
x->encode_breakout = cpi->segment_encode_breakout[mbmi->segment_id];
|
|
|
|
} else {
|
|
|
|
mbmi->segment_id = 0;
|
|
|
|
x->encode_breakout = cpi->encode_breakout;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-21 19:05:39 +01:00
|
|
|
static void duplicate_mode_info_in_sb(VP9_COMMON * const cm,
|
2014-03-04 20:15:35 +01:00
|
|
|
MACROBLOCKD *const xd,
|
|
|
|
int mi_row,
|
|
|
|
int mi_col,
|
|
|
|
BLOCK_SIZE bsize) {
|
|
|
|
const int block_width = num_8x8_blocks_wide_lookup[bsize];
|
|
|
|
const int block_height = num_8x8_blocks_high_lookup[bsize];
|
|
|
|
int i, j;
|
|
|
|
for (j = 0; j < block_height; ++j)
|
|
|
|
for (i = 0; i < block_width; ++i) {
|
|
|
|
if (mi_row + j < cm->mi_rows && mi_col + i < cm->mi_cols)
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[j * xd->mi_stride + i] = xd->mi[0];
|
2014-03-04 20:15:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_block_size(VP9_COMP * const cpi,
|
|
|
|
const TileInfo *const tile,
|
|
|
|
int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE bsize) {
|
|
|
|
if (cpi->common.mi_cols > mi_col && cpi->common.mi_rows > mi_row) {
|
|
|
|
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
|
|
|
|
set_modeinfo_offsets(&cpi->common, xd, mi_row, mi_col);
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[0]->mbmi.sb_type = bsize;
|
2014-03-21 19:05:39 +01:00
|
|
|
duplicate_mode_info_in_sb(&cpi->common, xd, mi_row, mi_col, bsize);
|
2014-03-04 20:15:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int64_t sum_square_error;
|
|
|
|
int64_t sum_error;
|
|
|
|
int count;
|
|
|
|
int variance;
|
|
|
|
} var;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
var none;
|
|
|
|
var horz[2];
|
|
|
|
var vert[2];
|
|
|
|
} partition_variance;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
partition_variance part_variances;
|
|
|
|
var split[4];
|
|
|
|
} v8x8;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
partition_variance part_variances;
|
|
|
|
v8x8 split[4];
|
|
|
|
} v16x16;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
partition_variance part_variances;
|
|
|
|
v16x16 split[4];
|
|
|
|
} v32x32;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
partition_variance part_variances;
|
|
|
|
v32x32 split[4];
|
|
|
|
} v64x64;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
partition_variance *part_variances;
|
|
|
|
var *split[4];
|
|
|
|
} variance_node;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
V16X16,
|
|
|
|
V32X32,
|
|
|
|
V64X64,
|
|
|
|
} TREE_LEVEL;
|
|
|
|
|
|
|
|
static void tree_to_node(void *data, BLOCK_SIZE bsize, variance_node *node) {
|
|
|
|
int i;
|
|
|
|
switch (bsize) {
|
|
|
|
case BLOCK_64X64: {
|
|
|
|
v64x64 *vt = (v64x64 *) data;
|
|
|
|
node->part_variances = &vt->part_variances;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
node->split[i] = &vt->split[i].part_variances.none;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BLOCK_32X32: {
|
|
|
|
v32x32 *vt = (v32x32 *) data;
|
|
|
|
node->part_variances = &vt->part_variances;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
node->split[i] = &vt->split[i].part_variances.none;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BLOCK_16X16: {
|
|
|
|
v16x16 *vt = (v16x16 *) data;
|
|
|
|
node->part_variances = &vt->part_variances;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
node->split[i] = &vt->split[i].part_variances.none;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BLOCK_8X8: {
|
|
|
|
v8x8 *vt = (v8x8 *) data;
|
|
|
|
node->part_variances = &vt->part_variances;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
node->split[i] = &vt->split[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: {
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set variance values given sum square error, sum error, count.
|
|
|
|
static void fill_variance(int64_t s2, int64_t s, int c, var *v) {
|
|
|
|
v->sum_square_error = s2;
|
|
|
|
v->sum_error = s;
|
|
|
|
v->count = c;
|
|
|
|
if (c > 0)
|
|
|
|
v->variance = (int)(256 *
|
|
|
|
(v->sum_square_error - v->sum_error * v->sum_error /
|
|
|
|
v->count) / v->count);
|
|
|
|
else
|
|
|
|
v->variance = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void sum_2_variances(const var *a, const var *b, var *r) {
|
|
|
|
fill_variance(a->sum_square_error + b->sum_square_error,
|
|
|
|
a->sum_error + b->sum_error, a->count + b->count, r);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fill_variance_tree(void *data, BLOCK_SIZE bsize) {
|
|
|
|
variance_node node;
|
|
|
|
tree_to_node(data, bsize, &node);
|
|
|
|
sum_2_variances(node.split[0], node.split[1], &node.part_variances->horz[0]);
|
|
|
|
sum_2_variances(node.split[2], node.split[3], &node.part_variances->horz[1]);
|
|
|
|
sum_2_variances(node.split[0], node.split[2], &node.part_variances->vert[0]);
|
|
|
|
sum_2_variances(node.split[1], node.split[3], &node.part_variances->vert[1]);
|
|
|
|
sum_2_variances(&node.part_variances->vert[0], &node.part_variances->vert[1],
|
|
|
|
&node.part_variances->none);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int set_vt_partitioning(VP9_COMP *cpi,
|
|
|
|
void *data,
|
|
|
|
const TileInfo *const tile,
|
|
|
|
BLOCK_SIZE bsize,
|
|
|
|
int mi_row,
|
|
|
|
int mi_col,
|
|
|
|
int mi_size) {
|
|
|
|
VP9_COMMON * const cm = &cpi->common;
|
|
|
|
variance_node vt;
|
|
|
|
const int block_width = num_8x8_blocks_wide_lookup[bsize];
|
|
|
|
const int block_height = num_8x8_blocks_high_lookup[bsize];
|
|
|
|
// TODO(debargha): Choose this more intelligently.
|
|
|
|
const int64_t threshold_multiplier = 25;
|
|
|
|
int64_t threshold = threshold_multiplier * cpi->common.base_qindex;
|
|
|
|
assert(block_height == block_width);
|
|
|
|
|
|
|
|
tree_to_node(data, bsize, &vt);
|
|
|
|
|
|
|
|
// Split none is available only if we have more than half a block size
|
|
|
|
// in width and height inside the visible image.
|
|
|
|
if (mi_col + block_width / 2 < cm->mi_cols &&
|
|
|
|
mi_row + block_height / 2 < cm->mi_rows &&
|
|
|
|
vt.part_variances->none.variance < threshold) {
|
|
|
|
set_block_size(cpi, tile, mi_row, mi_col, bsize);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Vertical split is available on all but the bottom border.
|
|
|
|
if (mi_row + block_height / 2 < cm->mi_rows &&
|
|
|
|
vt.part_variances->vert[0].variance < threshold &&
|
|
|
|
vt.part_variances->vert[1].variance < threshold) {
|
|
|
|
BLOCK_SIZE subsize = get_subsize(bsize, PARTITION_VERT);
|
|
|
|
set_block_size(cpi, tile, mi_row, mi_col, subsize);
|
|
|
|
set_block_size(cpi, tile, mi_row, mi_col + block_width / 2, subsize);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Horizontal split is available on all but the right border.
|
|
|
|
if (mi_col + block_width / 2 < cm->mi_cols &&
|
|
|
|
vt.part_variances->horz[0].variance < threshold &&
|
|
|
|
vt.part_variances->horz[1].variance < threshold) {
|
|
|
|
BLOCK_SIZE subsize = get_subsize(bsize, PARTITION_HORZ);
|
|
|
|
set_block_size(cpi, tile, mi_row, mi_col, subsize);
|
|
|
|
set_block_size(cpi, tile, mi_row + block_height / 2, mi_col, subsize);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(debargha): Fix this function and make it work as expected.
|
|
|
|
static void choose_partitioning(VP9_COMP *cpi,
|
|
|
|
const TileInfo *const tile,
|
|
|
|
int mi_row, int mi_col) {
|
|
|
|
VP9_COMMON * const cm = &cpi->common;
|
|
|
|
MACROBLOCK *x = &cpi->mb;
|
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
|
|
|
|
|
|
|
int i, j, k;
|
|
|
|
v64x64 vt;
|
|
|
|
uint8_t *s;
|
|
|
|
const uint8_t *d;
|
|
|
|
int sp;
|
|
|
|
int dp;
|
|
|
|
int pixels_wide = 64, pixels_high = 64;
|
|
|
|
int_mv nearest_mv, near_mv;
|
|
|
|
const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, LAST_FRAME);
|
|
|
|
const struct scale_factors *const sf = &cm->frame_refs[LAST_FRAME - 1].sf;
|
|
|
|
|
|
|
|
vp9_zero(vt);
|
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, BLOCK_64X64);
|
|
|
|
|
|
|
|
if (xd->mb_to_right_edge < 0)
|
|
|
|
pixels_wide += (xd->mb_to_right_edge >> 3);
|
|
|
|
if (xd->mb_to_bottom_edge < 0)
|
|
|
|
pixels_high += (xd->mb_to_bottom_edge >> 3);
|
|
|
|
|
|
|
|
s = x->plane[0].src.buf;
|
|
|
|
sp = x->plane[0].src.stride;
|
|
|
|
|
|
|
|
if (cm->frame_type != KEY_FRAME) {
|
|
|
|
vp9_setup_pre_planes(xd, 0, yv12, mi_row, mi_col, sf);
|
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[0]->mbmi.ref_frame[0] = LAST_FRAME;
|
|
|
|
xd->mi[0]->mbmi.sb_type = BLOCK_64X64;
|
2014-03-04 20:15:35 +01:00
|
|
|
vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv,
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[0]->mbmi.ref_mvs[LAST_FRAME],
|
2014-03-04 20:15:35 +01:00
|
|
|
&nearest_mv, &near_mv);
|
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[0]->mbmi.mv[0] = nearest_mv;
|
2014-03-04 20:15:35 +01:00
|
|
|
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, BLOCK_64X64);
|
|
|
|
|
|
|
|
d = xd->plane[0].dst.buf;
|
|
|
|
dp = xd->plane[0].dst.stride;
|
|
|
|
} else {
|
|
|
|
d = VP9_VAR_OFFS;
|
|
|
|
dp = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fill in the entire tree of 8x8 variances for splits.
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
const int x32_idx = ((i & 1) << 5);
|
|
|
|
const int y32_idx = ((i >> 1) << 5);
|
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
|
const int x16_idx = x32_idx + ((j & 1) << 4);
|
|
|
|
const int y16_idx = y32_idx + ((j >> 1) << 4);
|
|
|
|
v16x16 *vst = &vt.split[i].split[j];
|
|
|
|
for (k = 0; k < 4; k++) {
|
|
|
|
int x_idx = x16_idx + ((k & 1) << 3);
|
|
|
|
int y_idx = y16_idx + ((k >> 1) << 3);
|
|
|
|
unsigned int sse = 0;
|
|
|
|
int sum = 0;
|
|
|
|
if (x_idx < pixels_wide && y_idx < pixels_high)
|
|
|
|
vp9_get_sse_sum_8x8(s + y_idx * sp + x_idx, sp,
|
|
|
|
d + y_idx * dp + x_idx, dp, &sse, &sum);
|
|
|
|
fill_variance(sse, sum, 64, &vst->split[k].part_variances.none);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Fill the rest of the variance tree by summing split partition values.
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
for (j = 0; j < 4; j++) {
|
|
|
|
fill_variance_tree(&vt.split[i].split[j], BLOCK_16X16);
|
|
|
|
}
|
|
|
|
fill_variance_tree(&vt.split[i], BLOCK_32X32);
|
|
|
|
}
|
|
|
|
fill_variance_tree(&vt, BLOCK_64X64);
|
|
|
|
|
|
|
|
// Now go through the entire structure, splitting every block size until
|
|
|
|
// we get to one that's got a variance lower than our threshold, or we
|
|
|
|
// hit 8x8.
|
|
|
|
if (!set_vt_partitioning(cpi, &vt, tile, BLOCK_64X64,
|
|
|
|
mi_row, mi_col, 8)) {
|
|
|
|
for (i = 0; i < 4; ++i) {
|
|
|
|
const int x32_idx = ((i & 1) << 2);
|
|
|
|
const int y32_idx = ((i >> 1) << 2);
|
|
|
|
if (!set_vt_partitioning(cpi, &vt.split[i], tile, BLOCK_32X32,
|
|
|
|
(mi_row + y32_idx), (mi_col + x32_idx), 4)) {
|
|
|
|
for (j = 0; j < 4; ++j) {
|
|
|
|
const int x16_idx = ((j & 1) << 1);
|
|
|
|
const int y16_idx = ((j >> 1) << 1);
|
|
|
|
// NOTE: This is a temporary hack to disable 8x8 partitions,
|
|
|
|
// since it works really bad - possibly due to a bug
|
|
|
|
#define DISABLE_8X8_VAR_BASED_PARTITION
|
|
|
|
#ifdef DISABLE_8X8_VAR_BASED_PARTITION
|
|
|
|
if (mi_row + y32_idx + y16_idx + 1 < cm->mi_rows &&
|
|
|
|
mi_row + x32_idx + x16_idx + 1 < cm->mi_cols) {
|
|
|
|
set_block_size(cpi, tile,
|
|
|
|
(mi_row + y32_idx + y16_idx),
|
|
|
|
(mi_col + x32_idx + x16_idx),
|
|
|
|
BLOCK_16X16);
|
|
|
|
} else {
|
|
|
|
for (k = 0; k < 4; ++k) {
|
|
|
|
const int x8_idx = (k & 1);
|
|
|
|
const int y8_idx = (k >> 1);
|
|
|
|
set_block_size(cpi, tile,
|
|
|
|
(mi_row + y32_idx + y16_idx + y8_idx),
|
|
|
|
(mi_col + x32_idx + x16_idx + x8_idx),
|
|
|
|
BLOCK_8X8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (!set_vt_partitioning(cpi, &vt.split[i].split[j], tile,
|
|
|
|
BLOCK_16X16,
|
|
|
|
(mi_row + y32_idx + y16_idx),
|
|
|
|
(mi_col + x32_idx + x16_idx), 2)) {
|
|
|
|
for (k = 0; k < 4; ++k) {
|
|
|
|
const int x8_idx = (k & 1);
|
|
|
|
const int y8_idx = (k >> 1);
|
|
|
|
set_block_size(cpi, tile,
|
|
|
|
(mi_row + y32_idx + y16_idx + y8_idx),
|
|
|
|
(mi_col + x32_idx + x16_idx + x8_idx),
|
|
|
|
BLOCK_8X8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-12 18:01:55 +02:00
|
|
|
// Original activity measure from Tim T's code.
|
2013-08-01 01:59:15 +02:00
|
|
|
static unsigned int tt_activity_measure(MACROBLOCK *x) {
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int sse;
|
2014-03-07 19:56:20 +01:00
|
|
|
// TODO: This could also be done over smaller areas (8x8), but that would
|
|
|
|
// require extensive changes elsewhere, as lambda is assumed to be fixed
|
|
|
|
// over an entire MB in most of the code.
|
|
|
|
// Another option is to compute four 8x8 variances, and pick a single
|
|
|
|
// lambda using a non-linear combination (e.g., the smallest, or second
|
|
|
|
// smallest, etc.).
|
|
|
|
const unsigned int act = vp9_variance16x16(x->plane[0].src.buf,
|
|
|
|
x->plane[0].src.stride,
|
|
|
|
VP9_VAR_OFFS, 0, &sse) << 4;
|
2014-01-10 22:48:44 +01:00
|
|
|
// If the region is flat, lower the activity some more.
|
2014-03-07 19:56:20 +01:00
|
|
|
return act < (8 << 12) ? MIN(act, 5 << 12) : act;
|
2010-10-11 23:37:27 +02:00
|
|
|
}
|
|
|
|
|
2011-05-12 18:01:55 +02:00
|
|
|
// Stub for alternative experimental activity measures.
|
2013-08-16 21:51:20 +02:00
|
|
|
static unsigned int alt_activity_measure(MACROBLOCK *x, int use_dc_pred) {
|
|
|
|
return vp9_encode_intra(x, use_dc_pred);
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Measure the activity of the current macroblock
|
|
|
|
// What we measure here is TBD so abstracted to this function
|
2011-06-08 17:00:59 +02:00
|
|
|
#define ALT_ACT_MEASURE 1
|
2013-08-16 21:51:20 +02:00
|
|
|
static unsigned int mb_activity_measure(MACROBLOCK *x, int mb_row, int mb_col) {
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int mb_activity;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (ALT_ACT_MEASURE) {
|
2014-01-10 22:48:44 +01:00
|
|
|
const int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Or use and alternative.
|
2013-08-16 21:51:20 +02:00
|
|
|
mb_activity = alt_activity_measure(x, use_dc_pred);
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
// Original activity measure from Tim T's code.
|
2013-08-01 01:59:15 +02:00
|
|
|
mb_activity = tt_activity_measure(x);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2014-01-10 22:48:44 +01:00
|
|
|
return MAX(mb_activity, ACTIVITY_AVG_MIN);
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Calculate an "average" mb activity value for the frame
|
2011-06-08 17:00:59 +02:00
|
|
|
#define ACT_MEDIAN 0
|
2012-10-31 01:53:32 +01:00
|
|
|
static void calc_av_activity(VP9_COMP *cpi, int64_t activity_sum) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ACT_MEDIAN
|
2012-07-14 00:21:29 +02:00
|
|
|
// Find median: Simple n^2 algorithm for experimentation
|
|
|
|
{
|
|
|
|
unsigned int median;
|
|
|
|
unsigned int i, j;
|
|
|
|
unsigned int *sortlist;
|
|
|
|
unsigned int tmp;
|
|
|
|
|
|
|
|
// Create a list to sort to
|
2013-06-28 19:36:20 +02:00
|
|
|
CHECK_MEM_ERROR(&cpi->common, sortlist, vpx_calloc(sizeof(unsigned int),
|
|
|
|
cpi->common.MBs));
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Copy map to sort list
|
|
|
|
vpx_memcpy(sortlist, cpi->mb_activity_map,
|
2013-06-19 23:26:49 +02:00
|
|
|
sizeof(unsigned int) * cpi->common.MBs);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
// Ripple each value down to its correct position
|
|
|
|
for (i = 1; i < cpi->common.MBs; i ++) {
|
|
|
|
for (j = i; j > 0; j --) {
|
|
|
|
if (sortlist[j] < sortlist[j - 1]) {
|
|
|
|
// Swap values
|
|
|
|
tmp = sortlist[j - 1];
|
|
|
|
sortlist[j - 1] = sortlist[j];
|
|
|
|
sortlist[j] = tmp;
|
2013-10-04 23:37:31 +02:00
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
}
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Even number MBs so estimate median as mean of two either side.
|
|
|
|
median = (1 + sortlist[cpi->common.MBs >> 1] +
|
2013-06-19 23:26:49 +02:00
|
|
|
sortlist[(cpi->common.MBs >> 1) + 1]) >> 1;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cpi->activity_avg = median;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_free(sortlist);
|
|
|
|
}
|
2011-06-08 17:00:59 +02:00
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
// Simple mean for now
|
2013-06-19 23:26:49 +02:00
|
|
|
cpi->activity_avg = (unsigned int) (activity_sum / cpi->common.MBs);
|
2013-08-23 00:50:51 +02:00
|
|
|
#endif // ACT_MEDIAN
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2013-08-23 03:40:34 +02:00
|
|
|
if (cpi->activity_avg < ACTIVITY_AVG_MIN)
|
|
|
|
cpi->activity_avg = ACTIVITY_AVG_MIN;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Experimental code: return fixed value normalized for several clips
|
|
|
|
if (ALT_ACT_MEASURE)
|
|
|
|
cpi->activity_avg = 100000;
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
#define USE_ACT_INDEX 0
|
2011-05-12 18:01:55 +02:00
|
|
|
#define OUTPUT_NORM_ACT_STATS 0
|
2011-06-08 17:00:59 +02:00
|
|
|
|
|
|
|
#if USE_ACT_INDEX
|
2013-03-26 14:11:52 +01:00
|
|
|
// Calculate an activity index for each mb
|
2012-10-31 01:53:32 +01:00
|
|
|
static void calc_activity_index(VP9_COMP *cpi, MACROBLOCK *x) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2012-07-14 00:21:29 +02:00
|
|
|
int mb_row, mb_col;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int64_t act;
|
|
|
|
int64_t a;
|
|
|
|
int64_t b;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
FILE *f = fopen("norm_act.stt", "a");
|
|
|
|
fprintf(f, "\n%12d\n", cpi->activity_avg);
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Reset pointers to start of activity map
|
|
|
|
x->mb_activity_ptr = cpi->mb_activity_map;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate normalized mb activity number.
|
|
|
|
for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
|
|
|
|
// for each macroblock col in image
|
|
|
|
for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
|
|
|
|
// Read activity from the map
|
|
|
|
act = *(x->mb_activity_ptr);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate a normalized activity number
|
|
|
|
a = act + 4 * cpi->activity_avg;
|
|
|
|
b = 4 * act + cpi->activity_avg;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (b >= a)
|
2013-06-19 23:26:49 +02:00
|
|
|
*(x->activity_ptr) = (int)((b + (a >> 1)) / a) - 1;
|
2012-07-14 00:21:29 +02:00
|
|
|
else
|
2013-06-19 23:26:49 +02:00
|
|
|
*(x->activity_ptr) = 1 - (int)((a + (b >> 1)) / b);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, " %6d", *(x->mb_activity_ptr));
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// Increment activity map pointers
|
|
|
|
x->mb_activity_ptr++;
|
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
fprintf(f, "\n");
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
#if OUTPUT_NORM_ACT_STATS
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(f);
|
2011-05-12 18:01:55 +02:00
|
|
|
#endif
|
|
|
|
}
|
2013-08-23 00:50:51 +02:00
|
|
|
#endif // USE_ACT_INDEX
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
// Loop through all MBs. Note activity of each, average activity and
|
|
|
|
// calculate a normalized activity for each
|
2012-10-31 01:53:32 +01:00
|
|
|
static void build_activity_map(VP9_COMP *cpi) {
|
2014-01-08 23:51:00 +01:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2012-07-14 00:21:29 +02:00
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
2014-01-08 23:51:00 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ALT_ACT_MEASURE
|
2013-10-24 21:20:35 +02:00
|
|
|
YV12_BUFFER_CONFIG *new_yv12 = get_frame_new_buffer(cm);
|
2012-07-14 00:21:29 +02:00
|
|
|
int recon_yoffset;
|
|
|
|
int recon_y_stride = new_yv12->y_stride;
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int mb_row, mb_col;
|
|
|
|
unsigned int mb_activity;
|
|
|
|
int64_t activity_sum = 0;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2013-03-26 14:11:52 +01:00
|
|
|
x->mb_activity_ptr = cpi->mb_activity_map;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// for each macroblock row in image
|
|
|
|
for (mb_row = 0; mb_row < cm->mb_rows; mb_row++) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ALT_ACT_MEASURE
|
2012-07-14 00:21:29 +02:00
|
|
|
// reset above block coeffs
|
|
|
|
xd->up_available = (mb_row != 0);
|
|
|
|
recon_yoffset = (mb_row * recon_y_stride * 16);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
// for each macroblock col in image
|
|
|
|
for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if ALT_ACT_MEASURE
|
2013-04-20 00:52:17 +02:00
|
|
|
xd->plane[0].dst.buf = new_yv12->y_buffer + recon_yoffset;
|
2012-07-14 00:21:29 +02:00
|
|
|
xd->left_available = (mb_col != 0);
|
|
|
|
recon_yoffset += 16;
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2011-06-23 19:54:02 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// measure activity
|
2013-08-16 21:51:20 +02:00
|
|
|
mb_activity = mb_activity_measure(x, mb_row, mb_col);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Keep frame sum
|
|
|
|
activity_sum += mb_activity;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Store MB level activity details.
|
|
|
|
*x->mb_activity_ptr = mb_activity;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Increment activity map pointer
|
|
|
|
x->mb_activity_ptr++;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// adjust to the next column of source macroblocks
|
2013-04-24 01:22:47 +02:00
|
|
|
x->plane[0].src.buf += 16;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// adjust to the next row of mbs
|
2013-04-24 01:22:47 +02:00
|
|
|
x->plane[0].src.buf += 16 * x->plane[0].src.stride - 16 * cm->mb_cols;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate an "average" MB activity
|
|
|
|
calc_av_activity(cpi, activity_sum);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
#if USE_ACT_INDEX
|
2012-07-14 00:21:29 +02:00
|
|
|
// Calculate an activity index number of each mb
|
|
|
|
calc_activity_index(cpi, x);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
|
|
|
|
2011-06-08 17:00:59 +02:00
|
|
|
// Macroblock activity masking
|
2014-02-09 04:41:37 +01:00
|
|
|
static void activity_masking(VP9_COMP *cpi, MACROBLOCK *x) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if USE_ACT_INDEX
|
2012-07-14 00:21:29 +02:00
|
|
|
x->rdmult += *(x->mb_activity_ptr) * (x->rdmult >> 2);
|
|
|
|
x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
|
|
|
|
x->errorperbit += (x->errorperbit == 0);
|
2011-06-08 17:00:59 +02:00
|
|
|
#else
|
2014-01-10 22:48:44 +01:00
|
|
|
const int64_t act = *(x->mb_activity_ptr);
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Apply the masking to the RD multiplier.
|
2014-01-10 22:48:44 +01:00
|
|
|
const int64_t a = act + (2 * cpi->activity_avg);
|
|
|
|
const int64_t b = (2 * act) + cpi->activity_avg;
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2013-06-19 23:26:49 +02:00
|
|
|
x->rdmult = (unsigned int) (((int64_t) x->rdmult * b + (a >> 1)) / a);
|
2012-07-14 00:21:29 +02:00
|
|
|
x->errorperbit = x->rdmult * 100 / (110 * x->rddiv);
|
|
|
|
x->errorperbit += (x->errorperbit == 0);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2011-05-12 18:01:55 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Activity based Zbin adjustment
|
|
|
|
adjust_act_zbin(cpi, x);
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-06-19 23:26:49 +02:00
|
|
|
static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
|
2014-03-14 22:35:47 +01:00
|
|
|
int mi_row, int mi_col, BLOCK_SIZE bsize,
|
|
|
|
int output_enabled) {
|
2013-01-06 03:20:25 +01:00
|
|
|
int i, x_idx, y;
|
2013-08-06 20:04:31 +02:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-11-01 20:53:37 +01:00
|
|
|
struct macroblock_plane *const p = x->plane;
|
|
|
|
struct macroblockd_plane *const pd = xd->plane;
|
2012-07-14 00:21:29 +02:00
|
|
|
MODE_INFO *mi = &ctx->mic;
|
2014-04-02 01:18:47 +02:00
|
|
|
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
|
|
|
|
MODE_INFO *mi_addr = xd->mi[0];
|
2014-03-14 22:35:47 +01:00
|
|
|
const struct segmentation *const seg = &cm->seg;
|
2013-07-02 03:18:50 +02:00
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2013-07-23 15:51:44 +02:00
|
|
|
const int mi_width = num_8x8_blocks_wide_lookup[bsize];
|
2013-08-05 21:15:52 +02:00
|
|
|
const int mi_height = num_8x8_blocks_high_lookup[bsize];
|
2013-11-07 23:56:58 +01:00
|
|
|
int max_plane;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-05-11 02:06:37 +02:00
|
|
|
assert(mi->mbmi.sb_type == bsize);
|
2013-06-28 19:36:20 +02:00
|
|
|
|
2014-03-25 18:33:02 +01:00
|
|
|
*mi_addr = *mi;
|
|
|
|
|
|
|
|
// For in frame adaptive Q, check for reseting the segment_id and updating
|
|
|
|
// the cyclic refresh map.
|
|
|
|
if ((cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) && seg->enabled &&
|
2014-03-14 22:35:47 +01:00
|
|
|
output_enabled) {
|
2014-04-02 01:18:47 +02:00
|
|
|
vp9_cyclic_refresh_update_segment(cpi, &xd->mi[0]->mbmi,
|
2014-03-26 19:00:35 +01:00
|
|
|
mi_row, mi_col, bsize, 1);
|
2014-03-25 18:33:02 +01:00
|
|
|
vp9_init_plane_quantizers(cpi, x);
|
2014-03-14 22:35:47 +01:00
|
|
|
}
|
2013-11-22 18:21:53 +01:00
|
|
|
|
2013-11-07 23:56:58 +01:00
|
|
|
max_plane = is_inter_block(mbmi) ? MAX_MB_PLANE : 1;
|
|
|
|
for (i = 0; i < max_plane; ++i) {
|
2013-11-01 20:53:37 +01:00
|
|
|
p[i].coeff = ctx->coeff_pbuf[i][1];
|
2013-11-27 03:52:10 +01:00
|
|
|
p[i].qcoeff = ctx->qcoeff_pbuf[i][1];
|
2013-11-01 20:53:37 +01:00
|
|
|
pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][1];
|
2013-12-04 02:59:32 +01:00
|
|
|
p[i].eobs = ctx->eobs_pbuf[i][1];
|
2013-11-01 20:53:37 +01:00
|
|
|
}
|
|
|
|
|
2013-11-07 23:56:58 +01:00
|
|
|
for (i = max_plane; i < MAX_MB_PLANE; ++i) {
|
|
|
|
p[i].coeff = ctx->coeff_pbuf[i][2];
|
2013-11-27 03:52:10 +01:00
|
|
|
p[i].qcoeff = ctx->qcoeff_pbuf[i][2];
|
2013-11-07 23:56:58 +01:00
|
|
|
pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][2];
|
2013-12-04 02:59:32 +01:00
|
|
|
p[i].eobs = ctx->eobs_pbuf[i][2];
|
2013-11-07 23:56:58 +01:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Restore the coding context of the MB to that that was in place
|
|
|
|
// when the mode was picked for it
|
2013-08-06 20:04:31 +02:00
|
|
|
for (y = 0; y < mi_height; y++)
|
|
|
|
for (x_idx = 0; x_idx < mi_width; x_idx++)
|
2013-08-22 23:45:24 +02:00
|
|
|
if ((xd->mb_to_right_edge >> (3 + MI_SIZE_LOG2)) + mi_width > x_idx
|
2013-11-22 18:21:53 +01:00
|
|
|
&& (xd->mb_to_bottom_edge >> (3 + MI_SIZE_LOG2)) + mi_height > y) {
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[x_idx + y * mis] = mi_addr;
|
2013-11-22 18:21:53 +01:00
|
|
|
}
|
2013-08-06 20:04:31 +02:00
|
|
|
|
2014-03-14 22:35:47 +01:00
|
|
|
if (cpi->oxcf.aq_mode)
|
2014-02-28 19:11:31 +01:00
|
|
|
vp9_init_plane_quantizers(cpi, x);
|
2013-10-07 20:20:10 +02:00
|
|
|
|
2013-07-08 23:49:33 +02:00
|
|
|
// FIXME(rbultje) I'm pretty sure this should go to the end of this block
|
|
|
|
// (i.e. after the output_enabled)
|
2013-08-02 20:45:21 +02:00
|
|
|
if (bsize < BLOCK_32X32) {
|
|
|
|
if (bsize < BLOCK_16X16)
|
2013-08-03 02:28:23 +02:00
|
|
|
ctx->tx_rd_diff[ALLOW_16X16] = ctx->tx_rd_diff[ALLOW_8X8];
|
|
|
|
ctx->tx_rd_diff[ALLOW_32X32] = ctx->tx_rd_diff[ALLOW_16X16];
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-08-02 20:45:21 +02:00
|
|
|
if (is_inter_block(mbmi) && mbmi->sb_type < BLOCK_8X8) {
|
2013-07-18 01:46:53 +02:00
|
|
|
mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int;
|
|
|
|
mbmi->mv[1].as_int = mi->bmi[3].as_mv[1].as_int;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
2013-01-07 20:02:14 +01:00
|
|
|
x->skip = ctx->skip;
|
2013-09-21 01:29:24 +02:00
|
|
|
vpx_memcpy(x->zcoeff_blk[mbmi->tx_size], ctx->zcoeff_blk,
|
2013-10-16 21:43:03 +02:00
|
|
|
sizeof(uint8_t) * ctx->num_4x4_blk);
|
2013-09-21 01:29:24 +02:00
|
|
|
|
2013-01-06 03:20:25 +01:00
|
|
|
if (!output_enabled)
|
|
|
|
return;
|
|
|
|
|
2013-08-14 20:20:33 +02:00
|
|
|
if (!vp9_segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
|
2013-07-29 22:38:40 +02:00
|
|
|
for (i = 0; i < TX_MODES; i++)
|
2013-08-03 02:28:23 +02:00
|
|
|
cpi->rd_tx_select_diff[i] += ctx->tx_rd_diff[i];
|
2012-10-09 18:18:21 +02:00
|
|
|
}
|
|
|
|
|
2012-07-03 22:57:27 +02:00
|
|
|
#if CONFIG_INTERNAL_STATS
|
2014-02-14 23:46:29 +01:00
|
|
|
if (frame_is_intra_only(cm)) {
|
2012-07-14 00:21:29 +02:00
|
|
|
static const int kf_mode_index[] = {
|
2014-02-03 23:29:28 +01:00
|
|
|
THR_DC /*DC_PRED*/,
|
|
|
|
THR_V_PRED /*V_PRED*/,
|
|
|
|
THR_H_PRED /*H_PRED*/,
|
|
|
|
THR_D45_PRED /*D45_PRED*/,
|
2012-07-14 00:21:29 +02:00
|
|
|
THR_D135_PRED /*D135_PRED*/,
|
|
|
|
THR_D117_PRED /*D117_PRED*/,
|
|
|
|
THR_D153_PRED /*D153_PRED*/,
|
2013-08-24 02:33:48 +02:00
|
|
|
THR_D207_PRED /*D207_PRED*/,
|
2014-02-03 23:29:28 +01:00
|
|
|
THR_D63_PRED /*D63_PRED*/,
|
|
|
|
THR_TM /*TM_PRED*/,
|
2012-07-14 00:21:29 +02:00
|
|
|
};
|
2014-02-14 23:46:29 +01:00
|
|
|
++cpi->mode_chosen_counts[kf_mode_index[mbmi->mode]];
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
|
|
|
// Note how often each mode chosen as best
|
2014-02-14 23:46:29 +01:00
|
|
|
++cpi->mode_chosen_counts[ctx->best_mode_index];
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (!frame_is_intra_only(cm)) {
|
2014-02-05 20:04:53 +01:00
|
|
|
if (is_inter_block(mbmi)) {
|
2014-03-19 22:26:11 +01:00
|
|
|
vp9_update_mv_count(cm, xd);
|
2014-02-05 20:04:53 +01:00
|
|
|
|
|
|
|
if (cm->interp_filter == SWITCHABLE) {
|
|
|
|
const int ctx = vp9_get_pred_context_switchable_interp(xd);
|
|
|
|
++cm->counts.switchable_interp[ctx][mbmi->interp_filter];
|
|
|
|
}
|
2012-11-30 01:39:15 +01:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-11-23 01:35:37 +01:00
|
|
|
cpi->rd_comp_pred_diff[SINGLE_REFERENCE] += ctx->single_pred_diff;
|
|
|
|
cpi->rd_comp_pred_diff[COMPOUND_REFERENCE] += ctx->comp_pred_diff;
|
|
|
|
cpi->rd_comp_pred_diff[REFERENCE_MODE_SELECT] += ctx->hybrid_pred_diff;
|
2013-07-08 23:49:33 +02:00
|
|
|
|
2014-02-05 20:04:53 +01:00
|
|
|
for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
|
2013-07-08 23:49:33 +02:00
|
|
|
cpi->rd_filter_diff[i] += ctx->best_filter_diff[i];
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
|
|
|
|
2013-06-19 23:26:49 +02:00
|
|
|
void vp9_setup_src_planes(MACROBLOCK *x, const YV12_BUFFER_CONFIG *src,
|
2013-10-01 20:54:10 +02:00
|
|
|
int mi_row, int mi_col) {
|
|
|
|
uint8_t *const buffers[4] = {src->y_buffer, src->u_buffer, src->v_buffer,
|
|
|
|
src->alpha_buffer};
|
|
|
|
const int strides[4] = {src->y_stride, src->uv_stride, src->uv_stride,
|
|
|
|
src->alpha_stride};
|
2013-05-16 02:55:08 +02:00
|
|
|
int i;
|
|
|
|
|
2013-12-13 05:33:06 +01:00
|
|
|
// Set current frame pointer.
|
|
|
|
x->e_mbd.cur_buf = src;
|
|
|
|
|
2013-10-01 20:54:10 +02:00
|
|
|
for (i = 0; i < MAX_MB_PLANE; i++)
|
|
|
|
setup_pred_plane(&x->plane[i].src, buffers[i], strides[i], mi_row, mi_col,
|
2013-06-19 23:26:49 +02:00
|
|
|
NULL, x->e_mbd.plane[i].subsampling_x,
|
2013-05-16 02:55:08 +02:00
|
|
|
x->e_mbd.plane[i].subsampling_y);
|
2013-04-24 01:22:47 +02:00
|
|
|
}
|
|
|
|
|
2014-01-17 00:59:40 +01:00
|
|
|
static void rd_pick_sb_modes(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
int mi_row, int mi_col,
|
|
|
|
int *totalrate, int64_t *totaldist,
|
|
|
|
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
|
|
|
|
int64_t best_rd) {
|
2013-07-11 00:57:28 +02:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2014-03-10 18:58:32 +01:00
|
|
|
MB_MODE_INFO *mbmi;
|
2013-11-01 20:53:37 +01:00
|
|
|
struct macroblock_plane *const p = x->plane;
|
|
|
|
struct macroblockd_plane *const pd = xd->plane;
|
2014-03-10 18:58:32 +01:00
|
|
|
const AQ_MODE aq_mode = cpi->oxcf.aq_mode;
|
2014-03-14 19:03:58 +01:00
|
|
|
int i, orig_rdmult;
|
2013-10-17 20:04:57 +02:00
|
|
|
double rdmult_ratio;
|
|
|
|
|
2014-02-14 00:49:21 +01:00
|
|
|
vp9_clear_system_state();
|
2013-10-17 20:04:57 +02:00
|
|
|
rdmult_ratio = 1.0; // avoid uninitialized warnings
|
2012-08-20 23:43:34 +02:00
|
|
|
|
2013-08-20 21:55:41 +02:00
|
|
|
// Use the lower precision, but faster, 32x32 fdct for mode selection.
|
2013-08-08 00:22:51 +02:00
|
|
|
x->use_lp32x32fdct = 1;
|
2013-06-14 20:28:56 +02:00
|
|
|
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize < BLOCK_8X8) {
|
2013-08-01 18:04:15 +02:00
|
|
|
// When ab_index = 0 all sub-blocks are handled, so for ab_index != 0
|
|
|
|
// there is nothing to be done.
|
2013-11-12 00:58:57 +01:00
|
|
|
if (x->ab_index != 0) {
|
2013-08-01 23:57:46 +02:00
|
|
|
*totalrate = 0;
|
|
|
|
*totaldist = 0;
|
2013-05-11 02:06:37 +02:00
|
|
|
return;
|
2013-08-01 23:57:46 +02:00
|
|
|
}
|
2013-08-01 18:04:15 +02:00
|
|
|
}
|
2013-05-11 02:06:37 +02:00
|
|
|
|
2013-10-25 17:18:04 +02:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, bsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
mbmi = &xd->mi[0]->mbmi;
|
2014-03-10 18:58:32 +01:00
|
|
|
mbmi->sb_type = bsize;
|
2013-07-31 18:33:58 +02:00
|
|
|
|
2013-11-01 20:53:37 +01:00
|
|
|
for (i = 0; i < MAX_MB_PLANE; ++i) {
|
2013-11-06 06:07:08 +01:00
|
|
|
p[i].coeff = ctx->coeff_pbuf[i][0];
|
2013-11-27 03:52:10 +01:00
|
|
|
p[i].qcoeff = ctx->qcoeff_pbuf[i][0];
|
2013-11-06 06:07:08 +01:00
|
|
|
pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][0];
|
2013-12-04 02:59:32 +01:00
|
|
|
p[i].eobs = ctx->eobs_pbuf[i][0];
|
2013-11-01 20:53:37 +01:00
|
|
|
}
|
2013-11-06 06:07:08 +01:00
|
|
|
ctx->is_coded = 0;
|
2013-11-07 23:56:58 +01:00
|
|
|
x->skip_recode = 0;
|
2013-11-01 20:53:37 +01:00
|
|
|
|
2013-08-22 14:51:04 +02:00
|
|
|
// Set to zero to make sure we do not use the previous encoded frame stats
|
2014-03-10 18:58:32 +01:00
|
|
|
mbmi->skip = 0;
|
2013-08-22 14:51:04 +02:00
|
|
|
|
Speed feature to skip split partition based on var
Adds a speed feature to disable split partition search based on a
given threshold on the source variance. A tighter threshold derived
from the threshold provided is used to also disable horizontal and
vertical partitions.
Results on derfraw300:
threshold = 16, psnr = -0.057%, speedup ~1% (football)
threshold = 32, psnr = -0.150%, speedup ~4-5% (football)
threshold = 64, psnr = -0.570%, speedup ~10-12% (football)
Results on stdhdraw250:
threshold = 32, psnr = -0.18%, speedup is somewhat more than derf
because of a larger number of smoother blocks at higher resolution.
Based on these results, a threshold of 32 is chosen for speed 1,
and a threshold of 64 is chosen for speeds 2 and above.
Change-Id: If08912fb6c67fd4242d12a0d094783a99f52f6c6
2013-08-03 02:15:38 +02:00
|
|
|
x->source_variance = get_sby_perpixel_variance(cpi, x, bsize);
|
2013-08-22 14:51:04 +02:00
|
|
|
|
2014-03-10 18:58:32 +01:00
|
|
|
if (aq_mode == VARIANCE_AQ) {
|
2014-01-10 22:48:44 +01:00
|
|
|
const int energy = bsize <= BLOCK_16X16 ? x->mb_energy
|
|
|
|
: vp9_block_energy(cpi, x, bsize);
|
2014-02-03 13:47:01 +01:00
|
|
|
|
|
|
|
if (cm->frame_type == KEY_FRAME ||
|
|
|
|
cpi->refresh_alt_ref_frame ||
|
|
|
|
(cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref)) {
|
2014-03-10 18:58:32 +01:00
|
|
|
mbmi->segment_id = vp9_vaq_segment_id(energy);
|
2014-02-03 13:47:01 +01:00
|
|
|
} else {
|
|
|
|
const uint8_t *const map = cm->seg.update_map ? cpi->segmentation_map
|
|
|
|
: cm->last_frame_seg_map;
|
2014-03-10 18:58:32 +01:00
|
|
|
mbmi->segment_id = vp9_get_segment_id(cm, map, bsize, mi_row, mi_col);
|
2014-02-03 13:47:01 +01:00
|
|
|
}
|
|
|
|
|
2013-10-07 20:20:10 +02:00
|
|
|
rdmult_ratio = vp9_vaq_rdmult_ratio(energy);
|
2014-02-28 19:11:31 +01:00
|
|
|
vp9_init_plane_quantizers(cpi, x);
|
2013-10-07 20:20:10 +02:00
|
|
|
}
|
|
|
|
|
2014-03-14 19:03:58 +01:00
|
|
|
// Save rdmult before it might be changed, so it can be restored later.
|
|
|
|
orig_rdmult = x->rdmult;
|
2013-01-06 03:20:25 +01:00
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM)
|
2014-02-09 04:41:37 +01:00
|
|
|
activity_masking(cpi, x);
|
2012-08-20 23:43:34 +02:00
|
|
|
|
2014-03-10 18:58:32 +01:00
|
|
|
if (aq_mode == VARIANCE_AQ) {
|
2014-02-14 00:49:21 +01:00
|
|
|
vp9_clear_system_state();
|
2014-02-19 03:00:09 +01:00
|
|
|
x->rdmult = (int)round(x->rdmult * rdmult_ratio);
|
2014-03-10 18:58:32 +01:00
|
|
|
} else if (aq_mode == COMPLEXITY_AQ) {
|
2013-11-22 18:21:53 +01:00
|
|
|
const int mi_offset = mi_row * cm->mi_cols + mi_col;
|
|
|
|
unsigned char complexity = cpi->complexity_map[mi_offset];
|
2014-02-03 13:47:01 +01:00
|
|
|
const int is_edge = (mi_row <= 1) || (mi_row >= (cm->mi_rows - 2)) ||
|
|
|
|
(mi_col <= 1) || (mi_col >= (cm->mi_cols - 2));
|
2014-03-10 18:58:32 +01:00
|
|
|
if (!is_edge && (complexity > 128))
|
|
|
|
x->rdmult += ((x->rdmult * (complexity - 128)) / 256);
|
2014-03-14 22:35:47 +01:00
|
|
|
} else if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) {
|
|
|
|
const uint8_t *const map = cm->seg.update_map ? cpi->segmentation_map
|
|
|
|
: cm->last_frame_seg_map;
|
|
|
|
// If segment 1, use rdmult for that segment.
|
|
|
|
if (vp9_get_segment_id(cm, map, bsize, mi_row, mi_col))
|
2014-03-26 19:00:35 +01:00
|
|
|
x->rdmult = vp9_cyclic_refresh_get_rdmult(cpi->cyclic_refresh);
|
2013-10-17 20:04:57 +02:00
|
|
|
}
|
2013-10-07 20:20:10 +02:00
|
|
|
|
2013-07-11 00:57:28 +02:00
|
|
|
// Find best coding mode & reconstruct the MB so it is available
|
|
|
|
// as a predictor for MBs that follow in the SB
|
2013-10-03 18:07:24 +02:00
|
|
|
if (frame_is_intra_only(cm)) {
|
2013-07-17 18:56:46 +02:00
|
|
|
vp9_rd_pick_intra_mode_sb(cpi, x, totalrate, totaldist, bsize, ctx,
|
|
|
|
best_rd);
|
2013-09-28 01:02:49 +02:00
|
|
|
} else {
|
|
|
|
if (bsize >= BLOCK_8X8)
|
2013-10-25 17:18:04 +02:00
|
|
|
vp9_rd_pick_inter_mode_sb(cpi, x, tile, mi_row, mi_col,
|
|
|
|
totalrate, totaldist, bsize, ctx, best_rd);
|
2013-09-28 01:02:49 +02:00
|
|
|
else
|
2013-10-25 17:18:04 +02:00
|
|
|
vp9_rd_pick_inter_mode_sub8x8(cpi, x, tile, mi_row, mi_col, totalrate,
|
2013-09-28 01:02:49 +02:00
|
|
|
totaldist, bsize, ctx, best_rd);
|
|
|
|
}
|
2013-10-07 20:20:10 +02:00
|
|
|
|
2014-03-10 18:58:32 +01:00
|
|
|
if (aq_mode == VARIANCE_AQ) {
|
2013-10-17 20:04:57 +02:00
|
|
|
x->rdmult = orig_rdmult;
|
|
|
|
if (*totalrate != INT_MAX) {
|
2014-02-14 00:49:21 +01:00
|
|
|
vp9_clear_system_state();
|
2014-02-19 03:04:13 +01:00
|
|
|
*totalrate = (int)round(*totalrate * rdmult_ratio);
|
2013-10-17 20:04:57 +02:00
|
|
|
}
|
2014-03-14 22:35:47 +01:00
|
|
|
} else if ((cpi->oxcf.aq_mode == COMPLEXITY_AQ) ||
|
|
|
|
(cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)) {
|
2014-02-03 13:47:01 +01:00
|
|
|
x->rdmult = orig_rdmult;
|
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-08-01 01:59:15 +02:00
|
|
|
static void update_stats(VP9_COMP *cpi) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2014-02-08 00:19:54 +01:00
|
|
|
const MACROBLOCK *const x = &cpi->mb;
|
|
|
|
const MACROBLOCKD *const xd = &x->e_mbd;
|
2014-04-02 01:18:47 +02:00
|
|
|
const MODE_INFO *const mi = xd->mi[0];
|
2014-02-08 00:19:54 +01:00
|
|
|
const MB_MODE_INFO *const mbmi = &mi->mbmi;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-10-03 18:07:24 +02:00
|
|
|
if (!frame_is_intra_only(cm)) {
|
2013-08-14 20:20:33 +02:00
|
|
|
const int seg_ref_active = vp9_segfeature_active(&cm->seg, mbmi->segment_id,
|
2013-07-10 21:29:43 +02:00
|
|
|
SEG_LVL_REF_FRAME);
|
2014-02-08 00:19:54 +01:00
|
|
|
if (!seg_ref_active) {
|
|
|
|
FRAME_COUNTS *const counts = &cm->counts;
|
|
|
|
const int inter_block = is_inter_block(mbmi);
|
|
|
|
|
|
|
|
counts->intra_inter[vp9_get_intra_inter_context(xd)][inter_block]++;
|
|
|
|
|
|
|
|
// If the segment reference feature is enabled we have only a single
|
|
|
|
// reference frame allowed for the segment so exclude it from
|
|
|
|
// the reference frame counts used to work out probabilities.
|
|
|
|
if (inter_block) {
|
|
|
|
const MV_REFERENCE_FRAME ref0 = mbmi->ref_frame[0];
|
2013-06-07 20:54:20 +02:00
|
|
|
|
2014-02-08 00:19:54 +01:00
|
|
|
if (cm->reference_mode == REFERENCE_MODE_SELECT)
|
|
|
|
counts->comp_inter[vp9_get_reference_mode_context(cm, xd)]
|
|
|
|
[has_second_ref(mbmi)]++;
|
|
|
|
|
|
|
|
if (has_second_ref(mbmi)) {
|
|
|
|
counts->comp_ref[vp9_get_pred_context_comp_ref_p(cm, xd)]
|
|
|
|
[ref0 == GOLDEN_FRAME]++;
|
|
|
|
} else {
|
|
|
|
counts->single_ref[vp9_get_pred_context_single_ref_p1(xd)][0]
|
|
|
|
[ref0 != LAST_FRAME]++;
|
|
|
|
if (ref0 != LAST_FRAME)
|
|
|
|
counts->single_ref[vp9_get_pred_context_single_ref_p2(xd)][1]
|
|
|
|
[ref0 != GOLDEN_FRAME]++;
|
|
|
|
}
|
2013-06-06 22:44:34 +02:00
|
|
|
}
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-08-27 20:05:08 +02:00
|
|
|
static BLOCK_SIZE *get_sb_partitioning(MACROBLOCK *x, BLOCK_SIZE bsize) {
|
2013-05-08 23:24:43 +02:00
|
|
|
switch (bsize) {
|
2013-08-02 19:48:27 +02:00
|
|
|
case BLOCK_64X64:
|
2013-05-08 23:24:43 +02:00
|
|
|
return &x->sb64_partitioning;
|
2013-08-02 19:48:27 +02:00
|
|
|
case BLOCK_32X32:
|
2013-11-12 00:58:57 +01:00
|
|
|
return &x->sb_partitioning[x->sb_index];
|
2013-08-02 19:48:27 +02:00
|
|
|
case BLOCK_16X16:
|
2013-11-12 00:58:57 +01:00
|
|
|
return &x->mb_partitioning[x->sb_index][x->mb_index];
|
2013-08-02 19:48:27 +02:00
|
|
|
case BLOCK_8X8:
|
2013-11-12 00:58:57 +01:00
|
|
|
return &x->b_partitioning[x->sb_index][x->mb_index][x->b_index];
|
2013-05-08 23:24:43 +02:00
|
|
|
default:
|
|
|
|
assert(0);
|
2013-10-04 23:37:31 +02:00
|
|
|
return NULL;
|
2013-05-08 23:24:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void restore_context(VP9_COMP *cpi, int mi_row, int mi_col,
|
|
|
|
ENTROPY_CONTEXT a[16 * MAX_MB_PLANE],
|
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE],
|
2013-06-19 23:26:49 +02:00
|
|
|
PARTITION_CONTEXT sa[8], PARTITION_CONTEXT sl[8],
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE bsize) {
|
2013-08-05 21:15:52 +02:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2013-05-08 23:24:43 +02:00
|
|
|
int p;
|
2013-08-05 21:15:52 +02:00
|
|
|
const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
|
|
|
|
const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
|
2013-07-23 15:51:44 +02:00
|
|
|
int mi_width = num_8x8_blocks_wide_lookup[bsize];
|
|
|
|
int mi_height = num_8x8_blocks_high_lookup[bsize];
|
2013-05-08 23:24:43 +02:00
|
|
|
for (p = 0; p < MAX_MB_PLANE; p++) {
|
2013-06-19 23:26:49 +02:00
|
|
|
vpx_memcpy(
|
2014-03-25 02:32:46 +01:00
|
|
|
xd->above_context[p] + ((mi_col * 2) >> xd->plane[p].subsampling_x),
|
2013-07-23 15:51:44 +02:00
|
|
|
a + num_4x4_blocks_wide * p,
|
|
|
|
(sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide) >>
|
|
|
|
xd->plane[p].subsampling_x);
|
2013-06-19 23:26:49 +02:00
|
|
|
vpx_memcpy(
|
2014-03-25 02:32:46 +01:00
|
|
|
xd->left_context[p]
|
2013-07-23 15:51:44 +02:00
|
|
|
+ ((mi_row & MI_MASK) * 2 >> xd->plane[p].subsampling_y),
|
|
|
|
l + num_4x4_blocks_high * p,
|
|
|
|
(sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high) >>
|
|
|
|
xd->plane[p].subsampling_y);
|
|
|
|
}
|
2014-03-21 00:08:54 +01:00
|
|
|
vpx_memcpy(xd->above_seg_context + mi_col, sa,
|
|
|
|
sizeof(*xd->above_seg_context) * mi_width);
|
|
|
|
vpx_memcpy(xd->left_seg_context + (mi_row & MI_MASK), sl,
|
|
|
|
sizeof(xd->left_seg_context[0]) * mi_height);
|
2013-07-02 03:18:50 +02:00
|
|
|
}
|
2013-05-31 00:13:08 +02:00
|
|
|
static void save_context(VP9_COMP *cpi, int mi_row, int mi_col,
|
2013-06-19 23:26:49 +02:00
|
|
|
ENTROPY_CONTEXT a[16 * MAX_MB_PLANE],
|
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE],
|
|
|
|
PARTITION_CONTEXT sa[8], PARTITION_CONTEXT sl[8],
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE bsize) {
|
2013-08-05 21:15:52 +02:00
|
|
|
const MACROBLOCK *const x = &cpi->mb;
|
|
|
|
const MACROBLOCKD *const xd = &x->e_mbd;
|
2013-05-31 00:13:08 +02:00
|
|
|
int p;
|
2013-08-05 21:15:52 +02:00
|
|
|
const int num_4x4_blocks_wide = num_4x4_blocks_wide_lookup[bsize];
|
|
|
|
const int num_4x4_blocks_high = num_4x4_blocks_high_lookup[bsize];
|
2013-07-23 15:51:44 +02:00
|
|
|
int mi_width = num_8x8_blocks_wide_lookup[bsize];
|
|
|
|
int mi_height = num_8x8_blocks_high_lookup[bsize];
|
2013-05-31 00:13:08 +02:00
|
|
|
|
|
|
|
// buffer the above/left context information of the block in search.
|
|
|
|
for (p = 0; p < MAX_MB_PLANE; ++p) {
|
2013-06-19 23:26:49 +02:00
|
|
|
vpx_memcpy(
|
2013-07-23 15:51:44 +02:00
|
|
|
a + num_4x4_blocks_wide * p,
|
2014-03-25 02:32:46 +01:00
|
|
|
xd->above_context[p] + (mi_col * 2 >> xd->plane[p].subsampling_x),
|
2013-07-23 15:51:44 +02:00
|
|
|
(sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide) >>
|
|
|
|
xd->plane[p].subsampling_x);
|
2013-06-19 23:26:49 +02:00
|
|
|
vpx_memcpy(
|
2013-07-23 15:51:44 +02:00
|
|
|
l + num_4x4_blocks_high * p,
|
2014-03-25 02:32:46 +01:00
|
|
|
xd->left_context[p]
|
2013-07-23 15:51:44 +02:00
|
|
|
+ ((mi_row & MI_MASK) * 2 >> xd->plane[p].subsampling_y),
|
|
|
|
(sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high) >>
|
|
|
|
xd->plane[p].subsampling_y);
|
|
|
|
}
|
2014-03-21 00:08:54 +01:00
|
|
|
vpx_memcpy(sa, xd->above_seg_context + mi_col,
|
|
|
|
sizeof(*xd->above_seg_context) * mi_width);
|
|
|
|
vpx_memcpy(sl, xd->left_seg_context + (mi_row & MI_MASK),
|
|
|
|
sizeof(xd->left_seg_context[0]) * mi_height);
|
2013-07-23 15:51:44 +02:00
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
|
2013-10-25 17:18:04 +02:00
|
|
|
static void encode_b(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
TOKENEXTRA **tp, int mi_row, int mi_col,
|
2013-12-11 23:38:22 +01:00
|
|
|
int output_enabled, BLOCK_SIZE bsize) {
|
2013-11-12 00:58:57 +01:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize < BLOCK_8X8) {
|
2013-08-01 18:04:15 +02:00
|
|
|
// When ab_index = 0 all sub-blocks are handled, so for ab_index != 0
|
|
|
|
// there is nothing to be done.
|
2013-11-12 00:58:57 +01:00
|
|
|
if (x->ab_index > 0)
|
2013-05-16 07:28:36 +02:00
|
|
|
return;
|
2013-08-01 18:04:15 +02:00
|
|
|
}
|
2013-10-25 17:18:04 +02:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, bsize);
|
2014-03-14 22:35:47 +01:00
|
|
|
update_state(cpi, get_block_context(x, bsize), mi_row, mi_col, bsize,
|
|
|
|
output_enabled);
|
2013-05-05 07:09:43 +02:00
|
|
|
encode_superblock(cpi, tp, output_enabled, mi_row, mi_col, bsize);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (output_enabled) {
|
2013-08-01 01:59:15 +02:00
|
|
|
update_stats(cpi);
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
(*tp)->token = EOSB_TOKEN;
|
|
|
|
(*tp)++;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
|
2013-10-25 17:18:04 +02:00
|
|
|
static void encode_sb(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
TOKENEXTRA **tp, int mi_row, int mi_col,
|
2013-08-27 20:05:08 +02:00
|
|
|
int output_enabled, BLOCK_SIZE bsize) {
|
2013-11-12 00:58:57 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-03-21 00:08:54 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
|
2013-12-11 23:38:22 +01:00
|
|
|
const int bsl = b_width_log2(bsize), hbs = (1 << bsl) / 4;
|
|
|
|
int ctx;
|
2013-07-23 15:51:44 +02:00
|
|
|
PARTITION_TYPE partition;
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE subsize;
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-04-28 17:59:13 +02:00
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
2013-01-07 20:41:49 +01:00
|
|
|
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize >= BLOCK_8X8) {
|
2014-03-21 20:12:55 +01:00
|
|
|
ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2013-12-11 23:38:22 +01:00
|
|
|
subsize = *get_sb_partitioning(x, bsize);
|
|
|
|
} else {
|
|
|
|
ctx = 0;
|
|
|
|
subsize = BLOCK_4X4;
|
2013-05-01 01:13:20 +02:00
|
|
|
}
|
2013-12-11 23:38:22 +01:00
|
|
|
|
|
|
|
partition = partition_lookup[bsl][subsize];
|
2013-01-06 03:20:25 +01:00
|
|
|
|
2013-07-23 15:51:44 +02:00
|
|
|
switch (partition) {
|
|
|
|
case PARTITION_NONE:
|
2013-08-06 00:23:49 +02:00
|
|
|
if (output_enabled && bsize >= BLOCK_8X8)
|
2013-12-11 23:38:22 +01:00
|
|
|
cm->counts.partition[ctx][PARTITION_NONE]++;
|
|
|
|
encode_b(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
2013-07-23 15:51:44 +02:00
|
|
|
break;
|
|
|
|
case PARTITION_VERT:
|
|
|
|
if (output_enabled)
|
2013-12-11 23:38:22 +01:00
|
|
|
cm->counts.partition[ctx][PARTITION_VERT]++;
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
encode_b(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
|
|
|
if (mi_col + hbs < cm->mi_cols) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
encode_b(cpi, tile, tp, mi_row, mi_col + hbs, output_enabled, subsize);
|
|
|
|
}
|
2013-07-23 15:51:44 +02:00
|
|
|
break;
|
|
|
|
case PARTITION_HORZ:
|
|
|
|
if (output_enabled)
|
2013-12-11 23:38:22 +01:00
|
|
|
cm->counts.partition[ctx][PARTITION_HORZ]++;
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
encode_b(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
|
|
|
if (mi_row + hbs < cm->mi_rows) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
encode_b(cpi, tile, tp, mi_row + hbs, mi_col, output_enabled, subsize);
|
|
|
|
}
|
2013-07-23 15:51:44 +02:00
|
|
|
break;
|
|
|
|
case PARTITION_SPLIT:
|
|
|
|
subsize = get_subsize(bsize, PARTITION_SPLIT);
|
|
|
|
if (output_enabled)
|
2013-12-11 23:38:22 +01:00
|
|
|
cm->counts.partition[ctx][PARTITION_SPLIT]++;
|
|
|
|
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
encode_sb(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
encode_sb(cpi, tile, tp, mi_row, mi_col + hbs, output_enabled, subsize);
|
|
|
|
*get_sb_index(x, subsize) = 2;
|
|
|
|
encode_sb(cpi, tile, tp, mi_row + hbs, mi_col, output_enabled, subsize);
|
|
|
|
*get_sb_index(x, subsize) = 3;
|
|
|
|
encode_sb(cpi, tile, tp, mi_row + hbs, mi_col + hbs, output_enabled,
|
|
|
|
subsize);
|
2013-07-23 15:51:44 +02:00
|
|
|
break;
|
|
|
|
default:
|
2013-12-11 23:38:22 +01:00
|
|
|
assert("Invalid partition type.");
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
2013-04-23 19:12:18 +02:00
|
|
|
|
2013-10-21 21:02:19 +02:00
|
|
|
if (partition != PARTITION_SPLIT || bsize == BLOCK_8X8)
|
2014-03-21 20:12:55 +01:00
|
|
|
update_partition_context(xd, mi_row, mi_col, subsize, bsize);
|
2012-04-07 01:38:34 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-08-31 01:39:26 +02:00
|
|
|
// Check to see if the given partition size is allowed for a specified number
|
|
|
|
// of 8x8 block rows and columns remaining in the image.
|
|
|
|
// If not then return the largest allowed partition size
|
|
|
|
static BLOCK_SIZE find_partition_size(BLOCK_SIZE bsize,
|
|
|
|
int rows_left, int cols_left,
|
|
|
|
int *bh, int *bw) {
|
2014-01-10 22:48:44 +01:00
|
|
|
if (rows_left <= 0 || cols_left <= 0) {
|
2013-08-31 01:39:26 +02:00
|
|
|
return MIN(bsize, BLOCK_8X8);
|
|
|
|
} else {
|
2014-02-28 18:15:36 +01:00
|
|
|
for (; bsize > 0; bsize -= 3) {
|
2013-08-31 01:39:26 +02:00
|
|
|
*bh = num_8x8_blocks_high_lookup[bsize];
|
|
|
|
*bw = num_8x8_blocks_wide_lookup[bsize];
|
|
|
|
if ((*bh <= rows_left) && (*bw <= cols_left)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return bsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This function attempts to set all mode info entries in a given SB64
|
|
|
|
// to the same block partition size.
|
|
|
|
// However, at the bottom and right borders of the image the requested size
|
|
|
|
// may not be allowed in which case this code attempts to choose the largest
|
|
|
|
// allowable partition.
|
2014-03-04 20:15:35 +01:00
|
|
|
static void set_fixed_partitioning(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
MODE_INFO **mi_8x8, int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE bsize) {
|
2013-06-20 16:46:51 +02:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2013-10-25 17:18:04 +02:00
|
|
|
int row8x8_remaining = tile->mi_row_end - mi_row;
|
|
|
|
int col8x8_remaining = tile->mi_col_end - mi_col;
|
2013-05-31 00:13:08 +02:00
|
|
|
int block_row, block_col;
|
2014-01-10 22:48:44 +01:00
|
|
|
MODE_INFO *mi_upper_left = cm->mi + mi_row * mis + mi_col;
|
2013-09-11 19:45:44 +02:00
|
|
|
int bh = num_8x8_blocks_high_lookup[bsize];
|
|
|
|
int bw = num_8x8_blocks_wide_lookup[bsize];
|
2013-08-31 01:39:26 +02:00
|
|
|
|
|
|
|
assert((row8x8_remaining > 0) && (col8x8_remaining > 0));
|
|
|
|
|
|
|
|
// Apply the requested partition size to the SB64 if it is all "in image"
|
|
|
|
if ((col8x8_remaining >= MI_BLOCK_SIZE) &&
|
|
|
|
(row8x8_remaining >= MI_BLOCK_SIZE)) {
|
2013-09-11 19:45:44 +02:00
|
|
|
for (block_row = 0; block_row < MI_BLOCK_SIZE; block_row += bh) {
|
|
|
|
for (block_col = 0; block_col < MI_BLOCK_SIZE; block_col += bw) {
|
|
|
|
int index = block_row * mis + block_col;
|
|
|
|
mi_8x8[index] = mi_upper_left + index;
|
|
|
|
mi_8x8[index]->mbmi.sb_type = bsize;
|
2013-08-31 01:39:26 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Else this is a partial SB64.
|
|
|
|
for (block_row = 0; block_row < MI_BLOCK_SIZE; block_row += bh) {
|
|
|
|
for (block_col = 0; block_col < MI_BLOCK_SIZE; block_col += bw) {
|
2013-09-11 19:45:44 +02:00
|
|
|
int index = block_row * mis + block_col;
|
2013-08-31 01:39:26 +02:00
|
|
|
// Find a partition size that fits
|
2014-02-25 00:21:13 +01:00
|
|
|
bsize = find_partition_size(bsize,
|
2013-08-31 01:39:26 +02:00
|
|
|
(row8x8_remaining - block_row),
|
|
|
|
(col8x8_remaining - block_col), &bh, &bw);
|
2013-09-11 19:45:44 +02:00
|
|
|
mi_8x8[index] = mi_upper_left + index;
|
|
|
|
mi_8x8[index]->mbmi.sb_type = bsize;
|
2013-08-31 01:39:26 +02:00
|
|
|
}
|
2013-05-31 00:13:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-09-11 19:45:44 +02:00
|
|
|
|
2014-01-08 23:51:00 +01:00
|
|
|
static void copy_partitioning(VP9_COMMON *cm, MODE_INFO **mi_8x8,
|
2013-09-11 19:45:44 +02:00
|
|
|
MODE_INFO **prev_mi_8x8) {
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2013-06-20 18:32:19 +02:00
|
|
|
int block_row, block_col;
|
2013-09-11 19:45:44 +02:00
|
|
|
|
2013-06-20 18:32:19 +02:00
|
|
|
for (block_row = 0; block_row < 8; ++block_row) {
|
|
|
|
for (block_col = 0; block_col < 8; ++block_col) {
|
2014-01-10 22:48:44 +01:00
|
|
|
MODE_INFO *const prev_mi = prev_mi_8x8[block_row * mis + block_col];
|
|
|
|
const BLOCK_SIZE sb_type = prev_mi ? prev_mi->mbmi.sb_type : 0;
|
2014-03-29 01:42:45 +01:00
|
|
|
|
2013-09-11 19:45:44 +02:00
|
|
|
if (prev_mi) {
|
2014-01-10 22:48:44 +01:00
|
|
|
const ptrdiff_t offset = prev_mi - cm->prev_mi;
|
2013-09-11 19:45:44 +02:00
|
|
|
mi_8x8[block_row * mis + block_col] = cm->mi + offset;
|
|
|
|
mi_8x8[block_row * mis + block_col]->mbmi.sb_type = sb_type;
|
|
|
|
}
|
2013-06-20 18:32:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-05-31 00:13:08 +02:00
|
|
|
|
2014-01-10 22:48:44 +01:00
|
|
|
static int sb_has_motion(const VP9_COMMON *cm, MODE_INFO **prev_mi_8x8) {
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2013-07-08 15:13:48 +02:00
|
|
|
int block_row, block_col;
|
|
|
|
|
|
|
|
if (cm->prev_mi) {
|
|
|
|
for (block_row = 0; block_row < 8; ++block_row) {
|
|
|
|
for (block_col = 0; block_col < 8; ++block_col) {
|
2014-01-10 22:48:44 +01:00
|
|
|
const MODE_INFO *prev_mi = prev_mi_8x8[block_row * mis + block_col];
|
2013-07-08 15:13:48 +02:00
|
|
|
if (prev_mi) {
|
|
|
|
if (abs(prev_mi->mbmi.mv[0].as_mv.row) >= 8 ||
|
|
|
|
abs(prev_mi->mbmi.mv[0].as_mv.col) >= 8)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2014-02-13 18:39:03 +01:00
|
|
|
|
2014-03-27 19:44:19 +01:00
|
|
|
static void update_state_rt(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
|
2014-03-14 22:35:47 +01:00
|
|
|
int mi_row, int mi_col, int bsize) {
|
2014-01-10 20:51:20 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-01-29 17:39:39 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2014-04-02 01:18:47 +02:00
|
|
|
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
|
2014-03-14 22:35:47 +01:00
|
|
|
const struct segmentation *const seg = &cm->seg;
|
2014-01-10 20:51:20 +01:00
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
*(xd->mi[0]) = ctx->mic;
|
2014-03-26 21:00:06 +01:00
|
|
|
|
2014-03-27 19:44:19 +01:00
|
|
|
// For in frame adaptive Q, check for reseting the segment_id and updating
|
|
|
|
// the cyclic refresh map.
|
|
|
|
if ((cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) && seg->enabled) {
|
2014-04-02 01:18:47 +02:00
|
|
|
vp9_cyclic_refresh_update_segment(cpi, &xd->mi[0]->mbmi,
|
2014-03-26 19:00:35 +01:00
|
|
|
mi_row, mi_col, bsize, 1);
|
2014-03-14 22:35:47 +01:00
|
|
|
vp9_init_plane_quantizers(cpi, x);
|
|
|
|
}
|
|
|
|
|
2014-03-15 01:05:35 +01:00
|
|
|
if (is_inter_block(mbmi)) {
|
2014-03-19 22:26:11 +01:00
|
|
|
vp9_update_mv_count(cm, xd);
|
2014-03-15 01:05:35 +01:00
|
|
|
|
|
|
|
if (cm->interp_filter == SWITCHABLE) {
|
|
|
|
const int pred_ctx = vp9_get_pred_context_switchable_interp(xd);
|
|
|
|
++cm->counts.switchable_interp[pred_ctx][mbmi->interp_filter];
|
2014-01-29 17:39:39 +01:00
|
|
|
}
|
|
|
|
}
|
2014-04-01 01:54:33 +02:00
|
|
|
|
|
|
|
x->skip = ctx->skip;
|
2014-01-29 17:39:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void encode_b_rt(VP9_COMP *cpi, const TileInfo *const tile,
|
2014-03-26 21:00:06 +01:00
|
|
|
TOKENEXTRA **tp, int mi_row, int mi_col,
|
|
|
|
int output_enabled, BLOCK_SIZE bsize) {
|
2014-01-29 17:39:39 +01:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-01-10 20:51:20 +01:00
|
|
|
|
|
|
|
if (bsize < BLOCK_8X8) {
|
|
|
|
// When ab_index = 0 all sub-blocks are handled, so for ab_index != 0
|
|
|
|
// there is nothing to be done.
|
2014-01-29 17:39:39 +01:00
|
|
|
if (x->ab_index > 0)
|
2014-01-10 20:51:20 +01:00
|
|
|
return;
|
2014-01-29 17:39:39 +01:00
|
|
|
}
|
2014-03-27 19:44:19 +01:00
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, bsize);
|
2014-03-14 22:35:47 +01:00
|
|
|
update_state_rt(cpi, get_block_context(x, bsize), mi_row, mi_col, bsize);
|
2014-01-29 17:39:39 +01:00
|
|
|
|
|
|
|
encode_superblock(cpi, tp, output_enabled, mi_row, mi_col, bsize);
|
|
|
|
update_stats(cpi);
|
|
|
|
|
|
|
|
(*tp)->token = EOSB_TOKEN;
|
|
|
|
(*tp)++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void encode_sb_rt(VP9_COMP *cpi, const TileInfo *const tile,
|
2014-02-14 23:41:47 +01:00
|
|
|
TOKENEXTRA **tp, int mi_row, int mi_col,
|
|
|
|
int output_enabled, BLOCK_SIZE bsize) {
|
2014-01-29 17:39:39 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-03-21 00:08:54 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
const int bsl = b_width_log2(bsize), hbs = (1 << bsl) / 4;
|
|
|
|
int ctx;
|
|
|
|
PARTITION_TYPE partition;
|
|
|
|
BLOCK_SIZE subsize;
|
|
|
|
|
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (bsize >= BLOCK_8X8) {
|
|
|
|
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
|
2014-04-02 01:18:47 +02:00
|
|
|
const int idx_str = xd->mi_stride * mi_row + mi_col;
|
2014-01-29 17:39:39 +01:00
|
|
|
MODE_INFO ** mi_8x8 = cm->mi_grid_visible + idx_str;
|
2014-03-21 20:12:55 +01:00
|
|
|
ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-01-29 17:39:39 +01:00
|
|
|
subsize = mi_8x8[0]->mbmi.sb_type;
|
2014-01-10 20:51:20 +01:00
|
|
|
} else {
|
2014-01-29 17:39:39 +01:00
|
|
|
ctx = 0;
|
|
|
|
subsize = BLOCK_4X4;
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
partition = partition_lookup[bsl][subsize];
|
|
|
|
|
2014-01-10 20:51:20 +01:00
|
|
|
switch (partition) {
|
|
|
|
case PARTITION_NONE:
|
2014-01-29 17:39:39 +01:00
|
|
|
if (output_enabled && bsize >= BLOCK_8X8)
|
|
|
|
cm->counts.partition[ctx][PARTITION_NONE]++;
|
|
|
|
encode_b_rt(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
2014-01-10 20:51:20 +01:00
|
|
|
break;
|
2014-01-29 17:39:39 +01:00
|
|
|
case PARTITION_VERT:
|
|
|
|
if (output_enabled)
|
|
|
|
cm->counts.partition[ctx][PARTITION_VERT]++;
|
2014-01-10 20:51:20 +01:00
|
|
|
*get_sb_index(x, subsize) = 0;
|
2014-01-29 17:39:39 +01:00
|
|
|
encode_b_rt(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
|
|
|
if (mi_col + hbs < cm->mi_cols) {
|
2014-01-10 20:51:20 +01:00
|
|
|
*get_sb_index(x, subsize) = 1;
|
2014-01-29 17:39:39 +01:00
|
|
|
encode_b_rt(cpi, tile, tp, mi_row, mi_col + hbs, output_enabled,
|
|
|
|
subsize);
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
|
|
|
break;
|
2014-01-29 17:39:39 +01:00
|
|
|
case PARTITION_HORZ:
|
|
|
|
if (output_enabled)
|
|
|
|
cm->counts.partition[ctx][PARTITION_HORZ]++;
|
2014-01-10 20:51:20 +01:00
|
|
|
*get_sb_index(x, subsize) = 0;
|
2014-01-29 17:39:39 +01:00
|
|
|
encode_b_rt(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
|
|
|
if (mi_row + hbs < cm->mi_rows) {
|
2014-01-10 20:51:20 +01:00
|
|
|
*get_sb_index(x, subsize) = 1;
|
2014-01-29 17:39:39 +01:00
|
|
|
encode_b_rt(cpi, tile, tp, mi_row + hbs, mi_col, output_enabled,
|
|
|
|
subsize);
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PARTITION_SPLIT:
|
2014-01-29 17:39:39 +01:00
|
|
|
subsize = get_subsize(bsize, PARTITION_SPLIT);
|
|
|
|
if (output_enabled)
|
|
|
|
cm->counts.partition[ctx][PARTITION_SPLIT]++;
|
2014-01-10 20:51:20 +01:00
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
encode_sb_rt(cpi, tile, tp, mi_row, mi_col, output_enabled, subsize);
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
encode_sb_rt(cpi, tile, tp, mi_row, mi_col + hbs, output_enabled,
|
|
|
|
subsize);
|
|
|
|
*get_sb_index(x, subsize) = 2;
|
|
|
|
encode_sb_rt(cpi, tile, tp, mi_row + hbs, mi_col, output_enabled,
|
|
|
|
subsize);
|
|
|
|
*get_sb_index(x, subsize) = 3;
|
|
|
|
encode_sb_rt(cpi, tile, tp, mi_row + hbs, mi_col + hbs, output_enabled,
|
2014-02-27 21:00:24 +01:00
|
|
|
subsize);
|
2014-01-10 20:51:20 +01:00
|
|
|
break;
|
|
|
|
default:
|
2014-01-29 17:39:39 +01:00
|
|
|
assert("Invalid partition type.");
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
if (partition != PARTITION_SPLIT || bsize == BLOCK_8X8)
|
2014-03-21 20:12:55 +01:00
|
|
|
update_partition_context(xd, mi_row, mi_col, subsize, bsize);
|
2014-01-10 20:51:20 +01:00
|
|
|
}
|
|
|
|
|
2013-10-25 17:18:04 +02:00
|
|
|
static void rd_use_partition(VP9_COMP *cpi,
|
|
|
|
const TileInfo *const tile,
|
|
|
|
MODE_INFO **mi_8x8,
|
2013-09-11 19:45:44 +02:00
|
|
|
TOKENEXTRA **tp, int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE bsize, int *rate, int64_t *dist,
|
|
|
|
int do_recon) {
|
2013-11-12 00:58:57 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-03-21 00:08:54 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2014-01-10 22:48:44 +01:00
|
|
|
const int bsl = b_width_log2(bsize);
|
2014-03-21 22:24:03 +01:00
|
|
|
const int mi_step = num_4x4_blocks_wide_lookup[bsize] / 2;
|
2014-01-10 22:48:44 +01:00
|
|
|
const int bss = (1 << bsl) / 4;
|
2013-05-31 00:13:08 +02:00
|
|
|
int i, pl;
|
2013-07-10 23:27:20 +02:00
|
|
|
PARTITION_TYPE partition = PARTITION_NONE;
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE subsize;
|
2013-05-31 00:13:08 +02:00
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
|
|
|
|
PARTITION_CONTEXT sl[8], sa[8];
|
2013-07-02 03:18:50 +02:00
|
|
|
int last_part_rate = INT_MAX;
|
2014-02-25 16:29:48 +01:00
|
|
|
int64_t last_part_dist = INT64_MAX;
|
2014-02-26 16:46:56 +01:00
|
|
|
int64_t last_part_rd = INT64_MAX;
|
2013-07-02 03:18:50 +02:00
|
|
|
int none_rate = INT_MAX;
|
2014-02-25 16:29:48 +01:00
|
|
|
int64_t none_dist = INT64_MAX;
|
2014-02-26 16:46:56 +01:00
|
|
|
int64_t none_rd = INT64_MAX;
|
2013-07-02 03:18:50 +02:00
|
|
|
int chosen_rate = INT_MAX;
|
2014-02-25 16:29:48 +01:00
|
|
|
int64_t chosen_dist = INT64_MAX;
|
2014-02-26 16:46:56 +01:00
|
|
|
int64_t chosen_rd = INT64_MAX;
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE sub_subsize = BLOCK_4X4;
|
2013-07-02 03:18:50 +02:00
|
|
|
int splits_below = 0;
|
2013-09-11 19:45:44 +02:00
|
|
|
BLOCK_SIZE bs_type = mi_8x8[0]->mbmi.sb_type;
|
2014-03-19 01:00:30 +01:00
|
|
|
int do_partition_search = 1;
|
2013-05-31 00:13:08 +02:00
|
|
|
|
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
|
|
|
|
2014-03-21 22:24:03 +01:00
|
|
|
assert(num_4x4_blocks_wide_lookup[bsize] ==
|
|
|
|
num_4x4_blocks_high_lookup[bsize]);
|
|
|
|
|
2013-07-23 15:51:44 +02:00
|
|
|
partition = partition_lookup[bsl][bs_type];
|
2013-05-31 00:13:08 +02:00
|
|
|
subsize = get_subsize(bsize, partition);
|
|
|
|
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize < BLOCK_8X8) {
|
2013-08-01 18:04:15 +02:00
|
|
|
// When ab_index = 0 all sub-blocks are handled, so for ab_index != 0
|
|
|
|
// there is nothing to be done.
|
2013-11-12 00:58:57 +01:00
|
|
|
if (x->ab_index != 0) {
|
2013-06-20 18:32:19 +02:00
|
|
|
*rate = 0;
|
|
|
|
*dist = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
2013-05-31 00:13:08 +02:00
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
}
|
|
|
|
save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
2013-07-02 03:18:50 +02:00
|
|
|
|
2013-10-07 20:20:10 +02:00
|
|
|
if (bsize == BLOCK_16X16) {
|
2014-04-01 01:54:33 +02:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, bsize);
|
2013-10-07 20:20:10 +02:00
|
|
|
x->mb_energy = vp9_block_energy(cpi, x, bsize);
|
2014-04-01 01:54:33 +02:00
|
|
|
} else {
|
|
|
|
x->in_active_map = check_active_map(cpi, x, mi_row, mi_col, bsize);
|
2013-10-07 20:20:10 +02:00
|
|
|
}
|
|
|
|
|
2014-03-19 01:00:30 +01:00
|
|
|
if (!x->in_active_map) {
|
|
|
|
do_partition_search = 0;
|
|
|
|
if (mi_row + (mi_step >> 1) < cm->mi_rows &&
|
|
|
|
mi_col + (mi_step >> 1) < cm->mi_cols) {
|
|
|
|
*(get_sb_partitioning(x, bsize)) = bsize;
|
|
|
|
bs_type = mi_8x8[0]->mbmi.sb_type = bsize;
|
|
|
|
subsize = bsize;
|
|
|
|
partition = PARTITION_NONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (do_partition_search &&
|
|
|
|
cpi->sf.partition_search_type == SEARCH_PARTITION &&
|
2014-02-26 02:22:34 +01:00
|
|
|
cpi->sf.adjust_partitioning_from_last_frame) {
|
2013-07-02 03:18:50 +02:00
|
|
|
// Check if any of the sub blocks are further split.
|
2013-08-06 00:23:49 +02:00
|
|
|
if (partition == PARTITION_SPLIT && subsize > BLOCK_8X8) {
|
2013-07-02 03:18:50 +02:00
|
|
|
sub_subsize = get_subsize(subsize, PARTITION_SPLIT);
|
|
|
|
splits_below = 1;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
int jj = i >> 1, ii = i & 0x01;
|
2013-09-11 19:45:44 +02:00
|
|
|
MODE_INFO * this_mi = mi_8x8[jj * bss * mis + ii * bss];
|
|
|
|
if (this_mi && this_mi->mbmi.sb_type >= sub_subsize) {
|
2013-07-02 03:18:50 +02:00
|
|
|
splits_below = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If partition is not none try none unless each of the 4 splits are split
|
|
|
|
// even further..
|
|
|
|
if (partition != PARTITION_NONE && !splits_below &&
|
2014-03-21 22:24:03 +01:00
|
|
|
mi_row + (mi_step >> 1) < cm->mi_rows &&
|
|
|
|
mi_col + (mi_step >> 1) < cm->mi_cols) {
|
2013-07-02 03:18:50 +02:00
|
|
|
*(get_sb_partitioning(x, bsize)) = bsize;
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col, &none_rate, &none_dist, bsize,
|
|
|
|
get_block_context(x, bsize), INT64_MAX);
|
2013-07-02 03:18:50 +02:00
|
|
|
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-02-26 16:46:56 +01:00
|
|
|
|
|
|
|
if (none_rate < INT_MAX) {
|
|
|
|
none_rate += x->partition_cost[pl][PARTITION_NONE];
|
|
|
|
none_rd = RDCOST(x->rdmult, x->rddiv, none_rate, none_dist);
|
|
|
|
}
|
2013-07-02 03:18:50 +02:00
|
|
|
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
2013-09-11 19:45:44 +02:00
|
|
|
mi_8x8[0]->mbmi.sb_type = bs_type;
|
2013-07-02 03:18:50 +02:00
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
switch (partition) {
|
|
|
|
case PARTITION_NONE:
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col, &last_part_rate,
|
|
|
|
&last_part_dist, bsize,
|
|
|
|
get_block_context(x, bsize), INT64_MAX);
|
2013-05-31 00:13:08 +02:00
|
|
|
break;
|
|
|
|
case PARTITION_HORZ:
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 0;
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col, &last_part_rate,
|
|
|
|
&last_part_dist, subsize,
|
|
|
|
get_block_context(x, subsize), INT64_MAX);
|
2013-07-22 15:39:39 +02:00
|
|
|
if (last_part_rate != INT_MAX &&
|
2014-03-21 22:24:03 +01:00
|
|
|
bsize >= BLOCK_8X8 && mi_row + (mi_step >> 1) < cm->mi_rows) {
|
2013-07-01 17:54:50 +02:00
|
|
|
int rt = 0;
|
|
|
|
int64_t dt = 0;
|
2014-03-14 22:35:47 +01:00
|
|
|
update_state(cpi, get_block_context(x, subsize), mi_row, mi_col,
|
|
|
|
subsize, 0);
|
2013-05-31 00:13:08 +02:00
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 1;
|
2014-03-21 22:24:03 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row + (mi_step >> 1), mi_col, &rt, &dt,
|
2014-01-17 00:59:40 +01:00
|
|
|
subsize, get_block_context(x, subsize), INT64_MAX);
|
2014-02-25 16:29:48 +01:00
|
|
|
if (rt == INT_MAX || dt == INT64_MAX) {
|
2013-07-22 15:39:39 +02:00
|
|
|
last_part_rate = INT_MAX;
|
2014-02-25 16:29:48 +01:00
|
|
|
last_part_dist = INT64_MAX;
|
2013-07-22 15:39:39 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-07-02 03:18:50 +02:00
|
|
|
last_part_rate += rt;
|
|
|
|
last_part_dist += dt;
|
2013-05-31 00:13:08 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PARTITION_VERT:
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 0;
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col, &last_part_rate,
|
|
|
|
&last_part_dist, subsize,
|
|
|
|
get_block_context(x, subsize), INT64_MAX);
|
2013-07-22 15:39:39 +02:00
|
|
|
if (last_part_rate != INT_MAX &&
|
2014-03-21 22:24:03 +01:00
|
|
|
bsize >= BLOCK_8X8 && mi_col + (mi_step >> 1) < cm->mi_cols) {
|
2013-07-01 17:54:50 +02:00
|
|
|
int rt = 0;
|
|
|
|
int64_t dt = 0;
|
2014-03-14 22:35:47 +01:00
|
|
|
update_state(cpi, get_block_context(x, subsize), mi_row, mi_col,
|
|
|
|
subsize, 0);
|
2013-05-31 00:13:08 +02:00
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 1;
|
2014-03-21 22:24:03 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col + (mi_step >> 1), &rt, &dt,
|
2014-01-17 00:59:40 +01:00
|
|
|
subsize, get_block_context(x, subsize), INT64_MAX);
|
2014-02-25 16:29:48 +01:00
|
|
|
if (rt == INT_MAX || dt == INT64_MAX) {
|
2013-07-22 15:39:39 +02:00
|
|
|
last_part_rate = INT_MAX;
|
2014-02-25 16:29:48 +01:00
|
|
|
last_part_dist = INT64_MAX;
|
2013-07-22 15:39:39 +02:00
|
|
|
break;
|
|
|
|
}
|
2013-07-02 03:18:50 +02:00
|
|
|
last_part_rate += rt;
|
|
|
|
last_part_dist += dt;
|
2013-05-31 00:13:08 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PARTITION_SPLIT:
|
2013-07-02 03:18:50 +02:00
|
|
|
// Split partition.
|
|
|
|
last_part_rate = 0;
|
|
|
|
last_part_dist = 0;
|
2013-05-31 00:13:08 +02:00
|
|
|
for (i = 0; i < 4; i++) {
|
2014-03-21 22:24:03 +01:00
|
|
|
int x_idx = (i & 1) * (mi_step >> 1);
|
|
|
|
int y_idx = (i >> 1) * (mi_step >> 1);
|
2013-05-31 00:13:08 +02:00
|
|
|
int jj = i >> 1, ii = i & 0x01;
|
2013-07-02 03:18:50 +02:00
|
|
|
int rt;
|
|
|
|
int64_t dt;
|
2013-05-31 00:13:08 +02:00
|
|
|
|
|
|
|
if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
|
|
|
|
continue;
|
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = i;
|
2013-05-31 00:13:08 +02:00
|
|
|
|
2013-10-25 17:18:04 +02:00
|
|
|
rd_use_partition(cpi, tile, mi_8x8 + jj * bss * mis + ii * bss, tp,
|
2013-09-11 19:45:44 +02:00
|
|
|
mi_row + y_idx, mi_col + x_idx, subsize, &rt, &dt,
|
|
|
|
i != 3);
|
2014-02-25 16:29:48 +01:00
|
|
|
if (rt == INT_MAX || dt == INT64_MAX) {
|
2013-07-20 02:38:55 +02:00
|
|
|
last_part_rate = INT_MAX;
|
2014-02-25 16:29:48 +01:00
|
|
|
last_part_dist = INT64_MAX;
|
2013-07-20 02:38:55 +02:00
|
|
|
break;
|
|
|
|
}
|
2013-07-02 03:18:50 +02:00
|
|
|
last_part_rate += rt;
|
|
|
|
last_part_dist += dt;
|
2013-05-31 00:13:08 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
}
|
2013-10-21 21:02:19 +02:00
|
|
|
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-02-26 16:46:56 +01:00
|
|
|
if (last_part_rate < INT_MAX) {
|
2013-07-20 02:38:55 +02:00
|
|
|
last_part_rate += x->partition_cost[pl][partition];
|
2014-02-26 16:46:56 +01:00
|
|
|
last_part_rd = RDCOST(x->rdmult, x->rddiv, last_part_rate, last_part_dist);
|
|
|
|
}
|
2013-07-20 02:38:55 +02:00
|
|
|
|
2014-03-19 01:00:30 +01:00
|
|
|
if (do_partition_search
|
|
|
|
&& cpi->sf.adjust_partitioning_from_last_frame
|
2014-02-26 02:22:34 +01:00
|
|
|
&& cpi->sf.partition_search_type == SEARCH_PARTITION
|
2013-08-06 00:23:49 +02:00
|
|
|
&& partition != PARTITION_SPLIT && bsize > BLOCK_8X8
|
2014-03-21 22:24:03 +01:00
|
|
|
&& (mi_row + mi_step < cm->mi_rows ||
|
|
|
|
mi_row + (mi_step >> 1) == cm->mi_rows)
|
|
|
|
&& (mi_col + mi_step < cm->mi_cols ||
|
|
|
|
mi_col + (mi_step >> 1) == cm->mi_cols)) {
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE split_subsize = get_subsize(bsize, PARTITION_SPLIT);
|
2014-02-25 02:34:27 +01:00
|
|
|
chosen_rate = 0;
|
|
|
|
chosen_dist = 0;
|
2013-07-02 03:18:50 +02:00
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
|
|
|
|
// Split partition.
|
|
|
|
for (i = 0; i < 4; i++) {
|
2014-03-21 22:24:03 +01:00
|
|
|
int x_idx = (i & 1) * (mi_step >> 1);
|
|
|
|
int y_idx = (i >> 1) * (mi_step >> 1);
|
2013-07-02 03:18:50 +02:00
|
|
|
int rt = 0;
|
|
|
|
int64_t dt = 0;
|
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
|
|
|
|
PARTITION_CONTEXT sl[8], sa[8];
|
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
if ((mi_row + y_idx >= cm->mi_rows) || (mi_col + x_idx >= cm->mi_cols))
|
2013-07-02 03:18:50 +02:00
|
|
|
continue;
|
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, split_subsize) = i;
|
2013-08-28 21:22:37 +02:00
|
|
|
*get_sb_partitioning(x, bsize) = split_subsize;
|
|
|
|
*get_sb_partitioning(x, split_subsize) = split_subsize;
|
2013-07-02 03:18:50 +02:00
|
|
|
|
|
|
|
save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row + y_idx, mi_col + x_idx, &rt, &dt,
|
|
|
|
split_subsize, get_block_context(x, split_subsize),
|
|
|
|
INT64_MAX);
|
2013-07-02 03:18:50 +02:00
|
|
|
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
|
2014-02-25 16:29:48 +01:00
|
|
|
if (rt == INT_MAX || dt == INT64_MAX) {
|
2014-02-25 02:34:27 +01:00
|
|
|
chosen_rate = INT_MAX;
|
2014-02-25 16:29:48 +01:00
|
|
|
chosen_dist = INT64_MAX;
|
2013-07-22 15:39:39 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-02-25 02:34:27 +01:00
|
|
|
chosen_rate += rt;
|
|
|
|
chosen_dist += dt;
|
|
|
|
|
2013-07-22 15:39:39 +02:00
|
|
|
if (i != 3)
|
2013-10-25 17:18:04 +02:00
|
|
|
encode_sb(cpi, tile, tp, mi_row + y_idx, mi_col + x_idx, 0,
|
2013-07-02 03:18:50 +02:00
|
|
|
split_subsize);
|
|
|
|
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row + y_idx, mi_col + x_idx,
|
2013-12-10 23:34:32 +01:00
|
|
|
split_subsize);
|
2014-02-25 02:34:27 +01:00
|
|
|
chosen_rate += x->partition_cost[pl][PARTITION_NONE];
|
2013-07-02 03:18:50 +02:00
|
|
|
}
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-02-25 02:34:27 +01:00
|
|
|
if (chosen_rate < INT_MAX) {
|
|
|
|
chosen_rate += x->partition_cost[pl][PARTITION_SPLIT];
|
2014-02-26 16:46:56 +01:00
|
|
|
chosen_rd = RDCOST(x->rdmult, x->rddiv, chosen_rate, chosen_dist);
|
2013-07-22 15:39:39 +02:00
|
|
|
}
|
2013-07-02 03:18:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// If last_part is better set the partitioning to that...
|
2014-02-26 16:46:56 +01:00
|
|
|
if (last_part_rd < chosen_rd) {
|
2013-09-11 19:45:44 +02:00
|
|
|
mi_8x8[0]->mbmi.sb_type = bsize;
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize >= BLOCK_8X8)
|
2013-07-02 03:18:50 +02:00
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
chosen_rate = last_part_rate;
|
|
|
|
chosen_dist = last_part_dist;
|
2014-02-26 16:46:56 +01:00
|
|
|
chosen_rd = last_part_rd;
|
2013-07-02 03:18:50 +02:00
|
|
|
}
|
|
|
|
// If none was better set the partitioning to that...
|
2014-02-26 16:46:56 +01:00
|
|
|
if (none_rd < chosen_rd) {
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize >= BLOCK_8X8)
|
2013-07-02 03:18:50 +02:00
|
|
|
*(get_sb_partitioning(x, bsize)) = bsize;
|
|
|
|
chosen_rate = none_rate;
|
|
|
|
chosen_dist = none_dist;
|
|
|
|
}
|
2013-05-31 00:13:08 +02:00
|
|
|
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
|
2013-07-02 03:18:50 +02:00
|
|
|
// We must have chosen a partitioning and encoding or we'll fail later on.
|
|
|
|
// No other opportunities for success.
|
2013-08-06 00:23:49 +02:00
|
|
|
if ( bsize == BLOCK_64X64)
|
2014-02-25 16:29:48 +01:00
|
|
|
assert(chosen_rate < INT_MAX && chosen_dist < INT64_MAX);
|
2013-07-02 03:18:50 +02:00
|
|
|
|
2013-11-22 18:21:53 +01:00
|
|
|
if (do_recon) {
|
|
|
|
int output_enabled = (bsize == BLOCK_64X64);
|
|
|
|
|
|
|
|
// Check the projected output rate for this SB against it's target
|
|
|
|
// and and if necessary apply a Q delta using segmentation to get
|
|
|
|
// closer to the target.
|
|
|
|
if ((cpi->oxcf.aq_mode == COMPLEXITY_AQ) && cm->seg.update_map) {
|
2014-03-27 00:05:45 +01:00
|
|
|
vp9_select_in_frame_q_segment(cpi, mi_row, mi_col,
|
|
|
|
output_enabled, chosen_rate);
|
2013-11-22 18:21:53 +01:00
|
|
|
}
|
2014-03-26 19:00:35 +01:00
|
|
|
|
|
|
|
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
|
|
|
|
vp9_cyclic_refresh_set_rate_and_dist_sb(cpi->cyclic_refresh,
|
|
|
|
chosen_rate, chosen_dist);
|
2013-11-22 18:21:53 +01:00
|
|
|
|
|
|
|
encode_sb(cpi, tile, tp, mi_row, mi_col, output_enabled, bsize);
|
|
|
|
}
|
2013-07-20 02:38:55 +02:00
|
|
|
|
2013-07-02 03:18:50 +02:00
|
|
|
*rate = chosen_rate;
|
|
|
|
*dist = chosen_dist;
|
2013-05-31 00:13:08 +02:00
|
|
|
}
|
|
|
|
|
2013-08-27 20:05:08 +02:00
|
|
|
static const BLOCK_SIZE min_partition_size[BLOCK_SIZES] = {
|
2014-01-29 19:03:07 +01:00
|
|
|
BLOCK_4X4, BLOCK_4X4, BLOCK_4X4,
|
|
|
|
BLOCK_4X4, BLOCK_4X4, BLOCK_4X4,
|
|
|
|
BLOCK_8X8, BLOCK_8X8, BLOCK_8X8,
|
|
|
|
BLOCK_16X16, BLOCK_16X16, BLOCK_16X16,
|
|
|
|
BLOCK_16X16
|
2013-08-27 20:05:08 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static const BLOCK_SIZE max_partition_size[BLOCK_SIZES] = {
|
2014-01-29 19:03:07 +01:00
|
|
|
BLOCK_8X8, BLOCK_16X16, BLOCK_16X16,
|
|
|
|
BLOCK_16X16, BLOCK_32X32, BLOCK_32X32,
|
|
|
|
BLOCK_32X32, BLOCK_64X64, BLOCK_64X64,
|
|
|
|
BLOCK_64X64, BLOCK_64X64, BLOCK_64X64,
|
|
|
|
BLOCK_64X64
|
2013-08-27 20:05:08 +02:00
|
|
|
};
|
2013-07-24 15:07:37 +02:00
|
|
|
|
2013-08-16 17:54:12 +02:00
|
|
|
// Look at all the mode_info entries for blocks that are part of this
|
|
|
|
// partition and find the min and max values for sb_type.
|
|
|
|
// At the moment this is designed to work on a 64x64 SB but could be
|
|
|
|
// adjusted to use a size parameter.
|
|
|
|
//
|
|
|
|
// The min and max are assumed to have been initialized prior to calling this
|
|
|
|
// function so repeat calls can accumulate a min and max of more than one sb64.
|
2013-09-11 19:45:44 +02:00
|
|
|
static void get_sb_partition_size_range(VP9_COMP *cpi, MODE_INFO ** mi_8x8,
|
|
|
|
BLOCK_SIZE * min_block_size,
|
|
|
|
BLOCK_SIZE * max_block_size ) {
|
2013-08-16 17:54:12 +02:00
|
|
|
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
|
|
|
|
int sb_width_in_blocks = MI_BLOCK_SIZE;
|
|
|
|
int sb_height_in_blocks = MI_BLOCK_SIZE;
|
|
|
|
int i, j;
|
|
|
|
int index = 0;
|
|
|
|
|
|
|
|
// Check the sb_type for each block that belongs to this region.
|
|
|
|
for (i = 0; i < sb_height_in_blocks; ++i) {
|
|
|
|
for (j = 0; j < sb_width_in_blocks; ++j) {
|
2013-09-11 19:45:44 +02:00
|
|
|
MODE_INFO * mi = mi_8x8[index+j];
|
|
|
|
BLOCK_SIZE sb_type = mi ? mi->mbmi.sb_type : 0;
|
|
|
|
*min_block_size = MIN(*min_block_size, sb_type);
|
|
|
|
*max_block_size = MAX(*max_block_size, sb_type);
|
2013-08-16 17:54:12 +02:00
|
|
|
}
|
2014-04-02 01:18:47 +02:00
|
|
|
index += xd->mi_stride;
|
2013-08-16 17:54:12 +02:00
|
|
|
}
|
|
|
|
}
|
2013-07-24 15:07:37 +02:00
|
|
|
|
2014-02-11 02:19:36 +01:00
|
|
|
// Next square block size less or equal than current block size.
|
|
|
|
static const BLOCK_SIZE next_square_size[BLOCK_SIZES] = {
|
|
|
|
BLOCK_4X4, BLOCK_4X4, BLOCK_4X4,
|
|
|
|
BLOCK_8X8, BLOCK_8X8, BLOCK_8X8,
|
|
|
|
BLOCK_16X16, BLOCK_16X16, BLOCK_16X16,
|
|
|
|
BLOCK_32X32, BLOCK_32X32, BLOCK_32X32,
|
|
|
|
BLOCK_64X64
|
|
|
|
};
|
|
|
|
|
2013-08-01 18:04:15 +02:00
|
|
|
// Look at neighboring blocks and set a min and max partition size based on
|
2013-07-24 15:07:37 +02:00
|
|
|
// what they chose.
|
2013-10-25 17:18:04 +02:00
|
|
|
static void rd_auto_partition_range(VP9_COMP *cpi, const TileInfo *const tile,
|
2014-03-26 18:48:01 +01:00
|
|
|
int mi_row, int mi_col,
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE *min_block_size,
|
|
|
|
BLOCK_SIZE *max_block_size) {
|
2014-03-26 18:48:01 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2013-07-24 15:07:37 +02:00
|
|
|
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
|
2014-04-02 01:18:47 +02:00
|
|
|
MODE_INFO **mi_8x8 = xd->mi;
|
2013-09-11 19:45:44 +02:00
|
|
|
const int left_in_image = xd->left_available && mi_8x8[-1];
|
|
|
|
const int above_in_image = xd->up_available &&
|
2014-04-02 01:18:47 +02:00
|
|
|
mi_8x8[-xd->mi_stride];
|
2014-03-26 18:48:01 +01:00
|
|
|
MODE_INFO **above_sb64_mi_8x8;
|
|
|
|
MODE_INFO **left_sb64_mi_8x8;
|
2013-07-24 15:07:37 +02:00
|
|
|
|
2014-03-26 18:48:01 +01:00
|
|
|
int row8x8_remaining = tile->mi_row_end - mi_row;
|
|
|
|
int col8x8_remaining = tile->mi_col_end - mi_col;
|
2013-09-27 13:59:06 +02:00
|
|
|
int bh, bw;
|
2014-03-20 00:19:16 +01:00
|
|
|
BLOCK_SIZE min_size = BLOCK_4X4;
|
|
|
|
BLOCK_SIZE max_size = BLOCK_64X64;
|
2013-09-27 13:59:06 +02:00
|
|
|
// Trap case where we do not have a prediction.
|
2014-03-20 00:19:16 +01:00
|
|
|
if (left_in_image || above_in_image || cm->frame_type != KEY_FRAME) {
|
2013-09-27 13:59:06 +02:00
|
|
|
// Default "min to max" and "max to min"
|
2014-03-20 00:19:16 +01:00
|
|
|
min_size = BLOCK_64X64;
|
|
|
|
max_size = BLOCK_4X4;
|
2013-09-27 13:59:06 +02:00
|
|
|
|
|
|
|
// NOTE: each call to get_sb_partition_size_range() uses the previous
|
|
|
|
// passed in values for min and max as a starting point.
|
|
|
|
// Find the min and max partition used in previous frame at this location
|
2014-03-20 00:19:16 +01:00
|
|
|
if (cm->frame_type != KEY_FRAME) {
|
2014-03-26 18:48:01 +01:00
|
|
|
MODE_INFO **const prev_mi =
|
2014-04-02 01:18:47 +02:00
|
|
|
&cm->prev_mi_grid_visible[mi_row * xd->mi_stride + mi_col];
|
2014-03-26 18:48:01 +01:00
|
|
|
get_sb_partition_size_range(cpi, prev_mi, &min_size, &max_size);
|
2013-09-27 13:59:06 +02:00
|
|
|
}
|
|
|
|
// Find the min and max partition sizes used in the left SB64
|
|
|
|
if (left_in_image) {
|
|
|
|
left_sb64_mi_8x8 = &mi_8x8[-MI_BLOCK_SIZE];
|
|
|
|
get_sb_partition_size_range(cpi, left_sb64_mi_8x8,
|
2014-03-20 00:19:16 +01:00
|
|
|
&min_size, &max_size);
|
2013-09-27 13:59:06 +02:00
|
|
|
}
|
|
|
|
// Find the min and max partition sizes used in the above SB64.
|
|
|
|
if (above_in_image) {
|
2014-04-02 01:18:47 +02:00
|
|
|
above_sb64_mi_8x8 = &mi_8x8[-xd->mi_stride * MI_BLOCK_SIZE];
|
2013-09-27 13:59:06 +02:00
|
|
|
get_sb_partition_size_range(cpi, above_sb64_mi_8x8,
|
2014-03-20 00:19:16 +01:00
|
|
|
&min_size, &max_size);
|
|
|
|
}
|
|
|
|
// adjust observed min and max
|
|
|
|
if (cpi->sf.auto_min_max_partition_size == RELAXED_NEIGHBORING_MIN_MAX) {
|
|
|
|
min_size = min_partition_size[min_size];
|
|
|
|
max_size = max_partition_size[max_size];
|
2013-09-04 00:46:22 +02:00
|
|
|
}
|
2013-07-24 15:07:37 +02:00
|
|
|
}
|
2013-09-27 13:59:06 +02:00
|
|
|
|
2014-03-20 00:19:16 +01:00
|
|
|
// Check border cases where max and min from neighbors may not be legal.
|
|
|
|
max_size = find_partition_size(max_size,
|
|
|
|
row8x8_remaining, col8x8_remaining,
|
|
|
|
&bh, &bw);
|
|
|
|
min_size = MIN(min_size, max_size);
|
2014-02-11 02:19:36 +01:00
|
|
|
|
|
|
|
// When use_square_partition_only is true, make sure at least one square
|
|
|
|
// partition is allowed by selecting the next smaller square size as
|
|
|
|
// *min_block_size.
|
|
|
|
if (cpi->sf.use_square_partition_only &&
|
2014-03-20 00:19:16 +01:00
|
|
|
next_square_size[max_size] < min_size) {
|
|
|
|
min_size = next_square_size[max_size];
|
2014-02-11 02:19:36 +01:00
|
|
|
}
|
2014-03-20 00:19:16 +01:00
|
|
|
*min_block_size = min_size;
|
|
|
|
*max_block_size = max_size;
|
2013-07-24 15:07:37 +02:00
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
|
2013-09-12 19:06:47 +02:00
|
|
|
static INLINE void store_pred_mv(MACROBLOCK *x, PICK_MODE_CONTEXT *ctx) {
|
|
|
|
vpx_memcpy(ctx->pred_mv, x->pred_mv, sizeof(x->pred_mv));
|
|
|
|
}
|
|
|
|
|
|
|
|
static INLINE void load_pred_mv(MACROBLOCK *x, PICK_MODE_CONTEXT *ctx) {
|
|
|
|
vpx_memcpy(x->pred_mv, ctx->pred_mv, sizeof(x->pred_mv));
|
|
|
|
}
|
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
// TODO(jingning,jimbankoski,rbultje): properly skip partition types that are
|
2013-08-01 18:04:15 +02:00
|
|
|
// unlikely to be selected depending on previous rate-distortion optimization
|
2013-05-08 23:24:43 +02:00
|
|
|
// results, for encoding speed-up.
|
2013-10-25 17:18:04 +02:00
|
|
|
static void rd_pick_partition(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
TOKENEXTRA **tp, int mi_row,
|
2013-08-27 20:05:08 +02:00
|
|
|
int mi_col, BLOCK_SIZE bsize, int *rate,
|
2013-07-17 18:56:46 +02:00
|
|
|
int64_t *dist, int do_recon, int64_t best_rd) {
|
2013-11-12 00:58:57 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-03-21 00:08:54 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2014-03-21 22:24:03 +01:00
|
|
|
const int mi_step = num_8x8_blocks_wide_lookup[bsize] / 2;
|
2013-06-19 23:26:49 +02:00
|
|
|
ENTROPY_CONTEXT l[16 * MAX_MB_PLANE], a[16 * MAX_MB_PLANE];
|
2013-05-08 23:24:43 +02:00
|
|
|
PARTITION_CONTEXT sl[8], sa[8];
|
|
|
|
TOKENEXTRA *tp_orig = *tp;
|
2014-03-11 19:18:43 +01:00
|
|
|
PICK_MODE_CONTEXT *ctx = get_block_context(x, bsize);
|
2013-05-31 00:13:08 +02:00
|
|
|
int i, pl;
|
2013-08-27 20:05:08 +02:00
|
|
|
BLOCK_SIZE subsize;
|
2013-08-01 23:57:46 +02:00
|
|
|
int this_rate, sum_rate = 0, best_rate = INT_MAX;
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
int64_t this_dist, sum_dist = 0, best_dist = INT64_MAX;
|
2013-08-01 23:57:46 +02:00
|
|
|
int64_t sum_rd = 0;
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
int do_split = bsize >= BLOCK_8X8;
|
|
|
|
int do_rect = 1;
|
|
|
|
// Override skipping rectangular partition operations for edge blocks
|
2014-03-21 22:24:03 +01:00
|
|
|
const int force_horz_split = (mi_row + mi_step >= cm->mi_rows);
|
|
|
|
const int force_vert_split = (mi_col + mi_step >= cm->mi_cols);
|
2013-12-02 21:54:21 +01:00
|
|
|
const int xss = x->e_mbd.plane[1].subsampling_x;
|
|
|
|
const int yss = x->e_mbd.plane[1].subsampling_y;
|
Speed feature to skip split partition based on var
Adds a speed feature to disable split partition search based on a
given threshold on the source variance. A tighter threshold derived
from the threshold provided is used to also disable horizontal and
vertical partitions.
Results on derfraw300:
threshold = 16, psnr = -0.057%, speedup ~1% (football)
threshold = 32, psnr = -0.150%, speedup ~4-5% (football)
threshold = 64, psnr = -0.570%, speedup ~10-12% (football)
Results on stdhdraw250:
threshold = 32, psnr = -0.18%, speedup is somewhat more than derf
because of a larger number of smoother blocks at higher resolution.
Based on these results, a threshold of 32 is chosen for speed 1,
and a threshold of 64 is chosen for speeds 2 and above.
Change-Id: If08912fb6c67fd4242d12a0d094783a99f52f6c6
2013-08-03 02:15:38 +02:00
|
|
|
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
int partition_none_allowed = !force_horz_split && !force_vert_split;
|
2013-12-02 21:54:21 +01:00
|
|
|
int partition_horz_allowed = !force_vert_split && yss <= xss &&
|
|
|
|
bsize >= BLOCK_8X8;
|
|
|
|
int partition_vert_allowed = !force_horz_split && xss <= yss &&
|
|
|
|
bsize >= BLOCK_8X8;
|
2013-07-10 23:27:20 +02:00
|
|
|
(void) *tp_orig;
|
|
|
|
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize < BLOCK_8X8) {
|
2013-08-01 18:04:15 +02:00
|
|
|
// When ab_index = 0 all sub-blocks are handled, so for ab_index != 0
|
|
|
|
// there is nothing to be done.
|
2013-11-12 00:58:57 +01:00
|
|
|
if (x->ab_index != 0) {
|
2013-05-11 02:06:37 +02:00
|
|
|
*rate = 0;
|
|
|
|
*dist = 0;
|
|
|
|
return;
|
|
|
|
}
|
2013-08-01 18:04:15 +02:00
|
|
|
}
|
2013-11-06 22:34:23 +01:00
|
|
|
assert(num_8x8_blocks_wide_lookup[bsize] ==
|
|
|
|
num_8x8_blocks_high_lookup[bsize]);
|
2013-05-08 23:24:43 +02:00
|
|
|
|
2013-10-07 20:20:10 +02:00
|
|
|
if (bsize == BLOCK_16X16) {
|
2013-10-25 17:18:04 +02:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, bsize);
|
2013-10-07 20:20:10 +02:00
|
|
|
x->mb_energy = vp9_block_energy(cpi, x, bsize);
|
2014-04-01 01:54:33 +02:00
|
|
|
} else {
|
|
|
|
x->in_active_map = check_active_map(cpi, x, mi_row, mi_col, bsize);
|
2013-10-07 20:20:10 +02:00
|
|
|
}
|
|
|
|
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
// Determine partition types in search according to the speed features.
|
|
|
|
// The threshold set here has to be of square block size.
|
|
|
|
if (cpi->sf.auto_min_max_partition_size) {
|
|
|
|
partition_none_allowed &= (bsize <= cpi->sf.max_partition_size &&
|
|
|
|
bsize >= cpi->sf.min_partition_size);
|
|
|
|
partition_horz_allowed &= ((bsize <= cpi->sf.max_partition_size &&
|
|
|
|
bsize > cpi->sf.min_partition_size) ||
|
|
|
|
force_horz_split);
|
|
|
|
partition_vert_allowed &= ((bsize <= cpi->sf.max_partition_size &&
|
|
|
|
bsize > cpi->sf.min_partition_size) ||
|
|
|
|
force_vert_split);
|
|
|
|
do_split &= bsize > cpi->sf.min_partition_size;
|
|
|
|
}
|
|
|
|
if (cpi->sf.use_square_partition_only) {
|
|
|
|
partition_horz_allowed &= force_horz_split;
|
|
|
|
partition_vert_allowed &= force_vert_split;
|
|
|
|
}
|
|
|
|
|
2013-05-31 00:13:08 +02:00
|
|
|
save_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
2013-05-08 23:24:43 +02:00
|
|
|
|
Speed feature to skip split partition based on var
Adds a speed feature to disable split partition search based on a
given threshold on the source variance. A tighter threshold derived
from the threshold provided is used to also disable horizontal and
vertical partitions.
Results on derfraw300:
threshold = 16, psnr = -0.057%, speedup ~1% (football)
threshold = 32, psnr = -0.150%, speedup ~4-5% (football)
threshold = 64, psnr = -0.570%, speedup ~10-12% (football)
Results on stdhdraw250:
threshold = 32, psnr = -0.18%, speedup is somewhat more than derf
because of a larger number of smoother blocks at higher resolution.
Based on these results, a threshold of 32 is chosen for speed 1,
and a threshold of 64 is chosen for speeds 2 and above.
Change-Id: If08912fb6c67fd4242d12a0d094783a99f52f6c6
2013-08-03 02:15:38 +02:00
|
|
|
if (cpi->sf.disable_split_var_thresh && partition_none_allowed) {
|
|
|
|
unsigned int source_variancey;
|
|
|
|
vp9_setup_src_planes(x, cpi->Source, mi_row, mi_col);
|
|
|
|
source_variancey = get_sby_perpixel_variance(cpi, x, bsize);
|
Fixes on feature disabling split based on variance
Adds a couple of minor fixes, which may be absorbed in Jingning's
patch. Thanks to Guillaume for pointing these out.
Also adjusts the thresholds for speed 1 and 2 to 16 and 32
respectively, to keep quality drops small.
Results:
--------
derfraw300: threshold = 16, psnr -0.082%, speedup 2-3%
threshold = 32, psnr -0.218%, speedup 5-6%
stdhdraw250: threshold = 16, psnr -0.031%, speedup 2-3%
threshold = 32, psnr -0.273%, speedup 5-6%
Change-Id: I4b11ae8296cca6c2a9f644be7e40de7c423b8330
2013-08-22 01:19:35 +02:00
|
|
|
if (source_variancey < cpi->sf.disable_split_var_thresh) {
|
Speed feature to skip split partition based on var
Adds a speed feature to disable split partition search based on a
given threshold on the source variance. A tighter threshold derived
from the threshold provided is used to also disable horizontal and
vertical partitions.
Results on derfraw300:
threshold = 16, psnr = -0.057%, speedup ~1% (football)
threshold = 32, psnr = -0.150%, speedup ~4-5% (football)
threshold = 64, psnr = -0.570%, speedup ~10-12% (football)
Results on stdhdraw250:
threshold = 32, psnr = -0.18%, speedup is somewhat more than derf
because of a larger number of smoother blocks at higher resolution.
Based on these results, a threshold of 32 is chosen for speed 1,
and a threshold of 64 is chosen for speeds 2 and above.
Change-Id: If08912fb6c67fd4242d12a0d094783a99f52f6c6
2013-08-03 02:15:38 +02:00
|
|
|
do_split = 0;
|
Fixes on feature disabling split based on variance
Adds a couple of minor fixes, which may be absorbed in Jingning's
patch. Thanks to Guillaume for pointing these out.
Also adjusts the thresholds for speed 1 and 2 to 16 and 32
respectively, to keep quality drops small.
Results:
--------
derfraw300: threshold = 16, psnr -0.082%, speedup 2-3%
threshold = 32, psnr -0.218%, speedup 5-6%
stdhdraw250: threshold = 16, psnr -0.031%, speedup 2-3%
threshold = 32, psnr -0.273%, speedup 5-6%
Change-Id: I4b11ae8296cca6c2a9f644be7e40de7c423b8330
2013-08-22 01:19:35 +02:00
|
|
|
if (source_variancey < cpi->sf.disable_split_var_thresh / 2)
|
|
|
|
do_rect = 0;
|
|
|
|
}
|
Speed feature to skip split partition based on var
Adds a speed feature to disable split partition search based on a
given threshold on the source variance. A tighter threshold derived
from the threshold provided is used to also disable horizontal and
vertical partitions.
Results on derfraw300:
threshold = 16, psnr = -0.057%, speedup ~1% (football)
threshold = 32, psnr = -0.150%, speedup ~4-5% (football)
threshold = 64, psnr = -0.570%, speedup ~10-12% (football)
Results on stdhdraw250:
threshold = 32, psnr = -0.18%, speedup is somewhat more than derf
because of a larger number of smoother blocks at higher resolution.
Based on these results, a threshold of 32 is chosen for speed 1,
and a threshold of 64 is chosen for speeds 2 and above.
Change-Id: If08912fb6c67fd4242d12a0d094783a99f52f6c6
2013-08-03 02:15:38 +02:00
|
|
|
}
|
2013-05-01 01:13:20 +02:00
|
|
|
|
2014-03-12 00:39:42 +01:00
|
|
|
if (!x->in_active_map && (partition_horz_allowed || partition_vert_allowed))
|
|
|
|
do_split = 0;
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
// PARTITION_NONE
|
|
|
|
if (partition_none_allowed) {
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col, &this_rate, &this_dist, bsize,
|
2014-03-11 19:18:43 +01:00
|
|
|
ctx, best_rd);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
if (this_rate != INT_MAX) {
|
|
|
|
if (bsize >= BLOCK_8X8) {
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
this_rate += x->partition_cost[pl][PARTITION_NONE];
|
|
|
|
}
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_dist);
|
|
|
|
if (sum_rd < best_rd) {
|
2013-12-05 22:41:18 +01:00
|
|
|
int64_t stop_thresh = 4096;
|
|
|
|
int64_t stop_thresh_rd;
|
2013-09-07 01:59:55 +02:00
|
|
|
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
best_rate = this_rate;
|
|
|
|
best_dist = this_dist;
|
|
|
|
best_rd = sum_rd;
|
|
|
|
if (bsize >= BLOCK_8X8)
|
|
|
|
*(get_sb_partitioning(x, bsize)) = bsize;
|
2013-09-07 01:59:55 +02:00
|
|
|
|
|
|
|
// Adjust threshold according to partition size.
|
|
|
|
stop_thresh >>= 8 - (b_width_log2_lookup[bsize] +
|
|
|
|
b_height_log2_lookup[bsize]);
|
|
|
|
|
2013-12-05 22:41:18 +01:00
|
|
|
stop_thresh_rd = RDCOST(x->rdmult, x->rddiv, 0, stop_thresh);
|
2013-09-07 01:59:55 +02:00
|
|
|
// If obtained distortion is very small, choose current partition
|
|
|
|
// and stop splitting.
|
2013-12-05 22:41:18 +01:00
|
|
|
if (!x->e_mbd.lossless && best_rd < stop_thresh_rd) {
|
2013-09-07 01:59:55 +02:00
|
|
|
do_split = 0;
|
|
|
|
do_rect = 0;
|
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
}
|
|
|
|
}
|
2014-03-08 03:15:33 +01:00
|
|
|
if (!x->in_active_map) {
|
|
|
|
do_split = 0;
|
|
|
|
do_rect = 0;
|
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
|
2013-09-12 19:06:47 +02:00
|
|
|
// store estimated motion vector
|
|
|
|
if (cpi->sf.adaptive_motion_search)
|
2014-03-11 19:18:43 +01:00
|
|
|
store_pred_mv(x, ctx);
|
2013-09-12 19:06:47 +02:00
|
|
|
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
// PARTITION_SPLIT
|
|
|
|
sum_rd = 0;
|
|
|
|
// TODO(jingning): use the motion vectors given by the above search as
|
|
|
|
// the starting point of motion search in the following partition type check.
|
|
|
|
if (do_split) {
|
|
|
|
subsize = get_subsize(bsize, PARTITION_SPLIT);
|
|
|
|
for (i = 0; i < 4 && sum_rd < best_rd; ++i) {
|
2014-03-21 22:24:03 +01:00
|
|
|
const int x_idx = (i & 1) * mi_step;
|
|
|
|
const int y_idx = (i >> 1) * mi_step;
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
|
2013-08-28 21:22:37 +02:00
|
|
|
if (mi_row + y_idx >= cm->mi_rows || mi_col + x_idx >= cm->mi_cols)
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
continue;
|
2013-08-13 21:34:32 +02:00
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = i;
|
2013-09-12 19:06:47 +02:00
|
|
|
if (cpi->sf.adaptive_motion_search)
|
2014-03-11 19:18:43 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-01-24 21:26:57 +01:00
|
|
|
if (cpi->sf.adaptive_pred_interp_filter && bsize == BLOCK_8X8 &&
|
2013-12-13 02:31:04 +01:00
|
|
|
partition_none_allowed)
|
2014-01-24 21:26:57 +01:00
|
|
|
get_block_context(x, subsize)->pred_interp_filter =
|
2014-03-11 19:18:43 +01:00
|
|
|
ctx->mic.mbmi.interp_filter;
|
2013-10-25 17:18:04 +02:00
|
|
|
rd_pick_partition(cpi, tile, tp, mi_row + y_idx, mi_col + x_idx, subsize,
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
&this_rate, &this_dist, i != 3, best_rd - sum_rd);
|
|
|
|
|
|
|
|
if (this_rate == INT_MAX) {
|
|
|
|
sum_rd = INT64_MAX;
|
|
|
|
} else {
|
|
|
|
sum_rate += this_rate;
|
|
|
|
sum_dist += this_dist;
|
2013-08-01 23:57:46 +02:00
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
2013-07-17 18:56:46 +02:00
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
if (sum_rd < best_rd && i == 4) {
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
sum_rate += x->partition_cost[pl][PARTITION_SPLIT];
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
if (sum_rd < best_rd) {
|
|
|
|
best_rate = sum_rate;
|
|
|
|
best_dist = sum_dist;
|
|
|
|
best_rd = sum_rd;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
}
|
2013-09-30 20:58:22 +02:00
|
|
|
} else {
|
|
|
|
// skip rectangular partition test when larger block size
|
|
|
|
// gives better rd cost
|
|
|
|
if (cpi->sf.less_rectangular_check)
|
|
|
|
do_rect &= !partition_none_allowed;
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
}
|
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
2013-05-08 23:24:43 +02:00
|
|
|
}
|
2013-07-03 23:43:23 +02:00
|
|
|
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
// PARTITION_HORZ
|
|
|
|
if (partition_horz_allowed && do_rect) {
|
|
|
|
subsize = get_subsize(bsize, PARTITION_HORZ);
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 0;
|
2013-09-12 19:06:47 +02:00
|
|
|
if (cpi->sf.adaptive_motion_search)
|
2014-03-11 19:18:43 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-01-24 21:26:57 +01:00
|
|
|
if (cpi->sf.adaptive_pred_interp_filter && bsize == BLOCK_8X8 &&
|
2013-12-13 02:31:04 +01:00
|
|
|
partition_none_allowed)
|
2014-01-24 21:26:57 +01:00
|
|
|
get_block_context(x, subsize)->pred_interp_filter =
|
2014-03-11 19:18:43 +01:00
|
|
|
ctx->mic.mbmi.interp_filter;
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col, &sum_rate, &sum_dist, subsize,
|
|
|
|
get_block_context(x, subsize), best_rd);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
|
2014-03-21 22:24:03 +01:00
|
|
|
if (sum_rd < best_rd && mi_row + mi_step < cm->mi_rows) {
|
2014-03-14 22:35:47 +01:00
|
|
|
update_state(cpi, get_block_context(x, subsize), mi_row, mi_col,
|
|
|
|
subsize, 0);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 1;
|
2013-09-12 19:06:47 +02:00
|
|
|
if (cpi->sf.adaptive_motion_search)
|
2014-03-11 19:18:43 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-01-24 21:26:57 +01:00
|
|
|
if (cpi->sf.adaptive_pred_interp_filter && bsize == BLOCK_8X8 &&
|
2013-12-13 02:31:04 +01:00
|
|
|
partition_none_allowed)
|
2014-01-24 21:26:57 +01:00
|
|
|
get_block_context(x, subsize)->pred_interp_filter =
|
2014-03-11 19:18:43 +01:00
|
|
|
ctx->mic.mbmi.interp_filter;
|
2014-03-21 22:24:03 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row + mi_step, mi_col, &this_rate,
|
2014-01-17 00:59:40 +01:00
|
|
|
&this_dist, subsize, get_block_context(x, subsize),
|
|
|
|
best_rd - sum_rd);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
if (this_rate == INT_MAX) {
|
|
|
|
sum_rd = INT64_MAX;
|
|
|
|
} else {
|
|
|
|
sum_rate += this_rate;
|
|
|
|
sum_dist += this_dist;
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
2013-06-20 18:24:04 +02:00
|
|
|
}
|
2013-04-17 18:25:06 +02:00
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
if (sum_rd < best_rd) {
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
sum_rate += x->partition_cost[pl][PARTITION_HORZ];
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
if (sum_rd < best_rd) {
|
|
|
|
best_rd = sum_rd;
|
|
|
|
best_rate = sum_rate;
|
|
|
|
best_dist = sum_dist;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
2013-07-17 18:56:46 +02:00
|
|
|
}
|
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
|
|
|
}
|
2013-07-17 18:56:46 +02:00
|
|
|
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
// PARTITION_VERT
|
|
|
|
if (partition_vert_allowed && do_rect) {
|
|
|
|
subsize = get_subsize(bsize, PARTITION_VERT);
|
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 0;
|
2013-09-12 19:06:47 +02:00
|
|
|
if (cpi->sf.adaptive_motion_search)
|
2014-03-11 19:18:43 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-01-24 21:26:57 +01:00
|
|
|
if (cpi->sf.adaptive_pred_interp_filter && bsize == BLOCK_8X8 &&
|
2013-12-13 02:31:04 +01:00
|
|
|
partition_none_allowed)
|
2014-01-24 21:26:57 +01:00
|
|
|
get_block_context(x, subsize)->pred_interp_filter =
|
2014-03-11 19:18:43 +01:00
|
|
|
ctx->mic.mbmi.interp_filter;
|
2014-01-17 00:59:40 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col, &sum_rate, &sum_dist, subsize,
|
|
|
|
get_block_context(x, subsize), best_rd);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
2014-03-21 22:24:03 +01:00
|
|
|
if (sum_rd < best_rd && mi_col + mi_step < cm->mi_cols) {
|
2014-03-14 22:35:47 +01:00
|
|
|
update_state(cpi, get_block_context(x, subsize), mi_row, mi_col,
|
|
|
|
subsize, 0);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
encode_superblock(cpi, tp, 0, mi_row, mi_col, subsize);
|
|
|
|
|
2013-11-12 00:58:57 +01:00
|
|
|
*get_sb_index(x, subsize) = 1;
|
2013-09-12 19:06:47 +02:00
|
|
|
if (cpi->sf.adaptive_motion_search)
|
2014-03-11 19:18:43 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-01-24 21:26:57 +01:00
|
|
|
if (cpi->sf.adaptive_pred_interp_filter && bsize == BLOCK_8X8 &&
|
2013-12-13 02:31:04 +01:00
|
|
|
partition_none_allowed)
|
2014-01-24 21:26:57 +01:00
|
|
|
get_block_context(x, subsize)->pred_interp_filter =
|
2014-03-11 19:18:43 +01:00
|
|
|
ctx->mic.mbmi.interp_filter;
|
2014-03-21 22:24:03 +01:00
|
|
|
rd_pick_sb_modes(cpi, tile, mi_row, mi_col + mi_step, &this_rate,
|
2014-01-17 00:59:40 +01:00
|
|
|
&this_dist, subsize, get_block_context(x, subsize),
|
|
|
|
best_rd - sum_rd);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
if (this_rate == INT_MAX) {
|
|
|
|
sum_rd = INT64_MAX;
|
|
|
|
} else {
|
|
|
|
sum_rate += this_rate;
|
|
|
|
sum_dist += this_dist;
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
2013-06-27 21:07:07 +02:00
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
}
|
|
|
|
if (sum_rd < best_rd) {
|
2014-03-21 20:12:55 +01:00
|
|
|
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
sum_rate += x->partition_cost[pl][PARTITION_VERT];
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
if (sum_rd < best_rd) {
|
|
|
|
best_rate = sum_rate;
|
|
|
|
best_dist = sum_dist;
|
|
|
|
best_rd = sum_rd;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
2013-06-27 21:07:07 +02:00
|
|
|
}
|
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
restore_context(cpi, mi_row, mi_col, a, l, sa, sl, bsize);
|
2013-05-08 23:24:43 +02:00
|
|
|
}
|
Refactor rd_pick_partition for parameter control
This commit changes the partition search order of superblocks from
{SPLIT, NONE, HORZ, VERT} to {NONE, SPLIT, HORZ, VERT} for
consistency with that of sub8x8 partition search. It enable the use
of early termination in partition search for all block sizes.
For ped_area_1080p 50 frames coded at 4000 kbps, it makes the runtime
goes down from 844305ms -> 818003ms (3% speed-up) at speed 0.
This will further move towards making the in-search partition types
configurable, hence unifying various speed-up approaches.
Some speed 1 and 2 features are turned off during the refactoring
process, including:
disable_split_var_thresh
using_small_partition_info
Stricter constraints are applied to use_square_partition_only for
right/bottom boundary blocks. Will bring back/refine these features
subsequently. At this point, it makes derf set at speed 1 about
0.45% higher in compression performance, and 9% down in run-time.
Change-Id: I3db9f9d1d1a0d6cbe2e50e49bd9eda1cf705f37c
2013-08-20 23:34:17 +02:00
|
|
|
|
2014-02-12 20:54:04 +01:00
|
|
|
// TODO(jbb): This code added so that we avoid static analysis
|
|
|
|
// warning related to the fact that best_rd isn't used after this
|
|
|
|
// point. This code should be refactored so that the duplicate
|
|
|
|
// checks occur in some sub function and thus are used...
|
|
|
|
(void) best_rd;
|
2013-08-01 23:57:46 +02:00
|
|
|
*rate = best_rate;
|
|
|
|
*dist = best_dist;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-11-22 18:21:53 +01:00
|
|
|
if (best_rate < INT_MAX && best_dist < INT64_MAX && do_recon) {
|
|
|
|
int output_enabled = (bsize == BLOCK_64X64);
|
|
|
|
|
|
|
|
// Check the projected output rate for this SB against it's target
|
|
|
|
// and and if necessary apply a Q delta using segmentation to get
|
|
|
|
// closer to the target.
|
|
|
|
if ((cpi->oxcf.aq_mode == COMPLEXITY_AQ) && cm->seg.update_map) {
|
2014-03-27 00:05:45 +01:00
|
|
|
vp9_select_in_frame_q_segment(cpi, mi_row, mi_col, output_enabled,
|
|
|
|
best_rate);
|
2013-11-22 18:21:53 +01:00
|
|
|
}
|
2014-03-26 19:00:35 +01:00
|
|
|
|
|
|
|
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
|
|
|
|
vp9_cyclic_refresh_set_rate_and_dist_sb(cpi->cyclic_refresh,
|
|
|
|
best_rate, best_dist);
|
2014-03-14 22:35:47 +01:00
|
|
|
|
2013-11-22 18:21:53 +01:00
|
|
|
encode_sb(cpi, tile, tp, mi_row, mi_col, output_enabled, bsize);
|
|
|
|
}
|
2013-08-06 00:23:49 +02:00
|
|
|
if (bsize == BLOCK_64X64) {
|
2013-05-08 23:24:43 +02:00
|
|
|
assert(tp_orig < *tp);
|
2013-08-01 23:57:46 +02:00
|
|
|
assert(best_rate < INT_MAX);
|
2014-02-25 16:29:48 +01:00
|
|
|
assert(best_dist < INT64_MAX);
|
2013-05-11 02:06:37 +02:00
|
|
|
} else {
|
2013-05-08 23:24:43 +02:00
|
|
|
assert(tp_orig == *tp);
|
2013-05-11 02:06:37 +02:00
|
|
|
}
|
2013-05-08 23:24:43 +02:00
|
|
|
}
|
2013-04-17 18:25:06 +02:00
|
|
|
|
2014-02-25 00:21:13 +01:00
|
|
|
static void encode_rd_sb_row(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
int mi_row, TOKENEXTRA **tp) {
|
2014-01-08 23:51:00 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2014-03-21 00:08:54 +01:00
|
|
|
MACROBLOCKD *const xd = &cpi->mb.e_mbd;
|
2013-05-08 23:24:43 +02:00
|
|
|
int mi_col;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-05-08 23:24:43 +02:00
|
|
|
// Initialize the left context for the new SB row
|
2014-03-25 02:32:46 +01:00
|
|
|
vpx_memset(&xd->left_context, 0, sizeof(xd->left_context));
|
2014-03-21 00:08:54 +01:00
|
|
|
vpx_memset(xd->left_seg_context, 0, sizeof(xd->left_seg_context));
|
2013-05-08 23:24:43 +02:00
|
|
|
|
|
|
|
// Code each SB in the row
|
2013-10-25 17:18:04 +02:00
|
|
|
for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
|
2013-07-03 19:54:50 +02:00
|
|
|
mi_col += MI_BLOCK_SIZE) {
|
2013-06-21 21:54:52 +02:00
|
|
|
int dummy_rate;
|
|
|
|
int64_t dummy_dist;
|
2013-07-01 17:27:12 +02:00
|
|
|
|
2013-12-13 02:31:04 +01:00
|
|
|
BLOCK_SIZE i;
|
|
|
|
MACROBLOCK *x = &cpi->mb;
|
2014-02-24 23:05:06 +01:00
|
|
|
|
|
|
|
if (cpi->sf.adaptive_pred_interp_filter) {
|
|
|
|
for (i = BLOCK_4X4; i < BLOCK_8X8; ++i) {
|
|
|
|
const int num_4x4_w = num_4x4_blocks_wide_lookup[i];
|
|
|
|
const int num_4x4_h = num_4x4_blocks_high_lookup[i];
|
|
|
|
const int num_4x4_blk = MAX(4, num_4x4_w * num_4x4_h);
|
|
|
|
for (x->sb_index = 0; x->sb_index < 4; ++x->sb_index)
|
|
|
|
for (x->mb_index = 0; x->mb_index < 4; ++x->mb_index)
|
|
|
|
for (x->b_index = 0; x->b_index < 16 / num_4x4_blk; ++x->b_index)
|
|
|
|
get_block_context(x, i)->pred_interp_filter = SWITCHABLE;
|
|
|
|
}
|
2013-12-13 02:31:04 +01:00
|
|
|
}
|
|
|
|
|
2013-09-27 02:43:55 +02:00
|
|
|
vp9_zero(cpi->mb.pred_mv);
|
2013-09-16 21:44:50 +02:00
|
|
|
|
2014-02-25 00:21:13 +01:00
|
|
|
if ((cpi->sf.partition_search_type == SEARCH_PARTITION &&
|
|
|
|
cpi->sf.use_lastframe_partitioning) ||
|
|
|
|
cpi->sf.partition_search_type == FIXED_PARTITION ||
|
|
|
|
cpi->sf.partition_search_type == VAR_BASED_FIXED_PARTITION) {
|
2014-04-02 01:18:47 +02:00
|
|
|
const int idx_str = cm->mi_stride * mi_row + mi_col;
|
2013-09-11 19:45:44 +02:00
|
|
|
MODE_INFO **mi_8x8 = cm->mi_grid_visible + idx_str;
|
|
|
|
MODE_INFO **prev_mi_8x8 = cm->prev_mi_grid_visible + idx_str;
|
2013-07-31 18:33:58 +02:00
|
|
|
cpi->mb.source_variance = UINT_MAX;
|
2014-02-25 00:21:13 +01:00
|
|
|
if (cpi->sf.partition_search_type == FIXED_PARTITION) {
|
2013-10-25 17:18:04 +02:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, BLOCK_64X64);
|
2014-03-04 20:15:35 +01:00
|
|
|
set_fixed_partitioning(cpi, tile, mi_8x8, mi_row, mi_col,
|
|
|
|
cpi->sf.always_this_block_size);
|
2013-10-25 17:18:04 +02:00
|
|
|
rd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col, BLOCK_64X64,
|
2013-07-08 23:38:40 +02:00
|
|
|
&dummy_rate, &dummy_dist, 1);
|
2014-03-04 20:15:35 +01:00
|
|
|
} else if (cpi->sf.partition_search_type == VAR_BASED_FIXED_PARTITION) {
|
2014-02-25 00:21:13 +01:00
|
|
|
BLOCK_SIZE bsize;
|
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, BLOCK_64X64);
|
2014-02-26 02:22:34 +01:00
|
|
|
bsize = get_rd_var_based_fixed_partition(cpi, mi_row, mi_col);
|
2014-03-04 20:15:35 +01:00
|
|
|
set_fixed_partitioning(cpi, tile, mi_8x8, mi_row, mi_col, bsize);
|
|
|
|
rd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col, BLOCK_64X64,
|
|
|
|
&dummy_rate, &dummy_dist, 1);
|
|
|
|
} else if (cpi->sf.partition_search_type == VAR_BASED_PARTITION) {
|
|
|
|
choose_partitioning(cpi, tile, mi_row, mi_col);
|
2014-02-25 00:21:13 +01:00
|
|
|
rd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col, BLOCK_64X64,
|
|
|
|
&dummy_rate, &dummy_dist, 1);
|
2013-06-20 16:17:01 +02:00
|
|
|
} else {
|
2014-01-08 23:51:00 +01:00
|
|
|
if ((cm->current_video_frame
|
2013-07-02 03:18:50 +02:00
|
|
|
% cpi->sf.last_partitioning_redo_frequency) == 0
|
|
|
|
|| cm->prev_mi == 0
|
2014-01-08 23:51:00 +01:00
|
|
|
|| cm->show_frame == 0
|
|
|
|
|| cm->frame_type == KEY_FRAME
|
2013-12-13 18:32:05 +01:00
|
|
|
|| cpi->rc.is_src_frame_alt_ref
|
2013-10-01 17:57:18 +02:00
|
|
|
|| ((cpi->sf.use_lastframe_partitioning ==
|
|
|
|
LAST_FRAME_PARTITION_LOW_MOTION) &&
|
2014-01-08 23:51:00 +01:00
|
|
|
sb_has_motion(cm, prev_mi_8x8))) {
|
2013-07-24 15:07:37 +02:00
|
|
|
// If required set upper and lower partition size limits
|
|
|
|
if (cpi->sf.auto_min_max_partition_size) {
|
2013-10-25 17:18:04 +02:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, BLOCK_64X64);
|
|
|
|
rd_auto_partition_range(cpi, tile, mi_row, mi_col,
|
2013-07-24 15:07:37 +02:00
|
|
|
&cpi->sf.min_partition_size,
|
|
|
|
&cpi->sf.max_partition_size);
|
|
|
|
}
|
2013-10-25 17:18:04 +02:00
|
|
|
rd_pick_partition(cpi, tile, tp, mi_row, mi_col, BLOCK_64X64,
|
2013-07-17 18:56:46 +02:00
|
|
|
&dummy_rate, &dummy_dist, 1, INT64_MAX);
|
2013-06-20 16:17:01 +02:00
|
|
|
} else {
|
2014-01-08 23:51:00 +01:00
|
|
|
copy_partitioning(cm, mi_8x8, prev_mi_8x8);
|
2013-10-25 17:18:04 +02:00
|
|
|
rd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col, BLOCK_64X64,
|
2013-07-08 23:38:40 +02:00
|
|
|
&dummy_rate, &dummy_dist, 1);
|
2013-06-20 16:17:01 +02:00
|
|
|
}
|
2013-06-20 18:32:19 +02:00
|
|
|
}
|
2013-06-20 16:17:01 +02:00
|
|
|
} else {
|
2013-07-24 15:07:37 +02:00
|
|
|
// If required set upper and lower partition size limits
|
|
|
|
if (cpi->sf.auto_min_max_partition_size) {
|
2013-10-25 17:18:04 +02:00
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, BLOCK_64X64);
|
|
|
|
rd_auto_partition_range(cpi, tile, mi_row, mi_col,
|
2013-09-04 00:46:22 +02:00
|
|
|
&cpi->sf.min_partition_size,
|
2013-07-24 15:07:37 +02:00
|
|
|
&cpi->sf.max_partition_size);
|
|
|
|
}
|
2013-10-25 17:18:04 +02:00
|
|
|
rd_pick_partition(cpi, tile, tp, mi_row, mi_col, BLOCK_64X64,
|
2013-07-17 18:56:46 +02:00
|
|
|
&dummy_rate, &dummy_dist, 1, INT64_MAX);
|
2013-05-31 00:13:08 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-09-30 17:45:16 +02:00
|
|
|
}
|
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
static void init_encode_frame_mb_context(VP9_COMP *cpi) {
|
2013-07-08 23:54:04 +02:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
const int aligned_mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
x->act_zbin_adj = 0;
|
|
|
|
cpi->seg0_idx = 0;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Copy data over into macro block data structures.
|
2013-04-24 01:22:47 +02:00
|
|
|
vp9_setup_src_planes(x, cpi->Source, 0, 0);
|
2013-04-20 04:16:14 +02:00
|
|
|
|
|
|
|
// TODO(jkoleszar): are these initializations required?
|
2014-03-03 23:58:43 +01:00
|
|
|
vp9_setup_pre_planes(xd, 0, get_ref_frame_buffer(cpi, LAST_FRAME), 0, 0,
|
|
|
|
NULL);
|
|
|
|
vp9_setup_dst_planes(xd, get_frame_new_buffer(cm), 0, 0);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2014-02-01 02:35:53 +01:00
|
|
|
vp9_setup_block_planes(&x->e_mbd, cm->subsampling_x, cm->subsampling_y);
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[0]->mbmi.mode = DC_PRED;
|
|
|
|
xd->mi[0]->mbmi.uv_mode = DC_PRED;
|
2011-06-08 17:00:59 +02:00
|
|
|
|
2013-12-19 03:52:58 +01:00
|
|
|
vp9_zero(cm->counts.y_mode);
|
|
|
|
vp9_zero(cm->counts.uv_mode);
|
2013-10-16 01:09:28 +02:00
|
|
|
vp9_zero(cm->counts.inter_mode);
|
2013-11-22 23:26:39 +01:00
|
|
|
vp9_zero(cm->counts.partition);
|
2013-12-19 03:52:58 +01:00
|
|
|
vp9_zero(cm->counts.intra_inter);
|
2013-12-17 05:12:47 +01:00
|
|
|
vp9_zero(cm->counts.comp_inter);
|
|
|
|
vp9_zero(cm->counts.single_ref);
|
|
|
|
vp9_zero(cm->counts.comp_ref);
|
2013-07-24 02:02:08 +02:00
|
|
|
vp9_zero(cm->counts.tx);
|
2014-01-29 23:48:42 +01:00
|
|
|
vp9_zero(cm->counts.skip);
|
2013-04-16 09:18:02 +02:00
|
|
|
|
2013-04-29 19:37:25 +02:00
|
|
|
// Note: this memset assumes above_context[0], [1] and [2]
|
|
|
|
// are allocated as part of the same buffer.
|
2014-03-25 02:32:46 +01:00
|
|
|
vpx_memset(xd->above_context[0], 0,
|
|
|
|
sizeof(*xd->above_context[0]) *
|
2013-10-24 18:10:59 +02:00
|
|
|
2 * aligned_mi_cols * MAX_MB_PLANE);
|
2014-03-21 00:08:54 +01:00
|
|
|
vpx_memset(xd->above_seg_context, 0,
|
|
|
|
sizeof(*xd->above_seg_context) * aligned_mi_cols);
|
2011-06-08 17:00:59 +02:00
|
|
|
}
|
2013-02-20 16:27:35 +01:00
|
|
|
|
2013-02-13 23:22:15 +01:00
|
|
|
static void switch_lossless_mode(VP9_COMP *cpi, int lossless) {
|
|
|
|
if (lossless) {
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
// printf("Switching to lossless\n");
|
2013-10-23 23:28:39 +02:00
|
|
|
cpi->mb.fwd_txm4x4 = vp9_fwht4x4;
|
2013-10-08 20:27:56 +02:00
|
|
|
cpi->mb.e_mbd.itxm_add = vp9_iwht4x4_add;
|
2013-06-19 23:26:49 +02:00
|
|
|
cpi->mb.optimize = 0;
|
2013-08-09 23:41:51 +02:00
|
|
|
cpi->common.lf.filter_level = 0;
|
2013-06-19 23:26:49 +02:00
|
|
|
cpi->zbin_mode_boost_enabled = 0;
|
2013-07-19 20:37:13 +02:00
|
|
|
cpi->common.tx_mode = ONLY_4X4;
|
2013-02-13 23:22:15 +01:00
|
|
|
} else {
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
// printf("Not lossless\n");
|
2013-10-23 23:28:39 +02:00
|
|
|
cpi->mb.fwd_txm4x4 = vp9_fdct4x4;
|
2013-10-08 20:27:56 +02:00
|
|
|
cpi->mb.e_mbd.itxm_add = vp9_idct4x4_add;
|
2013-02-13 23:22:15 +01:00
|
|
|
}
|
|
|
|
}
|
2013-02-20 16:27:35 +01:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
static int check_dual_ref_flags(VP9_COMP *cpi) {
|
2013-08-14 20:20:33 +02:00
|
|
|
const int ref_flags = cpi->ref_frame_flags;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-08-14 20:20:33 +02:00
|
|
|
if (vp9_segfeature_active(&cpi->common.seg, 1, SEG_LVL_REF_FRAME)) {
|
2012-07-14 00:21:29 +02:00
|
|
|
return 0;
|
|
|
|
} else {
|
2013-06-19 23:26:49 +02:00
|
|
|
return (!!(ref_flags & VP9_GOLD_FLAG) + !!(ref_flags & VP9_LAST_FLAG)
|
|
|
|
+ !!(ref_flags & VP9_ALT_FLAG)) >= 2;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2012-03-22 18:03:14 +01:00
|
|
|
}
|
|
|
|
|
2013-09-11 19:45:44 +02:00
|
|
|
static int get_skip_flag(MODE_INFO **mi_8x8, int mis, int ymbs, int xmbs) {
|
2013-01-06 03:20:25 +01:00
|
|
|
int x, y;
|
|
|
|
|
|
|
|
for (y = 0; y < ymbs; y++) {
|
|
|
|
for (x = 0; x < xmbs; x++) {
|
2014-02-13 02:44:12 +01:00
|
|
|
if (!mi_8x8[y * mis + x]->mbmi.skip)
|
2013-01-06 03:20:25 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-01-08 23:51:00 +01:00
|
|
|
static void reset_skip_txfm_size(VP9_COMMON *cm, TX_SIZE txfm_max) {
|
2013-04-26 20:57:17 +02:00
|
|
|
int mi_row, mi_col;
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2014-03-24 16:51:45 +01:00
|
|
|
MODE_INFO **mi_ptr = cm->mi_grid_visible;
|
2012-10-12 03:19:20 +02:00
|
|
|
|
2014-03-24 16:51:45 +01:00
|
|
|
for (mi_row = 0; mi_row < cm->mi_rows; ++mi_row, mi_ptr += mis) {
|
|
|
|
for (mi_col = 0; mi_col < cm->mi_cols; ++mi_col) {
|
|
|
|
if (mi_ptr[mi_col]->mbmi.tx_size > txfm_max)
|
|
|
|
mi_ptr[mi_col]->mbmi.tx_size = txfm_max;
|
2013-09-11 19:45:44 +02:00
|
|
|
}
|
2012-10-12 03:19:20 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-10 18:38:25 +01:00
|
|
|
static MV_REFERENCE_FRAME get_frame_type(const VP9_COMP *cpi) {
|
2013-10-03 18:07:24 +02:00
|
|
|
if (frame_is_intra_only(&cpi->common))
|
2014-01-31 20:08:27 +01:00
|
|
|
return INTRA_FRAME;
|
2013-12-13 18:32:05 +01:00
|
|
|
else if (cpi->rc.is_src_frame_alt_ref && cpi->refresh_golden_frame)
|
2014-01-31 20:08:27 +01:00
|
|
|
return ALTREF_FRAME;
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
else if (cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)
|
2014-01-31 20:08:27 +01:00
|
|
|
return LAST_FRAME;
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
else
|
2014-01-31 20:08:27 +01:00
|
|
|
return GOLDEN_FRAME;
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
}
|
|
|
|
|
2014-03-10 18:38:25 +01:00
|
|
|
static TX_MODE select_tx_mode(const VP9_COMP *cpi) {
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
if (cpi->oxcf.lossless) {
|
2014-03-10 18:38:25 +01:00
|
|
|
return ONLY_4X4;
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
} else if (cpi->common.current_video_frame == 0) {
|
2014-03-10 18:38:25 +01:00
|
|
|
return TX_MODE_SELECT;
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
} else {
|
2013-07-03 23:47:54 +02:00
|
|
|
if (cpi->sf.tx_size_search_method == USE_LARGESTALL) {
|
2014-03-10 18:38:25 +01:00
|
|
|
return ALLOW_32X32;
|
2013-07-03 23:47:54 +02:00
|
|
|
} else if (cpi->sf.tx_size_search_method == USE_FULL_RD) {
|
2014-03-11 02:47:41 +01:00
|
|
|
const MV_REFERENCE_FRAME frame_type = get_frame_type(cpi);
|
2014-03-10 18:38:25 +01:00
|
|
|
return cpi->rd_tx_select_threshes[frame_type][ALLOW_32X32] >
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][TX_MODE_SELECT] ?
|
|
|
|
ALLOW_32X32 : TX_MODE_SELECT;
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
} else {
|
|
|
|
unsigned int total = 0;
|
|
|
|
int i;
|
2013-07-27 02:15:37 +02:00
|
|
|
for (i = 0; i < TX_SIZES; ++i)
|
2013-09-25 02:24:35 +02:00
|
|
|
total += cpi->tx_stepdown_count[i];
|
2014-03-10 18:38:25 +01:00
|
|
|
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
if (total) {
|
2014-03-10 18:38:25 +01:00
|
|
|
const double fraction = (double)cpi->tx_stepdown_count[0] / total;
|
|
|
|
return fraction > 0.90 ? ALLOW_32X32 : TX_MODE_SELECT;
|
|
|
|
} else {
|
|
|
|
return cpi->common.tx_mode;
|
|
|
|
}
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-02-12 21:48:15 +01:00
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
// Start RTC Exploration
|
|
|
|
typedef enum {
|
|
|
|
BOTH_ZERO = 0,
|
|
|
|
ZERO_PLUS_PREDICTED = 1,
|
|
|
|
BOTH_PREDICTED = 2,
|
|
|
|
NEW_PLUS_NON_INTRA = 3,
|
|
|
|
BOTH_NEW = 4,
|
|
|
|
INTRA_PLUS_NON_INTRA = 5,
|
|
|
|
BOTH_INTRA = 6,
|
|
|
|
INVALID_CASE = 9
|
|
|
|
} motion_vector_context;
|
|
|
|
|
|
|
|
static void set_mode_info(MB_MODE_INFO *mbmi, BLOCK_SIZE bsize,
|
2014-03-01 01:23:56 +01:00
|
|
|
MB_PREDICTION_MODE mode) {
|
2014-01-29 17:39:39 +01:00
|
|
|
mbmi->mode = mode;
|
2014-03-04 20:36:21 +01:00
|
|
|
mbmi->uv_mode = mode;
|
2014-01-29 17:39:39 +01:00
|
|
|
mbmi->mv[0].as_int = 0;
|
|
|
|
mbmi->mv[1].as_int = 0;
|
2014-03-04 20:36:21 +01:00
|
|
|
mbmi->ref_frame[0] = INTRA_FRAME;
|
|
|
|
mbmi->ref_frame[1] = NONE;
|
2014-01-29 17:39:39 +01:00
|
|
|
mbmi->tx_size = max_txsize_lookup[bsize];
|
2014-02-13 02:44:12 +01:00
|
|
|
mbmi->skip = 0;
|
2014-01-29 17:39:39 +01:00
|
|
|
mbmi->sb_type = bsize;
|
|
|
|
mbmi->segment_id = 0;
|
|
|
|
}
|
2014-02-12 21:48:15 +01:00
|
|
|
|
2014-03-04 20:15:35 +01:00
|
|
|
static void nonrd_pick_sb_modes(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
int mi_row, int mi_col,
|
|
|
|
int *rate, int64_t *dist,
|
|
|
|
BLOCK_SIZE bsize) {
|
2014-01-29 17:39:39 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-03-04 20:15:35 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
set_offsets(cpi, tile, mi_row, mi_col, bsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[0]->mbmi.sb_type = bsize;
|
2014-03-19 19:25:40 +01:00
|
|
|
|
2014-03-04 20:15:35 +01:00
|
|
|
if (!frame_is_intra_only(cm)) {
|
|
|
|
vp9_pick_inter_mode(cpi, x, tile, mi_row, mi_col,
|
|
|
|
rate, dist, bsize);
|
|
|
|
} else {
|
|
|
|
MB_PREDICTION_MODE intramode = DC_PRED;
|
2014-04-02 01:18:47 +02:00
|
|
|
set_mode_info(&xd->mi[0]->mbmi, bsize, intramode);
|
2014-03-04 20:15:35 +01:00
|
|
|
}
|
2014-03-21 19:05:39 +01:00
|
|
|
duplicate_mode_info_in_sb(cm, xd, mi_row, mi_col, bsize);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fill_mode_info_sb(VP9_COMMON *cm, MACROBLOCK *x,
|
2014-03-25 19:05:50 +01:00
|
|
|
int mi_row, int mi_col,
|
|
|
|
BLOCK_SIZE bsize, BLOCK_SIZE subsize) {
|
2014-03-21 19:05:39 +01:00
|
|
|
MACROBLOCKD *xd = &x->e_mbd;
|
|
|
|
int bsl = b_width_log2(bsize), hbs = (1 << bsl) / 4;
|
|
|
|
PARTITION_TYPE partition = partition_lookup[bsl][subsize];
|
|
|
|
|
|
|
|
assert(bsize >= BLOCK_8X8);
|
|
|
|
|
2014-03-25 19:05:50 +01:00
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
|
|
|
|
2014-03-21 19:05:39 +01:00
|
|
|
switch (partition) {
|
|
|
|
case PARTITION_NONE:
|
|
|
|
set_modeinfo_offsets(cm, xd, mi_row, mi_col);
|
2014-04-02 01:18:47 +02:00
|
|
|
*(xd->mi[0]) = get_block_context(x, subsize)->mic;
|
2014-03-21 19:05:39 +01:00
|
|
|
duplicate_mode_info_in_sb(cm, xd, mi_row, mi_col, bsize);
|
|
|
|
break;
|
|
|
|
case PARTITION_VERT:
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
set_modeinfo_offsets(cm, xd, mi_row, mi_col);
|
2014-04-02 01:18:47 +02:00
|
|
|
*(xd->mi[0]) = get_block_context(x, subsize)->mic;
|
2014-03-21 19:05:39 +01:00
|
|
|
duplicate_mode_info_in_sb(cm, xd, mi_row, mi_col, bsize);
|
|
|
|
|
|
|
|
if (mi_col + hbs < cm->mi_cols) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
set_modeinfo_offsets(cm, xd, mi_row, mi_col + hbs);
|
2014-04-02 01:18:47 +02:00
|
|
|
*(xd->mi[0]) = get_block_context(x, subsize)->mic;
|
2014-03-21 19:05:39 +01:00
|
|
|
duplicate_mode_info_in_sb(cm, xd, mi_row, mi_col + hbs, bsize);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PARTITION_HORZ:
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
set_modeinfo_offsets(cm, xd, mi_row, mi_col);
|
2014-04-02 01:18:47 +02:00
|
|
|
*(xd->mi[0]) = get_block_context(x, subsize)->mic;
|
2014-03-21 19:05:39 +01:00
|
|
|
duplicate_mode_info_in_sb(cm, xd, mi_row, mi_col, bsize);
|
|
|
|
if (mi_row + hbs < cm->mi_rows) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
set_modeinfo_offsets(cm, xd, mi_row + hbs, mi_col);
|
2014-04-02 01:18:47 +02:00
|
|
|
*(xd->mi[0]) = get_block_context(x, subsize)->mic;
|
2014-03-21 19:05:39 +01:00
|
|
|
duplicate_mode_info_in_sb(cm, xd, mi_row + hbs, mi_col, bsize);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PARTITION_SPLIT:
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
fill_mode_info_sb(cm, x, mi_row, mi_col, subsize,
|
|
|
|
*(get_sb_partitioning(x, subsize)));
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
fill_mode_info_sb(cm, x, mi_row, mi_col + hbs, subsize,
|
|
|
|
*(get_sb_partitioning(x, subsize)));
|
|
|
|
*get_sb_index(x, subsize) = 2;
|
|
|
|
fill_mode_info_sb(cm, x, mi_row + hbs, mi_col, subsize,
|
|
|
|
*(get_sb_partitioning(x, subsize)));
|
|
|
|
*get_sb_index(x, subsize) = 3;
|
|
|
|
fill_mode_info_sb(cm, x, mi_row + hbs, mi_col + hbs, subsize,
|
|
|
|
*(get_sb_partitioning(x, subsize)));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nonrd_pick_partition(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
TOKENEXTRA **tp, int mi_row,
|
|
|
|
int mi_col, BLOCK_SIZE bsize, int *rate,
|
|
|
|
int64_t *dist, int do_recon, int64_t best_rd) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
|
|
|
const int ms = num_8x8_blocks_wide_lookup[bsize] / 2;
|
|
|
|
TOKENEXTRA *tp_orig = *tp;
|
|
|
|
PICK_MODE_CONTEXT *ctx = get_block_context(x, bsize);
|
|
|
|
int i;
|
|
|
|
BLOCK_SIZE subsize;
|
|
|
|
int this_rate, sum_rate = 0, best_rate = INT_MAX;
|
|
|
|
int64_t this_dist, sum_dist = 0, best_dist = INT64_MAX;
|
|
|
|
int64_t sum_rd = 0;
|
|
|
|
int do_split = bsize >= BLOCK_8X8;
|
|
|
|
int do_rect = 1;
|
|
|
|
// Override skipping rectangular partition operations for edge blocks
|
|
|
|
const int force_horz_split = (mi_row + ms >= cm->mi_rows);
|
|
|
|
const int force_vert_split = (mi_col + ms >= cm->mi_cols);
|
|
|
|
const int xss = x->e_mbd.plane[1].subsampling_x;
|
|
|
|
const int yss = x->e_mbd.plane[1].subsampling_y;
|
|
|
|
|
|
|
|
int partition_none_allowed = !force_horz_split && !force_vert_split;
|
|
|
|
int partition_horz_allowed = !force_vert_split && yss <= xss &&
|
|
|
|
bsize >= BLOCK_8X8;
|
|
|
|
int partition_vert_allowed = !force_horz_split && xss <= yss &&
|
|
|
|
bsize >= BLOCK_8X8;
|
|
|
|
(void) *tp_orig;
|
|
|
|
|
|
|
|
if (bsize < BLOCK_8X8) {
|
|
|
|
// When ab_index = 0 all sub-blocks are handled, so for ab_index != 0
|
|
|
|
// there is nothing to be done.
|
|
|
|
if (x->ab_index != 0) {
|
|
|
|
*rate = 0;
|
|
|
|
*dist = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(num_8x8_blocks_wide_lookup[bsize] ==
|
|
|
|
num_8x8_blocks_high_lookup[bsize]);
|
|
|
|
|
2014-04-01 01:54:33 +02:00
|
|
|
x->in_active_map = check_active_map(cpi, x, mi_row, mi_col, bsize);
|
|
|
|
|
2014-03-21 19:05:39 +01:00
|
|
|
// Determine partition types in search according to the speed features.
|
|
|
|
// The threshold set here has to be of square block size.
|
|
|
|
if (cpi->sf.auto_min_max_partition_size) {
|
|
|
|
partition_none_allowed &= (bsize <= cpi->sf.max_partition_size &&
|
|
|
|
bsize >= cpi->sf.min_partition_size);
|
|
|
|
partition_horz_allowed &= ((bsize <= cpi->sf.max_partition_size &&
|
|
|
|
bsize > cpi->sf.min_partition_size) ||
|
|
|
|
force_horz_split);
|
|
|
|
partition_vert_allowed &= ((bsize <= cpi->sf.max_partition_size &&
|
|
|
|
bsize > cpi->sf.min_partition_size) ||
|
|
|
|
force_vert_split);
|
|
|
|
do_split &= bsize > cpi->sf.min_partition_size;
|
|
|
|
}
|
|
|
|
if (cpi->sf.use_square_partition_only) {
|
|
|
|
partition_horz_allowed &= force_horz_split;
|
|
|
|
partition_vert_allowed &= force_vert_split;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!x->in_active_map && (partition_horz_allowed || partition_vert_allowed))
|
|
|
|
do_split = 0;
|
|
|
|
|
|
|
|
// PARTITION_NONE
|
|
|
|
if (partition_none_allowed) {
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col,
|
|
|
|
&this_rate, &this_dist, bsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
ctx->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
if (this_rate != INT_MAX) {
|
2014-03-25 17:54:32 +01:00
|
|
|
int pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-03-21 19:05:39 +01:00
|
|
|
this_rate += x->partition_cost[pl][PARTITION_NONE];
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_dist);
|
|
|
|
if (sum_rd < best_rd) {
|
|
|
|
int64_t stop_thresh = 4096;
|
|
|
|
int64_t stop_thresh_rd;
|
|
|
|
|
|
|
|
best_rate = this_rate;
|
|
|
|
best_dist = this_dist;
|
|
|
|
best_rd = sum_rd;
|
|
|
|
if (bsize >= BLOCK_8X8)
|
|
|
|
*(get_sb_partitioning(x, bsize)) = bsize;
|
|
|
|
|
|
|
|
// Adjust threshold according to partition size.
|
|
|
|
stop_thresh >>= 8 - (b_width_log2_lookup[bsize] +
|
|
|
|
b_height_log2_lookup[bsize]);
|
|
|
|
|
|
|
|
stop_thresh_rd = RDCOST(x->rdmult, x->rddiv, 0, stop_thresh);
|
|
|
|
// If obtained distortion is very small, choose current partition
|
|
|
|
// and stop splitting.
|
|
|
|
if (!x->e_mbd.lossless && best_rd < stop_thresh_rd) {
|
|
|
|
do_split = 0;
|
|
|
|
do_rect = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!x->in_active_map) {
|
|
|
|
do_split = 0;
|
|
|
|
do_rect = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// store estimated motion vector
|
2014-03-25 06:31:03 +01:00
|
|
|
store_pred_mv(x, ctx);
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
// PARTITION_SPLIT
|
|
|
|
sum_rd = 0;
|
|
|
|
if (do_split) {
|
2014-03-25 17:54:32 +01:00
|
|
|
int pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-03-21 19:05:39 +01:00
|
|
|
sum_rate += x->partition_cost[pl][PARTITION_SPLIT];
|
|
|
|
subsize = get_subsize(bsize, PARTITION_SPLIT);
|
2014-03-25 19:05:50 +01:00
|
|
|
for (i = 0; i < 4 && sum_rd < best_rd; ++i) {
|
2014-03-21 19:05:39 +01:00
|
|
|
const int x_idx = (i & 1) * ms;
|
|
|
|
const int y_idx = (i >> 1) * ms;
|
|
|
|
|
|
|
|
if (mi_row + y_idx >= cm->mi_rows || mi_col + x_idx >= cm->mi_cols)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
*get_sb_index(x, subsize) = i;
|
2014-03-25 06:31:03 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
nonrd_pick_partition(cpi, tile, tp, mi_row + y_idx, mi_col + x_idx,
|
2014-03-25 19:05:50 +01:00
|
|
|
subsize, &this_rate, &this_dist, 0,
|
|
|
|
best_rd - sum_rd);
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
if (this_rate == INT_MAX) {
|
|
|
|
sum_rd = INT64_MAX;
|
|
|
|
} else {
|
|
|
|
sum_rate += this_rate;
|
|
|
|
sum_dist += this_dist;
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sum_rd < best_rd) {
|
|
|
|
best_rate = sum_rate;
|
|
|
|
best_dist = sum_dist;
|
|
|
|
best_rd = sum_rd;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
} else {
|
|
|
|
// skip rectangular partition test when larger block size
|
|
|
|
// gives better rd cost
|
|
|
|
if (cpi->sf.less_rectangular_check)
|
|
|
|
do_rect &= !partition_none_allowed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// PARTITION_HORZ
|
|
|
|
if (partition_horz_allowed && do_rect) {
|
|
|
|
subsize = get_subsize(bsize, PARTITION_HORZ);
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
if (cpi->sf.adaptive_motion_search)
|
|
|
|
load_pred_mv(x, ctx);
|
|
|
|
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col,
|
|
|
|
&this_rate, &this_dist, subsize);
|
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
|
|
|
|
if (sum_rd < best_rd && mi_row + ms < cm->mi_rows) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
|
2014-03-25 06:31:03 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row + ms, mi_col,
|
|
|
|
&this_rate, &this_dist, subsize);
|
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
if (this_rate == INT_MAX) {
|
|
|
|
sum_rd = INT64_MAX;
|
|
|
|
} else {
|
2014-03-25 17:54:32 +01:00
|
|
|
int pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-03-21 19:05:39 +01:00
|
|
|
this_rate += x->partition_cost[pl][PARTITION_HORZ];
|
|
|
|
sum_rate += this_rate;
|
|
|
|
sum_dist += this_dist;
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sum_rd < best_rd) {
|
|
|
|
best_rd = sum_rd;
|
|
|
|
best_rate = sum_rate;
|
|
|
|
best_dist = sum_dist;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// PARTITION_VERT
|
|
|
|
if (partition_vert_allowed && do_rect) {
|
|
|
|
subsize = get_subsize(bsize, PARTITION_VERT);
|
|
|
|
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
if (cpi->sf.adaptive_motion_search)
|
|
|
|
load_pred_mv(x, ctx);
|
|
|
|
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col,
|
|
|
|
&this_rate, &this_dist, subsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-21 19:05:39 +01:00
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
if (sum_rd < best_rd && mi_col + ms < cm->mi_cols) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
|
2014-03-25 06:31:03 +01:00
|
|
|
load_pred_mv(x, ctx);
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col + ms,
|
|
|
|
&this_rate, &this_dist, subsize);
|
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-21 19:05:39 +01:00
|
|
|
|
|
|
|
if (this_rate == INT_MAX) {
|
|
|
|
sum_rd = INT64_MAX;
|
|
|
|
} else {
|
2014-03-25 17:54:32 +01:00
|
|
|
int pl = partition_plane_context(xd, mi_row, mi_col, bsize);
|
2014-03-21 19:05:39 +01:00
|
|
|
this_rate += x->partition_cost[pl][PARTITION_VERT];
|
|
|
|
sum_rate += this_rate;
|
|
|
|
sum_dist += this_dist;
|
|
|
|
sum_rd = RDCOST(x->rdmult, x->rddiv, sum_rate, sum_dist);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sum_rd < best_rd) {
|
|
|
|
best_rate = sum_rate;
|
|
|
|
best_dist = sum_dist;
|
|
|
|
best_rd = sum_rd;
|
|
|
|
*(get_sb_partitioning(x, bsize)) = subsize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*rate = best_rate;
|
|
|
|
*dist = best_dist;
|
|
|
|
|
2014-03-25 19:05:50 +01:00
|
|
|
if (best_rate == INT_MAX)
|
|
|
|
return;
|
|
|
|
|
2014-03-21 19:05:39 +01:00
|
|
|
// update mode info array
|
|
|
|
fill_mode_info_sb(cm, x, mi_row, mi_col, bsize,
|
|
|
|
*(get_sb_partitioning(x, bsize)));
|
|
|
|
|
|
|
|
if (best_rate < INT_MAX && best_dist < INT64_MAX && do_recon) {
|
|
|
|
int output_enabled = (bsize == BLOCK_64X64);
|
|
|
|
|
|
|
|
// Check the projected output rate for this SB against it's target
|
|
|
|
// and and if necessary apply a Q delta using segmentation to get
|
|
|
|
// closer to the target.
|
|
|
|
if ((cpi->oxcf.aq_mode == COMPLEXITY_AQ) && cm->seg.update_map) {
|
2014-03-27 00:05:45 +01:00
|
|
|
vp9_select_in_frame_q_segment(cpi, mi_row, mi_col, output_enabled,
|
|
|
|
best_rate);
|
2014-03-21 19:05:39 +01:00
|
|
|
}
|
2014-03-26 19:00:35 +01:00
|
|
|
|
|
|
|
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
|
|
|
|
vp9_cyclic_refresh_set_rate_and_dist_sb(cpi->cyclic_refresh,
|
|
|
|
best_rate, best_dist);
|
2014-03-21 19:05:39 +01:00
|
|
|
|
2014-03-26 21:00:06 +01:00
|
|
|
encode_sb_rt(cpi, tile, tp, mi_row, mi_col, output_enabled, bsize);
|
2014-03-21 19:05:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bsize == BLOCK_64X64) {
|
|
|
|
assert(tp_orig < *tp);
|
|
|
|
assert(best_rate < INT_MAX);
|
|
|
|
assert(best_dist < INT64_MAX);
|
|
|
|
} else {
|
|
|
|
assert(tp_orig == *tp);
|
|
|
|
}
|
2014-03-04 20:15:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nonrd_use_partition(VP9_COMP *cpi,
|
|
|
|
const TileInfo *const tile,
|
|
|
|
MODE_INFO **mi_8x8,
|
|
|
|
TOKENEXTRA **tp,
|
|
|
|
int mi_row, int mi_col,
|
2014-03-15 01:10:32 +01:00
|
|
|
BLOCK_SIZE bsize, int output_enabled,
|
2014-03-04 20:15:35 +01:00
|
|
|
int *totrate, int64_t *totdist) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
2014-03-26 21:00:06 +01:00
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2014-03-04 20:15:35 +01:00
|
|
|
const int bsl = b_width_log2(bsize), hbs = (1 << bsl) / 4;
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2014-03-04 20:15:35 +01:00
|
|
|
PARTITION_TYPE partition;
|
|
|
|
BLOCK_SIZE subsize;
|
2014-03-21 03:35:06 +01:00
|
|
|
int rate = INT_MAX;
|
|
|
|
int64_t dist = INT64_MAX;
|
2014-03-04 20:15:35 +01:00
|
|
|
|
|
|
|
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (bsize >= BLOCK_8X8) {
|
|
|
|
subsize = mi_8x8[0]->mbmi.sb_type;
|
|
|
|
} else {
|
|
|
|
subsize = BLOCK_4X4;
|
|
|
|
}
|
|
|
|
|
|
|
|
partition = partition_lookup[bsl][subsize];
|
|
|
|
|
|
|
|
switch (partition) {
|
|
|
|
case PARTITION_NONE:
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, totrate, totdist, subsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-04 20:15:35 +01:00
|
|
|
break;
|
|
|
|
case PARTITION_VERT:
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, totrate, totdist, subsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-04 20:15:35 +01:00
|
|
|
if (mi_col + hbs < cm->mi_cols) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col + hbs,
|
|
|
|
&rate, &dist, subsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-04 20:15:35 +01:00
|
|
|
if (rate != INT_MAX && dist != INT64_MAX &&
|
|
|
|
*totrate != INT_MAX && *totdist != INT64_MAX) {
|
|
|
|
*totrate += rate;
|
|
|
|
*totdist += dist;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PARTITION_HORZ:
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, totrate, totdist, subsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = xd->mi[0]->mbmi;
|
2014-03-04 20:15:35 +01:00
|
|
|
if (mi_row + hbs < cm->mi_rows) {
|
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
nonrd_pick_sb_modes(cpi, tile, mi_row + hbs, mi_col,
|
|
|
|
&rate, &dist, subsize);
|
2014-04-02 01:18:47 +02:00
|
|
|
get_block_context(x, subsize)->mic.mbmi = mi_8x8[0]->mbmi;
|
2014-03-04 20:15:35 +01:00
|
|
|
if (rate != INT_MAX && dist != INT64_MAX &&
|
|
|
|
*totrate != INT_MAX && *totdist != INT64_MAX) {
|
|
|
|
*totrate += rate;
|
|
|
|
*totdist += dist;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PARTITION_SPLIT:
|
|
|
|
subsize = get_subsize(bsize, PARTITION_SPLIT);
|
|
|
|
*get_sb_index(x, subsize) = 0;
|
|
|
|
nonrd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col,
|
2014-03-15 01:10:32 +01:00
|
|
|
subsize, output_enabled, totrate, totdist);
|
2014-03-04 20:15:35 +01:00
|
|
|
*get_sb_index(x, subsize) = 1;
|
|
|
|
nonrd_use_partition(cpi, tile, mi_8x8 + hbs, tp,
|
2014-03-15 01:10:32 +01:00
|
|
|
mi_row, mi_col + hbs, subsize, output_enabled,
|
2014-03-04 20:15:35 +01:00
|
|
|
&rate, &dist);
|
|
|
|
if (rate != INT_MAX && dist != INT64_MAX &&
|
|
|
|
*totrate != INT_MAX && *totdist != INT64_MAX) {
|
|
|
|
*totrate += rate;
|
|
|
|
*totdist += dist;
|
|
|
|
}
|
|
|
|
*get_sb_index(x, subsize) = 2;
|
|
|
|
nonrd_use_partition(cpi, tile, mi_8x8 + hbs * mis, tp,
|
2014-03-15 01:10:32 +01:00
|
|
|
mi_row + hbs, mi_col, subsize, output_enabled,
|
2014-03-04 20:15:35 +01:00
|
|
|
&rate, &dist);
|
|
|
|
if (rate != INT_MAX && dist != INT64_MAX &&
|
|
|
|
*totrate != INT_MAX && *totdist != INT64_MAX) {
|
|
|
|
*totrate += rate;
|
|
|
|
*totdist += dist;
|
|
|
|
}
|
|
|
|
*get_sb_index(x, subsize) = 3;
|
|
|
|
nonrd_use_partition(cpi, tile, mi_8x8 + hbs * mis + hbs, tp,
|
2014-03-15 01:10:32 +01:00
|
|
|
mi_row + hbs, mi_col + hbs, subsize, output_enabled,
|
2014-03-04 20:15:35 +01:00
|
|
|
&rate, &dist);
|
|
|
|
if (rate != INT_MAX && dist != INT64_MAX &&
|
|
|
|
*totrate != INT_MAX && *totdist != INT64_MAX) {
|
|
|
|
*totrate += rate;
|
|
|
|
*totdist += dist;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert("Invalid partition type.");
|
|
|
|
}
|
|
|
|
|
2014-03-14 22:35:47 +01:00
|
|
|
if (bsize == BLOCK_64X64 && output_enabled) {
|
2014-03-26 19:00:35 +01:00
|
|
|
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
|
|
|
|
vp9_cyclic_refresh_set_rate_and_dist_sb(cpi->cyclic_refresh,
|
|
|
|
*totrate, *totdist);
|
2014-03-04 20:15:35 +01:00
|
|
|
encode_sb_rt(cpi, tile, tp, mi_row, mi_col, 1, bsize);
|
2014-03-14 22:35:47 +01:00
|
|
|
}
|
2014-03-04 20:15:35 +01:00
|
|
|
}
|
|
|
|
|
2014-02-25 00:21:13 +01:00
|
|
|
static void encode_nonrd_sb_row(VP9_COMP *cpi, const TileInfo *const tile,
|
|
|
|
int mi_row, TOKENEXTRA **tp) {
|
2014-03-13 23:31:23 +01:00
|
|
|
VP9_COMMON *cm = &cpi->common;
|
2014-03-21 00:08:54 +01:00
|
|
|
MACROBLOCKD *xd = &cpi->mb.e_mbd;
|
2014-01-29 17:39:39 +01:00
|
|
|
int mi_col;
|
|
|
|
|
|
|
|
// Initialize the left context for the new SB row
|
2014-03-25 02:32:46 +01:00
|
|
|
vpx_memset(&xd->left_context, 0, sizeof(xd->left_context));
|
2014-03-21 00:08:54 +01:00
|
|
|
vpx_memset(xd->left_seg_context, 0, sizeof(xd->left_seg_context));
|
2014-01-29 17:39:39 +01:00
|
|
|
|
|
|
|
// Code each SB in the row
|
|
|
|
for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
|
|
|
|
mi_col += MI_BLOCK_SIZE) {
|
2014-03-21 03:35:06 +01:00
|
|
|
int dummy_rate = 0;
|
|
|
|
int64_t dummy_dist = 0;
|
2014-04-02 01:18:47 +02:00
|
|
|
const int idx_str = cm->mi_stride * mi_row + mi_col;
|
2014-03-13 23:51:36 +01:00
|
|
|
MODE_INFO **mi_8x8 = cm->mi_grid_visible + idx_str;
|
2014-03-19 19:25:40 +01:00
|
|
|
MODE_INFO **prev_mi_8x8 = cm->prev_mi_grid_visible + idx_str;
|
|
|
|
|
2014-03-13 23:51:36 +01:00
|
|
|
BLOCK_SIZE bsize = cpi->sf.partition_search_type == FIXED_PARTITION ?
|
|
|
|
cpi->sf.always_this_block_size :
|
|
|
|
get_nonrd_var_based_fixed_partition(cpi, mi_row, mi_col);
|
2014-01-29 17:39:39 +01:00
|
|
|
|
|
|
|
cpi->mb.source_variance = UINT_MAX;
|
2014-03-26 21:00:06 +01:00
|
|
|
vp9_zero(cpi->mb.pred_mv);
|
2014-02-13 18:39:03 +01:00
|
|
|
|
2014-03-13 23:51:36 +01:00
|
|
|
// Set the partition type of the 64X64 block
|
2014-03-20 22:06:54 +01:00
|
|
|
switch (cpi->sf.partition_search_type) {
|
|
|
|
case VAR_BASED_PARTITION:
|
|
|
|
choose_partitioning(cpi, tile, mi_row, mi_col);
|
2014-03-19 19:25:40 +01:00
|
|
|
nonrd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col, BLOCK_64X64,
|
2014-03-20 22:06:54 +01:00
|
|
|
1, &dummy_rate, &dummy_dist);
|
|
|
|
break;
|
|
|
|
case VAR_BASED_FIXED_PARTITION:
|
|
|
|
case FIXED_PARTITION:
|
|
|
|
set_fixed_partitioning(cpi, tile, mi_8x8, mi_row, mi_col, bsize);
|
2014-03-19 19:25:40 +01:00
|
|
|
nonrd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col, BLOCK_64X64,
|
2014-03-20 22:06:54 +01:00
|
|
|
1, &dummy_rate, &dummy_dist);
|
|
|
|
break;
|
|
|
|
case REFERENCE_PARTITION:
|
2014-03-26 21:00:06 +01:00
|
|
|
if (cpi->sf.partition_check || sb_has_motion(cm, prev_mi_8x8)) {
|
2014-03-21 19:05:39 +01:00
|
|
|
nonrd_pick_partition(cpi, tile, tp, mi_row, mi_col, BLOCK_64X64,
|
|
|
|
&dummy_rate, &dummy_dist, 1, INT64_MAX);
|
2014-03-19 19:25:40 +01:00
|
|
|
} else {
|
2014-03-26 21:00:06 +01:00
|
|
|
copy_partitioning(cm, mi_8x8, prev_mi_8x8);
|
2014-03-21 19:05:39 +01:00
|
|
|
nonrd_use_partition(cpi, tile, mi_8x8, tp, mi_row, mi_col,
|
|
|
|
BLOCK_64X64, 1, &dummy_rate, &dummy_dist);
|
2014-03-19 19:25:40 +01:00
|
|
|
}
|
2014-03-20 22:06:54 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0);
|
2014-03-19 19:25:40 +01:00
|
|
|
}
|
2014-01-29 17:39:39 +01:00
|
|
|
}
|
|
|
|
}
|
2014-02-10 20:25:23 +01:00
|
|
|
// end RTC play code
|
2014-01-29 17:39:39 +01:00
|
|
|
|
2014-02-10 20:25:23 +01:00
|
|
|
static void encode_frame_internal(VP9_COMP *cpi) {
|
2014-01-29 17:39:39 +01:00
|
|
|
int mi_row;
|
2014-02-10 20:25:23 +01:00
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2014-01-29 17:39:39 +01:00
|
|
|
|
|
|
|
// fprintf(stderr, "encode_frame_internal frame %d (%d) type %d\n",
|
|
|
|
// cpi->common.current_video_frame, cpi->common.show_frame,
|
|
|
|
// cm->frame_type);
|
|
|
|
|
|
|
|
vp9_zero(cm->counts.switchable_interp);
|
|
|
|
vp9_zero(cpi->tx_stepdown_count);
|
|
|
|
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi = cm->mi_grid_visible;
|
2014-01-29 17:39:39 +01:00
|
|
|
// required for vp9_frame_init_quantizer
|
2014-04-02 01:18:47 +02:00
|
|
|
xd->mi[0] = cm->mi;
|
2014-01-29 17:39:39 +01:00
|
|
|
|
2014-02-10 20:25:23 +01:00
|
|
|
vp9_zero(cm->counts.mv);
|
2014-01-29 17:39:39 +01:00
|
|
|
vp9_zero(cpi->coef_counts);
|
|
|
|
vp9_zero(cm->counts.eob_branch);
|
|
|
|
|
2014-03-04 20:30:27 +01:00
|
|
|
// Set frame level transform size use case
|
2014-03-10 18:38:25 +01:00
|
|
|
cm->tx_mode = select_tx_mode(cpi);
|
2014-03-04 20:30:27 +01:00
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
cpi->mb.e_mbd.lossless = cm->base_qindex == 0 && cm->y_dc_delta_q == 0
|
|
|
|
&& cm->uv_dc_delta_q == 0 && cm->uv_ac_delta_q == 0;
|
|
|
|
switch_lossless_mode(cpi, cpi->mb.e_mbd.lossless);
|
|
|
|
|
|
|
|
vp9_frame_init_quantizer(cpi);
|
|
|
|
|
|
|
|
vp9_initialize_rd_consts(cpi);
|
|
|
|
vp9_initialize_me_consts(cpi, cm->base_qindex);
|
|
|
|
|
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
|
|
|
|
// Initialize encode frame context.
|
|
|
|
init_encode_frame_mb_context(cpi);
|
|
|
|
|
|
|
|
// Build a frame level activity map
|
|
|
|
build_activity_map(cpi);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Re-initialize encode frame context.
|
|
|
|
init_encode_frame_mb_context(cpi);
|
|
|
|
|
|
|
|
vp9_zero(cpi->rd_comp_pred_diff);
|
|
|
|
vp9_zero(cpi->rd_filter_diff);
|
|
|
|
vp9_zero(cpi->rd_tx_select_diff);
|
|
|
|
vp9_zero(cpi->rd_tx_select_threshes);
|
|
|
|
|
|
|
|
set_prev_mi(cm);
|
|
|
|
|
2014-02-25 00:21:13 +01:00
|
|
|
if (cpi->sf.use_nonrd_pick_mode) {
|
2014-02-13 20:41:08 +01:00
|
|
|
// Initialize internal buffer pointers for rtc coding, where non-RD
|
|
|
|
// mode decision is used and hence no buffer pointer swap needed.
|
|
|
|
int i;
|
|
|
|
struct macroblock_plane *const p = x->plane;
|
|
|
|
struct macroblockd_plane *const pd = xd->plane;
|
|
|
|
PICK_MODE_CONTEXT *ctx = &cpi->mb.sb64_context;
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_MB_PLANE; ++i) {
|
|
|
|
p[i].coeff = ctx->coeff_pbuf[i][0];
|
|
|
|
p[i].qcoeff = ctx->qcoeff_pbuf[i][0];
|
|
|
|
pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][0];
|
|
|
|
p[i].eobs = ctx->eobs_pbuf[i][0];
|
|
|
|
}
|
2014-03-14 20:07:21 +01:00
|
|
|
vp9_zero(x->zcoeff_blk);
|
2014-02-13 20:41:08 +01:00
|
|
|
}
|
|
|
|
|
2014-01-29 17:39:39 +01:00
|
|
|
{
|
|
|
|
struct vpx_usec_timer emr_timer;
|
|
|
|
vpx_usec_timer_start(&emr_timer);
|
|
|
|
|
|
|
|
{
|
|
|
|
// Take tiles into account and give start/end MB
|
|
|
|
int tile_col, tile_row;
|
|
|
|
TOKENEXTRA *tp = cpi->tok;
|
|
|
|
const int tile_cols = 1 << cm->log2_tile_cols;
|
|
|
|
const int tile_rows = 1 << cm->log2_tile_rows;
|
|
|
|
|
|
|
|
for (tile_row = 0; tile_row < tile_rows; tile_row++) {
|
|
|
|
for (tile_col = 0; tile_col < tile_cols; tile_col++) {
|
|
|
|
TileInfo tile;
|
|
|
|
TOKENEXTRA *tp_old = tp;
|
|
|
|
|
|
|
|
// For each row of SBs in the frame
|
|
|
|
vp9_tile_init(&tile, cm, tile_row, tile_col);
|
|
|
|
for (mi_row = tile.mi_row_start;
|
2014-02-19 20:17:12 +01:00
|
|
|
mi_row < tile.mi_row_end; mi_row += MI_BLOCK_SIZE) {
|
2014-03-07 03:56:50 +01:00
|
|
|
if (cpi->sf.use_nonrd_pick_mode && cm->frame_type != KEY_FRAME)
|
2014-02-25 00:21:13 +01:00
|
|
|
encode_nonrd_sb_row(cpi, &tile, mi_row, &tp);
|
2014-02-10 20:25:23 +01:00
|
|
|
else
|
2014-02-25 00:21:13 +01:00
|
|
|
encode_rd_sb_row(cpi, &tile, mi_row, &tp);
|
2014-02-10 20:25:23 +01:00
|
|
|
}
|
2014-01-29 17:39:39 +01:00
|
|
|
cpi->tok_count[tile_row][tile_col] = (unsigned int)(tp - tp_old);
|
|
|
|
assert(tp - cpi->tok <= get_token_alloc(cm->mb_rows, cm->mb_cols));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vpx_usec_timer_mark(&emr_timer);
|
|
|
|
cpi->time_encode_sb_row += vpx_usec_timer_elapsed(&emr_timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpi->sf.skip_encode_sb) {
|
|
|
|
int j;
|
|
|
|
unsigned int intra_count = 0, inter_count = 0;
|
|
|
|
for (j = 0; j < INTRA_INTER_CONTEXTS; ++j) {
|
|
|
|
intra_count += cm->counts.intra_inter[j][0];
|
|
|
|
inter_count += cm->counts.intra_inter[j][1];
|
|
|
|
}
|
2014-03-07 19:56:20 +01:00
|
|
|
cpi->sf.skip_encode_frame = (intra_count << 2) < inter_count &&
|
|
|
|
cm->frame_type != KEY_FRAME &&
|
|
|
|
cm->show_frame;
|
2014-01-29 17:39:39 +01:00
|
|
|
} else {
|
|
|
|
cpi->sf.skip_encode_frame = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
// Keep record of the total distortion this time around for future use
|
|
|
|
cpi->last_frame_distortion = cpi->frame_distortion;
|
|
|
|
#endif
|
|
|
|
}
|
Tx size selection enhancements
(1) Refines the modeling function and uses that to add some speed
features. Specifically, intead of using a flag use_largest_txfm as
a speed feature, an enum tx_size_search_method is used, of which
two of the types are USE_FULL_RD and USE_LARGESTALL. Two other
new types are added:
USE_LARGESTINTRA (use largest only for intra)
USE_LARGESTINTRA_MODELINTER (use largest for intra, and model for
inter)
(2) Another change is that the framework for deciding transform type
is simplified to use a heuristic count based method rather than
an rd based method using txfm_cache. In practice the new method
is found to work just as well - with derf only -0.01 down.
The new method is more compatible with the new framework where
certain rd costs are based on full rd and certain others are
based on modeled rd or are not computed. In this patch the existing
rd based method is still kept for use in the USE_FULL_RD mode.
In the other modes, the count based method is used.
However the recommendation is to remove it eventually since the
benefit is limited, and will remove a lot of complications in
the code
(3) Finally a bug is fixed with the existing use_largest_txfm speed feature
that causes mismatches when the lossless mode and 4x4 WH transform is
forced.
Results on derf:
USE_FULL_RD: +0.03% (due to change in the tables), 0% encode time reduction
USE_LARGESTINTRA: -0.21%, 15% encode time reduction (this one is a
pretty good compromise)
USE_LARGESTINTRA_MODELINTER: -0.98%, 22% encode time reduction
(currently the benefit of modeling is limited for txfm size selection,
but keeping this enum as a placeholder) .
USE_LARGESTALL: -1.05%, 27% encode-time reduction (same as existing
use_largest_txfm speed feature).
Change-Id: I4d60a5f9ce78fbc90cddf2f97ed91d8bc0d4f936
2013-06-22 01:31:12 +02:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
void vp9_encode_frame(VP9_COMP *cpi) {
|
2014-01-08 23:51:00 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2013-06-06 22:44:34 +02:00
|
|
|
|
2013-06-07 13:29:15 +02:00
|
|
|
// In the longer term the encoder should be generalized to match the
|
|
|
|
// decoder such that we allow compound where one of the 3 buffers has a
|
2013-07-24 16:58:26 +02:00
|
|
|
// different sign bias and that buffer is then the fixed ref. However, this
|
2013-06-07 13:29:15 +02:00
|
|
|
// requires further work in the rd loop. For now the only supported encoder
|
2013-08-20 21:55:41 +02:00
|
|
|
// side behavior is where the ALT ref buffer has opposite sign bias to
|
2013-06-07 13:29:15 +02:00
|
|
|
// the other two.
|
2013-10-03 18:07:24 +02:00
|
|
|
if (!frame_is_intra_only(cm)) {
|
2014-01-10 22:48:44 +01:00
|
|
|
if ((cm->ref_frame_sign_bias[ALTREF_FRAME] ==
|
|
|
|
cm->ref_frame_sign_bias[GOLDEN_FRAME]) ||
|
|
|
|
(cm->ref_frame_sign_bias[ALTREF_FRAME] ==
|
|
|
|
cm->ref_frame_sign_bias[LAST_FRAME])) {
|
2013-10-03 18:07:24 +02:00
|
|
|
cm->allow_comp_inter_inter = 0;
|
|
|
|
} else {
|
|
|
|
cm->allow_comp_inter_inter = 1;
|
|
|
|
cm->comp_fixed_ref = ALTREF_FRAME;
|
|
|
|
cm->comp_var_ref[0] = LAST_FRAME;
|
|
|
|
cm->comp_var_ref[1] = GOLDEN_FRAME;
|
|
|
|
}
|
2013-06-06 22:44:34 +02:00
|
|
|
}
|
|
|
|
|
2014-02-10 21:03:02 +01:00
|
|
|
if (cpi->sf.frame_parameter_update) {
|
2013-12-19 23:28:42 +01:00
|
|
|
int i;
|
|
|
|
REFERENCE_MODE reference_mode;
|
2012-07-14 00:21:29 +02:00
|
|
|
/*
|
|
|
|
* This code does a single RD pass over the whole frame assuming
|
|
|
|
* either compound, single or hybrid prediction as per whatever has
|
|
|
|
* worked best for that type of frame in the past.
|
|
|
|
* It also predicts whether another coding mode would have worked
|
|
|
|
* better that this coding mode. If that is the case, it remembers
|
2012-10-09 18:18:21 +02:00
|
|
|
* that for subsequent frames.
|
|
|
|
* It does the same analysis for transform size selection also.
|
2012-07-14 00:21:29 +02:00
|
|
|
*/
|
2014-01-31 20:08:27 +01:00
|
|
|
const MV_REFERENCE_FRAME frame_type = get_frame_type(cpi);
|
2013-12-19 23:28:42 +01:00
|
|
|
const int64_t *mode_thresh = cpi->rd_prediction_type_threshes[frame_type];
|
|
|
|
const int64_t *filter_thresh = cpi->rd_filter_threshes[frame_type];
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-10-09 18:18:21 +02:00
|
|
|
/* prediction (compound, single or hybrid) mode selection */
|
2013-06-06 22:44:34 +02:00
|
|
|
if (frame_type == 3 || !cm->allow_comp_inter_inter)
|
2013-12-19 23:28:42 +01:00
|
|
|
reference_mode = SINGLE_REFERENCE;
|
|
|
|
else if (mode_thresh[COMPOUND_REFERENCE] > mode_thresh[SINGLE_REFERENCE] &&
|
|
|
|
mode_thresh[COMPOUND_REFERENCE] >
|
|
|
|
mode_thresh[REFERENCE_MODE_SELECT] &&
|
|
|
|
check_dual_ref_flags(cpi) &&
|
|
|
|
cpi->static_mb_pct == 100)
|
|
|
|
reference_mode = COMPOUND_REFERENCE;
|
|
|
|
else if (mode_thresh[SINGLE_REFERENCE] > mode_thresh[REFERENCE_MODE_SELECT])
|
|
|
|
reference_mode = SINGLE_REFERENCE;
|
2012-07-14 00:21:29 +02:00
|
|
|
else
|
2013-12-19 23:28:42 +01:00
|
|
|
reference_mode = REFERENCE_MODE_SELECT;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-01-31 20:08:27 +01:00
|
|
|
if (cm->interp_filter == SWITCHABLE) {
|
|
|
|
if (frame_type != ALTREF_FRAME &&
|
|
|
|
filter_thresh[EIGHTTAP_SMOOTH] > filter_thresh[EIGHTTAP] &&
|
|
|
|
filter_thresh[EIGHTTAP_SMOOTH] > filter_thresh[EIGHTTAP_SHARP] &&
|
|
|
|
filter_thresh[EIGHTTAP_SMOOTH] > filter_thresh[SWITCHABLE - 1]) {
|
|
|
|
cm->interp_filter = EIGHTTAP_SMOOTH;
|
|
|
|
} else if (filter_thresh[EIGHTTAP_SHARP] > filter_thresh[EIGHTTAP] &&
|
|
|
|
filter_thresh[EIGHTTAP_SHARP] > filter_thresh[SWITCHABLE - 1]) {
|
|
|
|
cm->interp_filter = EIGHTTAP_SHARP;
|
|
|
|
} else if (filter_thresh[EIGHTTAP] > filter_thresh[SWITCHABLE - 1]) {
|
|
|
|
cm->interp_filter = EIGHTTAP;
|
|
|
|
}
|
2013-07-08 23:49:33 +02:00
|
|
|
}
|
|
|
|
|
2013-12-19 23:28:42 +01:00
|
|
|
cpi->mb.e_mbd.lossless = cpi->oxcf.lossless;
|
2014-01-08 23:51:00 +01:00
|
|
|
cm->reference_mode = reference_mode;
|
2014-01-29 17:39:39 +01:00
|
|
|
|
2014-02-10 20:25:23 +01:00
|
|
|
encode_frame_internal(cpi);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-11-23 01:35:37 +01:00
|
|
|
for (i = 0; i < REFERENCE_MODES; ++i) {
|
2014-01-08 23:51:00 +01:00
|
|
|
const int diff = (int) (cpi->rd_comp_pred_diff[i] / cm->MBs);
|
2012-08-10 03:25:29 +02:00
|
|
|
cpi->rd_prediction_type_threshes[frame_type][i] += diff;
|
|
|
|
cpi->rd_prediction_type_threshes[frame_type][i] >>= 1;
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-10-30 22:40:34 +01:00
|
|
|
for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
|
2014-01-08 23:51:00 +01:00
|
|
|
const int64_t diff = cpi->rd_filter_diff[i] / cm->MBs;
|
2013-07-08 23:49:33 +02:00
|
|
|
cpi->rd_filter_threshes[frame_type][i] =
|
|
|
|
(cpi->rd_filter_threshes[frame_type][i] + diff) / 2;
|
|
|
|
}
|
|
|
|
|
2013-07-29 22:38:40 +02:00
|
|
|
for (i = 0; i < TX_MODES; ++i) {
|
2012-10-09 18:18:21 +02:00
|
|
|
int64_t pd = cpi->rd_tx_select_diff[i];
|
|
|
|
int diff;
|
|
|
|
if (i == TX_MODE_SELECT)
|
2014-01-10 22:48:44 +01:00
|
|
|
pd -= RDCOST(cpi->mb.rdmult, cpi->mb.rddiv, 2048 * (TX_SIZES - 1), 0);
|
2014-01-08 23:51:00 +01:00
|
|
|
diff = (int) (pd / cm->MBs);
|
2012-10-09 18:18:21 +02:00
|
|
|
cpi->rd_tx_select_threshes[frame_type][i] += diff;
|
|
|
|
cpi->rd_tx_select_threshes[frame_type][i] /= 2;
|
|
|
|
}
|
|
|
|
|
2014-01-08 23:51:00 +01:00
|
|
|
if (cm->reference_mode == REFERENCE_MODE_SELECT) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int single_count_zero = 0;
|
|
|
|
int comp_count_zero = 0;
|
|
|
|
|
2013-06-06 22:44:34 +02:00
|
|
|
for (i = 0; i < COMP_INTER_CONTEXTS; i++) {
|
2013-12-17 05:12:47 +01:00
|
|
|
single_count_zero += cm->counts.comp_inter[i][0];
|
|
|
|
comp_count_zero += cm->counts.comp_inter[i][1];
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (comp_count_zero == 0) {
|
2014-01-08 23:51:00 +01:00
|
|
|
cm->reference_mode = SINGLE_REFERENCE;
|
2013-12-17 05:12:47 +01:00
|
|
|
vp9_zero(cm->counts.comp_inter);
|
2012-07-14 00:21:29 +02:00
|
|
|
} else if (single_count_zero == 0) {
|
2014-01-08 23:51:00 +01:00
|
|
|
cm->reference_mode = COMPOUND_REFERENCE;
|
2013-12-17 05:12:47 +01:00
|
|
|
vp9_zero(cm->counts.comp_inter);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
}
|
2012-10-09 18:18:21 +02:00
|
|
|
|
2014-01-08 23:51:00 +01:00
|
|
|
if (cm->tx_mode == TX_MODE_SELECT) {
|
2013-06-06 20:14:04 +02:00
|
|
|
int count4x4 = 0;
|
|
|
|
int count8x8_lp = 0, count8x8_8x8p = 0;
|
|
|
|
int count16x16_16x16p = 0, count16x16_lp = 0;
|
|
|
|
int count32x32 = 0;
|
|
|
|
|
2013-07-23 21:54:04 +02:00
|
|
|
for (i = 0; i < TX_SIZE_CONTEXTS; ++i) {
|
2013-07-24 02:02:08 +02:00
|
|
|
count4x4 += cm->counts.tx.p32x32[i][TX_4X4];
|
|
|
|
count4x4 += cm->counts.tx.p16x16[i][TX_4X4];
|
|
|
|
count4x4 += cm->counts.tx.p8x8[i][TX_4X4];
|
2013-06-06 20:14:04 +02:00
|
|
|
|
2013-07-24 02:02:08 +02:00
|
|
|
count8x8_lp += cm->counts.tx.p32x32[i][TX_8X8];
|
|
|
|
count8x8_lp += cm->counts.tx.p16x16[i][TX_8X8];
|
|
|
|
count8x8_8x8p += cm->counts.tx.p8x8[i][TX_8X8];
|
2013-06-06 20:14:04 +02:00
|
|
|
|
2013-07-24 02:02:08 +02:00
|
|
|
count16x16_16x16p += cm->counts.tx.p16x16[i][TX_16X16];
|
|
|
|
count16x16_lp += cm->counts.tx.p32x32[i][TX_16X16];
|
|
|
|
count32x32 += cm->counts.tx.p32x32[i][TX_32X32];
|
2013-07-23 21:54:04 +02:00
|
|
|
}
|
2012-10-09 18:18:21 +02:00
|
|
|
|
2014-01-08 23:51:00 +01:00
|
|
|
if (count4x4 == 0 && count16x16_lp == 0 && count16x16_16x16p == 0 &&
|
|
|
|
count32x32 == 0) {
|
|
|
|
cm->tx_mode = ALLOW_8X8;
|
|
|
|
reset_skip_txfm_size(cm, TX_8X8);
|
|
|
|
} else if (count8x8_8x8p == 0 && count16x16_16x16p == 0 &&
|
|
|
|
count8x8_lp == 0 && count16x16_lp == 0 && count32x32 == 0) {
|
|
|
|
cm->tx_mode = ONLY_4X4;
|
|
|
|
reset_skip_txfm_size(cm, TX_4X4);
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
} else if (count8x8_lp == 0 && count16x16_lp == 0 && count4x4 == 0) {
|
2014-01-08 23:51:00 +01:00
|
|
|
cm->tx_mode = ALLOW_32X32;
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
} else if (count32x32 == 0 && count8x8_lp == 0 && count4x4 == 0) {
|
2014-01-08 23:51:00 +01:00
|
|
|
cm->tx_mode = ALLOW_16X16;
|
|
|
|
reset_skip_txfm_size(cm, TX_16X16);
|
2012-10-09 18:18:21 +02:00
|
|
|
}
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
} else {
|
2014-03-04 19:24:25 +01:00
|
|
|
cpi->mb.e_mbd.lossless = cpi->oxcf.lossless;
|
|
|
|
cm->reference_mode = SINGLE_REFERENCE;
|
2014-01-31 20:08:27 +01:00
|
|
|
// Force the usage of the BILINEAR interp_filter.
|
|
|
|
cm->interp_filter = BILINEAR;
|
2014-02-10 20:25:23 +01:00
|
|
|
encode_frame_internal(cpi);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
Dual 16x16 inter prediction.
This patch introduces the concept of dual inter16x16 prediction. A
16x16 inter-predicted macroblock can use 2 references instead of 1,
where both references use the same mvmode (new, near/est, zero). In the
case of newmv, this means that two MVs are coded instead of one. The
frame can be encoded in 3 ways: all MBs single-prediction, all MBs dual
prediction, or per-MB single/dual prediction selection ("hybrid"), in
which case a single bit is coded per-MB to indicate whether the MB uses
single or dual inter prediction.
In the future, we can (maybe?) get further gains by mixing this with
Adrian's 32x32 work, per-segment dual prediction settings, or adding
support for dual splitmv/8x8mv inter prediction.
Gain (on derf-set, CQ mode) is ~2.8% (SSIM) or ~3.6% (glb PSNR). Most
gain is at medium/high bitrates, but there's minor gains at low bitrates
also. Output was confirmed to match between encoder and decoder.
Note for optimization people: this patch introduces a 2nd version of
16x16/8x8 sixtap/bilin functions, which does an avg instead of a
store. They may want to look and make sure this is implemented to
their satisfaction so we can optimize it best in the future.
Change-ID: I59dc84b07cbb3ccf073ac0f756d03d294cb19281
2011-12-06 20:53:02 +01:00
|
|
|
}
|
|
|
|
|
2014-01-10 22:48:44 +01:00
|
|
|
static void sum_intra_stats(FRAME_COUNTS *counts, const MODE_INFO *mi) {
|
2013-08-22 01:25:02 +02:00
|
|
|
const MB_PREDICTION_MODE y_mode = mi->mbmi.mode;
|
|
|
|
const MB_PREDICTION_MODE uv_mode = mi->mbmi.uv_mode;
|
2013-08-27 20:05:08 +02:00
|
|
|
const BLOCK_SIZE bsize = mi->mbmi.sb_type;
|
2013-08-22 01:25:02 +02:00
|
|
|
|
|
|
|
if (bsize < BLOCK_8X8) {
|
2013-05-20 21:08:22 +02:00
|
|
|
int idx, idy;
|
2014-03-07 19:56:20 +01:00
|
|
|
const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize];
|
|
|
|
const int num_4x4_h = num_4x4_blocks_high_lookup[bsize];
|
|
|
|
for (idy = 0; idy < 2; idy += num_4x4_h)
|
|
|
|
for (idx = 0; idx < 2; idx += num_4x4_w)
|
2014-01-10 22:48:44 +01:00
|
|
|
++counts->y_mode[0][mi->bmi[idy * 2 + idx].as_mode];
|
2013-08-22 01:25:02 +02:00
|
|
|
} else {
|
2014-01-10 22:48:44 +01:00
|
|
|
++counts->y_mode[size_group_lookup[bsize]][y_mode];
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2014-03-07 19:56:20 +01:00
|
|
|
|
|
|
|
++counts->uv_mode[y_mode][uv_mode];
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2011-05-12 18:01:55 +02:00
|
|
|
|
|
|
|
// Experimental stub function to create a per MB zbin adjustment based on
|
|
|
|
// some previously calculated measure of MB activity.
|
2012-10-31 01:53:32 +01:00
|
|
|
static void adjust_act_zbin(VP9_COMP *cpi, MACROBLOCK *x) {
|
2011-06-08 17:00:59 +02:00
|
|
|
#if USE_ACT_INDEX
|
2012-07-14 00:21:29 +02:00
|
|
|
x->act_zbin_adj = *(x->mb_activity_ptr);
|
2011-06-08 17:00:59 +02:00
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
// Apply the masking to the RD multiplier.
|
2014-03-07 19:56:20 +01:00
|
|
|
const int64_t act = *(x->mb_activity_ptr);
|
|
|
|
const int64_t a = act + 4 * cpi->activity_avg;
|
|
|
|
const int64_t b = 4 * act + cpi->activity_avg;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (act > cpi->activity_avg)
|
2013-06-19 23:26:49 +02:00
|
|
|
x->act_zbin_adj = (int) (((int64_t) b + (a >> 1)) / a) - 1;
|
2012-07-14 00:21:29 +02:00
|
|
|
else
|
2013-06-19 23:26:49 +02:00
|
|
|
x->act_zbin_adj = 1 - (int) (((int64_t) a + (b >> 1)) / b);
|
2011-06-08 17:00:59 +02:00
|
|
|
#endif
|
2011-05-12 18:01:55 +02:00
|
|
|
}
|
2013-12-18 19:39:08 +01:00
|
|
|
|
2014-01-10 22:48:44 +01:00
|
|
|
static int get_zbin_mode_boost(const MB_MODE_INFO *mbmi, int enabled) {
|
2013-12-18 19:39:08 +01:00
|
|
|
if (enabled) {
|
|
|
|
if (is_inter_block(mbmi)) {
|
|
|
|
if (mbmi->mode == ZEROMV) {
|
|
|
|
return mbmi->ref_frame[0] != LAST_FRAME ? GF_ZEROMV_ZBIN_BOOST
|
|
|
|
: LF_ZEROMV_ZBIN_BOOST;
|
|
|
|
} else {
|
|
|
|
return mbmi->sb_type < BLOCK_8X8 ? SPLIT_MV_ZBIN_BOOST
|
|
|
|
: MV_ZBIN_BOOST;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return INTRA_ZBIN_BOOST;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-19 23:26:49 +02:00
|
|
|
static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
|
2013-08-27 20:05:08 +02:00
|
|
|
int mi_row, int mi_col, BLOCK_SIZE bsize) {
|
2014-01-10 22:48:44 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
MACROBLOCK *const x = &cpi->mb;
|
|
|
|
MACROBLOCKD *const xd = &x->e_mbd;
|
2014-04-02 01:18:47 +02:00
|
|
|
MODE_INFO **mi_8x8 = xd->mi;
|
2013-09-11 19:45:44 +02:00
|
|
|
MODE_INFO *mi = mi_8x8[0];
|
2013-05-21 00:59:39 +02:00
|
|
|
MB_MODE_INFO *mbmi = &mi->mbmi;
|
2013-11-06 06:07:08 +01:00
|
|
|
PICK_MODE_CONTEXT *ctx = get_block_context(x, bsize);
|
2013-05-21 00:59:39 +02:00
|
|
|
unsigned int segment_id = mbmi->segment_id;
|
2014-04-02 01:18:47 +02:00
|
|
|
const int mis = cm->mi_stride;
|
2013-07-23 15:51:44 +02:00
|
|
|
const int mi_width = num_8x8_blocks_wide_lookup[bsize];
|
|
|
|
const int mi_height = num_8x8_blocks_high_lookup[bsize];
|
2014-02-14 23:41:47 +01:00
|
|
|
|
2013-11-22 18:21:53 +01:00
|
|
|
x->skip_recode = !x->select_txfm_size && mbmi->sb_type >= BLOCK_8X8 &&
|
2014-03-25 22:27:45 +01:00
|
|
|
cpi->oxcf.aq_mode != COMPLEXITY_AQ &&
|
|
|
|
cpi->oxcf.aq_mode != CYCLIC_REFRESH_AQ &&
|
|
|
|
cpi->sf.allow_skip_recode;
|
2014-03-20 16:16:35 +01:00
|
|
|
|
2013-11-06 06:07:08 +01:00
|
|
|
x->skip_optimize = ctx->is_coded;
|
|
|
|
ctx->is_coded = 1;
|
2013-08-08 00:22:51 +02:00
|
|
|
x->use_lp32x32fdct = cpi->sf.use_lp32x32fdct;
|
2013-07-09 01:48:47 +02:00
|
|
|
x->skip_encode = (!output_enabled && cpi->sf.skip_encode_frame &&
|
2013-11-13 02:28:27 +01:00
|
|
|
x->q_index < QIDX_SKIP_THRESH);
|
2014-03-14 20:07:21 +01:00
|
|
|
|
2013-07-09 01:48:47 +02:00
|
|
|
if (x->skip_encode)
|
|
|
|
return;
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
if (cm->frame_type == KEY_FRAME) {
|
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
|
|
|
|
adjust_act_zbin(cpi, x);
|
|
|
|
vp9_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
} else {
|
2014-01-28 01:00:20 +01:00
|
|
|
set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
|
2014-01-27 23:20:39 +01:00
|
|
|
xd->interp_kernel = vp9_get_interp_kernel(mbmi->interp_filter);
|
2013-01-06 03:20:25 +01:00
|
|
|
|
|
|
|
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {
|
|
|
|
// Adjust the zbin based on this MB rate.
|
|
|
|
adjust_act_zbin(cpi, x);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Experimental code. Special case for gf and arf zeromv modes.
|
|
|
|
// Increase zbin size to suppress noise
|
2013-12-18 19:39:08 +01:00
|
|
|
cpi->zbin_mode_boost = get_zbin_mode_boost(mbmi,
|
|
|
|
cpi->zbin_mode_boost_enabled);
|
2013-01-06 03:20:25 +01:00
|
|
|
vp9_update_zbin_extra(cpi, x);
|
|
|
|
}
|
|
|
|
|
2013-08-23 00:50:51 +02:00
|
|
|
if (!is_inter_block(mbmi)) {
|
2014-02-12 03:06:00 +01:00
|
|
|
int plane;
|
2014-02-13 02:44:12 +01:00
|
|
|
mbmi->skip = 1;
|
2014-02-12 03:06:00 +01:00
|
|
|
for (plane = 0; plane < MAX_MB_PLANE; ++plane)
|
|
|
|
vp9_encode_intra_block_plane(x, MAX(bsize, BLOCK_8X8), plane);
|
2013-01-06 03:20:25 +01:00
|
|
|
if (output_enabled)
|
2014-01-10 22:48:44 +01:00
|
|
|
sum_intra_stats(&cm->counts, mi);
|
2014-02-13 20:29:45 +01:00
|
|
|
vp9_tokenize_sb(cpi, t, !output_enabled, MAX(bsize, BLOCK_8X8));
|
2012-11-08 20:03:00 +01:00
|
|
|
} else {
|
2014-01-03 21:50:57 +01:00
|
|
|
int ref;
|
|
|
|
const int is_compound = has_second_ref(mbmi);
|
|
|
|
for (ref = 0; ref < 1 + is_compound; ++ref) {
|
2014-01-06 23:50:54 +01:00
|
|
|
YV12_BUFFER_CONFIG *cfg = get_ref_frame_buffer(cpi,
|
|
|
|
mbmi->ref_frame[ref]);
|
2014-03-03 23:58:43 +01:00
|
|
|
vp9_setup_pre_planes(xd, ref, cfg, mi_row, mi_col,
|
|
|
|
&xd->block_refs[ref]->sf);
|
2013-05-21 00:59:39 +02:00
|
|
|
}
|
2013-08-06 00:23:49 +02:00
|
|
|
vp9_build_inter_predictors_sb(xd, mi_row, mi_col, MAX(bsize, BLOCK_8X8));
|
2013-01-06 03:20:25 +01:00
|
|
|
|
2014-02-13 20:29:45 +01:00
|
|
|
if (!x->skip) {
|
|
|
|
mbmi->skip = 1;
|
|
|
|
vp9_encode_sb(x, MAX(bsize, BLOCK_8X8));
|
|
|
|
vp9_tokenize_sb(cpi, t, !output_enabled, MAX(bsize, BLOCK_8X8));
|
|
|
|
} else {
|
|
|
|
mbmi->skip = 1;
|
|
|
|
if (output_enabled)
|
|
|
|
cm->counts.skip[vp9_get_skip_context(xd)][1]++;
|
|
|
|
reset_skip_context(xd, MAX(bsize, BLOCK_8X8));
|
|
|
|
}
|
2013-01-06 03:20:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (output_enabled) {
|
2013-07-19 20:37:13 +02:00
|
|
|
if (cm->tx_mode == TX_MODE_SELECT &&
|
2013-08-06 00:23:49 +02:00
|
|
|
mbmi->sb_type >= BLOCK_8X8 &&
|
2013-08-03 01:25:33 +02:00
|
|
|
!(is_inter_block(mbmi) &&
|
2014-02-13 02:44:12 +01:00
|
|
|
(mbmi->skip ||
|
2013-08-14 20:20:33 +02:00
|
|
|
vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)))) {
|
2013-12-07 00:31:06 +01:00
|
|
|
++get_tx_counts(max_txsize_lookup[bsize], vp9_get_tx_size_context(xd),
|
|
|
|
&cm->counts.tx)[mbmi->tx_size];
|
2013-01-06 03:20:25 +01:00
|
|
|
} else {
|
|
|
|
int x, y;
|
2013-12-05 21:25:03 +01:00
|
|
|
TX_SIZE tx_size;
|
2013-06-19 23:26:49 +02:00
|
|
|
// The new intra coding scheme requires no change of transform size
|
2013-08-03 01:25:33 +02:00
|
|
|
if (is_inter_block(&mi->mbmi)) {
|
2013-12-05 21:25:03 +01:00
|
|
|
tx_size = MIN(tx_mode_to_biggest_tx_size[cm->tx_mode],
|
|
|
|
max_txsize_lookup[bsize]);
|
2013-05-17 21:50:40 +02:00
|
|
|
} else {
|
2013-12-05 21:25:03 +01:00
|
|
|
tx_size = (bsize >= BLOCK_8X8) ? mbmi->tx_size : TX_4X4;
|
2013-05-17 21:50:40 +02:00
|
|
|
}
|
2013-04-10 06:28:27 +02:00
|
|
|
|
2013-08-28 04:47:53 +02:00
|
|
|
for (y = 0; y < mi_height; y++)
|
|
|
|
for (x = 0; x < mi_width; x++)
|
|
|
|
if (mi_col + x < cm->mi_cols && mi_row + y < cm->mi_rows)
|
2013-12-05 21:25:03 +01:00
|
|
|
mi_8x8[mis * y + x]->mbmi.tx_size = tx_size;
|
2012-11-08 20:03:00 +01:00
|
|
|
}
|
|
|
|
}
|
2012-08-20 23:43:34 +02:00
|
|
|
}
|