| /* |
| * Copyright (c) 2021, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 3-Clause Clear License |
| * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear |
| * License was not distributed with this source code in the LICENSE file, you |
| * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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 |
| * aomedia.org/license/patent-license/. |
| */ |
| |
| #include "config/aom_config.h" |
| #include "config/av1_rtcd.h" |
| #include "config/aom_dsp_rtcd.h" |
| |
| #include "aom_dsp/bitwriter.h" |
| #include "aom_dsp/quantize.h" |
| #include "aom_mem/aom_mem.h" |
| #include "aom_ports/mem.h" |
| |
| #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG |
| #include "aom_util/debug_util.h" |
| #endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG |
| |
| #include "av1/common/cfl.h" |
| #include "av1/common/idct.h" |
| #include "av1/common/reconinter.h" |
| #include "av1/common/reconintra.h" |
| #include "av1/common/scan.h" |
| |
| #include "av1/encoder/av1_quantize.h" |
| #include "av1/encoder/encodemb.h" |
| #include "av1/encoder/encodetxb.h" |
| #include "av1/encoder/hybrid_fwd_txfm.h" |
| #include "av1/encoder/rd.h" |
| #include "av1/encoder/rdopt.h" |
| |
| void av1_subtract_block(const MACROBLOCKD *xd, int rows, int cols, |
| int16_t *diff, ptrdiff_t diff_stride, |
| const uint16_t *src, ptrdiff_t src_stride, |
| const uint16_t *pred, ptrdiff_t pred_stride) { |
| assert(rows >= 4 && cols >= 4); |
| aom_highbd_subtract_block(rows, cols, diff, diff_stride, src, src_stride, |
| pred, pred_stride, xd->bd); |
| } |
| |
| #if CONFIG_LOSSLESS_DPCM |
| // subtraction for residue calculation of DPCM mode |
| void av1_subtract_block_dpcm(const MACROBLOCKD *xd, int rows, int cols, |
| int16_t *diff, ptrdiff_t diff_stride, |
| const uint16_t *src, ptrdiff_t src_stride, |
| const uint16_t *pred, ptrdiff_t pred_stride, |
| int plane) { |
| assert(rows >= 4 && cols >= 4); |
| const MB_MODE_INFO *const mbmi = xd->mi[0]; |
| if (xd->lossless[mbmi->segment_id]) { |
| PREDICTION_MODE cur_pred_mode = |
| (plane == AOM_PLANE_Y) ? mbmi->mode : get_uv_mode(mbmi->uv_mode); |
| int cur_dpcm_flag = |
| (plane == AOM_PLANE_Y) ? mbmi->use_dpcm_y : mbmi->use_dpcm_uv; |
| int cur_angle_delta = (plane == AOM_PLANE_Y) ? mbmi->angle_delta[0] : 0; |
| if (cur_pred_mode == V_PRED && cur_angle_delta == 0 && cur_dpcm_flag > 0) { |
| av1_subtract_block_vert(xd, cols, rows, diff, diff_stride, src, |
| src_stride, pred, pred_stride); |
| } else if (cur_pred_mode == H_PRED && cur_angle_delta == 0 && |
| cur_dpcm_flag > 0) { |
| av1_subtract_block_horz(xd, cols, rows, diff, diff_stride, src, |
| src_stride, pred, pred_stride); |
| } else { |
| aom_highbd_subtract_block(rows, cols, diff, diff_stride, src, src_stride, |
| pred, pred_stride, xd->bd); |
| } |
| } else { |
| aom_highbd_subtract_block(rows, cols, diff, diff_stride, src, src_stride, |
| pred, pred_stride, xd->bd); |
| } |
| } |
| |
| // subtraction for DPCM lossless mode vertical direction |
| void av1_subtract_block_vert(const MACROBLOCKD *xd, int rows, int cols, |
| int16_t *diff, ptrdiff_t diff_stride, |
| const uint16_t *src, ptrdiff_t src_stride, |
| const uint16_t *pred, ptrdiff_t pred_stride) { |
| assert(rows >= 4 && cols >= 4); |
| aom_highbd_subtract_block_vert(rows, cols, diff, diff_stride, src, src_stride, |
| pred, pred_stride, xd->bd); |
| } |
| |
| // subtraction for DPCM lossless mode horizontal direction |
| void av1_subtract_block_horz(const MACROBLOCKD *xd, int rows, int cols, |
| int16_t *diff, ptrdiff_t diff_stride, |
| const uint16_t *src, ptrdiff_t src_stride, |
| const uint16_t *pred, ptrdiff_t pred_stride) { |
| assert(rows >= 4 && cols >= 4); |
| aom_highbd_subtract_block_horz(rows, cols, diff, diff_stride, src, src_stride, |
| pred, pred_stride, xd->bd); |
| } |
| #endif // CONFIG_LOSSLESS_DPCM |
| |
| void av1_subtract_txb(MACROBLOCK *x, int plane, BLOCK_SIZE plane_bsize, |
| int blk_col, int blk_row, TX_SIZE tx_size) { |
| MACROBLOCKD *const xd = &x->e_mbd; |
| struct macroblock_plane *const p = &x->plane[plane]; |
| const struct macroblockd_plane *const pd = &x->e_mbd.plane[plane]; |
| const int diff_stride = block_size_wide[plane_bsize]; |
| const int src_stride = p->src.stride; |
| const int dst_stride = pd->dst.stride; |
| const int tx1d_width = tx_size_wide[tx_size]; |
| const int tx1d_height = tx_size_high[tx_size]; |
| uint16_t *dst = |
| &pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2]; |
| uint16_t *src = &p->src.buf[(blk_row * src_stride + blk_col) << MI_SIZE_LOG2]; |
| int16_t *src_diff = |
| &p->src_diff[(blk_row * diff_stride + blk_col) << MI_SIZE_LOG2]; |
| #if CONFIG_LOSSLESS_DPCM |
| if (xd->lossless[xd->mi[0]->segment_id]) { |
| av1_subtract_block_dpcm(xd, tx1d_height, tx1d_width, src_diff, diff_stride, |
| src, src_stride, dst, dst_stride, plane); |
| } else { |
| av1_subtract_block(xd, tx1d_height, tx1d_width, src_diff, diff_stride, src, |
| src_stride, dst, dst_stride); |
| } |
| #else |
| av1_subtract_block(xd, tx1d_height, tx1d_width, src_diff, diff_stride, src, |
| src_stride, dst, dst_stride); |
| #endif |
| } |
| |
| void av1_subtract_plane(MACROBLOCK *x, BLOCK_SIZE plane_bsize, int plane) { |
| struct macroblock_plane *const p = &x->plane[plane]; |
| const struct macroblockd_plane *const pd = &x->e_mbd.plane[plane]; |
| assert(plane_bsize < BLOCK_SIZES_ALL); |
| const int bw = block_size_wide[plane_bsize]; |
| const int bh = block_size_high[plane_bsize]; |
| const MACROBLOCKD *xd = &x->e_mbd; |
| #if CONFIG_LOSSLESS_DPCM |
| if (xd->lossless[xd->mi[0]->segment_id]) { |
| av1_subtract_block_dpcm(xd, bh, bw, p->src_diff, bw, p->src.buf, |
| p->src.stride, pd->dst.buf, pd->dst.stride, plane); |
| } else { |
| av1_subtract_block(xd, bh, bw, p->src_diff, bw, p->src.buf, p->src.stride, |
| pd->dst.buf, pd->dst.stride); |
| } |
| #else |
| av1_subtract_block(xd, bh, bw, p->src_diff, bw, p->src.buf, p->src.stride, |
| pd->dst.buf, pd->dst.stride); |
| #endif |
| } |
| |
| #if CONFIG_IMPROVEIDTX_RDPH |
| /* |
| This function performs coefficient optimization over the quantized |
| coefficient samples when the transform type is 2D IDTX. Returns skip cost if |
| EOB=0, otherwise moves the first position index closer to the end of block by |
| shrinking the number of coefficient samples to be encoded. |
| */ |
| int av1_optimize_fsc(const struct AV1_COMP *cpi, MACROBLOCK *x, int plane, |
| int block, TX_SIZE tx_size, TX_TYPE tx_type, |
| const TXB_CTX *const txb_ctx, int *rate_cost) { |
| MACROBLOCKD *const xd = &x->e_mbd; |
| struct macroblock_plane *const p = &x->plane[plane]; |
| const int eob = p->eobs[block]; |
| const int segment_id = xd->mi[0]->segment_id; |
| if (eob == 0 || !cpi->optimize_seg_arr[segment_id] || |
| xd->lossless[segment_id]) { |
| *rate_cost = |
| av1_cost_skip_txb(&x->coeff_costs, txb_ctx, plane, tx_size, x, block); |
| return eob; |
| } |
| return av1_optimize_fsc_block(cpi, x, plane, block, tx_size, tx_type, txb_ctx, |
| rate_cost, cpi->oxcf.algo_cfg.sharpness); |
| } |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| |
| /* |
| This function performs coefficient optimization over the quantized coefficient |
| samples when the transform type is trigonometric along at least 1 dimension. |
| Returns skip cost if EOB=0, otherwise moves the last position index closer to |
| the end of block by shrinking the number of coefficient samples to be encoded. |
| */ |
| int av1_optimize_b(const struct AV1_COMP *cpi, MACROBLOCK *x, int plane, |
| int block, TX_SIZE tx_size, TX_TYPE tx_type, |
| CctxType cctx_type, const TXB_CTX *const txb_ctx, |
| int *rate_cost) { |
| MACROBLOCKD *const xd = &x->e_mbd; |
| struct macroblock_plane *const p = &x->plane[plane]; |
| const int eob = p->eobs[block]; |
| const int segment_id = xd->mi[0]->segment_id; |
| |
| if (eob == 0 || !cpi->optimize_seg_arr[segment_id] || |
| xd->lossless[segment_id]) { |
| *rate_cost = av1_cost_skip_txb(&x->coeff_costs, txb_ctx, plane, tx_size |
| #if CONFIG_CONTEXT_DERIVATION |
| , |
| x, block |
| #endif // CONFIG_CONTEXT_DERIVATION |
| ); |
| *rate_cost += get_cctx_type_cost(&cpi->common, x, xd, plane, tx_size, block, |
| cctx_type); |
| return eob; |
| } |
| |
| return av1_optimize_txb_new(cpi, x, plane, block, tx_size, tx_type, cctx_type, |
| txb_ctx, rate_cost, cpi->oxcf.algo_cfg.sharpness); |
| } |
| |
| // This function returns the multiplier of dequantization for current position. |
| static INLINE int get_dqv(const int32_t *dequant, int coeff_idx, |
| const qm_val_t *iqmatrix) { |
| int dqv = dequant[!!coeff_idx]; |
| if (iqmatrix != NULL) |
| dqv = |
| ((iqmatrix[coeff_idx] * dqv) + (1 << (AOM_QM_BITS - 1))) >> AOM_QM_BITS; |
| return dqv; |
| } |
| |
| // This function tunes the coefficients when trellis quantization is off. |
| void parity_hiding_trellis_off(const struct AV1_COMP *cpi, MACROBLOCK *mb, |
| const int plane_type, int block, TX_SIZE tx_size, |
| TX_TYPE tx_type) { |
| MACROBLOCKD *xd = &mb->e_mbd; |
| const struct macroblock_plane *const p = &mb->plane[plane_type]; |
| const int32_t *dequant = p->dequant_QTX; |
| const qm_val_t *iqmatrix = av1_get_iqmatrix(&cpi->common.quant_params, xd, |
| plane_type, tx_size, tx_type); |
| const int shift = av1_get_tx_scale(tx_size); |
| tran_low_t *const qcoeff = p->qcoeff + BLOCK_OFFSET(block); |
| tran_low_t *const dqcoeff = p->dqcoeff + BLOCK_OFFSET(block); |
| tran_low_t *const tcoeff = p->coeff + BLOCK_OFFSET(block); |
| const int eob = p->eobs[block]; |
| |
| if (eob <= PHTHRESH) { |
| return; |
| } |
| |
| const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type); |
| const int16_t *const scan = scan_order->scan; |
| |
| int nz = 0, sum_abs1 = 0; |
| for (int si = eob - 1; si > 0; si--) { |
| const int pos = scan[si]; |
| nz += !!(qcoeff[pos]); |
| sum_abs1 += AOMMIN(abs(qcoeff[pos]), MAX_BASE_BR_RANGE); |
| } |
| if (nz >= PHTHRESH && ((qcoeff[0] & 1) != (sum_abs1 & 1))) { |
| int tune_pos = scan[0]; |
| tran_low_t absdqcoeff = abs(dqcoeff[tune_pos]); |
| tran_low_t abstcoeff = abs(tcoeff[tune_pos]); |
| tran_low_t absqcoeff = |
| abs(qcoeff[tune_pos]) + ((abstcoeff < absdqcoeff) ? -1 : 1); |
| absdqcoeff = (tran_low_t)(ROUND_POWER_OF_TWO_64( |
| (tran_high_t)absqcoeff * |
| get_dqv(dequant, tune_pos, iqmatrix), |
| QUANT_TABLE_BITS) >> |
| shift); |
| tran_low_t dist_min = abs(abstcoeff - absdqcoeff); |
| tran_low_t tune_absqcoeff = absqcoeff, tune_absdqcoeff = absdqcoeff; |
| |
| for (int si = eob - 1; si > 0; si--) { |
| const int pos = scan[si]; |
| abstcoeff = abs(tcoeff[pos]); |
| absdqcoeff = abs(dqcoeff[pos]); |
| absqcoeff = abs(qcoeff[pos]); |
| bool tunable = |
| (absqcoeff < MAX_BASE_BR_RANGE) || |
| ((absqcoeff == MAX_BASE_BR_RANGE) && (abstcoeff < absdqcoeff)); |
| absqcoeff += ((abstcoeff < absdqcoeff) ? -1 : 1); |
| absdqcoeff = (tran_low_t)(ROUND_POWER_OF_TWO_64( |
| (tran_high_t)absqcoeff * |
| get_dqv(dequant, pos, iqmatrix), |
| QUANT_TABLE_BITS) >> |
| shift); |
| tran_low_t absdist = abs(abstcoeff - absdqcoeff); |
| if (absdist < dist_min && tunable) { |
| dist_min = absdist; |
| tune_pos = pos; |
| tune_absqcoeff = absqcoeff; |
| tune_absdqcoeff = absdqcoeff; |
| } |
| } |
| |
| tran_low_t sign = tcoeff[tune_pos] < 0 ? -1 : 1; |
| qcoeff[tune_pos] = tune_absqcoeff * sign; |
| dqcoeff[tune_pos] = tune_absdqcoeff * sign; |
| } |
| |
| int si = eob - 1; |
| for (; si >= 0; si--) { |
| if (qcoeff[scan[si]]) { |
| break; |
| } |
| } |
| int new_eob = si + 1; |
| |
| if (new_eob != p->eobs[block]) { |
| p->eobs[block] = new_eob; |
| p->txb_entropy_ctx[block] = |
| av1_get_txb_entropy_context(qcoeff, scan_order, new_eob); |
| } |
| } |
| |
| // Hyper-parameters for dropout optimization, based on following logics. |
| // TODO(yjshen): These settings are tuned by experiments. They may still be |
| // optimized for better performance. |
| // (1) Coefficients which are large enough will ALWAYS be kept. |
| const tran_low_t DROPOUT_COEFF_MAX = 2; // Max dropout-able coefficient. |
| // (2) Continuous coefficients will ALWAYS be kept. Here rigorous continuity is |
| // NOT required. For example, `5 0 0 0 7` is treated as two continuous |
| // coefficients if three zeros do not fulfill the dropout condition. |
| const int DROPOUT_CONTINUITY_MAX = 2; // Max dropout-able continuous coeff. |
| // (3) Dropout operation is NOT applicable to blocks with large or small |
| // quantization index. |
| const int DROPOUT_Q_MAX = 128; |
| const int DROPOUT_Q_MIN = 16; |
| // (4) Recall that dropout optimization will forcibly set some quantized |
| // coefficients to zero. The key logic on determining whether a coefficient |
| // should be dropped is to check the number of continuous zeros before AND |
| // after this coefficient. The exact number of zeros for judgement depends |
| // on block size and quantization index. More concretely, block size |
| // determines the base number of zeros, while quantization index determines |
| // the multiplier. Intuitively, larger block requires more zeros and larger |
| // quantization index also requires more zeros (more information is lost |
| // when using larger quantization index). |
| const int DROPOUT_BEFORE_BASE_MAX = 32; // Max base number for leading zeros. |
| const int DROPOUT_BEFORE_BASE_MIN = 16; // Min base number for leading zeros. |
| const int DROPOUT_AFTER_BASE_MAX = 32; // Max base number for trailing zeros. |
| const int DROPOUT_AFTER_BASE_MIN = 16; // Min base number for trailing zeros. |
| const int DROPOUT_MULTIPLIER_MAX = 8; // Max multiplier on number of zeros. |
| const int DROPOUT_MULTIPLIER_MIN = 2; // Min multiplier on number of zeros. |
| const int DROPOUT_MULTIPLIER_Q_BASE = 32; // Base Q to compute multiplier. |
| |
| void av1_dropout_qcoeff(MACROBLOCK *mb, int plane, int block, TX_SIZE tx_size, |
| TX_TYPE tx_type, int qindex) { |
| const struct macroblock_plane *const p = &mb->plane[plane]; |
| tran_low_t *const qcoeff = p->qcoeff + BLOCK_OFFSET(block); |
| tran_low_t *const dqcoeff = p->dqcoeff + BLOCK_OFFSET(block); |
| const int tx_width = tx_size_wide[tx_size]; |
| const int tx_height = tx_size_high[tx_size]; |
| const int max_eob = av1_get_max_eob(tx_size); |
| const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type); |
| |
| // Early return if `qindex` is out of range. |
| if (qindex > DROPOUT_Q_MAX || qindex < DROPOUT_Q_MIN) { |
| return; |
| } |
| |
| // Compute number of zeros used for dropout judgement. |
| const int base_size = AOMMAX(tx_width, tx_height); |
| const int multiplier = CLIP(qindex / DROPOUT_MULTIPLIER_Q_BASE, |
| DROPOUT_MULTIPLIER_MIN, DROPOUT_MULTIPLIER_MAX); |
| const int dropout_num_before = |
| multiplier * |
| CLIP(base_size, DROPOUT_BEFORE_BASE_MIN, DROPOUT_BEFORE_BASE_MAX); |
| const int dropout_num_after = |
| multiplier * |
| CLIP(base_size, DROPOUT_AFTER_BASE_MIN, DROPOUT_AFTER_BASE_MAX); |
| |
| // Early return if there are not enough non-zero coefficients. |
| if (p->eobs[block] == 0 || p->eobs[block] <= dropout_num_before) { |
| return; |
| } |
| |
| int count_zeros_before = 0; |
| int count_zeros_after = 0; |
| int count_nonzeros = 0; |
| // Index of the first non-zero coefficient after sufficient number of |
| // continuous zeros. If equals to `-1`, it means number of leading zeros |
| // hasn't reach `dropout_num_before`. |
| int idx = -1; |
| int eob = 0; // New end of block. |
| |
| for (int i = 0; i < p->eobs[block]; ++i) { |
| const int scan_idx = scan_order->scan[i]; |
| if (qcoeff[scan_idx] > DROPOUT_COEFF_MAX) { // Keep large coefficients. |
| count_zeros_before = 0; |
| count_zeros_after = 0; |
| idx = -1; |
| eob = i + 1; |
| } else if (qcoeff[scan_idx] == 0) { // Count zeros. |
| if (idx == -1) { |
| ++count_zeros_before; |
| } else { |
| ++count_zeros_after; |
| } |
| } else { // Count non-zeros. |
| if (count_zeros_before >= dropout_num_before) { |
| idx = (idx == -1) ? i : idx; |
| ++count_nonzeros; |
| } else { |
| count_zeros_before = 0; |
| eob = i + 1; |
| } |
| } |
| |
| // Handle continuity. |
| if (count_nonzeros > DROPOUT_CONTINUITY_MAX) { |
| count_zeros_before = 0; |
| count_zeros_after = 0; |
| idx = -1; |
| eob = i + 1; |
| } |
| |
| // Handle the trailing zeros after original end of block. |
| if (idx != -1 && i == p->eobs[block] - 1) { |
| count_zeros_after += (max_eob - p->eobs[block]); |
| } |
| |
| // Set redundant coefficients to zeros if needed. |
| if (count_zeros_after >= dropout_num_after) { |
| for (int j = idx; j <= i; ++j) { |
| qcoeff[scan_order->scan[j]] = 0; |
| dqcoeff[scan_order->scan[j]] = 0; |
| } |
| count_zeros_before += (i - idx + 1); |
| count_zeros_after = 0; |
| count_nonzeros = 0; |
| } else if (i == p->eobs[block] - 1) { |
| eob = i + 1; |
| } |
| } |
| |
| if (eob != p->eobs[block]) { |
| p->eobs[block] = eob; |
| p->txb_entropy_ctx[block] = |
| av1_get_txb_entropy_context(qcoeff, scan_order, eob); |
| } |
| } |
| |
| // Settings for optimization type. NOTE: To set optimization type for all intra |
| // frames, both `KEY_BLOCK_OPT_TYPE` and `INTRA_BLOCK_OPT_TYPE` should be set. |
| // TODO(yjshen): These settings are hard-coded and look okay for now. They |
| // should be made configurable later. |
| // Blocks of key frames ONLY. |
| const OPT_TYPE KEY_BLOCK_OPT_TYPE = TRELLIS_DROPOUT_OPT; |
| // Blocks of intra frames (key frames EXCLUSIVE). |
| const OPT_TYPE INTRA_BLOCK_OPT_TYPE = TRELLIS_DROPOUT_OPT; |
| // Blocks of inter frames. (NOTE: Dropout optimization is DISABLED by default |
| // if trellis optimization is on for inter frames.) |
| const OPT_TYPE INTER_BLOCK_OPT_TYPE = TRELLIS_DROPOUT_OPT; |
| |
| enum { |
| QUANT_FUNC_LOWBD = 0, |
| QUANT_FUNC_HIGHBD = 1, |
| QUANT_FUNC_TYPES = 2 |
| } UENUM1BYTE(QUANT_FUNC); |
| |
| static AV1_QUANT_FACADE quant_func_list[AV1_XFORM_QUANT_TYPES] = { |
| av1_highbd_quantize_fp_facade, av1_highbd_quantize_b_facade, |
| av1_highbd_quantize_dc_facade, NULL |
| }; |
| |
| // Computes the transform for DC only blocks |
| void av1_xform_dc_only(MACROBLOCK *x, int plane, int block, |
| TxfmParam *txfm_param, int64_t per_px_mean) { |
| assert(per_px_mean != INT64_MAX); |
| const struct macroblock_plane *const p = &x->plane[plane]; |
| const int block_offset = BLOCK_OFFSET(block); |
| tran_low_t *const coeff = p->coeff + block_offset; |
| const int n_coeffs = av1_get_max_eob(txfm_param->tx_size); |
| memset(coeff, 0, sizeof(*coeff) * n_coeffs); |
| coeff[0] = |
| (tran_low_t)((per_px_mean * dc_coeff_scale[txfm_param->tx_size]) >> 12); |
| } |
| |
| void av1_xform_quant(const AV1_COMMON *cm, MACROBLOCK *x, int plane, int block, |
| int blk_row, int blk_col, BLOCK_SIZE plane_bsize, |
| TxfmParam *txfm_param, QUANT_PARAM *qparam) { |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *const mbmi = xd->mi[0]; |
| const struct macroblock_plane *const p = &x->plane[plane]; |
| const int is_inter = is_inter_block(mbmi, xd->tree_type); |
| if (is_cctx_allowed(cm, xd)) { |
| // In the pipeline of cross-chroma transform, the forward transform for |
| // plane V is done earlier in plane U, followed by forward cross chroma |
| // transform, in order to obtain the quantized coefficients of the second |
| // channel. |
| if (plane != AOM_PLANE_V) { |
| av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, txfm_param, 0); |
| } |
| if (plane == AOM_PLANE_U) { |
| av1_xform(x, AOM_PLANE_V, block, blk_row, blk_col, plane_bsize, |
| txfm_param, 0); |
| forward_cross_chroma_transform(x, block, txfm_param->tx_size, |
| txfm_param->cctx_type); |
| } |
| } else { |
| av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, txfm_param, 0); |
| } |
| const uint8_t fsc_mode = |
| (mbmi->fsc_mode[xd->tree_type == CHROMA_PART] && plane == PLANE_TYPE_Y) || |
| use_inter_fsc(cm, plane, txfm_param->tx_type, is_inter); |
| #if !CONFIG_IMPROVEIDTX_RDPH |
| if (fsc_mode) qparam->use_optimize_b = false; |
| #endif // !CONFIG_IMPROVEIDTX_RDPH |
| av1_quant(x, plane, block, txfm_param, qparam); |
| if (fsc_mode) { |
| if (get_primary_tx_type(txfm_param->tx_type) == IDTX) { |
| uint16_t *const eob = &p->eobs[block]; |
| if (*eob != 0) *eob = av1_get_max_eob(txfm_param->tx_size); |
| } |
| } |
| } |
| |
| void av1_xform(MACROBLOCK *x, int plane, int block, int blk_row, int blk_col, |
| BLOCK_SIZE plane_bsize, TxfmParam *txfm_param, const int reuse) { |
| struct macroblock_plane *const p = &x->plane[plane]; |
| const int block_offset = BLOCK_OFFSET(block); |
| tran_low_t *const coeff = p->coeff + block_offset; |
| const int diff_stride = block_size_wide[plane_bsize]; |
| |
| const int src_offset = (blk_row * diff_stride + blk_col); |
| const int16_t *src_diff = &p->src_diff[src_offset << MI_SIZE_LOG2]; |
| |
| if (reuse == 0) { |
| av1_fwd_txfm(src_diff, coeff, diff_stride, txfm_param); |
| } else { |
| const int tr_width = tx_size_wide[txfm_param->tx_size] <= 32 |
| ? tx_size_wide[txfm_param->tx_size] |
| : 32; |
| const int tr_height = tx_size_high[txfm_param->tx_size] <= 32 |
| ? tx_size_high[txfm_param->tx_size] |
| : 32; |
| #if CONFIG_IST_ANY_SET |
| // perform fwd tx only once (and save the result in temp buff) during the |
| // search loop for IST Set (IST_DIR_SIZE sets) and its kenerls (3 tx kernels |
| // per set) Set 0 ~ IST_DIR_SIZE-1 for DCT_DCT, and Set IST_DIR_SIZE ~ |
| // IST_SET_SIZE-1 for ADST_ADST |
| if (txfm_param->sec_tx_type == 0 && |
| (txfm_param->sec_tx_set == 0 || txfm_param->sec_tx_set == IST_DIR_SIZE)) |
| #else |
| if (txfm_param->sec_tx_type == 0) |
| #endif // CONFIG_IST_ANY_SET |
| { |
| av1_fwd_txfm(src_diff, coeff, diff_stride, txfm_param); |
| if (plane == 0) { |
| memcpy(p->temp_coeff, coeff, tr_width * tr_height * sizeof(tran_low_t)); |
| } |
| } else { |
| if (plane == 0) |
| memcpy(coeff, p->temp_coeff, tr_width * tr_height * sizeof(tran_low_t)); |
| } |
| } |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *const mbmi = xd->mi[0]; |
| const PREDICTION_MODE intra_mode = get_intra_mode(mbmi, plane); |
| const int filter = mbmi->filter_intra_mode_info.use_filter_intra; |
| const int is_depth0 = tx_size_is_depth0(txfm_param->tx_size, plane_bsize); |
| assert(((intra_mode >= PAETH_PRED || filter || !is_depth0) && |
| txfm_param->sec_tx_type) == 0); |
| (void)intra_mode; |
| (void)filter; |
| (void)is_depth0; |
| av1_fwd_stxfm(coeff, txfm_param); |
| } |
| |
| // Facade function for forward cross chroma component transform |
| void forward_cross_chroma_transform(MACROBLOCK *x, int block, TX_SIZE tx_size, |
| CctxType cctx_type) { |
| struct macroblock_plane *const p_c1 = &x->plane[AOM_PLANE_U]; |
| struct macroblock_plane *const p_c2 = &x->plane[AOM_PLANE_V]; |
| const int block_offset = BLOCK_OFFSET(block); |
| tran_low_t *coeff_c1 = p_c1->coeff + block_offset; |
| tran_low_t *coeff_c2 = p_c2->coeff + block_offset; |
| av1_fwd_cross_chroma_tx_block(coeff_c1, coeff_c2, tx_size, cctx_type); |
| } |
| |
| // Finds and sets the first position (BOB) index. |
| // To make sure the BOB value is statistically similar to EOB |
| // for arithmetic coding efficiency performs a simple rotation. |
| void set_bob(MACROBLOCK *x, int plane, int block, TX_SIZE tx_size, |
| TX_TYPE tx_type) { |
| const struct macroblock_plane *const p = &x->plane[plane]; |
| const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type); |
| const int block_offset = BLOCK_OFFSET(block); |
| tran_low_t *const qcoeff = p->qcoeff + block_offset; |
| uint16_t *const eob = &p->eobs[block]; |
| uint16_t *const bob_ptr = &p->bobs[block]; |
| int bob = 0; |
| for (int c = 0; c < *eob; ++c) { |
| const int pos = scan_order->scan[c]; |
| const tran_low_t v = qcoeff[pos]; |
| const tran_low_t level = abs(v); |
| if (level != 0) { |
| break; |
| } |
| bob++; |
| } |
| *bob_ptr = av1_get_max_eob(tx_size) - bob; |
| } |
| |
| void av1_quant(MACROBLOCK *x, int plane, int block, TxfmParam *txfm_param, |
| QUANT_PARAM *qparam) { |
| const struct macroblock_plane *const p = &x->plane[plane]; |
| const SCAN_ORDER *const scan_order = |
| get_scan(txfm_param->tx_size, txfm_param->tx_type); |
| const int block_offset = BLOCK_OFFSET(block); |
| tran_low_t *const coeff = p->coeff + block_offset; |
| tran_low_t *const qcoeff = p->qcoeff + block_offset; |
| tran_low_t *const dqcoeff = p->dqcoeff + block_offset; |
| uint16_t *const eob = &p->eobs[block]; |
| |
| if (qparam->xform_quant_idx != AV1_XFORM_QUANT_SKIP_QUANT) { |
| const int n_coeffs = av1_get_max_eob(txfm_param->tx_size); |
| if (LIKELY(!x->seg_skip_block)) { |
| quant_func_list[qparam->xform_quant_idx]( |
| coeff, n_coeffs, p, qcoeff, dqcoeff, eob, scan_order, qparam); |
| } else { |
| av1_quantize_skip(n_coeffs, qcoeff, dqcoeff, eob); |
| } |
| } |
| |
| set_bob(x, plane, block, txfm_param->tx_size, txfm_param->tx_type); |
| |
| #if CONFIG_CONTEXT_DERIVATION |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const int16_t *const scan = scan_order->scan; |
| if (plane == AOM_PLANE_V) { |
| tran_low_t *const qcoeff_u = x->plane[AOM_PLANE_U].qcoeff + block_offset; |
| xd->eob_u_flag = x->plane[AOM_PLANE_U].eobs[block] ? 1 : 0; |
| const int width = get_txb_wide(txfm_param->tx_size); |
| const int height = get_txb_high(txfm_param->tx_size); |
| memset(xd->tmp_sign, 0, width * height * sizeof(int32_t)); |
| for (int c = 0; c < x->plane[AOM_PLANE_U].eobs[block]; ++c) { |
| const int pos = scan[c]; |
| int sign = (qcoeff_u[pos] < 0) ? 1 : 0; |
| if (abs(qcoeff_u[pos])) xd->tmp_sign[pos] = (sign ? 2 : 1); |
| } |
| } |
| #endif // CONFIG_CONTEXT_DERIVATION |
| |
| // use_optimize_b is true means av1_optimze_b will be called, |
| // thus cannot update entropy ctx now (performed in optimize_b) |
| if (qparam->use_optimize_b) { |
| p->txb_entropy_ctx[block] = 0; |
| } else { |
| p->txb_entropy_ctx[block] = |
| av1_get_txb_entropy_context(qcoeff, scan_order, *eob); |
| } |
| } |
| |
| void av1_setup_xform(const AV1_COMMON *cm, MACROBLOCK *x, int plane, |
| TX_SIZE tx_size, TX_TYPE tx_type, CctxType cctx_type, |
| TxfmParam *txfm_param) { |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *const mbmi = xd->mi[0]; |
| |
| txfm_param->tx_type = get_primary_tx_type(tx_type); |
| #if CONFIG_IST_SET_FLAG |
| txfm_param->sec_tx_set = 0; |
| #endif // CONFIG_IST_SET_FLAG |
| txfm_param->sec_tx_type = 0; |
| txfm_param->intra_mode = get_intra_mode(mbmi, plane); |
| if ((txfm_param->intra_mode < PAETH_PRED) && |
| !xd->lossless[mbmi->segment_id] && |
| !(mbmi->filter_intra_mode_info.use_filter_intra) && |
| !(mbmi->fsc_mode[xd->tree_type == CHROMA_PART]) && |
| cm->seq_params.enable_ist) { |
| #if CONFIG_IST_SET_FLAG |
| txfm_param->sec_tx_set = get_secondary_tx_set(tx_type); |
| #endif // CONFIG_IST_SET_FLAG |
| txfm_param->sec_tx_type = get_secondary_tx_type(tx_type); |
| } |
| txfm_param->cctx_type = cctx_type; |
| txfm_param->tx_size = tx_size; |
| txfm_param->lossless = xd->lossless[mbmi->segment_id]; |
| txfm_param->tx_set_type = |
| av1_get_ext_tx_set_type(tx_size, is_inter_block(mbmi, xd->tree_type), |
| cm->features.reduced_tx_set_used); |
| |
| txfm_param->bd = xd->bd; |
| } |
| void av1_setup_quant(TX_SIZE tx_size, int use_optimize_b, int xform_quant_idx, |
| int use_quant_b_adapt, QUANT_PARAM *qparam) { |
| qparam->log_scale = av1_get_tx_scale(tx_size); |
| qparam->tx_size = tx_size; |
| |
| qparam->use_quant_b_adapt = use_quant_b_adapt; |
| |
| // TODO(bohanli): optimize_b and quantization idx has relationship, |
| // but is kind of buried and complicated in different encoding stages. |
| // Should have a unified function to derive quant_idx, rather than |
| // determine and pass in the quant_idx |
| qparam->use_optimize_b = use_optimize_b; |
| qparam->xform_quant_idx = xform_quant_idx; |
| |
| qparam->qmatrix = NULL; |
| qparam->iqmatrix = NULL; |
| } |
| |
| void av1_update_trellisq(int use_optimize_b, int xform_quant_idx, |
| int use_quant_b_adapt, QUANT_PARAM *qparam) { |
| qparam->use_quant_b_adapt = use_quant_b_adapt; |
| qparam->use_optimize_b = use_optimize_b; |
| qparam->xform_quant_idx = xform_quant_idx; |
| } |
| |
| void av1_setup_qmatrix(const CommonQuantParams *quant_params, |
| const MACROBLOCKD *xd, int plane, TX_SIZE tx_size, |
| TX_TYPE tx_type, QUANT_PARAM *qparam) { |
| qparam->qmatrix = av1_get_qmatrix(quant_params, xd, plane, tx_size, tx_type); |
| qparam->iqmatrix = |
| av1_get_iqmatrix(quant_params, xd, plane, tx_size, tx_type); |
| } |
| |
| static void encode_block(int plane, int block, int blk_row, int blk_col, |
| BLOCK_SIZE plane_bsize, TX_SIZE tx_size, void *arg, |
| RUN_TYPE dry_run) { |
| (void)dry_run; |
| struct encode_b_args *const args = arg; |
| const AV1_COMP *const cpi = args->cpi; |
| const AV1_COMMON *const cm = &cpi->common; |
| MACROBLOCK *const x = args->x; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| struct macroblock_plane *const p = &x->plane[plane]; |
| struct macroblockd_plane *const pd = &xd->plane[plane]; |
| tran_low_t *dqcoeff = p->dqcoeff + BLOCK_OFFSET(block); |
| uint16_t *dst; |
| ENTROPY_CONTEXT *a, *l; |
| int dummy_rate_cost = 0; |
| |
| const int bw = mi_size_wide[plane_bsize]; |
| dst = &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2]; |
| |
| a = &args->ta[blk_col]; |
| l = &args->tl[blk_row]; |
| |
| TX_TYPE tx_type = av1_get_tx_type(xd, pd->plane_type, blk_row, blk_col, |
| tx_size, cm->features.reduced_tx_set_used); |
| CctxType cctx_type = |
| plane ? av1_get_cctx_type(xd, blk_row, blk_col) : CCTX_NONE; |
| |
| if (!is_blk_skip(x->txfm_search_info.blk_skip, plane, |
| blk_row * bw + blk_col) && |
| (plane < AOM_PLANE_V || !is_cctx_allowed(cm, xd) || |
| #if CCTX_C2_DROPPED |
| ((cctx_type == CCTX_NONE || x->plane[AOM_PLANE_U].eobs[block]) && |
| keep_chroma_c2(cctx_type))) && |
| #else |
| cctx_type == CCTX_NONE || x->plane[AOM_PLANE_U].eobs[block]) && |
| #endif // CCTX_C2_DROPPED |
| #if CONFIG_SKIP_MODE_ENHANCEMENT |
| !(mbmi->skip_mode == 1)) { |
| #else |
| !mbmi->skip_mode) { |
| #endif // CONFIG_SKIP_MODE_ENHANCEMENT |
| |
| TxfmParam txfm_param; |
| QUANT_PARAM quant_param; |
| const int is_inter = is_inter_block(mbmi, xd->tree_type); |
| const int fsc_mode = (mbmi->fsc_mode[xd->tree_type == CHROMA_PART] && |
| plane == PLANE_TYPE_Y) || |
| use_inter_fsc(cm, plane, tx_type, is_inter); |
| const int use_trellis = is_trellis_used(args->enable_optimize_b, dry_run) |
| #if !CONFIG_IMPROVEIDTX_RDPH |
| && !fsc_mode |
| #endif // !CONFIG_IMPROVEIDTX_RDPH |
| ; |
| int quant_idx; |
| if (use_trellis) |
| quant_idx = AV1_XFORM_QUANT_FP; |
| else |
| quant_idx = |
| USE_B_QUANT_NO_TRELLIS ? AV1_XFORM_QUANT_B : AV1_XFORM_QUANT_FP; |
| av1_setup_xform(cm, x, plane, tx_size, tx_type, cctx_type, &txfm_param); |
| av1_setup_quant(tx_size, use_trellis, quant_idx, |
| cpi->oxcf.q_cfg.quant_b_adapt, &quant_param); |
| av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type, |
| &quant_param); |
| av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, |
| &txfm_param, &quant_param); |
| |
| bool enable_parity_hiding = |
| cm->features.allow_parity_hiding && !xd->lossless[mbmi->segment_id] && |
| plane == PLANE_TYPE_Y && |
| #if CONFIG_IMPROVEIDTX_RDPH |
| ph_allowed_tx_types[get_primary_tx_type(tx_type)] && |
| (p->eobs[block] > PHTHRESH); |
| #else |
| get_primary_tx_type(tx_type) < IDTX; |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| |
| // Whether trellis or dropout optimization is required for inter frames. |
| const bool do_trellis = INTER_BLOCK_OPT_TYPE == TRELLIS_OPT || |
| INTER_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT; |
| const bool do_dropout = INTER_BLOCK_OPT_TYPE == DROPOUT_OPT || |
| INTER_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT; |
| if (quant_param.use_optimize_b && do_trellis) { |
| TXB_CTX txb_ctx; |
| get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx, |
| mbmi->fsc_mode[xd->tree_type == CHROMA_PART]); |
| #if CONFIG_IMPROVEIDTX_RDPH |
| if (fsc_mode) |
| av1_optimize_fsc(args->cpi, x, plane, block, tx_size, tx_type, &txb_ctx, |
| &dummy_rate_cost); |
| else |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type, cctx_type, |
| &txb_ctx, &dummy_rate_cost); |
| } |
| if (!quant_param.use_optimize_b && do_dropout && !fsc_mode && |
| !enable_parity_hiding) { |
| av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, |
| cm->quant_params.base_qindex); |
| } |
| |
| if (!quant_param.use_optimize_b && enable_parity_hiding) { |
| parity_hiding_trellis_off(cpi, x, plane, block, tx_size, tx_type); |
| } |
| const int skip_cctx = is_inter ? 0 : (p->eobs[block] == 1); |
| // Since eob can be updated here, make sure cctx_type is always CCTX_NONE |
| // when eob of U is 0. |
| if (is_cctx_allowed(cm, xd) && plane == AOM_PLANE_U && |
| (p->eobs[block] == 0 || skip_cctx)) { |
| // In dry run, cctx type will not be referenced by neighboring blocks, so |
| // there is no need to fill in the whole chroma region. In addition, |
| // ctx->cctx_type_map size in dry run may not be aligned with actual |
| // chroma coding region for some partition types. |
| update_cctx_array(xd, blk_row, blk_col, 0, 0, dry_run ? TX_4X4 : tx_size, |
| CCTX_NONE); |
| } |
| } else { |
| #if CCTX_C2_DROPPED |
| // Reset coeffs and dqcoeffs |
| if (plane == AOM_PLANE_V && !keep_chroma_c2(cctx_type) && |
| is_cctx_allowed(cm, xd)) |
| av1_quantize_skip(av1_get_max_eob(tx_size), |
| p->coeff + BLOCK_OFFSET(block), dqcoeff, |
| &p->eobs[block]); |
| #endif // CCTX_C2_DROPPED |
| p->eobs[block] = 0; |
| p->bobs[block] = 0; |
| p->txb_entropy_ctx[block] = 0; |
| } |
| |
| av1_set_txb_context(x, plane, block, tx_size, a, l); |
| |
| // In CCTX, reconstruction for U plane relies on dqcoeffs of V plane, so the |
| // below operations for U are performed together with V once dqcoeffs of V are |
| // obtained. |
| if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) { |
| if (p->eobs[block]) *(args->skip) = 0; |
| return; |
| } |
| int recon_with_cctx = 0; |
| int max_chroma_eob = 0; |
| if (plane == AOM_PLANE_V && is_cctx_allowed(cm, xd)) { |
| struct macroblock_plane *const p_c1 = &x->plane[AOM_PLANE_U]; |
| struct macroblockd_plane *const pd_c1 = &xd->plane[AOM_PLANE_U]; |
| tran_low_t *dqcoeff_c1 = p_c1->dqcoeff + BLOCK_OFFSET(block); |
| uint16_t *dst_c1 = |
| &pd_c1->dst |
| .buf[(blk_row * pd_c1->dst.stride + blk_col) << MI_SIZE_LOG2]; |
| int eob_c1 = p_c1->eobs[block]; |
| int eob_c2 = x->plane[AOM_PLANE_V].eobs[block]; |
| const int is_inter = is_inter_block(mbmi, xd->tree_type); |
| const int skip_cctx = is_inter ? 0 : (p->eobs[block] == 1); |
| recon_with_cctx = (eob_c1 || eob_c2) && !skip_cctx; |
| max_chroma_eob = AOMMAX(eob_c1, eob_c2); |
| if (recon_with_cctx) { |
| av1_inv_cross_chroma_tx_block(dqcoeff_c1, dqcoeff, tx_size, cctx_type); |
| av1_inverse_transform_block(xd, dqcoeff_c1, AOM_PLANE_U, tx_type, tx_size, |
| dst_c1, pd_c1->dst.stride, max_chroma_eob, |
| cm->features.reduced_tx_set_used); |
| } |
| } |
| |
| if (p->eobs[block] || recon_with_cctx) { |
| *(args->skip) = 0; |
| av1_inverse_transform_block( |
| xd, dqcoeff, plane, tx_type, tx_size, dst, pd->dst.stride, |
| (plane == 0 || !is_cctx_allowed(cm, xd) || !recon_with_cctx) |
| ? p->eobs[block] |
| : max_chroma_eob, |
| cm->features.reduced_tx_set_used); |
| } |
| |
| // TODO(debargha, jingning): Temporarily disable txk_type check for eob=0 |
| // case. It is possible that certain collision in hash index would cause |
| // the assertion failure. To further optimize the rate-distortion |
| // performance, we need to re-visit this part and enable this assert |
| // again. |
| if (p->eobs[block] == 0 && plane == 0) { |
| #if 0 |
| if (args->cpi->oxcf.q_cfg.aq_mode == NO_AQ && |
| args->cpi->oxcf.q_cfg.deltaq_mode == NO_DELTA_Q) { |
| // TODO(jingning,angiebird,huisu@google.com): enable txk_check when |
| // enable_optimize_b is true to detect potential RD bug. |
| const uint8_t disable_txk_check = args->enable_optimize_b; |
| if (!disable_txk_check) { |
| assert(xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col)] == |
| DCT_DCT); |
| } |
| } |
| #endif |
| update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT); |
| } |
| #if CONFIG_LR_IMPROVEMENTS |
| if (dry_run == OUTPUT_ENABLED && plane == AOM_PLANE_V && |
| is_cctx_allowed(cm, xd) && x->plane[AOM_PLANE_U].eobs[block] == 0) { |
| av1_update_txk_skip_array(cm, xd->mi_row, xd->mi_col, xd->tree_type, |
| &mbmi->chroma_ref_info, AOM_PLANE_U, blk_row, |
| blk_col, tx_size); |
| } |
| if (p->eobs[block] == 0 && dry_run == OUTPUT_ENABLED) { |
| av1_update_txk_skip_array(cm, xd->mi_row, xd->mi_col, xd->tree_type, |
| &mbmi->chroma_ref_info, plane, blk_row, blk_col, |
| tx_size); |
| } |
| #endif // CONFIG_LR_IMPROVEMENTS |
| #if CONFIG_MISMATCH_DEBUG |
| if (dry_run == OUTPUT_ENABLED) { |
| int pixel_c, pixel_r; |
| BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; |
| int blk_w = block_size_wide[bsize]; |
| int blk_h = block_size_high[bsize]; |
| if (plane) { |
| mi_to_pixel_loc(&pixel_c, &pixel_r, |
| mbmi->chroma_ref_info.mi_col_chroma_base, |
| mbmi->chroma_ref_info.mi_row_chroma_base, blk_col, |
| blk_row, pd->subsampling_x, pd->subsampling_y); |
| } else { |
| mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, blk_col, |
| blk_row, pd->subsampling_x, pd->subsampling_y); |
| } |
| if (plane == AOM_PLANE_V && is_cctx_allowed(cm, xd)) { |
| struct macroblockd_plane *const pd_c1 = &xd->plane[AOM_PLANE_U]; |
| uint16_t *dst_c1 = |
| &pd_c1->dst |
| .buf[(blk_row * pd_c1->dst.stride + blk_col) << MI_SIZE_LOG2]; |
| mismatch_record_block_tx(dst_c1, pd_c1->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| AOM_PLANE_U, pixel_c, pixel_r, blk_w, blk_h); |
| } |
| mismatch_record_block_tx(dst, pd->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| plane, pixel_c, pixel_r, blk_w, blk_h); |
| } |
| #endif // CONFIG_MISMATCH_DEBUG |
| } |
| |
| static void encode_block_inter(int plane, int block, int blk_row, int blk_col, |
| BLOCK_SIZE plane_bsize, TX_SIZE tx_size, |
| void *arg, RUN_TYPE dry_run) { |
| struct encode_b_args *const args = arg; |
| MACROBLOCK *const x = args->x; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *const mbmi = xd->mi[0]; |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| const int max_blocks_high = max_block_high(xd, plane_bsize, plane); |
| const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); |
| |
| if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; |
| #if CONFIG_TX_PARTITION_TYPE_EXT |
| const int index = av1_get_txb_size_index(plane_bsize, blk_row, blk_col); |
| #if CONFIG_EXT_RECUR_PARTITIONS |
| const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane); |
| const TX_SIZE plane_tx_size = |
| plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x, |
| pd->subsampling_y) |
| : mbmi->inter_tx_size[index]; |
| #else |
| const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane); |
| const TX_SIZE plane_tx_size = |
| plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x, |
| pd->subsampling_y) |
| : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row, |
| blk_col)]; |
| #endif // CONFIG_EXT_RECUR_PARTITIONS |
| #else |
| const TX_SIZE plane_tx_size = |
| plane ? av1_get_max_uv_txsize(mbmi->sb_type[xd->tree_type == CHROMA_PART], |
| pd->subsampling_x, pd->subsampling_y) |
| : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row, |
| blk_col)]; |
| #endif // CONFIG_TX_PARTITION_TYPE_EXT |
| if (!plane) { |
| assert(tx_size_wide[tx_size] >= tx_size_wide[plane_tx_size] && |
| tx_size_high[tx_size] >= tx_size_high[plane_tx_size]); |
| } |
| |
| if (tx_size == plane_tx_size || plane) { |
| encode_block(plane, block, blk_row, blk_col, plane_bsize, tx_size, arg, |
| dry_run); |
| } else { |
| #if CONFIG_NEW_TX_PARTITION |
| #if CONFIG_TX_PARTITION_TYPE_EXT |
| get_tx_partition_sizes(mbmi->tx_partition_type[index], tx_size, |
| &mbmi->txb_pos, mbmi->sub_txs); |
| for (int txb_idx = 0; txb_idx < mbmi->txb_pos.n_partitions; ++txb_idx) { |
| const TX_SIZE sub_tx = mbmi->sub_txs[txb_idx]; |
| int bsw = tx_size_wide_unit[sub_tx]; |
| int bsh = tx_size_high_unit[sub_tx]; |
| const int sub_step = bsw * bsh; |
| const int offsetr = blk_row + mbmi->txb_pos.row_offset[txb_idx]; |
| const int offsetc = blk_col + mbmi->txb_pos.col_offset[txb_idx]; |
| if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; |
| encode_block(plane, block, offsetr, offsetc, plane_bsize, sub_tx, arg, |
| dry_run); |
| block += sub_step; |
| } |
| #else |
| TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 }; |
| const int index = av1_get_txb_size_index(plane_bsize, blk_row, blk_col); |
| get_tx_partition_sizes(mbmi->tx_partition_type[index], tx_size, sub_txs); |
| int cur_partition = 0; |
| int bsw = 0, bsh = 0; |
| for (int r = 0; r < tx_size_high_unit[tx_size]; r += bsh) { |
| for (int c = 0; c < tx_size_wide_unit[tx_size]; c += bsw) { |
| const TX_SIZE sub_tx = sub_txs[cur_partition]; |
| bsw = tx_size_wide_unit[sub_tx]; |
| bsh = tx_size_high_unit[sub_tx]; |
| const int sub_step = bsw * bsh; |
| const int offsetr = blk_row + r; |
| const int offsetc = blk_col + c; |
| if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; |
| encode_block(plane, block, offsetr, offsetc, plane_bsize, sub_tx, arg, |
| dry_run); |
| block += sub_step; |
| cur_partition++; |
| } |
| } |
| #endif // CONFIG_TX_PARTITION_TYPE_EXT |
| #else |
| assert(tx_size < TX_SIZES_ALL); |
| const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; |
| assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size)); |
| assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size)); |
| // This is the square transform block partition entry point. |
| const int bsw = tx_size_wide_unit[sub_txs]; |
| const int bsh = tx_size_high_unit[sub_txs]; |
| const int step = bsh * bsw; |
| assert(bsw > 0 && bsh > 0); |
| |
| for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { |
| for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { |
| const int offsetr = blk_row + row; |
| const int offsetc = blk_col + col; |
| |
| if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; |
| |
| encode_block_inter(plane, block, offsetr, offsetc, plane_bsize, sub_txs, |
| arg, dry_run); |
| block += step; |
| } |
| } |
| #endif // CONFIG_NEW_TX_PARTITION |
| } |
| } |
| |
| void av1_foreach_transformed_block_in_plane( |
| const MACROBLOCKD *const xd, BLOCK_SIZE plane_bsize, int plane, |
| foreach_transformed_block_visitor visit, void *arg) { |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| // block and transform sizes, in number of 4x4 blocks log 2 ("*_b") |
| // 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8 |
| // transform size varies per plane, look it up in a common way. |
| const TX_SIZE tx_size = av1_get_tx_size(plane, xd); |
| const uint8_t txw_unit = tx_size_wide_unit[tx_size]; |
| const uint8_t txh_unit = tx_size_high_unit[tx_size]; |
| const int step = txw_unit * txh_unit; |
| |
| // If mb_to_right_edge is < 0 we are in a situation in which |
| // the current block size extends into the UMV and we won't |
| // visit the sub blocks that are wholly within the UMV. |
| const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); |
| const int max_blocks_high = max_block_high(xd, plane_bsize, plane); |
| const BLOCK_SIZE max_unit_bsize = |
| get_plane_block_size(BLOCK_64X64, pd->subsampling_x, pd->subsampling_y); |
| const int mu_blocks_wide = |
| AOMMIN(mi_size_wide[max_unit_bsize], max_blocks_wide); |
| const int mu_blocks_high = |
| AOMMIN(mi_size_high[max_unit_bsize], max_blocks_high); |
| |
| // Keep track of the row and column of the blocks we use so that we know |
| // if we are in the unrestricted motion border. |
| int i = 0; |
| for (int r = 0; r < max_blocks_high; r += mu_blocks_high) { |
| const int unit_height = AOMMIN(mu_blocks_high + r, max_blocks_high); |
| // Skip visiting the sub blocks that are wholly within the UMV. |
| for (int c = 0; c < max_blocks_wide; c += mu_blocks_wide) { |
| const int unit_width = AOMMIN(mu_blocks_wide + c, max_blocks_wide); |
| for (int blk_row = r; blk_row < unit_height; blk_row += txh_unit) { |
| for (int blk_col = c; blk_col < unit_width; blk_col += txw_unit) { |
| visit(plane, i, blk_row, blk_col, plane_bsize, tx_size, arg); |
| i += step; |
| } |
| } |
| } |
| } |
| } |
| |
| typedef struct encode_block_pass1_args { |
| AV1_COMP *cpi; |
| MACROBLOCK *x; |
| } encode_block_pass1_args; |
| |
| static void encode_block_pass1(int plane, int block, int blk_row, int blk_col, |
| BLOCK_SIZE plane_bsize, TX_SIZE tx_size, |
| void *arg) { |
| encode_block_pass1_args *args = (encode_block_pass1_args *)arg; |
| AV1_COMP *cpi = args->cpi; |
| AV1_COMMON *cm = &cpi->common; |
| MACROBLOCK *const x = args->x; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| struct macroblock_plane *const p = &x->plane[plane]; |
| struct macroblockd_plane *const pd = &xd->plane[plane]; |
| tran_low_t *const dqcoeff = p->dqcoeff + BLOCK_OFFSET(block); |
| |
| uint16_t *dst; |
| dst = &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2]; |
| |
| TxfmParam txfm_param; |
| QUANT_PARAM quant_param; |
| |
| av1_setup_xform(cm, x, plane, tx_size, DCT_DCT, CCTX_NONE, &txfm_param); |
| av1_setup_quant(tx_size, 0, AV1_XFORM_QUANT_B, cpi->oxcf.q_cfg.quant_b_adapt, |
| &quant_param); |
| av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, DCT_DCT, |
| &quant_param); |
| av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, |
| &txfm_param, &quant_param); |
| |
| if (p->eobs[block] > 0) { |
| txfm_param.eob = p->eobs[block]; |
| av1_highbd_inv_txfm_add(dqcoeff, dst, pd->dst.stride, &txfm_param); |
| } |
| } |
| |
| void av1_encode_sby_pass1(AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize) { |
| encode_block_pass1_args args = { cpi, x }; |
| av1_subtract_plane(x, bsize, 0); |
| av1_foreach_transformed_block_in_plane(&x->e_mbd, bsize, 0, |
| encode_block_pass1, &args); |
| } |
| |
| void av1_encode_sb(const struct AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, |
| RUN_TYPE dry_run, int plane_start, int plane_end) { |
| (void)bsize; |
| assert(bsize < BLOCK_SIZES_ALL); |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| |
| #if CONFIG_SKIP_MODE_ENHANCEMENT |
| // Temporally set the skip_mode to 2, for the encoding trick to not skip the |
| // residual coding at RD stage. To be further refined |
| if (mbmi->skip_mode == 1 && |
| mbmi->skip_txfm[xd->tree_type == CHROMA_PART] == 0) { |
| mbmi->skip_mode = 2; |
| } |
| #endif // CONFIG_SKIP_MODE_ENHANCEMENT |
| |
| mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1; |
| #if CONFIG_LR_IMPROVEMENTS |
| if (x->txfm_search_info.skip_txfm && dry_run == OUTPUT_ENABLED) { |
| const AV1_COMMON *const cm = &cpi->common; |
| const int sb_type = mbmi->sb_type[xd->tree_type == CHROMA_PART]; |
| av1_init_txk_skip_array(cm, xd->mi_row, xd->mi_col, sb_type, 1, |
| xd->tree_type, &mbmi->chroma_ref_info, plane_start, |
| plane_end); |
| } |
| #endif // CONFIG_LR_IMPROVEMENTS |
| if (x->txfm_search_info.skip_txfm) return; |
| |
| struct optimize_ctx ctx; |
| struct encode_b_args arg = { |
| cpi, x, &ctx, &mbmi->skip_txfm[xd->tree_type == CHROMA_PART], |
| NULL, NULL, dry_run, cpi->optimize_seg_arr[mbmi->segment_id] |
| }; |
| |
| // Subtract first, so both U and V residues will be available when U |
| // component is being transformed and quantized. |
| for (int plane = plane_start; plane < plane_end; ++plane) { |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| if (plane && !xd->is_chroma_ref) break; |
| const BLOCK_SIZE plane_bsize = get_mb_plane_block_size( |
| xd, mbmi, plane, pd->subsampling_x, pd->subsampling_y); |
| av1_subtract_plane(x, plane_bsize, plane); |
| } |
| for (int plane = plane_start; plane < plane_end; ++plane) { |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| const int subsampling_x = pd->subsampling_x; |
| const int subsampling_y = pd->subsampling_y; |
| if (plane && !xd->is_chroma_ref) break; |
| |
| const BLOCK_SIZE plane_bsize = |
| get_mb_plane_block_size(xd, mbmi, plane, subsampling_x, subsampling_y); |
| #if !CONFIG_EXT_RECUR_PARTITIONS |
| const BLOCK_SIZE bsize_base = |
| plane ? mbmi->chroma_ref_info.bsize_base |
| : mbmi->sb_type[xd->tree_type == CHROMA_PART]; |
| assert(plane_bsize == |
| get_plane_block_size(bsize_base, subsampling_x, subsampling_y)); |
| (void)bsize_base; |
| #endif // !CONFIG_EXT_RECUR_PARTITIONS |
| assert(plane_bsize < BLOCK_SIZES_ALL); |
| const int mi_width = mi_size_wide[plane_bsize]; |
| const int mi_height = mi_size_high[plane_bsize]; |
| const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, plane); |
| const BLOCK_SIZE txb_size = txsize_to_bsize[max_tx_size]; |
| const int bw = mi_size_wide[txb_size]; |
| const int bh = mi_size_high[txb_size]; |
| int block = 0; |
| const int step = |
| tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size]; |
| av1_get_entropy_contexts(plane_bsize, pd, ctx.ta[plane], ctx.tl[plane]); |
| arg.ta = ctx.ta[plane]; |
| arg.tl = ctx.tl[plane]; |
| const BLOCK_SIZE max_unit_bsize = |
| get_plane_block_size(BLOCK_64X64, subsampling_x, subsampling_y); |
| int mu_blocks_wide = mi_size_wide[max_unit_bsize]; |
| int mu_blocks_high = mi_size_high[max_unit_bsize]; |
| mu_blocks_wide = AOMMIN(mi_width, mu_blocks_wide); |
| mu_blocks_high = AOMMIN(mi_height, mu_blocks_high); |
| |
| for (int idy = 0; idy < mi_height; idy += mu_blocks_high) { |
| for (int idx = 0; idx < mi_width; idx += mu_blocks_wide) { |
| int blk_row, blk_col; |
| const int unit_height = AOMMIN(mu_blocks_high + idy, mi_height); |
| const int unit_width = AOMMIN(mu_blocks_wide + idx, mi_width); |
| for (blk_row = idy; blk_row < unit_height; blk_row += bh) { |
| for (blk_col = idx; blk_col < unit_width; blk_col += bw) { |
| encode_block_inter(plane, block, blk_row, blk_col, plane_bsize, |
| max_tx_size, &arg, dry_run); |
| block += step; |
| } |
| } |
| } |
| } |
| } |
| |
| #if CONFIG_SKIP_MODE_ENHANCEMENT |
| // trick to avoid reset the skip_txfm for skip mode |
| if (mbmi->skip_mode == 2) { |
| mbmi->skip_mode = 1; |
| } |
| #endif // CONFIG_SKIP_MODE_ENHANCEMENT |
| } |
| |
| static void encode_block_intra_and_set_context(int plane, int block, |
| int blk_row, int blk_col, |
| BLOCK_SIZE plane_bsize, |
| TX_SIZE tx_size, void *arg) { |
| av1_encode_block_intra(plane, block, blk_row, blk_col, plane_bsize, tx_size, |
| arg); |
| |
| struct encode_b_args *const args = arg; |
| MACROBLOCK *x = args->x; |
| ENTROPY_CONTEXT *a = &args->ta[blk_col]; |
| ENTROPY_CONTEXT *l = &args->tl[blk_row]; |
| av1_set_txb_context(x, plane, block, tx_size, a, l); |
| } |
| |
| void av1_encode_block_intra(int plane, int block, int blk_row, int blk_col, |
| BLOCK_SIZE plane_bsize, TX_SIZE tx_size, |
| void *arg) { |
| struct encode_b_args *const args = arg; |
| const AV1_COMP *const cpi = args->cpi; |
| const AV1_COMMON *const cm = &cpi->common; |
| MACROBLOCK *const x = args->x; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *const mbmi = xd->mi[0]; |
| const int is_inter = is_inter_block(mbmi, xd->tree_type); |
| struct macroblock_plane *const p = &x->plane[plane]; |
| struct macroblockd_plane *const pd = &xd->plane[plane]; |
| tran_low_t *dqcoeff = p->dqcoeff + BLOCK_OFFSET(block); |
| PLANE_TYPE plane_type = get_plane_type(plane); |
| uint16_t *eob = &p->eobs[block]; |
| uint16_t *bob_code = &p->bobs[block]; |
| const int dst_stride = pd->dst.stride; |
| uint16_t *dst = |
| &pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2]; |
| int dummy_rate_cost = 0; |
| |
| av1_predict_intra_block_facade(cm, xd, plane, blk_col, blk_row, tx_size); |
| |
| #if CONFIG_MISMATCH_DEBUG |
| if (args->dry_run == OUTPUT_ENABLED) { |
| int pixel_c, pixel_r; |
| if (plane) { |
| mi_to_pixel_loc(&pixel_c, &pixel_r, |
| mbmi->chroma_ref_info.mi_col_chroma_base, |
| mbmi->chroma_ref_info.mi_row_chroma_base, blk_col, |
| blk_row, pd->subsampling_x, pd->subsampling_y); |
| } else { |
| mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, blk_col, |
| blk_row, pd->subsampling_x, pd->subsampling_y); |
| } |
| mismatch_record_block_pre(pd->dst.buf, pd->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| plane, pixel_c, pixel_r, tx_size_wide[tx_size], |
| tx_size_high[tx_size]); |
| } |
| #endif // CONFIG_MISMATCH_DEBUG |
| |
| TX_TYPE tx_type = DCT_DCT; |
| const int bw = mi_size_wide[plane_bsize]; |
| #if DEBUG_EXTQUANT |
| if (args->dry_run == OUTPUT_ENABLED) { |
| fprintf(cm->fEncCoeffLog, |
| "\nmi_row = %d, mi_col = %d, blk_row = %d," |
| " blk_col = %d, plane = %d, tx_size = %d ", |
| xd->mi_row, xd->mi_col, blk_row, blk_col, plane, tx_size); |
| } |
| #endif |
| |
| if (plane == 0 && is_blk_skip(x->txfm_search_info.blk_skip, plane, |
| blk_row * bw + blk_col)) { |
| *eob = 0; |
| *bob_code = 0; |
| p->txb_entropy_ctx[block] = 0; |
| #if DEBUG_EXTQUANT |
| if (args->dry_run == OUTPUT_ENABLED) { |
| fprintf(cm->fEncCoeffLog, "tx_type = %d, eob = %d", tx_type, *eob); |
| } |
| #endif |
| } else { |
| av1_subtract_txb(x, plane, plane_bsize, blk_col, blk_row, tx_size); |
| |
| const ENTROPY_CONTEXT *a = &args->ta[blk_col]; |
| const ENTROPY_CONTEXT *l = &args->tl[blk_row]; |
| tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size, |
| cm->features.reduced_tx_set_used); |
| TxfmParam txfm_param; |
| QUANT_PARAM quant_param; |
| const uint8_t fsc_mode = (mbmi->fsc_mode[xd->tree_type == CHROMA_PART] && |
| plane == PLANE_TYPE_Y) || |
| use_inter_fsc(cm, plane, tx_type, is_inter); |
| const int use_trellis = |
| is_trellis_used(args->enable_optimize_b, args->dry_run) |
| #if !CONFIG_IMPROVEIDTX_RDPH |
| && !fsc_mode |
| #endif // !CONFIG_IMPROVEIDTX_RDPH |
| ; |
| int quant_idx; |
| if (use_trellis) |
| quant_idx = AV1_XFORM_QUANT_FP; |
| else |
| quant_idx = |
| USE_B_QUANT_NO_TRELLIS ? AV1_XFORM_QUANT_B : AV1_XFORM_QUANT_FP; |
| |
| av1_setup_xform(cm, x, plane, tx_size, tx_type, CCTX_NONE, &txfm_param); |
| av1_setup_quant(tx_size, use_trellis, quant_idx, |
| cpi->oxcf.q_cfg.quant_b_adapt, &quant_param); |
| av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type, |
| &quant_param); |
| av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, |
| &txfm_param, &quant_param); |
| |
| bool enable_parity_hiding = |
| cm->features.allow_parity_hiding && !xd->lossless[mbmi->segment_id] && |
| plane == PLANE_TYPE_Y && |
| #if CONFIG_IMPROVEIDTX_RDPH |
| ph_allowed_tx_types[get_primary_tx_type(tx_type)] && (*eob > PHTHRESH); |
| #else |
| get_primary_tx_type(tx_type) < IDTX; |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| #if DEBUG_EXTQUANT |
| if (args->dry_run == OUTPUT_ENABLED) { |
| fprintf(cm->fEncCoeffLog, "tx_type = %d, eob = %d\n", tx_type, *eob); |
| for (int c = 0; c < tx_size_wide[tx_size] * tx_size_high[tx_size]; c++) { |
| fprintf(cm->fEncCoeffLog, "%d ", dqcoeff[c]); |
| } |
| fprintf(cm->fEncCoeffLog, "\n\n"); |
| } |
| #endif |
| // Whether trellis or dropout optimization is required for key frames and |
| // intra frames. |
| const bool do_trellis = (frame_is_intra_only(cm) && |
| (KEY_BLOCK_OPT_TYPE == TRELLIS_OPT || |
| KEY_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)) || |
| (!frame_is_intra_only(cm) && |
| (INTRA_BLOCK_OPT_TYPE == TRELLIS_OPT || |
| INTRA_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)); |
| const bool do_dropout = (frame_is_intra_only(cm) && |
| (KEY_BLOCK_OPT_TYPE == DROPOUT_OPT || |
| KEY_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)) || |
| (!frame_is_intra_only(cm) && |
| (INTRA_BLOCK_OPT_TYPE == DROPOUT_OPT || |
| INTRA_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)); |
| |
| if (quant_param.use_optimize_b && do_trellis) { |
| TXB_CTX txb_ctx; |
| get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx, |
| mbmi->fsc_mode[xd->tree_type == CHROMA_PART]); |
| #if CONFIG_IMPROVEIDTX_RDPH |
| if (fsc_mode) |
| av1_optimize_fsc(args->cpi, x, plane, block, tx_size, tx_type, &txb_ctx, |
| &dummy_rate_cost); |
| else |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type, CCTX_NONE, |
| &txb_ctx, &dummy_rate_cost); |
| } |
| |
| if (do_dropout && !fsc_mode && !enable_parity_hiding) { |
| av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, |
| cm->quant_params.base_qindex); |
| } |
| // make sure recon is correct at the encoder |
| if (*eob == 1 && tx_type != 0 && plane == 0) { |
| xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col] = DCT_DCT; |
| tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size, |
| cm->features.reduced_tx_set_used); |
| av1_setup_xform(cm, x, plane, tx_size, tx_type, CCTX_NONE, &txfm_param); |
| av1_setup_quant(tx_size, use_trellis, quant_idx, |
| cpi->oxcf.q_cfg.quant_b_adapt, &quant_param); |
| av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type, |
| &quant_param); |
| av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, |
| &txfm_param, &quant_param); |
| if (quant_param.use_optimize_b && do_trellis) { |
| TXB_CTX txb_ctx; |
| get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx, |
| mbmi->fsc_mode[xd->tree_type == CHROMA_PART]); |
| #if CONFIG_IMPROVEIDTX_RDPH |
| if (fsc_mode) |
| av1_optimize_fsc(args->cpi, x, plane, block, tx_size, tx_type, |
| &txb_ctx, &dummy_rate_cost); |
| else |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type, |
| CCTX_NONE, &txb_ctx, &dummy_rate_cost); |
| } |
| if (do_dropout && !fsc_mode && !enable_parity_hiding) { |
| av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, |
| cm->quant_params.base_qindex); |
| } |
| } |
| if (!quant_param.use_optimize_b && enable_parity_hiding) { |
| parity_hiding_trellis_off(cpi, x, plane, block, tx_size, tx_type); |
| } |
| } |
| |
| if (*eob) { |
| av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst, |
| dst_stride, *eob, |
| cm->features.reduced_tx_set_used); |
| } |
| |
| // TODO(jingning): Temporarily disable txk_type check for eob=0 case. |
| // It is possible that certain collision in hash index would cause |
| // the assertion failure. To further optimize the rate-distortion |
| // performance, we need to re-visit this part and enable this assert |
| // again. |
| if (*eob == 0 && plane == 0) { |
| #if 0 |
| if (args->cpi->oxcf.q_cfg.aq_mode == NO_AQ |
| && args->cpi->oxcf.q_cfg.deltaq_mode == NO_DELTA_Q) { |
| assert(xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col)] == |
| DCT_DCT); |
| } |
| #endif |
| update_txk_array(xd, blk_row, blk_col, tx_size, DCT_DCT); |
| } |
| |
| #if CONFIG_LR_IMPROVEMENTS |
| if (*eob == 0 && args->dry_run == OUTPUT_ENABLED) { |
| av1_update_txk_skip_array(cm, xd->mi_row, xd->mi_col, xd->tree_type, |
| &mbmi->chroma_ref_info, plane, blk_row, blk_col, |
| tx_size); |
| } |
| #endif // CONFIG_LR_IMPROVEMENTS |
| |
| #if CONFIG_MISMATCH_DEBUG |
| if (args->dry_run == OUTPUT_ENABLED) { |
| int pixel_c, pixel_r; |
| BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; |
| int blk_w = block_size_wide[bsize]; |
| int blk_h = block_size_high[bsize]; |
| if (plane) { |
| mi_to_pixel_loc(&pixel_c, &pixel_r, |
| mbmi->chroma_ref_info.mi_col_chroma_base, |
| mbmi->chroma_ref_info.mi_row_chroma_base, blk_col, |
| blk_row, pd->subsampling_x, pd->subsampling_y); |
| } else { |
| mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, blk_col, |
| blk_row, pd->subsampling_x, pd->subsampling_y); |
| } |
| mismatch_record_block_tx(dst, pd->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| plane, pixel_c, pixel_r, blk_w, blk_h); |
| } |
| #endif // CONFIG_MISMATCH_DEBUG |
| |
| // For intra mode, skipped blocks are so rare that transmitting skip=1 is |
| // very expensive. |
| *(args->skip) = 0; |
| if (plane == AOM_PLANE_Y && xd->cfl.store_y && xd->tree_type == SHARED_PART) { |
| #if CONFIG_IMPROVED_CFL |
| cfl_store_tx(xd, blk_row, blk_col, tx_size, |
| cm->seq_params.enable_cfl_ds_filter); |
| #else |
| cfl_store_tx(xd, blk_row, blk_col, tx_size); |
| #endif // CONFIG_IMPROVED_CFL |
| } |
| } |
| |
| void av1_encode_intra_block_plane(const struct AV1_COMP *cpi, MACROBLOCK *x, |
| BLOCK_SIZE bsize, int plane, RUN_TYPE dry_run, |
| TRELLIS_OPT_TYPE enable_optimize_b) { |
| const MACROBLOCKD *const xd = &x->e_mbd; |
| if (plane && !xd->is_chroma_ref) return; |
| |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| const int ss_x = pd->subsampling_x; |
| const int ss_y = pd->subsampling_y; |
| ENTROPY_CONTEXT ta[MAX_MIB_SIZE] = { 0 }; |
| ENTROPY_CONTEXT tl[MAX_MIB_SIZE] = { 0 }; |
| int8_t *skip_txfm = &(xd->mi[0]->skip_txfm[xd->tree_type == CHROMA_PART]); |
| |
| struct encode_b_args arg = { cpi, x, NULL, skip_txfm, |
| ta, tl, dry_run, enable_optimize_b }; |
| const BLOCK_SIZE plane_bsize = |
| get_mb_plane_block_size(xd, xd->mi[0], plane, ss_x, ss_y); |
| #if !CONFIG_EXT_RECUR_PARTITIONS |
| assert(plane_bsize == get_plane_block_size(bsize, ss_x, ss_y)); |
| #endif // !CONFIG_EXT_RECUR_PARTITIONS |
| (void)bsize; |
| if (enable_optimize_b) { |
| av1_get_entropy_contexts(plane_bsize, pd, ta, tl); |
| } |
| #if CONFIG_TX_PARTITION_TYPE_EXT |
| if (plane == AOM_PLANE_Y && !xd->lossless[xd->mi[0]->segment_id]) { |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| const TX_SIZE max_tx_size = max_txsize_rect_lookup[plane_bsize]; |
| get_tx_partition_sizes(mbmi->tx_partition_type[0], max_tx_size, |
| &mbmi->txb_pos, mbmi->sub_txs); |
| // If mb_to_right_edge is < 0 we are in a situation in which |
| // the current block size extends into the UMV and we won't |
| // visit the sub blocks that are wholly within the UMV. |
| const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); |
| const int max_blocks_high = max_block_high(xd, plane_bsize, plane); |
| const BLOCK_SIZE max_unit_bsize = |
| get_plane_block_size(BLOCK_64X64, pd->subsampling_x, pd->subsampling_y); |
| const int mu_blocks_wide = |
| AOMMIN(mi_size_wide[max_unit_bsize], max_blocks_wide); |
| const int mu_blocks_high = |
| AOMMIN(mi_size_high[max_unit_bsize], max_blocks_high); |
| |
| // Keep track of the row and column of the blocks we use so that we know |
| // if we are in the unrestricted motion border. |
| int i = 0; |
| for (int r = 0; r < max_blocks_high; r += mu_blocks_high) { |
| const int unit_height = AOMMIN(mu_blocks_high + r, max_blocks_high); |
| // Skip visiting the sub blocks that are wholly within the UMV. |
| for (int c = 0; c < max_blocks_wide; c += mu_blocks_wide) { |
| const int unit_width = AOMMIN(mu_blocks_wide + c, max_blocks_wide); |
| |
| for (int txb_idx = 0; txb_idx < mbmi->txb_pos.n_partitions; ++txb_idx) { |
| TX_SIZE tx_size = mbmi->sub_txs[txb_idx]; |
| mbmi->txb_idx = txb_idx; |
| |
| const uint8_t txw_unit = tx_size_wide_unit[tx_size]; |
| const uint8_t txh_unit = tx_size_high_unit[tx_size]; |
| const int step = txw_unit * txh_unit; |
| |
| int blk_row = r + mbmi->txb_pos.row_offset[txb_idx]; |
| int blk_col = c + mbmi->txb_pos.col_offset[txb_idx]; |
| |
| if (blk_row >= unit_height || blk_col >= unit_width) continue; |
| |
| mbmi->tx_size = tx_size; |
| encode_block_intra_and_set_context(plane, i, blk_row, blk_col, |
| plane_bsize, tx_size, &arg); |
| i += step; |
| } |
| } |
| } |
| } else { |
| av1_foreach_transformed_block_in_plane( |
| xd, plane_bsize, plane, encode_block_intra_and_set_context, &arg); |
| } |
| #else |
| av1_foreach_transformed_block_in_plane( |
| xd, plane_bsize, plane, encode_block_intra_and_set_context, &arg); |
| #endif // CONFIG_TX_PARTITION_TYPE_EXT |
| } |
| |
| // Jointly encode two chroma components for an intra block. |
| void av1_encode_block_intra_joint_uv(int block, int blk_row, int blk_col, |
| BLOCK_SIZE plane_bsize, TX_SIZE tx_size, |
| void *arg) { |
| struct encode_b_args *const args = arg; |
| const AV1_COMP *const cpi = args->cpi; |
| const AV1_COMMON *const cm = &cpi->common; |
| MACROBLOCK *const x = args->x; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| assert(is_cctx_allowed(cm, xd)); |
| |
| struct macroblock_plane *const p_c1 = &x->plane[AOM_PLANE_U]; |
| struct macroblock_plane *const p_c2 = &x->plane[AOM_PLANE_V]; |
| struct macroblockd_plane *const pd_c1 = &xd->plane[AOM_PLANE_U]; |
| struct macroblockd_plane *const pd_c2 = &xd->plane[AOM_PLANE_V]; |
| tran_low_t *dqcoeff_c1 = p_c1->dqcoeff + BLOCK_OFFSET(block); |
| tran_low_t *dqcoeff_c2 = p_c2->dqcoeff + BLOCK_OFFSET(block); |
| uint16_t *eob_c1 = &p_c1->eobs[block]; |
| uint16_t *eob_c2 = &p_c2->eobs[block]; |
| const int dst_stride = pd_c1->dst.stride; |
| uint16_t *dst_c1 = |
| &pd_c1->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2]; |
| uint16_t *dst_c2 = |
| &pd_c2->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2]; |
| int dummy_rate_cost = 0; |
| |
| av1_predict_intra_block_facade(cm, xd, AOM_PLANE_U, blk_col, blk_row, |
| tx_size); |
| av1_predict_intra_block_facade(cm, xd, AOM_PLANE_V, blk_col, blk_row, |
| tx_size); |
| |
| #if CONFIG_MISMATCH_DEBUG |
| if (args->dry_run == OUTPUT_ENABLED) { |
| int pixel_c, pixel_r; |
| mi_to_pixel_loc(&pixel_c, &pixel_r, |
| xd->mi[0]->chroma_ref_info.mi_col_chroma_base, |
| xd->mi[0]->chroma_ref_info.mi_row_chroma_base, blk_col, |
| blk_row, pd_c1->subsampling_x, pd_c1->subsampling_y); |
| mismatch_record_block_pre(pd_c1->dst.buf, pd_c1->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| AOM_PLANE_U, pixel_c, pixel_r, |
| tx_size_wide[tx_size], tx_size_high[tx_size]); |
| mismatch_record_block_pre(pd_c2->dst.buf, pd_c2->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| AOM_PLANE_V, pixel_c, pixel_r, |
| tx_size_wide[tx_size], tx_size_high[tx_size]); |
| } |
| #endif // CONFIG_MISMATCH_DEBUG |
| |
| TX_TYPE tx_type = av1_get_tx_type(xd, PLANE_TYPE_UV, blk_row, blk_col, |
| tx_size, cm->features.reduced_tx_set_used); |
| CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col); |
| |
| av1_subtract_txb(x, AOM_PLANE_U, plane_bsize, blk_col, blk_row, tx_size); |
| av1_subtract_txb(x, AOM_PLANE_V, plane_bsize, blk_col, blk_row, tx_size); |
| |
| TxfmParam txfm_param; |
| QUANT_PARAM quant_param; |
| const int use_trellis = |
| is_trellis_used(args->enable_optimize_b, args->dry_run); |
| int quant_idx; |
| if (use_trellis) |
| quant_idx = AV1_XFORM_QUANT_FP; |
| else |
| quant_idx = USE_B_QUANT_NO_TRELLIS ? AV1_XFORM_QUANT_B : AV1_XFORM_QUANT_FP; |
| |
| av1_setup_xform(cm, x, AOM_PLANE_U, tx_size, tx_type, cctx_type, &txfm_param); |
| av1_setup_quant(tx_size, use_trellis, quant_idx, |
| cpi->oxcf.q_cfg.quant_b_adapt, &quant_param); |
| // Whether trellis or dropout optimization is required for key frames and |
| // intra frames. |
| const bool do_trellis = (frame_is_intra_only(cm) && |
| (KEY_BLOCK_OPT_TYPE == TRELLIS_OPT || |
| KEY_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)) || |
| (!frame_is_intra_only(cm) && |
| (INTRA_BLOCK_OPT_TYPE == TRELLIS_OPT || |
| INTRA_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)); |
| const bool do_dropout = (frame_is_intra_only(cm) && |
| (KEY_BLOCK_OPT_TYPE == DROPOUT_OPT || |
| KEY_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)) || |
| (!frame_is_intra_only(cm) && |
| (INTRA_BLOCK_OPT_TYPE == DROPOUT_OPT || |
| INTRA_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT)); |
| for (int plane = AOM_PLANE_U; plane <= AOM_PLANE_V; plane++) { |
| if (plane == AOM_PLANE_V && !is_inter_block(xd->mi[0], xd->tree_type) && |
| *eob_c1 == 1) { |
| update_cctx_array(xd, blk_row, blk_col, 0, 0, |
| args->dry_run ? TX_4X4 : tx_size, CCTX_NONE); |
| cctx_type = av1_get_cctx_type(xd, blk_row, blk_col); |
| } |
| // Since eob can be updated here, make sure cctx_type is always CCTX_NONE |
| // when eob of U is 0. |
| if (plane == AOM_PLANE_V && *eob_c1 == 0) { |
| // In dry run, cctx type will not be referenced by neighboring blocks, |
| // so there is no need to fill in the whole chroma region. In addition, |
| // ctx->cctx_type_map size in dry run may not be aligned with actual |
| // chroma coding region for some partition types. |
| update_cctx_array(xd, blk_row, blk_col, 0, 0, |
| args->dry_run ? TX_4X4 : tx_size, CCTX_NONE); |
| } |
| #if CCTX_C2_DROPPED |
| if (plane == AOM_PLANE_V && (!keep_chroma_c2(cctx_type) || |
| (*eob_c1 == 0 && cctx_type > CCTX_NONE))) { |
| #else |
| if (plane == AOM_PLANE_V && *eob_c1 == 0 && cctx_type > CCTX_NONE) { |
| #endif // CCTX_C2_DROPPED |
| av1_quantize_skip(av1_get_max_eob(tx_size), |
| p_c2->qcoeff + BLOCK_OFFSET(block), dqcoeff_c2, eob_c2); |
| break; |
| } |
| av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type, |
| &quant_param); |
| av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, |
| &txfm_param, &quant_param); |
| #if CONFIG_IMPROVEIDTX_RDPH |
| const uint8_t fsc_mode = |
| (xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] && |
| plane == PLANE_TYPE_Y) || |
| use_inter_fsc(cm, plane, tx_type, 0 /*is_inter*/); |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| if (quant_param.use_optimize_b && do_trellis) { |
| const ENTROPY_CONTEXT *a = |
| &args->ta[blk_col + (plane - AOM_PLANE_U) * MAX_MIB_SIZE]; |
| const ENTROPY_CONTEXT *l = |
| &args->tl[blk_row + (plane - AOM_PLANE_U) * MAX_MIB_SIZE]; |
| TXB_CTX txb_ctx; |
| get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx, |
| xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART]); |
| #if CONFIG_IMPROVEIDTX_RDPH |
| if (fsc_mode) |
| av1_optimize_fsc(args->cpi, x, plane, block, tx_size, tx_type, &txb_ctx, |
| &dummy_rate_cost); |
| else |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type, cctx_type, |
| &txb_ctx, &dummy_rate_cost); |
| } |
| if (do_dropout) { |
| av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, |
| cm->quant_params.base_qindex); |
| } |
| if (plane == AOM_PLANE_V && !is_inter_block(xd->mi[0], xd->tree_type) && |
| *eob_c1 == 1) { |
| update_cctx_array(xd, blk_row, blk_col, 0, 0, |
| args->dry_run ? TX_4X4 : tx_size, CCTX_NONE); |
| cctx_type = av1_get_cctx_type(xd, blk_row, blk_col); |
| av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type, |
| &quant_param); |
| av1_xform_quant(cm, x, plane, block, blk_row, blk_col, plane_bsize, |
| &txfm_param, &quant_param); |
| if (quant_param.use_optimize_b && do_trellis) { |
| const ENTROPY_CONTEXT *a = |
| &args->ta[blk_col + (plane - AOM_PLANE_U) * MAX_MIB_SIZE]; |
| const ENTROPY_CONTEXT *l = |
| &args->tl[blk_row + (plane - AOM_PLANE_U) * MAX_MIB_SIZE]; |
| TXB_CTX txb_ctx; |
| get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx, |
| xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART]); |
| #if CONFIG_IMPROVEIDTX_RDPH |
| if (fsc_mode) |
| av1_optimize_fsc(args->cpi, x, plane, block, tx_size, tx_type, |
| &txb_ctx, &dummy_rate_cost); |
| else |
| #endif // CONFIG_IMPROVEIDTX_RDPH |
| av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type, |
| cctx_type, &txb_ctx, &dummy_rate_cost); |
| } |
| if (do_dropout) { |
| av1_dropout_qcoeff(x, plane, block, tx_size, tx_type, |
| cm->quant_params.base_qindex); |
| } |
| } |
| } |
| |
| if (*eob_c1 || *eob_c2) { |
| av1_inv_cross_chroma_tx_block(dqcoeff_c1, dqcoeff_c2, tx_size, cctx_type); |
| av1_inverse_transform_block(xd, dqcoeff_c1, AOM_PLANE_U, tx_type, tx_size, |
| dst_c1, dst_stride, AOMMAX(*eob_c1, *eob_c2), |
| cm->features.reduced_tx_set_used); |
| av1_inverse_transform_block(xd, dqcoeff_c2, AOM_PLANE_V, tx_type, tx_size, |
| dst_c2, dst_stride, AOMMAX(*eob_c1, *eob_c2), |
| cm->features.reduced_tx_set_used); |
| } |
| |
| #if CONFIG_LR_IMPROVEMENTS |
| if (args->dry_run == OUTPUT_ENABLED) { |
| if (*eob_c1 == 0) |
| av1_update_txk_skip_array(cm, xd->mi_row, xd->mi_col, xd->tree_type, |
| &xd->mi[0]->chroma_ref_info, AOM_PLANE_U, |
| blk_row, blk_col, tx_size); |
| if (*eob_c2 == 0) |
| av1_update_txk_skip_array(cm, xd->mi_row, xd->mi_col, xd->tree_type, |
| &xd->mi[0]->chroma_ref_info, AOM_PLANE_V, |
| blk_row, blk_col, tx_size); |
| } |
| #endif // CONFIG_LR_IMPROVEMENTS |
| |
| #if CONFIG_MISMATCH_DEBUG |
| if (args->dry_run == OUTPUT_ENABLED) { |
| int pixel_c, pixel_r; |
| BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; |
| int blk_w = block_size_wide[bsize]; |
| int blk_h = block_size_high[bsize]; |
| mi_to_pixel_loc(&pixel_c, &pixel_r, |
| xd->mi[0]->chroma_ref_info.mi_col_chroma_base, |
| xd->mi[0]->chroma_ref_info.mi_row_chroma_base, blk_col, |
| blk_row, pd_c1->subsampling_x, pd_c1->subsampling_y); |
| mismatch_record_block_tx(dst_c1, pd_c1->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| AOM_PLANE_U, pixel_c, pixel_r, blk_w, blk_h); |
| mismatch_record_block_tx(dst_c2, pd_c2->dst.stride, |
| #if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| cm->current_frame.display_order_hint, |
| #else |
| cm->current_frame.order_hint, |
| #endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC |
| AOM_PLANE_V, pixel_c, pixel_r, blk_w, blk_h); |
| } |
| #endif // CONFIG_MISMATCH_DEBUG |
| |
| // For intra mode, skipped blocks are so rare that transmitting skip=1 is |
| // very expensive. |
| *(args->skip) = 0; |
| } |
| |
| // Jointly code two chroma components and set contexts |
| static void encode_block_intra_and_set_context_joint_uv( |
| int plane, int block, int blk_row, int blk_col, BLOCK_SIZE plane_bsize, |
| TX_SIZE tx_size, void *arg) { |
| (void)plane; |
| av1_encode_block_intra_joint_uv(block, blk_row, blk_col, plane_bsize, tx_size, |
| arg); |
| |
| struct encode_b_args *const args = arg; |
| MACROBLOCK *x = args->x; |
| ENTROPY_CONTEXT *au = &args->ta[blk_col]; |
| ENTROPY_CONTEXT *lu = &args->tl[blk_row]; |
| ENTROPY_CONTEXT *av = &args->ta[MAX_MIB_SIZE + blk_col]; |
| ENTROPY_CONTEXT *lv = &args->tl[MAX_MIB_SIZE + blk_row]; |
| av1_set_txb_context(x, AOM_PLANE_U, block, tx_size, au, lu); |
| av1_set_txb_context(x, AOM_PLANE_V, block, tx_size, av, lv); |
| } |
| |
| // This function codes the two chroma components jointly for each transform |
| // blocks within a block. This coding path is used instead of |
| // av1_encode_intra_block() when cross chroma component transform is |
| // applicable. |
| void av1_encode_intra_block_joint_uv(const struct AV1_COMP *cpi, MACROBLOCK *x, |
| BLOCK_SIZE bsize, RUN_TYPE dry_run, |
| TRELLIS_OPT_TYPE enable_optimize_b) { |
| assert(bsize < BLOCK_SIZES_ALL); |
| const MACROBLOCKD *const xd = &x->e_mbd; |
| if (!xd->is_chroma_ref) return; |
| |
| const struct macroblockd_plane *const pd_u = &xd->plane[AOM_PLANE_U]; |
| const struct macroblockd_plane *const pd_v = &xd->plane[AOM_PLANE_V]; |
| const int ss_x = pd_u->subsampling_x; |
| const int ss_y = pd_u->subsampling_y; |
| assert(ss_x == pd_v->subsampling_x && ss_y == pd_v->subsampling_y); |
| ENTROPY_CONTEXT ta[MAX_MIB_SIZE * 2] = { 0 }; |
| ENTROPY_CONTEXT tl[MAX_MIB_SIZE * 2] = { 0 }; |
| struct encode_b_args arg = { |
| cpi, x, NULL, &(xd->mi[0]->skip_txfm[xd->tree_type == CHROMA_PART]), |
| ta, tl, dry_run, enable_optimize_b |
| }; |
| const BLOCK_SIZE plane_bsize = |
| get_mb_plane_block_size(xd, xd->mi[0], AOM_PLANE_U, ss_x, ss_y); |
| #if !CONFIG_EXT_RECUR_PARTITIONS |
| assert(plane_bsize == get_plane_block_size(bsize, ss_x, ss_y)); |
| #endif // !CONFIG_EXT_RECUR_PARTITIONS |
| (void)bsize; |
| if (enable_optimize_b) { |
| av1_get_entropy_contexts(plane_bsize, pd_u, ta, tl); |
| av1_get_entropy_contexts(plane_bsize, pd_v, &ta[MAX_MIB_SIZE], |
| &tl[MAX_MIB_SIZE]); |
| } |
| av1_foreach_transformed_block_in_plane( |
| xd, plane_bsize, AOM_PLANE_U, encode_block_intra_and_set_context_joint_uv, |
| &arg); |
| } |