Refactor CommonQuantParams from AV1_COMMON struct. BUG=aomedia:2610 Change-Id: Ib2346b445946d3c2275c866b222313c2d0db659f
diff --git a/av1/av1_dx_iface.c b/av1/av1_dx_iface.c index 15a9ed2..0006c1f 100644 --- a/av1/av1_dx_iface.c +++ b/av1/av1_dx_iface.c
@@ -994,7 +994,8 @@ va_list args) { int *const arg = va_arg(args, int *); if (arg == NULL) return AOM_CODEC_INVALID_PARAM; - *arg = ((FrameWorkerData *)ctx->frame_worker->data1)->pbi->common.base_qindex; + *arg = ((FrameWorkerData *)ctx->frame_worker->data1) + ->pbi->common.quant_params.base_qindex; return AOM_CODEC_OK; }
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h index 4e8cdb0..d56f629 100644 --- a/av1/common/av1_common_int.h +++ b/av1/common/av1_common_int.h
@@ -419,6 +419,41 @@ int height); }; +// Parameters related to quantization. +typedef struct CommonQuantParams CommonQuantParams; +struct CommonQuantParams { + // Base qIndex of the frame in the range 0 to 255. + // The qindex per block may have a delta from this: see 'delta_q_info' below. + int base_qindex; + + int y_dc_delta_q; + int u_dc_delta_q; + int v_dc_delta_q; + int u_ac_delta_q; + int v_ac_delta_q; + + // The dequantizers below are true dequantizers used only in the + // dequantization process. They have the same coefficient + // shift/scale as TX. + int16_t y_dequant_QTX[MAX_SEGMENTS][2]; + int16_t u_dequant_QTX[MAX_SEGMENTS][2]; + int16_t v_dequant_QTX[MAX_SEGMENTS][2]; + + // Global quant matrix tables + const qm_val_t *giqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL]; + const qm_val_t *gqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL]; + + // Local quant matrix tables for each frame + const qm_val_t *y_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; + const qm_val_t *u_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; + const qm_val_t *v_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; + + int using_qmatrix; + int qm_y; + int qm_u; + int qm_v; +}; + typedef struct AV1Common { // Information about the current frame that is being coded. CurrentFrame current_frame; @@ -535,34 +570,8 @@ #if CONFIG_ENTROPY_STATS int coef_cdf_category; #endif - - int base_qindex; - int y_dc_delta_q; - int u_dc_delta_q; - int v_dc_delta_q; - int u_ac_delta_q; - int v_ac_delta_q; - - // The dequantizers below are true dequantizers used only in the - // dequantization process. They have the same coefficient - // shift/scale as TX. - int16_t y_dequant_QTX[MAX_SEGMENTS][2]; - int16_t u_dequant_QTX[MAX_SEGMENTS][2]; - int16_t v_dequant_QTX[MAX_SEGMENTS][2]; - - // Global quant matrix tables - const qm_val_t *giqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL]; - const qm_val_t *gqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL]; - - // Local quant matrix tables for each frame - const qm_val_t *y_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; - const qm_val_t *u_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; - const qm_val_t *v_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; - - int using_qmatrix; - int qm_y; - int qm_u; - int qm_v; + // Quantization params. + CommonQuantParams quant_params; uint8_t *last_frame_seg_map; @@ -836,25 +845,28 @@ static INLINE void av1_init_macroblockd(AV1_COMMON *cm, MACROBLOCKD *xd, tran_low_t *dqcoeff) { const int num_planes = av1_num_planes(cm); + const CommonQuantParams *const quant_params = &cm->quant_params; + for (int i = 0; i < num_planes; ++i) { xd->plane[i].dqcoeff = dqcoeff; if (xd->plane[i].plane_type == PLANE_TYPE_Y) { - memcpy(xd->plane[i].seg_dequant_QTX, cm->y_dequant_QTX, - sizeof(cm->y_dequant_QTX)); - memcpy(xd->plane[i].seg_iqmatrix, cm->y_iqmatrix, sizeof(cm->y_iqmatrix)); + memcpy(xd->plane[i].seg_dequant_QTX, quant_params->y_dequant_QTX, + sizeof(quant_params->y_dequant_QTX)); + memcpy(xd->plane[i].seg_iqmatrix, quant_params->y_iqmatrix, + sizeof(quant_params->y_iqmatrix)); } else { if (i == AOM_PLANE_U) { - memcpy(xd->plane[i].seg_dequant_QTX, cm->u_dequant_QTX, - sizeof(cm->u_dequant_QTX)); - memcpy(xd->plane[i].seg_iqmatrix, cm->u_iqmatrix, - sizeof(cm->u_iqmatrix)); + memcpy(xd->plane[i].seg_dequant_QTX, quant_params->u_dequant_QTX, + sizeof(quant_params->u_dequant_QTX)); + memcpy(xd->plane[i].seg_iqmatrix, quant_params->u_iqmatrix, + sizeof(quant_params->u_iqmatrix)); } else { - memcpy(xd->plane[i].seg_dequant_QTX, cm->v_dequant_QTX, - sizeof(cm->v_dequant_QTX)); - memcpy(xd->plane[i].seg_iqmatrix, cm->v_iqmatrix, - sizeof(cm->v_iqmatrix)); + memcpy(xd->plane[i].seg_dequant_QTX, quant_params->v_dequant_QTX, + sizeof(quant_params->v_dequant_QTX)); + memcpy(xd->plane[i].seg_iqmatrix, quant_params->v_iqmatrix, + sizeof(quant_params->v_iqmatrix)); } } }
diff --git a/av1/common/debugmodes.c b/av1/common/debugmodes.c index 7e1ab12..ff02ddd 100644 --- a/av1/common/debugmodes.c +++ b/av1/common/debugmodes.c
@@ -18,7 +18,7 @@ static void log_frame_info(AV1_COMMON *cm, const char *str, FILE *f) { fprintf(f, "%s", str); fprintf(f, "(Frame %d, Show:%d, Q:%d): \n", cm->current_frame.frame_number, - cm->show_frame, cm->base_qindex); + cm->show_frame, cm->quant_params.base_qindex); } /* This function dereferences a pointer to the mbmi structure * and uses the passed in member offset to print out the value of an integer
diff --git a/av1/common/entropy.c b/av1/common/entropy.c index cd63fd2..1f7a0ef 100644 --- a/av1/common/entropy.c +++ b/av1/common/entropy.c
@@ -29,7 +29,7 @@ } void av1_default_coef_probs(AV1_COMMON *cm) { - const int index = get_q_ctx(cm->base_qindex); + const int index = get_q_ctx(cm->quant_params.base_qindex); #if CONFIG_ENTROPY_STATS cm->coef_cdf_category = index; #endif
diff --git a/av1/common/quant_common.c b/av1/common/quant_common.c index 327948c..804eb6a 100644 --- a/av1/common/quant_common.c +++ b/av1/common/quant_common.c
@@ -225,23 +225,23 @@ } } -bool av1_use_qmatrix(const AV1_COMMON *cm, const MACROBLOCKD *const xd, - int segment_id) { +bool av1_use_qmatrix(const CommonQuantParams *quant_params, + const MACROBLOCKD *const xd, int segment_id) { // True if we are using Q matrix and this is not a lossless segment. - return cm->using_qmatrix && !xd->lossless[segment_id]; + return quant_params->using_qmatrix && !xd->lossless[segment_id]; } -const qm_val_t *av1_iqmatrix(AV1_COMMON *cm, int qmlevel, int plane, - TX_SIZE tx_size) { - assert(cm->giqmatrix[qmlevel][plane][tx_size] != NULL || +const qm_val_t *av1_iqmatrix(const CommonQuantParams *quant_params, int qmlevel, + int plane, TX_SIZE tx_size) { + assert(quant_params->giqmatrix[qmlevel][plane][tx_size] != NULL || qmlevel == NUM_QM_LEVELS - 1); - return cm->giqmatrix[qmlevel][plane][tx_size]; + return quant_params->giqmatrix[qmlevel][plane][tx_size]; } -const qm_val_t *av1_qmatrix(AV1_COMMON *cm, int qmlevel, int plane, - TX_SIZE tx_size) { - assert(cm->gqmatrix[qmlevel][plane][tx_size] != NULL || +const qm_val_t *av1_qmatrix(const CommonQuantParams *quant_params, int qmlevel, + int plane, TX_SIZE tx_size) { + assert(quant_params->gqmatrix[qmlevel][plane][tx_size] != NULL || qmlevel == NUM_QM_LEVELS - 1); - return cm->gqmatrix[qmlevel][plane][tx_size]; + return quant_params->gqmatrix[qmlevel][plane][tx_size]; } #define QM_TOTAL_SIZE 3344 @@ -250,27 +250,27 @@ static const qm_val_t wt_matrix_ref[NUM_QM_LEVELS - 1][2][QM_TOTAL_SIZE]; static const qm_val_t iwt_matrix_ref[NUM_QM_LEVELS - 1][2][QM_TOTAL_SIZE]; -void av1_qm_init(AV1_COMMON *cm) { - const int num_planes = av1_num_planes(cm); - int q, c, t; - int current; - for (q = 0; q < NUM_QM_LEVELS; ++q) { - for (c = 0; c < num_planes; ++c) { - current = 0; - for (t = 0; t < TX_SIZES_ALL; ++t) { +void av1_qm_init(CommonQuantParams *quant_params, int num_planes) { + for (int q = 0; q < NUM_QM_LEVELS; ++q) { + for (int c = 0; c < num_planes; ++c) { + int current = 0; + for (int t = 0; t < TX_SIZES_ALL; ++t) { const int size = tx_size_2d[t]; const int qm_tx_size = av1_get_adjusted_tx_size(t); if (q == NUM_QM_LEVELS - 1) { - cm->gqmatrix[q][c][t] = NULL; - cm->giqmatrix[q][c][t] = NULL; + quant_params->gqmatrix[q][c][t] = NULL; + quant_params->giqmatrix[q][c][t] = NULL; } else if (t != qm_tx_size) { // Reuse matrices for 'qm_tx_size' assert(t > qm_tx_size); - cm->gqmatrix[q][c][t] = cm->gqmatrix[q][c][qm_tx_size]; - cm->giqmatrix[q][c][t] = cm->giqmatrix[q][c][qm_tx_size]; + quant_params->gqmatrix[q][c][t] = + quant_params->gqmatrix[q][c][qm_tx_size]; + quant_params->giqmatrix[q][c][t] = + quant_params->giqmatrix[q][c][qm_tx_size]; } else { assert(current + size <= QM_TOTAL_SIZE); - cm->gqmatrix[q][c][t] = &wt_matrix_ref[q][c >= 1][current]; - cm->giqmatrix[q][c][t] = &iwt_matrix_ref[q][c >= 1][current]; + quant_params->gqmatrix[q][c][t] = &wt_matrix_ref[q][c >= 1][current]; + quant_params->giqmatrix[q][c][t] = + &iwt_matrix_ref[q][c >= 1][current]; current += size; } }
diff --git a/av1/common/quant_common.h b/av1/common/quant_common.h index 7556669..8dc0419 100644 --- a/av1/common/quant_common.h +++ b/av1/common/quant_common.h
@@ -38,6 +38,7 @@ #define DEFAULT_QM_LAST 9 struct AV1Common; +struct CommonQuantParams; struct macroblockd; int16_t av1_dc_quant_QTX(int qindex, int delta, aom_bit_depth_t bit_depth); @@ -47,19 +48,22 @@ int base_qindex); // Returns true if we should use quantization matrix. -bool av1_use_qmatrix(const struct AV1Common *cm, - const struct macroblockd *const xd, int segment_id); +bool av1_use_qmatrix(const struct CommonQuantParams *quant_params, + const struct macroblockd *xd, int segment_id); // Reduce the large number of quantizers to a smaller number of levels for which // different matrices may be defined static INLINE int aom_get_qmlevel(int qindex, int first, int last) { return first + (qindex * (last + 1 - first)) / QINDEX_RANGE; } -void av1_qm_init(struct AV1Common *cm); -const qm_val_t *av1_iqmatrix(struct AV1Common *cm, int qmlevel, int plane, - TX_SIZE tx_size); -const qm_val_t *av1_qmatrix(struct AV1Common *cm, int qmlevel, int plane, - TX_SIZE tx_size); + +// Initialize all global quant/dequant matrices. +void av1_qm_init(struct CommonQuantParams *quant_params, int num_planes); + +const qm_val_t *av1_iqmatrix(const struct CommonQuantParams *quant_params, + int qmlevel, int plane, TX_SIZE tx_size); +const qm_val_t *av1_qmatrix(const struct CommonQuantParams *quant_params, + int qmlevel, int plane, TX_SIZE tx_size); #ifdef __cplusplus } // extern "C"
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c index 75f88be..2e16afe 100644 --- a/av1/decoder/decodeframe.c +++ b/av1/decoder/decodeframe.c
@@ -1450,12 +1450,14 @@ for (int i = 0; i < MAX_SEGMENTS; i++) { const int current_qindex = av1_get_qindex(&cm->seg, i, xd->current_qindex); + const CommonQuantParams *const quant_params = &cm->quant_params; for (int j = 0; j < num_planes; ++j) { - const int dc_delta_q = - j == 0 ? cm->y_dc_delta_q - : (j == 1 ? cm->u_dc_delta_q : cm->v_dc_delta_q); - const int ac_delta_q = - j == 0 ? 0 : (j == 1 ? cm->u_ac_delta_q : cm->v_ac_delta_q); + const int dc_delta_q = j == 0 ? quant_params->y_dc_delta_q + : (j == 1 ? quant_params->u_dc_delta_q + : quant_params->v_dc_delta_q); + const int ac_delta_q = j == 0 ? 0 + : (j == 1 ? quant_params->u_ac_delta_q + : quant_params->v_ac_delta_q); xd->plane[j].seg_dequant_QTX[i][0] = av1_dc_quant_QTX( current_qindex, dc_delta_q, cm->seq_params.bit_depth); xd->plane[j].seg_dequant_QTX[i][1] = av1_ac_quant_QTX( @@ -2036,42 +2038,42 @@ return aom_rb_read_bit(rb) ? aom_rb_read_inv_signed_literal(rb, 6) : 0; } -static AOM_INLINE void setup_quantization(AV1_COMMON *const cm, +static AOM_INLINE void setup_quantization(CommonQuantParams *quant_params, + int num_planes, + bool separate_uv_delta_q, struct aom_read_bit_buffer *rb) { - const SequenceHeader *const seq_params = &cm->seq_params; - const int num_planes = av1_num_planes(cm); - cm->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS); - cm->y_dc_delta_q = read_delta_q(rb); + quant_params->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS); + quant_params->y_dc_delta_q = read_delta_q(rb); if (num_planes > 1) { int diff_uv_delta = 0; - if (seq_params->separate_uv_delta_q) diff_uv_delta = aom_rb_read_bit(rb); - cm->u_dc_delta_q = read_delta_q(rb); - cm->u_ac_delta_q = read_delta_q(rb); + if (separate_uv_delta_q) diff_uv_delta = aom_rb_read_bit(rb); + quant_params->u_dc_delta_q = read_delta_q(rb); + quant_params->u_ac_delta_q = read_delta_q(rb); if (diff_uv_delta) { - cm->v_dc_delta_q = read_delta_q(rb); - cm->v_ac_delta_q = read_delta_q(rb); + quant_params->v_dc_delta_q = read_delta_q(rb); + quant_params->v_ac_delta_q = read_delta_q(rb); } else { - cm->v_dc_delta_q = cm->u_dc_delta_q; - cm->v_ac_delta_q = cm->u_ac_delta_q; + quant_params->v_dc_delta_q = quant_params->u_dc_delta_q; + quant_params->v_ac_delta_q = quant_params->u_ac_delta_q; } } else { - cm->u_dc_delta_q = 0; - cm->u_ac_delta_q = 0; - cm->v_dc_delta_q = 0; - cm->v_ac_delta_q = 0; + quant_params->u_dc_delta_q = 0; + quant_params->u_ac_delta_q = 0; + quant_params->v_dc_delta_q = 0; + quant_params->v_ac_delta_q = 0; } - cm->using_qmatrix = aom_rb_read_bit(rb); - if (cm->using_qmatrix) { - cm->qm_y = aom_rb_read_literal(rb, QM_LEVEL_BITS); - cm->qm_u = aom_rb_read_literal(rb, QM_LEVEL_BITS); - if (!seq_params->separate_uv_delta_q) - cm->qm_v = cm->qm_u; + quant_params->using_qmatrix = aom_rb_read_bit(rb); + if (quant_params->using_qmatrix) { + quant_params->qm_y = aom_rb_read_literal(rb, QM_LEVEL_BITS); + quant_params->qm_u = aom_rb_read_literal(rb, QM_LEVEL_BITS); + if (!separate_uv_delta_q) + quant_params->qm_v = quant_params->qm_u; else - cm->qm_v = aom_rb_read_literal(rb, QM_LEVEL_BITS); + quant_params->qm_v = aom_rb_read_literal(rb, QM_LEVEL_BITS); } else { - cm->qm_y = 0; - cm->qm_u = 0; - cm->qm_v = 0; + quant_params->qm_y = 0; + quant_params->qm_u = 0; + quant_params->qm_v = 0; } } @@ -2082,33 +2084,37 @@ // When segmentation is disabled, only the first value is used. The // remaining are don't cares. const int max_segments = cm->seg.enabled ? MAX_SEGMENTS : 1; + CommonQuantParams *const quant_params = &cm->quant_params; for (int i = 0; i < max_segments; ++i) { const int qindex = xd->qindex[i]; - cm->y_dequant_QTX[i][0] = - av1_dc_quant_QTX(qindex, cm->y_dc_delta_q, bit_depth); - cm->y_dequant_QTX[i][1] = av1_ac_quant_QTX(qindex, 0, bit_depth); - cm->u_dequant_QTX[i][0] = - av1_dc_quant_QTX(qindex, cm->u_dc_delta_q, bit_depth); - cm->u_dequant_QTX[i][1] = - av1_ac_quant_QTX(qindex, cm->u_ac_delta_q, bit_depth); - cm->v_dequant_QTX[i][0] = - av1_dc_quant_QTX(qindex, cm->v_dc_delta_q, bit_depth); - cm->v_dequant_QTX[i][1] = - av1_ac_quant_QTX(qindex, cm->v_ac_delta_q, bit_depth); - const int use_qmatrix = av1_use_qmatrix(cm, xd, i); + quant_params->y_dequant_QTX[i][0] = + av1_dc_quant_QTX(qindex, quant_params->y_dc_delta_q, bit_depth); + quant_params->y_dequant_QTX[i][1] = av1_ac_quant_QTX(qindex, 0, bit_depth); + quant_params->u_dequant_QTX[i][0] = + av1_dc_quant_QTX(qindex, quant_params->u_dc_delta_q, bit_depth); + quant_params->u_dequant_QTX[i][1] = + av1_ac_quant_QTX(qindex, quant_params->u_ac_delta_q, bit_depth); + quant_params->v_dequant_QTX[i][0] = + av1_dc_quant_QTX(qindex, quant_params->v_dc_delta_q, bit_depth); + quant_params->v_dequant_QTX[i][1] = + av1_ac_quant_QTX(qindex, quant_params->v_ac_delta_q, bit_depth); + const int use_qmatrix = av1_use_qmatrix(quant_params, xd, i); // NB: depends on base index so there is only 1 set per frame // No quant weighting when lossless or signalled not using QM - const int qmlevel_y = use_qmatrix ? cm->qm_y : NUM_QM_LEVELS - 1; + const int qmlevel_y = use_qmatrix ? quant_params->qm_y : NUM_QM_LEVELS - 1; for (int j = 0; j < TX_SIZES_ALL; ++j) { - cm->y_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel_y, AOM_PLANE_Y, j); + quant_params->y_iqmatrix[i][j] = + av1_iqmatrix(quant_params, qmlevel_y, AOM_PLANE_Y, j); } - const int qmlevel_u = use_qmatrix ? cm->qm_u : NUM_QM_LEVELS - 1; + const int qmlevel_u = use_qmatrix ? quant_params->qm_u : NUM_QM_LEVELS - 1; for (int j = 0; j < TX_SIZES_ALL; ++j) { - cm->u_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel_u, AOM_PLANE_U, j); + quant_params->u_iqmatrix[i][j] = + av1_iqmatrix(quant_params, qmlevel_u, AOM_PLANE_U, j); } - const int qmlevel_v = use_qmatrix ? cm->qm_v : NUM_QM_LEVELS - 1; + const int qmlevel_v = use_qmatrix ? quant_params->qm_v : NUM_QM_LEVELS - 1; for (int j = 0; j < TX_SIZES_ALL; ++j) { - cm->v_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel_v, AOM_PLANE_V, j); + quant_params->v_iqmatrix[i][j] = + av1_iqmatrix(quant_params, qmlevel_v, AOM_PLANE_V, j); } } } @@ -3053,7 +3059,7 @@ td->bit_reader = &tile_data->bit_reader; av1_zero(td->cb_buffer_base.dqcoeff); av1_tile_init(&td->xd.tile, cm, row, col); - td->xd.current_qindex = cm->base_qindex; + td->xd.current_qindex = cm->quant_params.base_qindex; setup_bool_decoder(tile_bs_buf->data, data_end, tile_bs_buf->size, &cm->error, td->bit_reader, allow_update_cdf); #if CONFIG_ACCOUNTING @@ -3123,7 +3129,7 @@ td->bit_reader = &tile_data->bit_reader; av1_zero(td->cb_buffer_base.dqcoeff); av1_tile_init(&td->xd.tile, cm, tile_row, tile_col); - td->xd.current_qindex = cm->base_qindex; + td->xd.current_qindex = cm->quant_params.base_qindex; setup_bool_decoder(tile_buffer->data, thread_data->data_end, tile_buffer->size, &thread_data->error_info, td->bit_reader, allow_update_cdf); @@ -5173,7 +5179,9 @@ "Minimum tile width requirement not satisfied"); } - setup_quantization(cm, rb); + CommonQuantParams *const quant_params = &cm->quant_params; + setup_quantization(quant_params, av1_num_planes(cm), + cm->seq_params.separate_uv_delta_q, rb); xd->bd = (int)seq_params->bit_depth; if (cm->num_allocated_above_context_planes < av1_num_planes(cm) || @@ -5196,9 +5204,9 @@ cm->delta_q_info.delta_lf_present_flag = 0; cm->delta_q_info.delta_lf_multi = 0; cm->delta_q_info.delta_q_present_flag = - cm->base_qindex > 0 ? aom_rb_read_bit(rb) : 0; + quant_params->base_qindex > 0 ? aom_rb_read_bit(rb) : 0; if (cm->delta_q_info.delta_q_present_flag) { - xd->current_qindex = cm->base_qindex; + xd->current_qindex = quant_params->base_qindex; cm->delta_q_info.delta_q_res = 1 << aom_rb_read_literal(rb, 2); if (!features->allow_intrabc) cm->delta_q_info.delta_lf_present_flag = aom_rb_read_bit(rb); @@ -5212,10 +5220,11 @@ xd->cur_frame_force_integer_mv = features->cur_frame_force_integer_mv; for (int i = 0; i < MAX_SEGMENTS; ++i) { - const int qindex = av1_get_qindex(&cm->seg, i, cm->base_qindex); - xd->lossless[i] = qindex == 0 && cm->y_dc_delta_q == 0 && - cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 && - cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0; + const int qindex = av1_get_qindex(&cm->seg, i, quant_params->base_qindex); + xd->lossless[i] = + qindex == 0 && quant_params->y_dc_delta_q == 0 && + quant_params->u_dc_delta_q == 0 && quant_params->u_ac_delta_q == 0 && + quant_params->v_dc_delta_q == 0 && quant_params->v_ac_delta_q == 0; xd->qindex[i] = qindex; } features->coded_lossless = is_coded_lossless(cm, xd);
diff --git a/av1/decoder/decoder.c b/av1/decoder/decoder.c index 7cfe1ed..fc5f2cd 100644 --- a/av1/decoder/decoder.c +++ b/av1/decoder/decoder.c
@@ -137,7 +137,7 @@ av1_loop_filter_init(cm); - av1_qm_init(cm); + av1_qm_init(&cm->quant_params, av1_num_planes(cm)); av1_loop_restoration_precal(); #if CONFIG_ACCOUNTING pbi->acct_enabled = 1;
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c index 116b64c7..aa08022 100644 --- a/av1/decoder/decodetxb.c +++ b/av1/decoder/decodetxb.c
@@ -165,7 +165,7 @@ const qm_val_t *iqmatrix = IS_2D_TRANSFORM(tx_type) ? pd->seg_iqmatrix[mbmi->segment_id][qm_tx_size] - : cm->giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; + : cm->quant_params.giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type); const int16_t *const scan = scan_order->scan; int eob_extra = 0;
diff --git a/av1/decoder/inspection.c b/av1/decoder/inspection.c index 72ced47..d121a70 100644 --- a/av1/decoder/inspection.c +++ b/av1/decoder/inspection.c
@@ -37,6 +37,7 @@ struct AV1Decoder *pbi = (struct AV1Decoder *)decoder; AV1_COMMON *const cm = &pbi->common; const CommonModeInfoParams *const mi_params = &cm->mi_params; + const CommonQuantParams *quant_params = &cm->quant_params; if (fd->mi_rows != mi_params->mi_rows || fd->mi_cols != mi_params->mi_cols) { ifd_clear(fd); @@ -46,7 +47,7 @@ fd->frame_number = cm->current_frame.frame_number; fd->show_frame = cm->show_frame; fd->frame_type = cm->current_frame.frame_type; - fd->base_qindex = cm->base_qindex; + fd->base_qindex = quant_params->base_qindex; // Set width and height of the first tile until generic support can be added TileInfo tile_info; av1_tile_set_row(&tile_info, cm, 0); @@ -62,9 +63,9 @@ int i, j; for (i = 0; i < MAX_SEGMENTS; i++) { for (j = 0; j < 2; j++) { - fd->y_dequant[i][j] = cm->y_dequant_QTX[i][j]; - fd->u_dequant[i][j] = cm->u_dequant_QTX[i][j]; - fd->v_dequant[i][j] = cm->v_dequant_QTX[i][j]; + fd->y_dequant[i][j] = quant_params->y_dequant_QTX[i][j]; + fd->u_dequant[i][j] = quant_params->u_dequant_QTX[i][j]; + fd->v_dequant[i][j] = quant_params->v_dequant_QTX[i][j]; } } for (j = 0; j < mi_params->mi_rows; j++) {
diff --git a/av1/encoder/aq_complexity.c b/av1/encoder/aq_complexity.c index 936eddc..1756f46 100644 --- a/av1/encoder/aq_complexity.c +++ b/av1/encoder/aq_complexity.c
@@ -61,8 +61,9 @@ void av1_setup_in_frame_q_adj(AV1_COMP *cpi) { AV1_COMMON *const cm = &cpi->common; + const int base_qindex = cm->quant_params.base_qindex; struct segmentation *const seg = &cm->seg; - int resolution_change = + const int resolution_change = cm->prev_frame && (cm->width != cm->prev_frame->width || cm->height != cm->prev_frame->height); @@ -80,7 +81,7 @@ if (is_frame_aq_enabled(cpi)) { int segment; const int aq_strength = - get_aq_c_strength(cm->base_qindex, cm->seq_params.bit_depth); + get_aq_c_strength(base_qindex, cm->seq_params.bit_depth); // Clear down the segment map. memset(cpi->segmentation_map, DEFAULT_AQ2_SEG, @@ -105,17 +106,17 @@ if (segment == DEFAULT_AQ2_SEG) continue; qindex_delta = av1_compute_qdelta_by_rate( - &cpi->rc, cm->current_frame.frame_type, cm->base_qindex, + &cpi->rc, cm->current_frame.frame_type, base_qindex, aq_c_q_adj_factor[aq_strength][segment], cm->seq_params.bit_depth); // For AQ complexity mode, we dont allow Q0 in a segment if the base // Q is not 0. Q0 (lossless) implies 4x4 only and in AQ mode 2 a segment // Q delta is sometimes applied without going back around the rd loop. // This could lead to an illegal combination of partition size and q. - if ((cm->base_qindex != 0) && ((cm->base_qindex + qindex_delta) == 0)) { - qindex_delta = -cm->base_qindex + 1; + if ((base_qindex != 0) && ((base_qindex + qindex_delta) == 0)) { + qindex_delta = -base_qindex + 1; } - if ((cm->base_qindex + qindex_delta) > 0) { + if ((base_qindex + qindex_delta) > 0) { av1_enable_segfeature(seg, segment, SEG_LVL_ALT_Q); av1_set_segdata(seg, segment, SEG_LVL_ALT_Q, qindex_delta); } @@ -152,8 +153,8 @@ const int target_rate = (int)(num / denom); double logvar; double low_var_thresh; - const int aq_strength = - get_aq_c_strength(cm->base_qindex, cm->seq_params.bit_depth); + const int aq_strength = get_aq_c_strength(cm->quant_params.base_qindex, + cm->seq_params.bit_depth); aom_clear_system_state(); low_var_thresh =
diff --git a/av1/encoder/aq_cyclicrefresh.c b/av1/encoder/aq_cyclicrefresh.c index 3866411..835998b 100644 --- a/av1/encoder/aq_cyclicrefresh.c +++ b/av1/encoder/aq_cyclicrefresh.c
@@ -96,28 +96,27 @@ int av1_cyclic_refresh_estimate_bits_at_q(const AV1_COMP *cpi, double correction_factor) { const AV1_COMMON *const cm = &cpi->common; + const FRAME_TYPE frame_type = cm->current_frame.frame_type; + const int base_qindex = cm->quant_params.base_qindex; + const int bit_depth = cm->seq_params.bit_depth; const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh; - int estimated_bits; - int mbs = cm->mi_params.MBs; - int num4x4bl = mbs << 4; + const int mbs = cm->mi_params.MBs; + const int num4x4bl = mbs << 4; // Weight for non-base segments: use actual number of blocks refreshed in // previous/just encoded frame. Note number of blocks here is in 4x4 units. - double weight_segment1 = (double)cr->actual_num_seg1_blocks / num4x4bl; - double weight_segment2 = (double)cr->actual_num_seg2_blocks / num4x4bl; + const double weight_segment1 = (double)cr->actual_num_seg1_blocks / num4x4bl; + const double weight_segment2 = (double)cr->actual_num_seg2_blocks / num4x4bl; // Take segment weighted average for estimated bits. - estimated_bits = + const int estimated_bits = (int)((1.0 - weight_segment1 - weight_segment2) * - av1_estimate_bits_at_q(cm->current_frame.frame_type, - cm->base_qindex, mbs, correction_factor, - cm->seq_params.bit_depth) + + av1_estimate_bits_at_q(frame_type, base_qindex, mbs, + correction_factor, bit_depth) + weight_segment1 * av1_estimate_bits_at_q( - cm->current_frame.frame_type, - cm->base_qindex + cr->qindex_delta[1], mbs, - correction_factor, cm->seq_params.bit_depth) + + frame_type, base_qindex + cr->qindex_delta[1], + mbs, correction_factor, bit_depth) + weight_segment2 * av1_estimate_bits_at_q( - cm->current_frame.frame_type, - cm->base_qindex + cr->qindex_delta[2], mbs, - correction_factor, cm->seq_params.bit_depth)); + frame_type, base_qindex + cr->qindex_delta[2], + mbs, correction_factor, bit_depth)); return estimated_bits; } @@ -293,10 +292,10 @@ // TODO(any): Ensure the population of // cpi->common.features.allow_screen_content_tools and use the same instead // of cpi->oxcf.content == AOM_CONTENT_SCREEN - int qindex_thresh = - cpi->oxcf.content == AOM_CONTENT_SCREEN - ? av1_get_qindex(&cm->seg, CR_SEGMENT_ID_BOOST2, cm->base_qindex) - : 0; + int qindex_thresh = cpi->oxcf.content == AOM_CONTENT_SCREEN + ? av1_get_qindex(&cm->seg, CR_SEGMENT_ID_BOOST2, + cm->quant_params.base_qindex) + : 0; assert(mi_row >= 0 && mi_row < mi_params->mi_rows); assert(mi_col >= 0 && mi_col < mi_params->mi_cols); bl_index = mi_row * mi_params->mi_cols + mi_col; @@ -431,8 +430,8 @@ } return; } else { - const double q = - av1_convert_qindex_to_q(cm->base_qindex, cm->seq_params.bit_depth); + const double q = av1_convert_qindex_to_q(cm->quant_params.base_qindex, + cm->seq_params.bit_depth); aom_clear_system_state(); // Set rate threshold to some multiple (set to 2 for now) of the target // rate (target is given by sb64_target_rate and scaled by 256). @@ -463,20 +462,22 @@ av1_enable_segfeature(seg, CR_SEGMENT_ID_BOOST2, SEG_LVL_ALT_Q); // Set the q delta for segment BOOST1. + const CommonQuantParams *const quant_params = &cm->quant_params; int qindex_delta = - compute_deltaq(cpi, cm->base_qindex, cr->rate_ratio_qdelta); + compute_deltaq(cpi, quant_params->base_qindex, cr->rate_ratio_qdelta); cr->qindex_delta[1] = qindex_delta; // Compute rd-mult for segment BOOST1. - const int qindex2 = - clamp(cm->base_qindex + cm->y_dc_delta_q + qindex_delta, 0, MAXQ); + const int qindex2 = clamp( + quant_params->base_qindex + quant_params->y_dc_delta_q + qindex_delta, + 0, MAXQ); cr->rdmult = av1_compute_rd_mult(cpi, qindex2); av1_set_segdata(seg, CR_SEGMENT_ID_BOOST1, SEG_LVL_ALT_Q, qindex_delta); // Set a more aggressive (higher) q delta for segment BOOST2. qindex_delta = compute_deltaq( - cpi, cm->base_qindex, + cpi, quant_params->base_qindex, AOMMIN(CR_MAX_RATE_TARGET_RATIO, 0.1 * cr->rate_boost_fac * cr->rate_ratio_qdelta)); cr->qindex_delta[2] = qindex_delta;
diff --git a/av1/encoder/aq_variance.c b/av1/encoder/aq_variance.c index 6e3cc3c..89e444d 100644 --- a/av1/encoder/aq_variance.c +++ b/av1/encoder/aq_variance.c
@@ -44,6 +44,7 @@ void av1_vaq_frame_setup(AV1_COMP *cpi) { AV1_COMMON *cm = &cpi->common; + const int base_qindex = cm->quant_params.base_qindex; struct segmentation *seg = &cm->seg; int i; @@ -78,15 +79,15 @@ // Set up avg segment id to be 1.0 and adjust the other segments around // it. int qindex_delta = av1_compute_qdelta_by_rate( - &cpi->rc, cm->current_frame.frame_type, cm->base_qindex, + &cpi->rc, cm->current_frame.frame_type, base_qindex, rate_ratio[i] / avg_ratio, cm->seq_params.bit_depth); // We don't allow qindex 0 in a segment if the base value is not 0. // Q index 0 (lossless) implies 4x4 encoding only and in AQ mode a segment // Q delta is sometimes applied without going back around the rd loop. // This could lead to an illegal combination of partition size and q. - if ((cm->base_qindex != 0) && ((cm->base_qindex + qindex_delta) == 0)) { - qindex_delta = -cm->base_qindex + 1; + if ((base_qindex != 0) && ((base_qindex + qindex_delta) == 0)) { + qindex_delta = -base_qindex + 1; } av1_set_segdata(seg, i, SEG_LVL_ALT_Q, qindex_delta); @@ -193,12 +194,13 @@ } else { rate_level = block_var_level; } + const int base_qindex = cm->quant_params.base_qindex; int qindex_delta = av1_compute_qdelta_by_rate( - &cpi->rc, cm->current_frame.frame_type, cm->base_qindex, + &cpi->rc, cm->current_frame.frame_type, base_qindex, deltaq_rate_ratio[rate_level], cm->seq_params.bit_depth); - if ((cm->base_qindex != 0) && ((cm->base_qindex + qindex_delta) == 0)) { - qindex_delta = -cm->base_qindex + 1; + if ((base_qindex != 0) && ((base_qindex + qindex_delta) == 0)) { + qindex_delta = -base_qindex + 1; } - return cm->base_qindex + qindex_delta; + return base_qindex + qindex_delta; }
diff --git a/av1/encoder/av1_quantize.c b/av1/encoder/av1_quantize.c index bf649d2..995c90b 100644 --- a/av1/encoder/av1_quantize.c +++ b/av1/encoder/av1_quantize.c
@@ -649,30 +649,35 @@ } void av1_init_quantizer(AV1_COMP *cpi) { - AV1_COMMON *const cm = &cpi->common; + const AV1_COMMON *const cm = &cpi->common; + const CommonQuantParams *const quant_params = &cm->quant_params; QUANTS *const quants = &cpi->quants; Dequants *const dequants = &cpi->dequants; - av1_build_quantizer(cm->seq_params.bit_depth, cm->y_dc_delta_q, - cm->u_dc_delta_q, cm->u_ac_delta_q, cm->v_dc_delta_q, - cm->v_ac_delta_q, quants, dequants); + av1_build_quantizer(cm->seq_params.bit_depth, quant_params->y_dc_delta_q, + quant_params->u_dc_delta_q, quant_params->u_ac_delta_q, + quant_params->v_dc_delta_q, quant_params->v_ac_delta_q, + quants, dequants); } void av1_init_plane_quantizers(const AV1_COMP *cpi, MACROBLOCK *x, int segment_id) { const AV1_COMMON *const cm = &cpi->common; + const CommonQuantParams *const quant_params = &cm->quant_params; MACROBLOCKD *const xd = &x->e_mbd; const QUANTS *const quants = &cpi->quants; - const int current_qindex = AOMMAX( - 0, AOMMIN(QINDEX_RANGE - 1, cm->delta_q_info.delta_q_present_flag - ? cm->base_qindex + xd->delta_qindex - : cm->base_qindex)); + const int current_qindex = + AOMMAX(0, AOMMIN(QINDEX_RANGE - 1, + cm->delta_q_info.delta_q_present_flag + ? quant_params->base_qindex + xd->delta_qindex + : quant_params->base_qindex)); const int qindex = av1_get_qindex(&cm->seg, segment_id, current_qindex); - const int rdmult = av1_compute_rd_mult(cpi, qindex + cm->y_dc_delta_q); - const int use_qmatrix = av1_use_qmatrix(cm, xd, segment_id); + const int rdmult = + av1_compute_rd_mult(cpi, qindex + quant_params->y_dc_delta_q); + const int use_qmatrix = av1_use_qmatrix(quant_params, xd, segment_id); // Y - const int qmlevel_y = use_qmatrix ? cm->qm_y : NUM_QM_LEVELS - 1; + const int qmlevel_y = use_qmatrix ? quant_params->qm_y : NUM_QM_LEVELS - 1; x->plane[0].quant_QTX = quants->y_quant[qindex]; x->plane[0].quant_fp_QTX = quants->y_quant_fp[qindex]; x->plane[0].round_fp_QTX = quants->y_round_fp[qindex]; @@ -680,13 +685,15 @@ x->plane[0].zbin_QTX = quants->y_zbin[qindex]; x->plane[0].round_QTX = quants->y_round[qindex]; x->plane[0].dequant_QTX = cpi->dequants.y_dequant_QTX[qindex]; - memcpy(&xd->plane[0].seg_qmatrix[segment_id], cm->gqmatrix[qmlevel_y][0], - sizeof(cm->gqmatrix[qmlevel_y][0])); - memcpy(&xd->plane[0].seg_iqmatrix[segment_id], cm->giqmatrix[qmlevel_y][0], - sizeof(cm->giqmatrix[qmlevel_y][0])); + memcpy(&xd->plane[0].seg_qmatrix[segment_id], + quant_params->gqmatrix[qmlevel_y][0], + sizeof(quant_params->gqmatrix[qmlevel_y][0])); + memcpy(&xd->plane[0].seg_iqmatrix[segment_id], + quant_params->giqmatrix[qmlevel_y][0], + sizeof(quant_params->giqmatrix[qmlevel_y][0])); // U - const int qmlevel_u = use_qmatrix ? cm->qm_u : NUM_QM_LEVELS - 1; + const int qmlevel_u = use_qmatrix ? quant_params->qm_u : NUM_QM_LEVELS - 1; x->plane[1].quant_QTX = quants->u_quant[qindex]; x->plane[1].quant_fp_QTX = quants->u_quant_fp[qindex]; x->plane[1].round_fp_QTX = quants->u_round_fp[qindex]; @@ -694,12 +701,14 @@ x->plane[1].zbin_QTX = quants->u_zbin[qindex]; x->plane[1].round_QTX = quants->u_round[qindex]; x->plane[1].dequant_QTX = cpi->dequants.u_dequant_QTX[qindex]; - memcpy(&xd->plane[1].seg_qmatrix[segment_id], cm->gqmatrix[qmlevel_u][1], - sizeof(cm->gqmatrix[qmlevel_u][1])); - memcpy(&xd->plane[1].seg_iqmatrix[segment_id], cm->giqmatrix[qmlevel_u][1], - sizeof(cm->giqmatrix[qmlevel_u][1])); + memcpy(&xd->plane[1].seg_qmatrix[segment_id], + quant_params->gqmatrix[qmlevel_u][1], + sizeof(quant_params->gqmatrix[qmlevel_u][1])); + memcpy(&xd->plane[1].seg_iqmatrix[segment_id], + quant_params->giqmatrix[qmlevel_u][1], + sizeof(quant_params->giqmatrix[qmlevel_u][1])); // V - const int qmlevel_v = use_qmatrix ? cm->qm_v : NUM_QM_LEVELS - 1; + const int qmlevel_v = use_qmatrix ? quant_params->qm_v : NUM_QM_LEVELS - 1; x->plane[2].quant_QTX = quants->v_quant[qindex]; x->plane[2].quant_fp_QTX = quants->v_quant_fp[qindex]; x->plane[2].round_fp_QTX = quants->v_round_fp[qindex]; @@ -707,10 +716,12 @@ x->plane[2].zbin_QTX = quants->v_zbin[qindex]; x->plane[2].round_QTX = quants->v_round[qindex]; x->plane[2].dequant_QTX = cpi->dequants.v_dequant_QTX[qindex]; - memcpy(&xd->plane[2].seg_qmatrix[segment_id], cm->gqmatrix[qmlevel_v][2], - sizeof(cm->gqmatrix[qmlevel_v][2])); - memcpy(&xd->plane[2].seg_iqmatrix[segment_id], cm->giqmatrix[qmlevel_v][2], - sizeof(cm->giqmatrix[qmlevel_v][2])); + memcpy(&xd->plane[2].seg_qmatrix[segment_id], + quant_params->gqmatrix[qmlevel_v][2], + sizeof(quant_params->gqmatrix[qmlevel_v][2])); + memcpy(&xd->plane[2].seg_iqmatrix[segment_id], + quant_params->giqmatrix[qmlevel_v][2], + sizeof(quant_params->giqmatrix[qmlevel_v][2])); x->skip_block = segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP); x->qindex = qindex; @@ -729,22 +740,25 @@ // quantizer has to be reinitialized with av1_init_quantizer() if any // delta_q changes. AV1_COMMON *const cm = &cpi->common; - cm->base_qindex = AOMMAX(cm->delta_q_info.delta_q_present_flag, q); - cm->y_dc_delta_q = 0; - cm->u_dc_delta_q = 0; - cm->u_ac_delta_q = 0; - cm->v_dc_delta_q = 0; - cm->v_ac_delta_q = 0; - cm->qm_y = - aom_get_qmlevel(cm->base_qindex, cpi->min_qmlevel, cpi->max_qmlevel); - cm->qm_u = aom_get_qmlevel(cm->base_qindex + cm->u_ac_delta_q, - cpi->min_qmlevel, cpi->max_qmlevel); + CommonQuantParams *quant_params = &cm->quant_params; + quant_params->base_qindex = AOMMAX(cm->delta_q_info.delta_q_present_flag, q); + quant_params->y_dc_delta_q = 0; + quant_params->u_dc_delta_q = 0; + quant_params->u_ac_delta_q = 0; + quant_params->v_dc_delta_q = 0; + quant_params->v_ac_delta_q = 0; + quant_params->qm_y = aom_get_qmlevel(quant_params->base_qindex, + cpi->min_qmlevel, cpi->max_qmlevel); + quant_params->qm_u = + aom_get_qmlevel(quant_params->base_qindex + quant_params->u_ac_delta_q, + cpi->min_qmlevel, cpi->max_qmlevel); if (!cm->seq_params.separate_uv_delta_q) - cm->qm_v = cm->qm_u; + quant_params->qm_v = quant_params->qm_u; else - cm->qm_v = aom_get_qmlevel(cm->base_qindex + cm->v_ac_delta_q, - cpi->min_qmlevel, cpi->max_qmlevel); + quant_params->qm_v = + aom_get_qmlevel(quant_params->base_qindex + quant_params->v_ac_delta_q, + cpi->min_qmlevel, cpi->max_qmlevel); } // Table that converts 0-63 Q-range values passed in outside to the Qindex
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c index fc8a1de..a7f1cf5 100644 --- a/av1/encoder/bitstream.c +++ b/av1/encoder/bitstream.c
@@ -794,7 +794,7 @@ const FeatureFlags *const features = &cm->features; const int is_inter = is_inter_block(mbmi); if (get_ext_tx_types(tx_size, is_inter, features->reduced_tx_set_used) > 1 && - ((!cm->seg.enabled && cm->base_qindex > 0) || + ((!cm->seg.enabled && cm->quant_params.base_qindex > 0) || (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) && !mbmi->skip && !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { @@ -1691,7 +1691,7 @@ av1_init_above_context(cm, xd, tile->tile_row); if (cpi->common.delta_q_info.delta_q_present_flag) { - xd->current_qindex = cpi->common.base_qindex; + xd->current_qindex = cpi->common.quant_params.base_qindex; if (cpi->common.delta_q_info.delta_lf_present_flag) { av1_reset_loop_filter_delta(xd, av1_num_planes(cm)); } @@ -2026,31 +2026,31 @@ } } -static AOM_INLINE void encode_quantization(const AV1_COMMON *const cm, - struct aom_write_bit_buffer *wb) { - const int num_planes = av1_num_planes(cm); - - aom_wb_write_literal(wb, cm->base_qindex, QINDEX_BITS); - write_delta_q(wb, cm->y_dc_delta_q); +static AOM_INLINE void encode_quantization( + const CommonQuantParams *const quant_params, int num_planes, + bool separate_uv_delta_q, struct aom_write_bit_buffer *wb) { + aom_wb_write_literal(wb, quant_params->base_qindex, QINDEX_BITS); + write_delta_q(wb, quant_params->y_dc_delta_q); if (num_planes > 1) { - int diff_uv_delta = (cm->u_dc_delta_q != cm->v_dc_delta_q) || - (cm->u_ac_delta_q != cm->v_ac_delta_q); - if (cm->seq_params.separate_uv_delta_q) aom_wb_write_bit(wb, diff_uv_delta); - write_delta_q(wb, cm->u_dc_delta_q); - write_delta_q(wb, cm->u_ac_delta_q); + int diff_uv_delta = + (quant_params->u_dc_delta_q != quant_params->v_dc_delta_q) || + (quant_params->u_ac_delta_q != quant_params->v_ac_delta_q); + if (separate_uv_delta_q) aom_wb_write_bit(wb, diff_uv_delta); + write_delta_q(wb, quant_params->u_dc_delta_q); + write_delta_q(wb, quant_params->u_ac_delta_q); if (diff_uv_delta) { - write_delta_q(wb, cm->v_dc_delta_q); - write_delta_q(wb, cm->v_ac_delta_q); + write_delta_q(wb, quant_params->v_dc_delta_q); + write_delta_q(wb, quant_params->v_ac_delta_q); } } - aom_wb_write_bit(wb, cm->using_qmatrix); - if (cm->using_qmatrix) { - aom_wb_write_literal(wb, cm->qm_y, QM_LEVEL_BITS); - aom_wb_write_literal(wb, cm->qm_u, QM_LEVEL_BITS); - if (!cm->seq_params.separate_uv_delta_q) - assert(cm->qm_u == cm->qm_v); + aom_wb_write_bit(wb, quant_params->using_qmatrix); + if (quant_params->using_qmatrix) { + aom_wb_write_literal(wb, quant_params->qm_y, QM_LEVEL_BITS); + aom_wb_write_literal(wb, quant_params->qm_u, QM_LEVEL_BITS); + if (!separate_uv_delta_q) + assert(quant_params->qm_u == quant_params->qm_v); else - aom_wb_write_literal(wb, cm->qm_v, QM_LEVEL_BITS); + aom_wb_write_literal(wb, quant_params->qm_v, QM_LEVEL_BITS); } } @@ -2826,6 +2826,7 @@ struct aom_write_bit_buffer *wb) { AV1_COMMON *const cm = &cpi->common; const SequenceHeader *const seq_params = &cm->seq_params; + const CommonQuantParams *quant_params = &cm->quant_params; MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; CurrentFrame *const current_frame = &cm->current_frame; FeatureFlags *const features = &cm->features; @@ -3067,16 +3068,17 @@ } write_tile_info(cm, saved_wb, wb); - encode_quantization(cm, wb); + encode_quantization(quant_params, av1_num_planes(cm), + cm->seq_params.separate_uv_delta_q, wb); encode_segmentation(cm, xd, wb); const DeltaQInfo *const delta_q_info = &cm->delta_q_info; - if (delta_q_info->delta_q_present_flag) assert(cm->base_qindex > 0); - if (cm->base_qindex > 0) { + if (delta_q_info->delta_q_present_flag) assert(quant_params->base_qindex > 0); + if (quant_params->base_qindex > 0) { aom_wb_write_bit(wb, delta_q_info->delta_q_present_flag); if (delta_q_info->delta_q_present_flag) { aom_wb_write_literal(wb, get_msb(delta_q_info->delta_q_res), 2); - xd->current_qindex = cm->base_qindex; + xd->current_qindex = quant_params->base_qindex; if (features->allow_intrabc) assert(delta_q_info->delta_lf_present_flag == 0); else
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c index d00dafc..4791e55 100644 --- a/av1/encoder/encode_strategy.c +++ b/av1/encoder/encode_strategy.c
@@ -1260,7 +1260,7 @@ cpi->td.mb.e_mbd.delta_qindex = 0; if (!frame_params.show_existing_frame) { - cm->using_qmatrix = cpi->oxcf.using_qm; + cm->quant_params.using_qmatrix = cpi->oxcf.using_qm; cpi->min_qmlevel = cpi->oxcf.qm_minlevel; cpi->max_qmlevel = cpi->oxcf.qm_maxlevel; #if !CONFIG_REALTIME_ONLY
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c index 4533204..ccf66d6 100644 --- a/av1/encoder/encodeframe.c +++ b/av1/encoder/encodeframe.c
@@ -240,9 +240,9 @@ static int set_deltaq_rdmult(const AV1_COMP *const cpi, MACROBLOCKD *const xd) { const AV1_COMMON *const cm = &cpi->common; - - return av1_compute_rd_mult( - cpi, cm->base_qindex + xd->delta_qindex + cm->y_dc_delta_q); + const CommonQuantParams *quant_params = &cm->quant_params; + return av1_compute_rd_mult(cpi, quant_params->base_qindex + xd->delta_qindex + + quant_params->y_dc_delta_q); } static AOM_INLINE void set_ssim_rdmult(const AV1_COMP *const cpi, @@ -336,8 +336,10 @@ const AV1_COMMON *const cm = &cpi->common; av1_init_plane_quantizers(cpi, x, segment_id); aom_clear_system_state(); - int segment_qindex = av1_get_qindex(&cm->seg, segment_id, cm->base_qindex); - return av1_compute_rd_mult(cpi, segment_qindex + cm->y_dc_delta_q); + const int segment_qindex = + av1_get_qindex(&cm->seg, segment_id, cm->quant_params.base_qindex); + return av1_compute_rd_mult(cpi, + segment_qindex + cm->quant_params.y_dc_delta_q); } static AOM_INLINE void setup_block_rdmult(const AV1_COMP *const cpi, @@ -4028,12 +4030,13 @@ int64_t mc_dep_cost = 0; const int mi_wide = mi_size_wide[bsize]; const int mi_high = mi_size_high[bsize]; + const int base_qindex = cm->quant_params.base_qindex; - if (tpl_frame->is_valid == 0) return cm->base_qindex; + if (tpl_frame->is_valid == 0) return base_qindex; - if (!is_frame_tpl_eligible(cpi)) return cm->base_qindex; + if (!is_frame_tpl_eligible(cpi)) return base_qindex; - if (cpi->gf_group.index >= MAX_LAG_BUFFERS) return cm->base_qindex; + if (cpi->gf_group.index >= MAX_LAG_BUFFERS) return base_qindex; #if !USE_TPL_CLASSIC_MODEL int64_t mc_count = 0, mc_saved = 0; @@ -4073,13 +4076,13 @@ beta = (r0 / rk); assert(beta > 0.0); } - offset = av1_get_deltaq_offset(cpi, cm->base_qindex, beta); + offset = av1_get_deltaq_offset(cpi, base_qindex, beta); aom_clear_system_state(); const DeltaQInfo *const delta_q_info = &cm->delta_q_info; offset = AOMMIN(offset, delta_q_info->delta_q_res * 9 - 1); offset = AOMMAX(offset, -delta_q_info->delta_q_res * 9 + 1); - int qindex = cm->base_qindex + offset; + int qindex = cm->quant_params.base_qindex + offset; qindex = AOMMIN(qindex, MAXQ); qindex = AOMMAX(qindex, MINQ); @@ -4099,7 +4102,7 @@ // Delta-q modulation based on variance av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, sb_size); - int current_qindex = cm->base_qindex; + int current_qindex = cm->quant_params.base_qindex; if (cpi->oxcf.deltaq_mode == DELTA_Q_PERCEPTUAL) { if (DELTA_Q_PERCEPTUAL_MODULATION == 1) { const int block_wavelet_energy_level = @@ -4126,7 +4129,7 @@ current_qindex = clamp(current_qindex, delta_q_res, 256 - delta_q_info->delta_q_res); } else { - current_qindex = cm->base_qindex; + current_qindex = cm->quant_params.base_qindex; } MACROBLOCKD *const xd = &x->e_mbd; @@ -4140,7 +4143,7 @@ current_qindex = AOMMAX(current_qindex, MINQ + 1); assert(current_qindex > 0); - xd->delta_qindex = current_qindex - cm->base_qindex; + xd->delta_qindex = current_qindex - cm->quant_params.base_qindex; set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); xd->mi[0]->current_qindex = current_qindex; av1_init_plane_quantizers(cpi, x, xd->mi[0]->segment_id); @@ -4869,7 +4872,7 @@ // Reset delta for every tile if (mi_row == tile_info->mi_row_start || cpi->row_mt) { if (cm->delta_q_info.delta_q_present_flag) - xd->current_qindex = cm->base_qindex; + xd->current_qindex = cm->quant_params.base_qindex; if (cm->delta_q_info.delta_lf_present_flag) { av1_reset_loop_filter_delta(xd, av1_num_planes(cm)); } @@ -5686,13 +5689,15 @@ } } + const CommonQuantParams *quant_params = &cm->quant_params; for (i = 0; i < MAX_SEGMENTS; ++i) { - const int qindex = cm->seg.enabled - ? av1_get_qindex(&cm->seg, i, cm->base_qindex) - : cm->base_qindex; - xd->lossless[i] = qindex == 0 && cm->y_dc_delta_q == 0 && - cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 && - cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0; + const int qindex = + cm->seg.enabled ? av1_get_qindex(&cm->seg, i, quant_params->base_qindex) + : quant_params->base_qindex; + xd->lossless[i] = + qindex == 0 && quant_params->y_dc_delta_q == 0 && + quant_params->u_dc_delta_q == 0 && quant_params->u_ac_delta_q == 0 && + quant_params->v_dc_delta_q == 0 && quant_params->v_ac_delta_q == 0; if (xd->lossless[i]) cpi->has_lossless_segment = 1; xd->qindex[i] = qindex; if (xd->lossless[i]) { @@ -5733,12 +5738,12 @@ // update delta_q_present_flag and delta_lf_present_flag based on // base_qindex - cm->delta_q_info.delta_q_present_flag &= cm->base_qindex > 0; - cm->delta_q_info.delta_lf_present_flag &= cm->base_qindex > 0; + cm->delta_q_info.delta_q_present_flag &= quant_params->base_qindex > 0; + cm->delta_q_info.delta_lf_present_flag &= quant_params->base_qindex > 0; av1_frame_init_quantizer(cpi); av1_initialize_rd_consts(cpi); - av1_initialize_me_consts(cpi, x, cm->base_qindex); + av1_initialize_me_consts(cpi, x, quant_params->base_qindex); init_encode_frame_mb_context(cpi); set_default_interp_skip_flags(cpi);
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c index d855d2f..95b4e03 100644 --- a/av1/encoder/encodemb.c +++ b/av1/encoder/encodemb.c
@@ -338,21 +338,23 @@ qparam->qmatrix = NULL; qparam->iqmatrix = NULL; } -void av1_setup_qmatrix(const AV1_COMMON *cm, MACROBLOCK *x, int plane, - TX_SIZE tx_size, TX_TYPE tx_type, QUANT_PARAM *qparam) { - MACROBLOCKD *const xd = &x->e_mbd; +void av1_setup_qmatrix(const CommonQuantParams *quant_params, + const MACROBLOCK *x, int plane, TX_SIZE tx_size, + TX_TYPE tx_type, QUANT_PARAM *qparam) { + const MACROBLOCKD *const xd = &x->e_mbd; const struct macroblockd_plane *const pd = &xd->plane[plane]; - MB_MODE_INFO *const mbmi = xd->mi[0]; - int seg_id = mbmi->segment_id; + const MB_MODE_INFO *const mbmi = xd->mi[0]; + const int seg_id = mbmi->segment_id; const TX_SIZE qm_tx_size = av1_get_adjusted_tx_size(tx_size); // Use a flat matrix (i.e. no weighting) for 1D and Identity transforms const qm_val_t *qmatrix = - IS_2D_TRANSFORM(tx_type) ? pd->seg_qmatrix[seg_id][qm_tx_size] - : cm->gqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; + IS_2D_TRANSFORM(tx_type) + ? pd->seg_qmatrix[seg_id][qm_tx_size] + : quant_params->gqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; const qm_val_t *iqmatrix = IS_2D_TRANSFORM(tx_type) ? pd->seg_iqmatrix[seg_id][qm_tx_size] - : cm->giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; + : quant_params->giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; qparam->qmatrix = qmatrix; qparam->iqmatrix = iqmatrix; } @@ -396,7 +398,8 @@ av1_setup_xform(cm, x, tx_size, tx_type, &txfm_param); av1_setup_quant(tx_size, use_trellis, quant_idx, cpi->use_quant_b_adapt, &quant_param); - av1_setup_qmatrix(cm, x, plane, tx_size, tx_type, &quant_param); + av1_setup_qmatrix(&cm->quant_params, x, plane, tx_size, tx_type, + &quant_param); av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, &txfm_param, &quant_param); @@ -413,7 +416,8 @@ args->cpi->sf.rd_sf.trellis_eob_fast, &dummy_rate_cost); } if (!quant_param.use_optimize_b && do_dropout) { - av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, cm->base_qindex); + av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, + cm->quant_params.base_qindex); } } else { p->eobs[block] = 0; @@ -585,7 +589,8 @@ av1_setup_xform(cm, x, tx_size, DCT_DCT, &txfm_param); av1_setup_quant(tx_size, 0, AV1_XFORM_QUANT_B, cpi->use_quant_b_adapt, &quant_param); - av1_setup_qmatrix(cm, x, plane, tx_size, DCT_DCT, &quant_param); + av1_setup_qmatrix(&cm->quant_params, x, plane, tx_size, DCT_DCT, + &quant_param); av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, &txfm_param, &quant_param); @@ -726,7 +731,8 @@ av1_setup_xform(cm, x, tx_size, tx_type, &txfm_param); av1_setup_quant(tx_size, use_trellis, quant_idx, cpi->use_quant_b_adapt, &quant_param); - av1_setup_qmatrix(cm, x, plane, tx_size, tx_type, &quant_param); + av1_setup_qmatrix(&cm->quant_params, x, plane, tx_size, tx_type, + &quant_param); av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, &txfm_param, &quant_param); @@ -753,7 +759,8 @@ args->cpi->sf.rd_sf.trellis_eob_fast, &dummy_rate_cost); } if (do_dropout) { - av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, cm->base_qindex); + av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, + cm->quant_params.base_qindex); } }
diff --git a/av1/encoder/encodemb.h b/av1/encoder/encodemb.h index 2abe8ff..e05f4ce 100644 --- a/av1/encoder/encodemb.h +++ b/av1/encoder/encodemb.h
@@ -68,8 +68,9 @@ TX_TYPE tx_type, TxfmParam *txfm_param); void av1_setup_quant(TX_SIZE tx_size, int use_optimize_b, int xform_quant_idx, int use_quant_b_adapt, QUANT_PARAM *qparam); -void av1_setup_qmatrix(const AV1_COMMON *cm, MACROBLOCK *x, int plane, - TX_SIZE tx_size, TX_TYPE tx_type, QUANT_PARAM *qparam); +void av1_setup_qmatrix(const CommonQuantParams *quant_params, + const MACROBLOCK *x, int plane, TX_SIZE tx_size, + TX_TYPE tx_type, QUANT_PARAM *qparam); void av1_xform_quant(MACROBLOCK *x, int plane, int block, int blk_row, int blk_col, BLOCK_SIZE plane_bsize, TxfmParam *txfm_param,
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c index 0e25acc..f7864e9 100644 --- a/av1/encoder/encoder.c +++ b/av1/encoder/encoder.c
@@ -3430,7 +3430,7 @@ * av1_init_quantizer() for every frame. */ av1_init_quantizer(cpi); - av1_qm_init(cm); + av1_qm_init(&cm->quant_params, av1_num_planes(cm)); av1_loop_filter_init(cm); cm->superres_scale_denominator = SCALE_NUMERATOR; @@ -5837,7 +5837,7 @@ // Note: Both use common rdmult based on base qindex of fullres. const int64_t rdmult = - av1_compute_rd_mult_based_on_qindex(cpi, cm->base_qindex); + av1_compute_rd_mult_based_on_qindex(cpi, cm->quant_params.base_qindex); #if SUPERRES_RECODE_ALL_RATIOS // Find the best rdcost among all superres denoms. @@ -6904,7 +6904,9 @@ return 0; } -int av1_get_quantizer(AV1_COMP *cpi) { return cpi->common.base_qindex; } +int av1_get_quantizer(AV1_COMP *cpi) { + return cpi->common.quant_params.base_qindex; +} int av1_convert_sect5obus_to_annexb(uint8_t *buffer, size_t *frame_size) { size_t output_size = 0;
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c index c2941a5..697192e 100644 --- a/av1/encoder/encodetxb.c +++ b/av1/encoder/encodetxb.c
@@ -1754,7 +1754,8 @@ const qm_val_t *iqmatrix = IS_2D_TRANSFORM(tx_type) ? pd->seg_iqmatrix[xd->mi[0]->segment_id][qm_tx_size] - : cpi->common.giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; + : cpi->common.quant_params + .giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; const int block_offset = BLOCK_OFFSET(block); tran_low_t *qcoeff = p->qcoeff + block_offset; tran_low_t *dqcoeff = pd->dqcoeff + block_offset; @@ -1951,7 +1952,7 @@ const qm_val_t *iqmatrix = IS_2D_TRANSFORM(tx_type) ? pd->seg_iqmatrix[mbmi->segment_id][qm_tx_size] - : cm->giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; + : cm->quant_params.giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; assert(width == (1 << bwl)); const int tx_type_cost = get_tx_type_cost(x, xd, plane, tx_size, tx_type, reduced_tx_set_used); @@ -2036,7 +2037,7 @@ } if (get_ext_tx_types(tx_size, is_inter, reduced_tx_set_used) > 1 && - cm->base_qindex > 0 && !mbmi->skip && + cm->quant_params.base_qindex > 0 && !mbmi->skip && !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { const int eset = get_ext_tx_set(tx_size, is_inter, reduced_tx_set_used); if (eset > 0) {
diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c index 5a85037..21fdfe0 100644 --- a/av1/encoder/intra_mode_search.c +++ b/av1/encoder/intra_mode_search.c
@@ -1733,7 +1733,8 @@ const int mode_cost = x->mbmode_cost[size_group_lookup[bsize]][mode] + ref_frame_cost; const int intra_cost_penalty = av1_get_intra_cost_penalty( - cm->base_qindex, cm->y_dc_delta_q, cm->seq_params.bit_depth); + cm->quant_params.base_qindex, cm->quant_params.y_dc_delta_q, + cm->seq_params.bit_depth); const int skip_ctx = av1_get_skip_context(xd); int known_rate = mode_cost;
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c index d0eb08b..a6ab0ce 100644 --- a/av1/encoder/nonrd_pickmode.c +++ b/av1/encoder/nonrd_pickmode.c
@@ -1536,11 +1536,13 @@ const int bw = block_size_wide[bsize]; const int pixels_in_block = bh * bw; struct buf_2d orig_dst = pd->dst; + const CommonQuantParams *quant_params = &cm->quant_params; #if COLLECT_PICK_MODE_STAT aom_usec_timer_start(&ms_stat.timer2); #endif int intra_cost_penalty = av1_get_intra_cost_penalty( - cm->base_qindex, cm->y_dc_delta_q, cm->seq_params.bit_depth); + quant_params->base_qindex, quant_params->y_dc_delta_q, + cm->seq_params.bit_depth); int64_t inter_mode_thresh = RDCOST(x->rdmult, intra_cost_penalty, 0); const int perform_intra_pred = cpi->sf.rt_sf.check_intra_pred_nonrd; int use_modeled_non_rd_cost = 0; @@ -1658,7 +1660,7 @@ const int use_model_yrd_large = cpi->oxcf.rc_mode == AOM_CBR && large_block && !cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id) && - cm->base_qindex; + quant_params->base_qindex; #if COLLECT_PICK_MODE_STAT ms_stat.num_blocks[bsize]++; @@ -1671,9 +1673,9 @@ // TODO(marpan): Look into reducing these conditions. For now constrain // it to avoid significant bdrate loss. - if (cpi->sf.rt_sf.use_modeled_non_rd_cost && cm->base_qindex > 120 && - x->source_variance > 100 && bsize <= BLOCK_16X16 && - x->content_state_sb != kLowVarHighSumdiff && + if (cpi->sf.rt_sf.use_modeled_non_rd_cost && + quant_params->base_qindex > 120 && x->source_variance > 100 && + bsize <= BLOCK_16X16 && x->content_state_sb != kLowVarHighSumdiff && x->content_state_sb != kHighSad) use_modeled_non_rd_cost = 1;
diff --git a/av1/encoder/pass2_strategy.c b/av1/encoder/pass2_strategy.c index c2d8620..32b98df 100644 --- a/av1/encoder/pass2_strategy.c +++ b/av1/encoder/pass2_strategy.c
@@ -2780,7 +2780,7 @@ const int pyramid_level = cpi->gf_group.layer_depth[cpi->gf_group.index]; int i; for (i = pyramid_level; i <= MAX_ARF_LAYERS; ++i) { - rc->active_best_quality[i] = cpi->common.base_qindex; + rc->active_best_quality[i] = cpi->common.quant_params.base_qindex; // if (pyramid_level >= 2) { // rc->active_best_quality[pyramid_level] = // AOMMAX(rc->active_best_quality[pyramid_level], @@ -2805,7 +2805,8 @@ (double)twopass->rolling_arf_group_actual_bits / (double)twopass->rolling_arf_group_target_bits, twopass->bpm_factor, - av1_convert_qindex_to_q(cm->base_qindex, cm->seq_params.bit_depth), + av1_convert_qindex_to_q(quant_params->base_qindex, + cm->seq_params.bit_depth), av1_convert_qindex_to_q(rc->active_worst_quality, cm->seq_params.bit_depth)); fclose(fpfile);
diff --git a/av1/encoder/pickcdef.c b/av1/encoder/pickcdef.c index cc323a2..c8b90e1 100644 --- a/av1/encoder/pickcdef.c +++ b/av1/encoder/pickcdef.c
@@ -290,11 +290,12 @@ static void pick_cdef_from_qp(AV1_COMMON *const cm) { const int bd = cm->seq_params.bit_depth; - const int q = av1_ac_quant_QTX(cm->base_qindex, 0, bd) >> (bd - 8); + const int q = + av1_ac_quant_QTX(cm->quant_params.base_qindex, 0, bd) >> (bd - 8); CdefInfo *const cdef_info = &cm->cdef_info; cdef_info->cdef_bits = 0; cdef_info->nb_cdef_strengths = 1; - cdef_info->cdef_damping = 3 + (cm->base_qindex >> 6); + cdef_info->cdef_damping = 3 + (cm->quant_params.base_qindex >> 6); int predicted_y_f1 = 0; int predicted_y_f2 = 0; @@ -362,7 +363,7 @@ const int nvfb = (mi_params->mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; const int nhfb = (mi_params->mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; int *sb_index = aom_malloc(nvfb * nhfb * sizeof(*sb_index)); - const int damping = 3 + (cm->base_qindex >> 6); + const int damping = 3 + (cm->quant_params.base_qindex >> 6); const int fast = (pick_method == CDEF_FAST_SEARCH_LVL1 || pick_method == CDEF_FAST_SEARCH_LVL2); const int total_strengths = nb_cdef_strengths[pick_method];
diff --git a/av1/encoder/picklpf.c b/av1/encoder/picklpf.c index 78cb1c8..17c9965 100644 --- a/av1/encoder/picklpf.c +++ b/av1/encoder/picklpf.c
@@ -213,8 +213,8 @@ } else if (method >= LPF_PICK_FROM_Q) { const int min_filter_level = 0; const int max_filter_level = av1_get_max_filter_level(cpi); - const int q = - av1_ac_quant_QTX(cm->base_qindex, 0, cm->seq_params.bit_depth); + const int q = av1_ac_quant_QTX(cm->quant_params.base_qindex, 0, + cm->seq_params.bit_depth); // based on tests result for rtc test set // 0.04590 boosted or 0.02295 non-booseted in 18-bit fixed point const int strength_boost_q_treshold = 700;
diff --git a/av1/encoder/pickrst.c b/av1/encoder/pickrst.c index 50d70a7..ccbe1cc 100644 --- a/av1/encoder/pickrst.c +++ b/av1/encoder/pickrst.c
@@ -1464,7 +1464,7 @@ if (rsc->sf->lpf_sf.prune_wiener_based_on_src_var) { const int scale[3] = { 0, 1, 2 }; // Obtain the normalized Qscale - const int qs = av1_dc_quant_QTX(rsc->cm->base_qindex, 0, + const int qs = av1_dc_quant_QTX(rsc->cm->quant_params.base_qindex, 0, rsc->cm->seq_params.bit_depth) >> 3; // Derive threshold as sqr(normalized Qscale) * scale / 16,
diff --git a/av1/encoder/ratectrl.c b/av1/encoder/ratectrl.c index 1a045b5..992d1fb 100644 --- a/av1/encoder/ratectrl.c +++ b/av1/encoder/ratectrl.c
@@ -492,7 +492,7 @@ av1_cyclic_refresh_estimate_bits_at_q(cpi, rate_correction_factor); } else { projected_size_based_on_q = av1_estimate_bits_at_q( - cpi->common.current_frame.frame_type, cm->base_qindex, MBs, + cm->current_frame.frame_type, cm->quant_params.base_qindex, MBs, rate_correction_factor, cm->seq_params.bit_depth); } // Work out a size correction factor. @@ -510,7 +510,7 @@ } cpi->rc.q_2_frame = cpi->rc.q_1_frame; - cpi->rc.q_1_frame = cm->base_qindex; + cpi->rc.q_1_frame = cm->quant_params.base_qindex; cpi->rc.rc_2_frame = cpi->rc.rc_1_frame; if (correction_factor > 110) cpi->rc.rc_1_frame = -1; @@ -1566,7 +1566,7 @@ const int is_intrnl_arf = gf_group->update_type[gf_group->index] == INTNL_ARF_UPDATE; - const int qindex = cm->base_qindex; + const int qindex = cm->quant_params.base_qindex; // Update rate control heuristics rc->projected_frame_size = (int)(bytes_used << 3);
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c index 20e2ab2..727956c 100644 --- a/av1/encoder/rd.c +++ b/av1/encoder/rd.c
@@ -391,23 +391,23 @@ int av1_get_adaptive_rdmult(const AV1_COMP *cpi, double beta) { assert(beta > 0.0); const AV1_COMMON *cm = &cpi->common; - int64_t q = - av1_dc_quant_QTX(cm->base_qindex, 0, cpi->common.seq_params.bit_depth); + int64_t q = av1_dc_quant_QTX(cm->quant_params.base_qindex, 0, + cm->seq_params.bit_depth); int64_t rdmult = 0; - switch (cpi->common.seq_params.bit_depth) { + switch (cm->seq_params.bit_depth) { case AOM_BITS_8: rdmult = (int)((88 * q * q / beta) / 24); break; case AOM_BITS_10: rdmult = ROUND_POWER_OF_TWO((int)((88 * q * q / beta) / 24), 4); break; default: - assert(cpi->common.seq_params.bit_depth == AOM_BITS_12); + assert(cm->seq_params.bit_depth == AOM_BITS_12); rdmult = ROUND_POWER_OF_TWO((int)((88 * q * q / beta) / 24), 8); break; } if (is_stat_consumption_stage(cpi) && - (cpi->common.current_frame.frame_type != KEY_FRAME)) { + (cm->current_frame.frame_type != KEY_FRAME)) { const GF_GROUP *const gf_group = &cpi->gf_group; const FRAME_UPDATE_TYPE frame_type = gf_group->update_type[gf_group->index]; const int boost_index = AOMMIN(15, (cpi->rc.gfu_boost / 100)); @@ -451,10 +451,10 @@ int i, bsize, segment_id; for (segment_id = 0; segment_id < MAX_SEGMENTS; ++segment_id) { - const int qindex = - clamp(av1_get_qindex(&cm->seg, segment_id, cm->base_qindex) + - cm->y_dc_delta_q, - 0, MAXQ); + const int qindex = clamp( + av1_get_qindex(&cm->seg, segment_id, cm->quant_params.base_qindex) + + cm->quant_params.y_dc_delta_q, + 0, MAXQ); const int q = compute_rd_thresh_factor(qindex, cm->seq_params.bit_depth); for (bsize = 0; bsize < BLOCK_SIZES_ALL; ++bsize) { @@ -589,7 +589,8 @@ aom_clear_system_state(); - rd->RDMULT = av1_compute_rd_mult(cpi, cm->base_qindex + cm->y_dc_delta_q); + rd->RDMULT = av1_compute_rd_mult( + cpi, cm->quant_params.base_qindex + cm->quant_params.y_dc_delta_q); set_error_per_bit(x, rd->RDMULT);
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c index 8199875..827aec4 100644 --- a/av1/encoder/speed_features.c +++ b/av1/encoder/speed_features.c
@@ -1277,7 +1277,7 @@ SPEED_FEATURES *const sf = &cpi->sf; const int is_720p_or_larger = AOMMIN(cm->width, cm->height) >= 720; if (is_720p_or_larger && cpi->oxcf.mode == GOOD && speed == 0) { - if (cm->base_qindex <= 80) { + if (cm->quant_params.base_qindex <= 80) { sf->rd_sf.perform_coeff_opt = 2; memcpy(cpi->coeff_opt_dist_threshold, coeff_opt_dist_thresholds[sf->rd_sf.perform_coeff_opt],
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c index 4a35fa3..b722c7b 100644 --- a/av1/encoder/tpl_model.c +++ b/av1/encoder/tpl_model.c
@@ -737,7 +737,7 @@ tpl_frame->is_valid = 1; - cm->base_qindex = base_qindex; + cm->quant_params.base_qindex = base_qindex; av1_frame_init_quantizer(cpi); tpl_frame->base_rdmult = @@ -1157,10 +1157,12 @@ } MACROBLOCKD *const xd = &x->e_mbd; - const int orig_rdmult = - av1_compute_rd_mult(cpi, cm->base_qindex + cm->y_dc_delta_q); - const int new_rdmult = av1_compute_rd_mult( - cpi, cm->base_qindex + xd->delta_qindex + cm->y_dc_delta_q); + const CommonQuantParams *quant_params = &cm->quant_params; + const int orig_rdmult = av1_compute_rd_mult( + cpi, quant_params->base_qindex + quant_params->y_dc_delta_q); + const int new_rdmult = + av1_compute_rd_mult(cpi, quant_params->base_qindex + xd->delta_qindex + + quant_params->y_dc_delta_q); const double scaling_factor = (double)new_rdmult / (double)orig_rdmult; double scale_adj = log(scaling_factor) - log_sum / base_block_count;
diff --git a/av1/encoder/tx_search.c b/av1/encoder/tx_search.c index f65509d9..48cc47b 100644 --- a/av1/encoder/tx_search.c +++ b/av1/encoder/tx_search.c
@@ -1102,7 +1102,7 @@ : AV1_XFORM_QUANT_FP) : AV1_XFORM_QUANT_FP, cpi->use_quant_b_adapt, &quant_param_intra); - av1_setup_qmatrix(cm, x, plane, tx_size, best_tx_type, + av1_setup_qmatrix(&cm->quant_params, x, plane, tx_size, best_tx_type, &quant_param_intra); av1_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize, &txfm_param_intra, &quant_param_intra); @@ -2207,8 +2207,9 @@ const TX_TYPE tx_type = (TX_TYPE)txk_map[idx]; if (!(allowed_tx_mask & (1 << tx_type))) continue; txfm_param.tx_type = tx_type; - if (av1_use_qmatrix(cm, xd, mbmi->segment_id)) { - av1_setup_qmatrix(cm, x, plane, tx_size, tx_type, &quant_param); + if (av1_use_qmatrix(&cm->quant_params, xd, mbmi->segment_id)) { + av1_setup_qmatrix(&cm->quant_params, x, plane, tx_size, tx_type, + &quant_param); } if (plane == 0) xd->tx_type_map[tx_type_map_idx] = tx_type; RD_STATS this_rd_stats;
diff --git a/av1/encoder/var_based_part.c b/av1/encoder/var_based_part.c index b0fb2f0..9e7b264 100644 --- a/av1/encoder/var_based_part.c +++ b/av1/encoder/var_based_part.c
@@ -684,10 +684,11 @@ if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled && cyclic_refresh_segment_id_boosted(segment_id) && cpi->sf.rt_sf.use_nonrd_pick_mode) { - int q = av1_get_qindex(&cm->seg, segment_id, cm->base_qindex); + int q = av1_get_qindex(&cm->seg, segment_id, cm->quant_params.base_qindex); set_vbp_thresholds(cpi, thresholds, q, content_state); } else { - set_vbp_thresholds(cpi, thresholds, cm->base_qindex, content_state); + set_vbp_thresholds(cpi, thresholds, cm->quant_params.base_qindex, + content_state); } if (is_small_sb) {