Move sb_size to sequence header
sb_size, mib_size and mib_size_log2 have been moved from the AV1_COMMON struct
to the SequenceHeader struct, as they are sequence-level parameters. sb_size is
now written to and read from the end of the sequence header.
BUG=aomedia:996
Change-Id: I9d450518a1b898677976acd80088b8ea9ee9d7ce
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index deab086..287abf6 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -1383,7 +1383,8 @@
// Determine the vertical edges that need filtering
int idx_c;
- for (idx_c = 0; idx_c < cm->mib_size && mi_col + idx_c < cm->mi_cols;
+ for (idx_c = 0;
+ idx_c < cm->seq_params.mib_size && mi_col + idx_c < cm->mi_cols;
idx_c += col_step) {
const MODE_INFO *mi = mib[idx_r * cm->mi_stride + idx_c];
const MB_MODE_INFO *mbmi = &mi[0].mbmi;
@@ -1565,7 +1566,8 @@
uint8_t lfl[MAX_MIB_SIZE][MAX_MIB_SIZE] = { { 0 } };
int idx_r;
- for (idx_r = 0; idx_r < cm->mib_size && mi_row + idx_r < cm->mi_rows;
+ for (idx_r = 0;
+ idx_r < cm->seq_params.mib_size && mi_row + idx_r < cm->mi_rows;
idx_r += row_step) {
unsigned int mask_4x4_int;
FilterMasks col_masks;
@@ -1614,7 +1616,8 @@
uint8_t lfl[MAX_MIB_SIZE][MAX_MIB_SIZE] = { { 0 } };
int idx_r;
- for (idx_r = 0; idx_r < cm->mib_size && mi_row + idx_r < cm->mi_rows;
+ for (idx_r = 0;
+ idx_r < cm->seq_params.mib_size && mi_row + idx_r < cm->mi_rows;
idx_r += row_step) {
unsigned int mask_4x4_int;
FilterMasks row_masks;
@@ -1663,7 +1666,7 @@
assert(plane->subsampling_x == 0 && plane->subsampling_y == 0);
// Vertical pass: do 2 rows at one time
- for (r = 0; r < cm->mib_size && mi_row + r < cm->mi_rows; r += 2) {
+ for (r = 0; r < cm->seq_params.mib_size && mi_row + r < cm->mi_rows; r += 2) {
unsigned int mask_16x16_l = mask_16x16 & 0xffff;
unsigned int mask_8x8_l = mask_8x8 & 0xffff;
unsigned int mask_4x4_l = mask_4x4 & 0xffff;
@@ -1704,7 +1707,7 @@
assert(plane->subsampling_x == 0 && plane->subsampling_y == 0);
- for (r = 0; r < cm->mib_size && mi_row + r < cm->mi_rows; r++) {
+ for (r = 0; r < cm->seq_params.mib_size && mi_row + r < cm->mi_rows; r++) {
unsigned int mask_16x16_r;
unsigned int mask_8x8_r;
unsigned int mask_4x4_r;
@@ -1756,8 +1759,8 @@
memset(lfm->lfl_uv, 0, sizeof(lfm->lfl_uv));
// Vertical pass: do 2 rows at one time
- for (r = 0; r < cm->mib_size && mi_row + r < cm->mi_rows; r += 4) {
- for (c = 0; c < (cm->mib_size >> 1); c++) {
+ for (r = 0; r < cm->seq_params.mib_size && mi_row + r < cm->mi_rows; r += 4) {
+ for (c = 0; c < (cm->seq_params.mib_size >> 1); c++) {
lfm->lfl_uv[r >> 1][c] = lfm->lfl_y[r][c << 1];
lfm->lfl_uv[(r + 2) >> 1][c] = lfm->lfl_y[r + 2][c << 1];
}
@@ -1808,14 +1811,14 @@
// re-porpulate the filter level for uv, same as the code for vertical
// filter in av1_filter_block_plane_ss11_ver
- for (r = 0; r < cm->mib_size && mi_row + r < cm->mi_rows; r += 4) {
- for (c = 0; c < (cm->mib_size >> 1); c++) {
+ for (r = 0; r < cm->seq_params.mib_size && mi_row + r < cm->mi_rows; r += 4) {
+ for (c = 0; c < (cm->seq_params.mib_size >> 1); c++) {
lfm->lfl_uv[r >> 1][c] = lfm->lfl_y[r][c << 1];
lfm->lfl_uv[(r + 2) >> 1][c] = lfm->lfl_y[r + 2][c << 1];
}
}
- for (r = 0; r < cm->mib_size && mi_row + r < cm->mi_rows; r += 2) {
+ for (r = 0; r < cm->seq_params.mib_size && mi_row + r < cm->mi_rows; r += 2) {
const int skip_border_4x4_r = mi_row + r == cm->mi_rows - 1;
const unsigned int mask_4x4_int_r =
skip_border_4x4_r ? 0 : (mask_4x4_int & 0xf);
@@ -2369,13 +2372,14 @@
#if !CONFIG_PARALLEL_DEBLOCKING
for (int i = 0; i < nplanes; ++i)
memset(cm->top_txfm_context[i], TX_32X32, cm->mi_cols << TX_UNIT_WIDE_LOG2);
- for (mi_row = start; mi_row < stop; mi_row += cm->mib_size) {
+ for (mi_row = start; mi_row < stop; mi_row += cm->seq_params.mib_size) {
MODE_INFO **mi = cm->mi_grid_visible + mi_row * cm->mi_stride;
for (int i = 0; i < nplanes; ++i)
memset(cm->left_txfm_context[i], TX_32X32,
MAX_MIB_SIZE << TX_UNIT_HIGH_LOG2);
- for (mi_col = 0; mi_col < cm->mi_cols; mi_col += cm->mib_size) {
- av1_setup_dst_planes(planes, cm->sb_size, frame_buffer, mi_row, mi_col);
+ for (mi_col = 0; mi_col < cm->mi_cols; mi_col += cm->seq_params.mib_size) {
+ av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer, mi_row,
+ mi_col);
for (plane = plane_start; plane < plane_end; ++plane) {
av1_filter_block_plane_non420_ver(cm, &planes[plane], mi + mi_col,
@@ -2390,8 +2394,8 @@
// filter all vertical edges in every 64x64 super block
for (mi_row = start; mi_row < stop; mi_row += MAX_MIB_SIZE) {
for (mi_col = col_start; mi_col < col_end; mi_col += MAX_MIB_SIZE) {
- av1_setup_dst_planes(planes, cm->sb_size, frame_buffer, mi_row, mi_col,
- num_planes);
+ av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer, mi_row,
+ mi_col, num_planes);
for (plane = plane_start; plane < plane_end; ++plane) {
av1_filter_block_plane_vert(cm, plane, &planes[plane], mi_row, mi_col);
}
@@ -2401,8 +2405,8 @@
// filter all horizontal edges in every 64x64 super block
for (mi_row = start; mi_row < stop; mi_row += MAX_MIB_SIZE) {
for (mi_col = col_start; mi_col < col_end; mi_col += MAX_MIB_SIZE) {
- av1_setup_dst_planes(planes, cm->sb_size, frame_buffer, mi_row, mi_col,
- num_planes);
+ av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer, mi_row,
+ mi_col, num_planes);
for (plane = plane_start; plane < plane_end; ++plane) {
av1_filter_block_plane_horz(cm, plane, &planes[plane], mi_row, mi_col);
}
diff --git a/av1/common/cdef.c b/av1/common/cdef.c
index bd37b2b..8046f08 100644
--- a/av1/common/cdef.c
+++ b/av1/common/cdef.c
@@ -166,7 +166,8 @@
int coeff_shift = AOMMAX(cm->bit_depth - 8, 0);
const int nvfb = (cm->mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
const int nhfb = (cm->mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
- av1_setup_dst_planes(xd->plane, cm->sb_size, frame, 0, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0,
+ num_planes);
row_cdef = aom_malloc(sizeof(*row_cdef) * (nhfb + 2) * 2);
memset(row_cdef, 1, sizeof(*row_cdef) * (nhfb + 2) * 2);
prev_row_cdef = row_cdef + 1;
diff --git a/av1/common/mvref_common.c b/av1/common/mvref_common.c
index 2122855..4777f2d 100644
--- a/av1/common/mvref_common.c
+++ b/av1/common/mvref_common.c
@@ -384,7 +384,7 @@
static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd,
int mi_row, int mi_col, int bs) {
- const int sb_mi_size = mi_size_wide[cm->sb_size];
+ const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
const int mask_row = mi_row & (sb_mi_size - 1);
const int mask_col = mi_col & (sb_mi_size - 1);
@@ -434,7 +434,7 @@
static int check_sb_border(const AV1_COMMON *cm, const int mi_row,
const int mi_col, const int row_offset,
const int col_offset) {
- const int sb_mi_size = mi_size_wide[cm->sb_size];
+ const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
const int row = mi_row & (sb_mi_size - 1);
const int col = mi_col & (sb_mi_size - 1);
@@ -989,7 +989,7 @@
int16_t *mode_context, int_mv zeromv,
uint8_t refmv_count) {
const int *ref_sign_bias = cm->ref_frame_sign_bias;
- const int sb_mi_size = mi_size_wide[cm->sb_size];
+ const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
int i;
int context_counter = 0;
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index df510bd..e73dad6 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -222,6 +222,9 @@
int frame_id_numbers_present_flag;
int frame_id_length;
int delta_frame_id_length;
+ BLOCK_SIZE sb_size; // Size of the superblock used for this frame
+ int mib_size; // Size of the superblock in units of MI blocks
+ int mib_size_log2; // Log 2 of above.
#if CONFIG_MONO_VIDEO
int monochrome;
#endif // CONFIG_MONO_VIDEO
@@ -553,9 +556,6 @@
int film_grain_params_present;
aom_film_grain_t film_grain_params;
#endif
- BLOCK_SIZE sb_size; // Size of the superblock used for this frame
- int mib_size; // Size of the superblock in units of MI blocks
- int mib_size_log2; // Log 2 of above.
int cdef_pri_damping;
int cdef_sec_damping;
int nb_cdef_strengths;
@@ -746,11 +746,11 @@
}
static INLINE int mi_cols_aligned_to_sb(const AV1_COMMON *cm) {
- return ALIGN_POWER_OF_TWO(cm->mi_cols, cm->mib_size_log2);
+ return ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2);
}
static INLINE int mi_rows_aligned_to_sb(const AV1_COMMON *cm) {
- return ALIGN_POWER_OF_TWO(cm->mi_rows, cm->mib_size_log2);
+ return ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
}
static INLINE int frame_is_intra_only(const AV1_COMMON *const cm) {
@@ -1180,7 +1180,8 @@
int mi_col_start, int mi_col_end) {
const int num_planes = av1_num_planes(cm);
const int width = mi_col_end - mi_col_start;
- const int aligned_width = ALIGN_POWER_OF_TWO(width, cm->mib_size_log2);
+ const int aligned_width =
+ ALIGN_POWER_OF_TWO(width, cm->seq_params.mib_size_log2);
const int offset_y = mi_col_start << (MI_SIZE_LOG2 - tx_size_wide_log2[0]);
const int width_y = aligned_width << (MI_SIZE_LOG2 - tx_size_wide_log2[0]);
@@ -1377,10 +1378,11 @@
#endif
}
-static INLINE void set_sb_size(AV1_COMMON *const cm, BLOCK_SIZE sb_size) {
- cm->sb_size = sb_size;
- cm->mib_size = mi_size_wide[cm->sb_size];
- cm->mib_size_log2 = b_width_log2_lookup[cm->sb_size];
+static INLINE void set_sb_size(SequenceHeader *const seq_params,
+ BLOCK_SIZE sb_size) {
+ seq_params->sb_size = sb_size;
+ seq_params->mib_size = mi_size_wide[seq_params->sb_size];
+ seq_params->mib_size_log2 = b_width_log2_lookup[seq_params->sb_size];
}
static INLINE int all_lossless(const AV1_COMMON *cm, const MACROBLOCKD *xd) {
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index 4cf6fe7..15bfb5a 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -284,7 +284,7 @@
const int bw_in_mi_log2 = mi_width_log2_lookup[bsize];
const int bh_in_mi_log2 = mi_height_log2_lookup[bsize];
- const int sb_mi_size = mi_size_high[cm->sb_size];
+ const int sb_mi_size = mi_size_high[cm->seq_params.sb_size];
const int blk_row_in_sb = (mi_row & (sb_mi_size - 1)) >> bh_in_mi_log2;
const int blk_col_in_sb = (mi_col & (sb_mi_size - 1)) >> bw_in_mi_log2;
@@ -526,7 +526,7 @@
const int bw_in_mi_log2 = mi_width_log2_lookup[bsize];
const int bh_in_mi_log2 = mi_height_log2_lookup[bsize];
- const int sb_mi_size = mi_size_high[cm->sb_size];
+ const int sb_mi_size = mi_size_high[cm->seq_params.sb_size];
const int blk_row_in_sb = (mi_row & (sb_mi_size - 1)) >> bh_in_mi_log2;
const int blk_col_in_sb = (mi_col & (sb_mi_size - 1)) >> bw_in_mi_log2;
diff --git a/av1/common/restoration.c b/av1/common/restoration.c
index 9aabe00..e92fe80 100644
--- a/av1/common/restoration.c
+++ b/av1/common/restoration.c
@@ -1537,7 +1537,7 @@
int *rrow1, int *tile_tl_idx) {
assert(rcol0 && rcol1 && rrow0 && rrow1);
- if (bsize != cm->sb_size) return 0;
+ if (bsize != cm->seq_params.sb_size) return 0;
if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) return 0;
const int is_uv = plane > 0;
@@ -1545,7 +1545,7 @@
// Which tile contains the superblock? Find that tile's top-left in mi-units,
// together with the tile's size in pixels.
#if CONFIG_MAX_TILE
- const int mib_log2 = cm->mib_size_log2;
+ const int mib_log2 = cm->seq_params.mib_size_log2;
const int tile_row = get_tile_idx(cm->tile_row_start_sb, mi_row, mib_log2);
const int tile_col = get_tile_idx(cm->tile_col_start_sb, mi_col, mib_log2);
#else
diff --git a/av1/common/thread_common.c b/av1/common/thread_common.c
index 4eb0112..d842ece 100644
--- a/av1/common/thread_common.c
+++ b/av1/common/thread_common.c
@@ -151,16 +151,16 @@
enum lf_path path = get_loop_filter_path(lf_data->y_only, lf_data->planes);
#endif
for (mi_row = lf_data->start; mi_row < lf_data->stop;
- mi_row += lf_sync->num_workers * lf_data->cm->mib_size) {
+ mi_row += lf_sync->num_workers * lf_data->cm->seq_params.mib_size) {
MODE_INFO **const mi =
lf_data->cm->mi_grid_visible + mi_row * lf_data->cm->mi_stride;
for (mi_col = 0; mi_col < lf_data->cm->mi_cols;
- mi_col += lf_data->cm->mib_size) {
+ mi_col += lf_data->cm->seq_params.mib_size) {
LOOP_FILTER_MASK lfm;
int plane;
- av1_setup_dst_planes(lf_data->planes, lf_data->cm->sb_size,
+ av1_setup_dst_planes(lf_data->planes, lf_data->cm->seq_params.sb_size,
lf_data->frame_buffer, mi_row, mi_col,
av1_num_planes(lf_data->cm));
av1_setup_mask(lf_data->cm, mi_row, mi_col, mi + mi_col,
@@ -184,22 +184,22 @@
static int loop_filter_hor_row_worker(AV1LfSync *const lf_sync,
LFWorkerData *const lf_data) {
const int num_planes = lf_data->y_only ? 1 : MAX_MB_PLANE;
- const int sb_cols =
- mi_cols_aligned_to_sb(lf_data->cm) >> lf_data->cm->mib_size_log2;
+ const int sb_cols = mi_cols_aligned_to_sb(lf_data->cm) >>
+ lf_data->cm->seq_params.mib_size_log2;
int mi_row, mi_col;
#if !CONFIG_EXT_PARTITION_TYPES
enum lf_path path = get_loop_filter_path(lf_data->y_only, lf_data->planes);
#endif
for (mi_row = lf_data->start; mi_row < lf_data->stop;
- mi_row += lf_sync->num_workers * lf_data->cm->mib_size) {
+ mi_row += lf_sync->num_workers * lf_data->cm->seq_params.mib_size) {
MODE_INFO **const mi =
lf_data->cm->mi_grid_visible + mi_row * lf_data->cm->mi_stride;
for (mi_col = 0; mi_col < lf_data->cm->mi_cols;
- mi_col += lf_data->cm->mib_size) {
- const int r = mi_row >> lf_data->cm->mib_size_log2;
- const int c = mi_col >> lf_data->cm->mib_size_log2;
+ mi_col += lf_data->cm->seq_params.mib_size) {
+ const int r = mi_row >> lf_data->cm->seq_params.mib_size_log2;
+ const int c = mi_col >> lf_data->cm->seq_params.mib_size_log2;
LOOP_FILTER_MASK lfm;
int plane;
@@ -207,7 +207,7 @@
// the outer loop to column-based and remove the synchronizations here.
sync_read(lf_sync, r, c);
- av1_setup_dst_planes(lf_data->planes, lf_data->cm->sb_size,
+ av1_setup_dst_planes(lf_data->planes, lf_data->cm->seq_params.sb_size,
lf_data->frame_buffer, mi_row, mi_col,
av1_num_planes(lf_data->cm));
av1_setup_mask(lf_data->cm, mi_row, mi_col, mi + mi_col,
@@ -230,8 +230,8 @@
static int loop_filter_row_worker(AV1LfSync *const lf_sync,
LFWorkerData *const lf_data) {
const int num_planes = lf_data->y_only ? 1 : MAX_MB_PLANE;
- const int sb_cols =
- mi_cols_aligned_to_sb(lf_data->cm) >> lf_data->cm->mib_size_log2;
+ const int sb_cols = mi_cols_aligned_to_sb(lf_data->cm) >>
+ lf_data->cm->seq_params.mib_size_log2;
int mi_row, mi_col;
#if !CONFIG_EXT_PARTITION_TYPES
enum lf_path path = get_loop_filter_path(lf_data->y_only, lf_data->planes);
@@ -245,14 +245,14 @@
#endif // CONFIG_EXT_PARTITION
for (mi_row = lf_data->start; mi_row < lf_data->stop;
- mi_row += lf_sync->num_workers * lf_data->cm->mib_size) {
+ mi_row += lf_sync->num_workers * lf_data->cm->seq_params.mib_size) {
MODE_INFO **const mi =
lf_data->cm->mi_grid_visible + mi_row * lf_data->cm->mi_stride;
for (mi_col = 0; mi_col < lf_data->cm->mi_cols;
- mi_col += lf_data->cm->mib_size) {
- const int r = mi_row >> lf_data->cm->mib_size_log2;
- const int c = mi_col >> lf_data->cm->mib_size_log2;
+ mi_col += lf_data->cm->seq_params.mib_size) {
+ const int r = mi_row >> lf_data->cm->seq_params.mib_size_log2;
+ const int c = mi_col >> lf_data->cm->seq_params.mib_size_log2;
#if !CONFIG_EXT_PARTITION_TYPES
LOOP_FILTER_MASK lfm;
#endif
@@ -260,7 +260,7 @@
sync_read(lf_sync, r, c);
- av1_setup_dst_planes(lf_data->planes, lf_data->cm->sb_size,
+ av1_setup_dst_planes(lf_data->planes, lf_data->cm->seq_params.sb_size,
lf_data->frame_buffer, mi_row, mi_col);
#if CONFIG_EXT_PARTITION_TYPES
for (plane = 0; plane < num_planes; ++plane) {
@@ -300,7 +300,7 @@
const AVxWorkerInterface *const winterface = aom_get_worker_interface();
// Number of superblock rows and cols
- const int sb_rows = mi_rows_aligned_to_sb(cm) >> cm->mib_size_log2;
+ const int sb_rows = mi_rows_aligned_to_sb(cm) >> cm->seq_params.mib_size_log2;
// Decoder may allocate more threads than number of tiles based on user's
// input.
const int tile_cols = cm->tile_cols;
@@ -338,7 +338,7 @@
// Loopfilter data
av1_loop_filter_data_reset(lf_data, frame, cm, planes);
- lf_data->start = start + i * cm->mib_size;
+ lf_data->start = start + i * cm->seq_params.mib_size;
lf_data->stop = stop;
lf_data->y_only = y_only;
@@ -367,7 +367,7 @@
// Loopfilter data
av1_loop_filter_data_reset(lf_data, frame, cm, planes);
- lf_data->start = start + i * cm->mib_size;
+ lf_data->start = start + i * cm->seq_params.mib_size;
lf_data->stop = stop;
lf_data->y_only = y_only;
@@ -397,7 +397,7 @@
// Loopfilter data
av1_loop_filter_data_reset(lf_data, frame, cm, planes);
- lf_data->start = start + i * cm->mib_size;
+ lf_data->start = start + i * cm->seq_params.mib_size;
lf_data->stop = stop;
lf_data->y_only = y_only;
diff --git a/av1/common/tile_common.c b/av1/common/tile_common.c
index 7d41591..43da68c 100644
--- a/av1/common/tile_common.c
+++ b/av1/common/tile_common.c
@@ -58,10 +58,10 @@
}
void av1_get_tile_limits(AV1_COMMON *const cm) {
- int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->mib_size_log2);
- int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->mib_size_log2);
- int sb_cols = mi_cols >> cm->mib_size_log2;
- int sb_rows = mi_rows >> cm->mib_size_log2;
+ int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2);
+ int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
+ int sb_cols = mi_cols >> cm->seq_params.mib_size_log2;
+ int sb_rows = mi_rows >> cm->seq_params.mib_size_log2;
cm->min_log2_tile_cols = tile_log2(MAX_TILE_WIDTH_SB, sb_cols);
cm->max_log2_tile_cols = tile_log2(1, AOMMIN(sb_cols, MAX_TILE_COLS));
@@ -73,10 +73,10 @@
}
void av1_calculate_tile_cols(AV1_COMMON *const cm) {
- int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->mib_size_log2);
- int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->mib_size_log2);
- int sb_cols = mi_cols >> cm->mib_size_log2;
- int sb_rows = mi_rows >> cm->mib_size_log2;
+ int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2);
+ int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
+ int sb_cols = mi_cols >> cm->seq_params.mib_size_log2;
+ int sb_rows = mi_rows >> cm->seq_params.mib_size_log2;
int i;
if (cm->uniform_tile_spacing_flag) {
@@ -108,8 +108,8 @@
}
void av1_calculate_tile_rows(AV1_COMMON *const cm) {
- int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->mib_size_log2);
- int sb_rows = mi_rows >> cm->mib_size_log2;
+ int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
+ int sb_rows = mi_rows >> cm->seq_params.mib_size_log2;
int start_sb, size_sb, i;
if (cm->uniform_tile_spacing_flag) {
@@ -140,8 +140,9 @@
void av1_tile_set_row(TileInfo *tile, const AV1_COMMON *cm, int row) {
assert(row < cm->tile_rows);
- int mi_row_start = cm->tile_row_start_sb[row] << cm->mib_size_log2;
- int mi_row_end = cm->tile_row_start_sb[row + 1] << cm->mib_size_log2;
+ int mi_row_start = cm->tile_row_start_sb[row] << cm->seq_params.mib_size_log2;
+ int mi_row_end = cm->tile_row_start_sb[row + 1]
+ << cm->seq_params.mib_size_log2;
tile->mi_row_start = mi_row_start;
tile->mi_row_end = AOMMIN(mi_row_end, cm->mi_rows);
assert(tile->mi_row_end > tile->mi_row_start);
@@ -149,8 +150,9 @@
void av1_tile_set_col(TileInfo *tile, const AV1_COMMON *cm, int col) {
assert(col < cm->tile_cols);
- int mi_col_start = cm->tile_col_start_sb[col] << cm->mib_size_log2;
- int mi_col_end = cm->tile_col_start_sb[col + 1] << cm->mib_size_log2;
+ int mi_col_start = cm->tile_col_start_sb[col] << cm->seq_params.mib_size_log2;
+ int mi_col_end = cm->tile_col_start_sb[col + 1]
+ << cm->seq_params.mib_size_log2;
tile->mi_col_start = mi_col_start;
tile->mi_col_end = AOMMIN(mi_col_end, cm->mi_cols);
assert(tile->mi_col_end > tile->mi_col_start);
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index ddd7825..1aebfaa 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -1260,12 +1260,13 @@
pool->frame_bufs[cm->new_fb_idx].buf.render_height = cm->render_height;
}
-static void setup_sb_size(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
+static void setup_sb_size(SequenceHeader *seq_params,
+ struct aom_read_bit_buffer *rb) {
(void)rb;
#if CONFIG_EXT_PARTITION
- set_sb_size(cm, aom_rb_read_bit(rb) ? BLOCK_128X128 : BLOCK_64X64);
+ set_sb_size(seq_params, aom_rb_read_bit(rb) ? BLOCK_128X128 : BLOCK_64X64);
#else
- set_sb_size(cm, BLOCK_64X64);
+ set_sb_size(seq_params, BLOCK_64X64);
#endif // CONFIG_EXT_PARTITION
}
@@ -1411,10 +1412,10 @@
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->mib_size_log2);
- int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->mib_size_log2);
- int width_sb = width_mi >> cm->mib_size_log2;
- int height_sb = height_mi >> cm->mib_size_log2;
+ int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2);
+ int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
+ int width_sb = width_mi >> cm->seq_params.mib_size_log2;
+ int height_sb = height_mi >> cm->seq_params.mib_size_log2;
av1_get_tile_limits(cm);
cm->uniform_tile_spacing_flag = aom_rb_read_bit(rb);
@@ -1498,7 +1499,7 @@
;
// Read the tile width/height
#if CONFIG_EXT_PARTITION
- if (cm->sb_size == BLOCK_128X128) {
+ if (cm->seq_params.sb_size == BLOCK_128X128) {
cm->tile_width = aom_rb_read_literal(rb, 5) + 1;
cm->tile_height = aom_rb_read_literal(rb, 5) + 1;
} else {
@@ -1509,8 +1510,8 @@
}
#endif // CONFIG_EXT_PARTITION
- cm->tile_width <<= cm->mib_size_log2;
- cm->tile_height <<= cm->mib_size_log2;
+ cm->tile_width <<= cm->seq_params.mib_size_log2;
+ cm->tile_height <<= cm->seq_params.mib_size_log2;
cm->tile_width = AOMMIN(cm->tile_width, cm->mi_cols);
cm->tile_height = AOMMIN(cm->tile_height, cm->mi_rows);
@@ -1553,11 +1554,11 @@
#if CONFIG_MAX_TILE
for (int i = 0; i <= cm->tile_cols; i++) {
cm->tile_col_start_sb[i] =
- ((i * cm->tile_width - 1) >> cm->mib_size_log2) + 1;
+ ((i * cm->tile_width - 1) >> cm->seq_params.mib_size_log2) + 1;
}
for (int i = 0; i <= cm->tile_rows; i++) {
cm->tile_row_start_sb[i] =
- ((i * cm->tile_height - 1) >> cm->mib_size_log2) + 1;
+ ((i * cm->tile_height - 1) >> cm->seq_params.mib_size_log2) + 1;
}
#endif // CONFIG_MAX_TILE
} else {
@@ -2066,13 +2067,13 @@
#endif // CONFIG_LOOPFILTERING_ACROSS_TILES
for (mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end;
- mi_row += cm->mib_size) {
+ 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->mib_size) {
+ mi_col += cm->seq_params.mib_size) {
decode_partition(pbi, &td->xd, mi_row, mi_col, &td->bit_reader,
- cm->sb_size);
+ cm->seq_params.sb_size);
}
aom_merge_corrupted_flag(&pbi->mb.corrupted, td->xd.corrupted);
if (pbi->mb.corrupted)
@@ -2088,7 +2089,8 @@
// After loopfiltering, the last 7 row pixels in each superblock row may
// still be changed by the longest loopfilter of the next superblock row.
if (cm->frame_parallel_decode)
- av1_frameworker_broadcast(pbi->cur_buf, mi_row << cm->mib_size_log2);
+ av1_frameworker_broadcast(pbi->cur_buf,
+ mi_row << cm->seq_params.mib_size_log2);
}
#if CONFIG_INTRABC
@@ -2378,6 +2380,8 @@
seq_params->frame_id_length =
aom_rb_read_literal(rb, 3) + seq_params->delta_frame_id_length + 1;
}
+
+ setup_sb_size(seq_params, rb);
}
#endif // CONFIG_REFERENCE_BUFFER || CONFIG_OBU
@@ -2775,7 +2779,6 @@
#else
setup_frame_size(cm, rb);
#endif
- setup_sb_size(cm, rb);
if (pbi->need_resync) {
memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
@@ -2843,7 +2846,6 @@
#else
setup_frame_size(cm, rb);
#endif
- setup_sb_size(cm, rb);
if (pbi->need_resync) {
memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
pbi->need_resync = 0;
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 20a8735..be68f44 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -44,8 +44,8 @@
if (cm->all_lossless) return;
const int m = ~((1 << (6 - MI_SIZE_LOG2)) - 1);
- if (!(mi_col & (cm->mib_size - 1)) &&
- !(mi_row & (cm->mib_size - 1))) { // Top left?
+ if (!(mi_col & (cm->seq_params.mib_size - 1)) &&
+ !(mi_row & (cm->seq_params.mib_size - 1))) { // Top left?
#if CONFIG_EXT_PARTITION
cm->cdef_preset[0] = cm->cdef_preset[1] = cm->cdef_preset[2] =
cm->cdef_preset[3] = -1;
@@ -56,7 +56,7 @@
// Read CDEF param at first a non-skip coding block
#if CONFIG_EXT_PARTITION
const int mask = 1 << (6 - MI_SIZE_LOG2);
- const int index = cm->sb_size == BLOCK_128X128
+ const int index = cm->seq_params.sb_size == BLOCK_128X128
? !!(mi_col & mask) + 2 * !!(mi_row & mask)
: 0;
cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]
@@ -77,13 +77,14 @@
MB_MODE_INFO *const mbmi, int mi_col, int mi_row) {
int sign, abs, reduced_delta_qindex = 0;
BLOCK_SIZE bsize = mbmi->sb_type;
- const int b_col = mi_col & (cm->mib_size - 1);
- const int b_row = mi_row & (cm->mib_size - 1);
+ const int b_col = mi_col & (cm->seq_params.mib_size - 1);
+ const int b_row = mi_row & (cm->seq_params.mib_size - 1);
const int read_delta_q_flag = (b_col == 0 && b_row == 0);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
(void)cm;
- if ((bsize != cm->sb_size || mbmi->skip == 0) && read_delta_q_flag) {
+ if ((bsize != cm->seq_params.sb_size || mbmi->skip == 0) &&
+ read_delta_q_flag) {
abs = aom_read_symbol(r, ec_ctx->delta_q_cdf, DELTA_Q_PROBS + 1, ACCT_STR);
const int smallval = (abs < DELTA_Q_SMALL);
@@ -112,13 +113,14 @@
int mi_row) {
int sign, abs, reduced_delta_lflevel = 0;
BLOCK_SIZE bsize = mbmi->sb_type;
- const int b_col = mi_col & (cm->mib_size - 1);
- const int b_row = mi_row & (cm->mib_size - 1);
+ const int b_col = mi_col & (cm->seq_params.mib_size - 1);
+ const int b_row = mi_row & (cm->seq_params.mib_size - 1);
const int read_delta_lf_flag = (b_col == 0 && b_row == 0);
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
(void)cm;
- if ((bsize != cm->sb_size || mbmi->skip == 0) && read_delta_lf_flag) {
+ if ((bsize != cm->seq_params.sb_size || mbmi->skip == 0) &&
+ read_delta_lf_flag) {
#if CONFIG_LOOPFILTER_LEVEL
if (cm->delta_lf_multi) {
assert(lf_id >= 0 && lf_id < FRAME_LF_COUNT);
@@ -906,7 +908,7 @@
mv->as_mv.row = (mv->as_mv.row >> 3) * 8;
int valid = is_mv_valid(&mv->as_mv) &&
av1_is_dv_valid(mv->as_mv, &xd->tile, mi_row, mi_col, bsize,
- cm->mib_size_log2);
+ cm->seq_params.mib_size_log2);
return valid;
}
#endif // CONFIG_INTRABC
@@ -959,7 +961,8 @@
#endif
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->mib_size, mi_row, mi_col);
+ av1_find_ref_dv(&dv_ref, &xd->tile, cm->seq_params.mib_size, mi_row,
+ mi_col);
// Ref DV should not have sub-pel.
int valid_dv = (dv_ref.as_mv.col & 7) == 0 && (dv_ref.as_mv.row & 7) == 0;
dv_ref.as_mv.col = (dv_ref.as_mv.col >> 3) * 8;
@@ -1625,7 +1628,7 @@
static void fpm_sync(void *const data, int mi_row) {
AV1Decoder *const pbi = (AV1Decoder *)data;
av1_frameworker_wait(pbi->frame_worker_owner, pbi->common.prev_frame,
- mi_row << pbi->common.mib_size_log2);
+ mi_row << pbi->common.seq_params.mib_size_log2);
}
#if DEC_MISMATCH_DEBUG
diff --git a/av1/encoder/aq_complexity.c b/av1/encoder/aq_complexity.c
index cb08ef5..633c4ad 100644
--- a/av1/encoder/aq_complexity.c
+++ b/av1/encoder/aq_complexity.c
@@ -138,7 +138,7 @@
// It is converted to bits << AV1_PROB_COST_SHIFT units.
const int64_t num = (int64_t)(cpi->rc.sb64_target_rate * xmis * ymis)
<< AV1_PROB_COST_SHIFT;
- const int denom = cm->mib_size * cm->mib_size;
+ const int denom = cm->seq_params.mib_size * cm->seq_params.mib_size;
const int target_rate = (int)(num / denom);
double logvar;
double low_var_thresh;
diff --git a/av1/encoder/aq_cyclicrefresh.c b/av1/encoder/aq_cyclicrefresh.c
index a45a0ef..8d27068 100644
--- a/av1/encoder/aq_cyclicrefresh.c
+++ b/av1/encoder/aq_cyclicrefresh.c
@@ -389,8 +389,10 @@
int i, block_count, bl_index, sb_rows, sb_cols, sbs_in_frame;
int xmis, ymis, x, y;
memset(seg_map, CR_SEGMENT_ID_BASE, cm->mi_rows * cm->mi_cols);
- sb_cols = (cm->mi_cols + cm->mib_size - 1) / cm->mib_size;
- sb_rows = (cm->mi_rows + cm->mib_size - 1) / cm->mib_size;
+ sb_cols =
+ (cm->mi_cols + cm->seq_params.mib_size - 1) / cm->seq_params.mib_size;
+ sb_rows =
+ (cm->mi_rows + cm->seq_params.mib_size - 1) / cm->seq_params.mib_size;
sbs_in_frame = sb_cols * sb_rows;
// Number of target blocks to get the q delta (segment 1).
block_count = cr->percent_refresh * cm->mi_rows * cm->mi_cols / 100;
@@ -406,8 +408,8 @@
// Get the mi_row/mi_col corresponding to superblock index i.
int sb_row_index = (i / sb_cols);
int sb_col_index = i - sb_row_index * sb_cols;
- int mi_row = sb_row_index * cm->mib_size;
- int mi_col = sb_col_index * cm->mib_size;
+ int mi_row = sb_row_index * cm->seq_params.mib_size;
+ int mi_col = sb_col_index * cm->seq_params.mib_size;
int qindex_thresh =
cpi->oxcf.content == AOM_CONTENT_SCREEN
? av1_get_qindex(&cm->seg, CR_SEGMENT_ID_BOOST2, cm->base_qindex)
@@ -416,8 +418,8 @@
assert(mi_col >= 0 && mi_col < cm->mi_cols);
bl_index = mi_row * cm->mi_cols + mi_col;
// Loop through all MI blocks in superblock and update map.
- xmis = AOMMIN(cm->mi_cols - mi_col, cm->mib_size);
- ymis = AOMMIN(cm->mi_rows - mi_row, cm->mib_size);
+ xmis = AOMMIN(cm->mi_cols - mi_col, cm->seq_params.mib_size);
+ ymis = AOMMIN(cm->mi_rows - mi_row, cm->seq_params.mib_size);
for (y = 0; y < ymis; y++) {
for (x = 0; x < xmis; x++) {
const int bl_index2 = bl_index + y * cm->mi_cols + x;
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index a0a44f0..e240c02 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -1128,8 +1128,8 @@
const MB_MODE_INFO *mbmi =
&cm->mi_grid_visible[(mi_row & m) * cm->mi_stride + (mi_col & m)]->mbmi;
// Initialise when at top left part of the superblock
- if (!(mi_row & (cm->mib_size - 1)) &&
- !(mi_col & (cm->mib_size - 1))) { // Top left?
+ if (!(mi_row & (cm->seq_params.mib_size - 1)) &&
+ !(mi_col & (cm->seq_params.mib_size - 1))) { // Top left?
#if CONFIG_EXT_PARTITION
cm->cdef_preset[0] = cm->cdef_preset[1] = cm->cdef_preset[2] =
cm->cdef_preset[3] = -1;
@@ -1141,7 +1141,7 @@
// Emit CDEF param at first non-skip coding block
#if CONFIG_EXT_PARTITION
const int mask = 1 << (6 - MI_SIZE_LOG2);
- const int index = cm->sb_size == BLOCK_128X128
+ const int index = cm->seq_params.sb_size == BLOCK_128X128
? !!(mi_col & mask) + 2 * !!(mi_row & mask)
: 0;
if (cm->cdef_preset[index] == -1 && !skip) {
@@ -1257,9 +1257,11 @@
write_cdef(cm, w, skip, mi_col, mi_row);
if (cm->delta_q_present_flag) {
- int super_block_upper_left = ((mi_row & (cm->mib_size - 1)) == 0) &&
- ((mi_col & (cm->mib_size - 1)) == 0);
- if ((bsize != cm->sb_size || skip == 0) && super_block_upper_left) {
+ int super_block_upper_left =
+ ((mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
+ ((mi_col & (cm->seq_params.mib_size - 1)) == 0);
+ if ((bsize != cm->seq_params.sb_size || skip == 0) &&
+ super_block_upper_left) {
assert(mbmi->current_q_index > 0);
int reduced_delta_qindex =
(mbmi->current_q_index - xd->prev_qindex) / cm->delta_q_res;
@@ -1575,9 +1577,11 @@
write_cdef(cm, w, skip, mi_col, mi_row);
if (cm->delta_q_present_flag) {
- int super_block_upper_left = ((mi_row & (cm->mib_size - 1)) == 0) &&
- ((mi_col & (cm->mib_size - 1)) == 0);
- if ((bsize != cm->sb_size || skip == 0) && super_block_upper_left) {
+ int super_block_upper_left =
+ ((mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
+ ((mi_col & (cm->seq_params.mib_size - 1)) == 0);
+ if ((bsize != cm->seq_params.sb_size || skip == 0) &&
+ super_block_upper_left) {
assert(mbmi->current_q_index > 0);
int reduced_delta_qindex =
(mbmi->current_q_index - xd->prev_qindex) / cm->delta_q_res;
@@ -1780,7 +1784,7 @@
xd->mi = cm->mi_grid_visible + (mi_row * cm->mi_stride + mi_col);
m = xd->mi[0];
- assert(m->mbmi.sb_type <= cm->sb_size ||
+ assert(m->mbmi.sb_type <= cm->seq_params.sb_size ||
(m->mbmi.sb_type >= BLOCK_SIZES && m->mbmi.sb_type < BLOCK_SIZES_ALL));
bh = mi_size_high[m->mbmi.sb_type];
@@ -1894,7 +1898,7 @@
#endif
xd->mi = cm->mi_grid_visible + mi_offset;
- assert(mbmi->sb_type <= cm->sb_size ||
+ assert(mbmi->sb_type <= cm->seq_params.sb_size ||
(mbmi->sb_type >= BLOCK_SIZES && mbmi->sb_type < BLOCK_SIZES_ALL));
bh = mi_size_high[mbmi->sb_type];
@@ -2172,11 +2176,14 @@
#endif // CONFIG_EXT_DELTA_Q
}
- for (mi_row = mi_row_start; mi_row < mi_row_end; mi_row += cm->mib_size) {
+ for (mi_row = mi_row_start; mi_row < mi_row_end;
+ mi_row += cm->seq_params.mib_size) {
av1_zero_left_context(xd);
- for (mi_col = mi_col_start; mi_col < mi_col_end; mi_col += cm->mib_size) {
- write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col, cm->sb_size);
+ for (mi_col = mi_col_start; mi_col < mi_col_end;
+ mi_col += cm->seq_params.mib_size) {
+ write_modes_sb(cpi, tile, w, tok, tok_end, mi_row, mi_col,
+ cm->seq_params.sb_size);
}
}
}
@@ -2568,10 +2575,10 @@
static void write_tile_info_max_tile(const AV1_COMMON *const cm,
struct aom_write_bit_buffer *wb) {
- int width_mi = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->mib_size_log2);
- int height_mi = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->mib_size_log2);
- int width_sb = width_mi >> cm->mib_size_log2;
- int height_sb = height_mi >> cm->mib_size_log2;
+ 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;
int size_sb, i;
aom_wb_write_bit(wb, cm->uniform_tile_spacing_flag);
@@ -2622,18 +2629,18 @@
#if CONFIG_EXT_TILE
if (cm->large_scale_tile) {
const int tile_width =
- ALIGN_POWER_OF_TWO(cm->tile_width, cm->mib_size_log2) >>
- cm->mib_size_log2;
+ ALIGN_POWER_OF_TWO(cm->tile_width, cm->seq_params.mib_size_log2) >>
+ cm->seq_params.mib_size_log2;
const int tile_height =
- ALIGN_POWER_OF_TWO(cm->tile_height, cm->mib_size_log2) >>
- cm->mib_size_log2;
+ ALIGN_POWER_OF_TWO(cm->tile_height, cm->seq_params.mib_size_log2) >>
+ cm->seq_params.mib_size_log2;
assert(tile_width > 0);
assert(tile_height > 0);
// Write the tile sizes
#if CONFIG_EXT_PARTITION
- if (cm->sb_size == BLOCK_128X128) {
+ if (cm->seq_params.sb_size == BLOCK_128X128) {
assert(tile_width <= 32);
assert(tile_height <= 32);
aom_wb_write_literal(wb, tile_width - 1, 5);
@@ -3389,6 +3396,21 @@
}
#endif // CONFIG_FILM_GRAIN
+static void write_sb_size(SequenceHeader *seq_params,
+ struct aom_write_bit_buffer *wb) {
+ (void)seq_params;
+ (void)wb;
+ assert(seq_params->mib_size == mi_size_wide[seq_params->sb_size]);
+ assert(seq_params->mib_size == 1 << seq_params->mib_size_log2);
+#if CONFIG_EXT_PARTITION
+ assert(seq_params->sb_size == BLOCK_128X128 ||
+ seq_params->sb_size == BLOCK_64X64);
+ aom_wb_write_bit(wb, seq_params->sb_size == BLOCK_128X128 ? 1 : 0);
+#else
+ assert(seq_params->sb_size == BLOCK_64X64);
+#endif // CONFIG_EXT_PARTITION
+}
+
#if CONFIG_REFERENCE_BUFFER || CONFIG_OBU
void write_sequence_header(AV1_COMP *cpi, struct aom_write_bit_buffer *wb) {
AV1_COMMON *const cm = &cpi->common;
@@ -3430,23 +3452,11 @@
wb, seq_params->frame_id_length - seq_params->delta_frame_id_length - 1,
3);
}
+
+ write_sb_size(seq_params, wb);
}
#endif // CONFIG_REFERENCE_BUFFER || CONFIG_OBU
-static void write_sb_size(const AV1_COMMON *cm,
- struct aom_write_bit_buffer *wb) {
- (void)cm;
- (void)wb;
- assert(cm->mib_size == mi_size_wide[cm->sb_size]);
- assert(cm->mib_size == 1 << cm->mib_size_log2);
-#if CONFIG_EXT_PARTITION
- assert(cm->sb_size == BLOCK_128X128 || cm->sb_size == BLOCK_64X64);
- aom_wb_write_bit(wb, cm->sb_size == BLOCK_128X128 ? 1 : 0);
-#else
- assert(cm->sb_size == BLOCK_64X64);
-#endif // CONFIG_EXT_PARTITION
-}
-
static void write_compound_tools(const AV1_COMMON *cm,
struct aom_write_bit_buffer *wb) {
if (!frame_is_intra_only(cm) && cm->reference_mode != COMPOUND_REFERENCE) {
@@ -3663,8 +3673,6 @@
#else
write_frame_size(cm, wb);
#endif
- write_sb_size(cm, wb);
-
aom_wb_write_bit(wb, cm->allow_screen_content_tools);
#if CONFIG_INTRABC
if (cm->allow_screen_content_tools) aom_wb_write_bit(wb, cm->allow_intrabc);
@@ -3711,7 +3719,6 @@
#else
write_frame_size(cm, wb);
#endif
- write_sb_size(cm, wb);
aom_wb_write_bit(wb, cm->allow_screen_content_tools);
#if CONFIG_INTRABC
if (cm->allow_screen_content_tools)
@@ -4000,7 +4007,6 @@
#else
write_frame_size(cm, wb);
#endif
- write_sb_size(cm, wb);
aom_wb_write_bit(wb, cm->allow_screen_content_tools);
#if CONFIG_INTRABC
if (cm->allow_screen_content_tools) aom_wb_write_bit(wb, cm->allow_intrabc);
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 56843d7..ec4d908 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -931,8 +931,9 @@
const uint8_t allow_update_cdf = tile_data->allow_update_cdf;
// delta quant applies to both intra and inter
- const int super_block_upper_left = ((mi_row & (cm->mib_size - 1)) == 0) &&
- ((mi_col & (cm->mib_size - 1)) == 0);
+ const int super_block_upper_left =
+ ((mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
+ ((mi_col & (cm->seq_params.mib_size - 1)) == 0);
const int seg_ref_active =
segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_REF_FRAME);
@@ -956,7 +957,8 @@
}
#endif // CONFIG_EXT_SKIP
- if (cm->delta_q_present_flag && (bsize != cm->sb_size || !mbmi->skip) &&
+ if (cm->delta_q_present_flag &&
+ (bsize != cm->seq_params.sb_size || !mbmi->skip) &&
super_block_upper_left) {
const int dq = (mbmi->current_q_index - xd->prev_qindex) / cm->delta_q_res;
const int absdq = abs(dq);
@@ -1488,7 +1490,7 @@
if (!dry_run) {
#if CONFIG_EXT_DELTA_Q
mbmi = &xd->mi[0]->mbmi;
- if (bsize == cpi->common.sb_size && mbmi->skip == 1 &&
+ if (bsize == cpi->common.seq_params.sb_size && mbmi->skip == 1 &&
cpi->common.delta_lf_present_flag) {
#if CONFIG_LOOPFILTER_LEVEL
for (int lf_id = 0; lf_id < FRAME_LF_COUNT; ++lf_id)
@@ -1671,9 +1673,9 @@
MODE_INFO **mib) {
int bh = bh_in;
int r, c;
- for (r = 0; r < cm->mib_size; r += bh) {
+ for (r = 0; r < cm->seq_params.mib_size; r += bh) {
int bw = bw_in;
- for (c = 0; c < cm->mib_size; c += bw) {
+ for (c = 0; c < cm->seq_params.mib_size; c += bw) {
const int index = r * cm->mi_stride + c;
mib[index] = mi + index;
mib[index]->mbmi.sb_type = find_partition_size(
@@ -1701,10 +1703,11 @@
assert((mi_rows_remaining > 0) && (mi_cols_remaining > 0));
// Apply the requested partition size to the SB if it is all "in image"
- if ((mi_cols_remaining >= cm->mib_size) &&
- (mi_rows_remaining >= cm->mib_size)) {
- for (block_row = 0; block_row < cm->mib_size; block_row += bh) {
- for (block_col = 0; block_col < cm->mib_size; block_col += bw) {
+ if ((mi_cols_remaining >= cm->seq_params.mib_size) &&
+ (mi_rows_remaining >= cm->seq_params.mib_size)) {
+ for (block_row = 0; block_row < cm->seq_params.mib_size; block_row += bh) {
+ for (block_col = 0; block_col < cm->seq_params.mib_size;
+ block_col += bw) {
int index = block_row * cm->mi_stride + block_col;
mib[index] = mi_upper_left + index;
mib[index]->mbmi.sb_type = bsize;
@@ -1979,11 +1982,11 @@
// We must have chosen a partitioning and encoding or we'll fail later on.
// No other opportunities for success.
- if (bsize == cm->sb_size)
+ if (bsize == cm->seq_params.sb_size)
assert(chosen_rdc.rate < INT_MAX && chosen_rdc.dist < INT64_MAX);
if (do_recon) {
- if (bsize == cm->sb_size) {
+ if (bsize == cm->seq_params.sb_size) {
// NOTE: To get estimate for rate due to the tokens, use:
// int rate_coeffs = 0;
// encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_COSTCOEFFS,
@@ -2067,8 +2070,8 @@
int index = 0;
// Check the sb_type for each block that belongs to this region.
- for (i = 0; i < cm->mib_size; ++i) {
- for (j = 0; j < cm->mib_size; ++j) {
+ for (i = 0; i < cm->seq_params.mib_size; ++i) {
+ for (j = 0; j < cm->seq_params.mib_size; ++j) {
MODE_INFO *mi = mib[index + j];
BLOCK_SIZE sb_type = mi ? mi->mbmi.sb_type : BLOCK_4X4;
*min_block_size = AOMMIN(*min_block_size, sb_type);
@@ -2110,12 +2113,12 @@
}
// Find the min and max partition sizes used in the left superblock
if (left_in_image) {
- MODE_INFO **left_sb_mi = &mi[-cm->mib_size];
+ MODE_INFO **left_sb_mi = &mi[-cm->seq_params.mib_size];
get_sb_partition_size_range(cm, xd, left_sb_mi, &min_size, &max_size);
}
// Find the min and max partition sizes used in the above suprblock.
if (above_in_image) {
- MODE_INFO **above_sb_mi = &mi[-xd->mi_stride * cm->mib_size];
+ MODE_INFO **above_sb_mi = &mi[-xd->mi_stride * cm->seq_params.mib_size];
get_sb_partition_size_range(cm, xd, above_sb_mi, &min_size, &max_size);
}
@@ -2147,8 +2150,8 @@
min_size = AOMMIN(min_size, next_square_size[max_size]);
}
- *min_block_size = AOMMIN(min_size, cm->sb_size);
- *max_block_size = AOMMIN(max_size, cm->sb_size);
+ *min_block_size = AOMMIN(min_size, cm->seq_params.sb_size);
+ *max_block_size = AOMMIN(max_size, cm->seq_params.sb_size);
}
// TODO(jingning) refactor functions setting partition search range
@@ -2163,7 +2166,7 @@
const int idx_str = cm->mi_stride * mi_row + mi_col;
MODE_INFO **const prev_mi = &cm->prev_mi_grid_visible[idx_str];
- BLOCK_SIZE min_size = cm->sb_size; // default values
+ BLOCK_SIZE min_size = cm->seq_params.sb_size; // default values
BLOCK_SIZE max_size = BLOCK_4X4;
if (prev_mi) {
@@ -2200,8 +2203,8 @@
max_size = max_partition_size[max_size];
}
- *min_bs = AOMMIN(min_size, cm->sb_size);
- *max_bs = AOMMIN(max_size, cm->sb_size);
+ *min_bs = AOMMIN(min_size, cm->seq_params.sb_size);
+ *max_bs = AOMMIN(max_size, cm->seq_params.sb_size);
}
static INLINE void store_pred_mv(MACROBLOCK *x, PICK_MODE_CONTEXT *ctx) {
@@ -2670,7 +2673,7 @@
if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX &&
pc_tree->index != 3) {
- if (bsize == cm->sb_size) {
+ if (bsize == cm->seq_params.sb_size) {
restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes);
} else {
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
@@ -2686,7 +2689,7 @@
}
#endif // CONFIG_DIST_8X8
- if (bsize == cm->sb_size) {
+ if (bsize == cm->seq_params.sb_size) {
#if !CONFIG_LV_MAP
assert(tp_orig < *tp || (tp_orig == *tp && xd->mi[0]->mbmi.skip));
#endif
@@ -3535,7 +3538,7 @@
if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX &&
pc_tree->index != 3) {
- if (bsize == cm->sb_size) {
+ if (bsize == cm->seq_params.sb_size) {
#if CONFIG_LV_MAP
x->cb_offset = 0;
#endif
@@ -3556,7 +3559,7 @@
}
#endif // CONFIG_DIST_8X8
- if (bsize == cm->sb_size) {
+ if (bsize == cm->seq_params.sb_size) {
#if !CONFIG_LV_MAP
assert(tp_orig < *tp || (tp_orig == *tp && xd->mi[0]->mbmi.skip));
#endif
@@ -3602,7 +3605,7 @@
// Code each SB in the row
for (mi_col = tile_info->mi_col_start; mi_col < tile_info->mi_col_end;
- mi_col += cm->mib_size) {
+ mi_col += cm->seq_params.mib_size) {
const struct segmentation *const seg = &cm->seg;
int dummy_rate;
int64_t dummy_dist;
@@ -3612,7 +3615,8 @@
const int idx_str = cm->mi_stride * mi_row + mi_col;
MODE_INFO **mi = cm->mi_grid_visible + idx_str;
- PC_TREE *const pc_root = td->pc_root[cm->mib_size_log2 - MIN_MIB_SIZE_LOG2];
+ PC_TREE *const pc_root =
+ td->pc_root[cm->seq_params.mib_size_log2 - MIN_MIB_SIZE_LOG2];
#if CONFIG_LV_MAP
av1_fill_coeff_costs(&td->mb, xd->tile_ctx, num_planes);
@@ -3647,7 +3651,8 @@
if (seg->enabled) {
const uint8_t *const map =
seg->update_map ? cpi->segmentation_map : cm->last_frame_seg_map;
- int segment_id = get_segment_id(cm, map, cm->sb_size, mi_row, mi_col);
+ int segment_id =
+ get_segment_id(cm, map, cm->seq_params.sb_size, mi_row, mi_col);
seg_skip = segfeature_active(seg, segment_id, SEG_LVL_SKIP);
}
#if CONFIG_AMVR
@@ -3673,7 +3678,7 @@
assert(current_qindex > 0);
xd->delta_qindex = current_qindex - cm->base_qindex;
- set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->sb_size);
+ set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->seq_params.sb_size);
xd->mi[0]->mbmi.current_q_index = current_qindex;
#if !CONFIG_EXT_DELTA_Q
xd->mi[0]->mbmi.segment_id = 0;
@@ -3689,8 +3694,10 @@
// pre-set the delta lf for loop filter. Note that this value is set
// before mi is assigned for each block in current superblock
- for (j = 0; j < AOMMIN(cm->mib_size, cm->mi_rows - mi_row); j++) {
- for (k = 0; k < AOMMIN(cm->mib_size, cm->mi_cols - mi_col); k++) {
+ for (j = 0; j < AOMMIN(cm->seq_params.mib_size, cm->mi_rows - mi_row);
+ j++) {
+ for (k = 0; k < AOMMIN(cm->seq_params.mib_size, cm->mi_cols - mi_col);
+ k++) {
cm->mi[(mi_row + j) * cm->mi_stride + (mi_col + k)]
.mbmi.current_delta_lf_from_base = clamp(
current_delta_lf_from_base, -MAX_LOOP_FILTER, MAX_LOOP_FILTER);
@@ -3711,36 +3718,38 @@
x->source_variance = UINT_MAX;
if (sf->partition_search_type == FIXED_PARTITION || seg_skip) {
BLOCK_SIZE bsize;
- set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->sb_size);
- bsize = seg_skip ? cm->sb_size : sf->always_this_block_size;
+ set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->seq_params.sb_size);
+ bsize = seg_skip ? cm->seq_params.sb_size : sf->always_this_block_size;
set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize);
- rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, cm->sb_size,
- &dummy_rate, &dummy_dist, 1, pc_root);
+ rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col,
+ cm->seq_params.sb_size, &dummy_rate, &dummy_dist, 1,
+ pc_root);
} else if (cpi->partition_search_skippable_frame) {
BLOCK_SIZE bsize;
- set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->sb_size);
+ set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->seq_params.sb_size);
bsize = get_rd_var_based_fixed_partition(cpi, x, mi_row, mi_col);
set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize);
- rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, cm->sb_size,
- &dummy_rate, &dummy_dist, 1, pc_root);
+ rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col,
+ cm->seq_params.sb_size, &dummy_rate, &dummy_dist, 1,
+ pc_root);
} else {
// If required set upper and lower partition size limits
if (sf->auto_min_max_partition_size) {
- set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->sb_size);
+ set_offsets(cpi, tile_info, x, mi_row, mi_col, cm->seq_params.sb_size);
rd_auto_partition_range(cpi, tile_info, xd, mi_row, mi_col,
&x->min_partition_size, &x->max_partition_size);
}
- reset_partition(pc_root, cm->sb_size);
+ reset_partition(pc_root, cm->seq_params.sb_size);
x->use_cb_search_range = 0;
if (cpi->sf.two_pass_partition_search &&
- mi_row + mi_size_high[cm->sb_size] < cm->mi_rows &&
- mi_col + mi_size_wide[cm->sb_size] < cm->mi_cols &&
+ mi_row + mi_size_high[cm->seq_params.sb_size] < cm->mi_rows &&
+ mi_col + mi_size_wide[cm->seq_params.sb_size] < cm->mi_cols &&
cm->frame_type != KEY_FRAME) {
x->cb_partition_scan = 1;
rd_pick_sqr_partition(cpi, td, tile_data, tp, mi_row, mi_col,
- cm->sb_size, &dummy_rdc, INT64_MAX, pc_root,
- NULL);
+ cm->seq_params.sb_size, &dummy_rdc, INT64_MAX,
+ pc_root, NULL);
x->cb_partition_scan = 0;
x->source_variance = UINT_MAX;
@@ -3763,19 +3772,21 @@
av1_zero(x->pred_mv);
pc_root->index = 0;
- for (int idy = 0; idy < mi_size_high[cm->sb_size]; ++idy) {
- for (int idx = 0; idx < mi_size_wide[cm->sb_size]; ++idx) {
+ for (int idy = 0; idy < mi_size_high[cm->seq_params.sb_size]; ++idy) {
+ for (int idx = 0; idx < mi_size_wide[cm->seq_params.sb_size]; ++idx) {
const int offset = cm->mi_stride * (mi_row + idy) + (mi_col + idx);
cm->mi_grid_visible[offset] = 0;
}
}
x->use_cb_search_range = 1;
- rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, cm->sb_size,
- &dummy_rdc, INT64_MAX, pc_root, NULL);
+ rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col,
+ cm->seq_params.sb_size, &dummy_rdc, INT64_MAX,
+ pc_root, NULL);
} else {
- rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, cm->sb_size,
- &dummy_rdc, INT64_MAX, pc_root, NULL);
+ rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col,
+ cm->seq_params.sb_size, &dummy_rdc, INT64_MAX,
+ pc_root, NULL);
}
}
}
@@ -3858,8 +3869,8 @@
cpi->tile_tok[tile_row][tile_col] = pre_tok + tile_tok;
pre_tok = cpi->tile_tok[tile_row][tile_col];
- tile_tok = allocated_tokens(*tile_info, cm->mib_size_log2 + MI_SIZE_LOG2,
- num_planes);
+ tile_tok = allocated_tokens(
+ *tile_info, cm->seq_params.mib_size_log2 + MI_SIZE_LOG2, num_planes);
#if CONFIG_EXT_TILE
tile_data->allow_update_cdf = !cm->large_scale_tile;
@@ -3918,14 +3929,15 @@
#endif // CONFIG_INTRABC
for (mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end;
- mi_row += cm->mib_size) {
+ mi_row += cm->seq_params.mib_size) {
encode_rd_sb_row(cpi, td, this_tile, mi_row, &tok);
}
cpi->tok_count[tile_row][tile_col] =
(unsigned int)(tok - cpi->tile_tok[tile_row][tile_col]);
assert(cpi->tok_count[tile_row][tile_col] <=
- allocated_tokens(*tile_info, cm->mib_size_log2 + MI_SIZE_LOG2,
+ allocated_tokens(*tile_info,
+ cm->seq_params.mib_size_log2 + MI_SIZE_LOG2,
av1_num_planes(cm)));
}
@@ -4216,8 +4228,8 @@
int i;
const int last_fb_buf_idx = get_ref_frame_buf_idx(cpi, LAST_FRAME);
- x->min_partition_size = AOMMIN(x->min_partition_size, cm->sb_size);
- x->max_partition_size = AOMMIN(x->max_partition_size, cm->sb_size);
+ x->min_partition_size = AOMMIN(x->min_partition_size, cm->seq_params.sb_size);
+ x->max_partition_size = AOMMIN(x->max_partition_size, cm->seq_params.sb_size);
#if CONFIG_DIST_8X8
x->using_dist_8x8 = cpi->oxcf.using_dist_8x8;
x->tune_metric = cpi->oxcf.tuning;
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 95c2288..ac130ce 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -357,7 +357,7 @@
cpi->refresh_golden_frame = 1;
cpi->refresh_alt_ref_frame = 1;
av1_zero(cpi->interp_filter_selected);
- set_sb_size(cm, select_sb_size(cpi));
+ set_sb_size(&cm->seq_params, select_sb_size(cpi));
#if CONFIG_REFERENCE_BUFFER
set_use_reference_buffer(cm, 0);
#endif // CONFIG_REFERENCE_BUFFER
@@ -879,8 +879,8 @@
cm->log2_tile_cols = AOMMAX(cpi->oxcf.tile_columns, cm->min_log2_tile_cols);
cm->log2_tile_cols = AOMMIN(cm->log2_tile_cols, cm->max_log2_tile_cols);
} else {
- int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->mib_size_log2);
- int sb_cols = mi_cols >> cm->mib_size_log2;
+ int mi_cols = ALIGN_POWER_OF_TWO(cm->mi_cols, cm->seq_params.mib_size_log2);
+ int sb_cols = mi_cols >> cm->seq_params.mib_size_log2;
int size_sb, j = 0;
cm->uniform_tile_spacing_flag = 0;
for (i = 0, start_sb = 0; start_sb < sb_cols && i < MAX_TILE_COLS; i++) {
@@ -899,8 +899,8 @@
cm->log2_tile_rows = AOMMAX(cpi->oxcf.tile_rows, cm->min_log2_tile_rows);
cm->log2_tile_rows = AOMMIN(cm->log2_tile_rows, cm->max_log2_tile_rows);
} else {
- int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->mib_size_log2);
- int sb_rows = mi_rows >> cm->mib_size_log2;
+ int mi_rows = ALIGN_POWER_OF_TWO(cm->mi_rows, cm->seq_params.mib_size_log2);
+ int sb_rows = mi_rows >> cm->seq_params.mib_size_log2;
int size_sb, j = 0;
for (i = 0, start_sb = 0; start_sb < sb_rows && i < MAX_TILE_ROWS; i++) {
cm->tile_row_start_sb[i] = start_sb;
@@ -960,11 +960,11 @@
int i;
for (i = 0; i <= cm->tile_cols; i++) {
cm->tile_col_start_sb[i] =
- ((i * cm->tile_width - 1) >> cm->mib_size_log2) + 1;
+ ((i * cm->tile_width - 1) >> cm->seq_params.mib_size_log2) + 1;
}
for (i = 0; i <= cm->tile_rows; i++) {
cm->tile_row_start_sb[i] =
- ((i * cm->tile_height - 1) >> cm->mib_size_log2) + 1;
+ ((i * cm->tile_height - 1) >> cm->seq_params.mib_size_log2) + 1;
}
#endif // CONFIG_MAX_TILE
} else {
@@ -1111,7 +1111,8 @@
cm->width = oxcf->width;
cm->height = oxcf->height;
- set_sb_size(cm, select_sb_size(cpi)); // set sb size before allocations
+ set_sb_size(&cm->seq_params,
+ select_sb_size(cpi)); // set sb size before allocations
alloc_compressor_data(cpi);
#if CONFIG_FILM_GRAIN
update_film_grain_parameters(cpi, oxcf);
@@ -3232,12 +3233,12 @@
cm->width = cpi->oxcf.width;
cm->height = cpi->oxcf.height;
- int sb_size = cm->sb_size;
- set_sb_size(cm, select_sb_size(cpi));
+ int sb_size = cm->seq_params.sb_size;
+ set_sb_size(&cm->seq_params, select_sb_size(cpi));
- if (cpi->initial_width || sb_size != cm->sb_size) {
+ if (cpi->initial_width || sb_size != cm->seq_params.sb_size) {
if (cm->width > cpi->initial_width || cm->height > cpi->initial_height ||
- cm->sb_size != sb_size) {
+ cm->seq_params.sb_size != sb_size) {
av1_free_context_buffers(cm);
av1_free_pc_tree(&cpi->td, num_planes);
alloc_compressor_data(cpi);
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 1ee5089..e21fe79 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -72,8 +72,8 @@
}
#else
AV1_COMMON *cm = &cpi->common;
- int size = ((cm->mi_rows >> cm->mib_size_log2) + 1) *
- ((cm->mi_cols >> cm->mib_size_log2) + 1);
+ int size = ((cm->mi_rows >> cm->seq_params.mib_size_log2) + 1) *
+ ((cm->mi_cols >> cm->seq_params.mib_size_log2) + 1);
av1_free_txb_buf(cpi);
// TODO(jingning): This should be further reduced.
@@ -99,7 +99,7 @@
int mi_row, int mi_col) {
const AV1_COMMON *const cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
- int mib_size_log2 = cm->mib_size_log2;
+ int mib_size_log2 = cm->seq_params.mib_size_log2;
int stride = (cm->mi_cols >> mib_size_log2) + 1;
int offset = (mi_row >> mib_size_log2) * stride + (mi_col >> mib_size_log2);
CB_COEFF_BUFFER *coeff_buf = &cpi->coeff_buffer_base[offset];
diff --git a/av1/encoder/firstpass.c b/av1/encoder/firstpass.c
index 8fdb0cb..f605ed0 100644
--- a/av1/encoder/firstpass.c
+++ b/av1/encoder/firstpass.c
@@ -557,7 +557,8 @@
num_planes);
av1_setup_src_planes(x, cpi->source, 0, 0, num_planes);
- av1_setup_dst_planes(xd->plane, cm->sb_size, new_yv12, 0, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, new_yv12, 0, 0,
+ num_planes);
if (!frame_is_intra_only(cm)) {
av1_setup_pre_planes(xd, 0, first_ref_buf, 0, 0, NULL, num_planes);
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 649f354..af48656 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -2665,7 +2665,7 @@
const MV dv = { 8 * (ref_block_hash.y - y_pos),
8 * (ref_block_hash.x - x_pos) };
if (!av1_is_dv_valid(dv, tile, mi_row, mi_col, bsize,
- cpi->common.mib_size_log2))
+ cpi->common.seq_params.mib_size_log2))
continue;
}
#endif // CONFIG_INTRABC
diff --git a/av1/encoder/pickcdef.c b/av1/encoder/pickcdef.c
index e9a4cfc..e3bd10c 100644
--- a/av1/encoder/pickcdef.c
+++ b/av1/encoder/pickcdef.c
@@ -325,7 +325,8 @@
av1_ac_quant_Q3(cm->base_qindex, 0, cm->bit_depth) >> (cm->bit_depth - 8);
lambda = .12 * quantizer * quantizer / 256.;
- av1_setup_dst_planes(xd->plane, cm->sb_size, frame, 0, 0, num_planes);
+ av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0,
+ num_planes);
mse[0] = aom_malloc(sizeof(**mse) * nvfb * nhfb);
mse[1] = aom_malloc(sizeof(**mse) * nvfb * nhfb);
for (pli = 0; pli < num_planes; pli++) {
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index a4069a3..0e4b0a5 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -1233,7 +1233,8 @@
int mode;
for (mode = 0; mode < top_mode; ++mode) {
const BLOCK_SIZE min_size = AOMMAX(bsize - 1, BLOCK_4X4);
- const BLOCK_SIZE max_size = AOMMIN(bsize + 2, (int)cm->sb_size);
+ const BLOCK_SIZE max_size =
+ AOMMIN(bsize + 2, (int)cm->seq_params.sb_size);
BLOCK_SIZE bs;
for (bs = min_size; bs <= max_size; ++bs) {
int *const fact = &factor_buf[bs][mode];
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 4e14b90..cd918d0 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -6395,9 +6395,9 @@
step_param = cpi->mv_step_param;
}
- if (cpi->sf.adaptive_motion_search && bsize < cm->sb_size) {
+ if (cpi->sf.adaptive_motion_search && bsize < cm->seq_params.sb_size) {
int boffset =
- 2 * (b_width_log2_lookup[cm->sb_size] -
+ 2 * (b_width_log2_lookup[cm->seq_params.sb_size] -
AOMMIN(b_height_log2_lookup[bsize], b_width_log2_lookup[bsize]));
step_param = AOMMAX(step_param, boffset);
}
@@ -8761,8 +8761,8 @@
const int mi_col = -xd->mb_to_left_edge / (8 * MI_SIZE);
const int w = block_size_wide[bsize];
const int h = block_size_high[bsize];
- const int sb_row = mi_row >> cm->mib_size_log2;
- const int sb_col = mi_col >> cm->mib_size_log2;
+ const int sb_row = mi_row >> cm->seq_params.mib_size_log2;
+ const int sb_col = mi_col >> cm->seq_params.mib_size_log2;
MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
MV_REFERENCE_FRAME ref_frame = INTRA_FRAME;
@@ -8781,7 +8781,7 @@
int_mv dv_ref = nearestmv.as_int == 0 ? nearmv : nearestmv;
if (dv_ref.as_int == 0)
- av1_find_ref_dv(&dv_ref, tile, cm->mib_size, mi_row, mi_col);
+ av1_find_ref_dv(&dv_ref, tile, cm->seq_params.mib_size, mi_row, mi_col);
// Ref DV should not have sub-pel.
assert((dv_ref.as_mv.col & 7) == 0);
assert((dv_ref.as_mv.row & 7) == 0);
@@ -8814,16 +8814,18 @@
x->mv_limits.col_min = (tile->mi_col_start - mi_col) * MI_SIZE;
x->mv_limits.col_max = (tile->mi_col_end - mi_col) * MI_SIZE - w;
x->mv_limits.row_min = (tile->mi_row_start - mi_row) * MI_SIZE;
- x->mv_limits.row_max = (sb_row * cm->mib_size - mi_row) * MI_SIZE - h;
+ x->mv_limits.row_max =
+ (sb_row * cm->seq_params.mib_size - mi_row) * MI_SIZE - h;
break;
case IBC_MOTION_LEFT:
x->mv_limits.col_min = (tile->mi_col_start - mi_col) * MI_SIZE;
- x->mv_limits.col_max = (sb_col * cm->mib_size - mi_col) * MI_SIZE - w;
+ x->mv_limits.col_max =
+ (sb_col * cm->seq_params.mib_size - mi_col) * MI_SIZE - w;
// TODO(aconverse@google.com): Minimize the overlap between above and
// left areas.
x->mv_limits.row_min = (tile->mi_row_start - mi_row) * MI_SIZE;
int bottom_coded_mi_edge =
- AOMMIN((sb_row + 1) * cm->mib_size, tile->mi_row_end);
+ AOMMIN((sb_row + 1) * cm->seq_params.mib_size, tile->mi_row_end);
x->mv_limits.row_max = (bottom_coded_mi_edge - mi_row) * MI_SIZE - h;
break;
default: assert(0);
@@ -8862,7 +8864,8 @@
mvp_full = x->best_mv.as_mv;
MV dv = {.row = mvp_full.row * 8, .col = mvp_full.col * 8 };
if (mv_check_bounds(&x->mv_limits, &dv)) continue;
- if (!av1_is_dv_valid(dv, tile, mi_row, mi_col, bsize, cm->mib_size_log2))
+ if (!av1_is_dv_valid(dv, tile, mi_row, mi_col, bsize,
+ cm->seq_params.mib_size_log2))
continue;
// DV should not have sub-pel.
@@ -9093,8 +9096,8 @@
// In most cases this is the "real" edge unless there are formatting
// bars embedded in the stream.
int av1_active_edge_sb(const AV1_COMP *cpi, int mi_row, int mi_col) {
- return av1_active_h_edge(cpi, mi_row, cpi->common.mib_size) ||
- av1_active_v_edge(cpi, mi_col, cpi->common.mib_size);
+ return av1_active_h_edge(cpi, mi_row, cpi->common.seq_params.mib_size) ||
+ av1_active_v_edge(cpi, mi_col, cpi->common.seq_params.mib_size);
}
static void restore_uv_color_map(const AV1_COMP *const cpi, MACROBLOCK *x) {
diff --git a/av1/encoder/segmentation.c b/av1/encoder/segmentation.c
index b649a77..67ca776 100644
--- a/av1/encoder/segmentation.c
+++ b/av1/encoder/segmentation.c
@@ -230,13 +230,14 @@
mi_ptr = cm->mi_grid_visible + tile_info.mi_row_start * cm->mi_stride +
tile_info.mi_col_start;
for (mi_row = tile_info.mi_row_start; mi_row < tile_info.mi_row_end;
- mi_row += cm->mib_size, mi_ptr += cm->mib_size * cm->mi_stride) {
+ mi_row += cm->seq_params.mib_size,
+ mi_ptr += cm->seq_params.mib_size * cm->mi_stride) {
MODE_INFO **mi = mi_ptr;
for (mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
- mi_col += cm->mib_size, mi += cm->mib_size) {
+ mi_col += cm->seq_params.mib_size, mi += cm->seq_params.mib_size) {
count_segs_sb(cm, xd, &tile_info, mi, no_pred_segcounts,
temporal_predictor_count, t_unpred_seg_counts, mi_row,
- mi_col, cm->sb_size);
+ mi_col, cm->seq_params.sb_size);
}
}
}
