generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

vp9: Simplify the logic in denoiser SSE2 code.

Browse Source 
Block size passed into denoiser filter is always >= BLOCK_8X8 (in
vp9_pick_inter_mode), it is not necessary to check smaller block
size. Passed the bitexact test on clips with different resolutions and
noise levels.

Change-Id: I19fa3195d18c27d9e5de60dc11cff1522ef3714e
This commit is contained in:
JackyChen 2016-04-25 23:52:19 -07:00
parent b7e8b3cbb6
commit 1a53c0c9e1
3 changed files with 22 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/vpx_temporal_svc_encoder.c
View File

@ -715,7 +715,7 @@ int main(int argc, char **argv) {
vpx_codec_control(&codec, VP8E_SET_CPUUSED, speed); vpx_codec_control(&codec, VP8E_SET_CPUUSED, speed);
vpx_codec_control(&codec, VP9E_SET_AQ_MODE, 3); vpx_codec_control(&codec, VP9E_SET_AQ_MODE, 3);
vpx_codec_control(&codec, VP9E_SET_FRAME_PERIODIC_BOOST, 0); vpx_codec_control(&codec, VP9E_SET_FRAME_PERIODIC_BOOST, 0);
vpx_codec_control(&codec, VP9E_SET_NOISE_SENSITIVITY, 0); vpx_codec_control(&codec, VP9E_SET_NOISE_SENSITIVITY, kDenoiserOff);
vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1); vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
vpx_codec_control(&codec, VP9E_SET_TUNE_CONTENT, 0); vpx_codec_control(&codec, VP9E_SET_TUNE_CONTENT, 0);
vpx_codec_control(&codec, VP9E_SET_TILE_COLUMNS, (cfg.g_threads >> 1)); vpx_codec_control(&codec, VP9E_SET_TILE_COLUMNS, (cfg.g_threads >> 1));

7
test/vp9_denoiser_sse2_test.cc
View File

@ -94,8 +94,7 @@ TEST_P(VP9DenoiserTest, BitexactCheck) {
// Test for all block size. // Test for all block size.
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
SSE2, VP9DenoiserTest, SSE2, VP9DenoiserTest,
::testing::Values(BLOCK_4X4, BLOCK_4X8, BLOCK_8X4, BLOCK_8X8, ::testing::Values(BLOCK_8X8, BLOCK_8X16, BLOCK_16X8, BLOCK_16X16,
BLOCK_8X16, BLOCK_16X8, BLOCK_16X16, BLOCK_16X32, BLOCK_16X32, BLOCK_32X16, BLOCK_32X32, BLOCK_32X64,
BLOCK_32X16, BLOCK_32X32, BLOCK_32X64, BLOCK_64X32, BLOCK_64X32, BLOCK_64X64));
BLOCK_64X64));
} // namespace } // namespace

66
vp9/encoder/x86/vp9_denoiser_sse2.c
View File

