diff options
Diffstat (limited to 'third_party/aom/av1/encoder/bitstream.c')
| -rw-r--r-- | third_party/aom/av1/encoder/bitstream.c | 6540 |
1 files changed, 2296 insertions, 4244 deletions
diff --git a/third_party/aom/av1/encoder/bitstream.c b/third_party/aom/av1/encoder/bitstream.c index 08f605f10..cdd7c2492 100644 --- a/third_party/aom/av1/encoder/bitstream.c +++ b/third_party/aom/av1/encoder/bitstream.c @@ -24,9 +24,8 @@ #include "aom_util/debug_util.h" #endif // CONFIG_BITSTREAM_DEBUG -#if CONFIG_CDEF #include "av1/common/cdef.h" -#endif // CONFIG_CDEF +#include "av1/common/cfl.h" #include "av1/common/entropy.h" #include "av1/common/entropymode.h" #include "av1/common/entropymv.h" @@ -34,38 +33,21 @@ #include "av1/common/odintrin.h" #include "av1/common/pred_common.h" #include "av1/common/reconinter.h" -#if CONFIG_EXT_INTRA #include "av1/common/reconintra.h" -#endif // CONFIG_EXT_INTRA #include "av1/common/seg_common.h" #include "av1/common/tile_common.h" -#if CONFIG_LV_MAP -#include "av1/encoder/encodetxb.h" -#endif // CONFIG_LV_MAP #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" -#if CONFIG_PALETTE_DELTA_ENCODING #include "av1/encoder/palette.h" -#endif // CONFIG_PALETTE_DELTA_ENCODING #include "av1/encoder/segmentation.h" -#include "av1/encoder/subexp.h" #include "av1/encoder/tokenize.h" -#if CONFIG_PVQ -#include "av1/encoder/pvq_encoder.h" -#endif #define ENC_MISMATCH_DEBUG 0 -#if CONFIG_COMPOUND_SINGLEREF -static struct av1_token - inter_singleref_comp_mode_encodings[INTER_SINGLEREF_COMP_MODES]; -#endif // CONFIG_COMPOUND_SINGLEREF - -// TODO(anybody) : remove this flag when PVQ supports pallete coding tool -#if !CONFIG_PVQ || CONFIG_EXT_INTRA 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; @@ -77,110 +59,38 @@ static INLINE void write_uniform(aom_writer *w, int n, int v) { aom_write_literal(w, (v - m) & 1, 1); } } -#endif // !CONFIG_PVQ || CONFIG_EXT_INTRA - -#if CONFIG_EXT_INTRA -#if CONFIG_INTRA_INTERP -static struct av1_token intra_filter_encodings[INTRA_FILTERS]; -#endif // CONFIG_INTRA_INTERP -#endif // CONFIG_EXT_INTRA -#if CONFIG_INTERINTRA -static struct av1_token interintra_mode_encodings[INTERINTRA_MODES]; -#endif -#if CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE -static struct av1_token compound_type_encodings[COMPOUND_TYPES]; -#endif // CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE -#if CONFIG_LOOP_RESTORATION -static struct av1_token switchable_restore_encodings[RESTORE_SWITCHABLE_TYPES]; + static void loop_restoration_write_sb_coeffs(const AV1_COMMON *const cm, MACROBLOCKD *xd, + const RestorationUnitInfo *rui, aom_writer *const w, int plane, - int rtile_idx); -#endif // CONFIG_LOOP_RESTORATION -#if CONFIG_OBU -static void write_uncompressed_header_obu(AV1_COMP *cpi, - struct aom_write_bit_buffer *wb); -#else -static void write_uncompressed_header_frame(AV1_COMP *cpi, - struct aom_write_bit_buffer *wb); -#endif - -static uint32_t write_compressed_header(AV1_COMP *cpi, uint8_t *data); - -#if !CONFIG_OBU || CONFIG_EXT_TILE -static int remux_tiles(const AV1_COMMON *const cm, uint8_t *dst, - const uint32_t data_size, const uint32_t max_tile_size, - const uint32_t max_tile_col_size, - int *const tile_size_bytes, - int *const tile_col_size_bytes); -#endif -void av1_encode_token_init(void) { -#if CONFIG_EXT_INTRA && CONFIG_INTRA_INTERP - av1_tokens_from_tree(intra_filter_encodings, av1_intra_filter_tree); -#endif // CONFIG_EXT_INTRA && CONFIG_INTRA_INTERP -#if CONFIG_INTERINTRA - av1_tokens_from_tree(interintra_mode_encodings, av1_interintra_mode_tree); -#endif // CONFIG_INTERINTRA -#if CONFIG_COMPOUND_SINGLEREF - av1_tokens_from_tree(inter_singleref_comp_mode_encodings, - av1_inter_singleref_comp_mode_tree); -#endif // CONFIG_COMPOUND_SINGLEREF -#if CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE - av1_tokens_from_tree(compound_type_encodings, av1_compound_type_tree); -#endif // CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE -#if CONFIG_LOOP_RESTORATION - av1_tokens_from_tree(switchable_restore_encodings, - av1_switchable_restore_tree); -#endif // CONFIG_LOOP_RESTORATION -} + FRAME_COUNTS *counts); -static void write_intra_mode_kf(const AV1_COMMON *cm, FRAME_CONTEXT *frame_ctx, - const MODE_INFO *mi, const MODE_INFO *above_mi, - const MODE_INFO *left_mi, int block, +static void write_intra_mode_kf(FRAME_CONTEXT *frame_ctx, + const MB_MODE_INFO *mi, + const MB_MODE_INFO *above_mi, + const MB_MODE_INFO *left_mi, PREDICTION_MODE mode, aom_writer *w) { -#if CONFIG_INTRABC - assert(!is_intrabc_block(&mi->mbmi)); -#endif // CONFIG_INTRABC - aom_write_symbol(w, mode, - get_y_mode_cdf(frame_ctx, mi, above_mi, left_mi, block), + assert(!is_intrabc_block(mi)); + (void)mi; + aom_write_symbol(w, mode, get_y_mode_cdf(frame_ctx, above_mi, left_mi), INTRA_MODES); - (void)cm; } static void write_inter_mode(aom_writer *w, PREDICTION_MODE mode, FRAME_CONTEXT *ec_ctx, const int16_t mode_ctx) { const int16_t newmv_ctx = mode_ctx & NEWMV_CTX_MASK; -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, mode != NEWMV, ec_ctx->newmv_cdf[newmv_ctx], 2); -#else - aom_write(w, mode != NEWMV, ec_ctx->newmv_prob[newmv_ctx]); -#endif if (mode != NEWMV) { - if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET)) { - assert(mode == ZEROMV); - return; - } + const int16_t zeromv_ctx = + (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK; + aom_write_symbol(w, mode != GLOBALMV, ec_ctx->zeromv_cdf[zeromv_ctx], 2); - const int16_t zeromv_ctx = (mode_ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK; -#if CONFIG_NEW_MULTISYMBOL - aom_write_symbol(w, mode != ZEROMV, ec_ctx->zeromv_cdf[zeromv_ctx], 2); -#else - aom_write(w, mode != ZEROMV, ec_ctx->zeromv_prob[zeromv_ctx]); -#endif - - if (mode != ZEROMV) { + if (mode != GLOBALMV) { int16_t refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK; - - if (mode_ctx & (1 << SKIP_NEARESTMV_OFFSET)) refmv_ctx = 6; - if (mode_ctx & (1 << SKIP_NEARMV_OFFSET)) refmv_ctx = 7; - if (mode_ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) refmv_ctx = 8; -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, mode != NEARESTMV, ec_ctx->refmv_cdf[refmv_ctx], 2); -#else - aom_write(w, mode != NEARESTMV, ec_ctx->refmv_prob[refmv_ctx]); -#endif } } } @@ -191,24 +101,16 @@ static void write_drl_idx(FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi, assert(mbmi->ref_mv_idx < 3); -#if CONFIG_COMPOUND_SINGLEREF - if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV || - mbmi->mode == SR_NEW_NEWMV) { -#else // !CONFIG_COMPOUND_SINGLEREF - if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) { -#endif // CONFIG_COMPOUND_SINGLEREF + const int new_mv = mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV; + if (new_mv) { int idx; for (idx = 0; idx < 2; ++idx) { if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) { uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx); -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, mbmi->ref_mv_idx != idx, ec_ctx->drl_cdf[drl_ctx], 2); -#else - aom_write(w, mbmi->ref_mv_idx != idx, ec_ctx->drl_prob[drl_ctx]); -#endif if (mbmi->ref_mv_idx == idx) return; } } @@ -222,12 +124,8 @@ static void write_drl_idx(FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi, if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) { uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type], idx); -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, mbmi->ref_mv_idx != (idx - 1), ec_ctx->drl_cdf[drl_ctx], 2); -#else - aom_write(w, mbmi->ref_mv_idx != (idx - 1), ec_ctx->drl_prob[drl_ctx]); -#endif if (mbmi->ref_mv_idx == (idx - 1)) return; } } @@ -235,52 +133,22 @@ static void write_drl_idx(FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi, } } -static void write_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd, - aom_writer *w, PREDICTION_MODE mode, +static void write_inter_compound_mode(MACROBLOCKD *xd, aom_writer *w, + PREDICTION_MODE mode, const int16_t mode_ctx) { assert(is_inter_compound_mode(mode)); - (void)cm; aom_write_symbol(w, INTER_COMPOUND_OFFSET(mode), xd->tile_ctx->inter_compound_mode_cdf[mode_ctx], INTER_COMPOUND_MODES); } -#if CONFIG_COMPOUND_SINGLEREF -static void write_inter_singleref_comp_mode(MACROBLOCKD *xd, aom_writer *w, - PREDICTION_MODE mode, - const int16_t mode_ctx) { - assert(is_inter_singleref_comp_mode(mode)); - aom_cdf_prob *const inter_singleref_comp_cdf = - xd->tile_ctx->inter_singleref_comp_mode_cdf[mode_ctx]; - - aom_write_symbol(w, INTER_SINGLEREF_COMP_OFFSET(mode), - inter_singleref_comp_cdf, INTER_SINGLEREF_COMP_MODES); -} -#endif // CONFIG_COMPOUND_SINGLEREF - -static void encode_unsigned_max(struct aom_write_bit_buffer *wb, int data, - int max) { - aom_wb_write_literal(wb, data, get_unsigned_bits(max)); -} - -#if CONFIG_VAR_TX -static void write_tx_size_vartx(const AV1_COMMON *cm, MACROBLOCKD *xd, - const MB_MODE_INFO *mbmi, TX_SIZE tx_size, - int depth, int blk_row, int blk_col, - aom_writer *w) { -#if CONFIG_NEW_MULTISYMBOL +static 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 *ec_ctx = xd->tile_ctx; - (void)cm; -#endif - const int tx_row = blk_row >> 1; - const int tx_col = blk_col >> 1; const int max_blocks_high = max_block_high(xd, mbmi->sb_type, 0); const int max_blocks_wide = max_block_wide(xd, mbmi->sb_type, 0); - int ctx = txfm_partition_context(xd->above_txfm_context + blk_col, - xd->left_txfm_context + blk_row, - mbmi->sb_type, tx_size); - if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; if (depth == MAX_VARTX_DEPTH) { @@ -289,31 +157,25 @@ static void write_tx_size_vartx(const AV1_COMMON *cm, MACROBLOCKD *xd, return; } -#if CONFIG_RECT_TX_EXT - if (tx_size == mbmi->inter_tx_size[tx_row][tx_col] || - mbmi->tx_size == quarter_txsize_lookup[mbmi->sb_type]) { -#else - if (tx_size == mbmi->inter_tx_size[tx_row][tx_col]) { -#endif -#if CONFIG_NEW_MULTISYMBOL + const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col, + xd->left_txfm_context + blk_row, + mbmi->sb_type, tx_size); + const int txb_size_index = + av1_get_txb_size_index(mbmi->sb_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); -#else - aom_write(w, 0, cm->fc->txfm_partition_prob[ctx]); -#endif 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 bsl = tx_size_wide_unit[sub_txs]; - int i; + const int bsw = tx_size_wide_unit[sub_txs]; + const int bsh = tx_size_high_unit[sub_txs]; -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, 1, ec_ctx->txfm_partition_cdf[ctx], 2); -#else - aom_write(w, 1, cm->fc->txfm_partition_prob[ctx]); -#endif if (sub_txs == TX_4X4) { txfm_partition_update(xd->above_txfm_context + blk_col, @@ -321,185 +183,115 @@ static void write_tx_size_vartx(const AV1_COMMON *cm, MACROBLOCKD *xd, return; } - assert(bsl > 0); - for (i = 0; i < 4; ++i) { - int offsetr = blk_row + (i >> 1) * bsl; - int offsetc = blk_col + (i & 0x01) * bsl; - write_tx_size_vartx(cm, xd, mbmi, sub_txs, depth + 1, offsetr, offsetc, - w); - } + 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); + } } } -#if !CONFIG_NEW_MULTISYMBOL -static void update_txfm_partition_probs(AV1_COMMON *cm, aom_writer *w, - FRAME_COUNTS *counts, int probwt) { - int k; - for (k = 0; k < TXFM_PARTITION_CONTEXTS; ++k) - av1_cond_prob_diff_update(w, &cm->fc->txfm_partition_prob[k], - counts->txfm_partition[k], probwt); -} -#endif // CONFIG_NEW_MULTISYMBOL -#endif // CONFIG_VAR_TX - -static void write_selected_tx_size(const AV1_COMMON *cm, const MACROBLOCKD *xd, - aom_writer *w) { - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; +static 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; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; if (block_signals_txsize(bsize)) { const TX_SIZE tx_size = mbmi->tx_size; - const int is_inter = is_inter_block(mbmi); const int tx_size_ctx = get_tx_size_context(xd); - const int32_t tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize] - : intra_tx_size_cat_lookup[bsize]; - const TX_SIZE coded_tx_size = txsize_sqr_up_map[tx_size]; - const int depth = tx_size_to_depth(coded_tx_size); -#if CONFIG_EXT_TX && CONFIG_RECT_TX + 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)); assert(IMPLIES(is_rect_tx(tx_size), is_rect_tx_allowed(xd, mbmi))); -#endif // CONFIG_EXT_TX && CONFIG_RECT_TX aom_write_symbol(w, depth, ec_ctx->tx_size_cdf[tx_size_cat][tx_size_ctx], - tx_size_cat + 2); -#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX) - if (is_quarter_tx_allowed(xd, mbmi, is_inter) && tx_size != coded_tx_size) -#if CONFIG_NEW_MULTISYMBOL - aom_write_symbol(w, tx_size == quarter_txsize_lookup[bsize], - cm->fc->quarter_tx_size_cdf, 2); -#else - aom_write(w, tx_size == quarter_txsize_lookup[bsize], - cm->fc->quarter_tx_size_prob); -#endif -#endif + max_depths + 1); } } -#if !CONFIG_NEW_MULTISYMBOL -static void update_inter_mode_probs(AV1_COMMON *cm, aom_writer *w, - FRAME_COUNTS *counts) { - int i; - const int probwt = cm->num_tg; - for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i) - av1_cond_prob_diff_update(w, &cm->fc->newmv_prob[i], counts->newmv_mode[i], - probwt); - for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i) - av1_cond_prob_diff_update(w, &cm->fc->zeromv_prob[i], - counts->zeromv_mode[i], probwt); - for (i = 0; i < REFMV_MODE_CONTEXTS; ++i) - av1_cond_prob_diff_update(w, &cm->fc->refmv_prob[i], counts->refmv_mode[i], - probwt); - for (i = 0; i < DRL_MODE_CONTEXTS; ++i) - av1_cond_prob_diff_update(w, &cm->fc->drl_prob[i], counts->drl_mode[i], - probwt); -} -#endif - static int write_skip(const AV1_COMMON *cm, const MACROBLOCKD *xd, - int segment_id, const MODE_INFO *mi, aom_writer *w) { + 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 = mi->mbmi.skip; -#if CONFIG_NEW_MULTISYMBOL - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + const int skip = mi->skip; const int ctx = av1_get_skip_context(xd); + FRAME_CONTEXT *ec_ctx = xd->tile_ctx; aom_write_symbol(w, skip, ec_ctx->skip_cdfs[ctx], 2); -#else - aom_write(w, skip, av1_get_skip_prob(cm, xd)); -#endif return skip; } } +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->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)) { + assert(!skip_mode); + return 0; + } + if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME) || + 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 void write_is_inter(const AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id, aom_writer *w, const int is_inter) { if (!segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) { -#if CONFIG_NEW_MULTISYMBOL - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + 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; aom_write_symbol(w, is_inter, ec_ctx->intra_inter_cdf[ctx], 2); -#else - aom_write(w, is_inter, av1_get_intra_inter_prob(cm, xd)); -#endif } } -#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION static void write_motion_mode(const AV1_COMMON *cm, MACROBLOCKD *xd, - const MODE_INFO *mi, aom_writer *w) { - const MB_MODE_INFO *mbmi = &mi->mbmi; - -#if !CONFIG_GLOBAL_MOTION - // The cm parameter is only used with global_motion or with - // motion_var and warped_motion. In other cases, explicitly ignore - // it to avoid a compiler warning. - (void)cm; -#endif - MOTION_MODE last_motion_mode_allowed = motion_mode_allowed( -#if CONFIG_GLOBAL_MOTION - 0, cm->global_motion, -#endif // CONFIG_GLOBAL_MOTION -#if CONFIG_WARPED_MOTION - xd, -#endif - mi); - if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return; -#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION -#if CONFIG_NCOBMC_ADAPT_WEIGHT - if (last_motion_mode_allowed == NCOBMC_ADAPT_WEIGHT) { - aom_write_symbol(w, mbmi->motion_mode, - xd->tile_ctx->ncobmc_cdf[mbmi->sb_type], - OBMC_FAMILY_MODES); - } else if (last_motion_mode_allowed == OBMC_CAUSAL) { - aom_write_symbol(w, mbmi->motion_mode == OBMC_CAUSAL, - xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2); - } else { -#else - if (last_motion_mode_allowed == OBMC_CAUSAL) { -#if CONFIG_NEW_MULTISYMBOL - aom_write_symbol(w, mbmi->motion_mode == OBMC_CAUSAL, - xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2); -#else - aom_write(w, mbmi->motion_mode == OBMC_CAUSAL, - cm->fc->obmc_prob[mbmi->sb_type]); -#endif - } else { -#endif // CONFIG_NCOBMC_ADAPT_WEIGHT -#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION - aom_write_symbol(w, mbmi->motion_mode, - xd->tile_ctx->motion_mode_cdf[mbmi->sb_type], - MOTION_MODES); -#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION - } -#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION -} - -#if CONFIG_NCOBMC_ADAPT_WEIGHT -static void write_ncobmc_mode(MACROBLOCKD *xd, const MODE_INFO *mi, - aom_writer *w) { - const MB_MODE_INFO *mbmi = &mi->mbmi; - ADAPT_OVERLAP_BLOCK ao_block = adapt_overlap_block_lookup[mbmi->sb_type]; - if (mbmi->motion_mode != NCOBMC_ADAPT_WEIGHT) return; - - aom_write_symbol(w, mbmi->ncobmc_mode[0], - xd->tile_ctx->ncobmc_mode_cdf[ao_block], MAX_NCOBMC_MODES); - if (mi_size_wide[mbmi->sb_type] != mi_size_high[mbmi->sb_type]) { - aom_write_symbol(w, mbmi->ncobmc_mode[1], - xd->tile_ctx->ncobmc_mode_cdf[ao_block], MAX_NCOBMC_MODES); + const MB_MODE_INFO *mbmi, aom_writer *w) { + MOTION_MODE last_motion_mode_allowed = + cm->switchable_motion_mode + ? motion_mode_allowed(cm->global_motion, xd, mbmi, + cm->allow_warped_motion) + : SIMPLE_TRANSLATION; + 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], 2); + break; + default: + aom_write_symbol(w, mbmi->motion_mode, + xd->tile_ctx->motion_mode_cdf[mbmi->sb_type], + MOTION_MODES); } } -#endif -#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION -static void write_delta_qindex(const AV1_COMMON *cm, const MACROBLOCKD *xd, - int delta_qindex, aom_writer *w) { +static 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; - (void)cm; aom_write_symbol(w, AOMMIN(abs, DELTA_Q_SMALL), ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1); @@ -515,32 +307,23 @@ static void write_delta_qindex(const AV1_COMMON *cm, const MACROBLOCKD *xd, } } -#if CONFIG_EXT_DELTA_Q static void write_delta_lflevel(const AV1_COMMON *cm, const MACROBLOCKD *xd, -#if CONFIG_LOOPFILTER_LEVEL - int lf_id, -#endif - int delta_lflevel, aom_writer *w) { + 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; - (void)cm; -#if CONFIG_LOOPFILTER_LEVEL if (cm->delta_lf_multi) { - assert(lf_id >= 0 && lf_id < FRAME_LF_COUNT); + 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); } -#else - aom_write_symbol(w, AOMMIN(abs, DELTA_LF_SMALL), ec_ctx->delta_lf_cdf, - DELTA_LF_PROBS + 1); -#endif // CONFIG_LOOPFILTER_LEVEL if (!smallval) { rem_bits = OD_ILOG_NZ(abs - 1) - 1; @@ -552,22 +335,7 @@ static void write_delta_lflevel(const AV1_COMMON *cm, const MACROBLOCKD *xd, aom_write_bit(w, sign); } } -#endif // CONFIG_EXT_DELTA_Q - -#if !CONFIG_NEW_MULTISYMBOL -static void update_skip_probs(AV1_COMMON *cm, aom_writer *w, - FRAME_COUNTS *counts) { - int k; - const int probwt = cm->num_tg; - for (k = 0; k < SKIP_CONTEXTS; ++k) { - av1_cond_prob_diff_update(w, &cm->fc->skip_probs[k], counts->skip[k], - probwt); - } -} -#endif -// TODO(anybody) : remove this flag when PVQ supports pallete coding tool -#if !CONFIG_PVQ static void pack_map_tokens(aom_writer *w, const TOKENEXTRA **tp, int n, int num) { const TOKENEXTRA *p = *tp; @@ -580,423 +348,142 @@ static void pack_map_tokens(aom_writer *w, const TOKENEXTRA **tp, int n, } *tp = p; } -#endif // !CONFIG_PVQ -#if !CONFIG_PVQ -#if CONFIG_SUPERTX -static void update_supertx_probs(AV1_COMMON *cm, int probwt, aom_writer *w) { - const int savings_thresh = av1_cost_one(GROUP_DIFF_UPDATE_PROB) - - av1_cost_zero(GROUP_DIFF_UPDATE_PROB); - int i, j; - int savings = 0; - int do_update = 0; - for (i = 0; i < PARTITION_SUPERTX_CONTEXTS; ++i) { - for (j = TX_8X8; j < TX_SIZES; ++j) { - savings += av1_cond_prob_diff_update_savings( - &cm->fc->supertx_prob[i][j], cm->counts.supertx[i][j], probwt); - } - } - do_update = savings > savings_thresh; - aom_write(w, do_update, GROUP_DIFF_UPDATE_PROB); - if (do_update) { - for (i = 0; i < PARTITION_SUPERTX_CONTEXTS; ++i) { - for (j = TX_8X8; j < TX_SIZES; ++j) { - av1_cond_prob_diff_update(w, &cm->fc->supertx_prob[i][j], - cm->counts.supertx[i][j], probwt); - } - } - } -} -#endif // CONFIG_SUPERTX - -#if !CONFIG_LV_MAP -#if CONFIG_NEW_MULTISYMBOL -static INLINE void write_coeff_extra(const aom_cdf_prob *const *cdf, int val, - int n, aom_writer *w) { - // Code the extra bits from LSB to MSB in groups of 4 - int i = 0; - int count = 0; - while (count < n) { - const int size = AOMMIN(n - count, 4); - const int mask = (1 << size) - 1; - aom_write_cdf(w, val & mask, cdf[i++], 1 << size); - val >>= size; - count += size; - } -} -#else -static INLINE void write_coeff_extra(const aom_prob *pb, int value, - int num_bits, int skip_bits, aom_writer *w, - TOKEN_STATS *token_stats) { - // Code the extra bits from MSB to LSB 1 bit at a time - int index; - for (index = skip_bits; index < num_bits; ++index) { - const int shift = num_bits - index - 1; - const int bb = (value >> shift) & 1; - aom_write_record(w, bb, pb[index], token_stats); - } -} -#endif // CONFIG_NEW_MULTISYMBOL - -static void pack_mb_tokens(aom_writer *w, const TOKENEXTRA **tp, - const TOKENEXTRA *const stop, - aom_bit_depth_t bit_depth, const TX_SIZE tx_size, -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - TX_TYPE tx_type, int is_inter, -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - TOKEN_STATS *token_stats) { - const TOKENEXTRA *p = *tp; -#if CONFIG_VAR_TX - int count = 0; - const int seg_eob = tx_size_2d[tx_size]; -#endif - -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - if (tx_type == MRC_DCT && ((is_inter && SIGNAL_MRC_MASK_INTER) || - (!is_inter && SIGNAL_MRC_MASK_INTRA))) { - int rows = tx_size_high[tx_size]; - int cols = tx_size_wide[tx_size]; - assert(tx_size == TX_32X32); - assert(p < stop); - pack_map_tokens(w, &p, 2, rows * cols); - } -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - - while (p < stop && p->token != EOSB_TOKEN) { - const int token = p->token; - const int eob_val = p->eob_val; - if (token == BLOCK_Z_TOKEN) { - aom_write_symbol(w, 0, *p->head_cdf, HEAD_TOKENS + 1); - p++; -#if CONFIG_VAR_TX - break; -#endif - continue; - } - - const av1_extra_bit *const extra_bits = &av1_extra_bits[token]; - if (eob_val == LAST_EOB) { - // Just code a flag indicating whether the value is >1 or 1. - aom_write_bit(w, token != ONE_TOKEN); - } else { - int comb_symb = 2 * AOMMIN(token, TWO_TOKEN) - eob_val + p->first_val; - aom_write_symbol(w, comb_symb, *p->head_cdf, HEAD_TOKENS + p->first_val); - } - if (token > ONE_TOKEN) { - aom_write_symbol(w, token - TWO_TOKEN, *p->tail_cdf, TAIL_TOKENS); - } - - if (extra_bits->base_val) { - const int bit_string = p->extra; - const int bit_string_length = extra_bits->len; // Length of extra bits to - const int is_cat6 = (extra_bits->base_val == CAT6_MIN_VAL); - // be written excluding - // the sign bit. - int skip_bits = is_cat6 - ? (int)sizeof(av1_cat6_prob) - - av1_get_cat6_extrabits_size(tx_size, bit_depth) - : 0; - - assert(!(bit_string >> (bit_string_length - skip_bits + 1))); - if (bit_string_length > 0) -#if CONFIG_NEW_MULTISYMBOL - write_coeff_extra(extra_bits->cdf, bit_string >> 1, - bit_string_length - skip_bits, w); -#else - write_coeff_extra(extra_bits->prob, bit_string >> 1, bit_string_length, - skip_bits, w, token_stats); -#endif - - aom_write_bit_record(w, bit_string & 1, token_stats); - } - ++p; - -#if CONFIG_VAR_TX - ++count; - if (eob_val == EARLY_EOB || count == seg_eob) break; -#endif - } - - *tp = p; -} -#endif // !CONFIG_LV_MAP -#else // !CONFIG_PVQ -static PVQ_INFO *get_pvq_block(PVQ_QUEUE *pvq_q) { - PVQ_INFO *pvq; - - assert(pvq_q->curr_pos <= pvq_q->last_pos); - assert(pvq_q->curr_pos < pvq_q->buf_len); - - pvq = pvq_q->buf + pvq_q->curr_pos; - ++pvq_q->curr_pos; - - return pvq; -} - -static void pack_pvq_tokens(aom_writer *w, MACROBLOCK *const x, - MACROBLOCKD *const xd, int plane, BLOCK_SIZE bsize, - const TX_SIZE tx_size) { - PVQ_INFO *pvq; - int idx, idy; - const struct macroblockd_plane *const pd = &xd->plane[plane]; - od_adapt_ctx *adapt; - int max_blocks_wide; - int max_blocks_high; - int step = (1 << tx_size); - -#if CONFIG_CHROMA_SUB8X8 - const BLOCK_SIZE plane_bsize = - AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd)); -#elif CONFIG_CB4X4 - const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); -#else - const BLOCK_SIZE plane_bsize = - get_plane_block_size(AOMMAX(BLOCK_8X8, bsize), pd); -#endif - - adapt = x->daala_enc.state.adapt; - - max_blocks_wide = max_block_wide(xd, plane_bsize, plane); - max_blocks_high = max_block_high(xd, plane_bsize, plane); - - for (idy = 0; idy < max_blocks_high; idy += step) { - for (idx = 0; idx < max_blocks_wide; idx += step) { - const int is_keyframe = 0; - const int encode_flip = 0; - const int flip = 0; - int i; - const int has_dc_skip = 1; - int *exg = &adapt->pvq.pvq_exg[plane][tx_size][0]; - int *ext = adapt->pvq.pvq_ext + tx_size * PVQ_MAX_PARTITIONS; - generic_encoder *model = adapt->pvq.pvq_param_model; - - pvq = get_pvq_block(x->pvq_q); - - // encode block skip info - aom_write_symbol(w, pvq->ac_dc_coded, - adapt->skip_cdf[2 * tx_size + (plane != 0)], 4); - - // AC coeffs coded? - if (pvq->ac_dc_coded & AC_CODED) { - assert(pvq->bs == tx_size); - for (i = 0; i < pvq->nb_bands; i++) { - if (i == 0 || - (!pvq->skip_rest && !(pvq->skip_dir & (1 << ((i - 1) % 3))))) { - pvq_encode_partition( - w, pvq->qg[i], pvq->theta[i], pvq->y + pvq->off[i], - pvq->size[i], pvq->k[i], model, adapt, exg + i, ext + i, - (plane != 0) * OD_TXSIZES * PVQ_MAX_PARTITIONS + - pvq->bs * PVQ_MAX_PARTITIONS + i, - is_keyframe, i == 0 && (i < pvq->nb_bands - 1), pvq->skip_rest, - encode_flip, flip); - } - if (i == 0 && !pvq->skip_rest && pvq->bs > 0) { - aom_write_symbol( - w, pvq->skip_dir, - &adapt->pvq - .pvq_skip_dir_cdf[(plane != 0) + 2 * (pvq->bs - 1)][0], - 7); - } - } - } - // Encode residue of DC coeff, if exist. - if (!has_dc_skip || (pvq->ac_dc_coded & DC_CODED)) { - generic_encode(w, &adapt->model_dc[plane], - abs(pvq->dq_dc_residue) - has_dc_skip, - &adapt->ex_dc[plane][pvq->bs][0], 2); - } - if ((pvq->ac_dc_coded & DC_CODED)) { - aom_write_bit(w, pvq->dq_dc_residue < 0); - } - } - } // for (idy = 0; -} -#endif // !CONFIG_PVG - -#if CONFIG_VAR_TX && !CONFIG_COEF_INTERLEAVE -#if CONFIG_LV_MAP -static void pack_txb_tokens(aom_writer *w, -#if CONFIG_LV_MAP - AV1_COMMON *cm, -#endif // CONFIG_LV_MAP +static void pack_txb_tokens(aom_writer *w, AV1_COMMON *cm, MACROBLOCK *const x, const TOKENEXTRA **tp, - const TOKENEXTRA *const tok_end, -#if CONFIG_PVQ || CONFIG_LV_MAP - MACROBLOCK *const x, -#endif - MACROBLOCKD *xd, MB_MODE_INFO *mbmi, int plane, + 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 struct macroblockd_plane *const pd = &xd->plane[plane]; - const BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; - const int tx_row = blk_row >> (1 - pd->subsampling_y); - const int tx_col = blk_col >> (1 - pd->subsampling_x); - TX_SIZE plane_tx_size; 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; - plane_tx_size = - plane ? uv_txsize_lookup[bsize][mbmi->inter_tx_size[tx_row][tx_col]][0][0] - : mbmi->inter_tx_size[tx_row][tx_col]; - - if (tx_size == plane_tx_size) { - TOKEN_STATS tmp_token_stats; - init_token_stats(&tmp_token_stats); + const struct macroblockd_plane *const pd = &xd->plane[plane]; + const TX_SIZE plane_tx_size = + plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x, + pd->subsampling_y) + : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row, + blk_col)]; -#if !CONFIG_PVQ + if (tx_size == plane_tx_size || plane) { tran_low_t *tcoeff = BLOCK_OFFSET(x->mbmi_ext->tcoeff[plane], block); - uint16_t eob = x->mbmi_ext->eobs[plane][block]; + const uint16_t eob = x->mbmi_ext->eobs[plane][block]; TXB_CTX txb_ctx = { x->mbmi_ext->txb_skip_ctx[plane][block], x->mbmi_ext->dc_sign_ctx[plane][block] }; - av1_write_coeffs_txb(cm, xd, w, blk_row, blk_col, block, plane, tx_size, - tcoeff, eob, &txb_ctx); -#else - pack_pvq_tokens(w, x, xd, plane, bsize, tx_size); -#endif + av1_write_coeffs_txb(cm, xd, w, blk_row, blk_col, plane, tx_size, tcoeff, + eob, &txb_ctx); #if CONFIG_RD_DEBUG - token_stats->txb_coeff_cost_map[blk_row][blk_col] = tmp_token_stats.cost; - token_stats->cost += tmp_token_stats.cost; -#endif - } else { - const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; - const int bsl = tx_size_wide_unit[sub_txs]; - int i; - - assert(bsl > 0); - - for (i = 0; i < 4; ++i) { - const int offsetr = blk_row + (i >> 1) * bsl; - const int offsetc = blk_col + (i & 0x01) * bsl; - const int step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs]; - - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; - - pack_txb_tokens(w, -#if CONFIG_LV_MAP - cm, -#endif - tp, tok_end, -#if CONFIG_PVQ || CONFIG_LV_MAP - x, -#endif - xd, mbmi, plane, plane_bsize, bit_depth, block, offsetr, - offsetc, sub_txs, token_stats); - block += step; - } - } -} -#else // CONFIG_LV_MAP -static void pack_txb_tokens(aom_writer *w, const TOKENEXTRA **tp, - const TOKENEXTRA *const tok_end, -#if CONFIG_PVQ - MACROBLOCK *const x, -#endif - 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 struct macroblockd_plane *const pd = &xd->plane[plane]; - const BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; - const int tx_row = blk_row >> (1 - pd->subsampling_y); - const int tx_col = blk_col >> (1 - pd->subsampling_x); - TX_SIZE plane_tx_size; - 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 CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - TX_TYPE tx_type = av1_get_tx_type(plane ? PLANE_TYPE_UV : PLANE_TYPE_Y, xd, - blk_row, blk_col, block, tx_size); -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - - if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; - - plane_tx_size = - plane ? uv_txsize_lookup[bsize][mbmi->inter_tx_size[tx_row][tx_col]][0][0] - : mbmi->inter_tx_size[tx_row][tx_col]; - - if (tx_size == plane_tx_size) { TOKEN_STATS tmp_token_stats; init_token_stats(&tmp_token_stats); -#if !CONFIG_PVQ - pack_mb_tokens(w, tp, tok_end, bit_depth, tx_size, -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - tx_type, is_inter_block(mbmi), -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - &tmp_token_stats); -#else - pack_pvq_tokens(w, x, xd, plane, bsize, tx_size); -#endif -#if CONFIG_RD_DEBUG 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_RECT_TX_EXT - int is_qttx = plane_tx_size == quarter_txsize_lookup[plane_bsize]; - const TX_SIZE sub_txs = is_qttx ? plane_tx_size : sub_tx_size_map[tx_size]; -#else const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; -#endif - const int bsl = tx_size_wide_unit[sub_txs]; - int i; - - assert(bsl > 0); - - for (i = 0; i < 4; ++i) { -#if CONFIG_RECT_TX_EXT - int is_wide_tx = tx_size_wide_unit[sub_txs] > tx_size_high_unit[sub_txs]; - const int offsetr = - is_qttx ? (is_wide_tx ? i * tx_size_high_unit[sub_txs] : 0) - : blk_row + (i >> 1) * bsl; - const int offsetc = - is_qttx ? (is_wide_tx ? 0 : i * tx_size_wide_unit[sub_txs]) - : blk_col + (i & 0x01) * bsl; -#else - const int offsetr = blk_row + (i >> 1) * bsl; - const int offsetc = blk_col + (i & 0x01) * bsl; -#endif - const int step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs]; - - if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; - - pack_txb_tokens(w, tp, tok_end, -#if CONFIG_PVQ - x, -#endif - xd, mbmi, plane, plane_bsize, bit_depth, block, offsetr, - offsetc, sub_txs, token_stats); - block += step; + 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; + } + } + } +} + +static INLINE void set_spatial_segment_id(const AV1_COMMON *const cm, + uint8_t *segment_ids, + BLOCK_SIZE bsize, int mi_row, + int mi_col, int segment_id) { + const int mi_offset = mi_row * cm->mi_cols + mi_col; + const int bw = mi_size_wide[bsize]; + const int bh = mi_size_high[bsize]; + const int xmis = AOMMIN(cm->mi_cols - mi_col, bw); + const int ymis = AOMMIN(cm->mi_rows - mi_row, bh); + int x, y; + + for (y = 0; y < ymis; ++y) + for (x = 0; x < xmis; ++x) + segment_ids[mi_offset + y * cm->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; } } -#endif // CONFIG_LV_MAP -#endif // CONFIG_VAR_TX -static void write_segment_id(aom_writer *w, const struct segmentation *seg, - struct segmentation_probs *segp, int segment_id) { - if (seg->enabled && seg->update_map) { - aom_write_symbol(w, segment_id, segp->tree_cdf, MAX_SEGMENTS); +static 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 mi_row, + int mi_col, int skip) { + 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, mi_row, mi_col, &cdf_num); + + if (skip) { + // Still need to transmit tx size for intra blocks even if skip is + // true. Changing segment_id may make the tx size become invalid, e.g + // changing from lossless to lossy. + assert(is_inter_block(mbmi) || !cpi->has_lossless_segment); + + set_spatial_segment_id(cm, cm->current_frame_seg_map, mbmi->sb_type, mi_row, + mi_col, pred); + set_spatial_segment_id(cm, cpi->segmentation_map, mbmi->sb_type, 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, cm->current_frame_seg_map, mbmi->sb_type, mi_row, + mi_col, mbmi->segment_id); } -#if CONFIG_NEW_MULTISYMBOL #define WRITE_REF_BIT(bname, pname) \ - aom_write_symbol(w, bname, av1_get_pred_cdf_##pname(cm, xd), 2) -#define WRITE_REF_BIT2(bname, pname) \ aom_write_symbol(w, bname, av1_get_pred_cdf_##pname(xd), 2) -#else -#define WRITE_REF_BIT(bname, pname) \ - aom_write(w, bname, av1_get_pred_prob_##pname(cm, xd)) -#define WRITE_REF_BIT2(bname, pname) \ - aom_write(w, bname, av1_get_pred_prob_##pname(cm, xd)) -#endif // This function encodes the reference frame static void write_ref_frames(const AV1_COMMON *cm, const MACROBLOCKD *xd, aom_writer *w) { - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; + const MB_MODE_INFO *const mbmi = xd->mi[0]; const int is_compound = has_second_ref(mbmi); const int segment_id = mbmi->segment_id; @@ -1006,75 +493,40 @@ static void write_ref_frames(const AV1_COMMON *cm, const MACROBLOCKD *xd, assert(!is_compound); assert(mbmi->ref_frame[0] == get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME)); + } else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP) || + segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) { + assert(!is_compound); + assert(mbmi->ref_frame[0] == LAST_FRAME); } else { // does the feature use compound prediction or not // (if not specified at the frame/segment level) if (cm->reference_mode == REFERENCE_MODE_SELECT) { if (is_comp_ref_allowed(mbmi->sb_type)) -#if CONFIG_NEW_MULTISYMBOL - aom_write_symbol(w, is_compound, av1_get_reference_mode_cdf(cm, xd), 2); -#else - aom_write(w, is_compound, av1_get_reference_mode_prob(cm, xd)); -#endif // CONFIG_NEW_MULTISYMBOL + aom_write_symbol(w, is_compound, av1_get_reference_mode_cdf(xd), 2); } else { assert((!is_compound) == (cm->reference_mode == SINGLE_REFERENCE)); } if (is_compound) { -#if CONFIG_EXT_COMP_REFS const COMP_REFERENCE_TYPE comp_ref_type = has_uni_comp_refs(mbmi) ? UNIDIR_COMP_REFERENCE : BIDIR_COMP_REFERENCE; -#if USE_UNI_COMP_REFS -#if CONFIG_VAR_REFS - if ((L_OR_L2(cm) || L3_OR_G(cm)) && BWD_OR_ALT(cm)) - if (L_AND_L2(cm) || L_AND_L3(cm) || L_AND_G(cm) || BWD_AND_ALT(cm)) -#endif // CONFIG_VAR_REFS -#if CONFIG_NEW_MULTISYMBOL - aom_write_symbol(w, comp_ref_type, - av1_get_comp_reference_type_cdf(xd), 2); -#else - aom_write(w, comp_ref_type, av1_get_comp_reference_type_prob(cm, xd)); -#endif -#if CONFIG_VAR_REFS - else - assert(comp_ref_type == BIDIR_COMP_REFERENCE); - else - assert(comp_ref_type == UNIDIR_COMP_REFERENCE); -#endif // CONFIG_VAR_REFS -#else // !USE_UNI_COMP_REFS - // NOTE: uni-directional comp refs disabled - assert(comp_ref_type == BIDIR_COMP_REFERENCE); -#endif // USE_UNI_COMP_REFS + aom_write_symbol(w, comp_ref_type, av1_get_comp_reference_type_cdf(xd), + 2); if (comp_ref_type == UNIDIR_COMP_REFERENCE) { const int bit = mbmi->ref_frame[0] == BWDREF_FRAME; -#if CONFIG_VAR_REFS - if ((L_AND_L2(cm) || L_AND_L3(cm) || L_AND_G(cm)) && BWD_AND_ALT(cm)) -#endif // CONFIG_VAR_REFS - WRITE_REF_BIT2(bit, uni_comp_ref_p); + WRITE_REF_BIT(bit, uni_comp_ref_p); if (!bit) { assert(mbmi->ref_frame[0] == LAST_FRAME); -#if CONFIG_VAR_REFS - if (L_AND_L2(cm) && (L_AND_L3(cm) || L_AND_G(cm))) { -#endif // CONFIG_VAR_REFS - const int bit1 = mbmi->ref_frame[1] == LAST3_FRAME || - mbmi->ref_frame[1] == GOLDEN_FRAME; - WRITE_REF_BIT2(bit1, uni_comp_ref_p1); - if (bit1) { -#if CONFIG_VAR_REFS - if (L_AND_L3(cm) && L_AND_G(cm)) { -#endif // CONFIG_VAR_REFS - const int bit2 = mbmi->ref_frame[1] == GOLDEN_FRAME; - WRITE_REF_BIT2(bit2, uni_comp_ref_p2); -#if CONFIG_VAR_REFS - } -#endif // CONFIG_VAR_REFS - } -#if CONFIG_VAR_REFS + const int bit1 = mbmi->ref_frame[1] == LAST3_FRAME || + mbmi->ref_frame[1] == GOLDEN_FRAME; + WRITE_REF_BIT(bit1, uni_comp_ref_p1); + if (bit1) { + const int bit2 = mbmi->ref_frame[1] == GOLDEN_FRAME; + WRITE_REF_BIT(bit2, uni_comp_ref_p2); } -#endif // CONFIG_VAR_REFS } else { assert(mbmi->ref_frame[1] == ALTREF_FRAME); } @@ -1083,213 +535,81 @@ static void write_ref_frames(const AV1_COMMON *cm, const MACROBLOCKD *xd, } assert(comp_ref_type == BIDIR_COMP_REFERENCE); -#endif // CONFIG_EXT_COMP_REFS -#if CONFIG_EXT_REFS const int bit = (mbmi->ref_frame[0] == GOLDEN_FRAME || mbmi->ref_frame[0] == LAST3_FRAME); -#if CONFIG_VAR_REFS - // Test need to explicitly code (L,L2) vs (L3,G) branch node in tree - if (L_OR_L2(cm) && L3_OR_G(cm)) -#endif // CONFIG_VAR_REFS - WRITE_REF_BIT(bit, comp_ref_p); + WRITE_REF_BIT(bit, comp_ref_p); if (!bit) { -#if CONFIG_VAR_REFS - // Test need to explicitly code (L) vs (L2) branch node in tree - if (L_AND_L2(cm)) { -#endif // CONFIG_VAR_REFS - const int bit1 = mbmi->ref_frame[0] == LAST_FRAME; - WRITE_REF_BIT(bit1, comp_ref_p1); -#if CONFIG_VAR_REFS - } -#endif // CONFIG_VAR_REFS + const int bit1 = mbmi->ref_frame[0] == LAST2_FRAME; + WRITE_REF_BIT(bit1, comp_ref_p1); } else { -#if CONFIG_VAR_REFS - // Test need to explicitly code (L3) vs (G) branch node in tree - if (L3_AND_G(cm)) { -#endif // CONFIG_VAR_REFS - const int bit2 = mbmi->ref_frame[0] == GOLDEN_FRAME; - WRITE_REF_BIT(bit2, comp_ref_p2); -#if CONFIG_VAR_REFS - } -#endif // CONFIG_VAR_REFS + const int bit2 = mbmi->ref_frame[0] == GOLDEN_FRAME; + WRITE_REF_BIT(bit2, comp_ref_p2); } -#if CONFIG_VAR_REFS - // Test need to explicitly code (BWD,ALT2) vs (ALT) branch node in tree - if (BWD_OR_ALT2(cm) && ALTREF_IS_VALID(cm)) { -#endif // CONFIG_VAR_REFS - const int bit_bwd = mbmi->ref_frame[1] == ALTREF_FRAME; - WRITE_REF_BIT(bit_bwd, comp_bwdref_p); - - if (!bit_bwd) { -#if CONFIG_VAR_REFS - // Test need to explicitly code (BWD,ALT2) vs (ALT) branch node in - // tree - if (BWD_AND_ALT2(cm)) -#endif // CONFIG_VAR_REFS - WRITE_REF_BIT(mbmi->ref_frame[1] == ALTREF2_FRAME, comp_bwdref_p1); - } -#if CONFIG_VAR_REFS + const int bit_bwd = mbmi->ref_frame[1] == ALTREF_FRAME; + WRITE_REF_BIT(bit_bwd, comp_bwdref_p); + + if (!bit_bwd) { + WRITE_REF_BIT(mbmi->ref_frame[1] == ALTREF2_FRAME, comp_bwdref_p1); } -#endif // CONFIG_VAR_REFS -#else // !CONFIG_EXT_REFS - const int bit = mbmi->ref_frame[0] == GOLDEN_FRAME; - WRITE_REF_BIT(bit, comp_ref_p); -#endif // CONFIG_EXT_REFS } else { -#if CONFIG_EXT_REFS const int bit0 = (mbmi->ref_frame[0] <= ALTREF_FRAME && mbmi->ref_frame[0] >= BWDREF_FRAME); -#if CONFIG_VAR_REFS - // Test need to explicitly code (L,L2,L3,G) vs (BWD,ALT2,ALT) branch node - // in tree - if ((L_OR_L2(cm) || L3_OR_G(cm)) && - (BWD_OR_ALT2(cm) || ALTREF_IS_VALID(cm))) -#endif // CONFIG_VAR_REFS - WRITE_REF_BIT(bit0, single_ref_p1); + WRITE_REF_BIT(bit0, single_ref_p1); if (bit0) { -#if CONFIG_VAR_REFS - // Test need to explicitly code (BWD,ALT2) vs (ALT) branch node in tree - if (BWD_OR_ALT2(cm) && ALTREF_IS_VALID(cm)) { -#endif // CONFIG_VAR_REFS - const int bit1 = mbmi->ref_frame[0] == ALTREF_FRAME; - WRITE_REF_BIT(bit1, single_ref_p2); - - if (!bit1) { -#if CONFIG_VAR_REFS - // Test need to explicitly code (BWD) vs (ALT2) branch node in tree - if (BWD_AND_ALT2(cm)) -#endif // CONFIG_VAR_REFS - WRITE_REF_BIT(mbmi->ref_frame[0] == ALTREF2_FRAME, single_ref_p6); - } -#if CONFIG_VAR_REFS + const int bit1 = mbmi->ref_frame[0] == ALTREF_FRAME; + WRITE_REF_BIT(bit1, single_ref_p2); + + if (!bit1) { + WRITE_REF_BIT(mbmi->ref_frame[0] == ALTREF2_FRAME, single_ref_p6); } -#endif // CONFIG_VAR_REFS } else { const int bit2 = (mbmi->ref_frame[0] == LAST3_FRAME || mbmi->ref_frame[0] == GOLDEN_FRAME); -#if CONFIG_VAR_REFS - // Test need to explicitly code (L,L2) vs (L3,G) branch node in tree - if (L_OR_L2(cm) && L3_OR_G(cm)) -#endif // CONFIG_VAR_REFS - WRITE_REF_BIT(bit2, single_ref_p3); + WRITE_REF_BIT(bit2, single_ref_p3); if (!bit2) { -#if CONFIG_VAR_REFS - // Test need to explicitly code (L) vs (L2) branch node in tree - if (L_AND_L2(cm)) { -#endif // CONFIG_VAR_REFS - const int bit3 = mbmi->ref_frame[0] != LAST_FRAME; - WRITE_REF_BIT(bit3, single_ref_p4); -#if CONFIG_VAR_REFS - } -#endif // CONFIG_VAR_REFS + const int bit3 = mbmi->ref_frame[0] != LAST_FRAME; + WRITE_REF_BIT(bit3, single_ref_p4); } else { -#if CONFIG_VAR_REFS - // Test need to explicitly code (L3) vs (G) branch node in tree - if (L3_AND_G(cm)) { -#endif // CONFIG_VAR_REFS - const int bit4 = mbmi->ref_frame[0] != LAST3_FRAME; - WRITE_REF_BIT(bit4, single_ref_p5); -#if CONFIG_VAR_REFS - } -#endif // CONFIG_VAR_REFS + const int bit4 = mbmi->ref_frame[0] != LAST3_FRAME; + WRITE_REF_BIT(bit4, single_ref_p5); } } -#else // !CONFIG_EXT_REFS - const int bit0 = mbmi->ref_frame[0] != LAST_FRAME; - WRITE_REF_BIT(bit0, single_ref_p1); - - if (bit0) { - const int bit1 = mbmi->ref_frame[0] != GOLDEN_FRAME; - WRITE_REF_BIT(bit1, single_ref_p2); - } -#endif // CONFIG_EXT_REFS } } } -#if CONFIG_FILTER_INTRA -static void write_filter_intra_mode_info(const AV1_COMMON *const cm, +static void write_filter_intra_mode_info(const AV1_COMMON *cm, const MACROBLOCKD *xd, const MB_MODE_INFO *const mbmi, - int mi_row, int mi_col, aom_writer *w) { - if (mbmi->mode == DC_PRED && mbmi->palette_mode_info.palette_size[0] == 0) { - aom_write(w, mbmi->filter_intra_mode_info.use_filter_intra_mode[0], - cm->fc->filter_intra_probs[0]); - if (mbmi->filter_intra_mode_info.use_filter_intra_mode[0]) { - const FILTER_INTRA_MODE mode = - mbmi->filter_intra_mode_info.filter_intra_mode[0]; - write_uniform(w, FILTER_INTRA_MODES, mode); - } - } - -#if CONFIG_CB4X4 - if (!is_chroma_reference(mi_row, mi_col, mbmi->sb_type, - xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y)) - return; -#else - (void)xd; - (void)mi_row; - (void)mi_col; -#endif // CONFIG_CB4X4 - - if (mbmi->uv_mode == UV_DC_PRED && - mbmi->palette_mode_info.palette_size[1] == 0) { - aom_write(w, mbmi->filter_intra_mode_info.use_filter_intra_mode[1], - cm->fc->filter_intra_probs[1]); - if (mbmi->filter_intra_mode_info.use_filter_intra_mode[1]) { + if (av1_filter_intra_allowed(cm, mbmi)) { + aom_write_symbol(w, mbmi->filter_intra_mode_info.use_filter_intra, + xd->tile_ctx->filter_intra_cdfs[mbmi->sb_type], 2); + if (mbmi->filter_intra_mode_info.use_filter_intra) { const FILTER_INTRA_MODE mode = - mbmi->filter_intra_mode_info.filter_intra_mode[1]; - write_uniform(w, FILTER_INTRA_MODES, mode); + mbmi->filter_intra_mode_info.filter_intra_mode; + aom_write_symbol(w, mode, xd->tile_ctx->filter_intra_mode_cdf, + FILTER_INTRA_MODES); } } } -#endif // CONFIG_FILTER_INTRA -#if CONFIG_EXT_INTRA -static void write_intra_angle_info(const MACROBLOCKD *xd, - FRAME_CONTEXT *const ec_ctx, aom_writer *w) { - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; - const BLOCK_SIZE bsize = mbmi->sb_type; -#if CONFIG_INTRA_INTERP - const int intra_filter_ctx = av1_get_pred_context_intra_interp(xd); - int p_angle; -#endif // CONFIG_INTRA_INTERP - - (void)ec_ctx; - if (!av1_use_angle_delta(bsize)) return; - - if (av1_is_directional_mode(mbmi->mode, bsize)) { - write_uniform(w, 2 * MAX_ANGLE_DELTA + 1, - MAX_ANGLE_DELTA + mbmi->angle_delta[0]); -#if CONFIG_INTRA_INTERP - p_angle = mode_to_angle_map[mbmi->mode] + mbmi->angle_delta[0] * ANGLE_STEP; - if (av1_is_intra_filter_switchable(p_angle)) { - aom_write_symbol(w, mbmi->intra_filter, - ec_ctx->intra_filter_cdf[intra_filter_ctx], - INTRA_FILTERS); - } -#endif // CONFIG_INTRA_INTERP - } - - if (av1_is_directional_mode(get_uv_mode(mbmi->uv_mode), bsize)) { - write_uniform(w, 2 * MAX_ANGLE_DELTA + 1, - MAX_ANGLE_DELTA + mbmi->angle_delta[1]); - } +static 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_EXT_INTRA static void write_mb_interp_filter(AV1_COMP *cpi, const MACROBLOCKD *xd, aom_writer *w) { AV1_COMMON *const cm = &cpi->common; - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; + const MB_MODE_INFO *const mbmi = xd->mi[0]; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; if (!av1_is_interp_needed(xd)) { @@ -1299,36 +619,19 @@ static void write_mb_interp_filter(AV1_COMP *cpi, const MACROBLOCKD *xd, return; } if (cm->interp_filter == SWITCHABLE) { -#if CONFIG_DUAL_FILTER int dir; for (dir = 0; dir < 2; ++dir) { - if (has_subpel_mv_component(xd->mi[0], xd, dir) || - (mbmi->ref_frame[1] > INTRA_FRAME && - has_subpel_mv_component(xd->mi[0], xd, dir + 2))) { - const int ctx = av1_get_pred_context_switchable_interp(xd, dir); - InterpFilter filter = - av1_extract_interp_filter(mbmi->interp_filters, dir); - aom_write_symbol(w, filter, ec_ctx->switchable_interp_cdf[ctx], - SWITCHABLE_FILTERS); - ++cpi->interp_filter_selected[0][filter]; - } else { - assert(av1_extract_interp_filter(mbmi->interp_filters, dir) == - EIGHTTAP_REGULAR); - } - } -#else - { - const int ctx = av1_get_pred_context_switchable_interp(xd); - InterpFilter filter = av1_extract_interp_filter(mbmi->interp_filters, 0); + const int ctx = av1_get_pred_context_switchable_interp(xd, dir); + InterpFilter filter = + av1_extract_interp_filter(mbmi->interp_filters, dir); aom_write_symbol(w, filter, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS); ++cpi->interp_filter_selected[0][filter]; + if (cm->seq_params.enable_dual_filter == 0) return; } -#endif // CONFIG_DUAL_FILTER } } -#if CONFIG_PALETTE_DELTA_ENCODING // 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. @@ -1446,207 +749,90 @@ static void write_palette_colors_uv(const MACROBLOCKD *const xd, } } } -#endif // CONFIG_PALETTE_DELTA_ENCODING static void write_palette_mode_info(const AV1_COMMON *cm, const MACROBLOCKD *xd, - const MODE_INFO *const mi, aom_writer *w) { - const MB_MODE_INFO *const mbmi = &mi->mbmi; - const MODE_INFO *const above_mi = xd->above_mi; - const MODE_INFO *const left_mi = xd->left_mi; + const MB_MODE_INFO *const mbmi, int mi_row, + int mi_col, aom_writer *w) { + const int num_planes = av1_num_planes(cm); const BLOCK_SIZE bsize = mbmi->sb_type; + assert(av1_allow_palette(cm->allow_screen_content_tools, bsize)); const PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info; - - assert(bsize >= BLOCK_8X8 && bsize <= BLOCK_LARGEST); - const int block_palette_idx = bsize - BLOCK_8X8; + const int bsize_ctx = av1_get_palette_bsize_ctx(bsize); if (mbmi->mode == DC_PRED) { const int n = pmi->palette_size[0]; - int palette_y_mode_ctx = 0; - if (above_mi) { - palette_y_mode_ctx += - (above_mi->mbmi.palette_mode_info.palette_size[0] > 0); - } - if (left_mi) { - palette_y_mode_ctx += - (left_mi->mbmi.palette_mode_info.palette_size[0] > 0); - } -#if CONFIG_NEW_MULTISYMBOL + 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[block_palette_idx][palette_y_mode_ctx], - 2); -#else - aom_write( - w, n > 0, - av1_default_palette_y_mode_prob[block_palette_idx][palette_y_mode_ctx]); -#endif + 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[block_palette_idx], + xd->tile_ctx->palette_y_size_cdf[bsize_ctx], PALETTE_SIZES); -#if CONFIG_PALETTE_DELTA_ENCODING write_palette_colors_y(xd, pmi, cm->bit_depth, w); -#else - for (int i = 0; i < n; ++i) { - assert(pmi->palette_colors[i] < (1 << cm->bit_depth)); - aom_write_literal(w, pmi->palette_colors[i], cm->bit_depth); - } -#endif // CONFIG_PALETTE_DELTA_ENCODING } } - if (mbmi->uv_mode == UV_DC_PRED) { + const int uv_dc_pred = + num_planes > 1 && mbmi->uv_mode == UV_DC_PRED && + is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, + xd->plane[1].subsampling_y); + if (uv_dc_pred) { const int n = pmi->palette_size[1]; const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0); -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, n > 0, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2); -#else - aom_write(w, n > 0, av1_default_palette_uv_mode_prob[palette_uv_mode_ctx]); -#endif if (n > 0) { aom_write_symbol(w, n - PALETTE_MIN_SIZE, - xd->tile_ctx->palette_uv_size_cdf[block_palette_idx], + xd->tile_ctx->palette_uv_size_cdf[bsize_ctx], PALETTE_SIZES); -#if CONFIG_PALETTE_DELTA_ENCODING write_palette_colors_uv(xd, pmi, cm->bit_depth, w); -#else - for (int i = 0; i < n; ++i) { - assert(pmi->palette_colors[PALETTE_MAX_SIZE + i] < - (1 << cm->bit_depth)); - assert(pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] < - (1 << cm->bit_depth)); - aom_write_literal(w, pmi->palette_colors[PALETTE_MAX_SIZE + i], - cm->bit_depth); - aom_write_literal(w, pmi->palette_colors[2 * PALETTE_MAX_SIZE + i], - cm->bit_depth); - } -#endif // CONFIG_PALETTE_DELTA_ENCODING } } } void av1_write_tx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd, -#if CONFIG_SUPERTX - const int supertx_enabled, -#endif -#if CONFIG_TXK_SEL - int blk_row, int blk_col, int block, int plane, - TX_SIZE tx_size, -#endif + int blk_row, int blk_col, int plane, TX_SIZE tx_size, aom_writer *w) { - MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; + MB_MODE_INFO *mbmi = xd->mi[0]; const int is_inter = is_inter_block(mbmi); -#if !CONFIG_TXK_SEL -#if CONFIG_VAR_TX - const TX_SIZE tx_size = is_inter ? mbmi->min_tx_size : mbmi->tx_size; -#else - const TX_SIZE tx_size = mbmi->tx_size; -#endif // CONFIG_VAR_TX -#endif // !CONFIG_TXK_SEL FRAME_CONTEXT *ec_ctx = xd->tile_ctx; -#if !CONFIG_TXK_SEL - TX_TYPE tx_type = mbmi->tx_type; -#else // Only y plane's tx_type is transmitted if (plane > 0) return; PLANE_TYPE plane_type = get_plane_type(plane); - TX_TYPE tx_type = - av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, tx_size); -#endif - - if (!FIXED_TX_TYPE) { -#if CONFIG_EXT_TX - const TX_SIZE square_tx_size = txsize_sqr_map[tx_size]; - const BLOCK_SIZE bsize = mbmi->sb_type; - if (get_ext_tx_types(tx_size, bsize, is_inter, cm->reduced_tx_set_used) > - 1 && - ((!cm->seg.enabled && cm->base_qindex > 0) || - (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) && - !mbmi->skip && -#if CONFIG_SUPERTX - !supertx_enabled && -#endif // CONFIG_SUPERTX - !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { -#if CONFIG_MRC_TX - if (tx_type == MRC_DCT) - assert(mbmi->valid_mrc_mask && "Invalid MRC mask"); -#endif // CONFIG_MRC_TX - const TxSetType tx_set_type = get_ext_tx_set_type( - tx_size, bsize, is_inter, cm->reduced_tx_set_used); - const int eset = - get_ext_tx_set(tx_size, bsize, is_inter, cm->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); - assert(av1_ext_tx_used[tx_set_type][tx_type]); -#if !CONFIG_LGT_FROM_PRED - 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 (ALLOW_INTRA_EXT_TX) { - aom_write_symbol( - w, av1_ext_tx_ind[tx_set_type][tx_type], - ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode], - av1_num_ext_tx_set[tx_set_type]); - } -#else - // only signal tx_type when lgt is not allowed or not selected - if (is_inter) { - if (LGT_FROM_PRED_INTER) { - if (is_lgt_allowed(mbmi->mode, tx_size) && !cm->reduced_tx_set_used) - aom_write(w, mbmi->use_lgt, ec_ctx->inter_lgt_prob[square_tx_size]); - if (!mbmi->use_lgt) - 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 { - 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 (ALLOW_INTRA_EXT_TX) { - if (LGT_FROM_PRED_INTRA) { - if (is_lgt_allowed(mbmi->mode, tx_size) && !cm->reduced_tx_set_used) - aom_write(w, mbmi->use_lgt, - ec_ctx->intra_lgt_prob[square_tx_size][mbmi->mode]); - if (!mbmi->use_lgt) - aom_write_symbol( - w, av1_ext_tx_ind[tx_set_type][tx_type], - ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode], - av1_num_ext_tx_set[tx_set_type]); - } else { - aom_write_symbol( - w, av1_ext_tx_ind[tx_set_type][tx_type], - ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode], - av1_num_ext_tx_set[tx_set_type]); - } - } -#endif // CONFIG_LGT_FROM_PRED - } -#else // CONFIG_EXT_TX - if (tx_size < TX_32X32 && - ((!cm->seg.enabled && cm->base_qindex > 0) || - (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) && - !mbmi->skip && -#if CONFIG_SUPERTX - !supertx_enabled && -#endif // CONFIG_SUPERTX - !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { - if (is_inter) { - aom_write_symbol(w, av1_ext_tx_ind[tx_type], - ec_ctx->inter_ext_tx_cdf[tx_size], TX_TYPES); - } else { - aom_write_symbol( - w, av1_ext_tx_ind[tx_type], - ec_ctx->intra_ext_tx_cdf[tx_size] - [intra_mode_to_tx_type_context[mbmi->mode]], - TX_TYPES); - } + TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, blk_row, blk_col, tx_size, + cm->reduced_tx_set_used); + + const TX_SIZE square_tx_size = txsize_sqr_map[tx_size]; + if (get_ext_tx_types(tx_size, is_inter, cm->reduced_tx_set_used) > 1 && + ((!cm->seg.enabled && cm->base_qindex > 0) || + (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) && + !mbmi->skip && + !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { + const TxSetType tx_set_type = + av1_get_ext_tx_set_type(tx_size, is_inter, cm->reduced_tx_set_used); + const int eset = get_ext_tx_set(tx_size, is_inter, cm->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); + assert(av1_ext_tx_used[tx_set_type][tx_type]); + 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 { + 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; + aom_write_symbol( + w, av1_ext_tx_ind[tx_set_type][tx_type], + ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_dir], + av1_num_ext_tx_set[tx_set_type]); } -#endif // CONFIG_EXT_TX } } @@ -1658,14 +844,12 @@ static void write_intra_mode(FRAME_CONTEXT *frame_ctx, BLOCK_SIZE bsize, static void write_intra_uv_mode(FRAME_CONTEXT *frame_ctx, UV_PREDICTION_MODE uv_mode, - PREDICTION_MODE y_mode, aom_writer *w) { -#if !CONFIG_CFL - uv_mode = get_uv_mode(uv_mode); -#endif - aom_write_symbol(w, uv_mode, frame_ctx->uv_mode_cdf[y_mode], UV_INTRA_MODES); + 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); } -#if CONFIG_CFL static void write_cfl_alphas(FRAME_CONTEXT *const ec_ctx, int idx, int joint_sign, aom_writer *w) { aom_write_symbol(w, joint_sign, ec_ctx->cfl_sign_cdf, CFL_JOINT_SIGNS); @@ -1679,23 +863,85 @@ static void write_cfl_alphas(FRAME_CONTEXT *const ec_ctx, int idx, aom_write_symbol(w, CFL_IDX_V(idx), cdf_v, CFL_ALPHABET_SIZE); } } -#endif + +static void write_cdef(AV1_COMMON *cm, MACROBLOCKD *const xd, aom_writer *w, + int skip, int mi_col, int mi_row) { + if (cm->coded_lossless || cm->allow_intrabc) { + // Initialize to indicate no CDEF for safety. + cm->cdef_bits = 0; + cm->cdef_strengths[0] = 0; + cm->nb_cdef_strengths = 1; + cm->cdef_uv_strengths[0] = 0; + return; + } + + const int m = ~((1 << (6 - MI_SIZE_LOG2)) - 1); + const MB_MODE_INFO *mbmi = + cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]; + // Initialise when at top left part of the superblock + if (!(mi_row & (cm->seq_params.mib_size - 1)) && + !(mi_col & (cm->seq_params.mib_size - 1))) { // Top left? + xd->cdef_preset[0] = xd->cdef_preset[1] = xd->cdef_preset[2] = + xd->cdef_preset[3] = -1; + } + + // Emit CDEF param at first non-skip coding block + const int mask = 1 << (6 - MI_SIZE_LOG2); + const int index = cm->seq_params.sb_size == BLOCK_128X128 + ? !!(mi_col & mask) + 2 * !!(mi_row & mask) + : 0; + if (xd->cdef_preset[index] == -1 && !skip) { + aom_write_literal(w, mbmi->cdef_strength, cm->cdef_bits); + xd->cdef_preset[index] = mbmi->cdef_strength; + } +} + +static void write_inter_segment_id(AV1_COMP *cpi, aom_writer *w, + const struct segmentation *const seg, + struct segmentation_probs *const segp, + int mi_row, int mi_col, int skip, + int preskip) { + MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; + const MB_MODE_INFO *const mbmi = xd->mi[0]; + AV1_COMMON *const cm = &cpi->common; + + 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, mi_row, mi_col, 1); + if (seg->temporal_update) ((MB_MODE_INFO *)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, mi_row, mi_col, 0); + } + if (pred_flag) { + set_spatial_segment_id(cm, cm->current_frame_seg_map, mbmi->sb_type, + mi_row, mi_col, mbmi->segment_id); + } + } else { + write_segment_id(cpi, mbmi, w, seg, segp, mi_row, mi_col, 0); + } + } +} static void pack_inter_mode_mvs(AV1_COMP *cpi, const int mi_row, - const int mi_col, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif - aom_writer *w) { + const int mi_col, 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 MODE_INFO *mi = xd->mi[0]; - const struct segmentation *const seg = &cm->seg; struct segmentation_probs *const segp = &ec_ctx->seg; - const MB_MODE_INFO *const mbmi = &mi->mbmi; + const MB_MODE_INFO *const mbmi = xd->mi[0]; const MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext; const PREDICTION_MODE mode = mbmi->mode; const int segment_id = mbmi->segment_id; @@ -1704,595 +950,323 @@ static void pack_inter_mode_mvs(AV1_COMP *cpi, const int mi_row, const int is_inter = is_inter_block(mbmi); const int is_compound = has_second_ref(mbmi); int skip, ref; -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif (void)mi_row; (void)mi_col; - if (seg->update_map) { - if (seg->temporal_update) { - const int pred_flag = mbmi->seg_id_predicted; -#if CONFIG_NEW_MULTISYMBOL - aom_cdf_prob *pred_cdf = av1_get_pred_cdf_seg_id(segp, xd); - aom_write_symbol(w, pred_flag, pred_cdf, 2); -#else - aom_prob pred_prob = av1_get_pred_prob_seg_id(segp, xd); - aom_write(w, pred_flag, pred_prob); -#endif - if (!pred_flag) write_segment_id(w, seg, segp, segment_id); - } else { - write_segment_id(w, seg, segp, segment_id); - } - } + write_inter_segment_id(cpi, w, seg, segp, mi_row, mi_col, 0, 1); + + write_skip_mode(cm, xd, segment_id, mbmi, w); + + assert(IMPLIES(mbmi->skip_mode, mbmi->skip)); + skip = mbmi->skip_mode ? 1 : write_skip(cm, xd, segment_id, mbmi, w); + + write_inter_segment_id(cpi, w, seg, segp, mi_row, mi_col, skip, 0); + + write_cdef(cm, xd, w, skip, mi_col, mi_row); -#if CONFIG_SUPERTX - if (supertx_enabled) - skip = mbmi->skip; - else - skip = write_skip(cm, xd, segment_id, mi, w); -#else - skip = write_skip(cm, xd, segment_id, mi, w); -#endif // CONFIG_SUPERTX if (cm->delta_q_present_flag) { int super_block_upper_left = - ((mi_row & MAX_MIB_MASK) == 0) && ((mi_col & MAX_MIB_MASK) == 0); - if ((bsize != BLOCK_LARGEST || skip == 0) && super_block_upper_left) { - assert(mbmi->current_q_index > 0); + ((mi_row & (cm->seq_params.mib_size - 1)) == 0) && + ((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); int reduced_delta_qindex = - (mbmi->current_q_index - xd->prev_qindex) / cm->delta_q_res; - write_delta_qindex(cm, xd, reduced_delta_qindex, w); - xd->prev_qindex = mbmi->current_q_index; -#if CONFIG_EXT_DELTA_Q -#if CONFIG_LOOPFILTER_LEVEL + (mbmi->current_qindex - xd->current_qindex) / cm->delta_q_res; + write_delta_qindex(xd, reduced_delta_qindex, w); + xd->current_qindex = mbmi->current_qindex; if (cm->delta_lf_present_flag) { if (cm->delta_lf_multi) { - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) { + 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->curr_delta_lf[lf_id] - xd->prev_delta_lf[lf_id]) / + (mbmi->delta_lf[lf_id] - xd->delta_lf[lf_id]) / cm->delta_lf_res; write_delta_lflevel(cm, xd, lf_id, reduced_delta_lflevel, w); - xd->prev_delta_lf[lf_id] = mbmi->curr_delta_lf[lf_id]; + xd->delta_lf[lf_id] = mbmi->delta_lf[lf_id]; } } else { int reduced_delta_lflevel = - (mbmi->current_delta_lf_from_base - xd->prev_delta_lf_from_base) / + (mbmi->delta_lf_from_base - xd->delta_lf_from_base) / cm->delta_lf_res; write_delta_lflevel(cm, xd, -1, reduced_delta_lflevel, w); - xd->prev_delta_lf_from_base = mbmi->current_delta_lf_from_base; + xd->delta_lf_from_base = mbmi->delta_lf_from_base; } } -#else - if (cm->delta_lf_present_flag) { - int reduced_delta_lflevel = - (mbmi->current_delta_lf_from_base - xd->prev_delta_lf_from_base) / - cm->delta_lf_res; - write_delta_lflevel(cm, xd, reduced_delta_lflevel, w); - xd->prev_delta_lf_from_base = mbmi->current_delta_lf_from_base; - } -#endif // CONFIG_LOOPFILTER_LEVEL -#endif // CONFIG_EXT_DELTA_Q } } -#if CONFIG_SUPERTX - if (!supertx_enabled) -#endif // CONFIG_SUPERTX - write_is_inter(cm, xd, mbmi->segment_id, w, is_inter); + if (!mbmi->skip_mode) write_is_inter(cm, xd, mbmi->segment_id, w, is_inter); - if (cm->tx_mode == TX_MODE_SELECT && -#if CONFIG_CB4X4 && CONFIG_VAR_TX && !CONFIG_RECT_TX - (bsize >= BLOCK_8X8 || (bsize > BLOCK_4X4 && is_inter)) && -#else - block_signals_txsize(bsize) && -#endif -#if CONFIG_SUPERTX - !supertx_enabled && -#endif // CONFIG_SUPERTX - !(is_inter && skip) && !xd->lossless[segment_id]) { -#if CONFIG_VAR_TX - if (is_inter) { // This implies skip flag is 0. - const TX_SIZE max_tx_size = get_vartx_max_txsize(mbmi, bsize, 0); - const int bh = tx_size_high_unit[max_tx_size]; - const int bw = tx_size_wide_unit[max_tx_size]; - const int width = block_size_wide[bsize] >> tx_size_wide_log2[0]; - const int height = block_size_high[bsize] >> tx_size_wide_log2[0]; - int init_depth = - (height != width) ? RECT_VARTX_DEPTH_INIT : SQR_VARTX_DEPTH_INIT; - int idx, idy; - for (idy = 0; idy < height; idy += bh) - for (idx = 0; idx < width; idx += bw) - write_tx_size_vartx(cm, xd, mbmi, max_tx_size, init_depth, idy, idx, - w); -#if CONFIG_RECT_TX_EXT - if (is_quarter_tx_allowed(xd, mbmi, is_inter_block(mbmi)) && - quarter_txsize_lookup[bsize] != max_tx_size && - (mbmi->tx_size == quarter_txsize_lookup[bsize] || - mbmi->tx_size == max_tx_size)) { -#if CONFIG_NEW_MULTISYMBOL - aom_write_symbol(w, mbmi->tx_size != max_tx_size, - cm->fc->quarter_tx_size_cdf, 2); -#else - aom_write(w, mbmi->tx_size != max_tx_size, - cm->fc->quarter_tx_size_prob); -#endif - } -#endif - } else { - set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, skip, xd); - write_selected_tx_size(cm, xd, w); - } - } else { - set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, skip, xd); -#else - write_selected_tx_size(cm, xd, w); -#endif - } + if (mbmi->skip_mode) return; if (!is_inter) { - if (bsize >= BLOCK_8X8 || unify_bsize) { - write_intra_mode(ec_ctx, bsize, mode, w); - } else { - int idx, idy; - const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize]; - const int num_4x4_h = num_4x4_blocks_high_lookup[bsize]; - for (idy = 0; idy < 2; idy += num_4x4_h) { - for (idx = 0; idx < 2; idx += num_4x4_w) { - const PREDICTION_MODE b_mode = mi->bmi[idy * 2 + idx].as_mode; - write_intra_mode(ec_ctx, bsize, b_mode, w); - } - } + write_intra_mode(ec_ctx, bsize, mode, w); + const int use_angle_delta = av1_use_angle_delta(bsize); + + if (use_angle_delta && av1_is_directional_mode(mode)) { + write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_Y], + ec_ctx->angle_delta_cdf[mode - V_PRED]); } -#if CONFIG_CB4X4 - if (is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y)) { - write_intra_uv_mode(ec_ctx, mbmi->uv_mode, mode, w); -#else // !CONFIG_CB4X4 - write_intra_uv_mode(ec_ctx, mbmi->uv_mode, mode, w); -#endif // CONFIG_CB4X4 -#if CONFIG_CFL - if (mbmi->uv_mode == UV_CFL_PRED) { + if (!cm->seq_params.monochrome && + is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, + xd->plane[1].subsampling_y)) { + const UV_PREDICTION_MODE uv_mode = mbmi->uv_mode; + write_intra_uv_mode(ec_ctx, uv_mode, mode, is_cfl_allowed(xd), w); + if (uv_mode == UV_CFL_PRED) write_cfl_alphas(ec_ctx, mbmi->cfl_alpha_idx, mbmi->cfl_alpha_signs, w); + if (use_angle_delta && av1_is_directional_mode(get_uv_mode(uv_mode))) { + write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_UV], + ec_ctx->angle_delta_cdf[uv_mode - V_PRED]); } -#endif - -#if CONFIG_CB4X4 } -#endif -#if CONFIG_EXT_INTRA - write_intra_angle_info(xd, ec_ctx, w); -#endif // CONFIG_EXT_INTRA if (av1_allow_palette(cm->allow_screen_content_tools, bsize)) - write_palette_mode_info(cm, xd, mi, w); -#if CONFIG_FILTER_INTRA - if (bsize >= BLOCK_8X8 || unify_bsize) - write_filter_intra_mode_info(cm, xd, mbmi, mi_row, mi_col, w); -#endif // CONFIG_FILTER_INTRA + write_palette_mode_info(cm, xd, mbmi, mi_row, mi_col, w); + + write_filter_intra_mode_info(cm, xd, mbmi, w); } else { int16_t mode_ctx; - write_ref_frames(cm, xd, w); -#if CONFIG_COMPOUND_SINGLEREF - if (!segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME)) { - // NOTE: Handle single ref comp mode - if (!is_compound) - aom_write(w, is_inter_singleref_comp_mode(mode), - av1_get_inter_mode_prob(cm, xd)); - } -#endif // CONFIG_COMPOUND_SINGLEREF - -#if CONFIG_COMPOUND_SINGLEREF - if (is_compound || is_inter_singleref_comp_mode(mode)) -#else // !CONFIG_COMPOUND_SINGLEREF - if (is_compound) -#endif // CONFIG_COMPOUND_SINGLEREF - mode_ctx = mbmi_ext->compound_mode_context[mbmi->ref_frame[0]]; - else + av1_collect_neighbors_ref_counts(xd); - mode_ctx = av1_mode_context_analyzer(mbmi_ext->mode_context, - mbmi->ref_frame, bsize, -1); + write_ref_frames(cm, xd, w); + + mode_ctx = + av1_mode_context_analyzer(mbmi_ext->mode_context, mbmi->ref_frame); // If segment skip is not enabled code the mode. if (!segfeature_active(seg, segment_id, SEG_LVL_SKIP)) { - if (bsize >= BLOCK_8X8 || unify_bsize) { - if (is_inter_compound_mode(mode)) - write_inter_compound_mode(cm, xd, w, mode, mode_ctx); -#if CONFIG_COMPOUND_SINGLEREF - else if (is_inter_singleref_comp_mode(mode)) - write_inter_singleref_comp_mode(xd, w, mode, mode_ctx); -#endif // CONFIG_COMPOUND_SINGLEREF - else if (is_inter_singleref_mode(mode)) - write_inter_mode(w, mode, ec_ctx, mode_ctx); - - if (mode == NEWMV || mode == NEW_NEWMV || -#if CONFIG_COMPOUND_SINGLEREF - mbmi->mode == SR_NEW_NEWMV || -#endif // CONFIG_COMPOUND_SINGLEREF - have_nearmv_in_inter_mode(mode)) - write_drl_idx(ec_ctx, mbmi, mbmi_ext, w); - else - assert(mbmi->ref_mv_idx == 0); - } + if (is_inter_compound_mode(mode)) + write_inter_compound_mode(xd, w, mode, mode_ctx); + else if (is_inter_singleref_mode(mode)) + write_inter_mode(w, mode, ec_ctx, mode_ctx); + + if (mode == NEWMV || mode == NEW_NEWMV || have_nearmv_in_inter_mode(mode)) + write_drl_idx(ec_ctx, mbmi, mbmi_ext, w); + else + assert(mbmi->ref_mv_idx == 0); } -#if !CONFIG_DUAL_FILTER && !CONFIG_WARPED_MOTION && !CONFIG_GLOBAL_MOTION - write_mb_interp_filter(cpi, xd, w); -#endif // !CONFIG_DUAL_FILTER && !CONFIG_WARPED_MOTION - - if (bsize < BLOCK_8X8 && !unify_bsize) { -#if CONFIG_COMPOUND_SINGLEREF - /// NOTE: Single ref comp mode does not support sub8x8. - assert(is_compound || !is_inter_singleref_comp_mode(mbmi->mode)); -#endif // CONFIG_COMPOUND_SINGLEREF - const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize]; - const int num_4x4_h = num_4x4_blocks_high_lookup[bsize]; - int idx, idy; - for (idy = 0; idy < 2; idy += num_4x4_h) { - for (idx = 0; idx < 2; idx += num_4x4_w) { - const int j = idy * 2 + idx; - const PREDICTION_MODE b_mode = mi->bmi[j].as_mode; - if (!is_compound) - mode_ctx = av1_mode_context_analyzer(mbmi_ext->mode_context, - mbmi->ref_frame, bsize, j); - if (is_inter_compound_mode(b_mode)) - write_inter_compound_mode(cm, xd, w, b_mode, mode_ctx); - else if (is_inter_singleref_mode(b_mode)) - write_inter_mode(w, b_mode, ec_ctx, mode_ctx); - - if (b_mode == NEWMV || b_mode == NEW_NEWMV) { - for (ref = 0; ref < 1 + is_compound; ++ref) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type], - mbmi_ext->ref_mv_stack[rf_type], ref, - mbmi->ref_mv_idx); - nmv_context *nmvc = &ec_ctx->nmvc[nmv_ctx]; - av1_encode_mv(cpi, w, &mi->bmi[j].as_mv[ref].as_mv, - &mi->bmi[j].ref_mv[ref].as_mv, nmvc, allow_hp); - } - } else if (b_mode == NEAREST_NEWMV || b_mode == NEAR_NEWMV) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type], - mbmi_ext->ref_mv_stack[rf_type], 1, - mbmi->ref_mv_idx); - nmv_context *nmvc = &ec_ctx->nmvc[nmv_ctx]; - av1_encode_mv(cpi, w, &mi->bmi[j].as_mv[1].as_mv, - &mi->bmi[j].ref_mv[1].as_mv, nmvc, allow_hp); - } else if (b_mode == NEW_NEARESTMV || b_mode == NEW_NEARMV) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type], - mbmi_ext->ref_mv_stack[rf_type], 0, - mbmi->ref_mv_idx); - nmv_context *nmvc = &ec_ctx->nmvc[nmv_ctx]; - av1_encode_mv(cpi, w, &mi->bmi[j].as_mv[0].as_mv, - &mi->bmi[j].ref_mv[0].as_mv, nmvc, allow_hp); - } - } - } - } else { - if (mode == NEWMV || mode == NEW_NEWMV) { - int_mv ref_mv; - for (ref = 0; ref < 1 + is_compound; ++ref) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type], - mbmi_ext->ref_mv_stack[rf_type], ref, - mbmi->ref_mv_idx); - nmv_context *nmvc = &ec_ctx->nmvc[nmv_ctx]; - ref_mv = mbmi_ext->ref_mvs[mbmi->ref_frame[ref]][0]; - av1_encode_mv(cpi, w, &mbmi->mv[ref].as_mv, &ref_mv.as_mv, nmvc, - allow_hp); - } - } else if (mode == NEAREST_NEWMV || mode == NEAR_NEWMV) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = - av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type], - mbmi_ext->ref_mv_stack[rf_type], 1, mbmi->ref_mv_idx); - nmv_context *nmvc = &ec_ctx->nmvc[nmv_ctx]; - av1_encode_mv(cpi, w, &mbmi->mv[1].as_mv, - &mbmi_ext->ref_mvs[mbmi->ref_frame[1]][0].as_mv, nmvc, - allow_hp); - } else if (mode == NEW_NEARESTMV || mode == NEW_NEARMV) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = - av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type], - mbmi_ext->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx); - nmv_context *nmvc = &ec_ctx->nmvc[nmv_ctx]; - av1_encode_mv(cpi, w, &mbmi->mv[0].as_mv, - &mbmi_ext->ref_mvs[mbmi->ref_frame[0]][0].as_mv, nmvc, + if (mode == NEWMV || mode == NEW_NEWMV) { + for (ref = 0; ref < 1 + is_compound; ++ref) { + nmv_context *nmvc = &ec_ctx->nmvc; + const int_mv ref_mv = av1_get_ref_mv(x, ref); + av1_encode_mv(cpi, w, &mbmi->mv[ref].as_mv, &ref_mv.as_mv, nmvc, allow_hp); -#if CONFIG_COMPOUND_SINGLEREF - } else if ( // mode == SR_NEAREST_NEWMV || - mode == SR_NEAR_NEWMV || mode == SR_ZERO_NEWMV || - mode == SR_NEW_NEWMV) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = - av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type], - mbmi_ext->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx); - nmv_context *nmvc = &ec_ctx->nmvc[nmv_ctx]; - int_mv ref_mv = mbmi_ext->ref_mvs[mbmi->ref_frame[0]][0]; - if (mode == SR_NEW_NEWMV) - av1_encode_mv(cpi, w, &mbmi->mv[0].as_mv, &ref_mv.as_mv, nmvc, - allow_hp); - av1_encode_mv(cpi, w, &mbmi->mv[1].as_mv, &ref_mv.as_mv, nmvc, - allow_hp); -#endif // CONFIG_COMPOUND_SINGLEREF } + } else if (mode == NEAREST_NEWMV || mode == NEAR_NEWMV) { + nmv_context *nmvc = &ec_ctx->nmvc; + const int_mv ref_mv = av1_get_ref_mv(x, 1); + av1_encode_mv(cpi, w, &mbmi->mv[1].as_mv, &ref_mv.as_mv, nmvc, allow_hp); + } else if (mode == NEW_NEARESTMV || mode == NEW_NEARMV) { + nmv_context *nmvc = &ec_ctx->nmvc; + const int_mv ref_mv = av1_get_ref_mv(x, 0); + av1_encode_mv(cpi, w, &mbmi->mv[0].as_mv, &ref_mv.as_mv, nmvc, allow_hp); } -#if CONFIG_INTERINTRA if (cpi->common.reference_mode != COMPOUND_REFERENCE && -#if CONFIG_SUPERTX - !supertx_enabled && -#endif // CONFIG_SUPERTX - cpi->common.allow_interintra_compound && is_interintra_allowed(mbmi)) { + 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]; -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, interintra, ec_ctx->interintra_cdf[bsize_group], 2); -#else - aom_write(w, interintra, cm->fc->interintra_prob[bsize_group]); -#endif if (interintra) { aom_write_symbol(w, mbmi->interintra_mode, ec_ctx->interintra_mode_cdf[bsize_group], INTERINTRA_MODES); if (is_interintra_wedge_used(bsize)) { -#if CONFIG_NEW_MULTISYMBOL aom_write_symbol(w, mbmi->use_wedge_interintra, ec_ctx->wedge_interintra_cdf[bsize], 2); -#else - aom_write(w, mbmi->use_wedge_interintra, - cm->fc->wedge_interintra_prob[bsize]); -#endif if (mbmi->use_wedge_interintra) { - aom_write_literal(w, mbmi->interintra_wedge_index, - get_wedge_bits_lookup(bsize)); + aom_write_symbol(w, mbmi->interintra_wedge_index, + ec_ctx->wedge_idx_cdf[bsize], 16); assert(mbmi->interintra_wedge_sign == 0); } } } } -#endif // CONFIG_INTERINTRA - -#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION -#if CONFIG_SUPERTX - if (!supertx_enabled) -#endif // CONFIG_SUPERTX - if (mbmi->ref_frame[1] != INTRA_FRAME) write_motion_mode(cm, xd, mi, w); -#if CONFIG_NCOBMC_ADAPT_WEIGHT - write_ncobmc_mode(xd, mi, w); -#endif -#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION - - if ( -#if CONFIG_COMPOUND_SINGLEREF - is_inter_anyref_comp_mode(mbmi->mode) && -#else // !CONFIG_COMPOUND_SINGLEREF - cpi->common.reference_mode != SINGLE_REFERENCE && - is_inter_compound_mode(mbmi->mode) && -#endif // CONFIG_COMPOUND_SINGLEREF -#if CONFIG_MOTION_VAR - mbmi->motion_mode == SIMPLE_TRANSLATION && -#endif // CONFIG_MOTION_VAR - is_any_masked_compound_used(bsize)) { -#if CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE - if (cm->allow_masked_compound) { -#if CONFIG_WEDGE && CONFIG_COMPOUND_SEGMENT - if (!is_interinter_compound_used(COMPOUND_WEDGE, bsize)) - aom_write_bit(w, mbmi->interinter_compound_type == COMPOUND_AVERAGE); - else -#endif // CONFIG_WEDGE && CONFIG_COMPOUND_SEGMENT - aom_write_symbol(w, mbmi->interinter_compound_type, - ec_ctx->compound_type_cdf[bsize], COMPOUND_TYPES); -#if CONFIG_WEDGE - if (is_interinter_compound_used(COMPOUND_WEDGE, bsize) && - mbmi->interinter_compound_type == COMPOUND_WEDGE) { - aom_write_literal(w, mbmi->wedge_index, get_wedge_bits_lookup(bsize)); - aom_write_bit(w, mbmi->wedge_sign); + + if (mbmi->ref_frame[1] != INTRA_FRAME) write_motion_mode(cm, xd, mbmi, w); + + // First write idx to indicate current compound inter prediction mode group + // Group A (0): jnt_comp, compound_average + // Group B (1): interintra, compound_diffwtd, wedge + if (has_second_ref(mbmi)) { + 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(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) { + if (mbmi->compound_idx) + assert(mbmi->interinter_comp.type == COMPOUND_AVERAGE); + + if (cm->seq_params.enable_jnt_comp) { + const int comp_index_ctx = get_comp_index_context(cm, xd); + aom_write_symbol(w, mbmi->compound_idx, + ec_ctx->compound_index_cdf[comp_index_ctx], 2); + } else { + assert(mbmi->compound_idx == 1); } -#endif // CONFIG_WEDGE -#if CONFIG_COMPOUND_SEGMENT - if (mbmi->interinter_compound_type == COMPOUND_SEG) { - aom_write_literal(w, mbmi->mask_type, MAX_SEG_MASK_BITS); + } else { + assert(cpi->common.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 - 1, + ec_ctx->compound_type_cdf[bsize], + COMPOUND_TYPES - 1); + + if (mbmi->interinter_comp.type == COMPOUND_WEDGE) { + assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize)); + aom_write_symbol(w, mbmi->interinter_comp.wedge_index, + ec_ctx->wedge_idx_cdf[bsize], 16); + 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); } -#endif // CONFIG_COMPOUND_SEGMENT } -#endif // CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE } -#if CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION write_mb_interp_filter(cpi, xd, w); -#endif // CONFIG_DUAL_FILTE || CONFIG_WARPED_MOTION } +} -#if !CONFIG_TXK_SEL - av1_write_tx_type(cm, xd, -#if CONFIG_SUPERTX - supertx_enabled, -#endif - w); -#endif // !CONFIG_TXK_SEL +static void write_intrabc_info(MACROBLOCKD *xd, + const MB_MODE_INFO_EXT *mbmi_ext, + aom_writer *w) { + const MB_MODE_INFO *const mbmi = xd->mi[0]; + int use_intrabc = is_intrabc_block(mbmi); + FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf, 2); + if (use_intrabc) { + assert(mbmi->mode == DC_PRED); + assert(mbmi->uv_mode == UV_DC_PRED); + assert(mbmi->motion_mode == SIMPLE_TRANSLATION); + int_mv dv_ref = mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv; + av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc); + } } -static void write_mb_modes_kf(AV1_COMMON *cm, MACROBLOCKD *xd, -#if CONFIG_INTRABC +static void write_mb_modes_kf(AV1_COMP *cpi, MACROBLOCKD *xd, const MB_MODE_INFO_EXT *mbmi_ext, -#endif // CONFIG_INTRABC const int mi_row, const int mi_col, 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 MODE_INFO *const mi = xd->mi[0]; - const MODE_INFO *const above_mi = xd->above_mi; - const MODE_INFO *const left_mi = xd->left_mi; - const MB_MODE_INFO *const mbmi = &mi->mbmi; + const MB_MODE_INFO *const above_mi = xd->above_mbmi; + const MB_MODE_INFO *const left_mi = xd->left_mbmi; + const MB_MODE_INFO *const mbmi = xd->mi[0]; const BLOCK_SIZE bsize = mbmi->sb_type; -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif - (void)mi_row; - (void)mi_col; + const PREDICTION_MODE mode = mbmi->mode; + + if (seg->segid_preskip && seg->update_map) + write_segment_id(cpi, mbmi, w, seg, segp, mi_row, mi_col, 0); - if (seg->update_map) write_segment_id(w, seg, segp, mbmi->segment_id); + 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, mi_row, mi_col, skip); + + write_cdef(cm, xd, w, skip, mi_col, mi_row); - const int skip = write_skip(cm, xd, mbmi->segment_id, mi, w); if (cm->delta_q_present_flag) { int super_block_upper_left = - ((mi_row & MAX_MIB_MASK) == 0) && ((mi_col & MAX_MIB_MASK) == 0); - if ((bsize != BLOCK_LARGEST || skip == 0) && super_block_upper_left) { - assert(mbmi->current_q_index > 0); + ((mi_row & (cm->seq_params.mib_size - 1)) == 0) && + ((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); int reduced_delta_qindex = - (mbmi->current_q_index - xd->prev_qindex) / cm->delta_q_res; - write_delta_qindex(cm, xd, reduced_delta_qindex, w); - xd->prev_qindex = mbmi->current_q_index; -#if CONFIG_EXT_DELTA_Q -#if CONFIG_LOOPFILTER_LEVEL + (mbmi->current_qindex - xd->current_qindex) / cm->delta_q_res; + write_delta_qindex(xd, reduced_delta_qindex, w); + xd->current_qindex = mbmi->current_qindex; if (cm->delta_lf_present_flag) { if (cm->delta_lf_multi) { - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) { + 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->curr_delta_lf[lf_id] - xd->prev_delta_lf[lf_id]) / + (mbmi->delta_lf[lf_id] - xd->delta_lf[lf_id]) / cm->delta_lf_res; write_delta_lflevel(cm, xd, lf_id, reduced_delta_lflevel, w); - xd->prev_delta_lf[lf_id] = mbmi->curr_delta_lf[lf_id]; + xd->delta_lf[lf_id] = mbmi->delta_lf[lf_id]; } } else { int reduced_delta_lflevel = - (mbmi->current_delta_lf_from_base - xd->prev_delta_lf_from_base) / + (mbmi->delta_lf_from_base - xd->delta_lf_from_base) / cm->delta_lf_res; write_delta_lflevel(cm, xd, -1, reduced_delta_lflevel, w); - xd->prev_delta_lf_from_base = mbmi->current_delta_lf_from_base; + xd->delta_lf_from_base = mbmi->delta_lf_from_base; } } -#else - if (cm->delta_lf_present_flag) { - int reduced_delta_lflevel = - (mbmi->current_delta_lf_from_base - xd->prev_delta_lf_from_base) / - cm->delta_lf_res; - write_delta_lflevel(cm, xd, reduced_delta_lflevel, w); - xd->prev_delta_lf_from_base = mbmi->current_delta_lf_from_base; - } -#endif // CONFIG_LOOPFILTER_LEVEL -#endif // CONFIG_EXT_DELTA_Q } } - int enable_tx_size = cm->tx_mode == TX_MODE_SELECT && - block_signals_txsize(bsize) && - !xd->lossless[mbmi->segment_id]; - -#if CONFIG_INTRABC - if (av1_allow_intrabc(bsize, cm)) { - int use_intrabc = is_intrabc_block(mbmi); - aom_write_symbol(w, use_intrabc, ec_ctx->intrabc_cdf, 2); - if (use_intrabc) { - assert(mbmi->mode == DC_PRED); - assert(mbmi->uv_mode == UV_DC_PRED); - if (enable_tx_size && !mbmi->skip) write_selected_tx_size(cm, xd, w); - int_mv dv_ref = mbmi_ext->ref_mvs[INTRA_FRAME][0]; - av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc); -#if CONFIG_EXT_TX && !CONFIG_TXK_SEL - av1_write_tx_type(cm, xd, -#if CONFIG_SUPERTX - 0, -#endif - w); -#endif // CONFIG_EXT_TX && !CONFIG_TXK_SEL - return; - } + if (av1_allow_intrabc(cm)) { + write_intrabc_info(xd, mbmi_ext, w); + if (is_intrabc_block(mbmi)) return; } -#endif // CONFIG_INTRABC - if (enable_tx_size) write_selected_tx_size(cm, xd, w); - if (bsize >= BLOCK_8X8 || unify_bsize) { - write_intra_mode_kf(cm, ec_ctx, mi, above_mi, left_mi, 0, mbmi->mode, w); - } else { - const int num_4x4_w = num_4x4_blocks_wide_lookup[bsize]; - const int num_4x4_h = num_4x4_blocks_high_lookup[bsize]; - int idx, idy; - - for (idy = 0; idy < 2; idy += num_4x4_h) { - for (idx = 0; idx < 2; idx += num_4x4_w) { - const int block = idy * 2 + idx; - write_intra_mode_kf(cm, ec_ctx, mi, above_mi, left_mi, block, - mi->bmi[block].as_mode, w); - } - } + write_intra_mode_kf(ec_ctx, mbmi, above_mi, left_mi, mode, w); + + const int use_angle_delta = av1_use_angle_delta(bsize); + if (use_angle_delta && av1_is_directional_mode(mode)) { + write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_Y], + ec_ctx->angle_delta_cdf[mode - V_PRED]); } -#if CONFIG_CB4X4 - if (is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, + if (!cm->seq_params.monochrome && + is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, xd->plane[1].subsampling_y)) { - write_intra_uv_mode(ec_ctx, mbmi->uv_mode, mbmi->mode, w); -#else // !CONFIG_CB4X4 - write_intra_uv_mode(ec_ctx, mbmi->uv_mode, mbmi->mode, w); -#endif // CONFIG_CB4X4 - -#if CONFIG_CFL - if (mbmi->uv_mode == UV_CFL_PRED) { + const UV_PREDICTION_MODE uv_mode = mbmi->uv_mode; + write_intra_uv_mode(ec_ctx, uv_mode, mode, is_cfl_allowed(xd), w); + if (uv_mode == UV_CFL_PRED) write_cfl_alphas(ec_ctx, mbmi->cfl_alpha_idx, mbmi->cfl_alpha_signs, w); + if (use_angle_delta && av1_is_directional_mode(get_uv_mode(uv_mode))) { + write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_UV], + ec_ctx->angle_delta_cdf[uv_mode - V_PRED]); } -#endif - -#if CONFIG_CB4X4 } -#endif -#if CONFIG_EXT_INTRA - write_intra_angle_info(xd, ec_ctx, w); -#endif // CONFIG_EXT_INTRA + if (av1_allow_palette(cm->allow_screen_content_tools, bsize)) - write_palette_mode_info(cm, xd, mi, w); -#if CONFIG_FILTER_INTRA - if (bsize >= BLOCK_8X8 || unify_bsize) - write_filter_intra_mode_info(cm, xd, mbmi, mi_row, mi_col, w); -#endif // CONFIG_FILTER_INTRA - -#if !CONFIG_TXK_SEL - av1_write_tx_type(cm, xd, -#if CONFIG_SUPERTX - 0, -#endif - w); -#endif // !CONFIG_TXK_SEL -} + write_palette_mode_info(cm, xd, mbmi, mi_row, mi_col, w); -#if CONFIG_SUPERTX -#define write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, \ - mi_row, mi_col) \ - write_modes_b(cpi, tile, w, tok, tok_end, supertx_enabled, mi_row, mi_col) -#else -#define write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, \ - mi_row, mi_col) \ - write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col) -#endif // CONFIG_SUPERTX + write_filter_intra_mode_info(cm, xd, mbmi, w); +} #if CONFIG_RD_DEBUG static void dump_mode_info(MODE_INFO *mi) { - printf("\nmi->mbmi.mi_row == %d\n", mi->mbmi.mi_row); - printf("&& mi->mbmi.mi_col == %d\n", mi->mbmi.mi_col); - printf("&& mi->mbmi.sb_type == %d\n", mi->mbmi.sb_type); - printf("&& mi->mbmi.tx_size == %d\n", mi->mbmi.tx_size); - if (mi->mbmi.sb_type >= BLOCK_8X8) { - printf("&& mi->mbmi.mode == %d\n", mi->mbmi.mode); - } else { - printf("&& mi->bmi[0].as_mode == %d\n", mi->bmi[0].as_mode); - } + printf("\nmi->mi_row == %d\n", mi->mi_row); + printf("&& mi->mi_col == %d\n", mi->mi_col); + printf("&& mi->sb_type == %d\n", mi->sb_type); + 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) { -#if CONFIG_VAR_TX int r, c; -#endif printf("\nplane %d rd_stats->txb_coeff_cost %d token_stats->cost %d\n", plane, rd_stats->txb_coeff_cost[plane], token_stats->cost); -#if CONFIG_VAR_TX 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) { @@ -2308,7 +1282,6 @@ static int rd_token_stats_mismatch(RD_STATS *rd_stats, TOKEN_STATS *token_stats, } printf("\n"); } -#endif return 1; } return 0; @@ -2319,128 +1292,139 @@ static int rd_token_stats_mismatch(RD_STATS *rd_stats, TOKEN_STATS *token_stats, static void enc_dump_logs(AV1_COMP *cpi, int mi_row, int mi_col) { AV1_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; - MODE_INFO *m; xd->mi = cm->mi_grid_visible + (mi_row * cm->mi_stride + mi_col); - m = xd->mi[0]; - if (is_inter_block(&m->mbmi)) { -#define FRAME_TO_CHECK 1 + const MB_MODE_INFO *const *mbmi = xd->mi[0]; + if (is_inter_block(mbmi)) { +#define FRAME_TO_CHECK 11 if (cm->current_video_frame == FRAME_TO_CHECK && cm->show_frame == 1) { - const MB_MODE_INFO *const mbmi = &m->mbmi; const BLOCK_SIZE bsize = mbmi->sb_type; int_mv mv[2]; - int is_comp_ref = has_second_ref(&m->mbmi); + int is_comp_ref = has_second_ref(mbmi); int ref; for (ref = 0; ref < 1 + is_comp_ref; ++ref) - mv[ref].as_mv = m->mbmi.mv[ref].as_mv; + mv[ref].as_mv = mbmi->mv[ref].as_mv; if (!is_comp_ref) { -#if CONFIG_COMPOUND_SINGLEREF - if (is_inter_singleref_comp_mode(m->mbmi.mode)) - mv[1].as_mv = m->mbmi.mv[1].as_mv; - else -#endif // CONFIG_COMPOUND_SINGLEREF - mv[1].as_int = 0; + mv[1].as_int = 0; } MACROBLOCK *const x = &cpi->td.mb; const MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext; - const int16_t mode_ctx = av1_mode_context_analyzer( - mbmi_ext->mode_context, mbmi->ref_frame, bsize, -1); + const int16_t mode_ctx = + is_comp_ref ? mbmi_ext->compound_mode_context[mbmi->ref_frame[0]] + : av1_mode_context_analyzer(mbmi_ext->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 >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK; - if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET)) { - assert(mbmi->mode == ZEROMV); - } - if (mbmi->mode != ZEROMV) { + zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK; + if (mbmi->mode != GLOBALMV) refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK; - if (mode_ctx & (1 << SKIP_NEARESTMV_OFFSET)) refmv_ctx = 6; - if (mode_ctx & (1 << SKIP_NEARMV_OFFSET)) refmv_ctx = 7; - if (mode_ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) refmv_ctx = 8; - } } - int8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); printf( "=== ENCODER ===: " - "Frame=%d, (mi_row,mi_col)=(%d,%d), mode=%d, bsize=%d, " + "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, inter_mode_ctx=%d, mode_ctx=%d, " - "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d\n", - cm->current_video_frame, mi_row, mi_col, 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, mbmi_ext->mode_context[ref_frame_type], mode_ctx, - newmv_ctx, zeromv_ctx, refmv_ctx); + "ref[1]=%d, motion_mode=%d, mode_ctx=%d, " + "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d, tx_size=%d\n", + cm->current_video_frame, 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 void write_mbmi_b(AV1_COMP *cpi, const TileInfo *const tile, - aom_writer *w, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif - int mi_row, int mi_col) { + aom_writer *w, int mi_row, int mi_col) { AV1_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; - MODE_INFO *m; int bh, bw; xd->mi = cm->mi_grid_visible + (mi_row * cm->mi_stride + mi_col); - m = xd->mi[0]; + MB_MODE_INFO *m = xd->mi[0]; - assert(m->mbmi.sb_type <= cm->sb_size || - (m->mbmi.sb_type >= BLOCK_SIZES && m->mbmi.sb_type < BLOCK_SIZES_ALL)); + assert(m->sb_type <= cm->seq_params.sb_size || + (m->sb_type >= BLOCK_SIZES && m->sb_type < BLOCK_SIZES_ALL)); - bh = mi_size_high[m->mbmi.sb_type]; - bw = mi_size_wide[m->mbmi.sb_type]; + bh = mi_size_high[m->sb_type]; + bw = mi_size_wide[m->sb_type]; cpi->td.mb.mbmi_ext = cpi->mbmi_ext_base + (mi_row * cm->mi_cols + mi_col); - set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); + set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols); + + xd->above_txfm_context = cm->above_txfm_context[tile->tile_row] + mi_col; + xd->left_txfm_context = + xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); if (frame_is_intra_only(cm)) { - write_mb_modes_kf(cm, xd, -#if CONFIG_INTRABC - cpi->td.mb.mbmi_ext, -#endif // CONFIG_INTRABC - mi_row, mi_col, w); + write_mb_modes_kf(cpi, xd, cpi->td.mb.mbmi_ext, mi_row, mi_col, w); } else { -#if CONFIG_VAR_TX - xd->above_txfm_context = - cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2); - xd->left_txfm_context = xd->left_txfm_context_buffer + - ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2); -#endif -#if CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION // 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->mbmi.ref_frame[0], m->mbmi.ref_frame[1]); -#if CONFIG_COMPOUND_SINGLEREF - if (!has_second_ref(&m->mbmi) && is_inter_singleref_comp_mode(m->mbmi.mode)) - xd->block_refs[1] = xd->block_refs[0]; -#endif // CONFIG_COMPOUND_SINGLEREF -#endif // CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION + set_ref_ptrs(cm, xd, m->ref_frame[0], m->ref_frame[1]); #if ENC_MISMATCH_DEBUG enc_dump_logs(cpi, mi_row, mi_col); #endif // ENC_MISMATCH_DEBUG - pack_inter_mode_mvs(cpi, mi_row, mi_col, -#if CONFIG_SUPERTX - supertx_enabled, -#endif - w); + pack_inter_mode_mvs(cpi, mi_row, mi_col, w); + } +} + +static 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 BLOCK_SIZE bsize = mbmi->sb_type; + const BLOCK_SIZE bsizec = + scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y); + + const BLOCK_SIZE plane_bsize = + get_plane_block_size(bsizec, pd->subsampling_x, pd->subsampling_y); + + 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, pd->subsampling_x, pd->subsampling_y); + int mu_blocks_wide = block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0]; + int mu_blocks_high = block_size_high[max_unit_bsize] >> tx_size_high_log2[0]; + + int blk_row, blk_col; + + const int num_4x4_w = block_size_wide[plane_bsize] >> tx_size_wide_log2[0]; + const int num_4x4_h = block_size_high[plane_bsize] >> tx_size_high_log2[0]; + + const int unit_height = + AOMMIN(mu_blocks_high + (row >> pd->subsampling_y), num_4x4_h); + const int unit_width = + AOMMIN(mu_blocks_wide + (col >> pd->subsampling_x), num_4x4_w); + for (blk_row = row >> pd->subsampling_y; blk_row < unit_height; + blk_row += bkh) { + for (blk_col = col >> pd->subsampling_x; blk_col < unit_width; + blk_col += bkw) { + pack_txb_tokens(w, cm, x, tok, tok_end, xd, mbmi, plane, plane_bsize, + cm->bit_depth, *block, blk_row, blk_col, max_tx_size, + token_stats); + *block += step; + } } } @@ -2449,167 +1433,48 @@ static void write_tokens_b(AV1_COMP *cpi, const TileInfo *const tile, const TOKENEXTRA *const tok_end, int mi_row, int mi_col) { AV1_COMMON *const cm = &cpi->common; + const int num_planes = av1_num_planes(cm); MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; const int mi_offset = mi_row * cm->mi_stride + mi_col; - MODE_INFO *const m = *(cm->mi_grid_visible + mi_offset); - MB_MODE_INFO *const mbmi = &m->mbmi; + MB_MODE_INFO *const mbmi = *(cm->mi_grid_visible + mi_offset); int plane; int bh, bw; -#if CONFIG_PVQ || CONFIG_LV_MAP MACROBLOCK *const x = &cpi->td.mb; (void)tok; (void)tok_end; -#endif xd->mi = cm->mi_grid_visible + mi_offset; - assert(mbmi->sb_type <= cm->sb_size || + assert(mbmi->sb_type <= cm->seq_params.sb_size || (mbmi->sb_type >= BLOCK_SIZES && mbmi->sb_type < BLOCK_SIZES_ALL)); bh = mi_size_high[mbmi->sb_type]; bw = mi_size_wide[mbmi->sb_type]; cpi->td.mb.mbmi_ext = cpi->mbmi_ext_base + (mi_row * cm->mi_cols + mi_col); - set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); - -// TODO(anybody) : remove this flag when PVQ supports pallete coding tool -#if !CONFIG_PVQ - for (plane = 0; plane <= 1; ++plane) { - const uint8_t palette_size_plane = - mbmi->palette_mode_info.palette_size[plane]; - if (palette_size_plane > 0) { -#if CONFIG_INTRABC - assert(mbmi->use_intrabc == 0); -#endif - int rows, cols; - assert(mbmi->sb_type >= BLOCK_8X8); - av1_get_block_dimensions(mbmi->sb_type, plane, xd, NULL, NULL, &rows, - &cols); - assert(*tok < tok_end); - pack_map_tokens(w, tok, palette_size_plane, rows * cols); -#if !CONFIG_LV_MAP - assert(*tok < tok_end + mbmi->skip); -#endif // !CONFIG_LV_MAP - } - } -#endif // !CONFIG_PVQ + set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols); -#if CONFIG_COEF_INTERLEAVE if (!mbmi->skip) { - const struct macroblockd_plane *const pd_y = &xd->plane[0]; - const struct macroblockd_plane *const pd_c = &xd->plane[1]; - const TX_SIZE tx_log2_y = mbmi->tx_size; - const TX_SIZE tx_log2_c = av1_get_uv_tx_size(mbmi, pd_c); - const int tx_sz_y = (1 << tx_log2_y); - const int tx_sz_c = (1 << tx_log2_c); - - const BLOCK_SIZE plane_bsize_y = - get_plane_block_size(AOMMAX(mbmi->sb_type, 3), pd_y); - const BLOCK_SIZE plane_bsize_c = - get_plane_block_size(AOMMAX(mbmi->sb_type, 3), pd_c); - - const int num_4x4_w_y = num_4x4_blocks_wide_lookup[plane_bsize_y]; - const int num_4x4_w_c = num_4x4_blocks_wide_lookup[plane_bsize_c]; - const int num_4x4_h_y = num_4x4_blocks_high_lookup[plane_bsize_y]; - const int num_4x4_h_c = num_4x4_blocks_high_lookup[plane_bsize_c]; - - const int max_4x4_w_y = get_max_4x4_size(num_4x4_w_y, xd->mb_to_right_edge, - pd_y->subsampling_x); - const int max_4x4_h_y = get_max_4x4_size(num_4x4_h_y, xd->mb_to_bottom_edge, - pd_y->subsampling_y); - const int max_4x4_w_c = get_max_4x4_size(num_4x4_w_c, xd->mb_to_right_edge, - pd_c->subsampling_x); - const int max_4x4_h_c = get_max_4x4_size(num_4x4_h_c, xd->mb_to_bottom_edge, - pd_c->subsampling_y); - - // The max_4x4_w/h may be smaller than tx_sz under some corner cases, - // i.e. when the SB is splitted by tile boundaries. - const int tu_num_w_y = (max_4x4_w_y + tx_sz_y - 1) / tx_sz_y; - const int tu_num_h_y = (max_4x4_h_y + tx_sz_y - 1) / tx_sz_y; - const int tu_num_w_c = (max_4x4_w_c + tx_sz_c - 1) / tx_sz_c; - const int tu_num_h_c = (max_4x4_h_c + tx_sz_c - 1) / tx_sz_c; - const int tu_num_y = tu_num_w_y * tu_num_h_y; - const int tu_num_c = tu_num_w_c * tu_num_h_c; - - int tu_idx_y = 0, tu_idx_c = 0; - TOKEN_STATS token_stats; - init_token_stats(&token_stats); - - assert(*tok < tok_end); - - while (tu_idx_y < tu_num_y) { - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx_log2_y, &token_stats); - assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN); - (*tok)++; - tu_idx_y++; - - if (tu_idx_c < tu_num_c) { - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx_log2_c, &token_stats); - assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN); - (*tok)++; - - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx_log2_c, &token_stats); - assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN); - (*tok)++; - - tu_idx_c++; - } - } - - // In 422 case, it's possilbe that Chroma has more TUs than Luma - while (tu_idx_c < tu_num_c) { - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx_log2_c, &token_stats); - assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN); - (*tok)++; - - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx_log2_c, &token_stats); - assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN); - (*tok)++; - - tu_idx_c++; - } - } -#else // CONFIG_COEF_INTERLEAVE - if (!mbmi->skip) { -#if !CONFIG_PVQ && !CONFIG_LV_MAP - assert(*tok < tok_end); -#endif - for (plane = 0; plane < MAX_MB_PLANE; ++plane) { -#if CONFIG_CB4X4 - if (!is_chroma_reference(mi_row, mi_col, mbmi->sb_type, - xd->plane[plane].subsampling_x, - xd->plane[plane].subsampling_y)) { -#if !CONFIG_LV_MAP - (*tok)++; -#endif // !CONFIG_LV_MAP - continue; - } -#endif -#if CONFIG_VAR_TX - const struct macroblockd_plane *const pd = &xd->plane[plane]; - BLOCK_SIZE bsize = mbmi->sb_type; -#if CONFIG_CHROMA_SUB8X8 - const BLOCK_SIZE plane_bsize = - AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd)); -#elif CONFIG_CB4X4 - const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); -#else - const BLOCK_SIZE plane_bsize = - get_plane_block_size(AOMMAX(bsize, BLOCK_8X8), pd); -#endif - + if (!is_inter_block(mbmi)) + av1_write_coeffs_mb(cm, x, mi_row, mi_col, w, mbmi->sb_type); + + if (is_inter_block(mbmi)) { + int block[MAX_MB_PLANE] = { 0 }; + const BLOCK_SIZE plane_bsize = mbmi->sb_type; + assert(plane_bsize == get_plane_block_size(mbmi->sb_type, + xd->plane[0].subsampling_x, + xd->plane[0].subsampling_y)); const int num_4x4_w = block_size_wide[plane_bsize] >> tx_size_wide_log2[0]; const int num_4x4_h = - block_size_high[plane_bsize] >> tx_size_wide_log2[0]; + block_size_high[plane_bsize] >> tx_size_high_log2[0]; int row, col; TOKEN_STATS token_stats; init_token_stats(&token_stats); - const BLOCK_SIZE max_unit_bsize = get_plane_block_size(BLOCK_64X64, pd); + 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 = block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0]; int mu_blocks_high = @@ -2618,37 +1483,16 @@ static void write_tokens_b(AV1_COMP *cpi, const TileInfo *const tile, mu_blocks_wide = AOMMIN(num_4x4_w, mu_blocks_wide); mu_blocks_high = AOMMIN(num_4x4_h, mu_blocks_high); - if (is_inter_block(mbmi)) { - const TX_SIZE max_tx_size = get_vartx_max_txsize( - mbmi, plane_bsize, pd->subsampling_x || pd->subsampling_y); - int block = 0; - 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]; - assert(bkw <= mu_blocks_wide); - assert(bkh <= mu_blocks_high); - for (row = 0; row < num_4x4_h; row += mu_blocks_high) { - const int unit_height = AOMMIN(mu_blocks_high + row, num_4x4_h); - for (col = 0; col < num_4x4_w; col += mu_blocks_wide) { - int blk_row, blk_col; - const int unit_width = AOMMIN(mu_blocks_wide + col, num_4x4_w); - for (blk_row = row; blk_row < unit_height; blk_row += bkh) { - for (blk_col = col; blk_col < unit_width; blk_col += bkw) { - pack_txb_tokens(w, -#if CONFIG_LV_MAP - cm, -#endif - tok, tok_end, -#if CONFIG_PVQ || CONFIG_LV_MAP - x, -#endif - xd, mbmi, plane, plane_bsize, cm->bit_depth, - block, blk_row, blk_col, max_tx_size, - &token_stats); - block += step; - } + for (row = 0; row < num_4x4_h; row += mu_blocks_high) { + for (col = 0; col < num_4x4_w; col += mu_blocks_wide) { + for (plane = 0; plane < num_planes && is_inter_block(mbmi); ++plane) { + const struct macroblockd_plane *const pd = &xd->plane[plane]; + if (!is_chroma_reference(mi_row, mi_col, mbmi->sb_type, + pd->subsampling_x, pd->subsampling_y)) { + continue; } + write_inter_txb_coeff(cm, x, mbmi, w, tok, tok_end, &token_stats, + row, col, &block[plane], plane); } } #if CONFIG_RD_DEBUG @@ -2658,607 +1502,196 @@ static void write_tokens_b(AV1_COMP *cpi, const TileInfo *const tile, assert(0); } #endif // CONFIG_RD_DEBUG - } else { -#if CONFIG_LV_MAP - av1_write_coeffs_mb(cm, x, w, plane); -#else - const TX_SIZE tx = av1_get_tx_size(plane, xd); - const int bkw = tx_size_wide_unit[tx]; - const int bkh = tx_size_high_unit[tx]; - int blk_row, blk_col; - - for (row = 0; row < num_4x4_h; row += mu_blocks_high) { - for (col = 0; col < num_4x4_w; col += mu_blocks_wide) { - const int unit_height = AOMMIN(mu_blocks_high + row, num_4x4_h); - const int unit_width = AOMMIN(mu_blocks_wide + col, num_4x4_w); - - for (blk_row = row; blk_row < unit_height; blk_row += bkh) { - for (blk_col = col; blk_col < unit_width; blk_col += bkw) { -#if !CONFIG_PVQ -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - TX_TYPE tx_type = - av1_get_tx_type(plane ? PLANE_TYPE_UV : PLANE_TYPE_Y, xd, - blk_row, blk_col, 0, tx); -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx, -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - tx_type, is_inter_block(mbmi), -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - &token_stats); -#else - pack_pvq_tokens(w, x, xd, plane, bsize, tx); -#endif - } - } - } - } -#endif // CONFIG_LV_MAP - } -#else - const TX_SIZE tx = av1_get_tx_size(plane, xd); - TOKEN_STATS token_stats; -#if !CONFIG_PVQ - init_token_stats(&token_stats); -#if CONFIG_LV_MAP - (void)tx; - av1_write_coeffs_mb(cm, x, w, plane); -#else // CONFIG_LV_MAP -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - TX_TYPE tx_type = av1_get_tx_type(plane ? PLANE_TYPE_UV : PLANE_TYPE_Y, - xd, blk_row, blk_col, 0, tx); -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx, -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - tx_type, is_inter_block(mbmi), -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - &token_stats); -#endif // CONFIG_LV_MAP - -#else - (void)token_stats; - pack_pvq_tokens(w, x, xd, plane, mbmi->sb_type, tx); -#endif -#if CONFIG_RD_DEBUG - if (is_inter_block(mbmi) && mbmi->sb_type >= BLOCK_8X8 && - rd_token_stats_mismatch(&mbmi->rd_stats, &token_stats, plane)) { - dump_mode_info(m); - assert(0); } -#endif // CONFIG_RD_DEBUG -#endif // CONFIG_VAR_TX - -#if !CONFIG_PVQ && !CONFIG_LV_MAP - assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN); - (*tok)++; -#endif } } -#endif // CONFIG_COEF_INTERLEAVE } -#if CONFIG_MOTION_VAR && NC_MODE_INFO -static void write_tokens_sb(AV1_COMP *cpi, const TileInfo *const tile, - aom_writer *w, const TOKENEXTRA **tok, - const TOKENEXTRA *const tok_end, int mi_row, - int mi_col, BLOCK_SIZE bsize) { - const AV1_COMMON *const cm = &cpi->common; - const int hbs = mi_size_wide[bsize] / 2; - PARTITION_TYPE partition; - BLOCK_SIZE subsize; -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif - - if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return; - - partition = get_partition(cm, mi_row, mi_col, bsize); - subsize = get_subsize(bsize, partition); - - if (subsize < BLOCK_8X8 && !unify_bsize) { - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - } else { - switch (partition) { - case PARTITION_NONE: - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - break; - case PARTITION_HORZ: - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - if (mi_row + hbs < cm->mi_rows) - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); - break; - case PARTITION_VERT: - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - if (mi_col + hbs < cm->mi_cols) - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); - break; - case PARTITION_SPLIT: - write_tokens_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, subsize); - write_tokens_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs, - subsize); - write_tokens_sb(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col, - subsize); - write_tokens_sb(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs, - subsize); - break; -#if CONFIG_EXT_PARTITION_TYPES -#if CONFIG_EXT_PARTITION_TYPES_AB -#error NC_MODE_INFO+MOTION_VAR not yet supported for new HORZ/VERT_AB partitions -#endif - case PARTITION_HORZ_A: - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); - break; - case PARTITION_HORZ_B: - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs); - break; - case PARTITION_VERT_A: - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); - break; - case PARTITION_VERT_B: - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs); - break; -#endif // CONFIG_EXT_PARTITION_TYPES - default: assert(0); +static 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) { + write_mbmi_b(cpi, tile, w, mi_row, mi_col); + + AV1_COMMON *cm = &cpi->common; + MACROBLOCKD *xd = &cpi->td.mb.e_mbd; + MB_MODE_INFO *mbmi = xd->mi[0]; + for (int plane = 0; plane < AOMMIN(2, av1_num_planes(cm)); ++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 == 0); + assert(av1_allow_palette(cm->allow_screen_content_tools, mbmi->sb_type)); + int rows, cols; + av1_get_block_dimensions(mbmi->sb_type, plane, xd, NULL, NULL, &rows, + &cols); + assert(*tok < tok_end); + pack_map_tokens(w, tok, palette_size_plane, rows * cols); } } -} -#endif -static void write_modes_b(AV1_COMP *cpi, const TileInfo *const tile, - aom_writer *w, const TOKENEXTRA **tok, - const TOKENEXTRA *const tok_end, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif - int mi_row, int mi_col) { - write_mbmi_b(cpi, tile, w, -#if CONFIG_SUPERTX - supertx_enabled, -#endif - mi_row, mi_col); + BLOCK_SIZE bsize = mbmi->sb_type; + int is_inter_tx = is_inter_block(mbmi) || is_intrabc_block(mbmi); + int skip = mbmi->skip; + int segment_id = mbmi->segment_id; + if (cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) && + !(is_inter_tx && skip) && !xd->lossless[segment_id]) { + if (is_inter_tx) { // This implies skip flag is 0. + const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, bsize, 0); + const int txbh = tx_size_high_unit[max_tx_size]; + const int txbw = tx_size_wide_unit[max_tx_size]; + const int width = block_size_wide[bsize] >> tx_size_wide_log2[0]; + const int height = block_size_high[bsize] >> tx_size_high_log2[0]; + int idx, idy; + for (idy = 0; idy < height; idy += txbh) + for (idx = 0; idx < width; idx += txbw) + write_tx_size_vartx(xd, mbmi, max_tx_size, 0, idy, idx, w); + } else { + write_selected_tx_size(xd, w); + set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, 0, xd); + } + } else { + set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, + skip && is_inter_block(mbmi), xd); + } -#if CONFIG_MOTION_VAR && NC_MODE_INFO - (void)tok; - (void)tok_end; -#else -#if !CONFIG_PVQ && CONFIG_SUPERTX - if (!supertx_enabled) -#endif - write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); -#endif + write_tokens_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); } static void write_partition(const AV1_COMMON *const cm, const MACROBLOCKD *const xd, int hbs, int mi_row, int mi_col, PARTITION_TYPE p, BLOCK_SIZE bsize, aom_writer *w) { + const int is_partition_point = bsize >= BLOCK_8X8; + + if (!is_partition_point) return; + const int has_rows = (mi_row + hbs) < cm->mi_rows; const int has_cols = (mi_col + hbs) < cm->mi_cols; - const int is_partition_point = bsize >= BLOCK_8X8; - const int ctx = is_partition_point - ? partition_plane_context(xd, mi_row, mi_col, -#if CONFIG_UNPOISON_PARTITION_CTX - has_rows, has_cols, -#endif - bsize) - : 0; + const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize); FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; - if (!is_partition_point) return; + if (!has_rows && !has_cols) { + assert(p == PARTITION_SPLIT); + return; + } if (has_rows && has_cols) { -#if CONFIG_EXT_PARTITION_TYPES - const int num_partition_types = - (mi_width_log2_lookup[bsize] > mi_width_log2_lookup[BLOCK_8X8]) - ? EXT_PARTITION_TYPES - : PARTITION_TYPES; -#else - const int num_partition_types = PARTITION_TYPES; -#endif - aom_write_symbol(w, p, ec_ctx->partition_cdf[ctx], num_partition_types); + aom_write_symbol(w, p, ec_ctx->partition_cdf[ctx], + partition_cdf_length(bsize)); } else if (!has_rows && has_cols) { assert(p == PARTITION_SPLIT || p == PARTITION_HORZ); assert(bsize > BLOCK_8X8); aom_cdf_prob cdf[2]; - partition_gather_vert_alike(cdf, ec_ctx->partition_cdf[ctx]); + partition_gather_vert_alike(cdf, ec_ctx->partition_cdf[ctx], bsize); aom_write_cdf(w, p == PARTITION_SPLIT, cdf, 2); - } else if (has_rows && !has_cols) { + } else { + assert(has_rows && !has_cols); assert(p == PARTITION_SPLIT || p == PARTITION_VERT); assert(bsize > BLOCK_8X8); aom_cdf_prob cdf[2]; - partition_gather_horz_alike(cdf, ec_ctx->partition_cdf[ctx]); + partition_gather_horz_alike(cdf, ec_ctx->partition_cdf[ctx], bsize); aom_write_cdf(w, p == PARTITION_SPLIT, cdf, 2); - } else { - assert(p == PARTITION_SPLIT); } } -#if CONFIG_SUPERTX -#define write_modes_sb_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, \ - mi_row, mi_col, bsize) \ - write_modes_sb(cpi, tile, w, tok, tok_end, supertx_enabled, mi_row, mi_col, \ - bsize) -#else -#define write_modes_sb_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, \ - mi_row, mi_col, bsize) \ - write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, bsize) -#endif // CONFIG_SUPERTX - static void write_modes_sb(AV1_COMP *const cpi, const TileInfo *const tile, aom_writer *const w, const TOKENEXTRA **tok, - const TOKENEXTRA *const tok_end, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif - int mi_row, int mi_col, BLOCK_SIZE bsize) { + const TOKENEXTRA *const tok_end, int mi_row, + int mi_col, BLOCK_SIZE bsize) { const AV1_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; const int hbs = mi_size_wide[bsize] / 2; -#if CONFIG_EXT_PARTITION_TYPES const int quarter_step = mi_size_wide[bsize] / 4; int i; -#if CONFIG_EXT_PARTITION_TYPES_AB - const int qbs = mi_size_wide[bsize] / 4; -#endif // CONFIG_EXT_PARTITION_TYPES_AB -#endif // CONFIG_EXT_PARTITION_TYPES const PARTITION_TYPE partition = get_partition(cm, mi_row, mi_col, bsize); - const BLOCK_SIZE subsize = get_subsize(bsize, partition); -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif - -#if CONFIG_SUPERTX - const int mi_offset = mi_row * cm->mi_stride + mi_col; - MB_MODE_INFO *mbmi; - const int pack_token = !supertx_enabled; - TX_SIZE supertx_size; -#endif + const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition); if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return; - write_partition(cm, xd, hbs, mi_row, mi_col, partition, bsize, w); -#if CONFIG_SUPERTX - mbmi = &cm->mi_grid_visible[mi_offset]->mbmi; - xd->mi = cm->mi_grid_visible + mi_offset; - set_mi_row_col(xd, tile, mi_row, mi_size_high[bsize], mi_col, - mi_size_wide[bsize], -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); - if (!supertx_enabled && !frame_is_intra_only(cm) && - partition != PARTITION_NONE && bsize <= MAX_SUPERTX_BLOCK_SIZE && - !xd->lossless[0]) { - aom_prob prob; - supertx_size = max_txsize_lookup[bsize]; - prob = cm->fc->supertx_prob[partition_supertx_context_lookup[partition]] - [supertx_size]; - supertx_enabled = (xd->mi[0]->mbmi.tx_size == supertx_size); - aom_write(w, supertx_enabled, prob); - } -#endif // CONFIG_SUPERTX - if (subsize < BLOCK_8X8 && !unify_bsize) { - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, mi_row, - mi_col); - } else { - switch (partition) { - case PARTITION_NONE: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - break; - case PARTITION_HORZ: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - if (mi_row + hbs < cm->mi_rows) - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col); - break; - case PARTITION_VERT: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - if (mi_col + hbs < cm->mi_cols) - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + hbs); - break; - case PARTITION_SPLIT: - write_modes_sb_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col, subsize); - write_modes_sb_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + hbs, subsize); - write_modes_sb_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col, subsize); - write_modes_sb_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col + hbs, subsize); - break; -#if CONFIG_EXT_PARTITION_TYPES -#if CONFIG_EXT_PARTITION_TYPES_AB - case PARTITION_HORZ_A: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + qbs, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col); - break; - case PARTITION_HORZ_B: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col); - if (mi_row + 3 * qbs < cm->mi_rows) - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + 3 * qbs, mi_col); - break; - case PARTITION_VERT_A: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + qbs); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + hbs); - break; - case PARTITION_VERT_B: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + hbs); - if (mi_col + 3 * qbs < cm->mi_cols) - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + 3 * qbs); - break; -#else - case PARTITION_HORZ_A: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + hbs); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col); - break; - case PARTITION_HORZ_B: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col + hbs); - break; - case PARTITION_VERT_A: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + hbs); - break; - case PARTITION_VERT_B: - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, mi_col + hbs); - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row + hbs, mi_col + hbs); - break; -#endif - case PARTITION_HORZ_4: - for (i = 0; i < 4; ++i) { - int this_mi_row = mi_row + i * quarter_step; - if (i > 0 && this_mi_row >= cm->mi_rows) break; - - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - this_mi_row, mi_col); - } - break; - case PARTITION_VERT_4: - for (i = 0; i < 4; ++i) { - int this_mi_col = mi_col + i * quarter_step; - if (i > 0 && this_mi_col >= cm->mi_cols) break; - - write_modes_b_wrapper(cpi, tile, w, tok, tok_end, supertx_enabled, - mi_row, this_mi_col); + const int num_planes = av1_num_planes(cm); + for (int plane = 0; plane < num_planes; ++plane) { + int rcol0, rcol1, rrow0, rrow1, tile_tl_idx; + if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize, + &rcol0, &rcol1, &rrow0, &rrow1, + &tile_tl_idx)) { + const int rstride = cm->rst_info[plane].horz_units_per_tile; + for (int rrow = rrow0; rrow < rrow1; ++rrow) { + for (int rcol = rcol0; rcol < rcol1; ++rcol) { + const int runit_idx = tile_tl_idx + rcol + rrow * rstride; + const RestorationUnitInfo *rui = + &cm->rst_info[plane].unit_info[runit_idx]; + loop_restoration_write_sb_coeffs(cm, xd, rui, w, plane, + cpi->td.counts); } - break; -#endif // CONFIG_EXT_PARTITION_TYPES - default: assert(0); + } } } -#if CONFIG_SUPERTX - if (partition != PARTITION_NONE && supertx_enabled && pack_token) { - int skip; - const int bsw = mi_size_wide[bsize]; - const int bsh = mi_size_high[bsize]; - - xd->mi = cm->mi_grid_visible + mi_offset; - supertx_size = mbmi->tx_size; - set_mi_row_col(xd, tile, mi_row, bsh, mi_col, bsw, -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); - assert(IMPLIES(!cm->seg.enabled, mbmi->segment_id_supertx == 0)); - assert(mbmi->segment_id_supertx < MAX_SEGMENTS); - - skip = write_skip(cm, xd, mbmi->segment_id_supertx, xd->mi[0], w); - - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + write_partition(cm, xd, hbs, mi_row, mi_col, partition, bsize, w); + switch (partition) { + case PARTITION_NONE: + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); + break; + case PARTITION_HORZ: + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); + if (mi_row + hbs < cm->mi_rows) + write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); + break; + case PARTITION_VERT: + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); + if (mi_col + hbs < cm->mi_cols) + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); + break; + case PARTITION_SPLIT: + write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, subsize); + write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs, subsize); + write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col, subsize); + write_modes_sb(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs, + subsize); + break; + case PARTITION_HORZ_A: + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); + break; + case PARTITION_HORZ_B: + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs); + break; + case PARTITION_VERT_A: + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); + break; + case PARTITION_VERT_B: + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col + hbs); + write_modes_b(cpi, tile, w, tok, tok_end, mi_row + hbs, mi_col + hbs); + break; + case PARTITION_HORZ_4: + for (i = 0; i < 4; ++i) { + int this_mi_row = mi_row + i * quarter_step; + if (i > 0 && this_mi_row >= cm->mi_rows) break; -#if CONFIG_EXT_TX - if (get_ext_tx_types(supertx_size, bsize, 1, cm->reduced_tx_set_used) > 1 && - !skip) { - const int eset = - get_ext_tx_set(supertx_size, bsize, 1, cm->reduced_tx_set_used); - const int tx_set_type = - get_ext_tx_set_type(supertx_size, bsize, 1, cm->reduced_tx_set_used); - if (eset > 0) { - aom_write_symbol(w, av1_ext_tx_ind[tx_set_type][mbmi->tx_type], - ec_ctx->inter_ext_tx_cdf[eset][supertx_size], - av1_num_ext_tx_set[tx_set_type]); + write_modes_b(cpi, tile, w, tok, tok_end, this_mi_row, mi_col); } - } -#else - if (supertx_size < TX_32X32 && !skip) { - aom_write_symbol(w, mbmi->tx_type, ec_ctx->inter_ext_tx_cdf[supertx_size], - TX_TYPES); - } -#endif // CONFIG_EXT_TX + break; + case PARTITION_VERT_4: + for (i = 0; i < 4; ++i) { + int this_mi_col = mi_col + i * quarter_step; + if (i > 0 && this_mi_col >= cm->mi_cols) break; - if (!skip) { - assert(*tok < tok_end); - for (int plane = 0; plane < MAX_MB_PLANE; ++plane) { -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - TX_TYPE tx_type = av1_get_tx_type(plane ? PLANE_TYPE_UV : PLANE_TYPE_Y, - xd, blk_row, blk_col, block, tx_size); -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - const struct macroblockd_plane *const pd = &xd->plane[plane]; - const int mbmi_txb_size = txsize_to_bsize[mbmi->tx_size]; - const BLOCK_SIZE plane_bsize = get_plane_block_size(mbmi_txb_size, pd); - - const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); - const int max_blocks_high = max_block_high(xd, plane_bsize, plane); - - int row, col; - const TX_SIZE tx = av1_get_tx_size(plane, xd); - BLOCK_SIZE txb_size = txsize_to_bsize[tx]; - - const int stepr = tx_size_high_unit[txb_size]; - const int stepc = tx_size_wide_unit[txb_size]; - - TOKEN_STATS token_stats; - token_stats.cost = 0; - for (row = 0; row < max_blocks_high; row += stepr) - for (col = 0; col < max_blocks_wide; col += stepc) - pack_mb_tokens(w, tok, tok_end, cm->bit_depth, tx, -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - tx_type, is_inter_block(mbmi), -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - &token_stats); - assert(*tok < tok_end && (*tok)->token == EOSB_TOKEN); - (*tok)++; + write_modes_b(cpi, tile, w, tok, tok_end, mi_row, this_mi_col); } - } -#if CONFIG_VAR_TX - xd->above_txfm_context = cm->above_txfm_context + mi_col; - xd->left_txfm_context = - xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); - set_txfm_ctxs(xd->mi[0]->mbmi.tx_size, bsw, bsh, skip, xd); -#endif + break; + default: assert(0); } -#endif // CONFIG_SUPERTX -// update partition context -#if CONFIG_EXT_PARTITION_TYPES + // update partition context update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition); -#else - if (bsize >= BLOCK_8X8 && - (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT)) - update_partition_context(xd, mi_row, mi_col, subsize, bsize); -#endif // CONFIG_EXT_PARTITION_TYPES - -#if CONFIG_LPF_SB - // send filter level for each superblock (64x64) - if (bsize == cm->sb_size) { - if (mi_row == 0 && mi_col == 0) { - aom_write_literal(w, cm->mi_grid_visible[0]->mbmi.filt_lvl, 6); - cm->mi_grid_visible[0]->mbmi.reuse_sb_lvl = 0; - cm->mi_grid_visible[0]->mbmi.delta = 0; - cm->mi_grid_visible[0]->mbmi.sign = 0; - } else { - int prev_mi_row, prev_mi_col; - if (mi_col - MAX_MIB_SIZE < 0) { - prev_mi_row = mi_row - MAX_MIB_SIZE; - prev_mi_col = mi_col; - } else { - prev_mi_row = mi_row; - prev_mi_col = mi_col - MAX_MIB_SIZE; - } - MB_MODE_INFO *curr_mbmi = - &cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col]->mbmi; - MB_MODE_INFO *prev_mbmi = - &cm->mi_grid_visible[prev_mi_row * cm->mi_stride + prev_mi_col]->mbmi; - - const uint8_t curr_lvl = curr_mbmi->filt_lvl; - const uint8_t prev_lvl = prev_mbmi->filt_lvl; - - const int reuse_prev_lvl = curr_lvl == prev_lvl; - const int reuse_ctx = prev_mbmi->reuse_sb_lvl; - curr_mbmi->reuse_sb_lvl = reuse_prev_lvl; - aom_write_symbol(w, reuse_prev_lvl, - xd->tile_ctx->lpf_reuse_cdf[reuse_ctx], 2); - - if (reuse_prev_lvl) { - curr_mbmi->delta = 0; - curr_mbmi->sign = 0; - } else { - const unsigned int delta = abs(curr_lvl - prev_lvl) / LPF_STEP; - const int delta_ctx = prev_mbmi->delta; - curr_mbmi->delta = delta; - aom_write_symbol(w, delta, xd->tile_ctx->lpf_delta_cdf[delta_ctx], - DELTA_RANGE); - - if (delta) { - const int sign = curr_lvl > prev_lvl; - const int sign_ctx = prev_mbmi->sign; - curr_mbmi->sign = sign; - aom_write_symbol(w, sign, - xd->tile_ctx->lpf_sign_cdf[reuse_ctx][sign_ctx], 2); - } else { - curr_mbmi->sign = 0; - } - } - } - } -#endif - -#if CONFIG_CDEF - if (bsize == cm->sb_size && cm->cdef_bits != 0 && !cm->all_lossless) { - int width_step = mi_size_wide[BLOCK_64X64]; - int height_step = mi_size_high[BLOCK_64X64]; - int width, height; - for (height = 0; (height < mi_size_high[cm->sb_size]) && - (mi_row + height < cm->mi_rows); - height += height_step) { - for (width = 0; (width < mi_size_wide[cm->sb_size]) && - (mi_col + width < cm->mi_cols); - width += width_step) { - if (!sb_all_skip(cm, mi_row + height, mi_col + width)) - aom_write_literal( - w, - cm->mi_grid_visible[(mi_row + height) * cm->mi_stride + - (mi_col + width)] - ->mbmi.cdef_strength, - cm->cdef_bits); - } - } - } -#endif -#if CONFIG_LOOP_RESTORATION - for (int plane = 0; plane < MAX_MB_PLANE; ++plane) { - int rcol0, rcol1, rrow0, rrow1, nhtiles; - if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize, - &rcol0, &rcol1, &rrow0, &rrow1, - &nhtiles)) { - for (int rrow = rrow0; rrow < rrow1; ++rrow) { - for (int rcol = rcol0; rcol < rcol1; ++rcol) { - int rtile_idx = rcol + rrow * nhtiles; - loop_restoration_write_sb_coeffs(cm, xd, w, plane, rtile_idx); - } - } - } - } -#endif } static void write_modes(AV1_COMP *const cpi, const TileInfo *const tile, @@ -3272,78 +1705,46 @@ static void write_modes(AV1_COMP *const cpi, const TileInfo *const tile, const int mi_col_end = tile->mi_col_end; int mi_row, mi_col; -#if CONFIG_DEPENDENT_HORZTILES - if (!cm->dependent_horz_tiles || mi_row_start == 0 || - tile->tg_horz_boundary) { - av1_zero_above_context(cm, mi_col_start, mi_col_end); - } -#else - av1_zero_above_context(cm, mi_col_start, mi_col_end); -#endif -#if CONFIG_PVQ - assert(cpi->td.mb.pvq_q->curr_pos == 0); -#endif + av1_zero_above_context(cm, mi_col_start, mi_col_end, tile->tile_row); + av1_init_above_context(cm, xd, tile->tile_row); + if (cpi->common.delta_q_present_flag) { - xd->prev_qindex = cpi->common.base_qindex; -#if CONFIG_EXT_DELTA_Q + xd->current_qindex = cpi->common.base_qindex; if (cpi->common.delta_lf_present_flag) { -#if CONFIG_LOOPFILTER_LEVEL - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) - xd->prev_delta_lf[lf_id] = 0; -#endif // CONFIG_LOOPFILTER_LEVEL - xd->prev_delta_lf_from_base = 0; + av1_reset_loop_filter_delta(xd, av1_num_planes(cm)); } -#endif // CONFIG_EXT_DELTA_Q } - for (mi_row = mi_row_start; mi_row < mi_row_end; mi_row += cm->mib_size) { + for (mi_row = mi_row_start; mi_row < mi_row_end; + mi_row += cm->seq_params.mib_size) { av1_zero_left_context(xd); - for (mi_col = mi_col_start; mi_col < mi_col_end; mi_col += cm->mib_size) { - write_modes_sb_wrapper(cpi, tile, w, tok, tok_end, 0, mi_row, mi_col, - cm->sb_size); -#if CONFIG_MOTION_VAR && NC_MODE_INFO - write_tokens_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, cm->sb_size); -#endif + for (mi_col = mi_col_start; mi_col < mi_col_end; + mi_col += cm->seq_params.mib_size) { + write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, + cm->seq_params.sb_size); } } -#if CONFIG_PVQ - // Check that the number of PVQ blocks encoded and written to the bitstream - // are the same - assert(cpi->td.mb.pvq_q->curr_pos == cpi->td.mb.pvq_q->last_pos); - // Reset curr_pos in case we repack the bitstream - cpi->td.mb.pvq_q->curr_pos = 0; -#endif } -#if CONFIG_LOOP_RESTORATION static void encode_restoration_mode(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { - int p; - RestorationInfo *rsi = &cm->rst_info[0]; - switch (rsi->frame_restoration_type) { - case RESTORE_NONE: - aom_wb_write_bit(wb, 0); - aom_wb_write_bit(wb, 0); - break; - case RESTORE_WIENER: - aom_wb_write_bit(wb, 1); - aom_wb_write_bit(wb, 0); - break; - case RESTORE_SGRPROJ: - aom_wb_write_bit(wb, 1); - aom_wb_write_bit(wb, 1); - break; - case RESTORE_SWITCHABLE: - aom_wb_write_bit(wb, 0); - aom_wb_write_bit(wb, 1); - break; - default: assert(0); - } - for (p = 1; p < MAX_MB_PLANE; ++p) { - rsi = &cm->rst_info[p]; + assert(!cm->all_lossless); + if (!cm->seq_params.enable_restoration) return; + if (cm->allow_intrabc) return; + const int num_planes = av1_num_planes(cm); + int all_none = 1, chroma_none = 1; + for (int p = 0; p < num_planes; ++p) { + RestorationInfo *rsi = &cm->rst_info[p]; + if (rsi->frame_restoration_type != RESTORE_NONE) { + all_none = 0; + chroma_none &= p == 0; + } switch (rsi->frame_restoration_type) { - case RESTORE_NONE: aom_wb_write_bit(wb, 0); break; + case RESTORE_NONE: + aom_wb_write_bit(wb, 0); + aom_wb_write_bit(wb, 0); + break; case RESTORE_WIENER: aom_wb_write_bit(wb, 1); aom_wb_write_bit(wb, 0); @@ -3352,40 +1753,52 @@ static void encode_restoration_mode(AV1_COMMON *cm, aom_wb_write_bit(wb, 1); aom_wb_write_bit(wb, 1); break; + case RESTORE_SWITCHABLE: + aom_wb_write_bit(wb, 0); + aom_wb_write_bit(wb, 1); + break; default: assert(0); } } - if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || - cm->rst_info[1].frame_restoration_type != RESTORE_NONE || - cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { - rsi = &cm->rst_info[0]; - aom_wb_write_bit(wb, rsi->restoration_tilesize != RESTORATION_TILESIZE_MAX); - if (rsi->restoration_tilesize != RESTORATION_TILESIZE_MAX) { - aom_wb_write_bit( - wb, rsi->restoration_tilesize != (RESTORATION_TILESIZE_MAX >> 1)); + if (!all_none) { + assert(cm->seq_params.sb_size == BLOCK_64X64 || + cm->seq_params.sb_size == BLOCK_128X128); + const int sb_size = cm->seq_params.sb_size == BLOCK_128X128 ? 128 : 64; + + RestorationInfo *rsi = &cm->rst_info[0]; + + assert(rsi->restoration_unit_size >= sb_size); + assert(RESTORATION_UNITSIZE_MAX == 256); + + if (sb_size == 64) { + aom_wb_write_bit(wb, rsi->restoration_unit_size > 64); + } + if (rsi->restoration_unit_size > 64) { + aom_wb_write_bit(wb, rsi->restoration_unit_size > 128); } } - int s = AOMMIN(cm->subsampling_x, cm->subsampling_y); - if (s && (cm->rst_info[1].frame_restoration_type != RESTORE_NONE || - cm->rst_info[2].frame_restoration_type != RESTORE_NONE)) { - aom_wb_write_bit(wb, - cm->rst_info[1].restoration_tilesize != - cm->rst_info[0].restoration_tilesize); - assert(cm->rst_info[1].restoration_tilesize == - cm->rst_info[0].restoration_tilesize || - cm->rst_info[1].restoration_tilesize == - (cm->rst_info[0].restoration_tilesize >> s)); - assert(cm->rst_info[2].restoration_tilesize == - cm->rst_info[1].restoration_tilesize); - } else if (!s) { - assert(cm->rst_info[1].restoration_tilesize == - cm->rst_info[0].restoration_tilesize); - assert(cm->rst_info[2].restoration_tilesize == - cm->rst_info[1].restoration_tilesize); + + if (num_planes > 1) { + int s = AOMMIN(cm->subsampling_x, cm->subsampling_y); + if (s && !chroma_none) { + aom_wb_write_bit(wb, cm->rst_info[1].restoration_unit_size != + cm->rst_info[0].restoration_unit_size); + assert(cm->rst_info[1].restoration_unit_size == + cm->rst_info[0].restoration_unit_size || + cm->rst_info[1].restoration_unit_size == + (cm->rst_info[0].restoration_unit_size >> s)); + assert(cm->rst_info[2].restoration_unit_size == + cm->rst_info[1].restoration_unit_size); + } else if (!s) { + assert(cm->rst_info[1].restoration_unit_size == + cm->rst_info[0].restoration_unit_size); + assert(cm->rst_info[2].restoration_unit_size == + cm->rst_info[1].restoration_unit_size); + } } } -static void write_wiener_filter(int wiener_win, WienerInfo *wiener_info, +static void write_wiener_filter(int wiener_win, const WienerInfo *wiener_info, WienerInfo *ref_wiener_info, aom_writer *wb) { if (wiener_win == WIENER_WIN) aom_write_primitive_refsubexpfin( @@ -3428,78 +1841,106 @@ static void write_wiener_filter(int wiener_win, WienerInfo *wiener_info, memcpy(ref_wiener_info, wiener_info, sizeof(*wiener_info)); } -static void write_sgrproj_filter(SgrprojInfo *sgrproj_info, +static void write_sgrproj_filter(const SgrprojInfo *sgrproj_info, SgrprojInfo *ref_sgrproj_info, aom_writer *wb) { aom_write_literal(wb, sgrproj_info->ep, SGRPROJ_PARAMS_BITS); - aom_write_primitive_refsubexpfin(wb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, - SGRPROJ_PRJ_SUBEXP_K, - ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, - sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0); - aom_write_primitive_refsubexpfin(wb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, - SGRPROJ_PRJ_SUBEXP_K, - ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, - sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1); + const sgr_params_type *params = &sgr_params[sgrproj_info->ep]; + + if (params->r[0] == 0) { + assert(sgrproj_info->xqd[0] == 0); + aom_write_primitive_refsubexpfin( + wb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K, + ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, + sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1); + } else if (params->r[1] == 0) { + aom_write_primitive_refsubexpfin( + wb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K, + ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, + sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0); + } else { + aom_write_primitive_refsubexpfin( + wb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K, + ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, + sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0); + aom_write_primitive_refsubexpfin( + wb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K, + ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, + sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1); + } + memcpy(ref_sgrproj_info, sgrproj_info, sizeof(*sgrproj_info)); } static void loop_restoration_write_sb_coeffs(const AV1_COMMON *const cm, MACROBLOCKD *xd, + const RestorationUnitInfo *rui, aom_writer *const w, int plane, - int rtile_idx) { + FRAME_COUNTS *counts) { const RestorationInfo *rsi = cm->rst_info + plane; - if (rsi->frame_restoration_type == RESTORE_NONE) return; + RestorationType frame_rtype = rsi->frame_restoration_type; + if (frame_rtype == RESTORE_NONE) return; + + (void)counts; + assert(!cm->all_lossless); const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN; WienerInfo *wiener_info = xd->wiener_info + plane; SgrprojInfo *sgrproj_info = xd->sgrproj_info + plane; + RestorationType unit_rtype = rui->restoration_type; - if (rsi->frame_restoration_type == RESTORE_SWITCHABLE) { - assert(plane == 0); - av1_write_token( - w, av1_switchable_restore_tree, cm->fc->switchable_restore_prob, - &switchable_restore_encodings[rsi->restoration_type[rtile_idx]]); - if (rsi->restoration_type[rtile_idx] == RESTORE_WIENER) { - write_wiener_filter(wiener_win, &rsi->wiener_info[rtile_idx], wiener_info, - w); - } else if (rsi->restoration_type[rtile_idx] == RESTORE_SGRPROJ) { - write_sgrproj_filter(&rsi->sgrproj_info[rtile_idx], sgrproj_info, w); + if (frame_rtype == RESTORE_SWITCHABLE) { + aom_write_symbol(w, unit_rtype, xd->tile_ctx->switchable_restore_cdf, + RESTORE_SWITCHABLE_TYPES); +#if CONFIG_ENTROPY_STATS + ++counts->switchable_restore[unit_rtype]; +#endif + switch (unit_rtype) { + case RESTORE_WIENER: + write_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, w); + break; + case RESTORE_SGRPROJ: + write_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, w); + break; + default: assert(unit_rtype == RESTORE_NONE); break; } - } else if (rsi->frame_restoration_type == RESTORE_WIENER) { - aom_write(w, rsi->restoration_type[rtile_idx] != RESTORE_NONE, - RESTORE_NONE_WIENER_PROB); - if (rsi->restoration_type[rtile_idx] != RESTORE_NONE) { - write_wiener_filter(wiener_win, &rsi->wiener_info[rtile_idx], wiener_info, - w); + } else if (frame_rtype == RESTORE_WIENER) { + aom_write_symbol(w, unit_rtype != RESTORE_NONE, + xd->tile_ctx->wiener_restore_cdf, 2); +#if CONFIG_ENTROPY_STATS + ++counts->wiener_restore[unit_rtype != RESTORE_NONE]; +#endif + if (unit_rtype != RESTORE_NONE) { + write_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, w); } - } else if (rsi->frame_restoration_type == RESTORE_SGRPROJ) { - aom_write(w, rsi->restoration_type[rtile_idx] != RESTORE_NONE, - RESTORE_NONE_SGRPROJ_PROB); - if (rsi->restoration_type[rtile_idx] != RESTORE_NONE) { - write_sgrproj_filter(&rsi->sgrproj_info[rtile_idx], sgrproj_info, w); + } else if (frame_rtype == RESTORE_SGRPROJ) { + aom_write_symbol(w, unit_rtype != RESTORE_NONE, + xd->tile_ctx->sgrproj_restore_cdf, 2); +#if CONFIG_ENTROPY_STATS + ++counts->sgrproj_restore[unit_rtype != RESTORE_NONE]; +#endif + if (unit_rtype != RESTORE_NONE) { + write_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, w); } } } -#endif // CONFIG_LOOP_RESTORATION - static void encode_loopfilter(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { + assert(!cm->coded_lossless); + if (cm->allow_intrabc) return; + const int num_planes = av1_num_planes(cm); int i; struct loopfilter *lf = &cm->lf; -// Encode the loop filter level and type -#if !CONFIG_LPF_SB -#if CONFIG_LOOPFILTER_LEVEL + // Encode the loop filter level and type aom_wb_write_literal(wb, lf->filter_level[0], 6); aom_wb_write_literal(wb, lf->filter_level[1], 6); - if (lf->filter_level[0] || lf->filter_level[1]) { - aom_wb_write_literal(wb, lf->filter_level_u, 6); - aom_wb_write_literal(wb, lf->filter_level_v, 6); - } -#else - aom_wb_write_literal(wb, lf->filter_level, 6); -#endif // CONFIG_LOOPFILTER_LEVEL -#endif // CONFIG_LPF_SB + if (num_planes > 1) { + if (lf->filter_level[0] || lf->filter_level[1]) { + aom_wb_write_literal(wb, lf->filter_level_u, 6); + aom_wb_write_literal(wb, lf->filter_level_v, 6); + } + } aom_wb_write_literal(wb, lf->sharpness_level, 3); // Write out loop filter deltas applied at the MB level based on mode or @@ -3508,48 +1949,58 @@ static void encode_loopfilter(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { if (lf->mode_ref_delta_enabled) { aom_wb_write_bit(wb, lf->mode_ref_delta_update); + if (lf->mode_ref_delta_update) { - for (i = 0; i < TOTAL_REFS_PER_FRAME; i++) { + const int prime_idx = cm->primary_ref_frame; + const int buf_idx = + prime_idx == PRIMARY_REF_NONE ? -1 : cm->frame_refs[prime_idx].idx; + int8_t last_ref_deltas[REF_FRAMES]; + if (prime_idx == PRIMARY_REF_NONE || buf_idx < 0) { + av1_set_default_ref_deltas(last_ref_deltas); + } else { + memcpy(last_ref_deltas, cm->buffer_pool->frame_bufs[buf_idx].ref_deltas, + REF_FRAMES); + } + for (i = 0; i < REF_FRAMES; i++) { const int delta = lf->ref_deltas[i]; - const int changed = delta != lf->last_ref_deltas[i]; + const int changed = delta != last_ref_deltas[i]; aom_wb_write_bit(wb, changed); - if (changed) { - lf->last_ref_deltas[i] = delta; - aom_wb_write_inv_signed_literal(wb, delta, 6); - } + if (changed) aom_wb_write_inv_signed_literal(wb, delta, 6); } + int8_t last_mode_deltas[MAX_MODE_LF_DELTAS]; + if (prime_idx == PRIMARY_REF_NONE || buf_idx < 0) { + av1_set_default_mode_deltas(last_mode_deltas); + } else { + memcpy(last_mode_deltas, + cm->buffer_pool->frame_bufs[buf_idx].mode_deltas, + MAX_MODE_LF_DELTAS); + } for (i = 0; i < MAX_MODE_LF_DELTAS; i++) { const int delta = lf->mode_deltas[i]; - const int changed = delta != lf->last_mode_deltas[i]; + const int changed = delta != last_mode_deltas[i]; aom_wb_write_bit(wb, changed); - if (changed) { - lf->last_mode_deltas[i] = delta; - aom_wb_write_inv_signed_literal(wb, delta, 6); - } + if (changed) aom_wb_write_inv_signed_literal(wb, delta, 6); } } } } -#if CONFIG_CDEF static void encode_cdef(const AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { + assert(!cm->coded_lossless); + if (!cm->seq_params.enable_cdef) return; + if (cm->allow_intrabc) return; + const int num_planes = av1_num_planes(cm); int i; -#if CONFIG_CDEF_SINGLEPASS aom_wb_write_literal(wb, cm->cdef_pri_damping - 3, 2); assert(cm->cdef_pri_damping == cm->cdef_sec_damping); -#else - aom_wb_write_literal(wb, cm->cdef_pri_damping - 5, 1); - aom_wb_write_literal(wb, cm->cdef_sec_damping - 3, 2); -#endif aom_wb_write_literal(wb, cm->cdef_bits, 2); for (i = 0; i < cm->nb_cdef_strengths; i++) { aom_wb_write_literal(wb, cm->cdef_strengths[i], CDEF_STRENGTH_BITS); - if (cm->subsampling_x == cm->subsampling_y) + if (num_planes > 1) aom_wb_write_literal(wb, cm->cdef_uv_strengths[i], CDEF_STRENGTH_BITS); } } -#endif static void write_delta_q(struct aom_write_bit_buffer *wb, int delta_q) { if (delta_q != 0) { @@ -3562,63 +2013,71 @@ static void write_delta_q(struct aom_write_bit_buffer *wb, int delta_q) { static void encode_quantization(const AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { + const int num_planes = av1_num_planes(cm); + aom_wb_write_literal(wb, cm->base_qindex, QINDEX_BITS); write_delta_q(wb, cm->y_dc_delta_q); - write_delta_q(wb, cm->uv_dc_delta_q); - write_delta_q(wb, cm->uv_ac_delta_q); -#if CONFIG_AOM_QM + if (num_planes > 1) { + int diff_uv_delta = (cm->u_dc_delta_q != cm->v_dc_delta_q) || + (cm->u_ac_delta_q != cm->v_ac_delta_q); + if (cm->separate_uv_delta_q) aom_wb_write_bit(wb, diff_uv_delta); + write_delta_q(wb, cm->u_dc_delta_q); + write_delta_q(wb, cm->u_ac_delta_q); + if (diff_uv_delta) { + write_delta_q(wb, cm->v_dc_delta_q); + write_delta_q(wb, cm->v_ac_delta_q); + } + } aom_wb_write_bit(wb, cm->using_qmatrix); if (cm->using_qmatrix) { - aom_wb_write_literal(wb, cm->min_qmlevel, QM_LEVEL_BITS); - aom_wb_write_literal(wb, cm->max_qmlevel, QM_LEVEL_BITS); + aom_wb_write_literal(wb, cm->qm_y, QM_LEVEL_BITS); + aom_wb_write_literal(wb, cm->qm_u, QM_LEVEL_BITS); + if (!cm->separate_uv_delta_q) + assert(cm->qm_u == cm->qm_v); + else + aom_wb_write_literal(wb, cm->qm_v, QM_LEVEL_BITS); } -#endif } static void encode_segmentation(AV1_COMMON *cm, MACROBLOCKD *xd, struct aom_write_bit_buffer *wb) { int i, j; - const struct segmentation *seg = &cm->seg; + struct segmentation *seg = &cm->seg; aom_wb_write_bit(wb, seg->enabled); if (!seg->enabled) return; - // Segmentation map - if (!frame_is_intra_only(cm) && !cm->error_resilient_mode) { - aom_wb_write_bit(wb, seg->update_map); - } else { + // Write update flags + if (cm->primary_ref_frame == PRIMARY_REF_NONE) { assert(seg->update_map == 1); - } - if (seg->update_map) { - // Select the coding strategy (temporal or spatial) - av1_choose_segmap_coding_method(cm, xd); - - // Write out the chosen coding method. - if (!frame_is_intra_only(cm) && !cm->error_resilient_mode) { + seg->temporal_update = 0; + assert(seg->update_data == 1); + } else { + aom_wb_write_bit(wb, seg->update_map); + if (seg->update_map) { + // Select the coding strategy (temporal or spatial) + av1_choose_segmap_coding_method(cm, xd); aom_wb_write_bit(wb, seg->temporal_update); - } else { - assert(seg->temporal_update == 0); } + aom_wb_write_bit(wb, seg->update_data); } // Segmentation data - aom_wb_write_bit(wb, seg->update_data); if (seg->update_data) { - aom_wb_write_bit(wb, seg->abs_delta); - for (i = 0; i < MAX_SEGMENTS; i++) { for (j = 0; j < SEG_LVL_MAX; j++) { const int active = segfeature_active(seg, i, j); aom_wb_write_bit(wb, active); if (active) { - const int data = get_segdata(seg, i, j); const int data_max = av1_seg_feature_data_max(j); + const int data_min = -data_max; + const int ubits = get_unsigned_bits(data_max); + const int data = clamp(get_segdata(seg, i, j), data_min, data_max); if (av1_is_segfeature_signed(j)) { - encode_unsigned_max(wb, abs(data), data_max); - aom_wb_write_bit(wb, data < 0); + aom_wb_write_inv_signed_literal(wb, data, ubits); } else { - encode_unsigned_max(wb, data, data_max); + aom_wb_write_literal(wb, data, ubits); } } } @@ -3628,26 +2087,11 @@ static void encode_segmentation(AV1_COMMON *cm, MACROBLOCKD *xd, static void write_tx_mode(AV1_COMMON *cm, TX_MODE *mode, struct aom_write_bit_buffer *wb) { - if (cm->all_lossless) { + if (cm->coded_lossless) { *mode = ONLY_4X4; return; } -#if CONFIG_VAR_TX_NO_TX_MODE - (void)wb; - *mode = TX_MODE_SELECT; - return; -#else -#if CONFIG_TX64X64 - aom_wb_write_bit(wb, *mode == TX_MODE_SELECT); - if (*mode != TX_MODE_SELECT) { - aom_wb_write_literal(wb, AOMMIN(*mode, ALLOW_32X32), 2); - if (*mode >= ALLOW_32X32) aom_wb_write_bit(wb, *mode == ALLOW_64X64); - } -#else aom_wb_write_bit(wb, *mode == TX_MODE_SELECT); - if (*mode != TX_MODE_SELECT) aom_wb_write_literal(wb, *mode, 2); -#endif // CONFIG_TX64X64 -#endif // CONFIG_VAR_TX_NO_TX_MODE } static void write_frame_interp_filter(InterpFilter filter, @@ -3672,14 +2116,7 @@ static void fix_interp_filter(AV1_COMMON *cm, FRAME_COUNTS *counts) { // Only one filter is used. So set the filter at frame level for (i = 0; i < SWITCHABLE_FILTERS; ++i) { if (count[i]) { -#if CONFIG_MOTION_VAR && (CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION) -#if CONFIG_WARPED_MOTION - if (i == EIGHTTAP_REGULAR || WARP_WM_NEIGHBORS_WITH_OBMC) -#else - if (i == EIGHTTAP_REGULAR || WARP_GM_NEIGHBORS_WITH_OBMC) -#endif // CONFIG_WARPED_MOTION -#endif // CONFIG_MOTION_VAR && (CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION) - cm->interp_filter = i; + if (i == EIGHTTAP_REGULAR) cm->interp_filter = i; break; } } @@ -3687,8 +2124,6 @@ static void fix_interp_filter(AV1_COMMON *cm, FRAME_COUNTS *counts) { } } -#if CONFIG_MAX_TILE - // Same function as write_uniform but writing to uncompresses header wb static void wb_write_uniform(struct aom_write_bit_buffer *wb, int n, int v) { const int l = get_unsigned_bits(n); @@ -3704,10 +2139,10 @@ static void wb_write_uniform(struct aom_write_bit_buffer *wb, int n, int v) { static void write_tile_info_max_tile(const AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { - int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, MAX_MIB_SIZE_LOG2); - int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, MAX_MIB_SIZE_LOG2); - int width_sb = width_mi >> MAX_MIB_SIZE_LOG2; - int height_sb = height_mi >> MAX_MIB_SIZE_LOG2; + int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2); + int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2); + int width_sb = width_mi >> cm->seq_params.mib_size_log2; + int height_sb = height_mi >> cm->seq_params.mib_size_log2; int size_sb, i; aom_wb_write_bit(wb, cm->uniform_tile_spacing_flag); @@ -3736,7 +2171,8 @@ static void write_tile_info_max_tile(const AV1_COMMON *const cm, // columns for (i = 0; i < cm->tile_cols; i++) { size_sb = cm->tile_col_start_sb[i + 1] - cm->tile_col_start_sb[i]; - wb_write_uniform(wb, AOMMIN(width_sb, MAX_TILE_WIDTH_SB), size_sb - 1); + wb_write_uniform(wb, AOMMIN(width_sb, cm->max_tile_width_sb), + size_sb - 1); width_sb -= size_sb; } assert(width_sb == 0); @@ -3751,72 +2187,45 @@ static void write_tile_info_max_tile(const AV1_COMMON *const cm, assert(height_sb == 0); } } -#endif static void write_tile_info(const AV1_COMMON *const cm, + struct aom_write_bit_buffer *saved_wb, struct aom_write_bit_buffer *wb) { -#if CONFIG_EXT_TILE - if (cm->large_scale_tile) { - const int tile_width = - ALIGN_POWER_OF_TWO(cm->tile_width, cm->mib_size_log2) >> - cm->mib_size_log2; - const int tile_height = - ALIGN_POWER_OF_TWO(cm->tile_height, cm->mib_size_log2) >> - cm->mib_size_log2; - - assert(tile_width > 0); - assert(tile_height > 0); - -// Write the tile sizes -#if CONFIG_EXT_PARTITION - if (cm->sb_size == BLOCK_128X128) { - assert(tile_width <= 32); - assert(tile_height <= 32); - aom_wb_write_literal(wb, tile_width - 1, 5); - aom_wb_write_literal(wb, tile_height - 1, 5); - } else { -#endif // CONFIG_EXT_PARTITION - assert(tile_width <= 64); - assert(tile_height <= 64); - aom_wb_write_literal(wb, tile_width - 1, 6); - aom_wb_write_literal(wb, tile_height - 1, 6); -#if CONFIG_EXT_PARTITION - } -#endif // CONFIG_EXT_PARTITION - } else { -#endif // CONFIG_EXT_TILE - -#if CONFIG_MAX_TILE - write_tile_info_max_tile(cm, wb); -#else - int min_log2_tile_cols, max_log2_tile_cols, ones; - av1_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols); + write_tile_info_max_tile(cm, wb); - // columns - ones = cm->log2_tile_cols - min_log2_tile_cols; - while (ones--) aom_wb_write_bit(wb, 1); + *saved_wb = *wb; + if (cm->tile_rows * cm->tile_cols > 1) { + // tile id used for cdf update + aom_wb_write_literal(wb, 0, cm->log2_tile_cols + cm->log2_tile_rows); + // Number of bytes in tile size - 1 + aom_wb_write_literal(wb, 3, 2); + } +} - if (cm->log2_tile_cols < max_log2_tile_cols) aom_wb_write_bit(wb, 0); +static void write_ext_tile_info(const AV1_COMMON *const cm, + struct aom_write_bit_buffer *saved_wb, + struct aom_write_bit_buffer *wb) { + // This information is stored as a separate byte. + int mod = wb->bit_offset % CHAR_BIT; + if (mod > 0) aom_wb_write_literal(wb, 0, CHAR_BIT - mod); + assert(aom_wb_is_byte_aligned(wb)); - // rows - aom_wb_write_bit(wb, cm->log2_tile_rows != 0); - if (cm->log2_tile_rows != 0) aom_wb_write_bit(wb, cm->log2_tile_rows != 1); -#endif -#if CONFIG_DEPENDENT_HORZTILES - if (cm->tile_rows > 1) aom_wb_write_bit(wb, cm->dependent_horz_tiles); -#endif -#if CONFIG_EXT_TILE + *saved_wb = *wb; + if (cm->tile_rows * cm->tile_cols > 1) { + // Note that the last item in the uncompressed header is the data + // describing tile configuration. + // Number of bytes in tile column size - 1 + aom_wb_write_literal(wb, 0, 2); + // Number of bytes in tile size - 1 + aom_wb_write_literal(wb, 0, 2); } -#endif // CONFIG_EXT_TILE - -#if CONFIG_LOOPFILTERING_ACROSS_TILES - aom_wb_write_bit(wb, cm->loop_filter_across_tiles_enabled); -#endif // CONFIG_LOOPFILTERING_ACROSS_TILES } -#if CONFIG_EXT_REFS #if USE_GF16_MULTI_LAYER static int get_refresh_mask_gf16(AV1_COMP *cpi) { + if (cpi->common.frame_type == KEY_FRAME || frame_is_sframe(&cpi->common)) + return 0xFF; + int refresh_mask = 0; if (cpi->refresh_last_frame || cpi->refresh_golden_frame || @@ -3829,11 +2238,12 @@ static int get_refresh_mask_gf16(AV1_COMP *cpi) { return refresh_mask; } #endif // USE_GF16_MULTI_LAYER -#endif // CONFIG_EXT_REFS static int get_refresh_mask(AV1_COMP *cpi) { + if (cpi->common.frame_type == KEY_FRAME || frame_is_sframe(&cpi->common)) + return 0xFF; + int refresh_mask = 0; -#if CONFIG_EXT_REFS #if USE_GF16_MULTI_LAYER if (cpi->rc.baseline_gf_interval == 16) return get_refresh_mask_gf16(cpi); #endif // USE_GF16_MULTI_LAYER @@ -3847,13 +2257,12 @@ static int get_refresh_mask(AV1_COMP *cpi) { // shifted and become the new virtual indexes for LAST2_FRAME and // LAST3_FRAME. refresh_mask |= - (cpi->refresh_last_frame << cpi->lst_fb_idxes[LAST_REF_FRAMES - 1]); + (cpi->refresh_last_frame << cpi->ref_fb_idx[LAST_REF_FRAMES - 1]); - refresh_mask |= (cpi->refresh_bwd_ref_frame << cpi->bwd_fb_idx); - refresh_mask |= (cpi->refresh_alt2_ref_frame << cpi->alt2_fb_idx); -#else // !CONFIG_EXT_REFS - refresh_mask |= (cpi->refresh_last_frame << cpi->lst_fb_idx); -#endif // CONFIG_EXT_REFS + refresh_mask |= + (cpi->refresh_bwd_ref_frame << cpi->ref_fb_idx[BWDREF_FRAME - 1]); + refresh_mask |= + (cpi->refresh_alt2_ref_frame << cpi->ref_fb_idx[ALTREF2_FRAME - 1]); if (av1_preserve_existing_gf(cpi)) { // We have decided to preserve the previously existing golden frame as our @@ -3866,26 +2275,19 @@ static int get_refresh_mask(AV1_COMP *cpi) { // Note: This is highly specific to the use of ARF as a forward reference, // and this needs to be generalized as other uses are implemented // (like RTC/temporal scalability). - return refresh_mask | (cpi->refresh_golden_frame << cpi->alt_fb_idx); + return refresh_mask | + (cpi->refresh_golden_frame << cpi->ref_fb_idx[ALTREF_FRAME - 1]); } else { -#if CONFIG_EXT_REFS - const int arf_idx = cpi->alt_fb_idx; -#else // !CONFIG_EXT_REFS - int arf_idx = cpi->alt_fb_idx; - if ((cpi->oxcf.pass == 2) && cpi->multi_arf_allowed) { - const GF_GROUP *const gf_group = &cpi->twopass.gf_group; - arf_idx = gf_group->arf_update_idx[gf_group->index]; - } -#endif // CONFIG_EXT_REFS - return refresh_mask | (cpi->refresh_golden_frame << cpi->gld_fb_idx) | + const int arf_idx = cpi->ref_fb_idx[ALTREF_FRAME - 1]; + return refresh_mask | + (cpi->refresh_golden_frame << cpi->ref_fb_idx[GOLDEN_FRAME - 1]) | (cpi->refresh_alt_ref_frame << arf_idx); } } -#if CONFIG_EXT_TILE static INLINE int find_identical_tile( const int tile_row, const int tile_col, - TileBufferEnc (*const tile_buffers)[1024]) { + TileBufferEnc (*const tile_buffers)[MAX_TILE_COLS]) { const MV32 candidate_offset[1] = { { 1, 0 } }; const uint8_t *const cur_tile_data = tile_buffers[tile_row][tile_col].data + 4; @@ -3933,329 +2335,10 @@ static INLINE int find_identical_tile( // No identical tile found return 0; } -#endif // CONFIG_EXT_TILE - -#if !CONFIG_OBU || CONFIG_EXT_TILE -static uint32_t write_tiles(AV1_COMP *const cpi, uint8_t *const dst, - unsigned int *max_tile_size, - unsigned int *max_tile_col_size) { - const AV1_COMMON *const cm = &cpi->common; - aom_writer mode_bc; - int tile_row, tile_col; - TOKENEXTRA *(*const tok_buffers)[MAX_TILE_COLS] = cpi->tile_tok; - TileBufferEnc(*const tile_buffers)[MAX_TILE_COLS] = cpi->tile_buffers; - uint32_t total_size = 0; - const int tile_cols = cm->tile_cols; - const int tile_rows = cm->tile_rows; - unsigned int tile_size = 0; - const int have_tiles = tile_cols * tile_rows > 1; - struct aom_write_bit_buffer wb = { dst, 0 }; - const int n_log2_tiles = cm->log2_tile_rows + cm->log2_tile_cols; - uint32_t compressed_hdr_size; - // Fixed size tile groups for the moment - const int num_tg_hdrs = cm->num_tg; - const int tg_size = -#if CONFIG_EXT_TILE - (cm->large_scale_tile) - ? 1 - : -#endif // CONFIG_EXT_TILE - (tile_rows * tile_cols + num_tg_hdrs - 1) / num_tg_hdrs; - int tile_count = 0; - int tg_count = 1; - int tile_size_bytes = 4; - int tile_col_size_bytes; - uint32_t uncompressed_hdr_size = 0; - struct aom_write_bit_buffer tg_params_wb; - struct aom_write_bit_buffer tile_size_bytes_wb; - uint32_t saved_offset; - int mtu_size = cpi->oxcf.mtu; - int curr_tg_data_size = 0; - int hdr_size; - - *max_tile_size = 0; - *max_tile_col_size = 0; - -// All tile size fields are output on 4 bytes. A call to remux_tiles will -// later compact the data if smaller headers are adequate. - -#if CONFIG_EXT_TILE - if (cm->large_scale_tile) { - for (tile_col = 0; tile_col < tile_cols; tile_col++) { - TileInfo tile_info; - const int is_last_col = (tile_col == tile_cols - 1); - const uint32_t col_offset = total_size; - - av1_tile_set_col(&tile_info, cm, tile_col); - - // The last column does not have a column header - if (!is_last_col) total_size += 4; - - for (tile_row = 0; tile_row < tile_rows; tile_row++) { - TileBufferEnc *const buf = &tile_buffers[tile_row][tile_col]; - const TOKENEXTRA *tok = tok_buffers[tile_row][tile_col]; - const TOKENEXTRA *tok_end = tok + cpi->tok_count[tile_row][tile_col]; - const int data_offset = have_tiles ? 4 : 0; - const int tile_idx = tile_row * tile_cols + tile_col; - TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; - av1_tile_set_row(&tile_info, cm, tile_row); - - buf->data = dst + total_size; - - // Is CONFIG_EXT_TILE = 1, every tile in the row has a header, - // even for the last one, unless no tiling is used at all. - total_size += data_offset; - // Initialise tile context from the frame context - this_tile->tctx = *cm->fc; - cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = &this_tile->pvq_q; - cpi->td.mb.daala_enc.state.adapt = &this_tile->tctx.pvq_context; -#endif // CONFIG_PVQ -#if CONFIG_ANS - mode_bc.size = 1 << cpi->common.ans_window_size_log2; -#endif - aom_start_encode(&mode_bc, buf->data + data_offset); - write_modes(cpi, &tile_info, &mode_bc, &tok, tok_end); - assert(tok == tok_end); - aom_stop_encode(&mode_bc); - tile_size = mode_bc.pos; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = NULL; -#endif - buf->size = tile_size; - - // Record the maximum tile size we see, so we can compact headers later. - *max_tile_size = AOMMAX(*max_tile_size, tile_size); - - if (have_tiles) { - // tile header: size of this tile, or copy offset - uint32_t tile_header = tile_size; - const int tile_copy_mode = - ((AOMMAX(cm->tile_width, cm->tile_height) << MI_SIZE_LOG2) <= 256) - ? 1 - : 0; - - // If tile_copy_mode = 1, check if this tile is a copy tile. - // Very low chances to have copy tiles on the key frames, so don't - // search on key frames to reduce unnecessary search. - if (cm->frame_type != KEY_FRAME && tile_copy_mode) { - const int idendical_tile_offset = - find_identical_tile(tile_row, tile_col, tile_buffers); - - if (idendical_tile_offset > 0) { - tile_size = 0; - tile_header = idendical_tile_offset | 0x80; - tile_header <<= 24; - } - } - - mem_put_le32(buf->data, tile_header); - } - - total_size += tile_size; - } - - if (!is_last_col) { - uint32_t col_size = total_size - col_offset - 4; - mem_put_le32(dst + col_offset, col_size); - - // If it is not final packing, record the maximum tile column size we - // see, otherwise, check if the tile size is out of the range. - *max_tile_col_size = AOMMAX(*max_tile_col_size, col_size); - } - } - } else { -#endif // CONFIG_EXT_TILE - write_uncompressed_header_frame(cpi, &wb); - -#if CONFIG_EXT_REFS - if (cm->show_existing_frame) { - total_size = aom_wb_bytes_written(&wb); - return (uint32_t)total_size; - } -#endif // CONFIG_EXT_REFS - - // Write the tile length code - tile_size_bytes_wb = wb; - aom_wb_write_literal(&wb, 3, 2); - - /* Write a placeholder for the number of tiles in each tile group */ - tg_params_wb = wb; - saved_offset = wb.bit_offset; - if (have_tiles) { - aom_wb_overwrite_literal(&wb, 3, n_log2_tiles); - aom_wb_overwrite_literal(&wb, (1 << n_log2_tiles) - 1, n_log2_tiles); - } - - if (!use_compressed_header(cm)) { - uncompressed_hdr_size = aom_wb_bytes_written(&wb); - compressed_hdr_size = 0; - } else { - /* Write a placeholder for the compressed header length */ - struct aom_write_bit_buffer comp_hdr_len_wb = wb; - aom_wb_write_literal(&wb, 0, 16); - - uncompressed_hdr_size = aom_wb_bytes_written(&wb); - compressed_hdr_size = - write_compressed_header(cpi, dst + uncompressed_hdr_size); - aom_wb_overwrite_literal(&comp_hdr_len_wb, (int)(compressed_hdr_size), - 16); - } - - hdr_size = uncompressed_hdr_size + compressed_hdr_size; - total_size += hdr_size; - - for (tile_row = 0; tile_row < tile_rows; tile_row++) { - TileInfo tile_info; - const int is_last_row = (tile_row == tile_rows - 1); - av1_tile_set_row(&tile_info, cm, tile_row); - - for (tile_col = 0; tile_col < tile_cols; tile_col++) { - const int tile_idx = tile_row * tile_cols + tile_col; - TileBufferEnc *const buf = &tile_buffers[tile_row][tile_col]; - TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; - const TOKENEXTRA *tok = tok_buffers[tile_row][tile_col]; - const TOKENEXTRA *tok_end = tok + cpi->tok_count[tile_row][tile_col]; - const int is_last_col = (tile_col == tile_cols - 1); - const int is_last_tile = is_last_col && is_last_row; - - if ((!mtu_size && tile_count > tg_size) || - (mtu_size && tile_count && curr_tg_data_size >= mtu_size)) { - // New tile group - tg_count++; - // We've exceeded the packet size - if (tile_count > 1) { - /* The last tile exceeded the packet size. The tile group size - should therefore be tile_count-1. - Move the last tile and insert headers before it - */ - uint32_t old_total_size = total_size - tile_size - 4; - memmove(dst + old_total_size + hdr_size, dst + old_total_size, - (tile_size + 4) * sizeof(uint8_t)); - // Copy uncompressed header - memmove(dst + old_total_size, dst, - uncompressed_hdr_size * sizeof(uint8_t)); - // Write the number of tiles in the group into the last uncompressed - // header before the one we've just inserted - aom_wb_overwrite_literal(&tg_params_wb, tile_idx - tile_count, - n_log2_tiles); - aom_wb_overwrite_literal(&tg_params_wb, tile_count - 2, - n_log2_tiles); - // Update the pointer to the last TG params - tg_params_wb.bit_offset = saved_offset + 8 * old_total_size; - // Copy compressed header - memmove(dst + old_total_size + uncompressed_hdr_size, - dst + uncompressed_hdr_size, - compressed_hdr_size * sizeof(uint8_t)); - total_size += hdr_size; - tile_count = 1; - curr_tg_data_size = hdr_size + tile_size + 4; - } else { - // We exceeded the packet size in just one tile - // Copy uncompressed header - memmove(dst + total_size, dst, - uncompressed_hdr_size * sizeof(uint8_t)); - // Write the number of tiles in the group into the last uncompressed - // header - aom_wb_overwrite_literal(&tg_params_wb, tile_idx - tile_count, - n_log2_tiles); - aom_wb_overwrite_literal(&tg_params_wb, tile_count - 1, - n_log2_tiles); - tg_params_wb.bit_offset = saved_offset + 8 * total_size; - // Copy compressed header - memmove(dst + total_size + uncompressed_hdr_size, - dst + uncompressed_hdr_size, - compressed_hdr_size * sizeof(uint8_t)); - total_size += hdr_size; - tile_count = 0; - curr_tg_data_size = hdr_size; - } - } - tile_count++; - av1_tile_set_col(&tile_info, cm, tile_col); - -#if CONFIG_DEPENDENT_HORZTILES - av1_tile_set_tg_boundary(&tile_info, cm, tile_row, tile_col); -#endif - buf->data = dst + total_size; - - // The last tile does not have a header. - if (!is_last_tile) total_size += 4; - - // Initialise tile context from the frame context - this_tile->tctx = *cm->fc; - cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = &this_tile->pvq_q; - cpi->td.mb.daala_enc.state.adapt = &this_tile->tctx.pvq_context; -#endif // CONFIG_PVQ -#if CONFIG_ANS - mode_bc.size = 1 << cpi->common.ans_window_size_log2; -#endif // CONFIG_ANS -#if CONFIG_LOOP_RESTORATION - for (int p = 0; p < MAX_MB_PLANE; ++p) { - set_default_wiener(cpi->td.mb.e_mbd.wiener_info + p); - set_default_sgrproj(cpi->td.mb.e_mbd.sgrproj_info + p); - } -#endif // CONFIG_LOOP_RESTORATION - - aom_start_encode(&mode_bc, dst + total_size); - write_modes(cpi, &tile_info, &mode_bc, &tok, tok_end); -#if !CONFIG_LV_MAP -#if !CONFIG_PVQ - assert(tok == tok_end); -#endif // !CONFIG_PVQ -#endif // !CONFIG_LV_MAP - aom_stop_encode(&mode_bc); - tile_size = mode_bc.pos; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = NULL; -#endif - - assert(tile_size > 0); - - curr_tg_data_size += tile_size + 4; - buf->size = tile_size; - - if (!is_last_tile) { - *max_tile_size = AOMMAX(*max_tile_size, tile_size); - // size of this tile - mem_put_le32(buf->data, tile_size); - } - - total_size += tile_size; - } - } - // Write the final tile group size - if (n_log2_tiles) { - aom_wb_overwrite_literal( - &tg_params_wb, (tile_cols * tile_rows) - tile_count, n_log2_tiles); - aom_wb_overwrite_literal(&tg_params_wb, tile_count - 1, n_log2_tiles); - } - // Remux if possible. TODO (Thomas Davies): do this for more than one tile - // group - if (have_tiles && tg_count == 1) { - int data_size = - total_size - (uncompressed_hdr_size + compressed_hdr_size); - data_size = - remux_tiles(cm, dst + uncompressed_hdr_size + compressed_hdr_size, - data_size, *max_tile_size, *max_tile_col_size, - &tile_size_bytes, &tile_col_size_bytes); - total_size = data_size + uncompressed_hdr_size + compressed_hdr_size; - aom_wb_overwrite_literal(&tile_size_bytes_wb, tile_size_bytes - 1, 2); - } - -#if CONFIG_EXT_TILE - } -#endif // CONFIG_EXT_TILE - return (uint32_t)total_size; -} -#endif static void write_render_size(const AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { - const int scaling_active = !av1_resize_unscaled(cm); + const int scaling_active = av1_resize_scaled(cm); aom_wb_write_bit(wb, scaling_active); if (scaling_active) { aom_wb_write_literal(wb, cm->render_width - 1, 16); @@ -4263,31 +2346,42 @@ static void write_render_size(const AV1_COMMON *cm, } } -#if CONFIG_FRAME_SUPERRES static void write_superres_scale(const AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { + const SequenceHeader *const seq_params = &cm->seq_params; + if (!seq_params->enable_superres) { + assert(cm->superres_scale_denominator == SCALE_NUMERATOR); + return; + } + // First bit is whether to to scale or not if (cm->superres_scale_denominator == SCALE_NUMERATOR) { aom_wb_write_bit(wb, 0); // no scaling } else { aom_wb_write_bit(wb, 1); // scaling, write scale factor + assert(cm->superres_scale_denominator >= SUPERRES_SCALE_DENOMINATOR_MIN); + assert(cm->superres_scale_denominator < + SUPERRES_SCALE_DENOMINATOR_MIN + (1 << SUPERRES_SCALE_BITS)); aom_wb_write_literal( wb, cm->superres_scale_denominator - SUPERRES_SCALE_DENOMINATOR_MIN, SUPERRES_SCALE_BITS); } } -#endif // CONFIG_FRAME_SUPERRES -static void write_frame_size(const AV1_COMMON *cm, +static void write_frame_size(const AV1_COMMON *cm, int frame_size_override, struct aom_write_bit_buffer *wb) { -#if CONFIG_FRAME_SUPERRES - aom_wb_write_literal(wb, cm->superres_upscaled_width - 1, 16); - aom_wb_write_literal(wb, cm->superres_upscaled_height - 1, 16); + const int coded_width = cm->superres_upscaled_width - 1; + const int coded_height = cm->superres_upscaled_height - 1; + + if (frame_size_override) { + const SequenceHeader *seq_params = &cm->seq_params; + int num_bits_width = seq_params->num_bits_width; + int num_bits_height = seq_params->num_bits_height; + aom_wb_write_literal(wb, coded_width, num_bits_width); + aom_wb_write_literal(wb, coded_height, num_bits_height); + } + write_superres_scale(cm, wb); -#else - aom_wb_write_literal(wb, cm->width - 1, 16); - aom_wb_write_literal(wb, cm->height - 1, 16); -#endif // CONFIG_FRAME_SUPERRES write_render_size(cm, wb); } @@ -4301,209 +2395,426 @@ static void write_frame_size_with_refs(AV1_COMP *cpi, YV12_BUFFER_CONFIG *cfg = get_ref_frame_buffer(cpi, ref_frame); if (cfg != NULL) { -#if CONFIG_FRAME_SUPERRES found = cm->superres_upscaled_width == cfg->y_crop_width && cm->superres_upscaled_height == cfg->y_crop_height; -#else - found = - cm->width == cfg->y_crop_width && cm->height == cfg->y_crop_height; -#endif found &= cm->render_width == cfg->render_width && cm->render_height == cfg->render_height; } aom_wb_write_bit(wb, found); if (found) { -#if CONFIG_FRAME_SUPERRES write_superres_scale(cm, wb); -#endif // CONFIG_FRAME_SUPERRES break; } } - if (!found) write_frame_size(cm, wb); + if (!found) { + int frame_size_override = 1; // Always equal to 1 in this function + write_frame_size(cm, frame_size_override, wb); + } } static void write_profile(BITSTREAM_PROFILE profile, struct aom_write_bit_buffer *wb) { - switch (profile) { - case PROFILE_0: aom_wb_write_literal(wb, 0, 2); break; - case PROFILE_1: aom_wb_write_literal(wb, 2, 2); break; - case PROFILE_2: aom_wb_write_literal(wb, 1, 2); break; - case PROFILE_3: aom_wb_write_literal(wb, 6, 3); break; - default: assert(0); - } + assert(profile >= PROFILE_0 && profile < MAX_PROFILES); + aom_wb_write_literal(wb, profile, PROFILE_BITS); } -static void write_bitdepth_colorspace_sampling( - AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { - if (cm->profile >= PROFILE_2) { - assert(cm->bit_depth > AOM_BITS_8); +static void write_bitdepth(AV1_COMMON *const cm, + struct aom_write_bit_buffer *wb) { + // Profile 0/1: [0] for 8 bit, [1] 10-bit + // Profile 2: [0] for 8 bit, [10] 10-bit, [11] - 12-bit + aom_wb_write_bit(wb, cm->bit_depth == AOM_BITS_8 ? 0 : 1); + if (cm->profile == PROFILE_2 && cm->bit_depth != AOM_BITS_8) { aom_wb_write_bit(wb, cm->bit_depth == AOM_BITS_10 ? 0 : 1); } -#if CONFIG_COLORSPACE_HEADERS - aom_wb_write_literal(wb, cm->color_space, 5); - aom_wb_write_literal(wb, cm->transfer_function, 5); -#else - aom_wb_write_literal(wb, cm->color_space, 3); -#endif - if (cm->color_space != AOM_CS_SRGB) { +} + +static void write_color_config(AV1_COMMON *const cm, + struct aom_write_bit_buffer *wb) { + write_bitdepth(cm, wb); + const int is_monochrome = cm->seq_params.monochrome; + // monochrome bit + if (cm->profile != PROFILE_1) + aom_wb_write_bit(wb, is_monochrome); + else + assert(!is_monochrome); + if (cm->color_primaries == AOM_CICP_CP_UNSPECIFIED && + cm->transfer_characteristics == AOM_CICP_TC_UNSPECIFIED && + cm->matrix_coefficients == AOM_CICP_MC_UNSPECIFIED) { + aom_wb_write_bit(wb, 0); // No color description present + } else { + aom_wb_write_bit(wb, 1); // Color description present + aom_wb_write_literal(wb, cm->color_primaries, 8); + aom_wb_write_literal(wb, cm->transfer_characteristics, 8); + aom_wb_write_literal(wb, cm->matrix_coefficients, 8); + } + if (is_monochrome) { // 0: [16, 235] (i.e. xvYCC), 1: [0, 255] aom_wb_write_bit(wb, cm->color_range); - if (cm->profile == PROFILE_1 || cm->profile == PROFILE_3) { - assert(cm->subsampling_x != 1 || cm->subsampling_y != 1); - aom_wb_write_bit(wb, cm->subsampling_x); - aom_wb_write_bit(wb, cm->subsampling_y); - aom_wb_write_bit(wb, 0); // unused - } else { + return; + } + if (cm->color_primaries == AOM_CICP_CP_BT_709 && + cm->transfer_characteristics == AOM_CICP_TC_SRGB && + cm->matrix_coefficients == + AOM_CICP_MC_IDENTITY) { // it would be better to remove this + // dependency too + assert(cm->subsampling_x == 0 && cm->subsampling_y == 0); + assert(cm->profile == PROFILE_1 || + (cm->profile == PROFILE_2 && cm->bit_depth == AOM_BITS_12)); + } else { + // 0: [16, 235] (i.e. xvYCC), 1: [0, 255] + aom_wb_write_bit(wb, cm->color_range); + if (cm->profile == PROFILE_0) { + // 420 only assert(cm->subsampling_x == 1 && cm->subsampling_y == 1); + } else if (cm->profile == PROFILE_1) { + // 444 only + assert(cm->subsampling_x == 0 && cm->subsampling_y == 0); + } else if (cm->profile == PROFILE_2) { + if (cm->bit_depth == AOM_BITS_12) { + // 420, 444 or 422 + aom_wb_write_bit(wb, cm->subsampling_x); + if (cm->subsampling_x == 0) { + assert(cm->subsampling_y == 0 && + "4:4:0 subsampling not allowed in AV1"); + } else { + aom_wb_write_bit(wb, cm->subsampling_y); + } + } else { + // 422 only + assert(cm->subsampling_x == 1 && cm->subsampling_y == 0); + } + } + if (cm->matrix_coefficients == AOM_CICP_MC_IDENTITY) { + assert(cm->subsampling_x == 0 && cm->subsampling_y == 0); } -#if CONFIG_COLORSPACE_HEADERS if (cm->subsampling_x == 1 && cm->subsampling_y == 1) { aom_wb_write_literal(wb, cm->chroma_sample_position, 2); } -#endif - } else { - assert(cm->profile == PROFILE_1 || cm->profile == PROFILE_3); - aom_wb_write_bit(wb, 0); // unused } + aom_wb_write_bit(wb, cm->separate_uv_delta_q); } -#if CONFIG_REFERENCE_BUFFER -void write_sequence_header(AV1_COMMON *const cm, - struct aom_write_bit_buffer *wb) { - SequenceHeader *seq_params = &cm->seq_params; - /* Placeholder for actually writing to the bitstream */ - seq_params->frame_id_numbers_present_flag = -#if CONFIG_EXT_TILE - cm->large_scale_tile ? 0 : -#endif // CONFIG_EXT_TILE - FRAME_ID_NUMBERS_PRESENT_FLAG; - seq_params->frame_id_length_minus7 = FRAME_ID_LENGTH_MINUS7; - seq_params->delta_frame_id_length_minus2 = DELTA_FRAME_ID_LENGTH_MINUS2; - - aom_wb_write_bit(wb, seq_params->frame_id_numbers_present_flag); - if (seq_params->frame_id_numbers_present_flag) { - aom_wb_write_literal(wb, seq_params->frame_id_length_minus7, 4); - aom_wb_write_literal(wb, seq_params->delta_frame_id_length_minus2, 4); +static void write_timing_info_header(AV1_COMMON *const cm, + struct aom_write_bit_buffer *wb) { + aom_wb_write_unsigned_literal(wb, cm->timing_info.num_units_in_display_tick, + 32); // Number of units in tick + aom_wb_write_unsigned_literal(wb, cm->timing_info.time_scale, + 32); // Time scale + aom_wb_write_bit( + wb, + cm->timing_info.equal_picture_interval); // Equal picture interval bit + if (cm->timing_info.equal_picture_interval) { + aom_wb_write_uvlc( + wb, + cm->timing_info.num_ticks_per_picture - 1); // ticks per picture + } +} + +static void write_decoder_model_info(AV1_COMMON *const cm, + struct aom_write_bit_buffer *wb) { + aom_wb_write_literal( + wb, cm->buffer_model.encoder_decoder_buffer_delay_length - 1, 5); + aom_wb_write_unsigned_literal(wb, cm->buffer_model.num_units_in_decoding_tick, + 32); // Number of units in decoding tick + aom_wb_write_literal(wb, cm->buffer_model.buffer_removal_delay_length - 1, 5); + aom_wb_write_literal(wb, cm->buffer_model.frame_presentation_delay_length - 1, + 5); +} + +static void write_dec_model_op_parameters(AV1_COMMON *const cm, + struct aom_write_bit_buffer *wb, + int op_num) { + if (op_num > MAX_NUM_OPERATING_POINTS) + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Encoder does not support %d decoder model operating points", op_num); + + // aom_wb_write_bit(wb, cm->op_params[op_num].has_parameters); + // if (!cm->op_params[op_num].has_parameters) return; + + aom_wb_write_literal(wb, cm->op_params[op_num].decoder_buffer_delay, + cm->buffer_model.encoder_decoder_buffer_delay_length); + + aom_wb_write_literal(wb, cm->op_params[op_num].encoder_buffer_delay, + cm->buffer_model.encoder_decoder_buffer_delay_length); + + aom_wb_write_bit(wb, cm->op_params[op_num].low_delay_mode_flag); + + cm->op_frame_timing[op_num].buffer_removal_delay = + 0; // reset the decoded frame counter +} + +static void write_tu_pts_info(AV1_COMMON *const cm, + struct aom_write_bit_buffer *wb) { + aom_wb_write_unsigned_literal( + wb, (uint32_t)cm->tu_presentation_delay, + cm->buffer_model.frame_presentation_delay_length); +} + +static void write_film_grain_params(AV1_COMP *cpi, + struct aom_write_bit_buffer *wb) { + AV1_COMMON *const cm = &cpi->common; + aom_film_grain_t *pars = &cm->film_grain_params; + + cm->cur_frame->film_grain_params = *pars; + + aom_wb_write_bit(wb, pars->apply_grain); + if (!pars->apply_grain) return; + + aom_wb_write_literal(wb, pars->random_seed, 16); + + pars->random_seed += 3245; // For film grain test vectors purposes + if (!pars->random_seed) // Random seed should not be zero + pars->random_seed += 1735; + if (cm->frame_type == INTER_FRAME) + aom_wb_write_bit(wb, pars->update_parameters); + else + pars->update_parameters = 1; + if (!pars->update_parameters) { + RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; + int ref_frame, ref_idx, buf_idx; + for (ref_frame = LAST_FRAME; ref_frame < REF_FRAMES; ref_frame++) { + ref_idx = get_ref_frame_map_idx(cpi, ref_frame); + assert(ref_idx != INVALID_IDX); + buf_idx = cm->ref_frame_map[ref_idx]; + if (frame_bufs[buf_idx].film_grain_params_present && + memcmp(pars, &frame_bufs[buf_idx].film_grain_params, sizeof(*pars))) { + break; + } + } + assert(ref_frame < REF_FRAMES); + aom_wb_write_literal(wb, ref_idx, 3); + return; + } + + // Scaling functions parameters + aom_wb_write_literal(wb, pars->num_y_points, 4); // max 14 + for (int i = 0; i < pars->num_y_points; i++) { + aom_wb_write_literal(wb, pars->scaling_points_y[i][0], 8); + aom_wb_write_literal(wb, pars->scaling_points_y[i][1], 8); + } + + if (!cm->seq_params.monochrome) + aom_wb_write_bit(wb, pars->chroma_scaling_from_luma); + else + pars->chroma_scaling_from_luma = 0; // for monochrome override to 0 + + if (cm->seq_params.monochrome || pars->chroma_scaling_from_luma || + ((cm->subsampling_x == 1) && (cm->subsampling_y == 1) && + (pars->num_y_points == 0))) { + pars->num_cb_points = 0; + pars->num_cr_points = 0; + } else { + aom_wb_write_literal(wb, pars->num_cb_points, 4); // max 10 + for (int i = 0; i < pars->num_cb_points; i++) { + aom_wb_write_literal(wb, pars->scaling_points_cb[i][0], 8); + aom_wb_write_literal(wb, pars->scaling_points_cb[i][1], 8); + } + + aom_wb_write_literal(wb, pars->num_cr_points, 4); // max 10 + for (int i = 0; i < pars->num_cr_points; i++) { + aom_wb_write_literal(wb, pars->scaling_points_cr[i][0], 8); + aom_wb_write_literal(wb, pars->scaling_points_cr[i][1], 8); + } } + + aom_wb_write_literal(wb, pars->scaling_shift - 8, 2); // 8 + value + + // AR coefficients + // Only sent if the corresponsing scaling function has + // more than 0 points + + aom_wb_write_literal(wb, pars->ar_coeff_lag, 2); + + int num_pos_luma = 2 * pars->ar_coeff_lag * (pars->ar_coeff_lag + 1); + int num_pos_chroma = num_pos_luma; + if (pars->num_y_points > 0) ++num_pos_chroma; + + if (pars->num_y_points) + for (int i = 0; i < num_pos_luma; i++) + aom_wb_write_literal(wb, pars->ar_coeffs_y[i] + 128, 8); + + if (pars->num_cb_points || pars->chroma_scaling_from_luma) + for (int i = 0; i < num_pos_chroma; i++) + aom_wb_write_literal(wb, pars->ar_coeffs_cb[i] + 128, 8); + + if (pars->num_cr_points || pars->chroma_scaling_from_luma) + for (int i = 0; i < num_pos_chroma; i++) + aom_wb_write_literal(wb, pars->ar_coeffs_cr[i] + 128, 8); + + aom_wb_write_literal(wb, pars->ar_coeff_shift - 6, 2); // 8 + value + + aom_wb_write_literal(wb, pars->grain_scale_shift, 2); + + if (pars->num_cb_points) { + aom_wb_write_literal(wb, pars->cb_mult, 8); + aom_wb_write_literal(wb, pars->cb_luma_mult, 8); + aom_wb_write_literal(wb, pars->cb_offset, 9); + } + + if (pars->num_cr_points) { + aom_wb_write_literal(wb, pars->cr_mult, 8); + aom_wb_write_literal(wb, pars->cr_luma_mult, 8); + aom_wb_write_literal(wb, pars->cr_offset, 9); + } + + aom_wb_write_bit(wb, pars->overlap_flag); + + aom_wb_write_bit(wb, pars->clip_to_restricted_range); } -#endif // CONFIG_REFERENCE_BUFFER -static void write_sb_size(const AV1_COMMON *cm, +static void write_sb_size(SequenceHeader *seq_params, struct aom_write_bit_buffer *wb) { - (void)cm; + (void)seq_params; (void)wb; - assert(cm->mib_size == mi_size_wide[cm->sb_size]); - assert(cm->mib_size == 1 << cm->mib_size_log2); -#if CONFIG_EXT_PARTITION - assert(cm->sb_size == BLOCK_128X128 || cm->sb_size == BLOCK_64X64); - aom_wb_write_bit(wb, cm->sb_size == BLOCK_128X128 ? 1 : 0); -#else - assert(cm->sb_size == BLOCK_64X64); -#endif // CONFIG_EXT_PARTITION + assert(seq_params->mib_size == mi_size_wide[seq_params->sb_size]); + assert(seq_params->mib_size == 1 << seq_params->mib_size_log2); + assert(seq_params->sb_size == BLOCK_128X128 || + seq_params->sb_size == BLOCK_64X64); + aom_wb_write_bit(wb, seq_params->sb_size == BLOCK_128X128 ? 1 : 0); } -static void write_compound_tools(const AV1_COMMON *cm, - struct aom_write_bit_buffer *wb) { - (void)cm; - (void)wb; -#if CONFIG_INTERINTRA - if (!frame_is_intra_only(cm) && cm->reference_mode != COMPOUND_REFERENCE) { - aom_wb_write_bit(wb, cm->allow_interintra_compound); - } else { - assert(cm->allow_interintra_compound == 0); - } -#endif // CONFIG_INTERINTRA -#if CONFIG_WEDGE || CONFIG_COMPOUND_SEGMENT -#if CONFIG_COMPOUND_SINGLEREF - if (!frame_is_intra_only(cm)) { -#else // !CONFIG_COMPOUND_SINGLEREF - if (!frame_is_intra_only(cm) && cm->reference_mode != SINGLE_REFERENCE) { -#endif // CONFIG_COMPOUND_SINGLEREF - aom_wb_write_bit(wb, cm->allow_masked_compound); - } else { - assert(cm->allow_masked_compound == 0); +void write_sequence_header(AV1_COMP *cpi, struct aom_write_bit_buffer *wb) { + AV1_COMMON *const cm = &cpi->common; + SequenceHeader *seq_params = &cm->seq_params; + + int max_frame_width = cpi->oxcf.forced_max_frame_width + ? cpi->oxcf.forced_max_frame_width + : cpi->oxcf.width; + int max_frame_height = cpi->oxcf.forced_max_frame_height + ? cpi->oxcf.forced_max_frame_height + : cpi->oxcf.height; + const int num_bits_width = + (max_frame_width > 1) ? get_msb(max_frame_width - 1) + 1 : 1; + const int num_bits_height = + (max_frame_height > 1) ? get_msb(max_frame_height - 1) + 1 : 1; + assert(num_bits_width <= 16); + assert(num_bits_height <= 16); + + seq_params->num_bits_width = num_bits_width; + seq_params->num_bits_height = num_bits_height; + seq_params->max_frame_width = max_frame_width; + seq_params->max_frame_height = max_frame_height; + + aom_wb_write_literal(wb, num_bits_width - 1, 4); + aom_wb_write_literal(wb, num_bits_height - 1, 4); + aom_wb_write_literal(wb, max_frame_width - 1, num_bits_width); + aom_wb_write_literal(wb, max_frame_height - 1, num_bits_height); + + /* Placeholder for actually writing to the bitstream */ + if (!seq_params->reduced_still_picture_hdr) { + seq_params->frame_id_numbers_present_flag = + cm->large_scale_tile ? 0 : cm->error_resilient_mode; + seq_params->frame_id_length = FRAME_ID_LENGTH; + seq_params->delta_frame_id_length = DELTA_FRAME_ID_LENGTH; + + aom_wb_write_bit(wb, seq_params->frame_id_numbers_present_flag); + if (seq_params->frame_id_numbers_present_flag) { + // We must always have delta_frame_id_length < frame_id_length, + // in order for a frame to be referenced with a unique delta. + // Avoid wasting bits by using a coding that enforces this restriction. + aom_wb_write_literal(wb, seq_params->delta_frame_id_length - 2, 4); + aom_wb_write_literal( + wb, + seq_params->frame_id_length - seq_params->delta_frame_id_length - 1, + 3); + } + } + + write_sb_size(seq_params, wb); + + aom_wb_write_bit(wb, seq_params->enable_filter_intra); + aom_wb_write_bit(wb, seq_params->enable_intra_edge_filter); + + if (!seq_params->reduced_still_picture_hdr) { + aom_wb_write_bit(wb, seq_params->enable_interintra_compound); + aom_wb_write_bit(wb, seq_params->enable_masked_compound); + aom_wb_write_bit(wb, seq_params->enable_warped_motion); + aom_wb_write_bit(wb, seq_params->enable_dual_filter); + + aom_wb_write_bit(wb, seq_params->enable_order_hint); + + if (seq_params->enable_order_hint) { + aom_wb_write_bit(wb, seq_params->enable_jnt_comp); + aom_wb_write_bit(wb, seq_params->enable_ref_frame_mvs); + } + if (seq_params->force_screen_content_tools == 2) { + aom_wb_write_bit(wb, 1); + } else { + aom_wb_write_bit(wb, 0); + aom_wb_write_bit(wb, seq_params->force_screen_content_tools); + } + if (seq_params->force_screen_content_tools > 0) { + if (seq_params->force_integer_mv == 2) { + aom_wb_write_bit(wb, 1); + } else { + aom_wb_write_bit(wb, 0); + aom_wb_write_bit(wb, seq_params->force_integer_mv); + } + } else { + assert(seq_params->force_integer_mv == 2); + } + if (seq_params->enable_order_hint) + aom_wb_write_literal(wb, seq_params->order_hint_bits_minus_1, 3); } -#endif // CONFIG_WEDGE || CONFIG_COMPOUND_SEGMENT + + aom_wb_write_bit(wb, seq_params->enable_superres); + aom_wb_write_bit(wb, seq_params->enable_cdef); + aom_wb_write_bit(wb, seq_params->enable_restoration); } -#if CONFIG_GLOBAL_MOTION static void write_global_motion_params(const WarpedMotionParams *params, const WarpedMotionParams *ref_params, struct aom_write_bit_buffer *wb, int allow_hp) { - TransformationType type = params->wmtype; - int trans_bits; - int trans_prec_diff; + const TransformationType type = params->wmtype; aom_wb_write_bit(wb, type != IDENTITY); if (type != IDENTITY) { -#if GLOBAL_TRANS_TYPES > 4 - aom_wb_write_literal(wb, type - 1, GLOBAL_TYPE_BITS); -#else aom_wb_write_bit(wb, type == ROTZOOM); if (type != ROTZOOM) aom_wb_write_bit(wb, type == TRANSLATION); -#endif // GLOBAL_TRANS_TYPES > 4 - } - - switch (type) { - case HOMOGRAPHY: - case HORTRAPEZOID: - case VERTRAPEZOID: - if (type != HORTRAPEZOID) - aom_wb_write_signed_primitive_refsubexpfin( - wb, GM_ROW3HOMO_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[6] >> GM_ROW3HOMO_PREC_DIFF), - (params->wmmat[6] >> GM_ROW3HOMO_PREC_DIFF)); - if (type != VERTRAPEZOID) - aom_wb_write_signed_primitive_refsubexpfin( - wb, GM_ROW3HOMO_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[7] >> GM_ROW3HOMO_PREC_DIFF), - (params->wmmat[7] >> GM_ROW3HOMO_PREC_DIFF)); - // fallthrough intended - case AFFINE: - case ROTZOOM: - aom_wb_write_signed_primitive_refsubexpfin( - wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[2] >> GM_ALPHA_PREC_DIFF) - - (1 << GM_ALPHA_PREC_BITS), - (params->wmmat[2] >> GM_ALPHA_PREC_DIFF) - (1 << GM_ALPHA_PREC_BITS)); - if (type != VERTRAPEZOID) - aom_wb_write_signed_primitive_refsubexpfin( - wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[3] >> GM_ALPHA_PREC_DIFF), - (params->wmmat[3] >> GM_ALPHA_PREC_DIFF)); - if (type >= AFFINE) { - if (type != HORTRAPEZOID) - aom_wb_write_signed_primitive_refsubexpfin( - wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[4] >> GM_ALPHA_PREC_DIFF), - (params->wmmat[4] >> GM_ALPHA_PREC_DIFF)); - aom_wb_write_signed_primitive_refsubexpfin( - wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[5] >> GM_ALPHA_PREC_DIFF) - - (1 << GM_ALPHA_PREC_BITS), - (params->wmmat[5] >> GM_ALPHA_PREC_DIFF) - - (1 << GM_ALPHA_PREC_BITS)); - } - // fallthrough intended - case TRANSLATION: - trans_bits = (type == TRANSLATION) ? GM_ABS_TRANS_ONLY_BITS - !allow_hp - : GM_ABS_TRANS_BITS; - trans_prec_diff = (type == TRANSLATION) - ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp - : GM_TRANS_PREC_DIFF; - aom_wb_write_signed_primitive_refsubexpfin( - wb, (1 << trans_bits) + 1, SUBEXPFIN_K, - (ref_params->wmmat[0] >> trans_prec_diff), - (params->wmmat[0] >> trans_prec_diff)); - aom_wb_write_signed_primitive_refsubexpfin( - wb, (1 << trans_bits) + 1, SUBEXPFIN_K, - (ref_params->wmmat[1] >> trans_prec_diff), - (params->wmmat[1] >> trans_prec_diff)); - break; - case IDENTITY: break; - default: assert(0); + } + + if (type >= ROTZOOM) { + aom_wb_write_signed_primitive_refsubexpfin( + wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[2] >> GM_ALPHA_PREC_DIFF) - + (1 << GM_ALPHA_PREC_BITS), + (params->wmmat[2] >> GM_ALPHA_PREC_DIFF) - (1 << GM_ALPHA_PREC_BITS)); + aom_wb_write_signed_primitive_refsubexpfin( + wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[3] >> GM_ALPHA_PREC_DIFF), + (params->wmmat[3] >> GM_ALPHA_PREC_DIFF)); + } + + if (type >= AFFINE) { + aom_wb_write_signed_primitive_refsubexpfin( + wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[4] >> GM_ALPHA_PREC_DIFF), + (params->wmmat[4] >> GM_ALPHA_PREC_DIFF)); + aom_wb_write_signed_primitive_refsubexpfin( + wb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[5] >> GM_ALPHA_PREC_DIFF) - + (1 << GM_ALPHA_PREC_BITS), + (params->wmmat[5] >> GM_ALPHA_PREC_DIFF) - (1 << GM_ALPHA_PREC_BITS)); + } + + if (type >= TRANSLATION) { + const int trans_bits = (type == TRANSLATION) + ? GM_ABS_TRANS_ONLY_BITS - !allow_hp + : GM_ABS_TRANS_BITS; + const int trans_prec_diff = (type == TRANSLATION) + ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp + : GM_TRANS_PREC_DIFF; + aom_wb_write_signed_primitive_refsubexpfin( + wb, (1 << trans_bits) + 1, SUBEXPFIN_K, + (ref_params->wmmat[0] >> trans_prec_diff), + (params->wmmat[0] >> trans_prec_diff)); + aom_wb_write_signed_primitive_refsubexpfin( + wb, (1 << trans_bits) + 1, SUBEXPFIN_K, + (ref_params->wmmat[1] >> trans_prec_diff), + (params->wmmat[1] >> trans_prec_diff)); } } @@ -4513,8 +2824,8 @@ static void write_global_motion(AV1_COMP *cpi, int frame; for (frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) { const WarpedMotionParams *ref_params = - cm->error_resilient_mode ? &default_warp_params - : &cm->prev_frame->global_motion[frame]; + cm->prev_frame ? &cm->prev_frame->global_motion[frame] + : &default_warp_params; write_global_motion_params(&cm->global_motion[frame], ref_params, wb, cm->allow_high_precision_mv); // TODO(sarahparker, debargha): The logic in the commented out code below @@ -4541,820 +2852,452 @@ static void write_global_motion(AV1_COMP *cpi, */ } } -#endif -#if !CONFIG_OBU -static void write_uncompressed_header_frame(AV1_COMP *cpi, - struct aom_write_bit_buffer *wb) { +static void check_frame_refs_short_signaling(AV1_COMP *const cpi) { AV1_COMMON *const cm = &cpi->common; - MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; - - aom_wb_write_literal(wb, AOM_FRAME_MARKER, 2); - - write_profile(cm->profile, wb); + if (!cm->frame_refs_short_signaling) return; -#if CONFIG_EXT_TILE - aom_wb_write_literal(wb, cm->large_scale_tile, 1); -#endif // CONFIG_EXT_TILE - -#if CONFIG_EXT_REFS - // NOTE: By default all coded frames to be used as a reference - cm->is_reference_frame = 1; - - if (cm->show_existing_frame) { - RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; - const int frame_to_show = cm->ref_frame_map[cpi->existing_fb_idx_to_show]; - - if (frame_to_show < 0 || frame_bufs[frame_to_show].ref_count < 1) { - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Buffer %d does not contain a reconstructed frame", - frame_to_show); - } - ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show); - - aom_wb_write_bit(wb, 1); // show_existing_frame - aom_wb_write_literal(wb, cpi->existing_fb_idx_to_show, 3); - -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - int frame_id_len = cm->seq_params.frame_id_length_minus7 + 7; - int display_frame_id = cm->ref_frame_id[cpi->existing_fb_idx_to_show]; - aom_wb_write_literal(wb, display_frame_id, frame_id_len); - /* Add a zero byte to prevent emulation of superframe marker */ - /* Same logic as when when terminating the entropy coder */ - /* Consider to have this logic only one place */ - aom_wb_write_literal(wb, 0, 8); + // Check whether all references are distinct frames. + int buf_markers[FRAME_BUFFERS] = { 0 }; + for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { + const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame); + if (buf_idx != INVALID_IDX) { + assert(buf_idx >= 0 && buf_idx < FRAME_BUFFERS); + buf_markers[buf_idx] = 1; } -#endif // CONFIG_REFERENCE_BUFFER - - return; - } else { -#endif // CONFIG_EXT_REFS - aom_wb_write_bit(wb, 0); // show_existing_frame -#if CONFIG_EXT_REFS } -#endif // CONFIG_EXT_REFS - aom_wb_write_bit(wb, cm->frame_type); - aom_wb_write_bit(wb, cm->show_frame); - if (cm->frame_type != KEY_FRAME) - if (!cm->show_frame) aom_wb_write_bit(wb, cm->intra_only); - aom_wb_write_bit(wb, cm->error_resilient_mode); - - if (frame_is_intra_only(cm)) { -#if CONFIG_REFERENCE_BUFFER - write_sequence_header(cm, wb); -#endif // CONFIG_REFERENCE_BUFFER - } -#if CONFIG_REFERENCE_BUFFER - cm->invalid_delta_frame_id_minus1 = 0; - if (cm->seq_params.frame_id_numbers_present_flag) { - int frame_id_len = cm->seq_params.frame_id_length_minus7 + 7; - aom_wb_write_literal(wb, cm->current_frame_id, frame_id_len); + int num_refs = 0; + for (int buf_idx = 0; buf_idx < FRAME_BUFFERS; ++buf_idx) { + num_refs += buf_markers[buf_idx]; } -#endif // CONFIG_REFERENCE_BUFFER - if (cm->frame_type == KEY_FRAME) { - write_bitdepth_colorspace_sampling(cm, wb); - write_frame_size(cm, wb); - write_sb_size(cm, wb); - -#if CONFIG_ANS && ANS_MAX_SYMBOLS - assert(cpi->common.ans_window_size_log2 >= 8); - assert(cpi->common.ans_window_size_log2 < 24); - aom_wb_write_literal(wb, cpi->common.ans_window_size_log2 - 8, 4); -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - aom_wb_write_bit(wb, cm->allow_screen_content_tools); -#if CONFIG_AMVR - if (cm->allow_screen_content_tools) { - if (cm->seq_mv_precision_level == 2) { - aom_wb_write_bit(wb, 1); - } else { - aom_wb_write_bit(wb, 0); - aom_wb_write_bit(wb, cm->seq_mv_precision_level == 0); - } - } -#endif - } else { - if (cm->intra_only) aom_wb_write_bit(wb, cm->allow_screen_content_tools); -#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING - if (!cm->error_resilient_mode) { - if (cm->intra_only) { - aom_wb_write_bit(wb, - cm->reset_frame_context == RESET_FRAME_CONTEXT_ALL); - } else { - aom_wb_write_bit(wb, - cm->reset_frame_context != RESET_FRAME_CONTEXT_NONE); - if (cm->reset_frame_context != RESET_FRAME_CONTEXT_NONE) - aom_wb_write_bit(wb, - cm->reset_frame_context == RESET_FRAME_CONTEXT_ALL); - } - } -#endif -#if CONFIG_EXT_REFS - cpi->refresh_frame_mask = get_refresh_mask(cpi); -#endif // CONFIG_EXT_REFS - - if (cm->intra_only) { - write_bitdepth_colorspace_sampling(cm, wb); - -#if CONFIG_EXT_REFS - aom_wb_write_literal(wb, cpi->refresh_frame_mask, REF_FRAMES); -#else - aom_wb_write_literal(wb, get_refresh_mask(cpi), REF_FRAMES); -#endif // CONFIG_EXT_REFS - write_frame_size(cm, wb); - -#if CONFIG_ANS && ANS_MAX_SYMBOLS - assert(cpi->common.ans_window_size_log2 >= 8); - assert(cpi->common.ans_window_size_log2 < 24); - aom_wb_write_literal(wb, cpi->common.ans_window_size_log2 - 8, 4); -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - } else { - MV_REFERENCE_FRAME ref_frame; - -#if CONFIG_EXT_REFS - aom_wb_write_literal(wb, cpi->refresh_frame_mask, REF_FRAMES); -#else - aom_wb_write_literal(wb, get_refresh_mask(cpi), REF_FRAMES); -#endif // CONFIG_EXT_REFS - -#if CONFIG_EXT_REFS - if (!cpi->refresh_frame_mask) { - // NOTE: "cpi->refresh_frame_mask == 0" indicates that the coded frame - // will not be used as a reference - cm->is_reference_frame = 0; - } -#endif // CONFIG_EXT_REFS - - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - assert(get_ref_frame_map_idx(cpi, ref_frame) != INVALID_IDX); - aom_wb_write_literal(wb, get_ref_frame_map_idx(cpi, ref_frame), - REF_FRAMES_LOG2); -#if !CONFIG_FRAME_SIGN_BIAS - aom_wb_write_bit(wb, cm->ref_frame_sign_bias[ref_frame]); -#endif // !CONFIG_FRAME_SIGN_BIAS -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - int i = get_ref_frame_map_idx(cpi, ref_frame); - int frame_id_len = cm->seq_params.frame_id_length_minus7 + 7; - int diff_len = cm->seq_params.delta_frame_id_length_minus2 + 2; - int delta_frame_id_minus1 = - ((cm->current_frame_id - cm->ref_frame_id[i] + - (1 << frame_id_len)) % - (1 << frame_id_len)) - - 1; - if (delta_frame_id_minus1 < 0 || - delta_frame_id_minus1 >= (1 << diff_len)) - cm->invalid_delta_frame_id_minus1 = 1; - aom_wb_write_literal(wb, delta_frame_id_minus1, diff_len); - } -#endif // CONFIG_REFERENCE_BUFFER - } -#if CONFIG_FRAME_SIGN_BIAS -#define FRAME_SIGN_BIAS_DEBUG 0 -#if FRAME_SIGN_BIAS_DEBUG - { - printf("\n\nENCODER: Frame=%d, show_frame=%d:", cm->current_video_frame, - cm->show_frame); - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - printf(" sign_bias[%d]=%d", ref_frame, - cm->ref_frame_sign_bias[ref_frame]); - } - printf("\n"); - } -#endif // FRAME_SIGN_BIAS_DEBUG -#undef FRAME_SIGN_BIAS_DEBUG -#endif // CONFIG_FRAME_SIGN_BIAS - -#if CONFIG_FRAME_SIZE - if (cm->error_resilient_mode == 0) { - write_frame_size_with_refs(cpi, wb); - } else { - write_frame_size(cm, wb); - } -#else - write_frame_size_with_refs(cpi, wb); -#endif - -#if CONFIG_AMVR - if (cm->seq_mv_precision_level == 2) { - aom_wb_write_bit(wb, cm->cur_frame_mv_precision_level == 0); - } -#endif - aom_wb_write_bit(wb, cm->allow_high_precision_mv); - - fix_interp_filter(cm, cpi->td.counts); - write_frame_interp_filter(cm->interp_filter, wb); -#if CONFIG_TEMPMV_SIGNALING - if (frame_might_use_prev_frame_mvs(cm)) { - aom_wb_write_bit(wb, cm->use_prev_frame_mvs); - } -#endif - } + // We only turn on frame_refs_short_signaling when all references are + // distinct. + if (num_refs < INTER_REFS_PER_FRAME) { + // It indicates that there exist more than one reference frame pointing to + // the same reference buffer, i.e. two or more references are duplicate. + cm->frame_refs_short_signaling = 0; + return; } -#if CONFIG_FRAME_MARKER - if (cm->show_frame == 0) { - int arf_offset = AOMMIN( - (MAX_GF_INTERVAL - 1), - cpi->twopass.gf_group.arf_src_offset[cpi->twopass.gf_group.index]); -#if CONFIG_EXT_REFS - int brf_offset = - cpi->twopass.gf_group.brf_src_offset[cpi->twopass.gf_group.index]; + // Check whether the encoder side ref frame choices are aligned with that to + // be derived at the decoder side. + RefBuffer frame_refs_copy[INTER_REFS_PER_FRAME]; - arf_offset = AOMMIN((MAX_GF_INTERVAL - 1), arf_offset + brf_offset); -#endif - aom_wb_write_literal(wb, arf_offset, 4); - } -#endif + // Backup the frame refs info + memcpy(frame_refs_copy, cm->frame_refs, + INTER_REFS_PER_FRAME * sizeof(RefBuffer)); -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - cm->refresh_mask = - cm->frame_type == KEY_FRAME ? 0xFF : get_refresh_mask(cpi); - } -#endif // CONFIG_REFERENCE_BUFFER + const int lst_map_idx = get_ref_frame_map_idx(cpi, LAST_FRAME); + const int gld_map_idx = get_ref_frame_map_idx(cpi, GOLDEN_FRAME); - if (!cm->error_resilient_mode) { - aom_wb_write_bit( - wb, cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_FORWARD); - } -#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING - aom_wb_write_literal(wb, cm->frame_context_idx, FRAME_CONTEXTS_LOG2); -#endif - encode_loopfilter(cm, wb); - encode_quantization(cm, wb); - encode_segmentation(cm, xd, wb); - { - int i; - struct segmentation *const seg = &cm->seg; - int segment_quantizer_active = 0; - for (i = 0; i < MAX_SEGMENTS; i++) { - if (segfeature_active(seg, i, SEG_LVL_ALT_Q)) { - segment_quantizer_active = 1; - } - } + // Set up the frame refs mapping indexes according to the + // frame_refs_short_signaling policy. + av1_set_frame_refs(cm, lst_map_idx, gld_map_idx); - if (cm->delta_q_present_flag) - assert(segment_quantizer_active == 0 && cm->base_qindex > 0); - if (segment_quantizer_active == 0 && cm->base_qindex > 0) { - aom_wb_write_bit(wb, cm->delta_q_present_flag); - if (cm->delta_q_present_flag) { - aom_wb_write_literal(wb, OD_ILOG_NZ(cm->delta_q_res) - 1, 2); - xd->prev_qindex = cm->base_qindex; -#if CONFIG_EXT_DELTA_Q - assert(seg->abs_delta == SEGMENT_DELTADATA); - aom_wb_write_bit(wb, cm->delta_lf_present_flag); - if (cm->delta_lf_present_flag) { - aom_wb_write_literal(wb, OD_ILOG_NZ(cm->delta_lf_res) - 1, 2); - xd->prev_delta_lf_from_base = 0; -#if CONFIG_LOOPFILTER_LEVEL - aom_wb_write_bit(wb, cm->delta_lf_multi); - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) - xd->prev_delta_lf[lf_id] = 0; -#endif // CONFIG_LOOPFILTER_LEVEL - } -#endif // CONFIG_EXT_DELTA_Q - } + // We only turn on frame_refs_short_signaling when the encoder side decision + // on ref frames is identical to that at the decoder side. + for (int ref_idx = 0; ref_idx < INTER_REFS_PER_FRAME; ++ref_idx) { + // Compare the buffer index between two reference frames indexed + // respectively by the encoder and the decoder side decisions. + if (cm->frame_refs[ref_idx].idx != frame_refs_copy[ref_idx].idx) { + cm->frame_refs_short_signaling = 0; + break; } } -#if CONFIG_CDEF - if (!cm->all_lossless) { - encode_cdef(cm, wb); - } -#endif -#if CONFIG_LOOP_RESTORATION - encode_restoration_mode(cm, wb); -#endif // CONFIG_LOOP_RESTORATION - write_tx_mode(cm, &cm->tx_mode, wb); - - if (cpi->allow_comp_inter_inter) { - const int use_hybrid_pred = cm->reference_mode == REFERENCE_MODE_SELECT; -#if !CONFIG_REF_ADAPT - const int use_compound_pred = cm->reference_mode != SINGLE_REFERENCE; -#endif // !CONFIG_REF_ADAPT - aom_wb_write_bit(wb, use_hybrid_pred); -#if !CONFIG_REF_ADAPT - if (!use_hybrid_pred) aom_wb_write_bit(wb, use_compound_pred); -#endif // !CONFIG_REF_ADAPT +#if 0 // For debug + printf("\nFrame=%d: \n", cm->current_video_frame); + printf("***frame_refs_short_signaling=%d\n", cm->frame_refs_short_signaling); + for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { + printf("enc_ref(map_idx=%d, buf_idx=%d)=%d, vs. " + "dec_ref(map_idx=%d, buf_idx=%d)=%d\n", + get_ref_frame_map_idx(cpi, ref_frame), + get_ref_frame_buf_idx(cpi, ref_frame), ref_frame, + cm->frame_refs[ref_frame - LAST_FRAME].map_idx, + cm->frame_refs[ref_frame - LAST_FRAME].idx, ref_frame); } - write_compound_tools(cm, wb); - -#if CONFIG_EXT_TX - aom_wb_write_bit(wb, cm->reduced_tx_set_used); -#endif // CONFIG_EXT_TX - -#if CONFIG_ADAPT_SCAN - aom_wb_write_bit(wb, cm->use_adapt_scan); -#endif - -#if CONFIG_GLOBAL_MOTION - if (!frame_is_intra_only(cm)) write_global_motion(cpi, wb); -#endif // CONFIG_GLOBAL_MOTION +#endif // 0 - write_tile_info(cm, wb); + // Restore the frame refs info if frame_refs_short_signaling is off. + if (!cm->frame_refs_short_signaling) + memcpy(cm->frame_refs, frame_refs_copy, + INTER_REFS_PER_FRAME * sizeof(RefBuffer)); } -#else // New function based on HLS R18 static void write_uncompressed_header_obu(AV1_COMP *cpi, + struct aom_write_bit_buffer *saved_wb, struct aom_write_bit_buffer *wb) { AV1_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; -#if CONFIG_EXT_TILE - aom_wb_write_literal(wb, cm->large_scale_tile, 1); -#endif // CONFIG_EXT_TILE - -#if CONFIG_EXT_REFS // NOTE: By default all coded frames to be used as a reference cm->is_reference_frame = 1; + cm->frame_type = cm->intra_only ? INTRA_ONLY_FRAME : cm->frame_type; - if (cm->show_existing_frame) { - RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; - const int frame_to_show = cm->ref_frame_map[cpi->existing_fb_idx_to_show]; + if (cm->seq_params.still_picture) { + assert(cm->show_existing_frame == 0); + assert(cm->show_frame == 1); + assert(cm->frame_type == KEY_FRAME); + } + if (!cm->seq_params.reduced_still_picture_hdr) { + if (cm->show_existing_frame) { + RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; + const int frame_to_show = cm->ref_frame_map[cpi->existing_fb_idx_to_show]; - if (frame_to_show < 0 || frame_bufs[frame_to_show].ref_count < 1) { - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Buffer %d does not contain a reconstructed frame", - frame_to_show); + if (frame_to_show < 0 || frame_bufs[frame_to_show].ref_count < 1) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Buffer %d does not contain a reconstructed frame", + frame_to_show); + } + ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show); + + aom_wb_write_bit(wb, 1); // show_existing_frame + aom_wb_write_literal(wb, cpi->existing_fb_idx_to_show, 3); + + if (cm->seq_params.decoder_model_info_present_flag && + cm->timing_info.equal_picture_interval == 0) { + write_tu_pts_info(cm, wb); + } + if (cm->seq_params.frame_id_numbers_present_flag) { + int frame_id_len = cm->seq_params.frame_id_length; + int display_frame_id = cm->ref_frame_id[cpi->existing_fb_idx_to_show]; + aom_wb_write_literal(wb, display_frame_id, frame_id_len); + } + + if (cm->reset_decoder_state && + frame_bufs[frame_to_show].frame_type != KEY_FRAME) { + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "show_existing_frame to reset state on KEY_FRAME only"); + } + + return; + } else { + aom_wb_write_bit(wb, 0); // show_existing_frame } - ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show); - aom_wb_write_bit(wb, 1); // show_existing_frame - aom_wb_write_literal(wb, cpi->existing_fb_idx_to_show, 3); + aom_wb_write_literal(wb, cm->frame_type, 2); -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - int frame_id_len = cm->seq_params.frame_id_length_minus7 + 7; - int display_frame_id = cm->ref_frame_id[cpi->existing_fb_idx_to_show]; - aom_wb_write_literal(wb, display_frame_id, frame_id_len); - /* Add a zero byte to prevent emulation of superframe marker */ - /* Same logic as when when terminating the entropy coder */ - /* Consider to have this logic only one place */ - aom_wb_write_literal(wb, 0, 8); + aom_wb_write_bit(wb, cm->show_frame); + if (cm->show_frame) { + if (cm->seq_params.decoder_model_info_present_flag && + cm->timing_info.equal_picture_interval == 0) + write_tu_pts_info(cm, wb); + } else { + aom_wb_write_bit(wb, cm->showable_frame); + } + if (frame_is_sframe(cm)) { + assert(cm->error_resilient_mode); + } else if (!(cm->frame_type == KEY_FRAME && cm->show_frame)) { + aom_wb_write_bit(wb, cm->error_resilient_mode); } -#endif // CONFIG_REFERENCE_BUFFER + } + aom_wb_write_bit(wb, cm->disable_cdf_update); - return; + if (cm->seq_params.force_screen_content_tools == 2) { + aom_wb_write_bit(wb, cm->allow_screen_content_tools); } else { -#endif // CONFIG_EXT_REFS - aom_wb_write_bit(wb, 0); // show_existing_frame -#if CONFIG_EXT_REFS + assert(cm->allow_screen_content_tools == + cm->seq_params.force_screen_content_tools); } -#endif // CONFIG_EXT_REFS - cm->frame_type = cm->intra_only ? INTRA_ONLY_FRAME : cm->frame_type; - aom_wb_write_literal(wb, cm->frame_type, 2); + if (cm->allow_screen_content_tools) { + if (cm->seq_params.force_integer_mv == 2) { + aom_wb_write_bit(wb, cm->cur_frame_force_integer_mv); + } else { + assert(cm->cur_frame_force_integer_mv == cm->seq_params.force_integer_mv); + } + } else { + assert(cm->cur_frame_force_integer_mv == 0); + } - if (cm->intra_only) cm->frame_type = INTRA_ONLY_FRAME; + cm->invalid_delta_frame_id_minus_1 = 0; + int frame_size_override_flag = 0; + cm->frame_refs_short_signaling = 0; - aom_wb_write_bit(wb, cm->show_frame); - aom_wb_write_bit(wb, cm->error_resilient_mode); + if (cm->seq_params.reduced_still_picture_hdr) { + assert(cm->width == cm->seq_params.max_frame_width && + cm->height == cm->seq_params.max_frame_height); + } else { + if (cm->seq_params.frame_id_numbers_present_flag) { + int frame_id_len = cm->seq_params.frame_id_length; + aom_wb_write_literal(wb, cm->current_frame_id, frame_id_len); + } -#if CONFIG_REFERENCE_BUFFER - cm->invalid_delta_frame_id_minus1 = 0; - if (cm->seq_params.frame_id_numbers_present_flag) { - int frame_id_len = cm->seq_params.frame_id_length_minus7 + 7; - aom_wb_write_literal(wb, cm->current_frame_id, frame_id_len); + if (cm->width > cm->seq_params.max_frame_width || + cm->height > cm->seq_params.max_frame_height) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Frame dimensions are larger than the maximum values"); + } + + frame_size_override_flag = + frame_is_sframe(cm) ? 1 + : (cm->width != cm->seq_params.max_frame_width || + cm->height != cm->seq_params.max_frame_height); + if (!frame_is_sframe(cm)) aom_wb_write_bit(wb, frame_size_override_flag); + + if (cm->seq_params.enable_order_hint) + aom_wb_write_literal(wb, cm->frame_offset, + cm->seq_params.order_hint_bits_minus_1 + 1); + + if (!cm->error_resilient_mode && !frame_is_intra_only(cm)) { + aom_wb_write_literal(wb, cm->primary_ref_frame, PRIMARY_REF_BITS); + } + } + + if (cm->seq_params.decoder_model_info_present_flag) { + aom_wb_write_bit(wb, cm->buffer_removal_delay_present); + if (cm->buffer_removal_delay_present) { + for (int op_num = 0; + op_num < cm->seq_params.operating_points_cnt_minus_1 + 1; op_num++) { + if (cm->op_params[op_num].decoder_model_param_present_flag) { + if (((cm->seq_params.operating_point_idc[op_num] >> + cm->temporal_layer_id) & + 0x1 && + (cm->seq_params.operating_point_idc[op_num] >> + (cm->spatial_layer_id + 8)) & + 0x1) || + cm->seq_params.operating_point_idc[op_num] == 0) { + aom_wb_write_literal( + wb, (uint32_t)cm->op_frame_timing[op_num].buffer_removal_delay, + cm->buffer_model.buffer_removal_delay_length); + cm->op_frame_timing[op_num].buffer_removal_delay++; + } + } + } + } } -#endif // CONFIG_REFERENCE_BUFFER + cpi->refresh_frame_mask = get_refresh_mask(cpi); if (cm->frame_type == KEY_FRAME) { - write_frame_size(cm, wb); - write_sb_size(cm, wb); - -#if CONFIG_ANS && ANS_MAX_SYMBOLS - assert(cpi->common.ans_window_size_log2 >= 8); - assert(cpi->common.ans_window_size_log2 < 24); - aom_wb_write_literal(wb, cpi->common.ans_window_size_log2 - 8, 4); -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - aom_wb_write_bit(wb, cm->allow_screen_content_tools); -#if CONFIG_AMVR - if (cm->allow_screen_content_tools) { - if (cm->seq_mv_precision_level == 2) { - aom_wb_write_bit(wb, 1); - } else { - aom_wb_write_bit(wb, 0); - aom_wb_write_bit(wb, cm->seq_mv_precision_level == 0); - } + if (!cm->show_frame) { // unshown keyframe (forward keyframe) + aom_wb_write_literal(wb, cpi->refresh_frame_mask, REF_FRAMES); + } else { + assert(cpi->refresh_frame_mask == 0xFF); } -#endif - } else if (cm->frame_type == INTRA_ONLY_FRAME) { - if (cm->intra_only) aom_wb_write_bit(wb, cm->allow_screen_content_tools); -#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING - if (!cm->error_resilient_mode) { - if (cm->intra_only) { - aom_wb_write_bit(wb, - cm->reset_frame_context == RESET_FRAME_CONTEXT_ALL); + } else { + if (cm->frame_type == INTRA_ONLY_FRAME) { + assert(cpi->refresh_frame_mask != 0xFF); + int updated_fb = -1; + for (int i = 0; i < REF_FRAMES; i++) { + // If more than one frame is refreshed, it doesn't matter which one + // we pick, so pick the first. + if (cpi->refresh_frame_mask & (1 << i)) { + updated_fb = i; + break; + } } - } -#endif -#if CONFIG_EXT_REFS - cpi->refresh_frame_mask = get_refresh_mask(cpi); -#endif // CONFIG_EXT_REFS - - if (cm->intra_only) { -#if CONFIG_EXT_REFS + assert(updated_fb >= 0); + cm->fb_of_context_type[cm->frame_context_idx] = updated_fb; aom_wb_write_literal(wb, cpi->refresh_frame_mask, REF_FRAMES); -#else - aom_wb_write_literal(wb, get_refresh_mask(cpi), REF_FRAMES); -#endif // CONFIG_EXT_REFS - write_frame_size(cm, wb); - -#if CONFIG_ANS && ANS_MAX_SYMBOLS - assert(cpi->common.ans_window_size_log2 >= 8); - assert(cpi->common.ans_window_size_log2 < 24); - aom_wb_write_literal(wb, cpi->common.ans_window_size_log2 - 8, 4); -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - } - } else if (cm->frame_type == INTER_FRAME) { - MV_REFERENCE_FRAME ref_frame; -#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING - if (!cm->error_resilient_mode) { - aom_wb_write_bit(wb, cm->reset_frame_context != RESET_FRAME_CONTEXT_NONE); - if (cm->reset_frame_context != RESET_FRAME_CONTEXT_NONE) - aom_wb_write_bit(wb, - cm->reset_frame_context == RESET_FRAME_CONTEXT_ALL); - } -#endif + } else if (cm->frame_type == INTER_FRAME || frame_is_sframe(cm)) { + if (cm->frame_type == INTER_FRAME) { + aom_wb_write_literal(wb, cpi->refresh_frame_mask, REF_FRAMES); + } else { + assert(frame_is_sframe(cm) && cpi->refresh_frame_mask == 0xFF); + } + int updated_fb = -1; + for (int i = 0; i < REF_FRAMES; i++) { + // If more than one frame is refreshed, it doesn't matter which one + // we pick, so pick the first. + if (cpi->refresh_frame_mask & (1 << i)) { + updated_fb = i; + break; + } + } + // large scale tile sometimes won't refresh any fbs + if (updated_fb >= 0) { + cm->fb_of_context_type[cm->frame_context_idx] = updated_fb; + } -#if CONFIG_EXT_REFS - cpi->refresh_frame_mask = get_refresh_mask(cpi); - aom_wb_write_literal(wb, cpi->refresh_frame_mask, REF_FRAMES); -#else - aom_wb_write_literal(wb, get_refresh_mask(cpi), REF_FRAMES); -#endif // CONFIG_EXT_REFS - -#if CONFIG_EXT_REFS - if (!cpi->refresh_frame_mask) { - // NOTE: "cpi->refresh_frame_mask == 0" indicates that the coded frame - // will not be used as a reference - cm->is_reference_frame = 0; - } -#endif // CONFIG_EXT_REFS - - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - assert(get_ref_frame_map_idx(cpi, ref_frame) != INVALID_IDX); - aom_wb_write_literal(wb, get_ref_frame_map_idx(cpi, ref_frame), - REF_FRAMES_LOG2); -#if !CONFIG_FRAME_SIGN_BIAS - aom_wb_write_bit(wb, cm->ref_frame_sign_bias[ref_frame]); -#endif // !CONFIG_FRAME_SIGN_BIAS -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - int i = get_ref_frame_map_idx(cpi, ref_frame); - int frame_id_len = cm->seq_params.frame_id_length_minus7 + 7; - int diff_len = cm->seq_params.delta_frame_id_length_minus2 + 2; - int delta_frame_id_minus1 = - ((cm->current_frame_id - cm->ref_frame_id[i] + - (1 << frame_id_len)) % - (1 << frame_id_len)) - - 1; - if (delta_frame_id_minus1 < 0 || - delta_frame_id_minus1 >= (1 << diff_len)) - cm->invalid_delta_frame_id_minus1 = 1; - aom_wb_write_literal(wb, delta_frame_id_minus1, diff_len); + if (!cpi->refresh_frame_mask) { + // NOTE: "cpi->refresh_frame_mask == 0" indicates that the coded frame + // will not be used as a reference + cm->is_reference_frame = 0; } -#endif // CONFIG_REFERENCE_BUFFER } + } -#if CONFIG_FRAME_SIZE - if (cm->error_resilient_mode == 0) { - write_frame_size_with_refs(cpi, wb); - } else { - write_frame_size(cm, wb); - } -#else - write_frame_size_with_refs(cpi, wb); -#endif + if (!frame_is_intra_only(cm) || cpi->refresh_frame_mask != 0xFF) { + // Write all ref frame order hints if error_resilient_mode == 1 + if (cm->error_resilient_mode && cm->seq_params.enable_order_hint) { + RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; + for (int ref_idx = 0; ref_idx < REF_FRAMES; ref_idx++) { + // Get buffer index + const int buf_idx = cm->ref_frame_map[ref_idx]; + assert(buf_idx >= 0 && buf_idx < FRAME_BUFFERS); -#if CONFIG_AMVR - if (cm->seq_mv_precision_level == 2) { - aom_wb_write_bit(wb, cm->cur_frame_mv_precision_level == 0); + // Write order hint to bit stream + aom_wb_write_literal(wb, frame_bufs[buf_idx].cur_frame_offset, + cm->seq_params.order_hint_bits_minus_1 + 1); + } } -#endif - aom_wb_write_bit(wb, cm->allow_high_precision_mv); + } - fix_interp_filter(cm, cpi->td.counts); - write_frame_interp_filter(cm->interp_filter, wb); -#if CONFIG_TEMPMV_SIGNALING - if (frame_might_use_prev_frame_mvs(cm)) { - aom_wb_write_bit(wb, cm->use_prev_frame_mvs); - } -#endif - } else if (cm->frame_type == S_FRAME) { - MV_REFERENCE_FRAME ref_frame; - -#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING - if (!cm->error_resilient_mode) { - aom_wb_write_bit(wb, cm->reset_frame_context != RESET_FRAME_CONTEXT_NONE); - if (cm->reset_frame_context != RESET_FRAME_CONTEXT_NONE) - aom_wb_write_bit(wb, - cm->reset_frame_context == RESET_FRAME_CONTEXT_ALL); - } -#endif + if (cm->frame_type == KEY_FRAME) { + write_frame_size(cm, frame_size_override_flag, wb); + assert(!av1_superres_scaled(cm) || !cm->allow_intrabc); + if (cm->allow_screen_content_tools && !av1_superres_scaled(cm)) + aom_wb_write_bit(wb, cm->allow_intrabc); + // all eight fbs are refreshed, pick one that will live long enough + cm->fb_of_context_type[REGULAR_FRAME] = 0; + } else { + if (cm->frame_type == INTRA_ONLY_FRAME) { + write_frame_size(cm, frame_size_override_flag, wb); + assert(!av1_superres_scaled(cm) || !cm->allow_intrabc); + if (cm->allow_screen_content_tools && !av1_superres_scaled(cm)) + aom_wb_write_bit(wb, cm->allow_intrabc); + } else if (cm->frame_type == INTER_FRAME || frame_is_sframe(cm)) { + MV_REFERENCE_FRAME ref_frame; -#if CONFIG_EXT_REFS - if (!cpi->refresh_frame_mask) { - // NOTE: "cpi->refresh_frame_mask == 0" indicates that the coded frame - // will not be used as a reference - cm->is_reference_frame = 0; - } -#endif // CONFIG_EXT_REFS - - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - assert(get_ref_frame_map_idx(cpi, ref_frame) != INVALID_IDX); - aom_wb_write_literal(wb, get_ref_frame_map_idx(cpi, ref_frame), - REF_FRAMES_LOG2); - assert(cm->ref_frame_sign_bias[ref_frame] == 0); -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - int i = get_ref_frame_map_idx(cpi, ref_frame); - int frame_id_len = cm->seq_params.frame_id_length_minus7 + 7; - int diff_len = cm->seq_params.delta_frame_id_length_minus2 + 2; - int delta_frame_id_minus1 = - ((cm->current_frame_id - cm->ref_frame_id[i] + - (1 << frame_id_len)) % - (1 << frame_id_len)) - - 1; - if (delta_frame_id_minus1 < 0 || - delta_frame_id_minus1 >= (1 << diff_len)) - cm->invalid_delta_frame_id_minus1 = 1; - aom_wb_write_literal(wb, delta_frame_id_minus1, diff_len); + // NOTE: Error resilient mode turns off frame_refs_short_signaling + // automatically. +#define FRAME_REFS_SHORT_SIGNALING 0 +#if FRAME_REFS_SHORT_SIGNALING + cm->frame_refs_short_signaling = cm->seq_params.enable_order_hint; +#endif // FRAME_REFS_SHORT_SIGNALING + + if (cm->frame_refs_short_signaling) { + // NOTE(zoeliu@google.com): + // An example solution for encoder-side implementation on frame refs + // short signaling, which is only turned on when the encoder side + // decision on ref frames is identical to that at the decoder side. + check_frame_refs_short_signaling(cpi); } -#endif // CONFIG_REFERENCE_BUFFER - } -#if CONFIG_FRAME_SIZE - if (cm->error_resilient_mode == 0) { - write_frame_size_with_refs(cpi, wb); - } else { - write_frame_size(cm, wb); - } -#else - write_frame_size_with_refs(cpi, wb); -#endif + if (cm->seq_params.enable_order_hint) + aom_wb_write_bit(wb, cm->frame_refs_short_signaling); - aom_wb_write_bit(wb, cm->allow_high_precision_mv); + if (cm->frame_refs_short_signaling) { + const int lst_ref = get_ref_frame_map_idx(cpi, LAST_FRAME); + aom_wb_write_literal(wb, lst_ref, REF_FRAMES_LOG2); - fix_interp_filter(cm, cpi->td.counts); - write_frame_interp_filter(cm->interp_filter, wb); -#if CONFIG_TEMPMV_SIGNALING - if (frame_might_use_prev_frame_mvs(cm)) { - aom_wb_write_bit(wb, cm->use_prev_frame_mvs); - } -#endif - } + const int gld_ref = get_ref_frame_map_idx(cpi, GOLDEN_FRAME); + aom_wb_write_literal(wb, gld_ref, REF_FRAMES_LOG2); + } -#if CONFIG_MFMV - if (cm->show_frame == 0) { - int arf_offset = AOMMIN( - (MAX_GF_INTERVAL - 1), - cpi->twopass.gf_group.arf_src_offset[cpi->twopass.gf_group.index]); -#if CONFIG_EXT_REFS - int brf_offset = - cpi->twopass.gf_group.brf_src_offset[cpi->twopass.gf_group.index]; + for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { + assert(get_ref_frame_map_idx(cpi, ref_frame) != INVALID_IDX); + if (!cm->frame_refs_short_signaling) + aom_wb_write_literal(wb, get_ref_frame_map_idx(cpi, ref_frame), + REF_FRAMES_LOG2); + if (cm->seq_params.frame_id_numbers_present_flag) { + int i = get_ref_frame_map_idx(cpi, ref_frame); + int frame_id_len = cm->seq_params.frame_id_length; + int diff_len = cm->seq_params.delta_frame_id_length; + int delta_frame_id_minus_1 = + ((cm->current_frame_id - cm->ref_frame_id[i] + + (1 << frame_id_len)) % + (1 << frame_id_len)) - + 1; + if (delta_frame_id_minus_1 < 0 || + delta_frame_id_minus_1 >= (1 << diff_len)) + cm->invalid_delta_frame_id_minus_1 = 1; + aom_wb_write_literal(wb, delta_frame_id_minus_1, diff_len); + } + } - arf_offset = AOMMIN((MAX_GF_INTERVAL - 1), arf_offset + brf_offset); -#endif - aom_wb_write_literal(wb, arf_offset, 4); - } -#endif + if (!cm->error_resilient_mode && frame_size_override_flag) { + write_frame_size_with_refs(cpi, wb); + } else { + write_frame_size(cm, frame_size_override_flag, wb); + } -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - cm->refresh_mask = - cm->frame_type == KEY_FRAME ? 0xFF : get_refresh_mask(cpi); + if (cm->cur_frame_force_integer_mv) { + cm->allow_high_precision_mv = 0; + } else { + aom_wb_write_bit(wb, cm->allow_high_precision_mv); + } + fix_interp_filter(cm, cpi->td.counts); + write_frame_interp_filter(cm->interp_filter, wb); + aom_wb_write_bit(wb, cm->switchable_motion_mode); + if (frame_might_allow_ref_frame_mvs(cm)) { + aom_wb_write_bit(wb, cm->allow_ref_frame_mvs); + } else { + assert(cm->allow_ref_frame_mvs == 0); + } + } } -#endif // CONFIG_REFERENCE_BUFFER - if (!cm->error_resilient_mode) { + const int might_bwd_adapt = + !(cm->seq_params.reduced_still_picture_hdr) && !(cm->disable_cdf_update); + if (cm->large_scale_tile) + cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; + + if (might_bwd_adapt) { aom_wb_write_bit( - wb, cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_FORWARD); + wb, cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_DISABLED); } -#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING - aom_wb_write_literal(wb, cm->frame_context_idx, FRAME_CONTEXTS_LOG2); -#endif - encode_loopfilter(cm, wb); + + write_tile_info(cm, saved_wb, wb); encode_quantization(cm, wb); encode_segmentation(cm, xd, wb); - { - int i; - struct segmentation *const seg = &cm->seg; - int segment_quantizer_active = 0; - for (i = 0; i < MAX_SEGMENTS; i++) { - if (segfeature_active(seg, i, SEG_LVL_ALT_Q)) { - segment_quantizer_active = 1; - } - } - if (cm->delta_q_present_flag) - assert(segment_quantizer_active == 0 && cm->base_qindex > 0); - if (segment_quantizer_active == 0 && cm->base_qindex > 0) { - aom_wb_write_bit(wb, cm->delta_q_present_flag); - if (cm->delta_q_present_flag) { - aom_wb_write_literal(wb, OD_ILOG_NZ(cm->delta_q_res) - 1, 2); - xd->prev_qindex = cm->base_qindex; -#if CONFIG_EXT_DELTA_Q - assert(seg->abs_delta == SEGMENT_DELTADATA); + if (cm->delta_q_present_flag) assert(cm->base_qindex > 0); + if (cm->base_qindex > 0) { + aom_wb_write_bit(wb, cm->delta_q_present_flag); + if (cm->delta_q_present_flag) { + aom_wb_write_literal(wb, OD_ILOG_NZ(cm->delta_q_res) - 1, 2); + xd->current_qindex = cm->base_qindex; + if (cm->allow_intrabc) + assert(cm->delta_lf_present_flag == 0); + else aom_wb_write_bit(wb, cm->delta_lf_present_flag); - if (cm->delta_lf_present_flag) { - aom_wb_write_literal(wb, OD_ILOG_NZ(cm->delta_lf_res) - 1, 2); -#if CONFIG_LOOPFILTER_LEVEL - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) - xd->prev_delta_lf[lf_id] = 0; -#endif // CONFIG_LOOPFILTER_LEVEL - xd->prev_delta_lf_from_base = 0; - } -#endif // CONFIG_EXT_DELTA_Q + if (cm->delta_lf_present_flag) { + aom_wb_write_literal(wb, OD_ILOG_NZ(cm->delta_lf_res) - 1, 2); + aom_wb_write_bit(wb, cm->delta_lf_multi); + av1_reset_loop_filter_delta(xd, av1_num_planes(cm)); } } } -#if CONFIG_CDEF - if (!cm->all_lossless) { - encode_cdef(cm, wb); + + if (cm->all_lossless) { + assert(!av1_superres_scaled(cm)); + } else { + if (!cm->coded_lossless) { + encode_loopfilter(cm, wb); + encode_cdef(cm, wb); + } + encode_restoration_mode(cm, wb); } -#endif -#if CONFIG_LOOP_RESTORATION - encode_restoration_mode(cm, wb); -#endif // CONFIG_LOOP_RESTORATION + write_tx_mode(cm, &cm->tx_mode, wb); if (cpi->allow_comp_inter_inter) { const int use_hybrid_pred = cm->reference_mode == REFERENCE_MODE_SELECT; -#if !CONFIG_REF_ADAPT - const int use_compound_pred = cm->reference_mode != SINGLE_REFERENCE; -#endif // !CONFIG_REF_ADAPT aom_wb_write_bit(wb, use_hybrid_pred); -#if !CONFIG_REF_ADAPT - if (!use_hybrid_pred) aom_wb_write_bit(wb, use_compound_pred); -#endif // !CONFIG_REF_ADAPT } - write_compound_tools(cm, wb); - -#if CONFIG_EXT_TX - aom_wb_write_bit(wb, cm->reduced_tx_set_used); -#endif // CONFIG_EXT_TX - -#if CONFIG_GLOBAL_MOTION - if (!frame_is_intra_only(cm)) write_global_motion(cpi, wb); -#endif // CONFIG_GLOBAL_MOTION - - write_tile_info(cm, wb); -} -#endif // CONFIG_OBU - -static uint32_t write_compressed_header(AV1_COMP *cpi, uint8_t *data) { - AV1_COMMON *const cm = &cpi->common; -#if CONFIG_SUPERTX - MACROBLOCKD *const xd = &cpi->td.mb.e_mbd; -#endif // CONFIG_SUPERTX - FRAME_CONTEXT *const fc = cm->fc; - aom_writer *header_bc; - int i; -#if !CONFIG_NEW_MULTISYMBOL - FRAME_COUNTS *counts = cpi->td.counts; - int j; -#endif - - const int probwt = cm->num_tg; - (void)probwt; - (void)i; - (void)fc; - - aom_writer real_header_bc; - header_bc = &real_header_bc; -#if CONFIG_ANS - header_bc->size = 1 << cpi->common.ans_window_size_log2; -#endif - aom_start_encode(header_bc, data); -#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX) - if (cm->tx_mode == TX_MODE_SELECT) - av1_cond_prob_diff_update(header_bc, &cm->fc->quarter_tx_size_prob, - cm->counts.quarter_tx_size, probwt); -#endif -#if CONFIG_LV_MAP - av1_write_txb_probs(cpi, header_bc); -#endif // CONFIG_LV_MAP + if (cm->is_skip_mode_allowed) aom_wb_write_bit(wb, cm->skip_mode_flag); -#if CONFIG_VAR_TX && !CONFIG_NEW_MULTISYMBOL - if (cm->tx_mode == TX_MODE_SELECT) - update_txfm_partition_probs(cm, header_bc, counts, probwt); -#endif - -#if !CONFIG_NEW_MULTISYMBOL - update_skip_probs(cm, header_bc, counts); -#endif - - if (!frame_is_intra_only(cm)) { -#if !CONFIG_NEW_MULTISYMBOL - update_inter_mode_probs(cm, header_bc, counts); -#endif -#if CONFIG_INTERINTRA - if (cm->reference_mode != COMPOUND_REFERENCE && - cm->allow_interintra_compound) { -#if !CONFIG_NEW_MULTISYMBOL - for (i = 0; i < BLOCK_SIZE_GROUPS; i++) { - if (is_interintra_allowed_bsize_group(i)) { - av1_cond_prob_diff_update(header_bc, &fc->interintra_prob[i], - cm->counts.interintra[i], probwt); - } - } -#endif -#if CONFIG_WEDGE && !CONFIG_NEW_MULTISYMBOL -#if CONFIG_EXT_PARTITION_TYPES - int block_sizes_to_update = BLOCK_SIZES_ALL; -#else - int block_sizes_to_update = BLOCK_SIZES; -#endif - for (i = 0; i < block_sizes_to_update; i++) { - if (is_interintra_allowed_bsize(i) && is_interintra_wedge_used(i)) - av1_cond_prob_diff_update(header_bc, &fc->wedge_interintra_prob[i], - cm->counts.wedge_interintra[i], probwt); - } -#endif // CONFIG_WEDGE && CONFIG_NEW_MULTISYMBOL - } -#endif // CONFIG_INTERINTRA - -#if !CONFIG_NEW_MULTISYMBOL - for (i = 0; i < INTRA_INTER_CONTEXTS; i++) - av1_cond_prob_diff_update(header_bc, &fc->intra_inter_prob[i], - counts->intra_inter[i], probwt); -#endif + if (frame_might_allow_warped_motion(cm)) + aom_wb_write_bit(wb, cm->allow_warped_motion); + else + assert(!cm->allow_warped_motion); -#if !CONFIG_NEW_MULTISYMBOL - if (cpi->allow_comp_inter_inter) { - const int use_hybrid_pred = cm->reference_mode == REFERENCE_MODE_SELECT; - if (use_hybrid_pred) - for (i = 0; i < COMP_INTER_CONTEXTS; i++) - av1_cond_prob_diff_update(header_bc, &fc->comp_inter_prob[i], - counts->comp_inter[i], probwt); - } + aom_wb_write_bit(wb, cm->reduced_tx_set_used); - if (cm->reference_mode != COMPOUND_REFERENCE) { - for (i = 0; i < REF_CONTEXTS; i++) { - for (j = 0; j < (SINGLE_REFS - 1); j++) { - av1_cond_prob_diff_update(header_bc, &fc->single_ref_prob[i][j], - counts->single_ref[i][j], probwt); - } - } - } + if (!frame_is_intra_only(cm)) write_global_motion(cpi, wb); - if (cm->reference_mode != SINGLE_REFERENCE) { -#if CONFIG_EXT_COMP_REFS - for (i = 0; i < COMP_REF_TYPE_CONTEXTS; i++) - av1_cond_prob_diff_update(header_bc, &fc->comp_ref_type_prob[i], - counts->comp_ref_type[i], probwt); - - for (i = 0; i < UNI_COMP_REF_CONTEXTS; i++) - for (j = 0; j < (UNIDIR_COMP_REFS - 1); j++) - av1_cond_prob_diff_update(header_bc, &fc->uni_comp_ref_prob[i][j], - counts->uni_comp_ref[i][j], probwt); -#endif // CONFIG_EXT_COMP_REFS - - for (i = 0; i < REF_CONTEXTS; i++) { -#if CONFIG_EXT_REFS - for (j = 0; j < (FWD_REFS - 1); j++) { - av1_cond_prob_diff_update(header_bc, &fc->comp_ref_prob[i][j], - counts->comp_ref[i][j], probwt); - } - for (j = 0; j < (BWD_REFS - 1); j++) { - av1_cond_prob_diff_update(header_bc, &fc->comp_bwdref_prob[i][j], - counts->comp_bwdref[i][j], probwt); - } -#else - for (j = 0; j < (COMP_REFS - 1); j++) { - av1_cond_prob_diff_update(header_bc, &fc->comp_ref_prob[i][j], - counts->comp_ref[i][j], probwt); - } -#endif // CONFIG_EXT_REFS - } + if (cm->film_grain_params_present && (cm->show_frame || cm->showable_frame)) { + int flip_back_update_parameters_flag = 0; + if (cm->frame_type != INTER_FRAME && + cm->film_grain_params.update_parameters == 0) { + cm->film_grain_params.update_parameters = 1; + flip_back_update_parameters_flag = 1; } -#endif // CONFIG_NEW_MULTISYMBOL - -#if CONFIG_COMPOUND_SINGLEREF - for (i = 0; i < COMP_INTER_MODE_CONTEXTS; i++) - av1_cond_prob_diff_update(header_bc, &fc->comp_inter_mode_prob[i], - counts->comp_inter_mode[i], probwt); -#endif // CONFIG_COMPOUND_SINGLEREF + write_film_grain_params(cpi, wb); -#if !CONFIG_NEW_MULTISYMBOL - av1_write_nmv_probs(cm, cm->allow_high_precision_mv, header_bc, counts->mv); -#endif -#if CONFIG_SUPERTX - if (!xd->lossless[0]) update_supertx_probs(cm, probwt, header_bc); -#endif // CONFIG_SUPERTX + if (flip_back_update_parameters_flag) + cm->film_grain_params.update_parameters = 0; } - aom_stop_encode(header_bc); - assert(header_bc->pos <= 0xffff); - return header_bc->pos; + + if (cm->large_scale_tile) write_ext_tile_info(cm, saved_wb, wb); } -#if !CONFIG_OBU || CONFIG_EXT_TILE static int choose_size_bytes(uint32_t size, int spare_msbs) { // Choose the number of bytes required to represent size, without // using the 'spare_msbs' number of most significant bits. @@ -5394,116 +3337,112 @@ static int remux_tiles(const AV1_COMMON *const cm, uint8_t *dst, int tsb; int tcsb; -#if CONFIG_EXT_TILE if (cm->large_scale_tile) { // The top bit in the tile size field indicates tile copy mode, so we // have 1 less bit to code the tile size tsb = choose_size_bytes(max_tile_size, 1); tcsb = choose_size_bytes(max_tile_col_size, 0); } else { -#endif // CONFIG_EXT_TILE tsb = choose_size_bytes(max_tile_size, 0); tcsb = 4; // This is ignored (void)max_tile_col_size; -#if CONFIG_EXT_TILE } -#endif // CONFIG_EXT_TILE assert(tsb > 0); assert(tcsb > 0); *tile_size_bytes = tsb; *tile_col_size_bytes = tcsb; + if (tsb == 4 && tcsb == 4) return data_size; - if (tsb == 4 && tcsb == 4) { - return data_size; - } else { - uint32_t wpos = 0; - uint32_t rpos = 0; - -#if CONFIG_EXT_TILE - if (cm->large_scale_tile) { - int tile_row; - int tile_col; - - for (tile_col = 0; tile_col < cm->tile_cols; tile_col++) { - // All but the last column has a column header - if (tile_col < cm->tile_cols - 1) { - uint32_t tile_col_size = mem_get_le32(dst + rpos); - rpos += 4; - - // Adjust the tile column size by the number of bytes removed - // from the tile size fields. - tile_col_size -= (4 - tsb) * cm->tile_rows; - - mem_put_varsize(dst + wpos, tcsb, tile_col_size); - wpos += tcsb; - } + uint32_t wpos = 0; + uint32_t rpos = 0; - for (tile_row = 0; tile_row < cm->tile_rows; tile_row++) { - // All, including the last row has a header - uint32_t tile_header = mem_get_le32(dst + rpos); - rpos += 4; - - // If this is a copy tile, we need to shift the MSB to the - // top bit of the new width, and there is no data to copy. - if (tile_header >> 31 != 0) { - if (tsb < 4) tile_header >>= 32 - 8 * tsb; - mem_put_varsize(dst + wpos, tsb, tile_header); - wpos += tsb; - } else { - mem_put_varsize(dst + wpos, tsb, tile_header); - wpos += tsb; + if (cm->large_scale_tile) { + int tile_row; + int tile_col; - memmove(dst + wpos, dst + rpos, tile_header); - rpos += tile_header; - wpos += tile_header; - } - } + for (tile_col = 0; tile_col < cm->tile_cols; tile_col++) { + // All but the last column has a column header + if (tile_col < cm->tile_cols - 1) { + uint32_t tile_col_size = mem_get_le32(dst + rpos); + rpos += 4; + + // Adjust the tile column size by the number of bytes removed + // from the tile size fields. + tile_col_size -= (4 - tsb) * cm->tile_rows; + + mem_put_varsize(dst + wpos, tcsb, tile_col_size); + wpos += tcsb; } - } else { -#endif // CONFIG_EXT_TILE - const int n_tiles = cm->tile_cols * cm->tile_rows; - int n; - for (n = 0; n < n_tiles; n++) { - int tile_size; + for (tile_row = 0; tile_row < cm->tile_rows; tile_row++) { + // All, including the last row has a header + uint32_t tile_header = mem_get_le32(dst + rpos); + rpos += 4; - if (n == n_tiles - 1) { - tile_size = data_size - rpos; + // If this is a copy tile, we need to shift the MSB to the + // top bit of the new width, and there is no data to copy. + if (tile_header >> 31 != 0) { + if (tsb < 4) tile_header >>= 32 - 8 * tsb; + mem_put_varsize(dst + wpos, tsb, tile_header); + wpos += tsb; } else { - tile_size = mem_get_le32(dst + rpos); - rpos += 4; - mem_put_varsize(dst + wpos, tsb, tile_size); + mem_put_varsize(dst + wpos, tsb, tile_header); wpos += tsb; - } - memmove(dst + wpos, dst + rpos, tile_size); - - rpos += tile_size; - wpos += tile_size; + tile_header += AV1_MIN_TILE_SIZE_BYTES; + memmove(dst + wpos, dst + rpos, tile_header); + rpos += tile_header; + wpos += tile_header; + } } -#if CONFIG_EXT_TILE } -#endif // CONFIG_EXT_TILE assert(rpos > wpos); assert(rpos == data_size); return wpos; } + const int n_tiles = cm->tile_cols * cm->tile_rows; + int n; + + for (n = 0; n < n_tiles; n++) { + int tile_size; + + if (n == n_tiles - 1) { + tile_size = data_size - rpos; + } else { + tile_size = mem_get_le32(dst + rpos); + rpos += 4; + mem_put_varsize(dst + wpos, tsb, tile_size); + tile_size += AV1_MIN_TILE_SIZE_BYTES; + wpos += tsb; + } + + memmove(dst + wpos, dst + rpos, tile_size); + + rpos += tile_size; + wpos += tile_size; + } + + assert(rpos > wpos); + assert(rpos == data_size); + + return wpos; } -#endif -#if CONFIG_OBU -static uint32_t write_obu_header(OBU_TYPE obu_type, int obu_extension, - uint8_t *const dst) { +uint32_t write_obu_header(OBU_TYPE obu_type, int obu_extension, + uint8_t *const dst) { struct aom_write_bit_buffer wb = { dst, 0 }; uint32_t size = 0; - aom_wb_write_literal(&wb, (int)obu_type, 5); - aom_wb_write_literal(&wb, 0, 2); + aom_wb_write_literal(&wb, 0, 1); // forbidden bit. + aom_wb_write_literal(&wb, (int)obu_type, 4); aom_wb_write_literal(&wb, obu_extension ? 1 : 0, 1); + aom_wb_write_literal(&wb, 1, 1); // obu_has_payload_length_field + aom_wb_write_literal(&wb, 0, 1); // reserved + if (obu_extension) { aom_wb_write_literal(&wb, obu_extension & 0xFF, 8); } @@ -5512,87 +3451,156 @@ static uint32_t write_obu_header(OBU_TYPE obu_type, int obu_extension, return size; } -static uint32_t write_temporal_delimiter_obu() { return 0; } +int write_uleb_obu_size(uint32_t obu_header_size, uint32_t obu_payload_size, + uint8_t *dest) { + const uint32_t obu_size = obu_payload_size; + const uint32_t offset = obu_header_size; + size_t coded_obu_size = 0; -static uint32_t write_sequence_header_obu(AV1_COMP *cpi, uint8_t *const dst) { - AV1_COMMON *const cm = &cpi->common; - SequenceHeader *const seq_params = &cm->seq_params; - struct aom_write_bit_buffer wb = { dst, 0 }; - uint32_t size = 0; + if (aom_uleb_encode(obu_size, sizeof(obu_size), dest + offset, + &coded_obu_size) != 0) { + return AOM_CODEC_ERROR; + } - write_profile(cm->profile, &wb); + return AOM_CODEC_OK; +} - aom_wb_write_literal(&wb, 0, 4); +static size_t obu_memmove(uint32_t obu_header_size, uint32_t obu_payload_size, + uint8_t *data) { + const size_t length_field_size = aom_uleb_size_in_bytes(obu_payload_size); + const uint32_t move_dst_offset = + (uint32_t)length_field_size + obu_header_size; + const uint32_t move_src_offset = obu_header_size; + const uint32_t move_size = obu_payload_size; + memmove(data + move_dst_offset, data + move_src_offset, move_size); + return length_field_size; +} - seq_params->frame_id_numbers_present_flag = FRAME_ID_NUMBERS_PRESENT_FLAG; - aom_wb_write_literal(&wb, seq_params->frame_id_numbers_present_flag, 1); - if (seq_params->frame_id_numbers_present_flag) { - seq_params->frame_id_length_minus7 = FRAME_ID_LENGTH_MINUS7; - seq_params->delta_frame_id_length_minus2 = DELTA_FRAME_ID_LENGTH_MINUS2; - aom_wb_write_literal(&wb, seq_params->frame_id_length_minus7, 4); - aom_wb_write_literal(&wb, seq_params->delta_frame_id_length_minus2, 4); +static void add_trailing_bits(struct aom_write_bit_buffer *wb) { + if (aom_wb_is_byte_aligned(wb)) { + aom_wb_write_literal(wb, 0x80, 8); + } else { + // assumes that the other bits are already 0s + aom_wb_write_bit(wb, 1); } +} - // color_config - write_bitdepth_colorspace_sampling(cm, &wb); - - size = aom_wb_bytes_written(&wb); - return size; +static void write_bitstream_level(BitstreamLevel bl, + struct aom_write_bit_buffer *wb) { + uint8_t seq_level_idx = major_minor_to_seq_level_idx(bl); + assert(is_valid_seq_level_idx(seq_level_idx)); + aom_wb_write_literal(wb, seq_level_idx, LEVEL_BITS); } -static uint32_t write_frame_header_obu(AV1_COMP *cpi, uint8_t *const dst) { +static uint32_t write_sequence_header_obu(AV1_COMP *cpi, uint8_t *const dst) { AV1_COMMON *const cm = &cpi->common; struct aom_write_bit_buffer wb = { dst, 0 }; - uint32_t total_size = 0; - uint32_t compressed_hdr_size, uncompressed_hdr_size; + uint32_t size = 0; - write_uncompressed_header_obu(cpi, &wb); + write_profile(cm->profile, &wb); - if (cm->show_existing_frame) { - total_size = aom_wb_bytes_written(&wb); - return total_size; + // Still picture or not + aom_wb_write_bit(&wb, cm->seq_params.still_picture); + assert(IMPLIES(!cm->seq_params.still_picture, + !cm->seq_params.reduced_still_picture_hdr)); + // whether to use reduced still picture header + aom_wb_write_bit(&wb, cm->seq_params.reduced_still_picture_hdr); + + if (cm->seq_params.reduced_still_picture_hdr) { + assert(cm->timing_info_present == 0); + assert(cm->seq_params.decoder_model_info_present_flag == 0); + assert(cm->seq_params.display_model_info_present_flag == 0); + write_bitstream_level(cm->seq_params.level[0], &wb); + } else { + aom_wb_write_bit(&wb, cm->timing_info_present); // timing info present flag + + if (cm->timing_info_present) { + // timing_info + write_timing_info_header(cm, &wb); + aom_wb_write_bit(&wb, cm->seq_params.decoder_model_info_present_flag); + if (cm->seq_params.decoder_model_info_present_flag) { + write_decoder_model_info(cm, &wb); + } + } + aom_wb_write_bit(&wb, cm->seq_params.display_model_info_present_flag); + aom_wb_write_literal(&wb, cm->seq_params.operating_points_cnt_minus_1, + OP_POINTS_CNT_MINUS_1_BITS); + int i; + for (i = 0; i < cm->seq_params.operating_points_cnt_minus_1 + 1; i++) { + aom_wb_write_literal(&wb, cm->seq_params.operating_point_idc[i], + OP_POINTS_IDC_BITS); + write_bitstream_level(cm->seq_params.level[i], &wb); + if (cm->seq_params.level[i].major > 3) + aom_wb_write_bit(&wb, cm->seq_params.tier[i]); + if (cm->seq_params.decoder_model_info_present_flag) { + aom_wb_write_bit(&wb, + cm->op_params[i].decoder_model_param_present_flag); + if (cm->op_params[i].decoder_model_param_present_flag) + write_dec_model_op_parameters(cm, &wb, i); + } + if (cm->seq_params.display_model_info_present_flag) { + aom_wb_write_bit(&wb, + cm->op_params[i].display_model_param_present_flag); + if (cm->op_params[i].display_model_param_present_flag) { + assert(cm->op_params[i].initial_display_delay <= 10); + aom_wb_write_literal(&wb, cm->op_params[i].initial_display_delay - 1, + 4); + } + } + } } + write_sequence_header(cpi, &wb); - // write the tile length code (Always 4 bytes for now) - aom_wb_write_literal(&wb, 3, 2); + write_color_config(cm, &wb); - if (!use_compressed_header(cm)) { - uncompressed_hdr_size = aom_wb_bytes_written(&wb); - compressed_hdr_size = 0; - } else { - // placeholder for the compressed header length - struct aom_write_bit_buffer compr_hdr_len_wb = wb; - aom_wb_write_literal(&wb, 0, 16); + aom_wb_write_bit(&wb, cm->film_grain_params_present); - uncompressed_hdr_size = aom_wb_bytes_written(&wb); - compressed_hdr_size = - write_compressed_header(cpi, dst + uncompressed_hdr_size); - aom_wb_overwrite_literal(&compr_hdr_len_wb, (int)(compressed_hdr_size), 16); - } + add_trailing_bits(&wb); - total_size = uncompressed_hdr_size + compressed_hdr_size; - return total_size; + size = aom_wb_bytes_written(&wb); + return size; +} + +static uint32_t write_frame_header_obu(AV1_COMP *cpi, + struct aom_write_bit_buffer *saved_wb, + uint8_t *const dst, + int append_trailing_bits) { + struct aom_write_bit_buffer wb = { dst, 0 }; + write_uncompressed_header_obu(cpi, saved_wb, &wb); + if (append_trailing_bits) add_trailing_bits(&wb); + return aom_wb_bytes_written(&wb); } static uint32_t write_tile_group_header(uint8_t *const dst, int startTile, - int endTile, int tiles_log2) { + int endTile, int tiles_log2, + int tile_start_and_end_present_flag) { struct aom_write_bit_buffer wb = { dst, 0 }; uint32_t size = 0; - aom_wb_write_literal(&wb, startTile, tiles_log2); - aom_wb_write_literal(&wb, endTile, tiles_log2); + if (!tiles_log2) return size; + + aom_wb_write_bit(&wb, tile_start_and_end_present_flag); + + if (tile_start_and_end_present_flag) { + aom_wb_write_literal(&wb, startTile, tiles_log2); + aom_wb_write_literal(&wb, endTile, tiles_log2); + } size = aom_wb_bytes_written(&wb); return size; } +typedef struct { + uint8_t *frame_header; + size_t obu_header_byte_offset; + size_t total_length; +} FrameHeaderInfo; + static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, - unsigned int *max_tile_size, - unsigned int *max_tile_col_size, - uint8_t *const frame_header_obu_location, - uint32_t frame_header_obu_size, - int insert_frame_header_obu_flag) { - const AV1_COMMON *const cm = &cpi->common; + struct aom_write_bit_buffer *saved_wb, + uint8_t obu_extension_header, + const FrameHeaderInfo *fh_info) { + AV1_COMMON *const cm = &cpi->common; aom_writer mode_bc; int tile_row, tile_col; TOKENEXTRA *(*const tok_buffers)[MAX_TILE_COLS] = cpi->tile_tok; @@ -5601,29 +3609,53 @@ static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, const int tile_cols = cm->tile_cols; const int tile_rows = cm->tile_rows; unsigned int tile_size = 0; + unsigned int max_tile_size = 0; + unsigned int max_tile_col_size = 0; const int n_log2_tiles = cm->log2_tile_rows + cm->log2_tile_cols; // Fixed size tile groups for the moment const int num_tg_hdrs = cm->num_tg; const int tg_size = -#if CONFIG_EXT_TILE (cm->large_scale_tile) ? 1 - : -#endif // CONFIG_EXT_TILE - (tile_rows * tile_cols + num_tg_hdrs - 1) / num_tg_hdrs; + : (tile_rows * tile_cols + num_tg_hdrs - 1) / num_tg_hdrs; int tile_count = 0; int curr_tg_data_size = 0; uint8_t *data = dst; int new_tg = 1; -#if CONFIG_EXT_TILE const int have_tiles = tile_cols * tile_rows > 1; -#endif + int first_tg = 1; - *max_tile_size = 0; - *max_tile_col_size = 0; + cm->largest_tile_id = 0; -#if CONFIG_EXT_TILE if (cm->large_scale_tile) { + // For large_scale_tile case, we always have only one tile group, so it can + // be written as an OBU_FRAME. + const OBU_TYPE obu_type = OBU_FRAME; + const uint32_t tg_hdr_size = write_obu_header(obu_type, 0, data); + data += tg_hdr_size; + + const uint32_t frame_header_size = + write_frame_header_obu(cpi, saved_wb, data, 0); + data += frame_header_size; + total_size += frame_header_size; + +#define EXT_TILE_DEBUG 0 +#if EXT_TILE_DEBUG + { + char fn[20] = "./fh"; + fn[4] = cm->current_video_frame / 100 + '0'; + fn[5] = (cm->current_video_frame % 100) / 10 + '0'; + fn[6] = (cm->current_video_frame % 10) + '0'; + fn[7] = '\0'; + av1_print_uncompressed_frame_header(data - frame_header_size, + frame_header_size, fn); + } +#endif // EXT_TILE_DEBUG +#undef EXT_TILE_DEBUG + + int tile_size_bytes = 0; + int tile_col_size_bytes = 0; + for (tile_col = 0; tile_col < tile_cols; tile_col++) { TileInfo tile_info; const int is_last_col = (tile_col == tile_cols - 1); @@ -5643,7 +3675,7 @@ static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; av1_tile_set_row(&tile_info, cm, tile_row); - buf->data = dst + total_size; + buf->data = dst + total_size + tg_hdr_size; // Is CONFIG_EXT_TILE = 1, every tile in the row has a header, // even for the last one, unless no tiling is used at all. @@ -5651,29 +3683,25 @@ static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, // Initialise tile context from the frame context this_tile->tctx = *cm->fc; cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = &this_tile->pvq_q; - cpi->td.mb.daala_enc.state.adapt = &this_tile->tctx.pvq_context; -#endif // CONFIG_PVQ -#if CONFIG_ANS - mode_bc.size = 1 << cpi->common.ans_window_size_log2; -#endif + mode_bc.allow_update_cdf = !cm->large_scale_tile; + mode_bc.allow_update_cdf = + mode_bc.allow_update_cdf && !cm->disable_cdf_update; aom_start_encode(&mode_bc, buf->data + data_offset); write_modes(cpi, &tile_info, &mode_bc, &tok, tok_end); assert(tok == tok_end); aom_stop_encode(&mode_bc); tile_size = mode_bc.pos; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = NULL; -#endif buf->size = tile_size; // Record the maximum tile size we see, so we can compact headers later. - *max_tile_size = AOMMAX(*max_tile_size, tile_size); + if (tile_size > max_tile_size) { + max_tile_size = tile_size; + cm->largest_tile_id = tile_cols * tile_row + tile_col; + } if (have_tiles) { // tile header: size of this tile, or copy offset - uint32_t tile_header = tile_size; + uint32_t tile_header = tile_size - AV1_MIN_TILE_SIZE_BYTES; const int tile_copy_mode = ((AOMMAX(cm->tile_width, cm->tile_height) << MI_SIZE_LOG2) <= 256) ? 1 @@ -5683,12 +3711,12 @@ static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, // Very low chances to have copy tiles on the key frames, so don't // search on key frames to reduce unnecessary search. if (cm->frame_type != KEY_FRAME && tile_copy_mode) { - const int idendical_tile_offset = + const int identical_tile_offset = find_identical_tile(tile_row, tile_col, tile_buffers); - if (idendical_tile_offset > 0) { + if (identical_tile_offset > 0) { tile_size = 0; - tile_header = idendical_tile_offset | 0x80; + tile_header = identical_tile_offset | 0x80; tile_header <<= 24; } } @@ -5701,263 +3729,287 @@ static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, if (!is_last_col) { uint32_t col_size = total_size - col_offset - 4; - mem_put_le32(dst + col_offset, col_size); + mem_put_le32(dst + col_offset + tg_hdr_size, col_size); - // If it is not final packing, record the maximum tile column size we - // see, otherwise, check if the tile size is out of the range. - *max_tile_col_size = AOMMAX(*max_tile_col_size, col_size); + // Record the maximum tile column size we see. + max_tile_col_size = AOMMAX(max_tile_col_size, col_size); } } - } else { -#endif // CONFIG_EXT_TILE - for (tile_row = 0; tile_row < tile_rows; tile_row++) { - TileInfo tile_info; - const int is_last_row = (tile_row == tile_rows - 1); - av1_tile_set_row(&tile_info, cm, tile_row); + if (have_tiles) { + total_size = remux_tiles(cm, data, total_size - frame_header_size, + max_tile_size, max_tile_col_size, + &tile_size_bytes, &tile_col_size_bytes); + total_size += frame_header_size; + } + + // In EXT_TILE case, only use 1 tile group. Follow the obu syntax, write + // current tile group size before tile data(include tile column header). + // Tile group size doesn't include the bytes storing tg size. + total_size += tg_hdr_size; + const uint32_t obu_payload_size = total_size - tg_hdr_size; + const size_t length_field_size = + obu_memmove(tg_hdr_size, obu_payload_size, dst); + if (write_uleb_obu_size(tg_hdr_size, obu_payload_size, dst) != + AOM_CODEC_OK) { + assert(0); + } + total_size += (uint32_t)length_field_size; + saved_wb->bit_buffer += length_field_size; - for (tile_col = 0; tile_col < tile_cols; tile_col++) { - const int tile_idx = tile_row * tile_cols + tile_col; - TileBufferEnc *const buf = &tile_buffers[tile_row][tile_col]; - TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; - const TOKENEXTRA *tok = tok_buffers[tile_row][tile_col]; - const TOKENEXTRA *tok_end = tok + cpi->tok_count[tile_row][tile_col]; - const int is_last_col = (tile_col == tile_cols - 1); - const int is_last_tile = is_last_col && is_last_row; - int is_last_tile_in_tg = 0; - - if (new_tg) { - if (insert_frame_header_obu_flag && tile_idx) { - // insert a copy of frame header OBU (including 4-byte size), - // except before the first tile group - data = dst + total_size; - memmove(data, frame_header_obu_location, frame_header_obu_size); - total_size += frame_header_obu_size; - } - data = dst + total_size; - // A new tile group begins at this tile. Write the obu header and - // tile group header - curr_tg_data_size = write_obu_header(OBU_TILE_GROUP, 0, data + 4); - if (n_log2_tiles) - curr_tg_data_size += write_tile_group_header( - data + curr_tg_data_size + 4, tile_idx, - AOMMIN(tile_idx + tg_size - 1, tile_cols * tile_rows - 1), - n_log2_tiles); - total_size += curr_tg_data_size + 4; - new_tg = 0; - tile_count = 0; - } - tile_count++; - av1_tile_set_col(&tile_info, cm, tile_col); + // Now fill in the gaps in the uncompressed header. + if (have_tiles) { + assert(tile_col_size_bytes >= 1 && tile_col_size_bytes <= 4); + aom_wb_overwrite_literal(saved_wb, tile_col_size_bytes - 1, 2); - if (tile_count == tg_size || tile_idx == (tile_cols * tile_rows - 1)) { - is_last_tile_in_tg = 1; - new_tg = 1; - } else { - is_last_tile_in_tg = 0; + assert(tile_size_bytes >= 1 && tile_size_bytes <= 4); + aom_wb_overwrite_literal(saved_wb, tile_size_bytes - 1, 2); + } + return total_size; + } + + uint32_t obu_header_size = 0; + uint8_t *tile_data_start = dst + total_size; + for (tile_row = 0; tile_row < tile_rows; tile_row++) { + TileInfo tile_info; + av1_tile_set_row(&tile_info, cm, tile_row); + + for (tile_col = 0; tile_col < tile_cols; tile_col++) { + const int tile_idx = tile_row * tile_cols + tile_col; + TileBufferEnc *const buf = &tile_buffers[tile_row][tile_col]; + TileDataEnc *this_tile = &cpi->tile_data[tile_idx]; + const TOKENEXTRA *tok = tok_buffers[tile_row][tile_col]; + const TOKENEXTRA *tok_end = tok + cpi->tok_count[tile_row][tile_col]; + int is_last_tile_in_tg = 0; + + if (new_tg) { + data = dst + total_size; + + // A new tile group begins at this tile. Write the obu header and + // tile group header + const OBU_TYPE obu_type = + (num_tg_hdrs == 1) ? OBU_FRAME : OBU_TILE_GROUP; + curr_tg_data_size = + write_obu_header(obu_type, obu_extension_header, data); + obu_header_size = curr_tg_data_size; + + if (num_tg_hdrs == 1) { + curr_tg_data_size += write_frame_header_obu( + cpi, saved_wb, data + curr_tg_data_size, 0); } + curr_tg_data_size += write_tile_group_header( + data + curr_tg_data_size, tile_idx, + AOMMIN(tile_idx + tg_size - 1, tile_cols * tile_rows - 1), + n_log2_tiles, cm->num_tg > 1); + total_size += curr_tg_data_size; + tile_data_start += curr_tg_data_size; + new_tg = 0; + tile_count = 0; + } + tile_count++; + av1_tile_set_col(&tile_info, cm, tile_col); -#if CONFIG_DEPENDENT_HORZTILES - av1_tile_set_tg_boundary(&tile_info, cm, tile_row, tile_col); -#endif - buf->data = dst + total_size; + if (tile_count == tg_size || tile_idx == (tile_cols * tile_rows - 1)) { + is_last_tile_in_tg = 1; + new_tg = 1; + } else { + is_last_tile_in_tg = 0; + } - // The last tile of the tile group does not have a header. - if (!is_last_tile_in_tg) total_size += 4; + buf->data = dst + total_size; - // Initialise tile context from the frame context - this_tile->tctx = *cm->fc; - cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = &this_tile->pvq_q; - cpi->td.mb.daala_enc.state.adapt = &this_tile->tctx.pvq_context; -#endif // CONFIG_PVQ -#if CONFIG_ANS - mode_bc.size = 1 << cpi->common.ans_window_size_log2; -#endif // CONFIG_ANS - aom_start_encode(&mode_bc, dst + total_size); - write_modes(cpi, &tile_info, &mode_bc, &tok, tok_end); -#if !CONFIG_LV_MAP -#if !CONFIG_PVQ - assert(tok == tok_end); -#endif // !CONFIG_PVQ -#endif // !CONFIG_LV_MAP - aom_stop_encode(&mode_bc); - tile_size = mode_bc.pos; -#if CONFIG_PVQ - cpi->td.mb.pvq_q = NULL; -#endif - assert(tile_size > 0); + // The last tile of the tile group does not have a header. + if (!is_last_tile_in_tg) total_size += 4; - curr_tg_data_size += (tile_size + (is_last_tile_in_tg ? 0 : 4)); - buf->size = tile_size; + // Initialise tile context from the frame context + this_tile->tctx = *cm->fc; + cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; + mode_bc.allow_update_cdf = 1; + mode_bc.allow_update_cdf = + mode_bc.allow_update_cdf && !cm->disable_cdf_update; + const int num_planes = av1_num_planes(cm); + av1_reset_loop_restoration(&cpi->td.mb.e_mbd, num_planes); + + aom_start_encode(&mode_bc, dst + total_size); + write_modes(cpi, &tile_info, &mode_bc, &tok, tok_end); + aom_stop_encode(&mode_bc); + tile_size = mode_bc.pos; + assert(tile_size >= AV1_MIN_TILE_SIZE_BYTES); - if (!is_last_tile) { - *max_tile_size = AOMMAX(*max_tile_size, tile_size); + curr_tg_data_size += (tile_size + (is_last_tile_in_tg ? 0 : 4)); + buf->size = tile_size; + if (tile_size > max_tile_size) { + cm->largest_tile_id = tile_cols * tile_row + tile_col; + max_tile_size = tile_size; + } + + if (!is_last_tile_in_tg) { + // size of this tile + mem_put_le32(buf->data, tile_size - AV1_MIN_TILE_SIZE_BYTES); + } else { + // write current tile group size + const uint32_t obu_payload_size = curr_tg_data_size - obu_header_size; + const size_t length_field_size = + obu_memmove(obu_header_size, obu_payload_size, data); + if (write_uleb_obu_size(obu_header_size, obu_payload_size, data) != + AOM_CODEC_OK) { + assert(0); } - if (!is_last_tile_in_tg) { - // size of this tile - mem_put_le32(buf->data, tile_size); - } else { - // write current tile group size - mem_put_le32(data, curr_tg_data_size); + curr_tg_data_size += (int)length_field_size; + total_size += (uint32_t)length_field_size; + tile_data_start += length_field_size; + if (num_tg_hdrs == 1) { + // if this tg is combined with the frame header then update saved + // frame header base offset accroding to length field size + saved_wb->bit_buffer += length_field_size; } - total_size += tile_size; + if (!first_tg && cm->error_resilient_mode) { + // Make room for a duplicate Frame Header OBU. + memmove(data + fh_info->total_length, data, curr_tg_data_size); + + // Insert a copy of the Frame Header OBU. + memcpy(data, fh_info->frame_header, fh_info->total_length); + + // Force context update tile to be the first tile in error + // resiliant mode as the duplicate frame headers will have + // context_update_tile_id set to 0 + cm->largest_tile_id = 0; + + // Rewrite the OBU header to change the OBU type to Redundant Frame + // Header. + write_obu_header(OBU_REDUNDANT_FRAME_HEADER, obu_extension_header, + &data[fh_info->obu_header_byte_offset]); + + data += fh_info->total_length; + + curr_tg_data_size += (int)(fh_info->total_length); + total_size += (uint32_t)(fh_info->total_length); + } + first_tg = 0; } + + total_size += tile_size; } -#if CONFIG_EXT_TILE } -#endif // CONFIG_EXT_TILE - return (uint32_t)total_size; -} -#endif + if (have_tiles) { + // Fill in context_update_tile_id indicating the tile to use for the + // cdf update. The encoder currently sets it to the largest tile + // (but is up to the encoder) + aom_wb_overwrite_literal(saved_wb, cm->largest_tile_id, + cm->log2_tile_cols + cm->log2_tile_rows); + // If more than one tile group. tile_size_bytes takes the default value 4 + // and does not need to be set. For a single tile group it is set in the + // section below. + if (num_tg_hdrs == 1) { + int tile_size_bytes = 4, unused; + const uint32_t tile_data_offset = (uint32_t)(tile_data_start - dst); + const uint32_t tile_data_size = total_size - tile_data_offset; + + total_size = + remux_tiles(cm, tile_data_start, tile_data_size, max_tile_size, + max_tile_col_size, &tile_size_bytes, &unused); + total_size += tile_data_offset; + assert(tile_size_bytes >= 1 && tile_size_bytes <= 4); -void av1_pack_bitstream(AV1_COMP *const cpi, uint8_t *dst, size_t *size) { + aom_wb_overwrite_literal(saved_wb, tile_size_bytes - 1, 2); + + // Update the OBU length if remux_tiles() reduced the size. + uint64_t payload_size; + size_t length_field_size; + int res = + aom_uleb_decode(dst + obu_header_size, total_size - obu_header_size, + &payload_size, &length_field_size); + assert(res == 0); + (void)res; + + const uint64_t new_payload_size = + total_size - obu_header_size - length_field_size; + if (new_payload_size != payload_size) { + size_t new_length_field_size; + res = aom_uleb_encode(new_payload_size, length_field_size, + dst + obu_header_size, &new_length_field_size); + assert(res == 0); + if (new_length_field_size < length_field_size) { + const size_t src_offset = obu_header_size + length_field_size; + const size_t dst_offset = obu_header_size + new_length_field_size; + memmove(dst + dst_offset, dst + src_offset, (size_t)payload_size); + total_size -= (int)(length_field_size - new_length_field_size); + } + } + } + } + return total_size; +} + +int av1_pack_bitstream(AV1_COMP *const cpi, uint8_t *dst, size_t *size) { uint8_t *data = dst; uint32_t data_size; -#if CONFIG_EXT_TILE - AV1_COMMON *const cm = &cpi->common; - uint32_t compressed_hdr_size = 0; - uint32_t uncompressed_hdr_size; - struct aom_write_bit_buffer saved_wb; - struct aom_write_bit_buffer wb = { data, 0 }; - const int have_tiles = cm->tile_cols * cm->tile_rows > 1; - int tile_size_bytes; - int tile_col_size_bytes; -#endif // CONFIG_EXT_TILE - unsigned int max_tile_size; - unsigned int max_tile_col_size; -#if CONFIG_OBU -#if !CONFIG_EXT_TILE AV1_COMMON *const cm = &cpi->common; -#endif - uint32_t obu_size; - uint8_t *frame_header_location; - uint32_t frame_header_size; -#endif + uint32_t obu_header_size = 0; + uint32_t obu_payload_size = 0; + FrameHeaderInfo fh_info = { NULL, 0, 0 }; + const uint8_t obu_extension_header = + cm->temporal_layer_id << 5 | cm->spatial_layer_id << 3 | 0; #if CONFIG_BITSTREAM_DEBUG bitstream_queue_reset_write(); #endif -#if CONFIG_OBU - // write temporal delimiter obu, preceded by 4-byte size - obu_size = write_obu_header(OBU_TD, 0, data + 4); - obu_size += write_temporal_delimiter_obu(/*data + 4 + obu_size*/); - mem_put_le32(data, obu_size); - data += obu_size + 4; + // The TD is now written outside the frame encode loop // write sequence header obu if KEY_FRAME, preceded by 4-byte size if (cm->frame_type == KEY_FRAME) { - obu_size = write_obu_header(OBU_SEQUENCE_HEADER, 0, data + 4); - obu_size += write_sequence_header_obu(cpi, data + 4 + obu_size); - mem_put_le32(data, obu_size); - data += obu_size + 4; - } + obu_header_size = write_obu_header(OBU_SEQUENCE_HEADER, 0, data); - // write frame header obu, preceded by 4-byte size - frame_header_location = data + 4; - obu_size = write_obu_header(OBU_FRAME_HEADER, 0, frame_header_location); - frame_header_size = write_frame_header_obu(cpi, data + 4 + obu_size); - obu_size += frame_header_size; - mem_put_le32(data, obu_size); - data += obu_size + 4; + obu_payload_size = write_sequence_header_obu(cpi, data + obu_header_size); + const size_t length_field_size = + obu_memmove(obu_header_size, obu_payload_size, data); + if (write_uleb_obu_size(obu_header_size, obu_payload_size, data) != + AOM_CODEC_OK) { + return AOM_CODEC_ERROR; + } - if (cm->show_existing_frame) { - data_size = 0; - } else { - // Each tile group obu will be preceded by 4-byte size of the tile group - // obu - data_size = - write_tiles_in_tg_obus(cpi, data, &max_tile_size, &max_tile_col_size, - frame_header_location - 4, obu_size + 4, - 1 /* cm->error_resilient_mode */); + data += obu_header_size + obu_payload_size + length_field_size; } -#endif - -#if CONFIG_EXT_TILE - if (cm->large_scale_tile) { - // Write the uncompressed header - write_uncompressed_header_frame(cpi, &wb); - -#if CONFIG_EXT_REFS - if (cm->show_existing_frame) { - *size = aom_wb_bytes_written(&wb); - return; - } -#endif // CONFIG_EXT_REFS - - // We do not know these in advance. Output placeholder bit. - saved_wb = wb; - // Write tile size magnitudes - if (have_tiles) { - // Note that the last item in the uncompressed header is the data - // describing tile configuration. - // Number of bytes in tile column size - 1 - aom_wb_write_literal(&wb, 0, 2); + const int write_frame_header = (cm->num_tg > 1 || cm->show_existing_frame); + struct aom_write_bit_buffer saved_wb; + if (write_frame_header) { + // Write Frame Header OBU. + fh_info.frame_header = data; + obu_header_size = + write_obu_header(OBU_FRAME_HEADER, obu_extension_header, data); + obu_payload_size = + write_frame_header_obu(cpi, &saved_wb, data + obu_header_size, 1); - // Number of bytes in tile size - 1 - aom_wb_write_literal(&wb, 0, 2); + const size_t length_field_size = + obu_memmove(obu_header_size, obu_payload_size, data); + if (write_uleb_obu_size(obu_header_size, obu_payload_size, data) != + AOM_CODEC_OK) { + return AOM_CODEC_ERROR; } - if (!use_compressed_header(cm)) { - uncompressed_hdr_size = (uint32_t)aom_wb_bytes_written(&wb); - aom_clear_system_state(); - compressed_hdr_size = 0; - } else { - // Size of compressed header - aom_wb_write_literal(&wb, 0, 16); - uncompressed_hdr_size = (uint32_t)aom_wb_bytes_written(&wb); - aom_clear_system_state(); - // Write the compressed header - compressed_hdr_size = - write_compressed_header(cpi, data + uncompressed_hdr_size); - } - data += uncompressed_hdr_size + compressed_hdr_size; + fh_info.obu_header_byte_offset = 0; + fh_info.total_length = + obu_header_size + obu_payload_size + length_field_size; + data += fh_info.total_length; - // Write the encoded tile data - data_size = write_tiles(cpi, data, &max_tile_size, &max_tile_col_size); - } else { -#endif // CONFIG_EXT_TILE -#if !CONFIG_OBU - data_size = write_tiles(cpi, data, &max_tile_size, &max_tile_col_size); -#endif -#if CONFIG_EXT_TILE + // Since length_field_size is determined adaptively after frame header + // encoding, saved_wb must be adjusted accordingly. + saved_wb.bit_buffer += length_field_size; } -#endif // CONFIG_EXT_TILE -#if CONFIG_EXT_TILE - if (cm->large_scale_tile) { - if (have_tiles) { - data_size = - remux_tiles(cm, data, data_size, max_tile_size, max_tile_col_size, - &tile_size_bytes, &tile_col_size_bytes); - } - - data += data_size; - // Now fill in the gaps in the uncompressed header. - if (have_tiles) { - assert(tile_col_size_bytes >= 1 && tile_col_size_bytes <= 4); - aom_wb_write_literal(&saved_wb, tile_col_size_bytes - 1, 2); - - assert(tile_size_bytes >= 1 && tile_size_bytes <= 4); - aom_wb_write_literal(&saved_wb, tile_size_bytes - 1, 2); - } - // TODO(jbb): Figure out what to do if compressed_hdr_size > 16 bits. - assert(compressed_hdr_size <= 0xffff); - aom_wb_write_literal(&saved_wb, compressed_hdr_size, 16); + if (cm->show_existing_frame) { + data_size = 0; } else { -#endif // CONFIG_EXT_TILE - data += data_size; -#if CONFIG_EXT_TILE - } -#endif // CONFIG_EXT_TILE -#if CONFIG_ANS && ANS_REVERSE - // Avoid aliasing the superframe index - *data++ = 0; -#endif + // Each tile group obu will be preceded by 4-byte size of the tile group + // obu + data_size = write_tiles_in_tg_obus(cpi, data, &saved_wb, + obu_extension_header, &fh_info); + } + data += data_size; *size = data - dst; + return AOM_CODEC_OK; } |