Google Git
Sign in
aomedia / avm / refs/heads/research-inter2 / . / av1 / encoder / bitstream.c
blob: d861e7abce5e0d30d1e5beb001d0cc9df509b799 [file] [log] [blame] [edit]
/*
* 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 <assert.h>
#include <limits.h>
#include <stdio.h>
#include "aom/aom_encoder.h"
#include "aom_dsp/aom_dsp_common.h"
#include "aom_dsp/binary_codes_writer.h"
#include "aom_dsp/bitwriter_buffer.h"
#include "aom_mem/aom_mem.h"
#include "aom_ports/bitops.h"
#include "aom_ports/mem_ops.h"
#include "aom_ports/system_state.h"
#include "av1/common/blockd.h"
#if CONFIG_BITSTREAM_DEBUG
#include "aom_util/debug_util.h"
#endif // CONFIG_BITSTREAM_DEBUG
#include "common/md5_utils.h"
#include "common/rawenc.h"
#include "av1/common/blockd.h"
#include "av1/common/cdef.h"
#if CONFIG_CCSO
#include "av1/common/ccso.h"
#endif
#include "av1/common/cfl.h"
#include "av1/common/entropy.h"
#include "av1/common/entropymode.h"
#include "av1/common/entropymv.h"
#include "av1/common/mvref_common.h"
#include "av1/common/pred_common.h"
#include "av1/common/reconinter.h"
#include "av1/common/reconintra.h"
#include "av1/common/seg_common.h"
#include "av1/common/tile_common.h"
#include "av1/encoder/bitstream.h"
#include "av1/encoder/cost.h"
#include "av1/encoder/encodemv.h"
#include "av1/encoder/encodetxb.h"
#include "av1/encoder/mcomp.h"
#include "av1/encoder/palette.h"
#include "av1/encoder/pickrst.h"
#include "av1/encoder/segmentation.h"
#include "av1/encoder/tokenize.h"
// Silence compiler warning for unused static functions
static void image2yuvconfig_upshift(aom_image_t *hbd_img,
const aom_image_t *img,
YV12_BUFFER_CONFIG *yv12) AOM_UNUSED;
#include "av1/av1_iface_common.h"
#define ENC_MISMATCH_DEBUG 0
static INLINE void write_uniform(aom_writer *w, int n, int v) {
const int l = get_unsigned_bits(n);
const int m = (1 << l) - n;
if (l == 0) return;
if (v < m) {
aom_write_literal(w, v, l - 1);
} else {
aom_write_literal(w, m + ((v - m) >> 1), l - 1);
aom_write_literal(w, (v - m) & 1, 1);
}
}
static AOM_INLINE void loop_restoration_write_sb_coeffs(
const AV1_COMMON *const cm, MACROBLOCKD *xd, const RestorationUnitInfo *rui,
aom_writer *const w, int plane, FRAME_COUNTS *counts);
#if CONFIG_IBC_SR_EXT
static AOM_INLINE void write_intrabc_info(
MACROBLOCKD *xd, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
aom_writer *w);
#endif // CONFIG_IBC_SR_EXT
#if !CONFIG_AIMC
static AOM_INLINE void write_intra_y_mode_kf(FRAME_CONTEXT *frame_ctx,
const MB_MODE_INFO *mi,
const MB_MODE_INFO *neighbors0,
const MB_MODE_INFO *neighbors1,
PREDICTION_MODE mode,
aom_writer *w) {
assert(!is_intrabc_block(mi, SHARED_PART));
(void)mi;
aom_write_symbol(w, mode, get_y_mode_cdf(frame_ctx, neighbors0, neighbors1),
INTRA_MODES);
}
#endif // !CONFIG_AIMC
static AOM_INLINE void write_inter_mode(aom_writer *w, PREDICTION_MODE mode,
FRAME_CONTEXT *ec_ctx,
const int16_t mode_ctx
#if CONFIG_WARPMV
,
const AV1_COMMON *const cm,
const MACROBLOCKD *xd,
const MB_MODE_INFO *mbmi,
BLOCK_SIZE bsize
#endif // CONFIG_WARPMV
) {
const int16_t ismode_ctx = inter_single_mode_ctx(mode_ctx);
#if CONFIG_WARPMV
if (is_warpmv_mode_allowed(cm, mbmi, bsize)) {
const int16_t iswarpmvmode_ctx = inter_warpmv_mode_ctx(cm, xd, mbmi);
aom_write_symbol(w, mode == WARPMV,
ec_ctx->inter_warp_mode_cdf[iswarpmvmode_ctx], 2);
if (mode == WARPMV) return;
} else {
assert(mode != WARPMV);
}
#endif // CONFIG_WARPMV
aom_write_symbol(w, mode - SINGLE_INTER_MODE_START,
ec_ctx->inter_single_mode_cdf[ismode_ctx],
INTER_SINGLE_MODES);
}
static void write_drl_idx(int max_drl_bits, const int16_t mode_ctx,
FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi,
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
aom_writer *w) {
#if !CONFIG_SKIP_MODE_ENHANCEMENT
assert(!mbmi->skip_mode);
#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_WARPMV
assert(IMPLIES(mbmi->mode == WARPMV, 0));
#endif // CONFIG_WARPMV
// Write the DRL index as a sequence of bits encoding a decision tree:
// 0 -> 0 10 -> 1 110 -> 2 111 -> 3
// Also use the number of reference MVs for a frame type to reduce the
// number of bits written if there are less than 4 valid DRL indices.
#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
if (mbmi->skip_mode)
assert(mbmi->ref_mv_idx <
mbmi_ext_frame->skip_mvp_candidate_list.ref_mv_count);
else
#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
assert(mbmi->ref_mv_idx < mbmi_ext_frame->ref_mv_count);
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf =
#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
mbmi->skip_mode
? ec_ctx->skip_drl_cdf[AOMMIN(idx, 2)]
: av1_get_drl_cdf(ec_ctx, mbmi_ext_frame->weight, mode_ctx, idx);
#else
av1_get_drl_cdf(ec_ctx, mbmi_ext_frame->weight, mode_ctx, idx);
#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
aom_write_symbol(w, mbmi->ref_mv_idx != idx, drl_cdf, 2);
if (mbmi->ref_mv_idx == idx) break;
}
}
#if CONFIG_WARP_REF_LIST
static void write_warp_ref_idx(FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi,
aom_writer *w) {
assert(mbmi->warp_ref_idx < mbmi->max_num_warp_candidates);
assert(mbmi->max_num_warp_candidates <= MAX_WARP_REF_CANDIDATES);
if (mbmi->max_num_warp_candidates <= 1) {
return;
}
int max_idx_bits = mbmi->max_num_warp_candidates - 1;
for (int bit_idx = 0; bit_idx < max_idx_bits; ++bit_idx) {
aom_cdf_prob *warp_ref_idx_cdf = av1_get_warp_ref_idx_cdf(ec_ctx, bit_idx);
aom_write_symbol(w, mbmi->warp_ref_idx != bit_idx, warp_ref_idx_cdf, 2);
if (mbmi->warp_ref_idx == bit_idx) break;
}
}
#endif // CONFIG_WARP_REF_LIST
#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
// Write scale mode flag for joint mvd coding mode
static AOM_INLINE void write_jmvd_scale_mode(MACROBLOCKD *xd, aom_writer *w,
const MB_MODE_INFO *const mbmi) {
if (!is_joint_mvd_coding_mode(mbmi->mode)) return;
#if CONFIG_ADAPTIVE_MVD
const int is_joint_amvd_mode = is_joint_amvd_coding_mode(mbmi->mode);
aom_cdf_prob *jmvd_scale_mode_cdf =
is_joint_amvd_mode ? xd->tile_ctx->jmvd_amvd_scale_mode_cdf
: xd->tile_ctx->jmvd_scale_mode_cdf;
const int jmvd_scale_cnt = is_joint_amvd_mode ? JOINT_AMVD_SCALE_FACTOR_CNT
: JOINT_NEWMV_SCALE_FACTOR_CNT;
aom_write_symbol(w, mbmi->jmvd_scale_mode, jmvd_scale_mode_cdf,
jmvd_scale_cnt);
#else
aom_write_symbol(w, mbmi->jmvd_scale_mode, xd->tile_ctx->jmvd_scale_mode_cdf,
JOINT_NEWMV_SCALE_FACTOR_CNT);
#endif // CONFIG_ADAPTIVE_MVD
}
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
static AOM_INLINE void write_inter_compound_mode(MACROBLOCKD *xd, aom_writer *w,
PREDICTION_MODE mode,
#if CONFIG_OPTFLOW_REFINEMENT
const AV1_COMMON *cm,
const MB_MODE_INFO *const mbmi,
#endif // CONFIG_OPTFLOW_REFINEMENT
const int16_t mode_ctx) {
assert(is_inter_compound_mode(mode));
#if CONFIG_OPTFLOW_REFINEMENT
if (cm->features.opfl_refine_type == REFINE_SWITCHABLE &&
is_opfl_refine_allowed(cm, mbmi)) {
const int use_optical_flow = mode >= NEAR_NEARMV_OPTFLOW;
aom_write_symbol(w, use_optical_flow,
xd->tile_ctx->use_optflow_cdf[mode_ctx], 2);
}
int comp_mode_idx = opfl_get_comp_idx(mode);
aom_write_symbol(w, comp_mode_idx,
xd->tile_ctx->inter_compound_mode_cdf[mode_ctx],
INTER_COMPOUND_REF_TYPES);
#else
aom_write_symbol(w, INTER_COMPOUND_OFFSET(mode),
xd->tile_ctx->inter_compound_mode_cdf[mode_ctx],
INTER_COMPOUND_MODES);
#endif // CONFIG_OPTFLOW_REFINEMENT
}
#if CONFIG_NEW_TX_PARTITION
static void write_tx_partition(MACROBLOCKD *xd, const MB_MODE_INFO *mbmi,
TX_SIZE max_tx_size, int blk_row, int blk_col,
aom_writer *w) {
int plane_type = (xd->tree_type == CHROMA_PART);
const int max_blocks_high = max_block_high(xd, mbmi->sb_type[plane_type], 0);
const int max_blocks_wide = max_block_wide(xd, mbmi->sb_type[plane_type], 0);
const int bsize = mbmi->sb_type[plane_type];
const int is_inter = is_inter_block(mbmi, xd->tree_type);
const int txb_size_index =
is_inter ? av1_get_txb_size_index(bsize, blk_row, blk_col) : 0;
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
if (is_inter || (!is_inter && block_signals_txsize(bsize))) {
const TX_PARTITION_TYPE partition = mbmi->tx_partition_type[txb_size_index];
const int is_rect = is_rect_tx(max_tx_size);
const int allow_horz = allow_tx_horz_split(max_tx_size);
const int allow_vert = allow_tx_vert_split(max_tx_size);
if (allow_horz && allow_vert) {
const int split4_ctx =
is_inter ? txfm_partition_split4_inter_context(
xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, bsize, max_tx_size)
: get_tx_size_context(xd);
aom_cdf_prob *split4_cdf =
is_inter ? ec_ctx->inter_4way_txfm_partition_cdf[is_rect][split4_ctx]
: ec_ctx->intra_4way_txfm_partition_cdf[is_rect][split4_ctx];
const TX_PARTITION_TYPE split4_partition =
get_split4_partition(partition);
aom_write_symbol(w, split4_partition, split4_cdf, 4);
} else if (allow_horz || allow_vert) {
const int has_first_split = partition != TX_PARTITION_NONE;
aom_cdf_prob *split2_cdf = is_inter
? ec_ctx->inter_2way_txfm_partition_cdf
: ec_ctx->intra_2way_txfm_partition_cdf;
aom_write_symbol(w, has_first_split, split2_cdf, 2);
} else {
assert(!allow_horz && !allow_vert);
assert(partition == PARTITION_NONE);
}
}
if (is_inter) {
const TX_SIZE tx_size = mbmi->inter_tx_size[txb_size_index];
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, tx_size,
max_tx_size);
}
}
#else
static AOM_INLINE void write_tx_size_vartx(MACROBLOCKD *xd,
const MB_MODE_INFO *mbmi,
TX_SIZE tx_size, int depth,
int blk_row, int blk_col,
aom_writer *w) {
FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
int plane_type = (xd->tree_type == CHROMA_PART);
const int max_blocks_high = max_block_high(xd, mbmi->sb_type[plane_type], 0);
const int max_blocks_wide = max_block_wide(xd, mbmi->sb_type[plane_type], 0);
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
if (depth == MAX_VARTX_DEPTH) {
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, tx_size, tx_size);
return;
}
const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row,
mbmi->sb_type[plane_type], tx_size);
const int txb_size_index =
av1_get_txb_size_index(mbmi->sb_type[plane_type], blk_row, blk_col);
const int write_txfm_partition =
tx_size == mbmi->inter_tx_size[txb_size_index];
if (write_txfm_partition) {
aom_write_symbol(w, 0, ec_ctx->txfm_partition_cdf[ctx], 2);
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, tx_size, tx_size);
// TODO(yuec): set correct txfm partition update for qttx
} else {
const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
const int bsw = tx_size_wide_unit[sub_txs];
const int bsh = tx_size_high_unit[sub_txs];
aom_write_symbol(w, 1, ec_ctx->txfm_partition_cdf[ctx], 2);
if (sub_txs == TX_4X4) {
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, sub_txs, tx_size);
return;
}
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) {
int offsetr = blk_row + row;
int offsetc = blk_col + col;
write_tx_size_vartx(xd, mbmi, sub_txs, depth + 1, offsetr, offsetc, w);
}
}
}
static AOM_INLINE void write_selected_tx_size(const MACROBLOCKD *xd,
aom_writer *w) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
if (block_signals_txsize(bsize)) {
const TX_SIZE tx_size = mbmi->tx_size;
const int tx_size_ctx = get_tx_size_context(xd);
const int depth = tx_size_to_depth(tx_size, bsize);
const int max_depths = bsize_to_max_depth(bsize);
const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize);
assert(depth >= 0 && depth <= max_depths);
assert(!is_inter_block(mbmi, xd->tree_type));
assert(IMPLIES(is_rect_tx(tx_size), is_rect_tx_allowed(xd, mbmi)));
aom_write_symbol(w, depth, ec_ctx->tx_size_cdf[tx_size_cat][tx_size_ctx],
max_depths + 1);
}
}
#endif // CONFIG_NEW_TX_PARTITION
static int write_skip(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int segment_id, const MB_MODE_INFO *mi, aom_writer *w) {
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
return 1;
} else {
const int skip_txfm = mi->skip_txfm[xd->tree_type == CHROMA_PART];
const int ctx = av1_get_skip_txfm_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
aom_write_symbol(w, skip_txfm, ec_ctx->skip_txfm_cdfs[ctx], 2);
return skip_txfm;
}
}
static int write_skip_mode(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int segment_id, const MB_MODE_INFO *mi,
aom_writer *w) {
if (!cm->current_frame.skip_mode_info.skip_mode_flag) return 0;
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
return 0;
}
const int skip_mode = mi->skip_mode;
if (!is_comp_ref_allowed(mi->sb_type[xd->tree_type == CHROMA_PART])) {
assert(!skip_mode);
return 0;
}
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
// These features imply single-reference mode, while skip mode implies
// compound reference. Hence, the two are mutually exclusive.
// In other words, skip_mode is implicitly 0 here.
assert(!skip_mode);
return 0;
}
const int ctx = av1_get_skip_mode_context(xd);
aom_write_symbol(w, skip_mode, xd->tile_ctx->skip_mode_cdfs[ctx], 2);
return skip_mode;
}
static AOM_INLINE void write_is_inter(const AV1_COMMON *cm,
const MACROBLOCKD *xd, int segment_id,
aom_writer *w, const int is_inter
#if CONFIG_CONTEXT_DERIVATION
,
const int skip_txfm
#endif // CONFIG_CONTEXT_DERIVATION
) {
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
assert(is_inter);
return;
}
const int ctx = av1_get_intra_inter_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#if CONFIG_CONTEXT_DERIVATION
aom_write_symbol(w, is_inter, ec_ctx->intra_inter_cdf[skip_txfm][ctx], 2);
#else
aom_write_symbol(w, is_inter, ec_ctx->intra_inter_cdf[ctx], 2);
#endif // CONFIG_CONTEXT_DERIVATION
}
#if CONFIG_WEDGE_MOD_EXT
static void write_wedge_mode(aom_writer *w, FRAME_CONTEXT *ec_ctx,
const BLOCK_SIZE bsize, const int8_t wedge_index) {
const int wedge_angle = wedge_index_2_angle[wedge_index];
const int wedge_dist = wedge_index_2_dist[wedge_index];
const int wedge_angle_dir = (wedge_angle >= H_WEDGE_ANGLES);
aom_write_symbol(w, wedge_angle_dir, ec_ctx->wedge_angle_dir_cdf[bsize], 2);
if (wedge_angle_dir == 0) {
aom_write_symbol(w, wedge_angle, ec_ctx->wedge_angle_0_cdf[bsize],
H_WEDGE_ANGLES);
} else {
assert(wedge_angle >= H_WEDGE_ANGLES);
aom_write_symbol(w, (wedge_angle - H_WEDGE_ANGLES),
ec_ctx->wedge_angle_1_cdf[bsize], H_WEDGE_ANGLES);
}
if ((wedge_angle >= H_WEDGE_ANGLES) ||
(wedge_angle == WEDGE_90 || wedge_angle == WEDGE_180)) {
assert(wedge_dist != 0);
aom_write_symbol(w, wedge_dist - 1, ec_ctx->wedge_dist_cdf2[bsize],
NUM_WEDGE_DIST - 1);
} else {
aom_write_symbol(w, wedge_dist, ec_ctx->wedge_dist_cdf[bsize],
NUM_WEDGE_DIST);
}
}
#endif // CONFIG_WEDGE_MOD_EXT
#if CONFIG_EXTENDED_WARP_PREDICTION
static void write_warp_delta_param(const MACROBLOCKD *xd, int index, int value,
aom_writer *w) {
assert(2 <= index && index <= 5);
int index_type = (index == 2 || index == 5) ? 0 : 1;
int coded_value = (value / WARP_DELTA_STEP) + WARP_DELTA_CODED_MAX;
assert(0 <= coded_value && coded_value < WARP_DELTA_NUM_SYMBOLS);
// Check that the decoder will receive the correct value
assert((coded_value - WARP_DELTA_CODED_MAX) * WARP_DELTA_STEP == value);
aom_write_symbol(w, coded_value,
xd->tile_ctx->warp_delta_param_cdf[index_type],
WARP_DELTA_NUM_SYMBOLS);
}
static void write_warp_delta(const AV1_COMMON *cm, const MACROBLOCKD *xd,
const MB_MODE_INFO *mbmi,
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
aom_writer *w) {
#if CONFIG_WARP_REF_LIST
assert(mbmi->warp_ref_idx < mbmi->max_num_warp_candidates);
#if !CONFIG_WARPMV
write_warp_ref_idx(xd->tile_ctx, mbmi, w);
#endif // !CONFIG_WARPMV
if (!allow_warp_parameter_signaling(mbmi)) {
return;
}
#endif // CONFIG_WARP_REF_LIST
const WarpedMotionParams *params = &mbmi->wm_params[0];
WarpedMotionParams base_params;
av1_get_warp_base_params(cm,
#if !CONFIG_WARP_REF_LIST
xd,
#endif //! CONFIG_WARP_REF_LIST
mbmi,
#if !CONFIG_WARP_REF_LIST
mbmi_ext_frame->ref_mv_stack,
#endif //! CONFIG_WARP_REF_LIST
&base_params, NULL
#if CONFIG_WARP_REF_LIST
,
mbmi_ext_frame->warp_param_stack
#endif // CONFIG_WARP_REF_LIST
);
// The RDO stage should not give us a model which is not warpable.
// Such models can still be signalled, but are effectively useless
// as we'll just fall back to translational motion
assert(!params->invalid);
// TODO(rachelbarker): Allow signaling warp type?
write_warp_delta_param(xd, 2, params->wmmat[2] - base_params.wmmat[2], w);
write_warp_delta_param(xd, 3, params->wmmat[3] - base_params.wmmat[3], w);
}
static AOM_INLINE void write_motion_mode(
const AV1_COMMON *cm, MACROBLOCKD *xd, const MB_MODE_INFO *mbmi,
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame, aom_writer *w) {
const BLOCK_SIZE bsize = mbmi->sb_type[PLANE_TYPE_Y];
const RefCntBuffer *const refbuf = get_ref_frame_buf(cm, mbmi->ref_frame[0]);
const int allowed_motion_modes =
motion_mode_allowed(cm, xd, mbmi_ext_frame->ref_mv_stack, mbmi,
refbuf ? refbuf->base_qindex : -1);
assert((allowed_motion_modes & (1 << mbmi->motion_mode)) != 0);
assert((cm->features.enabled_motion_modes & (1 << mbmi->motion_mode)) != 0);
MOTION_MODE motion_mode = mbmi->motion_mode;
// Note(rachelbarker): Both of the conditions in brackets here are used in
// various places to mean "is this block interintra?". This assertion is a
// quick check to ensure these conditions can't get out of sync.
assert((mbmi->ref_frame[1] == INTRA_FRAME) == (motion_mode == INTERINTRA));
#if CONFIG_WARPMV
if (mbmi->mode == WARPMV) {
assert(mbmi->motion_mode == WARP_DELTA ||
warped_causal_idx_map(mbmi->motion_mode));
// Signal if the motion mode is WARP_CAUSAL or WARP_DELTA
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
aom_write_symbol(w, motion_mode == WARPED_CAUSAL,
xd->tile_ctx->warped_causal_warpmv_cdf[bsize], 2);
if (motion_mode == WARPED_CAUSAL) return;
}
#if CONFIG_INTERINTRA_WARP
if (allowed_motion_modes & (1 << WARPED_CAUSAL_INTERINTRA)) {
aom_write_symbol(w, motion_mode == WARPED_CAUSAL_INTERINTRA,
xd->tile_ctx->warped_causal_interintra_warpmv_cdf[bsize],
2);
}
#endif // CONFIG_INTERINTRA_WARP
return;
}
#endif // CONFIG_WARPMV
if (allowed_motion_modes & (1 << INTERINTRA)) {
const int bsize_group = size_group_lookup[bsize];
aom_write_symbol(w, motion_mode == INTERINTRA,
xd->tile_ctx->interintra_cdf[bsize_group], 2);
if (motion_mode == INTERINTRA) {
aom_write_symbol(w, mbmi->interintra_mode,
xd->tile_ctx->interintra_mode_cdf[bsize_group],
INTERINTRA_MODES);
if (av1_is_wedge_used(bsize)) {
aom_write_symbol(w, mbmi->use_wedge_interintra,
xd->tile_ctx->wedge_interintra_cdf[bsize], 2);
if (mbmi->use_wedge_interintra) {
#if CONFIG_WEDGE_MOD_EXT
write_wedge_mode(w, xd->tile_ctx, bsize,
mbmi->interintra_wedge_index);
#else
aom_write_symbol(w, mbmi->interintra_wedge_index,
xd->tile_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES);
#endif // CONFIG_WEDGE_MOD_EXT
}
}
return;
}
}
if (allowed_motion_modes & (1 << OBMC_CAUSAL)) {
aom_write_symbol(w, motion_mode == OBMC_CAUSAL,
xd->tile_ctx->obmc_cdf[bsize], 2);
if (motion_mode == OBMC_CAUSAL) {
return;
}
}
if (allowed_motion_modes & (1 << WARP_EXTEND)) {
const int ctx1 = av1_get_warp_extend_ctx1(xd, mbmi);
const int ctx2 = av1_get_warp_extend_ctx2(xd, mbmi);
aom_write_symbol(w, motion_mode == WARP_EXTEND,
xd->tile_ctx->warp_extend_cdf[ctx1][ctx2], 2);
if (motion_mode == WARP_EXTEND) {
return;
}
}
if (allowed_motion_modes & WARPED_CAUSAL_MASK) {
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
aom_write_symbol(w, motion_mode == WARPED_CAUSAL,
xd->tile_ctx->warped_causal_cdf[bsize], 2);
if (motion_mode == WARPED_CAUSAL) return;
}
#if CONFIG_INTERINTRA_WARP
if (allowed_motion_modes & (1 << WARPED_CAUSAL_INTERINTRA)) {
aom_write_symbol(w, motion_mode == WARPED_CAUSAL_INTERINTRA,
xd->tile_ctx->warped_causal_interintra_cdf[bsize], 2);
if (motion_mode == WARPED_CAUSAL_INTERINTRA) return;
}
#endif // CONFIG_INTERINTRA_WARP
}
if (allowed_motion_modes & (1 << WARP_DELTA)) {
aom_write_symbol(w, motion_mode == WARP_DELTA,
xd->tile_ctx->warp_delta_cdf[bsize], 2);
#if !CONFIG_WARPMV
if (motion_mode == WARP_DELTA) {
write_warp_delta(cm, xd, mbmi, mbmi_ext_frame, w);
return;
}
#endif // !CONFIG_WARPMV
}
}
#else
static AOM_INLINE void write_motion_mode(const AV1_COMMON *cm, MACROBLOCKD *xd,
const MB_MODE_INFO *mbmi,
aom_writer *w) {
MOTION_MODE last_motion_mode_allowed = motion_mode_allowed(cm, xd, mbmi);
assert(mbmi->motion_mode <= last_motion_mode_allowed);
switch (last_motion_mode_allowed) {
case SIMPLE_TRANSLATION: break;
case OBMC_CAUSAL:
aom_write_symbol(w, mbmi->motion_mode == OBMC_CAUSAL,
xd->tile_ctx->obmc_cdf[mbmi->sb_type[PLANE_TYPE_Y]], 2);
break;
default:
aom_write_symbol(
w, mbmi->motion_mode,
xd->tile_ctx->motion_mode_cdf[mbmi->sb_type[PLANE_TYPE_Y]],
MOTION_MODES);
}
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
static AOM_INLINE void write_delta_qindex(const MACROBLOCKD *xd,
int delta_qindex, aom_writer *w) {
int sign = delta_qindex < 0;
int abs = sign ? -delta_qindex : delta_qindex;
int rem_bits, thr;
int smallval = abs < DELTA_Q_SMALL ? 1 : 0;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
aom_write_symbol(w, AOMMIN(abs, DELTA_Q_SMALL), ec_ctx->delta_q_cdf,
DELTA_Q_PROBS + 1);
if (!smallval) {
rem_bits = get_msb(abs - 1);
thr = (1 << rem_bits) + 1;
aom_write_literal(w, rem_bits - 1, 3);
aom_write_literal(w, abs - thr, rem_bits);
}
if (abs > 0) {
aom_write_bit(w, sign);
}
}
static AOM_INLINE void write_delta_lflevel(const AV1_COMMON *cm,
const MACROBLOCKD *xd, int lf_id,
int delta_lflevel, aom_writer *w) {
int sign = delta_lflevel < 0;
int abs = sign ? -delta_lflevel : delta_lflevel;
int rem_bits, thr;
int smallval = abs < DELTA_LF_SMALL ? 1 : 0;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
if (cm->delta_q_info.delta_lf_multi) {
assert(lf_id >= 0 && lf_id < (av1_num_planes(cm) > 1 ? FRAME_LF_COUNT
: FRAME_LF_COUNT - 2));
aom_write_symbol(w, AOMMIN(abs, DELTA_LF_SMALL),
ec_ctx->delta_lf_multi_cdf[lf_id], DELTA_LF_PROBS + 1);
} else {
aom_write_symbol(w, AOMMIN(abs, DELTA_LF_SMALL), ec_ctx->delta_lf_cdf,
DELTA_LF_PROBS + 1);
}
if (!smallval) {
rem_bits = get_msb(abs - 1);
thr = (1 << rem_bits) + 1;
aom_write_literal(w, rem_bits - 1, 3);
aom_write_literal(w, abs - thr, rem_bits);
}
if (abs > 0) {
aom_write_bit(w, sign);
}
}
#if CONFIG_NEW_COLOR_MAP_CODING
static AOM_INLINE void pack_map_tokens(aom_writer *w, const TokenExtra **tp,
int n, int cols, int rows) {
const TokenExtra *p = *tp;
for (int y = 0; y < rows; y++) {
int identity_row_flag = p->identity_row_flag;
aom_write_symbol(w, identity_row_flag, p->identity_row_cdf, 2);
for (int x = 0; x < cols; x++) {
if (y == 0 && x == 0) {
write_uniform(w, n, p->token);
} else if (!identity_row_flag || x == 0) {
aom_write_symbol(w, p->token, p->color_map_cdf, n);
}
if (!identity_row_flag || x == 0) p++;
}
}
*tp = p;
}
#else
static AOM_INLINE void pack_map_tokens(aom_writer *w, const TokenExtra **tp,
int n, int num) {
const TokenExtra *p = *tp;
write_uniform(w, n, p->token); // The first color index.
++p;
--num;
for (int i = 0; i < num; ++i) {
aom_write_symbol(w, p->token, p->color_map_cdf, n);
++p;
}
*tp = p;
}
#endif // CONFIG_NEW_COLOR_MAP_CODING
static AOM_INLINE void av1_write_coeffs_txb_facade(
aom_writer *w, AV1_COMMON *cm, MACROBLOCK *const x, MACROBLOCKD *xd,
MB_MODE_INFO *mbmi, int plane, int block, int blk_row, int blk_col,
TX_SIZE tx_size) {
// code significance and TXB
const int code_rest =
av1_write_sig_txtype(cm, x, w, blk_row, blk_col, plane, block, tx_size);
const TX_TYPE tx_type =
av1_get_tx_type(xd, get_plane_type(plane), blk_row, blk_col, tx_size,
cm->features.reduced_tx_set_used);
const int is_inter = is_inter_block(mbmi, xd->tree_type);
if (code_rest) {
if ((mbmi->fsc_mode[xd->tree_type == CHROMA_PART] &&
get_primary_tx_type(tx_type) == IDTX && plane == PLANE_TYPE_Y) ||
use_inter_fsc(cm, plane, tx_type, is_inter)) {
av1_write_coeffs_txb_skip(cm, x, w, blk_row, blk_col, plane, block,
tx_size);
} else {
av1_write_coeffs_txb(cm, x, w, blk_row, blk_col, plane, block, tx_size);
}
}
}
static AOM_INLINE void pack_txb_tokens(
aom_writer *w, AV1_COMMON *cm, MACROBLOCK *const x, const TokenExtra **tp,
const TokenExtra *const tok_end, MACROBLOCKD *xd, MB_MODE_INFO *mbmi,
int plane, BLOCK_SIZE plane_bsize, aom_bit_depth_t bit_depth, int block,
int blk_row, int blk_col, TX_SIZE tx_size, TOKEN_STATS *token_stats) {
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;
const struct macroblockd_plane *const pd = &xd->plane[plane];
#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[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
#else
const TX_SIZE plane_tx_size =
plane ? av1_get_max_uv_txsize(mbmi->sb_type[plane > 0], 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
if (tx_size == plane_tx_size || plane) {
av1_write_coeffs_txb_facade(w, cm, x, xd, mbmi, plane, block, blk_row,
blk_col, tx_size);
#if CONFIG_RD_DEBUG
TOKEN_STATS tmp_token_stats;
init_token_stats(&tmp_token_stats);
token_stats->txb_coeff_cost_map[blk_row][blk_col] = tmp_token_stats.cost;
token_stats->cost += tmp_token_stats.cost;
#endif
} else {
#if CONFIG_NEW_TX_PARTITION
(void)tp;
(void)tok_end;
(void)token_stats;
(void)bit_depth;
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;
av1_write_coeffs_txb_facade(w, cm, x, xd, mbmi, plane, block, offsetr,
offsetc, sub_tx);
#if CONFIG_RD_DEBUG
TOKEN_STATS tmp_token_stats;
init_token_stats(&tmp_token_stats);
token_stats->txb_coeff_cost_map[offsetr][offsetc] =
tmp_token_stats.cost;
token_stats->cost += tmp_token_stats.cost;
#endif
block += sub_step;
cur_partition++;
}
}
#else
const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
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 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 int offsetr = blk_row + r;
const int offsetc = blk_col + c;
if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
pack_txb_tokens(w, cm, x, tp, tok_end, xd, mbmi, plane, plane_bsize,
bit_depth, block, offsetr, offsetc, sub_txs,
token_stats);
block += step;
}
}
#endif // CONFIG_NEW_TX_PARTITION
}
}
static INLINE void set_spatial_segment_id(
const CommonModeInfoParams *const mi_params, uint8_t *segment_ids,
BLOCK_SIZE bsize, int mi_row, int mi_col, int segment_id) {
const int mi_offset = mi_row * mi_params->mi_cols + mi_col;
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
const int xmis = AOMMIN(mi_params->mi_cols - mi_col, bw);
const int ymis = AOMMIN(mi_params->mi_rows - mi_row, bh);
for (int y = 0; y < ymis; ++y) {
for (int x = 0; x < xmis; ++x) {
segment_ids[mi_offset + y * mi_params->mi_cols + x] = segment_id;
}
}
}
int av1_neg_interleave(int x, int ref, int max) {
assert(x < max);
const int diff = x - ref;
if (!ref) return x;
if (ref >= (max - 1)) return -x + max - 1;
if (2 * ref < max) {
if (abs(diff) <= ref) {
if (diff > 0)
return (diff << 1) - 1;
else
return ((-diff) << 1);
}
return x;
} else {
if (abs(diff) < (max - ref)) {
if (diff > 0)
return (diff << 1) - 1;
else
return ((-diff) << 1);
}
return (max - x) - 1;
}
}
static AOM_INLINE void write_segment_id(AV1_COMP *cpi,
const MB_MODE_INFO *const mbmi,
aom_writer *w,
const struct segmentation *seg,
struct segmentation_probs *segp,
int skip_txfm) {
if (!seg->enabled || !seg->update_map) return;
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
int cdf_num;
const int pred = av1_get_spatial_seg_pred(cm, xd, &cdf_num);
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
if (skip_txfm) {
// Still need to transmit tx size for intra blocks even if skip_txfm is
// true. Changing segment_id may make the tx size become invalid, e.g
// changing from lossless to lossy.
assert(is_inter_block(mbmi, xd->tree_type) ||
!cpi->enc_seg.has_lossless_segment);
set_spatial_segment_id(&cm->mi_params, cm->cur_frame->seg_map,
mbmi->sb_type[xd->tree_type == CHROMA_PART], mi_row,
mi_col, pred);
set_spatial_segment_id(&cm->mi_params, cpi->enc_seg.map,
mbmi->sb_type[xd->tree_type == CHROMA_PART], mi_row,
mi_col, pred);
/* mbmi is read only but we need to update segment_id */
((MB_MODE_INFO *)mbmi)->segment_id = pred;
return;
}
const int coded_id =
av1_neg_interleave(mbmi->segment_id, pred, seg->last_active_segid + 1);
aom_cdf_prob *pred_cdf = segp->spatial_pred_seg_cdf[cdf_num];
aom_write_symbol(w, coded_id, pred_cdf, MAX_SEGMENTS);
set_spatial_segment_id(&cm->mi_params, cm->cur_frame->seg_map,
mbmi->sb_type[xd->tree_type == CHROMA_PART], mi_row,
mi_col, mbmi->segment_id);
}
static AOM_INLINE void write_single_ref(
const MACROBLOCKD *xd, const RefFramesInfo *const ref_frames_info,
aom_writer *w) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
MV_REFERENCE_FRAME ref = mbmi->ref_frame[0];
const int n_refs = ref_frames_info->num_total_refs;
assert(ref < n_refs);
for (int i = 0; i < n_refs - 1; i++) {
const int bit = ref == i;
aom_write_symbol(w, bit, av1_get_pred_cdf_single_ref(xd, i, n_refs), 2);
if (bit) return;
}
assert(ref == (n_refs - 1));
}
static AOM_INLINE void write_compound_ref(
const MACROBLOCKD *xd, const RefFramesInfo *const ref_frames_info,
aom_writer *w) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
MV_REFERENCE_FRAME ref0 = mbmi->ref_frame[0];
MV_REFERENCE_FRAME ref1 = mbmi->ref_frame[1];
const int n_refs = ref_frames_info->num_total_refs;
#if CONFIG_ALLOW_SAME_REF_COMPOUND
assert(n_refs >= 1);
assert(ref0 <= ref1);
#else
assert(n_refs >= 2);
assert(ref0 < ref1);
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
int n_bits = 0;
#if CONFIG_ALLOW_SAME_REF_COMPOUND
for (int i = 0; i < n_refs - 1 && n_bits < 2; i++) {
const int bit =
((n_bits == 0) && (ref0 == i)) || ((n_bits == 1) && (ref1 == i));
#else
for (int i = 0; i < n_refs + n_bits - 2 && n_bits < 2; i++) {
const int bit = ref0 == i || ref1 == i;
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
// bit_type: -1 for ref0, 0 for opposite sided ref1, 1 for same sided ref1
const int bit_type =
n_bits == 0 ? -1
: av1_get_compound_ref_bit_type(ref_frames_info, ref0, i);
// Implicitly signal a 1 when ref0 = RANK_REF0_TO_PRUNE - 1
if (n_bits > 0 || i < RANKED_REF0_TO_PRUNE - 1) {
aom_write_symbol(
w, bit,
av1_get_pred_cdf_compound_ref(xd, i, n_bits, bit_type, n_refs), 2);
}
n_bits += bit;
#if CONFIG_ALLOW_SAME_REF_COMPOUND
if (i < ref_frames_info->num_same_ref_compound) i -= bit;
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
}
#if !CONFIG_ALLOW_SAME_REF_COMPOUND
assert(IMPLIES(n_bits < 2, AOMMAX(ref0, ref1) == n_refs - 1));
assert(IMPLIES(n_bits < 1, AOMMIN(ref0, ref1) == n_refs - 2));
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
}
// This function encodes the reference frame
static AOM_INLINE void write_ref_frames(const AV1_COMMON *cm,
const MACROBLOCKD *xd, aom_writer *w) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
const int is_compound = has_second_ref(mbmi);
const int segment_id = mbmi->segment_id;
// If segment level coding of this signal is disabled...
// or the segment allows multiple reference frame options
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP) ||
segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) {
assert(mbmi->ref_frame[0] == get_closest_pastcur_ref_index(cm));
assert(!is_compound);
} else {
// does the feature use compound prediction or not
// (if not specified at the frame/segment level)
if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) {
if (is_comp_ref_allowed(mbmi->sb_type[PLANE_TYPE_Y]))
aom_write_symbol(w, is_compound, av1_get_reference_mode_cdf(cm, xd), 2);
} else {
assert((!is_compound) ==
(cm->current_frame.reference_mode == SINGLE_REFERENCE));
}
if (is_compound) {
write_compound_ref(xd, &cm->ref_frames_info, w);
} else {
write_single_ref(xd, &cm->ref_frames_info, w);
}
}
}
static AOM_INLINE void write_filter_intra_mode_info(
const AV1_COMMON *cm, const MACROBLOCKD *xd, const MB_MODE_INFO *const mbmi,
aom_writer *w) {
if (av1_filter_intra_allowed(cm, mbmi) && xd->tree_type != CHROMA_PART) {
aom_write_symbol(
w, mbmi->filter_intra_mode_info.use_filter_intra,
xd->tile_ctx->filter_intra_cdfs[mbmi->sb_type[PLANE_TYPE_Y]], 2);
if (mbmi->filter_intra_mode_info.use_filter_intra) {
const FILTER_INTRA_MODE mode =
mbmi->filter_intra_mode_info.filter_intra_mode;
aom_write_symbol(w, mode, xd->tile_ctx->filter_intra_mode_cdf,
FILTER_INTRA_MODES);
}
}
}
#if !CONFIG_AIMC
static AOM_INLINE void write_angle_delta(aom_writer *w, int angle_delta,
aom_cdf_prob *cdf) {
aom_write_symbol(w, angle_delta + MAX_ANGLE_DELTA, cdf,
2 * MAX_ANGLE_DELTA + 1);
}
#endif // !CONFIG_AIMC
static AOM_INLINE void write_mb_interp_filter(AV1_COMMON *const cm,
const MACROBLOCKD *xd,
aom_writer *w) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
if (!av1_is_interp_needed(cm, xd)) {
#if CONFIG_DEBUG
#if CONFIG_OPTFLOW_REFINEMENT
// Sharp filter is always used whenever optical flow refinement is applied.
int mb_interp_filter =
(mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi))
? MULTITAP_SHARP
: cm->features.interp_filter;
#else
int mb_interp_filter = cm->features.interp_filter;
#endif // CONFIG_OPTFLOW_REFINEMENT
assert(mbmi->interp_fltr == av1_unswitchable_filter(mb_interp_filter));
(void)mb_interp_filter;
#endif // CONFIG_DEBUG
return;
}
if (cm->features.interp_filter == SWITCHABLE) {
#if CONFIG_OPTFLOW_REFINEMENT
if (mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi)) {
assert(IMPLIES(
mbmi->mode >= NEAR_NEARMV_OPTFLOW || use_opfl_refine_all(cm, mbmi),
mbmi->interp_fltr == MULTITAP_SHARP));
return;
}
#endif // CONFIG_OPTFLOW_REFINEMENT
const int ctx = av1_get_pred_context_switchable_interp(xd, 0);
const InterpFilter filter = mbmi->interp_fltr;
aom_write_symbol(w, filter, ec_ctx->switchable_interp_cdf[ctx],
SWITCHABLE_FILTERS);
++cm->cur_frame->interp_filter_selected[filter];
}
}
// Transmit color values with delta encoding. Write the first value as
// literal, and the deltas between each value and the previous one. "min_val" is
// the smallest possible value of the deltas.
static AOM_INLINE void delta_encode_palette_colors(const int *colors, int num,
int bit_depth, int min_val,
aom_writer *w) {
if (num <= 0) return;
assert(colors[0] < (1 << bit_depth));
aom_write_literal(w, colors[0], bit_depth);
if (num == 1) return;
int max_delta = 0;
int deltas[PALETTE_MAX_SIZE];
memset(deltas, 0, sizeof(deltas));
for (int i = 1; i < num; ++i) {
assert(colors[i] < (1 << bit_depth));
const int delta = colors[i] - colors[i - 1];
deltas[i - 1] = delta;
assert(delta >= min_val);
if (delta > max_delta) max_delta = delta;
}
const int min_bits = bit_depth - 3;
int bits = AOMMAX(av1_ceil_log2(max_delta + 1 - min_val), min_bits);
assert(bits <= bit_depth);
int range = (1 << bit_depth) - colors[0] - min_val;
aom_write_literal(w, bits - min_bits, 2);
for (int i = 0; i < num - 1; ++i) {
aom_write_literal(w, deltas[i] - min_val, bits);
range -= deltas[i];
bits = AOMMIN(bits, av1_ceil_log2(range));
}
}
// Transmit luma palette color values. First signal if each color in the color
// cache is used. Those colors that are not in the cache are transmitted with
// delta encoding.
static AOM_INLINE void write_palette_colors_y(
const MACROBLOCKD *const xd, const PALETTE_MODE_INFO *const pmi,
int bit_depth, aom_writer *w) {
const int n = pmi->palette_size[0];
uint16_t color_cache[2 * PALETTE_MAX_SIZE];
const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
int out_cache_colors[PALETTE_MAX_SIZE];
uint8_t cache_color_found[2 * PALETTE_MAX_SIZE];
const int n_out_cache =
av1_index_color_cache(color_cache, n_cache, pmi->palette_colors, n,
cache_color_found, out_cache_colors);
int n_in_cache = 0;
for (int i = 0; i < n_cache && n_in_cache < n; ++i) {
const int found = cache_color_found[i];
aom_write_bit(w, found);
n_in_cache += found;
}
assert(n_in_cache + n_out_cache == n);
delta_encode_palette_colors(out_cache_colors, n_out_cache, bit_depth, 1, w);
}
// Write chroma palette color values. U channel is handled similarly to the luma
// channel. For v channel, either use delta encoding or transmit raw values
// directly, whichever costs less.
static AOM_INLINE void write_palette_colors_uv(
const MACROBLOCKD *const xd, const PALETTE_MODE_INFO *const pmi,
int bit_depth, aom_writer *w) {
const int n = pmi->palette_size[1];
const uint16_t *colors_u = pmi->palette_colors + PALETTE_MAX_SIZE;
const uint16_t *colors_v = pmi->palette_colors + 2 * PALETTE_MAX_SIZE;
// U channel colors.
uint16_t color_cache[2 * PALETTE_MAX_SIZE];
const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
int out_cache_colors[PALETTE_MAX_SIZE];
uint8_t cache_color_found[2 * PALETTE_MAX_SIZE];
const int n_out_cache = av1_index_color_cache(
color_cache, n_cache, colors_u, n, cache_color_found, out_cache_colors);
int n_in_cache = 0;
for (int i = 0; i < n_cache && n_in_cache < n; ++i) {
const int found = cache_color_found[i];
aom_write_bit(w, found);
n_in_cache += found;
}
delta_encode_palette_colors(out_cache_colors, n_out_cache, bit_depth, 0, w);
// V channel colors. Don't use color cache as the colors are not sorted.
const int max_val = 1 << bit_depth;
int zero_count = 0, min_bits_v = 0;
int bits_v =
av1_get_palette_delta_bits_v(pmi, bit_depth, &zero_count, &min_bits_v);
const int rate_using_delta =
2 + bit_depth + (bits_v + 1) * (n - 1) - zero_count;
const int rate_using_raw = bit_depth * n;
if (rate_using_delta < rate_using_raw) { // delta encoding
assert(colors_v[0] < (1 << bit_depth));
aom_write_bit(w, 1);
aom_write_literal(w, bits_v - min_bits_v, 2);
aom_write_literal(w, colors_v[0], bit_depth);
for (int i = 1; i < n; ++i) {
assert(colors_v[i] < (1 << bit_depth));
if (colors_v[i] == colors_v[i - 1]) { // No need to signal sign bit.
aom_write_literal(w, 0, bits_v);
continue;
}
const int delta = abs((int)colors_v[i] - colors_v[i - 1]);
const int sign_bit = colors_v[i] < colors_v[i - 1];
if (delta <= max_val - delta) {
aom_write_literal(w, delta, bits_v);
aom_write_bit(w, sign_bit);
} else {
aom_write_literal(w, max_val - delta, bits_v);
aom_write_bit(w, !sign_bit);
}
}
} else { // Transmit raw values.
aom_write_bit(w, 0);
for (int i = 0; i < n; ++i) {
assert(colors_v[i] < (1 << bit_depth));
aom_write_literal(w, colors_v[i], bit_depth);
}
}
}
static AOM_INLINE void write_palette_mode_info(const AV1_COMMON *cm,
const MACROBLOCKD *xd,
const MB_MODE_INFO *const mbmi,
aom_writer *w) {
const int num_planes = av1_num_planes(cm);
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
assert(av1_allow_palette(cm->features.allow_screen_content_tools, bsize));
const PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
const int bsize_ctx = av1_get_palette_bsize_ctx(bsize);
if (mbmi->mode == DC_PRED && xd->tree_type != CHROMA_PART) {
const int n = pmi->palette_size[0];
const int palette_y_mode_ctx = av1_get_palette_mode_ctx(xd);
aom_write_symbol(
w, n > 0,
xd->tile_ctx->palette_y_mode_cdf[bsize_ctx][palette_y_mode_ctx], 2);
if (n > 0) {
aom_write_symbol(w, n - PALETTE_MIN_SIZE,
xd->tile_ctx->palette_y_size_cdf[bsize_ctx],
PALETTE_SIZES);
write_palette_colors_y(xd, pmi, cm->seq_params.bit_depth, w);
}
}
const int uv_dc_pred = num_planes > 1 && xd->tree_type != LUMA_PART &&
mbmi->uv_mode == UV_DC_PRED && xd->is_chroma_ref;
if (uv_dc_pred) {
const int n = pmi->palette_size[1];
const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0);
aom_write_symbol(w, n > 0,
xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2);
if (n > 0) {
aom_write_symbol(w, n - PALETTE_MIN_SIZE,
xd->tile_ctx->palette_uv_size_cdf[bsize_ctx],
PALETTE_SIZES);
write_palette_colors_uv(xd, pmi, cm->seq_params.bit_depth, w);
}
}
}
void av1_write_tx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
TX_TYPE tx_type, TX_SIZE tx_size, aom_writer *w) {
MB_MODE_INFO *mbmi = xd->mi[0];
#if CONFIG_ATC_NEWTXSETS
PREDICTION_MODE intra_dir;
if (mbmi->filter_intra_mode_info.use_filter_intra)
intra_dir =
fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode];
else
intra_dir = mbmi->mode;
#endif // CONFIG_ATC_NEWTXSETS
const FeatureFlags *const features = &cm->features;
const int is_inter = is_inter_block(mbmi, xd->tree_type);
if (get_ext_tx_types(tx_size, is_inter, features->reduced_tx_set_used) > 1 &&
((!cm->seg.enabled && cm->quant_params.base_qindex > 0) ||
(cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
!mbmi->skip_txfm[xd->tree_type == CHROMA_PART] &&
!segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
const TxSetType tx_set_type = av1_get_ext_tx_set_type(
tx_size, is_inter, features->reduced_tx_set_used);
const int eset =
get_ext_tx_set(tx_size, is_inter, features->reduced_tx_set_used);
// eset == 0 should correspond to a set with only DCT_DCT and there
// is no need to send the tx_type
assert(eset > 0);
#if CONFIG_ATC_NEWTXSETS
const int size_info = av1_size_class[tx_size];
if (!is_inter) {
const int mode_info = av1_md_class[intra_dir];
(void)mode_info;
assert(tx_set_type == EXT_NEW_TX_SET
? av1_mdtx_used_flag[av1_size_class[tx_size]][mode_info]
[get_primary_tx_type(tx_type)]
: av1_ext_tx_used[tx_set_type][get_primary_tx_type(tx_type)]);
}
#else
assert(av1_ext_tx_used[tx_set_type][get_primary_tx_type(tx_type)]);
#endif // CONFIG_ATC_NEWTXSETS
if (is_inter) {
aom_write_symbol(w, av1_ext_tx_ind[tx_set_type][tx_type],
ec_ctx->inter_ext_tx_cdf[eset][square_tx_size],
av1_num_ext_tx_set[tx_set_type]);
} else {
if (mbmi->fsc_mode[xd->tree_type == CHROMA_PART]) {
return;
}
#if !CONFIG_ATC_NEWTXSETS
PREDICTION_MODE intra_dir;
if (mbmi->filter_intra_mode_info.use_filter_intra)
intra_dir =
fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode];
else
intra_dir = mbmi->mode;
#endif // !CONFIG_ATC_NEWTXSETS
aom_write_symbol(
#if CONFIG_ATC_NEWTXSETS
w,
av1_tx_type_to_idx(get_primary_tx_type(tx_type), tx_set_type,
intra_dir, size_info),
#if CONFIG_ATC_REDUCED_TXSET
ec_ctx->intra_ext_tx_cdf[eset + features->reduced_tx_set_used]
[square_tx_size][intra_dir],
features->reduced_tx_set_used
? av1_num_reduced_tx_set
: av1_num_ext_tx_set_intra[tx_set_type]);
#else
ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_dir],
av1_num_ext_tx_set_intra[tx_set_type]);
#endif // CONFIG_ATC_REDUCED_TXSET
#else
w, av1_ext_tx_ind_intra[tx_set_type][get_primary_tx_type(tx_type)],
ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_dir],
av1_num_ext_tx_set_intra[tx_set_type]);
#endif // CONFIG_ATC_NEWTXSETS
}
}
}
#if CONFIG_CROSS_CHROMA_TX
void av1_write_cctx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
CctxType cctx_type, TX_SIZE tx_size, aom_writer *w) {
MB_MODE_INFO *mbmi = xd->mi[0];
assert(xd->is_chroma_ref);
if (((!cm->seg.enabled && cm->quant_params.base_qindex > 0) ||
(cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
!mbmi->skip_txfm[xd->tree_type == CHROMA_PART] &&
!segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
int above_cctx, left_cctx;
#if CONFIG_EXT_RECUR_PARTITIONS
get_above_and_left_cctx_type(cm, xd, &above_cctx, &left_cctx);
#else
get_above_and_left_cctx_type(cm, xd, tx_size, &above_cctx, &left_cctx);
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int cctx_ctx = get_cctx_context(xd, &above_cctx, &left_cctx);
aom_write_symbol(w, cctx_type,
ec_ctx->cctx_type_cdf[square_tx_size][cctx_ctx],
CCTX_TYPES);
}
}
#endif // CONFIG_CROSS_CHROMA_TX
void av1_write_sec_tx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
TX_TYPE tx_type, TX_SIZE tx_size, uint16_t eob,
aom_writer *w) {
MB_MODE_INFO *mbmi = xd->mi[0];
const FeatureFlags *const features = &cm->features;
const int is_inter = is_inter_block(mbmi, xd->tree_type);
if (get_ext_tx_types(tx_size, is_inter, features->reduced_tx_set_used) > 1 &&
((!cm->seg.enabled && cm->quant_params.base_qindex > 0) ||
(cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) &&
!mbmi->skip_txfm[xd->tree_type == CHROMA_PART] &&
!segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
if (!is_inter) {
TX_TYPE stx_flag = get_secondary_tx_type(tx_type);
assert(stx_flag <= STX_TYPES - 1);
if (block_signals_sec_tx_type(xd, tx_size, tx_type, eob)) {
aom_write_symbol(w, stx_flag, ec_ctx->stx_cdf[square_tx_size],
STX_TYPES);
}
}
} else if (!is_inter && !xd->lossless[mbmi->segment_id]) {
TX_TYPE stx_flag = get_secondary_tx_type(tx_type);
assert(stx_flag <= STX_TYPES - 1);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
if (block_signals_sec_tx_type(xd, tx_size, tx_type, eob)) {
aom_write_symbol(w, stx_flag, ec_ctx->stx_cdf[square_tx_size], STX_TYPES);
}
}
}
#if !CONFIG_AIMC
static AOM_INLINE void write_intra_y_mode_nonkf(FRAME_CONTEXT *frame_ctx,
BLOCK_SIZE bsize,
PREDICTION_MODE mode,
aom_writer *w) {
aom_write_symbol(w, mode, frame_ctx->y_mode_cdf[size_group_lookup[bsize]],
INTRA_MODES);
}
#endif // !CONFIG_AIMC
static AOM_INLINE void write_mrl_index(FRAME_CONTEXT *ec_ctx, uint8_t mrl_index,
aom_writer *w) {
aom_write_symbol(w, mrl_index, ec_ctx->mrl_index_cdf, MRL_LINE_NUMBER);
}
static AOM_INLINE void write_fsc_mode(uint8_t fsc_mode, aom_writer *w,
aom_cdf_prob *fsc_cdf) {
aom_write_symbol(w, fsc_mode, fsc_cdf, FSC_MODES);
}
#if CONFIG_IMPROVED_CFL
static AOM_INLINE void write_cfl_index(FRAME_CONTEXT *ec_ctx, uint8_t cfl_index,
aom_writer *w) {
aom_write_symbol(w, cfl_index > 0, ec_ctx->cfl_index_cdf, CFL_TYPE_COUNT);
}
#endif
#if !CONFIG_AIMC
static AOM_INLINE void write_intra_uv_mode(FRAME_CONTEXT *frame_ctx,
UV_PREDICTION_MODE uv_mode,
PREDICTION_MODE y_mode,
CFL_ALLOWED_TYPE cfl_allowed,
aom_writer *w) {
aom_write_symbol(w, uv_mode, frame_ctx->uv_mode_cdf[cfl_allowed][y_mode],
UV_INTRA_MODES - !cfl_allowed);
}
#endif // !CONFIG_AIMC
static AOM_INLINE void write_cfl_alphas(FRAME_CONTEXT *const ec_ctx,
uint8_t idx, int8_t joint_sign,
aom_writer *w) {
aom_write_symbol(w, joint_sign, ec_ctx->cfl_sign_cdf, CFL_JOINT_SIGNS);
// Magnitudes are only signaled for nonzero codes.
if (CFL_SIGN_U(joint_sign) != CFL_SIGN_ZERO) {
aom_cdf_prob *cdf_u = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_U(joint_sign)];
aom_write_symbol(w, CFL_IDX_U(idx), cdf_u, CFL_ALPHABET_SIZE);
}
if (CFL_SIGN_V(joint_sign) != CFL_SIGN_ZERO) {
aom_cdf_prob *cdf_v = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_V(joint_sign)];
aom_write_symbol(w, CFL_IDX_V(idx), cdf_v, CFL_ALPHABET_SIZE);
}
}
static AOM_INLINE void write_cdef(AV1_COMMON *cm, MACROBLOCKD *const xd,
aom_writer *w, int skip) {
if (cm->features.coded_lossless || is_global_intrabc_allowed(cm)) return;
#if CONFIG_FIX_CDEF_SYNTAX
if (!cm->cdef_info.cdef_frame_enable) return;
#endif // CONFIG_FIX_CDEF_SYNTAX
// At the start of a superblock, mark that we haven't yet written CDEF
// strengths for any of the CDEF units contained in this superblock.
const int sb_mask = (cm->seq_params.mib_size - 1);
const int mi_row_in_sb = (xd->mi_row & sb_mask);
const int mi_col_in_sb = (xd->mi_col & sb_mask);
if (mi_row_in_sb == 0 && mi_col_in_sb == 0) {
av1_zero(xd->cdef_transmitted);
}
// CDEF unit size is 64x64 irrespective of the superblock size.
const int cdef_size = 1 << (6 - MI_SIZE_LOG2);
// Find index of this CDEF unit in this superblock.
const int index = av1_get_cdef_transmitted_index(xd->mi_row, xd->mi_col);
// Write CDEF strength to the first non-skip coding block in this CDEF unit.
if (!xd->cdef_transmitted[index] && !skip) {
// CDEF strength for this CDEF unit needs to be stored in the MB_MODE_INFO
// of the 1st block in this CDEF unit.
const int first_block_mask = ~(cdef_size - 1);
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const int grid_idx =
get_mi_grid_idx(mi_params, xd->mi_row & first_block_mask,
xd->mi_col & first_block_mask);
const MB_MODE_INFO *const mbmi = mi_params->mi_grid_base[grid_idx];
aom_write_literal(w, mbmi->cdef_strength, cm->cdef_info.cdef_bits);
xd->cdef_transmitted[index] = true;
}
}
#if CONFIG_CCSO
static AOM_INLINE void write_ccso(AV1_COMMON *cm, MACROBLOCKD *const xd,
aom_writer *w) {
if (cm->features.coded_lossless) return;
if (is_global_intrabc_allowed(cm)) return;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
const int blk_size_y =
(1 << (CCSO_BLK_SIZE + xd->plane[1].subsampling_y - MI_SIZE_LOG2)) - 1;
const int blk_size_x =
(1 << (CCSO_BLK_SIZE + xd->plane[1].subsampling_x - MI_SIZE_LOG2)) - 1;
const MB_MODE_INFO *mbmi =
mi_params->mi_grid_base[(mi_row & ~blk_size_y) * mi_params->mi_stride +
(mi_col & ~blk_size_x)];
#if CONFIG_CCSO_EXT
if (!(mi_row & blk_size_y) && !(mi_col & blk_size_x) &&
cm->ccso_info.ccso_enable[0]) {
aom_write_symbol(w, mbmi->ccso_blk_y == 0 ? 0 : 1,
xd->tile_ctx->ccso_cdf[0], 2);
xd->ccso_blk_y = mbmi->ccso_blk_y;
}
#endif
if (!(mi_row & blk_size_y) && !(mi_col & blk_size_x) &&
#if CONFIG_CCSO_EXT
cm->ccso_info.ccso_enable[1]) {
aom_write_symbol(w, mbmi->ccso_blk_u == 0 ? 0 : 1,
xd->tile_ctx->ccso_cdf[1], 2);
#else
cm->ccso_info.ccso_enable[0]) {
aom_write_bit(w, mbmi->ccso_blk_u == 0 ? 0 : 1);
#endif
xd->ccso_blk_u = mbmi->ccso_blk_u;
}
if (!(mi_row & blk_size_y) && !(mi_col & blk_size_x) &&
#if CONFIG_CCSO_EXT
cm->ccso_info.ccso_enable[2]) {
aom_write_symbol(w, mbmi->ccso_blk_v == 0 ? 0 : 1,
xd->tile_ctx->ccso_cdf[2], 2);
#else
cm->ccso_info.ccso_enable[1]) {
aom_write_bit(w, mbmi->ccso_blk_v == 0 ? 0 : 1);
#endif
xd->ccso_blk_v = mbmi->ccso_blk_v;
}
}
#endif
static AOM_INLINE void write_inter_segment_id(
AV1_COMP *cpi, aom_writer *w, const struct segmentation *const seg,
struct segmentation_probs *const segp, int skip, int preskip) {
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
AV1_COMMON *const cm = &cpi->common;
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
if (seg->update_map) {
if (preskip) {
if (!seg->segid_preskip) return;
} else {
if (seg->segid_preskip) return;
if (skip) {
write_segment_id(cpi, mbmi, w, seg, segp, 1);
if (seg->temporal_update) mbmi->seg_id_predicted = 0;
return;
}
}
if (seg->temporal_update) {
const int pred_flag = mbmi->seg_id_predicted;
aom_cdf_prob *pred_cdf = av1_get_pred_cdf_seg_id(segp, xd);
aom_write_symbol(w, pred_flag, pred_cdf, 2);
if (!pred_flag) {
write_segment_id(cpi, mbmi, w, seg, segp, 0);
}
if (pred_flag) {
set_spatial_segment_id(&cm->mi_params, cm->cur_frame->seg_map,
mbmi->sb_type[PLANE_TYPE_Y], mi_row, mi_col,
mbmi->segment_id);
}
} else {
write_segment_id(cpi, mbmi, w, seg, segp, 0);
}
}
}
// If delta q is present, writes delta_q index.
// Also writes delta_q loop filter levels, if present.
static AOM_INLINE void write_delta_q_params(AV1_COMP *cpi, int skip,
aom_writer *w) {
AV1_COMMON *const cm = &cpi->common;
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
if (delta_q_info->delta_q_present_flag) {
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
const MB_MODE_INFO *const mbmi = xd->mi[0];
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
const int super_block_upper_left =
((xd->mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
((xd->mi_col & (cm->seq_params.mib_size - 1)) == 0);
if ((bsize != cm->seq_params.sb_size || skip == 0) &&
super_block_upper_left) {
assert(mbmi->current_qindex > 0);
const int reduced_delta_qindex =
(mbmi->current_qindex - xd->current_base_qindex) /
delta_q_info->delta_q_res;
write_delta_qindex(xd, reduced_delta_qindex, w);
xd->current_base_qindex = mbmi->current_qindex;
if (delta_q_info->delta_lf_present_flag) {
if (delta_q_info->delta_lf_multi) {
const int frame_lf_count =
av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) {
int reduced_delta_lflevel =
(mbmi->delta_lf[lf_id] - xd->delta_lf[lf_id]) /
delta_q_info->delta_lf_res;
write_delta_lflevel(cm, xd, lf_id, reduced_delta_lflevel, w);
xd->delta_lf[lf_id] = mbmi->delta_lf[lf_id];
}
} else {
int reduced_delta_lflevel =
(mbmi->delta_lf_from_base - xd->delta_lf_from_base) /
delta_q_info->delta_lf_res;
write_delta_lflevel(cm, xd, -1, reduced_delta_lflevel, w);
xd->delta_lf_from_base = mbmi->delta_lf_from_base;
}
}
}
}
}
#if CONFIG_AIMC
// write mode set index and mode index in set for y component
static AOM_INLINE void write_intra_luma_mode(MACROBLOCKD *const xd,
aom_writer *w) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
MB_MODE_INFO *const mbmi = xd->mi[0];
const int mode_idx = mbmi->y_mode_idx;
assert(mode_idx >= 0 && mode_idx < LUMA_MODE_COUNT);
assert(mbmi->joint_y_mode_delta_angle >= 0 &&
mbmi->joint_y_mode_delta_angle < LUMA_MODE_COUNT);
if (mbmi->joint_y_mode_delta_angle < NON_DIRECTIONAL_MODES_COUNT)
assert(mbmi->joint_y_mode_delta_angle == mbmi->y_mode_idx);
const int context = get_y_mode_idx_ctx(xd);
int mode_set_index = mode_idx < FIRST_MODE_COUNT ? 0 : 1;
mode_set_index += ((mode_idx - FIRST_MODE_COUNT) / SECOND_MODE_COUNT);
aom_write_symbol(w, mode_set_index, ec_ctx->y_mode_set_cdf, INTRA_MODE_SETS);
if (mode_set_index == 0) {
aom_write_symbol(w, mode_idx, ec_ctx->y_mode_idx_cdf_0[context],
FIRST_MODE_COUNT);
} else {
aom_write_symbol(
w,
mode_idx - FIRST_MODE_COUNT - (mode_set_index - 1) * SECOND_MODE_COUNT,
ec_ctx->y_mode_idx_cdf_1[context], SECOND_MODE_COUNT);
}
if (mbmi->joint_y_mode_delta_angle < NON_DIRECTIONAL_MODES_COUNT)
assert(mbmi->joint_y_mode_delta_angle == mbmi->y_mode_idx);
}
// write mode mode index for uv component
static AOM_INLINE void write_intra_uv_mode(MACROBLOCKD *const xd,
CFL_ALLOWED_TYPE cfl_allowed,
aom_writer *w) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
MB_MODE_INFO *const mbmi = xd->mi[0];
const int uv_mode_idx = mbmi->uv_mode_idx;
assert(uv_mode_idx >= 0 && uv_mode_idx < UV_INTRA_MODES);
const int context = av1_is_directional_mode(mbmi->mode) ? 1 : 0;
aom_write_symbol(w, uv_mode_idx, ec_ctx->uv_mode_cdf[cfl_allowed][context],
UV_INTRA_MODES - !cfl_allowed);
}
#endif // CONFIG_AIMC
static AOM_INLINE void write_intra_prediction_modes(AV1_COMP *cpi,
int is_keyframe,
aom_writer *w) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const MB_MODE_INFO *const mbmi = xd->mi[0];
const PREDICTION_MODE mode = mbmi->mode;
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
#if !CONFIG_AIMC
const int use_angle_delta = av1_use_angle_delta(bsize);
#endif // !CONFIG_AIMC
// Y mode.
if (xd->tree_type != CHROMA_PART) {
#if CONFIG_AIMC
write_intra_luma_mode(xd, w);
if (allow_fsc_intra(cm, xd, bsize, mbmi) && xd->tree_type != CHROMA_PART) {
aom_cdf_prob *fsc_cdf = get_fsc_mode_cdf(xd, bsize, is_keyframe);
write_fsc_mode(mbmi->fsc_mode[xd->tree_type == CHROMA_PART], w, fsc_cdf);
}
#else
if (is_keyframe) {
write_intra_y_mode_kf(ec_ctx, mbmi, xd->neighbors[0], xd->neighbors[1],
mode, w);
} else {
write_intra_y_mode_nonkf(ec_ctx, bsize, mode, w);
}
if (allow_fsc_intra(cm, xd, bsize, mbmi) && xd->tree_type != CHROMA_PART) {
aom_cdf_prob *fsc_cdf = get_fsc_mode_cdf(xd, bsize, is_keyframe);
write_fsc_mode(mbmi->fsc_mode[xd->tree_type == CHROMA_PART], w, fsc_cdf);
}
// Y angle delta.
if (use_angle_delta && av1_is_directional_mode(mode)) {
write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_Y],
ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mode - V_PRED]);
}
#endif // CONFIG_AIMC
// Encoding reference line index
if (cm->seq_params.enable_mrls && av1_is_directional_mode(mode)) {
write_mrl_index(ec_ctx, mbmi->mrl_index, w);
}
}
// UV mode and UV angle delta.
if (!cm->seq_params.monochrome && xd->is_chroma_ref &&
xd->tree_type != LUMA_PART) {
const UV_PREDICTION_MODE uv_mode = mbmi->uv_mode;
#if CONFIG_AIMC
write_intra_uv_mode(xd, is_cfl_allowed(xd), w);
#else
write_intra_uv_mode(ec_ctx, uv_mode, mode, is_cfl_allowed(xd), w);
if (use_angle_delta && av1_is_directional_mode(get_uv_mode(uv_mode))) {
if (cm->seq_params.enable_sdp) {
write_angle_delta(
w, mbmi->angle_delta[PLANE_TYPE_UV],
ec_ctx->angle_delta_cdf[PLANE_TYPE_UV][uv_mode - V_PRED]);
} else {
write_angle_delta(
w, mbmi->angle_delta[PLANE_TYPE_UV],
ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][uv_mode - V_PRED]);
}
}
#endif // CONFIG_AIMC
if (uv_mode == UV_CFL_PRED) {
#if CONFIG_IMPROVED_CFL
write_cfl_index(ec_ctx, mbmi->cfl_idx, w);
if (mbmi->cfl_idx == 0)
#endif
write_cfl_alphas(ec_ctx, mbmi->cfl_alpha_idx, mbmi->cfl_alpha_signs, w);
}
}
// Palette.
if (av1_allow_palette(cm->features.allow_screen_content_tools, bsize)) {
write_palette_mode_info(cm, xd, mbmi, w);
}
// Filter intra.
write_filter_intra_mode_info(cm, xd, mbmi, w);
}
static INLINE int16_t mode_context_analyzer(
const int16_t mode_context, const MV_REFERENCE_FRAME *const rf) {
if (!is_inter_ref_frame(rf[1])) return mode_context;
#if CONFIG_C076_INTER_MOD_CTX
return mode_context & NEWMV_CTX_MASK;
#else
const int16_t newmv_ctx = mode_context & NEWMV_CTX_MASK;
const int16_t refmv_ctx = (mode_context >> REFMV_OFFSET) & REFMV_CTX_MASK;
const int16_t comp_ctx = compound_mode_ctx_map[refmv_ctx >> 1][AOMMIN(
newmv_ctx, COMP_NEWMV_CTXS - 1)];
return comp_ctx;
#endif // CONFIG_C076_INTER_MOD_CTX
}
static INLINE int_mv get_ref_mv_from_stack(
int ref_idx, const MV_REFERENCE_FRAME *ref_frame, int ref_mv_idx,
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame) {
const int8_t ref_frame_type = av1_ref_frame_type(ref_frame);
const CANDIDATE_MV *curr_ref_mv_stack = mbmi_ext_frame->ref_mv_stack;
if (is_inter_ref_frame(ref_frame[1])) {
assert(ref_idx == 0 || ref_idx == 1);
return ref_idx ? curr_ref_mv_stack[ref_mv_idx].comp_mv
: curr_ref_mv_stack[ref_mv_idx].this_mv;
}
assert(ref_idx == 0);
#if CONFIG_TIP
if (ref_mv_idx < mbmi_ext_frame->ref_mv_count) {
return curr_ref_mv_stack[ref_mv_idx].this_mv;
} else if (is_tip_ref_frame(ref_frame_type)) {
int_mv zero_mv;
zero_mv.as_int = 0;
return zero_mv;
} else {
return mbmi_ext_frame->global_mvs[ref_frame_type];
}
#else
return ref_mv_idx < mbmi_ext_frame->ref_mv_count
? curr_ref_mv_stack[ref_mv_idx].this_mv
: mbmi_ext_frame->global_mvs[ref_frame_type];
#endif // CONFIG_TIP
}
static INLINE int_mv get_ref_mv(const MACROBLOCK *x, int ref_idx) {
const MACROBLOCKD *xd = &x->e_mbd;
const MB_MODE_INFO *mbmi = xd->mi[0];
const int ref_mv_idx = mbmi->ref_mv_idx;
assert(IMPLIES(have_nearmv_newmv_in_inter_mode(mbmi->mode),
has_second_ref(mbmi)));
return get_ref_mv_from_stack(ref_idx, mbmi->ref_frame, ref_mv_idx,
x->mbmi_ext_frame);
}
#if CONFIG_FLEX_MVRES
static void write_pb_mv_precision(const AV1_COMMON *const cm,
MACROBLOCKD *const xd, aom_writer *w) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
assert(mbmi->pb_mv_precision <= mbmi->max_mv_precision);
assert(mbmi->max_mv_precision == xd->sbi->sb_mv_precision);
assert(av1_get_mbmi_max_mv_precision(cm, xd->sbi, mbmi) ==
mbmi->max_mv_precision);
#if !CONFIG_C071_SUBBLK_WARPMV
assert(check_mv_precision(cm, mbmi));
#endif // !CONFIG_C071_SUBBLK_WARPMV
const int down_ctx = av1_get_pb_mv_precision_down_context(cm, xd);
assert(mbmi->most_probable_pb_mv_precision <= mbmi->max_mv_precision);
assert(mbmi->most_probable_pb_mv_precision ==
cm->features.most_probable_fr_mv_precision);
// One binary symbol is used to signal if the precision is same as the most
// probable precision.
// mpp_flag == 1 indicates that the precision is same as the most probable
// precision in current implementaion, the most probable precision is same as
// the maximum precision value of the block.
const int mpp_flag_context = av1_get_mpp_flag_context(cm, xd);
const int mpp_flag =
(mbmi->pb_mv_precision == mbmi->most_probable_pb_mv_precision);
aom_write_symbol(w, mpp_flag,
xd->tile_ctx->pb_mv_mpp_flag_cdf[mpp_flag_context], 2);
if (!mpp_flag) {
const PRECISION_SET *precision_def =
&av1_mv_precision_sets[mbmi->mb_precision_set];
// instead of directly signaling the precision value, we signal index ( i.e.
// down) of the precision
int down = av1_get_pb_mv_precision_index(mbmi);
int nsymbs = precision_def->num_precisions - 1;
assert(down >= 0 && down <= nsymbs);
aom_write_symbol(
w, down,
xd->tile_ctx->pb_mv_precision_cdf[down_ctx][mbmi->max_mv_precision -
MV_PRECISION_HALF_PEL],
nsymbs);
}
}
#endif
static AOM_INLINE void pack_inter_mode_mvs(AV1_COMP *cpi, aom_writer *w) {
AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const struct segmentation *const seg = &cm->seg;
struct segmentation_probs *const segp = &ec_ctx->seg;
const MB_MODE_INFO *const mbmi = xd->mi[0];
const MB_MODE_INFO_EXT_FRAME *const mbmi_ext_frame = x->mbmi_ext_frame;
const PREDICTION_MODE mode = mbmi->mode;
const int segment_id = mbmi->segment_id;
const BLOCK_SIZE bsize = mbmi->sb_type[PLANE_TYPE_Y];
#if CONFIG_FLEX_MVRES
const MvSubpelPrecision pb_mv_precision = mbmi->pb_mv_precision;
#else
const int allow_hp = cm->features.allow_high_precision_mv;
#endif
#if CONFIG_IBC_SR_EXT
const int is_intrabc = is_intrabc_block(mbmi, xd->tree_type);
const int is_inter = is_inter_block(mbmi, xd->tree_type) && !is_intrabc;
#else
const int is_inter = is_inter_block(mbmi, xd->tree_type);
#endif // CONFIG_IBC_SR_EXT
const int is_compound = has_second_ref(mbmi);
int ref;
write_inter_segment_id(cpi, w, seg, segp, 0, 1);
write_skip_mode(cm, xd, segment_id, mbmi, w);
#if CONFIG_SKIP_MODE_ENHANCEMENT
const int skip = write_skip(cm, xd, segment_id, mbmi, w);
#else
assert(
IMPLIES(mbmi->skip_mode, mbmi->skip_txfm[xd->tree_type == CHROMA_PART]));
const int skip =
mbmi->skip_mode ? 1 : write_skip(cm, xd, segment_id, mbmi, w);
#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
write_inter_segment_id(cpi, w, seg, segp, skip, 0);
write_cdef(cm, xd, w, skip);
#if CONFIG_CCSO
if (cm->seq_params.enable_ccso) write_ccso(cm, xd, w);
#endif
write_delta_q_params(cpi, skip, w);
#if CONFIG_WARPMV
// Just for debugging purpose
if (mbmi->mode == WARPMV) {
assert(mbmi->skip_mode == 0);
assert(mbmi->motion_mode == WARP_DELTA ||
warped_causal_idx_map(mbmi->motion_mode));
assert(mbmi->ref_mv_idx == 0);
assert(!is_tip_ref_frame(mbmi->ref_frame[0]));
assert(is_inter);
assert(!have_drl_index(mode));
#if CONFIG_FLEX_MVRES
assert(mbmi->pb_mv_precision == mbmi->max_mv_precision);
#endif
#if CONFIG_BAWP
assert(mbmi->bawp_flag == 0);
#endif
}
#endif // CONFIG_WARPMV
if (!mbmi->skip_mode)
write_is_inter(cm, xd, mbmi->segment_id, w, is_inter
#if CONFIG_CONTEXT_DERIVATION
,
skip
#endif // CONFIG_CONTEXT_DERIVATION
);
#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode) {
av1_collect_neighbors_ref_counts(xd);
write_drl_idx(cm->features.max_drl_bits, mbmi_ext_frame->mode_context,
ec_ctx, mbmi, mbmi_ext_frame, w);
return;
}
#else
if (mbmi->skip_mode) return;
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_IBC_SR_EXT
if (!is_inter && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
write_intrabc_info(xd, mbmi_ext_frame, w);
if (is_intrabc_block(mbmi, xd->tree_type)) return;
}
#endif // CONFIG_IBC_SR_EXT
if (!is_inter) {
write_intra_prediction_modes(cpi, 0, w);
} else {
int16_t mode_ctx;
av1_collect_neighbors_ref_counts(xd);
#if CONFIG_TIP
if (cm->features.tip_frame_mode &&
#if CONFIG_EXT_RECUR_PARTITIONS
is_tip_allowed_bsize(mbmi)) {
#else // CONFIG_EXT_RECUR_PARTITIONS
is_tip_allowed_bsize(bsize)) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int tip_ctx = get_tip_ctx(xd);
aom_write_symbol(w, is_tip_ref_frame(mbmi->ref_frame[0]),
ec_ctx->tip_cdf[tip_ctx], 2);
}
if (!is_tip_ref_frame(mbmi->ref_frame[0])) write_ref_frames(cm, xd, w);
#else
write_ref_frames(cm, xd, w);
#endif // CONFIG_TIP
mode_ctx =
mode_context_analyzer(mbmi_ext_frame->mode_context, mbmi->ref_frame);
#if CONFIG_JOINT_MVD
const int jmvd_base_ref_list = get_joint_mvd_base_ref_list(cm, mbmi);
#endif // CONFIG_JOINT_MVD
// If segment skip is not enabled code the mode.
if (!segfeature_active(seg, segment_id, SEG_LVL_SKIP)) {
if (is_inter_compound_mode(mode))
write_inter_compound_mode(xd, w, mode,
#if CONFIG_OPTFLOW_REFINEMENT
cm, mbmi,
#endif // CONFIG_OPTFLOW_REFINEMENT
mode_ctx);
else if (is_inter_singleref_mode(mode))
write_inter_mode(w, mode, ec_ctx, mode_ctx
#if CONFIG_WARPMV
,
cm, xd, mbmi, bsize
#endif // CONFIG_WARPMV
);
#if CONFIG_WARPMV
#if CONFIG_BAWP
if (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
aom_write_symbol(w, mbmi->bawp_flag == 1, xd->tile_ctx->bawp_cdf, 2);
}
#endif
write_motion_mode(cm, xd, mbmi, mbmi_ext_frame, w);
int is_warpmv_warp_causal =
(warped_causal_idx_map(mbmi->motion_mode) && mbmi->mode == WARPMV);
if (mbmi->motion_mode == WARP_DELTA || is_warpmv_warp_causal)
write_warp_ref_idx(xd->tile_ctx, mbmi, w);
#endif // CONFIG_WARPMV
#if CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
write_jmvd_scale_mode(xd, w, mbmi);
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
#if IMPROVED_AMVD
int max_drl_bits = cm->features.max_drl_bits;
if (mbmi->mode == AMVDNEWMV) max_drl_bits = AOMMIN(max_drl_bits, 1);
#endif // IMPROVED_AMVD
if (have_drl_index(mode))
write_drl_idx(
#if IMPROVED_AMVD
max_drl_bits,
#else
cm->features.max_drl_bits,
#endif // IMPROVED_AMVD
mbmi_ext_frame->mode_context, ec_ctx, mbmi, mbmi_ext_frame, w);
else
assert(mbmi->ref_mv_idx == 0);
#if CONFIG_FLEX_MVRES
if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
write_pb_mv_precision(cm, xd, w);
}
#endif // CONFIG_FLEX_MVRES
}
if (have_newmv_in_each_reference(mode)) {
for (ref = 0; ref < 1 + is_compound; ++ref) {
nmv_context *nmvc = &ec_ctx->nmvc;
const int_mv ref_mv = get_ref_mv(x, ref);
av1_encode_mv(cpi, w,
#if CONFIG_FLEX_MVRES
mbmi->mv[ref].as_mv, ref_mv.as_mv,
#else
&mbmi->mv[ref].as_mv, &ref_mv.as_mv,
#endif
nmvc,
#if CONFIG_FLEX_MVRES
pb_mv_precision);
#else
allow_hp);
#endif
}
} else if (mode == NEAR_NEWMV
#if CONFIG_OPTFLOW_REFINEMENT
|| mode == NEAR_NEWMV_OPTFLOW
#endif // CONFIG_OPTFLOW_REFINEMENT
#if CONFIG_JOINT_MVD
|| (is_joint_mvd_coding_mode(mode) && jmvd_base_ref_list == 1)
#endif // CONFIG_JOINT_MVD
) {
nmv_context *nmvc = &ec_ctx->nmvc;
const int_mv ref_mv = get_ref_mv(x, 1);
av1_encode_mv(cpi, w,
#if CONFIG_FLEX_MVRES
mbmi->mv[1].as_mv, ref_mv.as_mv,
#else
&mbmi->mv[1].as_mv, &ref_mv.as_mv,
#endif
nmvc,
#if CONFIG_FLEX_MVRES
pb_mv_precision);
#else
allow_hp);
#endif
} else if (mode == NEW_NEARMV
#if CONFIG_OPTFLOW_REFINEMENT
|| mode == NEW_NEARMV_OPTFLOW
#endif // CONFIG_OPTFLOW_REFINEMENT
#if CONFIG_JOINT_MVD
|| (is_joint_mvd_coding_mode(mode) && jmvd_base_ref_list == 0)
#endif // CONFIG_JOINT_MVD
) {
nmv_context *nmvc = &ec_ctx->nmvc;
const int_mv ref_mv = get_ref_mv(x, 0);
av1_encode_mv(cpi, w,
#if CONFIG_FLEX_MVRES
mbmi->mv[0].as_mv, ref_mv.as_mv,
#else
&mbmi->mv[0].as_mv, &ref_mv.as_mv,
#endif
nmvc,
#if CONFIG_FLEX_MVRES
pb_mv_precision);
#else
allow_hp);
#endif
}
#if CONFIG_BAWP && !CONFIG_WARPMV
if (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
aom_write_symbol(w, mbmi->bawp_flag == 1, xd->tile_ctx->bawp_cdf, 2);
}
#endif
#if CONFIG_EXTENDED_WARP_PREDICTION
#if !CONFIG_WARPMV
write_motion_mode(cm, xd, mbmi, mbmi_ext_frame, w);
#else
if (mbmi->motion_mode == WARP_DELTA) {
write_warp_delta(cm, xd, mbmi, mbmi_ext_frame, w);
}
#endif // !CONFIG_WARPMV
#else
if (cpi->common.current_frame.reference_mode != COMPOUND_REFERENCE &&
cpi->common.seq_params.enable_interintra_compound &&
is_interintra_allowed(mbmi)) {
const int interintra = mbmi->ref_frame[1] == INTRA_FRAME;
const int bsize_group = size_group_lookup[bsize];
aom_write_symbol(w, interintra, ec_ctx->interintra_cdf[bsize_group], 2);
if (interintra) {
aom_write_symbol(w, mbmi->interintra_mode,
ec_ctx->interintra_mode_cdf[bsize_group],
INTERINTRA_MODES);
if (av1_is_wedge_used(bsize)) {
aom_write_symbol(w, mbmi->use_wedge_interintra,
ec_ctx->wedge_interintra_cdf[bsize], 2);
if (mbmi->use_wedge_interintra) {
#if CONFIG_WEDGE_MOD_EXT
write_wedge_mode(w, ec_ctx, bsize, mbmi->interintra_wedge_index);
#else
aom_write_symbol(w, mbmi->interintra_wedge_index,
ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES);
#endif // CONFIG_WEDGE_MOD_EXT
}
}
}
}
if (mbmi->ref_frame[1] != INTRA_FRAME) write_motion_mode(cm, xd, mbmi, w);
#endif // CONFIG_EXTENDED_WARP_PREDICTION
// First write idx to indicate current compound inter prediction mode
// group Group A (0): dist_wtd_comp, compound_average Group B (1):
// interintra, compound_diffwtd, wedge
if (has_second_ref(mbmi)
#if CONFIG_OPTFLOW_REFINEMENT
&& mbmi->mode < NEAR_NEARMV_OPTFLOW
#endif // CONFIG_OPTFLOW_REFINEMENT
#if IMPROVED_AMVD && CONFIG_JOINT_MVD
&& !is_joint_amvd_coding_mode(mbmi->mode)
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
) {
const int masked_compound_used = is_any_masked_compound_used(bsize) &&
cm->seq_params.enable_masked_compound;
if (masked_compound_used) {
const int ctx_comp_group_idx = get_comp_group_idx_context(cm, xd);
aom_write_symbol(w, mbmi->comp_group_idx,
ec_ctx->comp_group_idx_cdf[ctx_comp_group_idx], 2);
} else {
assert(mbmi->comp_group_idx == 0);
}
if (mbmi->comp_group_idx == 0) {
assert(mbmi->interinter_comp.type == COMPOUND_AVERAGE);
} else {
assert(cpi->common.current_frame.reference_mode != SINGLE_REFERENCE &&
is_inter_compound_mode(mbmi->mode) &&
mbmi->motion_mode == SIMPLE_TRANSLATION);
assert(masked_compound_used);
// compound_diffwtd, wedge
assert(mbmi->interinter_comp.type == COMPOUND_WEDGE ||
mbmi->interinter_comp.type == COMPOUND_DIFFWTD);
if (is_interinter_compound_used(COMPOUND_WEDGE, bsize))
aom_write_symbol(w, mbmi->interinter_comp.type - COMPOUND_WEDGE,
ec_ctx->compound_type_cdf[bsize],
MASKED_COMPOUND_TYPES);
if (mbmi->interinter_comp.type == COMPOUND_WEDGE) {
assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize));
#if CONFIG_WEDGE_MOD_EXT
write_wedge_mode(w, ec_ctx, bsize, mbmi->interinter_comp.wedge_index);
#else
aom_write_symbol(w, mbmi->interinter_comp.wedge_index,
ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES);
#endif // CONFIG_WEDGE_MOD_EXT
aom_write_bit(w, mbmi->interinter_comp.wedge_sign);
} else {
assert(mbmi->interinter_comp.type == COMPOUND_DIFFWTD);
aom_write_literal(w, mbmi->interinter_comp.mask_type,
MAX_DIFFWTD_MASK_BITS);
}
}
}
write_mb_interp_filter(cm, xd, w);
}
}
#if CONFIG_BVP_IMPROVEMENT
static void write_intrabc_drl_idx(int max_ref_bv_num, FRAME_CONTEXT *ec_ctx,
const MB_MODE_INFO *mbmi,
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
aom_writer *w) {
assert(!mbmi->skip_mode);
assert(mbmi->intrabc_drl_idx < mbmi_ext_frame->ref_mv_count);
assert(mbmi->intrabc_drl_idx < max_ref_bv_num);
(void)mbmi_ext_frame;
int bit_cnt = 0;
for (int idx = 0; idx < max_ref_bv_num - 1; ++idx) {
aom_write_symbol(w, mbmi->intrabc_drl_idx != idx,
ec_ctx->intrabc_drl_idx_cdf[bit_cnt], 2);
if (mbmi->intrabc_drl_idx == idx) break;
++bit_cnt;
}
}
#endif // CONFIG_BVP_IMPROVEMENT
static AOM_INLINE void write_intrabc_info(
MACROBLOCKD *xd, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
aom_writer *w) {
const MB_MODE_INFO *const mbmi = xd->mi[0];
int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
if (xd->tree_type == CHROMA_PART) assert(use_intrabc == 0);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#if CONFIG_NEW_CONTEXT_MODELING
const int intrabc_ctx = get_intrabc_ctx(xd);
aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf[intrabc_ctx], 2);
#else
aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf, 2);
#endif // CONFIG_NEW_CONTEXT_MODELING
if (use_intrabc) {
assert(mbmi->mode == DC_PRED);
assert(mbmi->motion_mode == SIMPLE_TRANSLATION);
#if CONFIG_FLEX_MVRES
assert(mbmi->pb_mv_precision == MV_PRECISION_ONE_PEL);
#endif
int_mv dv_ref = mbmi_ext_frame->ref_mv_stack[0].this_mv;
#if CONFIG_BVP_IMPROVEMENT
aom_write_symbol(w, mbmi->intrabc_mode, ec_ctx->intrabc_mode_cdf, 2);
write_intrabc_drl_idx(MAX_REF_BV_STACK_SIZE, ec_ctx, mbmi, mbmi_ext_frame,
w);
if (!mbmi->intrabc_mode)
av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc);
#else
av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc);
#endif // CONFIG_BVP_IMPROVEMENT
}
}
static AOM_INLINE void write_mb_modes_kf(
AV1_COMP *cpi, MACROBLOCKD *xd,
const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame, aom_writer *w) {
AV1_COMMON *const cm = &cpi->common;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const struct segmentation *const seg = &cm->seg;
struct segmentation_probs *const segp = &ec_ctx->seg;
const MB_MODE_INFO *const mbmi = xd->mi[0];
if (seg->segid_preskip && seg->update_map)
write_segment_id(cpi, mbmi, w, seg, segp, 0);
const int skip = write_skip(cm, xd, mbmi->segment_id, mbmi, w);
if (!seg->segid_preskip && seg->update_map)
write_segment_id(cpi, mbmi, w, seg, segp, skip);
if (xd->tree_type != CHROMA_PART) write_cdef(cm, xd, w, skip);
#if CONFIG_CCSO
if (cm->seq_params.enable_ccso
#if CONFIG_CCSO_EXT
&& xd->tree_type != CHROMA_PART
#else
&& xd->tree_type != LUMA_PART
#endif
)
write_ccso(cm, xd, w);
#endif
write_delta_q_params(cpi, skip, w);
if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
write_intrabc_info(xd, mbmi_ext_frame, w);
if (is_intrabc_block(mbmi, xd->tree_type)) return;
}
write_intra_prediction_modes(cpi, 1, w);
}
#if CONFIG_RD_DEBUG
static AOM_INLINE void dump_mode_info(MB_MODE_INFO *mi) {
printf("\nmi->mi_row == %d\n", mi->mi_row);
printf("&& mi->mi_col == %d\n", mi->mi_col);
printf("&& mi->sb_type[0] == %d\n", mi->sb_type[0]);
printf("&& mi->sb_type[1] == %d\n", mi->sb_type[1]);
printf("&& mi->tx_size == %d\n", mi->tx_size);
printf("&& mi->mode == %d\n", mi->mode);
}
static int rd_token_stats_mismatch(RD_STATS *rd_stats, TOKEN_STATS *token_stats,
int plane) {
if (rd_stats->txb_coeff_cost[plane] != token_stats->cost) {
int r, c;
printf("\nplane %d rd_stats->txb_coeff_cost %d token_stats->cost %d\n",
plane, rd_stats->txb_coeff_cost[plane], token_stats->cost);
printf("rd txb_coeff_cost_map\n");
for (r = 0; r < TXB_COEFF_COST_MAP_SIZE; ++r) {
for (c = 0; c < TXB_COEFF_COST_MAP_SIZE; ++c) {
printf("%d ", rd_stats->txb_coeff_cost_map[plane][r][c]);
}
printf("\n");
}
printf("pack txb_coeff_cost_map\n");
for (r = 0; r < TXB_COEFF_COST_MAP_SIZE; ++r) {
for (c = 0; c < TXB_COEFF_COST_MAP_SIZE; ++c) {
printf("%d ", token_stats->txb_coeff_cost_map[r][c]);
}
printf("\n");
}
return 1;
}
return 0;
}
#endif
#if ENC_MISMATCH_DEBUG
static AOM_INLINE void enc_dump_logs(
const AV1_COMMON *const cm,
const MBMIExtFrameBufferInfo *const mbmi_ext_info, int mi_row, int mi_col) {
const MB_MODE_INFO *const mbmi = *(
cm->mi_params.mi_grid_base + (mi_row * cm->mi_params.mi_stride + mi_col));
const MB_MODE_INFO_EXT_FRAME *const mbmi_ext_frame =
mbmi_ext_info->frame_base + get_mi_ext_idx(mi_row, mi_col,
cm->mi_params.mi_alloc_bsize,
mbmi_ext_info->stride);
if (is_inter_block(mbmi, SHARED_PART)) {
#define FRAME_TO_CHECK 11
if (cm->current_frame.frame_number == FRAME_TO_CHECK &&
cm->show_frame == 1) {
const BLOCK_SIZE bsize = mbmi->sb_type;
int_mv mv[2] = { 0 };
const int is_comp_ref = has_second_ref(mbmi);
for (int ref = 0; ref < 1 + is_comp_ref; ++ref)
mv[ref].as_mv = mbmi->mv[ref].as_mv;
if (!is_comp_ref) {
mv[1].as_int = 0;
}
const int16_t mode_ctx =
is_comp_ref ? 0
: mode_context_analyzer(mbmi_ext_frame->mode_context,
mbmi->ref_frame);
const int16_t newmv_ctx = mode_ctx & NEWMV_CTX_MASK;
int16_t zeromv_ctx = -1;
int16_t refmv_ctx = -1;
if (mbmi->mode != NEWMV) {
zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK;
if (mbmi->mode != GLOBALMV)
refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK;
}
printf(
"=== ENCODER ===: "
"Frame=%d, (mi_row,mi_col)=(%d,%d), skip_mode=%d, mode=%d, bsize=%d, "
"show_frame=%d, mv[0]=(%d,%d), mv[1]=(%d,%d), ref[0]=%d, "
"ref[1]=%d, motion_mode=%d, mode_ctx=%d, "
"newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d, tx_size=%d\n",
cm->current_frame.frame_number, mi_row, mi_col, mbmi->skip_mode,
mbmi->mode, bsize, cm->show_frame, mv[0].as_mv.row, mv[0].as_mv.col,
mv[1].as_mv.row, mv[1].as_mv.col, mbmi->ref_frame[0],
mbmi->ref_frame[1], mbmi->motion_mode, mode_ctx, newmv_ctx,
zeromv_ctx, refmv_ctx, mbmi->tx_size);
}
}
}
#endif // ENC_MISMATCH_DEBUG
static AOM_INLINE void write_mbmi_b(AV1_COMP *cpi, aom_writer *w) {
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
MB_MODE_INFO *m = xd->mi[0];
if (frame_is_intra_only(cm)) {
write_mb_modes_kf(cpi, xd, cpi->td.mb.mbmi_ext_frame, w);
} else {
// has_subpel_mv_component needs the ref frame buffers set up to look
// up if they are scaled. has_subpel_mv_component is in turn needed by
// write_switchable_interp_filter, which is called by pack_inter_mode_mvs.
set_ref_ptrs(cm, xd, m->ref_frame[0], m->ref_frame[1]);
#if ENC_MISMATCH_DEBUG
enc_dump_logs(cm, &cpi->mbmi_ext_info, xd->mi_row, xd->mi_col);
#endif // ENC_MISMATCH_DEBUG
pack_inter_mode_mvs(cpi, w);
}
}
static AOM_INLINE void write_inter_txb_coeff(
AV1_COMMON *const cm, MACROBLOCK *const x, MB_MODE_INFO *const mbmi,
aom_writer *w, const TokenExtra **tok, const TokenExtra *const tok_end,
TOKEN_STATS *token_stats, const int row, const int col, int *block,
const int plane) {
MACROBLOCKD *const xd = &x->e_mbd;
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
const BLOCK_SIZE plane_bsize =
get_mb_plane_block_size(xd, mbmi, plane, ss_x, ss_y);
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(plane_bsize ==
get_plane_block_size(mbmi->sb_type[PLANE_TYPE_Y], ss_x, ss_y));
#endif // !CONFIG_EXT_RECUR_PARTITIONS
assert(plane_bsize < BLOCK_SIZES_ALL);
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, plane);
const int step =
tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
const int bkw = tx_size_wide_unit[max_tx_size];
const int bkh = tx_size_high_unit[max_tx_size];
const BLOCK_SIZE max_unit_bsize =
get_plane_block_size(BLOCK_64X64, ss_x, ss_y);
const int num_4x4_w = mi_size_wide[plane_bsize];
const int num_4x4_h = mi_size_high[plane_bsize];
const int mu_blocks_wide = mi_size_wide[max_unit_bsize];
const int mu_blocks_high = mi_size_high[max_unit_bsize];
const int unit_height = AOMMIN(mu_blocks_high + (row >> ss_y), num_4x4_h);
const int unit_width = AOMMIN(mu_blocks_wide + (col >> ss_x), num_4x4_w);
for (int blk_row = row >> ss_y; blk_row < unit_height; blk_row += bkh) {
for (int blk_col = col >> ss_x; blk_col < unit_width; blk_col += bkw) {
#if CONFIG_CROSS_CHROMA_TX
if (plane == AOM_PLANE_V && is_cctx_allowed(cm, xd)) {
pack_txb_tokens(w, cm, x, tok, tok_end, xd, mbmi, AOM_PLANE_U,
plane_bsize, cm->seq_params.bit_depth,
block[AOM_PLANE_U], blk_row, blk_col, max_tx_size,
token_stats);
block[AOM_PLANE_U] += step;
}
pack_txb_tokens(w, cm, x, tok, tok_end, xd, mbmi, plane, plane_bsize,
cm->seq_params.bit_depth, block[plane], blk_row, blk_col,
max_tx_size, token_stats);
block[plane] += step;
#else
pack_txb_tokens(w, cm, x, tok, tok_end, xd, mbmi, plane, plane_bsize,
cm->seq_params.bit_depth, *block, blk_row, blk_col,
max_tx_size, token_stats);
*block += step;
#endif // CONFIG_CROSS_CHROMA_TX
}
}
}
static AOM_INLINE void write_tokens_b(AV1_COMP *cpi, aom_writer *w,
const TokenExtra **tok,
const TokenExtra *const tok_end) {
AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
#if CONFIG_EXT_RECUR_PARTITIONS
const BLOCK_SIZE bsize = get_bsize_base(xd, mbmi, AOM_PLANE_Y);
#else
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
#endif // CONFIG_EXT_RECUR_PARTITIONS
assert(!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]);
const int is_inter = is_inter_block(mbmi, xd->tree_type);
if (!is_inter) {
av1_write_intra_coeffs_mb(cm, x, w, bsize);
} else {
int block[MAX_MB_PLANE] = { 0 };
assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x,
xd->plane[0].subsampling_y));
const int num_4x4_w = mi_size_wide[bsize];
const int num_4x4_h = mi_size_high[bsize];
TOKEN_STATS token_stats;
init_token_stats(&token_stats);
const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
assert(max_unit_bsize == get_plane_block_size(BLOCK_64X64,
xd->plane[0].subsampling_x,
xd->plane[0].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(num_4x4_w, mu_blocks_wide);
mu_blocks_high = AOMMIN(num_4x4_h, mu_blocks_high);
for (int row = 0; row < num_4x4_h; row += mu_blocks_high) {
for (int col = 0; col < num_4x4_w; col += mu_blocks_wide) {
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end =
get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
for (int plane = plane_start; plane < plane_end; ++plane) {
if (plane && !xd->is_chroma_ref) break;
#if CONFIG_CROSS_CHROMA_TX
if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) continue;
write_inter_txb_coeff(cm, x, mbmi, w, tok, tok_end, &token_stats, row,
col, block, plane);
#else
write_inter_txb_coeff(cm, x, mbmi, w, tok, tok_end, &token_stats, row,
col, &block[plane], plane);
#endif // CONFIG_CROSS_CHROMA_TX
}
}
}
#if CONFIG_RD_DEBUG
for (int plane = 0; plane < num_planes; ++plane) {
if (mbmi->sb_type[xd->tree_type == CHROMA_PART] >= BLOCK_8X8 &&
rd_token_stats_mismatch(&mbmi->rd_stats, &token_stats, plane)) {
dump_mode_info(mbmi);
assert(0);
}
}
#endif // CONFIG_RD_DEBUG
}
}
static AOM_INLINE void write_modes_b(AV1_COMP *cpi, const TileInfo *const tile,
aom_writer *w, const TokenExtra **tok,
const TokenExtra *const tok_end,
int mi_row, int mi_col) {
const AV1_COMMON *cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
const int grid_idx = mi_row * mi_params->mi_stride + mi_col;
xd->mi = mi_params->mi_grid_base + grid_idx;
cpi->td.mb.mbmi_ext_frame =
cpi->mbmi_ext_info.frame_base +
get_mi_ext_idx(mi_row, mi_col, cm->mi_params.mi_alloc_bsize,
cpi->mbmi_ext_info.stride);
xd->tx_type_map = mi_params->tx_type_map + grid_idx;
xd->tx_type_map_stride = mi_params->mi_stride;
#if CONFIG_CROSS_CHROMA_TX
xd->cctx_type_map = mi_params->cctx_type_map + grid_idx;
xd->cctx_type_map_stride = mi_params->mi_stride;
#endif // CONFIG_CROSS_CHROMA_TX
MB_MODE_INFO *mbmi = xd->mi[0];
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
if (xd->tree_type == SHARED_PART)
assert(mbmi->sb_type[PLANE_TYPE_Y] == mbmi->sb_type[PLANE_TYPE_UV]);
assert(bsize <= cm->seq_params.sb_size ||
(bsize >= BLOCK_SIZES && bsize < BLOCK_SIZES_ALL));
const int bh = mi_size_high[bsize];
const int bw = mi_size_wide[bsize];
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
mi_params->mi_cols, &mbmi->chroma_ref_info);
#if CONFIG_CROSS_CHROMA_TX
// For skip blocks, reset the corresponding area in cctx_type_map to
// CCTX_NONE, which will be used as contexts for later blocks. No need to use
// av1_get_adjusted_tx_size because uv_txsize is intended to cover the entire
// prediction block area
if (is_cctx_enabled(cm, xd) &&
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] &&
xd->tree_type != LUMA_PART && xd->is_chroma_ref) {
struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_U];
const BLOCK_SIZE uv_bsize = get_mb_plane_block_size(
xd, mbmi, AOM_PLANE_U, pd->subsampling_x, pd->subsampling_y);
const TX_SIZE uv_txsize = max_txsize_rect_lookup[uv_bsize];
int row_offset, col_offset;
#if CONFIG_EXT_RECUR_PARTITIONS
get_chroma_mi_offsets(xd, &row_offset, &col_offset);
#else
get_chroma_mi_offsets(xd, uv_txsize, &row_offset, &col_offset);
#endif // CONFIG_EXT_RECUR_PARTITIONS
update_cctx_array(xd, 0, 0, row_offset, col_offset, uv_txsize, CCTX_NONE);
}
#endif // CONFIG_CROSS_CHROMA_TX
xd->above_txfm_context = cm->above_contexts.txfm[tile->tile_row] + mi_col;
xd->left_txfm_context =
xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
write_mbmi_b(cpi, w);
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end =
get_partition_plane_end(xd->tree_type, AOMMIN(2, av1_num_planes(cm)));
for (int plane = plane_start; plane < plane_end; ++plane) {
const uint8_t palette_size_plane =
mbmi->palette_mode_info.palette_size[plane];
assert(!mbmi->skip_mode || !palette_size_plane);
if (palette_size_plane > 0) {
assert(mbmi->use_intrabc[plane] == 0);
assert(av1_allow_palette(cm->features.allow_screen_content_tools,
mbmi->sb_type[plane]));
assert(!plane || xd->is_chroma_ref);
int rows, cols;
av1_get_block_dimensions(mbmi->sb_type[plane], plane, xd, NULL, NULL,
&rows, &cols);
assert(*tok < tok_end);
#if CONFIG_NEW_COLOR_MAP_CODING
pack_map_tokens(w, tok, palette_size_plane, cols, rows);