diff --git a/av1/common/blockd.h b/av1/common/blockd.h index 41d53d56b..3ccfdc8e4 100644 --- a/av1/common/blockd.h +++ b/av1/common/blockd.h @@ -366,8 +366,7 @@ typedef struct { int send_dq_bit; #endif // CONFIG_NEW_QUANT /* deringing gain *per-superblock* */ - int8_t dering_gain; - int8_t clpf_strength; + int8_t cdef_strength; #if CONFIG_DELTA_Q int current_q_index; #endif diff --git a/av1/common/cdef.c b/av1/common/cdef.c index a488df1b8..707f86032 100644 --- a/av1/common/cdef.c +++ b/av1/common/cdef.c @@ -24,74 +24,6 @@ int dering_level_table[DERING_STRENGTHS] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 17, 20, 24, 28, 33, 39, 46, 54, 63 }; -#ifndef NDEBUG -static int is_sorted(const int *arr, int num) { - int sorted = 1; - while (sorted && num-- > 1) sorted &= arr[num] >= arr[num - 1]; - return sorted; -} -#endif - -uint32_t levels_to_id(const int lev[DERING_REFINEMENT_LEVELS], - const int str[CLPF_REFINEMENT_LEVELS]) { - uint32_t id = 0; - int i; - - assert(is_sorted(lev, DERING_REFINEMENT_LEVELS)); - assert(is_sorted(str, CLPF_REFINEMENT_LEVELS)); - for (i = 0; i < DERING_REFINEMENT_LEVELS; i++) - id = id * DERING_STRENGTHS + lev[i]; - for (i = 0; i < CLPF_REFINEMENT_LEVELS; i++) - id = id * CLPF_STRENGTHS + str[i]; - return id; -} - -void id_to_levels(int lev[DERING_REFINEMENT_LEVELS], - int str[CLPF_REFINEMENT_LEVELS], uint32_t id) { - int i; - for (i = CLPF_REFINEMENT_LEVELS - 1; i >= 0; i--) { - str[i] = id % CLPF_STRENGTHS; - id /= CLPF_STRENGTHS; - } - for (i = DERING_REFINEMENT_LEVELS - 1; i >= 0; i--) { - lev[i] = id % DERING_STRENGTHS; - id /= DERING_STRENGTHS; - } - - // Pack tables - int j; - for (i = j = 1; i < DERING_REFINEMENT_LEVELS && j < DERING_REFINEMENT_LEVELS; - i++) - if (lev[j - 1] == lev[j]) - memmove(&lev[j - 1], &lev[j], - (DERING_REFINEMENT_LEVELS - j) * sizeof(*lev)); - else - j++; - for (i = j = 1; i < CLPF_REFINEMENT_LEVELS && j < DERING_REFINEMENT_LEVELS; - i++) - if (str[j - 1] == str[j]) - memmove(&str[j - 1], &str[j], - (CLPF_REFINEMENT_LEVELS - i) * sizeof(*str)); - else - j++; - - assert(is_sorted(lev, DERING_REFINEMENT_LEVELS)); - assert(is_sorted(str, CLPF_REFINEMENT_LEVELS)); -} - -void cdef_get_bits(const int *lev, const int *str, int *dering_bits, - int *clpf_bits) { - int i; - *dering_bits = *clpf_bits = 1; - for (i = 1; i < DERING_REFINEMENT_LEVELS; i++) - (*dering_bits) += lev[i] != lev[i - 1]; - for (i = 1; i < CLPF_REFINEMENT_LEVELS; i++) - (*clpf_bits) += str[i] != str[i - 1]; - - *dering_bits = get_msb(*dering_bits); - *clpf_bits = get_msb(*clpf_bits); -} - int sb_all_skip(const AV1_COMMON *const cm, int mi_row, int mi_col) { int r, c; int maxc, maxr; @@ -212,8 +144,7 @@ static void copy_sb8_16(UNUSED AV1_COMMON *cm, uint16_t *dst, int dstride, } void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd, - uint32_t global_level, int clpf_strength_u, - int clpf_strength_v) { + int clpf_strength_u, int clpf_strength_v) { int r, c; int sbr, sbc; int nhsb, nvsb; @@ -231,12 +162,11 @@ void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd, int dering_left; int coeff_shift = AOMMAX(cm->bit_depth - 8, 0); int nplanes = 3; - int lev[DERING_REFINEMENT_LEVELS]; - int str[CLPF_REFINEMENT_LEVELS]; + int *lev; int chroma_dering = xd->plane[1].subsampling_x == xd->plane[1].subsampling_y && xd->plane[2].subsampling_x == xd->plane[2].subsampling_y; - id_to_levels(lev, str, global_level); + lev = cm->cdef_strengths; nvsb = (cm->mi_rows + MAX_MIB_SIZE - 1) / MAX_MIB_SIZE; nhsb = (cm->mi_cols + MAX_MIB_SIZE - 1) / MAX_MIB_SIZE; av1_setup_dst_planes(xd->plane, frame, 0, 0); @@ -277,11 +207,13 @@ void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd, level = dering_level_table [lev[cm->mi_grid_visible[MAX_MIB_SIZE * sbr * cm->mi_stride + MAX_MIB_SIZE * sbc] - ->mbmi.dering_gain]]; + ->mbmi.cdef_strength] / + CLPF_STRENGTHS]; clpf_strength = - str[cm->mi_grid_visible[MAX_MIB_SIZE * sbr * cm->mi_stride + + lev[cm->mi_grid_visible[MAX_MIB_SIZE * sbr * cm->mi_stride + MAX_MIB_SIZE * sbc] - ->mbmi.clpf_strength]; + ->mbmi.cdef_strength] % + CLPF_STRENGTHS; clpf_strength += clpf_strength == 3; curr_row_dering[sbc] = 0; if ((level == 0 && clpf_strength == 0) || diff --git a/av1/common/cdef.h b/av1/common/cdef.h index bb010c418..d3c33f255 100644 --- a/av1/common/cdef.h +++ b/av1/common/cdef.h @@ -11,15 +11,8 @@ #ifndef AV1_COMMON_DERING_H_ #define AV1_COMMON_DERING_H_ -// ceil(log2(DERING_STRENGTHS^DERING_REFINEMENT_LEVELS * -// CLPF_STRENGTHS^CLPF_REFINEMENT_LEVELS)) -#define DERING_LEVEL_BITS (22) -#define MAX_DERING_LEVEL (1LL << DERING_LEVEL_BITS) - -#define DERING_REFINEMENT_BITS 2 -#define DERING_REFINEMENT_LEVELS 4 -#define CLPF_REFINEMENT_BITS 1 -#define CLPF_REFINEMENT_LEVELS 2 +#define CDEF_MAX_STRENGTHS 16 +#define CDEF_STRENGTH_BITS 7 #define DERING_STRENGTHS 21 #define CLPF_STRENGTHS 4 @@ -37,19 +30,11 @@ extern "C" { extern int dering_level_table[DERING_STRENGTHS]; -uint32_t levels_to_id(const int lev[DERING_REFINEMENT_LEVELS], - const int str[CLPF_REFINEMENT_LEVELS]); -void id_to_levels(int lev[DERING_REFINEMENT_LEVELS], - int str[CLPF_REFINEMENT_LEVELS], uint32_t id); -void cdef_get_bits(const int *lev, const int *str, int *dering_bits, - int *clpf_bits); - int sb_all_skip(const AV1_COMMON *const cm, int mi_row, int mi_col); int sb_compute_dering_list(const AV1_COMMON *const cm, int mi_row, int mi_col, dering_list *dlist); void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd, - uint32_t global_level, int clpf_strength_u, - int clpf_strength_v); + int clpf_strength_u, int clpf_strength_v); void av1_cdef_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref, AV1_COMMON *cm, MACROBLOCKD *xd); diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h index 997e3f285..99d7b2548 100644 --- a/av1/common/onyxc_int.h +++ b/av1/common/onyxc_int.h @@ -397,11 +397,9 @@ typedef struct AV1Common { int mib_size; // Size of the superblock in units of MI blocks int mib_size_log2; // Log 2 of above. #if CONFIG_CDEF - uint32_t dering_level; - int dering_lev[DERING_REFINEMENT_LEVELS]; - int clpf_str[CLPF_REFINEMENT_LEVELS]; - int dering_bits; - int clpf_bits; + int nb_cdef_strengths; + int cdef_strengths[CDEF_MAX_STRENGTHS]; + int cdef_bits; int clpf_strength_u; int clpf_strength_v; #endif diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c index 5cd21c7da..3f8aac63f 100644 --- a/av1/decoder/decodeframe.c +++ b/av1/decoder/decodeframe.c @@ -2402,14 +2402,11 @@ static void decode_partition(AV1Decoder *const pbi, MACROBLOCKD *const xd, if (bsize == BLOCK_64X64) { #endif if (!sb_all_skip(cm, mi_row, mi_col)) { - cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col]->mbmi.dering_gain = - aom_read_literal(r, cm->dering_bits, ACCT_STR); - cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col]->mbmi.clpf_strength = - aom_read_literal(r, cm->clpf_bits, ACCT_STR); + cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col]->mbmi.cdef_strength = + aom_read_literal(r, cm->cdef_bits, ACCT_STR); } else { - cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col]->mbmi.dering_gain = - cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col] - ->mbmi.clpf_strength = 0; + cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col]->mbmi.cdef_strength = + 0; } } #endif // CONFIG_CDEF @@ -2673,11 +2670,14 @@ static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { #if CONFIG_CDEF static void setup_cdef(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { - cm->dering_level = aom_rb_read_literal(rb, DERING_LEVEL_BITS); + int i; + cm->cdef_bits = aom_rb_read_literal(rb, 2); + cm->nb_cdef_strengths = 1 << cm->cdef_bits; + for (i = 0; i < cm->nb_cdef_strengths; i++) { + cm->cdef_strengths[i] = aom_rb_read_literal(rb, CDEF_STRENGTH_BITS); + } cm->clpf_strength_u = aom_rb_read_literal(rb, 2); cm->clpf_strength_v = aom_rb_read_literal(rb, 2); - id_to_levels(cm->dering_lev, cm->clpf_str, cm->dering_level); - cdef_get_bits(cm->dering_lev, cm->clpf_str, &cm->dering_bits, &cm->clpf_bits); } #endif // CONFIG_CDEF @@ -4950,10 +4950,9 @@ void av1_decode_frame(AV1Decoder *pbi, const uint8_t *data, } #if CONFIG_CDEF - if ((cm->dering_level || cm->clpf_strength_u || cm->clpf_strength_v) && - !cm->skip_loop_filter) { - av1_cdef_frame(&pbi->cur_buf->buf, cm, &pbi->mb, cm->dering_level, - cm->clpf_strength_u, cm->clpf_strength_v); + if (!cm->skip_loop_filter) { + av1_cdef_frame(&pbi->cur_buf->buf, cm, &pbi->mb, cm->clpf_strength_u, + cm->clpf_strength_v); } #endif // CONFIG_CDEF diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c index 3bbce0fb4..fdc7ac891 100644 --- a/av1/encoder/bitstream.c +++ b/av1/encoder/bitstream.c @@ -2785,14 +2785,10 @@ static void write_modes_sb(AV1_COMP *const cpi, const TileInfo *const tile, if (bsize == BLOCK_64X64 && #endif // CONFIG_EXT_PARTITION !sb_all_skip(cm, mi_row, mi_col)) { - if (cm->dering_bits) + if (cm->cdef_bits != 0) aom_write_literal(w, cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col] - ->mbmi.dering_gain, - cm->dering_bits); - if (cm->clpf_bits) - aom_write_literal(w, cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col] - ->mbmi.clpf_strength, - cm->clpf_bits); + ->mbmi.cdef_strength, + cm->cdef_bits); } #endif } @@ -3496,7 +3492,11 @@ static void encode_loopfilter(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { #if CONFIG_CDEF static void encode_cdef(const AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { - aom_wb_write_literal(wb, cm->dering_level, DERING_LEVEL_BITS); + int i; + aom_wb_write_literal(wb, cm->cdef_bits, 2); + for (i = 0; i < cm->nb_cdef_strengths; i++) { + aom_wb_write_literal(wb, cm->cdef_strengths[i], CDEF_STRENGTH_BITS); + } aom_wb_write_literal(wb, cm->clpf_strength_u, 2); aom_wb_write_literal(wb, cm->clpf_strength_v, 2); } diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c index f3157c4d8..757d58900 100644 --- a/av1/encoder/encoder.c +++ b/av1/encoder/encoder.c @@ -3522,14 +3522,17 @@ static void loopfilter_frame(AV1_COMP *cpi, AV1_COMMON *cm) { } #if CONFIG_CDEF if (is_lossless_requested(&cpi->oxcf)) { - cm->dering_level = cm->clpf_strength_u = cm->clpf_strength_v = 0; + cm->clpf_strength_u = cm->clpf_strength_v = 0; + cm->cdef_bits = 0; + cm->cdef_strengths[0] = 0; + cm->nb_cdef_strengths = 1; } else { // Find cm->dering_level, cm->clpf_strength_u and cm->clpf_strength_v av1_cdef_search(cm->frame_to_show, cpi->Source, cm, xd); // Apply the filter - av1_cdef_frame(cm->frame_to_show, cm, xd, cm->dering_level, - cm->clpf_strength_u, cm->clpf_strength_v); + av1_cdef_frame(cm->frame_to_show, cm, xd, cm->clpf_strength_u, + cm->clpf_strength_v); // Pack the clpf chroma strengths into two bits each cm->clpf_strength_u -= cm->clpf_strength_u == 4; diff --git a/av1/encoder/pickcdef.c b/av1/encoder/pickcdef.c index 5523a9c94..241d27af7 100644 --- a/av1/encoder/pickcdef.c +++ b/av1/encoder/pickcdef.c @@ -20,6 +20,64 @@ #include "av1/encoder/clpf_rdo.h" #include "av1/encoder/encoder.h" +#define TOTAL_STRENGTHS (DERING_STRENGTHS * CLPF_STRENGTHS) + +/* Search for the best strength to add as an option, knowing we + already selected nb_strengths options. */ +static uint64_t search_one(int *lev, int nb_strengths, + uint64_t mse[][TOTAL_STRENGTHS], int sb_count) { + uint64_t tot_mse[TOTAL_STRENGTHS]; + int i, j; + uint64_t best_tot_mse = (uint64_t)1 << 63; + int best_id = 0; + memset(tot_mse, 0, sizeof(tot_mse)); + for (i = 0; i < sb_count; i++) { + int gi; + uint64_t best_mse = (uint64_t)1 << 63; + /* Find best mse among already selected options. */ + for (gi = 0; gi < nb_strengths; gi++) { + if (mse[i][lev[gi]] < best_mse) { + best_mse = mse[i][lev[gi]]; + } + } + /* Find best mse when adding each possible new option. */ + for (j = 0; j < TOTAL_STRENGTHS; j++) { + uint64_t best = best_mse; + if (mse[i][j] < best) best = mse[i][j]; + tot_mse[j] += best; + } + } + for (j = 0; j < TOTAL_STRENGTHS; j++) { + if (tot_mse[j] < best_tot_mse) { + best_tot_mse = tot_mse[j]; + best_id = j; + } + } + lev[nb_strengths] = best_id; + return best_tot_mse; +} + +/* Search for the set of strengths that minimizes mse. */ +static uint64_t joint_strength_search(int *best_lev, int nb_strengths, + uint64_t mse[][TOTAL_STRENGTHS], + int sb_count) { + uint64_t best_tot_mse; + int i; + best_tot_mse = (uint64_t)1 << 63; + /* Greedy search: add one strength options at a time. */ + for (i = 0; i < nb_strengths; i++) { + best_tot_mse = search_one(best_lev, i, mse, sb_count); + } + /* Trying to refine the greedy search by reconsidering each + already-selected option. */ + for (i = 0; i < 4 * nb_strengths; i++) { + int j; + for (j = 0; j < nb_strengths - 1; j++) best_lev[j] = best_lev[j + 1]; + best_tot_mse = search_one(best_lev, nb_strengths - 1, mse, sb_count); + } + return best_tot_mse; +} + static double compute_dist(uint16_t *x, int xstride, uint16_t *y, int ystride, int nhb, int nvb, int coeff_shift) { int i, j; @@ -50,21 +108,24 @@ void av1_cdef_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref, int level; int dering_count; int coeff_shift = AOMMAX(cm->bit_depth - 8, 0); - uint64_t best_tot_mse = 0; + uint64_t best_tot_mse = (uint64_t)1 << 63; + uint64_t tot_mse; int sb_count; int nvsb = (cm->mi_rows + MAX_MIB_SIZE - 1) / MAX_MIB_SIZE; int nhsb = (cm->mi_cols + MAX_MIB_SIZE - 1) / MAX_MIB_SIZE; int *sb_index = aom_malloc(nvsb * nhsb * sizeof(*sb_index)); - uint64_t(*mse)[DERING_STRENGTHS][CLPF_STRENGTHS] = + uint64_t(*mse)[DERING_STRENGTHS * CLPF_STRENGTHS] = aom_malloc(sizeof(*mse) * nvsb * nhsb); int clpf_damping = 3 + (cm->base_qindex >> 6); int i; - int lev[DERING_REFINEMENT_LEVELS]; - int best_lev[DERING_REFINEMENT_LEVELS]; - int str[CLPF_REFINEMENT_LEVELS]; - int best_str[CLPF_REFINEMENT_LEVELS]; - double lambda = exp(cm->base_qindex / 36.0); - static int log2[] = { 0, 1, 2, 2 }; + int best_lev[CDEF_MAX_STRENGTHS]; + int nb_strengths; + int nb_strength_bits; + int quantizer; + double lambda; + quantizer = + av1_ac_quant(cm->base_qindex, 0, cm->bit_depth) >> (cm->bit_depth - 8); + lambda = .12 * quantizer * quantizer / 256.; src = aom_memalign(32, sizeof(*src) * cm->mi_rows * cm->mi_cols * 64); ref_coeff = @@ -143,7 +204,7 @@ void av1_cdef_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref, i + (i == 3), clpf_damping, coeff_shift); copy_dering_16bit_to_16bit(dst, MAX_MIB_SIZE << bsize[0], tmp_dst, dlist, dering_count, bsize[0]); - mse[sb_count][gi][i] = (int)compute_dist( + mse[sb_count][gi * CLPF_STRENGTHS + i] = (int)compute_dist( dst, MAX_MIB_SIZE << bsize[0], &ref_coeff[(sbr * stride * MAX_MIB_SIZE << bsize[0]) + (sbc * MAX_MIB_SIZE << bsize[0])], @@ -155,85 +216,38 @@ void av1_cdef_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref, sb_count++; } } - best_tot_mse = (uint64_t)1 << 63; - int l0; - for (l0 = 0; l0 < DERING_STRENGTHS; l0++) { - int l1; - lev[0] = l0; - for (l1 = l0; l1 < DERING_STRENGTHS; l1++) { - int l2; - lev[1] = l1; - for (l2 = l1; l2 < DERING_STRENGTHS; l2++) { - int l3; - lev[2] = l2; - for (l3 = l2; l3 < DERING_STRENGTHS; l3++) { - int cs0; - lev[3] = l3; - for (cs0 = 0; cs0 < CLPF_STRENGTHS; cs0++) { - int cs1; - str[0] = cs0; - for (cs1 = cs0; cs1 < CLPF_STRENGTHS; cs1++) { - uint64_t tot_mse = 0; - str[1] = cs1; - for (i = 0; i < sb_count; i++) { - int gi; - int cs; - uint64_t best_mse = (uint64_t)1 << 63; - for (gi = 0; gi < DERING_REFINEMENT_LEVELS; gi++) { - for (cs = 0; cs < CLPF_REFINEMENT_LEVELS; cs++) { - if (mse[i][lev[gi]][str[cs]] < best_mse) { - best_mse = mse[i][lev[gi]][str[cs]]; - } - } - } - tot_mse += best_mse; - } - - // Add the bit cost - int dering_diffs = 0, clpf_diffs = 0; - for (i = 1; i < DERING_REFINEMENT_LEVELS; i++) - dering_diffs += lev[i] != lev[i - 1]; - for (i = 1; i < CLPF_REFINEMENT_LEVELS; i++) - clpf_diffs += str[i] != str[i - 1]; - tot_mse += (uint64_t)(sb_count * lambda * - (log2[dering_diffs] + log2[clpf_diffs])); - - if (tot_mse < best_tot_mse) { - for (i = 0; i < DERING_REFINEMENT_LEVELS; i++) - best_lev[i] = lev[i]; - for (i = 0; i < CLPF_REFINEMENT_LEVELS; i++) - best_str[i] = str[i]; - best_tot_mse = tot_mse; - } - } - } - } - } + nb_strength_bits = 0; + /* Search for different number of signalling bits. */ + for (i = 0; i <= 3; i++) { + nb_strengths = 1 << i; + tot_mse = joint_strength_search(best_lev, nb_strengths, mse, sb_count); + /* Count superblock signalling cost. */ + tot_mse += (uint64_t)(sb_count * lambda * i); + /* Count header signalling cost. */ + tot_mse += (uint64_t)(nb_strengths * lambda * CDEF_STRENGTH_BITS); + if (tot_mse < best_tot_mse) { + best_tot_mse = tot_mse; + nb_strength_bits = i; } } - for (i = 0; i < DERING_REFINEMENT_LEVELS; i++) lev[i] = best_lev[i]; - for (i = 0; i < CLPF_REFINEMENT_LEVELS; i++) str[i] = best_str[i]; - - id_to_levels(lev, str, levels_to_id(lev, str)); // Pack tables - cdef_get_bits(lev, str, &cm->dering_bits, &cm->clpf_bits); + nb_strengths = 1 << nb_strength_bits; + cm->cdef_bits = nb_strength_bits; + cm->nb_cdef_strengths = nb_strengths; + for (i = 0; i < nb_strengths; i++) cm->cdef_strengths[i] = best_lev[i]; for (i = 0; i < sb_count; i++) { - int gi, cs; - int best_gi, best_clpf; + int gi; + int best_gi; uint64_t best_mse = (uint64_t)1 << 63; - best_gi = best_clpf = 0; - for (gi = 0; gi < (1 << cm->dering_bits); gi++) { - for (cs = 0; cs < (1 << cm->clpf_bits); cs++) { - if (mse[i][lev[gi]][str[cs]] < best_mse) { - best_gi = gi; - best_clpf = cs; - best_mse = mse[i][lev[gi]][str[cs]]; - } + best_gi = 0; + for (gi = 0; gi < cm->nb_cdef_strengths; gi++) { + if (mse[i][best_lev[gi]] < best_mse) { + best_gi = gi; + best_mse = mse[i][best_lev[gi]]; } } - cm->mi_grid_visible[sb_index[i]]->mbmi.dering_gain = best_gi; - cm->mi_grid_visible[sb_index[i]]->mbmi.clpf_strength = best_clpf; + cm->mi_grid_visible[sb_index[i]]->mbmi.cdef_strength = best_gi; } aom_free(src); @@ -245,5 +259,4 @@ void av1_cdef_search(YV12_BUFFER_CONFIG *frame, const YV12_BUFFER_CONFIG *ref, AOM_PLANE_U); av1_clpf_test_plane(cm->frame_to_show, ref, cm, &cm->clpf_strength_v, AOM_PLANE_V); - cm->dering_level = levels_to_id(best_lev, best_str); }