diff options
Diffstat (limited to 'media/libaom/src/av1/decoder')
| -rw-r--r-- | media/libaom/src/av1/decoder/accounting.c | 4 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/accounting.h | 2 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decodeframe.c | 2949 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decodeframe.h | 18 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decodemv.c | 483 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decodemv.h | 6 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decoder.c | 268 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decoder.h | 88 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decodetxb.c | 93 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/decodetxb.h | 2 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/dthread.c | 192 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/dthread.h | 31 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/inspection.c | 77 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/inspection.h | 11 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/obu.c | 670 | ||||
| -rw-r--r-- | media/libaom/src/av1/decoder/obu.h | 4 |
16 files changed, 2367 insertions, 2531 deletions
diff --git a/media/libaom/src/av1/decoder/accounting.c b/media/libaom/src/av1/decoder/accounting.c index 8d8f3dfdb4..2e58d09e0d 100644 --- a/media/libaom/src/av1/decoder/accounting.c +++ b/media/libaom/src/av1/decoder/accounting.c @@ -17,7 +17,7 @@ #include "aom/aom_integer.h" #include "av1/decoder/accounting.h" -static int aom_accounting_hash(const char *str) { +static int accounting_hash(const char *str) { uint32_t val; const unsigned char *ustr; val = 0; @@ -34,7 +34,7 @@ int aom_accounting_dictionary_lookup(Accounting *accounting, const char *str) { size_t len; AccountingDictionary *dictionary; dictionary = &accounting->syms.dictionary; - hash = aom_accounting_hash(str); + hash = accounting_hash(str); while (accounting->hash_dictionary[hash] != -1) { if (strcmp(dictionary->strs[accounting->hash_dictionary[hash]], str) == 0) { return accounting->hash_dictionary[hash]; diff --git a/media/libaom/src/av1/decoder/accounting.h b/media/libaom/src/av1/decoder/accounting.h index 288e5e63e3..ad2e8b6cfe 100644 --- a/media/libaom/src/av1/decoder/accounting.h +++ b/media/libaom/src/av1/decoder/accounting.h @@ -42,7 +42,7 @@ typedef struct { /** Dictionary for translating strings into id. */ typedef struct { - char *(strs[MAX_SYMBOL_TYPES]); + char *strs[MAX_SYMBOL_TYPES]; int num_strs; } AccountingDictionary; diff --git a/media/libaom/src/av1/decoder/decodeframe.c b/media/libaom/src/av1/decoder/decodeframe.c index 31f14b531f..7abfac4aaa 100644 --- a/media/libaom/src/av1/decoder/decodeframe.c +++ b/media/libaom/src/av1/decoder/decodeframe.c @@ -64,6 +64,9 @@ #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 \ @@ -85,9 +88,9 @@ int av1_check_trailing_bits(AV1Decoder *pbi, struct aom_read_bit_buffer *rb) { } // Use only_chroma = 1 to only set the chroma planes -static void set_planes_to_neutral_grey(const SequenceHeader *const seq_params, - const YV12_BUFFER_CONFIG *const buf, - int only_chroma) { +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++) { @@ -114,28 +117,17 @@ static void set_planes_to_neutral_grey(const SequenceHeader *const seq_params, } } -static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm, - MACROBLOCKD *xd, - aom_reader *const r, int plane, - int runit_idx); - -static void setup_compound_reference_mode(AV1_COMMON *cm) { - cm->comp_fwd_ref[0] = LAST_FRAME; - cm->comp_fwd_ref[1] = LAST2_FRAME; - cm->comp_fwd_ref[2] = LAST3_FRAME; - cm->comp_fwd_ref[3] = GOLDEN_FRAME; - - cm->comp_bwd_ref[0] = BWDREF_FRAME; - cm->comp_bwd_ref[1] = ALTREF2_FRAME; - cm->comp_bwd_ref[2] = ALTREF_FRAME; -} +static 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(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { - if (cm->coded_lossless) return ONLY_4X4; +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; } @@ -148,28 +140,24 @@ static REFERENCE_MODE read_frame_reference_mode( } } -static void inverse_transform_block(MACROBLOCKD *xd, int plane, - const TX_TYPE tx_type, - const TX_SIZE tx_size, uint8_t *dst, - int stride, int reduced_tx_set) { +static AOM_INLINE void inverse_transform_block(MACROBLOCKD *xd, int plane, + const TX_TYPE tx_type, + const TX_SIZE tx_size, + uint8_t *dst, int stride, + int reduced_tx_set) { struct macroblockd_plane *const pd = &xd->plane[plane]; - tran_low_t *const dqcoeff = pd->dqcoeff; + tran_low_t *const dqcoeff = pd->dqcoeff_block + xd->cb_offset[plane]; eob_info *eob_data = pd->eob_data + xd->txb_offset[plane]; uint16_t scan_line = eob_data->max_scan_line; uint16_t eob = eob_data->eob; - - memcpy(dqcoeff, pd->dqcoeff_block + xd->cb_offset[plane], - (scan_line + 1) * sizeof(dqcoeff[0])); av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst, stride, eob, reduced_tx_set); memset(dqcoeff, 0, (scan_line + 1) * sizeof(dqcoeff[0])); } -static void read_coeffs_tx_intra_block(const AV1_COMMON *const cm, - MACROBLOCKD *const xd, - aom_reader *const r, const int plane, - const int row, const int col, - const TX_SIZE tx_size) { +static AOM_INLINE void read_coeffs_tx_intra_block( + const AV1_COMMON *const cm, MACROBLOCKD *const xd, aom_reader *const r, + const int plane, const int row, const int col, const TX_SIZE tx_size) { MB_MODE_INFO *mbmi = xd->mi[0]; if (!mbmi->skip) { #if TXCOEFF_TIMER @@ -186,10 +174,11 @@ static void read_coeffs_tx_intra_block(const AV1_COMMON *const cm, } } -static void decode_block_void(const AV1_COMMON *const cm, MACROBLOCKD *const xd, - aom_reader *const r, const int plane, - const int row, const int col, - const TX_SIZE tx_size) { +static AOM_INLINE void decode_block_void(const AV1_COMMON *const cm, + MACROBLOCKD *const xd, + aom_reader *const r, const int plane, + const int row, const int col, + const TX_SIZE tx_size) { (void)cm; (void)xd; (void)r; @@ -199,23 +188,21 @@ static void decode_block_void(const AV1_COMMON *const cm, MACROBLOCKD *const xd, (void)tx_size; } -static void predict_inter_block_void(AV1_COMMON *const cm, - MACROBLOCKD *const xd, int mi_row, - int mi_col, BLOCK_SIZE bsize) { +static AOM_INLINE void predict_inter_block_void(AV1_COMMON *const cm, + MACROBLOCKD *const xd, + BLOCK_SIZE bsize) { (void)cm; (void)xd; - (void)mi_row; - (void)mi_col; (void)bsize; } -static void cfl_store_inter_block_void(AV1_COMMON *const cm, - MACROBLOCKD *const xd) { +static AOM_INLINE void cfl_store_inter_block_void(AV1_COMMON *const cm, + MACROBLOCKD *const xd) { (void)cm; (void)xd; } -static void predict_and_reconstruct_intra_block( +static AOM_INLINE void predict_and_reconstruct_intra_block( const AV1_COMMON *const cm, MACROBLOCKD *const xd, aom_reader *const r, const int plane, const int row, const int col, const TX_SIZE tx_size) { (void)r; @@ -226,16 +213,15 @@ static void predict_and_reconstruct_intra_block( if (!mbmi->skip) { struct macroblockd_plane *const pd = &xd->plane[plane]; - - // tx_type will be read out in av1_read_coeffs_txb_facade - const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, tx_size, - cm->reduced_tx_set_used); eob_info *eob_data = pd->eob_data + xd->txb_offset[plane]; if (eob_data->eob) { - uint8_t *dst = - &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]]; + 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); + uint8_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2]; inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride, - cm->reduced_tx_set_used); + reduced_tx_set_used); } } if (plane == AOM_PLANE_Y && store_cfl_required(cm, xd)) { @@ -243,49 +229,48 @@ static void predict_and_reconstruct_intra_block( } } -static void inverse_transform_inter_block(const AV1_COMMON *const cm, - MACROBLOCKD *const xd, - aom_reader *const r, const int plane, - const int blk_row, const int blk_col, - const TX_SIZE tx_size) { +static AOM_INLINE void inverse_transform_inter_block( + const AV1_COMMON *const cm, MACROBLOCKD *const xd, aom_reader *const r, + const int plane, const int blk_row, const int blk_col, + const TX_SIZE tx_size) { (void)r; PLANE_TYPE plane_type = get_plane_type(plane); const struct macroblockd_plane *const pd = &xd->plane[plane]; - - // tx_type will be read out in av1_read_coeffs_txb_facade - const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, blk_row, blk_col, - tx_size, cm->reduced_tx_set_used); + 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) << tx_size_wide_log2[0]]; + &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2]; inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride, - cm->reduced_tx_set_used); + 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->frame_offset, plane, pixel_c, - pixel_r, blk_w, blk_h, + mismatch_check_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint, + plane, pixel_c, pixel_r, blk_w, blk_h, xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH); #endif } -static void set_cb_buffer_offsets(MACROBLOCKD *const xd, TX_SIZE tx_size, - int plane) { +static AOM_INLINE void set_cb_buffer_offsets(MACROBLOCKD *const xd, + TX_SIZE tx_size, int plane) { xd->cb_offset[plane] += tx_size_wide[tx_size] * tx_size_high[tx_size]; xd->txb_offset[plane] = xd->cb_offset[plane] / (TX_SIZE_W_MIN * TX_SIZE_H_MIN); } -static void decode_reconstruct_tx(AV1_COMMON *cm, ThreadData *const td, - aom_reader *r, MB_MODE_INFO *const mbmi, - int plane, BLOCK_SIZE plane_bsize, - int blk_row, int blk_col, int block, - TX_SIZE tx_size, int *eob_total) { +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) { MACROBLOCKD *const xd = &td->xd; const struct macroblockd_plane *const pd = &xd->plane[plane]; const TX_SIZE plane_tx_size = @@ -333,61 +318,58 @@ static void decode_reconstruct_tx(AV1_COMMON *cm, ThreadData *const td, } } -static void set_offsets(AV1_COMMON *const cm, MACROBLOCKD *const xd, - BLOCK_SIZE bsize, int mi_row, int mi_col, int bw, - int bh, int x_mis, int y_mis) { +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 int offset = mi_row * cm->mi_stride + mi_col; + const CommonModeInfoParams *const mi_params = &cm->mi_params; const TileInfo *const tile = &xd->tile; - xd->mi = cm->mi_grid_visible + offset; - xd->mi[0] = &cm->mi[offset]; - // TODO(slavarnway): Generate sb_type based on bwl and bhl, instead of - // passing bsize from decode_partition(). + set_mi_offsets(mi_params, xd, mi_row, mi_col); xd->mi[0]->sb_type = bsize; #if CONFIG_RD_DEBUG xd->mi[0]->mi_row = mi_row; xd->mi[0]->mi_col = mi_col; #endif - xd->cfl.mi_row = mi_row; - xd->cfl.mi_col = mi_col; assert(x_mis && y_mis); for (int x = 1; x < x_mis; ++x) xd->mi[x] = xd->mi[0]; - int idx = cm->mi_stride; + 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 += cm->mi_stride; + idx += mi_params->mi_stride; } set_plane_n4(xd, bw, bh, num_planes); - set_skip_context(xd, mi_row, mi_col, 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, cm->mi_rows, cm->mi_cols); + 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, get_frame_new_buffer(cm), mi_row, - mi_col, 0, num_planes); + av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0, + num_planes); } -static void decode_mbmi_block(AV1Decoder *const pbi, MACROBLOCKD *const xd, - int mi_row, int mi_col, aom_reader *r, - PARTITION_TYPE partition, BLOCK_SIZE bsize) { +static AOM_INLINE void decode_mbmi_block(AV1Decoder *const pbi, + MACROBLOCKD *const xd, int mi_row, + int mi_col, aom_reader *r, + PARTITION_TYPE partition, + BLOCK_SIZE bsize) { AV1_COMMON *const cm = &pbi->common; const SequenceHeader *const seq_params = &cm->seq_params; const int bw = mi_size_wide[bsize]; const int bh = mi_size_high[bsize]; - const int x_mis = AOMMIN(bw, cm->mi_cols - mi_col); - const int y_mis = AOMMIN(bh, cm->mi_rows - mi_row); + 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); #if CONFIG_ACCOUNTING aom_accounting_set_context(&pbi->accounting, mi_col, mi_row); #endif set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis); xd->mi[0]->partition = partition; - av1_read_mode_info(pbi, xd, mi_row, mi_col, r, x_mis, y_mis); + av1_read_mode_info(pbi, xd, r, x_mis, y_mis); if (bsize >= BLOCK_8X8 && (seq_params->subsampling_x || seq_params->subsampling_y)) { const BLOCK_SIZE uv_subsize = @@ -397,9 +379,6 @@ static void decode_mbmi_block(AV1Decoder *const pbi, MACROBLOCKD *const xd, aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, "Invalid block size."); } - - int reader_corrupted_flag = aom_reader_has_error(r); - aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag); } typedef struct PadBlock { @@ -409,9 +388,11 @@ typedef struct PadBlock { int y1; } PadBlock; -static void highbd_build_mc_border(const uint8_t *src8, int src_stride, - uint8_t *dst8, int dst_stride, int x, int y, - int b_w, int b_h, int w, int h) { +#if CONFIG_AV1_HIGHBITDEPTH +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); @@ -446,10 +427,11 @@ static void highbd_build_mc_border(const uint8_t *src8, int src_stride, if (y > 0 && y < h) ref_row += src_stride; } while (--b_h); } +#endif // CONFIG_AV1_HIGHBITDEPTH -static void build_mc_border(const uint8_t *src, int src_stride, uint8_t *dst, - int dst_stride, int x, int y, int b_w, int b_h, - int w, int h) { +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; @@ -536,6 +518,7 @@ static INLINE void extend_mc_border(const struct scale_factors *const sf, const int b_w = block.x1 - block.x0; const int b_h = block.y1 - block.y0; +#if CONFIG_AV1_HIGHBITDEPTH // Extend the border. if (highbd) { highbd_build_mc_border(buf_ptr, buf_stride, mc_buf, b_w, block.x0, @@ -545,27 +528,36 @@ static INLINE void extend_mc_border(const struct scale_factors *const sf, 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 + (void)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); +#endif *src_stride = b_w; *pre = mc_buf + y_pad * (AOM_INTERP_EXTEND - 1) * b_w + x_pad * (AOM_INTERP_EXTEND - 1); } } -static INLINE void dec_calc_subpel_params( - MACROBLOCKD *xd, const struct scale_factors *const sf, const MV mv, - int plane, const int pre_x, const int pre_y, int x, int y, - struct buf_2d *const pre_buf, SubpelParams *subpel_params, int bw, int bh, - PadBlock *block, int mi_x, int mi_y, MV32 *scaled_mv, int *subpel_x_mv, - int *subpel_y_mv) { - struct macroblockd_plane *const pd = &xd->plane[plane]; +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, 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; + const int bw = inter_pred_params->block_width; + const int bh = inter_pred_params->block_height; const int is_scaled = av1_is_scaled(sf); if (is_scaled) { - int ssx = pd->subsampling_x; - int ssy = pd->subsampling_y; - int orig_pos_y = (pre_y + y) << SUBPEL_BITS; - orig_pos_y += mv.row * (1 << (1 - ssy)); - int orig_pos_x = (pre_x + x) << SUBPEL_BITS; - orig_pos_x += mv.col * (1 << (1 - ssx)); + int ssx = inter_pred_params->subsampling_x; + int ssy = inter_pred_params->subsampling_y; + int orig_pos_y = inter_pred_params->pix_row << SUBPEL_BITS; + orig_pos_y += src_mv->row * (1 << (1 - ssy)); + int orig_pos_x = inter_pred_params->pix_col << SUBPEL_BITS; + orig_pos_x += src_mv->col * (1 << (1 - ssx)); int pos_y = sf->scale_value_y(orig_pos_y, sf); int pos_x = sf->scale_value_x(orig_pos_x, sf); pos_x += SCALE_EXTRA_OFF; @@ -595,9 +587,10 @@ static INLINE void dec_calc_subpel_params( ((pos_y + (bh - 1) * subpel_params->ys) >> SCALE_SUBPEL_BITS) + 1; MV temp_mv; - temp_mv = clamp_mv_to_umv_border_sb(xd, &mv, bw, bh, pd->subsampling_x, - pd->subsampling_y); - *scaled_mv = av1_scale_mv(&temp_mv, (mi_x + x), (mi_y + y), sf); + temp_mv = clamp_mv_to_umv_border_sb(xd, src_mv, bw, bh, + 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; @@ -605,11 +598,12 @@ static INLINE void dec_calc_subpel_params( *subpel_y_mv = scaled_mv->row & SCALE_SUBPEL_MASK; } else { // Get block position in current frame. - int pos_x = (pre_x + x) << SUBPEL_BITS; - int pos_y = (pre_y + y) << SUBPEL_BITS; + 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, &mv, bw, bh, pd->subsampling_x, pd->subsampling_y); + xd, src_mv, bw, bh, 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; @@ -629,294 +623,79 @@ static INLINE void dec_calc_subpel_params( *subpel_x_mv = scaled_mv->col & SUBPEL_MASK; *subpel_y_mv = scaled_mv->row & SUBPEL_MASK; } -} - -static INLINE void dec_build_inter_predictors(const AV1_COMMON *cm, - MACROBLOCKD *xd, int plane, - const MB_MODE_INFO *mi, - int build_for_obmc, int bw, - int bh, int mi_x, int mi_y) { - struct macroblockd_plane *const pd = &xd->plane[plane]; - int is_compound = has_second_ref(mi); - int ref; - const int is_intrabc = is_intrabc_block(mi); - assert(IMPLIES(is_intrabc, !is_compound)); - int is_global[2] = { 0, 0 }; - for (ref = 0; ref < 1 + is_compound; ++ref) { - const WarpedMotionParams *const wm = &xd->global_motion[mi->ref_frame[ref]]; - is_global[ref] = is_global_mv_block(mi, wm->wmtype); - } - - const BLOCK_SIZE bsize = mi->sb_type; - const int ss_x = pd->subsampling_x; - const int ss_y = pd->subsampling_y; - int sub8x8_inter = (block_size_wide[bsize] < 8 && ss_x) || - (block_size_high[bsize] < 8 && ss_y); - - if (is_intrabc) sub8x8_inter = 0; - - // For sub8x8 chroma blocks, we may be covering more than one luma block's - // worth of pixels. Thus (mi_x, mi_y) may not be the correct coordinates for - // the top-left corner of the prediction source - the correct top-left corner - // is at (pre_x, pre_y). - const int row_start = - (block_size_high[bsize] == 4) && ss_y && !build_for_obmc ? -1 : 0; - const int col_start = - (block_size_wide[bsize] == 4) && ss_x && !build_for_obmc ? -1 : 0; - const int pre_x = (mi_x + MI_SIZE * col_start) >> ss_x; - const int pre_y = (mi_y + MI_SIZE * row_start) >> ss_y; - - sub8x8_inter = sub8x8_inter && !build_for_obmc; - if (sub8x8_inter) { - for (int row = row_start; row <= 0 && sub8x8_inter; ++row) { - for (int col = col_start; col <= 0; ++col) { - const MB_MODE_INFO *this_mbmi = xd->mi[row * xd->mi_stride + col]; - if (!is_inter_block(this_mbmi)) sub8x8_inter = 0; - if (is_intrabc_block(this_mbmi)) sub8x8_inter = 0; - } - } - } - - if (sub8x8_inter) { - // block size - const int b4_w = block_size_wide[bsize] >> ss_x; - const int b4_h = block_size_high[bsize] >> ss_y; - const BLOCK_SIZE plane_bsize = scale_chroma_bsize(bsize, ss_x, ss_y); - const int b8_w = block_size_wide[plane_bsize] >> ss_x; - const int b8_h = block_size_high[plane_bsize] >> ss_y; - assert(!is_compound); - - const struct buf_2d orig_pred_buf[2] = { pd->pre[0], pd->pre[1] }; - - int row = row_start; - int src_stride; - for (int y = 0; y < b8_h; y += b4_h) { - int col = col_start; - for (int x = 0; x < b8_w; x += b4_w) { - MB_MODE_INFO *this_mbmi = xd->mi[row * xd->mi_stride + col]; - is_compound = has_second_ref(this_mbmi); - int tmp_dst_stride = 8; - assert(bw < 8 || bh < 8); - ConvolveParams conv_params = get_conv_params_no_round( - 0, plane, xd->tmp_conv_dst, tmp_dst_stride, is_compound, xd->bd); - conv_params.use_jnt_comp_avg = 0; - struct buf_2d *const dst_buf = &pd->dst; - uint8_t *dst = dst_buf->buf + dst_buf->stride * y + x; - - ref = 0; - const RefBuffer *ref_buf = - &cm->frame_refs[this_mbmi->ref_frame[ref] - LAST_FRAME]; - - pd->pre[ref].buf0 = - (plane == 1) ? ref_buf->buf->u_buffer : ref_buf->buf->v_buffer; - pd->pre[ref].buf = - pd->pre[ref].buf0 + scaled_buffer_offset(pre_x, pre_y, - ref_buf->buf->uv_stride, - &ref_buf->sf); - pd->pre[ref].width = ref_buf->buf->uv_crop_width; - pd->pre[ref].height = ref_buf->buf->uv_crop_height; - pd->pre[ref].stride = ref_buf->buf->uv_stride; - - const struct scale_factors *const sf = - is_intrabc ? &cm->sf_identity : &ref_buf->sf; - struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref]; - - const MV mv = this_mbmi->mv[ref].as_mv; - - uint8_t *pre; - SubpelParams subpel_params; - PadBlock block; - MV32 scaled_mv; - int subpel_x_mv, subpel_y_mv; - int highbd; - WarpTypesAllowed warp_types; - warp_types.global_warp_allowed = is_global[ref]; - warp_types.local_warp_allowed = this_mbmi->motion_mode == WARPED_CAUSAL; - - dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, x, y, pre_buf, - &subpel_params, bw, bh, &block, mi_x, mi_y, - &scaled_mv, &subpel_x_mv, &subpel_y_mv); - pre = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0; - src_stride = pre_buf->stride; - highbd = xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH; - extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv, - subpel_y_mv, 0, is_intrabc, highbd, xd->mc_buf[ref], - &pre, &src_stride); - conv_params.do_average = ref; - if (is_masked_compound_type(mi->interinter_comp.type)) { - // masked compound type has its own average mechanism - conv_params.do_average = 0; - } - - av1_make_inter_predictor( - pre, src_stride, dst, dst_buf->stride, &subpel_params, sf, b4_w, - b4_h, &conv_params, this_mbmi->interp_filters, &warp_types, - (mi_x >> pd->subsampling_x) + x, (mi_y >> pd->subsampling_y) + y, - plane, ref, mi, build_for_obmc, xd, cm->allow_warped_motion); - - ++col; - } - ++row; - } - - for (ref = 0; ref < 2; ++ref) pd->pre[ref] = orig_pred_buf[ref]; - return; - } - - { - struct buf_2d *const dst_buf = &pd->dst; - uint8_t *const dst = dst_buf->buf; - uint8_t *pre[2]; - SubpelParams subpel_params[2]; - int src_stride[2]; - for (ref = 0; ref < 1 + is_compound; ++ref) { - const struct scale_factors *const sf = - is_intrabc ? &cm->sf_identity : &xd->block_refs[ref]->sf; - struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref]; - const MV mv = mi->mv[ref].as_mv; - PadBlock block; - MV32 scaled_mv; - int subpel_x_mv, subpel_y_mv; - int highbd; - - dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, 0, 0, pre_buf, - &subpel_params[ref], bw, bh, &block, mi_x, mi_y, - &scaled_mv, &subpel_x_mv, &subpel_y_mv); - pre[ref] = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0; - src_stride[ref] = pre_buf->stride; - highbd = xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH; - - WarpTypesAllowed warp_types; - warp_types.global_warp_allowed = is_global[ref]; - warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL; - int do_warp = (bw >= 8 && bh >= 8 && - av1_allow_warp(mi, &warp_types, - &xd->global_motion[mi->ref_frame[ref]], - build_for_obmc, subpel_params[ref].xs, - subpel_params[ref].ys, NULL)); - do_warp = (do_warp && xd->cur_frame_force_integer_mv == 0); - - extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv, subpel_y_mv, - do_warp, is_intrabc, highbd, xd->mc_buf[ref], &pre[ref], - &src_stride[ref]); - } - - ConvolveParams conv_params = get_conv_params_no_round( - 0, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd); - av1_jnt_comp_weight_assign(cm, mi, 0, &conv_params.fwd_offset, - &conv_params.bck_offset, - &conv_params.use_jnt_comp_avg, is_compound); - - for (ref = 0; ref < 1 + is_compound; ++ref) { - const struct scale_factors *const sf = - is_intrabc ? &cm->sf_identity : &xd->block_refs[ref]->sf; - WarpTypesAllowed warp_types; - warp_types.global_warp_allowed = is_global[ref]; - warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL; - conv_params.do_average = ref; - if (is_masked_compound_type(mi->interinter_comp.type)) { - // masked compound type has its own average mechanism - conv_params.do_average = 0; - } - - if (ref && is_masked_compound_type(mi->interinter_comp.type)) - av1_make_masked_inter_predictor( - pre[ref], src_stride[ref], dst, dst_buf->stride, - &subpel_params[ref], sf, bw, bh, &conv_params, mi->interp_filters, - plane, &warp_types, mi_x >> pd->subsampling_x, - mi_y >> pd->subsampling_y, ref, xd, cm->allow_warped_motion); - else - av1_make_inter_predictor( - pre[ref], src_stride[ref], dst, dst_buf->stride, - &subpel_params[ref], sf, bw, bh, &conv_params, mi->interp_filters, - &warp_types, mi_x >> pd->subsampling_x, mi_y >> pd->subsampling_y, - plane, ref, mi, build_for_obmc, xd, cm->allow_warped_motion); + *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 *xd, int mi_x, int mi_y, int ref, 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, &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, xd->mc_buf[ref], pre, src_stride); +} + +static void dec_build_inter_predictors(const AV1_COMMON *cm, MACROBLOCKD *xd, + int plane, const MB_MODE_INFO *mi, + int build_for_obmc, int bw, int bh, + int mi_x, int mi_y) { + av1_build_inter_predictors(cm, xd, plane, mi, build_for_obmc, bw, bh, mi_x, + mi_y, dec_calc_subpel_params_and_extend); +} + +static AOM_INLINE void dec_build_inter_predictor(const AV1_COMMON *cm, + MACROBLOCKD *xd, int mi_row, + int mi_col, BLOCK_SIZE bsize) { + 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, xd, 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 void dec_build_inter_predictors_for_planes(const AV1_COMMON *cm, - MACROBLOCKD *xd, - BLOCK_SIZE bsize, int mi_row, - int mi_col, int plane_from, - int plane_to) { - int plane; - const int mi_x = mi_col * MI_SIZE; - const int mi_y = mi_row * MI_SIZE; - for (plane = plane_from; plane <= plane_to; ++plane) { - const struct macroblockd_plane *pd = &xd->plane[plane]; - const int bw = pd->width; - const int bh = pd->height; - - if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, - pd->subsampling_y)) - continue; - - dec_build_inter_predictors(cm, xd, plane, xd->mi[0], 0, bw, bh, mi_x, mi_y); - } -} - -static void dec_build_inter_predictors_sby(const AV1_COMMON *cm, - MACROBLOCKD *xd, int mi_row, - int mi_col, BUFFER_SET *ctx, - BLOCK_SIZE bsize) { - dec_build_inter_predictors_for_planes(cm, xd, bsize, mi_row, mi_col, 0, 0); - - if (is_interintra_pred(xd->mi[0])) { - BUFFER_SET default_ctx = { { xd->plane[0].dst.buf, NULL, NULL }, - { xd->plane[0].dst.stride, 0, 0 } }; - if (!ctx) ctx = &default_ctx; - av1_build_interintra_predictors_sbp(cm, xd, xd->plane[0].dst.buf, - xd->plane[0].dst.stride, ctx, 0, bsize); - } -} - -static void dec_build_inter_predictors_sbuv(const AV1_COMMON *cm, - MACROBLOCKD *xd, int mi_row, - int mi_col, BUFFER_SET *ctx, - BLOCK_SIZE bsize) { - dec_build_inter_predictors_for_planes(cm, xd, bsize, mi_row, mi_col, 1, - MAX_MB_PLANE - 1); - - if (is_interintra_pred(xd->mi[0])) { - BUFFER_SET default_ctx = { - { NULL, xd->plane[1].dst.buf, xd->plane[2].dst.buf }, - { 0, xd->plane[1].dst.stride, xd->plane[2].dst.stride } - }; - if (!ctx) ctx = &default_ctx; - av1_build_interintra_predictors_sbuv( - cm, xd, xd->plane[1].dst.buf, xd->plane[2].dst.buf, - xd->plane[1].dst.stride, xd->plane[2].dst.stride, ctx, bsize); - } -} - -static void dec_build_inter_predictors_sb(const AV1_COMMON *cm, MACROBLOCKD *xd, - int mi_row, int mi_col, - BUFFER_SET *ctx, BLOCK_SIZE bsize) { - const int num_planes = av1_num_planes(cm); - dec_build_inter_predictors_sby(cm, xd, mi_row, mi_col, ctx, bsize); - if (num_planes > 1) - dec_build_inter_predictors_sbuv(cm, xd, mi_row, mi_col, ctx, bsize); -} - static INLINE void dec_build_prediction_by_above_pred( - MACROBLOCKD *xd, int rel_mi_col, uint8_t above_mi_width, - MB_MODE_INFO *above_mbmi, void *fun_ctxt, const int num_planes) { + MACROBLOCKD *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 = ctxt->mi_col + rel_mi_col; + const int above_mi_col = xd->mi_col + rel_mi_col; int mi_x, mi_y; MB_MODE_INFO backup_mbmi = *above_mbmi; - av1_setup_build_prediction_by_above_pred(xd, rel_mi_col, above_mi_width, + (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 = ctxt->mi_row << MI_SIZE_LOG2; + mi_y = xd->mi_row << MI_SIZE_LOG2; const BLOCK_SIZE bsize = xd->mi[0]->sb_type; for (int j = 0; j < num_planes; ++j) { const struct macroblockd_plane *pd = &xd->plane[j]; - int bw = (above_mi_width * MI_SIZE) >> pd->subsampling_x; + int 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)); @@ -926,44 +705,45 @@ static INLINE void dec_build_prediction_by_above_pred( } } -static void dec_build_prediction_by_above_preds( - const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, - uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE], - int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) { +static AOM_INLINE void dec_build_prediction_by_above_preds( + const AV1_COMMON *cm, MACROBLOCKD *xd, uint8_t *tmp_buf[MAX_MB_PLANE], + int tmp_width[MAX_MB_PLANE], int tmp_height[MAX_MB_PLANE], + int tmp_stride[MAX_MB_PLANE]) { if (!xd->up_available) return; // Adjust mb_to_bottom_edge to have the correct value for the OBMC // prediction block. This is half the height of the original block, // except for 128-wide blocks, where we only use a height of 32. - int this_height = xd->n4_h * MI_SIZE; - int pred_height = AOMMIN(this_height / 2, 32); - xd->mb_to_bottom_edge += (this_height - pred_height) * 8; - - struct build_prediction_ctxt ctxt = { cm, mi_row, - mi_col, tmp_buf, + 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 }; - BLOCK_SIZE bsize = xd->mi[0]->sb_type; - foreach_overlappable_nb_above(cm, xd, mi_col, + const BLOCK_SIZE bsize = xd->mi[0]->sb_type; + foreach_overlappable_nb_above(cm, xd, max_neighbor_obmc[mi_size_wide_log2[bsize]], dec_build_prediction_by_above_pred, &ctxt); - xd->mb_to_left_edge = -((mi_col * MI_SIZE) * 8); + 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 -= (this_height - pred_height) * 8; + xd->mb_to_bottom_edge -= GET_MV_SUBPEL(this_height - pred_height); } static INLINE void dec_build_prediction_by_left_pred( - MACROBLOCKD *xd, int rel_mi_row, uint8_t left_mi_height, - MB_MODE_INFO *left_mbmi, void *fun_ctxt, const int num_planes) { + MACROBLOCKD *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 = ctxt->mi_row + rel_mi_row; + const int left_mi_row = xd->mi_row + rel_mi_row; int mi_x, mi_y; MB_MODE_INFO backup_mbmi = *left_mbmi; - av1_setup_build_prediction_by_left_pred(xd, rel_mi_row, left_mi_height, + (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 = ctxt->mi_col << MI_SIZE_LOG2; + mi_x = xd->mi_col << MI_SIZE_LOG2; mi_y = left_mi_row << MI_SIZE_LOG2; const BLOCK_SIZE bsize = xd->mi[0]->sb_type; @@ -971,7 +751,7 @@ static INLINE void dec_build_prediction_by_left_pred( const struct macroblockd_plane *pd = &xd->plane[j]; int bw = clamp(block_size_wide[bsize] >> (pd->subsampling_x + 1), 4, block_size_wide[BLOCK_64X64] >> (pd->subsampling_x + 1)); - int bh = (left_mi_height << MI_SIZE_LOG2) >> pd->subsampling_y; + 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, xd, j, &backup_mbmi, 1, bw, bh, mi_x, @@ -979,36 +759,59 @@ static INLINE void dec_build_prediction_by_left_pred( } } -static void dec_build_prediction_by_left_preds( - const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, - uint8_t *tmp_buf[MAX_MB_PLANE], int tmp_width[MAX_MB_PLANE], - int tmp_height[MAX_MB_PLANE], int tmp_stride[MAX_MB_PLANE]) { +static AOM_INLINE void dec_build_prediction_by_left_preds( + const AV1_COMMON *cm, MACROBLOCKD *xd, uint8_t *tmp_buf[MAX_MB_PLANE], + int tmp_width[MAX_MB_PLANE], int tmp_height[MAX_MB_PLANE], + int tmp_stride[MAX_MB_PLANE]) { if (!xd->left_available) return; // Adjust mb_to_right_edge to have the correct value for the OBMC // prediction block. This is half the width of the original block, // except for 128-wide blocks, where we only use a width of 32. - int this_width = xd->n4_w * MI_SIZE; - int pred_width = AOMMIN(this_width / 2, 32); - xd->mb_to_right_edge += (this_width - pred_width) * 8; + 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, mi_row, - mi_col, tmp_buf, + struct build_prediction_ctxt ctxt = { cm, tmp_buf, tmp_width, tmp_height, tmp_stride, xd->mb_to_bottom_edge }; - BLOCK_SIZE bsize = xd->mi[0]->sb_type; - foreach_overlappable_nb_left(cm, xd, mi_row, + const BLOCK_SIZE bsize = xd->mi[0]->sb_type; + foreach_overlappable_nb_left(cm, xd, max_neighbor_obmc[mi_size_high_log2[bsize]], dec_build_prediction_by_left_pred, &ctxt); - xd->mb_to_top_edge = -((mi_row * MI_SIZE) * 8); - xd->mb_to_right_edge -= (this_width - pred_width) * 8; + 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 void dec_build_obmc_inter_predictors_sb(const AV1_COMMON *cm, - MACROBLOCKD *xd, int mi_row, - int mi_col) { +static void set_dst_buf(MACROBLOCKD *xd, uint8_t **dst_buf1, + uint8_t **dst_buf2) { + dst_buf1[0] = xd->tmp_obmc_bufs[0]; + dst_buf1[1] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE; + dst_buf1[2] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2; + dst_buf2[0] = xd->tmp_obmc_bufs[1]; + dst_buf2[1] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE; + dst_buf2[2] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2; +} + +#if CONFIG_AV1_HIGHBITDEPTH +static void set_dst_buf_highbd(MACROBLOCKD *xd, uint8_t **dst_buf1, + uint8_t **dst_buf2) { + int len = sizeof(uint16_t); + dst_buf1[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0]); + dst_buf1[1] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * len); + dst_buf1[2] = + CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2 * len); + dst_buf2[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1]); + dst_buf2[1] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * len); + dst_buf2[2] = + CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2 * len); +} +#endif + +static AOM_INLINE void dec_build_obmc_inter_predictors_sb(const AV1_COMMON *cm, + MACROBLOCKD *xd) { const int num_planes = av1_num_planes(cm); uint8_t *dst_buf1[MAX_MB_PLANE], *dst_buf2[MAX_MB_PLANE]; int dst_stride1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; @@ -1018,47 +821,43 @@ static void dec_build_obmc_inter_predictors_sb(const AV1_COMMON *cm, int dst_height1[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; int dst_height2[MAX_MB_PLANE] = { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE }; - if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - int len = sizeof(uint16_t); - dst_buf1[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0]); - dst_buf1[1] = - CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * len); - dst_buf1[2] = - CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2 * len); - dst_buf2[0] = CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1]); - dst_buf2[1] = - CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * len); - dst_buf2[2] = - CONVERT_TO_BYTEPTR(xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2 * len); +#if CONFIG_AV1_HIGHBITDEPTH + if (is_cur_buf_hbd(xd)) { + set_dst_buf_highbd(xd, dst_buf1, dst_buf2); } else { - dst_buf1[0] = xd->tmp_obmc_bufs[0]; - dst_buf1[1] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE; - dst_buf1[2] = xd->tmp_obmc_bufs[0] + MAX_SB_SQUARE * 2; - dst_buf2[0] = xd->tmp_obmc_bufs[1]; - dst_buf2[1] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE; - dst_buf2[2] = xd->tmp_obmc_bufs[1] + MAX_SB_SQUARE * 2; - } - dec_build_prediction_by_above_preds(cm, xd, mi_row, mi_col, dst_buf1, - dst_width1, dst_height1, dst_stride1); - dec_build_prediction_by_left_preds(cm, xd, mi_row, mi_col, dst_buf2, - dst_width2, dst_height2, dst_stride2); - av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type, get_frame_new_buffer(cm), + set_dst_buf(xd, dst_buf1, dst_buf2); + } +#else + set_dst_buf(xd, dst_buf1, dst_buf2); +#endif + + dec_build_prediction_by_above_preds(cm, xd, dst_buf1, dst_width1, dst_height1, + dst_stride1); + dec_build_prediction_by_left_preds(cm, xd, dst_buf2, dst_width2, dst_height2, + dst_stride2); + const int mi_row = xd->mi_row; + const int mi_col = xd->mi_col; + av1_setup_dst_planes(xd->plane, xd->mi[0]->sb_type, &cm->cur_frame->buf, mi_row, mi_col, 0, num_planes); - av1_build_obmc_inter_prediction(cm, xd, mi_row, mi_col, dst_buf1, dst_stride1, - dst_buf2, dst_stride2); + av1_build_obmc_inter_prediction(cm, xd, dst_buf1, dst_stride1, dst_buf2, + dst_stride2); } -static void cfl_store_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd) { +static AOM_INLINE void cfl_store_inter_block(AV1_COMMON *const cm, + MACROBLOCKD *const xd) { MB_MODE_INFO *mbmi = xd->mi[0]; if (store_cfl_required(cm, xd)) { cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size); } } -static void predict_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_row, int mi_col, BLOCK_SIZE bsize) { +static AOM_INLINE void predict_inter_block(AV1_COMMON *const cm, + MACROBLOCKD *const xd, + BLOCK_SIZE bsize) { MB_MODE_INFO *mbmi = xd->mi[0]; const int num_planes = av1_num_planes(cm); + const int mi_row = xd->mi_row; + const int mi_col = xd->mi_col; for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) { const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref]; if (frame < LAST_FRAME) { @@ -1066,17 +865,19 @@ static void predict_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd, assert(frame == INTRA_FRAME); assert(ref == 0); } else { - RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME]; + 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_refs[ref] = ref_buf; - av1_setup_pre_planes(xd, ref, ref_buf->buf, mi_row, mi_col, &ref_buf->sf, - num_planes); + 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_predictors_sb(cm, xd, mi_row, mi_col, NULL, bsize); + dec_build_inter_predictor(cm, xd, mi_row, mi_col, bsize); if (mbmi->motion_mode == OBMC_CAUSAL) { - dec_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col); + dec_build_obmc_inter_predictors_sb(cm, xd); } #if CONFIG_MISMATCH_DEBUG for (int plane = 0; plane < num_planes; ++plane) { @@ -1087,15 +888,16 @@ static void predict_inter_block(AV1_COMMON *const cm, MACROBLOCKD *const xd, if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, pd->subsampling_y)) continue; - mismatch_check_block_pre(pd->dst.buf, pd->dst.stride, cm->frame_offset, - plane, pixel_c, pixel_r, pd->width, pd->height, + mismatch_check_block_pre(pd->dst.buf, pd->dst.stride, + cm->current_frame.order_hint, plane, pixel_c, + pixel_r, pd->width, pd->height, xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH); } #endif } -static void set_color_index_map_offset(MACROBLOCKD *const xd, int plane, - aom_reader *r) { +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]; @@ -1104,18 +906,14 @@ static void set_color_index_map_offset(MACROBLOCKD *const xd, int plane, xd->color_index_map_offset[plane] += params.plane_width * params.plane_height; } -static void decode_token_recon_block(AV1Decoder *const pbi, - ThreadData *const td, int mi_row, - int mi_col, aom_reader *r, - BLOCK_SIZE bsize) { +static AOM_INLINE void decode_token_recon_block(AV1Decoder *const pbi, + ThreadData *const td, + aom_reader *r, + BLOCK_SIZE bsize) { AV1_COMMON *const cm = &pbi->common; MACROBLOCKD *const xd = &td->xd; const int num_planes = av1_num_planes(cm); - MB_MODE_INFO *mbmi = xd->mi[0]; - CFL_CTX *const cfl = &xd->cfl; - cfl->is_chroma_reference = is_chroma_reference( - mi_row, mi_col, bsize, cfl->subsampling_x, cfl->subsampling_y); if (!is_inter_block(mbmi)) { int row, col; @@ -1124,21 +922,16 @@ static void decode_token_recon_block(AV1Decoder *const pbi, const int max_blocks_wide = max_block_wide(xd, bsize, 0); const int max_blocks_high = max_block_high(xd, bsize, 0); const BLOCK_SIZE max_unit_bsize = BLOCK_64X64; - int mu_blocks_wide = - block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0]; - int mu_blocks_high = - block_size_high[max_unit_bsize] >> tx_size_high_log2[0]; + int mu_blocks_wide = mi_size_wide[max_unit_bsize]; + int mu_blocks_high = mi_size_high[max_unit_bsize]; mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide); mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high); for (row = 0; row < max_blocks_high; row += mu_blocks_high) { for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) { for (int plane = 0; plane < num_planes; ++plane) { + if (plane && !xd->is_chroma_ref) break; const struct macroblockd_plane *const pd = &xd->plane[plane]; - if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, - pd->subsampling_y)) - continue; - const TX_SIZE tx_size = av1_get_tx_size(plane, xd); const int stepr = tx_size_high_unit[tx_size]; const int stepc = tx_size_wide_unit[tx_size]; @@ -1163,7 +956,7 @@ static void decode_token_recon_block(AV1Decoder *const pbi, } } } else { - td->predict_inter_block_visit(cm, xd, mi_row, mi_col, bsize); + td->predict_inter_block_visit(cm, xd, bsize); // Reconstruction if (!mbmi->skip) { int eobtotal = 0; @@ -1176,10 +969,8 @@ static void decode_token_recon_block(AV1Decoder *const pbi, assert(max_unit_bsize == get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x, xd->plane[0].subsampling_y)); - int mu_blocks_wide = - block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0]; - int mu_blocks_high = - block_size_high[max_unit_bsize] >> tx_size_high_log2[0]; + 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); @@ -1187,15 +978,12 @@ static void decode_token_recon_block(AV1Decoder *const pbi, for (row = 0; row < max_blocks_high; row += mu_blocks_high) { for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) { for (int plane = 0; plane < num_planes; ++plane) { + if (plane && !xd->is_chroma_ref) break; const struct macroblockd_plane *const pd = &xd->plane[plane]; - if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, - pd->subsampling_y)) - continue; - const BLOCK_SIZE bsizec = - scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y); - const BLOCK_SIZE plane_bsize = get_plane_block_size( - bsizec, pd->subsampling_x, pd->subsampling_y); - + const 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]; @@ -1205,15 +993,13 @@ static void decode_token_recon_block(AV1Decoder *const pbi, 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), - pd->subsampling_y); + 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), - pd->subsampling_x); + AOMMIN(mu_blocks_wide + col, max_blocks_wide), ss_x); - for (blk_row = row >> pd->subsampling_y; blk_row < unit_height; + for (blk_row = row >> ss_y; blk_row < unit_height; blk_row += bh_var_tx) { - for (blk_col = col >> pd->subsampling_x; blk_col < unit_width; + 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, @@ -1228,22 +1014,32 @@ static void decode_token_recon_block(AV1Decoder *const pbi, td->cfl_store_inter_block_visit(cm, xd); } - av1_visit_palette(pbi, xd, mi_row, mi_col, r, bsize, - set_color_index_map_offset); + av1_visit_palette(pbi, xd, r, set_color_index_map_offset); } -#if LOOP_FILTER_BITMASK -static void store_bitmask_vartx(AV1_COMMON *cm, int mi_row, int mi_col, - BLOCK_SIZE bsize, TX_SIZE tx_size, - MB_MODE_INFO *mbmi); -#endif +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; + } + } +} -static void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, - TX_SIZE tx_size, int depth, -#if LOOP_FILTER_BITMASK - AV1_COMMON *cm, int mi_row, int mi_col, +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) { + int blk_row, int blk_col, + aom_reader *r) { FRAME_CONTEXT *ec_ctx = xd->tile_ctx; int is_split = 0; const BLOCK_SIZE bsize = mbmi->sb_type; @@ -1251,15 +1047,17 @@ static void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, 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) { - for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) { - for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) { - const int index = - av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx); - mbmi->inter_tx_size[index] = tx_size; - } - } + 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); @@ -1277,26 +1075,24 @@ static void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, const int bsh = tx_size_high_unit[sub_txs]; if (sub_txs == TX_4X4) { - for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) { - for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) { - const int index = - av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx); - mbmi->inter_tx_size[index] = sub_txs; - } - } + 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 LOOP_FILTER_BITMASK - store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, BLOCK_8X8, - TX_4X4, mbmi); +#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 LOOP_FILTER_BITMASK - if (depth + 1 == MAX_VARTX_DEPTH) { - store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, - txsize_to_bsize[tx_size], sub_txs, mbmi); +#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 @@ -1306,31 +1102,29 @@ static void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, int offsetr = blk_row + row; int offsetc = blk_col + col; read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1, -#if LOOP_FILTER_BITMASK - cm, mi_row, mi_col, +#if CONFIG_LPF_MASK + cm, mi_row, mi_col, store_bitmask, #endif offsetr, offsetc, r); } } } else { - for (int idy = 0; idy < tx_size_high_unit[tx_size]; ++idy) { - for (int idx = 0; idx < tx_size_wide_unit[tx_size]; ++idx) { - const int index = - av1_get_txb_size_index(bsize, blk_row + idy, blk_col + idx); - mbmi->inter_tx_size[index] = tx_size; - } - } + 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 LOOP_FILTER_BITMASK - store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, - txsize_to_bsize[tx_size], tx_size, mbmi); +#if CONFIG_LPF_MASK + if (store_bitmask) { + av1_store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, + txsize_to_bsize[tx_size], tx_size, mbmi); + } #endif } } -static TX_SIZE read_selected_tx_size(MACROBLOCKD *xd, aom_reader *r) { +static TX_SIZE read_selected_tx_size(const MACROBLOCKD *const xd, + aom_reader *r) { // TODO(debargha): Clean up the logic here. This function should only // be called for intra. const BLOCK_SIZE bsize = xd->mi[0]->sb_type; @@ -1345,9 +1139,9 @@ static TX_SIZE read_selected_tx_size(MACROBLOCKD *xd, aom_reader *r) { return tx_size; } -static TX_SIZE read_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd, int is_inter, - int allow_select_inter, aom_reader *r) { - const TX_MODE tx_mode = cm->tx_mode; +static TX_SIZE read_tx_size(const MACROBLOCKD *const xd, TX_MODE tx_mode, + int is_inter, int allow_select_inter, + aom_reader *r) { const BLOCK_SIZE bsize = xd->mi[0]->sb_type; if (xd->lossless[xd->mi[0]->segment_id]) return TX_4X4; @@ -1364,265 +1158,84 @@ static TX_SIZE read_tx_size(AV1_COMMON *cm, MACROBLOCKD *xd, int is_inter, } } -#if LOOP_FILTER_BITMASK -static void store_bitmask_vartx(AV1_COMMON *cm, int mi_row, int mi_col, - BLOCK_SIZE bsize, TX_SIZE tx_size, - MB_MODE_INFO *mbmi) { - LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); - const TX_SIZE tx_size_y_vert = txsize_vert_map[tx_size]; - const TX_SIZE tx_size_y_horz = txsize_horz_map[tx_size]; - const TX_SIZE tx_size_uv_vert = txsize_vert_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - const TX_SIZE tx_size_uv_horz = txsize_horz_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - const int is_square_transform_size = tx_size <= TX_64X64; - int mask_id = 0; - int offset = 0; - const int half_ratio_tx_size_max32 = - (tx_size > TX_64X64) & (tx_size <= TX_32X16); - if (is_square_transform_size) { - switch (tx_size) { - case TX_4X4: mask_id = mask_id_table_tx_4x4[bsize]; break; - case TX_8X8: - mask_id = mask_id_table_tx_8x8[bsize]; - offset = 19; - break; - case TX_16X16: - mask_id = mask_id_table_tx_16x16[bsize]; - offset = 33; - break; - case TX_32X32: - mask_id = mask_id_table_tx_32x32[bsize]; - offset = 42; - break; - case TX_64X64: mask_id = 46; break; - default: assert(!is_square_transform_size); return; - } - mask_id += offset; - } else if (half_ratio_tx_size_max32) { - int tx_size_equal_block_size = bsize == txsize_to_bsize[tx_size]; - mask_id = 47 + 2 * (tx_size - TX_4X8) + (tx_size_equal_block_size ? 0 : 1); - } else if (tx_size == TX_32X64) { - mask_id = 59; - } else if (tx_size == TX_64X32) { - mask_id = 60; - } else { // quarter ratio tx size - mask_id = 61 + (tx_size - TX_4X16); - } - int index = 0; - const int row = mi_row % MI_SIZE_64X64; - const int col = mi_col % MI_SIZE_64X64; - const int shift = get_index_shift(col, row, &index); - const int vert_shift = tx_size_y_vert <= TX_8X8 ? shift : col; - for (int i = 0; i + index < 4; ++i) { - // y vertical. - lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |= - (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); - // y horizontal. - lfm->tx_size_hor[0][tx_size_y_vert].bits[i + index] |= - (above_mask_univariant_reordered[mask_id].bits[i] << shift); - // u/v vertical. - lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |= - (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); - // u/v horizontal. - lfm->tx_size_hor[1][tx_size_uv_vert].bits[i + index] |= - (above_mask_univariant_reordered[mask_id].bits[i] << shift); - } -} - -static void store_bitmask_univariant_tx(AV1_COMMON *cm, int mi_row, int mi_col, - BLOCK_SIZE bsize, MB_MODE_INFO *mbmi) { - // Use a lookup table that provides one bitmask for a given block size and - // a univariant transform size. - int index; - int shift; - int row; - int col; - LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); - const TX_SIZE tx_size_y_vert = txsize_vert_map[mbmi->tx_size]; - const TX_SIZE tx_size_y_horz = txsize_horz_map[mbmi->tx_size]; - const TX_SIZE tx_size_uv_vert = txsize_vert_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - const TX_SIZE tx_size_uv_horz = txsize_horz_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - const int is_square_transform_size = mbmi->tx_size <= TX_64X64; - int mask_id = 0; - int offset = 0; - const int half_ratio_tx_size_max32 = - (mbmi->tx_size > TX_64X64) & (mbmi->tx_size <= TX_32X16); - if (is_square_transform_size) { - switch (mbmi->tx_size) { - case TX_4X4: mask_id = mask_id_table_tx_4x4[bsize]; break; - case TX_8X8: - mask_id = mask_id_table_tx_8x8[bsize]; - offset = 19; - break; - case TX_16X16: - mask_id = mask_id_table_tx_16x16[bsize]; - offset = 33; - break; - case TX_32X32: - mask_id = mask_id_table_tx_32x32[bsize]; - offset = 42; - break; - case TX_64X64: mask_id = 46; break; - default: assert(!is_square_transform_size); return; - } - mask_id += offset; - } else if (half_ratio_tx_size_max32) { - int tx_size_equal_block_size = bsize == txsize_to_bsize[mbmi->tx_size]; - mask_id = - 47 + 2 * (mbmi->tx_size - TX_4X8) + (tx_size_equal_block_size ? 0 : 1); - } else if (mbmi->tx_size == TX_32X64) { - mask_id = 59; - } else if (mbmi->tx_size == TX_64X32) { - mask_id = 60; - } else { // quarter ratio tx size - mask_id = 61 + (mbmi->tx_size - TX_4X16); - } - row = mi_row % MI_SIZE_64X64; - col = mi_col % MI_SIZE_64X64; - shift = get_index_shift(col, row, &index); - const int vert_shift = tx_size_y_vert <= TX_8X8 ? shift : col; - for (int i = 0; i + index < 4; ++i) { - // y vertical. - lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |= - (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); - // y horizontal. - lfm->tx_size_hor[0][tx_size_y_vert].bits[i + index] |= - (above_mask_univariant_reordered[mask_id].bits[i] << shift); - // u/v vertical. - lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |= - (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); - // u/v horizontal. - lfm->tx_size_hor[1][tx_size_uv_vert].bits[i + index] |= - (above_mask_univariant_reordered[mask_id].bits[i] << shift); - } -} - -static void store_bitmask_other_info(AV1_COMMON *cm, int mi_row, int mi_col, - BLOCK_SIZE bsize, MB_MODE_INFO *mbmi) { - int index; - int shift; - int row; - LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); - const int row_start = mi_row % MI_SIZE_64X64; - const int col_start = mi_col % MI_SIZE_64X64; - shift = get_index_shift(col_start, row_start, &index); - const uint64_t top_edge_mask = - ((uint64_t)1 << (shift + mi_size_wide[bsize])) - ((uint64_t)1 << shift); - lfm->is_horz_border.bits[index] |= top_edge_mask; - const int is_vert_border = mask_id_table_vert_border[bsize]; - const int vert_shift = block_size_high[bsize] <= 8 ? shift : col_start; - for (int i = 0; i + index < 4; ++i) { - lfm->is_vert_border.bits[i + index] |= - (left_mask_univariant_reordered[is_vert_border].bits[i] << vert_shift); - } - const int is_skip = mbmi->skip && is_inter_block(mbmi); - if (is_skip) { - const int is_skip_mask = mask_id_table_tx_4x4[bsize]; - for (int i = 0; i + index < 4; ++i) { - lfm->skip.bits[i + index] |= - (above_mask_univariant_reordered[is_skip_mask].bits[i] << shift); - } - } - const uint8_t level_vert_y = get_filter_level(cm, &cm->lf_info, 0, 0, mbmi); - const uint8_t level_horz_y = get_filter_level(cm, &cm->lf_info, 1, 0, mbmi); - const uint8_t level_u = get_filter_level(cm, &cm->lf_info, 0, 1, mbmi); - const uint8_t level_v = get_filter_level(cm, &cm->lf_info, 0, 2, mbmi); - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; r++) { - index = 0; - row = r % MI_SIZE_64X64; - memset(&lfm->lfl_y_ver[row][col_start], level_vert_y, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_y_hor[row][col_start], level_horz_y, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_u[row][col_start], level_u, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_v[row][col_start], level_v, - sizeof(uint8_t) * mi_size_wide[bsize]); - } -} -#endif - -static void parse_decode_block(AV1Decoder *const pbi, ThreadData *const td, - int mi_row, int mi_col, aom_reader *r, - PARTITION_TYPE partition, BLOCK_SIZE bsize) { +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) { MACROBLOCKD *const xd = &td->xd; decode_mbmi_block(pbi, xd, mi_row, mi_col, r, partition, bsize); - av1_visit_palette(pbi, xd, mi_row, mi_col, r, bsize, - av1_decode_palette_tokens); + av1_visit_palette(pbi, xd, r, av1_decode_palette_tokens); AV1_COMMON *cm = &pbi->common; const int num_planes = av1_num_planes(cm); MB_MODE_INFO *mbmi = xd->mi[0]; int inter_block_tx = is_inter_block(mbmi) || is_intrabc_block(mbmi); - if (cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) && + if (cm->features.tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) && !mbmi->skip && inter_block_tx && !xd->lossless[mbmi->segment_id]) { const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize]; const int bh = tx_size_high_unit[max_tx_size]; const int bw = tx_size_wide_unit[max_tx_size]; - const int width = block_size_wide[bsize] >> tx_size_wide_log2[0]; - const int height = block_size_high[bsize] >> tx_size_high_log2[0]; + 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) read_tx_size_vartx(xd, mbmi, max_tx_size, 0, -#if LOOP_FILTER_BITMASK - cm, mi_row, mi_col, +#if CONFIG_LPF_MASK + cm, mi_row, mi_col, 1, #endif idy, idx, r); } else { - mbmi->tx_size = read_tx_size(cm, xd, inter_block_tx, !mbmi->skip, r); + mbmi->tx_size = + read_tx_size(xd, cm->features.tx_mode, inter_block_tx, !mbmi->skip, r); if (inter_block_tx) memset(mbmi->inter_tx_size, mbmi->tx_size, sizeof(mbmi->inter_tx_size)); - set_txfm_ctxs(mbmi->tx_size, xd->n4_w, xd->n4_h, + set_txfm_ctxs(mbmi->tx_size, xd->width, xd->height, mbmi->skip && is_inter_block(mbmi), xd); -#if LOOP_FILTER_BITMASK +#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]) { - store_bitmask_univariant_tx(cm, mi_row, mi_col, bsize, mbmi); + 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]) { - store_bitmask_univariant_tx(cm, mi_row + row, mi_col + col, - BLOCK_64X64, mbmi); + av1_store_bitmask_univariant_tx(cm, mi_row + row, mi_col + col, + BLOCK_64X64, mbmi); } } } #endif } -#if LOOP_FILTER_BITMASK +#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]) { - store_bitmask_other_info(cm, mi_row, mi_col, bsize, mbmi); + 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]) { - store_bitmask_other_info(cm, mi_row + row, mi_col + col, BLOCK_64X64, - mbmi); + av1_store_bitmask_other_info(cm, mi_row + row, mi_col + col, + BLOCK_64X64, mbmi, row == 0, col == 0); } } } #endif - if (cm->delta_q_present_flag) { + if (cm->delta_q_info.delta_q_present_flag) { for (int i = 0; i < MAX_SEGMENTS; i++) { const int current_qindex = av1_get_qindex(&cm->seg, i, xd->current_qindex); + const CommonQuantParams *const quant_params = &cm->quant_params; for (int j = 0; j < num_planes; ++j) { - const int dc_delta_q = - j == 0 ? cm->y_dc_delta_q - : (j == 1 ? cm->u_dc_delta_q : cm->v_dc_delta_q); - const int ac_delta_q = - j == 0 ? 0 : (j == 1 ? cm->u_ac_delta_q : cm->v_ac_delta_q); + 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, cm->seq_params.bit_depth); xd->plane[j].seg_dequant_QTX[i][1] = av1_ac_quant_QTX( @@ -1630,46 +1243,48 @@ static void parse_decode_block(AV1Decoder *const pbi, ThreadData *const td, } } } - if (mbmi->skip) av1_reset_skip_context(xd, mi_row, mi_col, bsize, num_planes); + if (mbmi->skip) av1_reset_entropy_context(xd, bsize, num_planes); - decode_token_recon_block(pbi, td, mi_row, mi_col, r, bsize); - - int reader_corrupted_flag = aom_reader_has_error(r); - aom_merge_corrupted_flag(&xd->corrupted, reader_corrupted_flag); + decode_token_recon_block(pbi, td, r, bsize); } -static void set_offsets_for_pred_and_recon(AV1Decoder *const pbi, - ThreadData *const td, int mi_row, - int mi_col, BLOCK_SIZE bsize) { +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; MACROBLOCKD *const xd = &td->xd; const int bw = mi_size_wide[bsize]; const int bh = mi_size_high[bsize]; const int num_planes = av1_num_planes(cm); - const int offset = mi_row * cm->mi_stride + mi_col; + const int offset = mi_row * mi_params->mi_stride + mi_col; const TileInfo *const tile = &xd->tile; - xd->mi = cm->mi_grid_visible + offset; - xd->cfl.mi_row = mi_row; - xd->cfl.mi_col = mi_col; + 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, cm->mi_rows, cm->mi_cols); + 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, get_frame_new_buffer(cm), mi_row, - mi_col, 0, num_planes); + av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0, + num_planes); } -static void decode_block(AV1Decoder *const pbi, ThreadData *const td, - int mi_row, int mi_col, aom_reader *r, - PARTITION_TYPE partition, BLOCK_SIZE bsize) { +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); - decode_token_recon_block(pbi, td, mi_row, mi_col, r, bsize); + decode_token_recon_block(pbi, td, r, bsize); } static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col, @@ -1702,9 +1317,12 @@ static PARTITION_TYPE read_partition(MACROBLOCKD *xd, int mi_row, int mi_col, } // TODO(slavarnway): eliminate bsize and subsize in future commits -static void decode_partition(AV1Decoder *const pbi, ThreadData *const td, - int mi_row, int mi_col, aom_reader *r, - BLOCK_SIZE bsize, int parse_decode_flag) { +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; MACROBLOCKD *const xd = &td->xd; const int bw = mi_size_wide[bsize]; @@ -1713,18 +1331,19 @@ static void decode_partition(AV1Decoder *const pbi, ThreadData *const td, 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_rows; - const int has_cols = (mi_col + hbs) < cm->mi_cols; + 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_rows || mi_col >= cm->mi_cols) return; + 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 - }; + 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); @@ -1736,20 +1355,24 @@ static void decode_partition(AV1Decoder *const pbi, ThreadData *const td, 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, r, plane, runit_idx); + loop_restoration_read_sb_coeffs(cm, xd, reader, plane, runit_idx); } } } } partition = (bsize < BLOCK_8X8) ? PARTITION_NONE - : read_partition(xd, mi_row, mi_col, r, + : read_partition(xd, mi_row, mi_col, reader, has_rows, has_cols, bsize); } else { partition = get_partition(cm, mi_row, mi_col, bsize); } 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]; @@ -1762,12 +1385,12 @@ static void decode_partition(AV1Decoder *const pbi, ThreadData *const td, #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), r, \ - 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), r, (db_subsize), \ - parse_decode_flag) +#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; @@ -1808,14 +1431,14 @@ static void decode_partition(AV1Decoder *const pbi, ThreadData *const td, case PARTITION_HORZ_4: for (int i = 0; i < 4; ++i) { int this_mi_row = mi_row + i * quarter_step; - if (i > 0 && this_mi_row >= cm->mi_rows) break; + 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_cols) break; + if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break; DEC_BLOCK(mi_row, this_mi_col, subsize); } break; @@ -1831,10 +1454,10 @@ static void decode_partition(AV1Decoder *const pbi, ThreadData *const td, update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition); } -static void setup_bool_decoder(const uint8_t *data, const uint8_t *data_end, - const size_t read_size, - struct aom_internal_error_info *error_info, - aom_reader *r, uint8_t allow_update_cdf) { +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. @@ -1849,8 +1472,8 @@ static void setup_bool_decoder(const uint8_t *data, const uint8_t *data_end, r->allow_update_cdf = allow_update_cdf; } -static void setup_segmentation(AV1_COMMON *const cm, - struct aom_read_bit_buffer *rb) { +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; @@ -1860,21 +1483,22 @@ static void setup_segmentation(AV1_COMMON *const cm, seg->enabled = aom_rb_read_bit(rb); if (!seg->enabled) { if (cm->cur_frame->seg_map) - memset(cm->cur_frame->seg_map, 0, (cm->mi_rows * cm->mi_cols)); + memset(cm->cur_frame->seg_map, 0, + (cm->mi_params.mi_rows * cm->mi_params.mi_cols)); memset(seg, 0, sizeof(*seg)); segfeatures_copy(&cm->cur_frame->seg, seg); return; } if (cm->seg.enabled && cm->prev_frame && - (cm->mi_rows == cm->prev_frame->mi_rows) && - (cm->mi_cols == cm->prev_frame->mi_cols)) { + (cm->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->primary_ref_frame == PRIMARY_REF_NONE) { + 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; @@ -1915,18 +1539,18 @@ static void setup_segmentation(AV1_COMMON *const cm, av1_set_segdata(seg, i, j, data); } } - calculate_segdata(seg); + av1_calculate_segdata(seg); } else if (cm->prev_frame) { segfeatures_copy(seg, &cm->prev_frame->seg); } segfeatures_copy(&cm->cur_frame->seg, seg); } -static void decode_restoration_mode(AV1_COMMON *cm, - struct aom_read_bit_buffer *rb) { - assert(!cm->all_lossless); +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->allow_intrabc) return; + 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]; @@ -1978,8 +1602,10 @@ static void decode_restoration_mode(AV1_COMMON *cm, } } -static void read_wiener_filter(int wiener_win, WienerInfo *wiener_info, - WienerInfo *ref_wiener_info, aom_reader *rb) { +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)); @@ -2037,10 +1663,11 @@ static void read_wiener_filter(int wiener_win, WienerInfo *wiener_info, memcpy(ref_wiener_info, wiener_info, sizeof(*wiener_info)); } -static void read_sgrproj_filter(SgrprojInfo *sgrproj_info, - SgrprojInfo *ref_sgrproj_info, aom_reader *rb) { +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 = &sgr_params[sgrproj_info->ep]; + const sgr_params_type *params = &av1_sgr_params[sgrproj_info->ep]; if (params->r[0] == 0) { sgrproj_info->xqd[0] = 0; @@ -2073,15 +1700,14 @@ static void read_sgrproj_filter(SgrprojInfo *sgrproj_info, memcpy(ref_sgrproj_info, sgrproj_info, sizeof(*sgrproj_info)); } -static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm, - MACROBLOCKD *xd, - aom_reader *const r, int plane, - int runit_idx) { +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]; if (rsi->frame_restoration_type == RESTORE_NONE) return; - assert(!cm->all_lossless); + assert(!cm->features.all_lossless); const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN; WienerInfo *wiener_info = xd->wiener_info + plane; @@ -2117,16 +1743,18 @@ static void loop_restoration_read_sb_coeffs(const AV1_COMMON *const cm, } } -static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { +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->allow_intrabc || cm->coded_lossless) { + + 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->coded_lossless); + 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); @@ -2168,15 +1796,18 @@ static void setup_loopfilter(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { memcpy(cm->cur_frame->mode_deltas, lf->mode_deltas, MAX_MODE_LF_DELTAS); } -static void setup_cdef(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { +static AOM_INLINE void setup_cdef(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb) { const int num_planes = av1_num_planes(cm); - if (cm->allow_intrabc) return; - cm->cdef_pri_damping = cm->cdef_sec_damping = aom_rb_read_literal(rb, 2) + 3; - cm->cdef_bits = aom_rb_read_literal(rb, 2); - cm->nb_cdef_strengths = 1 << cm->cdef_bits; - for (int i = 0; i < cm->nb_cdef_strengths; i++) { - cm->cdef_strengths[i] = aom_rb_read_literal(rb, CDEF_STRENGTH_BITS); - cm->cdef_uv_strengths[i] = + 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; } } @@ -2185,82 +1816,86 @@ 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 void setup_quantization(AV1_COMMON *const cm, - struct aom_read_bit_buffer *rb) { - const SequenceHeader *const seq_params = &cm->seq_params; - const int num_planes = av1_num_planes(cm); - cm->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS); - cm->y_dc_delta_q = read_delta_q(rb); +static AOM_INLINE void setup_quantization(CommonQuantParams *quant_params, + int num_planes, + bool separate_uv_delta_q, + struct aom_read_bit_buffer *rb) { + quant_params->base_qindex = aom_rb_read_literal(rb, QINDEX_BITS); + quant_params->y_dc_delta_q = read_delta_q(rb); if (num_planes > 1) { int diff_uv_delta = 0; - if (seq_params->separate_uv_delta_q) diff_uv_delta = aom_rb_read_bit(rb); - cm->u_dc_delta_q = read_delta_q(rb); - cm->u_ac_delta_q = read_delta_q(rb); + if (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) { - cm->v_dc_delta_q = read_delta_q(rb); - cm->v_ac_delta_q = read_delta_q(rb); + quant_params->v_dc_delta_q = read_delta_q(rb); + quant_params->v_ac_delta_q = read_delta_q(rb); } else { - cm->v_dc_delta_q = cm->u_dc_delta_q; - cm->v_ac_delta_q = cm->u_ac_delta_q; + 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 { - cm->u_dc_delta_q = 0; - cm->u_ac_delta_q = 0; - cm->v_dc_delta_q = 0; - cm->v_ac_delta_q = 0; - } - cm->dequant_bit_depth = seq_params->bit_depth; - cm->using_qmatrix = aom_rb_read_bit(rb); - if (cm->using_qmatrix) { - cm->qm_y = aom_rb_read_literal(rb, QM_LEVEL_BITS); - cm->qm_u = aom_rb_read_literal(rb, QM_LEVEL_BITS); - if (!seq_params->separate_uv_delta_q) - cm->qm_v = cm->qm_u; + 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 - cm->qm_v = aom_rb_read_literal(rb, QM_LEVEL_BITS); + quant_params->qmatrix_level_v = aom_rb_read_literal(rb, QM_LEVEL_BITS); } else { - cm->qm_y = 0; - cm->qm_u = 0; - cm->qm_v = 0; + 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 void setup_segmentation_dequant(AV1_COMMON *const cm) { +static AOM_INLINE void setup_segmentation_dequant(AV1_COMMON *const cm, + MACROBLOCKD *const xd) { const int bit_depth = cm->seq_params.bit_depth; - const int using_qm = cm->using_qmatrix; // 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 = av1_get_qindex(&cm->seg, i, cm->base_qindex); - cm->y_dequant_QTX[i][0] = - av1_dc_quant_QTX(qindex, cm->y_dc_delta_q, bit_depth); - cm->y_dequant_QTX[i][1] = av1_ac_quant_QTX(qindex, 0, bit_depth); - cm->u_dequant_QTX[i][0] = - av1_dc_quant_QTX(qindex, cm->u_dc_delta_q, bit_depth); - cm->u_dequant_QTX[i][1] = - av1_ac_quant_QTX(qindex, cm->u_ac_delta_q, bit_depth); - cm->v_dequant_QTX[i][0] = - av1_dc_quant_QTX(qindex, cm->v_dc_delta_q, bit_depth); - cm->v_dequant_QTX[i][1] = - av1_ac_quant_QTX(qindex, cm->v_ac_delta_q, bit_depth); - const int lossless = qindex == 0 && cm->y_dc_delta_q == 0 && - cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 && - cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0; + const int qindex = xd->qindex[i]; + quant_params->y_dequant_QTX[i][0] = + av1_dc_quant_QTX(qindex, quant_params->y_dc_delta_q, 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, 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, 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 - int qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_y; + const int qmlevel_y = + use_qmatrix ? quant_params->qmatrix_level_y : NUM_QM_LEVELS - 1; for (int j = 0; j < TX_SIZES_ALL; ++j) { - cm->y_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_Y, j); + quant_params->y_iqmatrix[i][j] = + av1_iqmatrix(quant_params, qmlevel_y, AOM_PLANE_Y, j); } - qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_u; + const int qmlevel_u = + use_qmatrix ? quant_params->qmatrix_level_u : NUM_QM_LEVELS - 1; for (int j = 0; j < TX_SIZES_ALL; ++j) { - cm->u_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_U, j); + quant_params->u_iqmatrix[i][j] = + av1_iqmatrix(quant_params, qmlevel_u, AOM_PLANE_U, j); } - qmlevel = (lossless || using_qm == 0) ? NUM_QM_LEVELS - 1 : cm->qm_v; + const int qmlevel_v = + use_qmatrix ? quant_params->qmatrix_level_v : NUM_QM_LEVELS - 1; for (int j = 0; j < TX_SIZES_ALL; ++j) { - cm->v_iqmatrix[i][j] = av1_iqmatrix(cm, qmlevel, AOM_PLANE_V, j); + quant_params->v_iqmatrix[i][j] = + av1_iqmatrix(quant_params, qmlevel_v, AOM_PLANE_V, j); } } } @@ -2270,7 +1905,8 @@ static InterpFilter read_frame_interp_filter(struct aom_read_bit_buffer *rb) { : aom_rb_read_literal(rb, LOG_SWITCHABLE_FILTERS); } -static void setup_render_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { +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)) @@ -2278,8 +1914,9 @@ static void setup_render_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { } // TODO(afergs): make "struct aom_read_bit_buffer *const rb"? -static void setup_superres(AV1_COMMON *const cm, struct aom_read_bit_buffer *rb, - int *width, int *height) { +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; @@ -2300,7 +1937,8 @@ static void setup_superres(AV1_COMMON *const cm, struct aom_read_bit_buffer *rb, } } -static void resize_context_buffers(AV1_COMMON *cm, int width, int height) { +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, @@ -2315,7 +1953,8 @@ static void resize_context_buffers(AV1_COMMON *cm, int width, int height) { // Allocations in av1_alloc_context_buffers() depend on individual // dimensions as well as the overall size. - if (new_mi_cols > cm->mi_cols || new_mi_rows > cm->mi_rows) { + 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 @@ -2326,9 +1965,9 @@ static void resize_context_buffers(AV1_COMMON *cm, int width, int height) { "Failed to allocate context buffers"); } } else { - av1_set_mb_mi(cm, width, height); + cm->mi_params.set_mb_mi(&cm->mi_params, width, height); } - av1_init_context_buffers(cm); + av1_init_mi_buffers(&cm->mi_params); cm->width = width; cm->height = height; } @@ -2338,46 +1977,38 @@ static void resize_context_buffers(AV1_COMMON *cm, int width, int height) { cm->cur_frame->height = cm->height; } -static void setup_buffer_pool(AV1_COMMON *cm) { +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( - get_frame_new_buffer(cm), cm->width, cm->height, - seq_params->subsampling_x, seq_params->subsampling_y, - seq_params->use_highbitdepth, AOM_BORDER_IN_PIXELS, - cm->byte_alignment, - &pool->frame_bufs[cm->new_fb_idx].raw_frame_buffer, pool->get_fb_cb, - pool->cb_priv)) { + &cm->cur_frame->buf, cm->width, cm->height, seq_params->subsampling_x, + seq_params->subsampling_y, seq_params->use_highbitdepth, + AOM_DEC_BORDER_IN_PIXELS, cm->features.byte_alignment, + &cm->cur_frame->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { unlock_buffer_pool(pool); aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate frame buffer"); } unlock_buffer_pool(pool); - pool->frame_bufs[cm->new_fb_idx].buf.subsampling_x = - seq_params->subsampling_x; - pool->frame_bufs[cm->new_fb_idx].buf.subsampling_y = - seq_params->subsampling_y; - pool->frame_bufs[cm->new_fb_idx].buf.bit_depth = - (unsigned int)seq_params->bit_depth; - pool->frame_bufs[cm->new_fb_idx].buf.color_primaries = - seq_params->color_primaries; - pool->frame_bufs[cm->new_fb_idx].buf.transfer_characteristics = + cm->cur_frame->buf.bit_depth = (unsigned int)seq_params->bit_depth; + cm->cur_frame->buf.color_primaries = seq_params->color_primaries; + cm->cur_frame->buf.transfer_characteristics = seq_params->transfer_characteristics; - pool->frame_bufs[cm->new_fb_idx].buf.matrix_coefficients = - seq_params->matrix_coefficients; - pool->frame_bufs[cm->new_fb_idx].buf.monochrome = seq_params->monochrome; - pool->frame_bufs[cm->new_fb_idx].buf.chroma_sample_position = + cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients; + cm->cur_frame->buf.monochrome = seq_params->monochrome; + cm->cur_frame->buf.chroma_sample_position = seq_params->chroma_sample_position; - pool->frame_bufs[cm->new_fb_idx].buf.color_range = seq_params->color_range; - pool->frame_bufs[cm->new_fb_idx].buf.render_width = cm->render_width; - pool->frame_bufs[cm->new_fb_idx].buf.render_height = cm->render_height; + cm->cur_frame->buf.color_range = seq_params->color_range; + cm->cur_frame->buf.render_width = cm->render_width; + cm->cur_frame->buf.render_height = cm->render_height; } -static void setup_frame_size(AV1_COMMON *cm, int frame_size_override_flag, - struct aom_read_bit_buffer *rb) { +static AOM_INLINE void setup_frame_size(AV1_COMMON *cm, + int frame_size_override_flag, + struct aom_read_bit_buffer *rb) { const SequenceHeader *const seq_params = &cm->seq_params; int width, height; @@ -2401,8 +2032,8 @@ static void setup_frame_size(AV1_COMMON *cm, int frame_size_override_flag, setup_buffer_pool(cm); } -static void setup_sb_size(SequenceHeader *seq_params, - struct aom_read_bit_buffer *rb) { +static AOM_INLINE void setup_sb_size(SequenceHeader *seq_params, + struct aom_read_bit_buffer *rb) { set_sb_size(seq_params, aom_rb_read_bit(rb) ? BLOCK_128X128 : BLOCK_64X64); } @@ -2414,22 +2045,33 @@ static INLINE int valid_ref_frame_img_fmt(aom_bit_depth_t ref_bit_depth, ref_yss == this_yss; } -static void setup_frame_size_with_refs(AV1_COMMON *cm, - struct aom_read_bit_buffer *rb) { +static AOM_INLINE void setup_frame_size_with_refs( + AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { int width, height; int found = 0; int has_valid_ref_frame = 0; - for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { + for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { if (aom_rb_read_bit(rb)) { - YV12_BUFFER_CONFIG *const buf = cm->frame_refs[i].buf; - width = buf->y_crop_width; - height = buf->y_crop_height; - cm->render_width = buf->render_width; - cm->render_height = buf->render_height; - setup_superres(cm, rb, &width, &height); - resize_context_buffers(cm, width, height); - found = 1; - break; + const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, i); + // This will never be NULL in a normal stream, as streams are required to + // have a shown keyframe before any inter frames, which would refresh all + // the reference buffers. However, it might be null if we're starting in + // the middle of a stream, and static analysis will error if we don't do + // a null check here. + if (ref_buf == NULL) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Invalid condition: invalid reference buffer"); + } else { + const YV12_BUFFER_CONFIG *const buf = &ref_buf->buf; + width = buf->y_crop_width; + height = buf->y_crop_height; + cm->render_width = buf->render_width; + cm->render_height = buf->render_height; + setup_superres(cm, rb, &width, &height); + resize_context_buffers(cm, width, height); + found = 1; + break; + } } } @@ -2450,20 +2092,20 @@ static void setup_frame_size_with_refs(AV1_COMMON *cm, // Check to make sure at least one of frames that this frame references // has valid dimensions. - for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { - RefBuffer *const ref_frame = &cm->frame_refs[i]; + for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { + const RefCntBuffer *const ref_frame = get_ref_frame_buf(cm, i); has_valid_ref_frame |= - valid_ref_frame_size(ref_frame->buf->y_crop_width, - ref_frame->buf->y_crop_height, width, height); + valid_ref_frame_size(ref_frame->buf.y_crop_width, + ref_frame->buf.y_crop_height, width, height); } if (!has_valid_ref_frame) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Referenced frame has invalid size"); - for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { - RefBuffer *const ref_frame = &cm->frame_refs[i]; + for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { + const RefCntBuffer *const ref_frame = get_ref_frame_buf(cm, i); if (!valid_ref_frame_img_fmt( - ref_frame->buf->bit_depth, ref_frame->buf->subsampling_x, - ref_frame->buf->subsampling_y, seq_params->bit_depth, + ref_frame->buf.bit_depth, ref_frame->buf.subsampling_x, + ref_frame->buf.subsampling_y, seq_params->bit_depth, seq_params->subsampling_x, seq_params->subsampling_y)) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Referenced frame has incompatible color format"); @@ -2483,96 +2125,104 @@ static int rb_read_uniform(struct aom_read_bit_buffer *const rb, int n) { return (v << 1) - m + aom_rb_read_bit(rb); } -static void read_tile_info_max_tile(AV1_COMMON *const cm, - struct aom_read_bit_buffer *const rb) { - int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2); - int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2); - int width_sb = width_mi >> cm->seq_params.mib_size_log2; - int height_sb = height_mi >> cm->seq_params.mib_size_log2; +static AOM_INLINE void read_tile_info_max_tile( + AV1_COMMON *const cm, struct aom_read_bit_buffer *const rb) { + const SequenceHeader *const seq_params = &cm->seq_params; + CommonTileParams *const tiles = &cm->tiles; + int width_mi = + ALIGN_POWER_OF_TWO(cm->mi_params.mi_cols, seq_params->mib_size_log2); + int height_mi = + ALIGN_POWER_OF_TWO(cm->mi_params.mi_rows, seq_params->mib_size_log2); + int width_sb = width_mi >> seq_params->mib_size_log2; + int height_sb = height_mi >> seq_params->mib_size_log2; av1_get_tile_limits(cm); - cm->uniform_tile_spacing_flag = aom_rb_read_bit(rb); + tiles->uniform_spacing = aom_rb_read_bit(rb); // Read tile columns - if (cm->uniform_tile_spacing_flag) { - cm->log2_tile_cols = cm->min_log2_tile_cols; - while (cm->log2_tile_cols < cm->max_log2_tile_cols) { + if (tiles->uniform_spacing) { + tiles->log2_cols = tiles->min_log2_cols; + while (tiles->log2_cols < tiles->max_log2_cols) { if (!aom_rb_read_bit(rb)) { break; } - cm->log2_tile_cols++; + tiles->log2_cols++; } } else { int i; int start_sb; for (i = 0, start_sb = 0; width_sb > 0 && i < MAX_TILE_COLS; i++) { const int size_sb = - 1 + rb_read_uniform(rb, AOMMIN(width_sb, cm->max_tile_width_sb)); - cm->tile_col_start_sb[i] = start_sb; + 1 + rb_read_uniform(rb, AOMMIN(width_sb, tiles->max_width_sb)); + tiles->col_start_sb[i] = start_sb; start_sb += size_sb; width_sb -= size_sb; } - cm->tile_cols = i; - cm->tile_col_start_sb[i] = start_sb + width_sb; + tiles->cols = i; + tiles->col_start_sb[i] = start_sb + width_sb; } - av1_calculate_tile_cols(cm); + av1_calculate_tile_cols(seq_params, cm->mi_params.mi_rows, + cm->mi_params.mi_cols, tiles); // Read tile rows - if (cm->uniform_tile_spacing_flag) { - cm->log2_tile_rows = cm->min_log2_tile_rows; - while (cm->log2_tile_rows < cm->max_log2_tile_rows) { + if (tiles->uniform_spacing) { + tiles->log2_rows = tiles->min_log2_rows; + while (tiles->log2_rows < tiles->max_log2_rows) { if (!aom_rb_read_bit(rb)) { break; } - cm->log2_tile_rows++; + tiles->log2_rows++; } } else { int i; int start_sb; for (i = 0, start_sb = 0; height_sb > 0 && i < MAX_TILE_ROWS; i++) { const int size_sb = - 1 + rb_read_uniform(rb, AOMMIN(height_sb, cm->max_tile_height_sb)); - cm->tile_row_start_sb[i] = start_sb; + 1 + rb_read_uniform(rb, AOMMIN(height_sb, tiles->max_height_sb)); + tiles->row_start_sb[i] = start_sb; start_sb += size_sb; height_sb -= size_sb; } - cm->tile_rows = i; - cm->tile_row_start_sb[i] = start_sb + height_sb; + tiles->rows = i; + tiles->row_start_sb[i] = start_sb + height_sb; } - av1_calculate_tile_rows(cm); + av1_calculate_tile_rows(seq_params, cm->mi_params.mi_rows, tiles); } void av1_set_single_tile_decoding_mode(AV1_COMMON *const cm) { - cm->single_tile_decoding = 0; - if (cm->large_scale_tile) { + cm->tiles.single_tile_decoding = 0; + if (cm->tiles.large_scale) { struct loopfilter *lf = &cm->lf; + RestorationInfo *const rst_info = cm->rst_info; + const CdefInfo *const cdef_info = &cm->cdef_info; // Figure out single_tile_decoding by loopfilter_level. const int no_loopfilter = !(lf->filter_level[0] || lf->filter_level[1]); - const int no_cdef = cm->cdef_bits == 0 && cm->cdef_strengths[0] == 0 && - cm->cdef_uv_strengths[0] == 0; + const int no_cdef = cdef_info->cdef_bits == 0 && + cdef_info->cdef_strengths[0] == 0 && + cdef_info->cdef_uv_strengths[0] == 0; const int no_restoration = - cm->rst_info[0].frame_restoration_type == RESTORE_NONE && - cm->rst_info[1].frame_restoration_type == RESTORE_NONE && - cm->rst_info[2].frame_restoration_type == RESTORE_NONE; - assert(IMPLIES(cm->coded_lossless, no_loopfilter && no_cdef)); - assert(IMPLIES(cm->all_lossless, no_restoration)); - cm->single_tile_decoding = no_loopfilter && no_cdef && no_restoration; + rst_info[0].frame_restoration_type == RESTORE_NONE && + rst_info[1].frame_restoration_type == RESTORE_NONE && + rst_info[2].frame_restoration_type == RESTORE_NONE; + assert(IMPLIES(cm->features.coded_lossless, no_loopfilter && no_cdef)); + assert(IMPLIES(cm->features.all_lossless, no_restoration)); + cm->tiles.single_tile_decoding = no_loopfilter && no_cdef && no_restoration; } } -static void read_tile_info(AV1Decoder *const pbi, - struct aom_read_bit_buffer *const rb) { +static AOM_INLINE void read_tile_info(AV1Decoder *const pbi, + struct aom_read_bit_buffer *const rb) { AV1_COMMON *const cm = &pbi->common; read_tile_info_max_tile(cm, rb); - cm->context_update_tile_id = 0; - if (cm->tile_rows * cm->tile_cols > 1) { + pbi->context_update_tile_id = 0; + if (cm->tiles.rows * cm->tiles.cols > 1) { // tile to use for cdf update - cm->context_update_tile_id = - aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); - if (cm->context_update_tile_id >= cm->tile_rows * cm->tile_cols) { + pbi->context_update_tile_id = + aom_rb_read_literal(rb, cm->tiles.log2_rows + cm->tiles.log2_cols); + if (pbi->context_update_tile_id >= cm->tiles.rows * cm->tiles.cols) { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Invalid context_update_tile_id"); } @@ -2582,8 +2232,8 @@ static void read_tile_info(AV1Decoder *const pbi, } #if EXT_TILE_DEBUG -static void read_ext_tile_info(AV1Decoder *const pbi, - struct aom_read_bit_buffer *const rb) { +static AOM_INLINE void read_ext_tile_info( + AV1Decoder *const pbi, struct aom_read_bit_buffer *const rb) { AV1_COMMON *const cm = &pbi->common; // This information is stored as a separate byte. @@ -2591,7 +2241,7 @@ static void read_ext_tile_info(AV1Decoder *const pbi, if (mod > 0) aom_rb_read_literal(rb, CHAR_BIT - mod); assert(rb->bit_offset % CHAR_BIT == 0); - if (cm->tile_cols * cm->tile_rows > 1) { + if (cm->tiles.cols * cm->tiles.rows > 1) { // Read the number of bytes used to store tile size pbi->tile_col_size_bytes = aom_rb_read_literal(rb, 2) + 1; pbi->tile_size_bytes = aom_rb_read_literal(rb, 2) + 1; @@ -2613,7 +2263,7 @@ static size_t mem_get_varsize(const uint8_t *src, int sz) { // Reads the next tile returning its size and adjusting '*data' accordingly // based on 'is_last'. On return, '*data' is updated to point to the end of the // raw tile buffer in the bit stream. -static void get_ls_tile_buffer( +static AOM_INLINE void get_ls_tile_buffer( const uint8_t *const data_end, struct aom_internal_error_info *error_info, const uint8_t **data, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], int tile_size_bytes, int col, int row, int tile_copy_mode) { @@ -2659,13 +2309,13 @@ static void get_ls_tile_buffer( } // Returns the end of the last tile buffer -// (tile_buffers[cm->tile_rows - 1][cm->tile_cols - 1]). +// (tile_buffers[cm->tiles.rows - 1][cm->tiles.cols - 1]). static const uint8_t *get_ls_tile_buffers( AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, TileBufferDec (*const tile_buffers)[MAX_TILE_COLS]) { AV1_COMMON *const cm = &pbi->common; - const int tile_cols = cm->tile_cols; - const int tile_rows = cm->tile_rows; + const int tile_cols = cm->tiles.cols; + const int tile_rows = cm->tiles.rows; const int have_tiles = tile_cols * tile_rows > 1; const uint8_t *raw_data_end; // The end of the last tile buffer @@ -2694,9 +2344,10 @@ static const uint8_t *get_ls_tile_buffers( const int tile_col_size_bytes = pbi->tile_col_size_bytes; const int tile_size_bytes = pbi->tile_size_bytes; + int tile_width, tile_height; + av1_get_uniform_tile_size(cm, &tile_width, &tile_height); const int tile_copy_mode = - ((AOMMAX(cm->tile_width, cm->tile_height) << MI_SIZE_LOG2) <= 256) ? 1 - : 0; + ((AOMMAX(tile_width, tile_height) << MI_SIZE_LOG2) <= 256) ? 1 : 0; // Read tile column sizes for all columns (we need the last tile buffer) for (int c = 0; c < tile_cols; ++c) { const int is_last = c == tile_cols - 1; @@ -2759,16 +2410,16 @@ static const uint8_t *get_ls_single_tile_buffer( // Reads the next tile returning its size and adjusting '*data' accordingly // based on 'is_last'. -static void get_tile_buffer(const uint8_t *const data_end, - const int tile_size_bytes, int is_last, - struct aom_internal_error_info *error_info, - const uint8_t **data, TileBufferDec *const buf) { +static AOM_INLINE void get_tile_buffer( + const uint8_t *const data_end, const int tile_size_bytes, int is_last, + struct aom_internal_error_info *error_info, const uint8_t **data, + TileBufferDec *const buf) { size_t size; if (!is_last) { if (!read_is_valid(*data, tile_size_bytes, data_end)) aom_internal_error(error_info, AOM_CODEC_CORRUPT_FRAME, - "Truncated packet or corrupt tile length"); + "Not enough data to read tile size"); size = mem_get_varsize(*data, tile_size_bytes) + AV1_MIN_TILE_SIZE_BYTES; *data += tile_size_bytes; @@ -2786,15 +2437,14 @@ static void get_tile_buffer(const uint8_t *const data_end, *data += size; } -static void get_tile_buffers(AV1Decoder *pbi, const uint8_t *data, - const uint8_t *data_end, - TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], - int start_tile, int end_tile) { +static AOM_INLINE void get_tile_buffers( + AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, + TileBufferDec (*const tile_buffers)[MAX_TILE_COLS], int start_tile, + int end_tile) { AV1_COMMON *const cm = &pbi->common; - const int tile_cols = cm->tile_cols; - const int tile_rows = cm->tile_rows; + const int tile_cols = cm->tiles.cols; + const int tile_rows = cm->tiles.rows; int tc = 0; - int first_tile_in_tg = 0; for (int r = 0; r < tile_rows; ++r) { for (int c = 0; c < tile_cols; ++c, ++tc) { @@ -2808,7 +2458,6 @@ static void get_tile_buffers(AV1Decoder *pbi, const uint8_t *data, if (data + hdr_offset >= data_end) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Data ended before all tiles were read."); - first_tile_in_tg += tc == first_tile_in_tg ? pbi->tg_size : 0; data += hdr_offset; get_tile_buffer(data_end, pbi->tile_size_bytes, is_last, &pbi->common.error, &data, buf); @@ -2816,12 +2465,13 @@ static void get_tile_buffers(AV1Decoder *pbi, const uint8_t *data, } } -static void set_cb_buffer(AV1Decoder *pbi, MACROBLOCKD *const xd, - CB_BUFFER *cb_buffer_base, const int num_planes, - int mi_row, int mi_col) { +static AOM_INLINE void set_cb_buffer(AV1Decoder *pbi, MACROBLOCKD *const xd, + CB_BUFFER *cb_buffer_base, + const int num_planes, int mi_row, + int mi_col) { AV1_COMMON *const cm = &pbi->common; int mib_size_log2 = cm->seq_params.mib_size_log2; - int stride = (cm->mi_cols >> mib_size_log2) + 1; + int stride = (cm->mi_params.mi_cols >> mib_size_log2) + 1; int offset = (mi_row >> mib_size_log2) * stride + (mi_col >> mib_size_log2); CB_BUFFER *cb_buffer = cb_buffer_base + offset; @@ -2837,7 +2487,8 @@ static void set_cb_buffer(AV1Decoder *pbi, MACROBLOCKD *const xd, xd->color_index_map_offset[1] = 0; } -static void decoder_alloc_tile_data(AV1Decoder *pbi, const int n_tiles) { +static AOM_INLINE void decoder_alloc_tile_data(AV1Decoder *pbi, + const int n_tiles) { AV1_COMMON *const cm = &pbi->common; aom_free(pbi->tile_data); CHECK_MEM_ERROR(cm, pbi->tile_data, @@ -2869,8 +2520,8 @@ static INLINE int get_sync_range(int width) { } // Allocate memory for decoder row synchronization -static void dec_row_mt_alloc(AV1DecRowMTSync *dec_row_mt_sync, AV1_COMMON *cm, - int rows) { +static AOM_INLINE void dec_row_mt_alloc(AV1DecRowMTSync *dec_row_mt_sync, + AV1_COMMON *cm, int rows) { dec_row_mt_sync->allocated_sb_rows = rows; #if CONFIG_MULTITHREAD { @@ -2978,12 +2629,13 @@ static INLINE void sync_write(AV1DecRowMTSync *const dec_row_mt_sync, int r, #endif // CONFIG_MULTITHREAD } -static void decode_tile_sb_row(AV1Decoder *pbi, ThreadData *const td, - TileInfo tile_info, const int mi_row) { +static AOM_INLINE void decode_tile_sb_row(AV1Decoder *pbi, ThreadData *const td, + TileInfo tile_info, + const int mi_row) { AV1_COMMON *const cm = &pbi->common; const int num_planes = av1_num_planes(cm); TileDataDec *const tile_data = - pbi->tile_data + tile_info.tile_row * cm->tile_cols + tile_info.tile_col; + pbi->tile_data + tile_info.tile_row * cm->tiles.cols + tile_info.tile_col; const int sb_cols_in_tile = av1_get_sb_cols_in_tile(cm, tile_info); const int sb_row_in_tile = (mi_row - tile_info.mi_row_start) >> cm->seq_params.mib_size_log2; @@ -3028,7 +2680,8 @@ static int check_trailing_bits_after_symbol_coder(aom_reader *r) { return 0; } -static void set_decode_func_pointers(ThreadData *td, int parse_decode_flag) { +static AOM_INLINE void set_decode_func_pointers(ThreadData *td, + int parse_decode_flag) { td->read_coeffs_tx_intra_block_visit = decode_block_void; td->predict_and_recon_intra_block_visit = decode_block_void; td->read_coeffs_tx_inter_block_visit = decode_block_void; @@ -3049,8 +2702,8 @@ static void set_decode_func_pointers(ThreadData *td, int parse_decode_flag) { } } -static void decode_tile(AV1Decoder *pbi, ThreadData *const td, int tile_row, - int tile_col) { +static AOM_INLINE void decode_tile(AV1Decoder *pbi, ThreadData *const td, + int tile_row, int tile_col) { TileInfo tile_info; AV1_COMMON *const cm = &pbi->common; @@ -3092,8 +2745,9 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, int end_tile) { AV1_COMMON *const cm = &pbi->common; ThreadData *const td = &pbi->td; - const int tile_cols = cm->tile_cols; - const int tile_rows = cm->tile_rows; + CommonTileParams *const tiles = &cm->tiles; + const int tile_cols = tiles->cols; + const int tile_rows = tiles->rows; const int n_tiles = tile_cols * tile_rows; TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers; const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows); @@ -3110,7 +2764,7 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, uint8_t allow_update_cdf; const uint8_t *raw_data_end = NULL; - if (cm->large_scale_tile) { + if (tiles->large_scale) { tile_rows_start = single_row ? dec_tile_row : 0; tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows; tile_cols_start = single_col ? dec_tile_col : 0; @@ -3131,20 +2785,20 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, // No tiles to decode. if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start || // First tile is larger than end_tile. - tile_rows_start * cm->tile_cols + tile_cols_start > end_tile || + tile_rows_start * tiles->cols + tile_cols_start > end_tile || // Last tile is smaller than start_tile. - (tile_rows_end - 1) * cm->tile_cols + tile_cols_end - 1 < start_tile) + (tile_rows_end - 1) * tiles->cols + tile_cols_end - 1 < start_tile) return data; - allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update; + allow_update_cdf = allow_update_cdf && !cm->features.disable_cdf_update; assert(tile_rows <= MAX_TILE_ROWS); assert(tile_cols <= MAX_TILE_COLS); #if EXT_TILE_DEBUG - if (cm->large_scale_tile && !pbi->ext_tile_debug) + if (tiles->large_scale && !pbi->ext_tile_debug) raw_data_end = get_ls_single_tile_buffer(pbi, data, tile_buffers); - else if (cm->large_scale_tile && pbi->ext_tile_debug) + else if (tiles->large_scale && pbi->ext_tile_debug) raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers); else #endif // EXT_TILE_DEBUG @@ -3176,17 +2830,17 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, for (tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) { const int col = inv_col_order ? tile_cols - 1 - tile_col : tile_col; - TileDataDec *const tile_data = pbi->tile_data + row * cm->tile_cols + col; + TileDataDec *const tile_data = pbi->tile_data + row * tiles->cols + col; const TileBufferDec *const tile_bs_buf = &tile_buffers[row][col]; - if (row * cm->tile_cols + col < start_tile || - row * cm->tile_cols + col > end_tile) + if (row * tiles->cols + col < start_tile || + row * tiles->cols + col > end_tile) continue; td->bit_reader = &tile_data->bit_reader; - av1_zero(td->dqcoeff); + av1_zero(td->cb_buffer_base.dqcoeff); av1_tile_init(&td->xd.tile, cm, row, col); - td->xd.current_qindex = cm->base_qindex; + td->xd.current_qindex = cm->quant_params.base_qindex; setup_bool_decoder(tile_bs_buf->data, data_end, tile_bs_buf->size, &cm->error, td->bit_reader, allow_update_cdf); #if CONFIG_ACCOUNTING @@ -3198,8 +2852,9 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, td->bit_reader->accounting = NULL; } #endif - av1_init_macroblockd(cm, &td->xd, td->dqcoeff); - av1_init_above_context(cm, &td->xd, row); + av1_init_macroblockd(cm, &td->xd, NULL); + av1_init_above_context(&cm->above_contexts, av1_num_planes(cm), row, + &td->xd); // Initialise the tile context from the frame context tile_data->tctx = *cm->fc; @@ -3214,7 +2869,7 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data, } } - if (cm->large_scale_tile) { + if (tiles->large_scale) { if (n_tiles == 1) { // Find the end of the single tile buffer return aom_reader_find_end(&pbi->tile_data->bit_reader); @@ -3244,20 +2899,19 @@ static TileJobsDec *get_dec_job_info(AV1DecTileMT *tile_mt_info) { return cur_job_info; } -static void tile_worker_hook_init(AV1Decoder *const pbi, - DecWorkerData *const thread_data, - const TileBufferDec *const tile_buffer, - TileDataDec *const tile_data, - uint8_t allow_update_cdf) { +static AOM_INLINE void tile_worker_hook_init( + AV1Decoder *const pbi, DecWorkerData *const thread_data, + const TileBufferDec *const tile_buffer, TileDataDec *const tile_data, + uint8_t allow_update_cdf) { AV1_COMMON *cm = &pbi->common; ThreadData *const td = thread_data->td; int tile_row = tile_data->tile_info.tile_row; int tile_col = tile_data->tile_info.tile_col; td->bit_reader = &tile_data->bit_reader; - av1_zero(td->dqcoeff); + av1_zero(td->cb_buffer_base.dqcoeff); av1_tile_init(&td->xd.tile, cm, tile_row, tile_col); - td->xd.current_qindex = cm->base_qindex; + td->xd.current_qindex = cm->quant_params.base_qindex; setup_bool_decoder(tile_buffer->data, thread_data->data_end, tile_buffer->size, &thread_data->error_info, td->bit_reader, allow_update_cdf); @@ -3270,9 +2924,10 @@ static void tile_worker_hook_init(AV1Decoder *const pbi, td->bit_reader->accounting = NULL; } #endif - av1_init_macroblockd(cm, &td->xd, td->dqcoeff); + av1_init_macroblockd(cm, &td->xd, NULL); td->xd.error_info = &thread_data->error_info; - av1_init_above_context(cm, &td->xd, tile_row); + av1_init_above_context(&cm->above_contexts, av1_num_planes(cm), tile_row, + &td->xd); // Initialise the tile context from the frame context tile_data->tctx = *cm->fc; @@ -3302,16 +2957,16 @@ static int tile_worker_hook(void *arg1, void *arg2) { } thread_data->error_info.setjmp = 1; - allow_update_cdf = cm->large_scale_tile ? 0 : 1; - allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update; + allow_update_cdf = cm->tiles.large_scale ? 0 : 1; + allow_update_cdf = allow_update_cdf && !cm->features.disable_cdf_update; set_decode_func_pointers(td, 0x3); - assert(cm->tile_cols > 0); - while (1) { + assert(cm->tiles.cols > 0); + while (!td->xd.corrupted) { TileJobsDec *cur_job_info = get_dec_job_info(&pbi->tile_mt_info); - if (cur_job_info != NULL && !td->xd.corrupted) { + if (cur_job_info != NULL) { const TileBufferDec *const tile_buffer = cur_job_info->tile_buffer; TileDataDec *const tile_data = cur_job_info->tile_data; tile_worker_hook_init(pbi, thread_data, tile_buffer, tile_data, @@ -3328,6 +2983,30 @@ static int tile_worker_hook(void *arg1, void *arg2) { return !td->xd.corrupted; } +static INLINE int get_max_row_mt_workers_per_tile(AV1_COMMON *cm, + TileInfo tile) { + // NOTE: Currently value of max workers is calculated based + // on the parse and decode time. As per the theoretical estimate + // when percentage of parse time is equal to percentage of decode + // time, number of workers needed to parse + decode a tile can not + // exceed more than 2. + // TODO(any): Modify this value if parsing is optimized in future. + int sb_rows = av1_get_sb_rows_in_tile(cm, tile); + int max_workers = + sb_rows == 1 ? AOM_MIN_THREADS_PER_TILE : AOM_MAX_THREADS_PER_TILE; + return max_workers; +} + +// The caller must hold pbi->row_mt_mutex_ when calling this function. +// Returns 1 if either the next job is stored in *next_job_info or 1 is stored +// in *end_of_frame. +// NOTE: The caller waits on pbi->row_mt_cond_ if this function returns 0. +// The return value of this function depends on the following variables: +// - frame_row_mt_info->mi_rows_parse_done +// - frame_row_mt_info->mi_rows_decode_started +// - frame_row_mt_info->row_mt_exit +// Therefore we may need to signal or broadcast pbi->row_mt_cond_ if any of +// these variables is modified. static int get_next_job_info(AV1Decoder *const pbi, AV1DecRowMTJobInfo *next_job_info, int *end_of_frame) { @@ -3348,8 +3027,8 @@ static int get_next_job_info(AV1Decoder *const pbi, int min_threads_working = INT_MAX; int max_mis_to_decode = 0; int tile_row_idx, tile_col_idx; - int tile_row = 0; - int tile_col = 0; + int tile_row = -1; + int tile_col = -1; memset(next_job_info, 0, sizeof(*next_job_info)); @@ -3362,9 +3041,10 @@ static int get_next_job_info(AV1Decoder *const pbi, } // Decoding cannot start as bit-stream parsing is not complete. - if (frame_row_mt_info->mi_rows_parse_done - - frame_row_mt_info->mi_rows_decode_started == - 0) + assert(frame_row_mt_info->mi_rows_parse_done >= + frame_row_mt_info->mi_rows_decode_started); + if (frame_row_mt_info->mi_rows_parse_done == + frame_row_mt_info->mi_rows_decode_started) return 0; // Choose the tile to decode. @@ -3372,11 +3052,11 @@ static int get_next_job_info(AV1Decoder *const pbi, ++tile_row_idx) { for (tile_col_idx = tile_cols_start; tile_col_idx < tile_cols_end; ++tile_col_idx) { - if (tile_row_idx * cm->tile_cols + tile_col_idx < start_tile || - tile_row_idx * cm->tile_cols + tile_col_idx > end_tile) + if (tile_row_idx * cm->tiles.cols + tile_col_idx < start_tile || + tile_row_idx * cm->tiles.cols + tile_col_idx > end_tile) continue; - tile_data = pbi->tile_data + tile_row_idx * cm->tile_cols + tile_col_idx; + tile_data = pbi->tile_data + tile_row_idx * cm->tiles.cols + tile_col_idx; dec_row_mt_sync = &tile_data->dec_row_mt_sync; num_threads_working = dec_row_mt_sync->num_threads_working; @@ -3396,7 +3076,9 @@ static int get_next_job_info(AV1Decoder *const pbi, max_mis_to_decode = 0; } if (num_threads_working == min_threads_working && - num_mis_to_decode > max_mis_to_decode) { + num_mis_to_decode > max_mis_to_decode && + num_threads_working < + get_max_row_mt_workers_per_tile(cm, tile_data->tile_info)) { max_mis_to_decode = num_mis_to_decode; tile_row = tile_row_idx; tile_col = tile_col_idx; @@ -3404,8 +3086,10 @@ static int get_next_job_info(AV1Decoder *const pbi, } } } + // No job found to process + if (tile_row == -1 || tile_col == -1) return 0; - tile_data = pbi->tile_data + tile_row * cm->tile_cols + tile_col; + tile_data = pbi->tile_data + tile_row * cm->tiles.cols + tile_col; tile_info = tile_data->tile_info; dec_row_mt_sync = &tile_data->dec_row_mt_sync; @@ -3417,6 +3101,14 @@ static int get_next_job_info(AV1Decoder *const pbi, dec_row_mt_sync->num_threads_working++; dec_row_mt_sync->mi_rows_decode_started += sb_mi_size; frame_row_mt_info->mi_rows_decode_started += sb_mi_size; + assert(frame_row_mt_info->mi_rows_parse_done >= + frame_row_mt_info->mi_rows_decode_started); +#if CONFIG_MULTITHREAD + if (frame_row_mt_info->mi_rows_decode_started == + frame_row_mt_info->mi_rows_to_decode) { + pthread_cond_broadcast(pbi->row_mt_cond_); + } +#endif return 1; } @@ -3428,21 +3120,67 @@ static INLINE void signal_parse_sb_row_done(AV1Decoder *const pbi, #if CONFIG_MULTITHREAD pthread_mutex_lock(pbi->row_mt_mutex_); #endif + assert(frame_row_mt_info->mi_rows_parse_done >= + frame_row_mt_info->mi_rows_decode_started); tile_data->dec_row_mt_sync.mi_rows_parse_done += sb_mi_size; frame_row_mt_info->mi_rows_parse_done += sb_mi_size; #if CONFIG_MULTITHREAD - pthread_cond_broadcast(pbi->row_mt_cond_); + // A new decode job is available. Wake up one worker thread to handle the + // new decode job. + // NOTE: This assumes we bump mi_rows_parse_done and mi_rows_decode_started + // by the same increment (sb_mi_size). + pthread_cond_signal(pbi->row_mt_cond_); pthread_mutex_unlock(pbi->row_mt_mutex_); #endif } +// This function is very similar to decode_tile(). It would be good to figure +// out how to share code. +static AOM_INLINE void parse_tile_row_mt(AV1Decoder *pbi, ThreadData *const td, + TileDataDec *const tile_data) { + AV1_COMMON *const cm = &pbi->common; + const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size]; + const int num_planes = av1_num_planes(cm); + TileInfo tile_info = tile_data->tile_info; + int tile_row = tile_info.tile_row; + + av1_zero_above_context(cm, &td->xd, tile_info.mi_col_start, + tile_info.mi_col_end, tile_row); + av1_reset_loop_filter_delta(&td->xd, num_planes); + av1_reset_loop_restoration(&td->xd, num_planes); + + for (int mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end; + mi_row += cm->seq_params.mib_size) { + av1_zero_left_context(&td->xd); + + for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end; + mi_col += cm->seq_params.mib_size) { + set_cb_buffer(pbi, &td->xd, pbi->cb_buffer_base, num_planes, mi_row, + mi_col); + + // Bit-stream parsing of the superblock + decode_partition(pbi, td, mi_row, mi_col, td->bit_reader, + cm->seq_params.sb_size, 0x1); + + if (aom_reader_has_overflowed(td->bit_reader)) { + aom_merge_corrupted_flag(&td->xd.corrupted, 1); + return; + } + } + signal_parse_sb_row_done(pbi, tile_data, sb_mi_size); + } + + int corrupted = + (check_trailing_bits_after_symbol_coder(td->bit_reader)) ? 1 : 0; + aom_merge_corrupted_flag(&td->xd.corrupted, corrupted); +} + static int row_mt_worker_hook(void *arg1, void *arg2) { DecWorkerData *const thread_data = (DecWorkerData *)arg1; AV1Decoder *const pbi = (AV1Decoder *)arg2; AV1_COMMON *cm = &pbi->common; ThreadData *const td = thread_data->td; uint8_t allow_update_cdf; - const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size]; AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info; td->xd.corrupted = 0; @@ -3464,55 +3202,54 @@ static int row_mt_worker_hook(void *arg1, void *arg2) { } thread_data->error_info.setjmp = 1; - const int num_planes = av1_num_planes(cm); - allow_update_cdf = cm->large_scale_tile ? 0 : 1; - allow_update_cdf = allow_update_cdf && !cm->disable_cdf_update; + allow_update_cdf = cm->tiles.large_scale ? 0 : 1; + allow_update_cdf = allow_update_cdf && !cm->features.disable_cdf_update; - assert(cm->tile_cols > 0); - while (1) { + set_decode_func_pointers(td, 0x1); + + assert(cm->tiles.cols > 0); + while (!td->xd.corrupted) { TileJobsDec *cur_job_info = get_dec_job_info(&pbi->tile_mt_info); - if (cur_job_info != NULL && !td->xd.corrupted) { + if (cur_job_info != NULL) { const TileBufferDec *const tile_buffer = cur_job_info->tile_buffer; TileDataDec *const tile_data = cur_job_info->tile_data; tile_worker_hook_init(pbi, thread_data, tile_buffer, tile_data, allow_update_cdf); - - set_decode_func_pointers(td, 0x1); - +#if CONFIG_MULTITHREAD + pthread_mutex_lock(pbi->row_mt_mutex_); +#endif + tile_data->dec_row_mt_sync.num_threads_working++; +#if CONFIG_MULTITHREAD + pthread_mutex_unlock(pbi->row_mt_mutex_); +#endif // decode tile - TileInfo tile_info = tile_data->tile_info; - int tile_row = tile_info.tile_row; - - av1_zero_above_context(cm, &td->xd, tile_info.mi_col_start, - tile_info.mi_col_end, tile_row); - av1_reset_loop_filter_delta(&td->xd, num_planes); - av1_reset_loop_restoration(&td->xd, num_planes); - - for (int mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end; - mi_row += cm->seq_params.mib_size) { - av1_zero_left_context(&td->xd); - - for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end; - mi_col += cm->seq_params.mib_size) { - set_cb_buffer(pbi, &td->xd, pbi->cb_buffer_base, num_planes, mi_row, - mi_col); - - // Bit-stream parsing of the superblock - decode_partition(pbi, td, mi_row, mi_col, td->bit_reader, - cm->seq_params.sb_size, 0x1); - } - signal_parse_sb_row_done(pbi, tile_data, sb_mi_size); - } - - int corrupted = - (check_trailing_bits_after_symbol_coder(td->bit_reader)) ? 1 : 0; - aom_merge_corrupted_flag(&td->xd.corrupted, corrupted); + parse_tile_row_mt(pbi, td, tile_data); +#if CONFIG_MULTITHREAD + pthread_mutex_lock(pbi->row_mt_mutex_); +#endif + tile_data->dec_row_mt_sync.num_threads_working--; +#if CONFIG_MULTITHREAD + pthread_mutex_unlock(pbi->row_mt_mutex_); +#endif } else { break; } } + if (td->xd.corrupted) { + thread_data->error_info.setjmp = 0; +#if CONFIG_MULTITHREAD + pthread_mutex_lock(pbi->row_mt_mutex_); +#endif + frame_row_mt_info->row_mt_exit = 1; +#if CONFIG_MULTITHREAD + pthread_cond_broadcast(pbi->row_mt_cond_); + pthread_mutex_unlock(pbi->row_mt_mutex_); +#endif + return 0; + } + set_decode_func_pointers(td, 0x2); while (1) { @@ -3538,12 +3275,12 @@ static int row_mt_worker_hook(void *arg1, void *arg2) { int mi_row = next_job_info.mi_row; TileDataDec *tile_data = - pbi->tile_data + tile_row * cm->tile_cols + tile_col; + pbi->tile_data + tile_row * cm->tiles.cols + tile_col; AV1DecRowMTSync *dec_row_mt_sync = &tile_data->dec_row_mt_sync; TileInfo tile_info = tile_data->tile_info; av1_tile_init(&td->xd.tile, cm, tile_row, tile_col); - av1_init_macroblockd(cm, &td->xd, td->dqcoeff); + av1_init_macroblockd(cm, &td->xd, NULL); td->xd.error_info = &thread_data->error_info; decode_tile_sb_row(pbi, td, tile_info, mi_row); @@ -3567,10 +3304,10 @@ static int compare_tile_buffers(const void *a, const void *b) { return (((int)buf2->tile_buffer->size) - ((int)buf1->tile_buffer->size)); } -static void enqueue_tile_jobs(AV1Decoder *pbi, AV1_COMMON *cm, - int tile_rows_start, int tile_rows_end, - int tile_cols_start, int tile_cols_end, - int startTile, int endTile) { +static AOM_INLINE void enqueue_tile_jobs(AV1Decoder *pbi, AV1_COMMON *cm, + int tile_rows_start, int tile_rows_end, + int tile_cols_start, int tile_cols_end, + int start_tile, int end_tile) { AV1DecTileMT *tile_mt_info = &pbi->tile_mt_info; TileJobsDec *tile_job_queue = tile_mt_info->job_queue; tile_mt_info->jobs_enqueued = 0; @@ -3578,19 +3315,20 @@ static void enqueue_tile_jobs(AV1Decoder *pbi, AV1_COMMON *cm, for (int row = tile_rows_start; row < tile_rows_end; row++) { for (int col = tile_cols_start; col < tile_cols_end; col++) { - if (row * cm->tile_cols + col < startTile || - row * cm->tile_cols + col > endTile) + if (row * cm->tiles.cols + col < start_tile || + row * cm->tiles.cols + col > end_tile) continue; tile_job_queue->tile_buffer = &pbi->tile_buffers[row][col]; - tile_job_queue->tile_data = pbi->tile_data + row * cm->tile_cols + col; + tile_job_queue->tile_data = pbi->tile_data + row * cm->tiles.cols + col; tile_job_queue++; tile_mt_info->jobs_enqueued++; } } } -static void alloc_dec_jobs(AV1DecTileMT *tile_mt_info, AV1_COMMON *cm, - int tile_rows, int tile_cols) { +static AOM_INLINE void alloc_dec_jobs(AV1DecTileMT *tile_mt_info, + AV1_COMMON *cm, int tile_rows, + int tile_cols) { tile_mt_info->alloc_tile_rows = tile_rows; tile_mt_info->alloc_tile_cols = tile_cols; int num_tiles = tile_rows * tile_cols; @@ -3628,8 +3366,9 @@ void av1_free_mc_tmp_buf(ThreadData *thread_data) { } } -static void allocate_mc_tmp_buf(AV1_COMMON *const cm, ThreadData *thread_data, - int buf_size, int use_highbd) { +static AOM_INLINE void allocate_mc_tmp_buf(AV1_COMMON *const cm, + ThreadData *thread_data, + int buf_size, int use_highbd) { for (int ref = 0; ref < 2; ref++) { if (use_highbd) { uint16_t *hbd_mc_buf; @@ -3654,8 +3393,9 @@ static void allocate_mc_tmp_buf(AV1_COMMON *const cm, ThreadData *thread_data, } } -static void reset_dec_workers(AV1Decoder *pbi, AVxWorkerHook worker_hook, - int num_workers) { +static AOM_INLINE void reset_dec_workers(AV1Decoder *pbi, + AVxWorkerHook worker_hook, + int num_workers) { const AVxWorkerInterface *const winterface = aom_get_worker_interface(); // Reset tile decoding hook @@ -3683,8 +3423,9 @@ static void reset_dec_workers(AV1Decoder *pbi, AVxWorkerHook worker_hook, #endif } -static void launch_dec_workers(AV1Decoder *pbi, const uint8_t *data_end, - int num_workers) { +static AOM_INLINE void launch_dec_workers(AV1Decoder *pbi, + const uint8_t *data_end, + int num_workers) { const AVxWorkerInterface *const winterface = aom_get_worker_interface(); for (int worker_idx = 0; worker_idx < num_workers; ++worker_idx) { @@ -3702,7 +3443,7 @@ static void launch_dec_workers(AV1Decoder *pbi, const uint8_t *data_end, } } -static void sync_dec_workers(AV1Decoder *pbi, int num_workers) { +static AOM_INLINE void sync_dec_workers(AV1Decoder *pbi, int num_workers) { const AVxWorkerInterface *const winterface = aom_get_worker_interface(); int corrupted = 0; @@ -3714,7 +3455,7 @@ static void sync_dec_workers(AV1Decoder *pbi, int num_workers) { pbi->mb.corrupted = corrupted; } -static void decode_mt_init(AV1Decoder *pbi) { +static AOM_INLINE void decode_mt_init(AV1Decoder *pbi) { AV1_COMMON *const cm = &pbi->common; const AVxWorkerInterface *const winterface = aom_get_worker_interface(); int worker_idx; @@ -3733,6 +3474,7 @@ static void decode_mt_init(AV1Decoder *pbi) { ++pbi->num_workers; winterface->init(worker); + worker->thread_name = "aom tile worker"; if (worker_idx < num_threads - 1 && !winterface->reset(worker)) { aom_internal_error(&cm->error, AOM_CODEC_ERROR, "Tile decoder thread creation failed"); @@ -3751,7 +3493,7 @@ static void decode_mt_init(AV1Decoder *pbi) { thread_data->error_info.setjmp = 0; } } - const int use_highbd = cm->seq_params.use_highbitdepth ? 1 : 0; + const int use_highbd = cm->seq_params.use_highbitdepth; const int buf_size = MC_TEMP_BUF_PELS << use_highbd; for (worker_idx = 0; worker_idx < pbi->max_threads - 1; ++worker_idx) { DecWorkerData *const thread_data = pbi->thread_data + worker_idx; @@ -3762,10 +3504,11 @@ static void decode_mt_init(AV1Decoder *pbi) { } } -static void tile_mt_queue(AV1Decoder *pbi, int tile_cols, int tile_rows, - int tile_rows_start, int tile_rows_end, - int tile_cols_start, int tile_cols_end, - int start_tile, int end_tile) { +static AOM_INLINE void tile_mt_queue(AV1Decoder *pbi, int tile_cols, + int tile_rows, int tile_rows_start, + int tile_rows_end, int tile_cols_start, + int tile_cols_end, int start_tile, + int end_tile) { AV1_COMMON *const cm = &pbi->common; if (pbi->tile_mt_info.alloc_tile_cols != tile_cols || pbi->tile_mt_info.alloc_tile_rows != tile_rows) { @@ -3782,8 +3525,9 @@ static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, int start_tile, int end_tile) { AV1_COMMON *const cm = &pbi->common; - const int tile_cols = cm->tile_cols; - const int tile_rows = cm->tile_rows; + CommonTileParams *const tiles = &cm->tiles; + const int tile_cols = tiles->cols; + const int tile_rows = tiles->rows; const int n_tiles = tile_cols * tile_rows; TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers; const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows); @@ -3798,7 +3542,7 @@ static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data, int num_workers; const uint8_t *raw_data_end = NULL; - if (cm->large_scale_tile) { + if (tiles->large_scale) { tile_rows_start = single_row ? dec_tile_row : 0; tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows; tile_cols_start = single_col ? dec_tile_col : 0; @@ -3831,8 +3575,8 @@ static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data, // get tile size in tile group #if EXT_TILE_DEBUG - if (cm->large_scale_tile) assert(pbi->ext_tile_debug == 1); - if (cm->large_scale_tile) + if (tiles->large_scale) assert(pbi->ext_tile_debug == 1); + if (tiles->large_scale) raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers); else #endif // EXT_TILE_DEBUG @@ -3844,7 +3588,7 @@ static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data, for (int row = 0; row < tile_rows; row++) { for (int col = 0; col < tile_cols; col++) { - TileDataDec *tile_data = pbi->tile_data + row * cm->tile_cols + col; + TileDataDec *tile_data = pbi->tile_data + row * tiles->cols + col; av1_tile_init(&tile_data->tile_info, cm, row, col); } } @@ -3860,7 +3604,7 @@ static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data, aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Failed to decode tile data"); - if (cm->large_scale_tile) { + if (tiles->large_scale) { if (n_tiles == 1) { // Find the end of the single tile buffer return aom_reader_find_end(&pbi->tile_data->bit_reader); @@ -3873,23 +3617,24 @@ static const uint8_t *decode_tiles_mt(AV1Decoder *pbi, const uint8_t *data, return aom_reader_find_end(&tile_data->bit_reader); } -static void dec_alloc_cb_buf(AV1Decoder *pbi) { +static AOM_INLINE void dec_alloc_cb_buf(AV1Decoder *pbi) { AV1_COMMON *const cm = &pbi->common; - int size = ((cm->mi_rows >> cm->seq_params.mib_size_log2) + 1) * - ((cm->mi_cols >> cm->seq_params.mib_size_log2) + 1); + int size = ((cm->mi_params.mi_rows >> cm->seq_params.mib_size_log2) + 1) * + ((cm->mi_params.mi_cols >> cm->seq_params.mib_size_log2) + 1); if (pbi->cb_buffer_alloc_size < size) { av1_dec_free_cb_buf(pbi); CHECK_MEM_ERROR(cm, pbi->cb_buffer_base, aom_memalign(32, sizeof(*pbi->cb_buffer_base) * size)); + memset(pbi->cb_buffer_base, 0, sizeof(*pbi->cb_buffer_base) * size); pbi->cb_buffer_alloc_size = size; } } -static void row_mt_frame_init(AV1Decoder *pbi, int tile_rows_start, - int tile_rows_end, int tile_cols_start, - int tile_cols_end, int start_tile, int end_tile, - int max_sb_rows) { +static AOM_INLINE void row_mt_frame_init(AV1Decoder *pbi, int tile_rows_start, + int tile_rows_end, int tile_cols_start, + int tile_cols_end, int start_tile, + int end_tile, int max_sb_rows) { AV1_COMMON *const cm = &pbi->common; AV1DecRowMTInfo *frame_row_mt_info = &pbi->frame_row_mt_info; @@ -3906,12 +3651,12 @@ static void row_mt_frame_init(AV1Decoder *pbi, int tile_rows_start, for (int tile_row = tile_rows_start; tile_row < tile_rows_end; ++tile_row) { for (int tile_col = tile_cols_start; tile_col < tile_cols_end; ++tile_col) { - if (tile_row * cm->tile_cols + tile_col < start_tile || - tile_row * cm->tile_cols + tile_col > end_tile) + if (tile_row * cm->tiles.cols + tile_col < start_tile || + tile_row * cm->tiles.cols + tile_col > end_tile) continue; TileDataDec *const tile_data = - pbi->tile_data + tile_row * cm->tile_cols + tile_col; + pbi->tile_data + tile_row * cm->tiles.cols + tile_col; TileInfo tile_info = tile_data->tile_info; tile_data->dec_row_mt_sync.mi_rows_parse_done = 0; @@ -3956,8 +3701,9 @@ static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, int start_tile, int end_tile) { AV1_COMMON *const cm = &pbi->common; - const int tile_cols = cm->tile_cols; - const int tile_rows = cm->tile_rows; + CommonTileParams *const tiles = &cm->tiles; + const int tile_cols = tiles->cols; + const int tile_rows = tiles->rows; const int n_tiles = tile_cols * tile_rows; TileBufferDec(*const tile_buffers)[MAX_TILE_COLS] = pbi->tile_buffers; const int dec_tile_row = AOMMIN(pbi->dec_tile_row, tile_rows); @@ -3969,11 +3715,12 @@ static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data, int tile_cols_start; int tile_cols_end; int tile_count_tg; - int num_workers; + int num_workers = 0; + int max_threads; const uint8_t *raw_data_end = NULL; int max_sb_rows = 0; - if (cm->large_scale_tile) { + if (tiles->large_scale) { tile_rows_start = single_row ? dec_tile_row : 0; tile_rows_end = single_row ? dec_tile_row + 1 : tile_rows; tile_cols_start = single_col ? dec_tile_col : 0; @@ -3985,7 +3732,7 @@ static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data, tile_cols_end = tile_cols; } tile_count_tg = end_tile - start_tile + 1; - num_workers = pbi->max_threads; + max_threads = pbi->max_threads; // No tiles to decode. if (tile_rows_end <= tile_rows_start || tile_cols_end <= tile_cols_start || @@ -3998,7 +3745,7 @@ static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data, assert(tile_rows <= MAX_TILE_ROWS); assert(tile_cols <= MAX_TILE_COLS); assert(tile_count_tg > 0); - assert(num_workers > 0); + assert(max_threads > 0); assert(start_tile <= end_tile); assert(start_tile >= 0 && end_tile < n_tiles); @@ -4008,30 +3755,34 @@ static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data, // get tile size in tile group #if EXT_TILE_DEBUG - if (cm->large_scale_tile) assert(pbi->ext_tile_debug == 1); - if (cm->large_scale_tile) + if (tiles->large_scale) assert(pbi->ext_tile_debug == 1); + if (tiles->large_scale) raw_data_end = get_ls_tile_buffers(pbi, data, data_end, tile_buffers); else #endif // EXT_TILE_DEBUG get_tile_buffers(pbi, data, data_end, tile_buffers, start_tile, end_tile); if (pbi->tile_data == NULL || n_tiles != pbi->allocated_tiles) { - for (int i = 0; i < pbi->allocated_tiles; i++) { - TileDataDec *const tile_data = pbi->tile_data + i; - av1_dec_row_mt_dealloc(&tile_data->dec_row_mt_sync); + if (pbi->tile_data != NULL) { + for (int i = 0; i < pbi->allocated_tiles; i++) { + TileDataDec *const tile_data = pbi->tile_data + i; + av1_dec_row_mt_dealloc(&tile_data->dec_row_mt_sync); + } } decoder_alloc_tile_data(pbi, n_tiles); } for (int row = 0; row < tile_rows; row++) { for (int col = 0; col < tile_cols; col++) { - TileDataDec *tile_data = pbi->tile_data + row * cm->tile_cols + col; + TileDataDec *tile_data = pbi->tile_data + row * tiles->cols + col; av1_tile_init(&tile_data->tile_info, cm, row, col); max_sb_rows = AOMMAX(max_sb_rows, av1_get_sb_rows_in_tile(cm, tile_data->tile_info)); + num_workers += get_max_row_mt_workers_per_tile(cm, tile_data->tile_info); } } + num_workers = AOMMIN(num_workers, max_threads); if (pbi->allocated_row_mt_sync_rows != max_sb_rows) { for (int i = 0; i < n_tiles; ++i) { @@ -4058,7 +3809,7 @@ static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data, aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Failed to decode tile data"); - if (cm->large_scale_tile) { + if (tiles->large_scale) { if (n_tiles == 1) { // Find the end of the single tile buffer return aom_reader_find_end(&pbi->tile_data->bit_reader); @@ -4071,7 +3822,7 @@ static const uint8_t *decode_tiles_row_mt(AV1Decoder *pbi, const uint8_t *data, return aom_reader_find_end(&tile_data->bit_reader); } -static void error_handler(void *data) { +static AOM_INLINE void error_handler(void *data) { AV1_COMMON *const cm = (AV1_COMMON *)data; aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Truncated packet"); } @@ -4080,9 +3831,9 @@ static void error_handler(void *data) { // seq_params->bit_depth based on the values of those fields and // seq_params->profile. Reports errors by calling rb->error_handler() or // aom_internal_error(). -static void read_bitdepth(struct aom_read_bit_buffer *rb, - SequenceHeader *seq_params, - struct aom_internal_error_info *error_info) { +static AOM_INLINE void read_bitdepth( + struct aom_read_bit_buffer *rb, SequenceHeader *seq_params, + struct aom_internal_error_info *error_info) { const int high_bitdepth = aom_rb_read_bit(rb); if (seq_params->profile == PROFILE_2 && high_bitdepth) { const int twelve_bit = aom_rb_read_bit(rb); @@ -4093,6 +3844,12 @@ static void read_bitdepth(struct aom_read_bit_buffer *rb, aom_internal_error(error_info, AOM_CODEC_UNSUP_BITSTREAM, "Unsupported profile/bit-depth combination"); } +#if !CONFIG_AV1_HIGHBITDEPTH + if (seq_params->bit_depth > AOM_BITS_8) { + aom_internal_error(error_info, AOM_CODEC_UNSUP_BITSTREAM, + "Bit-depth %d not supported", seq_params->bit_depth); + } +#endif } void av1_read_film_grain_params(AV1_COMMON *cm, @@ -4107,7 +3864,7 @@ void av1_read_film_grain_params(AV1_COMMON *cm, } pars->random_seed = aom_rb_read_literal(rb, 16); - if (cm->frame_type == INTER_FRAME) + if (cm->current_frame.frame_type == INTER_FRAME) pars->update_parameters = aom_rb_read_bit(rb); else pars->update_parameters = 1; @@ -4116,20 +3873,38 @@ void av1_read_film_grain_params(AV1_COMMON *cm, if (!pars->update_parameters) { // inherit parameters from a previous reference frame - RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; int film_grain_params_ref_idx = aom_rb_read_literal(rb, 3); - int buf_idx = cm->ref_frame_map[film_grain_params_ref_idx]; - if (buf_idx == INVALID_IDX) { + // Section 6.8.20: It is a requirement of bitstream conformance that + // film_grain_params_ref_idx is equal to ref_frame_idx[ j ] for some value + // of j in the range 0 to REFS_PER_FRAME - 1. + int found = 0; + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { + if (film_grain_params_ref_idx == cm->remapped_ref_idx[i]) { + found = 1; + break; + } + } + if (!found) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Invalid film grain reference idx %d. ref_frame_idx = " + "{%d, %d, %d, %d, %d, %d, %d}", + film_grain_params_ref_idx, cm->remapped_ref_idx[0], + cm->remapped_ref_idx[1], cm->remapped_ref_idx[2], + cm->remapped_ref_idx[3], cm->remapped_ref_idx[4], + cm->remapped_ref_idx[5], cm->remapped_ref_idx[6]); + } + RefCntBuffer *const buf = cm->ref_frame_map[film_grain_params_ref_idx]; + if (buf == NULL) { aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, "Invalid Film grain reference idx"); } - if (!frame_bufs[buf_idx].film_grain_params_present) { + if (!buf->film_grain_params_present) { aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, "Film grain reference parameters not available"); } uint16_t random_seed = pars->random_seed; - *pars = frame_bufs[buf_idx].film_grain_params; // inherit paramaters - pars->random_seed = random_seed; // with new random seed + *pars = buf->film_grain_params; // inherit paramaters + pars->random_seed = random_seed; // with new random seed return; } @@ -4242,7 +4017,8 @@ void av1_read_film_grain_params(AV1_COMMON *cm, pars->clip_to_restricted_range = aom_rb_read_bit(rb); } -static void read_film_grain(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { +static AOM_INLINE void read_film_grain(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb) { if (cm->seq_params.film_grain_params_present && (cm->show_frame || cm->showable_frame)) { av1_read_film_grain_params(cm, rb); @@ -4286,7 +4062,6 @@ void av1_read_color_config(struct aom_read_bit_buffer *rb, if (seq_params->color_primaries == AOM_CICP_CP_BT_709 && seq_params->transfer_characteristics == AOM_CICP_TC_SRGB && seq_params->matrix_coefficients == AOM_CICP_MC_IDENTITY) { - // It would be good to remove this dependency. seq_params->subsampling_y = seq_params->subsampling_x = 0; seq_params->color_range = 1; // assume full color-range if (!(seq_params->profile == PROFILE_1 || @@ -4332,64 +4107,59 @@ void av1_read_color_config(struct aom_read_bit_buffer *rb, seq_params->separate_uv_delta_q = aom_rb_read_bit(rb); } -void av1_read_timing_info_header(AV1_COMMON *cm, +void av1_read_timing_info_header(aom_timing_info_t *timing_info, + struct aom_internal_error_info *error, struct aom_read_bit_buffer *rb) { - cm->timing_info.num_units_in_display_tick = aom_rb_read_unsigned_literal( - rb, 32); // Number of units in a display tick - cm->timing_info.time_scale = - aom_rb_read_unsigned_literal(rb, 32); // Time scale - if (cm->timing_info.num_units_in_display_tick == 0 || - cm->timing_info.time_scale == 0) { + timing_info->num_units_in_display_tick = + aom_rb_read_unsigned_literal(rb, + 32); // Number of units in a display tick + timing_info->time_scale = aom_rb_read_unsigned_literal(rb, 32); // Time scale + if (timing_info->num_units_in_display_tick == 0 || + timing_info->time_scale == 0) { aom_internal_error( - &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + error, AOM_CODEC_UNSUP_BITSTREAM, "num_units_in_display_tick and time_scale must be greater than 0."); } - cm->timing_info.equal_picture_interval = + timing_info->equal_picture_interval = aom_rb_read_bit(rb); // Equal picture interval bit - if (cm->timing_info.equal_picture_interval) { - cm->timing_info.num_ticks_per_picture = - aom_rb_read_uvlc(rb) + 1; // ticks per picture - if (cm->timing_info.num_ticks_per_picture == 0) { + if (timing_info->equal_picture_interval) { + const uint32_t num_ticks_per_picture_minus_1 = aom_rb_read_uvlc(rb); + if (num_ticks_per_picture_minus_1 == UINT32_MAX) { aom_internal_error( - &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + error, AOM_CODEC_UNSUP_BITSTREAM, "num_ticks_per_picture_minus_1 cannot be (1 << 32) − 1."); } + timing_info->num_ticks_per_picture = num_ticks_per_picture_minus_1 + 1; } } -void av1_read_decoder_model_info(AV1_COMMON *cm, +void av1_read_decoder_model_info(aom_dec_model_info_t *decoder_model_info, struct aom_read_bit_buffer *rb) { - cm->buffer_model.encoder_decoder_buffer_delay_length = + decoder_model_info->encoder_decoder_buffer_delay_length = + aom_rb_read_literal(rb, 5) + 1; + decoder_model_info->num_units_in_decoding_tick = + aom_rb_read_unsigned_literal(rb, + 32); // Number of units in a decoding tick + decoder_model_info->buffer_removal_time_length = aom_rb_read_literal(rb, 5) + 1; - cm->buffer_model.num_units_in_decoding_tick = aom_rb_read_unsigned_literal( - rb, 32); // Number of units in a decoding tick - cm->buffer_model.buffer_removal_time_length = aom_rb_read_literal(rb, 5) + 1; - cm->buffer_model.frame_presentation_time_length = + decoder_model_info->frame_presentation_time_length = aom_rb_read_literal(rb, 5) + 1; } -void av1_read_op_parameters_info(AV1_COMMON *const cm, - struct aom_read_bit_buffer *rb, int op_num) { - // The cm->op_params array has MAX_NUM_OPERATING_POINTS + 1 elements. - if (op_num > MAX_NUM_OPERATING_POINTS) { - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "AV1 does not support %d decoder model operating points", - op_num + 1); - } - - cm->op_params[op_num].decoder_buffer_delay = aom_rb_read_unsigned_literal( - rb, cm->buffer_model.encoder_decoder_buffer_delay_length); - - cm->op_params[op_num].encoder_buffer_delay = aom_rb_read_unsigned_literal( - rb, cm->buffer_model.encoder_decoder_buffer_delay_length); - - cm->op_params[op_num].low_delay_mode_flag = aom_rb_read_bit(rb); +void av1_read_op_parameters_info(aom_dec_model_op_parameters_t *op_params, + int buffer_delay_length, + struct aom_read_bit_buffer *rb) { + op_params->decoder_buffer_delay = + aom_rb_read_unsigned_literal(rb, buffer_delay_length); + op_params->encoder_buffer_delay = + aom_rb_read_unsigned_literal(rb, buffer_delay_length); + op_params->low_delay_mode_flag = aom_rb_read_bit(rb); } -static void av1_read_temporal_point_info(AV1_COMMON *const cm, - struct aom_read_bit_buffer *rb) { +static AOM_INLINE void read_temporal_point_info( + AV1_COMMON *const cm, struct aom_read_bit_buffer *rb) { cm->frame_presentation_time = aom_rb_read_unsigned_literal( - rb, cm->buffer_model.frame_presentation_time_length); + rb, cm->seq_params.decoder_model_info.frame_presentation_time_length); } void av1_read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb, @@ -4431,23 +4201,23 @@ void av1_read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb, seq_params->enable_masked_compound = 0; seq_params->enable_warped_motion = 0; seq_params->enable_dual_filter = 0; - seq_params->enable_order_hint = 0; - seq_params->enable_jnt_comp = 0; - seq_params->enable_ref_frame_mvs = 0; + seq_params->order_hint_info.enable_order_hint = 0; + seq_params->order_hint_info.enable_dist_wtd_comp = 0; + seq_params->order_hint_info.enable_ref_frame_mvs = 0; seq_params->force_screen_content_tools = 2; // SELECT_SCREEN_CONTENT_TOOLS seq_params->force_integer_mv = 2; // SELECT_INTEGER_MV - seq_params->order_hint_bits_minus_1 = -1; + seq_params->order_hint_info.order_hint_bits_minus_1 = -1; } else { seq_params->enable_interintra_compound = aom_rb_read_bit(rb); seq_params->enable_masked_compound = aom_rb_read_bit(rb); seq_params->enable_warped_motion = aom_rb_read_bit(rb); seq_params->enable_dual_filter = aom_rb_read_bit(rb); - seq_params->enable_order_hint = aom_rb_read_bit(rb); - seq_params->enable_jnt_comp = - seq_params->enable_order_hint ? aom_rb_read_bit(rb) : 0; - seq_params->enable_ref_frame_mvs = - seq_params->enable_order_hint ? aom_rb_read_bit(rb) : 0; + seq_params->order_hint_info.enable_order_hint = aom_rb_read_bit(rb); + seq_params->order_hint_info.enable_dist_wtd_comp = + seq_params->order_hint_info.enable_order_hint ? aom_rb_read_bit(rb) : 0; + seq_params->order_hint_info.enable_ref_frame_mvs = + seq_params->order_hint_info.enable_order_hint ? aom_rb_read_bit(rb) : 0; if (aom_rb_read_bit(rb)) { seq_params->force_screen_content_tools = @@ -4465,8 +4235,10 @@ void av1_read_sequence_header(AV1_COMMON *cm, struct aom_read_bit_buffer *rb, } else { seq_params->force_integer_mv = 2; // SELECT_INTEGER_MV } - seq_params->order_hint_bits_minus_1 = - seq_params->enable_order_hint ? aom_rb_read_literal(rb, 3) : -1; + seq_params->order_hint_info.order_hint_bits_minus_1 = + seq_params->order_hint_info.enable_order_hint + ? aom_rb_read_literal(rb, 3) + : -1; } seq_params->enable_superres = aom_rb_read_bit(rb); @@ -4539,20 +4311,22 @@ static int read_global_motion_params(WarpedMotionParams *params, } if (params->wmtype <= AFFINE) { - int good_shear_params = get_shear_params(params); + int good_shear_params = av1_get_shear_params(params); if (!good_shear_params) return 0; } return 1; } -static void read_global_motion(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { +static AOM_INLINE void read_global_motion(AV1_COMMON *cm, + struct aom_read_bit_buffer *rb) { for (int frame = LAST_FRAME; frame <= ALTREF_FRAME; ++frame) { const WarpedMotionParams *ref_params = cm->prev_frame ? &cm->prev_frame->global_motion[frame] : &default_warp_params; - int good_params = read_global_motion_params( - &cm->global_motion[frame], ref_params, rb, cm->allow_high_precision_mv); + int good_params = + read_global_motion_params(&cm->global_motion[frame], ref_params, rb, + cm->features.allow_high_precision_mv); if (!good_params) { #if WARPED_MOTION_DEBUG printf("Warning: unexpected global motion shear params from aomenc\n"); @@ -4569,14 +4343,14 @@ static void read_global_motion(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { cm->height == ref_buf->y_crop_height) { read_global_motion_params(&cm->global_motion[frame], &cm->prev_frame->global_motion[frame], rb, - cm->allow_high_precision_mv); + cm->features.allow_high_precision_mv); } else { cm->global_motion[frame] = default_warp_params; } */ /* printf("Dec Ref %d [%d/%d]: %d %d %d %d\n", - frame, cm->current_video_frame, cm->show_frame, + frame, cm->current_frame.frame_number, cm->show_frame, cm->global_motion[frame].wmmat[0], cm->global_motion[frame].wmmat[1], cm->global_motion[frame].wmmat[2], @@ -4587,96 +4361,72 @@ static void read_global_motion(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) { REF_FRAMES * sizeof(WarpedMotionParams)); } -static void show_existing_frame_reset(AV1Decoder *const pbi, - int existing_frame_idx) { - AV1_COMMON *const cm = &pbi->common; +// Release the references to the frame buffers in cm->ref_frame_map and reset +// all elements of cm->ref_frame_map to NULL. +static AOM_INLINE void reset_ref_frame_map(AV1_COMMON *const cm) { BufferPool *const pool = cm->buffer_pool; - RefCntBuffer *const frame_bufs = pool->frame_bufs; + + for (int i = 0; i < REF_FRAMES; i++) { + decrease_ref_count(cm->ref_frame_map[i], pool); + cm->ref_frame_map[i] = NULL; + } +} + +// If the refresh_frame_flags bitmask is set, update reference frame id values +// and mark frames as valid for reference. +static AOM_INLINE void update_ref_frame_id(AV1Decoder *const pbi) { + AV1_COMMON *const cm = &pbi->common; + int refresh_frame_flags = cm->current_frame.refresh_frame_flags; + for (int i = 0; i < REF_FRAMES; i++) { + if ((refresh_frame_flags >> i) & 1) { + cm->ref_frame_id[i] = cm->current_frame_id; + pbi->valid_for_referencing[i] = 1; + } + } +} + +static AOM_INLINE void show_existing_frame_reset(AV1Decoder *const pbi, + int existing_frame_idx) { + AV1_COMMON *const cm = &pbi->common; assert(cm->show_existing_frame); - cm->frame_type = KEY_FRAME; + cm->current_frame.frame_type = KEY_FRAME; - pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1; + cm->current_frame.refresh_frame_flags = (1 << REF_FRAMES) - 1; for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { - cm->frame_refs[i].idx = INVALID_IDX; - cm->frame_refs[i].buf = NULL; + cm->remapped_ref_idx[i] = INVALID_IDX; } if (pbi->need_resync) { - memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); + reset_ref_frame_map(cm); pbi->need_resync = 0; } - cm->cur_frame->intra_only = 1; + // Note that the displayed frame must be valid for referencing in order to + // have been selected. + cm->current_frame_id = cm->ref_frame_id[existing_frame_idx]; + update_ref_frame_id(pbi); - if (cm->seq_params.frame_id_numbers_present_flag) { - /* If bitmask is set, update reference frame id values and - mark frames as valid for reference. - Note that the displayed frame be valid for referencing - in order to have been selected. - */ - int refresh_frame_flags = pbi->refresh_frame_flags; - int display_frame_id = cm->ref_frame_id[existing_frame_idx]; - for (int i = 0; i < REF_FRAMES; i++) { - if ((refresh_frame_flags >> i) & 1) { - cm->ref_frame_id[i] = display_frame_id; - cm->valid_for_referencing[i] = 1; - } - } - } - - cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; - - // Generate next_ref_frame_map. - lock_buffer_pool(pool); - int ref_index = 0; - for (int mask = pbi->refresh_frame_flags; mask; mask >>= 1) { - if (mask & 1) { - cm->next_ref_frame_map[ref_index] = cm->new_fb_idx; - ++frame_bufs[cm->new_fb_idx].ref_count; - } else { - cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index]; - } - // Current thread holds the reference frame. - if (cm->ref_frame_map[ref_index] >= 0) - ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count; - ++ref_index; - } - - for (; ref_index < REF_FRAMES; ++ref_index) { - cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index]; - - // Current thread holds the reference frame. - if (cm->ref_frame_map[ref_index] >= 0) - ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count; - } - unlock_buffer_pool(pool); - pbi->hold_ref_buf = 1; - - // Reload the adapted CDFs from when we originally coded this keyframe - *cm->fc = cm->frame_contexts[existing_frame_idx]; + cm->features.refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; } static INLINE void reset_frame_buffers(AV1_COMMON *cm) { RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; int i; - memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); - memset(&cm->next_ref_frame_map, -1, sizeof(cm->next_ref_frame_map)); - lock_buffer_pool(cm->buffer_pool); + reset_ref_frame_map(cm); + assert(cm->cur_frame->ref_count == 1); for (i = 0; i < FRAME_BUFFERS; ++i) { - if (i != cm->new_fb_idx) { - frame_bufs[i].ref_count = 0; - cm->buffer_pool->release_fb_cb(cm->buffer_pool->cb_priv, - &frame_bufs[i].raw_frame_buffer); - } else { - assert(frame_bufs[i].ref_count == 1); + // Reset all unreferenced frame buffers. We can also reset cm->cur_frame + // because we are the sole owner of cm->cur_frame. + if (frame_bufs[i].ref_count > 0 && &frame_bufs[i] != cm->cur_frame) { + continue; } - frame_bufs[i].cur_frame_offset = 0; - av1_zero(frame_bufs[i].ref_frame_offset); + frame_bufs[i].order_hint = 0; + av1_zero(frame_bufs[i].ref_order_hints); } av1_zero_unused_internal_frame_buffers(&cm->buffer_pool->int_frame_buffers); unlock_buffer_pool(cm->buffer_pool); @@ -4688,6 +4438,8 @@ static int read_uncompressed_header(AV1Decoder *pbi, struct aom_read_bit_buffer *rb) { AV1_COMMON *const cm = &pbi->common; const SequenceHeader *const seq_params = &cm->seq_params; + CurrentFrame *const current_frame = &cm->current_frame; + FeatureFlags *const features = &cm->features; MACROBLOCKD *const xd = &pbi->mb; BufferPool *const pool = cm->buffer_pool; RefCntBuffer *const frame_bufs = pool->frame_bufs; @@ -4697,20 +4449,20 @@ static int read_uncompressed_header(AV1Decoder *pbi, "No sequence header"); } - cm->last_frame_type = cm->frame_type; - cm->last_intra_only = cm->intra_only; - - // NOTE: By default all coded frames to be used as a reference - cm->is_reference_frame = 1; - if (seq_params->reduced_still_picture_hdr) { cm->show_existing_frame = 0; cm->show_frame = 1; - cm->frame_type = KEY_FRAME; - cm->error_resilient_mode = 1; + current_frame->frame_type = KEY_FRAME; + if (pbi->sequence_header_changed) { + // This is the start of a new coded video sequence. + pbi->sequence_header_changed = 0; + pbi->decoding_first_frame = 1; + reset_frame_buffers(cm); + } + features->error_resilient_mode = 1; } else { cm->show_existing_frame = aom_rb_read_bit(rb); - cm->reset_decoder_state = 0; + pbi->reset_decoder_state = 0; if (cm->show_existing_frame) { if (pbi->sequence_header_changed) { @@ -4720,10 +4472,14 @@ static int read_uncompressed_header(AV1Decoder *pbi, } // Show an existing frame directly. const int existing_frame_idx = aom_rb_read_literal(rb, 3); - const int frame_to_show = cm->ref_frame_map[existing_frame_idx]; + RefCntBuffer *const frame_to_show = cm->ref_frame_map[existing_frame_idx]; + if (frame_to_show == NULL) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Buffer does not contain a decoded frame"); + } if (seq_params->decoder_model_info_present_flag && - cm->timing_info.equal_picture_interval == 0) { - av1_read_temporal_point_info(cm, rb); + seq_params->timing_info.equal_picture_interval == 0) { + read_temporal_point_info(cm, rb); } if (seq_params->frame_id_numbers_present_flag) { int frame_id_length = seq_params->frame_id_length; @@ -4731,49 +4487,60 @@ static int read_uncompressed_header(AV1Decoder *pbi, /* Compare display_frame_id with ref_frame_id and check valid for * referencing */ if (display_frame_id != cm->ref_frame_id[existing_frame_idx] || - cm->valid_for_referencing[existing_frame_idx] == 0) + pbi->valid_for_referencing[existing_frame_idx] == 0) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Reference buffer frame ID mismatch"); } lock_buffer_pool(pool); - if (frame_to_show < 0 || frame_bufs[frame_to_show].ref_count < 1) { - unlock_buffer_pool(pool); - aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "Buffer %d does not contain a decoded frame", - frame_to_show); - } - ref_cnt_fb(frame_bufs, &cm->new_fb_idx, frame_to_show); - cm->reset_decoder_state = - frame_bufs[frame_to_show].frame_type == KEY_FRAME; + assert(frame_to_show->ref_count > 0); + // cm->cur_frame should be the buffer referenced by the return value + // of the get_free_fb() call in assign_cur_frame_new_fb() (called by + // av1_receive_compressed_data()), so the ref_count should be 1. + assert(cm->cur_frame->ref_count == 1); + // assign_frame_buffer_p() decrements ref_count directly rather than + // call decrease_ref_count(). If cm->cur_frame->raw_frame_buffer has + // already been allocated, it will not be released by + // assign_frame_buffer_p()! + assert(!cm->cur_frame->raw_frame_buffer.data); + assign_frame_buffer_p(&cm->cur_frame, frame_to_show); + pbi->reset_decoder_state = frame_to_show->frame_type == KEY_FRAME; unlock_buffer_pool(pool); cm->lf.filter_level[0] = 0; cm->lf.filter_level[1] = 0; cm->show_frame = 1; - if (!frame_bufs[frame_to_show].showable_frame) { - aom_merge_corrupted_flag(&xd->corrupted, 1); + // Section 6.8.2: It is a requirement of bitstream conformance that when + // show_existing_frame is used to show a previous frame, that the value + // of showable_frame for the previous frame was equal to 1. + if (!frame_to_show->showable_frame) { + aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "Buffer does not contain a showable frame"); } - if (cm->reset_decoder_state) frame_bufs[frame_to_show].showable_frame = 0; + // Section 6.8.2: It is a requirement of bitstream conformance that when + // show_existing_frame is used to show a previous frame with + // RefFrameType[ frame_to_show_map_idx ] equal to KEY_FRAME, that the + // frame is output via the show_existing_frame mechanism at most once. + if (pbi->reset_decoder_state) frame_to_show->showable_frame = 0; - cm->film_grain_params = frame_bufs[frame_to_show].film_grain_params; + cm->film_grain_params = frame_to_show->film_grain_params; - if (cm->reset_decoder_state) { + if (pbi->reset_decoder_state) { show_existing_frame_reset(pbi, existing_frame_idx); } else { - pbi->refresh_frame_flags = 0; + current_frame->refresh_frame_flags = 0; } return 0; } - cm->frame_type = (FRAME_TYPE)aom_rb_read_literal(rb, 2); // 2 bits + current_frame->frame_type = (FRAME_TYPE)aom_rb_read_literal(rb, 2); if (pbi->sequence_header_changed) { - if (pbi->common.frame_type == KEY_FRAME) { + if (current_frame->frame_type == KEY_FRAME) { // This is the start of a new coded video sequence. pbi->sequence_header_changed = 0; pbi->decoding_first_frame = 1; - reset_frame_buffers(&pbi->common); + reset_frame_buffers(cm); } else { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Sequence header has changed without a keyframe."); @@ -4782,56 +4549,63 @@ static int read_uncompressed_header(AV1Decoder *pbi, cm->show_frame = aom_rb_read_bit(rb); if (seq_params->still_picture && - (cm->frame_type != KEY_FRAME || !cm->show_frame)) { + (current_frame->frame_type != KEY_FRAME || !cm->show_frame)) { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Still pictures must be coded as shown keyframes"); } - cm->showable_frame = cm->frame_type != KEY_FRAME; + cm->showable_frame = current_frame->frame_type != KEY_FRAME; if (cm->show_frame) { if (seq_params->decoder_model_info_present_flag && - cm->timing_info.equal_picture_interval == 0) - av1_read_temporal_point_info(cm, rb); + seq_params->timing_info.equal_picture_interval == 0) + read_temporal_point_info(cm, rb); } else { // See if this frame can be used as show_existing_frame in future cm->showable_frame = aom_rb_read_bit(rb); } cm->cur_frame->showable_frame = cm->showable_frame; - cm->intra_only = cm->frame_type == INTRA_ONLY_FRAME; - cm->error_resilient_mode = - frame_is_sframe(cm) || (cm->frame_type == KEY_FRAME && cm->show_frame) + features->error_resilient_mode = + frame_is_sframe(cm) || + (current_frame->frame_type == KEY_FRAME && cm->show_frame) ? 1 : aom_rb_read_bit(rb); } - cm->disable_cdf_update = aom_rb_read_bit(rb); + if (current_frame->frame_type == KEY_FRAME && cm->show_frame) { + /* All frames need to be marked as not valid for referencing */ + for (int i = 0; i < REF_FRAMES; i++) { + pbi->valid_for_referencing[i] = 0; + } + } + features->disable_cdf_update = aom_rb_read_bit(rb); if (seq_params->force_screen_content_tools == 2) { - cm->allow_screen_content_tools = aom_rb_read_bit(rb); + features->allow_screen_content_tools = aom_rb_read_bit(rb); } else { - cm->allow_screen_content_tools = seq_params->force_screen_content_tools; + features->allow_screen_content_tools = + seq_params->force_screen_content_tools; } - if (cm->allow_screen_content_tools) { + if (features->allow_screen_content_tools) { if (seq_params->force_integer_mv == 2) { - cm->cur_frame_force_integer_mv = aom_rb_read_bit(rb); + features->cur_frame_force_integer_mv = aom_rb_read_bit(rb); } else { - cm->cur_frame_force_integer_mv = seq_params->force_integer_mv; + features->cur_frame_force_integer_mv = seq_params->force_integer_mv; } } else { - cm->cur_frame_force_integer_mv = 0; + features->cur_frame_force_integer_mv = 0; } - cm->frame_refs_short_signaling = 0; int frame_size_override_flag = 0; - cm->allow_intrabc = 0; - cm->primary_ref_frame = PRIMARY_REF_NONE; + features->allow_intrabc = 0; + features->primary_ref_frame = PRIMARY_REF_NONE; if (!seq_params->reduced_still_picture_hdr) { if (seq_params->frame_id_numbers_present_flag) { int frame_id_length = seq_params->frame_id_length; int diff_len = seq_params->delta_frame_id_length; int prev_frame_id = 0; - int have_prev_frame_id = !pbi->decoding_first_frame && - !(cm->frame_type == KEY_FRAME && cm->show_frame); + int have_prev_frame_id = + !pbi->decoding_first_frame && + !(current_frame->frame_type == KEY_FRAME && cm->show_frame); if (have_prev_frame_id) { prev_frame_id = cm->current_frame_id; } @@ -4854,29 +4628,27 @@ static int read_uncompressed_header(AV1Decoder *pbi, } /* Check if some frames need to be marked as not valid for referencing */ for (int i = 0; i < REF_FRAMES; i++) { - if (cm->frame_type == KEY_FRAME && cm->show_frame) { - cm->valid_for_referencing[i] = 0; - } else if (cm->current_frame_id - (1 << diff_len) > 0) { + if (cm->current_frame_id - (1 << diff_len) > 0) { if (cm->ref_frame_id[i] > cm->current_frame_id || cm->ref_frame_id[i] < cm->current_frame_id - (1 << diff_len)) - cm->valid_for_referencing[i] = 0; + pbi->valid_for_referencing[i] = 0; } else { if (cm->ref_frame_id[i] > cm->current_frame_id && cm->ref_frame_id[i] < (1 << frame_id_length) + cm->current_frame_id - (1 << diff_len)) - cm->valid_for_referencing[i] = 0; + pbi->valid_for_referencing[i] = 0; } } } frame_size_override_flag = frame_is_sframe(cm) ? 1 : aom_rb_read_bit(rb); - cm->frame_offset = - aom_rb_read_literal(rb, seq_params->order_hint_bits_minus_1 + 1); - cm->current_video_frame = cm->frame_offset; + current_frame->order_hint = aom_rb_read_literal( + rb, seq_params->order_hint_info.order_hint_bits_minus_1 + 1); + current_frame->frame_number = current_frame->order_hint; - if (!cm->error_resilient_mode && !frame_is_intra_only(cm)) { - cm->primary_ref_frame = aom_rb_read_literal(rb, PRIMARY_REF_BITS); + if (!features->error_resilient_mode && !frame_is_intra_only(cm)) { + features->primary_ref_frame = aom_rb_read_literal(rb, PRIMARY_REF_BITS); } } @@ -4885,7 +4657,7 @@ static int read_uncompressed_header(AV1Decoder *pbi, if (cm->buffer_removal_time_present) { for (int op_num = 0; op_num < seq_params->operating_points_cnt_minus_1 + 1; op_num++) { - if (cm->op_params[op_num].decoder_model_param_present_flag) { + if (seq_params->op_params[op_num].decoder_model_param_present_flag) { if ((((seq_params->operating_point_idc[op_num] >> cm->temporal_layer_id) & 0x1) && @@ -4893,171 +4665,180 @@ static int read_uncompressed_header(AV1Decoder *pbi, (cm->spatial_layer_id + 8)) & 0x1)) || seq_params->operating_point_idc[op_num] == 0) { - cm->op_frame_timing[op_num].buffer_removal_time = - aom_rb_read_unsigned_literal( - rb, cm->buffer_model.buffer_removal_time_length); + cm->buffer_removal_times[op_num] = aom_rb_read_unsigned_literal( + rb, seq_params->decoder_model_info.buffer_removal_time_length); } else { - cm->op_frame_timing[op_num].buffer_removal_time = 0; + cm->buffer_removal_times[op_num] = 0; } } else { - cm->op_frame_timing[op_num].buffer_removal_time = 0; + cm->buffer_removal_times[op_num] = 0; } } } } - if (cm->frame_type == KEY_FRAME) { - if (!cm->show_frame) // unshown keyframe (forward keyframe) - pbi->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES); - else // shown keyframe - pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1; + if (current_frame->frame_type == KEY_FRAME) { + if (!cm->show_frame) { // unshown keyframe (forward keyframe) + current_frame->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES); + } else { // shown keyframe + current_frame->refresh_frame_flags = (1 << REF_FRAMES) - 1; + } for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { - cm->frame_refs[i].idx = INVALID_IDX; - cm->frame_refs[i].buf = NULL; + cm->remapped_ref_idx[i] = INVALID_IDX; } if (pbi->need_resync) { - memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); + reset_ref_frame_map(cm); pbi->need_resync = 0; } } else { - if (cm->intra_only) { - pbi->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES); - if (pbi->refresh_frame_flags == 0xFF) { + if (current_frame->frame_type == INTRA_ONLY_FRAME) { + current_frame->refresh_frame_flags = aom_rb_read_literal(rb, REF_FRAMES); + if (current_frame->refresh_frame_flags == 0xFF) { aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, "Intra only frames cannot have refresh flags 0xFF"); } if (pbi->need_resync) { - memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); + reset_ref_frame_map(cm); pbi->need_resync = 0; } } else if (pbi->need_resync != 1) { /* Skip if need resync */ - pbi->refresh_frame_flags = + current_frame->refresh_frame_flags = frame_is_sframe(cm) ? 0xFF : aom_rb_read_literal(rb, REF_FRAMES); - if (!pbi->refresh_frame_flags) { - // NOTE: "pbi->refresh_frame_flags == 0" indicates that the coded frame - // will not be used as a reference - cm->is_reference_frame = 0; - } } } - if (!frame_is_intra_only(cm) || pbi->refresh_frame_flags != 0xFF) { + if (!frame_is_intra_only(cm) || current_frame->refresh_frame_flags != 0xFF) { // Read all ref frame order hints if error_resilient_mode == 1 - if (cm->error_resilient_mode && seq_params->enable_order_hint) { + if (features->error_resilient_mode && + seq_params->order_hint_info.enable_order_hint) { for (int ref_idx = 0; ref_idx < REF_FRAMES; ref_idx++) { // Read order hint from bit stream - unsigned int frame_offset = - aom_rb_read_literal(rb, seq_params->order_hint_bits_minus_1 + 1); - // Get buffer index - int buf_idx = cm->ref_frame_map[ref_idx]; - assert(buf_idx < FRAME_BUFFERS); - if (buf_idx == -1 || - frame_offset != frame_bufs[buf_idx].cur_frame_offset) { - if (buf_idx >= 0) { + unsigned int order_hint = aom_rb_read_literal( + rb, seq_params->order_hint_info.order_hint_bits_minus_1 + 1); + // Get buffer + RefCntBuffer *buf = cm->ref_frame_map[ref_idx]; + if (buf == NULL || order_hint != buf->order_hint) { + if (buf != NULL) { lock_buffer_pool(pool); - decrease_ref_count(buf_idx, frame_bufs, pool); + decrease_ref_count(buf, pool); unlock_buffer_pool(pool); + cm->ref_frame_map[ref_idx] = NULL; } // If no corresponding buffer exists, allocate a new buffer with all // pixels set to neutral grey. - buf_idx = get_free_fb(cm); + int buf_idx = get_free_fb(cm); if (buf_idx == INVALID_IDX) { aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Unable to find free frame buffer"); } + buf = &frame_bufs[buf_idx]; lock_buffer_pool(pool); if (aom_realloc_frame_buffer( - &frame_bufs[buf_idx].buf, seq_params->max_frame_width, + &buf->buf, seq_params->max_frame_width, seq_params->max_frame_height, seq_params->subsampling_x, seq_params->subsampling_y, seq_params->use_highbitdepth, - AOM_BORDER_IN_PIXELS, cm->byte_alignment, - &pool->frame_bufs[buf_idx].raw_frame_buffer, pool->get_fb_cb, - pool->cb_priv)) { + AOM_BORDER_IN_PIXELS, features->byte_alignment, + &buf->raw_frame_buffer, pool->get_fb_cb, pool->cb_priv)) { + decrease_ref_count(buf, pool); unlock_buffer_pool(pool); aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate frame buffer"); } unlock_buffer_pool(pool); - set_planes_to_neutral_grey(seq_params, &frame_bufs[buf_idx].buf, 0); - - cm->ref_frame_map[ref_idx] = buf_idx; - frame_bufs[buf_idx].cur_frame_offset = frame_offset; + // According to the specification, valid bitstreams are required to + // never use missing reference frames so the filling process for + // missing frames is not normatively defined and RefValid for missing + // frames is set to 0. + + // To make libaom more robust when the bitstream has been corrupted + // by the loss of some frames of data, this code adds a neutral grey + // buffer in place of missing frames, i.e. + // + set_planes_to_neutral_grey(seq_params, &buf->buf, 0); + // + // and allows the frames to be used for referencing, i.e. + // + pbi->valid_for_referencing[ref_idx] = 1; + // + // Please note such behavior is not normative and other decoders may + // use a different approach. + cm->ref_frame_map[ref_idx] = buf; + buf->order_hint = order_hint; } } } } - if (cm->frame_type == KEY_FRAME) { + if (current_frame->frame_type == KEY_FRAME) { setup_frame_size(cm, frame_size_override_flag, rb); - if (cm->allow_screen_content_tools && !av1_superres_scaled(cm)) - cm->allow_intrabc = aom_rb_read_bit(rb); - cm->allow_ref_frame_mvs = 0; + if (features->allow_screen_content_tools && !av1_superres_scaled(cm)) + features->allow_intrabc = aom_rb_read_bit(rb); + features->allow_ref_frame_mvs = 0; cm->prev_frame = NULL; } else { - cm->allow_ref_frame_mvs = 0; + features->allow_ref_frame_mvs = 0; - if (cm->intra_only) { + if (current_frame->frame_type == INTRA_ONLY_FRAME) { cm->cur_frame->film_grain_params_present = seq_params->film_grain_params_present; setup_frame_size(cm, frame_size_override_flag, rb); - if (cm->allow_screen_content_tools && !av1_superres_scaled(cm)) - cm->allow_intrabc = aom_rb_read_bit(rb); + if (features->allow_screen_content_tools && !av1_superres_scaled(cm)) + features->allow_intrabc = aom_rb_read_bit(rb); } else if (pbi->need_resync != 1) { /* Skip if need resync */ - + int frame_refs_short_signaling = 0; // Frame refs short signaling is off when error resilient mode is on. - if (seq_params->enable_order_hint) - cm->frame_refs_short_signaling = aom_rb_read_bit(rb); + if (seq_params->order_hint_info.enable_order_hint) + frame_refs_short_signaling = aom_rb_read_bit(rb); - if (cm->frame_refs_short_signaling) { + if (frame_refs_short_signaling) { // == LAST_FRAME == const int lst_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2); - const int lst_idx = cm->ref_frame_map[lst_ref]; + const RefCntBuffer *const lst_buf = cm->ref_frame_map[lst_ref]; // == GOLDEN_FRAME == const int gld_ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2); - const int gld_idx = cm->ref_frame_map[gld_ref]; + const RefCntBuffer *const gld_buf = cm->ref_frame_map[gld_ref]; // Most of the time, streams start with a keyframe. In that case, // ref_frame_map will have been filled in at that point and will not - // contain any -1's. However, streams are explicitly allowed to start + // contain any NULLs. However, streams are explicitly allowed to start // with an intra-only frame, so long as they don't then signal a // reference to a slot that hasn't been set yet. That's what we are // checking here. - if (lst_idx == -1) + if (lst_buf == NULL) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Inter frame requests nonexistent reference"); - if (gld_idx == -1) + if (gld_buf == NULL) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Inter frame requests nonexistent reference"); - av1_set_frame_refs(cm, lst_ref, gld_ref); + av1_set_frame_refs(cm, cm->remapped_ref_idx, lst_ref, gld_ref); } for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { int ref = 0; - if (!cm->frame_refs_short_signaling) { + if (!frame_refs_short_signaling) { ref = aom_rb_read_literal(rb, REF_FRAMES_LOG2); - const int idx = cm->ref_frame_map[ref]; // Most of the time, streams start with a keyframe. In that case, // ref_frame_map will have been filled in at that point and will not - // contain any -1's. However, streams are explicitly allowed to start + // contain any NULLs. However, streams are explicitly allowed to start // with an intra-only frame, so long as they don't then signal a // reference to a slot that hasn't been set yet. That's what we are // checking here. - if (idx == -1) + if (cm->ref_frame_map[ref] == NULL) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Inter frame requests nonexistent reference"); - - RefBuffer *const ref_frame = &cm->frame_refs[i]; - ref_frame->idx = idx; - ref_frame->buf = &frame_bufs[idx].buf; - ref_frame->map_idx = ref; + cm->remapped_ref_idx[i] = ref; } else { - ref = cm->frame_refs[i].map_idx; + ref = cm->remapped_ref_idx[i]; } + // Check valid for referencing + if (pbi->valid_for_referencing[ref] == 0) + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Reference frame not valid for referencing"); cm->ref_frame_sign_bias[LAST_FRAME + i] = 0; @@ -5070,49 +4851,51 @@ static int read_uncompressed_header(AV1Decoder *pbi, (1 << frame_id_length)) % (1 << frame_id_length)); // Compare values derived from delta_frame_id_minus_1 and - // refresh_frame_flags. Also, check valid for referencing - if (ref_frame_id != cm->ref_frame_id[ref] || - cm->valid_for_referencing[ref] == 0) + // refresh_frame_flags. + if (ref_frame_id != cm->ref_frame_id[ref]) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Reference buffer frame ID mismatch"); } } - if (!cm->error_resilient_mode && frame_size_override_flag) { + if (!features->error_resilient_mode && frame_size_override_flag) { setup_frame_size_with_refs(cm, rb); } else { setup_frame_size(cm, frame_size_override_flag, rb); } - if (cm->cur_frame_force_integer_mv) { - cm->allow_high_precision_mv = 0; + if (features->cur_frame_force_integer_mv) { + features->allow_high_precision_mv = 0; } else { - cm->allow_high_precision_mv = aom_rb_read_bit(rb); + features->allow_high_precision_mv = aom_rb_read_bit(rb); } - cm->interp_filter = read_frame_interp_filter(rb); - cm->switchable_motion_mode = aom_rb_read_bit(rb); + features->interp_filter = read_frame_interp_filter(rb); + features->switchable_motion_mode = aom_rb_read_bit(rb); } - cm->prev_frame = get_prev_frame(cm); - if (cm->primary_ref_frame != PRIMARY_REF_NONE && - cm->frame_refs[cm->primary_ref_frame].idx < 0) { + cm->prev_frame = get_primary_ref_frame_buf(cm); + if (features->primary_ref_frame != PRIMARY_REF_NONE && + get_primary_ref_frame_buf(cm) == NULL) { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Reference frame containing this frame's initial " "frame context is unavailable."); } - if (!cm->intra_only && pbi->need_resync != 1) { + if (!(current_frame->frame_type == INTRA_ONLY_FRAME) && + pbi->need_resync != 1) { if (frame_might_allow_ref_frame_mvs(cm)) - cm->allow_ref_frame_mvs = aom_rb_read_bit(rb); + features->allow_ref_frame_mvs = aom_rb_read_bit(rb); else - cm->allow_ref_frame_mvs = 0; + features->allow_ref_frame_mvs = 0; - for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { - RefBuffer *const ref_buf = &cm->frame_refs[i]; + for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { + const RefCntBuffer *const ref_buf = get_ref_frame_buf(cm, i); + struct scale_factors *const ref_scale_factors = + get_ref_scale_factors(cm, i); av1_setup_scale_factors_for_frame( - &ref_buf->sf, ref_buf->buf->y_crop_width, - ref_buf->buf->y_crop_height, cm->width, cm->height); - if ((!av1_is_valid_scale(&ref_buf->sf))) + ref_scale_factors, ref_buf->buf.y_crop_width, + ref_buf->buf.y_crop_height, cm->width, cm->height); + if ((!av1_is_valid_scale(ref_scale_factors))) aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, "Reference frame has invalid dimensions"); } @@ -5123,43 +4906,31 @@ static int read_uncompressed_header(AV1Decoder *pbi, av1_setup_frame_sign_bias(cm); - cm->cur_frame->intra_only = cm->frame_type == KEY_FRAME || cm->intra_only; - cm->cur_frame->frame_type = cm->frame_type; + cm->cur_frame->frame_type = current_frame->frame_type; - if (seq_params->frame_id_numbers_present_flag) { - /* If bitmask is set, update reference frame id values and - mark frames as valid for reference */ - int refresh_frame_flags = pbi->refresh_frame_flags; - for (int i = 0; i < REF_FRAMES; i++) { - if ((refresh_frame_flags >> i) & 1) { - cm->ref_frame_id[i] = cm->current_frame_id; - cm->valid_for_referencing[i] = 1; - } - } - } + update_ref_frame_id(pbi); - const int might_bwd_adapt = - !(seq_params->reduced_still_picture_hdr) && !(cm->disable_cdf_update); + const int might_bwd_adapt = !(seq_params->reduced_still_picture_hdr) && + !(features->disable_cdf_update); if (might_bwd_adapt) { - cm->refresh_frame_context = aom_rb_read_bit(rb) - ? REFRESH_FRAME_CONTEXT_DISABLED - : REFRESH_FRAME_CONTEXT_BACKWARD; + features->refresh_frame_context = aom_rb_read_bit(rb) + ? REFRESH_FRAME_CONTEXT_DISABLED + : REFRESH_FRAME_CONTEXT_BACKWARD; } else { - cm->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; + features->refresh_frame_context = REFRESH_FRAME_CONTEXT_DISABLED; } - get_frame_new_buffer(cm)->bit_depth = seq_params->bit_depth; - get_frame_new_buffer(cm)->color_primaries = seq_params->color_primaries; - get_frame_new_buffer(cm)->transfer_characteristics = + cm->cur_frame->buf.bit_depth = seq_params->bit_depth; + cm->cur_frame->buf.color_primaries = seq_params->color_primaries; + cm->cur_frame->buf.transfer_characteristics = seq_params->transfer_characteristics; - get_frame_new_buffer(cm)->matrix_coefficients = - seq_params->matrix_coefficients; - get_frame_new_buffer(cm)->monochrome = seq_params->monochrome; - get_frame_new_buffer(cm)->chroma_sample_position = + cm->cur_frame->buf.matrix_coefficients = seq_params->matrix_coefficients; + cm->cur_frame->buf.monochrome = seq_params->monochrome; + cm->cur_frame->buf.chroma_sample_position = seq_params->chroma_sample_position; - get_frame_new_buffer(cm)->color_range = seq_params->color_range; - get_frame_new_buffer(cm)->render_width = cm->render_width; - get_frame_new_buffer(cm)->render_height = cm->render_height; + cm->cur_frame->buf.color_range = seq_params->color_range; + cm->cur_frame->buf.render_width = cm->render_width; + cm->cur_frame->buf.render_height = cm->render_height; if (pbi->need_resync) { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, @@ -5167,133 +4938,119 @@ static int read_uncompressed_header(AV1Decoder *pbi, " state"); } - // Generate next_ref_frame_map. - lock_buffer_pool(pool); - int ref_index = 0; - for (int mask = pbi->refresh_frame_flags; mask; mask >>= 1) { - if (mask & 1) { - cm->next_ref_frame_map[ref_index] = cm->new_fb_idx; - ++frame_bufs[cm->new_fb_idx].ref_count; - } else { - cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index]; - } - // Current thread holds the reference frame. - if (cm->ref_frame_map[ref_index] >= 0) - ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count; - ++ref_index; - } - - for (; ref_index < REF_FRAMES; ++ref_index) { - cm->next_ref_frame_map[ref_index] = cm->ref_frame_map[ref_index]; - - // Current thread holds the reference frame. - if (cm->ref_frame_map[ref_index] >= 0) - ++frame_bufs[cm->ref_frame_map[ref_index]].ref_count; - } - unlock_buffer_pool(pool); - pbi->hold_ref_buf = 1; - - if (cm->allow_intrabc) { + if (features->allow_intrabc) { // Set parameters corresponding to no filtering. struct loopfilter *lf = &cm->lf; lf->filter_level[0] = 0; lf->filter_level[1] = 0; - cm->cdef_bits = 0; - cm->cdef_strengths[0] = 0; - cm->nb_cdef_strengths = 1; - cm->cdef_uv_strengths[0] = 0; + cm->cdef_info.cdef_bits = 0; + cm->cdef_info.cdef_strengths[0] = 0; + cm->cdef_info.nb_cdef_strengths = 1; + cm->cdef_info.cdef_uv_strengths[0] = 0; cm->rst_info[0].frame_restoration_type = RESTORE_NONE; cm->rst_info[1].frame_restoration_type = RESTORE_NONE; cm->rst_info[2].frame_restoration_type = RESTORE_NONE; } read_tile_info(pbi, rb); - setup_quantization(cm, rb); + if (!av1_is_min_tile_width_satisfied(cm)) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Minimum tile width requirement not satisfied"); + } + + CommonQuantParams *const quant_params = &cm->quant_params; + setup_quantization(quant_params, av1_num_planes(cm), + cm->seq_params.separate_uv_delta_q, rb); xd->bd = (int)seq_params->bit_depth; - if (cm->num_allocated_above_context_planes < av1_num_planes(cm) || - cm->num_allocated_above_context_mi_col < cm->mi_cols || - cm->num_allocated_above_contexts < cm->tile_rows) { - av1_free_above_context_buffers(cm, cm->num_allocated_above_contexts); - if (av1_alloc_above_context_buffers(cm, cm->tile_rows)) + CommonContexts *const above_contexts = &cm->above_contexts; + if (above_contexts->num_planes < av1_num_planes(cm) || + above_contexts->num_mi_cols < cm->mi_params.mi_cols || + above_contexts->num_tile_rows < cm->tiles.rows) { + av1_free_above_context_buffers(above_contexts); + if (av1_alloc_above_context_buffers(above_contexts, cm->tiles.rows, + cm->mi_params.mi_cols, + av1_num_planes(cm))) { aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, "Failed to allocate context buffers"); + } } - if (cm->primary_ref_frame == PRIMARY_REF_NONE) { + if (features->primary_ref_frame == PRIMARY_REF_NONE) { av1_setup_past_independence(cm); } setup_segmentation(cm, rb); - cm->delta_q_res = 1; - cm->delta_lf_res = 1; - cm->delta_lf_present_flag = 0; - cm->delta_lf_multi = 0; - cm->delta_q_present_flag = cm->base_qindex > 0 ? aom_rb_read_bit(rb) : 0; - if (cm->delta_q_present_flag) { - xd->current_qindex = cm->base_qindex; - cm->delta_q_res = 1 << aom_rb_read_literal(rb, 2); - if (!cm->allow_intrabc) cm->delta_lf_present_flag = aom_rb_read_bit(rb); - if (cm->delta_lf_present_flag) { - cm->delta_lf_res = 1 << aom_rb_read_literal(rb, 2); - cm->delta_lf_multi = aom_rb_read_bit(rb); + cm->delta_q_info.delta_q_res = 1; + cm->delta_q_info.delta_lf_res = 1; + cm->delta_q_info.delta_lf_present_flag = 0; + cm->delta_q_info.delta_lf_multi = 0; + cm->delta_q_info.delta_q_present_flag = + quant_params->base_qindex > 0 ? aom_rb_read_bit(rb) : 0; + if (cm->delta_q_info.delta_q_present_flag) { + xd->current_qindex = quant_params->base_qindex; + cm->delta_q_info.delta_q_res = 1 << aom_rb_read_literal(rb, 2); + if (!features->allow_intrabc) + cm->delta_q_info.delta_lf_present_flag = aom_rb_read_bit(rb); + if (cm->delta_q_info.delta_lf_present_flag) { + cm->delta_q_info.delta_lf_res = 1 << aom_rb_read_literal(rb, 2); + cm->delta_q_info.delta_lf_multi = aom_rb_read_bit(rb); av1_reset_loop_filter_delta(xd, av1_num_planes(cm)); } } - xd->cur_frame_force_integer_mv = cm->cur_frame_force_integer_mv; + xd->cur_frame_force_integer_mv = features->cur_frame_force_integer_mv; for (int i = 0; i < MAX_SEGMENTS; ++i) { - const int qindex = cm->seg.enabled - ? av1_get_qindex(&cm->seg, i, cm->base_qindex) - : cm->base_qindex; - xd->lossless[i] = qindex == 0 && cm->y_dc_delta_q == 0 && - cm->u_dc_delta_q == 0 && cm->u_ac_delta_q == 0 && - cm->v_dc_delta_q == 0 && cm->v_ac_delta_q == 0; + const int qindex = av1_get_qindex(&cm->seg, i, quant_params->base_qindex); + xd->lossless[i] = + qindex == 0 && quant_params->y_dc_delta_q == 0 && + 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; xd->qindex[i] = qindex; } - cm->coded_lossless = is_coded_lossless(cm, xd); - cm->all_lossless = cm->coded_lossless && !av1_superres_scaled(cm); - setup_segmentation_dequant(cm); - if (cm->coded_lossless) { + features->coded_lossless = is_coded_lossless(cm, xd); + features->all_lossless = features->coded_lossless && !av1_superres_scaled(cm); + setup_segmentation_dequant(cm, xd); + if (features->coded_lossless) { cm->lf.filter_level[0] = 0; cm->lf.filter_level[1] = 0; } - if (cm->coded_lossless || !seq_params->enable_cdef) { - cm->cdef_bits = 0; - cm->cdef_strengths[0] = 0; - cm->cdef_uv_strengths[0] = 0; + if (features->coded_lossless || !seq_params->enable_cdef) { + cm->cdef_info.cdef_bits = 0; + cm->cdef_info.cdef_strengths[0] = 0; + cm->cdef_info.cdef_uv_strengths[0] = 0; } - if (cm->all_lossless || !seq_params->enable_restoration) { + if (features->all_lossless || !seq_params->enable_restoration) { cm->rst_info[0].frame_restoration_type = RESTORE_NONE; cm->rst_info[1].frame_restoration_type = RESTORE_NONE; cm->rst_info[2].frame_restoration_type = RESTORE_NONE; } setup_loopfilter(cm, rb); - if (!cm->coded_lossless && seq_params->enable_cdef) { + if (!features->coded_lossless && seq_params->enable_cdef) { setup_cdef(cm, rb); } - if (!cm->all_lossless && seq_params->enable_restoration) { + if (!features->all_lossless && seq_params->enable_restoration) { decode_restoration_mode(cm, rb); } - cm->tx_mode = read_tx_mode(cm, rb); - cm->reference_mode = read_frame_reference_mode(cm, rb); - if (cm->reference_mode != SINGLE_REFERENCE) setup_compound_reference_mode(cm); + features->tx_mode = read_tx_mode(rb, features->coded_lossless); + current_frame->reference_mode = read_frame_reference_mode(cm, rb); av1_setup_skip_mode_allowed(cm); - cm->skip_mode_flag = cm->is_skip_mode_allowed ? aom_rb_read_bit(rb) : 0; + current_frame->skip_mode_info.skip_mode_flag = + current_frame->skip_mode_info.skip_mode_allowed ? aom_rb_read_bit(rb) : 0; if (frame_might_allow_warped_motion(cm)) - cm->allow_warped_motion = aom_rb_read_bit(rb); + features->allow_warped_motion = aom_rb_read_bit(rb); else - cm->allow_warped_motion = 0; + features->allow_warped_motion = 0; - cm->reduced_tx_set_used = aom_rb_read_bit(rb); + features->reduced_tx_set_used = aom_rb_read_bit(rb); - if (cm->allow_ref_frame_mvs && !frame_might_allow_ref_frame_mvs(cm)) { + if (features->allow_ref_frame_mvs && !frame_might_allow_ref_frame_mvs(cm)) { aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Frame wrongly requests reference frame MVs"); } @@ -5305,7 +5062,7 @@ static int read_uncompressed_header(AV1Decoder *pbi, read_film_grain(cm, rb); #if EXT_TILE_DEBUG - if (pbi->ext_tile_debug && cm->large_scale_tile) { + if (pbi->ext_tile_debug && cm->tiles.large_scale) { read_ext_tile_info(pbi, rb); av1_set_single_tile_decoding_mode(cm); } @@ -5335,16 +5092,14 @@ BITSTREAM_PROFILE av1_read_profile(struct aom_read_bit_buffer *rb) { return (BITSTREAM_PROFILE)profile; } -void superres_post_decode(AV1Decoder *pbi) { +static AOM_INLINE void superres_post_decode(AV1Decoder *pbi) { AV1_COMMON *const cm = &pbi->common; BufferPool *const pool = cm->buffer_pool; if (!av1_superres_scaled(cm)) return; - assert(!cm->all_lossless); + assert(!cm->features.all_lossless); - lock_buffer_pool(pool); av1_superres_upscale(cm, pool); - unlock_buffer_pool(pool); } uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, @@ -5357,7 +5112,8 @@ uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, MACROBLOCKD *const xd = &pbi->mb; #if CONFIG_BITSTREAM_DEBUG - bitstream_queue_set_frame_read(cm->current_video_frame * 2 + cm->show_frame); + aom_bitstream_queue_set_frame_read(cm->current_frame.frame_number * 2 + + cm->show_frame); #endif #if CONFIG_MISMATCH_DEBUG mismatch_move_frame_idx_r(); @@ -5373,9 +5129,7 @@ uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, if (trailing_bits_present) av1_check_trailing_bits(pbi, rb); - // If cm->single_tile_decoding = 0, the independent decoding of a single tile - // or a section of a frame is not allowed. - if (!cm->single_tile_decoding && + if (!cm->tiles.single_tile_decoding && (pbi->dec_tile_row >= 0 || pbi->dec_tile_col >= 0)) { pbi->dec_tile_row = -1; pbi->dec_tile_col = -1; @@ -5383,7 +5137,7 @@ uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, const uint32_t uncomp_hdr_size = (uint32_t)aom_rb_bytes_read(rb); // Size of the uncompressed header - YV12_BUFFER_CONFIG *new_fb = get_frame_new_buffer(cm); + YV12_BUFFER_CONFIG *new_fb = &cm->cur_frame->buf; xd->cur_buf = new_fb; if (av1_allow_intrabc(cm)) { av1_setup_scale_factors_for_frame( @@ -5394,9 +5148,9 @@ uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, if (cm->show_existing_frame) { // showing a frame directly *p_data_end = data + uncomp_hdr_size; - if (cm->reset_decoder_state) { + if (pbi->reset_decoder_state) { // Use the default frame context values. - *cm->fc = cm->frame_contexts[FRAME_CONTEXT_DEFAULTS]; + *cm->fc = *cm->default_frame_context; if (!cm->fc->initialized) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, "Uninitialized entropy context."); @@ -5404,19 +5158,17 @@ uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, return uncomp_hdr_size; } - cm->setup_mi(cm); - - cm->current_frame_seg_map = cm->cur_frame->seg_map; + cm->mi_params.setup_mi(&cm->mi_params); av1_setup_motion_field(cm); av1_setup_block_planes(xd, cm->seq_params.subsampling_x, cm->seq_params.subsampling_y, num_planes); - if (cm->primary_ref_frame == PRIMARY_REF_NONE) { + if (cm->features.primary_ref_frame == PRIMARY_REF_NONE) { // use the default frame context values - *cm->fc = cm->frame_contexts[FRAME_CONTEXT_DEFAULTS]; + *cm->fc = *cm->default_frame_context; } else { - *cm->fc = cm->frame_contexts[cm->frame_refs[cm->primary_ref_frame].idx]; + *cm->fc = get_primary_ref_frame_buf(cm)->frame_context; } if (!cm->fc->initialized) aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, @@ -5427,7 +5179,7 @@ uint32_t av1_decode_frame_headers_and_setup(AV1Decoder *pbi, } // Once-per-frame initialization -static void setup_frame_info(AV1Decoder *pbi) { +static AOM_INLINE void setup_frame_info(AV1Decoder *pbi) { AV1_COMMON *const cm = &pbi->common; if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE || @@ -5435,7 +5187,7 @@ static void setup_frame_info(AV1Decoder *pbi) { cm->rst_info[2].frame_restoration_type != RESTORE_NONE) { av1_alloc_restoration_buffers(cm); } - const int use_highbd = cm->seq_params.use_highbitdepth ? 1 : 0; + const int use_highbd = cm->seq_params.use_highbitdepth; const int buf_size = MC_TEMP_BUF_PELS << use_highbd; if (pbi->td.mc_buf_size != buf_size) { av1_free_mc_tmp_buf(&pbi->td); @@ -5448,22 +5200,22 @@ void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, const uint8_t **p_data_end, int start_tile, int end_tile, int initialize_flag) { AV1_COMMON *const cm = &pbi->common; + CommonTileParams *const tiles = &cm->tiles; MACROBLOCKD *const xd = &pbi->mb; const int tile_count_tg = end_tile - start_tile + 1; if (initialize_flag) setup_frame_info(pbi); const int num_planes = av1_num_planes(cm); -#if LOOP_FILTER_BITMASK +#if CONFIG_LPF_MASK av1_loop_filter_frame_init(cm, 0, num_planes); - av1_zero_array(cm->lf.lfm, cm->lf.lfm_num); #endif - if (pbi->max_threads > 1 && !(cm->large_scale_tile && !pbi->ext_tile_debug) && + if (pbi->max_threads > 1 && !(tiles->large_scale && !pbi->ext_tile_debug) && pbi->row_mt) *p_data_end = decode_tiles_row_mt(pbi, data, data_end, start_tile, end_tile); else if (pbi->max_threads > 1 && tile_count_tg > 1 && - !(cm->large_scale_tile && !pbi->ext_tile_debug)) + !(tiles->large_scale && !pbi->ext_tile_debug)) *p_data_end = decode_tiles_mt(pbi, data, data_end, start_tile, end_tile); else *p_data_end = decode_tiles(pbi, data, data_end, start_tile, end_tile); @@ -5473,25 +5225,26 @@ void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, set_planes_to_neutral_grey(&cm->seq_params, xd->cur_buf, 1); } - if (end_tile != cm->tile_rows * cm->tile_cols - 1) { + if (end_tile != tiles->rows * tiles->cols - 1) { return; } - if (!cm->allow_intrabc && !cm->single_tile_decoding) { + if (!cm->features.allow_intrabc && !tiles->single_tile_decoding) { if (cm->lf.filter_level[0] || cm->lf.filter_level[1]) { -#if LOOP_FILTER_BITMASK - av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, 1, 0, - num_planes, 0); -#else if (pbi->num_workers > 1) { - av1_loop_filter_frame_mt(get_frame_new_buffer(cm), cm, &pbi->mb, 0, - num_planes, 0, pbi->tile_workers, - pbi->num_workers, &pbi->lf_row_sync); + av1_loop_filter_frame_mt( + &cm->cur_frame->buf, cm, &pbi->mb, 0, num_planes, 0, +#if CONFIG_LPF_MASK + 1, +#endif + pbi->tile_workers, pbi->num_workers, &pbi->lf_row_sync); } else { - av1_loop_filter_frame(get_frame_new_buffer(cm), cm, &pbi->mb, 0, - num_planes, 0); - } + av1_loop_filter_frame(&cm->cur_frame->buf, cm, &pbi->mb, +#if CONFIG_LPF_MASK + 1, #endif + 0, num_planes, 0); + } } const int do_loop_restoration = @@ -5499,21 +5252,24 @@ void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, cm->rst_info[1].frame_restoration_type != RESTORE_NONE || cm->rst_info[2].frame_restoration_type != RESTORE_NONE; const int do_cdef = - !cm->skip_loop_filter && !cm->coded_lossless && - (cm->cdef_bits || cm->cdef_strengths[0] || cm->cdef_uv_strengths[0]); + !pbi->skip_loop_filter && !cm->features.coded_lossless && + (cm->cdef_info.cdef_bits || cm->cdef_info.cdef_strengths[0] || + cm->cdef_info.cdef_uv_strengths[0]); const int do_superres = av1_superres_scaled(cm); const int optimized_loop_restoration = !do_cdef && !do_superres; if (!optimized_loop_restoration) { if (do_loop_restoration) - av1_loop_restoration_save_boundary_lines(&pbi->cur_buf->buf, cm, 0); + av1_loop_restoration_save_boundary_lines(&pbi->common.cur_frame->buf, + cm, 0); - if (do_cdef) av1_cdef_frame(&pbi->cur_buf->buf, cm, &pbi->mb); + if (do_cdef) av1_cdef_frame(&pbi->common.cur_frame->buf, cm, &pbi->mb); superres_post_decode(pbi); if (do_loop_restoration) { - av1_loop_restoration_save_boundary_lines(&pbi->cur_buf->buf, cm, 1); + av1_loop_restoration_save_boundary_lines(&pbi->common.cur_frame->buf, + cm, 1); if (pbi->num_workers > 1) { av1_loop_restoration_filter_frame_mt( (YV12_BUFFER_CONFIG *)xd->cur_buf, cm, optimized_loop_restoration, @@ -5542,11 +5298,14 @@ void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, } } } +#if CONFIG_LPF_MASK + av1_zero_array(cm->lf.lfm, cm->lf.lfm_num); +#endif if (!xd->corrupted) { - if (cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { - assert(cm->context_update_tile_id < pbi->allocated_tiles); - *cm->fc = pbi->tile_data[cm->context_update_tile_id].tctx; + if (cm->features.refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD) { + assert(pbi->context_update_tile_id < pbi->allocated_tiles); + *cm->fc = pbi->tile_data[pbi->context_update_tile_id].tctx; av1_reset_cdf_symbol_counters(cm->fc); } } else { @@ -5561,7 +5320,7 @@ void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data, #endif // Non frame parallel update frame context here. - if (!cm->large_scale_tile) { - cm->frame_contexts[cm->new_fb_idx] = *cm->fc; + if (!tiles->large_scale) { + cm->cur_frame->frame_context = *cm->fc; } } diff --git a/media/libaom/src/av1/decoder/decodeframe.h b/media/libaom/src/av1/decoder/decodeframe.h index ddad273f18..95b3c9f22c 100644 --- a/media/libaom/src/av1/decoder/decodeframe.h +++ b/media/libaom/src/av1/decoder/decodeframe.h @@ -46,8 +46,8 @@ uint32_t av1_decode_frame_headers_and_setup(struct AV1Decoder *pbi, void av1_decode_tg_tiles_and_wrapup(struct AV1Decoder *pbi, const uint8_t *data, const uint8_t *data_end, - const uint8_t **p_data_end, int startTile, - int endTile, int initialize_flag); + const uint8_t **p_data_end, int start_tile, + int end_tile, int initialize_flag); // Implements the color_config() function in the spec. Reports errors by // calling rb->error_handler() or aom_internal_error(). @@ -56,19 +56,21 @@ void av1_read_color_config(struct aom_read_bit_buffer *rb, struct aom_internal_error_info *error_info); // Implements the timing_info() function in the spec. Reports errors by calling -// rb->error_handler(). -void av1_read_timing_info_header(AV1_COMMON *cm, +// rb->error_handler() or aom_internal_error(). +void av1_read_timing_info_header(aom_timing_info_t *timing_info, + struct aom_internal_error_info *error, struct aom_read_bit_buffer *rb); // Implements the decoder_model_info() function in the spec. Reports errors by // calling rb->error_handler(). -void av1_read_decoder_model_info(AV1_COMMON *cm, +void av1_read_decoder_model_info(aom_dec_model_info_t *decoder_model_info, struct aom_read_bit_buffer *rb); // Implements the operating_parameters_info() function in the spec. Reports -// errors by calling rb->error_handler() or aom_internal_error(). -void av1_read_op_parameters_info(AV1_COMMON *const cm, - struct aom_read_bit_buffer *rb, int op_num); +// errors by calling rb->error_handler(). +void av1_read_op_parameters_info(aom_dec_model_op_parameters_t *op_params, + int buffer_delay_length, + struct aom_read_bit_buffer *rb); struct aom_read_bit_buffer *av1_init_read_bit_buffer( struct AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data, diff --git a/media/libaom/src/av1/decoder/decodemv.c b/media/libaom/src/av1/decoder/decodemv.c index 551e4d5437..e97cec42cb 100644 --- a/media/libaom/src/av1/decoder/decodemv.c +++ b/media/libaom/src/av1/decoder/decodemv.c @@ -36,40 +36,57 @@ static PREDICTION_MODE read_intra_mode(aom_reader *r, aom_cdf_prob *cdf) { return (PREDICTION_MODE)aom_read_symbol(r, cdf, INTRA_MODES, ACCT_STR); } -static void read_cdef(AV1_COMMON *cm, aom_reader *r, MACROBLOCKD *const xd, - int mi_col, int mi_row) { - MB_MODE_INFO *const mbmi = xd->mi[0]; - if (cm->coded_lossless) return; - if (cm->allow_intrabc) { - assert(cm->cdef_bits == 0); +static void read_cdef(AV1_COMMON *cm, aom_reader *r, MACROBLOCKD *const xd) { + const int skip = xd->mi[0]->skip; + if (cm->features.coded_lossless) return; + if (cm->features.allow_intrabc) { + assert(cm->cdef_info.cdef_bits == 0); return; } - if (!(mi_col & (cm->seq_params.mib_size - 1)) && - !(mi_row & (cm->seq_params.mib_size - 1))) { // Top left? - xd->cdef_preset[0] = xd->cdef_preset[1] = xd->cdef_preset[2] = - xd->cdef_preset[3] = -1; + // At the start of a superblock, mark that we haven't yet read CDEF strengths + // for any of the CDEF units contained in this superblock. + const int sb_mask = (cm->seq_params.mib_size - 1); + const int mi_row_in_sb = (xd->mi_row & sb_mask); + const int mi_col_in_sb = (xd->mi_col & sb_mask); + if (mi_row_in_sb == 0 && mi_col_in_sb == 0) { + xd->cdef_transmitted[0] = xd->cdef_transmitted[1] = + xd->cdef_transmitted[2] = xd->cdef_transmitted[3] = false; } - // Read CDEF param at the first non-skip coding block - const int mask = (1 << (6 - MI_SIZE_LOG2)); - const int m = ~(mask - 1); - const int index = cm->seq_params.sb_size == BLOCK_128X128 - ? !!(mi_col & mask) + 2 * !!(mi_row & mask) + + // CDEF unit size is 64x64 irrespective of the superblock size. + const int cdef_size = 1 << (6 - MI_SIZE_LOG2); + + // Find index of this CDEF unit in this superblock. + const int index_mask = cdef_size; + const int cdef_unit_row_in_sb = ((xd->mi_row & index_mask) != 0); + const int cdef_unit_col_in_sb = ((xd->mi_col & index_mask) != 0); + const int index = (cm->seq_params.sb_size == BLOCK_128X128) + ? cdef_unit_col_in_sb + 2 * cdef_unit_row_in_sb : 0; - cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)] - ->cdef_strength = xd->cdef_preset[index] = - xd->cdef_preset[index] == -1 && !mbmi->skip - ? aom_read_literal(r, cm->cdef_bits, ACCT_STR) - : xd->cdef_preset[index]; + + // Read CDEF strength from the first non-skip coding block in this CDEF unit. + if (!xd->cdef_transmitted[index] && !skip) { + // CDEF strength for this CDEF unit needs to be read into the MB_MODE_INFO + // of the 1st block in this CDEF unit. + const int first_block_mask = ~(cdef_size - 1); + CommonModeInfoParams *const mi_params = &cm->mi_params; + const int grid_idx = + get_mi_grid_idx(mi_params, xd->mi_row & first_block_mask, + xd->mi_col & first_block_mask); + MB_MODE_INFO *const mbmi = mi_params->mi_grid_base[grid_idx]; + mbmi->cdef_strength = + aom_read_literal(r, cm->cdef_info.cdef_bits, ACCT_STR); + xd->cdef_transmitted[index] = true; + } } static int read_delta_qindex(AV1_COMMON *cm, const MACROBLOCKD *xd, - aom_reader *r, MB_MODE_INFO *const mbmi, - int mi_col, int mi_row) { + aom_reader *r, MB_MODE_INFO *const mbmi) { int sign, abs, reduced_delta_qindex = 0; BLOCK_SIZE bsize = mbmi->sb_type; - const int b_col = mi_col & (cm->seq_params.mib_size - 1); - const int b_row = mi_row & (cm->seq_params.mib_size - 1); + const int b_col = xd->mi_col & (cm->seq_params.mib_size - 1); + const int b_row = xd->mi_row & (cm->seq_params.mib_size - 1); const int read_delta_q_flag = (b_col == 0 && b_row == 0); FRAME_CONTEXT *ec_ctx = xd->tile_ctx; @@ -129,20 +146,20 @@ static UV_PREDICTION_MODE read_intra_mode_uv(FRAME_CONTEXT *ec_ctx, return uv_mode; } -static int read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r, - int *signs_out) { - const int joint_sign = +static uint8_t read_cfl_alphas(FRAME_CONTEXT *const ec_ctx, aom_reader *r, + int8_t *signs_out) { + const int8_t joint_sign = aom_read_symbol(r, ec_ctx->cfl_sign_cdf, CFL_JOINT_SIGNS, "cfl:signs"); - int idx = 0; + uint8_t idx = 0; // Magnitudes are only coded for nonzero values if (CFL_SIGN_U(joint_sign) != CFL_SIGN_ZERO) { aom_cdf_prob *cdf_u = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_U(joint_sign)]; - idx = aom_read_symbol(r, cdf_u, CFL_ALPHABET_SIZE, "cfl:alpha_u") + idx = (uint8_t)aom_read_symbol(r, cdf_u, CFL_ALPHABET_SIZE, "cfl:alpha_u") << CFL_ALPHABET_SIZE_LOG2; } if (CFL_SIGN_V(joint_sign) != CFL_SIGN_ZERO) { aom_cdf_prob *cdf_v = ec_ctx->cfl_alpha_cdf[CFL_CONTEXT_V(joint_sign)]; - idx += aom_read_symbol(r, cdf_v, CFL_ALPHABET_SIZE, "cfl:alpha_v"); + idx += (uint8_t)aom_read_symbol(r, cdf_v, CFL_ALPHABET_SIZE, "cfl:alpha_v"); } *signs_out = joint_sign; return idx; @@ -183,7 +200,7 @@ static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd, if (mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV) { for (int idx = 0; idx < 2; ++idx) { if (xd->ref_mv_count[ref_frame_type] > idx + 1) { - uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx); + uint8_t drl_ctx = av1_drl_ctx(xd->weight[ref_frame_type], idx); int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR); mbmi->ref_mv_idx = idx + drl_idx; if (!drl_idx) return; @@ -196,7 +213,7 @@ static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd, // mode is factored in. for (int idx = 1; idx < 3; ++idx) { if (xd->ref_mv_count[ref_frame_type] > idx + 1) { - uint8_t drl_ctx = av1_drl_ctx(xd->ref_mv_stack[ref_frame_type], idx); + uint8_t drl_ctx = av1_drl_ctx(xd->weight[ref_frame_type], idx); int drl_idx = aom_read_symbol(r, ec_ctx->drl_cdf[drl_ctx], 2, ACCT_STR); mbmi->ref_mv_idx = idx + drl_idx - 1; if (!drl_idx) return; @@ -207,11 +224,11 @@ static void read_drl_idx(FRAME_CONTEXT *ec_ctx, MACROBLOCKD *xd, static MOTION_MODE read_motion_mode(AV1_COMMON *cm, MACROBLOCKD *xd, MB_MODE_INFO *mbmi, aom_reader *r) { - if (cm->switchable_motion_mode == 0) return SIMPLE_TRANSLATION; + if (cm->features.switchable_motion_mode == 0) return SIMPLE_TRANSLATION; if (mbmi->skip_mode) return SIMPLE_TRANSLATION; - const MOTION_MODE last_motion_mode_allowed = - motion_mode_allowed(xd->global_motion, xd, mbmi, cm->allow_warped_motion); + const MOTION_MODE last_motion_mode_allowed = motion_mode_allowed( + xd->global_motion, xd, mbmi, cm->features.allow_warped_motion); int motion_mode; if (last_motion_mode_allowed == SIMPLE_TRANSLATION) return SIMPLE_TRANSLATION; @@ -260,9 +277,9 @@ int av1_neg_deinterleave(int diff, int ref, int max) { } static int read_segment_id(AV1_COMMON *const cm, const MACROBLOCKD *const xd, - int mi_row, int mi_col, aom_reader *r, int skip) { + aom_reader *r, int skip) { int cdf_num; - const int pred = av1_get_spatial_seg_pred(cm, xd, mi_row, mi_col, &cdf_num); + const int pred = av1_get_spatial_seg_pred(cm, xd, &cdf_num); if (skip) return pred; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; @@ -286,8 +303,8 @@ static int dec_get_segment_id(const AV1_COMMON *cm, const uint8_t *segment_ids, for (int y = 0; y < y_mis; y++) for (int x = 0; x < x_mis; x++) - segment_id = - AOMMIN(segment_id, segment_ids[mi_offset + y * cm->mi_cols + x]); + segment_id = AOMMIN( + segment_id, segment_ids[mi_offset + y * cm->mi_params.mi_cols + x]); assert(segment_id >= 0 && segment_id < MAX_SEGMENTS); return segment_id; @@ -299,37 +316,40 @@ static void set_segment_id(AV1_COMMON *cm, int mi_offset, int x_mis, int y_mis, for (int y = 0; y < y_mis; y++) for (int x = 0; x < x_mis; x++) - cm->current_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id; + cm->cur_frame->seg_map[mi_offset + y * cm->mi_params.mi_cols + x] = + segment_id; } static int read_intra_segment_id(AV1_COMMON *const cm, - const MACROBLOCKD *const xd, int mi_row, - int mi_col, int bsize, aom_reader *r, - int skip) { + const MACROBLOCKD *const xd, int bsize, + aom_reader *r, int skip) { struct segmentation *const seg = &cm->seg; if (!seg->enabled) return 0; // Default for disabled segmentation - assert(seg->update_map && !seg->temporal_update); - const int mi_offset = mi_row * cm->mi_cols + mi_col; + const CommonModeInfoParams *const mi_params = &cm->mi_params; + const int mi_row = xd->mi_row; + const int mi_col = xd->mi_col; + const int mi_offset = mi_row * mi_params->mi_cols + mi_col; const int bw = mi_size_wide[bsize]; const int bh = mi_size_high[bsize]; - const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw); - const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh); - const int segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, skip); + const int x_mis = AOMMIN(mi_params->mi_cols - mi_col, bw); + const int y_mis = AOMMIN(mi_params->mi_rows - mi_row, bh); + const int segment_id = read_segment_id(cm, xd, r, skip); set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); return segment_id; } -static void copy_segment_id(const AV1_COMMON *cm, +static void copy_segment_id(const CommonModeInfoParams *const mi_params, const uint8_t *last_segment_ids, uint8_t *current_segment_ids, int mi_offset, int x_mis, int y_mis) { for (int y = 0; y < y_mis; y++) for (int x = 0; x < x_mis; x++) - current_segment_ids[mi_offset + y * cm->mi_cols + x] = - last_segment_ids ? last_segment_ids[mi_offset + y * cm->mi_cols + x] - : 0; + current_segment_ids[mi_offset + y * mi_params->mi_cols + x] = + last_segment_ids + ? last_segment_ids[mi_offset + y * mi_params->mi_cols + x] + : 0; } static int get_predicted_segment_id(AV1_COMMON *const cm, int mi_offset, @@ -340,22 +360,24 @@ static int get_predicted_segment_id(AV1_COMMON *const cm, int mi_offset, } static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_row, int mi_col, int preskip, - aom_reader *r) { + int preskip, aom_reader *r) { struct segmentation *const seg = &cm->seg; + const CommonModeInfoParams *const mi_params = &cm->mi_params; MB_MODE_INFO *const mbmi = xd->mi[0]; - const int mi_offset = mi_row * cm->mi_cols + mi_col; + const int mi_row = xd->mi_row; + const int mi_col = xd->mi_col; + const int mi_offset = mi_row * mi_params->mi_cols + mi_col; const int bw = mi_size_wide[mbmi->sb_type]; const int bh = mi_size_high[mbmi->sb_type]; // TODO(slavarnway): move x_mis, y_mis into xd ????? - const int x_mis = AOMMIN(cm->mi_cols - mi_col, bw); - const int y_mis = AOMMIN(cm->mi_rows - mi_row, bh); + const int x_mis = AOMMIN(mi_params->mi_cols - mi_col, bw); + const int y_mis = AOMMIN(mi_params->mi_rows - mi_row, bh); if (!seg->enabled) return 0; // Default for disabled segmentation if (!seg->update_map) { - copy_segment_id(cm, cm->last_frame_seg_map, cm->current_frame_seg_map, + copy_segment_id(mi_params, cm->last_frame_seg_map, cm->cur_frame->seg_map, mi_offset, x_mis, y_mis); return get_predicted_segment_id(cm, mi_offset, x_mis, y_mis); } @@ -364,12 +386,11 @@ static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd, if (preskip) { if (!seg->segid_preskip) return 0; } else { - if (seg->segid_preskip) return mbmi->segment_id; if (mbmi->skip) { if (seg->temporal_update) { mbmi->seg_id_predicted = 0; } - segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 1); + segment_id = read_segment_id(cm, xd, r, 1); set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); return segment_id; } @@ -384,10 +405,10 @@ static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd, if (mbmi->seg_id_predicted) { segment_id = get_predicted_segment_id(cm, mi_offset, x_mis, y_mis); } else { - segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0); + segment_id = read_segment_id(cm, xd, r, 0); } } else { - segment_id = read_segment_id(cm, xd, mi_row, mi_col, r, 0); + segment_id = read_segment_id(cm, xd, r, 0); } set_segment_id(cm, mi_offset, x_mis, y_mis, segment_id); return segment_id; @@ -395,7 +416,7 @@ static int read_inter_segment_id(AV1_COMMON *const cm, MACROBLOCKD *const xd, static int read_skip_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, int segment_id, aom_reader *r) { - if (!cm->skip_mode_flag) return 0; + if (!cm->current_frame.skip_mode_info.skip_mode_flag) return 0; if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) { return 0; @@ -539,11 +560,11 @@ static void read_palette_colors_uv(MACROBLOCKD *const xd, int bit_depth, } static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_row, int mi_col, aom_reader *r) { + aom_reader *r) { const int num_planes = av1_num_planes(cm); MB_MODE_INFO *const mbmi = xd->mi[0]; const BLOCK_SIZE bsize = mbmi->sb_type; - assert(av1_allow_palette(cm->allow_screen_content_tools, bsize)); + assert(av1_allow_palette(cm->features.allow_screen_content_tools, bsize)); PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info; const int bsize_ctx = av1_get_palette_bsize_ctx(bsize); @@ -560,9 +581,7 @@ static void read_palette_mode_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, read_palette_colors_y(xd, cm->seq_params.bit_depth, pmi, r); } } - if (num_planes > 1 && mbmi->uv_mode == UV_DC_PRED && - is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y)) { + if (num_planes > 1 && mbmi->uv_mode == UV_DC_PRED && xd->is_chroma_ref) { const int palette_uv_mode_ctx = (pmi->palette_size[0] > 0); const int modev = aom_read_symbol( r, xd->tile_ctx->palette_uv_mode_cdf[palette_uv_mode_ctx], 2, ACCT_STR); @@ -602,9 +621,8 @@ static void read_filter_intra_mode_info(const AV1_COMMON *const cm, void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row, int blk_col, TX_SIZE tx_size, aom_reader *r) { MB_MODE_INFO *mbmi = xd->mi[0]; - const int txk_type_idx = - av1_get_txk_type_index(mbmi->sb_type, blk_row, blk_col); - TX_TYPE *tx_type = &mbmi->txk_type[txk_type_idx]; + uint8_t *tx_type = + &xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col]; *tx_type = DCT_DCT; // No need to read transform type if block is skipped. @@ -612,16 +630,16 @@ void av1_read_tx_type(const AV1_COMMON *const cm, MACROBLOCKD *xd, int blk_row, return; // No need to read transform type for lossless mode(qindex==0). - const int qindex = - cm->seg.enabled ? xd->qindex[mbmi->segment_id] : cm->base_qindex; - if (qindex <= 0) return; + const int qindex = xd->qindex[mbmi->segment_id]; + if (qindex == 0) return; const int inter_block = is_inter_block(mbmi); - if (get_ext_tx_types(tx_size, inter_block, cm->reduced_tx_set_used) > 1) { - const TxSetType tx_set_type = - av1_get_ext_tx_set_type(tx_size, inter_block, cm->reduced_tx_set_used); + if (get_ext_tx_types(tx_size, inter_block, cm->features.reduced_tx_set_used) > + 1) { + const TxSetType tx_set_type = av1_get_ext_tx_set_type( + tx_size, inter_block, cm->features.reduced_tx_set_used); const int eset = - get_ext_tx_set(tx_size, inter_block, cm->reduced_tx_set_used); + get_ext_tx_set(tx_size, inter_block, cm->features.reduced_tx_set_used); // eset == 0 should correspond to a set with only DCT_DCT and // there is no need to read the tx_type assert(eset != 0); @@ -667,7 +685,7 @@ static INLINE int assign_dv(AV1_COMMON *cm, MACROBLOCKD *xd, int_mv *mv, } static void read_intrabc_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_row, int mi_col, aom_reader *r) { + aom_reader *r) { MB_MODE_INFO *const mbmi = xd->mi[0]; FRAME_CONTEXT *ec_ctx = xd->tile_ctx; mbmi->use_intrabc = aom_read_symbol(r, ec_ctx->intrabc_cdf, 2, ACCT_STR); @@ -680,10 +698,9 @@ static void read_intrabc_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES]; int_mv ref_mvs[INTRA_FRAME + 1][MAX_MV_REF_CANDIDATES]; - int_mv global_mvs[REF_FRAMES]; av1_find_mv_refs(cm, xd, mbmi, INTRA_FRAME, xd->ref_mv_count, - xd->ref_mv_stack, ref_mvs, global_mvs, mi_row, mi_col, + xd->ref_mv_stack, xd->weight, ref_mvs, /*global_mvs=*/NULL, inter_mode_ctx); int_mv nearestmv, nearmv; @@ -691,17 +708,17 @@ static void read_intrabc_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, av1_find_best_ref_mvs(0, ref_mvs[INTRA_FRAME], &nearestmv, &nearmv, 0); int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv; if (dv_ref.as_int == 0) - av1_find_ref_dv(&dv_ref, &xd->tile, cm->seq_params.mib_size, mi_row, - mi_col); + av1_find_ref_dv(&dv_ref, &xd->tile, cm->seq_params.mib_size, xd->mi_row); // Ref DV should not have sub-pel. int valid_dv = (dv_ref.as_mv.col & 7) == 0 && (dv_ref.as_mv.row & 7) == 0; dv_ref.as_mv.col = (dv_ref.as_mv.col >> 3) * 8; dv_ref.as_mv.row = (dv_ref.as_mv.row >> 3) * 8; - valid_dv = valid_dv && assign_dv(cm, xd, &mbmi->mv[0], &dv_ref, mi_row, - mi_col, bsize, r); + valid_dv = valid_dv && assign_dv(cm, xd, &mbmi->mv[0], &dv_ref, xd->mi_row, + xd->mi_col, bsize, r); if (!valid_dv) { // Intra bc motion vectors are not valid - signal corrupt frame - aom_merge_corrupted_flag(&xd->corrupted, 1); + aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, + "Invalid intrabc dv"); } } } @@ -709,17 +726,20 @@ static void read_intrabc_info(AV1_COMMON *const cm, MACROBLOCKD *const xd, // If delta q is present, reads delta_q index. // Also reads delta_q loop filter levels, if present. static void read_delta_q_params(AV1_COMMON *const cm, MACROBLOCKD *const xd, - const int mi_row, const int mi_col, aom_reader *r) { - if (cm->delta_q_present_flag) { + DeltaQInfo *const delta_q_info = &cm->delta_q_info; + + if (delta_q_info->delta_q_present_flag) { MB_MODE_INFO *const mbmi = xd->mi[0]; xd->current_qindex += - read_delta_qindex(cm, xd, r, mbmi, mi_col, mi_row) * cm->delta_q_res; + read_delta_qindex(cm, xd, r, mbmi) * delta_q_info->delta_q_res; /* Normative: Clamp to [1,MAXQ] to not interfere with lossless mode */ xd->current_qindex = clamp(xd->current_qindex, 1, MAXQ); FRAME_CONTEXT *const ec_ctx = xd->tile_ctx; - if (cm->delta_lf_present_flag) { - if (cm->delta_lf_multi) { + if (delta_q_info->delta_lf_present_flag) { + const int mi_row = xd->mi_row; + const int mi_col = xd->mi_col; + if (delta_q_info->delta_lf_multi) { const int frame_lf_count = av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { @@ -727,7 +747,7 @@ static void read_delta_q_params(AV1_COMMON *const cm, MACROBLOCKD *const xd, xd->delta_lf[lf_id] + read_delta_lflevel(cm, r, ec_ctx->delta_lf_multi_cdf[lf_id], mbmi, mi_col, mi_row) * - cm->delta_lf_res; + delta_q_info->delta_lf_res; mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id] = clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); } @@ -735,7 +755,7 @@ static void read_delta_q_params(AV1_COMMON *const cm, MACROBLOCKD *const xd, const int tmp_lvl = xd->delta_lf_from_base + read_delta_lflevel(cm, r, ec_ctx->delta_lf_cdf, mbmi, mi_col, mi_row) * - cm->delta_lf_res; + delta_q_info->delta_lf_res; mbmi->delta_lf_from_base = xd->delta_lf_from_base = clamp(tmp_lvl, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); } @@ -744,8 +764,7 @@ static void read_delta_q_params(AV1_COMMON *const cm, MACROBLOCKD *const xd, } static void read_intra_frame_mode_info(AV1_COMMON *const cm, - MACROBLOCKD *const xd, int mi_row, - int mi_col, aom_reader *r) { + MACROBLOCKD *const xd, aom_reader *r) { MB_MODE_INFO *const mbmi = xd->mi[0]; const MB_MODE_INFO *above_mi = xd->above_mbmi; const MB_MODE_INFO *left_mi = xd->left_mbmi; @@ -755,18 +774,16 @@ static void read_intra_frame_mode_info(AV1_COMMON *const cm, FRAME_CONTEXT *ec_ctx = xd->tile_ctx; if (seg->segid_preskip) - mbmi->segment_id = - read_intra_segment_id(cm, xd, mi_row, mi_col, bsize, r, 0); + mbmi->segment_id = read_intra_segment_id(cm, xd, bsize, r, 0); mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r); if (!seg->segid_preskip) - mbmi->segment_id = - read_intra_segment_id(cm, xd, mi_row, mi_col, bsize, r, mbmi->skip); + mbmi->segment_id = read_intra_segment_id(cm, xd, bsize, r, mbmi->skip); - read_cdef(cm, r, xd, mi_col, mi_row); + read_cdef(cm, r, xd); - read_delta_q_params(cm, xd, mi_row, mi_col, r); + read_delta_q_params(cm, xd, r); mbmi->current_qindex = xd->current_qindex; @@ -776,12 +793,14 @@ static void read_intra_frame_mode_info(AV1_COMMON *const cm, mbmi->palette_mode_info.palette_size[1] = 0; mbmi->filter_intra_mode_info.use_filter_intra = 0; - xd->above_txfm_context = cm->above_txfm_context[xd->tile.tile_row] + mi_col; + const int mi_row = xd->mi_row; + const int mi_col = xd->mi_col; + xd->above_txfm_context = cm->above_contexts.txfm[xd->tile.tile_row] + mi_col; xd->left_txfm_context = xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); if (av1_allow_intrabc(cm)) { - read_intrabc_info(cm, xd, mi_row, mi_col, r); + read_intrabc_info(cm, xd, r); if (is_intrabc_block(mbmi)) return; } @@ -793,10 +812,7 @@ static void read_intra_frame_mode_info(AV1_COMMON *const cm, ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED]) : 0; - if (!cm->seq_params.monochrome && - is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y)) { - xd->cfl.is_chroma_reference = 1; + if (!cm->seq_params.monochrome && xd->is_chroma_ref) { mbmi->uv_mode = read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode); if (mbmi->uv_mode == UV_CFL_PRED) { @@ -810,12 +826,11 @@ static void read_intra_frame_mode_info(AV1_COMMON *const cm, } else { // Avoid decoding angle_info if there is is no chroma prediction mbmi->uv_mode = UV_DC_PRED; - xd->cfl.is_chroma_reference = 0; } xd->cfl.store_y = store_cfl_required(cm, xd); - if (av1_allow_palette(cm->allow_screen_content_tools, bsize)) - read_palette_mode_info(cm, xd, mi_row, mi_col, r); + if (av1_allow_palette(cm->features.allow_screen_content_tools, bsize)) + read_palette_mode_info(cm, xd, r); read_filter_intra_mode_info(cm, xd, r); } @@ -882,14 +897,14 @@ static REFERENCE_MODE read_block_reference_mode(AV1_COMMON *cm, const MACROBLOCKD *xd, aom_reader *r) { if (!is_comp_ref_allowed(xd->mi[0]->sb_type)) return SINGLE_REFERENCE; - if (cm->reference_mode == REFERENCE_MODE_SELECT) { + if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) { const int ctx = av1_get_reference_mode_context(xd); const REFERENCE_MODE mode = (REFERENCE_MODE)aom_read_symbol( r, xd->tile_ctx->comp_inter_cdf[ctx], 2, ACCT_STR); return mode; // SINGLE_REFERENCE or COMPOUND_REFERENCE } else { - assert(cm->reference_mode == SINGLE_REFERENCE); - return cm->reference_mode; + assert(cm->current_frame.reference_mode == SINGLE_REFERENCE); + return cm->current_frame.reference_mode; } } @@ -907,8 +922,8 @@ static COMP_REFERENCE_TYPE read_comp_reference_type(const MACROBLOCKD *xd, static void set_ref_frames_for_skip_mode(AV1_COMMON *const cm, MV_REFERENCE_FRAME ref_frame[2]) { - ref_frame[0] = LAST_FRAME + cm->ref_frame_idx_0; - ref_frame[1] = LAST_FRAME + cm->ref_frame_idx_1; + ref_frame[0] = LAST_FRAME + cm->current_frame.skip_mode_info.ref_frame_idx_0; + ref_frame[1] = LAST_FRAME + cm->current_frame.skip_mode_info.ref_frame_idx_1; } // Read the referncence frame @@ -966,19 +981,19 @@ static void read_ref_frames(AV1_COMMON *const cm, MACROBLOCKD *const xd, // Decode forward references. if (!bit) { const int bit1 = READ_REF_BIT(comp_ref_p1); - ref_frame[!idx] = cm->comp_fwd_ref[bit1 ? 1 : 0]; + ref_frame[!idx] = bit1 ? LAST2_FRAME : LAST_FRAME; } else { const int bit2 = READ_REF_BIT(comp_ref_p2); - ref_frame[!idx] = cm->comp_fwd_ref[bit2 ? 3 : 2]; + ref_frame[!idx] = bit2 ? GOLDEN_FRAME : LAST3_FRAME; } // Decode backward references. const int bit_bwd = READ_REF_BIT(comp_bwdref_p); if (!bit_bwd) { const int bit1_bwd = READ_REF_BIT(comp_bwdref_p1); - ref_frame[idx] = cm->comp_bwd_ref[bit1_bwd]; + ref_frame[idx] = bit1_bwd ? ALTREF2_FRAME : BWDREF_FRAME; } else { - ref_frame[idx] = cm->comp_bwd_ref[2]; + ref_frame[idx] = ALTREF_FRAME; } } else if (mode == SINGLE_REFERENCE) { const int bit0 = READ_REF_BIT(single_ref_p1); @@ -1008,38 +1023,39 @@ static void read_ref_frames(AV1_COMMON *const cm, MACROBLOCKD *const xd, } } -static INLINE void read_mb_interp_filter(AV1_COMMON *const cm, - MACROBLOCKD *const xd, +static INLINE void read_mb_interp_filter(const MACROBLOCKD *const xd, + InterpFilter interp_filter, + bool enable_dual_filter, MB_MODE_INFO *const mbmi, aom_reader *r) { FRAME_CONTEXT *ec_ctx = xd->tile_ctx; if (!av1_is_interp_needed(xd)) { - set_default_interp_filters(mbmi, cm->interp_filter); + set_default_interp_filters(mbmi, interp_filter); return; } - if (cm->interp_filter != SWITCHABLE) { - mbmi->interp_filters = av1_broadcast_interp_filter(cm->interp_filter); + if (interp_filter != SWITCHABLE) { + mbmi->interp_filters = av1_broadcast_interp_filter(interp_filter); } else { InterpFilter ref0_filter[2] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR }; for (int dir = 0; dir < 2; ++dir) { const int ctx = av1_get_pred_context_switchable_interp(xd, dir); ref0_filter[dir] = (InterpFilter)aom_read_symbol( r, ec_ctx->switchable_interp_cdf[ctx], SWITCHABLE_FILTERS, ACCT_STR); - if (cm->seq_params.enable_dual_filter == 0) { + if (!enable_dual_filter) { ref0_filter[1] = ref0_filter[0]; break; } } // The index system works as: (0, 1) -> (vertical, horizontal) filter types - mbmi->interp_filters = - av1_make_interp_filters(ref0_filter[0], ref0_filter[1]); + mbmi->interp_filters.as_filters.x_filter = ref0_filter[1]; + mbmi->interp_filters.as_filters.y_filter = ref0_filter[0]; } } -static void read_intra_block_mode_info(AV1_COMMON *const cm, const int mi_row, - const int mi_col, MACROBLOCKD *const xd, +static void read_intra_block_mode_info(AV1_COMMON *const cm, + MACROBLOCKD *const xd, MB_MODE_INFO *const mbmi, aom_reader *r) { const BLOCK_SIZE bsize = mbmi->sb_type; @@ -1056,11 +1072,7 @@ static void read_intra_block_mode_info(AV1_COMMON *const cm, const int mi_row, use_angle_delta && av1_is_directional_mode(mbmi->mode) ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED]) : 0; - const int has_chroma = - is_chroma_reference(mi_row, mi_col, bsize, xd->plane[1].subsampling_x, - xd->plane[1].subsampling_y); - xd->cfl.is_chroma_reference = has_chroma; - if (!cm->seq_params.monochrome && has_chroma) { + if (!cm->seq_params.monochrome && xd->is_chroma_ref) { mbmi->uv_mode = read_intra_mode_uv(ec_ctx, r, is_cfl_allowed(xd), mbmi->mode); if (mbmi->uv_mode == UV_CFL_PRED) { @@ -1080,8 +1092,8 @@ static void read_intra_block_mode_info(AV1_COMMON *const cm, const int mi_row, mbmi->palette_mode_info.palette_size[0] = 0; mbmi->palette_mode_info.palette_size[1] = 0; - if (av1_allow_palette(cm->allow_screen_content_tools, bsize)) - read_palette_mode_info(cm, xd, mi_row, mi_col, r); + if (av1_allow_palette(cm->features.allow_screen_content_tools, bsize)) + read_palette_mode_info(cm, xd, r); read_filter_intra_mode_info(cm, xd, r); } @@ -1095,12 +1107,13 @@ static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd, PREDICTION_MODE mode, MV_REFERENCE_FRAME ref_frame[2], int_mv mv[2], int_mv ref_mv[2], int_mv nearest_mv[2], - int_mv near_mv[2], int mi_row, int mi_col, - int is_compound, int allow_hp, aom_reader *r) { + int_mv near_mv[2], int is_compound, int allow_hp, + aom_reader *r) { FRAME_CONTEXT *ec_ctx = xd->tile_ctx; MB_MODE_INFO *mbmi = xd->mi[0]; BLOCK_SIZE bsize = mbmi->sb_type; - if (cm->cur_frame_force_integer_mv) { + FeatureFlags *const features = &cm->features; + if (features->cur_frame_force_integer_mv) { allow_hp = MV_SUBPEL_NONE; } switch (mode) { @@ -1118,11 +1131,11 @@ static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd, break; } case GLOBALMV: { - mv[0].as_int = - gm_get_motion_vector(&cm->global_motion[ref_frame[0]], - cm->allow_high_precision_mv, bsize, mi_col, - mi_row, cm->cur_frame_force_integer_mv) - .as_int; + mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]], + features->allow_high_precision_mv, + bsize, xd->mi_col, xd->mi_row, + features->cur_frame_force_integer_mv) + .as_int; break; } case NEW_NEWMV: { @@ -1175,16 +1188,16 @@ static INLINE int assign_mv(AV1_COMMON *cm, MACROBLOCKD *xd, } case GLOBAL_GLOBALMV: { assert(is_compound); - mv[0].as_int = - gm_get_motion_vector(&cm->global_motion[ref_frame[0]], - cm->allow_high_precision_mv, bsize, mi_col, - mi_row, cm->cur_frame_force_integer_mv) - .as_int; - mv[1].as_int = - gm_get_motion_vector(&cm->global_motion[ref_frame[1]], - cm->allow_high_precision_mv, bsize, mi_col, - mi_row, cm->cur_frame_force_integer_mv) - .as_int; + mv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[0]], + features->allow_high_precision_mv, + bsize, xd->mi_col, xd->mi_row, + features->cur_frame_force_integer_mv) + .as_int; + mv[1].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame[1]], + features->allow_high_precision_mv, + bsize, xd->mi_col, xd->mi_row, + features->cur_frame_force_integer_mv) + .as_int; break; } default: { return 0; } @@ -1231,16 +1244,16 @@ static void dec_dump_logs(AV1_COMMON *cm, MB_MODE_INFO *const mbmi, int mi_row, } #define FRAME_TO_CHECK 11 - if (cm->current_video_frame == FRAME_TO_CHECK && cm->show_frame == 1) { + if (cm->current_frame.frame_number == FRAME_TO_CHECK && cm->show_frame == 1) { printf( "=== DECODER ===: " "Frame=%d, (mi_row,mi_col)=(%d,%d), skip_mode=%d, mode=%d, bsize=%d, " "show_frame=%d, mv[0]=(%d,%d), mv[1]=(%d,%d), ref[0]=%d, " "ref[1]=%d, motion_mode=%d, mode_ctx=%d, " "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d, tx_size=%d\n", - cm->current_video_frame, mi_row, mi_col, mbmi->skip_mode, mbmi->mode, - mbmi->sb_type, cm->show_frame, mv[0].as_mv.row, mv[0].as_mv.col, - mv[1].as_mv.row, mv[1].as_mv.col, mbmi->ref_frame[0], + cm->current_frame.frame_number, mi_row, mi_col, mbmi->skip_mode, + mbmi->mode, mbmi->sb_type, cm->show_frame, mv[0].as_mv.row, + mv[0].as_mv.col, mv[1].as_mv.row, mv[1].as_mv.col, mbmi->ref_frame[0], mbmi->ref_frame[1], mbmi->motion_mode, mode_ctx, newmv_ctx, zeromv_ctx, refmv_ctx, mbmi->tx_size); } @@ -1249,11 +1262,12 @@ static void dec_dump_logs(AV1_COMMON *cm, MB_MODE_INFO *const mbmi, int mi_row, static void read_inter_block_mode_info(AV1Decoder *const pbi, MACROBLOCKD *const xd, - MB_MODE_INFO *const mbmi, int mi_row, - int mi_col, aom_reader *r) { + MB_MODE_INFO *const mbmi, + aom_reader *r) { AV1_COMMON *const cm = &pbi->common; + FeatureFlags *const features = &cm->features; const BLOCK_SIZE bsize = mbmi->sb_type; - const int allow_hp = cm->allow_high_precision_mv; + const int allow_hp = features->allow_high_precision_mv; int_mv nearestmv[2], nearmv[2]; int_mv ref_mvs[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES] = { { { 0 } } }; int16_t inter_mode_ctx[MODE_CTX_REF_FRAMES]; @@ -1269,12 +1283,10 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, read_ref_frames(cm, xd, r, mbmi->segment_id, mbmi->ref_frame); const int is_compound = has_second_ref(mbmi); - MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame); - int_mv global_mvs[REF_FRAMES]; + const MV_REFERENCE_FRAME ref_frame = av1_ref_frame_type(mbmi->ref_frame); av1_find_mv_refs(cm, xd, mbmi, ref_frame, xd->ref_mv_count, xd->ref_mv_stack, - ref_mvs, global_mvs, mi_row, mi_col, inter_mode_ctx); + xd->weight, ref_mvs, /*global_mvs=*/NULL, inter_mode_ctx); - int mode_ctx = av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame); mbmi->ref_mv_idx = 0; if (mbmi->skip_mode) { @@ -1285,6 +1297,8 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_GLOBALMV)) { mbmi->mode = GLOBALMV; } else { + const int mode_ctx = + av1_mode_context_analyzer(inter_mode_ctx, mbmi->ref_frame); if (is_compound) mbmi->mode = read_inter_compound_mode(xd, r, mode_ctx); else @@ -1303,32 +1317,29 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, if (!is_compound && mbmi->mode != GLOBALMV) { av1_find_best_ref_mvs(allow_hp, ref_mvs[mbmi->ref_frame[0]], &nearestmv[0], - &nearmv[0], cm->cur_frame_force_integer_mv); + &nearmv[0], features->cur_frame_force_integer_mv); } if (is_compound && mbmi->mode != GLOBAL_GLOBALMV) { - int ref_mv_idx = mbmi->ref_mv_idx + 1; + const int ref_mv_idx = mbmi->ref_mv_idx + 1; nearestmv[0] = xd->ref_mv_stack[ref_frame][0].this_mv; nearestmv[1] = xd->ref_mv_stack[ref_frame][0].comp_mv; nearmv[0] = xd->ref_mv_stack[ref_frame][ref_mv_idx].this_mv; nearmv[1] = xd->ref_mv_stack[ref_frame][ref_mv_idx].comp_mv; lower_mv_precision(&nearestmv[0].as_mv, allow_hp, - cm->cur_frame_force_integer_mv); + features->cur_frame_force_integer_mv); lower_mv_precision(&nearestmv[1].as_mv, allow_hp, - cm->cur_frame_force_integer_mv); + features->cur_frame_force_integer_mv); lower_mv_precision(&nearmv[0].as_mv, allow_hp, - cm->cur_frame_force_integer_mv); + features->cur_frame_force_integer_mv); lower_mv_precision(&nearmv[1].as_mv, allow_hp, - cm->cur_frame_force_integer_mv); + features->cur_frame_force_integer_mv); } else if (mbmi->ref_mv_idx > 0 && mbmi->mode == NEARMV) { - int_mv cur_mv = + nearmv[0] = xd->ref_mv_stack[mbmi->ref_frame[0]][1 + mbmi->ref_mv_idx].this_mv; - nearmv[0] = cur_mv; } - int_mv ref_mv[2]; - ref_mv[0] = nearestmv[0]; - ref_mv[1] = nearestmv[1]; + int_mv ref_mv[2] = { nearestmv[0], nearestmv[1] }; if (is_compound) { int ref_mv_idx = mbmi->ref_mv_idx; @@ -1351,16 +1362,12 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, } } - if (mbmi->skip_mode) { - assert(mbmi->mode == NEAREST_NEARESTMV); - mbmi->mv[0].as_int = nearestmv[0].as_int; - mbmi->mv[1].as_int = nearestmv[1].as_int; - } else { - int mv_corrupted_flag = - !assign_mv(cm, xd, mbmi->mode, mbmi->ref_frame, mbmi->mv, ref_mv, - nearestmv, nearmv, mi_row, mi_col, is_compound, allow_hp, r); - aom_merge_corrupted_flag(&xd->corrupted, mv_corrupted_flag); - } + if (mbmi->skip_mode) assert(mbmi->mode == NEAREST_NEARESTMV); + + const int mv_corrupted_flag = + !assign_mv(cm, xd, mbmi->mode, mbmi->ref_frame, mbmi->mv, ref_mv, + nearestmv, nearmv, is_compound, allow_hp, r); + aom_merge_corrupted_flag(&xd->corrupted, mv_corrupted_flag); mbmi->use_wedge_interintra = 0; if (cm->seq_params.enable_interintra_compound && !mbmi->skip_mode && @@ -1377,13 +1384,12 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, mbmi->angle_delta[PLANE_TYPE_Y] = 0; mbmi->angle_delta[PLANE_TYPE_UV] = 0; mbmi->filter_intra_mode_info.use_filter_intra = 0; - if (is_interintra_wedge_used(bsize)) { + if (av1_is_wedge_used(bsize)) { mbmi->use_wedge_interintra = aom_read_symbol( r, ec_ctx->wedge_interintra_cdf[bsize], 2, ACCT_STR); if (mbmi->use_wedge_interintra) { - mbmi->interintra_wedge_index = - aom_read_symbol(r, ec_ctx->wedge_idx_cdf[bsize], 16, ACCT_STR); - mbmi->interintra_wedge_sign = 0; + mbmi->interintra_wedge_index = (int8_t)aom_read_symbol( + r, ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES, ACCT_STR); } } } @@ -1391,16 +1397,15 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) { const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref]; - RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME]; - - xd->block_refs[ref] = ref_buf; + xd->block_ref_scale_factors[ref] = get_ref_scale_factors_const(cm, frame); } mbmi->motion_mode = SIMPLE_TRANSLATION; if (is_motion_variation_allowed_bsize(mbmi->sb_type) && !mbmi->skip_mode && - !has_second_ref(mbmi)) - mbmi->num_proj_ref = findSamples(cm, xd, mi_row, mi_col, pts, pts_inref); - av1_count_overlappable_neighbors(cm, xd, mi_row, mi_col); + !has_second_ref(mbmi)) { + mbmi->num_proj_ref = av1_findSamples(cm, xd, pts, pts_inref); + } + av1_count_overlappable_neighbors(cm, xd); if (mbmi->ref_frame[1] != INTRA_FRAME) mbmi->motion_mode = read_motion_mode(cm, xd, mbmi, r); @@ -1417,38 +1422,43 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, if (masked_compound_used) { const int ctx_comp_group_idx = get_comp_group_idx_context(xd); - mbmi->comp_group_idx = aom_read_symbol( + mbmi->comp_group_idx = (uint8_t)aom_read_symbol( r, ec_ctx->comp_group_idx_cdf[ctx_comp_group_idx], 2, ACCT_STR); } if (mbmi->comp_group_idx == 0) { - if (cm->seq_params.enable_jnt_comp) { + if (cm->seq_params.order_hint_info.enable_dist_wtd_comp) { const int comp_index_ctx = get_comp_index_context(cm, xd); - mbmi->compound_idx = aom_read_symbol( + mbmi->compound_idx = (uint8_t)aom_read_symbol( r, ec_ctx->compound_index_cdf[comp_index_ctx], 2, ACCT_STR); + mbmi->interinter_comp.type = + mbmi->compound_idx ? COMPOUND_AVERAGE : COMPOUND_DISTWTD; } else { // Distance-weighted compound is disabled, so always use average mbmi->compound_idx = 1; + mbmi->interinter_comp.type = COMPOUND_AVERAGE; } } else { - assert(cm->reference_mode != SINGLE_REFERENCE && + assert(cm->current_frame.reference_mode != SINGLE_REFERENCE && is_inter_compound_mode(mbmi->mode) && mbmi->motion_mode == SIMPLE_TRANSLATION); assert(masked_compound_used); // compound_diffwtd, wedge - if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) + if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) { mbmi->interinter_comp.type = - 1 + aom_read_symbol(r, ec_ctx->compound_type_cdf[bsize], - COMPOUND_TYPES - 1, ACCT_STR); - else + COMPOUND_WEDGE + aom_read_symbol(r, + ec_ctx->compound_type_cdf[bsize], + MASKED_COMPOUND_TYPES, ACCT_STR); + } else { mbmi->interinter_comp.type = COMPOUND_DIFFWTD; + } if (mbmi->interinter_comp.type == COMPOUND_WEDGE) { assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize)); - mbmi->interinter_comp.wedge_index = - aom_read_symbol(r, ec_ctx->wedge_idx_cdf[bsize], 16, ACCT_STR); - mbmi->interinter_comp.wedge_sign = aom_read_bit(r, ACCT_STR); + mbmi->interinter_comp.wedge_index = (int8_t)aom_read_symbol( + r, ec_ctx->wedge_idx_cdf[bsize], MAX_WEDGE_TYPES, ACCT_STR); + mbmi->interinter_comp.wedge_sign = (int8_t)aom_read_bit(r, ACCT_STR); } else { assert(mbmi->interinter_comp.type == COMPOUND_DIFFWTD); mbmi->interinter_comp.mask_type = @@ -1457,19 +1467,24 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, } } - read_mb_interp_filter(cm, xd, mbmi, r); + read_mb_interp_filter(xd, features->interp_filter, + cm->seq_params.enable_dual_filter, mbmi, r); + + const int mi_row = xd->mi_row; + const int mi_col = xd->mi_col; if (mbmi->motion_mode == WARPED_CAUSAL) { mbmi->wm_params.wmtype = DEFAULT_WMTYPE; mbmi->wm_params.invalid = 0; - if (mbmi->num_proj_ref > 1) - mbmi->num_proj_ref = selectSamples(&mbmi->mv[0].as_mv, pts, pts_inref, - mbmi->num_proj_ref, bsize); + if (mbmi->num_proj_ref > 1) { + mbmi->num_proj_ref = av1_selectSamples(&mbmi->mv[0].as_mv, pts, pts_inref, + mbmi->num_proj_ref, bsize); + } - if (find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize, - mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col, - &mbmi->wm_params, mi_row, mi_col)) { + if (av1_find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize, + mbmi->mv[0].as_mv.row, mbmi->mv[0].as_mv.col, + &mbmi->wm_params, mi_row, mi_col)) { #if WARPED_MOTION_DEBUG printf("Warning: unexpected warped model from aomenc\n"); #endif @@ -1477,9 +1492,6 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, } } - xd->cfl.is_chroma_reference = - is_chroma_reference(mi_row, mi_col, bsize, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y); xd->cfl.store_y = store_cfl_required(cm, xd); #if DEC_MISMATCH_DEBUG @@ -1488,15 +1500,14 @@ static void read_inter_block_mode_info(AV1Decoder *const pbi, } static void read_inter_frame_mode_info(AV1Decoder *const pbi, - MACROBLOCKD *const xd, int mi_row, - int mi_col, aom_reader *r) { + MACROBLOCKD *const xd, aom_reader *r) { AV1_COMMON *const cm = &pbi->common; MB_MODE_INFO *const mbmi = xd->mi[0]; int inter_block = 1; mbmi->mv[0].as_int = 0; mbmi->mv[1].as_int = 0; - mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, 1, r); + mbmi->segment_id = read_inter_segment_id(cm, xd, 1, r); mbmi->skip_mode = read_skip_mode(cm, xd, mbmi->segment_id, r); @@ -1505,30 +1516,32 @@ static void read_inter_frame_mode_info(AV1Decoder *const pbi, else mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r); - mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, 0, r); + if (!cm->seg.segid_preskip) + mbmi->segment_id = read_inter_segment_id(cm, xd, 0, r); - read_cdef(cm, r, xd, mi_col, mi_row); + read_cdef(cm, r, xd); - read_delta_q_params(cm, xd, mi_row, mi_col, r); + read_delta_q_params(cm, xd, r); if (!mbmi->skip_mode) inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r); mbmi->current_qindex = xd->current_qindex; - xd->above_txfm_context = cm->above_txfm_context[xd->tile.tile_row] + mi_col; + xd->above_txfm_context = + cm->above_contexts.txfm[xd->tile.tile_row] + xd->mi_col; xd->left_txfm_context = - xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); + xd->left_txfm_context_buffer + (xd->mi_row & MAX_MIB_MASK); if (inter_block) - read_inter_block_mode_info(pbi, xd, mbmi, mi_row, mi_col, r); + read_inter_block_mode_info(pbi, xd, mbmi, r); else - read_intra_block_mode_info(cm, mi_row, mi_col, xd, mbmi, r); + read_intra_block_mode_info(cm, xd, mbmi, r); } static void intra_copy_frame_mvs(AV1_COMMON *const cm, int mi_row, int mi_col, int x_mis, int y_mis) { - const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1); + const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, 1); MV_REF *frame_mvs = cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1); x_mis = ROUND_POWER_OF_TWO(x_mis, 1); @@ -1544,17 +1557,19 @@ static void intra_copy_frame_mvs(AV1_COMMON *const cm, int mi_row, int mi_col, } } -void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, int mi_row, - int mi_col, aom_reader *r, int x_mis, int y_mis) { +void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, aom_reader *r, + int x_mis, int y_mis) { AV1_COMMON *const cm = &pbi->common; MB_MODE_INFO *const mi = xd->mi[0]; mi->use_intrabc = 0; if (frame_is_intra_only(cm)) { - read_intra_frame_mode_info(cm, xd, mi_row, mi_col, r); - intra_copy_frame_mvs(cm, mi_row, mi_col, x_mis, y_mis); + read_intra_frame_mode_info(cm, xd, r); + if (pbi->common.seq_params.order_hint_info.enable_ref_frame_mvs) + intra_copy_frame_mvs(cm, xd->mi_row, xd->mi_col, x_mis, y_mis); } else { - read_inter_frame_mode_info(pbi, xd, mi_row, mi_col, r); - av1_copy_frame_mvs(cm, mi, mi_row, mi_col, x_mis, y_mis); + read_inter_frame_mode_info(pbi, xd, r); + if (pbi->common.seq_params.order_hint_info.enable_ref_frame_mvs) + av1_copy_frame_mvs(cm, mi, xd->mi_row, xd->mi_col, x_mis, y_mis); } } diff --git a/media/libaom/src/av1/decoder/decodemv.h b/media/libaom/src/av1/decoder/decodemv.h index 1625e5bd23..289e66ae1e 100644 --- a/media/libaom/src/av1/decoder/decodemv.h +++ b/media/libaom/src/av1/decoder/decodemv.h @@ -20,10 +20,8 @@ extern "C" { #endif -void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, - - int mi_row, int mi_col, aom_reader *r, int x_mis, - int y_mis); +void av1_read_mode_info(AV1Decoder *const pbi, MACROBLOCKD *xd, aom_reader *r, + int x_mis, int y_mis); #ifdef __cplusplus } // extern "C" diff --git a/media/libaom/src/av1/decoder/decoder.c b/media/libaom/src/av1/decoder/decoder.c index a5f4fd67fa..fc5f2cd20d 100644 --- a/media/libaom/src/av1/decoder/decoder.c +++ b/media/libaom/src/av1/decoder/decoder.c @@ -17,6 +17,7 @@ #include "config/aom_dsp_rtcd.h" #include "config/aom_scale_rtcd.h" +#include "aom_dsp/aom_dsp_common.h" #include "aom_mem/aom_mem.h" #include "aom_ports/system_state.h" #include "aom_ports/aom_once.h" @@ -25,8 +26,8 @@ #include "aom_util/aom_thread.h" #include "av1/common/alloccommon.h" +#include "av1/common/av1_common_int.h" #include "av1/common/av1_loopfilter.h" -#include "av1/common/onyxc_int.h" #include "av1/common/quant_common.h" #include "av1/common/reconinter.h" #include "av1/common/reconintra.h" @@ -44,39 +45,59 @@ static void initialize_dec(void) { av1_init_wedge_masks(); } -static void dec_setup_mi(AV1_COMMON *cm) { - cm->mi = cm->mip; - cm->mi_grid_visible = cm->mi_grid_base; - memset(cm->mi_grid_base, 0, - cm->mi_stride * cm->mi_rows * sizeof(*cm->mi_grid_base)); +static void dec_set_mb_mi(CommonModeInfoParams *mi_params, int width, + int height) { + // Ensure that the decoded width and height are both multiples of + // 8 luma pixels (note: this may only be a multiple of 4 chroma pixels if + // subsampling is used). + // This simplifies the implementation of various experiments, + // eg. cdef, which operates on units of 8x8 luma pixels. + const int aligned_width = ALIGN_POWER_OF_TWO(width, 3); + const int aligned_height = ALIGN_POWER_OF_TWO(height, 3); + + mi_params->mi_cols = aligned_width >> MI_SIZE_LOG2; + mi_params->mi_rows = aligned_height >> MI_SIZE_LOG2; + mi_params->mi_stride = calc_mi_size(mi_params->mi_cols); + + mi_params->mb_cols = (mi_params->mi_cols + 2) >> 2; + mi_params->mb_rows = (mi_params->mi_rows + 2) >> 2; + mi_params->MBs = mi_params->mb_rows * mi_params->mb_cols; + + mi_params->mi_alloc_bsize = BLOCK_4X4; + mi_params->mi_alloc_stride = mi_params->mi_stride; + + assert(mi_size_wide[mi_params->mi_alloc_bsize] == + mi_size_high[mi_params->mi_alloc_bsize]); + +#if CONFIG_LPF_MASK + av1_alloc_loop_filter_mask(mi_params); +#endif } -static int av1_dec_alloc_mi(AV1_COMMON *cm, int mi_size) { - cm->mip = aom_calloc(mi_size, sizeof(*cm->mip)); - if (!cm->mip) return 1; - cm->mi_alloc_size = mi_size; - cm->mi_grid_base = - (MB_MODE_INFO **)aom_calloc(mi_size, sizeof(MB_MODE_INFO *)); - if (!cm->mi_grid_base) return 1; - return 0; +static void dec_setup_mi(CommonModeInfoParams *mi_params) { + const int mi_grid_size = + mi_params->mi_stride * calc_mi_size(mi_params->mi_rows); + memset(mi_params->mi_grid_base, 0, + mi_grid_size * sizeof(*mi_params->mi_grid_base)); } -static void dec_free_mi(AV1_COMMON *cm) { - aom_free(cm->mip); - cm->mip = NULL; - aom_free(cm->mi_grid_base); - cm->mi_grid_base = NULL; - cm->mi_alloc_size = 0; +static void dec_free_mi(CommonModeInfoParams *mi_params) { + aom_free(mi_params->mi_alloc); + mi_params->mi_alloc = NULL; + aom_free(mi_params->mi_grid_base); + mi_params->mi_grid_base = NULL; + mi_params->mi_alloc_size = 0; + aom_free(mi_params->tx_type_map); + mi_params->tx_type_map = NULL; } AV1Decoder *av1_decoder_create(BufferPool *const pool) { AV1Decoder *volatile const pbi = aom_memalign(32, sizeof(*pbi)); - AV1_COMMON *volatile const cm = pbi ? &pbi->common : NULL; - - if (!cm) return NULL; - + if (!pbi) return NULL; av1_zero(*pbi); + AV1_COMMON *volatile const cm = &pbi->common; + // The jmp_buf is valid only for the duration of the function that calls // setjmp(). Therefore, this function must reset the 'setjmp' field to 0 // before it returns. @@ -90,33 +111,33 @@ AV1Decoder *av1_decoder_create(BufferPool *const pool) { CHECK_MEM_ERROR(cm, cm->fc, (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->fc))); - CHECK_MEM_ERROR(cm, cm->frame_contexts, - (FRAME_CONTEXT *)aom_memalign( - 32, FRAME_CONTEXTS * sizeof(*cm->frame_contexts))); + CHECK_MEM_ERROR( + cm, cm->default_frame_context, + (FRAME_CONTEXT *)aom_memalign(32, sizeof(*cm->default_frame_context))); memset(cm->fc, 0, sizeof(*cm->fc)); - memset(cm->frame_contexts, 0, FRAME_CONTEXTS * sizeof(*cm->frame_contexts)); + memset(cm->default_frame_context, 0, sizeof(*cm->default_frame_context)); pbi->need_resync = 1; aom_once(initialize_dec); // Initialize the references to not point to any frame buffers. - memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); - memset(&cm->next_ref_frame_map, -1, sizeof(cm->next_ref_frame_map)); + for (int i = 0; i < REF_FRAMES; i++) { + cm->ref_frame_map[i] = NULL; + } - cm->current_video_frame = 0; + cm->current_frame.frame_number = 0; pbi->decoding_first_frame = 1; pbi->common.buffer_pool = pool; cm->seq_params.bit_depth = AOM_BITS_8; - cm->dequant_bit_depth = AOM_BITS_8; - cm->alloc_mi = av1_dec_alloc_mi; - cm->free_mi = dec_free_mi; - cm->setup_mi = dec_setup_mi; + cm->mi_params.free_mi = dec_free_mi; + cm->mi_params.setup_mi = dec_setup_mi; + cm->mi_params.set_mb_mi = dec_set_mb_mi; av1_loop_filter_init(cm); - av1_qm_init(cm); + av1_qm_init(&cm->quant_params, av1_num_planes(cm)); av1_loop_restoration_precal(); #if CONFIG_ACCOUNTING pbi->acct_enabled = 1; @@ -126,6 +147,7 @@ AV1Decoder *av1_decoder_create(BufferPool *const pool) { cm->error.setjmp = 0; aom_get_worker_interface()->init(&pbi->lf_worker); + pbi->lf_worker.thread_name = "aom lf worker"; return pbi; } @@ -157,8 +179,7 @@ void av1_decoder_remove(AV1Decoder *pbi) { if (!pbi) return; // Free the tile list output buffer. - if (pbi->tile_list_output != NULL) aom_free(pbi->tile_list_output); - pbi->tile_list_output = NULL; + aom_free_frame_buffer(&pbi->tile_list_outbuf); aom_get_worker_interface()->end(&pbi->lf_worker); aom_free(pbi->lf_worker.data1); @@ -204,19 +225,16 @@ void av1_decoder_remove(AV1Decoder *pbi) { aom_accounting_clear(&pbi->accounting); #endif av1_free_mc_tmp_buf(&pbi->td); - + aom_img_metadata_array_free(pbi->metadata); aom_free(pbi); } -void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, int mi_row, - int mi_col, aom_reader *r, BLOCK_SIZE bsize, - palette_visitor_fn_t visit) { +void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, + aom_reader *r, palette_visitor_fn_t visit) { if (!is_inter_block(xd->mi[0])) { for (int plane = 0; plane < AOMMIN(2, av1_num_planes(&pbi->common)); ++plane) { - const struct macroblockd_plane *const pd = &xd->plane[plane]; - if (is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, - pd->subsampling_y)) { + if (plane == 0 || xd->is_chroma_ref) { if (xd->mi[0]->palette_mode_info.palette_size[plane]) visit(xd, plane, r); } else { @@ -318,88 +336,85 @@ aom_codec_err_t av1_copy_new_frame_dec(AV1_COMMON *cm, return cm->error.error_code; } -/* If any buffer updating is signaled it should be done here. - Consumes a reference to cm->new_fb_idx. -*/ -static void swap_frame_buffers(AV1Decoder *pbi, int frame_decoded) { +static void release_current_frame(AV1Decoder *pbi) { + AV1_COMMON *const cm = &pbi->common; + BufferPool *const pool = cm->buffer_pool; + + cm->cur_frame->buf.corrupted = 1; + lock_buffer_pool(pool); + decrease_ref_count(cm->cur_frame, pool); + unlock_buffer_pool(pool); + cm->cur_frame = NULL; +} + +// If any buffer updating is signaled it should be done here. +// Consumes a reference to cm->cur_frame. +// +// This functions returns void. It reports failure by setting +// cm->error.error_code. +static void update_frame_buffers(AV1Decoder *pbi, int frame_decoded) { int ref_index = 0, mask; AV1_COMMON *const cm = &pbi->common; BufferPool *const pool = cm->buffer_pool; - RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; if (frame_decoded) { lock_buffer_pool(pool); // In ext-tile decoding, the camera frame header is only decoded once. So, - // we don't release the references here. + // we don't update the references here. if (!pbi->camera_frame_header_ready) { - for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { - const int old_idx = cm->ref_frame_map[ref_index]; - // Current thread releases the holding of reference frame. - decrease_ref_count(old_idx, frame_bufs, pool); - - // Release the reference frame holding in the reference map for the - // decoding of the next frame. - if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool); - cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; + // The following for loop needs to release the reference stored in + // cm->ref_frame_map[ref_index] before storing a reference to + // cm->cur_frame in cm->ref_frame_map[ref_index]. + for (mask = cm->current_frame.refresh_frame_flags; mask; mask >>= 1) { + if (mask & 1) { + decrease_ref_count(cm->ref_frame_map[ref_index], pool); + cm->ref_frame_map[ref_index] = cm->cur_frame; + ++cm->cur_frame->ref_count; + } ++ref_index; } - - // Current thread releases the holding of reference frame. - const int check_on_show_existing_frame = - !cm->show_existing_frame || cm->reset_decoder_state; - for (; ref_index < REF_FRAMES && check_on_show_existing_frame; - ++ref_index) { - const int old_idx = cm->ref_frame_map[ref_index]; - decrease_ref_count(old_idx, frame_bufs, pool); - cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; - } } - YV12_BUFFER_CONFIG *cur_frame = get_frame_new_buffer(cm); - if (cm->show_existing_frame || cm->show_frame) { if (pbi->output_all_layers) { // Append this frame to the output queue if (pbi->num_output_frames >= MAX_NUM_SPATIAL_LAYERS) { // We can't store the new frame anywhere, so drop it and return an // error - decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); + cm->cur_frame->buf.corrupted = 1; + decrease_ref_count(cm->cur_frame, pool); cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; } else { - pbi->output_frames[pbi->num_output_frames] = cur_frame; - pbi->output_frame_index[pbi->num_output_frames] = cm->new_fb_idx; + pbi->output_frames[pbi->num_output_frames] = cm->cur_frame; pbi->num_output_frames++; } } else { // Replace any existing output frame assert(pbi->num_output_frames == 0 || pbi->num_output_frames == 1); if (pbi->num_output_frames > 0) { - decrease_ref_count((int)pbi->output_frame_index[0], frame_bufs, pool); + decrease_ref_count(pbi->output_frames[0], pool); } - pbi->output_frames[0] = cur_frame; - pbi->output_frame_index[0] = cm->new_fb_idx; + pbi->output_frames[0] = cm->cur_frame; pbi->num_output_frames = 1; } } else { - decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); + decrease_ref_count(cm->cur_frame, pool); } unlock_buffer_pool(pool); } else { // Nothing was decoded, so just drop this frame buffer lock_buffer_pool(pool); - decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); + decrease_ref_count(cm->cur_frame, pool); unlock_buffer_pool(pool); } + cm->cur_frame = NULL; if (!pbi->camera_frame_header_ready) { - pbi->hold_ref_buf = 0; - // Invalidate these references until the next frame starts. for (ref_index = 0; ref_index < INTER_REFS_PER_FRAME; ref_index++) { - cm->frame_refs[ref_index].idx = INVALID_IDX; - cm->frame_refs[ref_index].buf = NULL; + cm->remapped_ref_idx[ref_index] = INVALID_IDX; } } } @@ -407,10 +422,9 @@ static void swap_frame_buffers(AV1Decoder *pbi, int frame_decoded) { int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, const uint8_t **psource) { AV1_COMMON *volatile const cm = &pbi->common; - BufferPool *volatile const pool = cm->buffer_pool; - RefCntBuffer *volatile const frame_bufs = cm->buffer_pool->frame_bufs; const uint8_t *source = *psource; cm->error.error_code = AOM_CODEC_OK; + cm->error.has_detail = 0; if (size == 0) { // This is used to signal that we are missing frames. @@ -421,29 +435,15 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, // TODO(jkoleszar): Error concealment is undefined and non-normative // at this point, but if it becomes so, [0] may not always be the correct // thing to do here. - if (cm->frame_refs[0].idx > 0) { - assert(cm->frame_refs[0].buf != NULL); - cm->frame_refs[0].buf->corrupted = 1; - } + RefCntBuffer *ref_buf = get_ref_frame_buf(cm, LAST_FRAME); + if (ref_buf != NULL) ref_buf->buf.corrupted = 1; } - // Find a free buffer for the new frame, releasing the reference previously - // held. - - // Find a free frame buffer. Return error if can not find any. - cm->new_fb_idx = get_free_fb(cm); - if (cm->new_fb_idx == INVALID_IDX) { + if (assign_cur_frame_new_fb(cm) == NULL) { cm->error.error_code = AOM_CODEC_MEM_ERROR; return 1; } - // Assign a MV array to the frame buffer. - cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx]; - - if (!pbi->camera_frame_header_ready) pbi->hold_ref_buf = 0; - - pbi->cur_buf = &frame_bufs[cm->new_fb_idx]; - // The jmp_buf is valid only for the duration of the function that calls // setjmp(). Therefore, this function must reset the 'setjmp' field to 0 // before it returns. @@ -460,35 +460,7 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, winterface->sync(&pbi->tile_workers[i]); } - lock_buffer_pool(pool); - // Release all the reference buffers if worker thread is holding them. - if (pbi->hold_ref_buf == 1) { - int ref_index = 0, mask; - for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { - const int old_idx = cm->ref_frame_map[ref_index]; - // Current thread releases the holding of reference frame. - decrease_ref_count(old_idx, frame_bufs, pool); - - // Release the reference frame holding in the reference map for the - // decoding of the next frame. - if (mask & 1) decrease_ref_count(old_idx, frame_bufs, pool); - ++ref_index; - } - - // Current thread releases the holding of reference frame. - const int check_on_show_existing_frame = - !cm->show_existing_frame || cm->reset_decoder_state; - for (; ref_index < REF_FRAMES && check_on_show_existing_frame; - ++ref_index) { - const int old_idx = cm->ref_frame_map[ref_index]; - decrease_ref_count(old_idx, frame_bufs, pool); - } - pbi->hold_ref_buf = 0; - } - // Release current frame. - decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); - unlock_buffer_pool(pool); - + release_current_frame(pbi); aom_clear_system_state(); return -1; } @@ -498,10 +470,9 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, int frame_decoded = aom_decode_frame_from_obus(pbi, source, source + size, psource); - if (cm->error.error_code != AOM_CODEC_OK) { - lock_buffer_pool(pool); - decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); - unlock_buffer_pool(pool); + if (frame_decoded < 0) { + assert(cm->error.error_code != AOM_CODEC_OK); + release_current_frame(pbi); cm->error.setjmp = 0; return 1; } @@ -515,9 +486,9 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, cm->txb_count = 0; #endif - // Note: At this point, this function holds a reference to cm->new_fb_idx - // in the buffer pool. This reference is consumed by swap_frame_buffers(). - swap_frame_buffers(pbi, frame_decoded); + // Note: At this point, this function holds a reference to cm->cur_frame + // in the buffer pool. This reference is consumed by update_frame_buffers(). + update_frame_buffers(pbi, frame_decoded); if (frame_decoded) { pbi->decoding_first_frame = 0; @@ -531,11 +502,10 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, aom_clear_system_state(); if (!cm->show_existing_frame) { - cm->last_show_frame = cm->show_frame; - if (cm->seg.enabled) { - if (cm->prev_frame && (cm->mi_rows == cm->prev_frame->mi_rows) && - (cm->mi_cols == cm->prev_frame->mi_cols)) { + if (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; @@ -544,10 +514,6 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, } // Update progress in frame parallel decode. - cm->last_width = cm->width; - cm->last_height = cm->height; - cm->last_tile_cols = cm->tile_cols; - cm->last_tile_rows = cm->tile_rows; cm->error.setjmp = 0; return 0; @@ -556,11 +522,9 @@ int av1_receive_compressed_data(AV1Decoder *pbi, size_t size, // Get the frame at a particular index in the output queue int av1_get_raw_frame(AV1Decoder *pbi, size_t index, YV12_BUFFER_CONFIG **sd, aom_film_grain_t **grain_params) { - RefCntBuffer *const frame_bufs = pbi->common.buffer_pool->frame_bufs; - if (index >= pbi->num_output_frames) return -1; - *sd = pbi->output_frames[index]; - *grain_params = &frame_bufs[pbi->output_frame_index[index]].film_grain_params; + *sd = &pbi->output_frames[index]->buf; + *grain_params = &pbi->output_frames[index]->film_grain_params; aom_clear_system_state(); return 0; } @@ -570,6 +534,6 @@ int av1_get_raw_frame(AV1Decoder *pbi, size_t index, YV12_BUFFER_CONFIG **sd, int av1_get_frame_to_show(AV1Decoder *pbi, YV12_BUFFER_CONFIG *frame) { if (pbi->num_output_frames == 0) return -1; - *frame = *pbi->output_frames[pbi->num_output_frames - 1]; + *frame = pbi->output_frames[pbi->num_output_frames - 1]->buf; return 0; } diff --git a/media/libaom/src/av1/decoder/decoder.h b/media/libaom/src/av1/decoder/decoder.h index 5ca939c245..4580de2ac7 100644 --- a/media/libaom/src/av1/decoder/decoder.h +++ b/media/libaom/src/av1/decoder/decoder.h @@ -19,8 +19,8 @@ #include "aom_scale/yv12config.h" #include "aom_util/aom_thread.h" +#include "av1/common/av1_common_int.h" #include "av1/common/thread_common.h" -#include "av1/common/onyxc_int.h" #include "av1/decoder/dthread.h" #if CONFIG_ACCOUNTING #include "av1/decoder/accounting.h" @@ -41,18 +41,15 @@ typedef void (*decode_block_visitor_fn_t)(const AV1_COMMON *const cm, typedef void (*predict_inter_block_visitor_fn_t)(AV1_COMMON *const cm, MACROBLOCKD *const xd, - int mi_row, int mi_col, BLOCK_SIZE bsize); typedef void (*cfl_store_inter_block_visitor_fn_t)(AV1_COMMON *const cm, MACROBLOCKD *const xd); typedef struct ThreadData { - aom_reader *bit_reader; DECLARE_ALIGNED(32, MACROBLOCKD, xd); - /* dqcoeff are shared by all the planes. So planes must be decoded serially */ - DECLARE_ALIGNED(32, tran_low_t, dqcoeff[MAX_TX_SQUARE]); CB_BUFFER cb_buffer_base; + aom_reader *bit_reader; uint8_t *mc_buf[2]; int32_t mc_buf_size; int mc_buf_use_highbd; // Boolean: whether the byte pointers stored in @@ -97,9 +94,26 @@ typedef struct AV1DecRowMTInfo { int tile_cols_end; int start_tile; int end_tile; + int mi_rows_to_decode; + + // Invariant: + // mi_rows_parse_done >= mi_rows_decode_started. + // mi_rows_parse_done and mi_rows_decode_started are both initialized to 0. + // mi_rows_parse_done is incremented freely. mi_rows_decode_started may only + // be incremented to catch up with mi_rows_parse_done but is not allowed to + // surpass mi_rows_parse_done. + // + // When mi_rows_decode_started reaches mi_rows_to_decode, there are no more + // decode jobs. + + // Indicates the progress of the bit-stream parsing of superblocks. + // Initialized to 0. Incremented by sb_mi_size when parse sb row is done. int mi_rows_parse_done; + // Indicates the progress of the decoding of superblocks. + // Initialized to 0. Incremented by sb_mi_size when decode sb row is started. int mi_rows_decode_started; - int mi_rows_to_decode; + // Boolean: Initialized to 0 (false). Set to 1 (true) on error to abort + // decoding. int row_mt_exit; } AV1DecRowMTInfo; @@ -146,13 +160,6 @@ typedef struct AV1Decoder { DECLARE_ALIGNED(32, AV1_COMMON, common); - int refresh_frame_flags; - - // TODO(hkuang): Combine this with cur_buf in macroblockd as they are - // the same. - RefCntBuffer *cur_buf; // Current decoding frame buffer. - - AVxWorker *frame_worker_owner; // frame_worker that owns this pbi. AVxWorker lf_worker; AV1LfSync lf_row_sync; AV1LrSync lr_row_sync; @@ -178,8 +185,7 @@ typedef struct AV1Decoder { // Note: The saved buffers are released at the start of the next time the // application calls aom_codec_decode(). int output_all_layers; - YV12_BUFFER_CONFIG *output_frames[MAX_NUM_SPATIAL_LAYERS]; - size_t output_frame_index[MAX_NUM_SPATIAL_LAYERS]; // Buffer pool indices + RefCntBuffer *output_frames[MAX_NUM_SPATIAL_LAYERS]; size_t num_output_frames; // How many frames are queued up so far? // In order to properly support random-access decoding, we need @@ -190,8 +196,8 @@ typedef struct AV1Decoder { int allow_lowbitdepth; int max_threads; int inv_tile_order; - int need_resync; // wait for key/intra-only frame. - int hold_ref_buf; // hold the reference buffer. + int need_resync; // wait for key/intra-only frame. + int reset_decoder_state; int tile_size_bytes; int tile_col_size_bytes; @@ -200,9 +206,6 @@ typedef struct AV1Decoder { int acct_enabled; Accounting accounting; #endif - int tg_size; // Number of tiles in the current tilegroup - int tg_start; // First tile in the current tilegroup - int tg_size_bit_offset; int sequence_header_ready; int sequence_header_changed; #if CONFIG_INSPECTION @@ -212,6 +215,8 @@ typedef struct AV1Decoder { int operating_point; int current_operating_point; int seen_frame_header; + // The expected start_tile (tg_start syntax element) of the next tile group. + int next_start_tile; // State if the camera frame header is already decoded while // large_scale_tile = 1. @@ -225,9 +230,7 @@ typedef struct AV1Decoder { unsigned int ext_tile_debug; // for ext-tile software debug & testing unsigned int row_mt; EXTERNAL_REFERENCES ext_refs; - size_t tile_list_size; - uint8_t *tile_list_output; - size_t buffer_sz; + YV12_BUFFER_CONFIG tile_list_outbuf; CB_BUFFER *cb_buffer_base; int cb_buffer_alloc_size; @@ -240,12 +243,19 @@ typedef struct AV1Decoder { #endif AV1DecRowMTInfo frame_row_mt_info; + aom_metadata_array_t *metadata; + + int context_update_tile_id; + int skip_loop_filter; + int skip_film_grain; + int is_annexb; + int valid_for_referencing[REF_FRAMES]; } AV1Decoder; // Returns 0 on success. Sets pbi->common.error.error_code to a nonzero error // code and returns a nonzero value on failure. int av1_receive_compressed_data(struct AV1Decoder *pbi, size_t size, - const uint8_t **dest); + const uint8_t **psource); // Get the frame at a particular index in the output queue int av1_get_raw_frame(AV1Decoder *pbi, size_t index, YV12_BUFFER_CONFIG **sd, @@ -266,23 +276,28 @@ aom_codec_err_t av1_copy_new_frame_dec(AV1_COMMON *cm, struct AV1Decoder *av1_decoder_create(BufferPool *const pool); void av1_decoder_remove(struct AV1Decoder *pbi); -void av1_dealloc_dec_jobs(struct AV1DecTileMTData *tile_jobs_sync); +void av1_dealloc_dec_jobs(struct AV1DecTileMTData *tile_mt_info); void av1_dec_row_mt_dealloc(AV1DecRowMTSync *dec_row_mt_sync); void av1_dec_free_cb_buf(AV1Decoder *pbi); -static INLINE void decrease_ref_count(int idx, RefCntBuffer *const frame_bufs, +static INLINE void decrease_ref_count(RefCntBuffer *const buf, BufferPool *const pool) { - if (idx >= 0) { - --frame_bufs[idx].ref_count; + if (buf != NULL) { + --buf->ref_count; + // Reference counts should never become negative. If this assertion fails, + // there is a bug in our reference count management. + assert(buf->ref_count >= 0); // A worker may only get a free framebuffer index when calling get_free_fb. - // But the private buffer is not set up until finish decoding header. - // So any error happens during decoding header, the frame_bufs will not - // have valid priv buffer. - if (frame_bufs[idx].ref_count == 0 && - frame_bufs[idx].raw_frame_buffer.priv) { - pool->release_fb_cb(pool->cb_priv, &frame_bufs[idx].raw_frame_buffer); + // But the raw frame buffer is not set up until we finish decoding header. + // So if any error happens during decoding header, frame_bufs[idx] will not + // have a valid raw frame buffer. + if (buf->ref_count == 0 && buf->raw_frame_buffer.data) { + pool->release_fb_cb(pool->cb_priv, &buf->raw_frame_buffer); + buf->raw_frame_buffer.data = NULL; + buf->raw_frame_buffer.size = 0; + buf->raw_frame_buffer.priv = NULL; } } } @@ -302,9 +317,8 @@ static INLINE int av1_read_uniform(aom_reader *r, int n) { typedef void (*palette_visitor_fn_t)(MACROBLOCKD *const xd, int plane, aom_reader *r); -void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, int mi_row, - int mi_col, aom_reader *r, BLOCK_SIZE bsize, - palette_visitor_fn_t visit); +void av1_visit_palette(AV1Decoder *const pbi, MACROBLOCKD *const xd, + aom_reader *r, palette_visitor_fn_t visit); typedef void (*block_visitor_fn_t)(AV1Decoder *const pbi, ThreadData *const td, int mi_row, int mi_col, aom_reader *r, diff --git a/media/libaom/src/av1/decoder/decodetxb.c b/media/libaom/src/av1/decoder/decodetxb.c index f3ef2d55e4..541f4c9846 100644 --- a/media/libaom/src/av1/decoder/decodetxb.c +++ b/media/libaom/src/av1/decoder/decodetxb.c @@ -43,7 +43,7 @@ static int read_golomb(MACROBLOCKD *xd, aom_reader *r) { } static INLINE int rec_eob_pos(const int eob_token, const int extra) { - int eob = k_eob_group_start[eob_token]; + int eob = av1_eob_group_start[eob_token]; if (eob > 2) { eob += extra; } @@ -136,31 +136,33 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd, uint16_t *const max_scan_line = &(eob_data->max_scan_line); *max_scan_line = 0; *eob = 0; + +#if CONFIG_INSPECTION + if (plane == 0) { + const int txk_type_idx = + av1_get_txk_type_index(mbmi->sb_type, blk_row, blk_col); + mbmi->tx_skip[txk_type_idx] = all_zero; + } +#endif + if (all_zero) { *max_scan_line = 0; if (plane == 0) { - const int txk_type_idx = - av1_get_txk_type_index(mbmi->sb_type, blk_row, blk_col); - mbmi->txk_type[txk_type_idx] = DCT_DCT; + xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col] = DCT_DCT; } return 0; } - memset(levels_buf, 0, - sizeof(*levels_buf) * - ((width + TX_PAD_HOR) * (height + TX_PAD_VER) + TX_PAD_END)); if (plane == AOM_PLANE_Y) { // only y plane's tx_type is transmitted av1_read_tx_type(cm, xd, blk_row, blk_col, tx_size, r); } - const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, blk_row, blk_col, - tx_size, cm->reduced_tx_set_used); + const TX_TYPE tx_type = + av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size, + cm->features.reduced_tx_set_used); const TX_CLASS tx_class = tx_type_to_class[tx_type]; - const TX_SIZE qm_tx_size = av1_get_adjusted_tx_size(tx_size); const qm_val_t *iqmatrix = - IS_2D_TRANSFORM(tx_type) - ? pd->seg_iqmatrix[mbmi->segment_id][qm_tx_size] - : cm->giqmatrix[NUM_QM_LEVELS - 1][0][qm_tx_size]; + av1_get_iqmatrix(&cm->quant_params, xd, plane, tx_size, tx_type); const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type); const int16_t *const scan = scan_order->scan; int eob_extra = 0; @@ -214,23 +216,30 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd, break; } - if (k_eob_offset_bits[eob_pt] > 0) { + const int eob_offset_bits = av1_eob_offset_bits[eob_pt]; + if (eob_offset_bits > 0) { const int eob_ctx = eob_pt - 3; int bit = aom_read_symbol( r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx], 2, ACCT_STR); if (bit) { - eob_extra += (1 << (k_eob_offset_bits[eob_pt] - 1)); + eob_extra += (1 << (eob_offset_bits - 1)); } - for (int i = 1; i < k_eob_offset_bits[eob_pt]; i++) { + for (int i = 1; i < eob_offset_bits; i++) { bit = aom_read_bit(r, ACCT_STR); if (bit) { - eob_extra += (1 << (k_eob_offset_bits[eob_pt] - 1 - i)); + eob_extra += (1 << (eob_offset_bits - 1 - i)); } } } *eob = rec_eob_pos(eob_pt, eob_extra); + if (*eob > 1) { + memset(levels_buf, 0, + sizeof(*levels_buf) * + ((width + TX_PAD_HOR) * (height + TX_PAD_VER) + TX_PAD_END)); + } + { // Read the non-zero coefficient with scan index eob-1 // TODO(angiebird): Put this into a function @@ -242,12 +251,10 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd, ec_ctx->coeff_base_eob_cdf[txs_ctx][plane_type][coeff_ctx]; int level = aom_read_symbol(r, cdf, nsymbs, ACCT_STR) + 1; if (level > NUM_BASE_LEVELS) { - const int br_ctx = get_br_ctx(levels, pos, bwl, tx_class); + const int br_ctx = get_br_ctx_eob(pos, bwl, tx_class); + cdf = ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][br_ctx]; for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) { - const int k = aom_read_symbol( - r, - ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][br_ctx], - BR_CDF_SIZE, ACCT_STR); + const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR); level += k; if (k < BR_CDF_SIZE - 1) break; } @@ -269,13 +276,6 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd, } } - int16_t num_zero_coeffs = 0; - for (int c = 0; c < *eob; ++c) { - const int pos = scan[c]; - num_zero_coeffs = AOMMAX(num_zero_coeffs, pos); - } - memset(tcoeffs, 0, (num_zero_coeffs + 1) * sizeof(tcoeffs[0])); - for (int c = 0; c < *eob; ++c) { const int pos = scan[c]; uint8_t sign; @@ -332,25 +332,42 @@ void av1_read_coeffs_txb_facade(const AV1_COMMON *const cm, struct macroblockd_plane *const pd = &xd->plane[plane]; const BLOCK_SIZE bsize = mbmi->sb_type; + assert(bsize < BLOCK_SIZES_ALL); const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y); TXB_CTX txb_ctx; - get_txb_ctx(plane_bsize, tx_size, plane, pd->above_context + col, - pd->left_context + row, &txb_ctx); + get_txb_ctx(plane_bsize, tx_size, plane, pd->above_entropy_context + col, + pd->left_entropy_context + row, &txb_ctx); const uint8_t cul_level = av1_read_coeffs_txb(cm, xd, r, row, col, plane, &txb_ctx, tx_size); - av1_set_contexts(xd, pd, plane, plane_bsize, tx_size, cul_level, col, row); + av1_set_entropy_contexts(xd, pd, plane, plane_bsize, tx_size, cul_level, col, + row); if (is_inter_block(mbmi)) { - PLANE_TYPE plane_type = get_plane_type(plane); + const PLANE_TYPE plane_type = get_plane_type(plane); // tx_type will be read out in av1_read_coeffs_txb_facade - const TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, tx_size, - cm->reduced_tx_set_used); + const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, row, col, tx_size, + cm->features.reduced_tx_set_used); - if (plane == 0) - update_txk_array(mbmi->txk_type, mbmi->sb_type, row, col, tx_size, - tx_type); + if (plane == 0) { + const int txw = tx_size_wide_unit[tx_size]; + const int txh = tx_size_high_unit[tx_size]; + // The 16x16 unit is due to the constraint from tx_64x64 which sets the + // maximum tx size for chroma as 32x32. Coupled with 4x1 transform block + // size, the constraint takes effect in 32x16 / 16x32 size too. To solve + // the intricacy, cover all the 16x16 units inside a 64 level transform. + if (txw == tx_size_wide_unit[TX_64X64] || + txh == tx_size_high_unit[TX_64X64]) { + const int tx_unit = tx_size_wide_unit[TX_16X16]; + const int stride = xd->tx_type_map_stride; + for (int idy = 0; idy < txh; idy += tx_unit) { + for (int idx = 0; idx < txw; idx += tx_unit) { + xd->tx_type_map[(row + idy) * stride + col + idx] = tx_type; + } + } + } + } } #if TXCOEFF_TIMER diff --git a/media/libaom/src/av1/decoder/decodetxb.h b/media/libaom/src/av1/decoder/decodetxb.h index fe04f6abdd..39bf0bf78f 100644 --- a/media/libaom/src/av1/decoder/decodetxb.h +++ b/media/libaom/src/av1/decoder/decodetxb.h @@ -14,8 +14,8 @@ #include "config/aom_config.h" +#include "av1/common/av1_common_int.h" #include "av1/common/blockd.h" -#include "av1/common/onyxc_int.h" #include "av1/common/txb_common.h" #include "aom_dsp/bitreader.h" diff --git a/media/libaom/src/av1/decoder/dthread.c b/media/libaom/src/av1/decoder/dthread.c deleted file mode 100644 index 3946c787a1..0000000000 --- a/media/libaom/src/av1/decoder/dthread.c +++ /dev/null @@ -1,192 +0,0 @@ -/* - * Copyright (c) 2016, Alliance for Open Media. All rights reserved - * - * This source code is subject to the terms of the BSD 2 Clause License and - * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License - * was not distributed with this source code in the LICENSE file, you can - * obtain it at www.aomedia.org/license/software. If the Alliance for Open - * Media Patent License 1.0 was not distributed with this source code in the - * PATENTS file, you can obtain it at www.aomedia.org/license/patent. - */ - -#include "config/aom_config.h" - -#include "aom_mem/aom_mem.h" -#include "av1/common/reconinter.h" -#include "av1/decoder/dthread.h" -#include "av1/decoder/decoder.h" - -// #define DEBUG_THREAD - -// TODO(hkuang): Clean up all the #ifdef in this file. -void av1_frameworker_lock_stats(AVxWorker *const worker) { -#if CONFIG_MULTITHREAD - FrameWorkerData *const worker_data = worker->data1; - pthread_mutex_lock(&worker_data->stats_mutex); -#else - (void)worker; -#endif -} - -void av1_frameworker_unlock_stats(AVxWorker *const worker) { -#if CONFIG_MULTITHREAD - FrameWorkerData *const worker_data = worker->data1; - pthread_mutex_unlock(&worker_data->stats_mutex); -#else - (void)worker; -#endif -} - -void av1_frameworker_signal_stats(AVxWorker *const worker) { -#if CONFIG_MULTITHREAD - FrameWorkerData *const worker_data = worker->data1; - -// TODO(hkuang): Fix the pthread_cond_broadcast in windows wrapper. -#if defined(_WIN32) && !HAVE_PTHREAD_H - pthread_cond_signal(&worker_data->stats_cond); -#else - pthread_cond_broadcast(&worker_data->stats_cond); -#endif - -#else - (void)worker; -#endif -} - -// This macro prevents thread_sanitizer from reporting known concurrent writes. -#if defined(__has_feature) -#if __has_feature(thread_sanitizer) -#define BUILDING_WITH_TSAN -#endif -#endif - -// TODO(hkuang): Remove worker parameter as it is only used in debug code. -void av1_frameworker_wait(AVxWorker *const worker, RefCntBuffer *const ref_buf, - int row) { -#if CONFIG_MULTITHREAD - if (!ref_buf) return; - -#ifndef BUILDING_WITH_TSAN - // The following line of code will get harmless tsan error but it is the key - // to get best performance. - if (ref_buf->row >= row && ref_buf->buf.corrupted != 1) return; -#endif - - { - // Find the worker thread that owns the reference frame. If the reference - // frame has been fully decoded, it may not have owner. - AVxWorker *const ref_worker = ref_buf->frame_worker_owner; - FrameWorkerData *const ref_worker_data = - (FrameWorkerData *)ref_worker->data1; - const AV1Decoder *const pbi = ref_worker_data->pbi; - -#ifdef DEBUG_THREAD - { - FrameWorkerData *const worker_data = (FrameWorkerData *)worker->data1; - printf("%d %p worker is waiting for %d %p worker (%d) ref %d \r\n", - worker_data->worker_id, worker, ref_worker_data->worker_id, - ref_buf->frame_worker_owner, row, ref_buf->row); - } -#endif - - av1_frameworker_lock_stats(ref_worker); - while (ref_buf->row < row && pbi->cur_buf == ref_buf && - ref_buf->buf.corrupted != 1) { - pthread_cond_wait(&ref_worker_data->stats_cond, - &ref_worker_data->stats_mutex); - } - - if (ref_buf->buf.corrupted == 1) { - FrameWorkerData *const worker_data = (FrameWorkerData *)worker->data1; - av1_frameworker_unlock_stats(ref_worker); - aom_internal_error(&worker_data->pbi->common.error, - AOM_CODEC_CORRUPT_FRAME, - "Worker %p failed to decode frame", worker); - } - av1_frameworker_unlock_stats(ref_worker); - } -#else - (void)worker; - (void)ref_buf; - (void)row; - (void)ref_buf; -#endif // CONFIG_MULTITHREAD -} - -void av1_frameworker_broadcast(RefCntBuffer *const buf, int row) { -#if CONFIG_MULTITHREAD - AVxWorker *worker = buf->frame_worker_owner; - -#ifdef DEBUG_THREAD - { - FrameWorkerData *const worker_data = (FrameWorkerData *)worker->data1; - printf("%d %p worker decode to (%d) \r\n", worker_data->worker_id, - buf->frame_worker_owner, row); - } -#endif - - av1_frameworker_lock_stats(worker); - buf->row = row; - av1_frameworker_signal_stats(worker); - av1_frameworker_unlock_stats(worker); -#else - (void)buf; - (void)row; -#endif // CONFIG_MULTITHREAD -} - -void av1_frameworker_copy_context(AVxWorker *const dst_worker, - AVxWorker *const src_worker) { -#if CONFIG_MULTITHREAD - FrameWorkerData *const src_worker_data = (FrameWorkerData *)src_worker->data1; - FrameWorkerData *const dst_worker_data = (FrameWorkerData *)dst_worker->data1; - AV1_COMMON *const src_cm = &src_worker_data->pbi->common; - AV1_COMMON *const dst_cm = &dst_worker_data->pbi->common; - int i; - - // Wait until source frame's context is ready. - av1_frameworker_lock_stats(src_worker); - while (!src_worker_data->frame_context_ready) { - pthread_cond_wait(&src_worker_data->stats_cond, - &src_worker_data->stats_mutex); - } - - dst_cm->last_frame_seg_map = src_cm->seg.enabled - ? src_cm->current_frame_seg_map - : src_cm->last_frame_seg_map; - dst_worker_data->pbi->need_resync = src_worker_data->pbi->need_resync; - av1_frameworker_unlock_stats(src_worker); - - dst_cm->seq_params.bit_depth = src_cm->seq_params.bit_depth; - dst_cm->seq_params.use_highbitdepth = src_cm->seq_params.use_highbitdepth; - // TODO(zoeliu): To handle parallel decoding - dst_cm->prev_frame = - src_cm->show_existing_frame ? src_cm->prev_frame : src_cm->cur_frame; - dst_cm->last_width = - !src_cm->show_existing_frame ? src_cm->width : src_cm->last_width; - dst_cm->last_height = - !src_cm->show_existing_frame ? src_cm->height : src_cm->last_height; - dst_cm->seq_params.subsampling_x = src_cm->seq_params.subsampling_x; - dst_cm->seq_params.subsampling_y = src_cm->seq_params.subsampling_y; - dst_cm->frame_type = src_cm->frame_type; - dst_cm->last_show_frame = !src_cm->show_existing_frame - ? src_cm->show_frame - : src_cm->last_show_frame; - for (i = 0; i < REF_FRAMES; ++i) - dst_cm->ref_frame_map[i] = src_cm->next_ref_frame_map[i]; - - memcpy(dst_cm->lf_info.lfthr, src_cm->lf_info.lfthr, - (MAX_LOOP_FILTER + 1) * sizeof(loop_filter_thresh)); - dst_cm->lf.sharpness_level = src_cm->lf.sharpness_level; - dst_cm->lf.filter_level[0] = src_cm->lf.filter_level[0]; - dst_cm->lf.filter_level[1] = src_cm->lf.filter_level[1]; - memcpy(dst_cm->lf.ref_deltas, src_cm->lf.ref_deltas, REF_FRAMES); - memcpy(dst_cm->lf.mode_deltas, src_cm->lf.mode_deltas, MAX_MODE_LF_DELTAS); - dst_cm->seg = src_cm->seg; - memcpy(dst_cm->frame_contexts, src_cm->frame_contexts, - FRAME_CONTEXTS * sizeof(dst_cm->frame_contexts[0])); -#else - (void)dst_worker; - (void)src_worker; -#endif // CONFIG_MULTITHREAD -} diff --git a/media/libaom/src/av1/decoder/dthread.h b/media/libaom/src/av1/decoder/dthread.h index 1d264b07eb..f82b9d8ccf 100644 --- a/media/libaom/src/av1/decoder/dthread.h +++ b/media/libaom/src/av1/decoder/dthread.h @@ -39,42 +39,11 @@ typedef struct FrameWorkerData { const uint8_t *data_end; size_t data_size; void *user_priv; - int worker_id; int received_frame; - - // scratch_buffer is used in frame parallel mode only. - // It is used to make a copy of the compressed data. - uint8_t *scratch_buffer; - size_t scratch_buffer_size; - -#if CONFIG_MULTITHREAD - pthread_mutex_t stats_mutex; - pthread_cond_t stats_cond; -#endif - int frame_context_ready; // Current frame's context is ready to read. int frame_decoded; // Finished decoding current frame. } FrameWorkerData; -void av1_frameworker_lock_stats(AVxWorker *const worker); -void av1_frameworker_unlock_stats(AVxWorker *const worker); -void av1_frameworker_signal_stats(AVxWorker *const worker); - -// Wait until ref_buf has been decoded to row in real pixel unit. -// Note: worker may already finish decoding ref_buf and release it in order to -// start decoding next frame. So need to check whether worker is still decoding -// ref_buf. -void av1_frameworker_wait(AVxWorker *const worker, RefCntBuffer *const ref_buf, - int row); - -// FrameWorker broadcasts its decoding progress so other workers that are -// waiting on it can resume decoding. -void av1_frameworker_broadcast(RefCntBuffer *const buf, int row); - -// Copy necessary decoding context from src worker to dst worker. -void av1_frameworker_copy_context(AVxWorker *const dst_worker, - AVxWorker *const src_worker); - #ifdef __cplusplus } // extern "C" #endif diff --git a/media/libaom/src/av1/decoder/inspection.c b/media/libaom/src/av1/decoder/inspection.c index e6c89298a4..d121a70348 100644 --- a/media/libaom/src/av1/decoder/inspection.c +++ b/media/libaom/src/av1/decoder/inspection.c @@ -33,24 +33,29 @@ void ifd_clear(insp_frame_data *fd) { /* TODO(negge) This function may be called by more than one thread when using a multi-threaded decoder and this may cause a data race. */ -int ifd_inspect(insp_frame_data *fd, void *decoder) { +int ifd_inspect(insp_frame_data *fd, void *decoder, int skip_not_transform) { struct AV1Decoder *pbi = (struct AV1Decoder *)decoder; AV1_COMMON *const cm = &pbi->common; - if (fd->mi_rows != cm->mi_rows || fd->mi_cols != cm->mi_cols) { + const CommonModeInfoParams *const mi_params = &cm->mi_params; + const CommonQuantParams *quant_params = &cm->quant_params; + + if (fd->mi_rows != mi_params->mi_rows || fd->mi_cols != mi_params->mi_cols) { ifd_clear(fd); - ifd_init_mi_rc(fd, cm->mi_rows, cm->mi_cols); + ifd_init_mi_rc(fd, mi_params->mi_rows, mi_params->mi_cols); } + fd->show_existing_frame = cm->show_existing_frame; + fd->frame_number = cm->current_frame.frame_number; fd->show_frame = cm->show_frame; - fd->frame_type = cm->frame_type; - fd->base_qindex = cm->base_qindex; + fd->frame_type = cm->current_frame.frame_type; + fd->base_qindex = quant_params->base_qindex; // Set width and height of the first tile until generic support can be added TileInfo tile_info; av1_tile_set_row(&tile_info, cm, 0); av1_tile_set_col(&tile_info, cm, 0); fd->tile_mi_cols = tile_info.mi_col_end - tile_info.mi_col_start; fd->tile_mi_rows = tile_info.mi_row_end - tile_info.mi_row_start; - fd->delta_q_present_flag = cm->delta_q_present_flag; - fd->delta_q_res = cm->delta_q_res; + fd->delta_q_present_flag = cm->delta_q_info.delta_q_present_flag; + fd->delta_q_res = cm->delta_q_info.delta_q_res; #if CONFIG_ACCOUNTING fd->accounting = &pbi->accounting; #endif @@ -58,15 +63,16 @@ int ifd_inspect(insp_frame_data *fd, void *decoder) { int i, j; for (i = 0; i < MAX_SEGMENTS; i++) { for (j = 0; j < 2; j++) { - fd->y_dequant[i][j] = cm->y_dequant_QTX[i][j]; - fd->u_dequant[i][j] = cm->u_dequant_QTX[i][j]; - fd->v_dequant[i][j] = cm->v_dequant_QTX[i][j]; + fd->y_dequant[i][j] = quant_params->y_dequant_QTX[i][j]; + fd->u_dequant[i][j] = quant_params->u_dequant_QTX[i][j]; + fd->v_dequant[i][j] = quant_params->v_dequant_QTX[i][j]; } } - for (j = 0; j < cm->mi_rows; j++) { - for (i = 0; i < cm->mi_cols; i++) { - const MB_MODE_INFO *mbmi = cm->mi_grid_visible[j * cm->mi_stride + i]; - insp_mi_data *mi = &fd->mi_grid[j * cm->mi_cols + i]; + for (j = 0; j < mi_params->mi_rows; j++) { + for (i = 0; i < mi_params->mi_cols; i++) { + const MB_MODE_INFO *mbmi = + mi_params->mi_grid_base[j * mi_params->mi_stride + i]; + insp_mi_data *mi = &fd->mi_grid[j * mi_params->mi_cols + i]; // Segment mi->segment_id = mbmi->segment_id; // Motion Vectors @@ -79,12 +85,19 @@ int ifd_inspect(insp_frame_data *fd, void *decoder) { mi->ref_frame[1] = mbmi->ref_frame[1]; // Prediction Mode mi->mode = mbmi->mode; + mi->intrabc = (int16_t)mbmi->use_intrabc; + mi->palette = (int16_t)mbmi->palette_mode_info.palette_size[0]; + mi->uv_palette = (int16_t)mbmi->palette_mode_info.palette_size[1]; // Prediction Mode for Chromatic planes if (mi->mode < INTRA_MODES) { mi->uv_mode = mbmi->uv_mode; } else { mi->uv_mode = UV_MODE_INVALID; } + + mi->motion_mode = mbmi->motion_mode; + mi->compound_type = mbmi->interinter_comp.type; + // Block Size mi->sb_type = mbmi->sb_type; // Skip Flag @@ -92,15 +105,39 @@ int ifd_inspect(insp_frame_data *fd, void *decoder) { mi->filter[0] = av1_extract_interp_filter(mbmi->interp_filters, 0); mi->filter[1] = av1_extract_interp_filter(mbmi->interp_filters, 1); mi->dual_filter_type = mi->filter[0] * 3 + mi->filter[1]; + // Transform // TODO(anyone): extract tx type info from mbmi->txk_type[]. - mi->tx_type = DCT_DCT; - mi->tx_size = mbmi->tx_size; - mi->cdef_level = - cm->cdef_strengths[mbmi->cdef_strength] / CDEF_SEC_STRENGTHS; - mi->cdef_strength = - cm->cdef_strengths[mbmi->cdef_strength] % CDEF_SEC_STRENGTHS; + const BLOCK_SIZE bsize = mbmi->sb_type; + const int c = i % mi_size_wide[bsize]; + const int r = j % mi_size_high[bsize]; + if (is_inter_block(mbmi) || is_intrabc_block(mbmi)) + mi->tx_size = mbmi->inter_tx_size[av1_get_txb_size_index(bsize, r, c)]; + else + mi->tx_size = mbmi->tx_size; + + if (skip_not_transform && mi->skip) mi->tx_size = -1; + + if (mi->skip) { + const int tx_type_row = j - j % tx_size_high_unit[mi->tx_size]; + const int tx_type_col = i - i % tx_size_wide_unit[mi->tx_size]; + const int tx_type_map_idx = + tx_type_row * mi_params->mi_stride + tx_type_col; + mi->tx_type = mi_params->tx_type_map[tx_type_map_idx]; + } else { + mi->tx_type = 0; + } + + if (skip_not_transform && + (mi->skip || mbmi->tx_skip[av1_get_txk_type_index(bsize, r, c)])) + mi->tx_type = -1; + + mi->cdef_level = cm->cdef_info.cdef_strengths[mbmi->cdef_strength] / + CDEF_SEC_STRENGTHS; + mi->cdef_strength = cm->cdef_info.cdef_strengths[mbmi->cdef_strength] % + CDEF_SEC_STRENGTHS; + mi->cdef_strength += mi->cdef_strength == 3; if (mbmi->uv_mode == UV_CFL_PRED) { mi->cfl_alpha_idx = mbmi->cfl_alpha_idx; diff --git a/media/libaom/src/av1/decoder/inspection.h b/media/libaom/src/av1/decoder/inspection.h index 7214a9beda..b963f6ac61 100644 --- a/media/libaom/src/av1/decoder/inspection.h +++ b/media/libaom/src/av1/decoder/inspection.h @@ -20,7 +20,7 @@ extern "C" { #include "av1/decoder/accounting.h" #endif -#ifndef AOM_AOMDX_H_ +#ifndef AOM_AOM_AOMDX_H_ typedef void (*aom_inspect_cb)(void *decoder, void *data); #endif @@ -50,6 +50,11 @@ struct insp_mi_data { int16_t cfl_alpha_idx; int16_t cfl_alpha_sign; int16_t current_qindex; + int16_t compound_type; + int16_t motion_mode; + int16_t intrabc; + int16_t palette; + int16_t uv_palette; }; typedef struct insp_frame_data insp_frame_data; @@ -59,6 +64,7 @@ struct insp_frame_data { Accounting *accounting; #endif insp_mi_data *mi_grid; + int16_t frame_number; int show_frame; int frame_type; int base_qindex; @@ -72,11 +78,12 @@ struct insp_frame_data { // TODO(negge): add per frame CDEF data int delta_q_present_flag; int delta_q_res; + int show_existing_frame; }; void ifd_init(insp_frame_data *fd, int frame_width, int frame_height); void ifd_clear(insp_frame_data *fd); -int ifd_inspect(insp_frame_data *fd, void *decoder); +int ifd_inspect(insp_frame_data *fd, void *decoder, int skip_not_transform); #ifdef __cplusplus } // extern "C" diff --git a/media/libaom/src/av1/decoder/obu.c b/media/libaom/src/av1/decoder/obu.c index 44ecf818e7..791e5965b5 100644 --- a/media/libaom/src/av1/decoder/obu.c +++ b/media/libaom/src/av1/decoder/obu.c @@ -12,6 +12,7 @@ #include <assert.h> #include "config/aom_config.h" +#include "config/aom_scale_rtcd.h" #include "aom/aom_codec.h" #include "aom_dsp/bitreader_buffer.h" @@ -24,25 +25,6 @@ #include "av1/decoder/decodeframe.h" #include "av1/decoder/obu.h" -// Picture prediction structures (0-12 are predefined) in scalability metadata. -typedef enum { - SCALABILITY_L1T2 = 0, - SCALABILITY_L1T3 = 1, - SCALABILITY_L2T1 = 2, - SCALABILITY_L2T2 = 3, - SCALABILITY_L2T3 = 4, - SCALABILITY_S2T1 = 5, - SCALABILITY_S2T2 = 6, - SCALABILITY_S2T3 = 7, - SCALABILITY_L2T1h = 8, - SCALABILITY_L2T2h = 9, - SCALABILITY_L2T3h = 10, - SCALABILITY_S2T1h = 11, - SCALABILITY_S2T2h = 12, - SCALABILITY_S2T3h = 13, - SCALABILITY_SS = 14 -} SCALABILITY_STRUCTURES; - aom_codec_err_t aom_get_num_layers_from_operating_point_idc( int operating_point_idc, unsigned int *number_spatial_layers, unsigned int *number_temporal_layers) { @@ -97,20 +79,22 @@ static int byte_alignment(AV1_COMMON *const cm, static uint32_t read_temporal_delimiter_obu() { return 0; } // Returns a boolean that indicates success. -static int read_bitstream_level(BitstreamLevel *bl, +static int read_bitstream_level(AV1_LEVEL *seq_level_idx, struct aom_read_bit_buffer *rb) { - const uint8_t seq_level_idx = aom_rb_read_literal(rb, LEVEL_BITS); - if (!is_valid_seq_level_idx(seq_level_idx)) return 0; - bl->major = (seq_level_idx >> LEVEL_MINOR_BITS) + LEVEL_MAJOR_MIN; - bl->minor = seq_level_idx & ((1 << LEVEL_MINOR_BITS) - 1); + *seq_level_idx = aom_rb_read_literal(rb, LEVEL_BITS); + if (!is_valid_seq_level_idx(*seq_level_idx)) return 0; return 1; } // Returns whether two sequence headers are consistent with each other. -// TODO(huisu,wtc@google.com): make sure the code matches the spec exactly. +// Note that the 'op_params' field is not compared per Section 7.5 in the spec: +// Within a particular coded video sequence, the contents of +// sequence_header_obu must be bit-identical each time the sequence header +// appears except for the contents of operating_parameters_info. static int are_seq_headers_consistent(const SequenceHeader *seq_params_old, const SequenceHeader *seq_params_new) { - return !memcmp(seq_params_old, seq_params_new, sizeof(SequenceHeader)); + return !memcmp(seq_params_old, seq_params_new, + offsetof(SequenceHeader, op_params)); } // On success, sets pbi->sequence_header_ready to 1 and returns the number of @@ -145,26 +129,26 @@ static uint32_t read_sequence_header_obu(AV1Decoder *pbi, } if (seq_params->reduced_still_picture_hdr) { - cm->timing_info_present = 0; + seq_params->timing_info_present = 0; seq_params->decoder_model_info_present_flag = 0; seq_params->display_model_info_present_flag = 0; seq_params->operating_points_cnt_minus_1 = 0; seq_params->operating_point_idc[0] = 0; - if (!read_bitstream_level(&seq_params->level[0], rb)) { + if (!read_bitstream_level(&seq_params->seq_level_idx[0], rb)) { cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; return 0; } seq_params->tier[0] = 0; - cm->op_params[0].decoder_model_param_present_flag = 0; - cm->op_params[0].display_model_param_present_flag = 0; + seq_params->op_params[0].decoder_model_param_present_flag = 0; + seq_params->op_params[0].display_model_param_present_flag = 0; } else { - cm->timing_info_present = aom_rb_read_bit(rb); // timing_info_present_flag - if (cm->timing_info_present) { - av1_read_timing_info_header(cm, rb); + seq_params->timing_info_present = aom_rb_read_bit(rb); + if (seq_params->timing_info_present) { + av1_read_timing_info_header(&seq_params->timing_info, &cm->error, rb); seq_params->decoder_model_info_present_flag = aom_rb_read_bit(rb); if (seq_params->decoder_model_info_present_flag) - av1_read_decoder_model_info(cm, rb); + av1_read_decoder_model_info(&seq_params->decoder_model_info, rb); } else { seq_params->decoder_model_info_present_flag = 0; } @@ -174,63 +158,68 @@ static uint32_t read_sequence_header_obu(AV1Decoder *pbi, for (int i = 0; i < seq_params->operating_points_cnt_minus_1 + 1; i++) { seq_params->operating_point_idc[i] = aom_rb_read_literal(rb, OP_POINTS_IDC_BITS); - if (!read_bitstream_level(&seq_params->level[i], rb)) { + if (!read_bitstream_level(&seq_params->seq_level_idx[i], rb)) { cm->error.error_code = AOM_CODEC_UNSUP_BITSTREAM; return 0; } // This is the seq_level_idx[i] > 7 check in the spec. seq_level_idx 7 // is equivalent to level 3.3. - if (seq_params->level[i].major > 3) + if (seq_params->seq_level_idx[i] >= SEQ_LEVEL_4_0) seq_params->tier[i] = aom_rb_read_bit(rb); else seq_params->tier[i] = 0; if (seq_params->decoder_model_info_present_flag) { - cm->op_params[i].decoder_model_param_present_flag = aom_rb_read_bit(rb); - if (cm->op_params[i].decoder_model_param_present_flag) - av1_read_op_parameters_info(cm, rb, i); + seq_params->op_params[i].decoder_model_param_present_flag = + aom_rb_read_bit(rb); + if (seq_params->op_params[i].decoder_model_param_present_flag) + av1_read_op_parameters_info(&seq_params->op_params[i], + seq_params->decoder_model_info + .encoder_decoder_buffer_delay_length, + rb); } else { - cm->op_params[i].decoder_model_param_present_flag = 0; + seq_params->op_params[i].decoder_model_param_present_flag = 0; } - if (cm->timing_info_present && - (cm->timing_info.equal_picture_interval || - cm->op_params[i].decoder_model_param_present_flag)) { - cm->op_params[i].bitrate = max_level_bitrate( - seq_params->profile, - major_minor_to_seq_level_idx(seq_params->level[i]), + if (seq_params->timing_info_present && + (seq_params->timing_info.equal_picture_interval || + seq_params->op_params[i].decoder_model_param_present_flag)) { + seq_params->op_params[i].bitrate = av1_max_level_bitrate( + seq_params->profile, seq_params->seq_level_idx[i], seq_params->tier[i]); // Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass // the check - if (cm->op_params[i].bitrate == 0) + if (seq_params->op_params[i].bitrate == 0) aom_internal_error(&cm->error, AOM_CODEC_UNSUP_BITSTREAM, "AV1 does not support this combination of " "profile, level, and tier."); // Buffer size in bits/s is bitrate in bits/s * 1 s - cm->op_params[i].buffer_size = cm->op_params[i].bitrate; + seq_params->op_params[i].buffer_size = seq_params->op_params[i].bitrate; } - if (cm->timing_info_present && cm->timing_info.equal_picture_interval && - !cm->op_params[i].decoder_model_param_present_flag) { + if (seq_params->timing_info_present && + seq_params->timing_info.equal_picture_interval && + !seq_params->op_params[i].decoder_model_param_present_flag) { // When the decoder_model_parameters are not sent for this op, set // the default ones that can be used with the resource availability mode - cm->op_params[i].decoder_buffer_delay = 70000; - cm->op_params[i].encoder_buffer_delay = 20000; - cm->op_params[i].low_delay_mode_flag = 0; + seq_params->op_params[i].decoder_buffer_delay = 70000; + seq_params->op_params[i].encoder_buffer_delay = 20000; + seq_params->op_params[i].low_delay_mode_flag = 0; } if (seq_params->display_model_info_present_flag) { - cm->op_params[i].display_model_param_present_flag = aom_rb_read_bit(rb); - if (cm->op_params[i].display_model_param_present_flag) { - cm->op_params[i].initial_display_delay = + seq_params->op_params[i].display_model_param_present_flag = + aom_rb_read_bit(rb); + if (seq_params->op_params[i].display_model_param_present_flag) { + seq_params->op_params[i].initial_display_delay = aom_rb_read_literal(rb, 4) + 1; - if (cm->op_params[i].initial_display_delay > 10) + if (seq_params->op_params[i].initial_display_delay > 10) aom_internal_error( &cm->error, AOM_CODEC_UNSUP_BITSTREAM, "AV1 does not support more than 10 decoded frames delay"); } else { - cm->op_params[i].initial_display_delay = 10; + seq_params->op_params[i].initial_display_delay = 10; } } else { - cm->op_params[i].display_model_param_present_flag = 0; - cm->op_params[i].initial_display_delay = 10; + seq_params->op_params[i].display_model_param_present_flag = 0; + seq_params->op_params[i].initial_display_delay = 10; } } } @@ -292,37 +281,62 @@ static uint32_t read_frame_header_obu(AV1Decoder *pbi, trailing_bits_present); } +// On success, returns the tile group header size. On failure, calls +// aom_internal_error() and returns -1. static int32_t read_tile_group_header(AV1Decoder *pbi, struct aom_read_bit_buffer *rb, int *start_tile, int *end_tile, int tile_start_implicit) { AV1_COMMON *const cm = &pbi->common; + CommonTileParams *const tiles = &cm->tiles; uint32_t saved_bit_offset = rb->bit_offset; int tile_start_and_end_present_flag = 0; - const int num_tiles = pbi->common.tile_rows * pbi->common.tile_cols; + const int num_tiles = tiles->rows * tiles->cols; - if (!pbi->common.large_scale_tile && num_tiles > 1) { + if (!tiles->large_scale && num_tiles > 1) { tile_start_and_end_present_flag = aom_rb_read_bit(rb); + if (tile_start_implicit && tile_start_and_end_present_flag) { + aom_internal_error( + &cm->error, AOM_CODEC_UNSUP_BITSTREAM, + "For OBU_FRAME type obu tile_start_and_end_present_flag must be 0"); + return -1; + } } - if (pbi->common.large_scale_tile || num_tiles == 1 || + if (tiles->large_scale || num_tiles == 1 || !tile_start_and_end_present_flag) { *start_tile = 0; *end_tile = num_tiles - 1; - return ((rb->bit_offset - saved_bit_offset + 7) >> 3); + } else { + int tile_bits = tiles->log2_rows + tiles->log2_cols; + *start_tile = aom_rb_read_literal(rb, tile_bits); + *end_tile = aom_rb_read_literal(rb, tile_bits); + } + if (*start_tile != pbi->next_start_tile) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "tg_start (%d) must be equal to %d", *start_tile, + pbi->next_start_tile); + return -1; } - if (tile_start_implicit && tile_start_and_end_present_flag) { + if (*start_tile > *end_tile) { aom_internal_error( - &cm->error, AOM_CODEC_UNSUP_BITSTREAM, - "For OBU_FRAME type obu tile_start_and_end_present_flag must be 0"); + &cm->error, AOM_CODEC_CORRUPT_FRAME, + "tg_end (%d) must be greater than or equal to tg_start (%d)", *end_tile, + *start_tile); return -1; } - *start_tile = - aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); - *end_tile = aom_rb_read_literal(rb, cm->log2_tile_rows + cm->log2_tile_cols); + if (*end_tile >= num_tiles) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "tg_end (%d) must be less than NumTiles (%d)", *end_tile, + num_tiles); + return -1; + } + pbi->next_start_tile = (*end_tile == num_tiles - 1) ? 0 : *end_tile + 1; return ((rb->bit_offset - saved_bit_offset + 7) >> 3); } +// On success, returns the tile group OBU size. On failure, sets +// pbi->common.error.error_code and returns 0. static uint32_t read_one_tile_group_obu( AV1Decoder *pbi, struct aom_read_bit_buffer *rb, int is_first_tg, const uint8_t *data, const uint8_t *data_end, const uint8_t **p_data_end, @@ -337,100 +351,132 @@ static uint32_t read_one_tile_group_obu( header_size = read_tile_group_header(pbi, rb, &start_tile, &end_tile, tile_start_implicit); if (header_size == -1 || byte_alignment(cm, rb)) return 0; - if (start_tile > end_tile) return header_size; data += header_size; av1_decode_tg_tiles_and_wrapup(pbi, data, data_end, p_data_end, start_tile, end_tile, is_first_tg); tg_payload_size = (uint32_t)(*p_data_end - data); - // TODO(shan): For now, assume all tile groups received in order - *is_last_tg = end_tile == cm->tile_rows * cm->tile_cols - 1; + *is_last_tg = end_tile == cm->tiles.rows * cm->tiles.cols - 1; return header_size + tg_payload_size; } static void alloc_tile_list_buffer(AV1Decoder *pbi) { - // TODO(yunqing): for now, copy each tile's decoded YUV data directly to the - // output buffer. This needs to be modified according to the application - // requirement. + // The resolution of the output frame is read out from the bitstream. The data + // are stored in the order of Y plane, U plane and V plane. As an example, for + // image format 4:2:0, the output frame of U plane and V plane is 1/4 of the + // output frame. AV1_COMMON *const cm = &pbi->common; - const int tile_width_in_pixels = cm->tile_width * MI_SIZE; - const int tile_height_in_pixels = cm->tile_height * MI_SIZE; - const int ssy = cm->seq_params.subsampling_y; - const int ssx = cm->seq_params.subsampling_x; - const int num_planes = av1_num_planes(cm); - const size_t yplane_tile_size = tile_height_in_pixels * tile_width_in_pixels; - const size_t uvplane_tile_size = - (num_planes > 1) - ? (tile_height_in_pixels >> ssy) * (tile_width_in_pixels >> ssx) - : 0; - const size_t tile_size = (cm->seq_params.use_highbitdepth ? 2 : 1) * - (yplane_tile_size + 2 * uvplane_tile_size); - pbi->tile_list_size = tile_size * (pbi->tile_count_minus_1 + 1); - - if (pbi->tile_list_size > pbi->buffer_sz) { - if (pbi->tile_list_output != NULL) aom_free(pbi->tile_list_output); - pbi->tile_list_output = NULL; - - pbi->tile_list_output = (uint8_t *)aom_memalign(32, pbi->tile_list_size); - if (pbi->tile_list_output == NULL) - aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, - "Failed to allocate the tile list output buffer"); - pbi->buffer_sz = pbi->tile_list_size; + int tile_width, tile_height; + av1_get_uniform_tile_size(cm, &tile_width, &tile_height); + const int tile_width_in_pixels = tile_width * MI_SIZE; + const int tile_height_in_pixels = tile_height * MI_SIZE; + const int output_frame_width = + (pbi->output_frame_width_in_tiles_minus_1 + 1) * tile_width_in_pixels; + const int output_frame_height = + (pbi->output_frame_height_in_tiles_minus_1 + 1) * tile_height_in_pixels; + // The output frame is used to store the decoded tile list. The decoded tile + // list has to fit into 1 output frame. + assert((pbi->tile_count_minus_1 + 1) <= + (pbi->output_frame_width_in_tiles_minus_1 + 1) * + (pbi->output_frame_height_in_tiles_minus_1 + 1)); + + // Allocate the tile list output buffer. + // Note: if cm->seq_params.use_highbitdepth is 1 and cm->seq_params.bit_depth + // is 8, we could allocate less memory, namely, 8 bits/pixel. + if (aom_alloc_frame_buffer(&pbi->tile_list_outbuf, output_frame_width, + output_frame_height, cm->seq_params.subsampling_x, + cm->seq_params.subsampling_y, + (cm->seq_params.use_highbitdepth && + (cm->seq_params.bit_depth > AOM_BITS_8)), + 0, cm->features.byte_alignment)) + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Failed to allocate the tile list output buffer"); +} + +static void yv12_tile_copy(const YV12_BUFFER_CONFIG *src, int hstart1, + int hend1, int vstart1, int vend1, + YV12_BUFFER_CONFIG *dst, int hstart2, int vstart2, + int plane) { + const int src_stride = (plane > 0) ? src->strides[1] : src->strides[0]; + const int dst_stride = (plane > 0) ? dst->strides[1] : dst->strides[0]; + int row, col; + + assert(src->flags & YV12_FLAG_HIGHBITDEPTH); + assert(!(dst->flags & YV12_FLAG_HIGHBITDEPTH)); + + const uint16_t *src16 = + CONVERT_TO_SHORTPTR(src->buffers[plane] + vstart1 * src_stride + hstart1); + uint8_t *dst8 = dst->buffers[plane] + vstart2 * dst_stride + hstart2; + + for (row = vstart1; row < vend1; ++row) { + for (col = 0; col < (hend1 - hstart1); ++col) *dst8++ = (uint8_t)(*src16++); + src16 += src_stride - (hend1 - hstart1); + dst8 += dst_stride - (hend1 - hstart1); } + return; } static void copy_decoded_tile_to_tile_list_buffer(AV1Decoder *pbi, - uint8_t **output) { + int tile_idx) { AV1_COMMON *const cm = &pbi->common; - const int tile_width_in_pixels = cm->tile_width * MI_SIZE; - const int tile_height_in_pixels = cm->tile_height * MI_SIZE; + int tile_width, tile_height; + av1_get_uniform_tile_size(cm, &tile_width, &tile_height); + const int tile_width_in_pixels = tile_width * MI_SIZE; + const int tile_height_in_pixels = tile_height * MI_SIZE; const int ssy = cm->seq_params.subsampling_y; const int ssx = cm->seq_params.subsampling_x; const int num_planes = av1_num_planes(cm); - // Copy decoded tile to the tile list output buffer. - YV12_BUFFER_CONFIG *cur_frame = get_frame_new_buffer(cm); - const int mi_row = pbi->dec_tile_row * cm->tile_height; - const int mi_col = pbi->dec_tile_col * cm->tile_width; - const int is_hbd = (cur_frame->flags & YV12_FLAG_HIGHBITDEPTH) ? 1 : 0; - uint8_t *bufs[MAX_MB_PLANE] = { NULL, NULL, NULL }; - int strides[MAX_MB_PLANE] = { 0, 0, 0 }; + YV12_BUFFER_CONFIG *cur_frame = &cm->cur_frame->buf; + const int tr = tile_idx / (pbi->output_frame_width_in_tiles_minus_1 + 1); + const int tc = tile_idx % (pbi->output_frame_width_in_tiles_minus_1 + 1); int plane; + // Copy decoded tile to the tile list output buffer. for (plane = 0; plane < num_planes; ++plane) { - int shift_x = plane > 0 ? ssx : 0; - int shift_y = plane > 0 ? ssy : 0; - - bufs[plane] = cur_frame->buffers[plane]; - strides[plane] = - (plane > 0) ? cur_frame->strides[1] : cur_frame->strides[0]; - - bufs[plane] += mi_row * (MI_SIZE >> shift_y) * strides[plane] + - mi_col * (MI_SIZE >> shift_x); - - if (is_hbd) { - bufs[plane] = (uint8_t *)CONVERT_TO_SHORTPTR(bufs[plane]); - strides[plane] *= 2; - } - - int w, h; - w = (plane > 0 && shift_x > 0) ? ((tile_width_in_pixels + 1) >> shift_x) - : tile_width_in_pixels; - w *= (1 + is_hbd); - h = (plane > 0 && shift_y > 0) ? ((tile_height_in_pixels + 1) >> shift_y) - : tile_height_in_pixels; - int j; - - for (j = 0; j < h; ++j) { - memcpy(*output, bufs[plane], w); - bufs[plane] += strides[plane]; - *output += w; + const int shift_x = plane > 0 ? ssx : 0; + const int shift_y = plane > 0 ? ssy : 0; + const int h = tile_height_in_pixels >> shift_y; + const int w = tile_width_in_pixels >> shift_x; + + // src offset + int vstart1 = pbi->dec_tile_row * h; + int vend1 = vstart1 + h; + int hstart1 = pbi->dec_tile_col * w; + int hend1 = hstart1 + w; + // dst offset + int vstart2 = tr * h; + int hstart2 = tc * w; + + if (cm->seq_params.use_highbitdepth && + cm->seq_params.bit_depth == AOM_BITS_8) { + yv12_tile_copy(cur_frame, hstart1, hend1, vstart1, vend1, + &pbi->tile_list_outbuf, hstart2, vstart2, plane); + } else { + switch (plane) { + case 0: + aom_yv12_partial_copy_y(cur_frame, hstart1, hend1, vstart1, vend1, + &pbi->tile_list_outbuf, hstart2, vstart2); + break; + case 1: + aom_yv12_partial_copy_u(cur_frame, hstart1, hend1, vstart1, vend1, + &pbi->tile_list_outbuf, hstart2, vstart2); + break; + case 2: + aom_yv12_partial_copy_v(cur_frame, hstart1, hend1, vstart1, vend1, + &pbi->tile_list_outbuf, hstart2, vstart2); + break; + default: assert(0); + } } } } // Only called while large_scale_tile = 1. +// +// On success, returns the tile list OBU size. On failure, sets +// pbi->common.error.error_code and returns 0. static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi, struct aom_read_bit_buffer *rb, const uint8_t *data, @@ -439,7 +485,7 @@ static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi, int *frame_decoding_finished) { AV1_COMMON *const cm = &pbi->common; uint32_t tile_list_payload_size = 0; - const int num_tiles = cm->tile_cols * cm->tile_rows; + const int num_tiles = cm->tiles.cols * cm->tiles.rows; const int start_tile = 0; const int end_tile = num_tiles - 1; int i = 0; @@ -459,8 +505,8 @@ static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi, uint32_t tile_list_info_bytes = 4; tile_list_payload_size += tile_list_info_bytes; data += tile_list_info_bytes; - uint8_t *output = pbi->tile_list_output; + int tile_idx = 0; for (i = 0; i <= pbi->tile_count_minus_1; i++) { // Process 1 tile. // Reset the bit reader. @@ -475,13 +521,14 @@ static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi, cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; return 0; } - av1_set_reference_dec(cm, 0, 1, &pbi->ext_refs.refs[ref_idx]); + av1_set_reference_dec(cm, cm->remapped_ref_idx[0], 1, + &pbi->ext_refs.refs[ref_idx]); pbi->dec_tile_row = aom_rb_read_literal(rb, 8); pbi->dec_tile_col = aom_rb_read_literal(rb, 8); if (pbi->dec_tile_row < 0 || pbi->dec_tile_col < 0 || - pbi->dec_tile_row >= cm->tile_rows || - pbi->dec_tile_col >= cm->tile_cols) { + pbi->dec_tile_row >= cm->tiles.rows || + pbi->dec_tile_col >= cm->tiles.cols) { cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; return 0; } @@ -504,135 +551,303 @@ static uint32_t read_and_decode_one_tile_list(AV1Decoder *pbi, assert(data <= data_end); // Copy the decoded tile to the tile list output buffer. - copy_decoded_tile_to_tile_list_buffer(pbi, &output); + copy_decoded_tile_to_tile_list_buffer(pbi, tile_idx); + tile_idx++; } *frame_decoding_finished = 1; return tile_list_payload_size; } -static void read_metadata_itut_t35(const uint8_t *data, size_t sz) { - struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; - for (size_t i = 0; i < sz; i++) { - aom_rb_read_literal(&rb, 8); +// Returns the last nonzero byte index in 'data'. If there is no nonzero byte in +// 'data', returns -1. +static int get_last_nonzero_byte_index(const uint8_t *data, size_t sz) { + // Scan backward and return on the first nonzero byte. + int i = (int)sz - 1; + while (i >= 0 && data[i] == 0) { + --i; } + return i; } -static void read_metadata_hdr_cll(const uint8_t *data, size_t sz) { - struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; - aom_rb_read_literal(&rb, 16); // max_cll - aom_rb_read_literal(&rb, 16); // max_fall +// Allocates metadata that was read and adds it to the decoders metadata array. +static void alloc_read_metadata(AV1Decoder *const pbi, + OBU_METADATA_TYPE metadata_type, + const uint8_t *data, size_t sz, + aom_metadata_insert_flags_t insert_flag) { + AV1_COMMON *const cm = &pbi->common; + aom_metadata_t *metadata = + aom_img_metadata_alloc(metadata_type, data, sz, insert_flag); + if (!metadata) { + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Error allocating metadata"); + } + if (!pbi->metadata) { + pbi->metadata = aom_img_metadata_array_alloc(1); + if (!pbi->metadata) { + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Failed to allocate metadata array"); + } + } else { + aom_metadata_t **metadata_array = + (aom_metadata_t **)realloc(pbi->metadata->metadata_array, + (pbi->metadata->sz + 1) * sizeof(metadata)); + if (!metadata_array) { + aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR, + "Error allocating metadata"); + } + pbi->metadata->metadata_array = metadata_array; + pbi->metadata->sz++; + } + pbi->metadata->metadata_array[pbi->metadata->sz - 1] = metadata; } -static void read_metadata_hdr_mdcv(const uint8_t *data, size_t sz) { - struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; - for (int i = 0; i < 3; i++) { - aom_rb_read_literal(&rb, 16); // primary_i_chromaticity_x - aom_rb_read_literal(&rb, 16); // primary_i_chromaticity_y +// On success, returns the number of bytes read from 'data'. On failure, calls +// aom_internal_error() and does not return. +static size_t read_metadata_itut_t35(AV1Decoder *const pbi, const uint8_t *data, + size_t sz) { + const int kMinItuT35PayloadSize = 2; + AV1_COMMON *const cm = &pbi->common; + if (sz == 0) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "itu_t_t35_country_code is missing"); + } + int bytes_read = get_last_nonzero_byte_index(data, sz); + if (bytes_read < 0) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "No trailing bits found on metadata"); } + if (*data == 0xFF && bytes_read < kMinItuT35PayloadSize) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "itu_t_t35_country_code_extension_byte is missing"); + } + alloc_read_metadata(pbi, OBU_METADATA_TYPE_ITUT_T35, data, (size_t)bytes_read, + AOM_MIF_ANY_FRAME); + return (size_t)bytes_read; +} - aom_rb_read_literal(&rb, 16); // white_point_chromaticity_x - aom_rb_read_literal(&rb, 16); // white_point_chromaticity_y +// On success, returns the number of bytes read from 'data'. On failure, calls +// aom_internal_error() and does not return. +static size_t read_metadata_hdr_cll(AV1Decoder *const pbi, const uint8_t *data, + size_t sz) { + const int kHdrCllPayloadSize = 4; + AV1_COMMON *const cm = &pbi->common; + if (sz == 0) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "HDR CLL metadata payload is missing"); + } + int bytes_read = get_last_nonzero_byte_index(data, sz); + if (bytes_read < 0) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "No trailing bits found on metadata"); + } + if (bytes_read != kHdrCllPayloadSize) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Incorrect HDR CLL metadata payload size"); + } + alloc_read_metadata(pbi, OBU_METADATA_TYPE_HDR_CLL, data, (size_t)bytes_read, + AOM_MIF_ANY_FRAME); + return (size_t)bytes_read; +} - aom_rb_read_unsigned_literal(&rb, 32); // luminance_max - aom_rb_read_unsigned_literal(&rb, 32); // luminance_min +// On success, returns the number of bytes read from 'data'. On failure, calls +// aom_internal_error() and does not return. +static size_t read_metadata_hdr_mdcv(AV1Decoder *const pbi, const uint8_t *data, + size_t sz) { + const int kMdcvPayloadSize = 24; + AV1_COMMON *const cm = &pbi->common; + if (sz == 0) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "HDR MDCV metadata payload is missing"); + } + int bytes_read = get_last_nonzero_byte_index(data, sz); + if (bytes_read < 0) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "No trailing bits found on HDR MDCV metadata"); + } + if (bytes_read != kMdcvPayloadSize) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Incorrect HDR MDCV metadata payload size"); + } + alloc_read_metadata(pbi, OBU_METADATA_TYPE_HDR_MDCV, data, (size_t)bytes_read, + AOM_MIF_ANY_FRAME); + return (size_t)bytes_read; } static void scalability_structure(struct aom_read_bit_buffer *rb) { - int spatial_layers_cnt = aom_rb_read_literal(rb, 2); - int spatial_layer_dimensions_present_flag = aom_rb_read_bit(rb); - int spatial_layer_description_present_flag = aom_rb_read_bit(rb); - int temporal_group_description_present_flag = aom_rb_read_bit(rb); + const int spatial_layers_cnt_minus_1 = aom_rb_read_literal(rb, 2); + const int spatial_layer_dimensions_present_flag = aom_rb_read_bit(rb); + const int spatial_layer_description_present_flag = aom_rb_read_bit(rb); + const int temporal_group_description_present_flag = aom_rb_read_bit(rb); aom_rb_read_literal(rb, 3); // reserved if (spatial_layer_dimensions_present_flag) { - int i; - for (i = 0; i < spatial_layers_cnt + 1; i++) { + for (int i = 0; i <= spatial_layers_cnt_minus_1; i++) { aom_rb_read_literal(rb, 16); aom_rb_read_literal(rb, 16); } } if (spatial_layer_description_present_flag) { - int i; - for (i = 0; i < spatial_layers_cnt + 1; i++) { + for (int i = 0; i <= spatial_layers_cnt_minus_1; i++) { aom_rb_read_literal(rb, 8); } } if (temporal_group_description_present_flag) { - int i, j, temporal_group_size; - temporal_group_size = aom_rb_read_literal(rb, 8); - for (i = 0; i < temporal_group_size; i++) { + const int temporal_group_size = aom_rb_read_literal(rb, 8); + for (int i = 0; i < temporal_group_size; i++) { aom_rb_read_literal(rb, 3); aom_rb_read_bit(rb); aom_rb_read_bit(rb); - int temporal_group_ref_cnt = aom_rb_read_literal(rb, 3); - for (j = 0; j < temporal_group_ref_cnt; j++) { + const int temporal_group_ref_cnt = aom_rb_read_literal(rb, 3); + for (int j = 0; j < temporal_group_ref_cnt; j++) { aom_rb_read_literal(rb, 8); } } } } -static void read_metadata_scalability(const uint8_t *data, size_t sz) { - struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; - int scalability_mode_idc = aom_rb_read_literal(&rb, 8); +static void read_metadata_scalability(struct aom_read_bit_buffer *rb) { + const int scalability_mode_idc = aom_rb_read_literal(rb, 8); if (scalability_mode_idc == SCALABILITY_SS) { - scalability_structure(&rb); + scalability_structure(rb); } } -static void read_metadata_timecode(const uint8_t *data, size_t sz) { - struct aom_read_bit_buffer rb = { data, data + sz, 0, NULL, NULL }; - aom_rb_read_literal(&rb, 5); // counting_type f(5) - int full_timestamp_flag = aom_rb_read_bit(&rb); // full_timestamp_flag f(1) - aom_rb_read_bit(&rb); // discontinuity_flag (f1) - aom_rb_read_bit(&rb); // cnt_dropped_flag f(1) - aom_rb_read_literal(&rb, 9); // n_frames f(9) +static void read_metadata_timecode(struct aom_read_bit_buffer *rb) { + aom_rb_read_literal(rb, 5); // counting_type f(5) + const int full_timestamp_flag = + aom_rb_read_bit(rb); // full_timestamp_flag f(1) + aom_rb_read_bit(rb); // discontinuity_flag (f1) + aom_rb_read_bit(rb); // cnt_dropped_flag f(1) + aom_rb_read_literal(rb, 9); // n_frames f(9) if (full_timestamp_flag) { - aom_rb_read_literal(&rb, 6); // seconds_value f(6) - aom_rb_read_literal(&rb, 6); // minutes_value f(6) - aom_rb_read_literal(&rb, 5); // hours_value f(5) + aom_rb_read_literal(rb, 6); // seconds_value f(6) + aom_rb_read_literal(rb, 6); // minutes_value f(6) + aom_rb_read_literal(rb, 5); // hours_value f(5) } else { - int seconds_flag = aom_rb_read_bit(&rb); // seconds_flag f(1) + const int seconds_flag = aom_rb_read_bit(rb); // seconds_flag f(1) if (seconds_flag) { - aom_rb_read_literal(&rb, 6); // seconds_value f(6) - int minutes_flag = aom_rb_read_bit(&rb); // minutes_flag f(1) + aom_rb_read_literal(rb, 6); // seconds_value f(6) + const int minutes_flag = aom_rb_read_bit(rb); // minutes_flag f(1) if (minutes_flag) { - aom_rb_read_literal(&rb, 6); // minutes_value f(6) - int hours_flag = aom_rb_read_bit(&rb); // hours_flag f(1) + aom_rb_read_literal(rb, 6); // minutes_value f(6) + const int hours_flag = aom_rb_read_bit(rb); // hours_flag f(1) if (hours_flag) { - aom_rb_read_literal(&rb, 5); // hours_value f(5) + aom_rb_read_literal(rb, 5); // hours_value f(5) } } } } // time_offset_length f(5) - int time_offset_length = aom_rb_read_literal(&rb, 5); + const int time_offset_length = aom_rb_read_literal(rb, 5); if (time_offset_length) { - aom_rb_read_literal(&rb, time_offset_length); // f(time_offset_length) + // time_offset_value f(time_offset_length) + aom_rb_read_literal(rb, time_offset_length); } } -static size_t read_metadata(const uint8_t *data, size_t sz) { +// Returns the last nonzero byte in 'data'. If there is no nonzero byte in +// 'data', returns 0. +// +// Call this function to check the following requirement in the spec: +// This implies that when any payload data is present for this OBU type, at +// least one byte of the payload data (including the trailing bit) shall not +// be equal to 0. +static uint8_t get_last_nonzero_byte(const uint8_t *data, size_t sz) { + // Scan backward and return on the first nonzero byte. + size_t i = sz; + while (i != 0) { + --i; + if (data[i] != 0) return data[i]; + } + return 0; +} + +// Checks the metadata for correct syntax but ignores the parsed metadata. +// +// On success, returns the number of bytes read from 'data'. On failure, sets +// pbi->common.error.error_code and returns 0, or calls aom_internal_error() +// and does not return. +static size_t read_metadata(AV1Decoder *pbi, const uint8_t *data, size_t sz) { + AV1_COMMON *const cm = &pbi->common; size_t type_length; uint64_t type_value; - OBU_METADATA_TYPE metadata_type; if (aom_uleb_decode(data, sz, &type_value, &type_length) < 0) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + const OBU_METADATA_TYPE metadata_type = (OBU_METADATA_TYPE)type_value; + if (metadata_type == 0 || metadata_type >= 6) { + // If metadata_type is reserved for future use or a user private value, + // ignore the entire OBU and just check trailing bits. + if (get_last_nonzero_byte(data + type_length, sz - type_length) == 0) { + pbi->common.error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } return sz; } - metadata_type = (OBU_METADATA_TYPE)type_value; if (metadata_type == OBU_METADATA_TYPE_ITUT_T35) { - read_metadata_itut_t35(data + type_length, sz - type_length); + size_t bytes_read = + type_length + + read_metadata_itut_t35(pbi, data + type_length, sz - type_length); + // itu_t_t35_payload_bytes is byte aligned and the first + // trailing byte should be 0x80. + if (get_last_nonzero_byte(data + bytes_read, sz - bytes_read) != 0x80) { + pbi->common.error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + return sz; } else if (metadata_type == OBU_METADATA_TYPE_HDR_CLL) { - read_metadata_hdr_cll(data + type_length, sz - type_length); + size_t bytes_read = + type_length + + read_metadata_hdr_cll(pbi, data + type_length, sz - type_length); + if (get_last_nonzero_byte(data + bytes_read, sz - bytes_read) != 0x80) { + pbi->common.error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + return sz; } else if (metadata_type == OBU_METADATA_TYPE_HDR_MDCV) { - read_metadata_hdr_mdcv(data + type_length, sz - type_length); - } else if (metadata_type == OBU_METADATA_TYPE_SCALABILITY) { - read_metadata_scalability(data + type_length, sz - type_length); - } else if (metadata_type == OBU_METADATA_TYPE_TIMECODE) { - read_metadata_timecode(data + type_length, sz - type_length); + size_t bytes_read = + type_length + + read_metadata_hdr_mdcv(pbi, data + type_length, sz - type_length); + if (get_last_nonzero_byte(data + bytes_read, sz - bytes_read) != 0x80) { + pbi->common.error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + return sz; } + struct aom_read_bit_buffer rb; + av1_init_read_bit_buffer(pbi, &rb, data + type_length, data + sz); + if (metadata_type == OBU_METADATA_TYPE_SCALABILITY) { + read_metadata_scalability(&rb); + } else { + assert(metadata_type == OBU_METADATA_TYPE_TIMECODE); + read_metadata_timecode(&rb); + } + if (av1_check_trailing_bits(pbi, &rb) != 0) { + // cm->error.error_code is already set. + return 0; + } + assert((rb.bit_offset & 7) == 0); + return type_length + (rb.bit_offset >> 3); +} + +// On success, returns 'sz'. On failure, sets pbi->common.error.error_code and +// returns 0. +static size_t read_padding(AV1_COMMON *const cm, const uint8_t *data, + size_t sz) { + // The spec allows a padding OBU to be header-only (i.e., obu_size = 0). So + // check trailing bits only if sz > 0. + if (sz > 0) { + // The payload of a padding OBU is byte aligned. Therefore the first + // trailing byte should be 0x80. See https://crbug.com/aomedia/2393. + const uint8_t last_nonzero_byte = get_last_nonzero_byte(data, sz); + if (last_nonzero_byte != 0x80) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return 0; + } + } return sz; } @@ -649,17 +864,18 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, ObuHeader obu_header; memset(&obu_header, 0, sizeof(obu_header)); pbi->seen_frame_header = 0; + pbi->next_start_tile = 0; if (data_end < data) { cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; return -1; } - // Reset pbi->camera_frame_header_ready to 0 if cm->large_scale_tile = 0. - if (!cm->large_scale_tile) pbi->camera_frame_header_ready = 0; + // Reset pbi->camera_frame_header_ready to 0 if cm->tiles.large_scale = 0. + if (!cm->tiles.large_scale) pbi->camera_frame_header_ready = 0; // decode frame as a series of OBUs - while (!frame_decoding_finished && !cm->error.error_code) { + while (!frame_decoding_finished && cm->error.error_code == AOM_CODEC_OK) { struct aom_read_bit_buffer rb; size_t payload_size = 0; size_t decoded_payload_size = 0; @@ -674,7 +890,7 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, } aom_codec_err_t status = - aom_read_obu_header_and_size(data, bytes_available, cm->is_annexb, + aom_read_obu_header_and_size(data, bytes_available, pbi->is_annexb, &obu_header, &payload_size, &bytes_read); if (status != AOM_CODEC_OK) { @@ -714,21 +930,39 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, case OBU_TEMPORAL_DELIMITER: decoded_payload_size = read_temporal_delimiter_obu(); pbi->seen_frame_header = 0; + pbi->next_start_tile = 0; break; case OBU_SEQUENCE_HEADER: decoded_payload_size = read_sequence_header_obu(pbi, &rb); if (cm->error.error_code != AOM_CODEC_OK) return -1; + // The sequence header should not change in the middle of a frame. + if (pbi->sequence_header_changed && pbi->seen_frame_header) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } break; case OBU_FRAME_HEADER: case OBU_REDUNDANT_FRAME_HEADER: case OBU_FRAME: + if (obu_header.type == OBU_REDUNDANT_FRAME_HEADER) { + if (!pbi->seen_frame_header) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + } else { + // OBU_FRAME_HEADER or OBU_FRAME. + if (pbi->seen_frame_header) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } + } // Only decode first frame header received if (!pbi->seen_frame_header || - (cm->large_scale_tile && !pbi->camera_frame_header_ready)) { + (cm->tiles.large_scale && !pbi->camera_frame_header_ready)) { frame_header_size = read_frame_header_obu( pbi, &rb, data, p_data_end, obu_header.type != OBU_FRAME); pbi->seen_frame_header = 1; - if (!pbi->ext_tile_debug && cm->large_scale_tile) + if (!pbi->ext_tile_debug && cm->tiles.large_scale) pbi->camera_frame_header_ready = 1; } else { // TODO(wtc): Verify that the frame_header_obu is identical to the @@ -769,6 +1003,7 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, if (obu_header.type != OBU_FRAME) break; obu_payload_offset = frame_header_size; // Byte align the reader before reading the tile group. + // byte_alignment() has set cm->error.error_code if it returns -1. if (byte_alignment(cm, &rb)) return -1; AOM_FALLTHROUGH_INTENDED; // fall through to read tile group. case OBU_TILE_GROUP: @@ -784,11 +1019,13 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, pbi, &rb, is_first_tg_obu_received, data + obu_payload_offset, data + payload_size, p_data_end, &frame_decoding_finished, obu_header.type == OBU_FRAME); + if (cm->error.error_code != AOM_CODEC_OK) return -1; is_first_tg_obu_received = 0; if (frame_decoding_finished) pbi->seen_frame_header = 0; break; case OBU_METADATA: - decoded_payload_size = read_metadata(data, payload_size); + decoded_payload_size = read_metadata(pbi, data, payload_size); + if (cm->error.error_code != AOM_CODEC_OK) return -1; break; case OBU_TILE_LIST: if (CONFIG_NORMAL_TILE_MODE) { @@ -803,7 +1040,7 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, return -1; } - cm->large_scale_tile = 1; + cm->tiles.large_scale = 1; av1_set_single_tile_decoding_mode(cm); decoded_payload_size = read_and_decode_one_tile_list(pbi, &rb, data, data + payload_size, @@ -811,8 +1048,16 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, if (cm->error.error_code != AOM_CODEC_OK) return -1; break; case OBU_PADDING: + decoded_payload_size = read_padding(&pbi->common, data, payload_size); + if (cm->error.error_code != AOM_CODEC_OK) return -1; + break; default: // Skip unrecognized OBUs + if (payload_size > 0 && + get_last_nonzero_byte(data, payload_size) == 0) { + cm->error.error_code = AOM_CODEC_CORRUPT_FRAME; + return -1; + } decoded_payload_size = payload_size; break; } @@ -835,5 +1080,6 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, data += payload_size; } + if (cm->error.error_code != AOM_CODEC_OK) return -1; return frame_decoding_finished; } diff --git a/media/libaom/src/av1/decoder/obu.h b/media/libaom/src/av1/decoder/obu.h index 5ab243fc90..d8ebe368e6 100644 --- a/media/libaom/src/av1/decoder/obu.h +++ b/media/libaom/src/av1/decoder/obu.h @@ -25,7 +25,7 @@ int aom_decode_frame_from_obus(struct AV1Decoder *pbi, const uint8_t *data, const uint8_t **p_data_end); aom_codec_err_t aom_get_num_layers_from_operating_point_idc( - int operating_point_idc, unsigned int *num_spatial_layers, - unsigned int *num_temporal_layers); + int operating_point_idc, unsigned int *number_spatial_layers, + unsigned int *number_temporal_layers); #endif // AOM_AV1_DECODER_OBU_H_ |