Commit 8962d975 authored by Dmitry Kovalev's avatar Dmitry Kovalev Committed by Gerrit Code Review
Browse files

Merge "Moving all loop filter related variables into new struct."

parents 39342db1 ee1771eb
......@@ -31,9 +31,6 @@
#define MBSKIP_CONTEXTS 3
#define MAX_REF_LF_DELTAS 4
#define MAX_MODE_LF_DELTAS 2
/* Segment Feature Masks */
#define MAX_MV_REF_CANDIDATES 2
......@@ -215,6 +212,27 @@ struct macroblockd_plane {
#define BLOCK_OFFSET(x, i, n) ((x) + (i) * (n))
#define MAX_REF_LF_DELTAS 4
#define MAX_MODE_LF_DELTAS 2
struct loopfilter {
int filter_level;
int sharpness_level;
int last_sharpness_level;
uint8_t mode_ref_delta_enabled;
uint8_t mode_ref_delta_update;
// 0 = Intra, Last, GF, ARF
signed char ref_deltas[MAX_REF_LF_DELTAS];
signed char last_ref_deltas[MAX_REF_LF_DELTAS];
// 0 = ZERO_MV, MV
signed char mode_deltas[MAX_MODE_LF_DELTAS];
signed char last_mode_deltas[MAX_MODE_LF_DELTAS];
};
typedef struct macroblockd {
struct macroblockd_plane plane[MAX_MB_PLANE];
......@@ -229,26 +247,12 @@ typedef struct macroblockd {
int right_available;
struct segmentation seg;
struct loopfilter lf;
// partition contexts
PARTITION_CONTEXT *above_seg_context;
PARTITION_CONTEXT *left_seg_context;
/* mode_based Loop filter adjustment */
unsigned char mode_ref_lf_delta_enabled;
unsigned char mode_ref_lf_delta_update;
/* Delta values have the range +/- MAX_LOOP_FILTER */
/* 0 = Intra, Last, GF, ARF */
signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];
/* 0 = Intra, Last, GF, ARF */
signed char ref_lf_deltas[MAX_REF_LF_DELTAS];
/* 0 = ZERO_MV, MV */
signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
/* 0 = ZERO_MV, MV */
signed char mode_lf_deltas[MAX_MODE_LF_DELTAS];
/* Distance of MB away from frame edges */
int mb_to_left_edge;
int mb_to_right_edge;
......
......@@ -552,16 +552,16 @@ void vp9_adapt_mode_probs(VP9_COMMON *cm) {
}
static void set_default_lf_deltas(MACROBLOCKD *xd) {
xd->mode_ref_lf_delta_enabled = 1;
xd->mode_ref_lf_delta_update = 1;
xd->lf.mode_ref_delta_enabled = 1;
xd->lf.mode_ref_delta_update = 1;
xd->ref_lf_deltas[INTRA_FRAME] = 1;
xd->ref_lf_deltas[LAST_FRAME] = 0;
xd->ref_lf_deltas[GOLDEN_FRAME] = -1;
xd->ref_lf_deltas[ALTREF_FRAME] = -1;
xd->lf.ref_deltas[INTRA_FRAME] = 1;
xd->lf.ref_deltas[LAST_FRAME] = 0;
xd->lf.ref_deltas[GOLDEN_FRAME] = -1;
xd->lf.ref_deltas[ALTREF_FRAME] = -1;
xd->mode_lf_deltas[0] = 0;
xd->mode_lf_deltas[1] = 0;
xd->lf.mode_deltas[0] = 0;
xd->lf.mode_deltas[1] = 0;
}
void vp9_setup_past_independence(VP9_COMMON *cm, MACROBLOCKD *xd) {
......@@ -574,8 +574,8 @@ void vp9_setup_past_independence(VP9_COMMON *cm, MACROBLOCKD *xd) {
vpx_memset(cm->last_frame_seg_map, 0, (cm->mi_rows * cm->mi_cols));
// Reset the mode ref deltas for loop filter
vp9_zero(xd->last_ref_lf_deltas);
vp9_zero(xd->last_mode_lf_deltas);
vp9_zero(xd->lf.last_ref_deltas);
vp9_zero(xd->lf.last_mode_deltas);
set_default_lf_deltas(xd);
vp9_default_coef_probs(cm);
......@@ -584,7 +584,7 @@ void vp9_setup_past_independence(VP9_COMMON *cm, MACROBLOCKD *xd) {
vp9_init_mv_probs(cm);
// To force update of the sharpness
cm->last_sharpness_level = -1;
xd->lf.last_sharpness_level = -1;
vp9_init_mode_contexts(cm);
......
......@@ -55,13 +55,13 @@ static void update_sharpness(loop_filter_info_n *const lfi, int sharpness_lvl) {
}
}
void vp9_loop_filter_init(VP9_COMMON *cm) {
void vp9_loop_filter_init(VP9_COMMON *cm, struct loopfilter *lf) {
loop_filter_info_n *lfi = &cm->lf_info;
int i;
// init limits for given sharpness
update_sharpness(lfi, cm->sharpness_level);
cm->last_sharpness_level = cm->sharpness_level;
update_sharpness(lfi, lf->sharpness_level);
lf->last_sharpness_level = lf->sharpness_level;
// init LUT for lvl and hev thr picking
lf_init_lut(lfi);
......@@ -79,11 +79,12 @@ static void loop_filter_frame_init(VP9_COMMON *const cm, MACROBLOCKD *const xd,
// 2 when filter_lvl is between 32 and 63
const int n_shift = default_filt_lvl >> 5;
loop_filter_info_n *const lfi = &cm->lf_info;
struct loopfilter *lf = &xd->lf;
// update limits if sharpness has changed
if (cm->last_sharpness_level != cm->sharpness_level) {
update_sharpness(lfi, cm->sharpness_level);
cm->last_sharpness_level = cm->sharpness_level;
if (lf->last_sharpness_level != lf->sharpness_level) {
update_sharpness(lfi, lf->sharpness_level);
lf->last_sharpness_level = lf->sharpness_level;
}
for (seg = 0; seg < MAX_MB_SEGMENTS; seg++) {
......@@ -97,20 +98,20 @@ static void loop_filter_frame_init(VP9_COMMON *const cm, MACROBLOCKD *const xd,
: clamp(default_filt_lvl + data, 0, MAX_LOOP_FILTER);
}
if (!xd->mode_ref_lf_delta_enabled) {
if (!lf->mode_ref_delta_enabled) {
// we could get rid of this if we assume that deltas are set to
// zero when not in use; encoder always uses deltas
vpx_memset(lfi->lvl[seg][0], lvl_seg, 4 * 4);
continue;
}
intra_lvl = lvl_seg + (xd->ref_lf_deltas[INTRA_FRAME] << n_shift);
intra_lvl = lvl_seg + (lf->ref_deltas[INTRA_FRAME] << n_shift);
lfi->lvl[seg][INTRA_FRAME][0] = clamp(intra_lvl, 0, MAX_LOOP_FILTER);
for (ref = LAST_FRAME; ref < MAX_REF_FRAMES; ++ref)
for (mode = 0; mode < MAX_MODE_LF_DELTAS; ++mode) {
const int inter_lvl = lvl_seg + (xd->ref_lf_deltas[ref] << n_shift)
+ (xd->mode_lf_deltas[mode] << n_shift);
const int inter_lvl = lvl_seg + (lf->ref_deltas[ref] << n_shift)
+ (lf->mode_deltas[mode] << n_shift);
lfi->lvl[seg][ref][mode] = clamp(inter_lvl, 0, MAX_LOOP_FILTER);
}
}
......
......@@ -46,7 +46,7 @@ struct loop_filter_info {
struct VP9Common;
struct macroblockd;
void vp9_loop_filter_init(struct VP9Common *cm);
void vp9_loop_filter_init(struct VP9Common *cm, struct loopfilter *lf);
void vp9_loop_filter_frame(struct VP9Common *cm,
struct macroblockd *mbd,
......
......@@ -202,10 +202,6 @@ typedef struct VP9Common {
loop_filter_info_n lf_info;
int filter_level;
int last_sharpness_level;
int sharpness_level;
int refresh_frame_context; /* Two state 0 = NO, 1 = YES */
int ref_frame_sign_bias[MAX_REF_FRAMES]; /* Two state 0, 1 */
......
......@@ -630,9 +630,11 @@ static void constrain_line(int x0, int *x1, int y0, int *y1,
}
}
int vp9_post_proc_frame(VP9_COMMON *oci, YV12_BUFFER_CONFIG *dest,
int vp9_post_proc_frame(struct VP9Common *oci,
struct loopfilter *lf,
YV12_BUFFER_CONFIG *dest,
vp9_ppflags_t *ppflags) {
int q = oci->filter_level * 10 / 6;
int q = lf->filter_level * 10 / 6;
int flags = ppflags->post_proc_flag;
int deblock_level = ppflags->deblocking_level;
int noise_level = ppflags->noise_level;
......
......@@ -26,8 +26,8 @@ struct postproc_state {
#include "vp9/common/vp9_onyxc_int.h"
#include "vp9/common/vp9_ppflags.h"
int vp9_post_proc_frame(struct VP9Common *oci, YV12_BUFFER_CONFIG *dest,
vp9_ppflags_t *flags);
int vp9_post_proc_frame(struct VP9Common *oci, struct loopfilter *lf,
YV12_BUFFER_CONFIG *dest, vp9_ppflags_t *flags);
void vp9_denoise(const YV12_BUFFER_CONFIG *src, YV12_BUFFER_CONFIG *dst, int q);
......
......@@ -438,30 +438,29 @@ static void setup_segmentation(struct segmentation *seg,
}
}
static void setup_loopfilter(VP9D_COMP *pbi, struct vp9_read_bit_buffer *rb) {
VP9_COMMON *const cm = &pbi->common;
MACROBLOCKD *const xd = &pbi->mb;
static void setup_loopfilter(struct loopfilter *lf,
struct vp9_read_bit_buffer *rb) {
cm->filter_level = vp9_rb_read_literal(rb, 6);
cm->sharpness_level = vp9_rb_read_literal(rb, 3);
lf->filter_level = vp9_rb_read_literal(rb, 6);
lf->sharpness_level = vp9_rb_read_literal(rb, 3);
// Read in loop filter deltas applied at the MB level based on mode or ref
// frame.
xd->mode_ref_lf_delta_update = 0;
lf->mode_ref_delta_update = 0;
xd->mode_ref_lf_delta_enabled = vp9_rb_read_bit(rb);
if (xd->mode_ref_lf_delta_enabled) {
xd->mode_ref_lf_delta_update = vp9_rb_read_bit(rb);
if (xd->mode_ref_lf_delta_update) {
lf->mode_ref_delta_enabled = vp9_rb_read_bit(rb);
if (lf->mode_ref_delta_enabled) {
lf->mode_ref_delta_update = vp9_rb_read_bit(rb);
if (lf->mode_ref_delta_update) {
int i;
for (i = 0; i < MAX_REF_LF_DELTAS; i++)
if (vp9_rb_read_bit(rb))
xd->ref_lf_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
lf->ref_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
if (vp9_rb_read_bit(rb))
xd->mode_lf_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
lf->mode_deltas[i] = vp9_rb_read_signed_literal(rb, 6);
}
}
}
......@@ -797,7 +796,7 @@ static size_t read_uncompressed_header(VP9D_COMP *pbi,
int frame_to_show = cm->ref_frame_map[vp9_rb_read_literal(rb, 3)];
ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->new_fb_idx, frame_to_show);
pbi->refresh_frame_flags = 0;
cm->filter_level = 0;
xd->lf.filter_level = 0;
return 0;
}
......@@ -881,9 +880,9 @@ static size_t read_uncompressed_header(VP9D_COMP *pbi,
if (cm->frame_type == KEY_FRAME || cm->error_resilient_mode || cm->intra_only)
vp9_setup_past_independence(cm, xd);
setup_loopfilter(pbi, rb);
setup_loopfilter(&xd->lf, rb);
setup_quantization(pbi, rb);
setup_segmentation(&pbi->mb.seg, rb);
setup_segmentation(&xd->seg, rb);
setup_tile_info(cm, rb);
......
......@@ -136,7 +136,7 @@ VP9D_PTR vp9_create_decompressor(VP9D_CONFIG *oxcf) {
// vp9_init_dequantizer() for every frame.
vp9_init_dequantizer(&pbi->common);
vp9_loop_filter_init(&pbi->common);
vp9_loop_filter_init(&pbi->common, &pbi->mb.lf);
pbi->common.error.setjmp = 0;
pbi->decoded_key_frame = 0;
......@@ -346,9 +346,9 @@ int vp9_receive_compressed_data(VP9D_PTR ptr,
cm->current_video_frame + 1000);
#endif
if (cm->filter_level) {
if (pbi->mb.lf.filter_level) {
/* Apply the loop filter if appropriate. */
vp9_loop_filter_frame(cm, &pbi->mb, cm->filter_level, 0);
vp9_loop_filter_frame(cm, &pbi->mb, pbi->mb.lf.filter_level, 0);
}
#if WRITE_RECON_BUFFER == 2
......@@ -413,7 +413,7 @@ int vp9_get_raw_frame(VP9D_PTR ptr, YV12_BUFFER_CONFIG *sd,
*time_end_stamp = 0;
#if CONFIG_POSTPROC
ret = vp9_post_proc_frame(&pbi->common, sd, flags);
ret = vp9_post_proc_frame(&pbi->common, &pbi->mb.lf, sd, flags);
#else
if (pbi->common.frame_to_show) {
......
......@@ -925,29 +925,29 @@ static void update_coef_probs(VP9_COMP* const cpi, vp9_writer* const bc) {
update_coef_probs_common(bc, cpi, TX_32X32);
}
static void encode_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd,
static void encode_loopfilter(struct loopfilter *lf,
struct vp9_write_bit_buffer *wb) {
int i;
// Encode the loop filter level and type
vp9_wb_write_literal(wb, pc->filter_level, 6);
vp9_wb_write_literal(wb, pc->sharpness_level, 3);
vp9_wb_write_literal(wb, lf->filter_level, 6);
vp9_wb_write_literal(wb, lf->sharpness_level, 3);
// Write out loop filter deltas applied at the MB level based on mode or
// ref frame (if they are enabled).
vp9_wb_write_bit(wb, xd->mode_ref_lf_delta_enabled);
vp9_wb_write_bit(wb, lf->mode_ref_delta_enabled);
if (xd->mode_ref_lf_delta_enabled) {
if (lf->mode_ref_delta_enabled) {
// Do the deltas need to be updated
vp9_wb_write_bit(wb, xd->mode_ref_lf_delta_update);
if (xd->mode_ref_lf_delta_update) {
vp9_wb_write_bit(wb, lf->mode_ref_delta_update);
if (lf->mode_ref_delta_update) {
// Send update
for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
const int delta = xd->ref_lf_deltas[i];
const int delta = lf->ref_deltas[i];
// Frame level data
if (delta != xd->last_ref_lf_deltas[i]) {
xd->last_ref_lf_deltas[i] = delta;
if (delta != lf->last_ref_deltas[i]) {
lf->last_ref_deltas[i] = delta;
vp9_wb_write_bit(wb, 1);
assert(delta != 0);
......@@ -960,9 +960,9 @@ static void encode_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd,
// Send update
for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
const int delta = xd->mode_lf_deltas[i];
if (delta != xd->last_mode_lf_deltas[i]) {
xd->last_mode_lf_deltas[i] = delta;
const int delta = lf->mode_deltas[i];
if (delta != lf->last_mode_deltas[i]) {
lf->last_mode_deltas[i] = delta;
vp9_wb_write_bit(wb, 1);
assert(delta != 0);
......@@ -1372,7 +1372,7 @@ static void write_uncompressed_header(VP9_COMP *cpi,
vp9_wb_write_literal(wb, cm->frame_context_idx, NUM_FRAME_CONTEXTS_LOG2);
encode_loopfilter(cm, xd, wb);
encode_loopfilter(&xd->lf, wb);
encode_quantization(cm, wb);
encode_segmentation(cpi, wb);
......
......@@ -1952,7 +1952,7 @@ static void switch_lossless_mode(VP9_COMP *cpi, int lossless) {
cpi->mb.e_mbd.inv_txm4x4_1_add = vp9_short_iwalsh4x4_1_add;
cpi->mb.e_mbd.inv_txm4x4_add = vp9_short_iwalsh4x4_add;
cpi->mb.optimize = 0;
cpi->common.filter_level = 0;
cpi->mb.e_mbd.lf.filter_level = 0;
cpi->zbin_mode_boost_enabled = 0;
cpi->common.tx_mode = ONLY_4X4;
} else {
......
......@@ -243,6 +243,7 @@ void vp9_initialize_enc() {
static void setup_features(VP9_COMP *cpi) {
MACROBLOCKD *xd = &cpi->mb.e_mbd;
struct loopfilter *lf = &xd->lf;
// Set up default state for MB feature flags
xd->seg.enabled = 0;
......@@ -253,12 +254,12 @@ static void setup_features(VP9_COMP *cpi) {
vp9_clearall_segfeatures(&xd->seg);
xd->mode_ref_lf_delta_enabled = 0;
xd->mode_ref_lf_delta_update = 0;
vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));
vpx_memset(xd->last_ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
vpx_memset(xd->last_mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));
lf->mode_ref_delta_enabled = 0;
lf->mode_ref_delta_update = 0;
vp9_zero(lf->ref_deltas);
vp9_zero(lf->mode_deltas);
vp9_zero(lf->last_ref_deltas);
vp9_zero(lf->last_mode_deltas);
set_default_lf_deltas(cpi);
}
......@@ -544,20 +545,22 @@ static void update_reference_segmentation_map(VP9_COMP *cpi) {
}
static void set_default_lf_deltas(VP9_COMP *cpi) {
cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
struct loopfilter *lf = &cpi->mb.e_mbd.lf;
vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
lf->mode_ref_delta_enabled = 1;
lf->mode_ref_delta_update = 1;
vp9_zero(lf->ref_deltas);
vp9_zero(lf->mode_deltas);
// Test of ref frame deltas
cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
lf->ref_deltas[INTRA_FRAME] = 2;
lf->ref_deltas[LAST_FRAME] = 0;
lf->ref_deltas[GOLDEN_FRAME] = -2;
lf->ref_deltas[ALTREF_FRAME] = -2;
cpi->mb.e_mbd.mode_lf_deltas[0] = 0; // Zero
cpi->mb.e_mbd.mode_lf_deltas[1] = 0; // New mv
lf->mode_deltas[0] = 0; // Zero
lf->mode_deltas[1] = 0; // New mv
}
static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode, int speed) {
......@@ -1285,7 +1288,7 @@ void vp9_change_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
// VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
cpi->oxcf.Sharpness = MIN(7, cpi->oxcf.Sharpness);
cm->sharpness_level = cpi->oxcf.Sharpness;
cpi->mb.e_mbd.lf.sharpness_level = cpi->oxcf.Sharpness;
if (cpi->initial_width) {
// Increasing the size of the frame beyond the first seen frame, or some
......@@ -1688,7 +1691,7 @@ VP9_PTR vp9_create_compressor(VP9_CONFIG *oxcf) {
*/
vp9_init_quantizer(cpi);
vp9_loop_filter_init(cm);
vp9_loop_filter_init(cm, &cpi->mb.e_mbd.lf);
cpi->common.error.setjmp = 0;
......@@ -2408,8 +2411,9 @@ static void update_reference_frames(VP9_COMP * const cpi) {
}
static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
if (cpi->mb.e_mbd.lossless) {
cm->filter_level = 0;
MACROBLOCKD *xd = &cpi->mb.e_mbd;
if (xd->lossless) {
xd->lf.filter_level = 0;
} else {
struct vpx_usec_timer timer;
......@@ -2423,14 +2427,13 @@ static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
}
if (cm->filter_level > 0) {
vp9_set_alt_lf_level(cpi, cm->filter_level);
vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, cm->filter_level, 0);
if (xd->lf.filter_level > 0) {
vp9_set_alt_lf_level(cpi, xd->lf.filter_level);
vp9_loop_filter_frame(cm, xd, xd->lf.filter_level, 0);
}
vp9_extend_frame_inner_borders(cm->frame_to_show,
cm->subsampling_x, cm->subsampling_y);
cm->subsampling_x, cm->subsampling_y);
}
static void scale_references(VP9_COMP *cpi) {
......@@ -2585,7 +2588,7 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi,
}
// Set default state for segment based loop filter update flags
xd->mode_ref_lf_delta_update = 0;
xd->lf.mode_ref_delta_update = 0;
// Set various flags etc to special state if it is a key frame
......@@ -3438,7 +3441,7 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi,
// Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
xd->seg.update_map = 0;
xd->seg.update_data = 0;
xd->mode_ref_lf_delta_update = 0;
xd->lf.mode_ref_delta_update = 0;
// keep track of the last coded dimensions
cm->last_width = cm->width;
......@@ -3547,7 +3550,7 @@ static int frame_is_reference(const VP9_COMP *cpi) {
cpi->refresh_golden_frame ||
cpi->refresh_alt_ref_frame ||
cm->refresh_frame_context ||
mb->mode_ref_lf_delta_update ||
mb->lf.mode_ref_delta_update ||
mb->seg.update_map ||
mb->seg.update_data;
}
......@@ -3953,7 +3956,7 @@ int vp9_get_preview_raw_frame(VP9_PTR comp, YV12_BUFFER_CONFIG *dest,
else {
int ret;
#if CONFIG_POSTPROC
ret = vp9_post_proc_frame(&cpi->common, dest, flags);
ret = vp9_post_proc_frame(&cpi->common, &cpi->mb.e_mbd.lf, dest, flags);
#else
if (cpi->common.frame_to_show) {
......
......@@ -127,6 +127,7 @@ void vp9_set_alt_lf_level(VP9_COMP *cpi, int filt_val) {
void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi) {
VP9_COMMON *cm = &cpi->common;
struct loopfilter *lf = &cpi->mb.e_mbd.lf;
int best_err = 0;
int filt_err = 0;
......@@ -135,7 +136,8 @@ void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi) {
int filter_step;
int filt_high = 0;
int filt_mid = cm->filter_level; // Start search at previous frame filter level
// Start search at previous frame filter level
int filt_mid = lf->filter_level;
int filt_low = 0;
int filt_best;
int filt_direction = 0;
......@@ -146,12 +148,12 @@ void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi) {
vp8_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
if (cm->frame_type == KEY_FRAME)
cm->sharpness_level = 0;
lf->sharpness_level = 0;
else
cm->sharpness_level = cpi->oxcf.Sharpness;
lf->sharpness_level = cpi->oxcf.Sharpness;
// Start the search at the previous frame filter level unless it is now out of range.
filt_mid = cm->filter_level;
filt_mid = lf->filter_level;
if (filt_mid < min_filter_level)
filt_mid = min_filter_level;
......@@ -232,5 +234,5 @@ void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi) {
}
}
cm->filter_level = filt_best;
lf->filter_level = filt_best;
}
......@@ -99,8 +99,8 @@ void vp9_save_coding_context(VP9_COMP *cpi) {
vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy,
cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols));
vp9_copy(cc->last_ref_lf_deltas, xd->last_ref_lf_deltas);
vp9_copy(cc->last_mode_lf_deltas, xd->last_mode_lf_deltas);
vp9_copy(cc->last_ref_lf_deltas, xd->lf.last_ref_deltas);
vp9_copy(cc->last_mode_lf_deltas, xd->lf.last_mode_deltas);
vp9_copy(cc->coef_probs, cm->fc.coef_probs);
vp9_copy(cc->switchable_interp_prob, cm->fc.switchable_interp_prob);
......@@ -138,8 +138,8 @@ void vp9_restore_coding_context(VP9_COMP *cpi) {
cpi->coding_context.last_frame_seg_map_copy,
(cm->mi_rows * cm->mi_cols));
vp9_copy(xd->last_ref_lf_deltas, cc->last_ref_lf_deltas);
vp9_copy(xd->last_mode_lf_deltas, cc->last_mode_lf_deltas);
vp9_copy(xd->lf.last_ref_deltas, cc->last_ref_lf_deltas);
vp9_copy(xd->lf.last_mode_deltas, cc->last_mode_lf_deltas);
vp9_copy(cm->fc.coef_probs, cc->coef_probs);
vp9_copy(cm->fc.switchable_interp_prob, cc->switchable_interp_prob);
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment