Commit 6d0ed3ed authored by Yaowu Xu's avatar Yaowu Xu

Remove CONFIG_PARALLEL_DEBLOCKING

The experiment is fully adopted now.

Change-Id: I27906d2af4c746ce55aa17f64d1c0ef281e23ab2
parent e4cf4fa4
......@@ -86,12 +86,6 @@ set(AOM_DSP_COMMON_INTRIN_AVX2
"${AOM_ROOT}/aom_dsp/x86/inv_txfm_common_avx2.h"
"${AOM_ROOT}/aom_dsp/x86/txfm_common_avx2.h")
if (NOT CONFIG_PARALLEL_DEBLOCKING)
set(AOM_DSP_COMMON_INTRIN_AVX2
${AOM_DSP_COMMON_INTRIN_AVX2}
"${AOM_ROOT}/aom_dsp/x86/loopfilter_avx2.c")
endif ()
if (NOT CONFIG_EXT_PARTITION)
set(AOM_DSP_COMMON_ASM_NEON
"${AOM_ROOT}/aom_dsp/arm/aom_convolve8_avg_neon_asm.asm"
......@@ -113,14 +107,6 @@ set(AOM_DSP_COMMON_ASM_NEON
"${AOM_ROOT}/aom_dsp/arm/intrapred_neon_asm.asm"
"${AOM_ROOT}/aom_dsp/arm/save_reg_neon.asm")
if (NOT CONFIG_PARALLEL_DEBLOCKING)
set(AOM_DSP_COMMON_ASM_NEON
${AOM_DSP_COMMON_ASM_NEON}
"${AOM_ROOT}/aom_dsp/arm/loopfilter_16_neon.asm"
"${AOM_ROOT}/aom_dsp/arm/loopfilter_4_neon.asm"
"${AOM_ROOT}/aom_dsp/arm/loopfilter_8_neon.asm"
"${AOM_ROOT}/aom_dsp/arm/loopfilter_mb_neon.asm")
endif ()
if (NOT CONFIG_EXT_PARTITION)
set(AOM_DSP_COMMON_INTRIN_NEON
......@@ -140,11 +126,6 @@ set(AOM_DSP_COMMON_INTRIN_NEON
"${AOM_ROOT}/aom_dsp/arm/subtract_neon.c"
"${AOM_ROOT}/aom_dsp/arm/variance_neon.c")
if (NOT CONFIG_PARALLEL_DEBLOCKING)
set(AOM_DSP_COMMON_INTRIN_NEON
${AOM_DSP_COMMON_INTRIN_NEON}
"${AOM_ROOT}/aom_dsp/arm/loopfilter_neon.c")
endif ()
if ("${AOM_TARGET_CPU}" STREQUAL "arm64")
if (NOT CONFIG_EXT_PARTITION)
......@@ -168,13 +149,6 @@ if ("${AOM_TARGET_CPU}" STREQUAL "arm64")
"${AOM_ROOT}/aom_dsp/arm/idct8x8_add_neon.c"
"${AOM_ROOT}/aom_dsp/arm/intrapred_neon.c")
if (NOT CONFIG_PARALLEL_DEBLOCKING)
set(AOM_DSP_COMMON_INTRIN_NEON
${AOM_DSP_COMMON_INTRIN_NEON}
"${AOM_ROOT}/aom_dsp/arm/loopfilter_16_neon.c"
"${AOM_ROOT}/aom_dsp/arm/loopfilter_4_neon.c"
"${AOM_ROOT}/aom_dsp/arm/loopfilter_8_neon.c")
endif ()
endif ()
set(AOM_DSP_COMMON_INTRIN_DSPR2
......@@ -196,18 +170,6 @@ set(AOM_DSP_COMMON_INTRIN_DSPR2
"${AOM_ROOT}/aom_dsp/mips/intrapred8_dspr2.c"
"${AOM_ROOT}/aom_dsp/mips/inv_txfm_dspr2.h")
if (NOT CONFIG_PARALLEL_DEBLOCKING)
set(AOM_DSP_COMMON_INTRIN_DSPR2
${AOM_DSP_COMMON_INTRIN_DSPR2}
"${AOM_ROOT}/aom_dsp/mips/loopfilter_filters_dspr2.c"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_filters_dspr2.h"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_macros_dspr2.h"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_masks_dspr2.h"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_mb_dspr2.c"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_mb_horiz_dspr2.c"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_mb_vert_dspr2.c")
endif ()
set(AOM_DSP_COMMON_INTRIN_MSA
"${AOM_ROOT}/aom_dsp/mips/aom_convolve8_avg_horiz_msa.c"
"${AOM_ROOT}/aom_dsp/mips/aom_convolve8_avg_msa.c"
......@@ -230,15 +192,6 @@ set(AOM_DSP_COMMON_INTRIN_MSA
"${AOM_ROOT}/aom_dsp/mips/macros_msa.h"
"${AOM_ROOT}/aom_dsp/mips/txfm_macros_msa.h")
if (NOT CONFIG_PARALLEL_DEBLOCKING)
set(AOM_DSP_COMMON_INTRIN_MSA
${AOM_DSP_COMMON_INTRIN_MSA}
"${AOM_ROOT}/aom_dsp/mips/loopfilter_16_msa.c"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_4_msa.c"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_8_msa.c"
"${AOM_ROOT}/aom_dsp/mips/loopfilter_msa.h")
endif ()
set(AOM_DSP_COMMON_ASM_SSE2
${AOM_DSP_COMMON_ASM_SSE2}
"${AOM_ROOT}/aom_dsp/x86/aom_high_subpixel_8t_sse2.asm"
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
......@@ -502,14 +502,12 @@ static INLINE void highbd_lpf_horz_edge_8_internal(uint16_t *s, int pitch,
// Note:
// highbd_lpf_horz_edge_8_8p() output 8 pixels per register
// highbd_lpf_horz_edge_8_4p() output 4 pixels per register
#if CONFIG_PARALLEL_DEBLOCKING
static INLINE void highbd_lpf_horz_edge_8_4p(uint16_t *s, int pitch,
const uint8_t *blt,
const uint8_t *lt,
const uint8_t *thr, int bd) {
highbd_lpf_horz_edge_8_internal(s, pitch, blt, lt, thr, bd, FOUR_PIXELS);
}
#endif // #if CONFIG_PARALLEL_DEBLOCKING
static INLINE void highbd_lpf_horz_edge_8_8p(uint16_t *s, int pitch,
const uint8_t *blt,
......@@ -522,44 +520,26 @@ void aom_highbd_lpf_horizontal_16_sse2(uint16_t *s, int p,
const uint8_t *_blimit,
const uint8_t *_limit,
const uint8_t *_thresh, int bd) {
#if CONFIG_PARALLEL_DEBLOCKING
highbd_lpf_horz_edge_8_4p(s, p, _blimit, _limit, _thresh, bd);
#else
highbd_lpf_horz_edge_8_8p(s, p, _blimit, _limit, _thresh, bd);
#endif
}
void aom_highbd_lpf_horizontal_16_dual_sse2(uint16_t *s, int p,
const uint8_t *_blimit,
const uint8_t *_limit,
const uint8_t *_thresh, int bd) {
#if CONFIG_PARALLEL_DEBLOCKING
highbd_lpf_horz_edge_8_4p(s, p, _blimit, _limit, _thresh, bd);
#else
highbd_lpf_horz_edge_8_8p(s, p, _blimit, _limit, _thresh, bd);
highbd_lpf_horz_edge_8_8p(s + 8, p, _blimit, _limit, _thresh, bd);
#endif
}
static INLINE void store_horizontal_8(const __m128i *p2, const __m128i *p1,
const __m128i *p0, const __m128i *q0,
const __m128i *q1, const __m128i *q2,
int p, uint16_t *s) {
#if CONFIG_PARALLEL_DEBLOCKING
_mm_storel_epi64((__m128i *)(s - 3 * p), *p2);
_mm_storel_epi64((__m128i *)(s - 2 * p), *p1);
_mm_storel_epi64((__m128i *)(s - 1 * p), *p0);
_mm_storel_epi64((__m128i *)(s + 0 * p), *q0);
_mm_storel_epi64((__m128i *)(s + 1 * p), *q1);
_mm_storel_epi64((__m128i *)(s + 2 * p), *q2);
#else
_mm_store_si128((__m128i *)(s - 3 * p), *p2);
_mm_store_si128((__m128i *)(s - 2 * p), *p1);
_mm_store_si128((__m128i *)(s - 1 * p), *p0);
_mm_store_si128((__m128i *)(s + 0 * p), *q0);
_mm_store_si128((__m128i *)(s + 1 * p), *q1);
_mm_store_si128((__m128i *)(s + 2 * p), *q2);
#endif
}
void aom_highbd_lpf_horizontal_8_sse2(uint16_t *s, int p,
......@@ -797,11 +777,7 @@ void aom_highbd_lpf_horizontal_8_dual_sse2(
const uint8_t *_thresh0, const uint8_t *_blimit1, const uint8_t *_limit1,
const uint8_t *_thresh1, int bd) {
aom_highbd_lpf_horizontal_8_sse2(s, p, _blimit0, _limit0, _thresh0, bd);
#if CONFIG_PARALLEL_DEBLOCKING
aom_highbd_lpf_horizontal_8_sse2(s + 4, p, _blimit1, _limit1, _thresh1, bd);
#else
aom_highbd_lpf_horizontal_8_sse2(s + 8, p, _blimit1, _limit1, _thresh1, bd);
#endif
}
void aom_highbd_lpf_horizontal_4_sse2(uint16_t *s, int p,
......@@ -811,18 +787,10 @@ void aom_highbd_lpf_horizontal_4_sse2(uint16_t *s, int p,
const __m128i zero = _mm_set1_epi16(0);
__m128i blimit, limit, thresh;
__m128i mask, hev, flat;
#if !(CONFIG_PARALLEL_DEBLOCKING)
__m128i p3 = _mm_loadu_si128((__m128i *)(s - 4 * p));
__m128i p2 = _mm_loadu_si128((__m128i *)(s - 3 * p));
#endif
__m128i p1 = _mm_loadu_si128((__m128i *)(s - 2 * p));
__m128i p0 = _mm_loadu_si128((__m128i *)(s - 1 * p));
__m128i q0 = _mm_loadu_si128((__m128i *)(s - 0 * p));
__m128i q1 = _mm_loadu_si128((__m128i *)(s + 1 * p));
#if !(CONFIG_PARALLEL_DEBLOCKING)
__m128i q2 = _mm_loadu_si128((__m128i *)(s + 2 * p));
__m128i q3 = _mm_loadu_si128((__m128i *)(s + 3 * p));
#endif
const __m128i abs_p1p0 =
_mm_or_si128(_mm_subs_epu16(p1, p0), _mm_subs_epu16(p0, p1));
const __m128i abs_q1q0 =
......@@ -905,16 +873,6 @@ void aom_highbd_lpf_horizontal_4_sse2(uint16_t *s, int p,
mask = _mm_and_si128(mask, _mm_adds_epu16(limit, one));
mask = _mm_max_epi16(flat, mask);
#if !(CONFIG_PARALLEL_DEBLOCKING)
__m128i work = _mm_max_epi16(
_mm_or_si128(_mm_subs_epu16(p2, p1), _mm_subs_epu16(p1, p2)),
_mm_or_si128(_mm_subs_epu16(p3, p2), _mm_subs_epu16(p2, p3)));
mask = _mm_max_epi16(work, mask);
work = _mm_max_epi16(
_mm_or_si128(_mm_subs_epu16(q2, q1), _mm_subs_epu16(q1, q2)),
_mm_or_si128(_mm_subs_epu16(q3, q2), _mm_subs_epu16(q2, q3)));
mask = _mm_max_epi16(work, mask);
#endif
mask = _mm_subs_epu16(mask, limit);
mask = _mm_cmpeq_epi16(mask, zero);
......@@ -980,17 +938,10 @@ void aom_highbd_lpf_horizontal_4_sse2(uint16_t *s, int p,
p1 = _mm_adds_epi16(ps1, filt);
pixel_clamp(&pmin, &pmax, &p1);
p1 = _mm_adds_epi16(p1, t80);
#if CONFIG_PARALLEL_DEBLOCKING
_mm_storel_epi64((__m128i *)(s - 2 * p), p1);
_mm_storel_epi64((__m128i *)(s - 1 * p), p0);
_mm_storel_epi64((__m128i *)(s + 0 * p), q0);
_mm_storel_epi64((__m128i *)(s + 1 * p), q1);
#else
_mm_storeu_si128((__m128i *)(s - 2 * p), p1);
_mm_storeu_si128((__m128i *)(s - 1 * p), p0);
_mm_storeu_si128((__m128i *)(s + 0 * p), q0);
_mm_storeu_si128((__m128i *)(s + 1 * p), q1);
#endif
}
void aom_highbd_lpf_horizontal_4_dual_sse2(
......@@ -998,11 +949,7 @@ void aom_highbd_lpf_horizontal_4_dual_sse2(
const uint8_t *_thresh0, const uint8_t *_blimit1, const uint8_t *_limit1,
const uint8_t *_thresh1, int bd) {
aom_highbd_lpf_horizontal_4_sse2(s, p, _blimit0, _limit0, _thresh0, bd);
#if CONFIG_PARALLEL_DEBLOCKING
aom_highbd_lpf_horizontal_4_sse2(s + 4, p, _blimit1, _limit1, _thresh1, bd);
#else
aom_highbd_lpf_horizontal_4_sse2(s + 8, p, _blimit1, _limit1, _thresh1, bd);
#endif
}
void aom_highbd_lpf_vertical_4_sse2(uint16_t *s, int p, const uint8_t *blimit,
......@@ -1134,13 +1081,7 @@ void aom_highbd_lpf_vertical_16_dual_sse2(uint16_t *s, int p,
// Transpose 16x16
highbd_transpose8x16(s - 8, s - 8 + 8 * p, p, t_dst, 16);
highbd_transpose8x16(s, s + 8 * p, p, t_dst + 8 * 16, 16);
#if CONFIG_PARALLEL_DEBLOCKING
highbd_lpf_horz_edge_8_8p(t_dst + 8 * 16, 16, blimit, limit, thresh, bd);
#else
aom_highbd_lpf_horizontal_16_dual_sse2(t_dst + 8 * 16, 16, blimit, limit,
thresh, bd);
#endif
// Transpose back
highbd_transpose8x16(t_dst, t_dst + 8 * 16, 16, s - 8, p);
highbd_transpose8x16(t_dst + 8, t_dst + 8 + 8 * 16, 16, s - 8 + 8 * p, p);
......
This diff is collapsed.
......@@ -1856,7 +1856,6 @@ void av1_filter_block_plane_ss11_hor(AV1_COMMON *const cm,
dst->buf = dst0;
}
#if CONFIG_PARALLEL_DEBLOCKING
typedef enum EDGE_DIR { VERT_EDGE = 0, HORZ_EDGE = 1, NUM_EDGE_DIRS } EDGE_DIR;
static const uint32_t av1_prediction_masks[NUM_EDGE_DIRS][BLOCK_SIZES_ALL] = {
// mask for vertical edges filtering
......@@ -2342,7 +2341,6 @@ static void av1_filter_block_plane_horz(
}
}
}
#endif // CONFIG_PARALLEL_DEBLOCKING
void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
struct macroblockd_plane *planes, int start, int stop,
......@@ -2360,35 +2358,11 @@ void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
const int plane_start = 0;
const int plane_end = nplanes;
#endif // CONFIG_LOOPFILTER_LEVEL
#if CONFIG_PARALLEL_DEBLOCKING
const int col_start = 0;
const int col_end = cm->mi_cols;
#endif
int mi_row, mi_col;
int plane;
#if !CONFIG_PARALLEL_DEBLOCKING
for (int i = 0; i < nplanes; ++i)
memset(cm->top_txfm_context[i], TX_32X32, cm->mi_cols << TX_UNIT_WIDE_LOG2);
for (mi_row = start; mi_row < stop; mi_row += cm->seq_params.mib_size) {
MODE_INFO **mi = cm->mi_grid_visible + mi_row * cm->mi_stride;
for (int i = 0; i < nplanes; ++i)
memset(cm->left_txfm_context[i], TX_32X32,
MAX_MIB_SIZE << TX_UNIT_HIGH_LOG2);
for (mi_col = 0; mi_col < cm->mi_cols; mi_col += cm->seq_params.mib_size) {
av1_setup_dst_planes(planes, cm->seq_params.sb_size, frame_buffer, mi_row,
mi_col);
for (plane = plane_start; plane < plane_end; ++plane) {
av1_filter_block_plane_non420_ver(cm, &planes[plane], mi + mi_col,
mi_row, mi_col, plane);
av1_filter_block_plane_non420_hor(cm, &planes[plane], mi + mi_col,
mi_row, mi_col, plane);
}
}
}
#else
// filter all vertical edges in every 64x64 super block
for (mi_row = start; mi_row < stop; mi_row += MAX_MIB_SIZE) {
for (mi_col = col_start; mi_col < col_end; mi_col += MAX_MIB_SIZE) {
......@@ -2410,7 +2384,6 @@ void av1_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
}
}
}
#endif // !CONFIG_PARALLEL_DEBLOCKING
}
void av1_loop_filter_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
......
......@@ -142,7 +142,6 @@ static INLINE void loop_filter_block_plane_hor(
}
#endif
// Row-based multi-threaded loopfilter hook
#if CONFIG_PARALLEL_DEBLOCKING
static int loop_filter_ver_row_worker(AV1LfSync *const lf_sync,
LFWorkerData *const lf_data) {
const int num_planes = lf_data->y_only ? 1 : MAX_MB_PLANE;
......@@ -226,66 +225,6 @@ static int loop_filter_hor_row_worker(AV1LfSync *const lf_sync,
}
return 1;
}
#else // CONFIG_PARALLEL_DEBLOCKING
static int loop_filter_row_worker(AV1LfSync *const lf_sync,
LFWorkerData *const lf_data) {
const int num_planes = lf_data->y_only ? 1 : MAX_MB_PLANE;
const int sb_cols = mi_cols_aligned_to_sb(lf_data->cm) >>
lf_data->cm->seq_params.mib_size_log2;
int mi_row, mi_col;
#if !CONFIG_EXT_PARTITION_TYPES
enum lf_path path = get_loop_filter_path(lf_data->y_only, lf_data->planes);
#endif // !CONFIG_EXT_PARTITION_TYPES
#if CONFIG_EXT_PARTITION
printf(
"STOPPING: This code has not been modified to work with the "
"extended coding unit size experiment");
exit(EXIT_FAILURE);
#endif // CONFIG_EXT_PARTITION
for (mi_row = lf_data->start; mi_row < lf_data->stop;
mi_row += lf_sync->num_workers * lf_data->cm->seq_params.mib_size) {
MODE_INFO **const mi =
lf_data->cm->mi_grid_visible + mi_row * lf_data->cm->mi_stride;
for (mi_col = 0; mi_col < lf_data->cm->mi_cols;
mi_col += lf_data->cm->seq_params.mib_size) {
const int r = mi_row >> lf_data->cm->seq_params.mib_size_log2;
const int c = mi_col >> lf_data->cm->seq_params.mib_size_log2;
#if !CONFIG_EXT_PARTITION_TYPES
LOOP_FILTER_MASK lfm;
#endif
int plane;
sync_read(lf_sync, r, c);
av1_setup_dst_planes(lf_data->planes, lf_data->cm->seq_params.sb_size,
lf_data->frame_buffer, mi_row, mi_col);
#if CONFIG_EXT_PARTITION_TYPES
for (plane = 0; plane < num_planes; ++plane) {
av1_filter_block_plane_non420_ver(lf_data->cm, &lf_data->planes[plane],
mi + mi_col, mi_row, mi_col, plane);
av1_filter_block_plane_non420_hor(lf_data->cm, &lf_data->planes[plane],
mi + mi_col, mi_row, mi_col, plane);
}
#else
av1_setup_mask(lf_data->cm, mi_row, mi_col, mi + mi_col,
lf_data->cm->mi_stride, &lfm);
for (plane = 0; plane < num_planes; ++plane) {
loop_filter_block_plane_ver(lf_data->cm, lf_data->planes, plane,
mi + mi_col, mi_row, mi_col, path, &lfm);
loop_filter_block_plane_hor(lf_data->cm, lf_data->planes, plane,
mi + mi_col, mi_row, mi_col, path, &lfm);
}
#endif // CONFIG_EXT_PARTITION_TYPES
sync_write(lf_sync, r, c, sb_cols);
}
}
return 1;
}
#endif // CONFIG_PARALLEL_DEBLOCKING
static void loop_filter_rows_mt(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
struct macroblockd_plane *planes, int start,
......@@ -313,16 +252,15 @@ static void loop_filter_rows_mt(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
av1_loop_filter_alloc(lf_sync, cm, sb_rows, cm->width, num_workers);
}
// Set up loopfilter thread data.
// The decoder is capping num_workers because it has been observed that
// using more threads on the loopfilter than there are cores will hurt
// performance on Android. This is because the system will only schedule the
// tile decode workers on cores equal to the number of tile columns. Then if
// the decoder tries to use more threads for the loopfilter, it will hurt
// performance because of contention. If the multithreading code changes in
// the future then the number of workers used by the loopfilter should be
// revisited.
#if CONFIG_PARALLEL_DEBLOCKING
// Set up loopfilter thread data.
// The decoder is capping num_workers because it has been observed that
// using more threads on the loopfilter than there are cores will hurt
// performance on Android. This is because the system will only schedule the
// tile decode workers on cores equal to the number of tile columns. Then if
// the decoder tries to use more threads for the loopfilter, it will hurt
// performance because of contention. If the multithreading code changes in
// the future then the number of workers used by the loopfilter should be
// revisited.
// Initialize cur_sb_col to -1 for all SB rows.
memset(lf_sync->cur_sb_col, -1, sizeof(*lf_sync->cur_sb_col) * sb_rows);
......@@ -382,37 +320,6 @@ static void loop_filter_rows_mt(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
for (i = 0; i < num_workers; ++i) {
winterface->sync(&workers[i]);
}
#else // CONFIG_PARALLEL_DEBLOCKING
// Initialize cur_sb_col to -1 for all SB rows.
memset(lf_sync->cur_sb_col, -1, sizeof(*lf_sync->cur_sb_col) * sb_rows);
for (i = 0; i < num_workers; ++i) {
AVxWorker *const worker = &workers[i];
LFWorkerData *const lf_data = &lf_sync->lfdata[i];
worker->hook = (AVxWorkerHook)loop_filter_row_worker;
worker->data1 = lf_sync;
worker->data2 = lf_data;
// Loopfilter data
av1_loop_filter_data_reset(lf_data, frame, cm, planes);
lf_data->start = start + i * cm->seq_params.mib_size;
lf_data->stop = stop;
lf_data->y_only = y_only;
// Start loopfiltering
if (i == num_workers - 1) {
winterface->execute(worker);
} else {
winterface->launch(worker);
}
}
// Wait till all rows are finished
for (i = 0; i < num_workers; ++i) {
winterface->sync(&workers[i]);
}
#endif // CONFIG_PARALLEL_DEBLOCKING
}
void av1_loop_filter_frame_mt(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
......
......@@ -142,7 +142,6 @@ set(CONFIG_OBU_NO_IVF 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_OBU_SIZING 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_OPT_REF_MV 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_PALETTE_THROUGHPUT 1 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_PARALLEL_DEBLOCKING 1 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_Q_ADAPT_PROBS 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_RD_DEBUG 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_RECT_TX_EXT 1 CACHE NUMBER "AV1 experiment flag.")
......
......@@ -57,9 +57,6 @@ macro (fix_experiment_configs)
if (NOT CONFIG_EXT_DELTA_Q)
change_config_and_warn(CONFIG_EXT_DELTA_Q 1 CONFIG_LOOPFILTER_LEVEL)
endif ()
if (NOT CONFIG_PARALLEL_DEBLOCKING)
change_config_and_warn(CONFIG_PARALLEL_DEBLOCKING 1 CONFIG_LOOPFILTER_LEVEL)
endif ()
endif ()
if (CONFIG_TXK_SEL)
......
......@@ -548,17 +548,6 @@ INSTANTIATE_TEST_CASE_P(AVX2, Loop8Test9Param_hbd,
#endif
#endif
#if HAVE_AVX2 && (!CONFIG_PARALLEL_DEBLOCKING)
INSTANTIATE_TEST_CASE_P(AVX2, Loop8Test6Param,
::testing::Values(
#if !CONFIG_DEBLOCK_13TAP // No SIMD implementation for deblock_13tap yet
make_tuple(&aom_lpf_horizontal_16_dual_avx2,
&aom_lpf_horizontal_16_dual_c, 8),
#endif
make_tuple(&aom_lpf_horizontal_16_avx2,
&aom_lpf_horizontal_16_c, 8)));
#endif
#if HAVE_SSE2
const hbddual_loop_param_t kHbdLoop8Test9[] = {
make_tuple(&aom_highbd_lpf_horizontal_4_dual_sse2,
......@@ -590,17 +579,6 @@ const hbddual_loop_param_t kHbdLoop8Test9[] = {
INSTANTIATE_TEST_CASE_P(SSE2, Loop8Test9Param_hbd,
::testing::ValuesIn(kHbdLoop8Test9));
#if !CONFIG_PARALLEL_DEBLOCKING
const hbddual_loop_param_t kLoop8Test9[] = {
make_tuple(&aom_lpf_horizontal_4_dual_sse2, &aom_lpf_horizontal_4_dual_c, 8),
make_tuple(&aom_lpf_horizontal_8_dual_sse2, &aom_lpf_horizontal_8_dual_c, 8),
make_tuple(&aom_lpf_vertical_4_dual_sse2, &aom_lpf_vertical_4_dual_c, 8),
make_tuple(&aom_lpf_vertical_8_dual_sse2, &aom_lpf_vertical_8_dual_c, 8)
};
INSTANTIATE_TEST_CASE_P(SSE2, Loop8Test9Param_lbd,
::testing::ValuesIn(kLoop8Test9));
#endif
#endif // HAVE_SSE2
#if HAVE_AVX2
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment