From 3eb10fcf212750b9029556b8181ef0d8e1473f28 Mon Sep 17 00:00:00 2001 From: Debargha Mukherjee Date: Wed, 27 Jan 2016 13:01:27 -0800 Subject: [PATCH] Cosmetic changes to loop restoration Also adds a normalized filtering function to be used later. Change-Id: I30e2140e664db635602f26a73b81ce8e008dff5e --- vp10/common/entropymode.c | 4 +- vp10/common/loopfilter.c | 274 +++++++++++++++++++++++-------------- vp10/common/loopfilter.h | 98 ++++++------- vp10/decoder/decodeframe.c | 22 +-- vp10/encoder/bitstream.c | 10 +- vp10/encoder/encoder.c | 10 +- vp10/encoder/picklpf.c | 92 ++++++------- 7 files changed, 289 insertions(+), 221 deletions(-) diff --git a/vp10/common/entropymode.c b/vp10/common/entropymode.c index 1a8562a14..98e754d47 100644 --- a/vp10/common/entropymode.c +++ b/vp10/common/entropymode.c @@ -1538,8 +1538,8 @@ void vp10_setup_past_independence(VP10_COMMON *cm) { // To force update of the sharpness lf->last_sharpness_level = -1; #if CONFIG_LOOP_RESTORATION - lf->bilateral_level = 0; - lf->last_bilateral_level = 0; + lf->restoration_level = 0; + lf->last_restoration_level = 0; #endif // CONFIG_LOOP_RESTORATION vp10_default_coef_probs(cm); diff --git a/vp10/common/loopfilter.c b/vp10/common/loopfilter.c index a4845339d..d4381f825 100644 --- a/vp10/common/loopfilter.c +++ b/vp10/common/loopfilter.c @@ -216,87 +216,90 @@ static const int mode_lf_lut[MB_MODE_COUNT] = { }; #if CONFIG_LOOP_RESTORATION -#define BILATERAL_RANGE 256 -#define BILATERAL_RANGE_SYM (2 * BILATERAL_RANGE + 1) -static double bilateral_filters_r_kf[BILATERAL_LEVELS_KF + 1] - [BILATERAL_RANGE_SYM]; -static double bilateral_filters_r[BILATERAL_LEVELS + 1][BILATERAL_RANGE_SYM]; -static double bilateral_filters_s_kf[BILATERAL_LEVELS_KF + 1] - [BILATERAL_WIN][BILATERAL_WIN]; -static double bilateral_filters_s[BILATERAL_LEVELS + 1] - [BILATERAL_WIN][BILATERAL_WIN]; - -void vp10_loop_bilateral_precal() { +#define RESTORATION_RANGE 256 +#define RESTORATION_RANGE_SYM (2 * RESTORATION_RANGE + 1) +static double restoration_filters_r_kf[RESTORATION_LEVELS_KF + 1] + [RESTORATION_RANGE_SYM]; +static double restoration_filters_r[RESTORATION_LEVELS + 1] + [RESTORATION_RANGE_SYM]; +static double restoration_filters_s_kf[RESTORATION_LEVELS_KF + 1] + [RESTORATION_WIN][RESTORATION_WIN]; +static double restoration_filters_s[RESTORATION_LEVELS + 1] + [RESTORATION_WIN][RESTORATION_WIN]; + +void vp10_loop_restoration_precal() { int i; - for (i = 1; i < BILATERAL_LEVELS_KF + 1; i ++) { - const bilateral_params_t param = vp10_bilateral_level_to_params(i, 1); + for (i = 1; i < RESTORATION_LEVELS_KF + 1; i ++) { + const restoration_params_t param = vp10_restoration_level_to_params(i, 1); const int sigma_x = param.sigma_x; const int sigma_y = param.sigma_y; const int sigma_r = param.sigma_r; - const double sigma_r_d = (double)sigma_r / BILATERAL_PRECISION; - const double sigma_x_d = (double)sigma_x / BILATERAL_PRECISION; - const double sigma_y_d = (double)sigma_y / BILATERAL_PRECISION; + const double sigma_r_d = (double)sigma_r / RESTORATION_PRECISION; + const double sigma_x_d = (double)sigma_x / RESTORATION_PRECISION; + const double sigma_y_d = (double)sigma_y / RESTORATION_PRECISION; - double *fr = bilateral_filters_r_kf[i] + BILATERAL_RANGE; + double *fr = restoration_filters_r_kf[i] + RESTORATION_RANGE; int j, x, y; - for (j = 0; j <= BILATERAL_RANGE; j++) { + for (j = 0; j <= RESTORATION_RANGE; j++) { fr[j] = exp(-(j * j) / (2 * sigma_r_d * sigma_r_d)); fr[-j] = fr[j]; } - for (y = -BILATERAL_HALFWIN; y <= BILATERAL_HALFWIN; y++) { - for (x = -BILATERAL_HALFWIN; x <= BILATERAL_HALFWIN; x++) { - bilateral_filters_s_kf[i][y + BILATERAL_HALFWIN] - [x + BILATERAL_HALFWIN] = + for (y = -RESTORATION_HALFWIN; y <= RESTORATION_HALFWIN; y++) { + for (x = -RESTORATION_HALFWIN; x <= RESTORATION_HALFWIN; x++) { + restoration_filters_s_kf[i][y + RESTORATION_HALFWIN] + [x + RESTORATION_HALFWIN] = exp(-(x * x) / (2 * sigma_x_d * sigma_x_d) -(y * y) / (2 * sigma_y_d * sigma_y_d)); } } } - for (i = 1; i < BILATERAL_LEVELS + 1; i ++) { - const bilateral_params_t param = vp10_bilateral_level_to_params(i, 0); + for (i = 1; i < RESTORATION_LEVELS + 1; i ++) { + const restoration_params_t param = vp10_restoration_level_to_params(i, 0); const int sigma_x = param.sigma_x; const int sigma_y = param.sigma_y; const int sigma_r = param.sigma_r; - const double sigma_r_d = (double)sigma_r / BILATERAL_PRECISION; - const double sigma_x_d = (double)sigma_x / BILATERAL_PRECISION; - const double sigma_y_d = (double)sigma_y / BILATERAL_PRECISION; + const double sigma_r_d = (double)sigma_r / RESTORATION_PRECISION; + const double sigma_x_d = (double)sigma_x / RESTORATION_PRECISION; + const double sigma_y_d = (double)sigma_y / RESTORATION_PRECISION; - double *fr = bilateral_filters_r[i] + BILATERAL_RANGE; + double *fr = restoration_filters_r[i] + RESTORATION_RANGE; int j, x, y; - for (j = 0; j <= BILATERAL_RANGE; j++) { + for (j = 0; j <= RESTORATION_RANGE; j++) { fr[j] = exp(-(j * j) / (2 * sigma_r_d * sigma_r_d)); fr[-j] = fr[j]; } - for (y = -BILATERAL_HALFWIN; y <= BILATERAL_HALFWIN; y++) { - for (x = -BILATERAL_HALFWIN; x <= BILATERAL_HALFWIN; x++) { - bilateral_filters_s[i][y + BILATERAL_HALFWIN][x + BILATERAL_HALFWIN] = - exp(-(x * x) / (2 * sigma_x_d * sigma_x_d) - -(y * y) / (2 * sigma_y_d * sigma_y_d)); + for (y = -RESTORATION_HALFWIN; y <= RESTORATION_HALFWIN; y++) { + for (x = -RESTORATION_HALFWIN; x <= RESTORATION_HALFWIN; x++) { + restoration_filters_s + [i][y + RESTORATION_HALFWIN][x + RESTORATION_HALFWIN] = + exp(-(x * x) / (2 * sigma_x_d * sigma_x_d) + -(y * y) / (2 * sigma_y_d * sigma_y_d)); } } } } -int vp10_bilateral_level_bits(const VP10_COMMON *const cm) { +int vp10_restoration_level_bits(const VP10_COMMON *const cm) { return cm->frame_type == KEY_FRAME ? - BILATERAL_LEVEL_BITS_KF : BILATERAL_LEVEL_BITS; + RESTORATION_LEVEL_BITS_KF : RESTORATION_LEVEL_BITS; } -int vp10_loop_bilateral_used(int level, int kf) { - const bilateral_params_t param = vp10_bilateral_level_to_params(level, kf); +int vp10_loop_restoration_used(int level, int kf) { + const restoration_params_t param = + vp10_restoration_level_to_params(level, kf); return (param.sigma_x && param.sigma_y && param.sigma_r); } -void vp10_loop_bilateral_init(loop_filter_info_n *lfi, int level, int kf) { - lfi->bilateral_used = vp10_loop_bilateral_used(level, kf); +void vp10_loop_restoration_init(loop_filter_info_n *lfi, int level, int kf) { + lfi->restoration_used = vp10_loop_restoration_used(level, kf); - if (lfi->bilateral_used) { + if (lfi->restoration_used) { int i; - lfi->wr_lut = kf ? bilateral_filters_r_kf[level] : - bilateral_filters_r[level]; - for (i = 0; i < BILATERAL_WIN; i++) - lfi->wx_lut[i] = kf ? bilateral_filters_s_kf[level][i] : - bilateral_filters_s[level][i]; + lfi->wr_lut = kf ? restoration_filters_r_kf[level] : + restoration_filters_r[level]; + for (i = 0; i < RESTORATION_WIN; i++) + lfi->wx_lut[i] = kf ? restoration_filters_s_kf[level][i] : + restoration_filters_s[level][i]; } } @@ -304,11 +307,11 @@ static int is_in_image(int x, int y, int width, int height) { return (x >= 0 && x < width && y >= 0 && y < height); } -void loop_bilateral_filter(uint8_t *data, int width, int height, - int stride, loop_filter_info_n *lfi, - uint8_t *tmpdata, int tmpstride) { +void loop_restoration_filter(uint8_t *data, int width, int height, + int stride, loop_filter_info_n *lfi, + uint8_t *tmpdata, int tmpstride) { int i, j; - const double *wr_lut_ = lfi->wr_lut + 256; + const double *wr_lut_ = lfi->wr_lut + RESTORATION_RANGE; uint8_t *data_p = data; uint8_t *tmpdata_p = tmpdata; @@ -316,12 +319,12 @@ void loop_bilateral_filter(uint8_t *data, int width, int height, for (j = 0; j < width; ++j) { int x, y; double flsum = 0, wtsum = 0, wt; - uint8_t *data_p2 = data_p + j - BILATERAL_HALFWIN * stride; - for (y = -BILATERAL_HALFWIN; y <= BILATERAL_HALFWIN; ++y) { - for (x = -BILATERAL_HALFWIN; x <= BILATERAL_HALFWIN; ++x) { + uint8_t *data_p2 = data_p + j - RESTORATION_HALFWIN * stride; + for (y = -RESTORATION_HALFWIN; y <= RESTORATION_HALFWIN; ++y) { + for (x = -RESTORATION_HALFWIN; x <= RESTORATION_HALFWIN; ++x) { if (!is_in_image(j + x, i + y, width, height)) continue; - wt = lfi->wx_lut[y + BILATERAL_HALFWIN][x + BILATERAL_HALFWIN] * + wt = lfi->wx_lut[y + RESTORATION_HALFWIN][x + RESTORATION_HALFWIN] * wr_lut_[data_p2[x] - data_p[j]]; wtsum += wt; flsum += wt * data_p2[x]; @@ -341,13 +344,43 @@ void loop_bilateral_filter(uint8_t *data, int width, int height, } } -#if CONFIG_VP9_HIGHBITDEPTH -void loop_bilateral_filter_highbd(uint8_t *data8, int width, int height, +// Normalized non-separable filter where weights all sum to 1 +void loop_restoration_filter_norm(uint8_t *data, int width, int height, int stride, loop_filter_info_n *lfi, - uint8_t *tmpdata8, int tmpstride, - int bit_depth) { + uint8_t *tmpdata, int tmpstride) { + int i, j; + uint8_t *data_p = data; + uint8_t *tmpdata_p = tmpdata; + for (i = RESTORATION_HALFWIN; i < height - RESTORATION_HALFWIN; ++i) { + for (j = RESTORATION_HALFWIN; j < width - RESTORATION_HALFWIN; ++j) { + int x, y; + double flsum = 0; + uint8_t *data_p2 = data_p + j - RESTORATION_HALFWIN * stride; + for (y = -RESTORATION_HALFWIN; y <= RESTORATION_HALFWIN; ++y) { + for (x = -RESTORATION_HALFWIN; x <= RESTORATION_HALFWIN; ++x) { + flsum += data_p2[x] * + lfi->wx_lut[y + RESTORATION_HALFWIN][x + RESTORATION_HALFWIN]; + } + data_p2 += stride; + } + tmpdata_p[j] = clip_pixel((int)(flsum + 0.5)); + } + tmpdata_p += tmpstride; + data_p += stride; + } + for (i = 0; i < height; ++i) { + memcpy(data + i * stride, tmpdata + i * tmpstride, + width * sizeof(*data)); + } +} + +#if CONFIG_VP9_HIGHBITDEPTH +void loop_restoration_filter_highbd(uint8_t *data8, int width, int height, + int stride, loop_filter_info_n *lfi, + uint8_t *tmpdata8, int tmpstride, + int bit_depth) { int i, j; - const double *wr_lut_ = lfi->wr_lut + 256; + const double *wr_lut_ = lfi->wr_lut + RESTORATION_RANGE; uint16_t *data = CONVERT_TO_SHORTPTR(data8); uint16_t *tmpdata = CONVERT_TO_SHORTPTR(tmpdata8); @@ -357,17 +390,17 @@ void loop_bilateral_filter_highbd(uint8_t *data8, int width, int height, for (j = 0; j < width; ++j) { int x, y, diff_r; double flsum = 0, wtsum = 0, wt; - uint16_t *data_p2 = data_p + j - BILATERAL_HALFWIN * stride; + uint16_t *data_p2 = data_p + j - RESTORATION_HALFWIN * stride; - for (y = -BILATERAL_HALFWIN; y <= BILATERAL_HALFWIN; ++y) { - for (x = -BILATERAL_HALFWIN; x <= BILATERAL_HALFWIN; ++x) { + for (y = -RESTORATION_HALFWIN; y <= RESTORATION_HALFWIN; ++y) { + for (x = -RESTORATION_HALFWIN; x <= RESTORATION_HALFWIN; ++x) { if (!is_in_image(j + x, i + y, width, height)) continue; diff_r = (data_p2[x] - data_p[j]) >> (bit_depth - 8); - assert(diff_r >= -256 && diff_r <= 256); + assert(diff_r >= -RESTORATION_RANGE && diff_r <= RESTORATION_RANGE); - wt = lfi->wx_lut[y + BILATERAL_HALFWIN][x + BILATERAL_HALFWIN] * + wt = lfi->wx_lut[y + RESTORATION_HALFWIN][x + RESTORATION_HALFWIN] * wr_lut_[diff_r]; wtsum += wt; flsum += wt * data_p2[x]; @@ -381,7 +414,38 @@ void loop_bilateral_filter_highbd(uint8_t *data8, int width, int height, tmpdata_p += tmpstride; data_p += stride; } + for (i = 0; i < height; ++i) { + memcpy(data + i * stride, tmpdata + i * tmpstride, + width * sizeof(*data)); + } +} +// Normalized non-separable filter where weights all sum to 1 +void loop_restoration_filter_norm(uint8_t *data8, int width, int height, + int stride, loop_filter_info_n *lfi, + uint8_t *tmpdata8, int tmpstride) { + int i, j; + uint16_t *data = CONVERT_TO_SHORTPTR(data8); + uint16_t *tmpdata = CONVERT_TO_SHORTPTR(tmpdata8); + uint16_t *data_p = data; + uint16_t *tmpdata_p = tmpdata; + for (i = RESTORATION_HALFWIN; i < height - RESTORATION_HALFWIN; ++i) { + for (j = RESTORATION_HALFWIN; j < width - RESTORATION_HALFWIN; ++j) { + int x, y; + double flsum = 0; + uint16_t *data_p2 = data_p + j - RESTORATION_HALFWIN * stride; + for (y = -RESTORATION_HALFWIN; y <= RESTORATION_HALFWIN; ++y) { + for (x = -RESTORATION_HALFWIN; x <= RESTORATION_HALFWIN; ++x) { + flsum += data_p2[x] * + lfi->wx_lut[y + RESTORATION_HALFWIN][x + RESTORATION_HALFWIN]; + } + data_p2 += stride; + } + tmpdata_p[j] = (int)(flsum + 0.5); + } + tmpdata_p += tmpstride; + data_p += stride; + } for (i = 0; i < height; ++i) { memcpy(data + i * stride, tmpdata + i * tmpstride, width * sizeof(*data)); @@ -389,10 +453,10 @@ void loop_bilateral_filter_highbd(uint8_t *data8, int width, int height, } #endif // CONFIG_VP9_HIGHBITDEPTH -void vp10_loop_bilateral_rows(YV12_BUFFER_CONFIG *frame, - VP10_COMMON *cm, - int start_mi_row, int end_mi_row, - int y_only) { +void vp10_loop_restoration_rows(YV12_BUFFER_CONFIG *frame, + VP10_COMMON *cm, + int start_mi_row, int end_mi_row, + int y_only) { const int ywidth = frame->y_crop_width; const int ystride = frame->y_stride; const int uvwidth = frame->uv_crop_width; @@ -419,39 +483,43 @@ void vp10_loop_bilateral_rows(YV12_BUFFER_CONFIG *frame, #if CONFIG_VP9_HIGHBITDEPTH if (cm->use_highbitdepth) - loop_bilateral_filter_highbd(frame->y_buffer + ystart * ystride, - ywidth, yend - ystart, ystride, &cm->lf_info, - tmp_buf->y_buffer + ystart * tmp_buf->y_stride, - tmp_buf->y_stride, cm->bit_depth); + loop_restoration_filter_highbd( + frame->y_buffer + ystart * ystride, + ywidth, yend - ystart, ystride, &cm->lf_info, + tmp_buf->y_buffer + ystart * tmp_buf->y_stride, + tmp_buf->y_stride, cm->bit_depth); else #endif // CONFIG_VP9_HIGHBITDEPTH - loop_bilateral_filter(frame->y_buffer + ystart * ystride, - ywidth, yend - ystart, ystride, &cm->lf_info, - tmp_buf->y_buffer + ystart * tmp_buf->y_stride, - tmp_buf->y_stride); + loop_restoration_filter( + frame->y_buffer + ystart * ystride, + ywidth, yend - ystart, ystride, &cm->lf_info, + tmp_buf->y_buffer + ystart * tmp_buf->y_stride, + tmp_buf->y_stride); if (!y_only) { #if CONFIG_VP9_HIGHBITDEPTH - if (cm->use_highbitdepth) { - loop_bilateral_filter_highbd( - frame->u_buffer + uvstart * uvstride, - uvwidth, uvend - uvstart, uvstride, &cm->lf_info, - tmp_buf->u_buffer + uvstart * tmp_buf->uv_stride, - tmp_buf->uv_stride, cm->bit_depth); - loop_bilateral_filter_highbd( - frame->v_buffer + uvstart * uvstride, - uvwidth, uvend - uvstart, uvstride, &cm->lf_info, - tmp_buf->v_buffer + uvstart * tmp_buf->uv_stride, - tmp_buf->uv_stride, cm->bit_depth); + if (cm->use_highbitdepth) { + loop_restoration_filter_highbd( + frame->u_buffer + uvstart * uvstride, + uvwidth, uvend - uvstart, uvstride, &cm->lf_info, + tmp_buf->u_buffer + uvstart * tmp_buf->uv_stride, + tmp_buf->uv_stride, cm->bit_depth); + loop_restoration_filter_highbd( + frame->v_buffer + uvstart * uvstride, + uvwidth, uvend - uvstart, uvstride, &cm->lf_info, + tmp_buf->v_buffer + uvstart * tmp_buf->uv_stride, + tmp_buf->uv_stride, cm->bit_depth); } else { #endif // CONFIG_VP9_HIGHBITDEPTH - loop_bilateral_filter(frame->u_buffer + uvstart * uvstride, - uvwidth, uvend - uvstart, uvstride, &cm->lf_info, - tmp_buf->u_buffer + uvstart * tmp_buf->uv_stride, - tmp_buf->uv_stride); - loop_bilateral_filter(frame->v_buffer + uvstart * uvstride, - uvwidth, uvend - uvstart, uvstride, &cm->lf_info, - tmp_buf->v_buffer + uvstart * tmp_buf->uv_stride, - tmp_buf->uv_stride); + loop_restoration_filter( + frame->u_buffer + uvstart * uvstride, + uvwidth, uvend - uvstart, uvstride, &cm->lf_info, + tmp_buf->u_buffer + uvstart * tmp_buf->uv_stride, + tmp_buf->uv_stride); + loop_restoration_filter( + frame->v_buffer + uvstart * uvstride, + uvwidth, uvend - uvstart, uvstride, &cm->lf_info, + tmp_buf->v_buffer + uvstart * tmp_buf->uv_stride, + tmp_buf->uv_stride); #if CONFIG_VP9_HIGHBITDEPTH } #endif // CONFIG_VP9_HIGHBITDEPTH @@ -501,7 +569,7 @@ void vp10_loop_filter_init(VP10_COMMON *cm) { memset(lfi->lfthr[lvl].hev_thr, (lvl >> 4), SIMD_WIDTH); #if CONFIG_LOOP_RESTORATION - vp10_loop_bilateral_precal(); + vp10_loop_restoration_precal(); #endif // CONFIG_LOOP_RESTORATION } @@ -1973,16 +2041,16 @@ void vp10_loop_filter_data_reset( } #if CONFIG_LOOP_RESTORATION -void vp10_loop_bilateral_frame(YV12_BUFFER_CONFIG *frame, +void vp10_loop_restoration_frame(YV12_BUFFER_CONFIG *frame, VP10_COMMON *cm, - int bilateral_level, + int restoration_level, int y_only, int partial_frame) { int start_mi_row, end_mi_row, mi_rows_to_filter; - // const int loop_bilateral_used = vp10_loop_bilateral_used( - // bilateral_level, cm->frame_type == KEY_FRAME); - vp10_loop_bilateral_init(&cm->lf_info, bilateral_level, + // const int loop_restoration_used = vp10_loop_restoration_used( + // restoration_level, cm->frame_type == KEY_FRAME); + vp10_loop_restoration_init(&cm->lf_info, restoration_level, cm->frame_type == KEY_FRAME); - if (!cm->lf_info.bilateral_used) + if (!cm->lf_info.restoration_used) return; start_mi_row = 0; mi_rows_to_filter = cm->mi_rows; @@ -1992,7 +2060,7 @@ void vp10_loop_bilateral_frame(YV12_BUFFER_CONFIG *frame, mi_rows_to_filter = VPXMAX(cm->mi_rows / 8, 8); } end_mi_row = start_mi_row + mi_rows_to_filter; - vp10_loop_bilateral_rows(frame, cm, start_mi_row, end_mi_row, y_only); + vp10_loop_restoration_rows(frame, cm, start_mi_row, end_mi_row, y_only); } #endif // CONFIG_LOOP_RESTORATION diff --git a/vp10/common/loopfilter.h b/vp10/common/loopfilter.h index 02bcb26e9..953a6b842 100644 --- a/vp10/common/loopfilter.h +++ b/vp10/common/loopfilter.h @@ -29,24 +29,24 @@ extern "C" { #define MAX_MODE_LF_DELTAS 2 #if CONFIG_LOOP_RESTORATION -#define BILATERAL_LEVEL_BITS_KF 4 -#define BILATERAL_LEVELS_KF (1 << BILATERAL_LEVEL_BITS_KF) -#define BILATERAL_LEVEL_BITS 3 -#define BILATERAL_LEVELS (1 << BILATERAL_LEVEL_BITS) -#define DEF_BILATERAL_LEVEL 2 +#define RESTORATION_LEVEL_BITS_KF 4 +#define RESTORATION_LEVELS_KF (1 << RESTORATION_LEVEL_BITS_KF) +#define RESTORATION_LEVEL_BITS 3 +#define RESTORATION_LEVELS (1 << RESTORATION_LEVEL_BITS) +#define DEF_RESTORATION_LEVEL 2 -#define BILATERAL_PRECISION 16 -#define BILATERAL_HALFWIN 3 -#define BILATERAL_WIN (2 * BILATERAL_HALFWIN + 1) +#define RESTORATION_PRECISION 16 +#define RESTORATION_HALFWIN 3 +#define RESTORATION_WIN (2 * RESTORATION_HALFWIN + 1) -typedef struct bilateral_params { +typedef struct restoration_params { int sigma_x; // spatial variance x int sigma_y; // spatial variance y int sigma_r; // range variance -} bilateral_params_t; +} restoration_params_t; -static bilateral_params_t - bilateral_level_to_params_arr[BILATERAL_LEVELS + 1] = { +static restoration_params_t + restoration_level_to_params_arr[RESTORATION_LEVELS + 1] = { // Values are rounded to 1/16 th precision {0, 0, 0}, // 0 - default {8, 9, 30}, @@ -59,8 +59,8 @@ static bilateral_params_t {32, 32, 40}, }; -static bilateral_params_t - bilateral_level_to_params_arr_kf[BILATERAL_LEVELS_KF + 1] = { +static restoration_params_t + restoration_level_to_params_arr_kf[RESTORATION_LEVELS_KF + 1] = { // Values are rounded to 1/16 th precision {0, 0, 0}, // 0 - default {8, 8, 30}, @@ -81,13 +81,13 @@ static bilateral_params_t {64, 64, 48}, }; -int vp10_bilateral_level_bits(const struct VP10Common *const cm); -int vp10_loop_bilateral_used(int level, int kf); +int vp10_restoration_level_bits(const struct VP10Common *const cm); +int vp10_loop_restoration_used(int level, int kf); -static INLINE bilateral_params_t vp10_bilateral_level_to_params( +static INLINE restoration_params_t vp10_restoration_level_to_params( int index, int kf) { - return kf ? bilateral_level_to_params_arr_kf[index] : - bilateral_level_to_params_arr[index]; + return kf ? restoration_level_to_params_arr_kf[index] : + restoration_level_to_params_arr[index]; } #endif // CONFIG_LOOP_RESTORATION @@ -116,8 +116,8 @@ struct loopfilter { signed char last_mode_deltas[MAX_MODE_LF_DELTAS]; #if CONFIG_LOOP_RESTORATION - int bilateral_level; - int last_bilateral_level; + int restoration_level; + int last_restoration_level; #endif // CONFIG_LOOP_RESTORATION }; @@ -133,12 +133,12 @@ typedef struct { loop_filter_thresh lfthr[MAX_LOOP_FILTER + 1]; uint8_t lvl[MAX_SEGMENTS][MAX_REF_FRAMES][MAX_MODE_LF_DELTAS]; #if CONFIG_LOOP_RESTORATION - double * wx_lut[BILATERAL_WIN]; - double * wr_lut; - int bilateral_sigma_x_set; - int bilateral_sigma_y_set; - int bilateral_sigma_r_set; - int bilateral_used; + double *wx_lut[RESTORATION_WIN]; + double *wr_lut; + int restoration_sigma_x_set; + int restoration_sigma_y_set; + int restoration_sigma_r_set; + int restoration_used; #endif // CONFIG_LOOP_RESTORATION } loop_filter_info_n; @@ -198,33 +198,33 @@ void vp10_loop_filter_init(struct VP10Common *cm); void vp10_loop_filter_frame_init(struct VP10Common *cm, int default_filt_lvl); void vp10_loop_filter_frame(YV12_BUFFER_CONFIG *frame, - struct VP10Common *cm, - struct macroblockd *mbd, - int filter_level, - int y_only, int partial_frame); + struct VP10Common *cm, + struct macroblockd *mbd, + int filter_level, + int y_only, int partial_frame); // Apply the loop filter to [start, stop) macro block rows in frame_buffer. void vp10_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, - struct VP10Common *cm, - struct macroblockd_plane planes[MAX_MB_PLANE], - int start, int stop, int y_only); + struct VP10Common *cm, + struct macroblockd_plane planes[MAX_MB_PLANE], + int start, int stop, int y_only); #if CONFIG_LOOP_RESTORATION -void vp10_loop_bilateral_frame(YV12_BUFFER_CONFIG *frame, - struct VP10Common *cm, - int bilateral_level, - int y_only, int partial_frame); -void vp10_loop_filter_bilateral_frame(YV12_BUFFER_CONFIG *frame, - struct VP10Common *cm, - struct macroblockd *mbd, - int frame_filter_level, - int bilateral_level, - int y_only, int partial_frame); -void vp10_loop_bilateral_init(loop_filter_info_n *lfi, int T, int kf); -void vp10_loop_bilateral_rows(YV12_BUFFER_CONFIG *frame, - struct VP10Common *cm, - int start_mi_row, int end_mi_row, - int y_only); +void vp10_loop_restoration_frame(YV12_BUFFER_CONFIG *frame, + struct VP10Common *cm, + int restoration_level, + int y_only, int partial_frame); +void vp10_loop_filter_restoration_frame(YV12_BUFFER_CONFIG *frame, + struct VP10Common *cm, + struct macroblockd *mbd, + int frame_filter_level, + int restoration_level, + int y_only, int partial_frame); +void vp10_loop_restoration_init(loop_filter_info_n *lfi, int T, int kf); +void vp10_loop_restoration_rows(YV12_BUFFER_CONFIG *frame, + struct VP10Common *cm, + int start_mi_row, int end_mi_row, + int y_only); #endif // CONFIG_LOOP_RESTORATION typedef struct LoopFilterWorkerData { diff --git a/vp10/decoder/decodeframe.c b/vp10/decoder/decodeframe.c index c2fbc121f..d0c9ffbc2 100644 --- a/vp10/decoder/decodeframe.c +++ b/vp10/decoder/decodeframe.c @@ -2139,17 +2139,17 @@ static void setup_loopfilter(VP10_COMMON *cm, } } #if CONFIG_LOOP_RESTORATION - lf->bilateral_level = vpx_rb_read_bit(rb); - if (lf->bilateral_level) { - int level = vpx_rb_read_literal(rb, vp10_bilateral_level_bits(cm)); - lf->bilateral_level = level + (level >= lf->last_bilateral_level); + lf->restoration_level = vpx_rb_read_bit(rb); + if (lf->restoration_level) { + int level = vpx_rb_read_literal(rb, vp10_restoration_level_bits(cm)); + lf->restoration_level = level + (level >= lf->last_restoration_level); } else { - lf->bilateral_level = lf->last_bilateral_level; + lf->restoration_level = lf->last_restoration_level; } if (cm->frame_type != KEY_FRAME) - cm->lf.last_bilateral_level = cm->lf.bilateral_level; + cm->lf.last_restoration_level = cm->lf.restoration_level; else - cm->lf.last_bilateral_level = 0; + cm->lf.last_restoration_level = 0; #endif // CONFIG_LOOP_RESTORATION } @@ -3481,10 +3481,10 @@ void vp10_decode_frame(VP10Decoder *pbi, *p_data_end = decode_tiles(pbi, data + first_partition_size, data_end); } #if CONFIG_LOOP_RESTORATION - vp10_loop_bilateral_init(&cm->lf_info, cm->lf.bilateral_level, - cm->frame_type == KEY_FRAME); - if (cm->lf_info.bilateral_used) { - vp10_loop_bilateral_rows(new_fb, cm, 0, cm->mi_rows, 0); + vp10_loop_restoration_init(&cm->lf_info, cm->lf.restoration_level, + cm->frame_type == KEY_FRAME); + if (cm->lf_info.restoration_used) { + vp10_loop_restoration_rows(new_fb, cm, 0, cm->mi_rows, 0); } #endif // CONFIG_LOOP_RESTORATION diff --git a/vp10/encoder/bitstream.c b/vp10/encoder/bitstream.c index 0c7967cce..db2e8ee10 100644 --- a/vp10/encoder/bitstream.c +++ b/vp10/encoder/bitstream.c @@ -1778,12 +1778,12 @@ static void encode_loopfilter(VP10_COMMON *cm, } } #if CONFIG_LOOP_RESTORATION - vpx_wb_write_bit(wb, lf->bilateral_level != lf->last_bilateral_level); - if (lf->bilateral_level != lf->last_bilateral_level) { - int level = lf->bilateral_level - - (lf->bilateral_level > lf->last_bilateral_level); + vpx_wb_write_bit(wb, lf->restoration_level != lf->last_restoration_level); + if (lf->restoration_level != lf->last_restoration_level) { + int level = lf->restoration_level - + (lf->restoration_level > lf->last_restoration_level); vpx_wb_write_literal(wb, level, - vp10_bilateral_level_bits(cm)); + vp10_restoration_level_bits(cm)); } #endif // CONFIG_LOOP_RESTORATION } diff --git a/vp10/encoder/encoder.c b/vp10/encoder/encoder.c index 8abe49658..c3e2fcd72 100644 --- a/vp10/encoder/encoder.c +++ b/vp10/encoder/encoder.c @@ -2779,10 +2779,10 @@ static void loopfilter_frame(VP10_COMP *cpi, VP10_COMMON *cm) { #endif } #if CONFIG_LOOP_RESTORATION - vp10_loop_bilateral_init(&cm->lf_info, cm->lf.bilateral_level, + vp10_loop_restoration_init(&cm->lf_info, cm->lf.restoration_level, cm->frame_type == KEY_FRAME); - if (cm->lf_info.bilateral_used) - vp10_loop_bilateral_rows(cm->frame_to_show, cm, 0, cm->mi_rows, 0); + if (cm->lf_info.restoration_used) + vp10_loop_restoration_rows(cm->frame_to_show, cm, 0, cm->mi_rows, 0); #endif // CONFIG_LOOP_RESTORATION vpx_extend_frame_inner_borders(cm->frame_to_show); @@ -3894,9 +3894,9 @@ static void encode_frame_to_data_rate(VP10_COMP *cpi, cm->last_frame_type = cm->frame_type; #if CONFIG_LOOP_RESTORATION if (cm->frame_type != KEY_FRAME) - cm->lf.last_bilateral_level = cm->lf.bilateral_level; + cm->lf.last_restoration_level = cm->lf.restoration_level; else - cm->lf.last_bilateral_level = 0; + cm->lf.last_restoration_level = 0; #endif // CONFIG_LOOP_RESTORATION vp10_rc_postencode_update(cpi, *size); diff --git a/vp10/encoder/picklpf.c b/vp10/encoder/picklpf.c index 9bd1555cb..8f28a3085 100644 --- a/vp10/encoder/picklpf.c +++ b/vp10/encoder/picklpf.c @@ -72,16 +72,16 @@ static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd, } #if CONFIG_LOOP_RESTORATION -#define JOINT_FILTER_BILATERAL_SEARCH +#define JOINT_FILTER_RESTORATION_SEARCH #define USE_RD_LOOP_POSTFILTER_SEARCH -static int try_bilateral_frame(const YV12_BUFFER_CONFIG *sd, - VP10_COMP *const cpi, - int bilateral_level, - int partial_frame) { +static int try_restoration_frame(const YV12_BUFFER_CONFIG *sd, + VP10_COMP *const cpi, + int restoration_level, + int partial_frame) { VP10_COMMON *const cm = &cpi->common; int filt_err; - vp10_loop_bilateral_frame(cm->frame_to_show, cm, - bilateral_level, 1, partial_frame); + vp10_loop_restoration_frame(cm->frame_to_show, cm, + restoration_level, 1, partial_frame); #if CONFIG_VP9_HIGHBITDEPTH if (cm->use_highbitdepth) { filt_err = vp10_highbd_get_y_sse(sd, cm->frame_to_show); @@ -97,16 +97,16 @@ static int try_bilateral_frame(const YV12_BUFFER_CONFIG *sd, return filt_err; } -static int search_bilateral_level(const YV12_BUFFER_CONFIG *sd, - VP10_COMP *cpi, - int filter_level, int partial_frame, - double *best_cost_ret) { +static int search_restoration_level(const YV12_BUFFER_CONFIG *sd, + VP10_COMP *cpi, + int filter_level, int partial_frame, + double *best_cost_ret) { VP10_COMMON *const cm = &cpi->common; - int i, bilateral_best, err; + int i, restoration_best, err; double best_cost; double cost; - const int bilateral_level_bits = vp10_bilateral_level_bits(&cpi->common); - const int bilateral_levels = 1 << bilateral_level_bits; + const int restoration_level_bits = vp10_restoration_level_bits(&cpi->common); + const int restoration_levels = 1 << restoration_level_bits; #ifdef USE_RD_LOOP_POSTFILTER_SEARCH MACROBLOCK *x = &cpi->td.mb; int bits; @@ -118,47 +118,47 @@ static int search_bilateral_level(const YV12_BUFFER_CONFIG *sd, 1, partial_frame); vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_db); - bilateral_best = 0; - err = try_bilateral_frame(sd, cpi, 0, partial_frame); + restoration_best = 0; + err = try_restoration_frame(sd, cpi, 0, partial_frame); #ifdef USE_RD_LOOP_POSTFILTER_SEARCH - bits = cm->lf.last_bilateral_level == 0 ? 0 : bilateral_level_bits; + bits = cm->lf.last_restoration_level == 0 ? 0 : restoration_level_bits; cost = RDCOST_DBL(x->rdmult, x->rddiv, (bits << 2), err); #else cost = (double)err; #endif // USE_RD_LOOP_POSTFILTER_SEARCH best_cost = cost; - for (i = 1; i <= bilateral_levels; ++i) { - err = try_bilateral_frame(sd, cpi, i, partial_frame); + for (i = 1; i <= restoration_levels; ++i) { + err = try_restoration_frame(sd, cpi, i, partial_frame); #ifdef USE_RD_LOOP_POSTFILTER_SEARCH // Normally the rate is rate in bits * 256 and dist is sum sq err * 64 // when RDCOST is used. However below we just scale both in the correct // ratios appropriately but not exactly by these values. - bits = cm->lf.last_bilateral_level == i ? 0 : bilateral_level_bits; + bits = cm->lf.last_restoration_level == i ? 0 : restoration_level_bits; cost = RDCOST_DBL(x->rdmult, x->rddiv, (bits << 2), err); #else cost = (double)err; #endif // USE_RD_LOOP_POSTFILTER_SEARCH if (cost < best_cost) { - bilateral_best = i; + restoration_best = i; best_cost = cost; } } if (best_cost_ret) *best_cost_ret = best_cost; vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show); - return bilateral_best; + return restoration_best; } -#ifdef JOINT_FILTER_BILATERAL_SEARCH -static int search_filter_bilateral_level(const YV12_BUFFER_CONFIG *sd, - VP10_COMP *cpi, - int partial_frame, - int *bilateral_level) { +#ifdef JOINT_FILTER_RESTORATION_SEARCH +static int search_filter_restoration_level(const YV12_BUFFER_CONFIG *sd, + VP10_COMP *cpi, + int partial_frame, + int *restoration_level) { const VP10_COMMON *const cm = &cpi->common; const struct loopfilter *const lf = &cm->lf; const int min_filter_level = 0; const int max_filter_level = get_max_filter_level(cpi); int filt_direction = 0; - int filt_best, bilateral_best; + int filt_best, restoration_best; double best_err; int i; @@ -173,10 +173,10 @@ static int search_filter_bilateral_level(const YV12_BUFFER_CONFIG *sd, for (i = 0; i <= MAX_LOOP_FILTER; ++i) ss_err[i] = -1.0; - bilateral = search_bilateral_level(sd, cpi, filt_mid, - partial_frame, &best_err); + bilateral = search_restoration_level(sd, cpi, filt_mid, + partial_frame, &best_err); filt_best = filt_mid; - bilateral_best = bilateral; + restoration_best = bilateral; ss_err[filt_mid] = best_err; while (filter_step > 0) { @@ -196,9 +196,9 @@ static int search_filter_bilateral_level(const YV12_BUFFER_CONFIG *sd, if (filt_direction <= 0 && filt_low != filt_mid) { // Get Low filter error score if (ss_err[filt_low] < 0) { - bilateral = search_bilateral_level(sd, cpi, filt_low, - partial_frame, - &ss_err[filt_low]); + bilateral = search_restoration_level(sd, cpi, filt_low, + partial_frame, + &ss_err[filt_low]); } // If value is close to the best so far then bias towards a lower loop // filter value. @@ -209,21 +209,21 @@ static int search_filter_bilateral_level(const YV12_BUFFER_CONFIG *sd, } filt_best = filt_low; - bilateral_best = bilateral; + restoration_best = bilateral; } } // Now look at filt_high if (filt_direction >= 0 && filt_high != filt_mid) { if (ss_err[filt_high] < 0) { - bilateral = search_bilateral_level(sd, cpi, filt_high, partial_frame, - &ss_err[filt_high]); + bilateral = search_restoration_level(sd, cpi, filt_high, partial_frame, + &ss_err[filt_high]); } // Was it better than the previous best? if (ss_err[filt_high] < (best_err - bias)) { best_err = ss_err[filt_high]; filt_best = filt_high; - bilateral_best = bilateral; + restoration_best = bilateral; } } @@ -236,10 +236,10 @@ static int search_filter_bilateral_level(const YV12_BUFFER_CONFIG *sd, filt_mid = filt_best; } } - *bilateral_level = bilateral_best; + *restoration_level = restoration_best; return filt_best; } -#endif // JOINT_FILTER_BILATERAL_SEARCH +#endif // JOINT_FILTER_RESTORATION_SEARCH #endif // CONFIG_LOOP_RESTORATION static int search_filter_level(const YV12_BUFFER_CONFIG *sd, VP10_COMP *cpi, @@ -364,20 +364,20 @@ void vp10_pick_filter_level(const YV12_BUFFER_CONFIG *sd, VP10_COMP *cpi, filt_guess -= 4; lf->filter_level = clamp(filt_guess, min_filter_level, max_filter_level); #if CONFIG_LOOP_RESTORATION - lf->bilateral_level = search_bilateral_level( + lf->restoration_level = search_restoration_level( sd, cpi, lf->filter_level, method == LPF_PICK_FROM_SUBIMAGE, NULL); #endif // CONFIG_LOOP_RESTORATION } else { #if CONFIG_LOOP_RESTORATION -#ifdef JOINT_FILTER_BILATERAL_SEARCH - lf->filter_level = search_filter_bilateral_level( - sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, &lf->bilateral_level); +#ifdef JOINT_FILTER_RESTORATION_SEARCH + lf->filter_level = search_filter_restoration_level( + sd, cpi, method == LPF_PICK_FROM_SUBIMAGE, &lf->restoration_level); #else lf->filter_level = search_filter_level( sd, cpi, method == LPF_PICK_FROM_SUBIMAGE); - lf->bilateral_level = search_bilateral_level( + lf->restoration_level = search_restoration_level( sd, cpi, lf->filter_level, method == LPF_PICK_FROM_SUBIMAGE, NULL); -#endif // JOINT_FILTER_BILATERAL_SEARCH +#endif // JOINT_FILTER_RESTORATION_SEARCH #else lf->filter_level = search_filter_level( sd, cpi, method == LPF_PICK_FROM_SUBIMAGE); -- 2.40.0