OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include "webrtc/modules/audio_processing/aec3/render_delay_controller.h" | 11 #include "webrtc/modules/audio_processing/aec3/render_delay_controller.h" |
12 | 12 |
13 #include <algorithm> | 13 #include <algorithm> |
14 #include <memory> | 14 #include <memory> |
15 #include <sstream> | 15 #include <sstream> |
16 #include <string> | 16 #include <string> |
17 #include <vector> | 17 #include <vector> |
18 | 18 |
19 #include "webrtc/base/random.h" | 19 #include "webrtc/base/random.h" |
20 #include "webrtc/modules/audio_processing/aec3/aec3_constants.h" | 20 #include "webrtc/modules/audio_processing/aec3/aec3_common.h" |
21 #include "webrtc/modules/audio_processing/aec3/render_delay_buffer.h" | 21 #include "webrtc/modules/audio_processing/aec3/render_delay_buffer.h" |
22 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h" | 22 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h" |
23 #include "webrtc/modules/audio_processing/test/echo_canceller_test_tools.h" | 23 #include "webrtc/modules/audio_processing/test/echo_canceller_test_tools.h" |
24 #include "webrtc/test/gtest.h" | 24 #include "webrtc/test/gtest.h" |
25 | 25 |
26 namespace webrtc { | 26 namespace webrtc { |
27 namespace { | 27 namespace { |
28 | 28 |
29 std::string ProduceDebugText(int sample_rate_hz) { | 29 std::string ProduceDebugText(int sample_rate_hz) { |
30 std::ostringstream ss; | 30 std::ostringstream ss; |
31 ss << "Sample rate: " << sample_rate_hz; | 31 ss << "Sample rate: " << sample_rate_hz; |
32 return ss.str(); | 32 return ss.str(); |
33 } | 33 } |
34 | 34 |
35 std::string ProduceDebugText(int sample_rate_hz, size_t delay) { | 35 std::string ProduceDebugText(int sample_rate_hz, size_t delay) { |
36 std::ostringstream ss(ProduceDebugText(sample_rate_hz)); | 36 std::ostringstream ss; |
37 ss << ", Delay: " << delay; | 37 ss << ProduceDebugText(sample_rate_hz) << ", Delay: " << delay; |
38 return ss.str(); | 38 return ss.str(); |
39 } | 39 } |
40 | 40 |
41 std::string ProduceDebugText(int sample_rate_hz, | 41 std::string ProduceDebugText(int sample_rate_hz, |
42 size_t delay, | 42 size_t delay, |
43 size_t max_jitter) { | 43 size_t max_jitter) { |
44 std::ostringstream ss(ProduceDebugText(sample_rate_hz, delay)); | 44 std::ostringstream ss; |
45 ss << ", Max Api call jitter: " << max_jitter; | 45 ss << ProduceDebugText(sample_rate_hz, delay) |
| 46 << ", Max Api call jitter: " << max_jitter; |
46 return ss.str(); | 47 return ss.str(); |
47 } | 48 } |
48 | 49 |
49 constexpr size_t kMaxApiCallJitter = 30; | 50 constexpr size_t kMaxApiCallJitter = 30; |
50 | 51 |
51 } // namespace | 52 } // namespace |
52 | 53 |
53 // Verifies the output of GetDelay when there are no AnalyzeRender calls. | 54 // Verifies the output of GetDelay when there are no AnalyzeRender calls. |
54 TEST(RenderDelayController, NoRenderSignal) { | 55 TEST(RenderDelayController, NoRenderSignal) { |
55 std::vector<float> block(kBlockSize, 0.f); | 56 std::vector<float> block(kBlockSize, 0.f); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
104 } | 105 } |
105 | 106 |
106 // Verifies that the RenderDelayController is able to align the signals for | 107 // Verifies that the RenderDelayController is able to align the signals for |
107 // simple timeshifts between the signals. | 108 // simple timeshifts between the signals. |
108 TEST(RenderDelayController, Alignment) { | 109 TEST(RenderDelayController, Alignment) { |
109 Random random_generator(42U); | 110 Random random_generator(42U); |
110 std::vector<float> render_block(kBlockSize, 0.f); | 111 std::vector<float> render_block(kBlockSize, 0.f); |
111 std::vector<float> capture_block(kBlockSize, 0.f); | 112 std::vector<float> capture_block(kBlockSize, 0.f); |
112 size_t delay_blocks = 0; | 113 size_t delay_blocks = 0; |
113 for (auto rate : {8000, 16000, 32000, 48000}) { | 114 for (auto rate : {8000, 16000, 32000, 48000}) { |
114 for (size_t delay_samples : {0, 50, 150, 200, 800, 4000}) { | 115 for (size_t delay_samples : {15, 50, 150, 200, 800, 4000}) { |
115 SCOPED_TRACE(ProduceDebugText(rate, delay_samples)); | 116 SCOPED_TRACE(ProduceDebugText(rate, delay_samples)); |
116 std::unique_ptr<RenderDelayBuffer> render_delay_buffer( | 117 std::unique_ptr<RenderDelayBuffer> render_delay_buffer( |
117 RenderDelayBuffer::Create(250, NumBandsForRate(rate), | 118 RenderDelayBuffer::Create(250, NumBandsForRate(rate), |
118 kMaxApiCallJitter)); | 119 kMaxApiCallJitter)); |
119 std::unique_ptr<RenderDelayController> delay_controller( | 120 std::unique_ptr<RenderDelayController> delay_controller( |
120 RenderDelayController::Create(rate, *render_delay_buffer)); | 121 RenderDelayController::Create(rate, *render_delay_buffer)); |
121 DelayBuffer<float> signal_delay_buffer(delay_samples); | 122 DelayBuffer<float> signal_delay_buffer(delay_samples); |
122 for (size_t k = 0; k < (300 + delay_samples / kBlockSize); ++k) { | 123 for (size_t k = 0; k < (400 + delay_samples / kBlockSize); ++k) { |
123 RandomizeSampleVector(&random_generator, render_block); | 124 RandomizeSampleVector(&random_generator, render_block); |
124 signal_delay_buffer.Delay(render_block, capture_block); | 125 signal_delay_buffer.Delay(render_block, capture_block); |
125 EXPECT_TRUE(delay_controller->AnalyzeRender(render_block)); | 126 EXPECT_TRUE(delay_controller->AnalyzeRender(render_block)); |
126 delay_blocks = delay_controller->GetDelay(capture_block); | 127 delay_blocks = delay_controller->GetDelay(capture_block); |
127 } | 128 } |
128 | 129 |
129 constexpr int kDelayHeadroomBlocks = 1; | 130 constexpr int kDelayHeadroomBlocks = 1; |
130 size_t expected_delay_blocks = | 131 size_t expected_delay_blocks = |
131 std::max(0, static_cast<int>(delay_samples / kBlockSize) - | 132 std::max(0, static_cast<int>(delay_samples / kBlockSize) - |
132 kDelayHeadroomBlocks); | 133 kDelayHeadroomBlocks); |
(...skipping 12 matching lines...) Expand all Loading... |
145 } | 146 } |
146 } | 147 } |
147 | 148 |
148 // Verifies that the RenderDelayController is able to align the signals for | 149 // Verifies that the RenderDelayController is able to align the signals for |
149 // simple timeshifts between the signals when there is jitter in the API calls. | 150 // simple timeshifts between the signals when there is jitter in the API calls. |
150 TEST(RenderDelayController, AlignmentWithJitter) { | 151 TEST(RenderDelayController, AlignmentWithJitter) { |
151 Random random_generator(42U); | 152 Random random_generator(42U); |
152 std::vector<float> render_block(kBlockSize, 0.f); | 153 std::vector<float> render_block(kBlockSize, 0.f); |
153 std::vector<float> capture_block(kBlockSize, 0.f); | 154 std::vector<float> capture_block(kBlockSize, 0.f); |
154 for (auto rate : {8000, 16000, 32000, 48000}) { | 155 for (auto rate : {8000, 16000, 32000, 48000}) { |
155 for (size_t delay_samples : {0, 50, 800}) { | 156 for (size_t delay_samples : {15, 50, 800}) { |
156 for (size_t max_jitter : {1, 9, 20}) { | 157 for (size_t max_jitter : {1, 9, 20}) { |
157 size_t delay_blocks = 0; | 158 size_t delay_blocks = 0; |
158 SCOPED_TRACE(ProduceDebugText(rate, delay_samples, max_jitter)); | 159 SCOPED_TRACE(ProduceDebugText(rate, delay_samples, max_jitter)); |
159 std::unique_ptr<RenderDelayBuffer> render_delay_buffer( | 160 std::unique_ptr<RenderDelayBuffer> render_delay_buffer( |
160 RenderDelayBuffer::Create(250, NumBandsForRate(rate), max_jitter)); | 161 RenderDelayBuffer::Create(250, NumBandsForRate(rate), max_jitter)); |
161 std::unique_ptr<RenderDelayController> delay_controller( | 162 std::unique_ptr<RenderDelayController> delay_controller( |
162 RenderDelayController::Create(rate, *render_delay_buffer)); | 163 RenderDelayController::Create(rate, *render_delay_buffer)); |
163 DelayBuffer<float> signal_delay_buffer(delay_samples); | 164 DelayBuffer<float> signal_delay_buffer(delay_samples); |
164 for (size_t j = 0; | 165 for (size_t j = 0; |
165 j < (300 + delay_samples / kBlockSize) / max_jitter + 1; ++j) { | 166 j < (300 + delay_samples / kBlockSize) / max_jitter + 1; ++j) { |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
253 kMaxApiCallJitter)); | 254 kMaxApiCallJitter)); |
254 EXPECT_DEATH(std::unique_ptr<RenderDelayController>( | 255 EXPECT_DEATH(std::unique_ptr<RenderDelayController>( |
255 RenderDelayController::Create(rate, *render_delay_buffer)), | 256 RenderDelayController::Create(rate, *render_delay_buffer)), |
256 ""); | 257 ""); |
257 } | 258 } |
258 } | 259 } |
259 | 260 |
260 #endif | 261 #endif |
261 | 262 |
262 } // namespace webrtc | 263 } // namespace webrtc |
OLD | NEW |