@ -125,7 +125,7 @@ static INLINE __m128i vp9_denoiser_adj_16x1_sse2(
return acc_diff; return acc_diff;
} }
// Denoiser for 4xM and 8xM blocks. // Denoise 8x8 and 8x16 blocks.
static int vp9_denoiser_NxM_sse2_small( static int vp9_denoiser_NxM_sse2_small(
const uint8_t *sig, int sig_stride, const uint8_t *mc_running_avg_y, const uint8_t *sig, int sig_stride, const uint8_t *mc_running_avg_y,
int mc_avg_y_stride, uint8_t *running_avg_y, int avg_y_stride, int mc_avg_y_stride, uint8_t *running_avg_y, int avg_y_stride,
@ -147,9 +147,8 @@ static int vp9_denoiser_NxM_sse2_small(
const __m128i l32 = _mm_set1_epi8(2); const __m128i l32 = _mm_set1_epi8(2);
// Difference between level 2 and level 1 is 1. // Difference between level 2 and level 1 is 1.
const __m128i l21 = _mm_set1_epi8(1); const __m128i l21 = _mm_set1_epi8(1);
const uint8_t shift = (width == 4) ? 2 : 1;
for (r = 0; r < ((4 << b_height_log2_lookup[bs]) >> shift); ++r) { for (r = 0; r < ((4 << b_height_log2_lookup[bs]) >> 1); ++r) {
memcpy(sig_buffer[r], sig, width); memcpy(sig_buffer[r], sig, width);
memcpy(sig_buffer[r] + width, sig + sig_stride, width); memcpy(sig_buffer[r] + width, sig + sig_stride, width);
memcpy(mc_running_buffer[r], mc_running_avg_y, width); memcpy(mc_running_buffer[r], mc_running_avg_y, width);
@ -157,18 +156,6 @@ static int vp9_denoiser_NxM_sse2_small(
mc_running_avg_y + mc_avg_y_stride, width); mc_running_avg_y + mc_avg_y_stride, width);
memcpy(running_buffer[r], running_avg_y, width); memcpy(running_buffer[r], running_avg_y, width);
memcpy(running_buffer[r] + width, running_avg_y + avg_y_stride, width); memcpy(running_buffer[r] + width, running_avg_y + avg_y_stride, width);
if (width == 4) {
memcpy(sig_buffer[r] + width * 2, sig + sig_stride * 2, width);
memcpy(sig_buffer[r] + width * 3, sig + sig_stride * 3, width);
memcpy(mc_running_buffer[r] + width * 2,
mc_running_avg_y + mc_avg_y_stride * 2, width);
memcpy(mc_running_buffer[r] + width * 3,
mc_running_avg_y + mc_avg_y_stride * 3, width);
memcpy(running_buffer[r] + width * 2,
running_avg_y + avg_y_stride * 2, width);
memcpy(running_buffer[r] + width * 3,
running_avg_y + avg_y_stride * 3, width);
}
acc_diff = vp9_denoiser_16x1_sse2(sig_buffer[r], acc_diff = vp9_denoiser_16x1_sse2(sig_buffer[r],
mc_running_buffer[r], mc_running_buffer[r],
running_buffer[r], running_buffer[r],
@ -176,16 +163,10 @@ static int vp9_denoiser_NxM_sse2_small(
&l3, &l32, &l21, acc_diff); &l3, &l32, &l21, acc_diff);
memcpy(running_avg_y, running_buffer[r], width); memcpy(running_avg_y, running_buffer[r], width);
memcpy(running_avg_y + avg_y_stride, running_buffer[r] + width, width); memcpy(running_avg_y + avg_y_stride, running_buffer[r] + width, width);
if (width == 4) {
memcpy(running_avg_y + avg_y_stride * 2,
running_buffer[r] + width * 2, width);
memcpy(running_avg_y + avg_y_stride * 3,
running_buffer[r] + width * 3, width);
}
// Update pointers for next iteration. // Update pointers for next iteration.
sig += (sig_stride << shift); sig += (sig_stride << 1);
mc_running_avg_y += (mc_avg_y_stride << shift); mc_running_avg_y += (mc_avg_y_stride << 1);
running_avg_y += (avg_y_stride << shift); running_avg_y += (avg_y_stride << 1);
} }
{ {
@ -208,21 +189,15 @@ static int vp9_denoiser_NxM_sse2_small(
if (delta < 4) { if (delta < 4) {
const __m128i k_delta = _mm_set1_epi8(delta); const __m128i k_delta = _mm_set1_epi8(delta);
running_avg_y -= avg_y_stride * (4 << b_height_log2_lookup[bs]); running_avg_y -= avg_y_stride * (4 << b_height_log2_lookup[bs]);
for (r = 0; r < ((4 << b_height_log2_lookup[bs]) >> shift); ++r) { for (r = 0; r < ((4 << b_height_log2_lookup[bs]) >> 1); ++r) {
acc_diff = vp9_denoiser_adj_16x1_sse2( acc_diff = vp9_denoiser_adj_16x1_sse2(
sig_buffer[r], mc_running_buffer[r], running_buffer[r], sig_buffer[r], mc_running_buffer[r], running_buffer[r],
k_0, k_delta, acc_diff); k_0, k_delta, acc_diff);
memcpy(running_avg_y, running_buffer[r], width); memcpy(running_avg_y, running_buffer[r], width);
memcpy(running_avg_y + avg_y_stride, memcpy(running_avg_y + avg_y_stride,
running_buffer[r] + width, width); running_buffer[r] + width, width);
if (width == 4) {
memcpy(running_avg_y + avg_y_stride * 2,
running_buffer[r] + width * 2, width);
memcpy(running_avg_y + avg_y_stride * 3,
running_buffer[r] + width * 3, width);
}
// Update pointers for next iteration. // Update pointers for next iteration.
running_avg_y += (avg_y_stride << shift); running_avg_y += (avg_y_stride << 1);
} }
sum_diff = sum_diff_16x1(acc_diff); sum_diff = sum_diff_16x1(acc_diff);
if (abs(sum_diff) > sum_diff_thresh) { if (abs(sum_diff) > sum_diff_thresh) {
@ -236,7 +211,7 @@ static int vp9_denoiser_NxM_sse2_small(
return FILTER_BLOCK; return FILTER_BLOCK;
} }
// Denoiser for 16xM, 32xM and 64xM blocks // Denoise 16x16, 16x32, 32x16, 32x32, 32x64, 64x32 and 64x64 blocks.
static int vp9_denoiser_NxM_sse2_big(const uint8_t *sig, int sig_stride, static int vp9_denoiser_NxM_sse2_big(const uint8_t *sig, int sig_stride,
const uint8_t *mc_running_avg_y, const uint8_t *mc_running_avg_y,
int mc_avg_y_stride, int mc_avg_y_stride,
@ -349,26 +324,21 @@ int vp9_denoiser_filter_sse2(const uint8_t *sig, int sig_stride,
int increase_denoising, int increase_denoising,
BLOCK_SIZE bs, BLOCK_SIZE bs,
int motion_magnitude) { int motion_magnitude) {
if (bs == BLOCK_4X4 || bs == BLOCK_4X8) { // Rank by frequency of the block type to have an early termination.
return vp9_denoiser_NxM_sse2_small(sig, sig_stride, if (bs == BLOCK_16X16 || bs == BLOCK_32X32 || bs == BLOCK_64X64 ||
mc_avg, mc_avg_stride, bs == BLOCK_16X32 || bs == BLOCK_16X8 || bs == BLOCK_32X16 ||
avg, avg_stride, bs == BLOCK_32X64 || bs == BLOCK_64X32) {
increase_denoising,
bs, motion_magnitude, 4);
} else if (bs == BLOCK_8X4 || bs == BLOCK_8X8 || bs == BLOCK_8X16) {
return vp9_denoiser_NxM_sse2_small(sig, sig_stride,
mc_avg, mc_avg_stride,
avg, avg_stride,
increase_denoising,
bs, motion_magnitude, 8);
} else if (bs == BLOCK_16X8 || bs == BLOCK_16X16 || bs == BLOCK_16X32 ||
bs == BLOCK_32X16|| bs == BLOCK_32X32 || bs == BLOCK_32X64 ||
bs == BLOCK_64X32 || bs == BLOCK_64X64) {
return vp9_denoiser_NxM_sse2_big(sig, sig_stride, return vp9_denoiser_NxM_sse2_big(sig, sig_stride,
mc_avg, mc_avg_stride, mc_avg, mc_avg_stride,
avg, avg_stride, avg, avg_stride,
increase_denoising, increase_denoising,
bs, motion_magnitude); bs, motion_magnitude);
} else if (bs == BLOCK_8X8 || bs == BLOCK_8X16) {
return vp9_denoiser_NxM_sse2_small(sig, sig_stride,
mc_avg, mc_avg_stride,
avg, avg_stride,
increase_denoising,
bs, motion_magnitude, 8);
} else { } else {
return COPY_BLOCK; return COPY_BLOCK;
} }