| /* |
| * Copyright (c) 2021, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 3-Clause Clear License |
| * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear |
| * License was not distributed with this source code in the LICENSE file, you |
| * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the |
| * Alliance for Open Media Patent License 1.0 was not distributed with this |
| * source code in the PATENTS file, you can obtain it at |
| * aomedia.org/license/patent-license/. |
| */ |
| |
| #include <assert.h> |
| #include <stddef.h> |
| |
| #include "config/aom_config.h" |
| #include "config/aom_dsp_rtcd.h" |
| #include "config/aom_scale_rtcd.h" |
| #include "config/av1_rtcd.h" |
| |
| #include "aom/aom_codec.h" |
| #include "aom_dsp/aom_dsp_common.h" |
| #include "aom_dsp/binary_codes_reader.h" |
| #include "aom_dsp/bitreader.h" |
| #include "aom_dsp/bitreader_buffer.h" |
| #include "aom_mem/aom_mem.h" |
| #include "aom_ports/aom_timer.h" |
| #include "aom_ports/mem.h" |
| #include "aom_ports/mem_ops.h" |
| #include "aom_scale/aom_scale.h" |
| #include "aom_util/aom_thread.h" |
| |
| #if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG |
| #include "aom_util/debug_util.h" |
| #endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG |
| |
| #include "av1/common/alloccommon.h" |
| #include "av1/common/cdef.h" |
| #if CONFIG_CCSO |
| #include "av1/common/ccso.h" |
| #endif |
| #include "av1/common/cfl.h" |
| #if CONFIG_INSPECTION |
| #include "av1/decoder/inspection.h" |
| #endif |
| #include "av1/common/common.h" |
| #include "av1/common/entropy.h" |
| #include "av1/common/entropymode.h" |
| #include "av1/common/entropymv.h" |
| #include "av1/common/frame_buffers.h" |
| #include "av1/common/idct.h" |
| #include "av1/common/mvref_common.h" |
| #include "av1/common/pred_common.h" |
| #include "av1/common/quant_common.h" |
| #include "av1/common/reconinter.h" |
| #include "av1/common/reconintra.h" |
| #include "av1/common/resize.h" |
| #include "av1/common/seg_common.h" |
| #include "av1/common/thread_common.h" |
| #include "av1/common/tile_common.h" |
| #include "av1/common/warped_motion.h" |
| #include "av1/common/obmc.h" |
| #include "av1/decoder/decodeframe.h" |
| #include "av1/decoder/decodemv.h" |
| #include "av1/decoder/decoder.h" |
| #include "av1/decoder/decodetxb.h" |
| #include "av1/decoder/detokenize.h" |
| |
| #define ACCT_STR __func__ |
| |
| #define AOM_MIN_THREADS_PER_TILE 1 |
| #define AOM_MAX_THREADS_PER_TILE 2 |
| |
| // This is needed by ext_tile related unit tests. |
| #define EXT_TILE_DEBUG 1 |
| #define MC_TEMP_BUF_PELS \ |
| (((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2) * \ |
| ((MAX_SB_SIZE)*2 + (AOM_INTERP_EXTEND)*2)) |
| |
| #if CONFIG_THROUGHPUT_ANALYSIS |
| int64_t tot_ctx_syms = { 0 }; |
| int64_t tot_bypass_syms = { 0 }; |
| int max_ctx_syms = { 0 }; |
| int max_bypass_syms = { 0 }; |
| int max_bits = { 0 }; |
| int64_t tot_bits = { 0 }; |
| int tot_frames = { 0 }; |
| #endif // CONFIG_THROUGHPUT_ANALYSIS |
| |
| // Checks that the remaining bits start with a 1 and ends with 0s. |
| // It consumes an additional byte, if already byte aligned before the check. |
| int av1_check_trailing_bits(AV1Decoder *pbi, struct aom_read_bit_buffer *rb) { |
| AV1_COMMON *const cm = &pbi->common; |
| // bit_offset is set to 0 (mod 8) when the reader is already byte aligned |
| int bits_before_alignment = 8 - rb->bit_offset % 8; |
| int trailing = aom_rb_read_literal(rb, bits_before_alignment); |
| if (trailing != (1 << (bits_before_alignment - 1))) { |
| cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; |
| return -1; |
| } |
| return 0; |
| } |
| |
| // Use only_chroma = 1 to only set the chroma planes |
| static AOM_INLINE void set_planes_to_neutral_grey( |
| const SequenceHeader *const seq_params, const YV12_BUFFER_CONFIG *const buf, |
| int only_chroma) { |
| if (seq_params->use_highbitdepth) { |
| const int val = 1 << (seq_params->bit_depth - 1); |
| for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) { |
| const int is_uv = plane > 0; |
| uint16_t *const base = CONVERT_TO_SHORTPTR(buf->buffers[plane]); |
| // Set the first row to neutral grey. Then copy the first row to all |
| // subsequent rows. |
| if (buf->crop_heights[is_uv] > 0) { |
| aom_memset16(base, val, buf->crop_widths[is_uv]); |
| for (int row_idx = 1; row_idx < buf->crop_heights[is_uv]; row_idx++) { |
| memcpy(&base[row_idx * buf->strides[is_uv]], base, |
| sizeof(*base) * buf->crop_widths[is_uv]); |
| } |
| } |
| } |
| } else { |
| for (int plane = only_chroma; plane < MAX_MB_PLANE; plane++) { |
| const int is_uv = plane > 0; |
| for (int row_idx = 0; row_idx < buf->crop_heights[is_uv]; row_idx++) { |
| memset(&buf->buffers[plane][row_idx * buf->uv_stride], 1 << 7, |
| buf->crop_widths[is_uv]); |
| } |
| } |
| } |
| } |
| |
| static AOM_INLINE void loop_restoration_read_sb_coeffs( |
| const AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane, |
| int runit_idx); |
| |
| static int read_is_valid(const uint8_t *start, size_t len, const uint8_t *end) { |
| return len != 0 && len <= (size_t)(end - start); |
| } |
| |
| static TX_MODE read_tx_mode(struct aom_read_bit_buffer *rb, |
| int coded_lossless) { |
| if (coded_lossless) return ONLY_4X4; |
| return aom_rb_read_bit(rb) ? TX_MODE_SELECT : TX_MODE_LARGEST; |
| } |
| |
| static REFERENCE_MODE read_frame_reference_mode( |
| const AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { |
| if (frame_is_intra_only(cm)) { |
| return SINGLE_REFERENCE; |
| } else { |
| return aom_rb_read_bit(rb) ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE; |
| } |
| } |
| |
| static AOM_INLINE void inverse_transform_block(DecoderCodingBlock *dcb, |
| int plane, const TX_TYPE tx_type, |
| const TX_SIZE tx_size, |
| uint8_t *dst, int stride, |
| int reduced_tx_set) { |
| #if CONFIG_IST |
| tran_low_t *dqcoeff = dcb->dqcoeff_block[plane] + dcb->cb_offset[plane]; |
| #else |
| tran_low_t *const dqcoeff = dcb->dqcoeff_block[plane] + dcb->cb_offset[plane]; |
| #endif |
| eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane]; |
| uint16_t scan_line = eob_data->max_scan_line; |
| uint16_t eob = eob_data->eob; |
| av1_inverse_transform_block(&dcb->xd, dqcoeff, plane, tx_type, tx_size, dst, |
| stride, eob, reduced_tx_set); |
| #if CONFIG_IST |
| const int width = tx_size_wide[tx_size] <= 32 ? tx_size_wide[tx_size] : 32; |
| const int height = tx_size_high[tx_size] <= 32 ? tx_size_high[tx_size] : 32; |
| const int sbSize = (width >= 8 && height >= 8) ? 8 : 4; |
| int32_t nz0 = (sbSize - 1) * tx_size_wide[tx_size] + sbSize; |
| int32_t nz1 = (scan_line + 1); |
| memset(dqcoeff, 0, AOMMAX(nz0, nz1) * sizeof(dqcoeff[0])); |
| #else |
| memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0])); |
| #endif |
| } |
| |
| static AOM_INLINE void read_coeffs_tx_intra_block( |
| const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r, |
| const int plane, const int row, const int col, const TX_SIZE tx_size) { |
| MB_MODE_INFO *mbmi = dcb->xd.mi[0]; |
| #if CONFIG_SDP |
| if (!mbmi->skip_txfm[dcb->xd.tree_type == CHROMA_PART]) { |
| #else |
| if (!mbmi->skip_txfm) { |
| #endif |
| #if TXCOEFF_TIMER |
| struct aom_usec_timer timer; |
| aom_usec_timer_start(&timer); |
| #endif |
| av1_read_coeffs_txb_facade(cm, dcb, r, plane, row, col, tx_size); |
| #if TXCOEFF_TIMER |
| aom_usec_timer_mark(&timer); |
| const int64_t elapsed_time = aom_usec_timer_elapsed(&timer); |
| cm->txcoeff_timer += elapsed_time; |
| ++cm->txb_count; |
| #endif |
| } |
| } |
| |
| static AOM_INLINE void decode_block_void(const AV1_COMMON *const cm, |
| DecoderCodingBlock *dcb, |
| aom_reader *const r, const int plane, |
| const int row, const int col, |
| const TX_SIZE tx_size) { |
| (void)cm; |
| (void)dcb; |
| (void)r; |
| (void)plane; |
| (void)row; |
| (void)col; |
| (void)tx_size; |
| } |
| |
| static AOM_INLINE void predict_inter_block_void(AV1_COMMON *const cm, |
| DecoderCodingBlock *dcb, |
| BLOCK_SIZE bsize) { |
| (void)cm; |
| (void)dcb; |
| (void)bsize; |
| } |
| |
| static AOM_INLINE void cfl_store_inter_block_void(AV1_COMMON *const cm, |
| MACROBLOCKD *const xd) { |
| (void)cm; |
| (void)xd; |
| } |
| |
| static AOM_INLINE void predict_and_reconstruct_intra_block( |
| const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r, |
| const int plane, const int row, const int col, const TX_SIZE tx_size) { |
| (void)r; |
| MACROBLOCKD *const xd = &dcb->xd; |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| PLANE_TYPE plane_type = get_plane_type(plane); |
| |
| av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size); |
| #if CONFIG_SDP |
| if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) { |
| #else |
| if (!mbmi->skip_txfm) { |
| #endif |
| eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane]; |
| if (eob_data->eob) { |
| const bool reduced_tx_set_used = cm->features.reduced_tx_set_used; |
| // tx_type was read out in av1_read_coeffs_txb. |
| const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, row, col, tx_size, |
| reduced_tx_set_used); |
| struct macroblockd_plane *const pd = &xd->plane[plane]; |
| uint8_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2]; |
| inverse_transform_block(dcb, plane, tx_type, tx_size, dst, pd->dst.stride, |
| reduced_tx_set_used); |
| } |
| } |
| #if CONFIG_SDP |
| if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd) && |
| xd->tree_type == SHARED_PART) { |
| #else |
| if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) { |
| #endif |
| #if CONFIG_SDP |
| cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type[AOM_PLANE_Y]); |
| #else |
| cfl_store_tx(xd, row, col, tx_size, mbmi->sb_type); |
| #endif |
| } |
| } |
| |
| static AOM_INLINE void inverse_transform_inter_block( |
| const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r, |
| const int plane, const int blk_row, const int blk_col, |
| const TX_SIZE tx_size) { |
| (void)r; |
| MACROBLOCKD *const xd = &dcb->xd; |
| PLANE_TYPE plane_type = get_plane_type(plane); |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| const bool reduced_tx_set_used = cm->features.reduced_tx_set_used; |
| // tx_type was read out in av1_read_coeffs_txb. |
| const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col, |
| tx_size, reduced_tx_set_used); |
| |
| uint8_t *dst = |
| &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2]; |
| inverse_transform_block(dcb, plane, tx_type, tx_size, dst, pd->dst.stride, |
| reduced_tx_set_used); |
| #if CONFIG_MISMATCH_DEBUG |
| int pixel_c, pixel_r; |
| BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; |
| int blk_w = block_size_wide[bsize]; |
| int blk_h = block_size_high[bsize]; |
| const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2); |
| const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2); |
| mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row, |
| pd->subsampling_x, pd->subsampling_y); |
| mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint, |
| plane, pixel_c, pixel_r, blk_w, blk_h, |
| xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH); |
| #endif |
| } |
| |
| static AOM_INLINE void set_cb_buffer_offsets(DecoderCodingBlock *dcb, |
| TX_SIZE tx_size, int plane) { |
| dcb->cb_offset[plane] += tx_size_wide[tx_size] * tx_size_high[tx_size]; |
| dcb->txb_offset[plane] = |
| dcb->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN); |
| } |
| |
| static AOM_INLINE void decode_reconstruct_tx( |
| AV1_COMMON *cm, ThreadData *const td, aom_reader *r, |
| MB_MODE_INFO *const mbmi, int plane, BLOCK_SIZE plane_bsize, int blk_row, |
| int blk_col, int block, TX_SIZE tx_size, int *eob_total) { |
| DecoderCodingBlock *const dcb = &td->dcb; |
| MACROBLOCKD *const xd = &dcb->xd; |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| #if CONFIG_SDP |
| if (xd->tree_type == SHARED_PART) |
| assert(mbmi->sb_type[PLANE_TYPE_Y] == mbmi->sb_type[PLANE_TYPE_UV]); |
| const TX_SIZE plane_tx_size = |
| plane ? av1_get_max_uv_txsize(mbmi->sb_type[plane > 0], pd->subsampling_x, |
| pd->subsampling_y) |
| : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row, |
| blk_col)]; |
| #else |
| const TX_SIZE plane_tx_size = |
| plane ? av1_get_max_uv_txsize(mbmi->sb_type, pd->subsampling_x, |
| pd->subsampling_y) |
| : mbmi->inter_tx_size[av1_get_txb_size_index(plane_bsize, blk_row, |
| blk_col)]; |
| #endif |
| // Scale to match transform block unit. |
| const int max_blocks_high = max_block_high(xd, plane_bsize, plane); |
| const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane); |
| |
| if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; |
| |
| if (tx_size == plane_tx_size || plane) { |
| td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col, |
| tx_size); |
| |
| td->inverse_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col, |
| tx_size); |
| eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane]; |
| *eob_total += eob_data->eob; |
| set_cb_buffer_offsets(dcb, tx_size, plane); |
| } else { |
| #if CONFIG_NEW_TX_PARTITION |
| TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 }; |
| const int index = av1_get_txb_size_index(plane_bsize, blk_row, blk_col); |
| get_tx_partition_sizes(mbmi->partition_type[index], tx_size, sub_txs); |
| int cur_partition = 0; |
| int bsw = 0, bsh = 0; |
| for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { |
| for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { |
| const TX_SIZE sub_tx = sub_txs[cur_partition]; |
| bsw = tx_size_wide_unit[sub_tx]; |
| bsh = tx_size_high_unit[sub_tx]; |
| const int sub_step = bsw * bsh; |
| const int offsetr = blk_row + row; |
| const int offsetc = blk_col + col; |
| if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; |
| |
| td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, offsetr, |
| offsetc, sub_tx); |
| td->inverse_tx_inter_block_visit(cm, dcb, r, plane, offsetr, offsetc, |
| sub_tx); |
| eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane]; |
| *eob_total += eob_data->eob; |
| set_cb_buffer_offsets(dcb, sub_tx, plane); |
| block += sub_step; |
| cur_partition++; |
| } |
| } |
| #else |
| const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; |
| assert(IMPLIES(tx_size <= TX_4X4, sub_txs == tx_size)); |
| assert(IMPLIES(tx_size > TX_4X4, sub_txs < tx_size)); |
| const int bsw = tx_size_wide_unit[sub_txs]; |
| const int bsh = tx_size_high_unit[sub_txs]; |
| const int sub_step = bsw * bsh; |
| |
| assert(bsw > 0 && bsh > 0); |
| |
| for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { |
| for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { |
| const int offsetr = blk_row + row; |
| const int offsetc = blk_col + col; |
| |
| if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; |
| |
| decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize, offsetr, |
| offsetc, block, sub_txs, eob_total); |
| block += sub_step; |
| } |
| } |
| #endif // CONFIG_NEW_TX_PARTITION |
| } |
| } |
| |
| static AOM_INLINE void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd, |
| BLOCK_SIZE bsize, int mi_row, int mi_col, |
| int bw, int bh, int x_mis, int y_mis) { |
| const int num_planes = av1_num_planes(cm); |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| const TileInfo *const tile = &xd->tile; |
| |
| set_mi_offsets(mi_params, xd, mi_row, mi_col); |
| #if CONFIG_SDP |
| xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART] = bsize; |
| #else |
| xd->mi[0]->sb_type = bsize; |
| #endif |
| #if CONFIG_RD_DEBUG |
| xd->mi[0]->mi_row = mi_row; |
| xd->mi[0]->mi_col = mi_col; |
| #endif |
| |
| #if CONFIG_SDP |
| if (xd->tree_type == SHARED_PART) { |
| #endif |
| assert(x_mis && y_mis); |
| for (int x = 1; x < x_mis; ++x) xd->mi[x] = xd->mi[0]; |
| int idx = mi_params->mi_stride; |
| for (int y = 1; y < y_mis; ++y) { |
| memcpy(&xd->mi[idx], &xd->mi[0], x_mis * sizeof(xd->mi[0])); |
| idx += mi_params->mi_stride; |
| } |
| #if CONFIG_SDP |
| } |
| #endif |
| |
| set_plane_n4(xd, bw, bh, num_planes); |
| set_entropy_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, mi_params->mi_rows, |
| mi_params->mi_cols); |
| |
| av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0, |
| num_planes); |
| } |
| |
| static AOM_INLINE void decode_mbmi_block(AV1Decoder *const pbi, |
| DecoderCodingBlock *dcb, int mi_row, |
| int mi_col, aom_reader *r, |
| PARTITION_TYPE partition, |
| BLOCK_SIZE bsize) { |
| AV1_COMMON *const cm = &pbi->common; |
| const SequenceHeader *const seq_params = &cm->seq_params; |
| const int bw = mi_size_wide[bsize]; |
| const int bh = mi_size_high[bsize]; |
| const int x_mis = AOMMIN(bw, cm->mi_params.mi_cols - mi_col); |
| const int y_mis = AOMMIN(bh, cm->mi_params.mi_rows - mi_row); |
| MACROBLOCKD *const xd = &dcb->xd; |
| |
| #if CONFIG_ACCOUNTING |
| aom_accounting_set_context(&pbi->accounting, mi_col, mi_row); |
| #endif |
| set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis); |
| xd->mi[0]->partition = partition; |
| av1_read_mode_info(pbi, dcb, r, x_mis, y_mis); |
| if (bsize >= BLOCK_8X8 && |
| (seq_params->subsampling_x || seq_params->subsampling_y)) { |
| const BLOCK_SIZE uv_subsize = |
| ss_size_lookup[bsize][seq_params->subsampling_x] |
| [seq_params->subsampling_y]; |
| if (uv_subsize == BLOCK_INVALID) |
| aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, |
| "Invalid block size."); |
| } |
| } |
| |
| typedef struct PadBlock { |
| int x0; |
| int x1; |
| int y0; |
| int y1; |
| } PadBlock; |
| |
| static AOM_INLINE void highbd_build_mc_border(const uint8_t *src8, |
| int src_stride, uint8_t *dst8, |
| int dst_stride, int x, int y, |
| int b_w, int b_h, int w, int h) { |
| // Get a pointer to the start of the real data for this row. |
| const uint16_t *src = CONVERT_TO_SHORTPTR(src8); |
| uint16_t *dst = CONVERT_TO_SHORTPTR(dst8); |
| const uint16_t *ref_row = src - x - y * src_stride; |
| |
| if (y >= h) |
| ref_row += (h - 1) * src_stride; |
| else if (y > 0) |
| ref_row += y * src_stride; |
| |
| do { |
| int right = 0, copy; |
| int left = x < 0 ? -x : 0; |
| |
| if (left > b_w) left = b_w; |
| |
| if (x + b_w > w) right = x + b_w - w; |
| |
| if (right > b_w) right = b_w; |
| |
| copy = b_w - left - right; |
| |
| if (left) aom_memset16(dst, ref_row[0], left); |
| |
| if (copy) memcpy(dst + left, ref_row + x + left, copy * sizeof(uint16_t)); |
| |
| if (right) aom_memset16(dst + left + copy, ref_row[w - 1], right); |
| |
| dst += dst_stride; |
| ++y; |
| |
| if (y > 0 && y < h) ref_row += src_stride; |
| } while (--b_h); |
| } |
| |
| static AOM_INLINE void build_mc_border(const uint8_t *src, int src_stride, |
| uint8_t *dst, int dst_stride, int x, |
| int y, int b_w, int b_h, int w, int h) { |
| // Get a pointer to the start of the real data for this row. |
| const uint8_t *ref_row = src - x - y * src_stride; |
| |
| if (y >= h) |
| ref_row += (h - 1) * src_stride; |
| else if (y > 0) |
| ref_row += y * src_stride; |
| |
| do { |
| int right = 0, copy; |
| int left = x < 0 ? -x : 0; |
| |
| if (left > b_w) left = b_w; |
| |
| if (x + b_w > w) right = x + b_w - w; |
| |
| if (right > b_w) right = b_w; |
| |
| copy = b_w - left - right; |
| |
| if (left) memset(dst, ref_row[0], left); |
| |
| if (copy) memcpy(dst + left, ref_row + x + left, copy); |
| |
| if (right) memset(dst + left + copy, ref_row[w - 1], right); |
| |
| dst += dst_stride; |
| ++y; |
| |
| if (y > 0 && y < h) ref_row += src_stride; |
| } while (--b_h); |
| } |
| |
| static INLINE int update_extend_mc_border_params( |
| const struct scale_factors *const sf, struct buf_2d *const pre_buf, |
| MV32 scaled_mv, PadBlock *block, int subpel_x_mv, int subpel_y_mv, |
| int do_warp, int is_intrabc, int *x_pad, int *y_pad) { |
| // Get reference width and height. |
| int frame_width = pre_buf->width; |
| int frame_height = pre_buf->height; |
| |
| // Do border extension if there is motion or |
| // width/height is not a multiple of 8 pixels. |
| #if CONFIG_OPTFLOW_REFINEMENT |
| // Extension is needed in optical flow refinement to obtain MV offsets |
| (void)scaled_mv; |
| if (!is_intrabc && !do_warp) { |
| #else |
| const int is_scaled = av1_is_scaled(sf); |
| if ((!is_intrabc) && (!do_warp) && |
| (is_scaled || scaled_mv.col || scaled_mv.row || (frame_width & 0x7) || |
| (frame_height & 0x7))) { |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| if (subpel_x_mv || (sf->x_step_q4 != SUBPEL_SHIFTS)) { |
| block->x0 -= AOM_INTERP_EXTEND - 1; |
| block->x1 += AOM_INTERP_EXTEND; |
| *x_pad = 1; |
| } |
| |
| if (subpel_y_mv || (sf->y_step_q4 != SUBPEL_SHIFTS)) { |
| block->y0 -= AOM_INTERP_EXTEND - 1; |
| block->y1 += AOM_INTERP_EXTEND; |
| *y_pad = 1; |
| } |
| |
| // Skip border extension if block is inside the frame. |
| if (block->x0 < 0 || block->x1 > frame_width - 1 || block->y0 < 0 || |
| block->y1 > frame_height - 1) { |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| static INLINE void extend_mc_border(const struct scale_factors *const sf, |
| struct buf_2d *const pre_buf, |
| MV32 scaled_mv, PadBlock block, |
| int subpel_x_mv, int subpel_y_mv, |
| int do_warp, int is_intrabc, 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_calc_subpel_params( |
| const MV *const src_mv, InterPredParams *const inter_pred_params, |
| const MACROBLOCKD *const xd, int mi_x, int mi_y, uint8_t **pre, |
| SubpelParams *subpel_params, int *src_stride, PadBlock *block, |
| #if CONFIG_OPTFLOW_REFINEMENT |
| int use_optflow_refinement, |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| MV32 *scaled_mv, int *subpel_x_mv, int *subpel_y_mv) { |
| const struct scale_factors *sf = inter_pred_params->scale_factors; |
| struct buf_2d *pre_buf = &inter_pred_params->ref_frame_buf; |
| #if CONFIG_OPTFLOW_REFINEMENT |
| // Use original block size to clamp MV and to extend block boundary |
| const int bw = use_optflow_refinement ? inter_pred_params->orig_block_width |
| : inter_pred_params->block_width; |
| const int bh = use_optflow_refinement ? inter_pred_params->orig_block_height |
| : inter_pred_params->block_height; |
| #else |
| const int bw = inter_pred_params->block_width; |
| const int bh = inter_pred_params->block_height; |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| const int is_scaled = av1_is_scaled(sf); |
| if (is_scaled) { |
| int ssx = inter_pred_params->subsampling_x; |
| int ssy = inter_pred_params->subsampling_y; |
| int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS; |
| int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS; |
| #if CONFIG_OPTFLOW_REFINEMENT |
| if (use_optflow_refinement) { |
| orig_pos_y += ROUND_POWER_OF_TWO_SIGNED(src_mv->row * (1 << SUBPEL_BITS), |
| MV_REFINE_PREC_BITS + ssy); |
| orig_pos_x += ROUND_POWER_OF_TWO_SIGNED(src_mv->col * (1 << SUBPEL_BITS), |
| MV_REFINE_PREC_BITS + ssx); |
| } else { |
| orig_pos_y += src_mv->row * (1 << (1 - ssy)); |
| orig_pos_x += src_mv->col * (1 << (1 - ssx)); |
| } |
| #else |
| orig_pos_y += src_mv->row * (1 << (1 - ssy)); |
| orig_pos_x += src_mv->col * (1 << (1 - ssx)); |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| int pos_y = sf->scale_value_y(orig_pos_y, sf); |
| int pos_x = sf->scale_value_x(orig_pos_x, sf); |
| pos_x += SCALE_EXTRA_OFF; |
| pos_y += SCALE_EXTRA_OFF; |
| |
| const int top = -AOM_LEFT_TOP_MARGIN_SCALED(ssy); |
| const int left = -AOM_LEFT_TOP_MARGIN_SCALED(ssx); |
| const int bottom = (pre_buf->height + AOM_INTERP_EXTEND) |
| << SCALE_SUBPEL_BITS; |
| const int right = (pre_buf->width + AOM_INTERP_EXTEND) << SCALE_SUBPEL_BITS; |
| pos_y = clamp(pos_y, top, bottom); |
| pos_x = clamp(pos_x, left, right); |
| |
| subpel_params->subpel_x = pos_x & SCALE_SUBPEL_MASK; |
| subpel_params->subpel_y = pos_y & SCALE_SUBPEL_MASK; |
| subpel_params->xs = sf->x_step_q4; |
| subpel_params->ys = sf->y_step_q4; |
| |
| // Get reference block top left coordinate. |
| block->x0 = pos_x >> SCALE_SUBPEL_BITS; |
| block->y0 = pos_y >> SCALE_SUBPEL_BITS; |
| |
| // Get reference block bottom right coordinate. |
| block->x1 = |
| ((pos_x + (inter_pred_params->block_width - 1) * subpel_params->xs) >> |
| SCALE_SUBPEL_BITS) + |
| 1; |
| block->y1 = |
| ((pos_y + (inter_pred_params->block_height - 1) * subpel_params->ys) >> |
| SCALE_SUBPEL_BITS) + |
| 1; |
| |
| MV temp_mv; |
| temp_mv = clamp_mv_to_umv_border_sb(xd, src_mv, bw, bh, |
| #if CONFIG_OPTFLOW_REFINEMENT |
| use_optflow_refinement, |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| inter_pred_params->subsampling_x, |
| inter_pred_params->subsampling_y); |
| *scaled_mv = av1_scale_mv(&temp_mv, mi_x, mi_y, sf); |
| scaled_mv->row += SCALE_EXTRA_OFF; |
| scaled_mv->col += SCALE_EXTRA_OFF; |
| |
| *subpel_x_mv = scaled_mv->col & SCALE_SUBPEL_MASK; |
| *subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK; |
| } else { |
| // Get block position in current frame. |
| int pos_x = inter_pred_params->pix_col << SUBPEL_BITS; |
| int pos_y = inter_pred_params->pix_row << SUBPEL_BITS; |
| |
| const MV mv_q4 = clamp_mv_to_umv_border_sb( |
| xd, src_mv, bw, bh, |
| #if CONFIG_OPTFLOW_REFINEMENT |
| use_optflow_refinement, |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| inter_pred_params->subsampling_x, inter_pred_params->subsampling_y); |
| subpel_params->xs = subpel_params->ys = SCALE_SUBPEL_SHIFTS; |
| subpel_params->subpel_x = (mv_q4.col & SUBPEL_MASK) << SCALE_EXTRA_BITS; |
| subpel_params->subpel_y = (mv_q4.row & SUBPEL_MASK) << SCALE_EXTRA_BITS; |
| |
| // Get reference block top left coordinate. |
| pos_x += mv_q4.col; |
| pos_y += mv_q4.row; |
| block->x0 = pos_x >> SUBPEL_BITS; |
| block->y0 = pos_y >> SUBPEL_BITS; |
| |
| // Get reference block bottom right coordinate. |
| block->x1 = |
| (pos_x >> SUBPEL_BITS) + (inter_pred_params->block_width - 1) + 1; |
| block->y1 = |
| (pos_y >> SUBPEL_BITS) + (inter_pred_params->block_height - 1) + 1; |
| |
| scaled_mv->row = mv_q4.row; |
| scaled_mv->col = mv_q4.col; |
| *subpel_x_mv = scaled_mv->col & SUBPEL_MASK; |
| *subpel_y_mv = scaled_mv->row & SUBPEL_MASK; |
| } |
| *pre = pre_buf->buf0 + block->y0 * pre_buf->stride + block->x0; |
| *src_stride = pre_buf->stride; |
| } |
| |
| static void dec_calc_subpel_params_and_extend( |
| const MV *const src_mv, InterPredParams *const inter_pred_params, |
| MACROBLOCKD *const xd, int mi_x, int mi_y, int ref, |
| #if CONFIG_OPTFLOW_REFINEMENT |
| int use_optflow_refinement, |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| uint8_t **mc_buf, uint8_t **pre, SubpelParams *subpel_params, |
| int *src_stride) { |
| PadBlock block; |
| MV32 scaled_mv; |
| int subpel_x_mv, subpel_y_mv; |
| dec_calc_subpel_params(src_mv, inter_pred_params, xd, mi_x, mi_y, pre, |
| subpel_params, src_stride, &block, |
| #if CONFIG_OPTFLOW_REFINEMENT |
| use_optflow_refinement, |
| #endif // CONFIG_OPTFLOW_REFINEMENT |
| &scaled_mv, &subpel_x_mv, &subpel_y_mv); |
| extend_mc_border( |
| inter_pred_params->scale_factors, &inter_pred_params->ref_frame_buf, |
| scaled_mv, block, subpel_x_mv, subpel_y_mv, |
| inter_pred_params->mode == WARP_PRED, inter_pred_params->is_intrabc, |
| inter_pred_params->use_hbd_buf, mc_buf[ref], pre, src_stride); |
| } |
| |
| static void dec_build_inter_predictors(const AV1_COMMON *cm, |
| DecoderCodingBlock *dcb, int plane, |
| MB_MODE_INFO *mi, int build_for_obmc, |
| int bw, int bh, int mi_x, int mi_y) { |
| av1_build_inter_predictors(cm, &dcb->xd, plane, mi, build_for_obmc, bw, bh, |
| mi_x, mi_y, dcb->mc_buf, |
| dec_calc_subpel_params_and_extend); |
| } |
| |
| static AOM_INLINE void dec_build_inter_predictor(const AV1_COMMON *cm, |
| DecoderCodingBlock *dcb, |
| int mi_row, int mi_col, |
| BLOCK_SIZE bsize) { |
| MACROBLOCKD *const xd = &dcb->xd; |
| const int num_planes = av1_num_planes(cm); |
| for (int plane = 0; plane < num_planes; ++plane) { |
| if (plane && !xd->is_chroma_ref) break; |
| const int mi_x = mi_col * MI_SIZE; |
| const int mi_y = mi_row * MI_SIZE; |
| dec_build_inter_predictors(cm, dcb, plane, xd->mi[0], 0, |
| xd->plane[plane].width, xd->plane[plane].height, |
| mi_x, mi_y); |
| if (is_interintra_pred(xd->mi[0])) { |
| BUFFER_SET ctx = { { xd->plane[0].dst.buf, xd->plane[1].dst.buf, |
| xd->plane[2].dst.buf }, |
| { xd->plane[0].dst.stride, xd->plane[1].dst.stride, |
| xd->plane[2].dst.stride } }; |
| av1_build_interintra_predictor(cm, xd, xd->plane[plane].dst.buf, |
| xd->plane[plane].dst.stride, &ctx, plane, |
| bsize); |
| } |
| } |
| } |
| |
| static INLINE void dec_build_prediction_by_above_pred( |
| MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size, |
| int dir, MB_MODE_INFO *above_mbmi, void *fun_ctxt, const int num_planes) { |
| struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt; |
| const int above_mi_col = xd->mi_col + rel_mi_col; |
| int mi_x, mi_y; |
| MB_MODE_INFO backup_mbmi = *above_mbmi; |
| |
| (void)rel_mi_row; |
| (void)dir; |
| |
| av1_setup_build_prediction_by_above_pred(xd, rel_mi_col, op_mi_size, |
| &backup_mbmi, ctxt, num_planes); |
| mi_x = above_mi_col << MI_SIZE_LOG2; |
| mi_y = xd->mi_row << MI_SIZE_LOG2; |
| #if CONFIG_SDP |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y]; |
| #else |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type; |
| #endif |
| |
| for (int j = 0; j < num_planes; ++j) { |
| const struct macroblockd_plane *pd = &xd->plane[j]; |
| int bw = (op_mi_size * MI_SIZE) >> pd->subsampling_x; |
| int bh = clamp(block_size_high[bsize] >> (pd->subsampling_y + 1), 4, |
| block_size_high[BLOCK_64X64] >> (pd->subsampling_y + 1)); |
| |
| if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 0)) continue; |
| dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j, |
| &backup_mbmi, 1, bw, bh, mi_x, mi_y); |
| } |
| } |
| |
| static AOM_INLINE void dec_build_prediction_by_above_preds( |
| const AV1_COMMON *cm, DecoderCodingBlock *dcb, |
| 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]) { |
| MACROBLOCKD *const xd = &dcb->xd; |
| if (!xd->up_available) return; |
| |
| // Adjust mb_to_bottom_edge to have the correct value for the OBMC |
| // prediction block. This is half the height of the original block, |
| // except for 128-wide blocks, where we only use a height of 32. |
| const int this_height = xd->height * MI_SIZE; |
| const int pred_height = AOMMIN(this_height / 2, 32); |
| xd->mb_to_bottom_edge += GET_MV_SUBPEL(this_height - pred_height); |
| struct build_prediction_ctxt ctxt = { |
| cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_right_edge, dcb |
| }; |
| #if CONFIG_SDP |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type[PLANE_TYPE_Y]; |
| #else |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type; |
| #endif |
| foreach_overlappable_nb_above(cm, xd, |
| max_neighbor_obmc[mi_size_wide_log2[bsize]], |
| dec_build_prediction_by_above_pred, &ctxt); |
| |
| xd->mb_to_left_edge = -GET_MV_SUBPEL(xd->mi_col * MI_SIZE); |
| xd->mb_to_right_edge = ctxt.mb_to_far_edge; |
| xd->mb_to_bottom_edge -= GET_MV_SUBPEL(this_height - pred_height); |
| } |
| |
| static INLINE void dec_build_prediction_by_left_pred( |
| MACROBLOCKD *const xd, int rel_mi_row, int rel_mi_col, uint8_t op_mi_size, |
| int dir, MB_MODE_INFO *left_mbmi, void *fun_ctxt, const int num_planes) { |
| struct build_prediction_ctxt *ctxt = (struct build_prediction_ctxt *)fun_ctxt; |
| const int left_mi_row = xd->mi_row + rel_mi_row; |
| int mi_x, mi_y; |
| MB_MODE_INFO backup_mbmi = *left_mbmi; |
| |
| (void)rel_mi_col; |
| (void)dir; |
| |
| av1_setup_build_prediction_by_left_pred(xd, rel_mi_row, op_mi_size, |
| &backup_mbmi, ctxt, num_planes); |
| mi_x = xd->mi_col << MI_SIZE_LOG2; |
| mi_y = left_mi_row << MI_SIZE_LOG2; |
| #if CONFIG_SDP |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART]; |
| #else |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type; |
| #endif |
| |
| for (int j = 0; j < num_planes; ++j) { |
| const struct macroblockd_plane *pd = &xd->plane[j]; |
| int bw = clamp(block_size_wide[bsize] >> (pd->subsampling_x + 1), 4, |
| block_size_wide[BLOCK_64X64] >> (pd->subsampling_x + 1)); |
| int bh = (op_mi_size << MI_SIZE_LOG2) >> pd->subsampling_y; |
| |
| if (av1_skip_u4x4_pred_in_obmc(bsize, pd, 1)) continue; |
| dec_build_inter_predictors(ctxt->cm, (DecoderCodingBlock *)ctxt->dcb, j, |
| &backup_mbmi, 1, bw, bh, mi_x, mi_y); |
| } |
| } |
| |
| static AOM_INLINE void dec_build_prediction_by_left_preds( |
| const AV1_COMMON *cm, DecoderCodingBlock *dcb, |
| 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]) { |
| MACROBLOCKD *const xd = &dcb->xd; |
| if (!xd->left_available) return; |
| |
| // Adjust mb_to_right_edge to have the correct value for the OBMC |
| // prediction block. This is half the width of the original block, |
| // except for 128-wide blocks, where we only use a width of 32. |
| const int this_width = xd->width * MI_SIZE; |
| const int pred_width = AOMMIN(this_width / 2, 32); |
| xd->mb_to_right_edge += GET_MV_SUBPEL(this_width - pred_width); |
| |
| struct build_prediction_ctxt ctxt = { |
| cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_bottom_edge, dcb |
| }; |
| #if CONFIG_SDP |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART]; |
| #else |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type; |
| #endif |
| foreach_overlappable_nb_left(cm, xd, |
| max_neighbor_obmc[mi_size_high_log2[bsize]], |
| dec_build_prediction_by_left_pred, &ctxt); |
| |
| xd->mb_to_top_edge = -GET_MV_SUBPEL(xd->mi_row * MI_SIZE); |
| xd->mb_to_right_edge -= GET_MV_SUBPEL(this_width - pred_width); |
| xd->mb_to_bottom_edge = ctxt.mb_to_far_edge; |
| } |
| |
| static AOM_INLINE void dec_build_obmc_inter_predictors_sb( |
| const AV1_COMMON *cm, DecoderCodingBlock *dcb) { |
| const int num_planes = av1_num_planes(cm); |
| 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 }; |
| |
| MACROBLOCKD *const xd = &dcb->xd; |
| av1_setup_obmc_dst_bufs(xd, dst_buf1, dst_buf2); |
| |
| dec_build_prediction_by_above_preds(cm, dcb, dst_buf1, dst_width1, |
| dst_height1, dst_stride1); |
| dec_build_prediction_by_left_preds(cm, dcb, dst_buf2, dst_width2, dst_height2, |
| dst_stride2); |
| const int mi_row = xd->mi_row; |
| const int mi_col = xd->mi_col; |
| #if CONFIG_SDP |
| av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type[PLANE_TYPE_Y], |
| &cm->cur_frame->buf, mi_row, mi_col, 0, num_planes); |
| #else |
| av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type, &cm->cur_frame->buf, |
| mi_row, mi_col, 0, num_planes); |
| #endif |
| av1_build_obmc_inter_prediction(cm, xd, dst_buf1, dst_stride1, dst_buf2, |
| dst_stride2); |
| } |
| |
| static AOM_INLINE void cfl_store_inter_block(AV1_COMMON *const cm, |
| MACROBLOCKD *const xd) { |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| #if CONFIG_SDP |
| if (store_cfl_required(cm, xd) && xd->tree_type == SHARED_PART) { |
| #else |
| if (store_cfl_required(cm, xd)) { |
| #endif |
| #if CONFIG_SDP |
| cfl_store_block(xd, mbmi->sb_type[PLANE_TYPE_Y], mbmi->tx_size); |
| #else |
| cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size); |
| #endif |
| } |
| } |
| |
| static AOM_INLINE void predict_inter_block(AV1_COMMON *const cm, |
| DecoderCodingBlock *dcb, |
| BLOCK_SIZE bsize) { |
| MACROBLOCKD *const xd = &dcb->xd; |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| const int num_planes = av1_num_planes(cm); |
| const int mi_row = xd->mi_row; |
| const int mi_col = xd->mi_col; |
| for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) { |
| const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref]; |
| #if CONFIG_NEW_REF_SIGNALING |
| if (frame == INTRA_FRAME_NRS) { |
| #else |
| if (frame < LAST_FRAME) { |
| assert(frame == INTRA_FRAME); |
| #endif // CONFIG_NEW_REF_SIGNALING |
| #if CONFIG_SDP |
| assert(is_intrabc_block(mbmi, xd->tree_type)); |
| #else |
| assert(is_intrabc_block(mbmi)); |
| #endif |
| assert(ref == 0); |
| } else { |
| const RefCntBuffer *ref_buf = get_ref_frame_buf(cm, frame); |
| const struct scale_factors *ref_scale_factors = |
| get_ref_scale_factors_const(cm, frame); |
| |
| xd->block_ref_scale_factors[ref] = ref_scale_factors; |
| av1_setup_pre_planes(xd, ref, &ref_buf->buf, mi_row, mi_col, |
| ref_scale_factors, num_planes); |
| } |
| } |
| |
| dec_build_inter_predictor(cm, dcb, mi_row, mi_col, bsize); |
| if (mbmi->motion_mode == OBMC_CAUSAL) { |
| dec_build_obmc_inter_predictors_sb(cm, dcb); |
| } |
| |
| #if CONFIG_MISMATCH_DEBUG |
| 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->current_frame.order_hint, plane, pixel_c, |
| pixel_r, pd->width, pd->height, |
| xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH); |
| } |
| #endif |
| } |
| |
| static AOM_INLINE void set_color_index_map_offset(MACROBLOCKD *const xd, |
| int plane, aom_reader *r) { |
| (void)r; |
| Av1ColorMapParam params; |
| const MB_MODE_INFO *const mbmi = xd->mi[0]; |
| #if CONFIG_SDP |
| av1_get_block_dimensions(mbmi->sb_type[plane > 0], plane, xd, |
| ¶ms.plane_width, ¶ms.plane_height, NULL, |
| NULL); |
| #else |
| av1_get_block_dimensions(mbmi->sb_type, plane, xd, ¶ms.plane_width, |
| ¶ms.plane_height, NULL, NULL); |
| #endif |
| xd->color_index_map_offset[plane] += params.plane_width * params.plane_height; |
| } |
| |
| static AOM_INLINE void decode_token_recon_block(AV1Decoder *const pbi, |
| ThreadData *const td, |
| aom_reader *r, |
| #if CONFIG_SDP |
| PARTITION_TYPE partition, |
| #endif |
| BLOCK_SIZE bsize) { |
| AV1_COMMON *const cm = &pbi->common; |
| DecoderCodingBlock *const dcb = &td->dcb; |
| MACROBLOCKD *const xd = &dcb->xd; |
| const int num_planes = av1_num_planes(cm); |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| #if CONFIG_SDP |
| xd->mi[0]->partition = partition; |
| const int plane_start = (xd->tree_type == CHROMA_PART); |
| const int plane_end = (xd->tree_type == LUMA_PART) ? 1 : num_planes; |
| if (!is_inter_block(mbmi, xd->tree_type)) { |
| #else |
| if (!is_inter_block(mbmi)) { |
| #endif |
| int row, col; |
| assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x, |
| xd->plane[0].subsampling_y)); |
| const int max_blocks_wide = max_block_wide(xd, bsize, 0); |
| const int max_blocks_high = max_block_high(xd, bsize, 0); |
| const BLOCK_SIZE max_unit_bsize = BLOCK_64X64; |
| int mu_blocks_wide = mi_size_wide[max_unit_bsize]; |
| int mu_blocks_high = mi_size_high[max_unit_bsize]; |
| mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide); |
| mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high); |
| |
| for (row = 0; row < max_blocks_high; row += mu_blocks_high) { |
| for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) { |
| #if CONFIG_SDP |
| for (int plane = plane_start; plane < plane_end; ++plane) { |
| #else |
| for (int plane = 0; plane < num_planes; ++plane) { |
| #endif |
| if (plane && !xd->is_chroma_ref) break; |
| 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]; |
| |
| 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) { |
| td->read_coeffs_tx_intra_block_visit(cm, dcb, r, plane, blk_row, |
| blk_col, tx_size); |
| td->predict_and_recon_intra_block_visit( |
| cm, dcb, r, plane, blk_row, blk_col, tx_size); |
| set_cb_buffer_offsets(dcb, tx_size, plane); |
| } |
| } |
| } |
| } |
| } |
| } else { |
| td->predict_inter_block_visit(cm, dcb, bsize); |
| // Reconstruction |
| #if CONFIG_SDP |
| if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) { |
| #else |
| if (!mbmi->skip_txfm) { |
| #endif |
| int eobtotal = 0; |
| |
| const int max_blocks_wide = max_block_wide(xd, bsize, 0); |
| const int max_blocks_high = max_block_high(xd, bsize, 0); |
| int row, col; |
| |
| const BLOCK_SIZE max_unit_bsize = BLOCK_64X64; |
| assert(max_unit_bsize == |
| get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x, |
| xd->plane[0].subsampling_y)); |
| int mu_blocks_wide = mi_size_wide[max_unit_bsize]; |
| int mu_blocks_high = mi_size_high[max_unit_bsize]; |
| |
| mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide); |
| mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high); |
| |
| for (row = 0; row < max_blocks_high; row += mu_blocks_high) { |
| for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) { |
| #if CONFIG_SDP |
| for (int plane = plane_start; plane < plane_end; ++plane) { |
| #else |
| for (int plane = 0; plane < num_planes; ++plane) { |
| #endif |
| if (plane && !xd->is_chroma_ref) break; |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| const int ss_x = pd->subsampling_x; |
| const int ss_y = pd->subsampling_y; |
| const BLOCK_SIZE plane_bsize = |
| get_plane_block_size(bsize, ss_x, ss_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 = ROUND_POWER_OF_TWO( |
| AOMMIN(mu_blocks_high + row, max_blocks_high), ss_y); |
| const int unit_width = ROUND_POWER_OF_TWO( |
| AOMMIN(mu_blocks_wide + col, max_blocks_wide), ss_x); |
| |
| for (blk_row = row >> ss_y; blk_row < unit_height; |
| blk_row += bh_var_tx) { |
| for (blk_col = col >> ss_x; blk_col < unit_width; |
| blk_col += bw_var_tx) { |
| decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize, |
| blk_row, blk_col, block, max_tx_size, |
| &eobtotal); |
| block += step; |
| } |
| } |
| } |
| } |
| } |
| } |
| td->cfl_store_inter_block_visit(cm, xd); |
| } |
| |
| av1_visit_palette(pbi, xd, r, set_color_index_map_offset); |
| } |
| |
| static AOM_INLINE void set_inter_tx_size(MB_MODE_INFO *mbmi, int stride_log2, |
| int tx_w_log2, int tx_h_log2, |
| int min_txs, int split_size, int txs, |
| int blk_row, int blk_col) { |
| for (int idy = 0; idy < tx_size_high_unit[split_size]; |
| idy += tx_size_high_unit[min_txs]) { |
| for (int idx = 0; idx < tx_size_wide_unit[split_size]; |
| idx += tx_size_wide_unit[min_txs]) { |
| const int index = (((blk_row + idy) >> tx_h_log2) << stride_log2) + |
| ((blk_col + idx) >> tx_w_log2); |
| mbmi->inter_tx_size[index] = txs; |
| } |
| } |
| } |
| |
| #if CONFIG_NEW_TX_PARTITION |
| static TX_SIZE read_tx_partition(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, |
| TX_SIZE max_tx_size, int blk_row, int blk_col, |
| aom_reader *r) { |
| #if CONFIG_SDP |
| int plane_type = (xd->tree_type == CHROMA_PART); |
| const BLOCK_SIZE bsize = mbmi->sb_type[plane_type]; |
| const int is_inter = is_inter_block(mbmi, xd->tree_type); |
| #else |
| const BLOCK_SIZE bsize = mbmi->sb_type; |
| const int is_inter = is_inter_block(mbmi); |
| #endif |
| const int max_blocks_high = max_block_high(xd, bsize, 0); |
| const int max_blocks_wide = max_block_wide(xd, bsize, 0); |
| if (is_inter && (blk_row >= max_blocks_high || blk_col >= max_blocks_wide)) |
| return TX_INVALID; |
| FRAME_CONTEXT *ec_ctx = xd->tile_ctx; |
| const int is_rect = is_rect_tx(max_tx_size); |
| const int allow_horz = allow_tx_horz_split(max_tx_size); |
| const int allow_vert = allow_tx_vert_split(max_tx_size); |
| const int allow_horz4 = allow_tx_horz4_split(max_tx_size); |
| const int allow_vert4 = allow_tx_vert4_split(max_tx_size); |
| TX_PARTITION_TYPE partition = 0; |
| /* |
| If both horizontal and vertical splits are allowed for this block, |
| first signal using a 4 way tree to indicate TX_PARTITION_NONE, |
| TX_PARTITION_SPLIT, TX_PARTITION_HORZ or TX_PARTITION_VERT. If the |
| actual tx partition type is HORZ4 or VERT4, we read an additional |
| bit to indicate to split further. |
| */ |
| if (allow_horz && allow_vert) { |
| // Read 4way tree type |
| const int split4_ctx = |
| is_inter ? txfm_partition_split4_inter_context( |
| xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, bsize, max_tx_size) |
| : get_tx_size_context(xd); |
| aom_cdf_prob *split4_cdf = |
| is_inter ? ec_ctx->inter_4way_txfm_partition_cdf[is_rect][split4_ctx] |
| : ec_ctx->intra_4way_txfm_partition_cdf[is_rect][split4_ctx]; |
| const TX_PARTITION_TYPE split4_partition = |
| aom_read_symbol(r, split4_cdf, 4, ACCT_STR); |
| partition = split4_partition; |
| // If further split is allowed, read an additional bit to determine |
| // the final partition type |
| if (((split4_partition == TX_PARTITION_VERT) && allow_vert4) || |
| ((split4_partition == TX_PARTITION_HORZ) && allow_horz4)) { |
| aom_cdf_prob *split2_rect_cdf = |
| is_inter ? ec_ctx->inter_2way_rect_txfm_partition_cdf |
| : ec_ctx->intra_2way_rect_txfm_partition_cdf; |
| const int further_split = |
| aom_read_symbol(r, split2_rect_cdf, 2, ACCT_STR); |
| if (further_split) |
| partition = (split4_partition == TX_PARTITION_VERT) |
| ? TX_PARTITION_VERT4 |
| : TX_PARTITION_HORZ4; |
| } |
| /* |
| If only one split type (horizontal or vertical) is allowed for this block, |
| first signal a bit indicating whether there is any split at all. If |
| the partition has a split, and this block is able to be split further, |
| we send a second bit to indicate if the type should be HORZ4 or VERT4. |
| */ |
| } else if (allow_horz || allow_vert) { |
| // Read bit to indicate if there is any split at all |
| aom_cdf_prob *split2_cdf = is_inter ? ec_ctx->inter_2way_txfm_partition_cdf |
| : ec_ctx->intra_2way_txfm_partition_cdf; |
| const int has_first_split = aom_read_symbol(r, split2_cdf, 2, ACCT_STR); |
| if (has_first_split) { |
| // If further splitting is allowed, read a bit determine the fineal |
| // partition type |
| aom_cdf_prob *split2_rect_cdf = |
| is_inter ? ec_ctx->inter_2way_rect_txfm_partition_cdf |
| : ec_ctx->intra_2way_rect_txfm_partition_cdf; |
| const int has_second_split = |
| (allow_horz4 || allow_vert4) |
| ? aom_read_symbol(r, split2_rect_cdf, 2, ACCT_STR) |
| : 0; |
| if (has_second_split) |
| partition = allow_horz ? TX_PARTITION_HORZ4 : TX_PARTITION_VERT4; |
| else |
| partition = allow_horz ? TX_PARTITION_HORZ : TX_PARTITION_VERT; |
| } else { |
| partition = TX_PARTITION_NONE; |
| } |
| } else { |
| assert(!allow_horz && !allow_vert); |
| partition = TX_PARTITION_NONE; |
| } |
| TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 }; |
| get_tx_partition_sizes(partition, max_tx_size, sub_txs); |
| // TODO(sarahparker) This assumes all of the tx sizes in the partition scheme |
| // are the same size. This will need to be adjusted to deal with the case |
| // where they can be different. |
| mbmi->tx_size = sub_txs[0]; |
| const int index = |
| is_inter ? av1_get_txb_size_index(bsize, blk_row, blk_col) : 0; |
| mbmi->partition_type[index] = partition; |
| if (is_inter) { |
| const TX_SIZE txs = sub_tx_size_map[max_txsize_rect_lookup[bsize]]; |
| const int tx_w_log2 = tx_size_wide_log2[txs] - MI_SIZE_LOG2; |
| const int tx_h_log2 = tx_size_high_log2[txs] - MI_SIZE_LOG2; |
| const int bw_log2 = mi_size_wide_log2[bsize]; |
| const int stride_log2 = bw_log2 - tx_w_log2; |
| set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, max_tx_size, |
| mbmi->tx_size, blk_row, blk_col); |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, mbmi->tx_size, |
| max_tx_size); |
| } |
| return sub_txs[0]; |
| } |
| #else |
| static AOM_INLINE void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, |
| TX_SIZE tx_size, int depth, |
| #if CONFIG_LPF_MASK |
| AV1_COMMON *cm, int mi_row, |
| int mi_col, int store_bitmask, |
| #endif |
| int blk_row, int blk_col, |
| aom_reader *r) { |
| FRAME_CONTEXT *ec_ctx = xd->tile_ctx; |
| int is_split = 0; |
| #if CONFIG_SDP |
| int plane_type = (xd->tree_type == CHROMA_PART); |
| const BLOCK_SIZE bsize = mbmi->sb_type[plane_type]; |
| #else |
| const BLOCK_SIZE bsize = mbmi->sb_type; |
| #endif |
| const int max_blocks_high = max_block_high(xd, bsize, 0); |
| const int max_blocks_wide = max_block_wide(xd, bsize, 0); |
| if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; |
| assert(tx_size > TX_4X4); |
| TX_SIZE txs = max_txsize_rect_lookup[bsize]; |
| for (int level = 0; level < MAX_VARTX_DEPTH - 1; ++level) |
| txs = sub_tx_size_map[txs]; |
| const int tx_w_log2 = tx_size_wide_log2[txs] - MI_SIZE_LOG2; |
| const int tx_h_log2 = tx_size_high_log2[txs] - MI_SIZE_LOG2; |
| const int bw_log2 = mi_size_wide_log2[bsize]; |
| const int stride_log2 = bw_log2 - tx_w_log2; |
| |
| if (depth == MAX_VARTX_DEPTH) { |
| set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size, |
| tx_size, blk_row, blk_col); |
| mbmi->tx_size = tx_size; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, tx_size, tx_size); |
| return; |
| } |
| #if CONFIG_SDP |
| const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, |
| mbmi->sb_type[plane_type], tx_size); |
| #else |
| const int ctx = txfm_partition_context(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, |
| mbmi->sb_type, tx_size); |
| #endif |
| is_split = aom_read_symbol(r, ec_ctx->txfm_partition_cdf[ctx], 2, ACCT_STR); |
| |
| if (is_split) { |
| const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; |
| const int bsw = tx_size_wide_unit[sub_txs]; |
| const int bsh = tx_size_high_unit[sub_txs]; |
| |
| if (sub_txs == TX_4X4) { |
| set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size, |
| sub_txs, blk_row, blk_col); |
| mbmi->tx_size = sub_txs; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, sub_txs, tx_size); |
| #if CONFIG_LPF_MASK |
| if (store_bitmask) { |
| av1_store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, |
| txsize_to_bsize[tx_size], TX_4X4, mbmi); |
| } |
| #endif |
| return; |
| } |
| #if CONFIG_LPF_MASK |
| if (depth + 1 == MAX_VARTX_DEPTH && store_bitmask) { |
| av1_store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, |
| txsize_to_bsize[tx_size], sub_txs, mbmi); |
| store_bitmask = 0; |
| } |
| #endif |
| |
| assert(bsw > 0 && bsh > 0); |
| for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { |
| for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { |
| int offsetr = blk_row + row; |
| int offsetc = blk_col + col; |
| read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1, |
| #if CONFIG_LPF_MASK |
| cm, mi_row, mi_col, store_bitmask, |
| #endif |
| offsetr, offsetc, r); |
| } |
| } |
| } else { |
| set_inter_tx_size(mbmi, stride_log2, tx_w_log2, tx_h_log2, txs, tx_size, |
| tx_size, blk_row, blk_col); |
| mbmi->tx_size = tx_size; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, tx_size, tx_size); |
| #if CONFIG_LPF_MASK |
| if (store_bitmask) { |
| av1_store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, |
| txsize_to_bsize[tx_size], tx_size, mbmi); |
| } |
| #endif |
| } |
| } |
| |
| static TX_SIZE read_selected_tx_size(const MACROBLOCKD *const xd, |
| aom_reader *r) { |
| // TODO(debargha): Clean up the logic here. This function should only |
| // be called for intra. |
| #if CONFIG_SDP |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART]; |
| #else |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type; |
| #endif |
| const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize); |
| const int max_depths = bsize_to_max_depth(bsize); |
| const int ctx = get_tx_size_context(xd); |
| FRAME_CONTEXT *ec_ctx = xd->tile_ctx; |
| const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx], |
| max_depths + 1, ACCT_STR); |
| assert(depth >= 0 && depth <= max_depths); |
| const TX_SIZE tx_size = depth_to_tx_size(depth, bsize); |
| return tx_size; |
| } |
| #endif // CONFIG_NEW_TX_PARTITION |
| |
| static TX_SIZE read_tx_size(MACROBLOCKD *xd, TX_MODE tx_mode, int is_inter, |
| int allow_select_inter, aom_reader *r) { |
| #if CONFIG_SDP |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART]; |
| #else |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type; |
| #endif |
| if (xd->lossless[xd->mi[0]->segment_id]) return TX_4X4; |
| |
| if (block_signals_txsize(bsize)) { |
| if ((!is_inter || allow_select_inter) && tx_mode == TX_MODE_SELECT) { |
| #if CONFIG_NEW_TX_PARTITION |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize]; |
| return read_tx_partition(xd, mbmi, max_tx_size, 0, 0, r); |
| #else |
| const TX_SIZE coded_tx_size = read_selected_tx_size(xd, r); |
| return coded_tx_size; |
| #endif // CONFIG_NEW_TX_PARTITION |
| } else { |
| return tx_size_from_tx_mode(bsize, tx_mode); |
| } |
| } else { |
| assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4)); |
| return max_txsize_rect_lookup[bsize]; |
| } |
| } |
| |
| static AOM_INLINE void parse_decode_block(AV1Decoder *const pbi, |
| ThreadData *const td, int mi_row, |
| int mi_col, aom_reader *r, |
| PARTITION_TYPE partition, |
| BLOCK_SIZE bsize) { |
| DecoderCodingBlock *const dcb = &td->dcb; |
| MACROBLOCKD *const xd = &dcb->xd; |
| decode_mbmi_block(pbi, dcb, mi_row, mi_col, r, partition, bsize); |
| |
| av1_visit_palette(pbi, xd, r, av1_decode_palette_tokens); |
| |
| AV1_COMMON *cm = &pbi->common; |
| const int num_planes = av1_num_planes(cm); |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| #if CONFIG_SDP |
| int inter_block_tx = is_inter_block(mbmi, xd->tree_type) || |
| is_intrabc_block(mbmi, xd->tree_type); |
| if (xd->tree_type != CHROMA_PART) { |
| #else |
| int inter_block_tx = is_inter_block(mbmi) || is_intrabc_block(mbmi); |
| #endif |
| if (cm->features.tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) && |
| #if CONFIG_SDP |
| !mbmi->skip_txfm[xd->tree_type == CHROMA_PART] && inter_block_tx && |
| !xd->lossless[mbmi->segment_id]) { |
| #else |
| !mbmi->skip_txfm && inter_block_tx && !xd->lossless[mbmi->segment_id]) { |
| #endif |
| const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize]; |
| const int bh = tx_size_high_unit[max_tx_size]; |
| const int bw = tx_size_wide_unit[max_tx_size]; |
| const int width = mi_size_wide[bsize]; |
| const int height = mi_size_high[bsize]; |
| |
| for (int idy = 0; idy < height; idy += bh) |
| for (int idx = 0; idx < width; idx += bw) |
| #if CONFIG_NEW_TX_PARTITION |
| read_tx_partition(xd, mbmi, max_tx_size, idy, idx, r); |
| #else |
| read_tx_size_vartx(xd, mbmi, max_tx_size, 0, |
| #if CONFIG_LPF_MASK |
| cm, mi_row, mi_col, 1, |
| #endif |
| idy, idx, r); |
| #endif // CONFIG_NEW_TX_PARTITION |
| } else { |
| mbmi->tx_size = |
| read_tx_size(xd, cm->features.tx_mode, inter_block_tx, |
| #if CONFIG_SDP |
| !mbmi->skip_txfm[xd->tree_type == CHROMA_PART], r); |
| #else |
| !mbmi->skip_txfm, r); |
| #endif |
| if (inter_block_tx) |
| memset(mbmi->inter_tx_size, mbmi->tx_size, sizeof(mbmi->inter_tx_size)); |
| set_txfm_ctxs(mbmi->tx_size, xd->width, xd->height, |
| #if CONFIG_SDP |
| mbmi->skip_txfm[xd->tree_type == CHROMA_PART] && |
| is_inter_block(mbmi, xd->tree_type), |
| xd); |
| #else |
| mbmi->skip_txfm && is_inter_block(mbmi), xd); |
| #endif |
| #if CONFIG_LPF_MASK |
| const int w = mi_size_wide[bsize]; |
| const int h = mi_size_high[bsize]; |
| if (w <= mi_size_wide[BLOCK_64X64] && h <= mi_size_high[BLOCK_64X64]) { |
| av1_store_bitmask_univariant_tx(cm, mi_row, mi_col, bsize, mbmi); |
| } else { |
| for (int row = 0; row < h; row += mi_size_high[BLOCK_64X64]) { |
| for (int col = 0; col < w; col += mi_size_wide[BLOCK_64X64]) { |
| av1_store_bitmask_univariant_tx(cm, mi_row + row, mi_col + col, |
| BLOCK_64X64, mbmi); |
| } |
| } |
| } |
| #endif |
| } |
| #if CONFIG_SDP |
| } |
| #endif |
| #if CONFIG_LPF_MASK |
| const int w = mi_size_wide[bsize]; |
| const int h = mi_size_high[bsize]; |
| if (w <= mi_size_wide[BLOCK_64X64] && h <= mi_size_high[BLOCK_64X64]) { |
| av1_store_bitmask_other_info(cm, mi_row, mi_col, bsize, mbmi, 1, 1); |
| } else { |
| for (int row = 0; row < h; row += mi_size_high[BLOCK_64X64]) { |
| for (int col = 0; col < w; col += mi_size_wide[BLOCK_64X64]) { |
| av1_store_bitmask_other_info(cm, mi_row + row, mi_col + col, |
| BLOCK_64X64, mbmi, row == 0, col == 0); |
| } |
| } |
| } |
| #endif |
| |
| if (cm->delta_q_info.delta_q_present_flag) { |
| for (int i = 0; i < MAX_SEGMENTS; i++) { |
| #if CONFIG_EXTQUANT |
| const int current_qindex = av1_get_qindex( |
| &cm->seg, i, xd->current_base_qindex, cm->seq_params.bit_depth); |
| #else |
| const int current_qindex = |
| av1_get_qindex(&cm->seg, i, xd->current_base_qindex); |
| #endif |
| const CommonQuantParams *const quant_params = &cm->quant_params; |
| for (int j = 0; j < num_planes; ++j) { |
| const int dc_delta_q = j == 0 ? quant_params->y_dc_delta_q |
| : (j == 1 ? quant_params->u_dc_delta_q |
| : quant_params->v_dc_delta_q); |
| const int ac_delta_q = j == 0 ? 0 |
| : (j == 1 ? quant_params->u_ac_delta_q |
| : quant_params->v_ac_delta_q); |
| xd->plane[j].seg_dequant_QTX[i][0] = |
| av1_dc_quant_QTX(current_qindex, dc_delta_q, |
| #if CONFIG_EXTQUANT |
| j == 0 ? cm->seq_params.base_y_dc_delta_q |
| : cm->seq_params.base_uv_dc_delta_q, |
| #endif |
| cm->seq_params.bit_depth); |
| xd->plane[j].seg_dequant_QTX[i][1] = av1_ac_quant_QTX( |
| current_qindex, ac_delta_q, cm->seq_params.bit_depth); |
| } |
| } |
| } |
| #if CONFIG_SDP |
| if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) |
| av1_reset_entropy_context(xd, bsize, num_planes); |
| #else |
| if (mbmi->skip_txfm) av1_reset_entropy_context(xd, bsize, num_planes); |
| #endif |
| #if CONFIG_SDP |
| decode_token_recon_block(pbi, td, r, partition, bsize); |
| #else |
| decode_token_recon_block(pbi, td, r, bsize); |
| #endif |
| |
| #if CONFIG_SDP |
| if (xd->tree_type != SHARED_PART) { |
| const int bh = mi_size_high[bsize]; |
| const int bw = mi_size_wide[bsize]; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| const int x_mis = AOMMIN(bw, mi_params->mi_cols - mi_col); |
| const int y_mis = AOMMIN(bh, mi_params->mi_rows - mi_row); |
| int idx = mi_params->mi_stride; |
| assert(x_mis && y_mis); |
| if (xd->tree_type != CHROMA_PART) { |
| for (int y = 0; y < y_mis; ++y) { |
| for (int x = 0; x < x_mis; ++x) { |
| if (x == 0 && y == 0) continue; |
| set_blk_offsets(mi_params, xd, mi_row, mi_col, y, x); |
| *(xd->mi[y * idx + x]) = *(xd->mi[0]); |
| } |
| } |
| } else { |
| assert(x_mis && y_mis); |
| for (int y = 0; y < y_mis; ++y) { |
| for (int x = 0; x < x_mis; ++x) { |
| if (x == 0 && y == 0) continue; |
| set_blk_offsets(mi_params, xd, mi_row, mi_col, y, x); |
| xd->mi[y * idx + x]->sb_type[PLANE_TYPE_UV] = |
| xd->mi[0]->sb_type[PLANE_TYPE_UV]; |
| xd->mi[y * idx + x]->uv_mode = xd->mi[0]->uv_mode; |
| xd->mi[y * idx + x]->angle_delta[PLANE_TYPE_UV] = |
| xd->mi[0]->angle_delta[PLANE_TYPE_UV]; |
| if (av1_allow_palette(cm->features.allow_screen_content_tools, |
| bsize)) { |
| xd->mi[y * idx + x]->palette_mode_info.palette_size[PLANE_TYPE_UV] = |
| xd->mi[0]->palette_mode_info.palette_size[PLANE_TYPE_UV]; |
| for (int i = PALETTE_MAX_SIZE; i < 3 * PALETTE_MAX_SIZE; i++) |
| xd->mi[y * idx + x]->palette_mode_info.palette_colors[i] = |
| xd->mi[0]->palette_mode_info.palette_colors[i]; |
| } |
| } |
| } |
| } |
| } |
| #endif |
| } |
| |
| static AOM_INLINE void set_offsets_for_pred_and_recon(AV1Decoder *const pbi, |
| ThreadData *const td, |
| int mi_row, int mi_col, |
| BLOCK_SIZE bsize) { |
| AV1_COMMON *const cm = &pbi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| DecoderCodingBlock *const dcb = &td->dcb; |
| MACROBLOCKD *const xd = &dcb->xd; |
| const int bw = mi_size_wide[bsize]; |
| const int bh = mi_size_high[bsize]; |
| const int num_planes = av1_num_planes(cm); |
| |
| const int offset = mi_row * mi_params->mi_stride + mi_col; |
| const TileInfo *const tile = &xd->tile; |
| |
| xd->mi = mi_params->mi_grid_base + offset; |
| xd->tx_type_map = |
| &mi_params->tx_type_map[mi_row * mi_params->mi_stride + mi_col]; |
| xd->tx_type_map_stride = mi_params->mi_stride; |
| |
| set_plane_n4(xd, bw, bh, 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, mi_params->mi_rows, |
| mi_params->mi_cols); |
| |
| av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0, |
| num_planes); |
| } |
| |
| static AOM_INLINE void decode_block(AV1Decoder *const pbi, ThreadData *const td, |
| int mi_row, int mi_col, aom_reader *r, |
| PARTITION_TYPE partition, |
| BLOCK_SIZE bsize) { |
| (void)partition; |
| set_offsets_for_pred_and_recon(pbi, td, mi_row, mi_col, bsize); |
| #if CONFIG_SDP |
| decode_token_recon_block(pbi, td, r, partition, bsize); |
| #else |
| decode_token_recon_block(pbi, td, r, bsize); |
| #endif |
| } |
| |
| #if CONFIG_SDP |
| static PARTITION_TYPE read_partition(const AV1_COMMON *const cm, |
| MACROBLOCKD *xd, int mi_row, int mi_col, |
| aom_reader *r, int has_rows, int has_cols, |
| BLOCK_SIZE bsize) { |
| #else |
| 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) { |
| #endif |
| const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize); |
| FRAME_CONTEXT *ec_ctx = xd->tile_ctx; |
| |
| if (!has_rows && !has_cols) return PARTITION_SPLIT; |
| |
| #if CONFIG_SDP |
| const int plane = xd->tree_type == CHROMA_PART; |
| if (plane == 1 && bsize == BLOCK_8X8) { |
| return PARTITION_NONE; |
| } |
| int parent_block_width = block_size_wide[bsize]; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| if (xd->tree_type == CHROMA_PART && parent_block_width >= SHARED_PART_SIZE) { |
| int luma_split_flag = get_luma_split_flag(bsize, mi_params, mi_row, mi_col); |
| // if luma blocks uses smaller blocks, then chroma will also split |
| if (luma_split_flag > 3) return PARTITION_SPLIT; |
| } |
| #endif |
| |
| assert(ctx >= 0); |
| #if CONFIG_SDP |
| aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[plane][ctx]; |
| #else |
| aom_cdf_prob *partition_cdf = ec_ctx->partition_cdf[ctx]; |
| #endif |
| if (has_rows && has_cols) { |
| return (PARTITION_TYPE)aom_read_symbol( |
| r, partition_cdf, partition_cdf_length(bsize), ACCT_STR); |
| } else if (!has_rows && has_cols) { |
| assert(bsize > BLOCK_8X8); |
| aom_cdf_prob cdf[2]; |
| partition_gather_vert_alike(cdf, partition_cdf, bsize); |
| assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP)); |
| return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_HORZ; |
| } else { |
| assert(has_rows && !has_cols); |
| assert(bsize > BLOCK_8X8); |
| aom_cdf_prob cdf[2]; |
| partition_gather_horz_alike(cdf, partition_cdf, bsize); |
| assert(cdf[1] == AOM_ICDF(CDF_PROB_TOP)); |
| return aom_read_cdf(r, cdf, 2, ACCT_STR) ? PARTITION_SPLIT : PARTITION_VERT; |
| } |
| } |
| |
| // TODO(slavarnway): eliminate bsize and subsize in future commits |
| static AOM_INLINE void decode_partition(AV1Decoder *const pbi, |
| ThreadData *const td, int mi_row, |
| int mi_col, aom_reader *reader, |
| BLOCK_SIZE bsize, |
| int parse_decode_flag) { |
| assert(bsize < BLOCK_SIZES_ALL); |
| AV1_COMMON *const cm = &pbi->common; |
| DecoderCodingBlock *const dcb = &td->dcb; |
| MACROBLOCKD *const xd = &dcb->xd; |
| const int bw = mi_size_wide[bsize]; |
| const int hbs = bw >> 1; |
| PARTITION_TYPE partition; |
| BLOCK_SIZE subsize; |
| const int quarter_step = bw / 4; |
| BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT); |
| const int has_rows = (mi_row + hbs) < cm->mi_params.mi_rows; |
| const int has_cols = (mi_col + hbs) < cm->mi_params.mi_cols; |
| |
| if (mi_row >= cm->mi_params.mi_rows || mi_col >= cm->mi_params.mi_cols) |
| return; |
| |
| // parse_decode_flag takes the following values : |
| // 01 - do parse only |
| // 10 - do decode only |
| // 11 - do parse and decode |
| static const block_visitor_fn_t block_visit[4] = { NULL, parse_decode_block, |
| decode_block, |
| parse_decode_block }; |
| |
| if (parse_decode_flag & 1) { |
| const int num_planes = av1_num_planes(cm); |
| #if CONFIG_SDP |
| const int plane_start = (xd->tree_type == CHROMA_PART); |
| const int plane_end = (xd->tree_type == LUMA_PART) ? 1 : num_planes; |
| for (int plane = plane_start; plane < plane_end; ++plane) { |
| #else |
| for (int plane = 0; plane < num_planes; ++plane) { |
| #endif |
| int rcol0, rcol1, rrow0, rrow1; |
| if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize, |
| &rcol0, &rcol1, &rrow0, &rrow1)) { |
| const int rstride = cm->rst_info[plane].horz_units_per_tile; |
| for (int rrow = rrow0; rrow < rrow1; ++rrow) { |
| for (int rcol = rcol0; rcol < rcol1; ++rcol) { |
| const int runit_idx = rcol + rrow * rstride; |
| loop_restoration_read_sb_coeffs(cm, xd, reader, plane, runit_idx); |
| } |
| } |
| } |
| } |
| #if CONFIG_SDP |
| partition = (bsize < BLOCK_8X8) |
| ? PARTITION_NONE |
| : read_partition(cm, xd, mi_row, mi_col, reader, has_rows, |
| has_cols, bsize); |
| #else |
| partition = (bsize < BLOCK_8X8) ? PARTITION_NONE |
| : read_partition(xd, mi_row, mi_col, reader, |
| has_rows, has_cols, bsize); |
| #endif |
| } else { |
| #if CONFIG_SDP |
| partition = |
| get_partition(cm, xd->tree_type == CHROMA_PART, mi_row, mi_col, bsize); |
| #else |
| partition = get_partition(cm, mi_row, mi_col, bsize); |
| #endif |
| } |
| subsize = get_partition_subsize(bsize, partition); |
| if (subsize == BLOCK_INVALID) { |
| aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, |
| "Partition is invalid for block size %dx%d", |
| block_size_wide[bsize], block_size_high[bsize]); |
| } |
| // Check the bitstream is conformant: if there is subsampling on the |
| // chroma planes, subsize must subsample to a valid block size. |
| const struct macroblockd_plane *const pd_u = &xd->plane[1]; |
| if (get_plane_block_size(subsize, pd_u->subsampling_x, pd_u->subsampling_y) == |
| BLOCK_INVALID) { |
| aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, |
| "Block size %dx%d invalid with this subsampling mode", |
| block_size_wide[subsize], block_size_high[subsize]); |
| } |
| |
| #define DEC_BLOCK_STX_ARG |
| #define DEC_BLOCK_EPT_ARG partition, |
| #define DEC_BLOCK(db_r, db_c, db_subsize) \ |
| block_visit[parse_decode_flag](pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), \ |
| reader, DEC_BLOCK_EPT_ARG(db_subsize)) |
| #define DEC_PARTITION(db_r, db_c, db_subsize) \ |
| decode_partition(pbi, td, DEC_BLOCK_STX_ARG(db_r), (db_c), reader, \ |
| (db_subsize), parse_decode_flag) |
| |
| 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_params.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_params.mi_cols) break; |
| DEC_BLOCK(mi_row, this_mi_col, subsize); |
| } |
| break; |
| default: assert(0 && "Invalid partition type"); |
| } |
| |
| #undef DEC_PARTITION |
| #undef DEC_BLOCK |
| #undef DEC_BLOCK_EPT_ARG |
| #undef DEC_BLOCK_STX_ARG |
| |
| if (parse_decode_flag & 1) |
| update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition); |
| } |
| |
| static AOM_INLINE void setup_bool_decoder( |
| const uint8_t *data, const uint8_t *data_end, const size_t read_size, |
| struct aom_internal_error_info *error_info, aom_reader *r, |
| uint8_t allow_update_cdf) { |
| // Validate the calculated partition length. If the buffer |
| // described by the partition can't be fully read, then restrict |
| // it to the portion that can be (for EC mode) or throw an error. |
| if (!read_is_valid(data, read_size, data_end)) |
| aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME, |
| "Truncated packet or corrupt tile length"); |
| |
| if (aom_reader_init(r, data, read_size)) |
| aom_internal_error(error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate bool decoder %d", 1); |
| |
| r->allow_update_cdf = allow_update_cdf; |
| } |
| |
| #if CONFIG_SDP |
| static AOM_INLINE void decode_partition_sb(AV1Decoder *const pbi, |
| ThreadData *const td, int mi_row, |
| int mi_col, aom_reader *reader, |
| BLOCK_SIZE bsize, |
| int parse_decode_flag) { |
| assert(bsize < BLOCK_SIZES_ALL); |
| AV1_COMMON *const cm = &pbi->common; |
| DecoderCodingBlock *const dcb = &td->dcb; |
| MACROBLOCKD *const xd = &dcb->xd; |
| const int total_loop_num = |
| (frame_is_intra_only(cm) && !cm->seq_params.monochrome && |
| cm->seq_params.enable_sdp) |
| ? 2 |
| : 1; |
| xd->tree_type = (total_loop_num == 1 ? SHARED_PART : LUMA_PART); |
| decode_partition(pbi, td, mi_row, mi_col, reader, bsize, parse_decode_flag); |
| if (total_loop_num == 2) { |
| xd->tree_type = CHROMA_PART; |
| decode_partition(pbi, td, mi_row, mi_col, reader, bsize, parse_decode_flag); |
| xd->tree_type = SHARED_PART; |
| } |
| } |
| #endif |
| |
| static AOM_INLINE void setup_segmentation(AV1_COMMON *const cm, |
| struct aom_read_bit_buffer *rb) { |
| struct segmentation *const seg = &cm->seg; |
| |
| seg->update_map = 0; |
| seg->update_data = 0; |
| seg->temporal_update = 0; |
| |
| seg->enabled = aom_rb_read_bit(rb); |
| if (!seg->enabled) { |
| if (cm->cur_frame->seg_map) { |
| memset(cm->cur_frame->seg_map, 0, |
| (cm->cur_frame->mi_rows * cm->cur_frame->mi_cols)); |
| } |
| |
| memset(seg, 0, sizeof(*seg)); |
| segfeatures_copy(&cm->cur_frame->seg, seg); |
| return; |
| } |
| if (cm->seg.enabled && cm->prev_frame && |
| (cm->mi_params.mi_rows == cm->prev_frame->mi_rows) && |
| (cm->mi_params.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->features.primary_ref_frame == PRIMARY_REF_NONE) { |
| // These frames can't use previous frames, so must signal map + features |
| seg->update_map = 1; |
| seg->temporal_update = 0; |
| seg->update_data = 1; |
| } else { |
| seg->update_map = aom_rb_read_bit(rb); |
| if (seg->update_map) { |
| seg->temporal_update = aom_rb_read_bit(rb); |
| } else { |
| seg->temporal_update = 0; |
| } |
| seg->update_data = aom_rb_read_bit(rb); |
| } |
| |
| // Segmentation data update |
| if (seg->update_data) { |
| av1_clearall_segfeatures(seg); |
| |
| for (int i = 0; i < MAX_SEGMENTS; i++) { |
| for (int j = 0; j < SEG_LVL_MAX; j++) { |
| int data = 0; |
| const int feature_enabled = aom_rb_read_bit(rb); |
| if (feature_enabled) { |
| av1_enable_segfeature(seg, i, j); |
| |
| const int data_max = av1_seg_feature_data_max(j); |
| const int data_min = -data_max; |
| const int ubits = get_unsigned_bits(data_max); |
| |
| if (av1_is_segfeature_signed(j)) { |
| data = aom_rb_read_inv_signed_literal(rb, ubits); |
| } else { |
| data = aom_rb_read_literal(rb, ubits); |
| } |
| |
| data = clamp(data, data_min, data_max); |
| } |
| av1_set_segdata(seg, i, j, data); |
| } |
| } |
| av1_calculate_segdata(seg); |
| } else if (cm->prev_frame) { |
| segfeatures_copy(seg, &cm->prev_frame->seg); |
| } |
| segfeatures_copy(&cm->cur_frame->seg, seg); |
| } |
| |
| static AOM_INLINE void decode_restoration_mode(AV1_COMMON *cm, |
| struct aom_read_bit_buffer *rb) { |
| assert(!cm->features.all_lossless); |
| const int num_planes = av1_num_planes(cm); |
| if (cm->features.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 = |
| 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; |
| |
| 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); |
| } |
| } else { |
| const int size = RESTORATION_UNITSIZE_MAX; |
| for (int p = 0; p < num_planes; ++p) |
| cm->rst_info[p].restoration_unit_size = size; |
| } |
| |
| if (num_planes > 1) { |
| int s = AOMMIN(cm->seq_params.subsampling_x, cm->seq_params.subsampling_y); |
| if (s && !chroma_none) { |
| cm->rst_info[1].restoration_unit_size = |
| cm->rst_info[0].restoration_unit_size >> (aom_rb_read_bit(rb) * s); |
| } else { |
| cm->rst_info[1].restoration_unit_size = |
| cm->rst_info[0].restoration_unit_size; |
| } |
| cm->rst_info[2].restoration_unit_size = |
| cm->rst_info[1].restoration_unit_size; |
| } |
| } |
| |
| static AOM_INLINE 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( |
| rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1, |
| WIENER_FILT_TAP0_SUBEXP_K, |
| ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) + |
| WIENER_FILT_TAP0_MINV; |
| else |
| wiener_info->vfilter[0] = wiener_info->vfilter[WIENER_WIN - 1] = 0; |
| wiener_info->vfilter[1] = wiener_info->vfilter[WIENER_WIN - 2] = |
| aom_read_primitive_refsubexpfin( |
| rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1, |
| WIENER_FILT_TAP1_SUBEXP_K, |
| ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) + |
| WIENER_FILT_TAP1_MINV; |
| wiener_info->vfilter[2] = wiener_info->vfilter[WIENER_WIN - 3] = |
| aom_read_primitive_refsubexpfin( |
| rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1, |
| WIENER_FILT_TAP2_SUBEXP_K, |
| ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) + |
| WIENER_FILT_TAP2_MINV; |
| // The central element has an implicit +WIENER_FILT_STEP |
| wiener_info->vfilter[WIENER_HALFWIN] = |
| -2 * (wiener_info->vfilter[0] + wiener_info->vfilter[1] + |
| wiener_info->vfilter[2]); |
| |
| if (wiener_win == WIENER_WIN) |
| wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] = |
| aom_read_primitive_refsubexpfin( |
| rb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1, |
| WIENER_FILT_TAP0_SUBEXP_K, |
| ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV, ACCT_STR) + |
| WIENER_FILT_TAP0_MINV; |
| else |
| wiener_info->hfilter[0] = wiener_info->hfilter[WIENER_WIN - 1] = 0; |
| wiener_info->hfilter[1] = wiener_info->hfilter[WIENER_WIN - 2] = |
| aom_read_primitive_refsubexpfin( |
| rb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1, |
| WIENER_FILT_TAP1_SUBEXP_K, |
| ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV, ACCT_STR) + |
| WIENER_FILT_TAP1_MINV; |
| wiener_info->hfilter[2] = wiener_info->hfilter[WIENER_WIN - 3] = |
| aom_read_primitive_refsubexpfin( |
| rb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1, |
| WIENER_FILT_TAP2_SUBEXP_K, |
| ref_wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV, ACCT_STR) + |
| WIENER_FILT_TAP2_MINV; |
| // The central element has an implicit +WIENER_FILT_STEP |
| wiener_info->hfilter[WIENER_HALFWIN] = |
| -2 * (wiener_info->hfilter[0] + wiener_info->hfilter[1] + |
| wiener_info->hfilter[2]); |
| memcpy(ref_wiener_info, wiener_info, sizeof(*wiener_info)); |
| } |
| |
| static AOM_INLINE 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); |
| const sgr_params_type *params = &av1_sgr_params[sgrproj_info->ep]; |
| |
| if (params->r[0] == 0) { |
| sgrproj_info->xqd[0] = 0; |
| sgrproj_info->xqd[1] = |
| aom_read_primitive_refsubexpfin( |
| rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K, |
| ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) + |
| SGRPROJ_PRJ_MIN1; |
| } else if (params->r[1] == 0) { |
| sgrproj_info->xqd[0] = |
| aom_read_primitive_refsubexpfin( |
| rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K, |
| ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) + |
| SGRPROJ_PRJ_MIN0; |
| sgrproj_info->xqd[1] = clamp((1 << SGRPROJ_PRJ_BITS) - sgrproj_info->xqd[0], |
| SGRPROJ_PRJ_MIN1, SGRPROJ_PRJ_MAX1); |
| } else { |
| sgrproj_info->xqd[0] = |
| aom_read_primitive_refsubexpfin( |
| rb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K, |
| ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, ACCT_STR) + |
| SGRPROJ_PRJ_MIN0; |
| sgrproj_info->xqd[1] = |
| aom_read_primitive_refsubexpfin( |
| rb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K, |
| ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, ACCT_STR) + |
| SGRPROJ_PRJ_MIN1; |
| } |
| |
| memcpy(ref_sgrproj_info, sgrproj_info, sizeof(*sgrproj_info)); |
| } |
| |
| static AOM_INLINE void loop_restoration_read_sb_coeffs( |
| const AV1_COMMON *const cm, MACROBLOCKD *xd, aom_reader *const r, int plane, |
| int runit_idx) { |
| const RestorationInfo *rsi = &cm->rst_info[plane]; |
| RestorationUnitInfo *rui = &rsi->unit_info[runit_idx]; |
| assert(rsi->frame_restoration_type != RESTORE_NONE); |
| |
| assert(!cm->features.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) { |
| 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_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 { |
| rui->restoration_type = RESTORE_NONE; |
| } |
| } else if (rsi->frame_restoration_type == RESTORE_SGRPROJ) { |
| if (aom_read_symbol(r, xd->tile_ctx->sgrproj_restore_cdf, 2, ACCT_STR)) { |
| rui->restoration_type = RESTORE_SGRPROJ; |
| read_sgrproj_filter(&rui->sgrproj_info, sgrproj_info, r); |
| } else { |
| rui->restoration_type = RESTORE_NONE; |
| } |
| } |
| } |
| |
| static AOM_INLINE void setup_loopfilter(AV1_COMMON *cm, |
| struct aom_read_bit_buffer *rb) { |
| const int num_planes = av1_num_planes(cm); |
| struct loopfilter *lf = &cm->lf; |
| |
| if (cm->features.allow_intrabc || cm->features.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->features.coded_lossless); |
| if (cm->prev_frame) { |
| // write deltas to frame buffer |
| memcpy(lf->ref_deltas, cm->prev_frame->ref_deltas, REF_FRAMES); |
| memcpy(lf->mode_deltas, cm->prev_frame->mode_deltas, MAX_MODE_LF_DELTAS); |
| } else { |
| av1_set_default_ref_deltas(lf->ref_deltas); |
| av1_set_default_mode_deltas(lf->mode_deltas); |
| } |
| lf->filter_level[0] = aom_rb_read_literal(rb, 6); |
| lf->filter_level[1] = aom_rb_read_literal(rb, 6); |
| if (num_planes > 1) { |
| if (lf->filter_level[0] || lf->filter_level[1]) { |
| lf->filter_level_u = aom_rb_read_literal(rb, 6); |
| lf->filter_level_v = aom_rb_read_literal(rb, 6); |
| } |
| } |
| lf->sharpness_level = aom_rb_read_literal(rb, 3); |
| |
| // Read in loop filter deltas applied at the MB level based on mode or ref |
| // frame. |
| lf->mode_ref_delta_update = 0; |
| |
| lf->mode_ref_delta_enabled = aom_rb_read_bit(rb); |
| if (lf->mode_ref_delta_enabled) { |
| lf->mode_ref_delta_update = aom_rb_read_bit(rb); |
| if (lf->mode_ref_delta_update) { |
| for (int i = 0; i < REF_FRAMES; i++) |
| if (aom_rb_read_bit(rb)) |
| lf->ref_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6); |
| |
| for (int i = 0; i < MAX_MODE_LF_DELTAS; i++) |
| if (aom_rb_read_bit(rb)) |
| lf->mode_deltas[i] = aom_rb_read_inv_signed_literal(rb, 6); |
| } |
| } |
| |
| // write deltas to frame buffer |
| memcpy(cm->cur_frame->ref_deltas, lf->ref_deltas, REF_FRAMES); |
| memcpy(cm->cur_frame->mode_deltas, lf->mode_deltas, MAX_MODE_LF_DELTAS); |
| } |
| |
| static AOM_INLINE void setup_cdef(AV1_COMMON *cm, |
| struct aom_read_bit_buffer *rb) { |
| const int num_planes = av1_num_planes(cm); |
| CdefInfo *const cdef_info = &cm->cdef_info; |
| |
| if (cm->features.allow_intrabc) return; |
| cdef_info->cdef_damping = aom_rb_read_literal(rb, 2) + 3; |
| cdef_info->cdef_bits = aom_rb_read_literal(rb, 2); |
| cdef_info->nb_cdef_strengths = 1 << cdef_info->cdef_bits; |
| for (int i = 0; i < cdef_info->nb_cdef_strengths; i++) { |
| cdef_info->cdef_strengths[i] = aom_rb_read_literal(rb, CDEF_STRENGTH_BITS); |
| cdef_info->cdef_uv_strengths[i] = |
| num_planes > 1 ? aom_rb_read_literal(rb, CDEF_STRENGTH_BITS) : 0; |
| } |
| } |
| |
| #if CONFIG_CCSO |
| static AOM_INLINE void setup_ccso(AV1_COMMON *cm, |
| struct aom_read_bit_buffer *rb) { |
| if (cm->features.allow_intrabc) return; |
| const int ccso_offset[8] = { 0, 1, -1, 3, -3, 5, -5, -7 }; |
| for (int plane = 1; plane < 3; plane++) { |
| cm->ccso_info.ccso_enable[plane - 1] = aom_rb_read_literal(rb, 1); |
| if (cm->ccso_info.ccso_enable[plane - 1]) { |
| cm->ccso_info.quant_idx[plane - 1] = aom_rb_read_literal(rb, 2); |
| cm->ccso_info.ext_filter_support[plane - 1] = aom_rb_read_literal(rb, 3); |
| for (int d0 = 0; d0 < CCSO_INPUT_INTERVAL; d0++) { |
| for (int d1 = 0; d1 < CCSO_INPUT_INTERVAL; d1++) { |
| const int lut_idx_ext = (d0 << 2) + d1; |
| const int offset_idx = aom_rb_read_literal(rb, 3); |
| cm->ccso_info.filter_offset[plane - 1][lut_idx_ext] = |
| ccso_offset[offset_idx]; |
| } |
| } |
| } |
| } |
| } |
| #endif |
| |
| 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; |
| } |
| |
| static AOM_INLINE void setup_quantization(CommonQuantParams *quant_params, |
| int num_planes, |
| aom_bit_depth_t bit_depth, |
| bool separate_uv_delta_q, |
| struct aom_read_bit_buffer *rb) { |
| #if CONFIG_EXTQUANT |
| quant_params->base_qindex = aom_rb_read_literal( |
| rb, bit_depth == AOM_BITS_8 ? QINDEX_BITS_UNEXT : QINDEX_BITS); |
| #else |
| (void)bit_depth; |
| quant_params->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS); |
| #endif |
| quant_params->y_dc_delta_q = read_delta_q(rb); |
| if (num_planes > 1) { |
| int diff_uv_delta = 0; |
| if (separate_uv_delta_q) diff_uv_delta = aom_rb_read_bit(rb); |
| quant_params->u_dc_delta_q = read_delta_q(rb); |
| quant_params->u_ac_delta_q = read_delta_q(rb); |
| if (diff_uv_delta) { |
| quant_params->v_dc_delta_q = read_delta_q(rb); |
| quant_params->v_ac_delta_q = read_delta_q(rb); |
| } else { |
| quant_params->v_dc_delta_q = quant_params->u_dc_delta_q; |
| quant_params->v_ac_delta_q = quant_params->u_ac_delta_q; |
| } |
| } else { |
| quant_params->u_dc_delta_q = 0; |
| quant_params->u_ac_delta_q = 0; |
| quant_params->v_dc_delta_q = 0; |
| quant_params->v_ac_delta_q = 0; |
| } |
| quant_params->using_qmatrix = aom_rb_read_bit(rb); |
| if (quant_params->using_qmatrix) { |
| quant_params->qmatrix_level_y = aom_rb_read_literal(rb, QM_LEVEL_BITS); |
| quant_params->qmatrix_level_u = aom_rb_read_literal(rb, QM_LEVEL_BITS); |
| if (!separate_uv_delta_q) |
| quant_params->qmatrix_level_v = quant_params->qmatrix_level_u; |
| else |
| quant_params->qmatrix_level_v = aom_rb_read_literal(rb, QM_LEVEL_BITS); |
| } else { |
| quant_params->qmatrix_level_y = 0; |
| quant_params->qmatrix_level_u = 0; |
| quant_params->qmatrix_level_v = 0; |
| } |
| } |
| |
| // Build y/uv dequant values based on segmentation. |
| static AOM_INLINE void setup_segmentation_dequant(AV1_COMMON *const cm, |
| MACROBLOCKD *const xd) { |
| const int bit_depth = cm->seq_params.bit_depth; |
| // 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; |
| CommonQuantParams *const quant_params = &cm->quant_params; |
| for (int i = 0; i < max_segments; ++i) { |
| const int qindex = xd->qindex[i]; |
| quant_params->y_dequant_QTX[i][0] = |
| av1_dc_quant_QTX(qindex, quant_params->y_dc_delta_q, |
| #if CONFIG_EXTQUANT |
| cm->seq_params.base_y_dc_delta_q, |
| #endif // CONFIG_EXTQUANT |
| bit_depth); |
| quant_params->y_dequant_QTX[i][1] = av1_ac_quant_QTX(qindex, 0, bit_depth); |
| quant_params->u_dequant_QTX[i][0] = |
| av1_dc_quant_QTX(qindex, quant_params->u_dc_delta_q, |
| #if CONFIG_EXTQUANT |
| cm->seq_params.base_uv_dc_delta_q, |
| #endif // CONFIG_EXTQUANT |
| bit_depth); |
| quant_params->u_dequant_QTX[i][1] = |
| av1_ac_quant_QTX(qindex, quant_params->u_ac_delta_q, bit_depth); |
| quant_params->v_dequant_QTX[i][0] = |
| av1_dc_quant_QTX(qindex, quant_params->v_dc_delta_q, |
| #if CONFIG_EXTQUANT |
| cm->seq_params.base_uv_dc_delta_q, |
| #endif // CONFIG_EXTQUANT |
| bit_depth); |
| quant_params->v_dequant_QTX[i][1] = |
| av1_ac_quant_QTX(qindex, quant_params->v_ac_delta_q, bit_depth); |
| const int use_qmatrix = av1_use_qmatrix(quant_params, xd, i); |
| // 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_y = |
| use_qmatrix ? quant_params->qmatrix_level_y : NUM_QM_LEVELS - 1; |
| for (int j = 0; j < TX_SIZES_ALL; ++j) { |
| quant_params->y_iqmatrix[i][j] = |
| av1_iqmatrix(quant_params, qmlevel_y, AOM_PLANE_Y, j); |
| } |
| const int qmlevel_u = |
| use_qmatrix ? quant_params->qmatrix_level_u : NUM_QM_LEVELS - 1; |
| for (int j = 0; j < TX_SIZES_ALL; ++j) { |
| quant_params->u_iqmatrix[i][j] = |
| av1_iqmatrix(quant_params, qmlevel_u, AOM_PLANE_U, j); |
| } |
| const int qmlevel_v = |
| use_qmatrix ? quant_params->qmatrix_level_v : NUM_QM_LEVELS - 1; |
| for (int j = 0; j < TX_SIZES_ALL; ++j) { |
| quant_params->v_iqmatrix[i][j] = |
| av1_iqmatrix(quant_params, qmlevel_v, AOM_PLANE_V, j); |
| } |
| } |
| } |
| |
| static InterpFilter read_frame_interp_filter(struct aom_read_bit_buffer *rb) { |
| return aom_rb_read_bit(rb) ? SWITCHABLE |
| : aom_rb_read_literal(rb, LOG_SWITCHABLE_FILTERS); |
| } |
| |
| static AOM_INLINE void setup_render_size(AV1_COMMON *cm, |
| struct aom_read_bit_buffer *rb) { |
| cm->render_width = cm->superres_upscaled_width; |
| cm->render_height = cm->superres_upscaled_height; |
| if (aom_rb_read_bit(rb)) |
| av1_read_frame_size(rb, 16, 16, &cm->render_width, &cm->render_height); |
| } |
| |
| // TODO(afergs): make "struct aom_read_bit_buffer *const rb"? |
| static AOM_INLINE 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); |
| cm->superres_scale_denominator += SUPERRES_SCALE_DENOMINATOR_MIN; |
| // Don't edit cm->width or cm->height directly, or the buffers won't get |
| // resized correctly |
| av1_calculate_scaled_superres_size(width, height, |
| cm->superres_scale_denominator); |
| } else { |
| // 1:1 scaling - ie. no scaling, scale not provided |
| cm->superres_scale_denominator = SCALE_NUMERATOR; |
| } |
| } |
| |
| static AOM_INLINE void resize_context_buffers(AV1_COMMON *cm, int width, |
| int height) { |
| #if CONFIG_SIZE_LIMIT |
| if (width > DECODE_WIDTH_LIMIT || height > DECODE_HEIGHT_LIMIT) |
| aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, |
| "Dimensions of %dx%d beyond allowed size of %dx%d.", |
| width, height, DECODE_WIDTH_LIMIT, DECODE_HEIGHT_LIMIT); |
| #endif |
| if (cm->width != width || cm->height != height) { |
| const int new_mi_rows = |
| ALIGN_POWER_OF_TWO(height, MI_SIZE_LOG2) >> MI_SIZE_LOG2; |
| const int new_mi_cols = |
| ALIGN_POWER_OF_TWO(width, MI_SIZE_LOG2) >> MI_SIZE_LOG2; |
| |
| // Allocations in av1_alloc_context_buffers() depend on individual |
| // dimensions as well as the overall size. |
| if (new_mi_cols > cm->mi_params.mi_cols || |
| new_mi_rows > cm->mi_params.mi_rows) { |
| if (av1_alloc_context_buffers(cm, width, height)) { |
| // The cm->mi_* values have been cleared and any existing context |
| // buffers have been freed. Clear cm->width and cm->height to be |
| // consistent and to force a realloc next time. |
| cm->width = 0; |
| cm->height = 0; |
| aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate context buffers"); |
| } |
| } else { |
| cm->mi_params.set_mb_mi(&cm->mi_params, width, height); |
| } |
| av1_init_mi_buffers(&cm->mi_params); |
| cm->width = width; |
| cm->height = height; |
| } |
| |
| ensure_mv_buffer(cm->cur_frame, cm); |
| cm->cur_frame->width = cm->width; |
| cm->cur_frame->height = cm->height; |
| } |
| |
| static AOM_INLINE void setup_buffer_pool(AV1_COMMON *cm) { |
| BufferPool *const pool = cm->buffer_pool; |
| const SequenceHeader *const seq_params = &cm->seq_params; |
| |
| lock_buffer_pool(pool); |
| if (aom_realloc_frame_buffer( |
| &cm->cur_frame->buf |