Google Git
Sign in
aomedia / avm / refs/heads/research-inter2 / . / av1 / decoder / decodeframe.c
blob: 48a2b21affaa9dd653e14da0fd8cbc1a8907eb8f [file] [log] [blame] [edit]
/*
* Copyright (c) 2021, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 3-Clause Clear License
* and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
* License was not distributed with this source code in the LICENSE file, you
* can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the
* Alliance for Open Media Patent License 1.0 was not distributed with this
* source code in the PATENTS file, you can obtain it at
* aomedia.org/license/patent-license/.
*/
#include <assert.h>
#include <stddef.h>
#include "av1/common/blockd.h"
#include "config/aom_config.h"
#include "config/aom_dsp_rtcd.h"
#include "config/aom_scale_rtcd.h"
#include "config/av1_rtcd.h"
#include "aom/aom_codec.h"
#include "aom_dsp/aom_dsp_common.h"
#include "aom_dsp/binary_codes_reader.h"
#include "aom_dsp/bitreader.h"
#include "aom_dsp/bitreader_buffer.h"
#include "aom_mem/aom_mem.h"
#include "aom_ports/aom_timer.h"
#include "aom_ports/mem.h"
#include "aom_ports/mem_ops.h"
#include "aom_scale/aom_scale.h"
#include "aom_util/aom_thread.h"
#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
#include "aom_util/debug_util.h"
#endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG
#include "av1/common/alloccommon.h"
#include "av1/common/cdef.h"
#if CONFIG_CCSO
#include "av1/common/ccso.h"
#endif
#include "av1/common/cfl.h"
#if CONFIG_INSPECTION
#include "av1/decoder/inspection.h"
#endif
#include "av1/common/common.h"
#include "av1/common/entropy.h"
#include "av1/common/entropymode.h"
#include "av1/common/entropymv.h"
#include "av1/common/frame_buffers.h"
#include "av1/common/idct.h"
#include "av1/common/mvref_common.h"
#include "av1/common/pred_common.h"
#include "av1/common/quant_common.h"
#include "av1/common/reconinter.h"
#include "av1/common/reconintra.h"
#include "av1/common/resize.h"
#include "av1/common/seg_common.h"
#include "av1/common/thread_common.h"
#include "av1/common/tile_common.h"
#if CONFIG_TIP
#include "av1/common/tip.h"
#endif // CONFIG_TIP
#include "av1/common/warped_motion.h"
#include "av1/common/obmc.h"
#include "av1/decoder/decodeframe.h"
#include "av1/decoder/decodemv.h"
#include "av1/decoder/decoder.h"
#include "av1/decoder/decodetxb.h"
#include "av1/decoder/detokenize.h"
#define ACCT_STR __func__
#define AOM_MIN_THREADS_PER_TILE 1
#define AOM_MAX_THREADS_PER_TILE 2
// This is needed by ext_tile related unit tests.
#define EXT_TILE_DEBUG 1
#define MC_TEMP_BUF_PELS \
(((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2) * \
((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2))
#if CONFIG_THROUGHPUT_ANALYSIS
int64_t tot_ctx_syms = { 0 };
int64_t tot_bypass_syms = { 0 };
int max_ctx_syms = { 0 };
int max_bypass_syms = { 0 };
int max_bits = { 0 };
int64_t tot_bits = { 0 };
int tot_frames = { 0 };
#endif // CONFIG_THROUGHPUT_ANALYSIS
// Checks that the remaining bits start with a 1 and ends with 0s.
// It consumes an additional byte, if already byte aligned before the check.
int av1_check_trailing_bits(AV1Decoder *pbi, struct aom_read_bit_buffer *rb) {
AV1_COMMON *const cm = &pbi->common;
// bit_offset is set to 0 (mod 8) when the reader is already byte aligned
int bits_before_alignment = 8 - rb->bit_offset % 8;
int trailing = aom_rb_read_literal(rb, bits_before_alignment);
if (trailing != (1 << (bits_before_alignment - 1))) {
cm->error.error_code = AOM_CODEC_CORRUPT_FRAME;
return -1;
}
return 0;
}
// Use only_chroma = 1 to only set the chroma planes
static AOM_INLINE void set_planes_to_neutral_grey(
const SequenceHeader *const seq_params, const YV12_BUFFER_CONFIG *const buf,
int only_chroma) {
const int val = 1 << (seq_params->bit_depth - 1);
for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {
const int is_uv = plane > 0;
uint16_t *const base = buf->buffers[plane];
// Set the first row to neutral grey. Then copy the first row to all
// subsequent rows.
if (buf->crop_heights[is_uv] > 0) {
aom_memset16(base, val, buf->crop_widths[is_uv]);
for (int row_idx = 1; row_idx < buf->crop_heights[is_uv]; row_idx++) {
memcpy(&base[row_idx * buf->strides[is_uv]], base,
sizeof(*base) * buf->crop_widths[is_uv]);
}
}
}
}
static AOM_INLINE void loop_restoration_read_sb_coeffs(
const AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane,
int runit_idx);
static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) {
return len != 0 && len <= (size_t)(end - start);
}
static TX_MODE read_tx_mode(struct aom_read_bit_buffer *rb,
int coded_lossless) {
if (coded_lossless) return ONLY_4X4;
return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST;
}
static REFERENCE_MODE read_frame_reference_mode(
const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
if (frame_is_intra_only(cm)) {
return SINGLE_REFERENCE;
} else {
return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
}
}
static AOM_INLINE void inverse_transform_block(DecoderCodingBlock *dcb,
#if CONFIG_CROSS_CHROMA_TX
const AV1_COMMON *cm,
#endif // CONFIG_CROSS_CHROMA_TX
int plane, const TX_TYPE tx_type,
const TX_SIZE tx_size,
uint16_t *dst, int stride,
int reduced_tx_set) {
tran_low_t *dqcoeff = dcb->dqcoeff_block[plane] + dcb->cb_offset[plane];
eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
uint16_t scan_line = eob_data->max_scan_line;
uint16_t eob = eob_data->eob;
#if CONFIG_CROSS_CHROMA_TX
// Update eob and scan_line according to those of the other chroma plane
if (plane && is_cctx_allowed(cm, &dcb->xd)) {
eob_info *eob_data_c1 =
dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
eob_info *eob_data_c2 =
dcb->eob_data[AOM_PLANE_V] + dcb->txb_offset[AOM_PLANE_V];
scan_line = AOMMAX(eob_data_c1->max_scan_line, eob_data_c2->max_scan_line);
eob = AOMMAX(eob_data_c1->eob, eob_data_c2->eob);
}
#endif // CONFIG_CROSS_CHROMA_TX
av1_inverse_transform_block(&dcb->xd, dqcoeff, plane, tx_type, tx_size, dst,
stride, eob, reduced_tx_set);
const int width = tx_size_wide[tx_size] <= 32 ? tx_size_wide[tx_size] : 32;
const int height = tx_size_high[tx_size] <= 32 ? tx_size_high[tx_size] : 32;
const int sbSize = (width >= 8 && height >= 8) ? 8 : 4;
int32_t nz0 = (sbSize - 1) * tx_size_wide[tx_size] + sbSize;
int32_t nz1 = (scan_line + 1);
memset(dqcoeff, 0, AOMMAX(nz0, nz1) * sizeof(dqcoeff[0]));
}
static AOM_INLINE void read_coeffs_tx_intra_block(
const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
const int plane, const int row, const int col, const TX_SIZE tx_size) {
MB_MODE_INFO *mbmi = dcb->xd.mi[0];
if (!mbmi->skip_txfm[dcb->xd.tree_type == CHROMA_PART]) {
#if TXCOEFF_TIMER
struct aom_usec_timer timer;
aom_usec_timer_start(&timer);
#endif
av1_read_coeffs_txb_facade(cm, dcb, r, plane, row, col, tx_size);
#if TXCOEFF_TIMER
aom_usec_timer_mark(&timer);
const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);
cm->txcoeff_timer += elapsed_time;
++cm->txb_count;
#endif
}
#if CONFIG_PC_WIENER
else {
// all tx blocks are skipped.
av1_update_txk_skip_array(cm, dcb->xd.mi_row, dcb->xd.mi_col,
dcb->xd.tree_type, &mbmi->chroma_ref_info, plane,
row, col, tx_size);
}
#endif // CONFIG_PC_WIENER
}
static AOM_INLINE void decode_block_void(const AV1_COMMON *const cm,
DecoderCodingBlock *dcb,
aom_reader *const r, const int plane,
const int row, const int col,
const TX_SIZE tx_size) {
(void)cm;
(void)dcb;
(void)r;
(void)plane;
(void)row;
(void)col;
(void)tx_size;
}
static AOM_INLINE void predict_inter_block_void(AV1_COMMON *const cm,
DecoderCodingBlock *dcb,
BLOCK_SIZE bsize) {
(void)cm;
(void)dcb;
(void)bsize;
}
static AOM_INLINE void cfl_store_inter_block_void(AV1_COMMON *const cm,
MACROBLOCKD *const xd) {
(void)cm;
(void)xd;
}
static AOM_INLINE void predict_and_reconstruct_intra_block(
const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
const int plane, const int row, const int col, const TX_SIZE tx_size) {
(void)r;
MACROBLOCKD *const xd = &dcb->xd;
MB_MODE_INFO *mbmi = xd->mi[0];
PLANE_TYPE plane_type = get_plane_type(plane);
av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size);
#if CONFIG_MISMATCH_DEBUG
const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
int pixel_c, pixel_r;
BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
int blk_w = block_size_wide[bsize];
int blk_h = block_size_high[bsize];
if (plane == 0 || xd->is_chroma_ref) {
struct macroblockd_plane *const pd = &xd->plane[plane];
if (plane) {
mi_to_pixel_loc(&pixel_c, &pixel_r,
mbmi->chroma_ref_info.mi_col_chroma_base,
mbmi->chroma_ref_info.mi_row_chroma_base, col, row,
pd->subsampling_x, pd->subsampling_y);
} else {
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, col, row,
pd->subsampling_x, pd->subsampling_y);
}
mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,
cm->current_frame.order_hint, plane, pixel_c,
pixel_r, blk_w, blk_h);
}
#endif // CONFIG_MISMATCH_DEBUG
if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
#if CONFIG_CROSS_CHROMA_TX
// In CCTX, when C2 eob = 0 but C1 eob > 0, plane V reconstruction is
// still needed
int recon_with_cctx = 0;
if (is_cctx_allowed(cm, xd) && plane == AOM_PLANE_V &&
av1_get_cctx_type(xd, row, col) > CCTX_NONE) {
eob_info *eob_data_c1 =
dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
recon_with_cctx = eob_data_c1->eob > 0;
}
if (eob_data->eob || recon_with_cctx) {
#else
if (eob_data->eob) {
#endif // CONFIG_CROSS_CHROMA_TX
const bool reduced_tx_set_used = cm->features.reduced_tx_set_used;
// tx_type was read out in av1_read_coeffs_txb.
const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, row, col, tx_size,
reduced_tx_set_used);
struct macroblockd_plane *const pd = &xd->plane[plane];
uint16_t *dst =
&pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2];
inverse_transform_block(dcb,
#if CONFIG_CROSS_CHROMA_TX
cm,
#endif // CONFIG_CROSS_CHROMA_TX
plane, tx_type, tx_size, dst, pd->dst.stride,
reduced_tx_set_used);
}
}
#if CONFIG_MISMATCH_DEBUG
{
struct macroblockd_plane *const pd = &xd->plane[plane];
uint16_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2];
if (plane) {
mi_to_pixel_loc(&pixel_c, &pixel_r,
mbmi->chroma_ref_info.mi_col_chroma_base,
mbmi->chroma_ref_info.mi_row_chroma_base, col, row,
pd->subsampling_x, pd->subsampling_y);
} else {
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, col, row,
pd->subsampling_x, pd->subsampling_y);
}
mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
plane, pixel_c, pixel_r, blk_w, blk_h);
}
#endif // CONFIG_MISMATCH_DEBUG
if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd) &&
xd->tree_type == SHARED_PART) {
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_tx(xd, row, col, tx_size,
#if DS_FRAME_LEVEL
cm->features.ds_filter_type);
#else
cm->seq_params.enable_cfl_ds_filter);
#endif // DS_FRAME_LEVEL
#else
cfl_store_tx(xd, row, col, tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
}
}
#if CONFIG_CROSS_CHROMA_TX
// Facade function for inverse cross chroma component transform
static AOM_INLINE void inverse_cross_chroma_transform_block(
const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
const int plane, const int blk_row, const int blk_col,
const TX_SIZE tx_size) {
(void)cm;
(void)r;
(void)plane;
tran_low_t *dqcoeff_c1 =
dcb->dqcoeff_block[AOM_PLANE_U] + dcb->cb_offset[AOM_PLANE_U];
tran_low_t *dqcoeff_c2 =
dcb->dqcoeff_block[AOM_PLANE_V] + dcb->cb_offset[AOM_PLANE_V];
MACROBLOCKD *const xd = &dcb->xd;
const CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
av1_inv_cross_chroma_tx_block(dqcoeff_c1, dqcoeff_c2, tx_size, cctx_type);
}
#endif // CONFIG_CROSS_CHROMA_TX
static AOM_INLINE void inverse_transform_inter_block(
const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
const int plane, const int blk_row, const int blk_col,
const TX_SIZE tx_size) {
(void)r;
MACROBLOCKD *const xd = &dcb->xd;
PLANE_TYPE plane_type = get_plane_type(plane);
const struct macroblockd_plane *const pd = &xd->plane[plane];
const bool reduced_tx_set_used = cm->features.reduced_tx_set_used;
// tx_type was read out in av1_read_coeffs_txb.
const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col,
tx_size, reduced_tx_set_used);
uint16_t *dst =
&pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2];
inverse_transform_block(dcb,
#if CONFIG_CROSS_CHROMA_TX
cm,
#endif // CONFIG_CROSS_CHROMA_TX
plane, tx_type, tx_size, dst, pd->dst.stride,
reduced_tx_set_used);
#if CONFIG_MISMATCH_DEBUG
int pixel_c, pixel_r;
BLOCK_SIZE bsize = txsize_to_bsize[tx_size];
int blk_w = block_size_wide[bsize];
int blk_h = block_size_high[bsize];
const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
if (plane) {
MB_MODE_INFO *const mbmi = xd->mi[0];
mi_to_pixel_loc(&pixel_c, &pixel_r,
mbmi->chroma_ref_info.mi_col_chroma_base,
mbmi->chroma_ref_info.mi_row_chroma_base, blk_col, blk_row,
pd->subsampling_x, pd->subsampling_y);
} else {
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row,
pd->subsampling_x, pd->subsampling_y);
}
mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
plane, pixel_c, pixel_r, blk_w, blk_h);
#endif // CONFIG_MISMATCH_DEBUG
}
static AOM_INLINE void set_cb_buffer_offsets(DecoderCodingBlock *dcb,
TX_SIZE tx_size, int plane) {
dcb->cb_offset[plane] += tx_size_wide[tx_size] * tx_size_high[tx_size];
dcb->txb_offset[plane] =
dcb->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
}
static AOM_INLINE void decode_reconstruct_tx(AV1_COMMON *cm,
ThreadData *const td,
aom_reader *r,
MB_MODE_INFO *const mbmi,
int plane, BLOCK_SIZE plane_bsize,
int blk_row, int blk_col,
#if !CONFIG_NEW_TX_PARTITION
int block,
#endif // !CONFIG_NEW_TX_PARTITION
TX_SIZE tx_size, int *eob_total) {
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
#if CONFIG_CROSS_CHROMA_TX
if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) return;
#endif // CONFIG_CROSS_CHROMA_TX
const struct macroblockd_plane *const pd = &xd->plane[plane];
#if CONFIG_EXT_RECUR_PARTITIONS
const BLOCK_SIZE bsize_base = get_bsize_base(xd, mbmi, plane);
const TX_SIZE plane_tx_size =
plane ? av1_get_max_uv_txsize(bsize_base, pd->subsampling_x,
pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
#else
if (xd->tree_type == SHARED_PART)
assert(mbmi->sb_type[PLANE_TYPE_Y] == mbmi->sb_type[PLANE_TYPE_UV]);
const TX_SIZE plane_tx_size =
plane ? av1_get_max_uv_txsize(mbmi->sb_type[plane > 0], pd->subsampling_x,
pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Scale to match transform block unit.
const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
if (tx_size == plane_tx_size || plane) {
#if CONFIG_CROSS_CHROMA_TX
if (plane == AOM_PLANE_V && is_cctx_allowed(cm, xd)) {
td->read_coeffs_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_U, blk_row,
blk_col, tx_size);
td->read_coeffs_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_V, blk_row,
blk_col, tx_size);
td->inverse_cctx_block_visit(cm, dcb, r, -1, blk_row, blk_col, tx_size);
td->inverse_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_U, blk_row,
blk_col, tx_size);
td->inverse_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_V, blk_row,
blk_col, tx_size);
eob_info *eob_data_c1 =
dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
eob_info *eob_data_c2 =
dcb->eob_data[AOM_PLANE_V] + dcb->txb_offset[AOM_PLANE_V];
*eob_total += eob_data_c1->eob + eob_data_c2->eob;
set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_U);
set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_V);
} else {
assert(plane == AOM_PLANE_Y || !is_cctx_allowed(cm, xd));
#endif // CONFIG_CROSS_CHROMA_TX
td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,
tx_size);
td->inverse_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,
tx_size);
eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
*eob_total += eob_data->eob;
set_cb_buffer_offsets(dcb, tx_size, plane);
#if CONFIG_CROSS_CHROMA_TX
}
#endif // CONFIG_CROSS_CHROMA_TX
} else {
#if CONFIG_NEW_TX_PARTITION
TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 };
const int index = av1_get_txb_size_index(plane_bsize, blk_row, blk_col);
get_tx_partition_sizes(mbmi->tx_partition_type[index], tx_size, sub_txs);
int cur_partition = 0;
int bsw = 0, bsh = 0;
for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) {
for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) {
const TX_SIZE sub_tx = sub_txs[cur_partition];
bsw = tx_size_wide_unit[sub_tx];
bsh = tx_size_high_unit[sub_tx];
const int offsetr = blk_row + row;
const int offsetc = blk_col + col;
if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, offsetr,
offsetc, sub_tx);
td->inverse_tx_inter_block_visit(cm, dcb, r, plane, offsetr, offsetc,
sub_tx);
eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
*eob_total += eob_data->eob;
set_cb_buffer_offsets(dcb, sub_tx, plane);
cur_partition++;
}
}
#else
const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size));
assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size));
const int bsw = tx_size_wide_unit[sub_txs];
const int bsh = tx_size_high_unit[sub_txs];
const int sub_step = bsw * bsh;
assert(bsw > 0 && bsh > 0);
for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) {
for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) {
const int offsetr = blk_row + row;
const int offsetc = blk_col + col;
if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize, offsetr,
offsetc, block, sub_txs, eob_total);
block += sub_step;
}
}
#endif // CONFIG_NEW_TX_PARTITION
}
}
static AOM_INLINE void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd,
BLOCK_SIZE bsize, int mi_row, int mi_col,
int bw, int bh, int x_inside_boundary,
int y_inside_boundary,
PARTITION_TREE *parent, int index) {
const int num_planes = av1_num_planes(cm);
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const TileInfo *const tile = &xd->tile;
set_mi_offsets(mi_params, xd, mi_row, mi_col
#if CONFIG_C071_SUBBLK_WARPMV
,
x_inside_boundary, y_inside_boundary
#endif // CONFIG_C071_SUBBLK_WARPMV
);
xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART] = bsize;
#if CONFIG_RD_DEBUG
xd->mi[0]->mi_row = mi_row;
xd->mi[0]->mi_col = mi_col;
#endif
if (xd->tree_type == SHARED_PART) {
assert(x_inside_boundary && y_inside_boundary);
for (int x = 1; x < x_inside_boundary; ++x) xd->mi[x] = xd->mi[0];
int idx = mi_params->mi_stride;
for (int y = 1; y < y_inside_boundary; ++y) {
memcpy(&xd->mi[idx], &xd->mi[0], x_inside_boundary * sizeof(xd->mi[0]));
idx += mi_params->mi_stride;
}
}
CHROMA_REF_INFO *chroma_ref_info = &xd->mi[0]->chroma_ref_info;
set_chroma_ref_info(mi_row, mi_col, index, bsize, chroma_ref_info,
parent ? &parent->chroma_ref_info : NULL,
parent ? parent->bsize : BLOCK_INVALID,
parent ? parent->partition : PARTITION_NONE,
xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);
set_plane_n4(xd, bw, bh, num_planes, chroma_ref_info);
set_entropy_context(xd, mi_row, mi_col, num_planes, chroma_ref_info);
// Distance of Mb to the various image edges. These are specified to 8th pel
// as they are always compared to values that are in 1/8th pel units
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
mi_params->mi_cols, chroma_ref_info);
av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
num_planes, chroma_ref_info);
}
typedef struct PadBlock {
int x0;
int x1;
int y0;
int y1;
} PadBlock;
static INLINE int update_extend_mc_border_params(
const struct scale_factors *const sf, struct buf_2d *const pre_buf,
MV32 scaled_mv, PadBlock *block, int subpel_x_mv, int subpel_y_mv,
int do_warp, int is_intrabc, int *x_pad, int *y_pad) {
// Get reference width and height.
int frame_width = pre_buf->width;
int frame_height = pre_buf->height;
// Do border extension if there is motion or
// width/height is not a multiple of 8 pixels.
#if CONFIG_OPTFLOW_REFINEMENT || CONFIG_TIP
// Extension is needed in optical flow refinement to obtain MV offsets
(void)scaled_mv;
if (!is_intrabc && !do_warp) {
#else
const int is_scaled = av1_is_scaled(sf);
if ((!is_intrabc) && (!do_warp) &&
(is_scaled || scaled_mv.col || scaled_mv.row || (frame_width & 0x7) ||
(frame_height & 0x7))) {
#endif // CONFIG_OPTFLOW_REFINEMENT || CONFIG_TIP
if (subpel_x_mv || (sf->x_step_q4 != SUBPEL_SHIFTS)) {
block->x0 -= AOM_INTERP_EXTEND - 1;
block->x1 += AOM_INTERP_EXTEND;
*x_pad = 1;
}
if (subpel_y_mv || (sf->y_step_q4 != SUBPEL_SHIFTS)) {
block->y0 -= AOM_INTERP_EXTEND - 1;
block->y1 += AOM_INTERP_EXTEND;
*y_pad = 1;
}
// Skip border extension if block is inside the frame.
if (block->x0 < 0 || block->x1 > frame_width - 1 || block->y0 < 0 ||
block->y1 > frame_height - 1) {
return 1;
}
}
return 0;
}
static INLINE void extend_mc_border(const struct scale_factors *const sf,
struct buf_2d *const pre_buf,
MV32 scaled_mv, PadBlock block,
int subpel_x_mv, int subpel_y_mv,
int do_warp, int is_intrabc,
uint16_t *mc_buf, uint16_t **pre,
int *src_stride) {
int x_pad = 0, y_pad = 0;
if (update_extend_mc_border_params(sf, pre_buf, scaled_mv, &block,
subpel_x_mv, subpel_y_mv, do_warp,
is_intrabc, &x_pad, &y_pad)) {
// Get reference block pointer.
const uint16_t *const buf_ptr =
pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
int buf_stride = pre_buf->stride;
const int b_w = block.x1 - block.x0;
const int b_h = block.y1 - block.y0;
// Extend the border.
highbd_build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0, block.y0,
b_w, b_h, pre_buf->width, pre_buf->height);
*src_stride = b_w;
*pre = mc_buf + y_pad * (AOM_INTERP_EXTEND - 1) * b_w +
x_pad * (AOM_INTERP_EXTEND - 1);
}
}
static void dec_calc_subpel_params(
const MV *const src_mv, InterPredParams *const inter_pred_params,
const MACROBLOCKD *const xd, int mi_x, int mi_y, uint16_t **pre,
SubpelParams *subpel_params, int *src_stride, PadBlock *block,
#if CONFIG_OPTFLOW_REFINEMENT
int use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
MV32 *scaled_mv, int *subpel_x_mv, int *subpel_y_mv) {
const struct scale_factors *sf = inter_pred_params->scale_factors;
struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;
#if CONFIG_OPTFLOW_REFINEMENT
// Use original block size to clamp MV and to extend block boundary
const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width
: inter_pred_params->block_width;
const int bh = use_optflow_refinement ? inter_pred_params->orig_block_height
: inter_pred_params->block_height;
#else
const int bw = inter_pred_params->block_width;
const int bh = inter_pred_params->block_height;
#endif // CONFIG_OPTFLOW_REFINEMENT
const int is_scaled = av1_is_scaled(sf);
if (is_scaled) {
int ssx = inter_pred_params->subsampling_x;
int ssy = inter_pred_params->subsampling_y;
int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
#if CONFIG_OPTFLOW_REFINEMENT
if (use_optflow_refinement) {
orig_pos_y += ROUND_POWER_OF_TWO_SIGNED(src_mv->row * (1 << SUBPEL_BITS),
MV_REFINE_PREC_BITS + ssy);
orig_pos_x += ROUND_POWER_OF_TWO_SIGNED(src_mv->col * (1 << SUBPEL_BITS),
MV_REFINE_PREC_BITS + ssx);
} else {
orig_pos_y += src_mv->row * (1 << (1 - ssy));
orig_pos_x += src_mv->col * (1 << (1 - ssx));
}
#else
orig_pos_y += src_mv->row * (1 << (1 - ssy));
orig_pos_x += src_mv->col * (1 << (1 - ssx));
#endif // CONFIG_OPTFLOW_REFINEMENT
int pos_y = sf->scale_value_y(orig_pos_y, sf);
int pos_x = sf->scale_value_x(orig_pos_x, sf);
pos_x += SCALE_EXTRA_OFF;
pos_y += SCALE_EXTRA_OFF;
const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy);
const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx);
const int bottom = (pre_buf->height + AOM_INTERP_EXTEND)
<< SCALE_SUBPEL_BITS;
const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;
pos_y = clamp(pos_y, top, bottom);
pos_x = clamp(pos_x, left, right);
subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK;
subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
subpel_params->xs = sf->x_step_q4;
subpel_params->ys = sf->y_step_q4;
// Get reference block top left coordinate.
block->x0 = pos_x >> SCALE_SUBPEL_BITS;
block->y0 = pos_y >> SCALE_SUBPEL_BITS;
// Get reference block bottom right coordinate.
block->x1 =
((pos_x + (inter_pred_params->block_width - 1) * subpel_params->xs) >>
SCALE_SUBPEL_BITS) +
1;
block->y1 =
((pos_y + (inter_pred_params->block_height - 1) * subpel_params->ys) >>
SCALE_SUBPEL_BITS) +
1;
MV temp_mv;
temp_mv = clamp_mv_to_umv_border_sb(xd, src_mv, bw, bh,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
inter_pred_params->subsampling_x,
inter_pred_params->subsampling_y);
*scaled_mv = av1_scale_mv(&temp_mv, mi_x, mi_y, sf);
scaled_mv->row += SCALE_EXTRA_OFF;
scaled_mv->col += SCALE_EXTRA_OFF;
*subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK;
*subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK;
} else {
// Get block position in current frame.
int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
const MV mv_q4 = clamp_mv_to_umv_border_sb(
xd, src_mv, bw, bh,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
inter_pred_params->subsampling_x, inter_pred_params->subsampling_y);
subpel_params->xs = subpel_params->ys = SCALE_SUBPEL_SHIFTS;
subpel_params->subpel_x = (mv_q4.col & SUBPEL_MASK) << SCALE_EXTRA_BITS;
subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS;
// Get reference block top left coordinate.
pos_x += mv_q4.col;
pos_y += mv_q4.row;
block->x0 = pos_x >> SUBPEL_BITS;
block->y0 = pos_y >> SUBPEL_BITS;
// Get reference block bottom right coordinate.
block->x1 =
(pos_x >> SUBPEL_BITS) + (inter_pred_params->block_width - 1) + 1;
block->y1 =
(pos_y >> SUBPEL_BITS) + (inter_pred_params->block_height - 1) + 1;
scaled_mv->row = mv_q4.row;
scaled_mv->col = mv_q4.col;
*subpel_x_mv = scaled_mv->col & SUBPEL_MASK;
*subpel_y_mv = scaled_mv->row & SUBPEL_MASK;
}
*pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;
*src_stride = pre_buf->stride;
}
static void dec_calc_subpel_params_and_extend(
const MV *const src_mv, InterPredParams *const inter_pred_params,
MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
#if CONFIG_OPTFLOW_REFINEMENT
int use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
int *src_stride) {
PadBlock block;
MV32 scaled_mv;
int subpel_x_mv, subpel_y_mv;
dec_calc_subpel_params(src_mv, inter_pred_params, xd, mi_x, mi_y, pre,
subpel_params, src_stride, &block,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
&scaled_mv, &subpel_x_mv, &subpel_y_mv);
extend_mc_border(inter_pred_params->scale_factors,
&inter_pred_params->ref_frame_buf, scaled_mv, block,
subpel_x_mv, subpel_y_mv,
inter_pred_params->mode == WARP_PRED,
inter_pred_params->is_intrabc, mc_buf[ref], pre, src_stride);
}
#if CONFIG_TIP
static AOM_INLINE void tip_dec_calc_subpel_params(
const MV *const src_mv, InterPredParams *const inter_pred_params, int mi_x,
int mi_y, uint16_t **pre, SubpelParams *subpel_params, int *src_stride,
PadBlock *block,
#if CONFIG_OPTFLOW_REFINEMENT
int use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
MV32 *scaled_mv, int *subpel_x_mv, int *subpel_y_mv) {
const struct scale_factors *sf = inter_pred_params->scale_factors;
struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf;
#if CONFIG_OPTFLOW_REFINEMENT
// Use original block size to clamp MV and to extend block boundary
const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width
: inter_pred_params->block_width;
const int bh = use_optflow_refinement ? inter_pred_params->orig_block_height
: inter_pred_params->block_height;
#else
const int bw = inter_pred_params->block_width;
const int bh = inter_pred_params->block_height;
#endif // CONFIG_OPTFLOW_REFINEMENT
const int is_scaled = av1_is_scaled(sf);
if (is_scaled) {
const int ssx = inter_pred_params->subsampling_x;
const int ssy = inter_pred_params->subsampling_y;
int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
#if CONFIG_OPTFLOW_REFINEMENT
if (use_optflow_refinement) {
orig_pos_y += ROUND_POWER_OF_TWO_SIGNED(src_mv->row * (1 << SUBPEL_BITS),
MV_REFINE_PREC_BITS + ssy);
orig_pos_x += ROUND_POWER_OF_TWO_SIGNED(src_mv->col * (1 << SUBPEL_BITS),
MV_REFINE_PREC_BITS + ssx);
} else {
orig_pos_y += src_mv->row * (1 << (1 - ssy));
orig_pos_x += src_mv->col * (1 << (1 - ssx));
}
#else
orig_pos_y += src_mv->row * (1 << (1 - ssy));
orig_pos_x += src_mv->col * (1 << (1 - ssx));
#endif // CONFIG_OPTFLOW_REFINEMENT
int pos_y = sf->scale_value_y(orig_pos_y, sf);
int pos_x = sf->scale_value_x(orig_pos_x, sf);
pos_x += SCALE_EXTRA_OFF;
pos_y += SCALE_EXTRA_OFF;
const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy);
const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx);
const int bottom = (pre_buf->height + AOM_INTERP_EXTEND)
<< SCALE_SUBPEL_BITS;
const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS;
pos_y = clamp(pos_y, top, bottom);
pos_x = clamp(pos_x, left, right);
subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK;
subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK;
subpel_params->xs = sf->x_step_q4;
subpel_params->ys = sf->y_step_q4;
// Get reference block top left coordinate.
block->x0 = pos_x >> SCALE_SUBPEL_BITS;
block->y0 = pos_y >> SCALE_SUBPEL_BITS;
// Get reference block bottom right coordinate.
block->x1 =
((pos_x + (bw - 1) * subpel_params->xs) >> SCALE_SUBPEL_BITS) + 1;
block->y1 =
((pos_y + (bh - 1) * subpel_params->ys) >> SCALE_SUBPEL_BITS) + 1;
MV temp_mv;
temp_mv = tip_clamp_mv_to_umv_border_sb(inter_pred_params, src_mv, bw, bh,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
inter_pred_params->subsampling_x,
inter_pred_params->subsampling_y);
*scaled_mv = av1_scale_mv(&temp_mv, mi_x, mi_y, sf);
scaled_mv->row += SCALE_EXTRA_OFF;
scaled_mv->col += SCALE_EXTRA_OFF;
*subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK;
*subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK;
} else {
// Get block position in current frame.
int pos_x = inter_pred_params->pix_col << SUBPEL_BITS;
int pos_y = inter_pred_params->pix_row << SUBPEL_BITS;
const MV mv_q4 = tip_clamp_mv_to_umv_border_sb(
inter_pred_params, src_mv, bw, bh,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
inter_pred_params->subsampling_x, inter_pred_params->subsampling_y);
subpel_params->xs = subpel_params->ys = SCALE_SUBPEL_SHIFTS;
subpel_params->subpel_x = (mv_q4.col & SUBPEL_MASK) << SCALE_EXTRA_BITS;
subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS;
// Get reference block top left coordinate.
pos_x += mv_q4.col;
pos_y += mv_q4.row;
pos_x = (pos_x >> SUBPEL_BITS);
pos_y = (pos_y >> SUBPEL_BITS);
block->x0 = pos_x;
block->y0 = pos_y;
// Get reference block bottom right coordinate.
block->x1 = pos_x + bw;
block->y1 = pos_y + bh;
scaled_mv->row = mv_q4.row;
scaled_mv->col = mv_q4.col;
*subpel_x_mv = scaled_mv->col & SUBPEL_MASK;
*subpel_y_mv = scaled_mv->row & SUBPEL_MASK;
}
*pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0;
*src_stride = pre_buf->stride;
}
static void tip_dec_calc_subpel_params_and_extend(
const MV *const src_mv, InterPredParams *const inter_pred_params,
MACROBLOCKD *const xd, int mi_x, int mi_y, int ref,
#if CONFIG_OPTFLOW_REFINEMENT
int use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
uint16_t **mc_buf, uint16_t **pre, SubpelParams *subpel_params,
int *src_stride) {
(void)xd;
PadBlock block;
MV32 scaled_mv;
int subpel_x_mv, subpel_y_mv;
tip_dec_calc_subpel_params(src_mv, inter_pred_params, mi_x, mi_y, pre,
subpel_params, src_stride, &block,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
&scaled_mv, &subpel_x_mv, &subpel_y_mv);
extend_mc_border(inter_pred_params->scale_factors,
&inter_pred_params->ref_frame_buf, scaled_mv, block,
subpel_x_mv, subpel_y_mv,
inter_pred_params->mode == WARP_PRED,
inter_pred_params->is_intrabc, mc_buf[ref], pre, src_stride);
}
static void av1_dec_setup_tip_frame(AV1_COMMON *cm, MACROBLOCKD *xd,
uint16_t **mc_buf,
CONV_BUF_TYPE *tmp_conv_dst) {
av1_setup_tip_motion_field(cm, 0);
av1_setup_tip_frame(cm, xd, mc_buf, tmp_conv_dst,
tip_dec_calc_subpel_params_and_extend);
}
static void av1_dec_tip_on_the_fly(AV1_COMMON *cm, MACROBLOCKD *xd,
uint16_t **mc_buf, CONV_BUF_TYPE *conv_dst) {
const MV *mv = &xd->mi[0]->mv[0].as_mv;
const int mvs_rows =
ROUND_POWER_OF_TWO(cm->mi_params.mi_rows, TMVP_SHIFT_BITS);
const int mvs_cols =
ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, TMVP_SHIFT_BITS);
const int extra_pixel = 1 << TMVP_MI_SZ_LOG2;
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
const int x_inside_boundary = xd->width;
const int y_inside_boundary = xd->height;
// define the block start and end pixel locations
FULLPEL_MV start_mv = get_fullmv_from_mv(mv);
const int bw = (x_inside_boundary << MI_SIZE_LOG2);
const int bh = (y_inside_boundary << MI_SIZE_LOG2);
int start_pixel_row = (mi_row << MI_SIZE_LOG2) + start_mv.row;
int start_pixel_col = (mi_col << MI_SIZE_LOG2) + start_mv.col;
int end_pixel_row = start_pixel_row + bh;
int end_pixel_col = start_pixel_col + bw;
// extend for handling interpolation
if (mv->row != 0) {
start_pixel_row -= extra_pixel;
end_pixel_row += extra_pixel;
}
if (mv->col != 0) {
start_pixel_col -= extra_pixel;
end_pixel_col += extra_pixel;
}
// clamp block start and end locations to make sure the block is in the frame
start_pixel_row = AOMMAX(0, start_pixel_row);
start_pixel_col = AOMMAX(0, start_pixel_col);
end_pixel_row = AOMMAX(0, end_pixel_row);
end_pixel_col = AOMMAX(0, end_pixel_col);
start_pixel_row = AOMMIN(cm->mi_params.mi_rows * MI_SIZE, start_pixel_row);
start_pixel_col = AOMMIN(cm->mi_params.mi_cols * MI_SIZE, start_pixel_col);
end_pixel_row = AOMMIN(cm->mi_params.mi_rows * MI_SIZE, end_pixel_row);
end_pixel_col = AOMMIN(cm->mi_params.mi_cols * MI_SIZE, end_pixel_col);
// convert the pixel block location to MV field grid location
int tpl_start_row = start_pixel_row >> TMVP_MI_SZ_LOG2;
int tpl_end_row = (end_pixel_row + TMVP_MI_SIZE - 1) >> TMVP_MI_SZ_LOG2;
int tpl_start_col = start_pixel_col >> TMVP_MI_SZ_LOG2;
int tpl_end_col = (end_pixel_col + TMVP_MI_SIZE - 1) >> TMVP_MI_SZ_LOG2;
// handling the boundary case when start and end locations are the same
if (tpl_start_row == tpl_end_row) {
if (tpl_start_row > 0) {
tpl_start_row -= 1;
} else {
tpl_end_row += 1;
}
}
if (tpl_start_col == tpl_end_col) {
if (tpl_start_col > 0) {
tpl_start_col -= 1;
} else {
tpl_end_col += 1;
}
}
// handle SIMD alignment for the chroma case
tpl_start_row = (tpl_start_row >> 1) << 1;
tpl_start_col = (tpl_start_col >> 1) << 1;
tpl_end_row = ((tpl_end_row + 1) >> 1) << 1;
tpl_end_col = ((tpl_end_col + 1) >> 1) << 1;
tpl_end_row = AOMMIN(mvs_rows, tpl_end_row);
tpl_end_col = AOMMIN(mvs_cols, tpl_end_col);
av1_setup_tip_on_the_fly(cm, xd, tpl_start_row, tpl_start_col, tpl_end_row,
tpl_end_col, mvs_cols, mc_buf, conv_dst,
tip_dec_calc_subpel_params_and_extend);
}
#endif // CONFIG_TIP
static AOM_INLINE void decode_mbmi_block(AV1Decoder *const pbi,
DecoderCodingBlock *dcb, int mi_row,
int mi_col, aom_reader *r,
PARTITION_TYPE partition,
BLOCK_SIZE bsize,
PARTITION_TREE *parent, int index) {
AV1_COMMON *const cm = &pbi->common;
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
const int x_mis = AOMMIN(bw, cm->mi_params.mi_cols - mi_col);
const int y_mis = AOMMIN(bh, cm->mi_params.mi_rows - mi_row);
MACROBLOCKD *const xd = &dcb->xd;
#if CONFIG_ACCOUNTING
aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
#endif
set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis, parent,
index);
xd->mi[0]->partition = partition;
av1_read_mode_info(pbi, dcb, r, x_mis, y_mis);
#if CONFIG_EXT_RECUR_PARTITIONS
if (xd->tree_type != LUMA_PART) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
const struct macroblockd_plane *const pd_u = &xd->plane[1];
const BLOCK_SIZE chroma_bsize_base =
get_bsize_base(xd, xd->mi[0], AOM_PLANE_U);
assert(chroma_bsize_base < BLOCK_SIZES_ALL);
if (get_plane_block_size(chroma_bsize_base, pd_u->subsampling_x,
pd_u->subsampling_y) == BLOCK_INVALID) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
"Block size %dx%d invalid with this subsampling mode",
block_size_wide[chroma_bsize_base],
block_size_high[chroma_bsize_base]);
}
#if CONFIG_EXT_RECUR_PARTITIONS
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_TIP
if (cm->features.tip_frame_mode == TIP_FRAME_AS_REF &&
is_tip_ref_frame(xd->mi[0]->ref_frame[0])) {
av1_dec_tip_on_the_fly(cm, xd, pbi->td.mc_buf, pbi->td.tmp_conv_dst);
}
#endif // CONFIG_TIP
}
/*
static AOM_INLINE void decode_mbmi_block(AV1Decoder *const pbi,
DecoderCodingBlock *dcb, int mi_row,
int mi_col, aom_reader *r,
PARTITION_TYPE partition,
BLOCK_SIZE bsize) {
AV1_COMMON *const cm = &pbi->common;
const SequenceHeader *const seq_params = &cm->seq_params;
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
const int x_inside_boundary = AOMMIN(bw, cm->mi_params.mi_cols - mi_col);
const int y_inside_boundary = AOMMIN(bh, cm->mi_params.mi_rows - mi_row);
MACROBLOCKD *const xd = &dcb->xd;
#if CONFIG_ACCOUNTING
aom_accounting_set_context(&pbi->accounting, mi_col, mi_row);
#endif
set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_inside_boundary,
y_inside_boundary);
xd->mi[0]->partition = partition;
av1_read_mode_info(pbi, dcb, r, x_inside_boundary, y_inside_boundary);
if (bsize >= BLOCK_8X8 &&
(seq_params->subsampling_x || seq_params->subsampling_y)) {
const BLOCK_SIZE uv_subsize =
ss_size_lookup[bsize][seq_params->subsampling_x]
[seq_params->subsampling_y];
if (uv_subsize == BLOCK_INVALID)
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
"Invalid block size.");
}
#if CONFIG_TIP
if (cm->features.tip_frame_mode == TIP_FRAME_AS_REF &&
is_tip_ref_frame(xd->mi[0]->ref_frame[0])) {
av1_dec_tip_on_the_fly(cm, xd, pbi->td.mc_buf, pbi->td.tmp_conv_dst);
}
#endif // CONFIG_TIP
}
*/
static void dec_build_inter_predictors(const AV1_COMMON *cm,
DecoderCodingBlock *dcb, int plane,
MB_MODE_INFO *mi, int build_for_obmc,
int bw, int bh, int mi_x, int mi_y) {
av1_build_inter_predictors(cm, &dcb->xd, plane, mi,
#if CONFIG_BAWP
NULL,
#endif
build_for_obmc, bw, bh, mi_x, mi_y, dcb->mc_buf,
dec_calc_subpel_params_and_extend);
}
static AOM_INLINE void dec_build_inter_predictor(const AV1_COMMON *cm,
DecoderCodingBlock *dcb,
int mi_row, int mi_col,
BLOCK_SIZE bsize) {
MACROBLOCKD *const xd = &dcb->xd;
const int num_planes = av1_num_planes(cm);
for (int plane = 0; plane < num_planes; ++plane) {
if (plane && !xd->is_chroma_ref) break;
const int mi_x = mi_col * MI_SIZE;
const int mi_y = mi_row * MI_SIZE;
dec_build_inter_predictors(cm, dcb, plane, xd->mi[0], 0,
xd->plane[plane].width, xd->plane[plane].height,
mi_x, mi_y);
if (is_interintra_pred(xd->mi[0])) {
BUFFER_SET ctx = { { xd->plane[0].dst.buf, xd->plane[1].dst.buf,
xd->plane[2].dst.buf },
{ xd->plane[0].dst.stride, xd->plane[1].dst.stride,
xd->plane[2].dst.stride } };
av1_build_interintra_predictor(cm, xd, xd->plane[plane].dst.buf,
xd->plane[plane].dst.stride, &ctx, plane,
bsize);
}
}
}
static INLINE void dec_build_prediction_by_above_pred(
MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
int dir, MB_MODE_INFO *above_mbmi, void *fun_ctxt, const int num_planes) {
struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;
const int above_mi_col = xd->mi_col + rel_mi_col;
int mi_x, mi_y;
MB_MODE_INFO backup_mbmi = *above_mbmi;
(void)rel_mi_row;
(void)dir;
av1_setup_build_prediction_by_above_pred(xd, rel_mi_col, op_mi_size,
&backup_mbmi, ctxt, num_planes);
mi_x = above_mi_col << MI_SIZE_LOG2;
mi_y = xd->mi_row << MI_SIZE_LOG2;
const BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y];
for (int j = 0; j < num_planes; ++j) {
const struct macroblockd_plane *pd = &xd->plane[j];
int bw = (op_mi_size * MI_SIZE) >> pd->subsampling_x;
int bh = clamp(block_size_high[bsize] >> (pd->subsampling_y + 1), 4,
block_size_high[BLOCK_64X64] >> (pd->subsampling_y + 1));
if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 0)) continue;
dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,
&backup_mbmi, 1, bw, bh, mi_x, mi_y);
}
}
static AOM_INLINE void dec_build_prediction_by_above_preds(
const AV1_COMMON *cm, DecoderCodingBlock *dcb,
uint16_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],
int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {
MACROBLOCKD *const xd = &dcb->xd;
if (!xd->up_available) return;
// Adjust mb_to_bottom_edge to have the correct value for the OBMC
// prediction block. This is half the height of the original block,
// except for 128-wide blocks, where we only use a height of 32.
const int this_height = xd->height * MI_SIZE;
const int pred_height = AOMMIN(this_height / 2, 32);
xd->mb_to_bottom_edge += GET_MV_SUBPEL(this_height - pred_height);
struct build_prediction_ctxt ctxt = {
cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_right_edge, dcb
};
const BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y];
foreach_overlappable_nb_above(cm, xd,
max_neighbor_obmc[mi_size_wide_log2[bsize]],
dec_build_prediction_by_above_pred, &ctxt);
xd->mb_to_left_edge = -GET_MV_SUBPEL(xd->mi_col * MI_SIZE);
xd->mb_to_right_edge = ctxt.mb_to_far_edge;
xd->mb_to_bottom_edge -= GET_MV_SUBPEL(this_height - pred_height);
}
static INLINE void dec_build_prediction_by_left_pred(
MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size,
int dir, MB_MODE_INFO *left_mbmi, void *fun_ctxt, const int num_planes) {
struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt;
const int left_mi_row = xd->mi_row + rel_mi_row;
int mi_x, mi_y;
MB_MODE_INFO backup_mbmi = *left_mbmi;
(void)rel_mi_col;
(void)dir;
av1_setup_build_prediction_by_left_pred(xd, rel_mi_row, op_mi_size,
&backup_mbmi, ctxt, num_planes);
mi_x = xd->mi_col << MI_SIZE_LOG2;
mi_y = left_mi_row << MI_SIZE_LOG2;
const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART];
for (int j = 0; j < num_planes; ++j) {
const struct macroblockd_plane *pd = &xd->plane[j];
int bw = clamp(block_size_wide[bsize] >> (pd->subsampling_x + 1), 4,
block_size_wide[BLOCK_64X64] >> (pd->subsampling_x + 1));
int bh = (op_mi_size << MI_SIZE_LOG2) >> pd->subsampling_y;
if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 1)) continue;
dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j,
&backup_mbmi, 1, bw, bh, mi_x, mi_y);
}
}
static AOM_INLINE void dec_build_prediction_by_left_preds(
const AV1_COMMON *cm, DecoderCodingBlock *dcb,
uint16_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE],
int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) {
MACROBLOCKD *const xd = &dcb->xd;
if (!xd->left_available) return;
// Adjust mb_to_right_edge to have the correct value for the OBMC
// prediction block. This is half the width of the original block,
// except for 128-wide blocks, where we only use a width of 32.
const int this_width = xd->width * MI_SIZE;
const int pred_width = AOMMIN(this_width / 2, 32);
xd->mb_to_right_edge += GET_MV_SUBPEL(this_width - pred_width);
struct build_prediction_ctxt ctxt = {
cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_bottom_edge, dcb
};
const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART];
foreach_overlappable_nb_left(cm, xd,
max_neighbor_obmc[mi_size_high_log2[bsize]],
dec_build_prediction_by_left_pred, &ctxt);
xd->mb_to_top_edge = -GET_MV_SUBPEL(xd->mi_row * MI_SIZE);
xd->mb_to_right_edge -= GET_MV_SUBPEL(this_width - pred_width);
xd->mb_to_bottom_edge = ctxt.mb_to_far_edge;
}
static AOM_INLINE void dec_build_obmc_inter_predictors_sb(
const AV1_COMMON *cm, DecoderCodingBlock *dcb) {
const int num_planes = av1_num_planes(cm);
uint16_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE];
int dst_stride1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
int dst_stride2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
int dst_width1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
int dst_width2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE };
MACROBLOCKD *const xd = &dcb->xd;
av1_setup_obmc_dst_bufs(xd, dst_buf1, dst_buf2);
dec_build_prediction_by_above_preds(cm, dcb, dst_buf1, dst_width1,
dst_height1, dst_stride1);
dec_build_prediction_by_left_preds(cm, dcb, dst_buf2, dst_width2, dst_height2,
dst_stride2);
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
num_planes, &xd->mi[0]->chroma_ref_info);
av1_build_obmc_inter_prediction(cm, xd, dst_buf1, dst_stride1, dst_buf2,
dst_stride2);
}
static AOM_INLINE void cfl_store_inter_block(AV1_COMMON *const cm,
MACROBLOCKD *const xd) {
MB_MODE_INFO *mbmi = xd->mi[0];
if (store_cfl_required(cm, xd) && xd->tree_type == SHARED_PART) {
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_block(xd, mbmi->sb_type[PLANE_TYPE_Y], mbmi->tx_size,
#if DS_FRAME_LEVEL
cm->features.ds_filter_type
#else
cm->seq_params.enable_cfl_ds_filter
#endif
);
#else
cfl_store_block(xd, mbmi->sb_type[PLANE_TYPE_Y], mbmi->tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
}
}
static AOM_INLINE void predict_inter_block(AV1_COMMON *const cm,
DecoderCodingBlock *dcb,
BLOCK_SIZE bsize) {
MACROBLOCKD *const xd = &dcb->xd;
MB_MODE_INFO *mbmi = xd->mi[0];
const int num_planes = av1_num_planes(cm);
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
if (frame == INTRA_FRAME) {
assert(is_intrabc_block(mbmi, xd->tree_type));
assert(ref == 0);
} else {
const RefCntBuffer *ref_buf = get_ref_frame_buf(cm, frame);
const struct scale_factors *ref_scale_factors =
get_ref_scale_factors_const(cm, frame);
xd->block_ref_scale_factors[ref] = ref_scale_factors;
av1_setup_pre_planes(xd, ref, &ref_buf->buf, mi_row, mi_col,
ref_scale_factors, num_planes,
&mbmi->chroma_ref_info);
}
}
#if CONFIG_INTERINTRA_WARP
if (mbmi->motion_mode == WARPED_CAUSAL_INTERINTRA) {
mbmi->wm_params[0].wmtype = ROTZOOM;
mbmi->wm_params[0].invalid = 0;
MV mv = mbmi->mv[0].as_mv;
if (av1_find_projection_interintra_ext(
xd, bsize, xd->plane[0].dst.buf, xd->plane[0].dst.stride, mv,
&mbmi->wm_params[0], cm->width, cm->height, dcb->mc_buf[0])) {
#if WARPED_MOTION_DEBUG
printf("Warning: unexpected warped model from aomenc\n");
#endif
mbmi->wm_params[0].invalid = 1;
}
#if CONFIG_C071_SUBBLK_WARPMV
assign_warpmv(cm, xd->submi, bsize, &mbmi->wm_params[0], mi_row, mi_col);
#endif // CONFIG_C071_SUBBLK_WARPMV
av1_update_warp_param_bank(cm, xd, mbmi);
}
#endif // CONFIG_INTERINTRA_WARP
dec_build_inter_predictor(cm, dcb, mi_row, mi_col, bsize);
if (mbmi->motion_mode == OBMC_CAUSAL) {
dec_build_obmc_inter_predictors_sb(cm, dcb);
}
#if CONFIG_MISMATCH_DEBUG
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end = get_partition_plane_end(xd->tree_type, num_planes);
for (int plane = plane_start; plane < plane_end; ++plane) {
const struct macroblockd_plane *pd = &xd->plane[plane];
int pixel_c, pixel_r;
if (plane && !xd->is_chroma_ref) continue;
if (plane) {
mi_to_pixel_loc(&pixel_c, &pixel_r,
mbmi->chroma_ref_info.mi_col_chroma_base,
mbmi->chroma_ref_info.mi_row_chroma_base, 0, 0,
pd->subsampling_x, pd->subsampling_y);
} else {
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0,
pd->subsampling_x, pd->subsampling_y);
}
mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,
cm->current_frame.order_hint, plane, pixel_c,
pixel_r, pd->width, pd->height);
}
#endif // CONFIG_MISMATCH_DEBUG
}
static AOM_INLINE void set_color_index_map_offset(MACROBLOCKD *const xd,
int plane, aom_reader *r) {
(void)r;
Av1ColorMapParam params;
const MB_MODE_INFO *const mbmi = xd->mi[0];
av1_get_block_dimensions(mbmi->sb_type[plane > 0], plane, xd,
&params.plane_width, &params.plane_height, NULL,
NULL);
xd->color_index_map_offset[plane] += params.plane_width * params.plane_height;
}
static AOM_INLINE void decode_token_recon_block(AV1Decoder *const pbi,
ThreadData *const td,
aom_reader *r,
PARTITION_TYPE partition,
BLOCK_SIZE bsize) {
AV1_COMMON *const cm = &pbi->common;
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
MB_MODE_INFO *mbmi = xd->mi[0];
xd->mi[0]->partition = partition;
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end =
get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
if (!is_inter_block(mbmi, xd->tree_type)) {
#if CONFIG_PC_WIENER
// When row_mt is used, this function can be called with
// td->read_coeffs_tx_intra_block_visit == decode_block_void.
// In that case do not reset since it will erase previously set
// values.
if (td->read_coeffs_tx_intra_block_visit != decode_block_void)
av1_init_txk_skip_array(cm, xd->mi_row, xd->mi_col, bsize, 0,
xd->tree_type, &mbmi->chroma_ref_info,
plane_start, plane_end);
#endif // CONFIG_PC_WIENER
int row, col;
assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x,
xd->plane[0].subsampling_y));
const int max_blocks_wide = max_block_wide(xd, bsize, 0);
const int max_blocks_high = max_block_high(xd, bsize, 0);
const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
int mu_blocks_wide = mi_size_wide[max_unit_bsize];
int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
for (int plane = plane_start; plane < plane_end; ++plane) {
if (plane && !xd->is_chroma_ref) break;
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
const BLOCK_SIZE plane_bsize =
get_mb_plane_block_size(xd, mbmi, plane, ss_x, ss_y);
const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
#if CONFIG_CROSS_CHROMA_TX
if (plane == AOM_PLANE_U && is_cctx_allowed(cm, xd)) continue;
#endif // CONFIG_CROSS_CHROMA_TX
const int stepr = tx_size_high_unit[tx_size];
const int stepc = tx_size_wide_unit[tx_size];
const int plane_unit_height =
get_plane_tx_unit_height(xd, plane_bsize, plane, row, ss_y);
const int plane_unit_width =
get_plane_tx_unit_width(xd, plane_bsize, plane, col, ss_x);
for (int blk_row = row >> ss_y; blk_row < plane_unit_height;
blk_row += stepr) {
for (int blk_col = col >> ss_x; blk_col < plane_unit_width;
blk_col += stepc) {
#if CONFIG_CROSS_CHROMA_TX
if (plane == AOM_PLANE_V && is_cctx_allowed(cm, xd)) {
td->read_coeffs_tx_intra_block_visit(cm, dcb, r, AOM_PLANE_U,
blk_row, blk_col, tx_size);
td->read_coeffs_tx_intra_block_visit(cm, dcb, r, AOM_PLANE_V,
blk_row, blk_col, tx_size);
td->inverse_cctx_block_visit(cm, dcb, r, -1, blk_row, blk_col,
tx_size);
td->predict_and_recon_intra_block_visit(
cm, dcb, r, AOM_PLANE_U, blk_row, blk_col, tx_size);
td->predict_and_recon_intra_block_visit(
cm, dcb, r, AOM_PLANE_V, blk_row, blk_col, tx_size);
set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_U);
set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_V);
} else {
assert(plane == AOM_PLANE_Y || !is_cctx_allowed(cm, xd));
#endif // CONFIG_CROSS_CHROMA_TX
td->read_coeffs_tx_intra_block_visit(cm, dcb, r, plane, blk_row,
blk_col, tx_size);
td->predict_and_recon_intra_block_visit(
cm, dcb, r, plane, blk_row, blk_col, tx_size);
set_cb_buffer_offsets(dcb, tx_size, plane);
#if CONFIG_CROSS_CHROMA_TX
}
#endif // CONFIG_CROSS_CHROMA_TX
}
}
}
}
}
} else {
#if CONFIG_PC_WIENER
// When row_mt is used, this function can be called with
// td->read_coeffs_tx_inter_block_visit == decode_block_void.
// In that case do not reset since it will erase previously set
// values.
if (td->read_coeffs_tx_inter_block_visit != decode_block_void)
av1_init_txk_skip_array(cm, xd->mi_row, xd->mi_col, bsize, 0,
xd->tree_type, &mbmi->chroma_ref_info,
plane_start, plane_end);
#endif // CONFIG_PC_WIENER
td->predict_inter_block_visit(cm, dcb, bsize);
// Reconstruction
if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
int eobtotal = 0;
const int max_blocks_wide = max_block_wide(xd, bsize, 0);
const int max_blocks_high = max_block_high(xd, bsize, 0);
int row, col;
const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
assert(max_unit_bsize ==
get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x,
xd->plane[0].subsampling_y));
int mu_blocks_wide = mi_size_wide[max_unit_bsize];
int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
for (int plane = plane_start; plane < plane_end; ++plane) {
if (plane && !xd->is_chroma_ref) break;
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
const BLOCK_SIZE plane_bsize =
get_mb_plane_block_size(xd, mbmi, plane, ss_x, ss_y);
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(plane_bsize == get_plane_block_size(bsize, ss_x, ss_y));
#endif // !CONFIG_EXT_RECUR_PARTITIONS
const TX_SIZE max_tx_size =
get_vartx_max_txsize(xd, plane_bsize, plane);
const int bh_var_tx = tx_size_high_unit[max_tx_size];
const int bw_var_tx = tx_size_wide_unit[max_tx_size];
#if !CONFIG_NEW_TX_PARTITION
int block = 0;
int step =
tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
#endif // !CONFIG_NEW_TX_PARTITION
const int plane_unit_height =
get_plane_tx_unit_height(xd, plane_bsize, plane, row, ss_y);
const int plane_unit_width =
get_plane_tx_unit_width(xd, plane_bsize, plane, col, ss_x);
for (int blk_row = row >> ss_y; blk_row < plane_unit_height;
blk_row += bh_var_tx) {
for (int blk_col = col >> ss_x; blk_col < plane_unit_width;
blk_col += bw_var_tx) {
decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize,
blk_row, blk_col,
#if !CONFIG_NEW_TX_PARTITION
block,
#endif // !CONFIG_NEW_TX_PARTITION
max_tx_size, &eobtotal);
#if !CONFIG_NEW_TX_PARTITION
block += step;
#endif // !CONFIG_NEW_TX_PARTITION
}
}
}
}
}
#if CONFIG_CROSS_CHROMA_TX
} else if (is_cctx_enabled(cm, xd) && xd->is_chroma_ref &&
xd->tree_type != LUMA_PART) {
#if CONFIG_PC_WIENER
av1_init_txk_skip_array(cm, xd->mi_row, xd->mi_col, bsize, 1,
xd->tree_type, &mbmi->chroma_ref_info,
plane_start, plane_end);
#endif // CONFIG_PC_WIENER
// fill cctx_type_map with CCTX_NONE for skip blocks so their
// neighbors can derive cctx contexts
const struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_U];
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
const BLOCK_SIZE uv_plane_bsize =
get_mb_plane_block_size(xd, mbmi, AOM_PLANE_U, ss_x, ss_y);
const TX_SIZE max_tx_size =
get_vartx_max_txsize(xd, uv_plane_bsize, AOM_PLANE_U);
const int max_blocks_wide = max_block_wide(xd, bsize, 0);
const int max_blocks_high = max_block_high(xd, bsize, 0);
const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
int mu_blocks_wide = mi_size_wide[max_unit_bsize];
int mu_blocks_high = mi_size_high[max_unit_bsize];
for (int row = 0; row < max_blocks_high; row += mu_blocks_high) {
for (int col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
int row_offset, col_offset;
#if CONFIG_EXT_RECUR_PARTITIONS
get_chroma_mi_offsets(xd, &row_offset, &col_offset);
#else
get_chroma_mi_offsets(xd, max_tx_size, &row_offset, &col_offset);
#endif // CONFIG_EXT_RECUR_PARTITIONS
update_cctx_array(xd, 0, 0, row_offset, col_offset, max_tx_size,
CCTX_NONE);
}
}
#endif // CONFIG_CROSS_CHROMA_TX
}
#if CONFIG_PC_WIENER
else {
av1_init_txk_skip_array(cm, xd->mi_row, xd->mi_col, bsize, 1,
xd->tree_type, &mbmi->chroma_ref_info,
plane_start, plane_end);
}
#endif // CONFIG_PC_WIENER
td->cfl_store_inter_block_visit(cm, xd);
}
av1_visit_palette(pbi, xd, r, set_color_index_map_offset);
av1_mark_block_as_coded(xd, bsize, cm->seq_params.sb_size);
}
static AOM_INLINE void set_inter_tx_size(MB_MODE_INFO *mbmi, int stride_log2,
int tx_w_log2, int tx_h_log2,
int min_txs, int split_size, int txs,
int blk_row, int blk_col) {
for (int idy = 0; idy < tx_size_high_unit[split_size];
idy += tx_size_high_unit[min_txs]) {
for (int idx = 0; idx < tx_size_wide_unit[split_size];
idx += tx_size_wide_unit[min_txs]) {
const int index = (((blk_row + idy) >> tx_h_log2) << stride_log2) +
((blk_col + idx) >> tx_w_log2);
mbmi->inter_tx_size[index] = txs;
}
}
}
#if CONFIG_NEW_TX_PARTITION
static TX_SIZE read_tx_partition(MACROBLOCKD *xd, MB_MODE_INFO *mbmi,
TX_SIZE max_tx_size, int blk_row, int blk_col,
aom_reader *r) {
int plane_type = (xd->tree_type == CHROMA_PART);
const BLOCK_SIZE bsize = mbmi->sb_type[plane_type];
const int is_inter = is_inter_block(mbmi, xd->tree_type);
const int max_blocks_high = max_block_high(xd, bsize, 0);
const int max_blocks_wide = max_block_wide(xd, bsize, 0);
if (is_inter && (blk_row >= max_blocks_high || blk_col >= max_blocks_wide))
return TX_INVALID;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const int is_rect = is_rect_tx(max_tx_size);
const int allow_horz = allow_tx_horz_split(max_tx_size);
const int allow_vert = allow_tx_vert_split(max_tx_size);
TX_PARTITION_TYPE partition = 0;
/*
If both horizontal and vertical splits are allowed for this block,
first signal using a 4 way tree to indicate TX_PARTITION_NONE,
TX_PARTITION_SPLIT, TX_PARTITION_HORZ or TX_PARTITION_VERT. If the
actual tx partition type is HORZ4 or VERT4, we read an additional
bit to indicate to split further.
*/
if (allow_horz && allow_vert) {
// Read 4way tree type
const int split4_ctx =
is_inter ? txfm_partition_split4_inter_context(
xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, bsize, max_tx_size)
: get_tx_size_context(xd);
aom_cdf_prob *split4_cdf =
is_inter ? ec_ctx->inter_4way_txfm_partition_cdf[is_rect][split4_ctx]
: ec_ctx->intra_4way_txfm_partition_cdf[is_rect][split4_ctx];
const TX_PARTITION_TYPE split4_partition =
aom_read_symbol(r, split4_cdf, 4, ACCT_STR);
partition = split4_partition;
/*
If only one split type (horizontal or vertical) is allowed for this block,
first signal a bit indicating whether there is any split at all. If
the partition has a split, and this block is able to be split further,
we send a second bit to indicate if the type should be HORZ4 or VERT4.
*/
} else if (allow_horz || allow_vert) {
// Read bit to indicate if there is any split at all
aom_cdf_prob *split2_cdf = is_inter ? ec_ctx->inter_2way_txfm_partition_cdf
: ec_ctx->intra_2way_txfm_partition_cdf;
const int has_first_split = aom_read_symbol(r, split2_cdf, 2, ACCT_STR);
partition = has_first_split
? (allow_horz ? TX_PARTITION_HORZ : TX_PARTITION_VERT)
: TX_PARTITION_NONE;
} else {
assert(!allow_horz && !allow_vert);
partition = TX_PARTITION_NONE;
}
TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 };
get_tx_partition_sizes(partition, max_tx_size, sub_txs);
// TODO(sarahparker) This assumes all of the tx sizes in the partition scheme
// are the same size. This will need to be adjusted to deal with the case
// where they can be different.
mbmi->tx_size = sub_txs[0];
const int index =
is_inter ? av1_get_txb_size_index(bsize, blk_row, blk_col) : 0;
mbmi->tx_partition_type[index] = partition;
if (is_inter) {
const TX_SIZE txs = sub_tx_size_map[max_txsize_rect_lookup[bsize]];
const int tx_w_log2 = tx_size_wide_log2[txs] - MI_SIZE_LOG2;
const int tx_h_log2 = tx_size_high_log2[txs] - MI_SIZE_LOG2;
const int bw_log2 = mi_size_wide_log2[bsize];
const int stride_log2 = bw_log2 - tx_w_log2;
set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, max_tx_size,
mbmi->tx_size, blk_row, blk_col);
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, mbmi->tx_size,
max_tx_size);
}
return sub_txs[0];
}
#else
static AOM_INLINE void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi,
TX_SIZE tx_size, int depth,
#if CONFIG_LPF_MASK
AV1_COMMON *cm, int mi_row,
int mi_col, int store_bitmask,
#endif
int blk_row, int blk_col,
aom_reader *r) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
int is_split = 0;
int plane_type = (xd->tree_type == CHROMA_PART);
const BLOCK_SIZE bsize = mbmi->sb_type[plane_type];
const int max_blocks_high = max_block_high(xd, bsize, 0);
const int max_blocks_wide = max_block_wide(xd, bsize, 0);
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
assert(tx_size > TX_4X4);
TX_SIZE txs = max_txsize_rect_lookup[bsize];
for (int level = 0; level < MAX_VARTX_DEPTH - 1; ++level)
txs = sub_tx_size_map[txs];
const int tx_w_log2 = tx_size_wide_log2[txs] - MI_SIZE_LOG2;
const int tx_h_log2 = tx_size_high_log2[txs] - MI_SIZE_LOG2;
const int bw_log2 = mi_size_wide_log2[bsize];
const int stride_log2 = bw_log2 - tx_w_log2;
if (depth == MAX_VARTX_DEPTH) {
set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size,
tx_size, blk_row, blk_col);
mbmi->tx_size = tx_size;
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, tx_size, tx_size);
return;
}
const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row,
mbmi->sb_type[plane_type], tx_size);
is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR);
if (is_split) {
const TX_SIZE sub_txs = sub_tx_size_map[tx_size];
const int bsw = tx_size_wide_unit[sub_txs];
const int bsh = tx_size_high_unit[sub_txs];
if (sub_txs == TX_4X4) {
set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size,
sub_txs, blk_row, blk_col);
mbmi->tx_size = sub_txs;
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, sub_txs, tx_size);
#if CONFIG_LPF_MASK
if (store_bitmask) {
av1_store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
txsize_to_bsize[tx_size], TX_4X4, mbmi);
}
#endif
return;
}
#if CONFIG_LPF_MASK
if (depth + 1 == MAX_VARTX_DEPTH && store_bitmask) {
av1_store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
txsize_to_bsize[tx_size], sub_txs, mbmi);
store_bitmask = 0;
}
#endif
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;
read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1,
#if CONFIG_LPF_MASK
cm, mi_row, mi_col, store_bitmask,
#endif
offsetr, offsetc, r);
}
}
} else {
set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size,
tx_size, blk_row, blk_col);
mbmi->tx_size = tx_size;
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, tx_size, tx_size);
#if CONFIG_LPF_MASK
if (store_bitmask) {
av1_store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
txsize_to_bsize[tx_size], tx_size, mbmi);
}
#endif
}
}
static TX_SIZE read_selected_tx_size(const MACROBLOCKD *const xd,
aom_reader *r) {
// TODO(debargha): Clean up the logic here. This function should only
// be called for intra.
const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART];
const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize);
const int max_depths = bsize_to_max_depth(bsize);
const int ctx = get_tx_size_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
max_depths + 1, ACCT_STR);
assert(depth >= 0 && depth <= max_depths);
const TX_SIZE tx_size = depth_to_tx_size(depth, bsize);
return tx_size;
}
#endif // CONFIG_NEW_TX_PARTITION
static TX_SIZE read_tx_size(MACROBLOCKD *xd, TX_MODE tx_mode, int is_inter,
int allow_select_inter, aom_reader *r) {
const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART];
if (xd->lossless[xd->mi[0]->segment_id]) return TX_4X4;
if (block_signals_txsize(bsize)) {
if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) {
#if CONFIG_NEW_TX_PARTITION
MB_MODE_INFO *mbmi = xd->mi[0];
const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
return read_tx_partition(xd, mbmi, max_tx_size, 0, 0, r);
#else
const TX_SIZE coded_tx_size = read_selected_tx_size(xd, r);
return coded_tx_size;
#endif // CONFIG_NEW_TX_PARTITION
} else {
return tx_size_from_tx_mode(bsize, tx_mode);
}
} else {
assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
return max_txsize_rect_lookup[bsize];
}
}
static AOM_INLINE void parse_decode_block(AV1Decoder *const pbi,
ThreadData *const td, int mi_row,
int mi_col, aom_reader *r,
PARTITION_TYPE partition,
BLOCK_SIZE bsize,
PARTITION_TREE *parent, int index) {
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
decode_mbmi_block(pbi, dcb, mi_row, mi_col, r, partition, bsize, parent,
index);
av1_visit_palette(pbi, xd, r, av1_decode_palette_tokens);
AV1_COMMON *cm = &pbi->common;
const int num_planes = av1_num_planes(cm);
MB_MODE_INFO *mbmi = xd->mi[0];
int inter_block_tx = is_inter_block(mbmi, xd->tree_type) ||
is_intrabc_block(mbmi, xd->tree_type);
if (xd->tree_type != CHROMA_PART) {
if (cm->features.tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) &&
!mbmi->skip_txfm[xd->tree_type == CHROMA_PART] && inter_block_tx &&
!xd->lossless[mbmi->segment_id]) {
const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
const int bh = tx_size_high_unit[max_tx_size];
const int bw = tx_size_wide_unit[max_tx_size];
const int width = mi_size_wide[bsize];
const int height = mi_size_high[bsize];
for (int idy = 0; idy < height; idy += bh)
for (int idx = 0; idx < width; idx += bw)
#if CONFIG_NEW_TX_PARTITION
read_tx_partition(xd, mbmi, max_tx_size, idy, idx, r);
#else
read_tx_size_vartx(xd, mbmi, max_tx_size, 0,
#if CONFIG_LPF_MASK
cm, mi_row, mi_col, 1,
#endif
idy, idx, r);
#endif // CONFIG_NEW_TX_PARTITION
} else {
mbmi->tx_size =
read_tx_size(xd, cm->features.tx_mode, inter_block_tx,
!mbmi->skip_txfm[xd->tree_type == CHROMA_PART], r);
if (inter_block_tx)
memset(mbmi->inter_tx_size, mbmi->tx_size, sizeof(mbmi->inter_tx_size));
set_txfm_ctxs(mbmi->tx_size, xd->width, xd->height,
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] &&
is_inter_block(mbmi, xd->tree_type),
xd);
#if CONFIG_LPF_MASK
const int w = mi_size_wide[bsize];
const int h = mi_size_high[bsize];
if (w <= mi_size_wide[BLOCK_64X64] && h <= mi_size_high[BLOCK_64X64]) {
av1_store_bitmask_univariant_tx(cm, mi_row, mi_col, bsize, mbmi);
} else {
for (int row = 0; row < h; row += mi_size_high[BLOCK_64X64]) {
for (int col = 0; col < w; col += mi_size_wide[BLOCK_64X64]) {
av1_store_bitmask_univariant_tx(cm, mi_row + row, mi_col + col,
BLOCK_64X64, mbmi);
}
}
}
#endif
}
}
#if CONFIG_LPF_MASK
const int w = mi_size_wide[bsize];
const int h = mi_size_high[bsize];
if (w <= mi_size_wide[BLOCK_64X64] && h <= mi_size_high[BLOCK_64X64]) {
av1_store_bitmask_other_info(cm, mi_row, mi_col, bsize, mbmi, 1, 1);
} else {
for (int row = 0; row < h; row += mi_size_high[BLOCK_64X64]) {
for (int col = 0; col < w; col += mi_size_wide[BLOCK_64X64]) {
av1_store_bitmask_other_info(cm, mi_row + row, mi_col + col,
BLOCK_64X64, mbmi, row == 0, col == 0);
}
}
}
#endif
if (cm->delta_q_info.delta_q_present_flag) {
for (int i = 0; i < MAX_SEGMENTS; i++) {
const int current_qindex = av1_get_qindex(
&cm->seg, i, xd->current_base_qindex, cm->seq_params.bit_depth);
const CommonQuantParams *const quant_params = &cm->quant_params;
for (int j = 0; j < num_planes; ++j) {
const int dc_delta_q = j == 0 ? quant_params->y_dc_delta_q
: (j == 1 ? quant_params->u_dc_delta_q
: quant_params->v_dc_delta_q);
const int ac_delta_q = j == 0 ? 0
: (j == 1 ? quant_params->u_ac_delta_q
: quant_params->v_ac_delta_q);
xd->plane[j].seg_dequant_QTX[i][0] =
av1_dc_quant_QTX(current_qindex, dc_delta_q,
j == 0 ? cm->seq_params.base_y_dc_delta_q
: cm->seq_params.base_uv_dc_delta_q,
cm->seq_params.bit_depth);
xd->plane[j].seg_dequant_QTX[i][1] = av1_ac_quant_QTX(
current_qindex, ac_delta_q, cm->seq_params.bit_depth);
}
}
}
assert(bsize == mbmi->sb_type[av1_get_sdp_idx(xd->tree_type)]);
if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART])
av1_reset_entropy_context(xd, bsize, num_planes);
decode_token_recon_block(pbi, td, r, partition, bsize);
if (xd->tree_type != SHARED_PART) {
const int bh = mi_size_high[bsize];
const int bw = mi_size_wide[bsize];
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const int x_inside_boundary = AOMMIN(bw, mi_params->mi_cols - mi_col);
const int y_inside_boundary = AOMMIN(bh, mi_params->mi_rows - mi_row);
int idx = mi_params->mi_stride;
assert(x_inside_boundary && y_inside_boundary);
if (xd->tree_type != CHROMA_PART) {
for (int y = 0; y < y_inside_boundary; ++y) {
for (int x = 0; x < x_inside_boundary; ++x) {
if (x == 0 && y == 0) continue;
set_blk_offsets(mi_params, xd, mi_row, mi_col, y, x);
*(xd->mi[y * idx + x]) = *(xd->mi[0]);
}
}
} else {
assert(x_inside_boundary && y_inside_boundary);
for (int y = 0; y < y_inside_boundary; ++y) {
for (int x = 0; x < x_inside_boundary; ++x) {
if (x == 0 && y == 0) continue;
set_blk_offsets(mi_params, xd, mi_row, mi_col, y, x);
xd->mi[y * idx + x]->sb_type[PLANE_TYPE_UV] =
xd->mi[0]->sb_type[PLANE_TYPE_UV];
xd->mi[y * idx + x]->uv_mode = xd->mi[0]->uv_mode;
xd->mi[y * idx + x]->angle_delta[PLANE_TYPE_UV] =
xd->mi[0]->angle_delta[PLANE_TYPE_UV];
if (av1_allow_palette(cm->features.allow_screen_content_tools,
bsize)) {
xd->mi[y * idx + x]->palette_mode_info.palette_size[PLANE_TYPE_UV] =
xd->mi[0]->palette_mode_info.palette_size[PLANE_TYPE_UV];
for (int i = PALETTE_MAX_SIZE; i < 3 * PALETTE_MAX_SIZE; i++)
xd->mi[y * idx + x]->palette_mode_info.palette_colors[i] =
xd->mi[0]->palette_mode_info.palette_colors[i];
}
}
}
}
}
// av1_mark_block_as_coded(xd, bsize, cm->seq_params.sb_size);
}
static AOM_INLINE void set_offsets_for_pred_and_recon(
AV1Decoder *const pbi, ThreadData *const td, int mi_row, int mi_col,
BLOCK_SIZE bsize, PARTITION_TREE *parent, int index) {
AV1_COMMON *const cm = &pbi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
const int num_planes = av1_num_planes(cm);
const int offset = mi_row * mi_params->mi_stride + mi_col;
const TileInfo *const tile = &xd->tile;
xd->mi = mi_params->mi_grid_base + offset;
xd->tx_type_map =
&mi_params->tx_type_map[mi_row * mi_params->mi_stride + mi_col];
xd->tx_type_map_stride = mi_params->mi_stride;
#if CONFIG_CROSS_CHROMA_TX
xd->cctx_type_map =
&mi_params->cctx_type_map[mi_row * mi_params->mi_stride + mi_col];
xd->cctx_type_map_stride = mi_params->mi_stride;
#endif // CONFIG_CROSS_CHROMA_TX
CHROMA_REF_INFO *chroma_ref_info = &xd->mi[0]->chroma_ref_info;
set_chroma_ref_info(mi_row, mi_col, index, bsize, chroma_ref_info,
parent ? &parent->chroma_ref_info : NULL,
parent ? parent->bsize : BLOCK_INVALID,
parent ? parent->partition : PARTITION_NONE,
xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);
set_plane_n4(xd, bw, bh, num_planes, chroma_ref_info);
// Distance of Mb to the various image edges. These are specified to 8th pel
// as they are always compared to values that are in 1/8th pel units
set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
mi_params->mi_cols, chroma_ref_info);
av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
num_planes, chroma_ref_info);
}
static AOM_INLINE void decode_block(AV1Decoder *const pbi, ThreadData *const td,
int mi_row, int mi_col, aom_reader *r,
PARTITION_TYPE partition, BLOCK_SIZE bsize,
PARTITION_TREE *parent, int index) {
(void)partition;
set_offsets_for_pred_and_recon(pbi, td, mi_row, mi_col, bsize, parent, index);
decode_token_recon_block(pbi, td, r, partition, bsize);
}
static PARTITION_TYPE read_partition(const AV1_COMMON *const cm,
MACROBLOCKD *xd, int mi_row, int mi_col,
aom_reader *r, int has_rows, int has_cols,
#if CONFIG_EXT_RECUR_PARTITIONS
const PARTITION_TREE *ptree,
const PARTITION_TREE *ptree_luma,
#endif // CONFIG_EXT_RECUR_PARTITIONS
BLOCK_SIZE bsize) {
#if CONFIG_EXT_RECUR_PARTITIONS
if (!is_partition_point(bsize)) return PARTITION_NONE;
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#if CONFIG_EXT_RECUR_PARTITIONS
(void)has_rows;
(void)has_cols;
const int plane = xd->tree_type == CHROMA_PART;
const int ssx = cm->seq_params.subsampling_x;
const int ssy = cm->seq_params.subsampling_y;
if (plane == 1 && bsize == BLOCK_8X8) {
return PARTITION_NONE;
}
if (is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
return sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ssx, ssy);
}
PARTITION_TYPE implied_partition;
const bool is_part_implied = is_partition_implied_at_boundary(
&cm->mi_params, xd->tree_type, ssx, ssy, mi_row, mi_col, bsize,
&ptree->chroma_ref_info, &implied_partition);
if (is_part_implied) return implied_partition;
#if !CONFIG_H_PARTITION
const PARTITION_TYPE parent_partition =
ptree->parent ? ptree->parent->partition : PARTITION_INVALID;
const bool is_middle_block = (parent_partition == PARTITION_HORZ_3 ||
parent_partition == PARTITION_VERT_3) &&
ptree->index == 1;
const bool limit_rect_split = is_middle_block &&
is_bsize_geq(bsize, BLOCK_8X8) &&
is_bsize_geq(BLOCK_64X64, bsize);
#endif // !CONFIG_H_PARTITION
const bool disable_ext_part = !cm->seq_params.enable_ext_partitions;
if (is_square_block(bsize)) {
assert(ctx >= 0);
if (disable_ext_part) {
aom_cdf_prob *partition_cdf = ec_ctx->partition_noext_cdf[plane][ctx];
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
partition_cdf =
ec_ctx->limited_partition_noext_cdf[plane][dir_index][ctx];
const int symbol = aom_read_symbol(r, partition_cdf,
LIMITED_PARTITION_TYPES, ACCT_STR);
return get_limited_partition_noext_from_symbol(symbol,
parent_partition);
} else {
#endif // !CONFIG_H_PARTITION
return (PARTITION_TYPE)aom_read_symbol(r, partition_cdf,
PARTITION_TYPES, ACCT_STR);
#if !CONFIG_H_PARTITION
}
#endif // !CONFIG_H_PARTITION
} else {
aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
const int dir_index = parent_partition == PARTITION_HORZ_3 ? 0 : 1;
partition_cdf = ec_ctx->limited_partition_cdf[plane][dir_index][ctx];
const int symbol = aom_read_symbol(
r, partition_cdf, limited_partition_cdf_length(bsize), ACCT_STR);
return get_limited_partition_from_symbol(symbol, parent_partition);
} else {
#endif // !CONFIG_H_PARTITION
return (PARTITION_TYPE)aom_read_symbol(
r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
#if !CONFIG_H_PARTITION
}
#endif // !CONFIG_H_PARTITION
}
} else {
if (disable_ext_part) {
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
aom_cdf_prob *partition_cdf =
ec_ctx->partition_middle_noext_rec_cdf[ctx];
const int cdf_length = partition_middle_noext_rec_cdf_length(bsize);
const int symbol =
aom_read_symbol(r, partition_cdf, cdf_length, ACCT_STR);
return get_limited_partition_noext_from_symbol(symbol,
parent_partition);
} else {
#endif // !CONFIG_H_PARTITION
aom_cdf_prob *partition_cdf = ec_ctx->partition_noext_rec_cdf[ctx];
const int cdf_length = partition_noext_rec_cdf_length(bsize);
const int symbol =
aom_read_symbol(r, partition_cdf, cdf_length, ACCT_STR);
return get_partition_noext_from_symbol_rec_block(bsize, symbol);
#if !CONFIG_H_PARTITION
}
#endif // !CONFIG_H_PARTITION
} else {
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
// If we are the middle block of a 3-way partitioning, disable HORZ/VERT
// of the middle partition because it is redundant.
assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
block_size_wide[bsize] == 2 * block_size_high[bsize]));
assert(IMPLIES(parent_partition == PARTITION_VERT_3,
2 * block_size_wide[bsize] == block_size_high[bsize]));
aom_cdf_prob *partition_middle_rec_cdf =
ec_ctx->partition_middle_rec_cdf[ctx];
const PARTITION_TYPE_REC symbol = (PARTITION_TYPE_REC)aom_read_symbol(
r, partition_middle_rec_cdf, partition_middle_rec_cdf_length(bsize),
ACCT_STR);
const PARTITION_TYPE partition =
get_partition_from_symbol_rec_block(bsize, symbol);
assert(IMPLIES(parent_partition == PARTITION_HORZ_3,
partition != PARTITION_HORZ));
assert(IMPLIES(parent_partition == PARTITION_VERT_3,
partition != PARTITION_VERT));
return partition;
}
#endif // !CONFIG_H_PARTITION
aom_cdf_prob *partition_rec_cdf = ec_ctx->partition_rec_cdf[ctx];
const PARTITION_TYPE_REC symbol = (PARTITION_TYPE_REC)aom_read_symbol(
r, partition_rec_cdf, partition_rec_cdf_length(bsize), ACCT_STR);
return get_partition_from_symbol_rec_block(bsize, symbol);
}
}
#else // !CONFIG_EXT_RECUR_PARTITIONS
if (!has_rows && !has_cols) return PARTITION_SPLIT;
const int plane = xd->tree_type == CHROMA_PART;
if (plane == 1 && bsize == BLOCK_8X8) {
return PARTITION_NONE;
}
int parent_block_width = block_size_wide[bsize];
const CommonModeInfoParams *const mi_params = &cm->mi_params;
if (plane && parent_block_width >= SHARED_PART_SIZE) {
int luma_split_flag = get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
// if luma blocks uses smaller blocks, then chroma will also split
if (luma_split_flag > 3) return PARTITION_SPLIT;
}
assert(ctx >= 0);
aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx];
if (has_rows && has_cols) {
return (PARTITION_TYPE)aom_read_symbol(
r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
} else if (!has_rows && has_cols) {
assert(bsize > BLOCK_8X8);
aom_cdf_prob cdf[2];
partition_gather_vert_alike(cdf, partition_cdf, bsize);
assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ;
} else {
assert(has_rows && !has_cols);
assert(bsize > BLOCK_8X8);
aom_cdf_prob cdf[2];
partition_gather_horz_alike(cdf, partition_cdf, bsize);
assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP));
return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
#if CONFIG_FLEX_MVRES
// Set the superblock level parameters
static void set_sb_mv_precision(SB_INFO *sbi, AV1Decoder *const pbi) {
AV1_COMMON *const cm = &pbi->common;
sbi->sb_mv_precision = cm->features.fr_mv_precision;
}
#endif
// TODO(slavarnway): eliminate bsize and subsize in future commits
static AOM_INLINE void decode_partition(AV1Decoder *const pbi,
ThreadData *const td, int mi_row,
int mi_col, aom_reader *reader,
BLOCK_SIZE bsize,
#if CONFIG_FLEX_MVRES
SB_INFO *sbi,
#endif
PARTITION_TREE *ptree,
#if CONFIG_EXT_RECUR_PARTITIONS
PARTITION_TREE *ptree_luma,
#endif // CONFIG_EXT_RECUR_PARTITIONS
int parse_decode_flag) {
assert(bsize < BLOCK_SIZES_ALL);
AV1_COMMON *const cm = &pbi->common;
DecoderCodingBlock *const dcb = &td->dcb;
MACROBLOCKD *const xd = &dcb->xd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const int hbs_w = mi_size_wide[bsize] / 2;
const int hbs_h = mi_size_high[bsize] / 2;
#if !CONFIG_H_PARTITION
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
#endif // !CONFIG_H_PARTITION
PARTITION_TYPE partition;
const int has_rows = (mi_row + hbs_h) < cm->mi_params.mi_rows;
const int has_cols = (mi_col + hbs_w) < cm->mi_params.mi_cols;
if (mi_row >= cm->mi_params.mi_rows || mi_col >= cm->mi_params.mi_cols)
return;
// parse_decode_flag takes the following values :
// 01 - do parse only
// 10 - do decode only
// 11 - do parse and decode
static const block_visitor_fn_t block_visit[4] = { NULL, parse_decode_block,
decode_block,
parse_decode_block };
#if CONFIG_FLEX_MVRES
const int is_sb_root = bsize == cm->seq_params.sb_size;
#endif
if (parse_decode_flag & 1) {
#if CONFIG_FLEX_MVRES
if (is_sb_root) {
set_sb_mv_precision(sbi, pbi);
}
#endif
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end =
get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
for (int plane = plane_start; plane < plane_end; ++plane) {
int rcol0, rcol1, rrow0, rrow1;
if (cm->rst_info[plane].frame_restoration_type != RESTORE_NONE &&
av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
&rcol0, &rcol1, &rrow0, &rrow1)) {
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 = rcol + rrow * rstride;
loop_restoration_read_sb_coeffs(cm, xd, reader, plane, runit_idx);
}
}
}
}
ptree->bsize = bsize;
ptree->mi_row = mi_row;
ptree->mi_col = mi_col;
ptree->is_settled = 1;
PARTITION_TREE *parent = ptree->parent;
set_chroma_ref_info(
mi_row, mi_col, ptree->index, bsize, &ptree->chroma_ref_info,
parent ? &parent->chroma_ref_info : NULL,
parent ? parent->bsize : BLOCK_INVALID,
parent ? parent->partition : PARTITION_NONE, ss_x, ss_y);
partition =
!is_partition_point(bsize)
? PARTITION_NONE
: read_partition(cm, xd, mi_row, mi_col, reader, has_rows, has_cols,
#if CONFIG_EXT_RECUR_PARTITIONS
ptree, ptree_luma,
#endif // CONFIG_EXT_RECUR_PARTITIONS
bsize);
ptree->partition = partition;
switch (partition) {
case PARTITION_SPLIT:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
break;
#if CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ:
case PARTITION_VERT:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
break;
case PARTITION_HORZ_3:
case PARTITION_VERT_3:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
#if CONFIG_H_PARTITION
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
#endif // CONFIG_H_PARTITION
break;
#endif // CONFIG_EXT_RECUR_PARTITIONS
default: break;
}
} else {
partition = ptree->partition;
}
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
if (subsize == BLOCK_INVALID) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
"Partition is invalid for block size %dx%d",
block_size_wide[bsize], block_size_high[bsize]);
}
// Check the bitstream is conformant: if there is subsampling on the
// chroma planes, subsize must subsample to a valid block size.
const struct macroblockd_plane *const pd_u = &xd->plane[1];
#if CONFIG_EXT_RECUR_PARTITIONS
BLOCK_SIZE test_subsize = subsize;
if (xd->tree_type == SHARED_PART) {
const PARTITION_TREE *parent = ptree;
CHROMA_REF_INFO chroma_ref_info;
const int index =
(partition == PARTITION_HORZ || partition == PARTITION_VERT) +
(partition == PARTITION_HORZ_3 || partition == PARTITION_VERT_3);
set_chroma_ref_info(mi_row, mi_col, index, bsize, &chroma_ref_info,
parent ? &parent->chroma_ref_info : NULL,
parent ? parent->bsize : BLOCK_INVALID,
parent ? parent->partition : PARTITION_NONE,
xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);
test_subsize = chroma_ref_info.bsize_base;
assert(test_subsize != BLOCK_INVALID);
}
if (xd->tree_type != LUMA_PART &&
get_plane_block_size(test_subsize, pd_u->subsampling_x,
pd_u->subsampling_y) == BLOCK_INVALID) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
"Block size %dx%d invalid with this subsampling mode",
block_size_wide[test_subsize],
block_size_high[test_subsize]);
}
const int track_ptree_luma =
ptree_luma ? (partition == ptree_luma->partition) : 0;
#else
if (get_plane_block_size(subsize, pd_u->subsampling_x, pd_u->subsampling_y) ==
BLOCK_INVALID) {
aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
"Block size %dx%d invalid with this subsampling mode",
block_size_wide[subsize], block_size_high[subsize]);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
#define DEC_BLOCK_STX_ARG
#define DEC_BLOCK_EPT_ARG partition,
#define DEC_BLOCK(db_r, db_c, db_subsize, index) \
block_visit[parse_decode_flag](pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), \
reader, DEC_BLOCK_EPT_ARG(db_subsize), ptree, \
index)
#if CONFIG_FLEX_MVRES && CONFIG_EXT_RECUR_PARTITIONS
#define DEC_PARTITION(db_r, db_c, db_subsize, index) \
decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \
(db_subsize), sbi, ptree->sub_tree[(index)], \
track_ptree_luma ? ptree_luma->sub_tree[index] : NULL, \
parse_decode_flag)
#elif CONFIG_FLEX_MVRES
#define DEC_PARTITION(db_r, db_c, db_subsize, index) \
decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \
(db_subsize), sbi, ptree->sub_tree[(index)], \
parse_decode_flag)
#elif CONFIG_EXT_RECUR_PARTITIONS
#define DEC_PARTITION(db_r, db_c, db_subsize, index) \
decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \
(db_subsize), ptree->sub_tree[(index)], \
track_ptree_luma ? ptree_luma->sub_tree[index] : NULL, \
parse_decode_flag)
#else
#define DEC_PARTITION(db_r, db_c, db_subsize, index) \
decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \
(db_subsize), ptree->sub_tree[(index)], parse_decode_flag)
#endif // CONFIG_FLEX_MVRES && CONFIG_EXT_RECUR_PARTITIONS
#if !CONFIG_EXT_RECUR_PARTITIONS
const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
switch (partition) {
case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize, 0); break;
case PARTITION_HORZ:
#if CONFIG_EXT_RECUR_PARTITIONS
DEC_PARTITION(mi_row, mi_col, subsize, 0);
if ((mi_row + hbs_h) < cm->mi_params.mi_rows)
DEC_PARTITION(mi_row + hbs_h, mi_col, subsize, 1);
#else
DEC_BLOCK(mi_row, mi_col, subsize, 0);
if (has_rows) DEC_BLOCK(mi_row + hbs_h, mi_col, subsize, 1);
#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
case PARTITION_VERT:
#if CONFIG_EXT_RECUR_PARTITIONS
DEC_PARTITION(mi_row, mi_col, subsize, 0);
if ((mi_col + hbs_w) < cm->mi_params.mi_cols)
DEC_PARTITION(mi_row, mi_col + hbs_w, subsize, 1);
#else
DEC_BLOCK(mi_row, mi_col, subsize, 0);
if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs_w, subsize, 1);
#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
#if CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_H_PARTITION
case PARTITION_HORZ_3:
case PARTITION_VERT_3: {
for (int i = 0; i < 4; ++i) {
BLOCK_SIZE this_bsize = get_h_partition_subsize(bsize, i, partition);
const int offset_r = get_h_partition_offset_mi_row(bsize, i, partition);
const int offset_c = get_h_partition_offset_mi_col(bsize, i, partition);
assert(this_bsize != BLOCK_INVALID);
assert(offset_r >= 0 && offset_c >= 0);
const int this_mi_row = mi_row + offset_r;
const int this_mi_col = mi_col + offset_c;
if (partition == PARTITION_HORZ_3) {
if (this_mi_row >= cm->mi_params.mi_rows) break;
} else {
if (this_mi_col >= cm->mi_params.mi_cols) break;
}
DEC_PARTITION(this_mi_row, this_mi_col, this_bsize, i);
}
break;
}
#else
case PARTITION_HORZ_3: {
const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_HORZ);
int this_mi_row = mi_row;
DEC_PARTITION(this_mi_row, mi_col, subsize, 0);
this_mi_row += qbs_h;
if (this_mi_row >= cm->mi_params.mi_rows) break;
DEC_PARTITION(this_mi_row, mi_col, bsize3, 1);
this_mi_row += 2 * qbs_h;
if (this_mi_row >= cm->mi_params.mi_rows) break;
DEC_PARTITION(this_mi_row, mi_col, subsize, 2);
break;
}
case PARTITION_VERT_3: {
const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_VERT);
int this_mi_col = mi_col;
DEC_PARTITION(mi_row, this_mi_col, subsize, 0);
this_mi_col += qbs_w;
if (this_mi_col >= cm->mi_params.mi_cols) break;
DEC_PARTITION(mi_row, this_mi_col, bsize3, 1);
this_mi_col += 2 * qbs_w;
if (this_mi_col >= cm->mi_params.mi_cols) break;
DEC_PARTITION(mi_row, this_mi_col, subsize, 2);
break;
}
#endif // CONFIG_H_PARTITION
#else
case PARTITION_SPLIT:
DEC_PARTITION(mi_row, mi_col, subsize, 0);
DEC_PARTITION(mi_row, mi_col + hbs_w, subsize, 1);
DEC_PARTITION(mi_row + hbs_h, mi_col, subsize, 2);
DEC_PARTITION(mi_row + hbs_h, mi_col + hbs_w, subsize, 3);
break;
case PARTITION_HORZ_A:
DEC_BLOCK(mi_row, mi_col, bsize2, 0);
DEC_BLOCK(mi_row, mi_col + hbs_w, bsize2, 1);
DEC_BLOCK(mi_row + hbs_h, mi_col, subsize, 2);
break;
case PARTITION_HORZ_B:
DEC_BLOCK(mi_row, mi_col, subsize, 0);
DEC_BLOCK(mi_row + hbs_h, mi_col, bsize2, 1);
DEC_BLOCK(mi_row + hbs_h, mi_col + hbs_w, bsize2, 2);
break;
case PARTITION_VERT_A:
DEC_BLOCK