Abstract seq_params to AV1_PRIMARY and AV1Decoder
Moved seq_params from AV1_COMMON to AV1_PRIMARY and AV1Decoder.
A reference is kept in AV1_COMMON which points to
AV1_PRIMARY.seq_params (for encoder) and
AV1Decoder.seq_params (for decoder).
Change-Id: Ie5e3f37be916f5af0210a866b15d0479c73aaf2e
diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index 7362d3a..a879aed 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c
@@ -1327,7 +1327,7 @@
ctx->cfg = *cfg;
set_encoder_config(&ctx->oxcf, &ctx->cfg, &ctx->extra_cfg);
// On profile change, request a key frame
- force_key |= ctx->ppi->cpi->common.seq_params.profile != ctx->oxcf.profile;
+ force_key |= ctx->ppi->seq_params.profile != ctx->oxcf.profile;
#if CONFIG_FRAME_PARALLEL_ENCODE
int i;
for (i = 0; i < ctx->ppi->num_fp_contexts; i++) {
@@ -2966,10 +2966,10 @@
}
if (cm->current_frame.frame_number == 0) {
if (!cpi->ppi->seq_params_locked) {
- SequenceHeader *const seq_params = &cm->seq_params;
+ SequenceHeader *const seq_params = cm->seq_params;
seq_params->operating_points_cnt_minus_1 =
cm->number_spatial_layers * cm->number_temporal_layers - 1;
- av1_init_seq_coding_tools(&cm->seq_params, cm, &cpi->oxcf, 1);
+ av1_init_seq_coding_tools(cm->seq_params, cm, &cpi->oxcf, 1);
}
av1_init_layer_context(cpi);
}
@@ -3477,7 +3477,7 @@
int *const arg = va_arg(args, int *);
const AV1_COMP *const cpi = ctx->ppi->cpi;
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
- return av1_get_seq_level_idx(&cpi->common.seq_params, &cpi->ppi->level_params,
+ return av1_get_seq_level_idx(cpi->common.seq_params, &cpi->ppi->level_params,
arg);
}
diff --git a/av1/av1_dx_iface.c b/av1/av1_dx_iface.c
index 2d5a195..5c57124 100644
--- a/av1/av1_dx_iface.c
+++ b/av1/av1_dx_iface.c
@@ -1095,10 +1095,9 @@
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
const AV1Decoder *pbi = frame_worker_data->pbi;
- still_picture_info->is_still_picture =
- (int)pbi->common.seq_params.still_picture;
+ still_picture_info->is_still_picture = (int)pbi->seq_params.still_picture;
still_picture_info->is_reduced_still_picture_hdr =
- (int)(pbi->common.seq_params.reduced_still_picture_hdr);
+ (int)(pbi->seq_params.reduced_still_picture_hdr);
return AOM_CODEC_OK;
} else {
return AOM_CODEC_ERROR;
@@ -1116,7 +1115,7 @@
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
const AV1Decoder *pbi = frame_worker_data->pbi;
- if (pbi->common.seq_params.sb_size == BLOCK_128X128) {
+ if (pbi->seq_params.sb_size == BLOCK_128X128) {
*sb_size = AOM_SUPERBLOCK_SIZE_128X128;
} else {
*sb_size = AOM_SUPERBLOCK_SIZE_64X64;
@@ -1295,7 +1294,7 @@
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
const AV1_COMMON *const cm = &frame_worker_data->pbi->common;
- *bit_depth = cm->seq_params.bit_depth;
+ *bit_depth = cm->seq_params->bit_depth;
return AOM_CODEC_OK;
} else {
return AOM_CODEC_ERROR;
@@ -1331,9 +1330,9 @@
(FrameWorkerData *)worker->data1;
const AV1_COMMON *const cm = &frame_worker_data->pbi->common;
- *img_fmt = get_img_format(cm->seq_params.subsampling_x,
- cm->seq_params.subsampling_y,
- cm->seq_params.use_highbitdepth);
+ *img_fmt = get_img_format(cm->seq_params->subsampling_x,
+ cm->seq_params->subsampling_y,
+ cm->seq_params->use_highbitdepth);
return AOM_CODEC_OK;
} else {
return AOM_CODEC_ERROR;
diff --git a/av1/common/alloccommon.c b/av1/common/alloccommon.c
index 5c91efc..fc8b8bb 100644
--- a/av1/common/alloccommon.c
+++ b/av1/common/alloccommon.c
@@ -111,7 +111,7 @@
aom_memalign(16, sizeof(**srcbuf) * CDEF_INBUF_SIZE));
for (int plane = 0; plane < num_planes; plane++) {
- const int shift = plane == AOM_PLANE_Y ? 0 : cm->seq_params.subsampling_x;
+ const int shift = plane == AOM_PLANE_Y ? 0 : cm->seq_params->subsampling_x;
const int block_height =
(CDEF_BLOCKSIZE << (MI_SIZE_LOG2 - shift)) * 2 * CDEF_VBORDER;
@@ -153,12 +153,12 @@
CdefInfo *cdef_info = &cm->cdef_info;
// Check for configuration change
const int is_sub_sampling_changed =
- (cdef_info->allocated_subsampling_x != cm->seq_params.subsampling_x ||
- cdef_info->allocated_subsampling_y != cm->seq_params.subsampling_y);
+ (cdef_info->allocated_subsampling_x != cm->seq_params->subsampling_x ||
+ cdef_info->allocated_subsampling_y != cm->seq_params->subsampling_y);
const int is_frame_scaled =
cdef_info->allocated_mi_cols != cm->mi_params.mi_cols;
const int is_cdef_flag_changed =
- cdef_info->prev_cdef_enable_flag != cm->seq_params.enable_cdef;
+ cdef_info->prev_cdef_enable_flag != cm->seq_params->enable_cdef;
const int is_large_scale_tile_changed =
cdef_info->prev_large_scale_tile_flag != cm->tiles.large_scale;
const int is_num_planes_changed = cdef_info->prev_num_planes != num_planes;
@@ -186,20 +186,20 @@
// Store configuration to check change in configuration
cdef_info->allocated_mi_cols = cm->mi_params.mi_cols;
cdef_info->allocated_mi_rows = num_mi_rows;
- cdef_info->allocated_subsampling_x = cm->seq_params.subsampling_x;
- cdef_info->allocated_subsampling_y = cm->seq_params.subsampling_y;
- cdef_info->prev_cdef_enable_flag = cm->seq_params.enable_cdef;
+ cdef_info->allocated_subsampling_x = cm->seq_params->subsampling_x;
+ cdef_info->allocated_subsampling_y = cm->seq_params->subsampling_y;
+ cdef_info->prev_cdef_enable_flag = cm->seq_params->enable_cdef;
cdef_info->prev_large_scale_tile_flag = cm->tiles.large_scale;
cdef_info->prev_num_planes = num_planes;
cdef_info->allocated_num_workers = num_workers;
- if (!cm->seq_params.enable_cdef && cm->tiles.large_scale) return;
+ if (!cm->seq_params->enable_cdef && cm->tiles.large_scale) return;
for (int plane = 0; plane < num_planes; plane++) {
if (cdef_info->linebuf[plane] == NULL) {
const int stride =
luma_stride >>
- (plane == AOM_PLANE_Y ? 0 : cm->seq_params.subsampling_x);
+ (plane == AOM_PLANE_Y ? 0 : cm->seq_params->subsampling_x);
CHECK_MEM_ERROR(cm, cdef_info->linebuf[plane],
aom_malloc(sizeof(*cdef_info->linebuf) * num_bufs *
(CDEF_VBORDER << 1) * stride));
@@ -260,11 +260,11 @@
// Now we need to allocate enough space to store the line buffers for the
// stripes
const int frame_w = cm->superres_upscaled_width;
- const int use_highbd = cm->seq_params.use_highbitdepth;
+ const int use_highbd = cm->seq_params->use_highbitdepth;
for (int p = 0; p < num_planes; ++p) {
const int is_uv = p > 0;
- const int ss_x = is_uv && cm->seq_params.subsampling_x;
+ const int ss_x = is_uv && cm->seq_params->subsampling_x;
const int plane_w = ((frame_w + ss_x) >> ss_x) + 2 * RESTORATION_EXTRA_HORZ;
const int stride = ALIGN_POWER_OF_TWO(plane_w, 5);
const int buf_size = num_stripes * stride * RESTORATION_CTX_VERT
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index 233c9fa..4654e28 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -613,12 +613,12 @@
/*!
* Delta of qindex (from base_qindex) for V plane DC coefficients.
- * Same as those for U plane if cm->seq_params.separate_uv_delta_q == 0.
+ * Same as those for U plane if cm->seq_params->separate_uv_delta_q == 0.
*/
int u_ac_delta_q;
/*!
* Delta of qindex (from base_qindex) for V plane AC coefficients.
- * Same as those for U plane if cm->seq_params.separate_uv_delta_q == 0.
+ * Same as those for U plane if cm->seq_params->separate_uv_delta_q == 0.
*/
int v_ac_delta_q;
@@ -961,7 +961,7 @@
* Elements part of the sequence header, that are applicable for all the
* frames in the video.
*/
- SequenceHeader seq_params;
+ SequenceHeader *seq_params;
/*!
* Current CDFs of all the symbols for the current frame.
@@ -993,7 +993,7 @@
CommonContexts above_contexts;
/**
- * \name Signaled when cm->seq_params.frame_id_numbers_present_flag == 1
+ * \name Signaled when cm->seq_params->frame_id_numbers_present_flag == 1
*/
/**@{*/
int current_frame_id; /*!< frame ID for the current frame. */
@@ -1203,15 +1203,15 @@
// Returns 1 if this frame might allow mvs from some reference frame.
static INLINE int frame_might_allow_ref_frame_mvs(const AV1_COMMON *cm) {
return !cm->features.error_resilient_mode &&
- cm->seq_params.order_hint_info.enable_ref_frame_mvs &&
- cm->seq_params.order_hint_info.enable_order_hint &&
+ cm->seq_params->order_hint_info.enable_ref_frame_mvs &&
+ cm->seq_params->order_hint_info.enable_order_hint &&
!frame_is_intra_only(cm);
}
// Returns 1 if this frame might use warped_motion
static INLINE int frame_might_allow_warped_motion(const AV1_COMMON *cm) {
return !cm->features.error_resilient_mode && !frame_is_intra_only(cm) &&
- cm->seq_params.enable_warped_motion;
+ cm->seq_params->enable_warped_motion;
}
static INLINE void ensure_mv_buffer(RefCntBuffer *buf, AV1_COMMON *cm) {
@@ -1251,7 +1251,7 @@
void cfl_init(CFL_CTX *cfl, const SequenceHeader *seq_params);
static INLINE int av1_num_planes(const AV1_COMMON *cm) {
- return cm->seq_params.monochrome ? 1 : MAX_MB_PLANE;
+ return cm->seq_params->monochrome ? 1 : MAX_MB_PLANE;
}
static INLINE void av1_init_above_context(CommonContexts *above_contexts,
@@ -1291,7 +1291,7 @@
}
xd->mi_stride = cm->mi_params.mi_stride;
xd->error_info = &cm->error;
- cfl_init(&xd->cfl, &cm->seq_params);
+ cfl_init(&xd->cfl, cm->seq_params);
}
static INLINE void set_entropy_context(MACROBLOCKD *xd, int mi_row, int mi_col,
@@ -1573,7 +1573,7 @@
const MACROBLOCKD *xd,
int mi_col_start, int mi_col_end,
const int tile_row) {
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int num_planes = av1_num_planes(cm);
const int width = mi_col_end - mi_col_start;
const int aligned_width =
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index caa15c2..48424f7 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -376,8 +376,8 @@
}
#if CONFIG_AV1_HIGHBITDEPTH
- const int use_highbitdepth = cm->seq_params.use_highbitdepth;
- const aom_bit_depth_t bit_depth = cm->seq_params.bit_depth;
+ const int use_highbitdepth = cm->seq_params->use_highbitdepth;
+ const aom_bit_depth_t bit_depth = cm->seq_params->bit_depth;
switch (params.filter_length) {
// apply 4-tap filtering
case 4:
@@ -489,8 +489,8 @@
}
#if CONFIG_AV1_HIGHBITDEPTH
- const int use_highbitdepth = cm->seq_params.use_highbitdepth;
- const aom_bit_depth_t bit_depth = cm->seq_params.bit_depth;
+ const int use_highbitdepth = cm->seq_params->use_highbitdepth;
+ const aom_bit_depth_t bit_depth = cm->seq_params->bit_depth;
switch (params.filter_length) {
// apply 4-tap filtering
case 4:
@@ -679,7 +679,7 @@
else if (plane == 2 && !(cm->lf.filter_level_v))
continue;
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, 0, 0,
+ av1_setup_dst_planes(pd, cm->seq_params->sb_size, frame_buffer, 0, 0,
plane, plane + 1);
av1_build_bitmask_vert_info(cm, &pd[plane], plane);
@@ -722,13 +722,13 @@
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) {
// filter vertical edges
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(pd, cm->seq_params->sb_size, frame_buffer,
+ mi_row, mi_col, plane, plane + 1);
av1_filter_block_plane_vert(cm, xd, plane, &pd[plane], mi_row,
mi_col);
// filter horizontal edges
if (mi_col - MAX_MIB_SIZE >= 0) {
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer,
+ av1_setup_dst_planes(pd, cm->seq_params->sb_size, frame_buffer,
mi_row, mi_col - MAX_MIB_SIZE, plane,
plane + 1);
av1_filter_block_plane_horz(cm, xd, plane, &pd[plane], mi_row,
@@ -736,7 +736,7 @@
}
}
// filter horizontal edges
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
+ av1_setup_dst_planes(pd, cm->seq_params->sb_size, frame_buffer, mi_row,
mi_col - MAX_MIB_SIZE, plane, plane + 1);
av1_filter_block_plane_horz(cm, xd, plane, &pd[plane], mi_row,
mi_col - MAX_MIB_SIZE);
@@ -745,8 +745,8 @@
// filter all vertical edges in every 128x128 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(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(pd, cm->seq_params->sb_size, frame_buffer,
+ mi_row, mi_col, plane, plane + 1);
av1_filter_block_plane_vert(cm, xd, plane, &pd[plane], mi_row,
mi_col);
}
@@ -755,8 +755,8 @@
// filter all horizontal edges in every 128x128 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(pd, cm->seq_params.sb_size, frame_buffer, mi_row,
- mi_col, plane, plane + 1);
+ av1_setup_dst_planes(pd, cm->seq_params->sb_size, frame_buffer,
+ mi_row, mi_col, plane, plane + 1);
av1_filter_block_plane_horz(cm, xd, plane, &pd[plane], mi_row,
mi_col);
}
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index bd7d723..b90d348 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -801,7 +801,7 @@
FRAME_CONTEXT *tile_ctx;
/*!
- * Bit depth: copied from cm->seq_params.bit_depth for convenience.
+ * Bit depth: copied from cm->seq_params->bit_depth for convenience.
*/
int bd;
@@ -942,7 +942,7 @@
/*! Is the image buffer high bit depth?
* Low bit depth buffer uses uint8_t.
* High bit depth buffer uses uint16_t.
- * Equivalent to cm->seq_params.use_highbitdepth
+ * Equivalent to cm->seq_params->use_highbitdepth
*/
int use_highbitdepth_buf;
} BitDepthInfo;
diff --git a/av1/common/cdef.c b/av1/common/cdef.c
index e8e381f..3588eea 100644
--- a/av1/common/cdef.c
+++ b/av1/common/cdef.c
@@ -90,7 +90,7 @@
void av1_cdef_copy_sb8_16(AV1_COMMON *cm, uint16_t *dst, int dstride,
const uint8_t *src, int src_voffset, int src_hoffset,
int sstride, int vsize, int hsize) {
- if (cm->seq_params.use_highbitdepth) {
+ if (cm->seq_params->use_highbitdepth) {
const uint16_t *base =
&CONVERT_TO_SHORTPTR(src)[src_voffset * sstride + src_hoffset];
cdef_copy_rect8_16bit_to_16bit(dst, dstride, base, sstride, vsize, hsize);
@@ -148,7 +148,7 @@
const uint16_t *bot_linebuf = fb_info->bot_linebuf[plane];
const int bot_offset = (vsize + CDEF_VBORDER) * CDEF_BSTRIDE;
const int stride =
- luma_stride >> (plane == AOM_PLANE_Y ? 0 : cm->seq_params.subsampling_x);
+ luma_stride >> (plane == AOM_PLANE_Y ? 0 : cm->seq_params->subsampling_x);
if (fbc == nhfb - 1)
cend = hsize;
@@ -321,7 +321,7 @@
return;
}
cdef_prepare_fb(cm, fb_info, colbuf, cdef_left, fbc, fbr, plane);
- cdef_filter_fb(fb_info, plane, cm->seq_params.use_highbitdepth);
+ cdef_filter_fb(fb_info, plane, cm->seq_params->use_highbitdepth);
}
*cdef_left = 1;
}
@@ -355,7 +355,7 @@
fb_info->src = src;
fb_info->damping = cm->cdef_info.cdef_damping;
- fb_info->coeff_shift = AOMMAX(cm->seq_params.bit_depth - 8, 0);
+ fb_info->coeff_shift = AOMMAX(cm->seq_params->bit_depth - 8, 0);
av1_zero(fb_info->dir);
av1_zero(fb_info->var);
@@ -415,7 +415,7 @@
const int num_planes = av1_num_planes(cm);
const int nvfb = (cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0, 0,
+ av1_setup_dst_planes(xd->plane, cm->seq_params->sb_size, frame, 0, 0, 0,
num_planes);
for (int fbr = 0; fbr < nvfb; fbr++)
diff --git a/av1/common/cfl.h b/av1/common/cfl.h
index 0062e9f..0d53764 100644
--- a/av1/common/cfl.h
+++ b/av1/common/cfl.h
@@ -39,7 +39,7 @@
const MACROBLOCKD *xd) {
const MB_MODE_INFO *mbmi = xd->mi[0];
- if (cm->seq_params.monochrome) return CFL_DISALLOWED;
+ if (cm->seq_params->monochrome) return CFL_DISALLOWED;
if (!xd->is_chroma_ref) {
// For non-chroma-reference blocks, we should always store the luma pixels,
diff --git a/av1/common/loopfiltermask.c b/av1/common/loopfiltermask.c
index 1ae0b11..22ab0ad 100644
--- a/av1/common/loopfiltermask.c
+++ b/av1/common/loopfiltermask.c
@@ -1002,11 +1002,11 @@
}
#if CONFIG_AV1_HIGHBITDEPTH
- if (cm->seq_params.use_highbitdepth)
+ if (cm->seq_params->use_highbitdepth)
highbd_filter_selectively_vert_row2(
ssx, CONVERT_TO_SHORTPTR(dst->buf), dst->stride, pl, mask_16x16_0,
mask_8x8_0, mask_4x4_0, mask_16x16_1, mask_8x8_1, mask_4x4_1,
- &cm->lf_info, lfl, lfl2, (int)cm->seq_params.bit_depth);
+ &cm->lf_info, lfl, lfl2, (int)cm->seq_params->bit_depth);
else
filter_selectively_vert_row2(
ssx, dst->buf, dst->stride, pl, mask_16x16_0, mask_8x8_0, mask_4x4_0,
@@ -1075,10 +1075,11 @@
mask_4x4 = (mask_4x4 >> shift) & mask_cutoff;
#if CONFIG_AV1_HIGHBITDEPTH
- if (cm->seq_params.use_highbitdepth)
- highbd_filter_selectively_horiz(
- CONVERT_TO_SHORTPTR(dst->buf), dst->stride, pl, ssx, mask_16x16,
- mask_8x8, mask_4x4, &cm->lf_info, lfl, (int)cm->seq_params.bit_depth);
+ if (cm->seq_params->use_highbitdepth)
+ highbd_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
+ dst->stride, pl, ssx, mask_16x16,
+ mask_8x8, mask_4x4, &cm->lf_info, lfl,
+ (int)cm->seq_params->bit_depth);
else
filter_selectively_horiz(dst->buf, dst->stride, pl, ssx, mask_16x16,
mask_8x8, mask_4x4, &cm->lf_info, lfl);
@@ -1109,10 +1110,10 @@
uint8_t *lfl2;
// filter two rows at a time
- for (r = 0; r < cm->seq_params.mib_size &&
+ for (r = 0; r < cm->seq_params->mib_size &&
((mi_row + r) << MI_SIZE_LOG2 < cm->height);
r += r_step) {
- for (c = 0; c < cm->seq_params.mib_size &&
+ for (c = 0; c < cm->seq_params->mib_size &&
((mi_col + c) << MI_SIZE_LOG2 < cm->width);
c += MI_SIZE_64X64) {
dst->buf += ((c << MI_SIZE_LOG2) >> ssx);
@@ -1159,11 +1160,11 @@
uint64_t mask_4x4_1 = (mask_4x4 >> shift_next) & mask_cutoff;
#if CONFIG_AV1_HIGHBITDEPTH
- if (cm->seq_params.use_highbitdepth)
+ if (cm->seq_params->use_highbitdepth)
highbd_filter_selectively_vert_row2(
ssx, CONVERT_TO_SHORTPTR(dst->buf), dst->stride, pl, mask_16x16_0,
mask_8x8_0, mask_4x4_0, mask_16x16_1, mask_8x8_1, mask_4x4_1,
- &cm->lf_info, lfl, lfl2, (int)cm->seq_params.bit_depth);
+ &cm->lf_info, lfl, lfl2, (int)cm->seq_params->bit_depth);
else
filter_selectively_vert_row2(ssx, dst->buf, dst->stride, pl,
mask_16x16_0, mask_8x8_0, mask_4x4_0,
@@ -1194,10 +1195,10 @@
uint64_t mask_4x4 = 0;
uint8_t *lfl;
- for (r = 0; r < cm->seq_params.mib_size &&
+ for (r = 0; r < cm->seq_params->mib_size &&
((mi_row + r) << MI_SIZE_LOG2 < cm->height);
r += r_step) {
- for (c = 0; c < cm->seq_params.mib_size &&
+ for (c = 0; c < cm->seq_params->mib_size &&
((mi_col + c) << MI_SIZE_LOG2 < cm->width);
c += MI_SIZE_64X64) {
if (mi_row + r == 0) continue;
@@ -1235,11 +1236,11 @@
mask_4x4 = (mask_4x4 >> shift) & mask_cutoff;
#if CONFIG_AV1_HIGHBITDEPTH
- if (cm->seq_params.use_highbitdepth)
+ if (cm->seq_params->use_highbitdepth)
highbd_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride, pl, ssx, mask_16x16,
mask_8x8, mask_4x4, &cm->lf_info, lfl,
- (int)cm->seq_params.bit_depth);
+ (int)cm->seq_params->bit_depth);
else
filter_selectively_horiz(dst->buf, dst->stride, pl, ssx, mask_16x16,
mask_8x8, mask_4x4, &cm->lf_info, lfl);
@@ -1260,9 +1261,11 @@
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->bsize, cm->seq_params.subsampling_x, cm->seq_params.subsampling_y)];
+ mbmi->bsize, 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->bsize, cm->seq_params.subsampling_x, cm->seq_params.subsampling_y)];
+ mbmi->bsize, 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;
@@ -1330,9 +1333,11 @@
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->bsize, cm->seq_params.subsampling_x, cm->seq_params.subsampling_y)];
+ mbmi->bsize, 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->bsize, cm->seq_params.subsampling_x, cm->seq_params.subsampling_y)];
+ mbmi->bsize, 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;
diff --git a/av1/common/mvref_common.c b/av1/common/mvref_common.c
index 04e050a..21be27c 100644
--- a/av1/common/mvref_common.c
+++ b/av1/common/mvref_common.c
@@ -258,7 +258,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->seq_params.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);
@@ -347,7 +347,7 @@
const int cur_frame_index = cm->cur_frame->order_hint;
const RefCntBuffer *const buf_0 = get_ref_frame_buf(cm, rf[0]);
const int frame0_index = buf_0->order_hint;
- const int cur_offset_0 = get_relative_dist(&cm->seq_params.order_hint_info,
+ const int cur_offset_0 = get_relative_dist(&cm->seq_params->order_hint_info,
cur_frame_index, frame0_index);
int idx;
const int allow_high_precision_mv = cm->features.allow_high_precision_mv;
@@ -380,7 +380,7 @@
// Process compound inter mode
const RefCntBuffer *const buf_1 = get_ref_frame_buf(cm, rf[1]);
const int frame1_index = buf_1->order_hint;
- const int cur_offset_1 = get_relative_dist(&cm->seq_params.order_hint_info,
+ const int cur_offset_1 = get_relative_dist(&cm->seq_params->order_hint_info,
cur_frame_index, frame1_index);
int_mv comp_refmv;
get_mv_projection(&comp_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv,
@@ -854,10 +854,10 @@
MV_REFERENCE_FRAME ref_frame;
for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame);
- if (cm->seq_params.order_hint_info.enable_order_hint && buf != NULL) {
+ if (cm->seq_params->order_hint_info.enable_order_hint && buf != NULL) {
const int ref_order_hint = buf->order_hint;
cm->ref_frame_sign_bias[ref_frame] =
- (get_relative_dist(&cm->seq_params.order_hint_info, ref_order_hint,
+ (get_relative_dist(&cm->seq_params->order_hint_info, ref_order_hint,
(int)cm->current_frame.order_hint) <= 0)
? 0
: 1;
@@ -930,10 +930,10 @@
&start_frame_buf->ref_order_hints[0];
const int cur_order_hint = cm->cur_frame->order_hint;
int start_to_current_frame_offset = get_relative_dist(
- &cm->seq_params.order_hint_info, start_frame_order_hint, cur_order_hint);
+ &cm->seq_params->order_hint_info, start_frame_order_hint, cur_order_hint);
for (MV_REFERENCE_FRAME rf = LAST_FRAME; rf <= INTER_REFS_PER_FRAME; ++rf) {
- ref_offset[rf] = get_relative_dist(&cm->seq_params.order_hint_info,
+ ref_offset[rf] = get_relative_dist(&cm->seq_params->order_hint_info,
start_frame_order_hint,
ref_order_hints[rf - LAST_FRAME]);
}
@@ -981,7 +981,7 @@
}
void av1_setup_motion_field(AV1_COMMON *cm) {
- const OrderHintInfo *const order_hint_info = &cm->seq_params.order_hint_info;
+ const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info;
memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side));
if (!order_hint_info->enable_order_hint) return;
@@ -1219,7 +1219,7 @@
}
void av1_setup_skip_mode_allowed(AV1_COMMON *cm) {
- const OrderHintInfo *const order_hint_info = &cm->seq_params.order_hint_info;
+ const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info;
SkipModeInfo *const skip_mode_info = &cm->current_frame.skip_mode_info;
skip_mode_info->skip_mode_allowed = 0;
@@ -1323,11 +1323,11 @@
int lst_frame_sort_idx = -1;
int gld_frame_sort_idx = -1;
- assert(cm->seq_params.order_hint_info.enable_order_hint);
- assert(cm->seq_params.order_hint_info.order_hint_bits_minus_1 >= 0);
+ assert(cm->seq_params->order_hint_info.enable_order_hint);
+ assert(cm->seq_params->order_hint_info.order_hint_bits_minus_1 >= 0);
const int cur_order_hint = (int)cm->current_frame.order_hint;
const int cur_frame_sort_idx =
- 1 << cm->seq_params.order_hint_info.order_hint_bits_minus_1;
+ 1 << cm->seq_params->order_hint_info.order_hint_bits_minus_1;
REF_FRAME_INFO ref_frame_info[REF_FRAMES];
int ref_flag_list[INTER_REFS_PER_FRAME] = { 0, 0, 0, 0, 0, 0, 0 };
@@ -1349,7 +1349,7 @@
ref_frame_info[i].sort_idx =
(offset == -1) ? -1
: cur_frame_sort_idx +
- get_relative_dist(&cm->seq_params.order_hint_info,
+ get_relative_dist(&cm->seq_params->order_hint_info,
offset, cur_order_hint);
assert(ref_frame_info[i].sort_idx >= -1);
diff --git a/av1/common/pred_common.h b/av1/common/pred_common.h
index 12bcce8..3db9dd6 100644
--- a/av1/common/pred_common.h
+++ b/av1/common/pred_common.h
@@ -107,9 +107,9 @@
if (bck_buf != NULL) bck_frame_index = bck_buf->order_hint;
if (fwd_buf != NULL) fwd_frame_index = fwd_buf->order_hint;
- int fwd = abs(get_relative_dist(&cm->seq_params.order_hint_info,
+ int fwd = abs(get_relative_dist(&cm->seq_params->order_hint_info,
fwd_frame_index, cur_frame_index));
- int bck = abs(get_relative_dist(&cm->seq_params.order_hint_info,
+ int bck = abs(get_relative_dist(&cm->seq_params->order_hint_info,
cur_frame_index, bck_frame_index));
const MB_MODE_INFO *const above_mi = xd->above_mbmi;
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index dc479a9..66c3e28ae 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -734,10 +734,10 @@
if (bck_buf != NULL) bck_frame_index = bck_buf->order_hint;
if (fwd_buf != NULL) fwd_frame_index = fwd_buf->order_hint;
- int d0 = clamp(abs(get_relative_dist(&cm->seq_params.order_hint_info,
+ int d0 = clamp(abs(get_relative_dist(&cm->seq_params->order_hint_info,
fwd_frame_index, cur_frame_index)),
0, MAX_FRAME_DISTANCE);
- int d1 = clamp(abs(get_relative_dist(&cm->seq_params.order_hint_info,
+ int d1 = clamp(abs(get_relative_dist(&cm->seq_params->order_hint_info,
cur_frame_index, bck_frame_index)),
0, MAX_FRAME_DISTANCE);
@@ -1363,7 +1363,7 @@
assert(xd->mi[0]->angle_delta[PLANE_TYPE_UV] == 0);
assert(xd->mi[0]->filter_intra_mode_info.use_filter_intra == 0);
assert(xd->mi[0]->use_intrabc == 0);
- const SequenceHeader *seq_params = &cm->seq_params;
+ const SequenceHeader *seq_params = cm->seq_params;
av1_predict_intra_block(xd, seq_params->sb_size,
seq_params->enable_intra_edge_filter, pd->width,
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index c148423..51b0178 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -1667,7 +1667,7 @@
? mbmi->filter_intra_mode_info.filter_intra_mode
: FILTER_INTRA_MODES;
const int angle_delta = mbmi->angle_delta[plane != AOM_PLANE_Y] * ANGLE_STEP;
- const SequenceHeader *seq_params = &cm->seq_params;
+ const SequenceHeader *seq_params = cm->seq_params;
if (plane != AOM_PLANE_Y && mbmi->uv_mode == UV_CFL_PRED) {
#if CONFIG_DEBUG
diff --git a/av1/common/reconintra.h b/av1/common/reconintra.h
index 63010d7..fa66ccd 100644
--- a/av1/common/reconintra.h
+++ b/av1/common/reconintra.h
@@ -67,7 +67,7 @@
static INLINE int av1_filter_intra_allowed_bsize(const AV1_COMMON *const cm,
BLOCK_SIZE bs) {
- if (!cm->seq_params.enable_filter_intra || bs == BLOCK_INVALID) return 0;
+ if (!cm->seq_params->enable_filter_intra || bs == BLOCK_INVALID) return 0;
return block_size_wide[bs] <= 32 && block_size_high[bs] <= 32;
}
diff --git a/av1/common/resize.c b/av1/common/resize.c
index 0cfb5a2..e28c832 100644
--- a/av1/common/resize.c
+++ b/av1/common/resize.c
@@ -1263,7 +1263,7 @@
int src_stride, uint8_t *dst, int dst_stride,
int plane, int rows) {
const int is_uv = (plane > 0);
- const int ss_x = is_uv && cm->seq_params.subsampling_x;
+ const int ss_x = is_uv && cm->seq_params->subsampling_x;
const int downscaled_plane_width = ROUND_POWER_OF_TWO(cm->width, ss_x);
const int upscaled_plane_width =
ROUND_POWER_OF_TWO(cm->superres_upscaled_width, ss_x);
@@ -1305,11 +1305,11 @@
const int pad_right = (j == cm->tiles.cols - 1);
#if CONFIG_AV1_HIGHBITDEPTH
- if (cm->seq_params.use_highbitdepth)
+ if (cm->seq_params->use_highbitdepth)
highbd_upscale_normative_rect(src_ptr, rows, src_width, src_stride,
dst_ptr, rows, dst_width, dst_stride,
x_step_qn, x0_qn, pad_left, pad_right,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
else
upscale_normative_rect(src_ptr, rows, src_width, src_stride, dst_ptr,
rows, dst_width, dst_stride, x_step_qn, x0_qn,
@@ -1354,18 +1354,18 @@
if (scaling_required) {
const int num_planes = av1_num_planes(cm);
#if CONFIG_AV1_HIGHBITDEPTH
- if (use_optimized_scaler && cm->seq_params.bit_depth == AOM_BITS_8) {
+ if (use_optimized_scaler && cm->seq_params->bit_depth == AOM_BITS_8) {
av1_resize_and_extend_frame(unscaled, scaled, filter, phase, num_planes);
} else {
av1_resize_and_extend_frame_nonnormative(
- unscaled, scaled, (int)cm->seq_params.bit_depth, num_planes);
+ unscaled, scaled, (int)cm->seq_params->bit_depth, num_planes);
}
#else
if (use_optimized_scaler) {
av1_resize_and_extend_frame(unscaled, scaled, filter, phase, num_planes);
} else {
av1_resize_and_extend_frame_nonnormative(
- unscaled, scaled, (int)cm->seq_params.bit_depth, num_planes);
+ unscaled, scaled, (int)cm->seq_params->bit_depth, num_planes);
}
#endif
return scaled;
@@ -1432,7 +1432,7 @@
void av1_superres_upscale(AV1_COMMON *cm, BufferPool *const pool) {
const int num_planes = av1_num_planes(cm);
if (!av1_superres_scaled(cm)) return;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int byte_alignment = cm->features.byte_alignment;
YV12_BUFFER_CONFIG copy_buffer;
diff --git a/av1/common/restoration.c b/av1/common/restoration.c
index 41d0e22..e346028 100644
--- a/av1/common/restoration.c
+++ b/av1/common/restoration.c
@@ -42,8 +42,8 @@
AV1PixelRect av1_whole_frame_rect(const AV1_COMMON *cm, int is_uv) {
AV1PixelRect rect;
- int ss_x = is_uv && cm->seq_params.subsampling_x;
- int ss_y = is_uv && cm->seq_params.subsampling_y;
+ int ss_x = is_uv && cm->seq_params->subsampling_x;
+ int ss_y = is_uv && cm->seq_params->subsampling_y;
rect.top = 0;
rect.bottom = ROUND_POWER_OF_TWO(cm->height, ss_y);
@@ -1107,7 +1107,7 @@
YV12_BUFFER_CONFIG *frame,
AV1_COMMON *cm, int optimized_lr,
int num_planes) {
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int bit_depth = seq_params->bit_depth;
const int highbd = seq_params->use_highbitdepth;
lr_ctxt->dst = &cm->rst_frame;
@@ -1299,7 +1299,7 @@
int32_t *tmpbuf,
RestorationLineBuffers *rlbs) {
const int is_uv = plane > 0;
- const int ss_y = is_uv && cm->seq_params.subsampling_y;
+ const int ss_y = is_uv && cm->seq_params->subsampling_y;
const RestorationInfo *rsi = &cm->rst_info[plane];
@@ -1315,7 +1315,7 @@
int *rrow1) {
assert(rcol0 && rcol1 && rrow0 && rrow1);
- if (bsize != cm->seq_params.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;
assert(!cm->features.all_lossless);
@@ -1345,8 +1345,8 @@
const int vert_units = av1_lr_count_units_in_tile(size, tile_h);
// The size of an MI-unit on this plane of the image
- const int ss_x = is_uv && cm->seq_params.subsampling_x;
- const int ss_y = is_uv && cm->seq_params.subsampling_y;
+ const int ss_x = is_uv && cm->seq_params->subsampling_x;
+ const int ss_y = is_uv && cm->seq_params->subsampling_y;
const int mi_size_x = MI_SIZE >> ss_x;
const int mi_size_y = MI_SIZE >> ss_y;
@@ -1427,7 +1427,7 @@
int upscaled_width;
int line_bytes;
if (av1_superres_scaled(cm)) {
- const int ss_x = is_uv && cm->seq_params.subsampling_x;
+ const int ss_x = is_uv && cm->seq_params->subsampling_x;
upscaled_width = (cm->superres_upscaled_width + ss_x) >> ss_x;
line_bytes = upscaled_width << use_highbd;
if (use_highbd)
@@ -1474,7 +1474,7 @@
// At the point where this function is called, we've already applied
// superres. So we don't need to extend the lines here, we can just
// pull directly from the topmost row of the upscaled frame.
- const int ss_x = is_uv && cm->seq_params.subsampling_x;
+ const int ss_x = is_uv && cm->seq_params->subsampling_x;
const int upscaled_width = av1_superres_scaled(cm)
? (cm->superres_upscaled_width + ss_x) >> ss_x
: src_width;
@@ -1494,7 +1494,7 @@
int use_highbd, int plane,
AV1_COMMON *cm, int after_cdef) {
const int is_uv = plane > 0;
- const int ss_y = is_uv && cm->seq_params.subsampling_y;
+ const int ss_y = is_uv && cm->seq_params->subsampling_y;
const int stripe_height = RESTORATION_PROC_UNIT_SIZE >> ss_y;
const int stripe_off = RESTORATION_UNIT_OFFSET >> ss_y;
@@ -1559,7 +1559,7 @@
void av1_loop_restoration_save_boundary_lines(const YV12_BUFFER_CONFIG *frame,
AV1_COMMON *cm, int after_cdef) {
const int num_planes = av1_num_planes(cm);
- const int use_highbd = cm->seq_params.use_highbitdepth;
+ const int use_highbd = cm->seq_params->use_highbitdepth;
for (int p = 0; p < num_planes; ++p) {
save_tile_row_boundary_lines(frame, use_highbd, p, cm, after_cdef);
}
diff --git a/av1/common/thread_common.c b/av1/common/thread_common.c
index 2f84355..3d4aae1 100644
--- a/av1/common/thread_common.c
+++ b/av1/common/thread_common.c
@@ -342,7 +342,7 @@
mi_col += MAX_MIB_SIZE) {
c = mi_col >> MAX_MIB_SIZE_LOG2;
- av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer,
+ av1_setup_dst_planes(planes, cm->seq_params->sb_size, frame_buffer,
mi_row, mi_col, plane, plane + 1);
av1_filter_block_plane_vert(cm, xd, plane, &planes[plane], mi_row,
@@ -362,7 +362,7 @@
// completed
sync_read(lf_sync, r + 1, c, plane);
- av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer,
+ av1_setup_dst_planes(planes, cm->seq_params->sb_size, frame_buffer,
mi_row, mi_col, plane, plane + 1);
av1_filter_block_plane_horz(cm, xd, plane, &planes[plane], mi_row,
mi_col);
@@ -565,7 +565,7 @@
// TODO(chengchen): can we remove this?
struct macroblockd_plane *pd = xd->plane;
- av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame, 0, 0, plane,
+ av1_setup_dst_planes(pd, cm->seq_params->sb_size, frame, 0, 0, plane,
plane + 1);
av1_build_bitmask_vert_info(cm, &pd[plane], plane);
@@ -773,7 +773,7 @@
for (int plane = 0; plane < num_planes; plane++) {
if (cm->rst_info[plane].frame_restoration_type == RESTORE_NONE) continue;
const int is_uv = plane > 0;
- const int ss_y = is_uv && cm->seq_params.subsampling_y;
+ const int ss_y = is_uv && cm->seq_params->subsampling_y;
AV1PixelRect tile_rect = ctxt[plane].tile_rect;
const int unit_size = ctxt[plane].rsi->restoration_unit_size;
@@ -1119,7 +1119,7 @@
fb_info->src = src;
fb_info->damping = cm->cdef_info.cdef_damping;
- fb_info->coeff_shift = AOMMAX(cm->seq_params.bit_depth - 8, 0);
+ fb_info->coeff_shift = AOMMAX(cm->seq_params->bit_depth - 8, 0);
av1_zero(fb_info->dir);
av1_zero(fb_info->var);
@@ -1168,7 +1168,7 @@
YV12_BUFFER_CONFIG *frame = &cm->cur_frame->buf;
const int num_planes = av1_num_planes(cm);
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0, 0,
+ av1_setup_dst_planes(xd->plane, cm->seq_params->sb_size, frame, 0, 0, 0,
num_planes);
reset_cdef_job_info(cdef_sync);
diff --git a/av1/common/tile_common.c b/av1/common/tile_common.c
index 1b11bd7..8f5d2a6 100644
--- a/av1/common/tile_common.c
+++ b/av1/common/tile_common.c
@@ -28,7 +28,7 @@
}
void av1_get_tile_limits(AV1_COMMON *const cm) {
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
CommonTileParams *const tiles = &cm->tiles;
const int mi_cols =
ALIGN_POWER_OF_TWO(cm->mi_params.mi_cols, seq_params->mib_size_log2);
@@ -130,9 +130,9 @@
void av1_tile_set_row(TileInfo *tile, const AV1_COMMON *cm, int row) {
assert(row < cm->tiles.rows);
int mi_row_start = cm->tiles.row_start_sb[row]
- << cm->seq_params.mib_size_log2;
+ << cm->seq_params->mib_size_log2;
int mi_row_end = cm->tiles.row_start_sb[row + 1]
- << cm->seq_params.mib_size_log2;
+ << cm->seq_params->mib_size_log2;
tile->tile_row = row;
tile->mi_row_start = mi_row_start;
tile->mi_row_end = AOMMIN(mi_row_end, cm->mi_params.mi_rows);
@@ -142,9 +142,9 @@
void av1_tile_set_col(TileInfo *tile, const AV1_COMMON *cm, int col) {
assert(col < cm->tiles.cols);
int mi_col_start = cm->tiles.col_start_sb[col]
- << cm->seq_params.mib_size_log2;
+ << cm->seq_params->mib_size_log2;
int mi_col_end = cm->tiles.col_start_sb[col + 1]
- << cm->seq_params.mib_size_log2;
+ << cm->seq_params->mib_size_log2;
tile->tile_col = col;
tile->mi_col_start = mi_col_start;
tile->mi_col_end = AOMMIN(mi_col_end, cm->mi_params.mi_cols);
@@ -153,16 +153,16 @@
int av1_get_sb_rows_in_tile(AV1_COMMON *cm, TileInfo tile) {
int mi_rows_aligned_to_sb = ALIGN_POWER_OF_TWO(
- tile.mi_row_end - tile.mi_row_start, cm->seq_params.mib_size_log2);
- int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params.mib_size_log2;
+ tile.mi_row_end - tile.mi_row_start, cm->seq_params->mib_size_log2);
+ int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params->mib_size_log2;
return sb_rows;
}
int av1_get_sb_cols_in_tile(AV1_COMMON *cm, TileInfo tile) {
int mi_cols_aligned_to_sb = ALIGN_POWER_OF_TWO(
- tile.mi_col_end - tile.mi_col_start, cm->seq_params.mib_size_log2);
- int sb_cols = mi_cols_aligned_to_sb >> cm->seq_params.mib_size_log2;
+ tile.mi_col_end - tile.mi_col_start, cm->seq_params->mib_size_log2);
+ int sb_cols = mi_cols_aligned_to_sb >> cm->seq_params->mib_size_log2;
return sb_cols;
}
@@ -195,8 +195,8 @@
r.bottom = AOMMIN(r.bottom, frame_h);
// Convert to coordinates in the appropriate plane
- const int ss_x = is_uv && cm->seq_params.subsampling_x;
- const int ss_y = is_uv && cm->seq_params.subsampling_y;
+ const int ss_x = is_uv && cm->seq_params->subsampling_x;
+ const int ss_y = is_uv && cm->seq_params->subsampling_y;
r.left = ROUND_POWER_OF_TWO(r.left, ss_x);
r.right = ROUND_POWER_OF_TWO(r.right, ss_x);
@@ -215,7 +215,7 @@
for (int i = 0; i < tiles->cols; ++i) {
const int tile_width_sb =
tiles->col_start_sb[i + 1] - tiles->col_start_sb[i];
- const int tile_w = tile_width_sb * cm->seq_params.mib_size;
+ const int tile_w = tile_width_sb * cm->seq_params->mib_size;
assert(i == 0 || tile_w == *w); // ensure all tiles have same dimension
*w = tile_w;
}
@@ -223,7 +223,7 @@
for (int i = 0; i < tiles->rows; ++i) {
const int tile_height_sb =
tiles->row_start_sb[i + 1] - tiles->row_start_sb[i];
- const int tile_h = tile_height_sb * cm->seq_params.mib_size;
+ const int tile_h = tile_height_sb * cm->seq_params->mib_size;
assert(i == 0 || tile_h == *h); // ensure all tiles have same dimension
*h = tile_h;
}
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 93c4eb5..4d522c9 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -364,7 +364,7 @@
PARTITION_TYPE partition,
BLOCK_SIZE bsize) {
AV1_COMMON *const cm = &pbi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
const int x_mis = AOMMIN(bw, cm->mi_params.mi_cols - mi_col);
@@ -1231,9 +1231,9 @@
: (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);
+ current_qindex, dc_delta_q, cm->seq_params->bit_depth);
xd->plane[j].seg_dequant_QTX[i][1] = av1_ac_quant_QTX(
- current_qindex, ac_delta_q, cm->seq_params.bit_depth);
+ current_qindex, ac_delta_q, cm->seq_params->bit_depth);
}
}
}
@@ -1566,9 +1566,9 @@
}
}
if (!all_none) {
- assert(cm->seq_params.sb_size == BLOCK_64X64 ||
- cm->seq_params.sb_size == BLOCK_128X128);
- const int sb_size = cm->seq_params.sb_size == BLOCK_128X128 ? 128 : 64;
+ assert(cm->seq_params->sb_size == BLOCK_64X64 ||
+ cm->seq_params->sb_size == BLOCK_128X128);
+ const int sb_size = cm->seq_params->sb_size == BLOCK_128X128 ? 128 : 64;
for (int p = 0; p < num_planes; ++p)
cm->rst_info[p].restoration_unit_size = sb_size;
@@ -1588,7 +1588,8 @@
}
if (num_planes > 1) {
- int s = AOMMIN(cm->seq_params.subsampling_x, cm->seq_params.subsampling_y);
+ int s =
+ AOMMIN(cm->seq_params->subsampling_x, cm->seq_params->subsampling_y);
if (s && !chroma_none) {
cm->rst_info[1].restoration_unit_size =
cm->rst_info[0].restoration_unit_size >> (aom_rb_read_bit(rb) * s);
@@ -1859,7 +1860,7 @@
// Build y/uv dequant values based on segmentation.
static AOM_INLINE void setup_segmentation_dequant(AV1_COMMON *const cm,
MACROBLOCKD *const xd) {
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
// When segmentation is disabled, only the first value is used. The
// remaining are don't cares.
const int max_segments = cm->seg.enabled ? MAX_SEGMENTS : 1;
@@ -1921,7 +1922,7 @@
cm->superres_upscaled_width = *width;
cm->superres_upscaled_height = *height;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
if (!seq_params->enable_superres) return;
if (aom_rb_read_bit(rb)) {
@@ -1980,7 +1981,7 @@
static AOM_INLINE void setup_buffer_pool(AV1_COMMON *cm) {
BufferPool *const pool = cm->buffer_pool;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
lock_buffer_pool(pool);
if (aom_realloc_frame_buffer(
@@ -2011,7 +2012,7 @@
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;
+ const SequenceHeader *const seq_params = cm->seq_params;
int width, height;
if (frame_size_override_flag) {
@@ -2077,7 +2078,7 @@
}
}
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
if (!found) {
int num_bits_width = seq_params->num_bits_width;
int num_bits_height = seq_params->num_bits_height;
@@ -2129,7 +2130,7 @@
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;
+ 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);
@@ -2472,7 +2473,7 @@
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 mib_size_log2 = cm->seq_params->mib_size_log2;
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;
@@ -2641,11 +2642,11 @@
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;
+ (mi_row - tile_info.mi_row_start) >> cm->seq_params->mib_size_log2;
int sb_col_in_tile = 0;
for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
- mi_col += cm->seq_params.mib_size, sb_col_in_tile++) {
+ mi_col += cm->seq_params->mib_size, sb_col_in_tile++) {
set_cb_buffer(pbi, &td->dcb, pbi->cb_buffer_base, num_planes, mi_row,
mi_col);
@@ -2653,7 +2654,7 @@
// Decoding of the super-block
decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
- cm->seq_params.sb_size, 0x2);
+ cm->seq_params->sb_size, 0x2);
sync_write(&tile_data->dec_row_mt_sync, sb_row_in_tile, sb_col_in_tile,
sb_cols_in_tile);
@@ -2723,16 +2724,16 @@
av1_reset_loop_restoration(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) {
+ mi_row += cm->seq_params->mib_size) {
av1_zero_left_context(xd);
for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
- mi_col += cm->seq_params.mib_size) {
+ mi_col += cm->seq_params->mib_size) {
set_cb_buffer(pbi, dcb, &td->cb_buffer_base, num_planes, 0, 0);
// Bit-stream parsing and decoding of the superblock
decode_partition(pbi, td, mi_row, mi_col, td->bit_reader,
- cm->seq_params.sb_size, 0x3);
+ cm->seq_params->sb_size, 0x3);
if (aom_reader_has_overflowed(td->bit_reader)) {
aom_merge_corrupted_flag(&dcb->corrupted, 1);
@@ -3033,7 +3034,7 @@
const int tile_cols_end = frame_row_mt_info->tile_cols_end;
const int start_tile = frame_row_mt_info->start_tile;
const int end_tile = frame_row_mt_info->end_tile;
- const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
+ const int sb_mi_size = mi_size_wide[cm->seq_params->sb_size];
int num_mis_to_decode, num_threads_working;
int num_mis_waiting_for_decode;
int min_threads_working = INT_MAX;
@@ -3151,7 +3152,7 @@
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 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;
@@ -3164,16 +3165,16 @@
av1_reset_loop_restoration(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) {
+ mi_row += cm->seq_params->mib_size) {
av1_zero_left_context(xd);
for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
- mi_col += cm->seq_params.mib_size) {
+ mi_col += cm->seq_params->mib_size) {
set_cb_buffer(pbi, dcb, 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);
+ cm->seq_params->sb_size, 0x1);
if (aom_reader_has_overflowed(td->bit_reader)) {
aom_merge_corrupted_flag(&dcb->corrupted, 1);
@@ -3522,7 +3523,7 @@
thread_data->error_info.setjmp = 0;
}
}
- const int use_highbd = cm->seq_params.use_highbitdepth;
+ const int use_highbd = cm->seq_params->use_highbitdepth;
const int buf_size = MC_TEMP_BUF_PELS << use_highbd;
for (worker_idx = 1; worker_idx < pbi->max_threads; ++worker_idx) {
DecWorkerData *const thread_data = pbi->thread_data + worker_idx;
@@ -3652,8 +3653,8 @@
static AOM_INLINE void dec_alloc_cb_buf(AV1Decoder *pbi) {
AV1_COMMON *const cm = &pbi->common;
- 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);
+ 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);
@@ -3697,10 +3698,10 @@
tile_data->dec_row_mt_sync.num_threads_working = 0;
tile_data->dec_row_mt_sync.mi_rows =
ALIGN_POWER_OF_TWO(tile_info.mi_row_end - tile_info.mi_row_start,
- cm->seq_params.mib_size_log2);
+ cm->seq_params->mib_size_log2);
tile_data->dec_row_mt_sync.mi_cols =
ALIGN_POWER_OF_TWO(tile_info.mi_col_end - tile_info.mi_col_start,
- cm->seq_params.mib_size_log2);
+ cm->seq_params->mib_size_log2);
frame_row_mt_info->mi_rows_to_decode +=
tile_data->dec_row_mt_sync.mi_rows;
@@ -3892,7 +3893,7 @@
void av1_read_film_grain_params(AV1_COMMON *cm,
struct aom_read_bit_buffer *rb) {
aom_film_grain_t *pars = &cm->film_grain_params;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
pars->apply_grain = aom_rb_read_bit(rb);
if (!pars->apply_grain) {
@@ -4056,13 +4057,13 @@
static AOM_INLINE void read_film_grain(AV1_COMMON *cm,
struct aom_read_bit_buffer *rb) {
- if (cm->seq_params.film_grain_params_present &&
+ if (cm->seq_params->film_grain_params_present &&
(cm->show_frame || cm->showable_frame)) {
av1_read_film_grain_params(cm, rb);
} else {
memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params));
}
- cm->film_grain_params.bit_depth = cm->seq_params.bit_depth;
+ cm->film_grain_params.bit_depth = cm->seq_params->bit_depth;
memcpy(&cm->cur_frame->film_grain_params, &cm->film_grain_params,
sizeof(aom_film_grain_t));
}
@@ -4196,7 +4197,7 @@
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->seq_params.decoder_model_info.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,
@@ -4478,7 +4479,7 @@
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;
+ const SequenceHeader *const seq_params = cm->seq_params;
CurrentFrame *const current_frame = &cm->current_frame;
FeatureFlags *const features = &cm->features;
MACROBLOCKD *const xd = &pbi->dcb.xd;
@@ -5011,7 +5012,7 @@
CommonQuantParams *const quant_params = &cm->quant_params;
setup_quantization(quant_params, av1_num_planes(cm),
- cm->seq_params.separate_uv_delta_q, rb);
+ cm->seq_params->separate_uv_delta_q, rb);
xd->bd = (int)seq_params->bit_depth;
CommonContexts *const above_contexts = &cm->above_contexts;
@@ -5212,8 +5213,8 @@
av1_setup_motion_field(cm);
- av1_setup_block_planes(xd, cm->seq_params.subsampling_x,
- cm->seq_params.subsampling_y, num_planes);
+ av1_setup_block_planes(xd, cm->seq_params->subsampling_x,
+ cm->seq_params->subsampling_y, num_planes);
if (cm->features.primary_ref_frame == PRIMARY_REF_NONE) {
// use the default frame context values
*cm->fc = *cm->default_frame_context;
@@ -5239,7 +5240,7 @@
av1_alloc_restoration_buffers(cm);
}
#endif
- const int use_highbd = cm->seq_params.use_highbitdepth;
+ 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);
@@ -5274,7 +5275,7 @@
// If the bit stream is monochrome, set the U and V buffers to a constant.
if (num_planes < 3) {
- set_planes_to_neutral_grey(&cm->seq_params, xd->cur_buf, 1);
+ set_planes_to_neutral_grey(cm->seq_params, xd->cur_buf, 1);
}
if (end_tile != tiles->rows * tiles->cols - 1) {
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 412be86..839bda2 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -46,7 +46,7 @@
// 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 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) {
@@ -61,7 +61,7 @@
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)
+ const int index = (cm->seq_params->sb_size == BLOCK_128X128)
? cdef_unit_col_in_sb + 2 * cdef_unit_row_in_sb
: 0;
@@ -85,12 +85,12 @@
aom_reader *r, MB_MODE_INFO *const mbmi) {
int sign, abs, reduced_delta_qindex = 0;
BLOCK_SIZE bsize = mbmi->bsize;
- 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 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;
- if ((bsize != cm->seq_params.sb_size || mbmi->skip_txfm == 0) &&
+ if ((bsize != cm->seq_params->sb_size || mbmi->skip_txfm == 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);
@@ -117,11 +117,11 @@
int mi_row) {
int reduced_delta_lflevel = 0;
const BLOCK_SIZE bsize = mbmi->bsize;
- 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 = 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);
- if ((bsize != cm->seq_params.sb_size || mbmi->skip_txfm == 0) &&
+ if ((bsize != cm->seq_params->sb_size || mbmi->skip_txfm == 0) &&
read_delta_lf_flag) {
int abs = aom_read_symbol(r, cdf, DELTA_LF_PROBS + 1, ACCT_STR);
const int smallval = (abs < DELTA_LF_SMALL);
@@ -579,7 +579,7 @@
aom_read_symbol(r, xd->tile_ctx->palette_y_size_cdf[bsize_ctx],
PALETTE_SIZES, ACCT_STR) +
2;
- read_palette_colors_y(xd, cm->seq_params.bit_depth, pmi, r);
+ read_palette_colors_y(xd, cm->seq_params->bit_depth, pmi, r);
}
}
if (num_planes > 1 && mbmi->uv_mode == UV_DC_PRED && xd->is_chroma_ref) {
@@ -591,7 +591,7 @@
aom_read_symbol(r, xd->tile_ctx->palette_uv_size_cdf[bsize_ctx],
PALETTE_SIZES, ACCT_STR) +
2;
- read_palette_colors_uv(xd, cm->seq_params.bit_depth, pmi, r);
+ read_palette_colors_uv(xd, cm->seq_params->bit_depth, pmi, r);
}
}
}
@@ -682,7 +682,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, cm, xd, mi_row, mi_col, bsize,
- cm->seq_params.mib_size_log2);
+ cm->seq_params->mib_size_log2);
return valid;
}
@@ -711,7 +711,7 @@
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, xd->mi_row);
+ 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;
@@ -816,7 +816,7 @@
? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
: 0;
- if (!cm->seq_params.monochrome && xd->is_chroma_ref) {
+ 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) {
@@ -1076,7 +1076,7 @@
use_angle_delta && av1_is_directional_mode(mbmi->mode)
? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
: 0;
- if (!cm->seq_params.monochrome && xd->is_chroma_ref) {
+ 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) {
@@ -1375,7 +1375,7 @@
aom_merge_corrupted_flag(&dcb->corrupted, mv_corrupted_flag);
mbmi->use_wedge_interintra = 0;
- if (cm->seq_params.enable_interintra_compound && !mbmi->skip_mode &&
+ if (cm->seq_params->enable_interintra_compound && !mbmi->skip_mode &&
is_interintra_allowed(mbmi)) {
const int bsize_group = size_group_lookup[bsize];
const int interintra =
@@ -1423,7 +1423,7 @@
if (has_second_ref(mbmi) && !mbmi->skip_mode) {
// Read idx to indicate current compound inter prediction mode group
const int masked_compound_used = is_any_masked_compound_used(bsize) &&
- cm->seq_params.enable_masked_compound;
+ cm->seq_params->enable_masked_compound;
if (masked_compound_used) {
const int ctx_comp_group_idx = get_comp_group_idx_context(xd);
@@ -1432,7 +1432,7 @@
}
if (mbmi->comp_group_idx == 0) {
- if (cm->seq_params.order_hint_info.enable_dist_wtd_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 = (uint8_t)aom_read_symbol(
r, ec_ctx->compound_index_cdf[comp_index_ctx], 2, ACCT_STR);
@@ -1473,7 +1473,7 @@
}
read_mb_interp_filter(xd, features->interp_filter,
- cm->seq_params.enable_dual_filter, mbmi, r);
+ cm->seq_params->enable_dual_filter, mbmi, r);
#if !CONFIG_REALTIME_ONLY
if (mbmi->motion_mode == WARPED_CAUSAL) {
@@ -1573,11 +1573,11 @@
if (frame_is_intra_only(cm)) {
read_intra_frame_mode_info(cm, dcb, r);
- if (cm->seq_params.order_hint_info.enable_ref_frame_mvs)
+ if (cm->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, dcb, r);
- if (cm->seq_params.order_hint_info.enable_ref_frame_mvs)
+ if (cm->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/av1/decoder/decoder.c b/av1/decoder/decoder.c
index 48d0e56..d665416 100644
--- a/av1/decoder/decoder.c
+++ b/av1/decoder/decoder.c
@@ -97,6 +97,7 @@
av1_zero(*pbi);
AV1_COMMON *volatile const cm = &pbi->common;
+ cm->seq_params = &pbi->seq_params;
// 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
@@ -129,7 +130,7 @@
pbi->decoding_first_frame = 1;
pbi->common.buffer_pool = pool;
- cm->seq_params.bit_depth = AOM_BITS_8;
+ cm->seq_params->bit_depth = AOM_BITS_8;
cm->mi_params.free_mi = dec_free_mi;
cm->mi_params.setup_mi = dec_setup_mi;
diff --git a/av1/decoder/decoder.h b/av1/decoder/decoder.h
index a8840e6..8914625 100644
--- a/av1/decoder/decoder.h
+++ b/av1/decoder/decoder.h
@@ -334,6 +334,12 @@
int is_arf_frame_present;
int num_tile_groups;
aom_s_frame_info sframe_info;
+
+ /*!
+ * Elements part of the sequence header, that are applicable for all the
+ * frames in the video.
+ */
+ SequenceHeader seq_params;
} AV1Decoder;
// Returns 0 on success. Sets pbi->common.error.error_code to a nonzero error
diff --git a/av1/decoder/obu.c b/av1/decoder/obu.c
index d3d1f0e..74fa532 100644
--- a/av1/decoder/obu.c
+++ b/av1/decoder/obu.c
@@ -110,7 +110,7 @@
// Use a local variable to store the information as we decode. At the end,
// if no errors have occurred, cm->seq_params is updated.
- SequenceHeader sh = cm->seq_params;
+ SequenceHeader sh = *cm->seq_params;
SequenceHeader *const seq_params = &sh;
seq_params->profile = av1_read_profile(rb);
@@ -260,11 +260,11 @@
// If a sequence header has been decoded before, we check if the new
// one is consistent with the old one.
if (pbi->sequence_header_ready) {
- if (!are_seq_headers_consistent(&cm->seq_params, seq_params))
+ if (!are_seq_headers_consistent(cm->seq_params, seq_params))
pbi->sequence_header_changed = 1;
}
- cm->seq_params = *seq_params;
+ *cm->seq_params = *seq_params;
pbi->sequence_header_ready = 1;
return ((rb->bit_offset - saved_bit_offset + 7) >> 3);
@@ -388,13 +388,14 @@
(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.
+ // 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)),
+ 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");
@@ -430,8 +431,8 @@
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 ssy = cm->seq_params->subsampling_y;
+ const int ssx = cm->seq_params->subsampling_x;
const int num_planes = av1_num_planes(cm);
YV12_BUFFER_CONFIG *cur_frame = &cm->cur_frame->buf;
@@ -455,8 +456,8 @@
int vstart2 = tr * h;
int hstart2 = tc * w;
- if (cm->seq_params.use_highbitdepth &&
- cm->seq_params.bit_depth == AOM_BITS_8) {
+ 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 {
diff --git a/av1/encoder/aq_complexity.c b/av1/encoder/aq_complexity.c
index 6f166d6..278e1ca 100644
--- a/av1/encoder/aq_complexity.c
+++ b/av1/encoder/aq_complexity.c
@@ -81,7 +81,7 @@
if (is_frame_aq_enabled(cpi)) {
int segment;
const int aq_strength =
- get_aq_c_strength(base_qindex, cm->seq_params.bit_depth);
+ get_aq_c_strength(base_qindex, cm->seq_params->bit_depth);
// Clear down the segment map.
memset(cpi->enc_seg.map, DEFAULT_AQ2_SEG,
@@ -108,7 +108,7 @@
qindex_delta = av1_compute_qdelta_by_rate(
&cpi->rc, cm->current_frame.frame_type, base_qindex,
aq_c_q_adj_factor[aq_strength][segment], cpi->is_screen_content_type,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
// For AQ complexity mode, we dont allow Q0 in a segment if the base
// Q is not 0. Q0 (lossless) implies 4x4 only and in AQ mode 2 a segment
@@ -150,12 +150,12 @@
// 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->seq_params.mib_size * cm->seq_params.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;
const int aq_strength = get_aq_c_strength(cm->quant_params.base_qindex,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
aom_clear_system_state();
low_var_thresh =
diff --git a/av1/encoder/aq_cyclicrefresh.c b/av1/encoder/aq_cyclicrefresh.c
index 551913e..f3a06a9 100644
--- a/av1/encoder/aq_cyclicrefresh.c
+++ b/av1/encoder/aq_cyclicrefresh.c
@@ -82,7 +82,7 @@
const RATE_CONTROL *const rc = &cpi->rc;
int deltaq = av1_compute_qdelta_by_rate(
rc, cpi->common.current_frame.frame_type, q, rate_factor,
- cpi->is_screen_content_type, cpi->common.seq_params.bit_depth);
+ cpi->is_screen_content_type, cpi->common.seq_params->bit_depth);
if ((-deltaq) > cr->max_qdelta_perc * q / 100) {
deltaq = -cr->max_qdelta_perc * q / 100;
}
@@ -94,7 +94,7 @@
const AV1_COMMON *const cm = &cpi->common;
const FRAME_TYPE frame_type = cm->current_frame.frame_type;
const int base_qindex = cm->quant_params.base_qindex;
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
const int mbs = cm->mi_params.MBs;
const int num4x4bl = mbs << 4;
@@ -138,11 +138,11 @@
bits_per_mb =
(int)((1.0 - weight_segment) *
av1_rc_bits_per_mb(cm->current_frame.frame_type, i,
- correction_factor, cm->seq_params.bit_depth,
+ correction_factor, cm->seq_params->bit_depth,
cpi->is_screen_content_type) +
weight_segment * av1_rc_bits_per_mb(cm->current_frame.frame_type,
i + deltaq, correction_factor,
- cm->seq_params.bit_depth,
+ cm->seq_params->bit_depth,
cpi->is_screen_content_type));
return bits_per_mb;
}
@@ -283,10 +283,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, mi_params->mi_rows * mi_params->mi_cols);
- sb_cols = (mi_params->mi_cols + cm->seq_params.mib_size - 1) /
- cm->seq_params.mib_size;
- sb_rows = (mi_params->mi_rows + cm->seq_params.mib_size - 1) /
- cm->seq_params.mib_size;
+ sb_cols = (mi_params->mi_cols + cm->seq_params->mib_size - 1) /
+ cm->seq_params->mib_size;
+ sb_rows = (mi_params->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 =
@@ -303,8 +303,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->seq_params.mib_size;
- int mi_col = sb_col_index * cm->seq_params.mib_size;
+ int mi_row = sb_row_index * cm->seq_params->mib_size;
+ int mi_col = sb_col_index * cm->seq_params->mib_size;
// TODO(any): Ensure the population of
// cpi->common.features.allow_screen_content_tools and use the same instead
// of cpi->oxcf.tune_cfg.content == AOM_CONTENT_SCREEN
@@ -316,8 +316,8 @@
assert(mi_col >= 0 && mi_col < mi_params->mi_cols);
bl_index = mi_row * mi_params->mi_cols + mi_col;
// Loop through all MI blocks in superblock and update map.
- xmis = AOMMIN(mi_params->mi_cols - mi_col, cm->seq_params.mib_size);
- ymis = AOMMIN(mi_params->mi_rows - mi_row, cm->seq_params.mib_size);
+ xmis = AOMMIN(mi_params->mi_cols - mi_col, cm->seq_params->mib_size);
+ ymis = AOMMIN(mi_params->mi_rows - mi_row, cm->seq_params->mib_size);
// cr_map only needed at 8x8 blocks.
for (y = 0; y < ymis; y += 2) {
for (x = 0; x < xmis; x += 2) {
@@ -447,7 +447,7 @@
return;
} else {
const double q = av1_convert_qindex_to_q(cm->quant_params.base_qindex,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
aom_clear_system_state();
// Set rate threshold to some multiple (set to 2 for now) of the target
// rate (target is given by sb64_target_rate and scaled by 256).
diff --git a/av1/encoder/aq_variance.c b/av1/encoder/aq_variance.c
index 3391315..39aa3cf 100644
--- a/av1/encoder/aq_variance.c
+++ b/av1/encoder/aq_variance.c
@@ -81,7 +81,7 @@
int qindex_delta = av1_compute_qdelta_by_rate(
&cpi->rc, cm->current_frame.frame_type, base_qindex,
rate_ratio[i] / avg_ratio, cpi->is_screen_content_type,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
// We don't allow qindex 0 in a segment if the base value is not 0.
// Q index 0 (lossless) implies 4x4 encoding only and in AQ mode a segment
@@ -199,7 +199,7 @@
int qindex_delta = av1_compute_qdelta_by_rate(
&cpi->rc, cm->current_frame.frame_type, base_qindex,
deltaq_rate_ratio[rate_level], cpi->is_screen_content_type,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
if ((base_qindex != 0) && ((base_qindex + qindex_delta) == 0)) {
qindex_delta = -base_qindex + 1;
diff --git a/av1/encoder/av1_noise_estimate.c b/av1/encoder/av1_noise_estimate.c
index dbc86c5..c5c088f 100644
--- a/av1/encoder/av1_noise_estimate.c
+++ b/av1/encoder/av1_noise_estimate.c
@@ -61,7 +61,7 @@
cpi->common.height != resize_pending_params->height));
#if CONFIG_AV1_HIGHBITDEPTH
- if (cpi->common.seq_params.use_highbitdepth) return 0;
+ if (cpi->common.seq_params->use_highbitdepth) return 0;
#endif
// Enable noise estimation if denoising is on.
#if CONFIG_AV1_TEMPORAL_DENOISING
diff --git a/av1/encoder/av1_quantize.c b/av1/encoder/av1_quantize.c
index 9d38e2d..6e9b79e 100644
--- a/av1/encoder/av1_quantize.c
+++ b/av1/encoder/av1_quantize.c
@@ -767,7 +767,7 @@
aom_get_qmlevel(quant_params->base_qindex + quant_params->u_ac_delta_q,
min_qmlevel, max_qmlevel);
- if (!cm->seq_params.separate_uv_delta_q)
+ if (!cm->seq_params->separate_uv_delta_q)
quant_params->qmatrix_level_v = quant_params->qmatrix_level_u;
else
quant_params->qmatrix_level_v =
diff --git a/av1/encoder/av1_temporal_denoiser.c b/av1/encoder/av1_temporal_denoiser.c
index 730711e..8e42471 100644
--- a/av1/encoder/av1_temporal_denoiser.c
+++ b/av1/encoder/av1_temporal_denoiser.c
@@ -485,8 +485,8 @@
if (denoiser->running_avg_y[fb_idx].buffer_alloc == NULL) {
fail = aom_alloc_frame_buffer(
&denoiser->running_avg_y[fb_idx], cm->width, cm->height,
- cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
- cm->seq_params.use_highbitdepth, AOM_BORDER_IN_PIXELS,
+ cm->seq_params->subsampling_x, cm->seq_params->subsampling_y,
+ cm->seq_params->use_highbitdepth, AOM_BORDER_IN_PIXELS,
cm->features.byte_alignment);
if (fail) {
av1_denoiser_free(denoiser);
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index b10e9aa..2849b37 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -638,7 +638,7 @@
aom_write_symbol(w, filter, ec_ctx->switchable_interp_cdf[ctx],
SWITCHABLE_FILTERS);
++td->interp_filter_selected[filter];
- if (cm->seq_params.enable_dual_filter == 0) return;
+ if (cm->seq_params->enable_dual_filter == 0) return;
}
}
}
@@ -781,7 +781,7 @@
aom_write_symbol(w, n - PALETTE_MIN_SIZE,
xd->tile_ctx->palette_y_size_cdf[bsize_ctx],
PALETTE_SIZES);
- write_palette_colors_y(xd, pmi, cm->seq_params.bit_depth, w);
+ write_palette_colors_y(xd, pmi, cm->seq_params->bit_depth, w);
}
}
@@ -796,7 +796,7 @@
aom_write_symbol(w, n - PALETTE_MIN_SIZE,
xd->tile_ctx->palette_uv_size_cdf[bsize_ctx],
PALETTE_SIZES);
- write_palette_colors_uv(xd, pmi, cm->seq_params.bit_depth, w);
+ write_palette_colors_uv(xd, pmi, cm->seq_params->bit_depth, w);
}
}
}
@@ -878,7 +878,7 @@
// At the start of a superblock, mark that we haven't yet written CDEF
// strengths for any of the CDEF units contained in this superblock.
- const int sb_mask = (cm->seq_params.mib_size - 1);
+ 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) {
@@ -893,7 +893,7 @@
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)
+ const int index = (cm->seq_params->sb_size == BLOCK_128X128)
? cdef_unit_col_in_sb + 2 * cdef_unit_row_in_sb
: 0;
@@ -960,10 +960,10 @@
const MB_MODE_INFO *const mbmi = xd->mi[0];
const BLOCK_SIZE bsize = mbmi->bsize;
const int super_block_upper_left =
- ((xd->mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
- ((xd->mi_col & (cm->seq_params.mib_size - 1)) == 0);
+ ((xd->mi_row & (cm->seq_params->mib_size - 1)) == 0) &&
+ ((xd->mi_col & (cm->seq_params->mib_size - 1)) == 0);
- if ((bsize != cm->seq_params.sb_size || skip == 0) &&
+ if ((bsize != cm->seq_params->sb_size || skip == 0) &&
super_block_upper_left) {
assert(mbmi->current_qindex > 0);
const int reduced_delta_qindex =
@@ -1020,7 +1020,7 @@
}
// UV mode and UV angle delta.
- if (!cm->seq_params.monochrome && xd->is_chroma_ref) {
+ if (!cm->seq_params->monochrome && xd->is_chroma_ref) {
const UV_PREDICTION_MODE uv_mode = mbmi->uv_mode;
write_intra_uv_mode(ec_ctx, uv_mode, mode, is_cfl_allowed(xd), w);
if (uv_mode == UV_CFL_PRED)
@@ -1163,7 +1163,7 @@
}
if (cpi->common.current_frame.reference_mode != COMPOUND_REFERENCE &&
- cpi->common.seq_params.enable_interintra_compound &&
+ cpi->common.seq_params->enable_interintra_compound &&
is_interintra_allowed(mbmi)) {
const int interintra = mbmi->ref_frame[1] == INTRA_FRAME;
const int bsize_group = size_group_lookup[bsize];
@@ -1190,7 +1190,7 @@
// Group B (1): interintra, compound_diffwtd, wedge
if (has_second_ref(mbmi)) {
const int masked_compound_used = is_any_masked_compound_used(bsize) &&
- cm->seq_params.enable_masked_compound;
+ cm->seq_params->enable_masked_compound;
if (masked_compound_used) {
const int ctx_comp_group_idx = get_comp_group_idx_context(xd);
@@ -1204,7 +1204,7 @@
if (mbmi->compound_idx)
assert(mbmi->interinter_comp.type == COMPOUND_AVERAGE);
- if (cm->seq_params.order_hint_info.enable_dist_wtd_comp) {
+ if (cm->seq_params->order_hint_info.enable_dist_wtd_comp) {
const int comp_index_ctx = get_comp_index_context(cm, xd);
aom_write_symbol(w, mbmi->compound_idx,
ec_ctx->compound_index_cdf[comp_index_ctx], 2);
@@ -1414,7 +1414,7 @@
for (int blk_row = row >> ss_y; blk_row < unit_height; blk_row += bkh) {
for (int blk_col = col >> ss_x; blk_col < unit_width; blk_col += bkw) {
pack_txb_tokens(w, cm, x, tok, tok_end, xd, mbmi, plane, plane_bsize,
- cm->seq_params.bit_depth, *block, blk_row, blk_col,
+ cm->seq_params->bit_depth, *block, blk_row, blk_col,
max_tx_size, token_stats);
*block += step;
}
@@ -1494,7 +1494,7 @@
const MB_MODE_INFO *mbmi = xd->mi[0];
const BLOCK_SIZE bsize = mbmi->bsize;
- assert(bsize <= cm->seq_params.sb_size ||
+ assert(bsize <= cm->seq_params->sb_size ||
(bsize >= BLOCK_SIZES && bsize < BLOCK_SIZES_ALL));
const int bh = mi_size_high[bsize];
@@ -1724,9 +1724,9 @@
}
for (int mi_row = mi_row_start; mi_row < mi_row_end;
- mi_row += cm->seq_params.mib_size) {
+ mi_row += cm->seq_params->mib_size) {
const int sb_row_in_tile =
- (mi_row - tile->mi_row_start) >> cm->seq_params.mib_size_log2;
+ (mi_row - tile->mi_row_start) >> cm->seq_params->mib_size_log2;
const TokenExtra *tok =
cpi->token_info.tplist[tile_row][tile_col][sb_row_in_tile].start;
const TokenExtra *tok_end =
@@ -1735,10 +1735,10 @@
av1_zero_left_context(xd);
for (int mi_col = mi_col_start; mi_col < mi_col_end;
- mi_col += cm->seq_params.mib_size) {
+ mi_col += cm->seq_params->mib_size) {
td->mb.cb_coef_buff = av1_get_cb_coeff_buffer(cpi, mi_row, mi_col);
write_modes_sb(cpi, td, tile, w, &tok, tok_end, mi_row, mi_col,
- cm->seq_params.sb_size);
+ cm->seq_params->sb_size);
}
assert(tok == tok_end);
}
@@ -1747,7 +1747,7 @@
static AOM_INLINE void encode_restoration_mode(
AV1_COMMON *cm, struct aom_write_bit_buffer *wb) {
assert(!cm->features.all_lossless);
- if (!cm->seq_params.enable_restoration) return;
+ if (!cm->seq_params->enable_restoration) return;
if (cm->features.allow_intrabc) return;
const int num_planes = av1_num_planes(cm);
int all_none = 1, chroma_none = 1;
@@ -1778,9 +1778,9 @@
}
}
if (!all_none) {
- assert(cm->seq_params.sb_size == BLOCK_64X64 ||
- cm->seq_params.sb_size == BLOCK_128X128);
- const int sb_size = cm->seq_params.sb_size == BLOCK_128X128 ? 128 : 64;
+ assert(cm->seq_params->sb_size == BLOCK_64X64 ||
+ cm->seq_params->sb_size == BLOCK_128X128);
+ const int sb_size = cm->seq_params->sb_size == BLOCK_128X128 ? 128 : 64;
RestorationInfo *rsi = &cm->rst_info[0];
@@ -1796,7 +1796,8 @@
}
if (num_planes > 1) {
- int s = AOMMIN(cm->seq_params.subsampling_x, cm->seq_params.subsampling_y);
+ int s =
+ AOMMIN(cm->seq_params->subsampling_x, cm->seq_params->subsampling_y);
if (s && !chroma_none) {
aom_wb_write_bit(wb, cm->rst_info[1].restoration_unit_size !=
cm->rst_info[0].restoration_unit_size);
@@ -2029,7 +2030,7 @@
static AOM_INLINE void encode_cdef(const AV1_COMMON *cm,
struct aom_write_bit_buffer *wb) {
assert(!cm->features.coded_lossless);
- if (!cm->seq_params.enable_cdef) return;
+ if (!cm->seq_params->enable_cdef) return;
if (cm->features.allow_intrabc) return;
const int num_planes = av1_num_planes(cm);
int i;
@@ -2144,11 +2145,11 @@
static AOM_INLINE 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_params.mi_cols, cm->seq_params.mib_size_log2);
+ ALIGN_POWER_OF_TWO(cm->mi_params.mi_cols, cm->seq_params->mib_size_log2);
int height_mi =
- ALIGN_POWER_OF_TWO(cm->mi_params.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;
+ ALIGN_POWER_OF_TWO(cm->mi_params.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;
const CommonTileParams *const tiles = &cm->tiles;
@@ -2295,7 +2296,7 @@
static AOM_INLINE void write_superres_scale(const AV1_COMMON *const cm,
struct aom_write_bit_buffer *wb) {
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
if (!seq_params->enable_superres) {
assert(cm->superres_scale_denominator == SCALE_NUMERATOR);
return;
@@ -2322,7 +2323,7 @@
const int coded_height = cm->superres_upscaled_height - 1;
if (frame_size_override) {
- const SequenceHeader *seq_params = &cm->seq_params;
+ const SequenceHeader *seq_params = cm->seq_params;
int num_bits_width = seq_params->num_bits_width;
int num_bits_height = seq_params->num_bits_height;
aom_wb_write_literal(wb, coded_width, num_bits_width);
@@ -2480,7 +2481,7 @@
struct aom_write_bit_buffer *wb) {
aom_wb_write_unsigned_literal(
wb, cm->frame_presentation_time,
- cm->seq_params.decoder_model_info.frame_presentation_time_length);
+ cm->seq_params->decoder_model_info.frame_presentation_time_length);
}
static AOM_INLINE void write_film_grain_params(
@@ -2518,15 +2519,15 @@
aom_wb_write_literal(wb, pars->scaling_points_y[i][1], 8);
}
- if (!cm->seq_params.monochrome) {
+ if (!cm->seq_params->monochrome) {
aom_wb_write_bit(wb, pars->chroma_scaling_from_luma);
} else {
assert(!pars->chroma_scaling_from_luma);
}
- if (cm->seq_params.monochrome || pars->chroma_scaling_from_luma ||
- ((cm->seq_params.subsampling_x == 1) &&
- (cm->seq_params.subsampling_y == 1) && (pars->num_y_points == 0))) {
+ if (cm->seq_params->monochrome || pars->chroma_scaling_from_luma ||
+ ((cm->seq_params->subsampling_x == 1) &&
+ (cm->seq_params->subsampling_y == 1) && (pars->num_y_points == 0))) {
assert(pars->num_cb_points == 0 && pars->num_cr_points == 0);
} else {
aom_wb_write_literal(wb, pars->num_cb_points, 4); // max 10
@@ -2826,7 +2827,7 @@
struct aom_write_bit_buffer *wb) {
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const CommonQuantParams *quant_params = &cm->quant_params;
CurrentFrame *const current_frame = &cm->current_frame;
FeatureFlags *const features = &cm->features;
@@ -3069,7 +3070,7 @@
write_tile_info(cm, saved_wb, wb);
encode_quantization(quant_params, av1_num_planes(cm),
- cm->seq_params.separate_uv_delta_q, wb);
+ cm->seq_params->separate_uv_delta_q, wb);
encode_segmentation(cm, wb);
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
@@ -4064,7 +4065,7 @@
level_params, &cpi->frame_header_count, OBU_SEQUENCE_HEADER, 0, data);
obu_payload_size =
- av1_write_sequence_header_obu(&cm->seq_params, data + obu_header_size);
+ av1_write_sequence_header_obu(cm->seq_params, data + obu_header_size);
const size_t length_field_size =
obu_memmove(obu_header_size, obu_payload_size, data);
if (av1_write_uleb_obu_size(obu_header_size, obu_payload_size, data) !=
diff --git a/av1/encoder/compound_type.c b/av1/encoder/compound_type.c
index fedc889..807fb2b 100644
--- a/av1/encoder/compound_type.c
+++ b/av1/encoder/compound_type.c
@@ -314,7 +314,7 @@
int8_t wedge_sign = 0;
assert(is_interinter_compound_used(COMPOUND_WEDGE, bsize));
- assert(cpi->common.seq_params.enable_masked_compound);
+ assert(cpi->common.seq_params->enable_masked_compound);
if (cpi->sf.inter_sf.fast_wedge_sign_estimate) {
wedge_sign = estimate_wedge_sign(cpi, x, bsize, p0, bw, p1, bw);
@@ -392,7 +392,7 @@
const MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
assert(av1_is_wedge_used(bsize));
- assert(cpi->common.seq_params.enable_interintra_compound);
+ assert(cpi->common.seq_params->enable_interintra_compound);
const struct buf_2d *const src = &x->plane[0].src;
const int bw = block_size_wide[bsize];
@@ -836,7 +836,7 @@
const int try_average_comp = (mode_search_mask & (1 << COMPOUND_AVERAGE));
const int try_distwtd_comp =
((mode_search_mask & (1 << COMPOUND_DISTWTD)) &&
- cm->seq_params.order_hint_info.enable_dist_wtd_comp == 1 &&
+ cm->seq_params->order_hint_info.enable_dist_wtd_comp == 1 &&
cpi->sf.inter_sf.use_dist_wtd_comp_flag != DIST_WTD_COMP_DISABLED);
// Check if COMPOUND_AVERAGE and COMPOUND_DISTWTD are valid cases
diff --git a/av1/encoder/context_tree.c b/av1/encoder/context_tree.c
index 566576e..9fd9d1b 100644
--- a/av1/encoder/context_tree.c
+++ b/av1/encoder/context_tree.c
@@ -230,7 +230,7 @@
void av1_setup_sms_tree(AV1_COMP *const cpi, ThreadData *td) {
AV1_COMMON *const cm = &cpi->common;
const int stat_generation_stage = is_stat_generation_stage(cpi);
- const int is_sb_size_128 = cm->seq_params.sb_size == BLOCK_128X128;
+ const int is_sb_size_128 = cm->seq_params->sb_size == BLOCK_128X128;
const int tree_nodes =
get_pc_tree_nodes(is_sb_size_128, stat_generation_stage);
int sms_tree_index = 0;
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index aeeba5c..a9d87d3 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -859,10 +859,10 @@
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
- av1_setup_src_planes(x, src, 0, 0, num_planes, cm->seq_params.sb_size);
+ av1_setup_src_planes(x, src, 0, 0, num_planes, cm->seq_params->sb_size);
- av1_setup_block_planes(xd, cm->seq_params.subsampling_x,
- cm->seq_params.subsampling_y, num_planes);
+ av1_setup_block_planes(xd, cm->seq_params->subsampling_x,
+ cm->seq_params->subsampling_y, num_planes);
set_mi_offsets(&cm->mi_params, xd, 0, 0);
}
@@ -895,7 +895,7 @@
oxcf->algo_cfg.arnr_max_frames > 0 && oxcf->gf_cfg.lag_in_frames > 1;
if (allow_kf_filtering) {
const double y_noise_level = av1_estimate_noise_from_single_plane(
- frame_input->source, 0, cm->seq_params.bit_depth);
+ frame_input->source, 0, cm->seq_params->bit_depth);
apply_filtering = y_noise_level > 0;
} else {
apply_filtering = 0;
@@ -1226,7 +1226,7 @@
&cm->film_grain_params);
} else {
cm->cur_frame->film_grain_params_present =
- cm->seq_params.film_grain_params_present;
+ cm->seq_params->film_grain_params_present;
}
// only one operating point supported now
const int64_t pts64 = ticks_to_timebase_units(timestamp_ratio, *time_stamp);
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 575d645..06da9e8 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -243,7 +243,7 @@
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
assert(delta_q_info->delta_q_present_flag);
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
// Delta-q modulation based on variance
av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, sb_size);
@@ -308,7 +308,7 @@
(int8_t)clamp(delta_lf_from_base, -MAX_LOOP_FILTER, MAX_LOOP_FILTER);
const int frame_lf_count =
av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
- const int mib_size = cm->seq_params.mib_size;
+ const int mib_size = cm->seq_params->mib_size;
// pre-set the delta lf for loop filter. Note that this value is set
// before mi is assigned for each block in current superblock
@@ -353,7 +353,7 @@
const int tpl_stride = tpl_frame->stride;
int64_t inter_cost[INTER_REFS_PER_FRAME] = { 0 };
const int step = 1 << block_mis_log2;
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
const int mi_row_end =
AOMMIN(mi_size_high[sb_size] + mi_row, mi_params->mi_rows);
@@ -428,7 +428,7 @@
static AOM_INLINE void adjust_rdmult_tpl_model(AV1_COMP *cpi, MACROBLOCK *x,
int mi_row, int mi_col) {
- const BLOCK_SIZE sb_size = cpi->common.seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cpi->common.seq_params->sb_size;
const int orig_rdmult = cpi->rd.RDMULT;
assert(IMPLIES(cpi->ppi->gf_group.size > 0,
@@ -453,7 +453,7 @@
MACROBLOCKD *xd = &x->e_mbd;
// TODO(kyslov) Extend to 128x128
- assert(cm->seq_params.sb_size == BLOCK_64X64);
+ assert(cm->seq_params->sb_size == BLOCK_64X64);
av1_set_offsets(cpi, tile, x, mi_row, mi_col, BLOCK_64X64);
@@ -514,7 +514,7 @@
const TileInfo *const tile_info = &tile_data->tile_info;
MB_MODE_INFO **mi = cm->mi_params.mi_grid_base +
get_mi_grid_idx(&cm->mi_params, mi_row, mi_col);
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
// Grade the temporal variation of the sb, the grade will be used to decide
// fast mode search strategy for coding blocks
@@ -601,7 +601,7 @@
if (gather_tpl_data) {
if (cm->delta_q_info.delta_q_present_flag) {
const int num_planes = av1_num_planes(cm);
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
setup_delta_q(cpi, td, x, tile_info, mi_row, mi_col, num_planes);
av1_tpl_rdmult_setup_sb(cpi, x, sb_size, mi_row, mi_col);
}
@@ -639,7 +639,7 @@
const TileInfo *const tile_info = &tile_data->tile_info;
MB_MODE_INFO **mi = cm->mi_params.mi_grid_base +
get_mi_grid_idx(&cm->mi_params, mi_row, mi_col);
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
const int num_planes = av1_num_planes(cm);
int dummy_rate;
int64_t dummy_dist;
@@ -786,9 +786,9 @@
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
const int sb_cols_in_tile = av1_get_sb_cols_in_tile(cm, tile_data->tile_info);
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
- const int mib_size = cm->seq_params.mib_size;
- const int mib_size_log2 = cm->seq_params.mib_size_log2;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
+ const int mib_size = cm->seq_params->mib_size;
+ const int mib_size_log2 = cm->seq_params->mib_size_log2;
const int sb_row = (mi_row - tile_info->mi_row_start) >> mib_size_log2;
const int use_nonrd_mode = cpi->sf.rt_sf.use_nonrd_pick_mode;
const CostUpdateFreq *const cost_upd_freq = &cpi->oxcf.cost_upd_freq;
@@ -902,10 +902,10 @@
// Copy data over into macro block data structures.
av1_setup_src_planes(x, cpi->source, 0, 0, num_planes,
- cm->seq_params.sb_size);
+ cm->seq_params->sb_size);
- av1_setup_block_planes(xd, cm->seq_params.subsampling_x,
- cm->seq_params.subsampling_y, num_planes);
+ av1_setup_block_planes(xd, cm->seq_params->subsampling_x,
+ cm->seq_params->subsampling_y, num_planes);
}
void av1_alloc_tile_data(AV1_COMP *cpi) {
@@ -947,9 +947,9 @@
if (pre_tok != NULL && tplist != NULL) {
token_info->tile_tok[tile_row][tile_col] = pre_tok + tile_tok;
pre_tok = token_info->tile_tok[tile_row][tile_col];
- tile_tok = allocated_tokens(*tile_info,
- cm->seq_params.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);
token_info->tplist[tile_row][tile_col] = tplist + tplist_count;
tplist = token_info->tplist[tile_row][tile_col];
tplist_count = av1_get_sb_rows_in_tile(cm, tile_data->tile_info);
@@ -977,14 +977,14 @@
TokenExtra *tok = NULL;
TokenList *const tplist = cpi->token_info.tplist[tile_row][tile_col];
const int sb_row_in_tile =
- (mi_row - tile_info->mi_row_start) >> cm->seq_params.mib_size_log2;
+ (mi_row - tile_info->mi_row_start) >> cm->seq_params->mib_size_log2;
const int tile_mb_cols =
(tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2;
const int num_mb_rows_in_sb =
- ((1 << (cm->seq_params.mib_size_log2 + MI_SIZE_LOG2)) + 8) >> 4;
+ ((1 << (cm->seq_params->mib_size_log2 + MI_SIZE_LOG2)) + 8) >> 4;
get_start_tok(cpi, tile_row, tile_col, mi_row, &tok,
- cm->seq_params.mib_size_log2 + MI_SIZE_LOG2, num_planes);
+ cm->seq_params->mib_size_log2 + MI_SIZE_LOG2, num_planes);
assert(tplist != NULL);
tplist[sb_row_in_tile].start = tok;
@@ -995,7 +995,7 @@
assert((unsigned int)(tok - tplist[sb_row_in_tile].start) <=
get_token_alloc(num_mb_rows_in_sb, tile_mb_cols,
- cm->seq_params.mib_size_log2 + MI_SIZE_LOG2,
+ cm->seq_params->mib_size_log2 + MI_SIZE_LOG2,
num_planes));
(void)tile_mb_cols;
@@ -1021,7 +1021,7 @@
&td->mb.e_mbd);
if (cpi->oxcf.intra_mode_cfg.enable_cfl_intra)
- cfl_init(&td->mb.e_mbd.cfl, &cm->seq_params);
+ cfl_init(&td->mb.e_mbd.cfl, cm->seq_params);
if (td->mb.txfm_search_info.txb_rd_records != NULL) {
av1_crc32c_calculator_init(
@@ -1029,7 +1029,7 @@
}
for (int mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end;
- mi_row += cm->seq_params.mib_size) {
+ mi_row += cm->seq_params->mib_size) {
av1_encode_sb_row(cpi, td, tile_row, tile_col, mi_row);
}
}
@@ -1152,10 +1152,10 @@
const int cur_offset = (int)cm->current_frame.order_hint;
int ref_offset[2];
get_skip_mode_ref_offsets(cm, ref_offset);
- const int cur_to_ref0 = get_relative_dist(&cm->seq_params.order_hint_info,
+ const int cur_to_ref0 = get_relative_dist(&cm->seq_params->order_hint_info,
cur_offset, ref_offset[0]);
- const int cur_to_ref1 = abs(get_relative_dist(&cm->seq_params.order_hint_info,
- cur_offset, ref_offset[1]));
+ const int cur_to_ref1 = abs(get_relative_dist(
+ &cm->seq_params->order_hint_info, cur_offset, ref_offset[1]));
if (abs(cur_to_ref0 - cur_to_ref1) > 1) return 0;
// High Latency: Turn off skip mode if all refs are fwd.
@@ -1328,7 +1328,7 @@
// Hash data generated for screen contents is used for intraBC ME
const int min_alloc_size = block_size_wide[mi_params->mi_alloc_bsize];
const int max_sb_size =
- (1 << (cm->seq_params.mib_size_log2 + MI_SIZE_LOG2));
+ (1 << (cm->seq_params->mib_size_log2 + MI_SIZE_LOG2));
int src_idx = 0;
for (int size = 4; size <= max_sb_size; size *= 2, src_idx = !src_idx) {
const int dst_idx = !src_idx;
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index 57f1c79..e97887b 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c
@@ -66,13 +66,13 @@
static int get_superblock_tpl_column_end(const AV1_COMMON *const cm, int mi_col,
int num_mi_w) {
// Find the start column of this superblock.
- const int sb_mi_col_start = (mi_col >> cm->seq_params.mib_size_log2)
- << cm->seq_params.mib_size_log2;
+ const int sb_mi_col_start = (mi_col >> cm->seq_params->mib_size_log2)
+ << cm->seq_params->mib_size_log2;
// Same but in superres upscaled dimension.
const int sb_mi_col_start_sr =
coded_to_superres_mi(sb_mi_col_start, cm->superres_scale_denominator);
// Width of this superblock in mi units.
- const int sb_mi_width = mi_size_wide[cm->seq_params.sb_size];
+ const int sb_mi_width = mi_size_wide[cm->seq_params->sb_size];
// Same but in superres upscaled dimension.
const int sb_mi_width_sr =
coded_to_superres_mi(sb_mi_width, cm->superres_scale_denominator);
@@ -134,7 +134,7 @@
rdmult = AOMMAX(rdmult, 0);
av1_set_error_per_bit(&x->errorperbit, rdmult);
aom_clear_system_state();
- if (bsize == cm->seq_params.sb_size) {
+ if (bsize == cm->seq_params->sb_size) {
const int rdmult_sb = set_deltaq_rdmult(cpi, x);
assert(rdmult_sb == rdmult);
(void)rdmult_sb;
@@ -342,7 +342,7 @@
const int x_mis = AOMMIN(bw, mi_params->mi_cols - mi_col);
const int y_mis = AOMMIN(bh, mi_params->mi_rows - mi_row);
- if (cm->seq_params.order_hint_info.enable_ref_frame_mvs)
+ if (cm->seq_params->order_hint_info.enable_ref_frame_mvs)
av1_copy_frame_mvs(cm, mi, mi_row, mi_col, x_mis, y_mis);
}
@@ -605,9 +605,9 @@
MB_MODE_INFO **mib) {
int bh = bh_in;
int r, c;
- for (r = 0; r < cm->seq_params.mib_size; r += bh) {
+ for (r = 0; r < cm->seq_params->mib_size; r += bh) {
int bw = bw_in;
- for (c = 0; c < cm->seq_params.mib_size; c += bw) {
+ for (c = 0; c < cm->seq_params->mib_size; c += bw) {
const int grid_index = get_mi_grid_idx(&cm->mi_params, r, c);
const int mi_index = get_alloc_mi_idx(&cm->mi_params, r, c);
mib[grid_index] = mi + mi_index;
@@ -639,11 +639,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->seq_params.mib_size) &&
- (mi_rows_remaining >= cm->seq_params.mib_size)) {
- for (int block_row = 0; block_row < cm->seq_params.mib_size;
+ if ((mi_cols_remaining >= cm->seq_params->mib_size) &&
+ (mi_rows_remaining >= cm->seq_params->mib_size)) {
+ for (int block_row = 0; block_row < cm->seq_params->mib_size;
block_row += bh) {
- for (int block_col = 0; block_col < cm->seq_params.mib_size;
+ for (int block_col = 0; block_col < cm->seq_params->mib_size;
block_col += bw) {
const int grid_index = get_mi_grid_idx(mi_params, block_row, block_col);
const int mi_index = get_alloc_mi_idx(mi_params, block_row, block_col);
@@ -1166,7 +1166,7 @@
void av1_source_content_sb(AV1_COMP *cpi, MACROBLOCK *x, int offset) {
unsigned int tmp_sse;
unsigned int tmp_variance;
- const BLOCK_SIZE bsize = cpi->common.seq_params.sb_size;
+ const BLOCK_SIZE bsize = cpi->common.seq_params->sb_size;
uint8_t *src_y = cpi->source->y_buffer;
int src_ystride = cpi->source->y_stride;
uint8_t *last_src_y = cpi->last_source->y_buffer;
@@ -1235,7 +1235,7 @@
const AV1_COMMON *cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
xd->above_txfm_context =
cm->above_contexts.txfm[tile_info->tile_row] + mi_col;
@@ -1271,7 +1271,7 @@
const AV1_COMMON *cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
av1_restore_context(x, &sb_fp_stats->x_ctx, mi_row, mi_col, sb_size,
num_planes);
@@ -1346,7 +1346,7 @@
// cost calculation is skipped in this case.
if (frame_is_intra_only(cm)) return 1;
- return skip_cost_update(&cm->seq_params, tile_info, mi_row, mi_col,
+ return skip_cost_update(cm->seq_params, tile_info, mi_row, mi_col,
cpi->sf.inter_sf.mv_cost_upd_level);
}
@@ -1360,7 +1360,7 @@
return 1;
}
- return skip_cost_update(&cm->seq_params, tile_info, mi_row, mi_col,
+ return skip_cost_update(cm->seq_params, tile_info, mi_row, mi_col,
cpi->sf.intra_sf.dv_cost_upd_level);
}
diff --git a/av1/encoder/encodeframe_utils.h b/av1/encoder/encodeframe_utils.h
index 3d2c9b8..d3a0ce0 100644
--- a/av1/encoder/encodeframe_utils.h
+++ b/av1/encoder/encodeframe_utils.h
@@ -245,9 +245,9 @@
AOMMAX(sf->part_sf.default_min_partition_size,
dim_to_size(cpi->oxcf.part_cfg.min_partition_size));
sb_enc->max_partition_size =
- AOMMIN(sb_enc->max_partition_size, cm->seq_params.sb_size);
+ AOMMIN(sb_enc->max_partition_size, cm->seq_params->sb_size);
sb_enc->min_partition_size =
- AOMMIN(sb_enc->min_partition_size, cm->seq_params.sb_size);
+ AOMMIN(sb_enc->min_partition_size, cm->seq_params->sb_size);
if (use_auto_max_partition(cpi, sb_size, mi_row, mi_col)) {
float features[FEATURE_SIZE_MAX_MIN_PART_PRED] = { 0.0f };
@@ -369,7 +369,8 @@
const int num_planes = av1_num_planes(cm);
for (int plane = 0; plane < num_planes; plane++) {
const int subsampling_xy =
- plane ? cm->seq_params.subsampling_x + cm->seq_params.subsampling_y : 0;
+ plane ? cm->seq_params->subsampling_x + cm->seq_params->subsampling_y
+ : 0;
const int sb_size = MAX_SB_SQUARE >> subsampling_xy;
CHECK_MEM_ERROR(cm, mb->plane[plane].src_diff,
(int16_t *)aom_memalign(
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index e92d643..3d405be 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -228,7 +228,7 @@
const int upscaled_width = cm->superres_upscaled_width;
const int height = cm->height;
const int luma_pic_size = upscaled_width * height;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const BITSTREAM_PROFILE profile = seq_params->profile;
const int pic_size_profile_factor =
profile == PROFILE_0 ? 15 : (profile == PROFILE_1 ? 30 : 36);
@@ -242,7 +242,7 @@
static void set_tile_info(AV1_COMMON *const cm,
const TileConfig *const tile_cfg) {
const CommonModeInfoParams *const mi_params = &cm->mi_params;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
CommonTileParams *const tiles = &cm->tiles;
int i, start_sb;
@@ -309,7 +309,7 @@
alloc_context_buffers_ext(cm, &cpi->mbmi_ext_info);
if (!cpi->ppi->seq_params_locked)
- set_sb_size(&cm->seq_params,
+ set_sb_size(cm->seq_params,
av1_select_sb_size(&cpi->oxcf, cm->width, cm->height,
cpi->svc.number_spatial_layers));
@@ -374,13 +374,13 @@
level = SEQ_LEVEL_6_2;
}
- SequenceHeader *const seq_params = &cm->seq_params;
+ SequenceHeader *const seq_params = cm->seq_params;
for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {
seq->seq_level_idx[i] = level;
// Set the maximum parameters for bitrate and buffer size for this profile,
// level, and tier
seq_params->op_params[i].bitrate = av1_max_level_bitrate(
- cm->seq_params.profile, seq->seq_level_idx[i], seq->tier[i]);
+ cm->seq_params->profile, seq->seq_level_idx[i], seq->tier[i]);
// Level with seq_level_idx = 31 returns a high "dummy" bitrate to pass the
// check
if (seq_params->op_params[i].bitrate == 0)
@@ -477,7 +477,7 @@
static void init_config(struct AV1_COMP *cpi, AV1EncoderConfig *oxcf) {
AV1_COMMON *const cm = &cpi->common;
- SequenceHeader *const seq_params = &cm->seq_params;
+ SequenceHeader *const seq_params = cm->seq_params;
ResizePendingParams *resize_pending_params = &cpi->resize_pending_params;
const DecoderModelCfg *const dec_model_cfg = &oxcf->dec_model_cfg;
const ColorCfg *const color_cfg = &oxcf->color_cfg;
@@ -588,7 +588,7 @@
void av1_change_config(struct AV1_COMP *cpi, const AV1EncoderConfig *oxcf) {
AV1_COMMON *const cm = &cpi->common;
- SequenceHeader *const seq_params = &cm->seq_params;
+ SequenceHeader *const seq_params = cm->seq_params;
RATE_CONTROL *const rc = &cpi->rc;
PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;
MACROBLOCK *const x = &cpi->td.mb;
@@ -725,7 +725,7 @@
}
if (x->pixel_gradient_info == NULL) {
- const int plane_types = PLANE_TYPES >> cm->seq_params.monochrome;
+ const int plane_types = PLANE_TYPES >> cm->seq_params->monochrome;
CHECK_MEM_ERROR(cm, x->pixel_gradient_info,
aom_malloc(sizeof(*x->pixel_gradient_info) * plane_types *
MAX_SB_SQUARE));
@@ -767,7 +767,7 @@
// Superblock size should not be updated after the first key frame.
if (!cpi->ppi->seq_params_locked) {
set_sb_size(
- &cm->seq_params,
+ cm->seq_params,
av1_select_sb_size(oxcf, frm_dim_cfg->width, frm_dim_cfg->height,
cpi->svc.number_spatial_layers));
for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i)
@@ -809,7 +809,7 @@
(cm->number_spatial_layers > 1 || cm->number_temporal_layers > 1)
? cm->number_spatial_layers * cm->number_temporal_layers - 1
: 0;
- av1_init_seq_coding_tools(&cm->seq_params, cm, oxcf, cpi->use_svc);
+ av1_init_seq_coding_tools(cm->seq_params, cm, oxcf, cpi->use_svc);
}
if (cpi->use_svc)
@@ -824,7 +824,7 @@
static INLINE void init_frame_info(FRAME_INFO *frame_info,
const AV1_COMMON *const cm) {
const CommonModeInfoParams *const mi_params = &cm->mi_params;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
frame_info->frame_width = cm->width;
frame_info->frame_height = cm->height;
frame_info->mi_cols = mi_params->mi_cols;
@@ -897,6 +897,7 @@
av1_zero(*cpi);
cpi->ppi = ppi;
+ cm->seq_params = &ppi->seq_params;
// 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
@@ -1366,7 +1367,7 @@
* av1_init_quantizer() for every frame.
*/
av1_init_quantizer(&cpi->enc_quant_dequant_params, &cm->quant_params,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
av1_qm_init(&cm->quant_params, av1_num_planes(cm));
av1_loop_filter_init(cm);
@@ -1804,14 +1805,14 @@
void av1_set_screen_content_options(AV1_COMP *cpi, FeatureFlags *features) {
const AV1_COMMON *const cm = &cpi->common;
- if (cm->seq_params.force_screen_content_tools != 2) {
+ if (cm->seq_params->force_screen_content_tools != 2) {
features->allow_screen_content_tools = features->allow_intrabc =
- cm->seq_params.force_screen_content_tools;
+ cm->seq_params->force_screen_content_tools;
return;
}
if (cpi->oxcf.mode == REALTIME) {
- assert(cm->seq_params.reduced_still_picture_hdr);
+ assert(cm->seq_params->reduced_still_picture_hdr);
features->allow_screen_content_tools = features->allow_intrabc = 0;
return;
}
@@ -1829,7 +1830,7 @@
const int stride = cpi->unfiltered_source->y_stride;
const int width = cpi->unfiltered_source->y_width;
const int height = cpi->unfiltered_source->y_height;
- const int bd = cm->seq_params.bit_depth;
+ const int bd = cm->seq_params->bit_depth;
const int blk_w = 16;
const int blk_h = 16;
// These threshold values are selected experimentally.
@@ -1975,7 +1976,7 @@
void av1_check_initial_width(AV1_COMP *cpi, int use_highbitdepth,
int subsampling_x, int subsampling_y) {
AV1_COMMON *const cm = &cpi->common;
- SequenceHeader *const seq_params = &cm->seq_params;
+ SequenceHeader *const seq_params = cm->seq_params;
InitialDimensions *const initial_dimensions = &cpi->initial_dimensions;
if (!initial_dimensions->width ||
@@ -2011,8 +2012,8 @@
if (av1_denoiser_alloc(
cm, &cpi->svc, &cpi->denoiser, cpi->use_svc,
cpi->oxcf.noise_sensitivity, cm->width, cm->height,
- cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
- cm->seq_params.use_highbitdepth, AOM_BORDER_IN_PIXELS))
+ cm->seq_params->subsampling_x, cm->seq_params->subsampling_y,
+ cm->seq_params->use_highbitdepth, AOM_BORDER_IN_PIXELS))
aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
"Failed to allocate denoiser");
}
@@ -2023,9 +2024,9 @@
int av1_set_size_literal(AV1_COMP *cpi, int width, int height) {
AV1_COMMON *cm = &cpi->common;
InitialDimensions *const initial_dimensions = &cpi->initial_dimensions;
- av1_check_initial_width(cpi, cm->seq_params.use_highbitdepth,
- cm->seq_params.subsampling_x,
- cm->seq_params.subsampling_y);
+ av1_check_initial_width(cpi, cm->seq_params->use_highbitdepth,
+ cm->seq_params->subsampling_x,
+ cm->seq_params->subsampling_y);
if (width <= 0 || height <= 0) return 1;
@@ -2055,7 +2056,7 @@
void av1_set_frame_size(AV1_COMP *cpi, int width, int height) {
AV1_COMMON *const cm = &cpi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
int ref_frame;
@@ -2112,7 +2113,7 @@
cpi->mt_info.num_mod_workers[MOD_CDEF]);
#if !CONFIG_REALTIME_ONLY
- const int use_restoration = cm->seq_params.enable_restoration &&
+ const int use_restoration = cm->seq_params->enable_restoration &&
!cm->features.all_lossless &&
!cm->tiles.large_scale;
if (use_restoration) {
@@ -2240,9 +2241,9 @@
const int use_loopfilter =
!cm->features.coded_lossless && !cm->tiles.large_scale;
- const int use_cdef = cm->seq_params.enable_cdef &&
+ const int use_cdef = cm->seq_params->enable_cdef &&
!cm->features.coded_lossless && !cm->tiles.large_scale;
- const int use_restoration = cm->seq_params.enable_restoration &&
+ const int use_restoration = cm->seq_params->enable_restoration &&
!cm->features.all_lossless &&
!cm->tiles.large_scale;
@@ -2402,7 +2403,7 @@
av1_set_speed_features_qindex_dependent(cpi, cpi->oxcf.speed);
if ((q_cfg->deltaq_mode != NO_DELTA_Q) || q_cfg->enable_chroma_deltaq)
av1_init_quantizer(&cpi->enc_quant_dequant_params, &cm->quant_params,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
av1_set_variance_partition_thresholds(cpi, q, 0);
av1_setup_frame(cpi);
@@ -2417,7 +2418,7 @@
av1_set_speed_features_qindex_dependent(cpi, cpi->oxcf.speed);
if (q_cfg->deltaq_mode != NO_DELTA_Q || q_cfg->enable_chroma_deltaq)
av1_init_quantizer(&cpi->enc_quant_dequant_params, &cm->quant_params,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
av1_set_variance_partition_thresholds(cpi, q, 0);
if (frame_is_intra_only(cm) || cm->features.error_resilient_mode)
av1_setup_frame(cpi);
@@ -2609,7 +2610,7 @@
if (q_cfg->deltaq_mode != NO_DELTA_Q || q_cfg->enable_chroma_deltaq)
av1_init_quantizer(&cpi->enc_quant_dequant_params, &cm->quant_params,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
av1_set_variance_partition_thresholds(cpi, q, 0);
@@ -2825,7 +2826,7 @@
#endif
AV1_COMMON *const cm = &cpi->common;
- SequenceHeader *const seq_params = &cm->seq_params;
+ SequenceHeader *const seq_params = cm->seq_params;
// Special case code to reduce pulsing when key frames are forced at a
// fixed interval. Note the reconstruction error if it is the frame before
@@ -2913,7 +2914,7 @@
uint8_t *dest,
int *largest_tile_id) {
const AV1_COMMON *const cm = &cpi->common;
- assert(cm->seq_params.enable_superres);
+ assert(cm->seq_params->enable_superres);
assert(av1_superres_in_recode_allowed(cpi));
aom_codec_err_t err = AOM_CODEC_OK;
av1_save_all_coding_context(cpi);
@@ -2970,7 +2971,7 @@
// Note: Both use common rdmult based on base qindex of fullres.
const int64_t rdmult = av1_compute_rd_mult_based_on_qindex(
- cm->seq_params.bit_depth, cm->quant_params.base_qindex);
+ cm->seq_params->bit_depth, cm->quant_params.base_qindex);
// Find the best rdcost among all superres denoms.
int best_denom = -1;
@@ -2981,7 +2982,7 @@
const int64_t this_rate = superres_rates[this_index];
const int this_largest_tile_id = superres_largest_tile_ids[this_index];
const double this_rdcost = RDCOST_DBL_WITH_NATIVE_BD_DIST(
- rdmult, this_rate, this_sse, cm->seq_params.bit_depth);
+ rdmult, this_rate, this_sse, cm->seq_params->bit_depth);
if (this_rdcost < proj_rdcost1) {
sse1 = this_sse;
rate1 = this_rate;
@@ -2991,7 +2992,7 @@
}
}
const double proj_rdcost2 = RDCOST_DBL_WITH_NATIVE_BD_DIST(
- rdmult, rate2, sse2, cm->seq_params.bit_depth);
+ rdmult, rate2, sse2, cm->seq_params->bit_depth);
// Re-encode with superres if it's better.
if (proj_rdcost1 < proj_rdcost2) {
restore_all_coding_context(cpi);
@@ -3034,11 +3035,11 @@
// Note: Both use common rdmult based on base qindex of fullres.
const int64_t rdmult = av1_compute_rd_mult_based_on_qindex(
- cm->seq_params.bit_depth, cm->quant_params.base_qindex);
+ cm->seq_params->bit_depth, cm->quant_params.base_qindex);
proj_rdcost1 = RDCOST_DBL_WITH_NATIVE_BD_DIST(rdmult, rate1, sse1,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
const double proj_rdcost2 = RDCOST_DBL_WITH_NATIVE_BD_DIST(
- rdmult, rate2, sse2, cm->seq_params.bit_depth);
+ rdmult, rate2, sse2, cm->seq_params->bit_depth);
// Re-encode with superres if it's better.
if (proj_rdcost1 < proj_rdcost2) {
restore_all_coding_context(cpi);
@@ -3084,7 +3085,7 @@
static int encode_frame_to_data_rate(AV1_COMP *cpi, size_t *size,
uint8_t *dest) {
AV1_COMMON *const cm = &cpi->common;
- SequenceHeader *const seq_params = &cm->seq_params;
+ SequenceHeader *const seq_params = cm->seq_params;
CurrentFrame *const current_frame = &cm->current_frame;
const AV1EncoderConfig *const oxcf = &cpi->oxcf;
struct segmentation *const seg = &cm->seg;
@@ -3176,7 +3177,7 @@
if (!is_stat_generation_stage(cpi) &&
cpi->common.features.allow_screen_content_tools &&
!frame_is_intra_only(cm)) {
- if (cpi->common.seq_params.force_integer_mv == 2) {
+ if (cpi->common.seq_params->force_integer_mv == 2) {
// Adaptive mode: see what previous frame encoded did
if (cpi->unscaled_last_source != NULL) {
features->cur_frame_force_integer_mv = av1_is_integer_mv(
@@ -3186,7 +3187,7 @@
}
} else {
cpi->common.features.cur_frame_force_integer_mv =
- cpi->common.seq_params.force_integer_mv;
+ cpi->common.seq_params->force_integer_mv;
}
} else {
cpi->common.features.cur_frame_force_integer_mv = 0;
@@ -3446,7 +3447,7 @@
current_frame->display_order_hint = current_frame->order_hint;
current_frame->order_hint %=
- (1 << (cm->seq_params.order_hint_info.order_hint_bits_minus_1 + 1));
+ (1 << (cm->seq_params->order_hint_info.order_hint_bits_minus_1 + 1));
if (is_stat_generation_stage(cpi)) {
#if !CONFIG_REALTIME_ONLY
@@ -3471,7 +3472,7 @@
AV1_COMMON *const cm = &cpi->common;
if (!cpi->denoise_and_model) {
cpi->denoise_and_model = aom_denoise_and_model_alloc(
- cm->seq_params.bit_depth, block_size, noise_level);
+ cm->seq_params->bit_depth, block_size, noise_level);
if (!cpi->denoise_and_model) {
aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
"Error allocating denoise and model");
@@ -3503,7 +3504,7 @@
YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
int64_t end_time) {
AV1_COMMON *const cm = &cpi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
int res = 0;
const int subsampling_x = sd->subsampling_x;
const int subsampling_y = sd->subsampling_y;
@@ -3630,7 +3631,7 @@
samples = psnr.samples[0];
// TODO(yaowu): unify these two versions into one.
- if (cm->seq_params.use_highbitdepth)
+ if (cm->seq_params->use_highbitdepth)
aom_highbd_calc_ssim(orig, recon, weight, bit_depth, in_bit_depth,
frame_ssim2);
else
@@ -3670,7 +3671,7 @@
#endif
}
if (cpi->b_calculate_blockiness) {
- if (!cm->seq_params.use_highbitdepth) {
+ if (!cm->seq_params->use_highbitdepth) {
const double frame_blockiness =
av1_get_blockiness(orig->y_buffer, orig->y_stride, recon->y_buffer,
recon->y_stride, orig->y_width, orig->y_height);
@@ -3679,7 +3680,7 @@
}
if (cpi->b_calculate_consistency) {
- if (!cm->seq_params.use_highbitdepth) {
+ if (!cm->seq_params->use_highbitdepth) {
const double this_inconsistency = aom_get_ssim_metrics(
orig->y_buffer, orig->y_stride, recon->y_buffer, recon->y_stride,
orig->y_width, orig->y_height, cpi->ssim_vars, &cpi->metrics, 1);
@@ -3841,8 +3842,8 @@
*dest = cm->cur_frame->buf;
dest->y_width = cm->width;
dest->y_height = cm->height;
- dest->uv_width = cm->width >> cm->seq_params.subsampling_x;
- dest->uv_height = cm->height >> cm->seq_params.subsampling_y;
+ dest->uv_width = cm->width >> cm->seq_params->subsampling_x;
+ dest->uv_height = cm->height >> cm->seq_params->subsampling_y;
ret = 0;
} else {
ret = -1;
@@ -4069,7 +4070,7 @@
uint8_t header_buf[512] = { 0 };
const uint32_t sequence_header_size =
- av1_write_sequence_header_obu(&cpi->common.seq_params, &header_buf[0]);
+ av1_write_sequence_header_obu(cpi->common.seq_params, &header_buf[0]);
assert(sequence_header_size <= sizeof(header_buf));
if (sequence_header_size == 0) return NULL;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 2ba997c..a508f1b 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -2167,6 +2167,12 @@
* frame or ARF frame.
*/
YV12_BUFFER_CONFIG alt_ref_buffer;
+
+ /*!
+ * Elements part of the sequence header, that are applicable for all the
+ * frames in the video.
+ */
+ SequenceHeader seq_params;
} AV1_PRIMARY;
/*!
diff --git a/av1/encoder/encoder_alloc.h b/av1/encoder/encoder_alloc.h
index f1b67ec..76454ba 100644
--- a/av1/encoder/encoder_alloc.h
+++ b/av1/encoder/encoder_alloc.h
@@ -295,7 +295,7 @@
static AOM_INLINE void variance_partition_alloc(AV1_COMP *cpi) {
AV1_COMMON *const cm = &cpi->common;
- const int num_64x64_blocks = (cm->seq_params.sb_size == BLOCK_64X64) ? 1 : 4;
+ const int num_64x64_blocks = (cm->seq_params->sb_size == BLOCK_64X64) ? 1 : 4;
if (cpi->td.vt64x64) {
if (num_64x64_blocks != cpi->td.num_64x64_blocks) {
aom_free(cpi->td.vt64x64);
@@ -311,7 +311,7 @@
static AOM_INLINE void alloc_altref_frame_buffer(AV1_COMP *cpi) {
AV1_COMMON *cm = &cpi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const AV1EncoderConfig *oxcf = &cpi->oxcf;
// When lag_in_frames <= 1, alt-ref frames are not enabled. In this case,
@@ -332,7 +332,7 @@
static AOM_INLINE void alloc_util_frame_buffers(AV1_COMP *cpi) {
AV1_COMMON *const cm = &cpi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int byte_alignment = cm->features.byte_alignment;
if (aom_realloc_frame_buffer(
&cpi->last_frame_uf, cm->width, cm->height, seq_params->subsampling_x,
@@ -343,7 +343,7 @@
// The frame buffer trial_frame_rst is used during loop restoration filter
// search. Hence it is allocated only when loop restoration is used.
- const int use_restoration = cm->seq_params.enable_restoration &&
+ const int use_restoration = cm->seq_params->enable_restoration &&
!cm->features.all_lossless &&
!cm->tiles.large_scale;
if (use_restoration) {
@@ -394,8 +394,8 @@
if (aom_realloc_frame_buffer(
&cpi->scaled_source, scaled_width, scaled_height,
- cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
- cm->seq_params.use_highbitdepth, AOM_BORDER_IN_PIXELS,
+ cm->seq_params->subsampling_x, cm->seq_params->subsampling_y,
+ cm->seq_params->use_highbitdepth, AOM_BORDER_IN_PIXELS,
cm->features.byte_alignment, NULL, NULL, NULL,
cpi->oxcf.tool_cfg.enable_global_motion))
aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
@@ -403,7 +403,7 @@
assert(cpi->scaled_source.y_crop_width == scaled_width);
assert(cpi->scaled_source.y_crop_height == scaled_height);
av1_resize_and_extend_frame_nonnormative(
- cpi->unscaled_source, &cpi->scaled_source, (int)cm->seq_params.bit_depth,
+ cpi->unscaled_source, &cpi->scaled_source, (int)cm->seq_params->bit_depth,
num_planes);
return &cpi->scaled_source;
}
diff --git a/av1/encoder/encoder_utils.c b/av1/encoder/encoder_utils.c
index 329635c..54aab7c 100644
--- a/av1/encoder/encoder_utils.c
+++ b/av1/encoder/encoder_utils.c
@@ -344,7 +344,7 @@
seg->update_data = 1;
qi_delta = av1_compute_qdelta(rc, rc->avg_q, rc->avg_q * 0.875,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
av1_set_segdata(seg, 1, SEG_LVL_ALT_Q, qi_delta - 2);
av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_H, -2);
av1_set_segdata(seg, 1, SEG_LVL_ALT_LF_Y_V, -2);
@@ -578,20 +578,20 @@
}
if (tune_cfg->film_grain_test_vector) {
- cm->seq_params.film_grain_params_present = 1;
+ cm->seq_params->film_grain_params_present = 1;
if (cm->current_frame.frame_type == KEY_FRAME) {
memcpy(&cm->film_grain_params,
film_grain_test_vectors + tune_cfg->film_grain_test_vector - 1,
sizeof(cm->film_grain_params));
if (oxcf->tool_cfg.enable_monochrome)
reset_film_grain_chroma_params(&cm->film_grain_params);
- cm->film_grain_params.bit_depth = cm->seq_params.bit_depth;
- if (cm->seq_params.color_range == AOM_CR_FULL_RANGE) {
+ cm->film_grain_params.bit_depth = cm->seq_params->bit_depth;
+ if (cm->seq_params->color_range == AOM_CR_FULL_RANGE) {
cm->film_grain_params.clip_to_restricted_range = 0;
}
}
} else if (tune_cfg->film_grain_table_filename) {
- cm->seq_params.film_grain_params_present = 1;
+ cm->seq_params->film_grain_params_present = 1;
cpi->film_grain_table = aom_malloc(sizeof(*cpi->film_grain_table));
memset(cpi->film_grain_table, 0, sizeof(aom_film_grain_table_t));
@@ -599,17 +599,17 @@
aom_film_grain_table_read(cpi->film_grain_table,
tune_cfg->film_grain_table_filename, &cm->error);
} else if (tune_cfg->content == AOM_CONTENT_FILM) {
- cm->seq_params.film_grain_params_present = 1;
- cm->film_grain_params.bit_depth = cm->seq_params.bit_depth;
+ cm->seq_params->film_grain_params_present = 1;
+ cm->film_grain_params.bit_depth = cm->seq_params->bit_depth;
if (oxcf->tool_cfg.enable_monochrome)
reset_film_grain_chroma_params(&cm->film_grain_params);
- if (cm->seq_params.color_range == AOM_CR_FULL_RANGE)
+ if (cm->seq_params->color_range == AOM_CR_FULL_RANGE)
cm->film_grain_params.clip_to_restricted_range = 0;
} else {
#if CONFIG_DENOISE
- cm->seq_params.film_grain_params_present = (cpi->oxcf.noise_level > 0);
+ cm->seq_params->film_grain_params_present = (cpi->oxcf.noise_level > 0);
#else
- cm->seq_params.film_grain_params_present = 0;
+ cm->seq_params->film_grain_params_present = 0;
#endif
memset(&cm->film_grain_params, 0, sizeof(cm->film_grain_params));
}
@@ -664,8 +664,8 @@
new_fb->buf.y_crop_height != cm->height) {
if (aom_realloc_frame_buffer(
&new_fb->buf, cm->width, cm->height,
- cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
- cm->seq_params.use_highbitdepth, AOM_BORDER_IN_PIXELS,
+ cm->seq_params->subsampling_x, cm->seq_params->subsampling_y,
+ cm->seq_params->use_highbitdepth, AOM_BORDER_IN_PIXELS,
cm->features.byte_alignment, NULL, NULL, NULL, 0)) {
if (force_scaling) {
// Release the reference acquired in the get_free_fb() call above.
@@ -675,19 +675,19 @@
"Failed to allocate frame buffer");
}
#if CONFIG_AV1_HIGHBITDEPTH
- if (use_optimized_scaler && cm->seq_params.bit_depth == AOM_BITS_8)
+ if (use_optimized_scaler && cm->seq_params->bit_depth == AOM_BITS_8)
av1_resize_and_extend_frame(ref, &new_fb->buf, filter, phase,
num_planes);
else
av1_resize_and_extend_frame_nonnormative(
- ref, &new_fb->buf, (int)cm->seq_params.bit_depth, num_planes);
+ ref, &new_fb->buf, (int)cm->seq_params->bit_depth, num_planes);
#else
if (use_optimized_scaler)
av1_resize_and_extend_frame(ref, &new_fb->buf, filter, phase,
num_planes);
else
av1_resize_and_extend_frame_nonnormative(
- ref, &new_fb->buf, (int)cm->seq_params.bit_depth, num_planes);
+ ref, &new_fb->buf, (int)cm->seq_params->bit_depth, num_planes);
#endif
cpi->scaled_ref_buf[ref_frame - 1] = new_fb;
alloc_frame_mvs(cm, new_fb);
@@ -753,7 +753,7 @@
if ((cm->current_frame.frame_type == KEY_FRAME && cm->show_frame) ||
frame_is_sframe(cm)) {
if (!cpi->ppi->seq_params_locked) {
- set_sb_size(&cm->seq_params,
+ set_sb_size(cm->seq_params,
av1_select_sb_size(&cpi->oxcf, cm->width, cm->height,
cpi->svc.number_spatial_layers));
}
@@ -960,7 +960,7 @@
av1_set_speed_features_qindex_dependent(cpi, oxcf->speed);
if (q_cfg->deltaq_mode != NO_DELTA_Q || q_cfg->enable_chroma_deltaq)
av1_init_quantizer(&cpi->enc_quant_dequant_params, &cm->quant_params,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
av1_set_variance_partition_thresholds(cpi, q_for_screen_content_quick_run,
0);
@@ -1006,7 +1006,7 @@
AV1_COMMON *const cm = &cpi->common;
CurrentFrame *const current_frame = &cm->current_frame;
- if (!cm->seq_params.reduced_still_picture_hdr &&
+ if (!cm->seq_params->reduced_still_picture_hdr &&
encode_show_existing_frame(cm)) {
RefCntBuffer *const frame_to_show =
cm->ref_frame_map[cpi->existing_fb_idx_to_show];
@@ -1020,7 +1020,7 @@
}
if (!encode_show_existing_frame(cm) &&
- cm->seq_params.film_grain_params_present &&
+ cm->seq_params->film_grain_params_present &&
(cm->show_frame || cm->showable_frame)) {
// Copy the current frame's film grain params to the its corresponding
// RefCntBuffer slot.
diff --git a/av1/encoder/encoder_utils.h b/av1/encoder/encoder_utils.h
index 3bffb10..0159a38 100644
--- a/av1/encoder/encoder_utils.h
+++ b/av1/encoder/encoder_utils.h
@@ -544,8 +544,8 @@
static AOM_INLINE void highbd_set_var_fns(AV1_COMP *const cpi) {
AV1_COMMON *const cm = &cpi->common;
- if (cm->seq_params.use_highbitdepth) {
- switch (cm->seq_params.bit_depth) {
+ if (cm->seq_params->use_highbitdepth) {
+ switch (cm->seq_params->bit_depth) {
case AOM_BITS_8:
#if !CONFIG_REALTIME_ONLY
HIGHBD_BFP_WRAPPER(64, 16, 8)
@@ -850,7 +850,7 @@
default:
assert(0 &&
- "cm->seq_params.bit_depth should be AOM_BITS_8, "
+ "cm->seq_params->bit_depth should be AOM_BITS_8, "
"AOM_BITS_10 or AOM_BITS_12");
}
}
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 7b0b281..2582ba8 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -26,11 +26,11 @@
void av1_alloc_txb_buf(AV1_COMP *cpi) {
AV1_COMMON *cm = &cpi->common;
CoeffBufferPool *coeff_buf_pool = &cpi->coeff_buffer_pool;
- 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);
+ 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);
const int num_planes = av1_num_planes(cm);
- const int subsampling_x = cm->seq_params.subsampling_x;
- const int subsampling_y = cm->seq_params.subsampling_y;
+ const int subsampling_x = cm->seq_params->subsampling_x;
+ const int subsampling_y = cm->seq_params->subsampling_y;
const int chroma_max_sb_square =
MAX_SB_SQUARE >> (subsampling_x + subsampling_y);
const int num_tcoeffs =
@@ -719,7 +719,7 @@
CB_COEFF_BUFFER *av1_get_cb_coeff_buffer(const struct AV1_COMP *cpi, int mi_row,
int mi_col) {
const AV1_COMMON *const cm = &cpi->common;
- const int mib_size_log2 = cm->seq_params.mib_size_log2;
+ const int mib_size_log2 = cm->seq_params->mib_size_log2;
const int stride = (cm->mi_params.mi_cols >> mib_size_log2) + 1;
const int offset =
(mi_row >> mib_size_log2) * stride + (mi_col >> mib_size_log2);
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index ce5ce4f..820e2e75 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -53,7 +53,7 @@
static AOM_INLINE void update_delta_lf_for_row_mt(AV1_COMP *cpi) {
AV1_COMMON *cm = &cpi->common;
MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
- const int mib_size = cm->seq_params.mib_size;
+ const int mib_size = cm->seq_params->mib_size;
const int frame_lf_count =
av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
for (int row = 0; row < cm->tiles.rows; row++) {
@@ -69,7 +69,8 @@
const int idx_str = cm->mi_params.mi_stride * mi_row + mi_col;
MB_MODE_INFO **mi = cm->mi_params.mi_grid_base + idx_str;
MB_MODE_INFO *mbmi = mi[0];
- if (mbmi->skip_txfm == 1 && (mbmi->bsize == cm->seq_params.sb_size)) {
+ if (mbmi->skip_txfm == 1 &&
+ (mbmi->bsize == cm->seq_params->sb_size)) {
for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id)
mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id];
mbmi->delta_lf_from_base = xd->delta_lf_from_base;
@@ -363,7 +364,7 @@
*cur_tile_id = tile_id;
const int unit_height = mi_size_high[fp_block_size];
get_next_job(&tile_data[tile_id], current_mi_row,
- is_firstpass ? unit_height : cm->seq_params.mib_size);
+ is_firstpass ? unit_height : cm->seq_params->mib_size);
}
}
@@ -448,7 +449,7 @@
pthread_mutex_lock(enc_row_mt_mutex_);
#endif
if (!get_next_job(&cpi->tile_data[cur_tile_id], ¤t_mi_row,
- cm->seq_params.mib_size)) {
+ cm->seq_params->mib_size)) {
// No jobs are available for the current tile. Query for the status of
// other tiles and get the next job if available
switch_tile_and_get_next_job(cm, cpi->tile_data, &cur_tile_id,
@@ -483,7 +484,7 @@
av1_init_above_context(&cm->above_contexts, av1_num_planes(cm), tile_row,
&td->mb.e_mbd);
- cfl_init(&td->mb.e_mbd.cfl, &cm->seq_params);
+ cfl_init(&td->mb.e_mbd.cfl, cm->seq_params);
if (td->mb.txfm_search_info.txb_rd_records != NULL) {
av1_crc32c_calculator_init(
&td->mb.txfm_search_info.txb_rd_records->mb_rd_record.crc_calculator);
@@ -635,14 +636,14 @@
sizeof(*thread_data->td->tmp_pred_bufs[j])));
}
- const int plane_types = PLANE_TYPES >> cm->seq_params.monochrome;
+ const int plane_types = PLANE_TYPES >> cm->seq_params->monochrome;
CHECK_MEM_ERROR(cm, thread_data->td->pixel_gradient_info,
aom_malloc(sizeof(*thread_data->td->pixel_gradient_info) *
plane_types * MAX_SB_SQUARE));
if (cpi->sf.part_sf.partition_search_type == VAR_BASED_PARTITION) {
const int num_64x64_blocks =
- (cm->seq_params.sb_size == BLOCK_64X64) ? 1 : 4;
+ (cm->seq_params->sb_size == BLOCK_64X64) ? 1 : 4;
CHECK_MEM_ERROR(
cm, thread_data->td->vt64x64,
aom_malloc(sizeof(*thread_data->td->vt64x64) * num_64x64_blocks));
diff --git a/av1/encoder/firstpass.c b/av1/encoder/firstpass.c
index 8fd4dcb..bf9011b 100644
--- a/av1/encoder/firstpass.c
+++ b/av1/encoder/firstpass.c
@@ -389,7 +389,7 @@
const int qindex, FRAME_STATS *const stats) {
const AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
const int unit_scale = mi_size_wide[fp_block_size];
@@ -988,7 +988,8 @@
const int num_planes = av1_num_planes(&cpi->common);
for (int plane = 0; plane < num_planes; plane++) {
const int subsampling_xy =
- plane ? cm->seq_params.subsampling_x + cm->seq_params.subsampling_y : 0;
+ plane ? cm->seq_params->subsampling_x + cm->seq_params->subsampling_y
+ : 0;
const int sb_size = MAX_SB_SQUARE >> subsampling_xy;
CHECK_MEM_ERROR(
cm, cpi->td.mb.plane[plane].src_diff,
@@ -1016,7 +1017,7 @@
AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
CurrentFrame *const current_frame = &cm->current_frame;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
TileInfo *tile = &tile_data->tile_info;
@@ -1157,7 +1158,7 @@
AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
CurrentFrame *const current_frame = &cm->current_frame;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
const int qindex = find_fp_qindex(seq_params->bit_depth);
diff --git a/av1/encoder/global_motion_facade.c b/av1/encoder/global_motion_facade.c
index 9ad6163..01ef7b0 100644
--- a/av1/encoder/global_motion_facade.c
+++ b/av1/encoder/global_motion_facade.c
@@ -108,10 +108,10 @@
const int do_adaptive_gm_estimation = 0;
const int ref_frame_dist = get_relative_dist(
- &cm->seq_params.order_hint_info, cm->current_frame.order_hint,
+ &cm->seq_params->order_hint_info, cm->current_frame.order_hint,
cm->cur_frame->ref_order_hints[frame - LAST_FRAME]);
const GlobalMotionEstimationType gm_estimation_type =
- cm->seq_params.order_hint_info.enable_order_hint &&
+ cm->seq_params->order_hint_info.enable_order_hint &&
abs(ref_frame_dist) <= 2 && do_adaptive_gm_estimation
? GLOBAL_MOTION_DISFLOW_BASED
: GLOBAL_MOTION_FEATURE_BASED;
@@ -126,7 +126,7 @@
av1_compute_global_motion(model, src_buffer, src_width, src_height,
src_stride, src_corners, num_src_corners,
- ref_buf[frame], cpi->common.seq_params.bit_depth,
+ ref_buf[frame], cpi->common.seq_params->bit_depth,
gm_estimation_type, inliers_by_motion,
params_by_motion, RANSAC_NUM_MOTIONS);
int64_t ref_frame_error = 0;
@@ -368,7 +368,7 @@
// The source buffer is 16-bit, so we need to convert to 8 bits for the
// following code. We cache the result until the source frame is released.
gm_info->src_buffer =
- av1_downconvert_frame(source, cpi->common.seq_params.bit_depth);
+ av1_downconvert_frame(source, cpi->common.seq_params->bit_depth);
}
gm_info->segment_map_w =
diff --git a/av1/encoder/interp_search.c b/av1/encoder/interp_search.c
index df7a2f4..53429d6 100644
--- a/av1/encoder/interp_search.c
+++ b/av1/encoder/interp_search.c
@@ -178,7 +178,7 @@
mbmi->interp_filters = filter_sets[filter_idx];
const int tmp_rs =
get_switchable_rate(x, mbmi->interp_filters, switchable_ctx,
- cm->seq_params.enable_dual_filter);
+ cm->seq_params->enable_dual_filter);
int64_t min_rd = RDCOST(x->rdmult, tmp_rs, 0);
if (min_rd > *rd) {
@@ -684,7 +684,7 @@
switchable_ctx[1] = av1_get_pred_context_switchable_interp(xd, 1);
*switchable_rate =
get_switchable_rate(x, mbmi->interp_filters, switchable_ctx,
- cm->seq_params.enable_dual_filter);
+ cm->seq_params->enable_dual_filter);
// Do MC evaluation for default filter_type.
// Luma MC
@@ -748,7 +748,7 @@
restore_dst_buf(xd, *tmp_dst, num_planes);
const BUFFER_SET *dst_bufs[2] = { tmp_dst, orig_dst };
// Evaluate dual interp filters
- if (cm->seq_params.enable_dual_filter) {
+ if (cm->seq_params->enable_dual_filter) {
if (cpi->sf.interp_sf.use_fast_interpolation_filter_search) {
fast_dual_interp_filter_rd(x, cpi, tile_data, bsize, orig_dst, rd,
&rd_stats_luma, &rd_stats, switchable_rate,
diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c
index f903731..9633a74 100644
--- a/av1/encoder/intra_mode_search.c
+++ b/av1/encoder/intra_mode_search.c
@@ -673,7 +673,7 @@
const int is_chroma = 1;
const int is_intra_frame = frame_is_intra_only(cm);
prune_intra_mode_with_hog(
- x, bsize, cm->seq_params.sb_size,
+ x, bsize, cm->seq_params->sb_size,
thresh[is_intra_frame]
[sf->intra_sf.chroma_intra_pruning_with_hog - 1],
intra_search_state.directional_mode_skip_mask, is_chroma);
@@ -1040,7 +1040,7 @@
int known_rate = mode_cost;
const int intra_cost_penalty = av1_get_intra_cost_penalty(
cm->quant_params.base_qindex, cm->quant_params.y_dc_delta_q,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
if (mode != DC_PRED && mode != PAETH_PRED) known_rate += intra_cost_penalty;
known_rate += AOMMIN(mode_costs->skip_txfm_cost[skip_ctx][0],
@@ -1058,7 +1058,7 @@
!intra_search_state->dir_mode_skip_mask_ready) {
const float thresh[4] = { -1.2f, 0.0f, 0.0f, 1.2f };
const int is_chroma = 0;
- prune_intra_mode_with_hog(x, bsize, cm->seq_params.sb_size,
+ prune_intra_mode_with_hog(x, bsize, cm->seq_params->sb_size,
thresh[sf->intra_sf.intra_pruning_with_hog - 1],
intra_search_state->directional_mode_skip_mask,
is_chroma);
@@ -1212,7 +1212,7 @@
const float thresh[4] = { -1.2f, -1.2f, -0.6f, 0.4f };
const int is_chroma = 0;
prune_intra_mode_with_hog(
- x, bsize, cpi->common.seq_params.sb_size,
+ x, bsize, cpi->common.seq_params->sb_size,
thresh[cpi->sf.intra_sf.intra_pruning_with_hog - 1],
directional_mode_skip_mask, is_chroma);
}
diff --git a/av1/encoder/intra_mode_search_utils.h b/av1/encoder/intra_mode_search_utils.h
index 11c2952..0bf77ac 100644
--- a/av1/encoder/intra_mode_search_utils.h
+++ b/av1/encoder/intra_mode_search_utils.h
@@ -491,7 +491,7 @@
const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
palette_mode_cost +=
av1_palette_color_cost_y(&mbmi->palette_mode_info, color_cache,
- n_cache, cpi->common.seq_params.bit_depth);
+ n_cache, cpi->common.seq_params->bit_depth);
palette_mode_cost +=
av1_cost_color_map(x, 0, bsize, mbmi->tx_size, PALETTE_MAP);
total_rate += palette_mode_cost;
@@ -551,7 +551,7 @@
uint16_t color_cache[2 * PALETTE_MAX_SIZE];
const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
palette_mode_cost += av1_palette_color_cost_uv(
- pmi, color_cache, n_cache, cpi->common.seq_params.bit_depth);
+ pmi, color_cache, n_cache, cpi->common.seq_params->bit_depth);
palette_mode_cost +=
av1_cost_color_map(x, 1, bsize, mbmi->tx_size, PALETTE_MAP);
total_rate += palette_mode_cost;
diff --git a/av1/encoder/level.c b/av1/encoder/level.c
index 1d74c2d..974bf70 100644
--- a/av1/encoder/level.c
+++ b/av1/encoder/level.c
@@ -353,7 +353,7 @@
if (spatial_layer_dimensions_present_flag) {
assert(0 && "Spatial layer dimensions not supported yet.");
} else {
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const int max_frame_width = seq_params->max_frame_width;
const int max_frame_height = seq_params->max_frame_height;
luma_samples = max_frame_width * max_frame_height;
@@ -473,7 +473,7 @@
decoder_model->level = level;
const AV1_COMMON *const cm = &cpi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
decoder_model->bit_rate = get_max_bitrate(
av1_level_defs + level, seq_params->tier[op_index], seq_params->profile);
@@ -1075,7 +1075,7 @@
const int temporal_layer_id = cm->temporal_layer_id;
const int spatial_layer_id = cm->spatial_layer_id;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
const BITSTREAM_PROFILE profile = seq_params->profile;
const int is_still_picture = seq_params->still_picture;
// update level_stats
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index f4ab6c3..a608702 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -1833,7 +1833,7 @@
const MV dv = { GET_MV_SUBPEL(ref_block_hash.y - y_pos),
GET_MV_SUBPEL(ref_block_hash.x - x_pos) };
if (!av1_is_dv_valid(dv, &cpi->common, xd, mi_row, mi_col, bsize,
- cpi->common.seq_params.mib_size_log2))
+ cpi->common.seq_params->mib_size_log2))
continue;
FULLPEL_MV hash_mv;
diff --git a/av1/encoder/motion_search_facade.c b/av1/encoder/motion_search_facade.c
index a59b58a..e6a67a0 100644
--- a/av1/encoder/motion_search_facade.c
+++ b/av1/encoder/motion_search_facade.c
@@ -69,8 +69,8 @@
const int nh = mi_size_high[bsize] / tplh;
if (nw >= 1 && nh >= 1) {
- const int of_h = mi_row % mi_size_high[cm->seq_params.sb_size];
- const int of_w = mi_col % mi_size_wide[cm->seq_params.sb_size];
+ const int of_h = mi_row % mi_size_high[cm->seq_params->sb_size];
+ const int of_w = mi_col % mi_size_wide[cm->seq_params->sb_size];
const int start = of_h / tplh * sb_enc->tpl_stride + of_w / tplw;
int valid = 1;
diff --git a/av1/encoder/mv_prec.c b/av1/encoder/mv_prec.c
index cc81d72..1b23550 100644
--- a/av1/encoder/mv_prec.c
+++ b/av1/encoder/mv_prec.c
@@ -230,7 +230,7 @@
const int y_stride = cpi->source->y_stride;
const int px_row = 4 * mi_row, px_col = 4 * mi_col;
const int buf_is_hbd = cpi->source->flags & YV12_FLAG_HIGHBITDEPTH;
- const int bd = cm->seq_params.bit_depth;
+ const int bd = cm->seq_params->bit_depth;
if (buf_is_hbd) {
uint16_t *source_buf =
CONVERT_TO_SHORTPTR(cpi->source->y_buffer) + px_row * y_stride + px_col;
@@ -339,8 +339,8 @@
const int mi_row_end = tile_info->mi_row_end;
const int mi_col_start = tile_info->mi_col_start;
const int mi_col_end = tile_info->mi_col_end;
- const int sb_size_mi = cm->seq_params.mib_size;
- BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const int sb_size_mi = cm->seq_params->mib_size;
+ BLOCK_SIZE sb_size = cm->seq_params->sb_size;
for (int mi_row = mi_row_start; mi_row < mi_row_end; mi_row += sb_size_mi) {
for (int mi_col = mi_col_start; mi_col < mi_col_end; mi_col += sb_size_mi) {
collect_mv_stats_sb(mv_stats, cpi, mi_row, mi_col, sb_size);
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c
index 136fb51..283a09d 100644
--- a/av1/encoder/nonrd_pickmode.c
+++ b/av1/encoder/nonrd_pickmode.c
@@ -1562,7 +1562,7 @@
else
model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rd_stats[i], 1);
pf_rd_stats[i].rate += av1_get_switchable_rate(
- x, xd, cm->features.interp_filter, cm->seq_params.enable_dual_filter);
+ x, xd, cm->features.interp_filter, cm->seq_params->enable_dual_filter);
cost = RDCOST(x->rdmult, pf_rd_stats[i].rate, pf_rd_stats[i].dist);
pf_tx_size[i] = mi->tx_size;
if (cost < best_cost) {
@@ -1618,7 +1618,7 @@
static void compute_intra_yprediction(const AV1_COMMON *cm,
PREDICTION_MODE mode, BLOCK_SIZE bsize,
MACROBLOCK *x, MACROBLOCKD *xd) {
- const SequenceHeader *seq_params = &cm->seq_params;
+ const SequenceHeader *seq_params = cm->seq_params;
struct macroblockd_plane *const pd = &xd->plane[0];
struct macroblock_plane *const p = &x->plane[0];
uint8_t *const src_buf_base = p->src.buf;
@@ -1738,7 +1738,7 @@
int *force_skip_low_temp_var) {
AV1_COMMON *const cm = &cpi->common;
const struct segmentation *const seg = &cm->seg;
- const int is_small_sb = (cm->seq_params.sb_size == BLOCK_64X64);
+ const int is_small_sb = (cm->seq_params->sb_size == BLOCK_64X64);
// For SVC the usage of alt_ref is determined by the ref_frame_flags.
int use_alt_ref_frame = cpi->use_svc || cpi->sf.rt_sf.use_nonrd_altref_frame;
@@ -1836,7 +1836,7 @@
int intra_cost_penalty = av1_get_intra_cost_penalty(
quant_params->base_qindex, quant_params->y_dc_delta_q,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
int64_t inter_mode_thresh = RDCOST(x->rdmult, intra_cost_penalty, 0);
int perform_intra_pred = cpi->sf.rt_sf.check_intra_pred_nonrd;
// For spatial enhancemanent layer: turn off intra prediction if the
@@ -2108,7 +2108,7 @@
DECLARE_ALIGNED(16, uint8_t, pred_buf[3 * 128 * 128]);
PRED_BUFFER *this_mode_pred = NULL;
const int reuse_inter_pred = cpi->sf.rt_sf.reuse_inter_pred_nonrd &&
- cm->seq_params.bit_depth == AOM_BITS_8;
+ cm->seq_params->bit_depth == AOM_BITS_8;
const int bh = block_size_high[bsize];
const int bw = block_size_wide[bsize];
@@ -2214,7 +2214,7 @@
const int use_model_yrd_large =
cpi->oxcf.rc_cfg.mode == AOM_CBR && large_block &&
!cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id) &&
- quant_params->base_qindex && cm->seq_params.bit_depth == 8;
+ quant_params->base_qindex && cm->seq_params->bit_depth == 8;
const int enable_filter_search =
is_filter_search_enabled(cpi, mi_row, mi_col, bsize);
diff --git a/av1/encoder/palette.c b/av1/encoder/palette.c
index fd579b7..d1380c7 100644
--- a/av1/encoder/palette.c
+++ b/av1/encoder/palette.c
@@ -223,7 +223,7 @@
int *beat_best_rd, PICK_MODE_CONTEXT *ctx, uint8_t *blk_skip,
uint8_t *tx_type_map, int *beat_best_palette_rd) {
optimize_palette_colors(color_cache, n_cache, n, 1, centroids,
- cpi->common.seq_params.bit_depth);
+ cpi->common.seq_params->bit_depth);
const int num_unique_colors = av1_remove_duplicates(centroids, n);
if (num_unique_colors < PALETTE_MIN_SIZE) {
// Too few unique colors to create a palette. And DC_PRED will work
@@ -231,10 +231,10 @@
return;
}
PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
for (int i = 0; i < num_unique_colors; ++i) {
pmi->palette_colors[i] = clip_pixel_highbd(
- (int)centroids[i], cpi->common.seq_params.bit_depth);
+ (int)centroids[i], cpi->common.seq_params->bit_depth);
}
} else {
for (int i = 0; i < num_unique_colors; ++i) {
@@ -450,7 +450,7 @@
int block_width, block_height, rows, cols;
av1_get_block_dimensions(bsize, 0, xd, &block_width, &block_height, &rows,
&cols);
- const SequenceHeader *const seq_params = &cpi->common.seq_params;
+ const SequenceHeader *const seq_params = cpi->common.seq_params;
const int is_hbd = seq_params->use_highbitdepth;
const int bit_depth = seq_params->bit_depth;
int unused;
@@ -645,7 +645,7 @@
mbmi->bsize));
PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
const BLOCK_SIZE bsize = mbmi->bsize;
- const SequenceHeader *const seq_params = &cpi->common.seq_params;
+ const SequenceHeader *const seq_params = cpi->common.seq_params;
int this_rate;
int64_t this_rd;
int colors_u, colors_v, colors;
@@ -737,7 +737,7 @@
}
av1_k_means(data, centroids, color_map, rows * cols, n, 2, max_itr);
optimize_palette_colors(color_cache, n_cache, n, 2, centroids,
- cpi->common.seq_params.bit_depth);
+ cpi->common.seq_params->bit_depth);
// Sort the U channel colors in ascending order.
for (i = 0; i < 2 * (n - 1); i += 2) {
int min_idx = i;
@@ -811,7 +811,7 @@
for (r = 0; r < rows; ++r) {
for (c = 0; c < cols; ++c) {
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
data[(r * cols + c) * 2] = src_u16[r * src_stride + c];
data[(r * cols + c) * 2 + 1] = src_v16[r * src_stride + c];
} else {
diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c
index 3cb5d49..c96db5b 100644
--- a/av1/encoder/partition_search.c
+++ b/av1/encoder/partition_search.c
@@ -322,7 +322,7 @@
xd->block_ref_scale_factors[ref], num_planes);
}
const int start_plane = (cpi->sf.rt_sf.reuse_inter_pred_nonrd &&
- cm->seq_params.bit_depth == AOM_BITS_8)
+ cm->seq_params->bit_depth == AOM_BITS_8)
? 1
: 0;
av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize,
@@ -791,11 +791,11 @@
#if CONFIG_ENTROPY_STATS
// delta quant applies to both intra and inter
const int super_block_upper_left =
- ((xd->mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
- ((xd->mi_col & (cm->seq_params.mib_size - 1)) == 0);
+ ((xd->mi_row & (cm->seq_params->mib_size - 1)) == 0) &&
+ ((xd->mi_col & (cm->seq_params->mib_size - 1)) == 0);
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
if (delta_q_info->delta_q_present_flag &&
- (bsize != cm->seq_params.sb_size || !mbmi->skip_txfm) &&
+ (bsize != cm->seq_params->sb_size || !mbmi->skip_txfm) &&
super_block_upper_left) {
const int dq = (mbmi->current_qindex - xd->current_base_qindex) /
delta_q_info->delta_q_res;
@@ -994,7 +994,7 @@
}
}
- if (cm->seq_params.enable_interintra_compound &&
+ if (cm->seq_params->enable_interintra_compound &&
is_interintra_allowed(mbmi)) {
const int bsize_group = size_group_lookup[bsize];
if (mbmi->ref_frame[1] == INTRA_FRAME) {
@@ -1055,7 +1055,7 @@
mbmi->motion_mode == SIMPLE_TRANSLATION);
const int masked_compound_used = is_any_masked_compound_used(bsize) &&
- cm->seq_params.enable_masked_compound;
+ cm->seq_params->enable_masked_compound;
if (masked_compound_used) {
const int comp_group_idx_ctx = get_comp_group_idx_context(xd);
#if CONFIG_ENTROPY_STATS
@@ -1100,7 +1100,7 @@
if (inter_block && cm->features.interp_filter == SWITCHABLE &&
mbmi->motion_mode != WARPED_CAUSAL &&
!is_nontrans_global_motion(xd, mbmi)) {
- update_filter_type_cdf(xd, mbmi, cm->seq_params.enable_dual_filter);
+ update_filter_type_cdf(xd, mbmi, cm->seq_params->enable_dual_filter);
}
if (inter_block &&
!segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
@@ -1207,8 +1207,8 @@
TileInfo *const tile = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *xd = &x->e_mbd;
- const int subsampling_x = cm->seq_params.subsampling_x;
- const int subsampling_y = cm->seq_params.subsampling_y;
+ const int subsampling_x = cm->seq_params->subsampling_x;
+ const int subsampling_y = cm->seq_params->subsampling_y;
av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize);
const int origin_mult = x->rdmult;
@@ -1221,9 +1221,9 @@
set_cb_offsets(x->mbmi_ext_frame->cb_offset, x->cb_offset[PLANE_TYPE_Y],
x->cb_offset[PLANE_TYPE_UV]);
assert(x->cb_offset[PLANE_TYPE_Y] <
- (1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]));
+ (1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size]));
assert(x->cb_offset[PLANE_TYPE_UV] <
- ((1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]) >>
+ ((1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size]) >>
(subsampling_x + subsampling_y)));
}
@@ -1231,7 +1231,7 @@
if (!dry_run) {
update_cb_offsets(x, bsize, subsampling_x, subsampling_y);
- if (bsize == cpi->common.seq_params.sb_size && mbmi->skip_txfm == 1 &&
+ if (bsize == cpi->common.seq_params->sb_size && mbmi->skip_txfm == 1 &&
cm->delta_q_info.delta_lf_present_flag) {
const int frame_lf_count =
av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;
@@ -1249,11 +1249,11 @@
// delta quant applies to both intra and inter
const int super_block_upper_left =
- ((mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
- ((mi_col & (cm->seq_params.mib_size - 1)) == 0);
+ ((mi_row & (cm->seq_params->mib_size - 1)) == 0) &&
+ ((mi_col & (cm->seq_params->mib_size - 1)) == 0);
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
if (delta_q_info->delta_q_present_flag &&
- (bsize != cm->seq_params.sb_size || !mbmi->skip_txfm) &&
+ (bsize != cm->seq_params->sb_size || !mbmi->skip_txfm) &&
super_block_upper_left) {
xd->current_base_qindex = mbmi->current_qindex;
if (delta_q_info->delta_lf_present_flag) {
@@ -1800,11 +1800,11 @@
// We must have chosen a partitioning and encoding or we'll fail later on.
// No other opportunities for success.
- if (bsize == cm->seq_params.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->seq_params.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,
@@ -1839,15 +1839,15 @@
// Nonrd pickmode does not currently support second/combined reference.
assert(!has_second_ref(mbmi));
av1_update_state(cpi, td, ctx, mi_row, mi_col, bsize, dry_run);
- const int subsampling_x = cpi->common.seq_params.subsampling_x;
- const int subsampling_y = cpi->common.seq_params.subsampling_y;
+ const int subsampling_x = cpi->common.seq_params->subsampling_x;
+ const int subsampling_y = cpi->common.seq_params->subsampling_y;
if (!dry_run) {
set_cb_offsets(x->mbmi_ext_frame->cb_offset, x->cb_offset[PLANE_TYPE_Y],
x->cb_offset[PLANE_TYPE_UV]);
assert(x->cb_offset[PLANE_TYPE_Y] <
- (1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]));
+ (1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size]));
assert(x->cb_offset[PLANE_TYPE_UV] <
- ((1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]) >>
+ ((1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size]) >>
(subsampling_x + subsampling_y)));
}
encode_superblock(cpi, tile_data, td, tp, dry_run, bsize, rate);
@@ -1936,8 +1936,8 @@
int i;
wait_for_top_right_sb(&cpi->mt_info.enc_row_mt, &tile_data->row_mt_sync,
- &tile_data->tile_info, cm->seq_params.sb_size,
- cm->seq_params.mib_size_log2, bsize, mi_row, mi_col);
+ &tile_data->tile_info, cm->seq_params->sb_size,
+ cm->seq_params->mib_size_log2, bsize, mi_row, mi_col);
#if CONFIG_COLLECT_COMPONENT_TIMING
start_timing(cpi, rd_pick_sb_modes_time);
@@ -3452,7 +3452,7 @@
if (cpi->sf.inter_sf.prune_ref_frame_for_rect_partitions) {
const int ref_type = av1_ref_frame_type(pc_tree->none->mic.ref_frame);
av1_update_picked_ref_frames_mask(
- x, ref_type, bsize, cm->seq_params.mib_size, mi_row, mi_col);
+ x, ref_type, bsize, cm->seq_params->mib_size, mi_row, mi_col);
}
// Calculate the total cost and update the best partition.
@@ -3749,7 +3749,7 @@
int num_nodes;
int num_configs;
fscanf(pfile, "%d,%d,%d", &read_bsize, &num_nodes, &num_configs);
- assert(read_bsize == cpi->common.seq_params.sb_size);
+ assert(read_bsize == cpi->common.seq_params->sb_size);
BLOCK_SIZE bsize = (BLOCK_SIZE)read_bsize;
PC_TREE *tree_node_queue[1024] = { NULL };
@@ -3904,7 +3904,7 @@
// Note: it is necessary to restore context information.
av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes);
- if (bsize != cm->seq_params.sb_size) {
+ if (bsize != cm->seq_params->sb_size) {
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
pc_tree, NULL);
}
@@ -4032,7 +4032,7 @@
av1_invalid_rd_stats(rd_cost);
return part_search_state.found_best_partition;
}
- if (bsize == cm->seq_params.sb_size) x->must_find_valid_partition = 0;
+ if (bsize == cm->seq_params->sb_size) x->must_find_valid_partition = 0;
// Override skipping rectangular partition operations for edge blocks.
if (none_rd) *none_rd = 0;
@@ -4157,7 +4157,7 @@
// when NONE and SPLIT partition rd_costs are INT64_MAX.
if (cpi->sf.part_sf.early_term_after_none_split &&
part_none_rd == INT64_MAX && part_split_rd == INT64_MAX &&
- !x->must_find_valid_partition && (bsize != cm->seq_params.sb_size)) {
+ !x->must_find_valid_partition && (bsize != cm->seq_params->sb_size)) {
part_search_state.terminate_partition_search = 1;
}
@@ -4248,7 +4248,7 @@
end_timing(cpi, rd_pick_4partition_time);
#endif
- if (bsize == cm->seq_params.sb_size &&
+ if (bsize == cm->seq_params->sb_size &&
!part_search_state.found_best_partition) {
// Did not find a valid partition, go back and search again, with less
// constraint on which partition types to search.
@@ -4297,7 +4297,7 @@
// If a valid partition is found and reconstruction is required for future
// sub-blocks in the same group.
if (part_search_state.found_best_partition && pc_tree->index != 3) {
- if (bsize == cm->seq_params.sb_size) {
+ if (bsize == cm->seq_params->sb_size) {
// Encode the superblock.
const int emit_output = multi_pass_mode != SB_DRY_PASS;
const RUN_TYPE run_type = emit_output ? OUTPUT_ENABLED : DRY_RUN_NORMAL;
@@ -4326,7 +4326,7 @@
if (pc_tree_dealloc == 0)
av1_free_pc_tree_recursive(pc_tree, num_planes, 1, 1);
- if (bsize == cm->seq_params.sb_size) {
+ if (bsize == cm->seq_params->sb_size) {
assert(best_rdc.rate < INT_MAX);
assert(best_rdc.dist < INT64_MAX);
} else {
@@ -4377,7 +4377,7 @@
const float thresh = cpi->oxcf.speed <= 5 ? 1.25f : 0.0f;
float features[FEATURES] = { 0.0f };
const int dc_q = av1_dc_quant_QTX(cm->quant_params.base_qindex, 0,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
int feature_idx = 0;
float score[LABELS];
@@ -4457,7 +4457,7 @@
{
const int dc_q = av1_dc_quant_QTX(cm->quant_params.base_qindex, 0,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
int feature_idx = 0;
features[feature_idx++] = logf((float)(dc_q * dc_q) / 256.0f + 1.0f);
@@ -4605,7 +4605,7 @@
int partition_none_allowed = !force_horz_split && !force_vert_split;
assert(mi_size_wide[bsize] == mi_size_high[bsize]); // Square partition only
- assert(cm->seq_params.sb_size == BLOCK_64X64); // Small SB so far
+ assert(cm->seq_params->sb_size == BLOCK_64X64); // Small SB so far
(void)*tp_orig;
@@ -4712,7 +4712,7 @@
fill_mode_info_sb(cpi, x, mi_row, mi_col, bsize, pc_tree);
if (do_recon) {
- if (bsize == cm->seq_params.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,
diff --git a/av1/encoder/partition_strategy.c b/av1/encoder/partition_strategy.c
index 0f0da7e..9fea0ad 100644
--- a/av1/encoder/partition_strategy.c
+++ b/av1/encoder/partition_strategy.c
@@ -61,7 +61,7 @@
int *partition_vert_allowed,
int *do_rectangular_split,
int *do_square_split) {
- assert(cm->seq_params.sb_size >= BLOCK_64X64 &&
+ assert(cm->seq_params->sb_size >= BLOCK_64X64 &&
"Invalid sb_size for intra_cnn!");
const int bsize_idx = convert_bsize_to_idx(bsize);
@@ -636,7 +636,7 @@
float *features) {
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *xd = &x->e_mbd;
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
// Currently this only allows 128X128 SB size. May extend it to 64X64 SB size.
assert(sb_size == BLOCK_128X128);
@@ -782,7 +782,7 @@
}
} else if (cpi->sf.part_sf.auto_max_partition_based_on_simple_motion ==
ADAPT_PRED) {
- const BLOCK_SIZE sb_size = cpi->common.seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cpi->common.seq_params->sb_size;
const MACROBLOCKD *const xd = &x->e_mbd;
// TODO(debargha): x->source_variance is unavailable at this point,
// so compute. The redundant recomputation later can be removed.
@@ -1380,7 +1380,7 @@
const int try_intra_cnn_split =
!cpi->use_screen_content_tools && frame_is_intra_only(cm) &&
cpi->sf.part_sf.intra_cnn_split &&
- cm->seq_params.sb_size >= BLOCK_64X64 && bsize <= BLOCK_64X64 &&
+ cm->seq_params->sb_size >= BLOCK_64X64 && bsize <= BLOCK_64X64 &&
bsize >= BLOCK_8X8 &&
mi_row + mi_size_high[bsize] <= mi_params->mi_rows &&
mi_col + mi_size_wide[bsize] <= mi_params->mi_cols;
diff --git a/av1/encoder/pass2_strategy.c b/av1/encoder/pass2_strategy.c
index f6d25ad..9752c65 100644
--- a/av1/encoder/pass2_strategy.c
+++ b/av1/encoder/pass2_strategy.c
@@ -302,7 +302,7 @@
// Try and pick a max Q that will be high enough to encode the
// content at the given rate.
int q = find_qindex_by_rate_with_correction(
- target_norm_bits_per_mb, cpi->common.seq_params.bit_depth,
+ target_norm_bits_per_mb, cpi->common.seq_params->bit_depth,
av_err_per_mb, cpi->ppi->twopass.bpm_factor, rate_err_tol,
rc->best_quality, rc->worst_quality);
@@ -837,7 +837,7 @@
int64_t group_bits,
int frame_type) {
const AV1_COMMON *const cm = &cpi->common;
- const SequenceHeader *const seq_params = &cm->seq_params;
+ const SequenceHeader *const seq_params = cm->seq_params;
PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;
const int temporal_layer_id = cm->temporal_layer_id;
const int spatial_layer_id = cm->spatial_layer_id;
@@ -3415,7 +3415,7 @@
rc->active_worst_quality = tmp_q;
rc->ni_av_qi = tmp_q;
rc->last_q[INTER_FRAME] = tmp_q;
- rc->avg_q = av1_convert_qindex_to_q(tmp_q, cm->seq_params.bit_depth);
+ rc->avg_q = av1_convert_qindex_to_q(tmp_q, cm->seq_params->bit_depth);
rc->avg_frame_qindex[INTER_FRAME] = tmp_q;
rc->last_q[KEY_FRAME] = (tmp_q + cpi->oxcf.rc_cfg.best_allowed_q) / 2;
rc->avg_frame_qindex[KEY_FRAME] = rc->last_q[KEY_FRAME];
@@ -4013,9 +4013,9 @@
(double)twopass->rolling_arf_group_target_bits,
twopass->bpm_factor,
av1_convert_qindex_to_q(cpi->common.quant_params.base_qindex,
- cm->seq_params.bit_depth),
+ cm->seq_params->bit_depth),
av1_convert_qindex_to_q(rc->active_worst_quality,
- cm->seq_params.bit_depth));
+ cm->seq_params->bit_depth));
fclose(fpfile);
}
#endif
diff --git a/av1/encoder/pickcdef.c b/av1/encoder/pickcdef.c
index 55e466d..7448312 100644
--- a/av1/encoder/pickcdef.c
+++ b/av1/encoder/pickcdef.c
@@ -454,13 +454,13 @@
(mi_params->mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
cdef_search_ctx->nhfb =
(mi_params->mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
- cdef_search_ctx->coeff_shift = AOMMAX(cm->seq_params.bit_depth - 8, 0);
+ cdef_search_ctx->coeff_shift = AOMMAX(cm->seq_params->bit_depth - 8, 0);
cdef_search_ctx->damping = 3 + (cm->quant_params.base_qindex >> 6);
cdef_search_ctx->total_strengths = nb_cdef_strengths[pick_method];
cdef_search_ctx->num_planes = num_planes;
cdef_search_ctx->pick_method = pick_method;
cdef_search_ctx->sb_count = 0;
- av1_setup_dst_planes(xd->plane, cm->seq_params.sb_size, frame, 0, 0, 0,
+ av1_setup_dst_planes(xd->plane, cm->seq_params->sb_size, frame, 0, 0, 0,
num_planes);
// Initialize plane wise information.
for (int pli = 0; pli < num_planes; pli++) {
@@ -478,7 +478,7 @@
}
// Function pointer initialization.
#if CONFIG_AV1_HIGHBITDEPTH
- if (cm->seq_params.use_highbitdepth) {
+ if (cm->seq_params->use_highbitdepth) {
cdef_search_ctx->copy_fn = copy_sb16_16_highbd;
cdef_search_ctx->compute_cdef_dist_fn = compute_cdef_dist_highbd;
} else {
@@ -492,7 +492,7 @@
}
static void pick_cdef_from_qp(AV1_COMMON *const cm) {
- const int bd = cm->seq_params.bit_depth;
+ const int bd = cm->seq_params->bit_depth;
const int q =
av1_ac_quant_QTX(cm->quant_params.base_qindex, 0, bd) >> (bd - 8);
CdefInfo *const cdef_info = &cm->cdef_info;
diff --git a/av1/encoder/picklpf.c b/av1/encoder/picklpf.c
index 30ce10f..f2168c4 100644
--- a/av1/encoder/picklpf.c
+++ b/av1/encoder/picklpf.c
@@ -87,7 +87,7 @@
plane, plane + 1, partial_frame);
filt_err = aom_get_sse_plane(sd, &cm->cur_frame->buf, plane,
- cm->seq_params.use_highbitdepth);
+ cm->seq_params->use_highbitdepth);
// Re-instate the unfiltered frame
yv12_copy_plane(&cpi->last_frame_uf, &cm->cur_frame->buf, plane);
@@ -205,7 +205,7 @@
if (best_cost_ret)
*best_cost_ret = RDCOST_DBL_WITH_NATIVE_BD_DIST(
- x->rdmult, 0, (best_err << 4), cm->seq_params.bit_depth);
+ x->rdmult, 0, (best_err << 4), cm->seq_params->bit_depth);
return filt_best;
}
@@ -226,7 +226,7 @@
const int min_filter_level = 0;
const int max_filter_level = av1_get_max_filter_level(cpi);
const int q = av1_ac_quant_QTX(cm->quant_params.base_qindex, 0,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
// based on tests result for rtc test set
// 0.04590 boosted or 0.02295 non-booseted in 18-bit fixed point
const int strength_boost_q_treshold = 0;
@@ -244,7 +244,7 @@
// And high bit depth separately:
// filt_guess = q * 0.316206 + 3.87252
int filt_guess;
- switch (cm->seq_params.bit_depth) {
+ switch (cm->seq_params->bit_depth) {
case AOM_BITS_8:
filt_guess =
(cm->current_frame.frame_type == KEY_FRAME)
@@ -263,7 +263,7 @@
"or AOM_BITS_12");
return;
}
- if (cm->seq_params.bit_depth != AOM_BITS_8 &&
+ if (cm->seq_params->bit_depth != AOM_BITS_8 &&
cm->current_frame.frame_type == KEY_FRAME)
filt_guess -= 4;
// TODO(chengchen): retrain the model for Y, U, V filter levels
diff --git a/av1/encoder/pickrst.c b/av1/encoder/pickrst.c
index 2196513..2c12cb0 100644
--- a/av1/encoder/pickrst.c
+++ b/av1/encoder/pickrst.c
@@ -199,8 +199,8 @@
const int is_uv = plane > 0;
const RestorationInfo *rsi = &cm->rst_info[plane];
RestorationLineBuffers rlbs;
- const int bit_depth = cm->seq_params.bit_depth;
- const int highbd = cm->seq_params.use_highbitdepth;
+ const int bit_depth = cm->seq_params->bit_depth;
+ const int highbd = cm->seq_params->use_highbitdepth;
const YV12_BUFFER_CONFIG *fts = &cm->cur_frame->buf;
// TODO(yunqing): For now, only use optimized LR filter in decoder. Can be
@@ -209,8 +209,8 @@
av1_loop_restoration_filter_unit(
limits, rui, &rsi->boundaries, &rlbs, tile_rect, rsc->tile_stripe0,
- is_uv && cm->seq_params.subsampling_x,
- is_uv && cm->seq_params.subsampling_y, highbd, bit_depth,
+ is_uv && cm->seq_params->subsampling_x,
+ is_uv && cm->seq_params->subsampling_y, highbd, bit_depth,
fts->buffers[plane], fts->strides[is_uv], rsc->dst->buffers[plane],
rsc->dst->strides[is_uv], cm->rst_tmpbuf, optimized_lr);
@@ -886,8 +886,8 @@
const MACROBLOCK *const x = rsc->x;
const AV1_COMMON *const cm = rsc->cm;
- const int highbd = cm->seq_params.use_highbitdepth;
- const int bit_depth = cm->seq_params.bit_depth;
+ const int highbd = cm->seq_params->use_highbitdepth;
+ const int bit_depth = cm->seq_params->bit_depth;
const int64_t bits_none = x->mode_costs.sgrproj_restore_cost[0];
// Prune evaluation of RESTORE_SGRPROJ if 'skip_sgr_eval' is set
@@ -905,8 +905,8 @@
rsc->src_buffer + limits->v_start * rsc->src_stride + limits->h_start;
const int is_uv = rsc->plane > 0;
- const int ss_x = is_uv && cm->seq_params.subsampling_x;
- const int ss_y = is_uv && cm->seq_params.subsampling_y;
+ const int ss_x = is_uv && cm->seq_params->subsampling_x;
+ const int ss_y = is_uv && cm->seq_params->subsampling_y;
const int procunit_width = RESTORATION_PROC_UNIT_SIZE >> ss_x;
const int procunit_height = RESTORATION_PROC_UNIT_SIZE >> ss_y;
@@ -1474,12 +1474,12 @@
const int scale[3] = { 0, 1, 2 };
// Obtain the normalized Qscale
const int qs = av1_dc_quant_QTX(rsc->cm->quant_params.base_qindex, 0,
- rsc->cm->seq_params.bit_depth) >>
+ rsc->cm->seq_params->bit_depth) >>
3;
// Derive threshold as sqr(normalized Qscale) * scale / 16,
const uint64_t thresh =
(qs * qs * scale[rsc->lpf_sf->prune_wiener_based_on_src_var]) >> 4;
- const int highbd = rsc->cm->seq_params.use_highbitdepth;
+ const int highbd = rsc->cm->seq_params->use_highbitdepth;
const uint64_t src_var =
var_restoration_unit(limits, rsc->src, rsc->plane, highbd);
// Do not perform Wiener search if source variance is lower than threshold
@@ -1510,11 +1510,11 @@
#if CONFIG_AV1_HIGHBITDEPTH
const AV1_COMMON *const cm = rsc->cm;
- if (cm->seq_params.use_highbitdepth) {
+ if (cm->seq_params->use_highbitdepth) {
av1_compute_stats_highbd(reduced_wiener_win, rsc->dgd_buffer,
rsc->src_buffer, limits->h_start, limits->h_end,
limits->v_start, limits->v_end, rsc->dgd_stride,
- rsc->src_stride, M, H, cm->seq_params.bit_depth);
+ rsc->src_stride, M, H, cm->seq_params->bit_depth);
} else {
av1_compute_stats(reduced_wiener_win, rsc->dgd_buffer, rsc->src_buffer,
limits->h_start, limits->h_end, limits->v_start,
@@ -1567,10 +1567,10 @@
double cost_none = RDCOST_DBL_WITH_NATIVE_BD_DIST(
x->rdmult, bits_none >> 4, rusi->sse[RESTORE_NONE],
- rsc->cm->seq_params.bit_depth);
+ rsc->cm->seq_params->bit_depth);
double cost_wiener = RDCOST_DBL_WITH_NATIVE_BD_DIST(
x->rdmult, bits_wiener >> 4, rusi->sse[RESTORE_WIENER],
- rsc->cm->seq_params.bit_depth);
+ rsc->cm->seq_params->bit_depth);
RestorationType rtype =
(cost_wiener < cost_none) ? RESTORE_WIENER : RESTORE_NONE;
@@ -1601,7 +1601,7 @@
RestSearchCtxt *rsc = (RestSearchCtxt *)priv;
RestUnitSearchInfo *rusi = &rsc->rusi[rest_unit_idx];
- const int highbd = rsc->cm->seq_params.use_highbitdepth;
+ const int highbd = rsc->cm->seq_params->use_highbitdepth;
rusi->sse[RESTORE_NONE] = sse_restoration_unit(
limits, rsc->src, &rsc->cm->cur_frame->buf, rsc->plane, highbd);
@@ -1653,8 +1653,8 @@
}
const int64_t coeff_bits = coeff_pcost << AV1_PROB_COST_SHIFT;
const int64_t bits = x->mode_costs.switchable_restore_cost[r] + coeff_bits;
- double cost = RDCOST_DBL_WITH_NATIVE_BD_DIST(x->rdmult, bits >> 4, sse,
- rsc->cm->seq_params.bit_depth);
+ double cost = RDCOST_DBL_WITH_NATIVE_BD_DIST(
+ x->rdmult, bits >> 4, sse, rsc->cm->seq_params->bit_depth);
if (r == RESTORE_SGRPROJ && rusi->sgrproj.ep < 10)
cost *= (1 + DUAL_SGR_PENALTY_MULT * rsc->lpf_sf->dual_sgr_penalty_level);
if (r == 0 || cost < best_cost) {
@@ -1694,7 +1694,7 @@
av1_foreach_rest_unit_in_plane(rsc->cm, rsc->plane, funs[rtype], rsc,
&rsc->tile_rect, rsc->cm->rst_tmpbuf, NULL);
return RDCOST_DBL_WITH_NATIVE_BD_DIST(
- rsc->x->rdmult, rsc->bits >> 4, rsc->sse, rsc->cm->seq_params.bit_depth);
+ rsc->x->rdmult, rsc->bits >> 4, rsc->sse, rsc->cm->seq_params->bit_depth);
}
static int rest_tiles_in_plane(const AV1_COMMON *cm, int plane) {
@@ -1740,7 +1740,7 @@
double best_cost = 0;
RestorationType best_rtype = RESTORE_NONE;
- const int highbd = rsc.cm->seq_params.use_highbitdepth;
+ const int highbd = rsc.cm->seq_params->use_highbitdepth;
if (!cpi->sf.lpf_sf.disable_loop_restoration_chroma || !plane) {
av1_extend_frame(rsc.dgd_buffer, rsc.plane_width, rsc.plane_height,
rsc.dgd_stride, RESTORATION_BORDER, RESTORATION_BORDER,
diff --git a/av1/encoder/ratectrl.c b/av1/encoder/ratectrl.c
index 347e24d..3779fff 100644
--- a/av1/encoder/ratectrl.c
+++ b/av1/encoder/ratectrl.c
@@ -429,7 +429,7 @@
// Adjust Q base on source content change from scene detection.
if (cpi->sf.rt_sf.check_scene_detection && rc->prev_avg_source_sad > 0 &&
rc->frames_since_key > 10) {
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
double delta =
(double)rc->avg_source_sad / (double)rc->prev_avg_source_sad - 1.0;
// Push Q downwards if content change is decreasing and buffer level
@@ -585,7 +585,7 @@
} else {
projected_size_based_on_q = av1_estimate_bits_at_q(
cm->current_frame.frame_type, cm->quant_params.base_qindex, MBs,
- rate_correction_factor, cm->seq_params.bit_depth,
+ rate_correction_factor, cm->seq_params->bit_depth,
cpi->is_screen_content_type);
}
// Work out a size correction factor.
@@ -641,7 +641,7 @@
return use_cyclic_refresh
? av1_cyclic_refresh_rc_bits_per_mb(cpi, q, correction_factor)
: av1_rc_bits_per_mb(cm->current_frame.frame_type, q,
- correction_factor, cm->seq_params.bit_depth,
+ correction_factor, cm->seq_params->bit_depth,
cpi->is_screen_content_type);
}
@@ -862,7 +862,7 @@
const RefreshFrameFlagsInfo *const refresh_frame_flags = &cpi->refresh_frame;
const CurrentFrame *const current_frame = &cm->current_frame;
int *rtc_minq;
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
int active_best_quality = rc->best_quality;
ASSIGN_MINQ_TABLE(bit_depth, rtc_minq);
@@ -940,7 +940,7 @@
const PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;
const CurrentFrame *const current_frame = &cm->current_frame;
int q;
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
int active_worst_quality = calc_active_worst_quality_no_stats_cbr(cpi);
int active_best_quality = calc_active_best_quality_no_stats_cbr(
cpi, active_worst_quality, width, height);
@@ -1043,7 +1043,7 @@
* \c oxcf->cq_level, or slightly modified for some
* special cases)
* \param[in] bit_depth Bit depth of the codec (same as
- * \c cm->seq_params.bit_depth)
+ * \c cm->seq_params->bit_depth)
* \return Returns selected q index to be used for encoding this frame.
*/
static int get_q_using_fixed_offsets(const AV1EncoderConfig *const oxcf,
@@ -1123,7 +1123,7 @@
const int cq_level =
get_active_cq_level(rc, oxcf, frame_is_intra_only(cm), cpi->superres_mode,
cm->superres_scale_denominator);
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
if (oxcf->q_cfg.use_fixed_qp_offsets) {
return get_q_using_fixed_offsets(oxcf, rc, gf_group, gf_index, cq_level,
@@ -1287,7 +1287,7 @@
return av1_compute_qdelta_by_rate(&cpi->rc, frame_type, q, rate_factor,
cpi->is_screen_content_type,
- cpi->common.seq_params.bit_depth);
+ cpi->common.seq_params->bit_depth);
}
// This unrestricted Q selection on CQ mode is useful when testing new features,
@@ -1302,7 +1302,7 @@
const int cq_level =
get_active_cq_level(rc, oxcf, frame_is_intra_only(cm), cpi->superres_mode,
cm->superres_scale_denominator);
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
const int q = (int)av1_convert_qindex_to_q(cq_level, bit_depth);
(void)width;
(void)height;
@@ -1326,7 +1326,7 @@
const AV1EncoderConfig *const oxcf = &cpi->oxcf;
int active_best_quality;
int active_worst_quality = *active_worst;
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
if (rc->frames_to_key <= 1 && oxcf->rc_cfg.mode == AOM_Q) {
// If the next frame is also a key frame or the current frame is the
@@ -1425,7 +1425,7 @@
const RATE_CONTROL *const rc = &cpi->rc;
const PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;
const RefreshFrameFlagsInfo *const refresh_frame_flags = &cpi->refresh_frame;
- const int bit_depth = cpi->common.seq_params.bit_depth;
+ const int bit_depth = cpi->common.seq_params->bit_depth;
int active_best_quality = *active_best;
int active_worst_quality = *active_worst;
// Extension to max or min Q if undershoot or overshoot is outside
@@ -1536,7 +1536,7 @@
const int active_worst_quality,
const int cq_level, const int gf_index) {
const AV1_COMMON *const cm = &cpi->common;
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
const RATE_CONTROL *const rc = &cpi->rc;
const PRIMARY_RATE_CONTROL *const p_rc = &cpi->ppi->p_rc;
const AV1EncoderConfig *const oxcf = &cpi->oxcf;
@@ -1627,7 +1627,7 @@
const int cq_level =
get_active_cq_level(rc, oxcf, frame_is_intra_only(cm), cpi->superres_mode,
cm->superres_scale_denominator);
- const int bit_depth = cm->seq_params.bit_depth;
+ const int bit_depth = cm->seq_params->bit_depth;
if (oxcf->q_cfg.use_fixed_qp_offsets) {
return get_q_using_fixed_offsets(oxcf, rc, gf_group, cpi->gf_frame_index,
@@ -1818,7 +1818,7 @@
rc->avg_frame_qindex[INTER_FRAME] =
ROUND_POWER_OF_TWO(3 * rc->avg_frame_qindex[INTER_FRAME] + qindex, 2);
rc->ni_frames++;
- rc->tot_q += av1_convert_qindex_to_q(qindex, cm->seq_params.bit_depth);
+ rc->tot_q += av1_convert_qindex_to_q(qindex, cm->seq_params->bit_depth);
rc->avg_q = rc->tot_q / rc->ni_frames;
// Calculate the average Q for normal inter frames (not key or GFU
// frames).
@@ -2305,9 +2305,9 @@
int num_samples = 0;
const int thresh = 6;
// SAD is computed on 64x64 blocks
- const int sb_size_by_mb = (cm->seq_params.sb_size == BLOCK_128X128)
- ? (cm->seq_params.mib_size >> 1)
- : cm->seq_params.mib_size;
+ const int sb_size_by_mb = (cm->seq_params->sb_size == BLOCK_128X128)
+ ? (cm->seq_params->mib_size >> 1)
+ : cm->seq_params->mib_size;
const int sb_cols = (num_mi_cols + sb_size_by_mb - 1) / sb_size_by_mb;
const int sb_rows = (num_mi_rows + sb_size_by_mb - 1) / sb_size_by_mb;
uint64_t sum_sq_thresh = 10000; // sum = sqrt(thresh / 64*64)) ~1.5
@@ -2731,7 +2731,7 @@
(int)(((uint64_t)target_size << BPER_MB_NORMBITS) / cm->mi_params.MBs);
// Rate correction factor based on target_bits_per_mb and qp (==max_QP).
// This comes from the inverse computation of vp9_rc_bits_per_mb().
- q2 = av1_convert_qindex_to_q(*q, cm->seq_params.bit_depth);
+ q2 = av1_convert_qindex_to_q(*q, cm->seq_params->bit_depth);
enumerator = 1800000; // Factor for inter frame.
enumerator += (int)(enumerator * q2) >> 12;
new_correction_factor = (double)target_bits_per_mb * q2 / enumerator;
diff --git a/av1/encoder/rc_utils.h b/av1/encoder/rc_utils.h
index 6e6adfc..df77357 100644
--- a/av1/encoder/rc_utils.h
+++ b/av1/encoder/rc_utils.h
@@ -38,7 +38,7 @@
aom_clear_system_state();
AV1EncoderConfig *const oxcf = &cpi->oxcf;
- SequenceHeader *const seq_params = &cpi->common.seq_params;
+ SequenceHeader *const seq_params = cpi->common.seq_params;
TileConfig *const tile_cfg = &oxcf->tile_cfg;
RateControlCfg *const rc_cfg = &oxcf->rc_cfg;
@@ -272,7 +272,7 @@
const int64_t low_err_target = cpi->ambient_err >> 1;
#if CONFIG_AV1_HIGHBITDEPTH
- if (cm->seq_params.use_highbitdepth) {
+ if (cm->seq_params->use_highbitdepth) {
kf_err = aom_highbd_get_y_sse(cpi->source, &cm->cur_frame->buf);
} else {
kf_err = aom_get_y_sse(cpi->source, &cm->cur_frame->buf);
@@ -325,11 +325,11 @@
if (*q == *q_high &&
rc->projected_frame_size >= rc->max_frame_bandwidth) {
const double q_val_high_current =
- av1_convert_qindex_to_q(*q_high, cm->seq_params.bit_depth);
+ av1_convert_qindex_to_q(*q_high, cm->seq_params->bit_depth);
const double q_val_high_new =
q_val_high_current *
((double)rc->projected_frame_size / rc->max_frame_bandwidth);
- *q_high = av1_find_qindex(q_val_high_new, cm->seq_params.bit_depth,
+ *q_high = av1_find_qindex(q_val_high_new, cm->seq_params->bit_depth,
rc->best_quality, rc->worst_quality);
}
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 03f85e3..ad0cea3 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -371,7 +371,7 @@
int av1_compute_rd_mult(const AV1_COMP *cpi, int qindex) {
int64_t rdmult = av1_compute_rd_mult_based_on_qindex(
- cpi->common.seq_params.bit_depth, qindex);
+ cpi->common.seq_params->bit_depth, qindex);
if (is_stat_consumption_stage(cpi) &&
(cpi->common.current_frame.frame_type != KEY_FRAME)) {
const GF_GROUP *const gf_group = &cpi->ppi->gf_group;
@@ -390,18 +390,18 @@
int av1_get_deltaq_offset(const AV1_COMP *cpi, int qindex, double beta) {
assert(beta > 0.0);
- int q = av1_dc_quant_QTX(qindex, 0, cpi->common.seq_params.bit_depth);
+ int q = av1_dc_quant_QTX(qindex, 0, cpi->common.seq_params->bit_depth);
int newq = (int)rint(q / sqrt(beta));
int orig_qindex = qindex;
if (newq < q) {
do {
qindex--;
- q = av1_dc_quant_QTX(qindex, 0, cpi->common.seq_params.bit_depth);
+ q = av1_dc_quant_QTX(qindex, 0, cpi->common.seq_params->bit_depth);
} while (newq < q && qindex > 0);
} else {
do {
qindex++;
- q = av1_dc_quant_QTX(qindex, 0, cpi->common.seq_params.bit_depth);
+ q = av1_dc_quant_QTX(qindex, 0, cpi->common.seq_params->bit_depth);
} while (newq > q && qindex < MAXQ);
}
return qindex - orig_qindex;
@@ -411,7 +411,7 @@
assert(beta > 0.0);
const AV1_COMMON *cm = &cpi->common;
int q = av1_dc_quant_QTX(cm->quant_params.base_qindex, 0,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
return (int)(av1_compute_rd_mult(cpi, q) / beta);
}
@@ -435,7 +435,7 @@
}
void av1_set_sad_per_bit(const AV1_COMP *cpi, int *sadperbit, int qindex) {
- switch (cpi->common.seq_params.bit_depth) {
+ switch (cpi->common.seq_params->bit_depth) {
case AOM_BITS_8: *sadperbit = sad_per_bit_lut_8[qindex]; break;
case AOM_BITS_10: *sadperbit = sad_per_bit_lut_10[qindex]; break;
case AOM_BITS_12: *sadperbit = sad_per_bit_lut_12[qindex]; break;
@@ -452,7 +452,7 @@
av1_get_qindex(&cm->seg, segment_id, cm->quant_params.base_qindex) +
cm->quant_params.y_dc_delta_q,
0, MAXQ);
- const int q = compute_rd_thresh_factor(qindex, cm->seq_params.bit_depth);
+ const int q = compute_rd_thresh_factor(qindex, cm->seq_params->bit_depth);
for (bsize = 0; bsize < BLOCK_SIZES_ALL; ++bsize) {
// Threshold here seems unnecessarily harsh but fine given actual
@@ -1291,7 +1291,7 @@
const THR_MODES top_mode = MAX_MODES;
const int max_rd_thresh_factor = use_adaptive_rd_thresh * RD_THRESH_MAX_FACT;
- const int bsize_is_1_to_4 = bsize > cm->seq_params.sb_size;
+ const int bsize_is_1_to_4 = bsize > cm->seq_params->sb_size;
BLOCK_SIZE min_size, max_size;
if (bsize_is_1_to_4) {
// This part handles block sizes with 1:4 and 4:1 aspect ratios
@@ -1300,7 +1300,7 @@
max_size = bsize;
} else {
min_size = AOMMAX(bsize - 2, BLOCK_4X4);
- max_size = AOMMIN(bsize + 2, (int)cm->seq_params.sb_size);
+ max_size = AOMMIN(bsize + 2, (int)cm->seq_params->sb_size);
}
for (THR_MODES mode = 0; mode < top_mode; ++mode) {
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index e5f29bc..1871373 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -1276,7 +1276,7 @@
uint8_t best_blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE];
uint8_t best_tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
const int rate_mv0 = *rate_mv;
- const int interintra_allowed = cm->seq_params.enable_interintra_compound &&
+ const int interintra_allowed = cm->seq_params->enable_interintra_compound &&
is_interintra_allowed(mbmi) &&
mbmi->compound_idx;
WARP_SAMPLE_INFO *const warp_sample_info =
@@ -1319,7 +1319,7 @@
const int switchable_rate =
av1_is_interp_needed(xd)
? av1_get_switchable_rate(x, xd, interp_filter,
- cm->seq_params.enable_dual_filter)
+ cm->seq_params->enable_dual_filter)
: 0;
int64_t best_rd = INT64_MAX;
int best_rate_mv = rate_mv0;
@@ -2428,7 +2428,7 @@
MB_MODE_INFO *mbmi = xd->mi[0];
const AV1_COMMON *cm = &cpi->common;
const int masked_compound_used = is_any_masked_compound_used(bsize) &&
- cm->seq_params.enable_masked_compound;
+ cm->seq_params->enable_masked_compound;
int mode_search_mask = (1 << COMPOUND_AVERAGE) | (1 << COMPOUND_DISTWTD) |
(1 << COMPOUND_WEDGE) | (1 << COMPOUND_DIFFWTD);
@@ -3015,8 +3015,8 @@
const int mi_col = xd->mi_col;
const int w = block_size_wide[bsize];
const int h = block_size_high[bsize];
- const int sb_row = mi_row >> cm->seq_params.mib_size_log2;
- const int sb_col = mi_col >> cm->seq_params.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;
const MV_REFERENCE_FRAME ref_frame = INTRA_FRAME;
@@ -3039,7 +3039,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->seq_params.mib_size, mi_row);
+ av1_find_ref_dv(&dv_ref, tile, cm->seq_params->mib_size, mi_row);
}
// Ref DV should not have sub-pel.
assert((dv_ref.as_mv.col & 7) == 0);
@@ -3084,19 +3084,19 @@
fullms_params.mv_limits.row_min =
(tile->mi_row_start - mi_row) * MI_SIZE;
fullms_params.mv_limits.row_max =
- (sb_row * cm->seq_params.mib_size - mi_row) * MI_SIZE - h;
+ (sb_row * cm->seq_params->mib_size - mi_row) * MI_SIZE - h;
break;
case IBC_MOTION_LEFT:
fullms_params.mv_limits.col_min =
(tile->mi_col_start - mi_col) * MI_SIZE;
fullms_params.mv_limits.col_max =
- (sb_col * cm->seq_params.mib_size - mi_col) * MI_SIZE - w;
+ (sb_col * cm->seq_params->mib_size - mi_col) * MI_SIZE - w;
// TODO(aconverse@google.com): Minimize the overlap between above and
// left areas.
fullms_params.mv_limits.row_min =
(tile->mi_row_start - mi_row) * MI_SIZE;
int bottom_coded_mi_edge =
- AOMMIN((sb_row + 1) * cm->seq_params.mib_size, tile->mi_row_end);
+ AOMMIN((sb_row + 1) * cm->seq_params->mib_size, tile->mi_row_end);
fullms_params.mv_limits.row_max =
(bottom_coded_mi_edge - mi_row) * MI_SIZE - h;
break;
@@ -3134,7 +3134,7 @@
get_fullmv_from_mv(&dv)))
continue;
if (!av1_is_dv_valid(dv, cm, xd, mi_row, mi_col, bsize,
- cm->seq_params.mib_size_log2))
+ cm->seq_params->mib_size_log2))
continue;
// DV should not have sub-pel.
@@ -5230,7 +5230,7 @@
if (mode != DC_PRED && mode != PAETH_PRED) {
const int intra_cost_penalty = av1_get_intra_cost_penalty(
cm->quant_params.base_qindex, cm->quant_params.y_dc_delta_q,
- cm->seq_params.bit_depth);
+ cm->seq_params->bit_depth);
intra_rd_stats.rate += intra_cost_penalty;
}
@@ -5346,7 +5346,7 @@
mbmi->partition != PARTITION_HORZ) ||
cpi->sf.inter_sf.prune_ref_frame_for_rect_partitions >= 2) {
picked_ref_frames_mask =
- fetch_picked_ref_frames_mask(x, bsize, cm->seq_params.mib_size);
+ fetch_picked_ref_frames_mask(x, bsize, cm->seq_params->mib_size);
}
}
@@ -5420,7 +5420,7 @@
if (do_pruning && sf->intra_sf.skip_intra_in_interframe &&
cpi->oxcf.algo_cfg.enable_tpl_model) {
// Only consider full SB.
- const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
+ const BLOCK_SIZE sb_size = cm->seq_params->sb_size;
const int tpl_bsize_1d = cpi->tpl_data.tpl_bsize_1d;
const int len = (block_size_wide[sb_size] / tpl_bsize_1d) *
(block_size_high[sb_size] / tpl_bsize_1d);
@@ -5889,7 +5889,7 @@
for (i = 0; i < SWITCHABLE_FILTERS; ++i) {
mbmi->interp_filters = av1_broadcast_interp_filter(i);
rs = av1_get_switchable_rate(x, xd, interp_filter,
- cm->seq_params.enable_dual_filter);
+ cm->seq_params->enable_dual_filter);
if (rs < best_rs) {
best_rs = rs;
best_filter = mbmi->interp_filters.as_filters.y_filter;
@@ -5900,7 +5900,7 @@
// Set the appropriate filter
mbmi->interp_filters = av1_broadcast_interp_filter(best_filter);
rate2 += av1_get_switchable_rate(x, xd, interp_filter,
- cm->seq_params.enable_dual_filter);
+ cm->seq_params->enable_dual_filter);
if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT)
rate2 += comp_inter_cost[comp_pred];
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 362da7b..055a49e 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -217,10 +217,10 @@
static INLINE int av1_get_sb_mi_size(const AV1_COMMON *const cm) {
const int mi_alloc_size_1d = mi_size_wide[cm->mi_params.mi_alloc_bsize];
int sb_mi_rows =
- (mi_size_wide[cm->seq_params.sb_size] + mi_alloc_size_1d - 1) /
+ (mi_size_wide[cm->seq_params->sb_size] + mi_alloc_size_1d - 1) /
mi_alloc_size_1d;
- assert(mi_size_wide[cm->seq_params.sb_size] ==
- mi_size_high[cm->seq_params.sb_size]);
+ assert(mi_size_wide[cm->seq_params->sb_size] ==
+ mi_size_high[cm->seq_params->sb_size]);
int sb_mi_size = sb_mi_rows * sb_mi_rows;
return sb_mi_size;
diff --git a/av1/encoder/rdopt_utils.h b/av1/encoder/rdopt_utils.h
index ddd180f..3996495 100644
--- a/av1/encoder/rdopt_utils.h
+++ b/av1/encoder/rdopt_utils.h
@@ -569,7 +569,7 @@
const MACROBLOCK *x) {
const MACROBLOCKD *xd = &x->e_mbd;
- if (cm->seq_params.monochrome || !xd->is_chroma_ref) return CFL_DISALLOWED;
+ if (cm->seq_params->monochrome || !xd->is_chroma_ref) return CFL_DISALLOWED;
if (!xd->is_chroma_ref) {
// For non-chroma-reference blocks, we should always store the luma pixels,
diff --git a/av1/encoder/segmentation.c b/av1/encoder/segmentation.c
index 8252f52..edb6ef6 100644
--- a/av1/encoder/segmentation.c
+++ b/av1/encoder/segmentation.c
@@ -202,15 +202,15 @@
tile_info.mi_row_start * cm->mi_params.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->seq_params.mib_size,
- mi_ptr += cm->seq_params.mib_size * cm->mi_params.mi_stride) {
+ mi_row += cm->seq_params->mib_size,
+ mi_ptr += cm->seq_params->mib_size * cm->mi_params.mi_stride) {
MB_MODE_INFO **mi = mi_ptr;
for (mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
- mi_col += cm->seq_params.mib_size,
- mi += cm->seq_params.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->seq_params.sb_size);
+ mi_col, cm->seq_params->sb_size);
}
}
}
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index ab55901..9bdcb0e 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -1756,7 +1756,7 @@
}
if (!cpi->ppi->seq_params_locked) {
- cpi->common.seq_params.enable_masked_compound &=
+ cpi->common.seq_params->enable_masked_compound &=
!sf->inter_sf.disable_masked_comp;
}
@@ -1808,11 +1808,11 @@
}
if (!cpi->ppi->seq_params_locked) {
- cpi->common.seq_params.enable_dual_filter &=
+ cpi->common.seq_params->enable_dual_filter &=
!sf->interp_sf.disable_dual_filter;
- cpi->common.seq_params.enable_restoration &= !sf->lpf_sf.disable_lr_filter;
+ cpi->common.seq_params->enable_restoration &= !sf->lpf_sf.disable_lr_filter;
- cpi->common.seq_params.enable_interintra_compound &=
+ cpi->common.seq_params->enable_interintra_compound &=
(sf->inter_sf.disable_interintra_wedge_var_thresh != UINT_MAX);
}
diff --git a/av1/encoder/superres_scale.c b/av1/encoder/superres_scale.c
index f035b02..f0e9e9c 100644
--- a/av1/encoder/superres_scale.c
+++ b/av1/encoder/superres_scale.c
@@ -80,7 +80,7 @@
if (is_stat_generation_stage(cpi)) return SCALE_NUMERATOR;
uint8_t new_denom = SCALE_NUMERATOR;
- if (cpi->common.seq_params.reduced_still_picture_hdr) return SCALE_NUMERATOR;
+ if (cpi->common.seq_params->reduced_still_picture_hdr) return SCALE_NUMERATOR;
switch (resize_cfg->resize_mode) {
case RESIZE_NONE: new_denom = SCALE_NUMERATOR; break;
case RESIZE_FIXED:
@@ -195,8 +195,8 @@
// Make sure that superres mode of the frame is consistent with the
// sequence-level flag.
assert(IMPLIES(superres_cfg->superres_mode != AOM_SUPERRES_NONE,
- cpi->common.seq_params.enable_superres));
- assert(IMPLIES(!cpi->common.seq_params.enable_superres,
+ cpi->common.seq_params->enable_superres));
+ assert(IMPLIES(!cpi->common.seq_params->enable_superres,
superres_cfg->superres_mode == AOM_SUPERRES_NONE));
// Make sure that superres mode for current encoding is consistent with user
// provided superres mode.
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c
index b0c3b5d..31057a6 100644
--- a/av1/encoder/temporal_filter.c
+++ b/av1/encoder/temporal_filter.c
@@ -755,7 +755,7 @@
const GF_GROUP *gf_group = &cpi->ppi->gf_group;
const FRAME_TYPE frame_type = gf_group->frame_type[cpi->gf_frame_index];
const int q = (int)av1_convert_qindex_to_q(
- cpi->rc.avg_frame_qindex[frame_type], cpi->common.seq_params.bit_depth);
+ cpi->rc.avg_frame_qindex[frame_type], cpi->common.seq_params->bit_depth);
return q;
}
@@ -973,7 +973,7 @@
double *noise_levels = tf_ctx->noise_levels;
for (int plane = 0; plane < num_planes; ++plane) {
noise_levels[plane] = av1_estimate_noise_from_single_plane(
- to_filter_frame, plane, cpi->common.seq_params.bit_depth);
+ to_filter_frame, plane, cpi->common.seq_params->bit_depth);
}
// Get quantization factor.
const int q = av1_get_q(cpi);
@@ -1068,10 +1068,10 @@
assert(frames[tf_ctx->filter_frame_idx] == to_filter_frame);
av1_setup_src_planes(&cpi->td.mb, &to_filter_buf->img, 0, 0, num_planes,
- cpi->common.seq_params.sb_size);
+ cpi->common.seq_params->sb_size);
av1_setup_block_planes(&cpi->td.mb.e_mbd,
- cpi->common.seq_params.subsampling_x,
- cpi->common.seq_params.subsampling_y, num_planes);
+ cpi->common.seq_params->subsampling_x,
+ cpi->common.seq_params->subsampling_y, num_planes);
}
/*!\cond */
@@ -1255,7 +1255,7 @@
const int q = av1_rc_pick_q_and_bounds(
cpi, cpi->oxcf.frm_dim_cfg.width, cpi->oxcf.frm_dim_cfg.height,
group_idx, &bottom_index, &top_index);
- const int ac_q = av1_ac_quant_QTX(q, 0, cpi->common.seq_params.bit_depth);
+ const int ac_q = av1_ac_quant_QTX(q, 0, cpi->common.seq_params->bit_depth);
const float threshold = 0.7f * ac_q * ac_q;
if (!is_second_arf) {
diff --git a/av1/encoder/tokenize.h b/av1/encoder/tokenize.h
index 51eb28c..f31dc96 100644
--- a/av1/encoder/tokenize.h
+++ b/av1/encoder/tokenize.h
@@ -119,8 +119,8 @@
// Allocate memory for token related info.
static AOM_INLINE void alloc_token_info(AV1_COMMON *cm, TokenInfo *token_info) {
int mi_rows_aligned_to_sb =
- ALIGN_POWER_OF_TWO(cm->mi_params.mi_rows, cm->seq_params.mib_size_log2);
- int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params.mib_size_log2;
+ ALIGN_POWER_OF_TWO(cm->mi_params.mi_rows, cm->seq_params->mib_size_log2);
+ int sb_rows = mi_rows_aligned_to_sb >> cm->seq_params->mib_size_log2;
const int num_planes = av1_num_planes(cm);
unsigned int tokens =
get_token_alloc(cm->mi_params.mb_rows, cm->mi_params.mb_cols,
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index 138dff6..3658c34 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -155,8 +155,8 @@
sizeof(*tpl_data->tpl_stats_buffer[frame].tpl_stats_ptr)));
if (aom_alloc_frame_buffer(
&tpl_data->tpl_rec_pool[frame], cm->width, cm->height,
- cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
- cm->seq_params.use_highbitdepth, tpl_data->border_in_pixels,
+ cm->seq_params->subsampling_x, cm->seq_params->subsampling_y,
+ cm->seq_params->use_highbitdepth, tpl_data->border_in_pixels,
cm->features.byte_alignment))
aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
"Failed to allocate frame buffer");
@@ -303,7 +303,7 @@
const YV12_BUFFER_CONFIG *ref_frame_ptr[2], uint8_t *rec_buffer_pool[3],
const int rec_stride_pool[3], TX_SIZE tx_size, PREDICTION_MODE best_mode,
int mi_row, int mi_col, int use_y_only_rate_distortion) {
- const SequenceHeader *seq_params = &cm->seq_params;
+ const SequenceHeader *seq_params = cm->seq_params;
*rate_cost = 0;
*recon_error = 1;
@@ -501,7 +501,7 @@
// H_PRED, and V_PRED
const PREDICTION_MODE last_intra_mode =
cpi->sf.tpl_sf.prune_intra_modes ? D45_PRED : INTRA_MODE_END;
- const SequenceHeader *seq_params = &cm->seq_params;
+ const SequenceHeader *seq_params = cm->seq_params;
for (PREDICTION_MODE mode = INTRA_MODE_START; mode < last_intra_mode;
++mode) {
av1_predict_intra_block(xd, seq_params->sb_size,
@@ -1148,7 +1148,7 @@
av1_frame_init_quantizer(cpi);
tpl_frame->base_rdmult = av1_compute_rd_mult_based_on_qindex(
- cm->seq_params.bit_depth, pframe_qindex) /
+ cm->seq_params->bit_depth, pframe_qindex) /
6;
memset(tpl_txfm_stats, 0, sizeof(*tpl_txfm_stats));
diff --git a/av1/encoder/tune_butteraugli.c b/av1/encoder/tune_butteraugli.c
index b5691f9..6c3a7fb 100644
--- a/av1/encoder/tune_butteraugli.c
+++ b/av1/encoder/tune_butteraugli.c
@@ -212,7 +212,7 @@
const int ss_y = cpi->source->subsampling_y;
if (dst->buffer_alloc_sz == 0) {
aom_alloc_frame_buffer(
- dst, width, height, ss_x, ss_y, cm->seq_params.use_highbitdepth,
+ dst, width, height, ss_x, ss_y, cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels, cm->features.byte_alignment);
}
av1_copy_and_extend_frame(cpi->source, dst);
@@ -221,7 +221,7 @@
if (resized_dst->buffer_alloc_sz == 0) {
aom_alloc_frame_buffer(
resized_dst, width / resize_factor, height / resize_factor, ss_x, ss_y,
- cm->seq_params.use_highbitdepth, cpi->oxcf.border_in_pixels,
+ cm->seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
}
av1_resize_and_extend_frame_nonnormative(cpi->source, resized_dst, bit_depth,
@@ -246,7 +246,7 @@
memset(&resized_recon, 0, sizeof(resized_recon));
aom_alloc_frame_buffer(
&resized_recon, width / resize_factor, height / resize_factor, ss_x, ss_y,
- cm->seq_params.use_highbitdepth, cpi->oxcf.border_in_pixels,
+ cm->seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
copy_img(&cpi->common.cur_frame->buf, &resized_recon, width / resize_factor,
height / resize_factor);
diff --git a/av1/encoder/tune_vmaf.c b/av1/encoder/tune_vmaf.c
index cb93dd7..7ade7d6 100644
--- a/av1/encoder/tune_vmaf.c
+++ b/av1/encoder/tune_vmaf.c
@@ -115,7 +115,7 @@
buf.buf = (uint8_t *)y_buffer + row_offset_y * y_stride + col_offset_y;
buf.stride = y_stride;
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
assert(frame->flags & YV12_FLAG_HIGHBITDEPTH);
var += av1_high_get_sby_perpixel_variance(cpi, &buf, block_size,
bit_depth);
@@ -232,7 +232,7 @@
const YV12_BUFFER_CONFIG *blurred,
const YV12_BUFFER_CONFIG *dst, double amount) {
const int bit_depth = cpi->td.mb.e_mbd.bd;
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
assert(source->flags & YV12_FLAG_HIGHBITDEPTH);
assert(blurred->flags & YV12_FLAG_HIGHBITDEPTH);
assert(dst->flags & YV12_FLAG_HIGHBITDEPTH);
@@ -343,10 +343,10 @@
const int height = source->y_height;
YV12_BUFFER_CONFIG sharpened;
memset(&sharpened, 0, sizeof(sharpened));
- aom_alloc_frame_buffer(&sharpened, width, height, source->subsampling_x,
- source->subsampling_y, cm->seq_params.use_highbitdepth,
- cpi->oxcf.border_in_pixels,
- cm->features.byte_alignment);
+ aom_alloc_frame_buffer(
+ &sharpened, width, height, source->subsampling_x, source->subsampling_y,
+ cm->seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
+ cm->features.byte_alignment);
const double baseline_variance = frame_average_variance(cpi, source);
double unsharp_amount;
@@ -396,10 +396,10 @@
YV12_BUFFER_CONFIG blurred;
memset(&blurred, 0, sizeof(blurred));
- aom_alloc_frame_buffer(&blurred, width, height, source->subsampling_x,
- source->subsampling_y, cm->seq_params.use_highbitdepth,
- cpi->oxcf.border_in_pixels,
- cm->features.byte_alignment);
+ aom_alloc_frame_buffer(
+ &blurred, width, height, source->subsampling_x, source->subsampling_y,
+ cm->seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
+ cm->features.byte_alignment);
gaussian_blur(bit_depth, source, &blurred);
unsharp(cpi, source, &blurred, source, best_frame_unsharp_amount);
@@ -418,14 +418,14 @@
YV12_BUFFER_CONFIG source_extended, blurred;
memset(&source_extended, 0, sizeof(source_extended));
memset(&blurred, 0, sizeof(blurred));
- aom_alloc_frame_buffer(&source_extended, width, height, source->subsampling_x,
- source->subsampling_y, cm->seq_params.use_highbitdepth,
- cpi->oxcf.border_in_pixels,
- cm->features.byte_alignment);
- aom_alloc_frame_buffer(&blurred, width, height, source->subsampling_x,
- source->subsampling_y, cm->seq_params.use_highbitdepth,
- cpi->oxcf.border_in_pixels,
- cm->features.byte_alignment);
+ aom_alloc_frame_buffer(
+ &source_extended, width, height, source->subsampling_x,
+ source->subsampling_y, cm->seq_params->use_highbitdepth,
+ cpi->oxcf.border_in_pixels, cm->features.byte_alignment);
+ aom_alloc_frame_buffer(
+ &blurred, width, height, source->subsampling_x, source->subsampling_y,
+ cm->seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
+ cm->features.byte_alignment);
av1_copy_and_extend_frame(source, &source_extended);
gaussian_blur(bit_depth, &source_extended, &blurred);
@@ -462,10 +462,10 @@
memset(&blurred, 0, sizeof(blurred));
memset(&source_extended, 0, sizeof(source_extended));
aom_alloc_frame_buffer(
- &blurred, width, height, ss_x, ss_y, cm->seq_params.use_highbitdepth,
+ &blurred, width, height, ss_x, ss_y, cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels, cm->features.byte_alignment);
aom_alloc_frame_buffer(&source_extended, width, height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
@@ -499,11 +499,11 @@
memset(&source_block, 0, sizeof(source_block));
memset(&blurred_block, 0, sizeof(blurred_block));
aom_alloc_frame_buffer(&source_block, block_w, block_h, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
aom_alloc_frame_buffer(&blurred_block, block_w, block_h, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
@@ -515,7 +515,7 @@
const int block_height = AOMMIN(height - row_offset_y, block_h);
const int index = col + row * num_cols;
- if (cm->seq_params.use_highbitdepth) {
+ if (cm->seq_params->use_highbitdepth) {
assert(source->flags & YV12_FLAG_HIGHBITDEPTH);
assert(blurred.flags & YV12_FLAG_HIGHBITDEPTH);
uint16_t *frame_src_buf = CONVERT_TO_SHORTPTR(source->y_buffer) +
@@ -584,7 +584,7 @@
const int block_height = AOMMIN(source->y_height - row_offset_y, block_h);
const int index = col + row * num_cols;
- if (cm->seq_params.use_highbitdepth) {
+ if (cm->seq_params->use_highbitdepth) {
assert(source->flags & YV12_FLAG_HIGHBITDEPTH);
assert(blurred.flags & YV12_FLAG_HIGHBITDEPTH);
uint16_t *src_buf = CONVERT_TO_SHORTPTR(source->y_buffer) +
@@ -629,7 +629,7 @@
memset(&resized_source, 0, sizeof(resized_source));
aom_alloc_frame_buffer(
&resized_source, y_width / resize_factor, y_height / resize_factor, ss_x,
- ss_y, cm->seq_params.use_highbitdepth, cpi->oxcf.border_in_pixels,
+ ss_y, cm->seq_params->use_highbitdepth, cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
av1_resize_and_extend_frame_nonnormative(cpi->source, &resized_source,
bit_depth, av1_num_planes(cm));
@@ -646,7 +646,7 @@
YV12_BUFFER_CONFIG blurred;
memset(&blurred, 0, sizeof(blurred));
aom_alloc_frame_buffer(&blurred, resized_y_width, resized_y_height, ss_x,
- ss_y, cm->seq_params.use_highbitdepth,
+ ss_y, cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
gaussian_blur(bit_depth, &resized_source, &blurred);
@@ -654,7 +654,7 @@
YV12_BUFFER_CONFIG recon;
memset(&recon, 0, sizeof(recon));
aom_alloc_frame_buffer(&recon, resized_y_width, resized_y_height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
aom_yv12_copy_frame(&resized_source, &recon, 1);
@@ -686,7 +686,7 @@
uint8_t *const recon_buf =
recon.y_buffer + row_offset_y * recon.y_stride + col_offset_y;
// Set recon buf
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
highbd_unsharp_rect(CONVERT_TO_SHORTPTR(blurred_buf), blurred.y_stride,
CONVERT_TO_SHORTPTR(blurred_buf), blurred.y_stride,
CONVERT_TO_SHORTPTR(recon_buf), recon.y_stride,
@@ -701,7 +701,7 @@
index);
// Restore recon buf
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
highbd_unsharp_rect(
CONVERT_TO_SHORTPTR(orig_buf), resized_source.y_stride,
CONVERT_TO_SHORTPTR(orig_buf), resized_source.y_stride,
@@ -833,15 +833,15 @@
memset(&blurred_next, 0, sizeof(blurred_next));
aom_alloc_frame_buffer(&blurred_cur, y_width, y_height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
aom_alloc_frame_buffer(&blurred_last, y_width, y_height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
aom_alloc_frame_buffer(&blurred_next, y_width, y_height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
@@ -850,7 +850,7 @@
if (next) gaussian_blur(bit_depth, next, &blurred_next);
double motion1, motion2 = 65536.0;
- if (cm->seq_params.use_highbitdepth) {
+ if (cm->seq_params->use_highbitdepth) {
assert(blurred_cur.flags & YV12_FLAG_HIGHBITDEPTH);
assert(blurred_last.flags & YV12_FLAG_HIGHBITDEPTH);
const float scale_factor = 1.0f / (float)(1 << (bit_depth - 8));
@@ -1026,19 +1026,19 @@
memset(&recon_blurred, 0, sizeof(recon_blurred));
memset(&src_blurred, 0, sizeof(src_blurred));
aom_alloc_frame_buffer(&recon_sharpened, width, height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
aom_alloc_frame_buffer(&src_sharpened, width, height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
aom_alloc_frame_buffer(&recon_blurred, width, height, ss_x, ss_y,
- cm->seq_params.use_highbitdepth,
+ cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels,
cm->features.byte_alignment);
aom_alloc_frame_buffer(
- &src_blurred, width, height, ss_x, ss_y, cm->seq_params.use_highbitdepth,
+ &src_blurred, width, height, ss_x, ss_y, cm->seq_params->use_highbitdepth,
cpi->oxcf.border_in_pixels, cm->features.byte_alignment);
gaussian_blur(bit_depth, recon, &recon_blurred);
@@ -1093,7 +1093,7 @@
aom_calc_vmaf(cpi->vmaf_info.vmaf_model, source, recon, bit_depth,
cal_vmaf_neg, &base_score);
cpi->vmaf_info.last_frame_vmaf[layer_depth] = base_score;
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
assert(source->flags & YV12_FLAG_HIGHBITDEPTH);
assert(recon->flags & YV12_FLAG_HIGHBITDEPTH);
cpi->vmaf_info.last_frame_ysse[layer_depth] =
diff --git a/av1/encoder/tx_search.c b/av1/encoder/tx_search.c
index 1a5071a..3fe65b6 100644
--- a/av1/encoder/tx_search.c
+++ b/av1/encoder/tx_search.c
@@ -618,7 +618,7 @@
assert(bw <= 32);
assert(bh <= 32);
assert(((bw - 1) >> w_shift) + (((bh - 1) >> h_shift) << 2) == 15);
- if (cpi->common.seq_params.use_highbitdepth) {
+ if (cpi->common.seq_params->use_highbitdepth) {
const uint16_t *src16 = CONVERT_TO_SHORTPTR(src);
const uint16_t *dst16 = CONVERT_TO_SHORTPTR(dst);
for (int i = 0; i < bh; ++i)
diff --git a/av1/encoder/var_based_part.c b/av1/encoder/var_based_part.c
index 5c61321..bf41fcd 100644
--- a/av1/encoder/var_based_part.c
+++ b/av1/encoder/var_based_part.c
@@ -629,7 +629,7 @@
xd->mi[0]->mv[0].as_mv.col > -mv_thr &&
xd->mi[0]->mv[0].as_mv.row < mv_thr &&
xd->mi[0]->mv[0].as_mv.row > -mv_thr))) {
- const int is_small_sb = (cm->seq_params.sb_size == BLOCK_64X64);
+ const int is_small_sb = (cm->seq_params->sb_size == BLOCK_64X64);
if (is_small_sb)
set_low_temp_var_flag_64x64(&cm->mi_params, part_info, xd,
&(vt->split[0]), thresholds, mi_col, mi_row);
@@ -683,7 +683,7 @@
AV1_COMMON *cm = &cpi->common;
MACROBLOCKD *xd = &x->e_mbd;
const int is_key_frame = frame_is_intra_only(cm);
- const int is_small_sb = (cm->seq_params.sb_size == BLOCK_64X64);
+ const int is_small_sb = (cm->seq_params->sb_size == BLOCK_64X64);
const int num_64x64_blocks = is_small_sb ? 1 : 4;
// TODO(kyslov) Bring back compute_minmax_variance with content type detection
const int compute_minmax_variance = 0;
@@ -797,7 +797,7 @@
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *xd = &x->e_mbd;
const int num_planes = av1_num_planes(cm);
- const int is_small_sb = (cm->seq_params.sb_size == BLOCK_64X64);
+ const int is_small_sb = (cm->seq_params->sb_size == BLOCK_64X64);
BLOCK_SIZE bsize = is_small_sb ? BLOCK_64X64 : BLOCK_128X128;
// TODO(kyslov): we are assuming that the ref is LAST_FRAME! Check if it
// is!!
@@ -824,13 +824,13 @@
get_ref_scale_factors(cm, LAST_FRAME), num_planes);
mi->ref_frame[0] = LAST_FRAME;
mi->ref_frame[1] = NONE_FRAME;
- mi->bsize = cm->seq_params.sb_size;
+ mi->bsize = cm->seq_params->sb_size;
mi->mv[0].as_int = 0;
mi->interp_filters = av1_broadcast_interp_filter(BILINEAR);
if (cpi->sf.rt_sf.estimate_motion_for_var_based_partition) {
if (xd->mb_to_right_edge >= 0 && xd->mb_to_bottom_edge >= 0) {
const MV dummy_mv = { 0, 0 };
- *y_sad = av1_int_pro_motion_estimation(cpi, x, cm->seq_params.sb_size,
+ *y_sad = av1_int_pro_motion_estimation(cpi, x, cm->seq_params->sb_size,
mi_row, mi_col, &dummy_mv);
}
}
@@ -859,7 +859,7 @@
set_ref_ptrs(cm, xd, mi->ref_frame[0], mi->ref_frame[1]);
av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL,
- cm->seq_params.sb_size, AOM_PLANE_Y,
+ cm->seq_params->sb_size, AOM_PLANE_Y,
AOM_PLANE_Y);
}
@@ -897,9 +897,9 @@
(cpi->use_svc &&
cpi->svc.layer_context[cpi->svc.temporal_layer_id].is_key_frame));
- assert(cm->seq_params.sb_size == BLOCK_64X64 ||
- cm->seq_params.sb_size == BLOCK_128X128);
- const int is_small_sb = (cm->seq_params.sb_size == BLOCK_64X64);
+ assert(cm->seq_params->sb_size == BLOCK_64X64 ||
+ cm->seq_params->sb_size == BLOCK_128X128);
+ const int is_small_sb = (cm->seq_params->sb_size == BLOCK_64X64);
const int num_64x64_blocks = is_small_sb ? 1 : 4;
unsigned int y_sad = UINT_MAX;
diff --git a/test/intrabc_test.cc b/test/intrabc_test.cc
index b57eb6f..2c60596 100644
--- a/test/intrabc_test.cc
+++ b/test/intrabc_test.cc
@@ -153,8 +153,10 @@
xd.plane[2].subsampling_x = 1;
xd.plane[2].subsampling_y = 1;
+ SequenceHeader seq_params = {};
AV1_COMMON cm;
memset(&cm, 0, sizeof(cm));
+ cm.seq_params = &seq_params;
for (const DvTestCase &dv_case : kDvCases) {
const int mi_row = xd.tile.mi_row_start + dv_case.mi_row_offset;
