OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 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 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 void AimAndVerify(NonlinearBeamformer* bf, float target_azimuth_radians) { | 50 void AimAndVerify(NonlinearBeamformer* bf, float target_azimuth_radians) { |
51 bf->AimAt(AzimuthToSphericalPoint(target_azimuth_radians)); | 51 bf->AimAt(AzimuthToSphericalPoint(target_azimuth_radians)); |
52 Verify(bf, target_azimuth_radians); | 52 Verify(bf, target_azimuth_radians); |
53 } | 53 } |
54 | 54 |
55 // Bitexactness test code. | 55 // Bitexactness test code. |
56 const size_t kNumFramesToProcess = 1000; | 56 const size_t kNumFramesToProcess = 1000; |
57 | 57 |
58 void ProcessOneFrame(int sample_rate_hz, | 58 void ProcessOneFrame(int sample_rate_hz, |
59 AudioBuffer* capture_audio_buffer, | 59 AudioBuffer* capture_audio_buffer, |
60 NonlinearBeamformer* beamformer) { | 60 Beamformer<float>* beamformer) { |
61 if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) { | 61 if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) { |
62 capture_audio_buffer->SplitIntoFrequencyBands(); | 62 capture_audio_buffer->SplitIntoFrequencyBands(); |
63 } | 63 } |
64 | 64 |
65 beamformer->AnalyzeChunk(*capture_audio_buffer->split_data_f()); | 65 beamformer->ProcessChunk(*capture_audio_buffer->split_data_f(), |
| 66 capture_audio_buffer->split_data_f()); |
66 capture_audio_buffer->set_num_channels(1); | 67 capture_audio_buffer->set_num_channels(1); |
67 beamformer->PostFilter(capture_audio_buffer->split_data_f()); | |
68 | 68 |
69 if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) { | 69 if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) { |
70 capture_audio_buffer->MergeFrequencyBands(); | 70 capture_audio_buffer->MergeFrequencyBands(); |
71 } | 71 } |
72 } | 72 } |
73 | 73 |
74 int BeamformerSampleRate(int sample_rate_hz) { | 74 int BeamformerSampleRate(int sample_rate_hz) { |
75 return (sample_rate_hz > AudioProcessing::kSampleRate16kHz | 75 return (sample_rate_hz > AudioProcessing::kSampleRate16kHz |
76 ? AudioProcessing::kSampleRate16kHz | 76 ? AudioProcessing::kSampleRate16kHz |
77 : sample_rate_hz); | 77 : sample_rate_hz); |
78 } | 78 } |
79 | 79 |
80 void RunBitExactnessTest(int sample_rate_hz, | 80 void RunBitExactnessTest(int sample_rate_hz, |
81 const std::vector<Point>& array_geometry, | 81 const std::vector<Point>& array_geometry, |
82 const SphericalPointf& target_direction, | 82 const SphericalPointf& target_direction, |
83 rtc::ArrayView<const float> output_reference) { | 83 rtc::ArrayView<const float> output_reference) { |
84 NonlinearBeamformer beamformer(array_geometry, 1u, target_direction); | 84 NonlinearBeamformer beamformer(array_geometry, target_direction); |
85 beamformer.Initialize(AudioProcessing::kChunkSizeMs, | 85 beamformer.Initialize(AudioProcessing::kChunkSizeMs, |
86 BeamformerSampleRate(sample_rate_hz)); | 86 BeamformerSampleRate(sample_rate_hz)); |
87 | 87 |
88 const StreamConfig capture_config(sample_rate_hz, array_geometry.size(), | 88 const StreamConfig capture_config(sample_rate_hz, array_geometry.size(), |
89 false); | 89 false); |
90 AudioBuffer capture_buffer( | 90 AudioBuffer capture_buffer( |
91 capture_config.num_frames(), capture_config.num_channels(), | 91 capture_config.num_frames(), capture_config.num_channels(), |
92 capture_config.num_frames(), capture_config.num_channels(), | 92 capture_config.num_frames(), capture_config.num_channels(), |
93 capture_config.num_frames()); | 93 capture_config.num_frames()); |
94 test::InputAudioFile capture_file( | 94 test::InputAudioFile capture_file( |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
152 const SphericalPointf TargetDirection2(static_cast<float>(M_PI) / 2.f, | 152 const SphericalPointf TargetDirection2(static_cast<float>(M_PI) / 2.f, |
153 1.f, | 153 1.f, |
154 2.f); | 154 2.f); |
155 | 155 |
156 } // namespace | 156 } // namespace |
157 | 157 |
158 TEST(NonlinearBeamformerTest, AimingModifiesBeam) { | 158 TEST(NonlinearBeamformerTest, AimingModifiesBeam) { |
159 std::vector<Point> array_geometry; | 159 std::vector<Point> array_geometry; |
160 array_geometry.push_back(Point(-0.025f, 0.f, 0.f)); | 160 array_geometry.push_back(Point(-0.025f, 0.f, 0.f)); |
161 array_geometry.push_back(Point(0.025f, 0.f, 0.f)); | 161 array_geometry.push_back(Point(0.025f, 0.f, 0.f)); |
162 NonlinearBeamformer bf(array_geometry, 1u); | 162 NonlinearBeamformer bf(array_geometry); |
163 bf.Initialize(kChunkSizeMs, kSampleRateHz); | 163 bf.Initialize(kChunkSizeMs, kSampleRateHz); |
164 // The default constructor parameter sets the target angle to PI / 2. | 164 // The default constructor parameter sets the target angle to PI / 2. |
165 Verify(&bf, static_cast<float>(M_PI) / 2.f); | 165 Verify(&bf, static_cast<float>(M_PI) / 2.f); |
166 AimAndVerify(&bf, static_cast<float>(M_PI) / 3.f); | 166 AimAndVerify(&bf, static_cast<float>(M_PI) / 3.f); |
167 AimAndVerify(&bf, 3.f * static_cast<float>(M_PI) / 4.f); | 167 AimAndVerify(&bf, 3.f * static_cast<float>(M_PI) / 4.f); |
168 AimAndVerify(&bf, static_cast<float>(M_PI) / 6.f); | 168 AimAndVerify(&bf, static_cast<float>(M_PI) / 6.f); |
169 AimAndVerify(&bf, static_cast<float>(M_PI)); | 169 AimAndVerify(&bf, static_cast<float>(M_PI)); |
170 } | 170 } |
171 | 171 |
172 TEST(NonlinearBeamformerTest, InterfAnglesTakeAmbiguityIntoAccount) { | 172 TEST(NonlinearBeamformerTest, InterfAnglesTakeAmbiguityIntoAccount) { |
173 { | 173 { |
174 // For linear arrays there is ambiguity. | 174 // For linear arrays there is ambiguity. |
175 std::vector<Point> array_geometry; | 175 std::vector<Point> array_geometry; |
176 array_geometry.push_back(Point(-0.1f, 0.f, 0.f)); | 176 array_geometry.push_back(Point(-0.1f, 0.f, 0.f)); |
177 array_geometry.push_back(Point(0.f, 0.f, 0.f)); | 177 array_geometry.push_back(Point(0.f, 0.f, 0.f)); |
178 array_geometry.push_back(Point(0.2f, 0.f, 0.f)); | 178 array_geometry.push_back(Point(0.2f, 0.f, 0.f)); |
179 NonlinearBeamformer bf(array_geometry, 1u); | 179 NonlinearBeamformer bf(array_geometry); |
180 bf.Initialize(kChunkSizeMs, kSampleRateHz); | 180 bf.Initialize(kChunkSizeMs, kSampleRateHz); |
181 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 181 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
182 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, | 182 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, |
183 bf.interf_angles_radians_[0]); | 183 bf.interf_angles_radians_[0]); |
184 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, | 184 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, |
185 bf.interf_angles_radians_[1]); | 185 bf.interf_angles_radians_[1]); |
186 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); | 186 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); |
187 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 187 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
188 EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f, | 188 EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f, |
189 bf.interf_angles_radians_[0]); | 189 bf.interf_angles_radians_[0]); |
190 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); | 190 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); |
191 } | 191 } |
192 { | 192 { |
193 // For planar arrays with normal in the xy-plane there is ambiguity. | 193 // For planar arrays with normal in the xy-plane there is ambiguity. |
194 std::vector<Point> array_geometry; | 194 std::vector<Point> array_geometry; |
195 array_geometry.push_back(Point(-0.1f, 0.f, 0.f)); | 195 array_geometry.push_back(Point(-0.1f, 0.f, 0.f)); |
196 array_geometry.push_back(Point(0.f, 0.f, 0.f)); | 196 array_geometry.push_back(Point(0.f, 0.f, 0.f)); |
197 array_geometry.push_back(Point(0.2f, 0.f, 0.f)); | 197 array_geometry.push_back(Point(0.2f, 0.f, 0.f)); |
198 array_geometry.push_back(Point(0.1f, 0.f, 0.2f)); | 198 array_geometry.push_back(Point(0.1f, 0.f, 0.2f)); |
199 array_geometry.push_back(Point(0.f, 0.f, -0.1f)); | 199 array_geometry.push_back(Point(0.f, 0.f, -0.1f)); |
200 NonlinearBeamformer bf(array_geometry, 1u); | 200 NonlinearBeamformer bf(array_geometry); |
201 bf.Initialize(kChunkSizeMs, kSampleRateHz); | 201 bf.Initialize(kChunkSizeMs, kSampleRateHz); |
202 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 202 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
203 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, | 203 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, |
204 bf.interf_angles_radians_[0]); | 204 bf.interf_angles_radians_[0]); |
205 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, | 205 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, |
206 bf.interf_angles_radians_[1]); | 206 bf.interf_angles_radians_[1]); |
207 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); | 207 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); |
208 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 208 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
209 EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f, | 209 EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f, |
210 bf.interf_angles_radians_[0]); | 210 bf.interf_angles_radians_[0]); |
211 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); | 211 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); |
212 } | 212 } |
213 { | 213 { |
214 // For planar arrays with normal not in the xy-plane there is no ambiguity. | 214 // For planar arrays with normal not in the xy-plane there is no ambiguity. |
215 std::vector<Point> array_geometry; | 215 std::vector<Point> array_geometry; |
216 array_geometry.push_back(Point(0.f, 0.f, 0.f)); | 216 array_geometry.push_back(Point(0.f, 0.f, 0.f)); |
217 array_geometry.push_back(Point(0.2f, 0.f, 0.f)); | 217 array_geometry.push_back(Point(0.2f, 0.f, 0.f)); |
218 array_geometry.push_back(Point(0.f, 0.1f, -0.2f)); | 218 array_geometry.push_back(Point(0.f, 0.1f, -0.2f)); |
219 NonlinearBeamformer bf(array_geometry, 1u); | 219 NonlinearBeamformer bf(array_geometry); |
220 bf.Initialize(kChunkSizeMs, kSampleRateHz); | 220 bf.Initialize(kChunkSizeMs, kSampleRateHz); |
221 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 221 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
222 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, | 222 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, |
223 bf.interf_angles_radians_[0]); | 223 bf.interf_angles_radians_[0]); |
224 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, | 224 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, |
225 bf.interf_angles_radians_[1]); | 225 bf.interf_angles_radians_[1]); |
226 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); | 226 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); |
227 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 227 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
228 EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]); | 228 EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]); |
229 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); | 229 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); |
230 } | 230 } |
231 { | 231 { |
232 // For arrays which are not linear or planar there is no ambiguity. | 232 // For arrays which are not linear or planar there is no ambiguity. |
233 std::vector<Point> array_geometry; | 233 std::vector<Point> array_geometry; |
234 array_geometry.push_back(Point(0.f, 0.f, 0.f)); | 234 array_geometry.push_back(Point(0.f, 0.f, 0.f)); |
235 array_geometry.push_back(Point(0.1f, 0.f, 0.f)); | 235 array_geometry.push_back(Point(0.1f, 0.f, 0.f)); |
236 array_geometry.push_back(Point(0.f, 0.2f, 0.f)); | 236 array_geometry.push_back(Point(0.f, 0.2f, 0.f)); |
237 array_geometry.push_back(Point(0.f, 0.f, 0.3f)); | 237 array_geometry.push_back(Point(0.f, 0.f, 0.3f)); |
238 NonlinearBeamformer bf(array_geometry, 1u); | 238 NonlinearBeamformer bf(array_geometry); |
239 bf.Initialize(kChunkSizeMs, kSampleRateHz); | 239 bf.Initialize(kChunkSizeMs, kSampleRateHz); |
240 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 240 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
241 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, | 241 EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_, |
242 bf.interf_angles_radians_[0]); | 242 bf.interf_angles_radians_[0]); |
243 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, | 243 EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_, |
244 bf.interf_angles_radians_[1]); | 244 bf.interf_angles_radians_[1]); |
245 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); | 245 bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f)); |
246 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); | 246 EXPECT_EQ(2u, bf.interf_angles_radians_.size()); |
247 EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]); | 247 EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]); |
248 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); | 248 EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]); |
249 } | 249 } |
250 } | 250 } |
251 | 251 |
252 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in | 252 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in |
253 // this setup. | 253 // this setup. |
254 TEST(BeamformerBitExactnessTest, | 254 TEST(BeamformerBitExactnessTest, |
255 DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection1) { | 255 DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection1) { |
256 const float kOutputReference[] = {0.001318f, -0.001091f, 0.000990f, | 256 const float kOutputReference[] = {0.001318f, -0.001091f, 0.000990f, |
257 0.001318f, -0.001091f, 0.000990f}; | 257 0.001318f, -0.001091f, 0.000990f}; |
258 | 258 |
259 RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1), | 259 RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1), |
260 TargetDirection1, kOutputReference); | 260 TargetDirection1, kOutputReference); |
261 } | 261 } |
262 | 262 |
263 TEST(BeamformerBitExactnessTest, | 263 TEST(BeamformerBitExactnessTest, |
264 Stereo16kHz_ArrayGeometry1_TargetDirection1) { | 264 Stereo16kHz_ArrayGeometry1_TargetDirection1) { |
265 const float kOutputReference[] = {-0.000077f, -0.000147f, -0.000138f, | 265 const float kOutputReference[] = {0.000064f, 0.000211f, 0.000075f, |
266 -0.000077f, -0.000147f, -0.000138f}; | 266 0.000064f, 0.000211f, 0.000075f}; |
267 | 267 |
268 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1), | 268 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1), |
269 TargetDirection1, kOutputReference); | 269 TargetDirection1, kOutputReference); |
270 } | 270 } |
271 | 271 |
272 TEST(BeamformerBitExactnessTest, | 272 TEST(BeamformerBitExactnessTest, |
273 Stereo32kHz_ArrayGeometry1_TargetDirection1) { | 273 Stereo32kHz_ArrayGeometry1_TargetDirection1) { |
274 const float kOutputReference[] = {-0.000061f, -0.000061f, -0.000061f, | 274 const float kOutputReference[] = {0.000183f, 0.000183f, 0.000183f, |
275 -0.000061f, -0.000061f, -0.000061f}; | 275 0.000183f, 0.000183f, 0.000183f}; |
276 | 276 |
277 RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1), | 277 RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1), |
278 TargetDirection1, kOutputReference); | 278 TargetDirection1, kOutputReference); |
279 } | 279 } |
280 | 280 |
281 TEST(BeamformerBitExactnessTest, | 281 TEST(BeamformerBitExactnessTest, |
282 Stereo48kHz_ArrayGeometry1_TargetDirection1) { | 282 Stereo48kHz_ArrayGeometry1_TargetDirection1) { |
283 const float kOutputReference[] = {0.000450f, 0.000436f, 0.000433f, | 283 const float kOutputReference[] = {0.000155f, 0.000152f, 0.000159f, |
284 0.000450f, 0.000436f, 0.000433f}; | 284 0.000155f, 0.000152f, 0.000159f}; |
285 | 285 |
286 RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1), | 286 RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1), |
287 TargetDirection1, kOutputReference); | 287 TargetDirection1, kOutputReference); |
288 } | 288 } |
289 | 289 |
290 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in | 290 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in |
291 // this setup. | 291 // this setup. |
292 TEST(BeamformerBitExactnessTest, | 292 TEST(BeamformerBitExactnessTest, |
293 DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection2) { | 293 DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection2) { |
294 const float kOutputReference[] = {0.001144f, -0.001026f, 0.001074f, | 294 const float kOutputReference[] = {0.001144f, -0.001026f, 0.001074f, |
295 -0.016205f, -0.007324f, -0.015656f}; | 295 -0.016205f, -0.007324f, -0.015656f}; |
296 | 296 |
297 RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1), | 297 RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1), |
298 TargetDirection2, kOutputReference); | 298 TargetDirection2, kOutputReference); |
299 } | 299 } |
300 | 300 |
301 TEST(BeamformerBitExactnessTest, | 301 TEST(BeamformerBitExactnessTest, |
302 Stereo16kHz_ArrayGeometry1_TargetDirection2) { | 302 Stereo16kHz_ArrayGeometry1_TargetDirection2) { |
303 const float kOutputReference[] = {0.000221f, -0.000249f, 0.000140f, | 303 const float kOutputReference[] = {0.001144f, -0.001026f, 0.001074f, |
304 0.000221f, -0.000249f, 0.000140f}; | 304 0.001144f, -0.001026f, 0.001074f}; |
305 | 305 |
306 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1), | 306 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1), |
307 TargetDirection2, kOutputReference); | 307 TargetDirection2, kOutputReference); |
308 } | 308 } |
309 | 309 |
310 TEST(BeamformerBitExactnessTest, | 310 TEST(BeamformerBitExactnessTest, |
311 Stereo32kHz_ArrayGeometry1_TargetDirection2) { | 311 Stereo32kHz_ArrayGeometry1_TargetDirection2) { |
312 const float kOutputReference[] = {0.000763f, -0.000336f, 0.000549f, | 312 const float kOutputReference[] = {0.000732f, -0.000397f, 0.000610f, |
313 0.000763f, -0.000336f, 0.000549f}; | 313 0.000732f, -0.000397f, 0.000610f}; |
314 | 314 |
315 RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1), | 315 RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1), |
316 TargetDirection2, kOutputReference); | 316 TargetDirection2, kOutputReference); |
317 } | 317 } |
318 | 318 |
319 TEST(BeamformerBitExactnessTest, | 319 TEST(BeamformerBitExactnessTest, |
320 Stereo48kHz_ArrayGeometry1_TargetDirection2) { | 320 Stereo48kHz_ArrayGeometry1_TargetDirection2) { |
321 const float kOutputReference[] = {-0.000004f, -0.000494f, 0.000255f, | 321 const float kOutputReference[] = {0.000106f, -0.000464f, 0.000188f, |
322 -0.000004f, -0.000494f, 0.000255f}; | 322 0.000106f, -0.000464f, 0.000188f}; |
323 | 323 |
324 RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1), | 324 RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1), |
325 TargetDirection2, kOutputReference); | 325 TargetDirection2, kOutputReference); |
326 } | 326 } |
327 | 327 |
328 TEST(BeamformerBitExactnessTest, | 328 TEST(BeamformerBitExactnessTest, |
329 Stereo8kHz_ArrayGeometry2_TargetDirection2) { | 329 Stereo8kHz_ArrayGeometry2_TargetDirection2) { |
330 const float kOutputReference[] = {-0.000914f, 0.002170f, -0.002382f, | 330 const float kOutputReference[] = {-0.000649f, 0.000576f, -0.000148f, |
331 -0.000914f, 0.002170f, -0.002382f}; | 331 -0.000649f, 0.000576f, -0.000148f}; |
332 | 332 |
333 RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(2), | 333 RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(2), |
334 TargetDirection2, kOutputReference); | 334 TargetDirection2, kOutputReference); |
335 } | 335 } |
336 | 336 |
337 TEST(BeamformerBitExactnessTest, | 337 TEST(BeamformerBitExactnessTest, |
338 Stereo16kHz_ArrayGeometry2_TargetDirection2) { | 338 Stereo16kHz_ArrayGeometry2_TargetDirection2) { |
339 const float kOutputReference[] = {0.000179f, -0.000179f, 0.000081f, | 339 const float kOutputReference[] = {0.000808f, -0.000695f, 0.000739f, |
340 0.000179f, -0.000179f, 0.000081f}; | 340 0.000808f, -0.000695f, 0.000739f}; |
341 | 341 |
342 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(2), | 342 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(2), |
343 TargetDirection2, kOutputReference); | 343 TargetDirection2, kOutputReference); |
344 } | 344 } |
345 | 345 |
346 TEST(BeamformerBitExactnessTest, | 346 TEST(BeamformerBitExactnessTest, |
347 Stereo32kHz_ArrayGeometry2_TargetDirection2) { | 347 Stereo32kHz_ArrayGeometry2_TargetDirection2) { |
348 const float kOutputReference[] = {0.000549f, -0.000214f, 0.000366f, | 348 const float kOutputReference[] = {0.000580f, -0.000183f, 0.000458f, |
349 0.000549f, -0.000214f, 0.000366f}; | 349 0.000580f, -0.000183f, 0.000458f}; |
350 | 350 |
351 RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(2), | 351 RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(2), |
352 TargetDirection2, kOutputReference); | 352 TargetDirection2, kOutputReference); |
353 } | 353 } |
354 | 354 |
355 TEST(BeamformerBitExactnessTest, | 355 TEST(BeamformerBitExactnessTest, |
356 Stereo48kHz_ArrayGeometry2_TargetDirection2) { | 356 Stereo48kHz_ArrayGeometry2_TargetDirection2) { |
357 const float kOutputReference[] = {0.000019f, -0.000310f, 0.000182f, | 357 const float kOutputReference[] = {0.000075f, -0.000288f, 0.000156f, |
358 0.000019f, -0.000310f, 0.000182f}; | 358 0.000075f, -0.000288f, 0.000156f}; |
359 | 359 |
360 RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(2), | 360 RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(2), |
361 TargetDirection2, kOutputReference); | 361 TargetDirection2, kOutputReference); |
362 } | 362 } |
363 | 363 |
364 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in | 364 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in |
365 // this setup. | 365 // this setup. |
366 TEST(BeamformerBitExactnessTest, | 366 TEST(BeamformerBitExactnessTest, |
367 DISABLED_Stereo16kHz_ArrayGeometry3_TargetDirection1) { | 367 DISABLED_Stereo16kHz_ArrayGeometry3_TargetDirection1) { |
368 const float kOutputReference[] = {-0.000161f, 0.000171f, -0.000096f, | 368 const float kOutputReference[] = {-0.000161f, 0.000171f, -0.000096f, |
369 0.001007f, 0.000427f, 0.000977f}; | 369 0.001007f, 0.000427f, 0.000977f}; |
370 | 370 |
371 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(3), | 371 RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(3), |
372 TargetDirection1, kOutputReference); | 372 TargetDirection1, kOutputReference); |
373 } | 373 } |
374 | 374 |
375 } // namespace webrtc | 375 } // namespace webrtc |
OLD | NEW |