ref: ee1771ebaaac5c4c799e3bd09241aed47b866bc4
parent: f00a237a43b86298f18ff9f09c29c4cf965f6d04
author: Dmitry Kovalev <dkovalev@google.com>
date: Wed Jul 17 14:37:45 EDT 2013
Moving all loop filter related variables into new struct. Adding loopfilter struct with fields from MACROBLOCKD and VP9Common. Eventually it will be moved to vp9_loopfilter.h for better code structure. Change-Id: Iaf5fb71c33719cdfa1b991f671caf071be9ea035
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -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 @@
#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];
@@ -231,25 +249,11 @@
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;
--- a/vp9/common/vp9_entropymode.c
+++ b/vp9/common/vp9_entropymode.c
@@ -553,16 +553,16 @@
}
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) {@@ -575,8 +575,8 @@
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);
@@ -585,7 +585,7 @@
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);
--- a/vp9/common/vp9_loopfilter.c
+++ b/vp9/common/vp9_loopfilter.c
@@ -55,13 +55,13 @@
}
}
-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 @@
// 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,7 +98,7 @@
: 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);
@@ -104,13 +105,13 @@
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);
}
}
--- a/vp9/common/vp9_loopfilter.h
+++ b/vp9/common/vp9_loopfilter.h
@@ -46,7 +46,7 @@
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,
--- a/vp9/common/vp9_onyxc_int.h
+++ b/vp9/common/vp9_onyxc_int.h
@@ -202,10 +202,6 @@
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 */
--- a/vp9/common/vp9_postproc.c
+++ b/vp9/common/vp9_postproc.c
@@ -630,9 +630,11 @@
}
}
-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;
--- a/vp9/common/vp9_postproc.h
+++ b/vp9/common/vp9_postproc.h
@@ -26,8 +26,8 @@
#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);
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -438,30 +438,29 @@
}
}
-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);
}
}
}
@@ -796,7 +795,7 @@
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;
}
@@ -880,9 +879,9 @@
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);
--- a/vp9/decoder/vp9_onyxd_if.c
+++ b/vp9/decoder/vp9_onyxd_if.c
@@ -136,7 +136,7 @@
// 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 @@
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 @@
*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) {--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -925,29 +925,29 @@
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 @@
// 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 @@
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);
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -1953,7 +1953,7 @@
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 {--- a/vp9/encoder/vp9_onyx_if.c
+++ b/vp9/encoder/vp9_onyx_if.c
@@ -243,6 +243,7 @@
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 @@
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 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 @@
// 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_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 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 @@
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 @@
}
// 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 @@
// 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 @@
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 @@
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) {--- a/vp9/encoder/vp9_picklpf.c
+++ b/vp9/encoder/vp9_picklpf.c
@@ -127,6 +127,7 @@
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 @@
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 @@
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 @@
}
}
- cm->filter_level = filt_best;
+ lf->filter_level = filt_best;
}
--- a/vp9/encoder/vp9_ratectrl.c
+++ b/vp9/encoder/vp9_ratectrl.c
@@ -137,8 +137,8 @@
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);
@@ -176,8 +176,8 @@
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);