jackychen | 67e94fb | 2016-01-11 21:34:07 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include <string.h> |
| 12 | |
| 13 | #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" |
| 14 | #include "webrtc/modules/video_processing/include/video_processing.h" |
| 15 | #include "webrtc/modules/video_processing/test/video_processing_unittest.h" |
| 16 | #include "webrtc/modules/video_processing/video_denoiser.h" |
nisse | 2080196 | 2016-02-26 06:40:39 -0800 | [diff] [blame^] | 17 | #include "webrtc/test/frame_utils.h" |
jackychen | 67e94fb | 2016-01-11 21:34:07 -0800 | [diff] [blame] | 18 | |
| 19 | namespace webrtc { |
| 20 | |
| 21 | TEST_F(VideoProcessingTest, CopyMem) { |
| 22 | rtc::scoped_ptr<DenoiserFilter> df_c(DenoiserFilter::Create(false)); |
| 23 | rtc::scoped_ptr<DenoiserFilter> df_sse_neon(DenoiserFilter::Create(true)); |
| 24 | uint8_t src[16 * 16], dst[16 * 16]; |
| 25 | for (int i = 0; i < 16; ++i) { |
| 26 | for (int j = 0; j < 16; ++j) { |
| 27 | src[i * 16 + j] = i * 16 + j; |
| 28 | } |
| 29 | } |
| 30 | |
| 31 | memset(dst, 0, 8 * 8); |
| 32 | df_c->CopyMem8x8(src, 8, dst, 8); |
| 33 | EXPECT_EQ(0, memcmp(src, dst, 8 * 8)); |
| 34 | |
| 35 | memset(dst, 0, 16 * 16); |
| 36 | df_c->CopyMem16x16(src, 16, dst, 16); |
| 37 | EXPECT_EQ(0, memcmp(src, dst, 16 * 16)); |
| 38 | |
| 39 | memset(dst, 0, 8 * 8); |
| 40 | df_sse_neon->CopyMem16x16(src, 8, dst, 8); |
| 41 | EXPECT_EQ(0, memcmp(src, dst, 8 * 8)); |
| 42 | |
| 43 | memset(dst, 0, 16 * 16); |
| 44 | df_sse_neon->CopyMem16x16(src, 16, dst, 16); |
| 45 | EXPECT_EQ(0, memcmp(src, dst, 16 * 16)); |
| 46 | } |
| 47 | |
| 48 | TEST_F(VideoProcessingTest, Variance) { |
| 49 | rtc::scoped_ptr<DenoiserFilter> df_c(DenoiserFilter::Create(false)); |
| 50 | rtc::scoped_ptr<DenoiserFilter> df_sse_neon(DenoiserFilter::Create(true)); |
| 51 | uint8_t src[16 * 16], dst[16 * 16]; |
| 52 | uint32_t sum = 0, sse = 0, var; |
| 53 | for (int i = 0; i < 16; ++i) { |
| 54 | for (int j = 0; j < 16; ++j) { |
| 55 | src[i * 16 + j] = i * 16 + j; |
| 56 | } |
| 57 | } |
| 58 | // Compute the 16x8 variance of the 16x16 block. |
| 59 | for (int i = 0; i < 8; ++i) { |
| 60 | for (int j = 0; j < 16; ++j) { |
| 61 | sum += (i * 32 + j); |
| 62 | sse += (i * 32 + j) * (i * 32 + j); |
| 63 | } |
| 64 | } |
| 65 | var = sse - ((sum * sum) >> 7); |
| 66 | memset(dst, 0, 16 * 16); |
| 67 | EXPECT_EQ(var, df_c->Variance16x8(src, 16, dst, 16, &sse)); |
| 68 | EXPECT_EQ(var, df_sse_neon->Variance16x8(src, 16, dst, 16, &sse)); |
| 69 | } |
| 70 | |
| 71 | TEST_F(VideoProcessingTest, MbDenoise) { |
| 72 | rtc::scoped_ptr<DenoiserFilter> df_c(DenoiserFilter::Create(false)); |
| 73 | rtc::scoped_ptr<DenoiserFilter> df_sse_neon(DenoiserFilter::Create(true)); |
| 74 | uint8_t running_src[16 * 16], src[16 * 16], dst[16 * 16], dst_ref[16 * 16]; |
| 75 | |
| 76 | // Test case: |diff| <= |3 + shift_inc1| |
| 77 | for (int i = 0; i < 16; ++i) { |
| 78 | for (int j = 0; j < 16; ++j) { |
| 79 | running_src[i * 16 + j] = i * 11 + j; |
| 80 | src[i * 16 + j] = i * 11 + j + 2; |
| 81 | dst_ref[i * 16 + j] = running_src[i * 16 + j]; |
| 82 | } |
| 83 | } |
| 84 | memset(dst, 0, 16 * 16); |
| 85 | df_c->MbDenoise(running_src, 16, dst, 16, src, 16, 0, 1); |
| 86 | EXPECT_EQ(0, memcmp(dst, dst_ref, 16 * 16)); |
| 87 | |
| 88 | // Test case: |diff| >= |4 + shift_inc1| |
| 89 | for (int i = 0; i < 16; ++i) { |
| 90 | for (int j = 0; j < 16; ++j) { |
| 91 | running_src[i * 16 + j] = i * 11 + j; |
| 92 | src[i * 16 + j] = i * 11 + j + 5; |
| 93 | dst_ref[i * 16 + j] = src[i * 16 + j] - 2; |
| 94 | } |
| 95 | } |
| 96 | memset(dst, 0, 16 * 16); |
| 97 | df_c->MbDenoise(running_src, 16, dst, 16, src, 16, 0, 1); |
| 98 | EXPECT_EQ(0, memcmp(dst, dst_ref, 16 * 16)); |
| 99 | memset(dst, 0, 16 * 16); |
| 100 | df_sse_neon->MbDenoise(running_src, 16, dst, 16, src, 16, 0, 1); |
| 101 | EXPECT_EQ(0, memcmp(dst, dst_ref, 16 * 16)); |
| 102 | |
| 103 | // Test case: |diff| >= 8 |
| 104 | for (int i = 0; i < 16; ++i) { |
| 105 | for (int j = 0; j < 16; ++j) { |
| 106 | running_src[i * 16 + j] = i * 11 + j; |
| 107 | src[i * 16 + j] = i * 11 + j + 8; |
| 108 | dst_ref[i * 16 + j] = src[i * 16 + j] - 6; |
| 109 | } |
| 110 | } |
| 111 | memset(dst, 0, 16 * 16); |
| 112 | df_c->MbDenoise(running_src, 16, dst, 16, src, 16, 0, 1); |
| 113 | EXPECT_EQ(0, memcmp(dst, dst_ref, 16 * 16)); |
| 114 | memset(dst, 0, 16 * 16); |
| 115 | df_sse_neon->MbDenoise(running_src, 16, dst, 16, src, 16, 0, 1); |
| 116 | EXPECT_EQ(0, memcmp(dst, dst_ref, 16 * 16)); |
| 117 | |
| 118 | // Test case: |diff| > 15 |
| 119 | for (int i = 0; i < 16; ++i) { |
| 120 | for (int j = 0; j < 16; ++j) { |
| 121 | running_src[i * 16 + j] = i * 11 + j; |
| 122 | src[i * 16 + j] = i * 11 + j + 16; |
| 123 | } |
| 124 | } |
| 125 | memset(dst, 0, 16 * 16); |
| 126 | DenoiserDecision decision = |
| 127 | df_c->MbDenoise(running_src, 16, dst, 16, src, 16, 0, 1); |
| 128 | EXPECT_EQ(COPY_BLOCK, decision); |
| 129 | decision = df_sse_neon->MbDenoise(running_src, 16, dst, 16, src, 16, 0, 1); |
| 130 | EXPECT_EQ(COPY_BLOCK, decision); |
| 131 | } |
| 132 | |
| 133 | TEST_F(VideoProcessingTest, Denoiser) { |
| 134 | // Create pure C denoiser. |
| 135 | VideoDenoiser denoiser_c(false); |
| 136 | // Create SSE or NEON denoiser. |
| 137 | VideoDenoiser denoiser_sse_neon(true); |
| 138 | VideoFrame denoised_frame_c; |
| 139 | VideoFrame denoised_frame_sse_neon; |
| 140 | |
| 141 | rtc::scoped_ptr<uint8_t[]> video_buffer(new uint8_t[frame_length_]); |
| 142 | while (fread(video_buffer.get(), 1, frame_length_, source_file_) == |
| 143 | frame_length_) { |
| 144 | // Using ConvertToI420 to add stride to the image. |
| 145 | EXPECT_EQ(0, ConvertToI420(kI420, video_buffer.get(), 0, 0, width_, height_, |
| 146 | 0, kVideoRotation_0, &video_frame_)); |
| 147 | |
| 148 | denoiser_c.DenoiseFrame(video_frame_, &denoised_frame_c); |
| 149 | denoiser_sse_neon.DenoiseFrame(video_frame_, &denoised_frame_sse_neon); |
| 150 | |
| 151 | // Denoising results should be the same for C and SSE/NEON denoiser. |
nisse | 2080196 | 2016-02-26 06:40:39 -0800 | [diff] [blame^] | 152 | ASSERT_TRUE(test::FramesEqual(denoised_frame_c, denoised_frame_sse_neon)); |
jackychen | 67e94fb | 2016-01-11 21:34:07 -0800 | [diff] [blame] | 153 | } |
| 154 | ASSERT_NE(0, feof(source_file_)) << "Error reading source file"; |
| 155 | } |
| 156 | |
| 157 | } // namespace webrtc |