Add allintra visual files Move allintra visual quality related functions to dedicated files. Change-Id: Ic6e2d5dca26932bd3aca183d2db8dad31f4d126e
diff --git a/av1/av1.cmake b/av1/av1.cmake index 80d8277..de000e6 100644 --- a/av1/av1.cmake +++ b/av1/av1.cmake
@@ -123,6 +123,8 @@ "${AOM_ROOT}/av1/encoder/aq_cyclicrefresh.h" "${AOM_ROOT}/av1/encoder/aq_variance.c" "${AOM_ROOT}/av1/encoder/aq_variance.h" + "${AOM_ROOT}/av1/encoder/allintra_vis.c" + "${AOM_ROOT}/av1/encoder/allintra_vis.h" "${AOM_ROOT}/av1/encoder/enc_enums.h" "${AOM_ROOT}/av1/encoder/av1_fwd_txfm1d.c" "${AOM_ROOT}/av1/encoder/av1_fwd_txfm1d.h"
diff --git a/av1/encoder/allintra_vis.c b/av1/encoder/allintra_vis.c new file mode 100644 index 0000000..2fc6c28 --- /dev/null +++ b/av1/encoder/allintra_vis.c
@@ -0,0 +1,252 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. If the Alliance for Open + * Media Patent License 1.0 was not distributed with this source code in the + * PATENTS file, you can obtain it at www.aomedia.org/license/patent. + */ + +#include "av1/encoder/allintra_vis.h" + +// Process the wiener variance in 16x16 block basis. +static int qsort_comp(const void *elem1, const void *elem2) { + int a = *((const int *)elem1); + int b = *((const int *)elem2); + if (a > b) return 1; + if (a < b) return -1; + return 0; +} + +void av1_init_mb_wiener_var_buffer(AV1_COMP *cpi) { + AV1_COMMON *cm = &cpi->common; + + if (cpi->mb_wiener_variance) return; + + CHECK_MEM_ERROR(cm, cpi->mb_wiener_variance, + aom_calloc(cpi->frame_info.mb_rows * cpi->frame_info.mb_cols, + sizeof(*cpi->mb_wiener_variance))); +} + +static int get_window_wiener_var(AV1_COMP *const cpi, BLOCK_SIZE bsize, + int mi_row, int mi_col) { + AV1_COMMON *const cm = &cpi->common; + const int mi_wide = mi_size_wide[bsize]; + const int mi_high = mi_size_high[bsize]; + + const int mi_step = mi_size_wide[BLOCK_16X16]; + int sb_wiener_var = 0; + int mb_stride = cpi->frame_info.mb_cols; + int mb_count = 0; + int64_t mb_wiener_sum = 0; + + for (int row = mi_row; row < mi_row + mi_high; row += mi_step) { + for (int col = mi_col; col < mi_col + mi_wide; col += mi_step) { + if (row >= cm->mi_params.mi_rows || col >= cm->mi_params.mi_cols) + continue; + + mb_wiener_sum += + (int)cpi->mb_wiener_variance[(row / mi_step) * mb_stride + + (col / mi_step)]; + ++mb_count; + } + } + + if (mb_count) sb_wiener_var = (int)(mb_wiener_sum / mb_count); + sb_wiener_var = AOMMAX(1, sb_wiener_var); + + return (int)(sqrt(sb_wiener_var)); +} + +static int get_var_perceptual_ai(AV1_COMP *const cpi, BLOCK_SIZE bsize, + int mi_row, int mi_col) { + AV1_COMMON *const cm = &cpi->common; + const int mi_wide = mi_size_wide[bsize]; + const int mi_high = mi_size_high[bsize]; + + int sb_wiener_var = get_window_wiener_var(cpi, bsize, mi_row, mi_col); + + if (mi_row >= (mi_high / 2)) { + sb_wiener_var = + AOMMIN(sb_wiener_var, + get_window_wiener_var(cpi, bsize, mi_row - mi_high / 2, mi_col)); + } + if (mi_row <= (cm->mi_params.mi_rows - mi_high - (mi_high / 2))) { + sb_wiener_var = + AOMMIN(sb_wiener_var, + get_window_wiener_var(cpi, bsize, mi_row + mi_high / 2, mi_col)); + } + if (mi_col >= (mi_wide / 2)) { + sb_wiener_var = + AOMMIN(sb_wiener_var, + get_window_wiener_var(cpi, bsize, mi_row, mi_col - mi_wide / 2)); + } + if (mi_col <= (cm->mi_params.mi_cols - mi_wide - (mi_wide / 2))) { + sb_wiener_var = + AOMMIN(sb_wiener_var, + get_window_wiener_var(cpi, bsize, mi_row, mi_col + mi_wide / 2)); + } + + return sb_wiener_var; +} + +void av1_set_mb_wiener_variance(AV1_COMP *cpi) { + AV1_COMMON *const cm = &cpi->common; + uint8_t *buffer = cpi->source->y_buffer; + int buf_stride = cpi->source->y_stride; + ThreadData *td = &cpi->td; + MACROBLOCK *x = &td->mb; + MACROBLOCKD *xd = &x->e_mbd; + MB_MODE_INFO mbmi; + memset(&mbmi, 0, sizeof(mbmi)); + MB_MODE_INFO *mbmi_ptr = &mbmi; + xd->mi = &mbmi_ptr; + + union { +#if CONFIG_AV1_HIGHBITDEPTH + DECLARE_ALIGNED(32, uint16_t, zero_pred16[32 * 32]); +#endif + DECLARE_ALIGNED(32, uint8_t, zero_pred8[32 * 32]); + } pred_buffer_mem; + uint8_t *pred_buf; + + DECLARE_ALIGNED(32, int16_t, src_diff[32 * 32]); + DECLARE_ALIGNED(32, tran_low_t, coeff[32 * 32]); + + int mb_row, mb_col, count = 0; + const TX_SIZE tx_size = TX_16X16; + const int block_size = tx_size_wide[tx_size]; + const int coeff_count = block_size * block_size; + +#if CONFIG_AV1_HIGHBITDEPTH + xd->cur_buf = cpi->source; + if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { + pred_buf = CONVERT_TO_BYTEPTR(pred_buffer_mem.zero_pred16); + memset(pred_buffer_mem.zero_pred16, 0, + sizeof(*pred_buffer_mem.zero_pred16) * coeff_count); + } else { + pred_buf = pred_buffer_mem.zero_pred8; + memset(pred_buffer_mem.zero_pred8, 0, + sizeof(*pred_buffer_mem.zero_pred8) * coeff_count); + } +#else + pred_buf = pred_buffer_mem.zero_pred8; + memset(pred_buffer_mem.zero_pred8, 0, + sizeof(*pred_buffer_mem.zero_pred8) * coeff_count); +#endif + + const BitDepthInfo bd_info = get_bit_depth_info(xd); + cpi->norm_wiener_variance = 0; + + int mb_step = mi_size_wide[BLOCK_16X16]; + + for (mb_row = 0; mb_row < cpi->frame_info.mb_rows; ++mb_row) { + for (mb_col = 0; mb_col < cpi->frame_info.mb_cols; ++mb_col) { + PREDICTION_MODE best_mode = DC_PRED; + int best_intra_cost = INT_MAX; + + int mi_row = mb_row * mb_step; + int mi_col = mb_col * mb_step; + + xd->up_available = mi_row > 0; + xd->left_available = mi_col > 0; + + int dst_mb_offset = mi_row * MI_SIZE * buf_stride + mi_col * MI_SIZE; + uint8_t *dst_buffer = xd->cur_buf->y_buffer + dst_mb_offset; + + for (PREDICTION_MODE mode = INTRA_MODE_START; mode < INTRA_MODE_END; + ++mode) { + av1_predict_intra_block(xd, cm->seq_params->sb_size, + cm->seq_params->enable_intra_edge_filter, + block_size, block_size, tx_size, mode, 0, 0, + FILTER_INTRA_MODES, dst_buffer, buf_stride, + pred_buf, block_size, 0, 0, 0); + + av1_subtract_block(bd_info, block_size, block_size, src_diff, + block_size, dst_buffer, buf_stride, pred_buf, + block_size); + av1_quick_txfm(0, tx_size, bd_info, src_diff, block_size, coeff); + int intra_cost = aom_satd(coeff, coeff_count); + if (intra_cost < best_intra_cost) { + best_intra_cost = intra_cost; + best_mode = mode; + } + } + + int idx; + int16_t median_val = 0; + uint8_t *mb_buffer = + buffer + mb_row * block_size * buf_stride + mb_col * block_size; + int64_t wiener_variance = 0; + av1_predict_intra_block( + xd, cm->seq_params->sb_size, cm->seq_params->enable_intra_edge_filter, + block_size, block_size, tx_size, best_mode, 0, 0, FILTER_INTRA_MODES, + dst_buffer, buf_stride, pred_buf, block_size, 0, 0, 0); + av1_subtract_block(bd_info, block_size, block_size, src_diff, block_size, + mb_buffer, buf_stride, pred_buf, block_size); + av1_quick_txfm(0, tx_size, bd_info, src_diff, block_size, coeff); + coeff[0] = 0; + for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]); + + qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp); + + // Noise level estimation + median_val = coeff[coeff_count / 2]; + + // Wiener filter + for (idx = 1; idx < coeff_count; ++idx) { + int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx]; + int64_t tmp_coeff = (int64_t)coeff[idx]; + if (median_val) { + tmp_coeff = (sqr_coeff * coeff[idx]) / + (sqr_coeff + (int64_t)median_val * median_val); + } + wiener_variance += tmp_coeff * tmp_coeff; + } + cpi->mb_wiener_variance[mb_row * cpi->frame_info.mb_cols + mb_col] = + wiener_variance / coeff_count; + ++count; + } + } + + int sb_step = mi_size_wide[cm->seq_params->sb_size]; + double sb_wiener_log = 0; + int sb_count = 0; + + for (int mi_row = 0; mi_row < cm->mi_params.mi_rows; mi_row += sb_step) { + for (int mi_col = 0; mi_col < cm->mi_params.mi_cols; mi_col += sb_step) { + int sb_wiener_var = + get_var_perceptual_ai(cpi, cm->seq_params->sb_size, mi_row, mi_col); + sb_wiener_log += log(sb_wiener_var); + ++sb_count; + } + } + + if (sb_count) + cpi->norm_wiener_variance = (int64_t)(exp(sb_wiener_log / sb_count)); + cpi->norm_wiener_variance = AOMMAX(1, cpi->norm_wiener_variance); +} + +int av1_get_sbq_perceptual_ai(AV1_COMP *const cpi, BLOCK_SIZE bsize, int mi_row, + int mi_col) { + AV1_COMMON *const cm = &cpi->common; + const int base_qindex = cm->quant_params.base_qindex; + int sb_wiener_var = get_var_perceptual_ai(cpi, bsize, mi_row, mi_col); + int offset = 0; + double beta = (double)cpi->norm_wiener_variance / sb_wiener_var; + // Cap beta such that the delta q value is not much far away from the base q. + beta = AOMMIN(beta, 4); + beta = AOMMAX(beta, 0.25); + offset = av1_get_deltaq_offset(cm->seq_params->bit_depth, base_qindex, beta); + const DeltaQInfo *const delta_q_info = &cm->delta_q_info; + offset = AOMMIN(offset, delta_q_info->delta_q_res * 20 - 1); + offset = AOMMAX(offset, -delta_q_info->delta_q_res * 20 + 1); + int qindex = cm->quant_params.base_qindex + offset; + qindex = AOMMIN(qindex, MAXQ); + qindex = AOMMAX(qindex, MINQ); + if (base_qindex > MINQ) qindex = AOMMAX(qindex, MINQ + 1); + + return qindex; +}
diff --git a/av1/encoder/allintra_vis.h b/av1/encoder/allintra_vis.h new file mode 100644 index 0000000..5f588f6 --- /dev/null +++ b/av1/encoder/allintra_vis.h
@@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. If the Alliance for Open + * Media Patent License 1.0 was not distributed with this source code in the + * PATENTS file, you can obtain it at www.aomedia.org/license/patent. + */ + +#include "config/aom_dsp_rtcd.h" + +#include "av1/common/enums.h" +#include "av1/common/reconintra.h" + +#include "av1/encoder/block.h" +#include "av1/encoder/encoder.h" +#include "av1/encoder/hybrid_fwd_txfm.h" + +void av1_init_mb_wiener_var_buffer(AV1_COMP *cpi); + +void av1_set_mb_wiener_variance(AV1_COMP *cpi); + +int av1_get_sbq_perceptual_ai(AV1_COMP *const cpi, BLOCK_SIZE bsize, int mi_row, + int mi_col);
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c index e4f8366..6ad70da 100644 --- a/av1/encoder/encodeframe.c +++ b/av1/encoder/encodeframe.c
@@ -43,6 +43,7 @@ #include "av1/common/tile_common.h" #include "av1/common/warped_motion.h" +#include "av1/encoder/allintra_vis.h" #include "av1/encoder/aq_complexity.h" #include "av1/encoder/aq_cyclicrefresh.h" #include "av1/encoder/aq_variance.h"
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c index 3ef5e5f..d3f848b 100644 --- a/av1/encoder/encoder.c +++ b/av1/encoder/encoder.c
@@ -45,6 +45,7 @@ #include "av1/common/resize.h" #include "av1/common/tile_common.h" +#include "av1/encoder/allintra_vis.h" #include "av1/encoder/aq_complexity.h" #include "av1/encoder/aq_cyclicrefresh.h" #include "av1/encoder/aq_variance.h" @@ -3117,246 +3118,6 @@ } #endif -// Process the wiener variance in 16x16 block basis. -static int qsort_comp(const void *elem1, const void *elem2) { - int a = *((const int *)elem1); - int b = *((const int *)elem2); - if (a > b) return 1; - if (a < b) return -1; - return 0; -} - -static void init_mb_wiener_var_buffer(AV1_COMP *cpi) { - AV1_COMMON *cm = &cpi->common; - - if (cpi->mb_wiener_variance) return; - - CHECK_MEM_ERROR(cm, cpi->mb_wiener_variance, - aom_calloc(cpi->frame_info.mb_rows * cpi->frame_info.mb_cols, - sizeof(*cpi->mb_wiener_variance))); -} - -static int get_window_wiener_var(AV1_COMP *const cpi, BLOCK_SIZE bsize, - int mi_row, int mi_col) { - AV1_COMMON *const cm = &cpi->common; - const int mi_wide = mi_size_wide[bsize]; - const int mi_high = mi_size_high[bsize]; - - const int mi_step = mi_size_wide[BLOCK_16X16]; - int sb_wiener_var = 0; - int mb_stride = cpi->frame_info.mb_cols; - int mb_count = 0; - int64_t mb_wiener_sum = 0; - - for (int row = mi_row; row < mi_row + mi_high; row += mi_step) { - for (int col = mi_col; col < mi_col + mi_wide; col += mi_step) { - if (row >= cm->mi_params.mi_rows || col >= cm->mi_params.mi_cols) - continue; - - mb_wiener_sum += - (int)cpi->mb_wiener_variance[(row / mi_step) * mb_stride + - (col / mi_step)]; - ++mb_count; - } - } - - if (mb_count) sb_wiener_var = (int)(mb_wiener_sum / mb_count); - sb_wiener_var = AOMMAX(1, sb_wiener_var); - - return (int)(sqrt(sb_wiener_var)); -} - -static int get_var_perceptual_ai(AV1_COMP *const cpi, BLOCK_SIZE bsize, - int mi_row, int mi_col) { - AV1_COMMON *const cm = &cpi->common; - const int mi_wide = mi_size_wide[bsize]; - const int mi_high = mi_size_high[bsize]; - - int sb_wiener_var = get_window_wiener_var(cpi, bsize, mi_row, mi_col); - - if (mi_row >= (mi_high / 2)) { - sb_wiener_var = - AOMMIN(sb_wiener_var, - get_window_wiener_var(cpi, bsize, mi_row - mi_high / 2, mi_col)); - } - if (mi_row <= (cm->mi_params.mi_rows - mi_high - (mi_high / 2))) { - sb_wiener_var = - AOMMIN(sb_wiener_var, - get_window_wiener_var(cpi, bsize, mi_row + mi_high / 2, mi_col)); - } - if (mi_col >= (mi_wide / 2)) { - sb_wiener_var = - AOMMIN(sb_wiener_var, - get_window_wiener_var(cpi, bsize, mi_row, mi_col - mi_wide / 2)); - } - if (mi_col <= (cm->mi_params.mi_cols - mi_wide - (mi_wide / 2))) { - sb_wiener_var = - AOMMIN(sb_wiener_var, - get_window_wiener_var(cpi, bsize, mi_row, mi_col + mi_wide / 2)); - } - - return sb_wiener_var; -} - -static void set_mb_wiener_variance(AV1_COMP *cpi) { - AV1_COMMON *const cm = &cpi->common; - uint8_t *buffer = cpi->source->y_buffer; - int buf_stride = cpi->source->y_stride; - ThreadData *td = &cpi->td; - MACROBLOCK *x = &td->mb; - MACROBLOCKD *xd = &x->e_mbd; - MB_MODE_INFO mbmi; - memset(&mbmi, 0, sizeof(mbmi)); - MB_MODE_INFO *mbmi_ptr = &mbmi; - xd->mi = &mbmi_ptr; - - union { -#if CONFIG_AV1_HIGHBITDEPTH - DECLARE_ALIGNED(32, uint16_t, zero_pred16[32 * 32]); -#endif - DECLARE_ALIGNED(32, uint8_t, zero_pred8[32 * 32]); - } pred_buffer_mem; - uint8_t *pred_buf; - - DECLARE_ALIGNED(32, int16_t, src_diff[32 * 32]); - DECLARE_ALIGNED(32, tran_low_t, coeff[32 * 32]); - - int mb_row, mb_col, count = 0; - const TX_SIZE tx_size = TX_16X16; - const int block_size = tx_size_wide[tx_size]; - const int coeff_count = block_size * block_size; - -#if CONFIG_AV1_HIGHBITDEPTH - xd->cur_buf = cpi->source; - if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - pred_buf = CONVERT_TO_BYTEPTR(pred_buffer_mem.zero_pred16); - memset(pred_buffer_mem.zero_pred16, 0, - sizeof(*pred_buffer_mem.zero_pred16) * coeff_count); - } else { - pred_buf = pred_buffer_mem.zero_pred8; - memset(pred_buffer_mem.zero_pred8, 0, - sizeof(*pred_buffer_mem.zero_pred8) * coeff_count); - } -#else - pred_buf = pred_buffer_mem.zero_pred8; - memset(pred_buffer_mem.zero_pred8, 0, - sizeof(*pred_buffer_mem.zero_pred8) * coeff_count); -#endif - - const BitDepthInfo bd_info = get_bit_depth_info(xd); - cpi->norm_wiener_variance = 0; - - int mb_step = mi_size_wide[BLOCK_16X16]; - - for (mb_row = 0; mb_row < cpi->frame_info.mb_rows; ++mb_row) { - for (mb_col = 0; mb_col < cpi->frame_info.mb_cols; ++mb_col) { - PREDICTION_MODE best_mode = DC_PRED; - int best_intra_cost = INT_MAX; - - int mi_row = mb_row * mb_step; - int mi_col = mb_col * mb_step; - - xd->up_available = mi_row > 0; - xd->left_available = mi_col > 0; - - int dst_mb_offset = mi_row * MI_SIZE * buf_stride + mi_col * MI_SIZE; - uint8_t *dst_buffer = xd->cur_buf->y_buffer + dst_mb_offset; - - for (PREDICTION_MODE mode = INTRA_MODE_START; mode < INTRA_MODE_END; - ++mode) { - av1_predict_intra_block(xd, cm->seq_params->sb_size, - cm->seq_params->enable_intra_edge_filter, - block_size, block_size, tx_size, mode, 0, 0, - FILTER_INTRA_MODES, dst_buffer, buf_stride, - pred_buf, block_size, 0, 0, 0); - - av1_subtract_block(bd_info, block_size, block_size, src_diff, - block_size, dst_buffer, buf_stride, pred_buf, - block_size); - av1_quick_txfm(0, tx_size, bd_info, src_diff, block_size, coeff); - int intra_cost = aom_satd(coeff, coeff_count); - if (intra_cost < best_intra_cost) { - best_intra_cost = intra_cost; - best_mode = mode; - } - } - - int idx; - int16_t median_val = 0; - uint8_t *mb_buffer = - buffer + mb_row * block_size * buf_stride + mb_col * block_size; - int64_t wiener_variance = 0; - av1_predict_intra_block( - xd, cm->seq_params->sb_size, cm->seq_params->enable_intra_edge_filter, - block_size, block_size, tx_size, best_mode, 0, 0, FILTER_INTRA_MODES, - dst_buffer, buf_stride, pred_buf, block_size, 0, 0, 0); - av1_subtract_block(bd_info, block_size, block_size, src_diff, block_size, - mb_buffer, buf_stride, pred_buf, block_size); - av1_quick_txfm(0, tx_size, bd_info, src_diff, block_size, coeff); - coeff[0] = 0; - for (idx = 1; idx < coeff_count; ++idx) coeff[idx] = abs(coeff[idx]); - - qsort(coeff, coeff_count - 1, sizeof(*coeff), qsort_comp); - - // Noise level estimation - median_val = coeff[coeff_count / 2]; - - // Wiener filter - for (idx = 1; idx < coeff_count; ++idx) { - int64_t sqr_coeff = (int64_t)coeff[idx] * coeff[idx]; - int64_t tmp_coeff = (int64_t)coeff[idx]; - if (median_val) { - tmp_coeff = (sqr_coeff * coeff[idx]) / - (sqr_coeff + (int64_t)median_val * median_val); - } - wiener_variance += tmp_coeff * tmp_coeff; - } - cpi->mb_wiener_variance[mb_row * cpi->frame_info.mb_cols + mb_col] = - wiener_variance / coeff_count; - ++count; - } - } - - int sb_step = mi_size_wide[cm->seq_params->sb_size]; - double sb_wiener_log = 0; - int sb_count = 0; - - for (int mi_row = 0; mi_row < cm->mi_params.mi_rows; mi_row += sb_step) { - for (int mi_col = 0; mi_col < cm->mi_params.mi_cols; mi_col += sb_step) { - int sb_wiener_var = - get_var_perceptual_ai(cpi, cm->seq_params->sb_size, mi_row, mi_col); - sb_wiener_log += log(sb_wiener_var); - ++sb_count; - } - } - - if (sb_count) - cpi->norm_wiener_variance = (int64_t)(exp(sb_wiener_log / sb_count)); - cpi->norm_wiener_variance = AOMMAX(1, cpi->norm_wiener_variance); -} - -int av1_get_sbq_perceptual_ai(AV1_COMP *const cpi, BLOCK_SIZE bsize, int mi_row, - int mi_col) { - AV1_COMMON *const cm = &cpi->common; - const int base_qindex = cm->quant_params.base_qindex; - int sb_wiener_var = get_var_perceptual_ai(cpi, bsize, mi_row, mi_col); - int offset = 0; - double beta = (double)cpi->norm_wiener_variance / sb_wiener_var; - // Cap beta such that the delta q value is not much far away from the base q. - beta = AOMMIN(beta, 4); - beta = AOMMAX(beta, 0.25); - offset = av1_get_deltaq_offset(cm->seq_params->bit_depth, base_qindex, beta); - const DeltaQInfo *const delta_q_info = &cm->delta_q_info; - offset = AOMMIN(offset, delta_q_info->delta_q_res * 20 - 1); - offset = AOMMAX(offset, -delta_q_info->delta_q_res * 20 + 1); - int qindex = cm->quant_params.base_qindex + offset; - qindex = AOMMIN(qindex, MAXQ); - qindex = AOMMAX(qindex, MINQ); - if (base_qindex > MINQ) qindex = AOMMAX(qindex, MINQ + 1); - - return qindex; -} - extern void av1_print_frame_contexts(const FRAME_CONTEXT *fc, const char *filename); @@ -3535,8 +3296,8 @@ #endif if (cpi->oxcf.q_cfg.deltaq_mode == DELTA_Q_PERCEPTUAL_AI) { - init_mb_wiener_var_buffer(cpi); - set_mb_wiener_variance(cpi); + av1_init_mb_wiener_var_buffer(cpi); + av1_set_mb_wiener_variance(cpi); } #if CONFIG_INTERNAL_STATS
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h index ffbc19e..eefbce9 100644 --- a/av1/encoder/encoder.h +++ b/av1/encoder/encoder.h
@@ -3319,9 +3319,6 @@ void av1_update_frame_size(AV1_COMP *cpi); -int av1_get_sbq_perceptual_ai(AV1_COMP *const cpi, BLOCK_SIZE bsize, int mi_row, - int mi_col); - #if CONFIG_FRAME_PARALLEL_ENCODE typedef struct { int pyr_level;