diff options
Diffstat (limited to 'third_party/aom/av1/decoder')
26 files changed, 5371 insertions, 8853 deletions
diff --git a/third_party/aom/av1/decoder/accounting.c b/third_party/aom/av1/decoder/accounting.c index ba243c9e1f..8d8f3dfdb4 100644 --- a/third_party/aom/av1/decoder/accounting.c +++ b/third_party/aom/av1/decoder/accounting.c @@ -15,7 +15,7 @@ #include <string.h> #include "aom/aom_integer.h" -#include "./accounting.h" +#include "av1/decoder/accounting.h" static int aom_accounting_hash(const char *str) { uint32_t val; @@ -31,7 +31,7 @@ static int aom_accounting_hash(const char *str) { /* Dictionary lookup based on an open-addressing hash table. */ int aom_accounting_dictionary_lookup(Accounting *accounting, const char *str) { int hash; - int len; + size_t len; AccountingDictionary *dictionary; dictionary = &accounting->syms.dictionary; hash = aom_accounting_hash(str); diff --git a/third_party/aom/av1/decoder/accounting.h b/third_party/aom/av1/decoder/accounting.h index 889865b2e7..9099d081be 100644 --- a/third_party/aom/av1/decoder/accounting.h +++ b/third_party/aom/av1/decoder/accounting.h @@ -11,6 +11,7 @@ #ifndef AOM_ACCOUNTING_H_ #define AOM_ACCOUNTING_H_ #include <stdlib.h> +#include "aom/aomdx.h" #ifdef __cplusplus extern "C" { @@ -58,8 +59,6 @@ typedef struct { AccountingDictionary dictionary; } AccountingSymbols; -typedef struct Accounting Accounting; - struct Accounting { AccountingSymbols syms; /** Size allocated for symbols (not all may be used). */ diff --git a/third_party/aom/av1/decoder/decint.h b/third_party/aom/av1/decoder/decint.h deleted file mode 100644 index e887ad5e0d..0000000000 --- a/third_party/aom/av1/decoder/decint.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (c) 2001-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. - */ - -/* clang-format off */ - -#if !defined(_decint_H) -# define _decint_H (1) -# include "av1/common/pvq_state.h" -# include "aom_dsp/bitreader.h" -# include "aom_dsp/entdec.h" - -typedef struct daala_dec_ctx daala_dec_ctx; - -typedef struct daala_dec_ctx od_dec_ctx; - - -struct daala_dec_ctx { - /* Stores context-adaptive CDFs for PVQ. */ - od_state state; - /* AOM entropy decoder. */ - aom_reader *r; - int use_activity_masking; - /* Mode of quantization matrice : FLAT (0) or HVS (1) */ - int qm; -}; - -#endif diff --git a/third_party/aom/av1/decoder/decodeframe.c b/third_party/aom/av1/decoder/decodeframe.c index 9ec3b60eb6..e92c6b28c8 100644 --- a/third_party/aom/av1/decoder/decodeframe.c +++ b/third_party/aom/av1/decoder/decodeframe.c @@ -10,12 +10,12 @@ */ #include <assert.h> -#include <stdlib.h> // qsort() +#include <stddef.h> -#include "./aom_config.h" -#include "./aom_dsp_rtcd.h" -#include "./aom_scale_rtcd.h" -#include "./av1_rtcd.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" @@ -23,19 +23,19 @@ #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 +#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG #include "aom_util/debug_util.h" -#endif // CONFIG_BITSTREAM_DEBUG +#endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG #include "av1/common/alloccommon.h" -#if CONFIG_CDEF #include "av1/common/cdef.h" -#endif +#include "av1/common/cfl.h" #if CONFIG_INSPECTION #include "av1/decoder/inspection.h" #endif @@ -49,78 +49,69 @@ #include "av1/common/quant_common.h" #include "av1/common/reconinter.h" #include "av1/common/reconintra.h" -#if CONFIG_FRAME_SUPERRES #include "av1/common/resize.h" -#endif // CONFIG_FRAME_SUPERRES #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" -#if CONFIG_LV_MAP #include "av1/decoder/decodetxb.h" -#endif #include "av1/decoder/detokenize.h" -#include "av1/decoder/dsubexp.h" -#include "av1/decoder/symbolrate.h" -#if CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION -#include "av1/common/warped_motion.h" -#endif // CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION - -#define MAX_AV1_HEADER_SIZE 80 #define ACCT_STR __func__ -#if CONFIG_PVQ -#include "av1/common/partition.h" -#include "av1/common/pvq.h" -#include "av1/common/scan.h" -#include "av1/decoder/decint.h" -#include "av1/decoder/pvq_decoder.h" -#include "av1/encoder/encodemb.h" -#include "av1/encoder/hybrid_fwd_txfm.h" -#endif +// 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_CFL -#include "av1/common/cfl.h" -#endif +// 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; +} -#if CONFIG_STRIPED_LOOP_RESTORATION && !CONFIG_LOOP_RESTORATION -#error "striped_loop_restoration requires loop_restoration" -#endif +// Use only_chroma = 1 to only set the chroma planes +static void set_planes_to_neutral_grey(AV1_COMMON *const cm, + const YV12_BUFFER_CONFIG *const buf, + int only_chroma) { + const int val = 1 << (cm->bit_depth - 1); + + 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++) { + if (cm->use_highbitdepth) { + // TODO(yaowu): replace this with aom_memset16() for speed + for (int col_idx = 0; col_idx < buf->crop_widths[is_uv]; col_idx++) { + uint16_t *base = CONVERT_TO_SHORTPTR(buf->buffers[plane]); + base[row_idx * buf->strides[is_uv] + col_idx] = val; + } + } else { + memset(&buf->buffers[plane][row_idx * buf->uv_stride], 1 << 7, + buf->crop_widths[is_uv]); + } + } + } +} -#if CONFIG_LOOP_RESTORATION static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane, - int rtile_idx); -#endif - -static struct aom_read_bit_buffer *init_read_bit_buffer( - AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data, - const uint8_t *data_end, uint8_t clear_data[MAX_AV1_HEADER_SIZE]); -static int read_compressed_header(AV1Decoder *pbi, const uint8_t *data, - size_t partition_size); -static size_t read_uncompressed_header(AV1Decoder *pbi, - struct aom_read_bit_buffer *rb); - -static int is_compound_reference_allowed(const AV1_COMMON *cm) { -#if CONFIG_ONE_SIDED_COMPOUND // Normative in decoder - return !frame_is_intra_only(cm); -#else - int i; - if (frame_is_intra_only(cm)) return 0; - for (i = 1; i < INTER_REFS_PER_FRAME; ++i) - if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1]) return 1; - - return 0; -#endif // CONFIG_ONE_SIDED_COMPOUND -} + int runit_idx); static void setup_compound_reference_mode(AV1_COMMON *cm) { -#if CONFIG_EXT_REFS cm->comp_fwd_ref[0] = LAST_FRAME; cm->comp_fwd_ref[1] = LAST2_FRAME; cm->comp_fwd_ref[2] = LAST3_FRAME; @@ -129,1952 +120,1099 @@ static void setup_compound_reference_mode(AV1_COMMON *cm) { cm->comp_bwd_ref[0] = BWDREF_FRAME; cm->comp_bwd_ref[1] = ALTREF2_FRAME; cm->comp_bwd_ref[2] = ALTREF_FRAME; -#else // !CONFIG_EXT_REFS - if (cm->ref_frame_sign_bias[LAST_FRAME] == - cm->ref_frame_sign_bias[GOLDEN_FRAME]) { - cm->comp_fixed_ref = ALTREF_FRAME; - cm->comp_var_ref[0] = LAST_FRAME; - cm->comp_var_ref[1] = GOLDEN_FRAME; - } else if (cm->ref_frame_sign_bias[LAST_FRAME] == - cm->ref_frame_sign_bias[ALTREF_FRAME]) { - cm->comp_fixed_ref = GOLDEN_FRAME; - cm->comp_var_ref[0] = LAST_FRAME; - cm->comp_var_ref[1] = ALTREF_FRAME; - } else { - cm->comp_fixed_ref = LAST_FRAME; - cm->comp_var_ref[0] = GOLDEN_FRAME; - cm->comp_var_ref[1] = ALTREF_FRAME; - } -#endif // CONFIG_EXT_REFS } 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 int decode_unsigned_max(struct aom_read_bit_buffer *rb, int max) { - const int data = aom_rb_read_literal(rb, get_unsigned_bits(max)); - return data > max ? max : data; -} - static TX_MODE read_tx_mode(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { -#if CONFIG_TX64X64 - TX_MODE tx_mode; -#endif - if (cm->all_lossless) return ONLY_4X4; -#if CONFIG_VAR_TX_NO_TX_MODE - (void)rb; - return TX_MODE_SELECT; -#else -#if CONFIG_TX64X64 - tx_mode = aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2); - if (tx_mode == ALLOW_32X32) tx_mode += aom_rb_read_bit(rb); - return tx_mode; -#else - return aom_rb_read_bit(rb) ? TX_MODE_SELECT : aom_rb_read_literal(rb, 2); -#endif // CONFIG_TX64X64 -#endif // CONFIG_VAR_TX_NO_TX_MODE + if (cm->coded_lossless) return ONLY_4X4; + return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST; } -#if !CONFIG_RESTRICT_COMPRESSED_HDR -static void read_inter_mode_probs(FRAME_CONTEXT *fc, aom_reader *r) { - int i; - for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i) - av1_diff_update_prob(r, &fc->newmv_prob[i], ACCT_STR); - for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i) - av1_diff_update_prob(r, &fc->zeromv_prob[i], ACCT_STR); - for (i = 0; i < REFMV_MODE_CONTEXTS; ++i) - av1_diff_update_prob(r, &fc->refmv_prob[i], ACCT_STR); - for (i = 0; i < DRL_MODE_CONTEXTS; ++i) - av1_diff_update_prob(r, &fc->drl_prob[i], ACCT_STR); -} -#endif - static REFERENCE_MODE read_frame_reference_mode( const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { - if (is_compound_reference_allowed(cm)) { -#if CONFIG_REF_ADAPT - return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE; -#else - return aom_rb_read_bit(rb) - ? REFERENCE_MODE_SELECT - : (aom_rb_read_bit(rb) ? COMPOUND_REFERENCE : SINGLE_REFERENCE); -#endif // CONFIG_REF_ADAPT - } else { + if (frame_is_intra_only(cm)) { return SINGLE_REFERENCE; + } else { + return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE; } } -#if !CONFIG_RESTRICT_COMPRESSED_HDR -static void read_frame_reference_mode_probs(AV1_COMMON *cm, aom_reader *r) { - FRAME_CONTEXT *const fc = cm->fc; - int i; - - if (cm->reference_mode == REFERENCE_MODE_SELECT) - for (i = 0; i < COMP_INTER_CONTEXTS; ++i) - av1_diff_update_prob(r, &fc->comp_inter_prob[i], ACCT_STR); - - if (cm->reference_mode != COMPOUND_REFERENCE) { - for (i = 0; i < REF_CONTEXTS; ++i) { - int j; - for (j = 0; j < (SINGLE_REFS - 1); ++j) { - av1_diff_update_prob(r, &fc->single_ref_prob[i][j], ACCT_STR); - } - } - } - - if (cm->reference_mode != SINGLE_REFERENCE) { -#if CONFIG_EXT_COMP_REFS - for (i = 0; i < COMP_REF_TYPE_CONTEXTS; ++i) - av1_diff_update_prob(r, &fc->comp_ref_type_prob[i], ACCT_STR); - - for (i = 0; i < UNI_COMP_REF_CONTEXTS; ++i) { - int j; - for (j = 0; j < (UNIDIR_COMP_REFS - 1); ++j) - av1_diff_update_prob(r, &fc->uni_comp_ref_prob[i][j], ACCT_STR); - } -#endif // CONFIG_EXT_COMP_REFS - - for (i = 0; i < REF_CONTEXTS; ++i) { - int j; -#if CONFIG_EXT_REFS - for (j = 0; j < (FWD_REFS - 1); ++j) - av1_diff_update_prob(r, &fc->comp_ref_prob[i][j], ACCT_STR); - for (j = 0; j < (BWD_REFS - 1); ++j) - av1_diff_update_prob(r, &fc->comp_bwdref_prob[i][j], ACCT_STR); -#else - for (j = 0; j < (COMP_REFS - 1); ++j) - av1_diff_update_prob(r, &fc->comp_ref_prob[i][j], ACCT_STR); -#endif // CONFIG_EXT_REFS - } - } -} - -static void update_mv_probs(aom_prob *p, int n, aom_reader *r) { - int i; - for (i = 0; i < n; ++i) av1_diff_update_prob(r, &p[i], ACCT_STR); -} - -static void read_mv_probs(nmv_context *ctx, int allow_hp, aom_reader *r) { - int i; - if (allow_hp) { - for (i = 0; i < 2; ++i) { - nmv_component *const comp_ctx = &ctx->comps[i]; - update_mv_probs(&comp_ctx->class0_hp, 1, r); - update_mv_probs(&comp_ctx->hp, 1, r); - } - } -} -#endif - static void inverse_transform_block(MACROBLOCKD *xd, int plane, -#if CONFIG_LGT_FROM_PRED - PREDICTION_MODE mode, -#endif const TX_TYPE tx_type, const TX_SIZE tx_size, uint8_t *dst, - int stride, int16_t scan_line, int eob) { + int stride, int reduced_tx_set) { struct macroblockd_plane *const pd = &xd->plane[plane]; tran_low_t *const dqcoeff = pd->dqcoeff; - av1_inverse_transform_block(xd, dqcoeff, -#if CONFIG_LGT_FROM_PRED - mode, -#endif -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - xd->mrc_mask, -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - tx_type, tx_size, dst, stride, eob); + 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; + + memcpy(dqcoeff, pd->dqcoeff_block + xd->cb_offset[plane], + (scan_line + 1) * sizeof(dqcoeff[0])); + 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 int get_block_idx(const MACROBLOCKD *xd, int plane, int row, int col) { - const int bsize = xd->mi[0]->mbmi.sb_type; - const struct macroblockd_plane *pd = &xd->plane[plane]; -#if CONFIG_CHROMA_SUB8X8 - const BLOCK_SIZE plane_bsize = - AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd)); -#elif CONFIG_CB4X4 - const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); -#else - const BLOCK_SIZE plane_bsize = - get_plane_block_size(AOMMAX(BLOCK_8X8, bsize), pd); -#endif - const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); - const TX_SIZE tx_size = av1_get_tx_size(plane, xd); - const uint8_t txh_unit = tx_size_high_unit[tx_size]; - return row * max_blocks_wide + col * txh_unit; -} - -#if CONFIG_PVQ -static int av1_pvq_decode_helper(MACROBLOCKD *xd, tran_low_t *ref_coeff, - tran_low_t *dqcoeff, int16_t *quant, int pli, - int bs, TX_TYPE tx_type, int xdec, - PVQ_SKIP_TYPE ac_dc_coded) { - unsigned int flags; // used for daala's stream analyzer. - int off; - const int is_keyframe = 0; - const int has_dc_skip = 1; - int coeff_shift = 3 - av1_get_tx_scale(bs); - int hbd_downshift = 0; - int rounding_mask; - // DC quantizer for PVQ - int pvq_dc_quant; - int lossless = (quant[0] == 0); - const int blk_size = tx_size_wide[bs]; - int eob = 0; - int i; - od_dec_ctx *dec = &xd->daala_dec; - int use_activity_masking = dec->use_activity_masking; - DECLARE_ALIGNED(16, tran_low_t, dqcoeff_pvq[OD_TXSIZE_MAX * OD_TXSIZE_MAX]); - DECLARE_ALIGNED(16, tran_low_t, ref_coeff_pvq[OD_TXSIZE_MAX * OD_TXSIZE_MAX]); - - od_coeff ref_int32[OD_TXSIZE_MAX * OD_TXSIZE_MAX]; - od_coeff out_int32[OD_TXSIZE_MAX * OD_TXSIZE_MAX]; - - hbd_downshift = xd->bd - 8; - - od_raster_to_coding_order(ref_coeff_pvq, blk_size, tx_type, ref_coeff, - blk_size); - - assert(OD_COEFF_SHIFT >= 4); - if (lossless) - pvq_dc_quant = 1; - else { - if (use_activity_masking) - pvq_dc_quant = - OD_MAXI(1, - (quant[0] << (OD_COEFF_SHIFT - 3) >> hbd_downshift) * - dec->state.pvq_qm_q4[pli][od_qm_get_index(bs, 0)] >> - 4); - else - pvq_dc_quant = - OD_MAXI(1, quant[0] << (OD_COEFF_SHIFT - 3) >> hbd_downshift); - } - - off = od_qm_offset(bs, xdec); - - // copy int16 inputs to int32 - for (i = 0; i < blk_size * blk_size; i++) { - ref_int32[i] = - AOM_SIGNED_SHL(ref_coeff_pvq[i], OD_COEFF_SHIFT - coeff_shift) >> - hbd_downshift; - } - - od_pvq_decode(dec, ref_int32, out_int32, - OD_MAXI(1, quant[1] << (OD_COEFF_SHIFT - 3) >> hbd_downshift), - pli, bs, OD_PVQ_BETA[use_activity_masking][pli][bs], - is_keyframe, &flags, ac_dc_coded, dec->state.qm + off, - dec->state.qm_inv + off); - - if (!has_dc_skip || out_int32[0]) { - out_int32[0] = - has_dc_skip + generic_decode(dec->r, &dec->state.adapt->model_dc[pli], - &dec->state.adapt->ex_dc[pli][bs][0], 2, - "dc:mag"); - if (out_int32[0]) out_int32[0] *= aom_read_bit(dec->r, "dc:sign") ? -1 : 1; - } - out_int32[0] = out_int32[0] * pvq_dc_quant + ref_int32[0]; - - // copy int32 result back to int16 - assert(OD_COEFF_SHIFT > coeff_shift); - rounding_mask = (1 << (OD_COEFF_SHIFT - coeff_shift - 1)) - 1; - for (i = 0; i < blk_size * blk_size; i++) { - out_int32[i] = AOM_SIGNED_SHL(out_int32[i], hbd_downshift); - dqcoeff_pvq[i] = (out_int32[i] + (out_int32[i] < 0) + rounding_mask) >> - (OD_COEFF_SHIFT - coeff_shift); - } - - od_coding_order_to_raster(dqcoeff, blk_size, tx_type, dqcoeff_pvq, blk_size); - - eob = blk_size * blk_size; - - return eob; -} - -static PVQ_SKIP_TYPE read_pvq_skip(AV1_COMMON *cm, MACROBLOCKD *const xd, - int plane, TX_SIZE tx_size) { - // decode ac/dc coded flag. bit0: DC coded, bit1 : AC coded - // NOTE : we don't use 5 symbols for luma here in aom codebase, - // since block partition is taken care of by aom. - // So, only AC/DC skip info is coded - const int ac_dc_coded = aom_read_symbol( - xd->daala_dec.r, - xd->daala_dec.state.adapt->skip_cdf[2 * tx_size + (plane != 0)], 4, - "skip"); - if (ac_dc_coded < 0 || ac_dc_coded > 3) { - aom_internal_error(&cm->error, AOM_CODEC_INVALID_PARAM, - "Invalid PVQ Skip Type"); - } - return ac_dc_coded; -} - -static int av1_pvq_decode_helper2(AV1_COMMON *cm, MACROBLOCKD *const xd, - MB_MODE_INFO *const mbmi, int plane, int row, - int col, TX_SIZE tx_size, TX_TYPE tx_type) { - struct macroblockd_plane *const pd = &xd->plane[plane]; - // transform block size in pixels - int tx_blk_size = tx_size_wide[tx_size]; - int i, j; - tran_low_t *pvq_ref_coeff = pd->pvq_ref_coeff; - const int diff_stride = tx_blk_size; - int16_t *pred = pd->pred; - tran_low_t *const dqcoeff = pd->dqcoeff; - uint8_t *dst; - int eob; - const PVQ_SKIP_TYPE ac_dc_coded = read_pvq_skip(cm, xd, plane, tx_size); - - eob = 0; - dst = &pd->dst.buf[4 * row * pd->dst.stride + 4 * col]; - - if (ac_dc_coded) { - int xdec = pd->subsampling_x; - int seg_id = mbmi->segment_id; - int16_t *quant; - TxfmParam txfm_param; - // ToDo(yaowu): correct this with optimal number from decoding process. - const int max_scan_line = tx_size_2d[tx_size]; -#if CONFIG_HIGHBITDEPTH - if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - for (j = 0; j < tx_blk_size; j++) - for (i = 0; i < tx_blk_size; i++) - pred[diff_stride * j + i] = - CONVERT_TO_SHORTPTR(dst)[pd->dst.stride * j + i]; - } else { +static void read_coeffs_tx_intra_block(AV1_COMMON *cm, MACROBLOCKD *const xd, + aom_reader *const r, int plane, int row, + int col, 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 - for (j = 0; j < tx_blk_size; j++) - for (i = 0; i < tx_blk_size; i++) - pred[diff_stride * j + i] = dst[pd->dst.stride * j + i]; -#if CONFIG_HIGHBITDEPTH - } + av1_read_coeffs_txb_facade(cm, xd, r, row, col, plane, 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 - - txfm_param.tx_type = tx_type; - txfm_param.tx_size = tx_size; - txfm_param.lossless = xd->lossless[seg_id]; - -#if CONFIG_HIGHBITDEPTH - if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - txfm_param.bd = xd->bd; - av1_highbd_fwd_txfm(pred, pvq_ref_coeff, diff_stride, &txfm_param); - } else { -#endif // CONFIG_HIGHBITDEPTH - av1_fwd_txfm(pred, pvq_ref_coeff, diff_stride, &txfm_param); -#if CONFIG_HIGHBITDEPTH - } -#endif // CONFIG_HIGHBITDEPTH - - quant = &pd->seg_dequant[seg_id][0]; // aom's quantizer - - eob = av1_pvq_decode_helper(xd, pvq_ref_coeff, dqcoeff, quant, plane, - tx_size, tx_type, xdec, ac_dc_coded); - - inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride, - max_scan_line, eob); } - - return eob; } -#endif -static void predict_and_reconstruct_intra_block( - AV1_COMMON *cm, MACROBLOCKD *const xd, aom_reader *const r, - MB_MODE_INFO *const mbmi, int plane, int row, int col, TX_SIZE tx_size) { - PLANE_TYPE plane_type = get_plane_type(plane); - const int block_idx = get_block_idx(xd, plane, row, col); -#if CONFIG_PVQ +static void predict_and_reconstruct_intra_block(AV1_COMMON *cm, + MACROBLOCKD *const xd, + aom_reader *const r, int plane, + int row, int col, + TX_SIZE tx_size) { (void)r; -#endif - av1_predict_intra_block_facade(cm, xd, plane, block_idx, col, row, tx_size); + 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) { -#if !CONFIG_PVQ struct macroblockd_plane *const pd = &xd->plane[plane]; -#if CONFIG_LV_MAP - int16_t max_scan_line = 0; - int eob; - av1_read_coeffs_txb_facade(cm, xd, r, row, col, block_idx, plane, - pd->dqcoeff, tx_size, &max_scan_line, &eob); + // 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, block_idx, tx_size); -#else // CONFIG_LV_MAP - const TX_TYPE tx_type = - av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size); - const SCAN_ORDER *scan_order = get_scan(cm, tx_size, tx_type, mbmi); - int16_t max_scan_line = 0; - const int eob = - av1_decode_block_tokens(cm, xd, plane, scan_order, col, row, tx_size, - tx_type, &max_scan_line, r, mbmi->segment_id); -#endif // CONFIG_LV_MAP - if (eob) { + 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, -#if CONFIG_LGT_FROM_PRED - mbmi->mode, -#endif - tx_type, tx_size, dst, pd->dst.stride, - max_scan_line, eob); + inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride, + cm->reduced_tx_set_used); } -#else // !CONFIG_PVQ - const TX_TYPE tx_type = - av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size); - av1_pvq_decode_helper2(cm, xd, mbmi, plane, row, col, tx_size, tx_type); -#endif // !CONFIG_PVQ - } -#if CONFIG_CFL - if (plane == AOM_PLANE_Y && xd->cfl->store_y) { + } + if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) { cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type); } -#endif // CONFIG_CFL } -#if CONFIG_VAR_TX && !CONFIG_COEF_INTERLEAVE +static void inverse_transform_inter_block(const AV1_COMMON *const cm, + MACROBLOCKD *const xd, + aom_reader *const r, + const int blk_row, const int blk_col, + const int plane, + const TX_SIZE tx_size) { + (void)r; + PLANE_TYPE plane_type = get_plane_type(plane); + const struct macroblockd_plane *const pd = &xd->plane[plane]; + MB_MODE_INFO *mbmi = xd->mi[0]; + + // 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); + + if (plane == 0) + update_txk_array(mbmi->txk_type, mbmi->sb_type, blk_row, blk_col, tx_size, + tx_type); + + 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); +} + +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, MACROBLOCKD *const xd, 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) { const struct macroblockd_plane *const pd = &xd->plane[plane]; - const BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; - const int tx_row = blk_row >> (1 - pd->subsampling_y); - const int tx_col = blk_col >> (1 - pd->subsampling_x); const TX_SIZE plane_tx_size = - plane ? uv_txsize_lookup[bsize][mbmi->inter_tx_size[tx_row][tx_col]][0][0] - : mbmi->inter_tx_size[tx_row][tx_col]; + plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x, + pd->subsampling_y) + : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row, + blk_col)]; // 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_TYPE plane_type = get_plane_type(plane); -#if CONFIG_LV_MAP - int16_t max_scan_line = 0; - int eob; - av1_read_coeffs_txb_facade(cm, xd, r, blk_row, blk_col, block, plane, - pd->dqcoeff, tx_size, &max_scan_line, &eob); - // 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, block, plane_tx_size); -#else // CONFIG_LV_MAP - const TX_TYPE tx_type = - av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, plane_tx_size); - const SCAN_ORDER *sc = get_scan(cm, plane_tx_size, tx_type, mbmi); - int16_t max_scan_line = 0; - const int eob = av1_decode_block_tokens( - cm, xd, plane, sc, blk_col, blk_row, plane_tx_size, tx_type, - &max_scan_line, r, mbmi->segment_id); -#endif // CONFIG_LV_MAP - inverse_transform_block(xd, plane, -#if CONFIG_LGT_FROM_PRED - mbmi->mode, -#endif - tx_type, plane_tx_size, - &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) - << tx_size_wide_log2[0]], - pd->dst.stride, max_scan_line, eob); - *eob_total += eob; + if (tx_size == plane_tx_size || plane) { +#if TXCOEFF_TIMER + struct aom_usec_timer timer; + aom_usec_timer_start(&timer); +#endif + av1_read_coeffs_txb_facade(cm, xd, r, blk_row, blk_col, plane, 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 + inverse_transform_inter_block(cm, xd, r, blk_row, blk_col, plane, tx_size); + +#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->frame_offset, plane, + pixel_c, pixel_r, blk_w, blk_h, + xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH); +#endif + 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_RECT_TX_EXT - int is_qttx = plane_tx_size == quarter_txsize_lookup[plane_bsize]; - const TX_SIZE sub_txs = is_qttx ? plane_tx_size : sub_tx_size_map[tx_size]; - if (is_qttx) assert(blk_row == 0 && blk_col == 0 && block == 0); -#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)); -#endif - const int bsl = tx_size_wide_unit[sub_txs]; - int sub_step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs]; - int i; + 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(bsl > 0); - - for (i = 0; i < 4; ++i) { -#if CONFIG_RECT_TX_EXT - int is_wide_tx = tx_size_wide_unit[sub_txs] > tx_size_high_unit[sub_txs]; - const int offsetr = - is_qttx ? (is_wide_tx ? i * tx_size_high_unit[sub_txs] : 0) - : blk_row + ((i >> 1) * bsl); - const int offsetc = - is_qttx ? (is_wide_tx ? 0 : i * tx_size_wide_unit[sub_txs]) - : blk_col + (i & 0x01) * bsl; -#else - const int offsetr = blk_row + (i >> 1) * bsl; - const int offsetc = blk_col + (i & 0x01) * bsl; -#endif + 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; + if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; - decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, offsetr, - offsetc, block, sub_txs, eob_total); - block += sub_step; + decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, offsetr, + offsetc, block, sub_txs, eob_total); + block += sub_step; + } } } } -#endif // CONFIG_VAR_TX - -#if !CONFIG_VAR_TX || CONFIG_SUPERTX || CONFIG_COEF_INTERLEAVE || \ - (!CONFIG_VAR_TX && CONFIG_EXT_TX && CONFIG_RECT_TX) -static int reconstruct_inter_block(AV1_COMMON *cm, MACROBLOCKD *const xd, - aom_reader *const r, int segment_id, - int plane, int row, int col, - TX_SIZE tx_size) { - PLANE_TYPE plane_type = get_plane_type(plane); - int block_idx = get_block_idx(xd, plane, row, col); -#if CONFIG_PVQ - int eob; - (void)r; - (void)segment_id; -#else - struct macroblockd_plane *const pd = &xd->plane[plane]; -#endif - -#if !CONFIG_PVQ -#if CONFIG_LV_MAP - (void)segment_id; - int16_t max_scan_line = 0; - int eob; - av1_read_coeffs_txb_facade(cm, xd, r, row, col, block_idx, plane, pd->dqcoeff, - tx_size, &max_scan_line, &eob); - // 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, block_idx, tx_size); -#else // CONFIG_LV_MAP - int16_t max_scan_line = 0; - const TX_TYPE tx_type = - av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size); - const SCAN_ORDER *scan_order = - get_scan(cm, tx_size, tx_type, &xd->mi[0]->mbmi); - const int eob = - av1_decode_block_tokens(cm, xd, plane, scan_order, col, row, tx_size, - tx_type, &max_scan_line, r, segment_id); -#endif // CONFIG_LV_MAP - uint8_t *dst = - &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]]; - if (eob) - inverse_transform_block(xd, plane, -#if CONFIG_LGT_FROM_PRED - xd->mi[0]->mbmi.mode, -#endif - tx_type, tx_size, dst, pd->dst.stride, - max_scan_line, eob); -#else - const TX_TYPE tx_type = - av1_get_tx_type(plane_type, xd, row, col, block_idx, tx_size); - eob = av1_pvq_decode_helper2(cm, xd, &xd->mi[0]->mbmi, plane, row, col, - tx_size, tx_type); -#endif - return eob; -} -#endif // !CONFIG_VAR_TX || CONFIG_SUPER_TX 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) { + const int num_planes = av1_num_planes(cm); + const int offset = mi_row * cm->mi_stride + mi_col; - int x, y; const TileInfo *const tile = &xd->tile; xd->mi = cm->mi_grid_visible + 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]->mbmi.sb_type = bsize; + xd->mi[0]->sb_type = bsize; #if CONFIG_RD_DEBUG - xd->mi[0]->mbmi.mi_row = mi_row; - xd->mi[0]->mbmi.mi_col = mi_col; + xd->mi[0]->mi_row = mi_row; + xd->mi[0]->mi_col = mi_col; #endif -#if CONFIG_CFL - xd->cfl->mi_row = mi_row; - xd->cfl->mi_col = mi_col; -#endif - for (y = 0; y < y_mis; ++y) - for (x = !y; x < x_mis; ++x) xd->mi[y * cm->mi_stride + x] = xd->mi[0]; + xd->cfl.mi_row = mi_row; + xd->cfl.mi_col = mi_col; - set_plane_n4(xd, bw, bh); - set_skip_context(xd, mi_row, 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; + } -#if CONFIG_VAR_TX - xd->max_tx_size = max_txsize_lookup[bsize]; -#endif + set_plane_n4(xd, bw, bh, num_planes); + set_skip_context(xd, mi_row, mi_col, num_planes); // 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, -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); + set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, cm->mi_rows, cm->mi_cols); av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row, - mi_col); + mi_col, 0, num_planes); } -#if CONFIG_SUPERTX -static MB_MODE_INFO *set_offsets_extend(AV1_COMMON *const cm, - MACROBLOCKD *const xd, - const TileInfo *const tile, - BLOCK_SIZE bsize_pred, int mi_row_pred, - int mi_col_pred, int mi_row_ori, - int mi_col_ori) { - // Used in supertx - // (mi_row_ori, mi_col_ori): location for mv - // (mi_row_pred, mi_col_pred, bsize_pred): region to predict - const int bw = mi_size_wide[bsize_pred]; - const int bh = mi_size_high[bsize_pred]; - const int offset = mi_row_ori * cm->mi_stride + mi_col_ori; - xd->mi = cm->mi_grid_visible + offset; - xd->mi[0] = cm->mi + offset; - set_mi_row_col(xd, tile, mi_row_pred, bh, mi_col_pred, bw, -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); - - xd->up_available = (mi_row_ori > tile->mi_row_start); - xd->left_available = (mi_col_ori > tile->mi_col_start); +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) { + 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_cols - mi_col); + const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row); - set_plane_n4(xd, bw, bh); +#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); + xd->mi[0]->partition = partition; + av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis); + if (bsize >= BLOCK_8X8 && (cm->subsampling_x || cm->subsampling_y)) { + const BLOCK_SIZE uv_subsize = + ss_size_lookup[bsize][cm->subsampling_x][cm->subsampling_y]; + if (uv_subsize == BLOCK_INVALID) + aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, + "Invalid block size."); + } - return &xd->mi[0]->mbmi; + int reader_corrupted_flag = aom_reader_has_error(r); + aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag); } -#if CONFIG_SUPERTX -static MB_MODE_INFO *set_mb_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) { - const int offset = mi_row * cm->mi_stride + mi_col; - const TileInfo *const tile = &xd->tile; - int x, y; +typedef struct PadBlock { + int x0; + int x1; + int y0; + int y1; +} PadBlock; - xd->mi = cm->mi_grid_visible + offset; - xd->mi[0] = cm->mi + offset; - xd->mi[0]->mbmi.sb_type = bsize; - for (y = 0; y < y_mis; ++y) - for (x = !y; x < x_mis; ++x) xd->mi[y * cm->mi_stride + x] = xd->mi[0]; - - set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); - return &xd->mi[0]->mbmi; -} -#endif +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; -static void set_offsets_topblock(AV1_COMMON *const cm, MACROBLOCKD *const xd, - const TileInfo *const tile, BLOCK_SIZE bsize, - int mi_row, int mi_col) { - const int bw = mi_size_wide[bsize]; - const int bh = mi_size_high[bsize]; - const int offset = mi_row * cm->mi_stride + mi_col; + if (y >= h) + ref_row += (h - 1) * src_stride; + else if (y > 0) + ref_row += y * src_stride; - xd->mi = cm->mi_grid_visible + offset; - xd->mi[0] = cm->mi + offset; + do { + int right = 0, copy; + int left = x < 0 ? -x : 0; - set_plane_n4(xd, bw, bh); + if (left > b_w) left = b_w; - set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); + if (x + b_w > w) right = x + b_w - w; - av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row, - mi_col); -} + if (right > b_w) right = b_w; -static void set_param_topblock(AV1_COMMON *const cm, MACROBLOCKD *const xd, - BLOCK_SIZE bsize, int mi_row, int mi_col, - int txfm, int skip) { - 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); - const int offset = mi_row * cm->mi_stride + mi_col; - int x, y; + copy = b_w - left - right; - xd->mi = cm->mi_grid_visible + offset; - xd->mi[0] = cm->mi + offset; + if (left) aom_memset16(dst, ref_row[0], left); - for (y = 0; y < y_mis; ++y) - for (x = 0; x < x_mis; ++x) { - xd->mi[y * cm->mi_stride + x]->mbmi.skip = skip; - xd->mi[y * cm->mi_stride + x]->mbmi.tx_type = txfm; - } -#if CONFIG_VAR_TX - xd->above_txfm_context = cm->above_txfm_context + mi_col; - xd->left_txfm_context = - xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); - set_txfm_ctxs(xd->mi[0]->mbmi.tx_size, bw, bh, skip, xd); -#endif -} + if (copy) memcpy(dst + left, ref_row + x + left, copy * sizeof(uint16_t)); -static void set_ref(AV1_COMMON *const cm, MACROBLOCKD *const xd, int idx, - int mi_row, int mi_col) { - MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; -#if CONFIG_COMPOUND_SINGLEREF - RefBuffer *ref_buffer = - has_second_ref(mbmi) ? &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME] - : &cm->frame_refs[mbmi->ref_frame[0] - LAST_FRAME]; -#else - RefBuffer *ref_buffer = &cm->frame_refs[mbmi->ref_frame[idx] - LAST_FRAME]; -#endif // CONFIG_COMPOUND_SINGLEREF - xd->block_refs[idx] = ref_buffer; - if (!av1_is_valid_scale(&ref_buffer->sf)) - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Invalid scale factors"); - av1_setup_pre_planes(xd, idx, ref_buffer->buf, mi_row, mi_col, - &ref_buffer->sf); - aom_merge_corrupted_flag(&xd->corrupted, ref_buffer->buf->corrupted); + 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 dec_predict_b_extend( - AV1Decoder *const pbi, MACROBLOCKD *const xd, const TileInfo *const tile, - int block, int mi_row_ori, int mi_col_ori, int mi_row_pred, int mi_col_pred, - int mi_row_top, int mi_col_top, int plane, uint8_t *dst_buf, int dst_stride, - BLOCK_SIZE bsize_top, BLOCK_SIZE bsize_pred, int b_sub8x8, int bextend) { - // Used in supertx - // (mi_row_ori, mi_col_ori): location for mv - // (mi_row_pred, mi_col_pred, bsize_pred): region to predict - // (mi_row_top, mi_col_top, bsize_top): region of the top partition size - // block: sub location of sub8x8 blocks - // b_sub8x8: 1: ori is sub8x8; 0: ori is not sub8x8 - // bextend: 1: region to predict is an extension of ori; 0: not - int r = (mi_row_pred - mi_row_top) * MI_SIZE; - int c = (mi_col_pred - mi_col_top) * MI_SIZE; - const int mi_width_top = mi_size_wide[bsize_top]; - const int mi_height_top = mi_size_high[bsize_top]; - MB_MODE_INFO *mbmi; - AV1_COMMON *const cm = &pbi->common; +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 (mi_row_pred < mi_row_top || mi_col_pred < mi_col_top || - mi_row_pred >= mi_row_top + mi_height_top || - mi_col_pred >= mi_col_top + mi_width_top || mi_row_pred >= cm->mi_rows || - mi_col_pred >= cm->mi_cols) - return; + if (y >= h) + ref_row += (h - 1) * src_stride; + else if (y > 0) + ref_row += y * src_stride; - mbmi = set_offsets_extend(cm, xd, tile, bsize_pred, mi_row_pred, mi_col_pred, - mi_row_ori, mi_col_ori); - set_ref(cm, xd, 0, mi_row_pred, mi_col_pred); - if (has_second_ref(&xd->mi[0]->mbmi) -#if CONFIG_COMPOUND_SINGLEREF - || is_inter_singleref_comp_mode(xd->mi[0]->mbmi.mode) -#endif // CONFIG_COMPOUND_SINGLEREF - ) - set_ref(cm, xd, 1, mi_row_pred, mi_col_pred); - if (!bextend) mbmi->tx_size = max_txsize_lookup[bsize_top]; - - xd->plane[plane].dst.stride = dst_stride; - xd->plane[plane].dst.buf = - dst_buf + (r >> xd->plane[plane].subsampling_y) * dst_stride + - (c >> xd->plane[plane].subsampling_x); - - if (!b_sub8x8) - av1_build_inter_predictor_sb_extend(&pbi->common, xd, mi_row_ori, - mi_col_ori, mi_row_pred, mi_col_pred, - plane, bsize_pred); - else - av1_build_inter_predictor_sb_sub8x8_extend( - &pbi->common, xd, mi_row_ori, mi_col_ori, mi_row_pred, mi_col_pred, - plane, bsize_pred, block); -} + do { + int right = 0, copy; + int left = x < 0 ? -x : 0; -static void dec_extend_dir(AV1Decoder *const pbi, MACROBLOCKD *const xd, - const TileInfo *const tile, int block, - BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, - int mi_row_ori, int mi_col_ori, int mi_row, - int mi_col, int mi_row_top, int mi_col_top, - int plane, uint8_t *dst_buf, int dst_stride, - int dir) { - // dir: 0-lower, 1-upper, 2-left, 3-right - // 4-lowerleft, 5-upperleft, 6-lowerright, 7-upperright - const int mi_width = mi_size_wide[bsize]; - const int mi_height = mi_size_high[bsize]; - int xss = xd->plane[1].subsampling_x; - int yss = xd->plane[1].subsampling_y; -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif - int b_sub8x8 = (bsize < BLOCK_8X8) && !unify_bsize ? 1 : 0; - BLOCK_SIZE extend_bsize; - int mi_row_pred, mi_col_pred; - - int wide_unit, high_unit; - int i, j; - int ext_offset = 0; - - if (dir == 0 || dir == 1) { - extend_bsize = - (mi_width == mi_size_wide[BLOCK_8X8] || bsize < BLOCK_8X8 || xss < yss) - ? BLOCK_8X8 - : BLOCK_16X8; -#if CONFIG_CB4X4 - if (bsize < BLOCK_8X8) { - extend_bsize = BLOCK_4X4; - ext_offset = mi_size_wide[BLOCK_8X8]; - } -#endif + if (left > b_w) left = b_w; - wide_unit = mi_size_wide[extend_bsize]; - high_unit = mi_size_high[extend_bsize]; - - mi_row_pred = mi_row + ((dir == 0) ? mi_height : -(mi_height + ext_offset)); - mi_col_pred = mi_col; - - for (j = 0; j < mi_height + ext_offset; j += high_unit) - for (i = 0; i < mi_width + ext_offset; i += wide_unit) - dec_predict_b_extend(pbi, xd, tile, block, mi_row_ori, mi_col_ori, - mi_row_pred + j, mi_col_pred + i, mi_row_top, - mi_col_top, plane, dst_buf, dst_stride, top_bsize, - extend_bsize, b_sub8x8, 1); - } else if (dir == 2 || dir == 3) { - extend_bsize = - (mi_height == mi_size_high[BLOCK_8X8] || bsize < BLOCK_8X8 || yss < xss) - ? BLOCK_8X8 - : BLOCK_8X16; -#if CONFIG_CB4X4 - if (bsize < BLOCK_8X8) { - extend_bsize = BLOCK_4X4; - ext_offset = mi_size_wide[BLOCK_8X8]; - } -#endif + if (x + b_w > w) right = x + b_w - w; - wide_unit = mi_size_wide[extend_bsize]; - high_unit = mi_size_high[extend_bsize]; + if (right > b_w) right = b_w; - mi_row_pred = mi_row; - mi_col_pred = mi_col + ((dir == 3) ? mi_width : -(mi_width + ext_offset)); + copy = b_w - left - right; - for (j = 0; j < mi_height + ext_offset; j += high_unit) - for (i = 0; i < mi_width + ext_offset; i += wide_unit) - dec_predict_b_extend(pbi, xd, tile, block, mi_row_ori, mi_col_ori, - mi_row_pred + j, mi_col_pred + i, mi_row_top, - mi_col_top, plane, dst_buf, dst_stride, top_bsize, - extend_bsize, b_sub8x8, 1); - } else { - extend_bsize = BLOCK_8X8; -#if CONFIG_CB4X4 - if (bsize < BLOCK_8X8) { - extend_bsize = BLOCK_4X4; - ext_offset = mi_size_wide[BLOCK_8X8]; + 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) { + const int is_scaled = av1_is_scaled(sf); + // 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 ((!is_intrabc) && (!do_warp) && + (is_scaled || scaled_mv.col || scaled_mv.row || (frame_width & 0x7) || + (frame_height & 0x7))) { + if (subpel_x_mv || (sf->x_step_q4 != SUBPEL_SHIFTS)) { + block->x0 -= AOM_INTERP_EXTEND - 1; + block->x1 += AOM_INTERP_EXTEND; + *x_pad = 1; } -#endif - wide_unit = mi_size_wide[extend_bsize]; - high_unit = mi_size_high[extend_bsize]; - mi_row_pred = mi_row + ((dir == 4 || dir == 6) ? mi_height - : -(mi_height + ext_offset)); - mi_col_pred = - mi_col + ((dir == 6 || dir == 7) ? mi_width : -(mi_width + ext_offset)); + if (subpel_y_mv || (sf->y_step_q4 != SUBPEL_SHIFTS)) { + block->y0 -= AOM_INTERP_EXTEND - 1; + block->y1 += AOM_INTERP_EXTEND; + *y_pad = 1; + } - for (j = 0; j < mi_height + ext_offset; j += high_unit) - for (i = 0; i < mi_width + ext_offset; i += wide_unit) - dec_predict_b_extend(pbi, xd, tile, block, mi_row_ori, mi_col_ori, - mi_row_pred + j, mi_col_pred + i, mi_row_top, - mi_col_top, plane, dst_buf, dst_stride, top_bsize, - extend_bsize, b_sub8x8, 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 void dec_extend_all(AV1Decoder *const pbi, MACROBLOCKD *const xd, - const TileInfo *const tile, int block, - BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, - int mi_row_ori, int mi_col_ori, int mi_row, - int mi_col, int mi_row_top, int mi_col_top, - int plane, uint8_t *dst_buf, int dst_stride) { - for (int i = 0; i < 8; ++i) { - dec_extend_dir(pbi, xd, tile, block, bsize, top_bsize, mi_row_ori, - mi_col_ori, mi_row, mi_col, mi_row_top, mi_col_top, plane, - dst_buf, dst_stride, i); +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) * b_w + + x_pad * (AOM_INTERP_EXTEND - 1); } } -static void dec_predict_sb_complex(AV1Decoder *const pbi, MACROBLOCKD *const xd, - const TileInfo *const tile, int mi_row, - int mi_col, int mi_row_top, int mi_col_top, - BLOCK_SIZE bsize, BLOCK_SIZE top_bsize, - uint8_t *dst_buf[3], int dst_stride[3]) { - const AV1_COMMON *const cm = &pbi->common; - const int hbs = mi_size_wide[bsize] / 2; - const PARTITION_TYPE partition = get_partition(cm, mi_row, mi_col, bsize); - const BLOCK_SIZE subsize = get_subsize(bsize, partition); -#if CONFIG_EXT_PARTITION_TYPES - const BLOCK_SIZE bsize2 = get_subsize(bsize, PARTITION_SPLIT); -#endif - int i; - const int mi_offset = mi_row * cm->mi_stride + mi_col; - uint8_t *dst_buf1[3], *dst_buf2[3], *dst_buf3[3]; -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif - - DECLARE_ALIGNED(16, uint8_t, tmp_buf1[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); - DECLARE_ALIGNED(16, uint8_t, tmp_buf2[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); - DECLARE_ALIGNED(16, uint8_t, tmp_buf3[MAX_MB_PLANE * MAX_TX_SQUARE * 2]); - int dst_stride1[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE }; - int dst_stride2[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE }; - int dst_stride3[3] = { MAX_TX_SIZE, MAX_TX_SIZE, MAX_TX_SIZE }; - -#if CONFIG_HIGHBITDEPTH - if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - int len = sizeof(uint16_t); - dst_buf1[0] = CONVERT_TO_BYTEPTR(tmp_buf1); - dst_buf1[1] = CONVERT_TO_BYTEPTR(tmp_buf1 + MAX_TX_SQUARE * len); - dst_buf1[2] = CONVERT_TO_BYTEPTR(tmp_buf1 + 2 * MAX_TX_SQUARE * len); - dst_buf2[0] = CONVERT_TO_BYTEPTR(tmp_buf2); - dst_buf2[1] = CONVERT_TO_BYTEPTR(tmp_buf2 + MAX_TX_SQUARE * len); - dst_buf2[2] = CONVERT_TO_BYTEPTR(tmp_buf2 + 2 * MAX_TX_SQUARE * len); - dst_buf3[0] = CONVERT_TO_BYTEPTR(tmp_buf3); - dst_buf3[1] = CONVERT_TO_BYTEPTR(tmp_buf3 + MAX_TX_SQUARE * len); - dst_buf3[2] = CONVERT_TO_BYTEPTR(tmp_buf3 + 2 * MAX_TX_SQUARE * len); +static INLINE void dec_calc_subpel_params( + MACROBLOCKD *xd, const struct scale_factors *const sf, const MV mv, + int plane, const int pre_x, const 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, 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, 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 { -#endif - dst_buf1[0] = tmp_buf1; - dst_buf1[1] = tmp_buf1 + MAX_TX_SQUARE; - dst_buf1[2] = tmp_buf1 + 2 * MAX_TX_SQUARE; - dst_buf2[0] = tmp_buf2; - dst_buf2[1] = tmp_buf2 + MAX_TX_SQUARE; - dst_buf2[2] = tmp_buf2 + 2 * MAX_TX_SQUARE; - dst_buf3[0] = tmp_buf3; - dst_buf3[1] = tmp_buf3 + MAX_TX_SQUARE; - dst_buf3[2] = tmp_buf3 + 2 * MAX_TX_SQUARE; -#if CONFIG_HIGHBITDEPTH + // 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, 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; } -#endif - - if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return; - - xd->mi = cm->mi_grid_visible + mi_offset; - xd->mi[0] = cm->mi + mi_offset; +} - for (i = 0; i < MAX_MB_PLANE; i++) { - xd->plane[i].dst.buf = dst_buf[i]; - xd->plane[i].dst.stride = dst_stride[i]; +static INLINE void dec_build_inter_predictors(const AV1_COMMON *cm, + MACROBLOCKD *xd, int plane, + const MB_MODE_INFO *mi, + int build_for_obmc, int bw, + int bh, int mi_x, int mi_y) { + struct macroblockd_plane *const pd = &xd->plane[plane]; + int is_compound = has_second_ref(mi); + int ref; + const int is_intrabc = is_intrabc_block(mi); + assert(IMPLIES(is_intrabc, !is_compound)); + int is_global[2] = { 0, 0 }; + for (ref = 0; ref < 1 + is_compound; ++ref) { + const WarpedMotionParams *const wm = &xd->global_motion[mi->ref_frame[ref]]; + is_global[ref] = is_global_mv_block(mi, wm->wmtype); + } + + const BLOCK_SIZE bsize = mi->sb_type; + const int ss_x = pd->subsampling_x; + const int ss_y = pd->subsampling_y; + int sub8x8_inter = (block_size_wide[bsize] < 8 && ss_x) || + (block_size_high[bsize] < 8 && ss_y); + + if (is_intrabc) sub8x8_inter = 0; + + // For sub8x8 chroma blocks, we may be covering more than one luma block's + // worth of pixels. Thus (mi_x, mi_y) may not be the correct coordinates for + // the top-left corner of the prediction source - the correct top-left corner + // is at (pre_x, pre_y). + const int row_start = + (block_size_high[bsize] == 4) && ss_y && !build_for_obmc ? -1 : 0; + const int col_start = + (block_size_wide[bsize] == 4) && ss_x && !build_for_obmc ? -1 : 0; + const int pre_x = (mi_x + MI_SIZE * col_start) >> ss_x; + const int pre_y = (mi_y + MI_SIZE * row_start) >> ss_y; + + sub8x8_inter = sub8x8_inter && !build_for_obmc; + if (sub8x8_inter) { + for (int row = row_start; row <= 0 && sub8x8_inter; ++row) { + for (int col = col_start; col <= 0; ++col) { + const MB_MODE_INFO *this_mbmi = xd->mi[row * xd->mi_stride + col]; + if (!is_inter_block(this_mbmi)) sub8x8_inter = 0; + if (is_intrabc_block(this_mbmi)) sub8x8_inter = 0; + } + } } - switch (partition) { - case PARTITION_NONE: - assert(bsize < top_bsize); - for (i = 0; i < MAX_MB_PLANE; i++) { - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, bsize, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i]); - } - break; - case PARTITION_HORZ: - if (bsize == BLOCK_8X8 && !unify_bsize) { - for (i = 0; i < MAX_MB_PLANE; i++) { - // For sub8x8, predict in 8x8 unit - // First half - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, BLOCK_8X8, 1, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i]); - - // Second half - dec_predict_b_extend(pbi, xd, tile, 2, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf1[i], - dst_stride1[i], top_bsize, BLOCK_8X8, 1, 1); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 2, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf1[i], dst_stride1[i]); + if (sub8x8_inter) { + // block size + const int b4_w = block_size_wide[bsize] >> ss_x; + const int b4_h = block_size_high[bsize] >> ss_y; + const BLOCK_SIZE plane_bsize = scale_chroma_bsize(bsize, ss_x, ss_y); + const int b8_w = block_size_wide[plane_bsize] >> ss_x; + const int b8_h = block_size_high[plane_bsize] >> ss_y; + assert(!is_compound); + + const struct buf_2d orig_pred_buf[2] = { pd->pre[0], pd->pre[1] }; + + int row = row_start; + int src_stride; + for (int y = 0; y < b8_h; y += b4_h) { + int col = col_start; + for (int x = 0; x < b8_w; x += b4_w) { + MB_MODE_INFO *this_mbmi = xd->mi[row * xd->mi_stride + col]; + is_compound = has_second_ref(this_mbmi); + DECLARE_ALIGNED(32, CONV_BUF_TYPE, tmp_dst[8 * 8]); + int tmp_dst_stride = 8; + assert(bw < 8 || bh < 8); + ConvolveParams conv_params = get_conv_params_no_round( + 0, 0, plane, tmp_dst, tmp_dst_stride, is_compound, xd->bd); + conv_params.use_jnt_comp_avg = 0; + struct buf_2d *const dst_buf = &pd->dst; + uint8_t *dst = dst_buf->buf + dst_buf->stride * y + x; + + ref = 0; + const RefBuffer *ref_buf = + &cm->frame_refs[this_mbmi->ref_frame[ref] - LAST_FRAME]; + + pd->pre[ref].buf0 = + (plane == 1) ? ref_buf->buf->u_buffer : ref_buf->buf->v_buffer; + pd->pre[ref].buf = + pd->pre[ref].buf0 + scaled_buffer_offset(pre_x, pre_y, + ref_buf->buf->uv_stride, + &ref_buf->sf); + pd->pre[ref].width = ref_buf->buf->uv_crop_width; + pd->pre[ref].height = ref_buf->buf->uv_crop_height; + pd->pre[ref].stride = ref_buf->buf->uv_stride; + + const struct scale_factors *const sf = + is_intrabc ? &cm->sf_identity : &ref_buf->sf; + struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref]; + + const MV mv = this_mbmi->mv[ref].as_mv; + + uint8_t *pre; + SubpelParams subpel_params; + PadBlock block; + MV32 scaled_mv; + int subpel_x_mv, subpel_y_mv; + int highbd; + WarpTypesAllowed warp_types; + warp_types.global_warp_allowed = is_global[ref]; + warp_types.local_warp_allowed = this_mbmi->motion_mode == WARPED_CAUSAL; + + dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, x, y, pre_buf, + &subpel_params, bw, bh, &block, mi_x, mi_y, + &scaled_mv, &subpel_x_mv, &subpel_y_mv); + pre = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0; + src_stride = pre_buf->stride; + highbd = xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH; + extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv, + subpel_y_mv, 0, is_intrabc, highbd, xd->mc_buf[ref], + &pre, &src_stride); + conv_params.ref = ref; + conv_params.do_average = ref; + if (is_masked_compound_type(mi->interinter_comp.type)) { + // masked compound type has its own average mechanism + conv_params.do_average = 0; } - // weighted average to smooth the boundary - xd->plane[0].dst.buf = dst_buf[0]; - xd->plane[0].dst.stride = dst_stride[0]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[0], dst_stride[0], dst_buf1[0], dst_stride1[0], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, - 0); - } else { - for (i = 0; i < MAX_MB_PLANE; i++) { -#if CONFIG_CB4X4 - const struct macroblockd_plane *pd = &xd->plane[i]; - int handle_chroma_sub8x8 = need_handle_chroma_sub8x8( - subsize, pd->subsampling_x, pd->subsampling_y); - - if (handle_chroma_sub8x8) { - int mode_offset_row = CONFIG_CHROMA_SUB8X8 ? hbs : 0; - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + mode_offset_row, - mi_col, mi_row, mi_col, mi_row_top, mi_col_top, - i, dst_buf[i], dst_stride[i], top_bsize, bsize, - 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, bsize, top_bsize, - mi_row + mode_offset_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i]); - } else { -#endif - // First half - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, - mi_col, mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col, mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i]); - else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col, mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i], 0); - - if (mi_row + hbs < cm->mi_rows) { - // Second half - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, - mi_row + hbs, mi_col, mi_row_top, mi_col_top, - i, dst_buf1[i], dst_stride1[i], top_bsize, - subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col, mi_row + hbs, mi_col, - mi_row_top, mi_col_top, i, dst_buf1[i], - dst_stride1[i]); - else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col, mi_row + hbs, mi_col, - mi_row_top, mi_col_top, i, dst_buf1[i], - dst_stride1[i], 1); - - // weighted average to smooth the boundary - xd->plane[i].dst.buf = dst_buf[i]; - xd->plane[i].dst.stride = dst_stride[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_HORZ, i); - } -#if CONFIG_CB4X4 - } -#endif - } - } - break; - case PARTITION_VERT: - if (bsize == BLOCK_8X8 && !unify_bsize) { - for (i = 0; i < MAX_MB_PLANE; i++) { - // First half - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, BLOCK_8X8, 1, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i]); - - // Second half - dec_predict_b_extend(pbi, xd, tile, 1, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf1[i], - dst_stride1[i], top_bsize, BLOCK_8X8, 1, 1); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 1, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf1[i], dst_stride1[i]); - } + av1_make_inter_predictor( + pre, src_stride, dst, dst_buf->stride, &subpel_params, sf, b4_w, + b4_h, &conv_params, this_mbmi->interp_filters, &warp_types, + (mi_x >> pd->subsampling_x) + x, (mi_y >> pd->subsampling_y) + y, + plane, ref, mi, build_for_obmc, xd, cm->allow_warped_motion); - // Smooth - xd->plane[0].dst.buf = dst_buf[0]; - xd->plane[0].dst.stride = dst_stride[0]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[0], dst_stride[0], dst_buf1[0], dst_stride1[0], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, - 0); - } else { - for (i = 0; i < MAX_MB_PLANE; i++) { -#if CONFIG_CB4X4 - const struct macroblockd_plane *pd = &xd->plane[i]; - int handle_chroma_sub8x8 = need_handle_chroma_sub8x8( - subsize, pd->subsampling_x, pd->subsampling_y); - - if (handle_chroma_sub8x8) { - int mode_offset_col = CONFIG_CHROMA_SUB8X8 ? hbs : 0; - assert(i > 0 && bsize == BLOCK_8X8); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, - mi_col + mode_offset_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, bsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, bsize, top_bsize, mi_row, - mi_col + mode_offset_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i]); - } else { -#endif - // First half - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, - mi_col, mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col, mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i]); - else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col, mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i], 3); - - // Second half - if (mi_col + hbs < cm->mi_cols) { - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - i, dst_buf1[i], dst_stride1[i], top_bsize, - subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col + hbs, mi_row, mi_col + hbs, mi_row_top, - mi_col_top, i, dst_buf1[i], dst_stride1[i]); - else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col + hbs, mi_row, mi_col + hbs, mi_row_top, - mi_col_top, i, dst_buf1[i], dst_stride1[i], 2); - - // Smooth - xd->plane[i].dst.buf = dst_buf[i]; - xd->plane[i].dst.stride = dst_stride[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_VERT, i); - } -#if CONFIG_CB4X4 - } -#endif - } + ++col; } - break; - case PARTITION_SPLIT: - if (bsize == BLOCK_8X8 && !unify_bsize) { - for (i = 0; i < MAX_MB_PLANE; i++) { - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, BLOCK_8X8, 1, 0); - dec_predict_b_extend(pbi, xd, tile, 1, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf1[i], - dst_stride1[i], top_bsize, BLOCK_8X8, 1, 1); - dec_predict_b_extend(pbi, xd, tile, 2, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf2[i], - dst_stride2[i], top_bsize, BLOCK_8X8, 1, 1); - dec_predict_b_extend(pbi, xd, tile, 3, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf3[i], - dst_stride3[i], top_bsize, BLOCK_8X8, 1, 1); - if (bsize < top_bsize) { - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i]); - dec_extend_all(pbi, xd, tile, 1, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf1[i], dst_stride1[i]); - dec_extend_all(pbi, xd, tile, 2, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf2[i], dst_stride2[i]); - dec_extend_all(pbi, xd, tile, 3, subsize, top_bsize, mi_row, mi_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf3[i], dst_stride3[i]); - } - } -#if CONFIG_CB4X4 - } else if (bsize == BLOCK_8X8) { - for (i = 0; i < MAX_MB_PLANE; i++) { - const struct macroblockd_plane *pd = &xd->plane[i]; - int handle_chroma_sub8x8 = need_handle_chroma_sub8x8( - subsize, pd->subsampling_x, pd->subsampling_y); - - if (handle_chroma_sub8x8) { - int mode_offset_row = - CONFIG_CHROMA_SUB8X8 && mi_row + hbs < cm->mi_rows ? hbs : 0; - int mode_offset_col = - CONFIG_CHROMA_SUB8X8 && mi_col + hbs < cm->mi_cols ? hbs : 0; - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + mode_offset_row, - mi_col + mode_offset_col, mi_row, mi_col, - mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, BLOCK_8X8, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, BLOCK_8X8, top_bsize, - mi_row + mode_offset_row, mi_col + mode_offset_col, - mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i]); - } else { - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, - mi_col, mi_row_top, mi_col_top, i, dst_buf[i], - dst_stride[i], top_bsize, subsize, 0, 0); - if (mi_row < cm->mi_rows && mi_col + hbs < cm->mi_cols) - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, - mi_row, mi_col + hbs, mi_row_top, mi_col_top, - i, dst_buf1[i], dst_stride1[i], top_bsize, - subsize, 0, 0); - if (mi_row + hbs < cm->mi_rows && mi_col < cm->mi_cols) - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, - mi_row + hbs, mi_col, mi_row_top, mi_col_top, - i, dst_buf2[i], dst_stride2[i], top_bsize, - subsize, 0, 0); - if (mi_row + hbs < cm->mi_rows && mi_col + hbs < cm->mi_cols) - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col + hbs, - mi_row + hbs, mi_col + hbs, mi_row_top, - mi_col_top, i, dst_buf3[i], dst_stride3[i], - top_bsize, subsize, 0, 0); - - if (bsize < top_bsize) { - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col, mi_row, mi_col, mi_row_top, mi_col_top, i, - dst_buf[i], dst_stride[i]); - if (mi_row < cm->mi_rows && mi_col + hbs < cm->mi_cols) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col + hbs, mi_row, mi_col + hbs, mi_row_top, - mi_col_top, i, dst_buf1[i], dst_stride1[i]); - if (mi_row + hbs < cm->mi_rows && mi_col < cm->mi_cols) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col, mi_row + hbs, mi_col, - mi_row_top, mi_col_top, i, dst_buf2[i], - dst_stride2[i]); - if (mi_row + hbs < cm->mi_rows && mi_col + hbs < cm->mi_cols) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, - mi_row + hbs, mi_col + hbs, mi_row + hbs, - mi_col + hbs, mi_row_top, mi_col_top, i, - dst_buf3[i], dst_stride3[i]); - } - } - } -#endif - } else { - dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col, mi_row_top, - mi_col_top, subsize, top_bsize, dst_buf, - dst_stride); - if (mi_row < cm->mi_rows && mi_col + hbs < cm->mi_cols) - dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col + hbs, - mi_row_top, mi_col_top, subsize, top_bsize, - dst_buf1, dst_stride1); - if (mi_row + hbs < cm->mi_rows && mi_col < cm->mi_cols) - dec_predict_sb_complex(pbi, xd, tile, mi_row + hbs, mi_col, - mi_row_top, mi_col_top, subsize, top_bsize, - dst_buf2, dst_stride2); - if (mi_row + hbs < cm->mi_rows && mi_col + hbs < cm->mi_cols) - dec_predict_sb_complex(pbi, xd, tile, mi_row + hbs, mi_col + hbs, - mi_row_top, mi_col_top, subsize, top_bsize, - dst_buf3, dst_stride3); - } - for (i = 0; i < MAX_MB_PLANE; i++) { -#if CONFIG_CB4X4 - const struct macroblockd_plane *pd = &xd->plane[i]; - int handle_chroma_sub8x8 = need_handle_chroma_sub8x8( - subsize, pd->subsampling_x, pd->subsampling_y); - if (handle_chroma_sub8x8) continue; // Skip <4x4 chroma smoothing -#else - if (bsize == BLOCK_8X8 && i != 0) - continue; // Skip <4x4 chroma smoothing -#endif - if (mi_row < cm->mi_rows && mi_col + hbs < cm->mi_cols) { - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_VERT, i); - if (mi_row + hbs < cm->mi_rows) { - av1_build_masked_inter_predictor_complex( - xd, dst_buf2[i], dst_stride2[i], dst_buf3[i], dst_stride3[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_VERT, i); - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_HORZ, i); - } - } else if (mi_row + hbs < cm->mi_rows && mi_col < cm->mi_cols) { - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_HORZ, i); - } - } - break; -#if CONFIG_EXT_PARTITION_TYPES -#if CONFIG_EXT_PARTITION_TYPES_AB -#error HORZ/VERT_A/B partitions not yet updated in superres code -#endif - case PARTITION_HORZ_A: - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride, - top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, mi_row, - mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, - dst_stride1, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row, mi_col + hbs, - mi_row_top, mi_col_top, dst_buf1, dst_stride1); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, mi_row + hbs, - mi_col, mi_row_top, mi_col_top, dst_buf2, - dst_stride2, top_bsize, subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row + hbs, - mi_col, mi_row_top, mi_col_top, dst_buf2, dst_stride2); - else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row + hbs, - mi_col, mi_row_top, mi_col_top, dst_buf2, dst_stride2, - 1); - - for (i = 0; i < MAX_MB_PLANE; i++) { - xd->plane[i].dst.buf = dst_buf[i]; - xd->plane[i].dst.stride = dst_stride[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, - i); - } - for (i = 0; i < MAX_MB_PLANE; i++) { - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, - i); - } - break; - case PARTITION_VERT_A: + ++row; + } - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride, - top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, mi_row + hbs, - mi_col, mi_row_top, mi_col_top, dst_buf1, - dst_stride1, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, mi_col, - mi_row_top, mi_col_top, dst_buf1, dst_stride1); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, mi_row, - mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, - dst_stride2, top_bsize, subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, - dst_stride2); - else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, - mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, - dst_stride2, 2); - - for (i = 0; i < MAX_MB_PLANE; i++) { - xd->plane[i].dst.buf = dst_buf[i]; - xd->plane[i].dst.stride = dst_stride[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, - i); - } - for (i = 0; i < MAX_MB_PLANE; i++) { - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf2[i], dst_stride2[i], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, - i); - } - break; - case PARTITION_HORZ_B: - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride, - top_bsize, subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride); - else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride, 0); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col, mi_row + hbs, - mi_col, mi_row_top, mi_col_top, dst_buf1, - dst_stride1, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, mi_col, - mi_row_top, mi_col_top, dst_buf1, dst_stride1); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col + hbs, - mi_row + hbs, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf2, dst_stride2, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, - mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, - dst_stride2); - - for (i = 0; i < MAX_MB_PLANE; i++) { - xd->plane[i].dst.buf = dst_buf1[i]; - xd->plane[i].dst.stride = dst_stride1[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf1[i], dst_stride1[i], dst_buf2[i], dst_stride2[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_VERT, i); - } - for (i = 0; i < MAX_MB_PLANE; i++) { - xd->plane[i].dst.buf = dst_buf[i]; - xd->plane[i].dst.stride = dst_stride[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_HORZ, - i); + for (ref = 0; ref < 2; ++ref) pd->pre[ref] = orig_pred_buf[ref]; + return; + } + + { + struct buf_2d *const dst_buf = &pd->dst; + uint8_t *const dst = dst_buf->buf; + uint8_t *pre[2]; + SubpelParams subpel_params[2]; + DECLARE_ALIGNED(32, uint16_t, tmp_dst[MAX_SB_SIZE * MAX_SB_SIZE]); + int src_stride[2]; + for (ref = 0; ref < 1 + is_compound; ++ref) { + const struct scale_factors *const sf = + is_intrabc ? &cm->sf_identity : &xd->block_refs[ref]->sf; + struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref]; + const MV mv = mi->mv[ref].as_mv; + PadBlock block; + MV32 scaled_mv; + int subpel_x_mv, subpel_y_mv; + int highbd; + + dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, 0, 0, pre_buf, + &subpel_params[ref], bw, bh, &block, mi_x, mi_y, + &scaled_mv, &subpel_x_mv, &subpel_y_mv); + pre[ref] = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0; + src_stride[ref] = pre_buf->stride; + highbd = xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH; + + WarpTypesAllowed warp_types; + warp_types.global_warp_allowed = is_global[ref]; + warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL; + int do_warp = (bw >= 8 && bh >= 8 && + av1_allow_warp(mi, &warp_types, + &xd->global_motion[mi->ref_frame[ref]], + build_for_obmc, subpel_params[ref].xs, + subpel_params[ref].ys, NULL)); + do_warp = (do_warp && 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, highbd, xd->mc_buf[ref], &pre[ref], + &src_stride[ref]); + } + + ConvolveParams conv_params = get_conv_params_no_round( + 0, 0, plane, tmp_dst, MAX_SB_SIZE, is_compound, xd->bd); + av1_jnt_comp_weight_assign(cm, mi, 0, &conv_params.fwd_offset, + &conv_params.bck_offset, + &conv_params.use_jnt_comp_avg, is_compound); + + for (ref = 0; ref < 1 + is_compound; ++ref) { + const struct scale_factors *const sf = + is_intrabc ? &cm->sf_identity : &xd->block_refs[ref]->sf; + WarpTypesAllowed warp_types; + warp_types.global_warp_allowed = is_global[ref]; + warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL; + conv_params.ref = ref; + conv_params.do_average = ref; + if (is_masked_compound_type(mi->interinter_comp.type)) { + // masked compound type has its own average mechanism + conv_params.do_average = 0; } - break; - case PARTITION_VERT_B: - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride, - top_bsize, subsize, 0, 0); - if (bsize < top_bsize) - dec_extend_all(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride); + + if (ref && is_masked_compound_type(mi->interinter_comp.type)) + av1_make_masked_inter_predictor( + pre[ref], src_stride[ref], dst, dst_buf->stride, + &subpel_params[ref], sf, bw, bh, &conv_params, mi->interp_filters, + plane, &warp_types, mi_x >> pd->subsampling_x, + mi_y >> pd->subsampling_y, ref, xd, cm->allow_warped_motion); else - dec_extend_dir(pbi, xd, tile, 0, subsize, top_bsize, mi_row, mi_col, - mi_row_top, mi_col_top, dst_buf, dst_stride, 3); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row, mi_col + hbs, mi_row, - mi_col + hbs, mi_row_top, mi_col_top, dst_buf1, - dst_stride1, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row, mi_col + hbs, - mi_row_top, mi_col_top, dst_buf1, dst_stride1); - - dec_predict_b_extend(pbi, xd, tile, 0, mi_row + hbs, mi_col + hbs, - mi_row + hbs, mi_col + hbs, mi_row_top, mi_col_top, - dst_buf2, dst_stride2, top_bsize, bsize2, 0, 0); - dec_extend_all(pbi, xd, tile, 0, bsize2, top_bsize, mi_row + hbs, - mi_col + hbs, mi_row_top, mi_col_top, dst_buf2, - dst_stride2); - - for (i = 0; i < MAX_MB_PLANE; i++) { - xd->plane[i].dst.buf = dst_buf1[i]; - xd->plane[i].dst.stride = dst_stride1[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf1[i], dst_stride1[i], dst_buf2[i], dst_stride2[i], - mi_row, mi_col, mi_row_top, mi_col_top, bsize, top_bsize, - PARTITION_HORZ, i); - } - for (i = 0; i < MAX_MB_PLANE; i++) { - xd->plane[i].dst.buf = dst_buf[i]; - xd->plane[i].dst.stride = dst_stride[i]; - av1_build_masked_inter_predictor_complex( - xd, dst_buf[i], dst_stride[i], dst_buf1[i], dst_stride1[i], mi_row, - mi_col, mi_row_top, mi_col_top, bsize, top_bsize, PARTITION_VERT, - i); - } - break; -#endif // CONFIG_EXT_PARTITION_TYPES - default: assert(0); + av1_make_inter_predictor( + pre[ref], src_stride[ref], dst, dst_buf->stride, + &subpel_params[ref], sf, bw, bh, &conv_params, mi->interp_filters, + &warp_types, mi_x >> pd->subsampling_x, mi_y >> pd->subsampling_y, + plane, ref, mi, build_for_obmc, xd, cm->allow_warped_motion); + } } } -static void set_segment_id_supertx(const AV1_COMMON *const cm, int mi_row, - int mi_col, BLOCK_SIZE bsize) { - const struct segmentation *seg = &cm->seg; - const int miw = AOMMIN(mi_size_wide[bsize], cm->mi_cols - mi_col); - const int mih = AOMMIN(mi_size_high[bsize], cm->mi_rows - mi_row); - const int mi_offset = mi_row * cm->mi_stride + mi_col; - MODE_INFO **const mip = cm->mi_grid_visible + mi_offset; - int r, c; - int seg_id_supertx = MAX_SEGMENTS; +static void dec_build_inter_predictors_for_planes(const AV1_COMMON *cm, + MACROBLOCKD *xd, + BLOCK_SIZE bsize, int mi_row, + int mi_col, int plane_from, + int plane_to) { + int plane; + const int mi_x = mi_col * MI_SIZE; + const int mi_y = mi_row * MI_SIZE; + for (plane = plane_from; plane <= plane_to; ++plane) { + const struct macroblockd_plane *pd = &xd->plane[plane]; + const int bw = pd->width; + const int bh = pd->height; + + if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, + pd->subsampling_y)) + continue; - if (!seg->enabled) { - seg_id_supertx = 0; - } else { - // Find the minimum segment_id - for (r = 0; r < mih; r++) - for (c = 0; c < miw; c++) - seg_id_supertx = - AOMMIN(mip[r * cm->mi_stride + c]->mbmi.segment_id, seg_id_supertx); - assert(0 <= seg_id_supertx && seg_id_supertx < MAX_SEGMENTS); - } - - // Assign the the segment_id back to segment_id_supertx - for (r = 0; r < mih; r++) - for (c = 0; c < miw; c++) - mip[r * cm->mi_stride + c]->mbmi.segment_id_supertx = seg_id_supertx; + dec_build_inter_predictors(cm, xd, plane, xd->mi[0], 0, bw, bh, mi_x, mi_y); + } } -#endif // CONFIG_SUPERTX -static void decode_mbmi_block(AV1Decoder *const pbi, MACROBLOCKD *const xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif // CONFIG_SUPERTX - int mi_row, int mi_col, aom_reader *r, -#if CONFIG_EXT_PARTITION_TYPES - PARTITION_TYPE partition, -#endif // CONFIG_EXT_PARTITION_TYPES - BLOCK_SIZE bsize) { - 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_cols - mi_col); - const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row); +static void dec_build_inter_predictors_sby(const AV1_COMMON *cm, + MACROBLOCKD *xd, int mi_row, + int mi_col, BUFFER_SET *ctx, + BLOCK_SIZE bsize) { + dec_build_inter_predictors_for_planes(cm, xd, bsize, mi_row, mi_col, 0, 0); -#if CONFIG_ACCOUNTING - aom_accounting_set_context(&pbi->accounting, mi_col, mi_row); -#endif -#if CONFIG_SUPERTX - if (supertx_enabled) { - set_mb_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis); - } else { - set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis); + if (is_interintra_pred(xd->mi[0])) { + BUFFER_SET default_ctx = { { xd->plane[0].dst.buf, NULL, NULL }, + { xd->plane[0].dst.stride, 0, 0 } }; + if (!ctx) ctx = &default_ctx; + av1_build_interintra_predictors_sby(cm, xd, xd->plane[0].dst.buf, + xd->plane[0].dst.stride, ctx, bsize); } -#if CONFIG_EXT_PARTITION_TYPES - xd->mi[0]->mbmi.partition = partition; -#endif - av1_read_mode_info(pbi, xd, supertx_enabled, mi_row, mi_col, r, x_mis, y_mis); -#else - set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis); -#if CONFIG_EXT_PARTITION_TYPES - xd->mi[0]->mbmi.partition = partition; -#endif - av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis); -#endif // CONFIG_SUPERTX - if (bsize >= BLOCK_8X8 && (cm->subsampling_x || cm->subsampling_y)) { - const BLOCK_SIZE uv_subsize = - ss_size_lookup[bsize][cm->subsampling_x][cm->subsampling_y]; - if (uv_subsize == BLOCK_INVALID) - aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, - "Invalid block size."); +} + +static void dec_build_inter_predictors_sbuv(const AV1_COMMON *cm, + MACROBLOCKD *xd, int mi_row, + int mi_col, BUFFER_SET *ctx, + BLOCK_SIZE bsize) { + dec_build_inter_predictors_for_planes(cm, xd, bsize, mi_row, mi_col, 1, + MAX_MB_PLANE - 1); + + if (is_interintra_pred(xd->mi[0])) { + BUFFER_SET default_ctx = { + { NULL, xd->plane[1].dst.buf, xd->plane[2].dst.buf }, + { 0, xd->plane[1].dst.stride, xd->plane[2].dst.stride } + }; + if (!ctx) ctx = &default_ctx; + av1_build_interintra_predictors_sbuv( + cm, xd, xd->plane[1].dst.buf, xd->plane[2].dst.buf, + xd->plane[1].dst.stride, xd->plane[2].dst.stride, ctx, bsize); } +} -#if CONFIG_SUPERTX - xd->mi[0]->mbmi.segment_id_supertx = MAX_SEGMENTS; -#endif // CONFIG_SUPERTX +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); + dec_build_inter_predictors_sby(cm, xd, mi_row, mi_col, ctx, bsize); + if (num_planes > 1) + dec_build_inter_predictors_sbuv(cm, xd, mi_row, mi_col, ctx, bsize); +} - int reader_corrupted_flag = aom_reader_has_error(r); - aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag); +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 = ctxt->mi_col + rel_mi_col; + int mi_x, mi_y; + MB_MODE_INFO backup_mbmi = *above_mbmi; + + 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 = ctxt->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(bsize, pd, 0)) continue; + dec_build_inter_predictors(ctxt->cm, xd, j, &backup_mbmi, 1, bw, bh, mi_x, + mi_y); + } } -#if CONFIG_NCOBMC_ADAPT_WEIGHT -static void set_mode_info_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_row, int mi_col) { - const int offset = mi_row * cm->mi_stride + mi_col; - xd->mi = cm->mi_grid_visible + offset; - xd->mi[0] = &cm->mi[offset]; +static void dec_build_prediction_by_above_preds( + const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, + 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->n8_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, mi_row, + mi_col, 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, mi_col, + max_neighbor_obmc[mi_size_wide_log2[bsize]], + dec_build_prediction_by_above_pred, &ctxt); + + xd->mb_to_left_edge = -((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 void get_ncobmc_recon(AV1_COMMON *const cm, MACROBLOCKD *xd, int mi_row, - int mi_col, int bsize, int mode) { - uint8_t *pred_buf[4][MAX_MB_PLANE]; - int pred_stride[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; - // target block in pxl - int pxl_row = mi_row << MI_SIZE_LOG2; - int pxl_col = mi_col << MI_SIZE_LOG2; +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 = ctxt->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 = ctxt->mi_col << MI_SIZE_LOG2; + mi_y = left_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 = 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(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, int mi_row, int mi_col, + 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->n8_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, mi_row, + mi_col, 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, mi_row, + max_neighbor_obmc[mi_size_high_log2[bsize]], + dec_build_prediction_by_left_pred, &ctxt); + + xd->mb_to_top_edge = -((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, int mi_row, + int mi_col) { + const int num_planes = av1_num_planes(cm); + DECLARE_ALIGNED(16, uint8_t, tmp_buf1[2 * MAX_MB_PLANE * MAX_SB_SQUARE]); + DECLARE_ALIGNED(16, uint8_t, tmp_buf2[2 * MAX_MB_PLANE * MAX_SB_SQUARE]); + 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 }; - int plane; -#if CONFIG_HIGHBITDEPTH if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { int len = sizeof(uint16_t); - ASSIGN_ALIGNED_PTRS_HBD(pred_buf[0], cm->ncobmcaw_buf[0], MAX_SB_SQUARE, - len); - ASSIGN_ALIGNED_PTRS_HBD(pred_buf[1], cm->ncobmcaw_buf[1], MAX_SB_SQUARE, - len); - ASSIGN_ALIGNED_PTRS_HBD(pred_buf[2], cm->ncobmcaw_buf[2], MAX_SB_SQUARE, - len); - ASSIGN_ALIGNED_PTRS_HBD(pred_buf[3], cm->ncobmcaw_buf[3], MAX_SB_SQUARE, - len); + dst_buf1[0] = CONVERT_TO_BYTEPTR(tmp_buf1); + dst_buf1[1] = CONVERT_TO_BYTEPTR(tmp_buf1 + MAX_SB_SQUARE * len); + dst_buf1[2] = CONVERT_TO_BYTEPTR(tmp_buf1 + MAX_SB_SQUARE * 2 * len); + dst_buf2[0] = CONVERT_TO_BYTEPTR(tmp_buf2); + dst_buf2[1] = CONVERT_TO_BYTEPTR(tmp_buf2 + MAX_SB_SQUARE * len); + dst_buf2[2] = CONVERT_TO_BYTEPTR(tmp_buf2 + MAX_SB_SQUARE * 2 * len); } else { -#endif // CONFIG_HIGHBITDEPTH - ASSIGN_ALIGNED_PTRS(pred_buf[0], cm->ncobmcaw_buf[0], MAX_SB_SQUARE); - ASSIGN_ALIGNED_PTRS(pred_buf[1], cm->ncobmcaw_buf[1], MAX_SB_SQUARE); - ASSIGN_ALIGNED_PTRS(pred_buf[2], cm->ncobmcaw_buf[2], MAX_SB_SQUARE); - ASSIGN_ALIGNED_PTRS(pred_buf[3], cm->ncobmcaw_buf[3], MAX_SB_SQUARE); -#if CONFIG_HIGHBITDEPTH - } -#endif - av1_get_ext_blk_preds(cm, xd, bsize, mi_row, mi_col, pred_buf, pred_stride); - av1_get_ori_blk_pred(cm, xd, bsize, mi_row, mi_col, pred_buf[3], pred_stride); - for (plane = 0; plane < MAX_MB_PLANE; ++plane) { - build_ncobmc_intrpl_pred(cm, xd, plane, pxl_row, pxl_col, bsize, pred_buf, - pred_stride, mode); + dst_buf1[0] = tmp_buf1; + dst_buf1[1] = tmp_buf1 + MAX_SB_SQUARE; + dst_buf1[2] = tmp_buf1 + MAX_SB_SQUARE * 2; + dst_buf2[0] = tmp_buf2; + dst_buf2[1] = tmp_buf2 + MAX_SB_SQUARE; + dst_buf2[2] = tmp_buf2 + MAX_SB_SQUARE * 2; + } + dec_build_prediction_by_above_preds(cm, xd, mi_row, mi_col, dst_buf1, + dst_width1, dst_height1, dst_stride1); + dec_build_prediction_by_left_preds(cm, xd, mi_row, mi_col, dst_buf2, + dst_width2, dst_height2, dst_stride2); + av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type, get_frame_new_buffer(cm), + mi_row, mi_col, 0, num_planes); + av1_build_obmc_inter_prediction(cm, xd, mi_row, mi_col, 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 av1_get_ncobmc_recon(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int bsize, const int mi_row, const int mi_col, - const NCOBMC_MODE modes) { - const int mi_width = mi_size_wide[bsize]; - const int mi_height = mi_size_high[bsize]; +static void predict_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd, + int mi_row, int mi_col, BLOCK_SIZE bsize) { + MB_MODE_INFO *mbmi = xd->mi[0]; + const int num_planes = av1_num_planes(cm); + 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 { + RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME]; - assert(bsize >= BLOCK_8X8); + xd->block_refs[ref] = ref_buf; + av1_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col, &ref_buf->sf, + num_planes); + } + } - reset_xd_boundary(xd, mi_row, mi_height, mi_col, mi_width, cm->mi_rows, - cm->mi_cols); - get_ncobmc_recon(cm, xd, mi_row, mi_col, bsize, modes); + 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, mi_row, mi_col); } -static void recon_ncobmc_intrpl_pred(AV1_COMMON *const cm, - MACROBLOCKD *const xd, int mi_row, - int mi_col, BLOCK_SIZE bsize) { - MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; - const int mi_width = mi_size_wide[bsize]; - const int mi_height = mi_size_high[bsize]; - const int hbs = AOMMAX(mi_size_wide[bsize] / 2, mi_size_high[bsize] / 2); - const BLOCK_SIZE sqr_blk = bsize_2_sqr_bsize[bsize]; - if (mi_width > mi_height) { - // horizontal partition - av1_get_ncobmc_recon(cm, xd, sqr_blk, mi_row, mi_col, mbmi->ncobmc_mode[0]); - xd->mi += hbs; - av1_get_ncobmc_recon(cm, xd, sqr_blk, mi_row, mi_col + hbs, - mbmi->ncobmc_mode[1]); - } else if (mi_height > mi_width) { - // vertical partition - av1_get_ncobmc_recon(cm, xd, sqr_blk, mi_row, mi_col, mbmi->ncobmc_mode[0]); - xd->mi += hbs * xd->mi_stride; - av1_get_ncobmc_recon(cm, xd, sqr_blk, mi_row + hbs, mi_col, - mbmi->ncobmc_mode[1]); - } else { - av1_get_ncobmc_recon(cm, xd, sqr_blk, mi_row, mi_col, mbmi->ncobmc_mode[0]); - } - set_mode_info_offsets(cm, xd, mi_row, mi_col); - // restore dst buffer and mode info - av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row, - mi_col); +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, ¶ms.plane_width, + ¶ms.plane_height, NULL, NULL); + xd->color_index_map_offset[plane] += params.plane_width * params.plane_height; } -#endif // CONFIG_NCOBMC_ADAPT_WEIGHT static void decode_token_and_recon_block(AV1Decoder *const pbi, MACROBLOCKD *const xd, int mi_row, int mi_col, aom_reader *r, BLOCK_SIZE bsize) { AV1_COMMON *const cm = &pbi->common; + const int num_planes = av1_num_planes(cm); 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); set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis); - MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; -#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 - CFL_CTX *const cfl = xd->cfl; + MB_MODE_INFO *mbmi = xd->mi[0]; + CFL_CTX *const cfl = &xd->cfl; cfl->is_chroma_reference = is_chroma_reference( mi_row, mi_col, bsize, cfl->subsampling_x, cfl->subsampling_y); -#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 if (cm->delta_q_present_flag) { - int i; - for (i = 0; i < MAX_SEGMENTS; i++) { -#if CONFIG_EXT_DELTA_Q + for (int i = 0; i < MAX_SEGMENTS; i++) { const int current_qindex = av1_get_qindex(&cm->seg, i, xd->current_qindex); -#else - const int current_qindex = xd->current_qindex; -#endif // CONFIG_EXT_DELTA_Q - int j; - for (j = 0; j < MAX_MB_PLANE; ++j) { - const int dc_delta_q = j == 0 ? cm->y_dc_delta_q : cm->uv_dc_delta_q; - const int ac_delta_q = j == 0 ? 0 : cm->uv_ac_delta_q; - - xd->plane[j].seg_dequant[i][0] = - av1_dc_quant(current_qindex, dc_delta_q, cm->bit_depth); - xd->plane[j].seg_dequant[i][1] = - av1_ac_quant(current_qindex, ac_delta_q, cm->bit_depth); + 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, cm->bit_depth); + xd->plane[j].seg_dequant_QTX[i][1] = + av1_ac_quant_QTX(current_qindex, ac_delta_q, cm->bit_depth); } } } + if (mbmi->skip) av1_reset_skip_context(xd, mi_row, mi_col, bsize, num_planes); -#if CONFIG_CB4X4 - if (mbmi->skip) av1_reset_skip_context(xd, mi_row, mi_col, bsize); -#else - if (mbmi->skip) { - av1_reset_skip_context(xd, mi_row, mi_col, AOMMAX(BLOCK_8X8, bsize)); - } -#endif - -#if CONFIG_COEF_INTERLEAVE - { - const struct macroblockd_plane *const pd_y = &xd->plane[0]; - const struct macroblockd_plane *const pd_c = &xd->plane[1]; - const TX_SIZE tx_log2_y = mbmi->tx_size; - const TX_SIZE tx_log2_c = av1_get_uv_tx_size(mbmi, pd_c); - const int tx_sz_y = (1 << tx_log2_y); - const int tx_sz_c = (1 << tx_log2_c); - const int num_4x4_w_y = pd_y->n4_w; - const int num_4x4_h_y = pd_y->n4_h; - const int num_4x4_w_c = pd_c->n4_w; - const int num_4x4_h_c = pd_c->n4_h; - const int max_4x4_w_y = get_max_4x4_size(num_4x4_w_y, xd->mb_to_right_edge, - pd_y->subsampling_x); - const int max_4x4_h_y = get_max_4x4_size(num_4x4_h_y, xd->mb_to_bottom_edge, - pd_y->subsampling_y); - const int max_4x4_w_c = get_max_4x4_size(num_4x4_w_c, xd->mb_to_right_edge, - pd_c->subsampling_x); - const int max_4x4_h_c = get_max_4x4_size(num_4x4_h_c, xd->mb_to_bottom_edge, - pd_c->subsampling_y); - - // The max_4x4_w/h may be smaller than tx_sz under some corner cases, - // i.e. when the SB is splitted by tile boundaries. - const int tu_num_w_y = (max_4x4_w_y + tx_sz_y - 1) / tx_sz_y; - const int tu_num_h_y = (max_4x4_h_y + tx_sz_y - 1) / tx_sz_y; - const int tu_num_w_c = (max_4x4_w_c + tx_sz_c - 1) / tx_sz_c; - const int tu_num_h_c = (max_4x4_h_c + tx_sz_c - 1) / tx_sz_c; - const int tu_num_c = tu_num_w_c * tu_num_h_c; - - if (!is_inter_block(mbmi)) { - int tu_idx_c = 0; - int row_y, col_y, row_c, col_c; - int plane; - -// TODO(anybody) : remove this flag when PVQ supports pallete coding tool -#if !CONFIG_PVQ - for (plane = 0; plane <= 1; ++plane) { - if (mbmi->palette_mode_info.palette_size[plane]) - av1_decode_palette_tokens(xd, plane, r); - } -#endif // !CONFIG_PVQ - - for (row_y = 0; row_y < tu_num_h_y; row_y++) { - for (col_y = 0; col_y < tu_num_w_y; col_y++) { - // luma - predict_and_reconstruct_intra_block( - cm, xd, r, mbmi, 0, row_y * tx_sz_y, col_y * tx_sz_y, tx_log2_y); - // chroma - if (tu_idx_c < tu_num_c) { - row_c = (tu_idx_c / tu_num_w_c) * tx_sz_c; - col_c = (tu_idx_c % tu_num_w_c) * tx_sz_c; - predict_and_reconstruct_intra_block(cm, xd, r, mbmi, 1, row_c, - col_c, tx_log2_c); - predict_and_reconstruct_intra_block(cm, xd, r, mbmi, 2, row_c, - col_c, tx_log2_c); - tu_idx_c++; - } - } - } - - // In 422 case, it's possilbe that Chroma has more TUs than Luma - while (tu_idx_c < tu_num_c) { - row_c = (tu_idx_c / tu_num_w_c) * tx_sz_c; - col_c = (tu_idx_c % tu_num_w_c) * tx_sz_c; - predict_and_reconstruct_intra_block(cm, xd, r, mbmi, 1, row_c, col_c, - tx_log2_c); - predict_and_reconstruct_intra_block(cm, xd, r, mbmi, 2, row_c, col_c, - tx_log2_c); - tu_idx_c++; - } - } else { - // Prediction - av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, - AOMMAX(bsize, BLOCK_8X8)); - - // Reconstruction - if (!mbmi->skip) { - int eobtotal = 0; - int tu_idx_c = 0; - int row_y, col_y, row_c, col_c; - - for (row_y = 0; row_y < tu_num_h_y; row_y++) { - for (col_y = 0; col_y < tu_num_w_y; col_y++) { - // luma - eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id, 0, - row_y * tx_sz_y, - col_y * tx_sz_y, tx_log2_y); - // chroma - if (tu_idx_c < tu_num_c) { - row_c = (tu_idx_c / tu_num_w_c) * tx_sz_c; - col_c = (tu_idx_c % tu_num_w_c) * tx_sz_c; - eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id, - 1, row_c, col_c, tx_log2_c); - eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id, - 2, row_c, col_c, tx_log2_c); - tu_idx_c++; + if (!is_inter_block(mbmi)) { + 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 = + 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 (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, + pd->subsampling_y)) + 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 int unit_height = ROUND_POWER_OF_TWO( + AOMMIN(mu_blocks_high + row, max_blocks_high), pd->subsampling_y); + const int unit_width = ROUND_POWER_OF_TWO( + AOMMIN(mu_blocks_wide + col, max_blocks_wide), pd->subsampling_x); + + for (int blk_row = row >> pd->subsampling_y; blk_row < unit_height; + blk_row += stepr) { + for (int blk_col = col >> pd->subsampling_x; blk_col < unit_width; + blk_col += stepc) { + read_coeffs_tx_intra_block(cm, xd, r, plane, blk_row, blk_col, + tx_size); + predict_and_reconstruct_intra_block(cm, xd, r, plane, blk_row, + blk_col, tx_size); + set_cb_buffer_offsets(xd, tx_size, plane); } } } - - // In 422 case, it's possilbe that Chroma has more TUs than Luma - while (tu_idx_c < tu_num_c) { - row_c = (tu_idx_c / tu_num_w_c) * tx_sz_c; - col_c = (tu_idx_c % tu_num_w_c) * tx_sz_c; - eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id, 1, - row_c, col_c, tx_log2_c); - eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id, 2, - row_c, col_c, tx_log2_c); - tu_idx_c++; - } - - // TODO(CONFIG_COEF_INTERLEAVE owners): bring eob == 0 corner case - // into line with the defaut configuration - if (bsize >= BLOCK_8X8 && eobtotal == 0) mbmi->skip = 1; } } - } -#else // CONFIG_COEF_INTERLEAVE - if (!is_inter_block(mbmi)) { - int plane; - -// TODO(anybody) : remove this flag when PVQ supports pallete coding tool -#if !CONFIG_PVQ - for (plane = 0; plane <= 1; ++plane) { - if (mbmi->palette_mode_info.palette_size[plane]) - av1_decode_palette_tokens(xd, plane, r); - } -#endif // #if !CONFIG_PVQ - - for (plane = 0; plane < MAX_MB_PLANE; ++plane) { - const struct macroblockd_plane *const pd = &xd->plane[plane]; - 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]; -#if CONFIG_CHROMA_SUB8X8 - const BLOCK_SIZE plane_bsize = - AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd)); -#elif CONFIG_CB4X4 - const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); -#else - const BLOCK_SIZE plane_bsize = - get_plane_block_size(AOMMAX(BLOCK_8X8, bsize), pd); -#endif - int row, col; - const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); - const int max_blocks_high = max_block_high(xd, plane_bsize, plane); -#if CONFIG_CB4X4 + } else { + predict_inter_block(cm, xd, mi_row, mi_col, bsize); +#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 (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, pd->subsampling_y)) continue; + mismatch_check_block_pre(pd->dst.buf, pd->dst.stride, cm->frame_offset, + plane, pixel_c, pixel_r, pd->width, pd->height, + xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH); + } #endif - int blk_row, blk_col; - const BLOCK_SIZE max_unit_bsize = get_plane_block_size(BLOCK_64X64, pd); + + // 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; + assert(max_unit_bsize == + get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x, + xd->plane[0].subsampling_y)); int mu_blocks_wide = block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0]; int mu_blocks_high = 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) { - const int unit_height = AOMMIN(mu_blocks_high + row, max_blocks_high); for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) { - const int unit_width = AOMMIN(mu_blocks_wide + col, max_blocks_wide); - - for (blk_row = row; blk_row < unit_height; blk_row += stepr) - for (blk_col = col; blk_col < unit_width; blk_col += stepc) - predict_and_reconstruct_intra_block(cm, xd, r, mbmi, plane, - blk_row, blk_col, tx_size); - } - } - } - } else { - int ref; - -#if CONFIG_COMPOUND_SINGLEREF - for (ref = 0; ref < 1 + is_inter_anyref_comp_mode(mbmi->mode); ++ref) -#else - for (ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) -#endif // CONFIG_COMPOUND_SINGLEREF - { - const MV_REFERENCE_FRAME frame = -#if CONFIG_COMPOUND_SINGLEREF - has_second_ref(mbmi) ? mbmi->ref_frame[ref] : mbmi->ref_frame[0]; -#else - mbmi->ref_frame[ref]; -#endif // CONFIG_COMPOUND_SINGLEREF - if (frame < LAST_FRAME) { -#if CONFIG_INTRABC - assert(is_intrabc_block(mbmi)); - assert(frame == INTRA_FRAME); - assert(ref == 0); -#else - assert(0); -#endif // CONFIG_INTRABC - } else { - RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME]; - - xd->block_refs[ref] = ref_buf; - if ((!av1_is_valid_scale(&ref_buf->sf))) - aom_internal_error(xd->error_info, AOM_CODEC_UNSUP_BITSTREAM, - "Reference frame has invalid dimensions"); - av1_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col, - &ref_buf->sf); - } - } - -#if CONFIG_CB4X4 - av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, bsize); -#else - av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, NULL, - AOMMAX(bsize, BLOCK_8X8)); -#endif - -#if CONFIG_MOTION_VAR - if (mbmi->motion_mode == OBMC_CAUSAL) { -#if CONFIG_NCOBMC - av1_build_ncobmc_inter_predictors_sb(cm, xd, mi_row, mi_col); -#else - av1_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col); -#endif - } -#endif // CONFIG_MOTION_VAR -#if CONFIG_NCOBMC_ADAPT_WEIGHT - if (mbmi->motion_mode == NCOBMC_ADAPT_WEIGHT) { - int plane; - recon_ncobmc_intrpl_pred(cm, xd, mi_row, mi_col, bsize); - for (plane = 0; plane < MAX_MB_PLANE; ++plane) { - get_pred_from_intrpl_buf(xd, mi_row, mi_col, bsize, plane); - } - } -#endif - // Reconstruction - if (!mbmi->skip) { - int eobtotal = 0; - int plane; - - for (plane = 0; plane < MAX_MB_PLANE; ++plane) { - const struct macroblockd_plane *const pd = &xd->plane[plane]; -#if CONFIG_CHROMA_SUB8X8 - const BLOCK_SIZE plane_bsize = - AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd)); -#elif CONFIG_CB4X4 - const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); -#else - const BLOCK_SIZE plane_bsize = - get_plane_block_size(AOMMAX(BLOCK_8X8, bsize), pd); -#endif - const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); - const int max_blocks_high = max_block_high(xd, plane_bsize, plane); - int row, col; - -#if CONFIG_CB4X4 - if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, - pd->subsampling_y)) - continue; -#endif - -#if CONFIG_VAR_TX - const BLOCK_SIZE max_unit_bsize = get_plane_block_size(BLOCK_64X64, pd); - 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); - - const TX_SIZE max_tx_size = get_vartx_max_txsize( - mbmi, plane_bsize, pd->subsampling_x || pd->subsampling_y); - const int bh_var_tx = tx_size_high_unit[max_tx_size]; - const int bw_var_tx = tx_size_wide_unit[max_tx_size]; - int block = 0; - int step = - tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size]; - - 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 (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, + pd->subsampling_y)) + continue; + const BLOCK_SIZE bsizec = + scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y); + const BLOCK_SIZE plane_bsize = get_plane_block_size( + bsizec, pd->subsampling_x, pd->subsampling_y); + + const TX_SIZE max_tx_size = + get_vartx_max_txsize(xd, plane_bsize, plane); + const int bh_var_tx = tx_size_high_unit[max_tx_size]; + const int bw_var_tx = tx_size_wide_unit[max_tx_size]; + int block = 0; + int step = + tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size]; int blk_row, blk_col; - const int unit_height = - AOMMIN(mu_blocks_high + row, max_blocks_high); - const int unit_width = - AOMMIN(mu_blocks_wide + col, max_blocks_wide); - for (blk_row = row; blk_row < unit_height; blk_row += bh_var_tx) { - for (blk_col = col; blk_col < unit_width; blk_col += bw_var_tx) { + const int unit_height = ROUND_POWER_OF_TWO( + AOMMIN(mu_blocks_high + row, max_blocks_high), + pd->subsampling_y); + const int unit_width = ROUND_POWER_OF_TWO( + AOMMIN(mu_blocks_wide + col, max_blocks_wide), + pd->subsampling_x); + + for (blk_row = row >> pd->subsampling_y; blk_row < unit_height; + blk_row += bh_var_tx) { + for (blk_col = col >> pd->subsampling_x; blk_col < unit_width; + blk_col += bw_var_tx) { decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, blk_row, blk_col, block, max_tx_size, &eobtotal); @@ -2083,388 +1221,291 @@ static void decode_token_and_recon_block(AV1Decoder *const pbi, } } } -#else - 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]; - for (row = 0; row < max_blocks_high; row += stepr) - for (col = 0; col < max_blocks_wide; col += stepc) - eobtotal += reconstruct_inter_block(cm, xd, r, mbmi->segment_id, - plane, row, col, tx_size); -#endif } } + cfl_store_inter_block(cm, xd); } -#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 - if (mbmi->uv_mode != UV_CFL_PRED) { -#if CONFIG_DEBUG - if (cfl->is_chroma_reference) { - cfl_clear_sub8x8_val(cfl); - } -#endif - if (!cfl->is_chroma_reference && is_inter_block(mbmi)) { - cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size); - } - } -#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 -#endif // CONFIG_COEF_INTERLEAVE + + av1_visit_palette(pbi, xd, mi_row, mi_col, r, bsize, + set_color_index_map_offset); int reader_corrupted_flag = aom_reader_has_error(r); aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag); } -#if NC_MODE_INFO && CONFIG_MOTION_VAR -static void detoken_and_recon_sb(AV1Decoder *const pbi, MACROBLOCKD *const xd, - int mi_row, int mi_col, aom_reader *r, - BLOCK_SIZE bsize) { - AV1_COMMON *const cm = &pbi->common; - const int hbs = mi_size_wide[bsize] >> 1; -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif -#if CONFIG_EXT_PARTITION_TYPES - BLOCK_SIZE bsize2 = get_subsize(bsize, PARTITION_SPLIT); -#endif - PARTITION_TYPE partition; - BLOCK_SIZE subsize; - const int has_rows = (mi_row + hbs) < cm->mi_rows; - const int has_cols = (mi_col + hbs) < cm->mi_cols; +static void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, + TX_SIZE tx_size, int depth, 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); + + if (depth == MAX_VARTX_DEPTH) { + for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) { + for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) { + const int index = + av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx); + mbmi->inter_tx_size[index] = tx_size; + } + } + 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; + } - if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) 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); - partition = get_partition(cm, mi_row, mi_col, bsize); - subsize = subsize_lookup[partition][bsize]; + 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) { + for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) { + for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) { + const int index = + av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx); + mbmi->inter_tx_size[index] = sub_txs; + } + } + mbmi->tx_size = sub_txs; + txfm_partition_update(xd->above_txfm_context + blk_col, + xd->left_txfm_context + blk_row, sub_txs, tx_size); + return; + } - if (!hbs && !unify_bsize) { - xd->bmode_blocks_wl = 1 >> !!(partition & PARTITION_VERT); - xd->bmode_blocks_hl = 1 >> !!(partition & PARTITION_HORZ); - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize); + 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, offsetr, offsetc, r); + } + } } else { - switch (partition) { - case PARTITION_NONE: - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize); - break; - case PARTITION_HORZ: - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize); - if (has_rows) - decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, - subsize); - break; - case PARTITION_VERT: - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize); - if (has_cols) - decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, - subsize); - break; - case PARTITION_SPLIT: - detoken_and_recon_sb(pbi, xd, mi_row, mi_col, r, subsize); - detoken_and_recon_sb(pbi, xd, mi_row, mi_col + hbs, r, subsize); - detoken_and_recon_sb(pbi, xd, mi_row + hbs, mi_col, r, subsize); - detoken_and_recon_sb(pbi, xd, mi_row + hbs, mi_col + hbs, r, subsize); - break; -#if CONFIG_EXT_PARTITION_TYPES -#if CONFIG_EXT_PARTITION_TYPES_AB -#error NC_MODE_INFO+MOTION_VAR not yet supported for new HORZ/VERT_AB partitions -#endif - case PARTITION_HORZ_A: - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize2); - decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, bsize2); - decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, subsize); - break; - case PARTITION_HORZ_B: - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize); - decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, bsize2); - decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col + hbs, r, - bsize2); - break; - case PARTITION_VERT_A: - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize2); - decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col, r, bsize2); - decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, subsize); - break; - case PARTITION_VERT_B: - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, subsize); - decode_token_and_recon_block(pbi, xd, mi_row, mi_col + hbs, r, bsize2); - decode_token_and_recon_block(pbi, xd, mi_row + hbs, mi_col + hbs, r, - bsize2); - break; -#endif - default: assert(0 && "Invalid partition type"); + for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) { + for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) { + const int index = + av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx); + mbmi->inter_tx_size[index] = tx_size; + } } + mbmi->tx_size = tx_size; + txfm_partition_update(xd->above_txfm_context + blk_col, + xd->left_txfm_context + blk_row, tx_size, tx_size); + } +} + +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; +} + +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) { + const TX_SIZE coded_tx_size = read_selected_tx_size(xd, r); + return coded_tx_size; + } 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]; } } -#endif static void decode_block(AV1Decoder *const pbi, MACROBLOCKD *const xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif // CONFIG_SUPERTX int mi_row, int mi_col, aom_reader *r, -#if CONFIG_EXT_PARTITION_TYPES - PARTITION_TYPE partition, -#endif // CONFIG_EXT_PARTITION_TYPES - BLOCK_SIZE bsize) { - decode_mbmi_block(pbi, xd, -#if CONFIG_SUPERTX - supertx_enabled, -#endif - mi_row, mi_col, r, -#if CONFIG_EXT_PARTITION_TYPES - partition, -#endif - bsize); + PARTITION_TYPE partition, BLOCK_SIZE bsize) { + decode_mbmi_block(pbi, xd, mi_row, mi_col, r, partition, bsize); + + av1_visit_palette(pbi, xd, mi_row, mi_col, r, bsize, + av1_decode_palette_tokens); + + AV1_COMMON *cm = &pbi->common; + 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) + read_tx_size_vartx(xd, mbmi, max_tx_size, 0, idy, idx, r); + } else { + mbmi->tx_size = read_tx_size(cm, xd, inter_block_tx, !mbmi->skip, 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->n8_w, xd->n8_h, + mbmi->skip && is_inter_block(mbmi), xd); + } -#if !(CONFIG_MOTION_VAR && NC_MODE_INFO) -#if CONFIG_SUPERTX - if (!supertx_enabled) -#endif // CONFIG_SUPERTX - decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize); -#endif + decode_token_and_recon_block(pbi, xd, mi_row, mi_col, r, bsize); } -static PARTITION_TYPE read_partition(AV1_COMMON *cm, MACROBLOCKD *xd, - int mi_row, int mi_col, aom_reader *r, - int has_rows, int has_cols, +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 CONFIG_UNPOISON_PARTITION_CTX - const int ctx = - partition_plane_context(xd, mi_row, mi_col, has_rows, has_cols, bsize); -#else const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize); -#endif - PARTITION_TYPE p; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; - aom_cdf_prob *partition_cdf = (ctx >= 0) ? ec_ctx->partition_cdf[ctx] : NULL; + 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) { -#if CONFIG_EXT_PARTITION_TYPES - const int num_partition_types = - (mi_width_log2_lookup[bsize] > mi_width_log2_lookup[BLOCK_8X8]) - ? EXT_PARTITION_TYPES - : PARTITION_TYPES; -#else - const int num_partition_types = PARTITION_TYPES; -#endif // CONFIG_EXT_PARTITION_TYPES - p = (PARTITION_TYPE)aom_read_symbol(r, partition_cdf, num_partition_types, - ACCT_STR); + 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); + partition_gather_vert_alike(cdf, partition_cdf, bsize); assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP)); - p = aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ; - // gather cols - } else if (has_rows && !has_cols) { + 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); + partition_gather_horz_alike(cdf, partition_cdf, bsize); assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP)); - p = aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT; - } else { - p = PARTITION_SPLIT; + return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT; } - - return p; } -#if CONFIG_SUPERTX -static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id, - aom_reader *r) { - if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) { - return 1; - } else { - const int ctx = av1_get_skip_context(xd); -#if CONFIG_NEW_MULTISYMBOL - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - const int skip = aom_read_symbol(r, ec_ctx->skip_cdfs[ctx], 2, ACCT_STR); -#else - const int skip = aom_read(r, cm->fc->skip_probs[ctx], ACCT_STR); -#endif - FRAME_COUNTS *counts = xd->counts; - if (counts) ++counts->skip[ctx][skip]; - return skip; - } -} -#endif // CONFIG_SUPERTX - // TODO(slavarnway): eliminate bsize and subsize in future commits static void decode_partition(AV1Decoder *const pbi, MACROBLOCKD *const xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif int mi_row, int mi_col, aom_reader *r, BLOCK_SIZE bsize) { AV1_COMMON *const cm = &pbi->common; - const int num_8x8_wh = mi_size_wide[bsize]; - const int hbs = num_8x8_wh >> 1; -#if CONFIG_EXT_PARTITION_TYPES && CONFIG_EXT_PARTITION_TYPES_AB - const int qbs = num_8x8_wh >> 2; -#endif -#if CONFIG_CB4X4 - const int unify_bsize = 1; -#else - const int unify_bsize = 0; -#endif + const int bw = mi_size_wide[bsize]; + const int hbs = bw >> 1; PARTITION_TYPE partition; BLOCK_SIZE subsize; -#if CONFIG_EXT_PARTITION_TYPES - const int quarter_step = num_8x8_wh / 4; - int i; -#if !CONFIG_EXT_PARTITION_TYPES_AB - BLOCK_SIZE bsize2 = get_subsize(bsize, PARTITION_SPLIT); -#endif -#endif + const int quarter_step = bw / 4; + BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT); const int has_rows = (mi_row + hbs) < cm->mi_rows; const int has_cols = (mi_col + hbs) < cm->mi_cols; -#if CONFIG_SUPERTX - const int read_token = !supertx_enabled; - int skip = 0; - TX_SIZE supertx_size = max_txsize_lookup[bsize]; - const TileInfo *const tile = &xd->tile; - int txfm = DCT_DCT; -#endif // CONFIG_SUPERTX if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) return; + const int num_planes = av1_num_planes(cm); + for (int plane = 0; plane < num_planes; ++plane) { + int rcol0, rcol1, rrow0, rrow1, tile_tl_idx; + if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize, + &rcol0, &rcol1, &rrow0, &rrow1, + &tile_tl_idx)) { + const int rstride = cm->rst_info[plane].horz_units_per_tile; + for (int rrow = rrow0; rrow < rrow1; ++rrow) { + for (int rcol = rcol0; rcol < rcol1; ++rcol) { + const int runit_idx = tile_tl_idx + rcol + rrow * rstride; + loop_restoration_read_sb_coeffs(cm, xd, r, plane, runit_idx); + } + } + } + } + partition = (bsize < BLOCK_8X8) ? PARTITION_NONE - : read_partition(cm, xd, mi_row, mi_col, r, + : read_partition(xd, mi_row, mi_col, r, has_rows, has_cols, bsize); - subsize = subsize_lookup[partition][bsize]; // get_subsize(bsize, partition); + subsize = get_partition_subsize(bsize, 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]; - if (get_plane_block_size(subsize, pd_u) == BLOCK_INVALID) { + if (get_plane_block_size(subsize, pd_u->subsampling_x, pd_u->subsampling_y) == + BLOCK_INVALID) { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Block size %dx%d invalid with this subsampling mode", block_size_wide[subsize], block_size_high[subsize]); } -#if CONFIG_PVQ - assert(partition < PARTITION_TYPES); - assert(subsize < BLOCK_SIZES_ALL); -#endif -#if CONFIG_SUPERTX - if (!frame_is_intra_only(cm) && partition != PARTITION_NONE && - bsize <= MAX_SUPERTX_BLOCK_SIZE && !supertx_enabled && !xd->lossless[0]) { - const int supertx_context = partition_supertx_context_lookup[partition]; - supertx_enabled = aom_read( - r, cm->fc->supertx_prob[supertx_context][supertx_size], ACCT_STR); - if (xd->counts) - xd->counts->supertx[supertx_context][supertx_size][supertx_enabled]++; -#if CONFIG_VAR_TX - if (supertx_enabled) xd->supertx_size = supertx_size; -#endif - } -#endif // CONFIG_SUPERTX - -#if CONFIG_SUPERTX -#define DEC_BLOCK_STX_ARG supertx_enabled, -#else #define DEC_BLOCK_STX_ARG -#endif -#if CONFIG_EXT_PARTITION_TYPES #define DEC_BLOCK_EPT_ARG partition, -#else -#define DEC_BLOCK_EPT_ARG -#endif #define DEC_BLOCK(db_r, db_c, db_subsize) \ decode_block(pbi, xd, DEC_BLOCK_STX_ARG(db_r), (db_c), r, \ DEC_BLOCK_EPT_ARG(db_subsize)) #define DEC_PARTITION(db_r, db_c, db_subsize) \ decode_partition(pbi, xd, DEC_BLOCK_STX_ARG(db_r), (db_c), r, (db_subsize)) - if (!hbs && !unify_bsize) { - // calculate bmode block dimensions (log 2) - xd->bmode_blocks_wl = 1 >> !!(partition & PARTITION_VERT); - xd->bmode_blocks_hl = 1 >> !!(partition & PARTITION_HORZ); - DEC_BLOCK(mi_row, mi_col, subsize); - } else { - switch (partition) { - case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize); break; - case PARTITION_HORZ: - DEC_BLOCK(mi_row, mi_col, subsize); - if (has_rows) DEC_BLOCK(mi_row + hbs, mi_col, subsize); - break; - case PARTITION_VERT: - DEC_BLOCK(mi_row, mi_col, subsize); - if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs, subsize); - break; - case PARTITION_SPLIT: - DEC_PARTITION(mi_row, mi_col, subsize); - DEC_PARTITION(mi_row, mi_col + hbs, subsize); - DEC_PARTITION(mi_row + hbs, mi_col, subsize); - DEC_PARTITION(mi_row + hbs, mi_col + hbs, subsize); - break; -#if CONFIG_EXT_PARTITION_TYPES -#if CONFIG_EXT_PARTITION_TYPES_AB - case PARTITION_HORZ_A: - DEC_BLOCK(mi_row, mi_col, get_subsize(bsize, PARTITION_HORZ_4)); - DEC_BLOCK(mi_row + qbs, mi_col, get_subsize(bsize, PARTITION_HORZ_4)); - DEC_BLOCK(mi_row + hbs, mi_col, subsize); - break; - case PARTITION_HORZ_B: - DEC_BLOCK(mi_row, mi_col, subsize); - DEC_BLOCK(mi_row + hbs, mi_col, get_subsize(bsize, PARTITION_HORZ_4)); - if (mi_row + 3 * qbs < cm->mi_rows) - DEC_BLOCK(mi_row + 3 * qbs, mi_col, - get_subsize(bsize, PARTITION_HORZ_4)); - break; - case PARTITION_VERT_A: - DEC_BLOCK(mi_row, mi_col, get_subsize(bsize, PARTITION_VERT_4)); - DEC_BLOCK(mi_row, mi_col + qbs, get_subsize(bsize, PARTITION_VERT_4)); - DEC_BLOCK(mi_row, mi_col + hbs, subsize); - break; - case PARTITION_VERT_B: - DEC_BLOCK(mi_row, mi_col, subsize); - DEC_BLOCK(mi_row, mi_col + hbs, get_subsize(bsize, PARTITION_VERT_4)); - if (mi_col + 3 * qbs < cm->mi_cols) - DEC_BLOCK(mi_row, mi_col + 3 * qbs, - get_subsize(bsize, PARTITION_VERT_4)); - break; -#else - case PARTITION_HORZ_A: - DEC_BLOCK(mi_row, mi_col, bsize2); - DEC_BLOCK(mi_row, mi_col + hbs, bsize2); - DEC_BLOCK(mi_row + hbs, mi_col, subsize); - break; - case PARTITION_HORZ_B: - DEC_BLOCK(mi_row, mi_col, subsize); - DEC_BLOCK(mi_row + hbs, mi_col, bsize2); - DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2); - break; - case PARTITION_VERT_A: - DEC_BLOCK(mi_row, mi_col, bsize2); - DEC_BLOCK(mi_row + hbs, mi_col, bsize2); - DEC_BLOCK(mi_row, mi_col + hbs, subsize); - break; - case PARTITION_VERT_B: - DEC_BLOCK(mi_row, mi_col, subsize); - DEC_BLOCK(mi_row, mi_col + hbs, bsize2); - DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2); - break; -#endif - case PARTITION_HORZ_4: - for (i = 0; i < 4; ++i) { - int this_mi_row = mi_row + i * quarter_step; - if (i > 0 && this_mi_row >= cm->mi_rows) break; - DEC_BLOCK(this_mi_row, mi_col, subsize); - } - break; - case PARTITION_VERT_4: - for (i = 0; i < 4; ++i) { - int this_mi_col = mi_col + i * quarter_step; - if (i > 0 && this_mi_col >= cm->mi_cols) break; - DEC_BLOCK(mi_row, this_mi_col, subsize); - } - break; -#endif // CONFIG_EXT_PARTITION_TYPES - default: assert(0 && "Invalid partition type"); - } + switch (partition) { + case PARTITION_NONE: DEC_BLOCK(mi_row, mi_col, subsize); break; + case PARTITION_HORZ: + DEC_BLOCK(mi_row, mi_col, subsize); + if (has_rows) DEC_BLOCK(mi_row + hbs, mi_col, subsize); + break; + case PARTITION_VERT: + DEC_BLOCK(mi_row, mi_col, subsize); + if (has_cols) DEC_BLOCK(mi_row, mi_col + hbs, subsize); + break; + case PARTITION_SPLIT: + DEC_PARTITION(mi_row, mi_col, subsize); + DEC_PARTITION(mi_row, mi_col + hbs, subsize); + DEC_PARTITION(mi_row + hbs, mi_col, subsize); + DEC_PARTITION(mi_row + hbs, mi_col + hbs, subsize); + break; + case PARTITION_HORZ_A: + DEC_BLOCK(mi_row, mi_col, bsize2); + DEC_BLOCK(mi_row, mi_col + hbs, bsize2); + DEC_BLOCK(mi_row + hbs, mi_col, subsize); + break; + case PARTITION_HORZ_B: + DEC_BLOCK(mi_row, mi_col, subsize); + DEC_BLOCK(mi_row + hbs, mi_col, bsize2); + DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2); + break; + case PARTITION_VERT_A: + DEC_BLOCK(mi_row, mi_col, bsize2); + DEC_BLOCK(mi_row + hbs, mi_col, bsize2); + DEC_BLOCK(mi_row, mi_col + hbs, subsize); + break; + case PARTITION_VERT_B: + DEC_BLOCK(mi_row, mi_col, subsize); + DEC_BLOCK(mi_row, mi_col + hbs, bsize2); + DEC_BLOCK(mi_row + hbs, mi_col + hbs, bsize2); + break; + case PARTITION_HORZ_4: + for (int i = 0; i < 4; ++i) { + int this_mi_row = mi_row + i * quarter_step; + if (i > 0 && this_mi_row >= cm->mi_rows) break; + DEC_BLOCK(this_mi_row, mi_col, subsize); + } + break; + case PARTITION_VERT_4: + for (int i = 0; i < 4; ++i) { + int this_mi_col = mi_col + i * quarter_step; + if (i > 0 && this_mi_col >= cm->mi_cols) break; + DEC_BLOCK(mi_row, this_mi_col, subsize); + } + break; + default: assert(0 && "Invalid partition type"); } #undef DEC_PARTITION @@ -2472,219 +1513,13 @@ static void decode_partition(AV1Decoder *const pbi, MACROBLOCKD *const xd, #undef DEC_BLOCK_EPT_ARG #undef DEC_BLOCK_STX_ARG -#if CONFIG_SUPERTX - if (supertx_enabled && read_token) { - uint8_t *dst_buf[3]; - int dst_stride[3], i; - int offset = mi_row * cm->mi_stride + mi_col; - - set_segment_id_supertx(cm, mi_row, mi_col, bsize); - - if (cm->delta_q_present_flag) { - for (i = 0; i < MAX_SEGMENTS; i++) { - int j; - for (j = 0; j < MAX_MB_PLANE; ++j) { - const int dc_delta_q = j == 0 ? cm->y_dc_delta_q : cm->uv_dc_delta_q; - const int ac_delta_q = j == 0 ? 0 : cm->uv_ac_delta_q; - - xd->plane[j].seg_dequant[i][0] = - av1_dc_quant(xd->current_qindex, dc_delta_q, cm->bit_depth); - xd->plane[j].seg_dequant[i][1] = - av1_ac_quant(xd->current_qindex, ac_delta_q, cm->bit_depth); - } - } - } - - xd->mi = cm->mi_grid_visible + offset; - xd->mi[0] = cm->mi + offset; - set_mi_row_col(xd, tile, mi_row, mi_size_high[bsize], mi_col, - mi_size_wide[bsize], -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles, -#endif // CONFIG_DEPENDENT_HORZTILES - cm->mi_rows, cm->mi_cols); - set_skip_context(xd, mi_row, mi_col); - skip = read_skip(cm, xd, xd->mi[0]->mbmi.segment_id_supertx, r); - if (skip) { - av1_reset_skip_context(xd, mi_row, mi_col, bsize); - } else { - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; -#if CONFIG_EXT_TX - if (get_ext_tx_types(supertx_size, bsize, 1, cm->reduced_tx_set_used) > - 1) { - const int eset = - get_ext_tx_set(supertx_size, bsize, 1, cm->reduced_tx_set_used); - if (eset > 0) { - const TxSetType tx_set_type = get_ext_tx_set_type( - supertx_size, bsize, 1, cm->reduced_tx_set_used); - const int packed_sym = - aom_read_symbol(r, ec_ctx->inter_ext_tx_cdf[eset][supertx_size], - av1_num_ext_tx_set[tx_set_type], ACCT_STR); - txfm = av1_ext_tx_inv[tx_set_type][packed_sym]; -#if CONFIG_ENTROPY_STATS - if (xd->counts) ++xd->counts->inter_ext_tx[eset][supertx_size][txfm]; -#endif // CONFIG_ENTROPY_STATS - } - } -#else - if (supertx_size < TX_32X32) { - txfm = aom_read_symbol(r, ec_ctx->inter_ext_tx_cdf[supertx_size], - TX_TYPES, ACCT_STR); -#if CONFIG_ENTROPY_STATS - if (xd->counts) ++xd->counts->inter_ext_tx[supertx_size][txfm]; -#endif // CONFIG_ENTROPY_STATS - } -#endif // CONFIG_EXT_TX - } - - av1_setup_dst_planes(xd->plane, bsize, get_frame_new_buffer(cm), mi_row, - mi_col); - for (i = 0; i < MAX_MB_PLANE; i++) { - dst_buf[i] = xd->plane[i].dst.buf; - dst_stride[i] = xd->plane[i].dst.stride; - } - dec_predict_sb_complex(pbi, xd, tile, mi_row, mi_col, mi_row, mi_col, bsize, - bsize, dst_buf, dst_stride); - - if (!skip) { - int eobtotal = 0; - MB_MODE_INFO *mbmi; - set_offsets_topblock(cm, xd, tile, bsize, mi_row, mi_col); - mbmi = &xd->mi[0]->mbmi; - mbmi->tx_type = txfm; - assert(mbmi->segment_id_supertx != MAX_SEGMENTS); - for (i = 0; i < MAX_MB_PLANE; ++i) { - const struct macroblockd_plane *const pd = &xd->plane[i]; - int row, col; - const TX_SIZE tx_size = av1_get_tx_size(i, xd); - const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); - const int stepr = tx_size_high_unit[tx_size]; - const int stepc = tx_size_wide_unit[tx_size]; - const int max_blocks_wide = max_block_wide(xd, plane_bsize, i); - const int max_blocks_high = max_block_high(xd, plane_bsize, i); - - for (row = 0; row < max_blocks_high; row += stepr) - for (col = 0; col < max_blocks_wide; col += stepc) - eobtotal += reconstruct_inter_block( - cm, xd, r, mbmi->segment_id_supertx, i, row, col, tx_size); - } - if ((unify_bsize || !(subsize < BLOCK_8X8)) && eobtotal == 0) skip = 1; - } - set_param_topblock(cm, xd, bsize, mi_row, mi_col, txfm, skip); - } -#endif // CONFIG_SUPERTX - -#if CONFIG_EXT_PARTITION_TYPES update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition); -#else - // update partition context - if (bsize >= BLOCK_8X8 && - (bsize == BLOCK_8X8 || partition != PARTITION_SPLIT)) - update_partition_context(xd, mi_row, mi_col, subsize, bsize); -#endif // CONFIG_EXT_PARTITION_TYPES - -#if CONFIG_LPF_SB - if (bsize == cm->sb_size) { - int filt_lvl; - if (mi_row == 0 && mi_col == 0) { - filt_lvl = aom_read_literal(r, 6, ACCT_STR); - cm->mi_grid_visible[0]->mbmi.reuse_sb_lvl = 0; - cm->mi_grid_visible[0]->mbmi.delta = 0; - cm->mi_grid_visible[0]->mbmi.sign = 0; - } else { - int prev_mi_row, prev_mi_col; - if (mi_col - MAX_MIB_SIZE < 0) { - prev_mi_row = mi_row - MAX_MIB_SIZE; - prev_mi_col = mi_col; - } else { - prev_mi_row = mi_row; - prev_mi_col = mi_col - MAX_MIB_SIZE; - } - - MB_MODE_INFO *curr_mbmi = - &cm->mi_grid_visible[mi_row * cm->mi_stride + mi_col]->mbmi; - MB_MODE_INFO *prev_mbmi = - &cm->mi_grid_visible[prev_mi_row * cm->mi_stride + prev_mi_col]->mbmi; - const uint8_t prev_lvl = prev_mbmi->filt_lvl; - - const int reuse_ctx = prev_mbmi->reuse_sb_lvl; - const int reuse_prev_lvl = aom_read_symbol( - r, xd->tile_ctx->lpf_reuse_cdf[reuse_ctx], 2, ACCT_STR); - curr_mbmi->reuse_sb_lvl = reuse_prev_lvl; - - if (reuse_prev_lvl) { - filt_lvl = prev_lvl; - curr_mbmi->delta = 0; - curr_mbmi->sign = 0; - } else { - const int delta_ctx = prev_mbmi->delta; - unsigned int delta = aom_read_symbol( - r, xd->tile_ctx->lpf_delta_cdf[delta_ctx], DELTA_RANGE, ACCT_STR); - curr_mbmi->delta = delta; - delta *= LPF_STEP; - - if (delta) { - const int sign_ctx = prev_mbmi->sign; - const int sign = aom_read_symbol( - r, xd->tile_ctx->lpf_sign_cdf[reuse_ctx][sign_ctx], 2, ACCT_STR); - curr_mbmi->sign = sign; - filt_lvl = sign ? prev_lvl + delta : prev_lvl - delta; - } else { - filt_lvl = prev_lvl; - curr_mbmi->sign = 0; - } - } - } - - av1_loop_filter_sb_level_init(cm, mi_row, mi_col, filt_lvl); - } -#endif - -#if CONFIG_CDEF - if (bsize == cm->sb_size) { - int width_step = mi_size_wide[BLOCK_64X64]; - int height_step = mi_size_wide[BLOCK_64X64]; - int w, h; - for (h = 0; (h < mi_size_high[cm->sb_size]) && (mi_row + h < cm->mi_rows); - h += height_step) { - for (w = 0; (w < mi_size_wide[cm->sb_size]) && (mi_col + w < cm->mi_cols); - w += width_step) { - if (!cm->all_lossless && !sb_all_skip(cm, mi_row + h, mi_col + w)) - cm->mi_grid_visible[(mi_row + h) * cm->mi_stride + (mi_col + w)] - ->mbmi.cdef_strength = - aom_read_literal(r, cm->cdef_bits, ACCT_STR); - else - cm->mi_grid_visible[(mi_row + h) * cm->mi_stride + (mi_col + w)] - ->mbmi.cdef_strength = -1; - } - } - } -#endif // CONFIG_CDEF -#if CONFIG_LOOP_RESTORATION - for (int plane = 0; plane < MAX_MB_PLANE; ++plane) { - int rcol0, rcol1, rrow0, rrow1, nhtiles; - if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize, - &rcol0, &rcol1, &rrow0, &rrow1, - &nhtiles)) { - for (int rrow = rrow0; rrow < rrow1; ++rrow) { - for (int rcol = rcol0; rcol < rcol1; ++rcol) { - int rtile_idx = rcol + rrow * nhtiles; - loop_restoration_read_sb_coeffs(cm, xd, r, plane, rtile_idx); - } - } - } - } -#endif } 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, -#if CONFIG_ANS && ANS_MAX_SYMBOLS - int window_size, -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - aom_decrypt_cb decrypt_cb, void *decrypt_state) { + 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. @@ -2692,117 +1527,147 @@ static void setup_bool_decoder(const uint8_t *data, const uint8_t *data_end, aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME, "Truncated packet or corrupt tile length"); -#if CONFIG_ANS && ANS_MAX_SYMBOLS - r->window_size = window_size; -#endif - if (aom_reader_init(r, data, read_size, decrypt_cb, decrypt_state)) + 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; - int i, j; seg->update_map = 0; seg->update_data = 0; seg->temporal_update = 0; seg->enabled = aom_rb_read_bit(rb); - if (!seg->enabled) return; + if (!seg->enabled) { + if (cm->cur_frame->seg_map) + memset(cm->cur_frame->seg_map, 0, (cm->mi_rows * cm->mi_cols)); - // Segmentation map update - if (frame_is_intra_only(cm) || cm->error_resilient_mode) { + 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) { - if (frame_is_intra_only(cm) || cm->error_resilient_mode) { - seg->temporal_update = 0; - } else { + 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 - seg->update_data = aom_rb_read_bit(rb); if (seg->update_data) { - seg->abs_delta = aom_rb_read_bit(rb); - av1_clearall_segfeatures(seg); - for (i = 0; i < MAX_SEGMENTS; i++) { - for (j = 0; j < SEG_LVL_MAX; j++) { + 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); - data = decode_unsigned_max(rb, av1_seg_feature_data_max(j)); - if (av1_is_segfeature_signed(j)) - data = aom_rb_read_bit(rb) ? -data : data; + + 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); } } + calculate_segdata(seg); + } else if (cm->prev_frame) { + segfeatures_copy(seg, &cm->prev_frame->seg); } + segfeatures_copy(&cm->cur_frame->seg, seg); } -#if CONFIG_LOOP_RESTORATION static void decode_restoration_mode(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { - int p; - RestorationInfo *rsi = &cm->rst_info[0]; - if (aom_rb_read_bit(rb)) { - rsi->frame_restoration_type = - aom_rb_read_bit(rb) ? RESTORE_SGRPROJ : RESTORE_WIENER; - } else { - rsi->frame_restoration_type = - aom_rb_read_bit(rb) ? RESTORE_SWITCHABLE : RESTORE_NONE; - } - for (p = 1; p < MAX_MB_PLANE; ++p) { - rsi = &cm->rst_info[p]; + 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) { + RestorationInfo *rsi = &cm->rst_info[p]; if (aom_rb_read_bit(rb)) { rsi->frame_restoration_type = aom_rb_read_bit(rb) ? RESTORE_SGRPROJ : RESTORE_WIENER; } else { - rsi->frame_restoration_type = RESTORE_NONE; + rsi->frame_restoration_type = + aom_rb_read_bit(rb) ? RESTORE_SWITCHABLE : RESTORE_NONE; + } + 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; - cm->rst_info[0].restoration_tilesize = RESTORATION_TILESIZE_MAX; - cm->rst_info[1].restoration_tilesize = RESTORATION_TILESIZE_MAX; - cm->rst_info[2].restoration_tilesize = RESTORATION_TILESIZE_MAX; - if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || - cm->rst_info[1].frame_restoration_type != RESTORE_NONE || - cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { - rsi = &cm->rst_info[0]; - rsi->restoration_tilesize >>= aom_rb_read_bit(rb); - if (rsi->restoration_tilesize != RESTORATION_TILESIZE_MAX) { - rsi->restoration_tilesize >>= aom_rb_read_bit(rb); + for (int p = 0; p < num_planes; ++p) + cm->rst_info[p].restoration_unit_size = sb_size; + + 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); } - } - int s = AOMMIN(cm->subsampling_x, cm->subsampling_y); - if (s && (cm->rst_info[1].frame_restoration_type != RESTORE_NONE || - cm->rst_info[2].frame_restoration_type != RESTORE_NONE)) { - cm->rst_info[1].restoration_tilesize = - cm->rst_info[0].restoration_tilesize >> (aom_rb_read_bit(rb) * s); } else { - cm->rst_info[1].restoration_tilesize = cm->rst_info[0].restoration_tilesize; + const int size = RESTORATION_UNITSIZE_MAX; + for (int p = 0; p < num_planes; ++p) + cm->rst_info[p].restoration_unit_size = size; } - cm->rst_info[2].restoration_tilesize = cm->rst_info[1].restoration_tilesize; - cm->rst_info[0].procunit_width = cm->rst_info[0].procunit_height = - RESTORATION_PROC_UNIT_SIZE; - cm->rst_info[1].procunit_width = cm->rst_info[2].procunit_width = - RESTORATION_PROC_UNIT_SIZE >> cm->subsampling_x; - cm->rst_info[1].procunit_height = cm->rst_info[2].procunit_height = - RESTORATION_PROC_UNIT_SIZE >> cm->subsampling_y; + if (num_planes > 1) { + int s = AOMMIN(cm->subsampling_x, cm->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(int wiener_win, WienerInfo *wiener_info, WienerInfo *ref_wiener_info, aom_reader *rb) { + 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( @@ -2860,75 +1725,109 @@ static void read_wiener_filter(int wiener_win, WienerInfo *wiener_info, static void read_sgrproj_filter(SgrprojInfo *sgrproj_info, SgrprojInfo *ref_sgrproj_info, aom_reader *rb) { sgrproj_info->ep = aom_read_literal(rb, SGRPROJ_PARAMS_BITS, ACCT_STR); - 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; + const sgr_params_type *params = &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)); } static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane, - int rtile_idx) { - const RestorationInfo *rsi = cm->rst_info + plane; + int runit_idx) { + const RestorationInfo *rsi = &cm->rst_info[plane]; + RestorationUnitInfo *rui = &rsi->unit_info[runit_idx]; if (rsi->frame_restoration_type == RESTORE_NONE) return; + assert(!cm->all_lossless); + const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN; WienerInfo *wiener_info = xd->wiener_info + plane; SgrprojInfo *sgrproj_info = xd->sgrproj_info + plane; if (rsi->frame_restoration_type == RESTORE_SWITCHABLE) { - assert(plane == 0); - rsi->restoration_type[rtile_idx] = - aom_read_tree(r, av1_switchable_restore_tree, - cm->fc->switchable_restore_prob, ACCT_STR); - - if (rsi->restoration_type[rtile_idx] == RESTORE_WIENER) { - read_wiener_filter(wiener_win, &rsi->wiener_info[rtile_idx], wiener_info, - r); - } else if (rsi->restoration_type[rtile_idx] == RESTORE_SGRPROJ) { - read_sgrproj_filter(&rsi->sgrproj_info[rtile_idx], sgrproj_info, r); + rui->restoration_type = + aom_read_symbol(r, xd->tile_ctx->switchable_restore_cdf, + RESTORE_SWITCHABLE_TYPES, ACCT_STR); + switch (rui->restoration_type) { + case RESTORE_WIENER: + read_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, r); + break; + case RESTORE_SGRPROJ: + read_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, r); + break; + default: assert(rui->restoration_type == RESTORE_NONE); break; } } else if (rsi->frame_restoration_type == RESTORE_WIENER) { - if (aom_read(r, RESTORE_NONE_WIENER_PROB, ACCT_STR)) { - rsi->restoration_type[rtile_idx] = RESTORE_WIENER; - read_wiener_filter(wiener_win, &rsi->wiener_info[rtile_idx], wiener_info, - r); + if (aom_read_symbol(r, xd->tile_ctx->wiener_restore_cdf, 2, ACCT_STR)) { + rui->restoration_type = RESTORE_WIENER; + read_wiener_filter(wiener_win, &rui->wiener_info, wiener_info, r); } else { - rsi->restoration_type[rtile_idx] = RESTORE_NONE; + rui->restoration_type = RESTORE_NONE; } } else if (rsi->frame_restoration_type == RESTORE_SGRPROJ) { - if (aom_read(r, RESTORE_NONE_SGRPROJ_PROB, ACCT_STR)) { - rsi->restoration_type[rtile_idx] = RESTORE_SGRPROJ; - read_sgrproj_filter(&rsi->sgrproj_info[rtile_idx], sgrproj_info, r); + if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2, ACCT_STR)) { + rui->restoration_type = RESTORE_SGRPROJ; + read_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, r); } else { - rsi->restoration_type[rtile_idx] = RESTORE_NONE; + rui->restoration_type = RESTORE_NONE; } } } -#endif // CONFIG_LOOP_RESTORATION 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 !CONFIG_LPF_SB -#if CONFIG_LOOPFILTER_LEVEL + 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 (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); + 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); + } } -#else - lf->filter_level = aom_rb_read_literal(rb, 6); -#endif -#endif // CONFIG_LPF_SB lf->sharpness_level = aom_rb_read_literal(rb, 3); // Read in loop filter deltas applied at the MB level based on mode or ref @@ -2939,38 +1838,33 @@ static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { if (lf->mode_ref_delta_enabled) { lf->mode_ref_delta_update = aom_rb_read_bit(rb); if (lf->mode_ref_delta_update) { - int i; - - for (i = 0; i < TOTAL_REFS_PER_FRAME; i++) + 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 (i = 0; i < MAX_MODE_LF_DELTAS; i++) + 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); } -#if CONFIG_CDEF static void setup_cdef(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { - int i; -#if CONFIG_CDEF_SINGLEPASS + const int num_planes = av1_num_planes(cm); + if (cm->allow_intrabc) return; cm->cdef_pri_damping = cm->cdef_sec_damping = aom_rb_read_literal(rb, 2) + 3; -#else - cm->cdef_pri_damping = aom_rb_read_literal(rb, 1) + 5; - cm->cdef_sec_damping = aom_rb_read_literal(rb, 2) + 3; -#endif cm->cdef_bits = aom_rb_read_literal(rb, 2); cm->nb_cdef_strengths = 1 << cm->cdef_bits; - for (i = 0; i < cm->nb_cdef_strengths; i++) { + for (int i = 0; i < cm->nb_cdef_strengths; i++) { cm->cdef_strengths[i] = aom_rb_read_literal(rb, CDEF_STRENGTH_BITS); - cm->cdef_uv_strengths[i] = cm->subsampling_x == cm->subsampling_y - ? aom_rb_read_literal(rb, CDEF_STRENGTH_BITS) - : 0; + cm->cdef_uv_strengths[i] = + num_planes > 1 ? aom_rb_read_literal(rb, CDEF_STRENGTH_BITS) : 0; } } -#endif // CONFIG_CDEF static INLINE int read_delta_q(struct aom_read_bit_buffer *rb) { return aom_rb_read_bit(rb) ? aom_rb_read_inv_signed_literal(rb, 6) : 0; @@ -2978,66 +1872,74 @@ static INLINE int read_delta_q(struct aom_read_bit_buffer *rb) { static void setup_quantization(AV1_COMMON *const cm, struct aom_read_bit_buffer *rb) { + const int num_planes = av1_num_planes(cm); cm->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS); cm->y_dc_delta_q = read_delta_q(rb); - cm->uv_dc_delta_q = read_delta_q(rb); - cm->uv_ac_delta_q = read_delta_q(rb); + if (num_planes > 1) { + int diff_uv_delta = 0; + if (cm->separate_uv_delta_q) diff_uv_delta = aom_rb_read_bit(rb); + cm->u_dc_delta_q = read_delta_q(rb); + cm->u_ac_delta_q = read_delta_q(rb); + if (diff_uv_delta) { + cm->v_dc_delta_q = read_delta_q(rb); + cm->v_ac_delta_q = read_delta_q(rb); + } else { + cm->v_dc_delta_q = cm->u_dc_delta_q; + cm->v_ac_delta_q = cm->u_ac_delta_q; + } + } cm->dequant_bit_depth = cm->bit_depth; -#if CONFIG_AOM_QM cm->using_qmatrix = aom_rb_read_bit(rb); if (cm->using_qmatrix) { - cm->min_qmlevel = aom_rb_read_literal(rb, QM_LEVEL_BITS); - cm->max_qmlevel = aom_rb_read_literal(rb, QM_LEVEL_BITS); + cm->qm_y = aom_rb_read_literal(rb, QM_LEVEL_BITS); + cm->qm_u = aom_rb_read_literal(rb, QM_LEVEL_BITS); + if (!cm->separate_uv_delta_q) + cm->qm_v = cm->qm_u; + else + cm->qm_v = aom_rb_read_literal(rb, QM_LEVEL_BITS); } else { - cm->min_qmlevel = 0; - cm->max_qmlevel = 0; + cm->qm_y = 0; + cm->qm_u = 0; + cm->qm_v = 0; } -#endif } // Build y/uv dequant values based on segmentation. static void setup_segmentation_dequant(AV1_COMMON *const cm) { -#if CONFIG_AOM_QM const int using_qm = cm->using_qmatrix; - const int minqm = cm->min_qmlevel; - const int maxqm = cm->max_qmlevel; -#endif // When segmentation is disabled, only the first value is used. The // remaining are don't cares. const int max_segments = cm->seg.enabled ? MAX_SEGMENTS : 1; for (int i = 0; i < max_segments; ++i) { const int qindex = av1_get_qindex(&cm->seg, i, cm->base_qindex); - cm->y_dequant[i][0] = av1_dc_quant(qindex, cm->y_dc_delta_q, cm->bit_depth); - cm->y_dequant[i][1] = av1_ac_quant(qindex, 0, cm->bit_depth); - cm->uv_dequant[i][0] = - av1_dc_quant(qindex, cm->uv_dc_delta_q, cm->bit_depth); - cm->uv_dequant[i][1] = - av1_ac_quant(qindex, cm->uv_ac_delta_q, cm->bit_depth); -#if CONFIG_AOM_QM + cm->y_dequant_QTX[i][0] = + av1_dc_quant_QTX(qindex, cm->y_dc_delta_q, cm->bit_depth); + cm->y_dequant_QTX[i][1] = av1_ac_quant_QTX(qindex, 0, cm->bit_depth); + cm->u_dequant_QTX[i][0] = + av1_dc_quant_QTX(qindex, cm->u_dc_delta_q, cm->bit_depth); + cm->u_dequant_QTX[i][1] = + av1_ac_quant_QTX(qindex, cm->u_ac_delta_q, cm->bit_depth); + cm->v_dequant_QTX[i][0] = + av1_dc_quant_QTX(qindex, cm->v_dc_delta_q, cm->bit_depth); + cm->v_dequant_QTX[i][1] = + av1_ac_quant_QTX(qindex, cm->v_ac_delta_q, cm->bit_depth); const int lossless = qindex == 0 && cm->y_dc_delta_q == 0 && - cm->uv_dc_delta_q == 0 && cm->uv_ac_delta_q == 0; + cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 && + cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0; // NB: depends on base index so there is only 1 set per frame // No quant weighting when lossless or signalled not using QM - const int qmlevel = (lossless || using_qm == 0) - ? NUM_QM_LEVELS - 1 - : aom_get_qmlevel(cm->base_qindex, minqm, maxqm); + int qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_y; for (int j = 0; j < TX_SIZES_ALL; ++j) { - cm->y_iqmatrix[i][1][j] = aom_iqmatrix(cm, qmlevel, 0, j, 1); - cm->y_iqmatrix[i][0][j] = aom_iqmatrix(cm, qmlevel, 0, j, 0); - cm->uv_iqmatrix[i][1][j] = aom_iqmatrix(cm, qmlevel, 1, j, 1); - cm->uv_iqmatrix[i][0][j] = aom_iqmatrix(cm, qmlevel, 1, j, 0); + cm->y_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_Y, j); } -#endif // CONFIG_AOM_QM -#if CONFIG_NEW_QUANT - for (int dq = 0; dq < QUANT_PROFILES; dq++) { - for (int b = 0; b < COEF_BANDS; ++b) { - av1_get_dequant_val_nuq(cm->y_dequant[i][b != 0], b, - cm->y_dequant_nuq[i][dq][b], NULL, dq); - av1_get_dequant_val_nuq(cm->uv_dequant[i][b != 0], b, - cm->uv_dequant_nuq[i][dq][b], NULL, dq); - } + qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_u; + for (int j = 0; j < TX_SIZES_ALL; ++j) { + cm->u_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_U, j); + } + qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_v; + for (int j = 0; j < TX_SIZES_ALL; ++j) { + cm->v_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_V, j); } -#endif // CONFIG_NEW_QUANT } } @@ -3047,23 +1949,21 @@ static InterpFilter read_frame_interp_filter(struct aom_read_bit_buffer *rb) { } static void setup_render_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { -#if CONFIG_FRAME_SUPERRES cm->render_width = cm->superres_upscaled_width; cm->render_height = cm->superres_upscaled_height; -#else - cm->render_width = cm->width; - cm->render_height = cm->height; -#endif // CONFIG_FRAME_SUPERRES if (aom_rb_read_bit(rb)) - av1_read_frame_size(rb, &cm->render_width, &cm->render_height); + av1_read_frame_size(rb, 16, 16, &cm->render_width, &cm->render_height); } -#if CONFIG_FRAME_SUPERRES // TODO(afergs): make "struct aom_read_bit_buffer *const rb"? static void setup_superres(AV1_COMMON *const cm, struct aom_read_bit_buffer *rb, int *width, int *height) { cm->superres_upscaled_width = *width; cm->superres_upscaled_height = *height; + + const SequenceHeader *const seq_params = &cm->seq_params; + if (!seq_params->enable_superres) return; + if (aom_rb_read_bit(rb)) { cm->superres_scale_denominator = (uint8_t)aom_rb_read_literal(rb, SUPERRES_SCALE_BITS); @@ -3077,7 +1977,6 @@ static void setup_superres(AV1_COMMON *const cm, struct aom_read_bit_buffer *rb, cm->superres_scale_denominator = SCALE_NUMERATOR; } } -#endif // CONFIG_FRAME_SUPERRES static void resize_context_buffers(AV1_COMMON *cm, int width, int height) { #if CONFIG_SIZE_LIMIT @@ -3111,24 +2010,34 @@ static void resize_context_buffers(AV1_COMMON *cm, int width, int height) { cm->cur_frame->height = cm->height; } -static void setup_frame_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { +static void setup_frame_size(AV1_COMMON *cm, int frame_size_override_flag, + struct aom_read_bit_buffer *rb) { int width, height; BufferPool *const pool = cm->buffer_pool; - av1_read_frame_size(rb, &width, &height); -#if CONFIG_FRAME_SUPERRES + + if (frame_size_override_flag) { + int num_bits_width = cm->seq_params.num_bits_width; + int num_bits_height = cm->seq_params.num_bits_height; + av1_read_frame_size(rb, num_bits_width, num_bits_height, &width, &height); + if (width > cm->seq_params.max_frame_width || + height > cm->seq_params.max_frame_height) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Frame dimensions are larger than the maximum values"); + } + } else { + width = cm->seq_params.max_frame_width; + height = cm->seq_params.max_frame_height; + } + setup_superres(cm, rb, &width, &height); -#endif // CONFIG_FRAME_SUPERRES - setup_render_size(cm, rb); resize_context_buffers(cm, width, height); + setup_render_size(cm, rb); lock_buffer_pool(pool); if (aom_realloc_frame_buffer( get_frame_new_buffer(cm), cm->width, cm->height, cm->subsampling_x, - cm->subsampling_y, -#if CONFIG_HIGHBITDEPTH - cm->use_highbitdepth, -#endif - AOM_BORDER_IN_PIXELS, cm->byte_alignment, + cm->subsampling_y, cm->use_highbitdepth, AOM_BORDER_IN_PIXELS, + cm->byte_alignment, &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { unlock_buffer_pool(pool); @@ -3140,25 +2049,22 @@ static void setup_frame_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { pool->frame_bufs[cm->new_fb_idx].buf.subsampling_x = cm->subsampling_x; pool->frame_bufs[cm->new_fb_idx].buf.subsampling_y = cm->subsampling_y; pool->frame_bufs[cm->new_fb_idx].buf.bit_depth = (unsigned int)cm->bit_depth; - pool->frame_bufs[cm->new_fb_idx].buf.color_space = cm->color_space; -#if CONFIG_COLORSPACE_HEADERS - pool->frame_bufs[cm->new_fb_idx].buf.transfer_function = - cm->transfer_function; + pool->frame_bufs[cm->new_fb_idx].buf.color_primaries = cm->color_primaries; + pool->frame_bufs[cm->new_fb_idx].buf.transfer_characteristics = + cm->transfer_characteristics; + pool->frame_bufs[cm->new_fb_idx].buf.matrix_coefficients = + cm->matrix_coefficients; + pool->frame_bufs[cm->new_fb_idx].buf.monochrome = cm->seq_params.monochrome; pool->frame_bufs[cm->new_fb_idx].buf.chroma_sample_position = cm->chroma_sample_position; -#endif pool->frame_bufs[cm->new_fb_idx].buf.color_range = cm->color_range; pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width; pool->frame_bufs[cm->new_fb_idx].buf.render_height = cm->render_height; } -static void setup_sb_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { - (void)rb; -#if CONFIG_EXT_PARTITION - set_sb_size(cm, aom_rb_read_bit(rb) ? BLOCK_128X128 : BLOCK_64X64); -#else - set_sb_size(cm, BLOCK_64X64); -#endif // CONFIG_EXT_PARTITION +static void setup_sb_size(SequenceHeader *seq_params, + struct aom_read_bit_buffer *rb) { + set_sb_size(seq_params, aom_rb_read_bit(rb) ? BLOCK_128X128 : BLOCK_64X64); } static INLINE int valid_ref_frame_img_fmt(aom_bit_depth_t ref_bit_depth, @@ -3172,29 +2078,30 @@ static INLINE int valid_ref_frame_img_fmt(aom_bit_depth_t ref_bit_depth, static void setup_frame_size_with_refs(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { int width, height; - int found = 0, i; + int found = 0; int has_valid_ref_frame = 0; BufferPool *const pool = cm->buffer_pool; - for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { if (aom_rb_read_bit(rb)) { YV12_BUFFER_CONFIG *const buf = cm->frame_refs[i].buf; width = buf->y_crop_width; height = buf->y_crop_height; cm->render_width = buf->render_width; cm->render_height = buf->render_height; -#if CONFIG_FRAME_SUPERRES setup_superres(cm, rb, &width, &height); -#endif // CONFIG_FRAME_SUPERRES + resize_context_buffers(cm, width, height); found = 1; break; } } if (!found) { - av1_read_frame_size(rb, &width, &height); -#if CONFIG_FRAME_SUPERRES + int num_bits_width = cm->seq_params.num_bits_width; + int num_bits_height = cm->seq_params.num_bits_height; + + av1_read_frame_size(rb, num_bits_width, num_bits_height, &width, &height); setup_superres(cm, rb, &width, &height); -#endif // CONFIG_FRAME_SUPERRES + resize_context_buffers(cm, width, height); setup_render_size(cm, rb); } @@ -3204,7 +2111,7 @@ static void setup_frame_size_with_refs(AV1_COMMON *cm, // Check to make sure at least one of frames that this frame references // has valid dimensions. - for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { RefBuffer *const ref_frame = &cm->frame_refs[i]; has_valid_ref_frame |= valid_ref_frame_size(ref_frame->buf->y_crop_width, @@ -3213,7 +2120,7 @@ static void setup_frame_size_with_refs(AV1_COMMON *cm, if (!has_valid_ref_frame) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Referenced frame has invalid size"); - for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { RefBuffer *const ref_frame = &cm->frame_refs[i]; if (!valid_ref_frame_img_fmt(ref_frame->buf->bit_depth, ref_frame->buf->subsampling_x, @@ -3223,16 +2130,11 @@ static void setup_frame_size_with_refs(AV1_COMMON *cm, "Referenced frame has incompatible color format"); } - resize_context_buffers(cm, width, height); - lock_buffer_pool(pool); if (aom_realloc_frame_buffer( get_frame_new_buffer(cm), cm->width, cm->height, cm->subsampling_x, - cm->subsampling_y, -#if CONFIG_HIGHBITDEPTH - cm->use_highbitdepth, -#endif - AOM_BORDER_IN_PIXELS, cm->byte_alignment, + cm->subsampling_y, cm->use_highbitdepth, AOM_BORDER_IN_PIXELS, + cm->byte_alignment, &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { unlock_buffer_pool(pool); @@ -3244,33 +2146,19 @@ static void setup_frame_size_with_refs(AV1_COMMON *cm, pool->frame_bufs[cm->new_fb_idx].buf.subsampling_x = cm->subsampling_x; pool->frame_bufs[cm->new_fb_idx].buf.subsampling_y = cm->subsampling_y; pool->frame_bufs[cm->new_fb_idx].buf.bit_depth = (unsigned int)cm->bit_depth; - pool->frame_bufs[cm->new_fb_idx].buf.color_space = cm->color_space; -#if CONFIG_COLORSPACE_HEADERS - pool->frame_bufs[cm->new_fb_idx].buf.transfer_function = - cm->transfer_function; + pool->frame_bufs[cm->new_fb_idx].buf.color_primaries = cm->color_primaries; + pool->frame_bufs[cm->new_fb_idx].buf.transfer_characteristics = + cm->transfer_characteristics; + pool->frame_bufs[cm->new_fb_idx].buf.matrix_coefficients = + cm->matrix_coefficients; + pool->frame_bufs[cm->new_fb_idx].buf.monochrome = cm->seq_params.monochrome; pool->frame_bufs[cm->new_fb_idx].buf.chroma_sample_position = cm->chroma_sample_position; -#endif pool->frame_bufs[cm->new_fb_idx].buf.color_range = cm->color_range; pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width; pool->frame_bufs[cm->new_fb_idx].buf.render_height = cm->render_height; } -static void read_tile_group_range(AV1Decoder *pbi, - struct aom_read_bit_buffer *const rb) { - AV1_COMMON *const cm = &pbi->common; - const int num_bits = cm->log2_tile_rows + cm->log2_tile_cols; - const int num_tiles = - cm->tile_rows * cm->tile_cols; // Note: May be < (1<<num_bits) - pbi->tg_start = aom_rb_read_literal(rb, num_bits); - pbi->tg_size = 1 + aom_rb_read_literal(rb, num_bits); - if (pbi->tg_start + pbi->tg_size > num_tiles) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Tile group extends past last tile in frame"); -} - -#if CONFIG_MAX_TILE - // Same function as av1_read_uniform but reading from uncompresses header wb static int rb_read_uniform(struct aom_read_bit_buffer *const rb, int n) { const int l = get_unsigned_bits(n); @@ -3285,11 +2173,10 @@ static int rb_read_uniform(struct aom_read_bit_buffer *const rb, int n) { static void read_tile_info_max_tile(AV1_COMMON *const cm, struct aom_read_bit_buffer *const rb) { - int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, MAX_MIB_SIZE_LOG2); - int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, MAX_MIB_SIZE_LOG2); - int width_sb = width_mi >> MAX_MIB_SIZE_LOG2; - int height_sb = height_mi >> MAX_MIB_SIZE_LOG2; - int start_sb, size_sb, i; + int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2); + int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2); + int width_sb = width_mi >> cm->seq_params.mib_size_log2; + int height_sb = height_mi >> cm->seq_params.mib_size_log2; av1_get_tile_limits(cm); cm->uniform_tile_spacing_flag = aom_rb_read_bit(rb); @@ -3304,8 +2191,11 @@ static void read_tile_info_max_tile(AV1_COMMON *const cm, cm->log2_tile_cols++; } } else { + int i; + int start_sb; for (i = 0, start_sb = 0; width_sb > 0 && i < MAX_TILE_COLS; i++) { - size_sb = 1 + rb_read_uniform(rb, AOMMIN(width_sb, MAX_TILE_WIDTH_SB)); + const int size_sb = + 1 + rb_read_uniform(rb, AOMMIN(width_sb, cm->max_tile_width_sb)); cm->tile_col_start_sb[i] = start_sb; start_sb += size_sb; width_sb -= size_sb; @@ -3325,8 +2215,10 @@ static void read_tile_info_max_tile(AV1_COMMON *const cm, cm->log2_tile_rows++; } } else { + int i; + int start_sb; for (i = 0, start_sb = 0; height_sb > 0 && i < MAX_TILE_ROWS; i++) { - size_sb = + const int size_sb = 1 + rb_read_uniform(rb, AOMMIN(height_sb, cm->max_tile_height_sb)); cm->tile_row_start_sb[i] = start_sb; start_sb += size_sb; @@ -3337,110 +2229,61 @@ static void read_tile_info_max_tile(AV1_COMMON *const cm, } av1_calculate_tile_rows(cm); } -#endif -static void read_tile_info(AV1Decoder *const pbi, - struct aom_read_bit_buffer *const rb) { - AV1_COMMON *const cm = &pbi->common; -#if CONFIG_EXT_TILE +void av1_set_single_tile_decoding_mode(AV1_COMMON *const cm) { cm->single_tile_decoding = 0; if (cm->large_scale_tile) { struct loopfilter *lf = &cm->lf; // Figure out single_tile_decoding by loopfilter_level. - cm->single_tile_decoding = (!lf->filter_level) ? 1 : 0; -// Read the tile width/height -#if CONFIG_EXT_PARTITION - if (cm->sb_size == BLOCK_128X128) { - cm->tile_width = aom_rb_read_literal(rb, 5) + 1; - cm->tile_height = aom_rb_read_literal(rb, 5) + 1; - } else { -#endif // CONFIG_EXT_PARTITION - cm->tile_width = aom_rb_read_literal(rb, 6) + 1; - cm->tile_height = aom_rb_read_literal(rb, 6) + 1; -#if CONFIG_EXT_PARTITION - } -#endif // CONFIG_EXT_PARTITION - -#if CONFIG_LOOPFILTERING_ACROSS_TILES - cm->loop_filter_across_tiles_enabled = aom_rb_read_bit(rb); -#endif // CONFIG_LOOPFILTERING_ACROSS_TILES - - cm->tile_width <<= cm->mib_size_log2; - cm->tile_height <<= cm->mib_size_log2; - - cm->tile_width = AOMMIN(cm->tile_width, cm->mi_cols); - cm->tile_height = AOMMIN(cm->tile_height, cm->mi_rows); - - // Get the number of tiles - cm->tile_cols = 1; - while (cm->tile_cols * cm->tile_width < cm->mi_cols) ++cm->tile_cols; - - cm->tile_rows = 1; - while (cm->tile_rows * cm->tile_height < cm->mi_rows) ++cm->tile_rows; - - if (cm->tile_cols * cm->tile_rows > 1) { - // Read the number of bytes used to store tile size - pbi->tile_col_size_bytes = aom_rb_read_literal(rb, 2) + 1; - pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1; - } - -#if CONFIG_DEPENDENT_HORZTILES - cm->dependent_horz_tiles = 0; -#endif - } else { -#endif // CONFIG_EXT_TILE - -#if CONFIG_MAX_TILE - read_tile_info_max_tile(cm, rb); -#else - int min_log2_tile_cols, max_log2_tile_cols, max_ones; - av1_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols); + const int no_loopfilter = !(lf->filter_level[0] || lf->filter_level[1]); + const int no_cdef = cm->cdef_bits == 0 && cm->cdef_strengths[0] == 0 && + cm->cdef_uv_strengths[0] == 0; + const int no_restoration = + cm->rst_info[0].frame_restoration_type == RESTORE_NONE && + cm->rst_info[1].frame_restoration_type == RESTORE_NONE && + cm->rst_info[2].frame_restoration_type == RESTORE_NONE; + assert(IMPLIES(cm->coded_lossless, no_loopfilter && no_cdef)); + assert(IMPLIES(cm->all_lossless, no_restoration)); + cm->single_tile_decoding = no_loopfilter && no_cdef && no_restoration; + } +} - // columns - max_ones = max_log2_tile_cols - min_log2_tile_cols; - cm->log2_tile_cols = min_log2_tile_cols; - while (max_ones-- && aom_rb_read_bit(rb)) cm->log2_tile_cols++; +static void read_tile_info(AV1Decoder *const pbi, + struct aom_read_bit_buffer *const rb) { + AV1_COMMON *const cm = &pbi->common; - if (cm->log2_tile_cols > 6) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Invalid number of tile columns"); + read_tile_info_max_tile(cm, rb); - // rows - cm->log2_tile_rows = aom_rb_read_bit(rb); - if (cm->log2_tile_rows) cm->log2_tile_rows += aom_rb_read_bit(rb); + cm->context_update_tile_id = 0; + if (cm->tile_rows * cm->tile_cols > 1) { + // tile to use for cdf update + cm->context_update_tile_id = + aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); + // tile size magnitude + pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1; + } +} - cm->tile_width = - get_tile_size(cm->mi_cols, cm->log2_tile_cols, &cm->tile_cols); - cm->tile_height = - get_tile_size(cm->mi_rows, cm->log2_tile_rows, &cm->tile_rows); +#if EXT_TILE_DEBUG +static void read_ext_tile_info(AV1Decoder *const pbi, + struct aom_read_bit_buffer *const rb) { + AV1_COMMON *const cm = &pbi->common; -#endif // CONFIG_MAX_TILE -#if CONFIG_DEPENDENT_HORZTILES - if (cm->tile_rows > 1) - cm->dependent_horz_tiles = aom_rb_read_bit(rb); - else - cm->dependent_horz_tiles = 0; -#endif -#if CONFIG_LOOPFILTERING_ACROSS_TILES - cm->loop_filter_across_tiles_enabled = aom_rb_read_bit(rb); -#endif // CONFIG_LOOPFILTERING_ACROSS_TILES + // This information is stored as a separate byte. + int mod = rb->bit_offset % CHAR_BIT; + if (mod > 0) aom_rb_read_literal(rb, CHAR_BIT - mod); + assert(rb->bit_offset % CHAR_BIT == 0); - // tile size magnitude + if (cm->tile_cols * cm->tile_rows > 1) { + // Read the number of bytes used to store tile size + pbi->tile_col_size_bytes = aom_rb_read_literal(rb, 2) + 1; pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1; -#if CONFIG_EXT_TILE } -#endif // CONFIG_EXT_TILE - -// each tile group header is in its own tile group OBU -#if !CONFIG_OBU - // Store an index to the location of the tile group information - pbi->tg_size_bit_offset = rb->bit_offset; - read_tile_group_range(pbi, rb); -#endif } +#endif // EXT_TILE_DEBUG -static int mem_get_varsize(const uint8_t *src, int sz) { +static size_t mem_get_varsize(const uint8_t *src, int sz) { switch (sz) { case 1: return src[0]; case 2: return mem_get_le16(src); @@ -3450,14 +2293,14 @@ static int mem_get_varsize(const uint8_t *src, int sz) { } } -#if CONFIG_EXT_TILE +#if EXT_TILE_DEBUG // Reads the next tile returning its size and adjusting '*data' accordingly -// based on 'is_last'. +// based on 'is_last'. On return, '*data' is updated to point to the end of the +// raw tile buffer in the bit stream. static void get_ls_tile_buffer( const uint8_t *const data_end, struct aom_internal_error_info *error_info, - const uint8_t **data, aom_decrypt_cb decrypt_cb, void *decrypt_state, - TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], int tile_size_bytes, - int col, int row, int tile_copy_mode) { + const uint8_t **data, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], + int tile_size_bytes, int col, int row, int tile_copy_mode) { size_t size; size_t copy_size = 0; @@ -3466,15 +2309,7 @@ static void get_ls_tile_buffer( if (!read_is_valid(*data, tile_size_bytes, data_end)) aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME, "Truncated packet or corrupt tile length"); - if (decrypt_cb) { - uint8_t be_data[4]; - decrypt_cb(decrypt_state, *data, be_data, tile_size_bytes); - - // Only read number of bytes in cm->tile_size_bytes. - size = mem_get_varsize(be_data, tile_size_bytes); - } else { - size = mem_get_varsize(*data, tile_size_bytes); - } + size = mem_get_varsize(*data, tile_size_bytes); // If tile_copy_mode = 1, then the top bit of the tile header indicates copy // mode. @@ -3486,6 +2321,8 @@ static void get_ls_tile_buffer( copy_data = tile_buffers[row - offset][col].data; copy_size = tile_buffers[row - offset][col].size; size = 0; + } else { + size += AV1_MIN_TILE_SIZE_BYTES; } *data += tile_size_bytes; @@ -3503,30 +2340,31 @@ static void get_ls_tile_buffer( } *data += size; - - tile_buffers[row][col].raw_data_end = *data; } -static void get_ls_tile_buffers( +// Returns the end of the last tile buffer +// (tile_buffers[cm->tile_rows - 1][cm->tile_cols - 1]). +static const uint8_t *get_ls_tile_buffers( AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) { AV1_COMMON *const cm = &pbi->common; const int tile_cols = cm->tile_cols; const int tile_rows = cm->tile_rows; const int have_tiles = tile_cols * tile_rows > 1; + const uint8_t *raw_data_end; // The end of the last tile buffer if (!have_tiles) { const size_t tile_size = data_end - data; tile_buffers[0][0].data = data; tile_buffers[0][0].size = tile_size; - tile_buffers[0][0].raw_data_end = NULL; + raw_data_end = NULL; } else { // We locate only the tile buffers that are required, which are the ones // specified by pbi->dec_tile_col and pbi->dec_tile_row. Also, we always // need the last (bottom right) tile buffer, as we need to know where the // end of the compressed frame buffer is for proper superframe decoding. - const uint8_t *tile_col_data_end[MAX_TILE_COLS]; + const uint8_t *tile_col_data_end[MAX_TILE_COLS] = { NULL }; const uint8_t *const data_start = data; const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows); @@ -3543,12 +2381,11 @@ static void get_ls_tile_buffers( const int tile_copy_mode = ((AOMMAX(cm->tile_width, cm->tile_height) << MI_SIZE_LOG2) <= 256) ? 1 : 0; - size_t tile_col_size; - int r, c; - // Read tile column sizes for all columns (we need the last tile buffer) - for (c = 0; c < tile_cols; ++c) { + for (int c = 0; c < tile_cols; ++c) { const int is_last = c == tile_cols - 1; + size_t tile_col_size; + if (!is_last) { tile_col_size = mem_get_varsize(data, tile_col_size_bytes); data += tile_col_size_bytes; @@ -3563,7 +2400,7 @@ static void get_ls_tile_buffers( data = data_start; // Read the required tile sizes. - for (c = tile_cols_start; c < tile_cols_end; ++c) { + for (int c = tile_cols_start; c < tile_cols_end; ++c) { const int is_last = c == tile_cols - 1; if (c > 0) data = tile_col_data_end[c - 1]; @@ -3571,40 +2408,45 @@ static void get_ls_tile_buffers( if (!is_last) data += tile_col_size_bytes; // Get the whole of the last column, otherwise stop at the required tile. - for (r = 0; r < (is_last ? tile_rows : tile_rows_end); ++r) { - tile_buffers[r][c].col = c; - + for (int r = 0; r < (is_last ? tile_rows : tile_rows_end); ++r) { get_ls_tile_buffer(tile_col_data_end[c], &pbi->common.error, &data, - pbi->decrypt_cb, pbi->decrypt_state, tile_buffers, - tile_size_bytes, c, r, tile_copy_mode); + tile_buffers, tile_size_bytes, c, r, tile_copy_mode); } } // If we have not read the last column, then read it to get the last tile. if (tile_cols_end != tile_cols) { - c = tile_cols - 1; + const int c = tile_cols - 1; data = tile_col_data_end[c - 1]; - for (r = 0; r < tile_rows; ++r) { - tile_buffers[r][c].col = c; - + for (int r = 0; r < tile_rows; ++r) { get_ls_tile_buffer(tile_col_data_end[c], &pbi->common.error, &data, - pbi->decrypt_cb, pbi->decrypt_state, tile_buffers, - tile_size_bytes, c, r, tile_copy_mode); + tile_buffers, tile_size_bytes, c, r, tile_copy_mode); } } + raw_data_end = data; } + return raw_data_end; +} +#endif // EXT_TILE_DEBUG + +static const uint8_t *get_ls_single_tile_buffer( + AV1Decoder *pbi, const uint8_t *data, + TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) { + assert(pbi->dec_tile_row >= 0 && pbi->dec_tile_col >= 0); + tile_buffers[pbi->dec_tile_row][pbi->dec_tile_col].data = data; + tile_buffers[pbi->dec_tile_row][pbi->dec_tile_col].size = + (size_t)pbi->coded_tile_data_size; + return data + pbi->coded_tile_data_size; } -#endif // CONFIG_EXT_TILE // Reads the next tile returning its size and adjusting '*data' accordingly // based on 'is_last'. static void get_tile_buffer(const uint8_t *const data_end, const int tile_size_bytes, int is_last, struct aom_internal_error_info *error_info, - const uint8_t **data, aom_decrypt_cb decrypt_cb, - void *decrypt_state, TileBufferDec *const buf) { + const uint8_t **data, TileBufferDec *const buf) { size_t size; if (!is_last) { @@ -3612,13 +2454,7 @@ static void get_tile_buffer(const uint8_t *const data_end, aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME, "Truncated packet or corrupt tile length"); - if (decrypt_cb) { - uint8_t be_data[4]; - decrypt_cb(decrypt_state, *data, be_data, tile_size_bytes); - size = mem_get_varsize(be_data, tile_size_bytes); - } else { - size = mem_get_varsize(*data, tile_size_bytes); - } + size = mem_get_varsize(*data, tile_size_bytes) + AV1_MIN_TILE_SIZE_BYTES; *data += tile_size_bytes; if (size > (size_t)(data_end - *data)) @@ -3637,140 +2473,123 @@ static void get_tile_buffer(const uint8_t *const data_end, static void get_tile_buffers(AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], - int startTile, int endTile) { + int start_tile, int end_tile) { AV1_COMMON *const cm = &pbi->common; - int r, c; const int tile_cols = cm->tile_cols; const int tile_rows = cm->tile_rows; int tc = 0; int first_tile_in_tg = 0; - struct aom_read_bit_buffer rb_tg_hdr; - uint8_t clear_data[MAX_AV1_HEADER_SIZE]; -#if !CONFIG_OBU - const size_t hdr_size = pbi->uncomp_hdr_size + pbi->first_partition_size; - const int tg_size_bit_offset = pbi->tg_size_bit_offset; -#else - const int tg_size_bit_offset = 0; -#endif - -#if CONFIG_DEPENDENT_HORZTILES - int tile_group_start_col = 0; - int tile_group_start_row = 0; -#endif - for (r = 0; r < tile_rows; ++r) { - for (c = 0; c < tile_cols; ++c, ++tc) { + for (int r = 0; r < tile_rows; ++r) { + for (int c = 0; c < tile_cols; ++c, ++tc) { TileBufferDec *const buf = &tile_buffers[r][c]; -#if CONFIG_OBU - const int is_last = (tc == endTile); + + const int is_last = (tc == end_tile); const size_t hdr_offset = 0; -#else - const int is_last = (r == tile_rows - 1) && (c == tile_cols - 1); - const size_t hdr_offset = (tc && tc == first_tile_in_tg) ? hdr_size : 0; -#endif - if (tc < startTile || tc > endTile) continue; + if (tc < start_tile || tc > end_tile) continue; if (data + hdr_offset >= data_end) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Data ended before all tiles were read."); - buf->col = c; - if (hdr_offset) { - init_read_bit_buffer(pbi, &rb_tg_hdr, data, data_end, clear_data); - rb_tg_hdr.bit_offset = tg_size_bit_offset; - read_tile_group_range(pbi, &rb_tg_hdr); -#if CONFIG_DEPENDENT_HORZTILES - tile_group_start_row = r; - tile_group_start_col = c; -#endif - } first_tile_in_tg += tc == first_tile_in_tg ? pbi->tg_size : 0; data += hdr_offset; get_tile_buffer(data_end, pbi->tile_size_bytes, is_last, - &pbi->common.error, &data, pbi->decrypt_cb, - pbi->decrypt_state, buf); -#if CONFIG_DEPENDENT_HORZTILES - cm->tile_group_start_row[r][c] = tile_group_start_row; - cm->tile_group_start_col[r][c] = tile_group_start_col; -#endif + &pbi->common.error, &data, buf); } } } -#if CONFIG_PVQ -static void daala_dec_init(AV1_COMMON *const cm, daala_dec_ctx *daala_dec, - aom_reader *r) { - daala_dec->r = r; +static void set_cb_buffer(MACROBLOCKD *const xd, CB_BUFFER *cb_buffer, + const int num_planes) { + for (int plane = 0; plane < num_planes; ++plane) { + xd->plane[plane].dqcoeff_block = cb_buffer->dqcoeff[plane]; + xd->plane[plane].eob_data = cb_buffer->eob_data[plane]; + xd->cb_offset[plane] = 0; + xd->txb_offset[plane] = 0; + } + xd->plane[0].color_index_map = cb_buffer->color_index_map[0]; + xd->plane[1].color_index_map = cb_buffer->color_index_map[1]; + xd->color_index_map_offset[0] = 0; + xd->color_index_map_offset[1] = 0; +} - // TODO(yushin) : activity masking info needs be signaled by a bitstream - daala_dec->use_activity_masking = AV1_PVQ_ENABLE_ACTIVITY_MASKING; +static void decode_tile_sb_row(AV1Decoder *pbi, ThreadData *const td, + TileInfo tile_info, const int mi_row) { + AV1_COMMON *const cm = &pbi->common; + const int num_planes = av1_num_planes(cm); + av1_zero_left_context(&td->xd); - if (daala_dec->use_activity_masking) - daala_dec->qm = OD_HVS_QM; - else - daala_dec->qm = OD_FLAT_QM; + for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end; + mi_col += cm->seq_params.mib_size) { + set_cb_buffer(&td->xd, &td->cb_buffer_base, num_planes); - od_init_qm(daala_dec->state.qm, daala_dec->state.qm_inv, - daala_dec->qm == OD_HVS_QM ? OD_QM8_Q4_HVS : OD_QM8_Q4_FLAT); + decode_partition(pbi, &td->xd, mi_row, mi_col, td->bit_reader, + cm->seq_params.sb_size); + } +} - if (daala_dec->use_activity_masking) { - int pli; - int use_masking = daala_dec->use_activity_masking; - int segment_id = 0; - int qindex = av1_get_qindex(&cm->seg, segment_id, cm->base_qindex); +static int check_trailing_bits_after_symbol_coder(aom_reader *r) { + uint32_t nb_bits = aom_reader_tell(r); + uint32_t nb_bytes = (nb_bits + 7) >> 3; - for (pli = 0; pli < MAX_MB_PLANE; pli++) { - int i; - int q; + const uint8_t *p_begin = aom_reader_find_begin(r); + const uint8_t *p_end = aom_reader_find_end(r); - q = qindex; - if (q <= OD_DEFAULT_QMS[use_masking][0][pli].interp_q << OD_COEFF_SHIFT) { - od_interp_qm(&daala_dec->state.pvq_qm_q4[pli][0], q, - &OD_DEFAULT_QMS[use_masking][0][pli], NULL); - } else { - i = 0; - while (OD_DEFAULT_QMS[use_masking][i + 1][pli].qm_q4 != NULL && - q > OD_DEFAULT_QMS[use_masking][i + 1][pli].interp_q - << OD_COEFF_SHIFT) { - i++; - } - od_interp_qm(&daala_dec->state.pvq_qm_q4[pli][0], q, - &OD_DEFAULT_QMS[use_masking][i][pli], - &OD_DEFAULT_QMS[use_masking][i + 1][pli]); - } - } + // It is legal to have no padding bytes (nb_bytes == p_end - p_begin). + if ((ptrdiff_t)nb_bytes > p_end - p_begin) return -1; + const uint8_t *p = p_begin + nb_bytes; + + // aom_reader_tell() returns 1 for a newly initialized decoder, and the + // return value only increases as values are decoded. So nb_bits > 0, and + // thus p > p_begin. Therefore accessing p[-1] is safe. + uint8_t last_byte = p[-1]; + uint8_t pattern = 128 >> ((nb_bits - 1) & 7); + if ((last_byte & (2 * pattern - 1)) != pattern) return -1; + + // Make sure that all padding bytes are zero as required by the spec. + while (p < p_end) { + if (*p != 0) return -1; + p++; } + return 0; } -#endif // #if CONFIG_PVQ -#if CONFIG_LOOPFILTERING_ACROSS_TILES -static void dec_setup_across_tile_boundary_info( - const AV1_COMMON *const cm, const TileInfo *const tile_info) { - if (tile_info->mi_row_start >= tile_info->mi_row_end || - tile_info->mi_col_start >= tile_info->mi_col_end) - return; +static void decode_tile(AV1Decoder *pbi, ThreadData *const td, int tile_row, + int tile_col) { + TileInfo tile_info; + + AV1_COMMON *const cm = &pbi->common; + const int num_planes = av1_num_planes(cm); - if (!cm->loop_filter_across_tiles_enabled) { - av1_setup_across_tile_boundary_info(cm, tile_info); + av1_tile_set_row(&tile_info, cm, tile_row); + av1_tile_set_col(&tile_info, cm, tile_col); + av1_zero_above_context(cm, tile_info.mi_col_start, tile_info.mi_col_end, + tile_row); + av1_reset_loop_restoration(&td->xd, num_planes); + + for (int mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end; + mi_row += cm->seq_params.mib_size) { + decode_tile_sb_row(pbi, td, tile_info, mi_row); } + + int corrupted = + (check_trailing_bits_after_symbol_coder(td->bit_reader)) ? 1 : 0; + aom_merge_corrupted_flag(&td->xd.corrupted, corrupted); } -#endif // CONFIG_LOOPFILTERING_ACROSS_TILES static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, int startTile, - int endTile) { + const uint8_t *data_end, int start_tile, + int end_tile) { AV1_COMMON *const cm = &pbi->common; - const AVxWorkerInterface *const winterface = aom_get_worker_interface(); const int tile_cols = cm->tile_cols; const int tile_rows = cm->tile_rows; const int n_tiles = tile_cols * tile_rows; TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers; -#if CONFIG_EXT_TILE const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows); const int single_row = pbi->dec_tile_row >= 0; const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols); const int single_col = pbi->dec_tile_col >= 0; -#endif // CONFIG_EXT_TILE int tile_rows_start; int tile_rows_end; int tile_cols_start; @@ -3778,8 +2597,9 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, int inv_col_order; int inv_row_order; int tile_row, tile_col; + uint8_t allow_update_cdf; + const uint8_t *raw_data_end = NULL; -#if CONFIG_EXT_TILE if (cm->large_scale_tile) { tile_rows_start = single_row ? dec_tile_row : 0; tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows; @@ -3787,46 +2607,38 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols; inv_col_order = pbi->inv_tile_order && !single_col; inv_row_order = pbi->inv_tile_order && !single_row; + allow_update_cdf = 0; } else { -#endif // CONFIG_EXT_TILE tile_rows_start = 0; tile_rows_end = tile_rows; tile_cols_start = 0; tile_cols_end = tile_cols; inv_col_order = pbi->inv_tile_order; inv_row_order = pbi->inv_tile_order; -#if CONFIG_EXT_TILE - } -#endif // CONFIG_EXT_TILE - - if (cm->lf.filter_level && !cm->skip_loop_filter && - pbi->lf_worker.data1 == NULL) { - CHECK_MEM_ERROR(cm, pbi->lf_worker.data1, - aom_memalign(32, sizeof(LFWorkerData))); - pbi->lf_worker.hook = (AVxWorkerHook)av1_loop_filter_worker; - if (pbi->max_threads > 1 && !winterface->reset(&pbi->lf_worker)) { - aom_internal_error(&cm->error, AOM_CODEC_ERROR, - "Loop filter thread creation failed"); - } + allow_update_cdf = 1; } - if (cm->lf.filter_level && !cm->skip_loop_filter) { - LFWorkerData *const lf_data = (LFWorkerData *)pbi->lf_worker.data1; - // Be sure to sync as we might be resuming after a failed frame decode. - winterface->sync(&pbi->lf_worker); - av1_loop_filter_data_reset(lf_data, get_frame_new_buffer(cm), cm, - pbi->mb.plane); - } + // No tiles to decode. + if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start || + // First tile is larger than end_tile. + tile_rows_start * cm->tile_cols + tile_cols_start > end_tile || + // Last tile is smaller than start_tile. + (tile_rows_end - 1) * cm->tile_cols + tile_cols_end - 1 < start_tile) + return data; + + allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update; assert(tile_rows <= MAX_TILE_ROWS); assert(tile_cols <= MAX_TILE_COLS); -#if CONFIG_EXT_TILE - if (cm->large_scale_tile) - get_ls_tile_buffers(pbi, data, data_end, tile_buffers); +#if EXT_TILE_DEBUG + if (cm->large_scale_tile && !pbi->ext_tile_debug) + raw_data_end = get_ls_single_tile_buffer(pbi, data, tile_buffers); + else if (cm->large_scale_tile && pbi->ext_tile_debug) + raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers); else -#endif // CONFIG_EXT_TILE - get_tile_buffers(pbi, data, data_end, tile_buffers, startTile, endTile); +#endif // EXT_TILE_DEBUG + get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile); if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) { aom_free(pbi->tile_data); @@ -3839,536 +2651,411 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, aom_accounting_reset(&pbi->accounting); } #endif - // Load all tile information into tile_data. + // Load all tile information into thread_data. for (tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) { + const int row = inv_row_order ? tile_rows - 1 - tile_row : tile_row; + for (tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) { - const TileBufferDec *const buf = &tile_buffers[tile_row][tile_col]; - TileData *const td = pbi->tile_data + tile_cols * tile_row + tile_col; + const int col = inv_col_order ? tile_cols - 1 - tile_col : tile_col; + ThreadData *const td = &pbi->td; + TileDataDec *const tile_data = pbi->tile_data + row * cm->tile_cols + col; + const TileBufferDec *const tile_bs_buf = &tile_buffers[row][col]; - if (tile_row * cm->tile_cols + tile_col < startTile || - tile_row * cm->tile_cols + tile_col > endTile) + if (row * cm->tile_cols + col < start_tile || + row * cm->tile_cols + col > end_tile) continue; - td->cm = cm; td->xd = pbi->mb; td->xd.corrupted = 0; - td->xd.counts = - cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD - ? &cm->counts - : NULL; + td->xd.mc_buf[0] = pbi->td.mc_buf[0]; + td->xd.mc_buf[1] = pbi->td.mc_buf[1]; + td->bit_reader = &tile_data->bit_reader; av1_zero(td->dqcoeff); -#if CONFIG_PVQ - av1_zero(td->pvq_ref_coeff); -#endif - av1_tile_init(&td->xd.tile, td->cm, tile_row, tile_col); - setup_bool_decoder(buf->data, data_end, buf->size, &cm->error, - &td->bit_reader, -#if CONFIG_ANS && ANS_MAX_SYMBOLS - 1 << cm->ans_window_size_log2, -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - pbi->decrypt_cb, pbi->decrypt_state); + av1_tile_init(&td->xd.tile, cm, row, col); + setup_bool_decoder(tile_bs_buf->data, data_end, tile_bs_buf->size, + &cm->error, td->bit_reader, allow_update_cdf); #if CONFIG_ACCOUNTING if (pbi->acct_enabled) { - td->bit_reader.accounting = &pbi->accounting; + td->bit_reader->accounting = &pbi->accounting; + td->bit_reader->accounting->last_tell_frac = + aom_reader_tell_frac(td->bit_reader); } else { - td->bit_reader.accounting = NULL; + td->bit_reader->accounting = NULL; } #endif - av1_init_macroblockd(cm, &td->xd, -#if CONFIG_PVQ - td->pvq_ref_coeff, -#endif -#if CONFIG_CFL - &td->cfl, -#endif - td->dqcoeff); + av1_init_macroblockd(cm, &td->xd, td->dqcoeff); + av1_init_above_context(cm, &td->xd, row); // Initialise the tile context from the frame context - td->tctx = *cm->fc; - td->xd.tile_ctx = &td->tctx; - -#if CONFIG_PVQ - daala_dec_init(cm, &td->xd.daala_dec, &td->bit_reader); - td->xd.daala_dec.state.adapt = &td->tctx.pvq_context; -#endif + tile_data->tctx = *cm->fc; + td->xd.tile_ctx = &tile_data->tctx; - td->xd.plane[0].color_index_map = td->color_index_map[0]; - td->xd.plane[1].color_index_map = td->color_index_map[1]; -#if CONFIG_MRC_TX - td->xd.mrc_mask = td->mrc_mask; -#endif // CONFIG_MRC_TX + // decode tile + decode_tile(pbi, &pbi->td, row, col); + aom_merge_corrupted_flag(&pbi->mb.corrupted, td->xd.corrupted); + if (pbi->mb.corrupted) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Failed to decode tile data"); } } - for (tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) { - const int row = inv_row_order ? tile_rows - 1 - tile_row : tile_row; - int mi_row = 0; - TileInfo tile_info; - - av1_tile_set_row(&tile_info, cm, row); - - for (tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) { - const int col = inv_col_order ? tile_cols - 1 - tile_col : tile_col; - TileData *const td = pbi->tile_data + tile_cols * row + col; + if (cm->large_scale_tile) { + if (n_tiles == 1) { + // Find the end of the single tile buffer + return aom_reader_find_end(&pbi->tile_data->bit_reader); + } + // Return the end of the last tile buffer + return raw_data_end; + } + TileDataDec *const tile_data = pbi->tile_data + end_tile; - if (tile_row * cm->tile_cols + tile_col < startTile || - tile_row * cm->tile_cols + tile_col > endTile) - continue; + return aom_reader_find_end(&tile_data->bit_reader); +} -#if CONFIG_ACCOUNTING - if (pbi->acct_enabled) { - td->bit_reader.accounting->last_tell_frac = - aom_reader_tell_frac(&td->bit_reader); - } -#endif +static TileJobsDec *get_dec_job_info(AV1DecTileMT *tile_mt_info) { + TileJobsDec *cur_job_info = NULL; +#if CONFIG_MULTITHREAD + pthread_mutex_lock(tile_mt_info->job_mutex); - av1_tile_set_col(&tile_info, cm, col); + if (tile_mt_info->jobs_dequeued < tile_mt_info->jobs_enqueued) { + cur_job_info = tile_mt_info->job_queue + tile_mt_info->jobs_dequeued; + tile_mt_info->jobs_dequeued++; + } -#if CONFIG_DEPENDENT_HORZTILES - av1_tile_set_tg_boundary(&tile_info, cm, tile_row, tile_col); - if (!cm->dependent_horz_tiles || tile_row == 0 || - tile_info.tg_horz_boundary) { - av1_zero_above_context(cm, tile_info.mi_col_start, - tile_info.mi_col_end); - } + pthread_mutex_unlock(tile_mt_info->job_mutex); #else - av1_zero_above_context(cm, tile_info.mi_col_start, tile_info.mi_col_end); + (void)tile_mt_info; #endif -#if CONFIG_LOOP_RESTORATION - for (int p = 0; p < MAX_MB_PLANE; ++p) { - set_default_wiener(td->xd.wiener_info + p); - set_default_sgrproj(td->xd.sgrproj_info + p); - } -#endif // CONFIG_LOOP_RESTORATION + return cur_job_info; +} -#if CONFIG_LOOPFILTERING_ACROSS_TILES - dec_setup_across_tile_boundary_info(cm, &tile_info); -#endif // CONFIG_LOOPFILTERING_ACROSS_TILES +static int tile_worker_hook(void *arg1, void *arg2) { + DecWorkerData *const thread_data = (DecWorkerData *)arg1; + AV1Decoder *const pbi = (AV1Decoder *)arg2; + AV1_COMMON *cm = &pbi->common; + ThreadData *const td = thread_data->td; + uint8_t allow_update_cdf; - for (mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end; - mi_row += cm->mib_size) { - int mi_col; + if (setjmp(thread_data->error_info.jmp)) { + thread_data->error_info.setjmp = 0; + thread_data->td->xd.corrupted = 1; + return 0; + } + allow_update_cdf = cm->large_scale_tile ? 0 : 1; + allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update; - av1_zero_left_context(&td->xd); + assert(cm->tile_cols > 0); + while (1) { + TileJobsDec *cur_job_info = get_dec_job_info(&pbi->tile_mt_info); - for (mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end; - mi_col += cm->mib_size) { -#if CONFIG_NCOBMC_ADAPT_WEIGHT - alloc_ncobmc_pred_buffer(&td->xd); - set_sb_mi_boundaries(cm, &td->xd, mi_row, mi_col); -#endif - decode_partition(pbi, &td->xd, -#if CONFIG_SUPERTX - 0, -#endif // CONFIG_SUPERTX - mi_row, mi_col, &td->bit_reader, cm->sb_size); -#if NC_MODE_INFO && CONFIG_MOTION_VAR - detoken_and_recon_sb(pbi, &td->xd, mi_row, mi_col, &td->bit_reader, - cm->sb_size); -#endif -#if CONFIG_NCOBMC_ADAPT_WEIGHT - free_ncobmc_pred_buffer(&td->xd); -#endif - } - aom_merge_corrupted_flag(&pbi->mb.corrupted, td->xd.corrupted); - if (pbi->mb.corrupted) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Failed to decode tile data"); - } - } - -#if !CONFIG_OBU - assert(mi_row > 0); -#endif + if (cur_job_info != NULL && !td->xd.corrupted) { + const TileBufferDec *const tile_buffer = cur_job_info->tile_buffer; + TileDataDec *const tile_data = cur_job_info->tile_data; + volatile int tile_row = tile_data->tile_info.tile_row; + volatile int tile_col = tile_data->tile_info.tile_col; -// when Parallel deblocking is enabled, deblocking should not -// be interleaved with decoding. Instead, deblocking should be done -// after the entire frame is decoded. -#if !CONFIG_VAR_TX && !CONFIG_PARALLEL_DEBLOCKING && !CONFIG_CB4X4 - // Loopfilter one tile row. - // Note: If out-of-order tile decoding is used(for example, inv_row_order - // = 1), the loopfiltering has be done after all tile rows are decoded. - if (!inv_row_order && cm->lf.filter_level && !cm->skip_loop_filter) { - LFWorkerData *const lf_data = (LFWorkerData *)pbi->lf_worker.data1; - const int lf_start = AOMMAX(0, tile_info.mi_row_start - cm->mib_size); - const int lf_end = tile_info.mi_row_end - cm->mib_size; - - // Delay the loopfilter if the first tile row is only - // a single superblock high. - if (lf_end <= 0) continue; - - // Decoding has completed. Finish up the loop filter in this thread. - if (tile_info.mi_row_end >= cm->mi_rows) continue; - - winterface->sync(&pbi->lf_worker); - lf_data->start = lf_start; - lf_data->stop = lf_end; - if (pbi->max_threads > 1) { - winterface->launch(&pbi->lf_worker); + td->xd = pbi->mb; + td->xd.corrupted = 0; + td->xd.mc_buf[0] = td->mc_buf[0]; + td->xd.mc_buf[1] = td->mc_buf[1]; + td->bit_reader = &tile_data->bit_reader; + av1_zero(td->dqcoeff); + av1_tile_init(&td->xd.tile, cm, tile_row, tile_col); + setup_bool_decoder(tile_buffer->data, thread_data->data_end, + tile_buffer->size, &cm->error, td->bit_reader, + allow_update_cdf); +#if CONFIG_ACCOUNTING + if (pbi->acct_enabled) { + td->bit_reader->accounting = &pbi->accounting; + td->bit_reader->accounting->last_tell_frac = + aom_reader_tell_frac(td->bit_reader); } else { - winterface->execute(&pbi->lf_worker); + td->bit_reader->accounting = NULL; } - } -#endif // !CONFIG_VAR_TX && !CONFIG_PARALLEL_DEBLOCKING - - // After loopfiltering, the last 7 row pixels in each superblock row may - // still be changed by the longest loopfilter of the next superblock row. - if (cm->frame_parallel_decode) - av1_frameworker_broadcast(pbi->cur_buf, mi_row << cm->mib_size_log2); - } +#endif + av1_init_macroblockd(cm, &td->xd, td->dqcoeff); + av1_init_above_context(cm, &td->xd, tile_row); -#if CONFIG_VAR_TX || CONFIG_CB4X4 -// Loopfilter the whole frame. -#if CONFIG_LPF_SB - av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, - cm->lf.filter_level, 0, 0, 0, 0); -#else -#if CONFIG_LOOPFILTER_LEVEL - if (cm->lf.filter_level[0] || cm->lf.filter_level[1]) { - av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, - cm->lf.filter_level[0], cm->lf.filter_level[1], 0, 0); - av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, - cm->lf.filter_level_u, cm->lf.filter_level_u, 1, 0); - av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, - cm->lf.filter_level_v, cm->lf.filter_level_v, 2, 0); - } -#else -#if CONFIG_OBU - if (endTile == cm->tile_rows * cm->tile_cols - 1) + // Initialise the tile context from the frame context + tile_data->tctx = *cm->fc; + td->xd.tile_ctx = &tile_data->tctx; +#if CONFIG_ACCOUNTING + if (pbi->acct_enabled) { + tile_data->bit_reader.accounting->last_tell_frac = + aom_reader_tell_frac(&tile_data->bit_reader); + } #endif - av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, - cm->lf.filter_level, 0, 0); -#endif // CONFIG_LOOPFILTER_LEVEL -#endif // CONFIG_LPF_SB -#else -#if CONFIG_PARALLEL_DEBLOCKING - // Loopfilter all rows in the frame in the frame. - if (cm->lf.filter_level && !cm->skip_loop_filter) { - LFWorkerData *const lf_data = (LFWorkerData *)pbi->lf_worker.data1; - winterface->sync(&pbi->lf_worker); - lf_data->start = 0; - lf_data->stop = cm->mi_rows; - winterface->execute(&pbi->lf_worker); - } -#else - // Loopfilter remaining rows in the frame. - if (cm->lf.filter_level && !cm->skip_loop_filter) { - LFWorkerData *const lf_data = (LFWorkerData *)pbi->lf_worker.data1; - winterface->sync(&pbi->lf_worker); - lf_data->start = lf_data->stop; - lf_data->stop = cm->mi_rows; - winterface->execute(&pbi->lf_worker); - } -#endif // CONFIG_PARALLEL_DEBLOCKING -#endif // CONFIG_VAR_TX - if (cm->frame_parallel_decode) - av1_frameworker_broadcast(pbi->cur_buf, INT_MAX); - -#if CONFIG_EXT_TILE - if (cm->large_scale_tile) { - if (n_tiles == 1) { -#if CONFIG_ANS - return data_end; -#else - // Find the end of the single tile buffer - return aom_reader_find_end(&pbi->tile_data->bit_reader); -#endif // CONFIG_ANS + // decode tile + decode_tile(pbi, td, tile_row, tile_col); } else { - // Return the end of the last tile buffer - return tile_buffers[tile_rows - 1][tile_cols - 1].raw_data_end; + break; } - } else { -#endif // CONFIG_EXT_TILE -#if CONFIG_ANS - return data_end; -#else -#if !CONFIG_OBU - { - // Get last tile data. - TileData *const td = pbi->tile_data + tile_cols * tile_rows - 1; - return aom_reader_find_end(&td->bit_reader); - } -#else - TileData *const td = pbi->tile_data + endTile; - return aom_reader_find_end(&td->bit_reader); -#endif -#endif // CONFIG_ANS -#if CONFIG_EXT_TILE } -#endif // CONFIG_EXT_TILE + return !td->xd.corrupted; } -static int tile_worker_hook(TileWorkerData *const tile_data, - const TileInfo *const tile) { - AV1Decoder *const pbi = tile_data->pbi; - const AV1_COMMON *const cm = &pbi->common; - int mi_row, mi_col; +// sorts in descending order +static int compare_tile_buffers(const void *a, const void *b) { + const TileJobsDec *const buf1 = (const TileJobsDec *)a; + const TileJobsDec *const buf2 = (const TileJobsDec *)b; + return (((int)buf2->tile_buffer->size) - ((int)buf1->tile_buffer->size)); +} - if (setjmp(tile_data->error_info.jmp)) { - tile_data->error_info.setjmp = 0; - aom_merge_corrupted_flag(&tile_data->xd.corrupted, 1); - return 0; +static void enqueue_tile_jobs(AV1Decoder *pbi, AV1_COMMON *cm, + int tile_rows_start, int tile_rows_end, + int tile_cols_start, int tile_cols_end, + int startTile, int endTile) { + AV1DecTileMT *tile_mt_info = &pbi->tile_mt_info; + TileJobsDec *tile_job_queue = tile_mt_info->job_queue; + tile_mt_info->jobs_enqueued = 0; + tile_mt_info->jobs_dequeued = 0; + + for (int row = tile_rows_start; row < tile_rows_end; row++) { + for (int col = tile_cols_start; col < tile_cols_end; col++) { + if (row * cm->tile_cols + col < startTile || + row * cm->tile_cols + col > endTile) + continue; + tile_job_queue->tile_buffer = &pbi->tile_buffers[row][col]; + tile_job_queue->tile_data = pbi->tile_data + row * cm->tile_cols + col; + tile_job_queue++; + tile_mt_info->jobs_enqueued++; + } } +} + +static void alloc_dec_jobs(AV1DecTileMT *tile_mt_info, AV1_COMMON *cm, + int tile_rows, int tile_cols) { + tile_mt_info->alloc_tile_rows = tile_rows; + tile_mt_info->alloc_tile_cols = tile_cols; + int num_tiles = tile_rows * tile_cols; +#if CONFIG_MULTITHREAD + { + CHECK_MEM_ERROR(cm, tile_mt_info->job_mutex, + aom_malloc(sizeof(*tile_mt_info->job_mutex) * num_tiles)); - tile_data->error_info.setjmp = 1; - tile_data->xd.error_info = &tile_data->error_info; -#if CONFIG_DEPENDENT_HORZTILES - if (!cm->dependent_horz_tiles || tile->tg_horz_boundary) { - av1_zero_above_context(&pbi->common, tile->mi_col_start, tile->mi_col_end); + for (int i = 0; i < num_tiles; i++) { + pthread_mutex_init(&tile_mt_info->job_mutex[i], NULL); + } } -#else - av1_zero_above_context(&pbi->common, tile->mi_col_start, tile->mi_col_end); #endif + CHECK_MEM_ERROR(cm, tile_mt_info->job_queue, + aom_malloc(sizeof(*tile_mt_info->job_queue) * num_tiles)); +} - for (mi_row = tile->mi_row_start; mi_row < tile->mi_row_end; - mi_row += cm->mib_size) { - av1_zero_left_context(&tile_data->xd); - - for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end; - mi_col += cm->mib_size) { - decode_partition(pbi, &tile_data->xd, -#if CONFIG_SUPERTX - 0, -#endif - mi_row, mi_col, &tile_data->bit_reader, cm->sb_size); -#if NC_MODE_INFO && CONFIG_MOTION_VAR - detoken_and_recon_sb(pbi, &tile_data->xd, mi_row, mi_col, - &tile_data->bit_reader, cm->sb_size); -#endif - } +void av1_free_mc_tmp_buf(void *td, int use_highbd) { + ThreadData *thread_data = (ThreadData *)td; + int ref; + for (ref = 0; ref < 2; ref++) { + if (use_highbd) + aom_free(CONVERT_TO_SHORTPTR(thread_data->mc_buf[ref])); + else + aom_free(thread_data->mc_buf[ref]); + thread_data->mc_buf[ref] = NULL; } - return !tile_data->xd.corrupted; + thread_data->mc_buf_size = 0; } -// sorts in descending order -static int compare_tile_buffers(const void *a, const void *b) { - const TileBufferDec *const buf1 = (const TileBufferDec *)a; - const TileBufferDec *const buf2 = (const TileBufferDec *)b; - return (int)(buf2->size - buf1->size); +static void allocate_mc_tmp_buf(AV1_COMMON *const cm, void *td, int buf_size, + int use_highbd) { + ThreadData *thread_data = (ThreadData *)td; + + for (int ref = 0; ref < 2; ref++) { + if (use_highbd) { + uint16_t *hbd_mc_buf; + CHECK_MEM_ERROR(cm, hbd_mc_buf, (uint16_t *)aom_memalign(16, buf_size)); + thread_data->mc_buf[ref] = CONVERT_TO_BYTEPTR(hbd_mc_buf); + } else { + CHECK_MEM_ERROR(cm, thread_data->mc_buf[ref], + (uint8_t *)aom_memalign(16, buf_size)); + } + } + thread_data->mc_buf_size = buf_size; } static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end) { + const uint8_t *data_end, int start_tile, + int end_tile) { AV1_COMMON *const cm = &pbi->common; const AVxWorkerInterface *const winterface = aom_get_worker_interface(); const int tile_cols = cm->tile_cols; const int tile_rows = cm->tile_rows; - const int num_workers = AOMMIN(pbi->max_threads & ~1, tile_cols); + const int n_tiles = tile_cols * tile_rows; TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers; -#if CONFIG_EXT_TILE const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows); const int single_row = pbi->dec_tile_row >= 0; const int dec_tile_col = AOMMIN(pbi->dec_tile_col, tile_cols); const int single_col = pbi->dec_tile_col >= 0; -#endif // CONFIG_EXT_TILE int tile_rows_start; int tile_rows_end; int tile_cols_start; int tile_cols_end; - int tile_row, tile_col; - int i; + int tile_count_tg; + int num_workers; + int worker_idx; + const uint8_t *raw_data_end = NULL; -#if CONFIG_EXT_TILE if (cm->large_scale_tile) { tile_rows_start = single_row ? dec_tile_row : 0; tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows; tile_cols_start = single_col ? dec_tile_col : 0; tile_cols_end = single_col ? tile_cols_start + 1 : tile_cols; } else { -#endif // CONFIG_EXT_TILE tile_rows_start = 0; tile_rows_end = tile_rows; tile_cols_start = 0; tile_cols_end = tile_cols; -#if CONFIG_EXT_TILE } -#endif // CONFIG_EXT_TILE + tile_count_tg = end_tile - start_tile + 1; + num_workers = AOMMIN(pbi->max_threads, tile_count_tg); -#if !CONFIG_ANS - int final_worker = -1; -#endif // !CONFIG_ANS + // No tiles to decode. + if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start || + // First tile is larger than end_tile. + tile_rows_start * tile_cols + tile_cols_start > end_tile || + // Last tile is smaller than start_tile. + (tile_rows_end - 1) * tile_cols + tile_cols_end - 1 < start_tile) + return data; assert(tile_rows <= MAX_TILE_ROWS); assert(tile_cols <= MAX_TILE_COLS); - - assert(tile_cols * tile_rows > 1); - - // TODO(jzern): See if we can remove the restriction of passing in max - // threads to the decoder. - if (pbi->num_tile_workers == 0) { - const int num_threads = pbi->max_threads & ~1; + assert(tile_count_tg > 0); + assert(num_workers > 0); + assert(start_tile <= end_tile); + assert(start_tile >= 0 && end_tile < n_tiles); + + // Create workers and thread_data + if (pbi->num_workers == 0) { + const int num_threads = pbi->max_threads; CHECK_MEM_ERROR(cm, pbi->tile_workers, aom_malloc(num_threads * sizeof(*pbi->tile_workers))); - // Ensure tile data offsets will be properly aligned. This may fail on - // platforms without DECLARE_ALIGNED(). - assert((sizeof(*pbi->tile_worker_data) % 16) == 0); - CHECK_MEM_ERROR( - cm, pbi->tile_worker_data, - aom_memalign(32, num_threads * sizeof(*pbi->tile_worker_data))); - CHECK_MEM_ERROR(cm, pbi->tile_worker_info, - aom_malloc(num_threads * sizeof(*pbi->tile_worker_info))); - for (i = 0; i < num_threads; ++i) { - AVxWorker *const worker = &pbi->tile_workers[i]; - ++pbi->num_tile_workers; + CHECK_MEM_ERROR(cm, pbi->thread_data, + aom_malloc(num_threads * sizeof(*pbi->thread_data))); + + for (worker_idx = 0; worker_idx < num_threads; ++worker_idx) { + AVxWorker *const worker = &pbi->tile_workers[worker_idx]; + DecWorkerData *const thread_data = pbi->thread_data + worker_idx; + ++pbi->num_workers; winterface->init(worker); - if (i < num_threads - 1 && !winterface->reset(worker)) { + if (worker_idx < num_threads - 1 && !winterface->reset(worker)) { aom_internal_error(&cm->error, AOM_CODEC_ERROR, "Tile decoder thread creation failed"); } - } - } - // Reset tile decoding hook - for (i = 0; i < num_workers; ++i) { - AVxWorker *const worker = &pbi->tile_workers[i]; - winterface->sync(worker); - worker->hook = (AVxWorkerHook)tile_worker_hook; - worker->data1 = &pbi->tile_worker_data[i]; - worker->data2 = &pbi->tile_worker_info[i]; + if (worker_idx < num_threads - 1) { + // Allocate thread data. + CHECK_MEM_ERROR(cm, thread_data->td, + aom_memalign(32, sizeof(*thread_data->td))); + av1_zero(*thread_data->td); + } else { + // Main thread acts as a worker and uses the thread data in pbi + thread_data->td = &pbi->td; + } + } } - - // Initialize thread frame counts. - if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { - for (i = 0; i < num_workers; ++i) { - TileWorkerData *const twd = (TileWorkerData *)pbi->tile_workers[i].data1; - av1_zero(twd->counts); + const int use_highbd = cm->use_highbitdepth ? 1 : 0; + const int buf_size = MC_TEMP_BUF_PELS << use_highbd; + for (worker_idx = 0; worker_idx < pbi->max_threads - 1; ++worker_idx) { + DecWorkerData *const thread_data = pbi->thread_data + worker_idx; + if (thread_data->td->mc_buf_size != buf_size) { + av1_free_mc_tmp_buf(thread_data->td, use_highbd); + allocate_mc_tmp_buf(cm, thread_data->td, buf_size, use_highbd); } } -// Load tile data into tile_buffers -#if CONFIG_EXT_TILE + // get tile size in tile group +#if EXT_TILE_DEBUG if (cm->large_scale_tile) - get_ls_tile_buffers(pbi, data, data_end, tile_buffers); + raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers); else -#endif // CONFIG_EXT_TILE - get_tile_buffers(pbi, data, data_end, tile_buffers, 0, - cm->tile_rows * cm->tile_cols - 1); +#endif // EXT_TILE_DEBUG + get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile); - for (tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) { - // Sort the buffers in this tile row based on size in descending order. - qsort(&tile_buffers[tile_row][tile_cols_start], - tile_cols_end - tile_cols_start, sizeof(tile_buffers[0][0]), - compare_tile_buffers); - - // Rearrange the tile buffers in this tile row such that per-tile group - // the largest, and presumably the most difficult tile will be decoded in - // the main thread. This should help minimize the number of instances - // where the main thread is waiting for a worker to complete. - { - int group_start; - for (group_start = tile_cols_start; group_start < tile_cols_end; - group_start += num_workers) { - const int group_end = AOMMIN(group_start + num_workers, tile_cols); - const TileBufferDec largest = tile_buffers[tile_row][group_start]; - memmove(&tile_buffers[tile_row][group_start], - &tile_buffers[tile_row][group_start + 1], - (group_end - group_start - 1) * sizeof(tile_buffers[0][0])); - tile_buffers[tile_row][group_end - 1] = largest; - } - } + if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) { + aom_free(pbi->tile_data); + CHECK_MEM_ERROR(cm, pbi->tile_data, + aom_memalign(32, n_tiles * sizeof(*pbi->tile_data))); + pbi->allocated_tiles = n_tiles; + } - for (tile_col = tile_cols_start; tile_col < tile_cols_end;) { - // Launch workers for individual columns - for (i = 0; i < num_workers && tile_col < tile_cols_end; - ++i, ++tile_col) { - TileBufferDec *const buf = &tile_buffers[tile_row][tile_col]; - AVxWorker *const worker = &pbi->tile_workers[i]; - TileWorkerData *const twd = (TileWorkerData *)worker->data1; - TileInfo *const tile_info = (TileInfo *)worker->data2; - - twd->pbi = pbi; - twd->xd = pbi->mb; - twd->xd.corrupted = 0; - twd->xd.counts = - cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD - ? &twd->counts - : NULL; - av1_zero(twd->dqcoeff); - av1_tile_init(tile_info, cm, tile_row, buf->col); - av1_tile_init(&twd->xd.tile, cm, tile_row, buf->col); - -#if CONFIG_LOOPFILTERING_ACROSS_TILES - dec_setup_across_tile_boundary_info(cm, tile_info); -#endif // CONFIG_LOOPFILTERING_ACROSS_TILES - - setup_bool_decoder(buf->data, data_end, buf->size, &cm->error, - &twd->bit_reader, -#if CONFIG_ANS && ANS_MAX_SYMBOLS - 1 << cm->ans_window_size_log2, -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - pbi->decrypt_cb, pbi->decrypt_state); - av1_init_macroblockd(cm, &twd->xd, -#if CONFIG_PVQ - twd->pvq_ref_coeff, -#endif -#if CONFIG_CFL - &twd->cfl, -#endif - twd->dqcoeff); -#if CONFIG_PVQ - daala_dec_init(cm, &twd->xd.daala_dec, &twd->bit_reader); - twd->xd.daala_dec.state.adapt = &twd->tctx.pvq_context; + // Reset tile decoding hook + for (worker_idx = 0; worker_idx < num_workers; ++worker_idx) { + AVxWorker *const worker = &pbi->tile_workers[worker_idx]; + DecWorkerData *const thread_data = pbi->thread_data + worker_idx; + winterface->sync(worker); + + worker->hook = tile_worker_hook; + worker->data1 = thread_data; + worker->data2 = pbi; + } +#if CONFIG_ACCOUNTING + if (pbi->acct_enabled) { + aom_accounting_reset(&pbi->accounting); + } #endif - // Initialise the tile context from the frame context - twd->tctx = *cm->fc; - twd->xd.tile_ctx = &twd->tctx; - twd->xd.plane[0].color_index_map = twd->color_index_map[0]; - twd->xd.plane[1].color_index_map = twd->color_index_map[1]; - - worker->had_error = 0; - if (i == num_workers - 1 || tile_col == tile_cols_end - 1) { - winterface->execute(worker); - } else { - winterface->launch(worker); - } + for (int row = 0; row < tile_rows; row++) { + for (int col = 0; col < tile_cols; col++) { + TileDataDec *tile_data = pbi->tile_data + row * cm->tile_cols + col; + av1_tile_init(&tile_data->tile_info, cm, row, col); + } + } -#if !CONFIG_ANS - if (tile_row == tile_rows - 1 && buf->col == tile_cols - 1) { - final_worker = i; - } -#endif // !CONFIG_ANS - } + if (pbi->tile_mt_info.alloc_tile_cols != tile_cols || + pbi->tile_mt_info.alloc_tile_rows != tile_rows) { + av1_dealloc_dec_jobs(&pbi->tile_mt_info); + alloc_dec_jobs(&pbi->tile_mt_info, cm, tile_rows, tile_cols); + } + enqueue_tile_jobs(pbi, cm, tile_rows_start, tile_rows_end, tile_cols_start, + tile_cols_end, start_tile, end_tile); + qsort(pbi->tile_mt_info.job_queue, pbi->tile_mt_info.jobs_enqueued, + sizeof(pbi->tile_mt_info.job_queue[0]), compare_tile_buffers); - // Sync all workers - for (; i > 0; --i) { - AVxWorker *const worker = &pbi->tile_workers[i - 1]; - // TODO(jzern): The tile may have specific error data associated with - // its aom_internal_error_info which could be propagated to the main - // info in cm. Additionally once the threads have been synced and an - // error is detected, there's no point in continuing to decode tiles. - pbi->mb.corrupted |= !winterface->sync(worker); + { + const int base = tile_count_tg / num_workers; + const int remain = tile_count_tg % num_workers; + int tile_start = start_tile; + int corrupted = 0; + + for (worker_idx = 0; worker_idx < num_workers; ++worker_idx) { + // compute number of tiles assign to each worker + const int count = base + (remain + worker_idx) / num_workers; + AVxWorker *const worker = &pbi->tile_workers[worker_idx]; + DecWorkerData *const thread_data = (DecWorkerData *)worker->data1; + + thread_data->data_end = data_end; + tile_start += count; + + worker->had_error = 0; + if (worker_idx == num_workers - 1) { + winterface->execute(worker); + } else { + winterface->launch(worker); } } - } - // Accumulate thread frame counts. - if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { - for (i = 0; i < num_workers; ++i) { - TileWorkerData *const twd = (TileWorkerData *)pbi->tile_workers[i].data1; - av1_accumulate_frame_counts(&cm->counts, &twd->counts); + for (; worker_idx > 0; --worker_idx) { + AVxWorker *const worker = &pbi->tile_workers[worker_idx - 1]; + aom_merge_corrupted_flag(&corrupted, !winterface->sync(worker)); } + + pbi->mb.corrupted = corrupted; } -#if CONFIG_EXT_TILE + if (pbi->mb.corrupted) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Failed to decode tile data"); + if (cm->large_scale_tile) { + if (n_tiles == 1) { + // Find the end of the single tile buffer + return aom_reader_find_end(&pbi->tile_data->bit_reader); + } // Return the end of the last tile buffer - return tile_buffers[tile_rows - 1][tile_cols - 1].raw_data_end; - } else { -#endif // CONFIG_EXT_TILE -#if CONFIG_ANS - return data_end; -#else - assert(final_worker != -1); - { - TileWorkerData *const twd = - (TileWorkerData *)pbi->tile_workers[final_worker].data1; - return aom_reader_find_end(&twd->bit_reader); - } -#endif // CONFIG_ANS -#if CONFIG_EXT_TILE + return raw_data_end; } -#endif // CONFIG_EXT_TILE + TileDataDec *const tile_data = pbi->tile_data + end_tile; + + return aom_reader_find_end(&tile_data->bit_reader); } static void error_handler(void *data) { @@ -4376,217 +3063,462 @@ static void error_handler(void *data) { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Truncated packet"); } -static void read_bitdepth_colorspace_sampling(AV1_COMMON *cm, - struct aom_read_bit_buffer *rb, - int allow_lowbitdepth) { - if (cm->profile >= PROFILE_2) { - cm->bit_depth = aom_rb_read_bit(rb) ? AOM_BITS_12 : AOM_BITS_10; +// Reads the high_bitdepth and twelve_bit fields in color_config() and sets +// cm->bit_depth based on the values of those fields and cm->profile. Reports +// errors by calling rb->error_handler() or aom_internal_error(). +static void av1_read_bitdepth(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { + const int high_bitdepth = aom_rb_read_bit(rb); + if (cm->profile == PROFILE_2 && high_bitdepth) { + const int twelve_bit = aom_rb_read_bit(rb); + cm->bit_depth = twelve_bit ? AOM_BITS_12 : AOM_BITS_10; + } else if (cm->profile <= PROFILE_2) { + cm->bit_depth = high_bitdepth ? AOM_BITS_10 : AOM_BITS_8; } else { - cm->bit_depth = AOM_BITS_8; + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Unsupported profile/bit-depth combination"); } +} -#if CONFIG_HIGHBITDEPTH - cm->use_highbitdepth = cm->bit_depth > AOM_BITS_8 || !allow_lowbitdepth; -#else - (void)allow_lowbitdepth; -#endif -#if CONFIG_COLORSPACE_HEADERS - cm->color_space = aom_rb_read_literal(rb, 5); - cm->transfer_function = aom_rb_read_literal(rb, 5); -#else - cm->color_space = aom_rb_read_literal(rb, 3); -#endif - if (cm->color_space != AOM_CS_SRGB) { - // [16,235] (including xvycc) vs [0,255] range - cm->color_range = aom_rb_read_bit(rb); - if (cm->profile == PROFILE_1 || cm->profile == PROFILE_3) { - cm->subsampling_x = aom_rb_read_bit(rb); - cm->subsampling_y = aom_rb_read_bit(rb); - if (cm->subsampling_x == 1 && cm->subsampling_y == 1) - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "4:2:0 color not supported in profile 1 or 3"); - if (aom_rb_read_bit(rb)) - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Reserved bit set"); - } else { - cm->subsampling_y = cm->subsampling_x = 1; +void av1_read_film_grain_params(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb) { + aom_film_grain_t *pars = &cm->film_grain_params; + + pars->apply_grain = aom_rb_read_bit(rb); + if (!pars->apply_grain) { + memset(pars, 0, sizeof(*pars)); + return; + } + + pars->random_seed = aom_rb_read_literal(rb, 16); + if (cm->frame_type == INTER_FRAME) + pars->update_parameters = aom_rb_read_bit(rb); + else + pars->update_parameters = 1; + + if (!pars->update_parameters) { + // inherit parameters from a previous reference frame + RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; + int film_grain_params_ref_idx = aom_rb_read_literal(rb, 3); + int buf_idx = cm->ref_frame_map[film_grain_params_ref_idx]; + if (buf_idx == INVALID_IDX) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Invalid Film grain reference idx"); } -#if CONFIG_COLORSPACE_HEADERS - if (cm->subsampling_x == 1 && cm->subsampling_y == 1) { - cm->chroma_sample_position = aom_rb_read_literal(rb, 2); + if (!frame_bufs[buf_idx].film_grain_params_present) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Film grain reference parameters not available"); } -#endif + uint16_t random_seed = pars->random_seed; + *pars = frame_bufs[buf_idx].film_grain_params; // inherit paramaters + pars->random_seed = random_seed; // with new random seed + return; + } + + // Scaling functions parameters + pars->num_y_points = aom_rb_read_literal(rb, 4); // max 14 + if (pars->num_y_points > 14) + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Number of points for film grain luma scaling function " + "exceeds the maximum value."); + for (int i = 0; i < pars->num_y_points; i++) { + pars->scaling_points_y[i][0] = aom_rb_read_literal(rb, 8); + if (i && pars->scaling_points_y[i - 1][0] >= pars->scaling_points_y[i][0]) + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "First coordinate of the scaling function points " + "shall be increasing."); + pars->scaling_points_y[i][1] = aom_rb_read_literal(rb, 8); + } + + if (!cm->seq_params.monochrome) + pars->chroma_scaling_from_luma = aom_rb_read_bit(rb); + + if (cm->seq_params.monochrome || pars->chroma_scaling_from_luma || + ((cm->subsampling_x == 1) && (cm->subsampling_y == 1) && + (pars->num_y_points == 0))) { + pars->num_cb_points = 0; + pars->num_cr_points = 0; } else { - if (cm->profile == PROFILE_1 || cm->profile == PROFILE_3) { - // Note if colorspace is SRGB then 4:4:4 chroma sampling is assumed. - // 4:2:2 or 4:4:0 chroma sampling is not allowed. - cm->subsampling_y = cm->subsampling_x = 0; - if (aom_rb_read_bit(rb)) + pars->num_cb_points = aom_rb_read_literal(rb, 4); // max 10 + if (pars->num_cb_points > 10) + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Number of points for film grain cb scaling function " + "exceeds the maximum value."); + for (int i = 0; i < pars->num_cb_points; i++) { + pars->scaling_points_cb[i][0] = aom_rb_read_literal(rb, 8); + if (i && + pars->scaling_points_cb[i - 1][0] >= pars->scaling_points_cb[i][0]) aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Reserved bit set"); - } else { + "First coordinate of the scaling function points " + "shall be increasing."); + pars->scaling_points_cb[i][1] = aom_rb_read_literal(rb, 8); + } + + pars->num_cr_points = aom_rb_read_literal(rb, 4); // max 10 + if (pars->num_cr_points > 10) aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "4:4:4 color not supported in profile 0 or 2"); + "Number of points for film grain cr scaling function " + "exceeds the maximum value."); + for (int i = 0; i < pars->num_cr_points; i++) { + pars->scaling_points_cr[i][0] = aom_rb_read_literal(rb, 8); + if (i && + pars->scaling_points_cr[i - 1][0] >= pars->scaling_points_cr[i][0]) + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "First coordinate of the scaling function points " + "shall be increasing."); + pars->scaling_points_cr[i][1] = aom_rb_read_literal(rb, 8); } + + if ((cm->subsampling_x == 1) && (cm->subsampling_y == 1) && + (((pars->num_cb_points == 0) && (pars->num_cr_points != 0)) || + ((pars->num_cb_points != 0) && (pars->num_cr_points == 0)))) + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "In YCbCr 4:2:0, film grain shall be applied " + "to both chroma components or neither."); } + + pars->scaling_shift = aom_rb_read_literal(rb, 2) + 8; // 8 + value + + // AR coefficients + // Only sent if the corresponsing scaling function has + // more than 0 points + + pars->ar_coeff_lag = aom_rb_read_literal(rb, 2); + + int num_pos_luma = 2 * pars->ar_coeff_lag * (pars->ar_coeff_lag + 1); + int num_pos_chroma = num_pos_luma; + if (pars->num_y_points > 0) ++num_pos_chroma; + + if (pars->num_y_points) + for (int i = 0; i < num_pos_luma; i++) + pars->ar_coeffs_y[i] = aom_rb_read_literal(rb, 8) - 128; + + if (pars->num_cb_points || pars->chroma_scaling_from_luma) + for (int i = 0; i < num_pos_chroma; i++) + pars->ar_coeffs_cb[i] = aom_rb_read_literal(rb, 8) - 128; + + if (pars->num_cr_points || pars->chroma_scaling_from_luma) + for (int i = 0; i < num_pos_chroma; i++) + pars->ar_coeffs_cr[i] = aom_rb_read_literal(rb, 8) - 128; + + pars->ar_coeff_shift = aom_rb_read_literal(rb, 2) + 6; // 6 + value + + pars->grain_scale_shift = aom_rb_read_literal(rb, 2); + + if (pars->num_cb_points) { + pars->cb_mult = aom_rb_read_literal(rb, 8); + pars->cb_luma_mult = aom_rb_read_literal(rb, 8); + pars->cb_offset = aom_rb_read_literal(rb, 9); + } + + if (pars->num_cr_points) { + pars->cr_mult = aom_rb_read_literal(rb, 8); + pars->cr_luma_mult = aom_rb_read_literal(rb, 8); + pars->cr_offset = aom_rb_read_literal(rb, 9); + } + + pars->overlap_flag = aom_rb_read_bit(rb); + + pars->clip_to_restricted_range = aom_rb_read_bit(rb); } -#if CONFIG_REFERENCE_BUFFER -void read_sequence_header(SequenceHeader *seq_params, - struct aom_read_bit_buffer *rb) { - /* Placeholder for actually reading from the bitstream */ - seq_params->frame_id_numbers_present_flag = aom_rb_read_bit(rb); - if (seq_params->frame_id_numbers_present_flag) { - seq_params->frame_id_length_minus7 = aom_rb_read_literal(rb, 4); - seq_params->delta_frame_id_length_minus2 = aom_rb_read_literal(rb, 4); +static void read_film_grain(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { + if (cm->film_grain_params_present && (cm->show_frame || cm->showable_frame)) { + av1_read_film_grain_params(cm, rb); + } else { + memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params)); } + cm->film_grain_params.bit_depth = cm->bit_depth; + memcpy(&cm->cur_frame->film_grain_params, &cm->film_grain_params, + sizeof(aom_film_grain_t)); } -#endif // CONFIG_REFERENCE_BUFFER -static void read_compound_tools(AV1_COMMON *cm, - struct aom_read_bit_buffer *rb) { - (void)cm; - (void)rb; -#if CONFIG_INTERINTRA - if (!frame_is_intra_only(cm) && cm->reference_mode != COMPOUND_REFERENCE) { - cm->allow_interintra_compound = aom_rb_read_bit(rb); +void av1_read_color_config(AV1_COMMON *cm, struct aom_read_bit_buffer *rb, + int allow_lowbitdepth) { + av1_read_bitdepth(cm, rb); + + cm->use_highbitdepth = cm->bit_depth > AOM_BITS_8 || !allow_lowbitdepth; + // monochrome bit (not needed for PROFILE_1) + const int is_monochrome = cm->profile != PROFILE_1 ? aom_rb_read_bit(rb) : 0; + cm->seq_params.monochrome = is_monochrome; + int color_description_present_flag = aom_rb_read_bit(rb); + if (color_description_present_flag) { + cm->color_primaries = aom_rb_read_literal(rb, 8); + cm->transfer_characteristics = aom_rb_read_literal(rb, 8); + cm->matrix_coefficients = aom_rb_read_literal(rb, 8); } else { - cm->allow_interintra_compound = 0; - } -#endif // CONFIG_INTERINTRA -#if CONFIG_WEDGE || CONFIG_COMPOUND_SEGMENT -#if CONFIG_COMPOUND_SINGLEREF - if (!frame_is_intra_only(cm)) { -#else // !CONFIG_COMPOUND_SINGLEREF - if (!frame_is_intra_only(cm) && cm->reference_mode != SINGLE_REFERENCE) { -#endif // CONFIG_COMPOUND_SINGLEREF - cm->allow_masked_compound = aom_rb_read_bit(rb); + cm->color_primaries = AOM_CICP_CP_UNSPECIFIED; + cm->transfer_characteristics = AOM_CICP_TC_UNSPECIFIED; + cm->matrix_coefficients = AOM_CICP_MC_UNSPECIFIED; + } + if (is_monochrome) { + // [16,235] (including xvycc) vs [0,255] range + cm->color_range = aom_rb_read_bit(rb); + cm->subsampling_y = cm->subsampling_x = 1; + cm->chroma_sample_position = AOM_CSP_UNKNOWN; + cm->separate_uv_delta_q = 0; + return; + } + if (cm->color_primaries == AOM_CICP_CP_BT_709 && + cm->transfer_characteristics == AOM_CICP_TC_SRGB && + cm->matrix_coefficients == AOM_CICP_MC_IDENTITY) { // it would be better + // to remove this + // dependency too + cm->subsampling_y = cm->subsampling_x = 0; + cm->color_range = 1; // assume full color-range + if (!(cm->profile == PROFILE_1 || + (cm->profile == PROFILE_2 && cm->bit_depth == AOM_BITS_12))) { + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "sRGB colorspace not compatible with specified profile"); + } } else { - cm->allow_masked_compound = 0; + // [16,235] (including xvycc) vs [0,255] range + cm->color_range = aom_rb_read_bit(rb); + if (cm->profile == PROFILE_0) { + // 420 only + cm->subsampling_x = cm->subsampling_y = 1; + } else if (cm->profile == PROFILE_1) { + // 444 only + cm->subsampling_x = cm->subsampling_y = 0; + } else { + assert(cm->profile == PROFILE_2); + if (cm->bit_depth == AOM_BITS_12) { + cm->subsampling_x = aom_rb_read_bit(rb); + if (cm->subsampling_x) + cm->subsampling_y = aom_rb_read_bit(rb); // 422 or 420 + else + cm->subsampling_y = 0; // 444 + } else { + // 422 + cm->subsampling_x = 1; + cm->subsampling_y = 0; + } + } + if (cm->matrix_coefficients == AOM_CICP_MC_IDENTITY && + (cm->subsampling_x || cm->subsampling_y)) { + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Identity CICP Matrix incompatible with non 4:4:4 color sampling"); + } + if (cm->subsampling_x && cm->subsampling_y) { + cm->chroma_sample_position = aom_rb_read_literal(rb, 2); + } } -#endif // CONFIG_WEDGE || CONFIG_COMPOUND_SEGMENT + cm->separate_uv_delta_q = aom_rb_read_bit(rb); } -#if CONFIG_VAR_REFS -static void check_valid_ref_frames(AV1_COMMON *cm) { - MV_REFERENCE_FRAME ref_frame; - // TODO(zoeliu): To handle ALTREF_FRAME the same way as do with other - // reference frames: Current encoder invalid ALTREF when ALTREF - // is the same as LAST, but invalid all the other references - // when they are the same as ALTREF. - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - LAST_FRAME]; - - if (ref_buf->idx != INVALID_IDX) { - ref_buf->is_valid = 1; - - MV_REFERENCE_FRAME ref; - for (ref = LAST_FRAME; ref < ref_frame; ++ref) { - RefBuffer *const buf = &cm->frame_refs[ref - LAST_FRAME]; - if (buf->is_valid && buf->idx == ref_buf->idx) { - if (ref_frame != ALTREF_FRAME || ref == LAST_FRAME) { - ref_buf->is_valid = 0; - break; - } else { - buf->is_valid = 0; - } - } +void av1_read_timing_info_header(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb) { + cm->timing_info.num_units_in_display_tick = aom_rb_read_unsigned_literal( + rb, 32); // Number of units in a display tick + cm->timing_info.time_scale = + aom_rb_read_unsigned_literal(rb, 32); // Time scale + if (cm->timing_info.num_units_in_display_tick == 0 || + cm->timing_info.time_scale == 0) { + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "num_units_in_display_tick and time_scale must be greater than 0."); + } + cm->timing_info.equal_picture_interval = + aom_rb_read_bit(rb); // Equal picture interval bit + if (cm->timing_info.equal_picture_interval) { + cm->timing_info.num_ticks_per_picture = + aom_rb_read_uvlc(rb) + 1; // ticks per picture + if (cm->timing_info.num_ticks_per_picture == 0) { + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "num_ticks_per_picture_minus_1 cannot be (1 << 32) − 1."); + } + } +} + +void av1_read_decoder_model_info(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb) { + cm->buffer_model.encoder_decoder_buffer_delay_length = + aom_rb_read_literal(rb, 5) + 1; + cm->buffer_model.num_units_in_decoding_tick = aom_rb_read_unsigned_literal( + rb, 32); // Number of units in a decoding tick + cm->buffer_model.buffer_removal_delay_length = aom_rb_read_literal(rb, 5) + 1; + cm->buffer_model.frame_presentation_delay_length = + aom_rb_read_literal(rb, 5) + 1; +} + +void av1_read_op_parameters_info(AV1_COMMON *const cm, + struct aom_read_bit_buffer *rb, int op_num) { + // The cm->op_params array has MAX_NUM_OPERATING_POINTS + 1 elements. + if (op_num > MAX_NUM_OPERATING_POINTS) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "AV1 does not support %d decoder model operating points", + op_num + 1); + } + + cm->op_params[op_num].decoder_buffer_delay = aom_rb_read_literal( + rb, cm->buffer_model.encoder_decoder_buffer_delay_length); + + cm->op_params[op_num].encoder_buffer_delay = aom_rb_read_literal( + rb, cm->buffer_model.encoder_decoder_buffer_delay_length); + + cm->op_params[op_num].low_delay_mode_flag = aom_rb_read_bit(rb); +} + +static void av1_read_tu_pts_info(AV1_COMMON *const cm, + struct aom_read_bit_buffer *rb) { + cm->tu_presentation_delay = + aom_rb_read_literal(rb, cm->buffer_model.frame_presentation_delay_length); +} + +void read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { + // rb->error_handler may be triggered during aom_rb_read_bit(), raising + // internal errors and immediate decoding termination. We use a local variable + // to store the info. as we decode. At the end, if no errors have occurred, + // cm->seq_params is updated. + SequenceHeader sh = cm->seq_params; + SequenceHeader *const seq_params = &sh; + int num_bits_width = aom_rb_read_literal(rb, 4) + 1; + int num_bits_height = aom_rb_read_literal(rb, 4) + 1; + int max_frame_width = aom_rb_read_literal(rb, num_bits_width) + 1; + int max_frame_height = aom_rb_read_literal(rb, num_bits_height) + 1; + + seq_params->num_bits_width = num_bits_width; + seq_params->num_bits_height = num_bits_height; + seq_params->max_frame_width = max_frame_width; + seq_params->max_frame_height = max_frame_height; + + if (seq_params->reduced_still_picture_hdr) { + seq_params->frame_id_numbers_present_flag = 0; + } else { + seq_params->frame_id_numbers_present_flag = aom_rb_read_bit(rb); + } + if (seq_params->frame_id_numbers_present_flag) { + // We must always have delta_frame_id_length < frame_id_length, + // in order for a frame to be referenced with a unique delta. + // Avoid wasting bits by using a coding that enforces this restriction. + seq_params->delta_frame_id_length = aom_rb_read_literal(rb, 4) + 2; + seq_params->frame_id_length = + aom_rb_read_literal(rb, 3) + seq_params->delta_frame_id_length + 1; + if (seq_params->frame_id_length > 16) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Invalid frame_id_length"); + } + + setup_sb_size(seq_params, rb); + + seq_params->enable_filter_intra = aom_rb_read_bit(rb); + seq_params->enable_intra_edge_filter = aom_rb_read_bit(rb); + + if (seq_params->reduced_still_picture_hdr) { + seq_params->enable_interintra_compound = 0; + seq_params->enable_masked_compound = 0; + seq_params->enable_warped_motion = 0; + seq_params->enable_dual_filter = 0; + seq_params->enable_order_hint = 0; + seq_params->enable_jnt_comp = 0; + seq_params->enable_ref_frame_mvs = 0; + seq_params->force_screen_content_tools = 2; // SELECT_SCREEN_CONTENT_TOOLS + seq_params->force_integer_mv = 2; // SELECT_INTEGER_MV + seq_params->order_hint_bits_minus_1 = -1; + } else { + seq_params->enable_interintra_compound = aom_rb_read_bit(rb); + seq_params->enable_masked_compound = aom_rb_read_bit(rb); + seq_params->enable_warped_motion = aom_rb_read_bit(rb); + seq_params->enable_dual_filter = aom_rb_read_bit(rb); + + seq_params->enable_order_hint = aom_rb_read_bit(rb); + seq_params->enable_jnt_comp = + seq_params->enable_order_hint ? aom_rb_read_bit(rb) : 0; + seq_params->enable_ref_frame_mvs = + seq_params->enable_order_hint ? aom_rb_read_bit(rb) : 0; + + if (aom_rb_read_bit(rb)) { + seq_params->force_screen_content_tools = + 2; // SELECT_SCREEN_CONTENT_TOOLS + } else { + seq_params->force_screen_content_tools = aom_rb_read_bit(rb); + } + + if (seq_params->force_screen_content_tools > 0) { + if (aom_rb_read_bit(rb)) { + seq_params->force_integer_mv = 2; // SELECT_INTEGER_MV + } else { + seq_params->force_integer_mv = aom_rb_read_bit(rb); } } else { - ref_buf->is_valid = 0; + seq_params->force_integer_mv = 2; // SELECT_INTEGER_MV } + seq_params->order_hint_bits_minus_1 = + seq_params->enable_order_hint ? aom_rb_read_literal(rb, 3) : -1; } + + seq_params->enable_superres = aom_rb_read_bit(rb); + seq_params->enable_cdef = aom_rb_read_bit(rb); + seq_params->enable_restoration = aom_rb_read_bit(rb); + cm->seq_params = *seq_params; } -#endif // CONFIG_VAR_REFS -#if CONFIG_GLOBAL_MOTION static int read_global_motion_params(WarpedMotionParams *params, const WarpedMotionParams *ref_params, struct aom_read_bit_buffer *rb, int allow_hp) { TransformationType type = aom_rb_read_bit(rb); if (type != IDENTITY) { -#if GLOBAL_TRANS_TYPES > 4 - type += aom_rb_read_literal(rb, GLOBAL_TYPE_BITS); -#else if (aom_rb_read_bit(rb)) type = ROTZOOM; else type = aom_rb_read_bit(rb) ? TRANSLATION : AFFINE; -#endif // GLOBAL_TRANS_TYPES > 4 } - int trans_bits; - int trans_dec_factor; - int trans_prec_diff; *params = default_warp_params; params->wmtype = type; - switch (type) { - case HOMOGRAPHY: - case HORTRAPEZOID: - case VERTRAPEZOID: - if (type != HORTRAPEZOID) - params->wmmat[6] = - aom_rb_read_signed_primitive_refsubexpfin( - rb, GM_ROW3HOMO_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[6] >> GM_ROW3HOMO_PREC_DIFF)) * - GM_ROW3HOMO_DECODE_FACTOR; - if (type != VERTRAPEZOID) - params->wmmat[7] = - aom_rb_read_signed_primitive_refsubexpfin( - rb, GM_ROW3HOMO_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[7] >> GM_ROW3HOMO_PREC_DIFF)) * - GM_ROW3HOMO_DECODE_FACTOR; - case AFFINE: - case ROTZOOM: - params->wmmat[2] = aom_rb_read_signed_primitive_refsubexpfin( - rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[2] >> GM_ALPHA_PREC_DIFF) - - (1 << GM_ALPHA_PREC_BITS)) * - GM_ALPHA_DECODE_FACTOR + - (1 << WARPEDMODEL_PREC_BITS); - if (type != VERTRAPEZOID) - params->wmmat[3] = aom_rb_read_signed_primitive_refsubexpfin( - rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[3] >> GM_ALPHA_PREC_DIFF)) * - GM_ALPHA_DECODE_FACTOR; - if (type >= AFFINE) { - if (type != HORTRAPEZOID) - params->wmmat[4] = aom_rb_read_signed_primitive_refsubexpfin( - rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[4] >> GM_ALPHA_PREC_DIFF)) * - GM_ALPHA_DECODE_FACTOR; - params->wmmat[5] = aom_rb_read_signed_primitive_refsubexpfin( - rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, - (ref_params->wmmat[5] >> GM_ALPHA_PREC_DIFF) - - (1 << GM_ALPHA_PREC_BITS)) * - GM_ALPHA_DECODE_FACTOR + - (1 << WARPEDMODEL_PREC_BITS); - } else { - params->wmmat[4] = -params->wmmat[3]; - params->wmmat[5] = params->wmmat[2]; - } - // fallthrough intended - case TRANSLATION: - trans_bits = (type == TRANSLATION) ? GM_ABS_TRANS_ONLY_BITS - !allow_hp - : GM_ABS_TRANS_BITS; - trans_dec_factor = (type == TRANSLATION) - ? GM_TRANS_ONLY_DECODE_FACTOR * (1 << !allow_hp) - : GM_TRANS_DECODE_FACTOR; - trans_prec_diff = (type == TRANSLATION) - ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp - : GM_TRANS_PREC_DIFF; - params->wmmat[0] = aom_rb_read_signed_primitive_refsubexpfin( - rb, (1 << trans_bits) + 1, SUBEXPFIN_K, - (ref_params->wmmat[0] >> trans_prec_diff)) * - trans_dec_factor; - params->wmmat[1] = aom_rb_read_signed_primitive_refsubexpfin( - rb, (1 << trans_bits) + 1, SUBEXPFIN_K, - (ref_params->wmmat[1] >> trans_prec_diff)) * - trans_dec_factor; - case IDENTITY: break; - default: assert(0); + + if (type >= ROTZOOM) { + params->wmmat[2] = aom_rb_read_signed_primitive_refsubexpfin( + rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[2] >> GM_ALPHA_PREC_DIFF) - + (1 << GM_ALPHA_PREC_BITS)) * + GM_ALPHA_DECODE_FACTOR + + (1 << WARPEDMODEL_PREC_BITS); + params->wmmat[3] = aom_rb_read_signed_primitive_refsubexpfin( + rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[3] >> GM_ALPHA_PREC_DIFF)) * + GM_ALPHA_DECODE_FACTOR; + } + + if (type >= AFFINE) { + params->wmmat[4] = aom_rb_read_signed_primitive_refsubexpfin( + rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[4] >> GM_ALPHA_PREC_DIFF)) * + GM_ALPHA_DECODE_FACTOR; + params->wmmat[5] = aom_rb_read_signed_primitive_refsubexpfin( + rb, GM_ALPHA_MAX + 1, SUBEXPFIN_K, + (ref_params->wmmat[5] >> GM_ALPHA_PREC_DIFF) - + (1 << GM_ALPHA_PREC_BITS)) * + GM_ALPHA_DECODE_FACTOR + + (1 << WARPEDMODEL_PREC_BITS); + } else { + params->wmmat[4] = -params->wmmat[3]; + params->wmmat[5] = params->wmmat[2]; + } + + if (type >= TRANSLATION) { + const int trans_bits = (type == TRANSLATION) + ? GM_ABS_TRANS_ONLY_BITS - !allow_hp + : GM_ABS_TRANS_BITS; + const int trans_dec_factor = + (type == TRANSLATION) ? GM_TRANS_ONLY_DECODE_FACTOR * (1 << !allow_hp) + : GM_TRANS_DECODE_FACTOR; + const int trans_prec_diff = (type == TRANSLATION) + ? GM_TRANS_ONLY_PREC_DIFF + !allow_hp + : GM_TRANS_PREC_DIFF; + params->wmmat[0] = aom_rb_read_signed_primitive_refsubexpfin( + rb, (1 << trans_bits) + 1, SUBEXPFIN_K, + (ref_params->wmmat[0] >> trans_prec_diff)) * + trans_dec_factor; + params->wmmat[1] = aom_rb_read_signed_primitive_refsubexpfin( + rb, (1 << trans_bits) + 1, SUBEXPFIN_K, + (ref_params->wmmat[1] >> trans_prec_diff)) * + trans_dec_factor; } + if (params->wmtype <= AFFINE) { int good_shear_params = get_shear_params(params); if (!good_shear_params) return 0; @@ -4596,16 +3528,18 @@ static int read_global_motion_params(WarpedMotionParams *params, } static void read_global_motion(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { - int frame; - for (frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) { + for (int frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) { const WarpedMotionParams *ref_params = - cm->error_resilient_mode ? &default_warp_params - : &cm->prev_frame->global_motion[frame]; + cm->prev_frame ? &cm->prev_frame->global_motion[frame] + : &default_warp_params; int good_params = read_global_motion_params( &cm->global_motion[frame], ref_params, rb, cm->allow_high_precision_mv); - if (!good_params) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Invalid shear parameters for global motion."); + if (!good_params) { +#if WARPED_MOTION_DEBUG + printf("Warning: unexpected global motion shear params from aomenc\n"); +#endif + cm->global_motion[frame].invalid = 1; + } // TODO(sarahparker, debargha): The logic in the commented out code below // does not work currently and causes mismatches when resize is on. Fix it @@ -4631,252 +3565,397 @@ static void read_global_motion(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { */ } memcpy(cm->cur_frame->global_motion, cm->global_motion, - TOTAL_REFS_PER_FRAME * sizeof(WarpedMotionParams)); + REF_FRAMES * sizeof(WarpedMotionParams)); } -#endif // CONFIG_GLOBAL_MOTION -static size_t read_uncompressed_header(AV1Decoder *pbi, - struct aom_read_bit_buffer *rb) { +static void show_existing_frame_reset(AV1Decoder *const pbi, + int existing_frame_idx) { + AV1_COMMON *const cm = &pbi->common; + BufferPool *const pool = cm->buffer_pool; + RefCntBuffer *const frame_bufs = pool->frame_bufs; + + assert(cm->show_existing_frame); + + cm->frame_type = KEY_FRAME; + + pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1; + + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { + cm->frame_refs[i].idx = INVALID_IDX; + cm->frame_refs[i].buf = NULL; + } + + if (pbi->need_resync) { + memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); + pbi->need_resync = 0; + } + + cm->cur_frame->intra_only = 1; + + if (cm->seq_params.frame_id_numbers_present_flag) { + /* If bitmask is set, update reference frame id values and + mark frames as valid for reference. + Note that the displayed frame be valid for referencing + in order to have been selected. + */ + int refresh_frame_flags = pbi->refresh_frame_flags; + int display_frame_id = cm->ref_frame_id[existing_frame_idx]; + for (int i = 0; i < REF_FRAMES; i++) { + if ((refresh_frame_flags >> i) & 1) { + cm->ref_frame_id[i] = display_frame_id; + cm->valid_for_referencing[i] = 1; + } + } + } + + cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; + + // Generate next_ref_frame_map. + lock_buffer_pool(pool); + int ref_index = 0; + for (int mask = pbi->refresh_frame_flags; mask; mask >>= 1) { + if (mask & 1) { + cm->next_ref_frame_map[ref_index] = cm->new_fb_idx; + ++frame_bufs[cm->new_fb_idx].ref_count; + } else { + cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index]; + } + // Current thread holds the reference frame. + if (cm->ref_frame_map[ref_index] >= 0) + ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count; + ++ref_index; + } + + for (; ref_index < REF_FRAMES; ++ref_index) { + cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index]; + + // Current thread holds the reference frame. + if (cm->ref_frame_map[ref_index] >= 0) + ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count; + } + unlock_buffer_pool(pool); + pbi->hold_ref_buf = 1; + + // Reload the adapted CDFs from when we originally coded this keyframe + *cm->fc = cm->frame_contexts[existing_frame_idx]; +} + +static int read_uncompressed_header(AV1Decoder *pbi, + struct aom_read_bit_buffer *rb) { AV1_COMMON *const cm = &pbi->common; MACROBLOCKD *const xd = &pbi->mb; BufferPool *const pool = cm->buffer_pool; RefCntBuffer *const frame_bufs = pool->frame_bufs; - int i, mask, ref_index = 0; - size_t sz; + + if (!pbi->sequence_header_ready) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "No sequence header"); + } cm->last_frame_type = cm->frame_type; cm->last_intra_only = cm->intra_only; -#if CONFIG_EXT_REFS // NOTE: By default all coded frames to be used as a reference cm->is_reference_frame = 1; -#endif // CONFIG_EXT_REFS -#if !CONFIG_OBU - if (aom_rb_read_literal(rb, 2) != AOM_FRAME_MARKER) - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Invalid frame marker"); + if (cm->seq_params.reduced_still_picture_hdr) { + cm->show_existing_frame = 0; + cm->show_frame = 1; + cm->frame_type = KEY_FRAME; + cm->error_resilient_mode = 1; + } else { + cm->show_existing_frame = aom_rb_read_bit(rb); + cm->reset_decoder_state = 0; + + if (cm->show_existing_frame) { + // Show an existing frame directly. + const int existing_frame_idx = aom_rb_read_literal(rb, 3); + const int frame_to_show = cm->ref_frame_map[existing_frame_idx]; + if (cm->seq_params.decoder_model_info_present_flag && + cm->timing_info.equal_picture_interval == 0) { + av1_read_tu_pts_info(cm, rb); + } + if (cm->seq_params.frame_id_numbers_present_flag) { + int frame_id_length = cm->seq_params.frame_id_length; + int display_frame_id = aom_rb_read_literal(rb, frame_id_length); + /* Compare display_frame_id with ref_frame_id and check valid for + * referencing */ + if (display_frame_id != cm->ref_frame_id[existing_frame_idx] || + cm->valid_for_referencing[existing_frame_idx] == 0) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Reference buffer frame ID mismatch"); + } + lock_buffer_pool(pool); + if (frame_to_show < 0 || frame_bufs[frame_to_show].ref_count < 1) { + unlock_buffer_pool(pool); + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Buffer %d does not contain a decoded frame", + frame_to_show); + } + ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show); + cm->reset_decoder_state = + frame_bufs[frame_to_show].frame_type == KEY_FRAME; + unlock_buffer_pool(pool); - cm->profile = av1_read_profile(rb); + cm->lf.filter_level[0] = 0; + cm->lf.filter_level[1] = 0; + cm->show_frame = 1; - const BITSTREAM_PROFILE MAX_SUPPORTED_PROFILE = - CONFIG_HIGHBITDEPTH ? MAX_PROFILES : PROFILE_2; + if (!frame_bufs[frame_to_show].showable_frame) { + aom_merge_corrupted_flag(&xd->corrupted, 1); + } + if (cm->reset_decoder_state) frame_bufs[frame_to_show].showable_frame = 0; - if (cm->profile >= MAX_SUPPORTED_PROFILE) - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Unsupported bitstream profile"); -#endif + cm->film_grain_params = frame_bufs[frame_to_show].film_grain_params; -#if CONFIG_EXT_TILE - cm->large_scale_tile = aom_rb_read_literal(rb, 1); -#if CONFIG_REFERENCE_BUFFER - if (cm->large_scale_tile) cm->seq_params.frame_id_numbers_present_flag = 0; -#endif // CONFIG_REFERENCE_BUFFER -#endif // CONFIG_EXT_TILE + if (cm->reset_decoder_state) { + show_existing_frame_reset(pbi, existing_frame_idx); + } else { + pbi->refresh_frame_flags = 0; + } - cm->show_existing_frame = aom_rb_read_bit(rb); + return 0; + } - if (cm->show_existing_frame) { - // Show an existing frame directly. - const int existing_frame_idx = aom_rb_read_literal(rb, 3); - const int frame_to_show = cm->ref_frame_map[existing_frame_idx]; -#if CONFIG_REFERENCE_BUFFER - if (cm->seq_params.frame_id_numbers_present_flag) { - int frame_id_length = cm->seq_params.frame_id_length_minus7 + 7; - int display_frame_id = aom_rb_read_literal(rb, frame_id_length); - /* Compare display_frame_id with ref_frame_id and check valid for - * referencing */ - if (display_frame_id != cm->ref_frame_id[existing_frame_idx] || - cm->valid_for_referencing[existing_frame_idx] == 0) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Reference buffer frame ID mismatch"); + cm->frame_type = (FRAME_TYPE)aom_rb_read_literal(rb, 2); // 2 bits + cm->show_frame = aom_rb_read_bit(rb); + if (cm->seq_params.still_picture && + (cm->frame_type != KEY_FRAME || !cm->show_frame)) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Still pictures must be coded as shown keyframes"); } -#endif - lock_buffer_pool(pool); - if (frame_to_show < 0 || frame_bufs[frame_to_show].ref_count < 1) { - unlock_buffer_pool(pool); - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Buffer %d does not contain a decoded frame", - frame_to_show); + cm->showable_frame = cm->frame_type != KEY_FRAME; + if (cm->show_frame) { + if (cm->seq_params.decoder_model_info_present_flag && + cm->timing_info.equal_picture_interval == 0) + av1_read_tu_pts_info(cm, rb); + } else { + // See if this frame can be used as show_existing_frame in future + cm->showable_frame = aom_rb_read_bit(rb); } - ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show); - unlock_buffer_pool(pool); + cm->cur_frame->showable_frame = cm->showable_frame; + cm->intra_only = cm->frame_type == INTRA_ONLY_FRAME; + cm->error_resilient_mode = + frame_is_sframe(cm) || (cm->frame_type == KEY_FRAME && cm->show_frame) + ? 1 + : aom_rb_read_bit(rb); + } -#if CONFIG_LOOPFILTER_LEVEL - cm->lf.filter_level[0] = 0; - cm->lf.filter_level[1] = 0; -#else - cm->lf.filter_level = 0; -#endif - cm->show_frame = 1; - pbi->refresh_frame_flags = 0; + cm->disable_cdf_update = aom_rb_read_bit(rb); + if (cm->seq_params.force_screen_content_tools == 2) { + cm->allow_screen_content_tools = aom_rb_read_bit(rb); + } else { + cm->allow_screen_content_tools = cm->seq_params.force_screen_content_tools; + } - if (cm->frame_parallel_decode) { - for (i = 0; i < REF_FRAMES; ++i) - cm->next_ref_frame_map[i] = cm->ref_frame_map[i]; + if (cm->allow_screen_content_tools) { + if (cm->seq_params.force_integer_mv == 2) { + cm->cur_frame_force_integer_mv = aom_rb_read_bit(rb); + } else { + cm->cur_frame_force_integer_mv = cm->seq_params.force_integer_mv; } - - return 0; + } else { + cm->cur_frame_force_integer_mv = 0; } -#if !CONFIG_OBU - cm->frame_type = (FRAME_TYPE)aom_rb_read_bit(rb); - cm->show_frame = aom_rb_read_bit(rb); - if (cm->frame_type != KEY_FRAME) - cm->intra_only = cm->show_frame ? 0 : aom_rb_read_bit(rb); -#else - cm->frame_type = (FRAME_TYPE)aom_rb_read_literal(rb, 2); // 2 bits - cm->show_frame = aom_rb_read_bit(rb); - cm->intra_only = cm->frame_type == INTRA_ONLY_FRAME; -#endif - cm->error_resilient_mode = aom_rb_read_bit(rb); -#if CONFIG_REFERENCE_BUFFER -#if !CONFIG_OBU - if (frame_is_intra_only(cm)) read_sequence_header(&cm->seq_params, rb); -#endif // !CONFIG_OBU - if (cm->seq_params.frame_id_numbers_present_flag) { - int frame_id_length = cm->seq_params.frame_id_length_minus7 + 7; - int diff_len = cm->seq_params.delta_frame_id_length_minus2 + 2; - int prev_frame_id = 0; - if (cm->frame_type != KEY_FRAME) { - prev_frame_id = cm->current_frame_id; - } - cm->current_frame_id = aom_rb_read_literal(rb, frame_id_length); + cm->frame_refs_short_signaling = 0; + int frame_size_override_flag = 0; + cm->allow_intrabc = 0; + cm->primary_ref_frame = PRIMARY_REF_NONE; - if (cm->frame_type != KEY_FRAME) { - int diff_frame_id; - if (cm->current_frame_id > prev_frame_id) { - diff_frame_id = cm->current_frame_id - prev_frame_id; - } else { - diff_frame_id = - (1 << frame_id_length) + cm->current_frame_id - prev_frame_id; + if (!cm->seq_params.reduced_still_picture_hdr) { + if (cm->seq_params.frame_id_numbers_present_flag) { + int frame_id_length = cm->seq_params.frame_id_length; + int diff_len = cm->seq_params.delta_frame_id_length; + int prev_frame_id = 0; + int have_prev_frame_id = !pbi->decoding_first_frame && + !(cm->frame_type == KEY_FRAME && cm->show_frame); + if (have_prev_frame_id) { + prev_frame_id = cm->current_frame_id; } - /* Check current_frame_id for conformance */ - if (prev_frame_id == cm->current_frame_id || - diff_frame_id >= (1 << (frame_id_length - 1))) { - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Invalid value of current_frame_id"); + cm->current_frame_id = aom_rb_read_literal(rb, frame_id_length); + + if (have_prev_frame_id) { + int diff_frame_id; + if (cm->current_frame_id > prev_frame_id) { + diff_frame_id = cm->current_frame_id - prev_frame_id; + } else { + diff_frame_id = + (1 << frame_id_length) + cm->current_frame_id - prev_frame_id; + } + /* Check current_frame_id for conformance */ + if (prev_frame_id == cm->current_frame_id || + diff_frame_id >= (1 << (frame_id_length - 1))) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Invalid value of current_frame_id"); + } } - } - /* Check if some frames need to be marked as not valid for referencing */ - for (i = 0; i < REF_FRAMES; i++) { - if (cm->frame_type == KEY_FRAME) { - cm->valid_for_referencing[i] = 0; - } else if (cm->current_frame_id - (1 << diff_len) > 0) { - if (cm->ref_frame_id[i] > cm->current_frame_id || - cm->ref_frame_id[i] < cm->current_frame_id - (1 << diff_len)) - cm->valid_for_referencing[i] = 0; - } else { - if (cm->ref_frame_id[i] > cm->current_frame_id && - cm->ref_frame_id[i] < - (1 << frame_id_length) + cm->current_frame_id - (1 << diff_len)) + /* Check if some frames need to be marked as not valid for referencing */ + for (int i = 0; i < REF_FRAMES; i++) { + if (cm->frame_type == KEY_FRAME && cm->show_frame) { cm->valid_for_referencing[i] = 0; + } else if (cm->current_frame_id - (1 << diff_len) > 0) { + if (cm->ref_frame_id[i] > cm->current_frame_id || + cm->ref_frame_id[i] < cm->current_frame_id - (1 << diff_len)) + cm->valid_for_referencing[i] = 0; + } else { + if (cm->ref_frame_id[i] > cm->current_frame_id && + cm->ref_frame_id[i] < (1 << frame_id_length) + + cm->current_frame_id - (1 << diff_len)) + cm->valid_for_referencing[i] = 0; + } + } + } + + frame_size_override_flag = + frame_is_sframe(cm) ? 1 : aom_rb_read_literal(rb, 1); + + cm->frame_offset = + aom_rb_read_literal(rb, cm->seq_params.order_hint_bits_minus_1 + 1); + cm->current_video_frame = cm->frame_offset; + + if (!cm->error_resilient_mode && !frame_is_intra_only(cm)) { + cm->primary_ref_frame = aom_rb_read_literal(rb, PRIMARY_REF_BITS); + } + } + + if (cm->seq_params.decoder_model_info_present_flag) { + cm->buffer_removal_delay_present = aom_rb_read_bit(rb); + if (cm->buffer_removal_delay_present) { + for (int op_num = 0; + op_num < cm->seq_params.operating_points_cnt_minus_1 + 1; op_num++) { + if (cm->op_params[op_num].decoder_model_param_present_flag) { + if ((((cm->seq_params.operating_point_idc[op_num] >> + cm->temporal_layer_id) & + 0x1) && + ((cm->seq_params.operating_point_idc[op_num] >> + (cm->spatial_layer_id + 8)) & + 0x1)) || + cm->seq_params.operating_point_idc[op_num] == 0) { + cm->op_frame_timing[op_num].buffer_removal_delay = + aom_rb_read_literal( + rb, cm->buffer_model.buffer_removal_delay_length); + } else { + cm->op_frame_timing[op_num].buffer_removal_delay = 0; + } + } else { + cm->op_frame_timing[op_num].buffer_removal_delay = 0; + } } } } -#endif // CONFIG_REFERENCE_BUFFER if (cm->frame_type == KEY_FRAME) { -#if !CONFIG_OBU - read_bitdepth_colorspace_sampling(cm, rb, pbi->allow_lowbitdepth); -#endif - pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1; + if (!cm->show_frame) // unshown keyframe (forward keyframe) + pbi->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES); + else // shown keyframe + pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1; - for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { cm->frame_refs[i].idx = INVALID_IDX; cm->frame_refs[i].buf = NULL; -#if CONFIG_VAR_REFS - cm->frame_refs[i].is_valid = 0; -#endif // CONFIG_VAR_REFS } - - setup_frame_size(cm, rb); - setup_sb_size(cm, rb); - if (pbi->need_resync) { memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); pbi->need_resync = 0; } -#if CONFIG_ANS && ANS_MAX_SYMBOLS - cm->ans_window_size_log2 = aom_rb_read_literal(rb, 4) + 8; -#endif // CONFIG_ANS && ANS_MAX_SYMBOLS - cm->allow_screen_content_tools = aom_rb_read_bit(rb); -#if CONFIG_AMVR - if (cm->allow_screen_content_tools) { - if (aom_rb_read_bit(rb)) { - cm->seq_mv_precision_level = 2; - } else { - cm->seq_mv_precision_level = aom_rb_read_bit(rb) ? 0 : 1; - } - } else { - cm->seq_mv_precision_level = 0; - } -#endif -#if CONFIG_TEMPMV_SIGNALING - cm->use_prev_frame_mvs = 0; -#endif } else { - if (cm->intra_only) cm->allow_screen_content_tools = aom_rb_read_bit(rb); -#if CONFIG_TEMPMV_SIGNALING - if (cm->intra_only || cm->error_resilient_mode) cm->use_prev_frame_mvs = 0; -#endif -#if CONFIG_NO_FRAME_CONTEXT_SIGNALING -// The only way to reset all frame contexts to their default values is with a -// keyframe. -#else - if (cm->error_resilient_mode) { - cm->reset_frame_context = RESET_FRAME_CONTEXT_ALL; - } else { - if (cm->intra_only) { - cm->reset_frame_context = aom_rb_read_bit(rb) - ? RESET_FRAME_CONTEXT_ALL - : RESET_FRAME_CONTEXT_CURRENT; - } else { - cm->reset_frame_context = aom_rb_read_bit(rb) - ? RESET_FRAME_CONTEXT_CURRENT - : RESET_FRAME_CONTEXT_NONE; - if (cm->reset_frame_context == RESET_FRAME_CONTEXT_CURRENT) - cm->reset_frame_context = aom_rb_read_bit(rb) - ? RESET_FRAME_CONTEXT_ALL - : RESET_FRAME_CONTEXT_CURRENT; - } - } -#endif - if (cm->intra_only) { -#if !CONFIG_OBU - read_bitdepth_colorspace_sampling(cm, rb, pbi->allow_lowbitdepth); -#endif - pbi->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES); - setup_frame_size(cm, rb); - setup_sb_size(cm, rb); + if (pbi->refresh_frame_flags == 0xFF) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Intra only frames cannot have refresh flags 0xFF"); + } if (pbi->need_resync) { memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); pbi->need_resync = 0; } -#if CONFIG_ANS && ANS_MAX_SYMBOLS - cm->ans_window_size_log2 = aom_rb_read_literal(rb, 4) + 8; -#endif } else if (pbi->need_resync != 1) { /* Skip if need resync */ -#if CONFIG_OBU - pbi->refresh_frame_flags = (cm->frame_type == S_FRAME) - ? ~(1 << REF_FRAMES) - : aom_rb_read_literal(rb, REF_FRAMES); -#else - pbi->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES); -#endif - -#if CONFIG_EXT_REFS + pbi->refresh_frame_flags = + frame_is_sframe(cm) ? 0xFF : aom_rb_read_literal(rb, REF_FRAMES); if (!pbi->refresh_frame_flags) { // NOTE: "pbi->refresh_frame_flags == 0" indicates that the coded frame // will not be used as a reference cm->is_reference_frame = 0; } -#endif // CONFIG_EXT_REFS + } + } - for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { - const int ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2); - const int idx = cm->ref_frame_map[ref]; + if (!frame_is_intra_only(cm) || pbi->refresh_frame_flags != 0xFF) { + // Read all ref frame order hints if error_resilient_mode == 1 + if (cm->error_resilient_mode && cm->seq_params.enable_order_hint) { + for (int ref_idx = 0; ref_idx < REF_FRAMES; ref_idx++) { + // Read order hint from bit stream + unsigned int frame_offset = + aom_rb_read_literal(rb, cm->seq_params.order_hint_bits_minus_1 + 1); + // Get buffer index + int buf_idx = cm->ref_frame_map[ref_idx]; + assert(buf_idx < FRAME_BUFFERS); + if (buf_idx == -1 || + frame_offset != frame_bufs[buf_idx].cur_frame_offset) { + if (buf_idx >= 0) { + lock_buffer_pool(pool); + decrease_ref_count(buf_idx, frame_bufs, pool); + unlock_buffer_pool(pool); + } + // If no corresponding buffer exists, allocate a new buffer with all + // pixels set to neutral grey. + buf_idx = get_free_fb(cm); + if (buf_idx == INVALID_IDX) { + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Unable to find free frame buffer"); + } + lock_buffer_pool(pool); + if (aom_realloc_frame_buffer( + &frame_bufs[buf_idx].buf, cm->seq_params.max_frame_width, + cm->seq_params.max_frame_height, cm->subsampling_x, + cm->subsampling_y, cm->use_highbitdepth, AOM_BORDER_IN_PIXELS, + cm->byte_alignment, + &pool->frame_bufs[buf_idx].raw_frame_buffer, pool->get_fb_cb, + pool->cb_priv)) { + unlock_buffer_pool(pool); + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Failed to allocate frame buffer"); + } + unlock_buffer_pool(pool); + set_planes_to_neutral_grey(cm, &frame_bufs[buf_idx].buf, 0); + + cm->ref_frame_map[ref_idx] = buf_idx; + frame_bufs[buf_idx].cur_frame_offset = frame_offset; + } + } + } + } + + if (cm->frame_type == KEY_FRAME) { + setup_frame_size(cm, frame_size_override_flag, rb); + + if (cm->allow_screen_content_tools && !av1_superres_scaled(cm)) + cm->allow_intrabc = aom_rb_read_bit(rb); + cm->allow_ref_frame_mvs = 0; + cm->prev_frame = NULL; + } else { + cm->allow_ref_frame_mvs = 0; + + if (cm->intra_only) { + cm->cur_frame->film_grain_params_present = cm->film_grain_params_present; + setup_frame_size(cm, frame_size_override_flag, rb); + if (cm->allow_screen_content_tools && !av1_superres_scaled(cm)) + cm->allow_intrabc = aom_rb_read_bit(rb); + + } else if (pbi->need_resync != 1) { /* Skip if need resync */ + + // Frame refs short signaling is off when error resilient mode is on. + if (cm->seq_params.enable_order_hint) + cm->frame_refs_short_signaling = aom_rb_read_bit(rb); + + if (cm->frame_refs_short_signaling) { + // == LAST_FRAME == + const int lst_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2); + const int lst_idx = cm->ref_frame_map[lst_ref]; + + // == GOLDEN_FRAME == + const int gld_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2); + const int gld_idx = cm->ref_frame_map[gld_ref]; // Most of the time, streams start with a keyframe. In that case, // ref_frame_map will have been filled in at that point and will not @@ -4884,146 +3963,136 @@ static size_t read_uncompressed_header(AV1Decoder *pbi, // with an intra-only frame, so long as they don't then signal a // reference to a slot that hasn't been set yet. That's what we are // checking here. - if (idx == -1) + if (lst_idx == -1) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Inter frame requests nonexistent reference"); + if (gld_idx == -1) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Inter frame requests nonexistent reference"); + + av1_set_frame_refs(cm, lst_ref, gld_ref); + } + + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { + int ref = 0; + if (!cm->frame_refs_short_signaling) { + ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2); + const int idx = cm->ref_frame_map[ref]; + + // Most of the time, streams start with a keyframe. In that case, + // ref_frame_map will have been filled in at that point and will not + // contain any -1's. However, streams are explicitly allowed to start + // with an intra-only frame, so long as they don't then signal a + // reference to a slot that hasn't been set yet. That's what we are + // checking here. + if (idx == -1) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Inter frame requests nonexistent reference"); + + RefBuffer *const ref_frame = &cm->frame_refs[i]; + ref_frame->idx = idx; + ref_frame->buf = &frame_bufs[idx].buf; + ref_frame->map_idx = ref; + } else { + ref = cm->frame_refs[i].map_idx; + } - RefBuffer *const ref_frame = &cm->frame_refs[i]; - ref_frame->idx = idx; - ref_frame->buf = &frame_bufs[idx].buf; -#if CONFIG_FRAME_SIGN_BIAS -#if CONFIG_OBU - // NOTE: For the scenario of (cm->frame_type != S_FRAME), - // ref_frame_sign_bias will be reset based on frame offsets. cm->ref_frame_sign_bias[LAST_FRAME + i] = 0; -#endif // CONFIG_OBU -#else // !CONFIG_FRAME_SIGN_BIAS -#if CONFIG_OBU - cm->ref_frame_sign_bias[LAST_FRAME + i] = - (cm->frame_type == S_FRAME) ? 0 : aom_rb_read_bit(rb); -#else // !CONFIG_OBU - cm->ref_frame_sign_bias[LAST_FRAME + i] = aom_rb_read_bit(rb); -#endif // CONFIG_OBU -#endif // CONFIG_FRAME_SIGN_BIAS -#if CONFIG_REFERENCE_BUFFER + if (cm->seq_params.frame_id_numbers_present_flag) { - int frame_id_length = cm->seq_params.frame_id_length_minus7 + 7; - int diff_len = cm->seq_params.delta_frame_id_length_minus2 + 2; - int delta_frame_id_minus1 = aom_rb_read_literal(rb, diff_len); + int frame_id_length = cm->seq_params.frame_id_length; + int diff_len = cm->seq_params.delta_frame_id_length; + int delta_frame_id_minus_1 = aom_rb_read_literal(rb, diff_len); int ref_frame_id = - ((cm->current_frame_id - (delta_frame_id_minus1 + 1) + + ((cm->current_frame_id - (delta_frame_id_minus_1 + 1) + (1 << frame_id_length)) % (1 << frame_id_length)); - /* Compare values derived from delta_frame_id_minus1 and - * refresh_frame_flags. Also, check valid for referencing */ + // Compare values derived from delta_frame_id_minus_1 and + // refresh_frame_flags. Also, check valid for referencing if (ref_frame_id != cm->ref_frame_id[ref] || cm->valid_for_referencing[ref] == 0) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Reference buffer frame ID mismatch"); } -#endif // CONFIG_REFERENCE_BUFFER } -#if CONFIG_VAR_REFS - check_valid_ref_frames(cm); -#endif // CONFIG_VAR_REFS - -#if CONFIG_FRAME_SIZE - if (cm->error_resilient_mode == 0) { + if (!cm->error_resilient_mode && frame_size_override_flag) { setup_frame_size_with_refs(cm, rb); } else { - setup_frame_size(cm, rb); + setup_frame_size(cm, frame_size_override_flag, rb); } -#else - setup_frame_size_with_refs(cm, rb); -#endif -#if CONFIG_AMVR - if (cm->seq_mv_precision_level == 2) { - cm->cur_frame_mv_precision_level = aom_rb_read_bit(rb) ? 0 : 1; + if (cm->cur_frame_force_integer_mv) { + cm->allow_high_precision_mv = 0; } else { - cm->cur_frame_mv_precision_level = cm->seq_mv_precision_level; + cm->allow_high_precision_mv = aom_rb_read_bit(rb); } -#endif - cm->allow_high_precision_mv = aom_rb_read_bit(rb); cm->interp_filter = read_frame_interp_filter(rb); -#if CONFIG_TEMPMV_SIGNALING - if (frame_might_use_prev_frame_mvs(cm)) - cm->use_prev_frame_mvs = aom_rb_read_bit(rb); + cm->switchable_motion_mode = aom_rb_read_bit(rb); + } + + cm->prev_frame = get_prev_frame(cm); + if (cm->primary_ref_frame != PRIMARY_REF_NONE && + cm->frame_refs[cm->primary_ref_frame].idx < 0) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Reference frame containing this frame's initial " + "frame context is unavailable."); + } + + if (!cm->intra_only && pbi->need_resync != 1) { + if (frame_might_allow_ref_frame_mvs(cm)) + cm->allow_ref_frame_mvs = aom_rb_read_bit(rb); else - cm->use_prev_frame_mvs = 0; -#endif - for (i = 0; i < INTER_REFS_PER_FRAME; ++i) { + cm->allow_ref_frame_mvs = 0; + + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { RefBuffer *const ref_buf = &cm->frame_refs[i]; -#if CONFIG_HIGHBITDEPTH - av1_setup_scale_factors_for_frame( - &ref_buf->sf, ref_buf->buf->y_crop_width, - ref_buf->buf->y_crop_height, cm->width, cm->height, - cm->use_highbitdepth); -#else av1_setup_scale_factors_for_frame( &ref_buf->sf, ref_buf->buf->y_crop_width, ref_buf->buf->y_crop_height, cm->width, cm->height); -#endif + if ((!av1_is_valid_scale(&ref_buf->sf))) + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Reference frame has invalid dimensions"); } } } -#if CONFIG_FRAME_MARKER - if (cm->show_frame == 0) { - cm->frame_offset = cm->current_video_frame + aom_rb_read_literal(rb, 4); - } else { - cm->frame_offset = cm->current_video_frame; - } av1_setup_frame_buf_refs(cm); -#if CONFIG_FRAME_SIGN_BIAS -#if CONFIG_OBU - if (cm->frame_type != S_FRAME) -#endif // CONFIG_OBU - av1_setup_frame_sign_bias(cm); -#define FRAME_SIGN_BIAS_DEBUG 0 -#if FRAME_SIGN_BIAS_DEBUG - { - printf("\n\nDECODER: Frame=%d, show_frame=%d:", cm->current_video_frame, - cm->show_frame); - MV_REFERENCE_FRAME ref_frame; - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - printf(" sign_bias[%d]=%d", ref_frame, - cm->ref_frame_sign_bias[ref_frame]); - } - printf("\n"); - } -#endif // FRAME_SIGN_BIAS_DEBUG -#undef FRAME_SIGN_BIAS_DEBUG -#endif // CONFIG_FRAME_SIGN_BIAS -#endif // CONFIG_FRAME_MARKER + av1_setup_frame_sign_bias(cm); -#if CONFIG_TEMPMV_SIGNALING cm->cur_frame->intra_only = cm->frame_type == KEY_FRAME || cm->intra_only; -#endif + cm->cur_frame->frame_type = cm->frame_type; -#if CONFIG_REFERENCE_BUFFER if (cm->seq_params.frame_id_numbers_present_flag) { /* If bitmask is set, update reference frame id values and mark frames as valid for reference */ - int refresh_frame_flags = - cm->frame_type == KEY_FRAME ? 0xFF : pbi->refresh_frame_flags; - for (i = 0; i < REF_FRAMES; i++) { + int refresh_frame_flags = pbi->refresh_frame_flags; + for (int i = 0; i < REF_FRAMES; i++) { if ((refresh_frame_flags >> i) & 1) { cm->ref_frame_id[i] = cm->current_frame_id; cm->valid_for_referencing[i] = 1; } } } -#endif // CONFIG_REFERENCE_BUFFER + + const int might_bwd_adapt = + !(cm->seq_params.reduced_still_picture_hdr) && !(cm->disable_cdf_update); + if (might_bwd_adapt) { + cm->refresh_frame_context = aom_rb_read_bit(rb) + ? REFRESH_FRAME_CONTEXT_DISABLED + : REFRESH_FRAME_CONTEXT_BACKWARD; + } else { + cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; + } get_frame_new_buffer(cm)->bit_depth = cm->bit_depth; - get_frame_new_buffer(cm)->color_space = cm->color_space; -#if CONFIG_COLORSPACE_HEADERS - get_frame_new_buffer(cm)->transfer_function = cm->transfer_function; + get_frame_new_buffer(cm)->color_primaries = cm->color_primaries; + get_frame_new_buffer(cm)->transfer_characteristics = + cm->transfer_characteristics; + get_frame_new_buffer(cm)->matrix_coefficients = cm->matrix_coefficients; + get_frame_new_buffer(cm)->monochrome = cm->seq_params.monochrome; get_frame_new_buffer(cm)->chroma_sample_position = cm->chroma_sample_position; -#endif get_frame_new_buffer(cm)->color_range = cm->color_range; get_frame_new_buffer(cm)->render_width = cm->render_width; get_frame_new_buffer(cm)->render_height = cm->render_height; @@ -5034,22 +4103,10 @@ static size_t read_uncompressed_header(AV1Decoder *pbi, " state"); } - if (!cm->error_resilient_mode) { - cm->refresh_frame_context = aom_rb_read_bit(rb) - ? REFRESH_FRAME_CONTEXT_FORWARD - : REFRESH_FRAME_CONTEXT_BACKWARD; - } else { - cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_FORWARD; - } -#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING - // This flag will be overridden by the call to av1_setup_past_independence - // below, forcing the use of context 0 for those frame types. - cm->frame_context_idx = aom_rb_read_literal(rb, FRAME_CONTEXTS_LOG2); -#endif - // Generate next_ref_frame_map. lock_buffer_pool(pool); - for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { + int ref_index = 0; + for (int mask = pbi->refresh_frame_flags; mask; mask >>= 1) { if (mask & 1) { cm->next_ref_frame_map[ref_index] = cm->new_fb_idx; ++frame_bufs[cm->new_fb_idx].ref_count; @@ -5072,461 +4129,185 @@ static size_t read_uncompressed_header(AV1Decoder *pbi, unlock_buffer_pool(pool); pbi->hold_ref_buf = 1; - if (frame_is_intra_only(cm) || cm->error_resilient_mode) - av1_setup_past_independence(cm); + if (cm->allow_intrabc) { + // Set parameters corresponding to no filtering. + struct loopfilter *lf = &cm->lf; + lf->filter_level[0] = 0; + lf->filter_level[1] = 0; + cm->cdef_bits = 0; + cm->cdef_strengths[0] = 0; + cm->nb_cdef_strengths = 1; + cm->cdef_uv_strengths[0] = 0; + cm->rst_info[0].frame_restoration_type = RESTORE_NONE; + cm->rst_info[1].frame_restoration_type = RESTORE_NONE; + cm->rst_info[2].frame_restoration_type = RESTORE_NONE; + } - setup_loopfilter(cm, rb); + read_tile_info(pbi, rb); setup_quantization(cm, rb); xd->bd = (int)cm->bit_depth; -#if CONFIG_Q_ADAPT_PROBS - av1_default_coef_probs(cm); - if (cm->frame_type == KEY_FRAME || cm->error_resilient_mode || - cm->reset_frame_context == RESET_FRAME_CONTEXT_ALL) { - for (i = 0; i < FRAME_CONTEXTS; ++i) cm->frame_contexts[i] = *cm->fc; - } else if (cm->reset_frame_context == RESET_FRAME_CONTEXT_CURRENT) { -#if CONFIG_NO_FRAME_CONTEXT_SIGNALING - if (cm->frame_refs[0].idx <= 0) { - cm->frame_contexts[cm->frame_refs[0].idx] = *cm->fc; - } -#else - cm->frame_contexts[cm->frame_context_idx] = *cm->fc; -#endif // CONFIG_NO_FRAME_CONTEXT_SIGNALING + if (cm->num_allocated_above_context_planes < av1_num_planes(cm) || + cm->num_allocated_above_context_mi_col < cm->mi_cols || + cm->num_allocated_above_contexts < cm->tile_rows) { + av1_free_above_context_buffers(cm, cm->num_allocated_above_contexts); + if (av1_alloc_above_context_buffers(cm, cm->tile_rows)) + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Failed to allocate context buffers"); } -#endif // CONFIG_Q_ADAPT_PROBS - setup_segmentation(cm, rb); + if (cm->primary_ref_frame == PRIMARY_REF_NONE) { + av1_setup_past_independence(cm); + } - { - struct segmentation *const seg = &cm->seg; - int segment_quantizer_active = 0; - for (i = 0; i < MAX_SEGMENTS; i++) { - if (segfeature_active(seg, i, SEG_LVL_ALT_Q)) { - segment_quantizer_active = 1; - } - } + setup_segmentation(cm, rb); - cm->delta_q_res = 1; -#if CONFIG_EXT_DELTA_Q - cm->delta_lf_res = 1; - cm->delta_lf_present_flag = 0; -#if CONFIG_LOOPFILTER_LEVEL - cm->delta_lf_multi = 0; -#endif // CONFIG_LOOPFILTER_LEVEL -#endif - if (segment_quantizer_active == 0 && cm->base_qindex > 0) { - cm->delta_q_present_flag = aom_rb_read_bit(rb); - } else { - cm->delta_q_present_flag = 0; - } - if (cm->delta_q_present_flag) { - xd->prev_qindex = cm->base_qindex; - cm->delta_q_res = 1 << aom_rb_read_literal(rb, 2); -#if CONFIG_EXT_DELTA_Q - assert(!segment_quantizer_active); - cm->delta_lf_present_flag = aom_rb_read_bit(rb); - if (cm->delta_lf_present_flag) { - xd->prev_delta_lf_from_base = 0; - cm->delta_lf_res = 1 << aom_rb_read_literal(rb, 2); -#if CONFIG_LOOPFILTER_LEVEL - cm->delta_lf_multi = aom_rb_read_bit(rb); - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) - xd->prev_delta_lf[lf_id] = 0; -#endif // CONFIG_LOOPFILTER_LEVEL - } -#endif // CONFIG_EXT_DELTA_Q + cm->delta_q_res = 1; + cm->delta_lf_res = 1; + cm->delta_lf_present_flag = 0; + cm->delta_lf_multi = 0; + cm->delta_q_present_flag = cm->base_qindex > 0 ? aom_rb_read_bit(rb) : 0; + if (cm->delta_q_present_flag) { + xd->current_qindex = cm->base_qindex; + cm->delta_q_res = 1 << aom_rb_read_literal(rb, 2); + if (!cm->allow_intrabc) cm->delta_lf_present_flag = aom_rb_read_bit(rb); + if (cm->delta_lf_present_flag) { + cm->delta_lf_res = 1 << aom_rb_read_literal(rb, 2); + cm->delta_lf_multi = aom_rb_read_bit(rb); + av1_reset_loop_filter_delta(xd, av1_num_planes(cm)); } } -#if CONFIG_AMVR - xd->cur_frame_mv_precision_level = cm->cur_frame_mv_precision_level; -#endif - for (i = 0; i < MAX_SEGMENTS; ++i) { + xd->cur_frame_force_integer_mv = cm->cur_frame_force_integer_mv; + + for (int i = 0; i < MAX_SEGMENTS; ++i) { const int qindex = cm->seg.enabled ? av1_get_qindex(&cm->seg, i, cm->base_qindex) : cm->base_qindex; xd->lossless[i] = qindex == 0 && cm->y_dc_delta_q == 0 && - cm->uv_dc_delta_q == 0 && cm->uv_ac_delta_q == 0; + cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 && + cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0; xd->qindex[i] = qindex; } - cm->all_lossless = all_lossless(cm, xd); + cm->coded_lossless = is_coded_lossless(cm, xd); + cm->all_lossless = cm->coded_lossless && !av1_superres_scaled(cm); setup_segmentation_dequant(cm); -#if CONFIG_CDEF - if (!cm->all_lossless) { - setup_cdef(cm, rb); + if (cm->coded_lossless) { + cm->lf.filter_level[0] = 0; + cm->lf.filter_level[1] = 0; } -#endif -#if CONFIG_LOOP_RESTORATION - decode_restoration_mode(cm, rb); -#endif // CONFIG_LOOP_RESTORATION - cm->tx_mode = read_tx_mode(cm, rb); - cm->reference_mode = read_frame_reference_mode(cm, rb); - if (cm->reference_mode != SINGLE_REFERENCE) setup_compound_reference_mode(cm); - read_compound_tools(cm, rb); - -#if CONFIG_EXT_TX - cm->reduced_tx_set_used = aom_rb_read_bit(rb); -#endif // CONFIG_EXT_TX - -#if CONFIG_ADAPT_SCAN - cm->use_adapt_scan = aom_rb_read_bit(rb); - // TODO(angiebird): call av1_init_scan_order only when use_adapt_scan - // switches from 1 to 0 - if (cm->use_adapt_scan == 0) av1_init_scan_order(cm); -#endif // CONFIG_ADAPT_SCAN - -#if CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING - // NOTE(zoeliu): As cm->prev_frame can take neither a frame of - // show_exisiting_frame=1, nor can it take a frame not used as - // a reference, it is probable that by the time it is being - // referred to, the frame buffer it originally points to may - // already get expired and have been reassigned to the current - // newly coded frame. Hence, we need to check whether this is - // the case, and if yes, we have 2 choices: - // (1) Simply disable the use of previous frame mvs; or - // (2) Have cm->prev_frame point to one reference frame buffer, - // e.g. LAST_FRAME. - if (!dec_is_ref_frame_buf(pbi, cm->prev_frame)) { - // Reassign the LAST_FRAME buffer to cm->prev_frame. - cm->prev_frame = - cm->frame_refs[LAST_FRAME - LAST_FRAME].idx != INVALID_IDX - ? &cm->buffer_pool - ->frame_bufs[cm->frame_refs[LAST_FRAME - LAST_FRAME].idx] - : NULL; - } -#endif // CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING - -#if CONFIG_TEMPMV_SIGNALING - if (cm->use_prev_frame_mvs && !frame_can_use_prev_frame_mvs(cm)) { - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Frame wrongly requests previous frame MVs"); + if (cm->coded_lossless || !cm->seq_params.enable_cdef) { + cm->cdef_bits = 0; + cm->cdef_strengths[0] = 0; + cm->cdef_uv_strengths[0] = 0; } -#else - cm->use_prev_frame_mvs = !cm->error_resilient_mode && cm->prev_frame && -#if CONFIG_FRAME_SUPERRES - cm->width == cm->last_width && - cm->height == cm->last_height && -#else - cm->width == cm->prev_frame->buf.y_crop_width && - cm->height == cm->prev_frame->buf.y_crop_height && -#endif // CONFIG_FRAME_SUPERRES - !cm->last_intra_only && cm->last_show_frame && - (cm->last_frame_type != KEY_FRAME); -#endif // CONFIG_TEMPMV_SIGNALING - -#if CONFIG_GLOBAL_MOTION - if (!frame_is_intra_only(cm)) read_global_motion(cm, rb); -#endif - - read_tile_info(pbi, rb); - if (use_compressed_header(cm)) { - sz = aom_rb_read_literal(rb, 16); - if (sz == 0) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Invalid header size"); - } else { - sz = 0; + if (cm->all_lossless || !cm->seq_params.enable_restoration) { + cm->rst_info[0].frame_restoration_type = RESTORE_NONE; + cm->rst_info[1].frame_restoration_type = RESTORE_NONE; + cm->rst_info[2].frame_restoration_type = RESTORE_NONE; } - return sz; -} + setup_loopfilter(cm, rb); -#if CONFIG_SUPERTX -static void read_supertx_probs(FRAME_CONTEXT *fc, aom_reader *r) { - int i, j; - if (aom_read(r, GROUP_DIFF_UPDATE_PROB, ACCT_STR)) { - for (i = 0; i < PARTITION_SUPERTX_CONTEXTS; ++i) { - for (j = TX_8X8; j < TX_SIZES; ++j) { - av1_diff_update_prob(r, &fc->supertx_prob[i][j], ACCT_STR); - } - } + if (!cm->coded_lossless && cm->seq_params.enable_cdef) { + setup_cdef(cm, rb); + } + if (!cm->all_lossless && cm->seq_params.enable_restoration) { + decode_restoration_mode(cm, rb); } -} -#endif // CONFIG_SUPERTX - -static int read_compressed_header(AV1Decoder *pbi, const uint8_t *data, - size_t partition_size) { -#if CONFIG_RESTRICT_COMPRESSED_HDR - (void)pbi; - (void)data; - (void)partition_size; - return 0; -#else - AV1_COMMON *const cm = &pbi->common; -#if CONFIG_SUPERTX - MACROBLOCKD *const xd = &pbi->mb; -#endif - aom_reader r; -#if !CONFIG_NEW_MULTISYMBOL - FRAME_CONTEXT *const fc = cm->fc; - int i; -#endif - -#if CONFIG_ANS && ANS_MAX_SYMBOLS - r.window_size = 1 << cm->ans_window_size_log2; -#endif - if (aom_reader_init(&r, data, partition_size, pbi->decrypt_cb, - pbi->decrypt_state)) - aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, - "Failed to allocate bool decoder 0"); -#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX) - if (cm->tx_mode == TX_MODE_SELECT) - av1_diff_update_prob(&r, &fc->quarter_tx_size_prob, ACCT_STR); -#endif + cm->tx_mode = read_tx_mode(cm, rb); + cm->reference_mode = read_frame_reference_mode(cm, rb); + if (cm->reference_mode != SINGLE_REFERENCE) setup_compound_reference_mode(cm); -#if CONFIG_LV_MAP && !LV_MAP_PROB - av1_read_txb_probs(fc, cm->tx_mode, &r, &cm->counts); -#endif // CONFIG_LV_MAP && !LV_MAP_PROB - -#if !CONFIG_NEW_MULTISYMBOL -#if CONFIG_VAR_TX - if (cm->tx_mode == TX_MODE_SELECT) - for (i = 0; i < TXFM_PARTITION_CONTEXTS; ++i) - av1_diff_update_prob(&r, &fc->txfm_partition_prob[i], ACCT_STR); -#endif // CONFIG_VAR_TX - for (i = 0; i < SKIP_CONTEXTS; ++i) - av1_diff_update_prob(&r, &fc->skip_probs[i], ACCT_STR); -#endif + av1_setup_skip_mode_allowed(cm); + cm->skip_mode_flag = cm->is_skip_mode_allowed ? aom_rb_read_bit(rb) : 0; - if (!frame_is_intra_only(cm)) { -#if !CONFIG_NEW_MULTISYMBOL - read_inter_mode_probs(fc, &r); -#endif + if (frame_might_allow_warped_motion(cm)) + cm->allow_warped_motion = aom_rb_read_bit(rb); + else + cm->allow_warped_motion = 0; -#if CONFIG_INTERINTRA - if (cm->reference_mode != COMPOUND_REFERENCE && - cm->allow_interintra_compound) { -#if !CONFIG_NEW_MULTISYMBOL - for (i = 0; i < BLOCK_SIZE_GROUPS; i++) { - if (is_interintra_allowed_bsize_group(i)) { - av1_diff_update_prob(&r, &fc->interintra_prob[i], ACCT_STR); - } - } -#endif -#if CONFIG_WEDGE && !CONFIG_NEW_MULTISYMBOL -#if CONFIG_EXT_PARTITION_TYPES - int block_sizes_to_update = BLOCK_SIZES_ALL; -#else - int block_sizes_to_update = BLOCK_SIZES; -#endif - for (i = 0; i < block_sizes_to_update; i++) { - if (is_interintra_allowed_bsize(i) && is_interintra_wedge_used(i)) { - av1_diff_update_prob(&r, &fc->wedge_interintra_prob[i], ACCT_STR); - } - } -#endif // CONFIG_WEDGE - } -#endif // CONFIG_INTERINTRA + cm->reduced_tx_set_used = aom_rb_read_bit(rb); -#if !CONFIG_NEW_MULTISYMBOL - for (i = 0; i < INTRA_INTER_CONTEXTS; i++) - av1_diff_update_prob(&r, &fc->intra_inter_prob[i], ACCT_STR); -#endif + if (cm->allow_ref_frame_mvs && !frame_might_allow_ref_frame_mvs(cm)) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Frame wrongly requests reference frame MVs"); + } -#if !CONFIG_NEW_MULTISYMBOL - read_frame_reference_mode_probs(cm, &r); -#endif + if (!frame_is_intra_only(cm)) read_global_motion(cm, rb); -#if CONFIG_COMPOUND_SINGLEREF - for (i = 0; i < COMP_INTER_MODE_CONTEXTS; i++) - av1_diff_update_prob(&r, &fc->comp_inter_mode_prob[i], ACCT_STR); -#endif // CONFIG_COMPOUND_SINGLEREF + cm->cur_frame->film_grain_params_present = cm->film_grain_params_present; + read_film_grain(cm, rb); -#if !CONFIG_NEW_MULTISYMBOL -#if CONFIG_AMVR - if (cm->cur_frame_mv_precision_level == 0) { -#endif - for (i = 0; i < NMV_CONTEXTS; ++i) - read_mv_probs(&fc->nmvc[i], cm->allow_high_precision_mv, &r); -#if CONFIG_AMVR - } -#endif -#endif -#if CONFIG_SUPERTX - if (!xd->lossless[0]) read_supertx_probs(fc, &r); -#endif +#if EXT_TILE_DEBUG + if (pbi->ext_tile_debug && cm->large_scale_tile) { + read_ext_tile_info(pbi, rb); + av1_set_single_tile_decoding_mode(cm); } - - return aom_reader_has_error(&r); -#endif // CONFIG_RESTRICT_COMPRESSED_HDR -} - -#ifdef NDEBUG -#define debug_check_frame_counts(cm) (void)0 -#else // !NDEBUG -// Counts should only be incremented when frame_parallel_decoding_mode and -// error_resilient_mode are disabled. -static void debug_check_frame_counts(const AV1_COMMON *const cm) { - FRAME_COUNTS zero_counts; - av1_zero(zero_counts); - assert(cm->refresh_frame_context != REFRESH_FRAME_CONTEXT_BACKWARD || - cm->error_resilient_mode); - assert(!memcmp(cm->counts.partition, zero_counts.partition, - sizeof(cm->counts.partition))); - assert(!memcmp(cm->counts.switchable_interp, zero_counts.switchable_interp, - sizeof(cm->counts.switchable_interp))); - assert(!memcmp(cm->counts.inter_compound_mode, - zero_counts.inter_compound_mode, - sizeof(cm->counts.inter_compound_mode))); -#if CONFIG_INTERINTRA - assert(!memcmp(cm->counts.interintra, zero_counts.interintra, - sizeof(cm->counts.interintra))); -#if CONFIG_WEDGE - assert(!memcmp(cm->counts.wedge_interintra, zero_counts.wedge_interintra, - sizeof(cm->counts.wedge_interintra))); -#endif // CONFIG_WEDGE -#endif // CONFIG_INTERINTRA - assert(!memcmp(cm->counts.compound_interinter, - zero_counts.compound_interinter, - sizeof(cm->counts.compound_interinter))); -#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION - assert(!memcmp(cm->counts.motion_mode, zero_counts.motion_mode, - sizeof(cm->counts.motion_mode))); -#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION -#if CONFIG_NCOBMC_ADAPT_WEIGHT && CONFIG_MOTION_VAR - assert(!memcmp(cm->counts.ncobmc_mode, zero_counts.ncobmc_mode, - sizeof(cm->counts.ncobmc_mode))); -#endif - assert(!memcmp(cm->counts.intra_inter, zero_counts.intra_inter, - sizeof(cm->counts.intra_inter))); -#if CONFIG_COMPOUND_SINGLEREF - assert(!memcmp(cm->counts.comp_inter_mode, zero_counts.comp_inter_mode, - sizeof(cm->counts.comp_inter_mode))); -#endif // CONFIG_COMPOUND_SINGLEREF - assert(!memcmp(cm->counts.comp_inter, zero_counts.comp_inter, - sizeof(cm->counts.comp_inter))); -#if CONFIG_EXT_COMP_REFS - assert(!memcmp(cm->counts.comp_ref_type, zero_counts.comp_ref_type, - sizeof(cm->counts.comp_ref_type))); - assert(!memcmp(cm->counts.uni_comp_ref, zero_counts.uni_comp_ref, - sizeof(cm->counts.uni_comp_ref))); -#endif // CONFIG_EXT_COMP_REFS - assert(!memcmp(cm->counts.single_ref, zero_counts.single_ref, - sizeof(cm->counts.single_ref))); - assert(!memcmp(cm->counts.comp_ref, zero_counts.comp_ref, - sizeof(cm->counts.comp_ref))); -#if CONFIG_EXT_REFS - assert(!memcmp(cm->counts.comp_bwdref, zero_counts.comp_bwdref, - sizeof(cm->counts.comp_bwdref))); -#endif // CONFIG_EXT_REFS - assert(!memcmp(&cm->counts.tx_size, &zero_counts.tx_size, - sizeof(cm->counts.tx_size))); - assert(!memcmp(cm->counts.skip, zero_counts.skip, sizeof(cm->counts.skip))); - assert( - !memcmp(&cm->counts.mv[0], &zero_counts.mv[0], sizeof(cm->counts.mv[0]))); - assert( - !memcmp(&cm->counts.mv[1], &zero_counts.mv[1], sizeof(cm->counts.mv[0]))); +#endif // EXT_TILE_DEBUG + return 0; } -#endif // NDEBUG -static struct aom_read_bit_buffer *init_read_bit_buffer( +struct aom_read_bit_buffer *av1_init_read_bit_buffer( AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data, - const uint8_t *data_end, uint8_t clear_data[MAX_AV1_HEADER_SIZE]) { + const uint8_t *data_end) { rb->bit_offset = 0; rb->error_handler = error_handler; rb->error_handler_data = &pbi->common; - if (pbi->decrypt_cb) { - const int n = (int)AOMMIN(MAX_AV1_HEADER_SIZE, data_end - data); - pbi->decrypt_cb(pbi->decrypt_state, data, clear_data, n); - rb->bit_buffer = clear_data; - rb->bit_buffer_end = clear_data + n; - } else { - rb->bit_buffer = data; - rb->bit_buffer_end = data_end; - } + rb->bit_buffer = data; + rb->bit_buffer_end = data_end; return rb; } -//------------------------------------------------------------------------------ - -void av1_read_frame_size(struct aom_read_bit_buffer *rb, int *width, - int *height) { - *width = aom_rb_read_literal(rb, 16) + 1; - *height = aom_rb_read_literal(rb, 16) + 1; +void av1_read_frame_size(struct aom_read_bit_buffer *rb, int num_bits_width, + int num_bits_height, int *width, int *height) { + *width = aom_rb_read_literal(rb, num_bits_width) + 1; + *height = aom_rb_read_literal(rb, num_bits_height) + 1; } BITSTREAM_PROFILE av1_read_profile(struct aom_read_bit_buffer *rb) { - int profile = aom_rb_read_bit(rb); - profile |= aom_rb_read_bit(rb) << 1; - if (profile > 2) profile += aom_rb_read_bit(rb); + int profile = aom_rb_read_literal(rb, PROFILE_BITS); return (BITSTREAM_PROFILE)profile; } -static void make_update_tile_list_dec(AV1Decoder *pbi, int tile_rows, - int tile_cols, FRAME_CONTEXT *ec_ctxs[]) { - int i; - for (i = 0; i < tile_rows * tile_cols; ++i) - ec_ctxs[i] = &pbi->tile_data[i].tctx; -} - -#if CONFIG_FRAME_SUPERRES void superres_post_decode(AV1Decoder *pbi) { AV1_COMMON *const cm = &pbi->common; BufferPool *const pool = cm->buffer_pool; - if (av1_superres_unscaled(cm)) return; + if (!av1_superres_scaled(cm)) return; + assert(!cm->all_lossless); lock_buffer_pool(pool); av1_superres_upscale(cm, pool); unlock_buffer_pool(pool); } -#endif // CONFIG_FRAME_SUPERRES - -static void dec_setup_frame_boundary_info(AV1_COMMON *const cm) { -// Note: When LOOPFILTERING_ACROSS_TILES is enabled, we need to clear the -// boundary information every frame, since the tile boundaries may -// change every frame (particularly when dependent-horztiles is also -// enabled); when it is disabled, the only information stored is the frame -// boundaries, which only depend on the frame size. -#if !CONFIG_LOOPFILTERING_ACROSS_TILES - if (cm->width != cm->last_width || cm->height != cm->last_height) -#endif // CONFIG_LOOPFILTERING_ACROSS_TILES - { - int row, col; - for (row = 0; row < cm->mi_rows; ++row) { - MODE_INFO *mi = cm->mi + row * cm->mi_stride; - for (col = 0; col < cm->mi_cols; ++col) { - mi->mbmi.boundary_info = 0; - mi++; - } - } - av1_setup_frame_boundary_info(cm); - } -} -size_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, - const uint8_t **p_data_end) { +int av1_decode_frame_headers_and_setup(AV1Decoder *pbi, + struct aom_read_bit_buffer *rb, + const uint8_t *data, + const uint8_t **p_data_end, + int trailing_bits_present) { AV1_COMMON *const cm = &pbi->common; + const int num_planes = av1_num_planes(cm); MACROBLOCKD *const xd = &pbi->mb; - struct aom_read_bit_buffer rb; - uint8_t clear_data[MAX_AV1_HEADER_SIZE]; - size_t first_partition_size; - YV12_BUFFER_CONFIG *new_fb; -#if CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING - RefBuffer *last_fb_ref_buf = &cm->frame_refs[LAST_FRAME - LAST_FRAME]; -#endif // CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING - -#if CONFIG_ADAPT_SCAN - av1_deliver_eob_threshold(cm, xd); -#endif + #if CONFIG_BITSTREAM_DEBUG bitstream_queue_set_frame_read(cm->current_video_frame * 2 + cm->show_frame); #endif +#if CONFIG_MISMATCH_DEBUG + mismatch_move_frame_idx_r(); +#endif -#if CONFIG_GLOBAL_MOTION - int i; - for (i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { + for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { cm->global_motion[i] = default_warp_params; cm->cur_frame->global_motion[i] = default_warp_params; } xd->global_motion = cm->global_motion; -#endif // CONFIG_GLOBAL_MOTION - first_partition_size = read_uncompressed_header( - pbi, init_read_bit_buffer(pbi, &rb, data, data_end, clear_data)); + read_uncompressed_header(pbi, rb); + + if (trailing_bits_present) av1_check_trailing_bits(pbi, rb); -#if CONFIG_EXT_TILE // If cm->single_tile_decoding = 0, the independent decoding of a single tile // or a section of a frame is not allowed. if (!cm->single_tile_decoding && @@ -5534,268 +4315,160 @@ size_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, const uint8_t *data, pbi->dec_tile_row = -1; pbi->dec_tile_col = -1; } -#endif // CONFIG_EXT_TILE - pbi->first_partition_size = first_partition_size; - pbi->uncomp_hdr_size = aom_rb_bytes_read(&rb); - new_fb = get_frame_new_buffer(cm); + pbi->uncomp_hdr_size = aom_rb_bytes_read(rb); + YV12_BUFFER_CONFIG *new_fb = get_frame_new_buffer(cm); xd->cur_buf = new_fb; -#if CONFIG_INTRABC -#if CONFIG_HIGHBITDEPTH - av1_setup_scale_factors_for_frame( - &xd->sf_identity, xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height, - xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height, - cm->use_highbitdepth); -#else - av1_setup_scale_factors_for_frame( - &xd->sf_identity, xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height, - xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height); -#endif // CONFIG_HIGHBITDEPTH -#endif // CONFIG_INTRABC + if (av1_allow_intrabc(cm)) { + av1_setup_scale_factors_for_frame( + &cm->sf_identity, xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height, + xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height); + } if (cm->show_existing_frame) { // showing a frame directly - *p_data_end = data + aom_rb_bytes_read(&rb); + *p_data_end = data + aom_rb_bytes_read(rb); + if (cm->reset_decoder_state) { + // Use the default frame context values. + *cm->fc = cm->frame_contexts[FRAME_CONTEXT_DEFAULTS]; + if (!cm->fc->initialized) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Uninitialized entropy context."); + } return 0; } - data += aom_rb_bytes_read(&rb); - if (first_partition_size) - if (!read_is_valid(data, first_partition_size, data_end)) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Truncated packet or corrupt header length"); - cm->setup_mi(cm); -#if CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING - // NOTE(zoeliu): As cm->prev_frame can take neither a frame of - // show_exisiting_frame=1, nor can it take a frame not used as - // a reference, it is probable that by the time it is being - // referred to, the frame buffer it originally points to may - // already get expired and have been reassigned to the current - // newly coded frame. Hence, we need to check whether this is - // the case, and if yes, we have 2 choices: - // (1) Simply disable the use of previous frame mvs; or - // (2) Have cm->prev_frame point to one reference frame buffer, - // e.g. LAST_FRAME. - if (!dec_is_ref_frame_buf(pbi, cm->prev_frame)) { - // Reassign the LAST_FRAME buffer to cm->prev_frame. - cm->prev_frame = last_fb_ref_buf->idx != INVALID_IDX - ? &cm->buffer_pool->frame_bufs[last_fb_ref_buf->idx] - : NULL; - } -#endif // CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING - -#if CONFIG_TEMPMV_SIGNALING - if (cm->use_prev_frame_mvs && !frame_can_use_prev_frame_mvs(cm)) { - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Frame wrongly requests previous frame MVs"); - } -#else - cm->use_prev_frame_mvs = !cm->error_resilient_mode && cm->prev_frame && -#if CONFIG_FRAME_SUPERRES - cm->width == cm->last_width && - cm->height == cm->last_height && -#else - cm->width == cm->prev_frame->buf.y_crop_width && - cm->height == cm->prev_frame->buf.y_crop_height && -#endif // CONFIG_FRAME_SUPERRES - !cm->last_intra_only && cm->last_show_frame && - (cm->last_frame_type != KEY_FRAME); -#endif // CONFIG_TEMPMV_SIGNALING - -#if CONFIG_MFMV + cm->current_frame_seg_map = cm->cur_frame->seg_map; + av1_setup_motion_field(cm); -#endif // CONFIG_MFMV - av1_setup_block_planes(xd, cm->subsampling_x, cm->subsampling_y); -#if CONFIG_NO_FRAME_CONTEXT_SIGNALING - if (cm->error_resilient_mode || frame_is_intra_only(cm)) { + av1_setup_block_planes(xd, cm->subsampling_x, cm->subsampling_y, num_planes); + if (cm->primary_ref_frame == PRIMARY_REF_NONE) { // use the default frame context values *cm->fc = cm->frame_contexts[FRAME_CONTEXT_DEFAULTS]; - cm->pre_fc = &cm->frame_contexts[FRAME_CONTEXT_DEFAULTS]; } else { - *cm->fc = cm->frame_contexts[cm->frame_refs[0].idx]; - cm->pre_fc = &cm->frame_contexts[cm->frame_refs[0].idx]; + *cm->fc = cm->frame_contexts[cm->frame_refs[cm->primary_ref_frame].idx]; } -#else - *cm->fc = cm->frame_contexts[cm->frame_context_idx]; - cm->pre_fc = &cm->frame_contexts[cm->frame_context_idx]; -#endif // CONFIG_NO_FRAME_CONTEXT_SIGNALING if (!cm->fc->initialized) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Uninitialized entropy context."); - av1_zero(cm->counts); - xd->corrupted = 0; - if (first_partition_size) { - new_fb->corrupted = read_compressed_header(pbi, data, first_partition_size); - if (new_fb->corrupted) - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Decode failed. Frame data header is corrupted."); - } - return first_partition_size; + return 0; } -void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, - const uint8_t **p_data_end, int startTile, - int endTile, int initialize_flag) { +// Once-per-frame initialization +static void setup_frame_info(AV1Decoder *pbi) { AV1_COMMON *const cm = &pbi->common; - MACROBLOCKD *const xd = &pbi->mb; - int context_updated = 0; -#if CONFIG_LOOP_RESTORATION if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || cm->rst_info[1].frame_restoration_type != RESTORE_NONE || cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { av1_alloc_restoration_buffers(cm); } -#endif - -#if !CONFIG_LOOPFILTER_LEVEL - if (cm->lf.filter_level && !cm->skip_loop_filter) { - av1_loop_filter_frame_init(cm, cm->lf.filter_level, cm->lf.filter_level); + const int use_highbd = cm->use_highbitdepth ? 1 : 0; + const int buf_size = MC_TEMP_BUF_PELS << use_highbd; + if (pbi->td.mc_buf_size != buf_size) { + av1_free_mc_tmp_buf(&pbi->td, use_highbd); + allocate_mc_tmp_buf(cm, &pbi->td, buf_size, use_highbd); } -#endif +} - // If encoded in frame parallel mode, frame context is ready after decoding - // the frame header. - if (cm->frame_parallel_decode && initialize_flag && - cm->refresh_frame_context != REFRESH_FRAME_CONTEXT_BACKWARD) { - AVxWorker *const worker = pbi->frame_worker_owner; - FrameWorkerData *const frame_worker_data = worker->data1; - if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_FORWARD) { - context_updated = 1; -#if CONFIG_NO_FRAME_CONTEXT_SIGNALING - cm->frame_contexts[cm->new_fb_idx] = *cm->fc; -#else - cm->frame_contexts[cm->frame_context_idx] = *cm->fc; -#endif // CONFIG_NO_FRAME_CONTEXT_SIGNALING - } - av1_frameworker_lock_stats(worker); - pbi->cur_buf->row = -1; - pbi->cur_buf->col = -1; - frame_worker_data->frame_context_ready = 1; - // Signal the main thread that context is ready. - av1_frameworker_signal_stats(worker); - av1_frameworker_unlock_stats(worker); - } - - dec_setup_frame_boundary_info(cm); - - if (pbi->max_threads > 1 && !CONFIG_CB4X4 && -#if CONFIG_EXT_TILE - pbi->dec_tile_col < 0 && // Decoding all columns -#endif // CONFIG_EXT_TILE - cm->tile_cols > 1) { - // Multi-threaded tile decoder - *p_data_end = - decode_tiles_mt(pbi, data + pbi->first_partition_size, data_end); - if (!xd->corrupted) { - if (!cm->skip_loop_filter) { -// If multiple threads are used to decode tiles, then we use those -// threads to do parallel loopfiltering. -#if CONFIG_LOOPFILTER_LEVEL - av1_loop_filter_frame_mt( - (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, pbi->mb.plane, - cm->lf.filter_level[0], cm->lf.filter_level[1], 0, 0, - pbi->tile_workers, pbi->num_tile_workers, &pbi->lf_row_sync); -#else - av1_loop_filter_frame_mt((YV12_BUFFER_CONFIG *)xd->cur_buf, cm, - pbi->mb.plane, cm->lf.filter_level, 0, 0, - pbi->tile_workers, pbi->num_tile_workers, - &pbi->lf_row_sync); -#endif // CONFIG_LOOPFILTER_LEVEL - } - } else { - aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, - "Decode failed. Frame data is corrupted."); - } - } else { -#if CONFIG_OBU - *p_data_end = decode_tiles(pbi, data, data_end, startTile, endTile); -#else - *p_data_end = decode_tiles( - pbi, data + pbi->uncomp_hdr_size + pbi->first_partition_size, data_end, - startTile, endTile); -#endif - } +void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, + const uint8_t *data_end, + const uint8_t **p_data_end, int start_tile, + int end_tile, int initialize_flag) { + AV1_COMMON *const cm = &pbi->common; + MACROBLOCKD *const xd = &pbi->mb; + const int tile_count_tg = end_tile - start_tile + 1; - if (endTile != cm->tile_rows * cm->tile_cols - 1) { - return; - } + if (initialize_flag) setup_frame_info(pbi); -#if CONFIG_STRIPED_LOOP_RESTORATION - if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || - cm->rst_info[1].frame_restoration_type != RESTORE_NONE || - cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { - av1_loop_restoration_save_boundary_lines(&pbi->cur_buf->buf, cm); - } -#endif + if (pbi->max_threads > 1 && tile_count_tg > 1 && !cm->large_scale_tile) + *p_data_end = decode_tiles_mt(pbi, data, data_end, start_tile, end_tile); + else + *p_data_end = decode_tiles(pbi, data, data_end, start_tile, end_tile); -#if CONFIG_CDEF - if (!cm->skip_loop_filter && !cm->all_lossless) { - av1_cdef_frame(&pbi->cur_buf->buf, cm, &pbi->mb); + const int num_planes = av1_num_planes(cm); + // If the bit stream is monochrome, set the U and V buffers to a constant. + if (num_planes < 3) set_planes_to_neutral_grey(cm, xd->cur_buf, 1); + + if (end_tile != cm->tile_rows * cm->tile_cols - 1) { + return; } -#endif // CONFIG_CDEF -#if CONFIG_FRAME_SUPERRES - superres_post_decode(pbi); -#endif // CONFIG_FRAME_SUPERRES + if (!cm->allow_intrabc && !cm->single_tile_decoding) { + if (cm->lf.filter_level[0] || cm->lf.filter_level[1]) { +#if LOOP_FILTER_BITMASK + av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, 0, + num_planes, 0); +#else + if (pbi->num_workers > 1) { + av1_loop_filter_frame_mt(get_frame_new_buffer(cm), cm, &pbi->mb, 0, + num_planes, 0, pbi->tile_workers, + pbi->num_workers, &pbi->lf_row_sync); + } else { + av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, 0, + num_planes, 0); + } +#endif + } -#if CONFIG_LOOP_RESTORATION - if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || - cm->rst_info[1].frame_restoration_type != RESTORE_NONE || - cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { - aom_extend_frame_borders((YV12_BUFFER_CONFIG *)xd->cur_buf); - av1_loop_restoration_frame((YV12_BUFFER_CONFIG *)xd->cur_buf, cm, - cm->rst_info, 7, 0, NULL); + const int do_loop_restoration = + cm->rst_info[0].frame_restoration_type != RESTORE_NONE || + cm->rst_info[1].frame_restoration_type != RESTORE_NONE || + cm->rst_info[2].frame_restoration_type != RESTORE_NONE; + const int do_cdef = + !cm->skip_loop_filter && !cm->coded_lossless && + (cm->cdef_bits || cm->cdef_strengths[0] || cm->cdef_uv_strengths[0]); + const int do_superres = av1_superres_scaled(cm); + const int optimized_loop_restoration = !do_cdef && !do_superres; + + if (!optimized_loop_restoration) { + if (do_loop_restoration) + av1_loop_restoration_save_boundary_lines(&pbi->cur_buf->buf, cm, 0); + + if (do_cdef) av1_cdef_frame(&pbi->cur_buf->buf, cm, &pbi->mb); + + superres_post_decode(pbi); + + if (do_loop_restoration) { + av1_loop_restoration_save_boundary_lines(&pbi->cur_buf->buf, cm, 1); + if (pbi->num_workers > 1) { + av1_loop_restoration_filter_frame_mt( + (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, optimized_loop_restoration, + pbi->tile_workers, pbi->num_workers, &pbi->lr_row_sync, + &pbi->lr_ctxt); + } else { + av1_loop_restoration_filter_frame((YV12_BUFFER_CONFIG *)xd->cur_buf, + cm, optimized_loop_restoration, + &pbi->lr_ctxt); + } + } + } else { + // In no cdef and no superres case. Provide an optimized version of + // loop_restoration_filter. + if (do_loop_restoration) { + if (pbi->num_workers > 1) { + av1_loop_restoration_filter_frame_mt( + (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, optimized_loop_restoration, + pbi->tile_workers, pbi->num_workers, &pbi->lr_row_sync, + &pbi->lr_ctxt); + } else { + av1_loop_restoration_filter_frame((YV12_BUFFER_CONFIG *)xd->cur_buf, + cm, optimized_loop_restoration, + &pbi->lr_ctxt); + } + } + } } -#endif // CONFIG_LOOP_RESTORATION if (!xd->corrupted) { if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { - FRAME_CONTEXT **tile_ctxs = aom_malloc(cm->tile_rows * cm->tile_cols * - sizeof(&pbi->tile_data[0].tctx)); - aom_cdf_prob **cdf_ptrs = - aom_malloc(cm->tile_rows * cm->tile_cols * - sizeof(&pbi->tile_data[0].tctx.partition_cdf[0][0])); - make_update_tile_list_dec(pbi, cm->tile_rows, cm->tile_cols, tile_ctxs); -#if CONFIG_LV_MAP - av1_adapt_coef_probs(cm); -#endif // CONFIG_LV_MAP -#if CONFIG_SYMBOLRATE - av1_dump_symbol_rate(cm); -#endif - av1_adapt_intra_frame_probs(cm); - av1_average_tile_coef_cdfs(pbi->common.fc, tile_ctxs, cdf_ptrs, - cm->tile_rows * cm->tile_cols); - av1_average_tile_intra_cdfs(pbi->common.fc, tile_ctxs, cdf_ptrs, - cm->tile_rows * cm->tile_cols); -#if CONFIG_PVQ - av1_average_tile_pvq_cdfs(pbi->common.fc, tile_ctxs, - cm->tile_rows * cm->tile_cols); -#endif // CONFIG_PVQ -#if CONFIG_ADAPT_SCAN - av1_adapt_scan_order(cm); -#endif // CONFIG_ADAPT_SCAN - - if (!frame_is_intra_only(cm)) { - av1_adapt_inter_frame_probs(cm); -#if !CONFIG_NEW_MULTISYMBOL - av1_adapt_mv_probs(cm, cm->allow_high_precision_mv); -#endif - av1_average_tile_inter_cdfs(&pbi->common, pbi->common.fc, tile_ctxs, - cdf_ptrs, cm->tile_rows * cm->tile_cols); - av1_average_tile_mv_cdfs(pbi->common.fc, tile_ctxs, cdf_ptrs, - cm->tile_rows * cm->tile_cols); - } - aom_free(tile_ctxs); - aom_free(cdf_ptrs); - } else { - debug_check_frame_counts(cm); + *cm->fc = pbi->tile_data[cm->context_update_tile_id].tctx; + av1_reset_cdf_symbol_counters(cm->fc); } } else { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, @@ -5808,153 +4481,8 @@ void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, } #endif -// Non frame parallel update frame context here. -#if CONFIG_NO_FRAME_CONTEXT_SIGNALING - if (!context_updated) cm->frame_contexts[cm->new_fb_idx] = *cm->fc; -#else - if (!cm->error_resilient_mode && !context_updated) - cm->frame_contexts[cm->frame_context_idx] = *cm->fc; -#endif -} - -#if CONFIG_OBU - -static OBU_TYPE read_obu_header(struct aom_read_bit_buffer *rb, - uint32_t *header_size) { - OBU_TYPE obu_type; - int obu_extension_flag; - - *header_size = 1; - - obu_type = (OBU_TYPE)aom_rb_read_literal(rb, 5); - aom_rb_read_literal(rb, 2); // reserved - obu_extension_flag = aom_rb_read_bit(rb); - if (obu_extension_flag) { - *header_size += 1; - aom_rb_read_literal(rb, 3); // temporal_id - aom_rb_read_literal(rb, 2); - aom_rb_read_literal(rb, 2); - aom_rb_read_literal(rb, 1); // reserved - } - - return obu_type; -} - -static uint32_t read_temporal_delimiter_obu() { return 0; } - -static uint32_t read_sequence_header_obu(AV1Decoder *pbi, - struct aom_read_bit_buffer *rb) { - AV1_COMMON *const cm = &pbi->common; - SequenceHeader *const seq_params = &cm->seq_params; - uint32_t saved_bit_offset = rb->bit_offset; - - cm->profile = av1_read_profile(rb); - aom_rb_read_literal(rb, 4); // level - - seq_params->frame_id_numbers_present_flag = aom_rb_read_bit(rb); - if (seq_params->frame_id_numbers_present_flag) { - seq_params->frame_id_length_minus7 = aom_rb_read_literal(rb, 4); - seq_params->delta_frame_id_length_minus2 = aom_rb_read_literal(rb, 4); - } - - read_bitdepth_colorspace_sampling(cm, rb, pbi->allow_lowbitdepth); - - return ((rb->bit_offset - saved_bit_offset + 7) >> 3); -} - -static uint32_t read_frame_header_obu(AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, - const uint8_t **p_data_end) { - size_t header_size; - - header_size = - av1_decode_frame_headers_and_setup(pbi, data, data_end, p_data_end); - return (uint32_t)(pbi->uncomp_hdr_size + header_size); -} - -static uint32_t read_tile_group_header(AV1Decoder *pbi, - struct aom_read_bit_buffer *rb, - int *startTile, int *endTile) { - AV1_COMMON *const cm = &pbi->common; - uint32_t saved_bit_offset = rb->bit_offset; - - *startTile = aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); - *endTile = aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); - - return ((rb->bit_offset - saved_bit_offset + 7) >> 3); -} - -static uint32_t read_one_tile_group_obu(AV1Decoder *pbi, - struct aom_read_bit_buffer *rb, - int is_first_tg, const uint8_t *data, - const uint8_t *data_end, - const uint8_t **p_data_end, - int *is_last_tg) { - AV1_COMMON *const cm = &pbi->common; - int startTile, endTile; - uint32_t header_size, tg_payload_size; - - header_size = read_tile_group_header(pbi, rb, &startTile, &endTile); - data += header_size; - av1_decode_tg_tiles_and_wrapup(pbi, data, data_end, p_data_end, startTile, - endTile, is_first_tg); - tg_payload_size = (uint32_t)(*p_data_end - data); - - // TODO(shan): For now, assume all tile groups received in order - *is_last_tg = endTile == cm->tile_rows * cm->tile_cols - 1; - - return header_size + tg_payload_size; -} - -void av1_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, - const uint8_t **p_data_end) { - AV1_COMMON *const cm = &pbi->common; - int frame_decoding_finished = 0; - int is_first_tg_obu_received = 1; - int frame_header_received = 0; - int frame_header_size = 0; - - // decode frame as a series of OBUs - while (!frame_decoding_finished && !cm->error.error_code) { - struct aom_read_bit_buffer rb; - uint8_t clear_data[80]; - uint32_t obu_size, obu_header_size, obu_payload_size = 0; - OBU_TYPE obu_type; - - init_read_bit_buffer(pbi, &rb, data + 4, data_end, clear_data); - - // every obu is preceded by 4-byte size of obu (obu header + payload size) - // The obu size is only needed for tile group OBUs - obu_size = mem_get_le32(data); - obu_type = read_obu_header(&rb, &obu_header_size); - data += (4 + obu_header_size); - - switch (obu_type) { - case OBU_TD: obu_payload_size = read_temporal_delimiter_obu(); break; - case OBU_SEQUENCE_HEADER: - obu_payload_size = read_sequence_header_obu(pbi, &rb); - break; - case OBU_FRAME_HEADER: - // Only decode first frame header received - if (!frame_header_received) { - frame_header_size = obu_payload_size = - read_frame_header_obu(pbi, data, data_end, p_data_end); - frame_header_received = 1; - } else { - obu_payload_size = frame_header_size; - } - if (cm->show_existing_frame) frame_decoding_finished = 1; - break; - case OBU_TILE_GROUP: - obu_payload_size = read_one_tile_group_obu( - pbi, &rb, is_first_tg_obu_received, data, data + obu_size - 1, - p_data_end, &frame_decoding_finished); - is_first_tg_obu_received = 0; - break; - default: break; - } - data += obu_payload_size; + // Non frame parallel update frame context here. + if (!cm->large_scale_tile) { + cm->frame_contexts[cm->new_fb_idx] = *cm->fc; } } -#endif diff --git a/third_party/aom/av1/decoder/decodeframe.h b/third_party/aom/av1/decoder/decodeframe.h index 0e7eb6a1d6..330cedcdce 100644 --- a/third_party/aom/av1/decoder/decodeframe.h +++ b/third_party/aom/av1/decoder/decodeframe.h @@ -19,35 +19,59 @@ extern "C" { struct AV1Decoder; struct aom_read_bit_buffer; -#if CONFIG_REFERENCE_BUFFER -/* Placeholder for now */ -void read_sequence_header(SequenceHeader *seq_params, - struct aom_read_bit_buffer *rb); -#endif +// Reads the middle part of the sequence header OBU (from +// frame_width_bits_minus_1 to enable_restoration) into cm->seq_params (a +// SequenceHeader). Reports errors by calling rb->error_handler() or +// aom_internal_error(). +void read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb); -void av1_read_frame_size(struct aom_read_bit_buffer *rb, int *width, - int *height); +void av1_read_frame_size(struct aom_read_bit_buffer *rb, int num_bits_width, + int num_bits_height, int *width, int *height); BITSTREAM_PROFILE av1_read_profile(struct aom_read_bit_buffer *rb); -// This function is now obsolete -void av1_decode_frame(struct AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, const uint8_t **p_data_end); -size_t av1_decode_frame_headers_and_setup(struct AV1Decoder *pbi, - const uint8_t *data, - const uint8_t *data_end, - const uint8_t **p_data_end); +// Returns 0 on success. Sets pbi->common.error.error_code and returns -1 on +// failure. +int av1_check_trailing_bits(struct AV1Decoder *pbi, + struct aom_read_bit_buffer *rb); + +int av1_decode_frame_headers_and_setup(struct AV1Decoder *pbi, + struct aom_read_bit_buffer *rb, + const uint8_t *data, + const uint8_t **p_data_end, + int trailing_bits_present); void av1_decode_tg_tiles_and_wrapup(struct AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, const uint8_t **p_data_end, int startTile, int endTile, int initialize_flag); -#if CONFIG_OBU -// replaces av1_decode_frame -void av1_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, - const uint8_t **p_data_end); -#endif +// Implements the color_config() function in the spec. Reports errors by +// calling rb->error_handler() or aom_internal_error(). +void av1_read_color_config(AV1_COMMON *cm, struct aom_read_bit_buffer *rb, + int allow_lowbitdepth); + +// Implements the timing_info() function in the spec. Reports errors by calling +// rb->error_handler(). +void av1_read_timing_info_header(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb); + +// Implements the decoder_model_info() function in the spec. Reports errors by +// calling rb->error_handler(). +void av1_read_decoder_model_info(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb); + +// Implements the operating_parameters_info() function in the spec. Reports +// errors by calling rb->error_handler() or aom_internal_error(). +void av1_read_op_parameters_info(AV1_COMMON *const cm, + struct aom_read_bit_buffer *rb, int op_num); + +struct aom_read_bit_buffer *av1_init_read_bit_buffer( + struct AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data, + const uint8_t *data_end); + +void av1_free_mc_tmp_buf(void *td, int use_highbd); + +void av1_set_single_tile_decoding_mode(AV1_COMMON *const cm); #ifdef __cplusplus } // extern "C" diff --git a/third_party/aom/av1/decoder/decodemv.c b/third_party/aom/av1/decoder/decodemv.c index cac27e9a68..cc8f4d29e0 100644 --- a/third_party/aom/av1/decoder/decodemv.c +++ b/third_party/aom/av1/decoder/decodemv.c @@ -11,6 +11,7 @@ #include <assert.h> +#include "av1/common/cfl.h" #include "av1/common/common.h" #include "av1/common/entropy.h" #include "av1/common/entropymode.h" @@ -18,13 +19,9 @@ #include "av1/common/mvref_common.h" #include "av1/common/pred_common.h" #include "av1/common/reconinter.h" -#if CONFIG_EXT_INTRA #include "av1/common/reconintra.h" -#endif // CONFIG_EXT_INTRA #include "av1/common/seg_common.h" -#if CONFIG_WARPED_MOTION #include "av1/common/warped_motion.h" -#endif // CONFIG_WARPED_MOTION #include "av1/decoder/decodeframe.h" #include "av1/decoder/decodemv.h" @@ -39,30 +36,51 @@ static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) { return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR); } -static int read_delta_qindex(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r, - MB_MODE_INFO *const mbmi, int mi_col, int mi_row) { - FRAME_COUNTS *counts = xd->counts; +static void read_cdef(AV1_COMMON *cm, aom_reader *r, MACROBLOCKD *const xd, + int mi_col, int mi_row) { + MB_MODE_INFO *const mbmi = xd->mi[0]; + if (cm->coded_lossless) return; + if (cm->allow_intrabc) { + assert(cm->cdef_bits == 0); + return; + } + + if (!(mi_col & (cm->seq_params.mib_size - 1)) && + !(mi_row & (cm->seq_params.mib_size - 1))) { // Top left? + xd->cdef_preset[0] = xd->cdef_preset[1] = xd->cdef_preset[2] = + xd->cdef_preset[3] = -1; + } + // Read CDEF param at the first non-skip coding block + const int mask = (1 << (6 - MI_SIZE_LOG2)); + const int m = ~(mask - 1); + const int index = cm->seq_params.sb_size == BLOCK_128X128 + ? !!(mi_col & mask) + 2 * !!(mi_row & mask) + : 0; + cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)] + ->cdef_strength = xd->cdef_preset[index] = + xd->cdef_preset[index] == -1 && !mbmi->skip + ? aom_read_literal(r, cm->cdef_bits, ACCT_STR) + : xd->cdef_preset[index]; +} + +static int read_delta_qindex(AV1_COMMON *cm, const MACROBLOCKD *xd, + aom_reader *r, MB_MODE_INFO *const mbmi, + int mi_col, int mi_row) { int sign, abs, reduced_delta_qindex = 0; BLOCK_SIZE bsize = mbmi->sb_type; - const int b_col = mi_col & MAX_MIB_MASK; - const int b_row = mi_row & MAX_MIB_MASK; + const int b_col = mi_col & (cm->seq_params.mib_size - 1); + const int b_row = mi_row & (cm->seq_params.mib_size - 1); const int read_delta_q_flag = (b_col == 0 && b_row == 0); - int rem_bits, thr; - int i, smallval; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; - if ((bsize != BLOCK_LARGEST || mbmi->skip == 0) && read_delta_q_flag) { + if ((bsize != cm->seq_params.sb_size || mbmi->skip == 0) && + read_delta_q_flag) { abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR); - smallval = (abs < DELTA_Q_SMALL); - if (counts) { - for (i = 0; i < abs; ++i) counts->delta_q[i][1]++; - if (smallval) counts->delta_q[abs][0]++; - } + const int smallval = (abs < DELTA_Q_SMALL); if (!smallval) { - rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1; - thr = (1 << rem_bits) + 1; + const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1; + const int thr = (1 << rem_bits) + 1; abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr; } @@ -76,56 +94,33 @@ static int read_delta_qindex(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r, } return reduced_delta_qindex; } -#if CONFIG_EXT_DELTA_Q -static int read_delta_lflevel(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r, -#if CONFIG_LOOPFILTER_LEVEL - int lf_id, -#endif +static int read_delta_lflevel(AV1_COMMON *cm, const MACROBLOCKD *xd, + aom_reader *r, int lf_id, MB_MODE_INFO *const mbmi, int mi_col, int mi_row) { - FRAME_COUNTS *counts = xd->counts; int sign, abs, reduced_delta_lflevel = 0; BLOCK_SIZE bsize = mbmi->sb_type; - const int b_col = mi_col & MAX_MIB_MASK; - const int b_row = mi_row & MAX_MIB_MASK; + const int b_col = mi_col & (cm->seq_params.mib_size - 1); + const int b_row = mi_row & (cm->seq_params.mib_size - 1); const int read_delta_lf_flag = (b_col == 0 && b_row == 0); - int rem_bits, thr; - int i, smallval; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; - if ((bsize != cm->sb_size || mbmi->skip == 0) && read_delta_lf_flag) { -#if CONFIG_LOOPFILTER_LEVEL + if ((bsize != cm->seq_params.sb_size || mbmi->skip == 0) && + read_delta_lf_flag) { if (cm->delta_lf_multi) { - assert(lf_id >= 0 && lf_id < FRAME_LF_COUNT); + assert(lf_id >= 0 && + lf_id < (av1_num_planes(cm) > 1 ? FRAME_LF_COUNT + : FRAME_LF_COUNT - 2)); abs = aom_read_symbol(r, ec_ctx->delta_lf_multi_cdf[lf_id], DELTA_LF_PROBS + 1, ACCT_STR); } else { abs = aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1, ACCT_STR); } -#else - abs = - aom_read_symbol(r, ec_ctx->delta_lf_cdf, DELTA_LF_PROBS + 1, ACCT_STR); -#endif // CONFIG_LOOPFILTER_LEVEL - smallval = (abs < DELTA_LF_SMALL); - if (counts) { -#if CONFIG_LOOPFILTER_LEVEL - if (cm->delta_lf_multi) { - for (i = 0; i < abs; ++i) counts->delta_lf_multi[lf_id][i][1]++; - if (smallval) counts->delta_lf_multi[lf_id][abs][0]++; - } else { - for (i = 0; i < abs; ++i) counts->delta_lf[i][1]++; - if (smallval) counts->delta_lf[abs][0]++; - } -#else - for (i = 0; i < abs; ++i) counts->delta_lf[i][1]++; - if (smallval) counts->delta_lf[abs][0]++; -#endif // CONFIG_LOOPFILTER_LEVEL - } + const int smallval = (abs < DELTA_LF_SMALL); if (!smallval) { - rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1; - thr = (1 << rem_bits) + 1; + const int rem_bits = aom_read_literal(r, 3, ACCT_STR) + 1; + const int thr = (1 << rem_bits) + 1; abs = aom_read_literal(r, rem_bits, ACCT_STR) + thr; } @@ -139,21 +134,17 @@ static int read_delta_lflevel(AV1_COMMON *cm, MACROBLOCKD *xd, aom_reader *r, } return reduced_delta_lflevel; } -#endif static UV_PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx, aom_reader *r, + CFL_ALLOWED_TYPE cfl_allowed, PREDICTION_MODE y_mode) { const UV_PREDICTION_MODE uv_mode = -#if CONFIG_CFL - aom_read_symbol(r, ec_ctx->uv_mode_cdf[y_mode], UV_INTRA_MODES, ACCT_STR); -#else - read_intra_mode(r, ec_ctx->uv_mode_cdf[y_mode]); -#endif // CONFIG_CFL + aom_read_symbol(r, ec_ctx->uv_mode_cdf[cfl_allowed][y_mode], + UV_INTRA_MODES - !cfl_allowed, ACCT_STR); return uv_mode; } -#if CONFIG_CFL static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r, int *signs_out) { const int joint_sign = @@ -172,400 +163,145 @@ static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r, *signs_out = joint_sign; return idx; } -#endif -#if CONFIG_INTERINTRA -static INTERINTRA_MODE read_interintra_mode(AV1_COMMON *cm, MACROBLOCKD *xd, - aom_reader *r, int size_group) { - (void)cm; +static INTERINTRA_MODE read_interintra_mode(MACROBLOCKD *xd, aom_reader *r, + int size_group) { const INTERINTRA_MODE ii_mode = (INTERINTRA_MODE)aom_read_symbol( r, xd->tile_ctx->interintra_mode_cdf[size_group], INTERINTRA_MODES, ACCT_STR); - FRAME_COUNTS *counts = xd->counts; - if (counts) ++counts->interintra_mode[size_group][ii_mode]; return ii_mode; } -#endif // CONFIG_INTERINTRA -static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd, - aom_reader *r, int16_t ctx) { - FRAME_COUNTS *counts = xd->counts; +static PREDICTION_MODE read_inter_mode(FRAME_CONTEXT *ec_ctx, aom_reader *r, + int16_t ctx) { int16_t mode_ctx = ctx & NEWMV_CTX_MASK; int is_newmv, is_zeromv, is_refmv; -#if CONFIG_NEW_MULTISYMBOL is_newmv = aom_read_symbol(r, ec_ctx->newmv_cdf[mode_ctx], 2, ACCT_STR) == 0; -#else - is_newmv = aom_read(r, ec_ctx->newmv_prob[mode_ctx], ACCT_STR) == 0; -#endif - - if (is_newmv) { - if (counts) ++counts->newmv_mode[mode_ctx][0]; - return NEWMV; - } - if (counts) ++counts->newmv_mode[mode_ctx][1]; - - if (ctx & (1 << ALL_ZERO_FLAG_OFFSET)) return ZEROMV; + if (is_newmv) return NEWMV; - mode_ctx = (ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK; - -#if CONFIG_NEW_MULTISYMBOL + mode_ctx = (ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK; is_zeromv = aom_read_symbol(r, ec_ctx->zeromv_cdf[mode_ctx], 2, ACCT_STR) == 0; -#else - is_zeromv = aom_read(r, ec_ctx->zeromv_prob[mode_ctx], ACCT_STR) == 0; -#endif - if (is_zeromv) { - if (counts) ++counts->zeromv_mode[mode_ctx][0]; - return ZEROMV; - } - if (counts) ++counts->zeromv_mode[mode_ctx][1]; + if (is_zeromv) return GLOBALMV; mode_ctx = (ctx >> REFMV_OFFSET) & REFMV_CTX_MASK; - - if (ctx & (1 << SKIP_NEARESTMV_OFFSET)) mode_ctx = 6; - if (ctx & (1 << SKIP_NEARMV_OFFSET)) mode_ctx = 7; - if (ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) mode_ctx = 8; - -#if CONFIG_NEW_MULTISYMBOL is_refmv = aom_read_symbol(r, ec_ctx->refmv_cdf[mode_ctx], 2, ACCT_STR) == 0; -#else - is_refmv = aom_read(r, ec_ctx->refmv_prob[mode_ctx], ACCT_STR) == 0; -#endif - - if (is_refmv) { - if (counts) ++counts->refmv_mode[mode_ctx][0]; - + if (is_refmv) return NEARESTMV; - } else { - if (counts) ++counts->refmv_mode[mode_ctx][1]; + else return NEARMV; - } - - // Invalid prediction mode. - assert(0); } static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd, MB_MODE_INFO *mbmi, aom_reader *r) { uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); mbmi->ref_mv_idx = 0; - - if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV -#if CONFIG_COMPOUND_SINGLEREF - || mbmi->mode == SR_NEW_NEWMV -#endif // CONFIG_COMPOUND_SINGLEREF - ) { - int idx; - for (idx = 0; idx < 2; ++idx) { + if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) { + for (int idx = 0; idx < 2; ++idx) { if (xd->ref_mv_count[ref_frame_type] > idx + 1) { uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx); -#if CONFIG_NEW_MULTISYMBOL int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR); -#else - int drl_idx = aom_read(r, ec_ctx->drl_prob[drl_ctx], ACCT_STR); -#endif mbmi->ref_mv_idx = idx + drl_idx; - if (xd->counts) ++xd->counts->drl_mode[drl_ctx][drl_idx]; if (!drl_idx) return; } } } - if (have_nearmv_in_inter_mode(mbmi->mode)) { - int idx; // Offset the NEARESTMV mode. // TODO(jingning): Unify the two syntax decoding loops after the NEARESTMV // mode is factored in. - for (idx = 1; idx < 3; ++idx) { + for (int idx = 1; idx < 3; ++idx) { if (xd->ref_mv_count[ref_frame_type] > idx + 1) { uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx); -#if CONFIG_NEW_MULTISYMBOL int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR); -#else - int drl_idx = aom_read(r, ec_ctx->drl_prob[drl_ctx], ACCT_STR); -#endif mbmi->ref_mv_idx = idx + drl_idx - 1; - if (xd->counts) ++xd->counts->drl_mode[drl_ctx][drl_idx]; if (!drl_idx) return; } } } } -#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd, - MODE_INFO *mi, aom_reader *r) { - MB_MODE_INFO *mbmi = &mi->mbmi; -#if !CONFIG_MOTION_VAR || !CONFIG_WARPED_MOTION || CONFIG_NEW_MULTISYMBOL || \ - CONFIG_NCOBMC_ADAPT_WEIGHT - (void)cm; -#endif + MB_MODE_INFO *mbmi, aom_reader *r) { + if (cm->switchable_motion_mode == 0) return SIMPLE_TRANSLATION; + if (mbmi->skip_mode) return SIMPLE_TRANSLATION; - const MOTION_MODE last_motion_mode_allowed = motion_mode_allowed( -#if CONFIG_GLOBAL_MOTION - 0, xd->global_motion, -#endif // CONFIG_GLOBAL_MOTION -#if CONFIG_WARPED_MOTION - xd, -#endif - mi); + const MOTION_MODE last_motion_mode_allowed = + motion_mode_allowed(xd->global_motion, xd, mbmi, cm->allow_warped_motion); int motion_mode; - FRAME_COUNTS *counts = xd->counts; if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION; -#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION -#if CONFIG_NCOBMC_ADAPT_WEIGHT - if (last_motion_mode_allowed == NCOBMC_ADAPT_WEIGHT) { - motion_mode = aom_read_symbol(r, xd->tile_ctx->ncobmc_cdf[mbmi->sb_type], - OBMC_FAMILY_MODES, ACCT_STR); - if (counts) ++counts->ncobmc[mbmi->sb_type][motion_mode]; - return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode); - } else if (last_motion_mode_allowed == OBMC_CAUSAL) { - motion_mode = - aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2, ACCT_STR); - if (counts) ++counts->obmc[mbmi->sb_type][motion_mode]; - return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode); - } else { -#else + if (last_motion_mode_allowed == OBMC_CAUSAL) { -#if CONFIG_NEW_MULTISYMBOL motion_mode = aom_read_symbol(r, xd->tile_ctx->obmc_cdf[mbmi->sb_type], 2, ACCT_STR); -#else - motion_mode = aom_read(r, cm->fc->obmc_prob[mbmi->sb_type], ACCT_STR); -#endif - if (counts) ++counts->obmc[mbmi->sb_type][motion_mode]; return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode); } else { -#endif // CONFIG_NCOBMC_ADAPT_WEIGHT -#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION motion_mode = aom_read_symbol(r, xd->tile_ctx->motion_mode_cdf[mbmi->sb_type], MOTION_MODES, ACCT_STR); - if (counts) ++counts->motion_mode[mbmi->sb_type][motion_mode]; return (MOTION_MODE)(SIMPLE_TRANSLATION + motion_mode); -#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION } -#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION } -#if CONFIG_NCOBMC_ADAPT_WEIGHT -static void read_ncobmc_mode(MACROBLOCKD *xd, MODE_INFO *mi, - NCOBMC_MODE ncobmc_mode[2], aom_reader *r) { - MB_MODE_INFO *mbmi = &mi->mbmi; - FRAME_COUNTS *counts = xd->counts; - ADAPT_OVERLAP_BLOCK ao_block = adapt_overlap_block_lookup[mbmi->sb_type]; - if (mbmi->motion_mode != NCOBMC_ADAPT_WEIGHT) return; - - ncobmc_mode[0] = aom_read_symbol(r, xd->tile_ctx->ncobmc_mode_cdf[ao_block], - MAX_NCOBMC_MODES, ACCT_STR); - if (counts) ++counts->ncobmc_mode[ao_block][ncobmc_mode[0]]; - - if (mi_size_wide[mbmi->sb_type] != mi_size_high[mbmi->sb_type]) { - ncobmc_mode[1] = aom_read_symbol(r, xd->tile_ctx->ncobmc_mode_cdf[ao_block], - MAX_NCOBMC_MODES, ACCT_STR); - if (counts) ++counts->ncobmc_mode[ao_block][ncobmc_mode[1]]; - } -} -#endif // CONFIG_NCOBMC_ADAPT_WEIGHT -#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION - -static PREDICTION_MODE read_inter_compound_mode(AV1_COMMON *cm, MACROBLOCKD *xd, - aom_reader *r, int16_t ctx) { - (void)cm; +static PREDICTION_MODE read_inter_compound_mode(MACROBLOCKD *xd, aom_reader *r, + int16_t ctx) { const int mode = aom_read_symbol(r, xd->tile_ctx->inter_compound_mode_cdf[ctx], INTER_COMPOUND_MODES, ACCT_STR); - FRAME_COUNTS *counts = xd->counts; - - if (counts) ++counts->inter_compound_mode[ctx][mode]; - assert(is_inter_compound_mode(NEAREST_NEARESTMV + mode)); return NEAREST_NEARESTMV + mode; } -#if CONFIG_COMPOUND_SINGLEREF -static PREDICTION_MODE read_inter_singleref_comp_mode(MACROBLOCKD *xd, - aom_reader *r, - int16_t ctx) { - const int mode = - aom_read_symbol(r, xd->tile_ctx->inter_singleref_comp_mode_cdf[ctx], - INTER_SINGLEREF_COMP_MODES, ACCT_STR); - FRAME_COUNTS *counts = xd->counts; - - if (counts) ++counts->inter_singleref_comp_mode[ctx][mode]; - - assert(is_inter_singleref_comp_mode(SR_NEAREST_NEARMV + mode)); - return SR_NEAREST_NEARMV + mode; -} -#endif // CONFIG_COMPOUND_SINGLEREF - -static int read_segment_id(aom_reader *r, struct segmentation_probs *segp) { - return aom_read_symbol(r, segp->tree_cdf, MAX_SEGMENTS, ACCT_STR); -} - -#if CONFIG_VAR_TX -static void read_tx_size_vartx(AV1_COMMON *cm, MACROBLOCKD *xd, - MB_MODE_INFO *mbmi, FRAME_COUNTS *counts, - TX_SIZE tx_size, int depth, int blk_row, - int blk_col, aom_reader *r) { -#if CONFIG_NEW_MULTISYMBOL - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; -#endif - int is_split = 0; - const int tx_row = blk_row >> 1; - const int tx_col = blk_col >> 1; - const int max_blocks_high = max_block_high(xd, mbmi->sb_type, 0); - const int max_blocks_wide = max_block_wide(xd, mbmi->sb_type, 0); - int ctx = txfm_partition_context(xd->above_txfm_context + blk_col, - xd->left_txfm_context + blk_row, - mbmi->sb_type, tx_size); - TX_SIZE(*const inter_tx_size) - [MAX_MIB_SIZE] = - (TX_SIZE(*)[MAX_MIB_SIZE]) & mbmi->inter_tx_size[tx_row][tx_col]; - if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; - assert(tx_size > TX_4X4); - - if (depth == MAX_VARTX_DEPTH) { - int idx, idy; - inter_tx_size[0][0] = tx_size; - for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy) - for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx) - inter_tx_size[idy][idx] = tx_size; - mbmi->tx_size = tx_size; - mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size)); - txfm_partition_update(xd->above_txfm_context + blk_col, - xd->left_txfm_context + blk_row, tx_size, tx_size); - return; - } - -#if CONFIG_NEW_MULTISYMBOL - is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR); -#else - is_split = aom_read(r, cm->fc->txfm_partition_prob[ctx], ACCT_STR); -#endif - - if (is_split) { - const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; - const int bsl = tx_size_wide_unit[sub_txs]; - int i; - - if (counts) ++counts->txfm_partition[ctx][1]; - - if (sub_txs == TX_4X4) { - int idx, idy; - inter_tx_size[0][0] = sub_txs; - for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy) - for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx) - inter_tx_size[idy][idx] = inter_tx_size[0][0]; - mbmi->tx_size = sub_txs; - mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size); - txfm_partition_update(xd->above_txfm_context + blk_col, - xd->left_txfm_context + blk_row, sub_txs, tx_size); - return; - } - - assert(bsl > 0); - for (i = 0; i < 4; ++i) { - int offsetr = blk_row + (i >> 1) * bsl; - int offsetc = blk_col + (i & 0x01) * bsl; - read_tx_size_vartx(cm, xd, mbmi, counts, sub_txs, depth + 1, offsetr, - offsetc, r); +int av1_neg_deinterleave(int diff, int ref, int max) { + if (!ref) return diff; + if (ref >= (max - 1)) return max - diff - 1; + if (2 * ref < max) { + if (diff <= 2 * ref) { + if (diff & 1) + return ref + ((diff + 1) >> 1); + else + return ref - (diff >> 1); } + return diff; } else { - int idx, idy; - inter_tx_size[0][0] = tx_size; - for (idy = 0; idy < tx_size_high_unit[tx_size] / 2; ++idy) - for (idx = 0; idx < tx_size_wide_unit[tx_size] / 2; ++idx) - inter_tx_size[idy][idx] = tx_size; - mbmi->tx_size = tx_size; - mbmi->min_tx_size = AOMMIN(mbmi->min_tx_size, get_min_tx_size(tx_size)); - if (counts) ++counts->txfm_partition[ctx][0]; - txfm_partition_update(xd->above_txfm_context + blk_col, - xd->left_txfm_context + blk_row, tx_size, tx_size); + if (diff <= 2 * (max - ref - 1)) { + if (diff & 1) + return ref + ((diff + 1) >> 1); + else + return ref - (diff >> 1); + } + return max - (diff + 1); } } -#endif -static TX_SIZE read_selected_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd, - int32_t tx_size_cat, aom_reader *r) { - FRAME_COUNTS *counts = xd->counts; - const int ctx = get_tx_size_context(xd); - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; - - const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx], - tx_size_cat + 2, ACCT_STR); - const TX_SIZE tx_size = depth_to_tx_size(depth); -#if CONFIG_RECT_TX - assert(!is_rect_tx(tx_size)); -#endif // CONFIG_RECT_TX - if (counts) ++counts->tx_size[tx_size_cat][ctx][depth]; - return tx_size; -} +static int read_segment_id(AV1_COMMON *const cm, const MACROBLOCKD *const xd, + int mi_row, int mi_col, aom_reader *r, int skip) { + int cdf_num; + const int pred = av1_get_spatial_seg_pred(cm, xd, mi_row, mi_col, &cdf_num); + if (skip) return pred; -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]->mbmi.sb_type; - if (xd->lossless[xd->mi[0]->mbmi.segment_id]) return TX_4X4; - - if (block_signals_txsize(bsize)) { - if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) { - const int32_t tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize] - : intra_tx_size_cat_lookup[bsize]; - const TX_SIZE coded_tx_size = - read_selected_tx_size(cm, xd, tx_size_cat, r); -#if CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX) - if (coded_tx_size > max_txsize_lookup[bsize]) { - assert(coded_tx_size == max_txsize_lookup[bsize] + 1); -#if CONFIG_RECT_TX_EXT - if (is_quarter_tx_allowed(xd, &xd->mi[0]->mbmi, is_inter)) { - int quarter_tx; - - if (quarter_txsize_lookup[bsize] != max_txsize_lookup[bsize]) { -#if CONFIG_NEW_MULTISYMBOL - quarter_tx = - aom_read_symbol(r, cm->fc->quarter_tx_size_cdf, 2, ACCT_STR); -#else - quarter_tx = aom_read(r, cm->fc->quarter_tx_size_prob, ACCT_STR); - FRAME_COUNTS *counts = xd->counts; - if (counts) ++counts->quarter_tx_size[quarter_tx]; -#endif - } else { - quarter_tx = 1; - } - return quarter_tx ? quarter_txsize_lookup[bsize] - : max_txsize_rect_lookup[bsize]; - } -#endif // CONFIG_RECT_TX_EXT - - return max_txsize_rect_lookup[bsize]; - } -#else - assert(coded_tx_size <= max_txsize_lookup[bsize]); -#endif // CONFIG_RECT_TX && (CONFIG_EXT_TX || CONFIG_VAR_TX) - return coded_tx_size; - } else { - return tx_size_from_tx_mode(bsize, tx_mode, is_inter); - } - } else { -#if CONFIG_EXT_TX && CONFIG_RECT_TX - assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4)); - return max_txsize_rect_lookup[bsize]; -#else - return TX_4X4; -#endif // CONFIG_EXT_TX && CONFIG_RECT_TX + FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + struct segmentation *const seg = &cm->seg; + struct segmentation_probs *const segp = &ec_ctx->seg; + aom_cdf_prob *pred_cdf = segp->spatial_pred_seg_cdf[cdf_num]; + const int coded_id = aom_read_symbol(r, pred_cdf, MAX_SEGMENTS, ACCT_STR); + const int segment_id = + av1_neg_deinterleave(coded_id, pred, seg->last_active_segid + 1); + + if (segment_id < 0 || segment_id > seg->last_active_segid) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Corrupted segment_ids"); } + return segment_id; } static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids, int mi_offset, int x_mis, int y_mis) { - int x, y, segment_id = INT_MAX; + int segment_id = INT_MAX; - for (y = 0; y < y_mis; y++) - for (x = 0; x < x_mis; x++) + for (int y = 0; y < y_mis; y++) + for (int x = 0; x < x_mis; x++) segment_id = AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]); @@ -575,30 +311,28 @@ static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids, static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis, int segment_id) { - int x, y; - assert(segment_id >= 0 && segment_id < MAX_SEGMENTS); - for (y = 0; y < y_mis; y++) - for (x = 0; x < x_mis; x++) + for (int y = 0; y < y_mis; y++) + for (int x = 0; x < x_mis; x++) cm->current_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id; } -static int read_intra_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_offset, int x_mis, int y_mis, - aom_reader *r) { +static int read_intra_segment_id(AV1_COMMON *const cm, + const MACROBLOCKD *const xd, int mi_row, + int mi_col, int bsize, aom_reader *r, + int skip) { struct segmentation *const seg = &cm->seg; - FRAME_COUNTS *counts = xd->counts; - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - struct segmentation_probs *const segp = &ec_ctx->seg; - int segment_id; - if (!seg->enabled) return 0; // Default for disabled segmentation assert(seg->update_map && !seg->temporal_update); - segment_id = read_segment_id(r, segp); - if (counts) ++counts->seg.tree_total[segment_id]; + const int mi_offset = mi_row * cm->mi_cols + mi_col; + const int bw = mi_size_wide[bsize]; + const int bh = mi_size_high[bsize]; + const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw); + const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh); + const int segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, skip); set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); return segment_id; } @@ -607,24 +341,25 @@ static void copy_segment_id(const AV1_COMMON *cm, const uint8_t *last_segment_ids, uint8_t *current_segment_ids, int mi_offset, int x_mis, int y_mis) { - int x, y; - - for (y = 0; y < y_mis; y++) - for (x = 0; x < x_mis; x++) + for (int y = 0; y < y_mis; y++) + for (int x = 0; x < x_mis; x++) current_segment_ids[mi_offset + y * cm->mi_cols + x] = last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x] : 0; } +static int get_predicted_segment_id(AV1_COMMON *const cm, int mi_offset, + int x_mis, int y_mis) { + return cm->last_frame_seg_map ? dec_get_segment_id(cm, cm->last_frame_seg_map, + mi_offset, x_mis, y_mis) + : 0; +} + static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_row, int mi_col, aom_reader *r) { + int mi_row, int mi_col, int preskip, + aom_reader *r) { struct segmentation *const seg = &cm->seg; - FRAME_COUNTS *counts = xd->counts; - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - struct segmentation_probs *const segp = &ec_ctx->seg; - - MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; - int predicted_segment_id, segment_id; + MB_MODE_INFO *const mbmi = xd->mi[0]; const int mi_offset = mi_row * cm->mi_cols + mi_col; const int bw = mi_size_wide[mbmi->sb_type]; const int bh = mi_size_high[mbmi->sb_type]; @@ -635,60 +370,82 @@ static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd, if (!seg->enabled) return 0; // Default for disabled segmentation - predicted_segment_id = cm->last_frame_seg_map - ? dec_get_segment_id(cm, cm->last_frame_seg_map, - mi_offset, x_mis, y_mis) - : 0; - if (!seg->update_map) { copy_segment_id(cm, cm->last_frame_seg_map, cm->current_frame_seg_map, mi_offset, x_mis, y_mis); - return predicted_segment_id; + return get_predicted_segment_id(cm, mi_offset, x_mis, y_mis); + } + + int segment_id; + if (preskip) { + if (!seg->segid_preskip) return 0; + } else { + if (seg->segid_preskip) return mbmi->segment_id; + if (mbmi->skip) { + if (seg->temporal_update) { + mbmi->seg_id_predicted = 0; + } + segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 1); + set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); + return segment_id; + } } if (seg->temporal_update) { const int ctx = av1_get_pred_context_seg_id(xd); -#if CONFIG_NEW_MULTISYMBOL + FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + struct segmentation_probs *const segp = &ec_ctx->seg; aom_cdf_prob *pred_cdf = segp->pred_cdf[ctx]; mbmi->seg_id_predicted = aom_read_symbol(r, pred_cdf, 2, ACCT_STR); -#else - const aom_prob pred_prob = segp->pred_probs[ctx]; - mbmi->seg_id_predicted = aom_read(r, pred_prob, ACCT_STR); -#endif - if (counts) ++counts->seg.pred[ctx][mbmi->seg_id_predicted]; if (mbmi->seg_id_predicted) { - segment_id = predicted_segment_id; + segment_id = get_predicted_segment_id(cm, mi_offset, x_mis, y_mis); } else { - segment_id = read_segment_id(r, segp); - if (counts) ++counts->seg.tree_mispred[segment_id]; + segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0); } } else { - segment_id = read_segment_id(r, segp); - if (counts) ++counts->seg.tree_total[segment_id]; + segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0); } set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); return segment_id; } +static int read_skip_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id, + aom_reader *r) { + if (!cm->skip_mode_flag) return 0; + + if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) { + return 0; + } + + if (!is_comp_ref_allowed(xd->mi[0]->sb_type)) return 0; + + if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME) || + segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) { + // These features imply single-reference mode, while skip mode implies + // compound reference. Hence, the two are mutually exclusive. + // In other words, skip_mode is implicitly 0 here. + return 0; + } + + const int ctx = av1_get_skip_mode_context(xd); + FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + const int skip_mode = + aom_read_symbol(r, ec_ctx->skip_mode_cdfs[ctx], 2, ACCT_STR); + return skip_mode; +} + static int read_skip(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id, aom_reader *r) { if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) { return 1; } else { const int ctx = av1_get_skip_context(xd); -#if CONFIG_NEW_MULTISYMBOL FRAME_CONTEXT *ec_ctx = xd->tile_ctx; const int skip = aom_read_symbol(r, ec_ctx->skip_cdfs[ctx], 2, ACCT_STR); -#else - const int skip = aom_read(r, cm->fc->skip_probs[ctx], ACCT_STR); -#endif - FRAME_COUNTS *counts = xd->counts; - if (counts) ++counts->skip[ctx][skip]; return skip; } } -#if CONFIG_PALETTE_DELTA_ENCODING // Merge the sorted list of cached colors(cached_colors[0...n_cached_colors-1]) // and the sorted list of transmitted colors(colors[n_cached_colors...n-1]) into // one single sorted list(colors[...]). @@ -796,346 +553,114 @@ static void read_palette_colors_uv(MACROBLOCKD *const xd, int bit_depth, } } } -#endif // CONFIG_PALETTE_DELTA_ENCODING static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, - aom_reader *r) { - MODE_INFO *const mi = xd->mi[0]; - MB_MODE_INFO *const mbmi = &mi->mbmi; - const MODE_INFO *const above_mi = xd->above_mi; - const MODE_INFO *const left_mi = xd->left_mi; + int mi_row, int mi_col, aom_reader *r) { + const int num_planes = av1_num_planes(cm); + MB_MODE_INFO *const mbmi = xd->mi[0]; const BLOCK_SIZE bsize = mbmi->sb_type; + assert(av1_allow_palette(cm->allow_screen_content_tools, bsize)); PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info; - - assert(bsize >= BLOCK_8X8 && bsize <= BLOCK_LARGEST); - const int block_palette_idx = bsize - BLOCK_8X8; - int modev; + const int bsize_ctx = av1_get_palette_bsize_ctx(bsize); if (mbmi->mode == DC_PRED) { - int palette_y_mode_ctx = 0; - if (above_mi) { - palette_y_mode_ctx += - (above_mi->mbmi.palette_mode_info.palette_size[0] > 0); - } - if (left_mi) { - palette_y_mode_ctx += - (left_mi->mbmi.palette_mode_info.palette_size[0] > 0); - } -#if CONFIG_NEW_MULTISYMBOL - modev = aom_read_symbol( - r, - xd->tile_ctx->palette_y_mode_cdf[block_palette_idx][palette_y_mode_ctx], - 2, ACCT_STR); -#else - modev = aom_read( - r, - av1_default_palette_y_mode_prob[block_palette_idx][palette_y_mode_ctx], + const int palette_mode_ctx = av1_get_palette_mode_ctx(xd); + const int modev = aom_read_symbol( + r, xd->tile_ctx->palette_y_mode_cdf[bsize_ctx][palette_mode_ctx], 2, ACCT_STR); -#endif if (modev) { pmi->palette_size[0] = - aom_read_symbol(r, - xd->tile_ctx->palette_y_size_cdf[block_palette_idx], + aom_read_symbol(r, xd->tile_ctx->palette_y_size_cdf[bsize_ctx], PALETTE_SIZES, ACCT_STR) + 2; -#if CONFIG_PALETTE_DELTA_ENCODING read_palette_colors_y(xd, cm->bit_depth, pmi, r); -#else - for (int i = 0; i < pmi->palette_size[0]; ++i) - pmi->palette_colors[i] = aom_read_literal(r, cm->bit_depth, ACCT_STR); -#endif // CONFIG_PALETTE_DELTA_ENCODING } } - if (mbmi->uv_mode == UV_DC_PRED) { + if (num_planes > 1 && mbmi->uv_mode == UV_DC_PRED && + is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, + xd->plane[1].subsampling_y)) { const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0); -#if CONFIG_NEW_MULTISYMBOL - modev = aom_read_symbol( + const int modev = aom_read_symbol( r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR); -#else - modev = aom_read(r, av1_default_palette_uv_mode_prob[palette_uv_mode_ctx], - ACCT_STR); -#endif if (modev) { pmi->palette_size[1] = - aom_read_symbol(r, - xd->tile_ctx->palette_uv_size_cdf[block_palette_idx], + aom_read_symbol(r, xd->tile_ctx->palette_uv_size_cdf[bsize_ctx], PALETTE_SIZES, ACCT_STR) + 2; -#if CONFIG_PALETTE_DELTA_ENCODING read_palette_colors_uv(xd, cm->bit_depth, pmi, r); -#else - for (int i = 0; i < pmi->palette_size[1]; ++i) { - pmi->palette_colors[PALETTE_MAX_SIZE + i] = - aom_read_literal(r, cm->bit_depth, ACCT_STR); - pmi->palette_colors[2 * PALETTE_MAX_SIZE + i] = - aom_read_literal(r, cm->bit_depth, ACCT_STR); - } -#endif // CONFIG_PALETTE_DELTA_ENCODING } } } -#if CONFIG_FILTER_INTRA -static void read_filter_intra_mode_info(AV1_COMMON *const cm, - MACROBLOCKD *const xd, int mi_row, - int mi_col, aom_reader *r) { - MODE_INFO *const mi = xd->mi[0]; - MB_MODE_INFO *const mbmi = &mi->mbmi; - FRAME_COUNTS *counts = xd->counts; +static int read_angle_delta(aom_reader *r, aom_cdf_prob *cdf) { + const int sym = aom_read_symbol(r, cdf, 2 * MAX_ANGLE_DELTA + 1, ACCT_STR); + return sym - MAX_ANGLE_DELTA; +} + +static void read_filter_intra_mode_info(const AV1_COMMON *const cm, + MACROBLOCKD *const xd, aom_reader *r) { + MB_MODE_INFO *const mbmi = xd->mi[0]; FILTER_INTRA_MODE_INFO *filter_intra_mode_info = &mbmi->filter_intra_mode_info; - if (mbmi->mode == DC_PRED && mbmi->palette_mode_info.palette_size[0] == 0) { - filter_intra_mode_info->use_filter_intra_mode[0] = - aom_read(r, cm->fc->filter_intra_probs[0], ACCT_STR); - if (filter_intra_mode_info->use_filter_intra_mode[0]) { - filter_intra_mode_info->filter_intra_mode[0] = - av1_read_uniform(r, FILTER_INTRA_MODES); + if (av1_filter_intra_allowed(cm, mbmi)) { + filter_intra_mode_info->use_filter_intra = aom_read_symbol( + r, xd->tile_ctx->filter_intra_cdfs[mbmi->sb_type], 2, ACCT_STR); + if (filter_intra_mode_info->use_filter_intra) { + filter_intra_mode_info->filter_intra_mode = aom_read_symbol( + r, xd->tile_ctx->filter_intra_mode_cdf, FILTER_INTRA_MODES, ACCT_STR); } - if (counts) { - ++counts - ->filter_intra[0][filter_intra_mode_info->use_filter_intra_mode[0]]; - } - } - -#if CONFIG_CB4X4 - if (!is_chroma_reference(mi_row, mi_col, mbmi->sb_type, - xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y)) - return; -#else - (void)mi_row; - (void)mi_col; -#endif // CONFIG_CB4X4 - - if (mbmi->uv_mode == UV_DC_PRED && - mbmi->palette_mode_info.palette_size[1] == 0) { - filter_intra_mode_info->use_filter_intra_mode[1] = - aom_read(r, cm->fc->filter_intra_probs[1], ACCT_STR); - if (filter_intra_mode_info->use_filter_intra_mode[1]) { - filter_intra_mode_info->filter_intra_mode[1] = - av1_read_uniform(r, FILTER_INTRA_MODES); - } - if (counts) { - ++counts - ->filter_intra[1][filter_intra_mode_info->use_filter_intra_mode[1]]; - } - } -} -#endif // CONFIG_FILTER_INTRA - -#if CONFIG_EXT_INTRA -static void read_intra_angle_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, - aom_reader *r) { - MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; - const BLOCK_SIZE bsize = mbmi->sb_type; -#if CONFIG_INTRA_INTERP - FRAME_CONTEXT *const ec_ctx = xd->tile_ctx; - const int ctx = av1_get_pred_context_intra_interp(xd); - int p_angle; -#endif // CONFIG_INTRA_INTERP - - (void)cm; - - mbmi->angle_delta[0] = 0; - mbmi->angle_delta[1] = 0; -#if CONFIG_INTRA_INTERP - mbmi->intra_filter = INTRA_FILTER_LINEAR; -#endif // CONFIG_INTRA_INTERP - - if (!av1_use_angle_delta(bsize)) return; - - if (av1_is_directional_mode(mbmi->mode, bsize)) { - mbmi->angle_delta[0] = - av1_read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA; -#if CONFIG_INTRA_INTERP - p_angle = mode_to_angle_map[mbmi->mode] + mbmi->angle_delta[0] * ANGLE_STEP; - if (av1_is_intra_filter_switchable(p_angle)) { - FRAME_COUNTS *counts = xd->counts; - mbmi->intra_filter = aom_read_symbol(r, ec_ctx->intra_filter_cdf[ctx], - INTRA_FILTERS, ACCT_STR); - if (counts) ++counts->intra_filter[ctx][mbmi->intra_filter]; - } -#endif // CONFIG_INTRA_INTERP - } - - if (av1_is_directional_mode(get_uv_mode(mbmi->uv_mode), bsize)) { - mbmi->angle_delta[1] = - av1_read_uniform(r, 2 * MAX_ANGLE_DELTA + 1) - MAX_ANGLE_DELTA; + } else { + filter_intra_mode_info->use_filter_intra = 0; } } -#endif // CONFIG_EXT_INTRA -void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif -#if CONFIG_TXK_SEL - int blk_row, int blk_col, int block, int plane, - TX_SIZE tx_size, -#endif - aom_reader *r) { - MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; +void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row, + int blk_col, TX_SIZE tx_size, aom_reader *r) { + MB_MODE_INFO *mbmi = xd->mi[0]; const int inter_block = is_inter_block(mbmi); -#if !CONFIG_TXK_SEL -#if CONFIG_VAR_TX - const TX_SIZE tx_size = inter_block ? mbmi->min_tx_size : mbmi->tx_size; -#else - const TX_SIZE tx_size = mbmi->tx_size; -#endif -#endif // !CONFIG_TXK_SEL FRAME_CONTEXT *ec_ctx = xd->tile_ctx; -#if !CONFIG_TXK_SEL - TX_TYPE *tx_type = &mbmi->tx_type; -#else - // only y plane's tx_type is transmitted - if (plane > 0) return; - (void)block; - TX_TYPE *tx_type = &mbmi->txk_type[(blk_row << 4) + blk_col]; -#endif -#if CONFIG_LGT_FROM_PRED - mbmi->use_lgt = 0; -#endif - - if (!FIXED_TX_TYPE) { -#if CONFIG_EXT_TX - const TX_SIZE square_tx_size = txsize_sqr_map[tx_size]; - if (get_ext_tx_types(tx_size, mbmi->sb_type, inter_block, - cm->reduced_tx_set_used) > 1 && - ((!cm->seg.enabled && cm->base_qindex > 0) || - (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) && - !mbmi->skip && -#if CONFIG_SUPERTX - !supertx_enabled && -#endif // CONFIG_SUPERTX - !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { - const TxSetType tx_set_type = get_ext_tx_set_type( - tx_size, mbmi->sb_type, inter_block, cm->reduced_tx_set_used); - const int eset = get_ext_tx_set(tx_size, mbmi->sb_type, inter_block, - cm->reduced_tx_set_used); - // eset == 0 should correspond to a set with only DCT_DCT and - // there is no need to read the tx_type - assert(eset != 0); - -#if !CONFIG_LGT_FROM_PRED - if (inter_block) { - *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( - r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size], - av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; - } else if (ALLOW_INTRA_EXT_TX) { - *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( - r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode], - av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; - } -#else - // only signal tx_type when lgt is not allowed or not selected - if (inter_block) { - if (LGT_FROM_PRED_INTER) { - if (is_lgt_allowed(mbmi->mode, tx_size) && !cm->reduced_tx_set_used) { - mbmi->use_lgt = - aom_read(r, ec_ctx->inter_lgt_prob[square_tx_size], ACCT_STR); -#if CONFIG_ENTROPY_STATS - if (counts) ++counts->inter_lgt[square_tx_size][mbmi->use_lgt]; -#endif // CONFIG_ENTROPY_STATS - } - if (!mbmi->use_lgt) { - *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( - r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size], - av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; -#if CONFIG_ENTROPY_STATS - if (counts) ++counts->inter_ext_tx[eset][square_tx_size][*tx_type]; -#endif // CONFIG_ENTROPY_STATS - } else { - *tx_type = DCT_DCT; // assign a dummy tx_type - } - } else { - *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( - r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size], - av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; -#if CONFIG_ENTROPY_STATS - if (counts) ++counts->inter_ext_tx[eset][square_tx_size][*tx_type]; -#endif // CONFIG_ENTROPY_STATS - } - } else if (ALLOW_INTRA_EXT_TX) { - if (LGT_FROM_PRED_INTRA) { - if (is_lgt_allowed(mbmi->mode, tx_size) && !cm->reduced_tx_set_used) { - mbmi->use_lgt = - aom_read(r, ec_ctx->intra_lgt_prob[square_tx_size][mbmi->mode], - ACCT_STR); -#if CONFIG_ENTROPY_STATS - if (counts) - ++counts->intra_lgt[square_tx_size][mbmi->mode][mbmi->use_lgt]; -#endif // CONFIG_ENTROPY_STATS - } - if (!mbmi->use_lgt) { - *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( - r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode], - av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; -#if CONFIG_ENTROPY_STATS - if (counts) - ++counts - ->intra_ext_tx[eset][square_tx_size][mbmi->mode][*tx_type]; -#endif // CONFIG_ENTROPY_STATS - } else { - *tx_type = DCT_DCT; // assign a dummy tx_type - } - } else { - *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( - r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][mbmi->mode], - av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; -#if CONFIG_ENTROPY_STATS - if (counts) - ++counts->intra_ext_tx[eset][square_tx_size][mbmi->mode][*tx_type]; -#endif // CONFIG_ENTROPY_STATS - } - } -#endif // CONFIG_LGT_FROM_PRED + const int txk_type_idx = + av1_get_txk_type_index(mbmi->sb_type, blk_row, blk_col); + TX_TYPE *tx_type = &mbmi->txk_type[txk_type_idx]; + + const TX_SIZE square_tx_size = txsize_sqr_map[tx_size]; + if (get_ext_tx_types(tx_size, inter_block, cm->reduced_tx_set_used) > 1 && + ((!cm->seg.enabled && cm->base_qindex > 0) || + (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) && + !mbmi->skip && + !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { + const TxSetType tx_set_type = + av1_get_ext_tx_set_type(tx_size, inter_block, cm->reduced_tx_set_used); + const int eset = + get_ext_tx_set(tx_size, inter_block, cm->reduced_tx_set_used); + // eset == 0 should correspond to a set with only DCT_DCT and + // there is no need to read the tx_type + assert(eset != 0); + + if (inter_block) { + *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( + r, ec_ctx->inter_ext_tx_cdf[eset][square_tx_size], + av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; } else { - *tx_type = DCT_DCT; - } -#else // CONFIG_EXT_TX - - if (tx_size < TX_32X32 && - ((!cm->seg.enabled && cm->base_qindex > 0) || - (cm->seg.enabled && xd->qindex[mbmi->segment_id] > 0)) && - !mbmi->skip && -#if CONFIG_SUPERTX - !supertx_enabled && -#endif // CONFIG_SUPERTX - !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { -#if CONFIG_ENTROPY_STATS - FRAME_COUNTS *counts = xd->counts; -#endif // CONFIG_ENTROPY_STATS - if (inter_block) { - *tx_type = av1_ext_tx_inv[aom_read_symbol( - r, ec_ctx->inter_ext_tx_cdf[tx_size], TX_TYPES, ACCT_STR)]; -#if CONFIG_ENTROPY_STATS - if (counts) ++counts->inter_ext_tx[tx_size][*tx_type]; -#endif // CONFIG_ENTROPY_STATS - } else { - const TX_TYPE tx_type_nom = intra_mode_to_tx_type_context[mbmi->mode]; - *tx_type = av1_ext_tx_inv[aom_read_symbol( - r, ec_ctx->intra_ext_tx_cdf[tx_size][tx_type_nom], TX_TYPES, - ACCT_STR)]; -#if CONFIG_ENTROPY_STATS - if (counts) ++counts->intra_ext_tx[tx_size][tx_type_nom][*tx_type]; -#endif // CONFIG_ENTROPY_STATS - } - } else { - *tx_type = DCT_DCT; + PREDICTION_MODE intra_dir; + if (mbmi->filter_intra_mode_info.use_filter_intra) + intra_dir = + fimode_to_intradir[mbmi->filter_intra_mode_info.filter_intra_mode]; + else + intra_dir = mbmi->mode; + *tx_type = av1_ext_tx_inv[tx_set_type][aom_read_symbol( + r, ec_ctx->intra_ext_tx_cdf[eset][square_tx_size][intra_dir], + av1_num_ext_tx_set[tx_set_type], ACCT_STR)]; } -#endif // CONFIG_EXT_TX + } else { + *tx_type = DCT_DCT; } -#if FIXED_TX_TYPE - assert(mbmi->tx_type == DCT_DCT); -#endif } -#if CONFIG_INTRABC static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref, - nmv_context *ctx, nmv_context_counts *counts, - MvSubpelPrecision precision); + nmv_context *ctx, MvSubpelPrecision precision); static INLINE int is_mv_valid(const MV *mv); @@ -1143,267 +668,195 @@ static INLINE int assign_dv(AV1_COMMON *cm, MACROBLOCKD *xd, int_mv *mv, const int_mv *ref_mv, int mi_row, int mi_col, BLOCK_SIZE bsize, aom_reader *r) { FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - (void)cm; - FRAME_COUNTS *counts = xd->counts; - nmv_context_counts *const dv_counts = counts ? &counts->dv : NULL; - read_mv(r, &mv->as_mv, &ref_mv->as_mv, &ec_ctx->ndvc, dv_counts, - MV_SUBPEL_NONE); + read_mv(r, &mv->as_mv, &ref_mv->as_mv, &ec_ctx->ndvc, MV_SUBPEL_NONE); + // DV should not have sub-pel. + assert((mv->as_mv.col & 7) == 0); + assert((mv->as_mv.row & 7) == 0); + mv->as_mv.col = (mv->as_mv.col >> 3) * 8; + mv->as_mv.row = (mv->as_mv.row >> 3) * 8; int valid = is_mv_valid(&mv->as_mv) && - is_dv_valid(mv->as_mv, &xd->tile, mi_row, mi_col, bsize); + av1_is_dv_valid(mv->as_mv, cm, xd, mi_row, mi_col, bsize, + cm->seq_params.mib_size_log2); return valid; } -#endif // CONFIG_INTRABC + +static void read_intrabc_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, + int mi_row, int mi_col, aom_reader *r) { + MB_MODE_INFO *const mbmi = xd->mi[0]; + FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + mbmi->use_intrabc = aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_STR); + if (mbmi->use_intrabc) { + BLOCK_SIZE bsize = mbmi->sb_type; + mbmi->mode = DC_PRED; + mbmi->uv_mode = UV_DC_PRED; + mbmi->interp_filters = av1_broadcast_interp_filter(BILINEAR); + mbmi->motion_mode = SIMPLE_TRANSLATION; + + int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES]; + int_mv ref_mvs[INTRA_FRAME + 1][MAX_MV_REF_CANDIDATES]; + int_mv global_mvs[REF_FRAMES]; + + av1_find_mv_refs(cm, xd, mbmi, INTRA_FRAME, xd->ref_mv_count, + xd->ref_mv_stack, ref_mvs, global_mvs, mi_row, mi_col, + inter_mode_ctx); + + int_mv nearestmv, nearmv; + + av1_find_best_ref_mvs(0, ref_mvs[INTRA_FRAME], &nearestmv, &nearmv, 0); + int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv; + if (dv_ref.as_int == 0) + av1_find_ref_dv(&dv_ref, &xd->tile, cm->seq_params.mib_size, mi_row, + mi_col); + // Ref DV should not have sub-pel. + int valid_dv = (dv_ref.as_mv.col & 7) == 0 && (dv_ref.as_mv.row & 7) == 0; + dv_ref.as_mv.col = (dv_ref.as_mv.col >> 3) * 8; + dv_ref.as_mv.row = (dv_ref.as_mv.row >> 3) * 8; + valid_dv = valid_dv && assign_dv(cm, xd, &mbmi->mv[0], &dv_ref, mi_row, + mi_col, bsize, r); + if (!valid_dv) { + // Intra bc motion vectors are not valid - signal corrupt frame + aom_merge_corrupted_flag(&xd->corrupted, 1); + } + } +} static void read_intra_frame_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, int mi_row, int mi_col, aom_reader *r) { - MODE_INFO *const mi = xd->mi[0]; - MB_MODE_INFO *const mbmi = &mi->mbmi; - const MODE_INFO *above_mi = xd->above_mi; - const MODE_INFO *left_mi = xd->left_mi; + MB_MODE_INFO *const mbmi = xd->mi[0]; + const MB_MODE_INFO *above_mi = xd->above_mbmi; + const MB_MODE_INFO *left_mi = xd->left_mbmi; const BLOCK_SIZE bsize = mbmi->sb_type; - int i; - const int mi_offset = mi_row * cm->mi_cols + mi_col; - const int bw = mi_size_wide[bsize]; - const int bh = mi_size_high[bsize]; + struct segmentation *const seg = &cm->seg; - // TODO(slavarnway): move x_mis, y_mis into xd ????? - const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw); - const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh); FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - mbmi->segment_id = read_intra_segment_id(cm, xd, mi_offset, x_mis, y_mis, r); + if (seg->segid_preskip) + mbmi->segment_id = + read_intra_segment_id(cm, xd, mi_row, mi_col, bsize, r, 0); + mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r); + if (!seg->segid_preskip) + mbmi->segment_id = + read_intra_segment_id(cm, xd, mi_row, mi_col, bsize, r, mbmi->skip); + + read_cdef(cm, r, xd, mi_col, mi_row); + if (cm->delta_q_present_flag) { - xd->current_qindex = - xd->prev_qindex + + xd->current_qindex += read_delta_qindex(cm, xd, r, mbmi, mi_col, mi_row) * cm->delta_q_res; /* Normative: Clamp to [1,MAXQ] to not interfere with lossless mode */ xd->current_qindex = clamp(xd->current_qindex, 1, MAXQ); - xd->prev_qindex = xd->current_qindex; -#if CONFIG_EXT_DELTA_Q if (cm->delta_lf_present_flag) { -#if CONFIG_LOOPFILTER_LEVEL if (cm->delta_lf_multi) { - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) { - mbmi->curr_delta_lf[lf_id] = xd->curr_delta_lf[lf_id] = - xd->prev_delta_lf[lf_id] + + const int frame_lf_count = + av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; + for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { + const int tmp_lvl = + xd->delta_lf[lf_id] + read_delta_lflevel(cm, xd, r, lf_id, mbmi, mi_col, mi_row) * cm->delta_lf_res; - xd->prev_delta_lf[lf_id] = xd->curr_delta_lf[lf_id]; + mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id] = + clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); } } else { - mbmi->current_delta_lf_from_base = xd->current_delta_lf_from_base = - xd->prev_delta_lf_from_base + + const int tmp_lvl = + xd->delta_lf_from_base + read_delta_lflevel(cm, xd, r, -1, mbmi, mi_col, mi_row) * cm->delta_lf_res; - xd->prev_delta_lf_from_base = xd->current_delta_lf_from_base; + mbmi->delta_lf_from_base = xd->delta_lf_from_base = + clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); } -#else - const int current_delta_lf_from_base = - xd->prev_delta_lf_from_base + - read_delta_lflevel(cm, xd, r, mbmi, mi_col, mi_row) * - cm->delta_lf_res; - mbmi->current_delta_lf_from_base = xd->current_delta_lf_from_base = - clamp(current_delta_lf_from_base, 0, MAX_LOOP_FILTER); - xd->prev_delta_lf_from_base = xd->current_delta_lf_from_base; -#endif // CONFIG_LOOPFILTER_LEVEL } -#endif } + mbmi->current_qindex = xd->current_qindex; + mbmi->ref_frame[0] = INTRA_FRAME; mbmi->ref_frame[1] = NONE_FRAME; + mbmi->palette_mode_info.palette_size[0] = 0; + mbmi->palette_mode_info.palette_size[1] = 0; + mbmi->filter_intra_mode_info.use_filter_intra = 0; -#if CONFIG_INTRABC - if (av1_allow_intrabc(bsize, cm)) { - mbmi->use_intrabc = aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_STR); - if (mbmi->use_intrabc) { - mbmi->tx_size = read_tx_size(cm, xd, 1, !mbmi->skip, r); - mbmi->mode = mbmi->uv_mode = UV_DC_PRED; - mbmi->interp_filters = av1_broadcast_interp_filter(BILINEAR); - - int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES]; - int_mv ref_mvs[MAX_MV_REF_CANDIDATES]; - - av1_find_mv_refs(cm, xd, mi, INTRA_FRAME, &xd->ref_mv_count[INTRA_FRAME], - xd->ref_mv_stack[INTRA_FRAME], NULL, ref_mvs, mi_row, - mi_col, NULL, NULL, inter_mode_ctx); - - int_mv nearestmv, nearmv; - av1_find_best_ref_mvs(0, ref_mvs, &nearestmv, &nearmv); - - int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv; - if (dv_ref.as_int == 0) av1_find_ref_dv(&dv_ref, mi_row, mi_col); - - xd->corrupted |= - !assign_dv(cm, xd, &mbmi->mv[0], &dv_ref, mi_row, mi_col, bsize, r); -#if CONFIG_VAR_TX - // TODO(aconverse@google.com): Evaluate allowing VAR TX on intrabc blocks - const int width = block_size_wide[bsize] >> tx_size_wide_log2[0]; - const int height = block_size_high[bsize] >> tx_size_high_log2[0]; - int idx, idy; - for (idy = 0; idy < height; ++idy) - for (idx = 0; idx < width; ++idx) - mbmi->inter_tx_size[idy >> 1][idx >> 1] = mbmi->tx_size; - mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size); -#endif // CONFIG_VAR_TX -#if CONFIG_EXT_TX && !CONFIG_TXK_SEL - av1_read_tx_type(cm, xd, -#if CONFIG_SUPERTX - 0, -#endif - r); -#endif // CONFIG_EXT_TX && !CONFIG_TXK_SEL - return; - } - } -#endif // CONFIG_INTRABC - - mbmi->tx_size = read_tx_size(cm, xd, 0, 1, r); - -#if CONFIG_CB4X4 - (void)i; - mbmi->mode = - read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0)); -#else - switch (bsize) { - case BLOCK_4X4: - for (i = 0; i < 4; ++i) - mi->bmi[i].as_mode = read_intra_mode( - r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, i)); - mbmi->mode = mi->bmi[3].as_mode; - break; - case BLOCK_4X8: - mi->bmi[0].as_mode = mi->bmi[2].as_mode = - read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0)); - mi->bmi[1].as_mode = mi->bmi[3].as_mode = mbmi->mode = - read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 1)); - break; - case BLOCK_8X4: - mi->bmi[0].as_mode = mi->bmi[1].as_mode = - read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0)); - mi->bmi[2].as_mode = mi->bmi[3].as_mode = mbmi->mode = - read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 2)); - break; - default: - mbmi->mode = - read_intra_mode(r, get_y_mode_cdf(ec_ctx, mi, above_mi, left_mi, 0)); + xd->above_txfm_context = cm->above_txfm_context[xd->tile.tile_row] + mi_col; + xd->left_txfm_context = + xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); + + if (av1_allow_intrabc(cm)) { + read_intrabc_info(cm, xd, mi_row, mi_col, r); + if (is_intrabc_block(mbmi)) return; } -#endif -#if CONFIG_CB4X4 - if (is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y)) { -#if CONFIG_CFL - xd->cfl->is_chroma_reference = 1; -#endif // CONFIG_CFL -#endif // CONFIG_CB4X4 - mbmi->uv_mode = read_intra_mode_uv(ec_ctx, r, mbmi->mode); + mbmi->mode = read_intra_mode(r, get_y_mode_cdf(ec_ctx, above_mi, left_mi)); -#if CONFIG_CFL + const int use_angle_delta = av1_use_angle_delta(bsize); + mbmi->angle_delta[PLANE_TYPE_Y] = + (use_angle_delta && av1_is_directional_mode(mbmi->mode)) + ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED]) + : 0; + + if (!cm->seq_params.monochrome && + is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, + xd->plane[1].subsampling_y)) { + xd->cfl.is_chroma_reference = 1; + mbmi->uv_mode = + read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode); if (mbmi->uv_mode == UV_CFL_PRED) { mbmi->cfl_alpha_idx = read_cfl_alphas(ec_ctx, r, &mbmi->cfl_alpha_signs); - xd->cfl->store_y = 1; - } else { - xd->cfl->store_y = 0; } -#endif // CONFIG_CFL - -#if CONFIG_CB4X4 + mbmi->angle_delta[PLANE_TYPE_UV] = + (use_angle_delta && av1_is_directional_mode(get_uv_mode(mbmi->uv_mode))) + ? read_angle_delta(r, + ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED]) + : 0; } else { // Avoid decoding angle_info if there is is no chroma prediction mbmi->uv_mode = UV_DC_PRED; -#if CONFIG_CFL - xd->cfl->is_chroma_reference = 0; - xd->cfl->store_y = 1; -#endif + xd->cfl.is_chroma_reference = 0; } -#endif + xd->cfl.store_y = store_cfl_required(cm, xd); -#if CONFIG_EXT_INTRA - read_intra_angle_info(cm, xd, r); -#endif // CONFIG_EXT_INTRA - mbmi->palette_mode_info.palette_size[0] = 0; - mbmi->palette_mode_info.palette_size[1] = 0; if (av1_allow_palette(cm->allow_screen_content_tools, bsize)) - read_palette_mode_info(cm, xd, r); -#if CONFIG_FILTER_INTRA - mbmi->filter_intra_mode_info.use_filter_intra_mode[0] = 0; - mbmi->filter_intra_mode_info.use_filter_intra_mode[1] = 0; - if (bsize >= BLOCK_8X8 || CONFIG_CB4X4) - read_filter_intra_mode_info(cm, xd, mi_row, mi_col, r); -#endif // CONFIG_FILTER_INTRA - -#if !CONFIG_TXK_SEL - av1_read_tx_type(cm, xd, -#if CONFIG_SUPERTX - 0, -#endif - r); -#endif // !CONFIG_TXK_SEL + read_palette_mode_info(cm, xd, mi_row, mi_col, r); + + read_filter_intra_mode_info(cm, xd, r); } static int read_mv_component(aom_reader *r, nmv_component *mvcomp, -#if CONFIG_INTRABC || CONFIG_AMVR - int use_subpel, -#endif // CONFIG_INTRABC || CONFIG_AMVR - int usehp) { + int use_subpel, int usehp) { int mag, d, fr, hp; -#if CONFIG_NEW_MULTISYMBOL - const int sign = aom_read_bit(r, ACCT_STR); -#else - const int sign = aom_read(r, mvcomp->sign, ACCT_STR); -#endif + const int sign = aom_read_symbol(r, mvcomp->sign_cdf, 2, ACCT_STR); const int mv_class = - aom_read_symbol(r, mvcomp->class_cdf, MV_CLASSES, ACCT_STR); + aom_read_symbol(r, mvcomp->classes_cdf, MV_CLASSES, ACCT_STR); const int class0 = mv_class == MV_CLASS_0; // Integer part if (class0) { -#if CONFIG_NEW_MULTISYMBOL d = aom_read_symbol(r, mvcomp->class0_cdf, CLASS0_SIZE, ACCT_STR); -#else - d = aom_read(r, mvcomp->class0[0], ACCT_STR); -#endif mag = 0; } else { - int i; const int n = mv_class + CLASS0_BITS - 1; // number of bits d = 0; -#if CONFIG_NEW_MULTISYMBOL - for (i = 0; i < n; ++i) - d |= aom_read_symbol(r, mvcomp->bits_cdf[(i + 1) / 2], 2, ACCT_STR) << i; -#else - for (i = 0; i < n; ++i) d |= aom_read(r, mvcomp->bits[i], ACCT_STR) << i; -#endif + for (int i = 0; i < n; ++i) + d |= aom_read_symbol(r, mvcomp->bits_cdf[i], 2, ACCT_STR) << i; mag = CLASS0_SIZE << (mv_class + 2); } -#if CONFIG_INTRABC || CONFIG_AMVR if (use_subpel) { -#endif // CONFIG_INTRABC || CONFIG_AMVR - // Fractional part + // Fractional part fr = aom_read_symbol(r, class0 ? mvcomp->class0_fp_cdf[d] : mvcomp->fp_cdf, MV_FP_SIZE, ACCT_STR); -// High precision part (if hp is not used, the default value of the hp is 1) -#if CONFIG_NEW_MULTISYMBOL + // High precision part (if hp is not used, the default value of the hp is 1) hp = usehp ? aom_read_symbol( r, class0 ? mvcomp->class0_hp_cdf : mvcomp->hp_cdf, 2, ACCT_STR) : 1; -#else - hp = usehp ? aom_read(r, class0 ? mvcomp->class0_hp : mvcomp->hp, ACCT_STR) - : 1; -#endif -#if CONFIG_INTRABC || CONFIG_AMVR } else { fr = 3; hp = 1; } -#endif // CONFIG_INTRABC || CONFIG_AMVR // Result mag += ((d << 3) | (fr << 1) | hp) + 1; @@ -1411,29 +864,19 @@ static int read_mv_component(aom_reader *r, nmv_component *mvcomp, } static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref, - nmv_context *ctx, nmv_context_counts *counts, - MvSubpelPrecision precision) { - MV_JOINT_TYPE joint_type; - MV diff = { 0, 0 }; - joint_type = - (MV_JOINT_TYPE)aom_read_symbol(r, ctx->joint_cdf, MV_JOINTS, ACCT_STR); + nmv_context *ctx, MvSubpelPrecision precision) { + MV diff = kZeroMv; + const MV_JOINT_TYPE joint_type = + (MV_JOINT_TYPE)aom_read_symbol(r, ctx->joints_cdf, MV_JOINTS, ACCT_STR); if (mv_joint_vertical(joint_type)) - diff.row = read_mv_component(r, &ctx->comps[0], -#if CONFIG_INTRABC || CONFIG_AMVR - precision > MV_SUBPEL_NONE, -#endif // CONFIG_INTRABC || CONFIG_AMVR + diff.row = read_mv_component(r, &ctx->comps[0], precision > MV_SUBPEL_NONE, precision > MV_SUBPEL_LOW_PRECISION); if (mv_joint_horizontal(joint_type)) - diff.col = read_mv_component(r, &ctx->comps[1], -#if CONFIG_INTRABC || CONFIG_AMVR - precision > MV_SUBPEL_NONE, -#endif // CONFIG_INTRABC || CONFIG_AMVR + diff.col = read_mv_component(r, &ctx->comps[1], precision > MV_SUBPEL_NONE, precision > MV_SUBPEL_LOW_PRECISION); - av1_inc_mv(&diff, counts, precision); - mv->row = ref->row + diff.row; mv->col = ref->col + diff.col; } @@ -1441,138 +884,68 @@ static INLINE void read_mv(aom_reader *r, MV *mv, const MV *ref, static REFERENCE_MODE read_block_reference_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, aom_reader *r) { - if (!is_comp_ref_allowed(xd->mi[0]->mbmi.sb_type)) return SINGLE_REFERENCE; + if (!is_comp_ref_allowed(xd->mi[0]->sb_type)) return SINGLE_REFERENCE; if (cm->reference_mode == REFERENCE_MODE_SELECT) { - const int ctx = av1_get_reference_mode_context(cm, xd); -#if CONFIG_NEW_MULTISYMBOL + const int ctx = av1_get_reference_mode_context(xd); const REFERENCE_MODE mode = (REFERENCE_MODE)aom_read_symbol( r, xd->tile_ctx->comp_inter_cdf[ctx], 2, ACCT_STR); -#else - const REFERENCE_MODE mode = - (REFERENCE_MODE)aom_read(r, cm->fc->comp_inter_prob[ctx], ACCT_STR); -#endif - FRAME_COUNTS *counts = xd->counts; - if (counts) ++counts->comp_inter[ctx][mode]; return mode; // SINGLE_REFERENCE or COMPOUND_REFERENCE } else { + assert(cm->reference_mode == SINGLE_REFERENCE); return cm->reference_mode; } } -#if CONFIG_NEW_MULTISYMBOL #define READ_REF_BIT(pname) \ - aom_read_symbol(r, av1_get_pred_cdf_##pname(cm, xd), 2, ACCT_STR) -#define READ_REF_BIT2(pname) \ aom_read_symbol(r, av1_get_pred_cdf_##pname(xd), 2, ACCT_STR) -#else -#define READ_REF_BIT(pname) \ - aom_read(r, av1_get_pred_prob_##pname(cm, xd), ACCT_STR) -#define READ_REF_BIT2(pname) \ - aom_read(r, av1_get_pred_prob_##pname(cm, xd), ACCT_STR) -#endif -#if CONFIG_EXT_COMP_REFS -static COMP_REFERENCE_TYPE read_comp_reference_type(AV1_COMMON *cm, - const MACROBLOCKD *xd, +static COMP_REFERENCE_TYPE read_comp_reference_type(const MACROBLOCKD *xd, aom_reader *r) { const int ctx = av1_get_comp_reference_type_context(xd); -#if USE_UNI_COMP_REFS - COMP_REFERENCE_TYPE comp_ref_type; -#if CONFIG_VAR_REFS - if ((L_OR_L2(cm) || L3_OR_G(cm)) && BWD_OR_ALT(cm)) { - if (L_AND_L2(cm) || L_AND_L3(cm) || L_AND_G(cm) || BWD_AND_ALT(cm)) { -#endif // CONFIG_VAR_REFS -#if CONFIG_NEW_MULTISYMBOL - (void)cm; - comp_ref_type = (COMP_REFERENCE_TYPE)aom_read_symbol( + const COMP_REFERENCE_TYPE comp_ref_type = + (COMP_REFERENCE_TYPE)aom_read_symbol( r, xd->tile_ctx->comp_ref_type_cdf[ctx], 2, ACCT_STR); -#else - comp_ref_type = (COMP_REFERENCE_TYPE)aom_read( - r, cm->fc->comp_ref_type_prob[ctx], ACCT_STR); -#endif -#if CONFIG_VAR_REFS - } else { - comp_ref_type = BIDIR_COMP_REFERENCE; - } - } else { - comp_ref_type = UNIDIR_COMP_REFERENCE; - } -#endif // CONFIG_VAR_REFS -#else // !USE_UNI_COMP_REFS - // TODO(zoeliu): Temporarily turn off uni-directional comp refs - const COMP_REFERENCE_TYPE comp_ref_type = BIDIR_COMP_REFERENCE; -#endif // USE_UNI_COMP_REFS - FRAME_COUNTS *counts = xd->counts; - if (counts) ++counts->comp_ref_type[ctx][comp_ref_type]; return comp_ref_type; // UNIDIR_COMP_REFERENCE or BIDIR_COMP_REFERENCE } -#endif // CONFIG_EXT_COMP_REFS + +static void set_ref_frames_for_skip_mode(AV1_COMMON *const cm, + MV_REFERENCE_FRAME ref_frame[2]) { + ref_frame[0] = LAST_FRAME + cm->ref_frame_idx_0; + ref_frame[1] = LAST_FRAME + cm->ref_frame_idx_1; +} // Read the referncence frame static void read_ref_frames(AV1_COMMON *const cm, MACROBLOCKD *const xd, aom_reader *r, int segment_id, MV_REFERENCE_FRAME ref_frame[2]) { - FRAME_COUNTS *counts = xd->counts; + if (xd->mi[0]->skip_mode) { + set_ref_frames_for_skip_mode(cm, ref_frame); + return; + } if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) { ref_frame[0] = (MV_REFERENCE_FRAME)get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME); ref_frame[1] = NONE_FRAME; + } else if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP) || + segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) { + ref_frame[0] = LAST_FRAME; + ref_frame[1] = NONE_FRAME; } else { const REFERENCE_MODE mode = read_block_reference_mode(cm, xd, r); - // FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding - if (mode == COMPOUND_REFERENCE) { -#if CONFIG_EXT_COMP_REFS - const COMP_REFERENCE_TYPE comp_ref_type = - read_comp_reference_type(cm, xd, r); -#if !USE_UNI_COMP_REFS - // TODO(zoeliu): Temporarily turn off uni-directional comp refs - assert(comp_ref_type == BIDIR_COMP_REFERENCE); -#endif // !USE_UNI_COMP_REFS + if (mode == COMPOUND_REFERENCE) { + const COMP_REFERENCE_TYPE comp_ref_type = read_comp_reference_type(xd, r); if (comp_ref_type == UNIDIR_COMP_REFERENCE) { - const int ctx = av1_get_pred_context_uni_comp_ref_p(xd); - int bit; -#if CONFIG_VAR_REFS - if ((L_AND_L2(cm) || L_AND_L3(cm) || L_AND_G(cm)) && BWD_AND_ALT(cm)) -#endif // CONFIG_VAR_REFS - bit = READ_REF_BIT2(uni_comp_ref_p); -#if CONFIG_VAR_REFS - else - bit = BWD_AND_ALT(cm); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->uni_comp_ref[ctx][0][bit]; - + const int bit = READ_REF_BIT(uni_comp_ref_p); if (bit) { ref_frame[0] = BWDREF_FRAME; ref_frame[1] = ALTREF_FRAME; } else { - const int ctx1 = av1_get_pred_context_uni_comp_ref_p1(xd); - int bit1; -#if CONFIG_VAR_REFS - if (L_AND_L2(cm) && (L_AND_L3(cm) || L_AND_G(cm))) -#endif // CONFIG_VAR_REFS - bit1 = READ_REF_BIT2(uni_comp_ref_p1); -#if CONFIG_VAR_REFS - else - bit1 = L_AND_L3(cm) || L_AND_G(cm); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->uni_comp_ref[ctx1][1][bit1]; - + const int bit1 = READ_REF_BIT(uni_comp_ref_p1); if (bit1) { - const int ctx2 = av1_get_pred_context_uni_comp_ref_p2(xd); - int bit2; -#if CONFIG_VAR_REFS - if (L_AND_L3(cm) && L_AND_G(cm)) -#endif // CONFIG_VAR_REFS - bit2 = READ_REF_BIT2(uni_comp_ref_p2); -#if CONFIG_VAR_REFS - else - bit2 = L_AND_G(cm); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->uni_comp_ref[ctx2][2][bit2]; - + const int bit2 = READ_REF_BIT(uni_comp_ref_p2); if (bit2) { ref_frame[0] = LAST_FRAME; ref_frame[1] = GOLDEN_FRAME; @@ -1590,202 +963,46 @@ static void read_ref_frames(AV1_COMMON *const cm, MACROBLOCKD *const xd, } assert(comp_ref_type == BIDIR_COMP_REFERENCE); -#endif // CONFIG_EXT_COMP_REFS -// Normative in decoder (for low delay) -#if CONFIG_ONE_SIDED_COMPOUND || CONFIG_FRAME_SIGN_BIAS const int idx = 1; -#else // !(CONFIG_ONE_SIDED_COMPOUND || CONFIG_FRAME_SIGN_BIAS) -#if CONFIG_EXT_REFS - const int idx = cm->ref_frame_sign_bias[cm->comp_bwd_ref[0]]; -#else // !CONFIG_EXT_REFS - const int idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref]; -#endif // CONFIG_EXT_REFS -#endif // CONFIG_ONE_SIDED_COMPOUND || CONFIG_FRAME_SIGN_BIAS) - - const int ctx = av1_get_pred_context_comp_ref_p(cm, xd); -#if CONFIG_VAR_REFS - int bit; - // Test need to explicitly code (L,L2) vs (L3,G) branch node in tree - if (L_OR_L2(cm) && L3_OR_G(cm)) - bit = READ_REF_BIT(comp_ref_p); - else - bit = L3_OR_G(cm); -#else // !CONFIG_VAR_REFS const int bit = READ_REF_BIT(comp_ref_p); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->comp_ref[ctx][0][bit]; - -#if CONFIG_EXT_REFS // Decode forward references. if (!bit) { - const int ctx1 = av1_get_pred_context_comp_ref_p1(cm, xd); -#if CONFIG_VAR_REFS - int bit1; - // Test need to explicitly code (L) vs (L2) branch node in tree - if (L_AND_L2(cm)) - bit1 = READ_REF_BIT(comp_ref_p1); - else - bit1 = LAST_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit1 = READ_REF_BIT(comp_ref_p1); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->comp_ref[ctx1][1][bit1]; - ref_frame[!idx] = cm->comp_fwd_ref[bit1 ? 0 : 1]; + ref_frame[!idx] = cm->comp_fwd_ref[bit1 ? 1 : 0]; } else { - const int ctx2 = av1_get_pred_context_comp_ref_p2(cm, xd); -#if CONFIG_VAR_REFS - int bit2; - // Test need to explicitly code (L3) vs (G) branch node in tree - if (L3_AND_G(cm)) - bit2 = READ_REF_BIT(comp_ref_p2); - else - bit2 = GOLDEN_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit2 = READ_REF_BIT(comp_ref_p2); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->comp_ref[ctx2][2][bit2]; ref_frame[!idx] = cm->comp_fwd_ref[bit2 ? 3 : 2]; } // Decode backward references. - const int ctx_bwd = av1_get_pred_context_comp_bwdref_p(cm, xd); -#if CONFIG_VAR_REFS - int bit_bwd; - // Test need to explicitly code (BWD/ALT2) vs (ALT) branch node in tree - const int bit_bwd_uncertain = BWD_OR_ALT2(cm) && ALTREF_IS_VALID(cm); - if (bit_bwd_uncertain) - bit_bwd = READ_REF_BIT(comp_bwdref_p); - else - bit_bwd = ALTREF_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit_bwd = READ_REF_BIT(comp_bwdref_p); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->comp_bwdref[ctx_bwd][0][bit_bwd]; if (!bit_bwd) { - const int ctx1_bwd = av1_get_pred_context_comp_bwdref_p1(cm, xd); -#if CONFIG_VAR_REFS - int bit1_bwd; - if (BWD_AND_ALT2(cm)) - bit1_bwd = READ_REF_BIT(comp_bwdref_p1); - else - bit1_bwd = ALTREF2_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit1_bwd = READ_REF_BIT(comp_bwdref_p1); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->comp_bwdref[ctx1_bwd][1][bit1_bwd]; ref_frame[idx] = cm->comp_bwd_ref[bit1_bwd]; } else { ref_frame[idx] = cm->comp_bwd_ref[2]; } -#else // !CONFIG_EXT_REFS - ref_frame[!idx] = cm->comp_var_ref[bit]; - ref_frame[idx] = cm->comp_fixed_ref; -#endif // CONFIG_EXT_REFS } else if (mode == SINGLE_REFERENCE) { -#if CONFIG_EXT_REFS - const int ctx0 = av1_get_pred_context_single_ref_p1(xd); -#if CONFIG_VAR_REFS - int bit0; - // Test need to explicitly code (L,L2,L3,G) vs (BWD,ALT2,ALT) branch node - // in tree - if ((L_OR_L2(cm) || L3_OR_G(cm)) && - (BWD_OR_ALT2(cm) || ALTREF_IS_VALID(cm))) - bit0 = READ_REF_BIT(single_ref_p1); - else - bit0 = (BWD_OR_ALT2(cm) || ALTREF_IS_VALID(cm)); -#else // !CONFIG_VAR_REFS const int bit0 = READ_REF_BIT(single_ref_p1); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->single_ref[ctx0][0][bit0]; - if (bit0) { - const int ctx1 = av1_get_pred_context_single_ref_p2(xd); -#if CONFIG_VAR_REFS - int bit1; - // Test need to explicitly code (BWD/ALT2) vs (ALT) branch node in tree - const int bit1_uncertain = BWD_OR_ALT2(cm) && ALTREF_IS_VALID(cm); - if (bit1_uncertain) - bit1 = READ_REF_BIT(single_ref_p2); - else - bit1 = ALTREF_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit1 = READ_REF_BIT(single_ref_p2); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->single_ref[ctx1][1][bit1]; if (!bit1) { - const int ctx5 = av1_get_pred_context_single_ref_p6(xd); -#if CONFIG_VAR_REFS - int bit5; - if (BWD_AND_ALT2(cm)) - bit5 = READ_REF_BIT(single_ref_p6); - else - bit5 = ALTREF2_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit5 = READ_REF_BIT(single_ref_p6); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->single_ref[ctx5][5][bit5]; ref_frame[0] = bit5 ? ALTREF2_FRAME : BWDREF_FRAME; } else { ref_frame[0] = ALTREF_FRAME; } } else { - const int ctx2 = av1_get_pred_context_single_ref_p3(xd); -#if CONFIG_VAR_REFS - int bit2; - // Test need to explicitly code (L,L2) vs (L3,G) branch node in tree - if (L_OR_L2(cm) && L3_OR_G(cm)) - bit2 = READ_REF_BIT(single_ref_p3); - else - bit2 = L3_OR_G(cm); -#else // !CONFIG_VAR_REFS const int bit2 = READ_REF_BIT(single_ref_p3); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->single_ref[ctx2][2][bit2]; if (bit2) { - const int ctx4 = av1_get_pred_context_single_ref_p5(xd); -#if CONFIG_VAR_REFS - int bit4; - // Test need to explicitly code (L3) vs (G) branch node in tree - if (L3_AND_G(cm)) - bit4 = READ_REF_BIT(single_ref_p5); - else - bit4 = GOLDEN_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit4 = READ_REF_BIT(single_ref_p5); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->single_ref[ctx4][4][bit4]; ref_frame[0] = bit4 ? GOLDEN_FRAME : LAST3_FRAME; } else { - const int ctx3 = av1_get_pred_context_single_ref_p4(xd); -#if CONFIG_VAR_REFS - int bit3; - // Test need to explicitly code (L) vs (L2) branch node in tree - if (L_AND_L2(cm)) - bit3 = READ_REF_BIT(single_ref_p4); - else - bit3 = LAST2_IS_VALID(cm); -#else // !CONFIG_VAR_REFS const int bit3 = READ_REF_BIT(single_ref_p4); -#endif // CONFIG_VAR_REFS - if (counts) ++counts->single_ref[ctx3][3][bit3]; ref_frame[0] = bit3 ? LAST2_FRAME : LAST_FRAME; } } -#else // !CONFIG_EXT_REFS - const int ctx0 = av1_get_pred_context_single_ref_p1(xd); - const int bit0 = READ_REF_BIT(single_ref_p1); - if (counts) ++counts->single_ref[ctx0][0][bit0]; - - if (bit0) { - const int ctx1 = av1_get_pred_context_single_ref_p2(xd); - const int bit1 = READ_REF_BIT(single_ref_p2); - if (counts) ++counts->single_ref[ctx1][1][bit1]; - ref_frame[0] = bit1 ? ALTREF_FRAME : GOLDEN_FRAME; - } else { - ref_frame[0] = LAST_FRAME; - } -#endif // CONFIG_EXT_REFS ref_frame[1] = NONE_FRAME; } else { @@ -1798,7 +1015,6 @@ static INLINE void read_mb_interp_filter(AV1_COMMON *const cm, MACROBLOCKD *const xd, MB_MODE_INFO *const mbmi, aom_reader *r) { - FRAME_COUNTS *counts = xd->counts; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; if (!av1_is_interp_needed(xd)) { @@ -1809,120 +1025,68 @@ static INLINE void read_mb_interp_filter(AV1_COMMON *const cm, if (cm->interp_filter != SWITCHABLE) { mbmi->interp_filters = av1_broadcast_interp_filter(cm->interp_filter); } else { -#if CONFIG_DUAL_FILTER InterpFilter ref0_filter[2] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR }; for (int dir = 0; dir < 2; ++dir) { - if (has_subpel_mv_component(xd->mi[0], xd, dir) || - (mbmi->ref_frame[1] > INTRA_FRAME && - has_subpel_mv_component(xd->mi[0], xd, dir + 2))) { - const int ctx = av1_get_pred_context_switchable_interp(xd, dir); - ref0_filter[dir] = - (InterpFilter)aom_read_symbol(r, ec_ctx->switchable_interp_cdf[ctx], - SWITCHABLE_FILTERS, ACCT_STR); - if (counts) ++counts->switchable_interp[ctx][ref0_filter[dir]]; + const int ctx = av1_get_pred_context_switchable_interp(xd, dir); + ref0_filter[dir] = (InterpFilter)aom_read_symbol( + r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS, ACCT_STR); + if (cm->seq_params.enable_dual_filter == 0) { + ref0_filter[1] = ref0_filter[0]; + break; } } // The index system works as: (0, 1) -> (vertical, horizontal) filter types mbmi->interp_filters = av1_make_interp_filters(ref0_filter[0], ref0_filter[1]); -#else // CONFIG_DUAL_FILTER - const int ctx = av1_get_pred_context_switchable_interp(xd); - InterpFilter filter = (InterpFilter)aom_read_symbol( - r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS, ACCT_STR); - mbmi->interp_filters = av1_broadcast_interp_filter(filter); - if (counts) ++counts->switchable_interp[ctx][filter]; -#endif // CONFIG_DUAL_FILTER } } static void read_intra_block_mode_info(AV1_COMMON *const cm, const int mi_row, const int mi_col, MACROBLOCKD *const xd, - MODE_INFO *mi, aom_reader *r) { - MB_MODE_INFO *const mbmi = &mi->mbmi; - const BLOCK_SIZE bsize = mi->mbmi.sb_type; - int i; + MB_MODE_INFO *const mbmi, + aom_reader *r) { + const BLOCK_SIZE bsize = mbmi->sb_type; + const int use_angle_delta = av1_use_angle_delta(bsize); mbmi->ref_frame[0] = INTRA_FRAME; mbmi->ref_frame[1] = NONE_FRAME; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; -#if CONFIG_CB4X4 - (void)i; mbmi->mode = read_intra_mode(r, ec_ctx->y_mode_cdf[size_group_lookup[bsize]]); -#else - switch (bsize) { - case BLOCK_4X4: - for (i = 0; i < 4; ++i) - mi->bmi[i].as_mode = read_intra_mode(r, ec_ctx->y_mode_cdf[0]); - mbmi->mode = mi->bmi[3].as_mode; - break; - case BLOCK_4X8: - mi->bmi[0].as_mode = mi->bmi[2].as_mode = - read_intra_mode(r, ec_ctx->y_mode_cdf[0]); - mi->bmi[1].as_mode = mi->bmi[3].as_mode = mbmi->mode = - read_intra_mode(r, ec_ctx->y_mode_cdf[0]); - break; - case BLOCK_8X4: - mi->bmi[0].as_mode = mi->bmi[1].as_mode = - read_intra_mode(r, ec_ctx->y_mode_cdf[0]); - mi->bmi[2].as_mode = mi->bmi[3].as_mode = mbmi->mode = - read_intra_mode(r, ec_ctx->y_mode_cdf[0]); - break; - default: - mbmi->mode = - read_intra_mode(r, ec_ctx->y_mode_cdf[size_group_lookup[bsize]]); - } -#endif -#if CONFIG_CB4X4 - if (is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y)) { - mbmi->uv_mode = read_intra_mode_uv(ec_ctx, r, mbmi->mode); -#else - mbmi->uv_mode = read_intra_mode_uv(ec_ctx, r, mbmi->mode); - (void)mi_row; - (void)mi_col; -#endif - -#if CONFIG_CFL + mbmi->angle_delta[PLANE_TYPE_Y] = + use_angle_delta && av1_is_directional_mode(mbmi->mode) + ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED]) + : 0; + const int has_chroma = + is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, + xd->plane[1].subsampling_y); + xd->cfl.is_chroma_reference = has_chroma; + if (!cm->seq_params.monochrome && has_chroma) { + mbmi->uv_mode = + read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode); if (mbmi->uv_mode == UV_CFL_PRED) { mbmi->cfl_alpha_idx = read_cfl_alphas(xd->tile_ctx, r, &mbmi->cfl_alpha_signs); - xd->cfl->store_y = 1; - } else { - xd->cfl->store_y = 0; } -#endif // CONFIG_CFL - -#if CONFIG_CB4X4 + mbmi->angle_delta[PLANE_TYPE_UV] = + use_angle_delta && av1_is_directional_mode(get_uv_mode(mbmi->uv_mode)) + ? read_angle_delta(r, + ec_ctx->angle_delta_cdf[mbmi->uv_mode - V_PRED]) + : 0; } else { // Avoid decoding angle_info if there is is no chroma prediction mbmi->uv_mode = UV_DC_PRED; -#if CONFIG_CFL - xd->cfl->is_chroma_reference = 0; - xd->cfl->store_y = 1; -#endif } -#endif - - // Explicitly ignore cm here to avoid a compile warning if none of - // ext-intra, palette and filter-intra are enabled. - (void)cm; + xd->cfl.store_y = store_cfl_required(cm, xd); -#if CONFIG_EXT_INTRA - read_intra_angle_info(cm, xd, r); -#endif // CONFIG_EXT_INTRA mbmi->palette_mode_info.palette_size[0] = 0; mbmi->palette_mode_info.palette_size[1] = 0; if (av1_allow_palette(cm->allow_screen_content_tools, bsize)) - read_palette_mode_info(cm, xd, r); -#if CONFIG_FILTER_INTRA - mbmi->filter_intra_mode_info.use_filter_intra_mode[0] = 0; - mbmi->filter_intra_mode_info.use_filter_intra_mode[1] = 0; - if (bsize >= BLOCK_8X8 || CONFIG_CB4X4) - read_filter_intra_mode_info(cm, xd, mi_row, mi_col, r); -#endif // CONFIG_FILTER_INTRA + read_palette_mode_info(cm, xd, mi_row, mi_col, r); + + read_filter_intra_mode_info(cm, xd, r); } static INLINE int is_mv_valid(const MV *mv) { @@ -1932,188 +1096,43 @@ static INLINE int is_mv_valid(const MV *mv) { static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd, PREDICTION_MODE mode, - MV_REFERENCE_FRAME ref_frame[2], int block, - int_mv mv[2], int_mv ref_mv[2], - int_mv nearest_mv[2], int_mv near_mv[2], int mi_row, - int mi_col, int is_compound, int allow_hp, - aom_reader *r) { - int i; - int ret = 1; + MV_REFERENCE_FRAME ref_frame[2], int_mv mv[2], + int_mv ref_mv[2], int_mv nearest_mv[2], + int_mv near_mv[2], int mi_row, int mi_col, + int is_compound, int allow_hp, aom_reader *r) { FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type; - MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; -#if CONFIG_CB4X4 - int_mv *pred_mv = mbmi->pred_mv; - (void)block; -#else - int_mv *pred_mv = - (bsize >= BLOCK_8X8) ? mbmi->pred_mv : xd->mi[0]->bmi[block].pred_mv; -#endif // CONFIG_CB4X4 - (void)ref_frame; - (void)cm; - (void)mi_row; - (void)mi_col; - (void)bsize; -#if CONFIG_AMVR - if (cm->cur_frame_mv_precision_level) { + MB_MODE_INFO *mbmi = xd->mi[0]; + BLOCK_SIZE bsize = mbmi->sb_type; + if (cm->cur_frame_force_integer_mv) { allow_hp = MV_SUBPEL_NONE; } -#endif switch (mode) { case NEWMV: { - FRAME_COUNTS *counts = xd->counts; - for (i = 0; i < 1 + is_compound; ++i) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = - av1_nmv_ctx(xd->ref_mv_count[rf_type], xd->ref_mv_stack[rf_type], i, - mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, nmvc, mv_counts, allow_hp); - ret = ret && is_mv_valid(&mv[i].as_mv); - - pred_mv[i].as_int = ref_mv[i].as_int; - } + nmv_context *const nmvc = &ec_ctx->nmvc; + read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp); break; } case NEARESTMV: { mv[0].as_int = nearest_mv[0].as_int; - if (is_compound) mv[1].as_int = nearest_mv[1].as_int; - - pred_mv[0].as_int = nearest_mv[0].as_int; - if (is_compound) pred_mv[1].as_int = nearest_mv[1].as_int; break; } case NEARMV: { mv[0].as_int = near_mv[0].as_int; - if (is_compound) mv[1].as_int = near_mv[1].as_int; - - pred_mv[0].as_int = near_mv[0].as_int; - if (is_compound) pred_mv[1].as_int = near_mv[1].as_int; - break; - } - case ZEROMV: { -#if CONFIG_GLOBAL_MOTION - mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]], - cm->allow_high_precision_mv, bsize, - mi_col, mi_row, block -#if CONFIG_AMVR - , - cm->cur_frame_mv_precision_level -#endif - ) - .as_int; - if (is_compound) - mv[1].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[1]], - cm->allow_high_precision_mv, bsize, - mi_col, mi_row, block -#if CONFIG_AMVR - , - cm->cur_frame_mv_precision_level -#endif - ) - .as_int; -#else - mv[0].as_int = 0; - if (is_compound) mv[1].as_int = 0; -#endif // CONFIG_GLOBAL_MOTION - - pred_mv[0].as_int = mv[0].as_int; - if (is_compound) pred_mv[1].as_int = mv[1].as_int; - break; - } -#if CONFIG_COMPOUND_SINGLEREF - case SR_NEAREST_NEARMV: { - assert(!is_compound); - mv[0].as_int = nearest_mv[0].as_int; - mv[1].as_int = near_mv[0].as_int; - break; - } - /* - case SR_NEAREST_NEWMV: { - assert(!is_compound); - mv[0].as_int = nearest_mv[0].as_int; - - FRAME_COUNTS *counts = xd->counts; - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type], - xd->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[1].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp); - ret = ret && is_mv_valid(&mv[1].as_mv); - break; - }*/ - case SR_NEAR_NEWMV: { - assert(!is_compound); - mv[0].as_int = near_mv[0].as_int; - - FRAME_COUNTS *counts = xd->counts; - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type], - xd->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[1].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp); - ret = ret && is_mv_valid(&mv[1].as_mv); - break; - } - case SR_ZERO_NEWMV: { - assert(!is_compound); -#if CONFIG_GLOBAL_MOTION - mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]], - cm->allow_high_precision_mv, bsize, - mi_col, mi_row, block) - .as_int; -#else - mv[0].as_int = 0; -#endif // CONFIG_GLOBAL_MOTION - - FRAME_COUNTS *counts = xd->counts; - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type], - xd->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[1].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp); - ret = ret && is_mv_valid(&mv[1].as_mv); break; } - case SR_NEW_NEWMV: { - assert(!is_compound); - - FRAME_COUNTS *counts = xd->counts; - for (i = 0; i < 2; ++i) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = - av1_nmv_ctx(xd->ref_mv_count[rf_type], xd->ref_mv_stack[rf_type], 0, - mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[i].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp); - ret = ret && is_mv_valid(&mv[i].as_mv); - } + case GLOBALMV: { + mv[0].as_int = + gm_get_motion_vector(&cm->global_motion[ref_frame[0]], + cm->allow_high_precision_mv, bsize, mi_col, + mi_row, cm->cur_frame_force_integer_mv) + .as_int; break; } -#endif // CONFIG_COMPOUND_SINGLEREF case NEW_NEWMV: { - FRAME_COUNTS *counts = xd->counts; assert(is_compound); - for (i = 0; i < 2; ++i) { - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = - av1_nmv_ctx(xd->ref_mv_count[rf_type], xd->ref_mv_stack[rf_type], i, - mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, nmvc, mv_counts, allow_hp); - ret = ret && is_mv_valid(&mv[i].as_mv); + for (int i = 0; i < 2; ++i) { + nmv_context *const nmvc = &ec_ctx->nmvc; + read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, nmvc, allow_hp); } break; } @@ -2130,984 +1149,440 @@ static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd, break; } case NEW_NEARESTMV: { - FRAME_COUNTS *counts = xd->counts; - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type], - xd->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp); + nmv_context *const nmvc = &ec_ctx->nmvc; + read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp); assert(is_compound); - ret = ret && is_mv_valid(&mv[0].as_mv); mv[1].as_int = nearest_mv[1].as_int; break; } case NEAREST_NEWMV: { - FRAME_COUNTS *counts = xd->counts; - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type], - xd->ref_mv_stack[rf_type], 1, mbmi->ref_mv_idx); - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; + nmv_context *const nmvc = &ec_ctx->nmvc; mv[0].as_int = nearest_mv[0].as_int; - read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, mv_counts, allow_hp); + read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, allow_hp); assert(is_compound); - ret = ret && is_mv_valid(&mv[1].as_mv); break; } case NEAR_NEWMV: { - FRAME_COUNTS *counts = xd->counts; - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type], - xd->ref_mv_stack[rf_type], 1, mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; + nmv_context *const nmvc = &ec_ctx->nmvc; mv[0].as_int = near_mv[0].as_int; - read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, mv_counts, allow_hp); + read_mv(r, &mv[1].as_mv, &ref_mv[1].as_mv, nmvc, allow_hp); assert(is_compound); - - ret = ret && is_mv_valid(&mv[1].as_mv); break; } case NEW_NEARMV: { - FRAME_COUNTS *counts = xd->counts; - int8_t rf_type = av1_ref_frame_type(mbmi->ref_frame); - int nmv_ctx = av1_nmv_ctx(xd->ref_mv_count[rf_type], - xd->ref_mv_stack[rf_type], 0, mbmi->ref_mv_idx); - nmv_context *const nmvc = &ec_ctx->nmvc[nmv_ctx]; - nmv_context_counts *const mv_counts = - counts ? &counts->mv[nmv_ctx] : NULL; - read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, mv_counts, allow_hp); + nmv_context *const nmvc = &ec_ctx->nmvc; + read_mv(r, &mv[0].as_mv, &ref_mv[0].as_mv, nmvc, allow_hp); assert(is_compound); - ret = ret && is_mv_valid(&mv[0].as_mv); mv[1].as_int = near_mv[1].as_int; break; } - case ZERO_ZEROMV: { + case GLOBAL_GLOBALMV: { assert(is_compound); -#if CONFIG_GLOBAL_MOTION - mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]], - cm->allow_high_precision_mv, bsize, - mi_col, mi_row, block -#if CONFIG_AMVR - , - cm->cur_frame_mv_precision_level -#endif - ) - .as_int; - mv[1].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[1]], - cm->allow_high_precision_mv, bsize, - mi_col, mi_row, block -#if CONFIG_AMVR - , - cm->cur_frame_mv_precision_level -#endif - ) - .as_int; -#else - mv[0].as_int = 0; - mv[1].as_int = 0; -#endif // CONFIG_GLOBAL_MOTION + mv[0].as_int = + gm_get_motion_vector(&cm->global_motion[ref_frame[0]], + cm->allow_high_precision_mv, bsize, mi_col, + mi_row, cm->cur_frame_force_integer_mv) + .as_int; + mv[1].as_int = + gm_get_motion_vector(&cm->global_motion[ref_frame[1]], + cm->allow_high_precision_mv, bsize, mi_col, + mi_row, cm->cur_frame_force_integer_mv) + .as_int; break; } default: { return 0; } } + + int ret = is_mv_valid(&mv[0].as_mv); + if (is_compound) { + ret = ret && is_mv_valid(&mv[1].as_mv); + } return ret; } static int read_is_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd, int segment_id, aom_reader *r) { if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) { - return get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME) != INTRA_FRAME; - } else { - const int ctx = av1_get_intra_inter_context(xd); -#if CONFIG_NEW_MULTISYMBOL - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - const int is_inter = - aom_read_symbol(r, ec_ctx->intra_inter_cdf[ctx], 2, ACCT_STR); -#else - const int is_inter = aom_read(r, cm->fc->intra_inter_prob[ctx], ACCT_STR); -#endif - FRAME_COUNTS *counts = xd->counts; - if (counts) ++counts->intra_inter[ctx][is_inter]; - return is_inter; + const int frame = get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME); + if (frame < LAST_FRAME) return 0; + return frame != INTRA_FRAME; } -} - -#if CONFIG_COMPOUND_SINGLEREF -static int read_is_inter_singleref_comp_mode(AV1_COMMON *const cm, - MACROBLOCKD *const xd, - int segment_id, aom_reader *r) { - if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) return 0; - - const int ctx = av1_get_inter_mode_context(xd); - const int is_singleref_comp_mode = - aom_read(r, cm->fc->comp_inter_mode_prob[ctx], ACCT_STR); - FRAME_COUNTS *counts = xd->counts; - - if (counts) ++counts->comp_inter_mode[ctx][is_singleref_comp_mode]; - return is_singleref_comp_mode; -} -#endif // CONFIG_COMPOUND_SINGLEREF - -static void fpm_sync(void *const data, int mi_row) { - AV1Decoder *const pbi = (AV1Decoder *)data; - av1_frameworker_wait(pbi->frame_worker_owner, pbi->common.prev_frame, - mi_row << pbi->common.mib_size_log2); + if (segfeature_active(&cm->seg, segment_id, SEG_LVL_GLOBALMV)) { + return 1; + } + const int ctx = av1_get_intra_inter_context(xd); + FRAME_CONTEXT *ec_ctx = xd->tile_ctx; + const int is_inter = + aom_read_symbol(r, ec_ctx->intra_inter_cdf[ctx], 2, ACCT_STR); + return is_inter; } #if DEC_MISMATCH_DEBUG -static void dec_dump_logs(AV1_COMMON *cm, MODE_INFO *const mi, int mi_row, - int mi_col, - int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES], - int16_t mode_ctx) { +static void dec_dump_logs(AV1_COMMON *cm, MB_MODE_INFO *const mbmi, int mi_row, + int mi_col, int16_t mode_ctx) { int_mv mv[2] = { { 0 } }; - int ref; - MB_MODE_INFO *const mbmi = &mi->mbmi; - for (ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) + for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) mv[ref].as_mv = mbmi->mv[ref].as_mv; const int16_t newmv_ctx = mode_ctx & NEWMV_CTX_MASK; int16_t zeromv_ctx = -1; int16_t refmv_ctx = -1; if (mbmi->mode != NEWMV) { - if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET)) assert(mbmi->mode == ZEROMV); - zeromv_ctx = (mode_ctx >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK; - if (mbmi->mode != ZEROMV) { + zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK; + if (mbmi->mode != GLOBALMV) refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK; - if (mode_ctx & (1 << SKIP_NEARESTMV_OFFSET)) refmv_ctx = 6; - if (mode_ctx & (1 << SKIP_NEARMV_OFFSET)) refmv_ctx = 7; - if (mode_ctx & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) refmv_ctx = 8; - } } - int8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); -#define FRAME_TO_CHECK 1 +#define FRAME_TO_CHECK 11 if (cm->current_video_frame == FRAME_TO_CHECK && cm->show_frame == 1) { printf( "=== DECODER ===: " - "Frame=%d, (mi_row,mi_col)=(%d,%d), mode=%d, bsize=%d, " + "Frame=%d, (mi_row,mi_col)=(%d,%d), skip_mode=%d, mode=%d, bsize=%d, " "show_frame=%d, mv[0]=(%d,%d), mv[1]=(%d,%d), ref[0]=%d, " - "ref[1]=%d, motion_mode=%d, inter_mode_ctx=%d, mode_ctx=%d, " - "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d\n", - cm->current_video_frame, mi_row, mi_col, mbmi->mode, mbmi->sb_type, - cm->show_frame, mv[0].as_mv.row, mv[0].as_mv.col, mv[1].as_mv.row, - mv[1].as_mv.col, mbmi->ref_frame[0], mbmi->ref_frame[1], - mbmi->motion_mode, inter_mode_ctx[ref_frame_type], mode_ctx, newmv_ctx, - zeromv_ctx, refmv_ctx); + "ref[1]=%d, motion_mode=%d, mode_ctx=%d, " + "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d, tx_size=%d\n", + cm->current_video_frame, mi_row, mi_col, mbmi->skip_mode, mbmi->mode, + mbmi->sb_type, cm->show_frame, mv[0].as_mv.row, mv[0].as_mv.col, + mv[1].as_mv.row, mv[1].as_mv.col, mbmi->ref_frame[0], + mbmi->ref_frame[1], mbmi->motion_mode, mode_ctx, newmv_ctx, zeromv_ctx, + refmv_ctx, mbmi->tx_size); } } #endif // DEC_MISMATCH_DEBUG static void read_inter_block_mode_info(AV1Decoder *const pbi, MACROBLOCKD *const xd, - MODE_INFO *const mi, -#if CONFIG_SUPERTX - int mi_row, int mi_col, aom_reader *r, - int supertx_enabled) { -#else - int mi_row, int mi_col, aom_reader *r) { -#endif // CONFIG_MOTION_VAR && CONFIG_SUPERTX + MB_MODE_INFO *const mbmi, int mi_row, + int mi_col, aom_reader *r) { AV1_COMMON *const cm = &pbi->common; - MB_MODE_INFO *const mbmi = &mi->mbmi; const BLOCK_SIZE bsize = mbmi->sb_type; const int allow_hp = cm->allow_high_precision_mv; - const int unify_bsize = CONFIG_CB4X4; int_mv nearestmv[2], nearmv[2]; - int_mv ref_mvs[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES]; - int ref, is_compound; -#if CONFIG_COMPOUND_SINGLEREF - int is_singleref_comp_mode = 0; -#endif // CONFIG_COMPOUND_SINGLEREF + int_mv ref_mvs[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES] = { { { 0 } } }; int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES]; - int16_t compound_inter_mode_ctx[MODE_CTX_REF_FRAMES]; - int16_t mode_ctx = 0; -#if CONFIG_WARPED_MOTION int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE]; -#if WARPED_MOTION_SORT_SAMPLES - int pts_mv[SAMPLES_ARRAY_SIZE]; -#endif // WARPED_MOTION_SORT_SAMPLES -#endif // CONFIG_WARPED_MOTION FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - assert(NELEMENTS(mode_2_counter) == MB_MODE_COUNT); - mbmi->uv_mode = UV_DC_PRED; mbmi->palette_mode_info.palette_size[0] = 0; mbmi->palette_mode_info.palette_size[1] = 0; - memset(ref_mvs, 0, sizeof(ref_mvs)); + av1_collect_neighbors_ref_counts(xd); read_ref_frames(cm, xd, r, mbmi->segment_id, mbmi->ref_frame); - is_compound = has_second_ref(mbmi); - -#if CONFIG_EXT_COMP_REFS -#if !USE_UNI_COMP_REFS - // NOTE: uni-directional comp refs disabled - if (is_compound) - assert(mbmi->ref_frame[0] < BWDREF_FRAME && - mbmi->ref_frame[1] >= BWDREF_FRAME); -#endif // !USE_UNI_COMP_REFS -#endif // CONFIG_EXT_COMP_REFS - -#if CONFIG_COMPOUND_SINGLEREF - if (!is_compound) - is_singleref_comp_mode = - read_is_inter_singleref_comp_mode(cm, xd, mbmi->segment_id, r); -#endif // CONFIG_COMPOUND_SINGLEREF - - for (ref = 0; ref < 1 + is_compound; ++ref) { - MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref]; - - av1_find_mv_refs(cm, xd, mi, frame, &xd->ref_mv_count[frame], - xd->ref_mv_stack[frame], compound_inter_mode_ctx, - ref_mvs[frame], mi_row, mi_col, fpm_sync, (void *)pbi, - inter_mode_ctx); - } + const int is_compound = has_second_ref(mbmi); - if (is_compound) { - MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame); - av1_find_mv_refs(cm, xd, mi, ref_frame, &xd->ref_mv_count[ref_frame], - xd->ref_mv_stack[ref_frame], compound_inter_mode_ctx, - ref_mvs[ref_frame], mi_row, mi_col, fpm_sync, (void *)pbi, - inter_mode_ctx); + MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame); + int_mv global_mvs[REF_FRAMES]; + av1_find_mv_refs(cm, xd, mbmi, ref_frame, xd->ref_mv_count, xd->ref_mv_stack, + ref_mvs, global_mvs, mi_row, mi_col, inter_mode_ctx); - if (xd->ref_mv_count[ref_frame] < 2) { - MV_REFERENCE_FRAME rf[2]; - int_mv zeromv[2]; - av1_set_ref_frame(rf, ref_frame); -#if CONFIG_GLOBAL_MOTION - zeromv[0].as_int = gm_get_motion_vector(&cm->global_motion[rf[0]], - cm->allow_high_precision_mv, - bsize, mi_col, mi_row, 0 -#if CONFIG_AMVR - , - cm->cur_frame_mv_precision_level -#endif - ) - .as_int; - zeromv[1].as_int = - (rf[1] != NONE_FRAME) - ? gm_get_motion_vector(&cm->global_motion[rf[1]], - cm->allow_high_precision_mv, bsize, mi_col, - mi_row, 0 -#if CONFIG_AMVR - , - cm->cur_frame_mv_precision_level -#endif - ) - .as_int - : 0; -#else - zeromv[0].as_int = zeromv[1].as_int = 0; -#endif - for (ref = 0; ref < 2; ++ref) { - if (rf[ref] == NONE_FRAME) continue; -#if CONFIG_AMVR - lower_mv_precision(&ref_mvs[rf[ref]][0].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); - lower_mv_precision(&ref_mvs[rf[ref]][1].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); -#else - lower_mv_precision(&ref_mvs[rf[ref]][0].as_mv, allow_hp); - lower_mv_precision(&ref_mvs[rf[ref]][1].as_mv, allow_hp); -#endif - if (ref_mvs[rf[ref]][0].as_int != zeromv[ref].as_int || - ref_mvs[rf[ref]][1].as_int != zeromv[ref].as_int) - inter_mode_ctx[ref_frame] &= ~(1 << ALL_ZERO_FLAG_OFFSET); - } - } - } - -#if CONFIG_COMPOUND_SINGLEREF - if (is_compound || is_singleref_comp_mode) -#else // !CONFIG_COMPOUND_SINGLEREF - if (is_compound) -#endif // CONFIG_COMPOUND_SINGLEREF - mode_ctx = compound_inter_mode_ctx[mbmi->ref_frame[0]]; - else - mode_ctx = - av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame, bsize, -1); + int mode_ctx = av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame); mbmi->ref_mv_idx = 0; -#if CONFIG_SEGMENT_ZEROMV - if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP) || - segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_ZEROMV)) { -#else - if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { -#endif - mbmi->mode = ZEROMV; - if (bsize < BLOCK_8X8 && !unify_bsize) { - aom_internal_error(xd->error_info, AOM_CODEC_UNSUP_BITSTREAM, - "Invalid usage of segment feature on small blocks"); - return; - } + if (mbmi->skip_mode) { + assert(is_compound); + mbmi->mode = NEAREST_NEARESTMV; } else { - if (bsize >= BLOCK_8X8 || unify_bsize) { + if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP) || + segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_GLOBALMV)) { + mbmi->mode = GLOBALMV; + } else { if (is_compound) - mbmi->mode = read_inter_compound_mode(cm, xd, r, mode_ctx); -#if CONFIG_COMPOUND_SINGLEREF - else if (is_singleref_comp_mode) - mbmi->mode = read_inter_singleref_comp_mode(xd, r, mode_ctx); -#endif // CONFIG_COMPOUND_SINGLEREF + mbmi->mode = read_inter_compound_mode(xd, r, mode_ctx); else - mbmi->mode = read_inter_mode(ec_ctx, xd, r, mode_ctx); + mbmi->mode = read_inter_mode(ec_ctx, r, mode_ctx); if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV || -#if CONFIG_COMPOUND_SINGLEREF - mbmi->mode == SR_NEW_NEWMV || -#endif // CONFIG_COMPOUND_SINGLEREF have_nearmv_in_inter_mode(mbmi->mode)) read_drl_idx(ec_ctx, xd, mbmi, r); } } - if ((bsize < BLOCK_8X8 && !unify_bsize) || - (mbmi->mode != ZEROMV && mbmi->mode != ZERO_ZEROMV)) { - for (ref = 0; ref < 1 + is_compound; ++ref) { -#if CONFIG_AMVR - av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[ref]], - &nearestmv[ref], &nearmv[ref], - cm->cur_frame_mv_precision_level); -#else - av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[ref]], - &nearestmv[ref], &nearmv[ref]); -#endif - } + if (is_compound != is_inter_compound_mode(mbmi->mode)) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Prediction mode %d invalid with ref frame %d %d", + mbmi->mode, mbmi->ref_frame[0], mbmi->ref_frame[1]); } -#if CONFIG_COMPOUND_SINGLEREF - if ((is_compound || is_singleref_comp_mode) && - (bsize >= BLOCK_8X8 || unify_bsize) && mbmi->mode != ZERO_ZEROMV) -#else // !CONFIG_COMPOUND_SINGLEREF - if (is_compound && (bsize >= BLOCK_8X8 || unify_bsize) && - mbmi->mode != ZERO_ZEROMV) -#endif // CONFIG_COMPOUND_SINGLEREF - { - uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); - - if (xd->ref_mv_count[ref_frame_type] > 0) { - if (mbmi->mode == NEAREST_NEARESTMV) { - nearestmv[0] = xd->ref_mv_stack[ref_frame_type][0].this_mv; - nearestmv[1] = xd->ref_mv_stack[ref_frame_type][0].comp_mv; -#if CONFIG_AMVR - lower_mv_precision(&nearestmv[0].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); - lower_mv_precision(&nearestmv[1].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); -#else - lower_mv_precision(&nearestmv[0].as_mv, allow_hp); - lower_mv_precision(&nearestmv[1].as_mv, allow_hp); -#endif - } else if (mbmi->mode == NEAREST_NEWMV -#if CONFIG_COMPOUND_SINGLEREF - || mbmi->mode == SR_NEAREST_NEARMV -// || mbmi->mode == SR_NEAREST_NEWMV -#endif // CONFIG_COMPOUND_SINGLEREF - ) { - nearestmv[0] = xd->ref_mv_stack[ref_frame_type][0].this_mv; - -#if CONFIG_AMVR - lower_mv_precision(&nearestmv[0].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); -#else - lower_mv_precision(&nearestmv[0].as_mv, allow_hp); -#endif - } else if (mbmi->mode == NEW_NEARESTMV) { - nearestmv[1] = xd->ref_mv_stack[ref_frame_type][0].comp_mv; -#if CONFIG_AMVR - lower_mv_precision(&nearestmv[1].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); -#else - lower_mv_precision(&nearestmv[1].as_mv, allow_hp); -#endif - } - } - - if (xd->ref_mv_count[ref_frame_type] > 1) { - int ref_mv_idx = 1 + mbmi->ref_mv_idx; -#if CONFIG_COMPOUND_SINGLEREF - if (is_compound) { -#endif // CONFIG_COMPOUND_SINGLEREF - if (compound_ref0_mode(mbmi->mode) == NEARMV) { - nearmv[0] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv; -#if CONFIG_AMVR - lower_mv_precision(&nearmv[0].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); -#else - lower_mv_precision(&nearmv[0].as_mv, allow_hp); -#endif - } + if (!is_compound && mbmi->mode != GLOBALMV) { + av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[0]], &nearestmv[0], + &nearmv[0], cm->cur_frame_force_integer_mv); + } - if (compound_ref1_mode(mbmi->mode) == NEARMV) { - nearmv[1] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].comp_mv; -#if CONFIG_AMVR - lower_mv_precision(&nearmv[1].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); -#else - lower_mv_precision(&nearmv[1].as_mv, allow_hp); -#endif - } -#if CONFIG_COMPOUND_SINGLEREF - } else { - assert(is_singleref_comp_mode); - if (compound_ref0_mode(mbmi->mode) == NEARMV || - compound_ref1_mode(mbmi->mode) == NEARMV) { - nearmv[0] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv; - lower_mv_precision(&nearmv[0].as_mv, allow_hp); - } - } -#endif // CONFIG_COMPOUND_SINGLEREF - } + if (is_compound && mbmi->mode != GLOBAL_GLOBALMV) { + int ref_mv_idx = mbmi->ref_mv_idx + 1; + nearestmv[0] = xd->ref_mv_stack[ref_frame][0].this_mv; + nearestmv[1] = xd->ref_mv_stack[ref_frame][0].comp_mv; + nearmv[0] = xd->ref_mv_stack[ref_frame][ref_mv_idx].this_mv; + nearmv[1] = xd->ref_mv_stack[ref_frame][ref_mv_idx].comp_mv; + lower_mv_precision(&nearestmv[0].as_mv, allow_hp, + cm->cur_frame_force_integer_mv); + lower_mv_precision(&nearestmv[1].as_mv, allow_hp, + cm->cur_frame_force_integer_mv); + lower_mv_precision(&nearmv[0].as_mv, allow_hp, + cm->cur_frame_force_integer_mv); + lower_mv_precision(&nearmv[1].as_mv, allow_hp, + cm->cur_frame_force_integer_mv); } else if (mbmi->ref_mv_idx > 0 && mbmi->mode == NEARMV) { int_mv cur_mv = xd->ref_mv_stack[mbmi->ref_frame[0]][1 + mbmi->ref_mv_idx].this_mv; nearmv[0] = cur_mv; } -#if !CONFIG_DUAL_FILTER && !CONFIG_WARPED_MOTION && !CONFIG_GLOBAL_MOTION - read_mb_interp_filter(cm, xd, mbmi, r); -#endif // !CONFIG_DUAL_FILTER && !CONFIG_WARPED_MOTION - - if (bsize < BLOCK_8X8 && !unify_bsize) { - const int num_4x4_w = 1 << xd->bmode_blocks_wl; - const int num_4x4_h = 1 << xd->bmode_blocks_hl; - int idx, idy; - PREDICTION_MODE b_mode; - int_mv nearest_sub8x8[2], near_sub8x8[2]; - int_mv ref_mv[2][2]; - for (idy = 0; idy < 2; idy += num_4x4_h) { - for (idx = 0; idx < 2; idx += num_4x4_w) { - int_mv block[2]; - const int j = idy * 2 + idx; - int_mv ref_mv_s8[2]; - if (!is_compound) - mode_ctx = av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame, - bsize, j); - if (is_compound) - b_mode = read_inter_compound_mode(cm, xd, r, mode_ctx); - else - b_mode = read_inter_mode(ec_ctx, xd, r, mode_ctx); - - if (b_mode != ZEROMV && b_mode != ZERO_ZEROMV) { - CANDIDATE_MV ref_mv_stack[2][MAX_REF_MV_STACK_SIZE]; - uint8_t ref_mv_count[2]; - for (ref = 0; ref < 1 + is_compound; ++ref) { - int_mv mv_ref_list[MAX_MV_REF_CANDIDATES]; - av1_update_mv_context(cm, xd, mi, mbmi->ref_frame[ref], mv_ref_list, - j, mi_row, mi_col, NULL); - av1_append_sub8x8_mvs_for_idx(cm, xd, j, ref, mi_row, mi_col, - ref_mv_stack[ref], &ref_mv_count[ref], - mv_ref_list, &nearest_sub8x8[ref], - &near_sub8x8[ref]); - if (have_newmv_in_inter_mode(b_mode)) { - mv_ref_list[0].as_int = nearest_sub8x8[ref].as_int; - mv_ref_list[1].as_int = near_sub8x8[ref].as_int; -#if CONFIG_AMVR - av1_find_best_ref_mvs(allow_hp, mv_ref_list, &ref_mv[0][ref], - &ref_mv[1][ref], - cm->cur_frame_mv_precision_level); -#else - av1_find_best_ref_mvs(allow_hp, mv_ref_list, &ref_mv[0][ref], - &ref_mv[1][ref]); -#endif - } - } - } - - for (ref = 0; ref < 1 + is_compound && b_mode != ZEROMV; ++ref) { - ref_mv_s8[ref] = nearest_sub8x8[ref]; -#if CONFIG_AMVR - lower_mv_precision(&ref_mv_s8[ref].as_mv, allow_hp, - cm->cur_frame_mv_precision_level); -#else - lower_mv_precision(&ref_mv_s8[ref].as_mv, allow_hp); -#endif - } - (void)ref_mv_s8; - - if (!assign_mv(cm, xd, b_mode, mbmi->ref_frame, j, block, ref_mv[0], - nearest_sub8x8, near_sub8x8, mi_row, mi_col, is_compound, - allow_hp, r)) { - aom_merge_corrupted_flag(&xd->corrupted, 1); - break; - }; - - mi->bmi[j].as_mv[0].as_int = block[0].as_int; - mi->bmi[j].as_mode = b_mode; - if (is_compound) mi->bmi[j].as_mv[1].as_int = block[1].as_int; - - if (num_4x4_h == 2) mi->bmi[j + 2] = mi->bmi[j]; - if (num_4x4_w == 2) mi->bmi[j + 1] = mi->bmi[j]; - } - } + int_mv ref_mv[2]; + ref_mv[0] = nearestmv[0]; + ref_mv[1] = nearestmv[1]; - mbmi->pred_mv[0].as_int = mi->bmi[3].pred_mv[0].as_int; - mbmi->pred_mv[1].as_int = mi->bmi[3].pred_mv[1].as_int; - mi->mbmi.mode = b_mode; - - mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int; - mbmi->mv[1].as_int = mi->bmi[3].as_mv[1].as_int; + if (is_compound) { + int ref_mv_idx = mbmi->ref_mv_idx; + // Special case: NEAR_NEWMV and NEW_NEARMV modes use + // 1 + mbmi->ref_mv_idx (like NEARMV) instead of + // mbmi->ref_mv_idx (like NEWMV) + if (mbmi->mode == NEAR_NEWMV || mbmi->mode == NEW_NEARMV) + ref_mv_idx = 1 + mbmi->ref_mv_idx; + + // TODO(jingning, yunqing): Do we need a lower_mv_precision() call here? + if (compound_ref0_mode(mbmi->mode) == NEWMV) + ref_mv[0] = xd->ref_mv_stack[ref_frame][ref_mv_idx].this_mv; + + if (compound_ref1_mode(mbmi->mode) == NEWMV) + ref_mv[1] = xd->ref_mv_stack[ref_frame][ref_mv_idx].comp_mv; } else { - int_mv ref_mv[2]; - ref_mv[0] = nearestmv[0]; - ref_mv[1] = nearestmv[1]; - - if (is_compound) { - int ref_mv_idx = mbmi->ref_mv_idx; - // Special case: NEAR_NEWMV and NEW_NEARMV modes use - // 1 + mbmi->ref_mv_idx (like NEARMV) instead of - // mbmi->ref_mv_idx (like NEWMV) - if (mbmi->mode == NEAR_NEWMV || mbmi->mode == NEW_NEARMV) - ref_mv_idx = 1 + mbmi->ref_mv_idx; - - if (compound_ref0_mode(mbmi->mode) == NEWMV) { - uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); - if (xd->ref_mv_count[ref_frame_type] > 1) { - ref_mv[0] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv; - clamp_mv_ref(&ref_mv[0].as_mv, xd->n8_w << MI_SIZE_LOG2, - xd->n8_h << MI_SIZE_LOG2, xd); - } - nearestmv[0] = ref_mv[0]; - } - if (compound_ref1_mode(mbmi->mode) == NEWMV) { - uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); - if (xd->ref_mv_count[ref_frame_type] > 1) { - ref_mv[1] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].comp_mv; - clamp_mv_ref(&ref_mv[1].as_mv, xd->n8_w << MI_SIZE_LOG2, - xd->n8_h << MI_SIZE_LOG2, xd); - } - nearestmv[1] = ref_mv[1]; - } -#if CONFIG_COMPOUND_SINGLEREF - } else if (is_singleref_comp_mode) { - int ref_mv_idx = mbmi->ref_mv_idx; - // Special case: SR_NEAR_NEWMV use 1 + mbmi->ref_mv_idx (like NEARMV) - // instead of mbmi->ref_mv_idx (like NEWMV) - if (mbmi->mode == SR_NEAR_NEWMV) ref_mv_idx = 1 + mbmi->ref_mv_idx; - - if (compound_ref0_mode(mbmi->mode) == NEWMV || - compound_ref1_mode(mbmi->mode) == NEWMV) { - uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); - if (xd->ref_mv_count[ref_frame_type] > 1) { - ref_mv[0] = xd->ref_mv_stack[ref_frame_type][ref_mv_idx].this_mv; - clamp_mv_ref(&ref_mv[0].as_mv, xd->n8_w << MI_SIZE_LOG2, - xd->n8_h << MI_SIZE_LOG2, xd); - } - // TODO(zoeliu): To further investigate why this would not cause a - // mismatch for the mode of SR_NEAREST_NEWMV. - nearestmv[0] = ref_mv[0]; - } -#endif // CONFIG_COMPOUND_SINGLEREF - } else { - if (mbmi->mode == NEWMV) { - for (ref = 0; ref < 1 + is_compound; ++ref) { - uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); - if (xd->ref_mv_count[ref_frame_type] > 1) { - ref_mv[ref] = - (ref == 0) - ? xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx].this_mv - : xd->ref_mv_stack[ref_frame_type][mbmi->ref_mv_idx] - .comp_mv; - clamp_mv_ref(&ref_mv[ref].as_mv, xd->n8_w << MI_SIZE_LOG2, - xd->n8_h << MI_SIZE_LOG2, xd); - } - nearestmv[ref] = ref_mv[ref]; - } - } + if (mbmi->mode == NEWMV) { + if (xd->ref_mv_count[ref_frame] > 1) + ref_mv[0] = xd->ref_mv_stack[ref_frame][mbmi->ref_mv_idx].this_mv; } + } + if (mbmi->skip_mode) { + assert(mbmi->mode == NEAREST_NEARESTMV); + mbmi->mv[0].as_int = nearestmv[0].as_int; + mbmi->mv[1].as_int = nearestmv[1].as_int; + } else { int mv_corrupted_flag = - !assign_mv(cm, xd, mbmi->mode, mbmi->ref_frame, 0, mbmi->mv, ref_mv, + !assign_mv(cm, xd, mbmi->mode, mbmi->ref_frame, mbmi->mv, ref_mv, nearestmv, nearmv, mi_row, mi_col, is_compound, allow_hp, r); aom_merge_corrupted_flag(&xd->corrupted, mv_corrupted_flag); } -#if CONFIG_INTERINTRA mbmi->use_wedge_interintra = 0; - if (cm->reference_mode != COMPOUND_REFERENCE && -#if CONFIG_SUPERTX - !supertx_enabled && -#endif - cm->allow_interintra_compound && is_interintra_allowed(mbmi)) { + if (cm->seq_params.enable_interintra_compound && !mbmi->skip_mode && + is_interintra_allowed(mbmi)) { const int bsize_group = size_group_lookup[bsize]; -#if CONFIG_NEW_MULTISYMBOL const int interintra = aom_read_symbol(r, ec_ctx->interintra_cdf[bsize_group], 2, ACCT_STR); -#else - const int interintra = - aom_read(r, cm->fc->interintra_prob[bsize_group], ACCT_STR); -#endif - if (xd->counts) xd->counts->interintra[bsize_group][interintra]++; assert(mbmi->ref_frame[1] == NONE_FRAME); if (interintra) { const INTERINTRA_MODE interintra_mode = - read_interintra_mode(cm, xd, r, bsize_group); + read_interintra_mode(xd, r, bsize_group); mbmi->ref_frame[1] = INTRA_FRAME; mbmi->interintra_mode = interintra_mode; -#if CONFIG_EXT_INTRA - mbmi->angle_delta[0] = 0; - mbmi->angle_delta[1] = 0; -#if CONFIG_INTRA_INTERP - mbmi->intra_filter = INTRA_FILTER_LINEAR; -#endif // CONFIG_INTRA_INTERP -#endif // CONFIG_EXT_INTRA -#if CONFIG_FILTER_INTRA - mbmi->filter_intra_mode_info.use_filter_intra_mode[0] = 0; - mbmi->filter_intra_mode_info.use_filter_intra_mode[1] = 0; -#endif // CONFIG_FILTER_INTRA + mbmi->angle_delta[PLANE_TYPE_Y] = 0; + mbmi->angle_delta[PLANE_TYPE_UV] = 0; + mbmi->filter_intra_mode_info.use_filter_intra = 0; if (is_interintra_wedge_used(bsize)) { -#if CONFIG_NEW_MULTISYMBOL mbmi->use_wedge_interintra = aom_read_symbol( r, ec_ctx->wedge_interintra_cdf[bsize], 2, ACCT_STR); -#else - mbmi->use_wedge_interintra = - aom_read(r, cm->fc->wedge_interintra_prob[bsize], ACCT_STR); -#endif - if (xd->counts) - xd->counts->wedge_interintra[bsize][mbmi->use_wedge_interintra]++; if (mbmi->use_wedge_interintra) { mbmi->interintra_wedge_index = - aom_read_literal(r, get_wedge_bits_lookup(bsize), ACCT_STR); + aom_read_symbol(r, ec_ctx->wedge_idx_cdf[bsize], 16, ACCT_STR); mbmi->interintra_wedge_sign = 0; } } } } -#endif // CONFIG_INTERINTRA -#if CONFIG_WARPED_MOTION - for (ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) { + for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) { const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref]; RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME]; xd->block_refs[ref] = ref_buf; } -#endif -#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION mbmi->motion_mode = SIMPLE_TRANSLATION; -#if CONFIG_WARPED_MOTION - if (mbmi->sb_type >= BLOCK_8X8 && !has_second_ref(mbmi)) -#if WARPED_MOTION_SORT_SAMPLES - mbmi->num_proj_ref[0] = - findSamples(cm, xd, mi_row, mi_col, pts, pts_inref, pts_mv); -#else + if (is_motion_variation_allowed_bsize(mbmi->sb_type) && !mbmi->skip_mode && + !has_second_ref(mbmi)) mbmi->num_proj_ref[0] = findSamples(cm, xd, mi_row, mi_col, pts, pts_inref); -#endif // WARPED_MOTION_SORT_SAMPLES -#endif // CONFIG_WARPED_MOTION -#if CONFIG_MOTION_VAR av1_count_overlappable_neighbors(cm, xd, mi_row, mi_col); -#endif -#if CONFIG_SUPERTX - if (!supertx_enabled) { -#endif // CONFIG_SUPERTX - if (mbmi->ref_frame[1] != INTRA_FRAME) - mbmi->motion_mode = read_motion_mode(cm, xd, mi, r); + if (mbmi->ref_frame[1] != INTRA_FRAME) + mbmi->motion_mode = read_motion_mode(cm, xd, mbmi, r); -#if CONFIG_NCOBMC_ADAPT_WEIGHT - read_ncobmc_mode(xd, mi, mbmi->ncobmc_mode, r); -#endif + // init + mbmi->comp_group_idx = 0; + mbmi->compound_idx = 1; + mbmi->interinter_comp.type = COMPOUND_AVERAGE; -#if CONFIG_COMPOUND_SINGLEREF - if (is_singleref_comp_mode) assert(mbmi->motion_mode == SIMPLE_TRANSLATION); -#endif // CONFIG_COMPOUND_SINGLEREF -#if CONFIG_WARPED_MOTION - if (mbmi->motion_mode == WARPED_CAUSAL) { - mbmi->wm_params[0].wmtype = DEFAULT_WMTYPE; - -#if WARPED_MOTION_SORT_SAMPLES - if (mbmi->num_proj_ref[0] > 1) - mbmi->num_proj_ref[0] = sortSamples(pts_mv, &mbmi->mv[0].as_mv, pts, - pts_inref, mbmi->num_proj_ref[0]); -#endif // WARPED_MOTION_SORT_SAMPLES - - if (find_projection(mbmi->num_proj_ref[0], pts, pts_inref, bsize, - mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col, - &mbmi->wm_params[0], mi_row, mi_col)) { - aom_internal_error(&cm->error, AOM_CODEC_ERROR, "Invalid Warped Model"); - } + if (has_second_ref(mbmi) && !mbmi->skip_mode) { + // Read idx to indicate current compound inter prediction mode group + const int masked_compound_used = is_any_masked_compound_used(bsize) && + cm->seq_params.enable_masked_compound; + + if (masked_compound_used) { + const int ctx_comp_group_idx = get_comp_group_idx_context(xd); + mbmi->comp_group_idx = aom_read_symbol( + r, ec_ctx->comp_group_idx_cdf[ctx_comp_group_idx], 2, ACCT_STR); } -#endif // CONFIG_WARPED_MOTION -#if CONFIG_SUPERTX - } -#endif // CONFIG_SUPERTX -#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION - - mbmi->interinter_compound_type = COMPOUND_AVERAGE; - if ( -#if CONFIG_COMPOUND_SINGLEREF - is_inter_anyref_comp_mode(mbmi->mode) -#else // !CONFIG_COMPOUND_SINGLEREF - cm->reference_mode != SINGLE_REFERENCE && - is_inter_compound_mode(mbmi->mode) -#endif // CONFIG_COMPOUND_SINGLEREF -#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION - && mbmi->motion_mode == SIMPLE_TRANSLATION -#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION - ) { - if (is_any_masked_compound_used(bsize)) { -#if CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE - if (cm->allow_masked_compound) { -#if CONFIG_WEDGE && CONFIG_COMPOUND_SEGMENT - if (!is_interinter_compound_used(COMPOUND_WEDGE, bsize)) - mbmi->interinter_compound_type = - aom_read_bit(r, ACCT_STR) ? COMPOUND_AVERAGE : COMPOUND_SEG; - else -#endif // CONFIG_WEDGE && CONFIG_COMPOUND_SEGMENT - mbmi->interinter_compound_type = aom_read_symbol( - r, ec_ctx->compound_type_cdf[bsize], COMPOUND_TYPES, ACCT_STR); -#if CONFIG_WEDGE - if (mbmi->interinter_compound_type == COMPOUND_WEDGE) { - assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize)); - mbmi->wedge_index = - aom_read_literal(r, get_wedge_bits_lookup(bsize), ACCT_STR); - mbmi->wedge_sign = aom_read_bit(r, ACCT_STR); - } -#endif // CONFIG_WEDGE -#if CONFIG_COMPOUND_SEGMENT - if (mbmi->interinter_compound_type == COMPOUND_SEG) { - mbmi->mask_type = aom_read_literal(r, MAX_SEG_MASK_BITS, ACCT_STR); - } -#endif // CONFIG_COMPOUND_SEGMENT + + if (mbmi->comp_group_idx == 0) { + if (cm->seq_params.enable_jnt_comp) { + const int comp_index_ctx = get_comp_index_context(cm, xd); + mbmi->compound_idx = aom_read_symbol( + r, ec_ctx->compound_index_cdf[comp_index_ctx], 2, ACCT_STR); + } else { + // Distance-weighted compound is disabled, so always use average + mbmi->compound_idx = 1; } -#endif // CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE } else { - mbmi->interinter_compound_type = COMPOUND_AVERAGE; + assert(cm->reference_mode != SINGLE_REFERENCE && + is_inter_compound_mode(mbmi->mode) && + mbmi->motion_mode == SIMPLE_TRANSLATION); + assert(masked_compound_used); + + // compound_diffwtd, wedge + if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) + mbmi->interinter_comp.type = + 1 + aom_read_symbol(r, ec_ctx->compound_type_cdf[bsize], + COMPOUND_TYPES - 1, ACCT_STR); + else + mbmi->interinter_comp.type = COMPOUND_DIFFWTD; + + if (mbmi->interinter_comp.type == COMPOUND_WEDGE) { + assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize)); + mbmi->interinter_comp.wedge_index = + aom_read_symbol(r, ec_ctx->wedge_idx_cdf[bsize], 16, ACCT_STR); + mbmi->interinter_comp.wedge_sign = aom_read_bit(r, ACCT_STR); + } else { + assert(mbmi->interinter_comp.type == COMPOUND_DIFFWTD); + mbmi->interinter_comp.mask_type = + aom_read_literal(r, MAX_DIFFWTD_MASK_BITS, ACCT_STR); + } } - if (xd->counts) - xd->counts->compound_interinter[bsize][mbmi->interinter_compound_type]++; } -#if CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION || CONFIG_GLOBAL_MOTION read_mb_interp_filter(cm, xd, mbmi, r); -#endif // CONFIG_DUAL_FILTER || CONFIG_WARPED_MOTION + + if (mbmi->motion_mode == WARPED_CAUSAL) { + mbmi->wm_params[0].wmtype = DEFAULT_WMTYPE; + mbmi->wm_params[0].invalid = 0; + + if (mbmi->num_proj_ref[0] > 1) + mbmi->num_proj_ref[0] = selectSamples(&mbmi->mv[0].as_mv, pts, pts_inref, + mbmi->num_proj_ref[0], bsize); + + if (find_projection(mbmi->num_proj_ref[0], pts, pts_inref, bsize, + mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col, + &mbmi->wm_params[0], mi_row, mi_col)) { +#if WARPED_MOTION_DEBUG + printf("Warning: unexpected warped model from aomenc\n"); +#endif + mbmi->wm_params[0].invalid = 1; + } + } + + xd->cfl.is_chroma_reference = is_chroma_reference( + mi_row, mi_col, bsize, cm->subsampling_x, cm->subsampling_y); + xd->cfl.store_y = store_cfl_required(cm, xd); #if DEC_MISMATCH_DEBUG - dec_dump_logs(cm, mi, mi_row, mi_col, inter_mode_ctx, mode_ctx); + dec_dump_logs(cm, mi, mi_row, mi_col, mode_ctx); #endif // DEC_MISMATCH_DEBUG } static void read_inter_frame_mode_info(AV1Decoder *const pbi, - MACROBLOCKD *const xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif // CONFIG_SUPERTX - int mi_row, int mi_col, aom_reader *r) { + MACROBLOCKD *const xd, int mi_row, + int mi_col, aom_reader *r) { AV1_COMMON *const cm = &pbi->common; - MODE_INFO *const mi = xd->mi[0]; - MB_MODE_INFO *const mbmi = &mi->mbmi; + MB_MODE_INFO *const mbmi = xd->mi[0]; int inter_block = 1; -#if CONFIG_VAR_TX - BLOCK_SIZE bsize = mbmi->sb_type; -#endif // CONFIG_VAR_TX mbmi->mv[0].as_int = 0; mbmi->mv[1].as_int = 0; - mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, r); -#if CONFIG_SUPERTX - if (!supertx_enabled) -#endif // CONFIG_SUPERTX + mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, 1, r); + + mbmi->skip_mode = read_skip_mode(cm, xd, mbmi->segment_id, r); + + if (mbmi->skip_mode) + mbmi->skip = 1; + else mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r); + mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, 0, r); + + read_cdef(cm, r, xd, mi_col, mi_row); + if (cm->delta_q_present_flag) { - xd->current_qindex = - xd->prev_qindex + + xd->current_qindex += read_delta_qindex(cm, xd, r, mbmi, mi_col, mi_row) * cm->delta_q_res; /* Normative: Clamp to [1,MAXQ] to not interfere with lossless mode */ xd->current_qindex = clamp(xd->current_qindex, 1, MAXQ); - xd->prev_qindex = xd->current_qindex; -#if CONFIG_EXT_DELTA_Q if (cm->delta_lf_present_flag) { -#if CONFIG_LOOPFILTER_LEVEL if (cm->delta_lf_multi) { - for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id) { - mbmi->curr_delta_lf[lf_id] = xd->curr_delta_lf[lf_id] = - xd->prev_delta_lf[lf_id] + + const int frame_lf_count = + av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; + for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { + const int tmp_lvl = + xd->delta_lf[lf_id] + read_delta_lflevel(cm, xd, r, lf_id, mbmi, mi_col, mi_row) * cm->delta_lf_res; - xd->prev_delta_lf[lf_id] = xd->curr_delta_lf[lf_id]; + mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id] = + clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); } } else { - mbmi->current_delta_lf_from_base = xd->current_delta_lf_from_base = - xd->prev_delta_lf_from_base + + const int tmp_lvl = + xd->delta_lf_from_base + read_delta_lflevel(cm, xd, r, -1, mbmi, mi_col, mi_row) * cm->delta_lf_res; - xd->prev_delta_lf_from_base = xd->current_delta_lf_from_base; + mbmi->delta_lf_from_base = xd->delta_lf_from_base = + clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); } -#else - const int current_delta_lf_from_base = - xd->prev_delta_lf_from_base + - read_delta_lflevel(cm, xd, r, mbmi, mi_col, mi_row) * - cm->delta_lf_res; - mbmi->current_delta_lf_from_base = xd->current_delta_lf_from_base = - clamp(current_delta_lf_from_base, 0, MAX_LOOP_FILTER); - xd->prev_delta_lf_from_base = xd->current_delta_lf_from_base; -#endif // CONFIG_LOOPFILTER_LEVEL } -#endif } -#if CONFIG_SUPERTX - if (!supertx_enabled) { -#endif // CONFIG_SUPERTX + if (!mbmi->skip_mode) inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r); -#if CONFIG_VAR_TX - xd->above_txfm_context = - cm->above_txfm_context + (mi_col << TX_UNIT_WIDE_LOG2); - xd->left_txfm_context = xd->left_txfm_context_buffer + - ((mi_row & MAX_MIB_MASK) << TX_UNIT_HIGH_LOG2); - - if (cm->tx_mode == TX_MODE_SELECT && -#if CONFIG_CB4X4 - bsize > BLOCK_4X4 && -#else - bsize >= BLOCK_8X8 && -#endif - !mbmi->skip && inter_block && !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_wide_log2[0]; - int idx, idy; - int init_depth = - (height != width) ? RECT_VARTX_DEPTH_INIT : SQR_VARTX_DEPTH_INIT; - - mbmi->min_tx_size = TX_SIZES_ALL; - for (idy = 0; idy < height; idy += bh) - for (idx = 0; idx < width; idx += bw) - read_tx_size_vartx(cm, xd, mbmi, xd->counts, max_tx_size, init_depth, - idy, idx, r); -#if CONFIG_RECT_TX_EXT - if (is_quarter_tx_allowed(xd, mbmi, inter_block) && - mbmi->tx_size == max_tx_size) { - int quarter_tx; - - if (quarter_txsize_lookup[bsize] != max_tx_size) { -#if CONFIG_NEW_MULTISYMBOL - quarter_tx = - aom_read_symbol(r, cm->fc->quarter_tx_size_cdf, 2, ACCT_STR); -#else - quarter_tx = aom_read(r, cm->fc->quarter_tx_size_prob, ACCT_STR); - if (xd->counts) ++xd->counts->quarter_tx_size[quarter_tx]; -#endif - } else { - quarter_tx = 1; - } - if (quarter_tx) { - mbmi->tx_size = quarter_txsize_lookup[bsize]; - for (idy = 0; idy < tx_size_high_unit[max_tx_size] / 2; ++idy) - for (idx = 0; idx < tx_size_wide_unit[max_tx_size] / 2; ++idx) - mbmi->inter_tx_size[idy][idx] = mbmi->tx_size; - mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size); - } - } -#endif - } else { - mbmi->tx_size = read_tx_size(cm, xd, inter_block, !mbmi->skip, r); - - if (inter_block) { - const int width = block_size_wide[bsize] >> tx_size_wide_log2[0]; - const int height = block_size_high[bsize] >> tx_size_high_log2[0]; - int idx, idy; - for (idy = 0; idy < height; ++idy) - for (idx = 0; idx < width; ++idx) - mbmi->inter_tx_size[idy >> 1][idx >> 1] = mbmi->tx_size; - } - mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size); - set_txfm_ctxs(mbmi->tx_size, xd->n8_w, xd->n8_h, mbmi->skip, xd); - } -#else - mbmi->tx_size = read_tx_size(cm, xd, inter_block, !mbmi->skip, r); -#endif // CONFIG_VAR_TX -#if CONFIG_SUPERTX - } -#if CONFIG_VAR_TX - else if (inter_block) { - const int width = num_4x4_blocks_wide_lookup[bsize]; - const int height = num_4x4_blocks_high_lookup[bsize]; - int idx, idy; - xd->mi[0]->mbmi.tx_size = xd->supertx_size; - for (idy = 0; idy < height; ++idy) - for (idx = 0; idx < width; ++idx) - xd->mi[0]->mbmi.inter_tx_size[idy >> 1][idx >> 1] = xd->supertx_size; - } -#endif // CONFIG_VAR_TX -#endif // CONFIG_SUPERTX + mbmi->current_qindex = xd->current_qindex; + + xd->above_txfm_context = cm->above_txfm_context[xd->tile.tile_row] + mi_col; + xd->left_txfm_context = + xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); if (inter_block) - read_inter_block_mode_info(pbi, xd, -#if CONFIG_SUPERTX - mi, mi_row, mi_col, r, supertx_enabled); -#else - mi, mi_row, mi_col, r); -#endif // CONFIG_MOTION_VAR && CONFIG_SUPERTX + read_inter_block_mode_info(pbi, xd, mbmi, mi_row, mi_col, r); else - read_intra_block_mode_info(cm, mi_row, mi_col, xd, mi, r); - -#if !CONFIG_TXK_SEL - av1_read_tx_type(cm, xd, -#if CONFIG_SUPERTX - supertx_enabled, -#endif - r); -#endif // !CONFIG_TXK_SEL + read_intra_block_mode_info(cm, mi_row, mi_col, xd, mbmi, r); } -static void av1_intra_copy_frame_mvs(AV1_COMMON *const cm, int mi_row, - int mi_col, int x_mis, int y_mis) { -#if CONFIG_TMV +static void intra_copy_frame_mvs(AV1_COMMON *const cm, int mi_row, int mi_col, + int x_mis, int y_mis) { const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1); - MV_REF *frame_mvs = cm->cur_frame->mvs + - ((mi_row & 0xfffe) >> 1) * frame_mvs_stride + - ((mi_col & 0xfffe) >> 1); + MV_REF *frame_mvs = + cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1); x_mis = ROUND_POWER_OF_TWO(x_mis, 1); y_mis = ROUND_POWER_OF_TWO(y_mis, 1); -#else - const int frame_mvs_stride = cm->mi_cols; - MV_REF *frame_mvs = cm->cur_frame->mvs + - (mi_row & 0xfffe) * frame_mvs_stride + (mi_col & 0xfffe); - x_mis = AOMMAX(x_mis, 2); - y_mis = AOMMAX(y_mis, 2); -#endif // CONFIG_TMV - int w, h; - - for (h = 0; h < y_mis; h++) { - MV_REF *const frame_mv = frame_mvs + h * frame_mvs_stride; - for (w = 0; w < x_mis; w++) { - MV_REF *const mv = frame_mv + w; - mv->ref_frame[0] = NONE_FRAME; - mv->ref_frame[1] = NONE_FRAME; + + for (int h = 0; h < y_mis; h++) { + MV_REF *mv = frame_mvs; + for (int w = 0; w < x_mis; w++) { + mv->ref_frame = NONE_FRAME; + mv++; } + frame_mvs += frame_mvs_stride; } } -void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif // CONFIG_SUPERTX - int mi_row, int mi_col, aom_reader *r, int x_mis, - int y_mis) { +void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, int mi_row, + int mi_col, aom_reader *r, int x_mis, int y_mis) { AV1_COMMON *const cm = &pbi->common; - MODE_INFO *const mi = xd->mi[0]; -#if CONFIG_INTRABC - mi->mbmi.use_intrabc = 0; -#endif // CONFIG_INTRABC + MB_MODE_INFO *const mi = xd->mi[0]; + mi->use_intrabc = 0; if (frame_is_intra_only(cm)) { read_intra_frame_mode_info(cm, xd, mi_row, mi_col, r); - av1_intra_copy_frame_mvs(cm, mi_row, mi_col, x_mis, y_mis); + intra_copy_frame_mvs(cm, mi_row, mi_col, x_mis, y_mis); } else { - read_inter_frame_mode_info(pbi, xd, -#if CONFIG_SUPERTX - supertx_enabled, -#endif // CONFIG_SUPERTX - mi_row, mi_col, r); + read_inter_frame_mode_info(pbi, xd, mi_row, mi_col, r); av1_copy_frame_mvs(cm, mi, mi_row, mi_col, x_mis, y_mis); } } diff --git a/third_party/aom/av1/decoder/decodemv.h b/third_party/aom/av1/decoder/decodemv.h index 162cf32542..6243bb1682 100644 --- a/third_party/aom/av1/decoder/decodemv.h +++ b/third_party/aom/av1/decoder/decodemv.h @@ -21,9 +21,6 @@ extern "C" { #endif void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif int mi_row, int mi_col, aom_reader *r, int x_mis, int y_mis); @@ -32,14 +29,7 @@ void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, } // extern "C" #endif -void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, -#if CONFIG_SUPERTX - int supertx_enabled, -#endif -#if CONFIG_TXK_SEL - int blk_row, int blk_col, int block, int plane, - TX_SIZE tx_size, -#endif - aom_reader *r); +void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row, + int blk_col, TX_SIZE tx_size, aom_reader *r); #endif // AV1_DECODER_DECODEMV_H_ diff --git a/third_party/aom/av1/decoder/decoder.c b/third_party/aom/av1/decoder/decoder.c index cd82d5b53e..2e91d27d36 100644 --- a/third_party/aom/av1/decoder/decoder.c +++ b/third_party/aom/av1/decoder/decoder.c @@ -13,9 +13,9 @@ #include <limits.h> #include <stdio.h> -#include "./av1_rtcd.h" -#include "./aom_dsp_rtcd.h" -#include "./aom_scale_rtcd.h" +#include "config/av1_rtcd.h" +#include "config/aom_dsp_rtcd.h" +#include "config/aom_scale_rtcd.h" #include "aom_mem/aom_mem.h" #include "aom_ports/system_state.h" @@ -33,12 +33,8 @@ #include "av1/decoder/decodeframe.h" #include "av1/decoder/decoder.h" -#if CONFIG_NCOBMC_ADAPT_WEIGHT -#include "av1/common/ncobmc_kernels.h" -#endif // CONFIG_NCOBMC_ADAPT_WEIGHT -#if !CONFIG_PVQ #include "av1/decoder/detokenize.h" -#endif +#include "av1/decoder/obu.h" static void initialize_dec(void) { static volatile int init_done = 0; @@ -53,23 +49,24 @@ static void initialize_dec(void) { } } -static void av1_dec_setup_mi(AV1_COMMON *cm) { - cm->mi = cm->mip + cm->mi_stride + 1; - cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1; +static void dec_setup_mi(AV1_COMMON *cm) { + cm->mi = cm->mip; + cm->mi_grid_visible = cm->mi_grid_base; memset(cm->mi_grid_base, 0, - cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base)); + cm->mi_stride * cm->mi_rows * sizeof(*cm->mi_grid_base)); } static int av1_dec_alloc_mi(AV1_COMMON *cm, int mi_size) { cm->mip = aom_calloc(mi_size, sizeof(*cm->mip)); if (!cm->mip) return 1; cm->mi_alloc_size = mi_size; - cm->mi_grid_base = (MODE_INFO **)aom_calloc(mi_size, sizeof(MODE_INFO *)); + cm->mi_grid_base = + (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *)); if (!cm->mi_grid_base) return 1; return 0; } -static void av1_dec_free_mi(AV1_COMMON *cm) { +static void dec_free_mi(AV1_COMMON *cm) { aom_free(cm->mip); cm->mip = NULL; aom_free(cm->mi_grid_base); @@ -108,28 +105,20 @@ AV1Decoder *av1_decoder_create(BufferPool *const pool) { memset(&cm->next_ref_frame_map, -1, sizeof(cm->next_ref_frame_map)); cm->current_video_frame = 0; - pbi->ready_for_new_data = 1; + pbi->decoding_first_frame = 1; pbi->common.buffer_pool = pool; cm->bit_depth = AOM_BITS_8; cm->dequant_bit_depth = AOM_BITS_8; cm->alloc_mi = av1_dec_alloc_mi; - cm->free_mi = av1_dec_free_mi; - cm->setup_mi = av1_dec_setup_mi; + cm->free_mi = dec_free_mi; + cm->setup_mi = dec_setup_mi; av1_loop_filter_init(cm); -#if CONFIG_NCOBMC_ADAPT_WEIGHT - get_default_ncobmc_kernels(cm); -#endif // CONFIG_NCOBMC_ADAPT_WEIGHT - -#if CONFIG_AOM_QM - aom_qm_init(cm); -#endif -#if CONFIG_LOOP_RESTORATION + av1_qm_init(cm); av1_loop_restoration_precal(); -#endif // CONFIG_LOOP_RESTORATION #if CONFIG_ACCOUNTING pbi->acct_enabled = 1; aom_accounting_init(&pbi->accounting); @@ -142,33 +131,83 @@ AV1Decoder *av1_decoder_create(BufferPool *const pool) { return pbi; } +void av1_dealloc_dec_jobs(struct AV1DecTileMTData *tile_mt_info) { + if (tile_mt_info != NULL) { +#if CONFIG_MULTITHREAD + if (tile_mt_info->job_mutex != NULL) { + pthread_mutex_destroy(tile_mt_info->job_mutex); + aom_free(tile_mt_info->job_mutex); + } +#endif + aom_free(tile_mt_info->job_queue); + // clear the structure as the source of this call may be a resize in which + // case this call will be followed by an _alloc() which may fail. + av1_zero(*tile_mt_info); + } +} + void av1_decoder_remove(AV1Decoder *pbi) { int i; if (!pbi) return; + // Free the tile list output buffer. + if (pbi->tile_list_output != NULL) aom_free(pbi->tile_list_output); + pbi->tile_list_output = NULL; + aom_get_worker_interface()->end(&pbi->lf_worker); aom_free(pbi->lf_worker.data1); - aom_free(pbi->tile_data); - for (i = 0; i < pbi->num_tile_workers; ++i) { + + if (pbi->thread_data) { + for (int worker_idx = 0; worker_idx < pbi->max_threads - 1; worker_idx++) { + DecWorkerData *const thread_data = pbi->thread_data + worker_idx; + const int use_highbd = pbi->common.use_highbitdepth ? 1 : 0; + av1_free_mc_tmp_buf(thread_data->td, use_highbd); + aom_free(thread_data->td); + } + aom_free(pbi->thread_data); + } + + for (i = 0; i < pbi->num_workers; ++i) { AVxWorker *const worker = &pbi->tile_workers[i]; aom_get_worker_interface()->end(worker); } - aom_free(pbi->tile_worker_data); - aom_free(pbi->tile_worker_info); + aom_free(pbi->tile_data); aom_free(pbi->tile_workers); - if (pbi->num_tile_workers > 0) { + if (pbi->num_workers > 0) { av1_loop_filter_dealloc(&pbi->lf_row_sync); + av1_loop_restoration_dealloc(&pbi->lr_row_sync, pbi->num_workers); + av1_dealloc_dec_jobs(&pbi->tile_mt_info); } #if CONFIG_ACCOUNTING aom_accounting_clear(&pbi->accounting); #endif + const int use_highbd = pbi->common.use_highbitdepth ? 1 : 0; + av1_free_mc_tmp_buf(&pbi->td, use_highbd); aom_free(pbi); } +void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, int mi_row, + int mi_col, aom_reader *r, BLOCK_SIZE bsize, + palette_visitor_fn_t visit) { + if (!is_inter_block(xd->mi[0])) { + for (int plane = 0; plane < AOMMIN(2, av1_num_planes(&pbi->common)); + ++plane) { + const struct macroblockd_plane *const pd = &xd->plane[plane]; + if (is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, + pd->subsampling_y)) { + if (xd->mi[0]->palette_mode_info.palette_size[plane]) + visit(xd, plane, r); + } else { + assert(xd->mi[0]->palette_mode_info.palette_size[plane] == 0); + } + } + } +} + static int equal_dimensions(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b) { return a->y_height == b->y_height && a->y_width == b->y_width && @@ -178,6 +217,7 @@ static int equal_dimensions(const YV12_BUFFER_CONFIG *a, aom_codec_err_t av1_copy_reference_dec(AV1Decoder *pbi, int idx, YV12_BUFFER_CONFIG *sd) { AV1_COMMON *cm = &pbi->common; + const int num_planes = av1_num_planes(cm); const YV12_BUFFER_CONFIG *const cfg = get_ref_frame(cm, idx); if (cfg == NULL) { @@ -188,13 +228,25 @@ aom_codec_err_t av1_copy_reference_dec(AV1Decoder *pbi, int idx, aom_internal_error(&cm->error, AOM_CODEC_ERROR, "Incorrect buffer dimensions"); else - aom_yv12_copy_frame(cfg, sd); + aom_yv12_copy_frame(cfg, sd, num_planes); return cm->error.error_code; } +static int equal_dimensions_and_border(const YV12_BUFFER_CONFIG *a, + const YV12_BUFFER_CONFIG *b) { + return a->y_height == b->y_height && a->y_width == b->y_width && + a->uv_height == b->uv_height && a->uv_width == b->uv_width && + a->y_stride == b->y_stride && a->uv_stride == b->uv_stride && + a->border == b->border && + (a->flags & YV12_FLAG_HIGHBITDEPTH) == + (b->flags & YV12_FLAG_HIGHBITDEPTH); +} + aom_codec_err_t av1_set_reference_dec(AV1_COMMON *cm, int idx, + int use_external_ref, YV12_BUFFER_CONFIG *sd) { + const int num_planes = av1_num_planes(cm); YV12_BUFFER_CONFIG *ref_buf = NULL; // Get the destination reference buffer. @@ -205,60 +257,132 @@ aom_codec_err_t av1_set_reference_dec(AV1_COMMON *cm, int idx, return AOM_CODEC_ERROR; } - if (!equal_dimensions(ref_buf, sd)) { - aom_internal_error(&cm->error, AOM_CODEC_ERROR, - "Incorrect buffer dimensions"); + if (!use_external_ref) { + if (!equal_dimensions(ref_buf, sd)) { + aom_internal_error(&cm->error, AOM_CODEC_ERROR, + "Incorrect buffer dimensions"); + } else { + // Overwrite the reference frame buffer. + aom_yv12_copy_frame(sd, ref_buf, num_planes); + } } else { - // Overwrite the reference frame buffer. - aom_yv12_copy_frame(sd, ref_buf); + if (!equal_dimensions_and_border(ref_buf, sd)) { + aom_internal_error(&cm->error, AOM_CODEC_ERROR, + "Incorrect buffer dimensions"); + } else { + // Overwrite the reference frame buffer pointers. + // Once we no longer need the external reference buffer, these pointers + // are restored. + ref_buf->store_buf_adr[0] = ref_buf->y_buffer; + ref_buf->store_buf_adr[1] = ref_buf->u_buffer; + ref_buf->store_buf_adr[2] = ref_buf->v_buffer; + ref_buf->y_buffer = sd->y_buffer; + ref_buf->u_buffer = sd->u_buffer; + ref_buf->v_buffer = sd->v_buffer; + ref_buf->use_external_refernce_buffers = 1; + } } return cm->error.error_code; } -/* If any buffer updating is signaled it should be done here. */ -static void swap_frame_buffers(AV1Decoder *pbi) { +aom_codec_err_t av1_copy_new_frame_dec(AV1_COMMON *cm, + YV12_BUFFER_CONFIG *new_frame, + YV12_BUFFER_CONFIG *sd) { + const int num_planes = av1_num_planes(cm); + + if (!equal_dimensions_and_border(new_frame, sd)) + aom_internal_error(&cm->error, AOM_CODEC_ERROR, + "Incorrect buffer dimensions"); + else + aom_yv12_copy_frame(new_frame, sd, num_planes); + + return cm->error.error_code; +} + +/* If any buffer updating is signaled it should be done here. + Consumes a reference to cm->new_fb_idx. +*/ +static void swap_frame_buffers(AV1Decoder *pbi, int frame_decoded) { int ref_index = 0, mask; AV1_COMMON *const cm = &pbi->common; BufferPool *const pool = cm->buffer_pool; RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; - lock_buffer_pool(pool); - for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { - const int old_idx = cm->ref_frame_map[ref_index]; - // Current thread releases the holding of reference frame. - decrease_ref_count(old_idx, frame_bufs, pool); - - // Release the reference frame holding in the reference map for the decoding - // of the next frame. - if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool); - cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; - ++ref_index; - } + if (frame_decoded) { + lock_buffer_pool(pool); - // Current thread releases the holding of reference frame. - for (; ref_index < REF_FRAMES && !cm->show_existing_frame; ++ref_index) { - const int old_idx = cm->ref_frame_map[ref_index]; - decrease_ref_count(old_idx, frame_bufs, pool); - cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; - } + // In ext-tile decoding, the camera frame header is only decoded once. So, + // we don't release the references here. + if (!pbi->camera_frame_header_ready) { + for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { + const int old_idx = cm->ref_frame_map[ref_index]; + // Current thread releases the holding of reference frame. + decrease_ref_count(old_idx, frame_bufs, pool); - unlock_buffer_pool(pool); - pbi->hold_ref_buf = 0; - cm->frame_to_show = get_frame_new_buffer(cm); + // Release the reference frame holding in the reference map for the + // decoding of the next frame. + if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool); + cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; + ++ref_index; + } - // TODO(zoeliu): To fix the ref frame buffer update for the scenario of - // cm->frame_parellel_decode == 1 - if (!cm->frame_parallel_decode || !cm->show_frame) { + // Current thread releases the holding of reference frame. + const int check_on_show_existing_frame = + !cm->show_existing_frame || cm->reset_decoder_state; + for (; ref_index < REF_FRAMES && check_on_show_existing_frame; + ++ref_index) { + const int old_idx = cm->ref_frame_map[ref_index]; + decrease_ref_count(old_idx, frame_bufs, pool); + cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; + } + } + + YV12_BUFFER_CONFIG *cur_frame = get_frame_new_buffer(cm); + + if (cm->show_existing_frame || cm->show_frame) { + if (pbi->output_all_layers) { + // Append this frame to the output queue + if (pbi->num_output_frames >= MAX_NUM_SPATIAL_LAYERS) { + // We can't store the new frame anywhere, so drop it and return an + // error + decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); + cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; + } else { + pbi->output_frames[pbi->num_output_frames] = cur_frame; + pbi->output_frame_index[pbi->num_output_frames] = cm->new_fb_idx; + pbi->num_output_frames++; + } + } else { + // Replace any existing output frame + assert(pbi->num_output_frames == 0 || pbi->num_output_frames == 1); + if (pbi->num_output_frames > 0) { + decrease_ref_count((int)pbi->output_frame_index[0], frame_bufs, pool); + } + pbi->output_frames[0] = cur_frame; + pbi->output_frame_index[0] = cm->new_fb_idx; + pbi->num_output_frames = 1; + } + } else { + decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); + } + + unlock_buffer_pool(pool); + } else { + // Nothing was decoded, so just drop this frame buffer lock_buffer_pool(pool); - --frame_bufs[cm->new_fb_idx].ref_count; + decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); unlock_buffer_pool(pool); } - // Invalidate these references until the next frame starts. - for (ref_index = 0; ref_index < INTER_REFS_PER_FRAME; ref_index++) { - cm->frame_refs[ref_index].idx = INVALID_IDX; - cm->frame_refs[ref_index].buf = NULL; + if (!pbi->camera_frame_header_ready) { + pbi->hold_ref_buf = 0; + + // Invalidate these references until the next frame starts. + for (ref_index = 0; ref_index < INTER_REFS_PER_FRAME; ref_index++) { + cm->frame_refs[ref_index].idx = INVALID_IDX; + cm->frame_refs[ref_index].buf = NULL; + } } } @@ -268,7 +392,6 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, BufferPool *volatile const pool = cm->buffer_pool; RefCntBuffer *volatile const frame_bufs = cm->buffer_pool->frame_bufs; const uint8_t *source = *psource; - int retcode = 0; cm->error.error_code = AOM_CODEC_OK; if (size == 0) { @@ -286,18 +409,9 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, } } - pbi->ready_for_new_data = 0; - // Find a free buffer for the new frame, releasing the reference previously // held. - // Check if the previous frame was a frame without any references to it. - // Release frame buffer if not decoding in frame parallel mode. - if (!cm->frame_parallel_decode && cm->new_fb_idx >= 0 && - frame_bufs[cm->new_fb_idx].ref_count == 0) - pool->release_fb_cb(pool->cb_priv, - &frame_bufs[cm->new_fb_idx].raw_frame_buffer); - // Find a free frame buffer. Return error if can not find any. cm->new_fb_idx = get_free_fb(cm); if (cm->new_fb_idx == INVALID_IDX) return AOM_CODEC_MEM_ERROR; @@ -305,31 +419,20 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, // Assign a MV array to the frame buffer. cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx]; - pbi->hold_ref_buf = 0; - if (cm->frame_parallel_decode) { - AVxWorker *const worker = pbi->frame_worker_owner; - av1_frameworker_lock_stats(worker); - frame_bufs[cm->new_fb_idx].frame_worker_owner = worker; - // Reset decoding progress. - pbi->cur_buf = &frame_bufs[cm->new_fb_idx]; - pbi->cur_buf->row = -1; - pbi->cur_buf->col = -1; - av1_frameworker_unlock_stats(worker); - } else { - pbi->cur_buf = &frame_bufs[cm->new_fb_idx]; - } + if (!pbi->camera_frame_header_ready) pbi->hold_ref_buf = 0; + + pbi->cur_buf = &frame_bufs[cm->new_fb_idx]; if (setjmp(cm->error.jmp)) { const AVxWorkerInterface *const winterface = aom_get_worker_interface(); int i; cm->error.setjmp = 0; - pbi->ready_for_new_data = 1; // Synchronize all threads immediately as a subsequent decode call may // cause a resize invalidating some allocations. winterface->sync(&pbi->lf_worker); - for (i = 0; i < pbi->num_tile_workers; ++i) { + for (i = 0; i < pbi->num_workers; ++i) { winterface->sync(&pbi->tile_workers[i]); } @@ -349,7 +452,10 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, } // Current thread releases the holding of reference frame. - for (; ref_index < REF_FRAMES && !cm->show_existing_frame; ++ref_index) { + const int check_on_show_existing_frame = + !cm->show_existing_frame || cm->reset_decoder_state; + for (; ref_index < REF_FRAMES && check_on_show_existing_frame; + ++ref_index) { const int old_idx = cm->ref_frame_map[ref_index]; decrease_ref_count(old_idx, frame_bufs, pool); } @@ -365,160 +471,72 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, cm->error.setjmp = 1; -#if !CONFIG_OBU - av1_decode_frame_headers_and_setup(pbi, source, source + size, psource); - if (!cm->show_existing_frame) { - av1_decode_tg_tiles_and_wrapup(pbi, source, source + size, psource, 0, - cm->tile_rows * cm->tile_cols - 1, 1); - } -#else - av1_decode_frame_from_obus(pbi, source, source + size, psource); + int frame_decoded = + aom_decode_frame_from_obus(pbi, source, source + size, psource); + + if (cm->error.error_code != AOM_CODEC_OK) return 1; + +#if TXCOEFF_TIMER + cm->cum_txcoeff_timer += cm->txcoeff_timer; + fprintf(stderr, + "txb coeff block number: %d, frame time: %ld, cum time %ld in us\n", + cm->txb_count, cm->txcoeff_timer, cm->cum_txcoeff_timer); + cm->txcoeff_timer = 0; + cm->txb_count = 0; #endif - swap_frame_buffers(pbi); + // Note: At this point, this function holds a reference to cm->new_fb_idx + // in the buffer pool. This reference is consumed by swap_frame_buffers(). + swap_frame_buffers(pbi, frame_decoded); + + if (frame_decoded) { + pbi->decoding_first_frame = 0; + } -#if CONFIG_EXT_TILE - // For now, we only extend the frame borders when the whole frame is decoded. - // Later, if needed, extend the border for the decoded tile on the frame - // border. - if (pbi->dec_tile_row == -1 && pbi->dec_tile_col == -1) -#endif // CONFIG_EXT_TILE - // TODO(debargha): Fix encoder side mv range, so that we can use the - // inner border extension. As of now use the larger extension. - // aom_extend_frame_inner_borders(cm->frame_to_show); - aom_extend_frame_borders(cm->frame_to_show); + if (cm->error.error_code != AOM_CODEC_OK) return 1; aom_clear_system_state(); if (!cm->show_existing_frame) { cm->last_show_frame = cm->show_frame; -#if CONFIG_EXT_REFS - // NOTE: It is not supposed to ref to any frame not used as reference - if (cm->is_reference_frame) -#endif // CONFIG_EXT_REFS - cm->prev_frame = cm->cur_frame; - - if (cm->seg.enabled && !cm->frame_parallel_decode) - av1_swap_current_and_last_seg_map(cm); - } - - // Update progress in frame parallel decode. - if (cm->frame_parallel_decode) { - // Need to lock the mutex here as another thread may - // be accessing this buffer. - AVxWorker *const worker = pbi->frame_worker_owner; - FrameWorkerData *const frame_worker_data = worker->data1; - av1_frameworker_lock_stats(worker); - - if (cm->show_frame) { - cm->current_video_frame++; - } - frame_worker_data->frame_decoded = 1; - frame_worker_data->frame_context_ready = 1; - av1_frameworker_signal_stats(worker); - av1_frameworker_unlock_stats(worker); - } else { - cm->last_width = cm->width; - cm->last_height = cm->height; - cm->last_tile_cols = cm->tile_cols; - cm->last_tile_rows = cm->tile_rows; - if (cm->show_frame) { - cm->current_video_frame++; + if (cm->seg.enabled) { + if (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; + } } } + // Update progress in frame parallel decode. + cm->last_width = cm->width; + cm->last_height = cm->height; + cm->last_tile_cols = cm->tile_cols; + cm->last_tile_rows = cm->tile_rows; cm->error.setjmp = 0; - return retcode; -} - -int av1_get_raw_frame(AV1Decoder *pbi, YV12_BUFFER_CONFIG *sd) { - AV1_COMMON *const cm = &pbi->common; - int ret = -1; - if (pbi->ready_for_new_data == 1) return ret; - pbi->ready_for_new_data = 1; + return 0; +} - /* no raw frame to show!!! */ - if (!cm->show_frame) return ret; +// Get the frame at a particular index in the output queue +int av1_get_raw_frame(AV1Decoder *pbi, size_t index, YV12_BUFFER_CONFIG **sd, + aom_film_grain_t **grain_params) { + RefCntBuffer *const frame_bufs = pbi->common.buffer_pool->frame_bufs; - *sd = *cm->frame_to_show; - ret = 0; + if (index >= pbi->num_output_frames) return -1; + *sd = pbi->output_frames[index]; + *grain_params = &frame_bufs[pbi->output_frame_index[index]].film_grain_params; aom_clear_system_state(); - return ret; + return 0; } +// Get the highest-spatial-layer output +// TODO(david.barker): What should this do? int av1_get_frame_to_show(AV1Decoder *pbi, YV12_BUFFER_CONFIG *frame) { - AV1_COMMON *const cm = &pbi->common; - - if (!cm->show_frame || !cm->frame_to_show) return -1; + if (pbi->num_output_frames == 0) return -1; - *frame = *cm->frame_to_show; + *frame = *pbi->output_frames[pbi->num_output_frames - 1]; return 0; } - -aom_codec_err_t av1_parse_superframe_index(const uint8_t *data, size_t data_sz, - uint32_t sizes[8], int *count, - int *index_size, - aom_decrypt_cb decrypt_cb, - void *decrypt_state) { - // A chunk ending with a byte matching 0xc0 is an invalid chunk unless - // it is a super frame index. If the last byte of real video compression - // data is 0xc0 the encoder must add a 0 byte. If we have the marker but - // not the associated matching marker byte at the front of the index we have - // an invalid bitstream and need to return an error. - - uint8_t marker; - size_t frame_sz_sum = 0; - - assert(data_sz); - marker = read_marker(decrypt_cb, decrypt_state, data); - *count = 0; - - if ((marker & 0xe0) == 0xc0) { - const uint32_t frames = (marker & 0x7) + 1; - const uint32_t mag = ((marker >> 3) & 0x3) + 1; - const size_t index_sz = 2 + mag * (frames - 1); - *index_size = (int)index_sz; - - // This chunk is marked as having a superframe index but doesn't have - // enough data for it, thus it's an invalid superframe index. - if (data_sz < index_sz) return AOM_CODEC_CORRUPT_FRAME; - - { - const uint8_t marker2 = - read_marker(decrypt_cb, decrypt_state, data + index_sz - 1); - - // This chunk is marked as having a superframe index but doesn't have - // the matching marker byte at the front of the index therefore it's an - // invalid chunk. - if (marker != marker2) return AOM_CODEC_CORRUPT_FRAME; - } - - { - // Found a valid superframe index. - uint32_t i, j; - const uint8_t *x = &data[1]; - - // Frames has a maximum of 8 and mag has a maximum of 4. - uint8_t clear_buffer[28]; - assert(sizeof(clear_buffer) >= (frames - 1) * mag); - if (decrypt_cb) { - decrypt_cb(decrypt_state, x, clear_buffer, (frames - 1) * mag); - x = clear_buffer; - } - - for (i = 0; i < frames - 1; ++i) { - uint32_t this_sz = 0; - - for (j = 0; j < mag; ++j) this_sz |= (*x++) << (j * 8); - this_sz += 1; - sizes[i] = this_sz; - frame_sz_sum += this_sz; - } - sizes[i] = (uint32_t)(data_sz - index_sz - frame_sz_sum); - *count = frames; - } - } - return AOM_CODEC_OK; -} diff --git a/third_party/aom/av1/decoder/decoder.h b/third_party/aom/av1/decoder/decoder.h index 20129b6693..42fcc12569 100644 --- a/third_party/aom/av1/decoder/decoder.h +++ b/third_party/aom/av1/decoder/decoder.h @@ -12,7 +12,7 @@ #ifndef AV1_DECODER_DECODER_H_ #define AV1_DECODER_DECODER_H_ -#include "./aom_config.h" +#include "config/aom_config.h" #include "aom/aom_codec.h" #include "aom_dsp/bitreader.h" @@ -29,73 +29,61 @@ #include "av1/decoder/inspection.h" #endif -#if CONFIG_PVQ -#include "aom_dsp/entdec.h" -#include "av1/decoder/decint.h" -#include "av1/encoder/encodemb.h" -#endif - #ifdef __cplusplus extern "C" { #endif -// TODO(hkuang): combine this with TileWorkerData. -typedef struct TileData { - AV1_COMMON *cm; - aom_reader bit_reader; - DECLARE_ALIGNED(16, MACROBLOCKD, xd); +typedef struct ThreadData { + aom_reader *bit_reader; + DECLARE_ALIGNED(32, MACROBLOCKD, xd); /* dqcoeff are shared by all the planes. So planes must be decoded serially */ - DECLARE_ALIGNED(16, tran_low_t, dqcoeff[MAX_TX_SQUARE]); -#if CONFIG_PVQ - /* forward transformed predicted image, a reference for PVQ */ - DECLARE_ALIGNED(16, tran_low_t, pvq_ref_coeff[OD_TXSIZE_MAX * OD_TXSIZE_MAX]); -#endif -#if CONFIG_CFL - CFL_CTX cfl; -#endif - DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx); - DECLARE_ALIGNED(16, uint8_t, color_index_map[2][MAX_SB_SQUARE]); -#if CONFIG_MRC_TX - DECLARE_ALIGNED(16, uint8_t, mrc_mask[MAX_SB_SQUARE]); -#endif // CONFIG_MRC_TX -} TileData; - -typedef struct TileWorkerData { - struct AV1Decoder *pbi; + DECLARE_ALIGNED(32, tran_low_t, dqcoeff[MAX_TX_SQUARE]); + CB_BUFFER cb_buffer_base; + uint8_t *mc_buf[2]; + int32_t mc_buf_size; +} ThreadData; + +typedef struct TileDataDec { + TileInfo tile_info; aom_reader bit_reader; - FRAME_COUNTS counts; - DECLARE_ALIGNED(16, MACROBLOCKD, xd); - /* dqcoeff are shared by all the planes. So planes must be decoded serially */ - DECLARE_ALIGNED(16, tran_low_t, dqcoeff[MAX_TX_SQUARE]); -#if CONFIG_PVQ - /* forward transformed predicted image, a reference for PVQ */ - DECLARE_ALIGNED(16, tran_low_t, pvq_ref_coeff[OD_TXSIZE_MAX * OD_TXSIZE_MAX]); -#endif -#if CONFIG_CFL - CFL_CTX cfl; -#endif - FRAME_CONTEXT tctx; - DECLARE_ALIGNED(16, uint8_t, color_index_map[2][MAX_SB_SQUARE]); -#if CONFIG_MRC_TX - DECLARE_ALIGNED(16, uint8_t, mrc_mask[MAX_SB_SQUARE]); -#endif // CONFIG_MRC_TX - struct aom_internal_error_info error_info; -} TileWorkerData; + DECLARE_ALIGNED(16, FRAME_CONTEXT, tctx); +} TileDataDec; typedef struct TileBufferDec { const uint8_t *data; size_t size; - const uint8_t *raw_data_end; // The end of the raw tile buffer in the - // bit stream. - int col; // only used with multi-threaded decoding } TileBufferDec; -typedef struct AV1Decoder { - DECLARE_ALIGNED(16, MACROBLOCKD, mb); +typedef struct DataBuffer { + const uint8_t *data; + size_t size; +} DataBuffer; + +typedef struct EXTERNAL_REFERENCES { + YV12_BUFFER_CONFIG refs[MAX_EXTERNAL_REFERENCES]; + int num; +} EXTERNAL_REFERENCES; + +typedef struct TileJobsDec { + TileBufferDec *tile_buffer; + TileDataDec *tile_data; +} TileJobsDec; - DECLARE_ALIGNED(16, AV1_COMMON, common); +typedef struct AV1DecTileMTData { +#if CONFIG_MULTITHREAD + pthread_mutex_t *job_mutex; +#endif + TileJobsDec *job_queue; + int jobs_enqueued; + int jobs_dequeued; + int alloc_tile_rows; + int alloc_tile_cols; +} AV1DecTileMT; + +typedef struct AV1Decoder { + DECLARE_ALIGNED(32, MACROBLOCKD, mb); - int ready_for_new_data; + DECLARE_ALIGNED(32, AV1_COMMON, common); int refresh_frame_flags; @@ -105,20 +93,38 @@ typedef struct AV1Decoder { AVxWorker *frame_worker_owner; // frame_worker that owns this pbi. AVxWorker lf_worker; + AV1LfSync lf_row_sync; + AV1LrSync lr_row_sync; + AV1LrStruct lr_ctxt; AVxWorker *tile_workers; - TileWorkerData *tile_worker_data; - TileInfo *tile_worker_info; - int num_tile_workers; - - TileData *tile_data; + int num_workers; + DecWorkerData *thread_data; + ThreadData td; + TileDataDec *tile_data; int allocated_tiles; TileBufferDec tile_buffers[MAX_TILE_ROWS][MAX_TILE_COLS]; - - AV1LfSync lf_row_sync; - - aom_decrypt_cb decrypt_cb; - void *decrypt_state; + AV1DecTileMT tile_mt_info; + + // Each time the decoder is called, we expect to receive a full temporal unit. + // This can contain up to one shown frame per spatial layer in the current + // operating point (note that some layers may be entirely omitted). + // If the 'output_all_layers' option is true, we save all of these shown + // frames so that they can be returned to the application. If the + // 'output_all_layers' option is false, then we only output one image per + // temporal unit. + // + // Note: The saved buffers are released at the start of the next time the + // application calls aom_codec_decode(). + int output_all_layers; + YV12_BUFFER_CONFIG *output_frames[MAX_NUM_SPATIAL_LAYERS]; + size_t output_frame_index[MAX_NUM_SPATIAL_LAYERS]; // Buffer pool indices + size_t num_output_frames; // How many frames are queued up so far? + + // In order to properly support random-access decoding, we need + // to behave slightly differently for the very first frame we decode. + // So we track whether this is the first frame or not. + int decoding_first_frame; int allow_lowbitdepth; int max_threads; @@ -127,29 +133,47 @@ typedef struct AV1Decoder { int hold_ref_buf; // hold the reference buffer. int tile_size_bytes; -#if CONFIG_EXT_TILE int tile_col_size_bytes; int dec_tile_row, dec_tile_col; // always -1 for non-VR tile encoding -#endif // CONFIG_EXT_TILE #if CONFIG_ACCOUNTING int acct_enabled; Accounting accounting; #endif - size_t uncomp_hdr_size; // Size of the uncompressed header - size_t first_partition_size; // Size of the compressed header - int tg_size; // Number of tiles in the current tilegroup - int tg_start; // First tile in the current tilegroup + size_t uncomp_hdr_size; // Size of the uncompressed header + int tg_size; // Number of tiles in the current tilegroup + int tg_start; // First tile in the current tilegroup int tg_size_bit_offset; + int sequence_header_ready; #if CONFIG_INSPECTION aom_inspect_cb inspect_cb; void *inspect_ctx; #endif + int operating_point; + int current_operating_point; + int seen_frame_header; + + // State if the camera frame header is already decoded while + // large_scale_tile = 1. + int camera_frame_header_ready; + size_t frame_header_size; + DataBuffer obu_size_hdr; + int output_frame_width_in_tiles_minus_1; + int output_frame_height_in_tiles_minus_1; + int tile_count_minus_1; + uint32_t coded_tile_data_size; + unsigned int ext_tile_debug; // for ext-tile software debug & testing + EXTERNAL_REFERENCES ext_refs; + size_t tile_list_size; + uint8_t *tile_list_output; + size_t buffer_sz; } AV1Decoder; int av1_receive_compressed_data(struct AV1Decoder *pbi, size_t size, const uint8_t **dest); -int av1_get_raw_frame(struct AV1Decoder *pbi, YV12_BUFFER_CONFIG *sd); +// Get the frame at a particular index in the output queue +int av1_get_raw_frame(AV1Decoder *pbi, size_t index, YV12_BUFFER_CONFIG **sd, + aom_film_grain_t **grain_params); int av1_get_frame_to_show(struct AV1Decoder *pbi, YV12_BUFFER_CONFIG *frame); @@ -157,29 +181,16 @@ aom_codec_err_t av1_copy_reference_dec(struct AV1Decoder *pbi, int idx, YV12_BUFFER_CONFIG *sd); aom_codec_err_t av1_set_reference_dec(AV1_COMMON *cm, int idx, + int use_external_ref, YV12_BUFFER_CONFIG *sd); - -static INLINE uint8_t read_marker(aom_decrypt_cb decrypt_cb, - void *decrypt_state, const uint8_t *data) { - if (decrypt_cb) { - uint8_t marker; - decrypt_cb(decrypt_state, data, &marker, 1); - return marker; - } - return *data; -} - -// This function is exposed for use in tests, as well as the inlined function -// "read_marker". -aom_codec_err_t av1_parse_superframe_index(const uint8_t *data, size_t data_sz, - uint32_t sizes[8], int *count, - int *index_size, - aom_decrypt_cb decrypt_cb, - void *decrypt_state); +aom_codec_err_t av1_copy_new_frame_dec(AV1_COMMON *cm, + YV12_BUFFER_CONFIG *new_frame, + YV12_BUFFER_CONFIG *sd); struct AV1Decoder *av1_decoder_create(BufferPool *const pool); void av1_decoder_remove(struct AV1Decoder *pbi); +void av1_dealloc_dec_jobs(struct AV1DecTileMTData *tile_jobs_sync); static INLINE void decrease_ref_count(int idx, RefCntBuffer *const frame_bufs, BufferPool *const pool) { @@ -196,7 +207,6 @@ static INLINE void decrease_ref_count(int idx, RefCntBuffer *const frame_bufs, } } -#if CONFIG_EXT_REFS || CONFIG_TEMPMV_SIGNALING static INLINE int dec_is_ref_frame_buf(AV1Decoder *const pbi, RefCntBuffer *frame_buf) { AV1_COMMON *const cm = &pbi->common; @@ -208,7 +218,6 @@ static INLINE int dec_is_ref_frame_buf(AV1Decoder *const pbi, } return (i < INTER_REFS_PER_FRAME); } -#endif // CONFIG_EXT_REFS #define ACCT_STR __func__ static INLINE int av1_read_uniform(aom_reader *r, int n) { @@ -222,6 +231,13 @@ static INLINE int av1_read_uniform(aom_reader *r, int n) { return (v << 1) - m + aom_read_literal(r, 1, ACCT_STR); } +typedef void (*palette_visitor_fn_t)(MACROBLOCKD *const xd, int plane, + aom_reader *r); + +void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, int mi_row, + int mi_col, aom_reader *r, BLOCK_SIZE bsize, + palette_visitor_fn_t visit); + #ifdef __cplusplus } // extern "C" #endif diff --git a/third_party/aom/av1/decoder/decodetxb.c b/third_party/aom/av1/decoder/decodetxb.c index 13f944b356..f9a3e85780 100644 --- a/third_party/aom/av1/decoder/decodetxb.c +++ b/third_party/aom/av1/decoder/decodetxb.c @@ -9,28 +9,25 @@ * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ -#include "av1/common/scan.h" +#include "av1/decoder/decodetxb.h" + +#include "aom_ports/mem.h" #include "av1/common/idct.h" +#include "av1/common/scan.h" #include "av1/common/txb_common.h" #include "av1/decoder/decodemv.h" -#include "av1/decoder/decodetxb.h" -#include "av1/decoder/dsubexp.h" -#include "av1/decoder/symbolrate.h" #define ACCT_STR __func__ -static int read_golomb(MACROBLOCKD *xd, aom_reader *r, FRAME_COUNTS *counts) { -#if !CONFIG_SYMBOLRATE - (void)counts; -#endif +static int read_golomb(MACROBLOCKD *xd, aom_reader *r) { int x = 1; int length = 0; int i = 0; while (!i) { - i = av1_read_record_bit(counts, r, ACCT_STR); + i = aom_read_bit(r, ACCT_STR); ++length; - if (length >= 32) { + if (length > 20) { aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, "Invalid length in read_golomb"); break; @@ -39,570 +36,306 @@ static int read_golomb(MACROBLOCKD *xd, aom_reader *r, FRAME_COUNTS *counts) { for (i = 0; i < length - 1; ++i) { x <<= 1; - x += av1_read_record_bit(counts, r, ACCT_STR); + x += aom_read_bit(r, ACCT_STR); } return x - 1; } -static INLINE int read_nz_map(aom_reader *r, tran_low_t *tcoeffs, int plane, - const int16_t *scan, TX_SIZE tx_size, - TX_TYPE tx_type, FRAME_CONTEXT *fc, - FRAME_COUNTS *counts) { - TX_SIZE txs_ctx = get_txsize_context(tx_size); - const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2; - const int height = tx_size_high[tx_size]; -#if CONFIG_CTX1D - const int width = tx_size_wide[tx_size]; - const int eob_offset = width + height; - const TX_CLASS tx_class = get_tx_class(tx_type); - const int seg_eob = - (tx_class == TX_CLASS_2D) ? tx_size_2d[tx_size] : eob_offset; -#else - const int seg_eob = tx_size_2d[tx_size]; -#endif - const PLANE_TYPE plane_type = get_plane_type(plane); - unsigned int(*nz_map_count)[SIG_COEF_CONTEXTS][2] = - (counts) ? &counts->nz_map[txs_ctx][plane_type] : NULL; -#if !LV_MAP_PROB - aom_prob *nz_map = fc->nz_map[txs_ctx][plane_type]; - aom_prob *eob_flag = fc->eob_flag[txs_ctx][plane_type]; -#endif - int c; - for (c = 0; c < seg_eob; ++c) { - int is_nz; - int coeff_ctx = get_nz_map_ctx(tcoeffs, c, scan, bwl, height, tx_type); - int eob_ctx = get_eob_ctx(tcoeffs, scan[c], txs_ctx, tx_type); - - if (c < seg_eob - 1) { -#if LV_MAP_PROB - is_nz = av1_read_record_bin( - counts, r, fc->nz_map_cdf[txs_ctx][plane_type][coeff_ctx], 2, - ACCT_STR); -#else - is_nz = aom_read(r, nz_map[coeff_ctx], ACCT_STR); -#endif - } else { - is_nz = 1; - } - - // set non-zero coefficient map. - tcoeffs[scan[c]] = is_nz; - - if (c == seg_eob - 1) { - ++c; - break; - } - - if (counts) ++(*nz_map_count)[coeff_ctx][is_nz]; - - if (is_nz) { -#if LV_MAP_PROB - int is_eob = av1_read_record_bin( - counts, r, fc->eob_flag_cdf[txs_ctx][plane_type][eob_ctx], 2, - ACCT_STR); -#else - int is_eob = aom_read(r, eob_flag[eob_ctx], ACCT_STR); -#endif - if (counts) ++counts->eob_flag[txs_ctx][plane_type][eob_ctx][is_eob]; - if (is_eob) break; - } +static INLINE int rec_eob_pos(const int eob_token, const int extra) { + int eob = k_eob_group_start[eob_token]; + if (eob > 2) { + eob += extra; } - return AOMMIN(seg_eob, c + 1); + return eob; } -#if CONFIG_CTX1D -static INLINE int read_nz_map_vert(aom_reader *r, tran_low_t *tcoeffs, - int plane, const int16_t *scan, - const int16_t *iscan, TX_SIZE tx_size, - TX_TYPE tx_type, FRAME_CONTEXT *fc, - FRAME_COUNTS *counts) { - const TX_SIZE txs_ctx = get_txsize_context(tx_size); - const PLANE_TYPE plane_type = get_plane_type(plane); - const TX_CLASS tx_class = get_tx_class(tx_type); - const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2; - const int width = tx_size_wide[tx_size]; - const int height = tx_size_high[tx_size]; - int16_t eob_ls[MAX_HVTX_SIZE]; - int eob = 0; -#if !LV_MAP_PROB - aom_prob *nz_map = fc->nz_map[txs_ctx][plane_type]; -#endif - for (int col = 0; col < width; ++col) { - int el_ctx = get_empty_line_ctx(col, eob_ls); -#if LV_MAP_PROB - int empty_line = av1_read_record_bin( - counts, r, fc->empty_line_cdf[txs_ctx][plane_type][tx_class][el_ctx], 2, - ACCT_STR); -#else - int empty_line = aom_read( - r, fc->empty_line[txs_ctx][plane_type][tx_class][el_ctx], ACCT_STR); -#endif - if (counts) - ++counts->empty_line[txs_ctx][plane_type][tx_class][el_ctx][empty_line]; - if (!empty_line) { - int row; - for (row = 0; row < height; ++row) { - if (row + 1 != height) { - int coeff_idx = row * width + col; - int scan_idx = iscan[coeff_idx]; - int coeff_ctx = - get_nz_map_ctx(tcoeffs, scan_idx, scan, bwl, height, tx_type); -#if LV_MAP_PROB - int is_nz = av1_read_record_bin( - counts, r, fc->nz_map_cdf[txs_ctx][plane_type][coeff_ctx], 2, - ACCT_STR); -#else - int is_nz = aom_read(r, nz_map[coeff_ctx], ACCT_STR); -#endif - if (counts) ++counts->nz_map[txs_ctx][plane_type][coeff_ctx][is_nz]; - tcoeffs[coeff_idx] = is_nz; - if (is_nz) { - eob = AOMMAX(eob, iscan[coeff_idx] + 1); - if (row + 1 != height) { - int eob_ctx = get_hv_eob_ctx(col, row, eob_ls); -#if LV_MAP_PROB - int is_eob = av1_read_record_bin( - counts, r, - fc->hv_eob_cdf[txs_ctx][plane_type][tx_class][eob_ctx], 2, - ACCT_STR); -#else - int is_eob = aom_read( - r, fc->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx], - ACCT_STR); -#endif - if (counts) - ++counts - ->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx][is_eob]; - if (is_eob) break; - } - } - } else { - int coeff_idx = row * width + col; - tcoeffs[coeff_idx] = 1; - eob = AOMMAX(eob, iscan[coeff_idx] + 1); - } +static INLINE int get_dqv(const int16_t *dequant, int coeff_idx, + const qm_val_t *iqmatrix) { + int dqv = dequant[!!coeff_idx]; + if (iqmatrix != NULL) + dqv = + ((iqmatrix[coeff_idx] * dqv) + (1 << (AOM_QM_BITS - 1))) >> AOM_QM_BITS; + return dqv; +} + +static INLINE void read_coeffs_reverse_2d(aom_reader *r, TX_SIZE tx_size, + int start_si, int end_si, + const int16_t *scan, int bwl, + uint8_t *levels, + base_cdf_arr base_cdf, + br_cdf_arr br_cdf) { + for (int c = end_si; c >= start_si; --c) { + const int pos = scan[c]; + const int coeff_ctx = get_lower_levels_ctx_2d(levels, pos, bwl, tx_size); + const int nsymbs = 4; + int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR); + if (level > NUM_BASE_LEVELS) { + const int br_ctx = get_br_ctx_2d(levels, pos, bwl); + aom_cdf_prob *cdf = br_cdf[br_ctx]; + for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) { + const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR); + level += k; + if (k < BR_CDF_SIZE - 1) break; } - eob_ls[col] = AOMMIN(height, row + 1); - } else { - eob_ls[col] = 0; } + levels[get_padded_idx(pos, bwl)] = level; } - return eob; } -static INLINE int read_nz_map_horiz(aom_reader *r, tran_low_t *tcoeffs, - int plane, const int16_t *scan, - const int16_t *iscan, TX_SIZE tx_size, - TX_TYPE tx_type, FRAME_CONTEXT *fc, - FRAME_COUNTS *counts) { - const TX_SIZE txs_ctx = get_txsize_context(tx_size); - const PLANE_TYPE plane_type = get_plane_type(plane); - const TX_CLASS tx_class = get_tx_class(tx_type); - const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2; - const int width = tx_size_wide[tx_size]; - const int height = tx_size_high[tx_size]; - int16_t eob_ls[MAX_HVTX_SIZE]; - int eob = 0; -#if !LV_MAP_PROB - aom_prob *nz_map = fc->nz_map[txs_ctx][plane_type]; -#endif - for (int row = 0; row < height; ++row) { - int el_ctx = get_empty_line_ctx(row, eob_ls); -#if LV_MAP_PROB - int empty_line = av1_read_record_bin( - counts, r, fc->empty_line_cdf[txs_ctx][plane_type][tx_class][el_ctx], 2, - ACCT_STR); -#else - int empty_line = aom_read( - r, fc->empty_line[txs_ctx][plane_type][tx_class][el_ctx], ACCT_STR); -#endif - if (counts) - ++counts->empty_line[txs_ctx][plane_type][tx_class][el_ctx][empty_line]; - if (!empty_line) { - int col; - for (col = 0; col < width; ++col) { - if (col + 1 != width) { - int coeff_idx = row * width + col; - int scan_idx = iscan[coeff_idx]; - int coeff_ctx = - get_nz_map_ctx(tcoeffs, scan_idx, scan, bwl, height, tx_type); -#if LV_MAP_PROB - int is_nz = av1_read_record_bin( - counts, r, fc->nz_map_cdf[txs_ctx][plane_type][coeff_ctx], 2, - ACCT_STR); -#else - int is_nz = aom_read(r, nz_map[coeff_ctx], ACCT_STR); -#endif - if (counts) ++counts->nz_map[txs_ctx][plane_type][coeff_ctx][is_nz]; - tcoeffs[coeff_idx] = is_nz; - if (is_nz) { - eob = AOMMAX(eob, iscan[coeff_idx] + 1); - int eob_ctx = get_hv_eob_ctx(row, col, eob_ls); -#if LV_MAP_PROB - int is_eob = av1_read_record_bin( - counts, r, - fc->hv_eob_cdf[txs_ctx][plane_type][tx_class][eob_ctx], 2, - ACCT_STR); -#else - int is_eob = - aom_read(r, fc->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx], - ACCT_STR); -#endif - if (counts) - ++counts->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx][is_eob]; - if (is_eob) break; - } - } else { - int coeff_idx = row * width + col; - tcoeffs[coeff_idx] = 1; - eob = AOMMAX(eob, iscan[coeff_idx] + 1); - } +static INLINE void read_coeffs_reverse(aom_reader *r, TX_SIZE tx_size, + TX_CLASS tx_class, int start_si, + int end_si, const int16_t *scan, int bwl, + uint8_t *levels, base_cdf_arr base_cdf, + br_cdf_arr br_cdf) { + for (int c = end_si; c >= start_si; --c) { + const int pos = scan[c]; + const int coeff_ctx = + get_lower_levels_ctx(levels, pos, bwl, tx_size, tx_class); + const int nsymbs = 4; + int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR); + if (level > NUM_BASE_LEVELS) { + const int br_ctx = get_br_ctx(levels, pos, bwl, tx_class); + aom_cdf_prob *cdf = br_cdf[br_ctx]; + for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) { + const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR); + level += k; + if (k < BR_CDF_SIZE - 1) break; } - eob_ls[row] = AOMMIN(width, col + 1); - } else { - eob_ls[row] = 0; } + levels[get_padded_idx(pos, bwl)] = level; } - return eob; } -#endif -uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *xd, - aom_reader *r, int blk_row, int blk_col, int block, - int plane, tran_low_t *tcoeffs, TXB_CTX *txb_ctx, - TX_SIZE tx_size, int16_t *max_scan_line, int *eob) { - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - FRAME_COUNTS *counts = xd->counts; - TX_SIZE txs_ctx = get_txsize_context(tx_size); - PLANE_TYPE plane_type = get_plane_type(plane); -#if !LV_MAP_PROB - aom_prob *nz_map = ec_ctx->nz_map[txs_ctx][plane_type]; - aom_prob *eob_flag = ec_ctx->eob_flag[txs_ctx][plane_type]; -#endif - MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; - const int seg_eob = tx_size_2d[tx_size]; - int c = 0; - int update_eob = -1; - const int16_t *const dequant = xd->plane[plane].seg_dequant[mbmi->segment_id]; +uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd, + aom_reader *const r, const int blk_row, + const int blk_col, const int plane, + const TXB_CTX *const txb_ctx, + const TX_SIZE tx_size) { + FRAME_CONTEXT *const ec_ctx = xd->tile_ctx; + const int32_t max_value = (1 << (7 + xd->bd)) - 1; + const int32_t min_value = -(1 << (7 + xd->bd)); + const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size); + const PLANE_TYPE plane_type = get_plane_type(plane); + MB_MODE_INFO *const mbmi = xd->mi[0]; + struct macroblockd_plane *const pd = &xd->plane[plane]; + const int16_t *const dequant = pd->seg_dequant_QTX[mbmi->segment_id]; + tran_low_t *const tcoeffs = pd->dqcoeff_block + xd->cb_offset[plane]; const int shift = av1_get_tx_scale(tx_size); - const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2; - const int height = tx_size_high[tx_size]; + const int bwl = get_txb_bwl(tx_size); + const int width = get_txb_wide(tx_size); + const int height = get_txb_high(tx_size); int cul_level = 0; - memset(tcoeffs, 0, sizeof(*tcoeffs) * seg_eob); - -#if LV_MAP_PROB - int all_zero = av1_read_record_bin( - counts, r, ec_ctx->txb_skip_cdf[txs_ctx][txb_ctx->txb_skip_ctx], 2, - ACCT_STR); -#else - int all_zero = - aom_read(r, ec_ctx->txb_skip[txs_ctx][txb_ctx->txb_skip_ctx], ACCT_STR); -#endif - if (xd->counts) - ++xd->counts->txb_skip[txs_ctx][txb_ctx->txb_skip_ctx][all_zero]; - + int dc_val = 0; + uint8_t levels_buf[TX_PAD_2D]; + uint8_t *const levels = set_levels(levels_buf, width); + const int all_zero = aom_read_symbol( + r, ec_ctx->txb_skip_cdf[txs_ctx][txb_ctx->txb_skip_ctx], 2, ACCT_STR); + eob_info *eob_data = pd->eob_data + xd->txb_offset[plane]; + uint16_t *const eob = &(eob_data->eob); + uint16_t *const max_scan_line = &(eob_data->max_scan_line); + *max_scan_line = 0; *eob = 0; if (all_zero) { *max_scan_line = 0; -#if CONFIG_TXK_SEL - if (plane == 0) mbmi->txk_type[(blk_row << 4) + blk_col] = DCT_DCT; -#endif + if (plane == 0) { + const int txk_type_idx = + av1_get_txk_type_index(mbmi->sb_type, blk_row, blk_col); + mbmi->txk_type[txk_type_idx] = DCT_DCT; + } return 0; } - (void)blk_row; - (void)blk_col; -#if CONFIG_TXK_SEL - av1_read_tx_type(cm, xd, blk_row, blk_col, block, plane, - get_min_tx_size(tx_size), r); -#endif - const TX_TYPE tx_type = - av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, tx_size); - const SCAN_ORDER *const scan_order = get_scan(cm, tx_size, tx_type, mbmi); - const int16_t *scan = scan_order->scan; - -#if CONFIG_CTX1D - const int16_t *iscan = scan_order->iscan; - TX_CLASS tx_class = get_tx_class(tx_type); - if (tx_class == TX_CLASS_2D) { - *eob = - read_nz_map(r, tcoeffs, plane, scan, tx_size, tx_type, ec_ctx, counts); - } else { -#if LV_MAP_PROB - const int eob_mode = av1_read_record_bin( - counts, r, ec_ctx->eob_mode_cdf[txs_ctx][plane_type][tx_class], 2, - ACCT_STR); -#else - const int eob_mode = - aom_read(r, ec_ctx->eob_mode[txs_ctx][plane_type][tx_class], ACCT_STR); -#endif - if (counts) ++counts->eob_mode[txs_ctx][plane_type][tx_class][eob_mode]; - if (eob_mode == 0) { - *eob = read_nz_map(r, tcoeffs, plane, scan, tx_size, tx_type, ec_ctx, - counts); - } else { - assert(tx_class == TX_CLASS_VERT || tx_class == TX_CLASS_HORIZ); - if (tx_class == TX_CLASS_VERT) - *eob = read_nz_map_vert(r, tcoeffs, plane, scan, iscan, tx_size, - tx_type, ec_ctx, counts); - else - *eob = read_nz_map_horiz(r, tcoeffs, plane, scan, iscan, tx_size, - tx_type, ec_ctx, counts); - } + memset(levels_buf, 0, + sizeof(*levels_buf) * + ((width + TX_PAD_HOR) * (height + TX_PAD_VER) + TX_PAD_END)); + if (plane == AOM_PLANE_Y) { + // only y plane's tx_type is transmitted + av1_read_tx_type(cm, xd, blk_row, blk_col, tx_size, r); + } + const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, blk_row, blk_col, + tx_size, cm->reduced_tx_set_used); + const TX_CLASS tx_class = tx_type_to_class[tx_type]; + const TX_SIZE qm_tx_size = av1_get_adjusted_tx_size(tx_size); + const qm_val_t *iqmatrix = + IS_2D_TRANSFORM(tx_type) + ? pd->seg_iqmatrix[mbmi->segment_id][qm_tx_size] + : cm->giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; + const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type); + const int16_t *const scan = scan_order->scan; + int eob_extra = 0; + int eob_pt = 1; + + const int eob_multi_size = txsize_log2_minus4[tx_size]; + const int eob_multi_ctx = (tx_class == TX_CLASS_2D) ? 0 : 1; + switch (eob_multi_size) { + case 0: + eob_pt = + aom_read_symbol(r, ec_ctx->eob_flag_cdf16[plane_type][eob_multi_ctx], + 5, ACCT_STR) + + 1; + break; + case 1: + eob_pt = + aom_read_symbol(r, ec_ctx->eob_flag_cdf32[plane_type][eob_multi_ctx], + 6, ACCT_STR) + + 1; + break; + case 2: + eob_pt = + aom_read_symbol(r, ec_ctx->eob_flag_cdf64[plane_type][eob_multi_ctx], + 7, ACCT_STR) + + 1; + break; + case 3: + eob_pt = + aom_read_symbol(r, ec_ctx->eob_flag_cdf128[plane_type][eob_multi_ctx], + 8, ACCT_STR) + + 1; + break; + case 4: + eob_pt = + aom_read_symbol(r, ec_ctx->eob_flag_cdf256[plane_type][eob_multi_ctx], + 9, ACCT_STR) + + 1; + break; + case 5: + eob_pt = + aom_read_symbol(r, ec_ctx->eob_flag_cdf512[plane_type][eob_multi_ctx], + 10, ACCT_STR) + + 1; + break; + case 6: + default: + eob_pt = aom_read_symbol( + r, ec_ctx->eob_flag_cdf1024[plane_type][eob_multi_ctx], 11, + ACCT_STR) + + 1; + break; } -#else - *eob = read_nz_map(r, tcoeffs, plane, scan, tx_size, tx_type, ec_ctx, counts); -#endif - *max_scan_line = *eob; - - int i; - for (i = 0; i < NUM_BASE_LEVELS; ++i) { -#if !LV_MAP_PROB - aom_prob *coeff_base = ec_ctx->coeff_base[txs_ctx][plane_type][i]; -#endif - update_eob = 0; - for (c = *eob - 1; c >= 0; --c) { - tran_low_t *v = &tcoeffs[scan[c]]; - int sign; - int ctx; - - if (*v <= i) continue; - - ctx = get_base_ctx(tcoeffs, scan[c], bwl, height, i + 1); - -#if LV_MAP_PROB - if (av1_read_record_bin( - counts, r, ec_ctx->coeff_base_cdf[txs_ctx][plane_type][i][ctx], 2, - ACCT_STR)) -#else - if (aom_read(r, coeff_base[ctx], ACCT_STR)) -#endif - { - *v = i + 1; - cul_level += i + 1; - if (counts) ++counts->coeff_base[txs_ctx][plane_type][i][ctx][1]; + if (k_eob_offset_bits[eob_pt] > 0) { + const int eob_ctx = eob_pt - 3; + int bit = aom_read_symbol( + r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx], 2, ACCT_STR); + if (bit) { + eob_extra += (1 << (k_eob_offset_bits[eob_pt] - 1)); + } - if (c == 0) { - int dc_sign_ctx = txb_ctx->dc_sign_ctx; -#if LV_MAP_PROB - sign = av1_read_record_bin( - counts, r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx], 2, - ACCT_STR); -#else - sign = - aom_read(r, ec_ctx->dc_sign[plane_type][dc_sign_ctx], ACCT_STR); -#endif - if (counts) ++counts->dc_sign[plane_type][dc_sign_ctx][sign]; - } else { - sign = av1_read_record_bit(counts, r, ACCT_STR); - } - if (sign) *v = -(*v); - continue; + for (int i = 1; i < k_eob_offset_bits[eob_pt]; i++) { + bit = aom_read_bit(r, ACCT_STR); + if (bit) { + eob_extra += (1 << (k_eob_offset_bits[eob_pt] - 1 - i)); } - *v = i + 2; - if (counts) ++counts->coeff_base[txs_ctx][plane_type][i][ctx][0]; - - // update the eob flag for coefficients with magnitude above 1. - update_eob = AOMMAX(update_eob, c); } } - - for (c = update_eob; c >= 0; --c) { - tran_low_t *v = &tcoeffs[scan[c]]; - int sign; - int idx; - int ctx; - - if (*v <= NUM_BASE_LEVELS) continue; - - if (c == 0) { - int dc_sign_ctx = txb_ctx->dc_sign_ctx; -#if LV_MAP_PROB - sign = av1_read_record_bin( - counts, r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx], 2, ACCT_STR); -#else - sign = aom_read(r, ec_ctx->dc_sign[plane_type][dc_sign_ctx], ACCT_STR); -#endif - if (counts) ++counts->dc_sign[plane_type][dc_sign_ctx][sign]; + *eob = rec_eob_pos(eob_pt, eob_extra); + + { + // Read the non-zero coefficient with scan index eob-1 + // TODO(angiebird): Put this into a function + const int c = *eob - 1; + const int pos = scan[c]; + const int coeff_ctx = get_lower_levels_ctx_eob(bwl, height, c); + const int nsymbs = 3; + aom_cdf_prob *cdf = + ec_ctx->coeff_base_eob_cdf[txs_ctx][plane_type][coeff_ctx]; + int level = aom_read_symbol(r, cdf, nsymbs, ACCT_STR) + 1; + if (level > NUM_BASE_LEVELS) { + const int br_ctx = get_br_ctx(levels, pos, bwl, tx_class); + for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) { + const int k = aom_read_symbol( + r, + ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][br_ctx], + BR_CDF_SIZE, ACCT_STR); + level += k; + if (k < BR_CDF_SIZE - 1) break; + } + } + levels[get_padded_idx(pos, bwl)] = level; + } + if (*eob > 1) { + base_cdf_arr base_cdf = ec_ctx->coeff_base_cdf[txs_ctx][plane_type]; + br_cdf_arr br_cdf = + ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type]; + if (tx_class == TX_CLASS_2D) { + read_coeffs_reverse_2d(r, tx_size, 1, *eob - 1 - 1, scan, bwl, levels, + base_cdf, br_cdf); + read_coeffs_reverse(r, tx_size, tx_class, 0, 0, scan, bwl, levels, + base_cdf, br_cdf); } else { - sign = av1_read_record_bit(counts, r, ACCT_STR); + read_coeffs_reverse(r, tx_size, tx_class, 0, *eob - 1 - 1, scan, bwl, + levels, base_cdf, br_cdf); } + } - ctx = get_br_ctx(tcoeffs, scan[c], bwl, height); - -#if BR_NODE - for (idx = 0; idx < BASE_RANGE_SETS; ++idx) { -#if LV_MAP_PROB - if (av1_read_record_bin( - counts, r, ec_ctx->coeff_br_cdf[txs_ctx][plane_type][idx][ctx], 2, - ACCT_STR)) -#else // LV_MAP_PROB - if (aom_read(r, ec_ctx->coeff_br[txs_ctx][plane_type][idx][ctx], - ACCT_STR)) -#endif // LV_MAP_PROB - { - int extra_bits = (1 << br_extra_bits[idx]) - 1; - // int br_offset = aom_read_literal(r, extra_bits, ACCT_STR); - int br_offset = 0; - int tok; - if (counts) ++counts->coeff_br[txs_ctx][plane_type][idx][ctx][1]; - for (tok = 0; tok < extra_bits; ++tok) { -#if LV_MAP_PROB - if (av1_read_record_bin( - counts, r, ec_ctx->coeff_lps_cdf[txs_ctx][plane_type][ctx], 2, - ACCT_STR)) -#else - if (aom_read(r, ec_ctx->coeff_lps[txs_ctx][plane_type][ctx], - ACCT_STR)) -#endif - { - br_offset = tok; - if (counts) ++counts->coeff_lps[txs_ctx][plane_type][ctx][1]; - break; - } - if (counts) ++counts->coeff_lps[txs_ctx][plane_type][ctx][0]; - } - if (tok == extra_bits) br_offset = extra_bits; - - int br_base = br_index_to_coeff[idx]; - - *v = NUM_BASE_LEVELS + 1 + br_base + br_offset; - cul_level += *v; - if (sign) *v = -(*v); - break; + int16_t num_zero_coeffs = 0; + for (int c = 0; c < *eob; ++c) { + const int pos = scan[c]; + num_zero_coeffs = AOMMAX(num_zero_coeffs, pos); + } + memset(tcoeffs, 0, (num_zero_coeffs + 1) * sizeof(tcoeffs[0])); + + for (int c = 0; c < *eob; ++c) { + const int pos = scan[c]; + uint8_t sign; + tran_low_t level = levels[get_padded_idx(pos, bwl)]; + if (level) { + *max_scan_line = AOMMAX(*max_scan_line, pos); + if (c == 0) { + const int dc_sign_ctx = txb_ctx->dc_sign_ctx; + sign = aom_read_symbol(r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx], + 2, ACCT_STR); + } else { + sign = aom_read_bit(r, ACCT_STR); + } + if (level >= MAX_BASE_BR_RANGE) { + level += read_golomb(xd, r); } - if (counts) ++counts->coeff_br[txs_ctx][plane_type][idx][ctx][0]; - } - - if (idx < BASE_RANGE_SETS) continue; -#else - for (idx = 0; idx < COEFF_BASE_RANGE; ++idx) { -#if LV_MAP_PROB - if (av1_read_record_bin(counts, r, - ec_ctx->coeff_lps_cdf[txs_ctx][plane_type][ctx], - 2, ACCT_STR)) -#else - if (aom_read(r, ec_ctx->coeff_lps[txs_ctx][plane_type][ctx], ACCT_STR)) -#endif - { - *v = (idx + 1 + NUM_BASE_LEVELS); - if (sign) *v = -(*v); - cul_level += abs(*v); - if (counts) ++counts->coeff_lps[txs_ctx][plane_type][ctx][1]; - break; + if (c == 0) dc_val = sign ? -level : level; + + // Bitmasking to clamp level to valid range: + // The valid range for 8/10/12 bit vdieo is at most 14/16/18 bit + level &= 0xfffff; + cul_level += level; + tran_low_t dq_coeff; + // Bitmasking to clamp dq_coeff to valid range: + // The valid range for 8/10/12 bit video is at most 17/19/21 bit + dq_coeff = (tran_low_t)( + (int64_t)level * get_dqv(dequant, scan[c], iqmatrix) & 0xffffff); + dq_coeff = dq_coeff >> shift; + if (sign) { + dq_coeff = -dq_coeff; } - if (counts) ++counts->coeff_lps[txs_ctx][plane_type][ctx][0]; + tcoeffs[pos] = clamp(dq_coeff, min_value, max_value); } - if (idx < COEFF_BASE_RANGE) continue; -#endif - - // decode 0-th order Golomb code - *v = read_golomb(xd, r, counts) + COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS; - if (sign) *v = -(*v); - cul_level += abs(*v); - } - - for (c = 0; c < *eob; ++c) { - int16_t dqv = (c == 0) ? dequant[0] : dequant[1]; - tran_low_t *v = &tcoeffs[scan[c]]; -#if CONFIG_SYMBOLRATE - av1_record_coeff(counts, abs(*v)); -#endif - int sign = (*v) < 0; - *v = (abs(*v) * dqv) >> shift; - if (sign) *v = -(*v); } - cul_level = AOMMIN(63, cul_level); + cul_level = AOMMIN(COEFF_CONTEXT_MASK, cul_level); // DC value - set_dc_sign(&cul_level, tcoeffs[0]); + set_dc_sign(&cul_level, dc_val); return cul_level; } -uint8_t av1_read_coeffs_txb_facade(AV1_COMMON *cm, MACROBLOCKD *xd, - aom_reader *r, int row, int col, int block, - int plane, tran_low_t *tcoeffs, - TX_SIZE tx_size, int16_t *max_scan_line, - int *eob) { - MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; - struct macroblockd_plane *pd = &xd->plane[plane]; +uint8_t av1_read_coeffs_txb_facade(const AV1_COMMON *const cm, + MACROBLOCKD *const xd, aom_reader *const r, + const int row, const int col, + const int plane, const TX_SIZE tx_size) { + MB_MODE_INFO *const mbmi = xd->mi[0]; + struct macroblockd_plane *const pd = &xd->plane[plane]; const BLOCK_SIZE bsize = mbmi->sb_type; -#if CONFIG_CHROMA_SUB8X8 - const BLOCK_SIZE plane_bsize = - AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd)); -#elif CONFIG_CB4X4 - const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); -#else // CONFIG_CB4X4 const BLOCK_SIZE plane_bsize = - get_plane_block_size(AOMMAX(BLOCK_8X8, bsize), pd); -#endif // CONFIG_CB4X4 + get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y); TXB_CTX txb_ctx; get_txb_ctx(plane_bsize, tx_size, plane, pd->above_context + col, pd->left_context + row, &txb_ctx); - uint8_t cul_level = - av1_read_coeffs_txb(cm, xd, r, row, col, block, plane, tcoeffs, &txb_ctx, - tx_size, max_scan_line, eob); -#if CONFIG_ADAPT_SCAN - PLANE_TYPE plane_type = get_plane_type(plane); - TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, block, tx_size); - if (xd->counts && *eob > 0) - av1_update_scan_count_facade(cm, xd->counts, tx_size, tx_type, pd->dqcoeff, - *eob); -#endif - av1_set_contexts(xd, pd, plane, tx_size, cul_level, col, row); + const uint8_t cul_level = + av1_read_coeffs_txb(cm, xd, r, row, col, plane, &txb_ctx, tx_size); + av1_set_contexts(xd, pd, plane, plane_bsize, tx_size, cul_level, col, row); return cul_level; } - -#if !LV_MAP_PROB -static void read_txb_probs(FRAME_CONTEXT *fc, const TX_SIZE tx_size, - aom_reader *r, FRAME_COUNTS *counts) { -#if !CONFIG_SYMBOLRATE - (void)counts; -#endif - int plane, ctx, level; - - if (av1_read_record_bit(counts, r, ACCT_STR) == 0) return; - - for (ctx = 0; ctx < TXB_SKIP_CONTEXTS; ++ctx) - av1_diff_update_prob(r, &fc->txb_skip[tx_size][ctx], ACCT_STR); - - for (plane = 0; plane < PLANE_TYPES; ++plane) - for (ctx = 0; ctx < SIG_COEF_CONTEXTS; ++ctx) - av1_diff_update_prob(r, &fc->nz_map[tx_size][plane][ctx], ACCT_STR); - - for (plane = 0; plane < PLANE_TYPES; ++plane) - for (ctx = 0; ctx < EOB_COEF_CONTEXTS; ++ctx) - av1_diff_update_prob(r, &fc->eob_flag[tx_size][plane][ctx], ACCT_STR); - - for (level = 0; level < NUM_BASE_LEVELS; ++level) - for (plane = 0; plane < PLANE_TYPES; ++plane) - for (ctx = 0; ctx < COEFF_BASE_CONTEXTS; ++ctx) - av1_diff_update_prob(r, &fc->coeff_base[tx_size][plane][level][ctx], - ACCT_STR); - - for (plane = 0; plane < PLANE_TYPES; ++plane) - for (ctx = 0; ctx < LEVEL_CONTEXTS; ++ctx) - av1_diff_update_prob(r, &fc->coeff_lps[tx_size][plane][ctx], ACCT_STR); -} - -void av1_read_txb_probs(FRAME_CONTEXT *fc, TX_MODE tx_mode, aom_reader *r, - FRAME_COUNTS *counts) { - const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode]; - TX_SIZE tx_size; - int ctx, plane; - - for (plane = 0; plane < PLANE_TYPES; ++plane) - for (ctx = 0; ctx < DC_SIGN_CONTEXTS; ++ctx) - av1_diff_update_prob(r, &fc->dc_sign[plane][ctx], ACCT_STR); - - for (tx_size = TX_4X4; tx_size <= max_tx_size; ++tx_size) - read_txb_probs(fc, tx_size, r, counts); -} -#endif // !LV_MAP_PROB diff --git a/third_party/aom/av1/decoder/decodetxb.h b/third_party/aom/av1/decoder/decodetxb.h index 1c6512e970..d0b3d8c7ae 100644 --- a/third_party/aom/av1/decoder/decodetxb.h +++ b/third_party/aom/av1/decoder/decodetxb.h @@ -12,24 +12,21 @@ #ifndef DECODETXB_H_ #define DECODETXB_H_ -#include "./aom_config.h" +#include "config/aom_config.h" + #include "av1/common/blockd.h" #include "av1/common/onyxc_int.h" #include "av1/common/txb_common.h" #include "aom_dsp/bitreader.h" -uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *xd, - aom_reader *r, int blk_row, int blk_col, int block, - int plane, tran_low_t *tcoeffs, TXB_CTX *txb_ctx, - TX_SIZE tx_size, int16_t *max_scan_line, int *eob); +uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd, + aom_reader *const r, const int blk_row, + const int blk_col, const int plane, + const TXB_CTX *const txb_ctx, + const TX_SIZE tx_size); -uint8_t av1_read_coeffs_txb_facade(AV1_COMMON *cm, MACROBLOCKD *xd, - aom_reader *r, int row, int col, int block, - int plane, tran_low_t *tcoeffs, - TX_SIZE tx_size, int16_t *max_scan_line, - int *eob); -#if !LV_MAP_PROB -void av1_read_txb_probs(FRAME_CONTEXT *fc, TX_MODE tx_mode, aom_reader *r, - FRAME_COUNTS *counts); -#endif // !LV_MAP_PROB +uint8_t av1_read_coeffs_txb_facade(const AV1_COMMON *const cm, + MACROBLOCKD *const xd, aom_reader *const r, + const int row, const int col, + const int plane, const TX_SIZE tx_size); #endif // DECODETXB_H_ diff --git a/third_party/aom/av1/decoder/detokenize.c b/third_party/aom/av1/decoder/detokenize.c index a59a7bac15..9d54bd13dd 100644 --- a/third_party/aom/av1/decoder/detokenize.c +++ b/third_party/aom/av1/decoder/detokenize.c @@ -9,245 +9,18 @@ * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ -#include "./aom_config.h" -#if !CONFIG_PVQ +#include "config/aom_config.h" + #include "aom_mem/aom_mem.h" #include "aom_ports/mem.h" -#endif // !CONFIG_PVQ - #include "av1/common/blockd.h" #include "av1/decoder/detokenize.h" #define ACCT_STR __func__ -#if !CONFIG_PVQ || CONFIG_VAR_TX #include "av1/common/common.h" #include "av1/common/entropy.h" #include "av1/common/idct.h" -#endif - -#include "av1/decoder/symbolrate.h" - -#if !CONFIG_PVQ || CONFIG_VAR_TX -#define EOB_CONTEXT_NODE 0 -#define ZERO_CONTEXT_NODE 1 -#define ONE_CONTEXT_NODE 2 -#define LOW_VAL_CONTEXT_NODE 0 -#define TWO_CONTEXT_NODE 1 -#define THREE_CONTEXT_NODE 2 -#define HIGH_LOW_CONTEXT_NODE 3 -#define CAT_ONE_CONTEXT_NODE 4 -#define CAT_THREEFOUR_CONTEXT_NODE 5 -#define CAT_THREE_CONTEXT_NODE 6 -#define CAT_FIVE_CONTEXT_NODE 7 - -#define INCREMENT_COUNT(token) \ - do { \ - if (counts) ++coef_counts[band][ctx][token]; \ - } while (0) - -#if CONFIG_NEW_MULTISYMBOL -#define READ_COEFF(counts, prob_name, cdf_name, num, r) \ - read_coeff(counts, cdf_name, num, r); -static INLINE int read_coeff(FRAME_COUNTS *counts, - const aom_cdf_prob *const *cdf, int n, - aom_reader *r) { -#if !CONFIG_SYMBOLRATE - (void)counts; -#endif - int val = 0; - int i = 0; - int count = 0; - while (count < n) { - const int size = AOMMIN(n - count, 4); - val |= av1_read_record_cdf(counts, r, cdf[i++], 1 << size, ACCT_STR) - << count; - count += size; - } - return val; -} -#else -#define READ_COEFF(counts, prob_name, cdf_name, num, r) \ - read_coeff(counts, prob_name, num, r); -static INLINE int read_coeff(FRAME_COUNTS *counts, const aom_prob *probs, int n, - aom_reader *r) { -#if !CONFIG_SYMBOLRATE - (void)counts; -#endif - int i, val = 0; - for (i = 0; i < n; ++i) - val = (val << 1) | av1_read_record(counts, r, probs[i], ACCT_STR); - return val; -} - -#endif - -static int token_to_value(FRAME_COUNTS *counts, aom_reader *const r, int token, - TX_SIZE tx_size, int bit_depth) { -#if !CONFIG_HIGHBITDEPTH - assert(bit_depth == 8); -#endif // !CONFIG_HIGHBITDEPTH - - switch (token) { - case ZERO_TOKEN: - case ONE_TOKEN: - case TWO_TOKEN: - case THREE_TOKEN: - case FOUR_TOKEN: return token; - case CATEGORY1_TOKEN: - return CAT1_MIN_VAL + - READ_COEFF(counts, av1_cat1_prob, av1_cat1_cdf, 1, r); - case CATEGORY2_TOKEN: - return CAT2_MIN_VAL + - READ_COEFF(counts, av1_cat2_prob, av1_cat2_cdf, 2, r); - case CATEGORY3_TOKEN: - return CAT3_MIN_VAL + - READ_COEFF(counts, av1_cat3_prob, av1_cat3_cdf, 3, r); - case CATEGORY4_TOKEN: - return CAT4_MIN_VAL + - READ_COEFF(counts, av1_cat4_prob, av1_cat4_cdf, 4, r); - case CATEGORY5_TOKEN: - return CAT5_MIN_VAL + - READ_COEFF(counts, av1_cat5_prob, av1_cat5_cdf, 5, r); - case CATEGORY6_TOKEN: { - const int skip_bits = (int)sizeof(av1_cat6_prob) - - av1_get_cat6_extrabits_size(tx_size, bit_depth); - return CAT6_MIN_VAL + READ_COEFF(counts, av1_cat6_prob + skip_bits, - av1_cat6_cdf, 18 - skip_bits, r); - } - default: - assert(0); // Invalid token. - return -1; - } -} - -static int decode_coefs(MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff, - TX_SIZE tx_size, TX_TYPE tx_type, const int16_t *dq, -#if CONFIG_NEW_QUANT - dequant_val_type_nuq *dq_val, -#else -#if CONFIG_AOM_QM - qm_val_t *iqm[2][TX_SIZES_ALL], -#endif // CONFIG_AOM_QM -#endif // CONFIG_NEW_QUANT - int ctx, const int16_t *scan, const int16_t *nb, - int16_t *max_scan_line, aom_reader *r) { - FRAME_CONTEXT *ec_ctx = xd->tile_ctx; - const int max_eob = tx_size_2d[tx_size]; - const int ref = is_inter_block(&xd->mi[0]->mbmi); -#if CONFIG_AOM_QM && !CONFIG_NEW_QUANT - const qm_val_t *iqmatrix = iqm[!ref][tx_size]; -#endif // CONFIG_AOM_QM - (void)tx_type; - int band, c = 0; - const TX_SIZE tx_size_ctx = txsize_sqr_map[tx_size]; - aom_cdf_prob(*coef_head_cdfs)[COEFF_CONTEXTS][CDF_SIZE(ENTROPY_TOKENS)] = - ec_ctx->coef_head_cdfs[tx_size_ctx][type][ref]; - aom_cdf_prob(*coef_tail_cdfs)[COEFF_CONTEXTS][CDF_SIZE(ENTROPY_TOKENS)] = - ec_ctx->coef_tail_cdfs[tx_size_ctx][type][ref]; - int val = 0; - - uint8_t token_cache[MAX_TX_SQUARE]; - const uint8_t *band_translate = get_band_translate(tx_size); - int dq_shift; - int v, token; - int32_t dqv = dq[0]; -#if CONFIG_NEW_QUANT - const tran_low_t *dqv_val = &dq_val[0][0]; -#endif // CONFIG_NEW_QUANT - - dq_shift = av1_get_tx_scale(tx_size); - - band = *band_translate++; - - int more_data = 1; - while (more_data) { - int comb_token; - int last_pos = (c + 1 == max_eob); - int first_pos = (c == 0); - -#if CONFIG_NEW_QUANT - dqv_val = &dq_val[band][0]; -#endif // CONFIG_NEW_QUANT - - comb_token = last_pos ? 2 * av1_read_record_bit(xd->counts, r, ACCT_STR) + 2 - : av1_read_record_symbol( - xd->counts, r, coef_head_cdfs[band][ctx], - HEAD_TOKENS + first_pos, ACCT_STR) + - !first_pos; - if (first_pos) { - if (comb_token == 0) return 0; - } - token = comb_token >> 1; - - while (!token) { - *max_scan_line = AOMMAX(*max_scan_line, scan[c]); - token_cache[scan[c]] = 0; -#if CONFIG_SYMBOLRATE - av1_record_coeff(xd->counts, 0); -#endif - ++c; - dqv = dq[1]; - ctx = get_coef_context(nb, token_cache, c); - band = *band_translate++; - - last_pos = (c + 1 == max_eob); - - comb_token = - last_pos - ? 2 * av1_read_record_bit(xd->counts, r, ACCT_STR) + 2 - : av1_read_record_symbol(xd->counts, r, coef_head_cdfs[band][ctx], - HEAD_TOKENS, ACCT_STR) + - 1; - token = comb_token >> 1; - } - - more_data = comb_token & 1; - - if (token > ONE_TOKEN) - token += av1_read_record_symbol(xd->counts, r, coef_tail_cdfs[band][ctx], - TAIL_TOKENS, ACCT_STR); -#if CONFIG_NEW_QUANT - dqv_val = &dq_val[band][0]; -#endif // CONFIG_NEW_QUANT - - *max_scan_line = AOMMAX(*max_scan_line, scan[c]); - token_cache[scan[c]] = av1_pt_energy_class[token]; - - val = token_to_value(xd->counts, r, token, tx_size, xd->bd); -#if CONFIG_SYMBOLRATE - av1_record_coeff(xd->counts, val); -#endif - -#if CONFIG_NEW_QUANT - v = av1_dequant_abscoeff_nuq(val, dqv, dqv_val); - v = dq_shift ? ROUND_POWER_OF_TWO(v, dq_shift) : v; -#else -#if CONFIG_AOM_QM - // Apply quant matrix only for 2D transforms - if (IS_2D_TRANSFORM(tx_type) && iqmatrix != NULL) - dqv = ((iqmatrix[scan[c]] * (int)dqv) + (1 << (AOM_QM_BITS - 1))) >> - AOM_QM_BITS; -#endif - v = (val * dqv) >> dq_shift; -#endif - - v = (int)check_range(av1_read_record_bit(xd->counts, r, ACCT_STR) ? -v : v, - xd->bd); - - dqcoeff[scan[c]] = v; - - ++c; - more_data &= (c < max_eob); - if (!more_data) break; - dqv = dq[1]; - ctx = get_coef_context(nb, token_cache, c); - band = *band_translate++; - } - - return c; -} -#endif // !CONFIG_PVQ static void decode_color_map_tokens(Av1ColorMapParam *param, aom_reader *r) { uint8_t color_order[PALETTE_MAX_SIZE]; @@ -263,7 +36,6 @@ static void decode_color_map_tokens(Av1ColorMapParam *param, aom_reader *r) { color_map[0] = av1_read_uniform(r, n); assert(color_map[0] < n); -#if CONFIG_PALETTE_THROUGHPUT // Run wavefront on the palette map index decoding. for (int i = 1; i < rows + cols - 1; ++i) { for (int j = AOMMIN(i, cols - 1); j >= AOMMAX(0, i - rows + 1); --j) { @@ -283,21 +55,6 @@ static void decode_color_map_tokens(Av1ColorMapParam *param, aom_reader *r) { (plane_block_width - cols)); } } -#else - for (int i = 0; i < rows; ++i) { - for (int j = (i == 0 ? 1 : 0); j < cols; ++j) { - const int color_ctx = av1_get_palette_color_index_context( - color_map, plane_block_width, i, j, n, color_order, NULL); - const int color_idx = aom_read_symbol( - r, color_map_cdf[n - PALETTE_MIN_SIZE][color_ctx], n, ACCT_STR); - assert(color_idx >= 0 && color_idx < n); - color_map[i * plane_block_width + j] = color_order[color_idx]; - } - memset(color_map + i * plane_block_width + cols, - color_map[i * plane_block_width + cols - 1], - (plane_block_width - cols)); // Copy last column to extra columns. - } -#endif // CONFIG_PALETTE_THROUGHPUT // Copy last row to extra rows. for (int i = rows; i < plane_block_height; ++i) { memcpy(color_map + i * plane_block_width, @@ -305,97 +62,17 @@ static void decode_color_map_tokens(Av1ColorMapParam *param, aom_reader *r) { } } -static void get_palette_params(const MACROBLOCKD *const xd, int plane, - BLOCK_SIZE bsize, Av1ColorMapParam *params) { - assert(plane == 0 || plane == 1); - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; - const PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info; - params->color_map = xd->plane[plane].color_index_map; - params->map_cdf = plane ? xd->tile_ctx->palette_uv_color_index_cdf - : xd->tile_ctx->palette_y_color_index_cdf; - params->n_colors = pmi->palette_size[plane]; - av1_get_block_dimensions(bsize, plane, xd, ¶ms->plane_width, - ¶ms->plane_height, ¶ms->rows, ¶ms->cols); -} - -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK -static void get_mrc_params(const MACROBLOCKD *const xd, TX_SIZE tx_size, - Av1ColorMapParam *params) { - memset(params, 0, sizeof(*params)); - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; - const int is_inter = is_inter_block(mbmi); - params->color_map = xd->mrc_mask; - params->map_cdf = is_inter ? xd->tile_ctx->mrc_mask_inter_cdf - : xd->tile_ctx->mrc_mask_intra_cdf; - params->n_colors = 2; - params->plane_width = tx_size_wide[tx_size]; - params->rows = tx_size_high[tx_size]; - params->cols = tx_size_wide[tx_size]; -} -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - void av1_decode_palette_tokens(MACROBLOCKD *const xd, int plane, aom_reader *r) { - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; assert(plane == 0 || plane == 1); - assert(mbmi->sb_type >= BLOCK_8X8); - Av1ColorMapParam color_map_params; - memset(&color_map_params, 0, sizeof(color_map_params)); - get_palette_params(xd, plane, mbmi->sb_type, &color_map_params); - decode_color_map_tokens(&color_map_params, r); -} - -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK -static void decode_mrc_tokens(MACROBLOCKD *const xd, TX_TYPE tx_size, - aom_reader *r) { - const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; - const int is_inter = is_inter_block(mbmi); - if ((is_inter && !SIGNAL_MRC_MASK_INTER) || - (!is_inter && !SIGNAL_MRC_MASK_INTRA)) - return; - Av1ColorMapParam color_map_params; - get_mrc_params(xd, tx_size, &color_map_params); - decode_color_map_tokens(&color_map_params, r); -} -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - -#if !CONFIG_PVQ || CONFIG_VAR_TX -int av1_decode_block_tokens(AV1_COMMON *cm, MACROBLOCKD *const xd, int plane, - const SCAN_ORDER *sc, int x, int y, TX_SIZE tx_size, - TX_TYPE tx_type, int16_t *max_scan_line, - aom_reader *r, int seg_id) { - struct macroblockd_plane *const pd = &xd->plane[plane]; - const int16_t *const dequant = pd->seg_dequant[seg_id]; - const int ctx = - get_entropy_context(tx_size, pd->above_context + x, pd->left_context + y); -#if CONFIG_NEW_QUANT - const int ref = is_inter_block(&xd->mi[0]->mbmi); - int dq = - get_dq_profile_from_ctx(xd->qindex[seg_id], ctx, ref, pd->plane_type); -#endif // CONFIG_NEW_QUANT - -#if CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - if (tx_type == MRC_DCT) decode_mrc_tokens(xd, tx_size, r); -#endif // CONFIG_MRC_TX && SIGNAL_ANY_MRC_MASK - - const int eob = - decode_coefs(xd, pd->plane_type, pd->dqcoeff, tx_size, tx_type, dequant, -#if CONFIG_NEW_QUANT - pd->seg_dequant_nuq[seg_id][dq], -#else -#if CONFIG_AOM_QM - pd->seg_iqmatrix[seg_id], -#endif // CONFIG_AOM_QM -#endif // CONFIG_NEW_QUANT - ctx, sc->scan, sc->neighbors, max_scan_line, r); - av1_set_contexts(xd, pd, plane, tx_size, eob > 0, x, y); -#if CONFIG_ADAPT_SCAN - if (xd->counts) - av1_update_scan_count_facade(cm, xd->counts, tx_size, tx_type, pd->dqcoeff, - eob); -#else - (void)cm; -#endif - return eob; + Av1ColorMapParam params; + params.color_map = + xd->plane[plane].color_index_map + xd->color_index_map_offset[plane]; + params.map_cdf = plane ? xd->tile_ctx->palette_uv_color_index_cdf + : xd->tile_ctx->palette_y_color_index_cdf; + const MB_MODE_INFO *const mbmi = xd->mi[0]; + params.n_colors = mbmi->palette_mode_info.palette_size[plane]; + av1_get_block_dimensions(mbmi->sb_type, plane, xd, ¶ms.plane_width, + ¶ms.plane_height, ¶ms.rows, ¶ms.cols); + decode_color_map_tokens(¶ms, r); } -#endif // !CONFIG_PVQ diff --git a/third_party/aom/av1/decoder/detokenize.h b/third_party/aom/av1/decoder/detokenize.h index eb31d58c6b..ec85bf7eae 100644 --- a/third_party/aom/av1/decoder/detokenize.h +++ b/third_party/aom/av1/decoder/detokenize.h @@ -12,10 +12,9 @@ #ifndef AV1_DECODER_DETOKENIZE_H_ #define AV1_DECODER_DETOKENIZE_H_ -#include "./aom_config.h" -#if !CONFIG_PVQ || CONFIG_VAR_TX +#include "config/aom_config.h" + #include "av1/common/scan.h" -#endif // !CONFIG_PVQ || CONFIG_VAR_TX #include "av1/decoder/decoder.h" #ifdef __cplusplus @@ -24,12 +23,6 @@ extern "C" { void av1_decode_palette_tokens(MACROBLOCKD *const xd, int plane, aom_reader *r); -#if !CONFIG_PVQ || CONFIG_VAR_TX -int av1_decode_block_tokens(AV1_COMMON *cm, MACROBLOCKD *const xd, int plane, - const SCAN_ORDER *sc, int x, int y, TX_SIZE tx_size, - TX_TYPE tx_type, int16_t *max_scan_line, - aom_reader *r, int seg_id); -#endif // !CONFIG_PVQ #ifdef __cplusplus } // extern "C" #endif diff --git a/third_party/aom/av1/decoder/dsubexp.c b/third_party/aom/av1/decoder/dsubexp.c deleted file mode 100644 index 5171f1144e..0000000000 --- a/third_party/aom/av1/decoder/dsubexp.c +++ /dev/null @@ -1,82 +0,0 @@ -/* - * 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 "av1/common/entropy.h" - -#include "av1/decoder/dsubexp.h" - -static int inv_recenter_nonneg(int v, int m) { - if (v > 2 * m) return v; - - return (v & 1) ? m - ((v + 1) >> 1) : m + (v >> 1); -} - -#define decode_uniform(r, ACCT_STR_NAME) \ - decode_uniform_(r ACCT_STR_ARG(ACCT_STR_NAME)) -#define decode_term_subexp(r, ACCT_STR_NAME) \ - decode_term_subexp_(r ACCT_STR_ARG(ACCT_STR_NAME)) - -static int decode_uniform_(aom_reader *r ACCT_STR_PARAM) { - const int l = 8; - const int m = (1 << l) - 190; - const int v = aom_read_literal(r, l - 1, ACCT_STR_NAME); - return v < m ? v : (v << 1) - m + aom_read_bit(r, ACCT_STR_NAME); -} - -static int inv_remap_prob(int v, int m) { - /* clang-format off */ - static uint8_t inv_map_table[MAX_PROB - 1] = { - 7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176, 189, - 202, 215, 228, 241, 254, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253 - }; /* clang-format on */ - assert(v < (int)(sizeof(inv_map_table) / sizeof(inv_map_table[0]))); - v = inv_map_table[v]; - m--; - if ((m << 1) <= MAX_PROB) { - return 1 + inv_recenter_nonneg(v, m); - } else { - return MAX_PROB - inv_recenter_nonneg(v, MAX_PROB - 1 - m); - } -} - -static int decode_term_subexp_(aom_reader *r ACCT_STR_PARAM) { - if (!aom_read_bit(r, ACCT_STR_NAME)) - return aom_read_literal(r, 4, ACCT_STR_NAME); - if (!aom_read_bit(r, ACCT_STR_NAME)) - return aom_read_literal(r, 4, ACCT_STR_NAME) + 16; - if (!aom_read_bit(r, ACCT_STR_NAME)) - return aom_read_literal(r, 5, ACCT_STR_NAME) + 32; - return decode_uniform(r, ACCT_STR_NAME) + 64; -} - -void av1_diff_update_prob_(aom_reader *r, aom_prob *p ACCT_STR_PARAM) { - if (aom_read(r, DIFF_UPDATE_PROB, ACCT_STR_NAME)) { - const int delp = decode_term_subexp(r, ACCT_STR_NAME); - *p = (aom_prob)inv_remap_prob(delp, *p); - } -} diff --git a/third_party/aom/av1/decoder/dsubexp.h b/third_party/aom/av1/decoder/dsubexp.h deleted file mode 100644 index 4bc38578c9..0000000000 --- a/third_party/aom/av1/decoder/dsubexp.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * 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. - */ - -#ifndef AV1_DECODER_DSUBEXP_H_ -#define AV1_DECODER_DSUBEXP_H_ - -#include "aom_dsp/bitreader.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if CONFIG_ACCOUNTING -#define av1_diff_update_prob(r, p, str) av1_diff_update_prob_(r, p, str) -#else -#define av1_diff_update_prob(r, p, str) av1_diff_update_prob_(r, p) -#endif - -void av1_diff_update_prob_(aom_reader *r, aom_prob *p ACCT_STR_PARAM); - -#ifdef __cplusplus -} // extern "C" -#endif -#endif // AV1_DECODER_DSUBEXP_H_ diff --git a/third_party/aom/av1/decoder/dthread.c b/third_party/aom/av1/decoder/dthread.c index 7f16b233ca..ff03502e62 100644 --- a/third_party/aom/av1/decoder/dthread.c +++ b/third_party/aom/av1/decoder/dthread.c @@ -9,7 +9,8 @@ * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ -#include "./aom_config.h" +#include "config/aom_config.h" + #include "aom_mem/aom_mem.h" #include "av1/common/reconinter.h" #include "av1/decoder/dthread.h" @@ -157,12 +158,8 @@ void av1_frameworker_copy_context(AVxWorker *const dst_worker, av1_frameworker_unlock_stats(src_worker); dst_cm->bit_depth = src_cm->bit_depth; -#if CONFIG_HIGHBITDEPTH dst_cm->use_highbitdepth = src_cm->use_highbitdepth; -#endif -#if CONFIG_EXT_REFS -// TODO(zoeliu): To handle parallel decoding -#endif // CONFIG_EXT_REFS + // TODO(zoeliu): To handle parallel decoding dst_cm->prev_frame = src_cm->show_existing_frame ? src_cm->prev_frame : src_cm->cur_frame; dst_cm->last_width = @@ -180,14 +177,10 @@ void av1_frameworker_copy_context(AVxWorker *const dst_worker, memcpy(dst_cm->lf_info.lfthr, src_cm->lf_info.lfthr, (MAX_LOOP_FILTER + 1) * sizeof(loop_filter_thresh)); - dst_cm->lf.last_sharpness_level = src_cm->lf.sharpness_level; -#if CONFIG_LOOPFILTER_LEVEL + dst_cm->lf.sharpness_level = src_cm->lf.sharpness_level; dst_cm->lf.filter_level[0] = src_cm->lf.filter_level[0]; dst_cm->lf.filter_level[1] = src_cm->lf.filter_level[1]; -#else - dst_cm->lf.filter_level = src_cm->lf.filter_level; -#endif - memcpy(dst_cm->lf.ref_deltas, src_cm->lf.ref_deltas, TOTAL_REFS_PER_FRAME); + memcpy(dst_cm->lf.ref_deltas, src_cm->lf.ref_deltas, REF_FRAMES); memcpy(dst_cm->lf.mode_deltas, src_cm->lf.mode_deltas, MAX_MODE_LF_DELTAS); dst_cm->seg = src_cm->seg; memcpy(dst_cm->frame_contexts, src_cm->frame_contexts, diff --git a/third_party/aom/av1/decoder/dthread.h b/third_party/aom/av1/decoder/dthread.h index c17053d9c2..33d89006e7 100644 --- a/third_party/aom/av1/decoder/dthread.h +++ b/third_party/aom/av1/decoder/dthread.h @@ -12,7 +12,8 @@ #ifndef AV1_DECODER_DTHREAD_H_ #define AV1_DECODER_DTHREAD_H_ -#include "./aom_config.h" +#include "config/aom_config.h" + #include "aom_util/aom_thread.h" #include "aom/internal/aom_codec_internal.h" @@ -22,6 +23,13 @@ extern "C" { struct AV1Common; struct AV1Decoder; +struct ThreadData; + +typedef struct DecWorkerData { + struct ThreadData *td; + const uint8_t *data_end; + struct aom_internal_error_info error_info; +} DecWorkerData; // WorkerData for the FrameWorker thread. It contains all the information of // the worker and decode structures for decoding a frame. diff --git a/third_party/aom/av1/decoder/generic_decoder.c b/third_party/aom/av1/decoder/generic_decoder.c deleted file mode 100644 index 0c7d71b9fc..0000000000 --- a/third_party/aom/av1/decoder/generic_decoder.c +++ /dev/null @@ -1,110 +0,0 @@ -/* - * Copyright (c) 2001-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. - */ - -/* clang-format off */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include <stdio.h> - -#include "aom_dsp/bitreader.h" -#include "av1/common/generic_code.h" -#include "av1/common/odintrin.h" -#include "pvq_decoder.h" - -/** Decodes a value from 0 to N-1 (with N up to 16) based on a cdf and adapts - * the cdf accordingly. - * - * @param [in,out] r multi-symbol entropy decoder - * @param [in,out] cdf CDF of the variable (Q15) - * @param [in] n number of values possible - * @param [in,out] count number of symbols encoded with that cdf so far - * @param [in] rate adaptation rate shift (smaller is faster) - * @return decoded variable - */ -int aom_decode_cdf_adapt_q15_(aom_reader *r, uint16_t *cdf, int n, - int *count, int rate ACCT_STR_PARAM) { - int val; - int i; - if (*count == 0) { - int ft; - ft = cdf[n - 1]; - for (i = 0; i < n; i++) { - cdf[i] = AOM_ICDF(cdf[i]*32768/ft); - } - } - val = aom_read_cdf(r, cdf, n, ACCT_STR_NAME); - aom_cdf_adapt_q15(val, cdf, n, count, rate); - return val; -} - -/** Encodes a random variable using a "generic" model, assuming that the - * distribution is one-sided (zero and up), has a single mode, and decays - * exponentially past the model. - * - * @param [in,out] r multi-symbol entropy decoder - * @param [in,out] model generic probability model - * @param [in] x variable being encoded - * @param [in,out] ExQ16 expectation of x (adapted) - * @param [in] integration integration period of ExQ16 (leaky average over - * 1<<integration samples) - * - * @retval decoded variable x - */ -int generic_decode_(aom_reader *r, generic_encoder *model, - int *ex_q16, int integration ACCT_STR_PARAM) { - int lg_q1; - int shift; - int id; - uint16_t *cdf; - int xs; - int lsb; - int x; - lsb = 0; - lg_q1 = log_ex(*ex_q16); - /* If expectation is too large, shift x to ensure that - all we have past xs=15 is the exponentially decaying tail - of the distribution. */ - shift = OD_MAXI(0, (lg_q1 - 5) >> 1); - /* Choose the cdf to use: we have two per "octave" of ExQ16. */ - id = OD_MINI(GENERIC_TABLES - 1, lg_q1); - cdf = model->cdf[id]; - xs = aom_read_symbol_pvq(r, cdf, 16, ACCT_STR_NAME); - if (xs == 15) { - int e; - unsigned decay; - /* Estimate decay based on the assumption that the distribution is close - to Laplacian for large values. We should probably have an adaptive - estimate instead. Note: The 2* is a kludge that's not fully understood - yet. */ - OD_ASSERT(*ex_q16 < INT_MAX >> 1); - e = ((2**ex_q16 >> 8) + (1 << shift >> 1)) >> shift; - decay = OD_MAXI(2, OD_MINI(254, 256*e/(e + 256))); - xs += aom_laplace_decode_special(r, decay, ACCT_STR_NAME); - } - if (shift != 0) { - int special; - /* Because of the rounding, there's only half the number of possibilities - for xs=0 */ - special = xs == 0; - if (shift - special > 0) { - lsb = aom_read_literal(r, shift - special, ACCT_STR_NAME); - } - lsb -= !special << (shift - 1); - } - x = (xs << shift) + lsb; - generic_model_update(ex_q16, x, integration); - OD_LOG((OD_LOG_ENTROPY_CODER, OD_LOG_DEBUG, - "dec: %d %d %d %d %d %x", *ex_q16, x, shift, id, xs, dec->rng)); - return x; -} diff --git a/third_party/aom/av1/decoder/inspection.c b/third_party/aom/av1/decoder/inspection.c index 98c51d4ba0..e6c89298a4 100644 --- a/third_party/aom/av1/decoder/inspection.c +++ b/third_party/aom/av1/decoder/inspection.c @@ -11,12 +11,7 @@ #include "av1/decoder/decoder.h" #include "av1/decoder/inspection.h" #include "av1/common/enums.h" -#if CONFIG_CDEF #include "av1/common/cdef.h" -#endif -#if CONFIG_CFL -#include "av1/common/cfl.h" -#endif static void ifd_init_mi_rc(insp_frame_data *fd, int mi_cols, int mi_rows) { fd->mi_cols = mi_cols; @@ -48,25 +43,29 @@ int ifd_inspect(insp_frame_data *fd, void *decoder) { fd->show_frame = cm->show_frame; fd->frame_type = cm->frame_type; fd->base_qindex = cm->base_qindex; - fd->tile_mi_cols = cm->tile_width; - fd->tile_mi_rows = cm->tile_height; + // Set width and height of the first tile until generic support can be added + TileInfo tile_info; + av1_tile_set_row(&tile_info, cm, 0); + av1_tile_set_col(&tile_info, cm, 0); + fd->tile_mi_cols = tile_info.mi_col_end - tile_info.mi_col_start; + fd->tile_mi_rows = tile_info.mi_row_end - tile_info.mi_row_start; + fd->delta_q_present_flag = cm->delta_q_present_flag; + fd->delta_q_res = cm->delta_q_res; #if CONFIG_ACCOUNTING fd->accounting = &pbi->accounting; #endif -#if CONFIG_CDEF -// TODO(negge): copy per frame CDEF data -#endif + // TODO(negge): copy per frame CDEF data int i, j; for (i = 0; i < MAX_SEGMENTS; i++) { for (j = 0; j < 2; j++) { - fd->y_dequant[i][j] = cm->y_dequant[i][j]; - fd->uv_dequant[i][j] = cm->uv_dequant[i][j]; + fd->y_dequant[i][j] = cm->y_dequant_QTX[i][j]; + fd->u_dequant[i][j] = cm->u_dequant_QTX[i][j]; + fd->v_dequant[i][j] = cm->v_dequant_QTX[i][j]; } } for (j = 0; j < cm->mi_rows; j++) { for (i = 0; i < cm->mi_cols; i++) { - const MB_MODE_INFO *mbmi = - &cm->mi_grid_visible[j * cm->mi_stride + i]->mbmi; + const MB_MODE_INFO *mbmi = cm->mi_grid_visible[j * cm->mi_stride + i]; insp_mi_data *mi = &fd->mi_grid[j * cm->mi_cols + i]; // Segment mi->segment_id = mbmi->segment_id; @@ -90,24 +89,19 @@ int ifd_inspect(insp_frame_data *fd, void *decoder) { mi->sb_type = mbmi->sb_type; // Skip Flag mi->skip = mbmi->skip; -#if CONFIG_DUAL_FILTER mi->filter[0] = av1_extract_interp_filter(mbmi->interp_filters, 0); mi->filter[1] = av1_extract_interp_filter(mbmi->interp_filters, 1); -#else - mi->filter = av1_extract_interp_filter(mbmi->interp_filters, 0); -#endif + mi->dual_filter_type = mi->filter[0] * 3 + mi->filter[1]; // Transform - mi->tx_type = mbmi->tx_type; + // TODO(anyone): extract tx type info from mbmi->txk_type[]. + mi->tx_type = DCT_DCT; mi->tx_size = mbmi->tx_size; -#if CONFIG_CDEF mi->cdef_level = cm->cdef_strengths[mbmi->cdef_strength] / CDEF_SEC_STRENGTHS; mi->cdef_strength = cm->cdef_strengths[mbmi->cdef_strength] % CDEF_SEC_STRENGTHS; mi->cdef_strength += mi->cdef_strength == 3; -#endif -#if CONFIG_CFL if (mbmi->uv_mode == UV_CFL_PRED) { mi->cfl_alpha_idx = mbmi->cfl_alpha_idx; mi->cfl_alpha_sign = mbmi->cfl_alpha_signs; @@ -115,7 +109,8 @@ int ifd_inspect(insp_frame_data *fd, void *decoder) { mi->cfl_alpha_idx = 0; mi->cfl_alpha_sign = 0; } -#endif + // delta_q + mi->current_qindex = mbmi->current_qindex; } } return 1; diff --git a/third_party/aom/av1/decoder/inspection.h b/third_party/aom/av1/decoder/inspection.h index 06a94b7370..bb604f684b 100644 --- a/third_party/aom/av1/decoder/inspection.h +++ b/third_party/aom/av1/decoder/inspection.h @@ -20,7 +20,9 @@ extern "C" { #include "av1/decoder/accounting.h" #endif +#ifndef AOM_AOMDX_H_ typedef void (*aom_inspect_cb)(void *decoder, void *data); +#endif typedef struct insp_mv insp_mv; @@ -33,27 +35,21 @@ typedef struct insp_mi_data insp_mi_data; struct insp_mi_data { insp_mv mv[2]; - int8_t ref_frame[2]; - int8_t mode; - int8_t uv_mode; - int8_t sb_type; - int8_t skip; - int8_t segment_id; -#if CONFIG_DUAL_FILTER - int8_t filter[2]; -#else - int8_t filter; -#endif - int8_t tx_type; - int8_t tx_size; -#if CONFIG_CDEF - int8_t cdef_level; - int8_t cdef_strength; -#endif -#if CONFIG_CFL - int8_t cfl_alpha_idx; - int8_t cfl_alpha_sign; -#endif + int16_t ref_frame[2]; + int16_t mode; + int16_t uv_mode; + int16_t sb_type; + int16_t skip; + int16_t segment_id; + int16_t dual_filter_type; + int16_t filter[2]; + int16_t tx_type; + int16_t tx_size; + int16_t cdef_level; + int16_t cdef_strength; + int16_t cfl_alpha_idx; + int16_t cfl_alpha_sign; + int16_t current_qindex; }; typedef struct insp_frame_data insp_frame_data; @@ -71,10 +67,11 @@ struct insp_frame_data { int tile_mi_rows; int tile_mi_cols; int16_t y_dequant[MAX_SEGMENTS][2]; - int16_t uv_dequant[MAX_SEGMENTS][2]; -#if CONFIG_CDEF -// TODO(negge): add per frame CDEF data -#endif + int16_t u_dequant[MAX_SEGMENTS][2]; + int16_t v_dequant[MAX_SEGMENTS][2]; + // TODO(negge): add per frame CDEF data + int delta_q_present_flag; + int delta_q_res; }; void ifd_init(insp_frame_data *fd, int frame_width, int frame_height); diff --git a/third_party/aom/av1/decoder/laplace_decoder.c b/third_party/aom/av1/decoder/laplace_decoder.c deleted file mode 100644 index 5cc080ea72..0000000000 --- a/third_party/aom/av1/decoder/laplace_decoder.c +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Copyright (c) 2001-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. - */ -/* clang-format off */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include <stdio.h> - -#include "aom_dsp/bitreader.h" -#include "av1/common/pvq.h" -#include "pvq_decoder.h" - -#define aom_decode_pvq_split(r, adapt, sum, ctx, ACCT_STR_NAME) \ - aom_decode_pvq_split_(r, adapt, sum, ctx ACCT_STR_ARG(ACCT_STR_NAME)) - -static int aom_decode_pvq_split_(aom_reader *r, od_pvq_codeword_ctx *adapt, - int sum, int ctx ACCT_STR_PARAM) { - int shift; - int count; - int msbs; - int fctx; - count = 0; - if (sum == 0) return 0; - shift = OD_MAXI(0, OD_ILOG(sum) - 3); - fctx = 7*ctx + (sum >> shift) - 1; - msbs = aom_read_symbol_pvq(r, adapt->pvq_split_cdf[fctx], (sum >> shift) + 1, - ACCT_STR_NAME); - if (shift) count = aom_read_literal(r, shift, ACCT_STR_NAME); - count += msbs << shift; - if (count > sum) { - count = sum; -#if !CONFIG_ANS - r->ec.error = 1; -#else -# error "CONFIG_PVQ currently requires !CONFIG_ANS." -#endif - } - return count; -} - -void aom_decode_band_pvq_splits(aom_reader *r, od_pvq_codeword_ctx *adapt, - od_coeff *y, int n, int k, int level) { - int mid; - int count_right; - if (n == 1) { - y[0] = k; - } - else if (k == 0) { - OD_CLEAR(y, n); - } - else if (k == 1 && n <= 16) { - int cdf_id; - int pos; - cdf_id = od_pvq_k1_ctx(n, level == 0); - OD_CLEAR(y, n); - pos = aom_read_symbol_pvq(r, adapt->pvq_k1_cdf[cdf_id], n, "pvq:k1"); - y[pos] = 1; - } - else { - mid = n >> 1; - count_right = aom_decode_pvq_split(r, adapt, k, od_pvq_size_ctx(n), - "pvq:split"); - aom_decode_band_pvq_splits(r, adapt, y, mid, k - count_right, level + 1); - aom_decode_band_pvq_splits(r, adapt, y + mid, n - mid, count_right, - level + 1); - } -} - -/** Decodes the tail of a Laplace-distributed variable, i.e. it doesn't - * do anything special for the zero case. - * - * @param [dec] range decoder - * @param [decay] decay factor of the distribution, i.e. pdf ~= decay^x - * - * @retval decoded variable x - */ -int aom_laplace_decode_special_(aom_reader *r, unsigned decay ACCT_STR_PARAM) { - int pos; - int shift; - int xs; - int sym; - const uint16_t *cdf; - shift = 0; - /* We don't want a large decay value because that would require too many - symbols. */ - while (decay > 235) { - decay = (decay*decay + 128) >> 8; - shift++; - } - decay = OD_MINI(decay, 254); - decay = OD_MAXI(decay, 2); - cdf = EXP_CDF_TABLE[(decay + 1) >> 1]; - OD_LOG((OD_LOG_PVQ, OD_LOG_DEBUG, "decay = %d\n", decay)); - xs = 0; - do { - sym = OD_MINI(xs, 15); - { - int i; - OD_LOG((OD_LOG_PVQ, OD_LOG_DEBUG, "%d %d %d", xs, shift, sym)); - for (i = 0; i < 16; i++) { - OD_LOG_PARTIAL((OD_LOG_PVQ, OD_LOG_DEBUG, "%d ", cdf[i])); - } - OD_LOG_PARTIAL((OD_LOG_PVQ, OD_LOG_DEBUG, "\n")); - } - sym = aom_read_cdf(r, cdf, 16, ACCT_STR_NAME); - xs += sym; - } while (sym >= 15); - if (shift) pos = (xs << shift) + aom_read_literal(r, shift, ACCT_STR_NAME); - else pos = xs; - return pos; -} diff --git a/third_party/aom/av1/decoder/obu.c b/third_party/aom/av1/decoder/obu.c new file mode 100644 index 0000000000..482b6415e3 --- /dev/null +++ b/third_party/aom/av1/decoder/obu.c @@ -0,0 +1,907 @@ +/* + * Copyright (c) 2017, 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 "config/aom_config.h" + +#include "aom/aom_codec.h" +#include "aom_dsp/bitreader_buffer.h" +#include "aom_ports/mem_ops.h" + +#include "av1/common/common.h" +#include "av1/common/timing.h" +#include "av1/decoder/decoder.h" +#include "av1/decoder/decodeframe.h" +#include "av1/decoder/obu.h" + +// Picture prediction structures (0-12 are predefined) in scalability metadata. +typedef enum { + SCALABILITY_L1T2 = 0, + SCALABILITY_L1T3 = 1, + SCALABILITY_L2T1 = 2, + SCALABILITY_L2T2 = 3, + SCALABILITY_L2T3 = 4, + SCALABILITY_S2T1 = 5, + SCALABILITY_S2T2 = 6, + SCALABILITY_S2T3 = 7, + SCALABILITY_L2T1h = 8, + SCALABILITY_L2T2h = 9, + SCALABILITY_L2T3h = 10, + SCALABILITY_S2T1h = 11, + SCALABILITY_S2T2h = 12, + SCALABILITY_S2T3h = 13, + SCALABILITY_SS = 14 +} SCALABILITY_STRUCTURES; + +// Returns 1 when OBU type is valid, and 0 otherwise. +static int valid_obu_type(int obu_type) { + int valid_type = 0; + switch (obu_type) { + case OBU_SEQUENCE_HEADER: + case OBU_TEMPORAL_DELIMITER: + case OBU_FRAME_HEADER: + case OBU_TILE_GROUP: + case OBU_METADATA: + case OBU_FRAME: + case OBU_REDUNDANT_FRAME_HEADER: + case OBU_TILE_LIST: + case OBU_PADDING: valid_type = 1; break; + default: break; + } + return valid_type; +} + +// Parses OBU header and stores values in 'header'. +static aom_codec_err_t read_obu_header(struct aom_read_bit_buffer *rb, + int is_annexb, ObuHeader *header) { + if (!rb || !header) return AOM_CODEC_INVALID_PARAM; + + const ptrdiff_t bit_buffer_byte_length = rb->bit_buffer_end - rb->bit_buffer; + if (bit_buffer_byte_length < 1) return AOM_CODEC_CORRUPT_FRAME; + + header->size = 1; + + if (aom_rb_read_bit(rb) != 0) { + // Forbidden bit. Must not be set. + return AOM_CODEC_CORRUPT_FRAME; + } + + header->type = (OBU_TYPE)aom_rb_read_literal(rb, 4); + + if (!valid_obu_type(header->type)) return AOM_CODEC_CORRUPT_FRAME; + + header->has_extension = aom_rb_read_bit(rb); + header->has_size_field = aom_rb_read_bit(rb); + + if (!header->has_size_field && !is_annexb) { + // section 5 obu streams must have obu_size field set. + return AOM_CODEC_UNSUP_BITSTREAM; + } + + if (aom_rb_read_bit(rb) != 0) { + // obu_reserved_1bit must be set to 0. + return AOM_CODEC_CORRUPT_FRAME; + } + + if (header->has_extension) { + if (bit_buffer_byte_length == 1) return AOM_CODEC_CORRUPT_FRAME; + + header->size += 1; + header->temporal_layer_id = aom_rb_read_literal(rb, 3); + header->spatial_layer_id = aom_rb_read_literal(rb, 2); + if (aom_rb_read_literal(rb, 3) != 0) { + // extension_header_reserved_3bits must be set to 0. + return AOM_CODEC_CORRUPT_FRAME; + } + } + + return AOM_CODEC_OK; +} + +aom_codec_err_t aom_read_obu_header(uint8_t *buffer, size_t buffer_length, + size_t *consumed, ObuHeader *header, + int is_annexb) { + if (buffer_length < 1 || !consumed || !header) return AOM_CODEC_INVALID_PARAM; + + // TODO(tomfinegan): Set the error handler here and throughout this file, and + // confirm parsing work done via aom_read_bit_buffer is successful. + struct aom_read_bit_buffer rb = { buffer, buffer + buffer_length, 0, NULL, + NULL }; + aom_codec_err_t parse_result = read_obu_header(&rb, is_annexb, header); + if (parse_result == AOM_CODEC_OK) *consumed = header->size; + return parse_result; +} + +aom_codec_err_t aom_get_num_layers_from_operating_point_idc( + int operating_point_idc, unsigned int *number_spatial_layers, + unsigned int *number_temporal_layers) { + // derive number of spatial/temporal layers from operating_point_idc + + if (!number_spatial_layers || !number_temporal_layers) + return AOM_CODEC_INVALID_PARAM; + + if (operating_point_idc == 0) { + *number_temporal_layers = 1; + *number_spatial_layers = 1; + } else { + *number_spatial_layers = 0; + *number_temporal_layers = 0; + for (int j = 0; j < MAX_NUM_SPATIAL_LAYERS; j++) { + *number_spatial_layers += + (operating_point_idc >> (j + MAX_NUM_TEMPORAL_LAYERS)) & 0x1; + } + for (int j = 0; j < MAX_NUM_TEMPORAL_LAYERS; j++) { + *number_temporal_layers += (operating_point_idc >> j) & 0x1; + } + } + + return AOM_CODEC_OK; +} + +static int is_obu_in_current_operating_point(AV1Decoder *pbi, + ObuHeader obu_header) { + if (!pbi->current_operating_point) { + return 1; + } + + if ((pbi->current_operating_point >> obu_header.temporal_layer_id) & 0x1 && + (pbi->current_operating_point >> (obu_header.spatial_layer_id + 8)) & + 0x1) { + return 1; + } + return 0; +} + +static uint32_t read_temporal_delimiter_obu() { return 0; } + +// Returns a boolean that indicates success. +static int read_bitstream_level(BitstreamLevel *bl, + struct aom_read_bit_buffer *rb) { + const uint8_t seq_level_idx = aom_rb_read_literal(rb, LEVEL_BITS); + if (!is_valid_seq_level_idx(seq_level_idx)) return 0; + bl->major = (seq_level_idx >> LEVEL_MINOR_BITS) + LEVEL_MAJOR_MIN; + bl->minor = seq_level_idx & ((1 << LEVEL_MINOR_BITS) - 1); + return 1; +} + +// On success, sets pbi->sequence_header_ready to 1 and returns the number of +// bytes read from 'rb'. +// On failure, sets pbi->common.error.error_code and returns 0. +static uint32_t read_sequence_header_obu(AV1Decoder *pbi, + struct aom_read_bit_buffer *rb) { + AV1_COMMON *const cm = &pbi->common; + const uint32_t saved_bit_offset = rb->bit_offset; + + // Verify rb has been configured to report errors. + assert(rb->error_handler); + + cm->profile = av1_read_profile(rb); + if (cm->profile > PROFILE_2) { + cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; + return 0; + } + + SequenceHeader *const seq_params = &cm->seq_params; + + // Still picture or not + seq_params->still_picture = aom_rb_read_bit(rb); + seq_params->reduced_still_picture_hdr = aom_rb_read_bit(rb); + // Video must have reduced_still_picture_hdr = 0 + if (!seq_params->still_picture && seq_params->reduced_still_picture_hdr) { + cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; + return 0; + } + + if (seq_params->reduced_still_picture_hdr) { + cm->timing_info_present = 0; + seq_params->decoder_model_info_present_flag = 0; + seq_params->display_model_info_present_flag = 0; + seq_params->operating_points_cnt_minus_1 = 0; + seq_params->operating_point_idc[0] = 0; + if (!read_bitstream_level(&seq_params->level[0], rb)) { + cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; + return 0; + } + seq_params->tier[0] = 0; + cm->op_params[0].decoder_model_param_present_flag = 0; + cm->op_params[0].display_model_param_present_flag = 0; + } else { + cm->timing_info_present = aom_rb_read_bit(rb); // timing_info_present_flag + if (cm->timing_info_present) { + av1_read_timing_info_header(cm, rb); + + seq_params->decoder_model_info_present_flag = aom_rb_read_bit(rb); + if (seq_params->decoder_model_info_present_flag) + av1_read_decoder_model_info(cm, rb); + } else { + seq_params->decoder_model_info_present_flag = 0; + } + seq_params->display_model_info_present_flag = aom_rb_read_bit(rb); + seq_params->operating_points_cnt_minus_1 = + aom_rb_read_literal(rb, OP_POINTS_CNT_MINUS_1_BITS); + for (int i = 0; i < seq_params->operating_points_cnt_minus_1 + 1; i++) { + seq_params->operating_point_idc[i] = + aom_rb_read_literal(rb, OP_POINTS_IDC_BITS); + if (!read_bitstream_level(&seq_params->level[i], rb)) { + cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; + return 0; + } + // This is the seq_level_idx[i] > 7 check in the spec. seq_level_idx 7 + // is equivalent to level 3.3. + if (seq_params->level[i].major > 3) + seq_params->tier[i] = aom_rb_read_bit(rb); + else + seq_params->tier[i] = 0; + if (seq_params->decoder_model_info_present_flag) { + cm->op_params[i].decoder_model_param_present_flag = aom_rb_read_bit(rb); + if (cm->op_params[i].decoder_model_param_present_flag) + av1_read_op_parameters_info(cm, rb, i); + } else { + cm->op_params[i].decoder_model_param_present_flag = 0; + } + if (cm->timing_info_present && + (cm->timing_info.equal_picture_interval || + cm->op_params[i].decoder_model_param_present_flag)) { + cm->op_params[i].bitrate = max_level_bitrate( + cm->profile, major_minor_to_seq_level_idx(seq_params->level[i]), + seq_params->tier[i]); + // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass + // the check + if (cm->op_params[i].bitrate == 0) + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "AV1 does not support this combination of " + "profile, level, and tier."); + // Buffer size in bits/s is bitrate in bits/s * 1 s + cm->op_params[i].buffer_size = cm->op_params[i].bitrate; + } + if (cm->timing_info_present && cm->timing_info.equal_picture_interval && + !cm->op_params[i].decoder_model_param_present_flag) { + // When the decoder_model_parameters are not sent for this op, set + // the default ones that can be used with the resource availability mode + cm->op_params[i].decoder_buffer_delay = 70000; + cm->op_params[i].encoder_buffer_delay = 20000; + cm->op_params[i].low_delay_mode_flag = 0; + } + + if (seq_params->display_model_info_present_flag) { + cm->op_params[i].display_model_param_present_flag = aom_rb_read_bit(rb); + if (cm->op_params[i].display_model_param_present_flag) { + cm->op_params[i].initial_display_delay = + aom_rb_read_literal(rb, 4) + 1; + if (cm->op_params[i].initial_display_delay > 10) + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "AV1 does not support more than 10 decoded frames delay"); + } else { + cm->op_params[i].initial_display_delay = 10; + } + } else { + cm->op_params[i].display_model_param_present_flag = 0; + cm->op_params[i].initial_display_delay = 10; + } + } + } + // This decoder supports all levels. Choose operating point provided by + // external means + int operating_point = pbi->operating_point; + if (operating_point < 0 || + operating_point > seq_params->operating_points_cnt_minus_1) + operating_point = 0; + pbi->current_operating_point = + seq_params->operating_point_idc[operating_point]; + if (aom_get_num_layers_from_operating_point_idc( + pbi->current_operating_point, &cm->number_spatial_layers, + &cm->number_temporal_layers) != AOM_CODEC_OK) { + cm->error.error_code = AOM_CODEC_ERROR; + return 0; + } + + read_sequence_header(cm, rb); + + av1_read_color_config(cm, rb, pbi->allow_lowbitdepth); + + cm->film_grain_params_present = aom_rb_read_bit(rb); + + if (av1_check_trailing_bits(pbi, rb) != 0) { + // cm->error.error_code is already set. + return 0; + } + + pbi->sequence_header_ready = 1; + + return ((rb->bit_offset - saved_bit_offset + 7) >> 3); +} + +static uint32_t read_frame_header_obu(AV1Decoder *pbi, + struct aom_read_bit_buffer *rb, + const uint8_t *data, + const uint8_t **p_data_end, + int trailing_bits_present) { + av1_decode_frame_headers_and_setup(pbi, rb, data, p_data_end, + trailing_bits_present); + return (uint32_t)(pbi->uncomp_hdr_size); +} + +static int32_t read_tile_group_header(AV1Decoder *pbi, + struct aom_read_bit_buffer *rb, + int *start_tile, int *end_tile, + int tile_start_implicit) { + AV1_COMMON *const cm = &pbi->common; + uint32_t saved_bit_offset = rb->bit_offset; + int tile_start_and_end_present_flag = 0; + const int num_tiles = pbi->common.tile_rows * pbi->common.tile_cols; + + if (!pbi->common.large_scale_tile && num_tiles > 1) { + tile_start_and_end_present_flag = aom_rb_read_bit(rb); + } + if (pbi->common.large_scale_tile || num_tiles == 1 || + !tile_start_and_end_present_flag) { + *start_tile = 0; + *end_tile = num_tiles - 1; + return ((rb->bit_offset - saved_bit_offset + 7) >> 3); + } + if (tile_start_implicit && tile_start_and_end_present_flag) { + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "For OBU_FRAME type obu tile_start_and_end_present_flag must be 0"); + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + *start_tile = + aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); + *end_tile = aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); + + return ((rb->bit_offset - saved_bit_offset + 7) >> 3); +} + +static uint32_t read_one_tile_group_obu( + AV1Decoder *pbi, struct aom_read_bit_buffer *rb, int is_first_tg, + const uint8_t *data, const uint8_t *data_end, const uint8_t **p_data_end, + int *is_last_tg, int tile_start_implicit) { + AV1_COMMON *const cm = &pbi->common; + int start_tile, end_tile; + int32_t header_size, tg_payload_size; + + header_size = read_tile_group_header(pbi, rb, &start_tile, &end_tile, + tile_start_implicit); + if (header_size == -1) return 0; + if (start_tile > end_tile) return header_size; + data += header_size; + av1_decode_tg_tiles_and_wrapup(pbi, data, data_end, p_data_end, start_tile, + end_tile, is_first_tg); + + tg_payload_size = (uint32_t)(*p_data_end - data); + + // TODO(shan): For now, assume all tile groups received in order + *is_last_tg = end_tile == cm->tile_rows * cm->tile_cols - 1; + return header_size + tg_payload_size; +} + +// Only called while large_scale_tile = 1. +static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi, + struct aom_read_bit_buffer *rb, + const uint8_t *data, + const uint8_t *data_end, + const uint8_t **p_data_end, + int *frame_decoding_finished) { + AV1_COMMON *const cm = &pbi->common; + uint32_t tile_list_payload_size = 0; + const int num_tiles = cm->tile_cols * cm->tile_rows; + const int start_tile = 0; + const int end_tile = num_tiles - 1; + int i = 0; + + // Process the tile list info. + pbi->output_frame_width_in_tiles_minus_1 = aom_rb_read_literal(rb, 8); + pbi->output_frame_height_in_tiles_minus_1 = aom_rb_read_literal(rb, 8); + pbi->tile_count_minus_1 = aom_rb_read_literal(rb, 16); + if (pbi->tile_count_minus_1 > 511) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + + // Allocate output frame buffer for the tile list. + // TODO(yunqing): for now, copy each tile's decoded YUV data directly to the + // output buffer. This needs to be modified according to the application + // requirement. + const int tile_width_in_pixels = cm->tile_width * MI_SIZE; + const int tile_height_in_pixels = cm->tile_height * MI_SIZE; + const int ssy = cm->subsampling_y; + const int ssx = cm->subsampling_x; + const int num_planes = av1_num_planes(cm); + const size_t yplane_tile_size = tile_height_in_pixels * tile_width_in_pixels; + const size_t uvplane_tile_size = + (num_planes > 1) + ? (tile_height_in_pixels >> ssy) * (tile_width_in_pixels >> ssx) + : 0; + const size_t tile_size = (cm->use_highbitdepth ? 2 : 1) * + (yplane_tile_size + 2 * uvplane_tile_size); + pbi->tile_list_size = tile_size * (pbi->tile_count_minus_1 + 1); + + if (pbi->tile_list_size > pbi->buffer_sz) { + if (pbi->tile_list_output != NULL) aom_free(pbi->tile_list_output); + pbi->tile_list_output = NULL; + + pbi->tile_list_output = (uint8_t *)aom_memalign(32, pbi->tile_list_size); + if (pbi->tile_list_output == NULL) + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Failed to allocate the tile list output buffer"); + pbi->buffer_sz = pbi->tile_list_size; + } + + uint32_t tile_list_info_bytes = 4; + tile_list_payload_size += tile_list_info_bytes; + data += tile_list_info_bytes; + uint8_t *output = pbi->tile_list_output; + + for (i = 0; i <= pbi->tile_count_minus_1; i++) { + // Process 1 tile. + // Reset the bit reader. + rb->bit_offset = 0; + rb->bit_buffer = data; + + // Read out the tile info. + uint32_t tile_info_bytes = 5; + // Set reference for each tile. + int ref_idx = aom_rb_read_literal(rb, 8); + if (ref_idx >= MAX_EXTERNAL_REFERENCES) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + av1_set_reference_dec(cm, 0, 1, &pbi->ext_refs.refs[ref_idx]); + + pbi->dec_tile_row = aom_rb_read_literal(rb, 8); + pbi->dec_tile_col = aom_rb_read_literal(rb, 8); + if (pbi->dec_tile_row < 0 || pbi->dec_tile_col < 0 || + pbi->dec_tile_row >= cm->tile_rows || + pbi->dec_tile_col >= cm->tile_cols) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + + pbi->coded_tile_data_size = aom_rb_read_literal(rb, 16) + 1; + data += tile_info_bytes; + if ((size_t)(data_end - data) < pbi->coded_tile_data_size) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + + av1_decode_tg_tiles_and_wrapup(pbi, data, data + pbi->coded_tile_data_size, + p_data_end, start_tile, end_tile, 0); + uint32_t tile_payload_size = (uint32_t)(*p_data_end - data); + + tile_list_payload_size += tile_info_bytes + tile_payload_size; + + // Update data ptr for next tile decoding. + data = *p_data_end; + assert(data <= data_end); + + // Copy decoded tile to the tile list output buffer. + YV12_BUFFER_CONFIG *cur_frame = get_frame_new_buffer(cm); + const int mi_row = pbi->dec_tile_row * cm->tile_height; + const int mi_col = pbi->dec_tile_col * cm->tile_width; + const int is_hbd = (cur_frame->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0; + uint8_t *bufs[MAX_MB_PLANE] = { NULL, NULL, NULL }; + int strides[MAX_MB_PLANE] = { 0, 0, 0 }; + int plane; + + for (plane = 0; plane < num_planes; ++plane) { + int shift_x = plane > 0 ? ssx : 0; + int shift_y = plane > 0 ? ssy : 0; + + bufs[plane] = cur_frame->buffers[plane]; + strides[plane] = + (plane > 0) ? cur_frame->strides[1] : cur_frame->strides[0]; + if (is_hbd) { + bufs[plane] = (uint8_t *)CONVERT_TO_SHORTPTR(cur_frame->buffers[plane]); + strides[plane] = + (plane > 0) ? 2 * cur_frame->strides[1] : 2 * cur_frame->strides[0]; + } + + bufs[plane] += mi_row * (MI_SIZE >> shift_y) * strides[plane] + + mi_col * (MI_SIZE >> shift_x); + + int w, h; + w = (plane > 0 && shift_x > 0) ? ((tile_width_in_pixels + 1) >> shift_x) + : tile_width_in_pixels; + w *= (1 + is_hbd); + h = (plane > 0 && shift_y > 0) ? ((tile_height_in_pixels + 1) >> shift_y) + : tile_height_in_pixels; + int j; + + for (j = 0; j < h; ++j) { + memcpy(output, bufs[plane], w); + bufs[plane] += strides[plane]; + output += w; + } + } + } + + *frame_decoding_finished = 1; + return tile_list_payload_size; +} + +static void read_metadata_itut_t35(const uint8_t *data, size_t sz) { + struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; + for (size_t i = 0; i < sz; i++) { + aom_rb_read_literal(&rb, 8); + } +} + +static void read_metadata_hdr_cll(const uint8_t *data, size_t sz) { + struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; + aom_rb_read_literal(&rb, 16); // max_cll + aom_rb_read_literal(&rb, 16); // max_fall +} + +static void read_metadata_hdr_mdcv(const uint8_t *data, size_t sz) { + struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; + for (int i = 0; i < 3; i++) { + aom_rb_read_literal(&rb, 16); // primary_i_chromaticity_x + aom_rb_read_literal(&rb, 16); // primary_i_chromaticity_y + } + + aom_rb_read_literal(&rb, 16); // white_point_chromaticity_x + aom_rb_read_literal(&rb, 16); // white_point_chromaticity_y + + aom_rb_read_unsigned_literal(&rb, 32); // luminance_max + aom_rb_read_unsigned_literal(&rb, 32); // luminance_min +} + +static void scalability_structure(struct aom_read_bit_buffer *rb) { + int spatial_layers_cnt = aom_rb_read_literal(rb, 2); + int spatial_layer_dimensions_present_flag = aom_rb_read_literal(rb, 1); + int spatial_layer_description_present_flag = aom_rb_read_literal(rb, 1); + int temporal_group_description_present_flag = aom_rb_read_literal(rb, 1); + aom_rb_read_literal(rb, 3); // reserved + + if (spatial_layer_dimensions_present_flag) { + int i; + for (i = 0; i < spatial_layers_cnt + 1; i++) { + aom_rb_read_literal(rb, 16); + aom_rb_read_literal(rb, 16); + } + } + if (spatial_layer_description_present_flag) { + int i; + for (i = 0; i < spatial_layers_cnt + 1; i++) { + aom_rb_read_literal(rb, 8); + } + } + if (temporal_group_description_present_flag) { + int i, j, temporal_group_size; + temporal_group_size = aom_rb_read_literal(rb, 8); + for (i = 0; i < temporal_group_size; i++) { + aom_rb_read_literal(rb, 3); + aom_rb_read_literal(rb, 1); + aom_rb_read_literal(rb, 1); + int temporal_group_ref_cnt = aom_rb_read_literal(rb, 3); + for (j = 0; j < temporal_group_ref_cnt; j++) { + aom_rb_read_literal(rb, 8); + } + } + } +} + +static void read_metadata_scalability(const uint8_t *data, size_t sz) { + struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; + int scalability_mode_idc = aom_rb_read_literal(&rb, 8); + if (scalability_mode_idc == SCALABILITY_SS) { + scalability_structure(&rb); + } +} + +static void read_metadata_timecode(const uint8_t *data, size_t sz) { + struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; + aom_rb_read_literal(&rb, 5); // counting_type f(5) + int full_timestamp_flag = aom_rb_read_bit(&rb); // full_timestamp_flag f(1) + aom_rb_read_bit(&rb); // discontinuity_flag (f1) + aom_rb_read_bit(&rb); // cnt_dropped_flag f(1) + aom_rb_read_literal(&rb, 9); // n_frames f(9) + if (full_timestamp_flag) { + aom_rb_read_literal(&rb, 6); // seconds_value f(6) + aom_rb_read_literal(&rb, 6); // minutes_value f(6) + aom_rb_read_literal(&rb, 5); // hours_value f(5) + } else { + int seconds_flag = aom_rb_read_bit(&rb); // seconds_flag f(1) + if (seconds_flag) { + aom_rb_read_literal(&rb, 6); // seconds_value f(6) + int minutes_flag = aom_rb_read_bit(&rb); // minutes_flag f(1) + if (minutes_flag) { + aom_rb_read_literal(&rb, 6); // minutes_value f(6) + int hours_flag = aom_rb_read_bit(&rb); // hours_flag f(1) + if (hours_flag) { + aom_rb_read_literal(&rb, 5); // hours_value f(5) + } + } + } + } + // time_offset_length f(5) + int time_offset_length = aom_rb_read_literal(&rb, 5); + if (time_offset_length) { + aom_rb_read_literal(&rb, time_offset_length); // f(time_offset_length) + } +} + +static size_t read_metadata(const uint8_t *data, size_t sz) { + size_t type_length; + uint64_t type_value; + OBU_METADATA_TYPE metadata_type; + if (aom_uleb_decode(data, sz, &type_value, &type_length) < 0) { + return sz; + } + metadata_type = (OBU_METADATA_TYPE)type_value; + if (metadata_type == OBU_METADATA_TYPE_ITUT_T35) { + read_metadata_itut_t35(data + type_length, sz - type_length); + } else if (metadata_type == OBU_METADATA_TYPE_HDR_CLL) { + read_metadata_hdr_cll(data + type_length, sz - type_length); + } else if (metadata_type == OBU_METADATA_TYPE_HDR_MDCV) { + read_metadata_hdr_mdcv(data + type_length, sz - type_length); + } else if (metadata_type == OBU_METADATA_TYPE_SCALABILITY) { + read_metadata_scalability(data + type_length, sz - type_length); + } else if (metadata_type == OBU_METADATA_TYPE_TIMECODE) { + read_metadata_timecode(data + type_length, sz - type_length); + } + + return sz; +} + +static aom_codec_err_t read_obu_size(const uint8_t *data, + size_t bytes_available, + size_t *const obu_size, + size_t *const length_field_size) { + uint64_t u_obu_size = 0; + if (aom_uleb_decode(data, bytes_available, &u_obu_size, length_field_size) != + 0) { + return AOM_CODEC_CORRUPT_FRAME; + } + + if (u_obu_size > UINT32_MAX) return AOM_CODEC_CORRUPT_FRAME; + *obu_size = (size_t)u_obu_size; + return AOM_CODEC_OK; +} + +aom_codec_err_t aom_read_obu_header_and_size(const uint8_t *data, + size_t bytes_available, + int is_annexb, + ObuHeader *obu_header, + size_t *const payload_size, + size_t *const bytes_read) { + size_t length_field_size = 0, obu_size = 0; + aom_codec_err_t status; + + if (is_annexb) { + // Size field comes before the OBU header, and includes the OBU header + status = + read_obu_size(data, bytes_available, &obu_size, &length_field_size); + + if (status != AOM_CODEC_OK) return status; + } + + struct aom_read_bit_buffer rb = { data + length_field_size, + data + bytes_available, 0, NULL, NULL }; + + status = read_obu_header(&rb, is_annexb, obu_header); + if (status != AOM_CODEC_OK) return status; + + if (is_annexb) { + // Derive the payload size from the data we've already read + if (obu_size < obu_header->size) return AOM_CODEC_CORRUPT_FRAME; + + *payload_size = obu_size - obu_header->size; + } else { + // Size field comes after the OBU header, and is just the payload size + status = read_obu_size(data + obu_header->size, + bytes_available - obu_header->size, payload_size, + &length_field_size); + if (status != AOM_CODEC_OK) return status; + } + + *bytes_read = length_field_size + obu_header->size; + return AOM_CODEC_OK; +} + +#define EXT_TILE_DEBUG 0 +// On success, returns a boolean that indicates whether the decoding of the +// current frame is finished. On failure, sets cm->error.error_code and +// returns -1. +int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, + const uint8_t *data_end, + const uint8_t **p_data_end) { + AV1_COMMON *const cm = &pbi->common; + int frame_decoding_finished = 0; + int is_first_tg_obu_received = 1; + int frame_header_size = 0; + int seq_header_received = 0; + size_t seq_header_size = 0; + ObuHeader obu_header; + memset(&obu_header, 0, sizeof(obu_header)); + pbi->seen_frame_header = 0; + + if (data_end < data) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + + // Reset pbi->camera_frame_header_ready to 0 if cm->large_scale_tile = 0. + if (!cm->large_scale_tile) pbi->camera_frame_header_ready = 0; + + // decode frame as a series of OBUs + while (!frame_decoding_finished && !cm->error.error_code) { + struct aom_read_bit_buffer rb; + size_t payload_size = 0; + size_t decoded_payload_size = 0; + size_t obu_payload_offset = 0; + size_t bytes_read = 0; + const size_t bytes_available = data_end - data; + + if (bytes_available == 0 && !pbi->seen_frame_header) { + *p_data_end = data; + cm->error.error_code = AOM_CODEC_OK; + break; + } + + aom_codec_err_t status = + aom_read_obu_header_and_size(data, bytes_available, cm->is_annexb, + &obu_header, &payload_size, &bytes_read); + + if (status != AOM_CODEC_OK) { + cm->error.error_code = status; + return -1; + } + + // Record obu size header information. + pbi->obu_size_hdr.data = data + obu_header.size; + pbi->obu_size_hdr.size = bytes_read - obu_header.size; + + // Note: aom_read_obu_header_and_size() takes care of checking that this + // doesn't cause 'data' to advance past 'data_end'. + data += bytes_read; + + if ((size_t)(data_end - data) < payload_size) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + + cm->temporal_layer_id = obu_header.temporal_layer_id; + cm->spatial_layer_id = obu_header.spatial_layer_id; + + if (obu_header.type != OBU_TEMPORAL_DELIMITER && + obu_header.type != OBU_SEQUENCE_HEADER && + obu_header.type != OBU_PADDING) { + // don't decode obu if it's not in current operating mode + if (!is_obu_in_current_operating_point(pbi, obu_header)) { + data += payload_size; + continue; + } + } + + av1_init_read_bit_buffer(pbi, &rb, data, data_end); + + switch (obu_header.type) { + case OBU_TEMPORAL_DELIMITER: + decoded_payload_size = read_temporal_delimiter_obu(); + pbi->seen_frame_header = 0; + break; + case OBU_SEQUENCE_HEADER: + if (!seq_header_received) { + decoded_payload_size = read_sequence_header_obu(pbi, &rb); + if (cm->error.error_code != AOM_CODEC_OK) return -1; + + seq_header_size = decoded_payload_size; + seq_header_received = 1; + } else { + // Seeing another sequence header, skip as all sequence headers are + // required to be identical except for the contents of + // operating_parameters_info and the amount of trailing bits. + // TODO(yaowu): verifying redundant sequence headers are identical. + decoded_payload_size = seq_header_size; + } + break; + case OBU_FRAME_HEADER: + case OBU_REDUNDANT_FRAME_HEADER: + case OBU_FRAME: + // Only decode first frame header received + if (!pbi->seen_frame_header || + (cm->large_scale_tile && !pbi->camera_frame_header_ready)) { + pbi->seen_frame_header = 1; + frame_header_size = read_frame_header_obu( + pbi, &rb, data, p_data_end, obu_header.type != OBU_FRAME); + if (cm->large_scale_tile) pbi->camera_frame_header_ready = 1; + } + decoded_payload_size = frame_header_size; + pbi->frame_header_size = (size_t)frame_header_size; + + if (cm->show_existing_frame) { + frame_decoding_finished = 1; + pbi->seen_frame_header = 0; + break; + } + +#if !EXT_TILE_DEBUG + // In large scale tile coding, decode the common camera frame header + // before any tile list OBU. + if (!pbi->ext_tile_debug && pbi->camera_frame_header_ready) { + frame_decoding_finished = 1; + // Skip the rest of the frame data. + decoded_payload_size = payload_size; + // Update data_end. + *p_data_end = data_end; + break; + } +#endif // EXT_TILE_DEBUG + + if (obu_header.type != OBU_FRAME) break; + obu_payload_offset = frame_header_size; + AOM_FALLTHROUGH_INTENDED; // fall through to read tile group. + case OBU_TILE_GROUP: + if (!pbi->seen_frame_header) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + if ((size_t)(data_end - data) < obu_payload_offset) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + decoded_payload_size += read_one_tile_group_obu( + pbi, &rb, is_first_tg_obu_received, data + obu_payload_offset, + data + payload_size, p_data_end, &frame_decoding_finished, + obu_header.type == OBU_FRAME); + is_first_tg_obu_received = 0; + if (frame_decoding_finished) pbi->seen_frame_header = 0; + break; + case OBU_METADATA: + decoded_payload_size = read_metadata(data, payload_size); + break; + case OBU_TILE_LIST: + // This OBU type is purely for the large scale tile coding mode. + // The common camera frame header has to be already decoded. + if (!pbi->camera_frame_header_ready) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + + cm->large_scale_tile = 1; + av1_set_single_tile_decoding_mode(cm); + decoded_payload_size = + read_and_decode_one_tile_list(pbi, &rb, data, data + payload_size, + p_data_end, &frame_decoding_finished); + if (cm->error.error_code != AOM_CODEC_OK) return -1; + break; + case OBU_PADDING: + default: + // Skip unrecognized OBUs + decoded_payload_size = payload_size; + break; + } + + // Check that the signalled OBU size matches the actual amount of data read + if (decoded_payload_size > payload_size) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + + // If there are extra padding bytes, they should all be zero + while (decoded_payload_size < payload_size) { + uint8_t padding_byte = data[decoded_payload_size++]; + if (padding_byte != 0) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + } + + data += payload_size; + } + + return frame_decoding_finished; +} +#undef EXT_TILE_DEBUG diff --git a/third_party/aom/av1/decoder/obu.h b/third_party/aom/av1/decoder/obu.h new file mode 100644 index 0000000000..5f2197058d --- /dev/null +++ b/third_party/aom/av1/decoder/obu.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2017, 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. + */ + +#ifndef AV1_DECODER_OBU_H +#define AV1_DECODER_OBU_H + +#include "aom/aom_codec.h" +#include "av1/decoder/decoder.h" + +typedef struct { + size_t size; // Size (1 or 2 bytes) of the OBU header (including the + // optional OBU extension header) in the bitstream. + OBU_TYPE type; + int has_size_field; + int has_extension; + // The following fields come from the OBU extension header and therefore are + // only used if has_extension is true. + int temporal_layer_id; + int spatial_layer_id; +} ObuHeader; + +aom_codec_err_t aom_read_obu_header(uint8_t *buffer, size_t buffer_length, + size_t *consumed, ObuHeader *header, + int is_annexb); + +aom_codec_err_t aom_read_obu_header_and_size(const uint8_t *data, + size_t bytes_available, + int is_annexb, + ObuHeader *obu_header, + size_t *const payload_size, + size_t *const bytes_read); + +// Try to decode one frame from a buffer. +// Returns 1 if we decoded a frame, +// 0 if we didn't decode a frame but that's okay +// (eg, if there was a frame but we skipped it), +// or -1 on error +int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, + const uint8_t *data_end, + const uint8_t **p_data_end); + +aom_codec_err_t aom_get_num_layers_from_operating_point_idc( + int operating_point_idc, unsigned int *num_spatial_layers, + unsigned int *num_temporal_layers); + +#endif diff --git a/third_party/aom/av1/decoder/pvq_decoder.c b/third_party/aom/av1/decoder/pvq_decoder.c deleted file mode 100644 index d9a8e80563..0000000000 --- a/third_party/aom/av1/decoder/pvq_decoder.c +++ /dev/null @@ -1,378 +0,0 @@ -/* - * Copyright (c) 2001-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. - */ - -/* clang-format off */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include <stdio.h> -#include <stdlib.h> -#include "./aom_config.h" -#include "aom_dsp/bitreader.h" -#include "aom_dsp/entcode.h" -#include "aom_dsp/entdec.h" -#include "av1/common/odintrin.h" -#include "av1/common/partition.h" -#include "av1/common/pvq_state.h" -#include "av1/decoder/decint.h" -#include "av1/decoder/pvq_decoder.h" -#include "aom_ports/system_state.h" - -int aom_read_symbol_pvq_(aom_reader *r, aom_cdf_prob *cdf, int nsymbs - ACCT_STR_PARAM) { - if (cdf[0] == 0) - aom_cdf_init_q15_1D(cdf, nsymbs, CDF_SIZE(nsymbs)); - return aom_read_symbol(r, cdf, nsymbs, ACCT_STR_NAME); -} - -static void aom_decode_pvq_codeword(aom_reader *r, od_pvq_codeword_ctx *ctx, - od_coeff *y, int n, int k) { - int i; - aom_decode_band_pvq_splits(r, ctx, y, n, k, 0); - for (i = 0; i < n; i++) { - if (y[i] && aom_read_bit(r, "pvq:sign")) y[i] = -y[i]; - } -} - -/** Inverse of neg_interleave; decodes the interleaved gain. - * - * @param [in] x quantized/interleaved gain to decode - * @param [in] ref quantized gain of the reference - * @return original quantized gain value - */ -static int neg_deinterleave(int x, int ref) { - if (x < 2*ref-1) { - if (x & 1) return ref - 1 - (x >> 1); - else return ref + (x >> 1); - } - else return x+1; -} - -/** Synthesizes one parition of coefficient values from a PVQ-encoded - * vector. - * - * @param [out] xcoeff output coefficient partition (x in math doc) - * @param [in] ypulse PVQ-encoded values (y in math doc); in the noref - * case, this vector has n entries, in the - * reference case it contains n-1 entries - * (the m-th entry is not included) - * @param [in] ref reference vector (prediction) - * @param [in] n number of elements in this partition - * @param [in] gr gain of the reference vector (prediction) - * @param [in] noref indicates presence or lack of prediction - * @param [in] g decoded quantized vector gain - * @param [in] theta decoded theta (prediction error) - * @param [in] qm QM with magnitude compensation - * @param [in] qm_inv Inverse of QM with magnitude compensation - */ -static void pvq_synthesis(od_coeff *xcoeff, od_coeff *ypulse, od_val16 *r16, - int n, od_val32 gr, int noref, od_val32 g, od_val32 theta, const int16_t *qm_inv, - int shift) { - int s; - int m; - /* Sign of the Householder reflection vector */ - s = 0; - /* Direction of the Householder reflection vector */ - m = noref ? 0 : od_compute_householder(r16, n, gr, &s, shift); - od_pvq_synthesis_partial(xcoeff, ypulse, r16, n, noref, g, theta, m, s, - qm_inv); -} - -typedef struct { - od_coeff *ref; - int nb_coeffs; - int allow_flip; -} cfl_ctx; - -/** Decodes a single vector of integers (eg, a partition within a - * coefficient block) encoded using PVQ - * - * @param [in,out] ec range encoder - * @param [in] q0 scale/quantizer - * @param [in] n number of coefficients in partition - * @param [in,out] model entropy decoder state - * @param [in,out] adapt adaptation context - * @param [in,out] exg ExQ16 expectation of decoded gain value - * @param [in,out] ext ExQ16 expectation of decoded theta value - * @param [in] ref 'reference' (prediction) vector - * @param [out] out decoded partition - * @param [out] noref boolean indicating absence of reference - * @param [in] beta per-band activity masking beta param - * @param [in] is_keyframe whether we're encoding a keyframe - * @param [in] pli plane index - * @param [in] cdf_ctx selects which cdf context to use - * @param [in,out] skip_rest whether to skip further bands in each direction - * @param [in] band index of the band being decoded - * @param [in] band index of the band being decoded - * @param [out] skip skip flag with range [0,1] - * @param [in] qm QM with magnitude compensation - * @param [in] qm_inv Inverse of QM with magnitude compensation - */ -static void pvq_decode_partition(aom_reader *r, - int q0, - int n, - generic_encoder model[3], - od_adapt_ctx *adapt, - int *exg, - int *ext, - od_coeff *ref, - od_coeff *out, - int *noref, - od_val16 beta, - int is_keyframe, - int pli, - int cdf_ctx, - cfl_ctx *cfl, - int has_skip, - int *skip_rest, - int band, - int *skip, - const int16_t *qm, - const int16_t *qm_inv) { - int k; - od_val32 qcg; - int itheta; - od_val32 theta; - od_val32 gr; - od_val32 gain_offset; - od_coeff y[MAXN]; - int qg; - int id; - int i; - od_val16 ref16[MAXN]; - int rshift; - theta = 0; - gr = 0; - gain_offset = 0; - /* Skip is per-direction. For band=0, we can use any of the flags. */ - if (skip_rest[(band + 2) % 3]) { - qg = 0; - if (is_keyframe) { - itheta = -1; - *noref = 1; - } - else { - itheta = 0; - *noref = 0; - } - } - else { - /* Jointly decode gain, itheta and noref for small values. Then we handle - larger gain. */ - id = aom_read_symbol_pvq(r, &adapt->pvq.pvq_gaintheta_cdf[cdf_ctx][0], - 8 + 7*has_skip, "pvq:gaintheta"); - if (!is_keyframe && id >= 10) id++; - if (is_keyframe && id >= 8) id++; - if (id >= 8) { - id -= 8; - skip_rest[0] = skip_rest[1] = skip_rest[2] = 1; - } - qg = id & 1; - itheta = (id >> 1) - 1; - *noref = (itheta == -1); - } - /* The CfL flip bit is only decoded on the first band that has noref=0. */ - if (cfl->allow_flip && !*noref) { - int flip; - flip = aom_read_bit(r, "cfl:flip"); - if (flip) { - for (i = 0; i < cfl->nb_coeffs; i++) cfl->ref[i] = -cfl->ref[i]; - } - cfl->allow_flip = 0; - } - if (qg > 0) { - int tmp; - tmp = *exg; - qg = 1 + generic_decode(r, &model[!*noref], &tmp, 2, "pvq:gain"); - OD_IIR_DIADIC(*exg, qg << 16, 2); - } - *skip = 0; -#if defined(OD_FLOAT_PVQ) - rshift = 0; -#else - /* Shift needed to make the reference fit in 15 bits, so that the Householder - vector can fit in 16 bits. */ - rshift = OD_MAXI(0, od_vector_log_mag(ref, n) - 14); -#endif - for (i = 0; i < n; i++) { -#if defined(OD_FLOAT_PVQ) - ref16[i] = ref[i]*(double)qm[i]*OD_QM_SCALE_1; -#else - ref16[i] = OD_SHR_ROUND(ref[i]*qm[i], OD_QM_SHIFT + rshift); -#endif - } - if(!*noref){ - /* we have a reference; compute its gain */ - od_val32 cgr; - int icgr; - int cfl_enabled; - cfl_enabled = pli != 0 && is_keyframe && !OD_DISABLE_CFL; - cgr = od_pvq_compute_gain(ref16, n, q0, &gr, beta, rshift); - if (cfl_enabled) cgr = OD_CGAIN_SCALE; -#if defined(OD_FLOAT_PVQ) - icgr = (int)floor(.5 + cgr); -#else - icgr = OD_SHR_ROUND(cgr, OD_CGAIN_SHIFT); -#endif - /* quantized gain is interleave encoded when there's a reference; - deinterleave it now */ - if (is_keyframe) qg = neg_deinterleave(qg, icgr); - else { - qg = neg_deinterleave(qg, icgr + 1) - 1; - if (qg == 0) *skip = (icgr ? OD_PVQ_SKIP_ZERO : OD_PVQ_SKIP_COPY); - } - if (qg == icgr && itheta == 0 && !cfl_enabled) *skip = OD_PVQ_SKIP_COPY; - gain_offset = cgr - OD_SHL(icgr, OD_CGAIN_SHIFT); - qcg = OD_SHL(qg, OD_CGAIN_SHIFT) + gain_offset; - /* read and decode first-stage PVQ error theta */ - if (itheta > 1) { - int tmp; - tmp = *ext; - itheta = 2 + generic_decode(r, &model[2], &tmp, 2, "pvq:theta"); - OD_IIR_DIADIC(*ext, itheta << 16, 2); - } - theta = od_pvq_compute_theta(itheta, od_pvq_compute_max_theta(qcg, beta)); - } - else{ - itheta = 0; - if (!is_keyframe) qg++; - qcg = OD_SHL(qg, OD_CGAIN_SHIFT); - if (qg == 0) *skip = OD_PVQ_SKIP_ZERO; - } - - k = od_pvq_compute_k(qcg, itheta, *noref, n, beta); - if (k != 0) { - /* when noref==0, y is actually size n-1 */ - aom_decode_pvq_codeword(r, &adapt->pvq.pvq_codeword_ctx, y, - n - !*noref, k); - } - else { - OD_CLEAR(y, n); - } - if (*skip) { - if (*skip == OD_PVQ_SKIP_COPY) OD_COPY(out, ref, n); - else OD_CLEAR(out, n); - } - else { - od_val32 g; - g = od_gain_expand(qcg, q0, beta); - pvq_synthesis(out, y, ref16, n, gr, *noref, g, theta, qm_inv, rshift); - } - /* If OD_PVQ_SKIP_ZERO or OD_PVQ_SKIP_COPY, set skip to 1 for visualization */ - if (*skip) *skip = 1; -} - -/** Decodes a coefficient block (except for DC) encoded using PVQ - * - * @param [in,out] dec daala decoder context - * @param [in] ref 'reference' (prediction) vector - * @param [out] out decoded partition - * @param [in] q0 quantizer - * @param [in] pli plane index - * @param [in] bs log of the block size minus two - * @param [in] beta per-band activity masking beta param - * @param [in] is_keyframe whether we're encoding a keyframe - * @param [out] flags bitmask of the per band skip and noref flags - * @param [in] ac_dc_coded skip flag for the block (range 0-3) - * @param [in] qm QM with magnitude compensation - * @param [in] qm_inv Inverse of QM with magnitude compensation - */ -void od_pvq_decode(daala_dec_ctx *dec, - od_coeff *ref, - od_coeff *out, - int q0, - int pli, - int bs, - const od_val16 *beta, - int is_keyframe, - unsigned int *flags, - PVQ_SKIP_TYPE ac_dc_coded, - const int16_t *qm, - const int16_t *qm_inv){ - - int noref[PVQ_MAX_PARTITIONS]; - int skip[PVQ_MAX_PARTITIONS]; - int *exg; - int *ext; - int nb_bands; - int i; - const int *off; - int size[PVQ_MAX_PARTITIONS]; - generic_encoder *model; - int skip_rest[3] = {0}; - cfl_ctx cfl; - const unsigned char *pvq_qm; - int use_masking; - - aom_clear_system_state(); - - /*Default to skip=1 and noref=0 for all bands.*/ - for (i = 0; i < PVQ_MAX_PARTITIONS; i++) { - noref[i] = 0; - skip[i] = 1; - } - - use_masking = dec->use_activity_masking; - - if (use_masking) - pvq_qm = &dec->state.pvq_qm_q4[pli][0]; - else - pvq_qm = 0; - - exg = &dec->state.adapt->pvq.pvq_exg[pli][bs][0]; - ext = dec->state.adapt->pvq.pvq_ext + bs*PVQ_MAX_PARTITIONS; - model = dec->state.adapt->pvq.pvq_param_model; - nb_bands = OD_BAND_OFFSETS[bs][0]; - off = &OD_BAND_OFFSETS[bs][1]; - out[0] = ac_dc_coded & DC_CODED; - if (ac_dc_coded < AC_CODED) { - if (is_keyframe) for (i = 1; i < 1 << (2*bs + 4); i++) out[i] = 0; - else for (i = 1; i < 1 << (2*bs + 4); i++) out[i] = ref[i]; - } - else { - for (i = 0; i < nb_bands; i++) size[i] = off[i+1] - off[i]; - cfl.ref = ref; - cfl.nb_coeffs = off[nb_bands]; - cfl.allow_flip = pli != 0 && is_keyframe; - for (i = 0; i < nb_bands; i++) { - int q; - - if (use_masking) - q = OD_MAXI(1, q0 * pvq_qm[od_qm_get_index(bs, i + 1)] >> 4); - else - q = OD_MAXI(1, q0); - - pvq_decode_partition(dec->r, q, size[i], - model, dec->state.adapt, exg + i, ext + i, ref + off[i], out + off[i], - &noref[i], beta[i], is_keyframe, pli, - (pli != 0)*OD_TXSIZES*PVQ_MAX_PARTITIONS + bs*PVQ_MAX_PARTITIONS + i, - &cfl, i == 0 && (i < nb_bands - 1), skip_rest, i, &skip[i], - qm + off[i], qm_inv + off[i]); - if (i == 0 && !skip_rest[0] && bs > 0) { - int skip_dir; - int j; - skip_dir = aom_read_symbol(dec->r, - &dec->state.adapt->pvq.pvq_skip_dir_cdf[(pli != 0) + 2*(bs - 1)][0], 7, - "pvq:skiprest"); - for (j = 0; j < 3; j++) skip_rest[j] = !!(skip_dir & (1 << j)); - } - } - } - *flags = 0; - for (i = nb_bands - 1; i >= 0; i--) { - *flags <<= 1; - *flags |= noref[i]&1; - *flags <<= 1; - *flags |= skip[i]&1; - } -} diff --git a/third_party/aom/av1/decoder/pvq_decoder.h b/third_party/aom/av1/decoder/pvq_decoder.h deleted file mode 100644 index 98970663be..0000000000 --- a/third_party/aom/av1/decoder/pvq_decoder.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) 2001-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. - */ - -/* clang-format off */ - -#if !defined(_pvq_decoder_H) -# define _pvq_decoder_H (1) -# include "aom_dsp/bitreader.h" -# include "aom_dsp/entdec.h" -# include "av1/common/pvq.h" -# include "av1/decoder/decint.h" - -#define aom_read_symbol_pvq(r, cdf, nsymbs, ACCT_STR_NAME) \ - aom_read_symbol_pvq_(r, cdf, nsymbs ACCT_STR_ARG(ACCT_STR_NAME)) - -int aom_read_symbol_pvq_(aom_reader *r, aom_cdf_prob *cdf, int nsymbs - ACCT_STR_PARAM); - -void aom_decode_band_pvq_splits(aom_reader *r, od_pvq_codeword_ctx *adapt, - od_coeff *y, int n, int k, int level); - -#define aom_laplace_decode_special(r, decay, ACCT_STR_NAME) \ - aom_laplace_decode_special_(r, decay ACCT_STR_ARG(ACCT_STR_NAME)) - -int aom_laplace_decode_special_(aom_reader *r, unsigned decay ACCT_STR_PARAM); - -void od_pvq_decode(daala_dec_ctx *dec, od_coeff *ref, od_coeff *out, int q0, - int pli, int bs, const od_val16 *beta, int is_keyframe, - unsigned int *flags, PVQ_SKIP_TYPE ac_dc_coded, const int16_t *qm, - const int16_t *qm_inv); - -#endif diff --git a/third_party/aom/av1/decoder/symbolrate.h b/third_party/aom/av1/decoder/symbolrate.h deleted file mode 100644 index 0232877325..0000000000 --- a/third_party/aom/av1/decoder/symbolrate.h +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (c) 2017, 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 "aom_dsp/bitreader.h" - -#ifndef AV1_DECODER_SYMBOLRATE_H_ -#define AV1_DECODER_SYMBOLRATE_H_ - -#if CONFIG_SYMBOLRATE -static INLINE void av1_dump_symbol_rate(struct AV1Common *cm) { - const FRAME_COUNTS *counts = &cm->counts; - printf("%d %d %d %d\n", counts->coeff_num[0], counts->coeff_num[1], - counts->symbol_num[0], counts->symbol_num[1]); -} -static INLINE int av1_read_record_symbol(FRAME_COUNTS *counts, aom_reader *r, - aom_cdf_prob *cdf, int nsymbs, - const char *str) { - (void)str; - if (counts) ++counts->symbol_num[0]; - return aom_read_symbol(r, cdf, nsymbs, str); -} - -#if CONFIG_LV_MAP -static INLINE int av1_read_record_bin(FRAME_COUNTS *counts, aom_reader *r, - aom_cdf_prob *cdf, int nsymbs, - const char *str) { - (void)str; - if (counts) ++counts->symbol_num[0]; - return aom_read_bin(r, cdf, nsymbs, str); -} -#endif - -static INLINE int av1_read_record(FRAME_COUNTS *counts, aom_reader *r, int prob, - const char *str) { - (void)str; - if (counts) ++counts->symbol_num[0]; - return aom_read(r, prob, str); -} - -static INLINE int av1_read_record_cdf(FRAME_COUNTS *counts, aom_reader *r, - const aom_cdf_prob *cdf, int nsymbs, - const char *str) { - (void)str; - if (counts) ++counts->symbol_num[0]; - return aom_read_cdf(r, cdf, nsymbs, str); -} - -static INLINE int av1_read_record_bit(FRAME_COUNTS *counts, aom_reader *r, - const char *str) { - (void)str; - if (counts) ++counts->symbol_num[1]; - return aom_read_bit(r, str); -} - -static INLINE void av1_record_coeff(FRAME_COUNTS *counts, tran_low_t qcoeff) { - assert(qcoeff >= 0); - if (counts) ++counts->coeff_num[qcoeff != 0]; -} -#else // CONFIG_SYMBOLRATE - -#define av1_read_record_symbol(counts, r, cdf, nsymbs, ACCT_STR_NAME) \ - aom_read_symbol(r, cdf, nsymbs, ACCT_STR_NAME) - -#if CONFIG_LV_MAP -#define av1_read_record_bin(counts, r, cdf, nsymbs, ACCT_STR_NAME) \ - aom_read_bin(r, cdf, nsymbs, ACCT_STR_NAME) -#endif - -#define av1_read_record(counts, r, prob, ACCT_STR_NAME) \ - aom_read(r, prob, ACCT_STR_NAME) - -#define av1_read_record_cdf(counts, r, cdf, nsymbs, ACCT_STR_NAME) \ - aom_read_cdf(r, cdf, nsymbs, ACCT_STR_NAME) - -#define av1_read_record_bit(counts, r, ACCT_STR_NAME) \ - aom_read_bit(r, ACCT_STR_NAME) - -#endif // CONFIG_SYMBOLRATE - -#endif // AV1_DECODER_SYMBOLRATE_H_ |