Google Git
Sign in
aomedia / avm / 1f69ae75f3918c5a194489e9366f2f3767281eec / . / av1 / decoder / decodeframe.c
blob: d5c14886cd7c0a2e67c885bc3b2c79ad9ebc9c36 [file] [log] [blame]
/*
* Copyright (c) 2016, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent.
*/
#include <assert.h>
#include <stddef.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"
#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"
#if CONFIG_MFQE_RESTORATION
#include "av1/common/mfqe.h"
#endif // CONFIG_MFQE_RESTORATION
#include "av1/common/mvref_common.h"
#if CONFIG_NN_RECON
#include "av1/common/nn_recon.h"
#endif // CONFIG_NN_RECON
#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"
#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"
#if CONFIG_CNN_RESTORATION || CONFIG_LOOP_RESTORE_CNN
#include "av1/common/cnn_tflite.h"
#endif // CONFIG_CNN_RESTORATION || CONFIG_LOOP_RESTORE_CNN
#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))
// 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 void set_planes_to_neutral_grey(const SequenceHeader *const seq_params,
const YV12_BUFFER_CONFIG *const buf,
int only_chroma) {
if (seq_params->use_highbitdepth) {
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 = CONVERT_TO_SHORTPTR(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]);
}
}
}
} else {
for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) {
const int is_uv = plane > 0;
for (int row_idx = 0; row_idx < buf->crop_heights[is_uv]; row_idx++) {
memset(&buf->buffers[plane][row_idx * buf->uv_stride], 1 << 7,
buf->crop_widths[is_uv]);
}
}
}
}
static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
MACROBLOCKD *xd,
aom_reader *const r, int plane,
int runit_idx);
#if CONFIG_CNN_CRLC_GUIDED
static void crlc_guided_read_coeffs(AV1_COMMON *const cm, MACROBLOCKD *xd,
aom_reader *const r, int plane,
int runit_idx);
#endif // CONFIG_CNN_CRLC_GUIDED
static void setup_compound_reference_mode(AV1_COMMON *cm) {
cm->comp_fwd_ref[0] = LAST_FRAME;
cm->comp_fwd_ref[1] = LAST2_FRAME;
cm->comp_fwd_ref[2] = LAST3_FRAME;
cm->comp_fwd_ref[3] = GOLDEN_FRAME;
cm->comp_bwd_ref[0] = BWDREF_FRAME;
cm->comp_bwd_ref[1] = ALTREF2_FRAME;
cm->comp_bwd_ref[2] = ALTREF_FRAME;
}
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(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
if (cm->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 CONFIG_MISC_CHANGES
if (cm->only_one_ref_available) return SINGLE_REFERENCE;
#endif // CONFIG_MISC_CHANGES
if (frame_is_intra_only(cm)) {
return SINGLE_REFERENCE;
} else {
return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
}
}
static void inverse_transform_block(MACROBLOCKD *xd, int plane,
const TX_TYPE tx_type,
const TX_SIZE tx_size, uint8_t *dst,
int stride, int reduced_tx_set) {
struct macroblockd_plane *const pd = &xd->plane[plane];
tran_low_t *const dqcoeff = pd->dqcoeff_block + xd->cb_offset[plane];
eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
uint16_t scan_line = eob_data->max_scan_line;
uint16_t eob = eob_data->eob;
av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst, stride,
eob, reduced_tx_set);
memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0]));
}
static void read_coeffs_tx_intra_block(const AV1_COMMON *const cm,
MACROBLOCKD *const xd,
aom_reader *const r, const int plane,
const int row, const int col,
const TX_SIZE tx_size) {
MB_MODE_INFO *mbmi = xd->mi[0];
if (!mbmi->skip) {
#if TXCOEFF_TIMER
struct aom_usec_timer timer;
aom_usec_timer_start(&timer);
#endif
av1_read_coeffs_txb_facade(cm, xd, 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
} else {
// all tx blocks are skipped.
av1_update_txk_skip_array(cm, xd->mi_row, xd->mi_col, plane, row, col,
tx_size, cm->fDecTxSkipLog);
}
}
static void decode_block_void(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
aom_reader *const r, const int plane,
const int row, const int col,
const TX_SIZE tx_size) {
(void)cm;
(void)xd;
(void)r;
(void)plane;
(void)row;
(void)col;
(void)tx_size;
}
static void predict_inter_block_void(AV1_COMMON *const cm,
MACROBLOCKD *const xd, BLOCK_SIZE bsize) {
(void)cm;
(void)xd;
(void)bsize;
}
static void cfl_store_inter_block_void(AV1_COMMON *const cm,
MACROBLOCKD *const xd) {
(void)cm;
(void)xd;
}
static void predict_and_reconstruct_intra_block(
const AV1_COMMON *const cm, MACROBLOCKD *const xd, aom_reader *const r,
const int plane, const int row, const int col, const TX_SIZE tx_size) {
(void)r;
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 (!mbmi->skip) {
struct macroblockd_plane *const pd = &xd->plane[plane];
// tx_type will be read out in av1_read_coeffs_txb_facade
const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, tx_size,
cm->reduced_tx_set_used);
eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
if (eob_data->eob) {
uint8_t *dst =
&pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
cm->reduced_tx_set_used);
}
}
if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) {
cfl_store_tx(xd, row, col, tx_size);
}
}
static void inverse_transform_inter_block(const AV1_COMMON *const cm,
MACROBLOCKD *const xd,
aom_reader *const r, const int plane,
const int blk_row, const int blk_col,
const TX_SIZE tx_size) {
(void)r;
PLANE_TYPE plane_type = get_plane_type(plane);
const struct macroblockd_plane *const pd = &xd->plane[plane];
// tx_type will be read out in av1_read_coeffs_txb_facade
const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, blk_row, blk_col,
tx_size, cm->reduced_tx_set_used);
uint8_t *dst =
&pd->dst
.buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]];
inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
cm->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];
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,
xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);
#endif
}
static void set_cb_buffer_offsets(MACROBLOCKD *const xd, TX_SIZE tx_size,
int plane) {
xd->cb_offset[plane] += tx_size_wide[tx_size] * tx_size_high[tx_size];
xd->txb_offset[plane] =
xd->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
}
static 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, int block,
TX_SIZE tx_size, int *eob_total) {
MACROBLOCKD *const xd = &td->xd;
const struct macroblockd_plane *const pd = &xd->plane[plane];
const BLOCK_SIZE uv_bsize_base = mbmi->chroma_ref_info.bsize_base;
const TX_SIZE plane_tx_size =
plane ? av1_get_max_uv_txsize(uv_bsize_base, pd->subsampling_x,
pd->subsampling_y)
: mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row,
blk_col)];
// 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) {
td->read_coeffs_tx_inter_block_visit(cm, xd, r, plane, blk_row, blk_col,
tx_size);
td->inverse_tx_inter_block_visit(cm, xd, r, plane, blk_row, blk_col,
tx_size);
eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
*eob_total += eob_data->eob;
set_cb_buffer_offsets(xd, tx_size, plane);
} 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->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 sub_step = bsw * bsh;
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, xd, r, plane, offsetr, offsetc,
sub_tx);
td->inverse_tx_inter_block_visit(cm, xd, r, plane, offsetr, offsetc,
sub_tx);
eob_info *eob_data = pd->eob_data + xd->txb_offset[plane];
*eob_total += eob_data->eob;
set_cb_buffer_offsets(xd, sub_tx, plane);
block += sub_step;
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 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_mis, int y_mis, PARTITION_TREE *parent,
int index) {
const int num_planes = av1_num_planes(cm);
const int offset = mi_row * cm->mi_stride + mi_col;
const TileInfo *const tile = &xd->tile;
xd->mi = cm->mi_grid_base + offset;
xd->mi[0] = &cm->mi[offset];
// TODO(slavarnway): Generate sb_type based on bwl and bhl, instead of
// passing bsize from decode_partition().
xd->mi[0]->sb_type = bsize;
#if CONFIG_RD_DEBUG
xd->mi[0]->mi_row = mi_row;
xd->mi[0]->mi_col = mi_col;
#endif
xd->cfl.mi_row = mi_row;
xd->cfl.mi_col = mi_col;
assert(x_mis && y_mis);
for (int x = 1; x < x_mis; ++x) xd->mi[x] = xd->mi[0];
int idx = cm->mi_stride;
for (int y = 1; y < y_mis; ++y) {
memcpy(&xd->mi[idx], &xd->mi[0], x_mis * sizeof(xd->mi[0]));
idx += cm->mi_stride;
}
set_chroma_ref_info(mi_row, mi_col, index, bsize, &xd->mi[0]->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, bsize, num_planes, &xd->mi[0]->chroma_ref_info);
set_skip_context(xd, mi_row, mi_col, num_planes, &xd->mi[0]->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, cm->mi_rows, cm->mi_cols,
&xd->mi[0]->chroma_ref_info);
av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
num_planes, &xd->mi[0]->chroma_ref_info);
}
static void decode_mbmi_block(AV1Decoder *const pbi, MACROBLOCKD *const xd,
int mi_row, int mi_col, aom_reader *r,
PARTITION_TYPE partition, BLOCK_SIZE bsize,
PARTITION_TREE *parent, int index) {
assert(bsize < BLOCK_SIZES_ALL);
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_mis = AOMMIN(bw, cm->mi_cols - mi_col);
const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row);
#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;
// 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];
const BLOCK_SIZE chroma_bsize_base = xd->mi[0]->chroma_ref_info.bsize_base;
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]);
}
av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis);
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.");
}
}
typedef struct PadBlock {
int x0;
int x1;
int y0;
int y1;
} PadBlock;
static void highbd_build_mc_border(const uint8_t *src8, int src_stride,
uint8_t *dst8, int dst_stride, int x, int y,
int b_w, int b_h, int w, int h) {
// Get a pointer to the start of the real data for this row.
const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
const uint16_t *ref_row = src - x - y * src_stride;
if (y >= h)
ref_row += (h - 1) * src_stride;
else if (y > 0)
ref_row += y * src_stride;
do {
int right = 0, copy;
int left = x < 0 ? -x : 0;
if (left > b_w) left = b_w;
if (x + b_w > w) right = x + b_w - w;
if (right > b_w) right = b_w;
copy = b_w - left - right;
if (left) aom_memset16(dst, ref_row[0], left);
if (copy) memcpy(dst + left, ref_row + x + left, copy * sizeof(uint16_t));
if (right) aom_memset16(dst + left + copy, ref_row[w - 1], right);
dst += dst_stride;
++y;
if (y > 0 && y < h) ref_row += src_stride;
} while (--b_h);
}
static void build_mc_border(const uint8_t *src, int src_stride, uint8_t *dst,
int dst_stride, int x, int y, int b_w, int b_h,
int w, int h) {
// Get a pointer to the start of the real data for this row.
const uint8_t *ref_row = src - x - y * src_stride;
if (y >= h)
ref_row += (h - 1) * src_stride;
else if (y > 0)
ref_row += y * src_stride;
do {
int right = 0, copy;
int left = x < 0 ? -x : 0;
if (left > b_w) left = b_w;
if (x + b_w > w) right = x + b_w - w;
if (right > b_w) right = b_w;
copy = b_w - left - right;
if (left) memset(dst, ref_row[0], left);
if (copy) memcpy(dst + left, ref_row + x + left, copy);
if (right) memset(dst + left + copy, ref_row[w - 1], right);
dst += dst_stride;
++y;
if (y > 0 && y < h) ref_row += src_stride;
} while (--b_h);
}
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) {
// For simplicity, always extend the border region. When someone calls
// av1_make_inter_predictor and wants a border built around it, this
// ensures it can read the data around it.
(void)sf;
(void)pre_buf;
(void)scaled_mv;
(void)subpel_x_mv;
(void)subpel_y_mv;
(void)do_warp;
if (!is_intrabc) {
block->x0 -= AOM_INTERP_EXTEND - 1 + INTERINTRA_PRED_BORDER;
block->x1 += AOM_INTERP_EXTEND + INTERINTRA_PRED_BORDER;
*x_pad = 1;
block->y0 -= AOM_INTERP_EXTEND - 1 + INTERINTRA_PRED_BORDER;
block->y1 += AOM_INTERP_EXTEND + INTERINTRA_PRED_BORDER;
*y_pad = 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, int highbd,
uint8_t *mc_buf, uint8_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 uint8_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.
if (highbd) {
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);
} else {
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 + INTERINTRA_PRED_BORDER) * b_w +
x_pad * (AOM_INTERP_EXTEND - 1 + INTERINTRA_PRED_BORDER);
}
}
static INLINE void dec_calc_subpel_params(
MACROBLOCKD *xd, const struct scale_factors *const sf, const MV *const mv,
int plane, int pre_x, int pre_y, int x, int y, struct buf_2d *const pre_buf,
SubpelParams *subpel_params, int bw, int bh, PadBlock *block, int mi_x,
int mi_y,
#if CONFIG_OPTFLOW_REFINEMENT
int use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
MV32 *scaled_mv, int *subpel_x_mv, int *subpel_y_mv) {
struct macroblockd_plane *const pd = &xd->plane[plane];
const int is_scaled = av1_is_scaled(sf);
if (is_scaled) {
int ssx = pd->subsampling_x;
int ssy = pd->subsampling_y;
int orig_pos_y = (pre_y + y) << SUBPEL_BITS;
orig_pos_y += mv->row * (1 << (1 - ssy));
int orig_pos_x = (pre_x + x) << SUBPEL_BITS;
orig_pos_x += mv->col * (1 << (1 - ssx));
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 = clamp_mv_to_umv_border_sb(xd, mv, bw, bh,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
pd->subsampling_x, pd->subsampling_y);
*scaled_mv = av1_scale_mv(&temp_mv, (mi_x + x), (mi_y + 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 = (pre_x + x) << SUBPEL_BITS;
int pos_y = (pre_y + y) << SUBPEL_BITS;
const MV mv_q4 =
clamp_mv_to_umv_border_sb(xd, mv, bw, bh,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
pd->subsampling_x, pd->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) + (bw - 1) + 1;
block->y1 = (pos_y >> SUBPEL_BITS) + (bh - 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;
}
}
typedef struct {
const MB_MODE_INFO *mi;
int mi_x;
int mi_y;
int build_for_obmc;
} DecCalcSubpelFuncArgs;
static void dec_calc_subpel_params_and_extend(
MACROBLOCKD *xd, const struct scale_factors *const sf, const MV *const mv,
int plane, int pre_x, int pre_y, int x, int y, struct buf_2d *const pre_buf,
int bw, int bh, const WarpTypesAllowed *const warp_types, int ref,
#if CONFIG_OPTFLOW_REFINEMENT
int use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
const void *const void_args, uint8_t **pre, SubpelParams *subpel_params,
int *src_stride) {
const DecCalcSubpelFuncArgs *const args =
(const DecCalcSubpelFuncArgs *)void_args;
PadBlock block;
MV32 scaled_mv;
int subpel_x_mv, subpel_y_mv;
dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, x, y, pre_buf,
subpel_params, bw, bh, &block, args->mi_x, args->mi_y,
#if CONFIG_OPTFLOW_REFINEMENT
use_optflow_refinement,
#endif // CONFIG_OPTFLOW_REFINEMENT
&scaled_mv, &subpel_x_mv, &subpel_y_mv);
*pre = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
*src_stride = pre_buf->stride;
const int highbd = is_cur_buf_hbd(xd);
const int do_warp =
#if CONFIG_EXT_WARP && CONFIG_SUB8X8_WARP
bw >= 4 && bh >= 4
#else
bw >= 8 && bh >= 8
#endif // CONFIG_EXT_WARP && CONFIG_SUB8X8_WARP
&& av1_allow_warp(args->mi, warp_types,
&xd->global_motion[args->mi->ref_frame[ref]],
args->build_for_obmc, sf, NULL) &&
(xd->cur_frame_force_integer_mv == 0);
extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv, subpel_y_mv,
do_warp, is_intrabc_block(args->mi), highbd, xd->mc_buf[ref],
pre, src_stride);
}
static void dec_build_inter_predictors(const AV1_COMMON *cm, MACROBLOCKD *xd,
int plane, MB_MODE_INFO *mi,
int build_for_obmc, int bw, int bh,
int mi_x, int mi_y) {
const DecCalcSubpelFuncArgs args = { mi, mi_x, mi_y, build_for_obmc };
const int border = 0;
av1_build_inter_predictors(cm, xd, plane, mi, build_for_obmc, bw, bh, mi_x,
mi_y, dec_calc_subpel_params_and_extend, &args,
xd->plane[plane].dst.buf,
xd->plane[plane].dst.stride, border);
}
static void build_inter_predictors_for_plane(const AV1_COMMON *cm,
MACROBLOCKD *xd, int mi_row,
int mi_col, const BUFFER_SET *ctx,
BLOCK_SIZE bsize, int plane) {
MB_MODE_INFO *mi = xd->mi[0];
if (plane != AOM_PLANE_Y && !mi->chroma_ref_info.is_chroma_ref) {
return;
}
const int mi_x = mi_col * MI_SIZE;
const int mi_y = mi_row * MI_SIZE;
const int bw = xd->plane[plane].width;
const int bh = xd->plane[plane].height;
const int build_for_obmc = 0;
if (!is_interintra_pred(mi)) {
dec_build_inter_predictors(cm, xd, plane, mi, build_for_obmc, bw, bh, mi_x,
mi_y);
return;
}
BUFFER_SET default_ctx = { { NULL, NULL, NULL }, { 0, 0, 0 } };
if (!ctx) {
default_ctx.plane[plane] = xd->plane[plane].dst.buf;
default_ctx.stride[plane] = xd->plane[plane].dst.stride;
ctx = &default_ctx;
}
const int border = av1_calc_border(xd, AOM_PLANE_Y, build_for_obmc);
uint8_t *interpred = xd->plane[plane].dst.buf;
int interpred_stride = xd->plane[plane].dst.stride;
if (border > 0) {
av1_alloc_buf_with_border(&interpred, &interpred_stride, border,
is_cur_buf_hbd(xd));
}
const DecCalcSubpelFuncArgs args = { mi, mi_x, mi_y, build_for_obmc };
av1_build_inter_predictors(cm, xd, plane, mi, build_for_obmc, bw, bh, mi_x,
mi_y, dec_calc_subpel_params_and_extend, &args,
interpred, interpred_stride, border);
// Saves the predictor in xd->plane[plane].dst.buf.
av1_build_interintra_predictors_sbp(cm, xd, interpred, interpred_stride, ctx,
plane, bsize, border);
if (border > 0) {
av1_free_buf_with_border(interpred, interpred_stride, border,
is_cur_buf_hbd(xd));
}
}
static void dec_build_inter_predictors_sb(const AV1_COMMON *cm, MACROBLOCKD *xd,
int mi_row, int mi_col,
BUFFER_SET *ctx, BLOCK_SIZE bsize) {
const int num_planes = av1_num_planes(cm);
build_inter_predictors_for_plane(cm, xd, mi_row, mi_col, ctx, bsize,
AOM_PLANE_Y);
if (num_planes > 1) {
build_inter_predictors_for_plane(cm, xd, mi_row, mi_col, ctx, bsize,
AOM_PLANE_U);
build_inter_predictors_for_plane(cm, xd, mi_row, mi_col, ctx, bsize,
AOM_PLANE_V);
}
}
static INLINE void dec_build_prediction_by_above_pred(
MACROBLOCKD *xd, int rel_mi_col, uint8_t above_mi_width,
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;
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);
av1_setup_build_prediction_by_above_pred(xd, rel_mi_col, above_mi_width,
&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;
for (int j = 0; j < num_planes; ++j) {
const struct macroblockd_plane *pd = &xd->plane[j];
int bw = (above_mi_width * 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(mi_row, mi_col, bsize, pd, 0)) continue;
dec_build_inter_predictors(ctxt->cm, xd, j, &backup_mbmi, 1, bw, bh, mi_x,
mi_y);
}
}
static void dec_build_prediction_by_above_preds(const AV1_COMMON *cm,
MACROBLOCKD *xd,
uint8_t *tmp_buf[MAX_MB_PLANE],
int tmp_width[MAX_MB_PLANE],
int tmp_height[MAX_MB_PLANE],
int tmp_stride[MAX_MB_PLANE]) {
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.
int this_height = xd->n4_h * MI_SIZE;
int pred_height = AOMMIN(this_height / 2, 32);
xd->mb_to_bottom_edge += (this_height - pred_height) * 8;
struct build_prediction_ctxt ctxt = { cm, tmp_buf,
tmp_width, tmp_height,
tmp_stride, xd->mb_to_right_edge };
BLOCK_SIZE bsize = xd->mi[0]->sb_type;
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 = -((xd->mi_col * MI_SIZE) * 8);
xd->mb_to_right_edge = ctxt.mb_to_far_edge;
xd->mb_to_bottom_edge -= (this_height - pred_height) * 8;
}
static INLINE void dec_build_prediction_by_left_pred(
MACROBLOCKD *xd, int rel_mi_row, uint8_t left_mi_height,
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;
av1_setup_build_prediction_by_left_pred(xd, rel_mi_row, left_mi_height,
&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;
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);
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 = (left_mi_height << MI_SIZE_LOG2) >> pd->subsampling_y;
if (av1_skip_u4x4_pred_in_obmc(mi_row, mi_col, bsize, pd, 1)) continue;
dec_build_inter_predictors(ctxt->cm, xd, j, &backup_mbmi, 1, bw, bh, mi_x,
mi_y);
}
}
static void dec_build_prediction_by_left_preds(const AV1_COMMON *cm,
MACROBLOCKD *xd,
uint8_t *tmp_buf[MAX_MB_PLANE],
int tmp_width[MAX_MB_PLANE],
int tmp_height[MAX_MB_PLANE],
int tmp_stride[MAX_MB_PLANE]) {
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.
int this_width = xd->n4_w * MI_SIZE;
int pred_width = AOMMIN(this_width / 2, 32);
xd->mb_to_right_edge += (this_width - pred_width) * 8;
struct build_prediction_ctxt ctxt = { cm, tmp_buf,
tmp_width, tmp_height,
tmp_stride, xd->mb_to_bottom_edge };
BLOCK_SIZE bsize = xd->mi[0]->sb_type;
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 = -((xd->mi_row * MI_SIZE) * 8);
xd->mb_to_right_edge -= (this_width - pred_width) * 8;
xd->mb_to_bottom_edge = ctxt.mb_to_far_edge;
}
static void dec_build_obmc_inter_predictors_sb(const AV1_COMMON *cm,
MACROBLOCKD *xd) {
const int num_planes = av1_num_planes(cm);
uint8_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 };
if (is_cur_buf_hbd(xd)) {
int len = sizeof(uint16_t);
dst_buf1[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0]);
dst_buf1[1] =
CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * len);
dst_buf1[2] =
CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2 * len);
dst_buf2[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1]);
dst_buf2[1] =
CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * len);
dst_buf2[2] =
CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2 * len);
} else {
dst_buf1[0] = xd->tmp_obmc_bufs[0];
dst_buf1[1] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE;
dst_buf1[2] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2;
dst_buf2[0] = xd->tmp_obmc_bufs[1];
dst_buf2[1] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE;
dst_buf2[2] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2;
}
dec_build_prediction_by_above_preds(cm, xd, dst_buf1, dst_width1, dst_height1,
dst_stride1);
dec_build_prediction_by_left_preds(cm, xd, 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 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)) {
cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
}
}
static void predict_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd,
BLOCK_SIZE bsize) {
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 < LAST_FRAME) {
assert(is_intrabc_block(mbmi));
assert(frame == INTRA_FRAME);
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);
}
}
dec_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, bsize);
if (mbmi->motion_mode == OBMC_CAUSAL) {
dec_build_obmc_inter_predictors_sb(cm, xd);
}
#if CONFIG_MISMATCH_DEBUG
for (int plane = 0; plane < num_planes; ++plane) {
const struct macroblockd_plane *pd = &xd->plane[plane];
int pixel_c, pixel_r;
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, pd->subsampling_x,
pd->subsampling_y);
if (plane && !mbmi->chroma_ref_info.is_chroma_ref) continue;
mismatch_check_block_pre(pd->dst.buf, pd->dst.stride,
cm->current_frame.order_hint, plane, pixel_c,
pixel_r, pd->width, pd->height,
xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);
}
#endif
}
static 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, xd, &params.plane_width,
&params.plane_height, NULL, NULL);
xd->color_index_map_offset[plane] += params.plane_width * params.plane_height;
}
static void decode_token_recon_block(AV1Decoder *const pbi,
ThreadData *const td, int mi_row,
int mi_col, aom_reader *r,
BLOCK_SIZE bsize) {
AV1_COMMON *const cm = &pbi->common;
MACROBLOCKD *const xd = &td->xd;
const int num_planes = av1_num_planes(cm);
MB_MODE_INFO *mbmi = xd->mi[0];
CFL_CTX *const cfl = &xd->cfl;
cfl->is_chroma_reference = mbmi->chroma_ref_info.is_chroma_ref;
av1_init_txk_skip_array(cm, mbmi, mi_row, mi_col, bsize, 0,
cm->fDecTxSkipLog);
if (!is_inter_block(mbmi)) {
int row, col;
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 =
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];
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 = 0; plane < num_planes; ++plane) {
const struct macroblockd_plane *const pd = &xd->plane[plane];
if (plane && !mbmi->chroma_ref_info.is_chroma_ref) continue;
const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
const int stepr = tx_size_high_unit[tx_size];
const int stepc = tx_size_wide_unit[tx_size];
const BLOCK_SIZE bsize_base =
plane ? mbmi->chroma_ref_info.bsize_base : bsize;
const BLOCK_SIZE plane_bsize = get_plane_block_size(
bsize_base, pd->subsampling_x, pd->subsampling_y);
const int row_plane = row >> pd->subsampling_y;
const int col_plane = col >> pd->subsampling_x;
int unit_width, unit_height;
av1_get_unit_width_height_coeff(xd, plane, plane_bsize, row_plane,
col_plane, &unit_width, &unit_height);
for (int blk_row = row_plane; blk_row < unit_height;
blk_row += stepr) {
for (int blk_col = col_plane; blk_col < unit_width;
blk_col += stepc) {
td->read_coeffs_tx_intra_block_visit(cm, xd, r, plane, blk_row,
blk_col, tx_size);
td->predict_and_recon_intra_block_visit(cm, xd, r, plane, blk_row,
blk_col, tx_size);
set_cb_buffer_offsets(xd, tx_size, plane);
}
}
}
}
}
} else {
td->predict_inter_block_visit(cm, xd, bsize);
// Reconstruction
if (!mbmi->skip) {
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;
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];
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 = 0; plane < num_planes; ++plane) {
const struct macroblockd_plane *const pd = &xd->plane[plane];
if (plane && !mbmi->chroma_ref_info.is_chroma_ref) continue;
const BLOCK_SIZE bsize_base =
plane ? mbmi->chroma_ref_info.bsize_base : bsize;
const BLOCK_SIZE plane_bsize = get_plane_block_size(
bsize_base, pd->subsampling_x, pd->subsampling_y);
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];
const int step =
tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
const int row_plane = row >> pd->subsampling_y;
const int col_plane = col >> pd->subsampling_x;
int unit_width, unit_height;
av1_get_unit_width_height_coeff(xd, plane, plane_bsize, row_plane,
col_plane, &unit_width,
&unit_height);
int block = 0;
for (int blk_row = row_plane; blk_row < unit_height;
blk_row += bh_var_tx) {
for (int blk_col = col_plane; blk_col < unit_width;
blk_col += bw_var_tx) {
decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize,
blk_row, blk_col, block, max_tx_size,
&eobtotal);
block += step;
}
}
}
}
}
} else {
av1_init_txk_skip_array(cm, mbmi, mi_row, mi_col, bsize, 1,
cm->fDecTxSkipLog);
}
td->cfl_store_inter_block_visit(cm, xd);
}
#if CONFIG_INTRA_ENTROPY && !CONFIG_USE_SMALL_MODEL
if (frame_is_intra_only(cm)) {
av1_get_gradient_hist(xd, mbmi, bsize);
av1_get_recon_var(xd, mbmi, bsize);
}
#endif // CONFIG_INTRA_ENTROPY
av1_visit_palette(pbi, xd, r, set_color_index_map_offset);
av1_mark_block_as_coded(xd, mi_row, mi_col, bsize, cm->seq_params.sb_size);
}
static 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 void read_tx_partition(MACROBLOCKD *xd, MB_MODE_INFO *mbmi,
TX_SIZE max_tx_size, int blk_row, int blk_col,
aom_reader *r) {
const int bsize = mbmi->sb_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;
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;
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row,
mbmi->sb_type, max_tx_size);
const int is_rect = is_rect_tx(max_tx_size);
const TX_PARTITION_TYPE partition =
aom_read_symbol(r, ec_ctx->txfm_partition_cdf[is_rect][ctx],
TX_PARTITION_TYPES, ACCT_STR);
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 = av1_get_txb_size_index(bsize, blk_row, blk_col);
mbmi->partition_type[index] = partition;
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);
}
static TX_SIZE read_tx_partition_intra(MACROBLOCKD *xd, aom_reader *r,
TX_SIZE max_tx_size) {
const int ctx = get_tx_size_context(xd);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
const int is_rect = is_rect_tx(max_tx_size);
const TX_PARTITION_TYPE partition = aom_read_symbol(
r, ec_ctx->tx_size_cdf[is_rect][ctx], TX_PARTITION_TYPES_INTRA, ACCT_STR);
TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 };
get_tx_partition_sizes(partition, max_tx_size, sub_txs);
return sub_txs[0];
}
#else
static 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;
const BLOCK_SIZE bsize = mbmi->sb_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, 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(MACROBLOCKD *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;
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(AV1_COMMON *cm, MACROBLOCKD *xd, int is_inter,
int allow_select_inter, aom_reader *r) {
const TX_MODE tx_mode = cm->tx_mode;
const BLOCK_SIZE bsize = xd->mi[0]->sb_type;
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
const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
return read_tx_partition_intra(xd, r, max_tx_size);
#else
return read_selected_tx_size(xd, r);
#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 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) {
MACROBLOCKD *const xd = &td->xd;
decode_mbmi_block(pbi, xd, 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) || is_intrabc_block(mbmi);
if (cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) &&
!mbmi->skip && 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 = block_size_wide[bsize] >> tx_size_wide_log2[0];
const int height = block_size_high[bsize] >> tx_size_high_log2[0];
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(cm, xd, inter_block_tx, !mbmi->skip, r);
#if CONFIG_NN_RECON
if (av1_is_block_nn_recon_eligible(cm, mbmi, mbmi->tx_size)) {
mbmi->use_nn_recon = aom_read_symbol(r, xd->tile_ctx->use_nn_recon_cdf,
CDF_SIZE(2), ACCT_STR);
}
#endif
if (inter_block_tx)
memset(mbmi->inter_tx_size, mbmi->tx_size, sizeof(mbmi->inter_tx_size));
set_txfm_ctxs(mbmi->tx_size, xd->n4_w, xd->n4_h,
mbmi->skip && is_inter_block(mbmi), 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++) {
#if CONFIG_DSPL_RESIDUAL
for (int j = 0; j < num_planes; ++j) {
// Similar to av1_init_macroblockd(), we need to build dequantizers for
// each of the downsampling options. By design, the dequantizers only
// differ for the Y plane. For U and V planes, we use the original
// dequantizers for both options.
for (DSPL_TYPE dspl_type = DSPL_NONE; dspl_type < DSPL_END;
++dspl_type) {
#if CONFIG_EXTQUANT
int current_qindex = av1_get_qindex(&cm->seg, i, xd->current_qindex,
cm->seq_params.bit_depth);
#else
int current_qindex = av1_get_qindex(&cm->seg, i, xd->current_qindex);
#endif
if (j == 0) {
int dspl_delta_q[DSPL_END];
av1_get_dspl_delta_q(current_qindex, dspl_delta_q);
current_qindex =
AOMMAX(0, current_qindex + dspl_delta_q[dspl_type]);
}
const int dc_delta_q =
j == 0 ? cm->y_dc_delta_q
: (j == 1 ? cm->u_dc_delta_q : cm->v_dc_delta_q);
const int ac_delta_q =
j == 0 ? 0 : (j == 1 ? cm->u_ac_delta_q : cm->v_ac_delta_q);
xd->plane[j].seg_dequant_QTX[dspl_type][i][0] =
av1_dc_quant_QTX(current_qindex, dc_delta_q,
#if CONFIG_EXTQUANT
j == 0 ? cm->seq_params.base_y_dc_delta_q
: cm->seq_params.base_uv_dc_delta_q,
#endif
cm->seq_params.bit_depth);
xd->plane[j].seg_dequant_QTX[dspl_type][i][1] = av1_ac_quant_QTX(
current_qindex, ac_delta_q, cm->seq_params.bit_depth);
}
}
#else
#if CONFIG_EXTQUANT
const int current_qindex = av1_get_qindex(&cm->seg, i, xd->current_qindex,
cm->seq_params.bit_depth);
#else
const int current_qindex =
av1_get_qindex(&cm->seg, i, xd->current_qindex);
#endif
for (int j = 0; j < num_planes; ++j) {
const int dc_delta_q =
j == 0 ? cm->y_dc_delta_q
: (j == 1 ? cm->u_dc_delta_q : cm->v_dc_delta_q);
const int ac_delta_q =
j == 0 ? 0 : (j == 1 ? cm->u_ac_delta_q : cm->v_ac_delta_q);
xd->plane[j].seg_dequant_QTX[i][0] =
av1_dc_quant_QTX(current_qindex, dc_delta_q,
#if CONFIG_EXTQUANT
j == 0 ? cm->seq_params.base_y_dc_delta_q
: cm->seq_params.base_uv_dc_delta_q,
#endif
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);
}
#endif // CONFIG_DSPL_RESIDUAL
}
}
if (mbmi->skip) av1_reset_skip_context(xd, bsize, num_planes);
decode_token_recon_block(pbi, td, mi_row, mi_col, r, bsize);
av1_mark_block_as_coded(xd, mi_row, mi_col, bsize, cm->seq_params.sb_size);
}
static 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;
MACROBLOCKD *const xd = &td->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 * cm->mi_stride + mi_col;
const TileInfo *const tile = &xd->tile;
xd->mi = cm->mi_grid_base + offset;
xd->cfl.mi_row = mi_row;
xd->cfl.mi_col = mi_col;
set_chroma_ref_info(mi_row, mi_col, index, bsize, &xd->mi[0]->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, bsize, num_planes, &xd->mi[0]->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, cm->mi_rows, cm->mi_cols,
&xd->mi[0]->chroma_ref_info);
av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
num_planes, &xd->mi[0]->chroma_ref_info);
}
static 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, mi_row, mi_col, r, bsize);
}
static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col,
aom_reader *r, int has_rows, int has_cols,
BLOCK_SIZE bsize) {
if (!is_partition_point(bsize)) return PARTITION_NONE;
const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
#if CONFIG_EXT_RECUR_PARTITIONS
if (is_square_block(bsize)) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS && !KEEP_PARTITION_SPLIT
if (!has_rows && has_cols) return PARTITION_HORZ;
if (has_rows && !has_cols) return PARTITION_VERT;
assert(ctx >= 0);
if (has_rows && has_cols) {
aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[ctx];
return (PARTITION_TYPE)aom_read_symbol(
r, partition_cdf, partition_cdf_length(bsize), ACCT_STR);
} else { // !has_rows && !has_cols
aom_cdf_prob cdf[2] = { 16384, AOM_ICDF(CDF_PROB_TOP) };
return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_VERT
: PARTITION_HORZ;
}
#else // CONFIG_EXT_RECUR_PARTITIONS && !KEEP_PARTITION_SPLIT
if (!has_rows && !has_cols) return PARTITION_SPLIT;
assert(ctx >= 0);
aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[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 && !KEEP_PARTITION_SPLIT
#if CONFIG_EXT_RECUR_PARTITIONS
} else {
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);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
#if CONFIG_FLEX_MVRES
static MvSubpelPrecision av1_read_sb_mv_precision(AV1_COMMON *const cm,
MACROBLOCKD *const xd,
aom_reader *r) {
const MvSubpelPrecision max_precision = cm->fr_mv_precision;
const int down = aom_read_symbol(
r,
xd->tile_ctx
->sb_mv_precision_cdf[max_precision - MV_SUBPEL_HALF_PRECISION],
cm->fr_mv_precision + 1, ACCT_STR);
return (MvSubpelPrecision)(max_precision - down);
}
#endif // CONFIG_FLEX_MVRES
// Read the superblock level parameters
static void read_sb_info(SB_INFO *sbi, AV1Decoder *const pbi,
ThreadData *const td, aom_reader *reader) {
AV1_COMMON *const cm = &pbi->common;
if (!frame_is_intra_only(cm)) {
sbi->sb_mv_precision = cm->fr_mv_precision;
#if CONFIG_FLEX_MVRES
if (cm->use_sb_mv_precision) {
MACROBLOCKD *const xd = &td->xd;
sbi->sb_mv_precision = av1_read_sb_mv_precision(cm, xd, reader);
}
#else
(void)reader;
(void)td;
#endif // CONFIG_FLEX_MVRES
}
}
#if CONFIG_CNN_CRLC_GUIDED
static void read_filter_crlc(AV1_COMMON *const cm, MACROBLOCKD *xd, int QP,
CRLCInfo *ci, int i, aom_reader *rb) {
if (i == 0) {
QP /= 4;
int A0_min, A1_min, channels = 2;
if (QP < 17) {
A0_min = -7;
A1_min = -5;
} else if (17 <= QP && QP < 27) {
A0_min = -12;
A1_min = -7;
} else if (27 <= QP && QP < 31) {
A0_min = -12;
A1_min = -3;
} else if (31 <= QP && QP < 37) {
A0_min = -13;
A1_min = -10;
} else if (37 <= QP && QP < 47) {
A0_min = -13;
A1_min = -10;
} else if (47 <= QP && QP < 57) {
A0_min = -13;
A1_min = -10;
} else {
A0_min = -15;
A1_min = -6;
}
if (cm->use_guided_level == 0) {
ci->crlc_unit_size = 256;
} else {
ci->crlc_unit_size = 128;
}
int height = (&cm->cur_frame->buf)->y_crop_height;
int width = (&cm->cur_frame->buf)->y_crop_width;
int cols = (int)(ceil((float)height / (ci->crlc_unit_size)));
int rows = (int)(ceil((float)width / ci->crlc_unit_size));
ci->num_crlc_unit = cols * rows;
ci->units_per_tile = cols * rows;
int p = 0;
av1_alloc_CRLC_struct(cm, &cm->crlc_info[p], p > 0);
int ref_0 = 8;
int ref_1 = 8;
for (int i = 0; i < ci->num_crlc_unit; i++) {
ci->unit_info[i].xqd[0] =
aom_read_primitive_refsubexpfin(rb, 16, 1, ref_0, ACCT_STR) + A0_min;
ci->unit_info[i].xqd[1] =
aom_read_primitive_refsubexpfin(rb, 16, 1, ref_1, ACCT_STR) + A1_min;
ref_0 = ci->unit_info[i].xqd[0] - A0_min;
ref_1 = ci->unit_info[i].xqd[1] - A1_min;
}
}
}
#endif // CONFIG_CNN_CRLC_GUIDED
// TODO(slavarnway): eliminate bsize and subsize in future commits
static void decode_partition(AV1Decoder *const pbi, ThreadData *const td,
int mi_row, int mi_col, aom_reader *reader,
BLOCK_SIZE bsize, SB_INFO *sbi,
PARTITION_TREE *ptree, int parse_decode_flag) {
assert(bsize < BLOCK_SIZES_ALL);
AV1_COMMON *const cm = &pbi->common;
MACROBLOCKD *const xd = &td->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;
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
PARTITION_TYPE partition;
const int has_rows = (mi_row + hbs_h) < cm->mi_rows;
const int has_cols = (mi_col + hbs_w) < cm->mi_cols;
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return;
if (bsize == cm->seq_params.sb_size && parse_decode_flag & 1) {
read_sb_info(sbi, pbi, td, reader);
}
// 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 };
assert(ptree);
if (parse_decode_flag & 1) {
#if CONFIG_CNN_CRLC_GUIDED
cm->use_full_crlc = 0;
#endif // CONFIG_CNN_CRLC_GUIDED
const int num_planes = av1_num_planes(cm);
for (int plane = 0; plane < num_planes; ++plane) {
#if CONFIG_CNN_RESTORATION && !CONFIG_LOOP_RESTORE_CNN
if ((plane == 0 && cm->use_cnn_y) || (plane > 0 && cm->use_cnn_uv))
continue;
#endif // CONFIG_CNN_RESTORATION && !CONFIG_LOOP_RESTORE_CNN
int rcol0, rcol1, rrow0, rrow1;
if (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);
}
}
}
}
#if CONFIG_CNN_CRLC_GUIDED
int rcol0, rcol1, rrow0, rrow1;
if (av1_CRLC_corners_in_sb(cm, 0, mi_row, mi_col, bsize, &rcol0, &rcol1,
&rrow0, &rrow1) &&
(mi_row == 0) && (mi_col == 0)) {
const int rstride = cm->crlc_info[0].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;
crlc_guided_read_coeffs(cm, xd, reader, 0, runit_idx);
}
}
}
#endif // CONFIG_CNN_CRLC_GUIDED
partition =
read_partition(xd, mi_row, mi_col, reader, has_rows, has_cols, bsize);
ptree->partition = partition;
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);
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);
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]);
}
#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)
#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)
#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_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_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;
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;
#if CONFIG_EXT_RECUR_PARTITIONS
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_rows) break;
DEC_PARTITION(this_mi_row, mi_col, bsize3, 1);
this_mi_row += 2 * qbs_h;
if (this_mi_row >= cm->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_cols) break;
DEC_PARTITION(mi_row, this_mi_col, bsize3, 1);
this_mi_col += 2 * qbs_w;
if (this_mi_col >= cm->mi_cols) break;
DEC_PARTITION(mi_row, this_mi_col, subsize, 2);
break;
}
#else
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(mi_row, mi_col, bsize2, 0);
DEC_BLOCK(mi_row + hbs_h, mi_col, bsize2, 1);
DEC_BLOCK(mi_row, mi_col + hbs_w, subsize, 2);
break;
case PARTITION_VERT_B:
DEC_BLOCK(mi_row, mi_col, subsize, 0);
DEC_BLOCK(mi_row, mi_col + hbs_w, bsize2, 1);
DEC_BLOCK(mi_row + hbs_h, mi_col + hbs_w, bsize2, 2);
break;
case PARTITION_HORZ_4:
for (int i = 0; i < 4; ++i) {
int this_mi_row = mi_row + i * qbs_h;
if (i > 0 && this_mi_row >= cm->mi_rows) break;
DEC_BLOCK(this_mi_row, mi_col, subsize, i);
}
break;
case PARTITION_VERT_4:
for (int i = 0; i < 4; ++i) {
int this_mi_col = mi_col + i * qbs_w;
if (i > 0 && this_mi_col >= cm->mi_cols) break;
DEC_BLOCK(mi_row, this_mi_col, subsize, i);
}
break;
#endif // CONFIG_EXT_RECUR_PARTITIONS
default: assert(0 && "Invalid partition type");
}
#undef DEC_PARTITION
#undef DEC_BLOCK
#undef DEC_BLOCK_EPT_ARG
#undef DEC_BLOCK_STX_ARG
if (parse_decode_flag & 1)
update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
}
static void setup_bool_decoder(const uint8_t *data, const uint8_t *data_end,
const size_t read_size,
struct aom_internal_error_info *error_info,
aom_reader *r, uint8_t allow_update_cdf) {
// Validate the calculated partition length. If the buffer
// described by the partition can't be fully read, then restrict
// it to the portion that can be (for EC mode) or throw an error.
if (!read_is_valid(data, read_size, data_end))
aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME,
"Truncated packet or corrupt tile length");
if (aom_reader_init(r, data, read_size))
aom_internal_error(error_info, AOM_CODEC_MEM_ERROR,
"Failed to allocate bool decoder %d", 1);
r->allow_update_cdf = allow_update_cdf;
}
static void setup_segmentation(AV1_COMMON *const cm,
struct aom_read_bit_buffer *rb) {
struct segmentation *const seg = &cm->seg;
seg->update_map = 0;
seg->update_data = 0;
seg->temporal_update = 0;
seg->enabled = aom_rb_read_bit(rb);
if (!seg->enabled) {
if (cm->cur_frame->seg_map)
memset(cm->cur_frame->seg_map, 0, (cm->mi_rows * cm->mi_cols));
memset(seg, 0, sizeof(*seg));
segfeatures_copy(&cm->cur_frame->seg, seg);
return;
}
if (cm->seg.enabled && cm->prev_frame &&
(cm->mi_rows == cm->prev_frame->mi_rows) &&
(cm->mi_cols == cm->prev_frame->mi_cols)) {
cm->last_frame_seg_map = cm->prev_frame->seg_map;
} else {
cm->last_frame_seg_map = NULL;
}
// Read update flags
if (cm->primary_ref_frame == PRIMARY_REF_NONE) {
// These frames can't use previous frames, so must signal map + features
seg->update_map = 1;
seg->temporal_update = 0;
seg->update_data = 1;
} else {
seg->update_map = aom_rb_read_bit(rb);
if (seg->update_map) {
seg->temporal_update = aom_rb_read_bit(rb);
} else {
seg->temporal_update = 0;
}
seg->update_data = aom_rb_read_bit(rb);
}
// Segmentation data update
if (seg->update_data) {
av1_clearall_segfeatures(seg);
for (int i = 0; i < MAX_SEGMENTS; i++) {
for (int j = 0; j < SEG_LVL_MAX; j++) {
int data = 0;
const int feature_enabled = aom_rb_read_bit(rb);
if (feature_enabled) {
av1_enable_segfeature(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);
if (av1_is_segfeature_signed(j)) {
data = aom_rb_read_inv_signed_literal(rb, ubits);
} else {
data = aom_rb_read_literal(rb, ubits);
}
data = clamp(data, data_min, data_max);
}
av1_set_segdata(seg, i, j, data);
}
}
av1_calculate_segdata(seg);
} else if (cm->prev_frame) {
segfeatures_copy(seg, &cm->prev_frame->seg);
}
segfeatures_copy(&cm->cur_frame->seg, seg);
}
#if CONFIG_CNN_RESTORATION || CONFIG_LOOP_RESTORE_CNN
static void decode_cnn(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
if (av1_use_cnn(cm)) {
cm->use_cnn_y = aom_rb_read_bit(rb);
cm->use_cnn_uv = aom_rb_read_bit(rb);
#if CONFIG_CNN_CRLC_GUIDED
cm->use_guided_level = aom_rb_read_bit(rb);
#endif // CONFIG_CNN_CRLC_GUIDED
} else {
cm->use_cnn_y = 0;
cm->use_cnn_uv = 0;
#if CONFIG_CNN_CRLC_GUIDED
cm->use_guided_level = 0;
#endif // CONFIG_CNN_CRLC_GUIDED
}
}
#endif // CONFIG_CNN_RESTORATION || CONFIG_LOOP_RESTORE_CNN
#if CONFIG_MFQE_RESTORATION
static void decode_mfqe(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
cm->use_mfqe = aom_rb_read_bit(rb);
}
#endif // CONFIG_MFQE_RESTORATION
static void decode_restoration_mode(AV1_COMMON *cm,
struct aom_read_bit_buffer *rb) {
assert(!cm->all_lossless);
const int num_planes = av1_num_planes(cm);
if (cm->allow_intrabc) return;
int all_none = 1, chroma_none = 1;
for (int p = 0; p < num_planes; ++p) {
#if CONFIG_LOOP_RESTORE_CNN
const bool use_cnn_plane =
(p == AOM_PLANE_Y) ? cm->use_cnn_y : cm->use_cnn_uv;
#endif // CONFIG_LOOP_RESTORE_CNN
RestorationInfo *rsi = &cm->rst_info[p];
#if CONFIG_CNN_RESTORATION
if ((p == 0 && cm->use_cnn_y) || (p > 0 && cm->use_cnn_uv)) {
rsi->frame_restoration_type = RESTORE_NONE;
continue;
}
#endif // CONFIG_CNN_RESTORATION
if (aom_rb_read_bit(rb)) {
if (aom_rb_read_bit(rb)) {
#if CONFIG_LOOP_RESTORE_CNN
rsi->frame_restoration_type =
use_cnn_plane ? RESTORE_CNN : RESTORE_SGRPROJ;
#else
rsi->frame_restoration_type = RESTORE_SGRPROJ;
#endif // CONFIG_LOOP_RESTORE_CNN
} else {
rsi->frame_restoration_type = RESTORE_WIENER;
}
} else {
if (aom_rb_read_bit(rb)) {
rsi->frame_restoration_type = RESTORE_SWITCHABLE;
} else {
#if CONFIG_LOOP_RESTORE_CNN
rsi->frame_restoration_type = use_cnn_plane && aom_rb_read_bit(rb)
? RESTORE_SGRPROJ
: RESTORE_NONE;
#elif CONFIG_WIENER_NONSEP
rsi->frame_restoration_type =
aom_rb_read_bit(rb) ? RESTORE_WIENER_NONSEP : RESTORE_NONE;
#else
rsi->frame_restoration_type = RESTORE_NONE;
#endif // CONFIG_LOOP_RESTORE_CNN
}
}
if (rsi->frame_restoration_type != RESTORE_NONE) {
all_none = 0;
chroma_none &= p == 0;
}
}
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;
for (int p = 0; p < num_planes; ++p)
cm->rst_info[p].restoration_unit_size = sb_size;
// TODO(urvang): Could save some bits by not reading restoration unit size
// for Y plane, when use_cnn_plane = 1.
RestorationInfo *rsi = &cm->rst_info[0];
if (sb_size == 64) {
rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
}
if (rsi->restoration_unit_size > 64) {
rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
}
} else {
const int size = RESTORATION_UNITSIZE_MAX;
for (int p = 0; p < num_planes; ++p)
cm->rst_info[p].restoration_unit_size = size;
}
if (num_planes > 1) {
int s = AOMMIN(cm->seq_params.subsampling_x, cm->seq_params.subsampling_y);
if (s && !chroma_none) {
cm->rst_info[1].restoration_unit_size =
cm->rst_info[0].restoration_unit_size >> (aom_rb_read_bit(rb) * s);
} else {
cm->rst_info[1].restoration_unit_size =
cm->rst_info[0].restoration_unit_size;
}
cm->rst_info[2].restoration_unit_size =
cm->rst_info[1].restoration_unit_size;
}
}
static void read_wiener_filter(MACROBLOCKD *xd, int wiener_win,
WienerInfo *wiener_info,
WienerInfo *ref_wiener_info, aom_reader *rb) {
#if CONFIG_RST_MERGECOEFFS
const int equal =
aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2, ACCT_STR);
if (equal) {
memcpy(wiener_info, ref_wiener_info, sizeof(*wiener_info));
return;
}
#else
(void)xd;
#endif // CONFIG_RST_MERGECOEFFS
memset(wiener_info->vfilter, 0, sizeof(wiener_info->vfilter));
memset(wiener_info->hfilter, 0, sizeof(wiener_info->hfilter));
if (wiener_win == WIENER_WIN)
wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
WIENER_FILT_TAP0_SUBEXP_K,
ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
WIENER_FILT_TAP0_MINV;
else
wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] = 0;
wiener_info->vfilter[1] = wiener_info->vfilter[WIENER_WIN - 2] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
WIENER_FILT_TAP1_SUBEXP_K,
ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
WIENER_FILT_TAP1_MINV;
wiener_info->vfilter[2] = wiener_info->vfilter[WIENER_WIN - 3] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
WIENER_FILT_TAP2_SUBEXP_K,
ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
WIENER_FILT_TAP2_MINV;
// The central element has an implicit +WIENER_FILT_STEP
wiener_info->vfilter[WIENER_HALFWIN] =
-2 * (wiener_info->vfilter[0] + wiener_info->vfilter[1] +
wiener_info->vfilter[2]);
if (wiener_win == WIENER_WIN)
wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1,
WIENER_FILT_TAP0_SUBEXP_K,
ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) +
WIENER_FILT_TAP0_MINV;
else
wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] = 0;
wiener_info->hfilter[1] = wiener_info->hfilter[WIENER_WIN - 2] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1,
WIENER_FILT_TAP1_SUBEXP_K,
ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) +
WIENER_FILT_TAP1_MINV;
wiener_info->hfilter[2] = wiener_info->hfilter[WIENER_WIN - 3] =
aom_read_primitive_refsubexpfin(
rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1,
WIENER_FILT_TAP2_SUBEXP_K,
ref_wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) +
WIENER_FILT_TAP2_MINV;
// The central element has an implicit +WIENER_FILT_STEP
wiener_info->hfilter[WIENER_HALFWIN] =
-2 * (wiener_info->hfilter[0] + wiener_info->hfilter[1] +
wiener_info->hfilter[2]);
memcpy(ref_wiener_info, wiener_info, sizeof(*wiener_info));
}
static void read_sgrproj_filter(MACROBLOCKD *xd, SgrprojInfo *sgrproj_info,
SgrprojInfo *ref_sgrproj_info, aom_reader *rb) {
#if CONFIG_RST_MERGECOEFFS
const int equal =
aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2, ACCT_STR);
if (equal) {
memcpy(sgrproj_info, ref_sgrproj_info, sizeof(*sgrproj_info));
return;
}
#else
(void)xd;
#endif // CONFIG_RST_MERGECOEFFS
sgrproj_info->ep = aom_read_literal(rb, SGRPROJ_PARAMS_BITS, ACCT_STR);
const sgr_params_type *params = &av1_sgr_params[sgrproj_info->ep];
if (params->r[0] == 0) {
sgrproj_info->xqd[0] = 0;
sgrproj_info->xqd[1] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
SGRPROJ_PRJ_MIN1;
} else if (params->r[1] == 0) {
sgrproj_info->xqd[0] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
SGRPROJ_PRJ_MIN0;
sgrproj_info->xqd[1] = clamp((1 << SGRPROJ_PRJ_BITS) - sgrproj_info->xqd[0],
SGRPROJ_PRJ_MIN1, SGRPROJ_PRJ_MAX1);
} else {
sgrproj_info->xqd[0] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K,
ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) +
SGRPROJ_PRJ_MIN0;
sgrproj_info->xqd[1] =
aom_read_primitive_refsubexpfin(
rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K,
ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) +
SGRPROJ_PRJ_MIN1;
}
memcpy(ref_sgrproj_info, sgrproj_info, sizeof(*sgrproj_info));
}
#if CONFIG_WIENER_NONSEP
static void read_wiener_nsfilter(MACROBLOCKD *xd, int is_uv,
WienerNonsepInfo *wienerns_info,
WienerNonsepInfo *ref_wienerns_info,
aom_reader *rb) {
#if CONFIG_RST_MERGECOEFFS
const int equal =
aom_read_symbol(rb, xd->tile_ctx->merged_param_cdf, 2, ACCT_STR);
if (equal) {
memcpy(wienerns_info, ref_wienerns_info, sizeof(*wienerns_info));
return;
}
#else
(void)xd;
#endif // CONFIG_RST_MERGECOEFFS
int beg_feat = is_uv ? wienerns_y : 0;
int end_feat = is_uv ? wienerns_y + wienerns_uv : wienerns_y;
const int(*wienerns_coeffs)[3] = is_uv ? wienerns_coeff_uv : wienerns_coeff_y;
set_default_wiener_nonsep(wienerns_info);
for (int i = beg_feat; i < end_feat; ++i) {
wienerns_info->nsfilter[i] += aom_read_primitive_refsubexpfin(
rb, (1 << wienerns_coeffs[i - beg_feat][WIENERNS_BIT_ID]),
wienerns_coeffs[i - beg_feat][WIENERNS_SUBEXP_K_ID],
ref_wienerns_info->nsfilter[i] -
wienerns_coeffs[i - beg_feat][WIENERNS_MIN_ID],
ACCT_STR);
}
memcpy(ref_wienerns_info, wienerns_info, sizeof(*wienerns_info));
}
#endif // CONFIG_WIENER_NONSEP
static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm,
MACROBLOCKD *xd,
aom_reader *const r, int plane,
int runit_idx) {
const RestorationInfo *rsi = &cm->rst_info[plane];
RestorationUnitInfo *rui = &rsi->unit_info[runit_idx];
assert(rsi->frame_restoration_type != RESTORE_NONE);
assert(!cm->all_lossless);
const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN;
#if CONFIG_WIENER_NONSEP
const int is_uv = (plane > 0);
#endif // CONFIG_WIENER_NONSEP
WienerInfo *wiener_info = xd->wiener_info + plane;
SgrprojInfo *sgrproj_info = xd->sgrproj_info + plane;
#if CONFIG_WIENER_NONSEP
WienerNonsepInfo *wiener_nonsep_info = xd->wiener_nonsep_info + plane;
#endif // CONFIG_WIENER_NONSEP
if (rsi->frame_restoration_type == RESTORE_SWITCHABLE) {
#if CONFIG_LOOP_RESTORE_CNN
const bool use_cnn_plane =
(plane == AOM_PLANE_Y) ? cm->use_cnn_y : cm->use_cnn_uv;
const int switchable_types =
use_cnn_plane ? RESTORE_SWITCHABLE_TYPES : RESTORE_SWITCHABLE_TYPES - 1;
rui->restoration_type =
aom_read_symbol(r, xd->tile_ctx->switchable_restore_cdf[use_cnn_plane],
switchable_types, ACCT_STR);
#else
rui->restoration_type =
aom_read_symbol(r, xd->tile_ctx->switchable_restore_cdf,
RESTORE_SWITCHABLE_TYPES, ACCT_STR);
#endif // CONFIG_LOOP_RESTORE_CNN
switch (rui->restoration_type) {
case RESTORE_WIENER:
read_wiener_filter(xd, wiener_win, &rui->wiener_info, wiener_info, r);
break;
case RESTORE_SGRPROJ:
read_sgrproj_filter(xd, &rui->sgrproj_info, sgrproj_info, r);
break;
#if CONFIG_LOOP_RESTORE_CNN
case RESTORE_CNN: break;
#endif // CONFIG_LOOP_RESTORE_CNN
#if CONFIG_WIENER_NONSEP
case RESTORE_WIENER_NONSEP:
read_wiener_nsfilter(xd, is_uv, &rui->wiener_nonsep_info,
wiener_nonsep_info, r);
break;
#endif // CONFIG_WIENER_NONSEP
default: assert(rui->restoration_type == RESTORE_NONE); break;
}
} else if (rsi->frame_restoration_type == RESTORE_WIENER) {
if (aom_read_symbol(r, xd->tile_ctx->wiener_restore_cdf, 2, ACCT_STR)) {
rui->restoration_type = RESTORE_WIENER;
read_wiener_filter(xd, wiener_win, &rui->wiener_info, wiener_info, r);
} else {
rui->restoration_type = RESTORE_NONE;
}
} else if (rsi->frame_restoration_type == RESTORE_SGRPROJ) {
if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2, ACCT_STR)) {
rui->restoration_type = RESTORE_SGRPROJ;
read_sgrproj_filter(xd, &rui->sgrproj_info, sgrproj_info, r);
} else {
rui->restoration_type = RESTORE_NONE;
}
}
#if CONFIG_LOOP_RESTORE_CNN
else if (rsi->frame_restoration_type == RESTORE_CNN) {
if (aom_read_symbol(r, xd->tile_ctx->cnn_restore_cdf, 2, ACCT_STR)) {
rui->restoration_type = RESTORE_CNN;
} else {
rui->restoration_type = RESTORE_NONE;
}
}
#endif // CONFIG_LOOP_RESTORE_CNN
#if CONFIG_WIENER_NONSEP
else if (rsi->frame_restoration_type == RESTORE_WIENER_NONSEP) {
if (aom_read_symbol(r, xd->tile_ctx->wiener_nonsep_restore_cdf, 2,
ACCT_STR)) {
rui->restoration_type = RESTORE_WIENER_NONSEP;
read_wiener_nsfilter(xd, is_uv, &rui->wiener_nonsep_info,
wiener_nonsep_info, r);
} else {
rui->restoration_type = RESTORE_NONE;
}
}
#endif // CONFIG_WIENER_NONSEP
}
#if CONFIG_CNN_CRLC_GUIDED
static void crlc_guided_read_coeffs(AV1_COMMON *const cm, MACROBLOCKD *xd,
aom_reader *const r, int plane,
int runit_idx) {
CRLCInfo *const ci = &cm->crlc_info[0];
read_filter_crlc(cm, xd, cm->base_qindex, ci, plane, r);
}
#endif // CONFIG_CNN_CRLC_GUIDED
static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
const int num_planes = av1_num_planes(cm);
struct loopfilter *lf = &cm->lf;
if (cm->allow_intrabc || cm->coded_lossless) {
// write default deltas to frame buffer
av1_set_default_ref_deltas(cm->cur_frame->ref_deltas);
av1_set_default_mode_deltas(cm->cur_frame->mode_deltas);
return;
}
assert(!cm->coded_lossless);
if (cm->prev_frame) {
// write deltas to frame buffer
memcpy(lf->ref_deltas, cm->prev_frame->ref_deltas, REF_FRAMES);
memcpy(lf->mode_deltas, cm->prev_frame->mode_deltas, MAX_MODE_LF_DELTAS);
} else {
av1_set_default_ref_deltas(lf->ref_deltas);
av1_set_default_mode_deltas(lf->mode_deltas);
}
lf->filter_level[0] = aom_rb_read_literal(rb, 6);
lf->filter_level[1] = aom_rb_read_literal(rb, 6);
if (num_planes > 1) {
if (lf->filter_level[0] || lf->filter_level[1]) {
lf->filter_level_u = aom_rb_read_literal(rb, 6);
lf->filter_level_v = aom_rb_read_literal(rb, 6);
}
}
lf->sharpness_level = aom_rb_read_literal(rb, 3);
// Read in loop filter deltas applied at the MB level based on mode or ref
// frame.
lf->mode_ref_delta_update = 0;
lf->mode_ref_delta_enabled = aom_rb_read_bit(rb);
if (lf->mode_ref_delta_enabled) {
lf->mode_ref_delta_update = aom_rb_read_bit(rb);
if (lf->mode_ref_delta_update) {
for (int i = 0; i < REF_FRAMES; i++)
if (aom_rb_read_bit(rb))
lf->ref_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6);
for (int i = 0; i < MAX_MODE_LF_DELTAS; i++)
if (aom_rb_read_bit(rb))
lf->mode_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6);
}
}
// write deltas to frame buffer
memcpy(cm->cur_frame->ref_deltas, lf->ref_deltas, REF_FRAMES);
memcpy(cm->cur_frame->mode_deltas, lf->mode_deltas, MAX_MODE_LF_DELTAS);
}
static void setup_cdef(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
const int num_planes = av1_num_planes(cm);
CdefInfo *const cdef_info = &cm->cdef_info;
if (cm->allow_intrabc) return;
#if CONFIG_CNN_RESTORATION || CONFIG_LOOP_RESTORE_CNN
if (cm->use_cnn_y) {
memset(cm->cdef_info.cdef_strengths, 0,
sizeof(cm->cdef_info.cdef_strengths));
}
if (cm->use_cnn_uv) {
memset(cm->cdef_info.cdef_uv_strengths, 0,
sizeof(cm->cdef_info.cdef_uv_strengths));
}
if (cm->use_cnn_y && cm->use_cnn_uv) {
cm->cdef_info.cdef_bits = 0;
cm->cdef_info.nb_cdef_strengths = 1;
return;
}
#endif // CONFIG_CNN_RESTORATION || CONFIG_LOOP_RESTORE_CNN
cdef_info->cdef_damping = aom_rb_read_literal(rb, 2) + 3;
cdef_info->cdef_bits = aom_rb_read_literal(rb, 2);
cdef_info->nb_cdef_strengths = 1 << cdef_info->cdef_bits;
for (int i = 0; i < cdef_info->nb_cdef_strengths; i++) {
#if CONFIG_CNN_RESTORATION
if (!cm->use_cnn_y)
#endif // CONFIG_CNN_RESTORATION
cdef_info->cdef_strengths[i] =
aom_rb_read_literal(rb, CDEF_STRENGTH_BITS);
#if CONFIG_CNN_RESTORATION
if (!cm->use_cnn_uv)
#endif // CONFIG_CNN_RESTORATION
cdef_info->cdef_uv_strengths[i] =
num_planes > 1 ? aom_rb_read_literal(rb, CDEF_STRENGTH_BITS) : 0;
}
}
static